@stackmemoryai/stackmemory 1.2.4 → 1.2.7

package/dist/src/integrations/mcp/tool-definitions.js

@@ -14,7 +14,6 @@ class MCPToolDefinitions {
       ...this.getTraceTools(),
       ...this.getDiscoveryTools(),
       ...this.getEditTools(),
-      ...this.getGraphitiTools(),
       ...this.getTeamTools(),
       ...this.getCordTools()
     ];
@@ -283,30 +282,6 @@ class MCPToolDefinitions {
           type: "object",
           properties: {}
         }
-      },
-      {
-        name: "add_task_dependency",
-        description: "Add dependency between tasks",
-        inputSchema: {
-          type: "object",
-          properties: {
-            task_id: {
-              type: "string",
-              description: "Task that depends on another"
-            },
-            depends_on: {
-              type: "string",
-              description: "Task that must be completed first"
-            },
-            dependency_type: {
-              type: "string",
-              enum: ["blocks", "related", "subtask"],
-              default: "blocks",
-              description: "Type of dependency"
-            }
-          },
-          required: ["task_id", "depends_on"]
-        }
       }
     ];
   }
@@ -417,7 +392,7 @@ class MCPToolDefinitions {
     return [
       {
         name: "get_traces",
-        description: "Get execution traces with optional filtering",
+        description: "Get execution traces with optional filtering. Set analyze=true to run pattern analysis instead of listing traces.",
         inputSchema: {
           type: "object",
           properties: {
@@ -444,30 +419,21 @@ class MCPToolDefinitions {
               type: "boolean",
               default: false,
               description: "Include full trace context"
-            }
-          }
-        }
-      },
-      {
-        name: "analyze_traces",
-        description: "Analyze trace patterns for insights",
-        inputSchema: {
-          type: "object",
-          properties: {
+            },
+            analyze: {
+              type: "boolean",
+              default: false,
+              description: "Run analysis on traces instead of listing them"
+            },
             trace_id: {
               type: "string",
-              description: "Specific trace to analyze"
+              description: "Specific trace to analyze (requires analyze=true)"
             },
             analysis_type: {
               type: "string",
               enum: ["performance", "patterns", "errors"],
               default: "performance",
-              description: "Type of analysis to perform"
-            },
-            include_recommendations: {
-              type: "boolean",
-              default: true,
-              description: "Include optimization recommendations"
+              description: "Type of analysis (requires analyze=true)"
             }
           }
         }
@@ -708,55 +674,6 @@ class MCPToolDefinitions {
       }
     ];
   }
-  /**
-   * Graphiti knowledge graph tools
-   */
-  getGraphitiTools() {
-    return [
-      {
-        name: "graphiti_status",
-        description: "Check Graphiti temporal knowledge graph connection status",
-        inputSchema: {
-          type: "object",
-          properties: {}
-        }
-      },
-      {
-        name: "graphiti_query",
-        description: "Query the Graphiti temporal knowledge graph for entities, relations, and episodes",
-        inputSchema: {
-          type: "object",
-          properties: {
-            query: {
-              type: "string",
-              description: "Semantic text query"
-            },
-            entityTypes: {
-              type: "array",
-              items: { type: "string" },
-              description: 'Entity types to filter (e.g., ["Person", "File", "Issue"])'
-            },
-            validFrom: {
-              type: "number",
-              description: "Start of time window (epoch ms)"
-            },
-            validTo: {
-              type: "number",
-              description: "End of time window (epoch ms)"
-            },
-            maxHops: {
-              type: "number",
-              description: "Graph traversal depth (default 2)"
-            },
-            k: {
-              type: "number",
-              description: "Top-k results (default 20)"
-            }
-          }
-        }
-      }
-    ];
-  }
   /**
    * Multi-agent team collaboration tools
    */
