@cspeach/cli 0.8.0 → 0.9.0

package/dist/ui/line-resolution.js

@@ -0,0 +1,81 @@
+// cspeach-cli/src/ui/line-resolution.ts
+//
+// Pure pre-dispatch resolution pipeline for the Ink input path
+// (2026-06-06 — Ink parity with the classic REPL's slash/at pickers,
+// repl.tsx ~1535-1640). Given a submitted line, decide ONE of:
+//
+//   submit      — line is fully resolved; hand it to the REPL handler
+//   open-slash  — line starts with a non-exact slash command; the App
+//                 mounts the CommandPalette seeded with the typed prefix
+//   open-at     — line ends with a partial/unresolved @-token; the App
+//                 mounts the FilePalette seeded with the typed prefix
+//   prefill     — skill command with no body; put `<cmd> ` back in the
+//                 input instead of dispatching an empty prompt the API
+//                 would reject (mirrors classic repl.tsx ~1626)
+//
+// Same auto-shortcuts as the classic pickers: a prefix that narrows to
+// exactly ONE command / file resolves silently — no palette, no extra
+// keystroke. The App calls nextResolutionStep again after every palette
+// pick, so a line flows slash → at → empty-body guard → submit no
+// matter where it entered the pipeline.
+import { isExactSlashMatch, filterSlashEntries } from '../repl/slash-picker.js';
+import { pendingAtTokenPrefix, filterFileChoices } from '../repl/at-picker.js';
+import { SKILL_CATALOG } from '../skill-catalog.js';
+export function nextResolutionStep(line, files) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('/') && !isExactSlashMatch(trimmed)) {
+        const headEnd = trimmed.search(/\s/);
+        const head = headEnd === -1 ? trimmed : trimmed.slice(0, headEnd);
+        const rest = headEnd === -1 ? '' : trimmed.slice(headEnd);
+        const prefix = head.slice(1);
+        const seeded = filterSlashEntries(prefix);
+        if (seeded.length === 1) {
+            // Unique match — resolve silently and continue down the pipeline.
+            return nextResolutionStep(`${seeded[0].name}${rest}`, files);
+        }
+        return { kind: 'open-slash', prefix, rest };
+    }
+    const filenames = files.map((f) => f.filename);
+    const atPrefix = pendingAtTokenPrefix(trimmed, filenames);
+    if (atPrefix !== null && files.length > 0) {
+        const seeded = filterFileChoices(atPrefix, files);
+        if (seeded.length === 1) {
+            return emptyBodyGuard(trimmed.replace(/@\S*$/, `@${seeded[0].filename}`));
+        }
+        return { kind: 'open-at', prefix: atPrefix, line: trimmed };
+    }
+    // Empty workspace: nothing to pick — let the downstream @-resolution
+    // produce its normal "no file matching" message.
+    return emptyBodyGuard(trimmed);
+}
+/** Substitute the picked command head into the pending line and continue. */
+export function applySlashPick(pickedName, rest, files) {
+    const name = pickedName.startsWith('/') ? pickedName : `/${pickedName}`;
+    return nextResolutionStep(`${name}${rest}`, files);
+}
+/** Substitute the picked filename into the rightmost @-token and continue. */
+export function applyAtPick(line, pickedFilename, files) {
+    return nextResolutionStep(line.replace(/@\S*$/, `@${pickedFilename}`), files);
+}
+/**
+ * A SKILL route with an empty body would dispatch an empty prompt the
+ * LLM API rejects — prefill `<cmd> ` instead (classic repl.tsx ~1626).
+ * Builtins (/help, /exit, /transport …) legitimately take no body and
+ * pass straight through.
+ */
+function emptyBodyGuard(line) {
+    if (line.startsWith('/')) {
+        const splitIdx = line.search(/\s/);
+        const head = splitIdx === -1 ? line : line.slice(0, splitIdx);
+        const body = splitIdx === -1 ? '' : line.slice(splitIdx).trim();
+        const isSkill = SKILL_CATALOG.some((s) => `/${s.name}` === head.toLowerCase());
+        if (isSkill && body.length === 0) {
+            return {
+                kind: 'prefill',
+                text: `${head} `,
+                hint: `↪ ${head} — type your prompt and press Enter`,
+            };
+        }
+    }
+    return { kind: 'submit', line };
+}

package/dist/ui/turn-status-emitter.js

@@ -0,0 +1,52 @@
+// cspeach-cli/src/ui/turn-status-emitter.ts
+//
+// Turn-lifecycle channel for the persistent status row (2026-06-07 —
+// the CC-style "always alive while working" indicator, B5 smoke
+// feedback round 3: fresh-line heartbeats were not enough).
+//
+// Same singleton-emitter pattern as error-emitter / approval-emitter:
+// the REPL marks turn start/stop around runTurn (try/finally so a
+// thrown turn can never leave the row stuck), loop.ts narrates the
+// current activity, and <TurnStatus /> renders it in the dynamic Ink
+// frame. In classic mode App is never mounted, the emitter has no
+// listeners, and every call is a no-op.
+import { EventEmitter } from 'node:events';
+class TurnStatusEmitter extends EventEmitter {
+    state = { active: false, paused: false, label: '', startedAt: 0 };
+    start(label = 'thinking') {
+        this.state = { active: true, paused: false, label, startedAt: Date.now() };
+        this.emit('change', this.state);
+    }
+    /** Update the activity label; ignored when no turn is active. Clears pause —
+     *  a real activity means the model is working again. */
+    activity(label) {
+        if (!this.state.active)
+            return;
+        this.state = { ...this.state, label, paused: false };
+        this.emit('change', this.state);
+    }
+    /** Blocked on user input — stop ticking and hide the row until resume(). */
+    pause() {
+        if (!this.state.active || this.state.paused)
+            return;
+        this.state = { ...this.state, paused: true };
+        this.emit('change', this.state);
+    }
+    /** User answered — the model is working again; bring the row back. */
+    resume() {
+        if (!this.state.active || !this.state.paused)
+            return;
+        this.state = { ...this.state, paused: false };
+        this.emit('change', this.state);
+    }
+    stop() {
+        if (!this.state.active)
+            return;
+        this.state = { active: false, paused: false, label: '', startedAt: 0 };
+        this.emit('change', this.state);
+    }
+    snapshot() {
+        return this.state;
+    }
+}
+export const turnStatusEmitter = new TurnStatusEmitter();

