@ikyyofc/gemini-cli 1.0.0

package/src/extensions.js

@@ -0,0 +1,195 @@
+// src/extensions.js — Extension manager (mirrors Gemini CLI extension system)
+import fs           from "fs";
+import path         from "path";
+import os           from "os";
+import { promisify } from "util";
+import { exec }     from "child_process";
+import { GLOBAL_DIR, CONTEXT_FILENAME, readWithImports } from "./memory.js";
+
+const execAsync  = promisify(exec);
+const EXT_DIR    = path.join(GLOBAL_DIR, "extensions");
+const CMD_DIR    = path.join(GLOBAL_DIR, "commands");
+
+// ─────────────────────────────────────────────────────────────────
+//  Extension manifest schema (gemini-extension.json)
+//  {
+//    "name": "my-ext",
+//    "version": "1.0.0",
+//    "description": "...",
+//    "contextFileName": "GEMINI.md",   // optional
+//    "commands": {                    // optional custom commands
+//      "cmd-name": {
+//        "description": "...",
+//        "prompt": "Do {{args}} for me"
+//      }
+//    },
+//    "enabled": true
+//  }
+// ─────────────────────────────────────────────────────────────────
+
+export function getExtensionDir() { return EXT_DIR; }
+export function getCommandDir()   { return CMD_DIR; }
+
+/** Load all enabled extensions, return their manifests + context dirs */
+export function loadExtensions() {
+    fs.mkdirSync(EXT_DIR, { recursive: true });
+    const extensions = [];
+
+    for (const name of fs.readdirSync(EXT_DIR)) {
+        const extPath  = path.join(EXT_DIR, name);
+        const manifest = path.join(extPath, "gemini-extension.json");
+        if (!fs.existsSync(manifest)) continue;
+
+        try {
+            const meta = JSON.parse(fs.readFileSync(manifest, "utf8"));
+            if (meta.enabled === false) continue;   // disabled
+
+            const contextFile = meta.contextFileName ?? CONTEXT_FILENAME;
+            const contextPath = path.join(extPath, contextFile);
+
+            extensions.push({
+                name:    meta.name ?? name,
+                version: meta.version ?? "0.0.0",
+                description: meta.description ?? "",
+                path:    extPath,
+                context: fs.existsSync(contextPath) ? contextPath : null,
+                commands: meta.commands ?? {},
+                raw: meta
+            });
+        } catch { /* skip malformed */ }
+    }
+
+    return extensions;
+}
+
+/** Collect extra context dirs from extensions for memory.js */
+export function getExtensionContextDirs(extensions) {
+    return extensions.map(e => e.path);
+}
+
+/** Build all custom commands from: extensions + ~/.gemini/commands/**  */
+export async function loadCustomCommands(extensions) {
+    const cmds = {};   // "namespace:name" → { description, prompt, source }
+
+    // 1. From extensions
+    for (const ext of extensions) {
+        for (const [cmdName, cmd] of Object.entries(ext.commands)) {
+            const key = `${ext.name}:${cmdName}`;
+            cmds[key] = { ...cmd, source: `extension:${ext.name}` };
+        }
+    }
+
+    // 2. From ~/.gemini/commands/<namespace>/<name>.toml
+    if (fs.existsSync(CMD_DIR)) {
+        for (const ns of fs.readdirSync(CMD_DIR)) {
+            const nsDir = path.join(CMD_DIR, ns);
+            if (!fs.statSync(nsDir).isDirectory()) continue;
+            for (const file of fs.readdirSync(nsDir)) {
+                if (!file.endsWith(".toml")) continue;
+                try {
+                    const { default: TOML } = await importToml();
+                    const raw  = fs.readFileSync(path.join(nsDir, file), "utf8");
+                    const parsed = TOML.parse(raw);
+                    const cmdName = file.replace(".toml", "");
+                    cmds[`${ns}:${cmdName}`] = { ...parsed, source: `commands/${ns}` };
+                } catch {}
+            }
+        }
+    }
+
+    return cmds;
+}
+
+/** Simple TOML loader (lazy import) */
+async function importToml() {
+    return import("toml");
+}
+
+// ─────────────────────────────────────────────────────────────────
+//  INSTALL / UNINSTALL / ENABLE / DISABLE / LIST
+// ─────────────────────────────────────────────────────────────────
+
+/**
+ * Install extension from:
+ *   - local path:  /path/to/my-ext
+ *   - git URL:     https://github.com/user/repo
+ */
+export async function installExtension(source) {
+    fs.mkdirSync(EXT_DIR, { recursive: true });
+
+    if (source.startsWith("http://") || source.startsWith("https://") || source.startsWith("git@")) {
+        // Git clone
+        const repoName = source.split("/").pop().replace(/\.git$/, "");
+        const destDir  = path.join(EXT_DIR, repoName);
+        if (fs.existsSync(destDir)) return { error: `Extension "${repoName}" already installed.` };
+        await execAsync(`git clone --depth 1 "${source}" "${destDir}"`);
+        const manifest = path.join(destDir, "gemini-extension.json");
+        if (!fs.existsSync(manifest)) {
+            // Auto-create minimal manifest
+            fs.writeFileSync(manifest, JSON.stringify({ name: repoName, version: "0.0.0", enabled: true }, null, 2));
+        } else {
+            // Ensure enabled
+            const meta = JSON.parse(fs.readFileSync(manifest, "utf8"));
+            meta.enabled = true;
+            fs.writeFileSync(manifest, JSON.stringify(meta, null, 2));
+        }
+        return { ok: true, name: repoName, path: destDir };
+
+    } else {
+        // Local path — create symlink or copy
+        const src  = path.resolve(source);
+        if (!fs.existsSync(src)) return { error: `Path not found: ${src}` };
+        const manifest = path.join(src, "gemini-extension.json");
+        if (!fs.existsSync(manifest)) return { error: `No gemini-extension.json found in: ${src}` };
+        const meta = JSON.parse(fs.readFileSync(manifest, "utf8"));
+        const name = meta.name ?? path.basename(src);
+        const dest = path.join(EXT_DIR, name);
+        if (fs.existsSync(dest)) return { error: `Extension "${name}" already installed.` };
+        // Copy (not symlink, for portability)
+        await execAsync(`cp -r "${src}" "${dest}"`);
+        meta.enabled = true;
+        fs.writeFileSync(path.join(dest, "gemini-extension.json"), JSON.stringify(meta, null, 2));
+        return { ok: true, name, path: dest };
+    }
+}
+
+export async function uninstallExtension(name) {
+    const dir = path.join(EXT_DIR, name);
+    if (!fs.existsSync(dir)) return { error: `Extension "${name}" not found.` };
+    await execAsync(`rm -rf "${dir}"`);
+    return { ok: true };
+}
+
+export function enableExtension(name, enable = true) {
+    const manifest = path.join(EXT_DIR, name, "gemini-extension.json");
+    if (!fs.existsSync(manifest)) return { error: `Extension "${name}" not found.` };
+    const meta = JSON.parse(fs.readFileSync(manifest, "utf8"));
+    meta.enabled = enable;
+    fs.writeFileSync(manifest, JSON.stringify(meta, null, 2));
+    return { ok: true };
+}
+
+export function listExtensions() {
+    fs.mkdirSync(EXT_DIR, { recursive: true });
+    const results = [];
+    for (const name of fs.readdirSync(EXT_DIR)) {
+        const manifest = path.join(EXT_DIR, name, "gemini-extension.json");
+        if (!fs.existsSync(manifest)) continue;
+        try {
+            const meta = JSON.parse(fs.readFileSync(manifest, "utf8"));
+            results.push({ name: meta.name ?? name, version: meta.version ?? "?", enabled: meta.enabled !== false, description: meta.description ?? "" });
+        } catch {}
+    }
+    return results;
+}
+
+export async function updateExtension(name) {
+    const dir = path.join(EXT_DIR, name);
+    if (!fs.existsSync(dir)) return { error: `Extension "${name}" not found.` };
+    try {
+        await execAsync(`git -C "${dir}" pull`);
+        return { ok: true };
+    } catch (e) {
+        return { error: e.message };
+    }
+}

