@plumpslabs/kuma 2.3.20 → 2.3.22

package/dist/chunk-LVKOGXLC.js

@@ -1,658 +0,0 @@
-// src/engine/sessionMemory.ts
-import fs from "fs";
-import path from "path";
-import { execSync } from "child_process";
-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();
-    const timestamp = Date.now();
-    this.state.toolCalls.push({
-      toolName,
-      params,
-      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-4XZ5S2LH.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();
-    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).filter((f) => f.endsWith(".md")).slice(0, 3);
-        for (const file of files) {
-          const filePath = path.join(memoriesDir, file);
-          try {
-            const content = fs.readFileSync(filePath, "utf-8");
-            const lines = content.split("\n");
-            const maxLinesPerFile = 500;
-            for (let i = 0; i < Math.min(lines.length, maxLinesPerFile); 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) {
-      const existing = toolCounts.get(call.toolName);
-      const action = call.params.action || "";
-      if (existing) {
-        existing.count++;
-        existing.actions.add(action);
-      } else {
-        toolCounts.set(call.toolName, { count: 1, actions: /* @__PURE__ */ new Set([action]) });
-      }
-    }
-    for (const [toolName, { count, actions }] of toolCounts) {
-      if (count >= 4) {
-        if (actions.size >= 3) continue;
-        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 };
-  }
-  // ============================================================
-  // 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-4XZ5S2LH.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({
-        projectRoot: process.cwd(),
-        startTime: Date.now()
-      });
-    }
-  }
-};
-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 {
-  sessionMemory
-};