opencode-auto-agent 1.3.0 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-auto-agent",
-  "version": "1.3.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",

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/ui.js

@@ -246,23 +246,33 @@ export async function select(title, items) {
 
   return new Promise((resolve) => {
     let cursor = 0;
-    const totalLines = items.length + 1;
+    const maxVisible = getMaxVisibleMenuItems();
+    const totalLines = Math.min(items.length, maxVisible) + 2;
     let hasRendered = false;
 
     const render = () => {
+      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)}\n`);
-      for (let i = 0; i < items.length; i++) {
-        const item = items[i];
-        const isSelected = i === cursor;
+      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(`\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;
     };
 
@@ -328,26 +338,35 @@ export async function multiSelect(title, items) {
   return new Promise((resolve) => {
     let cursor = 0;
     const selected = buildSelectedIndexSet(items);
-    const totalLines = items.length + 2;
+    const maxVisible = getMaxVisibleMenuItems();
+    const totalLines = Math.min(items.length, maxVisible) + 2;
     let hasRendered = false;
 
     const render = () => {
+      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, 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);
+      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;
     };
 
@@ -450,6 +469,42 @@ export function buildSelectedIndexSet(items) {
   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");
 }

package/src/lib/ui.test.js

@@ -1,7 +1,7 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 
-import { buildSelectedIndexSet } from "./ui.js";
+import { buildSelectedIndexSet, getVisibleWindow, getMaxVisibleMenuItems } from "./ui.js";
 
 test("buildSelectedIndexSet keeps original indexes", () => {
   const items = [
@@ -24,3 +24,18 @@ test("buildSelectedIndexSet handles empty selection", () => {
   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);
+});