@cspeach/cli 0.6.4 → 0.7.0

package/dist/doctor/__tests__/check-forge-rules.test.js

@@ -1,134 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-// ---- Mocks must be declared BEFORE the module under test is imported ----
-vi.mock('../../config/loader.js', () => ({
-    loadConfig: vi.fn(),
-}));
-vi.mock('../../sap/connection-manager.js', () => ({
-    getConnection: vi.fn(),
-}));
-// Build a re-usable AdtClient mock factory so each test can configure its own
-// per-method behaviour without accidentally sharing state.
-const makeAdtMock = () => ({
-    deleteObject: vi.fn().mockResolvedValue({ status: 200 }),
-    createObject: vi.fn().mockResolvedValue({ status: 201 }),
-    setSource: vi.fn().mockResolvedValue({ writeStatus: 200 }),
-    syntaxCheck: vi.fn().mockResolvedValue({ hasErrors: false, hasWarnings: false, messages: [] }),
-});
-let adtMock = makeAdtMock();
-vi.mock('@cspeach/sap-client', () => {
-    return {
-        AdtClient: vi.fn().mockImplementation(() => adtMock),
-        snapshots: {
-            list: vi.fn(),
-        },
-    };
-});
-import { loadConfig } from '../../config/loader.js';
-import { getConnection } from '../../sap/connection-manager.js';
-import { AdtClient, snapshots } from '@cspeach/sap-client';
-import { checkForgeRules } from '../checks/forge-rules.js';
-// Typed helpers so we can call vi mock APIs without `as any` everywhere.
-const mockLoadConfig = loadConfig;
-const mockGetConnection = getConnection;
-const mockSnapshotsList = snapshots.list;
-function mkCfg(sapAliases) {
-    const sap = {};
-    for (const a of sapAliases) {
-        sap[a] = { host: '10.0.0.1', port: 44300, client: '100', useSsl: true, sslVerify: false, username: 'DEV', authType: 'basic' };
-    }
-    return {
-        proxy_url: 'https://x',
-        default_model: 'claude-opus-4-7',
-        effort: 'xhigh',
-        telemetry: 'minimal',
-        write_mode: 'approval-gated',
-        llm: { mode: 'managed' },
-        sap,
-        classifier: { safe_mode: false },
-        ui: { rendering: 'classic' },
-    };
-}
-beforeEach(() => {
-    adtMock = makeAdtMock();
-    AdtClient.mockImplementation(() => adtMock);
-    mockGetConnection.mockResolvedValue({} /* fake SapConnection */);
-    vi.clearAllMocks();
-    // Re-apply the AdtClient mock after clearAllMocks
-    AdtClient.mockImplementation(() => adtMock);
-    mockGetConnection.mockResolvedValue({});
-});
-describe('doctor check: forge-rules', () => {
-    it('returns ok:true with skipped:undefined when Rule 7 and Rule 10 both pass', async () => {
-        mockLoadConfig.mockResolvedValue(mkCfg(['S4H_DEV']));
-        // Before write: 0 snapshots; after write: 1 snapshot
-        mockSnapshotsList
-            .mockResolvedValueOnce([]) // before setSource
-            .mockResolvedValueOnce([{ id: 'snap1' }]); // after setSource
-        const r = await checkForgeRules();
-        expect(r.ok).toBe(true);
-        expect(r.skipped).toBeUndefined();
-        expect(r.message).toContain('Rule 7');
-        expect(r.message).toContain('Rule 10');
-        expect(r.message).toContain('Z_CSPEACH_DOCTOR_PROBE');
-    });
-    it('returns ok:false, skipped:true when createObject returns 401', async () => {
-        mockLoadConfig.mockResolvedValue(mkCfg(['S4H_DEV']));
-        adtMock.createObject.mockRejectedValue(new Error('HTTP 401 Unauthorized'));
-        const r = await checkForgeRules();
-        expect(r.ok).toBe(false);
-        expect(r.skipped).toBe(true);
-        expect(r.message).toMatch(/write probe not permitted/);
-        expect(r.hint).toBeDefined();
-    });
-    it('returns ok:false, skipped:true when createObject returns 403', async () => {
-        mockLoadConfig.mockResolvedValue(mkCfg(['S4H_DEV']));
-        adtMock.createObject.mockRejectedValue(new Error('403 Forbidden — no create permission'));
-        const r = await checkForgeRules();
-        expect(r.ok).toBe(false);
-        expect(r.skipped).toBe(true);
-        expect(r.message).toMatch(/write probe not permitted/);
-    });
-    it('returns ok:false with Rule 7 message when snapshot count does not grow', async () => {
-        mockLoadConfig.mockResolvedValue(mkCfg(['S4H_DEV']));
-        // Both calls return the same list — count did not grow
-        mockSnapshotsList.mockResolvedValue([{ id: 'snap_existing' }]);
-        const r = await checkForgeRules();
-        expect(r.ok).toBe(false);
-        expect(r.skipped).toBeUndefined();
-        expect(r.message).toMatch(/Rule 7/);
-        expect(r.message).toMatch(/snapshot count did not increase/);
-    });
-    it('returns ok:false with Rule 10 message when syntax check reports errors', async () => {
-        mockLoadConfig.mockResolvedValue(mkCfg(['S4H_DEV']));
-        mockSnapshotsList
-            .mockResolvedValueOnce([])
-            .mockResolvedValueOnce([{ id: 'snap1' }]);
-        adtMock.syntaxCheck.mockResolvedValue({
-            hasErrors: true,
-            hasWarnings: false,
-            messages: [{ severity: 'E', line: 2, column: 1, text: 'Symbol not found' }],
-        });
-        const r = await checkForgeRules();
-        expect(r.ok).toBe(false);
-        expect(r.skipped).toBeUndefined();
-        expect(r.message).toMatch(/Rule 10/);
-        expect(r.message).toMatch(/Symbol not found/);
-    });
-    it('returns ok:false, skipped:true when no SAP system is configured', async () => {
-        mockLoadConfig.mockResolvedValue(mkCfg([]));
-        const r = await checkForgeRules();
-        expect(r.ok).toBe(false);
-        expect(r.skipped).toBe(true);
-        expect(r.message).toMatch(/no SAP system configured/);
-        expect(r.hint).toBeDefined();
-    });
-    it('always deletes the probe in the finally block even on Rule 7 failure', async () => {
-        mockLoadConfig.mockResolvedValue(mkCfg(['S4H_DEV']));
-        // Snapshot count does not grow → Rule 7 failure path
-        mockSnapshotsList.mockResolvedValue([{ id: 'snap_existing' }]);
-        await checkForgeRules();
-        // deleteObject is called twice: once at top cleanup, once in finally
-        expect(adtMock.deleteObject).toHaveBeenCalledWith('PROG', 'Z_CSPEACH_DOCTOR_PROBE');
-        expect(adtMock.deleteObject.mock.calls.length).toBeGreaterThanOrEqual(1);
-    });
-});

