lynkr 0.1.0

package/src/db/index.js

@@ -0,0 +1,192 @@
+const fs = require("fs");
+const path = require("path");
+const Database = require("better-sqlite3");
+const config = require("../config");
+const logger = require("../logger");
+
+const dbPath = config.sessionStore.dbPath;
+const directory = path.dirname(dbPath);
+
+if (!fs.existsSync(directory)) {
+  fs.mkdirSync(directory, { recursive: true });
+}
+
+const db = new Database(dbPath);
+
+db.pragma("journal_mode = WAL");
+db.pragma("synchronous = NORMAL");
+db.pragma("foreign_keys = ON");
+
+db.exec(`
+  CREATE TABLE IF NOT EXISTS sessions (
+    id TEXT PRIMARY KEY,
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL,
+    metadata TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS session_history (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id TEXT NOT NULL,
+    role TEXT,
+    type TEXT,
+    status INTEGER,
+    content TEXT,
+    metadata TEXT,
+    timestamp INTEGER NOT NULL,
+    FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_session_history_session_id_timestamp
+    ON session_history(session_id, timestamp);
+
+  CREATE TABLE IF NOT EXISTS files (
+    path TEXT PRIMARY KEY,
+    size_bytes INTEGER NOT NULL,
+    mtime_ms INTEGER NOT NULL,
+    language TEXT,
+    summary TEXT
+  );
+
+  CREATE TABLE IF NOT EXISTS symbols (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    file_path TEXT NOT NULL,
+    name TEXT NOT NULL,
+    kind TEXT,
+    line INTEGER,
+    column INTEGER,
+    metadata TEXT,
+    FOREIGN KEY (file_path) REFERENCES files(path) ON DELETE CASCADE
+  );
+
+  CREATE TABLE IF NOT EXISTS framework_signals (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    type TEXT NOT NULL,
+    file_path TEXT,
+    detail TEXT,
+    metadata TEXT
+  );
+
+  CREATE TABLE IF NOT EXISTS workspace_metadata (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS edits (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id TEXT,
+    file_path TEXT NOT NULL,
+    created_at INTEGER NOT NULL,
+    source TEXT,
+    before_content TEXT,
+    after_content TEXT,
+    diff TEXT,
+    metadata TEXT
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_edits_file_path_created
+    ON edits(file_path, created_at DESC);
+
+  CREATE INDEX IF NOT EXISTS idx_edits_session_created
+    ON edits(session_id, created_at DESC);
+
+  CREATE TABLE IF NOT EXISTS symbol_references (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    symbol_id INTEGER NOT NULL,
+    file_path TEXT NOT NULL,
+    line INTEGER,
+    column INTEGER,
+    snippet TEXT,
+    metadata TEXT,
+    FOREIGN KEY (symbol_id) REFERENCES symbols(id) ON DELETE CASCADE
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_symbol_references_symbol
+    ON symbol_references(symbol_id);
+
+  CREATE INDEX IF NOT EXISTS idx_symbol_references_file
+    ON symbol_references(file_path, line);
+
+  CREATE TABLE IF NOT EXISTS file_dependencies (
+    from_path TEXT NOT NULL,
+    to_path TEXT NOT NULL,
+    kind TEXT,
+    metadata TEXT,
+    FOREIGN KEY (from_path) REFERENCES files(path) ON DELETE CASCADE
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_file_dependencies_from
+    ON file_dependencies(from_path);
+
+  CREATE INDEX IF NOT EXISTS idx_file_dependencies_to
+    ON file_dependencies(to_path);
+
+  CREATE TABLE IF NOT EXISTS tasks (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    title TEXT NOT NULL,
+    status TEXT NOT NULL,
+    priority INTEGER DEFAULT 0,
+    tags TEXT,
+    linked_file TEXT,
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL,
+    created_by TEXT,
+    updated_by TEXT,
+    metadata TEXT
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_tasks_status
+    ON tasks(status, priority DESC, updated_at DESC);
+
+  CREATE INDEX IF NOT EXISTS idx_tasks_linked_file
+    ON tasks(linked_file, status);
+
+  CREATE INDEX IF NOT EXISTS idx_tasks_updated_at
+    ON tasks(updated_at DESC);
+
+  CREATE TABLE IF NOT EXISTS diff_comments (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    thread_id TEXT,
+    session_id TEXT,
+    file_path TEXT NOT NULL,
+    hunk TEXT,
+    line INTEGER,
+    comment TEXT NOT NULL,
+    author TEXT,
+    created_at INTEGER NOT NULL,
+    metadata TEXT
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_diff_comments_thread
+    ON diff_comments(thread_id);
+
+  CREATE INDEX IF NOT EXISTS idx_diff_comments_file
+    ON diff_comments(file_path, line);
+
+  CREATE TABLE IF NOT EXISTS test_runs (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    profile TEXT,
+    status TEXT,
+    command TEXT NOT NULL,
+    args TEXT,
+    cwd TEXT,
+    exit_code INTEGER,
+    timed_out INTEGER DEFAULT 0,
+    duration_ms INTEGER,
+    sandbox TEXT,
+    stdout TEXT,
+    stderr TEXT,
+    coverage TEXT,
+    created_at INTEGER NOT NULL
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_test_runs_created
+    ON test_runs(created_at DESC);
+
+  CREATE INDEX IF NOT EXISTS idx_test_runs_status
+    ON test_runs(status);
+`);
+
+logger.info({ dbPath }, "SQLite session store initialised");
+
+module.exports = db;

