hippo-memory 1.71.0 → 2.0.0

package/dist/cli/install-steps.js

@@ -3,7 +3,8 @@ import * as path from 'path';
 import { execFileSync, execSync } from 'child_process';
 import { installJsonHooks } from '../hooks/json-hooks.js';
 import { CODEX_TRUST_LINE } from '../hooks/shared.js';
-import { DAILY_TASK_NAME, buildDailyRunnerCommand, hasUnsafeRunnerPathChars, buildSchtasksCreateArgs, buildWindowsTaskRun, quoteInsideWindowsArg } from './scheduler.js';
+import { envSkipSchedule } from '../util/env.js';
+import { DAILY_TASK_NAME, buildDailyRunnerCommand, hasUnsafeRunnerPathChars, buildSchtasksCreateArgs, buildWindowsTaskRun, quoteInsideWindowsArg, } from './scheduler.js';
 /** Adds hippo's two Codex hooks and says what changed; each install ends on the trust reminder, since Codex skips an untrusted hook. */
 export function installCodexMemoryHooks(indent) {
     const result = installJsonHooks('codex');
@@ -20,11 +21,13 @@ export function installCodexMemoryHooks(indent) {
         : `${indent}hippo's Codex memory hooks already in ${result.settingsPath}`);
     console.log(`${indent}${CODEX_TRUST_LINE}`);
 }
-/** 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. */
+/** 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 function warnClaudeSettingsUnusable(result, indent, action = 'install') {
     if (!result.invalidJson)
         return false;
-    console.log(`${indent}WARNING: ${result.settingsPath} is not a JSON object hippo can merge into, so it was left unchanged; fix it, then run \`hippo hook ${action} claude-code\`.`);
+    console.log(`${indent}WARNING: ${result.settingsPath} is not a JSON object hippo can merge into, so it was left unchanged; ` +
+        `fix it, then run \`hippo hook ${action} claude-code\`.`);
     return true;
 }
 /** Machine-level daily runner sweeping all registered workspaces: user crontab on Linux/macOS, a scheduled task on Windows; skips if installed. */
