@cspeach/cli 0.8.0 → 1.0.0

package/dist/router/classifier.js

@@ -1,6 +1,8 @@
 import { loadConfig } from '../config/loader.js';
 import { getStore } from '../auth/api-key.js';
 import { classify as classifyLocal } from '../classifier/client.js';
+import { SKILL_CATALOG, SKILL_ALIASES, resolveSkillAlias } from '../skill-catalog.js';
+import { isBuiltinCommandHead } from '../repl/builtin-commands.js';
 // 8s — sized to cover the observed Fly cold-start (~3.2s on the 2026-05-20
 // probe) plus headroom for a slow network. Tighter values risk timing out
 // legitimate cold-start hits and burning the retry budget on the same.
@@ -42,6 +44,18 @@ async function tryFetchOnce(proxyUrl, key, prompt, context) {
     }
 }
 export async function classifyPrompt(prompt, context) {
+    // D22/D35 structural invariant (2026-06-11) — an explicit slash command
+    // must NEVER reach the classifier. The S3 battery proved the failure mode:
+    // `/abap-plan <multiline>` failed the old parseShortcut regex, the whole
+    // line (slash included) was classified, routed to /abap-rap, and the
+    // plan-save hook keyed off the wrong skill label silently lost the
+    // envelope. Routing layers (repl.tsx, one-shot.ts) handle slash input
+    // before classification; this guard is the backstop that turns any
+    // future regression into a loud error instead of a silent misroute.
+    // Fires BEFORE config/key loading so no network call is ever made.
+    if (prompt.trimStart().startsWith('/')) {
+        throw new Error('slash command reached the classifier — explicit /commands must be routed before classification (CLI bug, please report)');
+    }
     const cfg = await loadConfig();
     const store = await getStore();
     const key = await store.get();
@@ -82,23 +96,153 @@ export async function classifyPrompt(prompt, context) {
     }
     if (!r.ok)
         throw new Error(`classifier HTTP ${r.status}`);
-    return (await r.json());
+    const result = (await r.json());
+    // Portfolio-merge resilience (2026-06-12): the proxy classifier's skill
+    // list can lag a rename (it still knows 'abap-dump-analyze' until its
+    // SKILL_LIST is redeployed). Map retired names — primary and alternates —
+    // to their successor so the CLI never dispatches a deleted skill.
+    result.skill = resolveSkillAlias(result.skill);
+    if (result.alternates?.length) {
+        result.alternates = [...new Set(result.alternates.map(resolveSkillAlias))]
+            .filter((s) => s !== result.skill);
+    }
+    return result;
 }
 export function parseShortcut(input) {
     // `/skill-name rest` → { skill: 'abap-skill-name', prompt: 'rest' }
     //   abap- prefix auto-prepended if missing (all skills in KV use abap-* namespace).
     // `@OBJECT_NAME rest` → { object: 'OBJECT_NAME', prompt: 'rest' }
+    // `@OBJECT_NAME /skill rest` → { object, skill, prompt: 'rest' } (composed)
     // otherwise → { prompt: input }
-    const slashMatch = input.match(/^\/([a-z0-9-]+)\s*(.*)$/i);
+    //
+    // D22/D34 (2026-06-11): both regexes use `[\s\S]*` for the prompt body —
+    // `.` does not match `\n`, so the old `(.*)$` failed on any prompt with
+    // 2+ lines, fell through to { prompt: input }, and the slash command was
+    // silently fed to the intent classifier. Leading separator whitespace is
+    // stripped (greedy `\s*` / `\s+`); the prompt body's own newlines and
+    // indentation are preserved.
+    const slashMatch = input.match(/^\/([a-z0-9-]+)\s*([\s\S]*)$/i);
     /** Auto-prepend ONLY inside the slash shortcut branch; plain prose goes through classifyPrompt. */
     if (slashMatch) {
+        const typedHead = `/${slashMatch[1]}`;
         let skill = slashMatch[1];
         if (!skill.startsWith('abap-'))
             skill = 'abap-' + skill;
-        return { skill, prompt: slashMatch[2] };
+        // Retired-name redirect: '/abap-dump-analyze ...' keeps routing (to
+        // 'abap-dump') for one release. renamedFrom drives the dim notice.
+        if (skill in SKILL_ALIASES) {
+            return { skill: SKILL_ALIASES[skill], prompt: slashMatch[2], typedHead, renamedFrom: skill };
+        }
+        return { skill, prompt: slashMatch[2], typedHead };
+    }
+    const atMatch = input.match(/^@([A-Z0-9_]+)\s+([\s\S]*)$/i);
+    if (atMatch) {
+        const object = atMatch[1];
+        const body = atMatch[2];
+        // Composition (2026-06-11): `@ZCL_X /abap-explain why` — explicit skill
+        // after the object token. Re-parse the body so the skill routes; without
+        // this, prompt='/abap-explain why' leaks to classifyPrompt, whose slash
+        // guard throws (REPL: "[classifier error]"; one-shot: uncaught). The
+        // re-parsed skill goes through the same isKnownSkill / rejectUnknownSkill
+        // checks at the call sites — the object variant gets no bypass.
+        if (body.startsWith('/')) {
+            const inner = parseShortcut(body);
+            if (inner.skill) {
+                return { object, skill: inner.skill, prompt: inner.prompt, typedHead: inner.typedHead, renamedFrom: inner.renamedFrom };
+            }
+        }
+        return { object, prompt: body };
     }
-    const atMatch = input.match(/^@([A-Z0-9_]+)\s+(.*)$/i);
-    if (atMatch)
-        return { object: atMatch[1], prompt: atMatch[2] };
     return { prompt: input };
 }
