umbrella-context 0.1.2 → 0.1.32

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,225 @@
+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"];
+}
+function resolveModel(models, target) {
+    if (!target)
+        return null;
+    const normalized = target.toLowerCase();
+    return models.find((model) => model.toLowerCase() === normalized) ?? null;
+}
+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") {
+        let selectedModel = resolveModel(models, target);
+        if (!selectedModel) {
+            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;
+            }
+            selectedModel = answer.value;
+        }
+        if (!selectedModel) {
+            console.log(chalk.yellow("\n No model selected."));
+            return;
+        }
+        configManager.set({ activeModel: selectedModel });
+        await setSessionPanel("model", selectedModel);
+        await recordSessionModel(selectedModel);
+        await recordSessionEvent({
+            kind: "model",
+            title: `Switched active model to ${selectedModel}`,
+            detail: `${provider.name} is now paired with ${selectedModel} for terminal work.`,
+            panel: "model",
+            focus: selectedModel,
+            status: "success",
+        });
+        console.log(chalk.green(`\n Active model: ${selectedModel}`));
+        return {
+            action: "switch",
+            changed: true,
+            activeModel: selectedModel,
+            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" | "setup";
+    changed: boolean;
+    activeProvider: SavedProvider | null;
+    needsModelSelection: boolean;
+    inspectedProvider?: SavedProvider | null;
+};
+export declare function getActiveProvider(): SavedProvider | null;
+export declare function getProviderReadinessSummary(): {
+    activeModel: string | null;
+    activeProvider: SavedProvider | null;
+    modelReady: boolean;
+    providerReady: boolean;
+};
+export declare function providersCommandAction(action: string, target?: string): Promise<ProvidersCommandResult | void>;
+export declare function providersCommand(cli: any): void;