akm-cli 0.9.0-rc.0 → 0.9.0-rc.2

package/dist/setup/detected-engines.js

@@ -0,0 +1,142 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import { createHash } from "node:crypto";
+import { ConfigError } from "../core/errors.js";
+const CHAT_SUFFIX = "/chat/completions";
+export function normalizeChatCompletionsEndpoint(input) {
+    const url = new URL(input);
+    if (url.protocol !== "http:" && url.protocol !== "https:")
+        throw new Error("endpoint must use http or https");
+    if (url.username || url.password || url.search || url.hash)
+        throw new Error("endpoint cannot contain credentials, query, or fragment");
+    let pathname = url.pathname.replace(/\/+$/, "");
+    if (!pathname.endsWith(CHAT_SUFFIX)) {
+        if (!pathname.endsWith("/v1") && !pathname.includes("/openai"))
+            pathname += "/v1";
+        pathname += CHAT_SUFFIX;
+    }
+    url.pathname = pathname;
+    return url.toString().replace(/\/$/, "");
+}
+export function engineFingerprint(engine) {
+    return engine.kind === "llm"
+        ? `llm:${normalizeChatCompletionsEndpoint(engine.endpoint)}`
+        : `agent:${engine.platform}`;
+}
+export async function verifyOpenAiCompatibleEndpoint(candidate, fetchFn = fetch) {
+    let endpoint;
+    try {
+        endpoint = normalizeChatCompletionsEndpoint(candidate.endpoint);
+    }
+    catch (error) {
+        return { ok: false, reason: error instanceof Error ? error.message : String(error) };
+    }
+    if (!candidate.model.trim())
+        return { ok: false, reason: "no detected model" };
+    const credential = candidate.apiKeyEnvVar ? process.env[candidate.apiKeyEnvVar] : undefined;
+    if (candidate.apiKeyEnvVar && !credential) {
+        return { ok: false, reason: `required credential ${candidate.apiKeyEnvVar} is unavailable` };
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 10_000);
+    timer.unref?.();
+    try {
+        const response = await fetchFn(endpoint, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                ...(credential ? { authorization: `Bearer ${credential}` } : {}),
+            },
+            body: JSON.stringify({
+                model: candidate.model,
+                messages: [{ role: "user", content: "Reply OK" }],
+                max_tokens: 1,
+                stream: false,
+            }),
+            signal: controller.signal,
+        });
+        if (!response.ok)
+            return { ok: false, reason: `HTTP ${response.status}` };
+        const body = (await response.json());
+        if (typeof body.choices?.[0]?.message?.content !== "string") {
+            return { ok: false, reason: "response did not contain choices[0].message.content" };
+        }
+        return { ok: true, endpoint };
+    }
+    catch (error) {
+        return { ok: false, reason: error instanceof Error ? error.message : String(error) };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function slug(value) {
+    const normalized = value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-|-$/g, "");
+    return normalized && /^[a-z]/.test(normalized) ? normalized : "local";
+}
+function availableName(config, preferred, fingerprint) {
+    for (const [name, engine] of Object.entries(config.engines ?? {}).sort(([left], [right]) => left.localeCompare(right))) {
+        if (engineFingerprint(engine) === fingerprint)
+            return name;
+    }
+    const base = slug(preferred);
+    const expectedKind = fingerprint.startsWith("llm:") ? "llm" : "agent";
+    const baseEngine = config.engines?.[base];
+    if (baseEngine && baseEngine.kind !== expectedKind) {
+        throw new ConfigError(`Detected ${expectedKind} engine name ${JSON.stringify(base)} conflicts with configured ${baseEngine.kind} engine of the same name. Rename one engine before rerunning setup.`, "INVALID_CONFIG_FILE");
+    }
+    if (!config.engines?.[base])
+        return base;
+    const suffix = createHash("sha256").update(fingerprint).digest("hex").slice(0, 8);
+    const candidate = `${base}-${suffix}`;
+    const collision = config.engines?.[candidate];
+    if (!collision || engineFingerprint(collision) === fingerprint)
+        return candidate;
+    throw new ConfigError(`Detected engine identity collision at ${JSON.stringify(candidate)}. Choose an explicit engine name before rerunning setup.`, "INVALID_CONFIG_FILE");
+}
+/** Insert or reuse an LLM engine by canonical endpoint without modifying a match. */
+export function upsertDetectedLlmEngine(config, candidate) {
+    const endpoint = normalizeChatCompletionsEndpoint(candidate.endpoint);
+    const fingerprint = `llm:${endpoint}`;
+    const name = availableName(config, candidate.provider, fingerprint);
+    const existing = config.engines?.[name];
+    const reused = existing !== undefined && engineFingerprint(existing) === fingerprint;
+    const engines = reused
+        ? config.engines
+        : {
+            ...(config.engines ?? {}),
+            [name]: {
+                kind: "llm",
+                provider: candidate.provider,
+                endpoint,
+                model: candidate.model,
+                ...(candidate.apiKeyEnvVar ? { apiKey: `\${${candidate.apiKeyEnvVar}}` } : {}),
+            },
+        };
+    const defaults = { ...(config.defaults ?? {}) };
+    const currentDefault = defaults.llmEngine;
+    if (!currentDefault ||
+        (config.engines?.[currentDefault] && engineFingerprint(config.engines[currentDefault]) === fingerprint)) {
+        defaults.llmEngine = name;
+    }
+    return { config: { ...config, engines, defaults }, name, reused };
+}
+/** Insert or reuse an agent engine by canonical platform without modifying a match. */
+export function upsertDetectedAgentEngine(config, platform) {
+    const fingerprint = `agent:${platform}`;
+    const name = availableName(config, platform, fingerprint);
+    const existing = config.engines?.[name];
+    const reused = existing !== undefined && engineFingerprint(existing) === fingerprint;
+    const engines = reused ? config.engines : { ...(config.engines ?? {}), [name]: { kind: "agent", platform } };
+    const defaults = { ...(config.defaults ?? {}) };
+    const currentDefault = defaults.engine;
+    if (!currentDefault ||
+        (config.engines?.[currentDefault] && engineFingerprint(config.engines[currentDefault]) === fingerprint)) {
+        defaults.engine = name;
+    }
+    return { config: { ...config, engines, defaults }, name, reused };
+}

