@nanhara/hara 0.0.1 → 0.33.0

package/dist/tui/InputBox.js

@@ -0,0 +1,208 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+// The framed input box (ink): a top border carrying the session name in the right corner, the
+// prompt line in the middle, and a bottom border carrying the approval modes + token usage +
+// concurrency. Composed from <Text> rows (no ink border fork needed) so the title sits exactly
+// where we want it. Pure-ish: pass `width` to make rendering deterministic in tests.
+import { Box, Text, useInput, useStdout } from "ink";
+import { useMemo, useState } from "react";
+import { fileCandidates } from "../context/mentions.js";
+import { imagePathFromPaste } from "../images.js";
+export const MODES = ["suggest", "auto-edit", "full-auto", "plan"];
+export const nextMode = (m) => MODES[(MODES.indexOf(m) + 1) % MODES.length];
+const tok = (n) => (n >= 1000 ? `${(n / 1000).toFixed(1)}k` : `${n}`);
+function TopBorder({ name, width }) {
+    const labelLen = name.length + 2; // "⏺ " + name
+    const left = Math.max(2, width - labelLen - 3);
+    return (_jsxs(Box, { children: [_jsxs(Text, { dimColor: true, children: ["─".repeat(left), " "] }), _jsx(Text, { color: "cyan", children: "\u23FA" }), _jsxs(Text, { bold: true, children: [" ", name] }), _jsx(Text, { dimColor: true, children: " \u2500" })] }));
+}
+// Bottom border carries token usage + concurrency at the right corner (modes moved to ModeBar below).
+function BottomBorder({ s, width }) {
+    const usage = `↑${tok(s.input)} ↓${tok(s.output)}${s.ctxPct > 0 ? ` · ctx ${s.ctxPct}%` : ""}`;
+    const label = s.agents > 0 ? `${usage} · ⛁${s.agents}` : `${usage} · ⛁ idle`;
+    const left = Math.max(2, width - label.length - 3);
+    return (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: `${"─".repeat(left)} ${label} ─` }) }));
+}
+const MODE_DESC = {
+    suggest: "confirms edits & commands",
+    "auto-edit": "auto-applies edits · asks before commands",
+    "full-auto": "runs everything — no prompts  ⚠",
+    plan: "investigate read-only, then propose a plan to approve",
+};
+// Prominent approval-mode selector below the box: all three listed, the active one highlighted (red
+// for the dangerous full-auto) with a one-line description and the shift+tab hint.
+function ModeBar({ approval }) {
+    const warn = approval === "full-auto";
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { children: MODES.map((m, i) => (_jsxs(Text, { children: [i > 0 ? "   " : "  ", m === approval ? _jsx(Text, { color: warn ? "red" : m === "plan" ? "cyan" : "green", bold: true, children: `◆ ${m}` }) : _jsx(Text, { dimColor: true, children: m })] }, m))) }), _jsx(Text, { dimColor: true, children: `    ${MODE_DESC[approval]} · shift+tab ⇄` })] }));
+}
+/** The active `@mention` token immediately left of the cursor (for the file popup), or null. */
+function activeMention(value, cursor) {
+    const m = /(?:^|\s)@([^\s@]*)$/.exec(value.slice(0, cursor));
+    return m ? { query: m[1], start: cursor - m[1].length } : null;
+}
+// Dropdown of fuzzy @path matches, shown above the input as you type `@…` (codex / Claude-Code style).
+function MentionPopup({ items, selected, query }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: `  @${query}  ·  ${items.length} match${items.length === 1 ? "" : "es"} — ↑↓ select · Tab/Enter insert · Esc dismiss` }), items.map((it, i) => (_jsxs(Text, { children: [i === selected ? _jsx(Text, { color: "cyan", children: "  ▸ " }) : _jsx(Text, { children: "    " }), _jsx(Text, { color: it.endsWith("/") ? "blue" : undefined, dimColor: i !== selected, bold: i === selected, children: it })] }, it)))] }));
+}
+const TOKEN_RE = /\[Image #\d+\]/g;
+/** Render the prompt line: plain text + the cursor, with any `[Image #N]` attachment tokens highlighted
+ *  (codex / Claude-Code style — the image lives inline in the text, visibly distinct from what you typed). */
+function InputLine({ value, cursor }) {
+    const parts = [];
+    let last = 0;
+    let m;
+    TOKEN_RE.lastIndex = 0;
+    while ((m = TOKEN_RE.exec(value))) {
+        if (m.index > last)
+            parts.push({ text: value.slice(last, m.index), token: false });
+        parts.push({ text: m[0], token: true });
+        last = m.index + m[0].length;
+    }
+    if (last < value.length)
+        parts.push({ text: value.slice(last), token: false });
+    const seg = (token, text, k) => token ? (_jsx(Text, { backgroundColor: "magenta", color: "white", children: text }, k)) : (_jsx(Text, { children: text }, k));
+    const nodes = [];
+    let pos = 0;
+    let ki = 0;
+    for (const p of parts) {
+        const start = pos;
+        const end = pos + p.text.length;
+        if (cursor >= start && cursor < end) {
+            const rel = cursor - start;
+            if (rel > 0)
+                nodes.push(seg(p.token, p.text.slice(0, rel), `s${ki++}`));
+            nodes.push(_jsx(Text, { inverse: true, children: p.text[rel] }, `c${ki++}`));
+            if (rel + 1 < p.text.length)
+                nodes.push(seg(p.token, p.text.slice(rel + 1), `e${ki++}`));
+        }
+        else {
+            nodes.push(seg(p.token, p.text, `p${ki++}`));
+        }
+        pos = end;
+    }
+    if (cursor >= value.length)
+        nodes.push(_jsx(Text, { inverse: true, children: " " }, "end"));
+    return _jsx(Text, { children: nodes });
+}
+/** Top border (session) + prompt line + bottom border (usage) + ModeBar, with an @path popup. */
+export function InputBox({ status, cwd, width, onSubmit, onClipboardImage, isActive = true, placeholder = "Type a task · /help · @file · Ctrl+V paste image · shift+tab mode · Esc interrupts", }) {
+    const { stdout } = useStdout();
+    const w = width ?? stdout?.columns ?? 80;
+    const [value, setValue] = useState("");
+    const [cursor, setCursor] = useState(0);
+    const [sel, setSel] = useState(0);
+    const [dismissed, setDismissed] = useState(false);
+    const [images, setImages] = useState([]);
+    const set = (v, c) => {
+        setValue(v);
+        setCursor(c);
+        setSel(0);
+        setDismissed(false);
+    };
+    // Attach an image: drop a highlighted `[Image #N]` token inline at the cursor and track the file
+    // (codex / Claude-Code style). Backspace over the token removes both.
+    const addImage = (img) => {
+        const tok = `[Image #${images.length + 1}]`;
+        const before = value.slice(0, cursor);
+        const ins = (before && !/\s$/.test(before) ? " " : "") + tok + " ";
+        setValue(before + ins + value.slice(cursor));
+        setCursor((before + ins).length);
+        setImages((xs) => [...xs, img]);
+        setSel(0);
+        setDismissed(false);
+    };
+    const submit = (text) => {
+        if (!text.trim() && images.length === 0)
+            return; // nothing to send
+        onSubmit?.(text, images.length ? images : undefined);
+        set("", 0);
+        setImages([]);
+    };
+    const mention = activeMention(value, cursor);
+    const candidates = useMemo(() => (isActive && mention && !dismissed ? fileCandidates(cwd, mention.query, 8) : []), [cwd, isActive, dismissed, mention?.query, mention?.start]);
+    const popupOpen = candidates.length > 0;
+    const selIdx = popupOpen ? Math.min(sel, candidates.length - 1) : 0;
+    const complete = (cand) => {
+        if (!mention)
+            return;
+        const before = value.slice(0, mention.start); // includes the leading '@'
+        const after = value.slice(cursor);
+        const insert = cand.endsWith("/") ? cand : cand + " "; // dirs keep drilling; files end the mention
+        setValue(before + insert + after);
+        setCursor((before + insert).length);
+        setSel(0);
+        setDismissed(false);
+    };
+    useInput((input, key) => {
+        if (popupOpen && (key.upArrow || key.downArrow)) {
+            const n = candidates.length;
+            setSel((s) => (key.downArrow ? (s + 1) % n : (s - 1 + n) % n));
+            return;
+        }
+        if (popupOpen && (key.tab || key.return)) {
+            complete(candidates[selIdx]);
+            return;
+        }
+        if (key.escape) {
+            if (popupOpen)
+                setDismissed(true);
+            return;
+        }
+        if (key.return) {
+            submit(value);
+            return;
+        }
+        if (key.leftArrow)
+            return setCursor((c) => Math.max(0, c - 1));
+        if (key.rightArrow)
+            return setCursor((c) => Math.min(value.length, c + 1));
+        if (key.ctrl && input === "a")
+            return setCursor(0);
+        if (key.ctrl && input === "e")
+            return setCursor(value.length);
+        if (key.ctrl && input === "u")
+            return set(value.slice(cursor), 0);
+        if (key.ctrl && input === "v") {
+            // paste a screenshot / image from the OS clipboard
+            const img = onClipboardImage?.();
+            if (img)
+                addImage(img);
+            return;
+        }
+        if (key.backspace || key.delete) {
+            if (cursor > 0) {
+                const head = value.slice(0, cursor);
+                const tm = /\[Image #(\d+)\]\s?$/.exec(head); // backspacing over an attachment token removes it whole
+                if (tm) {
+                    const n = Number(tm[1]);
+                    const kept = head.slice(0, tm.index) + value.slice(cursor);
+                    const renumbered = kept.replace(/\[Image #(\d+)\]/g, (m2, d) => (Number(d) > n ? `[Image #${Number(d) - 1}]` : m2));
+                    setImages((xs) => xs.filter((_, i) => i !== n - 1));
+                    setValue(renumbered);
+                    setCursor(tm.index);
+                    setSel(0);
+                    setDismissed(false);
+                    return;
+                }
+                set(value.slice(0, cursor - 1) + value.slice(cursor), cursor - 1);
+            }
+            return;
+        }
+        if (input && !key.ctrl && !key.meta) {
+            const nl = input.search(/[\r\n]/); // a chunk carrying a newline (paste / fed input) submits
+            if (nl >= 0) {
+                submit(value.slice(0, cursor) + input.slice(0, nl) + value.slice(cursor));
+                return;
+            }
+            // a dragged-in / pasted image file path attaches instead of inserting literal text
+            if (input.length > 3) {
+                const img = imagePathFromPaste(input, cwd);
+                if (img) {
+                    addImage(img);
+                    return;
+                }
+            }
+            set(value.slice(0, cursor) + input + value.slice(cursor), cursor + input.length);
+        }
+    }, { isActive });
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(TopBorder, { name: status.sessionName || "session", width: w }), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: "› " }), value.length === 0 ? (_jsxs(Text, { children: [_jsx(Text, { inverse: true, children: " " }), _jsx(Text, { dimColor: true, children: placeholder })] })) : (_jsx(InputLine, { value: value, cursor: cursor }))] }), _jsx(BottomBorder, { s: status, width: w }), popupOpen ? _jsx(MentionPopup, { items: candidates, selected: selIdx, query: mention.query }) : null, _jsx(ModeBar, { approval: status.approval })] }));
+}

