fluffy-context 0.3.0 → 0.5.0

package/dist/src/integrations/claude-code.js

@@ -1,14 +1,22 @@
 import { access } from 'node:fs/promises';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { resolveProjectRoot } from '../project/project-resolver.js';
 import { atomicWriteJson } from '../storage/atomic-write.js';
 import { isRecord, readJson } from '../storage/json-store.js';
 import { manifestPath } from '../storage/layout.js';
+const cliPath = fileURLToPath(new URL('../cli/main.js', import.meta.url));
+const cliCommand = `"${process.execPath}" "${cliPath}"`;
 const HOOK_COMMANDS = {
+    sessionStart: `${cliCommand} hook claude-code session-start`,
+    userPrompt: `${cliCommand} hook claude-code user-prompt`,
+};
+const LEGACY_HOOK_COMMANDS = {
     sessionStart: 'ctx hook claude-code session-start',
     userPrompt: 'ctx hook claude-code user-prompt',
 };
-const MCP_SERVER = { command: 'ctx', args: ['agent', 'serve'] };
+const MCP_SERVER = { command: process.execPath, args: [cliPath, 'agent', 'serve'] };
+const LEGACY_MCP_SERVER = { command: 'ctx', args: ['agent', 'serve'] };
 function object(value) {
     return isRecord(value) ? { ...value } : {};
 }
@@ -19,11 +27,23 @@ function hookInstalled(value, command) {
         && Array.isArray(group.hooks)
         && group.hooks.some((hook) => isRecord(hook) && hook.type === 'command' && hook.command === command));
 }
