hippo-memory 0.22.1 → 0.24.0

package/dist/cli.js

@@ -27,8 +27,8 @@
 import * as path from 'path';
 import * as fs from 'fs';
 import * as os from 'os';
-import { execSync } from 'child_process';
-import { installJsonHooks, uninstallJsonHooks, resolveJsonHookPaths, detectInstalledTools, defaultSleepLogPath, } from './hooks.js';
+import { execSync, spawn } from 'child_process';
+import { installJsonHooks, uninstallJsonHooks, resolveJsonHookPaths, detectInstalledTools, defaultSleepLogPath, ensureCodexWrapperInstalled, installCodexWrapper, uninstallCodexWrapper, resolveCodexSessionTranscript, resolveCodexWrapperPaths, } from './hooks.js';
 import { createMemory, calculateStrength, calculateRewardFactor, deriveHalfLife, resolveConfidence, applyOutcome, computeSchemaFit, Layer, DECISION_HALF_LIFE_DAYS, } from './memory.js';
 import { getHippoRoot, isInitialized, initStore, writeEntry, readEntry, deleteEntry, loadAllEntries, loadSearchEntries, loadIndex, saveIndex, loadStats, updateStats, saveActiveTaskSnapshot, loadActiveTaskSnapshot, clearActiveTaskSnapshot, appendSessionEvent, listSessionEvents, listMemoryConflicts, resolveConflict, saveSessionHandoff, loadLatestHandoff, loadHandoffById, } from './store.js';
 import { markRetrieved, estimateTokens, hybridSearch, physicsSearch, explainMatch, textOverlap } from './search.js';
