cli-five 0.2.17 → 0.2.19

package/README.md

@@ -2,7 +2,7 @@
 
 > **Code Like I'm Five** — scaffold a 5-agent AI team into any repo.
 
-## Two ways to install
+## Three ways to install
 
 ### Full setup (recommended for teams)
 
@@ -27,6 +27,21 @@ copilot plugin install idusortus/cli-five
 
 Installs the 5 agents to your Copilot profile. No project config, no interview — just the agents with the same autonomous contracts shipped by the scaffolded templates.
 
+### Let an agent do it (prompt)
+
+Paste a ready-made prompt into any repo and have your agent install *and verify* cli-five there:
+
+```text
+Install cli-five in this repo for OpenCode and verify it works. Preview with
+`npx -y cli-five@latest init --target opencode --dry-run --yes` first, then run it
+without --dry-run. Confirm all five agents appear in `opencode debug agents`, run a
+live orchestrator->planner delegation smoke test, run `npx -y cli-five@latest doctor`,
+gitignore STATE.md/agent-diary.md/histories/, and leave everything staged without
+committing. Report what you verified.
+```
+
+The full version — platform detection, provider/auth checks, collision preview, stop conditions, and what to report back — is in **[docs/INSTALL_PROMPT.md](docs/INSTALL_PROMPT.md)**. It is generic: use it in any repository, Copilot or OpenCode.
+
 ## Supported platforms
 
 cli-five can scaffold for:
@@ -212,6 +227,8 @@ During `init --full-interview` you can choose the model provider and optionally
 | OpenCode Zen | OpenCode | `opencode/gpt-5.3-codex` |
 | OpenCode Go | OpenCode | `opencode-go/qwen3.8-max` |
 
+**On OpenCode, the default provider is auth-aware.** cli-five checks which provider you are actually authenticated for (`opencode auth list`) and uses it instead of blindly defaulting to OpenCode Zen. If you are authenticated for Go only, `init --target opencode` writes Go models automatically — no `--provider` flag needed. If nothing is detected, or the selected provider does not match your auth, `init` prints a warning telling you how to fix it, so you do not end up with agent files whose models silently fail.
+
 `--yes` uses the provider's defaults. `--provider opencode-go --yes` skips the provider prompt.
 
 ### Copilot cost modes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cli-five",
