@zephyrdeng/pi-review 0.5.1 → 0.6.1

package/extensions/rv-completions.ts

@@ -0,0 +1,489 @@
+/**
+ * Pure, testable /rv argument-completion logic.
+ *
+ * Avoids pi types so tokenizer + preset ordering can be unit-tested.
+ * Completion `value` must include the typed head (pi-tui replaces the whole arg).
+ */
+
+import { type RvLocale, rvUi } from "./rv-locale.js";
+import { semanticCompletionItems, SEMANTIC_PHRASES } from "./rv-semantic.js";
+import {
+  loadReviewModelPriorities,
+  primaryPresetForProfile,
+  rankModelsWithPresets,
+  resolvePresetOrderedModels,
+  resolveReviewProfile,
+  type ReviewModelPriorities,
+  type ReviewProfile,
+} from "./rv-model-priorities.js";
+
+export type AutocompleteItem = {
+  value: string;
+  label: string;
+  description?: string;
+};
+
+export const RV_MODE_VALUES = ["code", "plan", "challenge"] as const;
+export const THINKING_LEVELS = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+] as const;
+export const RV_FLAGS = [
+  "--mode",
+  "--model",
+  "--thinking",
+  "--keep-session",
+  "--no-stream",
+  "--continue",
+] as const;
+
+export const MODE_HINTS: Record<string, string> = {
+  code: "Code / diff / MR review",
+  plan: "Architecture or plan review",
+  challenge: "Adversarial plan review",
+};
+
+export const FLAG_HINTS: Record<string, string> = {
+  "--mode": "Review mode: code | plan | challenge",
+  "--model": "provider/model[:thinking]",
+  "--thinking": "off | minimal | low | medium | high | xhigh",
+  "--keep-session": "Keep session for /rv --continue follow-up",
+  "--no-stream": "Buffer output until exit (not default)",
+  "--continue": "Resume an existing review session",
+};
+
+/** Minimal model metadata we need; converted from the host's Model registry. */
+export interface ModelInfo {
+  provider: string;
+  id: string;
+  /** `${provider}/${id}` */
+  label: string;
+  name: string;
+  reasoning: boolean;
+  contextWindow: number;
+  /** Lowercased thinking levels the model actually supports; empty if non-reasoning. */
+  thinkingLevels: string[];
+}
+
+export interface ReviewSignals {
+  mode: string;
+  hasTarget: boolean;
+  targetExt?: string;
+  /** Provider of the host session's primary model, for cross-vendor bonus. */
+  primaryProvider?: string;
+}
+
+export interface CompletionDeps {
+  models?: ModelInfo[];
+  primaryProvider?: string;
+  priorities?: ReviewModelPriorities;
+  locale?: RvLocale;
+}
+
+function localeOf(deps: CompletionDeps): RvLocale {
+  return deps.locale ?? "en";
+}
+
+function modeFromSemanticHead(head: string[]): string | undefined {
+  const joined = head.join(" ").toLowerCase();
+  for (const row of SEMANTIC_PHRASES) {
+    if (!row.apply.mode) continue;
+    for (const p of row.phrases) {
+      if (joined.includes(p.toLowerCase())) return row.apply.mode;
+    }
+  }
+  return undefined;
+}
+
+function getPriorities(deps: CompletionDeps): ReviewModelPriorities {
+  return deps.priorities ?? loadReviewModelPriorities();
+}
+
+export function reviewProfileForSignals(sig: ReviewSignals): ReviewProfile {
+  return resolveReviewProfile(sig.mode, sig.targetExt);
+}
+
+// ---------------------------------------------------------------------------
+// Tokenizer
+// ---------------------------------------------------------------------------
+
+export interface TokenizedArgs {
+  /** Fully typed tokens before the in-progress tail. */
+  head: string[];
+  /** Raw head tokens (quotes preserved) for safe reconstruction. */
+  rawHead: string[];
+  /** The token currently being typed (may be ""). */
+  tail: string;
+  /** Last token of `head`, or null. Used to detect value-position flags. */
+  prev: string | null;
+}
+
+const TOKEN_RE = /(?:[^\s"']+|"[^"]*"|'[^']*')+/g;
+
+export function tokenizeArgPrefix(prefix: string): TokenizedArgs {
+  const lastSpace = prefix.lastIndexOf(" ");
+  if (lastSpace === -1) {
+    return { head: [], rawHead: [], tail: prefix, prev: null };
+  }
+  const headRaw = prefix.slice(0, lastSpace);
+  const tail = prefix.slice(lastSpace + 1);
+  const matches = headRaw.match(TOKEN_RE) ?? [];
+  const rawHead = matches.slice();
+  const head = matches.map((t) => t.replace(/^['"]|['"]$/g, ""));
+  const prev = head.length > 0 ? head[head.length - 1] : null;
+  return { head, rawHead, tail, prev };
+}
+
+// ---------------------------------------------------------------------------
+// Signal extraction
+// ---------------------------------------------------------------------------
+
+
+function extOf(token: string): string | undefined {
+  const cleaned = token.replace(/^['"]|['"]$/g, "").replace(/^@/, "");
+  const m = cleaned.match(/\.([a-zA-Z0-9]+)$/);
+  return m ? m[1].toLowerCase() : undefined;
+}
+
+export function extractSignals(head: string[], deps: CompletionDeps): ReviewSignals {
+  const target = head.find((t) => t.startsWith("@"));
+  const modeIdx = head.indexOf("--mode");
+  const mode =
+    (modeIdx >= 0 ? head[modeIdx + 1] : undefined) ?? modeFromSemanticHead(head) ?? "code";
+  return {
+    mode,
+    hasTarget: Boolean(target),
+    targetExt: target ? extOf(target) : undefined,
+    primaryProvider: deps.primaryProvider,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Model ordering: registry + preset priorities (no LLM)
+// ---------------------------------------------------------------------------
+
+export function rankModelsForReview(
+  models: ModelInfo[],
+  sig: ReviewSignals,
+  priorities?: ReviewModelPriorities,
+): ModelInfo[] {
+  const profile = reviewProfileForSignals(sig);
+  return rankModelsWithPresets(models, profile, priorities ?? loadReviewModelPriorities());
+}
+
+function presetDescription(
+  presetLabel: string,
+  profile: ReviewProfile,
+  presetRank: number | undefined,
+  locale: RvLocale,
+): string {
+  if (presetRank === undefined) return "";
+  const ui = rvUi(locale);
+  return `${ui.presetTier(presetRank)} · ${profile} · ${presetLabel}`;
+}
+
+// ---------------------------------------------------------------------------
+// Fuzzy filtering (subsequence match, case-insensitive)
+// ---------------------------------------------------------------------------
+
+export function fuzzyMatch(text: string, query: string): boolean {
+  if (!query) return true;
+  const t = text.toLowerCase();
+  const q = query.toLowerCase();
+  let i = 0;
+  for (const ch of t) {
+    if (ch === q[i]) i++;
+    if (i === q.length) return true;
+  }
+  return false;
+}
+
+function filterList(list: readonly string[], query: string): string[] {
+  if (!query) return [...list];
+  const prefixed = list.filter((item) => item.startsWith(query));
+  if (prefixed.length) return prefixed;
+  // Only fall back to subsequence matching when nothing starts with the query.
+  return list.filter((item) => fuzzyMatch(item, query));
+}
+
+function uniqueFlat(lists: string[][]): string[] {
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const list of lists) {
+    for (const v of list) {
+      if (!seen.has(v)) {
+        seen.add(v);
+        out.push(v);
+      }
+    }
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// Completion builders
+// ---------------------------------------------------------------------------
+
+function wrap(
+  candidates: string[],
+  headPrefix: string,
+  hints?: Record<string, string>,
+): AutocompleteItem[] | null {
+  if (candidates.length === 0) return null;
+  return candidates.map((c) => ({
+    value: `${headPrefix}${c}`,
+    label: c,
+    description: hints?.[c],
+  }));
+}
+
+function thinkingDescription(level: string, sig: ReviewSignals, locale: RvLocale): string {
+  const recommended = sig.mode === "code" ? "high" : "xhigh";
+  const star = level === recommended ? rvUi(locale).thinkingSuggested : "";
+  const map: Record<string, string> = {
+    off: "No thinking (fastest)",
+    minimal: "Minimal thinking",
+    low: "Low effort",
+    medium: "Medium effort",
+    high: "High effort (common for review)",
+    xhigh: "Max effort (plan/challenge)",
+  };
+  return `${star}${map[level] ?? level}`;
+}
+
+function contextLabel(ctx: number): string {
+  if (ctx >= 1_000_000) return "1M+ ctx";
+  if (ctx >= 1000) return `${Math.round(ctx / 1000)}k ctx`;
+  return `${ctx} ctx`;
+}
+
+function modelItems(
+  models: ModelInfo[],
+  sig: ReviewSignals,
+  headPrefix: string,
+  tail: string,
+  deps: CompletionDeps,
+): AutocompleteItem[] | null {
+  const priorities = getPriorities(deps);
+  const profile = reviewProfileForSignals(sig);
+  const presetRows = resolvePresetOrderedModels(models, profile, priorities);
+  const presetByLabel = new Map(presetRows.map((p) => [p.model.label, p]));
+  const ranked = rankModelsWithPresets(models, profile, priorities);
+  const items = ranked.map((m) => {
+    const preset = presetByLabel.get(m.label);
+    const tag = profile;
+    return {
+      value: `${headPrefix}${m.label}`,
+      label: m.label,
+      description: [
+        preset ? presetDescription(preset.presetLabel, profile, preset.presetRank, localeOf(deps)) : "",
+        tag,
+        m.reasoning ? "reasoning" : "",
+        contextLabel(m.contextWindow),
+        preset?.thinking ? `preset thinking ${preset.thinking}` : "",
+      ]
+        .filter(Boolean)
+        .join(" · "),
+    };
+  });
+  // Contiguous matching for model ids (subsequence is too loose for ids like
+  // "claude-opus" which would match "ope" via o-p...-e).
+  const q = tail;
+  const filtered = items.filter((it) => {
+    const label = it.label;
+    return (
+      label.startsWith(q) ||
+      label.includes(q) ||
+      // also allow matching by bare id / provider segment
+      label.split("/")[1]?.startsWith(q) ||
+      label.split("/")[0]?.startsWith(q)
+    );
+  });
+  return filtered.length ? filtered : null;
+}
+
+function thinkingSuffixItems(
+  tail: string,
+  models: ModelInfo[],
+  headPrefix: string,
+  sig: ReviewSignals,
+  deps: CompletionDeps,
+): AutocompleteItem[] | null {
+  const colonIdx = tail.lastIndexOf(":");
+  const modelPart = tail.slice(0, colonIdx);
+  const levelPart = tail.slice(colonIdx + 1);
+  if (!modelPart.includes("/")) return null;
+
+  const exact = models.filter((m) => m.label === modelPart);
+  const pool = exact.length
+    ? exact
+    : models.filter((m) => m.label.startsWith(modelPart) || m.id.startsWith(modelPart));
+  if (pool.length === 0) return null;
+
+  const levels = uniqueFlat(pool.map((m) => m.thinkingLevels));
+  const filtered = filterList(levels, levelPart);
+  if (filtered.length === 0) return null;
+  return filtered.map((level) => ({
+    value: `${headPrefix}${modelPart}:${level}`,
+    label: level,
+    description: thinkingDescription(level, sig, localeOf(deps)),
+  }));
+}
+
+function thinkingSuffixForModel(m: ModelInfo, want?: string): string {
+  const lvl =
+    want && m.thinkingLevels.includes(want)
+      ? want
+      : want && m.thinkingLevels.includes("high")
+        ? "high"
+        : m.thinkingLevels.includes("xhigh")
+          ? "xhigh"
+          : m.thinkingLevels.includes("high")
+            ? "high"
+            : (m.thinkingLevels[0] ?? "");
+  return lvl ? `:${lvl}` : "";
+}
+
+function sceneTemplates(
+  models: ModelInfo[],
+  sig: ReviewSignals,
+  headPrefix: string,
+  tail: string,
+  deps: CompletionDeps,
+): AutocompleteItem[] {
+  const priorities = getPriorities(deps);
+  const codePrimary = primaryPresetForProfile(models, "code", priorities);
+  const planPrimary = primaryPresetForProfile(models, "plan", priorities);
+  const frontendPrimary = primaryPresetForProfile(models, "frontend", priorities);
+
+  const ui = rvUi(localeOf(deps));
+  const templates: { cmd: string; label: string }[] = [];
+  if (codePrimary) {
+    const m = codePrimary.model;
+    templates.push({
+      cmd: `${ui.modeCode} --model ${m.label}${thinkingSuffixForModel(m, codePrimary.thinking ?? "xhigh")} @`,
+      label: ui.codePreset,
+    });
+  }
+  if (frontendPrimary) {
+    const m = frontendPrimary.model;
+    templates.push({
+      cmd: `${ui.modeCode} --model ${m.label}${thinkingSuffixForModel(m, frontendPrimary.thinking)} @`,
+      label: ui.frontendPreset,
+    });
+  }
+  if (planPrimary) {
+    const m = planPrimary.model;
+    templates.push({
+      cmd: `${ui.modePlan} --model ${m.label}${thinkingSuffixForModel(m, planPrimary.thinking ?? "high")} @`,
+      label: ui.planPreset,
+    });
+    templates.push({
+      cmd: `${ui.modeChallenge} ${ui.keepSession} --model ${m.label}${thinkingSuffixForModel(m, "xhigh")} @`,
+      label: ui.challengePreset,
+    });
+  }
+
+  return templates
+    .filter((t) => fuzzyMatch(t.label, tail) || t.cmd.includes(tail))
+    .map((t) => ({
+      value: `${headPrefix}${t.cmd}`,
+      label: t.label,
+      description: t.cmd,
+    }));
+}
+
+function flagItems(head: string[], tail: string, headPrefix: string): AutocompleteItem[] | null {
+  // Don't re-suggest boolean flags already present.
+  const present = new Set(head);
+  const candidates = filterList(RV_FLAGS, tail).filter((f) => {
+    if (f === "--keep-session" || f === "--no-stream") return !present.has(f);
+    return true;
+  });
+  return wrap(candidates, headPrefix, FLAG_HINTS);
+}
+
+function topLevelCompletions(
+  head: string[],
+  tail: string,
+  deps: CompletionDeps,
+  headPrefix: string,
+  sig: ReviewSignals,
+): AutocompleteItem[] | null {
+  const items: AutocompleteItem[] = [];
+
+  // Scene templates (only at top level, before any target/mode chosen is fine).
+  if (deps.models?.length) {
+    items.push(...sceneTemplates(deps.models, sig, headPrefix, tail, deps));
+  }
+
+  items.push(...semanticCompletionItems(localeOf(deps), tail, headPrefix, head));
+
+  const ui = rvUi(localeOf(deps));
+  if (fuzzyMatch(ui.modelsKeyword, tail) || ui.modelsKeyword.startsWith(tail) || fuzzyMatch("models", tail)) {
+    items.push({
+      value: `${headPrefix}${ui.listModels}`,
+      label: ui.listModels,
+      description: ui.listModelsDesc,
+    });
+  }
+
+  if (tail.startsWith("--")) {
+    const flags = flagItems(head, tail, headPrefix);
+    if (flags) items.push(...flags);
+  }
+
+  return items.length ? items : null;
+}
+
+// ---------------------------------------------------------------------------
+// Public entry point
+// ---------------------------------------------------------------------------
+
+export function buildRvCompletions(
+  prefix: string,
+  deps: CompletionDeps,
+): AutocompleteItem[] | null {
+  const { head, rawHead, tail, prev } = tokenizeArgPrefix(prefix);
+  const joinedHead = rawHead.join(" ");
+  const headPrefix = joinedHead ? `${joinedHead} ` : "";
+  const sig = extractSignals(head, deps);
+
+  // 1) --model value position (model list or :thinking suffix).
+  if (prev === "--model") {
+    const colonIdx = tail.lastIndexOf(":");
+    if (colonIdx !== -1 && tail.slice(0, colonIdx).includes("/")) {
+      const items = thinkingSuffixItems(tail, deps.models ?? [], headPrefix, sig, deps);
+      return items;
+    }
+    return modelItems(deps.models ?? [], sig, headPrefix, tail, deps);
+  }
+
+  // 2) --mode value position.
+  if (prev === "--mode") {
+    return wrap(filterList(RV_MODE_VALUES, tail), headPrefix, MODE_HINTS);
+  }
+
+  // 3) --thinking value position.
+  if (prev === "--thinking") {
+    return wrap(filterList(THINKING_LEVELS, tail), headPrefix);
+  }
+
+  // 4) --continue value position: defer (no static list; handler owns it).
+  if (prev === "--continue") return null;
+
+  // 5) Flag completion (tail starts with "--").
+  if (tail.startsWith("--")) {
+    return flagItems(head, tail, headPrefix);
+  }
+
+  // 6) File attachment in progress → defer to built-in file completion.
+  if (tail.startsWith("@")) return null;
+
+  // 7) Top-level: scene templates + `models` + flags.
+  return topLevelCompletions(head, tail, deps, headPrefix, sig);
+}

package/extensions/rv-locale.test.ts

@@ -0,0 +1,17 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { detectRvLocale } from "./rv-locale.js";
+
+describe("detectRvLocale", () => {
+  it("returns zh when recent messages are mostly Chinese", () => {
+    assert.equal(detectRvLocale(["帮我看一下这个方案", "好的"]), "zh");
+  });
+
+  it("returns en for English-only samples", () => {
+    assert.equal(detectRvLocale(["Please review this diff", "Thanks"]), "en");
+  });
+
+  it("defaults to en when empty", () => {
+    assert.equal(detectRvLocale([]), "en");
+  });
+});

package/extensions/rv-locale.ts

@@ -0,0 +1,81 @@
+/** Lightweight locale for /rv UI strings (no LLM). */
+
+export type RvLocale = "en" | "zh";
+
+const CJK_RE = /[\u4e00-\u9fff\u3400-\u4dbf]/;
+
+export function detectRvLocale(textSamples: string[]): RvLocale {
+  let cjk = 0;
+  let latin = 0;
+  for (const sample of textSamples) {
+    const t = sample.slice(0, 2000);
+    for (const ch of t) {
+      if (CJK_RE.test(ch)) cjk++;
+      else if (/[a-zA-Z]/.test(ch)) latin++;
+    }
+  }
+  if (cjk === 0 && latin === 0) return "en";
+  return cjk >= latin * 0.15 ? "zh" : "en";
+}
+
+export type RvUiStrings = {
+  modelsKeyword: string;
+  modelsDesc: string;
+  modeCode: string;
+  modePlan: string;
+  modeChallenge: string;
+  keepSession: string;
+  keepSessionDesc: string;
+  listModels: string;
+  listModelsDesc: string;
+  codePreset: string;
+  frontendPreset: string;
+  planPreset: string;
+  challengePreset: string;
+  suggested: string;
+  presetTier: (n: number) => string;
+  thinkingSuggested: string;
+};
+
+const UI: Record<RvLocale, RvUiStrings> = {
+  en: {
+    modelsKeyword: "models",
+    modelsDesc: "List pi-review models only",
+    modeCode: "code review",
+    modePlan: "plan review",
+    modeChallenge: "challenge review",
+    keepSession: "keep session for follow-up",
+    keepSessionDesc: "Persist review session for /rv --continue",
+    listModels: "list models",
+    listModelsDesc: "Show provider/model catalog",
+    codePreset: "Code review (preset)",
+    frontendPreset: "Frontend / multimodal review (preset)",
+    planPreset: "Plan review (preset)",
+    challengePreset: "Challenge review (preset)",
+    suggested: "Suggested",
+    presetTier: (n) => (n === 0 ? "Suggested" : `Preset #${n + 1}`),
+    thinkingSuggested: "Suggested ",
+  },
+  zh: {
+    modelsKeyword: "models",
+    modelsDesc: "仅列出 pi-review 可用模型",
+    modeCode: "代码审核",
+    modePlan: "方案审核",
+    modeChallenge: "对抗性审核",
+    keepSession: "保留会话可追问",
+    keepSessionDesc: "保留 review 会话，便于 /rv --continue",
+    listModels: "查看模型列表",
+    listModelsDesc: "列出当前可用 provider/model",
+    codePreset: "代码审核（推荐配置）",
+    frontendPreset: "前端 / 多模态审核（推荐）",
+    planPreset: "方案 / 架构审核（推荐）",
+    challengePreset: "对抗性方案审核（可追问）",
+    suggested: "推荐",
+    presetTier: (n) => (n === 0 ? "推荐" : `预设 #${n + 1}`),
+    thinkingSuggested: "推荐 ",
+  },
+};
+
+export function rvUi(locale: RvLocale): RvUiStrings {
+  return UI[locale];
+}

package/extensions/rv-model-priorities.test.ts

@@ -0,0 +1,69 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+  DEFAULT_REVIEW_MODEL_PRIORITIES,
+  matchPresetEntry,
+  rankModelsWithPresets,
+  resolveReviewProfile,
+  type PresetModelEntry,
+} from "./rv-model-priorities.js";
+import type { ModelInfo } from "./rv-completions.js";
+
+function m(provider: string, id: string, extra?: Partial<ModelInfo>): ModelInfo {
+  return {
+    provider,
+    id,
+    label: `${provider}/${id}`,
+    name: id,
+    reasoning: true,
+    contextWindow: 200_000,
+    thinkingLevels: ["high", "xhigh"],
+    ...extra,
+  };
+}
+
+describe("resolveReviewProfile", () => {
+  it("uses plan profile for plan/challenge mode", () => {
+    assert.equal(resolveReviewProfile("plan", "ts"), "plan");
+    assert.equal(resolveReviewProfile("challenge", "md"), "plan");
+  });
+
+  it("uses frontend profile for vue/svelte/css targets", () => {
+    assert.equal(resolveReviewProfile("code", "vue"), "frontend");
+    assert.equal(resolveReviewProfile("code", "css"), "frontend");
+  });
+
+  it("defaults to code profile", () => {
+    assert.equal(resolveReviewProfile("code", "ts"), "code");
+  });
+});
+
+describe("matchPresetEntry", () => {
+  const registry = [
+    m("openai", "gpt-5.5"),
+    m("zhipu", "glm-5.2-chat"),
+    m("moonshot", "kimi-k2.7-preview"),
+    m("moonshot", "kimi-k2.5"),
+    m("anthropic", "claude-opus-4-8"),
+    m("anthropic", "claude-opus-4-6"),
+    m("deepseek", "deepseek-v4-pro"),
+  ];
+
+  it("picks newest kimi when versionPrefer 2.7", () => {
+    const entry: PresetModelEntry = { idContains: "kimi", versionPrefer: "2.7" };
+    const hit = matchPresetEntry(registry, entry);
+    assert.ok(hit);
+    assert.match(hit!.id, /2\.7|k2\.7/i);
+  });
+
+  it("ranks gpt-5.5 first for code presets", () => {
+    const ordered = rankModelsWithPresets(registry, "code", DEFAULT_REVIEW_MODEL_PRIORITIES);
+    assert.equal(ordered[0].id, "gpt-5.5");
+    assert.equal(ordered[1].id, "glm-5.2-chat");
+  });
+
+  it("ranks claude-opus-4-8 before older opus for plan", () => {
+    const ordered = rankModelsWithPresets(registry, "plan", DEFAULT_REVIEW_MODEL_PRIORITIES);
+    assert.equal(ordered[0].id, "claude-opus-4-8");
+  });
+});