gnosys 5.11.4 → 5.12.2

package/dist/lib/setup/sections/providers.js

@@ -0,0 +1,307 @@
+/**
+ * Setup: Providers — API keys and provider credentials.
+ *
+ * `gnosys setup providers` or summary menu row "providers".
+ */
+import { loadConfig, updateConfig, } from "../../config.js";
+import { apiKeyServiceName, deleteStoredSecret, listStoredKeySlots, maskKeySnippet, storeApiKeySecret, } from "../../apiKeyVault.js";
+import { resolveActiveStorePath } from "../storePath.js";
+import { safeQuestion } from "../ui/safePrompt.js";
+import { Header } from "../ui/header.js";
+import { Title } from "../ui/title.js";
+import { Footer } from "../ui/footer.js";
+import { printStatus } from "../ui/status.js";
+import { c, color, glyph } from "../ui/tokens.js";
+import { CLOUD_PROVIDERS_FOR_KEYS, LOCAL_PROVIDERS, renderProviderLabel, renderProviderMark, } from "../providerGlyphs.js";
+async function ask(rl, prompt) {
+    return (await safeQuestion(rl, prompt)).trim();
+}
+async function askYesNo(rl, prompt, defaultYes = true) {
+    const hint = defaultYes ? " [Y/n] " : " [y/N] ";
+    const answer = (await ask(rl, prompt + hint)).toLowerCase();
+    if (!answer)
+        return defaultYes;
+    return answer === "y" || answer === "yes";
+}
+async function askChoice(rl, prompt, choices, defaultIdx = 0) {
+    console.log("");
+    if (prompt)
+        console.log(prompt);
+    choices.forEach((ch, i) => {
+        const marker = i === defaultIdx ? color(c.textDim, " (default)") : "";
+        console.log(`  ${i + 1}. ${ch}${marker}`);
+    });
+    for (let attempts = 0; attempts < 5; attempts++) {
+        const answer = await ask(rl, ` ${color(c.accent, glyph.prompt)} `);
+        if (!answer)
+            return defaultIdx;
+        const n = parseInt(answer, 10);
+        if (!Number.isNaN(n) && n >= 1 && n <= choices.length)
+            return n - 1;
+        printStatus("warn", `pick a number 1–${choices.length}`);
+    }
+    return defaultIdx;
+}
+function slotScopeLabel(slot) {
+    if (slot.scope === "global")
+        return "global";
+    return "provider";
+}
+async function clearConfigProviderApiKey(storePath, provider) {
+    const cfg = await loadConfig(storePath);
+    const patch = {};
+    switch (provider) {
+        case "anthropic":
+            if (!cfg.llm.anthropic.apiKey)
+                return;
+            patch.anthropic = { ...cfg.llm.anthropic, apiKey: "" };
+            break;
+        case "openai":
+            if (!cfg.llm.openai.apiKey)
+                return;
+            patch.openai = { ...cfg.llm.openai, apiKey: "" };
+            break;
+        case "groq":
+            if (!cfg.llm.groq.apiKey)
+                return;
+            patch.groq = { ...cfg.llm.groq, apiKey: "" };
+            break;
+        case "xai":
+            if (!cfg.llm.xai.apiKey)
+                return;
+            patch.xai = { ...cfg.llm.xai, apiKey: "" };
+            break;
+        case "mistral":
+            if (!cfg.llm.mistral.apiKey)
+                return;
+            patch.mistral = { ...cfg.llm.mistral, apiKey: "" };
+            break;
+        case "openrouter":
+            if (!cfg.llm.openrouter.apiKey)
+                return;
+            patch.openrouter = { ...cfg.llm.openrouter, apiKey: "" };
+            break;
+        case "custom":
+            if (!cfg.llm.custom?.apiKey)
+                return;
+            patch.custom = { ...cfg.llm.custom, apiKey: "" };
+            break;
+        default:
+            return;
+    }
+    await updateConfig(storePath, { llm: patch });
+}
+function renderProviderRow(index, provider, cfg, local = false) {
+    const mark = renderProviderMark(provider);
+    const slots = listStoredKeySlots(cfg, provider);
+    const hasKey = slots.length > 0;
+    const status = local
+        ? color(c.textDim, "local · no key")
+        : hasKey
+            ? color(c.ok, `${glyph.ok} key`)
+            : color(c.textGhost, "no key");
+    const preview = hasKey && !local ? `  ${color(c.textDim, slots[0].preview ?? "")}` : "";
+    const num = color(c.textDim, String(index));
+    const name = color(c.text, provider.padEnd(12));
+    return ` ${num}  ${mark}  ${name}  ${status}${preview}`;
+}
+async function manageProviderKeys(rl, storePath, cfg, provider) {
+    let changed = false;
+    while (true) {
+        const slots = listStoredKeySlots(cfg, provider);
+        console.log("");
+        console.log(Header(["gnosys", "setup", "providers", provider]));
+        console.log("");
+        console.log(Title(renderProviderLabel(provider), "stored credentials for this provider"));
+        console.log("");
+        if (slots.length === 0) {
+            console.log(`  ${color(c.textDim, "No keys found for this provider.")}`);
+            console.log(`  ${color(c.textDim, `Add one with rotate — saved as GNOSYS_GLOBAL_${provider.toUpperCase()}_KEY`)}`);
+            console.log("");
+        }
+        else {
+            for (const slot of slots) {
+                const scope = color(c.textMid, slotScopeLabel(slot).padEnd(14));
+                const src = color(c.textDim, slot.source.padEnd(22));
+                const prev = slot.preview ? color(c.text, slot.preview) : "";
+                console.log(`  ${scope} ${src} ${prev}`);
+                console.log(`  ${color(c.textGhost, "      " + slot.service)}`);
+            }
+            console.log("");
+        }
+        const defaultAction = slots.length > 0 ? 2 : 0; // when they have a key, default to "make default + model"
+        const choice = await askChoice(rl, "Actions", [
+            slots.length === 0 ? "Add API key (global)" : "Rotate global API key",
+            "Delete one stored key…",
+            "Use this provider as default for everything + pick model",
+            "Back",
+        ], defaultAction);
+        if (choice === 3) {
+            return changed;
+        }
+        if (choice === 2) {
+            // "Use this provider as default for everything + pick model"
+            // Set it as the global default provider
+            const current = await loadConfig(storePath);
+            await updateConfig(storePath, {
+                llm: {
+                    ...current.llm,
+                    defaultProvider: provider,
+                },
+                // Clear per-task overrides so this truly becomes the single default for everything
+                taskModels: {},
+            });
+            printStatus("ok", `default provider set to ${provider} (all tasks now default to it)`);
+            // Immediately let them pick a model for it (using the same picker the main flow uses)
+            try {
+                const { fetchDynamicModels } = await import("../../setup.js");
+                const { pickModel } = await import("../../setup.js");
+                const dynamicModels = await fetchDynamicModels();
+                const tiers = dynamicModels[provider] ?? [];
+                let chosenModel;
+                if (tiers.length > 0) {
+                    chosenModel = await pickModel(rl, provider, dynamicModels, `Default model for ${provider} (used for all tasks)`, current.llm[provider]?.model);
+                }
+                else {
+                    chosenModel = await ask(rl, `Enter default model name for ${provider}: `);
+                }
+                if (chosenModel) {
+                    const after = await loadConfig(storePath);
+                    await updateConfig(storePath, {
+                        llm: {
+                            ...after.llm,
+                            [provider]: {
+                                ...(after.llm[provider] || {}),
+                                model: chosenModel,
+                            },
+                        },
+                    });
+                    printStatus("ok", `default model set · ${provider} / ${chosenModel}`);
+                    printStatus("progress", "all tasks will now default to this provider + model", "use task routing for per-task overrides");
+                    changed = true;
+                }
+                else {
+                    printStatus("progress", "model left unchanged — you can set it from task routing");
+                }
+            }
+            catch (_err) {
+                printStatus("warn", "could not pick model right now", "you can set a default model from the main setup → task routing");
+            }
+            cfg = await loadConfig(storePath);
+            continue;
+        }
+        if (choice === 0) {
+            const service = apiKeyServiceName(provider, "global");
+            console.log("");
+            console.log(`  ${color(c.textDim, `Keychain: ${service}`)}`);
+            const key = await ask(rl, ` ${color(c.accent, glyph.prompt)} Enter ${provider} API key: `);
+            if (!key) {
+                printStatus("warn", "skipped");
+                continue;
+            }
+            if (storeApiKeySecret(service, key, provider)) {
+                const store = process.platform === "darwin" ? "macOS Keychain" : "GNOME Keyring";
+                printStatus("ok", "key saved", `${store} · ${maskKeySnippet(key)}`);
+                changed = true;
+            }
+            else {
+                printStatus("fail", "could not write to secure store");
+            }
+            continue;
+        }
+        if (choice === 1) {
+            if (slots.length === 0) {
+                printStatus("warn", "nothing to delete");
+                continue;
+            }
+            const labels = slots.map((s, i) => `${i + 1}. ${slotScopeLabel(s)} · ${s.service}`);
+            const pick = await askChoice(rl, "Delete which key?", [...labels, "Cancel"], labels.length);
+            if (pick >= slots.length)
+                continue;
+            const slot = slots[pick];
+            if (slot.service === "gnosys.json") {
+                if (await askYesNo(rl, "Clear API key from gnosys.json?", false)) {
+                    await clearConfigProviderApiKey(storePath, provider);
+                    printStatus("ok", "cleared gnosys.json apiKey");
+                    changed = true;
+                    cfg = await loadConfig(storePath);
+                }
+                continue;
+            }
+            if (slot.source.startsWith("$")) {
+                printStatus("warn", `unset ${slot.service} in your shell or ~/.config/gnosys/.env`, "env vars cannot be removed from here");
+                continue;
+            }
+            if (await askYesNo(rl, `Delete ${slot.service} from secure store?`, false)) {
+                if (deleteStoredSecret(slot.service)) {
+                    printStatus("ok", "deleted", slot.service);
+                    changed = true;
+                }
+                else {
+                    printStatus("fail", "delete failed or entry not found");
+                }
+            }
+        }
+    }
+}
+/**
+ * Providers + API key management screen.
+ */
+export async function runProvidersSetup(opts) {
+    const storePath = resolveActiveStorePath(opts.directory);
+    let cfg = await loadConfig(storePath);
+    let anyChange = false;
+    const menuProviders = [
+        ...CLOUD_PROVIDERS_FOR_KEYS,
+        ...LOCAL_PROVIDERS,
+    ];
+    while (true) {
+        console.log("");
+        console.log(Header(["gnosys", "setup", "providers"]));
+        console.log("");
+        console.log(Title("Providers", "API keys live here. Set a global default (or per-task models) from the main setup menu."));
+        console.log("");
+        for (let i = 0; i < menuProviders.length; i++) {
+            const p = menuProviders[i];
+            const local = LOCAL_PROVIDERS.includes(p);
+            console.log(renderProviderRow(i + 1, p, cfg, local));
+        }
+        console.log("");
+        console.log(`  ${color(c.textDim, "Keys: global = GNOSYS_GLOBAL_<PROVIDER>_KEY (shared across tasks)")}`);
+        console.log(Footer("number · manage    enter · back"));
+        const answer = await ask(opts.rl, ` ${color(c.accent, glyph.prompt)} `);
+        if (!answer) {
+            return anyChange;
+        }
+        const n = parseInt(answer, 10);
+        if (Number.isNaN(n) || n < 1 || n > menuProviders.length) {
+            printStatus("warn", `enter 1–${menuProviders.length} or press Enter to go back`);
+            continue;
+        }
+        const provider = menuProviders[n - 1];
+        if (LOCAL_PROVIDERS.includes(provider)) {
+            console.log("");
+            printStatus("ok", `${provider} is local`, "no API key required");
+            continue;
+        }
+        const changed = await manageProviderKeys(opts.rl, storePath, cfg, provider);
+        if (changed) {
+            anyChange = true;
+            cfg = await loadConfig(storePath);
+        }
+    }
+}
+/** Summary line: how many providers have keys. */
+export async function describeProvidersSummary(cfg) {
+    const named = [];
+    for (const p of CLOUD_PROVIDERS_FOR_KEYS) {
+        if (listStoredKeySlots(cfg, p).length > 0) {
+            named.push(p);
+        }
+    }
+    if (named.length === 0)
+        return "no keys stored";
+    const preview = named.slice(0, 3).join(", ");
+    const suffix = named.length > 3 ? ` +${named.length - 3}` : "";
+    return `${named.length} with keys · ${preview}${suffix}`;
+}

