@cspeach/cli 0.6.0

package/dist/projects/workspace.js

@@ -0,0 +1,478 @@
+/**
+ * CSPeach workspace folder — the user's "primary folder" for .cspeach.json
+ * artefacts.
+ *
+ * Why this exists: before v0.5.x, CLI saves landed in process.cwd() and
+ * @<file> tokens needed full absolute paths. Both pushed real friction onto
+ * the user — the path-copy circus. The workspace folder is one configurable
+ * directory that the CLI saves into and resolves bare @<name> tokens against.
+ *
+ * Default resolution (2026-05-08, "project-rooted workspace"):
+ *   1. `cfg.workspace_folder` in `~/.cspeach/config.toml` — explicit override,
+ *      highest priority.
+ *   2. `<git-root>/.cspeach/` — when the cwd is inside a git repository.
+ *      Each customer / project gets its own workspace; multi-project
+ *      consultants don't have artefacts piling up in one folder.
+ *   3. `<cwd>/.cspeach/` — fallback when cwd isn't inside a git repo.
+ *
+ * Earlier (pre-2026-05-08) default was `~/CSPeach/`. A first-run migration
+ * prompt (see src/projects/migration.ts) offers to move existing artefacts
+ * into the new project-rooted workspace, or pin workspace_folder back to
+ * `~/CSPeach/` for users who prefer the old behaviour.
+ *
+ * The folder is created on first use — no `cspeach init` ceremony.
+ */
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join, isAbsolute } from 'node:path';
+import os from 'node:os';
+import toml from '@iarna/toml';
+import { loadConfig } from '../config/loader.js';
+/**
+ * Walk up the directory tree from `startDir` looking for a `.git` entry
+ * (file or directory — submodules use a file). Returns the directory
+ * containing `.git`, or null when the search hits the filesystem root
+ * without finding one.
+ *
+ * Bounded by parent === dir, which terminates at "/" on POSIX and at
+ * each drive root on Windows.
+ */
+export function findProjectRoot(startDir) {
+    let dir = startDir;
+    for (let i = 0; i < 200; i++) {
+        if (existsSync(join(dir, '.git')))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+    return null;
+}
+/**
+ * Resolve the project-rooted default workspace path for a given cwd.
+ * Pure: does NOT touch the filesystem (other than the .git existence
+ * check via findProjectRoot). Caller decides whether to mkdir.
+ */
+export function defaultWorkspaceFor(cwd) {
+    const root = findProjectRoot(cwd);
+    return join(root ?? cwd, '.cspeach');
+}
+/**
+ * If the workspace lives directly under a project root that has a
+ * .gitignore, append a `.cspeach/` line so per-developer state doesn't
+ * get committed by accident. Idempotent — skips if .cspeach/ is already
+ * listed under any of the common patterns. No-op if .gitignore is
+ * missing (we don't create one — that's the user's call).
+ */
+function maybeAddToGitignore(workspaceDir) {
+    const projectRoot = dirname(workspaceDir);
+    const gitignorePath = join(projectRoot, '.gitignore');
+    if (!existsSync(gitignorePath))
+        return;
+    let content;
+    try {
+        content = readFileSync(gitignorePath, 'utf-8');
+    }
+    catch {
+        return;
+    }
+    const linesNorm = content.split('\n').map((l) => l.trim());
+    const already = linesNorm.some((l) => l === '.cspeach/' || l === '.cspeach' || l === '/.cspeach/' || l === '/.cspeach');
+    if (already)
+        return;
+    const sep = content.length === 0 || content.endsWith('\n') ? '' : '\n';
+    const block = `${sep}\n# CSPeach project workspace — per-developer state, not for commit.\n.cspeach/\n`;
+    try {
+        writeFileSync(gitignorePath, content + block, 'utf-8');
+    }
+    catch {
+        // Read-only filesystem / permission denied — silently skip; the workspace
+        // still works, the user just has to ignore it manually.
+    }
+}
+/**
+ * Resolve the workspace folder path, creating it if missing.
+ * Returns the absolute path. Idempotent.
+ */
+export async function ensureWorkspace() {
+    const cfg = await loadConfig();
+    const configured = cfg.workspace_folder?.trim();
+    const target = configured && configured.length > 0
+        ? expandHome(configured)
+        : defaultWorkspaceFor(process.cwd());
+    const justCreated = !existsSync(target);
+    if (justCreated) {
+        mkdirSync(target, { recursive: true });
+        // Only add to .gitignore for default project-rooted workspaces.
+        // Explicit overrides (e.g. ~/CSPeach/, /shared/team/cspeach/) are
+        // outside any project tree by design — adding to a parent .gitignore
+        // would be overreach.
+        if (!configured)
+            maybeAddToGitignore(target);
+    }
+    return target;
+}
+/**
+ * Synchronous variant for callers that cannot await — most importantly
+ * Node's readline `completer` interface, which is sync. Reads the TOML
+ * config directly via fs.readFileSync. Falls back to project-rooted
+ * default on any error (missing config, parse failure, etc.) — the
+ * completer should never throw.
+ *
+ * Earlier revision used `require('@iarna/toml')` here, which threw in
+ * ESM context (cspeach-cli has `"type": "module"`) and silently broke
+ * Tab completion. Top-level import is correct for ESM modules.
+ */
+export function ensureWorkspaceSync() {
+    let target = defaultWorkspaceFor(process.cwd());
+    try {
+        const cfgPath = join(os.homedir(), '.cspeach', 'config.toml');
+        if (existsSync(cfgPath)) {
+            const raw = readFileSync(cfgPath, 'utf-8');
+            const parsed = toml.parse(raw);
+            const configured = parsed.workspace_folder?.trim();
+            if (configured && configured.length > 0) {
+                target = expandHome(configured);
+            }
+        }
+    }
+    catch {
+        // Fall through to default — completer must never throw on a borked config.
+    }
+    if (!existsSync(target)) {
+        mkdirSync(target, { recursive: true });
+    }
+    return target;
+}
+/**
+ * Synchronous list of supported files in `workspace` — both
+ * `.cspeach.json` envelopes and `.txt` / `.md` text inputs. Mirrors
+ * listProjectFiles but skips the metadata parse (filename + kind +
+ * mtime only) since the readline completer only needs filenames.
+ * Lighter and faster for the per-keystroke hot path. Errors swallowed
+ * — see ensureWorkspaceSync.
+ */
+export function listProjectFilesSync(workspace) {
+    try {
+        const entries = readdirSync(workspace);
+        const out = [];
+        for (const name of entries) {
+            const isEnvelope = name.endsWith('.cspeach.json');
+            const isText = isTextFilename(name);
+            if (!isEnvelope && !isText)
+                continue;
+            const full = join(workspace, name);
+            const stat = statSync(full);
+            if (!stat.isFile())
+                continue;
+            out.push({
+                filename: name,
+                kind: isEnvelope ? 'envelope' : 'text',
+                mtimeMs: stat.mtimeMs,
+            });
+        }
+        out.sort((a, b) => b.mtimeMs - a.mtimeMs);
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Expand a leading `~/` to the user's home directory. Other paths are
+ * returned unchanged.
+ */
+function expandHome(p) {
+    if (p.startsWith('~/') || p === '~') {
+        return join(os.homedir(), p.slice(p === '~' ? 1 : 2));
+    }
+    return p;
+}
+/** File suffixes recognised as text-input candidates for skills. */
+const TEXT_SUFFIXES = ['.txt', '.md'];
+function isTextFilename(name) {
+    const lower = name.toLowerCase();
+    return TEXT_SUFFIXES.some((s) => lower.endsWith(s));
+}
+/**
+ * List supported workspace files (.cspeach.json envelopes AND .txt/.md
+ * text inputs), parsed for a tiny metadata summary. Sorted by mtime
+ * descending (most-recent first).
+ *
+ * Errors on individual envelope files (corrupt JSON, missing fields)
+ * yield an `unknown` summary rather than throwing — callers see the
+ * file name with no metadata so the user can investigate.
+ */
+export async function listProjectFiles() {
+    const ws = await ensureWorkspace();
+    const entries = readdirSync(ws);
+    const out = [];
+    for (const name of entries) {
+        const isEnvelope = name.endsWith('.cspeach.json');
+        const isText = isTextFilename(name);
+        if (!isEnvelope && !isText)
+            continue;
+        const path = join(ws, name);
+        const stat = statSync(path);
+        if (!stat.isFile())
+            continue;
+        if (isEnvelope) {
+            let artefactType = 'unknown';
+            let version = null;
+            let title = null;
+            try {
+                const env = JSON.parse(readFileSync(path, 'utf8'));
+                if (env.artefactType)
+                    artefactType = env.artefactType;
+                if (typeof env.version === 'number')
+                    version = env.version;
+                if (typeof env.title === 'string')
+                    title = env.title;
+            }
+            catch {
+                // leave defaults; the caller still sees the file
+            }
+            out.push({
+                path,
+                filename: name,
+                kind: 'envelope',
+                artefactType,
+                version,
+                title,
+                sizeBytes: stat.size,
+                mtimeMs: stat.mtimeMs,
+            });
+        }
+        else {
+            // text — no envelope metadata, just the file presence
+            out.push({
+                path,
+                filename: name,
+                kind: 'text',
+                artefactType: 'unknown',
+                version: null,
+                title: null,
+                sizeBytes: stat.size,
+                mtimeMs: stat.mtimeMs,
+            });
+        }
+    }
+    out.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    return out;
+}
+/**
+ * Inspect a `design` envelope and decide whether the design describes a
+ * RAP stack (Behavior Definition / Behavior Pool / Service Binding) or a
+ * classic build (report, class, function module). Used by the /files
+ * action menu and the /abap-design chain prompt to recommend the right
+ * BUILD skill — /abap-rap for RAP-shaped designs, /abap-generate for
+ * classic.
+ *
+ * Detection is conservative: a single RAP marker in any object's `type`
+ * field flags the whole design. The match is case-insensitive substring
+ * against the labels /abap-design produces (e.g. "BDEF", "Behavior
+ * Definition", "Service Binding"). Returns 'unknown' on any read/parse
+ * error so callers fall back to a neutral default ordering.
+ */
+export function detectDesignShape(envelopePath) {
+    let objects;
+    try {
+        const env = JSON.parse(readFileSync(envelopePath, 'utf8'));
+        objects = env.content?.objects;
+    }
+    catch {
+        return 'unknown';
+    }
+    if (!Array.isArray(objects) || objects.length === 0)
+        return 'unknown';
+    const RAP_MARKERS = [
+        'behavior definition', 'bdef',
+        'behavior implementation', 'behavior pool',
+        'service binding', 'srvb',
+        'service definition', 'srvd',
+    ];
+    const hasRap = objects.some((o) => {
+        const type = String(o?.type ?? '').toLowerCase();
+        return RAP_MARKERS.some((m) => type.includes(m));
+    });
+    return hasRap ? 'rap' : 'classic';
+}
+/**
+ * Resolve a CLI `@<token>` argument:
+ *   - absolute path  → returned verbatim (no workspace lookup)
+ *   - relative path  (starts with ./, ../, or contains a path separator)
+ *                    → resolved against `cwd`
+ *   - bare name      → searched in the workspace folder. Substring match
+ *                      on filename. Single match wins; multiple → ambiguous;
+ *                      none → notFound.
+ *
+ * Substring rather than prefix so the user can type any unique fragment of
+ * a long auto-generated filename (e.g. `@b9b0` finds
+ * `sales-order-status-dashboard-spec-gap-b9b0-v2.cspeach.json`).
+ *
+ * Pure function except for the workspace-listing read; all other I/O lives
+ * in the caller. Easy to unit-test by injecting a fake `files` list.
+ */
+export function resolveAtToken(args) {
+    const { token, cwd, workspace, files } = args;
+    if (isAbsolute(token)) {
+        return { kind: 'path', path: token };
+    }
+    if (token.startsWith('./') || token.startsWith('../') || token.startsWith('.\\') || token.startsWith('..\\')) {
+        return { kind: 'path', path: join(cwd, token) };
+    }
+    if (token.includes('/') || token.includes('\\')) {
+        // Other relative paths (no leading ./) — resolve against cwd, like a shell.
+        return { kind: 'path', path: join(cwd, token) };
+    }
+    // Bare name — workspace lookup.
+    const lower = token.toLowerCase();
+    const matches = files.filter((f) => f.filename.toLowerCase().includes(lower));
+    if (matches.length === 1) {
+        return { kind: 'path', path: matches[0].path };
+    }
+    if (matches.length === 0) {
+        return { kind: 'notFound', token, workspace };
+    }
+    return { kind: 'ambiguous', matches };
+}
+/**
+ * High-level resolver — combines listProjectFiles + resolveAtToken into a
+ * single async call. Callers in promote-command, status, etc. use this.
+ */
+export async function resolveAtTokenAsync(token, cwd) {
+    const workspace = await ensureWorkspace();
+    const files = await listProjectFiles();
+    return resolveAtToken({ token, cwd, workspace, files });
+}
+/**
+ * Format `listProjectFiles` output as a human-readable block for the
+ * `/files` REPL command and the ambiguous-match error path.
+ *
+ * Columns: filename, artefactType, version, last-modified relative time.
+ * No headers — keeps the output dense and copy-pasteable.
+ */
+export function formatProjectFileList(files, workspace) {
+    if (files.length === 0) {
+        return `Workspace: ${workspace}\n  (empty — drop .cspeach.json envelopes or .txt/.md spec docs here)`;
+    }
+    const now = Date.now();
+    const lines = [`Workspace: ${workspace}`, ''];
+    for (const f of files) {
+        const ageStr = relativeTime(now - f.mtimeMs);
+        const meta = f.kind === 'envelope'
+            ? `${f.artefactType.padEnd(9)} v${f.version ?? '?'}`
+            : `text       ${formatBytes(f.sizeBytes).padStart(7)}`;
+        lines.push(`  ${f.filename}  —  ${meta}  ${ageStr}`);
+    }
+    lines.push('');
+    lines.push(`${files.length} file(s). Use @<partial-name> to load — e.g. @${shortHint(files[0].filename)}`);
+    return lines.join('\n');
+}
+function formatBytes(n) {
+    if (n < 1024)
+        return `${n} B`;
+    if (n < 1024 * 1024)
+        return `${Math.round(n / 1024)} KB`;
+    return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+}
+function relativeTime(deltaMs) {
+    const m = Math.round(deltaMs / 60_000);
+    if (m < 1)
+        return 'just now';
+    if (m < 60)
+        return `${m} minute${m === 1 ? '' : 's'} ago`;
+    const h = Math.round(m / 60);
+    if (h < 24)
+        return `${h} hour${h === 1 ? '' : 's'} ago`;
+    const d = Math.round(h / 24);
+    return `${d} day${d === 1 ? '' : 's'} ago`;
+}
+function shortHint(filename) {
+    // First word of the filename (everything before the first hyphen) is
+    // usually a strong unique fragment.
+    const m = /^([^-]+)/.exec(filename);
+    return m ? m[1] : filename.slice(0, 8);
+}
+/**
+ * Cap on text-file content the model receives. Long text files would
+ * blow the model's context budget and bury the user's actual prompt.
+ * 64 KB is generous for typical requirement docs (a 20-page Word
+ * conversion clocks in around 30 KB), and chops cleanly on a UTF-8
+ * char boundary because we slice the decoded string, not the bytes.
+ */
+const MAX_TEXT_FILE_CHARS = 64 * 1024;
+/**
+ * Scan `userMessage` for `@<token>` references that resolve to .txt /
+ * .md files in the workspace, read their content, and substitute the
+ * token with an `<attached file="...">` block containing the file
+ * body. Returns the expanded message.
+ *
+ * Tokens that resolve to .cspeach.json envelopes are LEFT ALONE —
+ * those are handled by the --from / --status code paths and substitute
+ * here would double-handle them. Tokens that don't resolve to any
+ * file in the workspace are also left alone (treated as literal text)
+ * with a warning emitted via the optional `log` callback.
+ *
+ * Used by runTurn before the user message hits the LLM, so any text
+ * file the user references gets ingested as input context.
+ */
+export async function expandTextFileAttachments(userMessage, cwd, log) {
+    // Match @<word> tokens. Same regex as parseFromFlag's anchor but
+    // we keep it global to find every occurrence.
+    const tokenRe = /@(?:"([^"]+)"|(\S+))/g;
+    const matches = [];
+    let m;
+    while ((m = tokenRe.exec(userMessage)) !== null) {
+        const token = m[1] ?? m[2] ?? '';
+        if (token.length === 0)
+            continue;
+        matches.push({ match: m[0], token, index: m.index });
+    }
+    if (matches.length === 0)
+        return userMessage;
+    // Resolve each token; only act on those pointing to .txt / .md files
+    // that exist on disk. Build a list of substitutions to apply.
+    const substitutions = [];
+    for (const { match, token, index } of matches) {
+        const resolved = await resolveAtTokenAsync(token, cwd);
+        if (resolved.kind !== 'path')
+            continue;
+        const path = resolved.path;
+        if (!isTextFilename(path))
+            continue;
+        // Only ingest if the file exists. Missing files are just left as
+        // literal @<token> in the message (the LLM gets to see them too).
+        if (!existsSync(path)) {
+            if (log)
+                log(`(attached @${token} not found in workspace — left as literal)`);
+            continue;
+        }
+        let content;
+        try {
+            content = readFileSync(path, 'utf8');
+        }
+        catch (err) {
+            if (log)
+                log(`(could not read @${token}: ${err.message})`);
+            continue;
+        }
+        if (content.length > MAX_TEXT_FILE_CHARS) {
+            content = content.slice(0, MAX_TEXT_FILE_CHARS) + '\n... [truncated, file exceeds 64 KB]';
+        }
+        const filename = path.split(/[\\\/]/).pop() ?? token;
+        const replacement = `<attached file="${filename}">\n${content}\n</attached>`;
+        substitutions.push({ index, matchLen: match.length, replacement });
+        if (log)
+            log(`(attached ${filename} — ${formatBytes(Buffer.byteLength(content, 'utf8'))})`);
+    }
+    if (substitutions.length === 0)
+        return userMessage;
+    // Apply substitutions back-to-front so earlier indices stay valid.
+    substitutions.sort((a, b) => b.index - a.index);
+    let out = userMessage;
+    for (const s of substitutions) {
+        out = out.slice(0, s.index) + s.replacement + out.slice(s.index + s.matchLen);
+    }
+    return out;
+}

package/dist/renderer/abap-inline.js

@@ -0,0 +1,121 @@
+// C:\Users\Admin\ClaudeProjects\ABAPForge\cspeach-cli\src\renderer\abap-inline.ts
+/**
+ * Whole-text syntax-highlight pass for fenced code blocks.
+ *
+ * v0.1.1 shipped this file as a regex-based ABAP-only highlighter
+ * (function `applyAbapHighlight`). v0.2 extends it to dispatch by language:
+ *   ```abap  → existing ABAP regex logic (unchanged)
+ *   ```cds   → cli-highlight CDS grammar (via syntax.ts)
+ *   ```bdef  → cli-highlight BDEF grammar (via syntax.ts)
+ *   ```<any other or empty> → pass through (no highlight)
+ *
+ * The function is renamed `applyCodeHighlight`. A deprecation re-export
+ * `applyAbapHighlight` is kept because `pipeline.ts` currently imports that
+ * name; removing the re-export would require an edit to pipeline.ts, which
+ * is out of scope for this task.
+ */
+import chalk from 'chalk';
+import { highlightCodeBlock } from './syntax.js';
+const ABAP_KEYWORDS = new Set([
+    'DATA', 'TYPES', 'CONSTANTS', 'CLASS', 'INTERFACE', 'METHOD', 'ENDMETHOD',
+    'ENDCLASS', 'ENDINTERFACE', 'IF', 'ELSE', 'ELSEIF', 'ENDIF', 'LOOP',
+    'ENDLOOP', 'DO', 'ENDDO', 'WHILE', 'ENDWHILE', 'TRY', 'CATCH', 'CLEANUP',
+    'ENDTRY', 'RAISE', 'SELECT', 'FROM', 'WHERE', 'INTO', 'TABLE', 'FOR',
+    'ALL', 'ENTRIES', 'IN', 'CALL', 'FUNCTION', 'METHOD', 'PERFORMING',
+    'PERFORM', 'WRITE', 'MOVE', 'APPEND', 'READ', 'DELETE', 'INSERT',
+    'MODIFY', 'ASSIGN', 'UNASSIGN', 'CHECK', 'RETURN', 'EXIT', 'CONTINUE',
+    'CASE', 'WHEN', 'ENDCASE', 'NEW', 'CREATE', 'OBJECT', 'FIELD-SYMBOLS',
+    'TYPE', 'REF', 'TO', 'IMPORTING', 'EXPORTING', 'CHANGING', 'RETURNING',
+    'EXCEPTIONS', 'PUBLIC', 'PROTECTED', 'PRIVATE', 'SECTION', 'DEFINITION',
+    'IMPLEMENTATION', 'INHERITING', 'INTERFACES', 'ALIASES', 'ABSTRACT',
+    'FINAL', 'STATIC', 'REDEFINITION', 'AND', 'OR', 'NOT', 'IS', 'INITIAL',
+    'BOUND', 'INSTANCE', 'LOCAL', 'FRIENDS', 'DEFERRED',
+]);
+// Capture the language tag on the opening fence (was: /^```(abap)?(\s*)$/i).
+// Now accepts any alphanumeric/_/- lang slug and makes it available as m[1].
+const OPEN_FENCE_RE = /^```([a-z0-9_-]*)\s*$/i;
+const CLOSE_FENCE_RE = /^```\s*$/;
+/** Whole-text pass. Splits by fenced blocks; routes each block by lang. */
+export function applyCodeHighlight(text) {
+    const lines = text.split('\n');
+    const out = [];
+    let inFence = false;
+    let lang = '';
+    let blockLines = [];
+    for (const line of lines) {
+        if (!inFence) {
+            const m = OPEN_FENCE_RE.exec(line);
+            if (m) {
+                inFence = true;
+                lang = (m[1] ?? '').toLowerCase();
+                blockLines = [];
+                out.push(line);
+                continue;
+            }
+            out.push(line);
+            continue;
+        }
+        // inFence === true
+        if (CLOSE_FENCE_RE.test(line)) {
+            const body = blockLines.join('\n');
+            if (lang === 'abap') {
+                // Preserve v0.1.1 regex-based highlighter for ABAP — it is stable,
+                // has been tested in production, and avoids a second runtime
+                // dependency for the hottest fenced-block type.
+                out.push(highlightAbapBlock(body));
+            }
+            else if (lang === 'cds' || lang === 'bdef') {
+                // cli-highlight grammars via the Task 5 dispatcher.
+                out.push(highlightCodeBlock(body, lang));
+            }
+            else {
+                // Unknown / empty lang → pass through unchanged.
+                out.push(body);
+            }
+            out.push(line);
+            inFence = false;
+            lang = '';
+            blockLines = [];
+            continue;
+        }
+        blockLines.push(line);
+    }
+    // Unterminated fence at EOF — emit what we buffered without highlighting.
+    if (inFence && blockLines.length > 0) {
+        out.push(blockLines.join('\n'));
+    }
+    return out.join('\n');
+}
+/**
+ * Deprecated name kept for pipeline.ts compatibility. New call sites should
+ * import `applyCodeHighlight` directly.
+ */
+export { applyCodeHighlight as applyAbapHighlight };
+function highlightAbapBlock(block) {
+    return block.split('\n').map(highlightLine).join('\n');
+}
+function highlightLine(line) {
+    // Comment: full line starting with * or " (ABAP inline comment)
+    const trimmed = line.trimStart();
+    if (trimmed.startsWith('*') || trimmed.startsWith('"')) {
+        return chalk.gray(line);
+    }
+    // Tokenise: strings first (to avoid coloring contents), then the rest.
+    // Z/Y prefix heuristic: matches any word starting with Z or Y — case-insensitive
+    // on the prefix letter because modern ABAP (Eclipse ADT / Clean ABAP) is typically
+    // lowercase (`zcl_my_class`) while legacy tooling uses UPPERCASE (`ZCL_MY_CLASS`).
+    // The `\w+` tail accepts either case. May false-positive on English words like
+    // "Yes", "Zebra" if they appear as bare identifiers — acceptable trade-off for
+    // zero-config highlighting.
+    return line.replace(/('(?:[^']|'')*')|(\b[ZYzy]\w+)|(\b(?:0x[\da-fA-F]+|\d+(?:\.\d+)?)\b)|(\b[A-Z_][A-Z0-9_-]*\b)/g, (match, str, zy, num, word) => {
+        if (str !== undefined)
+            return chalk.green(str);
+        if (zy !== undefined)
+            return chalk.yellow(match);
+        if (num !== undefined)
+            return chalk.magenta(match);
+        if (word !== undefined && ABAP_KEYWORDS.has(word.toUpperCase()))
+            return chalk.cyan(match);
+        return match;
+    });
+}