package/src/diff/comments.js

@@ -0,0 +1,153 @@
+const crypto = require("crypto");
+const db = require("../db");
+const logger = require("../logger");
+
+const insertCommentStmt = db.prepare(
+  `INSERT INTO diff_comments (
+     thread_id,
+     session_id,
+     file_path,
+     hunk,
+     line,
+     comment,
+     author,
+     created_at,
+     metadata
+   ) VALUES (
+     @thread_id,
+     @session_id,
+     @file_path,
+     @hunk,
+     @line,
+     @comment,
+     @author,
+     @created_at,
+     @metadata
+   )`,
+);
+
+const deleteCommentStmt = db.prepare("DELETE FROM diff_comments WHERE id = ?");
+
+function buildSelectCommentsQuery({ filePath, threadId }) {
+  let sql = `SELECT id,
+                    thread_id,
+                    session_id,
+                    file_path,
+                    hunk,
+                    line,
+                    comment,
+                    author,
+                    created_at,
+                    metadata
+             FROM diff_comments`;
+  const conditions = [];
+  const params = [];
+  if (filePath) {
+    conditions.push("file_path = ?");
+    params.push(filePath);
+  }
+  if (threadId) {
+    conditions.push("thread_id = ?");
+    params.push(threadId);
+  }
+  if (conditions.length) {
+    sql += ` WHERE ${conditions.join(" AND ")}`;
+  }
+  sql += " ORDER BY created_at ASC, id ASC";
+  return { sql, params };
+}
+
+function normaliseCommentRow(row) {
+  return {
+    id: row.id,
+    threadId: row.thread_id ?? null,
+    sessionId: row.session_id ?? null,
+    filePath: row.file_path,
+    hunk: row.hunk ?? null,
+    line: typeof row.line === "number" ? row.line : null,
+    comment: row.comment,
+    author: row.author ?? null,
+    createdAt: row.created_at,
+    metadata: row.metadata ? JSON.parse(row.metadata) : null,
+  };
+}
+
+function addDiffComment({
+  threadId,
+  sessionId,
+  filePath,
+  line,
+  hunk,
+  comment,
+  author,
+  metadata,
+}) {
+  if (typeof filePath !== "string" || filePath.trim().length === 0) {
+    throw new Error("Diff comment requires a file path.");
+  }
+  if (typeof comment !== "string" || comment.trim().length === 0) {
+    throw new Error("Diff comment requires non-empty comment text.");
+  }
+
+  const createdAt = Date.now();
+  const thread = threadId ?? crypto.randomUUID();
+
+  const params = {
+    thread_id: thread,
+    session_id: sessionId ?? null,
+    file_path: filePath,
+    hunk: hunk ?? null,
+    line: typeof line === "number" ? line : null,
+    comment,
+    author: author ?? null,
+    created_at: createdAt,
+    metadata: metadata ? JSON.stringify(metadata) : null,
+  };
+
+  const result = insertCommentStmt.run(params);
+
+  logger.debug(
+    {
+      id: result.lastInsertRowid,
+      thread,
+      filePath,
+      line,
+    },
+    "Recorded diff comment",
+  );
+
+  return normaliseCommentRow({
+    id: result.lastInsertRowid,
+    thread_id: thread,
+    session_id: sessionId ?? null,
+    file_path: filePath,
+    hunk: hunk ?? null,
+    line: typeof line === "number" ? line : null,
+    comment,
+    author: author ?? null,
+    created_at: createdAt,
+    metadata: metadata ? JSON.stringify(metadata) : null,
+  });
+}
+
+function listDiffComments({ filePath, threadId } = {}) {
+  const { sql, params } = buildSelectCommentsQuery({ filePath, threadId });
+  return db
+    .prepare(sql)
+    .all(...params)
+    .map(normaliseCommentRow);
+}
+
+function deleteDiffComment({ id }) {
+  if (!id) {
+    throw new Error("diff_comment_delete requires an id.");
+  }
+  const result = deleteCommentStmt.run(id);
+  return result.changes > 0;
+}
+
+module.exports = {
+  addDiffComment,
+  listDiffComments,
+  deleteDiffComment,
+};

