cli-five 0.2.13 → 0.2.16

package/src/steps/platform.mjs

@@ -0,0 +1,239 @@
+import kleur from 'kleur';
+import prompts from 'prompts';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import {
+  PLATFORM_COPILOT,
+  PLATFORM_OPENCODE,
+  PLATFORMS,
+  platformLabel,
+} from '../util/platforms.mjs';
+import { log } from '../util/log.mjs';
+import {
+  agentNames,
+  getDefaultModelMap,
+  getModelCatalog,
+  normalizeProvider,
+  providerForPlatform,
+  providerLabel,
+  PROVIDER_COPILOT,
+  PROVIDER_ZEN,
+  PROVIDERS,
+} from '../util/models.mjs';
+
+const CUSTOM_SENTINEL = '__custom__';
+
+/**
+ * Resolve whether CodeGraph should be enabled when no explicit `--codegraph`
+ * / `--no-codegraph` value was passed.
+ *
+ * The registration/opt-out mechanism is unchanged — this only decides the
+ * default: on for the full interview, off for minimal init.
+ */
+export function resolveCodegraphDefault(args, fullInterview) {
+  if (args.codegraph === true || args.codegraph === false) return args.codegraph;
+  return Boolean(fullInterview);
+}
+
+/**
+ * Ask the user to choose a target platform.
+ * If args.target is a valid platform, skip the prompt.
+ *
+ * Options:
+ *   autoDetect   — infer the platform from an existing scaffold before prompting
+ *   askCodegraph — whether to ask the CodeGraph opt-out question (full interview)
+ *   codegraphDefault — resolved default when no explicit flag was passed
+ *
+ * Note: CodeGraph registration and the `--no-codegraph` opt-out are unchanged;
+ * this only controls whether the question is asked / what the default is.
+ */
+export async function choosePlatform(args, { autoDetect = false, askCodegraph = true, codegraphDefault } = {}) {
+  if (codegraphDefault === undefined) codegraphDefault = args.codegraph !== false;
+
+  if (args.target) {
+    const t = String(args.target).toLowerCase();
+    if (PLATFORMS.includes(t)) {
+      return { platform: t, codegraph: codegraphDefault };
+    }
+  }
+
+  if (autoDetect) {
+    const existing = detectExistingPlatform(args.cwd);
+    if (existing) {
+      log.dim(`Detected existing ${platformLabel(existing)} scaffold.`);
+      return { platform: existing, codegraph: codegraphDefault };
+    }
+  }
+
+  if (args.yes) {
+    return { platform: PLATFORM_COPILOT, codegraph: codegraphDefault };
+  }
+
+  const { platform } = await prompts({
+    type: 'select',
+    name: 'platform',
+    message: 'Target platform',
+    choices: [
+      {
+        title: 'GitHub Copilot',
+        value: PLATFORM_COPILOT,
+        description: 'VS Code / Copilot Chat agent customization files',
+      },
+      {
+        title: 'OpenCode',
+        value: PLATFORM_OPENCODE,
+        description: 'OpenCode project agents + opencode.json',
+      },
+    ],
+    initial: 0,
+  });
+
+  if (!platform) {
+    throw new Error('Platform selection cancelled. Nothing was written.');
+  }
+
+  if (!askCodegraph) {
+    return { platform, codegraph: codegraphDefault };
+  }
+
+  const { codegraph } = await prompts({
+    type: 'confirm',
+    name: 'codegraph',
+    message: `Add CodeGraph MCP + instructions for ${platformLabel(platform)}?`,
+    initial: true,
+  });
+
+  return { platform, codegraph: codegraph !== false };
+}
+
+/** Infer an existing scaffold's platform, or null when there is no scaffold. */
+export function detectExistingPlatform(cwd) {
+  if (existsSync(join(cwd, '.opencode', 'agents'))) return PLATFORM_OPENCODE;
+  if (existsSync(join(cwd, '.github', 'agents', 'orchestrator.agent.md'))) return PLATFORM_COPILOT;
+  return null;
+}
+
+/**
+ * Ask the user whether to customize models, pick a provider, and optionally
+ * override per-agent models.
+ */
+export async function chooseModels(platform, args) {
+  // Defaults for the platform.
+  const defaultProvider = providerForPlatform(platform, args.provider);
+  const defaults = getDefaultModelMap(defaultProvider);
+
+  if (args.yes) {
+    return {
+      provider: defaultProvider,
+      modelMap: defaults,
+      customized: false,
+    };
+  }
+
+  const { customize } = await prompts({
+    type: 'confirm',
+    name: 'customize',
+    message: 'Customize agent models?',
+    initial: false,
+  });
+
+  if (!customize) {
+    return {
+      provider: defaultProvider,
+      modelMap: defaults,
+      customized: false,
+    };
+  }
+
+  const provider = await chooseProvider(platform, args.provider);
+  const baseMap = getDefaultModelMap(provider);
+
+  // Show defaults and ask which agents to override.
+  log.raw(kleur.dim('\n  Default models:'));
+  for (const agent of agentNames()) {
+    log.raw(kleur.dim(`    ${agent.padEnd(14)} → ${baseMap[agent]}`));
+  }
+
+  const { overrideAgents } = await prompts({
+    type: 'multiselect',
+    name: 'overrideAgents',
+    message: 'Select agents whose model you want to change',
+    choices: agentNames().map((name) => ({ title: name, value: name })),
+    hint: 'Space to toggle, Enter to confirm',
+  });
+
+  const modelMap = { ...baseMap };
+
+  if (overrideAgents && overrideAgents.length > 0) {
+    const catalog = getModelCatalog(provider);
+    const choices = buildModelChoices(catalog);
+
+    for (const agent of overrideAgents) {
+      const { model } = await prompts({
+        type: 'select',
+        name: 'model',
+        message: `Model for ${agent}`,
+        choices,
+        initial: 0,
+      });
+
+      if (model === CUSTOM_SENTINEL) {
+        const { custom } = await prompts({
+          type: 'text',
+          name: 'custom',
+          message: `Custom model for ${agent}`,
+          initial: baseMap[agent],
+        });
+        if (custom) modelMap[agent] = custom.trim();
+      } else if (model) {
+        modelMap[agent] = model;
+      }
+    }
+  }
+
+  return { provider, modelMap, customized: true };
+}
+
+async function chooseProvider(platform, cliProvider) {
+  if (cliProvider) {
+    const normalized = normalizeProvider(cliProvider);
+    if (platform === PLATFORM_OPENCODE || normalized === PROVIDER_COPILOT) {
+      return normalized;
+    }
+  }
+
+  if (platform === PLATFORM_COPILOT) {
+    return PROVIDER_COPILOT;
+  }
+
+  const { provider } = await prompts({
+    type: 'select',
+    name: 'provider',
+    message: 'OpenCode model provider',
+    choices: [
+      {
+        title: providerLabel(PROVIDER_ZEN),
+        value: PROVIDER_ZEN,
+        description: 'Curated, tested models via OpenCode Zen',
+      },
+      {
+        title: 'OpenCode Go',
+        value: 'opencode-go',
+        description: 'Low-cost open-coding model subscription',
+      },
+    ],
+    initial: 0,
+  });
+
+  if (!provider) {
+    throw new Error('Provider selection cancelled. Nothing was written.');
+  }
+
+  return provider;
+}
+
+function buildModelChoices(catalog) {
+  const choices = catalog.map((id) => ({ title: id, value: id }));
+  choices.push({ title: kleur.dim('Type custom model...'), value: CUSTOM_SENTINEL });
+  return choices;
+}

