@cogineai/dearharness 0.1.0

package/dist/model/providers/anthropic.js

@@ -0,0 +1,104 @@
+import { fetchWithTimeout, joinUrl, readJsonResponse, readSseDeltas } from '../http.js';
+function splitMessages(messages) {
+    const system = messages
+        .filter((message) => message.role === 'system')
+        .map((message) => message.content)
+        .join('\n\n');
+    const rest = messages
+        .filter((message) => message.role !== 'system')
+        .map((message) => ({ role: message.role, content: message.content }));
+    return { system, messages: rest };
+}
+function messagesUrl(baseUrl) {
+    return baseUrl.replace(/\/+$/, '').endsWith('/v1')
+        ? joinUrl(baseUrl, '/messages')
+        : joinUrl(baseUrl, '/v1/messages');
+}
+export function createAnthropicClient(config) {
+    return {
+        async complete(messages, options) {
+            const body = splitMessages(messages);
+            await options?.onEvent?.({
+                type: 'start',
+                provider: config.provider,
+                model: config.model,
+                streaming: config.streaming !== 'off'
+            });
+            try {
+                if (!config.apiKey) {
+                    throw new Error('ANTHROPIC_API_KEY is required');
+                }
+                if (config.streaming !== 'off') {
+                    const response = await fetchWithTimeout(messagesUrl(config.baseUrl), {
+                        method: 'POST',
+                        headers: {
+                            'content-type': 'application/json',
+                            'x-api-key': config.apiKey,
+                            'anthropic-version': '2023-06-01'
+                        },
+                        body: JSON.stringify({
+                            model: config.model,
+                            max_tokens: config.maxOutputTokens ?? 4096,
+                            ...(body.system ? { system: body.system } : {}),
+                            messages: body.messages,
+                            stream: true
+                        })
+                    });
+                    const content = (await readSseDeltas(response, (json) => {
+                        const event = json;
+                        return event.type === 'content_block_delta' && event.delta?.type === 'text_delta'
+                            ? (event.delta.text ?? null)
+                            : null;
+                    }, async (text) => options?.onEvent?.({ type: 'text-delta', text }))).trim();
+                    if (!content) {
+                        throw new Error('Anthropic stream missing text content');
+                    }
+                    await options?.onEvent?.({ type: 'end' });
+                    return {
+                        content,
+                        provider: config.provider,
+                        model: config.model
+                    };
+                }
+                const response = await fetchWithTimeout(messagesUrl(config.baseUrl), {
+                    method: 'POST',
+                    headers: {
+                        'content-type': 'application/json',
+                        'x-api-key': config.apiKey,
+                        'anthropic-version': '2023-06-01'
+                    },
+                    body: JSON.stringify({
+                        model: config.model,
+                        max_tokens: config.maxOutputTokens ?? 4096,
+                        ...(body.system ? { system: body.system } : {}),
+                        messages: body.messages,
+                        stream: false
+                    })
+                });
+                const json = await readJsonResponse(response, 'Anthropic');
+                if (!Array.isArray(json.content)) {
+                    throw new Error(`Anthropic response missing or invalid content array: ${JSON.stringify(json)}`);
+                }
+                const content = json.content
+                    .find((block) => block.type === 'text' && typeof block.text === 'string')
+                    ?.text?.trim();
+                if (!content) {
+                    throw new Error(`Anthropic response missing text content: ${JSON.stringify(json)}`);
+                }
+                await options?.onEvent?.({ type: 'end' });
+                return {
+                    content,
+                    provider: config.provider,
+                    model: config.model
+                };
+            }
+            catch (error) {
+                await options?.onEvent?.({
+                    type: 'error',
+                    message: error instanceof Error ? error.message : String(error)
+                });
+                throw error;
+            }
+        }
+    };
+}

package/dist/model/providers/ollama-discovery.js

