@plumpslabs/kuma 2.1.8 → 2.2.0

package/dist/chunk-QPVPFUCQ.js

@@ -0,0 +1,612 @@
+// src/engine/sessionMemory.ts
+import fs from "fs";
+import path from "path";
+var SessionMemory = class {
+  state;
+  initialized = false;
+  init(config) {
+    const kumaDir = path.join(config.projectRoot, ".kuma");
+    const sessionFile = path.join(kumaDir, "memory.json");
+    const oldFile = path.join(kumaDir, ".kuma-memory.json");
+    if (fs.existsSync(oldFile) && !fs.existsSync(sessionFile)) {
+      try {
+        fs.renameSync(oldFile, sessionFile);
+        console.error("[SessionMemory] Migrated .kuma-memory.json \u2192 memory.json");
+      } catch {
+      }
+    }
+    const oldSessionFile = path.join(kumaDir, "session.json");
+    if (fs.existsSync(oldSessionFile) && !fs.existsSync(sessionFile)) {
+      try {
+        fs.renameSync(oldSessionFile, sessionFile);
+        console.error("[SessionMemory] Migrated session.json \u2192 memory.json");
+      } catch {
+      }
+    }
+    if (fs.existsSync(sessionFile)) {
+      try {
+        const raw = fs.readFileSync(sessionFile, "utf-8");
+        const parsed = JSON.parse(raw);
+        this.state = {
+          projectRoot: parsed.projectRoot || config.projectRoot,
+          startTime: parsed.startTime || config.startTime,
+          currentGoal: parsed.currentGoal || "",
+          completedSteps: parsed.completedSteps || [],
+          modifiedFiles: new Map(parsed.modifiedFiles || []),
+          failedFiles: new Map(parsed.failedFiles || []),
+          searchResults: new Map(parsed.searchResults || []),
+          dependencyGraph: new Map(parsed.dependencyGraph || []),
+          toolCalls: parsed.toolCalls || [],
+          conventions: parsed.conventions
+        };
+        this.initialized = true;
+        console.error(`[SessionMemory] Loaded persistent session memory.json`);
+        return;
+      } catch (err) {
+        console.error(`[SessionMemory] Failed to load persistent session: ${err}. Re-initializing.`);
+      }
+    }
+    this.state = {
+      projectRoot: config.projectRoot,
+      startTime: config.startTime,
+      currentGoal: "",
+      completedSteps: [],
+      modifiedFiles: /* @__PURE__ */ new Map(),
+      failedFiles: /* @__PURE__ */ new Map(),
+      searchResults: /* @__PURE__ */ new Map(),
+      dependencyGraph: /* @__PURE__ */ new Map(),
+      toolCalls: []
+    };
+    this.initialized = true;
+    this.save();
+    this.ensureMemoriesDir();
+    console.error(`[SessionMemory] Initialized at ${new Date(config.startTime).toISOString()}`);
+  }
+  memoriesDir() {
+    return path.join(this.state.projectRoot, ".kuma", "memories");
+  }
+  ensureMemoriesDir() {
+    const dir = this.memoriesDir();
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  }
+  memoryFilePath(topic) {
+    return path.join(this.memoriesDir(), `${topic}.md`);
+  }
+  getMemoryContent(topic) {
+    this.ensureInit();
+    this.ensureMemoriesDir();
+    const filePath = this.memoryFilePath(topic);
+    if (fs.existsSync(filePath)) {
+      return fs.readFileSync(filePath, "utf-8");
+    }
+    return this.generateMemory(topic);
+  }
+  writeMemory(topic, content) {
+    this.ensureInit();
+    this.ensureMemoriesDir();
+    this.writeMemoryFile(topic, content);
+  }
+  writeMemoryFile(topic, content) {
+    const filePath = this.memoryFilePath(topic);
+    fs.writeFileSync(filePath, content, "utf-8");
+  }
+  generateMemory(topic) {
+    switch (topic) {
+      case "architecture":
+        return this.generateArchitectureMd();
+      case "conventions":
+        return this.generateConventionsMd();
+      case "known-issues":
+        return this.generateKnownIssuesMd();
+      default:
+        return `# ${topic}
+
+(empty)`;
+    }
+  }
+  generateArchitectureMd() {
+    const conv = this.state.conventions;
+    if (!conv) return `# Architecture
+
+Run project_conventions first to auto-generate.`;
+    const stackKeys = ["framework", "projectType", "monorepo", "buildTool", "packageManager"];
+    const lines = [
+      "# Architecture",
+      "",
+      `Generated at ${(/* @__PURE__ */ new Date()).toISOString()}`,
+      "",
+      "## Stack",
+      ""
+    ];
+    for (const key of stackKeys) {
+      if (conv[key] !== void 0) {
+        lines.push(`- **${key}**: ${JSON.stringify(conv[key])}`);
+      }
+    }
+    lines.push("", "## Project Layout", "");
+    if (conv.workspaces) {
+      lines.push(`- Monorepo workspaces: ${JSON.stringify(conv.workspaces)}`);
+    }
+    lines.push(`- Source root: ${conv.srcDir || "src/"}`);
+    return lines.join("\n");
+  }
+  generateConventionsMd() {
+    const conv = this.state.conventions;
+    if (!conv) return `# Conventions
+
+Run project_conventions first to auto-generate.`;
+    const styleKeys = ["testRunner", "styling", "importAlias", "lintConfig", "codeStyle"];
+    const lines = [
+      "# Conventions",
+      "",
+      `Generated at ${(/* @__PURE__ */ new Date()).toISOString()}`,
+      "",
+      "## Code Style",
+      ""
+    ];
+    for (const key of styleKeys) {
+      if (conv[key] !== void 0) {
+        lines.push(`- **${key}**: ${JSON.stringify(conv[key])}`);
+      }
+    }
+    if (conv.testRunner) {
+      lines.push("", `## Testing
+
+- Test runner: ${conv.testRunner}`);
+    }
+    if (conv.importAlias) {
+      lines.push("", `## Imports
+
+- Alias: \`${conv.importAlias}\``);
+    }
+    return lines.join("\n");
+  }
+  generateKnownIssuesMd() {
+    const allFailures = this.getFailedFiles();
+    const unresolved = allFailures.filter((f) => f.failures.some((ff) => !ff.resolved));
+    if (unresolved.length === 0) return `# Known Issues
+
+No unresolved issues.`;
+    const lines = [
+      "# Known Issues",
+      "",
+      `Generated at ${(/* @__PURE__ */ new Date()).toISOString()}`,
+      ""
+    ];
+    for (const f of unresolved) {
+      lines.push(`## ${f.task}`);
+      for (const ff of f.failures) {
+        if (!ff.resolved) {
+          lines.push(`- ${new Date(ff.timestamp).toISOString()}: ${ff.error}`);
+        }
+      }
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+  save() {
+    if (!this.initialized || !this.state) return;
+    try {
+      const kumaDir = path.join(this.state.projectRoot, ".kuma");
+      if (!fs.existsSync(kumaDir)) {
+        fs.mkdirSync(kumaDir, { recursive: true });
+      }
+      const serialized = {
+        projectRoot: this.state.projectRoot,
+        startTime: this.state.startTime,
+        currentGoal: this.state.currentGoal,
+        completedSteps: this.state.completedSteps,
+        modifiedFiles: Array.from(this.state.modifiedFiles.entries()),
+        failedFiles: Array.from(this.state.failedFiles.entries()),
+        searchResults: Array.from(this.state.searchResults.entries()),
+        dependencyGraph: Array.from(this.state.dependencyGraph.entries()),
+        toolCalls: this.state.toolCalls,
+        conventions: this.state.conventions
+      };
+      fs.writeFileSync(path.join(kumaDir, "memory.json"), JSON.stringify(serialized, null, 2), "utf-8");
+    } catch (err) {
+      console.error(`[SessionMemory] Failed to save session: ${err}`);
+    }
+  }
+  setGoal(goal) {
+    this.ensureInit();
+    this.state.currentGoal = goal;
+    this.save();
+  }
+  addCompletedStep(step) {
+    this.ensureInit();
+    if (!this.state.completedSteps.includes(step)) {
+      this.state.completedSteps.push(step);
+      this.save();
+    }
+  }
+  addModifiedFile(filePath) {
+    this.ensureInit();
+    const existing = this.state.modifiedFiles.get(filePath);
+    if (existing) {
+      existing.modifiedAt = Date.now();
+      existing.status = "modified";
+    } else {
+      this.state.modifiedFiles.set(filePath, {
+        filePath,
+        modifiedAt: Date.now(),
+        status: "modified"
+      });
+    }
+    this.save();
+  }
+  addCreatedFile(filePath) {
+    this.ensureInit();
+    this.state.modifiedFiles.set(filePath, {
+      filePath,
+      modifiedAt: Date.now(),
+      status: "created"
+    });
+    this.save();
+  }
+  addFailedFile(task, error) {
+    this.ensureInit();
+    const trimmedError = error?.trim() ?? "";
+    if (!trimmedError) return;
+    const truncatedError = trimmedError.substring(0, 500);
+    const failures = this.state.failedFiles.get(task) ?? [];
+    const lastUnresolved = [...failures].reverse().find((f) => !f.resolved);
+    if (lastUnresolved && lastUnresolved.error === truncatedError) return;
+    failures.push({
+      task,
+      error: truncatedError,
+      timestamp: Date.now(),
+      resolved: false
+    });
+    this.state.failedFiles.set(task, failures);
+    this.save();
+    this.ensureMemoriesDir();
+    this.writeMemoryFile("known-issues", this.generateKnownIssuesMd());
+  }
+  markFailureResolved(task) {
+    this.ensureInit();
+    const failures = this.state.failedFiles.get(task);
+    if (failures) {
+      let changed = false;
+      for (const f of failures) {
+        if (!f.resolved) {
+          f.resolved = true;
+          changed = true;
+        }
+      }
+      if (changed) {
+        this.save();
+        this.ensureMemoriesDir();
+        this.writeMemoryFile("known-issues", this.generateKnownIssuesMd());
+      }
+    }
+  }
+  addSearchResult(query, files) {
+    this.ensureInit();
+    this.state.searchResults.set(query, files);
+    this.save();
+  }
+  addDependency(file, dependsOn) {
+    this.ensureInit();
+    const deps = this.state.dependencyGraph.get(file) ?? [];
+    if (!deps.includes(dependsOn)) {
+      deps.push(dependsOn);
+      this.state.dependencyGraph.set(file, deps);
+      this.save();
+    }
+  }
+  recordToolCall(toolName, params) {
+    this.ensureInit();
+    this.state.toolCalls.push({
+      toolName,
+      params,
+      timestamp: Date.now()
+    });
+    if (this.state.toolCalls.length > 100) {
+      this.state.toolCalls = this.state.toolCalls.slice(-100);
+    }
+    this.save();
+  }
+  setConventions(conventions) {
+    this.ensureInit();
+    this.state.conventions = conventions;
+    this.save();
+    this.ensureMemoriesDir();
+    this.writeMemoryFile("architecture", this.generateArchitectureMd());
+    this.writeMemoryFile("conventions", this.generateConventionsMd());
+  }
+  // ============================================================
+  // KEYWORD SEARCH — Search session memory content
+  // ============================================================
+  /**
+   * Load previous session data into current session.
+   * Called by kuma_init() to hydrate conventions, failures, and modified files
+   * from a prior session stored in memory.json.
+   */
+  loadSession() {
+    this.ensureInit();
+    const kumaDir = path.join(this.state.projectRoot, ".kuma");
+    const sessionFile = path.join(kumaDir, "memory.json");
+    if (!fs.existsSync(sessionFile)) {
+      return { hasPrevSession: false, toolCallCount: 0, hasConventions: !!this.state.conventions };
+    }
+    try {
+      const raw = fs.readFileSync(sessionFile, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (!this.state.conventions && parsed.conventions) {
+        this.state.conventions = parsed.conventions;
+      }
+      const prevFailed = parsed.failedFiles;
+      if (prevFailed) {
+        for (const [task, failures] of prevFailed) {
+          for (const f of failures) {
+            if (!f.resolved) {
+              const existing = this.state.failedFiles.get(task);
+              if (!existing?.some((ef) => ef.error === f.error)) {
+                this.state.failedFiles.set(task, [...existing || [], f]);
+              }
+            }
+          }
+        }
+      }
+      const prevModified = parsed.modifiedFiles;
+      if (prevModified) {
+        for (const [filePath, mod] of prevModified) {
+          if (!this.state.modifiedFiles.has(filePath)) {
+            this.state.modifiedFiles.set(filePath, {
+              filePath,
+              modifiedAt: mod.modifiedAt,
+              status: mod.status
+            });
+          }
+        }
+      }
+      const prevSearch = parsed.searchResults;
+      if (prevSearch) {
+        for (const [query, files] of prevSearch) {
+          if (!this.state.searchResults.has(query)) {
+            this.state.searchResults.set(query, files);
+          }
+        }
+      }
+      const toolCallCount = parsed.toolCalls?.length ?? 0;
+      this.save();
+      return {
+        hasPrevSession: true,
+        toolCallCount,
+        hasConventions: !!this.state.conventions
+      };
+    } catch {
+      return { hasPrevSession: false, toolCallCount: 0, hasConventions: !!this.state.conventions };
+    }
+  }
+  /**
+   * Search through tool call history, memory files, search results,
+   * errors, and file modifications for a keyword.
+   */
+  searchMemory(query, limit = 20) {
+    this.ensureInit();
+    const results = [];
+    const q = query.toLowerCase();
+    for (const call of this.state.toolCalls) {
+      const paramStr = JSON.stringify(call.params);
+      if (call.toolName.toLowerCase().includes(q) || paramStr.toLowerCase().includes(q)) {
+        results.push({
+          type: `tool:${call.toolName}`,
+          content: `${call.toolName}(${JSON.stringify(call.params).substring(0, 200)})`,
+          timestamp: call.timestamp
+        });
+      }
+    }
+    for (const [queryStr, files] of this.state.searchResults) {
+      if (queryStr.toLowerCase().includes(q) || files.some((f) => f.toLowerCase().includes(q))) {
+        results.push({
+          type: "search",
+          content: `Query: "${queryStr}" \u2192 ${files.slice(0, 5).join(", ")}${files.length > 5 ? ` (+${files.length - 5} more)` : ""}`
+        });
+      }
+    }
+    for (const [, mod] of this.state.modifiedFiles) {
+      if (mod.filePath.toLowerCase().includes(q)) {
+        results.push({
+          type: `file:${mod.status}`,
+          content: `${mod.status.toUpperCase()}: ${mod.filePath}`,
+          timestamp: mod.modifiedAt
+        });
+      }
+    }
+    for (const [task, failures] of this.state.failedFiles) {
+      for (const f of failures) {
+        if (task.toLowerCase().includes(q) || f.error.toLowerCase().includes(q)) {
+          results.push({
+            type: `failure:${task}`,
+            content: `[${f.resolved ? "RESOLVED" : "UNRESOLVED"}] ${task}: ${f.error.substring(0, 200)}`,
+            timestamp: f.timestamp
+          });
+        }
+      }
+    }
+    for (const [file, deps] of this.state.dependencyGraph) {
+      if (file.toLowerCase().includes(q)) {
+        results.push({
+          type: "dependency",
+          content: `${file} depends on: ${deps.join(", ")}`
+        });
+      }
+    }
+    const memoriesDir = this.memoriesDir();
+    if (fs.existsSync(memoriesDir)) {
+      try {
+        const files = fs.readdirSync(memoriesDir);
+        for (const file of files) {
+          if (!file.endsWith(".md")) continue;
+          const filePath = path.join(memoriesDir, file);
+          try {
+            const content = fs.readFileSync(filePath, "utf-8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+              if (lines[i].toLowerCase().includes(q)) {
+                const topicName = file.replace(/\.md$/, "");
+                results.push({
+                  type: `memory:${topicName}`,
+                  content: `[${topicName}] L${i + 1}: ${lines[i].trim().substring(0, 150)}`
+                });
+                if (results.filter((r) => r.type.startsWith("memory")).length >= 5) break;
+              }
+            }
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+    results.sort((a, b) => {
+      if (a.timestamp && b.timestamp) return b.timestamp - a.timestamp;
+      if (a.timestamp) return -1;
+      if (b.timestamp) return 1;
+      return 0;
+    });
+    return results.slice(0, limit);
+  }
+  getConventions() {
+    this.ensureInit();
+    return this.state.conventions;
+  }
+  pruneMemory() {
+    this.ensureInit();
+    this.state.toolCalls = this.state.toolCalls.slice(-3);
+    this.state.searchResults.clear();
+    this.state.completedSteps = [];
+    this.save();
+  }
+  getSummary(topic) {
+    this.ensureInit();
+    if (topic) {
+      const content = this.getMemoryContent(topic);
+      return { topic, content };
+    }
+    const unresolvedFailures = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const [, failures] of this.state.failedFiles) {
+      for (const f of failures) {
+        if (f.resolved) continue;
+        const error = f.error.substring(0, 200);
+        if (!error.trim()) continue;
+        const key = `${f.task}::${error}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        unresolvedFailures.push({ task: f.task, error });
+      }
+    }
+    const hasMemories = fs.existsSync(this.memoriesDir());
+    let availableMemories = [];
+    if (hasMemories) {
+      try {
+        availableMemories = fs.readdirSync(this.memoriesDir()).filter((f) => f.endsWith(".md")).map((f) => f.replace(/\.md$/, ""));
+      } catch {
+      }
+    }
+    return {
+      projectRoot: this.state.projectRoot,
+      sessionDuration: Math.round((Date.now() - this.state.startTime) / 1e3) + "s",
+      currentGoal: this.state.currentGoal,
+      completedSteps: this.state.completedSteps,
+      modifiedFiles: Array.from(this.state.modifiedFiles.values()),
+      unresolvedFailures,
+      toolCallCount: this.state.toolCalls.length,
+      recentSearches: Array.from(this.state.searchResults.keys()).slice(-5),
+      hasConventions: !!this.state.conventions,
+      ...availableMemories.length > 0 ? { availableMemories } : {},
+      ...availableMemories.length > 0 ? { hint: `Use get_session_memory({ topic: "<name>" }) to load a specific memory. Topics: ${availableMemories.join(", ")}` } : {}
+    };
+  }
+  getModifiedFiles() {
+    this.ensureInit();
+    return Array.from(this.state.modifiedFiles.values());
+  }
+  getFailedFiles() {
+    this.ensureInit();
+    const result = [];
+    for (const [task, failures] of this.state.failedFiles) {
+      result.push({ task, failures });
+    }
+    return result;
+  }
+  getToolCallHistory(limit = 10) {
+    this.ensureInit();
+    return this.state.toolCalls.slice(-limit);
+  }
+  detectLoop() {
+    this.ensureInit();
+    const recentCalls = this.state.toolCalls.slice(-10);
+    if (recentCalls.length < 6) return { isLooping: false };
+    const toolCounts = /* @__PURE__ */ new Map();
+    for (const call of recentCalls) {
+      toolCounts.set(call.toolName, (toolCounts.get(call.toolName) ?? 0) + 1);
+    }
+    for (const [toolName, count] of toolCounts) {
+      if (count >= 4) {
+        return {
+          isLooping: true,
+          toolName,
+          message: `Detected potential loop: "${toolName}" called ${count} times in last ${recentCalls.length} tool calls. Consider a different approach.`
+        };
+      }
+    }
+    return { isLooping: false };
+  }
+  ensureInit() {
+    if (!this.initialized) {
+      this.init({
+        projectRoot: process.cwd(),
+        startTime: Date.now()
+      });
+    }
+  }
+};
+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
+};