atom-agent 0.3.0

package/dist/env-block.js

@@ -0,0 +1,166 @@
+// Per-turn environment block (Task 6, plans/tasks.md): grounds every ATOM
+// turn in repo reality — cwd, git branch/status (best-effort), node version,
+// timestamp.
+//
+// Placement: pinned to the SYSTEM message only (suffix to history[0]'s
+// content via withEnvBlock), NEVER into user content. history[0] is the only
+// slot truncateHistory never drops, so the block survives budget trimming.
+// Caching: the App refreshes history[0] once per turn in submit() (before the
+// budget check, so truncation accounts for it) — the loop's up-to-30 POSTs
+// reuse the same history[0], so git is shelled at most once per turn.
+// Failure-silent: missing git / non-repo cwd / timeout → the block shrinks
+// (cwd + node + time only), never throws, never blocks the turn. No new
+// dependencies; one cheap `git status` invocation with a short timeout, and
+// zero shell-outs when `.git` is absent.
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import * as path from "node:path";
+// Cap for the block itself (~500 chars per the task). The base system prompt
+// (SYSTEM_PROMPT + AGENTS.md overlay) is untouched by this cap.
+export const ENV_BLOCK_CHAR_CAP = 500;
+// Marker identifying a previously pinned block (for idempotent refresh).
+export const ENV_BLOCK_TAG = "[env ";
+// Single git invocation budget: fail fast, never stall the turn.
+const GIT_TIMEOUT_MS = 750;
+// Long Windows cwds would blow the cap alone: keep the identifying tail.
+const CWD_DISPLAY_CAP = 180;
+function shortCwd(cwd) {
+    if (cwd.length <= CWD_DISPLAY_CAP)
+        return cwd;
+    return `…${cwd.slice(cwd.length - (CWD_DISPLAY_CAP - 1))}`;
+}
+// Pure formatter (no I/O): always `cwd + node + time`, plus
+// `branch + status` only when git reported them. Capped to
+// ENV_BLOCK_CHAR_CAP (cwd is pre-truncated so time/node survive the cap).
+export function buildEnvBlock(parts) {
+    const cwd = shortCwd(parts.cwd);
+    const git = parts.branch !== undefined &&
+        parts.branch !== null &&
+        parts.branch.length > 0
+        ? ` branch=${parts.branch} status=${parts.status ?? "unknown"}`
+        : "";
+    const block = `[env cwd=${cwd}${git} node=${parts.nodeVersion} time=${parts.timestamp}]`;
+    return block.length > ENV_BLOCK_CHAR_CAP
+        ? `${block.slice(0, ENV_BLOCK_CHAR_CAP - 1)}]`
+        : block;
+}
+// One cheap `git status --branch --porcelain=v1`: branch from the `##` line,
+// dirtiness from the remaining file lines. Null on ANY failure (no repo, no
+// git binary, timeout) — the caller shrinks the block instead.
+export function getGitInfo(cwd) {
+    try {
+        if (!existsSync(path.join(cwd, ".git")))
+            return null;
+        const out = execFileSync("git", ["status", "--branch", "--porcelain=v1"], {
+            cwd,
+            timeout: GIT_TIMEOUT_MS,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        const text = typeof out === "string" ? out : String(out ?? "");
+        const lines = text.split("\n");
+        const head = (lines[0] ?? "").trim();
+        if (!head.startsWith("## "))
+            return null;
+        const rest = head.slice(3).trim();
+        let branch;
+        if (rest.startsWith("No commits yet on ")) {
+            branch = rest.slice("No commits yet on ".length).split(" ")[0] ?? "";
+        }
+        else {
+            branch = rest.split("...")[0]?.split(" ")[0] ?? "";
+        }
+        branch = branch.trim().slice(0, 64);
+        if (!branch)
+            return null;
+        let changed = 0;
+        for (let i = 1; i < lines.length; i++) {
+            if ((lines[i] ?? "").trim().length > 0)
+                changed += 1;
+        }
+        return { branch, status: changed === 0 ? "clean" : `dirty:${changed}` };
+    }
+    catch {
+        return null;
+    }
+}
+// Gather + format for a cwd (default: process cwd). NEVER throws: every piece
+// is best-effort and the block shrinks to what was available.
+export function getEnvBlock(cwd = process.cwd()) {
+    try {
+        let dir = cwd;
+        try {
+            if (!dir)
+                dir = process.cwd();
+        }
+        catch {
+            dir = ".";
+        }
+        let nodeVersion = "unknown";
+        try {
+            nodeVersion = process.version ?? "unknown";
+        }
+        catch {
+            // keep fallback
+        }
+        let timestamp = "";
+        try {
+            timestamp = new Date().toISOString();
+        }
+        catch {
+            timestamp = String(Date.now());
+        }
+        let git = null;
+        try {
+            git = getGitInfo(dir);
+        }
+        catch {
+            git = null;
+        }
+        return buildEnvBlock({
+            cwd: dir,
+            branch: git?.branch ?? null,
+            status: git?.status ?? null,
+            nodeVersion,
+            timestamp,
+        });
+    }
+    catch {
+        return `[env node=unknown time=${Date.now()}]`;
+    }
+}
+// Remove a previously pinned block (idempotent refresh needs this so blocks
+// never stack across turns). Only strips a TRAILING block — an "[env "
+// anywhere else in the prompt is left alone.
+export function stripEnvBlock(content) {
+    const idx = content.lastIndexOf(`\n\n${ENV_BLOCK_TAG}`);
+    if (idx < 0)
+        return content;
+    const tail = content.slice(idx + 2);
+    if (!tail.startsWith(ENV_BLOCK_TAG))
+        return content;
+    if (!tail.trimEnd().endsWith("]"))
+        return content;
+    return content.slice(0, idx);
+}
+// Pin a fresh block to system content (strips any prior block first, so
+// per-turn refresh is idempotent). NEVER throws — on any failure the input
+// is returned unchanged.
+export function withEnvBlock(systemContent, cwd) {
+    try {
+        const base = stripEnvBlock(systemContent);
+        let block = "";
+        try {
+            block = getEnvBlock(cwd ?? process.cwd());
+        }
+        catch {
+            return base;
+        }
+        if (!block)
+            return base;
+        return `${base}\n\n${block}`;
+    }
+    catch {
+        return systemContent;
+    }
+}

package/dist/permissions.js

@@ -0,0 +1,129 @@
+// Scoped allow/deny rules for tool approval (ticket 03).
+// Pure module: pattern matching over tool name + arguments. No UI imports.
+//
+// Rule syntax: `tool` or `tool:glob`
+//   - `write`            matches any write call (tool-only rule)
+//   - `bash:npm test*`   matches bash calls whose command starts with "npm test"
+//   - `write:src/**`     matches writes under src/
+// The glob applies to the tool's primary string (the same primary shown in
+// the `⚙` audit line): path for read/write/edit, pattern for glob/grep,
+// command for bash, url/query for webfetch/websearch, taskId for
+// bash_output, question for ask_question. Other tools have no primary string,
+// so only tool-only rules match them.
+// Glob dialect: `*` matches any sequence (including `/` and spaces), `?`
+// matches exactly one char, everything else is literal. Case-sensitive.
+//
+// Effect is decided at the approve() call site (App.tsx): deny is checked
+// first and wins over yolo/session-trust/always/skill grants; allow runs the
+// call without prompting. With no rules the verdict is null and the existing
+// y/a/n + /trust flow is byte-identical. Rules only take effect on
+// approval-gated calls (write/edit/bash) because read-only tools never
+// consult approve() — a rule naming another tool is accepted but inert.
+// Parse one user-typed pattern (`tool` or `tool:glob`). Returns null when the
+// pattern has no usable tool name (empty, whitespace, or a colon first).
+export function parseRuleInput(pattern, kind) {
+    const raw = pattern.trim();
+    if (raw.length === 0)
+        return null;
+    const colon = raw.indexOf(":");
+    const tool = (colon === -1 ? raw : raw.slice(0, colon)).trim();
+    // Tool names are single lowercase tokens; anything else is a typo worth
+    // rejecting loudly rather than a rule that silently never matches.
+    if (!/^[a-z0-9_-]+$/.test(tool))
+        return null;
+    let glob = null;
+    if (colon !== -1) {
+        const rest = raw.slice(colon + 1).trim();
+        glob = rest.length > 0 ? rest : null;
+    }
+    return { kind, tool, glob, pattern: tool + (glob === null ? "" : `:${glob}`) };
+}
+// Glob match: `*` = any sequence, `?` = one char, else literal.
+// Case-sensitive (commands and paths are). Empty pattern matches only "".
+export function matchGlob(pattern, value) {
+    let px = 0;
+    let vx = 0;
+    let star = -1;
+    let starVx = 0;
+    while (vx < value.length) {
+        const p = pattern[px];
+        if (px < pattern.length && (p === "?" || p === value[vx])) {
+            px += 1;
+            vx += 1;
+        }
+        else if (px < pattern.length && p === "*") {
+            star = px;
+            starVx = vx;
+            px += 1;
+        }
+        else if (star !== -1) {
+            starVx += 1;
+            vx = starVx;
+            px = star + 1;
+        }
+        else {
+            return false;
+        }
+    }
+    while (px < pattern.length && pattern[px] === "*")
+        px += 1;
+    return px === pattern.length;
+}
+// Primary string for a tool call: the same primary describeToolCall shows in
+// the `⚙` audit line, so what you allow is what you see. Non-string or
+// missing primaries read as "" (a glob can still match "" explicitly, e.g.
+// `*` — a tool-only rule is the clearer way to say "any").
+export function primaryTarget(name, args) {
+    const a = args ?? {};
+    const str = (v) => (typeof v === "string" ? v : "");
+    switch (name) {
+        case "read":
+        case "write":
+        case "edit":
+            return str(a["path"]);
+        case "glob":
+        case "grep":
+            return str(a["pattern"]);
+        case "bash":
+            return str(a["command"]);
+        case "bash_output":
+            return str(a["taskId"]);
+        case "webfetch":
+            return str(a["url"]);
+        case "websearch":
+            return str(a["query"]);
+        case "ask_question":
+            return str(a["question"]);
+        default:
+            return "";
+    }
+}
+function ruleMatches(rule, name, args) {
+    if (rule.tool !== name)
+        return false;
+    if (rule.glob === null)
+        return true;
+    return matchGlob(rule.glob, primaryTarget(name, args));
+}
+// First deny match wins (even over allows and over trust/yolo at the call
+// site); otherwise the first allow match auto-approves; otherwise null
+// (fall through to the normal prompt flow).
+export function checkRules(rules, name, args) {
+    for (const rule of rules) {
+        if (rule.kind === "deny" && ruleMatches(rule, name, args))
+            return "deny";
+    }
+    for (const rule of rules) {
+        if (rule.kind === "allow" && ruleMatches(rule, name, args))
+            return "allow";
+    }
+    return null;
+}
+export function formatRule(rule) {
+    return `${rule.kind === "allow" ? "allow" : "deny"}: ${rule.pattern}`;
+}
+export function formatRules(rules) {
+    if (rules.length === 0)
+        return "(no rules)";
+    return `Rules (${rules.length}):\n${rules.map((r, i) => `${i + 1}. ${formatRule(r)}`).join("\n")}`;
+}

package/dist/providers.js

@@ -0,0 +1,224 @@
+// Provider registry for Atom (mirrors opencode /connect, manual-key only).
+// No OAuth, no browser flow. Credentials live in ~/.atom/auth.json;
+// env vars win when set (see src/auth.ts).
+//
+// Curated fallback model lists were picked at BUILD time (2026-09-07)
+// from each vendor's docs (tool-capable chat models preferred, 3-6 ids):
+// - opencode-zen: existing FALLBACK_MODELS in src/zen.ts (verified from
+//   https://opencode.ai/docs/zen). Re-listed here for the picker.
+// - openai: https://platform.openai.com/docs/models — flagship chat models
+//   with function calling (GPT-6 Astra, GPT-5.6 Sol/Terra/Luna).
+// - anthropic: https://docs.anthropic.com/en/docs/about-claude/models —
+//   Claude Sonnet/Opus/Haiku with tool use (Messages API).
+// - deepseek: https://api-docs.deepseek.com/quick_start/pricing —
+//   deepseek-v4-flash / deepseek-v4-pro / deepseek-v4-flash-vision-exp
+//   (all list Tool Calls support; OpenAI-compatible base https://api.deepseek.com).
+// - mistral: https://docs.mistral.ai/inference/models — generalist
+//   tool-capable models via *-latest aliases (large/medium/small + nemo).
+// - google-gemini: https://ai.google.dev/gemini-api/docs/models —
+//   Gemini 2.5/2.0/1.5 Flash/Pro with function calling.
+// - openai-compatible: generic OpenAI-shape ids (custom baseURL); the live
+//   /models list is authoritative, these are just offline placeholders.
+export const DEFAULT_PROVIDER = "opencode-zen";
+export const PROVIDERS = [
+    {
+        id: "opencode-zen",
+        name: "OpenCode Zen",
+        kind: "openai-chat",
+        chatEndpoint: "https://opencode.ai/zen/v1/chat/completions",
+        consoleURL: "https://opencode.ai/auth",
+        envVars: ["OPENCODE_ZEN_API_KEY"],
+        // Task 5: strong tool-reliable default (live-list + docs verified
+        // 2026-09-08, see DEFAULT_MODEL in src/zen.ts). Free big-pickle stays
+        // listed as a fallback, selectable via /model. kimi-k2.6 / minimax-m2.7
+        // replace kimi-k2.5 / minimax-m2.5 (both deprecated upstream 2026-08-05).
+        defaultModel: "deepseek-v4-pro",
+        fallbackModels: [
+            "deepseek-v4-pro",
+            "kimi-k2.6",
+            "glm-5.2",
+            "minimax-m2.7",
+            "big-pickle",
+        ],
+        notes: "OpenAI-compatible chat/completions. reasoning_effort only here.",
+    },
+    {
+        id: "openai",
+        name: "OpenAI",
+        kind: "openai-chat",
+        chatEndpoint: "https://api.openai.com/v1/chat/completions",
+        consoleURL: "https://platform.openai.com/api-keys",
+        envVars: ["OPENAI_API_KEY"],
+        defaultModel: "gpt-5.6-terra",
+        fallbackModels: [
+            "gpt-6-astra",
+            "gpt-5.6-sol",
+            "gpt-5.6-terra",
+            "gpt-5.6-luna",
+        ],
+        notes: "OpenAI-compatible chat/completions. reasoning_effort never sent.",
+    },
+    {
+        id: "anthropic",
+        name: "Anthropic",
+        kind: "anthropic-messages",
+        chatEndpoint: "https://api.anthropic.com/v1/messages",
+        consoleURL: "https://console.anthropic.com/settings/keys",
+        envVars: ["ANTHROPIC_API_KEY"],
+        defaultModel: "claude-sonnet-4-5",
+        fallbackModels: [
+            "claude-sonnet-4-5",
+            "claude-opus-4-1",
+            "claude-3-5-sonnet-20241022",
+            "claude-3-5-haiku-20241022",
+        ],
+        notes: "Messages API with tool_use blocks. max_tokens 4096.",
+    },
+    {
+        id: "deepseek",
+        name: "DeepSeek",
+        kind: "openai-chat",
+        chatEndpoint: "https://api.deepseek.com/chat/completions",
+        consoleURL: "https://platform.deepseek.com/api_keys",
+        envVars: ["DEEPSEEK_API_KEY"],
+        defaultModel: "deepseek-chat",
+        fallbackModels: [
+            "deepseek-chat",
+            "deepseek-reasoner",
+            "deepseek-v4-flash",
+            "deepseek-v4-pro",
+        ],
+        notes: "OpenAI-compatible (no /v1 prefix). reasoning_effort never sent.",
+    },
+    {
+        id: "mistral",
+        name: "Mistral",
+        kind: "openai-chat",
+        chatEndpoint: "https://api.mistral.ai/v1/chat/completions",
+        consoleURL: "https://console.mistral.ai/api-keys",
+        envVars: ["MISTRAL_API_KEY"],
+        defaultModel: "mistral-medium-latest",
+        fallbackModels: [
+            "mistral-large-latest",
+            "mistral-medium-latest",
+            "mistral-small-latest",
+            "open-mistral-nemo",
+        ],
+        notes: "OpenAI-compatible chat/completions. reasoning_effort never sent.",
+    },
+    {
+        id: "google-gemini",
+        name: "Google Gemini",
+        kind: "gemini-generate",
+        // {model} is interpolated per POST; see adapters.geminiChatUrl().
+        chatEndpoint: "https://generativelanguage.googleapis.com/v1beta/models",
+        consoleURL: "https://aistudio.google.com/apikey",
+        envVars: ["GEMINI_API_KEY", "GOOGLE_API_KEY"],
+        defaultModel: "gemini-2.5-flash",
+        fallbackModels: [
+            "gemini-2.5-pro",
+            "gemini-2.5-flash",
+            "gemini-2.0-flash",
+            "gemini-1.5-flash",
+        ],
+        notes: "streamGenerateContent SSE; :generateContent fallback.",
+    },
+    {
+        id: "openai-compatible",
+        name: "OpenAI-compatible (custom)",
+        kind: "openai-chat",
+        chatEndpoint: undefined,
+        consoleURL: "",
+        envVars: [],
+        defaultModel: "gpt-3.5-turbo",
+        fallbackModels: [
+            "gpt-3.5-turbo",
+            "gpt-4o",
+            "llama-3.1-70b-versatile",
+            "mixtral-8x7b-32768",
+        ],
+        notes: "Stored baseURL + stored key only. Live /models authoritative.",
+    },
+];
+const BY_ID = Object.fromEntries(PROVIDERS.map((p) => [p.id, p]));
+export function getProvider(id) {
+    return BY_ID[id];
+}
+export function isProviderId(id) {
+    return getProvider(id) !== undefined;
+}
+export function providerKind(id) {
+    return getProvider(id).kind;
+}
+// Display label for errors/status (e.g. "Anthropic HTTP 401").
+export function providerLabel(id) {
+    const def = getProvider(id);
+    if (!def)
+        return String(id);
+    if (id === "opencode-zen")
+        return "Zen";
+    if (id === "openai-compatible")
+        return "Provider";
+    return def.name;
+}
+// Normalize a custom baseURL: trim whitespace/trailing slashes.
+export function normalizeBaseURL(raw) {
+    return raw.trim().replace(/\/+$/, "");
+}
+// openai-compatible chat endpoint: stored baseURL + /chat/completions
+// appended iff missing, trailing slashes trimmed.
+export function openaiCompatibleChatEndpoint(baseURL) {
+    const base = normalizeBaseURL(baseURL);
+    return base.endsWith("/chat/completions")
+        ? base
+        : `${base}/chat/completions`;
+}
+// Chat endpoint for a provider (openai-compatible needs stored baseURL).
+export function chatEndpointFor(id, storedBaseURL) {
+    const def = getProvider(id);
+    if (id === "openai-compatible") {
+        return openaiCompatibleChatEndpoint(storedBaseURL ?? "");
+    }
+    return def.chatEndpoint ?? "";
+}
+// Derive the models URL from a chat/completions endpoint
+// (mirrors zen.modelsUrl for OpenAI-kind providers).
+export function modelsUrlForEndpoint(endpoint) {
+    const suffix = "/chat/completions";
+    if (endpoint.endsWith(suffix)) {
+        return endpoint.slice(0, -suffix.length) + "/models";
+    }
+    return endpoint.replace(/\/+$/, "") + "/models";
+}
+// Models (validation/list) URL per provider.
+export function modelsUrlForProvider(id, storedBaseURL) {
+    if (id === "anthropic")
+        return "https://api.anthropic.com/v1/models";
+    if (id === "google-gemini")
+        return "https://generativelanguage.googleapis.com/v1beta/models";
+    return modelsUrlForEndpoint(chatEndpointFor(id, storedBaseURL));
+}
+// Mask a key for display: "…1234". Never the full key.
+export function maskKey(key) {
+    if (!key)
+        return "(no key)";
+    const last4 = key.slice(-4);
+    return `…${last4}`;
+}
+// Validate a custom baseURL: must be http(s). Returns error or null.
+export function validateBaseURL(raw) {
+    const s = raw.trim();
+    if (!s)
+        return "baseURL must be a non-empty string";
+    let u;
+    try {
+        u = new URL(s);
+    }
+    catch {
+        return `invalid URL: ${s}`;
+    }
+    if (u.protocol !== "http:" && u.protocol !== "https:") {
+        return `unsupported URL scheme (only http/https allowed): ${u.protocol}`;
+    }
+    return null;
+}