@cspeach/cli 0.6.0

package/dist/renderer/pipeline.js

@@ -0,0 +1,201 @@
+// ────────────────────────────────────────────────────────────────────
+// IMPORTS — all at top of file (ESM)
+// ────────────────────────────────────────────────────────────────────
+import { isTTY, shouldUseInk } from './tty.js'; // UNCHANGED FROM v0.1.1 (shouldUseInk is NEW IN v0.3 use-site)
+import { renderMarkdown } from './markdown.js'; // UNCHANGED FROM v0.1.1
+import { applySeverity } from './severity.js'; // UNCHANGED FROM v0.1.1
+import { applyAbapHighlight } from './abap-inline.js'; // UNCHANGED FROM v0.1.1
+import { renderTables } from './tables.js'; // UNCHANGED FROM v0.1.1
+import { extractWidgets } from './widget-extractor.js'; // NEW IN v0.3
+import { WIDGET_SCHEMAS } from './widget-schemas.js'; // NEW IN v0.3
+import { WIDGET_CONTROL } from '../ui/widget-control.js'; // NEW IN v0.3
+// Question-widget normalizer retired in v0.3.1 hotfix — skills now call the
+// `ask_question` tool for interactive questions (src/tools/ask-question.ts).
+// The normalizer's regex + streaming buffering proved too fragile. Import
+// kept commented-out as a breadcrumb; the file itself is retained in case
+// any other skill still emits a widget-real block we want to catch.
+import { renderQuestionCard } from './widget-fallback.js'; // NEW IN v0.3.1
+export function initialBufferState() {
+    return { pending: '', fenceCount: 0, widgetBuffer: '', insideWidget: false, orderedListCounter: 0 };
+}
+// ────────────────────────────────────────────────────────────────────
+// FULL-TEXT RENDER — UNCHANGED FROM v0.1.1
+// Pipeline order: markdown → severity → abap-inline → tables.
+// Non-TTY: strip ANSI so piped output is clean.
+// ────────────────────────────────────────────────────────────────────
+export function render(text) {
+    let out = renderMarkdown(text);
+    out = applySeverity(out);
+    out = applyAbapHighlight(out);
+    out = renderTables(out);
+    if (!isTTY())
+        out = stripAnsi(out);
+    return out;
+}
+// ────────────────────────────────────────────────────────────────────
+// STREAMING CHUNK RENDER — NEW OUTER SHAPE IN v0.3 (widget pre-stage),
+// inner passthrough path UNCHANGED FROM v0.1.1 (see renderPassthrough).
+//
+// Order of operations per chunk:
+//   1. If mid-widget (state.insideWidget), prepend state.widgetBuffer.
+//   2. Extract widget segments via extractWidgets(). Buffered-tail returns
+//      keep the unterminated fence in state.widgetBuffer and re-enter next chunk.
+//   3. Each passthrough segment goes through renderPassthrough (v0.1.1 logic).
+//   4. Each widget segment goes through renderWidget (validate + emit control
+//      string for Ink, or ```json``` fallback for non-TTY).
+//
+// INVARIANT: when no widget fence has ever been seen in this stream,
+// state.insideWidget stays false and the whole chunk is a single
+// passthrough segment — behavior is byte-identical to v0.1.1.
+// ────────────────────────────────────────────────────────────────────
+const WIDGET_OPEN_RE = /^```cspeach-widget:[a-z-]+\s*$/m;
+export function renderChunk(chunk, state) {
+    // 1. Prepend any mid-widget buffer from a prior chunk.
+    const input = state.insideWidget ? state.widgetBuffer + chunk : chunk;
+    // 2. Extract widget segments.
+    const segments = extractWidgets(input);
+    // 3. If extractor returned `buffered`, tail contains unterminated widget fence.
+    const bufferedIdx = segments.findIndex((s) => s.type === 'buffered');
+    if (bufferedIdx !== -1) {
+        // Render any complete segments before the unterminated fence.
+        const completedOutput = renderCompletedSegments(segments.slice(0, bufferedIdx), state);
+        // Buffer the unterminated open-fence region for next chunk.
+        const match = WIDGET_OPEN_RE.exec(input);
+        const nextWidgetBuffer = match ? input.slice(match.index) : input;
+        return {
+            output: completedOutput,
+            state: { ...state, widgetBuffer: nextWidgetBuffer, insideWidget: true },
+        };
+    }
+    // 4. No open widget fence: clear widget buffer and render all segments.
+    const nextState = { ...state, widgetBuffer: '', insideWidget: false };
+    const output = renderCompletedSegments(segments, nextState);
+    return { output, state: nextState };
+}
+function renderCompletedSegments(segments, state) {
+    let out = '';
+    let widgetIdx = 0;
+    for (const seg of segments) {
+        if (seg.type === 'passthrough') {
+            out += renderPassthrough(seg.rawText, state);
+        }
+        else if (seg.type === 'widget') {
+            out += renderWidget(seg.widgetType, seg.rawJson, widgetIdx++);
+        }
+        // `buffered` never reaches here — filtered out by caller.
+    }
+    return out;
+}
+/**
+ * renderPassthrough — the v0.1.1 streaming chunk renderer, moved verbatim
+ * into a helper. Fence-aware, flushes at \n\n block boundaries, honours
+ * state.pending for partial markdown. Mutates `state.pending` and
+ * `state.fenceCount` exactly as v0.1.1 did.
+ *
+ * UNCHANGED FROM v0.1.1 (logic-identical — the body is the former
+ * renderChunk body from pipeline.ts lines 59-92 of the v0.1.1 file).
+ */
+function renderPassthrough(chunk, state) {
+    const combined = state.pending + chunk;
+    // Line-anchored ``` only — matches CommonMark and stays consistent with
+    // markdown.ts / abap-inline.ts (both /^```/m). UNCHANGED FROM v0.1.1.
+    const newFencesInChunk = (chunk.match(/^```/gm) || []).length;
+    const projectedFenceCount = state.fenceCount + newFencesInChunk;
+    if (projectedFenceCount % 2 !== 0) {
+        // Inside an open fence — hold everything until fence closes.
+        state.pending = combined;
+        state.fenceCount = projectedFenceCount;
+        return '';
+    }
+    // Outside a fence — flush up to last BLANK LINE (\n\n) boundary.
+    const lastBlankLine = combined.lastIndexOf('\n\n');
+    if (lastBlankLine >= 0) {
+        const flushable = combined.slice(0, lastBlankLine + 2);
+        const unflushed = combined.slice(lastBlankLine + 2);
+        state.pending = unflushed;
+        state.fenceCount = projectedFenceCount;
+        const rendered = render(flushable);
+        return renumberOrderedLists(rendered, state);
+    }
+    // No blank line yet — hold combined, emit nothing.
+    state.pending = combined;
+    state.fenceCount = projectedFenceCount;
+    return '';
+}
+// ────────────────────────────────────────────────────────────────────
+// ORDERED-LIST RENUMBER — NEW
+// Walks rendered output line-by-line and renumbers consecutive ordered
+// list items across paragraph flushes. See BufferState.orderedListCounter.
+//
+// marked-terminal emits ordered list items as `    1. <text>` (4-space
+// indent + N + dot + space, then optional ANSI styling on the content).
+// We detect these lines BEFORE any ANSI escapes and rewrite the visible
+// number when we're continuing a list.
+// ────────────────────────────────────────────────────────────────────
+const ANSI_PREFIX_RE = /^(\x1B\[[0-9;]*[mGKHFABCDsuJSTfrl])+/;
+const LIST_ITEM_RE = /^(\s+)(\d+)\.\s/;
+function renumberOrderedLists(rendered, state) {
+    if (rendered === '')
+        return rendered;
+    const lines = rendered.split('\n');
+    const out = [];
+    for (const line of lines) {
+        // Strip leading ANSI escapes so we can match against the visible prefix.
+        const ansiMatch = ANSI_PREFIX_RE.exec(line);
+        const ansiPrefix = ansiMatch ? ansiMatch[0] : '';
+        const visiblePart = line.slice(ansiPrefix.length);
+        const m = LIST_ITEM_RE.exec(visiblePart);
+        if (m) {
+            // It's an ordered list item.
+            state.orderedListCounter += 1;
+            const replacedVisible = visiblePart.replace(LIST_ITEM_RE, `${m[1]}${state.orderedListCounter}. `);
+            out.push(ansiPrefix + replacedVisible);
+            continue;
+        }
+        // Not a list item. Blank lines preserve the counter (inter-item gaps);
+        // any other non-blank line resets it (the list ended).
+        const visibleStripped = visiblePart.replace(/\x1B\[[0-9;]*[mGKHFABCDsuJSTfrl]/g, '');
+        if (visibleStripped.trim() !== '') {
+            state.orderedListCounter = 0;
+        }
+        out.push(line);
+    }
+    return out.join('\n');
+}
+/**
+ * renderWidget — NEW IN v0.3. Validate JSON against the widget's zod
+ * schema. On success, emit the WIDGET_CONTROL-wrapped payload (Ink/TTY) or
+ * a prose ```json``` block (non-TTY). On validation failure, emit a
+ * fenced ```json``` block with a warning comment — never throw.
+ */
+function renderWidget(type, rawJson, idx) {
+    const schema = WIDGET_SCHEMAS[type];
+    let parsed;
+    try {
+        parsed = JSON.parse(rawJson);
+    }
+    catch {
+        return '```json\n// \u26A0 widget JSON parse failed\n' + rawJson + '\n```\n';
+    }
+    if (!schema || !schema.safeParse(parsed).success) {
+        return '```json\n// \u26A0 widget validation failed (unknown type or schema mismatch)\n' + rawJson + '\n```\n';
+    }
+    if (!shouldUseInk()) {
+        // Non-TTY / CI: question widgets get the heavy-border chalk card.
+        // Other widget types fall through to the ```json``` prose block.
+        if (type === 'question') {
+            return renderQuestionCard(parsed);
+        }
+        return '```json\n' + rawJson + '\n```\n';
+    }
+    // REPL+TTY: emit a control string the <Body> component splits on.
+    const b64 = Buffer.from(rawJson).toString('base64');
+    return `${WIDGET_CONTROL}${idx}:${type}:${b64}${WIDGET_CONTROL}`;
+}
+// ────────────────────────────────────────────────────────────────────
+// ANSI stripper — UNCHANGED FROM v0.1.1
+// ────────────────────────────────────────────────────────────────────
+const ANSI_RE = /\x1B\[[0-9;]*[mGKHFABCDsuJSTfrl]|\x1B\][^\x07]*\x07/g;
+function stripAnsi(s) {
+    return s.replace(ANSI_RE, '');
+}

