@cspeach/cli 0.6.0

package/dist/approvals/jwt.js

@@ -0,0 +1,33 @@
+import { SignJWT, jwtVerify } from 'jose';
+import crypto from 'node:crypto';
+// Session-scoped HMAC key — generated per CLI start, never persisted.
+const sessionKey = crypto.randomBytes(32);
+const usedNonces = new Set();
+export async function mintApprovalId(payload) {
+    const nonce = crypto.randomBytes(16).toString('hex');
+    return new SignJWT({ ...payload, nonce })
+        .setProtectedHeader({ alg: 'HS256' })
+        .setIssuedAt()
+        .setExpirationTime('5m')
+        .sign(sessionKey);
+}
+export async function verifyAndSpendApprovalId(jwt, expectedObject, expectedOp) {
+    try {
+        const { payload } = await jwtVerify(jwt, sessionKey);
+        const p = payload;
+        if (usedNonces.has(p.nonce))
+            return { ok: false, reason: 'nonce_spent' };
+        if (p.object !== expectedObject)
+            return { ok: false, reason: 'object_mismatch' };
+        if (p.op !== expectedOp)
+            return { ok: false, reason: 'op_mismatch' };
+        usedNonces.add(p.nonce);
+        return { ok: true, payload: p };
+    }
+    catch (err) {
+        if (String(err?.code).includes('JWTExpired') || String(err?.message).toLowerCase().includes('expired')) {
+            return { ok: false, reason: 'expired' };
+        }
+        return { ok: false, reason: 'invalid_signature' };
+    }
+}

package/dist/approvals/render.js

