@cachly-dev/mcp-server 0.10.129 → 0.10.130

package/dist/src/brain-export.js

@@ -1,119 +1,16 @@
-/**
- * Turns raw Brain lessons into the two files `cachly export` writes: a
- * human-readable Markdown dump and a machine-readable JSONL dump. Pure by
- * design — no network, no filesystem. The `export` CLI command in index.ts
- * fetches the lessons and writes the files these functions build.
- */
-/**
- * Macht aus einem gespeicherten Lektions-Datensatz eine ExportLesson.
- *
- * Die bekannten Felder werden benannt, damit das Markdown sie rendern kann.
- * Der ganze Datensatz bleibt zusaetzlich unter `raw` erhalten, damit die
- * JSONL-Zeile nichts verliert.
- */
-export function vonRohLektion(roh) {
-    if (typeof roh !== 'object' || roh === null)
-        return null;
-    const r = roh;
-    const topic = typeof r.topic === 'string' ? r.topic : '';
-    if (!topic)
-        return null;
-    const text = (v) => (typeof v === 'string' && v ? v : undefined);
-    const liste = (v) => Array.isArray(v) && v.length > 0 ? v.filter((x) => typeof x === 'string') : undefined;
-    return {
-        topic,
-        outcome: text(r.outcome),
-        severity: text(r.severity),
-        whatWorked: text(r.what_worked),
-        whatFailed: text(r.what_failed),
-        filePaths: liste(r.file_paths),
-        tags: liste(r.tags),
-        ts: text(r.ts),
-        author: text(r.author),
-        recallCount: typeof r.recall_count === 'number' ? r.recall_count : undefined,
-        raw: r,
-    };
-}
-const UNGROUPED_HEADING = 'Ungrouped';
-function groupByCategory(lessons) {
-    const groups = new Map();
-    for (const lesson of lessons) {
-        const colonIdx = lesson.topic.indexOf(':');
-        const category = colonIdx > 0 ? lesson.topic.slice(0, colonIdx) : UNGROUPED_HEADING;
-        const bucket = groups.get(category);
-        if (bucket) {
-            bucket.push(lesson);
-        }
-        else {
-            groups.set(category, [lesson]);
-        }
-    }
-    return groups;
-}
-function renderLesson(lesson) {
-    const fields = [];
-    if (lesson.outcome)
-        fields.push(`- **Outcome:** ${lesson.outcome}`);
-    if (lesson.severity)
-        fields.push(`- **Severity:** ${lesson.severity}`);
-    if (lesson.ts)
-        fields.push(`- **Date:** ${lesson.ts}`);
-    if (lesson.filePaths && lesson.filePaths.length > 0)
-        fields.push(`- **Files:** ${lesson.filePaths.join(', ')}`);
-    if (lesson.author)
-        fields.push(`- **Author:** ${lesson.author}`);
-    if (lesson.tags && lesson.tags.length > 0)
-        fields.push(`- **Tags:** ${lesson.tags.join(', ')}`);
-    const body = [];
-    if (lesson.whatWorked)
-        body.push(lesson.whatWorked);
-    if (lesson.whatFailed)
-        body.push(`**What failed:** ${lesson.whatFailed}`);
-    return [`### ${lesson.topic}`, '', ...fields, '', ...body].join('\n').trimEnd();
-}
-/**
- * Builds the human-readable Markdown dump: one `##` section per topic
- * category (the part of `topic` before the first `:`, or "Ungrouped" when
- * there is none), one `###` subsection per lesson listing outcome, severity,
- * date and files. Never throws — an empty list renders a plain "no lessons
- * yet" line instead of an empty document, and any text in a lesson (however
- * unusual) is written as-is without breaking the surrounding structure.
- */
-export function buildLessonsMarkdown(lessons) {
-    if (lessons.length === 0) {
-        return '# Your Cachly Brain\n\nNo lessons yet — nothing to export.\n';
-    }
-    const groups = groupByCategory(lessons);
-    const categories = [...groups.keys()].sort((a, b) => a.localeCompare(b));
-    const sections = categories.map((category) => {
-        const entries = groups.get(category).map(renderLesson).join('\n\n');
-        return `## ${category}\n\n${entries}`;
-    });
-    const count = lessons.length;
-    const heading = `# Your Cachly Brain\n\n${count} lesson${count === 1 ? '' : 's'}, grouped by topic.`;
-    return [heading, ...sections].join('\n\n') + '\n';
-}
-/**
- * Builds the machine-readable JSONL dump: one JSON object per line, one
- * line per lesson, snake_case keys matching `learn_from_attempts` so the
- * file can be grepped, jq'd or re-imported without a schema lookup. Fields
- * that are absent on a lesson are simply omitted from its line. An empty
- * list returns an empty string (a zero-line file), never throws.
- */
-export function buildLessonsJsonl(lessons) {
-    if (lessons.length === 0)
-        return '';
-    return lessons.map((lesson) => JSON.stringify(lesson.raw ?? {
-        topic: lesson.topic,
-        outcome: lesson.outcome,
-        severity: lesson.severity,
-        what_worked: lesson.whatWorked,
-        what_failed: lesson.whatFailed,
-        file_paths: lesson.filePaths,
-        tags: lesson.tags,
-        ts: lesson.ts,
-        author: lesson.author,
-        recall_count: lesson.recallCount,
-    })).join('\n') + '\n';
-}
-//# sourceMappingURL=brain-export.js.map
+function p(e){if(typeof e!="object"||e===null)return null;const t=e,i=typeof t.topic=="string"?t.topic:"";if(!i)return null;const o=r=>typeof r=="string"&&r?r:void 0,n=r=>Array.isArray(r)&&r.length>0?r.filter(a=>typeof a=="string"):void 0;return{topic:i,outcome:o(t.outcome),severity:o(t.severity),whatWorked:o(t.what_worked),whatFailed:o(t.what_failed),filePaths:n(t.file_paths),tags:n(t.tags),ts:o(t.ts),author:o(t.author),recallCount:typeof t.recall_count=="number"?t.recall_count:void 0,raw:t}}const c="Ungrouped";function h(e){const t=new Map;for(const i of e){const o=i.topic.indexOf(":"),n=o>0?i.topic.slice(0,o):c,r=t.get(n);r?r.push(i):t.set(n,[i])}return t}function f(e){const t=[];e.outcome&&t.push(`- **Outcome:** ${e.outcome}`),e.severity&&t.push(`- **Severity:** ${e.severity}`),e.ts&&t.push(`- **Date:** ${e.ts}`),e.filePaths&&e.filePaths.length>0&&t.push(`- **Files:** ${e.filePaths.join(", ")}`),e.author&&t.push(`- **Author:** ${e.author}`),e.tags&&e.tags.length>0&&t.push(`- **Tags:** ${e.tags.join(", ")}`);const i=[];return e.whatWorked&&i.push(e.whatWorked),e.whatFailed&&i.push(`**What failed:** ${e.whatFailed}`),[`### ${e.topic}`,"",...t,"",...i].join(`
+`).trimEnd()}function d(e){if(e.length===0)return`# Your Cachly Brain
+
+No lessons yet \u2014 nothing to export.
+`;const t=h(e),o=[...t.keys()].sort((a,u)=>a.localeCompare(u)).map(a=>{const u=t.get(a).map(f).join(`
+
+`);return`## ${a}
+
+${u}`}),n=e.length;return[`# Your Cachly Brain
+
+${n} lesson${n===1?"":"s"}, grouped by topic.`,...o].join(`
+
+`)+`
+`}function g(e){return e.length===0?"":e.map(t=>JSON.stringify(t.raw??{topic:t.topic,outcome:t.outcome,severity:t.severity,what_worked:t.whatWorked,what_failed:t.whatFailed,file_paths:t.filePaths,tags:t.tags,ts:t.ts,author:t.author,recall_count:t.recallCount})).join(`
+`)+`
+`}export{g as buildLessonsJsonl,d as buildLessonsMarkdown,p as vonRohLektion};