package/dist/doctor/__tests__/check-llm-mode.test.js

@@ -1,21 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-vi.mock('../../auth/api-key.js', () => ({
-    getStore: vi.fn().mockResolvedValue({ get: vi.fn().mockResolvedValue('test-key') }),
-}));
-vi.mock('../../agent/providers/factory.js', () => ({
-    createProviderForMode: vi.fn().mockReturnValue({
-        name: 'managed',
-        mode: 'managed',
-        skillSource: { describe: () => 'mock source' },
-        healthCheck: async () => ({ ok: true, message: 'healthy' }),
-    }),
-}));
-import { checkLlmMode } from '../checks/llm-mode.js';
-describe('doctor check: llm-mode', () => {
-    it('reports OK when provider healthCheck passes', async () => {
-        const cfg = { llm: { mode: 'managed' }, proxy_url: 'https://x' };
-        const r = await checkLlmMode(cfg);
-        expect(r.ok).toBe(true);
-        expect(r.message).toContain('managed');
-    });
-});

package/dist/doctor/__tests__/check-write-mode.test.js

@@ -1,34 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { checkWriteMode } from '../checks/write-mode.js';
-function mkCfg(mode) {
-    return {
-        proxy_url: 'https://x',
-        default_model: 'claude-opus-4-7',
-        effort: 'xhigh',
-        telemetry: 'minimal',
-        write_mode: mode,
-        llm: { mode: 'managed' },
-        sap: {},
-        classifier: { safe_mode: false },
-        ui: { rendering: 'classic' },
-    };
-}
-describe('doctor check: write-mode', () => {
-    it('reports approval-gated as OK', async () => {
-        const r = await checkWriteMode(mkCfg('approval-gated'));
-        expect(r.ok).toBe(true);
-        expect(r.message).toContain('approval-gated');
-    });
-    it('reports advisory-only as OK with explanatory message', async () => {
-        const r = await checkWriteMode(mkCfg('advisory-only'));
-        expect(r.ok).toBe(true);
-        expect(r.message).toContain('advisory-only');
-        expect(r.message).toMatch(/no.*write/i);
-    });
-    it('reports auto with a caution hint', async () => {
-        const r = await checkWriteMode(mkCfg('auto'));
-        expect(r.ok).toBe(true);
-        // The plan says `r.hint` — adapt if the CheckResult uses a different name (e.g. `detail`, `warning`, `note`)
-        expect(r.hint ?? r.message).toMatch(/auto/i);
-    });
-});

