@cspeach/cli 1.1.45 → 1.1.47

package/dist/repl/chat-lane.js

@@ -0,0 +1,135 @@
+/**
+ * Chat lane (spec 2026-10-17 D1/D6/D8) — the lane decision both REPL paths
+ * make BEFORE today's routing block, as a pure function:
+ *   explicit  — the person typed (or CSPeach queued) a /skill
+ *   route     — today's block, verbatim (skills lane, or a piped/non-TTY surface)
+ *   continue  — chat lane, but the previous workflow keeps the turn (D6)
+ *   chat      — everything else in the chat lane
+ * ACK_PHRASES / isAckContinuation / CONVERSATIONAL_ACKS / isConversationalAck
+ * moved here from repl.tsx unchanged so the decision and the routing block
+ * share one predicate.
+ */
+import { isShortFollowUp } from '../router/resume-routing.js';
+import { isChatSkill } from '../agent/chat-prompt.js';
+import { enableToolFlags } from '../tools/_flag.js';
+/** Short user inputs that almost always mean "continue what we were doing"
+ *  rather than "start a new task." When the previous turn left a skill
+ *  in session.skill, an ack-only follow-up should route there instead of
+ *  re-classifying as a fresh prompt (which produces nonsense like "yes"
+ *  → /abap-explain at 35% confidence). */
+export const ACK_PHRASES = new Set([
+    'yes', 'y', 'yeah', 'yep', 'yup', 'sure',
+    'ok', 'okay', 'k', 'kk',
+    'proceed', 'continue', 'go', 'go ahead', 'do it', 'do that', 'go on',
+    'no', 'n', 'nope', 'nah',
+    'stop', 'cancel', 'abort', 'never mind', 'nm',
+    'approve', 'approved', 'accept', 'accepted',
+    'decline', 'denied', 'reject', 'rejected',
+    'skip', 'next',
+]);
+/**
+ * Returns true when `trimmed` is a short acknowledgement-style follow-up
+ * AND there is a previous skill to continue. Treats both bare acks and
+ * short ack-prefixed phrases ("yes please", "no thanks") the same way.
+ * Strips trailing punctuation so "yes." and "yes!" still register.
+ */
+export function isAckContinuation(trimmed, sessionSkill) {
+    if (!sessionSkill)
+        return false;
+    const normalized = trimmed.toLowerCase().trim().replace(/[.!?,]+$/, '');
+    if (ACK_PHRASES.has(normalized))
+        return true;
+    // "yes please", "go ahead and do it", "no thanks" — first word is an ack
+    // and the whole phrase is short enough to be a follow-up not a new task.
+    if (normalized.length <= 30) {
+        const firstWord = normalized.split(/\s+/)[0] ?? '';
+        if (ACK_PHRASES.has(firstWord))
+            return true;
+    }
+    return false;
+}
+/** Conversational acks — "user closes the previous thread, no further work"
+ *  (moved from repl.tsx unchanged). Distinct from ACK_PHRASES (which
+ *  largely mean "yes/no to a question"). In the skills lane the routing
+ *  block prints a friendly ack for these and returns without classifying.
+ *
+ *  2026-05-17 — Laeeq hit "thank you" being classified and run through
+ *  /abap-explain, producing another huge code explanation. THIS is the
+ *  fix for that. */
+export const CONVERSATIONAL_ACKS = new Set([
+    'thanks', 'thank you', 'thank u', 'thx', 'tx', 'ty', 'ta',
+    'cool', 'nice', 'great', 'awesome', 'perfect',
+    'got it', 'gotit', 'understood',
+    'cheers',
+    // Common ackowledgements that follow a long answer.
+    'makes sense',
+]);
+/** True when `trimmed` is one of CONVERSATIONAL_ACKS (today's skills-lane predicate, unchanged). */
+export function isConversationalAck(trimmed) {
+    const normalized = trimmed.toLowerCase().trim().replace(/[.!?,]+$/, '');
+    return CONVERSATIONAL_ACKS.has(normalized);
+}
+/** Chat lane only: a conversational ack, also behind a leading "ok"/"okay"
+ *  ("ok thanks", "okay, got it") — those start with an ACK_PHRASES word and
+ *  would otherwise read as a "yes" to the workflow. */
+function isChatClosingAck(trimmed) {
+    return isConversationalAck(stripOkPrefix(trimmed));
+}
+function stripOkPrefix(trimmed) {
+    return trimmed.trim().replace(/^(ok|okay)[\s,]+/i, '');
+}
+/** Pure thanks — the only closing acks that win over a workflow's open question (D6). */
+const THANKS_PHRASES = new Set(['thanks', 'thank you', 'thank u', 'thx', 'tx', 'ty', 'ta', 'cheers']);
+/** "thanks" / "ok, thanks!" — while a workflow is asking, "perfect" / "ok great"
+ *  is an answer to it ("Shall I create these 5 objects?"), but thanks is not. */
+function isThanksOnly(trimmed) {
+    return THANKS_PHRASES.has(stripOkPrefix(trimmed).toLowerCase().replace(/[.!?,]+$/, ''));
+}
+/** Today's continuation predicate (repl.tsx Ink + classic paths), as one
+ *  function: the skill that keeps the turn, or null. */
+export function wantsContinuation(i) {
+    if (!i.sessionSkill)
+        return null;
+    return (i.awaitingSkillAnswer || (i.resumedSkill !== null && isShortFollowUp(i.trimmed)) || isAckContinuation(i.trimmed, i.sessionSkill)) ? i.sessionSkill : null;
+}
+export function decideLane(i) {
+    if (i.explicitSkill)
+        return { kind: 'explicit', skill: i.explicitSkill };
+    if (i.laneSetting === 'skills' || !i.interactive)
+        return { kind: 'route' };
+    // "thanks" / "ok thanks" closes the thread — chat answers it; it is never
+    // a workflow turn or a "yes" to the workflow's question. While a workflow
+    // just asked, only pure thanks closes it: "perfect" / "ok great" answer it.
+    if (i.awaitingSkillAnswer ? isThanksOnly(i.trimmed) : isChatClosingAck(i.trimmed))
+        return { kind: 'chat' };
+    const continued = wantsContinuation(i);
+    if (continued)
+        return { kind: 'continue', skill: continued };
+    return { kind: 'chat' };
+}
+/** The status row label (D7): "chat", never "/_chat". */
+export function turnStatusLabel(skill) {
+    return isChatSkill(skill) ? 'chat' : `/${skill}`;
+}
+/** D11 — the one dim line shown in place of the echo when the message re-runs through today's router. */
+export const CHAT_UNAVAILABLE_LINE = "Chat isn't available on this server yet — using skill routing.";
+export function chatFallbackOrigin() {
+    return { by: 'chat_fallback', line: CHAT_UNAVAILABLE_LINE };
+}
+/**
+ * The one place a process lane's tool side effect is applied (D5, §6.1).
+ * Only an interactive chat-lane process enables the `hand_off` flag; a
+ * skills-lane process, piped stdin and one-shot keep today's tools array
+ * byte-identical (guarded by chat-lane-hand-off-guard.test.ts).
+ *
+ * Seam for Task 14 (`/chat on`): after setting the REPL's `laneSetting`, call
+ * this again with the new lane — the next turn's tools array then lists
+ * hand_off (in static mode the array grows once; the user chose the switch).
+ * It never disables: `/chat off` and the D11 fallback leave the flag on, so
+ * the array stays stable for the rest of the session; hand_off is inert there
+ * because its handler and dispatch refuse it outside the chat lane.
+ */
+export function applyLaneTools(lane, interactive) {
+    if (lane === 'chat' && interactive)
+        enableToolFlags(['hand_off']);
+}

