opencode-auto-agent 1.0.0 → 1.2.0

package/src/commands/init.js

@@ -1,80 +1,187 @@
 /**
- * init command — scaffold .ai-starter-kit/ into the target repository.
+ * init command — model-aware, interactive scaffolding of the OpenCode agent team.
+ *
+ * Flow:
+ *  1. Validate prerequisites (opencode, ralphy, node)
+ *  2. Discover available models via `opencode models`
+ *  3. Let the user choose a preset
+ *  4. Let the user assign models to each agent role
+ *  5. Scaffold .opencode/ directory with agents, rules, presets, context
+ *  6. Write config.json with full agent-model mapping
+ *  7. Generate opencode.json at project root (with model assignments)
+ *  8. Generate .opencode/agents/*.md from templates (with model frontmatter)
+ *  9. Generate .ralphy/config.yaml stub if missing
+ * 10. Print summary and next steps
  *
  * Rules:
- *  1. Never overwrite files that already exist (safe re-run).
- *  2. Write config.json with schema version for future upgrades.
- *  3. Copy agent markdowns, rules, and selected preset.
- *  4. Create empty context/ folder for runtime context assembly.
+ *  - Never overwrite files that already exist (safe re-run) unless --force
+ *  - Abort if prerequisites fail
+ *  - Do not auto-install anything
  */
 
