@giovannijecha/jecode 0.3.2 → 0.4.0

package/README.md

@@ -25,7 +25,7 @@
   <a href="https://github.com/giovannijecha/jecode/releases">Releases</a>
 </p>
 
-> Jecode is an early 0.3.x release. The core loop is usable today; commands and
+> Jecode is an early 0.4.x release. The core loop is usable today; commands and
 > terminal interactions may still evolve before 1.0.
 
 ## Why Jecode
@@ -146,10 +146,11 @@ published package runs no compilation or installation scripts.
 ## First session
 
 Jecode opens on an empty composer instead of forcing a setup wizard. Type
-**/settings** when you are ready to choose a provider, select a model, and
-configure authentication. An API key can remain in memory for the current
-session or be saved explicitly under **~/.jecode**; it is never stored in the
-workspace.
+**/providers** to connect the services you use, then **/models** to choose from
+their combined live catalogues. **/settings** keeps the selected model and the
+remaining non-secret defaults together. An API key can remain in memory for
+the current session or be saved explicitly under **~/.jecode**; it is never
+stored in the workspace.
 
 | Provider ID | Authentication | Notes |
 |---|---|---|
@@ -158,7 +159,8 @@ workspace.
 | openai-codex | ChatGPT OAuth | Experimental; uses eligible ChatGPT Codex access |
 | ollama | OLLAMA_API_KEY for Cloud/remote | Cloud with a key, local without one |
 
-Choose **openai-codex** to sign in on OpenAI's website without pasting a key.
+Choose **ChatGPT** in **/providers** to sign in on OpenAI's website without
+pasting a key.
 Jecode offers a local browser callback and a device-code flow; WSL and remote
 terminals default to the device code. The connection is saved only after the
 flow completes. Availability and usage limits are determined by the ChatGPT
@@ -168,10 +170,10 @@ and is not an endorsement of Jecode by OpenAI.
 Anthropic remains API-key only. Jecode does not reuse a Claude consumer
 subscription or copy credentials from another client.
 
-Choose **cloud**, **local**, or a custom endpoint from the Ollama connection row
-in **/settings**. Existing users with an Ollama API key automatically use
-**https://ollama.com**; without a key, Jecode uses the local daemon at
-**http://127.0.0.1:11434**. Remote custom endpoints must use HTTPS.
+Choose **Ollama** in **/providers** to manage its API key and select **cloud**,
+**local**, or a custom endpoint. Existing users with an Ollama API key
+automatically use **https://ollama.com**; without a key, Jecode uses the local
+daemon at **http://127.0.0.1:11434**. Remote custom endpoints must use HTTPS.
 
 ## Use the TUI
 
@@ -179,12 +181,11 @@ Type **/** to open searchable command completion inside the composer.
 
 | Command | What it does |
 |---|---|
-| /settings | Manage provider, connection, model, limits, motion, and authentication |
+| /settings | Manage the selected model, limits, effort, motion, and provider access |
 | /effort | Change and save reasoning effort directly |
-| /providers | Switch the provider for the next turn |
-| /models | Search the live model catalogue |
-| /credentials | Manage API keys and the connected ChatGPT account |
-| /permissions | Manage session tool access and remembered approvals |
+| /providers | Manage API keys, ChatGPT sign-in, and Ollama connections |
+| /models | Search models across every available provider and select one |
+| /permissions | Change session tool access inline and review remembered approvals |
 | /new | Start a clean conversation and reset session tool permissions |
 | /export | Save a timestamped Markdown transcript in the launch directory |
 | /help | Open a temporary keyboard reference in the composer dock |
@@ -193,6 +194,10 @@ Type **/** to open searchable command completion inside the composer.
 Useful controls:
 
 - **Up/Down** moves through command suggestions, menus, and input history.
+- **Left/Right** moves the composer cursor or changes an inline menu value;
+  **Ctrl+Left/Right** moves by word.
+- **Backspace/Delete** removes one character; **Ctrl+Backspace/Delete** removes
+  one word. **Home/End** moves to the start or end of the composer.
 - **Tab** completes a slash command without running it; **Enter** sends.
 - **Alt+Enter** inserts a newline.
 - **Esc** closes a menu or interrupts the foreground operation.