package/dist/project-context/__tests__/conventions.test.js

@@ -1,221 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { promises as fs } from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { readConventions } from '../conventions.js';
-let root;
-beforeEach(async () => {
-    root = await fs.mkdtemp(path.join(os.tmpdir(), 'cspeach-conv-'));
-});
-afterEach(async () => {
-    await fs.rm(root, { recursive: true, force: true });
-});
-async function writeFile(rel, content) {
-    const full = path.join(root, rel);
-    await fs.mkdir(path.dirname(full), { recursive: true });
-    await fs.writeFile(full, content, 'utf-8');
-}
-describe('readConventions — defaults', () => {
-    it('empty directory → DEFAULT_CONVENTIONS (null freeText, empty patterns, 2-space LF)', async () => {
-        const c = await readConventions(root);
-        expect(c.freeText).toBeNull();
-        expect(c.namingPatterns.classes).toEqual([]);
-        expect(c.namingPatterns.interfaces).toEqual([]);
-        expect(c.namingPatterns.cdsViews).toEqual([]);
-        expect(c.style.indentSize).toBe(2);
-        expect(c.style.indentChar).toBe('space');
-        expect(c.style.eol).toBe('lf');
-    });
-    it('non-existent directory → defaults (never throws)', async () => {
-        const c = await readConventions(path.join(root, 'does-not-exist'));
-        expect(c.freeText).toBeNull();
-    });
-});
-describe('readConventions — CLAUDE.md', () => {
-    it('reads CLAUDE.md verbatim into freeText with header', async () => {
-        await writeFile('CLAUDE.md', '# Project conventions\n\nUse the ZCL_ prefix for all classes.\n');
-        const c = await readConventions(root);
-        expect(c.freeText).toContain('## CLAUDE.md');
-        expect(c.freeText).toContain('Use the ZCL_ prefix');
-    });
-    it('handles a large CLAUDE.md without truncation at this layer', async () => {
-        const big = '# Big\n' + 'a'.repeat(5000);
-        await writeFile('CLAUDE.md', big);
-        const c = await readConventions(root);
-        expect(c.freeText?.length).toBeGreaterThan(4000);
-        // Token-budget truncation happens at the render layer, not here.
-    });
-});
-describe('readConventions — CSPEACH.md', () => {
-    it('reads CSPEACH.md as override appended after CLAUDE.md', async () => {
-        await writeFile('CLAUDE.md', 'Generic Claude conventions');
-        await writeFile('CSPEACH.md', 'CSPeach-specific overrides');
-        const c = await readConventions(root);
-        expect(c.freeText).toContain('## CLAUDE.md');
-        expect(c.freeText).toContain('Generic Claude conventions');
-        expect(c.freeText).toContain('## CSPEACH.md');
-        expect(c.freeText).toContain('CSPeach-specific overrides');
-        expect(c.freeText.indexOf('## CLAUDE.md')).toBeLessThan(c.freeText.indexOf('## CSPEACH.md'));
-    });
-    it('CSPEACH.md alone (no CLAUDE.md) still produces freeText', async () => {
-        await writeFile('CSPEACH.md', 'Solo CSPeach guidance');
-        const c = await readConventions(root);
-        expect(c.freeText).toContain('## CSPEACH.md');
-        expect(c.freeText).toContain('Solo CSPeach guidance');
-        expect(c.freeText).not.toContain('CLAUDE.md');
-    });
-});
-describe('readConventions — .cspeach/conventions.toml', () => {
-    it('parses namingPatterns from TOML', async () => {
-        await writeFile('.cspeach/conventions.toml', `
-[namingPatterns]
-classes = ["ZCL_", "Z_"]
-interfaces = ["ZIF_"]
-cdsViews = ["ZI_", "ZC_"]
-`);
-        const c = await readConventions(root);
-        expect(c.namingPatterns.classes).toEqual(['ZCL_', 'Z_']);
-        expect(c.namingPatterns.interfaces).toEqual(['ZIF_']);
-        expect(c.namingPatterns.cdsViews).toEqual(['ZI_', 'ZC_']);
-    });
-    it('parses style from TOML', async () => {
-        await writeFile('.cspeach/conventions.toml', `
-[style]
-indentSize = 4
-indentChar = "tab"
-eol = "crlf"
-`);
-        const c = await readConventions(root);
-        expect(c.style.indentSize).toBe(4);
-        expect(c.style.indentChar).toBe('tab');
-        expect(c.style.eol).toBe('crlf');
-    });
-    it('honours comments and blank lines', async () => {
-        await writeFile('.cspeach/conventions.toml', `
-# Top-level comment
-[namingPatterns]   # inline comment
-classes = ["ZCL_"]
-
-# blank line above
-interfaces = ["ZIF_"]
-`);
-        const c = await readConventions(root);
-        expect(c.namingPatterns.classes).toEqual(['ZCL_']);
-        expect(c.namingPatterns.interfaces).toEqual(['ZIF_']);
-    });
-    it('malformed TOML falls back to defaults (does not throw)', async () => {
-        await writeFile('.cspeach/conventions.toml', '!!!not a valid toml!!!');
-        const c = await readConventions(root);
-        // Defaults preserved; no exception.
-        expect(c.namingPatterns.classes).toEqual([]);
-        expect(c.style.indentSize).toBe(2);
-    });
-    it('partial TOML override leaves other fields at default', async () => {
-        await writeFile('.cspeach/conventions.toml', `
-[style]
-indentSize = 8
-`);
-        const c = await readConventions(root);
-        expect(c.style.indentSize).toBe(8);
-        // Other style fields default
-        expect(c.style.indentChar).toBe('space');
-        expect(c.style.eol).toBe('lf');
-    });
-    it('ignores unknown sections', async () => {
-        await writeFile('.cspeach/conventions.toml', `
-[unknownSection]
-foo = "bar"
-
-[namingPatterns]
-classes = ["ZCL_"]
-`);
-        const c = await readConventions(root);
-        expect(c.namingPatterns.classes).toEqual(['ZCL_']);
-    });
-    it('rejects invalid status enum values silently', async () => {
-        await writeFile('.cspeach/conventions.toml', `
-[style]
-indentChar = "purple"
-eol = "magenta"
-`);
-        const c = await readConventions(root);
-        // Invalid values rejected; falls back to defaults
-        expect(c.style.indentChar).toBe('space');
-        expect(c.style.eol).toBe('lf');
-    });
-});
-describe('readConventions — style inference from existing files', () => {
-    it('detects tab indentation from a sampled .ts file', async () => {
-        await writeFile('src/foo.ts', '\tconst x = 1;\n\tconst y = 2;\n');
-        const c = await readConventions(root);
-        expect(c.style.indentChar).toBe('tab');
-        expect(c.style.indentSize).toBe(1);
-    });
-    it('detects 4-space indentation from a sampled file', async () => {
-        await writeFile('src/foo.ts', '    const x = 1;\n    const y = 2;\n');
-        const c = await readConventions(root);
-        expect(c.style.indentChar).toBe('space');
-        expect(c.style.indentSize).toBe(4);
-    });
-    it('skips JSDoc continuation lines (` *`) when measuring indent (regression)', async () => {
-        // 2026-05-10 dogfooding finding: most CSPeach .ts files start with
-        // a /** ... */ docblock. The earlier detector saw the ` * comment`
-        // continuation as the first indented line and reported indentSize=1
-        // — which the model dutifully echoed as "1-space indent" in the
-        // first project_context turn.
-        await writeFile('src/foo.ts', [
-            '/**',
-            ' * Top-of-file docblock.',
-            ' * Continuation line with one-space indent.',
-            ' */',
-            '',
-            'export function bar() {',
-            '  const x = 1;',
-            '}',
-            '',
-        ].join('\n'));
-        const c = await readConventions(root);
-        expect(c.style.indentChar).toBe('space');
-        expect(c.style.indentSize).toBe(2);
-    });
-    it('still detects tab indent even past a docblock', async () => {
-        // Same docblock guard, but the actual code uses tabs.
-        await writeFile('src/foo.ts', [
-            '/**',
-            ' * Docblock first.',
-            ' */',
-            'export function bar() {',
-            '\treturn 42;',
-            '}',
-            '',
-        ].join('\n'));
-        const c = await readConventions(root);
-        expect(c.style.indentChar).toBe('tab');
-        expect(c.style.indentSize).toBe(1);
-    });
-    it('detects CRLF line endings', async () => {
-        await writeFile('src/foo.ts', 'const x = 1;\r\nconst y = 2;\r\n');
-        const c = await readConventions(root);
-        expect(c.style.eol).toBe('crlf');
-    });
-    it('skips node_modules + .git for inference', async () => {
-        // Only files in noisy dirs → no inference, defaults retained.
-        await writeFile('node_modules/junk.ts', '\tjunk();\n');
-        await writeFile('.git/HEAD', 'ref: refs/heads/main\r\n');
-        const c = await readConventions(root);
-        expect(c.style.indentChar).toBe('space');
-        expect(c.style.indentSize).toBe(2);
-    });
-    it('TOML overrides win over inferred style', async () => {
-        // File suggests tabs, TOML says 4-space.
-        await writeFile('src/foo.ts', '\tjunk();\n');
-        await writeFile('.cspeach/conventions.toml', `
-[style]
-indentSize = 4
-indentChar = "space"
-`);
-        const c = await readConventions(root);
-        expect(c.style.indentChar).toBe('space');
-        expect(c.style.indentSize).toBe(4);
-    });
-});

