@giovannijecha/jecode 0.3.2 → 0.5.0

package/dist/provider-commands.js

@@ -1,227 +1,81 @@
-// Provider and model command flows.
-import { heading } from "./tui/picker.js";
-import { PROVIDERS } from "./providers/index.js";
-import { readSettings } from "./settings.js";
-import { authenticationNeed, ensureProviderAuthentication, } from "./credential-commands.js";
-import { providerFailure } from "./provider-errors.js";
+// Provider access and connection management. Runtime selection lives in /models.
+import { saveCommandSettings } from "./command-settings.js";
+import { apiKeyCommand } from "./credential-commands.js";
+import { credentialSource } from "./credentials.js";
+import { ollamaConnectionHint, ollamaConnectionSetting, } from "./ollama-settings-command.js";
+import { openAIAccountHint } from "./openai-account.js";
+import { openAIAccountCommand } from "./openai-account-command.js";
 import { providerLabel } from "./provider-label.js";
-import { compatibleEffort } from "./effort.js";
-/**
- * The provider menu.
- *
- * Every provider is offered, including the ones that cannot run: the reason
- * one is unusable — the variable it wants, by name — is worth more on screen
- * than the row would be worth hidden. A blocked choice opens the same masked
- * credential flow used by settings, and cancellation leaves the old choice.
- */
-export async function providersCommand(session, host, behavior = {}) {
+import { PROVIDERS } from "./providers/index.js";
+import { ollamaConnection } from "./providers/ollama.js";
+import { heading } from "./tui/picker.js";
+const OLLAMA_KEY = "OLLAMA_API_KEY";
+/** The single control plane for API keys, OAuth accounts, and Ollama endpoints. */
+export async function providersCommand(session, host) {
     const choose = chooser(host);
     if (choose === undefined)
-        return false;
-    const options = PROVIDERS.map((provider) => ({
-        label: provider.id,
-        hint: provider.blocked() ?? "ready",
-    }));
-    const at = PROVIDERS.findIndex((provider) => provider.id === session.provider.id);
-    const index = await choose({
-        title: heading("provider", "where the next turn runs", session.palette),
-        options,
-        index: Math.max(0, at),
-    });
-    if (index === undefined)
-        return false;
-    const chosen = PROVIDERS[index];
-    if (chosen === undefined)
-        return false;
-    // Picking the provider already in use is not a no-op when it cannot run:
-    // it is how the user asks to fix the reason it cannot.
-    if (chosen.id === session.provider.id) {
-        if (!(await ensureProviderAuthentication(chosen, session, host)))
-            return false;
-        return session.model === ""
-            ? modelsCommand(session, host, { announce: false, save: behavior.save })
-            : true;
-    }
-    // A provider that cannot run is worth one offer to fix it, here, rather
-    // than a note telling the user to leave and export something.
-    const blocked = chosen.blocked();
-    if (blocked !== undefined) {
-        await ensureProviderAuthentication(chosen, session, host);
-        const still = chosen.blocked();
-        if (still !== undefined) {
-            host.emit({
-                kind: "notice",
-                text: `${providerLabel(chosen.id)} still needs ${authenticationNeed(chosen)} · provider unchanged`,
-                tone: "warn",
-            });
-            return false;
-        }
-    }
-    const before = {
-        provider: session.provider,
-        model: session.model,
-        providerId: session.config.providerId,
-        configModel: session.config.model,
-        effort: session.config.effort,
-    };
-    session.provider = chosen;
-    // The model belonged to the old provider. Carrying it across would send
-    // `claude-sonnet-5` to OpenAI and call the 404 a bug in the provider.
-    session.model = readSettings().models?.[chosen.id] ?? chosen.defaultModel;
-    session.config.providerId = chosen.id;
-    session.config.model = session.model;
-    if (session.model === "") {
-        if (!(await modelsCommand(session, host, { announce: false, save: false }))) {
-            restoreProvider(session, before);
-            return false;
-        }
-    }
-    else {
-        const alignment = await alignEffort(session, host);
-        if (!alignment.ok) {
-            restoreProvider(session, before);
-            return false;
-        }
-    }
-    if (behavior.save !== false) {
-        const saved = readSettings();
-        const models = { ...saved.models };
-        if (session.model !== "")
-            models[chosen.id] = session.model;
-        const patch = {
-            provider: chosen.id,
-            models,
-            ...(session.config.effort === before.effort ? {} : { effort: session.config.effort }),
-        };
-        if (!(await saveDefaults(host, patch))) {
-            restoreProvider(session, before);
-            return false;
-        }
-    }
-    if (behavior.announce !== false) {
-        host.emit({
-            kind: "notice",
-            text: session.model === "" ? `provider · ${chosen.id} · pick a model` : `provider · ${chosen.id}`,
-            tone: "info",
+        return;
+    let selected = Math.max(0, PROVIDERS.findIndex((provider) => provider.id === session.provider.id));
+    while (true) {
+        const index = await choose({
+            title: [],
+            options: PROVIDERS.map((provider) => ({
+                label: providerLabel(provider.id),
+                value: providerAccessHint(provider),
+            })),
+            index: selected,
         });
+        if (index === undefined)
+            return;
+        const provider = PROVIDERS[index];
+        if (provider === undefined)
+            return;
+        selected = index;
+        await manageProvider(provider, session, host);
+        // Esc closes only the nested provider flow. Ctrl+C also settles that
+        // picker, but aborts the command signal and must not reopen the parent.
+        throwIfAborted(host.signal);
     }
-    return true;
 }
-/** The model menu, built from what the provider says it has right now. */
-export async function modelsCommand(session, host, behavior = {}) {
-    // Before the network, not after: asking a provider for a list nothing can
-    // be picked from is a request spent on a menu that will never open.
-    const choose = chooser(host);
-    if (choose === undefined)
-        return false;
-    const provider = session.provider;
-    // Offer the key rather than only naming what is missing: the user came here
-    // to pick a model, and "go and export a variable" is not an answer.
-    const blocked = provider.blocked();
-    if (blocked !== undefined) {
-        await ensureProviderAuthentication(provider, session, host);
-        const still = provider.blocked();
-        if (still !== undefined) {
-            host.emit({
-                kind: "notice",
-                text: `${providerLabel(provider.id)} still needs ${authenticationNeed(provider)}`,
-                tone: "warn",
-            });
-            return false;
-        }
-    }
-    host.status?.(`Asking ${provider.id}`);
-    let ids;
-    try {
-        ids = await provider.models(host.signal, (status) => host.status?.(status));
-    }
-    catch (error) {
-        host.emit({
-            kind: "notice",
-            text: providerFailure(provider, error, true),
-            tone: "error",
-        });
-        return false;
-    }
-    finally {
-        host.status?.(undefined);
-    }
-    if (ids.length === 0) {
-        host.emit({ kind: "notice", text: `${provider.id} offers no models`, tone: "warn" });
-        return false;
-    }
-    const index = await choose({
-        title: heading("model", provider.id, session.palette),
-        options: ids.map((id) => ({ label: id })),
-        searchable: true,
-        query: "",
-        index: Math.max(0, ids.indexOf(session.model)),
-    });
-    if (index === undefined)
-        return false;
-    const chosen = ids[index];
-    if (chosen === undefined)
-        return false;
-    const before = {
-        model: session.model,
-        configModel: session.config.model,
-        effort: session.config.effort,
-    };
-    session.model = chosen;
-    session.config.model = chosen;
-    const alignment = await alignEffort(session, host);
-    if (!alignment.ok) {
-        session.model = before.model;
-        session.config.model = before.configModel;
-        session.config.effort = before.effort;
-        return false;
-    }
-    if (behavior.save !== false) {
-        const saved = readSettings();
-        const models = { ...saved.models, [provider.id]: chosen };
-        const patch = {
-            models,
-            ...(session.config.effort === before.effort ? {} : { effort: session.config.effort }),
-        };
-        if (!(await saveDefaults(host, patch))) {
-            session.model = before.model;
-            session.config.model = before.configModel;
-            session.config.effort = before.effort;
-            return false;
-        }
+export function providerAccessHint(provider) {
+    if (provider.id === "ollama") {
+        const connection = ollamaConnection();
+        if (connection.loopback)
+            return `${ollamaConnectionHint()} · no key needed`;
+        return `${ollamaConnectionHint()} · API key ${credentialSource(OLLAMA_KEY) ?? "missing"}`;
+    }
+    if (provider.auth.kind === "oauth")
+        return openAIAccountHint();
+    return `API key · ${credentialSource(provider.auth.keyVar) ?? "missing"}`;
+}
+async function manageProvider(provider, session, host) {
+    if (provider.id === "ollama") {
+        await ollamaProviderCommand(session, host);
+        return;
     }
-    if (behavior.announce !== false) {
-        host.emit({ kind: "notice", text: `model · ${chosen}`, tone: "info" });
+    if (provider.auth.kind === "oauth") {
+        await openAIAccountCommand(session, host);
+        return;
     }
-    return true;
+    await apiKeyCommand(provider.auth.keyVar, providerLabel(provider.id), session, host);
 }
-function restoreProvider(session, before) {
-    session.provider = before.provider;
-    session.model = before.model;
-    session.config.providerId = before.providerId;
-    session.config.model = before.configModel;
-    session.config.effort = before.effort;
-}
-async function alignEffort(session, host) {
-    if (session.provider.efforts === undefined)
-        return { ok: true };
-    let supported;
-    try {
-        supported = await session.provider.efforts(session.model, host.signal, (status) => host.status?.(status));
+async function ollamaProviderCommand(session, host) {
+    if (host.choose === undefined)
+        return;
+    const index = await host.choose({
+        title: heading("Ollama", "access and connection", session.palette),
+        options: [
+            { label: "connection", hint: ollamaConnectionHint() },
+            { label: "API key", hint: credentialSource(OLLAMA_KEY) ?? "missing" },
+        ],
+        index: 0,
+    });
+    if (index === 0) {
+        await ollamaConnectionSetting(session, host, (patch) => saveCommandSettings(host, patch));
     }
-    catch (error) {
-        host.emit({
-            kind: "notice",
-            text: providerFailure(session.provider, error, true),
-            tone: "error",
-        });
-        return { ok: false };
+    else if (index === 1) {
+        await apiKeyCommand(OLLAMA_KEY, "Ollama", session, host);
     }
-    const adjusted = compatibleEffort(session.config.effort, supported);
-    if (adjusted === undefined || adjusted === session.config.effort)
-        return { ok: true };
-    session.config.effort = adjusted;
-    return { ok: true, adjusted };
 }
 function chooser(host) {
     if (host.choose === undefined) {
@@ -229,19 +83,8 @@ function chooser(host) {
     }
     return host.choose;
 }
-async function saveDefaults(host, patch) {
-    if (host.saveSettings === undefined)
-        return true;
-    try {
-        await host.saveSettings(patch);
-        return true;
-    }
-    catch (error) {
-        host.emit({
-            kind: "notice",
-            text: `could not save settings · ${error.message}`,
-            tone: "error",
-        });
-        return false;
-    }
+function throwIfAborted(signal) {
+    if (signal?.aborted !== true)
+        return;
+    throw signal.reason instanceof Error ? signal.reason : new Error("interrupted");
 }

package/dist/provider-errors.js

@@ -1,10 +1,11 @@
 // Actionable provider failures for user-facing command and turn surfaces.
+import { providerLabel } from "./provider-label.js";
 const CONNECTION_FAILURE = /network error calling|timed out waiting for response headers|response body was idle/i;
 export function providerFailure(provider, error, labelProvider = false) {
     if (provider.id === "ollama" && CONNECTION_FAILURE.test(error.message)) {
         return provider.location?.() === "local"
-            ? "Ollama is not reachable on this computer · start Ollama or choose cloud in /settings"
-            : "Ollama is not reachable · check its connection in /settings";
+            ? "Ollama is not reachable on this computer · start Ollama or choose cloud in /providers"
+            : "Ollama is not reachable · check its connection in /providers";
     }
-    return labelProvider ? `${provider.id}: ${error.message}` : error.message;
+    return labelProvider ? `${providerLabel(provider.id)}: ${error.message}` : error.message;
 }

package/dist/provider-label.js

@@ -2,8 +2,8 @@
 export function providerLabel(id) {
     switch (id) {
         case "anthropic": return "Anthropic";
-        case "openai": return "OpenAI";
-        case "openai-codex": return "OpenAI Codex";
+        case "openai": return "OpenAI API";
+        case "openai-codex": return "ChatGPT";
         case "ollama": return "Ollama";
         default: return id === "" ? "Provider" : `${id[0]?.toUpperCase() ?? ""}${id.slice(1)}`;
     }

package/dist/providers/ollama.js

@@ -5,6 +5,7 @@
 // daemon. There is no default model — the catalogue is whatever the host has
 // pulled or the subscription grants — so the model has to be named with
 // --model.
+import { requireSupportedEffort } from "../effort.js";
 import { postSse } from "./http.js";
 import { listModels } from "./catalog.js";
 import { keyFor } from "../credentials.js";
@@ -12,6 +13,8 @@ import { assembleOllama } from "./ollama-stream.js";
 import { OLLAMA_CLOUD_HOST, OLLAMA_LOCAL_HOST, ollamaConnectionKind, parseOllamaEndpoint, } from "./ollama-endpoint.js";
 import { fromWireReply, stopNotice, toWireMessages, toWireTool } from "./ollama-wire.js";
 const KEY = "OLLAMA_API_KEY";
+// Ollama also accepts `none`; Jecode's product-wide reasoning floor is `low`.
+const OLLAMA_EFFORTS = ["low", "medium", "high"];
 let configuredHost;
 /** Set the endpoint selected for this process. Undefined restores key-aware inference. */
 export function configureOllama(host) {
@@ -46,7 +49,7 @@ export const ollama = {
         return listModels(`${at.baseUrl}/v1/models`, headers(at), signal, onStatus);
     },
     async efforts() {
-        return [];
+        return OLLAMA_EFFORTS;
     },
     location: () => {
         try {
@@ -58,13 +61,15 @@ export const ollama = {
     },
     async send(req) {
         const at = endpoint();
-        // `effort` has no equivalent in this shape and is dropped rather than
-        // guessed at — depth on these models is a property of the model chosen.
+        const effort = requireSupportedEffort(req.model, req.effort, OLLAMA_EFFORTS);
+        // The OpenAI-compatible endpoint accepts this vocabulary for thinking
+        // models. Invalid levels are rejected locally instead of being rewritten.
         const events = await postSse(`${at.baseUrl}/v1/chat/completions`, headers(at), {
             model: req.model,
             messages: toWireMessages(req.system, req.messages),
             tools: req.tools.map(toWireTool),
             max_tokens: req.maxTokens,
+            reasoning_effort: effort,
             stream: true,
         }, req.signal, req.onStatus);
         const reply = await assembleOllama(events, req.onStream);