@stackmemoryai/stackmemory 1.10.4 → 1.12.0

package/dist/src/mcp/stackmemory-mcp-server.js

@@ -18,6 +18,10 @@ import {
 import { FrameManager } from "../core/context/index.js";
 import { AgentTaskManager } from "../agents/core/agent-task-manager.js";
 import { logger } from "../core/monitoring/logger.js";
+import { ContentCache } from "../core/cache/content-cache.js";
+import { getSkillPackRegistry } from "../core/skill-packs/index.js";
+import { ProvenanceStore } from "../core/provenance/provenance-store.js";
+import { scoreConfidence } from "../core/provenance/confidence-scorer.js";
 const PROJECT_ROOT = process.env["STACKMEMORY_PROJECT"] || process.cwd();
 const stackmemoryDir = join(PROJECT_ROOT, ".stackmemory");
 if (!existsSync(stackmemoryDir)) {
@@ -27,6 +31,11 @@ const db = new Database(join(stackmemoryDir, "cache.db"));
 const taskStore = new LinearTaskManager(PROJECT_ROOT, db);
 const frameManager = new FrameManager(db, PROJECT_ROOT, void 0);
 const agentTaskManager = new AgentTaskManager(taskStore, frameManager);
+const contentCacheDb = new Database(join(stackmemoryDir, "content-cache.db"));
+const contentCache = new ContentCache(contentCacheDb);
+const provenanceDb = new Database(join(stackmemoryDir, "provenance.db"));
+const provenanceStore = new ProvenanceStore(provenanceDb);
+const packRegistry = getSkillPackRegistry();
 let _claudeSessionId = null;
 let claudeFrameId = null;
 const TOOLS = [
@@ -182,6 +191,137 @@ const TOOLS = [
       },
       required: ["sessionId"]
     }
+  },
+  // ── Content Cache ───────────────────────────────────────────────────
+  {
+    name: "cache_lookup",
+    description: "Check if content has been seen before. Returns cache hit/miss and token savings.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        content: { type: "string", description: "Content to check/cache" },
+        source: {
+          type: "string",
+          description: 'Where this content came from (e.g. "file:src/index.ts")'
+        }
+      },
+      required: ["content"]
+    }
+  },
+  {
+    name: "cache_stats",
+    description: "Get content cache statistics: total entries, tokens cached, tokens saved, hit rate.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  // ── Skill Packs ─────────────────────────────────────────────────────
+  {
+    name: "pack_list",
+    description: "List installed skill packs, optionally filtered by namespace.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: {
+          type: "string",
+          description: 'Filter by namespace (e.g. "coding", "ops")'
+        }
+      }
+    }
+  },
+  {
+    name: "pack_search",
+    description: "Search installed skill packs by keyword.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search keyword" }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "pack_get",
+    description: "Get full details of a skill pack including instructions and MCP tools.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: 'Pack name (e.g. "coding/typescript-react")'
+        }
+      },
+      required: ["name"]
+    }
+  },
+  // ── Provenance ──────────────────────────────────────────────────────
+  {
+    name: "record_trace",
+    description: "Record a provenance-tracked trace event with actor, operation, and source lineage.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        traceId: { type: "string", description: "Unique trace ID" },
+        sessionId: { type: "string", description: "Session ID" },
+        tenantId: { type: "string", description: "Tenant ID" },
+        operation: {
+          type: "string",
+          description: 'What happened (e.g. "query", "decision", "edit")'
+        },
+        host: {
+          type: "string",
+          description: 'Agent host (e.g. "claude-code", "cursor")'
+        },
+        inputs: { type: "object", description: "Operation inputs" },
+        outputs: { type: "object", description: "Operation outputs" },
+        tokensIn: { type: "number", description: "Input tokens" },
+        tokensOut: { type: "number", description: "Output tokens" },
+        costUsd: { type: "number", description: "Cost in USD" },
+        parentTraceId: { type: "string", description: "Parent trace ID" },
+        score: { type: "number", description: "Numeric evaluation score" },
+        feedback: {
+          type: "string",
+          description: "Textual feedback for optimization"
+        },
+        confidence: {
+          type: "number",
+          description: "Confidence level (0-1)",
+          minimum: 0,
+          maximum: 1
+        },
+        sources: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              system: { type: "string" },
+              externalId: { type: "string" },
+              url: { type: "string" }
+            },
+            required: ["system", "externalId"]
+          },
+          description: "Source references for provenance"
+        }
+      },
+      required: ["traceId", "sessionId", "tenantId", "operation"]
+    }
+  },
+  {
+    name: "score_confidence",
+    description: "Score text for decision confidence. Returns confidence (0-1), signals, and classification (accept/review/discard).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        text: { type: "string", description: "Text to score" },
+        actor: { type: "string", description: "Who said it (boosts score)" },
+        replyCount: {
+          type: "number",
+          description: "Thread reply count (boosts if >2)"
+        }
+      },
+      required: ["text"]
+    }
   }
 ];
 const server = new Server(
@@ -500,6 +640,179 @@ Ready for next action.`
           ]
         };
       }
+      // ── Content Cache handlers ──────────────────────────────────────
+      case "cache_lookup": {
+        const { content, source } = args;
+        const result = contentCache.lookup(content, source ?? "mcp");
+        if (!result.hit) {
+          contentCache.put(content, source ?? "mcp");
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.hit ? `Cache HIT (hash: ${result.hash.slice(0, 12)}...). Tokens saved: ${result.tokensSaved}. Total hits: ${result.entry?.hitCount ?? 0}.` : `Cache MISS (hash: ${result.hash.slice(0, 12)}...). Content cached for future dedup.`
+            }
+          ]
+        };
+      }
+      case "cache_stats": {
+        const stats = contentCache.getStats();
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Content Cache Stats:
+  Entries: ${stats.totalEntries}
+  Tokens cached: ${stats.totalTokensCached}
+  Tokens saved: ${stats.totalTokensSaved}
+  Hit rate: ${(stats.hitRate * 100).toFixed(1)}%
+  Top sources: ${stats.topSources.map((s) => `${s.source} (${s.tokensSaved} saved)`).join(", ") || "none"}`
+            }
+          ]
+        };
+      }
+      // ── Skill Pack handlers ─────────────────────────────────────────
+      case "pack_list": {
+        const { namespace } = args;
+        const packs = packRegistry.list(namespace ? { namespace } : void 0);
+        if (packs.length === 0) {
+          return {
+            content: [{ type: "text", text: "No packs installed." }]
+          };
+        }
+        const list = packs.map((p) => {
+          const tools = p.manifest.mcp?.tools?.length ?? 0;
+          return `- ${p.manifest.name} v${p.manifest.version} (${tools} tools) \u2014 ${p.manifest.description}`;
+        }).join("\n");
+        return {
+          content: [
+            {
+              type: "text",
+              text: `${packs.length} pack(s) installed:
+${list}`
+            }
+          ]
+        };
+      }
+      case "pack_search": {
+        const { query } = args;
+        const results = packRegistry.search(query);
+        if (results.length === 0) {
+          return {
+            content: [{ type: "text", text: `No packs matching "${query}".` }]
+          };
+        }
+        const list = results.map(
+          (p) => `- ${p.manifest.name} v${p.manifest.version} \u2014 ${p.manifest.description}`
+        ).join("\n");
+        return {
+          content: [
+            {
+              type: "text",
+              text: `${results.length} result(s) for "${query}":
+${list}`
+            }
+          ]
+        };
+      }
+      case "pack_get": {
+        const { name: packName } = args;
+        const pack = packRegistry.get(packName);
+        if (!pack) {
+          return {
+            content: [{ type: "text", text: `Pack "${packName}" not found.` }]
+          };
+        }
+        const m = pack.manifest;
+        const tools = m.mcp?.tools?.map((t) => `  - ${t.name}: ${t.description}`).join("\n");
+        const examples = m.examples?.map((e) => `  Q: ${e.input}
+  A: ${e.output}`).join("\n\n");
+        return {
+          content: [
+            {
+              type: "text",
+              text: [
+                `${m.name} v${m.version}`,
+                m.description,
+                `Author: ${m.author} | License: ${m.license}`,
+                `Runtime: ${m.runtime?.type ?? "local"}`,
+                tools ? `
+MCP Tools:
+${tools}` : "",
+                examples ? `
+Examples:
+${examples}` : "",
+                pack.instructions ? `
+Instructions:
+${pack.instructions}` : ""
+              ].filter(Boolean).join("\n")
+            }
+          ]
+        };
+      }
+      // ── Provenance handlers ─────────────────────────────────────────
+      case "record_trace": {
+        const a = args;
+        const event = {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          traceId: a["traceId"],
+          sessionId: a["sessionId"],
+          tenantId: a["tenantId"],
+          operation: a["operation"],
+          actor: {
+            host: a["host"] || "unknown",
+            agent: "mcp",
+            user: "unknown"
+          },
+          inputs: a["inputs"] ?? null,
+          outputs: a["outputs"] ?? null,
+          tokensIn: a["tokensIn"] || 0,
+          tokensOut: a["tokensOut"] || 0,
+          costUsd: a["costUsd"] || 0,
+          provenance: {
+            sources: (a["sources"] || []).map((s) => ({
+              system: s["system"] ?? "",
+              externalId: s["externalId"] ?? "",
+              url: s["url"],
+              fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+            })),
+            derivation: [],
+            confidence: a["confidence"] || 0
+          }
+        };
+        if (a["parentTraceId"]) {
+          event.parentTraceId = a["parentTraceId"];
+        }
+        if (a["score"] !== void 0) {
+          event.score = a["score"];
+        }
+        if (a["feedback"]) {
+          event.feedback = a["feedback"];
+        }
+        provenanceStore.record(event);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Trace recorded: ${event.traceId} (${event.operation}, confidence: ${event.provenance.confidence})`
+            }
+          ]
+        };
+      }
+      case "score_confidence": {
+        const { text, actor, replyCount } = args;
+        const result = scoreConfidence(text, { actor, replyCount });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Confidence: ${result.confidence.toFixed(2)} (${result.classification})
+Signals: ${JSON.stringify(result.signals)}`
+            }
+          ]
+        };
+      }
       default:
         throw new Error(`Unknown tool: ${name}`);
     }