package/dist/tui/run.js

@@ -0,0 +1,10 @@
+// Mounts the hara TUI (ink) and resolves when the user exits. Thin shell — all agent wiring
+// (provider, session history, slash commands, turn execution) is passed in via AppProps.onSubmit
+// from index.ts, which owns that state.
+import { render } from "ink";
+import { createElement } from "react";
+import { App } from "./App.js";
+export async function runTui(props) {
+    const instance = render(createElement(App, props));
+    await instance.waitUntilExit();
+}

package/dist/tui/theme.js

@@ -0,0 +1,11 @@
+let current = "dark";
+export function setTheme(name) {
+    current = name === "light" ? "light" : "dark";
+}
+export function themeName() {
+    return current;
+}
+/** Brand accent (warm vermilion · 朱印). */
+export function accent() {
+    return current === "light" ? "#C0392B" : "#FF6B5C";
+}

package/dist/ui.js

@@ -0,0 +1,17 @@
+import { stdout } from "node:process";
+const useColor = stdout.isTTY && process.env.NO_COLOR === undefined;
+const wrap = (code) => (s) => (useColor ? `\x1b[${code}m${s}\x1b[0m` : s);
+export const c = {
+    dim: wrap("2"),
+    bold: wrap("1"),
+    cyan: wrap("36"),
+    green: wrap("32"),
+    yellow: wrap("33"),
+    red: wrap("31"),
+};
+export function out(s) {
+    stdout.write(s);
+}
+export function statusLine(model, inTok, outTok) {
+    return c.dim(`  ${model} · ↑${inTok} ↓${outTok} tok`);
+}

