micode 0.6.0 → 0.7.1

package/src/tools/artifact-index/index.ts

@@ -0,0 +1,269 @@
+// src/tools/artifact-index/index.ts
+import { Database } from "bun:sqlite";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { mkdirSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+
+const DEFAULT_DB_DIR = join(homedir(), ".config", "opencode", "artifact-index");
+const DB_NAME = "context.db";
+
+export interface PlanRecord {
+  id: string;
+  title?: string;
+  filePath: string;
+  overview?: string;
+  approach?: string;
+}
+
+export interface LedgerRecord {
+  id: string;
+  sessionName?: string;
+  filePath: string;
+  goal?: string;
+  stateNow?: string;
+  keyDecisions?: string;
+  filesRead?: string;
+  filesModified?: string;
+}
+
+export interface SearchResult {
+  type: "plan" | "ledger";
+  id: string;
+  filePath: string;
+  title?: string;
+  summary?: string;
+  score: number;
+}
+
+export class ArtifactIndex {
+  private db: Database | null = null;
+  private dbPath: string;
+
+  constructor(dbDir: string = DEFAULT_DB_DIR) {
+    this.dbPath = join(dbDir, DB_NAME);
+  }
+
+  async initialize(): Promise<void> {
+    // Ensure directory exists
+    const dir = dirname(this.dbPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+
+    this.db = new Database(this.dbPath);
+
+    // Load and execute schema
+    const schemaPath = join(dirname(import.meta.path), "schema.sql");
+    let schema: string;
+
+    try {
+      schema = readFileSync(schemaPath, "utf-8");
+    } catch {
+      // Fallback: inline schema for when bundled
+      schema = this.getInlineSchema();
+    }
+
+    // Execute schema - use exec for multi-statement support
+    this.db.exec(schema);
+  }
+
+  private getInlineSchema(): string {
+    return `
+      CREATE TABLE IF NOT EXISTS plans (
+        id TEXT PRIMARY KEY,
+        title TEXT,
+        file_path TEXT UNIQUE NOT NULL,
+        overview TEXT,
+        approach TEXT,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        indexed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      );
+      CREATE TABLE IF NOT EXISTS ledgers (
+        id TEXT PRIMARY KEY,
+        session_name TEXT,
+        file_path TEXT UNIQUE NOT NULL,
+        goal TEXT,
+        state_now TEXT,
+        key_decisions TEXT,
+        files_read TEXT,
+        files_modified TEXT,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        indexed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      );
+      CREATE VIRTUAL TABLE IF NOT EXISTS plans_fts USING fts5(id, title, overview, approach);
+      CREATE VIRTUAL TABLE IF NOT EXISTS ledgers_fts USING fts5(id, session_name, goal, state_now, key_decisions);
+    `;
+  }
+
+  async indexPlan(record: PlanRecord): Promise<void> {
+    if (!this.db) throw new Error("Database not initialized");
+
+    // Check for existing record by file_path to clean up old FTS entry
+    const existing = this.db
+      .query<{ id: string }, [string]>(`SELECT id FROM plans WHERE file_path = ?`)
+      .get(record.filePath);
+    if (existing) {
+      this.db.run(`DELETE FROM plans_fts WHERE id = ?`, [existing.id]);
+    }
+
+    this.db.run(
+      `
+      INSERT INTO plans (id, title, file_path, overview, approach, indexed_at)
+      VALUES (?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+      ON CONFLICT(file_path) DO UPDATE SET
+        id = excluded.id,
+        title = excluded.title,
+        overview = excluded.overview,
+        approach = excluded.approach,
+        indexed_at = CURRENT_TIMESTAMP
+    `,
+      [record.id, record.title ?? null, record.filePath, record.overview ?? null, record.approach ?? null],
+    );
+
+    this.db.run(
+      `
+      INSERT INTO plans_fts (id, title, overview, approach)
+      VALUES (?, ?, ?, ?)
+    `,
+      [record.id, record.title ?? null, record.overview ?? null, record.approach ?? null],
+    );
+  }
+
+  async indexLedger(record: LedgerRecord): Promise<void> {
+    if (!this.db) throw new Error("Database not initialized");
+
+    // Check for existing record by file_path to clean up old FTS entry
+    const existing = this.db
+      .query<{ id: string }, [string]>(`SELECT id FROM ledgers WHERE file_path = ?`)
+      .get(record.filePath);
+    if (existing) {
+      this.db.run(`DELETE FROM ledgers_fts WHERE id = ?`, [existing.id]);
+    }
+
+    this.db.run(
+      `
+      INSERT INTO ledgers (id, session_name, file_path, goal, state_now, key_decisions, files_read, files_modified, indexed_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+      ON CONFLICT(file_path) DO UPDATE SET
+        id = excluded.id,
+        session_name = excluded.session_name,
+        goal = excluded.goal,
+        state_now = excluded.state_now,
+        key_decisions = excluded.key_decisions,
+        files_read = excluded.files_read,
+        files_modified = excluded.files_modified,
+        indexed_at = CURRENT_TIMESTAMP
+    `,
+      [
+        record.id,
+        record.sessionName ?? null,
+        record.filePath,
+        record.goal ?? null,
+        record.stateNow ?? null,
+        record.keyDecisions ?? null,
+        record.filesRead ?? null,
+        record.filesModified ?? null,
+      ],
+    );
+
+    this.db.run(
+      `
+      INSERT INTO ledgers_fts (id, session_name, goal, state_now, key_decisions)
+      VALUES (?, ?, ?, ?, ?)
+    `,
+      [
+        record.id,
+        record.sessionName ?? null,
+        record.goal ?? null,
+        record.stateNow ?? null,
+        record.keyDecisions ?? null,
+      ],
+    );
+  }
+
+  async search(query: string, limit: number = 10): Promise<SearchResult[]> {
+    if (!this.db) throw new Error("Database not initialized");
+
+    const results: SearchResult[] = [];
+    const escapedQuery = this.escapeFtsQuery(query);
+
+    // Search plans
+    const plans = this.db
+      .query<{ id: string; file_path: string; title: string; rank: number }, [string, number]>(`
+      SELECT p.id, p.file_path, p.title, rank
+      FROM plans_fts
+      JOIN plans p ON plans_fts.id = p.id
+      WHERE plans_fts MATCH ?
+      ORDER BY rank
+      LIMIT ?
+    `)
+      .all(escapedQuery, limit);
+
+    for (const row of plans) {
+      results.push({
+        type: "plan",
+        id: row.id,
+        filePath: row.file_path,
+        title: row.title,
+        score: -row.rank,
+      });
+    }
+
+    // Search ledgers
+    const ledgers = this.db
+      .query<{ id: string; file_path: string; session_name: string; goal: string; rank: number }, [string, number]>(`
+      SELECT l.id, l.file_path, l.session_name, l.goal, rank
+      FROM ledgers_fts
+      JOIN ledgers l ON ledgers_fts.id = l.id
+      WHERE ledgers_fts MATCH ?
+      ORDER BY rank
+      LIMIT ?
+    `)
+      .all(escapedQuery, limit);
+
+    for (const row of ledgers) {
+      results.push({
+        type: "ledger",
+        id: row.id,
+        filePath: row.file_path,
+        title: row.session_name,
+        summary: row.goal,
+        score: -row.rank,
+      });
+    }
+
+    // Sort all results by score descending
+    results.sort((a, b) => b.score - a.score);
+
+    return results.slice(0, limit);
+  }
+
+  private escapeFtsQuery(query: string): string {
+    // Escape special FTS5 characters and wrap terms in quotes
+    return query
+      .replace(/['"]/g, "")
+      .split(/\s+/)
+      .filter((term) => term.length > 0)
+      .map((term) => `"${term}"`)
+      .join(" OR ");
+  }
+
+  async close(): Promise<void> {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+}
+
+// Singleton instance for global use
+let globalIndex: ArtifactIndex | null = null;
+
+export async function getArtifactIndex(): Promise<ArtifactIndex> {
+  if (!globalIndex) {
+    globalIndex = new ArtifactIndex();
+    await globalIndex.initialize();
+  }
+  return globalIndex;
+}

package/src/tools/artifact-index/schema.sql

@@ -0,0 +1,44 @@
+-- src/tools/artifact-index/schema.sql
+-- Artifact Index Schema for SQLite + FTS5
+-- NOTE: FTS tables are standalone (not content-linked) and manually synced by code
+
+-- Plans table
+CREATE TABLE IF NOT EXISTS plans (
+    id TEXT PRIMARY KEY,
+    title TEXT,
+    file_path TEXT UNIQUE NOT NULL,
+    overview TEXT,
+    approach TEXT,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    indexed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Ledgers table - with file operation tracking
+CREATE TABLE IF NOT EXISTS ledgers (
+    id TEXT PRIMARY KEY,
+    session_name TEXT,
+    file_path TEXT UNIQUE NOT NULL,
+    goal TEXT,
+    state_now TEXT,
+    key_decisions TEXT,
+    files_read TEXT,
+    files_modified TEXT,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    indexed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- FTS5 virtual tables for full-text search (standalone, manually synced)
+CREATE VIRTUAL TABLE IF NOT EXISTS plans_fts USING fts5(
+    id,
+    title,
+    overview,
+    approach
+);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS ledgers_fts USING fts5(
+    id,
+    session_name,
+    goal,
+    state_now,
+    key_decisions
+);

package/src/tools/artifact-search.ts

@@ -0,0 +1,49 @@
+// src/tools/artifact-search.ts
+import { tool } from "@opencode-ai/plugin/tool";
+import { getArtifactIndex } from "./artifact-index";
+
+export const artifact_search = tool({
+  description: `Search past plans and ledgers for relevant precedent.
+Use this to find:
+- Similar problems you've solved before
+- Patterns and approaches that worked
+- Lessons learned from past sessions
+Returns ranked results with file paths for further reading.`,
+  args: {
+    query: tool.schema.string().describe("Search query - describe what you're looking for"),
+    limit: tool.schema.number().optional().describe("Max results to return (default: 10)"),
+    type: tool.schema.enum(["all", "plan", "ledger"]).optional().describe("Filter by artifact type (default: all)"),
+  },
+  execute: async (args) => {
+    try {
+      const index = await getArtifactIndex();
+      const results = await index.search(args.query, args.limit || 10);
+
+      // Filter by type if specified
+      const filtered = args.type && args.type !== "all" ? results.filter((r) => r.type === args.type) : results;
+
+      if (filtered.length === 0) {
+        return `No results found for "${args.query}". Try broader search terms.`;
+      }
+
+      let output = `## Search Results for "${args.query}"\n\n`;
+      output += `Found ${filtered.length} result(s):\n\n`;
+
+      for (const result of filtered) {
+        const typeLabel = result.type.charAt(0).toUpperCase() + result.type.slice(1);
+        output += `### ${typeLabel}: ${result.title || result.id}\n`;
+        output += `**File:** \`${result.filePath}\`\n`;
+        if (result.summary) {
+          output += `**Summary:** ${result.summary}\n`;
+        }
+        output += `**Relevance Score:** ${result.score.toFixed(2)}\n\n`;
+      }
+
+      output += `---\n*Use the Read tool to view full content of relevant files.*`;
+
+      return output;
+    } catch (e) {
+      return `Error searching artifacts: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  },
+});

package/src/tools/ast-grep/index.ts

@@ -0,0 +1,189 @@
+import { spawn, which } from "bun";
+import { tool } from "@opencode-ai/plugin/tool";
+
+/**
+ * Check if ast-grep CLI (sg) is available on the system.
+ * Returns installation instructions if not found.
+ */
+export async function checkAstGrepAvailable(): Promise<{ available: boolean; message?: string }> {
+  const sgPath = which("sg");
+  if (sgPath) {
+    return { available: true };
+  }
+  return {
+    available: false,
+    message:
+      "ast-grep CLI (sg) not found. AST-aware search/replace will not work.\n" +
+      "Install with one of:\n" +
+      "  npm install -g @ast-grep/cli\n" +
+      "  cargo install ast-grep --locked\n" +
+      "  brew install ast-grep",
+  };
+}
+
+const LANGUAGES = [
+  "c",
+  "cpp",
+  "csharp",
+  "css",
+  "dart",
+  "elixir",
+  "go",
+  "haskell",
+  "html",
+  "java",
+  "javascript",
+  "json",
+  "kotlin",
+  "lua",
+  "php",
+  "python",
+  "ruby",
+  "rust",
+  "scala",
+  "sql",
+  "swift",
+  "tsx",
+  "typescript",
+  "yaml",
+] as const;
+
+interface Match {
+  file: string;
+  range: { start: { line: number; column: number }; end: { line: number; column: number } };
+  text: string;
+  replacement?: string;
+}
+
+async function runSg(args: string[]): Promise<{ matches: Match[]; error?: string }> {
+  try {
+    const proc = spawn(["sg", ...args], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited,
+    ]);
+
+    if (exitCode !== 0 && !stdout.trim()) {
+      if (stderr.includes("No files found")) {
+        return { matches: [] };
+      }
+      return { matches: [], error: stderr.trim() || `Exit code ${exitCode}` };
+    }
+
+    if (!stdout.trim()) return { matches: [] };
+
+    try {
+      const matches = JSON.parse(stdout) as Match[];
+      return { matches };
+    } catch {
+      return { matches: [], error: "Failed to parse output" };
+    }
+  } catch (e) {
+    const err = e as Error;
+    if (err.message?.includes("ENOENT")) {
+      return {
+        matches: [],
+        error:
+          "ast-grep CLI not found. Install with:\n" +
+          "  npm install -g @ast-grep/cli\n" +
+          "  cargo install ast-grep --locked\n" +
+          "  brew install ast-grep",
+      };
+    }
+    return { matches: [], error: err.message };
+  }
+}
+
+function formatMatches(matches: Match[], isDryRun = false): string {
+  if (matches.length === 0) return "No matches found";
+
+  const MAX = 100;
+  const truncated = matches.length > MAX;
+  const shown = matches.slice(0, MAX);
+
+  const lines = shown.map((m) => {
+    const loc = `${m.file}:${m.range.start.line}:${m.range.start.column}`;
+    const text = m.text.length > 100 ? `${m.text.slice(0, 100)}...` : m.text;
+    if (isDryRun && m.replacement) {
+      return `${loc}\n  - ${text}\n  + ${m.replacement}`;
+    }
+    return `${loc}: ${text}`;
+  });
+
+  if (truncated) {
+    lines.unshift(`Found ${matches.length} matches (showing first ${MAX}):`);
+  }
+
+  return lines.join("\n");
+}
+
+export const ast_grep_search = tool({
+  description:
+    "Search code patterns using AST-aware matching. " +
+    "Use meta-variables: $VAR (single node), $$$ (multiple nodes). " +
+    "Patterns must be complete AST nodes. " +
+    "Examples: 'console.log($MSG)', 'def $FUNC($$$):', 'async function $NAME($$$)'",
+  args: {
+    pattern: tool.schema.string().describe("AST pattern with meta-variables"),
+    lang: tool.schema.enum(LANGUAGES).describe("Target language"),
+    paths: tool.schema.array(tool.schema.string()).optional().describe("Paths to search"),
+  },
+  execute: async (args) => {
+    const sgArgs = ["run", "-p", args.pattern, "--lang", args.lang, "--json=compact"];
+    if (args.paths?.length) {
+      sgArgs.push(...args.paths);
+    } else {
+      sgArgs.push(".");
+    }
+
+    const result = await runSg(sgArgs);
+    if (result.error) return `Error: ${result.error}`;
+    return formatMatches(result.matches);
+  },
+});
+
+export const ast_grep_replace = tool({
+  description:
+    "Replace code patterns with AST-aware rewriting. " +
+    "Dry-run by default. Use meta-variables in rewrite to preserve matched content. " +
+    "Example: pattern='console.log($MSG)' rewrite='logger.info($MSG)'",
+  args: {
+    pattern: tool.schema.string().describe("AST pattern to match"),
+    rewrite: tool.schema.string().describe("Replacement pattern"),
+    lang: tool.schema.enum(LANGUAGES).describe("Target language"),
+    paths: tool.schema.array(tool.schema.string()).optional().describe("Paths to search"),
+    apply: tool.schema.boolean().optional().describe("Apply changes (default: false, dry-run)"),
+  },
+  execute: async (args) => {
+    const sgArgs = ["run", "-p", args.pattern, "-r", args.rewrite, "--lang", args.lang, "--json=compact"];
+
+    if (args.apply) {
+      sgArgs.push("--update-all");
+    }
+
+    if (args.paths?.length) {
+      sgArgs.push(...args.paths);
+    } else {
+      sgArgs.push(".");
+    }
+
+    const result = await runSg(sgArgs);
+    if (result.error) return `Error: ${result.error}`;
+
+    const isDryRun = !args.apply;
+    const output = formatMatches(result.matches, isDryRun);
+
+    if (isDryRun && result.matches.length > 0) {
+      return `${output}\n\n(Dry run - use apply=true to apply changes)`;
+    }
+    if (args.apply && result.matches.length > 0) {
+      return `Applied ${result.matches.length} replacements:\n${output}`;
+    }
+    return output;
+  },
+});