micode 0.7.0 → 0.7.1

package/src/index.ts

@@ -0,0 +1,258 @@
+import type { Plugin } from "@opencode-ai/plugin";
+import type { McpLocalConfig } from "@opencode-ai/sdk";
+
+// Agents
+import { agents, PRIMARY_AGENT_NAME } from "./agents";
+
+// Tools
+import { ast_grep_search, ast_grep_replace, checkAstGrepAvailable } from "./tools/ast-grep";
+import { btca_ask, checkBtcaAvailable } from "./tools/btca";
+import { look_at } from "./tools/look-at";
+import { artifact_search } from "./tools/artifact-search";
+
+// Hooks
+import { createAutoCompactHook } from "./hooks/auto-compact";
+import { createContextInjectorHook } from "./hooks/context-injector";
+import { createSessionRecoveryHook } from "./hooks/session-recovery";
+import { createTokenAwareTruncationHook } from "./hooks/token-aware-truncation";
+import { createContextWindowMonitorHook } from "./hooks/context-window-monitor";
+import { createCommentCheckerHook } from "./hooks/comment-checker";
+import { createAutoClearLedgerHook } from "./hooks/auto-clear-ledger";
+import { createLedgerLoaderHook } from "./hooks/ledger-loader";
+import { createArtifactAutoIndexHook } from "./hooks/artifact-auto-index";
+import { createFileOpsTrackerHook } from "./hooks/file-ops-tracker";
+
+// Background Task System
+import { BackgroundTaskManager, createBackgroundTaskTools } from "./tools/background-task";
+
+// PTY System
+import { PTYManager, createPtyTools } from "./tools/pty";
+
+// Config loader
+import { loadMicodeConfig, mergeAgentConfigs } from "./config-loader";
+
+// Think mode: detect keywords and enable extended thinking
+const THINK_KEYWORDS = [
+  /\bthink\s*(hard|deeply|carefully|through)\b/i,
+  /\bthink\b.*\b(about|on|through)\b/i,
+  /\b(deeply|carefully)\s*think\b/i,
+  /\blet('s|s)?\s*think\b/i,
+];
+
+function detectThinkKeyword(text: string): boolean {
+  return THINK_KEYWORDS.some((pattern) => pattern.test(text));
+}
+
+// MCP server configurations
+const MCP_SERVERS: Record<string, McpLocalConfig> = {
+  context7: {
+    type: "local",
+    command: ["npx", "-y", "@upstash/context7-mcp@latest"],
+  },
+};
+
+// Environment-gated research MCP servers
+if (process.env.PERPLEXITY_API_KEY) {
+  MCP_SERVERS.perplexity = {
+    type: "local",
+    command: ["npx", "-y", "@anthropic/mcp-perplexity"],
+  };
+}
+
+if (process.env.FIRECRAWL_API_KEY) {
+  MCP_SERVERS.firecrawl = {
+    type: "local",
+    command: ["npx", "-y", "firecrawl-mcp"],
+  };
+}
+
+const OpenCodeConfigPlugin: Plugin = async (ctx) => {
+  // Validate external tool dependencies at startup
+  const astGrepStatus = await checkAstGrepAvailable();
+  if (!astGrepStatus.available) {
+    console.warn(`[micode] ${astGrepStatus.message}`);
+  }
+
+  const btcaStatus = await checkBtcaAvailable();
+  if (!btcaStatus.available) {
+    console.warn(`[micode] ${btcaStatus.message}`);
+  }
+
+  // Load user config for model overrides
+  const userConfig = await loadMicodeConfig();
+  if (userConfig?.agents) {
+    console.log(`[micode] Loaded model overrides for: ${Object.keys(userConfig.agents).join(", ")}`);
+  }
+
+  // Think mode state per session
+  const thinkModeState = new Map<string, boolean>();
+
+  // Hooks
+  const autoCompactHook = createAutoCompactHook(ctx);
+  const contextInjectorHook = createContextInjectorHook(ctx);
+  const autoClearLedgerHook = createAutoClearLedgerHook(ctx);
+  const ledgerLoaderHook = createLedgerLoaderHook(ctx);
+  const sessionRecoveryHook = createSessionRecoveryHook(ctx);
+  const tokenAwareTruncationHook = createTokenAwareTruncationHook(ctx);
+  const contextWindowMonitorHook = createContextWindowMonitorHook(ctx);
+  const commentCheckerHook = createCommentCheckerHook(ctx);
+  const artifactAutoIndexHook = createArtifactAutoIndexHook(ctx);
+  const fileOpsTrackerHook = createFileOpsTrackerHook(ctx);
+
+  // Background Task System
+  const backgroundTaskManager = new BackgroundTaskManager(ctx);
+  const backgroundTaskTools = createBackgroundTaskTools(backgroundTaskManager);
+
+  // PTY System
+  const ptyManager = new PTYManager();
+  const ptyTools = createPtyTools(ptyManager);
+
+  return {
+    // Tools
+    tool: {
+      ast_grep_search,
+      ast_grep_replace,
+      btca_ask,
+      look_at,
+      artifact_search,
+      ...backgroundTaskTools,
+      ...ptyTools,
+    },
+
+    config: async (config) => {
+      // Allow all permissions globally - no prompts
+      config.permission = {
+        ...config.permission,
+        edit: "allow",
+        bash: "allow",
+        webfetch: "allow",
+        doom_loop: "allow",
+        external_directory: "allow",
+      };
+
+      // Merge user config overrides into plugin agents
+      const mergedAgents = mergeAgentConfigs(agents, userConfig);
+
+      // Add our agents - our agents override OpenCode defaults, demote built-in build/plan to subagent
+      config.agent = {
+        ...config.agent, // OpenCode defaults first
+        build: { ...config.agent?.build, mode: "subagent" },
+        plan: { ...config.agent?.plan, mode: "subagent" },
+        triage: { ...config.agent?.triage, mode: "subagent" },
+        docs: { ...config.agent?.docs, mode: "subagent" },
+        // Our agents override - spread these LAST so they take precedence
+        ...Object.fromEntries(Object.entries(mergedAgents).filter(([k]) => k !== PRIMARY_AGENT_NAME)),
+        [PRIMARY_AGENT_NAME]: mergedAgents[PRIMARY_AGENT_NAME],
+      };
+
+      // Add MCP servers (plugin servers override defaults)
+      config.mcp = {
+        ...config.mcp,
+        ...MCP_SERVERS,
+      };
+
+      // Add commands
+      config.command = {
+        ...config.command,
+        init: {
+          description: "Initialize project with ARCHITECTURE.md and CODE_STYLE.md",
+          agent: "project-initializer",
+          template: `Initialize this project. $ARGUMENTS`,
+        },
+        ledger: {
+          description: "Create or update continuity ledger for session state",
+          agent: "ledger-creator",
+          template: `Update the continuity ledger. $ARGUMENTS`,
+        },
+        search: {
+          description: "Search past handoffs, plans, and ledgers",
+          agent: "artifact-searcher",
+          template: `Search for: $ARGUMENTS`,
+        },
+      };
+    },
+
+    "chat.message": async (input, output) => {
+      // Extract text from user message
+      const text = output.parts
+        .filter((p) => p.type === "text" && "text" in p)
+        .map((p) => (p as { text: string }).text)
+        .join(" ");
+
+      // Track if think mode was requested
+      thinkModeState.set(input.sessionID, detectThinkKeyword(text));
+    },
+
+    "chat.params": async (input, output) => {
+      // Inject ledger context first (highest priority)
+      await ledgerLoaderHook["chat.params"](input, output);
+
+      // Inject project context files
+      await contextInjectorHook["chat.params"](input, output);
+
+      // Inject context window status
+      await contextWindowMonitorHook["chat.params"](input, output);
+
+      // If think mode was requested, increase thinking budget
+      if (thinkModeState.get(input.sessionID)) {
+        output.options = {
+          ...output.options,
+          thinking: {
+            type: "enabled",
+            budget_tokens: 32000,
+          },
+        };
+      }
+    },
+
+    // Tool output processing
+    "tool.execute.after": async (
+      input: { tool: string; sessionID: string; callID: string; args?: Record<string, unknown> },
+      output: { output?: string },
+    ) => {
+      // Token-aware truncation
+      await tokenAwareTruncationHook["tool.execute.after"]({ name: input.tool, sessionID: input.sessionID }, output);
+
+      // Comment checker for Edit tool
+      await commentCheckerHook["tool.execute.after"]({ tool: input.tool, args: input.args }, output);
+
+      // Directory-aware context injection for Read/Edit
+      await contextInjectorHook["tool.execute.after"]({ tool: input.tool, args: input.args }, output);
+
+      // Auto-index artifacts when written to thoughts/ directories
+      await artifactAutoIndexHook["tool.execute.after"]({ tool: input.tool, args: input.args }, output);
+
+      // Track file operations for ledger
+      await fileOpsTrackerHook["tool.execute.after"](
+        { tool: input.tool, sessionID: input.sessionID, args: input.args },
+        output,
+      );
+    },
+
+    event: async ({ event }) => {
+      // Session cleanup (think mode + PTY)
+      if (event.type === "session.deleted") {
+        const props = event.properties as { info?: { id?: string } } | undefined;
+        if (props?.info?.id) {
+          thinkModeState.delete(props.info.id);
+          ptyManager.cleanupBySession(props.info.id);
+        }
+      }
+
+      // Run all event hooks
+      await autoCompactHook.event({ event });
+      await autoClearLedgerHook.event({ event });
+      await sessionRecoveryHook.event({ event });
+      await tokenAwareTruncationHook.event({ event });
+      await contextWindowMonitorHook.event({ event });
+
+      // Background task manager event handling
+      backgroundTaskManager.handleEvent(event);
+
+      // File ops tracker cleanup
+      await fileOpsTrackerHook.event({ event });
+    },
+  };
+};
+
+export default OpenCodeConfigPlugin;

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)}`;
+    }
+  },
+});