package/src/edits/index.js

@@ -0,0 +1,171 @@
+const fs = require("fs/promises");
+const path = require("path");
+const { createTwoFilesPatch } = require("diff");
+const db = require("../db");
+const { resolveWorkspacePath } = require("../workspace");
+const logger = require("../logger");
+
+const insertEditStmt = db.prepare(
+  `INSERT INTO edits (
+    session_id,
+    file_path,
+    created_at,
+    source,
+    before_content,
+    after_content,
+    diff,
+    metadata
+  ) VALUES (
+    @session_id,
+    @file_path,
+    @created_at,
+    @source,
+    @before_content,
+    @after_content,
+    @diff,
+    @metadata
+  )`,
+);
+
+const selectEditByIdStmt = db.prepare(
+  `SELECT id, session_id, file_path, created_at, source,
+          before_content, after_content, diff, metadata
+   FROM edits WHERE id = ?`,
+);
+
+function buildHistoryQuery({ filePath, sessionId, limit }) {
+  let query = `SELECT id, session_id, file_path, created_at, source,
+                      before_content, after_content, diff, metadata
+               FROM edits`;
+  const conditions = [];
+  const params = [];
+  if (filePath) {
+    conditions.push("file_path = ?");
+    params.push(filePath);
+  }
+  if (sessionId) {
+    conditions.push("session_id = ?");
+    params.push(sessionId);
+  }
+  if (conditions.length) {
+    query += ` WHERE ${conditions.join(" AND ")}`;
+  }
+  query += " ORDER BY created_at DESC";
+  if (limit) {
+    query += ` LIMIT ${limit}`;
+  }
+  return { query, params };
+}
+
+function computeDiff(filePath, beforeContent, afterContent) {
+  const before = beforeContent ?? "";
+  const after = afterContent ?? "";
+  if (before === after) return null;
+  return createTwoFilesPatch(
+    path.join("before", filePath),
+    path.join("after", filePath),
+    before,
+    after,
+    undefined,
+    undefined,
+    { context: 3 },
+  );
+}
+
+function recordEdit({
+  sessionId,
+  filePath,
+  source = "tool",
+  beforeContent,
+  afterContent,
+  metadata,
+}) {
+  if ((beforeContent ?? "") === (afterContent ?? "")) {
+    return null;
+  }
+  const diff = computeDiff(filePath, beforeContent, afterContent);
+  const createdAt = Date.now();
+  insertEditStmt.run({
+    session_id: sessionId ?? null,
+    file_path: filePath,
+    created_at: createdAt,
+    source,
+    before_content: beforeContent ?? null,
+    after_content: afterContent ?? null,
+    diff,
+    metadata: metadata ? JSON.stringify(metadata) : null,
+  });
+  logger.info(
+    {
+      sessionId,
+      filePath,
+      source,
+    },
+    "Recorded workspace edit",
+  );
+  return {
+    sessionId,
+    filePath,
+    createdAt,
+    diff,
+  };
+}
+
+function getEditHistory({ filePath, sessionId, limit }) {
+  const { query, params } = buildHistoryQuery({
+    filePath,
+    sessionId,
+    limit,
+  });
+  const rows = db.prepare(query).all(...params);
+  return rows.map((row) => ({
+    id: row.id,
+    sessionId: row.session_id,
+    filePath: row.file_path,
+    createdAt: row.created_at,
+    source: row.source,
+    diff: row.diff,
+    metadata: row.metadata ? JSON.parse(row.metadata) : null,
+  }));
+}
+
+async function revertEdit({ editId, sessionId }) {
+  const row = selectEditByIdStmt.get(editId);
+  if (!row) {
+    throw new Error(`Edit ${editId} not found.`);
+  }
+
+  const absolute = resolveWorkspacePath(row.file_path);
+  if (row.before_content === null || row.before_content === undefined) {
+    // Original file did not exist; delete if present.
+    try {
+      await fs.unlink(absolute);
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        throw err;
+      }
+    }
+  } else {
+    await fs.writeFile(absolute, row.before_content, "utf8");
+  }
+
+  recordEdit({
+    sessionId,
+    filePath: row.file_path,
+    source: "revert_edit",
+    beforeContent: row.after_content,
+    afterContent: row.before_content,
+    metadata: { revertedEditId: row.id },
+  });
+
+  return {
+    revertedEditId: row.id,
+    filePath: row.file_path,
+  };
+}
+
+module.exports = {
+  recordEdit,
+  getEditHistory,
+  revertEdit,
+};