@cspeach/cli 1.0.0 → 1.1.1

package/dist/session/recap.js

@@ -0,0 +1,160 @@
+// cspeach-cli/src/session/recap.ts
+//
+// UX Wave 2 / Task 6 — session recap: three lines that re-orient a developer
+// who just resumed (or typed /recap) without scrolling back through the
+// transcript.
+//
+//   ↩ last session: /abap-generate · 4 turns · 3h ago · "add a validation…"
+//   ▶ tasks: 2 done / 3 open — next: write the BDEF validation
+//   ▷ plan Maintenance Requests: phase 3/7 validated — next: /abap-plan --resume @…
+//
+// Line 1 always prints (unless the session has zero user turns → recap is
+// empty and callers print nothing). Line 2 only when the session's todo list
+// has non-completed entries. Line 3 only when the NEWEST plan family in the
+// workspace still has unsatisfied phases (audit-aware, same predicates the
+// plan DAG uses).
+//
+// PURE except the plan-envelope reads: no writes, no prompts, never throws —
+// a bad/missing workspace or a corrupt envelope silently drops line 3. The
+// workspace dir is injectable (opts.workspaceDir) so call sites can pass the
+// config-resolved path (resolveWorkspacePath) and tests can point at a temp
+// dir; the fallback is the project-rooted default for `cwd`.
+import { readdirSync, statSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { formatTimeAgo } from './time-ago.js';
+import { readProjectFile } from '../projects/status.js';
+import { parsePlanContent } from '../projects/plan-schema.js';
+import { statusesFromItems, isPhaseSatisfied } from '../projects/plan-run.js';
+import { defaultWorkspaceFor } from '../projects/workspace.js';
+/** Wave-1 truncation rule (see /reroute): ≤60 chars total, '...' suffix. */
+function truncatePrompt(s) {
+    return s.length > 60 ? s.slice(0, 57) + '...' : s;
+}
+/**
+ * Build the recap lines for a session. Returns [] for an empty session
+ * (zero user turns) — callers print nothing in that case.
+ */
+export function buildRecap(session, cwd, opts) {
+    const lines = [];
+    // ── line 1: session orientation ─────────────────────────────────────────
+    // "User turns" = plain-string user messages (tool_result rounds are arrays)
+    // — same counting rule as the resume picker (session/store.ts).
+    const userMessages = session.messages.filter((m) => m.role === 'user' && typeof m.content === 'string');
+    const turns = userMessages.length;
+    if (turns === 0)
+        return [];
+    const skillLabel = session.skill ? `/${session.skill}` : 'no skill';
+    // Last user prompt: prefer the persisted lastUserPrompt (user-typed prose;
+    // null after slash-only commands), fall back to the last string user
+    // message with the first-turn <session_context> wrapper stripped (same
+    // rule as the picker's promptSnippet).
+    let prompt = session.lastUserPrompt;
+    if (!prompt) {
+        const last = userMessages[userMessages.length - 1].content;
+        prompt = last.replace(/<session_context>[\s\S]*?<\/session_context>\s*/g, '').trim() || null;
+    }
+    const quoted = prompt ? `"${truncatePrompt(prompt)}"` : '(no prompt)';
+    const ago = formatTimeAgo(session.last_turn_at, opts?.now);
+    lines.push(`↩ last session: ${skillLabel} · ${turns} turn${turns === 1 ? '' : 's'} · ${ago} · ${quoted}`);
+    // ── line 2: todo list (Task 4's todo_set) — only when open work exists ──
+    const todos = session.todos ?? [];
+    const open = todos.filter((t) => t.status !== 'completed');
+    if (open.length > 0) {
+        const done = todos.length - open.length;
+        const next = todos.find((t) => t.status === 'in_progress') ?? todos.find((t) => t.status === 'pending');
+        lines.push(`▶ tasks: ${done} done / ${open.length} open — next: ${next.text}`);
+    }
+    // ── line 3: newest plan family with unsatisfied phases ──────────────────
+    // Never throws: any fs/parse problem silently drops the line.
+    try {
+        const planLine = buildPlanLine(opts?.workspaceDir ?? defaultWorkspaceFor(cwd));
+        if (planLine)
+            lines.push(planLine);
+    }
+    catch { /* recap must never throw */ }
+    return lines;
+}
+/**
+ * Scan `workspaceDir` for the newest plan family and, when it still has
+ * unsatisfied phases, produce the plan recap line. Returns null when there
+ * is no plan, the newest plan family is fully satisfied, or its envelope is
+ * invalid (silent skip by design).
+ *
+ * "Newest family": envelope files group into families by filename base
+ * (`<base>-v<N>[-<sub>].cspeach.json` — same convention as
+ * pickNewestPlanVersion / findNewestVersion in commands/plan-resume.ts);
+ * within a family the highest version wins; families rank by their newest
+ * file's mtime. Non-plan envelopes (design, spec-gap, …) are skipped so the
+ * newest PLAN family is found even when a newer non-plan artefact exists.
+ */
+function buildPlanLine(workspaceDir) {
+    let names;
+    try {
+        names = readdirSync(workspaceDir);
+    }
+    catch {
+        return null; // workspace missing — nothing to recap
+    }
+    const re = /^(.+)-v(\d+)(?:-(\d+))?\.cspeach\.json$/;
+    const cands = [];
+    for (const name of names) {
+        if (!name.endsWith('.cspeach.json'))
+            continue;
+        const path = join(workspaceDir, name);
+        let mtimeMs;
+        try {
+            mtimeMs = statSync(path).mtimeMs;
+        }
+        catch {
+            continue;
+        }
+        const m = re.exec(name);
+        if (m) {
+            cands.push({ path, family: m[1], version: Number(m[2]), sub: m[3] ? Number(m[3]) : 0, mtimeMs });
+        }
+        else {
+            // Hand-renamed / version-less envelope: its own single-file family.
+            cands.push({ path, family: name.slice(0, -'.cspeach.json'.length), version: 0, sub: 0, mtimeMs });
+        }
+    }
+    if (cands.length === 0)
+        return null;
+    // Newest version per family (version, then collision sub, then mtime).
+    const byFamily = new Map();
+    for (const c of cands) {
+        const cur = byFamily.get(c.family);
+        if (!cur
+            || c.version > cur.version
+            || (c.version === cur.version && (c.sub > cur.sub || (c.sub === cur.sub && c.mtimeMs > cur.mtimeMs)))) {
+            byFamily.set(c.family, c);
+        }
+    }
+    // Families newest-first by their representative file's mtime; the first
+    // family whose envelope IS a plan is "the newest plan family".
+    const familiesNewestFirst = [...byFamily.values()].sort((a, b) => b.mtimeMs - a.mtimeMs);
+    for (const cand of familiesNewestFirst) {
+        let env;
+        try {
+            env = readProjectFile(cand.path);
+        }
+        catch {
+            continue; // unreadable/invalid file — can't tell it's a plan; skip family
+        }
+        if (env.artefactType !== 'plan')
+            continue;
+        // This is the newest plan family. Invalid content → silent skip (no
+        // falling through to an older plan family — stale info is worse than none).
+        const pc = parsePlanContent(env.content);
+        if (!pc.ok)
+            return null;
+        const statuses = statusesFromItems(env.interaction.items, pc.content.phases);
+        const total = pc.content.phases.length;
+        // Audit-aware satisfaction — same predicate as the plan DAG (a
+        // validated-but-audit-failed phase is NOT done).
+        const validated = pc.content.phases.filter((p) => isPhaseSatisfied(statuses[p.id], p.audit)).length;
+        if (total === 0 || validated >= total)
+            return null; // fully satisfied — no line
+        return `▷ plan ${env.title}: phase ${validated}/${total} validated — next: /abap-plan --resume @${basename(cand.path)}`;
+    }
+    return null;
+}

package/dist/skill-catalog.js

@@ -1,12 +1,12 @@
 /**
  * Static skill catalog for CSPeach CLI v0.2.
  *
- * STALENESS RISK (spec §3.3): This constant is hardcoded against the 32 skills
- * in .claude/skills/ as of 2026-06-28 (abap-dump-analyze + abap-dump-triage
+ * STALENESS RISK (spec §3.3): This constant is hardcoded against the 33 skills
+ * in .claude/skills/ as of 2026-07-03 (abap-dump-analyze + abap-dump-triage
  * merged into abap-dump 2026-06-12; abap-extend-model added 2026-06-25;
  * abap-radar/abap-document/abap-performance/abap-cloud-check merged into
  * abap-explain/abap-handover/abap-review 2026-06-28 per
- * plan 2026-06-28-skill-portfolio-merge). It will drift if skills are added or
+ * plan 2026-06-28-skill-portfolio-merge; abap-clean-core added 2026-06-29). It will drift if skills are added or
  * removed. At Plan 4b kickoff decision the build-time generation option
  * (scripts/generate-skill-catalog.ts reads SKILL.md frontmatter) or runtime
  * fetch (/v1/skills endpoint) will be chosen to replace this file. Until then,
@@ -32,6 +32,12 @@ export const SKILL_CATALOG = [
         description: 'Read-only review across lenses: quality (default), performance, cloud-readiness',
         whenToUse: `grade source: quality (default) + performance/cloud lenses`,
     },
+    {
+        name: 'abap-clean-core',
+        category: 'Read / Analyze',
+        description: 'Clean-core decision & defense — recommend the clean-core-correct approach, classify the level (A/B/C/D), produce citable evidence; verifies live when connected. Read-only.',
+        whenToUse: `pick this for "is this clean-core-OK?" decisions + defendable evidence (not /abap-review cloud lens — that grades code)`,
+    },
     {
         name: 'abap-handover',
         category: 'Read / Analyze',