opencode-auto-agent 1.2.0 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-auto-agent",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "description": "Scaffold and run an AI agent team powered by Ralphy + OpenCode. Presets for Java, Spring Boot, Next.js, and more.",
   "license": "MIT",
   "type": "module",
@@ -15,8 +15,8 @@
   ],
   "scripts": {
     "dev": "node bin/cli.js",
-    "test": "node --test src/**/*.test.js 2>/dev/null || true",
-    "verify": "node bin/cli.js help"
+    "test": "node --test src/**/*.test.js",
+    "verify": "npm run test && node bin/cli.js help"
   },
   "keywords": [
     "ai",

package/src/commands/init.js

@@ -112,26 +112,22 @@ export async function init(targetDir, { preset, force, nonInteractive } = {}) {
       continue;
     }
 
-    // Build selection list: default first, then all others
-    const items = [];
-    if (defaultModel) {
-      items.push({
-        label: defaultModel.id,
-        value: defaultModel.id,
-        hint: "(recommended)",
-      });
-    }
-    for (const m of models) {
-      if (m.id !== defaultModel?.id) {
-        items.push({ label: m.id, value: m.id });
-      }
-    }
+    const recommendedProvider = defaultModel?.provider || providerFromId(defaultId);
+    const providerItems = buildProviderItems(models, recommendedProvider);
+
+    const providerChoice = await select(
+      `Provider for ${c.bold(role)} ${c.gray(`\u2014 ${roleDef.description}`)}`,
+      providerItems
+    );
 
-    const result = await select(
-      `Model for ${c.bold(role)} ${c.gray(`\u2014 ${roleDef.description}`)}`,
-      items
+    const providerModels = models.filter((m) => m.provider === providerChoice.value);
+    const modelItems = buildModelItemsForProvider(providerModels, defaultModel?.id);
+    const modelChoice = await select(
+      `Model for ${c.bold(role)} ${c.gray(`(${providerChoice.value})`)}`,
+      modelItems
     );
-    modelMapping[role] = result.value;
+
+    modelMapping[role] = modelChoice.value;
   }
 
   // Show summary table
@@ -399,6 +395,43 @@ notifications:
 
 // ── Helpers ────────────────────────────────────────────────────────────────
 
+function providerFromId(modelId) {
+  return modelId.includes("/") ? modelId.split("/")[0] : modelId;
+}
+
+function buildProviderItems(models, preferredProvider) {
+  const counts = new Map();
+  for (const m of models) {
+    counts.set(m.provider, (counts.get(m.provider) || 0) + 1);
+  }
+
+  const providers = [...counts.keys()].sort((a, b) => {
+    if (a === preferredProvider) return -1;
+    if (b === preferredProvider) return 1;
+    return a.localeCompare(b);
+  });
+
+  return providers.map((provider) => ({
+    label: provider,
+    value: provider,
+    hint: `${counts.get(provider)} models${provider === preferredProvider ? " (recommended)" : ""}`,
+  }));
+}
+
+function buildModelItemsForProvider(providerModels, preferredModelId) {
+  const sorted = [...providerModels].sort((a, b) => {
+    if (a.id === preferredModelId) return -1;
+    if (b.id === preferredModelId) return 1;
+    return a.model.localeCompare(b.model);
+  });
+
+  return sorted.map((m) => ({
+    label: m.model,
+    value: m.id,
+    hint: m.id === preferredModelId ? "(recommended)" : "",
+  }));
+}
+
 function presetDescription(name) {
   const desc = {
     java: "General Java project (Maven/Gradle)",

package/src/commands/setup.js

@@ -131,35 +131,25 @@ export async function setup(targetDir, preset, { models: reconfigModels, nonInte
       for (const role of AGENTS) {
         const currentModel = modelMapping[role] || DEFAULT_MODEL_MAP[role];
         const currentFound = findModel(models, currentModel);
+        const defaultFound = findModel(models, DEFAULT_MODEL_MAP[role]);
+        const preferredProvider =
+          currentFound?.provider ||
+          defaultFound?.provider ||
+          providerFromId(currentModel);
+
+        const providerChoice = await select(
+          `Provider for ${c.bold(role)} ${c.gray(`\u2014 ${AGENT_ROLES[role].description}`)}`,
+          buildProviderItems(models, preferredProvider)
+        );
 
-        // Build selection: current first, default second (if different), then rest
-        const items = [];
-        const seen = new Set();
-
-        if (currentFound) {
-          items.push({ label: currentFound.id, value: currentFound.id, hint: "(current)" });
-          seen.add(currentFound.id);
-        }
-
-        const defaultId = DEFAULT_MODEL_MAP[role];
-        const defaultFound = findModel(models, defaultId);
-        if (defaultFound && !seen.has(defaultFound.id)) {
-          items.push({ label: defaultFound.id, value: defaultFound.id, hint: "(recommended)" });
-          seen.add(defaultFound.id);
-        }
-
-        for (const m of models) {
-          if (!seen.has(m.id)) {
-            items.push({ label: m.id, value: m.id });
-          }
-        }
-
-        const result = await select(
-          `Model for ${c.bold(role)} ${c.gray(`\u2014 ${AGENT_ROLES[role].description}`)}`,
-          items
+        const providerModels = models.filter((m) => m.provider === providerChoice.value);
+        const modelChoice = await select(
+          `Model for ${c.bold(role)} ${c.gray(`(${providerChoice.value})`)}`,
+          buildModelItemsForProvider(providerModels, currentModel, defaultFound?.id)
         );
-        if (result.value !== currentModel) modelsChanged = true;
-        modelMapping[role] = result.value;
+
+        if (modelChoice.value !== currentModel) modelsChanged = true;
+        modelMapping[role] = modelChoice.value;
       }
     } else {
       warn("No models found. Keeping current model assignments.", "Configure opencode providers first.");
@@ -311,6 +301,51 @@ function buildAgentPrompt(role, preset) {
   return prompts[role] || `You are the ${role} agent.`;
 }
 
+function providerFromId(modelId) {
+  return modelId.includes("/") ? modelId.split("/")[0] : modelId;
+}
+
+function buildProviderItems(models, preferredProvider) {
+  const counts = new Map();
+  for (const m of models) {
+    counts.set(m.provider, (counts.get(m.provider) || 0) + 1);
+  }
+
+  const providers = [...counts.keys()].sort((a, b) => {
+    if (a === preferredProvider) return -1;
+    if (b === preferredProvider) return 1;
+    return a.localeCompare(b);
+  });
+
+  return providers.map((provider) => ({
+    label: provider,
+    value: provider,
+    hint: `${counts.get(provider)} models${provider === preferredProvider ? " (recommended)" : ""}`,
+  }));
+}
+
+function buildModelItemsForProvider(providerModels, currentModelId, recommendedModelId) {
+  const sorted = [...providerModels].sort((a, b) => {
+    if (a.id === currentModelId) return -1;
+    if (b.id === currentModelId) return 1;
+    if (a.id === recommendedModelId) return -1;
+    if (b.id === recommendedModelId) return 1;
+    return a.model.localeCompare(b.model);
+  });
+
+  return sorted.map((m) => {
+    let hint = "";
+    if (m.id === currentModelId) hint = "(current)";
+    else if (m.id === recommendedModelId) hint = "(recommended)";
+
+    return {
+      label: m.model,
+      value: m.id,
+      hint,
+    };
+  });
+}
+
 /**
  * Patch or add the `model:` field in markdown YAML frontmatter.
  */

package/src/lib/models.test.js

@@ -0,0 +1,42 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { parseModelsOutput, findModel, isValidModel } from "./models.js";
+
+test("parseModelsOutput parses slash-style model lines", () => {
+  const raw = [
+    "openai/gpt-5.1-codex",
+    "anthropic/claude-sonnet-4-5  Fast and reliable",
+    "google/gemini-3-pro",
+  ].join("\n");
+
+  const models = parseModelsOutput(raw);
+  assert.equal(models.length, 3);
+  assert.equal(models[0].id, "openai/gpt-5.1-codex");
+  assert.equal(models[1].provider, "anthropic");
+});
+
+test("parseModelsOutput parses table-like provider/model lines", () => {
+  const raw = [
+    "provider   model",
+    "openai     gpt-5.1-codex",
+    "google     gemini-3-pro",
+  ].join("\n");
+
+  const models = parseModelsOutput(raw);
+  assert.equal(models.length, 2);
+  assert.equal(models[0].id, "openai/gpt-5.1-codex");
+  assert.equal(models[1].id, "google/gemini-3-pro");
+});
+
+test("findModel falls back from exact to model-name match", () => {
+  const models = [
+    { id: "openrouter/gpt-5.1-codex", provider: "openrouter", model: "gpt-5.1-codex" },
+    { id: "google/gemini-3-pro", provider: "google", model: "gemini-3-pro" },
+  ];
+
+  const found = findModel(models, "openai/gpt-5.1-codex");
+  assert.ok(found);
+  assert.equal(found.id, "openrouter/gpt-5.1-codex");
+  assert.equal(isValidModel(models, "openai/gpt-5.1-codex"), true);
+});

package/src/lib/ui.js

@@ -240,36 +240,43 @@ export async function input(question, defaultValue = "") {
 export async function select(title, items) {
   if (!items.length) throw new Error("select: no items provided");
 
+  if (!supportsInteractiveMenu()) {
+    return selectFallback(title, items);
+  }
+
   return new Promise((resolve) => {
     let cursor = 0;
+    const maxVisible = getMaxVisibleMenuItems();
+    const totalLines = Math.min(items.length, maxVisible) + 2;
+    let hasRendered = false;
 
     const render = () => {
-      // Move cursor up to overwrite previous render
-      if (cursor !== -1) {
-        stdout.write(`\x1b[${items.length + 1}A`);
+      const { start, end } = getVisibleWindow(items.length, cursor, maxVisible);
+      const visible = items.slice(start, end);
+
+      if (hasRendered) {
+        stdout.write(`\x1b[${totalLines}A`);
       }
 
-      stdout.write(`  ${c.cyan("?")} ${c.bold(title)}\n`);
-      for (let i = 0; i < items.length; i++) {
-        const item = items[i];
-        const selected = i === cursor;
-        const pointer = selected ? c.cyan("\u25B6") : " ";
-        const label = selected ? c.cyan(item.label) : c.white(item.label);
+      stdout.write(`\x1b[2K  ${c.cyan("?")} ${c.bold(title)}\n`);
+      for (let i = 0; i < visible.length; i++) {
+        const itemIndex = start + i;
+        const item = visible[i];
+        const isSelected = itemIndex === cursor;
+        const pointer = isSelected ? c.cyan("\u25B6") : " ";
+        const label = isSelected ? c.cyan(item.label) : c.white(item.label);
         const hint = item.hint ? c.gray(` ${item.hint}`) : "";
-        stdout.write(`  ${pointer} ${label}${hint}\n`);
+        stdout.write(`\x1b[2K  ${pointer} ${label}${hint}\n`);
       }
+
+      const range = `${start + 1}-${end}`;
+      const moreAbove = start > 0 ? c.gray("↑") : c.gray(" ");
+      const moreBelow = end < items.length ? c.gray("↓") : c.gray(" ");
+      stdout.write(`\x1b[2K  ${c.gray(`[${range}/${items.length}] ${moreAbove}${moreBelow} arrows/jk + enter`)}` + "\n");
+      hasRendered = true;
     };
 
-    // Initial render
-    stdout.write(`  ${c.cyan("?")} ${c.bold(title)}\n`);
-    for (let i = 0; i < items.length; i++) {
-      const item = items[i];
-      const selected = i === cursor;
-      const pointer = selected ? c.cyan("\u25B6") : " ";
-      const label = selected ? c.cyan(item.label) : c.white(item.label);
-      const hint = item.hint ? c.gray(` ${item.hint}`) : "";
-      stdout.write(`  ${pointer} ${label}${hint}\n`);
-    }
+    render();
 
     stdin.setRawMode(true);
     stdin.resume();
@@ -288,13 +295,12 @@ export async function select(title, items) {
         stdin.setRawMode(false);
         stdin.removeListener("data", onData);
         stdin.pause();
-        // Clear and reprint final selection
-        stdout.write(`\x1b[${items.length + 1}A`);
-        stdout.write(`  ${c.green("\u2713")} ${c.bold(title)} ${c.cyan(items[cursor].label)}\n`);
-        for (let i = 0; i < items.length; i++) {
-          stdout.write(`\x1b[2K\n`); // clear each line
+        stdout.write(`\x1b[${totalLines}A`);
+        for (let i = 0; i < totalLines; i++) {
+          stdout.write("\x1b[2K\n");
         }
-        stdout.write(`\x1b[${items.length}A`); // move back up
+        stdout.write(`\x1b[${totalLines}A`);
+        stdout.write(`\x1b[2K  ${c.green("\u2713")} ${c.bold(title)} ${c.cyan(items[cursor].label)}\n`);
         resolve(items[cursor]);
         return;
       }
@@ -325,41 +331,46 @@ export async function select(title, items) {
 export async function multiSelect(title, items) {
   if (!items.length) throw new Error("multiSelect: no items provided");
 
+  if (!supportsInteractiveMenu()) {
+    return multiSelectFallback(title, items);
+  }
+
   return new Promise((resolve) => {
     let cursor = 0;
-    const selected = new Set(
-      items.filter((it) => it.selected).map((_, i) => i)
-    );
+    const selected = buildSelectedIndexSet(items);
+    const maxVisible = getMaxVisibleMenuItems();
+    const totalLines = Math.min(items.length, maxVisible) + 2;
+    let hasRendered = false;
 
     const render = () => {
-      stdout.write(`\x1b[${items.length + 2}A`);
-      stdout.write(`  ${c.cyan("?")} ${c.bold(title)} ${c.gray("(space to toggle, enter to confirm)")}\n`);
-      for (let i = 0; i < items.length; i++) {
-        const item = items[i];
-        const isCursor = i === cursor;
-        const isSelected = selected.has(i);
+      const { start, end } = getVisibleWindow(items.length, cursor, maxVisible);
+      const visible = items.slice(start, end);
+
+      if (hasRendered) {
+        stdout.write(`\x1b[${totalLines}A`);
+      }
+
+      stdout.write(`\x1b[2K  ${c.cyan("?")} ${c.bold(title)} ${c.gray("(space to toggle)")}\n`);
+      for (let i = 0; i < visible.length; i++) {
+        const itemIndex = start + i;
+        const item = visible[i];
+        const isCursor = itemIndex === cursor;
+        const isSelected = selected.has(itemIndex);
         const pointer = isCursor ? c.cyan("\u25B6") : " ";
         const check = isSelected ? c.green("\u25C9") : c.gray("\u25CB");
         const label = isCursor ? c.cyan(item.label) : c.white(item.label);
         const hint = item.hint ? c.gray(` ${item.hint}`) : "";
         stdout.write(`\x1b[2K  ${pointer} ${check} ${label}${hint}\n`);
       }
-      stdout.write("\x1b[2K\n");
+
+      const range = `${start + 1}-${end}`;
+      const moreAbove = start > 0 ? c.gray("↑") : c.gray(" ");
+      const moreBelow = end < items.length ? c.gray("↓") : c.gray(" ");
+      stdout.write(`\x1b[2K  ${c.gray(`[${range}/${items.length}] ${moreAbove}${moreBelow} arrows/jk + space + enter`)}` + "\n");
+      hasRendered = true;
     };
 
-    // Initial render
-    stdout.write(`  ${c.cyan("?")} ${c.bold(title)} ${c.gray("(space to toggle, enter to confirm)")}\n`);
-    for (let i = 0; i < items.length; i++) {
-      const item = items[i];
-      const isCursor = i === cursor;
-      const isSelected = selected.has(i);
-      const pointer = isCursor ? c.cyan("\u25B6") : " ";
-      const check = isSelected ? c.green("\u25C9") : c.gray("\u25CB");
-      const label = isCursor ? c.cyan(item.label) : c.white(item.label);
-      const hint = item.hint ? c.gray(` ${item.hint}`) : "";
-      stdout.write(`  ${pointer} ${check} ${label}${hint}\n`);
-    }
-    stdout.write("\n");
+    render();
 
     stdin.setRawMode(true);
     stdin.resume();
@@ -376,14 +387,14 @@ export async function multiSelect(title, items) {
         stdin.setRawMode(false);
         stdin.removeListener("data", onData);
         stdin.pause();
-        const result = [...selected].map((i) => items[i]);
-        // Clear and show final
-        stdout.write(`\x1b[${items.length + 2}A`);
-        stdout.write(`\x1b[2K  ${c.green("\u2713")} ${c.bold(title)} ${c.cyan(result.map((r) => r.label).join(", "))}\n`);
-        for (let i = 0; i < items.length + 1; i++) {
-          stdout.write(`\x1b[2K\n`);
+        const orderedIndexes = [...selected].sort((a, b) => a - b);
+        const result = orderedIndexes.map((i) => items[i]);
+        stdout.write(`\x1b[${totalLines}A`);
+        for (let i = 0; i < totalLines; i++) {
+          stdout.write("\x1b[2K\n");
         }
-        stdout.write(`\x1b[${items.length + 1}A`);
+        stdout.write(`\x1b[${totalLines}A`);
+        stdout.write(`\x1b[2K  ${c.green("\u2713")} ${c.bold(title)} ${c.cyan(result.map((r) => r.label).join(", "))}\n`);
         resolve(result);
         return;
       }
@@ -444,3 +455,102 @@ export function truncate(str, maxLen = 40) {
   if (str.length <= maxLen) return str;
   return str.slice(0, maxLen - 1) + "\u2026";
 }
+
+/**
+ * Build selected index set preserving original item indexes.
+ * @param {Array<{selected?: boolean}>} items
+ * @returns {Set<number>}
+ */
+export function buildSelectedIndexSet(items) {
+  const indexes = new Set();
+  for (let i = 0; i < items.length; i++) {
+    if (items[i]?.selected) indexes.add(i);
+  }
+  return indexes;
+}
+
+/**
+ * Calculate the visible start/end indexes for long menu lists.
+ * @param {number} total
+ * @param {number} cursor
+ * @param {number} maxVisible
+ * @returns {{start:number,end:number}}
+ */
+export function getVisibleWindow(total, cursor, maxVisible) {
+  if (total <= 0) return { start: 0, end: 0 };
+  if (maxVisible >= total) return { start: 0, end: total };
+
+  const half = Math.floor(maxVisible / 2);
+  let start = cursor - half;
+  let end = start + maxVisible;
+
+  if (start < 0) {
+    start = 0;
+    end = maxVisible;
+  }
+  if (end > total) {
+    end = total;
+    start = total - maxVisible;
+  }
+
+  return { start, end };
+}
+
+/**
+ * Compute the max menu rows based on terminal height.
+ * Leaves room for prompt output and avoids terminal overflow.
+ */
+export function getMaxVisibleMenuItems(termRows = stdout.rows || 24) {
+  const safe = Math.max(6, termRows - 8);
+  return Math.min(20, safe);
+}
+
+function supportsInteractiveMenu() {
+  return Boolean(stdin.isTTY && stdout.isTTY && typeof stdin.setRawMode === "function");
+}
+
+async function selectFallback(title, items) {
+  console.log(`  ${c.cyan("?")} ${c.bold(title)}`);
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    const hint = item.hint ? ` ${c.gray(item.hint)}` : "";
+    console.log(`    ${String(i + 1).padStart(2, " ")}) ${item.label}${hint}`);
+  }
+  const answer = await input("Choose an option number", "1");
+  const idx = clampIndex(parseInt(answer, 10) - 1, items.length);
+  console.log(`  ${c.green("\u2713")} ${c.bold(title)} ${c.cyan(items[idx].label)}`);
+  return items[idx];
+}
+
+async function multiSelectFallback(title, items) {
+  console.log(`  ${c.cyan("?")} ${c.bold(title)}`);
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    const mark = item.selected ? "*" : " ";
+    const hint = item.hint ? ` ${c.gray(item.hint)}` : "";
+    console.log(`    ${String(i + 1).padStart(2, " ")}) [${mark}] ${item.label}${hint}`);
+  }
+  const answer = await input("Choose option numbers (comma-separated)", "1");
+  const indexes = parseMultiNumberInput(answer, items.length);
+  const selected = indexes.map((i) => items[i]);
+  console.log(`  ${c.green("\u2713")} ${c.bold(title)} ${c.cyan(selected.map((it) => it.label).join(", "))}`);
+  return selected;
+}
+
+function clampIndex(idx, length) {
+  if (Number.isNaN(idx) || idx < 0) return 0;
+  if (idx >= length) return length - 1;
+  return idx;
+}
+
+function parseMultiNumberInput(text, length) {
+  const indexes = new Set();
+  for (const rawPart of text.split(",")) {
+    const n = parseInt(rawPart.trim(), 10);
+    if (Number.isNaN(n)) continue;
+    const idx = n - 1;
+    if (idx >= 0 && idx < length) indexes.add(idx);
+  }
+  if (indexes.size === 0) indexes.add(0);
+  return [...indexes].sort((a, b) => a - b);
+}

package/src/lib/ui.test.js

@@ -0,0 +1,41 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { buildSelectedIndexSet, getVisibleWindow, getMaxVisibleMenuItems } from "./ui.js";
+
+test("buildSelectedIndexSet keeps original indexes", () => {
+  const items = [
+    { label: "a", selected: false },
+    { label: "b", selected: true },
+    { label: "c", selected: false },
+    { label: "d", selected: true },
+  ];
+
+  const selected = buildSelectedIndexSet(items);
+  assert.deepEqual([...selected], [1, 3]);
+});
+
+test("buildSelectedIndexSet handles empty selection", () => {
+  const items = [
+    { label: "a" },
+    { label: "b", selected: false },
+  ];
+
+  const selected = buildSelectedIndexSet(items);
+  assert.equal(selected.size, 0);
+});
+
+test("getVisibleWindow keeps cursor centered when possible", () => {
+  const w = getVisibleWindow(100, 50, 10);
+  assert.deepEqual(w, { start: 45, end: 55 });
+});
+
+test("getVisibleWindow clamps to beginning and end", () => {
+  assert.deepEqual(getVisibleWindow(100, 2, 10), { start: 0, end: 10 });
+  assert.deepEqual(getVisibleWindow(100, 98, 10), { start: 90, end: 100 });
+});
+
+test("getMaxVisibleMenuItems enforces safe min/max", () => {
+  assert.equal(getMaxVisibleMenuItems(12), 6);
+  assert.equal(getMaxVisibleMenuItems(40), 20);
+});