@@ -0,0 +1,32 @@
+import { OLLAMA_DEFAULT_BASE_URL, OLLAMA_DISCOVERY_TIMEOUT_MS } from '../../config.js';
+import { fetchWithTimeout, joinUrl, readJsonResponse } from '../http.js';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function normalizeOllamaModel(value) {
+    if (!isRecord(value) || typeof value.name !== 'string' || value.name.trim() === '') {
+        return null;
+    }
+    return {
+        name: value.name,
+        ...(typeof value.modified_at === 'string' ? { modified_at: value.modified_at } : {}),
+        ...(typeof value.size === 'number' ? { size: value.size } : {}),
+        ...(typeof value.digest === 'string' ? { digest: value.digest } : {})
+    };
+}
+export function selectDefaultOllamaModel(models) {
+    return models.find((model) => model.name.toLowerCase().includes('qwen'))?.name ?? models[0]?.name ?? null;
+}
+export async function discoverOllamaModels(baseUrl = OLLAMA_DEFAULT_BASE_URL) {
+    const response = await fetchWithTimeout(joinUrl(baseUrl, '/api/tags'), {
+        method: 'GET'
+    }, OLLAMA_DISCOVERY_TIMEOUT_MS);
+    const json = await readJsonResponse(response, 'Ollama discovery');
+    if (!isRecord(json) || !Array.isArray(json.models)) {
+        throw new Error(`Ollama discovery response missing models array: ${JSON.stringify(json)}`);
+    }
+    return json.models.flatMap((model) => {
+        const normalized = normalizeOllamaModel(model);
+        return normalized ? [normalized] : [];
+    });
+}

package/dist/model/providers/ollama.js

@@ -0,0 +1,70 @@
+import { fetchWithTimeout, joinUrl, readJsonResponse, readNdjsonDeltas } from '../http.js';
+export function createOllamaClient(config) {
+    return {
+        async complete(messages, options) {
+            await options?.onEvent?.({
+                type: 'start',
+                provider: config.provider,
+                model: config.model,
+                streaming: config.streaming !== 'off'
+            });
+            try {
+                if (config.streaming !== 'off') {
+                    const response = await fetchWithTimeout(joinUrl(config.baseUrl, '/api/chat'), {
+                        method: 'POST',
+                        headers: {
+                            'content-type': 'application/json'
+                        },
+                        body: JSON.stringify({
+                            model: config.model,
+                            messages,
+                            stream: true
+                        })
+                    });
+                    const content = (await readNdjsonDeltas(response, (json) => {
+                        const event = json;
+                        return event.message?.content ?? null;
+                    }, async (text) => options?.onEvent?.({ type: 'text-delta', text }))).trim();
+                    if (!content) {
+                        throw new Error('Ollama stream missing message/content');
+                    }
+                    await options?.onEvent?.({ type: 'end' });
+                    return {
+                        content,
+                        provider: config.provider,
+                        model: config.model
+                    };
+                }
+                const response = await fetchWithTimeout(joinUrl(config.baseUrl, '/api/chat'), {
+                    method: 'POST',
+                    headers: {
+                        'content-type': 'application/json'
+                    },
+                    body: JSON.stringify({
+                        model: config.model,
+                        messages,
+                        stream: false
+                    })
+                });
+                const json = await readJsonResponse(response, 'Ollama');
+                const content = json.message?.content?.trim();
+                if (!content) {
+                    throw new Error(`Ollama response missing message/content: ${JSON.stringify(json)}`);
+                }
+                await options?.onEvent?.({ type: 'end' });
+                return {
+                    content,
+                    provider: config.provider,
+                    model: config.model
+                };
+            }
+            catch (error) {
+                await options?.onEvent?.({
+                    type: 'error',
+                    message: error instanceof Error ? error.message : String(error)
+                });
+                throw error;
+            }
+        }
+    };
+}

package/dist/model/providers/openai-compatible.js

