talos-code 0.0.1 → 0.1.0

package/dist/tui/tools/row-format.js

@@ -0,0 +1,187 @@
+/*
+ * R3 lane RD — the ONE tool row (gate E1), owner decisions of 2026-09-24 (ledger "R3 — tools and approvals"):
+ *
+ *   <Label> <target> · <isolation> · <why it ran> · <result> · <duration>        (Q-R3-1)
+ *     <detail lines: output tail / diff / reason>
+ *
+ *   - isolation: commands only (file tools are governed by permissions, R0 decision 3), from the CLI's own annotation as
+ *     structured `facts.isolation` (gate E6), never kernel prose;
+ *   - why it ran: the decision kinds (Q-R3-3); a person's `!` command is `typed by you`; nothing without a decision;
+ *   - result: commands `exit N` (receipt or facts, gate E3), reads `N lines`, lists `N entries`, searches `N results`,
+ *     writes `new file · N lines` or `+a −r`, edits `+a −r`; nothing to say is `done`;
+ *   - duration: the kernel's measured `durationMs` only (never the CLI clock, which includes the approval wait): always
+ *     for commands, from 1 s for other tools (Q-R3-2);
+ *   - a state other than done replaces result and duration with its word (`waiting for you`, `running 12 s`, `denied`,
+ *     `interrupted after 4.2 s`, `failed` + the exit code or the reason) — dictionary words, never the enum (E2);
+ *   - too wide: the target is cut in the middle, then the duration goes, then the isolation word leaves its glyph; the
+ *     glyph, the why field and the state word or exit code are never dropped. If even that does not fit, the target
+ *     shrinks to `…`, then an `allow:` rule is cut in the middle, and whatever remains wraps (the estimate counts the
+ *     same wrap, because it measures this same line).
+ */
+import { t } from "../../i18n/index.js";
+import { displayWidth, truncateDisplay, truncateMiddle } from "../text-width.js";
+import { boundedLines, detailWidth, formatDuration, labelFor, sanitizeDisplayText, withoutKernelExitLine } from "./shared.js";
+const SEPARATOR = ' · ';
+/* The target keeps at least this many columns while facts are still being shortened (then it may shrink to `…`). */
+const TARGET_MIN = 12;
+/** Q-R3-3: why a tool was allowed to run, in the owner's words; null when no decision was involved. */
+function whyFact(row) {
+    const decision = row.decision ?? (row.origin === 'person' ? { kind: 'typed' } : null);
+    if (!decision)
+        return null;
+    if (decision.kind === 'rule') {
+        const rule = sanitizeDisplayText(String(decision.rule ?? '')).replace(/\s*\n\s*/gu, ' ');
+        return { role: 'why', text: t('tool.why.rule', { rule }), rule };
+    }
+    return { role: 'why', text: t(`tool.why.${decision.kind}`) };
+}
+/* A target is one line: its first line, and `…` when it had more (Q-R2-3). Shown as data (escaped controls). */
+function oneLineTarget(value) { const [first = '', ...more] = sanitizeDisplayText(String(value ?? '')).split('\n'); const shown = first.trim(); return more.some(line => line.trim()) ? `${shown} …`.trim() : shown; }
+function composeLine(label, target, facts) { return { title: label + (target ? ' ' + target : ''), statusLabel: facts.map(fact => fact.text).join(SEPARATOR) }; }
+function widthOf(label, target, facts) { const { title, statusLabel } = composeLine(label, target, facts); return displayWidth(title + SEPARATOR + statusLabel); }
+function fit(label, target, facts, width) {
+    if (!Number.isFinite(width) || widthOf(label, target, facts) <= width)
+        return { target, facts };
+    const cut = (current, minimum) => {
+        if (!target)
+            return '';
+        const budget = Math.max(Math.min(minimum, displayWidth(target)), width - widthOf(label, '', current) - 1);
+        return displayWidth(target) <= budget ? target : truncateMiddle(target, Math.max(1, budget));
+    };
+    const fits = (shown, current) => widthOf(label, shown, current) <= width;
+    let current = facts, shown = cut(current, TARGET_MIN);
+    if (fits(shown, current))
+        return { target: shown, facts: current };
+    current = current.filter(fact => fact.role !== 'duration');
+    shown = cut(current, TARGET_MIN);
+    if (fits(shown, current))
+        return { target: shown, facts: current };
+    current = current.map(fact => fact.role === 'isolation' && fact.short ? { ...fact, text: fact.short } : fact);
+    shown = cut(current, TARGET_MIN);
+    if (fits(shown, current))
+        return { target: shown, facts: current };
+    shown = cut(current, 1);
+    if (fits(shown, current))
+        return { target: shown, facts: current };
+    const why = current.find(fact => fact.role === 'why' && fact.rule !== undefined);
+    if (why) {
+        const others = current.filter(fact => fact !== why);
+        const room = width - widthOf(label, shown, others) - displayWidth(SEPARATOR) - displayWidth(t('tool.why.rule', { rule: '' }));
+        const rule = truncateMiddle(why.rule, Math.max(1, room));
+        current = current.map(fact => fact === why ? { ...fact, text: t('tool.why.rule', { rule }) } : fact);
+    }
+    return { target: shown, facts: current };
+}
+function evidenceLines(row, width) {
+    const outcome = row.outcome;
+    if (!outcome)
+        return [];
+    const rows = [];
+    if (outcome.receiptStatus)
+        rows.push(`receipt ${outcome.receiptStatus}`);
+    if (outcome.exitCode !== null)
+        rows.push(`exit ${outcome.exitCode}`);
+    if (outcome.enforcement !== null)
+        rows.push(`enforcement ${outcome.enforcement}`);
+    if (outcome.allowed !== null || outcome.permissionVia !== null) {
+        const decision = outcome.allowed === true ? 'allowed' : outcome.allowed === false ? 'denied' : 'not reported';
+        rows.push(`permission ${decision}${outcome.permissionVia ? ` via ${outcome.permissionVia}` : ''}`);
+    }
+    if (outcome.permissionReason)
+        rows.push(`permission reason ${outcome.permissionReason}`);
+    if (outcome.risk)
+        rows.push(`risk ${outcome.risk}`);
+    return rows.map(text => truncateDisplay(sanitizeDisplayText(text), detailWidth(width)));
+}
+function firstLine(text) { return String(text ?? '').split(/\r?\n/u).map(line => line.trim()).find(Boolean) ?? ''; }
+export function composeToolRow(row, view, context) {
+    const label = sanitizeDisplayText(view.label ?? labelFor(row));
+    const target = oneLineTarget(view.target);
+    const facts = [];
+    if (view.command && row.facts?.isolation) {
+        const kind = row.facts.isolation;
+        facts.push({ role: 'isolation', text: t(`tool.isolation.${kind}`), short: t(`tool.isolation.${kind}.glyph`) });
+    }
+    const why = whyFact(row);
+    if (why)
+        facts.push(why);
+    const exit = row.facts?.exitCode ?? row.outcome?.exitCode ?? null;
+    const duration = typeof row.facts?.durationMs === 'number' && Number.isFinite(row.facts.durationMs) ? row.facts.durationMs : null;
+    const state = (text) => facts.push({ role: 'state', text });
+    let tone;
+    switch (row.status) {
+        case 'approval':
+            tone = 'waiting';
+            state(t('tool.state.waiting'));
+            break;
+        case 'queued':
+        case 'running':
+        case 'streaming': {
+            tone = 'running';
+            const elapsed = row.startedAt === null ? 0 : Math.max(0, context.now - row.startedAt);
+            state(view.liveTail || elapsed < 1000 ? t('tool.state.running') : t('tool.state.runningFor', { duration: formatDuration(elapsed) }));
+            break;
+        }
+        case 'completed': {
+            if (view.command) {
+                tone = exit !== null && exit !== 0 ? 'failed' : 'done';
+                if (exit !== null)
+                    facts.push({ role: 'exit', text: t('tool.exit', { code: exit }) });
+                else
+                    state(t('tool.state.done'));
+                if (duration !== null)
+                    facts.push({ role: 'duration', text: formatDuration(duration) });
+            }
+            else {
+                tone = 'done';
+                if (view.result.length)
+                    for (const text of view.result)
+                        facts.push({ role: 'result', text });
+                else
+                    state(t('tool.state.done'));
+                if (duration !== null && duration >= 1000)
+                    facts.push({ role: 'duration', text: formatDuration(duration) });
+            }
+            break;
+        }
+        case 'failed':
+            tone = 'failed';
+            state(t('tool.state.failed'));
+            if (exit !== null)
+                facts.push({ role: 'exit', text: t('tool.exit', { code: exit }) });
+            if (view.command && duration !== null)
+                facts.push({ role: 'duration', text: formatDuration(duration) });
+            break;
+        case 'denied':
+            tone = 'denied';
+            state(t('tool.state.denied'));
+            break;
+        case 'cancelled':
+        case 'interrupted': {
+            tone = 'interrupted';
+            const ran = row.startedAt !== null && row.endedAt !== null ? row.endedAt - row.startedAt : 0;
+            state(ran >= 1000 ? t('tool.state.interruptedAfter', { duration: formatDuration(ran) }) : t('tool.state.interrupted'));
+            break;
+        }
+        default:
+            tone = 'unknown';
+            state(t('tool.state.unknown'));
+    }
+    const fitted = fit(label, target, facts, context.width);
+    const { title, statusLabel } = composeLine(label, fitted.target, fitted.facts);
+    const detail = [];
+    if (row.status === 'denied') {
+        /* E9: the refusal's English reason (transcript-model.ts puts describeRefusal's sentence in finalOutput). */
+        detail.push(truncateDisplay(sanitizeDisplayText(firstLine(row.finalOutput) || t('error.refused.generic')), detailWidth(context.width)));
+    }
+    else if (row.status === 'failed' && !view.showsOutput) {
+        detail.push(...boundedLines(withoutKernelExitLine(row.finalOutput).trim(), context.width, 2));
+    }
+    detail.push(...view.detail);
+    if (context.expanded) {
+        detail.push(...evidenceLines(row, context.width));
+        // Q-R2-3: the raw kernel name is shown only here, in the expanded detail, as the secondary identifier.
+        detail.push(truncateDisplay(sanitizeDisplayText(t('tool.detail.raw', { name: row.name })), detailWidth(context.width)));
+    }
+    return { title, statusLabel, line: title + SEPARATOR + statusLabel, detailLines: detail, tone, label, target: fitted.target, facts: fitted.facts.map(fact => fact.text) };
+}