@@ -542,6 +855,8 @@ process.on("SIGINT", async () => {
     }
   }
   db.close();
+  contentCacheDb.close();
+  provenanceDb.close();
   process.exit(0);
 });
 main().catch((error) => {

package/dist/src/orchestrators/multimodal/determinism.js

@@ -0,0 +1,243 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { createHash } from "crypto";
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync
+} from "fs";
+import { join } from "path";
+import { compactPlan } from "./utils.js";
+import { runSpike } from "./harness.js";
+const DETERMINISM_WATCH_PATTERNS = [
+  "src/orchestrators/multimodal",
+  "src/cli/commands/bench.ts",
+  "src/cli/index.ts",
+  "src/core/monitoring/logger.ts"
+];
+const DETERMINISM_WATCH_IGNORE = [
+  ".git/**",
+  "node_modules/**",
+  "dist/**",
+  "build/**",
+  ".next/**",
+  ".turbo/**",
+  "coverage/**",
+  ".stackmemory/**"
+];
+function stableStringify(value) {
+  return JSON.stringify(canonicalize(value));
+}
+function canonicalize(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => canonicalize(item));
+  }
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).sort(
+      ([a], [b]) => a.localeCompare(b)
+    );
+    return Object.fromEntries(
+      entries.map(([key, entryValue]) => [key, canonicalize(entryValue)])
+    );
+  }
+  return value;
+}
+function hashValue(value) {
+  return createHash("sha256").update(stableStringify(value)).digest("hex");
+}
+function modeAgreement(values) {
+  if (values.length === 0) return 1;
+  const counts = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    counts.set(value, (counts.get(value) || 0) + 1);
+  }
+  const maxCount = Math.max(...counts.values());
+  return maxCount / values.length;
+}
+function normalizeResult(result) {
+  return {
+    plan: compactPlan(result.plan),
+    critique: canonicalize(result.critique),
+    implementation: {
+      success: result.implementation.success,
+      summary: result.implementation.summary,
+      commands: [...result.implementation.commands || []]
+    },
+    iterations: (result.iterations || []).map((iteration) => ({
+      command: iteration.command,
+      ok: iteration.ok,
+      critique: canonicalize(iteration.critique),
+      outputPreviewHash: hashValue(iteration.outputPreview)
+    }))
+  };
+}
+function estimateContextTokens(result) {
+  const normalized = normalizeResult(result);
+  return Math.ceil(stableStringify(normalized).length / 4);
+}
+function toSnapshot(result, index) {
+  const normalized = normalizeResult(result);
+  return {
+    index,
+    approved: result.critique.approved,
+    iterations: (result.iterations || []).length,
+    planHash: hashValue(compactPlan(result.plan)),
+    critiqueHash: hashValue(canonicalize(result.critique)),
+    commandsHash: hashValue(result.implementation.commands || []),
+    resultHash: hashValue(normalized),
+    contextTokens: estimateContextTokens(result)
+  };
+}
+function computeNumericStability(values) {
+  if (values.length <= 1) return 1;
+  const min = Math.min(...values);
+  const max = Math.max(...values);
+  if (max === min) return 1;
+  return Math.max(0, 1 - (max - min) / Math.max(max, 1));
+}
+function scoreReport(snapshots) {
+  const dimensions = [
+    {
+      name: "result",
+      weight: 40,
+      score: modeAgreement(snapshots.map((item) => item.resultHash)) * 100,
+      details: "Full normalized result hash agreement"
+    },
+    {
+      name: "plan",
+      weight: 20,
+      score: modeAgreement(snapshots.map((item) => item.planHash)) * 100,
+      details: "Plan structure hash agreement"
+    },
+    {
+      name: "critique",
+      weight: 15,
+      score: modeAgreement(snapshots.map((item) => item.critiqueHash)) * 100,
+      details: "Critique hash agreement"
+    },
+    {
+      name: "commands",
+      weight: 10,
+      score: modeAgreement(snapshots.map((item) => item.commandsHash)) * 100,
+      details: "Implementer command sequence agreement"
+    },
+    {
+      name: "iterations",
+      weight: 10,
+      score: modeAgreement(snapshots.map((item) => item.iterations)) * 100,
+      details: "Retry-count agreement"
+    },
+    {
+      name: "context_tokens",
+      weight: 5,
+      score: computeNumericStability(snapshots.map((item) => item.contextTokens)) * 100,
+      details: "Token-footprint stability"
+    }
+  ];
+  const weightedScore = dimensions.reduce((sum, dimension) => {
+    return sum + dimension.score * dimension.weight;
+  }, 0);
+  const totalWeight = dimensions.reduce(
+    (sum, dimension) => sum + dimension.weight,
+    0
+  );
+  const score = totalWeight > 0 ? weightedScore / totalWeight : 0;
+  const recommendations = [];
+  if (dimensions[0].score < 100) {
+    recommendations.push(
+      "Pin planner/critic outputs behind deterministic fixtures or replay traces."
+    );
+  }
+  if (dimensions[1].score < 100) {
+    recommendations.push(
+      "Canonicalize plan generation further and remove any model-dependent fields from smoke checks."
+    );
+  }
+  if (dimensions[4].score < 100) {
+    recommendations.push(
+      "Tighten retry rules so the same failure mode produces the same iteration count."
+    );
+  }
+  if (dimensions[5].score < 100) {
+    recommendations.push(
+      "Reduce context assembly drift by sorting symbols and fixing token accounting."
+    );
+  }
+  return {
+    runs: snapshots.length,
+    score: Math.round(score * 100) / 100,
+    snapshots,
+    dimensions,
+    recommendations
+  };
+}
+async function runDeterminismSmoke(input, options = {}) {
+  const runs = Math.max(1, options.runs ?? 5);
+  const snapshots = [];
+  for (let index = 0; index < runs; index++) {
+    const result = await runSpike(input, {
+      ...options,
+      dryRun: options.dryRun ?? true,
+      deterministicFixture: options.deterministicFixture ?? true,
+      persistAudit: false,
+      record: false,
+      recordFrame: false
+    });
+    snapshots.push(toSnapshot(result, index + 1));
+  }
+  return scoreReport(snapshots);
+}
+function getDeterminismWatchTargets(repoPath) {
+  const existingTargets = DETERMINISM_WATCH_PATTERNS.filter(
+    (target) => existsSync(join(repoPath, target))
+  );
+  if (existingTargets.length > 0) {
+    return existingTargets;
+  }
+  return ["."];
+}
+function getDeterminismDir(repoPath) {
+  return join(repoPath, ".stackmemory", "determinism");
+}
+function persistDeterminismReport(repoPath, report, meta) {
+  const dir = getDeterminismDir(repoPath);
+  mkdirSync(dir, { recursive: true });
+  const stored = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    task: meta.task,
+    trigger: meta.trigger,
+    changedPaths: meta.changedPaths || [],
+    report
+  };
+  writeFileSync(
+    join(dir, "latest.json"),
+    JSON.stringify(stored, null, 2) + "\n"
+  );
+  appendFileSync(join(dir, "history.jsonl"), JSON.stringify(stored) + "\n");
+  return stored;
+}
+function readLatestDeterminismReport(repoPath) {
+  const latestPath = join(getDeterminismDir(repoPath), "latest.json");
+  if (!existsSync(latestPath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(
+      readFileSync(latestPath, "utf8")
+    );
+  } catch {
+    return null;
+  }
+}
+export {
+  DETERMINISM_WATCH_IGNORE,
+  DETERMINISM_WATCH_PATTERNS,
+  getDeterminismWatchTargets,
+  persistDeterminismReport,
+  readLatestDeterminismReport,
+  runDeterminismSmoke
+};