-function addHook(value, command) {
+function addHook(value, command, legacyCommand) {
     const groups = Array.isArray(value) ? value.filter(isRecord).map((group) => ({ ...group })) : [];
     if (hookInstalled(groups, command))
         return groups;
-    return [...groups, { hooks: [{ type: 'command', command }] }];
+    let replaced = false;
+    const updated = groups.map((group) => ({
+        ...group,
+        hooks: Array.isArray(group.hooks)
+            ? group.hooks.map((hook) => {
+                if (!isRecord(hook) || hook.type !== 'command' || hook.command !== legacyCommand)
+                    return hook;
+                replaced = true;
+                return { ...hook, command };
+            })
+            : group.hooks,
+    }));
+    return replaced ? updated : [...updated, { hooks: [{ type: 'command', command }] }];
 }
 async function exists(filePath) {
     try {
@@ -50,18 +70,21 @@ function validateConfig(settings, mcp) {
     if (mcp.mcpServers !== undefined && !isRecord(mcp.mcpServers))
         throw new Error('Claude Code MCP servers must be an object');
 }
+function mcpInstalled(value, server = MCP_SERVER) {
+    return isRecord(value)
+        && value.command === server.command
+        && Array.isArray(value.args)
+        && value.args.length === server.args.length
+        && value.args.every((item, index) => item === server.args[index]);
+}
 function status(projectRoot, settingsPath, mcpPath, settings, mcp, settingsExists, mcpExists, initialized) {
     const hooks = object(settings.hooks);
     const sessionStartInstalled = hookInstalled(hooks.SessionStart, HOOK_COMMANDS.sessionStart);
     const userPromptInstalled = hookInstalled(hooks.UserPromptSubmit, HOOK_COMMANDS.userPrompt);
     const mcpServers = object(mcp.mcpServers);
     const configuredMcp = mcpServers['fluffy-context'];
-    const mcpInstalled = isRecord(configuredMcp)
-        && configuredMcp.command === MCP_SERVER.command
-        && Array.isArray(configuredMcp.args)
-        && configuredMcp.args.length === MCP_SERVER.args.length
-        && configuredMcp.args.every((value, index) => value === MCP_SERVER.args[index]);
-    const mcpConflict = configuredMcp !== undefined && !mcpInstalled;
+    const installed = mcpInstalled(configuredMcp);
+    const mcpConflict = configuredMcp !== undefined && !installed && !mcpInstalled(configuredMcp, LEGACY_MCP_SERVER);
     return {
         projectRoot,
         initialized,
@@ -71,9 +94,9 @@ function status(projectRoot, settingsPath, mcpPath, settings, mcp, settingsExist
         mcpExists,
         sessionStartInstalled,
         userPromptInstalled,
-        mcpInstalled,
+        mcpInstalled: installed,
         mcpConflict,
-        installationNeeded: !sessionStartInstalled || !userPromptInstalled || !mcpInstalled,
+        installationNeeded: !sessionStartInstalled || !userPromptInstalled || !installed,
     };
 }
 async function inspect(projectRoot) {
@@ -105,8 +128,8 @@ export async function installClaudeIntegration(startPath, apply) {
         ...inspected.settings,
         hooks: {
             ...settingsHooks,
-            SessionStart: addHook(settingsHooks.SessionStart, HOOK_COMMANDS.sessionStart),
-            UserPromptSubmit: addHook(settingsHooks.UserPromptSubmit, HOOK_COMMANDS.userPrompt),
+            SessionStart: addHook(settingsHooks.SessionStart, HOOK_COMMANDS.sessionStart, LEGACY_HOOK_COMMANDS.sessionStart),
+            UserPromptSubmit: addHook(settingsHooks.UserPromptSubmit, HOOK_COMMANDS.userPrompt, LEGACY_HOOK_COMMANDS.userPrompt),
         },
     };
     const mcpServers = object(inspected.mcp.mcpServers);

package/dist/src/runtime/diagnostics.js

@@ -4,6 +4,7 @@ import { readJson } from '../storage/json-store.js';
 import { contextRoot, contextMetadataPath, contextsRoot, indexPath, manifestPath, notesPath, snapshotPath } from '../storage/layout.js';
 import { rebuildIndex, rebuildSnapshot } from './runtime.js';
 import { isValidNote } from './notes.js';
+import { migrationReadiness } from '../cognition/readiness.js';
 import { filterPaths } from '../capture/context-filter.js';
 export async function status(startPath) {
     const projectRoot = await resolveProjectRoot(startPath);
@@ -95,5 +96,10 @@ export async function doctor(startPath) {
         if (rebuiltIds.size !== storedIds.size || [...rebuiltIds].some((id) => !storedIds.has(id)))
             throw new Error('index rebuild mismatch');
     });
+    await check('v2 migration readiness', async () => {
+        const readiness = await migrationReadiness(projectRoot);
+        if (!readiness.eligible)
+            throw new Error(readiness.issues.join('; '));
+    });
     return { healthy, projectRoot, checks };
 }

package/dist/src/runtime/knowledge.js

@@ -5,6 +5,7 @@ import { isRecord, readJson } from '../storage/json-store.js';
 import { withLock } from '../storage/lock.js';
 import { contextMetadataPath, deadendsPath, knowledgePath, locksDirectory, snapshotPath } from '../storage/layout.js';
 import { rebuildSnapshot } from './runtime.js';
+import { mirrorDeadend, mirrorKnowledge } from '../cognition/v1-bridge.js';
 function id(prefix) {
     return `${prefix}-${Date.now().toString(36)}-${crypto.randomBytes(4).toString('hex')}`;
 }
@@ -119,6 +120,7 @@ export async function learnKnowledge(startPath, statement, scopeOrInput = 'proje
             updatedAt: now,
         };
         await atomicWriteJson(knowledgePath(projectRoot), { schemaVersion: 1, items: [...file.items, item] });
+        await mirrorKnowledge(projectRoot, item);
         return item;
     });
 }
@@ -210,6 +212,7 @@ export async function verifyKnowledge(startPath, knowledgeId) {
         item.confidence = Math.max(item.confidence, 0.8);
         item.updatedAt = new Date().toISOString();
         await atomicWriteJson(knowledgePath(projectRoot), file);
+        await mirrorKnowledge(projectRoot, item);
         return item;
     });
 }
@@ -233,6 +236,7 @@ export async function recordDeadend(startPath, attempt, reason, scopeOrInput = '
             updatedAt: now,
         };
         await atomicWriteJson(deadendsPath(projectRoot), { schemaVersion: 1, items: [...file.items, item] });
+        await mirrorDeadend(projectRoot, item);
         return item;
     });
 }
@@ -294,6 +298,7 @@ export async function verifyDeadend(startPath, deadendId) {
         item.status = 'verified';
         item.updatedAt = new Date().toISOString();
         await atomicWriteJson(deadendsPath(projectRoot), file);
+        await mirrorDeadend(projectRoot, item);
         return item;
     });
 }

package/dist/src/runtime/notes.js

@@ -6,6 +6,7 @@ import { atomicWriteJson } from '../storage/atomic-write.js';
 import { isRecord, readJson } from '../storage/json-store.js';
 import { contextMetadataPath, contextsRoot, locksDirectory, notesPath, snapshotPath, snapshotsDirectory } from '../storage/layout.js';
 import { withLock } from '../storage/lock.js';