@@ -229,7 +234,9 @@ Persistent preferences live in **~/.jecode/settings.json**. Explicitly saved
 API keys live in **~/.jecode/credentials.json**; the ChatGPT OAuth account lives
 separately in **~/.jecode/accounts.json**. Both secret stores use owner-only
 permissions where the operating system supports them. Environment API keys
-always win.
+always win. Model selection saves the provider and model as one change; the
+separate startup flags remain available for automation and override that saved
+choice.
 
 Jecode has one interface theme: dark Steel. **NO_COLOR** is supported for
 terminals and pipelines that disable colour.

package/dist/command-settings.js

@@ -0,0 +1,19 @@
+// Shared persistence boundary for commands that change non-secret defaults.
+import { updateSettings } from "./settings.js";
+export async function saveCommandSettings(host, patch) {
+    try {
+        if (host.saveSettings === undefined)
+            await updateSettings(patch);
+        else
+            await host.saveSettings(patch);
+        return true;
+    }
+    catch (error) {
+        host.emit({
+            kind: "notice",
+            text: `could not save settings · ${error.message}`,
+            tone: "error",
+        });
+        return false;
+    }
+}

package/dist/commands.js

@@ -2,10 +2,10 @@
 //
 // One of them does reach the network — a menu of models cannot be built
 // without asking the provider what it has — but none of them ever sends a
-// message. Provider and credential interaction lives in provider-commands.ts;
-// this file keeps command discovery, dispatch, and local session operations.
-import { modelsCommand, providersCommand } from "./provider-commands.js";
-import { credentialsCommand } from "./credential-commands.js";
+// message. Provider access and model selection stay in their own commands;
+// this file keeps discovery, dispatch, and local session operations.
+import { modelsCommand } from "./model-command.js";
+import { providersCommand } from "./provider-commands.js";
 import { permissionsCommand } from "./permission-command.js";
 import { effortCommand, settingsCommand } from "./settings-command.js";
 import { emptyUsage } from "./usage.js";
@@ -13,8 +13,8 @@ import { emptyUsage } from "./usage.js";
  * The commands, declared once.
  *
  * Deliberately short. `/settings` owns persistent defaults; the narrower