package/dist/project-context/__tests__/detect.test.js

@@ -1,177 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { promises as fs } from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { detectProjectType } from '../detect.js';
-/**
- * Detection tests use real temp directories with synthetic file layouts.
- * Each test builds the layout, runs detection, asserts the type, cleans up.
- *
- * Pure read-only filesystem inspection — no SAP, no mocking required.
- */
-let root;
-beforeEach(async () => {
-    root = await fs.mkdtemp(path.join(os.tmpdir(), 'cspeach-detect-'));
-});
-afterEach(async () => {
-    await fs.rm(root, { recursive: true, force: true });
-});
-/* ── Helpers ───────────────────────────────────────────────────────── */
-async function writeFile(rel, content) {
-    const full = path.join(root, rel);
-    await fs.mkdir(path.dirname(full), { recursive: true });
-    await fs.writeFile(full, content, 'utf-8');
-}
-async function makeDir(rel) {
-    await fs.mkdir(path.join(root, rel), { recursive: true });
-}
-/* ── Tests ─────────────────────────────────────────────────────────── */
-describe('detectProjectType — base cases', () => {
-    it('empty directory → unknown', async () => {
-        expect(await detectProjectType(root)).toBe('unknown');
-    });
-    it('non-existent directory → null', async () => {
-        expect(await detectProjectType(path.join(root, 'nope'))).toBeNull();
-    });
-    it('file (not directory) → null', async () => {
-        await writeFile('a-file.txt', 'hi');
-        expect(await detectProjectType(path.join(root, 'a-file.txt'))).toBeNull();
-    });
-    it('garbage path → null (never throws)', async () => {
-        await expect(detectProjectType('\0\0\0')).resolves.toBeNull();
-    });
-});
-describe('detectProjectType — mixed (mta.yaml)', () => {
-    it('mta.yaml at root → mixed', async () => {
-        await writeFile('mta.yaml', 'ID: my-app\nversion: 1.0.0\n');
-        expect(await detectProjectType(root)).toBe('mixed');
-    });
-    it('mta.yaml beats any other signal (mixed has highest priority)', async () => {
-        await writeFile('mta.yaml', 'ID: my-app\n');
-        // Even if Fiori signals are also present:
-        await writeFile('webapp/manifest.json', '{}');
-        await writeFile('ui5.yaml', 'specVersion: "3.0"\n');
-        expect(await detectProjectType(root)).toBe('mixed');
-    });
-});
-describe('detectProjectType — CAP Node', () => {
-    it('package.json with @sap/cds + srv/ + db/ → cap-node', async () => {
-        await writeFile('package.json', JSON.stringify({ dependencies: { '@sap/cds': '^7.0.0' } }));
-        await makeDir('srv');
-        await makeDir('db');
-        expect(await detectProjectType(root)).toBe('cap-node');
-    });
-    it('@sap/cds in devDependencies also counts', async () => {
-        await writeFile('package.json', JSON.stringify({ devDependencies: { '@sap/cds': '^7.0.0' } }));
-        await makeDir('srv');
-        await makeDir('db');
-        expect(await detectProjectType(root)).toBe('cap-node');
-    });
-    it('@sap/cds without srv/ or db/ → not CAP', async () => {
-        await writeFile('package.json', JSON.stringify({ dependencies: { '@sap/cds': '^7.0.0' } }));
-        // Only db/, no srv/
-        await makeDir('db');
-        expect(await detectProjectType(root)).toBe('unknown');
-    });
-    it('CAP detection wins over a webapp/ subdir (priority order)', async () => {
-        await writeFile('package.json', JSON.stringify({ dependencies: { '@sap/cds': '^7.0.0' } }));
-        await makeDir('srv');
-        await makeDir('db');
-        // Also add a Fiori-shaped subdir — CAP wins.
-        await writeFile('app/myapp/webapp/manifest.json', '{}');
-        expect(await detectProjectType(root)).toBe('cap-node');
-    });
-});
-describe('detectProjectType — Fiori UI5', () => {
-    it('webapp/manifest.json + ui5.yaml → fiori-ui5', async () => {
-        await writeFile('webapp/manifest.json', '{}');
-        await writeFile('ui5.yaml', 'specVersion: "3.0"\n');
-        expect(await detectProjectType(root)).toBe('fiori-ui5');
-    });
-    it('webapp/manifest.json + package.json with @sap/ux-ui5-tooling → fiori-ui5', async () => {
-        await writeFile('webapp/manifest.json', '{}');
-        await writeFile('package.json', JSON.stringify({ devDependencies: { '@sap/ux-ui5-tooling': '^1.0.0' } }));
-        expect(await detectProjectType(root)).toBe('fiori-ui5');
-    });
-    it('webapp/manifest.json alone (no ui5.yaml, no Fiori dep) → unknown', async () => {
-        await writeFile('webapp/manifest.json', '{}');
-        expect(await detectProjectType(root)).toBe('unknown');
-    });
-    it('ui5.yaml without webapp/manifest.json → unknown', async () => {
-        await writeFile('ui5.yaml', 'specVersion: "3.0"\n');
-        expect(await detectProjectType(root)).toBe('unknown');
-    });
-});
-describe('detectProjectType — abapGit', () => {
-    it('.abapgit.xml at root → abapgit', async () => {
-        await writeFile('.abapgit.xml', '<?xml version="1.0" encoding="utf-8"?><abapGit></abapGit>');
-        expect(await detectProjectType(root)).toBe('abapgit');
-    });
-    it('src/*.prog.abap without .abapgit.xml → abapgit', async () => {
-        await writeFile('src/zhello.prog.abap', 'REPORT zhello.');
-        expect(await detectProjectType(root)).toBe('abapgit');
-    });
-    it('src/*.clas.abap → abapgit', async () => {
-        await writeFile('src/zcl_foo.clas.abap', 'CLASS zcl_foo DEFINITION. ENDCLASS.');
-        expect(await detectProjectType(root)).toBe('abapgit');
-    });
-    it('src/ with non-abap files only → unknown', async () => {
-        await writeFile('src/something.js', 'console.log("hi");');
-        expect(await detectProjectType(root)).toBe('unknown');
-    });
-    it('classic ABAP files in nested package dir → abapgit (recursive walk)', async () => {
-        await writeFile('src/zpkg_subdir/sub2/zhello.prog.abap', 'REPORT zhello.');
-        expect(await detectProjectType(root)).toBe('abapgit');
-    });
-});
-describe('detectProjectType — ABAP Cloud', () => {
-    it('src/ with .bdef behavior definition → abap-cloud', async () => {
-        await writeFile('src/zr_payments.bdef.asbdef', 'managed implementation ...');
-        expect(await detectProjectType(root)).toBe('abap-cloud');
-    });
-    it('src/ with .srvd service definition → abap-cloud', async () => {
-        await writeFile('src/zsd_payments.srvd.srvd', 'define service ...');
-        expect(await detectProjectType(root)).toBe('abap-cloud');
-    });
-    it('src/ with .dcls access control → abap-cloud', async () => {
-        await writeFile('src/zi_payments.dcls.asdcls', 'define role ...');
-        expect(await detectProjectType(root)).toBe('abap-cloud');
-    });
-    it('mixed cloud + classic ABAP files → abap-cloud (cloud markers win)', async () => {
-        await writeFile('src/zhello.prog.abap', 'REPORT zhello.');
-        await writeFile('src/zr_root.bdef.asbdef', 'managed implementation ...');
-        expect(await detectProjectType(root)).toBe('abap-cloud');
-    });
-    it('.abapgit.xml present + cloud markers → abap-cloud (cloud markers still win)', async () => {
-        // abapGit working copies of cloud projects exist — the cloud marker
-        // signals the project's character regardless of abapGit packaging.
-        await writeFile('.abapgit.xml', '<abapGit/>');
-        await writeFile('src/zr_root.bdef.asbdef', 'managed implementation ...');
-        expect(await detectProjectType(root)).toBe('abap-cloud');
-    });
-});
-describe('detectProjectType — priority + edge cases', () => {
-    it('mta.yaml + CAP signals + Fiori signals → mixed (highest priority wins)', async () => {
-        await writeFile('mta.yaml', 'ID: x\n');
-        await writeFile('package.json', JSON.stringify({ dependencies: { '@sap/cds': '^7.0.0' } }));
-        await makeDir('srv');
-        await makeDir('db');
-        await writeFile('webapp/manifest.json', '{}');
-        expect(await detectProjectType(root)).toBe('mixed');
-    });
-    it('Fiori signals + abapGit signals → fiori-ui5 (Fiori has higher priority)', async () => {
-        await writeFile('webapp/manifest.json', '{}');
-        await writeFile('ui5.yaml', 'specVersion: "3.0"\n');
-        await writeFile('.abapgit.xml', '<abapGit/>');
-        expect(await detectProjectType(root)).toBe('fiori-ui5');
-    });
-    it('package.json without any SAP deps → not CAP / not Fiori', async () => {
-        await writeFile('package.json', JSON.stringify({ dependencies: { react: '^18.0.0' } }));
-        expect(await detectProjectType(root)).toBe('unknown');
-    });
-    it('malformed package.json does not crash detection', async () => {
-        await writeFile('package.json', '{ this is not valid json');
-        // Should still return unknown gracefully.
-        expect(await detectProjectType(root)).toBe('unknown');
-    });
-});