-  "version": "0.2.17",
+  "version": "0.2.19",
   "description": "Code Like I'm Five — scaffold a 5-agent AI team (GitHub Copilot or OpenCode) into any repo.",
   "type": "module",
   "repository": {

package/src/commands/init.mjs

@@ -13,6 +13,7 @@ import { choosePlatform, chooseModels, resolveCodegraphDefault } from '../steps/
 import { isGitRepo, gitInit } from '../util/git.mjs';
 import { platformLabel } from '../util/platforms.mjs';
 import { autoProjectInfo } from '../util/project.mjs';
+import { detectAuthenticatedProviders } from '../util/auth.mjs';
 
 export async function init(args) {
   const cwd = args.cwd;
@@ -100,7 +101,7 @@ export async function init(args) {
   } else {
     log.step('4/8 Project info');
     docHints = autoProjectInfo(cwd);
-    logAutoProjectInfo(docHints);
+    logAutoProjectInfo(docHints, { yes: args.yes });
 
     log.step('5/8 Model configuration');
     // Minimal path uses provider defaults without prompting (still honours --provider).
@@ -169,20 +170,30 @@ export async function init(args) {
 }
 
 /** Log which project fields were auto-pulled from the workspace. */
-function logAutoProjectInfo(info) {
+function logAutoProjectInfo(info, { yes = false } = {}) {
   const name = info?.name || {};
   const oneLiner = info?.oneLiner || {};
 
   if (name.value && !name.ambiguous) {
     log.info(`Name:    ${kleur.bold(name.value)} ${kleur.gray(`(${name.sources[0].source})`)}`);
   } else if (name.ambiguous) {
-    log.warn(`Multiple project names found (${name.sources.map((s) => s.source).join(', ')}) — asking.`);
+    const picks = name.sources.map((s) => `${s.source}="${s.value}"`).join(', ');
+    if (yes) {
+      log.warn(`Multiple project names found (${picks}); --yes picked "${name.value}".`);
+    } else {
+      log.warn(`Multiple project names found (${picks}) — asking.`);
+    }
   }
 
   if (oneLiner.value && !oneLiner.ambiguous) {
     log.info(`Tagline: ${oneLiner.value} ${kleur.gray(`(${oneLiner.sources[0].source})`)}`);
   } else if (oneLiner.ambiguous) {
-    log.warn(`Multiple descriptions found (${oneLiner.sources.map((s) => s.source).join(', ')}) — asking.`);
+    const picks = oneLiner.sources.map((s) => `${s.source}="${s.value}"`).join(', ');
+    if (yes) {
+      log.warn(`Multiple descriptions found (${picks}); --yes picked ${oneLiner.sources[0].source}.`);
+    } else {
+      log.warn(`Multiple descriptions found (${picks}) — asking.`);
+    }
   }
 }
 
@@ -208,6 +219,19 @@ function printNextSteps(answers, { generatedInstructions = false } = {}) {
     log.raw(`  3. Run OpenCode from this directory:`);
     log.raw(kleur.gray(`        opencode`));
     log.raw(`  4. Select ${kleur.bold('Orchestrator')} and describe what you want built.`);
+
+    // A provider the user is not authenticated for produces agent files whose
+    // models silently fail. Surface that here rather than at first agent use.
+    const authed = detectAuthenticatedProviders();
+    const provider = answers.provider;
+    if (authed.length > 0 && !authed.includes(provider)) {
+      log.raw('');
+      log.warn(`Models use "${provider}", but you are authenticated for: ${authed.join(', ')}.`);
+      log.dim(`  Authenticate with \`opencode auth login\`, or re-run with --provider ${authed[0]}.`);
+    } else if (authed.length === 0) {
+      log.raw('');
+      log.dim(`  Make sure you are authenticated (\`opencode auth login\`) for provider "${provider}".`);
+    }
   } else {
     log.raw(`  1. Open this folder in VS Code Insiders.`);
     log.raw(`  2. Enable Copilot subagent invocations (settings.json):`);

package/src/steps/platform.mjs

@@ -9,6 +9,7 @@ import {
   platformLabel,
 } from '../util/platforms.mjs';
 import { log } from '../util/log.mjs';
+import { detectAuthenticatedProviders, preferredProviderForAuth } from '../util/auth.mjs';
 import {
   agentNames,
   getDefaultModelMap,
@@ -118,10 +119,17 @@ export function detectExistingPlatform(cwd) {
  * override per-agent models.
  */
 export async function chooseModels(platform, args) {
-  // Defaults for the platform.
-  const defaultProvider = providerForPlatform(platform, args.provider);
+  // Defaults for the platform, refined by what the user is actually authed for.
+  const authedProvider = platform === PLATFORM_OPENCODE && !args.provider
+    ? preferredProviderForAuth(platform)
+    : null;
+  const defaultProvider = providerForPlatform(platform, args.provider || authedProvider);
   const defaults = getDefaultModelMap(defaultProvider);
 
+  if (authedProvider && authedProvider !== PROVIDER_ZEN) {
+    log.dim(`Detected authenticated OpenCode provider: ${providerLabel(authedProvider)} (using it instead of the ${providerLabel(PROVIDER_ZEN)} default).`);
+  }
+
   if (args.yes) {
     return {
       provider: defaultProvider,
@@ -206,23 +214,27 @@ async function chooseProvider(platform, cliProvider) {
     return PROVIDER_COPILOT;
   }
 
+  const authed = detectAuthenticatedProviders();
+  const isAuthed = (p) => authed.includes(p);
+  const annotate = (p, label, description) => ({
+    title: isAuthed(p) ? `${label} ${kleur.green('(authenticated)')}` : label,
+    value: p,
+    description,
+  });
+
+  const choices = [
+    annotate(PROVIDER_ZEN, providerLabel(PROVIDER_ZEN), 'Curated, tested models via OpenCode Zen'),
+    annotate(PROVIDER_GO, 'OpenCode Go', 'Low-cost open-coding model subscription'),
+  ];
+  // Put an authenticated provider first so the default is one that works.
+  const initial = Math.max(0, choices.findIndex((c) => isAuthed(c.value)));
+
   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,
+    choices,
+    initial,
   });
 
   if (!provider) {

package/src/util/auth.mjs

@@ -0,0 +1,85 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { PROVIDER_ZEN, PROVIDER_GO } from './models.mjs';
+
+// OpenCode auth provider id -> cli-five provider id.
+// Zen authenticates as `opencode`; Go as `opencode-go`.
+const AUTH_ID_TO_PROVIDER = {
+  opencode: PROVIDER_ZEN,
+  'opencode-go': PROVIDER_GO,
+};
+
+/**
+ * Detect which OpenCode model providers the user is actually authenticated for.
+ *
+ * Best-effort and side-effect free: shells out to `opencode auth list --format json`
+ * and falls back to reading OpenCode's auth.json. Returns an array of cli-five
+ * provider ids (e.g. ['opencode-go']); empty when nothing is detected.
+ *
+ * Never throws — a missing OpenCode CLI or unreadable auth must not break init.
+ */
+export function detectAuthenticatedProviders() {
+  for (const ids of [authFromCli(), authFromFile()]) {
+    if (ids && ids.length > 0) return ids;
+  }
+  return [];
+}
+
+function authFromCli() {
+  try {
+    const out = execFileSync('opencode', ['auth', 'list', '--format', 'json'], {
+      stdio: ['ignore', 'pipe', 'ignore'],
+      encoding: 'utf8',
+      timeout: 5000,
+    });
+    const parsed = JSON.parse(out);
+    if (!Array.isArray(parsed)) return null;
+    return parsed
+      .map((entry) => AUTH_ID_TO_PROVIDER[entry?.id])
+      .filter(Boolean);
+  } catch {
+    return null;
+  }
+}
+
+function authFromFile() {
+  const candidates = [
+    process.env.OPENCODE_AUTH_FILE,
+    join(homedir(), '.local', 'share', 'opencode', 'auth.json'),
+    join(process.env.XDG_DATA_HOME || '', 'opencode', 'auth.json'),
+  ].filter(Boolean);
+
+  for (const path of candidates) {
+    if (!existsSync(path)) continue;
+    try {
+      const data = JSON.parse(readFileSync(path, 'utf8'));
+      return Object.keys(data)
+        .map((id) => AUTH_ID_TO_PROVIDER[id])
+        .filter(Boolean);
+    } catch {
+      /* try next */
+    }
+  }
+  return null;
+}
+
+/**
+ * Pick the best provider for a platform given what the user is authenticated for.
+ *
+ * For OpenCode: prefer the authenticated provider when there is one; when the
+ * user has only Go (or only Zen), use it instead of the blind Zen default.
+ * Returns null when no preference can be inferred (caller keeps its default).
+ */
+export function preferredProviderForAuth(platform) {
+  if (platform !== 'opencode') return null;
+  const authed = detectAuthenticatedProviders();
+  if (authed.length === 0) return null;
+  // Prefer Go when both are present only if Zen is absent — otherwise Zen.
+  if (authed.includes(PROVIDER_ZEN)) return PROVIDER_ZEN;
+  if (authed.includes(PROVIDER_GO)) return PROVIDER_GO;
+  return null;
+}
+
+export const __testables = { authFromCli, authFromFile, AUTH_ID_TO_PROVIDER };