package/src/steps/scaffold.mjs

@@ -1,20 +1,14 @@
 import { join } from 'node:path';
 import { log } from '../util/log.mjs';
-import { readTemplate, render, writeFile, listFilesRecursive, relTo } from '../util/fs.mjs';
-import { templatePath } from '../util/fs.mjs';
+import { readTemplate, render, writeFile, listFilesRecursive, relTo, templatePath } from '../util/fs.mjs';
 import { readFileSync } from 'node:fs';
+import { PLATFORM_COPILOT, PLATFORM_OPENCODE, agentDirFor, agentFileFor } from '../util/platforms.mjs';
 
-const AGENT_FILES = [
-  'orchestrator.agent.md',
-  'planner.agent.md',
-  'coder.agent.md',
-  'designer.agent.md',
-  'reviewer.agent.md',
-];
-
+const AGENT_NAMES = ['orchestrator', 'planner', 'coder', 'designer', 'reviewer'];
 const HISTORY_FILES = ['orchestrator.md', 'planner.md', 'coder.md', 'designer.md', 'reviewer.md'];
 
-const MODEL_MAP = {
+// Legacy cost-mode maps for GitHub Copilot (used when models are not customized).
+const COPILOT_COST_MODE_MAP = {
   premium: {
     Orchestrator: 'Claude Sonnet 4.6 (copilot)',
     Planner: 'Claude Opus 4.6 (copilot)',
@@ -39,21 +33,55 @@ const MODEL_MAP = {
 };
 
 export function scaffold({ cwd, answers, args }) {
+  const platform = answers.platform || PLATFORM_COPILOT;
   const vars = buildVars(answers);
   const written = [];
 
-  // Agents (with model swap per cost mode)
-  for (const file of AGENT_FILES) {
+  if (platform === PLATFORM_OPENCODE) {
+    written.push(...scaffoldOpenCode({ cwd, answers, args, vars }));
+  } else {
+    written.push(...scaffoldCopilot({ cwd, answers, args, vars }));
+  }
+
+  // Shared memory primitives
+  for (const tmpl of [
+    'AGENTS.md.tmpl',
+    'PROJECT.md.tmpl',
+    'STATE.md.tmpl',
+    'decisions.md.tmpl',
+    'agent-diary.md.tmpl',
+  ]) {
+    const out = render(readTemplate(tmpl), vars);
+    const target = tmpl.replace(/\.tmpl$/, '');
+    written.push(writeFile(join(cwd, target), out, args));
+  }
+
+  // Per-agent histories
+  for (const file of HISTORY_FILES) {
+    written.push(writeFile(join(cwd, 'histories', file), readTemplate('histories', file), args));
+  }
+
+  return written;
+}
+
+function scaffoldCopilot({ cwd, answers, args, vars }) {
+  const written = [];
+  const modelByAgent = answers.customizedModels
+    ? answers.modelMap
+    : COPILOT_COST_MODE_MAP[answers.costMode] || COPILOT_COST_MODE_MAP.premium;
+
+  // Agents
+  for (const file of AGENT_NAMES.map((n) => `${n}.agent.md`)) {
     const src = readFileSync(templatePath('.github', 'agents', file), 'utf8');
-    const swapped = swapModel(src, MODEL_MAP[answers.costMode]);
+    const swapped = swapModel(src, modelByAgent);
     written.push(writeFile(join(cwd, '.github', 'agents', file), swapped, args));
   }
 
-  // copilot-instructions.md (templated)
+  // copilot-instructions.md
   const ci = render(readTemplate('.github', 'copilot-instructions.md.tmpl'), vars);
   written.push(writeFile(join(cwd, '.github', 'copilot-instructions.md'), ci, args));
 
-  // Empty containers ready for /agent-customization
+  // Empty containers
   written.push(
     writeFile(
       join(cwd, '.github', 'instructions', 'README.md'),
@@ -65,28 +93,85 @@ export function scaffold({ cwd, answers, args }) {
     writeFile(join(cwd, '.github', 'skills', 'README.md'), readTemplate('.github', 'skills', 'README.md'), args),
   );
 
-  // Project root memory primitives (GSD-inspired)
-  for (const tmpl of [
-    'AGENTS.md.tmpl',
-    'PROJECT.md.tmpl',
-    'STATE.md.tmpl',
-    'decisions.md.tmpl',
-    'agent-diary.md.tmpl',
-  ]) {
-    const out = render(readTemplate(tmpl), vars);
-    const target = tmpl.replace(/\.tmpl$/, '');
-    written.push(writeFile(join(cwd, target), out, args));
+  // CodeGraph MCP for VS Code Copilot
+  if (answers.codegraph) {
+    written.push(writeFile(join(cwd, '.vscode', 'mcp.json'), JSON.stringify(codegraphMcpJson(), null, 2), args));
   }
 
-  // Per-agent histories
-  for (const file of HISTORY_FILES) {
-    written.push(writeFile(join(cwd, 'histories', file), readTemplate('histories', file), args));
+  return written;
+}
+
+function scaffoldOpenCode({ cwd, answers, args, vars }) {
+  const written = [];
+  const modelByAgent = answers.modelMap || {};
+  const orchestratorModel = modelByAgent.Orchestrator || 'opencode/gpt-5.3-codex';
+
+  // Agents
+  for (const name of AGENT_NAMES) {
+    const src = readFileSync(templatePath('opencode', 'agents', `${name}.md`), 'utf8');
+    const swapped = swapModel(src, modelByAgent);
+    written.push(writeFile(join(cwd, '.opencode', 'agents', `${name}.md`), swapped, args));
   }
 
+  // opencode.json
+  const opencodeConfig = buildOpencodeConfig({ answers, orchestratorModel });
+  written.push(writeFile(join(cwd, 'opencode.json'), JSON.stringify(opencodeConfig, null, 2) + '\n', args));
+
+  // Empty containers (still useful for OpenCode agents)
+  written.push(
+    writeFile(
+      join(cwd, '.github', 'instructions', 'README.md'),
+      readTemplate('.github', 'instructions', 'README.md'),
+      args,
+    ),
+  );
+  written.push(
+    writeFile(join(cwd, '.github', 'skills', 'README.md'), readTemplate('.github', 'skills', 'README.md'), args),
+  );
+
   return written;
 }
 
+function buildOpencodeConfig({ answers, orchestratorModel }) {
+  const smallModel = answers.provider === 'opencode-go'
+    ? 'opencode-go/qwen3.8-flash'
+    : 'opencode/gpt-5-nano';
+
+  const config = {
+    $schema: 'https://opencode.ai/config.json',
+    model: orchestratorModel,
+    small_model: smallModel,
+    subagent_depth: 2,
+  };
+
+  if (answers.codegraph) {
+    config.mcp = {
+      codegraph: {
+        type: 'local',
+        command: ['codegraph', 'serve', '--mcp'],
+        enabled: true,
+      },
+    };
+  }
+
+  return config;
+}
+
+function codegraphMcpJson() {
+  return {
+    inputs: [],
+    servers: {
+      codegraph: {
+        command: 'codegraph',
+        args: ['serve', '--mcp'],
+      },
+    },
+  };
+}
+
 function buildVars(a) {
+  const codegraphBlock = a.codegraph ? CODEGRAPH_BLOCK : '';
+
   return {
     PROJECT_NAME: a.projectName,
     ONE_LINER: a.oneLiner || 'TODO — write a one-line vision statement.',
@@ -105,17 +190,17 @@ ${a.docs}
 ` : '',
     DATE: new Date().toISOString().slice(0, 10),
     PERSONA_BLOCK: a.snark ? PERSONA_BLOCK : '',
+    CODEGRAPH_BLOCK: codegraphBlock,
   };
 }
 
 function swapModel(src, modelByAgent) {
-  // Replace the YAML `model:` line based on the `name:` immediately above/around it.
   const lines = src.split('\n');
   let agentName = null;
   for (let i = 0; i < lines.length; i++) {
-    const m = /^name:\s*(.+?)\s*$/.exec(lines[i]);
-    if (m) {
-      agentName = m[1];
+    const nameMatch = /^name:\s*(.+?)\s*$/.exec(lines[i]);
+    if (nameMatch) {
+      agentName = nameMatch[1];
       continue;
     }
     if (agentName && /^model:\s*/.test(lines[i])) {
@@ -136,6 +221,22 @@ const PERSONA_BLOCK = `# Persona
 
 `;
 
+const CODEGRAPH_BLOCK = `
+<!-- CODEGRAPH_START -->
+## CodeGraph
+
+This project is configured to use [CodeGraph](https://codegraph.ru) for graph-backed codebase context.
+When you need to understand relationships, call paths, or impacts, use:
+
+\`\`\`
+codegraph explore "<your question>"
+\`\`\`
+
+The CodeGraph MCP server is registered in the project config. Run \`codegraph init\` in this directory
+if the project has not been indexed yet.
+<!-- CODEGRAPH_END -->
+`;
+
 export function summarize(written, cwd) {
   const lines = [];
   for (const w of written) {

package/src/util/agents.mjs

@@ -1,4 +1,5 @@
 import { readFileSync } from 'node:fs';
+import YAML from 'yaml';
 
 export const AGENT_FILES = [
   'orchestrator.agent.md',
@@ -8,6 +9,14 @@ export const AGENT_FILES = [
   'reviewer.agent.md',
 ];
 
+export const OPENCODE_AGENT_FILES = [
+  'orchestrator.md',
+  'planner.md',
+  'coder.md',
+  'designer.md',
+  'reviewer.md',
+];
+
 export const EXPECTED_AGENT_NAMES = {
   'orchestrator.agent.md': 'Orchestrator',
   'planner.agent.md': 'Planner',
@@ -89,6 +98,44 @@ export function validateAgentSource(source, fileName, { requiredMarkers = [] } =
   return errors;
 }
 
+export function validateOpenCodeAgentSource(source, fileName) {
+  const errors = [];
+  const { frontmatter, body } = parseAgentSource(source);
+
+  if (!frontmatter) {
+    return ['missing YAML frontmatter'];
+  }
+
+  for (const key of ['description', 'mode', 'model']) {
+    if (!(key in frontmatter)) {
+      errors.push(`missing frontmatter key: ${key}`);
+    }
+  }
+
+  const mode = String(frontmatter.mode || '').toLowerCase();
+  if (mode && !['primary', 'subagent', 'all'].includes(mode)) {
+    errors.push(`invalid mode: ${frontmatter.mode}`);
+  }
+
+  const expectedMode = fileName === 'orchestrator.md' ? 'primary' : 'subagent';
+  if (mode && mode !== expectedMode && mode !== 'all') {
+    errors.push(`expected mode ${expectedMode}, found ${frontmatter.mode}`);
+  }
+
+  if (fileName === 'orchestrator.md') {
+    const task = frontmatter.permission?.task || frontmatter.permissions?.task;
+    if (!task) {
+      errors.push('orchestrator must declare permission.task for subagents');
+    }
+  }
+
+  if (!body.trim()) {
+    errors.push('agent body must not be empty');
+  }
+
+  return errors;
+}
+
 function requiredFrontmatterKeys(fileName) {
   return fileName === 'orchestrator.agent.md'
     ? ['name', 'description', 'model', 'tools', 'agents']
@@ -96,16 +143,21 @@ function requiredFrontmatterKeys(fileName) {
 }
 
 function parseFrontmatter(block) {
-  const out = {};
-  for (const rawLine of block.split('\n')) {
-    const line = rawLine.trim();
-    if (!line) continue;
-    const match = /^([A-Za-z-]+):\s*(.+)$/.exec(line);
-    if (!match) continue;
-    const [, key, rawValue] = match;
-    out[key] = parseFrontmatterValue(rawValue.trim());
-  }
-  return out;
+  try {
+    return YAML.parse(block, { strict: false });
+  } catch {
+    // Fall back to the legacy line parser for simple Copilot frontmatter.
+    const out = {};
+    for (const rawLine of block.split('\n')) {
+      const line = rawLine.trim();
+      if (!line) continue;
+      const match = /^([A-Za-z-]+):\s*(.+)$/.exec(line);
+      if (!match) continue;
+      const [, key, rawValue] = match;
+      out[key] = parseFrontmatterValue(rawValue.trim());
+    }
+    return out;
+  }
 }
 
 function parseFrontmatterValue(rawValue) {
@@ -134,4 +186,4 @@ function parseArrayValue(rawValue) {
       }
       return part;
     });
-}
+}