- * provider, model, effort, and credential commands remain useful direct paths
- * into the same interactions.
+ * model, provider-access, and effort commands remain useful direct paths into
+ * the same interactions.
  */
 export const COMMANDS = [
     { name: "help", blurb: "show keyboard controls" },
@@ -24,9 +24,8 @@ export const COMMANDS = [
     { name: "permissions", blurb: "manage session tool access" },
     { name: "settings", blurb: "change and save jecode defaults" },
     { name: "effort", blurb: "set the reasoning effort" },
-    { name: "credentials", blurb: "manage API keys and connected accounts" },
-    { name: "models", blurb: "pick a model, from what the provider offers" },
-    { name: "providers", blurb: "pick a provider" },
+    { name: "models", blurb: "choose from every available provider" },
+    { name: "providers", blurb: "manage provider access and connections" },
 ];
 export async function handleCommand(line, session, host) {
     const [name] = line.slice(1).trim().split(/\s+/);
@@ -69,9 +68,6 @@ export async function handleCommand(line, session, host) {
         case "effort":
             await effortCommand(session, host);
             return "handled";
-        case "credentials":
-            await credentialsCommand(session, host);
-            return "handled";
         case "models":
             await modelsCommand(session, host);
             return "handled";

package/dist/credential-commands.js

@@ -1,10 +1,7 @@
-// Credential command flows shared by settings and provider selection.
-import { heading } from "./tui/picker.js";
+// Masked API-key interaction shared by provider connection flows.
+import { credentialSource, forgetSaved, forgetSession, hasSaved, hold, keep, storeLabel, } from "./credentials.js";
 import { EMPTY } from "./tui/editor.js";
-import { PROVIDERS } from "./providers/index.js";
-import { openAIAccountHint } from "./openai-account.js";
-import { ensureOpenAIAccount, openAIAccountCommand, } from "./openai-account-command.js";
-import { credentialSource, forgetSaved, hasSaved, hold, keep, storeLabel, } from "./credentials.js";
+import { heading } from "./tui/picker.js";
 /** Ask for a key, then ask separately whether it may be written to disk. */
 export async function askForKey(name, host, pal) {
     if (host.type === undefined || host.choose === undefined)
@@ -43,109 +40,95 @@ export async function askForKey(name, host, pal) {
             return true;
         }
         catch (error) {
-            host.emit({ kind: "notice", text: `could not save API key · ${error.message}`, tone: "error" });
+            host.emit({
+                kind: "notice",
+                text: `could not save API key · ${error.message}`,
+                tone: "error",
+            });
             return false;
         }
     }
     return false;
 }
-export async function credentialsCommand(session, host) {
+/** Manage one provider key without ever placing its value on screen. */
+export async function apiKeyCommand(name, label, session, host) {
     const choose = chooser(host);
     if (choose === undefined)
         return;
-    const index = await choose({
-        title: heading("authentication", "secrets are never shown", session.palette),
-        options: PROVIDERS.map((provider) => ({
-            label: provider.auth.kind === "api-key" ? provider.auth.keyVar : `${provider.auth.label} account`,
-            hint: provider.auth.kind === "api-key"
-                ? credentialSource(provider.auth.keyVar) ?? "missing"
-                : openAIAccountHint(),
-        })),
-        index: Math.max(0, PROVIDERS.findIndex((provider) => provider.id === session.provider.id)),
-    });
-    if (index === undefined)
-        return;
-    const provider = PROVIDERS[index];
-    if (provider === undefined)
-        return;
-    if (provider.auth.kind === "oauth") {
-        await openAIAccountCommand(session, host);
-        return;
-    }
-    const name = provider.auth.keyVar;
     const source = credentialSource(name);
     if (source === "environment") {
-        host.emit({
-            kind: "notice",
-            text: `${name} comes from the environment · restart after changing it`,
-            tone: "info",
+        if (!hasSaved(name)) {
+            host.emit({
+                kind: "notice",
+                text: `${label} API key comes from the environment · restart after changing it`,
+                tone: "info",
+            });
+            return;
+        }
+        const action = await choose({
+            title: heading(`${label} API key`, `${name} · environment`, session.palette),
+            description: "The environment value is read-only. A saved copy is currently shadowed.",
+            options: [{ label: "forget saved copy", hint: storeLabel(), key: "f" }],
+            index: 0,
         });
-        if (hasSaved(name))
-            await offerForget(name, session, host, "a saved copy is currently shadowed");
+        if (action === 0)
+            await forgetSavedKey(name, host);
         return;
     }
     const actions = [
-        { label: source === undefined ? "add credential" : "replace credential", key: "r" },
-        ...(hasSaved(name) ? [{ label: "forget saved copy", hint: storeLabel(), key: "f" }] : []),
+        {
+            label: source === undefined ? "add API key" : "replace API key",
+            hint: source === undefined ? "session or owner-only file" : `currently ${source}`,
+            key: "r",
+        },
+        ...(source === "session"
+            ? [{ label: "clear session key", hint: "this process only", key: "c" }]
+            : []),
+        ...(hasSaved(name)
+            ? [{ label: "forget saved copy", hint: storeLabel(), key: "f" }]
+            : []),
     ];
-    const action = await choose({
-        title: heading(name, source ?? "missing", session.palette),
+    const index = await choose({
+        title: heading(`${label} API key`, `${name} · ${source ?? "missing"}`, session.palette),
         options: actions,
         index: 0,
     });
-    if (action === undefined)
-        return;
-    if (actions[action]?.key === "f") {
-        await forget(name, host);
-        return;
-    }
-    await askForKey(name, host, session.palette);
+    const action = index === undefined ? undefined : actions[index]?.key;
+    if (action === "r")
+        await askForKey(name, host, session.palette);
+    else if (action === "c")
+        clearSessionKey(name, host);
+    else if (action === "f")
+        await forgetSavedKey(name, host);
 }
-/** Offer the authentication flow owned by a provider, if that is its blocker. */
-export async function ensureProviderAuthentication(provider, session, host) {
-    const blocked = provider.blocked();
-    if (blocked === undefined)
-        return true;
-    if (provider.auth.kind === "oauth") {
-        return provider.auth.account === "openai-codex"
-            ? ensureOpenAIAccount(session, host)
-            : false;
-    }
-    if (!blocked.startsWith(`${provider.auth.keyVar} `)) {
-        host.emit({ kind: "notice", text: blocked, tone: "error" });
-        return false;
-    }
-    await askForKey(provider.auth.keyVar, host, session.palette);
-    return provider.blocked() === undefined;
-}
-export function authenticationNeed(provider) {
-    return provider.auth.kind === "oauth" ? `${provider.auth.label} sign-in` : "an API key";
-}
-async function offerForget(name, session, host, hint) {
-    if (host.choose === undefined)
-        return;
-    const index = await host.choose({
-        title: heading(name, hint, session.palette),
-        options: [
-            { label: "keep saved copy", key: "k" },
-            { label: "forget saved copy", hint: storeLabel(), key: "f" },
-        ],
-        index: 0,
+function clearSessionKey(name, host) {
+    const removed = forgetSession(name);
+    const fallback = credentialSource(name);
+    host.emit({
+        kind: "notice",
+        text: removed
+            ? fallback === undefined
+                ? "session API key removed"
+                : `session API key removed · ${fallback} copy now active`
+            : "no session API key",
+        tone: removed ? "info" : "warn",
     });
-    if (index === 1)
-        await forget(name, host);
 }
-async function forget(name, host) {
+async function forgetSavedKey(name, host) {
     try {
         const removed = await forgetSaved(name);
         host.emit({
             kind: "notice",
-            text: removed ? "API key removed" : "no saved API key",
+            text: removed ? "saved API key removed" : "no saved API key",
             tone: removed ? "info" : "warn",
         });
     }
     catch (error) {
-        host.emit({ kind: "notice", text: `could not remove API key · ${error.message}`, tone: "error" });
+        host.emit({
+            kind: "notice",
+            text: `could not remove API key · ${error.message}`,
+            tone: "error",
+        });
     }
 }
 function chooser(host) {

package/dist/credentials.js

@@ -60,6 +60,10 @@ export function hasSaved(name) {
 export function hold(name, value) {
     held.set(name, value);
 }
+/** Remove only the value held by this process. Saved and environment values remain. */
+export function forgetSession(name) {
+    return held.delete(name);
+}
 /**
  * Take a key and write it down, returning the path it went to.
  *
@@ -74,8 +78,10 @@ export async function keep(name, value) {
     return withStoreLock(file, async () => {
         const all = { ...readSavedStore(), [name]: value };
         await persist(file, all);
-        hold(name, value);
         saved = all;
+        // A newly saved replacement must become active immediately. Otherwise an
+        // older session-only value would keep shadowing the value just written.
+        held.delete(name);
         return file;
     });
 }

package/dist/model-command.js

@@ -0,0 +1,171 @@
+// Model-first runtime selection across every provider that can answer now.
+import { saveCommandSettings } from "./command-settings.js";
+import { compatibleEffort } from "./effort.js";
+import { providerFailure } from "./provider-errors.js";
+import { providerLabel } from "./provider-label.js";
+import { PROVIDERS } from "./providers/index.js";
+import { readSettings } from "./settings.js";
+/** Build one searchable catalogue from every provider that is usable now. */
+export async function modelsCommand(session, host, behavior = {}, providers = PROVIDERS) {
+    const choose = chooser(host);
+    if (choose === undefined)
+        return false;
+    const availability = providers.map((provider) => ({
+        provider,
+        blocked: provider.blocked(),
+    }));
+    const connected = availability
+        .filter((entry) => entry.blocked === undefined)
+        .map((entry) => entry.provider);
+    const disconnected = availability
+        .filter((entry) => entry.blocked !== undefined)
+        .map((entry) => entry.provider);
+    if (connected.length === 0) {
+        host.emit({
+            kind: "notice",
+            text: "no providers are connected · use /providers",
+            tone: "warn",
+        });
+        return false;
+    }
+    throwIfAborted(host.signal);
+    host.status?.("Loading model catalogs");
+    let settled;
+    try {
+        settled = await Promise.allSettled(connected.map(async (provider) => ({
+            provider,
+            models: await provider.models(host.signal, (status) => host.status?.(`${providerLabel(provider.id)} · ${status}`)),
+        })));
+        // allSettled deliberately preserves partial provider failures, but an
+        // explicit command cancellation is not a catalogue failure.
+        throwIfAborted(host.signal);
+    }
+    finally {
+        host.status?.(undefined);
+    }
+    const choices = [];
+    const failed = [];
+    for (let index = 0; index < settled.length; index++) {
+        const result = settled[index];
+        const provider = connected[index];
+        if (result === undefined || provider === undefined)
+            continue;
+        if (result.status === "rejected") {
+            failed.push({
+                provider,
+                error: result.reason instanceof Error ? result.reason : new Error(String(result.reason)),
+            });
+            continue;
+        }
+        for (const model of result.value.models)
+            choices.push({ provider, model });
+    }
+    if (choices.length === 0) {
+        host.emit({
+            kind: "notice",
+            text: emptyCatalogMessage(connected, failed),
+            tone: failed.length === connected.length ? "error" : "warn",
+        });
+        return false;
+    }
+    const description = catalogDescription(disconnected, failed);
+    const index = await choose({
+        title: [],
+        ...(description === undefined ? {} : { description }),
+        options: choices.map((choice) => ({
+            label: choice.model,
+            // Provider identity is part of the choice, not optional help: keep it
+            // visible even when the terminal is only at the supported minimum.
+            value: providerLabel(choice.provider.id),
+        })),
+        searchable: true,
+        query: "",
+        index: Math.max(0, choices.findIndex((choice) => choice.provider.id === session.provider.id && choice.model === session.model)),
+    });
+    throwIfAborted(host.signal);
+    const chosen = index === undefined ? undefined : choices[index];
+    if (chosen === undefined)
+        return false;
+    const beforeEffort = session.config.effort;
+    const alignment = await alignEffort(chosen.provider, chosen.model, beforeEffort, host);
+    if (!alignment.ok)
+        return false;
+    if (behavior.save !== false) {
+        const saved = readSettings();
+        const patch = {
+            provider: chosen.provider.id,
+            models: { ...saved.models, [chosen.provider.id]: chosen.model },
+            ...(alignment.effort === beforeEffort ? {} : { effort: alignment.effort }),
+        };
+        if (!(await saveCommandSettings(host, patch)))
+            return false;
+    }
+    // Commit the runtime selection only after both provider validation and
+    // persistence succeed, so neither the footer nor a later turn can observe a
+    // half-applied provider/model pair.
+    session.provider = chosen.provider;
+    session.model = chosen.model;
+    session.config.providerId = chosen.provider.id;
+    session.config.model = chosen.model;
+    session.config.effort = alignment.effort;
+    if (behavior.announce !== false) {
+        host.emit({
+            kind: "notice",
+            text: `model · ${providerLabel(chosen.provider.id)} · ${chosen.model}`,
+            tone: "info",
+        });
+    }
+    return true;
+}
+async function alignEffort(provider, model, effort, host) {
+    if (provider.efforts === undefined)
+        return { ok: true, effort };
+    try {
+        throwIfAborted(host.signal);
+        const supported = await provider.efforts(model, host.signal, (status) => host.status?.(status));
+        throwIfAborted(host.signal);
+        return { ok: true, effort: compatibleEffort(effort, supported) ?? effort };
+    }
+    catch (error) {
+        throwIfAborted(host.signal);
+        host.emit({
+            kind: "notice",
+            text: providerFailure(provider, error, true),
+            tone: "error",
+        });
+        return { ok: false };
+    }
+}
+function catalogDescription(disconnected, failed) {
+    const parts = [
+        disconnected.length === 0
+            ? undefined
+            : `Not connected: ${disconnected.map((provider) => providerLabel(provider.id)).join(", ")}`,
+        failed.length === 0
+            ? undefined
+            : `Unavailable: ${failed.map((entry) => providerLabel(entry.provider.id)).join(", ")}`,
+    ].filter((part) => part !== undefined);
+    return parts.length === 0 ? undefined : `${parts.join(" · ")} · manage in /providers`;
+}
+function emptyCatalogMessage(connected, failed) {
+    if (failed.length === 1 && connected.length === 1) {
+        const one = failed[0];
+        if (one !== undefined)
+            return providerFailure(one.provider, one.error, true);
+    }
+    if (failed.length > 0) {
+        return `model catalogs unavailable: ${failed.map((entry) => providerLabel(entry.provider.id)).join(", ")} · /providers`;
+    }
+    return "connected providers offer no models · check /providers";
+}
+function chooser(host) {
+    if (host.choose === undefined) {
+        host.emit({ kind: "notice", text: "that command needs the screen", tone: "warn" });
+    }
+    return host.choose;
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted !== true)
+        return;
+    throw signal.reason instanceof Error ? signal.reason : new Error("interrupted");
+}