+import { mirrorNote } from '../cognition/v1-bridge.js';
 function id() {
     return `note-${Date.now().toString(36)}-${crypto.randomBytes(4).toString('hex')}`;
 }
@@ -78,6 +79,7 @@ export async function addNote(startPath, message, input = {}) {
             updatedAt: now,
         };
         await atomicWriteJson(notesPath(projectRoot), { schemaVersion: 1, items: [...file.items, note] });
+        await mirrorNote(projectRoot, note);
         return note;
     });
 }
@@ -163,8 +165,13 @@ export async function absorbNotes(startPath, contextId, snapshotId) {
             absorbed += 1;
             return { ...note, absorbedBySnapshotId: snapshotId, updatedAt: new Date().toISOString() };
         });
-        if (absorbed > 0)
+        if (absorbed > 0) {
             await atomicWriteJson(notesPath(projectRoot), { schemaVersion: 1, items });
+            for (const note of items) {
+                if (note.contextId === contextId && note.absorbedBySnapshotId === snapshotId)
+                    await mirrorNote(projectRoot, note, true);
+            }
+        }
         return absorbed;
     });
 }

package/dist/src/runtime/runtime.d.ts

@@ -8,4 +8,5 @@ export declare function checkpoint(startPath: string | undefined, input: Checkpo
 export interface ResumeOptions {
     touchLastUsedAt?: boolean;
 }
+export declare function resumeSnapshot(startPath: string | undefined, contextId: string, snapshotId: string, maxChars?: number): Promise<ResumeResult>;
 export declare function resume(startPath?: string, contextId?: string, maxChars?: number, options?: ResumeOptions): Promise<ResumeResult>;

package/dist/src/runtime/runtime.js

@@ -9,6 +9,7 @@ import { contextDirectory, contextMetadataPath, contextsRoot, indexPath, locksDi
 import { loadManifest } from './init.js';
 import { filterPaths } from '../capture/context-filter.js';
 import { absorbNotes } from './notes.js';
+import { mirrorCheckpoint } from '../cognition/v1-bridge.js';
 const emptyContext = () => ({
     progressSummary: '',
     lastError: null,
@@ -307,9 +308,36 @@ export async function checkpoint(startPath, input, options = {}) {
         });
         if (input.absorbNotes)
             await absorbNotes(projectRoot, contextId, snapshotId);
+        await mirrorCheckpoint(projectRoot, updatedContext, snapshot);
         return { status: 'saved', context: updatedContext, snapshot };
     });
 }
