s-app-scoder-agent 0.6.0 → 0.8.0

package/dist/tui/state.js

@@ -9,13 +9,87 @@ export function initialState() {
         workdir: "",
         buildCmd: "",
         buildLamp: "none",
+        permission: "",
+        startedAt: null,
+        endedAt: null,
         usage: { calls: 0, inputTokens: 0, outputTokens: 0, cachedTokens: 0 },
         summary: null,
+        guardrailCount: 0,
+        lastGuardrail: null,
+        thinkingVisible: false,
+        phases: [],
+        mcpServers: {},
+        streamingOutputChars: 0,
     };
 }
 const MAX_ITEMS = 400;
 const MAX_OUTPUT_CHARS = 20_000;
 const MAX_TEXT_CHARS = 40_000;
+/**
+ * T4: ước lượng chiều cao (rows) của một ChatItem khi render — dùng cho
+ * virtualization (chỉ render window quanh viewport thay vì cap cứng).
+ * Over-estimate nhẹ an toàn hơn under-estimate (viewport luôn đủ phủ).
+ * ponytail: heuristic theo chars, không đo Ink thật — nâng cấp thành đo
+ * height thật (useBoxMetrics per item) khi heuristic lệch đáng kể.
+ */
+export function estimateItemRows(item) {
+    switch (item.kind) {
+        case "user":
+            return 2 + Math.ceil(item.text.length / 80);
+        case "assistant":
+        case "thinking":
+            return 1 + Math.ceil((item.text?.length ?? 0) / 80) + (item.text ? item.text.split("\n").length : 0);
+        case "tool":
+            return 1 + 2; // title + preview 2 lines
+        case "diff":
+            return 3 + Math.min(24, (item.text?.split("\n").length ?? 0)); // header + ≤24 lines + border
+        case "todo":
+            return 2 + item.items.length;
+        case "build":
+            return 1;
+        case "notice":
+            return 1 + Math.ceil(item.text.length / 2000);
+    }
+}
+/**
+ * T4: chọn window item để render: lấy từ cuối lên tới khi tổng rows ước
+ * lượng ≥ viewportRows + margin (render dư phía trên để scroll mượt), nhưng
+ * giữ toàn bộ khi tổng nhỏ. Trả về slice của items (không mutate).
+ */
+export function visibleWindow(items, viewportRows, margin = 50) {
+    const budget = viewportRows + margin;
+    let acc = 0;
+    let start = items.length;
+    while (start > 0 && acc < budget) {
+        start--;
+        acc += estimateItemRows(items[start]);
+    }
+    return start === 0 ? items : items.slice(start);
+}
+/**
+ * Plan mới nhất cho sidebar — todo items được append mỗi lần update nhưng
+ * sidebar chỉ cần snapshot hiện tại (last-wins), null khi chưa có plan.
+ *
+ * Reset realtime: mỗi lần user gửi message mới, plan reset — chỉ hiện plan
+ * được viết SAU user message cuối cùng. Tránh stale plan từ task trước hiện
+ * trong task mới.
+ */
+export function latestPlan(items) {
+    // Tìm user message cuối cùng — plan chỉ reset tại đây.
+    let lastUserIdx = -1;
+    for (let i = items.length - 1; i >= 0; i--) {
+        if (items[i].kind === "user") {
+            lastUserIdx = i;
+            break;
+        }
+    }
+    // Chỉ tìm todo SAU user cuối.
+    for (let i = items.length - 1; i > lastUserIdx; i--) {
+        if (items[i].kind === "todo")
+            return items[i];
+    }
+    return null;
+}
 function appendItem(state, item) {
     state.items.push(item);
     if (state.items.length > MAX_ITEMS)
@@ -30,22 +104,69 @@ function capTail(text, max = MAX_OUTPUT_CHARS) {
         return text;
     return `…[truncated ${text.length - max} chars]\n${text.slice(text.length - max)}`;
 }
+/**
+ * Map tên tool → phase của breadcrumb (plan→explore→edit→build→verify).
+ * Trả về null với tool không thuộc phase nào (mcp__*...).
+ */
+export function toolPhase(name) {
+    if (name === "write_todos")
+        return "plan";
+    if (name === "list_files" || name === "read_file" || name === "web_fetch" || name === "load_skill")
+        return "explore";
+    if (name === "write_file" || name === "edit_file")
+        return "edit";
+    if (name === "run_command")
+        return "build";
+    return null;
+}
+/** Guardrail event: đếm + giữ decision gần nhất (ngắn, tự giải thích cho header). */
+function applyGuardrail(state, ev) {
+    // history-trim là routine context management — đếm làm gì, hiện làm gì:
+    // header chỉ hiển thị những can thiệp THẬT sự đáng chú ý (inject/finish/verify).
+    if (ev.action === "trim")
+        return;
+    state.guardrailCount += 1;
+    // Thông điệp thân thiện theo rule — không dump raw "rule · reason" lên UI.
+    const HUMAN = {
+        "wrap-up": "sắp hết bước — yêu cầu agent chốt việc và chạy build",
+        "chat-done": "lượt chat thuần — kết thúc không cần build",
+        "completion-claim": "agent báo hoàn thành — buộc chạy build xác minh",
+        "text-only-streak": "agent chỉ nói không làm — dừng run",
+        "continue-nudge": "trả lời text chưa dùng tool — nhắc tiếp tục",
+        "doom-loop": "lặp lẫn lộn cùng tool call — yêu cầu đổi hướng",
+        "build-stop": "build pass — kết thúc run",
+    };
+    state.lastGuardrail = HUMAN[ev.rule] ?? `${ev.rule}: ${ev.reason}`;
+}
 /**
  * Fold one AgentEvent into the state (mutates `state`, returns it for
  * reducer-style chaining). Unknown events are ignored.
  */
 export function applyEvent(state, ev) {
     switch (ev.type) {
+        case "permission_request": {
+            // T-03: surfaced via a dedicated React state hook in TuiApp (not the
+            // chat items — the modal is modal, not transcript).
+            break;
+        }
         case "run_start": {
             state.model = ev.model;
             state.provider = ev.provider;
             state.workdir = ev.workdir;
             state.buildCmd = ev.buildCmd;
             state.buildLamp = "none";
+            state.permission = ev.permission;
+            state.startedAt = Date.now();
+            state.endedAt = null;
             state.status = "running";
             state.step = 0;
             state.summary = null;
             state.usage = { calls: 0, inputTokens: 0, outputTokens: 0, cachedTokens: 0 };
+            // Reset tracking của run mới.
+            state.guardrailCount = 0;
+            state.lastGuardrail = null;
+            state.phases = [];
+            state.streamingOutputChars = 0;
             // The TUI pushes the user's message itself when submitting; avoid a
             // duplicate when run_start carries the same task.
             const last = lastItem(state);
@@ -54,6 +175,22 @@ export function applyEvent(state, ev) {
             }
             break;
         }
+        case "llm_reasoning": {
+            // T-10: thinking stream — chỉ append khi thinkingVisible; vẫn giữ trong
+            // reasoning buffer riêng để toggle bật lại thấy (đơn giản: drop khi off).
+            if (!state.thinkingVisible)
+                break;
+            const last = lastItem(state);
+            if (last && last.kind === "thinking" && last.streaming) {
+                last.text += ev.delta;
+                if (last.text.length > MAX_TEXT_CHARS)
+                    last.text = last.text.slice(-MAX_TEXT_CHARS);
+            }
+            else {
+                appendItem(state, { kind: "thinking", text: ev.delta, streaming: true });
+            }
+            break;
+        }
         case "step": {
             state.step = ev.step;
             state.maxSteps = ev.maxSteps;
@@ -61,9 +198,12 @@ export function applyEvent(state, ev) {
             const last = lastItem(state);
             if (last && last.kind === "assistant" && last.streaming)
                 last.streaming = false;
+            if (last && last.kind === "thinking" && last.streaming)
+                last.streaming = false;
             break;
         }
         case "llm_delta": {
+            state.streamingOutputChars += ev.delta.length;
             const last = lastItem(state);
             if (last && last.kind === "assistant" && last.streaming) {
                 last.text += ev.delta;
@@ -89,7 +229,20 @@ export function applyEvent(state, ev) {
             break;
         }
         case "tool_call": {
-            appendItem(state, { kind: "tool", name: ev.name, args: ev.args, ok: null, output: "", step: ev.step });
+            appendItem(state, {
+                kind: "tool",
+                name: ev.name,
+                args: ev.args,
+                callId: ev.id,
+                ok: null,
+                output: "",
+                step: ev.step,
+                startedAt: Date.now(),
+            });
+            // Phase tracking cho breadcrumb (không trùng phase liền trước).
+            const phase = toolPhase(ev.name);
+            if (phase && state.phases[state.phases.length - 1] !== phase)
+                state.phases.push(phase);
             break;
         }
         case "tool_output": {
@@ -109,13 +262,20 @@ export function applyEvent(state, ev) {
             break;
         }
         case "tool_result": {
+            // T6: correlate theo callId (parallel calls cùng tên vẫn đúng card);
+            // fallback theo name cho event cũ không id.
             for (let i = state.items.length - 1; i >= 0; i--) {
                 const it = state.items[i];
-                if (it.kind === "tool" && it.name === ev.name && it.ok === null) {
+                const match = it.kind === "tool" && it.ok === null && (ev.id ? it.callId === ev.id : it.name === ev.name);
+                if (match) {
                     it.ok = ev.ok;
+                    if (it.startedAt != null)
+                        it.durationMs = Date.now() - it.startedAt;
                     // Prefer the final (complete) result over accumulated live chunks.
                     if (ev.output.length >= it.output.length)
                         it.output = ev.output;
+                    if (ev.image)
+                        it.image = ev.image;
                     break;
                 }
             }
@@ -136,16 +296,41 @@ export function applyEvent(state, ev) {
         }
         case "build": {
             state.buildLamp = ev.success ? "ok" : "fail";
+            if (state.phases[state.phases.length - 1] !== "verify")
+                state.phases.push("verify");
             appendItem(state, { kind: "build", success: ev.success, command: ev.command });
             break;
         }
+        case "todo": {
+            // Plan updates render as a live checkbox list in the chat pane.
+            appendItem(state, { kind: "todo", items: ev.items.map((t) => ({ ...t })) });
+            break;
+        }
+        case "guardrail": {
+            applyGuardrail(state, ev);
+            break;
+        }
+        case "mcp_status": {
+            // Sidebar: structured event (server+state) → cập nhật map, không spam chat.
+            // onStatus riêng vẫn đẩy notice text đầy đủ cho transcript.
+            if (ev.server && ev.state) {
+                state.mcpServers = { ...state.mcpServers, [ev.server]: ev.state };
+                break;
+            }
+            appendItem(state, { kind: "notice", text: ev.line, level: ev.line.includes("unavailable") ? "warn" : "info" });
+            break;
+        }
         case "finish": {
             state.status = ev.success ? "success" : /interrupted|aborted/i.test(ev.summary) ? "aborted" : "failed";
             state.summary = ev.summary;
-            // Close any dangling streaming assistant message.
-            const last = lastItem(state);
-            if (last && last.kind === "assistant")
-                last.streaming = false;
+            state.endedAt = Date.now();
+            // Close ALL dangling streaming assistant messages — not just the last
+            // item: a notice/tool item appended after the assistant text would
+            // otherwise leave it stuck in raw streaming mode (invisible text).
+            for (const it of state.items) {
+                if (it.kind === "assistant" && it.streaming)
+                    it.streaming = false;
+            }
             break;
         }
         case "error": {
@@ -159,6 +344,7 @@ export function applyEvent(state, ev) {
 export function markAborted(state) {
     state.status = "aborted";
     state.summary = "abort requested…";
+    state.endedAt = Date.now();
     const last = lastItem(state);
     if (last && last.kind === "assistant")
         last.streaming = false;

package/dist/tui/theme.js

@@ -0,0 +1,90 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text } from "ink";
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+const MISSION = {
+    brand: "magenta", accent: "cyan", success: "green", error: "red", warn: "yellow",
+    user: "blue", dim: "gray", border: "gray",
+    mermaid: "magentaBright", thinking: "gray", code: "green", table: "cyan",
+};
+const PAPER = {
+    brand: "blue", accent: "blue", success: "green", error: "red", warn: "yellow",
+    user: "black", dim: "gray", border: "gray",
+    mermaid: "magentaBright", thinking: "gray", code: "green", table: "cyan",
+};
+const MONO = {
+    brand: "white", accent: "white", success: "white", error: "white", warn: "white",
+    user: "white", dim: "gray", border: "gray",
+    mermaid: "whiteBright", thinking: "white", code: "whiteBright", table: "whiteBright",
+};
+const LIGHT = {
+    brand: "magentaBright", accent: "cyanBright", success: "greenBright", error: "redBright",
+    warn: "yellowBright", user: "blueBright", dim: "blackBright", border: "blackBright",
+    mermaid: "magentaBright", thinking: "gray", code: "greenBright", table: "cyanBright",
+};
+const HIGH_CONTRAST = {
+    brand: "whiteBright", accent: "cyanBright", success: "greenBright", error: "redBright",
+    warn: "yellowBright", user: "whiteBright", dim: "white", border: "whiteBright",
+    mermaid: "magentaBright", thinking: "whiteBright", code: "greenBright", table: "cyanBright",
+};
+const SOLARIZED = {
+    brand: "magentaBright", accent: "cyanBright", success: "greenBright", error: "redBright",
+    warn: "yellowBright", user: "blueBright", dim: "gray", border: "gray",
+    mermaid: "magentaBright", thinking: "gray", code: "greenBright", table: "cyanBright",
+};
+export const THEMES = {
+    mission: MISSION, paper: PAPER, mono: MONO,
+    light: LIGHT, "high-contrast": HIGH_CONTRAST, solarized: SOLARIZED,
+};
+export function defaultThemeName(env = process.env) {
+    if (env.TERM === "dumb" || !env.TERM)
+        return "mono";
+    if (env.COLOR_COUNT && Number(env.COLOR_COUNT) < 16)
+        return "mono";
+    return "mission";
+}
+export function getTheme(workdir) {
+    const p = join(workdir, ".scoder", "theme.json");
+    if (existsSync(p)) {
+        try {
+            const raw = JSON.parse(readFileSync(p, "utf8"));
+            const base = raw.name ? THEMES[raw.name] ?? THEMES[defaultThemeName()] : THEMES[defaultThemeName()];
+            return { ...base, ...Object.fromEntries(Object.entries(raw).filter(([k]) => k in base)) };
+        }
+        catch { /* malformed → default */ }
+    }
+    return THEMES[defaultThemeName()];
+}
+let active = MISSION;
+export function setActiveTheme(t) { active = t; }
+export function useNamedTheme(name) {
+    if (name === "list")
+        return `themes: ${Object.keys(THEMES).join(", ")} — /theme <name>`;
+    const t = THEMES[name];
+    if (!t)
+        return `ERROR: unknown theme "${name}" — available: ${Object.keys(THEMES).join(", ")}`;
+    active = t;
+    return `theme → ${name}`;
+}
+export const theme = new Proxy({}, {
+    get(_t, prop) { return active[prop]; },
+});
+/** Icon per tool name — compact visual vocabulary for the flight recorder. */
+const TOOL_ICONS = {
+    list_files: "🗂", read_file: "📖", write_file: "📝", edit_file: "✏️",
+    run_command: "⚡", web_fetch: "🌐", write_todos: "☑",
+};
+export function toolIcon(name) {
+    if (TOOL_ICONS[name])
+        return TOOL_ICONS[name];
+    if (name.startsWith("mcp__"))
+        return "🔌";
+    return "🔧";
+}
+export function fit(text, max) {
+    return text.length <= max ? text : text.slice(0, Math.max(0, max - 1)) + "…";
+}
+/** The agent's signature mark, used as an avatar on assistant output. */
+export function AgentMark() {
+    return _jsx(Text, { color: theme.brand, bold: true, children: "\u25C6 " });
+}

package/dist/tui/vim.js

@@ -0,0 +1,60 @@
+/**
+ * T5: vim-motion cho Input — mode normal/insert, word motions.
+ * Module thuần (test được); Input chỉ wire keymap.
+ */
+/** w — đầu từ kế tiếp (vim: skip word chars rồi skip whitespace). */
+export function wordForward(s, i) {
+    while (i < s.length && /\S/.test(s[i]))
+        i++;
+    while (i < s.length && /\s/.test(s[i]))
+        i++;
+    return Math.min(i, s.length);
+}
+/** b — đầu từ trước. */
+export function wordBack(s, i) {
+    i--;
+    while (i > 0 && /\s/.test(s[i]))
+        i--;
+    while (i > 0 && /\S/.test(s[i - 1]))
+        i--;
+    return Math.max(0, i);
+}
+/** e — cuối từ hiện tại/kế tiếp. */
+export function wordEnd(s, i) {
+    i++;
+    while (i < s.length - 1 && /\s/.test(s[i]))
+        i++;
+    while (i < s.length - 1 && /\S/.test(s[i + 1]))
+        i++;
+    return Math.min(i, Math.max(0, s.length - 1));
+}
+/** Áp dụng một phím normal-mode. Trả về unhandled=true khi không phải motion. */
+export function applyNormalKey(value, cursor, input) {
+    const ok = (v, c, mode = "normal") => ({ value: v, cursor: c, mode, unhandled: false });
+    switch (input) {
+        case "h":
+            return ok(value, Math.max(0, cursor - 1));
+        case "l":
+            return ok(value, Math.min(value.length, cursor + 1));
+        case "w":
+            return ok(value, wordForward(value, cursor));
+        case "b":
+            return ok(value, wordBack(value, cursor));
+        case "e":
+            return ok(value, wordEnd(value, cursor));
+        case "0":
+            return ok(value, 0);
+        case "$":
+            return ok(value, value.length);
+        case "x":
+            return cursor < value.length ? ok(value.slice(0, cursor) + value.slice(cursor + 1), cursor) : ok(value, cursor);
+        case "i":
+            return ok(value, cursor, "insert");
+        case "a":
+            return ok(value, Math.min(value.length, cursor + 1), "insert");
+        case "A":
+            return ok(value, value.length, "insert");
+        default:
+            return { value, cursor, mode: "normal", unhandled: true };
+    }
+}

package/dist/watch.js

@@ -0,0 +1,52 @@
+/**
+ * M4: hot-reload — watch .scoderrc + .scoder/skills/ (fs.watch, debounce
+ * 500ms). onChange(kind) — Agent quyết định hành động (reload skills /
+ * restart MCP). Module thuần, không dependency.
+ */
+import { watch, existsSync } from "node:fs";
+import { join } from "node:path";
+const DEBOUNCE_MS = 500;
+/** Watch rc file + skills dir. Fire onChange(kind) debounced (giữa các burst). */
+export function watchWorkdir(workdir, onChange) {
+    const watchers = [];
+    const timers = new Map();
+    const fire = (kind) => {
+        const t = timers.get(kind);
+        if (t)
+            clearTimeout(t);
+        timers.set(kind, setTimeout(() => {
+            timers.delete(kind);
+            onChange(kind);
+        }, DEBOUNCE_MS));
+    };
+    // .scoderrc (hoặc .scoderrc.json) — config changes.
+    for (const name of [".scoderrc.json", ".scoderrc"]) {
+        const p = join(workdir, name);
+        if (!existsSync(p))
+            continue;
+        try {
+            watchers.push(watch(p, () => fire("config")));
+        }
+        catch { /* race — file removed between existsSync and watch */ }
+    }
+    // .scoder/skills/ — skill files added/removed/edited.
+    const skillsDir = join(workdir, ".scoder", "skills");
+    if (existsSync(skillsDir)) {
+        try {
+            watchers.push(watch(skillsDir, { recursive: true }, () => fire("skills")));
+        }
+        catch { /* platform không hỗ trợ recursive (hiếm trên macOS/Windows OK) */ }
+    }
+    return {
+        close() {
+            for (const w of watchers) {
+                try {
+                    w.close();
+                }
+                catch { /* already closed */ }
+            }
+            for (const t of timers.values())
+                clearTimeout(t);
+        },
+    };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "s-app-scoder-agent",
-  "version": "0.6.0",
-  "description": "Autonomous coding agent CLI - similar to opencode/cline/claude. Runs tasks until build succeeds.",
+  "version": "0.8.0",
+  "description": "Autonomous coding agent CLI — writes, edits, and builds code autonomously until the project compiles without errors.",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -10,17 +10,19 @@
   "scripts": {
     "build": "tsc",
     "prepare": "npm run build",
-    "prepublishOnly": "npm run lint && npm run typecheck && npm test",
+    "prepublishOnly": "npm run lint && npm run typecheck",
     "start": "node dist/index.js",
     "dev": "tsc --watch",
     "typecheck": "tsc --noEmit",
     "lint": "eslint src/",
     "coverage": "npm run build && node --test --experimental-test-coverage test/*.test.mjs",
+    "eval": "node test/run-eval.mjs",
     "test": "npm run build && node --test test/*.test.mjs && node test/run-e2e.mjs && node test/run-mcp-test.mjs"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
+  "author": "nbhson",
   "keywords": [
     "cli",
     "agent",
@@ -41,18 +43,24 @@
   "files": [
     "dist",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    ".scoderrc.example.json"
   ],
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@types/node": "^22.0.0",
-    "@types/react": "^18.3.31",
+    "@types/react": "^19.3.0",
     "eslint": "^10.13.0",
     "typescript": "^5.6.0",
     "typescript-eslint": "^8.72.1"
   },
   "dependencies": {
-    "ink": "^5.2.1",
-    "react": "^18.3.1"
+    "fuzzysort": "^3.1.0",
+    "gpt-tokenizer": "^4.1.0",
+    "ink": "^8.0.0",
+    "react": "^19.3.1",
+    "react-dom": "^19.3.1",
+    "tree-sitter": "^0.25.1",
+    "tree-sitter-bash": "^0.25.1"
   }
 }

package/dist/tui-direct.mjs

@@ -1,4 +0,0 @@
-import { runTui } from "./tui/app.js";
-console.log("calling runTui");
-await runTui({ workdir: process.cwd(), model: "m", provider: "openai", apiKey: "k", permissionMode: "auto", baseUrl: "http://127.0.0.1:1", maxSteps: 5, stream: false }, null);
-console.log("returned");