@giovannijecha/jecode 0.1.5-rc.2

package/dist/tui/turn.js

@@ -0,0 +1,255 @@
+// Turning what the controller reports into what the transcript shows.
+//
+// The controller speaks in stream events and tool results; the screen speaks in
+// blocks. This is the whole of the translation, kept out of the shell so that
+// neither has to know how the other is built.
+import { condense, diff } from "../ui/diff.js";
+import { promptFor } from "./approve.js";
+/**
+ * What the footer can truthfully say.
+ *
+ * Every one of these is read off an event that has actually arrived, never
+ * from a guess about where the turn probably is. A status line that says one
+ * thing for the whole turn is decoration; this one is the only window into a
+ * process that is otherwise silent for seconds at a time, so it has to be
+ * worth believing.
+ */
+const WAITING = "Waiting";
+const THINKING = "Thinking";
+const WRITING = "Writing";
+const ASKING = "Waiting for you";
+/** Unchanged rows kept either side of a change. */
+const CONTEXT = 2;
+export function transcribe(stage) {
+    // The block the stream is currently filling. A change of kind starts a new
+    // one, which is what keeps reasoning and answer from running together.
+    let open;
+    const tools = new Map();
+    let step = 1;
+    let steps = 1;
+    let tool = 1;
+    let toolTotal = 1;
+    const close = () => {
+        const block = open?.block;
+        const changed = block?.kind === "reasoning" && block.live === true;
+        if (changed && block.kind === "reasoning")
+            block.live = false;
+        open = undefined;
+        return changed ? block : undefined;
+    };
+    return {
+        finish() {
+            const changed = close();
+            if (changed !== undefined)
+                stage.render(changed);
+        },
+        onStep(current, total) {
+            step = current;
+            steps = total;
+            stage.status(waiting(step, steps));
+            stage.render();
+        },
+        onToolProgress(current, total) {
+            tool = current;
+            toolTotal = total;
+        },
+        onUsage(usage) {
+            stage.usage?.(usage);
+        },
+        onStatus(status) {
+            stage.status(status);
+            stage.render();
+        },
+        onStream(event) {
+            const kind = event.kind === "thinking" ? "reasoning" : "answer";
+            stage.status(kind === "reasoning" ? THINKING : WRITING);
+            if (open === undefined || open.kind !== kind) {
+                const changed = close();
+                if (changed !== undefined)
+                    stage.render(changed);
+                const block = kind === "reasoning"
+                    ? { kind, text: "", live: true, expanded: false }
+                    : { kind, text: "" };
+                open = { kind, block };
+                stage.emit(block);
+            }
+            if (open.block.kind === "answer" || open.block.kind === "reasoning") {
+                open.block.text += event.text;
+            }
+            stage.render(open.block);
+        },
+        onToolCall(call, look) {
+            const changed = close();
+            if (changed !== undefined)
+                stage.render(changed);
+            stage.status(`Running ${call.name}${toolTotal > 1 ? ` · tool ${tool}/${toolTotal}` : ""}${step > 1 ? ` · step ${step}/${steps}` : ""}`);
+            const block = {
+                kind: "tool",
+                name: call.name,
+                target: target(call.input),
+                right: "pending",
+                tone: "pending",
+                body: preview(call, look),
+            };
+            tools.set(call.id, block);
+            stage.emit(block);
+            stage.render(block);
+        },
+        onToolResult(call, result, summary) {
+            stage.status(waiting(step, steps));
+            const block = tools.get(call.id);
+            if (block === undefined || block.kind !== "tool")
+                return;
+            block.tone = result.isError ? "fail" : "ok";
+            block.right = summary ?? "";
+            // A failure replaces the preview: what the call was going to do stops
+            // being the interesting part the moment it did not do it.
+            const outcome = result.isError
+                ? details(result.output, "out")
+                : produced(call, result.output);
+            if (outcome !== undefined)
+                block.body = outcome;
+            stage.render(block);
+        },
+        approve(call) {
+            if (stage.approved(call))
+                return Promise.resolve(true);
+            const changed = close();
+            if (changed !== undefined)
+                stage.render(changed);
+            stage.status(ASKING);
+            return new Promise((resolve) => {
+                stage.ask(promptFor(call, target(call.input), stage.palette), (answer) => {
+                    if (answer === "always")
+                        stage.remember(call);
+                    const approved = answer !== "no";
+                    const block = tools.get(call.id);
+                    if (!approved && block !== undefined && block.kind === "tool") {
+                        block.tone = "deny";
+                        block.right = "declined";
+                        block.body = undefined;
+                    }
+                    stage.status(approved ? `Running ${call.name}` : waiting(step, steps));
+                    stage.render(block);
+                    resolve(approved);
+                });
+            });
+        },
+    };
+}
+function waiting(step, total) {
+    return step === 1 ? WAITING : `${WAITING} · step ${step}/${total}`;
+}
+/** The argument worth showing: the thing the call acts on. */
+function target(input) {
+    const { path, command } = input;
+    if (typeof command === "string")
+        return command;
+    if (typeof path === "string")
+        return path;
+    const rest = JSON.stringify(input);
+    return rest === "{}" ? "" : rest;
+}
+/**
+ * What the call is about to do, drawn before it is allowed to do it.
+ *
+ * The tool is asked first, because only it knows what is already on disk: a
+ * write against an existing file is a replacement, and showing it as a page of
+ * additions hides exactly the part worth approving. The fallback diffs what is
+ * in the arguments, which is all there is when a tool has nothing to say.
+ */
+function preview(call, look) {
+    if (look !== undefined)
+        return changes(look.before, look.after);
+    const input = call.input;
+    if (call.name === "write_file" && typeof input.content === "string") {
+        return changes("", input.content);
+    }
+    if (call.name === "edit_file" && typeof input.old_text === "string") {
+        return changes(input.old_text, typeof input.new_text === "string" ? input.new_text : "");
+    }
+    return undefined;
+}
+/** Two texts as the rows of their difference, unchanged runs summed up. */
+function changes(before, after) {
+    let oldLine = 1;
+    let newLine = 1;
+    const rows = [];
+    for (const changed of condense(diff(before, after), CONTEXT)) {
+        if (changed.kind === "gap") {
+            rows.push({ kind: "gap", text: `… ${changed.skipped} unchanged` });
+            oldLine += changed.skipped;
+            newLine += changed.skipped;
+            continue;
+        }
+        if (changed.kind === "keep") {
+            rows.push({ kind: "keep", text: tabs(changed.text), oldLine, newLine });
+            oldLine++;
+            newLine++;
+            continue;
+        }
+        if (changed.kind === "del") {
+            rows.push({ kind: "del", text: tabs(changed.text), oldLine });
+            oldLine++;
+            continue;
+        }
+        rows.push({ kind: "add", text: tabs(changed.text), newLine });
+        newLine++;
+    }
+    emphasizePairs(rows);
+    return rows.length === 0 ? undefined : rows;
+}
+function emphasizePairs(rows) {
+    for (let index = 0; index < rows.length - 1; index++) {
+        const removed = rows[index];
+        const added = rows[index + 1];
+        if (removed?.kind !== "del" || added?.kind !== "add")
+            continue;
+        if (rows[index - 1]?.kind === "del" || rows[index + 2]?.kind === "add")
+            continue;
+        let start = 0;
+        while (start < removed.text.length && start < added.text.length && removed.text[start] === added.text[start])
+            start++;
+        let suffix = 0;
+        while (suffix < removed.text.length - start &&
+            suffix < added.text.length - start &&
+            removed.text[removed.text.length - 1 - suffix] === added.text[added.text.length - 1 - suffix])
+            suffix++;
+        while (suffix > 0 && (!wordBoundary(removed.text, suffix) || !wordBoundary(added.text, suffix)))
+            suffix--;
+        const removedLength = removed.text.length - start - suffix;
+        const addedLength = added.text.length - start - suffix;
+        if (removedLength > 0)
+            removed.emphasis = { start, length: removedLength };
+        if (addedLength > 0)
+            added.emphasis = { start, length: addedLength };
+    }
+}
+function wordBoundary(text, suffix) {
+    const at = text.length - suffix;
+    if (at <= 0 || at >= text.length)
+        return true;
+    return /\w/.test(text[at - 1]) !== /\w/.test(text[at]);
+}
+/** What the call left behind, for the calls whose output is worth a look. */
+function produced(call, output) {
+    if (call.name === "run_command")
+        return details(output, "out");
+    // A read or a listing is already summed up on the right of its own row, and
+    // the model is about to say what was in it. Printing it twice helps nobody.
+    return undefined;
+}
+function details(text, kind) {
+    const rows = split(text).map((line) => ({ kind, text: tabs(line) }));
+    return rows.length === 0 ? undefined : rows;
+}
+function split(text) {
+    const lines = text.replace(/\r\n?/g, "\n").split("\n");
+    while (lines.length > 0 && lines[lines.length - 1] === "")
+        lines.pop();
+    return lines.map(tabs);
+}
+// A tab is a width the terminal decides and the row measurement cannot see.
+function tabs(line) {
+    return line.replace(/\t/g, "  ");
+}

