@lunchbox-labs/opencode-model-profiles 0.0.0-stage → 0.1.0

package/dist/resolution.js

@@ -0,0 +1,140 @@
+import { builtInAgentNames, isRecord, ownValue, } from "./models-file.js";
+const profileOrigins = {
+    environment: "OPENCODE_MODEL_PROFILE",
+    saved: "the saved worktree selection",
+    defaultProfile: "defaultProfile",
+};
+/** Takes the first choice that names a defined profile (or "defaults only"); undefined profiles fall through to the next. */
+export function selectProfile(document, environmentProfile, savedProfile) {
+    const candidates = [
+        [environmentProfile, "environment"],
+        [savedProfile, "saved"],
+        [document.defaultProfile, "defaultProfile"],
+    ];
+    const skipped = [];
+    let selected = {
+        profile: null,
+        source: "none",
+    };
+    for (const [requested, source] of candidates) {
+        if (requested === undefined || source === "none") {
+            continue;
+        }
+        if (requested === null || Object.hasOwn(document.profiles, requested)) {
+            selected = { profile: requested, source };
+            break;
+        }
+        skipped.push([requested, source]);
+    }
+    const using = selected.profile === null
+        ? "defaults only"
+        : `profile "${selected.profile}"`;
+    return {
+        ...selected,
+        notices: skipped.map(([requested, source]) => `Profile "${requested}" from ${profileOrigins[source]} is not defined in models.jsonc; using ${using}.`),
+    };
+}
+function resolveRef(document, profile, ref) {
+    const profileRefs = profile === null ? undefined : ownValue(document.profiles, profile);
+    const profileChoice = profileRefs === undefined ? undefined : ownValue(profileRefs, ref);
+    if (profileChoice !== undefined) {
+        return { choice: profileChoice, source: "profile" };
+    }
+    const defaultChoice = ownValue(document.defaults, ref);
+    return defaultChoice === undefined
+        ? undefined
+        : { choice: defaultChoice, source: "defaults" };
+}
+function withoutModelRef(agent) {
+    const { modelRef: topLevel, ...rest } = agent;
+    let declared = topLevel;
+    if (isRecord(rest.options) && Object.hasOwn(rest.options, "modelRef")) {
+        const { modelRef: fromOptions, ...options } = rest.options;
+        declared ??= fromOptions;
+        rest.options = options;
+    }
+    return { agent: rest, declared };
+}
+/**
+ * Returns a new agent map and leaves the given one untouched: OpenCode keeps the global config's
+ * agent objects for the whole process, so mutating them would lose each modelRef on the next reload.
+ */
+export function applyModelRefs(configuredAgents, document, profile) {
+    const notices = [];
+    const agents = {};
+    const refAgents = new Map();
+    const builtIns = builtInAgentNames;
+    const sourceAgents = isRecord(configuredAgents) ? configuredAgents : {};
+    const names = [
+        ...new Set([
+            ...Object.keys(sourceAgents),
+            ...Object.keys(document.builtins),
+        ]),
+    ];
+    for (const name of names) {
+        const original = ownValue(sourceAgents, name);
+        if (original !== undefined && !isRecord(original)) {
+            agents[name] = original;
+            continue;
+        }
+        const { agent, declared } = withoutModelRef(original ?? {});
+        const builtInRef = builtIns.includes(name) && agent.model === undefined
+            ? ownValue(document.builtins, name)
+            : undefined;
+        if (declared !== undefined &&
+            (typeof declared !== "string" || declared.trim() === "")) {
+            notices.push(`Agent ${name} has a modelRef that is not a ref name; it keeps OpenCode's model.`);
+        }
+        const ref = declared === undefined
+            ? builtInRef
+            : typeof declared === "string" && declared.trim() !== ""
+                ? declared
+                : undefined;
+        if (original === undefined && ref === undefined) {
+            continue;
+        }
+        if (ref === undefined || agent.disable === true) {
+            agents[name] = agent;
+            continue;
+        }
+        refAgents.set(ref, [...(refAgents.get(ref) ?? []), name]);
+        const resolved = resolveRef(document, profile, ref);
+        if (resolved !== undefined) {
+            agent.model = resolved.choice.model;
+            if (resolved.choice.variant !== undefined) {
+                agent.variant = resolved.choice.variant;
+            }
+        }
+        if (original !== undefined || resolved !== undefined) {
+            agents[name] = agent;
+        }
+    }
+    const refNames = [
+        ...new Set([
+            ...Object.keys(document.defaults),
+            ...(profile === null
+                ? []
+                : Object.keys(ownValue(document.profiles, profile) ?? {})),
+            ...refAgents.keys(),
+        ]),
+    ].sort();
+    const refs = refNames.map((ref) => {
+        const users = refAgents.get(ref) ?? [];
+        const resolved = resolveRef(document, profile, ref);
+        if (resolved === undefined) {
+            const where = profile === null ? "defaults" : `profile "${profile}" or defaults`;
+            notices.push(`Ref "${ref}" is not defined in ${where}; ${users.join(", ")} ${users.length === 1 ? "keeps" : "keep"} OpenCode's model.`);
+            return { ref, source: "unresolved", agents: users };
+        }
+        return {
+            ref,
+            model: resolved.choice.model,
+            ...(resolved.choice.variant === undefined
+                ? {}
+                : { variant: resolved.choice.variant }),
+            source: resolved.source,
+            agents: users,
+        };
+    });
+    return { agents, refs, notices };
+}

