@plumpslabs/kuma 2.2.7 → 2.3.0

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

@@ -89,77 +89,16 @@ 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 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,
-  getBackupPath,
-  ensureBackupDir,
-  getKumaDir,
-  getKumaBackupsDir
+  getKumaDir
 };

package/dist/chunk-OUPFJQKW.js

@@ -0,0 +1,131 @@
+import {
+  sessionMemory
+} from "./chunk-TT37TE4P.js";
+import {
+  getProjectRoot
+} from "./chunk-IXMWW5WA.js";
+
+// src/engine/kumaMemory.ts
+import fs from "fs";
+import path from "path";
+var MEMORY_DIR = ".kuma/memories";
+function scoreMemoryRelevance(context, limit = 5) {
+  const results = [];
+  const kumaDir = path.join(getProjectRoot(), MEMORY_DIR);
+  if (!fs.existsSync(kumaDir)) return [];
+  const terms = context.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
+  if (terms.length === 0) return [];
+  try {
+    const files = fs.readdirSync(kumaDir).filter((f) => f.endsWith(".md"));
+    for (const file of files) {
+      try {
+        const content = fs.readFileSync(path.join(kumaDir, file), "utf-8");
+        const lower = content.toLowerCase();
+        let matchCount = 0;
+        for (const term of terms) {
+          if (lower.includes(term)) matchCount++;
+        }
+        const score = Math.round(matchCount / terms.length * 100);
+        if (score > 0) {
+          const topic = file.replace(/\.md$/, "");
+          const firstLine = content.split("\n").slice(0, 3).join(" ").substring(0, 150);
+          results.push({
+            topic,
+            content: firstLine,
+            score,
+            reason: `${matchCount}/${terms.length} terms matched`
+          });
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return results.sort((a, b) => b.score - a.score).slice(0, limit);
+}
+function formatScoredMemories(memories, context) {
+  if (memories.length === 0) return "";
+  const lines = [
+    `\u{1F9E0} **Relevant Memories** (for "${context.substring(0, 40)}")`,
+    "\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 m of memories) {
+    const bar = "\u2588".repeat(Math.round(m.score / 10)) + "\u2591".repeat(Math.round(10 - m.score / 10));
+    lines.push(`  **${m.topic}** \u2014 ${bar} ${m.score}%`);
+    lines.push(`  ${m.content.substring(0, 100)}`);
+    lines.push(`  \u{1F4A1} ${m.reason}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function recordDecision(decision) {
+  try {
+    const entry = [
+      "",
+      `## ${decision.title}`,
+      `- **Date:** ${decision.timestamp || (/* @__PURE__ */ new Date()).toISOString()}`,
+      `- **Context:** ${decision.context}`,
+      `- **Options:** ${decision.options.join(", ")}`,
+      `- **Rationale:** ${decision.rationale}`,
+      `- **Outcome:** ${decision.outcome}`,
+      ""
+    ].join("\n");
+    const existing = sessionMemory.getMemoryContent("decisions");
+    sessionMemory.writeMemory("decisions", existing + entry);
+    sessionMemory.recordToolCall("kuma_decision", { title: decision.title });
+    return `\u2705 Decision "${decision.title}" recorded.`;
+  } catch (err) {
+    return `Error recording decision: ${err}`;
+  }
+}
+var decisionCooldown = 0;
+function shouldRecordDecision() {
+  const history = sessionMemory.getToolCallHistory(30);
+  const edits = history.filter((c) => c.toolName === "precise_diff_editor");
+  if (edits.length > decisionCooldown + 10 && edits.length >= 10) {
+    decisionCooldown = edits.length;
+    return {
+      worth: true,
+      title: `Significant edits (${edits.length} changes)`
+    };
+  }
+  return { worth: false };
+}
+function getProactiveMemories() {
+  const summary = sessionMemory.getSummary();
+  const goal = summary.currentGoal || "";
+  const modifiedFiles = summary.modifiedFiles || [];
+  const context = [goal, ...modifiedFiles.map((f) => f.filePath || "")].join(" ");
+  if (!context.trim()) return "";
+  const memories = scoreMemoryRelevance(context, 3);
+  return formatScoredMemories(memories, goal || "current context");
+}
+function formatDecisionTemplate() {
+  return [
+    "\u{1F4DD} **Decision Recording Template**",
+    "\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",
+    "",
+    "Use kuma_decision({ action: 'record', ... }) to log important decisions:",
+    "",
+    "```",
+    "kuma_decision({",
+    "  action: 'record',",
+    "  title: 'Why Redis instead of in-memory cache',",
+    "  context: 'Need stateless auth for mobile clients',",
+    "  options: ['Redis', 'In-memory', 'Database'],",
+    "  rationale: 'Latency <10ms with persistence required',",
+    "  outcome: 'Redis chosen'",
+    "})",
+    "```",
+    "",
+    "\u{1F4A1} Call kuma_decision({ action: 'suggest' }) to check if now is a good time to record."
+  ].join("\n");
+}
+
+export {
+  scoreMemoryRelevance,
+  recordDecision,
+  shouldRecordDecision,
+  getProactiveMemories,
+  formatDecisionTemplate
+};

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

@@ -1,6 +1,7 @@
 // src/engine/sessionMemory.ts
 import fs from "fs";
 import path from "path";
+import { execSync } from "child_process";
 var SessionMemory = class {
   state;
   initialized = false;
@@ -557,6 +558,47 @@ No unresolved issues.`;
     }
     return { isLooping: false };
   }
+  // ============================================================
+  // V3: Change Tracking (Selective Undo)
+  // ============================================================
+  /**
+   * Track a file change with symbol-level detail.
+   * Stores in memory.json AND writes to change_log in DB.
+   */
+  async trackChange(filePath, changeType, symbol) {
+    this.ensureInit();
+    if (changeType === "modified" || changeType === "created") {
+      this.addModifiedFile(filePath);
+    }
+    try {
+      const { recordChange } = await import("./kumaDb-KN7Z4B5V.js");
+      const gitHash = this.getGitHead();
+      await recordChange({ filePath, changeType, symbol, gitCommitHash: gitHash || void 0 });
+    } catch {
+    }
+    this.save();
+  }
+  /**
+   * Get the current git HEAD hash.
+   */
+  getGitHead() {
+    try {
+      return execSync("git rev-parse HEAD", { encoding: "utf-8", timeout: 3e3 }).trim();
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get changes for selective undo, grouped by session.
+   */
+  getChangesGrouped() {
+    this.ensureInit();
+    return [{
+      sessionId: String(this.state.startTime),
+      files: Array.from(this.state.modifiedFiles.keys()),
+      goal: this.state.currentGoal
+    }];
+  }
   ensureInit() {
     if (!this.initialized) {
       this.init({
@@ -567,46 +609,7 @@ No unresolved issues.`;
   }
 };
 var sessionMemory = new SessionMemory();
-function getSessionMemory(topic) {
-  return sessionMemory.getSummary(topic);
-}
-function searchSessionMemory(params) {
-  const { query, limit = 20 } = params;
-  sessionMemory.recordToolCall("search_session_memory", { query, limit });
-  const results = sessionMemory.searchMemory(query, limit);
-  if (results.length === 0) {
-    return `\u{1F50D} **Search Memory** \u2014 No results for "${query}".`;
-  }
-  const lines = [
-    `\u{1F50D} **Search Memory** \u2014 ${results.length} results for "${query}"`,
-    ""
-  ];
-  for (const r of results) {
-    const icon = r.type.startsWith("tool:") ? "\u{1F6E0}\uFE0F" : r.type.startsWith("file:") ? r.type.includes("created") ? "\u2728" : "\u{1F4DD}" : r.type.startsWith("failure") ? "\u274C" : r.type.startsWith("memory") ? "\u{1F9E0}" : r.type === "search" ? "\u{1F50E}" : r.type === "dependency" ? "\u{1F517}" : "\u{1F4C4}";
-    const timeStr = r.timestamp ? new Date(r.timestamp).toLocaleTimeString() : "";
-    lines.push(`${icon} ${timeStr ? `[${timeStr}] ` : ""}${r.content}`);
-  }
-  lines.push("", `\u{1F4A1} Use get_session_memory({topic: "..."}) to load a specific memory topic.`);
-  return lines.join("\n");
-}
-function handleWriteMemory(params) {
-  const { topic, content, mode = "append" } = params;
-  const existing = sessionMemory.getMemoryContent(topic);
-  let finalContent = content;
-  if (mode === "prepend") {
-    finalContent = content + "\n\n" + existing;
-  } else if (mode === "append") {
-    finalContent = existing + "\n\n" + content;
-  }
-  sessionMemory.writeMemory(topic, finalContent);
-  sessionMemory.recordToolCall("write_memory", { topic, mode });
-  return `\u2705 Memory "${topic}" updated (mode: ${mode}).`;
-}
 
 export {
-  SessionMemory,
-  sessionMemory,
-  getSessionMemory,
-  searchSessionMemory,
-  handleWriteMemory
+  sessionMemory
 };

package/dist/chunk-WP3WRPDC.js

@@ -0,0 +1,71 @@
+import {
+  sessionMemory
+} from "./chunk-TT37TE4P.js";
+import {
+  getProjectRoot
+} from "./chunk-IXMWW5WA.js";
+
+// src/utils/kumaShared.ts
+import { execSync } from "child_process";
+function getSessionStats(inputGoal) {
+  const summary = sessionMemory.getSummary();
+  const goal = inputGoal || summary.currentGoal || "";
+  const modifiedFiles = sessionMemory.getModifiedFiles();
+  const toolCalls = sessionMemory.getToolCallHistory(50);
+  const failedFiles = sessionMemory.getFailedFiles();
+  const loop = sessionMemory.detectLoop();
+  return {
+    goal,
+    modifiedFiles,
+    toolCalls,
+    toolCallCount: toolCalls.length,
+    failedFiles,
+    hasLoop: loop.isLooping,
+    loopMessage: loop.message,
+    hasRunTests: toolCalls.some((c) => c.toolName === "execute_safe_test")
+  };
+}
+function getGitDiffStat(timeout = 3e3) {
+  try {
+    const root = getProjectRoot();
+    return execSync("git diff --stat", {
+      cwd: root,
+      encoding: "utf-8",
+      timeout
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+function getUnresolvedCount(failedFiles) {
+  let count = 0;
+  for (const f of failedFiles) {
+    for (const ff of f.failures) {
+      if (!ff.resolved) count++;
+    }
+  }
+  return count;
+}
+function buildDriftMessages(modifiedFiles, hasRunTests, unresolvedCount, gitStat, loopMessage) {
+  const drifts = [];
+  if (modifiedFiles > 0 && !hasRunTests) {
+    drifts.push(`${modifiedFiles} file(s) edited but no test run`);
+  }
+  if (loopMessage) {
+    drifts.push(loopMessage);
+  }
+  if (unresolvedCount > 0) {
+    drifts.push(`${unresolvedCount} unresolved failure(s)`);
+  }
+  if (gitStat) {
+    drifts.push(`Git diff: ${gitStat}`);
+  }
+  return drifts;
+}
+
+export {
+  getSessionStats,
+  getGitDiffStat,
+  getUnresolvedCount,
+  buildDriftMessages
+};