@@ -0,0 +1,118 @@
+import { fetchWithTimeout, joinUrl, readJsonResponse, readSseDeltas } from '../http.js';
+const AUTO_STREAM_FALLBACK_STATUSES = new Set([400, 404, 405, 415, 422]);
+function headers(config) {
+    return {
+        'content-type': 'application/json',
+        ...(config.apiKey ? { authorization: `Bearer ${config.apiKey}` } : {})
+    };
+}
+function shouldFallbackFromStreamingResponse(response) {
+    return AUTO_STREAM_FALLBACK_STATUSES.has(response.status);
+}
+async function streamHttpError(response) {
+    const body = (await response.text()).trim();
+    const detail = body ? `: ${body}` : '';
+    return new Error(`Model stream error ${response.status}${detail}. If this endpoint does not support streaming, retry with --streaming off.`);
+}
+async function emitErrorEvent(options, error) {
+    try {
+        await options?.onEvent?.({
+            type: 'error',
+            message: error instanceof Error ? error.message : String(error)
+        });
+    }
+    catch {
+        // Preserve the original provider failure even if the event sink fails.
+    }
+}
+async function emitStartEvent(config, options, streaming) {
+    await options?.onEvent?.({
+        type: 'start',
+        provider: config.provider,
+        model: config.model,
+        streaming
+    });
+}
+function parseContent(json, provider) {
+    if (!Array.isArray(json.choices) || json.choices.length === 0) {
+        throw new Error(`${provider} response missing choices/content: ${JSON.stringify(json)}`);
+    }
+    const content = json.choices[0]?.message?.content?.trim();
+    if (!content) {
+        throw new Error(`${provider} response missing choices/content: ${JSON.stringify(json)}`);
+    }
+    return content;
+}
+async function completeWithoutStreaming(config, messages, options) {
+    await emitStartEvent(config, options, false);
+    const response = await fetchWithTimeout(joinUrl(config.baseUrl, '/chat/completions'), {
+        method: 'POST',
+        headers: headers(config),
+        body: JSON.stringify({
+            model: config.model,
+            messages,
+            stream: false
+        })
+    });
+    const json = await readJsonResponse(response, config.provider);
+    const content = parseContent(json, config.provider);
+    await options?.onEvent?.({ type: 'end' });
+    return {
+        content,
+        provider: config.provider,
+        model: config.model
+    };
+}
+async function completeWithStreaming(config, messages, options) {
+    if (config.streaming === 'on') {
+        await emitStartEvent(config, options, true);
+    }
+    const response = await fetchWithTimeout(joinUrl(config.baseUrl, '/chat/completions'), {
+        method: 'POST',
+        headers: headers(config),
+        body: JSON.stringify({
+            model: config.model,
+            messages,
+            stream: true
+        })
+    });
+    if (!response.ok) {
+        if (config.streaming === 'auto' && shouldFallbackFromStreamingResponse(response)) {
+            await response.body?.cancel();
+            return completeWithoutStreaming(config, messages, options);
+        }
+        throw await streamHttpError(response);
+    }
+    if (config.streaming === 'auto') {
+        await emitStartEvent(config, options, true);
+    }
+    const content = (await readSseDeltas(response, (json) => {
+        const choice = json.choices?.[0];
+        return choice?.delta?.content ?? null;
+    }, async (text) => options?.onEvent?.({ type: 'text-delta', text }))).trim();
+    if (!content) {
+        throw new Error(`${config.provider} stream missing text content`);
+    }
+    await options?.onEvent?.({ type: 'end' });
+    return {
+        content,
+        provider: config.provider,
+        model: config.model
+    };
+}
+export function createOpenAICompatibleClient(config) {
+    return {
+        async complete(messages, options) {
+            try {
+                if (config.streaming !== 'off') {
+                    return await completeWithStreaming(config, messages, options);
+                }
+                return await completeWithoutStreaming(config, messages, options);
+            }
+            catch (error) {
+                await emitErrorEvent(options, error);
+                throw error;
+            }
+        }
+    };
+}

package/dist/model/providers/openai.js

@@ -0,0 +1,4 @@
+import { createOpenAICompatibleClient } from './openai-compatible.js';
+export function createOpenAIClient(config) {
+    return createOpenAICompatibleClient(config);
+}

package/dist/model/providers/openrouter.js

