hippo-memory 1.69.0 → 1.70.0

package/dist/cli/setup.js

@@ -9,15 +9,19 @@ import { installOpencodePlugin, uninstallOpencodePlugin, resolveOpencodePluginPa
 import { COPILOT_CLI_MCP, VSCODE_MCP, copilotMcpSnippet, copilotPaths, installCopilot, isCopilotCliPresent, isMcpFailure, uninstallCopilot, } from '../hooks/copilot.js';
 import { isInitialized } from '../store/open.js';
 import { currentMachine, importUserMemories } from '../agent-memories/sync.js';
-import { getGlobalRoot } from '../shared.js';
-import { listRegisteredWorkspaces, runDailyMaintenance } from '../scheduler.js';
-import { replayCompactionsAt } from '../compaction-record.js';
-import { log } from '../log.js';
+import { getGlobalRoot } from '../sharing/shared.js';
+import { listRegisteredWorkspaces, runDailyMaintenance } from './scheduler.js';
+import { replayCompactionsAt } from '../capture/compaction-record.js';
+import { errorMessage, log } from '../util/log.js';
+import { envDailyStepTimeoutMs } from '../util/env.js';
+import { writeFileAtomic } from '../util/atomic-write.js';
 import { printError } from './output.js';
-import { printAgentImport, installCodexMemoryHooks, setupDailySchedule, warnClaudeSettingsUnusable } from './shared.js';
+import { boolFlag } from './flag-values.js';
+import { printAgentImport } from './print.js';
+import { installCodexMemoryHooks, setupDailySchedule, warnClaudeSettingsUnusable } from './install-steps.js';
 import { repairQualityOnceAt } from './quality-repair-once.js';
-import { HOOK_MARKERS, HOOKS, hippoBlock, withoutHookBlock } from './hook-blocks.js';
-import { escapeRegex } from '../escape.js';
+import { HOOK_MARKERS, HOOKS, hippoBlock, withoutHookBlock } from '../hooks/hook-blocks.js';
+import { escapeRegex } from '../util/escape.js';
 // ---------------------------------------------------------------------------
 // Hook install/uninstall
 // ---------------------------------------------------------------------------
@@ -89,12 +93,12 @@ function patchAgentFile(hook, target) {
         else if (existing.includes(HOOK_MARKERS.start)) {
             const re = new RegExp(`${escapeRegex(HOOK_MARKERS.start)}[\\s\\S]*?${escapeRegex(HOOK_MARKERS.end)}`, 'g');
             const updated = existing.replace(re, block);
-            fs.writeFileSync(filepath, updated, 'utf8');
+            writeFileAtomic(filepath, updated);
             console.log(`Updated Hippo hook in ${hook.file}`);
         }
         else {
             const sep = existing.endsWith('\n') ? '\n' : '\n\n';
-            fs.writeFileSync(filepath, existing + sep + block + '\n', 'utf8');
+            writeFileAtomic(filepath, existing + sep + block + '\n');
             console.log(`Installed Hippo hook in ${hook.file} (appended)`);
         }
     }
@@ -295,7 +299,7 @@ function unpatchAgentFile(hook, target) {
         console.log(`Left the hippo block in ${hook.file}: ${whose}. Delete it by hand if no agent needs it.`);
     }
     else if (existing.includes(HOOK_MARKERS.start)) {
-        fs.writeFileSync(filepath, withoutHookBlock(existing) + '\n', 'utf8');
+        writeFileAtomic(filepath, withoutHookBlock(existing) + '\n');
         console.log(`Removed Hippo hook from ${hook.file}`);
     }
     else {
@@ -309,21 +313,13 @@ function removeLegacyCursorRules() {
     if (old.includes(HOOK_MARKERS.start)) {
         const left = withoutHookBlock(old);
         if (left)
-            fs.writeFileSync(legacy, left + '\n', 'utf8');
+            writeFileAtomic(legacy, left + '\n');
         else
             fs.unlinkSync(legacy);
         console.log(left ? 'Removed the old Hippo hook from .cursorrules' : 'Deleted .cursorrules, which held only the old Hippo hook');
     }
 }
-// `hippo setup` -- one-shot configuration for every AI coding tool on the box.
-// Detection and install logic live in ./hooks.ts.
-export function cmdSetup(flags) {
-    const dryRun = Boolean(flags['dry-run']);
-    const forceAll = Boolean(flags['all']);
-    const tools = detectInstalledTools();
-    const globalRoot = getGlobalRoot();
-    console.log('Hippo setup -- configuring SessionEnd + SessionStart hooks');
-    console.log('');
+function setupDetectedTools(tools, forceAll, dryRun) {
     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);
@@ -353,6 +349,17 @@ export function cmdSetup(flags) {
             console.log(`  ${tool.name.padEnd(14)} ${tool.notes}`);
         }
     }
+}
+// `hippo setup` -- one-shot configuration for every AI coding tool on the box.
+// Detection and install logic live in ./hooks.ts.
+export function cmdSetup(flags) {
+    const dryRun = boolFlag(flags, 'dry-run');
+    const forceAll = boolFlag(flags, 'all');
+    const tools = detectInstalledTools();
+    const globalRoot = getGlobalRoot();
+    console.log('Hippo setup -- configuring SessionEnd + SessionStart hooks');
+    console.log('');
+    setupDetectedTools(tools, forceAll, dryRun);
     if (!flags['no-schedule']) {
         console.log('');
         if (dryRun) {
@@ -467,6 +474,14 @@ function setupPluginTool(tool, dryRun) {
         console.log(`  ${tool.name.padEnd(14)} ${bits.join(', ')} -> ${result.pluginPath}`);
     }
 }
+// Three times the 10 minutes POST /v1/sleep allows a consolidation, so a slow real sleep fits and a hung child cannot stall every later workspace.
+const DAILY_STEP_TIMEOUT_MS = 30 * 60_000;
+/** Why a child step failed; a child killed at the deadline says so, since its own message is only the spawn error code. */
+function dailyStepFailure(err, timeoutMs) {
+    if (err instanceof Error && 'code' in err && err.code === 'ETIMEDOUT')
+        return `timed out after ${timeoutMs} ms and was stopped`;
+    return errorMessage(err);
+}
 export function cmdDailyRunner() {
     const globalRoot = getGlobalRoot();
     // No workspace sleep ever opens the global store, yet hooks in folders without a store compact into it.
@@ -485,12 +500,14 @@ export function cmdDailyRunner() {
     console.log(`Running daily maintenance across ${workspaces.length} registered workspace${workspaces.length === 1 ? '' : 's'}...`);
     let processed = 0;
     let failed = 0;
+    const timeout = envDailyStepTimeoutMs() ?? DAILY_STEP_TIMEOUT_MS;
     runDailyMaintenance(workspaces, (cwd, args) => {
         try {
             execFileSync(process.execPath, [process.argv[1], ...args], {
                 cwd,
                 stdio: 'inherit',
                 windowsHide: true,
+                timeout,
             });
             if (args[0] === 'sleep')
                 processed++;
@@ -498,9 +515,12 @@ export function cmdDailyRunner() {
         catch (err) {
             failed++;
             const action = args.join(' ');
-            log.error(`daily-runner failed in ${cwd} during \`${action}\`: ${err.message}`);
+            log.error(`daily-runner failed in ${cwd} during \`${action}\`: ${dailyStepFailure(err, timeout)}`, { workspace: cwd });
         }
     });
     console.log(`Daily maintenance complete: ${processed} workspace${processed === 1 ? '' : 's'} processed, ${failed} command failure${failed === 1 ? '' : 's'}.`);
+    // The scheduler that runs this only sees the exit code, so a failed workspace must not read as a clean run.
+    if (failed > 0)
+        process.exitCode = 1;
 }
 //# sourceMappingURL=setup.js.map

package/dist/cli/shared.d.ts

@@ -1,17 +1,7 @@
-import { type InstallResult } from '../hooks/json-hooks.js';
-import { TaskSnapshot, SessionEvent } from '../store/rows.js';
-import type { HookRuntime } from '../capture-contract.js';
-import type { SessionHandoff } from '../handoff.js';
-import type { SearchResult } from '../search/types.js';
-import { type HippoConfig } from '../config.js';
-import { type ImportReport } from '../agent-memories/report.js';
-import { type ChurnStaleResult } from '../invalidation.js';
-import { type AuditOp } from '../audit.js';
-import { type ServerInfo } from '../server-detect.js';
-import type { RecallSearchOpts } from '../recall-pipeline.js';
-export declare function parseLimitFlag(value: string | boolean | string[] | undefined): number;
-export declare function parseCountFlag(value: string | boolean | string[] | undefined): number;
-export declare function parseBudgetFlag(value: string | boolean | string[] | undefined, fallback: number): number;
+import { type ChurnStaleResult } from '../learn/invalidation.js';
+import { type AuditOp } from '../store/audit.js';
+import { type ServerInfo } from '../server/server-detect.js';
+import type { CliFlags } from './flag-values.js';
 /**
  * Emit an audit event against `hippoRoot`'s db. Opens its own short-lived
  * connection so callers don't have to thread a db handle. Swallows all errors
@@ -40,92 +30,12 @@ export declare function runChurnStaleForRepo(hippoRoot: string, dryRun: boolean)
  * degrading to direct mode.
  */
 export declare function runViaServerIfAvailable(hippoRoot: string, httpFn: (info: ServerInfo, apiKey: string | undefined) => Promise<void>): Promise<boolean>;
-export declare function fmt(n: number, digits?: number): string;
-export declare function recallEntryText(r: SearchResult, query: string, showWhy: boolean, isGlobal: boolean): string;
-export declare function recallHeading(entries: number, tokens: number, query: string): string;
-/** One line when an agent memory import moved anything; its warnings go to stderr. */
-export declare function printAgentImport(report: ImportReport, indent?: string): void;
 /** True, after one line, on a shared store: this account's commits and agent notes are not its members' memories. */
 export declare function skipLearnOnSharedStore(hippoRoot: string): boolean;
-/** Adds hippo's two Codex hooks and says what changed; each install ends on the trust reminder, since Codex skips an untrusted hook. */
-export declare function installCodexMemoryHooks(indent: string): void;
-/** The one line init, hook install, hook uninstall and setup print when Claude Code's settings.json is not JSON hippo can edit and so was left unchanged; true when it printed. */
-export declare function warnClaudeSettingsUnusable(result: Pick<InstallResult, 'settingsPath' | 'invalidJson'>, indent: string, action?: 'install' | 'uninstall'): boolean;
-/**
- * Set up a machine-level daily runner that sweeps all registered Hippo
- * workspaces.
- * Linux/macOS: writes to user crontab.
- * Windows: creates a scheduled task.
- * Skips if already installed.
- */
-export declare function setupDailySchedule(globalRoot: string): void;
-export type CliFlags = Record<string, string | boolean | string[]>;
-/** What the command table hands each verb's run(). */
-export interface CommandContext {
-    readonly hippoRoot: string;
-    readonly args: string[];
-    readonly flags: CliFlags;
-}
-export type EngineFlags = Pick<RecallSearchOpts, 'usePhysics' | 'physicsConfig' | 'mmr' | 'mmrLambda' | 'localBump'>;
-export declare function parseAsOfFlag(flags: CliFlags): string | undefined;
-/** --physics forces physics, --classic forces BM25+cosine, else physics unless the config turns it off. */
-export declare function engineFlags(flags: CliFlags, config: HippoConfig): EngineFlags;
-/**
- * Detached worker that counts re-reads, runs sleep, then capture. Invoked via the internal
- * `__session-end-worker` subcommand (not user-facing). Failures in one stage
- * do not block the other.
- */
-/** A folder without its own store never sleeps at session end, so its project's agent notes go to the global store here. */
-export declare function logSessionEndImport(logFile: string | null, transcriptPath: string | undefined): void;
-/**
- * Best-effort log line for the snapshot-close step in
- * `cmdSessionEndWorker`. `cmdSleep`/`cmdCapture` each tee console output to
- * `logFile` only for their own duration (the tee is restored before this
- * runs), so a plain `console.log` here would be silently discarded under
- * the detached worker's `stdio: 'ignore'` — write straight to the file
- * instead, matching capture.ts's `appendPreCompactLog` convention.
- */
-export declare function appendSessionEndCloseLog(logFile: string | null, message: string, opts?: {
-    startFresh?: boolean;
-}): void;
-export declare function printActiveTaskSnapshot(snapshot: TaskSnapshot): void;
-export declare function printSessionEvents(events: SessionEvent[]): void;
-export declare function printHandoff(handoff: SessionHandoff): void;
-export declare function cardStringFlag(flags: Record<string, string | boolean | string[]>, key: string): string | undefined;
-export declare function hostSessionId(): string | undefined;
-/**
- * Compaction drops the pinned blocks the per-prompt hook injected
- * earlier, so record a `reset` for the payload's session and the next prompt
- * injects again even if nothing changed. `requiredSource` limits it to hook
- * payloads with that `source` (SessionStart fires for other reasons too).
- * Best-effort and silent: a malformed payload records nothing.
- */
-export declare function resetHookInjection(hippoRoot: string, stdinText: string | undefined, requiredSource: string | null): void;
-/**
- * Run `fn` with console.log captured; returns the captured lines joined by
- * newlines (what the same calls would have printed, minus the final newline).
- */
-export declare function captureConsole(fn: () => void): string;
-/**
- * The store a Claude Code hook writes to: the project store when there is
- * one, else an existing global store, else the project path (which the hook
- * then skips, since hooks fire in every directory and must not create one).
- * Pre-compact and compact-resume must agree, or a snapshot saved to one store
- * is looked for in the other.
- */
-export declare function hookStoreRoot(hippoRoot: string): string;
-/** `--runtime copilot`, or `--format copilot` on `hippo context`, marks a Copilot hook: the flag decides, never the payload. */
-export declare function hookRuntime(flags: CliFlags): HookRuntime;
-/** A Copilot hook's project root, from the payload's `cwd`, since VS Code runs user-level hooks in the home folder; other runtimes keep `hippoRoot`. */
-export declare function payloadCwdRoot(hippoRoot: string, stdinText: string | undefined, runtime: HookRuntime): string;
 export declare function learnFromRepo(hippoRoot: string, repoPath: string, days: number, label?: string): {
     added: number;
     skipped: number;
     lowInfo: number;
 };
-export declare function resolveAuthRoot(hippoRoot: string, flags: Record<string, string | boolean | string[]>): string;
-/** Hook commands share one handle per store and wait at most HOOK_DB_WAIT_MS for a lock; a store still busy after that skips the hook's work with one warning, exit 0. */
-export declare function runHookWithStores<T>(fn: () => T | Promise<T>): Promise<T | undefined>;
-/** Whether this session sits in the pilot's holdout arm; off at rate 0 and with no session id. */
-export declare function inPilotHoldout(hippoRoot: string, tenantId: string, sessionId: string | undefined, write: boolean): boolean;
+export declare function resolveAuthRoot(hippoRoot: string, flags: CliFlags): string;
 //# sourceMappingURL=shared.d.ts.map