package/dist/tui/view.js

@@ -0,0 +1,88 @@
+// Compose one exact-height frame from the transcript and production chrome.
+import { row } from "../ui/render.js";
+import { elide } from "../ui/width.js";
+import * as modal from "./modal.js";
+import { renderCommandMenu } from "./components/command-menu.js";
+import { renderComposer } from "./components/composer.js";
+import { renderDock } from "./components/dock.js";
+import { renderFooter } from "./components/footer.js";
+import { renderStatus, spinner } from "./components/status.js";
+import { transcriptRenderer } from "./transcript-view.js";
+export { spinner } from "./components/status.js";
+const DOCK_MAX = 6;
+const FOOTER_ROWS = 1;
+const DOCK_RULES = 2;
+const TRANSCRIPT_DOCK_GAP = 1;
+const TRANSCRIPT_MIN = 1;
+const MIN_ROWS = 14;
+const MIN_COLS = 38;
+export function compose(view, size, transcript = transcriptRenderer()) {
+    const height = Math.max(1, size.rows);
+    const width = Math.max(1, size.cols);
+    if (height < MIN_ROWS || width < MIN_COLS)
+        return tooSmall(height, width, view);
+    const dock = dockRows(view, width, height);
+    const transcriptHeight = Math.max(1, height - dock.rows.length);
+    // Any spare height belongs above the conversation, so short sessions grow
+    // upward from the fixed dock rhythm instead of leaving a changing hole
+    // beneath the latest reply.
+    const viewport = transcript.viewport(view.blocks, width, transcriptHeight, view.scroll, view.pal);
+    const cursor = dock.cursor === undefined
+        ? undefined
+        : { row: transcriptHeight + dock.cursor.row, col: dock.cursor.col };
+    return { rows: [...viewport.rows, ...dock.rows], cursor, maxScroll: viewport.maxScroll };
+}
+function dockRows(view, width, height) {
+    const status = renderStatus({
+        // A modal already names the interaction in progress. Let command feedback
+        // use the footer while that interaction is open instead of repeating a
+        // generic "Running /…" label beside it.
+        status: view.modal === undefined ? view.status : undefined,
+        feedback: view.feedback,
+        readiness: view.readiness,
+        tick: view.spin,
+        reducedMotion: view.reducedMotion === true,
+        unseen: view.unseen ?? 0,
+    }, view.pal);
+    const footer = renderFooter(view.footer, status, width, view.pal);
+    if (view.modal !== undefined) {
+        const body = {
+            rows: modal.panel(view.modal, width, view.pal, height - FOOTER_ROWS - TRANSCRIPT_MIN - TRANSCRIPT_DOCK_GAP - DOCK_RULES),
+            cursor: modal.caret(view.modal, width),
+        };
+        const dock = renderDock(body, width, view.pal, true);
+        return {
+            rows: ["", ...dock.rows, ...footer],
+            cursor: offset(dock.cursor, TRANSCRIPT_DOCK_GAP),
+        };
+    }
+    const menu = renderCommandMenu(view.menu ?? [], view.menuIndex, width, view.pal);
+    const available = height
+        - TRANSCRIPT_MIN
+        - TRANSCRIPT_DOCK_GAP
+        - menu.length
+        - FOOTER_ROWS
+        - DOCK_RULES;
+    const composer = renderComposer(view.editor, width, Math.max(1, Math.min(DOCK_MAX, available)), view.pal);
+    const dock = renderDock({ rows: [...composer.rows, ...menu], cursor: composer.cursor }, width, view.pal, menu.length > 0);
+    return {
+        rows: ["", ...dock.rows, ...footer],
+        cursor: offset(dock.cursor, TRANSCRIPT_DOCK_GAP),
+    };
+}
+function offset(cursor, rows) {
+    return cursor === undefined ? undefined : { row: cursor.row + rows, col: cursor.col };
+}
+function tooSmall(height, width, view) {
+    const rows = Array.from({ length: height }, () => "");
+    const middle = Math.floor(height / 2);
+    rows[middle] = row(width, [
+        { text: elide("jecode · terminal too small", Math.max(1, width)), fg: view.pal.accent, bold: true },
+    ]);
+    if (middle + 1 < height) {
+        rows[middle + 1] = row(width, [
+            { text: elide(`need ${MIN_COLS}×${MIN_ROWS}`, Math.max(1, width)), fg: view.pal.ink.muted },
+        ]);
+    }
+    return { rows, maxScroll: 0 };
+}

