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

package/dist/models-file.js

@@ -0,0 +1,155 @@
+import { readFile } from "node:fs/promises";
+import { parse, printParseErrorCode } from "jsonc-parser";
+export const builtInAgentNames = [
+    "build",
+    "plan",
+    "general",
+    "explore",
+    "compaction",
+    "title",
+    "summary",
+];
+export function emptyModelsDocument() {
+    return { defaults: {}, profiles: {}, builtins: {} };
+}
+export function ownValue(record, key) {
+    return Object.hasOwn(record, key) ? record[key] : undefined;
+}
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyName(value) {
+    return typeof value === "string" && value.trim() !== "";
+}
+const modelIdentifierPattern = /^[^\s/]+\/\S+$/;
+function readModelChoice(value) {
+    if (typeof value === "string") {
+        return modelIdentifierPattern.test(value) ? { model: value } : undefined;
+    }
+    if (!isRecord(value) ||
+        typeof value.model !== "string" ||
+        !modelIdentifierPattern.test(value.model)) {
+        return undefined;
+    }
+    if (value.variant === undefined) {
+        return { model: value.model };
+    }
+    return isNonEmptyName(value.variant)
+        ? { model: value.model, variant: value.variant }
+        : undefined;
+}
+function readModelChoices(value, location, notices) {
+    const choices = {};
+    if (value === undefined) {
+        return choices;
+    }
+    if (!isRecord(value)) {
+        notices.push(`${location} is not an object of model refs; ignored.`);
+        return choices;
+    }
+    for (const [ref, entry] of Object.entries(value)) {
+        const choice = readModelChoice(entry);
+        if (choice === undefined || !isNonEmptyName(ref)) {
+            notices.push(`${location}.${ref} is not "provider/model" or { "model", "variant" }; skipped.`);
+            continue;
+        }
+        choices[ref] = choice;
+    }
+    return choices;
+}
+function lineAndColumn(text, offset) {
+    const before = text.slice(0, offset).split("\n");
+    return `line ${before.length}, column ${(before.at(-1)?.length ?? 0) + 1}`;
+}
+export function parseModelsDocument(text, path) {
+    const notices = [];
+    const errors = [];
+    const value = parse(text, errors, {
+        allowTrailingComma: true,
+        disallowComments: false,
+    });
+    const firstError = errors.at(0);
+    if (firstError !== undefined) {
+        notices.push(`${path} has a syntax error (${printParseErrorCode(firstError.error)} at ${lineAndColumn(text, firstError.offset)}); its model refs are ignored.`);
+        return { document: emptyModelsDocument(), status: "unusable", notices };
+    }
+    if (!isRecord(value)) {
+        notices.push(`${path} is not a JSON object; its model refs are ignored.`);
+        return { document: emptyModelsDocument(), status: "unusable", notices };
+    }
+    const knownKeys = [
+        "$schema",
+        "defaultProfile",
+        "defaults",
+        "profiles",
+        "builtins",
+    ];
+    for (const key of Object.keys(value)) {
+        if (!knownKeys.includes(key)) {
+            notices.push(`Unknown top-level key "${key}" in ${path}; ignored.`);
+        }
+    }
+    const document = emptyModelsDocument();
+    document.defaults = readModelChoices(value.defaults, "defaults", notices);
+    if (value.profiles !== undefined && !isRecord(value.profiles)) {
+        notices.push("profiles is not an object of profiles; ignored.");
+    }
+    else {
+        for (const [name, refs] of Object.entries(value.profiles ?? {})) {
+            if (!isNonEmptyName(name)) {
+                notices.push("A profile with an empty name was skipped.");
+                continue;
+            }
+            document.profiles[name] = readModelChoices(refs, `profiles.${name}`, notices);
+        }
+    }
+    if (value.builtins !== undefined && !isRecord(value.builtins)) {
+        notices.push("builtins is not an object of agent names; ignored.");
+    }
+    else {
+        const knownBuiltIns = builtInAgentNames;
+        for (const [agent, ref] of Object.entries(value.builtins ?? {})) {
+            if (!knownBuiltIns.includes(agent)) {
+                notices.push(`builtins.${agent} is not a built-in agent (${builtInAgentNames.join(", ")}); skipped.`);
+            }
+            else if (!isNonEmptyName(ref)) {
+                notices.push(`builtins.${agent} is not a ref name; skipped.`);
+            }
+            else {
+                document.builtins[agent] = ref;
+            }
+        }
+    }
+    if (value.defaultProfile !== undefined) {
+        if (isNonEmptyName(value.defaultProfile)) {
+            document.defaultProfile = value.defaultProfile;
+        }
+        else {
+            notices.push("defaultProfile is not a profile name; ignored.");
+        }
+    }
+    return { document, status: "loaded", notices };
+}
+export async function loadModelsDocument(path) {
+    let text;
+    try {
+        text = await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return {
+                document: emptyModelsDocument(),
+                status: "missing",
+                notices: [],
+            };
+        }
+        return {
+            document: emptyModelsDocument(),
+            status: "unusable",
+            notices: [
+                `Could not read ${path} (${error instanceof Error ? error.message : String(error)}); its model refs are ignored.`,
+            ],
+        };
+    }
+    return parseModelsDocument(text, path);
+}

