localpi 0.1.0

package/dist/src/localpi/managed-runtime.js

@@ -0,0 +1,225 @@
+import { ensureLlamaServer, getManagedLlamaServerMetadata, getLlamaServerModels, llamaBaseUrl, managedLlamaServerNeedsRestart, stopManagedLlamaServer } from "./llama-server.js";
+import { managedModelSupportsReasoning } from "./catalog.js";
+import { catalogModelFromModelInfo, catalogRuntimeConnection, connectionCatalogModels, modelChoiceList, optionalContextWindow, replaceManagedLoadedModels } from "./runtime-connection.js";
+import { defaultLlamaModelName, findModelAlias, resolveLlamaModel } from "./models.js";
+export async function resolveLlamaRuntime(options) {
+    const requested = options.model ?? defaultLlamaModelName();
+    const existing = await existingLlamaRuntime(options, requested);
+    if (existing !== undefined) {
+        return existing;
+    }
+    const model = await resolveLlamaModelForStart(requested, options);
+    const modelForStart = llamaModelForStart(model, options);
+    await assertDirectLlamaStartIsSafe(options, modelForStart);
+    const runtime = await ensureLlamaServer(options, modelForStart);
+    return {
+        runtime: runtime.managed ? "llama-server" : "llama-server/external",
+        providerId: "llama-server",
+        providerName: "llama-server",
+        baseUrl: runtime.baseUrl,
+        model: runtime.model,
+        availableModels: runtime.availableModels,
+        catalogModels: connectionCatalogModels("llama-server", "llama-server", "managed-llama-server", runtime.baseUrl, runtime.availableModels, options, runtime.contextWindow),
+        warnings: runtime.warnings,
+        ...optionalContextWindow(options.contextWindow ?? runtime.contextWindow)
+    };
+}
+export async function resolveSelectedLlamaRuntime(options, selected, catalog) {
+    const existing = selected.availability === "loaded"
+        ? await existingLlamaRuntime(options, selected.modelId)
+        : undefined;
+    if (existing !== undefined) {
+        const selectedModel = managedCatalogModelFromConnection(options, selected, existing);
+        return catalogRuntimeConnection(options, selectedModel, {
+            models: replaceManagedLoadedModels(catalog.models, selected, existing.catalogModels),
+            warnings: [...catalog.warnings, ...existing.warnings]
+        });
+    }
+    return startSelectedLlamaRuntime(options, selected, catalog);
+}
+export async function customPathCatalogModel(options, provider, requested) {
+    if (options.runtime !== "auto" ||
+        (provider !== undefined && provider !== "llama-server") ||
+        !isGgufPathRequest(requested)) {
+        return undefined;
+    }
+    const resolved = await resolveLlamaModelForStart(requested, options);
+    return {
+        providerId: "llama-server",
+        providerName: "llama-server",
+        runtime: "managed-llama-server",
+        baseUrl: llamaBaseUrl(options),
+        modelId: resolved.id,
+        aliases: [requested],
+        displayName: `llama-server / ${resolved.name}`,
+        maxTokens: options.maxTokens,
+        reasoning: managedModelSupportsReasoning(resolved.id),
+        capabilities: ["text"],
+        availability: "startable",
+        ...optionalContextWindow(options.contextWindow ?? resolved.contextWindow)
+    };
+}
+async function resolveLlamaModelForStart(requested, options) {
+    try {
+        return await resolveLlamaModel(requested, options.chatTemplate);
+    }
+    catch (error) {
+        const managed = await getManagedLlamaServerMetadata(options);
+        if (managed !== undefined && (requested === "auto" || requested === managed.modelId)) {
+            return {
+                source: "path",
+                name: managed.modelId,
+                id: managed.modelId,
+                modelPath: managed.modelPath,
+                contextWindow: managed.contextWindow,
+                ...optionalChatTemplate(options.chatTemplate ?? managed.chatTemplate)
+            };
+        }
+        throw error;
+    }
+}
+async function existingLlamaRuntime(options, requested) {
+    const match = await existingModelMatch(options, requested);
+    if (match === undefined) {
+        return undefined;
+    }
+    const managed = await getManagedLlamaServerMetadata(options);
+    const reportedContextWindow = reportedRuntimeContext(managed, match);
+    if (managed !== undefined &&
+        shouldResolveManagedThroughStartPath(managed, options, requested, match.modelId)) {
+        return undefined;
+    }
+    if (shouldRestartManagedForContext(options, managed, reportedContextWindow)) {
+        return undefined;
+    }
+    assertCompatibleRuntimeContext(options, match.modelId, reportedContextWindow);
+    return existingRuntimeConnection(options, match, managed, reportedContextWindow);
+}
+function existingRuntimeConnection(options, match, managed, reportedContextWindow) {
+    return {
+        runtime: runtimeName(managed),
+        providerId: "llama-server",
+        providerName: "llama-server",
+        baseUrl: llamaBaseUrl(options),
+        model: match.modelId,
+        availableModels: match.models.map((model) => model.id),
+        catalogModels: match.models.map((model) => catalogModelFromModelInfo("llama-server", "llama-server", "managed-llama-server", llamaBaseUrl(options), model, options, model.id === match.modelId ? reportedContextWindow : model.contextWindow)),
+        warnings: [],
+        ...optionalContextWindow(options.contextWindow ?? reportedContextWindow)
+    };
+}
+function reportedRuntimeContext(managed, match) {
+    return managed?.contextWindow ?? match.info?.contextWindow;
+}
+function runtimeName(managed) {
+    return managed === undefined ? "llama-server/external" : "llama-server";
+}
+async function existingModelMatch(options, requested) {
+    const models = await getLlamaServerModels(options);
+    if (models === undefined) {
+        return undefined;
+    }
+    const modelId = await existingModelId(requested, models);
+    if (modelId === undefined) {
+        return undefined;
+    }
+    return {
+        models,
+        modelId,
+        info: models.find((model) => model.id === modelId)
+    };
+}
+function shouldRestartManagedForContext(options, managed, reportedContextWindow) {
+    return (managed !== undefined &&
+        options.contextWindow !== undefined &&
+        reportedContextWindow !== undefined &&
+        reportedContextWindow !== options.contextWindow);
+}
+function shouldResolveManagedThroughStartPath(managed, options, requested, modelId) {
+    return (managedLlamaServerNeedsRestart(options, managed) ||
+        (requested !== "auto" && requested !== modelId));
+}
+function assertCompatibleRuntimeContext(options, modelId, reportedContextWindow) {
+    if (options.contextWindow !== undefined &&
+        reportedContextWindow !== undefined &&
+        reportedContextWindow !== options.contextWindow) {
+        throw new Error(`server at ${llamaBaseUrl(options)} reports ${modelId} ctx=${String(reportedContextWindow)}, but --ctx ${String(options.contextWindow)} was requested`);
+    }
+}
+async function existingModelId(requested, models) {
+    if (requested === "auto") {
+        return models[0]?.id;
+    }
+    if (models.some((model) => model.id === requested)) {
+        return requested;
+    }
+    const alias = await findModelAlias(requested);
+    return alias !== undefined && models.some((model) => model.id === alias.id)
+        ? alias.id
+        : undefined;
+}
+function llamaModelForStart(model, options) {
+    return {
+        id: model.id,
+        modelPath: model.modelPath,
+        ...optionalContextWindow(options.contextWindow ?? model.contextWindow),
+        ...optionalChatTemplate(options.chatTemplate ?? model.chatTemplate)
+    };
+}
+async function startSelectedLlamaRuntime(options, selected, catalog) {
+    const model = await resolveLlamaModelForStart(selected.aliases[0] ?? selected.modelId, options);
+    const modelForStart = llamaModelForStart(model, options);
+    await stopStaleManagedLlamaServer(options, modelForStart);
+    assertNoLoadedExternalModels(catalog);
+    const runtime = await ensureLlamaServer(options, modelForStart);
+    const loadedSelected = runtimeSelectedCatalogModel(options, selected, runtime);
+    return catalogRuntimeConnection(options, loadedSelected, {
+        models: replaceManagedLoadedModels(catalog.models, selected, [loadedSelected]),
+        warnings: [...catalog.warnings, ...runtime.warnings]
+    });
+}
+async function assertDirectLlamaStartIsSafe(options, model) {
+    const { discoverModelCatalog } = await import("./catalog.js");
+    const catalog = await discoverModelCatalog({
+        ...options,
+        runtime: "auto",
+        provider: undefined,
+        model: "auto"
+    });
+    try {
+        assertNoLoadedExternalModels(catalog);
+    }
+    catch (error) {
+        await stopStaleManagedLlamaServer(options, model);
+        throw error;
+    }
+}
+async function stopStaleManagedLlamaServer(options, model) {
+    const managed = await getManagedLlamaServerMetadata(options);
+    if (managed !== undefined && managedLlamaServerNeedsRestart(options, managed, model)) {
+        await stopManagedLlamaServer(options);
+    }
+}
+function runtimeSelectedCatalogModel(options, selected, runtime) {
+    return catalogModelFromModelInfo(selected.providerId, selected.providerName, "managed-llama-server", runtime.baseUrl, runtime.contextWindow === undefined
+        ? { id: runtime.model }
+        : { id: runtime.model, contextWindow: runtime.contextWindow }, options, runtime.contextWindow);
+}
+function managedCatalogModelFromConnection(options, selected, connection) {
+    return catalogModelFromModelInfo(selected.providerId, selected.providerName, "managed-llama-server", connection.baseUrl, connection.contextWindow === undefined
+        ? { id: connection.model }
+        : { id: connection.model, contextWindow: connection.contextWindow }, options, connection.contextWindow);
+}
+function assertNoLoadedExternalModels(catalog) {
+    const external = catalog.models.filter((model) => model.runtime !== "managed-llama-server" && model.availability === "loaded");
+    if (external.length === 0) {
+        return;
+    }
+    throw new Error(`external local models are already loaded; choose one or unload them before starting llama-server:\n${modelChoiceList(external)}`);
+}
+function isGgufPathRequest(value) {
+    return value.endsWith(".gguf") || value.includes("/") || value.includes("\\");
+}
+function optionalChatTemplate(chatTemplate) {
+    return chatTemplate === undefined ? {} : { chatTemplate };
+}

