codeshark-cli 0.1.1

package/dist/project.js

@@ -0,0 +1,56 @@
+import { statSync } from "node:fs";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+export class ProjectFolderError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ProjectFolderError";
+    }
+}
+/** Confirm that the selected working directory is a real folder. */
+export function requireProjectFolder(folder = process.cwd()) {
+    const resolved = resolve(folder);
+    const stat = statSync(resolved, { throwIfNoEntry: false });
+    if (!stat) {
+        throw new ProjectFolderError(`Project folder does not exist: ${resolved}`);
+    }
+    if (!stat.isDirectory()) {
+        throw new ProjectFolderError(`CodeShark needs a folder, not a file: ${resolved}`);
+    }
+    return resolved;
+}
+/** Resolve a path while keeping the agent inside its selected project folder. */
+export function resolveProjectPath(input, cwd) {
+    const root = resolve(cwd);
+    const target = isAbsolute(input) ? resolve(input) : resolve(root, input);
+    const rel = relative(root, target);
+    if (rel === "" || (rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel)))
+        return target;
+    throw new ProjectFolderError(`Path escapes the project folder: ${input}`);
+}
+/** Change into an explicitly selected project folder before starting CodeShark. */
+export function openProjectFolder(folder) {
+    const resolved = requireProjectFolder(folder);
+    process.chdir(resolved);
+    return resolved;
+}
+/** Parse --folder / --cwd without treating normal prompt text as a path. */
+export function extractFolderArg(args) {
+    const remaining = [];
+    let folder;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--folder" || arg === "--cwd") {
+            const next = args[++i];
+            // No path given: default to the current folder instead of failing,
+            // so `codeshark --folder` just works from inside the project.
+            folder = next ? (isAbsolute(next) ? next : resolve(process.cwd(), next)) : process.cwd();
+        }
+        else if (arg.startsWith("--folder=") || arg.startsWith("--cwd=")) {
+            folder = arg.slice(arg.indexOf("=") + 1);
+        }
+        else {
+            remaining.push(arg);
+        }
+    }
+    return { args: remaining, folder };
+}

package/dist/provider/gateway.js

@@ -0,0 +1,19 @@
+import { createOpenAICompatClient } from "./openaiCompat.js";
+import { DEFAULT_GATEWAY_URL, effectiveModel } from "../config.js";
+/**
+ * The community gateway gives CodeShark its "works out of the box" default:
+ * end users need no API key. The gateway (see worker/) holds keys server-side
+ * and enforces `:free` lanes only. Fork the repo and deploy your own gateway,
+ * then point CODESHARK_CONFIG / gatewayUrl at it.
+ */
+export function createGatewayClient(cfg) {
+    const base = cfg.gatewayUrl ?? process.env.CODESHARK_GATEWAY_URL ?? DEFAULT_GATEWAY_URL;
+    const model = effectiveModel(cfg, "gateway");
+    return createOpenAICompatClient({
+        provider: "gateway",
+        baseUrl: base,
+        model,
+        apiKey: cfg.gatewayKey ?? process.env.CODESHARK_GATEWAY_KEY,
+        isFree: true,
+    });
+}

package/dist/provider/gemini.js

