hippo-memory 0.35.0 → 0.36.0

package/dist/cli.js

@@ -45,12 +45,15 @@ import { captureError, extractLessons, deduplicateLesson, runWatched, fetchGitLo
 import { extractInvalidationTarget, invalidateMatching } from './invalidation.js';
 import { extractPathTags } from './path-context.js';
 import { detectScope, scopeMatch } from './scope.js';
-import { getGlobalRoot, initGlobal, promoteToGlobal, shareMemory, listPeers, autoShare, transferScore, searchBothHybrid, syncGlobalToLocal, } from './shared.js';
+import { getGlobalRoot, initGlobal, shareMemory, listPeers, autoShare, transferScore, searchBothHybrid, syncGlobalToLocal, } from './shared.js';
 import { DAILY_TASK_NAME, buildDailyRunnerCommand, listRegisteredWorkspaces, registerWorkspace, runDailyMaintenance, } from './scheduler.js';
 import { importChatGPT, importClaude, importCursor, importGenericFile, importMarkdown, } from './importers.js';
 import { cmdCapture } from './capture.js';
-import { auditMemories, appendAuditEvent, queryAuditEvents, } from './audit.js';
-import { createApiKey, listApiKeys, revokeApiKey } from './auth.js';
+import { auditMemories, appendAuditEvent, } from './audit.js';
+import { listApiKeys, revokeApiKey } from './auth.js';
+import * as api from './api.js';
+import * as client from './client.js';
+import { detectServer, removePidfile } from './server-detect.js';
 import { resolveTenantId } from './tenant.js';
 import { runEval, bootstrapCorpus, compareSummaries } from './eval.js';
 import { runFeatureEval, formatResult, resultToBaseline, detectRegressions } from './eval-suite.js';
@@ -99,6 +102,35 @@ function requireInit(hippoRoot) {
         process.exit(1);
     }
 }
