@cachly-dev/mcp-server 0.10.128 → 0.10.130

package/dist/src/ambient-hooks.js

@@ -1,278 +1,5 @@
-// Ambient Recall (Phase 4) — Claude Code hook-script generators.
-//
-// Builds the SessionStart + UserPromptSubmit hook scripts (and the
-// .claude/settings.json fragment that wires them) so recall is PUSHED into
-// context automatically, without the agent having to remember to call it
-// (roadmap §6.1). This is the packaging that turns cachly's existing recall
-// into "memory that is just there".
-//
-// Design mirrors cls-hook.ts:
-//   • Pure string builders — exhaustively unit-tested.
-//   • No untrusted input is interpolated into the script; the hook payload
-//     (which contains the user's prompt) is piped to the CLI on stdin, never
-//     spliced into shell/JS source.
-//   • Versioned so installers can upgrade old hooks in place.
-//   • Graceful: a crashing hook must NEVER block the agent — every path exits 0
-//     with no output, so Claude Code simply proceeds without the extra context
-//     (§6.3 guardrail 5).
-import { existsSync } from 'node:fs';
-import { readFile, writeFile, chmod, mkdir } from 'node:fs/promises';
-import { resolve } from 'node:path';
-/**
- * Bumped whenever a hook script changes so installers can upgrade old hooks.
- * v3: hooks became Node scripts (.mjs) invoked as `node "<path>"` — the
- * cross-platform shape from the Claude Code hooks guide. The v1/v2 POSIX shell
- * scripts silently never ran on native Windows (no /bin/sh); Node is already a
- * hard requirement of this package, so the hook now runs identically on
- * Windows, macOS and Linux.
- * v4 (GROW-015): the script no longer embeds the caller's key as a string
- * literal. It resolves CACHLY_JWT at run time from the environment instead,
- * so a `.claude/hooks/` script that gets committed to a repo never leaks a
- * secret. Bumping the version replaces old v1-v3 scripts (which DID embed
- * the key) the next time setup/autopilot runs.
- */
-export const AMBIENT_HOOK_VERSION = 'v4';
-/**
- * The CLI subcommand the hooks pipe their payload to. It reads the hook JSON on
- * stdin, runs smart_recall through the relevance gate (ambient-recall.ts), and
- * prints the `hookSpecificOutput` JSON Claude Code injects as additionalContext.
- * The CLI self-limits its latency budget (§6.3 guardrail 4). See ambient-cli.ts.
- */
-export const AMBIENT_CLI_SUBCOMMAND = 'ambient-recall';
-const DEFAULT_CLI = `npx @cachly-dev/mcp-server@latest ${AMBIENT_CLI_SUBCOMMAND}`;
-/** Escape a value for embedding inside a single-quoted JS string literal. */
-function jsString(s) {
-    return s.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
-}
-function buildHook(event, opts) {
-    const cli = opts.cliCommand ?? DEFAULT_CLI;
-    return [
-        `#!/usr/bin/env node`,
-        `// cachly Ambient Recall — ${event} ${AMBIENT_HOOK_VERSION}`,
-        `// Pushes relevant memory into context automatically. Cross-platform Node hook`,
-        `// (no shell script — runs identically on Windows/macOS/Linux). Never blocks`,
-        `// the agent: every failure path exits 0 with no output (graceful degrade).`,
-        `import { spawn } from 'node:child_process';`,
-        `process.env.CACHLY_BRAIN_INSTANCE_ID = '${jsString(opts.instanceId)}';`,
-        // GROW-015: never embed the caller's key as a string literal here — read
-        // it at run time instead, so a committed .claude/hooks/ script can never
-        // leak a secret. Only the key's origin changed: same events, same
-        // output, same 3s budget, errors still swallowed.
-        `if (!process.env.CACHLY_JWT && process.env.CACHLY_API_KEY) process.env.CACHLY_JWT = process.env.CACHLY_API_KEY;`,
-        `process.env.CACHLY_HOOK_EVENT = '${jsString(event)}';`,
-        `try {`,
-        // Claude Code delivers the hook payload as JSON on stdin; stdio 'inherit'
-        // hands it verbatim to the CLI (no re-parsing of prompt content), and the
-        // CLI's hookSpecificOutput JSON flows straight back to Claude Code on
-        // stdout. shell:true resolves npx/npx.cmd on every platform; stderr is
-        // discarded so a noisy npm can never corrupt the hook protocol.
-        `  const child = spawn('${jsString(cli)}', { shell: true, stdio: ['inherit', 'inherit', 'ignore'] });`,
-        `  child.on('error', () => process.exit(0));`,
-        `  child.on('close', () => process.exit(0));`,
-        `} catch {`,
-        `  process.exit(0);`,
-        `}`,
-    ].join('\n');
-}
-/**
- * SessionStart hook: emits the session briefing as additionalContext at the
- * start of every session — the automatic replacement for "the agent should call
- * session_start".
- */
-export function buildSessionStartHook(opts) {
-    return buildHook('SessionStart', opts);
-}
-/**
- * UserPromptSubmit hook — the core of Ambient Recall. Runs before every user
- * message, recalls on the prompt through the relevance gate, and pushes gated
- * hits into context. This is the most-forgotten call, made automatic.
- */
-export function buildUserPromptSubmitHook(opts) {
-    return buildHook('UserPromptSubmit', opts);
-}
-/**
- * PreToolUse hook (Ausbau) — file-open briefing. Fires before Edit/Write-class
- * tools (settings matcher `Edit|Write|MultiEdit`); the CLI recalls file-scoped
- * lessons and injects them as additionalContext — the automatic "prüf mal, ob's
- * zu dieser Datei Lessons gibt" (roadmap §6.1).
- */
-export function buildPreToolUseHook(opts) {
-    return buildHook('PreToolUse', opts);
-}
-/**
- * Stop hook (Ausbau) — auto-learn. After a turn whose final message carries a
- * clear fix signal, the CLI feeds one observation to auto_learn_session — the
- * automatic replacement for the forgotten `learn_from_attempts` call.
- */
-export function buildStopHook(opts) {
-    return buildHook('Stop', opts);
-}
-// Per-event latency budgets (seconds). The CLI self-limits recall to 3s; these
-// are the outer safety net so a wedged npx can never stall a turn for long.
-const EVENT_TIMEOUTS = {
-    SessionStart: 30,
-    UserPromptSubmit: 10,
-    PreToolUse: 10,
-    Stop: 60, // auto-learn may do a real write; Stop is not latency-critical
-};
-/** Matcher for the PreToolUse briefing: only file-mutating tools. */
-export const PRE_TOOL_USE_MATCHER = 'Edit|Write|MultiEdit|NotebookEdit';
-/**
- * Build the `.claude/settings.json` `hooks` fragment that wires the scripts.
- * The caller merges this into the user's existing settings (never overwrites).
- * Shape matches Claude Code's hooks config: an array of matcher groups, each
- * with a list of `{ type: "command", command, timeout }` entries.
- */
-export function buildAmbientSettingsHooks(paths) {
-    // v3: the command is `node "<script>"` — a plain string that both /bin/sh
-    // (macOS/Linux, Windows+Git-Bash) and PowerShell (native Windows fallback)
-    // execute identically, so one settings shape covers every platform.
-    const entry = (event, scriptPath, matcher) => ({
-        ...(matcher ? { matcher } : {}),
-        hooks: [{ type: 'command', command: `node "${scriptPath}"`, timeout: EVENT_TIMEOUTS[event] }],
-    });
-    const frag = {
-        SessionStart: [entry('SessionStart', paths.sessionStart)],
-        UserPromptSubmit: [entry('UserPromptSubmit', paths.userPromptSubmit)],
-    };
-    if (paths.preToolUse)
-        frag.PreToolUse = [entry('PreToolUse', paths.preToolUse, PRE_TOOL_USE_MATCHER)];
-    if (paths.stop)
-        frag.Stop = [entry('Stop', paths.stop)];
-    return frag;
-}
-// ── Installer ────────────────────────────────────────────────────────────────
-// Writes the two hook scripts into `.claude/hooks/` and merges the settings
-// fragment into `.claude/settings.json`. Idempotent and non-destructive:
-//   • re-running upgrades the scripts in place (version marker) and never
-//     duplicates a settings entry that already points at our script,
-//   • foreign hooks in the user's settings are preserved (we append, never
-//     overwrite the arrays).
-// Never throws — returns a status the caller can log.
-const HOOK_DIR = '.claude/hooks';
-const SETTINGS_FILE = '.claude/settings.json';
-/** Script filename per event — shared marker `cachly-ambient-` drives upgrades. */
-const SCRIPT_NAMES = {
-    SessionStart: 'cachly-ambient-session-start.mjs',
-    UserPromptSubmit: 'cachly-ambient-prompt-submit.mjs',
-    PreToolUse: 'cachly-ambient-pre-tool.mjs',
-    Stop: 'cachly-ambient-stop.mjs',
-};
-const AMBIENT_SCRIPT_MARKER = '.claude/hooks/cachly-ambient-';
-/** True when this matcher group only wires cachly-ambient scripts. */
-function isAmbientGroup(g, currentPaths) {
-    const hooks = g.hooks ?? [];
-    return (hooks.length > 0 &&
-        hooks.every((h) => {
-            const cmd = h.command ?? '';
-            // Matches v1/v2 entries (bare script path), v3 entries (`node "<path>"`),
-            // and marker-less test/custom paths passed as the current fragment.
-            return (cmd.includes(AMBIENT_SCRIPT_MARKER) ||
-                currentPaths.has(cmd) ||
-                [...currentPaths].some((p) => cmd.includes(`"${p}"`)));
-        }));
-}
-/**
- * Merge our hook entries into an existing settings object without disturbing
- * anything else. Idempotent AND upgrade-safe: existing cachly-ambient groups
- * (from any prior version/paths) are replaced by the current fragment rather
- * than accumulated; foreign groups are always preserved. Pure — unit-tested.
- */
-export function mergeAmbientSettings(existing, paths) {
-    const next = { ...existing, hooks: { ...(existing.hooks ?? {}) } };
-    const hooks = next.hooks;
-    const fragment = buildAmbientSettingsHooks(paths);
-    const currentPaths = new Set([paths.sessionStart, paths.userPromptSubmit, paths.preToolUse, paths.stop].filter((p) => !!p));
-    for (const [event, ourGroups] of Object.entries(fragment)) {
-        const foreign = (Array.isArray(hooks[event]) ? hooks[event] : []).filter((g) => !isAmbientGroup(g, currentPaths));
-        hooks[event] = [...foreign, ...ourGroups];
-    }
-    const changed = JSON.stringify(next) !== JSON.stringify(existing);
-    return { settings: next, changed };
-}
-/**
- * Install/upgrade the Ambient Recall hooks in `projectDir`. Best-effort:
- * a filesystem error surfaces as a thrown error only for the top-level caller,
- * which wraps it in try/catch (the git-hook feature is non-critical).
- */
-export async function installAmbientHooks(projectDir, instanceId, apiKey, options = {}) {
-    const hookDir = resolve(projectDir, HOOK_DIR);
-    await mkdir(hookDir, { recursive: true });
-    const opts = { instanceId, apiKey };
-    const events = ['SessionStart', 'UserPromptSubmit', 'PreToolUse', 'Stop'];
-    const scriptFor = {
-        SessionStart: buildSessionStartHook(opts),
-        UserPromptSubmit: buildUserPromptSubmitHook(opts),
-        PreToolUse: buildPreToolUseHook(opts),
-        Stop: buildStopHook(opts),
-    };
-    const pathFor = (e) => resolve(hookDir, SCRIPT_NAMES[e]);
-    const readIf = async (p) => {
-        try {
-            return await readFile(p, 'utf-8');
-        }
-        catch {
-            return '';
-        }
-    };
-    let anyExisting = false;
-    let allCurrent = true;
-    for (const e of events) {
-        const prev = await readIf(pathFor(e));
-        if (prev)
-            anyExisting = true;
-        if (prev !== scriptFor[e] + '\n')
-            allCurrent = false;
-    }
-    const scripts = allCurrent ? 'unchanged' : anyExisting ? 'upgraded' : 'written';
-    if (scripts !== 'unchanged') {
-        for (const e of events) {
-            await writeFile(pathFor(e), scriptFor[e] + '\n', 'utf-8');
-            await chmod(pathFor(e), 0o755).catch(() => { });
-        }
-    }
-    // Merge the settings fragment (upgrade-safe: prior ambient groups replaced).
-    const settingsPath = resolve(projectDir, SETTINGS_FILE);
-    const settingsExisted = existsSync(settingsPath);
-    let existingSettings = {};
-    if (settingsExisted) {
-        try {
-            existingSettings = JSON.parse(await readFile(settingsPath, 'utf-8'));
-        }
-        catch {
-            existingSettings = {};
-        } // corrupt/empty file → start fresh (still non-destructive to hooks we add)
-    }
-    // Portable installs (committed hooks) reference $CLAUDE_PROJECT_DIR so the
-    // settings work at any checkout location; local installs use absolute paths.
-    // These are SCRIPT PATHS — buildAmbientSettingsHooks wraps them as
-    // `node "<path>"`, so the portable var sits inside the double quotes and is
-    // expanded by the shell at hook time.
-    const commandFor = (e) => options.portable ? `$CLAUDE_PROJECT_DIR/${HOOK_DIR}/${SCRIPT_NAMES[e]}` : pathFor(e);
-    const { settings, changed } = mergeAmbientSettings(existingSettings, {
-        sessionStart: commandFor('SessionStart'),
-        userPromptSubmit: commandFor('UserPromptSubmit'),
-        preToolUse: commandFor('PreToolUse'),
-        stop: commandFor('Stop'),
-    });
-    let settingsStatus;
-    if (!settingsExisted)
-        settingsStatus = 'written';
-    else if (!changed)
-        settingsStatus = 'unchanged';
-    else
-        settingsStatus = 'merged';
-    if (settingsStatus !== 'unchanged') {
-        await mkdir(resolve(projectDir, '.claude'), { recursive: true });
-        await writeFile(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
-    }
-    return {
-        sessionStartPath: pathFor('SessionStart'),
-        promptSubmitPath: pathFor('UserPromptSubmit'),
-        preToolUsePath: pathFor('PreToolUse'),
-        stopPath: pathFor('Stop'),
-        scripts,
-        settings: settingsStatus,
-    };
-}
-//# sourceMappingURL=ambient-hooks.js.map
+import{existsSync as v}from"node:fs";import{readFile as E,writeFile as y,chmod as N,mkdir as A}from"node:fs/promises";import{resolve as S}from"node:path";const O="v4",H="ambient-recall",w=`npx @cachly-dev/mcp-server@latest ${H}`;function P(t){return t.replace(/\\/g,"\\\\").replace(/'/g,"\\'")}function d(t,o){const e=o.cliCommand??w;return["#!/usr/bin/env node",`// cachly Ambient Recall \u2014 ${t} ${O}`,"// Pushes relevant memory into context automatically. Cross-platform Node hook","// (no shell script \u2014 runs identically on Windows/macOS/Linux). Never blocks","// the agent: every failure path exits 0 with no output (graceful degrade).","import { spawn } from 'node:child_process';",`process.env.CACHLY_BRAIN_INSTANCE_ID = '${P(o.instanceId)}';`,"if (!process.env.CACHLY_JWT && process.env.CACHLY_API_KEY) process.env.CACHLY_JWT = process.env.CACHLY_API_KEY;",`process.env.CACHLY_HOOK_EVENT = '${P(t)}';`,"try {",`  const child = spawn('${P(e)}', { shell: true, stdio: ['inherit', 'inherit', 'ignore'] });`,"  child.on('error', () => process.exit(0));","  child.on('close', () => process.exit(0));","} catch {","  process.exit(0);","}"].join(`
+`)}function L(t){return d("SessionStart",t)}function R(t){return d("UserPromptSubmit",t)}function $(t){return d("PreToolUse",t)}function M(t){return d("Stop",t)}const Y={SessionStart:30,UserPromptSubmit:10,PreToolUse:10,Stop:60},F="Edit|Write|MultiEdit|NotebookEdit";function J(t){const o=(c,n,r)=>({...r?{matcher:r}:{},hooks:[{type:"command",command:`node "${n}"`,timeout:Y[c]}]}),e={SessionStart:[o("SessionStart",t.sessionStart)],UserPromptSubmit:[o("UserPromptSubmit",t.userPromptSubmit)]};return t.preToolUse&&(e.PreToolUse=[o("PreToolUse",t.preToolUse,F)]),t.stop&&(e.Stop=[o("Stop",t.stop)]),e}const C=".claude/hooks",j=".claude/settings.json",k={SessionStart:"cachly-ambient-session-start.mjs",UserPromptSubmit:"cachly-ambient-prompt-submit.mjs",PreToolUse:"cachly-ambient-pre-tool.mjs",Stop:"cachly-ambient-stop.mjs"},K=".claude/hooks/cachly-ambient-";function B(t,o){const e=t.hooks??[];return e.length>0&&e.every(c=>{const n=c.command??"";return n.includes(K)||o.has(n)||[...o].some(r=>n.includes(`"${r}"`))})}function D(t,o){const e={...t,hooks:{...t.hooks??{}}},c=e.hooks,n=J(o),r=new Set([o.sessionStart,o.userPromptSubmit,o.preToolUse,o.stop].filter(a=>!!a));for(const[a,i]of Object.entries(n)){const f=(Array.isArray(c[a])?c[a]:[]).filter(m=>!B(m,r));c[a]=[...f,...i]}const l=JSON.stringify(e)!==JSON.stringify(t);return{settings:e,changed:l}}async function q(t,o,e,c={}){const n=S(t,C);await A(n,{recursive:!0});const r={instanceId:o,apiKey:e},l=["SessionStart","UserPromptSubmit","PreToolUse","Stop"],a={SessionStart:L(r),UserPromptSubmit:R(r),PreToolUse:$(r),Stop:M(r)},i=s=>S(n,k[s]),f=async s=>{try{return await E(s,"utf-8")}catch{return""}};let m=!1,g=!0;for(const s of l){const _=await f(i(s));_&&(m=!0),_!==a[s]+`
+`&&(g=!1)}const T=g?"unchanged":m?"upgraded":"written";if(T!=="unchanged")for(const s of l)await y(i(s),a[s]+`
+`,"utf-8"),await N(i(s),493).catch(()=>{});const h=S(t,j),U=v(h);let b={};if(U)try{b=JSON.parse(await E(h,"utf-8"))}catch{b={}}const p=s=>c.portable?`$CLAUDE_PROJECT_DIR/${C}/${k[s]}`:i(s),{settings:x,changed:I}=D(b,{sessionStart:p("SessionStart"),userPromptSubmit:p("UserPromptSubmit"),preToolUse:p("PreToolUse"),stop:p("Stop")});let u;return U?I?u="merged":u="unchanged":u="written",u!=="unchanged"&&(await A(S(t,".claude"),{recursive:!0}),await y(h,JSON.stringify(x,null,2)+`
+`,"utf-8")),{sessionStartPath:i("SessionStart"),promptSubmitPath:i("UserPromptSubmit"),preToolUsePath:i("PreToolUse"),stopPath:i("Stop"),scripts:T,settings:u}}export{H as AMBIENT_CLI_SUBCOMMAND,O as AMBIENT_HOOK_VERSION,F as PRE_TOOL_USE_MATCHER,J as buildAmbientSettingsHooks,$ as buildPreToolUseHook,L as buildSessionStartHook,M as buildStopHook,R as buildUserPromptSubmitHook,q as installAmbientHooks,D as mergeAmbientSettings};

package/dist/src/ambient-ledger.js

@@ -1,95 +1,6 @@
-// Ambient Recall (Phase 4 Ausbau) — the net-token ledger.
-//
-// Roadmap §6.2: the whole feature is only honest if injected tokens (cost, paid
-// now) are weighed against prevented tokens (a wrong path a lesson averted).
-// This module persists per-turn records as JSONL (~/.cachly/ambient-ledger.jsonl)
-// so `ambient-stats` can show the NET number — even when it is negative — and
-// the CLI can auto-backoff (§6.3 guardrail 3) when the recent window is net-red.
-//
-// Prevented-credit in v1 is agent-reported: the injected context carries a tiny
-// footer inviting the agent to run `ambient-credit <tokens>` when a recalled
-// lesson actually changed its path. Self-reported ≠ perfect, but it is the only
-// client-side signal that exists before the server-side dashboard (v2) — and it
-// is what makes auto-backoff meaningful instead of permanently red.
-//
-// Everything here is best-effort: a broken ledger must never break a hook.
-import { appendFile, readFile, rename, writeFile } from 'node:fs/promises';
-import { mkdir } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { dirname, resolve } from 'node:path';
-/** Default ledger location; overridable for tests via explicit path args. */
-export function defaultLedgerPath() {
-    return resolve(homedir(), '.cachly', 'ambient-ledger.jsonl');
-}
-/** One JSONL line for an entry. Pure. */
-export function serializeEntry(e) {
-    return JSON.stringify({
-        ts: e.ts,
-        event: e.event,
-        injected: Math.max(0, Math.round(e.injected)),
-        prevented: Math.max(0, Math.round(e.prevented)),
-        ...(e.note ? { note: e.note.slice(0, 200) } : {}),
-    });
-}
-/** Parse ledger text into entries, silently skipping corrupt lines. Pure. */
-export function parseLedger(text) {
-    const out = [];
-    for (const line of text.split('\n')) {
-        const t = line.trim();
-        if (!t)
-            continue;
-        try {
-            const e = JSON.parse(t);
-            if (typeof e !== 'object' || e === null)
-                continue;
-            const injected = Number(e.injected);
-            const prevented = Number(e.prevented);
-            if (!Number.isFinite(injected) || !Number.isFinite(prevented))
-                continue;
-            out.push({
-                ts: typeof e.ts === 'string' ? e.ts : '',
-                event: typeof e.event === 'string' ? e.event : 'unknown',
-                injected: Math.max(0, injected),
-                prevented: Math.max(0, prevented),
-                ...(typeof e.note === 'string' ? { note: e.note } : {}),
-            });
-        }
-        catch {
-            // corrupt line (partial write, manual edit) → skip, never throw
-        }
-    }
-    return out;
-}
-// Rotation keeps the ledger bounded: hooks run on every prompt, and an
-// unbounded append-only file would eventually slow every turn down.
-const MAX_LEDGER_BYTES = 256 * 1024;
-const KEEP_LINES_ON_ROTATE = 400;
-/** Append an entry; auto-creates the directory, auto-rotates. Never throws. */
-export async function appendLedgerEntry(entry, path = defaultLedgerPath()) {
-    try {
-        await mkdir(dirname(path), { recursive: true });
-        await appendFile(path, serializeEntry(entry) + '\n', 'utf-8');
-        const text = await readFile(path, 'utf-8');
-        if (Buffer.byteLength(text, 'utf-8') > MAX_LEDGER_BYTES) {
-            const lines = text.split('\n').filter(Boolean);
-            const kept = lines.slice(-KEEP_LINES_ON_ROTATE).join('\n') + '\n';
-            // Write-then-rename so a crash mid-rotation never truncates to nothing.
-            const tmp = path + '.tmp';
-            await writeFile(tmp, kept, 'utf-8');
-            await rename(tmp, path);
-        }
-    }
-    catch {
-        // Ledger is telemetry — never let it break a hook or a commit.
-    }
-}
-/** Read all entries; missing/corrupt file → []. Never throws. */
-export async function readLedger(path = defaultLedgerPath()) {
-    try {
-        return parseLedger(await readFile(path, 'utf-8'));
-    }
-    catch {
-        return [];
-    }
-}
-//# sourceMappingURL=ambient-ledger.js.map
+import{appendFile as u,readFile as s,rename as f,writeFile as p}from"node:fs/promises";import{mkdir as d}from"node:fs/promises";import{homedir as m}from"node:os";import{dirname as l,resolve as y}from"node:path";function a(){return y(m(),".cachly","ambient-ledger.jsonl")}function v(t){return JSON.stringify({ts:t.ts,event:t.event,injected:Math.max(0,Math.round(t.injected)),prevented:Math.max(0,Math.round(t.prevented)),...t.note?{note:t.note.slice(0,200)}:{}})}function g(t){const n=[];for(const i of t.split(`
+`)){const o=i.trim();if(o)try{const e=JSON.parse(o);if(typeof e!="object"||e===null)continue;const r=Number(e.injected),c=Number(e.prevented);if(!Number.isFinite(r)||!Number.isFinite(c))continue;n.push({ts:typeof e.ts=="string"?e.ts:"",event:typeof e.event=="string"?e.event:"unknown",injected:Math.max(0,r),prevented:Math.max(0,c),...typeof e.note=="string"?{note:e.note}:{}})}catch{}}return n}const h=256*1024,x=400;async function b(t,n=a()){try{await d(l(n),{recursive:!0}),await u(n,v(t)+`
+`,"utf-8");const i=await s(n,"utf-8");if(Buffer.byteLength(i,"utf-8")>h){const e=i.split(`
+`).filter(Boolean).slice(-x).join(`
+`)+`
+`,r=n+".tmp";await p(r,e,"utf-8"),await f(r,n)}}catch{}}async function L(t=a()){try{return g(await s(t,"utf-8"))}catch{return[]}}export{b as appendLedgerEntry,a as defaultLedgerPath,g as parseLedger,L as readLedger,v as serializeEntry};

package/dist/src/ambient-memory.js

@@ -1,67 +1 @@
-import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { resolve } from 'node:path';
-import { emptyMemory } from './ambient-recall.js';
-const MEMORY_FILE_NAME = 'ambient-memory.json';
-const MAX_MEMORY_BYTES = 64 * 1024;
-function defaultAmbientMemoryDir() {
-    return resolve(homedir(), '.cachly');
-}
-function isFiniteNumberRecord(value) {
-    if (typeof value !== 'object' || value === null || Array.isArray(value))
-        return false;
-    return Object.values(value).every((n) => typeof n === 'number' && Number.isFinite(n));
-}
-function isValidMemory(value) {
-    if (typeof value !== 'object' || value === null)
-        return false;
-    const m = value;
-    if (typeof m.turn !== 'number' || !Number.isFinite(m.turn))
-        return false;
-    if (!isFiniteNumberRecord(m.lastInjectedTurn))
-        return false;
-    if (!Array.isArray(m.injectionTurns))
-        return false;
-    if (!m.injectionTurns.every((n) => typeof n === 'number' && Number.isFinite(n)))
-        return false;
-    return true;
-}
-/**
- * Loads the persisted {@link RecallMemory} from `<dir>/ambient-memory.json`.
- * Falls back to {@link emptyMemory} when the file is missing, corrupt, larger
- * than 64KB, or structurally invalid. Never throws.
- */
-export function loadAmbientMemory(dir = defaultAmbientMemoryDir()) {
-    try {
-        const raw = readFileSync(resolve(dir, MEMORY_FILE_NAME), 'utf-8');
-        if (Buffer.byteLength(raw, 'utf-8') > MAX_MEMORY_BYTES)
-            return emptyMemory();
-        const parsed = JSON.parse(raw);
-        if (!isValidMemory(parsed))
-            return emptyMemory();
-        return {
-            turn: parsed.turn,
-            lastInjectedTurn: { ...parsed.lastInjectedTurn },
-            injectionTurns: [...parsed.injectionTurns],
-        };
-    }
-    catch {
-        return emptyMemory();
-    }
-}
-/**
- * Persists `memory` to `<dir>/ambient-memory.json` via write-then-rename so a
- * crash mid-write never corrupts the file for the next read. Never throws.
- */
-export function saveAmbientMemory(memory, dir = defaultAmbientMemoryDir()) {
-    try {
-        mkdirSync(dir, { recursive: true });
-        const path = resolve(dir, MEMORY_FILE_NAME);
-        const tmp = `${path}.tmp`;
-        writeFileSync(tmp, JSON.stringify(memory), 'utf-8');
-        renameSync(tmp, path);
-    }
-    catch {
-    }
-}
-//# sourceMappingURL=ambient-memory.js.map
+import{mkdirSync as s,readFileSync as c,renameSync as m,writeFileSync as y}from"node:fs";import{homedir as a}from"node:os";import{resolve as n}from"node:path";import{emptyMemory as i}from"./ambient-recall.js";const u="ambient-memory.json",p=64*1024;function f(){return n(a(),".cachly")}function l(e){return typeof e!="object"||e===null||Array.isArray(e)?!1:Object.values(e).every(r=>typeof r=="number"&&Number.isFinite(r))}function b(e){if(typeof e!="object"||e===null)return!1;const r=e;return!(typeof r.turn!="number"||!Number.isFinite(r.turn)||!l(r.lastInjectedTurn)||!Array.isArray(r.injectionTurns)||!r.injectionTurns.every(t=>typeof t=="number"&&Number.isFinite(t)))}function T(e=f()){try{const r=c(n(e,u),"utf-8");if(Buffer.byteLength(r,"utf-8")>p)return i();const t=JSON.parse(r);return b(t)?{turn:t.turn,lastInjectedTurn:{...t.lastInjectedTurn},injectionTurns:[...t.injectionTurns]}:i()}catch{return i()}}function F(e,r=f()){try{s(r,{recursive:!0});const t=n(r,u),o=`${t}.tmp`;y(o,JSON.stringify(e),"utf-8"),m(o,t)}catch{}}export{T as loadAmbientMemory,F as saveAmbientMemory};