package/src/gemini.js

@@ -0,0 +1,119 @@
+// src/gemini.js — Gemini API client with native function calling
+import axios from "axios";
+import { fileTypeFromBuffer } from "file-type";
+
+const CONFIG = {
+    URL:   "https://us-central1-gemmy-ai-bdc03.cloudfunctions.net/gemini",
+    MODEL: "gemini-pro-latest",
+    HEADERS: {
+        "User-Agent":       "okhttp/5.3.2",
+        "Accept-Encoding":  "gzip",
+        "content-type":     "application/json; charset=UTF-8"
+    }
+};
+
+const SUPPORTED_MIMES = new Set([
+    "image/jpeg","image/png","image/gif","image/webp","image/heic","image/heif",
+    "video/mp4","video/mpeg","video/mov","video/avi","video/x-flv","video/mpg",
+    "video/webm","video/wmv","video/3gpp",
+    "audio/wav","audio/mp3","audio/aiff","audio/aac","audio/ogg","audio/flac",
+    "audio/mpeg","audio/ogg; codecs=opus",
+    "application/pdf","text/plain","text/html","text/css","text/javascript",
+    "text/x-typescript","text/csv","text/markdown","text/x-python",
+    "application/json","application/xml","application/rtf"
+]);
+
+async function getToken() {
+    const { data } = await axios.post(
+        "https://www.googleapis.com/identitytoolkit/v3/relyingparty/signupNewUser?key=AIzaSyAxof8_SbpDcww38NEQRhNh0Pzvbphh-IQ",
+        { clientType: "CLIENT_TYPE_ANDROID" },
+        { headers: {
+            "User-Agent":       "Dalvik/2.1.0 (Linux; U; Android 12; SM-S9280 Build/AP3A.240905.015.A2)",
+            "Content-Type":     "application/json",
+            "X-Android-Package":"com.jetkite.gemmy",
+            "X-Android-Cert":   "037CD2976D308B4EFD63EC63C48DC6E7AB7E5AF2",
+            "X-Firebase-GMPID": "1:652803432695:android:c4341db6033e62814f33f2"
+        }}
+    );
+    return data.idToken;
+}
+
+/**
+ * Core API call — supports:
+ *   - plain chat (messages only)
+ *   - file attachment (fileBuffer)
+ *   - native function calling (tools = [{ functionDeclarations: [...] }])
+ *   - function responses in history (parts with functionCall / functionResponse)
+ */
+export async function callGemini({ messages = [], fileBuffer = null, tools = null, systemInstruction = null } = {}) {
+    const token = await getToken();
+
+    // Separate system message
+    const sysMsg = messages.find(m => m.role === "system");
+    const sysText = systemInstruction
+        ?? (sysMsg ? (typeof sysMsg.content === "string" ? sysMsg.content : sysMsg.parts?.[0]?.text ?? "") : null);
+
+    // Build contents array — support both {role,content} and {role,parts} formats
+    const contents = messages
+        .filter(m => m.role !== "system")
+        .map(m => {
+            if (m.parts) {
+                // Already in Gemini parts format (used for functionCall / functionResponse turns)
+                return { role: m.role === "assistant" ? "model" : m.role, parts: m.parts };
+            }
+            return {
+                role: m.role === "assistant" ? "model" : m.role,
+                parts: [{ text: typeof m.content === "string" ? m.content : JSON.stringify(m.content) }]
+            };
+        });
+
+    // Attach file to last user message if provided
+    if (fileBuffer) {
+        const result = await fileTypeFromBuffer(fileBuffer);
+        const mimeType = result?.mime ?? "application/octet-stream";
+        if (!SUPPORTED_MIMES.has(mimeType)) throw new Error(`Unsupported file type: ${mimeType}`);
+        const filePart = { inlineData: { mimeType, data: fileBuffer.toString("base64") } };
+        const last = contents[contents.length - 1];
+        if (last?.role === "user") last.parts.push(filePart);
+        else contents.push({ role: "user", parts: [filePart] });
+    }
+
+    const payload = {
+        model: CONFIG.MODEL,
+        request: {
+            contents,
+            generationConfig: {
+                thinkingConfig: { thinkingLevel: "HIGH" },
+                temperature: 0
+            },
+            safetySettings: [
+                { category: "HARM_CATEGORY_HARASSMENT",        threshold: "BLOCK_NONE" },
+                { category: "HARM_CATEGORY_HATE_SPEECH",       threshold: "BLOCK_NONE" },
+                { category: "HARM_CATEGORY_SEXUALLY_EXPLICIT", threshold: "BLOCK_NONE" },
+                { category: "HARM_CATEGORY_DANGEROUS_CONTENT", threshold: "BLOCK_NONE" }
+            ],
+            // ── Native function calling ──────────────────────────────────────
+            ...(tools?.length && { tools }),
+            // ── System instruction ───────────────────────────────────────────
+            ...(sysText && { systemInstruction: { role: "user", parts: [{ text: sysText }] } })
+        },
+        stream: false
+    };
+
+    const { data } = await axios.post(CONFIG.URL, payload, {
+        headers: { ...CONFIG.HEADERS, authorization: `Bearer ${token}` }
+    });
+
+    if (!data?.candidates?.length) throw new Error("No response candidates from API");
+
+    const candidate = data.candidates[0];
+    const parts     = candidate.content?.parts ?? [];
+
+    return { parts, candidate, raw: data };
+}
+
+/** Convenience: plain text chat (no tools) */
+export async function chat(messages = [], fileBuffer = null) {
+    const { parts } = await callGemini({ messages, fileBuffer });
+    return parts.map(p => p.text ?? "").join("");
+}

