// retoor <retoor@molodetz.nl>
#include "db.h"
#include "r_config.h"
#include <sqlite3.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
struct db_t {
sqlite3 *conn;
char *path;
};
static char *expand_home_directory(const char *path) {
if (!path) return NULL;
if (path[0] != '~') return strdup(path);
const char *home_dir = getenv("HOME");
if (!home_dir) home_dir = getenv("USERPROFILE");
if (!home_dir) return strdup(path);
size_t home_len = strlen(home_dir);
size_t path_len = strlen(path);
char *expanded = malloc(home_len + path_len + 1);
if (!expanded) return NULL;
memcpy(expanded, home_dir, home_len);
memcpy(expanded + home_len, path + 1, path_len);
return expanded;
}
db_handle db_open(const char *path) {
struct db_t *db = calloc(1, sizeof(struct db_t));
if (!db) return NULL;
if (!path) {
r_config_handle cfg = r_config_get_instance();
path = r_config_get_db_path(cfg);
}
db->path = expand_home_directory(path);
if (!db->path) {
free(db);
return NULL;
}
if (sqlite3_open(db->path, &db->conn) != SQLITE_OK) {
free(db->path);
free(db);
return NULL;
}
db_init(db);
return db;
}
void db_close(db_handle db) {
if (!db) return;
if (db->conn) sqlite3_close(db->conn);
free(db->path);
free(db);
}
r_status_t db_init(db_handle db) {
if (!db || !db->conn) return R_ERROR_INVALID_ARG;
const char *sql =
"CREATE TABLE IF NOT EXISTS kv ("
" key TEXT PRIMARY KEY,"
" value TEXT NOT NULL,"
" created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,"
" updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP"
");"
"CREATE TABLE IF NOT EXISTS file_versions ("
" id INTEGER PRIMARY KEY AUTOINCREMENT,"
" path TEXT NOT NULL,"
" content TEXT NOT NULL,"
" created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP"
");"
"CREATE TABLE IF NOT EXISTS conversations ("
" session_key TEXT PRIMARY KEY,"
" data TEXT NOT NULL,"
" updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP"
");"
"CREATE TABLE IF NOT EXISTS blackboard ("
" id INTEGER PRIMARY KEY AUTOINCREMENT,"
" sender TEXT NOT NULL,"
" recipient TEXT,"
" topic TEXT NOT NULL,"
" message TEXT NOT NULL,"
" status TEXT DEFAULT 'pending',"
" created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,"
" updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP"
");"
"CREATE TABLE IF NOT EXISTS gtr ("
" task_hash TEXT PRIMARY KEY,"
" task_description TEXT NOT NULL,"
" status TEXT NOT NULL,"
" owner_agent TEXT NOT NULL,"
" result_summary TEXT,"
" created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,"
" updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP"
");"
"CREATE TABLE IF NOT EXISTS audit_log ("
" id INTEGER PRIMARY KEY AUTOINCREMENT,"
" timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,"
" issuer_agent TEXT NOT NULL,"
" recipient_agent TEXT NOT NULL,"
" order_description TEXT NOT NULL,"
" logic_justification TEXT NOT NULL,"
" status TEXT NOT NULL"
");"
"CREATE TABLE IF NOT EXISTS agents ("
" agent_id TEXT PRIMARY KEY,"
" role TEXT NOT NULL,"
" manager_id TEXT,"
" department TEXT,"
" budget_limit_tokens INTEGER DEFAULT 1000000,"
" used_tokens INTEGER DEFAULT 0,"
" last_heartbeat TIMESTAMP DEFAULT CURRENT_TIMESTAMP,"
" status TEXT DEFAULT 'active'"
");"
"CREATE TABLE IF NOT EXISTS research_tasks ("
" id INTEGER PRIMARY KEY AUTOINCREMENT,"
" url_hash TEXT UNIQUE,"
" url TEXT NOT NULL,"
" status TEXT NOT NULL,"
" summary TEXT,"
" batch_id TEXT,"
" created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,"
" updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP"
");"
"CREATE TABLE IF NOT EXISTS snapshots ("
" id INTEGER PRIMARY KEY AUTOINCREMENT,"
" session_id TEXT NOT NULL,"
" description TEXT,"
" created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP"
");"
"CREATE TABLE IF NOT EXISTS snapshot_files ("
" id INTEGER PRIMARY KEY AUTOINCREMENT,"
" snapshot_id INTEGER NOT NULL,"
" path TEXT NOT NULL,"
" content TEXT NOT NULL,"
" FOREIGN KEY (snapshot_id) REFERENCES snapshots(id) ON DELETE CASCADE"
");"
"CREATE UNIQUE INDEX IF NOT EXISTS idx_snapshot_files_unique "
"ON snapshot_files(snapshot_id, path);";
char *err_msg = NULL;
if (sqlite3_exec(db->conn, sql, NULL, NULL, &err_msg) != SQLITE_OK) {
sqlite3_free(err_msg);
return R_ERROR_DB_QUERY;
}
return R_SUCCESS;
}
r_status_t db_kv_set(db_handle db, const char *key, const char *value) {
if (!db || !db->conn || !key || !value) return R_ERROR_INVALID_ARG;
char *sql = sqlite3_mprintf(
"INSERT OR REPLACE INTO kv (key, value, updated_at) VALUES (%Q, %Q, CURRENT_TIMESTAMP)",
key, value);
if (!sql) return R_ERROR_OUT_OF_MEMORY;
char *err_msg = NULL;
int rc = sqlite3_exec(db->conn, sql, NULL, NULL, &err_msg);
sqlite3_free(sql);
if (rc != SQLITE_OK) {
sqlite3_free(err_msg);
return R_ERROR_DB_QUERY;
}
return R_SUCCESS;
}
r_status_t db_kv_get(db_handle db, const char *key, char **value) {
if (!db || !db->conn || !key || !value) return R_ERROR_INVALID_ARG;
*value = NULL;
const char *sql = "SELECT value FROM kv WHERE key = ?";
sqlite3_stmt *stmt = NULL;
if (sqlite3_prepare_v2(db->conn, sql, -1, &stmt, NULL) != SQLITE_OK) {
return R_ERROR_DB_QUERY;
}
sqlite3_bind_text(stmt, 1, key, -1, SQLITE_STATIC);
int rc = sqlite3_step(stmt);
if (rc == SQLITE_ROW) {
const char *val = (const char *)sqlite3_column_text(stmt, 0);
*value = val ? strdup(val) : NULL;
}
sqlite3_finalize(stmt);
return (rc == SQLITE_ROW) ? R_SUCCESS : R_ERROR_DB_NOT_FOUND;
}
r_status_t db_execute(db_handle db, const char *sql, struct json_object **result) {
if (!db || !db->conn || !sql || !result) return R_ERROR_INVALID_ARG;
*result = NULL;
const char *select_check = sql;
while (*select_check == ' ') select_check++;
if (strncasecmp(select_check, "SELECT", 6) != 0) {
char *err_msg = NULL;
int rc = sqlite3_exec(db->conn, sql, NULL, NULL, &err_msg);
if (rc != SQLITE_OK) {
struct json_object *error_obj = json_object_new_object();
json_object_object_add(error_obj, "error",
json_object_new_string(err_msg ? err_msg : "Query failed"));
sqlite3_free(err_msg);
*result = error_obj;
return R_ERROR_DB_QUERY;
}
struct json_object *success_obj = json_object_new_object();
json_object_object_add(success_obj, "success", json_object_new_boolean(1));
*result = success_obj;
return R_SUCCESS;
}
sqlite3_stmt *stmt = NULL;
if (sqlite3_prepare_v2(db->conn, sql, -1, &stmt, NULL) != SQLITE_OK) {
struct json_object *error_obj = json_object_new_object();
json_object_object_add(error_obj, "error",
json_object_new_string(sqlite3_errmsg(db->conn)));
*result = error_obj;
return R_ERROR_DB_QUERY;
}
struct json_object *array = json_object_new_array();
int col_count = sqlite3_column_count(stmt);
while (sqlite3_step(stmt) == SQLITE_ROW) {
struct json_object *row = json_object_new_object();
for (int i = 0; i < col_count; i++) {
const char *col_name = sqlite3_column_name(stmt, i);
int col_type = sqlite3_column_type(stmt, i);
switch (col_type) {
case SQLITE_INTEGER:
json_object_object_add(row, col_name,
json_object_new_int64(sqlite3_column_int64(stmt, i)));
break;
case SQLITE_FLOAT:
json_object_object_add(row, col_name,
json_object_new_double(sqlite3_column_double(stmt, i)));
break;
case SQLITE_TEXT:
json_object_object_add(row, col_name,
json_object_new_string((const char *)sqlite3_column_text(stmt, i)));
break;
case SQLITE_NULL:
json_object_object_add(row, col_name, NULL);
break;
default:
json_object_object_add(row, col_name,
json_object_new_string((const char *)sqlite3_column_text(stmt, i)));
break;
}
}
json_object_array_add(array, row);
}
sqlite3_finalize(stmt);
*result = array;
return R_SUCCESS;
}
char *db_get_schema(db_handle db) {
if (!db || !db->conn) return strdup("Database not available");
struct json_object *result = NULL;
r_status_t status = db_execute(db,
"SELECT name, sql FROM sqlite_master WHERE type='table' ORDER BY name",
&result);
if (status != R_SUCCESS || !result) {
return strdup("Failed to get schema");
}
char *schema = strdup(json_object_to_json_string_ext(result, JSON_C_TO_STRING_PRETTY));
json_object_put(result);
return schema;
}
r_status_t db_store_file_version(db_handle db, const char *path) {
if (!db || !db->conn || !path) return R_ERROR_INVALID_ARG;
FILE *fp = fopen(path, "r");
if (!fp) return R_ERROR_FILE_NOT_FOUND;
fseek(fp, 0, SEEK_END);
long size = ftell(fp);
rewind(fp);
if (size <= 0 || size > 1000000) {
fclose(fp);
return R_SUCCESS;
}
char *content = malloc(size + 1);
if (!content) {
fclose(fp);
return R_ERROR_OUT_OF_MEMORY;
}
size_t read_size = fread(content, 1, size, fp);
content[read_size] = '\0';
fclose(fp);
char *sql = sqlite3_mprintf(
"INSERT INTO file_versions (path, content) VALUES (%Q, %Q)",
path, content);
free(content);
if (!sql) return R_ERROR_OUT_OF_MEMORY;
char *err_msg = NULL;
int rc = sqlite3_exec(db->conn, sql, NULL, NULL, &err_msg);
sqlite3_free(sql);
sqlite3_free(err_msg);
return (rc == SQLITE_OK) ? R_SUCCESS : R_ERROR_DB_QUERY;
}
r_status_t db_save_conversation(db_handle db, const char *session_key, const char *data) {
if (!db || !db->conn || !session_key || !data) return R_ERROR_INVALID_ARG;
char *sql = sqlite3_mprintf(
"INSERT OR REPLACE INTO conversations (session_key, data, updated_at) "
"VALUES (%Q, %Q, CURRENT_TIMESTAMP)",
session_key, data);
if (!sql) return R_ERROR_OUT_OF_MEMORY;
char *err_msg = NULL;
int rc = sqlite3_exec(db->conn, sql, NULL, NULL, &err_msg);
sqlite3_free(sql);
sqlite3_free(err_msg);
return (rc == SQLITE_OK) ? R_SUCCESS : R_ERROR_DB_QUERY;
}
long long db_get_conversation_age(db_handle db, const char *session_key) {
if (!db || !db->conn || !session_key) return -1;
const char *sql = "SELECT CAST((julianday('now') - julianday(updated_at)) * 86400 AS INTEGER) FROM conversations WHERE session_key = ?";
sqlite3_stmt *stmt = NULL;
if (sqlite3_prepare_v2(db->conn, sql, -1, &stmt, NULL) != SQLITE_OK) {
return -1;
}
sqlite3_bind_text(stmt, 1, session_key, -1, SQLITE_STATIC);
long long age = -1;
if (sqlite3_step(stmt) == SQLITE_ROW) {
age = sqlite3_column_int64(stmt, 0);
}
sqlite3_finalize(stmt);
return age;
}
r_status_t db_delete_conversation(db_handle db, const char *session_key) {
if (!db || !db->conn || !session_key) return R_ERROR_INVALID_ARG;
char *sql = sqlite3_mprintf("DELETE FROM conversations WHERE session_key = %Q", session_key);
if (!sql) return R_ERROR_OUT_OF_MEMORY;
char *err_msg = NULL;
int rc = sqlite3_exec(db->conn, sql, NULL, NULL, &err_msg);
sqlite3_free(sql);
sqlite3_free(err_msg);
return (rc == SQLITE_OK) ? R_SUCCESS : R_ERROR_DB_QUERY;
}
r_status_t db_load_conversation(db_handle db, const char *session_key, char **data) {
if (!db || !db->conn || !session_key || !data) return R_ERROR_INVALID_ARG;
*data = NULL;
const char *sql = "SELECT data FROM conversations WHERE session_key = ?";
sqlite3_stmt *stmt = NULL;
if (sqlite3_prepare_v2(db->conn, sql, -1, &stmt, NULL) != SQLITE_OK) {
return R_ERROR_DB_QUERY;
}
sqlite3_bind_text(stmt, 1, session_key, -1, SQLITE_STATIC);
int rc = sqlite3_step(stmt);
if (rc == SQLITE_ROW) {
const char *val = (const char *)sqlite3_column_text(stmt, 0);
*data = val ? strdup(val) : NULL;
}
sqlite3_finalize(stmt);
return (rc == SQLITE_ROW) ? R_SUCCESS : R_ERROR_DB_NOT_FOUND;
}
r_status_t db_snapshot_create(db_handle db, const char *session_id, const char *description,
const char **paths, const char **contents, int file_count,
long long *snapshot_id_out) {
if (!db || !db->conn || !session_id || !paths || !contents || file_count <= 0 || !snapshot_id_out)
return R_ERROR_INVALID_ARG;
char *err_msg = NULL;
if (sqlite3_exec(db->conn, "BEGIN TRANSACTION", NULL, NULL, &err_msg) != SQLITE_OK) {
sqlite3_free(err_msg);
return R_ERROR_DB_QUERY;
}
char *sql = sqlite3_mprintf(
"INSERT INTO snapshots (session_id, description) VALUES (%Q, %Q)",
session_id, description ? description : "");
if (!sql) {
sqlite3_exec(db->conn, "ROLLBACK", NULL, NULL, NULL);
return R_ERROR_OUT_OF_MEMORY;
}
int rc = sqlite3_exec(db->conn, sql, NULL, NULL, &err_msg);
sqlite3_free(sql);
if (rc != SQLITE_OK) {
sqlite3_free(err_msg);
sqlite3_exec(db->conn, "ROLLBACK", NULL, NULL, NULL);
return R_ERROR_DB_QUERY;
}
long long sid = sqlite3_last_insert_rowid(db->conn);
for (int i = 0; i < file_count; i++) {
sql = sqlite3_mprintf(
"INSERT INTO snapshot_files (snapshot_id, path, content) VALUES (%lld, %Q, %Q)",
sid, paths[i], contents[i]);
if (!sql) {
sqlite3_exec(db->conn, "ROLLBACK", NULL, NULL, NULL);
return R_ERROR_OUT_OF_MEMORY;
}
rc = sqlite3_exec(db->conn, sql, NULL, NULL, &err_msg);
sqlite3_free(sql);
if (rc != SQLITE_OK) {
sqlite3_free(err_msg);
sqlite3_exec(db->conn, "ROLLBACK", NULL, NULL, NULL);
return R_ERROR_DB_QUERY;
}
}
if (sqlite3_exec(db->conn, "COMMIT", NULL, NULL, &err_msg) != SQLITE_OK) {
sqlite3_free(err_msg);
sqlite3_exec(db->conn, "ROLLBACK", NULL, NULL, NULL);
return R_ERROR_DB_QUERY;
}
*snapshot_id_out = sid;
return R_SUCCESS;
}
r_status_t db_snapshot_list(db_handle db, const char *session_id, struct json_object **result) {
if (!db || !db->conn || !session_id || !result) return R_ERROR_INVALID_ARG;
char *sql = sqlite3_mprintf(
"SELECT s.id, s.session_id, s.description, s.created_at, "
"(SELECT COUNT(*) FROM snapshot_files sf WHERE sf.snapshot_id = s.id) AS file_count "
"FROM snapshots s WHERE s.session_id = %Q ORDER BY s.created_at DESC",
session_id);
if (!sql) return R_ERROR_OUT_OF_MEMORY;
r_status_t status = db_execute(db, sql, result);
sqlite3_free(sql);
return status;
}
r_status_t db_snapshot_get_files(db_handle db, long long snapshot_id, struct json_object **result) {
if (!db || !db->conn || !result) return R_ERROR_INVALID_ARG;
char *sql = sqlite3_mprintf(
"SELECT path, content FROM snapshot_files WHERE snapshot_id = %lld",
snapshot_id);
if (!sql) return R_ERROR_OUT_OF_MEMORY;
r_status_t status = db_execute(db, sql, result);
sqlite3_free(sql);
return status;
}
r_status_t db_snapshot_ensure_live(db_handle db, const char *session_id,
const char *description, long long *snapshot_id_out) {
if (!db || !db->conn || !session_id || !snapshot_id_out) return R_ERROR_INVALID_ARG;
const char *select_sql = "SELECT id FROM snapshots WHERE session_id = ? LIMIT 1";
sqlite3_stmt *stmt = NULL;
if (sqlite3_prepare_v2(db->conn, select_sql, -1, &stmt, NULL) != SQLITE_OK) {
return R_ERROR_DB_QUERY;
}
sqlite3_bind_text(stmt, 1, session_id, -1, SQLITE_STATIC);
int rc = sqlite3_step(stmt);
if (rc == SQLITE_ROW) {
*snapshot_id_out = sqlite3_column_int64(stmt, 0);
sqlite3_finalize(stmt);
char *update_sql = sqlite3_mprintf(
"UPDATE snapshots SET description = %Q WHERE id = %lld",
description ? description : "", *snapshot_id_out);
if (!update_sql) return R_ERROR_OUT_OF_MEMORY;
char *err_msg = NULL;
rc = sqlite3_exec(db->conn, update_sql, NULL, NULL, &err_msg);
sqlite3_free(update_sql);
sqlite3_free(err_msg);
return (rc == SQLITE_OK) ? R_SUCCESS : R_ERROR_DB_QUERY;
}
sqlite3_finalize(stmt);
char *insert_sql = sqlite3_mprintf(
"INSERT INTO snapshots (session_id, description) VALUES (%Q, %Q)",
session_id, description ? description : "");
if (!insert_sql) return R_ERROR_OUT_OF_MEMORY;
char *err_msg = NULL;
rc = sqlite3_exec(db->conn, insert_sql, NULL, NULL, &err_msg);
sqlite3_free(insert_sql);
if (rc != SQLITE_OK) {
sqlite3_free(err_msg);
return R_ERROR_DB_QUERY;
}
*snapshot_id_out = sqlite3_last_insert_rowid(db->conn);
return R_SUCCESS;
}
r_status_t db_snapshot_upsert_file(db_handle db, long long snapshot_id,
const char *path, const char *content) {
if (!db || !db->conn || !path || !content) return R_ERROR_INVALID_ARG;
char *sql = sqlite3_mprintf(
"INSERT OR REPLACE INTO snapshot_files (snapshot_id, path, content) "
"VALUES (%lld, %Q, %Q)",
snapshot_id, path, content);
if (!sql) return R_ERROR_OUT_OF_MEMORY;
char *err_msg = NULL;
int rc = sqlite3_exec(db->conn, sql, NULL, NULL, &err_msg);
sqlite3_free(sql);
sqlite3_free(err_msg);
return (rc == SQLITE_OK) ? R_SUCCESS : R_ERROR_DB_QUERY;
}
Reference in New Issue View Git Blame Copy Permalink