@@ -0,0 +1,79 @@
+import { fetchWithTimeout, joinUrl, readJsonResponse, readSseDeltas } from '../http.js';
+export function createOpenRouterClient(config) {
+    return {
+        async complete(messages, options) {
+            if (!config.apiKey) {
+                throw new Error('OPENROUTER_API_KEY is required');
+            }
+            await options?.onEvent?.({
+                type: 'start',
+                provider: config.provider,
+                model: config.model,
+                streaming: config.streaming !== 'off'
+            });
+            try {
+                if (config.streaming !== 'off') {
+                    const response = await fetchWithTimeout(joinUrl(config.baseUrl, '/chat/completions'), {
+                        method: 'POST',
+                        headers: {
+                            'content-type': 'application/json',
+                            authorization: `Bearer ${config.apiKey}`,
+                            'HTTP-Referer': 'https://local.cliq',
+                            'X-Title': 'cliq-agent'
+                        },
+                        body: JSON.stringify({
+                            model: config.model,
+                            messages,
+                            stream: true
+                        })
+                    });
+                    const content = (await readSseDeltas(response, (json) => {
+                        const choice = json.choices?.[0];
+                        return choice?.delta?.content ?? null;
+                    }, async (text) => options?.onEvent?.({ type: 'text-delta', text }))).trim();
+                    if (!content) {
+                        throw new Error('OpenRouter stream missing text content');
+                    }
+                    await options?.onEvent?.({ type: 'end' });
+                    return {
+                        content,
+                        provider: config.provider,
+                        model: config.model
+                    };
+                }
+                const response = await fetchWithTimeout(joinUrl(config.baseUrl, '/chat/completions'), {
+                    method: 'POST',
+                    headers: {
+                        'content-type': 'application/json',
+                        authorization: `Bearer ${config.apiKey}`,
+                        'HTTP-Referer': 'https://local.cliq',
+                        'X-Title': 'cliq-agent'
+                    },
+                    body: JSON.stringify({
+                        model: config.model,
+                        messages,
+                        stream: false
+                    })
+                });
+                const json = await readJsonResponse(response, 'OpenRouter');
+                const content = json.choices[0]?.message?.content?.trim();
+                if (!content) {
+                    throw new Error(`OpenRouter response missing choices/content: ${JSON.stringify(json)}`);
+                }
+                await options?.onEvent?.({ type: 'end' });
+                return {
+                    content,
+                    provider: config.provider,
+                    model: config.model
+                };
+            }
+            catch (error) {
+                await options?.onEvent?.({
+                    type: 'error',
+                    message: error instanceof Error ? error.message : String(error)
+                });
+                throw error;
+            }
+        }
+    };
+}

package/dist/model/registry.js