@@ -0,0 +1,184 @@
+import { ProviderError, classifyStatus, errorMessage, } from "./types.js";
+import { effectiveModel } from "../config.js";
+export const GEMINI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+function toGeminiContents(messages) {
+    const systemParts = [];
+    const contents = [];
+    for (const m of messages) {
+        switch (m.role) {
+            case "system":
+                systemParts.push(m.content);
+                break;
+            case "user":
+                contents.push({ role: "user", parts: [{ text: m.content }] });
+                break;
+            case "assistant": {
+                const parts = [];
+                if (m.content)
+                    parts.push({ text: m.content });
+                for (const tc of m.toolCalls ?? []) {
+                    parts.push({ functionCall: { name: tc.name, args: tc.args } });
+                }
+                contents.push({ role: "model", parts });
+                break;
+            }
+            case "tool": {
+                contents.push({
+                    role: "user",
+                    parts: [
+                        {
+                            functionResponse: {
+                                name: m.toolName ?? "unknown",
+                                response: { result: m.content, isError: m.isError ?? false },
+                            },
+                        },
+                    ],
+                });
+                break;
+            }
+        }
+    }
+    return { system: systemParts.join("\n\n") || undefined, contents };
+}
+function toGeminiTools(tools) {
+    if (!tools.length)
+        return [];
+    return [
+        {
+            functionDeclarations: tools.map((t) => ({
+                name: t.name,
+                description: t.description,
+                parameters: t.inputSchema,
+            })),
+        },
+    ];
+}
+export function createGeminiClient(cfg, apiKey) {
+    const model = effectiveModel(cfg, "gemini");
+    const base = cfg.geminiBaseUrl ?? GEMINI_BASE_URL;
+    const endpoint = `${base.replace(/\/+$/, "")}/models/${model}:streamGenerateContent?alt=sse&key=${apiKey}`;
+    return {
+        provider: "gemini",
+        model,
+        isFree: true,
+        async chat(messages, tools, events, signal) {
+            const { system, contents } = toGeminiContents(messages);
+            const body = {
+                contents,
+                generationConfig: { temperature: 0.3 },
+            };
+            if (system)
+                body.systemInstruction = { parts: [{ text: system }] };
+            const gTools = toGeminiTools(tools);
+            if (gTools.length)
+                body.tools = gTools;
+            let res;
+            try {
+                res = await fetch(endpoint, {
+                    method: "POST",
+                    headers: { "content-type": "application/json" },
+                    body: JSON.stringify(body),
+                    signal,
+                });
+            }
+            catch (e) {
+                throw new ProviderError(`Cannot reach gemini: ${errorMessage(e)}`, "network");
+            }
+            if (!res.ok) {
+                let detail = "";
+                try {
+                    const j = (await res.json());
+                    detail = j.error?.message ?? "";
+                }
+                catch {
+                    // ignore
+                }
+                throw classifyStatus(res.status, "gemini", detail);
+            }
+            if (!res.body)
+                throw new ProviderError("gemini: empty response body", "unknown");
+            return parseGeminiStream(res.body, model, events);
+        },
+    };
+}
+async function parseGeminiStream(body, model, events) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let text = "";
+    const toolCalls = [];
+    let truncated = false;
+    const handleData = (data) => {
+        if (!data)
+            return;
+        let json;
+        try {
+            json = JSON.parse(data);
+        }
+        catch {
+            return;
+        }
+        if (json.error) {
+            const err = json.error;
+            const status = typeof json.code === "number" ? json.code : 400;
+            throw classifyStatus(status, "gemini", err.message ?? "stream error");
+        }
+        const candidates = json.candidates;
+        const candidate = candidates?.[0];
+        if (!candidate?.content)
+            return;
+        for (const part of candidate.content.parts ?? []) {
+            if (part.text) {
+                text += part.text;
+                events?.onText?.(part.text);
+            }
+            if (part.functionCall) {
+                toolCalls.push({
+                    id: `fc_${part.functionCall.name}_${toolCalls.length}`,
+                    name: part.functionCall.name,
+                    args: part.functionCall.args ?? {},
+                });
+            }
+        }
+        if (candidate.finishReason === "MAX_TOKENS")
+            truncated = true;
+        if (candidate.finishReason === "SAFETY") {
+            throw new ProviderError("gemini: response blocked by safety filter", "unknown");
+        }
+    };
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (trimmed.startsWith("data:"))
+                    handleData(trimmed.slice(5).trim());
+            }
+        }
+        if (buffer.trim()) {
+            const trimmed = buffer.trim();
+            if (trimmed.startsWith("data:"))
+                handleData(trimmed.slice(5).trim());
+        }
+    }
+    catch (e) {
+        if (e instanceof ProviderError)
+            throw e;
+        throw new ProviderError(`gemini: stream interrupted: ${errorMessage(e)}`, "network");
+    }
+    if (truncated) {
+        events?.onDebug?.(`gemini: response hit MAX_TOKENS and was truncated.`);
+    }
+    return {
+        role: "assistant",
+        content: text.trim(),
+        toolCalls: toolCalls.length ? toolCalls : undefined,
+    };
+}
+/** Exported for tests. */
+export { toGeminiContents, toGeminiTools };

