becki-mcp 1.1.0

package/dist/core/runner.js

@@ -0,0 +1,109 @@
+// runner.ts — Becki Core daemon orchestration (#191 sub-tasks 3-4 glue)
+//
+// When becki-mcp runs as the stdio MCP server (the normal Claude Code /
+// Cursor invocation), it can ALSO start background work:
+//   1. Project activity watchers (chokidar per registered project)
+//   2. A daily AI session digest sweep (runs once at startup if it's been
+//      >20h, then every 12h thereafter)
+//
+// Wired here rather than in index.ts so the existing 4K-line MCP file
+// stays focused on tool dispatch; this module owns the "Core daemon"
+// concerns.
+//
+// Extractor + ingester are injected — runner.ts doesn't know whether
+// extraction goes to Anthropic directly or proxies through the Becki
+// backend. index.ts wires the actual transport at startup time.
+import { BeckiCache } from "./db.js";
+import { ProjectActivityWatcher } from "./project-activity.js";
+import { runDigest } from "./ai-sessions.js";
+const DIGEST_INTERVAL_MS = 12 * 60 * 60 * 1000; // 12h
+const DIGEST_STARTUP_GRACE_MS = 20 * 60 * 60 * 1000; // run at boot if last digest >20h ago
+const CONFIG_LAST_DIGEST = "core.lastDigestAt";
+export class CoreRunner {
+    opts;
+    cache;
+    watcher = null;
+    digestTimer = null;
+    log;
+    running = false;
+    constructor(opts) {
+        this.opts = opts;
+        this.cache = new BeckiCache(opts.beckiHome);
+        this.log = opts.logger ?? (() => { });
+    }
+    /** Start watchers + schedule digests. Idempotent. */
+    async start() {
+        if (this.running)
+            return;
+        this.running = true;
+        this.watcher = new ProjectActivityWatcher({
+            cache: this.cache,
+            ingest: this.opts.ingest,
+            logger: this.log,
+        });
+        await this.watcher.startAll();
+        const lastDigestStr = this.cache.getConfig(CONFIG_LAST_DIGEST);
+        const lastDigest = lastDigestStr ? Number(lastDigestStr) : 0;
+        const sinceLast = Date.now() - lastDigest;
+        if (sinceLast > DIGEST_STARTUP_GRACE_MS) {
+            this.log(`core-runner: last digest ${Math.round(sinceLast / 3.6e6)}h ago; running on startup`);
+            // Don't block daemon startup on the digest — kick it off async.
+            void this.runOneDigest("daily");
+        }
+        this.digestTimer = setInterval(() => {
+            void this.runOneDigest("interval");
+        }, DIGEST_INTERVAL_MS);
+        // unref so the daemon can exit cleanly when the MCP stdio closes.
+        this.digestTimer.unref?.();
+    }
+    /** Manually trigger a digest (used by `becki-mcp digest` CLI). */
+    async runOneDigest(reason) {
+        this.log(`core-runner: starting digest (${reason})`);
+        try {
+            const result = await runDigest({
+                cache: this.cache,
+                extract: this.opts.extract,
+                ingest: this.opts.ingest,
+                logger: this.log,
+            });
+            this.cache.setConfig(CONFIG_LAST_DIGEST, String(Date.now()));
+            this.log(`core-runner: digest done — processed=${result.processed} ingested=${result.ingested} ` +
+                `errors=${result.errors} skipped=${result.skippedSettled + result.skippedNoGrowth + result.skippedTooSmall + result.skippedTokenCap}`);
+        }
+        catch (err) {
+            this.log(`core-runner: digest failed: ${err.message}`);
+        }
+    }
+    /** Manually trigger a historical bootstrap (used by `becki-mcp bootstrap` CLI). */
+    async runBootstrap(ageWindowDays = 90) {
+        this.log(`core-runner: starting historical bootstrap (${ageWindowDays}d)`);
+        try {
+            const result = await runDigest({
+                cache: this.cache,
+                extract: this.opts.extract,
+                ingest: this.opts.ingest,
+                isBootstrap: true,
+                ageWindowDays,
+                logger: this.log,
+            });
+            this.log(`core-runner: bootstrap done — processed=${result.processed} ingested=${result.ingested} errors=${result.errors}`);
+        }
+        catch (err) {
+            this.log(`core-runner: bootstrap failed: ${err.message}`);
+        }
+    }
+    async stop() {
+        if (!this.running)
+            return;
+        this.running = false;
+        if (this.digestTimer) {
+            clearInterval(this.digestTimer);
+            this.digestTimer = null;
+        }
+        if (this.watcher) {
+            await this.watcher.stopAll();
+            this.watcher = null;
+        }
+        this.cache.close();
+    }
+}