@@ -0,0 +1,108 @@
+import { DEFAULT_MODEL_BASE_URL, DEFAULT_MODEL_PROVIDER, MODEL, OLLAMA_DEFAULT_BASE_URL } from '../config.js';
+const TEXT_TO_TEXT = {
+    input: ['text'],
+    output: ['text'],
+    streaming: true,
+    reasoning: false,
+    toolCalling: false
+};
+const TEXT_TO_TEXT_REASONING = {
+    ...TEXT_TO_TEXT,
+    reasoning: true
+};
+export const DEFAULT_MODEL_CONFIG = {
+    provider: DEFAULT_MODEL_PROVIDER,
+    model: MODEL,
+    baseUrl: DEFAULT_MODEL_BASE_URL,
+    streaming: 'auto'
+};
+const PROVIDERS = {
+    openrouter: {
+        name: 'openrouter',
+        displayName: 'OpenRouter',
+        defaultBaseUrl: 'https://openrouter.ai/api/v1',
+        apiKeyEnv: 'OPENROUTER_API_KEY',
+        requiresApiKey: true,
+        getDefaultModel: () => MODEL,
+        getKnownModels: () => [
+            {
+                provider: 'openrouter',
+                model: MODEL,
+                displayName: 'Claude Sonnet 4.6 via OpenRouter',
+                capabilities: TEXT_TO_TEXT_REASONING
+            }
+        ]
+    },
+    anthropic: {
+        name: 'anthropic',
+        displayName: 'Anthropic',
+        defaultBaseUrl: 'https://api.anthropic.com',
+        apiKeyEnv: 'ANTHROPIC_API_KEY',
+        requiresApiKey: true,
+        getDefaultModel: () => 'claude-sonnet-4-20250514',
+        getKnownModels: () => [
+            {
+                provider: 'anthropic',
+                model: 'claude-sonnet-4-20250514',
+                displayName: 'Claude Sonnet 4',
+                capabilities: TEXT_TO_TEXT_REASONING
+            }
+        ]
+    },
+    openai: {
+        name: 'openai',
+        displayName: 'OpenAI',
+        defaultBaseUrl: 'https://api.openai.com/v1',
+        apiKeyEnv: 'OPENAI_API_KEY',
+        requiresApiKey: true,
+        getDefaultModel: () => 'gpt-5.2',
+        getKnownModels: () => [
+            {
+                provider: 'openai',
+                model: 'gpt-5.2',
+                displayName: 'GPT-5.2',
+                capabilities: TEXT_TO_TEXT_REASONING
+            }
+        ]
+    },
+    'openai-compatible': {
+        name: 'openai-compatible',
+        displayName: 'OpenAI-compatible',
+        defaultBaseUrl: '',
+        apiKeyEnv: 'OPENAI_COMPATIBLE_API_KEY',
+        requiresApiKey: false,
+        getDefaultModel: () => null,
+        getKnownModels: () => []
+    },
+    ollama: {
+        name: 'ollama',
+        displayName: 'Ollama',
+        defaultBaseUrl: OLLAMA_DEFAULT_BASE_URL,
+        requiresApiKey: false,
+        getDefaultModel: () => null,
+        getKnownModels: () => []
+    }
+};
+const factories = new Map();
+export function registerModelClientFactory(provider, factory) {
+    factories.set(provider, factory);
+}
+export function isProviderName(value) {
+    return Object.hasOwn(PROVIDERS, value);
+}
+export function getModelProvider(provider) {
+    const definition = PROVIDERS[provider];
+    return {
+        ...definition,
+        createClient(config) {
+            const factory = factories.get(provider);
+            if (!factory) {
+                throw new Error(`Model provider ${provider} is not registered`);
+            }
+            return factory(config);
+        }
+    };
+}
+export function listModelProviders() {
+    return Object.keys(PROVIDERS).map((provider) => getModelProvider(provider));
+}

package/dist/model/types.js

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

package/dist/policy/engine.js

@@ -0,0 +1,30 @@
+export function createPolicyEngine({ mode, confirm }) {
+    async function authorize(definition) {
+        if (mode === 'auto') {
+            return { allowed: true };
+        }
+        if (mode === 'read-only' && definition.access !== 'read') {
+            return {
+                allowed: false,
+                reason: `policy mode read-only blocks ${definition.access} tools`
+            };
+        }
+        // "confirm-bash" is the current user-facing label, but policy should apply
+        // to any exec-capable tool rather than only the built-in bash tool name.
+        const requiresConfirmation = mode === 'confirm-all' ||
+            (mode === 'confirm-write' && definition.access === 'write') ||
+            (mode === 'confirm-bash' && definition.access === 'exec');
+        if (!requiresConfirmation) {
+            return { allowed: true };
+        }
+        if (!confirm) {
+            return {
+                allowed: false,
+                reason: 'confirmation required but no confirmer is available'
+            };
+        }
+        const approved = await confirm(`Allow ${definition.name} (${definition.access})?`);
+        return approved ? { allowed: true } : { allowed: false, reason: 'user declined confirmation' };
+    }
+    return { mode, authorize };
+}

package/dist/policy/types.js

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

package/dist/prompt/system.js