package/dist/src/brain-watch-hook.js

@@ -1,86 +1,8 @@
-// Ambient git post-commit hook builder for Brain auto-learning.
-//
-// Installs a .git/hooks/post-commit script that POSTs the commit data
-// directly to the cachly API via curl — no Node required at hook runtime,
-// so it works even without npx or the MCP server installed locally.
-//
-// Safety contract:
-//   • exit 0 is ALWAYS the last line — the hook never blocks a commit.
-//   • All network calls run in the background (&) with 2>/dev/null.
-//   • Commit message / sha / files are never interpolated into JS source;
-//     they're passed as shell variables in the JSON body (curl --data-raw).
-import { existsSync } from 'node:fs';
-import { readFile, writeFile, chmod, mkdir } from 'node:fs/promises';
-import { resolve } from 'node:path';
-/** Bumped whenever the hook script changes so installers can upgrade old hooks. */
-export const BRAIN_WATCH_HOOK_VERSION = 'v1';
-/**
- * Matches any previously-installed cachly brain_watch block (from its marker
- * comment down to the trailing `exit 0`), optionally including a shebang.
- * Used to upgrade old hooks in place rather than duplicating them.
- */
-const BRAIN_WATCH_BLOCK_RE = /(?:#!\/bin\/sh\n)?# cachly brain_watch[\s\S]*?\nexit 0\n?/;
-/**
- * Idempotently install/upgrade the brain_watch post-commit hook in `projectDir`.
- * Never throws — returns a status string the caller can report. Safe to run
- * repeatedly; a second call with the same version returns 'unchanged'.
- */
-export async function installBrainWatchHook(projectDir, instanceId, apiKey) {
-    if (!existsSync(resolve(projectDir, '.git'))) {
-        return { result: 'skipped-no-git', hookPath: '' };
-    }
-    const hookDir = resolve(projectDir, '.git', 'hooks');
-    const hookPath = resolve(hookDir, 'post-commit');
-    await mkdir(hookDir, { recursive: true });
-    const script = buildBrainWatchHook(instanceId, apiKey);
-    let existing = '';
-    try {
-        existing = await readFile(hookPath, 'utf-8');
-    }
-    catch { /* no existing hook */ }
-    if (!existing) {
-        await writeFile(hookPath, script + '\n', 'utf-8');
-        await chmod(hookPath, 0o755).catch(() => { });
-        return { result: 'written', hookPath };
-    }
-    if (existing.includes(`cachly brain_watch — Auto-Learn ${BRAIN_WATCH_HOOK_VERSION}`)) {
-        return { result: 'unchanged', hookPath };
-    }
-    if (BRAIN_WATCH_BLOCK_RE.test(existing)) {
-        const replaced = existing.replace(BRAIN_WATCH_BLOCK_RE, script);
-        await writeFile(hookPath, replaced.endsWith('\n') ? replaced : replaced + '\n', 'utf-8');
-        await chmod(hookPath, 0o755).catch(() => { });
-        return { result: 'upgraded', hookPath };
-    }
-    // Foreign hook with no brain_watch block → append ours.
-    await writeFile(hookPath, existing.trimEnd() + '\n\n' + script + '\n', 'utf-8');
-    await chmod(hookPath, 0o755).catch(() => { });
-    return { result: 'appended', hookPath };
-}
-/**
- * Build the `.git/hooks/post-commit` shell script for brain_watch.
- * Uses curl (not Node) so it works without npx. Runs in the background and
- * always exits 0 — never blocks a commit.
- *
- * @param instanceId  Cachly Brain instance to learn into.
- * @param apiKey      Optional cky_… key; if absent, the script reads $CACHLY_JWT from env.
- */
-export function buildBrainWatchHook(instanceId, apiKey) {
-    return [
-        `#!/bin/sh`,
-        `# cachly brain_watch — Auto-Learn ${BRAIN_WATCH_HOOK_VERSION}`,
-        `# Silently teaches your Brain after every commit — no manual brain_from_git needed.`,
-        ...(apiKey ? [`CACHLY_JWT="${apiKey}"`] : []),
-        `_BW_SHA=$(git rev-parse HEAD 2>/dev/null || echo "")`,
-        `_BW_MSG=$(git log -1 --pretty=%B 2>/dev/null | head -1 | cut -c1-200)`,
-        `_BW_FILES=$(git diff-tree --no-commit-id -r --name-only HEAD 2>/dev/null | tr '\\n' '\\t' | sed 's/\\t$//')`,
-        `(curl -s -o /dev/null -m 8 \\`,
-        `  -X POST "https://api.cachly.dev/api/v1/instances/${instanceId}/learn" \\`,
-        `  -H "Authorization: Bearer \${CACHLY_JWT}" \\`,
-        `  -H "Content-Type: application/json" \\`,
-        `  --data-raw "{\\"message\\":\\"$(echo "$_BW_MSG" | sed 's/"/\\\\"/g')\\",\\"sha\\":\\"$_BW_SHA\\",\\"files\\":[$(echo "$_BW_FILES" | tr '\\t' '\\n' | grep -v '^$' | sed 's/.*/\\"&\\"/' | tr '\\n' ',' | sed 's/,$//')],\\"source\\":\\"brain_watch\\"}" \\`,
-        `) 2>/dev/null &`,
-        `exit 0`,
-    ].join('\n');
-}
-//# sourceMappingURL=brain-watch-hook.js.map
+import{existsSync as _}from"node:fs";import{readFile as p,writeFile as o,chmod as c,mkdir as m}from"node:fs/promises";import{resolve as s}from"node:path";const u="v1",h=/(?:#!\/bin\/sh\n)?# cachly brain_watch[\s\S]*?\nexit 0\n?/;async function B(n,a,d){if(!_(s(n,".git")))return{result:"skipped-no-git",hookPath:""};const l=s(n,".git","hooks"),t=s(l,"post-commit");await m(l,{recursive:!0});const r=f(a,d);let e="";try{e=await p(t,"utf-8")}catch{}if(!e)return await o(t,r+`
+`,"utf-8"),await c(t,493).catch(()=>{}),{result:"written",hookPath:t};if(e.includes(`cachly brain_watch \u2014 Auto-Learn ${u}`))return{result:"unchanged",hookPath:t};if(h.test(e)){const i=e.replace(h,r);return await o(t,i.endsWith(`
+`)?i:i+`
+`,"utf-8"),await c(t,493).catch(()=>{}),{result:"upgraded",hookPath:t}}return await o(t,e.trimEnd()+`
+
+`+r+`
+`,"utf-8"),await c(t,493).catch(()=>{}),{result:"appended",hookPath:t}}function f(n,a){return["#!/bin/sh",`# cachly brain_watch \u2014 Auto-Learn ${u}`,"# Silently teaches your Brain after every commit \u2014 no manual brain_from_git needed.",...a?[`CACHLY_JWT="${a}"`]:[],'_BW_SHA=$(git rev-parse HEAD 2>/dev/null || echo "")',"_BW_MSG=$(git log -1 --pretty=%B 2>/dev/null | head -1 | cut -c1-200)","_BW_FILES=$(git diff-tree --no-commit-id -r --name-only HEAD 2>/dev/null | tr '\\n' '\\t' | sed 's/\\t$//')","(curl -s -o /dev/null -m 8 \\",`  -X POST "https://api.cachly.dev/api/v1/instances/${n}/learn" \\`,'  -H "Authorization: Bearer ${CACHLY_JWT}" \\','  -H "Content-Type: application/json" \\',`  --data-raw "{\\"message\\":\\"$(echo "$_BW_MSG" | sed 's/"/\\\\"/g')\\",\\"sha\\":\\"$_BW_SHA\\",\\"files\\":[$(echo "$_BW_FILES" | tr '\\t' '\\n' | grep -v '^$' | sed 's/.*/\\"&\\"/' | tr '\\n' ',' | sed 's/,$//')],\\"source\\":\\"brain_watch\\"}" \\`,") 2>/dev/null &","exit 0"].join(`
+`)}export{u as BRAIN_WATCH_HOOK_VERSION,f as buildBrainWatchHook,B as installBrainWatchHook};

package/dist/src/cachly-url.js

@@ -1,21 +1 @@
-const CACHLY_ORIGIN = 'https://cachly.dev';
-/**
- * Builds a cachly.dev URL that carries a `utm_source` tag naming the place
- * the click came from, so Plausible can group clicks instead of showing
- * every visit as "direct".
- *
- * Pure: no network, no filesystem, no environment access. Existing query
- * parts in `path` are preserved; an existing `utm_source` is replaced, never
- * duplicated. `path` may include a path segment such as an instance ID —
- * `source` must never be anything but a value from {@link UrlQuelle}.
- */
-export function cachlyUrl(path, source) {
-    const withSlash = path.startsWith('/') ? path : `/${path}`;
-    const questionMark = withSlash.indexOf('?');
-    const pathPart = questionMark === -1 ? withSlash : withSlash.slice(0, questionMark);
-    const queryPart = questionMark === -1 ? '' : withSlash.slice(questionMark + 1);
-    const params = new URLSearchParams(queryPart);
-    params.set('utm_source', source);
-    return `${CACHLY_ORIGIN}${pathPart}?${params.toString()}`;
-}
-//# sourceMappingURL=cachly-url.js.map
+const o="https://cachly.dev";function i(c,n){const t=c.startsWith("/")?c:`/${c}`,s=t.indexOf("?"),e=s===-1?t:t.slice(0,s),a=s===-1?"":t.slice(s+1),r=new URLSearchParams(a);return r.set("utm_source",n),`${o}${e}?${r.toString()}`}export{i as cachlyUrl};

package/dist/src/ckg.js

@@ -1,108 +1 @@
-const STOPWORDS_CKG = new Set(['that', 'this', 'with', 'from', 'when', 'then', 'also', 'have', 'been', 'will', 'were', 'they', 'them', 'than', 'more', 'some', 'into', 'over', 'only', 'just', 'where', 'while', 'which', 'there', 'their', 'would', 'could', 'should', 'after', 'before', 'about']);
-export function ckgSlug(text) {
-    return text.toLowerCase().replace(/[^a-z0-9\-:]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '').slice(0, 80);
-}
-/** Extract 1-3 significant keywords from free text for a problem concept */
-export function extractProblemConcept(text) {
-    const words = text.toLowerCase()
-        .replace(/[^a-z0-9\s\-_]/g, ' ').split(/\s+/)
-        .filter(w => w.length > 3 && !STOPWORDS_CKG.has(w))
-        .slice(0, 5);
-    if (words.length === 0)
-        return null;
-    return words.slice(0, 2).join('-');
-}
-export async function ckgUpsertNode(redis, id, domain, type) {
-    const key = `cachly:ckg:node:${id}`;
-    const raw = await redis.get(key);
-    const node = raw ? JSON.parse(raw) : { id, domain, type, count: 0, ts: new Date().toISOString() };
-    node.count = (node.count || 0) + 1;
-    node.ts = new Date().toISOString();
-    await redis.set(key, JSON.stringify(node));
-}
-/** Upsert a Person node; returns the node id ("person:{slug}"). */
-export async function ckgUpsertPersonNode(redis, handle, domain) {
-    const id = `person:${ckgSlug(handle)}`;
-    const key = `cachly:ckg:node:${id}`;
-    const raw = await redis.get(key);
-    const node = raw
-        ? JSON.parse(raw)
-        : { id, handle, domain, type: 'person', count: 0, last_active: new Date().toISOString() };
-    node.count = (node.count || 0) + 1;
-    node.last_active = new Date().toISOString();
-    if (!node.domain)
-        node.domain = domain;
-    await redis.set(key, JSON.stringify(node));
-    return id;
-}
-/** Upsert a File node; returns the node id ("file:{slug}"). */
-export async function ckgUpsertFileNode(redis, filePath) {
-    const dir = filePath.split('/')[0] ?? 'root';
-    const id = `file:${ckgSlug(filePath)}`;
-    const key = `cachly:ckg:node:${id}`;
-    const raw = await redis.get(key);
-    const node = raw
-        ? JSON.parse(raw)
-        : { id, path: filePath, domain: dir, type: 'file', count: 0, ts: new Date().toISOString() };
-    node.count = (node.count || 0) + 1;
-    node.ts = new Date().toISOString();
-    await redis.set(key, JSON.stringify(node));
-    return id;
-}
-/** Upsert a Service/System node; returns the node id ("service:{slug}"). */
-export async function ckgUpsertServiceNode(redis, name, domain, kind = 'service') {
-    const id = `service:${ckgSlug(name)}`;
-    const key = `cachly:ckg:node:${id}`;
-    const raw = await redis.get(key);
-    const node = raw
-        ? JSON.parse(raw)
-        : { id, name, kind, domain, type: 'service', count: 0, last_active: new Date().toISOString() };
-    node.count = (node.count || 0) + 1;
-    node.last_active = new Date().toISOString();
-    if (!node.domain)
-        node.domain = domain;
-    // A node may start life as a 'service' and later be classified as 'system' (or vice
-    // versa) by an explicit caller — honour the latest non-default classification.
-    if (kind === 'system')
-        node.kind = 'system';
-    await redis.set(key, JSON.stringify(node));
-    return id;
-}
-export async function ckgUpdateEdge(redis, from, edgeType, to, success, partial = false) {
-    const key = `cachly:ckg:edge:${from}:${edgeType}:${to}`;
-    const raw = await redis.get(key);
-    const edge = raw ? JSON.parse(raw) : { from, to, edgeType, successes: 0, trials: 0, confidence: 0, last_updated: '' };
-    edge.trials = (edge.trials || 0) + 1;
-    if (success)
-        edge.successes = (edge.successes || 0) + 1;
-    else if (partial)
-        edge.successes = (edge.successes || 0) + 0.5;
-    // Beta distribution smoothed confidence: (successes+1) / (trials+2)
-    edge.confidence = (edge.successes + 1) / (edge.trials + 2);
-    edge.last_updated = new Date().toISOString();
-    await redis.set(key, JSON.stringify(edge));
-    // Index: set of edge keys per source node (for fast traversal)
-    await redis.sadd(`cachly:ckg:idx:from:${from}`, key);
-    await redis.sadd(`cachly:ckg:idx:to:${to}`, key);
-}
-/**
- * Phase 3: Collaboration graph. When `personId` touches `fileId`, record a
- * bidirectional `collaborates` edge to every *other* person who has touched the
- * same file. Builds the person↔person graph organically — "who works with whom".
- * Bounded: only the first MAX_CO_TOUCHERS prior touchers are linked, so a hot file
- * touched by hundreds of people can't blow up the write path.
- */
-const MAX_CO_TOUCHERS = 25;
-export async function ckgRecordCollaboration(redis, fileId, personId) {
-    const touchersKey = `cachly:ckg:file:touchers:${fileId}`;
-    const priorTouchers = await redis.smembers(touchersKey);
-    for (const other of priorTouchers.slice(0, MAX_CO_TOUCHERS)) {
-        if (other === personId)
-            continue;
-        // Symmetric edges so traversal works from either node.
-        await ckgUpdateEdge(redis, personId, 'collaborates', other, true);
-        await ckgUpdateEdge(redis, other, 'collaborates', personId, true);
-    }
-    await redis.sadd(touchersKey, personId);
-}
-//# sourceMappingURL=ckg.js.map
+const g=new Set(["that","this","with","from","when","then","also","have","been","will","were","they","them","than","more","some","into","over","only","just","where","while","which","there","their","would","could","should","after","before","about"]);function l(t){return t.toLowerCase().replace(/[^a-z0-9\-:]/g,"-").replace(/-+/g,"-").replace(/^-|-$/g,"").slice(0,80)}function S(t){const c=t.toLowerCase().replace(/[^a-z0-9\s\-_]/g," ").split(/\s+/).filter(n=>n.length>3&&!g.has(n)).slice(0,5);return c.length===0?null:c.slice(0,2).join("-")}async function y(t,c,n,o){const a=`cachly:ckg:node:${c}`,s=await t.get(a),e=s?JSON.parse(s):{id:c,domain:n,type:o,count:0,ts:new Date().toISOString()};e.count=(e.count||0)+1,e.ts=new Date().toISOString(),await t.set(a,JSON.stringify(e))}async function p(t,c,n){const o=`person:${l(c)}`,a=`cachly:ckg:node:${o}`,s=await t.get(a),e=s?JSON.parse(s):{id:o,handle:c,domain:n,type:"person",count:0,last_active:new Date().toISOString()};return e.count=(e.count||0)+1,e.last_active=new Date().toISOString(),e.domain||(e.domain=n),await t.set(a,JSON.stringify(e)),o}async function f(t,c){const n=c.split("/")[0]??"root",o=`file:${l(c)}`,a=`cachly:ckg:node:${o}`,s=await t.get(a),e=s?JSON.parse(s):{id:o,path:c,domain:n,type:"file",count:0,ts:new Date().toISOString()};return e.count=(e.count||0)+1,e.ts=new Date().toISOString(),await t.set(a,JSON.stringify(e)),o}async function h(t,c,n,o="service"){const a=`service:${l(c)}`,s=`cachly:ckg:node:${a}`,e=await t.get(s),r=e?JSON.parse(e):{id:a,name:c,kind:o,domain:n,type:"service",count:0,last_active:new Date().toISOString()};return r.count=(r.count||0)+1,r.last_active=new Date().toISOString(),r.domain||(r.domain=n),o==="system"&&(r.kind="system"),await t.set(s,JSON.stringify(r)),a}async function u(t,c,n,o,a,s=!1){const e=`cachly:ckg:edge:${c}:${n}:${o}`,r=await t.get(e),i=r?JSON.parse(r):{from:c,to:o,edgeType:n,successes:0,trials:0,confidence:0,last_updated:""};i.trials=(i.trials||0)+1,a?i.successes=(i.successes||0)+1:s&&(i.successes=(i.successes||0)+.5),i.confidence=(i.successes+1)/(i.trials+2),i.last_updated=new Date().toISOString(),await t.set(e,JSON.stringify(i)),await t.sadd(`cachly:ckg:idx:from:${c}`,e),await t.sadd(`cachly:ckg:idx:to:${o}`,e)}const w=25;async function d(t,c,n){const o=`cachly:ckg:file:touchers:${c}`,a=await t.smembers(o);for(const s of a.slice(0,w))s!==n&&(await u(t,n,"collaborates",s,!0),await u(t,s,"collaborates",n,!0));await t.sadd(o,n)}export{d as ckgRecordCollaboration,l as ckgSlug,u as ckgUpdateEdge,f as ckgUpsertFileNode,y as ckgUpsertNode,p as ckgUpsertPersonNode,h as ckgUpsertServiceNode,S as extractProblemConcept};

package/dist/src/cls-hook.js

@@ -1,94 +1,8 @@
-// Shared builder for the CLS (Continuous Learning Stream) git post-commit hook.
-//
-// History / why this is centralised:
-// The previous inline versions interpolated the commit message directly into a
-// `node -e "... message:'$MSG' ..."` JS string. Any commit message containing an
-// apostrophe (e.g. "don't crash") produced invalid JavaScript, so the hook
-// silently ingested nothing — and a crafted message could inject shell/JS.
-//
-// This version is robust:
-//   • Commit message / sha / files are passed to node via ENVIRONMENT VARIABLES,
-//     never interpolated into JS source — no quoting or injection breakage.
-//   • The JSON payload is handed to the CLI via execFileSync (no shell), so the
-//     shell never re-parses quotes, `$`, or backticks from the message.
-//   • CACHLY_JWT is embedded only when provided so the `cls-ingest` CLI command
-//     can authenticate; absent it, that command exits 0 silently.
-import { existsSync } from 'node:fs';
-import { readFile, writeFile, chmod, mkdir } from 'node:fs/promises';
-import { resolve } from 'node:path';
-/** Bumped whenever the hook script changes so installers can upgrade old hooks. */
-export const CLS_HOOK_VERSION = 'v2';
-/**
- * Matches any previously-installed cachly CLS block (from its marker comment
- * down to the trailing `exit 0`), optionally including an immediately-preceding
- * standalone shebang. Used to upgrade old hooks in place rather than skipping
- * them (the v1 block was a silent no-op).
- */
-const CLS_BLOCK_RE = /(?:#!\/bin\/sh\n)?# cachly CLS[\s\S]*?\nexit 0\n?/;
-/**
- * Idempotently install/upgrade the CLS post-commit hook in `projectDir`.
- * Never throws — returns a status the caller can log. Shared by `init`, `setup`
- * and `autopilot` so all paths stay in lock-step.
- */
-export async function installClsPostCommitHook(projectDir, instanceId, apiKey) {
-    if (!existsSync(resolve(projectDir, '.git')))
-        return 'skipped-no-git';
-    const hookDir = resolve(projectDir, '.git', 'hooks');
-    const hookPath = resolve(hookDir, 'post-commit');
-    await mkdir(hookDir, { recursive: true });
-    const script = buildClsPostCommitHook(instanceId, apiKey);
-    let existing = '';
-    try {
-        existing = await readFile(hookPath, 'utf-8');
-    }
-    catch { /* no existing hook */ }
-    if (!existing) {
-        await writeFile(hookPath, script + '\n', 'utf-8');
-        await chmod(hookPath, 0o755).catch(() => { });
-        return 'written';
-    }
-    if (existing.includes(`cachly CLS — Continuous Learning Stream ${CLS_HOOK_VERSION}`)) {
-        return 'unchanged';
-    }
-    if (CLS_BLOCK_RE.test(existing)) {
-        // Upgrade an older cachly block in place, preserving any surrounding hook.
-        const replaced = existing.replace(CLS_BLOCK_RE, script);
-        await writeFile(hookPath, replaced.endsWith('\n') ? replaced : replaced + '\n', 'utf-8');
-        await chmod(hookPath, 0o755).catch(() => { });
-        return 'upgraded';
-    }
-    // Foreign hook with no cachly block → append ours.
-    await writeFile(hookPath, existing.trimEnd() + '\n\n' + script + '\n', 'utf-8');
-    await chmod(hookPath, 0o755).catch(() => { });
-    return 'appended';
-}
-/** The node `-e` program — reads commit data from env, ingests via the CLI. */
-const CLS_NODE_PROGRAM = "try{" +
-    "var p={instance_id:process.env.CACHLY_BRAIN_INSTANCE_ID,source:'git_commit'," +
-    "payload:{message:process.env.CLS_MSG||'',sha:process.env.CLS_SHA||''," +
-    "files:(process.env.CLS_FILES||'').split(',').filter(Boolean)}};" +
-    "require('child_process').execFileSync('npx',['@cachly-dev/mcp-server@latest','cls-ingest',JSON.stringify(p)]," +
-    "{stdio:'ignore',timeout:8000});" +
-    "}catch(e){}";
-/**
- * Build the `.git/hooks/post-commit` shell script.
- * @param instanceId  Cachly Brain instance to ingest into.
- * @param apiKey      Optional cky_… key embedded for authentication.
- */
-export function buildClsPostCommitHook(instanceId, apiKey) {
-    return [
-        `#!/bin/sh`,
-        `# cachly CLS — Continuous Learning Stream ${CLS_HOOK_VERSION}`,
-        `# Runs silently on every commit to keep your brain up to date.`,
-        `export CACHLY_BRAIN_INSTANCE_ID="${instanceId}"`,
-        ...(apiKey ? [`export CACHLY_JWT="${apiKey}"`] : []),
-        `CLS_SHA=$(git rev-parse HEAD 2>/dev/null || echo "")`,
-        // No `tr`/quote-mangling — the message is passed verbatim via env.
-        `CLS_MSG=$(git log -1 --pretty=%B 2>/dev/null | head -1 | cut -c1-200)`,
-        `CLS_FILES=$(git diff-tree --no-commit-id -r --name-only HEAD 2>/dev/null | tr '\\n' ',' | sed 's/,$//')`,
-        `export CLS_SHA CLS_MSG CLS_FILES`,
-        `node -e "${CLS_NODE_PROGRAM}" 2>/dev/null &`,
-        `exit 0`,
-    ].join('\n');
-}
-//# sourceMappingURL=cls-hook.js.map
+import{existsSync as C}from"node:fs";import{readFile as d,writeFile as s,chmod as c,mkdir as m}from"node:fs/promises";import{resolve as a}from"node:path";const u="v2",S=/(?:#!\/bin\/sh\n)?# cachly CLS[\s\S]*?\nexit 0\n?/;async function v(n,i,p){if(!C(a(n,".git")))return"skipped-no-git";const l=a(n,".git","hooks"),t=a(l,"post-commit");await m(l,{recursive:!0});const o=L(i,p);let e="";try{e=await d(t,"utf-8")}catch{}if(!e)return await s(t,o+`
+`,"utf-8"),await c(t,493).catch(()=>{}),"written";if(e.includes(`cachly CLS \u2014 Continuous Learning Stream ${u}`))return"unchanged";if(S.test(e)){const r=e.replace(S,o);return await s(t,r.endsWith(`
+`)?r:r+`
+`,"utf-8"),await c(t,493).catch(()=>{}),"upgraded"}return await s(t,e.trimEnd()+`
+
+`+o+`
+`,"utf-8"),await c(t,493).catch(()=>{}),"appended"}const _="try{var p={instance_id:process.env.CACHLY_BRAIN_INSTANCE_ID,source:'git_commit',payload:{message:process.env.CLS_MSG||'',sha:process.env.CLS_SHA||'',files:(process.env.CLS_FILES||'').split(',').filter(Boolean)}};require('child_process').execFileSync('npx',['@cachly-dev/mcp-server@latest','cls-ingest',JSON.stringify(p)],{stdio:'ignore',timeout:8000});}catch(e){}";function L(n,i){return["#!/bin/sh",`# cachly CLS \u2014 Continuous Learning Stream ${u}`,"# Runs silently on every commit to keep your brain up to date.",`export CACHLY_BRAIN_INSTANCE_ID="${n}"`,...i?[`export CACHLY_JWT="${i}"`]:[],'CLS_SHA=$(git rev-parse HEAD 2>/dev/null || echo "")',"CLS_MSG=$(git log -1 --pretty=%B 2>/dev/null | head -1 | cut -c1-200)","CLS_FILES=$(git diff-tree --no-commit-id -r --name-only HEAD 2>/dev/null | tr '\\n' ',' | sed 's/,$//')","export CLS_SHA CLS_MSG CLS_FILES",`node -e "${_}" 2>/dev/null &`,"exit 0"].join(`
+`)}export{u as CLS_HOOK_VERSION,L as buildClsPostCommitHook,v as installClsPostCommitHook};

package/dist/src/confidence.js

@@ -1,50 +1 @@
-import { createHash } from 'node:crypto';
-// ── Confidence Decay Config ───────────────────────────────────────────────────
-export const CONFIDENCE_WARN_DAYS = Number(process.env.CACHLY_CONFIDENCE_WARN_DAYS ?? 5);
-export const CONFIDENCE_STALE_DAYS = Number(process.env.CACHLY_CONFIDENCE_STALE_DAYS ?? 10);
-export const CONFIDENCE_WARN_VALUE = 0.7;
-export const CONFIDENCE_STALE_VALUE = 0.5;
-// ── One of THREE deliberately-different age/decay curves. Do NOT unify them. ──
-// This one (SHARP: 0.7@5d, 0.5@10d) is a user-facing *staleness warning* — it
-// drives the recall_best_solution freshness badge and brain_predict, where the
-// point is to shout "verify before applying" once a lesson is old.
-//   • Ranking uses a SEPARATE, gentle curve — search.ts `recencyBoost`
-//     (0.5^(age/7)+0.5, range [0.5,1.5]). It is bench-tuned. Feeding THIS sharp
-//     curve into the recall rerank regressed every Cachly-Bench floor (home P@1
-//     92→77%) and was reverted — see PR #228. Relevant lessons are often days
-//     /weeks old; penalising age hard in ranking buries the right answer.
-//   • The knowledge_decay *report* uses a THIRD, points-based curve
-//     (advanced.ts) that also folds in recall_count + outcome.
-// Three purposes, three curves — that divergence is intentional, not a bug.
-/** Calculate current confidence for a lesson based on how long since last verified. */
-export function calculateConfidence(lesson) {
-    const ref = lesson.verified_at ?? lesson.ts;
-    const ageMs = Date.now() - new Date(ref).getTime();
-    const ageDays = ageMs / 86400000;
-    if (ageDays >= CONFIDENCE_STALE_DAYS)
-        return CONFIDENCE_STALE_VALUE;
-    if (ageDays >= CONFIDENCE_WARN_DAYS)
-        return CONFIDENCE_WARN_VALUE;
-    return 1.0 - (ageDays / CONFIDENCE_WARN_DAYS) * (1.0 - CONFIDENCE_WARN_VALUE);
-}
-/** Render a confidence badge string. */
-export function confidenceBadge(confidence, ageDays) {
-    if (confidence >= 0.9)
-        return '✅';
-    if (confidence >= 0.7)
-        return `⚠️ (${Math.round(ageDays)}d old, confidence ${(confidence * 100).toFixed(0)}% — verify before applying)`;
-    return `🔴 STALE (${Math.round(ageDays)}d old, confidence ${(confidence * 100).toFixed(0)}% — likely outdated!)`;
-}
-/** Category-specific required fields for structured lessons. */
-export const STRUCTURED_TEMPLATES = {
-    'deploy': { required: ['commands'], hint: 'deploy:* needs commands[]' },
-    'bash': { required: ['commands'], hint: 'bash:* needs commands[]' },
-    'infra': { required: ['commands'], hint: 'infra:* needs commands[] + verified on real system' },
-    'pricing': { required: [], hint: 'pricing:* — add context with source (e.g. "Stripe Dashboard Apr 2026")' },
-    'stripe': { required: [], hint: 'stripe:* — add context with Stripe API version' },
-};
-/** Fast content hash for index invalidation (not cryptographic, just change detection) */
-export function simpleHash(text) {
-    return createHash('md5').update(text).digest('hex').slice(0, 12);
-}
-//# sourceMappingURL=confidence.js.map
+import{createHash as i}from"node:crypto";const n=Number(process.env.CACHLY_CONFIDENCE_WARN_DAYS??5),d=Number(process.env.CACHLY_CONFIDENCE_STALE_DAYS??10),o=.7,s=.5;function p(e){const r=e.verified_at??e.ts,t=(Date.now()-new Date(r).getTime())/864e5;return t>=d?s:t>=n?o:1-t/n*(1-o)}function u(e,r){return e>=.9?"\u2705":e>=.7?`\u26A0\uFE0F (${Math.round(r)}d old, confidence ${(e*100).toFixed(0)}% \u2014 verify before applying)`:`\u{1F534} STALE (${Math.round(r)}d old, confidence ${(e*100).toFixed(0)}% \u2014 likely outdated!)`}const E={deploy:{required:["commands"],hint:"deploy:* needs commands[]"},bash:{required:["commands"],hint:"bash:* needs commands[]"},infra:{required:["commands"],hint:"infra:* needs commands[] + verified on real system"},pricing:{required:[],hint:'pricing:* \u2014 add context with source (e.g. "Stripe Dashboard Apr 2026")'},stripe:{required:[],hint:"stripe:* \u2014 add context with Stripe API version"}};function m(e){return i("md5").update(e).digest("hex").slice(0,12)}export{d as CONFIDENCE_STALE_DAYS,s as CONFIDENCE_STALE_VALUE,n as CONFIDENCE_WARN_DAYS,o as CONFIDENCE_WARN_VALUE,E as STRUCTURED_TEMPLATES,p as calculateConfidence,u as confidenceBadge,m as simpleHash};

package/dist/src/credentials.js

@@ -1,85 +1 @@
-// Credentials — where the ambient hooks and CLI resolve the API key from
-// (GROW-015): never a literal in a generated/committed file, always the
-// environment or a file in the user's home directory.
-import { existsSync, mkdirSync, writeFileSync, renameSync, chmodSync, readFileSync } from 'node:fs';
-import { resolve, dirname } from 'node:path';
-function defaultHome() {
-    return process.env.HOME ?? process.env.USERPROFILE ?? process.env.APPDATA ?? '';
-}
-function nonEmpty(value) {
-    return typeof value === 'string' && value.length > 0 ? value : undefined;
-}
-/**
- * Path of the local credentials file in the user's home directory
- * (`<home>/.cachly/credentials.json`) — never inside a project checkout.
- * Mirrors the HOME/USERPROFILE/APPDATA fallback `persistApiKeyToConfig`
- * already uses for `~/.claude/mcp.json`.
- */
-export function credentialsPath(opts = {}) {
-    const home = opts.home ?? defaultHome();
-    return resolve(home, '.cachly', 'credentials.json');
-}
-/**
- * Persists the API key to {@link credentialsPath} so ambient hooks (which run
- * as bare OS processes and never see the MCP config's env) can find it at
- * run time without it ever being embedded in a generated script. Writes via
- * a temp file + rename so a crash mid-write can never leave a truncated
- * file, and restricts the file to the owner (0600 — a no-op on Windows).
- * Best-effort: a failure here never throws, matching every other ambient-path
- * write (setup and CLI auth still succeed without a persisted copy).
- */
-export function saveApiKey(key, opts = {}) {
-    try {
-        const target = credentialsPath(opts);
-        mkdirSync(dirname(target), { recursive: true });
-        const tmp = `${target}.${process.pid}-${Date.now()}.tmp`;
-        writeFileSync(tmp, JSON.stringify({ apiKey: key }, null, 2), 'utf8');
-        try {
-            chmodSync(tmp, 0o600);
-        }
-        catch { /* e.g. Windows — best-effort */ }
-        renameSync(tmp, target);
-    }
-    catch { /* best-effort — a failed persist must not break the caller */ }
-}
-function readHomeCredential(opts) {
-    try {
-        const path = credentialsPath(opts);
-        if (!existsSync(path))
-            return undefined;
-        const parsed = JSON.parse(readFileSync(path, 'utf8'));
-        return nonEmpty(parsed.apiKey);
-    }
-    catch {
-        return undefined;
-    }
-}
-function readProjectConfigKey(opts) {
-    try {
-        const path = resolve(opts.cwd ?? process.cwd(), '.mcp.json');
-        if (!existsSync(path))
-            return undefined;
-        const parsed = JSON.parse(readFileSync(path, 'utf8'));
-        return nonEmpty(parsed.mcpServers?.cachly?.env?.CACHLY_JWT);
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * Resolves the API key the same way for every ambient/CLI caller, in order:
- * `CACHLY_JWT` env -> `CACHLY_API_KEY` env -> {@link credentialsPath} in the
- * user's home -> (legacy fallback) `mcpServers.cachly.env.CACHLY_JWT` in a
- * project's `.mcp.json`, for installs from before this file existed. A
- * corrupt file at any source counts as empty rather than throwing. Returns
- * `undefined` — never an empty string — when nothing is found, so callers
- * can tell "no key" apart from "empty key" with a plain truthiness check.
- */
-export function resolveApiKey(opts = {}) {
-    const env = opts.env ?? process.env;
-    return (nonEmpty(env.CACHLY_JWT) ??
-        nonEmpty(env.CACHLY_API_KEY) ??
-        readHomeCredential(opts) ??
-        readProjectConfigKey(opts));
-}
-//# sourceMappingURL=credentials.js.map
+import{existsSync as o,mkdirSync as p,writeFileSync as a,renameSync as d,chmodSync as f,readFileSync as i}from"node:fs";import{resolve as s,dirname as y}from"node:path";function m(){return process.env.HOME??process.env.USERPROFILE??process.env.APPDATA??""}function t(e){return typeof e=="string"&&e.length>0?e:void 0}function u(e={}){const n=e.home??m();return s(n,".cachly","credentials.json")}function A(e,n={}){try{const r=u(n);p(y(r),{recursive:!0});const c=`${r}.${process.pid}-${Date.now()}.tmp`;a(c,JSON.stringify({apiKey:e},null,2),"utf8");try{f(c,384)}catch{}d(c,r)}catch{}}function h(e){try{const n=u(e);if(!o(n))return;const r=JSON.parse(i(n,"utf8"));return t(r.apiKey)}catch{return}}function l(e){try{const n=s(e.cwd??process.cwd(),".mcp.json");if(!o(n))return;const r=JSON.parse(i(n,"utf8"));return t(r.mcpServers?.cachly?.env?.CACHLY_JWT)}catch{return}}function C(e={}){const n=e.env??process.env;return t(n.CACHLY_JWT)??t(n.CACHLY_API_KEY)??h(e)??l(e)}export{u as credentialsPath,C as resolveApiKey,A as saveApiKey};