package/dist/report.d.ts

@@ -0,0 +1,17 @@
+import type { ProfileSource, RefResolution } from "./resolution.ts";
+export declare const packageName = "@lunchbox-labs/opencode-model-profiles";
+/** What the server applied, published in its own plugin entry so the TUI can read it through /config. */
+export interface ModelProfilesReport {
+    version: 1;
+    configFile: string;
+    selectionFile: string;
+    worktree: string;
+    profiles: string[];
+    profile: string | null;
+    profileSource: ProfileSource;
+    environmentProfile?: string;
+    refs: RefResolution[];
+    notices: string[];
+}
+export declare function publishReport(config: Record<string, unknown>, options: unknown, report: ModelProfilesReport): boolean;
+export declare function readReport(config: unknown): ModelProfilesReport | undefined;

package/dist/report.js

@@ -0,0 +1,73 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { isRecord } from "./models-file.js";
+export const packageName = "@lunchbox-labs/opencode-model-profiles";
+const reportKey = "modelProfilesReport";
+const packageRoot = path.resolve(fileURLToPath(new URL("../", import.meta.url)));
+function isOwnSpecifier(specifier) {
+    if (typeof specifier !== "string") {
+        return false;
+    }
+    if (specifier === packageName || specifier.startsWith(`${packageName}@`)) {
+        return true;
+    }
+    if (!specifier.startsWith("file:")) {
+        return false;
+    }
+    try {
+        const target = path.resolve(fileURLToPath(specifier));
+        return target === packageRoot || target.startsWith(packageRoot + path.sep);
+    }
+    catch {
+        return false;
+    }
+}
+export function publishReport(config, options, report) {
+    if (!Array.isArray(config.plugin)) {
+        return false;
+    }
+    const plugins = [...config.plugin];
+    const index = plugins.findIndex((entry) => Array.isArray(entry)
+        ? entry[1] === options || isOwnSpecifier(entry[0])
+        : isOwnSpecifier(entry));
+    if (index < 0) {
+        return false;
+    }
+    const entry = plugins[index];
+    const specifier = Array.isArray(entry) ? entry[0] : entry;
+    const entryOptions = Array.isArray(entry) ? entry[1] : undefined;
+    plugins[index] = [
+        specifier,
+        {
+            ...(isRecord(entryOptions) ? entryOptions : {}),
+            [reportKey]: JSON.parse(JSON.stringify(report)),
+        },
+    ];
+    config.plugin = plugins;
+    return true;
+}
+function isReport(value) {
+    return (isRecord(value) &&
+        value.version === 1 &&
+        typeof value.configFile === "string" &&
+        typeof value.selectionFile === "string" &&
+        typeof value.worktree === "string" &&
+        (value.profile === null || typeof value.profile === "string") &&
+        Array.isArray(value.profiles) &&
+        Array.isArray(value.refs) &&
+        Array.isArray(value.notices));
+}
+export function readReport(config) {
+    if (!isRecord(config) || !Array.isArray(config.plugin)) {
+        return undefined;
+    }
+    for (const entry of config.plugin) {
+        const report = Array.isArray(entry) && isRecord(entry[1])
+            ? entry[1][reportKey]
+            : undefined;
+        if (isReport(report)) {
+            return report;
+        }
+    }
+    return undefined;
+}

package/dist/resolution.d.ts

