@jeffober/thatch 0.1.48 → 0.2.1

package/src/tools.ts

@@ -1,48 +1,29 @@
 import { tool } from "@opencode-ai/plugin";
-import type { ThatchDB } from "./db";
-import type { EmbeddingModel } from "./embeddings";
-import { TOOL_DEFS, type CoreContext, type HostToolContext } from "./tool-defs";
-import type { WatcherRegistry } from "./watchers";
+import { TOOL_DEFS, trimHostContext, type CoreContext } from "./tool-defs";
+
+// V1-ONLY module: this file imports the opencode v1 SDK at runtime, so
+// nothing shared may import from it. The host-agnostic pieces
+// (buildCoreContext, trimHostContext, CoreContext, TOOL_DEFS) live in
+// tool-defs.ts precisely so the v2 adapter and the MCP server can use them
+// without evaluating the v1 SDK - the v2 plugin install skips optional
+// peers, and a missing SDK import here would kill the whole plugin load.
 
 /**
- * Builds the opencode tool map from shared tool definitions. Each definition
- * in TOOL_DEFS is wrapped in opencode's `tool()` with a `thatch_` prefix
- * on the name - opencode uses the object key as the tool name, so the prefix
- * lives here, not in the shared definitions.
+ * Builds the v1 opencode tool map from shared tool definitions. Each
+ * definition in TOOL_DEFS is wrapped in opencode's `tool()` with a
+ * `thatch_` prefix on the name - opencode uses the object key as the tool
+ * name, so the prefix lives here, not in the shared definitions. Takes the
+ * shared CoreContext (buildCoreContext) rather than raw deps, so both host
+ * adapters feed the same context construction.
  */
-export function createTools(
-  db: ThatchDB,
-  model: EmbeddingModel,
-  defaultStore: string,
-  extensions?: {
-    extractionPayloadProvider?: CoreContext["extractionPayloadProvider"];
-    drainExtractionQueue?: CoreContext["drainExtractionQueue"];
-    watcherRegistry?: WatcherRegistry;
-    projectDir?: string;
-  },
-): Record<string, ReturnType<typeof tool>> {
-  const ctx: CoreContext = {
-    db,
-    model,
-    defaultStore,
-    extractionPayloadProvider: extensions?.extractionPayloadProvider,
-    drainExtractionQueue: extensions?.drainExtractionQueue,
-    watchers: extensions?.watcherRegistry,
-    projectDir: extensions?.projectDir,
-  };
-
+export function createTools(coreContext: CoreContext): Record<string, ReturnType<typeof tool>> {
   const tools: Record<string, ReturnType<typeof tool>> = {};
   for (const def of TOOL_DEFS) {
     tools[`thatch_${def.name}`] = tool({
       description: def.description,
       args: def.args,
       async execute(args, hostContext) {
-        // Trim opencode's ToolContext to the host-agnostic fields the shared
-        // definitions know about. Tests and MCP paths pass no host context.
-        const host: HostToolContext | undefined = hostContext
-          ? { sessionID: hostContext.sessionID, agent: hostContext.agent }
-          : undefined;
-        return def.execute(args as Record<string, unknown>, ctx, host);
+        return def.execute(args as Record<string, unknown>, coreContext, trimHostContext(hostContext));
       },
     });
   }

package/src/watchers.ts

@@ -16,16 +16,14 @@
  * never its output (injection hygiene: command output can be external
  * content, so it never rides a notification).
  *
- * Lifetime is deliberately process-scoped. The registry lives in plugin
- * memory, never in SQLite: opencode loads thatch in-process, so the plugin
- * process is the natural owner of its watchers. This makes multi-instance
- * ownership structurally impossible (each process polls only what it
- * registered), leaves no orphan data behind, and matches the extraction
- * pipeline's opencode path, which is also in-memory. A crashed or restarted
- * opencode loses its watchers - acceptable, because the session that created
- * them lost its conversational context too, and a delivered notification
- * into a session that no longer knows why it is being watched is worse than
- * a lost watch.
+ * Lifetime is deliberately process-scoped for the LIVE registry: the
+ * poller and delivery state live in plugin memory, never in SQLite -
+ * opencode loads thatch in-process, so the plugin process is the natural
+ * owner of its watchers, and no cross-process "who polls this?" claim
+ * logic is needed. The DEFINITIONS, however, are journaled to
+ * runtime_state (the optional journal hook) so they survive v2 plugin
+ * reloads and, as dormant rows, full restarts - see the rearm() and the
+ * runtime's dormant-watcher scan.
  */
 
 // ---------------------------------------------------------------------------
@@ -280,6 +278,8 @@ export interface WatcherRegistryOptions {
   pollIntervalMs?: number;
   ttlMinutes?: number;
   maxPerSession?: number;
+  /** Persistence hook: called after membership changes with the session's watcher list. */
+  journal?: (sessionID: string, watchers: Watcher[]) => void;
 }
 
 // ---------------------------------------------------------------------------
@@ -391,6 +391,17 @@ export async function ghApiRunWithTimeout(apiArgs: string[], timeoutMs: number):
   }
 }
 
