@zephyrdeng/pi-review 0.5.1 → 0.6.1

package/README.md

@@ -222,7 +222,16 @@ The `/rv` command injects a task message for the parent agent (Pi host rules: de
 /rv --mode challenge --keep-session @docs/design.md
 ```
 
-Argument completions (`--mode`, `@`, `models`, etc.) are hints only; execution is skill-driven.
+Argument completions are context-aware. After the host session starts, `/rv` reads the live model registry and offers:
+
+- **Model list** after `--model `: candidates come from the live Pi registry; order follows **`resources/rv-model-priorities.json`** (override with `PI_REVIEW_RV_PRIORITIES`). Presets match registry ids by substring and prefer newer version strings (e.g. kimi `2.7`, `claude-opus-4-8`). Profiles: **code** (e.g. gpt-5.5 `:xhigh`, glm-5.2 `:high`), **frontend** (vue/css/… → kimi, claude-sonnet, minimax-m3), **plan/challenge** (claude-opus-4-8, deepseek-v4-pro, …).
+- **Thinking suffix** after `provider/model:` — only levels the chosen model actually supports.
+- **Semantic phrases** (e.g. `code review` / 代码审核, `查看模型列表`) in addition to flags; orchestration prompts follow **session locale** (zh/en) for summaries.
+- **Scene templates** at the top level (code / frontend / plan presets).
+
+**Claude Code / Codex:** the bundled skill includes **[skills/pi-review/references/model-selection.md](skills/pi-review/references/model-selection.md)** — same presets as `/rv` for choosing `--model` after `pi-review models`.
+
+Completions are a hint layer only; execution remains skill-driven. When the model registry is unavailable (e.g. non-TUI mode), `/rv` falls back to the static hint list.
 
 ## Security
 

package/extensions/review.ts

@@ -1,4 +1,9 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+  buildRvCompletions,
+  type ModelInfo,
+} from "./rv-completions.js";
+import { detectRvLocale } from "./rv-locale.js";
 import {
   buildRvOrchestrationPrompt,
   parseRvArgs,
@@ -6,11 +11,98 @@ import {
   validateRvParsed,
 } from "./rv-prompts.js";
 
+/**
+ * Captured at `session_start` so the synchronous-ish `getArgumentCompletions`
+ * callback (which receives only the argument prefix) can read the live model
+ * registry without ctx. Stays undefined in non-TUI/print mode; completions then
+ * gracefully degrade to the static `RV_COMPLETIONS` fallback.
+ */
+let capturedModels: ModelInfo[] | undefined;
+let capturedPrimaryProvider: string | undefined;
+let capturedLocale: ReturnType<typeof detectRvLocale> = "en";
+
+function sampleSessionText(
+  sessionManager: { getEntries?: () => Array<{ type?: string; content?: unknown }> },
+): string[] {
+  const out: string[] = [];
+  try {
+    const entries = sessionManager.getEntries?.() ?? [];
+    for (let i = entries.length - 1; i >= 0 && out.length < 12; i--) {
+      const e = entries[i];
+      if (e.type !== "message") continue;
+      const c = e.content;
+      if (typeof c === "string") out.push(c);
+      else if (c && typeof c === "object" && "text" in c && typeof (c as { text: string }).text === "string") {
+        out.push((c as { text: string }).text);
+      }
+    }
+  } catch {
+    /* ignore */
+  }
+  return out;
+}
+
+function toModelInfo(m: {
+  provider: string;
+  id: string;
+  name?: string;
+  reasoning?: boolean;
+  contextWindow?: number;
+  thinkingLevelMap?: Record<string, string | null | undefined>;
+}): ModelInfo {
+  const levels: string[] = [];
+  const map = m.thinkingLevelMap ?? {};
+  for (const k of ["off", "minimal", "low", "medium", "high", "xhigh"]) {
+    // A level is supported unless explicitly disabled (null) and is present in the map.
+    if (k in map && map[k] !== null && map[k] !== undefined) levels.push(k);
+  }
+  return {
+    provider: m.provider,
+    id: m.id,
+    label: `${m.provider}/${m.id}`,
+    name: m.name ?? m.id,
+    reasoning: Boolean(m.reasoning),
+    contextWindow: m.contextWindow ?? 0,
+    thinkingLevels: levels,
+  };
+}
+
 export default function piReviewExtension(pi: ExtensionAPI) {
+  pi.on("session_start", (_event, ctx) => {
+    try {
+      const available = ctx.modelRegistry?.getAvailable?.() ?? [];
+      capturedModels = available.map((m) => toModelInfo(m as unknown as Parameters<typeof toModelInfo>[0]));
+      capturedPrimaryProvider = ctx.model?.provider;
+      capturedLocale = detectRvLocale(sampleSessionText(ctx.sessionManager));
+    } catch {
+      capturedModels = undefined;
+      capturedPrimaryProvider = undefined;
+      capturedLocale = "en";
+    }
+  });
+
+  function localeForHandler(ctx: { sessionManager?: Parameters<typeof sampleSessionText>[0] }): typeof capturedLocale {
+    try {
+      return detectRvLocale(sampleSessionText(ctx.sessionManager ?? { getEntries: () => [] }));
+    } catch {
+      return capturedLocale;
+    }
+  }
+
   pi.registerCommand("rv", {
     description:
-      "Delegate pi-review to the agent. Usage: /rv [--mode plan|challenge] [--model id] [--keep-session] [--no-stream] @target | /rv --continue <handle> [opts] [text] | models",
-    getArgumentCompletions: (prefix) => {
+      "Delegate pi-review to the agent. Usage: /rv [--mode plan|challenge] [--model id] [--thinking level] [--keep-session] [--no-stream] @target | /rv --continue <handle> [opts] [text] | models",
+    getArgumentCompletions: (prefix): ReturnType<typeof buildRvCompletions> => {
+      // Try dynamic completion first (models + thinking + scene templates).
+      if (capturedModels && capturedModels.length > 0) {
+        const dynamic = buildRvCompletions(prefix, {
+          models: capturedModels,
+          primaryProvider: capturedPrimaryProvider,
+          locale: capturedLocale,
+        });
+        if (dynamic && dynamic.length) return dynamic;
+      }
+      // Graceful fallback to static hint list when registry is unavailable.
       const filtered = RV_COMPLETIONS.filter((item) => item.value.startsWith(prefix));
       return filtered.length
         ? filtered.map(({ value, hint }) => ({ value, label: value, description: hint }))
@@ -35,7 +127,7 @@ export default function piReviewExtension(pi: ExtensionAPI) {
         return;
       }
 
-      pi.sendUserMessage(buildRvOrchestrationPrompt(parsed));
+      pi.sendUserMessage(buildRvOrchestrationPrompt(parsed, localeForHandler(ctx)));
     },
   });
 }

package/extensions/rv-completions.test.ts

@@ -0,0 +1,218 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+  buildRvCompletions,
+  extractSignals,
+  fuzzyMatch,
+  MODE_HINTS,
+  rankModelsForReview,
+  tokenizeArgPrefix,
+  type ModelInfo,
+} from "./rv-completions.js";
+import { rvUi } from "./rv-locale.js";
+import { DEFAULT_REVIEW_MODEL_PRIORITIES } from "./rv-model-priorities.js";
+
+function model(partial: Partial<ModelInfo> & Pick<ModelInfo, "provider" | "id">): ModelInfo {
+  return {
+    label: `${partial.provider}/${partial.id}`,
+    name: partial.id,
+    reasoning: false,
+    contextWindow: 200_000,
+    thinkingLevels: ["off", "low", "medium", "high"],
+    ...partial,
+  };
+}
+
+const MODELS: ModelInfo[] = [
+  model({ provider: "anthropic", id: "claude-opus-4-6", reasoning: true, contextWindow: 200_000, thinkingLevels: ["off", "low", "medium", "high", "xhigh"] }),
+  model({ provider: "openai", id: "gpt-5.5", reasoning: true, contextWindow: 400_000, thinkingLevels: ["off", "minimal", "low", "medium", "high", "xhigh"] }),
+  model({ provider: "zenmux", id: "gemini-3-flash", reasoning: false, contextWindow: 1_000_000, thinkingLevels: [] }),
+];
+
+describe("tokenizeArgPrefix", () => {
+  it("splits head and tail on the last space", () => {
+    const t = tokenizeArgPrefix("@src/foo.ts --model ope");
+    assert.deepEqual(t.head, ["@src/foo.ts", "--model"]);
+    assert.equal(t.tail, "ope");
+    assert.equal(t.prev, "--model");
+  });
+
+  it("treats a single token as tail with empty head", () => {
+    const t = tokenizeArgPrefix("--mode");
+    assert.deepEqual(t.head, []);
+    assert.equal(t.tail, "--mode");
+    assert.equal(t.prev, null);
+  });
+
+  it("handles trailing space as empty tail", () => {
+    const t = tokenizeArgPrefix("@a.ts ");
+    assert.deepEqual(t.head, ["@a.ts"]);
+    assert.equal(t.tail, "");
+    assert.equal(t.prev, "@a.ts");
+  });
+
+  it("strips surrounding quotes in head tokens", () => {
+    const t = tokenizeArgPrefix('"@a b.ts" --mode ');
+    assert.deepEqual(t.head, ["@a b.ts", "--mode"]);
+    assert.deepEqual(t.rawHead, ['"@a b.ts"', "--mode"]);
+    assert.equal(t.prev, "--mode");
+  });
+});
+
+describe("extractSignals", () => {
+  it("detects target extension and explicit mode", () => {
+    const sig = extractSignals(["@docs/design.md", "--mode", "plan"], {});
+    assert.equal(sig.mode, "plan");
+    assert.equal(sig.targetExt, "md");
+    assert.equal(sig.hasTarget, true);
+  });
+
+  it("defaults mode to code", () => {
+    const sig = extractSignals(["@src/foo.ts"], {});
+    assert.equal(sig.mode, "code");
+    assert.equal(sig.targetExt, "ts");
+  });
+
+  it("carries primary provider on signals", () => {
+    const sig = extractSignals([], { primaryProvider: "anthropic" });
+    assert.equal(sig.primaryProvider, "anthropic");
+  });
+});
+
+describe("rankModelsForReview", () => {
+  it("puts preset code models first when registered", () => {
+    const sig = extractSignals(["@src/a.ts"], {});
+    const ranked = rankModelsForReview(MODELS, sig, DEFAULT_REVIEW_MODEL_PRIORITIES);
+    assert.equal(ranked[0].id, "gpt-5.5");
+  });
+
+  it("puts preset plan models first for plan mode", () => {
+    const sig = extractSignals(["--mode", "plan"], {});
+    const ranked = rankModelsForReview(MODELS, sig, DEFAULT_REVIEW_MODEL_PRIORITIES);
+    assert.equal(ranked[0].id, "claude-opus-4-6");
+  });
+});
+
+describe("fuzzyMatch", () => {
+  it("matches subsequence case-insensitively", () => {
+    assert.equal(fuzzyMatch("anthropic/claude-opus-4-6", "aclaude"), true);
+    assert.equal(fuzzyMatch("Anthropic/Claude", "acl"), true);
+    assert.equal(fuzzyMatch("openai/gpt-5.5", "zzz"), false);
+  });
+});
+
+describe("buildRvCompletions", () => {
+  const deps = {
+    models: MODELS,
+    primaryProvider: "anthropic",
+    priorities: DEFAULT_REVIEW_MODEL_PRIORITIES,
+  };
+
+  it("returns dynamic model list after --model, with recommended marker on top items", () => {
+    const items = buildRvCompletions("@x.md --model ", deps);
+    assert.ok(items, "expected items");
+    assert.ok(items!.some((i) => i.label === "openai/gpt-5.5"));
+    const top = items!.find((i) => i.description?.includes("Suggested"));
+    assert.ok(top, "expected at least one recommended item");
+    // value carries the head so applyCompletion replaces the whole arg safely
+    assert.ok(top!.value.startsWith("@x.md --model "));
+  });
+
+  it("filters models by a partial query", () => {
+    const items = buildRvCompletions("--model ope", deps);
+    assert.ok(items);
+    assert.ok(items!.every((i) => i.label.includes("openai")));
+  });
+
+  it("completes thinking suffix after provider/id: for a reasoning model", () => {
+    const items = buildRvCompletions("--model openai/gpt-5.5:", deps);
+    assert.ok(items);
+    const labels = items!.map((i) => i.label);
+    assert.ok(labels.includes("high"));
+    assert.ok(labels.includes("xhigh"));
+    assert.ok(items!.every((i) => i.value.startsWith("--model openai/gpt-5.5:")));
+  });
+
+  it("does not offer thinking suffix for a non-reasoning model", () => {
+    const items = buildRvCompletions("--model zenmux/gemini-3-flash:", deps);
+    // flash has empty thinkingLevels → no suffix candidates
+    assert.equal(items, null);
+  });
+
+  it("completes --mode values with hints", () => {
+    const items = buildRvCompletions("--mode pl", deps);
+    assert.ok(items);
+    assert.deepEqual(items!.map((i) => i.label), ["plan"]);
+    assert.equal(items![0].description, MODE_HINTS["plan"]);
+  });
+
+  it("completes --thinking levels", () => {
+    const items = buildRvCompletions("--thinking h", deps);
+    assert.ok(items);
+    assert.deepEqual(items!.map((i) => i.label).sort(), ["high"]);
+  });
+
+  it("completes flags when tail starts with --", () => {
+    const items = buildRvCompletions("--keep", deps);
+    assert.ok(items);
+    assert.deepEqual(items!.map((i) => i.label), ["--keep-session"]);
+    assert.ok(items![0].value === "--keep-session");
+  });
+
+  it("defers to built-in file completion when tail starts with @", () => {
+    assert.equal(buildRvCompletions("@src/foo", deps), null);
+  });
+
+  it("defers --continue value to the handler (no static list)", () => {
+    assert.equal(buildRvCompletions("--continue abc", deps), null);
+  });
+
+  it("offers scene templates + models keyword at empty top level", () => {
+    const items = buildRvCompletions("", deps);
+    const ui = rvUi("en");
+    assert.ok(items);
+    assert.ok(items!.some((i) => i.label === ui.listModels));
+    assert.ok(items!.some((i) => i.label === ui.codePreset));
+    const tmpl = items!.find((i) => i.label === ui.codePreset)!;
+    assert.ok(tmpl.value.endsWith(" @"));
+  });
+
+  it("every returned value preserves the head prefix (整段替换安全)", () => {
+    const cases = ["@a.ts --mode ", "@a.ts --model ", "@a.ts --thinking ", "@a.ts --"];
+    for (const c of cases) {
+      const items = buildRvCompletions(c, deps);
+      if (!items) continue;
+      for (const it of items) {
+        assert.ok(
+          it.value.startsWith(c),
+          `value "${it.value}" must preserve head "${c}"`,
+        );
+      }
+    }
+  });
+
+  it("preserves quotes in headPrefix for paths with spaces (note #2 fix)", () => {
+    const items = buildRvCompletions('"@a b.ts" --model ', deps);
+    assert.ok(items);
+    for (const it of items) {
+      assert.ok(
+        it.value.startsWith('"@a b.ts" --model '),
+        `value "${it.value}" must preserve quoted head`,
+      );
+    }
+  });
+
+  it("omits preset scene templates when registry has no preset id match", () => {
+    const nonReasoning = [{ ...MODELS[2], thinkingLevels: [] }] as ModelInfo[];
+    const items = buildRvCompletions("", { models: nonReasoning, priorities: DEFAULT_REVIEW_MODEL_PRIORITIES });
+    assert.ok(items);
+    assert.ok(!items!.some((i) => i.label === rvUi("en").codePreset));
+    assert.ok(items!.some((i) => i.label === rvUi("en").listModels));
+  });
+
+  it("falls back gracefully when models are unavailable (static flags still work)", () => {
+    const items = buildRvCompletions("--mode ", {});
+    assert.ok(items);
+    assert.ok(items!.some((i) => i.label === "code" || i.label === "plan" || i.label === "challenge"));
+  });
+});