package/dist/undo.js

@@ -0,0 +1,40 @@
+// In-session undo stack for file changes. Each edit tool records the prior state of the files it
+// touched; `/undo` pops the last group and restores it. Process-scoped (one REPL session).
+import { writeFile, unlink, mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+const stack = [];
+const MAX = 50;
+/** Record a group of file changes (one tool call = one undo step). */
+export function recordEdit(group) {
+    if (!group.length)
+        return;
+    stack.push(group);
+    if (stack.length > MAX)
+        stack.shift();
+}
+export function undoDepth() {
+    return stack.length;
+}
+/** Restore the most recent edit group. Returns the files reverted, or an error. */
+export async function undoLast() {
+    const group = stack.pop();
+    if (!group)
+        return { error: "nothing to undo" };
+    const files = [];
+    for (const s of group) {
+        try {
+            if (s.before === null) {
+                await unlink(s.absPath).catch(() => { }); // was newly created → remove
+            }
+            else {
+                await mkdir(dirname(s.absPath), { recursive: true });
+                await writeFile(s.absPath, s.before, "utf8");
+            }
+            files.push(s.path);
+        }
+        catch {
+            /* skip a file we can't restore */
+        }
+    }
+    return { files };
+}

package/dist/vision.js

@@ -0,0 +1,81 @@
+// Built-in capability map for the major model families. First matching rule wins, so each family's
+// vision pattern is listed BEFORE its text catch-all. Anything that matches nothing → "unknown"
+// (we ask the user once and remember). Easy to extend — add a rule near the right family.
+const MODEL_VISION_MAP = [
+    // OpenAI
+    { rx: /gpt-4o|gpt-4\.1|gpt-4-turbo|chatgpt-4o|gpt-5|(?:^|[-_/])o[134](?:[-_/]|$)/i, cap: "vision" },
+    { rx: /gpt-4(\b|-0|-1)|gpt-3\.5|davinci|babbage|text-(?:embedding|davinci)/i, cap: "text" },
+    // Qwen — Alibaba Coding Plan: qwen3.x-plus see images (verified qwen3.7-plus); max/coder are text-only.
+    { rx: /qwen.*vl|qwen.*omni|qvq/i, cap: "vision" },
+    { rx: /qwen-?3[.\d]*-plus/i, cap: "vision" }, // qwen3.5-plus / qwen3.6-plus / qwen3.7-plus
+    { rx: /qwen.*(?:coder|plus|max|turbo|long|math)|qwq|qwen[\d.]*-?\d+b\b|qwen-?\d/i, cap: "text" },
+    // GLM / Zhipu — 4v/4.5v see images; glm-5, glm-4.7, glm-4-flash are text-only.
+    { rx: /glm-?\d(?:\.\d+)?v|cogvlm|glm.*vision/i, cap: "vision" },
+    { rx: /glm-?\d(?:\.\d+)?(?:-(?:air|flash|plus|long|x|0520))?\b|glm-z|chatglm/i, cap: "text" },
+    // DeepSeek (VL first, then the text families)
+    { rx: /deepseek.*vl/i, cap: "vision" },
+    { rx: /deepseek/i, cap: "text" },
+    // Google
+    { rx: /gemini|gemma-3/i, cap: "vision" },
+    { rx: /gemma/i, cap: "text" },
+    // Mistral (Pixtral/small-3 see; the rest text)
+    { rx: /pixtral|mistral-small-3|mistral.*vision/i, cap: "vision" },
+    { rx: /mistral|mixtral|codestral|ministral/i, cap: "text" },
+    // Meta Llama (3.2-11B/90B + 4 see; the rest text)
+    { rx: /llama-?3\.2-(?:11|90)b|llama.*vision|llama-?4/i, cap: "vision" },
+    { rx: /llama|codellama/i, cap: "text" },
+    // Moonshot / Kimi — kimi-k2.5 sees images (Coding Plan); older Kimi text.
+    { rx: /kimi-?k?2\.5|kimi.*vl|moonshot.*(?:vl|vision)/i, cap: "vision" },
+    { rx: /kimi|moonshot/i, cap: "text" },
+    // xAI Grok
+    { rx: /grok.*vision|grok-[\d.]*v\b|grok-4/i, cap: "vision" },
+    { rx: /grok/i, cap: "text" },
+    // MiniMax — VL models see images; the M-series chat (e.g. MiniMax-M2.5) is text-only.
+    { rx: /minimax.*(?:vl|vision)|abab.*vl/i, cap: "vision" },
+    { rx: /minimax|abab/i, cap: "text" },
+    // Other well-known vision families
+    { rx: /(?:^|[-_/])vl(?:[-_/]|$)|internvl|llava|minicpm-?v|yi-vl|step-1[vo]|doubao.*(?:vl|vision)|ernie.*vl/i, cap: "vision" },
+];
+/**
+ * Resolve a model's vision capability: explicit per-model override → Anthropic (all modern Claude see
+ * images) → built-in family map → "unknown" (caller asks the user). Pure + table-driven so it's testable.
+ */
+export function classifyVision(provider, model, overrides = {}) {
+    const o = overrides[model];
+    if (o === "yes")
+        return "vision";
+    if (o === "no")
+        return "text";
+    if (provider === "anthropic")
+        return "vision";
+    const m = model || "";
+    for (const r of MODEL_VISION_MAP)
+        if (r.rx.test(m))
+            return r.cap;
+    return "unknown";
+}
+export const DESCRIBE_SYSTEM = [
+    "You are the eyes of a coding assistant that cannot see images. Transcribe and describe the attached",
+    "image(s) completely and precisely so the assistant can act on them without seeing them.",
+    "Rules:",
+    "1. Transcribe ALL visible text and code VERBATIM, preserving line breaks and indentation — put code,",
+    "   terminal output, and logs in fenced code blocks.",
+    "2. For UI / screenshots: describe the layout, components, labels, states, and notable colors.",
+    "3. For diagrams / charts: describe the structure — nodes, edges, axes, and data.",
+    "4. Quote any error or warning messages exactly.",
+    "5. Be thorough and factual; do not speculate beyond what is visible.",
+].join("\n");
+const PROMPT = "Describe the attached image(s) per your instructions.";
+/** Send images to the vision provider and return its textual description. Throws on a provider error. */
+export async function describeImages(provider, images, opts = {}) {
+    const r = await provider.turn({
+        system: DESCRIBE_SYSTEM,
+        history: [{ role: "user", content: PROMPT, images }],
+        tools: [],
+        onText: () => { },
+        signal: opts.signal,
+    });
+    if (r.stop === "error")
+        throw new Error(r.errorMsg || "vision provider error");
+    return r.text.trim();
+}

package/package.json

@@ -1,15 +1,17 @@
 {
   "name": "@nanhara/hara",
-  "version": "0.0.1",
-  "description": "hara — a coding agent CLI that runs like an engineering org. Placeholder; under active development.",
+  "version": "0.33.0",
+  "description": "hara — a coding agent CLI that runs like an engineering org.",
   "bin": {
-    "hara": "bin/hara.mjs"
+    "hara": "dist/index.js"
   },
   "type": "module",
   "files": [
-    "bin",
+    "dist",
     "README.md",
-    "LICENSE"
+    "CHANGELOG.md",
+    "LICENSE",
+    "CLA.md"
   ],
   "keywords": [
     "ai",
@@ -18,9 +20,11 @@
     "coding-agent",
     "llm",
     "agent-orchestration",
-    "multi-agent"
+    "multi-agent",
+    "anthropic",
+    "claude"
   ],
-  "license": "MIT",
+  "license": "Apache-2.0",
   "author": "Nanhara",
   "homepage": "https://hara.run",
   "repository": {
@@ -30,7 +34,29 @@
   "engines": {
     "node": ">=20"
   },
+  "scripts": {
+    "build": "tsc",
+    "prepare": "tsc",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "test": "tsc && node --test test/*.test.mjs"
+  },
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.104.2",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "commander": "^15.0.0",
+    "ink": "^6.8.0",
+    "openai": "^6.44.0",
+    "react": "^19.2.7"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.3",
+    "@types/react": "^19.2.17",
+    "ink-testing-library": "^4.0.0",
+    "tsx": "^4.22.4",
+    "typescript": "^6.0.3"
   }
 }

package/bin/hara.mjs

@@ -1,25 +0,0 @@
-#!/usr/bin/env node
-// hara — placeholder CLI. Real agent coming soon.
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { dirname, join } from "node:path";
-
-const __dir = dirname(fileURLToPath(import.meta.url));
-let version = "0.0.1";
-try {
-  version = JSON.parse(readFileSync(join(__dir, "..", "package.json"), "utf8")).version;
-} catch {}
-
-const args = process.argv.slice(2);
-if (args[0] === "-v" || args[0] === "--version") {
-  console.log(version);
-  process.exit(0);
-}
-
-console.log(`hara v${version}
-A coding agent CLI that runs like an engineering org.
-
-This is an early placeholder — the real thing is under active development.
-Track it:  https://github.com/hara-cli/hara
-Site:      https://hara.run
-`);