tokenmaw 0.3.0

package/dist/config.js

@@ -0,0 +1,155 @@
+/**
+ * config.ts — .agentrc config file support.
+ *
+ * Merges .agentrc from the current project and user home. User values win,
+ * and interactive changes are persisted to the user-scoped file.
+ *
+ * Format: JSON with optional fields:
+ *  {
+ *    "baseUrl": "http://localhost:11434",
+ *    "model": "gemma4:31b-cloud",
+ *    "backend": "openai",
+ *    "apiKey": "sk-...",
+ *    "artifactsDir": ".agent-workspace/artifacts",
+ *    "models": {
+ *      "fast": {
+ *        "model": "provider-model-id",
+ *        "requestOptions": {
+ *          "extraBody": {
+ *            "provider_option": true
+ *          }
+ *        }
+ *      }
+ *    }
+ *  }
+ */
+import { readFile, writeFile, mkdir, rename, rm } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+const CONFIG_FILES = ['.agentrc', '.agentrc.json'];
+const configWrites = new Map();
+async function replaceConfigFile(tempPath, path) {
+    let lastError;
+    for (let attempt = 0; attempt < 6; attempt += 1) {
+        try {
+            await rename(tempPath, path);
+            return;
+        }
+        catch (error) {
+            lastError = error;
+            const code = error.code;
+            if (code !== 'EPERM' && code !== 'EEXIST' && code !== 'EACCES')
+                throw error;
+            await rm(path, { force: true }).catch(() => undefined);
+            await new Promise((resolveP) => setTimeout(resolveP, (attempt + 1) * 4));
+        }
+    }
+    throw lastError;
+}
+function configHome() {
+    return process.env.CODER_CONFIG_HOME?.trim() || homedir();
+}
+function mergeConfig(project, user) {
+    return {
+        ...project,
+        ...user,
+        models: Object.keys(project.models ?? {}).length || Object.keys(user.models ?? {}).length
+            ? { ...(project.models ?? {}), ...(user.models ?? {}) }
+            : undefined,
+    };
+}
+function parseConfig(raw) {
+    const parsed = JSON.parse(raw);
+    // roleModels belonged to the retired hard-coded Reception/Brain/Worker
+    // architecture. Agent-specific model selection now lives in Agent Specs.
+    delete parsed.roleModels;
+    if (parsed.backend && !['ollama', 'openai', 'anthropic'].includes(parsed.backend)) {
+        throw new Error(`Invalid backend "${parsed.backend}" in config. Use "openai", "anthropic", or "ollama".`);
+    }
+    if (parsed.artifactsDir !== undefined && typeof parsed.artifactsDir !== 'string') {
+        throw new Error('Invalid artifactsDir in config. Use a string path.');
+    }
+    if (parsed.models) {
+        for (const [name, modelConfig] of Object.entries(parsed.models)) {
+            if (modelConfig.wireApi && !['chat', 'responses'].includes(modelConfig.wireApi)) {
+                throw new Error(`Invalid wireApi for model alias "${name}". Use "chat" or "responses".`);
+            }
+            if (!modelConfig?.model || typeof modelConfig.model !== 'string') {
+                throw new Error(`Invalid model alias "${name}" in config. Each model alias needs a string "model".`);
+            }
+            if (modelConfig.backend && !['ollama', 'openai', 'anthropic'].includes(modelConfig.backend)) {
+                throw new Error(`Invalid backend "${modelConfig.backend}" for model alias "${name}". Use "openai", "anthropic", or "ollama".`);
+            }
+        }
+    }
+    return parsed;
+}
+async function tryReadConfigWithPath(dir) {
+    for (const name of CONFIG_FILES) {
+        const path = join(dir, name);
+        try {
+            const raw = await readFile(path, 'utf8');
+            return { config: parseConfig(raw), path };
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                const message = error instanceof Error ? error.message : String(error);
+                throw new Error(`Could not load config ${path}: ${message}`);
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Async config loader — call once at startup.
+ * CWD config takes precedence over home directory config.
+ */
+export async function loadConfig() {
+    const loaded = await loadConfigWithPath();
+    return loaded.config;
+}
+export async function loadConfigWithPath() {
+    const userDir = configHome();
+    const sameDir = resolve(process.cwd()).toLowerCase() === resolve(userDir).toLowerCase();
+    const projectConfig = sameDir ? null : await tryReadConfigWithPath(process.cwd());
+    const userConfig = await tryReadConfigWithPath(userDir);
+    return {
+        config: mergeConfig(projectConfig?.config ?? {}, userConfig?.config ?? {}),
+        path: userConfig?.path ?? join(userDir, '.agentrc'),
+    };
+}
+export async function saveSelectedModel(model) {
+    const loaded = await loadConfigWithPath();
+    const nextConfig = {
+        ...loaded.config,
+        model,
+    };
+    return saveConfig(nextConfig, loaded.path);
+}
+export async function saveConfig(config, existingPath) {
+    const path = existingPath ?? join(configHome(), '.agentrc');
+    const payload = `${JSON.stringify(config, null, 2)}\n`;
+    const previous = configWrites.get(path) ?? Promise.resolve();
+    const next = previous.catch(() => undefined).then(async () => {
+        await mkdir(dirname(path), { recursive: true });
+        const tempPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+        try {
+            await writeFile(tempPath, payload, 'utf8');
+            await replaceConfigFile(tempPath, path);
+        }
+        catch (error) {
+            await rm(tempPath, { force: true }).catch(() => undefined);
+            throw error;
+        }
+    });
+    configWrites.set(path, next);
+    try {
+        await next;
+    }
+    finally {
+        if (configWrites.get(path) === next)
+            configWrites.delete(path);
+    }
+    return path;
+}

package/dist/diff.js

@@ -0,0 +1,45 @@
+export function unifiedDiff(filePath, before, after, maxChangedLines = 160) {
+    if (before === after)
+        return '';
+    const beforeLines = before.split('\n');
+    const afterLines = after.split('\n');
+    let start = 0;
+    while (start < beforeLines.length && start < afterLines.length && beforeLines[start] === afterLines[start]) {
+        start += 1;
+    }
+    let beforeEnd = beforeLines.length - 1;
+    let afterEnd = afterLines.length - 1;
+    while (beforeEnd >= start && afterEnd >= start && beforeLines[beforeEnd] === afterLines[afterEnd]) {
+        beforeEnd -= 1;
+        afterEnd -= 1;
+    }
+    const contextBeforeStart = Math.max(0, start - 3);
+    const contextAfterEnd = Math.min(afterLines.length - 1, afterEnd + 3);
+    const lines = [
+        '```diff',
+        `--- ${filePath}`,
+        `+++ ${filePath}`,
+        `@@ -${contextBeforeStart + 1} +${contextBeforeStart + 1} @@`,
+    ];
+    for (const line of beforeLines.slice(contextBeforeStart, start)) {
+        lines.push(` ${line}`);
+    }
+    const removed = beforeLines.slice(start, beforeEnd + 1);
+    const added = afterLines.slice(start, afterEnd + 1);
+    const changed = [
+        ...removed.map((line) => `-${line}`),
+        ...added.map((line) => `+${line}`),
+    ];
+    if (changed.length > maxChangedLines) {
+        lines.push(...changed.slice(0, maxChangedLines));
+        lines.push(` ... ${changed.length - maxChangedLines} more changed lines`);
+    }
+    else {
+        lines.push(...changed);
+    }
+    for (const line of afterLines.slice(afterEnd + 1, contextAfterEnd + 1)) {
+        lines.push(` ${line}`);
+    }
+    lines.push('```');
+    return lines.join('\n');
+}

package/dist/domain/agent.js

@@ -0,0 +1 @@
+export {};

package/dist/fetch.js

@@ -0,0 +1,110 @@
+/**
+ * fetch.ts — Resilient HTTP client with retry, timeout, and reconnection.
+ *
+ * Wraps the native `fetch` with:
+ *  • Configurable retry count and backoff
+ *  • Request timeout
+ *  • Connection-refused detection for local LLM servers
+ */
+export class FetchError extends Error {
+    status;
+    retriable;
+    constructor(message, status, retriable) {
+        super(message);
+        this.status = status;
+        this.retriable = retriable;
+        this.name = 'FetchError';
+    }
+}
+function isRetriable(status, error) {
+    if (status === null)
+        return true; // network error
+    if (status === 429)
+        return true; // rate limited
+    if (status >= 500)
+        return true; // server error
+    return false;
+}
+function getErrorMessage(status, cause) {
+    if (cause instanceof Error && 'code' in cause) {
+        const code = cause.code;
+        if (code === 'ECONNREFUSED') {
+            return 'Connection refused — is the configured LLM server running? (LLM_BASE_URL / OLLAMA_BASE_URL)';
+        }
+        if (code === 'ENOTFOUND') {
+            return 'DNS lookup failed — check LLM_BASE_URL';
+        }
+        if (code === 'ECONNRESET') {
+            return 'Connection reset by server';
+        }
+    }
+    if (status !== null)
+        return `HTTP ${status}`;
+    return String(cause);
+}
+const MAX_ERROR_BODY_LENGTH = 512;
+async function errorResponseBody(response) {
+    try {
+        const text = (await response.text()).trim();
+        if (!text)
+            return '';
+        return text.length > MAX_ERROR_BODY_LENGTH ? `${text.slice(0, MAX_ERROR_BODY_LENGTH)}…` : text;
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Resilient fetch with retry, timeout, and backoff.
+ */
+export async function resilientFetch(url, opts = {}) {
+    const { retries = 3, retryDelay = 1000, timeout = 120_000, ...fetchOpts } = opts;
+    let lastError = null;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeout);
+        // Merge user-provided signal with our timeout signal
+        if (fetchOpts.signal) {
+            fetchOpts.signal.addEventListener('abort', () => controller.abort());
+        }
+        try {
+            const response = await fetch(url, {
+                ...fetchOpts,
+                signal: controller.signal,
+            });
+            clearTimeout(timer);
+            if (!response.ok) {
+                const retriable = isRetriable(response.status, null);
+                if (retriable && attempt < retries) {
+                    const delay = retryDelay * Math.pow(2, attempt);
+                    await sleep(delay);
+                    continue;
+                }
+                const body = await errorResponseBody(response);
+                throw new FetchError(getErrorMessage(response.status, null) + (body ? `: ${body}` : ''), response.status, false);
+            }
+            return response;
+        }
+        catch (err) {
+            clearTimeout(timer);
+            if (err instanceof FetchError)
+                throw err;
+            // Caller cancellation is intentional, not a transient network failure.
+            // Never retry an aborted model request.
+            if (fetchOpts.signal?.aborted) {
+                throw new FetchError('Request aborted', null, false);
+            }
+            const retriable = isRetriable(null, err);
+            lastError = new FetchError(getErrorMessage(null, err), null, retriable);
+            if (!retriable || attempt >= retries) {
+                throw lastError;
+            }
+            const delay = retryDelay * Math.pow(2, attempt);
+            await sleep(delay);
+        }
+    }
+    throw lastError ?? new FetchError('Unknown fetch error', null, false);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/infra/file-snapshot.js

@@ -0,0 +1,54 @@
+import { mkdir, readFile, stat, writeFile } from 'node:fs/promises';
+import { randomBytes } from 'node:crypto';
+import { join, relative, resolve } from 'node:path';
+import { tmpdir } from 'node:os';
+function sanitizeComponent(name) {
+    return name.replace(/[^a-zA-Z0-9._-]+/g, '_').replace(/^_+|_+$/g, '') || 'root';
+}
+function externalKey(abs) {
+    return sanitizeComponent(abs.replace(/^([a-zA-Z]:)?[/\\]+/, ''));
+}
+function snapshotDirFor(abs, workspaceRoot) {
+    if (workspaceRoot)
+        return resolve(workspaceRoot, '.coder', 'snapshots');
+    return join(tmpdir(), 'coder-snapshots', externalKey(abs));
+}
+function snapshotNameFor(abs, workspaceRoot) {
+    const relKey = workspaceRoot
+        ? sanitizeComponent(relative(workspaceRoot, abs).replace(/\\/g, '/'))
+        : externalKey(abs);
+    const stamp = new Date().toISOString().replace(/[^a-zA-Z0-9]+/g, '');
+    return `${relKey}~${stamp}~${randomBytes(4).toString('hex')}.bak`;
+}
+function errorCode(error) {
+    const code = error.code;
+    return code ?? 'error';
+}
+export async function snapshotBeforeWrite(filePath, workspaceRoot) {
+    try {
+        const abs = resolve(filePath);
+        const info = await stat(abs).catch(() => undefined);
+        if (!info || !info.isFile())
+            return { path: null };
+        let content;
+        try {
+            content = await readFile(abs, 'utf8');
+        }
+        catch (error) {
+            return { path: null, reason: `could not read existing file (${errorCode(error)})` };
+        }
+        const dir = snapshotDirFor(abs, workspaceRoot);
+        const snapshotPath = join(dir, snapshotNameFor(abs, workspaceRoot));
+        try {
+            await mkdir(dir, { recursive: true });
+            await writeFile(snapshotPath, content, 'utf8');
+        }
+        catch (error) {
+            return { path: null, reason: `could not write snapshot (${errorCode(error)})` };
+        }
+        return { path: snapshotPath };
+    }
+    catch (error) {
+        return { path: null, reason: `snapshot failed (${String(error?.message ?? error)})` };
+    }
+}