+/**
+ * The stable target label a watcher reports in events, lists, and recovery
+ * notices: "owner/repo#N" for PRs, "owner/repo@branch" for branches, and a
+ * one-line clip of the command for command watches.
+ */
+export function watcherTarget(watcher: Watcher): string {
+  if (watcher.source === "pr") return `${watcher.repo}#${watcher.pr}`;
+  if (watcher.source === "branch") return `${watcher.repo}@${watcher.branch}`;
+  return commandTargetLabel(watcher.command);
+}
+
 let ghAvailability: boolean | null = null;
 
 /**
@@ -829,6 +840,13 @@ export class WatcherRegistry {
   #timer: ReturnType<typeof setInterval> | null = null;
   #delivering = false;
   #polling = false;
+  /**
+   * Persistence hook (optional): called after every membership change with
+   * the session's current watcher list, so the runtime can journal the
+   * definitions and re-arm them after a v2 plugin reload. Passing no hook
+   * (tests, MCP) keeps the registry in-memory only.
+   */
+  #journal?: (sessionID: string, watchers: Watcher[]) => void;
   readonly #opts: WatcherRegistryOptions & {
     pollIntervalMs: number;
     ttlMinutes: number;
@@ -836,6 +854,18 @@ export class WatcherRegistry {
     commandRunner: CommandRunner;
     commandTimeoutMs: number;
   };
+  /**
+   * The most recently constructed instance in this process. opencode v2
+   * re-runs plugin setup() when the session's directory changes
+   * (session_move between directories of the same repo) or on plugin-file
+   * changes; each setup() built a fresh registry while the OLD instance's
+   * poller timer kept running - the watch tools then queried an empty
+   * registry ("No active watchers" / "No watcher in this session") while
+   * delivery kept flowing from the orphaned poller. The handoff stops the
+   * predecessor's poller at construction so at most one registry polls per
+   * process; the watch tools' journal reconcile covers the state transfer.
+   */
+  static #live: WatcherRegistry | undefined;
 
   constructor(options: WatcherRegistryOptions) {
     this.#opts = {
@@ -846,6 +876,9 @@ export class WatcherRegistry {
       commandTimeoutMs: defaultCommandTimeoutMs(),
       ...options,
     };
+    this.#journal = options.journal;
+    WatcherRegistry.#live?.stop();
+    WatcherRegistry.#live = this;
   }
 
   // -- Lifecycle -----------------------------------------------------------