package/dist/tui/tools/search-renderer.js

@@ -0,0 +1,38 @@
+import { argumentLine, boundedLines, outputText, parseArgs } from "./shared.js";
+import { tn } from "../../i18n/index.js";
+/* R2 lane T: the kernel's `cerca` sends `testo` (text inside files) and/or `nome` (a path fragment), talosHarness.mjs:1586-1599.
+   R3 (Q-R3-1): `N results` on the row, counted from the kernel's own result shape (cercaNelProgetto, talosHarness.mjs:3630):
+   one match per line, `no file matches. …` for none, `… and N[+] more matches not shown …` for the cut, `⚠` notices apart.
+   These exact templates are pinned by r3-rd-tool-rows.test.ts; an answer of another shape gets no count. */
+const NO_MATCH = /^no file matches\. Scanned /u;
+const MISSING_ARGUMENTS = /^give at least one of "/u;
+const MORE = /^… and (\d+)(\+?) more matches not shown — narrow the search\.$/u;
+function searchCount(text) {
+    const value = String(text).trim();
+    if (MISSING_ARGUMENTS.test(value))
+        return null;
+    if (value === '' || NO_MATCH.test(value))
+        return { count: 0, atLeast: false };
+    let count = 0, atLeast = false;
+    for (const line of value.split(/\r?\n/u)) {
+        if (!line.trim() || line.startsWith('⚠'))
+            continue;
+        const more = MORE.exec(line);
+        if (more) {
+            count += Number(more[1]);
+            atLeast ||= more[2] === '+';
+            continue;
+        }
+        count++;
+    }
+    return { count, atLeast };
+}
+export const renderSearch = (row, context) => {
+    const a = parseArgs(row);
+    const query = String(a.testo ?? a.nome ?? a.query ?? a.pattern ?? a.term ?? a.raw ?? '').trim();
+    const path = String(a.path ?? a.root ?? '').trim();
+    const found = searchCount(outputText(row));
+    const result = found ? [tn('tool.search.results', found.count, found.atLeast ? { count: `${found.count}+` } : {})] : [];
+    const detail = [...(path ? boundedLines(argumentLine('path', path), context.width, 1) : []), ...(row.status === 'denied' || found?.count === 0 ? [] : boundedLines(outputText(row), context.width, context.expanded ? 12 : 3))];
+    return { target: query, result, detail, showsOutput: true };
+};