package/src/memory.js

@@ -0,0 +1,102 @@
+// src/memory.js — GEMINI.md hierarchical context loader (mirrors Gemini CLI)
+import fs   from "fs";
+import path from "path";
+import os   from "os";
+
+export const CONTEXT_FILENAME = "GEMINI.md";
+export const GLOBAL_DIR       = path.join(os.homedir(), ".gemini");
+export const GLOBAL_CONTEXT   = path.join(GLOBAL_DIR, CONTEXT_FILENAME);
+
+/**
+ * Load all GEMINI.md files in order (same as Gemini CLI):
+ *  1. ~/.gemini/GEMINI.md           — global user instructions
+ *  2. Extensions' GEMINI.md        — loaded separately by extensions.js
+ *  3. Project root → CWD          — walk up from CWD to .git root
+ *
+ * Supports @./path/to/other.md imports (recursive).
+ */
+export function loadMemory(extraDirs = []) {
+    const loaded = [];   // { file, content }
+
+    // 1. Global
+    if (fs.existsSync(GLOBAL_CONTEXT)) {
+        loaded.push({ file: GLOBAL_CONTEXT, content: readWithImports(GLOBAL_CONTEXT) });
+    }
+
+    // 2. Extra dirs (extensions inject their GEMINI.md here)
+    for (const dir of extraDirs) {
+        const p = path.join(dir, CONTEXT_FILENAME);
+        if (fs.existsSync(p)) {
+            loaded.push({ file: p, content: readWithImports(p) });
+        }
+    }
+
+    // 3. Walk from CWD up to git root (or filesystem root)
+    const chain = walkUpToRoot(process.cwd());
+    // Reverse so parent-most context loads first, CWD context last (highest priority)
+    for (const dir of chain.reverse()) {
+        const p = path.join(dir, CONTEXT_FILENAME);
+        if (fs.existsSync(p)) {
+            loaded.push({ file: p, content: readWithImports(p) });
+        }
+    }
+
+    return loaded;
+}
+
+/** Concatenate all loaded context into one string for the system prompt */
+export function buildContextString(loaded) {
+    if (!loaded.length) return null;
+    return loaded
+        .map(({ file, content }) => `<!-- context: ${file} -->\n${content}`)
+        .join("\n\n");
+}
+
+/** Walk up from dir to git root (or fs root), return all dirs in path */
+function walkUpToRoot(startDir) {
+    const dirs = [];
+    let current = startDir;
+    while (true) {
+        dirs.push(current);
+        const parent = path.dirname(current);
+        if (parent === current) break; // filesystem root
+        // Stop at git root
+        if (fs.existsSync(path.join(current, ".git"))) break;
+        current = parent;
+    }
+    return dirs;
+}
+
+/** Read file and resolve @./import.md directives recursively */
+export function readWithImports(filePath, depth = 0) {
+    if (depth > 10 || !fs.existsSync(filePath)) return "";
+    const src = fs.readFileSync(filePath, "utf8");
+    return src.replace(/^@(\.\/[^\s]+\.md)$/gm, (_, importPath) => {
+        const resolved = path.resolve(path.dirname(filePath), importPath);
+        return readWithImports(resolved, depth + 1);
+    });
+}
+
+// ─────────────────────────────────────────────────────────────────
+//  /memory commands
+// ─────────────────────────────────────────────────────────────────
+
+export function memoryShow(loaded) {
+    if (!loaded.length) return "(no GEMINI.md files loaded)";
+    return loaded.map(({ file, content }) =>
+        `\n${"═".repeat(60)}\n📄 ${file}\n${"═".repeat(60)}\n${content}`
+    ).join("\n");
+}
+
+export function memoryAdd(text) {
+    fs.mkdirSync(GLOBAL_DIR, { recursive: true });
+    const existing = fs.existsSync(GLOBAL_CONTEXT) ? fs.readFileSync(GLOBAL_CONTEXT, "utf8") : "";
+    const sep = existing.endsWith("\n") ? "" : "\n";
+    fs.appendFileSync(GLOBAL_CONTEXT, `${sep}\n${text}\n`, "utf8");
+    return `Appended to ${GLOBAL_CONTEXT}`;
+}
+
+export function ensureGlobalDir() {
+    fs.mkdirSync(path.join(GLOBAL_DIR, "extensions"), { recursive: true });
+    fs.mkdirSync(path.join(GLOBAL_DIR, "commands"),   { recursive: true });
+}

