@smithers-orchestrator/cli 0.20.4 → 0.21.0

package/src/agent-detection.js

@@ -27,10 +27,26 @@ const DETECTORS = [
         apiKeys: ["OPENAI_API_KEY"],
         setupHint: "Install the Codex CLI and run `codex login`, or set `OPENAI_API_KEY`.",
     },
+    {
+        id: "antigravity",
+        displayName: "Antigravity",
+        binary: "agy",
+        authSignals: (homeDir, env) => {
+            const configRoot = env.GEMINI_DIR ? resolve(env.GEMINI_DIR) : join(homeDir, ".gemini");
+            return [
+                join(configRoot, "antigravity-cli", "settings.json"),
+                join(configRoot, "antigravity-cli"),
+            ];
+        },
+        apiKeys: [],
+        setupHint: "Install the Antigravity CLI, run `agy`, and complete Google Sign-In.",
+    },
     {
         id: "gemini",
         displayName: "Gemini",
         binary: "gemini",
+        deprecated: true,
+        deprecationReason: "Gemini CLI is deprecated for individual/free users; use Antigravity CLI (`agy`) instead.",
         authSignals: (homeDir, env) => {
             const configDir = env.GEMINI_DIR ? resolve(env.GEMINI_DIR) : join(homeDir, ".gemini");
             return [
@@ -44,7 +60,7 @@ const DETECTORS = [
             const trustFile = join(configDir, "trustedFolders.json");
             return readGeminiProjectTrust(trustFile, cwd);
         },
-        setupHint: "Install the Gemini CLI, authenticate it, and trust this project with Gemini, or set `GEMINI_API_KEY` after installing the CLI.",
+        setupHint: "Gemini CLI is deprecated. Install Antigravity CLI and run `agy`, or continue using Gemini only for legacy/enterprise setups.",
     },
     {
         id: "pi",
@@ -78,10 +94,10 @@ const DETECTORS = [
 ];
 const ROLE_PREFERENCES = {
     spec: ["claude", "codex"],
-    research: ["gemini", "kimi", "codex", "claude"],
-    plan: ["gemini", "codex", "claude", "kimi"],
-    implement: ["codex", "amp", "gemini", "claude", "kimi"],
-    validate: ["codex", "amp", "gemini"],
+    research: ["antigravity", "kimi", "codex", "claude"],
+    plan: ["antigravity", "codex", "claude", "kimi"],
+    implement: ["codex", "amp", "antigravity", "claude", "kimi"],
+    validate: ["codex", "amp", "antigravity"],
     review: ["claude", "amp", "codex"],
 };
 const AGENT_VARIANTS = [
@@ -98,12 +114,28 @@ const AGENT_VARIANTS = [
 const SCAFFOLDED_PROVIDERS = {
     claude: "ClaudeCodeAgent",
     codex: "CodexAgent",
+    antigravity: "AntigravityAgent",
+};
+const SCAFFOLDED_PROVIDER_FILES = {
+    claude: "claude-code",
+    codex: "codex",
+    antigravity: "antigravity",
+};
+const LEGACY_SCAFFOLDED_PROVIDERS = {
     gemini: "GeminiAgent",
 };
+const LOCAL_SCAFFOLDED_PROVIDERS = {
+    ...SCAFFOLDED_PROVIDERS,
+    ...LEGACY_SCAFFOLDED_PROVIDERS,
+};
+const LOCAL_SCAFFOLDED_PROVIDER_FILES = {
+    ...SCAFFOLDED_PROVIDER_FILES,
+    gemini: "gemini",
+};
 const TIER_PREFERENCES = {
-    cheapFast: { order: ["kimi", "claudeSonnet", "gemini", "pi"], maxSize: 2 },
-    smart: { order: ["codex", "claude", "kimi", "gemini", "amp"], maxSize: 3 },
-    smartTool: { order: ["claude", "codex", "kimi", "gemini", "amp"], maxSize: 3 },
+    cheapFast: { order: ["kimi", "claudeSonnet", "antigravity", "pi"], maxSize: 2 },
+    smart: { order: ["codex", "claude", "kimi", "antigravity", "amp"], maxSize: 3 },
+    smartTool: { order: ["claude", "codex", "kimi", "antigravity", "amp"], maxSize: 3 },
 };
 const CONSTRUCTORS = {
     claude: {
@@ -114,6 +146,10 @@ const CONSTRUCTORS = {
         importName: "CodexAgent",
         expr: 'new SmithersCodexAgent({ model: "gpt-5.3-codex", cwd: process.cwd(), skipGitRepoCheck: true })',
     },
+    antigravity: {
+        importName: "AntigravityAgent",
+        expr: "new SmithersAntigravityAgent({ cwd: process.cwd() })",
+    },
     gemini: {
         importName: "GeminiAgent",
         expr: 'new SmithersGeminiAgent({ model: "gemini-3.1-pro-preview", cwd: process.cwd() })',
@@ -131,7 +167,6 @@ const CONSTRUCTORS = {
         expr: "new SmithersAmpAgent()",
     },
 };
-
 /**
  * @param {string} id
  */
@@ -153,6 +188,43 @@ function baseAgentIdForProviderId(id) {
     return variantForId(id)?.derivedFrom ?? id;
 }
 
+/**
+ * Extracts detection-derived provider ids from a generated `.smithers/agents.ts`.
+ * Account labels are deliberately ignored; the accounts registry remains the
+ * source of truth for account-backed providers.
+ *
+ * @param {string} source
+ * @returns {Set<string>}
+ */
+export function extractGeneratedDetectionProviderIds(source) {
+    const ids = new Set();
+    if (!source.startsWith("// smithers-source: generated")) {
+        return ids;
+    }
+    const providersMatch = source.match(/export const providers\s*=\s*{([\s\S]*?)}\s*as const;/);
+    if (!providersMatch) {
+        return ids;
+    }
+    for (const line of providersMatch[1].split("\n")) {
+        const match = line.match(/^\s*([A-Za-z_$][\w$]*)\s*:\s*(.*?)\s*,?\s*$/);
+        if (!match)
+            continue;
+        const [, providerId, initializer] = match;
+        const scaffoldedProvider = SCAFFOLDED_PROVIDERS[providerId] ?? LEGACY_SCAFFOLDED_PROVIDERS[providerId];
+        const constructorProvider = CONSTRUCTORS[providerId];
+        if ((scaffoldedProvider && initializer === scaffoldedProvider) ||
+            (constructorProvider && initializer === constructorProvider.expr)) {
+            ids.add(providerId);
+            continue;
+        }
+        const variant = variantForId(providerId);
+        if (variant && initializer === variant.constructor.expr) {
+            ids.add(variant.derivedFrom);
+        }
+    }
+    return ids;
+}
+
 /**
  * @param {string} id
  */
@@ -290,7 +362,7 @@ export function describeUnavailableAgent(agent) {
  */
 export function formatNoUsableAgentsMessage(detections) {
     const summaries = detections
-        .map((entry) => `${entry.displayName}: ${entry.usable ? "usable" : formatUnusableReasons(entry)}`)
+        .map((entry) => `${entry.displayName}: ${entry.deprecated ? `deprecated (${entry.deprecationReason})` : entry.usable ? "usable" : formatUnusableReasons(entry)}`)
         .join(" | ");
     return [
         `No usable agents detected. ${summaries}.`,
@@ -335,6 +407,8 @@ export function detectAvailableAgents(env = process.env, options = {}) {
             id: detector.id,
             displayName: detector.displayName,
             binary: detector.binary,
+            deprecated: detector.deprecated === true ? true : undefined,
+            deprecationReason: detector.deprecationReason,
             hasBinary,
             hasAuthSignal,
             hasApiKeySignal,
@@ -382,6 +456,7 @@ function resolveRoleAgents(role, available) {
  */
 const ACCOUNT_PROVIDER_CLASSES = {
     "claude-code": "ClaudeCodeAgent",
+    "antigravity": "AntigravityAgent",
     "codex": "CodexAgent",
     "gemini": "GeminiAgent",
     "kimi": "KimiAgent",
@@ -398,6 +473,7 @@ const ACCOUNT_PROVIDER_CLASSES = {
 const ACCOUNT_PROVIDER_POOL = {
     "claude-code": "claude",
     "anthropic-api": "claude",
+    "antigravity": "antigravity",
     "codex": "codex",
     "openai-api": "codex",
     "gemini": "gemini",
@@ -412,6 +488,7 @@ const ACCOUNT_PROVIDER_POOL = {
 const ACCOUNT_PROVIDER_DEFAULT_MODEL = {
     "claude-code": "claude-opus-4-7",
     "anthropic-api": "claude-opus-4-7",
+    "antigravity": undefined,
     "codex": "gpt-5.4-codex",
     "openai-api": "gpt-5.4-codex",
     "gemini": "gemini-3.1-pro-preview",
@@ -564,12 +641,34 @@ function renderTierLine(tier, providerIds, comments) {
 
 /**
  * @param {NodeJS.ProcessEnv} [env]
- * @param {{ cwd?: string }} [options]
+ * @param {{ cwd?: string; preserveProviderIds?: Iterable<string>; scaffoldProviderIds?: Iterable<string> }} [options]
  */
 export function generateAgentsTs(env = process.env, options = {}) {
     const registeredAccounts = listAccounts(env);
     const detections = detectAvailableAgents(env, options);
-    const available = detections.filter((entry) => entry.usable);
+    const scaffoldProviderIds = new Set(options.scaffoldProviderIds ?? Object.keys(SCAFFOLDED_PROVIDERS));
+    const usesLocalScaffold = (providerId) => providerId in LOCAL_SCAFFOLDED_PROVIDERS && scaffoldProviderIds.has(providerId);
+    const availableById = new Map(detections.filter((entry) => entry.usable && !entry.deprecated).map((entry) => [entry.id, entry]));
+    for (const providerId of options.preserveProviderIds ?? []) {
+        const baseId = baseAgentIdForProviderId(providerId);
+        const detector = detectorForId(baseId);
+        if (!detector || availableById.has(baseId)) continue;
+        availableById.set(baseId, {
+            id: detector.id,
+            displayName: detector.displayName,
+            binary: detector.binary,
+            hasBinary: false,
+            hasAuthSignal: false,
+            hasApiKeySignal: false,
+            hasProjectTrustSignal: true,
+            status: "likely-subscription",
+            score: scoreStatus("likely-subscription"),
+            usable: true,
+            checks: [`preserved:${detector.id}:yes`],
+            unusableReasons: [],
+        });
+    }
+    const available = [...availableById.values()];
     if (available.length === 0 && registeredAccounts.length === 0) {
         throw new SmithersError("NO_USABLE_AGENTS", formatNoUsableAgentsMessage(detections));
     }
@@ -581,7 +680,7 @@ export function generateAgentsTs(env = process.env, options = {}) {
     }
     // Base providers in detection order
     const orderedProviders = DETECTORS
-        .map((detector) => available.find((entry) => entry.id === detector.id))
+        .map((detector) => availableById.get(detector.id))
         .filter((entry) => Boolean(entry));
     // Derive variants (e.g. claudeSonnet from claude)
     const availableIds = new Set(orderedProviders.map((p) => p.id));
@@ -590,7 +689,7 @@ export function generateAgentsTs(env = process.env, options = {}) {
     // detection providers + every account class.
     const importNames = new Set();
     for (const provider of orderedProviders) {
-        if (!(provider.id in SCAFFOLDED_PROVIDERS)) {
+        if (!usesLocalScaffold(provider.id)) {
             importNames.add(CONSTRUCTORS[provider.id].importName);
         }
     }
@@ -609,10 +708,16 @@ export function generateAgentsTs(env = process.env, options = {}) {
     // Provider lines: detection base + variants + accounts (additive — `agent
     // add` must never silently delete a previously-emitted provider).
     const providerLines = [
-        ...orderedProviders.map((provider) => `  ${provider.id}: ${SCAFFOLDED_PROVIDERS[provider.id] ?? CONSTRUCTORS[provider.id].expr},`),
+        ...orderedProviders.map((provider) => `  ${provider.id}: ${usesLocalScaffold(provider.id) ? LOCAL_SCAFFOLDED_PROVIDERS[provider.id] : CONSTRUCTORS[provider.id].expr},`),
         ...activeVariants.map((variant) => `  ${variant.variantId}: ${variant.constructor.expr},`),
         ...registeredAccounts.map((account) => renderAccountProviderLine(account, homeDir)),
     ];
+    const scaffoldImportLines = orderedProviders
+        .filter((provider) => usesLocalScaffold(provider.id))
+        .map((provider) => `import { ${LOCAL_SCAFFOLDED_PROVIDERS[provider.id]} } from "./agents/${LOCAL_SCAFFOLDED_PROVIDER_FILES[provider.id]}";`);
+    const scaffoldExportLines = orderedProviders
+        .filter((provider) => usesLocalScaffold(provider.id))
+        .map((provider) => `export { ${LOCAL_SCAFFOLDED_PROVIDERS[provider.id]} } from "./agents/${LOCAL_SCAFFOLDED_PROVIDER_FILES[provider.id]}";`);
     // All known provider/variant IDs for tier resolution
     const allProviderIds = new Set([
         ...orderedProviders.map((p) => p.id),
@@ -646,14 +751,10 @@ export function generateAgentsTs(env = process.env, options = {}) {
         ...(hasAccounts ? ["// Account providers (camelCase labels) come from ~/.smithers/accounts.json — managed via `smithers agent add|list|remove`."] : []),
         ...(hasAccounts ? ['import { homedir } from "node:os";', 'import path from "node:path";'] : []),
         `import { ${smithersImportSpecifiers.join(", ")} } from "smithers-orchestrator";`,
-        'import { ClaudeCodeAgent } from "./agents/claude-code";',
-        'import { CodexAgent } from "./agents/codex";',
-        'import { GeminiAgent } from "./agents/gemini";',
-        "",
-        'export { ClaudeCodeAgent } from "./agents/claude-code";',
-        'export { CodexAgent } from "./agents/codex";',
-        'export { GeminiAgent } from "./agents/gemini";',
+        ...scaffoldImportLines,
         "",
+        ...scaffoldExportLines,
+        ...(scaffoldExportLines.length ? [""] : []),
         "export const providers = {",
         ...providerLines,
         "} as const;",

package/src/argv-utils.js

@@ -0,0 +1,73 @@
+const BUILTIN_FLAGS_WITH_VALUES = new Set([
+    "--format",
+    "--filter-output",
+    "--surface",
+    "--token-limit",
+    "--token-offset",
+]);
+
+/**
+ * @param {string | undefined} value
+ * @returns {"semantic" | "raw" | "both"}
+ */
+function normalizeMcpSurface(value) {
+    const surface = value?.trim().toLowerCase();
+    if (surface === undefined || surface.length === 0) {
+        throw new Error("Missing value for --surface. Expected semantic, raw, or both.");
+    }
+    if (surface === "semantic" || surface === "raw" || surface === "both") {
+        return surface;
+    }
+    throw new Error(`Invalid --surface value: ${value}. Expected semantic, raw, or both.`);
+}
+
+/**
+ * @param {string[]} argv
+ */
+export function parseMcpSurfaceArgv(argv) {
+    let surface = "semantic";
+    const filtered = [];
+    for (let index = 0; index < argv.length; index++) {
+        const arg = argv[index];
+        if (arg === "--surface") {
+            surface = normalizeMcpSurface(argv[index + 1]);
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--surface=")) {
+            surface = normalizeMcpSurface(arg.slice("--surface=".length));
+            continue;
+        }
+        filtered.push(arg);
+    }
+    return { surface, argv: filtered };
+}
+
+/**
+ * @param {string[]} argv
+ * @returns {number}
+ */
+export function findFirstPositionalIndex(argv, startIndex = 0) {
+    for (let index = startIndex; index < argv.length; index++) {
+        const arg = argv[index];
+        if (!arg.startsWith("-")) {
+            return index;
+        }
+        if (BUILTIN_FLAGS_WITH_VALUES.has(arg)) {
+            index++;
+        }
+    }
+    return -1;
+}
+
+/**
+ * Incur treats union-typed options as value-bearing flags, so a bare
+ * `--resume --run-id value` would consume `--run-id` as the resume value.
+ *
+ * @param {string[]} argv
+ */
+export function rewriteBareResumeFlagArgv(argv) {
+    return argv.map((arg, index) => arg === "--resume" && (argv[index + 1] === undefined || argv[index + 1]?.startsWith("-"))
+        ? "--resume=true"
+        : arg);
+}

package/src/ask.js

@@ -4,6 +4,7 @@ import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { AntigravityAgent } from "@smithers-orchestrator/agents/AntigravityAgent";
 import { ClaudeCodeAgent } from "@smithers-orchestrator/agents/ClaudeCodeAgent";
 import { CodexAgent } from "@smithers-orchestrator/agents/CodexAgent";
 import { GeminiAgent } from "@smithers-orchestrator/agents/GeminiAgent";
@@ -20,7 +21,7 @@ import { describeUnavailableAgent, detectAvailableAgents, formatNoUsableAgentsMe
  */
 /** @typedef {import("@smithers-orchestrator/agents/agent-contract").SmithersToolSurface} SmithersToolSurface */
 
-const ASK_AGENT_IDS = ["claude", "codex", "kimi", "gemini", "pi"];
+const ASK_AGENT_IDS = ["claude", "codex", "kimi", "antigravity", "gemini", "pi"];
 const DEFAULT_SERVER_NAME = "smithers";
 /**
  * @param {AgentAvailability["id"]} value
@@ -52,6 +53,7 @@ function resolveBootstrapMode(agentId, noMcp = false) {
             return "mcp-config-inline";
         case "gemini":
             return "mcp-allow-list";
+        case "antigravity":
         case "pi":
             return "prompt-only";
     }
@@ -216,7 +218,7 @@ function selectAgent(agents, options) {
             selectionReason: "requested via --agent",
         };
     }
-    const usable = supported.filter((agent) => agent.usable);
+    const usable = supported.filter((agent) => agent.usable && !agent.deprecated);
     if (usable.length === 0) {
         throw noUsableAgentError(agents);
     }
@@ -369,6 +371,15 @@ function buildAgent(selection, bootstrap, systemPrompt, cwd) {
                 }),
                 cleanup() { },
             };
+        case "antigravity":
+            return {
+                agent: new AntigravityAgent({
+                    cwd,
+                    systemPrompt,
+                    dangerouslySkipPermissions: true,
+                }),
+                cleanup() { },
+            };
         case "codex":
             return {
                 agent: new CodexAgent({