umbrella-context 0.1.2 → 0.1.20

package/dist/commands/locations.d.ts

@@ -1 +1,2 @@
+export declare function locationsCommandAction(): Promise<void>;
 export declare function locationsCommand(cli: any): void;

package/dist/commands/locations.js

@@ -1,17 +1,20 @@
 import chalk from "chalk";
 import { configManager } from "../config.js";
+export async function locationsCommandAction() {
+    const locations = configManager.locations;
+    if (locations.length === 0) {
+        console.log(chalk.yellow("\n No repo locations saved yet."));
+        return;
+    }
+    console.log(chalk.bold("\n Saved Context Locations\n"));
+    locations.forEach((location, index) => {
+        console.log(chalk.cyan(` ${index + 1}. ${location.companyName} / ${location.projectName}`));
+        console.log(chalk.gray(`    ${location.repoRoot}`));
+        console.log(chalk.gray(`    Updated: ${new Date(location.updatedAt).toLocaleString()}`));
+    });
+}
 export function locationsCommand(cli) {
-    cli.command("locations", "List repo folders that have been connected on this machine").action(() => {
-        const locations = configManager.locations;
-        if (locations.length === 0) {
-            console.log(chalk.yellow("\n No repo locations saved yet."));
-            return;
-        }
-        console.log(chalk.bold("\n Saved Context Locations\n"));
-        locations.forEach((location, index) => {
-            console.log(chalk.cyan(` ${index + 1}. ${location.companyName} / ${location.projectName}`));
-            console.log(chalk.gray(`    ${location.repoRoot}`));
-            console.log(chalk.gray(`    Updated: ${new Date(location.updatedAt).toLocaleString()}`));
-        });
+    cli.command("locations", "List repo folders that have been connected on this machine").action(async () => {
+        await locationsCommandAction();
     });
 }

package/dist/commands/logout.d.ts

@@ -0,0 +1,2 @@
+export declare function logoutCommandAction(force?: boolean): Promise<void>;
+export declare function logoutCommand(cli: any): void;

package/dist/commands/logout.js

@@ -0,0 +1,34 @@
+import chalk from "chalk";
+import prompts from "prompts";
+import { configManager } from "../config.js";
+export async function logoutCommandAction(force = false) {
+    const current = configManager.config;
+    if (!current) {
+        console.log(chalk.yellow("No Umbrella session is currently saved on this device."));
+        return;
+    }
+    if (!force) {
+        const answer = await prompts({
+            type: "confirm",
+            name: "value",
+            message: `Disconnect this device from ${current.companyName} / ${current.projectName}?`,
+            initial: false,
+        });
+        if (!answer.value) {
+            console.log(chalk.yellow("\n Logout cancelled."));
+            return;
+        }
+    }
+    configManager.clearUmbrellaSession();
+    console.log(chalk.green("\n This device is now signed out of Umbrella Context."));
+    console.log(chalk.gray(' Your local providers and hub registries were kept on this device.'));
+    console.log(chalk.gray(' Run "umbrella-context setup" to connect again.'));
+}
+export function logoutCommand(cli) {
+    cli
+        .command("logout", "Disconnect this device from Umbrella Context and clear saved auth")
+        .option("--yes", "Skip confirmation")
+        .action(async (opts) => {
+        await logoutCommandAction(Boolean(opts?.yes));
+    });
+}

package/dist/commands/model.d.ts

@@ -0,0 +1,11 @@
+export declare function getModelsForActiveProvider(): string[];
+export type ModelCommandResult = {
+    action: "list" | "switch" | "inspect" | "ready";
+    changed: boolean;
+    activeModel: string | null;
+    providerName: string | null;
+    availableModels: string[];
+    inspectedModel?: string | null;
+};
+export declare function modelCommandAction(action: string, target?: string): Promise<ModelCommandResult | void>;
+export declare function modelCommand(cli: any): void;

package/dist/commands/model.js

@@ -0,0 +1,211 @@
+import chalk from "chalk";
+import prompts from "prompts";
+import { configManager } from "../config.js";
+import { getSessionState, recordSessionEvent, recordSessionModel, setSessionPanel } from "../repo-state.js";
+const MODELS_BY_PROVIDER = {
+    anthropic: ["claude-3-7-sonnet", "claude-3-5-sonnet", "claude-3-5-haiku"],
+    openai: ["gpt-5.4", "gpt-5.4-mini", "gpt-4.1"],
+    google: ["gemini-2.5-pro", "gemini-2.5-flash"],
+    openrouter: ["openai/gpt-4.1", "anthropic/claude-3.7-sonnet", "google/gemini-2.5-pro"],
+    "openai-compatible": ["custom-model"],
+};
+function getActiveProvider() {
+    const config = configManager.config;
+    const providers = configManager.providers;
+    return providers.find((entry) => entry.id === config?.activeProvider) ?? null;
+}
+export function getModelsForActiveProvider() {
+    const provider = getActiveProvider();
+    if (!provider)
+        return [];
+    return MODELS_BY_PROVIDER[provider.kind] ?? ["custom-model"];
+}
+export async function modelCommandAction(action, target) {
+    const normalized = action.toLowerCase();
+    const config = configManager.config;
+    if (!config) {
+        console.log(chalk.red("Not configured. Run: umbrella-context setup"));
+        return;
+    }
+    const provider = getActiveProvider();
+    if (!provider) {
+        console.log(chalk.yellow(" No active provider. Run: umbrella-context providers connect"));
+        return;
+    }
+    const models = getModelsForActiveProvider();
+    await setSessionPanel("model", config.activeModel ?? provider.id);
+    if (normalized === "list") {
+        await setSessionPanel("model", config.activeModel ?? provider.id);
+        console.log(chalk.bold(`\n Models for ${provider.name}\n`));
+        models.forEach((model, index) => {
+            const active = config.activeModel === model ? " (active)" : "";
+            console.log(` ${index + 1}. ${model}${active}`);
+        });
+        return {
+            action: "list",
+            changed: false,
+            activeModel: config.activeModel ?? null,
+            providerName: provider.name,
+            availableModels: models,
+        };
+    }
+    if (normalized === "ready") {
+        const ready = Boolean(config.activeModel);
+        await setSessionPanel("model", config.activeModel ?? provider.id);
+        await recordSessionEvent({
+            kind: "model",
+            title: ready ? `Model runtime ready for ${provider.name}` : `Model missing for ${provider.name}`,
+            detail: ready
+                ? `${config.activeModel} is ready for terminal work.`
+                : "Choose an active model before running provider-backed queries.",
+            panel: "model",
+            focus: config.activeModel ?? provider.id,
+            status: ready ? "success" : "warning",
+        });
+        console.log(chalk.bold(`\n Model readiness for ${provider.name}\n`));
+        console.log(` Active model: ${config.activeModel ?? "Not selected"}`);
+        console.log(` Available models: ${models.length}`);
+        console.log(` Runtime ready: ${ready ? "Yes" : "No"}`);
+        console.log("");
+        console.log(chalk.cyan(" Recommended Next Step"));
+        console.log(ready
+            ? "  - Runtime is ready. Ask a plain question or run umbrella-context query."
+            : "  - Run umbrella-context model switch to choose the active model.");
+        return {
+            action: "ready",
+            changed: false,
+            activeModel: config.activeModel ?? null,
+            providerName: provider.name,
+            availableModels: models,
+        };
+    }
+    if (normalized === "inspect") {
+        if (models.length === 0) {
+            console.log(chalk.yellow(" No models available for the active provider."));
+            return;
+        }
+        let selectedModel = target;
+        if (!selectedModel) {
+            const answer = await prompts({
+                type: "select",
+                name: "value",
+                message: `Choose a model to inspect for ${provider.name}`,
+                choices: models.map((model) => ({
+                    title: model,
+                    value: model,
+                })),
+            });
+            if (!answer.value) {
+                console.log(chalk.yellow("\n No model selected."));
+                return;
+            }
+            selectedModel = answer.value;
+        }
+        const inspectedModel = selectedModel;
+        await setSessionPanel("model", inspectedModel);
+        await recordSessionModel(inspectedModel);
+        await recordSessionEvent({
+            kind: "model",
+            title: `Inspected model ${inspectedModel}`,
+            detail: `${inspectedModel} belongs to ${provider.name} and is ${config.activeModel === inspectedModel ? "already active" : "available to activate"}.`,
+            panel: "model",
+            focus: inspectedModel,
+            status: "info",
+        });
+        console.log(chalk.bold(`\n ${inspectedModel}\n`));
+        console.log(` Provider: ${provider.name}`);
+        console.log(` Active: ${config.activeModel === inspectedModel ? "Yes" : "No"}`);
+        console.log(` Family: ${provider.kind}`);
+        console.log("");
+        console.log(chalk.cyan(" Recommended Next Step"));
+        if (config.activeModel !== inspectedModel) {
+            console.log(`  - Run umbrella-context model switch and choose ${inspectedModel} to make it active.`);
+        }
+        else {
+            console.log("  - Model is active. Ask a plain question or run umbrella-context query.");
+        }
+        return {
+            action: "inspect",
+            changed: false,
+            activeModel: config.activeModel ?? null,
+            providerName: provider.name,
+            availableModels: models,
+            inspectedModel,
+        };
+    }
+    if (normalized === "recent") {
+        const session = await getSessionState();
+        const recentModel = target ?? session?.recentModels?.[0] ?? config.activeModel ?? null;
+        if (!recentModel) {
+            console.log(chalk.yellow("\n No recent model in this session yet."));
+            return;
+        }
+        await setSessionPanel("model", recentModel);
+        await recordSessionModel(recentModel);
+        await recordSessionEvent({
+            kind: "model",
+            title: `Re-opened recent model ${recentModel}`,
+            detail: `Returned to the most recent model touched for ${provider.name}.`,
+            panel: "model",
+            focus: recentModel,
+            status: "info",
+        });
+        console.log(chalk.bold(`\n ${recentModel}\n`));
+        console.log(` Provider: ${provider.name}`);
+        console.log(` Active: ${config.activeModel === recentModel ? "Yes" : "No"}`);
+        console.log(` Family: ${provider.kind}`);
+        console.log("");
+        console.log(chalk.cyan(" Recommended Next Step"));
+        if (config.activeModel !== recentModel) {
+            console.log(`  - Run umbrella-context model switch and choose ${recentModel} to make it active.`);
+        }
+        else {
+            console.log("  - Model is active. Ask a plain question or run umbrella-context query.");
+        }
+        return {
+            action: "inspect",
+            changed: false,
+            activeModel: config.activeModel ?? null,
+            providerName: provider.name,
+            availableModels: models,
+            inspectedModel: recentModel,
+        };
+    }
+    if (normalized === "switch") {
+        const answer = await prompts({
+            type: "select",
+            name: "value",
+            message: `Choose the active model for ${provider.name}`,
+            choices: models.map((model) => ({ title: model, value: model })),
+        });
+        if (!answer.value) {
+            console.log(chalk.yellow("\n No model selected."));
+            return;
+        }
+        configManager.set({ activeModel: answer.value });
+        await setSessionPanel("model", answer.value);
+        await recordSessionModel(answer.value);
+        await recordSessionEvent({
+            kind: "model",
+            title: `Switched active model to ${answer.value}`,
+            detail: `${provider.name} is now paired with ${answer.value} for terminal work.`,
+            panel: "model",
+            focus: answer.value,
+            status: "success",
+        });
+        console.log(chalk.green(`\n Active model: ${answer.value}`));
+        return {
+            action: "switch",
+            changed: true,
+            activeModel: answer.value,
+            providerName: provider.name,
+            availableModels: models,
+        };
+    }
+    console.log(chalk.red("Use one of: model list, model inspect, model recent, model ready, model switch"));
+}
+export function modelCommand(cli) {
+    cli.command("model <action> [target]", "List or switch the active model for the current provider").action(async (action, target) => {
+        await modelCommandAction(action, target);
+    });
+}

package/dist/commands/providers.d.ts

@@ -0,0 +1,17 @@
+import { type SavedProvider } from "../config.js";
+export type ProvidersCommandResult = {
+    action: "list" | "connect" | "switch" | "disconnect" | "inspect" | "test";
+    changed: boolean;
+    activeProvider: SavedProvider | null;
+    needsModelSelection: boolean;
+    inspectedProvider?: SavedProvider | null;
+};
+export declare function getActiveProvider(): SavedProvider | null;
+export declare function getProviderReadinessSummary(): {
+    activeProvider: SavedProvider | null;
+    activeModel: string | null;
+    providerReady: boolean;
+    modelReady: boolean;
+};
+export declare function providersCommandAction(action: string, target?: string): Promise<ProvidersCommandResult | void>;
+export declare function providersCommand(cli: any): void;

package/dist/commands/providers.js

@@ -0,0 +1,344 @@
+import { randomUUID } from "crypto";
+import chalk from "chalk";
+import prompts from "prompts";
+import { configManager } from "../config.js";
+import { recordSessionEvent, recordSessionProvider, setSessionPanel } from "../repo-state.js";
+const PROVIDER_CHOICES = [
+    { kind: "anthropic", name: "Anthropic" },
+    { kind: "openai", name: "OpenAI" },
+    { kind: "google", name: "Google" },
+    { kind: "openrouter", name: "OpenRouter" },
+    { kind: "openai-compatible", name: "OpenAI-Compatible" },
+];
+function printProviders(providers, activeProvider) {
+    console.log(chalk.bold("\n Connected Providers\n"));
+    if (providers.length === 0) {
+        console.log(chalk.yellow(" No providers connected yet. Run: umbrella-context providers connect"));
+        return;
+    }
+    providers.forEach((provider, index) => {
+        const active = provider.id === activeProvider ? " (active)" : "";
+        const base = provider.baseUrl ? ` -> ${provider.baseUrl}` : "";
+        console.log(` ${index + 1}. ${provider.name} [${provider.kind}]${active}${base}`);
+    });
+}
+export function getActiveProvider() {
+    const config = configManager.config;
+    const providers = configManager.providers;
+    return providers.find((entry) => entry.id === config?.activeProvider) ?? null;
+}
+export function getProviderReadinessSummary() {
+    const activeProvider = getActiveProvider();
+    const activeModel = configManager.config?.activeModel ?? null;
+    return {
+        activeProvider,
+        activeModel,
+        providerReady: Boolean(activeProvider),
+        modelReady: Boolean(activeProvider && activeModel),
+    };
+}
+export async function providersCommandAction(action, target) {
+    const normalized = action.toLowerCase();
+    const providers = configManager.providers;
+    const activeProvider = configManager.config?.activeProvider;
+    await setSessionPanel("providers", null);
+    if (normalized === "list") {
+        await setSessionPanel("providers", "list");
+        printProviders(providers, activeProvider);
+        const current = getActiveProvider();
+        return {
+            action: "list",
+            changed: false,
+            activeProvider: current,
+            needsModelSelection: Boolean(current && !configManager.config?.activeModel),
+        };
+    }
+    if (normalized === "test") {
+        const current = getActiveProvider();
+        if (!current) {
+            console.log(chalk.yellow("\n No active provider. Run: umbrella-context providers connect"));
+            return;
+        }
+        await setSessionPanel("providers", current.id);
+        await recordSessionProvider(current.id);
+        const runtimeReady = Boolean(current.apiKey && configManager.config?.activeModel);
+        await recordSessionEvent({
+            kind: "provider",
+            title: runtimeReady ? `Runtime ready for ${current.name}` : `Runtime incomplete for ${current.name}`,
+            detail: runtimeReady
+                ? `${current.name} has both an API key and an active model.`
+                : !configManager.config?.activeModel
+                    ? `${current.name} is connected, but you still need to choose a model.`
+                    : `${current.name} is missing the configuration needed to run.`,
+            panel: "providers",
+            focus: current.id,
+            status: runtimeReady ? "success" : "warning",
+        });
+        console.log(chalk.bold(`\n Runtime check for ${current.name}\n`));
+        console.log(` Kind: ${current.kind}`);
+        console.log(` API key saved: ${current.apiKey ? "Yes" : "No"}`);
+        console.log(` Active model: ${configManager.config?.activeModel ?? "Not selected"}`);
+        console.log(` Runtime ready: ${runtimeReady ? "Yes" : "No"}`);
+        console.log("");
+        console.log(chalk.cyan(" Recommended Next Step"));
+        console.log(runtimeReady
+            ? "  - Runtime is ready. Ask a plain question or run umbrella-context query."
+            : '  - Run umbrella-context model switch to finish the runtime setup.');
+        return {
+            action: "test",
+            changed: false,
+            activeProvider: current,
+            needsModelSelection: !configManager.config?.activeModel,
+        };
+    }
+    if (normalized === "inspect") {
+        if (providers.length === 0) {
+            console.log(chalk.yellow(" No connected providers yet. Run: umbrella-context providers connect"));
+            return;
+        }
+        let selectedId = target;
+        if (!selectedId) {
+            const answer = await prompts({
+                type: "select",
+                name: "value",
+                message: "Choose a provider to inspect",
+                choices: providers.map((provider) => ({
+                    title: `${provider.name} (${provider.kind})`,
+                    value: provider.id,
+                })),
+            });
+            if (!answer.value) {
+                console.log(chalk.yellow("\n No provider selected."));
+                return;
+            }
+            selectedId = answer.value;
+        }
+        const provider = providers.find((entry) => entry.id === selectedId || entry.name.toLowerCase() === selectedId?.toLowerCase()) ?? null;
+        if (!provider)
+            return;
+        await setSessionPanel("providers", provider.id);
+        await recordSessionProvider(provider.id);
+        await recordSessionEvent({
+            kind: "provider",
+            title: `Inspected provider ${provider.name}`,
+            detail: `${provider.name} is ${provider.id === activeProvider ? "the active provider" : "saved on this device but not active"}.`,
+            panel: "providers",
+            focus: provider.id,
+            status: "info",
+        });
+        console.log(chalk.bold(`\n ${provider.name}\n`));
+        console.log(` Kind: ${provider.kind}`);
+        console.log(` Active: ${provider.id === activeProvider ? "Yes" : "No"}`);
+        console.log(` Base URL: ${provider.baseUrl ?? "Default"}`);
+        console.log(` Updated: ${new Date(provider.updatedAt).toLocaleString()}`);
+        console.log("");
+        console.log(chalk.cyan(" Recommended Next Step"));
+        if (provider.id !== activeProvider) {
+            console.log("  - Run umbrella-context providers switch to make this the active runtime.");
+        }
+        else if (!configManager.config?.activeModel) {
+            console.log("  - Run umbrella-context model switch to choose a model for this provider.");
+        }
+        else {
+            console.log("  - Runtime is ready. Ask a question or run umbrella-context query.");
+        }
+        return {
+            action: "inspect",
+            changed: false,
+            activeProvider: getActiveProvider(),
+            needsModelSelection: Boolean(provider.id === activeProvider && !configManager.config?.activeModel),
+            inspectedProvider: provider,
+        };
+    }
+    if (normalized === "recent") {
+        const session = await import("../repo-state.js").then((mod) => mod.getSessionState());
+        const recentId = target ?? session?.recentProviderIds?.[0];
+        if (!recentId) {
+            console.log(chalk.yellow("\n No recent provider in this session yet."));
+            return;
+        }
+        const provider = providers.find((entry) => entry.id === recentId) ?? null;
+        if (!provider) {
+            console.log(chalk.yellow("\n The most recent provider is no longer saved on this device."));
+            return;
+        }
+        await setSessionPanel("providers", provider.id);
+        await recordSessionProvider(provider.id);
+        await recordSessionEvent({
+            kind: "provider",
+            title: `Re-opened recent provider ${provider.name}`,
+            detail: "Returned to the provider you touched most recently in this session.",
+            panel: "providers",
+            focus: provider.id,
+            status: "info",
+        });
+        console.log(chalk.bold(`\n ${provider.name}\n`));
+        console.log(` Kind: ${provider.kind}`);
+        console.log(` Active: ${provider.id === activeProvider ? "Yes" : "No"}`);
+        console.log(` Base URL: ${provider.baseUrl ?? "Default"}`);
+        console.log(` Updated: ${new Date(provider.updatedAt).toLocaleString()}`);
+        console.log("");
+        console.log(chalk.cyan(" Recommended Next Step"));
+        if (provider.id !== activeProvider) {
+            console.log("  - Run umbrella-context providers switch to make this the active runtime.");
+        }
+        else if (!configManager.config?.activeModel) {
+            console.log("  - Run umbrella-context model switch to choose a model for this provider.");
+        }
+        else {
+            console.log("  - Runtime is ready. Ask a question or run umbrella-context query.");
+        }
+        return {
+            action: "inspect",
+            changed: false,
+            activeProvider: getActiveProvider(),
+            needsModelSelection: Boolean(provider.id === activeProvider && !configManager.config?.activeModel),
+            inspectedProvider: provider,
+        };
+    }
+    if (normalized === "connect") {
+        const answer = await prompts([
+            {
+                type: "select",
+                name: "kind",
+                message: "Choose a provider",
+                choices: PROVIDER_CHOICES.map((entry) => ({ title: entry.name, value: entry.kind })),
+            },
+            {
+                type: "text",
+                name: "label",
+                message: "What label should this provider use on this device?",
+            },
+            {
+                type: "password",
+                name: "apiKey",
+                message: "Paste the provider API key (stored only on this device)",
+            },
+            {
+                type: (prev) => (prev === "openai-compatible" ? "text" : null),
+                name: "baseUrl",
+                message: "Base URL for the compatible API",
+            },
+        ]);
+        if (!answer.kind || !answer.label || !answer.apiKey) {
+            console.log(chalk.yellow("\n Provider connection cancelled."));
+            return;
+        }
+        const provider = {
+            id: randomUUID(),
+            name: answer.label,
+            kind: answer.kind,
+            apiKey: answer.apiKey,
+            baseUrl: answer.baseUrl || undefined,
+            updatedAt: new Date().toISOString(),
+        };
+        configManager.upsertProvider(provider);
+        configManager.set({
+            activeProvider: provider.id,
+            activeModel: undefined,
+        });
+        await setSessionPanel("providers", provider.id);
+        await recordSessionProvider(provider.id);
+        await recordSessionEvent({
+            kind: "provider",
+            title: `Connected provider ${provider.name}`,
+            detail: `${provider.name} is now the active provider for this device and needs a model next.`,
+            panel: "providers",
+            focus: provider.id,
+            status: "success",
+        });
+        console.log(chalk.green(`\n Connected ${provider.name}.`));
+        console.log(chalk.gray(" Use 'umbrella-context model switch' to choose a model next."));
+        return {
+            action: "connect",
+            changed: true,
+            activeProvider: provider,
+            needsModelSelection: true,
+        };
+    }
+    if (normalized === "switch") {
+        if (providers.length === 0) {
+            console.log(chalk.yellow(" No connected providers yet. Run: umbrella-context providers connect"));
+            return;
+        }
+        const answer = await prompts({
+            type: "select",
+            name: "value",
+            message: "Choose the active provider",
+            choices: providers.map((provider) => ({
+                title: `${provider.name} (${provider.kind})`,
+                value: provider.id,
+            })),
+        });
+        if (!answer.value) {
+            console.log(chalk.yellow("\n No provider selected."));
+            return;
+        }
+        configManager.set({ activeProvider: answer.value, activeModel: undefined });
+        const provider = providers.find((entry) => entry.id === answer.value);
+        if (provider) {
+            await setSessionPanel("providers", provider.id);
+            await recordSessionProvider(provider.id);
+            await recordSessionEvent({
+                kind: "provider",
+                title: `Switched active provider to ${provider.name}`,
+                detail: "The active model was cleared so you can choose one for this provider.",
+                panel: "providers",
+                focus: provider.id,
+                status: "success",
+            });
+        }
+        console.log(chalk.green(`\n Active provider: ${provider?.name ?? "Updated"}`));
+        return {
+            action: "switch",
+            changed: true,
+            activeProvider: provider ?? null,
+            needsModelSelection: true,
+        };
+    }
+    if (normalized === "disconnect") {
+        if (providers.length === 0) {
+            console.log(chalk.yellow(" No connected providers yet."));
+            return;
+        }
+        const answer = await prompts({
+            type: "select",
+            name: "value",
+            message: "Choose a provider to disconnect",
+            choices: providers.map((provider) => ({
+                title: `${provider.name} (${provider.kind})`,
+                value: provider.id,
+            })),
+        });
+        if (!answer.value) {
+            console.log(chalk.yellow("\n No provider selected."));
+            return;
+        }
+        const provider = providers.find((entry) => entry.id === answer.value);
+        configManager.removeProvider(answer.value);
+        await setSessionPanel("providers", provider?.id ?? null);
+        await recordSessionEvent({
+            kind: "provider",
+            title: `Disconnected ${provider?.name ?? "a provider"}`,
+            detail: getActiveProvider()
+                ? `${getActiveProvider().name} is still available as the active provider.`
+                : "No active provider is left on this device.",
+            panel: "providers",
+            focus: provider?.id ?? null,
+            status: "warning",
+        });
+        console.log(chalk.green(`\n Disconnected ${provider?.name ?? "provider"}.`));
+        return {
+            action: "disconnect",
+            changed: true,
+            activeProvider: getActiveProvider(),
+            needsModelSelection: false,
+        };
+    }
+    console.log(chalk.red("Use one of: providers list, providers inspect, providers recent, providers test, providers connect, providers switch, providers disconnect"));
+}
+export function providersCommand(cli) {
+    cli.command("providers <action> [target]", "Manage local LLM providers for the interactive Context terminal").action(async (action, target) => {
+        await providersCommandAction(action, target);
+    });
+}