hippo-memory 1.69.0 → 1.71.0

package/dist/cli/print.js

@@ -0,0 +1,82 @@
+// Text printers for recall results, agent imports, task snapshots, session trails and handoffs.
+import { confidenceLabel } from '../core/memory.js';
+import { explainMatch } from '../search/explain.js';
+import { summaryLine } from '../agent-memories/report.js';
+import { snapshotText, sessionTrailText, handoffText } from '../api/context-render.js';
+import { printError } from './output.js';
+export function fmt(n, digits = 2) {
+    return n.toFixed(digits);
+}
+// What `hippo recall` prints for one result; the budget prices this same text.
+export function recallEntryText(r, query, showWhy, isGlobal) {
+    const e = r.entry;
+    const label = confidenceLabel(e);
+    const confLabel = label.warn ? `[${label.text}] ⚠️` : `[${label.text}]`;
+    const bars = Math.round(e.strength * 10);
+    const graphMark = r.graphVia ? ` [graph: ${r.graphVia.hops}hop ${r.graphVia.relType}]` : '';
+    const lines = [
+        `--- ${e.id} [${e.layer}] ${confLabel}${isGlobal ? ' [global]' : ''}${e.superseded_by ? ' [superseded]' : ''}${graphMark} score=${fmt(r.score, 3)} strength=${fmt(e.strength)}`,
+        `    [${'█'.repeat(bars)}${'░'.repeat(10 - bars)}] tags: ${e.tags.join(', ') || 'none'} | retrieved: ${e.retrieval_count}x`,
+    ];
+    if (showWhy) {
+        const explanation = explainMatch(query, r);
+        lines.push(`    source:${isGlobal ? ' [global]' : ' [local]'} | layer: [${e.layer}] | confidence: [${label.text}]`, `    reason: ${explanation.reason}`);
+        const env = explanation.envelope;
+        if (env) {
+            lines.push(`    kind: ${env.kind}`);
+            if (env.scope)
+                lines.push(`    scope: ${env.scope}`);
+            if (env.owner)
+                lines.push(`    owner: ${env.owner}`);
+            if (env.artifact_ref)
+                lines.push(`    artifact_ref: ${env.artifact_ref}`);
+            if (env.session_id)
+                lines.push(`    session_id: ${env.session_id}`);
+            lines.push(`    confidence: ${env.confidence}`);
+        }
+        // The recall trace, e.g. "ranking: base 0.420 -> interference x0.30 -> 0.126 -> goal-boost x1.50 -> 0.189".
+        if (r.rerankTrace && r.rerankTrace.length > 0) {
+            const parts = [`base ${fmt(r.rerankTrace[0].scoreBefore, 3)}`];
+            for (const step of r.rerankTrace) {
+                parts.push(`${step.stage}${step.multiplier !== undefined ? ` x${fmt(step.multiplier, 2)}` : ''}`, fmt(step.scoreAfter, 3));
+            }
+            lines.push(`    ranking: ${parts.join(' -> ')}`);
+        }
+    }
+    lines.push('', e.content, '');
+    return lines.join('\n');
+}
+export function recallHeading(entries, tokens, query) {
+    return `Found ${entries} memories (${tokens} tokens) for: "${query}"\n`;
+}
+/** One line when an agent memory import moved anything; its warnings go to stderr. */
+export function printAgentImport(report, indent = '   ') {
+    const line = summaryLine(report);
+    if (line !== null)
+        console.log(`${indent}${line}`);
+    for (const warning of report.warnings)
+        printError(`hippo: agent memories: ${warning}`);
+}
+export function printActiveTaskSnapshot(snapshot) {
+    console.log(snapshotText(snapshot));
+}
+export function printSessionEvents(events) {
+    console.log(events.length === 0 ? 'No session events found.' : sessionTrailText(events));
+}
+export function printHandoff(handoff) {
+    console.log(handoffText(handoff));
+}
+/** Run `fn` with console.log captured; returns the captured lines joined by newlines (no final newline). */
+export function captureConsole(fn) {
+    const lines = [];
+    const realLog = console.log;
+    console.log = (...parts) => { lines.push(parts.map(String).join(' ')); };
+    try {
+        fn();
+    }
+    finally {
+        console.log = realLog;
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=print.js.map

package/dist/cli/projects.d.ts

@@ -1,4 +1,3 @@
-type Flags = Record<string, string | boolean | string[]>;
-export declare function cmdProjects(hippoRoot: string, args: string[], flags: Flags): void;
-export {};
+import { type CommandContext } from './flag-values.js';
+export declare function handleProjects({ hippoRoot, tenantId, args, flags }: CommandContext): void;
 //# sourceMappingURL=projects.d.ts.map

package/dist/cli/projects.js

@@ -1,11 +1,13 @@
 // The `hippo projects` verb: list a store's project names, fold an old worktree name into its repo, repair old tags in one pass.
 import * as path from 'path';
 import { execFileSync } from 'child_process';
-import { closeHippoDb, openHippoDb } from '../db.js';
-import { listProjects, mergeProjects, repairProjects } from '../project-merge.js';
-import { resolveTenantId } from '../tenant.js';
+import { closeHippoDb, openHippoDb } from '../db/index.js';
+import { listProjects, mergeProjects, repairProjects } from '../sharing/project-merge.js';
+import { flagIsTrue } from './flag-values.js';
 import { resolveAuthRoot } from './shared.js';
 import { printError } from './output.js';
+import { errorMessage } from '../util/log.js';
+import { DATE_PREFIX_CHARS } from '../util/token-text.js';
 /** Old per-worktree project names of the repo at cwd, mapped to the repo's main checkout name; empty outside git. */
 function worktreeNames() {
     try {
@@ -30,62 +32,65 @@ function hint(p, worktrees) {
 function count(n, one, many = `${one}s`) {
     return `${n} ${n === 1 ? one : many}`;
 }
-export function cmdProjects(hippoRoot, args, flags) {
+function projectsList(db, tenantId, root, flags) {
+    const projects = listProjects(db, tenantId);
+    if (flags['json']) {
+        console.log(JSON.stringify({ store: root, projects }, null, 2));
+        return;
+    }
+    const worktrees = worktreeNames();
+    console.log(`${count(projects.length, 'project name')} in ${root} (newest write first):\n`);
+    for (const p of projects) {
+        console.log(`${label(p.origin)}  ${count(p.live, 'memory', 'memories')}, ${p.imported} imported from agent notes, newest ${p.newest.slice(0, DATE_PREFIX_CHARS)}${hint(p, worktrees)}`);
+    }
+}
+function projectsMerge(db, tenantId, root, args, flags) {
+    const apply = flagIsTrue(flags, 'apply');
+    const [from, into] = [args[1] ?? '', args[2] ?? ''];
+    const r = mergeProjects(db, root, { tenantId, from, into, dryRun: !apply });
+    if (flags['json']) {
+        console.log(JSON.stringify(r, null, 2));
+        return;
+    }
+    console.log(`${apply ? 'Merged' : 'Dry run: would merge'} ${from} into ${into}:`);
+    console.log(`  ${count(r.setAside.length, 'imported note copy', 'imported note copies')} set aside (${into} already holds the same note; the rest move under ${into} on the next sync)`);
+    console.log(`  ${count(r.restamped.length, 'memory', 'memories')} re-tagged, plus ${r.dormantRestamped.length} dormant and ${count(r.compactions, 'compaction record')}`);
+    console.log(apply ? `Backup: ${r.backup}\nEvery id is in the audit log: hippo audit list --op project_merge` : 'Nothing written. Add --apply to run it.');
+}
+function projectsRepair(db, tenantId, root, flags) {
+    const apply = flagIsTrue(flags, 'apply');
+    const r = repairProjects(db, root, { tenantId, dryRun: !apply });
+    if (flags['json']) {
+        console.log(JSON.stringify(r, null, 2));
+        return;
+    }
+    console.log(`${apply ? 'Repaired' : 'Dry run: would repair'} ${root}:`);
+    console.log(`  ${count(r.copies.length, 'imported note copy', 'imported note copies')} under the wrong project set aside (the note stays under its own, or user-global)`);
+    for (const f of r.folds)
+        console.log(`  ${f.from} folded into ${f.into} (its sessions' folders resolve there now)`);
+    for (const c of r.collisions)
+        console.log(`  ${c.name} left as it is: its folders now resolve to ${c.ids.join(', ')}; fold it by hand with hippo projects merge`);
+    console.log(`  sleep's user-global merged rows: ${r.toProject.length} re-tagged to their parents' project`);
+    console.log(`  ${r.setAside.length} set aside (parents in two projects; sleep re-merges them per project)`);
+    console.log(`  ${r.untraced.length} left as they are (no parent left to show which project; check them with hippo inspect <id>)`);
+    console.log(apply ? `Backup: ${r.backup}\nEvery id is in the audit log: hippo audit list --op project_repair` : 'Nothing written. Add --apply to run it.');
+}
+export function handleProjects({ hippoRoot, tenantId, args, flags }) {
     const root = resolveAuthRoot(hippoRoot, flags);
-    const tenantId = resolveTenantId({});
-    const apply = flags['apply'] === true;
     const sub = args[0] ?? 'list';
     const db = openHippoDb(root);
     try {
-        if (sub === 'list') {
-            const projects = listProjects(db, tenantId);
-            if (flags['json']) {
-                console.log(JSON.stringify({ store: root, projects }, null, 2));
-                return;
-            }
-            const worktrees = worktreeNames();
-            console.log(`${count(projects.length, 'project name')} in ${root} (newest write first):\n`);
-            for (const p of projects) {
-                console.log(`${label(p.origin)}  ${count(p.live, 'memory', 'memories')}, ${p.imported} imported from agent notes, newest ${p.newest.slice(0, 10)}${hint(p, worktrees)}`);
-            }
-            return;
-        }
-        if (sub === 'merge') {
-            const [from, into] = [args[1] ?? '', args[2] ?? ''];
-            const r = mergeProjects(db, root, { tenantId, from, into, dryRun: !apply });
-            if (flags['json']) {
-                console.log(JSON.stringify(r, null, 2));
-                return;
-            }
-            console.log(`${apply ? 'Merged' : 'Dry run: would merge'} ${from} into ${into}:`);
-            console.log(`  ${count(r.setAside.length, 'imported note copy', 'imported note copies')} set aside (${into} already holds the same note; the rest move under ${into} on the next sync)`);
-            console.log(`  ${count(r.restamped.length, 'memory', 'memories')} re-tagged, plus ${r.dormantRestamped.length} dormant and ${count(r.compactions, 'compaction record')}`);
-            console.log(apply ? `Backup: ${r.backup}\nEvery id is in the audit log: hippo audit list --op project_merge` : 'Nothing written. Add --apply to run it.');
-            return;
-        }
-        if (sub === 'repair') {
-            const r = repairProjects(db, root, { tenantId, dryRun: !apply });
-            if (flags['json']) {
-                console.log(JSON.stringify(r, null, 2));
-                return;
-            }
-            console.log(`${apply ? 'Repaired' : 'Dry run: would repair'} ${root}:`);
-            console.log(`  ${count(r.copies.length, 'imported note copy', 'imported note copies')} under the wrong project set aside (the note stays under its own, or user-global)`);
-            for (const f of r.folds)
-                console.log(`  ${f.from} folded into ${f.into} (its sessions' folders resolve there now)`);
-            for (const c of r.collisions)
-                console.log(`  ${c.name} left as it is: its folders now resolve to ${c.ids.join(', ')}; fold it by hand with hippo projects merge`);
-            console.log(`  sleep's user-global merged rows: ${r.toProject.length} re-tagged to their parents' project`);
-            console.log(`  ${r.setAside.length} set aside (parents in two projects; sleep re-merges them per project)`);
-            console.log(`  ${r.untraced.length} left as they are (no parent left to show which project; check them with hippo inspect <id>)`);
-            console.log(apply ? `Backup: ${r.backup}\nEvery id is in the audit log: hippo audit list --op project_repair` : 'Nothing written. Add --apply to run it.');
-            return;
-        }
+        if (sub === 'list')
+            return projectsList(db, tenantId, root, flags);
+        if (sub === 'merge')
+            return projectsMerge(db, tenantId, root, args, flags);
+        if (sub === 'repair')
+            return projectsRepair(db, tenantId, root, flags);
         printError('Usage: hippo projects [list] [--json] | merge <from> <into> [--apply] | repair [--apply]  [--global]');
         process.exitCode = 1;
     }
     catch (err) {
-        printError(err instanceof Error ? err.message : String(err));
+        printError(errorMessage(err));
         process.exitCode = 1;
     }
     finally {

package/dist/cli/provenance-coverage.d.ts

@@ -0,0 +1,14 @@
+import { MemoryEntry } from '../core/memory.js';
+export interface ProvenanceCoverage {
+    rawTotal: number;
+    rawWithEnvelope: number;
+    coverage: number;
+    gaps: Array<{
+        id: string;
+        missing: ('owner' | 'artifact_ref')[];
+    }>;
+}
+/** Provenance coverage gate: every `kind='raw'` row must carry `owner` and `artifact_ref`; derivative or terminal rows are excluded.
+ * Coverage 1.0 on a non-empty raw set is the ship gate. */
+export declare function buildProvenanceCoverage(entries: MemoryEntry[]): ProvenanceCoverage;
+//# sourceMappingURL=provenance-coverage.d.ts.map

package/dist/{provenance-coverage.js → cli/provenance-coverage.js}

@@ -1,9 +1,5 @@
-/**
- * Provenance coverage gate: every `kind='raw'` row must carry both `owner`
- * and `artifact_ref`. Distilled / superseded / archived rows are excluded —
- * those are derivative or terminal, not source receipts. Coverage of 1.0 on
- * a non-empty raw set is the ship gate from the Company Brain scorecard.
- */
+/** Provenance coverage gate: every `kind='raw'` row must carry `owner` and `artifact_ref`; derivative or terminal rows are excluded.
+ * Coverage 1.0 on a non-empty raw set is the ship gate. */
 export function buildProvenanceCoverage(entries) {
     const raws = entries.filter((e) => e.kind === 'raw');
     const gaps = [];

package/dist/cli/quality-repair-once.js

@@ -1,9 +1,9 @@
 // Sleep and the daily runner clean a store's old automatic memories once, so an upgrade needs no command.
 import * as path from 'path';
-import { errorMessage, log } from '../log.js';
-import { repairQualityOnce } from '../quality-repair.js';
-import { getGlobalRoot } from '../shared.js';
-import { resolveTenantId } from '../tenant.js';
+import { errorMessage, log } from '../util/log.js';
+import { repairQualityOnce } from '../store/quality-repair.js';
+import { getGlobalRoot } from '../sharing/global-store.js';
+import { resolveTenantId } from '../store/tenant.js';
 /** Fault-isolated like the project tag repair: a failure warns, leaves the store unmarked and runs again next time. */
 export function repairQualityOnceAt(root) {
     try {

package/dist/cli/recall.d.ts

@@ -1,7 +1,3 @@
-import { type CliFlags, type CommandContext } from './shared.js';
-/** Test-only: reset the CLI recall rings. Call from beforeEach. */
-export declare function __resetSessionRecallHistoryCli(): void;
-/** Runs `hippo recall`: parse, rank, load continuity, fit the printed block to the budget, audit, then write and print. */
-export declare function cmdRecall(hippoRoot: string, query: string, flags: CliFlags): Promise<void>;
-export declare function handleRecall({ hippoRoot, args, flags }: CommandContext): Promise<void>;
+import { type CommandContext } from './flag-values.js';
+export declare function handleRecall({ hippoRoot, tenantId, args, flags }: CommandContext): Promise<void>;
 //# sourceMappingURL=recall.d.ts.map