stackmem 1.0.5 → 1.0.7

package/dist/scoring.js

@@ -192,6 +192,50 @@ export function buildSummaryContent(cluster) {
         .join("; ");
     return `[${mostCommonType.toUpperCase()} cluster] ${topic}: ${items}`;
 }
+// --- message quality filter ------------------------------------------------
+const LOW_QUALITY_PREFIXES = [
+    "wip", "fix", "update", "misc", "temp", "test", "patch", "minor",
+    "tweak", "change", "stuff", "done", "commit", "save", "ok", "m", "x",
+];
+const SEMVER_RE = /^\d+\.\d+\.\d+$/;
+// Filters out lazy/placeholder messages ("wip", "fix", "m", "...") and bare
+// version bumps ("1.0.4"). Checked against the first word (and the whole
+// message), not a raw prefix match, so a real message like "Migrate auth to
+// JWT" isn't rejected just for starting with the letter "m". The git hook
+// keeps its own inline copy of this same logic since it runs as a standalone
+// script with no access to this module — keep the two in sync by hand if
+// this changes.
+export function isQualityMessage(message) {
+    const trimmed = message.trim();
+    if (trimmed.length < 15)
+        return false;
+    if (SEMVER_RE.test(trimmed))
+        return false;
+    if (!trimmed.includes(" "))
+        return false;
+    const stripped = trimmed.replace(/\s/g, "");
+    if (stripped.length > 0 && new Set(stripped).size === 1)
+        return false;
+    const lowerTrimmed = trimmed.toLowerCase();
+    if (LOW_QUALITY_PREFIXES.includes(lowerTrimmed))
+        return false;
+    const firstWord = (lowerTrimmed.match(/^[a-z0-9]+/) || [""])[0];
+    if (LOW_QUALITY_PREFIXES.includes(firstWord))
+        return false;
+    return true;
+}
+// --- session-end classification ---------------------------------------------
+const FAILURE_PHRASES = ["failed", "didn't work", "reverted", "switched away"];
+export function indicatesFailedApproach(text) {
+    const lower = text.toLowerCase();
+    return FAILURE_PHRASES.some((phrase) => lower.includes(phrase));
+}
+export function isAuthRelatedFile(filePath) {
+    return /(auth|login|session|token)/i.test(filePath);
+}
+export function isCodeFile(filePath) {
+    return /\.(ts|js)$/i.test(filePath);
+}
 // --- task relevance --------------------------------------------------------
 function splitWords(text) {
     return text

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stackmem",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "",
   "main": "index.js",
   "type": "module",

package/src/ast-index.ts

@@ -217,12 +217,23 @@ export function analyzeCodebase(projectPath: string): AnalyzeCodebaseResult {
   const insertImport = db.prepare("INSERT INTO imports (file_id, source) VALUES (?, ?)");
 
   const files = walkProjectFiles(resolvedProjectPath);
+  let filesIndexed = 0;
   let totalFunctions = 0;
   let totalClasses = 0;
 
   const runAll = db.transaction((filePaths: string[]) => {
     for (const filePath of filePaths) {
-      const extraction = extractFile(filePath, resolvedProjectPath);
+      let extraction: FileExtraction;
+      try {
+        extraction = extractFile(filePath, resolvedProjectPath);
+      } catch {
+        // Tree-sitter (or the file read) choked on this file — better-sqlite3
+        // transactions roll back entirely on a throw, so skipping here
+        // (rather than letting it propagate) is what keeps one bad file from
+        // wiping out every other file already processed in this run.
+        continue;
+      }
+
       const row = insertFile.get(
         extraction.relativePath,
         path.basename(extraction.relativePath),
@@ -245,6 +256,8 @@ export function analyzeCodebase(projectPath: string): AnalyzeCodebaseResult {
       for (const source of extraction.imports) {
         insertImport.run(fileId, source);
       }
+
+      filesIndexed++;
     }
   });
 
@@ -252,7 +265,7 @@ export function analyzeCodebase(projectPath: string): AnalyzeCodebaseResult {
   db.close();
 
   return {
-    files_indexed: files.length,
+    files_indexed: filesIndexed,
     functions: totalFunctions,
     classes: totalClasses,
   };

package/src/cli.ts

@@ -14,6 +14,10 @@ import {
   computeMemoryLinks,
   decideSaveAction,
   estimateTokens,
+  indicatesFailedApproach,
+  isAuthRelatedFile,
+  isCodeFile,
+  isQualityMessage,
   scoreMemoryRelevance,
 } from "./scoring.js";
 import { supabase } from "./storage.js";
@@ -43,16 +47,23 @@ function usage(): never {
   cm save [project] <type> <content> [--force]  (type: decision|rejection|constraint|discovery)
   cm fix [project] <problem> <solution>
   cm analyze [project] <path>
-  cm search [project] <query>
+  cm search [--project <name>] <query>
   cm resolve [project] <memory-id>
   cm delete [project] <memory-id>
   cm compress [project]
   cm init <project> <path>
-  cm context [project] <task>
+  cm context [--project <name>] <task>
+  cm session-end [project] [--summary <text>] [--errors <a,b>] [--files <a,b>] [--approaches <a,b>]
+  cm doctor
+  cm undo [project]
+  cm export [filename]
+  cm import [project] <filename>
   cm help
 
   [project] is optional if a .stackmem file exists in the current
-  directory (written by 'cm init'). Otherwise it must be given explicitly.`);
+  directory (written by 'cm init'). Otherwise it must be given explicitly.
+  search/context take --project instead of a positional project, since a
+  bare query/task can't otherwise be told apart from a project name.`);
   process.exit(1);
 }
 
@@ -82,9 +93,10 @@ function cmdHelp() {
       Build an AST index (files, functions, classes) for the codebase
       at <path>.
 
-  cm search [project] <query>
+  cm search [--project <name>] <query>
       Search saved memories and past fixes for a project matching
-      <query>.
+      <query>. The whole query is always the full remaining text — use
+      --project to search a project other than the one in .stackmem.
 
   cm resolve [project] <memory-id>
       Mark a memory as resolved.
@@ -101,10 +113,42 @@ function cmdHelp() {
       the stackmem MCP server with Claude Code, write a CLAUDE.md and
       .stackmem file, and seed initial memories from the project scan.
 
-  cm context [project] <task>
+  cm context [--project <name>] <task>
       Return only the top 5 memories most relevant to a specific
       task, ranked by a blend of task relevance and decay score,
-      as a markdown block capped at a 2000 token budget.
+      as a markdown block capped at a 2000 token budget. Use
+      --project to target a project other than the one in .stackmem.
+
+  cm session-end [project] [--summary <text>] [--errors <a,b>] [--files <a,b>] [--approaches <a,b>]
+      Capture what happened in a session and extract memories: each
+      error becomes an unsolved execution_log entry, each approach
+      containing "failed", "didn't work", "reverted", or "switched
+      away" becomes a rejection, a summary that passes the quality
+      filter becomes a decision, auth-related files become a
+      discovery, and any .ts/.js file triggers an AST re-index.
+      Accepts the same fields as JSON on stdin instead of flags
+      (project, summary, errors_encountered, files_touched,
+      approaches_tried) when stdin is piped rather than a terminal.
+
+  cm doctor
+      Check every integration point in the current directory — backend
+      connection, MCP registration, .stackmem, git hook, and memory
+      count — and report what's working and what's broken.
+
+  cm undo [project]
+      Delete the most recently saved unresolved memory (and any
+      memory_links referencing it) for a project.
+
+  cm export [filename]
+      Export all unresolved memories, execution_log entries, and
+      memory_links for a project to a JSON file. Defaults to
+      <project>-memories.json.
+
+  cm import [project] <filename>
+      Import memories and execution_log entries from a JSON file
+      produced by 'cm export'. Inserted under the current device_id
+      and project; memory_links are skipped and get rebuilt by
+      semantic linking the next time cm save runs.
 
   cm help
       Show this help message.`);
@@ -126,7 +170,22 @@ function readProjectFromFile(): string | null {
   return content.length > 0 ? content : null;
 }
 
+// Catches the common habit-slip of typing `cm fix . "problem" "solution"` by
+// muscle memory from `cm init <project> .` — "." (or "..", or anything
+// path-shaped) is never a real project name, so an explicit arg this shape
+// almost certainly means the caller meant to omit the project entirely.
+function looksLikeAPath(value: string): boolean {
+  return value === "." || value === ".." || value.includes("/") || value.includes("\\");
+}
+
 function requireProject(explicit: string | null): string {
+  if (explicit && looksLikeAPath(explicit)) {
+    console.error(
+      `Warning: '${explicit}' is not a valid project name — reading from .stackmem instead.`
+    );
+    explicit = null;
+  }
+
   if (explicit) return explicit;
 
   const fromFile = readProjectFromFile();
@@ -154,12 +213,23 @@ function splitOptionalProject(
 // arg count can't disambiguate an omitted project from a multi-word query —
 // "cm search bug fix" is ambiguous by count alone. Use .stackmem's presence
 // instead: if it exists, nothing is positionally a project.
+// Arg count can't disambiguate an omitted project from a multi-word query —
+// "cm search bug fix" is ambiguous by count alone. Treating .stackmem's mere
+// presence as "project omitted" (the previous approach) was worse: it
+// silently swallowed an explicit project into the query text whenever a
+// .stackmem file happened to exist in cwd, so "cm search otherproj auth bug"
+// would search project X (from .stackmem) for the literal text "otherproj
+// auth bug" with no error. Positional args are now always the full
+// query/task; an explicit override uses --project <name> instead, which is
+// never ambiguous and is never silently absorbed.
 function splitProjectFromVariadic(args: string[]): { project: string | null; rest: string[] } {
-  if (readProjectFromFile() !== null) {
-    return { project: null, rest: args };
+  const flagIndex = args.indexOf("--project");
+  if (flagIndex !== -1 && args[flagIndex + 1] !== undefined) {
+    const project = args[flagIndex + 1];
+    const rest = [...args.slice(0, flagIndex), ...args.slice(flagIndex + 2)];
+    return { project, rest };
   }
-  const [project = null, ...rest] = args;
-  return { project, rest };
+  return { project: null, rest: args };
 }
 
 // --- cm start ----------------------------------------------------------
@@ -578,13 +648,17 @@ const LOW_QUALITY_PREFIXES = [
   "tweak", "change", "stuff", "done", "commit", "save", "ok", "m", "x",
 ];
 
+const SEMVER_RE = /^\\d+\\.\\d+\\.\\d+$/;
+
 // Filters out lazy/placeholder commit messages ("wip", "fix", "m", "...")
-// so only messages worth remembering become decisions. Checked against the
-// first word, not a raw prefix match, so a real message like "Migrate auth
-// to JWT" isn't rejected just for starting with the letter "m".
+// and bare version bumps ("1.0.4") so only messages worth remembering
+// become decisions. Checked against the first word, not a raw prefix
+// match, so a real message like "Migrate auth to JWT" isn't rejected just
+// for starting with the letter "m".
 function isQualityCommitMessage(message) {
   const trimmed = message.trim();
-  if (trimmed.length <= 20) return false;
+  if (trimmed.length < 15) return false;
+  if (SEMVER_RE.test(trimmed)) return false;
   if (!trimmed.includes(" ")) return false;
 
   const stripped = trimmed.replace(/\\s/g, "");
@@ -934,7 +1008,7 @@ async function cmdInit(project: string, targetPath: string) {
       `stackmem is live. Open Claude Code and ask "what do you know about this project?" to verify.`
     );
   } else {
-    console.log("✗ Backend connection failed — run 'cm doctor' (once we build it)");
+    console.log("✗ Backend connection failed — run 'cm doctor'");
   }
 
   // Written last and deliberately: if a commit (and hence the post-commit
@@ -999,6 +1073,382 @@ async function cmdContext(project: string, task: string) {
   console.log(lines.join("\n"));
 }
 
+// --- cm session-end --------------------------------------------------------
+
+interface SessionEndInput {
+  project: string | null;
+  summary?: string;
+  errors: string[];
+  files: string[];
+  approaches: string[];
+}
+
+function splitCommaList(value: string | undefined): string[] {
+  if (!value) return [];
+  return value
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+// Flags only — stdin JSON is handled separately in cmdSessionEndEntry, since
+// it carries its own full shape (arrays, not comma-joined strings).
+function parseSessionEndFlags(args: string[]): SessionEndInput {
+  let project: string | null = null;
+  let summary: string | undefined;
+  let errors: string[] = [];
+  let files: string[] = [];
+  let approaches: string[] = [];
+
+  let i = 0;
+  if (args[i] && !args[i].startsWith("--")) {
+    project = args[i];
+    i++;
+  }
+
+  for (; i < args.length; i++) {
+    const flag = args[i];
+    const value = args[i + 1];
+    if (flag === "--summary") {
+      summary = value;
+      i++;
+    } else if (flag === "--errors") {
+      errors = splitCommaList(value);
+      i++;
+    } else if (flag === "--files") {
+      files = splitCommaList(value);
+      i++;
+    } else if (flag === "--approaches") {
+      approaches = splitCommaList(value);
+      i++;
+    }
+  }
+
+  return { project, summary, errors, files, approaches };
+}
+
+async function readStdinJson(): Promise<Record<string, unknown> | null> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk as Buffer);
+  }
+  const raw = Buffer.concat(chunks).toString("utf-8").trim();
+  if (!raw) return null;
+
+  try {
+    const parsed = JSON.parse(raw);
+    return typeof parsed === "object" && parsed !== null ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+async function cmdSessionEnd(project: string, input: Omit<SessionEndInput, "project">) {
+  let memoriesSaved = 0;
+  let errorsLogged = 0;
+
+  for (const problem of input.errors) {
+    const { error } = await supabase.from("execution_log").insert({
+      project,
+      problem,
+      solution: null,
+      resolved: false,
+      device_id: getDeviceId(),
+    });
+    if (!error) errorsLogged++;
+  }
+
+  for (const approach of input.approaches) {
+    if (!indicatesFailedApproach(approach)) continue;
+    const { error } = await supabase.from("memories").insert({
+      project,
+      type: "rejection",
+      content: approach,
+      device_id: getDeviceId(),
+    });
+    if (!error) memoriesSaved++;
+  }
+
+  if (input.summary && isQualityMessage(input.summary)) {
+    const { error } = await supabase.from("memories").insert({
+      project,
+      type: "decision",
+      content: input.summary.trim(),
+      device_id: getDeviceId(),
+    });
+    if (!error) memoriesSaved++;
+  }
+
+  const authFiles = input.files.filter(isAuthRelatedFile);
+  if (authFiles.length > 0) {
+    const { error } = await supabase.from("memories").insert({
+      project,
+      type: "discovery",
+      content: `session touched auth files: ${authFiles.join(", ")}`,
+      device_id: getDeviceId(),
+    });
+    if (!error) memoriesSaved++;
+  }
+
+  if (input.files.some(isCodeFile)) {
+    analyzeCodebase(process.cwd());
+  }
+
+  console.log(`Session captured. ${memoriesSaved} memories saved.`);
+  if (errorsLogged > 0) {
+    console.log(`${errorsLogged} error(s) logged to execution_log.`);
+  }
+}
+
+// Dispatches to JSON-from-stdin or flag parsing depending on how the
+// command was invoked — piped input (e.g. from a script) uses JSON; an
+// interactive terminal with no piped stdin uses flags.
+async function cmdSessionEndEntry(args: string[]) {
+  let input: SessionEndInput;
+
+  if (!process.stdin.isTTY) {
+    const json = await readStdinJson();
+    if (json) {
+      input = {
+        project: typeof json.project === "string" ? json.project : null,
+        summary: typeof json.summary === "string" ? json.summary : undefined,
+        errors: Array.isArray(json.errors_encountered) ? json.errors_encountered : [],
+        files: Array.isArray(json.files_touched) ? json.files_touched : [],
+        approaches: Array.isArray(json.approaches_tried) ? json.approaches_tried : [],
+      };
+    } else {
+      input = parseSessionEndFlags(args);
+    }
+  } else {
+    input = parseSessionEndFlags(args);
+  }
+
+  const project = requireProject(input.project);
+  await cmdSessionEnd(project, {
+    summary: input.summary,
+    errors: input.errors,
+    files: input.files,
+    approaches: input.approaches,
+  });
+}
+
+// --- cm doctor ---------------------------------------------------------
+
+async function cmdDoctor() {
+  let issues = 0;
+  const project = readProjectFromFile();
+
+  // 1. Backend connection
+  const backendOk = await verifyBackendConnection(project ?? "");
+  if (backendOk) {
+    console.log("✓ Backend connection verified");
+  } else {
+    console.log("✗ Backend connection failed — check your network");
+    issues++;
+  }
+
+  // 2. MCP server registration
+  const claudeConfigPath = nodePath.join(nodeOs.homedir(), ".claude.json");
+  let mcpRegistered = false;
+  if (nodeFs.existsSync(claudeConfigPath)) {
+    try {
+      const config = JSON.parse(nodeFs.readFileSync(claudeConfigPath, "utf-8"));
+      mcpRegistered = Boolean(config?.mcpServers?.stackmem);
+    } catch {
+      mcpRegistered = false;
+    }
+  }
+  if (mcpRegistered) {
+    console.log("✓ MCP server registered with Claude Code");
+  } else {
+    console.log("✗ MCP server not registered — run 'cm init <project> .'");
+    issues++;
+  }
+
+  // 3. Project file
+  if (project) {
+    console.log(`✓ Project file found: ${project}`);
+  } else {
+    console.log("✗ No .stackmem found — run 'cm init <project> .'");
+    issues++;
+  }
+
+  // 4. Git hook
+  const gitDir = nodePath.join(process.cwd(), ".git");
+  if (!nodeFs.existsSync(gitDir)) {
+    console.log("✗ No git repo found in current directory");
+    issues++;
+  } else {
+    const hookPath = nodePath.join(gitDir, "hooks", "post-commit");
+    let hookExecutable = false;
+    if (nodeFs.existsSync(hookPath)) {
+      try {
+        nodeFs.accessSync(hookPath, nodeFs.constants.X_OK);
+        hookExecutable = true;
+      } catch {
+        hookExecutable = false;
+      }
+    }
+    if (hookExecutable) {
+      console.log("✓ Git hook installed");
+    } else {
+      console.log("✗ Git hook not installed — run 'cm init <project> .'");
+      issues++;
+    }
+  }
+
+  // 5. Memory count
+  if (project) {
+    const { count, error } = await supabase
+      .from("memories")
+      .select("id", { count: "exact", head: true })
+      .eq("project", project)
+      .eq("resolved", false);
+
+    if (!error && (count ?? 0) > 0) {
+      console.log(`✓ ${count} memories stored for "${project}"`);
+    } else {
+      console.log(`✗ No memories yet — make a commit to start capturing`);
+      issues++;
+    }
+  } else {
+    console.log(`✗ No memories yet — make a commit to start capturing`);
+    issues++;
+  }
+
+  console.log("");
+  if (issues === 0) {
+    console.log("All systems operational.");
+  } else {
+    console.log(`${issues} issue(s) found. See above.`);
+  }
+}
+
+// --- cm undo -------------------------------------------------------------
+
+async function cmdUndo(project: string) {
+  const { data, error } = await supabase
+    .from("memories")
+    .select("*")
+    .eq("project", project)
+    .eq("resolved", false)
+    .order("created_at", { ascending: false })
+    .limit(1);
+
+  if (error) fail(`Failed to load most recent memory: ${error.message}`);
+
+  const memory = (data ?? [])[0];
+  if (!memory) {
+    console.log("Nothing to undo.");
+    return;
+  }
+
+  const { error: linksError } = await supabase
+    .from("memory_links")
+    .delete()
+    .or(`source_id.eq.${memory.id},target_id.eq.${memory.id}`);
+
+  if (linksError) fail(`Failed to delete memory links: ${linksError.message}`);
+
+  const { error: deleteError } = await supabase.from("memories").delete().eq("id", memory.id);
+
+  if (deleteError) fail(`Failed to delete memory: ${deleteError.message}`);
+
+  console.log(`Undone: [${memory.type}] ${memory.content}`);
+}
+
+// --- cm export -------------------------------------------------------------
+
+async function cmdExport(project: string, filename?: string) {
+  const { data: memories, error: memoriesError } = await supabase
+    .from("memories")
+    .select("*")
+    .eq("project", project)
+    .eq("resolved", false);
+
+  if (memoriesError) fail(`Failed to load memories: ${memoriesError.message}`);
+
+  const { data: executionLog, error: executionLogError } = await supabase
+    .from("execution_log")
+    .select("*")
+    .eq("project", project);
+
+  if (executionLogError) fail(`Failed to load execution log: ${executionLogError.message}`);
+
+  const memoryResults = memories ?? [];
+  const memoryIds = memoryResults.map((m) => m.id);
+
+  let memoryLinks: unknown[] = [];
+  if (memoryIds.length > 0) {
+    const idList = memoryIds.join(",");
+    const { data: links, error: linksError } = await supabase
+      .from("memory_links")
+      .select("*")
+      .or(`source_id.in.(${idList}),target_id.in.(${idList})`);
+
+    if (linksError) fail(`Failed to load memory links: ${linksError.message}`);
+    memoryLinks = links ?? [];
+  }
+
+  const exportData = {
+    project,
+    exported_at: new Date().toISOString(),
+    memories: memoryResults,
+    execution_log: executionLog ?? [],
+    memory_links: memoryLinks,
+  };
+
+  const outputFilename = filename ?? `${project}-memories.json`;
+  nodeFs.writeFileSync(outputFilename, JSON.stringify(exportData, null, 2), "utf-8");
+
+  console.log(`Exported ${memoryResults.length} memories to ${outputFilename}`);
+}
+
+// --- cm import -------------------------------------------------------------
+
+async function cmdImport(project: string, filename: string) {
+  if (!nodeFs.existsSync(filename)) {
+    console.log(`File not found: ${filename}`);
+    return;
+  }
+
+  let parsed: any;
+  try {
+    parsed = JSON.parse(nodeFs.readFileSync(filename, "utf-8"));
+  } catch (error) {
+    fail(`Failed to parse ${filename}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+
+  const memories = Array.isArray(parsed.memories) ? parsed.memories : [];
+  const executionLogEntries = Array.isArray(parsed.execution_log) ? parsed.execution_log : [];
+
+  // memory_links are intentionally skipped — they get rebuilt by semantic
+  // linking the next time cm save runs against the imported memories.
+
+  let importedCount = 0;
+  for (const memory of memories) {
+    const { error } = await supabase.from("memories").insert({
+      project,
+      type: memory.type,
+      content: memory.content,
+      device_id: getDeviceId(),
+    });
+    if (!error) importedCount++;
+  }
+
+  for (const entry of executionLogEntries) {
+    await supabase.from("execution_log").insert({
+      project,
+      problem: entry.problem,
+      solution: entry.solution ?? null,
+      resolved: entry.resolved ?? false,
+      device_id: getDeviceId(),
+    });
+  }
+
+  console.log(`Imported ${importedCount} memories from ${filename}`);
+}
+
 // --- main --------------------------------------------------------------
 
 async function main() {
@@ -1094,6 +1544,36 @@ async function main() {
       await cmdContext(project, split.rest.join(" "));
       break;
     }
+    case "session-end": {
+      await cmdSessionEndEntry(args);
+      break;
+    }
+    case "doctor": {
+      await cmdDoctor();
+      break;
+    }
+    case "undo": {
+      const split = splitOptionalProject(args, 0);
+      if (!split) usage();
+      const project = requireProject(split.project);
+      await cmdUndo(project);
+      break;
+    }
+    case "export": {
+      if (args.length > 1) usage();
+      const [filename] = args;
+      const project = requireProject(null);
+      await cmdExport(project, filename);
+      break;
+    }
+    case "import": {
+      const split = splitOptionalProject(args, 1);
+      if (!split) usage();
+      const project = requireProject(split.project);
+      const [filename] = split.rest;
+      await cmdImport(project, filename);
+      break;
+    }
     case "help": {
       cmdHelp();
       break;