@cspeach/cli 0.6.0

package/dist/projects/extract-design.js

@@ -0,0 +1,107 @@
+const TITLE_RE = /^## ABAP Design — (.+)$/m;
+const OBJECTS_HEADING_RE = /^### Objects to Create\s*$/m;
+const DEPENDENCY_HEADING_RE = /^### Dependency Sequence\s*$/m;
+const NEXT_HEADING_RE = /^###\s/m;
+function sliceSection(markdown, headingRe) {
+    const m = headingRe.exec(markdown);
+    if (!m)
+        return null;
+    const start = m.index + m[0].length;
+    const rest = markdown.slice(start);
+    const next = NEXT_HEADING_RE.exec(rest);
+    return next ? rest.slice(0, next.index) : rest;
+}
+function parseObjectsTable(section) {
+    const lines = section.split(/\r?\n/);
+    const rows = [];
+    for (const raw of lines) {
+        const line = raw.trim();
+        if (!line.startsWith('|'))
+            continue;
+        if (/^\|\s*-+\s*\|/.test(line))
+            continue;
+        if (/^\|\s*#\s*\|/.test(line))
+            continue;
+        const cells = line.split('|').slice(1, -1).map((c) => c.trim());
+        if (cells.length < 5)
+            continue;
+        const numStr = cells[0];
+        if (!/^\d+$/.test(numStr))
+            continue;
+        rows.push({
+            num: Number(numStr),
+            name: cells[1],
+            type: cells[2],
+            package: cells[4],
+        });
+    }
+    return rows;
+}
+function parseDependencySequence(section, nameToId) {
+    const out = new Map();
+    if (!section)
+        return out;
+    // Tolerate em-dash (—), en-dash (–), double hyphen (--), or single hyphen (-).
+    const itemRe = /^\d+\.\s+([A-Za-z0-9_]+)\s*(?:\([^)]*\))?\s*(?:[—–]|--?)\s*(.+)$/gm;
+    let m;
+    while ((m = itemRe.exec(section)) !== null) {
+        const name = m[1];
+        const tail = m[2];
+        const deps = [];
+        if (!/no dependencies/i.test(tail)) {
+            const depMatch = /depends on\s+(.+)$/i.exec(tail);
+            if (depMatch) {
+                const depList = depMatch[1].split(/\s*,\s*(?:and\s+)?|\s+and\s+/).map((s) => s.trim()).filter(Boolean);
+                for (const depName of depList) {
+                    const clean = depName.replace(/\s*\([^)]*\)\s*$/, '').replace(/[.,;]+$/, '').trim();
+                    const depId = nameToId.get(clean);
+                    if (depId)
+                        deps.push(depId);
+                }
+            }
+        }
+        out.set(name, deps);
+    }
+    return out;
+}
+export function extractDesign(markdown) {
+    const titleMatch = TITLE_RE.exec(markdown);
+    if (!titleMatch) {
+        throw new Error('Input is not a design output (no "## ABAP Design — ..." heading found)');
+    }
+    const title = titleMatch[1].trim();
+    const objectsSection = sliceSection(markdown, OBJECTS_HEADING_RE);
+    if (!objectsSection) {
+        throw new Error('No "### Objects to Create" section found');
+    }
+    const rows = parseObjectsTable(objectsSection);
+    if (rows.length === 0) {
+        throw new Error('Objects to Create table is empty');
+    }
+    // Assign sequential ids obj-001..obj-N preserving table order
+    const nameToId = new Map();
+    const idForRow = rows.map((r, i) => {
+        const id = `obj-${String(i + 1).padStart(3, '0')}`;
+        nameToId.set(r.name, id);
+        return id;
+    });
+    const depsByName = parseDependencySequence(sliceSection(markdown, DEPENDENCY_HEADING_RE) ?? '', nameToId);
+    const content = {
+        objects: rows.map((r, i) => ({
+            id: idForRow[i],
+            name: r.name,
+            type: r.type,
+            package: r.package,
+            dependsOn: depsByName.get(r.name) ?? [],
+        })),
+    };
+    const items = content.objects.map((o) => ({
+        id: o.id,
+        status: 'keep',
+        answer: null,
+        answeredBy: null,
+        answeredAt: null,
+        comments: [],
+    }));
+    return { title, content, items };
+}

