@stitchdb/cli 0.6.0 → 0.6.1

package/dist/cli.js

@@ -420,6 +420,11 @@ async function cmdHook(args) {
     const cfg = loadConfig();
     if (!cfg.apiKey)
         return; // not logged in, silently skip
+    // When the Stitch CLI spawns its own `claude -p` (e.g. for distillation),
+    // we don't want THAT inner conversation logged as a user/assistant turn —
+    // it would pollute the project thread with the distill prompt and JSON.
+    if (process.env.STITCH_HOOKS_DISABLED === '1')
+        return;
     let raw = '';
     try {
         raw = await readStdinAll();
@@ -646,29 +651,24 @@ function saveDistillState(s) {
         fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
     fs.writeFileSync(DISTILL_STATE_FILE, JSON.stringify(s, null, 2));
 }
-const DISTILL_PROMPT = `You are a memory distiller for an AI coding assistant.
+const DISTILL_PROMPT = `You are a memory distiller. Output ONLY a JSON array of memory objects. Be GENEROUS — capture every concrete fact about the project that future sessions will care about. Aim for 10–30 memories on a substantial conversation.
+
+Each memory is one atomic, self-contained statement (1–4 sentences) that someone reading it months later — without the conversation around it — will fully understand.
 
-Read the conversation below (between a developer and an AI). Extract ONLY
-durable, project-specific facts the developer explicitly stated or decisions
-they explicitly made. Do not invent. Do not extrapolate from implications.
-Skip anything that's tentative, exploratory, or not directly stated.
+Format:
+  [{"kind":"fact|decision|snippet|preference","content":"...","tags":["short","keywords"]}, ...]
 
-Output a JSON array. Each entry:
-  {
-    "kind": "fact" | "decision" | "snippet" | "preference",
-    "content": "<self-contained, single-paragraph statement>",
-    "tags": ["<short-keyword>", ...]
-  }
+Capture:
+- fact        — anything concrete: file paths, endpoint URLs, commands, version
+                numbers, architecture, deployed services, schemas, dependencies,
+                bugs found, fixes shipped.
+- decision    — choices with rationale.
+- snippet     — reusable commands/config/code/CLI flags/env var names.
+- preference  — how the developer wants the AI to behave on this project.
 
-Rules:
-- "fact"        : stable knowledge about this project (architecture, services, schema)
-- "decision"    : explicit choice with rationale (e.g. "we use X because Y")
-- "snippet"     : a reusable code/config/command pattern the user wants kept
-- "preference"  : how the developer wants the AI to behave on this project
-- Each entry must stand alone — readable months later without context.
-- Tags should be 1–3 short keywords.
-- If nothing durable was said, output exactly: []
-- Output ONLY the JSON array. No prose, no code fences, no commentary.
+Skip pleasantries and questions still being explored. One atomic idea per
+memory — don't bundle. If truly nothing durable was discussed, output: [].
+Output the JSON array and nothing else — no prose, no markdown fences.
 
 Conversation:
 `;
@@ -701,7 +701,29 @@ async function cmdDistill(args) {
     }
     const claudeBin = process.env.STITCH_CLAUDE_BIN || 'claude';
     process.stdout.write(`  → asking ${claudeBin} -p to extract facts… `);
-    const result = await run(claudeBin, ['-p', DISTILL_PROMPT + conversation], { cwd: process.cwd() });
+    const fullPrompt = DISTILL_PROMPT + conversation;
+    // Pipe the prompt via stdin: long conversations blow past ARG_MAX when
+    // passed as `-p <prompt>`, and stdin avoids claude interpreting any
+    // prompt-internal characters as flags. `claude -p` with no value reads
+    // from stdin. STITCH_HOOKS_DISABLED stops our own _hook command from
+    // logging this nested distill conversation as project thread turns.
+    const result = await runWithStdin(claudeBin, ['-p'], fullPrompt, {
+        cwd: process.cwd(),
+        env: { STITCH_HOOKS_DISABLED: '1' },
+    });
+    // Debug capture: STITCH_DEBUG_DISTILL=1 writes raw stdout/stderr/prompt
+    // to /tmp so we can see exactly what claude actually returned.
+    if (process.env.STITCH_DEBUG_DISTILL === '1') {
+        const ts = Date.now();
+        const dbgDir = '/tmp';
+        try {
+            fs.writeFileSync(path.join(dbgDir, `stitch-distill-${ts}.prompt.txt`), fullPrompt);
+            fs.writeFileSync(path.join(dbgDir, `stitch-distill-${ts}.stdout.txt`), result.stdout);
+            fs.writeFileSync(path.join(dbgDir, `stitch-distill-${ts}.stderr.txt`), result.stderr);
+            console.log(`\n  [debug] wrote /tmp/stitch-distill-${ts}.{prompt,stdout,stderr}.txt`);
+        }
+        catch { /* ignore */ }
+    }
     if (result.exit_code !== 0) {
         console.log('failed');
         console.error(result.stderr.trim().slice(0, 400));
@@ -710,6 +732,10 @@ async function cmdDistill(args) {
     const memories = parseDistillationOutput(result.stdout);
     console.log(`extracted ${memories.length} memories`);
     if (memories.length === 0) {
+        if (process.env.STITCH_DEBUG_DISTILL === '1') {
+            console.error('  [debug] claude stdout (first 600 chars):');
+            console.error('  ' + result.stdout.slice(0, 600).replace(/\n/g, '\n  '));
+        }
         bumpDistillCooldown(thread);
         return;
     }
@@ -739,25 +765,76 @@ function bumpDistillCooldown(thread) {
     saveDistillState(state);
 }
 function parseDistillationOutput(stdout) {
-    // claude -p sometimes wraps in markdown fences or adds a "Here are the memories:" preamble.
-    // Strip everything outside the first balanced [..] array.
+    // claude -p often wraps the array in markdown fences, prepends prose like
+    // "Here are the extracted memories:", or follows it with a sign-off line.
+    // Strategy: try several extraction modes from most-precise to most-lenient,
+    // returning the first one that parses to a non-empty valid array.
     const text = stdout.trim();
-    const start = text.indexOf('[');
-    const end = text.lastIndexOf(']');
-    if (start === -1 || end === -1 || end < start)
+    if (!text)
         return [];
-    const json = text.slice(start, end + 1);
-    try {
-        const parsed = JSON.parse(json);
-        if (!Array.isArray(parsed))
-            return [];
-        return parsed.filter((m) => m && typeof m === 'object'
-            && typeof m.content === 'string' && m.content.length > 0
-            && typeof m.kind === 'string' && ['fact', 'decision', 'snippet', 'preference', 'note'].includes(m.kind));
+    const candidates = [];
+    // 1. Fenced ```json block
+    const fenced = text.match(/```(?:json)?\s*\n([\s\S]*?)\n```/i);
+    if (fenced)
+        candidates.push(fenced[1].trim());
+    // 2. The first `[ {` … last `} ]` window (skips prose-level stray brackets).
+    const objStart = text.indexOf('[');
+    const objEnd = text.lastIndexOf(']');
+    if (objStart !== -1 && objEnd > objStart) {
+        candidates.push(text.slice(objStart, objEnd + 1));
+    }
+    // 3. Largest `[\n{ ... }\n]` block via balanced scan from each `[`
+    for (let i = 0; i < text.length; i++) {
+        if (text[i] !== '[')
+            continue;
+        let depth = 0;
+        let inStr = false;
+        let esc = false;
+        for (let j = i; j < text.length; j++) {
+            const ch = text[j];
+            if (esc) {
+                esc = false;
+                continue;
+            }
+            if (ch === '\\' && inStr) {
+                esc = true;
+                continue;
+            }
+            if (ch === '"') {
+                inStr = !inStr;
+                continue;
+            }
+            if (inStr)
+                continue;
+            if (ch === '[')
+                depth++;
+            else if (ch === ']') {
+                depth--;
+                if (depth === 0) {
+                    candidates.push(text.slice(i, j + 1));
+                    break;
+                }
+            }
+        }
     }
-    catch {
-        return [];
+    const seen = new Set();
+    for (const cand of candidates) {
+        if (seen.has(cand))
+            continue;
+        seen.add(cand);
+        try {
+            const parsed = JSON.parse(cand);
+            if (!Array.isArray(parsed))
+                continue;
+            const valid = parsed.filter((m) => m && typeof m === 'object'
+                && typeof m.content === 'string' && m.content.length > 0
+                && typeof m.kind === 'string' && ['fact', 'decision', 'snippet', 'preference', 'note'].includes(m.kind));
+            if (valid.length > 0)
+                return valid;
+        }
+        catch { /* try next candidate */ }
     }
+    return [];
 }
 async function distillReview(args) {
     const cfg = loadConfig();
@@ -1387,6 +1464,22 @@ function run(cmd, args, opts = {}) {
         child.on('close', (code) => resolve({ stdout, stderr, exit_code: code ?? 0 }));
     });
 }
+function runWithStdin(cmd, args, stdinData, opts = {}) {
+    return new Promise((resolve) => {
+        const child = spawn(cmd, args, {
+            cwd: opts.cwd || process.cwd(),
+            env: { ...process.env, ...(opts.env || {}) },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (d) => stdout += d.toString());
+        child.stderr.on('data', (d) => stderr += d.toString());
+        child.on('error', (err) => resolve({ stdout, stderr: stderr + '\n[spawn error] ' + err.message, exit_code: 127 }));
+        child.on('close', (code) => resolve({ stdout, stderr, exit_code: code ?? 0 }));
+        child.stdin.end(stdinData);
+    });
+}
 function readLine() {
     return new Promise((resolve) => {
         const onData = (d) => { process.stdin.off('data', onData); resolve(d.toString().trim()); };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stitchdb/cli",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Stitch CLI — manage memory + run agents from your terminal",
   "type": "module",
   "bin": {