@@ -0,0 +1,46 @@
+import { type ModelsDocument } from "./models-file.ts";
+import type { SavedProfile } from "./selection.ts";
+export type ProfileSource = "environment" | "saved" | "defaultProfile" | "none";
+export interface ProfileSelection {
+    profile: string | null;
+    source: ProfileSource;
+    notices: string[];
+}
+/** Takes the first choice that names a defined profile (or "defaults only"); undefined profiles fall through to the next. */
+export declare function selectProfile(document: ModelsDocument, environmentProfile: string | undefined, savedProfile: SavedProfile): ProfileSelection;
+/**
+ * The fallback notice for a ref whose model no connected provider offers. The server and the TUI word it the same
+ * way, so the TUI does not toast it again when the reload that drops the ref replaces its own check with the server's.
+ */
+export declare function unavailableModelNotice(ref: string, model: string, agents: readonly string[], providerConnected: boolean): string;
+export interface RefResolution {
+    ref: string;
+    model?: string;
+    variant?: string;
+    source: "profile" | "defaults" | "unresolved";
+    /** Set when no connected provider offers the model, so agents keep OpenCode's model. */
+    unavailable?: true;
+    agents: string[];
+}
+/** A ref that resolved for an agent, and the model the agent had without it, for falling back at runtime. */
+export interface RefAssignment {
+    agent: string;
+    ref: string;
+    model: string;
+    variant?: string;
+    ownModel?: string;
+    ownVariant?: string;
+    /** False when the model was known to be unavailable, so the agent kept its own model. */
+    applied: boolean;
+}
+export interface AppliedModelRefs {
+    agents: Record<string, unknown>;
+    refs: RefResolution[];
+    assignments: RefAssignment[];
+    notices: string[];
+}
+/**
+ * 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 declare function applyModelRefs(configuredAgents: unknown, document: ModelsDocument, profile: string | null, availableModels?: ReadonlySet<string>): AppliedModelRefs;

package/dist/resolution.js

@@ -0,0 +1,179 @@
+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 providerOf(model) {
+    return model.slice(0, model.indexOf("/"));
+}
+/**
+ * The fallback notice for a ref whose model no connected provider offers. The server and the TUI word it the same
+ * way, so the TUI does not toast it again when the reload that drops the ref replaces its own check with the server's.
+ */
+export function unavailableModelNotice(ref, model, agents, providerConnected) {
+    const providerId = providerOf(model);
+    const reason = providerConnected
+        ? `"${providerId}" has no model "${model.slice(providerId.length + 1)}"`
+        : `provider "${providerId}" is not connected`;
+    return `Ref "${ref}" uses ${model}, but ${reason}; ${agents.join(", ")} ${agents.length === 1 ? "falls" : "fall"} back to OpenCode's model until you fix the ref or pick another profile.`;
+}
+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, availableModels) {
+    const notices = [];
+    const assignments = [];
+    const isAvailable = (model) => availableModels === undefined || availableModels.has(model);
+    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) {
+            const applied = isAvailable(resolved.choice.model);
+            assignments.push({
+                agent: name,
+                ref,
+                model: resolved.choice.model,
+                ...(resolved.choice.variant === undefined
+                    ? {}
+                    : { variant: resolved.choice.variant }),
+                ...(typeof agent.model === "string" ? { ownModel: agent.model } : {}),
+                ...(typeof agent.variant === "string"
+                    ? { ownVariant: agent.variant }
+                    : {}),
+                applied,
+            });
+            if (applied) {
+                agent.model = resolved.choice.model;
+                if (resolved.choice.variant !== undefined) {
+                    agent.variant = resolved.choice.variant;
+                }
+            }
+        }
+        if (original !== undefined ||
+            (resolved !== undefined && isAvailable(resolved.choice.model))) {
+            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 };
+        }
+        const unavailable = !isAvailable(resolved.choice.model);
+        if (unavailable && users.length > 0) {
+            notices.push(unavailableModelNotice(ref, resolved.choice.model, users, availableModels !== undefined &&
+                [...availableModels].some((model) => model.startsWith(`${providerOf(resolved.choice.model)}/`))));
+        }
+        return {
+            ref,
+            model: resolved.choice.model,
+            ...(resolved.choice.variant === undefined
+                ? {}
+                : { variant: resolved.choice.variant }),
+            source: resolved.source,
+            ...(unavailable ? { unavailable: true } : {}),
+            agents: users,
+        };
+    });
+    return { agents, refs, assignments, 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;