@scira/cli 0.1.0

package/dist/ui/ink/lib/markdown.js

@@ -0,0 +1,245 @@
+import { displayWidth } from "./utils.js";
+export function parseInlineMarkdown(text) {
+    const segs = [];
+    const re = /(\[[^\]]+\]\([^)]+\))|(`[^`]+`)|(\*\*[^*]+\*\*)|(__[^_]+__)|(\*[^*\s][^*]*\*)|(_[^_\s][^_]*_)/gu;
+    let last = 0;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+        if (m.index > last)
+            segs.push({ text: text.slice(last, m.index) });
+        const tok = m[0];
+        if (tok.startsWith("`"))
+            segs.push({ text: tok.slice(1, -1), color: "#FFE0C2" });
+        else if (tok.startsWith("**") || tok.startsWith("__"))
+            segs.push({ text: tok.slice(2, -2), bold: true });
+        else if (tok.startsWith("[")) {
+            const link = /^\[([^\]]+)\]\(([^)]+)\)$/u.exec(tok);
+            segs.push({ text: link ? link[1] : tok, color: "#FFE0C2", underline: true, url: link ? link[2] : undefined });
+        }
+        else
+            segs.push({ text: tok.slice(1, -1), italic: true });
+        last = re.lastIndex;
+    }
+    if (last < text.length)
+        segs.push({ text: text.slice(last) });
+    return segs.length > 0 ? segs : [{ text: "" }];
+}
+export function wrapSegments(segs, width) {
+    const w = Math.max(10, width);
+    const lines = [];
+    let line = [];
+    let len = 0;
+    const flush = () => { lines.push(line); line = []; len = 0; };
+    for (const seg of segs) {
+        for (const part of seg.text.split(/(\s+)/u)) {
+            if (part === "")
+                continue;
+            if (/^\s+$/u.test(part)) {
+                if (len === 0)
+                    continue;
+                if (len + 1 <= w) {
+                    line.push({ ...seg, text: " " });
+                    len += 1;
+                }
+                else
+                    flush();
+                continue;
+            }
+            let word = part;
+            while (displayWidth(word) > w) {
+                if (len > 0)
+                    flush();
+                let cells = 0;
+                let chars = 0;
+                for (const ch of word) {
+                    const cw = displayWidth(ch);
+                    if (cells + cw > w)
+                        break;
+                    cells += cw;
+                    chars += ch.length;
+                }
+                line.push({ ...seg, text: word.slice(0, chars) });
+                len = w;
+                flush();
+                word = word.slice(chars);
+            }
+            const wordW = displayWidth(word);
+            if (len > 0 && len + wordW > w)
+                flush();
+            line.push({ ...seg, text: word });
+            len += wordW;
+        }
+    }
+    if (line.length > 0)
+        flush();
+    return lines.length > 0 ? lines : [[]];
+}
+export function parseMarkdownTable(lines, start) {
+    const header = lines[start];
+    const divider = lines[start + 1];
+    if (!header || !divider)
+        return null;
+    const isRow = (line) => /^\s*\|.*\|\s*$/u.test(line);
+    const isDivider = (line) => /^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)+\|?\s*$/u.test(line);
+    if (!isRow(header) || !isDivider(divider))
+        return null;
+    const split = (line) => {
+        const trimmed = line.trim().replace(/^\|/u, "").replace(/\|$/u, "");
+        const cells = [];
+        let current = "";
+        let inCode = false;
+        for (let i = 0; i < trimmed.length; i += 1) {
+            const ch = trimmed[i];
+            const prev = trimmed[i - 1];
+            if (ch === "`" && prev !== "\\")
+                inCode = !inCode;
+            if (ch === "|" && prev !== "\\" && !inCode) {
+                cells.push(current.trim().replace(/\\\|/gu, "|"));
+                current = "";
+            }
+            else {
+                current += ch;
+            }
+        }
+        cells.push(current.trim().replace(/\\\|/gu, "|"));
+        return cells;
+    };
+    const rows = [split(header)];
+    let i = start + 2;
+    while (i < lines.length && isRow(lines[i])) {
+        rows.push(split(lines[i]));
+        i += 1;
+    }
+    return { rows, end: i };
+}
+export function segsTextLength(segs) {
+    return segs.reduce((n, seg) => n + displayWidth(seg.text), 0);
+}
+export function truncateSegs(segs, width) {
+    if (segsTextLength(segs) <= width)
+        return segs;
+    const out = [];
+    let remaining = Math.max(0, width - 1);
+    for (const seg of segs) {
+        if (remaining <= 0)
+            break;
+        const segW = displayWidth(seg.text);
+        if (segW <= remaining) {
+            out.push(seg);
+            remaining -= segW;
+        }
+        else {
+            let cells = 0;
+            let chars = 0;
+            for (const ch of seg.text) {
+                const cw = displayWidth(ch);
+                if (cells + cw > remaining)
+                    break;
+                cells += cw;
+                chars += ch.length;
+            }
+            out.push({ ...seg, text: seg.text.slice(0, chars) });
+            remaining = 0;
+        }
+    }
+    out.push({ text: "…", color: "gray", dim: true });
+    return out;
+}
+export function tableToSegLines(rows, width) {
+    const cols = Math.max(...rows.map((row) => row.length));
+    const colWidths = Array.from({ length: cols }, (_, col) => Math.max(3, ...rows.map((row) => displayWidth(row[col] ?? ""))));
+    const total = colWidths.reduce((n, w) => n + w, 0) + Math.max(0, cols - 1) * 3;
+    if (total > width) {
+        const scale = Math.max(0.35, (width - Math.max(0, cols - 1) * 3) / Math.max(1, colWidths.reduce((n, w) => n + w, 0)));
+        for (let i = 0; i < colWidths.length; i += 1)
+            colWidths[i] = Math.max(3, Math.floor(colWidths[i] * scale));
+    }
+    const out = [];
+    rows.forEach((row, rowIndex) => {
+        const segs = [];
+        for (let col = 0; col < cols; col += 1) {
+            const raw = row[col] ?? "";
+            const parsed = truncateSegs(parseInlineMarkdown(raw), colWidths[col]);
+            const pad = Math.max(0, colWidths[col] - segsTextLength(parsed));
+            if (col > 0)
+                segs.push({ text: " │ ", color: "gray", dim: true });
+            segs.push(...parsed.map((seg) => ({ ...seg, bold: rowIndex === 0 ? true : seg.bold, color: rowIndex === 0 ? "white" : seg.color })));
+            if (pad > 0)
+                segs.push({ text: " ".repeat(pad) });
+        }
+        out.push(segs);
+        if (rowIndex === 0) {
+            const rule = [];
+            for (let col = 0; col < cols; col += 1) {
+                if (col > 0)
+                    rule.push({ text: "─┼─", color: "gray", dim: true });
+                rule.push({ text: "─".repeat(colWidths[col]), color: "gray", dim: true });
+            }
+            out.push(rule);
+        }
+    });
+    return out;
+}
+export function markdownToSegLines(text, width) {
+    const out = [];
+    let inFence = false;
+    const normalized = text
+        .replace(/(\[[^\]\n]*)\n\s*([^\]\n]*\]\([^)]+\))/gu, "$1 $2")
+        .replace(/(\[[^\]]+\])\n\s*(\([^)]+\))/gu, "$1$2");
+    const rawLines = normalized.split("\n");
+    for (let lineIndex = 0; lineIndex < rawLines.length; lineIndex += 1) {
+        const raw = rawLines[lineIndex];
+        if (/^\s*```/u.test(raw)) {
+            inFence = !inFence;
+            continue;
+        }
+        if (inFence) {
+            const gutter = { text: "  │ ", color: "gray", dim: true };
+            const wrapped = wrapSegments([{ text: raw || " ", color: "#FFE0C2", dim: true }], width - 4);
+            for (const ln of wrapped)
+                out.push([gutter, ...ln]);
+            continue;
+        }
+        const table = parseMarkdownTable(rawLines, lineIndex);
+        if (table) {
+            out.push(...tableToSegLines(table.rows, width));
+            lineIndex = table.end - 1;
+            continue;
+        }
+        if (raw.trim() === "") {
+            out.push([]);
+            continue;
+        }
+        if (/^\s*([-*_])(\s*\1){2,}\s*$/u.test(raw)) {
+            out.push([{ text: "─".repeat(Math.max(3, width - 1)), color: "gray", dim: true }]);
+            continue;
+        }
+        const heading = /^(#{1,6})\s+(.*)$/u.exec(raw);
+        if (heading) {
+            const color = heading[1].length <= 2 ? "#FFE0C2" : "white";
+            const segs = parseInlineMarkdown(heading[2]).map((s) => ({ ...s, bold: true, color }));
+            for (const ln of wrapSegments(segs, width))
+                out.push(ln);
+            continue;
+        }
+        const quote = /^\s*>\s?(.*)$/u.exec(raw);
+        if (quote) {
+            const segs = parseInlineMarkdown(quote[1]).map((s) => ({ ...s, dim: true }));
+            for (const ln of wrapSegments(segs, width - 2))
+                out.push([{ text: "│ ", color: "gray", dim: true }, ...ln]);
+            continue;
+        }
+        const list = /^(\s*)(?:[-*+]|(\d+)[.)])\s+(.*)$/u.exec(raw);
+        if (list) {
+            const marker = list[2] ? `${list[2]}. ` : "• ";
+            const prefix = list[1] + marker;
+            const segs = parseInlineMarkdown(list[3]);
+            const wrapped = wrapSegments(segs, Math.max(10, width - prefix.length));
+            wrapped.forEach((ln, i) => out.push([{ text: i === 0 ? prefix : " ".repeat(prefix.length), color: "#FFE0C2" }, ...ln]));
+            continue;
+        }
+        for (const ln of wrapSegments(parseInlineMarkdown(raw), width))
+            out.push(ln);
+    }
+    return out;
+}

package/dist/ui/ink/lib/utils.js

@@ -0,0 +1,224 @@
+import { readFileSync } from "node:fs";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import stringWidth from "string-width";
+import { FULL_MODE_TRIGGERS } from "../constants.js";
+export const pkgVersion = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), "../../../../package.json"), "utf8")).version;
+/** Pipe text to the OS clipboard (pbcopy / clip / xclip). Resolves false when unavailable. */
+export function copyToClipboard(text) {
+    return new Promise((res) => {
+        const cmd = process.platform === "darwin" ? "pbcopy" : process.platform === "win32" ? "clip" : "xclip";
+        const args = cmd === "xclip" ? ["-selection", "clipboard"] : [];
+        const child = spawn(cmd, args, { stdio: ["pipe", "ignore", "ignore"] });
+        child.on("error", () => res(false));
+        child.on("close", (code) => res(code === 0));
+        child.stdin.write(text);
+        child.stdin.end();
+    });
+}
+function historyFile(runDirectory) {
+    return resolve(process.cwd(), runDirectory, "..", "input-history.json");
+}
+export async function loadInputHistory(runDirectory) {
+    try {
+        const parsed = JSON.parse(await readFile(historyFile(runDirectory), "utf8"));
+        return Array.isArray(parsed) ? parsed.filter((x) => typeof x === "string").slice(-50) : [];
+    }
+    catch {
+        return [];
+    }
+}
+export async function saveInputHistory(runDirectory, history) {
+    try {
+        const file = historyFile(runDirectory);
+        await mkdir(dirname(file), { recursive: true });
+        await writeFile(file, JSON.stringify(history.slice(-50), null, 2));
+    }
+    catch { /* non-fatal */ }
+}
+export const CWD_DISPLAY = (() => {
+    const home = homedir();
+    const cwd = process.cwd();
+    return cwd.startsWith(home) ? "~" + cwd.slice(home.length) : cwd;
+})();
+export function prettifyModelId(id) {
+    const slug = id.includes("/") ? id.split("/").pop() : id;
+    return slug
+        .split(/[-_]/u)
+        .map((w) => (/^[0-9]/u.test(w) ? w : w.charAt(0).toUpperCase() + w.slice(1)))
+        .join(" ");
+}
+/** Terminal-cell width of a string (CJK/emoji aware, strips ANSI). */
+export function displayWidth(text) {
+    return stringWidth(text);
+}
+/** Longest prefix of `text` whose terminal-cell width fits in `width`; returns its char length. */
+function fitChars(text, width) {
+    if (stringWidth(text) === text.length)
+        return Math.min(text.length, width);
+    let cells = 0;
+    let chars = 0;
+    for (const ch of text) {
+        const w = stringWidth(ch);
+        if (cells + w > width)
+            break;
+        cells += w;
+        chars += ch.length;
+    }
+    return chars;
+}
+export function wrapText(text, width) {
+    const w = Math.max(20, width);
+    const out = [];
+    for (const raw of text.split("\n")) {
+        let line = raw;
+        if (line.length === 0) {
+            out.push("");
+            continue;
+        }
+        while (displayWidth(line) > w) {
+            const fit = fitChars(line, w);
+            const slice = line.slice(0, fit);
+            const sp = slice.lastIndexOf(" ");
+            if (sp > fit * 0.5) {
+                out.push(line.slice(0, sp));
+                line = line.slice(sp + 1);
+            }
+            else {
+                out.push(slice);
+                line = line.slice(fit);
+            }
+        }
+        out.push(line);
+    }
+    return out;
+}
+export function formatTime(ts) {
+    if (!ts)
+        return "";
+    return new Date(ts).toLocaleTimeString("en-US", { hour: "numeric", minute: "2-digit" });
+}
+export function fmtDuration(ms) {
+    if (!ms || ms < 0)
+        return "0s";
+    if (ms < 1000)
+        return `${ms}ms`;
+    const s = ms / 1000;
+    if (s < 60)
+        return `${s.toFixed(s < 10 ? 1 : 0)}s`;
+    const m = Math.floor(s / 60);
+    const rem = Math.round(s - m * 60);
+    return rem === 0 ? `${m}m` : `${m}m${rem}s`;
+}
+export function fmtTokens(n) {
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 10_000)
+        return `${Math.round(n / 1000)}k`;
+    if (n >= 1_000)
+        return `${(n / 1000).toFixed(1)}k`;
+    return String(n);
+}
+/** Compact relative time, e.g. "now", "5m", "3h", "2d", "3w". */
+export function relativeTime(ms) {
+    if (!ms)
+        return "";
+    const diff = Date.now() - ms;
+    if (diff < 60_000)
+        return "now";
+    const mins = Math.floor(diff / 60_000);
+    if (mins < 60)
+        return `${mins}m ago`;
+    const hours = Math.floor(mins / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    if (days < 7)
+        return `${days}d ago`;
+    const weeks = Math.floor(days / 7);
+    if (weeks < 5)
+        return `${weeks}w ago`;
+    return new Date(ms).toLocaleDateString();
+}
+/** Wrap text in an OSC 8 terminal hyperlink (clickable in supported terminals). */
+export function hyperlink(text, url) {
+    if (!url)
+        return text;
+    return `\x1b]8;;${url}\x1b\\${text}\x1b]8;;\x1b\\`;
+}
+/** True if the prompt clearly asks for full, report-grade research. */
+export function wantsFullResearch(prompt) {
+    const p = prompt.toLowerCase();
+    return FULL_MODE_TRIGGERS.some((kw) => p.includes(kw));
+}
+/** Word-wrap input text and locate the caret in the wrapped output (no cursor char injection). */
+export function wrapInputWithCursor(text, width, caretPos) {
+    const w = Math.max(1, width);
+    const lines = [];
+    let cursorLine = 0;
+    let cursorCol = 0;
+    let i = 0;
+    while (i < text.length || lines.length === 0) {
+        const remaining = text.slice(i);
+        if (remaining.length === 0) {
+            lines.push("");
+            break;
+        }
+        let lineEnd;
+        if (remaining.length <= w) {
+            lineEnd = remaining.length;
+        }
+        else {
+            const slice = remaining.slice(0, w);
+            const sp = slice.lastIndexOf(" ");
+            lineEnd = sp > Math.floor(w * 0.4) ? sp : w;
+        }
+        const line = remaining.slice(0, lineEnd);
+        if (caretPos >= i && caretPos <= i + lineEnd) {
+            cursorLine = lines.length;
+            cursorCol = caretPos - i;
+        }
+        lines.push(line);
+        const skipSpace = text[i + lineEnd] === " " ? 1 : 0;
+        i += lineEnd + skipSpace;
+    }
+    if (caretPos >= text.length && lines.length > 0) {
+        cursorLine = lines.length - 1;
+        cursorCol = lines[lines.length - 1].length;
+    }
+    return { lines: lines.length ? lines : [""], cursorLine, cursorCol };
+}
+export function aggregateTurns(turns) {
+    const byModel = {};
+    const total = { input: 0, output: 0, total: 0 };
+    for (const t of turns) {
+        const cur = byModel[t.model] ?? { input: 0, output: 0, total: 0, turns: 0 };
+        byModel[t.model] = { input: cur.input + t.input, output: cur.output + t.output, total: cur.total + t.total, turns: cur.turns + 1 };
+        total.input += t.input;
+        total.output += t.output;
+        total.total += t.total;
+    }
+    return { total, byModel, turns };
+}
+export function summarizeToolInput(name, input) {
+    const obj = (input ?? {});
+    if (name === "bash")
+        return String(obj.command ?? "");
+    if (name === "webSearch") {
+        const queries = Array.isArray(obj.queries) ? obj.queries : [];
+        return queries.length > 0 ? queries.slice(0, 2).join(" · ") + (queries.length > 2 ? ` +${queries.length - 2}` : "") : String(obj.query ?? "");
+    }
+    if (name === "readUrl")
+        return String(obj.url ?? "");
+    if (name === "writeFile" || name === "editFile" || name === "readFile")
+        return String(obj.path ?? "");
+    try {
+        return JSON.stringify(obj).slice(0, 80);
+    }
+    catch {
+        return "";
+    }
+}

package/dist/ui/ink/session-manager.js

@@ -0,0 +1,160 @@
+const sessions = new Map();
+export function getSession(runPath) {
+    return sessions.get(runPath);
+}
+export function createSession(runPath) {
+    const existing = sessions.get(runPath);
+    if (existing)
+        return existing;
+    const session = {
+        runPath,
+        feedBuffer: [],
+        busy: false,
+        approvalPending: null,
+        abort: null,
+        subscriber: null,
+    };
+    sessions.set(runPath, session);
+    return session;
+}
+export function attachSubscriber(runPath, sub) {
+    const session = sessions.get(runPath);
+    if (!session)
+        return [];
+    session.subscriber = sub;
+    return [...session.feedBuffer];
+}
+export function detachSubscriber(runPath) {
+    const session = sessions.get(runPath);
+    if (session)
+        session.subscriber = null;
+    // deliberately NOT aborting — stream keeps running in the background
+}
+export function abortSession(runPath) {
+    const session = sessions.get(runPath);
+    if (!session)
+        return;
+    session.abort?.abort();
+    session.abort = null;
+    session.busy = false;
+    sessions.delete(runPath);
+}
+export function removeSession(runPath) {
+    sessions.delete(runPath);
+}
+/** Route a feed item to the correct subscriber method and buffer it. */
+export function sessionPushFeed(runPath, item) {
+    const session = sessions.get(runPath);
+    if (!session)
+        return;
+    const sub = session.subscriber;
+    if (sub) {
+        // Route to fine-grained helpers for smooth streaming rendering
+        if (item.kind === "text") {
+            sub.appendText(item.text);
+            // Keep buffer in sync: merge into last text item or push new
+            const last = session.feedBuffer.at(-1);
+            if (last?.kind === "text") {
+                session.feedBuffer[session.feedBuffer.length - 1] = { ...last, text: last.text + item.text };
+            }
+            else {
+                session.feedBuffer.push(item);
+            }
+            return;
+        }
+        if (item.kind === "reasoning") {
+            sub.appendReasoning(item.text);
+            const last = session.feedBuffer.at(-1);
+            if (last?.kind === "reasoning" && last.durationMs === undefined) {
+                session.feedBuffer[session.feedBuffer.length - 1] = { ...last, text: last.text + item.text };
+            }
+            else {
+                session.feedBuffer.push({ ...item, startedAt: item.startedAt ?? Date.now() });
+            }
+            return;
+        }
+        if (item.kind === "tool" && (item.status === "done" || item.status === "error") && item.toolCallId) {
+            sub.markToolDone(item.toolCallId, item.status, item.result);
+            // Update existing tool item in buffer
+            for (let i = session.feedBuffer.length - 1; i >= 0; i--) {
+                const b = session.feedBuffer[i];
+                if (b.kind === "tool" && b.status === "running" && (b.toolCallId === item.toolCallId || !item.toolCallId)) {
+                    session.feedBuffer[i] = { ...b, status: item.status, result: item.result };
+                    break;
+                }
+            }
+            return;
+        }
+        sub.pushFeed(item);
+    }
+    // No subscriber — always buffer
+    if (item.kind === "tool" && (item.status === "done" || item.status === "error") && item.toolCallId) {
+        for (let i = session.feedBuffer.length - 1; i >= 0; i--) {
+            const b = session.feedBuffer[i];
+            if (b.kind === "tool" && b.status === "running" && (b.toolCallId === item.toolCallId || !item.toolCallId)) {
+                session.feedBuffer[i] = { ...b, status: item.status, result: item.result };
+                return;
+            }
+        }
+    }
+    if (item.kind === "text") {
+        const last = session.feedBuffer.at(-1);
+        if (last?.kind === "text") {
+            session.feedBuffer[session.feedBuffer.length - 1] = { ...last, text: last.text + item.text };
+            return;
+        }
+    }
+    if (item.kind === "reasoning") {
+        const last = session.feedBuffer.at(-1);
+        if (last?.kind === "reasoning" && last.durationMs === undefined) {
+            session.feedBuffer[session.feedBuffer.length - 1] = { ...last, text: last.text + item.text };
+            return;
+        }
+        session.feedBuffer.push({ ...item, startedAt: item.startedAt ?? Date.now() });
+        return;
+    }
+    session.feedBuffer.push(item);
+}
+export function sessionFinishReasoning(runPath) {
+    const session = sessions.get(runPath);
+    if (!session)
+        return;
+    const ended = Date.now();
+    for (let i = session.feedBuffer.length - 1; i >= 0; i--) {
+        const item = session.feedBuffer[i];
+        if (item.kind === "reasoning" && item.durationMs === undefined) {
+            session.feedBuffer[i] = { ...item, durationMs: ended - (item.startedAt ?? ended) };
+            break;
+        }
+    }
+    session.subscriber?.finishReasoning();
+}
+export function sessionSetBusy(runPath, busy) {
+    const session = sessions.get(runPath);
+    if (!session)
+        return;
+    session.busy = busy;
+    session.subscriber?.onBusyChange(busy);
+}
+export function sessionSetApproval(runPath, pending) {
+    const session = sessions.get(runPath);
+    if (!session)
+        return;
+    session.approvalPending = pending;
+    // NOTE: The resolve closure in pending is captured per-promise, so it correctly
+    // resolves even if the subscriber changed (user navigated away and back).
+    if (pending) {
+        session.subscriber?.onApprovalRequired(pending);
+    }
+    else {
+        session.subscriber?.onApprovalCleared();
+    }
+}
+export function sessionNotifyEscalate(runPath) {
+    const session = sessions.get(runPath);
+    session?.subscriber?.onEscalate();
+}
+export function sessionNotifyModeChange(runPath, full) {
+    const session = sessions.get(runPath);
+    session?.subscriber?.onModeChange(full);
+}

package/dist/ui/ink/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/ids.js

@@ -0,0 +1,15 @@
+export function slugify(input) {
+    return input
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 64) || "research";
+}
+export function createRunId(goal, date = new Date()) {
+    const stamp = date.toISOString().slice(0, 10);
+    const time = date.toISOString().slice(11, 19).replace(/:/g, "");
+    return `${stamp}-${time}-${slugify(goal)}`;
+}
+export function createEntityId(prefix, index) {
+    return `${prefix}_${String(index).padStart(3, "0")}`;
+}