package/dist/provider/index.js

@@ -0,0 +1,94 @@
+import { activeProvider, envApiKey } from "../config.js";
+import { createGatewayClient } from "./gateway.js";
+import { createGeminiClient } from "./gemini.js";
+import { createNvidiaClient } from "./nvidia.js";
+import { createOllamaClient } from "./ollama.js";
+import { createOpenRouterClient } from "./openrouter.js";
+import { createUnoRouterClient } from "./unorouter.js";
+/**
+ * Build the ordered list of ChatClients for this machine:
+ * the active model's provider first, then automatic free fallbacks
+ * (any other configured keys, then the zero-setup community gateway).
+ */
+export function resolveClients(cfg, debug) {
+    const clients = [];
+    const add = (c) => {
+        if (!clients.some((x) => x.provider === c.provider))
+            clients.push(c);
+    };
+    const has = (provider) => clients.some((c) => c.provider === provider);
+    const primary = activeProvider(cfg);
+    switch (primary) {
+        case "openrouter": {
+            const key = cfg.openrouterApiKey ?? envApiKey("openrouter");
+            // With no key, an OpenRouter model still runs through the gateway.
+            if (key)
+                add(createOpenRouterClient(cfg, key));
+            else
+                add(createGatewayClient(cfg));
+            break;
+        }
+        case "unorouter": {
+            const key = cfg.unorouterApiKey ?? envApiKey("unorouter");
+            // With no key, an UnoRouter model still runs through the gateway
+            // (the gateway holds the free UnoRouter key server-side).
+            if (key)
+                add(createUnoRouterClient(cfg, key));
+            else
+                add(createGatewayClient(cfg));
+            break;
+        }
+        case "nvidia": {
+            const key = cfg.nvidiaApiKey ?? envApiKey("nvidia");
+            // NVIDIA-hosted models can't run through the OpenRouter gateway.
+            if (key)
+                add(createNvidiaClient(cfg, key));
+            else
+                debug?.("NVIDIA model selected but no NVIDIA_API_KEY found — run `codeshark setup`.");
+            break;
+        }
+        case "gemini": {
+            const key = cfg.geminiApiKey ?? envApiKey("gemini");
+            if (key)
+                add(createGeminiClient(cfg, key));
+            else
+                debug?.("No Gemini API key env found (GEMINI_API_KEY) — will fall back.");
+            break;
+        }
+        case "ollama":
+            add(createOllamaClient(cfg));
+            break;
+        case "gateway":
+        default:
+            add(createGatewayClient(cfg));
+            break;
+    }
+    // Automatic free fallbacks, deduped: any other provider you have a key for.
+    if (!has("openrouter")) {
+        const key = cfg.openrouterApiKey ?? envApiKey("openrouter");
+        if (key)
+            add(createOpenRouterClient(cfg, key));
+    }
+    if (!has("unorouter")) {
+        const key = cfg.unorouterApiKey ?? envApiKey("unorouter");
+        if (key)
+            add(createUnoRouterClient(cfg, key));
+    }
+    if (!has("nvidia")) {
+        const key = cfg.nvidiaApiKey ?? envApiKey("nvidia");
+        if (key)
+            add(createNvidiaClient(cfg, key));
+    }
+    if (!has("gemini")) {
+        const key = cfg.geminiApiKey ?? envApiKey("gemini");
+        if (key)
+            add(createGeminiClient(cfg, key));
+    }
+    if (!has("ollama") && (cfg.ollamaBaseUrl || process.env.CODESHARK_OLLAMA_URL)) {
+        add(createOllamaClient(cfg));
+    }
+    if (!has("gateway") && primary !== "ollama") {
+        add(createGatewayClient(cfg));
+    }
+    return clients;
+}