+export async function resumeSnapshot(startPath, contextId, snapshotId, maxChars = 4000) {
+    const projectRoot = await resolveProjectRoot(startPath);
+    await loadManifest(projectRoot);
+    const [git, context, snapshot] = await Promise.all([
+        readGitState(projectRoot),
+        loadContext(projectRoot, contextId),
+        loadSnapshot(projectRoot, contextId, snapshotId),
+    ]);
+    const details = await rebuildSnapshot(projectRoot, contextId, snapshotId);
+    const budget = { remaining: Math.max(0, maxChars) };
+    return {
+        context,
+        snapshot,
+        details,
+        resumeSummary: {
+            progressSummary: limited(details.progressSummary, budget.remaining),
+            lastError: details.lastError === null ? null : limited(details.lastError, budget.remaining),
+            completed: limitedList(details.completed, budget),
+            pendingTasks: limitedList(details.pendingTasks, budget),
+            decisions: limitedList(details.decisions, budget),
+            risks: limitedList(details.risks, budget),
+            relatedFiles: limitedList(details.relatedFiles, budget),
+            branchOrCommitDrift: context.branch !== git.branch || context.commit !== git.commit,
+        },
+    };
+}
 export async function resume(startPath, contextId, maxChars = 4000, options = {}) {
     const projectRoot = await resolveProjectRoot(startPath);
     await loadManifest(projectRoot);

package/dist/src/storage/layout.d.ts

@@ -11,3 +11,21 @@ export declare function locksDirectory(projectRoot: string): string;
 export declare function knowledgePath(projectRoot: string): string;
 export declare function deadendsPath(projectRoot: string): string;
 export declare function notesPath(projectRoot: string): string;
+export declare function cognitionRoot(projectRoot: string): string;
+export declare function cognitionManifestPath(projectRoot: string): string;
+export declare function cognitionPolicyPath(projectRoot: string): string;
+export declare function cognitionJournalDirectory(projectRoot: string): string;
+export declare function cognitionProjectionsDirectory(projectRoot: string): string;
+export declare function cognitionProjectionCursorPath(projectRoot: string): string;
+export declare function cognitionBranchesDirectory(projectRoot: string): string;
+export declare function cognitionContextsProjectionPath(projectRoot: string): string;
+export declare function cognitionKnowledgeProjectionPath(projectRoot: string): string;
+export declare function cognitionDeadendsProjectionPath(projectRoot: string): string;
+export declare function cognitionNotesProjectionPath(projectRoot: string): string;
+export declare function cognitionMigrationsDirectory(projectRoot: string): string;
+export declare function cognitionV1ImportPath(projectRoot: string): string;
+export declare function cognitionRuntimeDirectory(projectRoot: string): string;
+export declare function cognitionRuntimeLeasePath(projectRoot: string): string;
+export declare function cognitionRuntimeSecretPath(projectRoot: string): string;
+export declare function cognitionV1SyncPath(projectRoot: string): string;
+export declare function cognitionQuarantineDirectory(projectRoot: string): string;

package/dist/src/storage/layout.js

@@ -38,3 +38,57 @@ export function deadendsPath(projectRoot) {
 export function notesPath(projectRoot) {
     return path.join(contextRoot(projectRoot), 'notes.json');
 }
+export function cognitionRoot(projectRoot) {
+    return path.join(contextRoot(projectRoot), 'v2');
+}
+export function cognitionManifestPath(projectRoot) {
+    return path.join(cognitionRoot(projectRoot), 'manifest.json');
+}
+export function cognitionPolicyPath(projectRoot) {
+    return path.join(cognitionRoot(projectRoot), 'policy.json');
+}
+export function cognitionJournalDirectory(projectRoot) {
+    return path.join(cognitionRoot(projectRoot), 'journal');
+}
+export function cognitionProjectionsDirectory(projectRoot) {
+    return path.join(cognitionRoot(projectRoot), 'projections');
+}
+export function cognitionProjectionCursorPath(projectRoot) {
+    return path.join(cognitionProjectionsDirectory(projectRoot), 'cursor.json');
+}
+export function cognitionBranchesDirectory(projectRoot) {
+    return path.join(cognitionProjectionsDirectory(projectRoot), 'branches');
+}
+export function cognitionContextsProjectionPath(projectRoot) {
+    return path.join(cognitionProjectionsDirectory(projectRoot), 'contexts.json');
+}
+export function cognitionKnowledgeProjectionPath(projectRoot) {
+    return path.join(cognitionProjectionsDirectory(projectRoot), 'knowledge.json');
+}
+export function cognitionDeadendsProjectionPath(projectRoot) {
+    return path.join(cognitionProjectionsDirectory(projectRoot), 'deadends.json');
+}
+export function cognitionNotesProjectionPath(projectRoot) {
+    return path.join(cognitionProjectionsDirectory(projectRoot), 'notes.json');
+}
+export function cognitionMigrationsDirectory(projectRoot) {
+    return path.join(cognitionRoot(projectRoot), 'migrations');
+}
+export function cognitionV1ImportPath(projectRoot) {
+    return path.join(cognitionMigrationsDirectory(projectRoot), 'v1-import.json');
+}
+export function cognitionRuntimeDirectory(projectRoot) {
+    return path.join(cognitionRoot(projectRoot), 'runtime');
+}
+export function cognitionRuntimeLeasePath(projectRoot) {
+    return path.join(cognitionRuntimeDirectory(projectRoot), 'lease.json');
+}
+export function cognitionRuntimeSecretPath(projectRoot) {
+    return path.join(cognitionRuntimeDirectory(projectRoot), 'secret');
+}
+export function cognitionV1SyncPath(projectRoot) {
+    return path.join(cognitionRuntimeDirectory(projectRoot), 'v1-sync.json');
+}
+export function cognitionQuarantineDirectory(projectRoot) {
+    return path.join(cognitionRoot(projectRoot), 'quarantine');
+}

package/dist/src/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.3.0";
+export declare const VERSION = "0.5.0";

package/dist/src/version.js

@@ -1 +1 @@
-export const VERSION = '0.3.0';
+export const VERSION = '0.5.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fluffy-context",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Local context management CLI and MCP tools for AI coding agents",
   "license": "MIT",
   "author": "FluffyChi-Xing",