@@ -0,0 +1,211 @@
+import { select, input } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { shouldUseInk } from '../renderer/tty.js';
+import { approvalEmitter } from '../ui/approval-emitter.js';
+import { withInquirer } from '../repl/inquirer-guard.js';
+import { inquirerTheme } from '../repl/inquirer-theme.js';
+import { PEACH } from '../renderer/banners.js';
+const peach = (s) => chalk.hex(PEACH)(s);
+/**
+ * Op-row glyph. 2026-05-01: dropped the per-op color spread (yellow M,
+ * green A, blue >, magenta ^). Using 5 different hues for routine plan
+ * rows trains the user to ignore color as semantic signal — by the time
+ * an actual delete shows up, red has already appeared on three other
+ * lines and lost its punch. Now: only `D` (delete) gets red, because
+ * delete is the only op that's destructive enough to deserve a hot
+ * accent. Everything else renders dim — the row layout already tells
+ * the user it's a change row.
+ */
+function opIcon(op) {
+    switch (op) {
+        case 'create': return chalk.dim('A');
+        case 'modify': return chalk.dim('M');
+        case 'delete': return chalk.red('D');
+        case 'activate': return chalk.dim('>');
+        case 'release': return chalk.dim('^');
+        default: return chalk.dim('?');
+    }
+}
+/**
+ * Risk tag. 2026-05-01: yellow used to fire on `medium` too, which
+ * meant most plans had a yellow tag — defeating yellow's purpose as
+ * an "attention required" signal. Now: yellow ONLY on `high`,
+ * everything else dim. (Risk is also raised to red.bold for high so
+ * it pops without yellow doing extra work.)
+ */
+function riskTag(r) {
+    if (r === 'high')
+        return chalk.red.bold('high risk');
+    return chalk.dim(r === 'medium' ? 'medium risk' : 'low risk');
+}
+/**
+ * Colorize a unified-diff string for terminal display:
+ *   - `+ …` (additions)         → green
+ *   - `- …` (removals)          → red
+ *   - `@@ …` (hunk headers)     → peach (brand)
+ *   - `--- …` / `+++ …` headers → dim (informational, not part of the change)
+ *   - context lines             → dim
+ *
+ * Operates line-by-line so a long diff stays readable. The leading +/- char
+ * is part of the colored span, matching standard `git diff` rendering.
+ */
+function colorizeDiff(diff) {
+    return diff
+        .split('\n')
+        .map((line) => {
+        if (line.startsWith('+++') || line.startsWith('---'))
+            return chalk.dim(line);
+        if (line.startsWith('@@'))
+            return peach(line);
+        if (line.startsWith('+'))
+            return chalk.green(line);
+        if (line.startsWith('-'))
+            return chalk.red(line);
+        return chalk.dim(line);
+    })
+        .join('\n');
+}
+/**
+ * Plan-level gate. Renders a compact summary of the change set and asks the
+ * user to apply-all, review-each, or cancel. Apply-all is the default —
+ * matches how users actually operate ("yes, do it") and skips the redundant
+ * per-change prompts that were the main "so much confusion" complaint.
+ *
+ * Color discipline:
+ *   - Peach (PEACH) for the brand-bearing "Plan" header.
+ *   - Default text for the summary, change list. No cyan, no bold-on-bold.
+ *   - Yellow tag for medium risk, red for high. Low is dim — no shouting.
+ */
+/**
+ * Collapse the changes list for *display purposes only* — `activate` is the
+ * implicit follow-on of a `modify`/`create` on the same object, so we hide
+ * the activate row when its sibling write is already in the list. The
+ * underlying `changes[]` (which drives approval-id minting and per-change
+ * approval prompts) is unchanged — only the user-facing plan summary is
+ * compressed. This is what fixes the "what 2 changes?" complaint when the
+ * model declares modify+activate of the same object.
+ */
+function collapseImplicitActivates(changes) {
+    const writeKeys = new Set();
+    for (const c of changes) {
+        if (c.op === 'modify' || c.op === 'create') {
+            writeKeys.add(`${c.type}:${c.object}`);
+        }
+    }
+    return changes.filter((c) => {
+        if (c.op !== 'activate')
+            return true;
+        return !writeKeys.has(`${c.type}:${c.object}`);
+    });
+}
+export async function renderPlanGate(summary, changes, transport, effectiveRisk) {
+    const visibleChanges = collapseImplicitActivates(changes);
+    const visibleCount = visibleChanges.length;
+    const noun = visibleCount === 1 ? 'change' : 'changes';
+    console.log('');
+    console.log(`${peach('Plan')}  ${summary}`);
+    const meta = [`${visibleCount} ${noun}`, riskTag(effectiveRisk.level)];
+    if (transport)
+        meta.push(`transport ${transport}`);
+    console.log(`      ${chalk.dim(meta.join(' · '))}`);
+    if (effectiveRisk.raisedBy.length > 0) {
+        console.log(`      ${chalk.dim(`(raised from low: ${effectiveRisk.raisedBy.join(', ')})`)}`);
+    }
+    for (const c of visibleChanges) {
+        console.log(`        ${opIcon(c.op)} ${c.object.padEnd(30)} ${chalk.dim(`(${c.type})`)}`);
+    }
+    console.log('');
+    const choice = await withInquirer(() => select({
+        message: 'Apply?',
+        default: 'apply_all',
+        theme: inquirerTheme,
+        choices: [
+            { value: 'apply_all', name: `Apply all ${visibleCount} ${noun}` },
+            { value: 'review', name: 'Review each change individually' },
+            { value: 'cancel', name: 'Cancel' },
+        ],
+    }));
+    return choice;
+}
+export async function renderPerChangeApproval(change, effectiveRisk, transport) {
+    // No "Approval requested" preamble — the inquirer message below carries the
+    // change identifier. The risk + transport line was redundant with what
+    // renderPlanGate already showed, and was the main source of "why so much
+    // text for one prompt" feedback. Show it ONLY when this per-change call
+    // fires standalone (single-change request_approval) AND risk is non-low.
+    void effectiveRisk;
+    void transport;
+    const objLabel = `${opIcon(change.op)} ${change.object} (${change.type})`;
+    const choice = await withInquirer(() => select({
+        message: `${objLabel} — apply?`,
+        default: 'apply',
+        theme: inquirerTheme,
+        choices: [
+            { value: 'apply', name: 'Apply' },
+            { value: 'diff', name: 'Show diff' },
+            { value: 'skip', name: 'Skip (tell model why)' },
+            { value: 'cancel', name: 'Cancel turn' },
+        ],
+    }));
+    if (choice === 'apply')
+        return { approved: true };
+    if (choice === 'cancel')
+        return { approved: false, reason: '__cancel_turn__' };
+    if (choice === 'skip') {
+        const reason = await withInquirer(() => input({ message: 'Why skip?', theme: inquirerTheme }));
+        return { approved: false, reason };
+    }
+    // 'diff' — print colorized + lines (green) / - lines (red) / hunk headers
+    // (peach) so the user can scan the change at a glance instead of squinting
+    // at flat-gray text.
+    //
+    // 2026-05-01: detect "model sent a description, not a diff" — when the
+    // payload has no +/-/@ lines and no `--- /+++ ` headers, colorizeDiff
+    // would render every line in dim grey, making the summary look like a
+    // useless diff and forcing the user to hit Skip in frustration. Show an
+    // explicit warning instead so the user knows the model didn't supply
+    // proper diff content.
+    if (change.diff) {
+        if (looksLikeUnifiedDiff(change.diff)) {
+            console.log('\n' + colorizeDiff(change.diff) + '\n');
+        }
+        else {
+            console.log('\n' + chalk.yellow('⚠  Model did not provide a unified diff — only a description:'));
+            console.log(chalk.dim(change.diff) + '\n');
+        }
+    }
+    else {
+        console.log(chalk.dim('(No diff provided by the model)'));
+    }
+    return renderPerChangeApproval(change, effectiveRisk, transport);
+}
+/**
+ * Heuristic: a real unified diff has at least one line starting with `+`,
+ * `-`, or `@@`. A summary or change description won't. Used to gate
+ * colorizeDiff vs the "model didn't supply a diff" warning so the Show diff
+ * option doesn't return useless dim grey text when the model passed a
+ * one-paragraph description in the `diff` field.
+ */
+function looksLikeUnifiedDiff(s) {
+    return s.split('\n').some((line) => {
+        if (line.startsWith('+++') || line.startsWith('---'))
+            return false;
+        return line.startsWith('+') || line.startsWith('-') || line.startsWith('@@');
+    });
+}
+/**
+ * v0.3 dispatcher: routes to Ink modal (via approvalEmitter) when running
+ * under Ink, else delegates to the existing inquirer-based flow.
+ */
+export async function renderPerChangeApprovalV3(change, riskResult, transport) {
+    if (!shouldUseInk()) {
+        // Non-TTY: delegate to existing inquirer flow.
+        return renderPerChangeApproval(change, riskResult, transport);
+    }
+    return renderApprovalModalAndAwait(change, riskResult, transport);
+}
+async function renderApprovalModalAndAwait(change, riskResult, transport) {
+    return new Promise((resolve) => {
+        approvalEmitter.emit('request', { change, effectiveRisk: riskResult, transport, resolve });
+    });
+}