package/dist/repl/level-command.js

@@ -0,0 +1,79 @@
+import { ASSISTANT_LEVELS, parseLevel } from '../agent/level.js';
+import { setAssistantLevel } from '../agent/level-state.js';
+import { formatFailure } from '../renderer/notice-shape.js';
+import { paint } from '../renderer/theme.js';
+import { getGlyphs } from '../renderer/glyphs.js';
+/** Spec §10 D13 — who CSPeach is talking to. One line per level, shown in the picker. Product copy; plain words. */
+export const LEVEL_DESCRIPTIONS = Object.freeze({
+    developer: "Talks to a developer — today's behaviour (default)",
+    learning: 'Explains the why and the terms — for a developer still building experience',
+    functional: 'Business first, code only when asked — hands code changes to a developer as a request file',
+});
+/** D15 — the recommended set-up for a non-developer, said once, never enforced.
+ *  /level is saved but /mode is session-only, so the tip leads with the saved
+ *  write_mode setting (the pairing would otherwise lapse next launch). */
+export const FUNCTIONAL_WRITE_MODE_TIP = 'For someone who should not change SAP, also run: cspeach config set write_mode advisory-only (or /mode advisory for this session)';
+/** D-L — one line: the confirmation, plus the D15 tip only when it applies. */
+export function levelConfirmation(level, writeMode) {
+    const base = `Level set to ${level}`;
+    return level === 'functional' && writeMode !== 'advisory-only' ? `${base} · ${FUNCTIONAL_WRITE_MODE_TIP}` : `${base}.`;
+}
+/**
+ * `writeMode` is the mode in force now (the REPL passes the effective mode, so
+ * a `/mode advisory` earlier in the session counts); it defaults to the config.
+ */
+export async function handleLevelCommand(arg, cfg, save, emit, pick, writeMode = cfg.write_mode) {
+    const raw = arg.trim();
+    let next;
+    if (raw === '') {
+        next = await pick(cfg.assistant.level);
+        if (next === null)
+            return; // cancelled: nothing changes, nothing printed
+    }
+    else {
+        next = parseLevel(raw);
+        if (!next) {
+            emit(formatFailure({ what: `Unknown level: ${raw}. Try ${ASSISTANT_LEVELS.join(', ')}.` }).trimEnd());
+            return;
+        }
+    }
+    cfg.assistant.level = next;
+    setAssistantLevel(next);
+    try {
+        await save(cfg);
+        emit(`${paint('ok', getGlyphs().done)} ${levelConfirmation(next, writeMode)}`);
+    }
+    catch (err) {
+        emit(formatFailure({ what: `Failed to save config: ${err.message} (applied for this session only)` }).trimEnd());
+    }
+}
+/** Ink: an AskCard choice under the card-slot focus claim; the cursor starts on
+ *  the current level, tagged "(current)" — "(default)" is only developer's description. */
+export async function pickLevelInk(current) {
+    const { askQuestionEmitter } = await import('../ui/ask-question-emitter.js');
+    const { withFocusClaim } = await import('../ui/card-slot.js');
+    const res = await withFocusClaim(() => askQuestionEmitter.request({
+        id: 'level',
+        question: "Who you're talking to",
+        kind: 'choice',
+        cursorValue: current,
+        choices: ASSISTANT_LEVELS.map((l) => ({ value: l, label: l === current ? `${l} (current)` : l, description: LEVEL_DESCRIPTIONS[l] })),
+    }));
+    return parseLevel(res.answer);
+}
+/** Classic: a themed inquirer select; Ctrl+C there resolves null. */
+export async function pickLevelClassic(current) {
+    const { withInquirer } = await import('./inquirer-guard.js');
+    const { select } = await import('./themed-prompts.js');
+    try {
+        const v = await withInquirer(() => select({
+            message: "Who you're talking to",
+            default: current,
+            choices: ASSISTANT_LEVELS.map((l) => ({ value: l, name: l, description: LEVEL_DESCRIPTIONS[l] })),
+        }));
+        return parseLevel(v);
+    }
+    catch {
+        return null; // Ctrl+C in inquirer
+    }
+}

