@stackmemoryai/stackmemory 1.2.2 → 1.2.6

package/dist/src/integrations/ralph/visualization/ralph-debugger.js

@@ -27,7 +27,10 @@ class RalphDebugger {
       await sessionManager.initialize();
       const session = await sessionManager.getOrCreateSession({});
       if (session.database) {
-        this.frameManager = new FrameManager(session.database, session.projectId);
+        this.frameManager = new FrameManager(
+          session.database,
+          session.projectId
+        );
       }
       logger.info("Debugger initialized successfully");
     } catch (error) {
@@ -111,7 +114,10 @@ class RalphDebugger {
         contextSize: iter.contextSize,
         phase: iter.phase
       })),
-      totalDuration: session.performance.iterationTimes.reduce((sum, time) => sum + time, 0)
+      totalDuration: session.performance.iterationTimes.reduce(
+        (sum, time) => sum + time,
+        0
+      )
     };
     const html = await this.generateTimelineHTML(timeline);
     const timelinePath = path.join(".ralph-debug", `timeline-${loopId}.html`);
@@ -165,7 +171,10 @@ class RalphDebugger {
     diagram.metrics = {
       totalNodes: diagram.nodes.length,
       totalEdges: diagram.edges.length,
-      avgContextSize: session.performance.contextSizes.length > 0 ? session.performance.contextSizes.reduce((sum, size) => sum + size, 0) / session.performance.contextSizes.length : 0,
+      avgContextSize: session.performance.contextSizes.length > 0 ? session.performance.contextSizes.reduce(
+        (sum, size) => sum + size,
+        0
+      ) / session.performance.contextSizes.length : 0,
       maxContextSize: Math.max(...session.performance.contextSizes)
     };
     return diagram;
@@ -230,15 +239,24 @@ class RalphDebugger {
   async updatePerformanceMetrics(session) {
     const currentMemory = process.memoryUsage().heapUsed;
     session.performance.memoryUsage.push(currentMemory);
-    session.performance.peakMemory = Math.max(session.performance.peakMemory, currentMemory);
+    session.performance.peakMemory = Math.max(
+      session.performance.peakMemory,
+      currentMemory
+    );
     const contextSize = await this.calculateContextSize(session.ralphDir);
     session.performance.contextSizes.push(contextSize);
     if (session.performance.iterationTimes.length > 0) {
-      session.performance.averageIterationTime = session.performance.iterationTimes.reduce((sum, time) => sum + time, 0) / session.performance.iterationTimes.length;
+      session.performance.averageIterationTime = session.performance.iterationTimes.reduce(
+        (sum, time) => sum + time,
+        0
+      ) / session.performance.iterationTimes.length;
     }
     if (session.performance.contextSizes.length > 0) {
       const avgContextSize = session.performance.contextSizes.reduce((sum, size) => sum + size, 0) / session.performance.contextSizes.length;
-      session.performance.contextEfficiency = Math.max(0, 1 - avgContextSize / 1e4);
+      session.performance.contextEfficiency = Math.max(
+        0,
+        1 - avgContextSize / 1e4
+      );
     }
   }
   /**
@@ -246,8 +264,13 @@ class RalphDebugger {
    */
   async generateSummary(session) {
     const totalIterations = session.iterations.length;
-    const successfulIterations = session.iterations.filter((i) => i.success).length;
-    const totalDuration = session.performance.iterationTimes.reduce((sum, time) => sum + time, 0);
+    const successfulIterations = session.iterations.filter(
+      (i) => i.success
+    ).length;
+    const totalDuration = session.performance.iterationTimes.reduce(
+      (sum, time) => sum + time,
+      0
+    );
     return {
       loopId: session.loopId,
       totalIterations,
@@ -271,18 +294,26 @@ class RalphDebugger {
     const avgDuration = durations.reduce((sum, d) => sum + d, 0) / durations.length;
     if (durations.some((d) => d > avgDuration * 2)) {
       patterns.push("Variable iteration times detected");
-      insights.push("Some iterations took significantly longer than average - investigate bottlenecks");
+      insights.push(
+        "Some iterations took significantly longer than average - investigate bottlenecks"
+      );
     }
-    const consecutiveFailures = this.findConsecutiveFailures(session.iterations);
+    const consecutiveFailures = this.findConsecutiveFailures(
+      session.iterations
+    );
     if (consecutiveFailures.length > 2) {
       patterns.push("Multiple consecutive failures detected");
-      insights.push("Consider adjusting approach or criteria after consecutive failures");
+      insights.push(
+        "Consider adjusting approach or criteria after consecutive failures"
+      );
     }
     if (session.performance.contextSizes.length > 1) {
       const contextGrowth = session.performance.contextSizes[session.performance.contextSizes.length - 1] - session.performance.contextSizes[0];
       if (contextGrowth > 1e3) {
         patterns.push("Significant context growth");
-        insights.push("Context is growing rapidly - consider context pruning strategies");
+        insights.push(
+          "Context is growing rapidly - consider context pruning strategies"
+        );
       }
     }
     return { patterns, insights };
@@ -292,9 +323,14 @@ class RalphDebugger {
    */
   async analyzeContextFlow(session) {
     return {
-      avgContextSize: session.performance.contextSizes.length > 0 ? session.performance.contextSizes.reduce((sum, size) => sum + size, 0) / session.performance.contextSizes.length : 0,
+      avgContextSize: session.performance.contextSizes.length > 0 ? session.performance.contextSizes.reduce(
+        (sum, size) => sum + size,
+        0
+      ) / session.performance.contextSizes.length : 0,
       maxContextSize: Math.max(...session.performance.contextSizes),
-      contextGrowthRate: this.calculateGrowthRate(session.performance.contextSizes),
+      contextGrowthRate: this.calculateGrowthRate(
+        session.performance.contextSizes
+      ),
       efficiency: session.performance.contextEfficiency
     };
   }
@@ -303,7 +339,9 @@ class RalphDebugger {
    */
   async analyzePerformance(session) {
     return {
-      memoryEfficiency: this.calculateMemoryEfficiency(session.performance.memoryUsage),
+      memoryEfficiency: this.calculateMemoryEfficiency(
+        session.performance.memoryUsage
+      ),
       iterationEfficiency: session.performance.averageIterationTime,
       resourceUtilization: {
         cpu: "N/A",
@@ -318,7 +356,10 @@ class RalphDebugger {
    */
   async generateVisualization(session) {
     const htmlContent = await this.generateVisualizationHTML(session);
-    const vizPath = path.join(".ralph-debug", `visualization-${session.loopId}.html`);
+    const vizPath = path.join(
+      ".ralph-debug",
+      `visualization-${session.loopId}.html`
+    );
     await fs.mkdir(path.dirname(vizPath), { recursive: true });
     await fs.writeFile(vizPath, htmlContent);
     return {
@@ -343,17 +384,25 @@ class RalphDebugger {
   async generateRecommendations(session) {
     const recommendations = [];
     if (session.performance.averageIterationTime > 3e4) {
-      recommendations.push("Consider breaking down complex tasks into smaller iterations");
+      recommendations.push(
+        "Consider breaking down complex tasks into smaller iterations"
+      );
     }
     if (session.performance.contextEfficiency < 0.7) {
-      recommendations.push("Optimize context management - consider using context budgeting");
+      recommendations.push(
+        "Optimize context management - consider using context budgeting"
+      );
     }
     const successRate = session.iterations.filter((i) => i.success).length / Math.max(1, session.iterations.length);
     if (successRate < 0.5) {
-      recommendations.push("Low success rate detected - review task criteria and approach");
+      recommendations.push(
+        "Low success rate detected - review task criteria and approach"
+      );
     }
     if (session.performance.peakMemory > 500 * 1024 * 1024) {
-      recommendations.push("High memory usage detected - investigate memory leaks");
+      recommendations.push(
+        "High memory usage detected - investigate memory leaks"
+      );
     }
     return recommendations;
   }
@@ -450,14 +499,16 @@ class RalphDebugger {
 <body>
     <h1>${timeline.title}</h1>
     <div class="timeline">
-        ${timeline.iterations.map((iter) => `
+        ${timeline.iterations.map(
+      (iter) => `
             <div class="iteration ${iter.success ? "success" : "failure"}">
                 <h3>Iteration ${iter.iteration}</h3>
                 <p>Duration: ${iter.duration}ms</p>
                 <p>Changes: ${iter.changes} | Errors: ${iter.errors}</p>
                 <p>Context Size: ${iter.contextSize}</p>
             </div>
-        `).join("")}
+        `
+    ).join("")}
     </div>
 </body>
 </html>

package/dist/src/skills/claude-skills.js

@@ -3,9 +3,6 @@ import { dirname as __pathDirname } from 'path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import { logger } from "../core/monitoring/logger.js";
-import {
-  RepoIngestionSkill
-} from "./repo-ingestion-skill.js";
 import {
   RecursiveAgentOrchestrator
 } from "./recursive-agent-orchestrator.js";
@@ -617,22 +614,6 @@ class ClaudeSkillsManager {
       this.dashboardLauncher = new module.DashboardLauncherSkill();
       logger.info("Dashboard launcher initialized (manual launch required)");
     });
-    const chromaConfig = {
-      apiKey: process.env["CHROMADB_API_KEY"] || "",
-      tenant: process.env["CHROMADB_TENANT"] || "",
-      database: process.env["CHROMADB_DATABASE"] || "stackmemory",
-      collectionName: process.env["CHROMADB_COLLECTION"] || "stackmemory_repos"
-    };
-    if (chromaConfig.apiKey && chromaConfig.tenant) {
-      this.repoIngestionSkill = new RepoIngestionSkill(
-        chromaConfig,
-        context.userId,
-        process.env["CHROMADB_TEAM_ID"]
-      );
-      this.repoIngestionSkill.initialize().catch((error) => {
-        logger.warn("Repo ingestion skill initialization failed:", error);
-      });
-    }
     import("../features/tasks/linear-task-manager.js").then((module) => {
       const taskStore = new module.LinearTaskManager();
       const frameManager = context.frameManager;
@@ -662,7 +643,6 @@ class ClaudeSkillsManager {
   checkpointSkill;
   archaeologistSkill;
   dashboardLauncher;
-  repoIngestionSkill = null;
   rlmOrchestrator = null;
   apiSkill;
   specGeneratorSkill;
@@ -738,64 +718,6 @@ class ClaudeSkillsManager {
           };
         }
         return this.rlmOrchestrator.execute(args[0], options);
-      case "repo":
-      case "ingest":
-        if (!this.repoIngestionSkill) {
-          return {
-            success: false,
-            message: "Repo ingestion skill not initialized. Please configure ChromaDB."
-          };
-        }
-        const repoCommand = args[0];
-        switch (repoCommand) {
-          case "ingest":
-            const repoPath = args[1] || process.cwd();
-            const repoName = args[2] || path.basename(repoPath);
-            return await this.repoIngestionSkill.ingestRepository(
-              repoPath,
-              repoName,
-              options
-            );
-          case "update":
-            const updatePath = args[1] || process.cwd();
-            const updateName = args[2] || path.basename(updatePath);
-            return await this.repoIngestionSkill.updateRepository(
-              updatePath,
-              updateName,
-              options
-            );
-          case "search":
-            const query = args[1];
-            if (!query) {
-              return {
-                success: false,
-                message: "Search query required"
-              };
-            }
-            const results = await this.repoIngestionSkill.searchCode(query, {
-              repoName: options?.repoName,
-              language: options?.language,
-              limit: options?.limit,
-              includeContext: options?.includeContext
-            });
-            return {
-              success: true,
-              message: `Found ${results.length} results`,
-              data: results
-            };
-          case "stats":
-            const stats = await this.repoIngestionSkill.getRepoStats(args[1]);
-            return {
-              success: true,
-              message: "Repository statistics",
-              data: stats
-            };
-          default:
-            return {
-              success: false,
-              message: `Unknown repo command: ${repoCommand}. Use: ingest, update, search, or stats`
-            };
-        }
       case "dashboard":
         const dashboardCmd = args[0];
         if (!this.dashboardLauncher) {
@@ -967,6 +889,25 @@ class ClaudeSkillsManager {
             };
         }
       }
+      case "theory": {
+        const { TheorySkill } = await import("./theory-skill.js");
+        const theorySkill = new TheorySkill(this.context);
+        switch (args[0]) {
+          case "show":
+            return theorySkill.show();
+          case "update":
+            return theorySkill.update(args.slice(1).join(" "));
+          case "init":
+            return theorySkill.init(args.slice(1).join(" "));
+          case "status":
+            return theorySkill.status();
+          default:
+            return {
+              success: false,
+              message: "Usage: theory show|init|update|status"
+            };
+        }
+      }
       case "linear-run": {
         if (!this.linearTaskRunner) {
           return {
@@ -1009,11 +950,9 @@ class ClaudeSkillsManager {
       "dashboard",
       "api",
       "spec",
-      "agent"
+      "agent",
+      "theory"
     ];
-    if (this.repoIngestionSkill) {
-      skills.push("repo");
-    }
     if (this.rlmOrchestrator) {
       skills.push("rlm", "lint");
     }
@@ -1097,27 +1036,6 @@ Launch the StackMemory web dashboard for real-time monitoring
 - launch: Start the web dashboard and open in browser (default)
 - stop: Stop the dashboard server
 Auto-launches on new sessions when configured
-`;
-      case "repo":
-        return `
-/repo ingest [path] [name] [--incremental] [--include-tests] [--include-docs]
-/repo update [path] [name] [--force-update]
-/repo search "query" [--repo-name name] [--language lang] [--limit n]
-/repo stats [repo-name]
-
-Ingest and search code repositories in ChromaDB:
-- ingest: Index a new repository (defaults to current directory)
-- update: Update an existing repository with changes
-- search: Semantic search across ingested code
-- stats: View statistics about ingested repositories
-
-Options:
-- --incremental: Only process changed files
-- --include-tests: Include test files in indexing
-- --include-docs: Include documentation files
-- --force-update: Force re-indexing of all files
-- --language: Filter search by programming language
-- --limit: Maximum search results (default: 20)
 `;
       case "recursive":
         return `
@@ -1190,6 +1108,22 @@ Options:
 Each agent runs in a disposable /tmp workspace (git clone --depth=1).
 Patches: git apply .stackmemory/patches/<file>.patch
 Spec branches: cd /tmp/sm-spec-* && git log --oneline
+`;
+      case "theory":
+        return `
+/theory show
+/theory init "<problem statement>"
+/theory update "<full content>"
+/theory status
+
+Maintain a living THEORY.MD at repo root \u2014 a narrative operating theory:
+  show   \u2014 Display current THEORY.MD content
+  init   \u2014 Create THEORY.MD with scaffold sections
+  update \u2014 Overwrite THEORY.MD (validates length, warns on anti-patterns)
+  status \u2014 Show metadata: exists, line count, sections, last modified
+
+Sections: Problem, Operating Theory, Strategy, Key Discoveries, Open Questions
+Based on Theorist by @blader (MIT).
 `;
       case "linear-run":
         return `

package/dist/src/skills/theory-skill.js

@@ -0,0 +1,191 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import * as fs from "fs";
+import * as path from "path";
+import { execSync } from "child_process";
+import { logger } from "../core/monitoring/logger.js";
+const THEORY_FILE = "THEORY.MD";
+const MIN_CONTENT_LENGTH = 100;
+const MAX_LINE_WARNING = 200;
+const TEMPLATE_SECTIONS = [
+  "## Problem",
+  "## Operating Theory",
+  "## Strategy",
+  "## Key Discoveries",
+  "## Open Questions"
+];
+function getGitRoot() {
+  try {
+    return execSync("git rev-parse --show-toplevel", {
+      encoding: "utf-8",
+      timeout: 5e3
+    }).trim();
+  } catch {
+    return void 0;
+  }
+}
+function generateTemplate(problemStatement) {
+  return `# THEORY.MD
+
+## Problem
+
+${problemStatement}
+
+## Operating Theory
+
+_What is your current mental model of how this system works or should work?_
+
+## Strategy
+
+_What approach are you taking and why?_
+
+## Key Discoveries
+
+_What have you learned that changed your thinking?_
+
+## Open Questions
+
+_What don't you know yet? What assumptions need validation?_
+`;
+}
+class TheorySkill {
+  constructor(context) {
+    this.context = context;
+    this.rootDir = getGitRoot() || process.cwd();
+  }
+  rootDir;
+  get theoryPath() {
+    return path.join(this.rootDir, THEORY_FILE);
+  }
+  show() {
+    if (!fs.existsSync(this.theoryPath)) {
+      return {
+        success: false,
+        message: `No ${THEORY_FILE} found. Run \`theory init "<problem>"\` to create one.`
+      };
+    }
+    const content = fs.readFileSync(this.theoryPath, "utf-8");
+    return {
+      success: true,
+      message: content,
+      data: { path: this.theoryPath, length: content.length }
+    };
+  }
+  init(problemStatement) {
+    if (!problemStatement || problemStatement.trim().length === 0) {
+      return {
+        success: false,
+        message: "A problem statement is required to initialize THEORY.MD."
+      };
+    }
+    if (fs.existsSync(this.theoryPath)) {
+      return {
+        success: false,
+        message: `${THEORY_FILE} already exists at ${this.theoryPath}. Use \`theory update\` to modify it.`
+      };
+    }
+    const content = generateTemplate(problemStatement.trim());
+    fs.writeFileSync(this.theoryPath, content, "utf-8");
+    logger.info("Created THEORY.MD", { path: this.theoryPath });
+    return {
+      success: true,
+      message: `Created ${THEORY_FILE} at ${this.theoryPath}`,
+      data: { path: this.theoryPath, sections: TEMPLATE_SECTIONS }
+    };
+  }
+  update(content) {
+    if (!content || content.trim().length === 0) {
+      return { success: false, message: "Content is required for update." };
+    }
+    if (content.trim().length < MIN_CONTENT_LENGTH) {
+      return {
+        success: false,
+        message: `Content too short (${content.trim().length} chars). THEORY.MD should be at least ${MIN_CONTENT_LENGTH} characters to be meaningful.`
+      };
+    }
+    const warnings = [];
+    if (/\[[ x]\]/i.test(content)) {
+      warnings.push(
+        "Contains checkboxes \u2014 THEORY.MD is narrative, not a checklist."
+      );
+    }
+    if (/\d{4}-\d{2}-\d{2}/.test(content)) {
+      warnings.push(
+        "Contains dates \u2014 THEORY.MD captures current thinking, not a changelog."
+      );
+    }
+    const lineCount = content.split("\n").length;
+    if (lineCount > MAX_LINE_WARNING) {
+      warnings.push(
+        `${lineCount} lines is long. Consider distilling to keep THEORY.MD focused.`
+      );
+    }
+    fs.writeFileSync(this.theoryPath, content, "utf-8");
+    if (this.context.frameManager) {
+      try {
+        const frameId = this.context.frameManager.createFrame(
+          "write",
+          "theory-update",
+          { source: THEORY_FILE, length: content.length }
+        );
+        this.context.frameManager.addEvent(
+          "artifact",
+          {
+            type: "theory-update",
+            path: this.theoryPath,
+            length: content.length,
+            lineCount
+          },
+          frameId
+        );
+        this.context.frameManager.closeFrame(frameId, {
+          theory_updated: true
+        });
+      } catch (err) {
+        logger.warn("Failed to record theory update frame", { error: err });
+      }
+    }
+    logger.info("Updated THEORY.MD", {
+      path: this.theoryPath,
+      length: content.length
+    });
+    const message = warnings.length > 0 ? `Updated ${THEORY_FILE}. Warnings:
+${warnings.map((w) => `  - ${w}`).join("\n")}` : `Updated ${THEORY_FILE} (${lineCount} lines)`;
+    return {
+      success: true,
+      message,
+      data: { path: this.theoryPath, lineCount, warnings }
+    };
+  }
+  status() {
+    if (!fs.existsSync(this.theoryPath)) {
+      return {
+        success: true,
+        message: `No ${THEORY_FILE} found.`,
+        data: { exists: false }
+      };
+    }
+    const content = fs.readFileSync(this.theoryPath, "utf-8");
+    const lines = content.split("\n");
+    const stat = fs.statSync(this.theoryPath);
+    const sections = TEMPLATE_SECTIONS.filter((s) => content.includes(s));
+    return {
+      success: true,
+      message: `${THEORY_FILE}: ${lines.length} lines, ${sections.length}/${TEMPLATE_SECTIONS.length} sections`,
+      data: {
+        exists: true,
+        path: this.theoryPath,
+        lineCount: lines.length,
+        charCount: content.length,
+        sections,
+        totalSections: TEMPLATE_SECTIONS.length,
+        lastModified: stat.mtime.toISOString()
+      }
+    };
+  }
+}
+export {
+  TheorySkill
+};

package/dist/src/utils/hook-installer.js

@@ -31,6 +31,22 @@ const CANONICAL_HOOKS = [
     timeout: 2,
     commandPrefix: "node",
     required: true
+  },
+  {
+    scriptName: "cord-trace.js",
+    eventType: "PostToolUse",
+    matcher: "mcp__.*__cord_(spawn|fork|complete|ask|tree)",
+    timeout: 2,
+    commandPrefix: "node",
+    required: true
+  },
+  {
+    scriptName: "theory-capture.js",
+    eventType: "PostToolUse",
+    matcher: "Edit|Write|MultiEdit",
+    timeout: 2,
+    commandPrefix: "node",
+    required: false
   }
 ];
 const DEAD_HOOKS = ["sms-response-handler.js"];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stackmemoryai/stackmemory",
-  "version": "1.2.2",
-  "description": "Project-scoped memory for AI coding tools. Durable context across sessions with MCP integration, frames, smart retrieval, Claude Code skills, and automatic hooks.",
+  "version": "1.2.6",
+  "description": "Project-scoped memory for AI coding tools. Durable context across sessions with 32 MCP tools, FTS5 search, Claude/Codex/OpenCode wrappers, Linear sync, automatic hooks, and log analysis.",
   "engines": {
     "node": ">=20.0.0",
     "npm": ">=10.0.0"
@@ -87,8 +87,8 @@
     "postinstall": "node scripts/install-claude-hooks-auto.js || true",
     "init": "node dist/scripts/initialize.js",
     "build": "rm -rf dist && node esbuild.config.js",
-    "lint": "eslint src/**/*.ts scripts/**/*.ts",
-    "lint:fix": "eslint src/**/*.ts scripts/**/*.ts --fix --max-warnings=-1",
+    "lint": "eslint 'src/**/*.ts' 'scripts/**/*.ts'",
+    "lint:fix": "eslint 'src/**/*.ts' 'scripts/**/*.ts' --fix --max-warnings=-1",
     "lint:fast": "oxlint src scripts",
     "format": "prettier --write src/**/*.ts scripts/**/*.ts",
     "test": "vitest",
@@ -121,6 +121,7 @@
     "daemon:status": "node dist/cli/index.js daemon status",
     "sync:start": "node scripts/background-sync-manager.js",
     "sync:setup": "./scripts/setup-background-sync.sh",
+    "eval:cord": "npx tsx scripts/evals/cord-vs-flat-eval.ts",
     "prepare": "echo 'Prepare step completed'",
     "verify:dist": "node scripts/verify-dist.cjs",
     "test:smoke-db": "bash scripts/smoke-init-db.sh",
@@ -197,7 +198,6 @@
     "@xenova/transformers": "^2.17.2",
     "blessed": "^0.1.81",
     "blessed-contrib": "^4.11.0",
-    "chokidar": "^5.0.0",
-    "chromadb": "^3.2.2"
+    "chokidar": "^5.0.0"
   }
 }

package/scripts/install-claude-hooks-auto.js

@@ -81,6 +81,14 @@ try {
       commandPrefix: 'node',
       required: true,
     },
+    {
+      scriptName: 'cord-trace.js',
+      eventType: 'PostToolUse',
+      matcher: 'mcp__.*__cord_(spawn|fork|complete|ask|tree)',
+      timeout: 2,
+      commandPrefix: 'node',
+      required: true,
+    },
   ];
 
   const DEAD_HOOKS = ['sms-response-handler.js'];