package/dist/approvals/risk-floor.js

@@ -0,0 +1,26 @@
+export function effectiveRisk(declared, changes, ctx) {
+    let floor = declared;
+    const raisedBy = [];
+    const rank = (r) => ({ low: 0, medium: 1, high: 2 }[r]);
+    const raise = (r, label) => {
+        if (rank(r) > rank(floor)) {
+            floor = r;
+            raisedBy.push(label);
+        }
+    };
+    if (ctx.autoApprovePolicy === 'never')
+        raise('high', 'non_prod_override');
+    if (changes.some((c) => c.op === 'delete'))
+        raise('medium', 'delete_op');
+    if (changes.some((c) => c.op === 'release' || c.op === 'activate'))
+        raise('medium', 'shared_transport');
+    if (ctx.recentAtcFailure && changes.some((c) => ctx.recentAtcFailure.includes(c.object)))
+        raise('medium', 'atc_failed_24h');
+    if ((ctx.transportRecentDevelopers ?? 0) >= 3)
+        raise('medium', 'shared_transport');
+    if (changes.length > 5)
+        raise('medium', 'escalated_in_session');
+    if (ctx.prodNamespaces && changes.some((c) => ctx.prodNamespaces.some((p) => c.object.startsWith(p))))
+        raise('medium', 'prod_namespace');
+    return { level: floor, raisedBy };
+}