package/dist/tui/tools/shared.js

@@ -0,0 +1,97 @@
+import { t, tn } from "../../i18n/index.js";
+import { truncateDisplay } from "../text-width.js";
+import { argumentLabel, toolDisplay } from "../tool-display.js";
+/*
+ * What reaches a terminal from a tool (its arguments, its output, a file's lines) is data: control characters, line and
+ * paragraph separators and bidi controls are shown escaped, never interpreted. The one implementation; transcript-model.ts
+ * re-exports it as `sanitizeTranscriptText` (kept here so the tool rows need no import of the transcript model).
+ */
+const UNSAFE_DISPLAY = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f\u2028\u2029\p{Bidi_Control}]/gu;
+export function visibleEscape(character) { const code = character.codePointAt(0); return code > 0xffff ? '\\u{' + code.toString(16) + '}' : '\\u' + code.toString(16).padStart(4, '0'); }
+export function sanitizeDisplayText(value) { return String(value).replace(/\r\n?/gu, '\n').replace(UNSAFE_DISPLAY, visibleEscape); }
+/*
+ * R2 lane T (review D-07): arguments arrive as JSON text, streamed. A JSON object that is still arriving is repaired for
+ * display by closing its open string and braces; if that fails nothing is shown — partial JSON never reaches the screen.
+ * Text that is not JSON at all is a value, and stays one (`raw`).
+ */
+const CLOSERS = ['', '"}', '}', '"]}', ']}', '"}]}', '}]}', '"}}', '}}'];
+export function parseArgs(row) {
+    const text = String(row.argsText || '').trim();
+    if (!text)
+        return {};
+    if (!text.startsWith('{'))
+        return { raw: row.argsText };
+    for (const closer of CLOSERS) {
+        try {
+            const value = JSON.parse(text + closer);
+            if (value && typeof value === 'object' && !Array.isArray(value))
+                return value;
+        }
+        catch { }
+    }
+    return {};
+}
+export function outputText(row) { return row.finalOutput || row.liveOutput || ''; }
+export function detailWidth(width) { return Math.max(16, Math.min(240, width - 4)); }
+export function boundedLines(text, width, maxLines = 8) { const cap = detailWidth(width); const rows = String(text).split(/\r?\n/u).slice(0, maxLines).map(line => truncateDisplay(sanitizeDisplayText(line), cap)); if (String(text).split(/\r?\n/u).length > maxLines)
+    rows.push('…'); return rows.filter(Boolean); }
+/** The English label of a row's tool (tool-display.ts), whatever renderer draws it. */
+export function labelFor(row) { return toolDisplay(row.name).label; }
+export function textSize(text) { return { bytes: Buffer.byteLength(text, 'utf8'), lines: text ? text.split(/\r?\n/u).length : 0 }; }
+/** Lines of a text as a person counts them: a final line break does not start a new line. */
+export function lineCount(text) { const value = String(text); if (value === '')
+    return 0; const n = value.split('\n').length; return value.endsWith('\n') ? n - 1 : n; }
+/*
+ * R3 gate E3: a command's result content starts with the kernel's own line `exit <n> [sandbox: <enforcement>]` (the model's
+ * shell, talosHarness.mjs:8662; a `!` command, agent-service.mjs:2166) or `exit <n>` (`prova`, talosHarness.mjs:8554/8564).
+ * The row states the exit code and the isolation from structured facts, so that exact first line is hidden on screen; the
+ * model's content is untouched (it stays in `outcome.content`). The templates are pinned by r3-rd-tool-rows.test.ts.
+ */
+const KERNEL_EXIT_LINE = /^exit (?:-?\d+|null|undefined)(?: \[sandbox: [^\n]*\])?$/u;
+export function withoutKernelExitLine(text) { const value = String(text); const cut = value.indexOf('\n'); const first = cut < 0 ? value : value.slice(0, cut); return KERNEL_EXIT_LINE.test(first) ? (cut < 0 ? '' : value.slice(cut + 1)) : value; }
+/* The transcript keeps the END of a long output behind this marker (transcript-model.ts `tail`). */
+export function truncatedMarker() { return t('tool.transcript.truncated'); }
+/** The last `max` lines of an output and how many lines stand above them (`atLeast` when the model kept only the end). */
+export function outputTail(text, max) {
+    let value = String(text).replace(/\n+$/u, '');
+    const marker = truncatedMarker() + '\n', atLeast = value.startsWith(marker);
+    if (atLeast)
+        value = value.slice(marker.length);
+    if (value === '')
+        return { lines: [], hidden: 0, atLeast: false };
+    const all = value.split('\n');
+    const lines = all.slice(-max);
+    return { lines, hidden: all.length - lines.length, atLeast: atLeast && all.length > lines.length };
+}
+/** `+N lines` (or `+N+ lines` when the start of the output was dropped). */
+export function moreLines(hidden, atLeast) { return tn('tool.output.more', hidden, atLeast ? { count: `${hidden}+` } : {}); }
+/** Q-R3-2 words: `0.1 s`, `4.2 s` under ten seconds, `12 s`, then `1 min 15 s`. */
+export function formatDuration(ms) {
+    const value = Math.max(0, Number(ms) || 0);
+    if (value < 10_000)
+        return t('tool.duration.seconds', { seconds: (value / 1000).toFixed(1) });
+    const seconds = Math.round(value / 1000);
+    if (seconds < 60)
+        return t('tool.duration.seconds', { seconds });
+    return t('tool.duration.minutes', { minutes: Math.floor(seconds / 60), seconds: seconds % 60 });
+}
+/*
+ * One argument as one line, `label: value`. A value is data and is shown as it is (strings, numbers, booleans); a text
+ * of several lines is counted (`content: 7 bytes · 2 lines`); an array or object is counted, never printed as JSON
+ * (review D-07: `args {"percorso":…}`).
+ */
+export function argumentLine(key, value) {
+    const label = argumentLabel(key);
+    if (typeof value === 'string') {
+        if (value === '')
+            return `${label}: ${t('tool.value.empty')}`;
+        return /\r|\n/u.test(value) ? `${label}: ${t('tool.value.bytes', textSize(value))}` : `${label}: ${value}`;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return `${label}: ${String(value)}`;
+    if (value === null || value === undefined)
+        return `${label}: ${t('tool.value.empty')}`;
+    if (Array.isArray(value))
+        return `${label}: ${tn('common.item', value.length)}`;
+    return `${label}: ${tn('tool.value.fields', Object.keys(value).length)}`;
+}

package/dist/tui/tools/write-renderer.js

@@ -0,0 +1,15 @@
+import { argumentLine, lineCount, parseArgs } from "./shared.js";
+import { changeDiff, changeSummaryOf, diffDetail, resultOfChange } from "./change.js";
+import { t, tn } from "../../i18n/index.js";
+/* R2 lane T: the kernel's `scrivi` sends `percorso`, `contenuto` and an optional `mode:"append"` (talosHarness.mjs:1653-1668).
+   R3 (Q-R3-4, gate E10): the row states the change the kernel reported (`file.changed`: `new file · N lines`, or `+a −r`
+   when it replaced a file); before that is known, the size of what was sent. The full diff is the expanded view (Ctrl+O). */
+export const renderWrite = (row, context) => {
+    const a = parseArgs(row);
+    const path = String(a.percorso ?? a.path ?? a.file ?? a.filename ?? '').trim();
+    const content = String(a.contenuto ?? a.content ?? a.text ?? '');
+    const summary = changeSummaryOf(row);
+    const result = summary ? resultOfChange(summary) : [tn('tool.result.lines', lineCount(content)), ...(a.mode === 'append' ? [t('tool.result.appended')] : [])];
+    const detail = !context.expanded ? [] : row.change ? diffDetail(changeDiff(row.change), context.width) : [argumentLine('contenuto', content)];
+    return { target: path, result, detail };
+};