@phuetz/code-buddy 1.1.0 → 1.2.0

package/dist/commands/handlers/goal-handler.js

@@ -1,3 +1,4 @@
+import { decomposeGoal, formatGoalPlan, shouldAutoDecomposeGoal, } from '../../goals/goal-decomposer.js';
 import { getGoalManager } from '../../goals/goal-manager.js';
 /**
  * /goal — standing goal with judge + auto-continue loop (the Ralph loop,
@@ -10,10 +11,10 @@ import { getGoalManager } from '../../goals/goal-manager.js';
  *   /goal resume     restart the loop (resets the turn budget)
  *   /goal clear      discard the goal (aliases: stop, done)
  */
-export async function handleGoal(args) {
+export async function handleGoal(args, options = {}) {
     const arg = args.join(' ').trim();
     const lower = arg.toLowerCase();
-    const mgr = getGoalManager();
+    const mgr = getGoalManager(options.sessionKey);
     if (!arg || lower === 'status') {
         return textResult(mgr.statusLine());
     }
@@ -35,13 +36,37 @@ export async function handleGoal(args) {
         return textResult(had ? '✓ Goal cleared.' : 'No active goal.');
     }
     // Otherwise treat the arg as the goal text.
+    let plan = null;
+    let planAttempted = false;
+    let planError = '';
+    if (options.client && shouldAutoDecomposeGoal(arg)) {
+        planAttempted = true;
+        try {
+            plan = await (options.planner ?? decomposeGoal)(arg, options.client);
+        }
+        catch (error) {
+            planError = error instanceof Error ? error.message : String(error);
+        }
+    }
     let state;
     try {
-        state = mgr.set(arg);
+        state = mgr.set(arg, {
+            ...(plan ? { goalPlan: plan } : {}),
+            ...(planAttempted ? { goalPlanAttempted: true } : {}),
+        });
+        if (planAttempted && !plan && planError) {
+            mgr.markGoalPlanAttempted(planError);
+            state = mgr.state ?? state;
+        }
     }
     catch (error) {
         return textResult(`Invalid goal: ${error instanceof Error ? error.message : String(error)}`);
     }
+    const planBlock = state.goalPlan
+        ? `\n\nHermes-style task graph attached:\n${formatGoalPlan(state.goalPlan)}`
+        : planError
+            ? `\n\nGoal planning was skipped after an LLM planner error: ${planError}`
+            : '';
     return {
         handled: true,
         entry: {
@@ -51,7 +76,8 @@ export async function handleGoal(args) {
                 'keeps working until it is, you pause/clear it, or the budget is ' +
                 'exhausted. Use /goal status, /goal pause, /goal resume, /goal clear. ' +
                 'Tip: for unattended runs, enable auto-approval (/yolo or auto-edit) so ' +
-                'the loop is not blocked on confirmations.',
+                'the loop is not blocked on confirmations.' +
+                planBlock,
             timestamp: new Date(),
         },
         // Kick the loop off immediately — the dispatcher feeds the goal text as
@@ -73,9 +99,9 @@ export async function handleGoal(args) {
  * them) and the continuation prompt (agent sees them) on the next turn
  * boundary — no special kick needed.
  */
-export async function handleSubgoal(args) {
+export async function handleSubgoal(args, options = {}) {
     const arg = args.join(' ').trim();
-    const mgr = getGoalManager();
+    const mgr = getGoalManager(options.sessionKey);
     if (!mgr.hasGoal()) {
         return textResult('No active goal. Set one with /goal <text>.');
     }
@@ -88,9 +114,10 @@ export async function handleSubgoal(args) {
         if (!rest) {
             return textResult('Usage: /subgoal remove <n>');
         }
-        const idx = Number(rest.split(/\s+/)[0]);
-        if (!Number.isInteger(idx)) {
-            return textResult('/subgoal remove: <n> must be an integer (1-based index).');
+        const indexToken = rest.split(/\s+/)[0] ?? '';
+        const idx = Number(indexToken);
+        if (!/^[1-9]\d*$/.test(indexToken) || !Number.isSafeInteger(idx)) {
+            return textResult('/subgoal remove: <n> must be a positive integer (1-based index).');
         }
         try {
             const removed = mgr.removeSubgoal(idx);

package/dist/commands/handlers/infra-handlers.js

@@ -6,6 +6,7 @@
  * and the current TurboQuant routing statistics.
  */
 import { logger } from '../../utils/logger.js';
+import { fetchOllamaStatus } from '../ollama.js';
 async function checkEndpoint(name, url, timeoutMs = 4000) {
     const start = Date.now();
     try {
@@ -49,6 +50,35 @@ function formatRoutingStats(stats) {
     }
     return lines.join('\n');
 }
+function formatOllamaSummary(status) {
+    const lines = [
+        `  Reachable: ${status.reachable ? 'YES' : 'NO'}`,
+        `  Version: ${status.version ?? '(unknown)'}`,
+        `  Models: ${status.models.length > 0 ? status.models.join(', ') : '(none)'}`,
+    ];
+    if (status.error) {
+        lines.push(`  Error: ${status.error}`);
+    }
+    lines.push(`  Gemma 4 ready: ${isGemma4Ready(status.version, status.models) ? 'YES' : 'NO'}`);
+    return lines.join('\n');
+}
+function isGemma4Ready(version, models) {
+    if (!version)
+        return false;
+    const [majorRaw, minorRaw, patchRaw] = version.split('.');
+    const major = Number.parseInt(majorRaw ?? '', 10);
+    const minor = Number.parseInt(minorRaw ?? '', 10);
+    const patch = Number.parseInt(patchRaw ?? '', 10);
+    if (!Number.isFinite(major) || !Number.isFinite(minor) || !Number.isFinite(patch))
+        return false;
+    if (major > 0)
+        return true;
+    if (minor > 24)
+        return true;
+    if (minor === 24 && patch >= 1)
+        return true;
+    return models.some((model) => model.toLowerCase().includes('gemma4'));
+}
 // ---------------------------------------------------------------------------
 // Main handler
 // ---------------------------------------------------------------------------
@@ -102,6 +132,9 @@ async function handleInfraDashboard() {
         lines.push(formatStatus(s));
     }
     lines.push('');
+    lines.push('Ollama Summary:');
+    lines.push(formatOllamaSummary(await fetchOllamaStatus(ollamaUrl)));
+    lines.push('');
     // Routing stats from TurboQuant plugin
     try {
         const { getTurboQuantStats } = await import('../../plugins/bundled/turboquant-plugin.js');
@@ -159,6 +192,9 @@ async function handleInfraHealth() {
     for (const s of statuses) {
         lines.push(formatStatus(s));
     }
+    lines.push('');
+    lines.push('Ollama Summary:');
+    lines.push(formatOllamaSummary(await fetchOllamaStatus(ollamaUrl)));
     return { handled: true, response: lines.join('\n') };
 }
 //# sourceMappingURL=infra-handlers.js.map

package/dist/commands/handlers/memory-handlers.js

@@ -27,6 +27,9 @@ function formatTimeAgo(date, now = new Date()) {
     const yr = Math.floor(day / 365);
     return `${yr} year${yr === 1 ? "" : "s"} ago`;
 }
+function clip(text, max = 180) {
+    return text.length > max ? text.slice(0, max - 1) + "…" : text;
+}
 /**
  * Memory - Manage persistent memory using PersistentMemoryManager (Markdown) and EnhancedMemory (SQLite/Vector)
  */
@@ -103,10 +106,10 @@ export async function handleMemory(args) {
                         content = `Usage: /memory remember <key> <content> [project|user]`;
                         break;
                     }
-                    const value = args.slice(2).join(" ");
                     const scope = (args[args.length - 1] === "user" || args[args.length - 1] === "project")
                         ? args.pop()
                         : "project";
+                    const value = args.slice(2).join(" ");
                     // Store in both for redundancy and better retrieval
                     await persistentMemory.remember(key, value, { scope, category: "custom" });
                     await enhancedMemory.store({
@@ -121,6 +124,30 @@ export async function handleMemory(args) {
                     content = `Usage: /memory remember <key> <content> [project|user]`;
                 }
                 break;
+            case "replace":
+            case "update":
+                if (args.length >= 3) {
+                    const key = args[1];
+                    if (key === undefined) {
+                        content = `Usage: /memory replace <key> <content> [project|user]`;
+                        break;
+                    }
+                    const scope = (args[args.length - 1] === "user" || args[args.length - 1] === "project")
+                        ? args.pop()
+                        : "project";
+                    const value = args.slice(2).join(" ");
+                    const result = await persistentMemory.replace(key, value, { scope });
+                    if (result.status === 'missing') {
+                        content = result.message;
+                    }
+                    else {
+                        content = `✅ ${result.message}\nCapacity: ${result.usage.used}/${result.usage.limit} chars (${result.usage.percent}%).`;
+                    }
+                }
+                else {
+                    content = `Usage: /memory replace <key> <content> [project|user]`;
+                }
+                break;
             case "context":
                 const enhancedContext = await enhancedMemory.buildContext({
                     includeProject: true,
@@ -154,6 +181,74 @@ export async function handleMemory(args) {
                 }
                 break;
             }
+            case "candidates":
+            case "candidate":
+            case "pending": {
+                const { getMemoryCandidateQueue } = await import("../../memory/memory-candidate-queue.js");
+                const statusArg = args[1];
+                const status = statusArg === "pending" || statusArg === "accepted" || statusArg === "rejected"
+                    ? statusArg
+                    : undefined;
+                const rawLimit = parseInt(args[status ? 2 : 1] ?? "20", 10);
+                const limit = Math.min(50, Math.max(1, Number.isFinite(rawLimit) ? rawLimit : 20));
+                const candidates = getMemoryCandidateQueue(process.cwd()).list(status).slice(0, limit);
+                if (candidates.length === 0) {
+                    content = status ? `No ${status} memory candidates.` : "No memory candidates yet.";
+                }
+                else {
+                    const lines = [`🧠 Memory candidates (${candidates.length}${status ? ` ${status}` : ""})`, "═".repeat(50)];
+                    for (const candidate of candidates) {
+                        const created = formatTimeAgo(new Date(candidate.createdAt));
+                        const confidence = typeof candidate.confidence === "number"
+                            ? ` | confidence ${(candidate.confidence * 100).toFixed(0)}%`
+                            : "";
+                        lines.push(`[${candidate.status}] ${candidate.id} | ${candidate.scope}/${candidate.category}${confidence} | ${created}`);
+                        lines.push(`  ${candidate.key}: ${clip(candidate.value)}`);
+                        const citation = candidate.citations?.[0];
+                        if (citation) {
+                            const label = citation.sessionId
+                                ? `${citation.sessionId}${citation.messageId ? `#${citation.messageId}` : citation.messageIndex ? `#${citation.messageIndex}` : ""}`
+                                : citation.messageIndex ? `message ${citation.messageIndex}` : "evidence";
+                            lines.push(`  citation: ${label}${citation.role ? ` (${citation.role})` : ""} — ${clip(citation.snippet, 140)}`);
+                        }
+                        lines.push("");
+                    }
+                    lines.push("Approve: /memory accept <id> [reviewer]");
+                    lines.push("Reject:  /memory reject <id> [reason]");
+                    content = lines.join("\n").trimEnd();
+                }
+                break;
+            }
+            case "accept":
+            case "approve": {
+                const id = args[1];
+                if (!id) {
+                    content = `Usage: /memory accept <candidate-id> [reviewer]`;
+                    break;
+                }
+                const reviewedBy = args.slice(2).join(" ").trim() || "user";
+                const { getMemoryCandidateQueue } = await import("../../memory/memory-candidate-queue.js");
+                const { candidate, write } = await getMemoryCandidateQueue(process.cwd()).accept(id, { reviewedBy });
+                content = `✅ Accepted ${candidate.id} into ${candidate.scope} memory as "${candidate.key}".\n` +
+                    `Write status: ${write.status}. Capacity: ${write.usage.used}/${write.usage.limit} chars (${write.usage.percent}%).`;
+                break;
+            }
+            case "reject":
+            case "discard": {
+                const id = args[1];
+                if (!id) {
+                    content = `Usage: /memory reject <candidate-id> [reason]`;
+                    break;
+                }
+                const reason = args.slice(2).join(" ").trim();
+                const { getMemoryCandidateQueue } = await import("../../memory/memory-candidate-queue.js");
+                const candidate = getMemoryCandidateQueue(process.cwd()).reject(id, {
+                    reviewedBy: "user",
+                    ...(reason ? { reason } : {}),
+                });
+                content = `🗑️ Rejected memory candidate ${candidate.id}.`;
+                break;
+            }
             case "status":
             case "list":
             default:

package/dist/commands/headless-slash.d.ts

@@ -33,6 +33,8 @@ export interface HeadlessSlashContext {
     conversationHistory?: ChatEntry[];
     /** LLM client, for tokens that call the model directly (ai-test, btw). */
     client?: CodeBuddyClient;
+    /** Optional goal-state key for non-TUI surfaces with their own session ids. */
+    goalSessionKey?: string;
 }
 /** Result of running a special token outside the TUI. */
 export interface HeadlessSlashResult {

package/dist/commands/headless-slash.js

@@ -55,6 +55,18 @@ export async function executeHeadlessSlashToken(token, args, allow, ctx = {}) {
     if (ctx.client)
         handler.setCodeBuddyClient(ctx.client);
     try {
+        if (ctx.goalSessionKey && (token === '__GOAL__' || token === '__SUBGOAL__')) {
+            const { handleGoal, handleSubgoal } = await import('./handlers/goal-handler.js');
+            const result = token === '__GOAL__'
+                ? await handleGoal(args, { sessionKey: ctx.goalSessionKey, client: ctx.client ?? null })
+                : await handleSubgoal(args, { sessionKey: ctx.goalSessionKey });
+            return {
+                handled: result.handled,
+                output: result.entry?.content,
+                prompt: result.prompt,
+                passToAI: result.passToAI,
+            };
+        }
         const result = await handler.handleCommand(token, args, [token, ...args].join(" "));
         return {
             handled: result.handled,

package/dist/commands/llm-provider-resolution.d.ts

@@ -6,9 +6,11 @@
  * provider + the `PROVIDERS` map (paid keys), so a machine running on
  * local Ollama (`CODEBUDDY_PROVIDER=ollama`, $0) hit the "no API key"
  * exit even though the rest of Code Buddy — including the autonomous
- * daemon — runs fine there. This resolver keeps the legacy path first
- * (backward compatible) and falls back to {@link detectProviderFromEnv}
- * (ollama / chatgpt-oauth / env-detected providers) when either:
+ * daemon — runs fine there. This resolver keeps the legacy path for
+ * ambient paid-key defaults, but honors explicit local / ChatGPT
+ * subscription model choices before a cloud key can hijack them. It
+ * falls back to {@link detectProviderFromEnv} (ollama / chatgpt-oauth /
+ * env-detected providers) when either:
  *   - `CODEBUDDY_PROVIDER` is explicitly set (operator intent wins), or
  *   - the legacy path found no key.
  */

package/dist/commands/llm-provider-resolution.js

@@ -6,58 +6,69 @@
  * provider + the `PROVIDERS` map (paid keys), so a machine running on
  * local Ollama (`CODEBUDDY_PROVIDER=ollama`, $0) hit the "no API key"
  * exit even though the rest of Code Buddy — including the autonomous
- * daemon — runs fine there. This resolver keeps the legacy path first
- * (backward compatible) and falls back to {@link detectProviderFromEnv}
- * (ollama / chatgpt-oauth / env-detected providers) when either:
+ * daemon — runs fine there. This resolver keeps the legacy path for
+ * ambient paid-key defaults, but honors explicit local / ChatGPT
+ * subscription model choices before a cloud key can hijack them. It
+ * falls back to {@link detectProviderFromEnv} (ollama / chatgpt-oauth /
+ * env-detected providers) when either:
  *   - `CODEBUDDY_PROVIDER` is explicitly set (operator intent wins), or
  *   - the legacy path found no key.
  */
 import { getSettingsManager } from '../utils/settings-manager.js';
 import { detectProviderFromEnv } from '../utils/provider-detector.js';
-import { PROVIDERS } from './provider.js';
+import { inferProvider } from '../config/resolve-model.js';
+import { hasCodexCredentials } from '../providers/codex-oauth.js';
+import { resolveProviderFromCatalog } from '../providers/provider-catalog.js';
+import { PROVIDERS, resolveProviderCommandKey } from './provider.js';
 export function resolveCommandProvider(options = {}) {
+    const settingsManager = getSettingsManager();
+    const settings = settingsManager.loadUserSettings();
+    const configuredModel = options.explicitModel || settingsManager.getCurrentModel();
     const detectFirst = Boolean(process.env.CODEBUDDY_PROVIDER);
     if (detectFirst) {
         const detected = fromEnvDetection(options.explicitModel);
         if (detected)
             return detected;
     }
-    const settingsManager = getSettingsManager();
-    const settings = settingsManager.loadUserSettings();
+    const explicitLocal = resolveExplicitOllamaModel(configuredModel);
+    if (explicitLocal)
+        return explicitLocal;
+    const explicitChatGpt = resolveExplicitChatGptModel(configuredModel);
+    if (explicitChatGpt)
+        return explicitChatGpt;
     const currentProviderKey = settings.provider || 'grok';
-    const providerInfo = PROVIDERS[currentProviderKey];
-    let apiKey = process.env[providerInfo?.envVar || ''] || '';
-    if (!apiKey && currentProviderKey === 'grok')
-        apiKey = process.env.XAI_API_KEY || '';
-    if (!apiKey && currentProviderKey === 'gemini')
-        apiKey = process.env.GOOGLE_API_KEY || '';
-    if (!apiKey) {
-        apiKey =
-            process.env.GROK_API_KEY ||
-                process.env.ANTHROPIC_API_KEY ||
-                process.env.OPENAI_API_KEY ||
-                process.env.GOOGLE_API_KEY ||
-                '';
+    const providerInfoKey = resolveProviderCommandKey(currentProviderKey) || currentProviderKey;
+    const providerInfo = PROVIDERS[providerInfoKey];
+    if (providerInfo) {
+        const configuredProvider = resolveProviderFromCatalog({
+            providerOverride: providerInfo.providerId,
+            hasChatGptOAuth: hasCodexCredentials(),
+            requireConfigured: providerInfo.authMode === 'api-key',
+        });
+        if (configuredProvider) {
+            return {
+                apiKey: configuredProvider.apiKey,
+                baseURL: configuredProvider.baseURL,
+                model: configuredModel || configuredProvider.defaultModel,
+                providerLabel: configuredProvider.provider,
+            };
+        }
     }
-    if (apiKey) {
-        const providerEnvBaseURL = {
-            grok: process.env.GROK_BASE_URL,
-            claude: process.env.ANTHROPIC_BASE_URL,
-            openai: process.env.OPENAI_BASE_URL,
-            gemini: process.env.GEMINI_BASE_URL,
-        };
+    const ambientProvider = resolveProviderFromCatalog({
+        hasChatGptOAuth: hasCodexCredentials(),
+        requireConfigured: true,
+    });
+    if (ambientProvider) {
         return {
-            apiKey,
-            baseURL: providerEnvBaseURL[currentProviderKey] || providerInfo?.baseURL,
-            model: options.explicitModel ||
-                settingsManager.getCurrentModel() ||
-                providerInfo?.defaultModel,
-            providerLabel: providerInfo?.name || currentProviderKey,
+            apiKey: ambientProvider.apiKey,
+            baseURL: ambientProvider.baseURL,
+            model: configuredModel || ambientProvider.defaultModel,
+            providerLabel: ambientProvider.provider,
         };
     }
     // Legacy path found nothing — fall back to env detection (local
     // Ollama, ChatGPT OAuth, …) so a $0 local machine can still run.
-    return fromEnvDetection(options.explicitModel);
+    return fromEnvDetection(configuredModel);
 }
 function fromEnvDetection(explicitModel) {
     const detected = detectProviderFromEnv();
@@ -70,4 +81,47 @@ function fromEnvDetection(explicitModel) {
         providerLabel: detected.provider,
     };
 }
+function resolveExplicitOllamaModel(explicitModel) {
+    const model = explicitModel?.trim();
+    if (!model || !isLocalOllamaModel(model))
+        return null;
+    let host = process.env.OLLAMA_HOST || 'http://localhost:11434';
+    if (!/^https?:\/\//i.test(host))
+        host = `http://${host}`;
+    if (!host.endsWith('/v1'))
+        host = host.replace(/\/+$/, '') + '/v1';
+    return {
+        apiKey: 'ollama',
+        baseURL: host,
+        model,
+        providerLabel: 'ollama',
+    };
+}
+function isLocalOllamaModel(model) {
+    const normalized = model.trim().toLowerCase();
+    return inferProvider(normalized) === 'ollama' || normalized.startsWith('devstral-small-2');
+}
+function resolveExplicitChatGptModel(explicitModel) {
+    const model = explicitModel?.trim();
+    if (!model || !isChatGptSubscriptionModel(model))
+        return null;
+    const detected = detectProviderFromEnv();
+    if (detected?.provider !== 'chatgpt')
+        return null;
+    return {
+        apiKey: detected.apiKey,
+        baseURL: detected.baseURL,
+        model,
+        providerLabel: detected.provider,
+    };
+}
+function isChatGptSubscriptionModel(model) {
+    const m = model.trim().toLowerCase();
+    return (m === 'gpt-5.2' ||
+        m === 'gpt-5.5' ||
+        m.startsWith('gpt-5.5-') ||
+        m.includes('-codex') ||
+        m === 'codex-1' ||
+        m.startsWith('codex-mini'));
+}
 //# sourceMappingURL=llm-provider-resolution.js.map

package/dist/commands/ollama.d.ts

@@ -0,0 +1,25 @@
+export interface OllamaStatus {
+    baseUrl: string;
+    reachable: boolean;
+    version: string | null;
+    models: string[];
+    error: string | null;
+}
+export interface OllamaUpdatePlan {
+    supported: boolean;
+    platform: NodeJS.Platform;
+    repoRoot: string;
+    scriptPath: string;
+    scriptUrl: string;
+    command?: string;
+    args?: string[];
+    message: string;
+}
+export declare function normalizeOllamaBaseUrl(rawUrl?: string): string;
+export declare function fetchOllamaStatus(baseUrl?: string): Promise<OllamaStatus>;
+export declare function buildOllamaUpdatePlan(options: {
+    platform?: NodeJS.Platform;
+    repoRoot: string;
+    scriptUrl?: string;
+}): OllamaUpdatePlan;
+export declare function runOllamaUpdatePlan(plan: OllamaUpdatePlan): Promise<void>;

package/dist/commands/ollama.js

@@ -0,0 +1,100 @@
+import { spawn } from 'child_process';
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+export function normalizeOllamaBaseUrl(rawUrl) {
+    const value = (rawUrl || 'http://localhost:11434').trim();
+    const withoutV1 = value.replace(/\/v1\/?$/, '');
+    return withoutV1.replace(/\/+$/, '');
+}
+export async function fetchOllamaStatus(baseUrl) {
+    const normalizedBaseUrl = normalizeOllamaBaseUrl(baseUrl);
+    const apiBase = `${normalizedBaseUrl}/api`;
+    try {
+        const [versionResponse, tagsResponse] = await Promise.all([
+            fetch(`${apiBase}/version`, { signal: AbortSignal.timeout(5000) }),
+            fetch(`${apiBase}/tags`, { signal: AbortSignal.timeout(5000) }),
+        ]);
+        const versionJson = (await versionResponse.json());
+        const tagsJson = (await tagsResponse.json());
+        return {
+            baseUrl: normalizedBaseUrl,
+            reachable: versionResponse.ok && tagsResponse.ok,
+            version: typeof versionJson.version === 'string' ? versionJson.version : null,
+            models: Array.isArray(tagsJson.models)
+                ? tagsJson.models
+                    .map((model) => (typeof model.name === 'string' ? model.name : null))
+                    .filter((name) => Boolean(name))
+                : [],
+            error: versionResponse.ok && tagsResponse.ok ? null : `HTTP ${versionResponse.status}/${tagsResponse.status}`,
+        };
+    }
+    catch (error) {
+        return {
+            baseUrl: normalizedBaseUrl,
+            reachable: false,
+            version: null,
+            models: [],
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+export function buildOllamaUpdatePlan(options) {
+    const platform = options.platform ?? process.platform;
+    const repoRoot = resolve(options.repoRoot);
+    const scriptPath = resolve(repoRoot, 'scripts', 'update-ollama-windows.ps1');
+    const scriptUrl = options.scriptUrl ?? 'https://ollama.com/install.ps1';
+    const supported = platform === 'win32';
+    if (!supported) {
+        return {
+            supported,
+            platform,
+            repoRoot,
+            scriptPath,
+            scriptUrl,
+            message: 'Ollama update automation is implemented for Windows. Use the official install script on this platform.',
+        };
+    }
+    const command = 'powershell';
+    const args = [
+        '-ExecutionPolicy',
+        'Bypass',
+        '-File',
+        scriptPath,
+        '-InstallerScriptUrl',
+        scriptUrl,
+    ];
+    return {
+        supported,
+        platform,
+        repoRoot,
+        scriptPath,
+        scriptUrl,
+        command,
+        args,
+        message: `Windows update script ready: ${scriptPath}`,
+    };
+}
+export async function runOllamaUpdatePlan(plan) {
+    if (!plan.supported || !plan.command || !plan.args) {
+        throw new Error(plan.message);
+    }
+    if (!existsSync(plan.scriptPath)) {
+        throw new Error(`Missing Ollama update script: ${plan.scriptPath}`);
+    }
+    await new Promise((resolvePromise, rejectPromise) => {
+        const child = spawn(plan.command, plan.args, {
+            stdio: 'inherit',
+            cwd: plan.repoRoot,
+            shell: false,
+        });
+        child.once('error', rejectPromise);
+        child.once('exit', (code) => {
+            if (code === 0) {
+                resolvePromise();
+                return;
+            }
+            rejectPromise(new Error(`Ollama update script exited with code ${code ?? 'unknown'}`));
+        });
+    });
+}
+//# sourceMappingURL=ollama.js.map

package/dist/commands/provider.d.ts

@@ -4,13 +4,18 @@
  * CLI commands for managing AI providers (Claude, ChatGPT, Grok, Gemini)
  */
 import { Command } from 'commander';
+import { type RuntimeProviderCatalogEntry, type RuntimeProviderId } from '../providers/provider-catalog.js';
 interface ProviderInfo {
     name: string;
     envVar: string;
+    envVars: string[];
     models: string[];
     defaultModel: string;
     baseURL?: string;
+    providerId: RuntimeProviderId;
+    authMode: RuntimeProviderCatalogEntry['authMode'];
 }
 export declare const PROVIDERS: Record<string, ProviderInfo>;
 export declare function createProviderCommand(): Command;
+export declare function resolveProviderCommandKey(provider: string): string | null;
 export default createProviderCommand;