@plumpslabs/kuma 2.3.0 → 2.3.2

package/dist/{chunk-IXMWW5WA.js → chunk-E2KFPEBT.js}

@@ -89,16 +89,95 @@ function validateFilePath(filePath, projectRoot) {
     };
   }
 }
+function validateFileExtension(filePath) {
+  const allowedExtensions = [
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".json",
+    ".md",
+    ".css",
+    ".html",
+    ".htm",
+    ".env",
+    ".env.example",
+    ".env.local",
+    ".yml",
+    ".yaml",
+    ".toml",
+    ".svg",
+    ".png",
+    ".jpg",
+    ".gif",
+    ".sh",
+    ".bat",
+    ".ps1",
+    ".sql",
+    ".graphql",
+    ".gql",
+    ".vue",
+    ".svelte",
+    ".astro",
+    ".prisma",
+    ".proto",
+    ".txt",
+    ".log"
+  ];
+  const ext = path.extname(filePath).toLowerCase();
+  return allowedExtensions.includes(ext);
+}
 function getProjectRoot() {
   return process.env.AGENT_PROJECT_ROOT ?? process.cwd();
 }
+function isReadable(filePath) {
+  try {
+    fs.accessSync(filePath, fs.constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isWritable(dirPath) {
+  try {
+    fs.accessSync(dirPath, fs.constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getBackupPath(filePath, timestamp) {
+  const ts = timestamp ?? Date.now();
+  const root = getProjectRoot();
+  const relativePath = path.relative(root, filePath);
+  return path.join(root, ".kuma", "backups", String(ts), relativePath);
+}
+function ensureBackupDir() {
+  const root = getProjectRoot();
+  const backupDir = path.join(root, ".kuma", "backups");
+  if (!fs.existsSync(backupDir)) {
+    fs.mkdirSync(backupDir, { recursive: true });
+  }
+  return backupDir;
+}
 function getKumaDir() {
   const root = getProjectRoot();
   return path.join(root, ".kuma");
 }
+function getKumaBackupsDir() {
+  return path.join(getKumaDir(), "backups");
+}
 
 export {
   validateFilePath,
+  validateFileExtension,
   getProjectRoot,
-  getKumaDir
+  isReadable,
+  isWritable,
+  getBackupPath,
+  ensureBackupDir,
+  getKumaDir,
+  getKumaBackupsDir
 };

package/dist/{chunk-OUPFJQKW.js → chunk-EIK7T746.js}

@@ -1,9 +1,9 @@
 import {
   sessionMemory
-} from "./chunk-TT37TE4P.js";
+} from "./chunk-SU7BTOND.js";
 import {
   getProjectRoot
-} from "./chunk-IXMWW5WA.js";
+} from "./chunk-E2KFPEBT.js";
 
 // src/engine/kumaMemory.ts
 import fs from "fs";
@@ -73,11 +73,52 @@ function recordDecision(decision) {
     const existing = sessionMemory.getMemoryContent("decisions");
     sessionMemory.writeMemory("decisions", existing + entry);
     sessionMemory.recordToolCall("kuma_decision", { title: decision.title });
+    recordDecisionToGraph(decision).catch(() => {
+    });
     return `\u2705 Decision "${decision.title}" recorded.`;
   } catch (err) {
     return `Error recording decision: ${err}`;
   }
 }
+async function recordDecisionToGraph(decision) {
+  try {
+    const { upsertNode, addEdge } = await import("./kumaGraph-5IZ4FDZA.js");
+    const decisionId = `decision::${decision.title.replace(/[^a-zA-Z0-9_\-\s]/g, "").trim().replace(/\s+/g, "-")}`;
+    await upsertNode({
+      id: decisionId,
+      type: "variable",
+      name: `ADR: ${decision.title.substring(0, 80)}`,
+      metadata: {
+        type: "architectural-decision",
+        context: decision.context.substring(0, 200),
+        rationale: decision.rationale.substring(0, 200),
+        outcome: decision.outcome,
+        timestamp: decision.timestamp
+      }
+    });
+    const filePathMatches = decision.context.matchAll(/["']?([\w./-]+\.\w+)["']?/g);
+    for (const match of filePathMatches) {
+      const possiblePath = match[1];
+      if (possiblePath.includes("/") && (possiblePath.endsWith(".ts") || possiblePath.endsWith(".js") || possiblePath.endsWith(".json") || possiblePath.endsWith(".md"))) {
+        try {
+          const fileId = `file::${possiblePath}`;
+          await upsertNode({ id: fileId, type: "file", name: possiblePath });
+          await addEdge({ sourceId: decisionId, targetId: fileId, type: "depends_on", metadata: { reason: "adr-context" } });
+        } catch {
+        }
+      }
+    }
+    if (decision.outcome && decision.outcome !== "implemented") {
+      try {
+        const outcomeId = `decision-outcome::${decision.outcome.replace(/[^a-zA-Z0-9]/g, "-").toLowerCase()}`;
+        await upsertNode({ id: outcomeId, type: "variable", name: `Outcome: ${decision.outcome.substring(0, 60)}` });
+        await addEdge({ sourceId: decisionId, targetId: outcomeId, type: "depends_on" });
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
 var decisionCooldown = 0;
 function shouldRecordDecision() {
   const history = sessionMemory.getToolCallHistory(30);

package/dist/{chunk-IMO4QAFJ.js → chunk-EQ2CE4UC.js}

@@ -1,10 +1,10 @@
 import {
   getDb,
   saveDb
-} from "./chunk-6NEMSUKP.js";
+} from "./chunk-5N6KXACT.js";
 import {
   getProjectRoot
-} from "./chunk-IXMWW5WA.js";
+} from "./chunk-E2KFPEBT.js";
 
 // src/engine/kumaSelfHeal.ts
 import { execSync } from "child_process";
@@ -458,7 +458,7 @@ The two nodes may not be connected in the knowledge graph yet. Use more tools to
 }
 async function buildFromSessionMemory() {
   try {
-    const { sessionMemory } = await import("./sessionMemory-52ECPXZ6.js");
+    const { sessionMemory } = await import("./sessionMemory-LI4FIAMF.js");
     const toolCalls = sessionMemory.getToolCallHistory(50);
     let edgeCount = 0;
     for (const call of toolCalls) {
@@ -532,7 +532,7 @@ async function searchGraph(query, limit = 20) {
     }
     stmt.free();
     if (results.length === 0) {
-      return `\u{1F50D} **Graph Search** \u2014 No results for "${query}". Try a different search term.`;
+      return await codebaseSearchFallback(query, limit);
     }
     const lines = [
       `\u{1F50D} **Graph Search** \u2014 ${results.length} result(s) for "${query}"`,
@@ -546,6 +546,89 @@ async function searchGraph(query, limit = 20) {
     return `Error searching graph: ${err}`;
   }
 }
+async function codebaseSearchFallback(query, limit = 20) {
+  try {
+    const fg = (await import("fast-glob")).default;
+    const { getProjectRoot: getProjectRoot2 } = await import("./pathValidator-V4DC6U6Z.js");
+    const root = getProjectRoot2();
+    const patterns = [
+      `**/*${query}*`,
+      `**/*${query}*/**`,
+      query.includes(".") ? `**/${query}` : null
+    ].filter(Boolean);
+    const ignorePatterns = ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/build/**", "**/.kuma/**"];
+    const files = await fg(patterns, {
+      cwd: root,
+      ignore: ignorePatterns,
+      onlyFiles: true,
+      deep: 6,
+      dot: false
+    });
+    if (files.length === 0) {
+      return `\u{1F50D} **Codebase Search** \u2014 No results for "${query}". Try a different search term or research the topic first.`;
+    }
+    const lines = [
+      `\u{1F50D} **Codebase Search** \u2014 ${files.length} result(s) for "${query}" (graph fallback)`,
+      `\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`,
+      ""
+    ];
+    for (const file of files.slice(0, limit)) {
+      lines.push(`  \u{1F4C4} **${file}**`);
+    }
+    if (files.length > limit) {
+      lines.push(`  ... and ${files.length - limit} more`);
+    }
+    lines.push(
+      "",
+      "\u{1F4A1} The knowledge graph is empty or has no matches.",
+      "\u{1F4A1} Run research or use more tools to build the graph for richer results."
+    );
+    return lines.join("\n");
+  } catch {
+    try {
+      let walk2 = function(dir) {
+        if (results.length >= limit) return;
+        let entries = [];
+        try {
+          entries = fs2.readdirSync(dir);
+        } catch {
+          return;
+        }
+        for (const entry of entries) {
+          if (entry.startsWith(".") || entry === "node_modules" || entry === "dist" || entry === "build") continue;
+          const full = path2.join(dir, entry);
+          try {
+            const stat = fs2.statSync(full);
+            if (stat.isDirectory()) {
+              walk2(full);
+            } else if (entry.toLowerCase().includes(query.toLowerCase())) {
+              results.push(path2.relative(root, full));
+            }
+          } catch {
+          }
+        }
+      };
+      var walk = walk2;
+      const fs2 = await import("fs");
+      const path2 = await import("path");
+      const root = process.cwd();
+      const results = [];
+      walk2(root);
+      if (results.length === 0) {
+        return `\u{1F50D} **Codebase Search** \u2014 No results for "${query}". Try a different search term.`;
+      }
+      return [
+        `\u{1F50D} **Codebase Search** \u2014 ${results.length} result(s) for "${query}" (basic fallback)`,
+        "",
+        ...results.slice(0, limit).map((f) => `  \u{1F4C4} **${f}**`),
+        "",
+        "\u{1F4A1} Install fast-glob for faster, more comprehensive codebase searches."
+      ].join("\n");
+    } catch {
+      return `\u{1F50D} **Search** \u2014 No results for "${query}". The knowledge graph is empty. Try researching first.`;
+    }
+  }
+}
 async function getGraphStats() {
   try {
     const db = await getDb();
@@ -589,6 +672,10 @@ async function getGraphStats() {
 async function analyzeImpact(target) {
   try {
     const db = await getDb();
+    const nodeCount = db.exec("SELECT COUNT(*) as c FROM nodes")[0]?.values[0][0] ?? 0;
+    if (nodeCount === 0) {
+      return await codebaseImpactFallback(target);
+    }
     const nodeStmt = db.prepare(`
       SELECT id, name, type, file_path FROM nodes
       WHERE name LIKE ? OR file_path = ? OR id = ?
@@ -604,7 +691,7 @@ async function analyzeImpact(target) {
     }
     nodeStmt.free();
     if (!nodeId2) {
-      return { symbol: target, references: 0, files: 0, testFiles: 0, entryPoints: [], risk: "low" };
+      return await codebaseImpactFallback(target);
     }
     const refStmt = db.prepare(`
       SELECT COUNT(*) as cnt, COUNT(DISTINCT CASE WHEN e.source_id != ? THEN e.source_id ELSE e.target_id END) as file_count
@@ -651,6 +738,34 @@ async function analyzeImpact(target) {
     return { symbol: target, references: 0, files: 0, testFiles: 0, entryPoints: [], risk: "low" };
   }
 }
+async function codebaseImpactFallback(target) {
+  try {
+    const { execSync: execSync2 } = await import("child_process");
+    const root = process.cwd();
+    const grepResult = execSync2(
+      `grep -rn --include="*.ts" --include="*.tsx" --include="*.js" --include="*.jsx" --include="*.json" -l "${target.replace(/"/g, '\\"')}" . 2>/dev/null | grep -v node_modules | grep -v .git | grep -v dist | grep -v .kuma | head -50`,
+      { cwd: root, encoding: "utf-8", timeout: 5e3, maxBuffer: 1024 * 1024 }
+    ).trim();
+    const files = grepResult ? grepResult.split("\n").filter(Boolean).filter((f) => !f.startsWith("./")) : [];
+    if (files.length === 0) {
+      return { symbol: target, references: 0, files: 0, testFiles: 0, entryPoints: [], risk: "low" };
+    }
+    const fileCount = files.length;
+    const testFiles = files.filter((f) => f.includes("test") || f.includes("spec") || f.includes("__tests__")).length;
+    const risk = fileCount > 20 ? "high" : fileCount > 5 ? "medium" : "low";
+    return {
+      symbol: target,
+      references: fileCount,
+      // file-level count since we're approximating
+      files: fileCount,
+      testFiles,
+      entryPoints: files.slice(0, 5).map((f) => `${f} (grep match)`),
+      risk
+    };
+  } catch {
+    return { symbol: target, references: 0, files: 0, testFiles: 0, entryPoints: [], risk: "low" };
+  }
+}
 function formatImpact(result) {
   const icon = result.risk === "high" ? "\u{1F534}" : result.risk === "medium" ? "\u{1F7E1}" : "\u{1F7E2}";
   const lines = [

package/dist/{chunk-WP3WRPDC.js → chunk-JIL533AM.js}

@@ -1,9 +1,9 @@
 import {
   sessionMemory
-} from "./chunk-TT37TE4P.js";
+} from "./chunk-SU7BTOND.js";
 import {
   getProjectRoot
-} from "./chunk-IXMWW5WA.js";
+} from "./chunk-E2KFPEBT.js";
 
 // src/utils/kumaShared.ts
 import { execSync } from "child_process";

package/dist/{chunk-5A6AKUJZ.js → chunk-L5WU2HTN.js}

@@ -1,6 +1,6 @@
 import {
   getProjectRoot
-} from "./chunk-IXMWW5WA.js";
+} from "./chunk-E2KFPEBT.js";
 
 // src/cli/init.ts
 import fs from "fs";
@@ -270,6 +270,7 @@ function generateInitMdContent() {
     "",
     '- `kuma_memory({ action: "research_save", scope: "...", ... })` \u2014 Save research results',
     '- `kuma_memory({ action: "decision", decisionAction: "record", ... })` \u2014 ADR-style decision',
+    '- **`kuma_memory({ action: "mine", scope: "..." })` \u2014 Mine historical decisions from git log & comments**',
     '- `kuma_memory({ action: "session" })` \u2014 Session summary',
     '- `kuma_memory({ action: "heal" })` \u2014 Self-heal knowledge graph',
     '- `kuma_memory({ action: "search", query: "..." })` \u2014 Search memories + graph',
@@ -278,6 +279,7 @@ function generateInitMdContent() {
     "### \u{1F6E1}\uFE0F kuma_safety \u2014 Safety & Policy",
     "",
     '- `kuma_safety({ action: "guard", guardGoal: "..." })` \u2014 Anti-pattern, drift, loop detection',
+    '- **`kuma_safety({ action: "verify", scope: "..." })` \u2014 Auto-run scoped tests & verify correctness**',
     '- `kuma_safety({ action: "check", ... })` \u2014 Pre-execution safety check',
     '- `kuma_safety({ action: "audit" })` \u2014 Query safety audit trail',
     '- `kuma_safety({ action: "lock", lockAction: "acquire", ... })` \u2014 Multi-agent file lock',

package/dist/{chunk-TT37TE4P.js → chunk-SU7BTOND.js}

@@ -300,15 +300,41 @@ No unresolved issues.`;
   }
   recordToolCall(toolName, params) {
     this.ensureInit();
+    const timestamp = Date.now();
     this.state.toolCalls.push({
       toolName,
       params,
-      timestamp: Date.now()
+      timestamp
     });
     if (this.state.toolCalls.length > 100) {
       this.state.toolCalls = this.state.toolCalls.slice(-100);
     }
     this.save();
+    this.autoTrackToDb(toolName, params, timestamp).catch(() => {
+    });
+  }
+  /**
+   * Auto-track tool calls to the database sessions + tool_calls + experiences tables.
+   * This is the passive observability pipeline — every tool call gets recorded
+   * automatically without requiring the tool to explicitly write to the DB.
+   */
+  async autoTrackToDb(toolName, params, timestamp) {
+    try {
+      const { getDb, saveDb } = await import("./kumaDb-RC2EO3OB.js");
+      const db = await getDb();
+      db.run(
+        `INSERT INTO tool_calls (tool_name, params, success, duration_ms, created_at) VALUES (?, ?, 1, 0, ?)`,
+        [toolName, JSON.stringify(params), Math.floor(timestamp / 1e3)]
+      );
+      const paramsHash = simpleHash(JSON.stringify(params));
+      const filePath = params.filePath || params.file_path || params.target || null;
+      db.run(
+        `INSERT INTO experiences (tool_name, params_hash, success, context_file, context_action, created_at) VALUES (?, ?, 1, ?, ?, ?)`,
+        [toolName, paramsHash, filePath, params.action || null, Math.floor(timestamp / 1e3)]
+      );
+      saveDb(db);
+    } catch {
+    }
   }
   setConventions(conventions) {
     this.ensureInit();
@@ -571,7 +597,7 @@ No unresolved issues.`;
       this.addModifiedFile(filePath);
     }
     try {
-      const { recordChange } = await import("./kumaDb-KN7Z4B5V.js");
+      const { recordChange } = await import("./kumaDb-RC2EO3OB.js");
       const gitHash = this.getGitHead();
       await recordChange({ filePath, changeType, symbol, gitCommitHash: gitHash || void 0 });
     } catch {
@@ -608,6 +634,15 @@ No unresolved issues.`;
     }
   }
 };
+function simpleHash(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(36);
+}
 var sessionMemory = new SessionMemory();
 
 export {