@@ -0,0 +1,30 @@
+export const BASE_SYSTEM_PROMPT = `You are a tiny coding agent inside a local CLI runtime.
+Return exactly one JSON object and nothing else.
+
+Allowed response shapes:
+- {"bash":"<shell command>"}
+- {"edit":{"path":"<workspace-relative-path>","old_text":"<exact old text>","new_text":"<replacement text>"}}
+- {"read":{"path":"<workspace-relative-path>","start_line":1,"end_line":120}}
+- {"ls":{"path":"<workspace-relative-path>"}}
+- {"find":{"path":"<workspace-relative-path>","name":"<substring>"}}
+- {"grep":{"path":"<workspace-relative-path>","pattern":"<substring>"}}
+- {"message":"<final user-facing response>"}
+
+Rules:
+- The workspace root is the current working directory. Commands run there.
+- Prefer {"edit":...} for precise single-file text replacements when it is simpler and safer than shell editing.
+- Prefer {"read":...}, {"ls":...}, {"find":...}, and {"grep":...} for repo inspection before using {"bash":...}.
+- Use {"bash":...} for tests, formatting, file creation, multi-step shell work, or anything not covered by the structured tools.
+- Paths should normally be relative to the workspace root.
+- old_text must match exactly once. If it does not, inspect first and recover.
+- Keep going until the task is complete or you are blocked.
+- When finished, respond with {"message":"..."} summarizing what changed and any verification.
+- Do not wrap JSON in markdown fences.
+- Do not emit explanatory text before or after the JSON.
+
+Examples:
+- {"ls":{"path":"src"}}
+- {"read":{"path":"src/runtime/runner.ts","start_line":1,"end_line":80}}
+- {"find":{"path":"src","name":"runner"}}
+- {"grep":{"path":"src","pattern":"runTurn"}}`;
+export const SYSTEM_PROMPT = BASE_SYSTEM_PROMPT;

package/dist/protocol/actions.js

@@ -0,0 +1,88 @@
+const TOP_LEVEL_ACTIONS = ['bash', 'edit', 'read', 'ls', 'find', 'grep', 'message'];
+export function parseModelAction(content) {
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid JSON from model: ${message}\n${content}`);
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`Model returned invalid action object:\n${content}`);
+    }
+    const record = parsed;
+    const keys = Object.keys(record);
+    if (keys.length !== 1) {
+        throw new Error(`Model action must contain exactly one top-level key:\n${content}`);
+    }
+    const topLevelKey = keys[0];
+    if (typeof record.bash === 'string') {
+        return { bash: record.bash };
+    }
+    if (typeof record.message === 'string') {
+        return { message: record.message };
+    }
+    if (record.edit && typeof record.edit === 'object' && !Array.isArray(record.edit)) {
+        const edit = record.edit;
+        if (typeof edit.path === 'string' && typeof edit.old_text === 'string' && typeof edit.new_text === 'string') {
+            return {
+                edit: {
+                    path: edit.path,
+                    old_text: edit.old_text,
+                    new_text: edit.new_text
+                }
+            };
+        }
+    }
+    if (record.read && typeof record.read === 'object' && !Array.isArray(record.read)) {
+        const read = record.read;
+        if (typeof read.path === 'string' &&
+            (read.start_line === undefined || typeof read.start_line === 'number') &&
+            (read.end_line === undefined || typeof read.end_line === 'number')) {
+            return {
+                read: {
+                    path: read.path,
+                    start_line: read.start_line,
+                    end_line: read.end_line
+                }
+            };
+        }
+    }
+    if (record.ls && typeof record.ls === 'object' && !Array.isArray(record.ls)) {
+        const ls = record.ls;
+        if (ls.path === undefined || typeof ls.path === 'string') {
+            return {
+                ls: {
+                    path: ls.path
+                }
+            };
+        }
+    }
+    if (record.find && typeof record.find === 'object' && !Array.isArray(record.find)) {
+        const find = record.find;
+        if ((find.path === undefined || typeof find.path === 'string') && typeof find.name === 'string') {
+            return {
+                find: {
+                    path: find.path,
+                    name: find.name
+                }
+            };
+        }
+    }
+    if (record.grep && typeof record.grep === 'object' && !Array.isArray(record.grep)) {
+        const grep = record.grep;
+        if ((grep.path === undefined || typeof grep.path === 'string') && typeof grep.pattern === 'string') {
+            return {
+                grep: {
+                    path: grep.path,
+                    pattern: grep.pattern
+                }
+            };
+        }
+    }
+    if (!TOP_LEVEL_ACTIONS.includes(topLevelKey)) {
+        throw new Error(`Unknown top-level key in model action: ${topLevelKey}\n${content}`);
+    }
+    throw new Error(`Model returned unsupported action:\n${content}`);
+}