package/dist/selection.d.ts

@@ -0,0 +1,17 @@
+export declare const processProfileVariable = "OPENCODE_MODEL_PROFILE";
+export declare function processProfile(environment?: NodeJS.ProcessEnv): string | undefined;
+export declare function configurationDirectory(environment?: NodeJS.ProcessEnv): string;
+/** OpenCode 1.19 uses xdg-basedir for its state directory on every platform, including Windows. */
+export declare function stateDirectory(environment?: NodeJS.ProcessEnv): string;
+/** Outside a git repository OpenCode reports the worktree as "/", so the directory stands in for it. */
+export declare function worktreeRoot(worktree: unknown, directory: unknown): string;
+export declare function selectionFilePath(state: string, worktree: string, platform?: NodeJS.Platform): string;
+/** `null` saves "defaults only"; `undefined` means nothing is saved for this worktree. */
+export type SavedProfile = string | null | undefined;
+export interface SavedSelection {
+    profile: SavedProfile;
+    notice?: string;
+}
+export declare function readSavedSelection(file: string): Promise<SavedSelection>;
+export declare function saveSelection(file: string, worktree: string, profile: string | null): Promise<void>;
+export declare function clearSelection(file: string): Promise<void>;

package/dist/selection.js

@@ -0,0 +1,95 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { isRecord } from "./models-file.js";
+export const processProfileVariable = "OPENCODE_MODEL_PROFILE";
+export function processProfile(environment = process.env) {
+    const value = environment[processProfileVariable]?.trim();
+    return value === undefined || value === "" ? undefined : value;
+}
+export function configurationDirectory(environment = process.env) {
+    const configured = environment.OPENCODE_CONFIG_DIR;
+    if (configured !== undefined && configured !== "") {
+        return path.resolve(configured);
+    }
+    const xdg = environment.XDG_CONFIG_HOME;
+    return xdg !== undefined && path.isAbsolute(xdg)
+        ? path.join(xdg, "opencode")
+        : path.join(homedir(), ".config", "opencode");
+}
+/** OpenCode 1.19 uses xdg-basedir for its state directory on every platform, including Windows. */
+export function stateDirectory(environment = process.env) {
+    const xdg = environment.XDG_STATE_HOME;
+    return path.join(xdg !== undefined && path.isAbsolute(xdg)
+        ? xdg
+        : path.join(homedir(), ".local", "state"), "opencode");
+}
+/** Outside a git repository OpenCode reports the worktree as "/", so the directory stands in for it. */
+export function worktreeRoot(worktree, directory) {
+    if (typeof worktree === "string" && worktree !== "" && worktree !== "/") {
+        return worktree;
+    }
+    return typeof directory === "string" && directory !== ""
+        ? directory
+        : process.cwd();
+}
+/** `resolve` already drops trailing separators except at a root, so equivalent spellings share a key. */
+function worktreeKey(worktree, platform) {
+    return platform === "win32"
+        ? path.win32.resolve(worktree).toLowerCase()
+        : path.posix.resolve(worktree);
+}
+export function selectionFilePath(state, worktree, platform = process.platform) {
+    const key = createHash("sha256")
+        .update(worktreeKey(worktree, platform))
+        .digest("hex")
+        .slice(0, 32);
+    const platformPath = platform === "win32" ? path.win32 : path.posix;
+    return platformPath.join(state, "model-profiles", "worktrees", `${key}.json`);
+}
+export async function readSavedSelection(file) {
+    let text;
+    try {
+        text = await readFile(file, "utf8");
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return { profile: undefined };
+        }
+        return {
+            profile: undefined,
+            notice: `Could not read the saved profile at ${file}; using the default selection.`,
+        };
+    }
+    try {
+        const value = JSON.parse(text);
+        if (isRecord(value) &&
+            value.version === 1 &&
+            (value.profile === null ||
+                (typeof value.profile === "string" && value.profile !== ""))) {
+            return { profile: value.profile };
+        }
+    }
+    catch {
+        // An unreadable selection is reported below like any other invalid content.
+    }
+    return {
+        profile: undefined,
+        notice: `The saved profile at ${file} is invalid; using the default selection. Pick a profile with /model-config to replace it.`,
+    };
+}
+export async function saveSelection(file, worktree, profile) {
+    await mkdir(path.dirname(file), { recursive: true });
+    const temporary = `${file}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, `${JSON.stringify({ version: 1, worktree, profile }, null, 2)}\n`, "utf8");
+        await rename(temporary, file);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}
+export async function clearSelection(file) {
+    await rm(file, { force: true });
+}

package/dist/server.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from "@opencode-ai/plugin";
+declare const _default: {
+    id: string;
+    server: Plugin;
+};
+export default _default;

package/dist/server.js

@@ -0,0 +1,40 @@
+import { modelsFilePath, resolveModelProfiles, stripModelRefs, } from "./apply.js";
+import { publishReport } from "./report.js";
+import { selectionFilePath, stateDirectory, worktreeRoot, } from "./selection.js";
+const ModelProfilesServer = (input, options) => {
+    const worktree = worktreeRoot(input.worktree, input.directory);
+    return Promise.resolve({
+        config: async (config) => {
+            const target = config;
+            const configFile = modelsFilePath(options);
+            try {
+                publishReport(target, options, await resolveModelProfiles(target, { configFile, worktree }));
+            }
+            catch (error) {
+                try {
+                    stripModelRefs(target);
+                    publishReport(target, options, {
+                        version: 1,
+                        configFile,
+                        selectionFile: selectionFilePath(stateDirectory(), worktree),
+                        worktree,
+                        profiles: [],
+                        profile: null,
+                        profileSource: "none",
+                        refs: [],
+                        notices: [
+                            `Model refs were not applied (${error instanceof Error ? error.message : String(error)}); agents keep OpenCode's models.`,
+                        ],
+                    });
+                }
+                catch {
+                    // A failing config hook must never stop OpenCode; agents then keep OpenCode's models.
+                }
+            }
+        },
+    });
+};
+export default {
+    id: "model-profiles",
+    server: ModelProfilesServer,
+};

