orchestrator-workflow 0.25.0 → 0.26.0

package/dist/cli-inputs.js

@@ -0,0 +1,253 @@
+import inquirer from "inquirer";
+import { HARNESSES, parseHarnessOption } from "./detect.js";
+import { CLASS_MODELS, DEFAULT_MODELS, DEFAULT_PROFILE, MODEL_ALIASES, MODEL_CLASSES, assertValidModelId, parseModelsSpec, parseProfile, rolesForProfile, } from "./models.js";
+import { detectProvider, loadOpencodeCatalog, resolveAlias, resolveOpencodeModels, } from "./opencode.js";
+export async function promptHarnesses(detected, installed, fallbackToClaude = true) {
+    const known = [...new Set([...detected, ...installed])];
+    // Nothing detected and nothing previously installed: the plain-first-run
+    // case pre-checks `claude` as a sane default (`fallbackToClaude`'s default
+    // `true`). The templates-only re-run branch below opts OUT of that
+    // (`fallbackToClaude: false`): a repo the operator explicitly recorded as
+    // `harnesses: []` has no harness files by construction, so `detected` is
+    // always empty there too, and pre-checking `claude` on Enter would
+    // silently re-widen an explicit `--harness none` install -- contradicting
+    // README.md's and this function's own "nothing forced pre-selected" claim
+    // (see CHANGELOG).
+    const preselected = known.length > 0 ? known : fallbackToClaude ? ["claude"] : [];
+    const { harnesses } = await inquirer.prompt([
+        {
+            type: "checkbox",
+            name: "harnesses",
+            message: "Install adapters for which harnesses? (deselect all for templates only, no harness)",
+            choices: HARNESSES.map((harness) => ({
+                name: harness + (detected.includes(harness) ? " (detected)" : ""),
+                value: harness,
+                checked: preselected.includes(harness),
+            })),
+            // An empty selection is a supported state
+            // (`--harness none`, templates-only mode): it used to be rejected
+            // here because every install always wrote at least one harness
+            // adapter; there is no longer a reason to require one.
+        },
+    ]);
+    return harnesses;
+}
+export async function promptProfile(base) {
+    // Labels are derived from rolesForProfile so a future role addition (like
+    // the advisor role) shows up here automatically instead of silently
+    // falling out of sync with the roles the profile actually installs.
+    const fullRoles = rolesForProfile("full").join(", ");
+    const minimalRoles = rolesForProfile("minimal").join(", ");
+    const { profile } = await inquirer.prompt([
+        {
+            type: "list",
+            name: "profile",
+            message: "Which subagent roles should be installed?",
+            default: base,
+            choices: [
+                {
+                    name: `full — ${fullRoles} (default)`,
+                    value: "full",
+                },
+                {
+                    name: `minimal — ${minimalRoles} only (reviewer is never optional)`,
+                    value: "minimal",
+                },
+            ],
+        },
+    ]);
+    return profile;
+}
+export async function promptModels(base, roles) {
+    const models = { ...base };
+    for (const role of roles) {
+        const { choice } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "choice",
+                message: `Model for the ${role} subagent:`,
+                default: models[role],
+                choices: [
+                    ...MODEL_ALIASES.map((alias) => ({
+                        name: alias === DEFAULT_MODELS[role] ? `${alias} (default)` : alias,
+                        value: alias,
+                    })),
+                    { name: "custom model id", value: "__custom__" },
+                ],
+            },
+        ]);
+        if (choice === "__custom__") {
+            const { custom } = await inquirer.prompt([
+                {
+                    type: "input",
+                    name: "custom",
+                    message: `Custom model id for ${role}:`,
+                    validate: (value) => {
+                        try {
+                            assertValidModelId(value.trim());
+                            return true;
+                        }
+                        catch (error) {
+                            return error instanceof Error ? error.message : String(error);
+                        }
+                    },
+                },
+            ]);
+            models[role] = custom.trim();
+        }
+        else {
+            models[role] = choice;
+        }
+    }
+    return models;
+}
+/**
+ * Resolves everything `runInit` needs (harnesses, profile, models, tiers,
+ * the opencode model resolutions) from the CLI-parsed options, the target
+ * directory, whether the session is interactive, and the previously
+ * installed manifest. Used by `init`'s action today, and reusable by a
+ * later `apply --target` command without duplicating this logic.
+ *
+ * Every override-vs-persist rule below matches `init`'s pre-extraction
+ * behaviour: an explicit flag always overrides; a plain re-run (flag
+ * omitted) keeps the previously installed value; a fresh install with no
+ * prior manifest falls back to the shipped default.
+ */
+export async function resolveInitInputs(params) {
+    const { detected, interactive, previous, opts, previousIsRecordedManifest } = params;
+    let harnesses;
+    if (opts.harness) {
+        harnesses = parseHarnessOption(opts.harness);
+    }
+    else if (previousIsRecordedManifest &&
+        previous &&
+        previous.harnessesRecordedEmpty) {
+        // A recorded previous manifest with harnesses: [] was an explicit
+        // --harness none (templates-only) install. A plain non-interactive
+        // re-run (no --harness flag) must stay templates-only rather than
+        // falling back to filesystem detection and silently installing a
+        // harness (e.g. claude) the operator never asked for; adding one back
+        // requires an explicit --harness on this run, the same
+        // override-vs-persist rule --profile/--models/--tiers already use,
+        // just applied to the "no harnesses" case specifically.
+        // `harnessesRecordedEmpty` gates this on the raw JSON's `harnesses`
+        // field having actually been an empty array: a missing/malformed field,
+        // or an array whose every entry failed the known-harness filter (e.g.
+        // ["cursor"], all-unknown names), also sanitizes to
+        // `harnesses.length === 0` (readInstalledManifest in init.ts) but must
+        // fall through to detection below instead, the same as any other
+        // damaged manifest (see CHANGELOG).
+        //
+        // An interactive re-run is different: stickiness only protects a
+        // non-interactive call (`--yes`, or any other flow with no prompt) from
+        // silently widening an explicit "none" back out; an interactive session
+        // can already ask and let the operator decide, so it still prompts here
+        // instead of skipping straight to templates-only. `installed` is passed
+        // as `[]` (not the recorded `previous.harnesses`) so nothing is
+        // pre-checked, unlike the "else" branch below's normal re-run prompt --
+        // the previous run explicitly asked for none, so the checkbox starts
+        // from that state, only `detected` entries pre-checked. `fallbackToClaude:
+        // false` closes the same gap for the case where nothing is detected
+        // either: without it, `promptHarnesses` would pre-check `claude` on its
+        // own "nothing known" fallback, re-widening the install on a bare Enter.
+        harnesses = interactive ? await promptHarnesses(detected, [], false) : [];
+    }
+    else {
+        const installed = previous?.harnesses ?? [];
+        const fallback = [...new Set([...detected, ...installed])];
+        harnesses = interactive
+            ? await promptHarnesses(detected, installed)
+            : fallback.length > 0
+                ? fallback
+                : ["claude"];
+    }
+    // Explicit --profile always overrides; a plain re-run keeps the
+    // profile from the previous install (same override-vs-persist rule as
+    // --harness/--models above); a fresh install with no prior manifest
+    // defaults to full.
+    let profile;
+    if (opts.profile) {
+        profile = parseProfile(opts.profile);
+    }
+    else {
+        profile = previous?.profile ?? DEFAULT_PROFILE;
+        if (interactive)
+            profile = await promptProfile(profile);
+    }
+    let models = {
+        ...DEFAULT_MODELS,
+        ...(previous?.models ?? {}),
+    };
+    if (opts.models)
+        models = parseModelsSpec(opts.models, models);
+    if (interactive && !opts.models)
+        models = await promptModels(models, rolesForProfile(profile));
+    // Explicit --tiers/--no-tiers always override; a plain re-run (neither
+    // flag passed) keeps whatever the previous install had (default false
+    // for a fresh install), same override-vs-persist rule as
+    // --profile/--models above. commander's negatable-option pairing
+    // (--tiers / --no-tiers declared under the same "tiers" option name)
+    // resolves opts.tiers to `true` when --tiers is passed, `false` when
+    // --no-tiers is passed, and `undefined` when neither is passed; the
+    // CLI re-run test verifies this against the installed commander
+    // version rather than assuming it. No interactive prompt: tiers is
+    // opt-in/off via the flags only.
+    const tiers = opts.tiers ?? previous?.tiers ?? false;
+    // Resolve opencode model aliases against the live catalog when the opencode
+    // harness is selected. The shell-out stays reachable only from this
+    // resolution step, keeping runInit pure.
+    let opencodeModels;
+    let opencodeClassModels;
+    const warnings = [];
+    if (harnesses.includes("opencode")) {
+        const catalog = loadOpencodeCatalog();
+        const { resolved, warnings: modelWarnings } = resolveOpencodeModels(models, {
+            catalog,
+            explicitProvider: opts.opencodeProvider,
+        });
+        opencodeModels = resolved;
+        for (const w of modelWarnings) {
+            warnings.push(`Warning: ${w}`);
+        }
+        if (tiers) {
+            const providerResult = detectProvider({
+                catalog,
+                explicit: opts.opencodeProvider,
+            });
+            opencodeClassModels = {};
+            for (const modelClass of MODEL_CLASSES) {
+                const alias = CLASS_MODELS[modelClass];
+                const resolvedModel = providerResult.provider
+                    ? resolveAlias(providerResult.provider, alias, catalog)
+                    : undefined;
+                opencodeClassModels[modelClass] = resolvedModel;
+                if (resolvedModel !== undefined)
+                    continue;
+                // One warning per unresolved model class: without it, every
+                // effort-tier variant keyed to this class is silently skipped
+                // (init.ts skips the variant write entirely when the class
+                // model is unresolved), with nothing on stderr saying why.
+                const reason = providerResult.provider
+                    ? `provider "${providerResult.provider}" has no "${alias}" model in the catalog`
+                    : providerResult.ambiguous
+                        ? `multiple providers offer Claude models in the live catalog; cannot auto-detect`
+                        : `no provider offering Claude models found in the live catalog`;
+                // States the real effect (no variant file at all, not just a
+                // missing model: line, since init.ts skips the write entirely
+                // when the class never resolves) and the real scope (opencode
+                // only: Claude Code variants resolve model: from a plain alias
+                // and need no live catalog lookup, so they are unaffected).
+                warnings.push(`Warning: Tier model class "${modelClass}" (alias "${alias}") could not be resolved to an opencode model id (${reason}); no opencode effort-tier variant files will be rendered for this class (Claude Code variants are unaffected).`);
+            }
+        }
+    }
+    return {
+        harnesses,
+        profile,
+        models,
+        tiers,
+        opencodeModels,
+        opencodeClassModels,
+        warnings,
+    };
+}