package/dist/lib/setup/sections/routing.d.ts

@@ -2,9 +2,7 @@
  * Setup: Task Routing.
  *
  * Standalone wizard for configuring per-task LLM routing
- * (structuring / synthesis / vision / transcription / dream).
- * Extracted from the linear `runSetup` flow so it can be invoked
- * directly via `gnosys setup routing` or from the summary-first menu.
+ * (structuring / synthesis / vision / transcription / chat / dream).
  */
 import type { Interface as ReadlineInterface } from "readline/promises";
 export interface RoutingOptions {
@@ -12,8 +10,6 @@ export interface RoutingOptions {
     directory: string;
 }
 /**
- * Run the task-routing wizard. Reads current config, walks the 3-way choice
- * (keep defaults / customize individual / use same for all), writes any
- * overrides via updateConfig(). Returns true if config was changed.
+ * Run the task-routing wizard.
  */
 export declare function runRoutingSetup(opts: RoutingOptions): Promise<boolean>;

package/dist/lib/setup/sections/routing.js

@@ -2,17 +2,18 @@
  * Setup: Task Routing.
  *
  * Standalone wizard for configuring per-task LLM routing
- * (structuring / synthesis / vision / transcription / dream).
- * Extracted from the linear `runSetup` flow so it can be invoked
- * directly via `gnosys setup routing` or from the summary-first menu.
+ * (structuring / synthesis / vision / transcription / chat / dream).
  */
-import { loadConfig, updateConfig, resolveTaskModel, getProviderModel, } from "../../config.js";
+import { loadConfig, updateConfig, getProviderModel, } from "../../config.js";
+import { buildApiKeyRequirementsFromConfig, buildEffectiveRouting, ensureApiKeys, } from "../../apiKeyVault.js";
 import { safeQuestion } from "../ui/safePrompt.js";
 import { Header } from "../ui/header.js";
 import { Title } from "../ui/title.js";
 import { Footer } from "../ui/footer.js";
 import { printStatus } from "../ui/status.js";
 import { classifyCost, renderRoutingTable, renderRoutingDiff, } from "../routingRender.js";
+import { runCommaListRoutingEditor } from "./taskRoutingEditor.js";
+import { resolveActiveStorePath } from "../storePath.js";
 const DIM = "\x1b[2m";
 const RESET = "\x1b[0m";
 const TASKS = ["structuring", "synthesis", "chat", "vision", "transcription"];
@@ -45,23 +46,6 @@ async function askChoice(rl, prompt, choices, defaultIdx = 0) {
     }
     return defaultIdx;
 }