+/** True when `skill` (full name, e.g. 'abap-plan') exists in the catalog. */
+export function isKnownSkill(skill) {
+    return SKILL_CATALOG.some((s) => s.name === skill);
+}
+/**
+ * Levenshtein edit distance. Inputs are skill-name sized (≤ ~25 chars),
+ * so the O(a·b) two-row implementation is plenty.
+ */
+function levenshtein(a, b) {
+    let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+    for (let i = 1; i <= a.length; i++) {
+        const curr = [i];
+        for (let j = 1; j <= b.length; j++) {
+            curr[j] = Math.min(prev[j] + 1, // deletion
+            curr[j - 1] + 1, // insertion
+            prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+        }
+        prev = curr;
+    }
+    return prev[b.length];
+}
+/**
+ * D35 — closest catalog skills for an unknown `/cmd`. Prefix completions
+ * rank first (typed a truncated name), then close typos (edit distance ≤ 3).
+ */
+export function suggestSkills(unknown, limit = 3) {
+    const u = unknown.toLowerCase();
+    return SKILL_CATALOG
+        .map((s) => ({ name: s.name, rank: s.name.startsWith(u) ? 0 : levenshtein(u, s.name) }))
+        .filter((s) => s.rank <= 3)
+        .sort((a, b) => a.rank - b.rank)
+        .slice(0, limit)
+        .map((s) => s.name);
+}
+/**
+ * D35 — user-facing notice for an explicit slash command that names a
+ * skill missing from the catalog. The routing layer prints this and ends
+ * the turn; the input must NEVER fall through to the classifier (the
+ * classifyPrompt guard above enforces that structurally).
+ */
+export function unknownSkillMessage(skill) {
+    const suggestions = suggestSkills(skill);
+    const didYouMean = suggestions.length > 0
+        ? ` — did you mean ${suggestions.map((s) => `/${s}`).join(' or ')}?`
+        : '.';
+    return `unknown skill /${skill}${didYouMean} Type /help to see all skills.`;
+}
+/** Notice for a builtin command typed with arguments (e.g. `/help me`). */
+export function builtinTakesNoArgsMessage(head) {
+    return `${head} doesn't take arguments — just type ${head}.`;
+}
+/** One-line notice when a retired skill name redirects to its successor. */
+export function renamedSkillMessage(oldName, newName) {
+    return `/${oldName} is now /${newName} — routing there. The old name goes away next release.`;
+}
+/**
+ * Shared unknown-skill gate for all three routing layers (Ink REPL,
+ * classic REPL, one-shot). Call right after parseShortcut, BEFORE any
+ * dispatch or classification:
+ *
+ *   if (rejectUnknownSkill(parsed, emit)) return; // turn ends here
+ *
+ * Returns true (and emits exactly one notice) when the parsed slash names
+ * a skill missing from the catalog — the input must NEVER fall through to
+ * the classifier (classifyPrompt asserts on it) and must never dispatch
+ * to a nonexistent skill. Returns false when there is nothing to reject
+ * (no slash, or a known skill).
+ *
+ * Builtin disambiguation (2026-06-11): `/help me` parses to skill
+ * 'abap-help' (unknown) — but the user meant the builtin. Builtins with
+ * arguments are never handled by the REPLs' exact-match builtin handlers,
+ * so they land here; emit a "doesn't take arguments" notice instead of
+ * the misleading "unknown skill /abap-help — did you mean ...".
+ */
+export function rejectUnknownSkill(parsed, emit) {
+    // Renamed-skill notice (2026-06-12): a retired name was redirected by
+    // parseShortcut. Tell the user once, then continue the turn normally —
+    // this is informational, NOT a rejection (return false).
+    if (parsed.skill && parsed.renamedFrom) {
+        emit(renamedSkillMessage(parsed.renamedFrom, parsed.skill));
+        return false;
+    }
+    if (!parsed.skill || isKnownSkill(parsed.skill))
+        return false;
+    if (parsed.typedHead && isBuiltinCommandHead(parsed.typedHead) && parsed.prompt.trim().length > 0) {
+        emit(builtinTakesNoArgsMessage(parsed.typedHead.toLowerCase()));
+        return true;
+    }
+    emit(unknownSkillMessage(parsed.skill));
+    return true;
+}

package/dist/sap/capability-matrix.js

@@ -0,0 +1,20 @@
+/**
+ * Snapshot loader for the committed ABAP feature matrix.
+ *
+ * The snapshot (capability-matrix.json) is DATA, not code — it is refreshed
+ * by re-pulling from the sap-docs MCP and overwriting the file, never
+ * hand-edited.
+ *
+ * Loading mechanism: a direct JSON import. The project's tsconfig enables
+ * `resolveJsonModule` with `module: NodeNext`, so `tsc` both type-checks the
+ * import AND copies the .json into `dist/sap/` alongside the emitted .js
+ * (verified: the emitted module does `require("./capability-matrix.json")`
+ * and the file is present in outDir). This is build-safe with the project's
+ * plain-`tsc` build — no asset-copy step or bundler is involved — and matches
+ * the fiori catalog's intent of keeping bundled data deterministic.
+ */
+import matrix from './capability-matrix.json' with { type: 'json' };
+/** Returns the committed feature-matrix snapshot. Side-effect-free. */
+export function loadCapabilityMatrix() {
+    return matrix;
+}