package/dist/tui/workspace.js

@@ -0,0 +1,59 @@
+// Compact workspace identity for the persistent footer.
+import { readFile, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import * as path from "node:path";
+export async function workspaceLabel(root) {
+    const shown = displayRoot(root);
+    const branch = await findBranch(root);
+    return branch === undefined ? shown : `${shown} (${branch})`;
+}
+export function displayRoot(root, home = homedir()) {
+    const resolvedHome = path.resolve(home);
+    const absolute = path.resolve(root);
+    const relative = path.relative(resolvedHome, absolute);
+    const inside = relative === "" ||
+        (relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative));
+    return inside ? (relative === "" ? "~" : `~${path.sep}${relative}`) : absolute;
+}
+async function findBranch(root) {
+    let directory = path.resolve(root);
+    for (;;) {
+        const branch = await branchAt(directory);
+        if (branch !== undefined)
+            return branch;
+        const parent = path.dirname(directory);
+        if (parent === directory)
+            return undefined;
+        directory = parent;
+    }
+}
+async function branchAt(directory) {
+    const marker = path.join(directory, ".git");
+    try {
+        const info = await stat(marker);
+        if (info.isDirectory())
+            return readHead(marker);
+        if (!info.isFile())
+            return undefined;
+        const pointer = await readFile(marker, "utf8");
+        const match = /^gitdir:\s*(.+)\s*$/im.exec(pointer);
+        if (match === null)
+            return undefined;
+        return readHead(path.resolve(directory, match[1]));
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readHead(gitDirectory) {
+    try {
+        const head = (await readFile(path.join(gitDirectory, "HEAD"), "utf8")).trim();
+        const prefix = "ref: refs/heads/";
+        if (head.startsWith(prefix))
+            return head.slice(prefix.length);
+        return /^[0-9a-f]{7,}$/i.test(head) ? head.slice(0, 7) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/types.js

@@ -0,0 +1,9 @@
+// The normalized vocabulary the controller speaks. Deliberately smaller than
+// any vendor's wire format: text, a tool call, a tool result. Providers
+// translate to and from this; the controller never sees a vendor shape.
+export function isToolCall(block) {
+    return block.kind === "tool_call";
+}
+export function isText(block) {
+    return block.kind === "text";
+}

package/dist/ui/diff.js

@@ -0,0 +1,109 @@
+// Comparing two texts line by line.
+//
+// Written here rather than shelled out to `git diff`, because a tool result has
+// to be drawable on a machine with no git, in a workspace that is not a repo,
+// for text that was never on disk — the new half of an edit exists only in the
+// call the model just made.
+/**
+ * Above this many cells the table stops being worth building.
+ *
+ * The diff is quadratic in the two line counts, and it is drawn between two
+ * keystrokes. Past the ceiling the honest answer is the coarse one — all of
+ * the old, then all of the new — rather than a frame the user waits for.
+ */
+const CEILING = 250_000;
+export function diff(before, after) {
+    const a = lines(before);
+    const b = lines(after);
+    if (a.length * b.length > CEILING) {
+        return [...a.map(del), ...b.map(add)];
+    }
+    const table = common(a, b);
+    const rows = [];
+    let i = 0;
+    let j = 0;
+    const width = b.length + 1;
+    while (i < a.length && j < b.length) {
+        if (a[i] === b[j]) {
+            rows.push({ kind: "keep", text: a[i] });
+            i++;
+            j++;
+            continue;
+        }
+        // Deletions first on a tie, so a replaced line reads old-then-new — the
+        // order the eye expects, and the order every other diff prints.
+        if (table[(i + 1) * width + j] >= table[i * width + j + 1]) {
+            rows.push(del(a[i]));
+            i++;
+        }
+        else {
+            rows.push(add(b[j]));
+            j++;
+        }
+    }
+    while (i < a.length)
+        rows.push(del(a[i++]));
+    while (j < b.length)
+        rows.push(add(b[j++]));
+    return rows;
+}
+/**
+ * Drop the unchanged stretches, keeping `context` rows either side.
+ *
+ * A diff nobody can see the changes in is a wall of text with a colour in it.
+ */
+export function condense(rows, context) {
+    const near = new Set();
+    rows.forEach((row, index) => {
+        if (row.kind === "keep")
+            return;
+        for (let k = index - context; k <= index + context; k++)
+            near.add(k);
+    });
+    const out = [];
+    let skipped = 0;
+    const flush = () => {
+        if (skipped > 0)
+            out.push({ kind: "gap", skipped });
+        skipped = 0;
+    };
+    rows.forEach((row, index) => {
+        if (near.has(index)) {
+            flush();
+            out.push(row);
+        }
+        else {
+            skipped++;
+        }
+    });
+    flush();
+    return out;
+}
+/** Lengths of the longest common subsequence of every pair of suffixes. */
+function common(a, b) {
+    const width = b.length + 1;
+    const table = new Uint32Array((a.length + 1) * width);
+    for (let i = a.length - 1; i >= 0; i--) {
+        for (let j = b.length - 1; j >= 0; j--) {
+            table[i * width + j] =
+                a[i] === b[j]
+                    ? table[(i + 1) * width + j + 1] + 1
+                    : Math.max(table[(i + 1) * width + j], table[i * width + j + 1]);
+        }
+    }
+    return table;
+}
+// A trailing newline is a property of the file, not a line of it: counting it
+// as one would report every append as touching two lines instead of one.
+function lines(text) {
+    const split = text.split("\n");
+    if (split.length > 1 && split[split.length - 1] === "")
+        split.pop();
+    return split;
+}
+function add(text) {
+    return { kind: "add", text };
+}
+function del(text) {
+    return { kind: "del", text };
+}

package/dist/ui/highlight.js

@@ -0,0 +1,158 @@
+// Colouring a fenced code block.
+//
+// Not a parser and not trying to be one: a code block on screen is read, not
+// compiled, and what a reader needs is the shape — where the strings end, what
+// is a comment, which words are the language's own. Five roles carry all of
+// that, and a language nobody here knows gets no colour at all rather than
+// colour that is wrong, because wrong highlighting reads as a wrong program.
+const FAMILIES = {
+    ts: "clike",
+    tsx: "clike",
+    typescript: "clike",
+    js: "clike",
+    jsx: "clike",
+    javascript: "clike",
+    mjs: "clike",
+    java: "clike",
+    c: "clike",
+    cpp: "clike",
+    cs: "clike",
+    go: "clike",
+    rust: "clike",
+    rs: "clike",
+    swift: "clike",
+    php: "clike",
+    py: "python",
+    python: "python",
+    sh: "shell",
+    bash: "shell",
+    zsh: "shell",
+    shell: "shell",
+    console: "shell",
+    ps1: "shell",
+    powershell: "shell",
+    json: "json",
+    jsonc: "json",
+};
+const KEYWORDS = {
+    clike: new Set([
+        "abstract", "as", "async", "await", "break", "case", "catch", "class", "const",
+        "continue", "declare", "default", "delete", "do", "else", "enum", "export",
+        "extends", "false", "finally", "for", "from", "func", "function", "get", "if",
+        "implements", "import", "in", "instanceof", "interface", "let", "new", "null",
+        "of", "package", "private", "protected", "public", "readonly", "return", "set",
+        "static", "struct", "super", "switch", "this", "throw", "true", "try", "type",
+        "typeof", "undefined", "var", "void", "while", "yield",
+    ]),
+    python: new Set([
+        "and", "as", "assert", "async", "await", "break", "class", "continue", "def",
+        "del", "elif", "else", "except", "False", "finally", "for", "from", "global",
+        "if", "import", "in", "is", "lambda", "None", "nonlocal", "not", "or", "pass",
+        "raise", "return", "True", "try", "while", "with", "yield",
+    ]),
+    shell: new Set([
+        "case", "cd", "do", "done", "echo", "elif", "else", "esac", "exit", "export",
+        "fi", "for", "function", "if", "in", "local", "return", "set", "then", "while",
+    ]),
+    json: new Set(["false", "null", "true"]),
+    none: new Set(),
+};
+const LINE_COMMENT = {
+    clike: ["//"],
+    python: ["#"],
+    shell: ["#"],
+    json: [],
+    none: [],
+};
+const WORD = /[A-Za-z_$][A-Za-z0-9_$]*/y;
+// Hex first: the decimal branch would otherwise match the leading 0 of 0x1f
+// and leave the rest of the literal looking like an identifier.
+const NUMBER = /0[xXbBoO][0-9a-fA-F_]+|\d[\d_]*(?:\.\d+)?(?:[eE][+-]?\d+)?/y;
+export function family(lang) {
+    return FAMILIES[lang.trim().toLowerCase().split(/\s+/)[0] ?? ""] ?? "none";
+}
+/**
+ * Tokenize a whole block, because a block comment and a template string both
+ * outlive the line they open on. State is carried between lines rather than
+ * rediscovered, which is the only way the row after `/*` comes out grey.
+ */
+export function highlight(lines, lang) {
+    const kind = family(lang);
+    if (kind === "none")
+        return lines.map((line) => [{ text: line, role: "plain" }]);
+    const keywords = KEYWORDS[kind];
+    const comments = LINE_COMMENT[kind];
+    let inBlock = false;
+    return lines.map((line) => {
+        const tokens = [];
+        let plain = "";
+        let i = 0;
+        const flush = () => {
+            if (plain !== "")
+                tokens.push({ text: plain, role: "plain" });
+            plain = "";
+        };
+        const take = (text, role) => {
+            flush();
+            tokens.push({ text, role });
+            i += text.length;
+        };
+        while (i < line.length) {
+            if (inBlock) {
+                const end = line.indexOf("*/", i);
+                const stop = end === -1 ? line.length : end + 2;
+                take(line.slice(i, stop), "comment");
+                inBlock = end === -1;
+                continue;
+            }
+            const rest = line.slice(i);
+            if (kind === "clike" && rest.startsWith("/*")) {
+                inBlock = true;
+                continue;
+            }
+            const comment = comments.find((mark) => rest.startsWith(mark));
+            if (comment !== undefined) {
+                take(rest, "comment");
+                continue;
+            }
+            const quote = line[i];
+            if (quote === '"' || quote === "'" || quote === "`") {
+                take(line.slice(i, closingQuote(line, i, quote)), "string");
+                continue;
+            }
+            NUMBER.lastIndex = i;
+            const number = NUMBER.exec(line);
+            if (number !== null && number.index === i) {
+                take(number[0], "number");
+                continue;
+            }
+            WORD.lastIndex = i;
+            const word = WORD.exec(line);
+            if (word !== null && word.index === i) {
+                if (keywords.has(word[0]))
+                    take(word[0], "keyword");
+                else {
+                    plain += word[0];
+                    i += word[0].length;
+                }
+                continue;
+            }
+            plain += quote;
+            i += 1;
+        }
+        flush();
+        return tokens.length === 0 ? [{ text: "", role: "plain" }] : tokens;
+    });
+}
+/** Index just past the closing quote, or the end of the line if it never comes. */
+function closingQuote(line, start, quote) {
+    for (let i = start + 1; i < line.length; i++) {
+        if (line[i] === "\\") {
+            i++;
+            continue;
+        }
+        if (line[i] === quote)
+            return i + 1;
+    }
+    return line.length;
+}