package/dist/renderer/banners.js

@@ -0,0 +1,39 @@
+import chalk from 'chalk';
+/** CSPeach brand colour — used for the brand-name text in the startup line,
+ *  the tool-dispatch bullet (⏺), and the result continuation glyph (⎿).
+ *  Single source of truth so a future rebrand is one find-replace.
+ *  The startup banner uses the 🍑 emoji directly (no tint) for identity. */
+export const PEACH = '#FFCBA4';
+/**
+ * Minimal startup line — terse, single bullet, three lines max. Modeled on
+ * Claude Code's `✻ Welcome to Claude Code v1.0.x` pattern but with the
+ * CSPeach brand glyph (Georgia peach emoji) replacing the generic star.
+ * No box, no fanfare — get out of the way.
+ *
+ * Renders:
+ *   🍑 CSPeach  v0.5.0
+ *      ABAP + AI + safety gates · by Cremencing Solutions
+ *
+ * Note on indent — the 🍑 emoji renders as 2 cells in modern terminals
+ * (Windows Terminal, iTerm2, Git Bash). Line 2 uses 3 leading spaces so
+ * the tagline column-aligns with the brand-name letters above. The emoji
+ * is intentionally NOT chalk-colored — terminals render emoji with their
+ * native color glyph and applying a tint usually corrupts that.
+ *
+ * The fallback literal is the published version — bumped here whenever
+ * the CLI is released. npm_package_version is set when the binary runs
+ * via `npm exec` / `pnpm`, but unset for direct `cspeach` shim launches,
+ * which is why the literal exists at all.
+ */
+export function printStartupBanner() {
+    const version = process.env.npm_package_version ?? '0.5.0';
+    console.log('');
+    console.log(`🍑 ${chalk.hex(PEACH).bold('CSPeach')}  ${chalk.white.bold('v' + version)}`);
+    console.log(`   ${chalk.gray('ABAP + AI + safety gates')} ${chalk.dim('·')} ${chalk.gray('by Cremencing Solutions')}`);
+    console.log('');
+}
+export function printKeytarFallbackBanner() {
+    console.log(chalk.yellow('⚠  OS keychain unavailable on this system.'));
+    console.log(chalk.yellow('   API key + SAP passwords will be prompted per session.'));
+    console.log(chalk.yellow('   Run `cspeach doctor` for remediation hints.\n'));
+}