chels-code 0.0.0-stage → 0.5.1

package/dist/src/providers.js

@@ -0,0 +1,250 @@
+export const PROVIDER_IDS = ["openrouter", "nvidia", "groq"];
+export const PROVIDERS = {
+    openrouter: {
+        label: "OpenRouter",
+        endpoint: "https://openrouter.ai/api/v1/chat/completions",
+        modelsEndpoint: "https://openrouter.ai/api/v1/models",
+        keyVariable: "OPENROUTER_API_KEY",
+    },
+    nvidia: {
+        label: "NVIDIA",
+        endpoint: "https://integrate.api.nvidia.com/v1/chat/completions",
+        modelsEndpoint: "https://integrate.api.nvidia.com/v1/models",
+        keyVariable: "NVIDIA_API_KEY",
+    },
+    groq: {
+        label: "Groq",
+        endpoint: "https://api.groq.com/openai/v1/chat/completions",
+        modelsEndpoint: "https://api.groq.com/openai/v1/models",
+        keyVariable: "GROQ_API_KEY",
+    },
+};
+const PREFERRED_MODELS = {
+    openrouter: [
+        "qwen/qwen3-coder:free",
+        "deepseek/deepseek-chat-v3-0324:free",
+        "meta-llama/llama-3.3-70b-instruct:free",
+    ],
+    nvidia: [
+        "meta/llama-3.3-70b-instruct",
+        "qwen/qwen2.5-coder-32b-instruct",
+    ],
+    groq: [
+        "llama-3.3-70b-versatile",
+        "qwen/qwen3-32b",
+        "deepseek-r1-distill-llama-70b",
+    ],
+};
+async function providerFetch(url, provider, apiKey, options = {}) {
+    const headers = new Headers(options.headers);
+    headers.set("Authorization", `Bearer ${apiKey}`);
+    const response = await fetch(url, {
+        ...options,
+        headers,
+        signal: AbortSignal.timeout(120_000),
+    });
+    if (!response.ok) {
+        const body = await response.text();
+        let detail = body;
+        try {
+            const parsed = JSON.parse(body);
+            detail = parsed.error?.message ?? parsed.message ?? body;
+        }
+        catch {
+            // Keep the provider's plain-text error response.
+        }
+        throw new Error(`${PROVIDERS[provider].label} API returned HTTP ${response.status}: ${detail}`);
+    }
+    return response;
+}
+function isExplicitlyFree(model) {
+    if (typeof model.id === "string" && model.id.endsWith(":free"))
+        return true;
+    const asPrice = (value) => (typeof value === "number" || (typeof value === "string" && value.trim() !== "")
+        ? Number(value)
+        : Number.NaN);
+    const prompt = asPrice(model.pricing?.prompt);
+    const completion = asPrice(model.pricing?.completion);
+    return Number.isFinite(prompt) && Number.isFinite(completion) && prompt === 0 && completion === 0;
+}
+export async function discoverModels(provider, apiKey) {
+    const response = await providerFetch(PROVIDERS[provider].modelsEndpoint, provider, apiKey);
+    const data = await response.json();
+    if (typeof data !== "object"
+        || data === null
+        || !Array.isArray(data.data)) {
+        throw new Error(`${PROVIDERS[provider].label} returned an unsupported model-list response.`);
+    }
+    return (data.data)
+        .filter((model) => (typeof model === "object"
+        && model !== null
+        && typeof model.id === "string"))
+        .map((model) => ({
+        id: model.id,
+        name: typeof model.name === "string" ? model.name : model.id,
+        free: isExplicitlyFree(model),
+        supportsTools: Array.isArray(model.supported_parameters)
+            ? model.supported_parameters.includes("tools")
+            : undefined,
+        contextLength: Number(model.context_length ?? model.context_window) || 0,
+        type: typeof model.type === "string" ? model.type : undefined,
+    }))
+        .sort((left, right) => Number(right.free) - Number(left.free) || left.id.localeCompare(right.id));
+}
+function isChatModel(model) {
+    if (typeof model.type === "string" && !["chat", "text"].includes(model.type.toLowerCase())) {
+        return false;
+    }
+    return !/(embedding|rerank|moderation|whisper|transcri|text-to-speech|tts|image-gen)/i.test(model.id);
+}
+function reliabilityScore(model) {
+    let score = 0;
+    const id = model.id.toLowerCase();
+    if (/(instruct|chat|versatile)/.test(id))
+        score += 12;
+    if (/(preview|experimental|beta|deprecated|legacy)/.test(id))
+        score -= 20;
+    const size = id.match(/(?:^|[-/])(\d+(?:\.\d+)?)b(?:[-:/]|$)/);
+    if (size)
+        score += Math.min(Number(size[1]), 70) / 10;
+    score += Math.min(model.contextLength, 128_000) / 128_000;
+    return score;
+}
+export function selectReliableModel(provider, models) {
+    const chatModels = models.filter(isChatModel);
+    if (chatModels.length === 0) {
+        throw new Error(`${PROVIDERS[provider].label} did not return any chat models.`);
+    }
+    const freeModels = chatModels.filter((model) => model.free);
+    const candidates = freeModels.length ? freeModels : chatModels;
+    const toolModels = candidates.filter((model) => model.supportsTools === true);
+    const compatible = toolModels.length
+        ? toolModels
+        : candidates.filter((model) => model.supportsTools !== false);
+    if (compatible.length === 0) {
+        throw new Error(`${PROVIDERS[provider].label} has no available chat model that supports tool calls.`);
+    }
+    const preferred = PREFERRED_MODELS[provider];
+    return [...compatible].sort((left, right) => {
+        const leftPreference = preferred.indexOf(left.id);
+        const rightPreference = preferred.indexOf(right.id);
+        const leftRank = leftPreference < 0 ? Number.MAX_SAFE_INTEGER : leftPreference;
+        const rightRank = rightPreference < 0 ? Number.MAX_SAFE_INTEGER : rightPreference;
+        return leftRank - rightRank
+            || reliabilityScore(right) - reliabilityScore(left)
+            || left.id.localeCompare(right.id);
+    })[0];
+}
+export async function chooseAvailableModel(provider, apiKey) {
+    const models = await discoverModels(provider, apiKey);
+    return selectReliableModel(provider, models);
+}
+function optionalNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string" && value.trim() !== "") {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return null;
+}
+function normalizeUsage(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const raw = value;
+    const prompt = optionalNumber(raw.prompt_tokens);
+    const completion = optionalNumber(raw.completion_tokens);
+    const total = optionalNumber(raw.total_tokens);
+    if (prompt === null && completion === null && total === null)
+        return undefined;
+    const promptTokens = prompt ?? 0;
+    const completionTokens = completion ?? 0;
+    const totalTokens = total ?? promptTokens + completionTokens;
+    const cost = optionalNumber(raw.cost);
+    return cost === null
+        ? { promptTokens, completionTokens, totalTokens }
+        : { promptTokens, completionTokens, totalTokens, cost };
+}
+async function readCreditJson(response) {
+    try {
+        return await response.json();
+    }
+    catch {
+        return null;
+    }
+}
+export async function fetchAvailableCredits(apiKey) {
+    const headers = { Authorization: `Bearer ${apiKey}` };
+    try {
+        const response = await fetch("https://openrouter.ai/api/v1/key", {
+            headers,
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (response.ok) {
+            const { data } = (await readCreditJson(response) ?? {});
+            const remaining = optionalNumber(data?.limit_remaining);
+            if (remaining !== null) {
+                return { remaining: Math.max(0, remaining), source: "key" };
+            }
+            const limit = optionalNumber(data?.limit);
+            const usage = optionalNumber(data?.usage) ?? 0;
+            if (limit !== null && limit > 0) {
+                return { remaining: Math.max(0, limit - usage), source: "key" };
+            }
+            const budgetRemaining = optionalNumber(data?.effective_budget?.remaining_usd);
+            if (budgetRemaining !== null) {
+                return { remaining: Math.max(0, budgetRemaining), source: "budget" };
+            }
+            const budgets = Array.isArray(data?.budgets) ? data.budgets : [];
+            const remainingBudgets = budgets
+                .map((budget) => optionalNumber(budget?.remaining_usd))
+                .filter((value) => value !== null);
+            if (remainingBudgets.length > 0) {
+                return { remaining: Math.max(0, Math.min(...remainingBudgets)), source: "budget" };
+            }
+        }
+    }
+    catch {
+        // Credit status is optional; the footer can fall back to context usage.
+    }
+    try {
+        const response = await fetch("https://openrouter.ai/api/v1/credits", {
+            headers,
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (response.ok) {
+            const { data } = (await readCreditJson(response) ?? {});
+            const total = optionalNumber(data?.total_credits);
+            const used = optionalNumber(data?.total_usage) ?? 0;
+            if (total !== null) {
+                return { remaining: Math.max(0, total - used), source: "account" };
+            }
+        }
+    }
+    catch {
+        // Account credits require a management key and may not be available.
+    }
+    return null;
+}
+export async function createChatCompletion({ provider, apiKey, model, messages, tools, }) {
+    const payload = {
+        model,
+        messages,
+        max_tokens: 4096,
+    };
+    if (tools) {
+        payload.tools = tools;
+        payload.tool_choice = "auto";
+    }
+    const response = await providerFetch(PROVIDERS[provider].endpoint, provider, apiKey, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+    });
+    const data = await response.json();
+    const message = data.choices?.[0]?.message;
+    if (!message)
+        throw new Error(`${PROVIDERS[provider].label} returned no assistant message.`);
+    return { message, usage: normalizeUsage(data.usage) };
+}

package/dist/src/safety.js

@@ -0,0 +1,48 @@
+import path from "node:path";
+import { realpath, stat } from "node:fs/promises";
+const SECRET_FILE = /(^|[/\\])\.env(?:\..*)?$|(?:^|[/\\])[^/\\]*(?:secret|credential|private[-_]?key)[^/\\]*|\.pem$/i;
+export function isSensitivePath(relativePath) {
+    const normalized = relativePath.replaceAll("\\", "/");
+    return SECRET_FILE.test(normalized) && !/(^|\/)\.env\.example$/i.test(normalized);
+}
+export async function resolveWorkspacePath(workspace, requestedPath, { mustExist = false } = {}) {
+    if (typeof requestedPath !== "string" || requestedPath.length === 0 || requestedPath.includes("\0")) {
+        throw new Error("A non-empty relative path is required.");
+    }
+    if (path.isAbsolute(requestedPath) || /^[a-z]:/i.test(requestedPath)) {
+        throw new Error("Absolute paths are not allowed.");
+    }
+    const root = await realpath(workspace);
+    const target = path.resolve(root, requestedPath);
+    const relative = path.relative(root, target);
+    if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+        throw new Error("The path must stay inside the workspace.");
+    }
+    if (isSensitivePath(relative)) {
+        throw new Error("Access to secret-like files is blocked.");
+    }
+    let existing = target;
+    while (true) {
+        try {
+            existing = await realpath(existing);
+            break;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+            const parent = path.dirname(existing);
+            if (parent === existing)
+                throw error;
+            existing = parent;
+        }
+    }
+    const resolvedRelative = path.relative(root, existing);
+    if (resolvedRelative === ".." || resolvedRelative.startsWith(`..${path.sep}`) || path.isAbsolute(resolvedRelative)) {
+        throw new Error("The path resolves outside the workspace.");
+    }
+    if (mustExist) {
+        await stat(target);
+        return realpath(target);
+    }
+    return target;
+}

package/dist/src/session.js

@@ -0,0 +1,188 @@
+import { randomBytes } from "node:crypto";
+import { mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync, } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { PROVIDER_IDS } from "./providers.js";
+import { DEFAULT_EFFORT, DEFAULT_MODE, EFFORT_LEVELS, MODE_OPTIONS, } from "./types.js";
+export const SESSION_SCHEMA = 1;
+const SESSION_ID = /^[a-z0-9]{4,64}$/i;
+export function createSessionId() {
+    return randomBytes(4).toString("hex");
+}
+export function isValidSessionId(id) {
+    return SESSION_ID.test(id);
+}
+export function sessionDirectory() {
+    if (process.platform === "win32") {
+        const base = process.env.LOCALAPPDATA?.trim()
+            || path.join(os.homedir(), "AppData", "Local");
+        return path.join(base, "ChelsCode", "sessions");
+    }
+    const base = process.env.XDG_STATE_HOME?.trim()
+        || path.join(os.homedir(), ".local", "state");
+    return path.join(base, "chelscode", "sessions");
+}
+export function resumeHint(id) {
+    return `Resume this session with:\n  chelscode --id ${id}`;
+}
+export function sameWorkspace(left, right) {
+    const a = path.resolve(left);
+    const b = path.resolve(right);
+    return process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
+}
+function sessionFile(id, directory) {
+    if (!isValidSessionId(id))
+        throw new Error(`Invalid session id: ${id}`);
+    return path.join(directory, `${id}.json`);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isProvider(value) {
+    return typeof value === "string" && PROVIDER_IDS.includes(value);
+}
+function isWorkTask(value) {
+    if (!isRecord(value))
+        return false;
+    return typeof value.title === "string"
+        && typeof value.instructions === "string"
+        && isProvider(value.provider);
+}
+function isMadeItem(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.kind === "file")
+        return typeof value.path === "string";
+    if (value.kind === "command")
+        return typeof value.command === "string";
+    return false;
+}
+function isTranscriptEntry(value) {
+    if (!isRecord(value) || typeof value.id !== "number")
+        return false;
+    switch (value.kind) {
+        case "header":
+            return typeof value.workspace === "string"
+                && typeof value.version === "string"
+                && (value.resumedFrom === undefined || typeof value.resumedFrom === "string");
+        case "user":
+        case "note":
+            return typeof value.text === "string";
+        case "plan":
+            return Array.isArray(value.tasks) && value.tasks.every(isWorkTask);
+        case "done":
+            return typeof value.text === "string"
+                && Array.isArray(value.made)
+                && value.made.every(isMadeItem);
+        case "error":
+            return typeof value.title === "string" && typeof value.message === "string";
+        default:
+            return false;
+    }
+}
+function isMode(value) {
+    return typeof value === "string" && MODE_OPTIONS.includes(value);
+}
+function isEffort(value) {
+    return typeof value === "string" && EFFORT_LEVELS.includes(value);
+}
+function nonNegative(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+}
+function parseSnapshot(value, expectedId) {
+    if (!isRecord(value))
+        throw new Error(`Session ${expectedId} is not valid.`);
+    if (value.schema !== SESSION_SCHEMA) {
+        throw new Error(`Session ${expectedId} uses an unsupported format.`);
+    }
+    if (value.id !== expectedId)
+        throw new Error(`Session ${expectedId} has a mismatched id.`);
+    if (typeof value.workspace !== "string" || !value.workspace.trim()) {
+        throw new Error(`Session ${expectedId} has no workspace.`);
+    }
+    if (typeof value.createdAt !== "string" || typeof value.updatedAt !== "string") {
+        throw new Error(`Session ${expectedId} has no timestamps.`);
+    }
+    if (!Array.isArray(value.entries) || !value.entries.every(isTranscriptEntry)) {
+        throw new Error(`Session ${expectedId} has an unreadable transcript.`);
+    }
+    return {
+        schema: SESSION_SCHEMA,
+        id: expectedId,
+        workspace: value.workspace,
+        createdAt: value.createdAt,
+        updatedAt: value.updatedAt,
+        mode: isMode(value.mode) ? value.mode : DEFAULT_MODE,
+        effort: isEffort(value.effort) ? value.effort : DEFAULT_EFFORT,
+        tokensUsed: nonNegative(value.tokensUsed),
+        creditsUsed: nonNegative(value.creditsUsed),
+        creditsAvailable: value.creditsAvailable === null || value.creditsAvailable === undefined
+            ? null
+            : nonNegative(value.creditsAvailable),
+        entries: value.entries,
+    };
+}
+export function saveSession(snapshot, directory = sessionDirectory()) {
+    const file = sessionFile(snapshot.id, directory);
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const temp = `${file}.${process.pid}.${randomBytes(3).toString("hex")}.tmp`;
+    writeFileSync(temp, `${JSON.stringify(snapshot, null, 2)}\n`, {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    renameSync(temp, file);
+}
+export function loadSession(id, directory = sessionDirectory()) {
+    const file = sessionFile(id, directory);
+    let text;
+    try {
+        text = readFileSync(file, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            throw new Error(`Session ${id} was not found.`);
+        }
+        throw new Error(`Could not read session ${id}: ${errorMessage(error)}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        throw new Error(`Session ${id} is not valid JSON.`);
+    }
+    return parseSnapshot(parsed, id);
+}
+export function findLatestSession(workspace, directory = sessionDirectory()) {
+    let files;
+    try {
+        files = readdirSync(directory);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+    let latest = null;
+    for (const file of files) {
+        if (!file.endsWith(".json"))
+            continue;
+        const id = file.slice(0, -".json".length);
+        if (!isValidSessionId(id))
+            continue;
+        try {
+            const snapshot = loadSession(id, directory);
+            if (workspace && !sameWorkspace(snapshot.workspace, workspace))
+                continue;
+            if (!latest || snapshot.updatedAt > latest.updatedAt)
+                latest = snapshot;
+        }
+        catch {
+            // Ignore malformed or unreadable session files.
+        }
+    }
+    return latest;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/src/terminal-title.js

@@ -0,0 +1,41 @@
+import { stdout } from "node:process";
+const OSC = "\u001b]";
+const BEL = "\u0007";
+/** Remove control characters so a saved title cannot inject terminal escapes. */
+export function cleanTitle(title) {
+    return title.replace(/[\u0000-\u001f\u007f]/g, "");
+}
+/** OSC 0 updates both the window title and the tab title. */
+export function titleSequence(title) {
+    return `${OSC}0;${cleanTitle(title)}${BEL}`;
+}
+/**
+ * Set the terminal title while ChelsCode runs and return a function that
+ * restores the title that was there before. Only touches interactive output.
+ */
+export function installTerminalTitle(title, hooks = {}) {
+    const output = hooks.output ?? stdout;
+    const platform = hooks.platform ?? process.platform;
+    const readTitle = hooks.readTitle ?? (() => process.title);
+    const writeTitle = hooks.writeTitle ?? ((next) => {
+        process.title = next;
+    });
+    if (!output.isTTY)
+        return () => { };
+    const previous = platform === "win32" ? readTitle() : "";
+    if (platform === "win32")
+        writeTitle(title);
+    output.write(titleSequence(title));
+    let restored = false;
+    return () => {
+        if (restored)
+            return;
+        restored = true;
+        if (platform === "win32") {
+            writeTitle(previous);
+            output.write(titleSequence(previous));
+            return;
+        }
+        output.write(`${OSC}0;${BEL}`);
+    };
+}

package/dist/src/types.js

@@ -0,0 +1,4 @@
+export const EFFORT_LEVELS = ["low", "medium", "high", "max", "ultra"];
+export const DEFAULT_EFFORT = "max";
+export const MODE_OPTIONS = ["build", "plan"];
+export const DEFAULT_MODE = "build";