openpoly 0.1.0

package/dist/config/config.js

@@ -0,0 +1,109 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, copyFileSync, } from "node:fs";
+/** Bump when the seeded defaults change in a way that should reseed configs. */
+const CONFIG_VERSION = 3;
+/** OpenRouter's OpenAI-compatible gateway — free open-source models + many more. */
+export const OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
+export const OPENROUTER_MODELS_URL = `${OPENROUTER_BASE_URL}/models`;
+const CONFIG_DIR = join(homedir(), ".config", "polycode");
+const GLOBAL_CONFIG_PATH = join(CONFIG_DIR, "config.json");
+const PROJECT_CONFIG_NAME = ".polycode.json";
+const KNOWN_PROVIDERS = [
+    "openai",
+    "anthropic",
+    "google",
+    "openai-compatible",
+    "openrouter",
+];
+/** A config is stale if it references a provider we no longer support (e.g. an
+ * old Puter seed). Such configs are migrated by reseeding the defaults. */
+function isStale(cfg) {
+    return (cfg.models ?? []).some((m) => !KNOWN_PROVIDERS.includes(m.provider));
+}
+/** Sensible starter config seeded on first run. Defaults to free, open-source
+ * models on OpenRouter (one free API key, no credit card), plus local Ollama. */
+export function defaultConfig() {
+    return {
+        version: CONFIG_VERSION,
+        defaultModel: "gpt-oss",
+        models: [
+            // --- OpenRouter free, open-source, tool-capable models (OPENROUTER_API_KEY) ---
+            { name: "gpt-oss", provider: "openrouter", model: "openai/gpt-oss-120b:free" },
+            { name: "gpt-oss-mini", provider: "openrouter", model: "openai/gpt-oss-20b:free" },
+            { name: "qwen-coder", provider: "openrouter", model: "qwen/qwen3-coder:free" },
+            { name: "llama", provider: "openrouter", model: "meta-llama/llama-3.3-70b-instruct:free" },
+            { name: "nemotron", provider: "openrouter", model: "nvidia/nemotron-nano-9b-v2:free" },
+            // --- Local, fully free, no key (requires Ollama running) ---
+            { name: "deepseek-local", provider: "openai-compatible", model: "deepseek-r1", baseURL: "http://localhost:11434/v1" },
+            { name: "glm-local", provider: "openai-compatible", model: "glm4", baseURL: "http://localhost:11434/v1" },
+            { name: "qwen-local", provider: "openai-compatible", model: "qwen3", baseURL: "http://localhost:11434/v1" },
+            // --- Direct providers (bring your own API keys) ---
+            { name: "gpt-4o-direct", provider: "openai", model: "gpt-4o" },
+            { name: "claude-direct", provider: "anthropic", model: "claude-3-5-sonnet-latest" },
+            { name: "gemini-direct", provider: "google", model: "gemini-1.5-pro-latest" },
+        ],
+    };
+}
+/** Build a config entry for an arbitrary OpenRouter model id (used by
+ * `/model <id>` and the live menu, so any OpenRouter model works directly). */
+export function openRouterModelConfig(modelId) {
+    return { name: modelId, provider: "openrouter", model: modelId };
+}
+function readJson(path) {
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Load config by merging the global config with an optional project-level
+ * `.polycode.json` (project values win). Seeds a global default on first run.
+ */
+export function loadConfig(cwd = process.cwd()) {
+    let seeded = false;
+    const existing = readJson(GLOBAL_CONFIG_PATH);
+    const outdated = !existing || existing.version !== CONFIG_VERSION || isStale(existing);
+    if (outdated) {
+        // Preserve any prior config (e.g. user edits) before reseeding.
+        if (existing) {
+            try {
+                copyFileSync(GLOBAL_CONFIG_PATH, `${GLOBAL_CONFIG_PATH}.bak`);
+            }
+            catch {
+                /* best effort */
+            }
+        }
+        saveGlobalConfig(defaultConfig());
+        seeded = true;
+    }
+    const global = (seeded ? defaultConfig() : existing) ?? defaultConfig();
+    const project = readJson(join(cwd, PROJECT_CONFIG_NAME)) ?? {};
+    const merged = {
+        defaultModel: project.defaultModel ?? global.defaultModel ?? "qwen-coder",
+        models: mergeModels(global.models ?? [], project.models ?? []),
+    };
+    return { config: merged, seeded };
+}
+/** Project models override global ones with the same name; new ones are added. */
+function mergeModels(globalModels, projectModels) {
+    const byName = new Map();
+    for (const m of globalModels)
+        byName.set(m.name, m);
+    for (const m of projectModels)
+        byName.set(m.name, m);
+    return [...byName.values()];
+}
+export function saveGlobalConfig(config) {
+    if (!existsSync(CONFIG_DIR))
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(GLOBAL_CONFIG_PATH, JSON.stringify(config, null, 2), "utf8");
+}
+export function globalConfigPath() {
+    return GLOBAL_CONFIG_PATH;
+}
+export function findModel(config, name) {
+    return config.models.find((m) => m.name === name);
+}

package/dist/providers/index.js

@@ -0,0 +1,101 @@
+import { createOpenAI } from "@ai-sdk/openai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { OPENROUTER_BASE_URL, OPENROUTER_MODELS_URL, } from "../config/config.js";
+const DEFAULT_KEY_ENV = {
+    openai: "OPENAI_API_KEY",
+    anthropic: "ANTHROPIC_API_KEY",
+    google: "GOOGLE_GENERATIVE_AI_API_KEY",
+    "openai-compatible": "OPENAI_API_KEY",
+    openrouter: "OPENROUTER_API_KEY",
+};
+// Optional ranking headers OpenRouter uses to attribute traffic to an app.
+const OPENROUTER_HEADERS = {
+    "HTTP-Referer": "https://github.com/polycode",
+    "X-Title": "polycode",
+};
+export class ProviderError extends Error {
+}
+/** The environment variable that holds the API key for a given model. */
+export function keyEnvFor(cfg) {
+    return cfg.apiKeyEnv ?? DEFAULT_KEY_ENV[cfg.provider] ?? "API_KEY";
+}
+/** Whether a model needs an API key (local openai-compatible servers don't). */
+export function needsKey(cfg) {
+    return cfg.provider !== "openai-compatible";
+}
+/**
+ * Resolve a config entry into a concrete Vercel AI SDK model instance.
+ * Throws a friendly ProviderError when the required API key is missing.
+ */
+export function buildModel(cfg) {
+    const keyEnv = cfg.apiKeyEnv ?? DEFAULT_KEY_ENV[cfg.provider];
+    const apiKey = keyEnv ? process.env[keyEnv] : undefined;
+    // Local openai-compatible servers (e.g. Ollama) need no real key.
+    const requiresKey = cfg.provider !== "openai-compatible";
+    if (requiresKey && !apiKey) {
+        if (cfg.provider === "openrouter") {
+            throw new ProviderError(`Missing OpenRouter key. Get a free one (no credit card) at https://openrouter.ai/keys and set OPENROUTER_API_KEY.`);
+        }
+        throw new ProviderError(`Missing API key for model "${cfg.name}". Set the ${keyEnv} environment variable.`);
+    }
+    switch (cfg.provider) {
+        case "openai":
+            return createOpenAI({ apiKey })(cfg.model);
+        case "anthropic":
+            return createAnthropic({ apiKey })(cfg.model);
+        case "google":
+            return createGoogleGenerativeAI({ apiKey })(cfg.model);
+        case "openai-compatible":
+            if (!cfg.baseURL) {
+                throw new ProviderError(`Model "${cfg.name}" uses provider "openai-compatible" but has no baseURL.`);
+            }
+            return createOpenAICompatible({
+                name: cfg.name,
+                baseURL: cfg.baseURL,
+                apiKey: apiKey ?? "not-needed",
+            })(cfg.model);
+        case "openrouter":
+            return createOpenAICompatible({
+                name: "openrouter",
+                baseURL: OPENROUTER_BASE_URL,
+                apiKey: apiKey,
+                headers: OPENROUTER_HEADERS,
+            })(cfg.model);
+        default:
+            throw new ProviderError(`Unknown provider "${cfg.provider}".`);
+    }
+}
+/**
+ * Fetch OpenRouter's live catalog and return every **tool-capable** model (the
+ * ones usable by this coding agent), flagging which are free. Free models come
+ * first, then alphabetical. Throws on network failure. (The free set rotates;
+ * DeepSeek/GLM/Kimi show up as free whenever they're offered free.)
+ */
+export async function listModels() {
+    let res;
+    try {
+        res = await fetch(OPENROUTER_MODELS_URL);
+    }
+    catch (err) {
+        throw new ProviderError(`Could not reach OpenRouter: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (!res.ok) {
+        throw new ProviderError(`OpenRouter returned ${res.status} ${res.statusText} when listing models.`);
+    }
+    const body = (await res.json());
+    const models = [];
+    for (const m of body.data ?? []) {
+        if (!m.id)
+            continue;
+        const hasTools = m.supported_parameters?.includes("tools") ?? false;
+        if (!hasTools)
+            continue; // the agent needs tool calling
+        const free = m.id.endsWith(":free") || m.pricing?.prompt === "0";
+        models.push({ id: m.id, free });
+    }
+    // Free first, then alphabetical, so the free options are front and centre.
+    models.sort((a, b) => a.free === b.free ? a.id.localeCompare(b.id) : a.free ? -1 : 1);
+    return models;
+}

package/dist/tools/fsutil.js

@@ -0,0 +1,18 @@
+import { resolve, relative, isAbsolute } from "node:path";
+/**
+ * Resolve a user/model-supplied path against the working directory and refuse
+ * anything that escapes it. Keeps the agent contained to the project.
+ */
+export function resolveSafe(cwd, p) {
+    const abs = isAbsolute(p) ? p : resolve(cwd, p);
+    const rel = relative(cwd, abs);
+    if (rel.startsWith("..") || isAbsolute(rel)) {
+        throw new Error(`Path "${p}" is outside the working directory.`);
+    }
+    return abs;
+}
+/** Display a path relative to cwd for tidy UI output. */
+export function displayPath(cwd, abs) {
+    const rel = relative(cwd, abs);
+    return rel === "" ? "." : rel;
+}

package/dist/tools/index.js

@@ -0,0 +1,192 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, statSync, } from "node:fs";
+import { dirname, join } from "node:path";
+import { exec } from "node:child_process";
+import { resolveSafe, displayPath } from "./fsutil.js";
+const IGNORED_DIRS = new Set([
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    ".next",
+    ".vexp",
+]);
+/**
+ * Build the tool set, capturing the working directory and permission broker in
+ * a closure so the Vercel AI SDK can call them without extra context plumbing.
+ */
+export function createTools(cwd, broker) {
+    return {
+        read_file: tool({
+            description: "Read the contents of a file in the project. Returns the text with line numbers.",
+            parameters: z.object({
+                path: z.string().describe("File path relative to the project root."),
+            }),
+            execute: async ({ path }) => {
+                const abs = resolveSafe(cwd, path);
+                if (!existsSync(abs))
+                    return `Error: file not found: ${path}`;
+                const text = readFileSync(abs, "utf8");
+                const numbered = text
+                    .split("\n")
+                    .map((line, i) => `${String(i + 1).padStart(5)}  ${line}`)
+                    .join("\n");
+                return numbered;
+            },
+        }),
+        write_file: tool({
+            description: "Create a new file or overwrite an existing one with the given content.",
+            parameters: z.object({
+                path: z.string().describe("File path relative to the project root."),
+                content: z.string().describe("Full content to write."),
+            }),
+            execute: async ({ path, content }) => {
+                const abs = resolveSafe(cwd, path);
+                const exists = existsSync(abs);
+                const ok = await broker.request("write_file", `${exists ? "Overwrite" : "Create"} file: ${displayPath(cwd, abs)}`, previewContent(content));
+                if (!ok)
+                    return "Denied by user.";
+                mkdirSync(dirname(abs), { recursive: true });
+                writeFileSync(abs, content, "utf8");
+                return `Wrote ${content.length} bytes to ${displayPath(cwd, abs)}`;
+            },
+        }),
+        edit_file: tool({
+            description: "Replace an exact string in a file with new text. The old string must appear exactly once.",
+            parameters: z.object({
+                path: z.string().describe("File path relative to the project root."),
+                old_string: z.string().describe("Exact text to replace."),
+                new_string: z.string().describe("Replacement text."),
+            }),
+            execute: async ({ path, old_string, new_string }) => {
+                const abs = resolveSafe(cwd, path);
+                if (!existsSync(abs))
+                    return `Error: file not found: ${path}`;
+                const original = readFileSync(abs, "utf8");
+                const count = original.split(old_string).length - 1;
+                if (count === 0)
+                    return "Error: old_string not found in file.";
+                if (count > 1)
+                    return `Error: old_string appears ${count} times; it must be unique.`;
+                const updated = original.replace(old_string, new_string);
+                const ok = await broker.request("edit_file", `Edit file: ${displayPath(cwd, abs)}`, diffPreview(old_string, new_string));
+                if (!ok)
+                    return "Denied by user.";
+                writeFileSync(abs, updated, "utf8");
+                return `Edited ${displayPath(cwd, abs)}`;
+            },
+        }),
+        run_command: tool({
+            description: "Run a shell command in the project directory and return its output. Use for tests, git, builds, etc.",
+            parameters: z.object({
+                command: z.string().describe("The shell command to run."),
+            }),
+            execute: async ({ command }) => {
+                const ok = await broker.request("run_command", `Run command: ${command}`);
+                if (!ok)
+                    return "Denied by user.";
+                return runShell(command, cwd);
+            },
+        }),
+        search_code: tool({
+            description: "Search the project for a text pattern (literal or regex). Returns matching files and lines.",
+            parameters: z.object({
+                pattern: z.string().describe("Text or regular expression to find."),
+                path: z
+                    .string()
+                    .optional()
+                    .describe("Optional subdirectory to search within."),
+            }),
+            execute: async ({ pattern, path }) => {
+                const root = resolveSafe(cwd, path ?? ".");
+                let regex;
+                try {
+                    regex = new RegExp(pattern, "i");
+                }
+                catch {
+                    regex = new RegExp(escapeRegex(pattern), "i");
+                }
+                const results = [];
+                walk(root, (file) => {
+                    let text;
+                    try {
+                        text = readFileSync(file, "utf8");
+                    }
+                    catch {
+                        return; // skip binary/unreadable
+                    }
+                    text.split("\n").forEach((line, i) => {
+                        if (regex.test(line) && results.length < 100) {
+                            results.push(`${displayPath(cwd, file)}:${i + 1}: ${line.trim()}`);
+                        }
+                    });
+                });
+                return results.length
+                    ? results.join("\n")
+                    : `No matches for "${pattern}".`;
+            },
+        }),
+    };
+}
+function previewContent(content) {
+    const lines = content.split("\n");
+    const head = lines.slice(0, 20).join("\n");
+    return lines.length > 20 ? `${head}\n… (${lines.length} lines total)` : head;
+}
+function diffPreview(oldStr, newStr) {
+    const minus = oldStr
+        .split("\n")
+        .map((l) => `- ${l}`)
+        .join("\n");
+    const plus = newStr
+        .split("\n")
+        .map((l) => `+ ${l}`)
+        .join("\n");
+    return `${minus}\n${plus}`;
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function walk(dir, onFile) {
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            if (IGNORED_DIRS.has(entry.name))
+                continue;
+            walk(join(dir, entry.name), onFile);
+        }
+        else if (entry.isFile()) {
+            const full = join(dir, entry.name);
+            try {
+                if (statSync(full).size > 1_000_000)
+                    continue; // skip huge files
+            }
+            catch {
+                continue;
+            }
+            onFile(full);
+        }
+    }
+}
+function runShell(command, cwd) {
+    return new Promise((resolve) => {
+        exec(command, { cwd, timeout: 120_000, maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
+            const out = [stdout, stderr].filter(Boolean).join("\n").trim();
+            if (error && error.code === "ETIMEDOUT") {
+                resolve(`Command timed out after 120s.\n${out}`);
+                return;
+            }
+            const exitInfo = error && typeof error.code === "number"
+                ? `\n[exit code ${error.code}]`
+                : "";
+            resolve((out || "(no output)") + exitInfo);
+        });
+    });
+}

package/dist/tools/permissions.js

@@ -0,0 +1,32 @@
+import { EventEmitter } from "node:events";
+import { randomUUID } from "node:crypto";
+/**
+ * Bridges tool execution (which needs an answer) and the TUI (which asks the
+ * user). Tools `await request(...)`; the TUI listens for "request" events and
+ * calls `respond`. "always" remembers the tool for the rest of the session.
+ */
+export class PermissionBroker extends EventEmitter {
+    alwaysAllowed = new Set();
+    /** Pre-approve a tool (used by --yolo / auto-approve mode). */
+    allowAlways(tool) {
+        this.alwaysAllowed.add(tool);
+    }
+    async request(tool, title, detail) {
+        if (this.alwaysAllowed.has(tool))
+            return true;
+        return new Promise((resolve) => {
+            const req = {
+                id: randomUUID(),
+                tool,
+                title,
+                detail,
+                respond: (decision) => {
+                    if (decision === "always")
+                        this.alwaysAllowed.add(tool);
+                    resolve(decision !== "deny");
+                },
+            };
+            this.emit("request", req);
+        });
+    }
+}