package/dist/repl/style-command.js

@@ -0,0 +1,67 @@
+import { ASSISTANT_STYLES, parseStyle } from '../agent/style.js';
+import { setAssistantStyle } from '../agent/style-state.js';
+import { formatFailure } from '../renderer/notice-shape.js';
+import { paint } from '../renderer/theme.js';
+import { getGlyphs } from '../renderer/glyphs.js';
+/** One line per style, shown in the picker. Product copy; plain words. */
+export const STYLE_DESCRIPTIONS = Object.freeze({
+    professional: "Clear and neutral — today's voice (default)",
+    conversational: 'Like a teammate in a chat — relaxed, still brief',
+    humor: "A light, dry aside now and then — never at anyone's expense",
+    blunt: 'Direct, no padding — critiques the code, never the person',
+});
+export async function handleStyleCommand(arg, cfg, save, emit, pick) {
+    const raw = arg.trim();
+    let next;
+    if (raw === '') {
+        next = await pick(cfg.assistant.style);
+        if (next === null)
+            return; // cancelled: nothing changes, nothing printed
+    }
+    else {
+        next = parseStyle(raw);
+        if (!next) {
+            emit(formatFailure({ what: `Unknown style: ${raw}. Try ${ASSISTANT_STYLES.join(', ')}.` }).trimEnd());
+            return;
+        }
+    }
+    cfg.assistant.style = next;
+    setAssistantStyle(next);
+    try {
+        await save(cfg);
+        emit(`${paint('ok', getGlyphs().done)} Style set to ${next}.`);
+    }
+    catch (err) {
+        emit(formatFailure({ what: `Failed to save config: ${err.message} (applied for this session only)` }).trimEnd());
+    }
+}
+/** Ink: an AskCard choice under the card-slot focus claim; the cursor starts on
+ *  the current style, tagged "(current)" — "(default)" is only professional's description. */
+export async function pickStyleInk(current) {
+    const { askQuestionEmitter } = await import('../ui/ask-question-emitter.js');
+    const { withFocusClaim } = await import('../ui/card-slot.js');
+    const res = await withFocusClaim(() => askQuestionEmitter.request({
+        id: 'style',
+        question: 'Talking style',
+        kind: 'choice',
+        cursorValue: current,
+        choices: ASSISTANT_STYLES.map((s) => ({ value: s, label: s === current ? `${s} (current)` : s, description: STYLE_DESCRIPTIONS[s] })),
+    }));
+    return parseStyle(res.answer);
+}
+/** Classic: a themed inquirer select; Ctrl+C there resolves null. */
+export async function pickStyleClassic(current) {
+    const { withInquirer } = await import('./inquirer-guard.js');
+    const { select } = await import('./themed-prompts.js');
+    try {
+        const v = await withInquirer(() => select({
+            message: 'Talking style',
+            default: current,
+            choices: ASSISTANT_STYLES.map((s) => ({ value: s, name: s, description: STYLE_DESCRIPTIONS[s] })),
+        }));
+        return parseStyle(v);
+    }
+    catch {
+        return null; // Ctrl+C in inquirer
+    }
+}