package/dist/src/localpi/models.js

@@ -0,0 +1,169 @@
+import { access, readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { asObject, optionalString } from "../common/json.js";
+export async function listModelAliases(home = os.homedir()) {
+    return (await allAliases(home)).map((alias) => ({
+        name: alias.name,
+        id: alias.id,
+        paths: alias.paths,
+        ...(alias.contextWindow === undefined ? {} : { contextWindow: alias.contextWindow })
+    }));
+}
+export async function findModelAlias(name, home = os.homedir()) {
+    return (await allAliases(home)).find((entry) => entry.name === name);
+}
+export async function resolveLlamaModel(requested, chatTemplateOverride, home = os.homedir()) {
+    const expanded = expandHome(requested, home);
+    if (isGgufPath(expanded)) {
+        return customPathModel(expanded, chatTemplateOverride);
+    }
+    const alias = findRequestedAlias(await allAliases(home), requested);
+    if (alias === undefined) {
+        throw new Error(`unknown llama-server model alias ${requested}; pass a GGUF path or use --list`);
+    }
+    const modelPath = await firstExisting(alias.paths.map((candidate) => expandHome(candidate, home)));
+    if (modelPath === undefined) {
+        throw new Error(`model alias ${requested} has no installed GGUF; checked: ${alias.paths.join(", ")}`);
+    }
+    return {
+        source: "alias",
+        name: alias.name,
+        id: alias.id,
+        modelPath,
+        ...(alias.contextWindow === undefined ? {} : { contextWindow: alias.contextWindow }),
+        ...optionalChatTemplate(chatTemplateOverride ??
+            (await firstExisting((alias.chatTemplates ?? []).map(expandTemplate(home)))))
+    };
+}
+function findRequestedAlias(aliases, requested) {
+    return (aliases.find((entry) => entry.name === requested) ??
+        aliases.find((entry) => entry.id === requested));
+}
+export function defaultLlamaModelName() {
+    return "gemma-12b";
+}
+function customPathModel(modelPath, chatTemplate) {
+    return {
+        source: "path",
+        name: path.basename(modelPath, path.extname(modelPath)),
+        id: modelIdFromPath(modelPath),
+        modelPath,
+        ...optionalChatTemplate(chatTemplate)
+    };
+}
+async function allAliases(home) {
+    return [...(await configuredAliases(home)), ...builtInAliases(home)];
+}
+async function configuredAliases(home) {
+    const configPath = process.env["LOCALPI_MODELS_FILE"];
+    if (configPath === undefined) {
+        return [];
+    }
+    const raw = await readFile(expandHome(configPath, home), "utf8");
+    const root = asObject(JSON.parse(raw), "model alias config");
+    if (root["models"] === undefined) {
+        return [];
+    }
+    const models = asObject(root["models"], "model alias config models");
+    return Object.entries(models).map(([name, value]) => configuredAlias(name, value, home));
+}
+function configuredAlias(name, value, home) {
+    const entry = asObject(value, `model alias ${name}`);
+    const id = optionalString(entry["id"]) ?? name;
+    const primaryPath = optionalString(entry["path"]);
+    const paths = optionalStringArray(entry["paths"]);
+    const allPaths = [primaryPath, ...paths].filter((candidate) => candidate !== undefined);
+    if (allPaths.length === 0) {
+        throw new Error(`model alias ${name} must define path or paths`);
+    }
+    return {
+        name,
+        id,
+        paths: allPaths.map((candidate) => expandHome(candidate, home)),
+        ...optionalContextWindow(optionalPositiveInteger(entry["contextWindow"])),
+        chatTemplates: optionalStringArray(entry["chatTemplates"], optionalString(entry["chatTemplate"]))
+    };
+}
+function builtInAliases(home) {
+    return [
+        {
+            name: "gemma-12b",
+            id: "gemma-4-12b-it",
+            paths: [
+                "~/.lmstudio/models/lmstudio-community/gemma-4-12B-it-GGUF/gemma-4-12B-it-Q4_K_M.gguf",
+                "~/.lmstudio/models/unsloth/gemma-4-12b-it-GGUF/gemma-4-12b-it-Q4_K_M.gguf"
+            ],
+            contextWindow: 32768,
+            chatTemplates: [
+                "~/scratch/gemma12b-chat-template-efficiency/templates/source/gemma4-12b-lmstudio.jinja"
+            ]
+        },
+        {
+            name: "gemma-e4b",
+            id: "gemma-4-e4b-it",
+            paths: ["~/.lmstudio/models/ggml-org/gemma-4-E4B-it-GGUF/gemma-4-E4B-it-bf16.gguf"],
+            contextWindow: 32768,
+            chatTemplates: [
+                "~/scratch/gemma12b-chat-template-efficiency/templates/source/gemma4-e4b.jinja"
+            ]
+        },
+        {
+            name: "gemma-e2b",
+            id: "gemma-4-e2b-it",
+            paths: ["~/.lmstudio/models/ggml-org/gemma-4-E2B-it-GGUF/gemma-4-E2B-it-Q8_0.gguf"],
+            contextWindow: 32768,
+            chatTemplates: [
+                "~/scratch/gemma12b-chat-template-efficiency/templates/source/gemma4-e4b.jinja"
+            ]
+        }
+    ].map((alias) => ({
+        ...alias,
+        paths: alias.paths.map((candidate) => expandHome(candidate, home)),
+        chatTemplates: alias.chatTemplates.map((candidate) => expandHome(candidate, home))
+    }));
+}
+function optionalStringArray(value, first) {
+    const rest = Array.isArray(value) && value.every((entry) => typeof entry === "string")
+        ? value
+        : [];
+    return first === undefined ? rest : [first, ...rest];
+}
+function optionalPositiveInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : undefined;
+}
+function expandTemplate(home) {
+    return (candidate) => expandHome(candidate, home);
+}
+function expandHome(value, home) {
+    return value === "~" || value.startsWith("~/") ? path.join(home, value.slice(2)) : value;
+}
+function isGgufPath(value) {
+    return value.endsWith(".gguf") || value.includes("/") || value.includes("\\");
+}
+function optionalContextWindow(contextWindow) {
+    return contextWindow === undefined ? {} : { contextWindow };
+}
+function optionalChatTemplate(chatTemplate) {
+    return chatTemplate === undefined ? {} : { chatTemplate };
+}
+async function firstExisting(candidates) {
+    for (const candidate of candidates) {
+        if (await exists(candidate)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+async function exists(candidate) {
+    try {
+        await access(candidate);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function modelIdFromPath(modelPath) {
+    return path.basename(modelPath, path.extname(modelPath)).replaceAll(/\s+/gu, "-").toLowerCase();
+}

package/dist/src/localpi/options.js

@@ -0,0 +1,240 @@
+import path from "node:path";
+import { normalizeBaseUrl } from "../llm/openai.js";
+export const thinkingLevels = [
+    "off",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh"
+];
+export function defaultOptions() {
+    const home = envString("HOME", ".");
+    const stateDir = envString("LOCALPI_STATE_DIR", path.join(home, ".local/state/localpi"));
+    return {
+        runtime: parseRuntime(envString("LOCALPI_RUNTIME", "auto")),
+        baseUrl: envOptionalBaseUrl("LOCALPI_BASE_URL"),
+        model: process.env["LOCALPI_MODEL"],
+        provider: process.env["LOCALPI_PROVIDER"],
+        customProviderId: envString("LOCALPI_PROVIDER_ID", "local-openai"),
+        providersFile: process.env["LOCALPI_PROVIDERS_FILE"],
+        stateDir,
+        sessionDir: defaultSessionDir(stateDir),
+        piCommand: envString("LOCALPI_PI_CMD", "npx -y @earendil-works/pi-coding-agent@latest"),
+        thinking: parseThinkingLevel(envString("LOCALPI_THINKING", "off")),
+        contextWindow: envOptionalPositiveInteger("LOCALPI_CONTEXT_WINDOW"),
+        maxTokens: envPositiveInteger("LOCALPI_MAX_TOKENS", "8192"),
+        timeoutMs: envPositiveInteger("LOCALPI_TIMEOUT_MS", "3000"),
+        serverCommand: envString("LOCALPI_LLAMA_SERVER", "llama-server"),
+        host: envString("LOCALPI_HOST", "127.0.0.1"),
+        port: envPositiveInteger("LOCALPI_PORT", "18194"),
+        gpuLayers: envNonNegativeInteger("LOCALPI_GPU_LAYERS", "999"),
+        parallel: envPositiveInteger("LOCALPI_PARALLEL", "1"),
+        chatTemplate: process.env["LOCALPI_CHAT_TEMPLATE"],
+        tools: envString("LOCALPI_TOOLS", "read,bash,edit,write,grep,find,ls"),
+        approval: envBoolean("LOCALPI_APPROVAL", true),
+        tokenStatus: envBoolean("LOCALPI_TOKEN_STATUS", true),
+        status: false,
+        stop: false,
+        list: false,
+        forwardedArgs: []
+    };
+}
+export function parseLocalpiArgs(args) {
+    let options = defaultOptions();
+    const forwardedArgs = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === undefined) {
+            continue;
+        }
+        if (arg === "--") {
+            forwardedArgs.push(...args.slice(index + 1));
+            break;
+        }
+        if (arg === "-h" || arg === "--help") {
+            return { ...options, forwardedArgs: ["--help"] };
+        }
+        const parsed = parseLocalpiFlag(options, args, index);
+        if (parsed !== undefined) {
+            options = parsed.options;
+            index += parsed.advance;
+            continue;
+        }
+        forwardedArgs.push(arg);
+    }
+    return { ...options, forwardedArgs };
+}
+export function usage() {
+    return `${[
+        "localpi - Pi, automatically pointed at a local model",
+        "",
+        "usage:",
+        "  localpi [localpi options] [pi options/messages]",
+        "",
+        "localpi options:",
+        "  --runtime <kind>         auto, llama-server, lmstudio, vllm, or openai-compatible",
+        "  --provider <id>          catalog provider id to use",
+        "  --model <alias|id|path>  model alias, backend id, or GGUF path",
+        "  --base-url <url>         OpenAI-compatible endpoint",
+        "  --ctx <n>                model context window",
+        "  --context-window <n>     alias for --ctx",
+        "  --max-tokens <n>         generated model max output tokens",
+        "  --server-command <path>  llama-server executable",
+        "  --llama-server <path>    alias for --server-command",
+        "  --host <host>            managed llama-server host",
+        "  --port <n>               managed llama-server port",
+        "  --gpu-layers <n>         llama-server GPU layers",
+        "  --parallel <n>           llama-server parallel slots",
+        "  --chat-template <path>   llama.cpp chat template file",
+        "  --tools <list>           Pi tools allow list",
+        "  --providers-file <path>  localpi provider registry JSON",
+        "  --no-approval           do not ask before tool calls",
+        "  --no-token-status       do not install token status extension",
+        "  --status                print runtime status and exit",
+        "  --stop                  stop the localpi-owned llama-server",
+        "  --list                  list model aliases",
+        "  --state-dir <path>      localpi runtime state directory",
+        "  --session-dir <path>    Pi session directory",
+        "  --pi-command <command>  Pi launch command",
+        "  --thinking <level>      thinking level: off, minimal, low, medium, high, xhigh",
+        "  --timeout-ms <n>        backend probe timeout",
+        "  -h, --help              show this help",
+        "",
+        "removed options:",
+        "  --final-schema and --schema belong in localpager-agent, not localpi",
+        "",
+        "examples:",
+        "  localpi --list",
+        "  localpi --status",
+        '  localpi --model gemma-e4b -p "say ok"',
+        "  localpi --runtime lmstudio --model gemma-4-e4b-it",
+        "  localpi -- --help"
+    ].join("\n")}\n`;
+}
+function parseLocalpiFlag(options, args, index) {
+    const arg = args[index];
+    const booleanResult = arg === undefined ? undefined : parseBooleanFlag(options, arg);
+    if (booleanResult !== undefined) {
+        return booleanResult;
+    }
+    if (arg === "--schema" || arg === "--final-schema") {
+        throw new Error(`${arg} was removed from localpi; use localpager-agent for schema output`);
+    }
+    return arg === undefined ? undefined : parseValueFlag(options, args, index, arg);
+}
+function parseBooleanFlag(options, arg) {
+    const updater = booleanFlagUpdaters[arg];
+    return updater === undefined ? undefined : { options: updater(options), advance: 0 };
+}
+const booleanFlagUpdaters = {
+    "--status": (options) => ({ ...options, status: true }),
+    "--stop": (options) => ({ ...options, stop: true }),
+    "--list": (options) => ({ ...options, list: true }),
+    "--no-approval": (options) => ({ ...options, approval: false }),
+    "--no-token-status": (options) => ({ ...options, tokenStatus: false })
+};
+const valueFlagUpdaters = {
+    "--runtime": (options, value) => ({ ...options, runtime: parseRuntime(value) }),
+    "--base-url": (options, value) => ({ ...options, baseUrl: normalizeBaseUrl(value) }),
+    "--model": (options, value) => ({ ...options, model: value }),
+    "--provider": (options, value) => ({ ...options, provider: value }),
+    "--provider-id": (options, value) => ({ ...options, customProviderId: value }),
+    "--providers-file": (options, value) => ({ ...options, providersFile: value }),
+    "--state-dir": (options, value) => ({ ...options, stateDir: value }),
+    "--session-dir": (options, value) => ({ ...options, sessionDir: value }),
+    "--pi-command": (options, value) => ({ ...options, piCommand: value }),
+    "--thinking": (options, value) => ({ ...options, thinking: parseThinkingLevel(value) }),
+    "--ctx": (options, value) => ({ ...options, contextWindow: parsePositiveInteger(value) }),
+    "--context-window": (options, value) => ({
+        ...options,
+        contextWindow: parsePositiveInteger(value)
+    }),
+    "--max-tokens": (options, value) => ({ ...options, maxTokens: parsePositiveInteger(value) }),
+    "--timeout-ms": (options, value) => ({ ...options, timeoutMs: parsePositiveInteger(value) }),
+    "--server-command": (options, value) => ({ ...options, serverCommand: value }),
+    "--llama-server": (options, value) => ({ ...options, serverCommand: value }),
+    "--host": (options, value) => ({ ...options, host: value }),
+    "--port": (options, value) => ({ ...options, port: parsePositiveInteger(value) }),
+    "--gpu-layers": (options, value) => ({ ...options, gpuLayers: parseNonNegativeInteger(value) }),
+    "--parallel": (options, value) => ({ ...options, parallel: parsePositiveInteger(value) }),
+    "--chat-template": (options, value) => ({ ...options, chatTemplate: value }),
+    "--tools": (options, value) => ({ ...options, tools: value })
+};
+function parseValueFlag(options, args, index, flag) {
+    const updater = valueFlagUpdaters[flag];
+    if (updater === undefined) {
+        return undefined;
+    }
+    return { options: updater(options, requiredValue(args, index + 1, flag)), advance: 1 };
+}
+function parseRuntime(value) {
+    if (value === "auto" ||
+        value === "llama-server" ||
+        value === "lmstudio" ||
+        value === "vllm" ||
+        value === "openai-compatible") {
+        return value;
+    }
+    throw new Error(`unknown runtime ${value}; expected auto, llama-server, lmstudio, vllm, or openai-compatible`);
+}
+export function parseThinkingLevel(value) {
+    for (const level of thinkingLevels) {
+        if (value === level) {
+            return level;
+        }
+    }
+    throw new Error(`unknown thinking level ${value}; expected off, minimal, low, medium, high, or xhigh`);
+}
+function envString(name, fallback) {
+    return process.env[name] ?? fallback;
+}
+function envOptionalBaseUrl(name) {
+    const value = process.env[name];
+    return value === undefined ? undefined : normalizeBaseUrl(value);
+}
+function envPositiveInteger(name, fallback) {
+    return parsePositiveInteger(envString(name, fallback));
+}
+function envNonNegativeInteger(name, fallback) {
+    return parseNonNegativeInteger(envString(name, fallback));
+}
+function envOptionalPositiveInteger(name) {
+    const value = process.env[name];
+    return value === undefined ? undefined : parsePositiveInteger(value);
+}
+function envBoolean(name, fallback) {
+    const value = process.env[name];
+    if (value === undefined) {
+        return fallback;
+    }
+    if (["1", "true", "yes", "on"].includes(value.toLowerCase())) {
+        return true;
+    }
+    if (["0", "false", "no", "off"].includes(value.toLowerCase())) {
+        return false;
+    }
+    throw new Error(`${name} must be boolean-like, got ${value}`);
+}
+function defaultSessionDir(stateDir) {
+    return envString("LOCALPI_SESSION_DIR", envString("PI_CODING_AGENT_SESSION_DIR", path.join(stateDir, "sessions")));
+}
+function requiredValue(args, index, flag) {
+    const value = args[index];
+    if (value === undefined) {
+        throw new Error(`${flag} requires a value`);
+    }
+    return value;
+}
+function parsePositiveInteger(value) {
+    if (!/^[1-9]\d*$/u.test(value)) {
+        throw new Error(`expected a positive integer, got ${value}`);
+    }
+    return Number.parseInt(value, 10);
+}
+function parseNonNegativeInteger(value) {
+    if (!/^(0|[1-9]\d*)$/u.test(value)) {
+        throw new Error(`expected a non-negative integer, got ${value}`);
+    }
+    return Number.parseInt(value, 10);
+}