@gonrocca/zero-pi 0.1.3 → 0.1.4

package/README.md

@@ -46,9 +46,19 @@ Run it with the `/forge <feature>` prompt. The orchestrator drives phase order
 and enforces a hard build/veredicto iteration cap. Each phase has its own prompt
 under `prompts/phases/` so it can be delegated to a dedicated sub-agent.
 
-`/forge models` (no feature request) opens an in-session editor for the
-per-phase models — it reads `~/.pi/zero.json`, lets you reassign any phase, and
-writes the choice back.
+### Per-phase models (`/zero-models`)
+
+`/zero-models` is a real pi command — a code handler, not an LLM prompt — for
+the SDD models. Run it with no argument to pick a phase and a model
+interactively, or set one directly:
+
+```
+/zero-models                        # interactive picker
+/zero-models build=claude-opus-4-7  # set one phase
+```
+
+It reads and writes `~/.pi/zero.json`; the orchestrator picks the change up on
+the next `/forge` run.
 
 Per-phase model assignments are read from `~/.pi/zero.json`, which the `zero`
 CLI writes when it installs this layer.

package/extensions/zero-models.ts

@@ -0,0 +1,189 @@
+// zero-pi — the /zero-models command.
+//
+// A real pi command — a code handler, not an LLM prompt — for reading and
+// changing the per-phase SDD models in `~/.pi/zero.json`. It is deterministic:
+// no model is involved, so it does exactly what you pick, every time.
+//
+//   /zero-models                        interactive — pick a phase, pick a model
+//   /zero-models build=claude-opus-4-7   set one phase directly
+//
+// The SDD orchestrator reads `~/.pi/zero.json` at the start of every `/forge`
+// run, so a change takes effect on the next run.
+
+import { readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+/** The SDD phases, in pipeline order. */
+export const PHASES = ["explore", "plan", "build", "veredicto"] as const;
+export type Phase = (typeof PHASES)[number];
+
+/** The per-phase model map. */
+export type PhaseModels = Record<Phase, string>;
+
+/** Fallback models when `~/.pi/zero.json` has none — cheap to explore, strong
+ *  to plan and review. */
+const DEFAULT_MODELS: PhaseModels = {
+  explore: "claude-haiku-4-5",
+  plan: "claude-opus-4-7",
+  build: "claude-sonnet-4-6",
+  veredicto: "claude-opus-4-7",
+};
+
+/** Models offered in the interactive picker — the Claude lineup pi-claude-cli
+ *  exposes. Any other model can still be typed via the custom option. */
+const MODEL_CHOICES = [
+  "claude-opus-4-7",
+  "claude-opus-4-6",
+  "claude-sonnet-4-6",
+  "claude-haiku-4-5",
+];
+
+/** Absolute path of pi's `zero.json` marker. */
+function zeroJsonPath(): string {
+  return join(homedir(), ".pi", "zero.json");
+}
+
+/** Whether a string names an SDD phase. */
+export function isPhase(value: string): value is Phase {
+  return (PHASES as readonly string[]).includes(value);
+}
+
+/** Read `~/.pi/zero.json`, returning an empty object when absent or invalid. */
+function readZeroJson(): Record<string, unknown> {
+  try {
+    return JSON.parse(readFileSync(zeroJsonPath(), "utf8")) as Record<string, unknown>;
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Extract the per-phase models from a zero.json object, filling any gap with
+ * the default so the picker always has a value to show.
+ */
+export function readModels(data: Record<string, unknown>): PhaseModels {
+  const raw = (data.models ?? {}) as Record<string, unknown>;
+  const models: PhaseModels = { ...DEFAULT_MODELS };
+  for (const phase of PHASES) {
+    if (typeof raw[phase] === "string") models[phase] = raw[phase] as string;
+  }
+  return models;
+}
+
+/** Parse a `<phase>=<model>` (or `<phase> <model>`) assignment. */
+export function parseAssignment(arg: string): { phase: Phase; model: string } | null {
+  const match = arg.trim().match(/^(\w+)\s*[=\s]\s*(.+)$/);
+  if (!match) return null;
+  const phase = match[1].toLowerCase();
+  const model = match[2].trim();
+  if (!isPhase(phase) || model === "") return null;
+  return { phase, model };
+}
+
+/** Render the per-phase model map as an aligned block. */
+export function formatModels(models: PhaseModels): string {
+  return PHASES.map((phase) => `  ${phase.padEnd(10)} ${models[phase]}`).join("\n");
+}
+
+/** Write the models back into `~/.pi/zero.json`, preserving every other key. */
+function writeModels(data: Record<string, unknown>, models: PhaseModels): void {
+  writeFileSync(zeroJsonPath(), `${JSON.stringify({ ...data, models }, null, 2)}\n`, "utf8");
+}
+
+/** The slice of pi's extension API this command uses. */
+interface PiUI {
+  select(prompt: string, options: string[]): Promise<string | undefined>;
+  input(prompt: string, placeholder?: string): Promise<string | undefined>;
+  notify(message: string, type?: "info" | "warning" | "error"): void;
+}
+interface PiCommandContext {
+  ui: PiUI;
+}
+interface PiExtensionAPI {
+  registerCommand(
+    name: string,
+    options: {
+      description?: string;
+      handler: (args: string, ctx: PiCommandContext) => Promise<void> | void;
+    },
+  ): void;
+}
+
+const SAVE_AND_EXIT = "— guardar y salir —";
+const CUSTOM_MODEL = "— otro modelo (escribir) —";
+
+/**
+ * The pi extension entry point — registers the `/zero-models` command.
+ */
+export default function register(pi?: PiExtensionAPI): void {
+  if (!pi || typeof pi.registerCommand !== "function") return;
+
+  pi.registerCommand("zero-models", {
+    description: "Show or set the per-phase SDD models — /zero-models [<phase>=<model>]",
+    handler: async (args: string, ctx: PiCommandContext): Promise<void> => {
+      try {
+        const data = readZeroJson();
+        const models = readModels(data);
+
+        // Direct form: /zero-models build=claude-opus-4-7
+        const arg = args.trim();
+        if (arg) {
+          const assignment = parseAssignment(arg);
+          if (!assignment) {
+            ctx.ui.notify(
+              "uso: /zero-models  —o—  /zero-models <fase>=<modelo> " +
+                "(fase: explore | plan | build | veredicto)",
+              "warning",
+            );
+            return;
+          }
+          models[assignment.phase] = assignment.model;
+          writeModels(data, models);
+          ctx.ui.notify(`zero models: ${assignment.phase} → ${assignment.model}`, "info");
+          return;
+        }
+
+        // Interactive form: pick a phase, pick a model, repeat until saved.
+        let changed = false;
+        for (;;) {
+          const phasePick = await ctx.ui.select(
+            "zero · modelos SDD — elegí una fase",
+            [...PHASES.map((p) => `${p}   →   ${models[p]}`), SAVE_AND_EXIT],
+          );
+          if (!phasePick || phasePick === SAVE_AND_EXIT) break;
+
+          const phase = phasePick.split(/\s/)[0];
+          if (!isPhase(phase)) break;
+
+          const modelPick = await ctx.ui.select(`Modelo para «${phase}»`, [
+            ...MODEL_CHOICES,
+            CUSTOM_MODEL,
+          ]);
+          if (!modelPick) continue;
+
+          let model = modelPick;
+          if (modelPick === CUSTOM_MODEL) {
+            const typed = await ctx.ui.input(`Modelo para «${phase}»`, models[phase]);
+            if (!typed || typed.trim() === "") continue;
+            model = typed.trim();
+          }
+          models[phase] = model;
+          changed = true;
+        }
+
+        if (changed) {
+          writeModels(data, models);
+          ctx.ui.notify(`zero · modelos SDD guardados:\n${formatModels(models)}`, "info");
+        } else {
+          ctx.ui.notify(`zero · modelos SDD (sin cambios):\n${formatModels(models)}`, "info");
+        }
+      } catch (err) {
+        ctx.ui.notify(
+          `zero-models: ${err instanceof Error ? err.message : String(err)}`,
+          "error",
+        );
+      }
+    },
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gonrocca/zero-pi",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "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": [
@@ -20,13 +20,15 @@
       "./skills"
     ],
     "extensions": [
-      "./extensions/startup-banner.ts"
+      "./extensions/startup-banner.ts",
+      "./extensions/zero-models.ts"
     ]
   },
   "files": [
     "prompts",
     "skills",
     "extensions/startup-banner.ts",
+    "extensions/zero-models.ts",
     "README.md",
     "LICENSE"
   ],

package/prompts/forge.md

@@ -1,31 +1,8 @@
 ---
-description: Run the SDD pipeline for a feature — or `/forge models` to set the per-phase models
+description: Run an automatic spec-driven development pipeline for a feature request
 ---
 
-The argument decides the mode.
-
-## `/forge models` — configure the SDD models
-
-When the argument is exactly `models`, do **not** run the pipeline. Configure
-the per-phase models instead:
-
-1. Read `~/.pi/zero.json`. Show the user the current `models` mapping — the
-   model assigned to each phase: `explore`, `plan`, `build`, `veredicto`.
-2. Ask which phases they want to change and to what. Offer the models the
-   active provider exposes — run `pi --list-models` if you need the list.
-   Guidance: a cheap, fast model suits `explore`; a strong model suits `plan`
-   and the adversarial `veredicto`; `build` sits in between.
-3. Write the chosen models back into `~/.pi/zero.json`, replacing only the
-   `models` block and preserving every other key (`version`, `installedAt`).
-   Validate each model name against `pi --list-models` before writing.
-4. Confirm the new mapping back to the user.
-
-This changes the models for every later `/forge` run — the orchestrator reads
-`~/.pi/zero.json` at the start of each run.
-
-## `/forge <feature request>` — run the SDD pipeline
-
-For any other argument, run the zero SDD pipeline for that feature request.
+Run the zero SDD pipeline for the feature request in the arguments.
 
 Follow the zero SDD orchestrator instructions: drive the run through the
 explore → plan → build → veredicto phases, honour the build/veredicto iteration
@@ -40,4 +17,7 @@ In interactive mode, pause after each phase with a summary and ask before
 continuing. Never report success unless the veredicto phase returned a `pasa`
 verdict; if the cap is reached first, report that the result is not verified.
 
-Argument: $ARGUMENTS
+To change the per-phase models, the user runs the `/zero-models` command — do
+not handle model configuration here.
+
+Feature request: $ARGUMENTS