package/dist/setup/engine-config.js

@@ -0,0 +1,89 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import { ConfigError } from "../core/errors.js";
+export function readCurrentLlmEngine(config) {
+    const name = config.defaults?.llmEngine;
+    const engine = name ? config.engines?.[name] : undefined;
+    if (!engine || engine.kind !== "llm")
+        return undefined;
+    const { kind: _kind, supportsJsonSchema, timeoutMs, ...connection } = engine;
+    return {
+        ...connection,
+        ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+        ...(supportsJsonSchema !== undefined ? { capabilities: { structuredOutput: supportsJsonSchema } } : {}),
+    };
+}
+export function readAgentEngineSelection(config) {
+    const engines = {};
+    for (const [name, engine] of Object.entries(config.engines ?? {})) {
+        if (engine.kind === "agent")
+            engines[name] = { ...engine };
+    }
+    const defaultName = config.defaults?.engine;
+    const defaultIsAgent = defaultName && config.engines?.[defaultName]?.kind === "agent";
+    if (Object.keys(engines).length === 0 && !defaultIsAgent)
+        return undefined;
+    return { ...(defaultIsAgent ? { default: defaultName } : {}), engines };
+}
+/** Write an OpenAI-compatible connection as a named LLM engine. */
+export function writeLlmEngine(config, llm) {
+    const name = config.defaults?.llmEngine ?? "default";
+    if (!llm) {
+        const engines = { ...(config.engines ?? {}) };
+        if (engines[name]?.kind === "llm")
+            delete engines[name];
+        const defaults = { ...(config.defaults ?? {}) };
+        delete defaults.llmEngine;
+        return { engines, defaults };
+    }
+    if (config.engines?.[name] && config.engines[name].kind !== "llm") {
+        throw new ConfigError(`Cannot configure LLM engine ${JSON.stringify(name)} because that name belongs to an agent engine.`, "INVALID_CONFIG_FILE");
+    }
+    const endpoint = llm.endpoint.endsWith("/chat/completions")
+        ? llm.endpoint
+        : `${llm.endpoint.replace(/\/$/, "")}/chat/completions`;
+    const { capabilities, ...connection } = llm;
+    return {
+        engines: {
+            ...(config.engines ?? {}),
+            [name]: {
+                ...connection,
+                kind: "llm",
+                endpoint,
+                ...(capabilities?.structuredOutput !== undefined ? { supportsJsonSchema: capabilities.structuredOutput } : {}),
+            },
+        },
+        defaults: { ...(config.defaults ?? {}), llmEngine: name },
+    };
+}
+/** Merge setup-selected agent engines without translating profile-shaped data. */
+export function writeAgentEngines(config, selection) {
+    for (const [name, engine] of Object.entries(selection?.engines ?? {})) {
+        const existing = config.engines?.[name];
+        if (existing && existing.kind !== engine.kind) {
+            throw new ConfigError(`Cannot configure ${engine.kind} engine ${JSON.stringify(name)} because that name belongs to an ${existing.kind} engine.`, "INVALID_CONFIG_FILE");
+        }
+    }
+    const defaults = { ...(config.defaults ?? {}) };
+    if (!selection?.default)
+        delete defaults.engine;
+    else
+        defaults.engine = selection.default;
+    const engines = { ...(config.engines ?? {}), ...(selection?.engines ?? {}) };
+    if (selection?.default && engines[selection.default] && engines[selection.default].kind !== "agent") {
+        throw new ConfigError(`Cannot select agent engine ${JSON.stringify(selection.default)} because that name belongs to an LLM engine.`, "INVALID_CONFIG_FILE");
+    }
+    if (selection?.default && !engines[selection.default]) {
+        engines[selection.default] = {
+            kind: "agent",
+            platform: selection.default,
+        };
+    }
+    return { engines, defaults };
+}
+export function cloneLlmConnection(llm) {
+    if (!llm)
+        return undefined;
+    return JSON.parse(JSON.stringify(llm));
+}