acmecode 1.0.0

package/dist/tui/src/markdown.js

@@ -0,0 +1,356 @@
+import { theme } from "./theme.js";
+import pc from "picocolors"; // Keep pc for some low-level things if needed, but primarily use theme
+/**
+ * Lightweight terminal markdown renderer.
+ * Converts common markdown syntax to ANSI-styled text for terminal display.
+ * Handles: headers, bold, italic, inline code, code blocks, lists, checkboxes, horizontal rules.
+ */
+export function renderMarkdown(input) {
+    const lines = input.split("\n");
+    const result = [];
+    let inCodeBlock = false;
+    let codeBlockLang = "";
+    let codeBuffer = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // ── Code block toggle ──
+        if (line.trimStart().startsWith("```")) {
+            if (!inCodeBlock) {
+                inCodeBlock = true;
+                codeBlockLang = line.trimStart().slice(3).trim();
+                codeBuffer = [];
+                continue;
+            }
+            else {
+                // End code block — render it
+                inCodeBlock = false;
+                if (codeBlockLang === "diff" || codeBlockLang === "patch") {
+                    // Diff-specific rendering — colored lines, no box border
+                    for (const codeLine of codeBuffer) {
+                        result.push(renderDiffLine(codeLine));
+                    }
+                }
+                else {
+                    const header = codeBlockLang
+                        ? theme.muted(`┌─ ${codeBlockLang} ${"─".repeat(Math.max(0, 36 - codeBlockLang.length))}`)
+                        : theme.muted(`┌${"─".repeat(40)}`);
+                    const footer = theme.muted(`└${"─".repeat(40)}`);
+                    result.push(header);
+                    for (const codeLine of codeBuffer) {
+                        result.push(theme.muted("│ ") + highlightCode(codeLine, codeBlockLang));
+                    }
+                    result.push(footer);
+                }
+                codeBlockLang = "";
+                codeBuffer = [];
+                continue;
+            }
+        }
+        if (inCodeBlock) {
+            codeBuffer.push(line);
+            continue;
+        }
+        // ── Horizontal rule ──
+        if (/^(\s*[-*_]){3,}\s*$/.test(line)) {
+            result.push(theme.muted("─".repeat(40)));
+            continue;
+        }
+        // ── Headers ──
+        const h1Match = line.match(/^# (.+)/);
+        if (h1Match) {
+            result.push("");
+            result.push(theme.highlight(theme.primary(`█ ${h1Match[1]}`)));
+            result.push(theme.muted("─".repeat(Math.min(40, (h1Match[1]?.length || 0) + 4))));
+            continue;
+        }
+        const h2Match = line.match(/^## (.+)/);
+        if (h2Match) {
+            result.push("");
+            result.push(theme.highlight(theme.info(`▌ ${h2Match[1]}`)));
+            continue;
+        }
+        const h3Match = line.match(/^### (.+)/);
+        if (h3Match) {
+            result.push(theme.highlight(theme.secondary(`  ▸ ${h3Match[1]}`)));
+            continue;
+        }
+        const h4Match = line.match(/^#### (.+)/);
+        if (h4Match) {
+            result.push(theme.highlight(`    ${h4Match[1]}`));
+            continue;
+        }
+        // ── Checkbox lists ──
+        const checkMatch = line.match(/^(\s*)- \[([ xX])\] (.+)/);
+        if (checkMatch) {
+            const indent = checkMatch[1] || "";
+            const checked = checkMatch[2].toLowerCase() === "x";
+            const text = formatInline(checkMatch[3]);
+            const icon = checked ? theme.success("✔") : theme.muted("○");
+            result.push(`${indent}  ${icon} ${checked ? theme.muted(pc.strikethrough(text)) : text}`);
+            continue;
+        }
+        // ── Unordered lists ──
+        const ulMatch = line.match(/^(\s*)[-*] (.+)/);
+        if (ulMatch) {
+            const indent = ulMatch[1] || "";
+            const text = formatInline(ulMatch[2]);
+            result.push(`${indent}  ${theme.primary("•")} ${text}`);
+            continue;
+        }
+        // ── Ordered lists ──
+        const olMatch = line.match(/^(\s*)(\d+)\. (.+)/);
+        if (olMatch) {
+            const indent = olMatch[1] || "";
+            const num = olMatch[2];
+            const text = formatInline(olMatch[3]);
+            result.push(`${indent}  ${theme.primary(num + ".")} ${text}`);
+            continue;
+        }
+        // ── Blockquotes ──
+        const bqMatch = line.match(/^>\s?(.*)/);
+        if (bqMatch) {
+            result.push(`  ${theme.muted("│")} ${theme.muted(pc.italic(bqMatch[1] || ""))}`);
+            continue;
+        }
+        // ── Regular text with inline formatting ──
+        result.push(formatInline(line));
+    }
+    // Handle unclosed code block
+    if (inCodeBlock && codeBuffer.length > 0) {
+        result.push(theme.muted(`┌${"─".repeat(40)}`));
+        for (const codeLine of codeBuffer) {
+            result.push(theme.muted("│ ") + highlightCode(codeLine, codeBlockLang));
+        }
+        result.push(theme.muted(`└${"─".repeat(40)}`));
+    }
+    return result.join("\n");
+}
+/**
+ * Format inline markdown: bold, italic, inline code, strikethrough, links
+ */
+function formatInline(text) {
+    // Inline code (must be first to prevent inner formatting)
+    text = text.replace(/`([^`]+)`/g, (_, code) => theme.warning(pc.bgBlack(` ${code} `)));
+    // Bold + italic
+    text = text.replace(/\*\*\*(.+?)\*\*\*/g, (_, t) => theme.highlight(pc.italic(t)));
+    // Bold
+    text = text.replace(/\*\*(.+?)\*\*/g, (_, t) => theme.highlight(t));
+    // Italic
+    text = text.replace(/\*(.+?)\*/g, (_, t) => pc.italic(t));
+    text = text.replace(/_(.+?)_/g, (_, t) => pc.italic(t));
+    // Strikethrough
+    text = text.replace(/~~(.+?)~~/g, (_, t) => theme.muted(pc.strikethrough(t)));
+    // Links [text](url) → text (url)
+    text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, label, url) => `${pc.underline(theme.info(label))} ${theme.muted(`(${url})`)}`);
+    return text;
+}
+// ── Syntax highlighting keywords ──
+const KEYWORDS = new Set([
+    // JS/TS
+    "const",
+    "let",
+    "var",
+    "function",
+    "return",
+    "if",
+    "else",
+    "for",
+    "while",
+    "do",
+    "switch",
+    "case",
+    "break",
+    "continue",
+    "new",
+    "this",
+    "class",
+    "extends",
+    "super",
+    "import",
+    "export",
+    "from",
+    "default",
+    "async",
+    "await",
+    "try",
+    "catch",
+    "finally",
+    "throw",
+    "typeof",
+    "instanceof",
+    "in",
+    "of",
+    "yield",
+    "delete",
+    "void",
+    // Python
+    "def",
+    "lambda",
+    "pass",
+    "raise",
+    "with",
+    "as",
+    "global",
+    "nonlocal",
+    "assert",
+    "elif",
+    "except",
+    "is",
+    "not",
+    "and",
+    "or",
+    "True",
+    "False",
+    "None",
+    "print",
+    // Common
+    "true",
+    "false",
+    "null",
+    "undefined",
+    "nil",
+]);
+const TYPES = new Set([
+    "string",
+    "number",
+    "boolean",
+    "object",
+    "any",
+    "void",
+    "never",
+    "unknown",
+    "int",
+    "float",
+    "double",
+    "char",
+    "long",
+    "short",
+    "byte",
+    "bool",
+    "String",
+    "Number",
+    "Boolean",
+    "Array",
+    "Object",
+    "Map",
+    "Set",
+    "Promise",
+    "Record",
+    "Partial",
+    "Required",
+    "Readonly",
+    "interface",
+    "type",
+    "enum",
+    "struct",
+    "impl",
+    "trait",
+    "pub",
+    "fn",
+    "mod",
+    "use",
+    "crate",
+]);
+/**
+ * Simple token-based syntax highlighter for code blocks.
+ */
+function highlightCode(line, _lang) {
+    // Line-level comment detection
+    const trimmed = line.trimStart();
+    if (trimmed.startsWith("//") ||
+        trimmed.startsWith("#") ||
+        trimmed.startsWith("--")) {
+        return theme.muted(pc.italic(line));
+    }
+    let result = "";
+    let i = 0;
+    while (i < line.length) {
+        const ch = line[i];
+        // ── String literals ──
+        if (ch === '"' || ch === "'" || ch === "`") {
+            const quote = ch;
+            let end = i + 1;
+            while (end < line.length && line[end] !== quote) {
+                if (line[end] === "\\")
+                    end++; // skip escaped
+                end++;
+            }
+            end = Math.min(end + 1, line.length);
+            result += theme.success(line.slice(i, end));
+            i = end;
+            continue;
+        }
+        // ── Numbers ──
+        if (/\d/.test(ch) &&
+            (i === 0 || /[\s(,=:+\-*/<>[\]{}!&|^~%]/.test(line[i - 1] || " "))) {
+            let end = i;
+            while (end < line.length && /[\d.xXa-fA-FeEoObB_]/.test(line[end]))
+                end++;
+            result += theme.warning(line.slice(i, end));
+            i = end;
+            continue;
+        }
+        // ── Words (keywords/types/identifiers) ──
+        if (/[a-zA-Z_$@]/.test(ch)) {
+            let end = i;
+            while (end < line.length && /[a-zA-Z0-9_$]/.test(line[end]))
+                end++;
+            const word = line.slice(i, end);
+            if (KEYWORDS.has(word)) {
+                result += theme.secondary(word);
+            }
+            else if (TYPES.has(word)) {
+                result += theme.primary(word);
+            }
+            else {
+                result += word;
+            }
+            i = end;
+            continue;
+        }
+        // ── Operators/punctuation ──
+        if (/[(){}[\];,.<>+\-*/%=!&|^~?:]/.test(ch)) {
+            result += theme.muted(ch);
+            i++;
+            continue;
+        }
+        result += ch;
+        i++;
+    }
+    return result;
+}
+// ANSI truecolor background helpers (terminals supporting 24-bit color)
+function bgRgb(r, g, b, text) {
+    return `\x1b[48;2;${r};${g};${b}m${text}\x1b[49m`;
+}
+// Diff background colors — matching opencode's diffAddedBg / diffRemovedBg
+const DIFF_ADDED_BG = (t) => bgRgb(32, 48, 59, t); // #20303b deep teal-green
+const DIFF_REMOVED_BG = (t) => bgRgb(55, 34, 44, t); // #37222c deep rose-red
+/**
+ * Render a single line of a unified diff with appropriate colors.
+ * +  added lines   → green fg + deep green bg
+ * -  removed lines → red fg + deep red bg
+ * @@ hunk headers  → cyan
+ * --- / +++ file headers → bold dim
+ * context lines    → dim
+ */
+function renderDiffLine(line) {
+    if (line.startsWith("+++") || line.startsWith("---")) {
+        return theme.muted(theme.highlight(line));
+    }
+    if (line.startsWith("@@")) {
+        const match = line.match(/^(@@ .+? @@)(.*)/);
+        if (match) {
+            return theme.info(match[1]) + theme.muted(match[2] || "");
+        }
+        return theme.info(line);
+    }
+    if (line.startsWith("+")) {
+        return DIFF_ADDED_BG(theme.success(line));
+    }
+    if (line.startsWith("-")) {
+        return DIFF_REMOVED_BG(theme.danger(line));
+    }
+    // Context line
+    return theme.muted(line);
+}

package/dist/tui/src/theme.d.ts

@@ -0,0 +1,31 @@
+export interface ThemeColors {
+    primary: (text: string) => string;
+    secondary: (text: string) => string;
+    muted: (text: string) => string;
+    success: (text: string) => string;
+    danger: (text: string) => string;
+    warning: (text: string) => string;
+    info: (text: string) => string;
+    highlight: (text: string) => string;
+    border: string;
+    borderDim: string;
+    logo: string;
+    /** Hex color for the header card background */
+    bgHeader: string;
+    /** Hex color for the input card background */
+    bgInput: string;
+    /** Hex color for the accent bar on the left of the input */
+    accentIdle: string;
+    /** Hex color for the accent bar when generating */
+    accentBusy: string;
+}
+export declare function getTheme(): ThemeColors;
+export declare function setTheme(name: string): boolean;
+export declare function onThemeChange(listener: (name: string) => void): void;
+export declare function getThemeName(): string;
+export declare function listThemes(): string[];
+export declare const theme: ThemeColors;
+export declare function formatToolIcon(toolName: string): string;
+export declare function formatToolName(toolName: string): string;
+export declare function formatBorder(width: number, char?: string): string;
+export declare function formatKeyHint(key: string, label: string): string;

package/dist/tui/src/theme.js

@@ -0,0 +1,239 @@
+import pc from "picocolors";
+import { t } from "./i18n.js";
+import { loadThemeConfig, saveGlobalThemeConfig, } from "@acmecode/core/config/index.js";
+// Helper: ANSI 256-color foreground
+const c256 = (n) => (text) => `\x1b[38;5;${n}m${text}\x1b[0m`;
+// ── Built-in Themes ──
+const themes = {
+    dark: {
+        primary: pc.cyan,
+        secondary: pc.magenta,
+        muted: pc.gray,
+        success: pc.green,
+        danger: pc.red,
+        warning: pc.yellow,
+        info: pc.blue,
+        highlight: pc.bold,
+        border: "─",
+        borderDim: "┄",
+        logo: `${pc.cyan(pc.bold("AcmeCode"))} ${pc.gray("v1.0")}`,
+        bgHeader: "#141414",
+        bgInput: "#1e1e1e",
+        accentIdle: "cyan",
+        accentBusy: "yellow",
+    },
+    dracula: {
+        primary: c256(141), // purple
+        secondary: c256(212), // pink
+        muted: c256(103), // comment gray
+        success: c256(84), // green
+        danger: c256(203), // red
+        warning: c256(228), // yellow
+        info: c256(117), // cyan
+        highlight: pc.bold,
+        border: "─",
+        borderDim: "┄",
+        logo: `\x1b[38;5;141m\x1b[1mAcmeCode\x1b[0m \x1b[38;5;103mv1.0\x1b[0m`,
+        bgHeader: "#21222c",
+        bgInput: "#282a36",
+        accentIdle: "#bd93f9",
+        accentBusy: "#ffb86c",
+    },
+    tokyonight: {
+        primary: c256(111), // blue
+        secondary: c256(176), // magenta
+        muted: c256(60), // dark comment
+        success: c256(115), // green
+        danger: c256(210), // red
+        warning: c256(222), // yellow
+        info: c256(81), // cyan
+        highlight: pc.bold,
+        border: "─",
+        borderDim: "┄",
+        logo: `\x1b[38;5;111m\x1b[1mAcmeCode\x1b[0m \x1b[38;5;60mv1.0\x1b[0m`,
+        bgHeader: "#16161e",
+        bgInput: "#1a1b26",
+        accentIdle: "#7aa2f7",
+        accentBusy: "#e0af68",
+    },
+    nord: {
+        primary: c256(110), // frost blue
+        secondary: c256(139), // purple
+        muted: c256(59), // polar night
+        success: c256(108), // aurora green
+        danger: c256(174), // aurora red
+        warning: c256(179), // aurora yellow
+        info: c256(67), // frost darker
+        highlight: pc.bold,
+        border: "─",
+        borderDim: "┄",
+        logo: `\x1b[38;5;110m\x1b[1mAcmeCode\x1b[0m \x1b[38;5;59mv1.0\x1b[0m`,
+        bgHeader: "#2e3440",
+        bgInput: "#3b4252",
+        accentIdle: "#88c0d0",
+        accentBusy: "#ebcb8b",
+    },
+    catppuccin: {
+        primary: c256(183), // lavender
+        secondary: c256(211), // pink
+        muted: c256(244), // overlay
+        success: c256(120), // green
+        danger: c256(210), // red
+        warning: c256(223), // peach
+        info: c256(152), // teal
+        highlight: pc.bold,
+        border: "─",
+        borderDim: "┄",
+        logo: `\x1b[38;5;183m\x1b[1mAcmeCode\x1b[0m \x1b[38;5;244mv1.0\x1b[0m`,
+        bgHeader: "#1e1e2e",
+        bgInput: "#24273a",
+        accentIdle: "#cba6f7",
+        accentBusy: "#fab387",
+    },
+    monokai: {
+        primary: c256(81), // cyan
+        secondary: c256(148), // green
+        muted: c256(242), // comment
+        success: c256(148), // green
+        danger: c256(204), // pink/red
+        warning: c256(186), // yellow
+        info: c256(141), // purple
+        highlight: pc.bold,
+        border: "─",
+        borderDim: "┄",
+        logo: `\x1b[38;5;81m\x1b[1mAcmeCode\x1b[0m \x1b[38;5;242mv1.0\x1b[0m`,
+        bgHeader: "#1e1e1e",
+        bgInput: "#272822",
+        accentIdle: "#66d9e8",
+        accentBusy: "#e6db74",
+    },
+    gruvbox: {
+        primary: c256(214), // orange
+        secondary: c256(108), // aqua
+        muted: c256(243), // gray
+        success: c256(142), // green
+        danger: c256(167), // red
+        warning: c256(214), // orange
+        info: c256(108), // aqua
+        highlight: pc.bold,
+        border: "─",
+        borderDim: "┄",
+        logo: `\x1b[38;5;214m\x1b[1mAcmeCode\x1b[0m \x1b[38;5;243mv1.0\x1b[0m`,
+        bgHeader: "#1d2021",
+        bgInput: "#282828",
+        accentIdle: "#fabd2f",
+        accentBusy: "#fe8019",
+    },
+    everforest: {
+        primary: c256(108), // green
+        secondary: c256(175), // purple
+        muted: c256(243), // gray
+        success: c256(142), // green
+        danger: c256(167), // red
+        warning: c256(214), // yellow
+        info: c256(109), // blue
+        highlight: pc.bold,
+        border: "─",
+        borderDim: "┄",
+        logo: `\x1b[38;5;108m\x1b[1mAcmeCode\x1b[0m \x1b[38;5;243mv1.0\x1b[0m`,
+        bgHeader: "#1e2326",
+        bgInput: "#272e33",
+        accentIdle: "#a7c080",
+        accentBusy: "#e69875",
+    },
+    rosepine: {
+        primary: c256(189), // iris
+        secondary: c256(217), // rose
+        muted: c256(60), // muted
+        success: c256(115), // foam
+        danger: c256(210), // love
+        warning: c256(222), // gold
+        info: c256(116), // pine
+        highlight: pc.bold,
+        border: "─",
+        borderDim: "┄",
+        logo: `\x1b[38;5;189m\x1b[1mAcmeCode\x1b[0m \x1b[38;5;60mv1.0\x1b[0m`,
+        bgHeader: "#191724",
+        bgInput: "#1f1d2e",
+        accentIdle: "#c4a7e7",
+        accentBusy: "#ebbcba",
+    },
+    solarized: {
+        primary: c256(37), // cyan
+        secondary: c256(61), // violet
+        muted: c256(240), // base01
+        success: c256(64), // green
+        danger: c256(160), // red
+        warning: c256(136), // yellow
+        info: c256(33), // blue
+        highlight: pc.bold,
+        border: "─",
+        borderDim: "┄",
+        logo: `\x1b[38;5;37m\x1b[1mAcmeCode\x1b[0m \x1b[38;5;240mv1.0\x1b[0m`,
+        bgHeader: "#002731",
+        bgInput: "#00212b",
+        accentIdle: "#2aa198",
+        accentBusy: "#b58900",
+    },
+};
+// ── Active theme state ──
+let activeThemeName = loadThemeConfig();
+const listeners = [];
+export function getTheme() {
+    return themes[activeThemeName] || themes["dark"];
+}
+export function setTheme(name) {
+    if (themes[name]) {
+        activeThemeName = name;
+        saveGlobalThemeConfig(name);
+        listeners.forEach((l) => l(name));
+        return true;
+    }
+    return false;
+}
+export function onThemeChange(listener) {
+    listeners.push(listener);
+}
+export function getThemeName() {
+    return activeThemeName;
+}
+export function listThemes() {
+    return Object.keys(themes);
+}
+// ── Re-export active theme (backward compatible) ──
+export const theme = new Proxy({}, {
+    get(_target, prop) {
+        return getTheme()[prop];
+    },
+});
+// ── Formatting helpers ──
+export function formatToolIcon(toolName) {
+    const icons = {
+        read_file: "📖",
+        write_file: "📝",
+        run_command: "⚡",
+        list_dir: "📂",
+        edit_file: "✏️",
+        grep_search: "🔍",
+        webfetch: "🌐",
+        websearch: "🔎",
+        codesearch: "💻",
+        lsp: "🧠",
+        switch_mode: "⚙️",
+        batch: "📦",
+        browser_action: "🖥️",
+    };
+    return icons[toolName] || "🔧";
+}
+export function formatToolName(toolName) {
+    const key = `tool.${toolName}`;
+    const translated = t(key);
+    return translated !== key ? translated : toolName;
+}
+export function formatBorder(width, char) {
+    return (char || getTheme().border).repeat(width);
+}
+export function formatKeyHint(key, label) {
+    const t = getTheme();
+    return `${t.muted("[")}${t.primary(key)}${t.muted("]")} ${t.muted(label)}`;
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "acmecode",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "AI Coding Assistant CLI",
+  "main": "dist/cli/index.js",
+  "bin": {
+    "acmecode": "dist/cli/bin/acmecode.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/index.js",
+    "dev": "tsx bin/acmecode.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "ai": "^4.1.0",
+    "@ai-sdk/anthropic": "^1.1.0",
+    "@ai-sdk/deepinfra": "^0.1.0",
+    "@ai-sdk/google": "^1.2.0",
+    "@ai-sdk/groq": "^0.1.0",
+    "@ai-sdk/mistral": "^0.1.0",
+    "@ai-sdk/openai": "^1.1.0",
+    "@ai-sdk/xai": "^0.1.0",
+    "@openrouter/ai-sdk-provider": "^0.1.0",
+    "better-sqlite3": "^11.8.1",
+    "chalk": "^5.4.1",
+    "commander": "^14.0.3",
+    "dotenv": "^16.5.0",
+    "ink": "^6.8.0",
+    "react": "^19.2.4",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^25.3.0",
+    "@types/react": "^19.2.14",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/packages/cli/package.json

@@ -0,0 +1,25 @@
+{
+    "name": "@acmecode/cli",
+    "version": "1.0.0",
+    "type": "module",
+    "main": "dist/index.js",
+    "bin": {
+        "acmecode": "bin/acmecode.js"
+    },
+    "scripts": {
+        "build": "tsc",
+        "start": "node dist/index.js",
+        "dev": "tsx src/index.ts"
+    },
+    "dependencies": {
+        "@acmecode/core": "^1.0.0",
+        "@acmecode/tui": "^1.0.0",
+        "commander": "^14.0.3",
+        "ink": "^6.8.0",
+        "react": "^19.2.4"
+    },
+    "devDependencies": {
+        "@types/node": "^25.3.0",
+        "@types/react": "^19.2.14"
+    }
+}