package/dist/renderer/progress-chatter.js

@@ -0,0 +1,237 @@
+import chalk from 'chalk';
+/**
+ * Progress chatter — keeps the tool-widget box alive while a tool runs.
+ *
+ * Rendered as a single animated line inside the widget frame, between the
+ * arg rows (painted by renderToolCallTop) and the bottom border (painted
+ * by renderToolCallBottom). Uses ANSI cursor-up + erase-line to redraw
+ * in place, so the line leaves no trace once the tool returns.
+ *
+ * Disabled in non-TTY mode (piped output, CI) and in Ink mode (chunkEmitter
+ * present) — the animation would fight the surrounding render cycle.
+ * In those modes `startProgress()` returns a no-op stop() handle.
+ */
+// 8-frame braille spinner — tick every 80ms.
+const SPINNER_CHARS = ['⣾', '⣽', '⣻', '⢿', '⡿', '⣟', '⣯', '⣷'];
+const SPINNER_TICK_MS = 80;
+const MESSAGE_ROTATE_MS = 3_000;
+// BOX_WIDTH must match tool-widget.ts — we could import it, but duplicating
+// the const here keeps progress-chatter.ts decoupled from that module's
+// internals and the value is set once across v0.2.
+const BOX_WIDTH = 64;
+/**
+ * Per-tool message pools. Messages may include `{name}` / `{type}` placeholders
+ * — substituted from the tool's args at render time. If the arg is absent,
+ * the placeholder is dropped together with any surrounding whitespace.
+ *
+ * Keep messages short (≤ ~50 chars) so they fit inside the widget's
+ * BOX_WIDTH content area without truncation.
+ */
+const MESSAGES = {
+    sap_search_object: [
+        'Hunting for {name} in the repository…',
+        'Asking SAP ADT for matches…',
+        'Scanning the object catalog…',
+    ],
+    sap_get_source: [
+        'Fetching source for {name}…',
+        'Bytes in transit…',
+        'Reading from SAP…',
+    ],
+    sap_set_source: [
+        'Writing {name} with safety gates…',
+        'Snapshot captured, applying change…',
+        'Waiting on SAP to ACK the write…',
+    ],
+    sap_activate: [
+        'Activating {name}…',
+        'Asking the ABAP compiler politely…',
+        'Checking for activation errors…',
+    ],
+    sap_object_structure: [
+        'Mapping {name}\'s structure…',
+        'Inspecting includes and references…',
+        'Tracing the object shape…',
+    ],
+    sap_atc_run: [
+        'Running ATC checks on {name}…',
+        'Counting findings — this can take a minute…',
+        'ATC is thorough. Patiently waiting…',
+    ],
+    sap_syntax_check: [
+        'Checking syntax for {name}…',
+        'Validating ABAP compile…',
+    ],
+    sap_run_unit_test: [
+        'Running ABAP Unit for {name}…',
+        'Waiting on assertions…',
+    ],
+    sap_usage_references: [
+        'Tracing callers of {name}…',
+        'Running where-used scan…',
+        'Mapping dependencies…',
+    ],
+    sap_sql_query: [
+        'Running SQL query…',
+        'Fetching rows…',
+    ],
+    sap_short_dump: [
+        'Reading short dump…',
+        'Parsing stack trace…',
+        'Looking for root cause…',
+    ],
+    sap_lock: [
+        'Acquiring lock on {name}…',
+        'Checking for contention…',
+        'Staking claim in SAP…',
+    ],
+    sap_unlock: [
+        'Releasing lock on {name}…',
+    ],
+    sap_transport_create: [
+        'Reserving a transport request…',
+        'Asking SAP for a fresh TR…',
+    ],
+    sap_transport_list: [
+        'Listing open transports…',
+        'Finding modifiable TRs…',
+    ],
+    sap_transport_release: [
+        'Releasing transport for QA queue…',
+        'This is irreversible — sending now…',
+    ],
+    sap_create_object: [
+        'Creating {name}…',
+        'Shell object in flight…',
+    ],
+    sap_delete_object: [
+        'Deleting {name}…',
+        'Marking for removal…',
+    ],
+    sap_snapshot_take: [
+        'Capturing snapshot of {name}…',
+        'Saving before-state to disk…',
+    ],
+    sap_snapshot_list: [
+        'Listing snapshots for {name}…',
+        'Walking the snapshot directory…',
+    ],
+    sap_snapshot_read: [
+        'Reading snapshot file…',
+    ],
+    sap_snapshot_cleanup: [
+        'Sweeping old snapshots…',
+    ],
+    sap_diff: [
+        'Computing diff for {name}…',
+    ],
+    sap_preview_change: [
+        'Previewing change for {name}…',
+    ],
+    sap_update_method: [
+        'Updating method body in {name}…',
+    ],
+    sap_class_includes: [
+        'Listing includes of {name}…',
+    ],
+    sap_inactive_objects: [
+        'Counting inactive objects…',
+        'Asking SAP what\'s still pending…',
+    ],
+    sap_odata_test: [
+        'Probing OData service…',
+        'Calling $metadata…',
+    ],
+    sap_badi_list: [
+        'Searching BAdI definitions…',
+        'Walking enhancement spots…',
+    ],
+    sap_message_maintain: [
+        '(stub — short-circuit)',
+    ],
+    sap_number_range_intervals: [
+        '(stub — short-circuit)',
+    ],
+    sap_service_binding_publish: [
+        'Publishing service binding…',
+        'Asking SAP to expose the OData endpoint…',
+    ],
+};
+const FALLBACK_MESSAGES = [
+    'Working on it…',
+    'Processing…',
+    'Patiently waiting for SAP…',
+    'Thinking hard about this…',
+];
+/**
+ * Start animated chatter inside the tool-widget frame. Call immediately after
+ * `renderToolCallTop()` and call `.stop()` immediately before
+ * `renderToolCallBottom()`.
+ */
+export function startProgress(params) {
+    const { name, args, chunkEmitter } = params;
+    // Skip when we can't redraw in place: piped output (no TTY), Ink mode
+    // (emitter owns the render cycle), or dumb terminals.
+    const disabled = chunkEmitter !== undefined ||
+        !process.stdout.isTTY ||
+        process.env['CI'] === '1' ||
+        process.env['TERM'] === 'dumb';
+    if (disabled) {
+        return { stop: () => undefined };
+    }
+    const pool = MESSAGES[name] ?? FALLBACK_MESSAGES;
+    const substituted = pool.map((msg) => substitute(msg, args));
+    let spinnerIdx = 0;
+    let messageIdx = 0;
+    let lastMessageRotate = Date.now();
+    let stopped = false;
+    const render = () => {
+        if (stopped)
+            return;
+        const now = Date.now();
+        if (now - lastMessageRotate >= MESSAGE_ROTATE_MS) {
+            messageIdx = (messageIdx + 1) % substituted.length;
+            lastMessageRotate = now;
+        }
+        const spinner = SPINNER_CHARS[spinnerIdx];
+        spinnerIdx = (spinnerIdx + 1) % SPINNER_CHARS.length;
+        const raw = `${spinner} ${substituted[messageIdx]}`;
+        const truncated = raw.length > BOX_WIDTH ? raw.slice(0, BOX_WIDTH - 1) + '…' : raw;
+        const padded = truncated.padEnd(BOX_WIDTH);
+        const line = chalk.dim('│ ') + chalk.cyan(padded) + chalk.dim(' │');
+        // Cursor-up 1, erase current line, rewrite. Trailing \n puts us back below.
+        process.stdout.write(`\x1B[1A\x1B[2K${line}\n`);
+    };
+    // Paint the initial chatter line (no cursor-up — it occupies a fresh line).
+    const initialSpinner = SPINNER_CHARS[0];
+    const initialRaw = `${initialSpinner} ${substituted[0]}`;
+    const initialTruncated = initialRaw.length > BOX_WIDTH ? initialRaw.slice(0, BOX_WIDTH - 1) + '…' : initialRaw;
+    const initialPadded = initialTruncated.padEnd(BOX_WIDTH);
+    const initialLine = chalk.dim('│ ') + chalk.cyan(initialPadded) + chalk.dim(' │');
+    process.stdout.write(initialLine + '\n');
+    const interval = setInterval(render, SPINNER_TICK_MS);
+    // Don't keep the event loop alive waiting for this timer.
+    interval.unref?.();
+    return {
+        stop: () => {
+            if (stopped)
+                return;
+            stopped = true;
+            clearInterval(interval);
+            // Erase the chatter line and back up so the bottom border writes
+            // adjacent to the args (as if no chatter ever existed).
+            process.stdout.write('\x1B[1A\x1B[2K');
+        },
+    };
+}
+function substitute(template, args) {
+    return template.replace(/\{(\w+)\}/g, (_match, key) => {
+        const v = args[key];
+        if (typeof v === 'string' && v.length > 0)
+            return v;
+        return '';
+    })
+        // Collapse any double spaces left by missing substitutions.
+        .replace(/\s+/g, ' ')
+        .trim();
+}