package/dist/provider/nvidia.js

@@ -0,0 +1,19 @@
+import { createOpenAICompatClient } from "./openaiCompat.js";
+import { effectiveModel } from "../config.js";
+import { toApiSlug } from "../models.js";
+export const DEFAULT_NVIDIA_BASE_URL = "https://integrate.api.nvidia.com/v1";
+/**
+ * NVIDIA NIM hosts open models (DeepSeek, Kimi, GLM, Nemotron, …) behind a
+ * free, OpenAI-compatible API. Get a key at https://build.nvidia.com —
+ * no credit card, keys start with `nvapi-`.
+ */
+export function createNvidiaClient(cfg, apiKey) {
+    const model = toApiSlug(effectiveModel(cfg, "nvidia"));
+    return createOpenAICompatClient({
+        provider: "nvidia",
+        baseUrl: cfg.nvidiaBaseUrl ?? DEFAULT_NVIDIA_BASE_URL,
+        model,
+        apiKey,
+        isFree: true,
+    });
+}

package/dist/provider/ollama.js

@@ -0,0 +1,22 @@
+import { createOpenAICompatClient } from "./openaiCompat.js";
+import { effectiveModel } from "../config.js";
+export const DEFAULT_OLLAMA_BASE_URL = "http://127.0.0.1:11434/v1";
+export function createOllamaClient(cfg) {
+    const model = effectiveModel(cfg, "ollama");
+    return createOpenAICompatClient({
+        provider: "ollama",
+        baseUrl: cfg.ollamaBaseUrl ?? DEFAULT_OLLAMA_BASE_URL,
+        model,
+        isFree: true,
+    });
+}
+/** Quick reachability check for the local Ollama server. */
+export async function ollamaAvailable(cfg) {
+    try {
+        const res = await fetch(`${(cfg.ollamaBaseUrl ?? DEFAULT_OLLAMA_BASE_URL).replace(/\/+$/, "")}/models`);
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/provider/openaiCompat.js

@@ -0,0 +1,198 @@
+import { ProviderError, classifyStatus, errorMessage, } from "./types.js";
+function toOpenAIMessages(messages) {
+    const out = [];
+    for (const m of messages) {
+        switch (m.role) {
+            case "system":
+            case "user":
+                out.push({ role: m.role, content: m.content });
+                break;
+            case "assistant": {
+                const msg = { role: "assistant", content: m.content };
+                if (m.toolCalls?.length) {
+                    msg.tool_calls = m.toolCalls.map((tc) => ({
+                        id: tc.id,
+                        type: "function",
+                        function: { name: tc.name, arguments: JSON.stringify(tc.args) },
+                    }));
+                }
+                out.push(msg);
+                break;
+            }
+            case "tool":
+                out.push({ role: "tool", content: m.content, tool_call_id: m.toolCallId });
+                break;
+        }
+    }
+    return out;
+}
+function toOpenAITools(tools) {
+    return tools.map((t) => ({
+        type: "function",
+        function: { name: t.name, description: t.description, parameters: t.inputSchema },
+    }));
+}
+function safeParseArgs(raw) {
+    if (!raw)
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function createOpenAICompatClient(opts) {
+    const base = opts.baseUrl.replace(/\/+$/, "");
+    const endpoint = `${base}/chat/completions`;
+    const fetchImpl = opts.fetchImpl ?? fetch;
+    return {
+        provider: opts.provider,
+        model: opts.model,
+        isFree: opts.isFree ?? true,
+        async chat(messages, tools, events, signal) {
+            const body = {
+                model: opts.model,
+                messages: toOpenAIMessages(messages),
+                stream: true,
+                temperature: 0.3,
+            };
+            if (tools.length)
+                body.tools = toOpenAITools(tools);
+            const headers = {
+                "content-type": "application/json",
+                ...(opts.apiKey ? { authorization: `Bearer ${opts.apiKey}` } : {}),
+                ...opts.extraHeaders,
+            };
+            // Wait out rate limits with backoff before surfacing a 429 — the
+            // queue lives client-side too, so shared gateway lanes feel smooth.
+            const retryDelays = opts.rateLimitRetryDelays ?? [800, 1600];
+            let res;
+            for (let attempt = 0;; attempt++) {
+                let candidate;
+                try {
+                    candidate = await fetchImpl(endpoint, {
+                        method: "POST",
+                        headers,
+                        body: JSON.stringify(body),
+                        signal,
+                    });
+                }
+                catch (e) {
+                    throw new ProviderError(`Cannot reach ${opts.provider} at ${base}: ${errorMessage(e)}`, "network");
+                }
+                if (candidate.status !== 429 || attempt >= retryDelays.length) {
+                    res = candidate;
+                    break;
+                }
+                await new Promise((r) => setTimeout(r, retryDelays[attempt]));
+            }
+            if (!res.ok) {
+                let detail = "";
+                try {
+                    const j = (await res.json());
+                    detail = j.error?.message ?? JSON.stringify(j).slice(0, 300);
+                }
+                catch {
+                    detail = (await res.text().catch(() => "")).slice(0, 300);
+                }
+                throw classifyStatus(res.status, opts.provider, detail);
+            }
+            if (!res.body) {
+                throw new ProviderError(`${opts.provider}: empty response body`, "unknown");
+            }
+            return parseOpenAIStream(res.body, opts.provider, events);
+        },
+    };
+}
+async function parseOpenAIStream(body, provider, events) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let content = "";
+    const pending = new Map();
+    const finalized = new Map();
+    const handleData = (data) => {
+        if (!data || data === "[DONE]")
+            return;
+        let json;
+        try {
+            json = JSON.parse(data);
+        }
+        catch {
+            return;
+        }
+        if (json.error) {
+            const err = json.error;
+            const status = typeof json.status === "number" ? json.status : 400;
+            throw classifyStatus(status, provider, err.message ?? "stream error");
+        }
+        const choices = json.choices;
+        const choice = choices?.[0];
+        if (!choice)
+            return;
+        const delta = choice.delta ?? {};
+        if (delta.content) {
+            content += delta.content;
+            events?.onText?.(delta.content);
+        }
+        if (delta.tool_calls) {
+            for (const tc of delta.tool_calls) {
+                const idx = tc.index ?? 0;
+                const cur = pending.get(idx) ?? { id: "", name: "", args: "" };
+                if (tc.id)
+                    cur.id = tc.id;
+                if (tc.function?.name)
+                    cur.name += tc.function.name;
+                if (tc.function?.arguments)
+                    cur.args += tc.function.arguments;
+                pending.set(idx, cur);
+            }
+        }
+        if (choice.finish_reason) {
+            for (const [idx, tc] of pending)
+                finalized.set(idx, tc);
+            pending.clear();
+        }
+    };
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (trimmed.startsWith("data:"))
+                    handleData(trimmed.slice(5).trim());
+            }
+        }
+        if (buffer.trim()) {
+            const trimmed = buffer.trim();
+            if (trimmed.startsWith("data:"))
+                handleData(trimmed.slice(5).trim());
+        }
+    }
+    catch (e) {
+        if (e instanceof ProviderError)
+            throw e;
+        throw new ProviderError(`${provider}: stream interrupted: ${errorMessage(e)}`, "network");
+    }
+    const toolCalls = [...finalized.values()]
+        .filter((c) => c.name)
+        .map((c) => ({
+        id: c.id || `call_${Math.random().toString(36).slice(2, 10)}`,
+        name: c.name,
+        args: safeParseArgs(c.args),
+    }));
+    return {
+        role: "assistant",
+        content: content.trim(),
+        toolCalls: toolCalls.length ? toolCalls : undefined,
+    };
+}
+/** Exported for tests. */
+export { toOpenAIMessages, toOpenAITools, safeParseArgs };