package/dist/projects/extract-estimate.js

@@ -0,0 +1,93 @@
+const TITLE_RE = /^## Effort Estimate — (.+)$/m;
+const COMPONENTS_HEADING_RE = /^### Component Breakdown\s*$/m;
+const NEXT_HEADING_RE = /^###\s/m;
+function sliceSection(markdown, headingRe) {
+    const m = headingRe.exec(markdown);
+    if (!m)
+        return null;
+    const start = m.index + m[0].length;
+    const rest = markdown.slice(start);
+    const next = NEXT_HEADING_RE.exec(rest);
+    return next ? rest.slice(0, next.index) : rest;
+}
+// Parse a numeric cell, tolerating "**44**" / "5" / "1.5" / "0.5".
+function parseHours(cell) {
+    const cleaned = cell.replace(/\*+/g, '').trim();
+    if (!/^-?\d+(\.\d+)?$/.test(cleaned))
+        return null;
+    return Number(cleaned);
+}
+function parseComponentsTable(section) {
+    const lines = section.split(/\r?\n/);
+    const rows = [];
+    for (const raw of lines) {
+        const line = raw.trim();
+        if (!line.startsWith('|'))
+            continue;
+        if (/^\|\s*-+\s*\|/.test(line))
+            continue;
+        if (/^\|\s*#\s*\|/.test(line))
+            continue;
+        const cells = line.split('|').slice(1, -1).map((c) => c.trim());
+        // Expected cell count: 7 (#, Component, Objects, Opt, Realistic, Pess, Notes)
+        if (cells.length < 7)
+            continue;
+        const numStr = cells[0];
+        if (!/^\d+$/.test(numStr))
+            continue; // skips "TOTAL" row (empty # cell)
+        // Belt-and-braces: also skip rows whose Component cell looks like a TOTAL
+        // header even if it somehow has a numeric # column (e.g. malformed input).
+        if (/^\*?\*?\s*total/i.test(cells[1]))
+            continue;
+        const hOpt = parseHours(cells[3]);
+        const hReal = parseHours(cells[4]);
+        const hPess = parseHours(cells[5]);
+        if (hOpt === null || hReal === null || hPess === null)
+            continue;
+        const notes = cells[6].trim();
+        const risks = notes ? notes.split(/;\s*/).map((s) => s.trim()).filter(Boolean) : [];
+        rows.push({
+            num: Number(numStr),
+            name: cells[1],
+            hoursOptimistic: hOpt,
+            hoursRealistic: hReal,
+            hoursPessimistic: hPess,
+            risks,
+        });
+    }
+    return rows;
+}
+export function extractEstimate(markdown) {
+    const titleMatch = TITLE_RE.exec(markdown);
+    if (!titleMatch) {
+        throw new Error('Input is not an estimate output (no "## Effort Estimate — ..." heading found)');
+    }
+    const title = titleMatch[1].trim();
+    const section = sliceSection(markdown, COMPONENTS_HEADING_RE);
+    if (!section) {
+        throw new Error('No "### Component Breakdown" section found');
+    }
+    const rows = parseComponentsTable(section);
+    if (rows.length === 0) {
+        throw new Error('Component Breakdown table has no data rows');
+    }
+    const content = {
+        components: rows.map((r, i) => ({
+            id: `cmp-${String(i + 1).padStart(3, '0')}`,
+            name: r.name,
+            hoursOptimistic: r.hoursOptimistic,
+            hoursRealistic: r.hoursRealistic,
+            hoursPessimistic: r.hoursPessimistic,
+            risks: r.risks,
+        })),
+    };
+    const items = content.components.map((c) => ({
+        id: c.id,
+        status: 'confirmed',
+        answer: null,
+        answeredBy: null,
+        answeredAt: null,
+        comments: [],
+    }));
+    return { title, content, items };
+}

package/dist/projects/extract-modernize.js

@@ -0,0 +1,130 @@
+/**
+ * Parser for the `<!-- csforge:modernize-manifest ... -->` block emitted
+ * by /abap-modernize at the end of a run. v0.7 — one of the trio of
+ * downstream artefacts a cca-assessment fans out into.
+ *
+ * Format mirrors extract-upgrade.ts / extract-cca.ts. The grammar is
+ * key:value pairs + optional indented `|`-separated tables under a
+ * trailing-colon header. Hidden in human renderers (HTML comment),
+ * structured enough for a deterministic extractor.
+ *
+ *   <!-- csforge:modernize-manifest
+ *   artefact: modernize-result
+ *   title: ZDPR_PAYMENTS — modernization
+ *   detail_path: .abapforge/modernize/zdpr-payments/project.json
+ *   baseline_path: <project-relative path>
+ *   baseline_sha256: <hex>
+ *   transport: <id or ->
+ *   applied: 1
+ *   skipped: 0
+ *   failed: 0
+ *   pending: 0
+ *   modernizations:
+ *     item-001 | ZBDC_VENDOR_PAYMENTS_CLOUD | FUNC | bdc-against-f53 | fm-based-posting | applied
+ *     item-002 | ZPAYMENTS                  | PROG | select-from-bsig | cds-i_journalentryitem | pending
+ *   -->
+ *
+ * Parsing is permissive — missing optional fields produce defaults; a
+ * missing manifest block throws so callers know to surface the error.
+ */
+const MANIFEST_RE = /<!--\s*csforge:modernize-manifest\s*\n([\s\S]*?)\n\s*-->/;
+function parseManifestBlock(markdown) {
+    const m = MANIFEST_RE.exec(markdown);
+    if (!m) {
+        throw new Error('No <!-- csforge:modernize-manifest --> block found in skill output');
+    }
+    const body = m[1] ?? '';
+    const kv = {};
+    const tables = {};
+    let currentTable = null;
+    for (const rawLine of body.split('\n')) {
+        const line = rawLine.replace(/\r$/, '');
+        if (line.trim().length === 0) {
+            currentTable = null;
+            continue;
+        }
+        if (currentTable !== null && /^\s+/.test(line)) {
+            const cells = line.trim().split('|').map((c) => c.trim());
+            if (cells.length > 0) {
+                if (!tables[currentTable])
+                    tables[currentTable] = [];
+                tables[currentTable].push(cells);
+            }
+            continue;
+        }
+        const colon = line.indexOf(':');
+        if (colon === -1)
+            continue;
+        const key = line.slice(0, colon).trim();
+        const value = line.slice(colon + 1).trim();
+        if (value.length === 0) {
+            currentTable = key;
+            tables[key] = [];
+        }
+        else {
+            kv[key] = value;
+            currentTable = null;
+        }
+    }
+    return { kv, tables };
+}
+function intOr(kv, key, fallback) {
+    const v = kv[key];
+    if (v === undefined)
+        return fallback;
+    const n = Number.parseInt(v, 10);
+    return Number.isFinite(n) ? n : fallback;
+}
+const ALLOWED_STATUSES = [
+    'applied', 'skipped', 'failed', 'pending',
+];
+function asStatus(raw) {
+    const v = raw.toLowerCase();
+    return ALLOWED_STATUSES.includes(v)
+        ? v
+        : 'pending';
+}
+export function extractModernizeResult(markdown) {
+    const { kv, tables } = parseManifestBlock(markdown);
+    if (kv.artefact !== 'modernize-result') {
+        throw new Error(`Manifest artefact mismatch: expected 'modernize-result', got '${kv.artefact}'`);
+    }
+    if (!kv.detail_path) {
+        throw new Error("modernize-result manifest missing required 'detail_path'");
+    }
+    if (!kv.baseline_path) {
+        throw new Error("modernize-result manifest missing required 'baseline_path'");
+    }
+    const modernizations = (tables.modernizations ?? []).map((row, i) => ({
+        id: row[0] ?? `item-${String(i + 1).padStart(3, '0')}`,
+        objectName: row[1] ?? '',
+        objectType: row[2] ?? '',
+        fromArchitecture: row[3] ?? '',
+        toArchitecture: row[4] ?? '',
+        status: asStatus(row[5] ?? 'pending'),
+    }));
+    const content = {
+        detailPath: kv.detail_path,
+        baselineRef: {
+            path: kv.baseline_path,
+            sha256: kv.baseline_sha256 ?? '',
+        },
+        transport: kv.transport && kv.transport !== '-' ? kv.transport : null,
+        summary: {
+            applied: intOr(kv, 'applied', 0),
+            skipped: intOr(kv, 'skipped', 0),
+            failed: intOr(kv, 'failed', 0),
+            pending: intOr(kv, 'pending', 0),
+        },
+        modernizations,
+    };
+    const items = modernizations.map((m) => ({
+        id: m.id,
+        status: m.status,
+        answer: null,
+        answeredBy: null,
+        answeredAt: null,
+        comments: [],
+    }));
+    return { title: kv.title ?? 'Modernization Result', content, items };
+}

package/dist/projects/extract-spec-gap.js

@@ -0,0 +1,101 @@
+const TITLE_RE = /^## Spec Gap Analysis — (.+)$/m;
+const DOMAIN_RE = /^\*\*Inferred Domain:\*\*\s*(.+?)(?:\s*\[INFERRED.*?\])?$/m;
+const INPUT_TYPE_RE = /^\*\*Input Type:\*\*\s*(.+)$/m;
+const SECTION_HEADING_RE = /^### (.+)$/gm;
+// Real-world model output shows two formatting variants:
+//   '    1. [BLOCKER] Text'        — leading indent (4 spaces or tab), plain severity
+//   '1. **[BLOCKER]** Text'        — no indent, severity wrapped in markdown bold
+// Tolerate both: optional leading whitespace + optional `**` around the severity bracket.
+const GAP_LINE_RE = /^\s*(\d+)\.\s*(?:\*\*)?\[(BLOCKER|IMPORTANT|NICE TO KNOW)\](?:\*\*)?\s*(.+)$/m;
+const AUDIENCE_BY_SECTION_NAME = {
+    'missing business questions': 'business',
+    'missing technical questions': 'technical',
+    'data assumptions to confirm': 'data',
+    'authorization questions': 'auth',
+    'authorisation questions': 'auth',
+    'edge cases not covered': 'business',
+    'transport and release concerns': 'transport',
+    'clean core / api concerns': 'clean-core',
+};
+function audienceFor(sectionName) {
+    const key = sectionName.toLowerCase().trim();
+    for (const [k, v] of Object.entries(AUDIENCE_BY_SECTION_NAME)) {
+        if (key.includes(k))
+            return v;
+    }
+    return 'unknown';
+}
+const KNOWN_GAP_SECTIONS = [
+    'Missing Business Questions',
+    'Missing Technical Questions',
+    'Data Assumptions to Confirm',
+    'Authorization Questions',
+    'Authorisation Questions', // British spelling — both OK
+    'Edge Cases Not Covered',
+    'Transport and Release Concerns',
+    'Clean Core / API Concerns',
+];
+const SKIP_SECTIONS = [
+    'Suggested Test Scenarios', // is a table, not a gap list
+    'Recommended Next Steps', // is a paragraph
+];
+export function extractSpecGap(markdown) {
+    const titleMatch = TITLE_RE.exec(markdown);
+    if (!titleMatch) {
+        throw new Error('Input is not a spec-gap output (no "## Spec Gap Analysis — ..." heading found)');
+    }
+    const title = titleMatch[1].trim();
+    const inputType = (INPUT_TYPE_RE.exec(markdown)?.[1] ?? 'Unknown').trim();
+    const inferredDomain = (DOMAIN_RE.exec(markdown)?.[1] ?? 'Unknown').trim();
+    const sectionStarts = [];
+    let m;
+    const reCopy = new RegExp(SECTION_HEADING_RE.source, SECTION_HEADING_RE.flags);
+    while ((m = reCopy.exec(markdown)) !== null) {
+        sectionStarts.push({ name: m[1].trim(), index: m.index });
+    }
+    if (sectionStarts.length === 0) {
+        throw new Error('Input is not a spec-gap output (no "### " sections found)');
+    }
+    const sections = [];
+    const items = [];
+    let gapCounter = 1;
+    for (let i = 0; i < sectionStarts.length; i++) {
+        const cur = sectionStarts[i];
+        const next = sectionStarts[i + 1];
+        if (SKIP_SECTIONS.some((s) => cur.name.toLowerCase().includes(s.toLowerCase())))
+            continue;
+        if (!KNOWN_GAP_SECTIONS.some((s) => cur.name.toLowerCase().includes(s.toLowerCase())))
+            continue;
+        const body = markdown.slice(cur.index, next ? next.index : markdown.length);
+        const gaps = parseGapsFromSection(body, () => `gap-${String(gapCounter++).padStart(3, '0')}`);
+        if (gaps.length > 0) {
+            sections.push({ name: cur.name, audience: audienceFor(cur.name), gaps });
+            for (const g of gaps) {
+                items.push({
+                    id: g.id,
+                    status: 'open',
+                    answer: null,
+                    answeredBy: null,
+                    answeredAt: null,
+                    comments: [],
+                });
+            }
+        }
+    }
+    return {
+        title,
+        content: { inputType, inferredDomain, sections },
+        items,
+    };
+}
+function parseGapsFromSection(sectionBody, nextId) {
+    const out = [];
+    const re = new RegExp(GAP_LINE_RE.source, 'gm');
+    let m;
+    while ((m = re.exec(sectionBody)) !== null) {
+        const severity = m[2];
+        const text = m[3].trim();
+        out.push({ id: nextId(), severity, text });
+    }
+    return out;
+}

package/dist/projects/extract-test-coverage.js

@@ -0,0 +1,137 @@
+/**
+ * Parser for the `<!-- csforge:test-coverage-manifest ... -->` block
+ * emitted by /abap-test at the end of a run. v0.7 — one of the trio of
+ * downstream artefacts a cca-assessment fans out into.
+ *
+ * coverage_pct_before / coverage_pct_after are optional — SAP's coverage
+ * tool (SCMP) isn't always available and the skill works without it.
+ * Empty / "-" values parse to null.
+ *
+ *   <!-- csforge:test-coverage-manifest
+ *   artefact: test-coverage
+ *   title: ZDPR_PAYMENTS — test coverage
+ *   detail_path: .abapforge/tests/zdpr-payments/project.json
+ *   baseline_path: <project-relative path>
+ *   baseline_sha256: <hex>
+ *   transport: <id or ->
+ *   test_classes_generated: 14
+ *   methods_added: 87
+ *   coverage_pct_before: 12
+ *   coverage_pct_after: 78
+ *   skipped: 0
+ *   failed: 0
+ *   tests:
+ *     item-001 | ZPAYMENTS         | PROG | ZPAYMENTS_TEST         | 6 | generated
+ *     item-002 | ZPAYMENTS_OLD     | PROG | ZPAYMENTS_OLD_TEST     | 4 | generated
+ *   -->
+ */
+const MANIFEST_RE = /<!--\s*csforge:test-coverage-manifest\s*\n([\s\S]*?)\n\s*-->/;
+function parseManifestBlock(markdown) {
+    const m = MANIFEST_RE.exec(markdown);
+    if (!m) {
+        throw new Error('No <!-- csforge:test-coverage-manifest --> block found in skill output');
+    }
+    const body = m[1] ?? '';
+    const kv = {};
+    const tables = {};
+    let currentTable = null;
+    for (const rawLine of body.split('\n')) {
+        const line = rawLine.replace(/\r$/, '');
+        if (line.trim().length === 0) {
+            currentTable = null;
+            continue;
+        }
+        if (currentTable !== null && /^\s+/.test(line)) {
+            const cells = line.trim().split('|').map((c) => c.trim());
+            if (cells.length > 0) {
+                if (!tables[currentTable])
+                    tables[currentTable] = [];
+                tables[currentTable].push(cells);
+            }
+            continue;
+        }
+        const colon = line.indexOf(':');
+        if (colon === -1)
+            continue;
+        const key = line.slice(0, colon).trim();
+        const value = line.slice(colon + 1).trim();
+        if (value.length === 0) {
+            currentTable = key;
+            tables[key] = [];
+        }
+        else {
+            kv[key] = value;
+            currentTable = null;
+        }
+    }
+    return { kv, tables };
+}
+function intOr(kv, key, fallback) {
+    const v = kv[key];
+    if (v === undefined)
+        return fallback;
+    const n = Number.parseInt(v, 10);
+    return Number.isFinite(n) ? n : fallback;
+}
+function intOrNull(kv, key) {
+    const v = kv[key];
+    if (v === undefined || v === '' || v === '-')
+        return null;
+    const n = Number.parseInt(v, 10);
+    return Number.isFinite(n) ? n : null;
+}
+const ALLOWED_STATUSES = [
+    'generated', 'skipped', 'failed', 'pending',
+];
+function asStatus(raw) {
+    const v = raw.toLowerCase();
+    return ALLOWED_STATUSES.includes(v)
+        ? v
+        : 'pending';
+}
+export function extractTestCoverage(markdown) {
+    const { kv, tables } = parseManifestBlock(markdown);
+    if (kv.artefact !== 'test-coverage') {
+        throw new Error(`Manifest artefact mismatch: expected 'test-coverage', got '${kv.artefact}'`);
+    }
+    if (!kv.detail_path) {
+        throw new Error("test-coverage manifest missing required 'detail_path'");
+    }
+    if (!kv.baseline_path) {
+        throw new Error("test-coverage manifest missing required 'baseline_path'");
+    }
+    const tests = (tables.tests ?? []).map((row, i) => ({
+        id: row[0] ?? `item-${String(i + 1).padStart(3, '0')}`,
+        targetObjectName: row[1] ?? '',
+        targetObjectType: row[2] ?? '',
+        testClassName: row[3] ?? '',
+        methodCount: Number.parseInt(row[4] ?? '0', 10) || 0,
+        status: asStatus(row[5] ?? 'pending'),
+    }));
+    const content = {
+        detailPath: kv.detail_path,
+        baselineRef: {
+            path: kv.baseline_path,
+            sha256: kv.baseline_sha256 ?? '',
+        },
+        transport: kv.transport && kv.transport !== '-' ? kv.transport : null,
+        summary: {
+            testClassesGenerated: intOr(kv, 'test_classes_generated', tests.filter((t) => t.status === 'generated').length),
+            methodsAdded: intOr(kv, 'methods_added', 0),
+            coveragePctBefore: intOrNull(kv, 'coverage_pct_before'),
+            coveragePctAfter: intOrNull(kv, 'coverage_pct_after'),
+            skipped: intOr(kv, 'skipped', 0),
+            failed: intOr(kv, 'failed', 0),
+        },
+        tests,
+    };
+    const items = tests.map((t) => ({
+        id: t.id,
+        status: t.status,
+        answer: null,
+        answeredBy: null,
+        answeredAt: null,
+        comments: [],
+    }));
+    return { title: kv.title ?? 'Test Coverage Report', content, items };
+}