package/src/renderer.js

@@ -0,0 +1,202 @@
+// src/renderer.js — Terminal rendering (markdown, syntax, boxes, UI)
+import chalk from "chalk";
+
+// ─────────────────────────────────────────────────────────────────
+//  Syntax highlighting
+// ─────────────────────────────────────────────────────────────────
+const KW = {
+    js:  /\b(const|let|var|function|return|if|else|for|while|do|switch|case|break|continue|new|this|class|extends|import|export|default|async|await|try|catch|finally|throw|typeof|instanceof|of|in|null|undefined|true|false|void|delete|yield|from|static|super|get|set)\b/g,
+    ts:  /\b(const|let|var|function|return|if|else|for|while|switch|case|class|extends|import|export|default|async|await|try|catch|type|interface|enum|implements|declare|readonly|abstract|as|keyof|never|any|string|number|boolean|null|undefined|true|false)\b/g,
+    py:  /\b(def|class|return|if|elif|else|for|while|import|from|as|with|try|except|finally|raise|pass|break|continue|and|or|not|in|is|None|True|False|lambda|yield|global|async|await)\b/g,
+    go:  /\b(func|return|if|else|for|range|switch|var|const|type|struct|interface|import|package|defer|go|chan|map|make|new|nil|true|false)\b/g,
+    sh:  /\b(if|then|else|elif|fi|for|while|do|done|case|esac|function|return|exit|export|echo|local|read|source|alias)\b/g,
+    rs:  /\b(fn|let|mut|return|if|else|for|match|use|mod|pub|struct|enum|impl|trait|type|const|static|async|await|true|false|None|Some|Ok|Err)\b/g,
+};
+const LANGMAP = { javascript:"js",js:"js",typescript:"ts",ts:"ts",python:"py",py:"py",go:"go",golang:"go",rust:"rs",rs:"rs",bash:"sh",sh:"sh",shell:"sh",zsh:"sh" };
+
+function highlight(code, lang = "") {
+    const l = LANGMAP[lang.toLowerCase()] || "";
+    let r = code;
+    const saved = [];
+    const save = s => { const id = `\x00${saved.length}\x00`; saved.push(s); return id; };
+
+    // Comments
+    r = r.replace(/(\/\/.*$|#.*$|\/\*[\s\S]*?\*\/)/gm, m => save(chalk.hex("#6A9955").italic(m)));
+    // Strings
+    r = r.replace(/("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`)/g, m => save(chalk.hex("#CE9178")(m)));
+    // Keywords
+    if (KW[l]) r = r.replace(KW[l], m => save(chalk.hex("#569CD6")(m)));
+    // Numbers
+    r = r.replace(/\b(\d+\.?\d*)\b/g, m => save(chalk.hex("#B5CEA8")(m)));
+    // Function calls
+    r = r.replace(/\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*(?=\()/g, m => save(chalk.hex("#DCDCAA")(m)));
+    // Restore
+    return r.replace(/\x00(\d+)\x00/g, (_, i) => saved[parseInt(i)]);
+}
+
+// ─────────────────────────────────────────────────────────────────
+//  Markdown → terminal
+// ─────────────────────────────────────────────────────────────────
+export function renderMarkdown(text) {
+    let r = text;
+
+    // Fenced code blocks
+    r = r.replace(/```(\w*)\n?([\s\S]*?)```/g, (_, lang, code) => {
+        const hl   = highlight(code.trim(), lang);
+        const lbl  = lang ? chalk.hex("#858585")(` ${lang} `) : "";
+        const top  = chalk.hex("#3C3C3C")("┌" + "─".repeat(58)) + lbl;
+        const bot  = chalk.hex("#3C3C3C")("└" + "─".repeat(59));
+        const body = hl.split("\n").map(l => chalk.hex("#3C3C3C")("│ ") + l).join("\n");
+        return `\n${top}\n${body}\n${bot}\n`;
+    });
+
+    // Inline code
+    r = r.replace(/`([^`\n]+)`/g, (_, c) => chalk.hex("#CE9178").bgHex("#2A2A2A")(` ${c} `));
+
+    // Headers
+    r = r.replace(/^### (.+)$/gm, (_, t) => chalk.hex("#DCDCAA").bold(`  ◆ ${t}`));
+    r = r.replace(/^## (.+)$/gm,  (_, t) => chalk.hex("#4EC9B0").bold(`\n  ◈ ${t}`));
+    r = r.replace(/^# (.+)$/gm,   (_, t) => chalk.hex("#569CD6").bold.underline(`\n  ${t}`));
+
+    // Bold / italic
+    r = r.replace(/\*\*\*(.+?)\*\*\*/g, (_, t) => chalk.bold.italic(t));
+    r = r.replace(/\*\*(.+?)\*\*/g,     (_, t) => chalk.bold(t));
+    r = r.replace(/\*(.+?)\*/g,          (_, t) => chalk.italic(t));
+
+    // Blockquotes
+    r = r.replace(/^> (.+)$/gm, (_, t) => chalk.hex("#6A9955")(`  ▌ ${t}`));
+
+    // Lists
+    r = r.replace(/^(\s*)[*\-+] (.+)$/gm, (_, i, t) => `${i}${chalk.hex("#569CD6")("◆")} ${t}`);
+    r = r.replace(/^(\s*)(\d+)\. (.+)$/gm, (_, i, n, t) => `${i}${chalk.hex("#569CD6").bold(n+".")} ${t}`);
+
+    // HR
+    r = r.replace(/^---+$/gm, chalk.hex("#3C3C3C")("─".repeat(58)));
+
+    // Links
+    r = r.replace(/\[(.+?)\]\((.+?)\)/g, (_, txt, url) =>
+        chalk.bold(txt) + " " + chalk.hex("#858585").dim(`(${url})`)
+    );
+
+    return r;
+}
+
+// ─────────────────────────────────────────────────────────────────
+//  Box printers
+// ─────────────────────────────────────────────────────────────────
+const W = 60;
+
+export function printUser(text) {
+    process.stdout.write(
+        "\n" +
+        chalk.hex("#569CD6").bold("  ╭─ You " + "─".repeat(W - 8)) + "\n" +
+        chalk.hex("#569CD6")("  │ ") + chalk.white(text) + "\n" +
+        chalk.hex("#569CD6")("  ╰" + "─".repeat(W)) + "\n"
+    );
+}
+
+export function printAssistant(text) {
+    process.stdout.write(
+        "\n" + chalk.hex("#4EC9B0").bold("  ╭─ Gemini " + "─".repeat(W - 10)) + "\n"
+    );
+    renderMarkdown(text).split("\n").forEach(line =>
+        process.stdout.write(chalk.hex("#4EC9B0")("  │ ") + line + "\n")
+    );
+    process.stdout.write(chalk.hex("#4EC9B0")("  ╰" + "─".repeat(W)) + "\n\n");
+}
+
+export function printError(msg) {
+    process.stdout.write("\n" + chalk.hex("#F44747")("  ✖ ") + chalk.hex("#CE9178")(msg) + "\n\n");
+}
+export function printInfo(msg) {
+    process.stdout.write(chalk.hex("#858585")("  ℹ ") + chalk.hex("#6A9955")(msg) + "\n");
+}
+export function printSuccess(msg) {
+    process.stdout.write(chalk.hex("#4EC9B0")("  ✔ ") + chalk.hex("#4EC9B0")(msg) + "\n");
+}
+export function printWarning(msg) {
+    process.stdout.write(chalk.hex("#DCDCAA")("  ⚠ ") + chalk.hex("#DCDCAA")(msg) + "\n");
+}
+
+// ─────────────────────────────────────────────────────────────────
+//  Welcome screen
+// ─────────────────────────────────────────────────────────────────
+export function renderWelcome(memCount = 0, extCount = 0, cmdCount = 0) {
+    return [
+        "",
+        chalk.hex("#4EC9B0").bold("   ██████╗ ███████╗███╗   ███╗██╗███╗   ██╗██╗"),
+        chalk.hex("#4EC9B0").bold("  ██╔════╝ ██╔════╝████╗ ████║██║████╗  ██║██║"),
+        chalk.hex("#569CD6").bold("  ██║  ███╗█████╗  ██╔████╔██║██║██╔██╗ ██║██║"),
+        chalk.hex("#569CD6").bold("  ██║   ██║██╔══╝  ██║╚██╔╝██║██║██║╚██╗██║██║"),
+        chalk.hex("#DCDCAA").bold("  ╚██████╔╝███████╗██║ ╚═╝ ██║██║██║ ╚████║██║"),
+        chalk.hex("#858585")      ("   ╚═════╝ ╚══════╝╚═╝     ╚═╝╚═╝╚═╝  ╚═══╝╚═╝"),
+        "",
+        chalk.hex("#858585")("  ╔═══════════════════════════════════════════════════════╗"),
+        chalk.hex("#858585")("  ║ ") + chalk.hex("#4EC9B0")("  AI Agent CLI") + chalk.hex("#858585")(" · ") + chalk.hex("#DCDCAA")("native function calling") + chalk.hex("#858585")(" · ") + chalk.hex("#C586C0")("Gemini Pro  ") + chalk.hex("#858585")(" ║"),
+        chalk.hex("#858585")("  ╚═══════════════════════════════════════════════════════╝"),
+        "",
+        chalk.hex("#6A9955")(
+            `  Context files: ${memCount}  ·  Extensions: ${extCount}  ·  Custom commands: ${cmdCount}`
+        ),
+        chalk.hex("#858585")(`  Type ${chalk.hex("#CE9178")("/help")} for all commands`),
+        "",
+    ].join("\n");
+}
+
+// ─────────────────────────────────────────────────────────────────
+//  Help screen
+// ─────────────────────────────────────────────────────────────────
+export function renderHelp(customCommands = {}) {
+    const builtIn = [
+        ["/agent",              "Toggle AGENT (ReAct loop) ↔ CHAT mode"],
+        ["/yolo",               "Toggle auto-approve all tool actions"],
+        ["/memory show",        "Show all loaded GEMINI.md context files"],
+        ["/memory reload",      "Reload all GEMINI.md files from disk"],
+        ["/memory add <text>",  "Append text to ~/.gemini/GEMINI.md"],
+        ["/ext list",           "List installed extensions"],
+        ["/ext install <src>",  "Install extension (path or git URL)"],
+        ["/ext uninstall <n>",  "Uninstall extension by name"],
+        ["/ext enable <name>",  "Enable an extension"],
+        ["/ext disable <name>", "Disable an extension"],
+        ["/ext update <name>",  "Pull latest from git source"],
+        ["/file <path>",        "Attach file to next message"],
+        ["/system <text>",      "Set session system instruction"],
+        ["/history",            "Show conversation turns"],
+        ["/export <file>",      "Export history to JSON"],
+        ["/cd <path>",          "Change working directory"],
+        ["/cwd",                "Show working directory"],
+        ["/new  /clear",        "Reset conversation"],
+        ["/model",              "Show model & config info"],
+        ["/help",               "Show this help"],
+        ["/exit  /quit",        "Exit Gemini"],
+    ];
+
+    const lines = [
+        "",
+        chalk.hex("#569CD6").bold("  ┌─ BUILT-IN COMMANDS ─────────────────────────────────────┐"),
+        ...builtIn.map(([cmd, desc]) =>
+            chalk.hex("#569CD6")("  │ ") +
+            chalk.hex("#CE9178").bold(cmd.padEnd(26)) +
+            chalk.hex("#858585")(desc.padEnd(36)) +
+            chalk.hex("#569CD6")("│")
+        ),
+        chalk.hex("#569CD6")("  └────────────────────────────────────────────────────────┘"),
+    ];
+
+    const cmds = Object.entries(customCommands);
+    if (cmds.length) {
+        lines.push("", chalk.hex("#C586C0").bold("  ┌─ CUSTOM COMMANDS ─────────────────────────────────────────┐"));
+        cmds.forEach(([key, cmd]) => {
+            lines.push(
+                chalk.hex("#C586C0")("  │ ") +
+                chalk.hex("#DCDCAA").bold(("/" + key).padEnd(28)) +
+                chalk.hex("#858585")((cmd.description ?? "").padEnd(34)) +
+                chalk.hex("#C586C0")("│")
+            );
+        });
+        lines.push(chalk.hex("#C586C0")("  └───────────────────────────────────────────────────────────┘"));
+    }
+
+    lines.push("", chalk.hex("#6A9955")("  Tip: /yolo skips all confirmations  ·  Ctrl+C to cancel  ·  Ctrl+D to exit"), "");
+    return lines.join("\n");
+}