lynkr 9.9.1 → 9.11.0

package/src/agents/store.js

@@ -1,259 +0,0 @@
-let Database;
-try {
-  Database = require("better-sqlite3");
-} catch {
-  Database = null;
-}
-const path = require("path");
-const fs = require("fs");
-const logger = require("../logger");
-
-class AgentStore {
-  constructor() {
-    if (!Database) {
-      this.db = null;
-      return;
-    }
-
-    try {
-      // Use same database location as main app
-      const dbDir = path.join(process.cwd(), "data");
-      if (!fs.existsSync(dbDir)) {
-        fs.mkdirSync(dbDir, { recursive: true });
-      }
-
-      const dbPath = path.join(dbDir, "lynkr.db");
-      this.db = new Database(dbPath, {
-        verbose: process.env.DEBUG_SQL ? console.log : null,
-        fileMustExist: false
-      });
-
-      this.initTables();
-      this.prepareStatements();
-    } catch (err) {
-      logger.warn({ err: err.message }, "AgentStore: better-sqlite3 not available");
-      this.db = null;
-    }
-  }
-
-  initTables() {
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS agent_executions (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        session_id TEXT,
-        agent_type TEXT NOT NULL,
-        prompt TEXT NOT NULL,
-        model TEXT NOT NULL,
-        status TEXT NOT NULL, -- 'pending', 'running', 'completed', 'failed'
-        result TEXT,
-        error TEXT,
-        steps INTEGER DEFAULT 0,
-        duration_ms INTEGER,
-        input_tokens INTEGER DEFAULT 0,
-        output_tokens INTEGER DEFAULT 0,
-        created_at INTEGER NOT NULL,
-        completed_at INTEGER
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_agent_executions_session_id
-        ON agent_executions(session_id);
-
-      CREATE INDEX IF NOT EXISTS idx_agent_executions_agent_type
-        ON agent_executions(agent_type);
-
-      CREATE INDEX IF NOT EXISTS idx_agent_executions_status
-        ON agent_executions(status);
-
-      CREATE INDEX IF NOT EXISTS idx_agent_executions_created_at
-        ON agent_executions(created_at DESC);
-    `);
-
-    logger.info("Agent store tables initialized");
-  }
-
-  prepareStatements() {
-    this.stmts = {
-      create: this.db.prepare(`
-        INSERT INTO agent_executions (
-          session_id, agent_type, prompt, model, status, created_at
-        ) VALUES (?, ?, ?, ?, ?, ?)
-      `),
-
-      updateStatus: this.db.prepare(`
-        UPDATE agent_executions
-        SET status = ?, completed_at = ?
-        WHERE id = ?
-      `),
-
-      complete: this.db.prepare(`
-        UPDATE agent_executions
-        SET status = 'completed',
-            result = ?,
-            steps = ?,
-            duration_ms = ?,
-            input_tokens = ?,
-            output_tokens = ?,
-            completed_at = ?
-        WHERE id = ?
-      `),
-
-      fail: this.db.prepare(`
-        UPDATE agent_executions
-        SET status = 'failed',
-            error = ?,
-            steps = ?,
-            duration_ms = ?,
-            completed_at = ?
-        WHERE id = ?
-      `),
-
-      get: this.db.prepare(`
-        SELECT * FROM agent_executions WHERE id = ?
-      `),
-
-      getBySession: this.db.prepare(`
-        SELECT * FROM agent_executions
-        WHERE session_id = ?
-        ORDER BY created_at DESC
-      `),
-
-      getRecent: this.db.prepare(`
-        SELECT * FROM agent_executions
-        ORDER BY created_at DESC
-        LIMIT ?
-      `),
-
-      stats: this.db.prepare(`
-        SELECT
-          agent_type,
-          COUNT(*) as total_executions,
-          SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) as completed,
-          SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) as failed,
-          AVG(CASE WHEN status = 'completed' THEN duration_ms ELSE NULL END) as avg_duration_ms,
-          SUM(input_tokens) as total_input_tokens,
-          SUM(output_tokens) as total_output_tokens
-        FROM agent_executions
-        GROUP BY agent_type
-      `)
-    };
-  }
-
-  /**
-   * Create new agent execution
-   */
-  createExecution({ sessionId, agentType, prompt, model }) {
-    const now = Date.now();
-    const result = this.stmts.create.run(
-      sessionId || null,
-      agentType,
-      prompt,
-      model,
-      'pending',
-      now
-    );
-
-    logger.info({
-      executionId: result.lastInsertRowid,
-      agentType,
-      sessionId
-    }, "Created agent execution");
-
-    return result.lastInsertRowid;
-  }
-
-  /**
-   * Update execution status
-   */
-  updateStatus(executionId, status) {
-    const now = Date.now();
-    this.stmts.updateStatus.run(status, now, executionId);
-  }
-
-  /**
-   * Mark execution as completed
-   */
-  completeExecution(executionId, result, stats = {}) {
-    const now = Date.now();
-    this.stmts.complete.run(
-      result,
-      stats.steps || 0,
-      stats.durationMs || 0,
-      stats.inputTokens || 0,
-      stats.outputTokens || 0,
-      now,
-      executionId
-    );
-
-    logger.info({
-      executionId,
-      steps: stats.steps,
-      durationMs: stats.durationMs
-    }, "Agent execution completed");
-  }
-
-  /**
-   * Mark execution as failed
-   */
-  failExecution(executionId, error, stats = {}) {
-    const now = Date.now();
-    this.stmts.fail.run(
-      error.message || String(error),
-      stats.steps || 0,
-      stats.durationMs || 0,
-      now,
-      executionId
-    );
-
-    logger.warn({
-      executionId,
-      error: error.message
-    }, "Agent execution failed");
-  }
-
-  /**
-   * Get execution by ID
-   */
-  getExecution(executionId) {
-    return this.stmts.get.get(executionId);
-  }
-
-  /**
-   * Get executions by session
-   */
-  getSessionExecutions(sessionId) {
-    return this.stmts.getBySession.all(sessionId);
-  }
-
-  /**
-   * Get recent executions
-   */
-  getRecentExecutions(limit = 100) {
-    return this.stmts.getRecent.all(limit);
-  }
-
-  /**
-   * Get aggregate statistics
-   */
-  getStats() {
-    return this.stmts.stats.all();
-  }
-
-  /**
-   * Close database connection
-   */
-  close() {
-    this.db.close();
-  }
-}
-
-// Singleton instance
-let instance = null;
-
-function getInstance() {
-  if (!instance) {
-    instance = new AgentStore();
-  }
-  return instance;
-}
-
-module.exports = getInstance();

package/src/edits/index.js

@@ -1,171 +0,0 @@
-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,
-};

package/src/indexer/babel-parser.js

@@ -1,213 +0,0 @@
-/**
- * Babel-based Parser (Pure JS Fallback)
- *
- * Used when tree-sitter is unavailable (e.g., Node 25 without prebuilt binaries).
- * Supports JavaScript, TypeScript, JSX, and TSX.
- *
- * @module indexer/babel-parser
- */
-
-const logger = require("../logger");
-
-let babelParser = null;
-let babelTraverse = null;
-
-function loadBabel() {
-  if (babelParser) return true;
-  try {
-    babelParser = require("@babel/parser");
-    babelTraverse = require("@babel/traverse").default;
-    return true;
-  } catch (err) {
-    logger.warn({ err: err.message }, "[BabelParser] Failed to load @babel/parser");
-    return false;
-  }
-}
-
-const LANGUAGE_TO_PLUGINS = {
-  javascript: ["jsx"],
-  "javascript-react": ["jsx"],
-  typescript: ["typescript", "jsx"],
-  "typescript-react": ["typescript", "jsx"],
-};
-
-/**
- * Parse JavaScript/TypeScript file using Babel
- */
-function parseFile(relativePath, content, language) {
-  if (!loadBabel()) return null;
-
-  const plugins = LANGUAGE_TO_PLUGINS[language];
-  if (!plugins) {
-    logger.debug({ language }, "[BabelParser] Unsupported language");
-    return null;
-  }
-
-  try {
-    const ast = babelParser.parse(content, {
-      sourceType: "unambiguous",
-      plugins: [...plugins, "decorators-legacy", "classProperties", "dynamicImport"],
-      errorRecovery: true,
-    });
-
-    const symbols = [];
-    const dependencies = [];
-    const imports = [];
-    const exports = [];
-    const references = [];
-
-    babelTraverse(ast, {
-      // Functions
-      FunctionDeclaration(path) {
-        if (path.node.id) {
-          symbols.push({
-            name: path.node.id.name,
-            kind: "function",
-            line: path.node.loc?.start.line || 1,
-            column: (path.node.loc?.start.column || 0) + 1,
-          });
-        }
-      },
-
-      // Arrow functions assigned to variables
-      VariableDeclarator(path) {
-        if (
-          path.node.init &&
-          (path.node.init.type === "ArrowFunctionExpression" ||
-            path.node.init.type === "FunctionExpression") &&
-          path.node.id?.type === "Identifier"
-        ) {
-          symbols.push({
-            name: path.node.id.name,
-            kind: "function",
-            line: path.node.loc?.start.line || 1,
-            column: (path.node.loc?.start.column || 0) + 1,
-          });
-        }
-      },
-
-      // Classes
-      ClassDeclaration(path) {
-        if (path.node.id) {
-          symbols.push({
-            name: path.node.id.name,
-            kind: "class",
-            line: path.node.loc?.start.line || 1,
-            column: (path.node.loc?.start.column || 0) + 1,
-          });
-        }
-      },
-
-      // Class methods
-      ClassMethod(path) {
-        if (path.node.key?.type === "Identifier") {
-          symbols.push({
-            name: path.node.key.name,
-            kind: "method",
-            line: path.node.loc?.start.line || 1,
-            column: (path.node.loc?.start.column || 0) + 1,
-          });
-        }
-      },
-
-      // Import statements
-      ImportDeclaration(path) {
-        const importPath = path.node.source.value;
-        dependencies.push({
-          kind: "import",
-          path: importPath,
-          metadata: { clause: content.slice(path.node.start, path.node.end) },
-        });
-        imports.push({
-          path: importPath,
-          clause: content.slice(path.node.start, path.node.end),
-          line: path.node.loc?.start.line || 1,
-          column: (path.node.loc?.start.column || 0) + 1,
-        });
-      },
-
-      // require() calls
-      CallExpression(path) {
-        if (
-          path.node.callee?.type === "Identifier" &&
-          path.node.callee.name === "require" &&
-          path.node.arguments[0]?.type === "StringLiteral"
-        ) {
-          const reqPath = path.node.arguments[0].value;
-          dependencies.push({
-            kind: "require",
-            path: reqPath,
-            metadata: { clause: content.slice(path.node.start, path.node.end) },
-          });
-          imports.push({
-            path: reqPath,
-            clause: content.slice(path.node.start, path.node.end),
-            line: path.node.loc?.start.line || 1,
-            column: (path.node.loc?.start.column || 0) + 1,
-          });
-        }
-      },
-
-      // Exports
-      ExportNamedDeclaration(path) {
-        exports.push({
-          clause: content.slice(path.node.start, path.node.end).substring(0, 200),
-          line: path.node.loc?.start.line || 1,
-          column: (path.node.loc?.start.column || 0) + 1,
-        });
-      },
-
-      ExportDefaultDeclaration(path) {
-        exports.push({
-          clause: content.slice(path.node.start, path.node.end).substring(0, 200),
-          line: path.node.loc?.start.line || 1,
-          column: (path.node.loc?.start.column || 0) + 1,
-        });
-      },
-
-      // Track identifiers for references (limited to avoid noise)
-      Identifier(path) {
-        // Only track identifiers in call expressions or member expressions
-        if (
-          path.parent?.type === "CallExpression" &&
-          path.parent.callee === path.node
-        ) {
-          references.push({
-            name: path.node.name,
-            line: path.node.loc?.start.line || 1,
-            column: (path.node.loc?.start.column || 0) + 1,
-            snippet: path.node.name,
-          });
-        }
-      },
-    });
-
-    const langType = language.includes("typescript") ? "typescript" : "javascript";
-
-    return {
-      symbols,
-      dependencies,
-      references,
-      imports,
-      exports,
-      language: langType,
-      definitions: symbols,
-      parser: "babel",
-    };
-  } catch (err) {
-    logger.warn({ err: err.message, file: relativePath }, "[BabelParser] Parse failed");
-    return null;
-  }
-}
-
-/**
- * Check if Babel parser is available
- */
-function isBabelAvailable() {
-  return loadBabel();
-}
-
-module.exports = {
-  parseFile,
-  isBabelAvailable,
-};