@gonrocca/zero-pi 0.1.13 → 0.1.15

package/extensions/opencode-models.ts

@@ -0,0 +1,111 @@
+// zero-pi — OpenCode model-catalog discovery.
+//
+// Surfaces the model providers a user can run by cross-referencing OpenCode's
+// model catalog cache with the user's OpenCode auth file. This is the same
+// approach the `zero` installer's model picker uses, so `/zero-models` offers
+// the same providers — opencode-go, openai (codex/gpt), anthropic, … — as the
+// installer, instead of a hardcoded Claude list.
+//
+// Sources, under the user's home (ZERO_HOME-overridable for tests):
+//   ~/.cache/opencode/models.json       — the full provider/model catalog
+//   ~/.local/share/opencode/auth.json   — the providers the user authenticated
+//
+// Discovery is total: a missing or corrupt file yields an empty list, so a
+// user without OpenCode simply falls back to pi's own model registry.
+
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+/** A model discovered from OpenCode's catalog. */
+export interface DiscoveredModel {
+  /** The provider id, e.g. `opencode-go`, `openai`, `anthropic`. */
+  provider: string;
+  /** The model id, e.g. `gpt-5-codex`. */
+  id: string;
+  /** The human-readable model name. */
+  name: string;
+  /** Whether the model supports tool calls — required for the SDD phases. */
+  toolCall: boolean;
+  /** Whether the model exposes a reasoning-effort setting. */
+  reasoning: boolean;
+}
+
+/** The home directory discovery resolves OpenCode paths against. */
+function discoveryHome(): string {
+  const override = process.env.ZERO_HOME;
+  return typeof override === "string" && override.trim() !== "" ? override : homedir();
+}
+
+/** True for a plain (non-array) object. */
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/** Read and parse a JSON file; returns null on any failure. */
+function readJson(path: string): unknown {
+  try {
+    return JSON.parse(readFileSync(path, "utf8")) as unknown;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Extract a provider's models from its OpenCode catalog entry.
+ *
+ * Exported for tests.
+ */
+export function extractModels(
+  providerId: string,
+  entry: Record<string, unknown>,
+): DiscoveredModel[] {
+  const raw = entry.models;
+  if (!isObject(raw)) return [];
+
+  const models: DiscoveredModel[] = [];
+  for (const [id, model] of Object.entries(raw)) {
+    if (!isObject(model)) continue;
+    models.push({
+      provider: providerId,
+      id,
+      name: typeof model.name === "string" ? model.name : id,
+      toolCall: model.tool_call === true,
+      reasoning: model.reasoning === true,
+    });
+  }
+  return models;
+}
+
+/**
+ * Discover every model the user can run, flattened across all OpenCode-
+ * authenticated providers.
+ *
+ * `catalogJson` and `authJson` are injectable for tests; in normal use they
+ * are read from OpenCode's cache and auth files on disk. The result is empty
+ * when either source is absent or malformed.
+ */
+export function discoverModels(
+  catalogJson?: unknown,
+  authJson?: unknown,
+): DiscoveredModel[] {
+  // Only touch disk when an argument is genuinely absent — an explicit value
+  // (including `null`) is used as given, so tests never read real files.
+  const auth =
+    authJson === undefined
+      ? readJson(join(discoveryHome(), ".local", "share", "opencode", "auth.json"))
+      : authJson;
+  const catalog =
+    catalogJson === undefined
+      ? readJson(join(discoveryHome(), ".cache", "opencode", "models.json"))
+      : catalogJson;
+  if (!isObject(auth) || !isObject(catalog)) return [];
+
+  const models: DiscoveredModel[] = [];
+  for (const providerId of Object.keys(auth)) {
+    const entry = catalog[providerId];
+    if (!isObject(entry)) continue;
+    models.push(...extractModels(providerId, entry));
+  }
+  return models;
+}

package/extensions/win-tree-kill.ts

@@ -0,0 +1,114 @@
+// zero-pi — Windows process-tree kill for aborts.
+//
+// On Windows, `ChildProcess.kill()` terminates only the target process, not
+// its descendants. A provider like pi-claude-cli spawns `claude` through a
+// `cmd.exe` batch wrapper (`claude` resolves to `claude.cmd`), so when pi
+// aborts a turn the wrapper is killed but the real `claude` process is
+// orphaned and keeps streaming — pressing Esc appears to do nothing.
+//
+// This extension patches `child_process.spawn` once, at load, so every
+// subprocess spawned afterwards gets a `kill()` that terminates the whole
+// process tree via `taskkill /T /F`. It is a no-op on non-Windows platforms.
+//
+// Patching the shared `child_process` module reaches code in other packages
+// (pi-claude-cli, and the `cross-spawn` it depends on, both call into the same
+// builtin) without modifying them — so the fix survives `pi update`.
+
+import { createRequire } from "node:module";
+
+/** Build the Windows command that kills a process and its whole tree. */
+export function treeKillCommand(pid: number): string {
+  return `taskkill /pid ${pid} /t /f`;
+}
+
+/** The slice of a child process this extension touches. */
+export interface KillableChild {
+  pid?: number;
+  kill(signal?: NodeJS.Signals | number): boolean;
+}
+
+/** Marker so a `kill` is wrapped at most once. */
+const WRAPPED = Symbol.for("zero-pi.win-tree-kill.wrapped");
+
+/**
+ * Replace `child.kill` with one that terminates the whole process tree by
+ * running `exec(treeKillCommand(pid))`. Falls back to the original `kill` when
+ * there is no pid or the tree-kill throws. Idempotent — wrapping an already
+ * wrapped child is a no-op. Exported for tests.
+ */
+export function wrapKill(
+  child: KillableChild,
+  exec: (command: string) => void,
+): KillableChild {
+  const original = child.kill;
+  if (typeof original !== "function") return child;
+
+  const tagged = original as typeof original & { [WRAPPED]?: boolean };
+  if (tagged[WRAPPED]) return child;
+
+  const wrapped = function (signal?: NodeJS.Signals | number): boolean {
+    const pid = child.pid;
+    if (typeof pid === "number") {
+      try {
+        exec(treeKillCommand(pid));
+        return true;
+      } catch {
+        // Process already gone, or taskkill unavailable — fall through.
+      }
+    }
+    return original.call(child, signal);
+  } as KillableChild["kill"] & { [WRAPPED]?: boolean };
+  wrapped[WRAPPED] = true;
+
+  child.kill = wrapped;
+  return child;
+}
+
+/** Whether the running platform needs the tree-kill patch. */
+export function shouldPatch(platform: string): boolean {
+  return platform === "win32";
+}
+
+/** Module-level guard so the global patch is installed at most once. */
+let patched = false;
+
+/**
+ * The pi extension entry point. Patches `child_process.spawn` so every later
+ * subprocess tree-kills on `kill()`. Defensive: a failure here must never
+ * break a pi session, so it is swallowed.
+ */
+export default function register(): void {
+  if (patched || !shouldPatch(process.platform)) return;
+  try {
+    const require = createRequire(import.meta.url);
+    const cp = require("node:child_process") as {
+      spawn: (...args: unknown[]) => KillableChild;
+      execSync: (command: string, options?: unknown) => unknown;
+    };
+
+    const originalSpawn = cp.spawn as typeof cp.spawn & { [WRAPPED]?: boolean };
+    if (originalSpawn[WRAPPED]) {
+      patched = true;
+      return;
+    }
+
+    const exec = (command: string): void => {
+      cp.execSync(command, { stdio: "ignore" });
+    };
+
+    const patchedSpawn = function (this: unknown, ...args: unknown[]): KillableChild {
+      const child = originalSpawn.apply(this, args);
+      try {
+        return wrapKill(child, exec);
+      } catch {
+        return child;
+      }
+    } as typeof cp.spawn & { [WRAPPED]?: boolean };
+    patchedSpawn[WRAPPED] = true;
+
+    cp.spawn = patchedSpawn;
+    patched = true;
+  } catch {
+    // Hardening must never break a session.
+  }
+}

package/extensions/zero-models.ts

@@ -21,6 +21,7 @@ import { join } from "node:path";
 
 import { readAutotuneMode, type AutotuneMode } from "./autotune.ts";
 import type { AutotunePending } from "./autotune-extension.ts";
+import { discoverModels } from "./opencode-models.ts";
 
 /** The SDD phases, in pipeline order. */
 export const PHASES = ["explore", "plan", "build", "veredicto"] as const;
@@ -211,34 +212,56 @@ const CUSTOM_MODEL = "— otro modelo (escribir) —";
 const CUSTOM_PROVIDER = "— otro provider (escribir) —";
 
 /**
- * Group the registry's models by provider. Prefers `getAvailable()` (providers
- * with configured auth — what the user actually has) and falls back to the
- * full `getAll()` set, then to an empty map when no registry is present.
+ * Group models by provider for the picker.
+ *
+ * The primary source is OpenCode's model catalog — the same one the `zero`
+ * installer's picker uses — so every provider the user authenticated there
+ * (opencode-go, openai/codex, anthropic, …) is offered, with only tool-call-
+ * capable models (the SDD phases need tool calls). When OpenCode is not
+ * present it falls back to pi's own model registry, then to an empty map.
  */
 function providerGroups(registry: PiModelRegistry | undefined): Map<string, string[]> {
-  if (!registry || typeof registry.getAll !== "function") return new Map();
   try {
-    const available = typeof registry.getAvailable === "function" ? registry.getAvailable() : [];
-    const source = available && available.length > 0 ? available : registry.getAll();
-    return groupByProvider(source ?? []);
+    const discovered = discoverModels().filter((m) => m.toolCall);
+    if (discovered.length > 0) return groupByProvider(discovered);
   } catch {
-    return new Map();
+    /* fall through to pi's registry */
+  }
+  if (registry && typeof registry.getAll === "function") {
+    try {
+      const all = registry.getAll();
+      if (all && all.length > 0) return groupByProvider(all);
+    } catch {
+      /* fall through */
+    }
   }
+  return new Map();
 }
 
-/** Find the provider that owns a model id, if the registry knows it. */
+/**
+ * Find the provider that owns a model id — checked against OpenCode's catalog
+ * first, then pi's own registry.
+ */
 function resolveProvider(
   registry: PiModelRegistry | undefined,
   modelId: string,
 ): string | undefined {
-  if (!registry || typeof registry.getAll !== "function") return undefined;
   try {
-    for (const m of registry.getAll()) {
-      if (m && m.id === modelId && typeof m.provider === "string") return m.provider;
+    for (const m of discoverModels()) {
+      if (m.id === modelId) return m.provider;
     }
   } catch {
     /* ignore */
   }
+  if (registry && typeof registry.getAll === "function") {
+    try {
+      for (const m of registry.getAll()) {
+        if (m && m.id === modelId && typeof m.provider === "string") return m.provider;
+      }
+    } catch {
+      /* ignore */
+    }
+  }
   return undefined;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gonrocca/zero-pi",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "zero-pi — an installable layer for pi (pi.dev): the zero spec-driven development workflow, skill auto-learning, and an animated ZERO startup banner. Adds capability to pi without modifying pi.",
   "type": "module",
   "keywords": [
@@ -25,6 +25,7 @@
     "extensions": [
       "./extensions/startup-banner.ts",
       "./extensions/working-phrases.ts",
+      "./extensions/win-tree-kill.ts",
       "./extensions/conversation-resume.ts",
       "./extensions/zero-models.ts",
       "./extensions/autotune-extension.ts",
@@ -38,8 +39,10 @@
     "themes",
     "extensions/startup-banner.ts",
     "extensions/working-phrases.ts",
+    "extensions/win-tree-kill.ts",
     "extensions/conversation-resume.ts",
     "extensions/zero-models.ts",
+    "extensions/opencode-models.ts",
     "extensions/autotune.ts",
     "extensions/autotune-extension.ts",
     "extensions/spec-merge.ts",