llm-cli-gateway 1.0.0

package/dist/model-registry.js

@@ -0,0 +1,346 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { homedir } from "os";
+import path from "path";
+const FALLBACK_INFO = {
+    claude: {
+        description: "Anthropic's Claude Code CLI - best for code generation, analysis, and agentic coding tasks",
+        models: {
+            opus: "Most capable model. Best for: complex reasoning, nuanced analysis, difficult problems, research",
+            sonnet: "Balanced performance. Best for: everyday coding, code review, general tasks (default)",
+            haiku: "Fastest model. Best for: simple queries, quick answers, high-volume tasks, cost-sensitive use"
+        },
+        defaultModel: "sonnet",
+        modelOrder: ["opus", "sonnet", "haiku"]
+    },
+    codex: {
+        description: "OpenAI's Codex CLI - best for code execution in sandboxed environments",
+        models: {
+            "gpt-5.4": "Frontier coding and professional-work model. Best for: most Codex tasks, long-running agentic work",
+            "gpt-5.3-codex": "Specialized Codex model. Best for: agentic coding workflows with Codex-tuned behavior",
+            "gpt-5.2": "Strong general-purpose GPT-5 model. Best for: broad coding and reasoning tasks",
+            "gpt-5-pro": "Highest-capability GPT-5 model. Best for: deep reasoning and difficult professional workflows"
+        },
+        defaultModel: "gpt-5.4",
+        modelOrder: ["gpt-5.4", "gpt-5.3-codex", "gpt-5.2", "gpt-5-pro"]
+    },
+    gemini: {
+        description: "Google's Gemini CLI - best for multimodal tasks and Google ecosystem integration",
+        models: {
+            "gemini-2.5-pro": "Most capable model. Best for: complex reasoning, long context, multimodal",
+            "gemini-2.5-flash": "Fast model. Best for: quick responses, high throughput, cost-sensitive use"
+        }
+    }
+};
+const MODEL_CACHE_TTL_MS = 2 * 60 * 1000;
+let cachedInfo = null;
+export function getCliInfo(forceRefresh = false) {
+    if (!forceRefresh && cachedInfo && Date.now() - cachedInfo.loadedAt < MODEL_CACHE_TTL_MS) {
+        return cachedInfo.info;
+    }
+    const info = buildCliInfo();
+    cachedInfo = { loadedAt: Date.now(), info };
+    return info;
+}
+export function resolveModelAlias(cli, model, info) {
+    if (!model) {
+        return undefined;
+    }
+    const trimmed = model.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const normalized = trimmed.toLowerCase();
+    const cliInfo = info[cli];
+    if (normalized === "default" || normalized === "latest") {
+        return cliInfo.defaultModel ?? trimmed;
+    }
+    if (cli === "gemini") {
+        if (normalized === "flash" || normalized === "pro") {
+            const picked = pickLatestMatching(cliInfo, normalized);
+            return picked ?? trimmed;
+        }
+    }
+    return trimmed;
+}
+function buildCliInfo() {
+    const info = {
+        claude: cloneInfo(FALLBACK_INFO.claude),
+        codex: cloneInfo(FALLBACK_INFO.codex),
+        gemini: cloneInfo(FALLBACK_INFO.gemini)
+    };
+    applyClaudeOverrides(info.claude);
+    applyCodexOverrides(info.codex);
+    applyGeminiOverrides(info.gemini);
+    return info;
+}
+function cloneInfo(source) {
+    return {
+        description: source.description,
+        models: { ...source.models },
+        defaultModel: source.defaultModel,
+        modelOrder: source.modelOrder ? [...source.modelOrder] : undefined
+    };
+}
+function applyClaudeOverrides(info) {
+    const settingsPath = path.join(homedir(), ".claude", "settings.json");
+    const settingsLocalPath = path.join(homedir(), ".claude", "settings.local.json");
+    const envDefault = process.env.CLAUDE_DEFAULT_MODEL;
+    const localDefault = readJsonValue(settingsLocalPath, "model");
+    const settingsDefault = readJsonValue(settingsPath, "model");
+    const defaultModel = envDefault || localDefault || settingsDefault;
+    const defaultSource = envDefault
+        ? "CLAUDE_DEFAULT_MODEL"
+        : localDefault
+            ? settingsLocalPath
+            : settingsPath;
+    if (defaultModel && typeof defaultModel === "string") {
+        if (!info.models[defaultModel]) {
+            info.models[defaultModel] = `Configured default from ${defaultSource}`;
+        }
+        info.defaultModel = defaultModel;
+    }
+    const envModels = parseEnvModels(process.env.CLAUDE_MODELS);
+    if (envModels.length > 0) {
+        envModels.forEach(model => {
+            if (!info.models[model]) {
+                info.models[model] = "Configured via CLAUDE_MODELS";
+            }
+        });
+    }
+    info.modelOrder = buildOrder(info, info.defaultModel);
+}
+function applyCodexOverrides(info) {
+    const configPath = process.env.CODEX_CONFIG_PATH || path.join(homedir(), ".codex", "config.toml");
+    const envDefault = process.env.CODEX_DEFAULT_MODEL;
+    const envModels = parseEnvModels(process.env.CODEX_MODELS);
+    const detectedModels = {};
+    let defaultModel;
+    if (existsSync(configPath)) {
+        const content = readFileSync(configPath, "utf-8");
+        const model = extractTomlString(content, "model");
+        if (model) {
+            detectedModels[model] = `Default from ${configPath}`;
+            defaultModel = model;
+        }
+        const migrations = extractTomlTableMap(content, "notice.model_migrations");
+        Object.entries(migrations).forEach(([from, to]) => {
+            if (!detectedModels[to]) {
+                detectedModels[to] = `Migrated from ${from}`;
+            }
+            if (!detectedModels[from]) {
+                detectedModels[from] = `Legacy model (migrates to ${to})`;
+            }
+        });
+    }
+    envModels.forEach(model => {
+        if (!detectedModels[model]) {
+            detectedModels[model] = "Configured via CODEX_MODELS";
+        }
+    });
+    if (envDefault) {
+        detectedModels[envDefault] = detectedModels[envDefault] || "Default from CODEX_DEFAULT_MODEL";
+        defaultModel = envDefault;
+    }
+    if (Object.keys(detectedModels).length > 0) {
+        info.models = detectedModels;
+        info.defaultModel = defaultModel;
+    }
+    else {
+        info.defaultModel = defaultModel;
+    }
+    info.modelOrder = buildOrder(info, info.defaultModel);
+}
+function applyGeminiOverrides(info) {
+    const envDefault = process.env.GEMINI_DEFAULT_MODEL;
+    const envModels = parseEnvModels(process.env.GEMINI_MODELS);
+    const observed = collectGeminiModels();
+    if (Object.keys(observed.models).length > 0) {
+        info.models = observed.models;
+        info.modelOrder = observed.order;
+        info.defaultModel = observed.order[0];
+    }
+    envModels.forEach(model => {
+        if (!info.models[model]) {
+            info.models[model] = "Configured via GEMINI_MODELS";
+        }
+    });
+    if (envDefault) {
+        info.models[envDefault] = info.models[envDefault] || "Default from GEMINI_DEFAULT_MODEL";
+        info.defaultModel = envDefault;
+    }
+    info.modelOrder = buildOrder(info, info.defaultModel);
+}
+function readJsonValue(filePath, key) {
+    if (!existsSync(filePath)) {
+        return undefined;
+    }
+    try {
+        const content = readFileSync(filePath, "utf-8");
+        const parsed = JSON.parse(content);
+        const value = parsed?.[key];
+        return typeof value === "string" ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseEnvModels(value) {
+    if (!value) {
+        return [];
+    }
+    return value
+        .split(/[,\n]/)
+        .map(entry => entry.trim())
+        .filter(entry => entry.length > 0);
+}
+function extractTomlString(content, key) {
+    const regex = new RegExp(`^\\s*${escapeRegex(key)}\\s*=\\s*\"([^\"]+)\"`, "m");
+    const match = content.match(regex);
+    return match ? match[1] : undefined;
+}
+function extractTomlTableMap(content, tableName) {
+    const tableRegex = new RegExp(`^\\s*\\[${escapeRegex(tableName)}\\]\\s*$`, "m");
+    const tableMatch = content.match(tableRegex);
+    if (!tableMatch || tableMatch.index === undefined) {
+        return {};
+    }
+    const startIndex = tableMatch.index + tableMatch[0].length;
+    const rest = content.slice(startIndex);
+    const nextTable = rest.search(/^\s*\[[^\]]+\]\s*$/m);
+    const block = nextTable >= 0 ? rest.slice(0, nextTable) : rest;
+    const map = {};
+    const lineRegex = /"([^"]+)"\s*=\s*"([^"]+)"/g;
+    let match;
+    while ((match = lineRegex.exec(block)) !== null) {
+        map[match[1]] = match[2];
+    }
+    return map;
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function collectGeminiModels() {
+    const root = path.join(homedir(), ".gemini", "tmp");
+    if (!existsSync(root)) {
+        return { models: {}, order: [] };
+    }
+    const candidates = [];
+    const roots = safeReadDir(root);
+    roots.forEach(entry => {
+        if (!entry.isDirectory()) {
+            return;
+        }
+        const chatsPath = path.join(root, entry.name, "chats");
+        if (!existsSync(chatsPath)) {
+            return;
+        }
+        safeReadDir(chatsPath).forEach(file => {
+            if (!file.isFile() || !file.name.endsWith(".json")) {
+                return;
+            }
+            const filePath = path.join(chatsPath, file.name);
+            try {
+                const stat = statSync(filePath);
+                candidates.push({ filePath, mtimeMs: stat.mtimeMs });
+            }
+            catch {
+                return;
+            }
+        });
+    });
+    candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    const maxFiles = 200;
+    const recent = candidates.slice(0, maxFiles);
+    const models = {};
+    for (const candidate of recent) {
+        const model = extractGeminiModel(candidate.filePath);
+        if (!model) {
+            continue;
+        }
+        const existing = models[model]?.lastSeen ?? 0;
+        if (candidate.mtimeMs > existing) {
+            models[model] = { lastSeen: candidate.mtimeMs };
+        }
+    }
+    const order = Object.entries(models)
+        .sort((a, b) => {
+        const versionDiff = extractModelVersion(b[0]) - extractModelVersion(a[0]);
+        if (versionDiff !== 0) {
+            return versionDiff;
+        }
+        return b[1].lastSeen - a[1].lastSeen;
+    })
+        .map(([name]) => name);
+    const describedModels = {};
+    order.forEach(model => {
+        describedModels[model] = `Observed in local Gemini sessions (last seen ${formatDate(models[model].lastSeen)})`;
+    });
+    return { models: describedModels, order };
+}
+function extractGeminiModel(filePath) {
+    try {
+        const content = readFileSync(filePath, "utf-8");
+        const match = content.match(/"model"\s*:\s*"([^"]+)"/);
+        return match ? match[1] : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function formatDate(timestampMs) {
+    try {
+        return new Date(timestampMs).toISOString().slice(0, 10);
+    }
+    catch {
+        return "unknown";
+    }
+}
+function extractModelVersion(model) {
+    const match = model.match(/(\d+(?:\.\d+)?)/);
+    if (!match) {
+        return 0;
+    }
+    const parsed = Number.parseFloat(match[1]);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function safeReadDir(dirPath) {
+    try {
+        return readdirSync(dirPath, { withFileTypes: true, encoding: "utf8" });
+    }
+    catch {
+        return [];
+    }
+}
+function buildOrder(info, preferred) {
+    const order = [];
+    const seen = new Set();
+    if (preferred && info.models[preferred]) {
+        order.push(preferred);
+        seen.add(preferred);
+    }
+    if (info.modelOrder) {
+        info.modelOrder.forEach(model => {
+            if (!seen.has(model) && info.models[model]) {
+                order.push(model);
+                seen.add(model);
+            }
+        });
+    }
+    Object.keys(info.models).forEach(model => {
+        if (!seen.has(model)) {
+            order.push(model);
+            seen.add(model);
+        }
+    });
+    return order;
+}
+function pickLatestMatching(info, token) {
+    const normalized = token.toLowerCase();
+    const order = info.modelOrder ?? Object.keys(info.models);
+    for (const model of order) {
+        if (model.toLowerCase().includes(normalized)) {
+            return model;
+        }
+    }
+    return undefined;
+}

package/dist/optimizer.d.ts

@@ -0,0 +1,3 @@
+export declare function estimateTokens(text: string): number;
+export declare function optimizePrompt(text: string): string;
+export declare function optimizeResponse(text: string): string;

package/dist/optimizer.js

@@ -0,0 +1,183 @@
+const COURTESY_PATTERNS = [
+    /\bPlease\b[:,]?\s*/gi,
+    /\bCould you\b\s*/gi,
+    /\bI would like you to\b\s*/gi,
+    /\bI would like\b\s*/gi,
+    /\bI need you to\b\s*/gi,
+    /\bI just implemented\b\s*/gi,
+    /\bPlease do the following:?\s*/gi
+];
+const ADJECTIVE_PATTERNS = [
+    /\bcomprehensive\b/gi,
+    /\bdetailed\b/gi,
+    /\bthorough\b/gi,
+    /\boverall\b/gi,
+    /\bcritical\b/gi
+];
+const TASK_PREFIXES = [
+    /^(First|Then|After that|Finally),?\s*/i,
+    /^(First|Then|After that|Finally),?\s*you should\s*/i
+];
+export function estimateTokens(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return 0;
+    const words = trimmed.split(/\s+/).length;
+    return Math.ceil(words * 1.3);
+}
+export function optimizePrompt(text) {
+    return optimizeText(text, "prompt");
+}
+export function optimizeResponse(text) {
+    return optimizeText(text, "response");
+}
+function optimizeText(text, mode) {
+    if (!text.trim())
+        return text;
+    const parts = [];
+    const codeBlockRegex = /```[\s\S]*?```/g;
+    let lastIndex = 0;
+    let match;
+    while ((match = codeBlockRegex.exec(text)) !== null) {
+        parts.push(optimizeSegment(text.slice(lastIndex, match.index), mode));
+        parts.push(match[0]);
+        lastIndex = match.index + match[0].length;
+    }
+    parts.push(optimizeSegment(text.slice(lastIndex), mode));
+    return parts.join("");
+}
+function optimizeSegment(segment, mode) {
+    const inlineParts = segment.split(/(`[^`]*`)/g);
+    return inlineParts
+        .map((part) => (part.startsWith("`") ? part : optimizePlain(part, mode)))
+        .join("");
+}
+function optimizePlain(text, mode) {
+    let output = text;
+    COURTESY_PATTERNS.forEach((pattern) => {
+        output = output.replace(pattern, "");
+    });
+    ADJECTIVE_PATTERNS.forEach((pattern) => {
+        output = output.replace(pattern, "");
+    });
+    output = output.replace(/\bfound in the [^:.\n]+/gi, "");
+    output = output.replace(/\bthat we implemented\b/gi, "");
+    output = output.replace(/\bwe implemented\b/gi, "");
+    output = output.replace(/\bthe\s+([a-z][\w\s-]+?)\s+system\b/gi, "$1");
+    output = output.replace(/\bthe\s+([a-z][\w\s-]+?)\s+feature\b/gi, "$1");
+    output = output.replace(/^\s*Problem:\s*/gim, "");
+    output = inlineFileReferences(output);
+    output = compactTypes(output);
+    output = output.replace(/\bAre there any\s+([^?]+)\?/gi, "$1?");
+    output = compressTaskLists(output);
+    output = applyArrowNotation(output);
+    output = applySlashNotation(output);
+    if (mode === "response") {
+        output = output.replace(/\bIn conclusion\b[:,]?\s*/gi, "");
+        output = output.replace(/\bOverall\b[:,]?\s*/gi, "");
+    }
+    output = output.replace(/[ \t]+/g, " ");
+    output = output.replace(/\n{3,}/g, "\n\n");
+    return output.trimEnd();
+}
+function inlineFileReferences(text) {
+    const replaceLines = (lines) => {
+        const matches = lines.match(/\d+/g);
+        if (!matches)
+            return lines.trim();
+        return matches.join(",");
+    };
+    let output = text.replace(/\b(?:in (?:the )?file\s+)?(\S+)\s+(?:on|at)\s+lines?\s+([0-9 ,and~]+)/gi, (_match, file, lines) => `${file}:${replaceLines(lines)}`);
+    output = output.replace(/\b(?:in (?:the )?file\s+)?(\S+)\s+on line\s+~?(\d+)/gi, (_match, file, line) => `${file}:${line}`);
+    output = output.replace(/\b(\S+)\s+line\s+~?(\d+)/gi, (_match, file, line) => `${file}:${line}`);
+    output = output.replace(/\b(?:in the )?([\w./-]+)\s+file\s+at\s+lines?\s+([0-9 ,and~]+)/gi, (_match, file, lines) => `${file}:${replaceLines(lines)}`);
+    output = output.replace(/\bin the\s+([\w./-]+)\s+file:(\d+(?:,\d+)*)/gi, "$1:$2");
+    return output;
+}
+function compactTypes(text) {
+    let output = text;
+    output = output.replace(/\ban? optional boolean\s*\(default\s*(true|false)\)/gi, "bool=$1");
+    output = output.replace(/\boptional boolean\b/gi, "bool?");
+    output = output.replace(/\bboolean\b/gi, "bool");
+    output = output.replace(/\ban? required integer\b/gi, "int!");
+    output = output.replace(/\ban? integer\b/gi, "int");
+    output = output.replace(/\ban? array of strings\b/gi, "str[]");
+    output = output.replace(/\bstring enum of\s*(\[[^\]]+\])/gi, "enum$1");
+    output = output.replace(/\bstring enum\b/gi, "enum");
+    output = output.replace(/\bstring parameter\b/gi, "param:str");
+    output = output.replace(/\bstring\b/gi, "str");
+    return output;
+}
+function compressTaskLists(text) {
+    const lines = text.split("\n");
+    const output = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        if (/^\s*\d+\.\s+/.test(line)) {
+            const items = [];
+            let j = i;
+            while (j < lines.length && /^\s*\d+\.\s+/.test(lines[j])) {
+                const item = lines[j].replace(/^\s*\d+\.\s+/, "");
+                items.push(cleanTaskItem(item));
+                j += 1;
+            }
+            if (items.length > 1) {
+                output.push(`Tasks: ${items.join(" → ")}`);
+                i = j - 1;
+                continue;
+            }
+        }
+        if (/^\s*-\s+/.test(line)) {
+            const items = [];
+            let j = i;
+            while (j < lines.length && /^\s*-\s+/.test(lines[j])) {
+                const item = lines[j].replace(/^\s*-\s+/, "");
+                items.push(cleanTaskItem(item));
+                j += 1;
+            }
+            if (items.length > 1) {
+                output.push(items.join(" → "));
+                i = j - 1;
+                continue;
+            }
+        }
+        output.push(line);
+    }
+    return output.join("\n");
+}
+function cleanTaskItem(item) {
+    let cleaned = item.trim();
+    TASK_PREFIXES.forEach((pattern) => {
+        cleaned = cleaned.replace(pattern, "");
+    });
+    cleaned = cleaned.replace(/^you should\s*/i, "");
+    cleaned = cleaned.replace(/^\bPlease\b\s*/i, "");
+    cleaned = cleaned.replace(/[.:;]+$/g, "");
+    return cleaned;
+}
+function applyArrowNotation(text) {
+    const lines = text.split("\n");
+    const output = lines.map((line) => {
+        let updated = line;
+        updated = updated.replace(/\bChange\s+(?:the\s+)?([A-Za-z][\w-]*)\s+to\s+(?:a\s+|an\s+)?([A-Za-z][\w-]*)([.!?]|$)/gi, (_m, from, to, end) => {
+            return `${from.trim()} → ${to.trim()}${end || ""}`;
+        });
+        updated = updated.replace(/\bConvert\s+(?:the\s+)?([A-Za-z][\w-]*)\s+to\s+(?:a\s+|an\s+)?([A-Za-z][\w-]*)([.!?]|$)/gi, (_m, from, to, end) => {
+            return `${from.trim()} → ${to.trim()}${end || ""}`;
+        });
+        updated = updated.replace(/\b(\w+)\s+should be\s+an?\s+(\w+)/gi, "$1: $2");
+        return updated;
+    });
+    return output.join("\n");
+}
+function applySlashNotation(text) {
+    const lines = text.split("\n");
+    const output = lines.map((line) => {
+        const trimmed = line.trim();
+        if (trimmed.length < 50 && /^[A-Za-z0-9][A-Za-z0-9\s/&-]+$/.test(trimmed)) {
+            return line.replace(/\s+and\s+/, "/");
+        }
+        return line;
+    });
+    return output.join("\n");
+}

package/dist/process-monitor.d.ts

@@ -0,0 +1,54 @@
+/**
+ * On-demand process health monitoring via /proc (Linux).
+ * Gracefully degrades on non-Linux platforms.
+ */
+import type { Logger } from "./logger.js";
+export interface ProcessHealth {
+    pid: number;
+    alive: boolean;
+    state: string | null;
+    cpuPercent: number | null;
+    memoryRssKb: number | null;
+    sampledAt: string;
+}
+export interface JobHealth {
+    jobId: string;
+    cli: string;
+    status: string;
+    processHealth: ProcessHealth | null;
+    isDead: boolean;
+    isZombie: boolean;
+    runningForMs: number;
+}
+/**
+ * Parse /proc/[pid]/stat safely.
+ * The `comm` field (field 2) is in parentheses and may contain spaces,
+ * so we find the LAST ')' and parse remaining fields from there.
+ */
+export declare function parseProcStat(content: string): {
+    state: string;
+    utime: number;
+    stime: number;
+} | null;
+/**
+ * Parse VmRSS from /proc/[pid]/status.
+ * Returns RSS in kilobytes (already in kB in /proc/[pid]/status).
+ */
+export declare function parseVmRss(content: string): number | null;
+export declare class ProcessMonitor {
+    private logger;
+    private prevSamples;
+    constructor(logger?: Logger);
+    /** Clear all cached CPU samples */
+    reset(): void;
+    sampleProcess(pid: number): ProcessHealth;
+    checkJobHealth(jobs: {
+        jobId: string;
+        cli: string;
+        status: string;
+        pid: number | null;
+        startedAt: string;
+    }[]): JobHealth[];
+    /** Clean up stale samples for PIDs that no longer exist */
+    cleanupSamples(activePids: Set<number>): void;
+}