package/dist/ui/turn-status.js

@@ -0,0 +1,59 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Text } from 'ink';
+import { turnStatusEmitter } from './turn-status-emitter.js';
+const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const TICK_MS = 250;
+const PEACH = '#FFCBA4';
+function fmtElapsed(ms) {
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    return `${Math.floor(s / 60)}m ${s % 60}s`;
+}
+/**
+ * Persistent turn-status row (2026-06-07) — lives in the DYNAMIC Ink
+ * frame just above the Footer, so it repaints with the frame and
+ * vanishes the instant the turn ends. While a turn is in flight:
+ *
+ *   ⠹ sap_create_object · 34s · ctrl+c to interrupt
+ *
+ * The label follows the loop's narration (thinking / tool name /
+ * writing response / save check). Its presence answers "is it still
+ * working?"; its absence answers "is it done?" — the ambiguity that
+ * burned the B5 smoke three times.
+ *
+ * Pure Ink — no raw stdout writes, no cursor escape codes (the phantom
+ * cursor #25 class of bug came from a raw-stdout spinner; this
+ * component cannot reproduce it). Guard: ink-cursor-invariant test.
+ */
+export function TurnStatus() {
+    const [state, setState] = useState(turnStatusEmitter.snapshot());
+    const [frame, setFrame] = useState(0);
+    const [now, setNow] = useState(Date.now());
+    useEffect(() => {
+        const onChange = (s) => setState({ ...s });
+        turnStatusEmitter.on('change', onChange);
+        // Re-sync from the snapshot AFTER subscribing — an event fired between
+        // mount and this effect (e.g. a turn starting while App is still
+        // mounting) would otherwise be missed and the row stays blank.
+        setState({ ...turnStatusEmitter.snapshot() });
+        return () => { turnStatusEmitter.off('change', onChange); };
+    }, []);
+    useEffect(() => {
+        // Don't tick while paused (blocked on user input) — a live tick here
+        // repaints the dynamic frame every 250ms and overdraws an inquirer
+        // approval picker / churns the Ink ask_question modal (stacked borders,
+        // lost keypress). The row resumes the instant the user answers.
+        if (!state.active || state.paused)
+            return;
+        const interval = setInterval(() => {
+            setFrame((f) => (f + 1) % FRAMES.length);
+            setNow(Date.now());
+        }, TICK_MS);
+        return () => clearInterval(interval);
+    }, [state.active, state.paused]);
+    if (!state.active || state.paused)
+        return null;
+    return (_jsxs(Text, { children: [_jsxs(Text, { color: PEACH, children: [FRAMES[frame], " "] }), _jsx(Text, { children: state.label }), _jsxs(Text, { dimColor: true, children: [" \u00B7 ", fmtElapsed(now - state.startedAt), " \u00B7 ctrl+c to interrupt"] })] }));
+}

package/dist/ui/widgets/ask-question-modal.js

@@ -15,11 +15,36 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * learned the hard way that absolute overlays paint over Body and
  * can't be navigated cleanly).
  */
-import { useState } from 'react';
+import { useState, useEffect } from 'react';
 import { Box, Text, useInput } from 'ink';
 import TextInput from 'ink-text-input';
 const PEACH = '#FFCBA4';
+/**
+ * Reclaim raw-mode stdin when an Ink modal mounts (2026-06-08).
+ *
+ * The approval plan-gate uses `@inquirer/prompts`, which toggles the
+ * terminal's raw mode (and pauses stdin) out from under Ink while it runs.
+ * When it releases, Ink's INTERNAL bookkeeping still thinks raw mode is on,
+ * so it does not re-assert it — and a modal mounted afterwards (this one)
+ * receives no keypresses: arrow keys and Enter are dead, the user cannot
+ * answer the question. Re-syncing the OS state to what Ink expects on mount
+ * fixes it. Direct `process.stdin` calls (not Ink's ref-counted setRawMode)
+ * because the whole problem is that Ink's count is stale.
+ */
+function useReclaimRawStdin() {
+    useEffect(() => {
+        const stdin = process.stdin;
+        if (stdin.isTTY && typeof stdin.setRawMode === 'function') {
+            try {
+                stdin.setRawMode(true);
+            }
+            catch { /* not a TTY — ignore */ }
+            stdin.resume();
+        }
+    }, []);
+}
 export function AskQuestionModal({ params, onResolve }) {
+    useReclaimRawStdin();
     if (params.kind === 'text' || params.choices.length === 0) {
         return _jsx(TextInputForm, { params: params, onResolve: onResolve });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cspeach/cli",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "CSPeach — AI-assisted ABAP development CLI. Direct SAP access, 34 skills, safety gates.",
   "keywords": [
     "abap",
@@ -82,6 +82,9 @@
     "vitest": "^2.1.0"
   },
   "pnpm": {
-    "onlyBuiltDependencies": ["keytar", "esbuild"]
+    "onlyBuiltDependencies": [
+      "keytar",
+      "esbuild"
+    ]
   }
 }