chainlesschain 0.37.12 → 0.40.1

package/src/lib/permanent-memory.js

@@ -0,0 +1,370 @@
+/**
+ * CLI Permanent Memory — cross-session persistent memory with Daily Notes,
+ * MEMORY.md knowledge base, and BM25 hybrid search.
+ *
+ * Graceful degradation: works without DB (file-only mode).
+ * Keeps CLI < 2MB — uses BM25 for search, no heavy vector dependencies.
+ */
+
+import fs from "fs";
+import path from "path";
+import { BM25Search } from "./bm25-search.js";
+
+// Exported for test injection
+export const _deps = {
+  fs,
+  path,
+  BM25Search,
+};
+
+export class CLIPermanentMemory {
+  /**
+   * @param {object} options
+   * @param {object|null} options.db - Database instance (null for file-only mode)
+   * @param {string} options.memoryDir - Directory for memory files
+   */
+  constructor({ db, memoryDir } = {}) {
+    this.db = db || null;
+    this.memoryDir = memoryDir || "";
+    this._bm25 = null;
+    this._initialized = false;
+    this._memoryFileContent = "";
+    this._dailyNotes = [];
+    this._dbEntries = [];
+  }
+
+  /**
+   * Initialize: create tables, load MEMORY.md, build BM25 index.
+   */
+  initialize() {
+    if (this._initialized) return;
+    this._initialized = true;
+
+    // Ensure directories
+    if (this.memoryDir) {
+      try {
+        const dailyDir = _deps.path.join(this.memoryDir, "daily");
+        if (!_deps.fs.existsSync(this.memoryDir)) {
+          _deps.fs.mkdirSync(this.memoryDir, { recursive: true });
+        }
+        if (!_deps.fs.existsSync(dailyDir)) {
+          _deps.fs.mkdirSync(dailyDir, { recursive: true });
+        }
+      } catch (_err) {
+        // Directory creation failed — continue in degraded mode
+      }
+    }
+
+    // Create DB table
+    if (this.db) {
+      try {
+        this.db.exec(`
+          CREATE TABLE IF NOT EXISTS permanent_memory (
+            id TEXT PRIMARY KEY,
+            content TEXT NOT NULL,
+            source TEXT DEFAULT 'auto',
+            category TEXT DEFAULT 'general',
+            importance REAL DEFAULT 0.5,
+            created_at TEXT DEFAULT (datetime('now')),
+            updated_at TEXT DEFAULT (datetime('now'))
+          )
+        `);
+      } catch (_err) {
+        // Table creation failed — continue without DB
+      }
+    }
+
+    // Load MEMORY.md
+    this._loadMemoryFile();
+
+    // Load daily notes (recent 7 days)
+    this._loadRecentDailyNotes();
+
+    // Load DB entries
+    this._loadDbEntries();
+
+    // Build BM25 index
+    this._buildIndex();
+  }
+
+  /**
+   * Append content to today's daily note.
+   */
+  appendDailyNote(content) {
+    if (!this.memoryDir || !content) return null;
+
+    try {
+      const today = new Date().toISOString().slice(0, 10);
+      const dailyDir = _deps.path.join(this.memoryDir, "daily");
+      const filePath = _deps.path.join(dailyDir, `${today}.md`);
+      const timestamp = new Date().toISOString().slice(11, 19);
+      const entry = `\n## ${timestamp}\n\n${content}\n`;
+
+      if (_deps.fs.existsSync(filePath)) {
+        _deps.fs.appendFileSync(filePath, entry, "utf-8");
+      } else {
+        _deps.fs.writeFileSync(
+          filePath,
+          `# Daily Note: ${today}\n${entry}`,
+          "utf-8",
+        );
+      }
+
+      // Rebuild index
+      this._loadRecentDailyNotes();
+      this._buildIndex();
+
+      return { date: today, path: filePath };
+    } catch (_err) {
+      return null;
+    }
+  }
+
+  /**
+   * Update a section of MEMORY.md.
+   * If section exists, replaces it. Otherwise appends.
+   */
+  updateMemoryFile(section, content) {
+    if (!this.memoryDir) return null;
+
+    try {
+      const filePath = _deps.path.join(this.memoryDir, "MEMORY.md");
+      let existing = "";
+      if (_deps.fs.existsSync(filePath)) {
+        existing = _deps.fs.readFileSync(filePath, "utf-8");
+      }
+
+      const sectionHeader = `## ${section}`;
+      const sectionIdx = existing.indexOf(sectionHeader);
+
+      if (sectionIdx >= 0) {
+        // Find next ## or end of file
+        const afterHeader = existing.indexOf(
+          "\n## ",
+          sectionIdx + sectionHeader.length,
+        );
+        const endIdx = afterHeader >= 0 ? afterHeader : existing.length;
+        const newContent =
+          existing.slice(0, sectionIdx) +
+          `${sectionHeader}\n\n${content}\n` +
+          existing.slice(endIdx);
+        _deps.fs.writeFileSync(filePath, newContent, "utf-8");
+      } else {
+        // Append new section
+        const append = existing
+          ? `\n${sectionHeader}\n\n${content}\n`
+          : `# Memory\n\n${sectionHeader}\n\n${content}\n`;
+        _deps.fs.writeFileSync(filePath, existing + append, "utf-8");
+      }
+
+      this._loadMemoryFile();
+      this._buildIndex();
+      return { path: filePath };
+    } catch (_err) {
+      return null;
+    }
+  }
+
+  /**
+   * BM25 hybrid search across all memory sources.
+   */
+  hybridSearch(query, { topK = 5 } = {}) {
+    if (!this._bm25 || !query) return [];
+
+    try {
+      return this._bm25.search(query, { topK, threshold: 0.1 });
+    } catch (_err) {
+      return [];
+    }
+  }
+
+  /**
+   * Get relevant context for a query (used by CLIContextEngineering).
+   * Returns array of { content, source, score }.
+   */
+  getRelevantContext(query, limit = 3) {
+    if (!query) return [];
+
+    this.initialize();
+    const results = this.hybridSearch(query, { topK: limit });
+    return results.map((r) => ({
+      content: (r.doc.content || "").substring(0, 300),
+      source: r.doc.source || "memory",
+      score: r.score,
+    }));
+  }
+
+  /**
+   * Auto-summarize session messages and store key facts.
+   * Called at session end.
+   */
+  autoSummarize(sessionMessages) {
+    if (!sessionMessages || sessionMessages.length < 4) return [];
+
+    const facts = [];
+
+    // Extract tool usage patterns
+    const toolUses = sessionMessages.filter(
+      (m) => m.role === "tool" || m.tool_calls,
+    );
+    if (toolUses.length > 0) {
+      const toolNames = new Set();
+      for (const m of sessionMessages) {
+        if (m.tool_calls) {
+          for (const tc of m.tool_calls) {
+            toolNames.add(tc.function?.name || tc.name || "unknown");
+          }
+        }
+      }
+      if (toolNames.size > 0) {
+        facts.push(`Tools used: ${[...toolNames].join(", ")}`);
+      }
+    }
+
+    // Extract user questions/topics
+    const userMsgs = sessionMessages.filter((m) => m.role === "user");
+    if (userMsgs.length > 0) {
+      const topics = userMsgs
+        .slice(0, 3)
+        .map((m) => (m.content || "").substring(0, 60).replace(/\n/g, " "))
+        .filter(Boolean);
+      if (topics.length > 0) {
+        facts.push(`Topics discussed: ${topics.join("; ")}`);
+      }
+    }
+
+    // Store facts
+    for (const fact of facts) {
+      this._storeEntry(fact, "auto-summary");
+    }
+
+    // Append to daily note
+    if (facts.length > 0) {
+      this.appendDailyNote(
+        `Session summary:\n${facts.map((f) => `- ${f}`).join("\n")}`,
+      );
+    }
+
+    return facts;
+  }
+
+  /**
+   * Store a permanent memory entry in DB.
+   */
+  _storeEntry(content, source = "auto", importance = 0.5) {
+    if (!this.db) return null;
+    try {
+      const id = `pm-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+      this.db
+        .prepare(
+          "INSERT INTO permanent_memory (id, content, source, importance) VALUES (?, ?, ?, ?)",
+        )
+        .run(id, content, source, importance);
+      return id;
+    } catch (_err) {
+      return null;
+    }
+  }
+
+  // ─── Internal ───
+
+  _loadMemoryFile() {
+    if (!this.memoryDir) return;
+    try {
+      const filePath = _deps.path.join(this.memoryDir, "MEMORY.md");
+      if (_deps.fs.existsSync(filePath)) {
+        this._memoryFileContent = _deps.fs.readFileSync(filePath, "utf-8");
+      }
+    } catch (_err) {
+      this._memoryFileContent = "";
+    }
+  }
+
+  _loadRecentDailyNotes() {
+    if (!this.memoryDir) return;
+    this._dailyNotes = [];
+    try {
+      const dailyDir = _deps.path.join(this.memoryDir, "daily");
+      if (!_deps.fs.existsSync(dailyDir)) return;
+
+      const files = _deps.fs
+        .readdirSync(dailyDir)
+        .filter((f) => f.endsWith(".md"))
+        .sort()
+        .reverse()
+        .slice(0, 7);
+
+      for (const f of files) {
+        const content = _deps.fs.readFileSync(
+          _deps.path.join(dailyDir, f),
+          "utf-8",
+        );
+        this._dailyNotes.push({
+          date: f.replace(".md", ""),
+          content,
+        });
+      }
+    } catch (_err) {
+      // Non-critical
+    }
+  }
+
+  _loadDbEntries() {
+    if (!this.db) return;
+    this._dbEntries = [];
+    try {
+      this._dbEntries = this.db
+        .prepare(
+          "SELECT id, content, source, importance FROM permanent_memory ORDER BY importance DESC LIMIT 100",
+        )
+        .all();
+    } catch (_err) {
+      // Table may not exist
+    }
+  }
+
+  _buildIndex() {
+    const docs = [];
+
+    // MEMORY.md sections
+    if (this._memoryFileContent) {
+      const sections = this._memoryFileContent.split(/^## /m).filter(Boolean);
+      for (const section of sections) {
+        const firstLine = section.split("\n")[0].trim();
+        docs.push({
+          id: `memfile-${firstLine.substring(0, 30)}`,
+          title: firstLine,
+          content: section.substring(0, 500),
+          source: "MEMORY.md",
+        });
+      }
+    }
+
+    // Daily notes
+    for (const note of this._dailyNotes) {
+      docs.push({
+        id: `daily-${note.date}`,
+        title: `Daily Note ${note.date}`,
+        content: note.content.substring(0, 500),
+        source: "daily-note",
+      });
+    }
+
+    // DB entries
+    for (const entry of this._dbEntries) {
+      docs.push({
+        id: entry.id,
+        title: (entry.content || "").substring(0, 60),
+        content: entry.content || "",
+        source: entry.source || "db",
+      });
+    }
+
+    if (docs.length > 0) {
+      this._bm25 = new _deps.BM25Search();
+      this._bm25.indexDocuments(docs);
+    } else {
+      this._bm25 = null;
+    }
+  }
+}

package/src/lib/plan-mode.js

@@ -54,6 +54,26 @@ const WRITE_TOOLS = new Set([
 /**
  * A single item in an execution plan
  */
+/**
+ * Risk weights for tool categories
+ */
+const TOOL_RISK_WEIGHTS = {
+  read_file: 1,
+  search_files: 1,
+  list_dir: 1,
+  list_skills: 1,
+  write_file: 2,
+  edit_file: 2,
+  run_skill: 2,
+  run_shell: 3,
+};
+
+const IMPACT_MULTIPLIERS = {
+  low: 1,
+  medium: 2,
+  high: 3,
+};
+
 export class PlanItem {
   constructor(data = {}) {
     this.id =
@@ -69,6 +89,16 @@ export class PlanItem {
     this.result = null;
     this.error = null;
   }
+
+  /**
+   * Calculate risk score for this item.
+   * Score = tool_weight × impact_multiplier
+   */
+  get riskScore() {
+    const toolWeight = TOOL_RISK_WEIGHTS[this.tool] || 1;
+    const impactMul = IMPACT_MULTIPLIERS[this.estimatedImpact] || 1;
+    return toolWeight * impactMul;
+  }
 }
 
 /**
@@ -102,6 +132,115 @@ export class ExecutionPlan {
   getItem(itemId) {
     return this.items.find((i) => i.id === itemId);
   }
+
+  /**
+   * Topological sort of items by dependencies.
+   * Returns items in execution order. Throws if cycle detected.
+   */
+  topologicalSort() {
+    const itemMap = new Map(this.items.map((i) => [i.id, i]));
+    const visited = new Set();
+    const visiting = new Set();
+    const sorted = [];
+
+    const visit = (id) => {
+      if (visited.has(id)) return;
+      if (visiting.has(id))
+        throw new Error(`Dependency cycle detected involving ${id}`);
+
+      visiting.add(id);
+      const item = itemMap.get(id);
+      if (item && item.dependencies) {
+        for (const depId of item.dependencies) {
+          if (itemMap.has(depId)) {
+            visit(depId);
+          }
+        }
+      }
+      visiting.delete(id);
+      visited.add(id);
+      if (item) sorted.push(item);
+    };
+
+    for (const item of this.items) {
+      visit(item.id);
+    }
+
+    return sorted;
+  }
+
+  /**
+   * Execute items in DAG topological order using provided executor.
+   * If a dependency fails, downstream items are marked as blocked.
+   *
+   * @param {function} executor - async (item) => result
+   * @returns {Array<{ item: PlanItem, success: boolean, result: any, error: string }>}
+   */
+  async executeInOrder(executor) {
+    const sorted = this.topologicalSort();
+    const results = [];
+    const failedIds = new Set();
+
+    for (const item of sorted) {
+      // Check if any dependency failed
+      const blocked = (item.dependencies || []).some((depId) =>
+        failedIds.has(depId),
+      );
+      if (blocked) {
+        item.status = PlanStatus.FAILED;
+        item.error = "Blocked by failed dependency";
+        failedIds.add(item.id);
+        results.push({ item, success: false, result: null, error: item.error });
+        continue;
+      }
+
+      item.status = PlanStatus.EXECUTING;
+      try {
+        const result = await executor(item);
+        item.status = PlanStatus.COMPLETED;
+        item.result = result;
+        results.push({ item, success: true, result, error: null });
+      } catch (err) {
+        item.status = PlanStatus.FAILED;
+        item.error = err.message;
+        failedIds.add(item.id);
+        results.push({
+          item,
+          success: false,
+          result: null,
+          error: err.message,
+        });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Calculate aggregate risk score for the plan.
+   */
+  getRiskAssessment() {
+    const scores = this.items.map((i) => i.riskScore);
+    const total = scores.reduce((sum, s) => sum + s, 0);
+    const max = Math.max(...scores, 0);
+    const avg = scores.length > 0 ? total / scores.length : 0;
+
+    let level = "low";
+    if (max >= 6 || avg >= 4) level = "high";
+    else if (max >= 4 || avg >= 2) level = "medium";
+
+    return {
+      level,
+      totalScore: total,
+      maxScore: max,
+      averageScore: Math.round(avg * 100) / 100,
+      itemScores: this.items.map((i) => ({
+        id: i.id,
+        title: i.title,
+        score: i.riskScore,
+      })),
+    };
+  }
 }
 
 /**
@@ -116,6 +255,14 @@ export class PlanModeManager extends EventEmitter {
     this.currentPlan = null;
     this.history = [];
     this.blockedToolLog = [];
+    this._hookDb = null;
+  }
+
+  /**
+   * Set DB reference for hook execution.
+   */
+  setHookDb(db) {
+    this._hookDb = db;
   }
 
   /**
@@ -141,6 +288,7 @@ export class PlanModeManager extends EventEmitter {
     this.blockedToolLog = [];
 
     this.emit("enter", { plan: this.currentPlan, state: this.state });
+    this._fireHook("PlanModeEnter", { planId: this.currentPlan.id });
     return { plan: this.currentPlan };
   }
 
@@ -217,6 +365,10 @@ export class PlanModeManager extends EventEmitter {
       plan: this.currentPlan,
       approvedCount: approvedItems.length,
     });
+    this._fireHook("PlanApproved", {
+      planId: this.currentPlan.id,
+      itemCount: approvedItems.length,
+    });
     return { plan: this.currentPlan, approvedCount: approvedItems.length };
   }
 
@@ -233,6 +385,7 @@ export class PlanModeManager extends EventEmitter {
     }
 
     this.state = PlanState.REJECTED;
+    this._fireHook("PlanRejected", { planId: this.currentPlan.id, reason });
     return this.exitPlanMode({ savePlan: true, reason: reason || "rejected" });
   }
 
@@ -297,6 +450,13 @@ export class PlanModeManager extends EventEmitter {
       }
     }
 
+    // Risk assessment
+    const risk = plan.getRiskAssessment();
+    lines.push("");
+    lines.push(
+      `**Risk**: ${risk.level} (total: ${risk.totalScore}, max: ${risk.maxScore}, avg: ${risk.averageScore})`,
+    );
+
     if (this.blockedToolLog.length > 0) {
       lines.push("");
       lines.push(
@@ -307,12 +467,63 @@ export class PlanModeManager extends EventEmitter {
     return lines.filter(Boolean).join("\n");
   }
 
+  /**
+   * Get risk assessment for current plan.
+   */
+  getRiskAssessment() {
+    if (!this.currentPlan) return null;
+    return this.currentPlan.getRiskAssessment();
+  }
+
+  /**
+   * Execute approved plan items in DAG order.
+   * @param {function} executor - async (item) => result
+   */
+  async executePlan(executor) {
+    if (!this.currentPlan) return { error: "No active plan" };
+    if (this.state !== PlanState.APPROVED)
+      return { error: "Plan not approved" };
+
+    this.state = PlanState.EXECUTING;
+    this.currentPlan.status = PlanState.EXECUTING;
+
+    const results = await this.currentPlan.executeInOrder(async (item) => {
+      this._fireHook("PlanItemExecute", {
+        planId: this.currentPlan.id,
+        itemId: item.id,
+        tool: item.tool,
+      });
+      return executor(item);
+    });
+
+    const allDone = results.every((r) => r.success);
+    this.state = allDone ? PlanState.COMPLETED : PlanState.COMPLETED;
+    this.currentPlan.status = allDone
+      ? PlanState.COMPLETED
+      : PlanState.COMPLETED;
+
+    return { results, success: allDone };
+  }
+
   /**
    * Get plans history
    */
   getHistory() {
     return this.history;
   }
+
+  /**
+   * Fire a hook event (best-effort, non-blocking).
+   */
+  _fireHook(eventName, context) {
+    if (!this._hookDb) return;
+    // Dynamic import to avoid circular deps
+    import("./hook-manager.js")
+      .then(({ executeHooks }) => {
+        executeHooks(this._hookDb, eventName, context).catch(() => {});
+      })
+      .catch(() => {});
+  }
 }
 
 // Singleton