@cspeach/cli 0.6.0

package/dist/project-context/conventions.js

@@ -0,0 +1,309 @@
+/**
+ * Project conventions reader.
+ *
+ * Source priority (highest first):
+ *
+ *   1. CLAUDE.md — preferred. Matches Claude Code's convention so
+ *      developers who use both tools don't maintain two files.
+ *      Read as free-text, included verbatim in `freeText`.
+ *
+ *   2. CSPEACH.md — optional CSPeach-specific override. Appended to
+ *      CLAUDE.md content when both exist. Use when CSPeach should
+ *      behave differently from Claude Code in the same repo (rare).
+ *
+ *   3. .cspeach/conventions.toml — structured overrides for naming
+ *      patterns + style. Sits alongside the optional .cspeach/ workspace
+ *      directory that already exists for project-rooted CSPeach files.
+ *
+ *   4. Inferred from existing files — when none of the above exist, we
+ *      sample one or two files to detect indent + EOL. Naming patterns
+ *      stay empty (best-effort inference is a follow-up; manual
+ *      override via .cspeach/conventions.toml is the recommended path
+ *      for projects that need it).
+ *
+ * Returns sensible defaults on every error. Never throws.
+ */
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+/**
+ * Default conventions used when no source has anything to say. Picked
+ * to match the most common conventions in modern SAP / web projects:
+ * 2-space indent, LF line endings, no inferred naming patterns.
+ */
+const DEFAULT_CONVENTIONS = {
+    freeText: null,
+    namingPatterns: {
+        classes: [],
+        interfaces: [],
+        cdsViews: [],
+    },
+    style: {
+        indentSize: 2,
+        indentChar: 'space',
+        eol: 'lf',
+    },
+};
+/**
+ * Read project conventions. Best-effort: returns DEFAULT_CONVENTIONS on
+ * any IO failure. Combines the four sources per priority order; later
+ * sources override earlier ones for structured fields, and append to
+ * `freeText` rather than replace it.
+ */
+export async function readConventions(cwd) {
+    const claudeBody = await readFileSafe(path.join(cwd, 'CLAUDE.md'));
+    const cspeachBody = await readFileSafe(path.join(cwd, 'CSPEACH.md'));
+    const freeText = combineFreeText(claudeBody, cspeachBody);
+    const tomlPath = path.join(cwd, '.cspeach', 'conventions.toml');
+    const tomlOverrides = await readConventionsToml(tomlPath);
+    const inferred = await inferStyleFromExistingFiles(cwd);
+    return {
+        freeText,
+        namingPatterns: {
+            classes: tomlOverrides?.namingPatterns?.classes ?? DEFAULT_CONVENTIONS.namingPatterns.classes,
+            interfaces: tomlOverrides?.namingPatterns?.interfaces ?? DEFAULT_CONVENTIONS.namingPatterns.interfaces,
+            cdsViews: tomlOverrides?.namingPatterns?.cdsViews ?? DEFAULT_CONVENTIONS.namingPatterns.cdsViews,
+        },
+        style: {
+            indentSize: tomlOverrides?.style?.indentSize ?? inferred?.indentSize ?? DEFAULT_CONVENTIONS.style.indentSize,
+            indentChar: tomlOverrides?.style?.indentChar ?? inferred?.indentChar ?? DEFAULT_CONVENTIONS.style.indentChar,
+            eol: tomlOverrides?.style?.eol ?? inferred?.eol ?? DEFAULT_CONVENTIONS.style.eol,
+        },
+    };
+}
+/* ── Free-text combination ─────────────────────────────────────────── */
+function combineFreeText(claude, cspeach) {
+    if (claude === null && cspeach === null)
+        return null;
+    const parts = [];
+    if (claude !== null) {
+        parts.push('## CLAUDE.md\n\n' + claude.trim());
+    }
+    if (cspeach !== null) {
+        parts.push('## CSPEACH.md\n\n' + cspeach.trim());
+    }
+    return parts.join('\n\n');
+}
+/**
+ * Parse `.cspeach/conventions.toml` if it exists. Returns null when the
+ * file is missing or malformed. We use a minimal TOML parser (just
+ * enough for the subset we accept) to avoid adding a dependency.
+ */
+async function readConventionsToml(p) {
+    const raw = await readFileSafe(p);
+    if (raw === null)
+        return null;
+    try {
+        return parseMinimalToml(raw);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Tiny TOML parser supporting only the subset we need:
+ *   - Section headers: [namingPatterns], [style]
+ *   - Key = "string", Key = 123, Key = ["a", "b"]
+ *   - # comments to end of line
+ *
+ * We avoid pulling in a TOML dependency (e.g. `smol-toml`) because the
+ * surface we parse is tiny and a typo-tolerant minimal parser keeps the
+ * convention file from failing the whole context read.
+ */
+function parseMinimalToml(raw) {
+    const out = {};
+    let section = null;
+    for (const rawLine of raw.split('\n')) {
+        const line = rawLine.replace(/#.*$/, '').trim();
+        if (line.length === 0)
+            continue;
+        // Section header
+        const sectionMatch = /^\[([a-zA-Z_]+)\]$/.exec(line);
+        if (sectionMatch) {
+            const name = sectionMatch[1];
+            if (name === 'namingPatterns' || name === 'style') {
+                section = name;
+            }
+            else {
+                section = null;
+            }
+            continue;
+        }
+        // Key = value
+        const kvMatch = /^([a-zA-Z_]+)\s*=\s*(.+)$/.exec(line);
+        if (!kvMatch)
+            continue;
+        const key = kvMatch[1];
+        const valueRaw = kvMatch[2].trim();
+        if (section === 'namingPatterns') {
+            const arr = parseStringArray(valueRaw);
+            if (arr !== null) {
+                if (!out.namingPatterns)
+                    out.namingPatterns = {};
+                if (key === 'classes')
+                    out.namingPatterns.classes = arr;
+                else if (key === 'interfaces')
+                    out.namingPatterns.interfaces = arr;
+                else if (key === 'cdsViews')
+                    out.namingPatterns.cdsViews = arr;
+            }
+        }
+        else if (section === 'style') {
+            if (!out.style)
+                out.style = {};
+            if (key === 'indentSize') {
+                const n = Number.parseInt(valueRaw, 10);
+                if (Number.isFinite(n) && n > 0)
+                    out.style.indentSize = n;
+            }
+            else if (key === 'indentChar') {
+                const s = parseString(valueRaw);
+                if (s === 'tab' || s === 'space')
+                    out.style.indentChar = s;
+            }
+            else if (key === 'eol') {
+                const s = parseString(valueRaw);
+                if (s === 'lf' || s === 'crlf')
+                    out.style.eol = s;
+            }
+        }
+    }
+    return out;
+}
+function parseString(v) {
+    const m = /^"([^"]*)"$/.exec(v) ?? /^'([^']*)'$/.exec(v);
+    return m ? m[1] : null;
+}
+function parseStringArray(v) {
+    if (!v.startsWith('[') || !v.endsWith(']'))
+        return null;
+    const inner = v.slice(1, -1).trim();
+    if (inner.length === 0)
+        return [];
+    const items = [];
+    // Simple split — doesn't handle escaped commas, which is fine for our subset.
+    for (const part of inner.split(',')) {
+        const s = parseString(part.trim());
+        if (s === null)
+            return null;
+        items.push(s);
+    }
+    return items;
+}
+/* ── Style inference ───────────────────────────────────────────────── */
+/**
+ * Sample one or two text files in the project tree and infer indent +
+ * EOL. Used only when conventions.toml doesn't override. Cheap heuristic
+ * — peek at the first few hundred bytes of the first 2 files we find.
+ *
+ * Returns null on any failure; caller falls back to DEFAULT_CONVENTIONS.style.
+ */
+async function inferStyleFromExistingFiles(cwd) {
+    try {
+        const samplePaths = await findSampleFiles(cwd, 2);
+        if (samplePaths.length === 0)
+            return null;
+        let indentChar;
+        let indentSize;
+        let eol;
+        for (const p of samplePaths) {
+            try {
+                const raw = await fs.readFile(p, 'utf-8');
+                const head = raw.slice(0, 4096);
+                // EOL: presence of \r\n means CRLF.
+                if (eol === undefined) {
+                    eol = head.includes('\r\n') ? 'crlf' : 'lf';
+                }
+                // Indent: scan for the first CODE-shaped indented line. Tab vs
+                // space is determined by what character appears first.
+                //
+                // Skip JSDoc / block-comment continuation lines (they start with
+                // ` *` — one space + asterisk — which would otherwise be misread
+                // as "1-space indent." This was a real dogfooding finding: most
+                // CSPeach .ts files start with a `/** ... */` docblock; the very
+                // first indented line was the ` * comment` continuation, and the
+                // detector reported indentSize=1.
+                if (indentChar === undefined) {
+                    for (const line of head.split('\n')) {
+                        if (line.length === 0)
+                            continue;
+                        // Skip block-comment continuation: `\s*\*\s` pattern (any
+                        // amount of leading whitespace, then `*`, then a space).
+                        if (/^\s*\*(\s|$|\/)/.test(line))
+                            continue;
+                        // Also skip pure-whitespace lines (some editors leave
+                        // trailing whitespace inside docblocks).
+                        if (/^\s*$/.test(line))
+                            continue;
+                        const ch = line[0];
+                        if (ch === '\t') {
+                            indentChar = 'tab';
+                            indentSize = 1;
+                            break;
+                        }
+                        if (ch === ' ') {
+                            indentChar = 'space';
+                            let count = 0;
+                            while (count < line.length && line[count] === ' ')
+                                count++;
+                            indentSize = count > 0 ? count : 2;
+                            break;
+                        }
+                    }
+                }
+            }
+            catch {
+                // Skip unreadable file
+            }
+        }
+        if (indentChar === undefined && eol === undefined)
+            return null;
+        return { indentChar, indentSize, eol };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Find up to `limit` text-ish source files for sampling. Skips
+ * node_modules, .git, dist, build, .cspeach output dirs. Prefers files
+ * likely to reflect human-authored style (ts, js, abap, cds, xml).
+ */
+async function findSampleFiles(cwd, limit) {
+    const out = [];
+    const TEXT_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.abap', '.cds', '.xml', '.yaml', '.yml'];
+    const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.cspeach', '.abapforge']);
+    async function walk(d) {
+        if (out.length >= limit)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(d, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const ent of entries) {
+            if (out.length >= limit)
+                return;
+            if (ent.isFile()) {
+                if (TEXT_EXTENSIONS.some((ext) => ent.name.endsWith(ext))) {
+                    out.push(path.join(d, ent.name));
+                }
+            }
+            else if (ent.isDirectory() && !SKIP_DIRS.has(ent.name)) {
+                await walk(path.join(d, ent.name));
+            }
+        }
+    }
+    await walk(cwd);
+    return out;
+}
+/* ── Small filesystem helper ───────────────────────────────────────── */
+async function readFileSafe(p) {
+    try {
+        return await fs.readFile(p, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}

package/dist/project-context/detect.js

@@ -0,0 +1,250 @@
+/**
+ * Project-type detection — identifies what kind of SAP/development
+ * project lives at a given directory.
+ *
+ * Detection is purely structural — it looks at files + directories,
+ * not contents (except parsing one package.json for the Fiori/CAP
+ * discrimination). The function never runs ABAP, never connects to
+ * SAP, never modifies anything. Pure read-only filesystem inspection.
+ *
+ * Priority order matters: a CAP project that happens to contain a
+ * `webapp/` directory should still classify as CAP, not Fiori. The
+ * priority below is calibrated to that case.
+ */
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+/**
+ * Detect the project type at the given working directory.
+ *
+ * Priority (first match wins):
+ *  1. `mta.yaml` at root              → mixed (multi-target application)
+ *  2. CAP Node: `package.json` with `@sap/cds` + `srv/` + `db/` dirs
+ *  3. Fiori UI5: `webapp/manifest.json` + (`ui5.yaml` OR
+ *     `package.json` with `@sap/ux-ui5-tooling`)
+ *  4. abapGit: `.abapgit.xml` at root
+ *     OR `src/` containing `*.prog.abap` / `*.clas.abap` / `*.intf.abap`
+ *  5. ABAP Cloud: same disk shape as abapGit, but with `.bdef` /
+ *     `.behaviordefinition` / `.dcl` / `.ddls` files indicating cloud
+ *     ABAP patterns
+ *  6. Anything else → `unknown`
+ *
+ * Returns null on IO errors (missing dir, permission denied, etc.) so
+ * the caller can decide whether to treat null as "no project" or "error
+ * reading project." Today's only consumer in Phase 1A treats both as
+ * "no project context" — that semantic is intentional.
+ */
+export async function detectProjectType(cwd) {
+    try {
+        const stat = await fs.stat(cwd);
+        if (!stat.isDirectory())
+            return null;
+    }
+    catch {
+        // cwd doesn't exist or isn't accessible → not a project.
+        return null;
+    }
+    // 1. Mixed (mta.yaml at root)
+    if (await fileExists(path.join(cwd, 'mta.yaml'))) {
+        return 'mixed';
+    }
+    // 2. CAP Node (checked BEFORE Fiori — a CAP project may have a webapp/
+    //    subdirectory under its `app/` folder, which would otherwise match
+    //    Fiori detection).
+    if (await isCapNode(cwd)) {
+        return 'cap-node';
+    }
+    // 3. Fiori UI5 (webapp/manifest.json + ui5.yaml or package.json with
+    //    @sap/ux-ui5-tooling)
+    if (await isFioriUi5(cwd)) {
+        return 'fiori-ui5';
+    }
+    // 4 & 5. abapGit and ABAP Cloud share the same on-disk shape
+    //    (src/*.<type>.abap). We discriminate by the presence of
+    //    cloud-specific extensions.
+    if (await isAbapDiskProject(cwd)) {
+        if (await hasAbapCloudMarkers(cwd)) {
+            return 'abap-cloud';
+        }
+        return 'abapgit';
+    }
+    // 6. Nothing matched.
+    return 'unknown';
+}
+/* ── Per-type detection helpers ─────────────────────────────────────── */
+async function isCapNode(cwd) {
+    const pkgPath = path.join(cwd, 'package.json');
+    const pkg = await readJsonSafe(pkgPath);
+    if (!pkg)
+        return false;
+    const deps = collectDeps(pkg);
+    if (!('@sap/cds' in deps))
+        return false;
+    // CAP convention: srv/ for service definitions, db/ for entity models
+    return ((await directoryExists(path.join(cwd, 'srv'))) &&
+        (await directoryExists(path.join(cwd, 'db'))));
+}
+async function isFioriUi5(cwd) {
+    // Must have webapp/manifest.json
+    if (!(await fileExists(path.join(cwd, 'webapp', 'manifest.json')))) {
+        return false;
+    }
+    // PLUS either ui5.yaml OR package.json with @sap/ux-ui5-tooling
+    if (await fileExists(path.join(cwd, 'ui5.yaml'))) {
+        return true;
+    }
+    const pkg = await readJsonSafe(path.join(cwd, 'package.json'));
+    if (pkg) {
+        const deps = collectDeps(pkg);
+        if ('@sap/ux-ui5-tooling' in deps)
+            return true;
+    }
+    return false;
+}
+/**
+ * True if a `src/` directory exists and contains at least one ABAP
+ * source file. Accepts BOTH classic abapGit naming (.prog.abap,
+ * .clas.abap, etc.) AND ABAP-Cloud-specific naming (.bdef.asbdef,
+ * .srvd.srvd, .dcls.asdcls, etc.) — a cloud-only project still
+ * qualifies as a disk-project; discrimination of cloud-vs-classic
+ * happens in the calling code via `hasAbapCloudMarkers`.
+ */
+async function isAbapDiskProject(cwd) {
+    // .abapgit.xml at root is a strong signal regardless of src/ contents.
+    if (await fileExists(path.join(cwd, '.abapgit.xml'))) {
+        return true;
+    }
+    const srcDir = path.join(cwd, 'src');
+    if (!(await directoryExists(srcDir)))
+        return false;
+    // Check both extension catalogs — a project with ONLY cloud-specific
+    // markers (.bdef, .srvd, .dcls, etc.) should still qualify as a
+    // disk-project, otherwise hasAbapCloudMarkers never gets to run.
+    const allAbapExtensions = [
+        ...ABAP_DISK_EXTENSIONS,
+        ...ABAP_CLOUD_EXTENSIONS,
+    ];
+    return await directoryContainsExtension(srcDir, allAbapExtensions, /* recursive */ true);
+}
+/**
+ * Cloud-specific markers that distinguish ABAP Cloud / RAP-on-cloud
+ * (on-disk) from a generic abapGit working copy. Behavior definitions
+ * (`.bdef.abap` / `.behaviordefinition.bdef`) and ABAP Cloud package
+ * markers are the canonical signal.
+ */
+async function hasAbapCloudMarkers(cwd) {
+    const srcDir = path.join(cwd, 'src');
+    return await directoryContainsExtension(srcDir, ABAP_CLOUD_EXTENSIONS, /* recursive */ true);
+}
+/* ── File-system primitives ─────────────────────────────────────────── */
+async function fileExists(p) {
+    try {
+        const s = await fs.stat(p);
+        return s.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function directoryExists(p) {
+    try {
+        const s = await fs.stat(p);
+        return s.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function readJsonSafe(p) {
+    try {
+        const raw = await fs.readFile(p, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Merge dependencies + devDependencies + peerDependencies into one
+ * lookup. Returns empty record if pkg is malformed.
+ */
+function collectDeps(pkg) {
+    const out = {};
+    for (const field of ['dependencies', 'devDependencies', 'peerDependencies']) {
+        const block = pkg[field];
+        if (block && typeof block === 'object') {
+            for (const [k, v] of Object.entries(block)) {
+                if (typeof v === 'string')
+                    out[k] = v;
+            }
+        }
+    }
+    return out;
+}
+/**
+ * True if any file under `dir` ends with one of the given extensions.
+ * Recursive walk; bails after first hit. Cap at 5000 dir entries
+ * checked total to prevent runaway walks on very large trees.
+ */
+async function directoryContainsExtension(dir, extensions, recursive) {
+    let budget = 5000;
+    async function walk(d) {
+        if (budget <= 0)
+            return false;
+        let entries;
+        try {
+            entries = await fs.readdir(d, { withFileTypes: true });
+        }
+        catch {
+            return false;
+        }
+        for (const ent of entries) {
+            if (budget <= 0)
+                return false;
+            budget--;
+            if (ent.isFile()) {
+                for (const ext of extensions) {
+                    if (ent.name.endsWith(ext))
+                        return true;
+                }
+            }
+            else if (recursive && ent.isDirectory()) {
+                // Skip noisy dirs that shouldn't be walked.
+                if (ent.name === 'node_modules' || ent.name === '.git')
+                    continue;
+                if (await walk(path.join(d, ent.name)))
+                    return true;
+            }
+        }
+        return false;
+    }
+    return walk(dir);
+}
+/* ── Extension catalogs ─────────────────────────────────────────────── */
+/**
+ * abapGit naming convention: <object_name>.<type>.abap and friends.
+ * Object types we accept as evidence of an ABAP working copy.
+ */
+const ABAP_DISK_EXTENSIONS = [
+    '.prog.abap', // programs (executable + module-pool)
+    '.clas.abap', // classes
+    '.intf.abap', // interfaces
+    '.fugr.abap', // function groups
+    '.tabl.xml', // tables (DDIC)
+    '.dtel.xml', // data elements
+    '.doma.xml', // domains
+    '.ddls.asddls', // CDS views (interface DDL source)
+    '.ddls.asccds', // CDS views (consumption DDL source, abapGit naming)
+];
+/**
+ * ABAP Cloud / RAP-on-disk specific markers. Presence of any of these
+ * tells us we're looking at ABAP Cloud rather than classic abapGit
+ * (even though the two share the disk layout under src/).
+ */
+const ABAP_CLOUD_EXTENSIONS = [
+    '.bdef.asbdef', // RAP behavior definition (cloud)
+    '.behaviordefinition', // alternate naming some projects use
+    '.dcls.asdcls', // CDS access control / DCL
+    '.ddlx.asddlx', // metadata extension
+    '.srvb.srvb', // service binding
+    '.srvd.srvd', // service definition
+];

package/dist/project-context/domain/abap-cloud.js

@@ -0,0 +1,26 @@
+/**
+ * ABAP Cloud / RAP-on-disk domain extractor.
+ *
+ * Builds on the abapGit walker — same on-disk shape, same filename
+ * convention, same package inference. The only delta is that ABAP Cloud
+ * projects emit RAP-specific objects (behavior definitions, service
+ * definitions, service bindings, DCL access controls, metadata
+ * extensions) that we surface as a separate concept.
+ *
+ * For Phase 1E we promote behavior definitions specifically — they're
+ * the entry point a RAP-aware skill needs to know about most often.
+ * Other RAP objects (SRVD, SRVB, DCLS, DDLX) are still surfaced through
+ * the generic objects[] list, just not called out separately.
+ */
+import { collectAbapObjects } from './abapgit.js';
+/**
+ * Walk `src/` under cwd and return the abap-cloud DomainObjectIndex
+ * variant: full object list plus the names of all behavior definitions.
+ */
+export async function extractAbapCloud(cwd) {
+    const objects = await collectAbapObjects(cwd);
+    const behaviorDefinitions = objects
+        .filter((o) => o.type === 'BDEF')
+        .map((o) => o.name);
+    return { type: 'abap-cloud', objects, behaviorDefinitions };
+}