@gonrocca/zero-pi 0.1.14 → 0.1.16

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

@@ -83,7 +83,7 @@ export default function register(): void {
     const require = createRequire(import.meta.url);
     const cp = require("node:child_process") as {
       spawn: (...args: unknown[]) => KillableChild;
-      execSync: (command: string, options?: unknown) => unknown;
+      exec: (command: string, callback: (error: unknown) => void) => unknown;
     };
 
     const originalSpawn = cp.spawn as typeof cp.spawn & { [WRAPPED]?: boolean };
@@ -92,8 +92,12 @@ export default function register(): void {
       return;
     }
 
+    // Fire-and-forget, ASYNC. A blocking execSync here would freeze pi's whole
+    // event loop on every subprocess kill — and pi kills a subprocess on most
+    // turns (pi-claude-cli's break-early). taskkill can take seconds or hang,
+    // so it must never run on the event loop.
     const exec = (command: string): void => {
-      cp.execSync(command, { stdio: "ignore" });
+      cp.exec(command, () => {});
     };
 
     const patchedSpawn = function (this: unknown, ...args: unknown[]): KillableChild {

package/extensions/working-phrases.ts

@@ -169,8 +169,13 @@ export function spinnerFrames(theme: Theme): string[] {
 
 // ── Extension entry point ──────────────────────────────────────────────────
 
+/** Module guard so a double-load never stacks handlers or a second timer. */
+let registered = false;
+
 export default function register(pi?: PiAPI): void {
   if (!pi || typeof pi.on !== "function") return;
+  if (registered) return;
+  registered = true;
 
   // The last UI handle seen on any event — the rotation timer uses it.
   let ui: PiUI | undefined;

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.14",
+  "version": "0.1.16",
   "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": [
@@ -42,6 +42,7 @@
     "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",