-import { existsSync, mkdirSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
-import { SCAFFOLD_DIR, CONFIG_FILE, PRESETS, AGENTS, DIRS, SCHEMA_VERSION } from "../lib/constants.js";
+import {
+  SCAFFOLD_DIR, CONFIG_FILE, PRESETS, AGENTS, AGENT_ROLES,
+  DIRS, SCHEMA_VERSION, DEFAULT_MODEL_MAP, WORKFLOW_STEPS,
+} from "../lib/constants.js";
 import { copyDirSync, readJsonSync, writeJsonSync, writeTextSync } from "../lib/fs-utils.js";
+import { validateAndReport } from "../lib/prerequisites.js";
+import { discoverModelsInteractive, findModel, groupByProvider } from "../lib/models.js";
+import {
+  banner, section, status, kv, success, error, c, boxList,
+  select, confirm, table,
+} from "../lib/ui.js";
 
 const __dirname = fileURLToPath(new URL(".", import.meta.url));
 const TEMPLATES_ROOT = resolve(__dirname, "..", "..", "templates");
 
 /**
- * Default config written on first init.
+ * Main init entry point.
+ *
+ * @param {string} targetDir - Project root directory
+ * @param {Object} opts
+ * @param {string} [opts.preset] - Preset name (skips interactive selection)
+ * @param {boolean} [opts.force] - Overwrite existing config
+ * @param {boolean} [opts.nonInteractive] - Skip all prompts, use defaults
  */
-function makeDefaultConfig(preset) {
-  return {
-    $schema: "https://github.com/opencode-auto-agent/config-schema",
-    version: SCHEMA_VERSION,
-    preset: preset || "java",
-    docsPath: "./Docs",
-    tasksPath: "./PRD.md",
-    outputPath: "./",
-    engine: "opencode",
-    agents: AGENTS.reduce((acc, name) => {
-      acc[name] = { enabled: true };
-      return acc;
-    }, {}),
-    orchestrator: {
-      workflowSteps: ["plan", "implement", "test", "verify"],
-      requirePlanApproval: false,
-    },
-  };
-}
+export async function init(targetDir, { preset, force, nonInteractive } = {}) {
+  banner(
+    "OpenCode Auto-Agent Initializer",
+    `Scaffolding an AI agent team into ${targetDir}`
+  );
 
-export async function init(targetDir, { preset } = {}) {
+  // ── Step 1: Prerequisites ────────────────────────────────────────────────
+  section("Prerequisites");
+  validateAndReport({ requireRalphy: false, abortOnFail: true });
+  console.log();
+
+  // ── Step 2: Discover models ──────────────────────────────────────────────
+  section("Model Discovery");
+  const models = discoverModelsInteractive();
+
+  if (models.length === 0) {
+    error(
+      "No models available from OpenCode.",
+      "Configure at least one provider: opencode auth login"
+    );
+    process.exit(1);
+  }
+
+  // Show provider summary
+  const groups = groupByProvider(models);
+  const providerList = [...groups.entries()].map(
+    ([p, ms]) => `${c.bold(p)} ${c.gray(`(${ms.length} models)`)}`
+  );
+  boxList("Available Providers", providerList);
+
+  // ── Step 3: Choose preset ────────────────────────────────────────────────
+  section("Preset Selection");
+  let chosenPreset = preset;
+
+  if (!chosenPreset && !nonInteractive) {
+    const presetItems = PRESETS.map((p) => ({
+      label: p,
+      value: p,
+      hint: presetDescription(p),
+    }));
+    const result = await select("Choose a project preset", presetItems);
+    chosenPreset = result.value;
+  }
+  chosenPreset = chosenPreset && PRESETS.includes(chosenPreset) ? chosenPreset : "java";
+  status("pass", `Preset: ${c.bold(chosenPreset)}`, presetDescription(chosenPreset));
+
+  // ── Step 4: Assign models to agent roles ─────────────────────────────────
+  section("Agent Model Assignment");
+  console.log(`  ${c.gray("Assign a model to each agent role. Defaults are shown.")}`);
+  console.log();
+
+  const modelMapping = {};
+
+  for (const role of AGENTS) {
+    const roleDef = AGENT_ROLES[role];
+    const defaultId = DEFAULT_MODEL_MAP[role];
+    const defaultModel = findModel(models, defaultId);
+
+    if (nonInteractive) {
+      // Use default or first available
+      modelMapping[role] = defaultModel ? defaultModel.id : models[0].id;
+      status("dot", `${padRole(role)} ${c.cyan(modelMapping[role])}`, "(default)");
+      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 result = await select(
+      `Model for ${c.bold(role)} ${c.gray(`\u2014 ${roleDef.description}`)}`,
+      items
+    );
+    modelMapping[role] = result.value;
+  }
+
+  // Show summary table
+  console.log();
+  table(
+    ["Agent Role", "Model", "Mode"],
+    AGENTS.map((role) => [
+      c.bold(role),
+      c.cyan(modelMapping[role]),
+      c.gray(AGENT_ROLES[role].mode),
+    ])
+  );
+
+  // ── Step 5: Confirm ──────────────────────────────────────────────────────
+  if (!nonInteractive) {
+    console.log();
+    const proceed = await confirm("Proceed with this configuration?", true);
+    if (!proceed) {
+      console.log(c.gray("\n  Aborted.\n"));
+      process.exit(0);
+    }
+  }
+
+  // ── Step 6: Scaffold directories ─────────────────────────────────────────
+  section("Scaffolding");
   const scaffoldDir = join(targetDir, SCAFFOLD_DIR);
   const isUpgrade = existsSync(scaffoldDir);
 
   if (isUpgrade) {
-    console.log(`[init] Existing ${SCAFFOLD_DIR}/ detected — upgrading (no overwrites).`);
-  } else {
-    console.log(`[init] Scaffolding ${SCAFFOLD_DIR}/ into ${targetDir}`);
+    status("info", `Existing ${SCAFFOLD_DIR}/ detected \u2014 upgrading (no overwrites)`);
   }
 
-  // 1. Create directory skeleton
   for (const sub of Object.values(DIRS)) {
     mkdirSync(join(scaffoldDir, sub), { recursive: true });
   }
 
-  // 2. Copy agent markdowns (skip existing)
-  const agentsSrc = join(TEMPLATES_ROOT, "agents");
-  const agentsDest = join(scaffoldDir, DIRS.agents);
-  copyDirSync(agentsSrc, agentsDest, { overwrite: false });
-  console.log(`[init] Agents written to ${DIRS.agents}/`);
-
-  // 3. Copy rules (skip existing)
-  const rulesSrc = join(TEMPLATES_ROOT, "rules");
-  const rulesDest = join(scaffoldDir, DIRS.rules);
-  copyDirSync(rulesSrc, rulesDest, { overwrite: false });
-  console.log(`[init] Rules written to ${DIRS.rules}/`);
-
-  // 4. Copy selected preset (or all presets)
-  const presetsSrc = join(TEMPLATES_ROOT, "presets");
-  const presetsDest = join(scaffoldDir, DIRS.presets);
-  copyDirSync(presetsSrc, presetsDest, { overwrite: false });
-  console.log(`[init] Presets written to ${DIRS.presets}/`);
-
-  // 5. Seed empty context readme
+  // Copy template agents (skip existing unless --force)
+  const overwrite = !!force;
+  copyDirSync(join(TEMPLATES_ROOT, "agents"), join(scaffoldDir, DIRS.agents), { overwrite });
+  status("pass", "Agent templates", `${DIRS.agents}/`);
+
+  // Copy rules
+  copyDirSync(join(TEMPLATES_ROOT, "rules"), join(scaffoldDir, DIRS.rules), { overwrite });
+  status("pass", "Rules", `${DIRS.rules}/`);
+
+  // Copy presets
+  copyDirSync(join(TEMPLATES_ROOT, "presets"), join(scaffoldDir, DIRS.presets), { overwrite });
+  status("pass", "Presets", `${DIRS.presets}/`);
+
+  // Seed context readme
   const contextReadme = join(scaffoldDir, DIRS.context, "README.md");
   if (!existsSync(contextReadme)) {
     writeTextSync(
@@ -82,95 +189,176 @@ export async function init(targetDir, { preset } = {}) {
       "# Runtime Context\n\nThis folder is populated at runtime by the orchestrator.\nDo not manually edit files here; they are regenerated on each `run`.\n"
     );
   }
+  status("pass", "Context directory", `${DIRS.context}/`);
 
-  // 6. Write config.json (only if missing)
+  // ── Step 7: Write config.json ────────────────────────────────────────────
   const configPath = join(scaffoldDir, CONFIG_FILE);
-  if (!existsSync(configPath)) {
-    const chosenPreset = preset && PRESETS.includes(preset) ? preset : undefined;
-    writeJsonSync(configPath, makeDefaultConfig(chosenPreset));
-    console.log(`[init] Config written to ${CONFIG_FILE} (preset: ${chosenPreset || "java"})`);
+  if (!existsSync(configPath) || force) {
+    const config = buildProjectConfig(chosenPreset, modelMapping);
+    writeJsonSync(configPath, config);
+    status("pass", "Project config", CONFIG_FILE);
   } else {
-    console.log(`[init] Config already exists — skipped.`);
+    status("info", "Project config already exists \u2014 skipped", CONFIG_FILE);
   }
 
-  // 7. Generate opencode.json at project root if missing
+  // ── Step 8: Generate opencode.json ───────────────────────────────────────
   const opencodeConfig = join(targetDir, "opencode.json");
-  if (!existsSync(opencodeConfig)) {
-    writeJsonSync(opencodeConfig, buildOpencodeConfig());
-    console.log(`[init] Generated opencode.json at project root.`);
+  if (!existsSync(opencodeConfig) || force) {
+    writeJsonSync(opencodeConfig, buildOpencodeJson(modelMapping, chosenPreset));
+    status("pass", "OpenCode config", "opencode.json");
+  } else {
+    status("info", "opencode.json already exists \u2014 skipped");
+  }
+
+  // ── Step 9: Generate agent markdown files with model frontmatter ─────────
+  for (const role of AGENTS) {
+    const agentFile = join(scaffoldDir, DIRS.agents, `${role}.md`);
+    const templateFile = join(TEMPLATES_ROOT, "agents", `${role}.md`);
+    if (existsSync(templateFile) && (!existsSync(agentFile) || force)) {
+      const template = readFileSync(templateFile, "utf8");
+      const patched = patchAgentModelFrontmatter(template, modelMapping[role]);
+      writeTextSync(agentFile, patched);
+    }
   }
+  status("pass", "Agent markdown files updated with model assignments");
 
-  // 8. Generate .ralphy/config.yaml stub if missing
+  // ── Step 10: .ralphy/config.yaml ─────────────────────────────────────────
   const ralphyDir = join(targetDir, ".ralphy");
   const ralphyConfig = join(ralphyDir, "config.yaml");
   if (!existsSync(ralphyConfig)) {
     mkdirSync(ralphyDir, { recursive: true });
     writeTextSync(ralphyConfig, buildRalphyConfig());
-    console.log(`[init] Generated .ralphy/config.yaml`);
+    status("pass", "Ralphy config", ".ralphy/config.yaml");
+  } else {
+    status("info", "Ralphy config already exists \u2014 skipped");
   }
 
-  console.log(`\n[init] Done. Next steps:`);
-  console.log(`  1. Edit ${SCAFFOLD_DIR}/${CONFIG_FILE} to set your preset and paths.`);
-  console.log(`  2. Run: npx opencode-auto-agent doctor`);
-  console.log(`  3. Run: npx opencode-auto-agent run`);
+  // ── Done ─────────────────────────────────────────────────────────────────
+  success("Initialization complete!");
+
+  console.log(`  ${c.bold("Next steps:")}`);
+  console.log(`  ${c.gray("1.")} Edit ${c.cyan(`${SCAFFOLD_DIR}/${CONFIG_FILE}`)} to fine-tune agents and paths`);
+  console.log(`  ${c.gray("2.")} Run  ${c.cyan("npx opencode-auto-agent doctor")} to validate`);
+  console.log(`  ${c.gray("3.")} Run  ${c.cyan("npx opencode-auto-agent run")} to start the orchestrator`);
+  console.log();
 }
 
-// ── helpers ────────────────────────────────────────────────────────────────
+// ── Config builders ────────────────────────────────────────────────────────
 
-function buildOpencodeConfig() {
+function buildProjectConfig(preset, modelMapping) {
   return {
-    $schema: "https://opencode.ai/config.json",
+    $schema: "https://github.com/opencode-auto-agent/config-schema",
+    version: SCHEMA_VERSION,
+    preset,
+    docsPath: "./Docs",
+    tasksPath: "./PRD.md",
+    outputPath: "./",
+    engine: "opencode",
+    models: { ...modelMapping },
+    agents: Object.fromEntries(
+      AGENTS.map((name) => [
+        name,
+        {
+          enabled: true,
+          model: modelMapping[name],
+          mode: AGENT_ROLES[name].mode,
+        },
+      ])
+    ),
+    rules: [
+      `.opencode/rules/universal.md`,
+    ],
     instructions: [
-      ".ai-starter-kit/agents/orchestrator.md",
-      ".ai-starter-kit/rules/universal.md",
+      "AGENTS.md",
+      `.opencode/rules/universal.md`,
     ],
-    agent: {
-      orchestrator: {
-        description: "Primary orchestrator — routes tasks to specialist sub-agents",
-        mode: "primary",
-        prompt: "You are the orchestrator. Read .ai-starter-kit/context/ for active context. Follow the workflow: plan -> implement -> test -> verify.",
-        tools: { "*": true },
-        permission: {
-          task: { "*": "allow" },
-        },
-      },
-      planner: {
-        description: "Architect & planner — breaks objectives into steps",
-        mode: "subagent",
-        prompt: "You are the planner agent. Produce step-by-step implementation plans. Do not write code. Output plans as numbered markdown lists.",
-        tools: { write: false, edit: false, bash: false },
-      },
-      developer: {
-        description: "Developer — writes and edits production code",
-        mode: "subagent",
-        prompt: "You are the developer agent. Implement code changes per the plan. Follow project conventions. Write clean, tested code.",
-        tools: { "*": true },
-      },
-      qa: {
-        description: "QA / Tester — runs tests, verifies correctness",
-        mode: "subagent",
-        prompt: "You are the QA agent. Run tests, check for regressions, verify acceptance criteria. Report pass/fail status clearly.",
-        tools: { write: false },
-        permission: { bash: "allow" },
-      },
-      reviewer: {
-        description: "Code reviewer — reviews for quality, security, performance",
-        mode: "subagent",
-        prompt: "You are the reviewer agent. Review code for correctness, security issues, performance problems, and style violations. Do not make changes.",
-        tools: { write: false, edit: false, bash: false },
-      },
-      docs: {
-        description: "Documentation — keeps docs aligned with code changes",
-        mode: "subagent",
-        prompt: "You are the docs agent. Update documentation to reflect code changes. Keep README, API docs, and inline comments accurate.",
-        tools: { bash: false },
-      },
+    orchestrator: {
+      workflowSteps: WORKFLOW_STEPS,
+      requirePlanApproval: false,
     },
   };
 }
 
+function buildOpencodeJson(modelMapping, preset) {
+  const agents = {};
+  for (const role of AGENTS) {
+    const def = AGENT_ROLES[role];
+    agents[role] = {
+      description: def.description,
+      mode: def.mode,
+      model: modelMapping[role],
+      temperature: def.temperature,
+      prompt: buildAgentPrompt(role, preset),
+      tools: def.tools,
+    };
+    if (Object.keys(def.permission).length > 0) {
+      agents[role].permission = def.permission;
+    }
+  }
+
+  return {
+    $schema: "https://opencode.ai/config.json",
+    model: modelMapping.orchestrator,
+    instructions: [
+      "AGENTS.md",
+      `.opencode/rules/universal.md`,
+    ],
+    agent: agents,
+  };
+}
+
+function buildAgentPrompt(role, preset) {
+  const prompts = {
+    orchestrator:
+      `You are the orchestrator. Read .opencode/context/ for active context. Follow the workflow: plan -> implement -> test -> verify. Preset: ${preset}.`,
+    planner:
+      "You are the planner agent. Produce step-by-step implementation plans. Do not write code. Output plans as numbered markdown lists.",
+    developer:
+      "You are the developer agent. Implement code changes per the plan. Follow project conventions. Write clean, tested code.",
+    qa:
+      "You are the QA agent. Run tests, check for regressions, verify acceptance criteria. Report pass/fail status clearly.",
+    reviewer:
+      "You are the reviewer agent. Review code for correctness, security issues, performance problems, and style violations. Do not make changes.",
+    docs:
+      "You are the docs agent. Update documentation to reflect code changes. Keep README, API docs, and inline comments accurate.",
+  };
+  return prompts[role] || `You are the ${role} agent.`;
+}
+
+/**
+ * Patch the `model:` field in a markdown agent file's YAML frontmatter.
+ * If no model field exists, add one.
+ */
+function patchAgentModelFrontmatter(content, modelId) {
+  // Check if content has YAML frontmatter
+  if (!content.startsWith("---")) return content;
+
+  const endIdx = content.indexOf("---", 3);
+  if (endIdx === -1) return content;
+
+  let frontmatter = content.slice(3, endIdx);
+  const body = content.slice(endIdx);
+
+  if (/^model:/m.test(frontmatter)) {
+    // Replace existing model line
+    frontmatter = frontmatter.replace(/^model:.*$/m, `model: ${modelId}`);
+  } else {
+    // Add model field after description or at the end
+    const lines = frontmatter.split("\n");
+    const descIdx = lines.findIndex((l) => l.startsWith("description:"));
+    if (descIdx >= 0) {
+      lines.splice(descIdx + 1, 0, `model: ${modelId}`);
+    } else {
+      lines.push(`model: ${modelId}`);
+    }
+    frontmatter = lines.join("\n");
+  }
+
+  return `---${frontmatter}${body}`;
+}
+
 function buildRalphyConfig() {
-  return `# Ralphy configuration — generated by opencode-auto-agent
+  return `# Ralphy configuration \u2014 generated by opencode-auto-agent
 project:
   name: ""
   language: ""
@@ -186,5 +374,40 @@ rules:
   - "Follow the plan produced by the planner agent before implementing."
   - "Run tests after every implementation step."
   - "Do not modify files outside the project source tree."
+
+boundaries:
+  never_touch:
+    - ".env"
+    - ".env.*"
+    - "secrets/**"
+    - "**/*.pem"
+    - "**/*.key"
+    - "node_modules/**"
+    - ".git/**"
+    - "dist/**"
+    - "build/**"
+
+capabilities:
+  browser: "auto"
+
+notifications:
+  discord_webhook: ""
+  slack_webhook: ""
+  custom_webhook: ""
 `;
 }
+
+// ── Helpers ────────────────────────────────────────────────────────────────
+
+function presetDescription(name) {
+  const desc = {
+    java: "General Java project (Maven/Gradle)",
+    springboot: "Spring Boot 3.x web application",
+    nextjs: "Next.js 14+ with App Router",
+  };
+  return desc[name] || "";
+}
+
+function padRole(role) {
+  return role.padEnd(14);
+}