@@ -988,8 +905,6 @@ class MCPToolDefinitions {
         return this.getDiscoveryTools();
       case "edit":
         return this.getEditTools();
-      case "graphiti":
-        return this.getGraphitiTools();
       case "team":
         return this.getTeamTools();
       case "cord":

package/dist/src/integrations/ralph/patterns/oracle-worker-pattern.js

@@ -320,9 +320,9 @@ const defaultModelConfigs = {
     {
       tier: "oracle",
       provider: "claude",
-      model: "claude-3-opus-20240229",
-      costPerToken: 0.015,
-      // $15/1M input tokens
+      model: "claude-sonnet-4-5-20250929",
+      costPerToken: 3e-3,
+      // $3/1M input tokens
       capabilities: [
         "strategic_planning",
         "complex_reasoning",
@@ -336,9 +336,9 @@ const defaultModelConfigs = {
     {
       tier: "worker",
       provider: "claude",
-      model: "claude-3-5-haiku-20241022",
-      costPerToken: 25e-5,
-      // $0.25/1M input tokens
+      model: "claude-haiku-4-5-20251001",
+      costPerToken: 8e-4,
+      // $0.80/1M input tokens
       capabilities: [
         "code_implementation",
         "unit_testing",

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

@@ -889,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 {
@@ -931,7 +950,8 @@ class ClaudeSkillsManager {
       "dashboard",
       "api",
       "spec",
-      "agent"
+      "agent",
+      "theory"
     ];
     if (this.rlmOrchestrator) {
       skills.push("rlm", "lint");
@@ -1088,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

@@ -39,6 +39,14 @@ const CANONICAL_HOOKS = [
     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.4",
-  "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.7",
+  "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"
@@ -52,7 +52,7 @@
     "type": "git",
     "url": "https://github.com/stackmemoryai/stackmemory.git"
   },
-  "homepage": "https://github.com/stackmemoryai/stackmemory",
+  "homepage": "https://stackmemoryai.github.io/stackmemory/",
   "bugs": {
     "url": "https://github.com/stackmemoryai/stackmemory/issues"
   },
@@ -63,22 +63,35 @@
   },
   "keywords": [
     "ai",
+    "ai-memory",
+    "ai-coding",
     "memory",
     "context",
+    "context-management",
     "llm",
     "mcp",
+    "mcp-server",
+    "mcp-tools",
+    "model-context-protocol",
     "claude",
     "claude-code",
-    "coding",
+    "codex",
+    "opencode",
+    "coding-assistant",
     "persistence",
+    "session-persistence",
+    "fts5",
+    "full-text-search",
+    "sqlite",
     "skills",
     "hooks",
-    "spec-generator",
     "linear",
+    "linear-integration",
     "task-runner",
-    "prompt-optimization",
-    "model-routing",
-    "agent-orchestration"
+    "agent-orchestration",
+    "multi-agent",
+    "developer-tools",
+    "devtools"
   ],
   "scripts": {
     "start": "node dist/src/integrations/mcp/server.js",

package/templates/claude-hooks/theory-capture.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+
+/**
+ * Theory Capture Hook (PostToolUse)
+ *
+ * Detects writes to THEORY.MD and:
+ *   1. Caches metadata to .stackmemory/theory-cache.json
+ *   2. Fire-and-forget: records a StackMemory frame via CLI
+ *
+ * Must complete in <50ms -- file I/O only, CLI exec is detached.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { spawn } = require('child_process');
+
+const WRITE_TOOLS = ['Edit', 'Write', 'MultiEdit'];
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+function safeWriteFile(filePath, content) {
+  const tmp = filePath + '.tmp';
+  fs.writeFileSync(tmp, content);
+  fs.renameSync(tmp, filePath);
+}
+
+function isTheoryPath(filePath) {
+  if (!filePath) return false;
+  const lower = filePath.toLowerCase();
+  return (
+    lower.endsWith('/theory.md') ||
+    lower.endsWith('\\theory.md') ||
+    lower === 'theory.md'
+  );
+}
+
+async function readInput() {
+  let input = '';
+  for await (const chunk of process.stdin) {
+    input += chunk;
+  }
+  return JSON.parse(input);
+}
+
+async function main() {
+  try {
+    const input = await readInput();
+    const { tool_name, tool_input } = input;
+
+    // Only care about file-write tools
+    if (!WRITE_TOOLS.includes(tool_name)) return;
+
+    const fp = tool_input?.file_path || '';
+    if (!isTheoryPath(fp)) return;
+
+    // Read current content
+    let content;
+    try {
+      content = fs.readFileSync(fp, 'utf-8');
+    } catch {
+      return; // File doesn't exist or unreadable
+    }
+
+    // Cache metadata for next session start
+    const cacheDir = path.join(process.cwd(), '.stackmemory');
+    ensureDir(cacheDir);
+
+    const lineCount = content.split('\n').length;
+    safeWriteFile(
+      path.join(cacheDir, 'theory-cache.json'),
+      JSON.stringify({
+        path: fp,
+        timestamp: new Date().toISOString(),
+        hash: crypto.createHash('md5').update(content).digest('hex'),
+        lineCount,
+      })
+    );
+
+    // Fire-and-forget: record as frame via CLI
+    const child = spawn(
+      'stackmemory',
+      ['context', 'add', 'artifact', `THEORY.MD updated (${lineCount} lines)`],
+      {
+        cwd: process.cwd(),
+        stdio: 'ignore',
+        detached: true,
+      }
+    );
+    child.unref();
+  } catch {
+    // Silent fail -- never block the agent
+  }
+}
+
+main();