@cspeach/cli 0.6.0

package/dist/project-context/domain/abapgit.js

@@ -0,0 +1,177 @@
+/**
+ * abapGit domain extractor.
+ *
+ * abapGit serializes ABAP repository objects to disk under `src/`, with
+ * each object as one or more files following the pattern
+ *
+ *   <object_name>.<type>.<extension>
+ *
+ * Examples:
+ *   zhello.prog.abap        program ZHELLO
+ *   zcl_foo.clas.abap       class ZCL_FOO
+ *   zif_bar.intf.abap       interface ZIF_BAR
+ *   ztab.tabl.xml           table ZTAB
+ *   ztype.dtel.xml          data element ZTYPE
+ *   zfg.fugr.abap           function group ZFG
+ *   zi_view.ddls.asddls     CDS view ZI_VIEW
+ *
+ * The package an object belongs to is inferred from its folder. abapGit
+ * mirrors the SAP package hierarchy as nested folders under `src/`, so
+ * `src/zfi/zfi_payments/zcl_foo.clas.abap` belongs to package
+ * ZFI_PAYMENTS (the immediate parent folder name, uppercased).
+ *
+ * Discipline: filenames carry enough — we never open the files. The
+ * agent reads source on demand via Phase 3 file_read or sap_get_source.
+ */
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+/** Cap on tree entries walked. abapGit repos with > 5K objects are rare. */
+const MAX_ENTRIES = 5000;
+/**
+ * Parse an abapGit filename into name + type. Returns null when the
+ * filename doesn't follow the convention (skipped silently — many
+ * repos contain README.md, .gitignore, etc.).
+ *
+ * Matches:
+ *   <name>.<type>.<ext>      → { name: <name>.toUpperCase(), type: <type>.toUpperCase() }
+ *   special: package files like `package.devc.xml` map to type DEVC.
+ */
+export function parseAbapFilename(filename) {
+    const lower = filename.toLowerCase();
+    // Two-dot pattern: name.type.ext
+    const parts = lower.split('.');
+    if (parts.length < 3)
+        return null;
+    // Anything before the type segment is the object name; type is the
+    // second-to-last segment. abapGit object names may legitimately contain
+    // dots in unusual cases (e.g. namespace prefixes), so we join all but
+    // the last two segments back into the name.
+    const ext = parts[parts.length - 1];
+    const type = parts[parts.length - 2];
+    const namePart = parts.slice(0, parts.length - 2).join('.');
+    if (!namePart || !type || !ext)
+        return null;
+    if (!ABAPGIT_TYPES.has(type))
+        return null;
+    return { name: namePart.toUpperCase(), type: type.toUpperCase() };
+}
+/**
+ * Walk `src/` under cwd and surface all abapGit objects found. Returns
+ * the abapGit DomainObjectIndex variant. Never throws; missing src/ →
+ * empty objects array.
+ */
+export async function extractAbapGit(cwd) {
+    const objects = await collectAbapObjects(cwd);
+    return { type: 'abapgit', objects };
+}
+/**
+ * Shared walker used by abapgit + abap-cloud extractors. Walks src/,
+ * collects each file matching the abapGit convention, dedupes by
+ * (name, type) so the same object's multiple files (e.g. .clas.abap +
+ * .clas.locals_imp.abap) collapse to one entry. Exported for reuse.
+ */
+export async function collectAbapObjects(cwd) {
+    const srcDir = path.join(cwd, 'src');
+    const seen = new Map();
+    let budget = MAX_ENTRIES;
+    async function walk(dir, packageHint) {
+        if (budget <= 0)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const ent of entries) {
+            if (budget <= 0)
+                return;
+            budget--;
+            if (ent.isDirectory()) {
+                // The directory name typically IS a package in abapGit's serializer.
+                // Use this folder as the package hint for files contained directly
+                // under it; nested directories override with their own name.
+                const nextPackage = ent.name.toUpperCase();
+                await walk(path.join(dir, ent.name), nextPackage);
+            }
+            else if (ent.isFile()) {
+                const parsed = parseAbapFilename(ent.name);
+                if (!parsed)
+                    continue;
+                const key = `${parsed.name}\0${parsed.type}`;
+                if (seen.has(key))
+                    continue;
+                const relPath = path
+                    .relative(cwd, path.join(dir, ent.name))
+                    .replace(/\\/g, '/');
+                seen.set(key, {
+                    name: parsed.name,
+                    type: parsed.type,
+                    path: relPath,
+                    package: packageHint,
+                });
+            }
+        }
+    }
+    try {
+        const stat = await fs.stat(srcDir);
+        if (!stat.isDirectory())
+            return [];
+    }
+    catch {
+        return [];
+    }
+    await walk(srcDir, null);
+    // Stable order: by name then type so consumers + tests get a predictable list.
+    return [...seen.values()].sort((a, b) => {
+        if (a.name !== b.name)
+            return a.name.localeCompare(b.name);
+        return a.type.localeCompare(b.type);
+    });
+}
+/**
+ * Type segments abapGit emits as the second-to-last filename token.
+ * Lowercased here; matched against lowercased filenames. Sourced from
+ * abapGit's serializer module list — a comprehensive set covering the
+ * common object types Z/Y custom code typically produces.
+ */
+const ABAPGIT_TYPES = new Set([
+    'prog', // program
+    'clas', // class
+    'intf', // interface
+    'fugr', // function group
+    'tabl', // table (DDIC)
+    'dtel', // data element
+    'doma', // domain
+    'ttyp', // table type
+    'view', // DDIC view (classic)
+    'ddls', // CDS DDL source
+    'ddlx', // CDS metadata extension
+    'dcls', // CDS access control / DCL
+    'bdef', // RAP behavior definition
+    'srvd', // RAP service definition
+    'srvb', // RAP service binding
+    'devc', // package
+    'msag', // message class
+    'tran', // transaction
+    'xslt', // XSL transformation
+    'enho', // enhancement implementation
+    'enhs', // enhancement spot
+    'idoc', // IDoc type
+    'doct', // documentation
+    'auth', // authorization object
+    'shlp', // search help
+    'iarp', // IDoc reduction
+    'wdya', // Web Dynpro application
+    'wdyn', // Web Dynpro component
+    'sicf', // SICF service node
+    'pinf', // package interface
+    'iwsv', // OData service
+    'iwmo', // OData model
+    'sots', // OTR string short text
+    'snro', // number range object
+    'styl', // SAPscript style
+    'form', // SAPscript form
+    'fdt0', // BRFplus function
+]);

