hippo-memory 1.58.0 → 1.60.0

package/dist/cli.d.ts

@@ -20,6 +20,7 @@
  *   hippo rejections
  *   hippo unreject <digest-prefix>
  *   hippo dormant [<query>] [--limit <n>] [--json] | restore <id> | forget <id>
+ *   hippo projects [--json] | merge <from> <into> [--apply] | repair [--apply]
  *   hippo tokens [--days <n>] [--json] [--global]
  *   hippo doctor [--json]
  *   hippo inspect <id>
@@ -35,6 +36,7 @@
 import { MemoryEntry } from './memory.js';
 /** Test-only: reset the module-level recall-history Map. Call from beforeEach. */
 export declare function __resetSessionRecallHistoryCli(): void;
+import { type CliFlags } from './cli/shared.js';
 export declare const BOOLEAN_FLAGS: ReadonlySet<string>;
 export declare const KNOWN_FLAGS: ReadonlySet<string>;
 export declare function parseArgs(argv: string[]): {
@@ -53,7 +55,361 @@ export declare function printContextMarkdown(items: Array<{
     showStrength?: boolean;
     heading?: string;
 }): void;
+interface CommandContext {
+    readonly hippoRoot: string;
+    readonly args: string[];
+    readonly flags: CliFlags;
+}
+declare function handleRemember({ hippoRoot, args, flags }: CommandContext): Promise<void>;
+declare function handleRecall({ hippoRoot, args, flags }: CommandContext): Promise<void>;
+declare function handleDrill({ hippoRoot, args, flags }: CommandContext): void;
+declare function handleAssemble({ hippoRoot, args, flags }: CommandContext): void;
+declare function handleSupersede({ hippoRoot, args, flags }: CommandContext): void;
+declare function handleExplain({ hippoRoot, args, flags }: CommandContext): Promise<void>;
+declare function handleEval({ hippoRoot, args, flags }: CommandContext): Promise<void>;
+declare function handleTrace({ hippoRoot, args, flags }: CommandContext): void;
+declare function handlePreCompact({ hippoRoot, flags }: CommandContext): Promise<void>;
+declare function handlePostCompact({ hippoRoot, flags }: CommandContext): Promise<void>;
+declare function handleCaptureError({ hippoRoot }: CommandContext): Promise<void>;
+declare function handleCompactResume({ hippoRoot }: CommandContext): Promise<void>;
+declare function handleAudit({ hippoRoot, args, flags }: CommandContext): void;
+declare function handleCorrectionLatency({ hippoRoot, flags }: CommandContext): void;
+declare function handleProvenance({ hippoRoot, flags }: CommandContext): void;
+declare function handleDoctor({ flags }: CommandContext): void;
+declare function handleSupportBundle({ flags }: CommandContext): void;
+declare function handleForget({ hippoRoot, args, flags }: CommandContext): Promise<void>;
+declare function handleInspect({ hippoRoot, args }: CommandContext): void;
+declare function handleContext({ hippoRoot, args, flags }: CommandContext): Promise<void>;
+declare function handleWatch({ hippoRoot, args }: CommandContext): Promise<void>;
+declare function handlePromote({ hippoRoot, args }: CommandContext): Promise<void>;
+declare function handleShare({ hippoRoot, args, flags }: CommandContext): void;
+declare function handlePeers({ flags }: CommandContext): void;
+declare function handleExport({ hippoRoot, args, flags }: CommandContext): void;
+declare function handleCapture({ hippoRoot, flags }: CommandContext): Promise<void>;
+declare function handleDashboard({ hippoRoot, flags }: CommandContext): Promise<void>;
+declare function handleMcp(): Promise<void>;
+declare function handleServe({ hippoRoot, flags }: CommandContext): Promise<void>;
+declare function handleInvalidate({ hippoRoot, args, flags }: CommandContext): void;
+/** Every verb main() dispatches, keyed by name, with its handler, aliases and help blocks. */
+export declare const COMMANDS: {
+    init: {
+        run: ({ hippoRoot, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    remember: {
+        run: typeof handleRemember;
+        usage: string[];
+    };
+    recall: {
+        run: typeof handleRecall;
+        usage: string[];
+    };
+    drill: {
+        run: typeof handleDrill;
+        usage: string[];
+    };
+    assemble: {
+        run: typeof handleAssemble;
+        usage: string[];
+    };
+    supersede: {
+        run: typeof handleSupersede;
+        usage: string[];
+    };
+    explain: {
+        run: typeof handleExplain;
+        usage: string[];
+    };
+    eval: {
+        run: typeof handleEval;
+        usage: string[];
+    };
+    trace: {
+        run: typeof handleTrace;
+        usage: string[];
+    };
+    refine: {
+        run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
+        usage: string[];
+    };
+    sleep: {
+        run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
+        usage: string[];
+    };
+    'last-sleep': {
+        run: ({ flags }: CommandContext) => void;
+        usage: string[];
+    };
+    'session-end': {
+        run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
+        usage: string[];
+    };
+    '__session-end-worker': {
+        run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
+        usage: never[];
+    };
+    'pre-compact': {
+        run: typeof handlePreCompact;
+        usage: string[];
+    };
+    'post-compact': {
+        run: typeof handlePostCompact;
+        usage: string[];
+    };
+    'capture-error': {
+        run: typeof handleCaptureError;
+        usage: string[];
+    };
+    'compact-resume': {
+        run: typeof handleCompactResume;
+        usage: string[];
+    };
+    'codex-run': {
+        run: ({ hippoRoot, args }: CommandContext) => void;
+        usage: string[];
+    };
+    '__codex-session-end-worker': {
+        run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
+        usage: never[];
+    };
+    dedup: {
+        run: ({ hippoRoot, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    dag: {
+        run: ({ hippoRoot, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    auth: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    goal: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    slack: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    github: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
+        usage: string[];
+    };
+    audit: {
+        run: typeof handleAudit;
+        usage: string[];
+    };
+    'correction-latency': {
+        run: typeof handleCorrectionLatency;
+        usage: string[];
+    };
+    provenance: {
+        run: typeof handleProvenance;
+        usage: string[];
+    };
+    status: {
+        run: ({ hippoRoot }: CommandContext) => void;
+        usage: string[];
+    };
+    outcome: {
+        run: ({ hippoRoot, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    conflicts: {
+        run: ({ hippoRoot, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    resolve: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    reject: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    rejections: {
+        run: ({ hippoRoot, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    unreject: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    dormant: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    projects: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => Promise<void>;
+        usage: string[];
+    };
+    quarantine: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    tokens: {
+        run: ({ hippoRoot, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    failures: {
+        run: ({ hippoRoot, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    doctor: {
+        run: typeof handleDoctor;
+        usage: string[];
+    };
+    'support-bundle': {
+        run: typeof handleSupportBundle;
+        usage: string[];
+    };
+    snapshot: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    session: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    handoff: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    card: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    predict: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    current: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    forget: {
+        run: typeof handleForget;
+        usage: string[];
+    };
+    inspect: {
+        run: typeof handleInspect;
+        usage: string[];
+    };
+    context: {
+        run: typeof handleContext;
+        usage: string[];
+    };
+    hook: {
+        run: ({ args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    setup: {
+        run: ({ flags }: CommandContext) => void;
+        usage: string[];
+    };
+    'daily-runner': {
+        run: () => void;
+        usage: string[];
+    };
+    embed: {
+        run: ({ hippoRoot, flags }: CommandContext) => Promise<void>;
+        usage: string[];
+    };
+    watch: {
+        run: typeof handleWatch;
+        usage: string[];
+    };
+    learn: {
+        run: ({ hippoRoot, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    promote: {
+        run: typeof handlePromote;
+        usage: string[];
+    };
+    sync: {
+        run: ({ hippoRoot, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    share: {
+        run: typeof handleShare;
+        usage: string[];
+    };
+    peers: {
+        run: typeof handlePeers;
+        usage: string[];
+    };
+    import: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    export: {
+        run: typeof handleExport;
+        usage: string[];
+    };
+    capture: {
+        run: typeof handleCapture;
+        usage: string[];
+    };
+    dashboard: {
+        run: typeof handleDashboard;
+        usage: string[];
+    };
+    wm: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    mcp: {
+        run: typeof handleMcp;
+        usage: string[];
+    };
+    serve: {
+        run: typeof handleServe;
+        usage: string[];
+    };
+    invalidate: {
+        run: typeof handleInvalidate;
+        usage: string[];
+    };
+    decide: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    incident: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    process: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    policy: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    skill: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+    brief: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        aliases: string[];
+        usage: string[];
+    };
+    note: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        aliases: string[];
+        usage: string[];
+    };
+    graph: {
+        run: ({ hippoRoot, args, flags }: CommandContext) => void;
+        usage: string[];
+    };
+};
 export declare function usageText(): string;
+/** One verb's help blocks as `hippo <verb> --help` prints them, or null for a verb with none. */
 export declare function verbUsage(verb: string): string | null;
 export declare function runCli(argv?: string[]): Promise<void>;
+export {};
 //# sourceMappingURL=cli.d.ts.map