waku-memory 0.1.0 → 0.2.0

package/dist/cli.js

@@ -13,12 +13,15 @@
 // --help, and the found/wrote/error tri-state collapsing into one boolean
 // -- are pinned by plain assertions on return values, not by mocking
 // console.log.
+import { spawnSync } from 'node:child_process';
 import { readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename, dirname, join } from 'node:path';
 import { createInterface } from 'node:readline';
+import { fileURLToPath } from 'node:url';
+import { DEFAULT_WINDOW_DAYS } from "./bootstrap.js";
 import { getHarnesses, getManualHarnesses, harnessConfigExists, mergeMcpConfig, } from "./harnesses.js";
-import { handleHookEvent } from "./hook.js";
+import { SHIM_VERSION, handleHookEvent } from "./hook.js";
 import { KEYS_PAGE_URL, disable, enable } from "./capture.js";
 export const DEFAULT_URL = 'https://api.waku.one/mcp';
 export const DEFAULT_NAME = 'waku';
@@ -67,6 +70,9 @@ export function importNote() {
 export function parseArgs(argv) {
     let name = DEFAULT_NAME;
     let url = DEFAULT_URL;
+    let since;
+    let all = false;
+    let noBootstrap = false;
     const positional = [];
     for (let i = 0; i < argv.length; i++) {
         const arg = argv[i];
@@ -76,6 +82,15 @@ export function parseArgs(argv) {
         else if (arg === '--url' && i + 1 < argv.length) {
             url = argv[++i];
         }
+        else if (arg === '--since' && i + 1 < argv.length) {
+            since = argv[++i];
+        }
+        else if (arg === '--all') {
+            all = true;
+        }
+        else if (arg === '--no-bootstrap') {
+            noBootstrap = true;
+        }
         else if (!arg.startsWith('--')) {
             positional.push(arg);
         }
@@ -83,7 +98,7 @@ export function parseArgs(argv) {
     // subcommand is only meaningful to the caller for "capture enable" /
     // "capture disable" -- setup and hook both ignore it, same as they always
     // ignored any positional beyond the first.
-    return { command: positional[0], subcommand: positional[1], name, url };
+    return { command: positional[0], subcommand: positional[1], name, url, since, all, noBootstrap };
 }
 export function printUsage() {
     console.log('Usage: npx waku-memory setup [--name <name>] [--url <url>]');
@@ -97,7 +112,7 @@ export function printUsage() {
     console.log('  the server named in ~/.waku-memory/config.json. Invoked by Claude Code');
     console.log('  itself (see "capture enable") -- not meant to be run by hand.');
     console.log('');
-    console.log('Usage: waku-memory capture enable [--url <ingest-base>]');
+    console.log('Usage: waku-memory capture enable [--url <ingest-base>] [--since <N>d] [--all] [--no-bootstrap]');
     console.log('');
     console.log('  Turns on automatic capture: every turn of your Claude Code sessions is');
     console.log('  sent to our server and on to Anthropic for extraction. Shows that');
@@ -105,11 +120,36 @@ export function printUsage() {
     console.log(`  asks for an API key (mint one at ${KEYS_PAGE_URL})`);
     console.log('  and installs the hook into ~/.claude/settings.json.');
     console.log('');
+    console.log('  A third question then offers to import the memory and history Claude');
+    console.log('  Code already keeps on this machine -- its own memory files and session');
+    console.log('  transcripts -- asked only when it finds anything to offer.');
+    console.log('');
+    console.log(`  --since <N>d    only scan transcripts from the last N days (default: ${DEFAULT_WINDOW_DAYS}d)`);
+    console.log('  --all           scan full history instead, ignoring --since');
+    console.log('  --no-bootstrap  skip the scan and the third question entirely');
+    console.log('');
     console.log('Usage: waku-memory capture disable');
     console.log('');
     console.log('  Removes exactly the hook entries "capture enable" added. Your saved key');
     console.log('  is left in place -- revoke it on the keys page if you want it gone too.');
 }
+// The default third question: on, with the full DEFAULT_WINDOW_DAYS window
+// (spec 011 §8/§9, task 14). Used both as dispatch()'s no-flags-given result
+// and, for "capture disable", unconditionally -- disable() never reads
+// deps.bootstrap (see its own comment), so there is nothing to gain and a
+// real footgun to avoid in parsing --since/--all/--no-bootstrap for an
+// action that would silently ignore them.
+const DEFAULT_BOOTSTRAP = { windowDays: DEFAULT_WINDOW_DAYS, enabled: true };
+// Accepts a bare integer ("90") or an integer with a trailing "d" ("90d") --
+// the brief's two named shapes, spec 011 §9. Anything else (empty, signed,
+// fractional, trailing garbage after the "d") is null, which dispatch()
+// turns into a 'bad-flag' rather than a silent fallback to the default: a
+// person who typed --since clearly meant to change the window, so getting
+// no error and the default anyway would be the more confusing wrong answer.
+export function parseSinceDays(raw) {
+    const match = /^(\d+)d?$/.exec(raw);
+    return match ? Number(match[1]) : null;
+}
 export function dispatch(argv) {
     // Checked ahead of parseArgs deliberately: --help/-h are flags, so
     // parseArgs (which only special-cases --name/--url) would otherwise drop
@@ -118,7 +158,7 @@ export function dispatch(argv) {
     // existed to pin it. See cli.test.mjs's dispatch block.
     if (argv.includes('--help') || argv.includes('-h'))
         return { kind: 'help' };
-    const { command, subcommand, name, url } = parseArgs(argv);
+    const { command, subcommand, name, url, since, all, noBootstrap } = parseArgs(argv);
     if (command === undefined)
         return { kind: 'no-command' };
     if (command === 'hook')
@@ -132,7 +172,30 @@ export function dispatch(argv) {
         // cheapest way to tell "the user passed --url" apart from "parseArgs's
         // unrelated default happened to apply" without giving parseArgs a
         // second, command-dependent default of its own.
-        return { kind: 'capture', action: subcommand, url: argv.includes('--url') ? url : DEFAULT_INGEST_URL };
+        const ingestUrl = argv.includes('--url') ? url : DEFAULT_INGEST_URL;
+        if (subcommand === 'disable') {
+            return { kind: 'capture', action: 'disable', url: ingestUrl, bootstrap: DEFAULT_BOOTSTRAP };
+        }
+        // --since is validated unconditionally (even alongside --all) so a typo
+        // is never silently swallowed by an --all that happened to be present
+        // too; --all is then applied on top, since "scan everything" is the
+        // least surprising way to read the two stacked together (untested by
+        // the brief -- there is no one obviously-right answer here, but this at
+        // least never hides a bad --since value).
+        let windowDays = DEFAULT_WINDOW_DAYS;
+        if (since !== undefined) {
+            const parsed = parseSinceDays(since);
+            if (parsed === null) {
+                return {
+                    kind: 'bad-flag',
+                    message: `waku-memory capture enable: invalid --since value "${since}" -- expected a number of days, e.g. "90d" or "90".`,
+                };
+            }
+            windowDays = parsed;
+        }
+        if (all)
+            windowDays = null;
+        return { kind: 'capture', action: 'enable', url: ingestUrl, bootstrap: { windowDays, enabled: !noBootstrap } };
     }
     if (command !== 'setup')
         return { kind: 'unknown', command };
@@ -383,14 +446,34 @@ async function runHookCommand() {
 // JSON-shaped types meet. Safe in practice: atomicWriteJson only ever does
 // JSON.stringify(data) -- it has no opinion about McpConfig vs
 // ClaudeSettings beyond the type checker's.
-function realCaptureDeps(prompt) {
+//
+// hookSourceDir is this module's own directory, not a fixed constant: as
+// published, cli.ts compiles to dist/cli.js and runs from there, so
+// import.meta.url resolves to dist -- exactly the directory installHookCopy
+// needs (spec 011 §6, task 11). verifyHook actually runs the entry once
+// with a throwaway event before enable() trusts it, so a corrupted copy or
+// a Node too old for it is caught before settings.json is ever touched.
+//
+// fetchImpl is task 13's addition (spec 011 §8): the real global fetch, for
+// runBootstrap's own network calls. bootstrap is now a parameter rather than
+// a hardcoded default (task 14): dispatch() has already turned
+// --since/--all/--no-bootstrap (or their absence) into this same shape, so
+// this function's only job is to place it on the deps bag unchanged, the
+// same way `prompt` already arrives built by its own call site below.
+function realCaptureDeps(prompt, bootstrap) {
     const claudeDir = join(homedir(), '.claude');
     return {
         claudeDir,
         settingsPath: join(claudeDir, 'settings.json'),
         configDir: join(homedir(), '.waku-memory'),
+        hookSourceDir: dirname(fileURLToPath(import.meta.url)),
+        version: SHIM_VERSION,
+        execPath: process.execPath,
+        verifyHook: (run) => spawnSync(run.command, run.args ?? [], { input: '{"hook_event_name":"Nope"}\n', timeout: 10_000 }).status === 0,
         prompt,
         writeSettingsJson: (path, data) => atomicWriteJson(path, data),
+        fetchImpl: fetch,
+        bootstrap,
     };
 }
 // Not awaited by run() below, for the same structural reason runHookCommand
@@ -401,14 +484,16 @@ function realCaptureDeps(prompt) {
 // safely touch) is the one outcome that should make a scripted caller
 // notice. 'declined' and the disable no-op are both a normal, successful
 // run that did exactly what was asked -- nothing.
-async function runCaptureCommand(action, url) {
+async function runCaptureCommand(action, url, bootstrap) {
     if (action === 'disable') {
         // disable() never prompts (see its own comment) -- no readline interface
         // is created at all, and this stub is a fail-loud guard against that
-        // ever silently stopping being true.
+        // ever silently stopping being true. bootstrap is dispatch()'s
+        // DEFAULT_BOOTSTRAP here regardless of what was on argv -- disable()
+        // itself never reads deps.bootstrap either.
         const deps = realCaptureDeps(() => {
             throw new Error('waku-memory capture disable: unexpectedly tried to prompt.');
-        });
+        }, bootstrap);
         const result = await disable(deps);
         if (result === 'refused')
             process.exitCode = 1;
@@ -446,7 +531,7 @@ async function runCaptureCommand(action, url) {
             const { value, done } = await lines.next();
             return done ? '' : value; // stdin closed before an answer arrived -- treated as "declined"
         };
-        const result = await enable(url, realCaptureDeps(prompt));
+        const result = await enable(url, realCaptureDeps(prompt, bootstrap));
         if (result === 'refused')
             process.exitCode = 1;
     }
@@ -470,6 +555,11 @@ export function run(argv) {
             printUsage();
             process.exitCode = 1;
             return;
+        case 'bad-flag':
+            console.error(d.message);
+            printUsage();
+            process.exitCode = 1;
+            return;
         case 'setup':
             setup(d.name, d.url);
             return;
@@ -488,7 +578,7 @@ export function run(argv) {
             });
             return;
         case 'capture':
-            void runCaptureCommand(d.action, d.url).catch((err) => {
+            void runCaptureCommand(d.action, d.url, d.bootstrap).catch((err) => {
                 console.error(`waku-memory capture: unexpected failure -- ${errorMessage(err)}.`);
                 process.exitCode = 1;
             });

package/dist/dialogue.js

@@ -0,0 +1,139 @@
+// cc-dialogue-v1 (spec 011 §1): the fixed rule that turns a transcript
+// delta into the conversation before it leaves the machine, and the piece
+// cut (§3) that keeps every request under the ingest cap. No judgement
+// lives here -- record types and block types only -- and the rule is
+// versioned: a change is a new CONTENT_FORMAT, not an edit to this one.
+//
+// The same rule exists in Python (waku_worker/dialogue.py) for raw jobs
+// from 0.1.x shims; tests/fixtures/cc-dialogue-v1 pins both to one output.
+export const CONTENT_FORMAT = 'cc-dialogue-v1';
+export const MAX_PIECE_BYTES = 200 * 1024; // under the 256 KiB ingest cap, with room for one long record
+// Text Claude Code itself writes into `user` records: a subagent's
+// completion report, slash-command output, reminders. A text starting
+// with one of these is the harness's, not the person's. The list is a
+// census over Yang's machine on 2026-09-05 (task-notification 563,
+// command-name 34, local-command-stdout 34, system-reminder 12) plus the
+// caveat tag the harness documents for the same shape. Part of the
+// format version: a new tag is cc-dialogue-v2, here and in dialogue.py.
+const HARNESS_TAGS = [
+    '<task-notification>',
+    '<local-command-stdout>',
+    '<local-command-caveat>',
+    '<command-name>',
+    '<system-reminder>',
+];
+// Named so the Python twin (waku_worker/dialogue.py) strips the same set:
+// trimStart() and str.lstrip() disagree on U+001C-U+001F and U+0085.
+const LEADING_BLANKS = /^[ \t\r\n\f\v]+/;
+function isTagged(text) {
+    const t = text.replace(LEADING_BLANKS, '');
+    return HARNESS_TAGS.some((tag) => t.startsWith(tag));
+}
+function textBlocks(content) {
+    if (typeof content === 'string')
+        return [content];
+    if (!Array.isArray(content))
+        return [];
+    const out = [];
+    for (const b of content) {
+        if (b && typeof b === 'object' && b.type === 'text' && typeof b.text === 'string')
+            out.push(b.text);
+    }
+    return out;
+}
+// One JSONL line -> the entries the rule keeps, or none when it drops
+// the line.
+export function formatLine(line) {
+    let rec;
+    try {
+        rec = JSON.parse(line);
+    }
+    catch {
+        return [];
+    }
+    if (rec === null || typeof rec !== 'object')
+        return [];
+    const r = rec;
+    const content = r.message && typeof r.message === 'object' ? r.message.content : undefined;
+    if (r.type === 'user') {
+        if (r.isMeta === true || r.isCompactSummary === true)
+            return [];
+        return textBlocks(content)
+            .filter((t) => !isTagged(t))
+            .map((t) => ({ role: 'user', text: t }));
+    }
+    if (r.type === 'assistant') {
+        if (!Array.isArray(content))
+            return [];
+        const entries = [];
+        for (const b of content) {
+            if (!b || typeof b !== 'object')
+                continue;
+            if (b.type === 'text' && typeof b.text === 'string')
+                entries.push({ role: 'assistant', text: b.text });
+            else if (b.type === 'tool_use' && typeof b.name === 'string')
+                entries.push({ role: 'tool', text: b.name });
+        }
+        return entries;
+    }
+    return [];
+}
+export function renderEntry(e) {
+    if (e.role === 'user')
+        return `user: ${e.text}`;
+    if (e.role === 'assistant')
+        return `assistant: ${e.text}`;
+    return `assistant used tool: ${e.text}`;
+}
+// The wire text: entries joined by one blank line.
+export function renderEntries(entries) {
+    return entries.map(renderEntry).join('\n\n');
+}
+// One line -> one string or null: the contract the fixture test and the
+// Python twin (waku_worker/dialogue.py) share.
+export function formatRecord(line) {
+    const entries = formatLine(line);
+    return entries.length > 0 ? renderEntries(entries) : null;
+}
+// Formats every complete line of `buf` and packs the surviving entries
+// into pieces under `maxPieceBytes`, cutting only between lines (§3): a
+// line's entries always travel together. A trailing partial line (no
+// newline yet) is left for the next event. `end` is the offset past the
+// last newline consumed, whether or not anything survived -- the
+// caller's watermark moves to it either way.
+export function formatDelta(buf, maxPieceBytes = MAX_PIECE_BYTES) {
+    const pieces = [];
+    let entries = [];
+    let entriesBytes = 0;
+    let pieceEnd = 0;
+    let lineStart = 0;
+    let end = 0;
+    const flush = () => {
+        if (entries.length > 0) {
+            pieces.push({ entries, text: renderEntries(entries), end: pieceEnd });
+            entries = [];
+            entriesBytes = 0;
+        }
+    };
+    for (;;) {
+        const nl = buf.indexOf(0x0a, lineStart);
+        if (nl === -1)
+            break;
+        const lineEnd = nl + 1;
+        const lineEntries = formatLine(buf.subarray(lineStart, nl).toString('utf8'));
+        lineStart = lineEnd;
+        end = lineEnd;
+        if (lineEntries.length === 0) {
+            pieceEnd = lineEnd;
+            continue;
+        }
+        const bytes = Buffer.byteLength(renderEntries(lineEntries), 'utf8') + (entries.length > 0 ? 2 : 0);
+        if (entries.length > 0 && entriesBytes + bytes > maxPieceBytes)
+            flush();
+        entries.push(...lineEntries);
+        entriesBytes += bytes;
+        pieceEnd = lineEnd;
+    }
+    flush();
+    return { pieces, end };
+}