-function buildEffectiveRouting(cfg) {
-    const out = {};
-    for (const t of TASKS) {
-        const r = resolveTaskModel(cfg, t);
-        out[t] = { provider: r.provider, model: r.model };
-    }
-    out.dream = {
-        provider: cfg.dream?.provider ?? "ollama",
-        model: cfg.dream?.model ?? getProviderModel(cfg, (cfg.dream?.provider ?? "ollama")),
-    };
-    return out;
-}
-/**
- * Build the table-row payload from current routing data. Marks any
- * task whose effective provider/model differs from the snapshot as
- * `changed` so the renderer can highlight it (▶ in accent-hi).
- */
 function buildTaskRows(routing, baseline, dreamEnabled) {
     const rows = [];
     for (const t of [...TASKS, "dream"]) {
@@ -75,72 +59,68 @@ function buildTaskRows(routing, baseline, dreamEnabled) {
     return rows;
 }
 /**
- * Run the task-routing wizard. Reads current config, walks the 3-way choice
- * (keep defaults / customize individual / use same for all), writes any
- * overrides via updateConfig(). Returns true if config was changed.
+ * Run the task-routing wizard.
  */
 export async function runRoutingSetup(opts) {
-    const cfg = await loadConfig(opts.directory);
+    const storePath = resolveActiveStorePath(opts.directory);
+    const cfg = await loadConfig(storePath);
     const provider = cfg.llm.defaultProvider;
     const model = getProviderModel(cfg, provider);
     console.log("");
     console.log(Header(["gnosys", "setup", "routing"]));
     console.log("");
-    console.log(Title("Task routing", "each task can use a different model — overrides the default"));
+    console.log(Title("Task routing", "pick provider + model per task — set API keys under setup providers"));
     console.log("");
     const dreamEnabled = !!cfg.dream?.enabled;
     const baseline = buildEffectiveRouting(cfg);
-    // Initial table: nothing has changed yet, so every row is `changed: false`.
     const initialRows = buildTaskRows(baseline, baseline, dreamEnabled);
     console.log(renderRoutingTable(initialRows));
     console.log("");
-    // v5.9.4 Bug 5 — clearer option copy. Option 1 keeps current routing
-    // (skip, no changes). Option 2 customises individual tasks. Option 3
-    // CLEARS all task overrides so every task falls back to the default
-    // provider; we show a Diff() of what's being removed before committing.
     const choice = await askChoice(opts.rl, "What would you like to do?", [
         "Keep current routing (no changes)",
-        "Customize individual tasks",
-        "Reset all task overrides to use default",
+        "Edit tasks — set the same provider + model for all tasks (simple global default)",
+        "Edit tasks — pick different providers/models for specific tasks (advanced)",
+        "Reset all task overrides to the current default (the one shown in the main setup summary)",
     ], 0);
     if (choice === 0) {
         console.log(`${DIM}No changes.${RESET}`);
         return false;
     }
-    const newTaskModels = {
-        ...(cfg.taskModels ?? {}),
-    };
-    let dreamProvider = (cfg.dream?.provider ?? "ollama");
-    let dreamModel = cfg.dream?.model ?? "llama3.2";
-    let dreamEnabledNew = dreamEnabled;
     if (choice === 1) {
-        // Customize each task
-        for (const t of TASKS) {
-            const current = baseline[t];
-            const keep = await askYesNo(opts.rl, `Keep ${t} → ${current.provider} / ${current.model}?`, true);
-            if (!keep) {
-                const p = await ask(opts.rl, `  Provider for ${t} (e.g. anthropic, openai, xai, ollama): `);
-                const m = await ask(opts.rl, `  Model for ${t}: `);
-                if (p && m)
-                    newTaskModels[t] = { provider: p, model: m };
+        // Edit tasks — set the same provider + model for all tasks (simple global default)
+        console.log("");
+        printStatus("progress", "setting a single default for all tasks…");
+        try {
+            const { fetchDynamicModels } = await import("../../setup.js");
+            const { pickModel } = await import("../../setup.js");
+            const dynamicModels = await fetchDynamicModels();
+            const currentModel = getProviderModel(cfg, provider);
+            const chosenModel = await pickModel(opts.rl, provider, dynamicModels, `Default model for ${provider} (used for all tasks + dream)`, currentModel);
+            if (chosenModel && chosenModel !== currentModel) {
+                const after = await loadConfig(storePath);
+                await updateConfig(storePath, {
+                    llm: {
+                        ...after.llm,
+                        [provider]: {
+                            ...(after.llm[provider] || {}),
+                            model: chosenModel,
+                        },
+                    },
+                    // Clear per-task overrides so everything truly uses the single default
+                    taskModels: {},
+                });
+                printStatus("ok", `default set for everything · ${provider} / ${chosenModel}`);
             }
-        }
-        // Dream
-        dreamEnabledNew = await askYesNo(opts.rl, "Enable dream mode?", dreamEnabled);
-        if (dreamEnabledNew) {
-            const keepDream = await askYesNo(opts.rl, `Keep dream → ${dreamProvider} / ${dreamModel}?`, true);
-            if (!keepDream) {
-                const p = (await ask(opts.rl, "  Provider for dream: "));
-                if (p)
-                    dreamProvider = p;
-                dreamModel = (await ask(opts.rl, "  Model for dream: ")) || dreamModel;
+            else {
+                printStatus("ok", "no change to the global default");
             }
         }
+        catch (err) {
+            printStatus("warn", "could not update default model", String(err));
+        }
+        return true;
     }
-    else {
-        // v5.9.4 Bug 5 — choice === 2 now means "reset all task overrides to use
-        // default". Show the user what's about to be cleared (the rows currently
-        // pinned to non-default providers) before committing.
+    if (choice === 3) {
         const { Diff } = await import("../ui/diff.js");
         const overridesBeingCleared = Object.entries(cfg.taskModels ?? {})
             .filter(([, v]) => v.provider !== provider || v.model !== model)
@@ -157,31 +137,29 @@ export async function runRoutingSetup(opts) {
         else {
             console.log(`${DIM}No overrides to clear — already using default everywhere.${RESET}`);
         }
-        const confirmReset = await askYesNo(opts.rl, "Reset all task overrides?", true);
+        console.log(`${DIM}The current default is ${provider} / ${model} (set via the main setup "Default provider" or the simple global option above).${RESET}`);
+        const confirmReset = await askYesNo(opts.rl, "Reset all task overrides to the current default?", true);
         if (!confirmReset) {
             console.log(`${DIM}Cancelled.${RESET}`);
             return false;
         }
-        // Clear every overridden task back to default by deleting the keys.
-        for (const t of TASKS)
-            delete newTaskModels[t];
+        await updateConfig(storePath, { taskModels: {} });
+        printStatus("ok", "routing reset", "all tasks now use the global default provider/model");
+        console.log(Footer("press enter to return"));
+        return true;
+    }
+    // choice === 2 → advanced per-task editor (the powerful comma-list path)
+    const patch = await runCommaListRoutingEditor(opts.rl, storePath, cfg);
+    if (!patch) {
+        return false;
     }
-    // Persist
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    await updateConfig(opts.directory, {
-        taskModels: newTaskModels,
-        dream: {
-            ...(cfg.dream ?? {}),
-            enabled: dreamEnabledNew,
-            provider: dreamProvider,
-            model: dreamModel,
-        },
+    await updateConfig(storePath, {
+        taskModels: patch.taskModels,
+        dream: patch.dream,
     });
-    // v5.9.3 Screen 4 — re-render the table with `▶` markers on changed rows
-    // followed by a Diff() block summarizing what shipped. Then a final
-    // status line that names the saved file.
-    const updatedCfg = await loadConfig(opts.directory);
+    const updatedCfg = await loadConfig(storePath);
     const updatedRouting = buildEffectiveRouting(updatedCfg);
+    const dreamEnabledNew = !!updatedCfg.dream?.enabled;
     const finalRows = buildTaskRows(updatedRouting, baseline, dreamEnabledNew);
     console.log("");
     console.log(renderRoutingTable(finalRows));
@@ -196,8 +174,15 @@ export async function runRoutingSetup(opts) {
     }
     console.log(renderRoutingDiff(diffEntries));
     console.log("");
-    printStatus("ok", "routing saved", `${opts.directory}/.gnosys/gnosys.json`);
-    // Footer hint (right-aligned) for any follow-up navigation in the menu flow.
+    printStatus("ok", "routing saved", `${storePath}/gnosys.json`);
+    const keyReqs = buildApiKeyRequirementsFromConfig(updatedCfg);
+    if (keyReqs.length > 0) {
+        const askInput = async (r, prompt) => ask(r, `${prompt}: `);
+        await ensureApiKeys(opts.rl, keyReqs, askInput, {
+            dim: DIM,
+            reset: RESET,
+        });
+    }
     console.log(Footer("press enter to return"));
     return true;
 }

package/dist/lib/setup/sections/taskRoutingEditor.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Comma-list task routing editor (provider + model per selected task).
+ */
+import type { Interface as ReadlineInterface } from "readline/promises";
+import type { GnosysConfig } from "../../config.js";
+/**
+ * Let the user pick tasks by number, then provider + model for each.
+ * Returns a patch for taskModels + dream, or null if cancelled.
+ */
+export declare function runCommaListRoutingEditor(rl: ReadlineInterface, storePath: string, cfg: GnosysConfig): Promise<{
+    taskModels: NonNullable<GnosysConfig["taskModels"]>;
+    dream: GnosysConfig["dream"];
+} | null>;