package/dist/provider/openrouter.js

@@ -0,0 +1,21 @@
+import { createOpenAICompatClient } from "./openaiCompat.js";
+import { effectiveModel } from "../config.js";
+export const OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
+/** True when the model slug only targets free models on OpenRouter. */
+export function isOpenRouterFreeModel(model) {
+    return model === "openrouter/free" || model.endsWith(":free");
+}
+export function createOpenRouterClient(cfg, apiKey) {
+    const model = effectiveModel(cfg, "openrouter");
+    return createOpenAICompatClient({
+        provider: "openrouter",
+        baseUrl: cfg.openrouterBaseUrl ?? OPENROUTER_BASE_URL,
+        model,
+        apiKey,
+        isFree: isOpenRouterFreeModel(model),
+        extraHeaders: {
+            "HTTP-Referer": "https://github.com/codeshark/codeshark",
+            "X-Title": "CodeShark",
+        },
+    });
+}

package/dist/provider/types.js

@@ -0,0 +1,35 @@
+/**
+ * Canonical message/tool types shared across every provider adapter.
+ * Adapters convert between this format and their own wire format.
+ */
+export class ProviderError extends Error {
+    kind;
+    status;
+    constructor(message, kind = "unknown", status) {
+        super(message);
+        this.name = "ProviderError";
+        this.kind = kind;
+        this.status = status;
+    }
+}
+export function errorMessage(e) {
+    return e instanceof Error ? e.message : String(e);
+}
+/** Best-effort mapping of HTTP status codes to a friendly error kind. */
+export function classifyStatus(status, provider, detail) {
+    switch (status) {
+        case 401:
+        case 403:
+            return new ProviderError(`${provider}: authentication failed${detail ? ` (${detail})` : ""}. Check your API key (run \`codeshark setup\`).`, "auth", status);
+        case 404:
+        case 400:
+            return new ProviderError(`${provider}: model or request rejected${detail ? ` (${detail})` : ""}. Try \`codeshark model\` to see the active model.`, "model", status);
+        case 429:
+            return new ProviderError(`${provider}: rate limit hit on shared lanes — wait a moment or add your own key (run \`codeshark setup\`).`, "rate_limit", status);
+        default:
+            if (status >= 500) {
+                return new ProviderError(`${provider}: server error (${status}). Try again shortly.`, "server", status);
+            }
+            return new ProviderError(`${provider}: request failed (${status})${detail ? `: ${detail}` : ""}.`, "unknown", status);
+    }
+}

package/dist/provider/unorouter.js

@@ -0,0 +1,25 @@
+import { createOpenAICompatClient } from "./openaiCompat.js";
+import { effectiveModel } from "../config.js";
+export const UNOROUTER_BASE_URL = "https://api.unorouter.com/v1";
+/**
+ * True when the model slug only targets free models on UnoRouter.
+ * UnoRouter's free lanes are OpenAI-compatible: one key, 200+ free models
+ * behind `:free` slugs (https://unorouter.com).
+ */
+export function isUnoRouterFreeModel(model) {
+    return model === "unorouter/free" || model.endsWith(":free");
+}
+export function createUnoRouterClient(cfg, apiKey) {
+    const model = effectiveModel(cfg, "unorouter");
+    return createOpenAICompatClient({
+        provider: "unorouter",
+        baseUrl: cfg.unorouterBaseUrl ?? UNOROUTER_BASE_URL,
+        model,
+        apiKey,
+        isFree: isUnoRouterFreeModel(model),
+        extraHeaders: {
+            "HTTP-Referer": "https://github.com/codeshark/codeshark",
+            "X-Title": "CodeShark",
+        },
+    });
+}