@@ -889,6 +922,59 @@ export class WatcherRegistry {
 
   // -- CRUD ----------------------------------------------------------------
 
+  /** Journal the session's current watcher list (no-op without a hook). */
+  #emit(sessionID: string): void {
+    this.#journal?.(sessionID, this.listForSession(sessionID));
+  }
+
+  /** Restore persisted watchers (same-process reload rehydration). */
+  hydrate(watchers: Watcher[]): void {
+    for (const w of watchers) {
+      // Do not clobber a watcher created after the journal was written.
+      if (!this.#watchers.has(w.id)) this.#watchers.set(w.id, w);
+    }
+  }
+
+  /**
+   * Re-arms persisted watcher definitions recovered on session resume after
+   * a restart (the dormant journal rows the runtime keeps instead of
+   * pruning). Definitions whose TTL expired while the session was away are
+   * dropped - a watch that outlived its own expiry must not fire on a stale
+   * baseline. PR and branch definitions are REVALIDATED by re-fetching
+   * their baseline: a deleted branch or closed PR would otherwise re-arm
+   * into silent poll failure, and a stale baseline would flood the session
+   * with every event that happened while it was away; fetch failures drop
+   * the definition and count as failed. The rest join the live registry
+   * newest-first up to the per-session limit (the session may have created
+   * watchers since the restart), and the journal is rewritten either way:
+   * with the current process's pid when anything re-arms, deleted when
+   * nothing does.
+   */
+  async rearm(sessionID: string, defs: Watcher[]): Promise<{ rearmed: Watcher[]; expired: number; failed: number }> {
+    const now = Date.now();
+    const fresh = defs.filter((w) => now <= w.expiresAt).sort((a, b) => b.createdAt - a.createdAt);
+    const budget = Math.max(0, this.#opts.maxPerSession - this.listForSession(sessionID).length);
+    const rearmed: Watcher[] = [];
+    let failed = 0;
+    for (const def of fresh.slice(0, budget)) {
+      if (def.source !== "command") {
+        try {
+          def.state = def.source === "pr"
+            ? await fetchPrState(this.#opts.ghRunner, def.repo, def.pr)
+            : await fetchBranchState(this.#opts.ghRunner, def.repo, def.branch);
+        } catch {
+          failed++;
+          continue;
+        }
+      }
+      // Do not clobber a watcher created after the journal was written.
+      if (!this.#watchers.has(def.id)) this.#watchers.set(def.id, def);
+      rearmed.push(def);
+    }
+    this.#emit(sessionID);
+    return { rearmed, expired: defs.length - fresh.length, failed };
+  }
+
   /**
    * Registers a PR watcher and captures the baseline state immediately. The
    * baseline fetch doubles as validation: a bad repo, missing PR, or broken
@@ -929,6 +1015,7 @@ export class WatcherRegistry {
       state,
     };
     this.#watchers.set(watcher.id, watcher);
+    this.#emit(sessionID);
     return { ok: true, watcher };
   }
 
@@ -973,6 +1060,7 @@ export class WatcherRegistry {
       state,
     };
     this.#watchers.set(watcher.id, watcher);
+    this.#emit(sessionID);
     return { ok: true, watcher };
   }
 
@@ -1028,6 +1116,7 @@ export class WatcherRegistry {
       state: { lastExit: baseline.timedOut ? 124 : baseline.exitCode },
     };
     this.#watchers.set(watcher.id, watcher);
+    this.#emit(sessionID);
     return { ok: true, watcher };
   }
 
@@ -1051,6 +1140,7 @@ export class WatcherRegistry {
     const watcher = this.#watchers.get(id);
     if (!watcher || watcher.sessionID !== sessionID) return false;
     this.#watchers.delete(id);
+    this.#emit(sessionID);
     return true;
   }
 
@@ -1060,6 +1150,7 @@ export class WatcherRegistry {
       if (w.sessionID === sessionID) this.#watchers.delete(id);
     }
     this.#pending.delete(sessionID);
+    this.#emit(sessionID);
   }
 
   // -- Polling and delivery ------------------------------------------------
@@ -1079,6 +1170,7 @@ export class WatcherRegistry {
       for (const [id, watcher] of this.#watchers) {
         if (now > watcher.expiresAt) {
           this.#watchers.delete(id);
+          this.#emit(watcher.sessionID);
           continue;
         }
         try {
@@ -1092,7 +1184,10 @@ export class WatcherRegistry {
             // if the session is busy. Cancellation at detection time keeps
             // "wait for this run to finish" from leaving a standing watch
             // polling a target nobody is waiting on anymore.
-            if (watcher.once) this.#watchers.delete(id);
+            if (watcher.once) {
+              this.#watchers.delete(id);
+              this.#emit(watcher.sessionID);
+            }
           }
         } catch (err) {
           console.error(`[thatch] watcher ${id} poll failed: ${err}`);
@@ -1108,7 +1203,7 @@ export class WatcherRegistry {
   async #pollOne(watcher: Watcher): Promise<WatcherEvent[]> {
     if (watcher.source === "pr") {
       const after = await fetchPrState(this.#opts.ghRunner, watcher.repo, watcher.pr);
-      const events = diffPrState(watcher.state, after, `${watcher.repo}#${watcher.pr}`, this.#prUrl(watcher))
+      const events = diffPrState(watcher.state, after, watcherTarget(watcher), this.#prUrl(watcher))
         .filter((e) => watcher.events.includes(e.type as PrWatcherEventType));
       watcher.state = after;
       return events;
@@ -1124,13 +1219,13 @@ export class WatcherRegistry {
       if (result.timedOut || result.exitCode !== 0) return [];
       return [{
         type: "command_success",
-        target: commandTargetLabel(watcher.command),
+        target: watcherTarget(watcher),
         summary: `command exited 0 (took ${(result.durationMs / 1000).toFixed(1)}s)`,
         url: "",
       }];
     }
     const after = await fetchBranchState(this.#opts.ghRunner, watcher.repo, watcher.branch);
-    const all = diffBranchState(watcher.state, after, `${watcher.repo}@${watcher.branch}`, watcher.repo);
+    const all = diffBranchState(watcher.state, after, watcherTarget(watcher), watcher.repo);
     watcher.state = after;
     // The workflow-name filter narrows branch_workflow events only -
     // commits and check runs pass through unfiltered, or a watch filtered