@@ -67,6 +67,10 @@ function parseArgs(argv) {
     let i = 0;
     while (i < rest.length) {
         const part = rest[i];
+        if (part === '--') {
+            args.push(...rest.slice(i + 1));
+            break;
+        }
         if (part.startsWith('--')) {
             const key = part.slice(2);
             const next = rest[i + 1];
@@ -279,19 +283,19 @@ function autoInstallHooks(quiet) {
         if (hook === 'claude-code' || hook === 'opencode') {
             const result = installJsonHooks(hook);
             if (result.installedSessionEnd) {
-                console.log(`   Auto-installed hippo sleep SessionEnd hook in ${hook} settings`);
+                console.log(`   Auto-installed hippo session-end SessionEnd hook in ${hook} settings`);
             }
             if (result.installedSessionStart) {
                 console.log(`   Auto-installed hippo last-sleep SessionStart hook in ${hook} settings`);
             }
-            if (result.installedSessionCapture) {
-                console.log(`   Auto-installed hippo capture SessionEnd hook in ${hook} settings`);
-            }
             if (result.migratedFromStop) {
                 console.log(`   Migrated legacy Stop hook → SessionEnd (no longer runs every turn)`);
             }
-            if (result.migratedLegacySessionEnd) {
-                console.log(`   Migrated legacy SessionEnd entry to the new --log-file form`);
+            if (result.migratedSplitSessionEnd) {
+                console.log(`   Migrated split sleep+capture SessionEnd entries → single detached hippo session-end`);
+            }
+            else if (result.migratedLegacySessionEnd) {
+                console.log(`   Migrated legacy SessionEnd entry to the new detached form`);
             }
         }
     }
@@ -798,6 +802,229 @@ function cmdLastSleep(flags) {
         catch { /* non-fatal */ }
     }
 }
+/**
+ * SessionEnd entry point. Claude Code / OpenCode fire this on /exit while
+ * tearing down the TUI, which kills any child that is still running when
+ * the parent returns. Running sleep + capture synchronously here means both
+ * get SIGTERM'd mid-consolidation.
+ *
+ * So we do the minimum inline (read stdin for transcript_path), then spawn
+ * a fully detached Node child that runs sleep → capture and exit the parent
+ * immediately. The child writes to the log file and survives TUI teardown;
+ * the next SessionStart reads the log via `hippo last-sleep`.
+ */
+function cmdSessionEnd(hippoRoot, flags) {
+    const logFile = typeof flags['log-file'] === 'string' ? flags['log-file'] : null;
+    // Read stdin synchronously. The SessionEnd hook payload carries
+    // `transcript_path` as JSON; we extract it here and pass it to the worker
+    // via argv so the detached child doesn't need to inherit stdin.
+    let transcriptPath = null;
+    try {
+        const stdinText = fs.readFileSync(0, 'utf8');
+        if (stdinText && stdinText.trim().startsWith('{')) {
+            const payload = JSON.parse(stdinText);
+            if (typeof payload.transcript_path === 'string') {
+                transcriptPath = payload.transcript_path;
+            }
+        }
+    }
+    catch {
+        // No stdin, not JSON, or read failure — capture will fall back to
+        // transcript auto-discovery.
+    }
+    const workerArgs = [process.argv[1], '__session-end-worker'];
+    if (logFile)
+        workerArgs.push('--log-file', logFile);
+    if (transcriptPath)
+        workerArgs.push('--transcript', transcriptPath);
+    try {
+        const child = spawn(process.execPath, workerArgs, {
+            detached: true,
+            stdio: 'ignore',
+            windowsHide: true,
+        });
+        child.unref();
+    }
+    catch (err) {
+        // If spawn fails, run inline as a last resort — better late output than
+        // no consolidation at all.
+        cmdSessionEndWorker(hippoRoot, flags);
+        return;
+    }
+}
+/**
+ * Detached worker that runs sleep, then capture. Invoked via the internal
+ * `__session-end-worker` subcommand (not user-facing). Failures in one stage
+ * do not block the other.
+ */
+function cmdSessionEndWorker(hippoRoot, flags) {
+    try {
+        cmdSleep(hippoRoot, flags);
+    }
+    catch {
+        // sleep errors are already tee'd to the log file via cmdSleep's
+        // `[hippo] sleep failed: ...` line. Continue to capture regardless.
+    }
+    try {
+        const captureOpts = {
+            source: 'last-session',
+            transcriptPath: typeof flags['transcript'] === 'string'
+                ? flags['transcript']
+                : undefined,
+            logFile: typeof flags['log-file'] === 'string'
+                ? flags['log-file']
+                : undefined,
+            dryRun: false,
+            global: false,
+        };
+        cmdCapture(hippoRoot, captureOpts);
+    }
+    catch {
+        // Same treatment — the failure line is already in the log.
+    }
+}
+function loadCodexWrapperMetadata() {
+    const { metadataPath } = resolveCodexWrapperPaths();
+    if (!fs.existsSync(metadataPath)) {
+        throw new Error('Codex wrapper is not installed. Run `hippo hook install codex` first.');
+    }
+    return JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
+}
+function quoteCmdArg(arg) {
+    if (arg.length === 0)
+        return '""';
+    if (!/[ \t"&()^<>|]/.test(arg))
+        return arg;
+    return `"${arg.replace(/"/g, '""')}"`;
+}
+function spawnRealCodex(realCodexPath, forwardArgs, cwd) {
+    const ext = path.extname(realCodexPath).toLowerCase();
+    if (process.platform === 'win32' && ext === '.ps1') {
+        return spawn('powershell.exe', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', realCodexPath, ...forwardArgs], { cwd, stdio: 'inherit', windowsHide: false });
+    }
+    if (process.platform === 'win32' && (ext === '.cmd' || ext === '.bat')) {
+        const command = `"${realCodexPath}"${forwardArgs.length > 0 ? ` ${forwardArgs.map(quoteCmdArg).join(' ')}` : ''}`;
+        return spawn('cmd.exe', ['/d', '/s', '/c', command], { cwd, stdio: 'inherit', windowsHide: false });
+    }
+    return spawn(realCodexPath, forwardArgs, { cwd, stdio: 'inherit', windowsHide: false });
+}
+function cmdCodexRun(hippoRoot, args) {
+    const metadata = loadCodexWrapperMetadata();
+    const startedAtMs = Date.now();
+    const historyPath = metadata.historyPath;
+    const startOffsetBytes = fs.existsSync(historyPath) ? fs.statSync(historyPath).size : 0;
+    try {
+        cmdLastSleep({ path: metadata.logFile });
+    }
+    catch {
+        // best-effort only
+    }
+    const child = spawnRealCodex(metadata.realCodexPath, args, process.cwd());
+    child.on('error', (err) => {
+        console.error(`Failed to launch Codex: ${err.message}`);
+        process.exit(1);
+    });
+    child.on('exit', (code, signal) => {
+        const workerArgs = [
+            process.argv[1],
+            '__codex-session-end-worker',
+            '--codex-home',
+            path.dirname(historyPath),
+            '--history-path',
+            historyPath,
+            '--start-offset',
+            String(startOffsetBytes),
+            '--started-at',
+            String(startedAtMs),
+            '--log-file',
+            metadata.logFile,
+        ];
+        try {
+            const worker = spawn(process.execPath, workerArgs, {
+                detached: true,
+                stdio: 'ignore',
+                windowsHide: true,
+            });
+            worker.unref();
+        }
+        catch {
+            // Fall back to the inline path if the detached worker cannot be created.
+            cmdCodexSessionEndWorker(hippoRoot, {
+                'codex-home': path.dirname(historyPath),
+                'history-path': historyPath,
+                'start-offset': String(startOffsetBytes),
+                'started-at': String(startedAtMs),
+                'log-file': metadata.logFile,
+            });
+        }
+        if (signal) {
+            try {
+                process.kill(process.pid, signal);
+            }
+            catch {
+                process.exit(1);
+            }
+            return;
+        }
+        process.exit(code ?? 0);
+    });
+}
+function cmdCodexSessionEndWorker(hippoRoot, flags) {
+    const logFile = typeof flags['log-file'] === 'string' ? flags['log-file'] : undefined;
+    try {
+        cmdSleep(hippoRoot, logFile ? { 'log-file': logFile } : {});
+    }
+    catch {
+        // sleep errors are already written via cmdSleep
+    }
+    try {
+        const codexHome = typeof flags['codex-home'] === 'string'
+            ? flags['codex-home']
+            : path.join(os.homedir(), '.codex');
+        const historyPath = typeof flags['history-path'] === 'string'
+            ? flags['history-path']
+            : path.join(codexHome, 'history.jsonl');
+        const startOffsetBytes = parseInt(String(flags['start-offset'] ?? '0'), 10) || 0;
+        const startedAtMs = parseInt(String(flags['started-at'] ?? Date.now()), 10) || Date.now();
+        const transcriptPath = resolveCodexSessionTranscript({
+            codexHome,
+            historyPath,
+            startOffsetBytes,
+            startedAtMs,
+        }) ?? undefined;
+        const captureOpts = {
+            source: 'last-session',
+            transcriptPath,
+            logFile,
+            dryRun: false,
+            global: false,
+        };
+        cmdCapture(hippoRoot, captureOpts);
+    }
+    catch {
+        // capture path logs its own failures
+    }
+}
+function shouldAutoInstallCodexWrapper(currentCommand, currentArgs) {
+    if (process.env.HIPPO_SKIP_AUTO_INTEGRATIONS === '1')
+        return false;
+    if (!['context', 'remember', 'recall', 'sleep', 'capture', 'outcome', 'status', 'init'].includes(currentCommand)) {
+        return false;
+    }
+    if (currentCommand === 'init' && currentArgs.includes('--no-hooks'))
+        return false;
+    return true;
+}
+function maybeAutoInstallCodexWrapper(currentCommand, currentArgs) {
+    if (!shouldAutoInstallCodexWrapper(currentCommand, currentArgs))
+        return;
+    try {
+        ensureCodexWrapperInstalled();
+    }
+    catch {
+        // best-effort only
+    }
+}
 function cmdStatus(hippoRoot) {
     requireInit(hippoRoot);
     const entries = loadAllEntries(hippoRoot);
@@ -1914,7 +2141,7 @@ hippo capture --stdin <<< '<decisions, errors, lessons — 2-5 bullets>'
     'codex': {
         file: 'AGENTS.md',
         description: 'OpenAI Codex',
-        content: `
+        content: `
 ## Project Memory (Hippo)
 
 At the start of every task, run:
@@ -1933,7 +2160,8 @@ On task completion:
 hippo outcome --good
 \`\`\`
 
-When ending a session, capture a brief summary:
+When Hippo's Codex wrapper is installed, session-end capture runs automatically.
+If the wrapper is not installed, capture a brief summary manually:
 \`\`\`bash
 hippo capture --stdin <<< '<decisions, errors, lessons — 2-5 bullets>'
 \`\`\`
@@ -2094,21 +2322,26 @@ function cmdHook(args, flags) {
         if (target === 'claude-code' || target === 'opencode') {
             const result = installJsonHooks(target);
             if (result.installedSessionEnd) {
-                console.log(`Installed hippo sleep SessionEnd hook in ${result.target} settings`);
+                console.log(`Installed hippo session-end SessionEnd hook in ${result.target} settings`);
             }
             if (result.installedSessionStart) {
                 console.log(`Installed hippo last-sleep SessionStart hook in ${result.target} settings`);
             }
-            if (result.installedSessionCapture) {
-                console.log(`Installed hippo capture SessionEnd hook in ${result.target} settings`);
-            }
             if (result.migratedFromStop) {
                 console.log(`Migrated legacy Stop hook → SessionEnd (was running every turn; now fires once on session exit)`);
             }
-            if (result.migratedLegacySessionEnd) {
-                console.log(`Migrated legacy SessionEnd entry to the new --log-file form`);
+            if (result.migratedSplitSessionEnd) {
+                console.log(`Migrated split sleep+capture SessionEnd entries → single detached hippo session-end`);
+            }
+            else if (result.migratedLegacySessionEnd) {
+                console.log(`Migrated legacy SessionEnd entry to the new detached form`);
             }
         }
+        else if (target === 'codex') {
+            const result = installCodexWrapper();
+            console.log(`Installed Codex session-end integration -> ${result.metadataPath}`);
+            console.log(`   Wrapped detected Codex launcher at ${result.commandPath}`);
+        }
         return;
     }
     if (subcommand === 'uninstall') {
@@ -2118,25 +2351,32 @@ function cmdHook(args, flags) {
         }
         const hook = HOOKS[target];
         const filepath = path.resolve(process.cwd(), hook.file);
-        if (!fs.existsSync(filepath)) {
-            console.log(`${hook.file} not found, nothing to uninstall.`);
-            return;
+        if (fs.existsSync(filepath)) {
+            const existing = fs.readFileSync(filepath, 'utf8');
+            if (existing.includes(HOOK_MARKERS.start)) {
+                const re = new RegExp(`\\n?${escapeRegex(HOOK_MARKERS.start)}[\\s\\S]*?${escapeRegex(HOOK_MARKERS.end)}\\n?`, 'g');
+                const cleaned = existing.replace(re, '\n').replace(/\n{3,}/g, '\n\n').trim();
+                fs.writeFileSync(filepath, cleaned + '\n', 'utf8');
+                console.log(`Removed Hippo hook from ${hook.file}`);
+            }
+            else {
+                console.log(`No Hippo hook found in ${hook.file}.`);
+            }
         }
-        const existing = fs.readFileSync(filepath, 'utf8');
-        if (!existing.includes(HOOK_MARKERS.start)) {
-            console.log(`No Hippo hook found in ${hook.file}.`);
-            return;
+        else {
+            console.log(`${hook.file} not found, skipping agent-instructions uninstall.`);
         }
-        const re = new RegExp(`\\n?${escapeRegex(HOOK_MARKERS.start)}[\\s\\S]*?${escapeRegex(HOOK_MARKERS.end)}\\n?`, 'g');
-        const cleaned = existing.replace(re, '\n').replace(/\n{3,}/g, '\n\n').trim();
-        fs.writeFileSync(filepath, cleaned + '\n', 'utf8');
-        console.log(`Removed Hippo hook from ${hook.file}`);
         // For JSON-hook tools, also strip their SessionEnd/SessionStart entries.
         if (target === 'claude-code' || target === 'opencode') {
             if (uninstallJsonHooks(target)) {
                 console.log(`Removed hippo hooks from ${target} settings`);
             }
         }
+        else if (target === 'codex') {
+            if (uninstallCodexWrapper()) {
+                console.log('Removed Codex wrapper integration');
+            }
+        }
         return;
     }
     console.error('Usage: hippo hook <install|uninstall|list> [target]');
@@ -2154,6 +2394,7 @@ function cmdSetup(flags) {
     console.log('Hippo setup -- configuring SessionEnd + SessionStart hooks');
     console.log('');
     const jsonTools = tools.filter((t) => t.kind === 'json-hook' && (t.detected || forceAll));
+    const wrapperTools = tools.filter((t) => t.kind === 'wrapper' && (t.detected || forceAll));
     const skipped = tools.filter((t) => t.kind === 'json-hook' && !t.detected && !forceAll);
     const markdownTools = tools.filter((t) => t.kind === 'markdown-instruction' && t.detected);
     const pluginTools = tools.filter((t) => t.kind === 'plugin' && t.detected);
@@ -2172,14 +2413,14 @@ function cmdSetup(flags) {
         const result = installJsonHooks(tool.name);
         const bits = [];
         if (result.installedSessionEnd)
-            bits.push('SessionEnd (sleep)');
-        if (result.installedSessionCapture)
-            bits.push('SessionEnd (capture)');
+            bits.push('SessionEnd (session-end)');
         if (result.installedSessionStart)
             bits.push('SessionStart');
         if (result.migratedFromStop)
             bits.push('migrated legacy Stop');
-        if (result.migratedLegacySessionEnd)
+        if (result.migratedSplitSessionEnd)
+            bits.push('migrated split SessionEnd → session-end');
+        else if (result.migratedLegacySessionEnd)
             bits.push('migrated legacy SessionEnd');
         if (bits.length === 0) {
             console.log(`  ${tool.name.padEnd(14)} already configured (${result.settingsPath})`);
@@ -2191,6 +2432,24 @@ function cmdSetup(flags) {
     for (const tool of skipped) {
         console.log(`  ${tool.name.padEnd(14)} not detected at ${tool.configDir} -- skipping`);
     }
+    for (const tool of wrapperTools) {
+        if (dryRun) {
+            console.log(`[dry-run] would wrap the detected ${tool.name} launcher in place`);
+            continue;
+        }
+        if (tool.name === 'codex') {
+            const result = ensureCodexWrapperInstalled();
+            if (result.status === 'installed') {
+                console.log(`  ${tool.name.padEnd(14)} wrapped launcher -> ${result.commandPath}`);
+            }
+            else if (result.status === 'already-installed') {
+                console.log(`  ${tool.name.padEnd(14)} already wrapped -> ${result.commandPath}`);
+            }
+            else {
+                console.log(`  ${tool.name.padEnd(14)} not found on PATH -- skipping`);
+            }
+        }
+    }
     if (pluginTools.length > 0) {
         console.log('');
         console.log('Plugin-based tools (hook API via plugin, not JSON):');
@@ -2215,8 +2474,7 @@ function installClaudeCodeSessionEndHook() {
     const result = installJsonHooks('claude-code');
     return {
         installed: result.installedSessionEnd ||
-            result.installedSessionStart ||
-            result.installedSessionCapture,
+            result.installedSessionStart,
         migratedFromStop: result.migratedFromStop,
     };
 }
@@ -2421,13 +2679,15 @@ Commands:
                            available SessionEnd+SessionStart hooks
     --all                  Install for every JSON-hook tool, even if not detected
     --dry-run              Show what would be installed without writing
-  last-sleep               Print the last 'hippo sleep --log-file' output and clear it
-    --path <p>             Log path (default: ~/.hippo/logs/last-sleep.log)
-    --keep                 Print without clearing
-  hook <sub> [target]      Manage framework integrations
-    hook list              Show available hooks
-    hook install <target>  Install hook (claude-code|codex|cursor|openclaw|opencode|pi)
-                           claude-code also installs SessionEnd+SessionStart in settings.json
+  last-sleep               Print the last 'hippo sleep --log-file' output and clear it
+    --path <p>             Log path (default: ~/.hippo/logs/last-sleep.log)
+    --keep                 Print without clearing
+  codex-run [-- ...args]   Launch real Codex behind Hippo's session-end wrapper
+  hook <sub> [target]      Manage framework integrations
+    hook list              Show available hooks
+    hook install <target>  Install hook (claude-code|codex|cursor|openclaw|opencode|pi)
+                           claude-code/opencode install SessionEnd+SessionStart;
+                           codex wraps the detected launcher in place
     hook uninstall <target> Remove hook
   decide "<decision>"      Record an architectural decision (90-day half-life)
     --context "<why>"      Why this decision was made
@@ -2489,6 +2749,7 @@ Examples:
 const { command, args, flags } = parseArgs(process.argv);
 const hippoRoot = getHippoRoot(process.cwd());
 async function main() {
+    maybeAutoInstallCodexWrapper(command, args);
     switch (command) {
         case 'init':
             cmdInit(hippoRoot, flags);
@@ -2517,6 +2778,18 @@ async function main() {
         case 'last-sleep':
             cmdLastSleep(flags);
             break;
+        case 'session-end':
+            cmdSessionEnd(hippoRoot, flags);
+            break;
+        case '__session-end-worker':
+            cmdSessionEndWorker(hippoRoot, flags);
+            break;
+        case 'codex-run':
+            cmdCodexRun(hippoRoot, args);
+            break;
+        case '__codex-session-end-worker':
+            cmdCodexSessionEndWorker(hippoRoot, flags);
+            break;
         case 'dedup':
             cmdDedup(hippoRoot, flags);
             break;