package/dist/tui.d.ts

@@ -0,0 +1,6 @@
+import type { TuiPlugin } from "@opencode-ai/plugin/tui";
+declare const _default: {
+    id: string;
+    tui: TuiPlugin;
+};
+export default _default;

package/dist/tui.js

@@ -0,0 +1,204 @@
+import { fallbackToastLines, modelConfigOptions, profileLabel, selectedChoice, selectedNotice, unavailableModelNotices, } from "./model-config-view.js";
+import { loadModelsDocument } from "./models-file.js";
+import { readReport } from "./report.js";
+import { clearSelection, processProfileVariable, readSavedSelection, saveSelection, } from "./selection.js";
+const toastTitle = "Model Profiles";
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function registerModelConfig(api) {
+    const directory = () => api.state.path.directory;
+    let shownNotices = new Set();
+    let reading = Promise.resolve();
+    let reloadsInFlight = 0;
+    const toast = (variant, lines) => {
+        api.ui.toast({
+            variant,
+            title: toastTitle,
+            message: lines.join("\n"),
+            duration: variant === "warning" ? 10_000 : 5_000,
+        });
+    };
+    /** Reads what the server applied; a fallback is new until it disappears from a later report. */
+    const readApplied = () => {
+        const next = reading.then(async () => {
+            const response = await api.client.config.get({ directory: directory() });
+            const report = response.error === undefined ? readReport(response.data) : undefined;
+            if (report === undefined) {
+                return undefined;
+            }
+            const notices = [
+                ...unavailableModelNotices(report.refs, api.state.provider),
+                ...report.notices,
+            ];
+            const newNotices = notices.filter((notice) => !shownNotices.has(notice));
+            shownNotices = new Set(notices);
+            return { report, notices, newNotices };
+        });
+        reading = next.catch(() => undefined);
+        return next;
+    };
+    const announceFallbacks = async () => {
+        const applied = await readApplied();
+        if (applied !== undefined && applied.newNotices.length > 0) {
+            toast("warning", fallbackToastLines(applied.newNotices));
+        }
+    };
+    const reload = async (label) => {
+        const status = await api.client.session.status({ directory: directory() });
+        if (status.error !== undefined) {
+            toast("warning", [
+                `Saved ${label} for this worktree, but OpenCode could not report whether a session is busy, so it did not reload. It applies on the next reload.`,
+            ]);
+            return;
+        }
+        if (Object.values(status.data).some((session) => session.type !== "idle")) {
+            toast("info", [
+                `Saved ${label} for this worktree. A session is busy, so it applies the next time OpenCode reloads this project, or pick it again in /model-config once the session is idle.`,
+            ]);
+            return;
+        }
+        reloadsInFlight += 1;
+        const disposed = await api.client.instance
+            .dispose({ directory: directory() })
+            .finally(() => {
+            reloadsInFlight -= 1;
+        });
+        if (disposed.error !== undefined) {
+            toast("warning", [
+                `Saved ${label}, but OpenCode did not reload. It applies on the next reload.`,
+            ]);
+            return;
+        }
+        const applied = await readApplied();
+        if (applied === undefined) {
+            toast("success", [`Saved ${label}.`]);
+            return;
+        }
+        toast(applied.newNotices.length > 0 ? "warning" : "success", [
+            `Using ${profileLabel(applied.report.profile)}.`,
+            ...fallbackToastLines(applied.newNotices),
+        ]);
+    };
+    const choose = async (report, choice, defaultProfile) => {
+        const label = choice.kind === "save"
+            ? profileLabel(choice.profile)
+            : `defaultProfile (${defaultProfile ?? "none"})`;
+        try {
+            await (choice.kind === "save"
+                ? saveSelection(report.selectionFile, report.worktree, choice.profile)
+                : clearSelection(report.selectionFile));
+        }
+        catch (error) {
+            toast("warning", [`Could not save ${label}: ${errorText(error)}`]);
+            return;
+        }
+        if (report.environmentProfile !== undefined) {
+            toast("info", [
+                `Saved ${label} for this worktree. ${processProfileVariable}=${report.environmentProfile} still applies to this OpenCode process.`,
+            ]);
+            return;
+        }
+        try {
+            await reload(label);
+        }
+        catch (error) {
+            toast("warning", [
+                `Saved ${label}, but could not reload OpenCode (${errorText(error)}). It applies on the next reload.`,
+            ]);
+        }
+    };
+    const open = async () => {
+        const applied = await readApplied().catch(() => undefined);
+        if (applied === undefined) {
+            toast("warning", [
+                "The server plugin has not reported model refs. Add @lunchbox-labs/opencode-model-profiles to plugin in opencode.jsonc.",
+            ]);
+            return;
+        }
+        const { report, notices } = applied;
+        const [current, saved] = await Promise.all([
+            loadModelsDocument(report.configFile),
+            readSavedSelection(report.selectionFile),
+        ]);
+        const loaded = current.status === "loaded";
+        const defaultProfile = loaded ? current.document.defaultProfile : undefined;
+        api.ui.dialog.replace(() => api.ui.DialogSelect({
+            title: "Model config",
+            options: modelConfigOptions({
+                report,
+                profiles: loaded
+                    ? Object.keys(current.document.profiles)
+                    : report.profiles,
+                savedProfile: saved.profile,
+                defaultProfile,
+                notices,
+            }),
+            current: report.profile === null ? "defaults" : `profile:${report.profile}`,
+            onSelect: (option) => {
+                const notice = selectedNotice(option.value, notices);
+                if (notice !== undefined) {
+                    toast("warning", [notice]);
+                    return;
+                }
+                const choice = selectedChoice(option.value);
+                if (choice === undefined) {
+                    return;
+                }
+                api.ui.dialog.clear();
+                choose(report, choice, defaultProfile).catch(() => undefined);
+            },
+        }));
+        api.ui.dialog.setSize("large");
+    };
+    const unregister = api.keymap.registerLayer({
+        commands: [
+            {
+                name: "model-profiles.config",
+                title: "Model config",
+                category: "Model",
+                namespace: "palette",
+                slashName: "model-config",
+                run: () => {
+                    open().catch(() => undefined);
+                },
+            },
+        ],
+    });
+    const unsubscribeInstance = api.event.on("server.instance.disposed", (event) => {
+        if (reloadsInFlight === 0 && event.properties.directory === directory()) {
+            announceFallbacks().catch(() => undefined);
+        }
+    });
+    const unsubscribeGlobal = api.event.on("global.disposed", () => {
+        announceFallbacks().catch(() => undefined);
+    });
+    /** Models are checked against connected providers, which may not have loaded when the TUI starts. */
+    let providerChecks = 0;
+    const providerTimer = setInterval(() => {
+        providerChecks += 1;
+        if (api.state.provider.length > 0) {
+            clearInterval(providerTimer);
+            announceFallbacks().catch(() => undefined);
+        }
+        else if (providerChecks >= 60) {
+            clearInterval(providerTimer);
+        }
+    }, 500);
+    providerTimer.unref();
+    api.lifecycle.onDispose(() => {
+        clearInterval(providerTimer);
+        unregister();
+        unsubscribeInstance();
+        unsubscribeGlobal();
+    });
+    announceFallbacks().catch(() => undefined);
+}
+const ModelProfilesTui = (api) => {
+    registerModelConfig(api);
+    return Promise.resolve();
+};
+export default {
+    id: "model-profiles",
+    tui: ModelProfilesTui,
+};