package/dist/auth/api-key.js

@@ -0,0 +1,40 @@
+import keytar from 'keytar';
+const SERVICE = 'cspeach';
+const ACCOUNT = 'api-key';
+class KeytarStore {
+    async get() { return keytar.getPassword(SERVICE, ACCOUNT); }
+    async set(key) { await keytar.setPassword(SERVICE, ACCOUNT, key); }
+    async delete() { await keytar.deletePassword(SERVICE, ACCOUNT); }
+    async isKeychainAvailable() {
+        try {
+            const probe = `probe-${Date.now()}`;
+            await keytar.setPassword(SERVICE, 'probe', probe);
+            const ok = (await keytar.getPassword(SERVICE, 'probe')) === probe;
+            await keytar.deletePassword(SERVICE, 'probe');
+            return ok;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+class EphemeralStore {
+    cached = null;
+    async get() { return this.cached; }
+    async set(key) { this.cached = key; }
+    async delete() { this.cached = null; }
+    async isKeychainAvailable() { return false; }
+}
+let store;
+export async function getStore() {
+    if (store)
+        return store;
+    const ktr = new KeytarStore();
+    if (await ktr.isKeychainAvailable()) {
+        store = ktr;
+    }
+    else {
+        store = new EphemeralStore();
+    }
+    return store;
+}

package/dist/auth/auth-file.js

@@ -0,0 +1,59 @@
+/**
+ * Read/write ~/.cspeach/auth.json — the customer's CSPeach API key
+ * + optional Anthropic key for BYOK trials.
+ *
+ * Permissions: 0600 on POSIX. Windows uses NTFS ACLs which Node's
+ * fs mode flag doesn't translate; we rely on the user-dir default
+ * permissions on Windows and recommend OS keychain (v2 roadmap)
+ * for that platform.
+ *
+ * Coexists with the existing keytar-based auth/api-key.ts. The
+ * device-code flow (cspeach login) writes here; older config-set
+ * paths still write to keytar. Task 9 wires the REPL to read here
+ * first, fall back to keytar.
+ */
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import { cspeachRoot } from '../config/paths.js';
+let pathOverride = null;
+/** Test-only override; pass null to reset. */
+export function __setAuthFilePathForTests(p) {
+    pathOverride = p;
+}
+function authFilePath() {
+    return pathOverride ?? path.join(cspeachRoot(), 'auth.json');
+}
+export async function readAuthFile() {
+    try {
+        const raw = await fs.readFile(authFilePath(), 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.apiKey !== 'string' || typeof parsed.customerId !== 'string')
+            return null;
+        return {
+            apiKey: parsed.apiKey,
+            customerId: parsed.customerId,
+            byokAnthropicKey: typeof parsed.byokAnthropicKey === 'string' ? parsed.byokAnthropicKey : null,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeAuthFile(auth) {
+    const p = authFilePath();
+    await fs.mkdir(path.dirname(p), { recursive: true });
+    await fs.writeFile(p, JSON.stringify(auth, null, 2), { encoding: 'utf-8', mode: 0o600 });
+    // Defensive: re-chmod in case the create-time mode was ignored (e.g., umask 022).
+    if (process.platform !== 'win32') {
+        try {
+            await fs.chmod(p, 0o600);
+        }
+        catch { /* ignore */ }
+    }
+}
+export async function deleteAuthFile() {
+    try {
+        await fs.unlink(authFilePath());
+    }
+    catch { /* ignore */ }
+}

package/dist/auth/device.js

@@ -0,0 +1,8 @@
+// node-machine-id is CJS — import the default, then destructure.
+import nodeMachineId from 'node-machine-id';
+import os from 'node:os';
+const { machineId } = nodeMachineId;
+export async function getDeviceFingerprint() {
+    const mid = await machineId(true).catch(() => 'unknown');
+    return { machineId: mid, hostname: os.hostname() };
+}

package/dist/auth/me.js

@@ -0,0 +1,19 @@
+/**
+ * Fetch /v1/me — customer profile + entitlements + usage.
+ * Result envelope so the REPL doesn't need try/catch.
+ */
+export async function fetchMe(opts) {
+    const url = `${opts.proxyUrl.replace(/\/$/, '')}/v1/me`;
+    try {
+        const r = await fetch(url, { headers: { Authorization: `Bearer ${opts.apiKey}` } });
+        if (!r.ok) {
+            const body = await r.json().catch(() => ({}));
+            return { ok: false, status: r.status, error: body.error ?? 'unknown' };
+        }
+        const profile = await r.json();
+        return { ok: true, profile };
+    }
+    catch (err) {
+        return { ok: false, status: 0, error: err instanceof Error ? err.message : String(err) };
+    }
+}

package/dist/classifier/client.js

@@ -0,0 +1,58 @@
+const RULES = [
+    { skill: 'abap-atc-fix', patterns: [/atc\s+(fix|auto\s+fix)|abap\s+test\s+cockpit.*fix/i] },
+    { skill: 'abap-cca', patterns: [/custom\s+code\s+analysis|\bcca\b|clean\s+core\s+(assessment|analysis)/i] },
+    { skill: 'abap-cloud-check', patterns: [/cloud\s+ready|clean\s+core(?!\s+(assessment|analysis))|s\/4hana\s+cloud\s+check/i] },
+    { skill: 'abap-data-model', patterns: [/data\s+model|ddic\s+(design|structure)|domain|data\s+element|create\s+(a\s+)?z[_\w]*\s+(table|structure)|new\s+(z[_\w]*\s+)?(table|structure|domain)/i] },
+    { skill: 'abap-design', patterns: [/solution\s+architecture|object\s+list|design\s+the\s+solution/i] },
+    { skill: 'abap-handover', patterns: [/technical\s+documentation|object\s+catalog|doc(ument)?\s+package|handover/i] },
+    { skill: 'abap-document', patterns: [/developer\s+documentation|document\s+this\s+(class|program|object)/i] },
+    // abap-incident MUST precede dump rules — pipeline framing beats keyword-only matches
+    { skill: 'abap-incident', patterns: [/incident|resolve.*dump.*to.*fix|pipeline.*(short\s+dump|st22|dump)|(dump|st22).*to.*transport|formal\s+(incident|dump)\s+report|end.to.end.*dump/i] },
+    { skill: 'abap-dump-triage', patterns: [/dump\s+triage|structured\s+investigation.*dump|dump\s+forensic/i] },
+    { skill: 'abap-dump-analyze', patterns: [/short\s+dump|runtime\s+error|\bst22\b|dump\s+analys/i] },
+    { skill: 'abap-eml', patterns: [/\beml\b|entity\s+manipulation|behavior\s+handler/i] },
+    { skill: 'abap-enhance', patterns: [/\bbadi\b|enhancement\s+spot|implicit\s+enhancement|customer\s+exit|user\s+exit|(hook\s+into|extend)\s+(sap|standard|me\d+|migo|miro|va\d+|vf\d+|vl\d+|fb\d+)/i] },
+    { skill: 'abap-estimate', patterns: [/effort\s+estimat|ticket\s+estimat|size\s+this\s+(work|task|ticket|story)|how\s+(many|long).*(hours|days).*(build|develop|implement)/i] },
+    { skill: 'abap-explain', patterns: [/\bexplain\b|what\s+does\s+this\s+(do|code)|walk.*through/i] },
+    // abap-test MUST precede abap-generate so "generate tests" routes to the test skill
+    // (test-gen merged into abap-test on 2026-05-02 — phrases preserved here).
+    { skill: 'abap-test', patterns: [/unit\s+test|abap\s+unit|test\s+(class|doubles)|generate\s+tests|test\s+generation|improve\s+test\s+coverage/i] },
+    // abap-modernize MUST precede abap-rap so "rebuild as RAP" / "convert to RAP" stays
+    // on modernize (rebuild intent) instead of falling to abap-rap's bare \brap\b match.
+    { skill: 'abap-modernize', patterns: [/modernise|modernize|classic.*to.*modern|convert.*to\s+(rap|fiori|odata)|rebuild.*as\s+(rap|fiori)/i] },
+    // abap-rap MUST precede abap-generate so RAP-stack prompts route to rap, not the
+    // generic generator (cluster I, 2026-05-03). Also captures "scaffold a CDS view +
+    // BDEF + service binding" type prompts which collide with abap-generate.
+    { skill: 'abap-rap', patterns: [/\brap\b|business\s+object(?!s?\s+for)|bdef|service\s+binding|srvb|scaffold.*(cds|odata\s+v4|bdef|behavior)|odata\s+v4\s+service/i] },
+    { skill: 'abap-generate', patterns: [/\bgenerate\b|create\s+(a\s+)?(new\s+)?(class|program|report|include)|build.*from\s+scratch/i] },
+    { skill: 'abap-impact', patterns: [/impact\s+analysis|where.*used|what.*affected\s+by/i] },
+    // abap-upgrade-* must precede abap-migrate
+    { skill: 'abap-upgrade-verify', patterns: [/upgrade\s+verify|remediation\s+report|verify\s+upgrade/i] },
+    { skill: 'abap-upgrade-fix', patterns: [/upgrade\s+fix|atc\s+remediation|fix\s+upgrade\s+finding/i] },
+    { skill: 'abap-upgrade-scan', patterns: [/upgrade\s+scan|scan.*s\/4|readiness\s+variant/i] },
+    { skill: 'abap-migrate', patterns: [/ecc.*migration|migrate.*s\/4|api\s+successor/i] },
+    { skill: 'abap-performance', patterns: [/performance|\bn\+1\b|select\s+inside\s+loop|slow\s+(query|select)/i] },
+    { skill: 'abap-preflight', patterns: [/preflight|pre.release|go\/no.go|release\s+readiness/i] },
+    { skill: 'abap-radar', patterns: [/radar|quick\s+look|overview\s+of\s+(this\s+)?(class|program|object)/i] },
+    { skill: 'abap-refactor', patterns: [/refactor|clean\s+up\s+(code|abap)|procedural.*to\s+oo/i] },
+    { skill: 'abap-review', patterns: [/^review|code\s+review|code\s+quality|clean\s+abap(?!\s+conformity)/i] },
+    { skill: 'abap-segw', patterns: [/segw|dpc_ext|mpc_ext|gateway\s+(project|service)|build.*odata.*(ecc|gateway)/i] },
+    { skill: 'abap-spec-gap', patterns: [/spec\s+gap|missing\s+(spec|requirements)|business\s+questions|clarif(y|ying)\s+(question|requirement)|gaps?\s+in\s+the\s+(spec|story|requirement)/i] },
+    // abap-transport-analysis MUST precede abap-transport
+    { skill: 'abap-transport-analysis', patterns: [/transport\s+analysis|pre.release\s+transport|transport\s+readiness/i] },
+    { skill: 'abap-transport', patterns: [/transport\s+(create|release|list)|\bcts\b|release.*request/i] },
+];
+if (RULES.length !== 32) {
+    // Warn-not-throw — managed-mode users never exercise classify() (the proxy
+    // does server-side classification), so a module-load crash would break
+    // them for a local-only consistency check. Unit tests assert the exact
+    // count.
+    console.warn(`[classifier] RULES drift: expected 32, got ${RULES.length} — reconcile with .claude/skills/`);
+}
+export function classify(prompt) {
+    for (const rule of RULES) {
+        if (rule.patterns.some(p => p.test(prompt)))
+            return rule.skill;
+    }
+    return undefined;
+}

package/dist/cli-args.js

@@ -0,0 +1,38 @@
+/**
+ * Pure argument-parsing helpers for the CSPeach CLI entry point.
+ * Extracted for unit-testability — no side effects, no I/O.
+ */
+/**
+ * Scan `args` for `--sap-alias <name>`.
+ *
+ * - If the flag is absent: returns `{ rest: args }` (no-op).
+ * - If the flag is present and the alias is in `availableAliases`: strips the
+ *   two tokens and returns `{ sapAlias, rest }`.
+ * - If the alias is NOT in `availableAliases`: returns `{ error, rest: args }`.
+ * - If `--sap-alias` is the last token (no name follows): returns `{ error, rest: args }`.
+ */
+export function extractSapAliasFlag(args, availableAliases) {
+    const idx = args.indexOf('--sap-alias');
+    if (idx === -1) {
+        return { rest: args };
+    }
+    // Flag present but no value after it
+    if (idx === args.length - 1) {
+        return {
+            rest: args,
+            error: 'error: --sap-alias requires a name argument. Usage: cspeach --sap-alias <name>',
+        };
+    }
+    const alias = args[idx + 1];
+    // Unknown alias
+    if (availableAliases.length > 0 && !availableAliases.includes(alias)) {
+        const list = availableAliases.join(', ');
+        return {
+            rest: args,
+            error: `error: alias '${alias}' not found in config. Available: ${list}`,
+        };
+    }
+    // Strip the two tokens from args
+    const rest = [...args.slice(0, idx), ...args.slice(idx + 2)];
+    return { sapAlias: alias, rest };
+}

package/dist/cli.js

@@ -0,0 +1,148 @@
+import chalk from 'chalk';
+import { runAddSapWizard } from './sap/onboarding.js';
+import { runGcOnStartup } from './session/gc.js';
+import { checkForUpgrade } from './upgrade-check.js';
+import { extractSapAliasFlag } from './cli-args.js';
+export async function main(argv) {
+    runGcOnStartup().catch(() => { });
+    checkForUpgrade().catch(() => { });
+    let args = argv.slice(2);
+    if (args[0] === '--help' || args[0] === '-h') {
+        printHelp();
+        return 0;
+    }
+    if (args[0] === '--version') {
+        console.log(process.env.npm_package_version ?? '0.5.0');
+        return 0;
+    }
+    if (args[0] === '--upgrade') {
+        const { runUpgrade } = await import('./upgrade.js');
+        return runUpgrade();
+    }
+    if (args[0] === '--resume') {
+        const { runResume } = await import('./session/resume.js');
+        return runResume(args[1]);
+    }
+    // C.1 — extract --sap-alias <name> early so it is available for REPL and
+    // one-shot paths. Validation requires loading config to know available aliases.
+    let sapAlias;
+    if (args.includes('--sap-alias')) {
+        const { loadConfig } = await import('./config/loader.js');
+        const cfg = await loadConfig();
+        const availableAliases = Object.keys(cfg.sap);
+        const parsed = extractSapAliasFlag(args, availableAliases);
+        if (parsed.error) {
+            console.error(chalk.red(parsed.error));
+            return 1;
+        }
+        sapAlias = parsed.sapAlias;
+        args = parsed.rest;
+    }
+    if (args[0] === 'configure') {
+        console.log(chalk.dim('(alias for `cspeach config add-sap`)'));
+        await runAddSapWizard();
+        return 0;
+    }
+    if (args[0] === 'config' && args[1] === 'add-sap') {
+        await runAddSapWizard();
+        return 0;
+    }
+    if (args[0] === 'config' && args[1] === 'set') {
+        const { runConfigSet, ConfigSetError } = await import('./commands/config-set.js');
+        try {
+            await runConfigSet(args.slice(2));
+        }
+        catch (e) {
+            if (e instanceof ConfigSetError) {
+                console.error(chalk.red(`✗ ${e.message}`));
+                process.exit(e.exitCode);
+            }
+            throw e;
+        }
+        return 0;
+    }
+    if (args[0] === 'config' && args[1] === 'show') {
+        const { runConfigShow } = await import('./commands/config-show.js');
+        await runConfigShow(args.slice(2));
+        return 0;
+    }
+    if (args[0] === 'doctor') {
+        const { runDoctor } = await import('./doctor/run.js');
+        return runDoctor();
+    }
+    if (args[0] === 'login') {
+        const { runLoginCommand } = await import('./commands/login.js');
+        const { input } = await import('@inquirer/prompts');
+        const { loadConfig } = await import('./config/loader.js');
+        const cfg = await loadConfig();
+        const open = async (url) => {
+            const { spawn } = await import('node:child_process');
+            // On Windows, `start` is a cmd builtin and needs a shell; spawn the URL via cmd /c.
+            if (process.platform === 'win32') {
+                spawn('cmd', ['/c', 'start', '', url], { detached: true, stdio: 'ignore' }).unref();
+            }
+            else {
+                const cmd = process.platform === 'darwin' ? 'open' : 'xdg-open';
+                spawn(cmd, [url], { detached: true, stdio: 'ignore' }).unref();
+            }
+        };
+        return runLoginCommand({
+            proxyUrl: cfg.proxy_url,
+            open,
+            print: (s) => console.log(s),
+            prompt: (q) => input({ message: q }),
+        });
+    }
+    if (args[0] === 'logout') {
+        const { runLogoutCommand } = await import('./commands/logout.js');
+        return runLogoutCommand({ print: (s) => console.log(s) });
+    }
+    if (args[0] === 'whoami') {
+        const { runWhoamiCommand } = await import('./commands/whoami.js');
+        const { loadConfig } = await import('./config/loader.js');
+        const cfg = await loadConfig();
+        return runWhoamiCommand({ proxyUrl: cfg.proxy_url, print: (s) => console.log(s) });
+    }
+    if (args[0] === 'analyze' && args[1] === 'project-context') {
+        const { runProjectContextImpactCommand } = await import('./commands/project-context-impact.js');
+        return runProjectContextImpactCommand(args.slice(2));
+    }
+    if (args[0] === '--one-shot') {
+        const { runOneShot } = await import('./one-shot.js');
+        return runOneShot(args.slice(1).join(' '), { sapAlias });
+    }
+    // Default: if first arg exists and is not a flag, treat as one-shot prompt.
+    if (args.length > 0 && !args[0].startsWith('-')) {
+        const { runOneShot } = await import('./one-shot.js');
+        return runOneShot(args.join(' '), { sapAlias });
+    }
+    // No args → REPL.
+    const { runRepl } = await import('./repl.js');
+    return runRepl({ sapAlias });
+}
+function printHelp() {
+    console.log(`
+CSPeach — AI-assisted ABAP development CLI
+
+Usage:
+  cspeach                           Start interactive REPL
+  cspeach "<prompt>"                One-shot — runs one turn and exits
+  cspeach --one-shot "<prompt>"     Same as above, explicit flag
+  cspeach --sap-alias <name>        Use a specific SAP alias (overrides default)
+  cspeach --resume [id]             Resume a previous session (list if no id)
+  cspeach config add-sap            Add a SAP system interactively
+  cspeach configure                 Alias for \`cspeach config add-sap\`
+  cspeach config set <key> <value>  Update a config key
+  cspeach config show [key]         Show config (full or single key)
+  cspeach doctor                    Diagnose install + connectivity
+  cspeach login                     Sign in via device-code flow
+  cspeach logout                    Sign out (keep keytar key, if any)
+  cspeach whoami                    Print current account info
+  cspeach analyze project-context   Compare flag-on vs flag-off session metrics
+  cspeach --upgrade                 Upgrade to latest via npm
+  cspeach --version                 Print version
+  cspeach --help                    Show this help
+
+Docs: https://cspeach.dev
+`);
+}