@@ -38,6 +41,11 @@ function warnSchedulerTimedOut(command) {
     console.log(`   ${command} did not answer within ${SCHEDULER_CALL_TIMEOUT_MS / 1000} s and was stopped, so the daily runner is not scheduled.`);
 }
 export function setupDailySchedule(globalRoot) {
+    // Checked here, not per caller, so init, init --scan and setup all honour it.
+    if (envSkipSchedule()) {
+        console.log('   HIPPO_SKIP_SCHEDULE=1, so the machine-level daily runner was not scheduled.');
+        return;
+    }
     const runnerDir = path.resolve(globalRoot);
     if (hasUnsafeRunnerPathChars(runnerDir, process.platform)) {
         console.log(`   Skipping schedule: runner path contains unsafe characters.`);

package/dist/cli/last-sleep.js

@@ -1,7 +1,7 @@
 // `hippo last-sleep`: the previous session's sleep log for the debug log, and one problems line for the user.
 import * as fs from 'fs';
 import { isStringValue } from '../core/capture-contract.js';
-import { REPLAY_AFTER_MS } from '../capture/compaction-record.js';
+import { REPLAY_AFTER_MS } from '../core/compaction-timing.js';
 import { SPOOL_PROBLEM, spoolCounts } from '../capture/compaction-spool.js';
 import { defaultSleepLogPath } from '../hooks/shared.js';
 import { errorMessage, log } from '../util/log.js';

package/dist/cli/maintenance.d.ts

@@ -1,6 +1,6 @@
-import { type EmbeddingProvider } from '../store/embeddings/provider.js';
+import { type EmbeddingProvider } from '../embeddings/provider.js';
 import { type CommandContext } from './flag-values.js';
 export declare function handleRefine({ hippoRoot, tenantId, flags }: CommandContext): Promise<void>;
-export declare function handleDedup({ hippoRoot, flags }: CommandContext): void;
-export declare function handleEmbed({ hippoRoot, flags }: CommandContext, given?: EmbeddingProvider): Promise<void>;
+export declare function handleDedup({ hippoRoot, tenantId, flags }: CommandContext): void;
+export declare function handleEmbed({ hippoRoot, tenantId, flags }: CommandContext, given?: EmbeddingProvider): Promise<void>;
 //# sourceMappingURL=maintenance.d.ts.map

package/dist/cli/maintenance.js

@@ -1,14 +1,14 @@
 // Store upkeep verbs: `hippo refine`, `hippo dedup` and `hippo embed`.
 import { envAnthropicApiKey } from '../util/env.js';
-import { loadAllEntries, loadAllEntryIds } from '../store/entry-reads.js';
 import { deduplicateStore } from '../consolidate/dedupe.js';
-import { embedAll } from '../store/embeddings/index.js';
-import { resolveEmbeddingProvider } from '../store/embeddings/provider.js';
-import { loadEmbeddingIndex, resetStoredParticles } from '../store/vector-index.js';
+import { resolveEmbeddingProvider } from '../embeddings/provider.js';
+import { embedCoverage, embedMissingMemories, resetPhysicsFromVectors, storedVectorCount } from '../api/embeddings.js';
+import { countAllMemories } from '../api/memories.js';
+import { cliApiContext } from './api-context.js';
 import { loadConfig } from '../core/config.js';
 import { refineStore } from './refine-llm.js';
 import { printError } from './output.js';
-import { boolFlag } from './flag-values.js';
+import { boolFlag, numberFlag } from './flag-values.js';
 import { requireInit, resolveAuthRoot } from './shared.js';
 import { errorMessage } from '../util/log.js';
 import { CliExit } from './exit.js';
@@ -24,7 +24,7 @@ export async function handleRefine({ hippoRoot, tenantId, flags }) {
     }
     const dryRun = boolFlag(flags, 'dry-run');
     const all = boolFlag(flags, 'all');
-    const limit = flags['limit'] !== undefined ? parseInt(String(flags['limit']), 10) : undefined;
+    const limit = numberFlag(flags, 'limit');
     const model = flags['model'] ? String(flags['model']) : undefined;
     const asJson = boolFlag(flags, 'json');
     const result = await refineStore(hippoRoot, {
@@ -50,14 +50,14 @@ export async function handleRefine({ hippoRoot, tenantId, flags }) {
         }
     }
 }
-export function handleDedup({ hippoRoot, flags }) {
+export function handleDedup({ hippoRoot, tenantId, flags }) {
     requireInit(hippoRoot);
     const dryRun = boolFlag(flags, 'dry-run');
     if (flags['threshold'] !== undefined) {
         printError('hippo dedup: --threshold is ignored; a duplicate is the same text apart from spacing.');
     }
-    const entries = loadAllEntries(hippoRoot);
-    console.log(`Scanning ${entries.length} memories for duplicates (same text apart from spacing)${dryRun ? ' (dry run)' : ''}...\n`);
+    const total = countAllMemories(cliApiContext(hippoRoot, tenantId));
+    console.log(`Scanning ${total} memories for duplicates (same text apart from spacing)${dryRun ? ' (dry run)' : ''}...\n`);
     const result = deduplicateStore(hippoRoot, { dryRun });
     if (result.removed === 0) {
         console.log('No duplicates found.');
@@ -100,18 +100,19 @@ function printDedupPairs(result, dryRun) {
     }
 }
 // Embed command
-export async function handleEmbed({ hippoRoot, flags }, given) {
+export async function handleEmbed({ hippoRoot, tenantId, flags }, given) {
     // --global mirrors resolveAuthRoot: initGlobal() + the global root, skipping the local requireInit,
     // so it heals pre-1.27.0 global stores from a directory with no local .hippo.
     const root = resolveAuthRoot(hippoRoot, flags);
+    const ctx = cliApiContext(root, tenantId);
     // --status and --reset-physics only read cached state, so they must work with no provider key (e.g. removed after an earlier embed);
     // the provider-availability gate is deferred to the embed path.
     if (flags['reset-physics']) {
-        resetPhysics(root);
+        resetPhysics(ctx);
         return;
     }
     if (flags['status']) {
-        printEmbedStatus(root);
+        printEmbedStatus(ctx);
         return;
     }
     const provider = readyEmbedProvider(root, given);
@@ -120,40 +121,38 @@ export async function handleEmbed({ hippoRoot, flags }, given) {
     console.log('Embedding all memories (this may take a moment on first run to download model)...');
     let count;
     try {
-        count = await embedAll(root, undefined, provider);
+        count = await embedMissingMemories(ctx, provider);
     }
     catch (err) {
         printError(`Embedding failed: ${errorMessage(err)}`);
-        const partial = loadEmbeddingIndex(root);
-        printError(`Partial progress saved: ${Object.keys(partial).length} embeddings on disk. Re-run \`hippo embed\` to resume.`);
+        printError(`Partial progress saved: ${storedVectorCount(ctx)} embeddings on disk. Re-run \`hippo embed\` to resume.`);
         process.exitCode = 1;
         return;
     }
-    const entriesAfter = loadAllEntries(root);
-    const embIndexAfter = loadEmbeddingIndex(root);
-    console.log(`Done. ${count} new embeddings created. ${Object.keys(embIndexAfter).length}/${entriesAfter.length} total.`);
-    const unembedded = entriesAfter.filter((e) => !embIndexAfter[e.id]).length;
+    const after = embedCoverage(ctx);
+    console.log(`Done. ${count} new embeddings created. ${after.vectorIds.length}/${after.memoryIds.length} total.`);
+    const embeddedAfter = new Set(after.vectorIds);
+    const unembedded = after.memoryIds.filter((id) => !embeddedAfter.has(id)).length;
     if (unembedded > 0) {
         printError(`${unembedded} memories are still not embedded (the warnings above name them). Re-run \`hippo embed\` to retry.`);
         process.exitCode = 1;
     }
 }
-function resetPhysics(root) {
-    const embIndex = loadEmbeddingIndex(root);
-    const count = resetStoredParticles(root, loadAllEntryIds(root), embIndex);
+function resetPhysics(ctx) {
+    const count = resetPhysicsFromVectors(ctx);
     console.log(`Reset physics state: ${count} particles re-initialized from embeddings.`);
 }
-function printEmbedStatus(root) {
-    const entries = loadAllEntries(root);
-    const embIndex = loadEmbeddingIndex(root);
-    const activeIds = new Set(entries.map((e) => e.id));
-    const activeEmbedded = Object.keys(embIndex).filter((id) => activeIds.has(id)).length;
-    const orphaned = Object.keys(embIndex).length - activeEmbedded;
-    console.log(`Embedding status: ${activeEmbedded}/${entries.length} memories embedded`);
+function printEmbedStatus(ctx) {
+    const { memoryIds, vectorIds } = embedCoverage(ctx);
+    const activeIds = new Set(memoryIds);
+    const activeEmbedded = vectorIds.filter((id) => activeIds.has(id)).length;
+    const orphaned = vectorIds.length - activeEmbedded;
+    console.log(`Embedding status: ${activeEmbedded}/${memoryIds.length} memories embedded`);
     if (orphaned > 0) {
         console.log(`  ${orphaned} orphaned embeddings (run \`hippo embed\` to prune)`);
     }
-    const missing = entries.filter((e) => !embIndex[e.id]);
+    const embedded = new Set(vectorIds);
+    const missing = memoryIds.filter((id) => !embedded.has(id));
     if (missing.length > 0) {
         console.log(`  ${missing.length} memories need embedding (run \`hippo embed\` to embed them)`);
     }

package/dist/cli/notes.d.ts

@@ -0,0 +1,2 @@
+export declare const handleCustomerNote: (ctx: import("./flag-values.js").CommandContext) => void;
+//# sourceMappingURL=notes.d.ts.map

package/dist/cli/notes.js

@@ -0,0 +1,41 @@
+// The customer note verbs: one account's note, versioned by supersession.
+import * as customerNotesModule from '../objects/customer-notes.js';
+import { stringFlag } from './flag-values.js';
+import { requiredText, versionedVerbs } from './versioned-verbs.js';
+function printNoteRow(n) {
+    console.log(`#${n.id} [${n.status}] v${n.version} customer="${n.customer}" memory=${n.memoryId ?? '-'}`);
+    if (n.changeSummary)
+        console.log(`    change: ${n.changeSummary}`);
+}
+const noteKind = (hippoRoot, tenantId) => ({
+    names: { cmd: 'note', noun: 'Customer note', idLabel: 'note' },
+    plural: 'customer notes',
+    states: customerNotesModule.VALID_NOTE_STATES,
+    usage: [
+        'Usage: hippo note new "<customer>" --text "<note>"',
+        '       hippo note list [--status active|superseded|closed|all] [--customer "<id>"] [--limit N]',
+        '       hippo note get <id>',
+        '       hippo note supersede <id> --text "<note>" [--change "<summary>"]',
+        '       hippo note close <id>',
+    ],
+    supersedeUsage: 'Usage: hippo note supersede <id> --text "<note>" [--change "<summary>"]',
+    bodyRequired: '--text "<note>"',
+    body: (flags) => requiredText(flags, 'text'),
+    keyOf: (n) => n.customer,
+    save: (customer, note, extraTags, from) => customerNotesModule.saveCustomerNote(hippoRoot, tenantId, {
+        customer, note, extraTags, changeSummary: from?.changeSummary, supersedesNoteId: from?.id,
+    }),
+    recorded: (n) => `Customer note recorded: #${n.id} (v${n.version}) for customer "${n.customer}"`,
+    list: (opts, flags) => customerNotesModule.loadCustomerNotes(hippoRoot, tenantId, { ...opts, customer: stringFlag(flags, 'customer')?.trim() || undefined }),
+    loadById: (id) => customerNotesModule.loadCustomerNoteById(hippoRoot, tenantId, id),
+    close: (id) => customerNotesModule.closeCustomerNote(hippoRoot, tenantId, id),
+    printRow: printNoteRow,
+    printDetail: (n) => {
+        console.log(`  customer: ${n.customer}`);
+        console.log(`  status: ${n.status}`);
+        console.log(`  version: ${n.version}`);
+        console.log(`  note: ${n.note}`);
+    },
+});
+export const handleCustomerNote = versionedVerbs(noteKind);
+//# sourceMappingURL=notes.js.map

package/dist/cli/object-verbs.d.ts

@@ -14,7 +14,7 @@ export interface ObjectListSpec<O, S extends string> {
 }
 export declare function listObjects<O, S extends string>(flags: CliFlags, spec: ObjectListSpec<O, S>): void;
 /** The `<id>` after the subcommand; prints `usage` and exits 1 when it is missing. */
-export declare function idArgOrExit(args: string[], usage: string, label: string, parseId?: (raw: string, label: string) => number): number;
+export declare function idArgOrExit(args: string[], usage: string, label: string): number;
 export declare function foundOrExit<O>(found: O | null | undefined, noun: string, id: number): O;
 /** How a kind is named in usage lines (`cmd`), in messages (`noun`) and in the invalid-id error (`idLabel`). */
 export interface ObjectNames {
@@ -25,7 +25,7 @@ export interface ObjectNames {
 /** `hippo <cmd> close <id>` for a kind whose close call returns the closed row. */
 export declare function closeObject(args: string[], names: ObjectNames, close: (id: number) => {
     id: number;
-}, parseId?: (raw: string, label: string) => number): void;
+}): void;
 interface LifecycleTail {
     readonly changeSummary?: string | null;
     readonly supersededBy: number | null;

package/dist/cli/object-verbs.js

@@ -29,13 +29,13 @@ export function listObjects(flags, spec) {
         spec.printRow(o);
 }
 /** The `<id>` after the subcommand; prints `usage` and exits 1 when it is missing. */
-export function idArgOrExit(args, usage, label, parseId = parsePositiveId) {
+export function idArgOrExit(args, usage, label) {
     const idRaw = args[1];
     if (!idRaw) {
         printError(usage);
         throw new CliExit(1);
     }
-    return parseId(idRaw, label);
+    return parsePositiveId(idRaw, label);
 }
 export function foundOrExit(found, noun, id) {
     if (!found) {
@@ -45,8 +45,8 @@ export function foundOrExit(found, noun, id) {
     return found;
 }
 /** `hippo <cmd> close <id>` for a kind whose close call returns the closed row. */
-export function closeObject(args, names, close, parseId = parsePositiveId) {
-    const id = idArgOrExit(args, `Usage: hippo ${names.cmd} close <id>`, names.idLabel, parseId);
+export function closeObject(args, names, close) {
+    const id = idArgOrExit(args, `Usage: hippo ${names.cmd} close <id>`, names.idLabel);
     console.log(`${names.noun} #${close(id).id} closed.`);
 }
 /** The detail lines every `get` ends with. */

package/dist/cli/open-browser.d.ts

@@ -0,0 +1,14 @@
+/** The part of a child process the launch reads. */
+interface Launched {
+    on(event: 'error', listener: (err: Error) => void): void;
+    unref(): void;
+}
+type Launcher = (cmd: string, args: string[], opts: {
+    detached: boolean;
+    stdio: 'ignore';
+    windowsHide: boolean;
+}) => Launched;
+/** `launch` is the process starter; tests hand in a stand-in. */
+export declare function openInBrowser(out: string, launch?: Launcher): void;
+export {};
+//# sourceMappingURL=open-browser.d.ts.map

package/dist/cli/open-browser.js

@@ -0,0 +1,26 @@
+// Best-effort browser launch for CLI verbs that write a file.
+import { spawn } from 'child_process';
+import { errorMessage, log } from '../util/log.js';
+/** `launch` is the process starter; tests hand in a stand-in. */
+export function openInBrowser(out, launch = spawn) {
+    // Best-effort browser launch; never fail the command if it doesn't work.
+    try {
+        const [cmd, cmdArgs] = process.platform === 'win32'
+            ? ['cmd', ['/c', 'start', '', out]]
+            : process.platform === 'darwin'
+                ? ['open', [out]]
+                : ['xdg-open', [out]];
+        const child = launch(cmd, cmdArgs, { detached: true, stdio: 'ignore', windowsHide: true });
+        // A missing launcher (e.g. xdg-open absent) emits 'error' asynchronously; unhandled, it would throw.
+        child.on('error', (err) => {
+            log.warn(`graph view: could not open the browser: ${errorMessage(err)}`);
+            process.exitCode = 1;
+        });
+        child.unref();
+    }
+    catch (err) {
+        // The file is written and its path printed above, so a browser that will not start costs nothing.
+        log.debug(`browser not opened: ${errorMessage(err)}`);
+    }
+}
+//# sourceMappingURL=open-browser.js.map

package/dist/cli/playbooks.d.ts

@@ -1,5 +1,4 @@
-import { type CommandContext } from './flag-values.js';
-export declare function handleProcess({ hippoRoot, tenantId, args, flags }: CommandContext): void;
-export declare function handlePolicy({ hippoRoot, tenantId, args, flags }: CommandContext): void;
-export declare function handleSkill({ hippoRoot, tenantId, args, flags }: CommandContext): void;
+export declare const handleProcess: (ctx: import("./flag-values.js").CommandContext) => void;
+export declare const handlePolicy: (ctx: import("./flag-values.js").CommandContext) => void;
+export declare const handleSkill: (ctx: import("./flag-values.js").CommandContext) => void;
 //# sourceMappingURL=playbooks.d.ts.map