package/package.json

@@ -1,6 +1,75 @@
 {
   "name": "@lunchbox-labs/opencode-model-profiles",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Pick agent models by name, with defaults and per-worktree profiles",
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lunchbox-labs/opencode-model-profiles.git"
+  },
+  "engines": {
+    "node": ">=22.18.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/server.d.ts",
+      "default": "./dist/server.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "default": "./dist/server.js"
+    },
+    "./tui": {
+      "types": "./dist/tui.d.ts",
+      "default": "./dist/tui.js"
+    },
+    "./schema.json": "./schema.json"
+  },
+  "files": [
+    "dist",
+    "schema.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json",
+    "test": "node --experimental-strip-types --test tests/*.test.ts tests/*.test.mjs",
+    "lint": "eslint . --max-warnings 0",
+    "format": "prettier --write src tests scripts package.json tsconfig*.json *.config.mjs schema.json",
+    "format:check": "prettier --check src tests scripts package.json tsconfig*.json *.config.mjs schema.json",
+    "check": "npm run check:static && npm test",
+    "prepack": "npm run build",
+    "test:package": "npm run build && node --experimental-strip-types --test tests/package.integration.ts",
+    "check:static": "concurrently --names typecheck,lint,format --kill-others-on-fail \"npm run typecheck\" \"npm run lint\" \"npm run format:check\"",
+    "prebuild": "node --input-type=module -e \"import { rm } from 'node:fs/promises'; await rm('dist', { recursive: true, force: true });\""
+  },
+  "devDependencies": {
+    "@eslint-community/eslint-plugin-eslint-comments": "4.8.1",
+    "@eslint/js": "10.0.1",
+    "@opencode-ai/plugin": "1.19.5",
+    "@opencode-ai/sdk": "1.19.5",
+    "@opentui/core": "0.4.5",
+    "@opentui/keymap": "0.4.5",
+    "@opentui/solid": "0.4.5",
+    "@types/node": "24.19.2",
+    "concurrently": "10.0.6",
+    "eslint": "10.14.0",
+    "eslint-config-prettier": "10.1.8",
+    "eslint-plugin-regexp": "3.3.3",
+    "globals": "17.14.0",
+    "prettier": "3.9.10",
+    "solid-js": "1.9.12",
+    "typescript": "6.0.3",
+    "typescript-eslint": "8.72.1",
+    "yaml": "2.9.1"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "dependencies": {
+    "jsonc-parser": "3.3.1"
+  }
+}