+/**
+ * Run an HTTP-routed command if a `hippo serve` instance is detected for
+ * `hippoRoot`. Returns:
+ *   - true  if the HTTP path ran (success OR a structured server error that
+ *           was already surfaced to stdout/stderr by `httpFn`),
+ *   - false if no server was detected, or if the detected pidfile turned out
+ *           to be stale (connection refused). On stale, the pidfile is removed
+ *           and the caller should fall back to the direct path.
+ *
+ * Per the A1 plan footgun #1: stale pidfiles must self-heal, not crash.
+ */
+async function runViaServerIfAvailable(hippoRoot, httpFn) {
+    const info = detectServer(hippoRoot);
+    if (!info)
+        return false;
+    const apiKey = process.env['HIPPO_API_KEY'];
+    try {
+        await httpFn(info, apiKey);
+        return true;
+    }
+    catch (err) {
+        if (client.isConnectionRefused(err)) {
+            console.error('hippo: stale server pidfile detected, falling back to direct mode');
+            removePidfile(hippoRoot);
+            return false;
+        }
+        throw err;
+    }
+}
 function parseArgs(argv) {
     const [, , command = '', ...rest] = argv;
     const args = [];
@@ -2159,12 +2191,17 @@ function cmdOutcome(hippoRoot, flags) {
 }
 function cmdForget(hippoRoot, id) {
     requireInit(hippoRoot);
-    const ok = deleteEntry(hippoRoot, id);
-    if (ok) {
+    const ctx = {
+        hippoRoot,
+        tenantId: resolveTenantId({}),
+        actor: 'cli',
+    };
+    try {
+        api.forget(ctx, id);
         updateStats(hippoRoot, { forgotten: 1 });
         console.log(`Forgot ${id}`);
     }
-    else {
+    catch {
         console.error(`Memory not found: ${id}`);
         process.exit(1);
     }
@@ -3238,14 +3275,14 @@ function cmdPromote(hippoRoot, id) {
         console.error('Usage: hippo promote <id>');
         process.exit(1);
     }
+    const ctx = {
+        hippoRoot,
+        tenantId: resolveTenantId({}),
+        actor: 'cli',
+    };
     try {
-        const globalEntry = promoteToGlobal(hippoRoot, id);
-        // Emit audit on the global store (where the promoted memory now lives).
-        // The writeEntry inside promoteToGlobal already fires a 'remember' on the
-        // global db; we add a separate 'promote' event so the audit trail keeps
-        // the user-facing intent distinct from the underlying upsert.
-        emitCliAudit(getGlobalRoot(), 'promote', globalEntry.id, { sourceId: id });
-        console.log(`Promoted ${id} to global store as ${globalEntry.id}`);
+        const result = api.promote(ctx, id);
+        console.log(`Promoted ${id} to global store as ${result.globalId}`);
         console.log(`   Global store: ${getGlobalRoot()}`);
     }
     catch (err) {
@@ -3813,21 +3850,18 @@ function cmdAuthCreate(hippoRoot, flags) {
     const root = resolveAuthRoot(hippoRoot, flags);
     const tenantFlag = typeof flags['tenant'] === 'string' ? flags['tenant'] : undefined;
     const labelFlag = typeof flags['label'] === 'string' ? flags['label'] : undefined;
-    const tenantId = tenantFlag ?? resolveTenantId({});
     const asJson = Boolean(flags['json']);
-    const db = openHippoDb(root);
-    let result;
-    try {
-        result = createApiKey(db, { tenantId, label: labelFlag });
-    }
-    finally {
-        closeHippoDb(db);
-    }
+    const ctx = {
+        hippoRoot: root,
+        tenantId: resolveTenantId({}),
+        actor: 'cli',
+    };
+    const result = api.authCreate(ctx, { tenantId: tenantFlag, label: labelFlag });
     if (asJson) {
         console.log(JSON.stringify({
             keyId: result.keyId,
             plaintext: result.plaintext,
-            tenantId,
+            tenantId: result.tenantId,
             label: labelFlag ?? null,
         }));
         return;
@@ -3969,14 +4003,8 @@ function cmdAuditList(hippoRoot, flags) {
         console.error(`--limit must be between 1 and 10000 (got ${limit}).`);
         process.exit(1);
     }
-    const db = openHippoDb(root);
-    let events;
-    try {
-        events = queryAuditEvents(db, { tenantId, op, since, limit });
-    }
-    finally {
-        closeHippoDb(db);
-    }
+    const ctx = { hippoRoot: root, tenantId, actor: 'cli' };
+    const events = api.auditList(ctx, { op, since, limit });
     if (asJson) {
         console.log(JSON.stringify(events));
         return;
@@ -4350,6 +4378,37 @@ async function main() {
                 console.error('Memory content too short (minimum 3 characters).');
                 process.exit(1);
             }
+            // Thin-client routing. When a server is up, simple `remember` calls go
+            // over HTTP so the daemon stays single-writer (footgun #2). Rich CLI
+            // flags (--pin, --layer, --extract, --global, salience gates) still
+            // need the direct path; we only intercept the minimal envelope.
+            const richFlag = flags['pin'] || flags['global'] || flags['extract'] || flags['force'] ||
+                flags['observed'] || flags['inferred'] || flags['verified'] ||
+                flags['layer'] !== undefined;
+            if (!richFlag) {
+                const rememberKindRaw = typeof flags['kind'] === 'string' ? flags['kind'].toLowerCase() : undefined;
+                const rememberKindAllowed = ['distilled', 'superseded'];
+                if (rememberKindRaw === undefined || rememberKindAllowed.includes(rememberKindRaw)) {
+                    const tagsRaw = flags['tag'];
+                    const tags = Array.isArray(tagsRaw)
+                        ? tagsRaw.map(String)
+                        : typeof tagsRaw === 'string' ? [tagsRaw] : undefined;
+                    const remembered = await runViaServerIfAvailable(hippoRoot, async (info, apiKey) => {
+                        const result = await client.remember(info.url, apiKey, {
+                            content: text,
+                            kind: rememberKindRaw,
+                            scope: typeof flags['scope'] === 'string' ? flags['scope'] : undefined,
+                            owner: typeof flags['owner'] === 'string' ? flags['owner'] : undefined,
+                            artifactRef: typeof flags['artifact-ref'] === 'string' ? flags['artifact-ref'] : undefined,
+                            tags,
+                        });
+                        console.log(`Remembered [${result.id}] (via ${info.url})`);
+                        console.log(`   Kind: ${result.kind} | Tenant: ${result.tenantId}`);
+                    });
+                    if (remembered)
+                        break;
+                }
+            }
             await cmdRemember(hippoRoot, text, flags);
             break;
         }
@@ -4499,6 +4558,18 @@ async function main() {
                 console.error('Please provide a memory ID.');
                 process.exit(1);
             }
+            const routed = await runViaServerIfAvailable(hippoRoot, async (info, apiKey) => {
+                try {
+                    await client.forget(info.url, apiKey, id);
+                    console.log(`Forgot ${id}`);
+                }
+                catch (err) {
+                    console.error(err.message);
+                    process.exit(1);
+                }
+            });
+            if (routed)
+                break;
             cmdForget(hippoRoot, id);
             break;
         }
@@ -4540,6 +4611,18 @@ async function main() {
                 console.error('Please provide a memory ID.');
                 process.exit(1);
             }
+            const promoted = await runViaServerIfAvailable(hippoRoot, async (info, apiKey) => {
+                try {
+                    const result = await client.promote(info.url, apiKey, id);
+                    console.log(`Promoted ${id} to global store as ${result.globalId}`);
+                }
+                catch (err) {
+                    console.error(`Failed to promote: ${err.message}`);
+                    process.exit(1);
+                }
+            });
+            if (promoted)
+                break;
             cmdPromote(hippoRoot, id);
             break;
         }
@@ -4689,12 +4772,35 @@ async function main() {
         case 'wm':
             cmdWm(hippoRoot, args, flags);
             break;
-        case 'mcp':
-            // Start MCP server over stdio - dynamically import to keep main CLI lean
-            await import('./mcp/server.js');
+        case 'mcp': {
+            // Start MCP server over stdio. Dynamic import keeps main CLI lean; the
+            // dispatcher itself is transport-agnostic, so we explicitly attach the
+            // stdio loop here. (HTTP/SSE transport is wired in src/server.ts and
+            // imports the same module without triggering stdin handlers.)
+            const mod = await import('./mcp/server.js');
+            mod.startStdioLoop();
             // Server runs until stdin closes, so we never reach here
             await new Promise(() => { }); // hang forever
             break;
+        }
+        case 'serve': {
+            requireInit(hippoRoot);
+            const portRaw = flags['port'] ?? process.env['HIPPO_PORT'] ?? '6789';
+            const port = Number(portRaw);
+            if (!Number.isFinite(port) || port < 0) {
+                console.error(`Invalid --port: ${String(portRaw)}`);
+                process.exit(1);
+            }
+            const host = typeof flags['host'] === 'string' ? flags['host'] : '127.0.0.1';
+            const { serve } = await import('./server.js');
+            const handle = await serve({ hippoRoot, port, host });
+            console.log(`hippo serve listening on ${handle.url} (pid ${process.pid})`);
+            console.log(`pidfile: ${path.join(hippoRoot, 'server.pid')}`);
+            console.log('press Ctrl+C to stop');
+            // SIGINT/SIGTERM handlers wired in server.ts (skipped under VITEST). Hang.
+            await new Promise(() => { });
+            break;
+        }
         case 'invalidate': {
             requireInit(hippoRoot);
             const target = args[0];