package/dist/project-context/domain/cap.js

@@ -0,0 +1,164 @@
+/**
+ * CAP (SAP Cloud Application Programming) Node domain extractor.
+ *
+ * CAP projects organize CDS sources under two folders by convention:
+ *
+ *   db/     entity definitions (the persistence model)
+ *   srv/    service definitions (what the project exposes)
+ *
+ * For Phase 1E we want a structural outline — enough for the agent to
+ * know what services + entities exist and where to find them. We do NOT
+ * pull in a full CDS parser; that's a heavy dependency for what amounts
+ * to a regex-friendly pattern set. The agent reads full file content on
+ * demand via Phase 3's file_read tool when it needs the rest.
+ *
+ * Extraction approach:
+ *
+ *   - Walk db/ and srv/ recursively, collecting `.cds` files.
+ *   - For each file, regex-scan for `entity NAME` and `service NAME`
+ *     declarations. Comments and string literals are ignored at the
+ *     basic level (single-line `//` comments are stripped before the
+ *     regex pass; deeper edge cases are left to the agent).
+ *   - Map services to their exposed entities by file co-location:
+ *     a service file's entities[] is the union of any `entity` keywords
+ *     found in the same file (e.g. via `as projection on`).
+ *   - For DB entities, the `source` field captures the underlying table
+ *     or external annotation (e.g. `@cds.persistence.exists`) when easy
+ *     to detect; otherwise null.
+ */
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+const MAX_CDS_FILES = 1000;
+const MAX_FILE_SIZE_BYTES = 1_000_000; // 1 MB; CDS files past this are unusual.
+/**
+ * Walk db/ + srv/ under cwd and return the cap-node DomainObjectIndex
+ * variant. Never throws; missing folders → empty arrays.
+ */
+export async function extractCap(cwd) {
+    const services = [];
+    const entities = [];
+    // srv/ — service definitions + their projected entities.
+    for (const file of await findCdsFiles(path.join(cwd, 'srv'))) {
+        const text = await readFileSafe(file);
+        if (text === null)
+            continue;
+        const stripped = stripLineComments(text);
+        const rel = relUnix(cwd, file);
+        const serviceNames = extractMatches(stripped, /\bservice\s+([A-Za-z_][A-Za-z0-9_.]*)/g);
+        const entityNames = extractMatches(stripped, /\bentity\s+([A-Za-z_][A-Za-z0-9_.]*)/g);
+        // A srv/ file can declare zero, one, or multiple services. The
+        // entities found in the file are projected by the service(s) in it.
+        for (const name of serviceNames) {
+            services.push({ name, path: rel, entities: [...entityNames] });
+        }
+        // srv/ files often inline-define projection entities too; surface
+        // those as entities anchored at the srv file.
+        for (const name of entityNames) {
+            entities.push({ name, path: rel, source: null });
+        }
+    }
+    // db/ — persistence-side entities.
+    for (const file of await findCdsFiles(path.join(cwd, 'db'))) {
+        const text = await readFileSafe(file);
+        if (text === null)
+            continue;
+        const stripped = stripLineComments(text);
+        const rel = relUnix(cwd, file);
+        const entityNames = extractMatches(stripped, /\bentity\s+([A-Za-z_][A-Za-z0-9_.]*)/g);
+        const persistenceExists = /@cds\.persistence\.exists/.test(stripped);
+        for (const name of entityNames) {
+            entities.push({
+                name,
+                path: rel,
+                source: persistenceExists ? 'external-table' : null,
+            });
+        }
+    }
+    // Stable order for tests + diff-friendliness.
+    services.sort(compareByNameThenPath);
+    entities.sort(compareByNameThenPath);
+    return { type: 'cap-node', services, entities };
+}
+/* ── Helpers ────────────────────────────────────────────────────────── */
+async function findCdsFiles(dir) {
+    const out = [];
+    let budget = MAX_CDS_FILES;
+    async function walk(d) {
+        if (budget <= 0)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(d, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const ent of entries) {
+            if (budget <= 0)
+                return;
+            if (ent.isDirectory()) {
+                if (ent.name === 'node_modules' || ent.name === '.git')
+                    continue;
+                await walk(path.join(d, ent.name));
+            }
+            else if (ent.isFile() && ent.name.toLowerCase().endsWith('.cds')) {
+                out.push(path.join(d, ent.name));
+                budget--;
+            }
+        }
+    }
+    try {
+        const stat = await fs.stat(dir);
+        if (!stat.isDirectory())
+            return [];
+    }
+    catch {
+        return [];
+    }
+    await walk(dir);
+    return out;
+}
+async function readFileSafe(p) {
+    try {
+        const stat = await fs.stat(p);
+        if (stat.size > MAX_FILE_SIZE_BYTES)
+            return null;
+        return await fs.readFile(p, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Remove single-line `//` comments. Block comments and CDS doc comments
+ * (`/** ... *\/`) are left alone — false positives there are rare and
+ * the regex extraction tolerates noise (it just over-matches a little).
+ */
+function stripLineComments(text) {
+    return text
+        .split('\n')
+        .map((line) => {
+        const idx = line.indexOf('//');
+        return idx === -1 ? line : line.slice(0, idx);
+    })
+        .join('\n');
+}
+function extractMatches(text, re) {
+    const out = [];
+    let m;
+    // Defensive copy — re may be reused across files within one extractor call.
+    const local = new RegExp(re.source, re.flags.includes('g') ? re.flags : `${re.flags}g`);
+    while ((m = local.exec(text)) !== null) {
+        if (m[1])
+            out.push(m[1]);
+    }
+    return [...new Set(out)];
+}
+function relUnix(cwd, abs) {
+    return path.relative(cwd, abs).replace(/\\/g, '/');
+}
+function compareByNameThenPath(a, b) {
+    if (a.name !== b.name)
+        return a.name.localeCompare(b.name);
+    return a.path.localeCompare(b.path);
+}

package/dist/project-context/domain/fiori.js

@@ -0,0 +1,326 @@
+/**
+ * Fiori UI5 domain extractor.
+ *
+ * Surfaces the structural pieces of a UI5 project: routes (from
+ * manifest.json), controllers (with linked views + i18n keys),
+ * views (with linked controllers + bound model paths), and the i18n
+ * key catalog from the .properties files.
+ *
+ * What we extract — and why this depth:
+ *
+ *   - manifest.json: parsed JSON. The agent uses routing to navigate
+ *     "where does the route 'detail' end up?" without re-reading the
+ *     manifest each turn.
+ *   - controllers (.controller.js): regex-based scan for the canonical
+ *     `getResourceBundle().getText("key")` pattern. We also do a
+ *     pragmatic extraction of `.getText('key')` so the linked-i18n
+ *     story works for projects that cache the bundle in a property.
+ *   - views (.view.xml): controllerName attribute + simple model-binding
+ *     scan (`{path: '/Worklist/items'}` plus `"{/Worklist/items}"` style).
+ *   - i18n (.properties): line-based key=value harvest with comment skip.
+ *
+ * Discipline: best-effort, no XML / JS parsers as dependencies. The
+ * model can read a controller in full via Phase 3's file_read for
+ * deep cases. We aim to give the model what it needs to navigate;
+ * we do NOT aim to type-check or fully understand UI5 sources.
+ */
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+const MAX_FILES_PER_CATEGORY = 500;
+const MAX_FILE_SIZE_BYTES = 2_000_000; // 2 MB
+/**
+ * Extract Fiori domain objects from a UI5 project rooted at `cwd`.
+ * Expects the standard `webapp/` layout. Missing webapp/ → empty
+ * arrays. Never throws.
+ */
+export async function extractFiori(cwd) {
+    const webapp = path.join(cwd, 'webapp');
+    const empty = {
+        type: 'fiori-ui5',
+        controllers: [],
+        views: [],
+        routes: [],
+        i18nKeys: [],
+    };
+    if (!(await directoryExists(webapp)))
+        return empty;
+    const [routes, controllers, viewsRaw, i18nKeys] = await Promise.all([
+        extractRoutes(webapp, cwd),
+        extractControllers(webapp, cwd),
+        extractViewsRaw(webapp, cwd),
+        extractI18nKeys(webapp),
+    ]);
+    // Resolve controllerName attribute → controller filesystem path. Where
+    // the attribute is absent, fall back to basename match
+    // (Worklist.view.xml ↔ Worklist.controller.js). Each side gets its
+    // counterpart's path when one is found.
+    const views = linkControllersAndViews(controllers, viewsRaw);
+    return { type: 'fiori-ui5', controllers, views, routes, i18nKeys };
+}
+/* ── manifest.json → routes ────────────────────────────────────────── */
+async function extractRoutes(webapp, cwd) {
+    const manifestPath = path.join(webapp, 'manifest.json');
+    const text = await readFileSafe(manifestPath);
+    if (text === null)
+        return [];
+    let manifest;
+    try {
+        manifest = JSON.parse(text);
+    }
+    catch {
+        return [];
+    }
+    void cwd; // path resolution stays inside webapp/ for routes
+    const ui5 = manifest['sap.ui5'];
+    if (!ui5 || typeof ui5 !== 'object')
+        return [];
+    const routing = ui5.routing;
+    if (!routing || typeof routing !== 'object')
+        return [];
+    const rawRoutes = routing.routes;
+    const out = [];
+    if (Array.isArray(rawRoutes)) {
+        for (const entry of rawRoutes) {
+            const route = parseRouteEntry(entry);
+            if (route)
+                out.push(route);
+        }
+    }
+    else if (rawRoutes && typeof rawRoutes === 'object') {
+        // Some apps declare routes as an object keyed by name. Coerce.
+        for (const [name, entry] of Object.entries(rawRoutes)) {
+            const route = parseRouteEntry(entry, name);
+            if (route)
+                out.push(route);
+        }
+    }
+    return out;
+}
+function parseRouteEntry(entry, fallbackName) {
+    if (!entry || typeof entry !== 'object')
+        return null;
+    const e = entry;
+    const name = typeof e.name === 'string' ? e.name : (fallbackName ?? null);
+    if (name === null)
+        return null;
+    const pattern = typeof e.pattern === 'string' ? e.pattern : '';
+    const targets = coerceTargets(e.target);
+    return { name, pattern, targets };
+}
+function coerceTargets(raw) {
+    if (typeof raw === 'string')
+        return [raw];
+    if (Array.isArray(raw))
+        return raw.filter((x) => typeof x === 'string');
+    return [];
+}
+/* ── controllers/*.controller.js ──────────────────────────────────── */
+async function extractControllers(webapp, cwd) {
+    const dir = path.join(webapp, 'controller');
+    if (!(await directoryExists(dir)))
+        return [];
+    const files = await listFiles(dir, (n) => n.toLowerCase().endsWith('.controller.js'));
+    const out = [];
+    for (const file of files.slice(0, MAX_FILES_PER_CATEGORY)) {
+        const text = await readFileSafe(file);
+        if (text === null)
+            continue;
+        const name = path.basename(file).replace(/\.controller\.js$/i, '');
+        const i18nKeys = extractI18nKeyReferences(text);
+        out.push({
+            name,
+            path: relUnix(cwd, file),
+            viewPath: null, // populated by linkControllersAndViews
+            i18nKeys,
+        });
+    }
+    return out;
+}
+function extractI18nKeyReferences(jsSource) {
+    // Match `getText("key")` and `getText('key')`. Conservative — we don't
+    // try to resolve dynamic key construction. The agent can read the
+    // controller source for the harder cases.
+    const pattern = /getText\(\s*['"]([A-Za-z0-9._-]+)['"]/g;
+    const out = new Set();
+    let m;
+    while ((m = pattern.exec(jsSource)) !== null) {
+        if (m[1])
+            out.add(m[1]);
+    }
+    return [...out].sort();
+}
+async function extractViewsRaw(webapp, cwd) {
+    const dir = path.join(webapp, 'view');
+    if (!(await directoryExists(dir)))
+        return [];
+    const files = await listFiles(dir, (n) => n.toLowerCase().endsWith('.view.xml'));
+    const out = [];
+    for (const file of files.slice(0, MAX_FILES_PER_CATEGORY)) {
+        const text = await readFileSafe(file);
+        if (text === null)
+            continue;
+        const name = path.basename(file).replace(/\.view\.xml$/i, '');
+        const controllerNameAttr = extractControllerNameAttr(text);
+        const boundModelPaths = extractBoundModelPaths(text);
+        out.push({
+            controllerNameAttr,
+            view: {
+                name,
+                path: relUnix(cwd, file),
+                controllerPath: null,
+                boundModelPaths,
+            },
+        });
+    }
+    return out;
+}
+function extractControllerNameAttr(xml) {
+    const m = /controllerName\s*=\s*"([^"]+)"/.exec(xml);
+    return m && m[1] ? m[1] : null;
+}
+function extractBoundModelPaths(xml) {
+    // Three binding forms we want to capture:
+    //   1. Object form:    items="{path: '/Worklist/items', formatter: 'fn'}"
+    //   2. Simple form:    items="{/Worklist/items}"
+    //   3. Composite/multi: text="prefix {/name} suffix"  or  text="{/a} {/b}"
+    //
+    // Form 1 needs the explicit `path:` keyword scan because the value
+    // could appear anywhere inside the object literal.
+    //
+    // Forms 2 and 3 share a single rule: any `{/...}` token inside the
+    // XML where the inner content starts with `/` (absolute path). The
+    // leading `/` requirement excludes object-form fragments (those start
+    // with `path` etc.) and named-model bindings (those contain `>`,
+    // e.g. `{i18n>title}`).
+    const out = new Set();
+    const pathExpr = /\{\s*path\s*:\s*['"]([^'"]+)['"]/g;
+    // Match `{/<absolute-path>}` anywhere — captures simple, composite,
+    // and multi-bindings inside the same attribute. The inner character
+    // class excludes braces (they delimit) and `>` (alias bindings).
+    const absoluteBinding = /\{(\/[^{}>]+)\}/g;
+    let m;
+    while ((m = pathExpr.exec(xml)) !== null) {
+        if (m[1] && !m[1].includes('>'))
+            out.add(m[1]);
+    }
+    while ((m = absoluteBinding.exec(xml)) !== null) {
+        const v = m[1];
+        if (!v)
+            continue;
+        out.add(v.trim());
+    }
+    return [...out].sort();
+}
+/* ── i18n/*.properties ────────────────────────────────────────────── */
+async function extractI18nKeys(webapp) {
+    const dir = path.join(webapp, 'i18n');
+    if (!(await directoryExists(dir)))
+        return [];
+    const files = await listFiles(dir, (n) => n.toLowerCase().endsWith('.properties'));
+    const seen = new Set();
+    for (const file of files) {
+        const text = await readFileSafe(file);
+        if (text === null)
+            continue;
+        for (const rawLine of text.split('\n')) {
+            const line = rawLine.replace(/^/, '').trim();
+            if (line.length === 0)
+                continue;
+            if (line.startsWith('#') || line.startsWith('!'))
+                continue;
+            // key=value or key:value (Java properties allow either)
+            const eq = line.indexOf('=');
+            const colon = line.indexOf(':');
+            const sep = eq === -1 ? colon : colon === -1 ? eq : Math.min(eq, colon);
+            if (sep <= 0)
+                continue;
+            const key = line.slice(0, sep).trim();
+            if (key)
+                seen.add(key);
+        }
+    }
+    return [...seen].sort();
+}
+/* ── Cross-linking ────────────────────────────────────────────────── */
+function linkControllersAndViews(controllers, rawViews) {
+    const controllerByName = new Map(controllers.map((c) => [c.name, c]));
+    const out = [];
+    for (const { view, controllerNameAttr } of rawViews) {
+        // The `controllerName` attribute uses module-form notation
+        // (e.g. "myapp.controller.Worklist"). Take the trailing segment as
+        // the controller name and try to match. Falls back to basename match
+        // when the attribute is absent.
+        let controllerName;
+        if (controllerNameAttr) {
+            controllerName = controllerNameAttr.includes('.')
+                ? controllerNameAttr.slice(controllerNameAttr.lastIndexOf('.') + 1)
+                : controllerNameAttr;
+        }
+        else {
+            controllerName = view.name;
+        }
+        const controller = controllerByName.get(controllerName) ?? null;
+        out.push({
+            ...view,
+            controllerPath: controller ? controller.path : null,
+        });
+        if (controller && !controller.viewPath) {
+            controller.viewPath = view.path;
+        }
+    }
+    return out;
+}
+/* ── Filesystem primitives ────────────────────────────────────────── */
+async function directoryExists(p) {
+    try {
+        const s = await fs.stat(p);
+        return s.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function listFiles(dir, matcher) {
+    const out = [];
+    let budget = MAX_FILES_PER_CATEGORY * 4;
+    async function walk(d) {
+        if (budget <= 0)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(d, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const ent of entries) {
+            if (budget <= 0)
+                return;
+            budget--;
+            if (ent.isDirectory()) {
+                if (ent.name === 'node_modules' || ent.name === '.git')
+                    continue;
+                await walk(path.join(d, ent.name));
+            }
+            else if (ent.isFile() && matcher(ent.name)) {
+                out.push(path.join(d, ent.name));
+            }
+        }
+    }
+    await walk(dir);
+    return out;
+}
+async function readFileSafe(p) {
+    try {
+        const stat = await fs.stat(p);
+        if (stat.size > MAX_FILE_SIZE_BYTES)
+            return null;
+        return await fs.readFile(p, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+function relUnix(cwd, abs) {
+    return path.relative(cwd, abs).replace(/\\/g, '/');
+}