@cachly-dev/mcp-server 0.10.100 → 0.10.102

package/dist/src/index.js

@@ -706,6 +706,7 @@ import { handleRoadmapTool } from './handlers/roadmap.js';
 import { handleAdvancedTool } from './handlers/advanced.js';
 import { handleSyndicateTool } from './handlers/syndicate.js';
 import { handleFedbrainTool, _lastBrainFromGitCounts } from './handlers/fedbrain.js';
+import { installClsPostCommitHook, CLS_HOOK_VERSION } from './cls-hook.js';
 import { handleShareTool } from './handlers/share.js';
 import { handleVizTool } from './handlers/viz.js';
 // ── Tools (imported from tools.ts) ─────────────────────────────────────────
@@ -776,6 +777,67 @@ async function sendAnonymousTelemetry(toolName) {
     }
     catch { /* fire-and-forget, never block the user */ }
 }
+// ── Feature-Gate (premium tools) ────────────────────────────────────────────
+// Free tier delivers the magic moment: keyword + CKG recall, learn, sessions.
+// The deeper intelligence layers — causal root-cause tracing, predictive risk,
+// and the shared Team Brain — are Premium. Value through depth, not volume. A
+// free user who reaches for one of these gets the value pitched at the exact
+// moment of need, never a silent failure.
+const PREMIUM_TOOLS = new Set([
+    // Predictive + causal intelligence
+    'causal_trace', 'brain_predict', 'brain_plan', 'brain_predict_failures',
+    // Team Brain (shared, multi-author knowledge)
+    'team_learn', 'team_confirm', 'team_recall', 'team_synthesize', 'team_crystallize',
+    'global_learn', 'global_recall',
+]);
+const PREMIUM_PITCH = {
+    causal_trace: 'Causal root-cause tracing — follow the failure chain to the real cause, not just the symptom.',
+    brain_predict: 'Predictive risk — your Brain warns you what will break *before* you run it.',
+    brain_plan: 'Generative planning — turn a goal into an ordered, risk-aware plan from your own history.',
+    brain_predict_failures: 'Failure prediction — catch CI/build breakage before it happens.',
+    team_learn: 'Team Brain — one shared memory across your whole team.',
+    team_confirm: 'Team Brain — peer + senior review that raises lesson trust.',
+    team_recall: 'Team Brain — recall everything your teammates have already solved.',
+    team_synthesize: 'Team Brain — synthesize collective knowledge across authors.',
+    team_crystallize: "Team Brain — compress your team's wisdom into a shareable crystal.",
+    global_learn: "Team Brain — contribute to your organization's shared memory.",
+    global_recall: 'Team Brain — recall across your entire organization.',
+};
+const UPGRADE_URL_FG = 'https://cachly.dev/billing';
+const _tierCache = new Map();
+async function getTierInfo(instanceId) {
+    const cached = _tierCache.get(instanceId);
+    if (cached && cached.expiresAt > Date.now())
+        return cached.info;
+    try {
+        const inst = await apiFetch(`/api/v1/instances/${instanceId}`);
+        const tier = (inst?.tier ?? 'free').toLowerCase();
+        const info = { tier, isFree: tier === 'free' || tier === '' };
+        _tierCache.set(instanceId, { info, expiresAt: Date.now() + 60_000 });
+        return info;
+    }
+    catch {
+        // Tier unknown → fail open (never block on a stats hiccup).
+        return { tier: 'unknown', isFree: false };
+    }
+}
+/** Returns an upgrade teaser if a free-tier caller reached for a premium tool, else null. */
+async function featureGate(name, instanceId) {
+    if (!PREMIUM_TOOLS.has(name) || !instanceId)
+        return null;
+    const { isFree } = await getTierInfo(instanceId);
+    if (!isFree)
+        return null;
+    const pitch = PREMIUM_PITCH[name] ?? 'A Premium intelligence feature.';
+    return [
+        `🔒 **\`${name}\` is a Premium feature**`,
+        ``,
+        `${pitch}`,
+        ``,
+        `Your Free Brain keeps full keyword + causal-graph recall, learning, and sessions — forever.`,
+        `Unlock the deeper layer (causal tracing · predictive risk · Team Brain) → ${UPGRADE_URL_FG}`,
+    ].join('\n');
+}
 async function handleTool(name, args) {
     // Guard: if no JWT, return actionable onboarding message instead of HTTP 401
     if (!JWT) {
@@ -843,6 +905,13 @@ async function handleTool(name, args) {
         if (defaultId)
             args = { ...args, instance_id: defaultId };
     }
+    // Feature-Gate: free tier reaching for a Premium tool gets the upgrade pitch
+    // at the moment of need (the magic moment of basic recall stays untouched).
+    const gateMsg = await featureGate(name, args.instance_id);
+    if (gateMsg !== null) {
+        sendFunnelEvent('premium_gate_hit', { tool: name, instance_id: args.instance_id ?? '' });
+        return gateMsg;
+    }
     // Delegate brain tools (learn, recall, session, etc.)
     const brainResult = await handleBrainTool(name, args, getConnection, apiFetch);
     if (brainResult !== null) {
@@ -1880,6 +1949,11 @@ if (process.argv[2] === 'bench') {
         console.log('  \x1b[2m  npx @cachly-dev/mcp-server@latest bench my-incidents.json\x1b[0m');
         console.log('  \x1b[2m  npx @cachly-dev/mcp-server@latest bench --json   # machine-readable\x1b[0m');
         console.log('');
+        console.log('  \x1b[1m→ Give your AI this recall quality on your own work (free, 1–5 min):\x1b[0m');
+        console.log('  \x1b[32m$ npx @cachly-dev/mcp-server@latest autopilot\x1b[0m');
+        console.log('  \x1b[90m  Signs in, configures every editor, bootstraps from your git history.\x1b[0m');
+        console.log('  \x1b[90m  Or create your Brain at: \x1b[36mhttps://cachly.dev/setup-ai\x1b[0m');
+        console.log('');
     }
     catch (e) {
         console.error(`\n❌ bench failed: ${e.message}\n`);
@@ -2340,43 +2414,15 @@ if (process.argv[2] === 'init') {
     }
     // ── CLS Phase 4: Auto-install git post-commit hook ─────────────────────────
     try {
-        const { existsSync } = await import('node:fs');
-        const gitHookDir = resolve(projectDir, '.git', 'hooks');
-        const hookPath = resolve(gitHookDir, 'post-commit');
-        if (existsSync(resolve(projectDir, '.git'))) {
-            await mkdir(gitHookDir, { recursive: true });
-            const hookScript = [
-                `#!/bin/sh`,
-                `# cachly CLS — Continuous Learning Stream (installed by cachly init)`,
-                `# Runs silently on every commit to keep your brain up to date.`,
-                `CACHLY_INSTANCE="${instanceId}"`,
-                `SHA=$(git rev-parse HEAD 2>/dev/null || echo "")`,
-                `MSG=$(git log -1 --pretty=%B 2>/dev/null | head -1 | tr '"' "'" | cut -c1-200)`,
-                `FILES=$(git diff-tree --no-commit-id -r --name-only HEAD 2>/dev/null | tr '\\n' ',' | sed 's/,$//')`,
-                `node -e "try{require('child_process').execSync('npx @cachly-dev/mcp-server@latest cls-ingest \\''+ JSON.stringify({instance_id:'$CACHLY_INSTANCE',source:'git_commit',payload:{message:'$MSG',sha:'$SHA',files:'$FILES'.split(',').filter(Boolean)}})+'\\'' ,{stdio:'ignore',timeout:5000})}catch(e){}" 2>/dev/null &`,
-                `exit 0`,
-            ].join('\n');
-            let existing = '';
-            try {
-                const { readFile } = await import('node:fs/promises');
-                existing = await readFile(hookPath, 'utf-8');
-            }
-            catch { /* no existing hook */ }
-            if (existing && !existing.includes('cachly CLS')) {
-                // Append to existing hook
-                await writeFile(hookPath, existing.trimEnd() + '\n\n' + hookScript + '\n', 'utf-8');
-                console.log(`✅ Appended: .git/hooks/post-commit (CLS hook)`);
-            }
-            else if (!existing) {
-                await writeFile(hookPath, hookScript + '\n', 'utf-8');
-                const { chmod } = await import('node:fs/promises');
-                await chmod(hookPath, 0o755);
-                console.log(`✅ Written: .git/hooks/post-commit (CLS hook)`);
-            }
-            else {
-                console.log(`✓  CLS hook already present in .git/hooks/post-commit`);
-            }
-        }
+        const r = await installClsPostCommitHook(projectDir, instanceId, JWT || undefined);
+        if (r === 'written')
+            console.log(`✅ Written: .git/hooks/post-commit (CLS hook)`);
+        else if (r === 'upgraded')
+            console.log(`✅ Upgraded: .git/hooks/post-commit (CLS hook → ${CLS_HOOK_VERSION})`);
+        else if (r === 'appended')
+            console.log(`✅ Appended: .git/hooks/post-commit (CLS hook)`);
+        else if (r === 'unchanged')
+            console.log(`✓  CLS hook already current in .git/hooks/post-commit`);
     }
     catch { /* non-critical — git hook is a best-effort feature */ }
     const initSecs = ((Date.now() - initStart) / 1000).toFixed(1);
@@ -3229,39 +3275,13 @@ if (process.argv[2] === 'setup' || _isAutopilotCli) {
     }
     // ── CLS Phase 4: Auto-install git post-commit hook in setup flow ─────────
     try {
-        const { existsSync } = await import('node:fs');
-        const { writeFile: wf2, mkdir: mk2, chmod: ch2, readFile: rf2 } = await import('node:fs/promises');
-        const { resolve: res2 } = await import('node:path');
-        const setupProjectDir = process.cwd();
-        const gitHookDir2 = res2(setupProjectDir, '.git', 'hooks');
-        const hookPath2 = res2(gitHookDir2, 'post-commit');
-        if (existsSync(res2(setupProjectDir, '.git'))) {
-            await mk2(gitHookDir2, { recursive: true });
-            const hs2 = [
-                `#!/bin/sh`,
-                `# cachly CLS — Continuous Learning Stream (installed by cachly setup)`,
-                `CACHLY_INSTANCE="${instance.id}"`,
-                `SHA=$(git rev-parse HEAD 2>/dev/null || echo "")`,
-                `MSG=$(git log -1 --pretty=%B 2>/dev/null | head -1 | tr '"' "'" | cut -c1-200)`,
-                `FILES=$(git diff-tree --no-commit-id -r --name-only HEAD 2>/dev/null | tr '\\n' ',' | sed 's/,$//')`,
-                `node -e "try{require('child_process').execSync('npx @cachly-dev/mcp-server@latest cls-ingest \\''+ JSON.stringify({instance_id:'$CACHLY_INSTANCE',source:'git_commit',payload:{message:'$MSG',sha:'$SHA',files:'$FILES'.split(',').filter(Boolean)}})+'\\'' ,{stdio:'ignore',timeout:5000})}catch(e){}" 2>/dev/null &`,
-                `exit 0`,
-            ].join('\n');
-            let ex2 = '';
-            try {
-                ex2 = await rf2(hookPath2, 'utf-8');
-            }
-            catch { /* no existing */ }
-            if (!ex2) {
-                await wf2(hookPath2, hs2 + '\n', 'utf-8');
-                await ch2(hookPath2, 0o755);
-                console.log(`\n✅  CLS git hook installed — your brain will learn from every commit.`);
-            }
-            else if (!ex2.includes('cachly CLS')) {
-                await wf2(hookPath2, ex2.trimEnd() + '\n\n' + hs2 + '\n', 'utf-8');
-                console.log(`\n✅  CLS git hook appended to existing post-commit.`);
-            }
-        }
+        const r = await installClsPostCommitHook(process.cwd(), instance.id, token || undefined);
+        if (r === 'written')
+            console.log(`\n✅  CLS git hook installed — your brain will learn from every commit.`);
+        else if (r === 'upgraded')
+            console.log(`\n✅  CLS git hook upgraded to ${CLS_HOOK_VERSION}.`);
+        else if (r === 'appended')
+            console.log(`\n✅  CLS git hook appended to existing post-commit.`);
     }
     catch { /* non-critical */ }
     // Setup reached the end — close the funnel. Report config-write outcome so the
@@ -3389,6 +3409,37 @@ if (process.argv[2] === 'learn-git') {
     }
     process.exit(0);
 }
+// ── cls-ingest: CLI entrypoint for the git post-commit hook ───────────────────
+// Invoked as: cachly cls-ingest '<json>'  where json = { instance_id, source, payload }.
+// Auth comes from CACHLY_JWT (embedded in the generated hook). This is a silent,
+// best-effort sink: ANY problem (no JWT, bad JSON, network) exits 0 so a commit
+// is never blocked or noisy. Without this command the hook was a no-op.
+if (process.argv[2] === 'cls-ingest') {
+    try {
+        const raw = process.argv[3];
+        if (!raw || !JWT)
+            process.exit(0); // nothing to do / not authenticated → silent
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            process.exit(0); // malformed payload → never block the commit
+        }
+        const instanceId = parsed.instance_id ?? _defaultInstanceId;
+        if (!instanceId || !parsed.source)
+            process.exit(0);
+        await handleTool('cls_ingest', {
+            instance_id: instanceId,
+            source: parsed.source,
+            payload: parsed.payload ?? {},
+        });
+    }
+    catch {
+        // Swallow everything — a learning sink must never break `git commit`.
+    }
+    process.exit(0);
+}
 // ── Start ─────────────────────────────────────────────────────────────────────
 // M2M / headless auth: if no JWT but client credentials are present, run the
 // OAuth2 client_credentials grant before any credential-missing handling. This