@cspeach/cli 0.6.4 → 0.7.0

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

@@ -1,282 +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 { extractFiori } from '../domain/fiori.js';
-let root;
-beforeEach(async () => {
-    root = await fs.mkdtemp(path.join(os.tmpdir(), 'cspeach-fiori-'));
-});
-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('extractFiori — empty / missing', () => {
-    it('returns empty everything when webapp/ does not exist', async () => {
-        const result = await extractFiori(root);
-        expect(result).toEqual({
-            type: 'fiori-ui5',
-            controllers: [],
-            views: [],
-            routes: [],
-            i18nKeys: [],
-        });
-    });
-    it('returns empty arrays when webapp/ exists but is empty', async () => {
-        await fs.mkdir(path.join(root, 'webapp'));
-        const result = await extractFiori(root);
-        if (result.type !== 'fiori-ui5')
-            throw new Error('wrong variant');
-        expect(result.routes).toEqual([]);
-        expect(result.controllers).toEqual([]);
-        expect(result.views).toEqual([]);
-        expect(result.i18nKeys).toEqual([]);
-    });
-});
-describe('extractFiori — manifest.json routes', () => {
-    it('parses routes declared as an array', async () => {
-        await writeFile('webapp/manifest.json', JSON.stringify({
-            'sap.ui5': {
-                routing: {
-                    routes: [
-                        { name: 'worklist', pattern: '', target: 'worklist' },
-                        { name: 'detail', pattern: 'detail/{id}', target: ['detail'] },
-                    ],
-                },
-            },
-        }));
-        const result = await extractFiori(root);
-        if (result.type !== 'fiori-ui5')
-            throw new Error('wrong variant');
-        expect(result.routes).toEqual([
-            { name: 'worklist', pattern: '', targets: ['worklist'] },
-            { name: 'detail', pattern: 'detail/{id}', targets: ['detail'] },
-        ]);
-    });
-    it('parses routes declared as an object map (legacy form)', async () => {
-        await writeFile('webapp/manifest.json', JSON.stringify({
-            'sap.ui5': {
-                routing: {
-                    routes: {
-                        home: { pattern: '', target: 'main' },
-                    },
-                },
-            },
-        }));
-        const result = await extractFiori(root);
-        if (result.type !== 'fiori-ui5')
-            throw new Error('wrong variant');
-        expect(result.routes).toEqual([
-            { name: 'home', pattern: '', targets: ['main'] },
-        ]);
-    });
-    it('returns empty routes on malformed manifest.json (does not throw)', async () => {
-        await writeFile('webapp/manifest.json', '{ this is not JSON');
-        const result = await extractFiori(root);
-        if (result.type !== 'fiori-ui5')
-            throw new Error('wrong variant');
-        expect(result.routes).toEqual([]);
-    });
-    it('returns empty routes when manifest has no routing section', async () => {
-        await writeFile('webapp/manifest.json', JSON.stringify({ 'sap.app': { id: 'myapp' } }));
-        const result = await extractFiori(root);
-        if (result.type !== 'fiori-ui5')
-            throw new Error('wrong variant');
-        expect(result.routes).toEqual([]);
-    });
-});
-describe('extractFiori — controllers', () => {
-    it('collects controllers and extracts i18n key references', async () => {
-        await writeFile('webapp/controller/Worklist.controller.js', `sap.ui.define([], function () {
-         return Controller.extend("myapp.controller.Worklist", {
-           onInit: function () {
-             var msg = this.getResourceBundle().getText("worklistTitle");
-             var sub = this.getView().getModel("i18n").getResourceBundle().getText('worklistDescription');
-           }
-         });
-       });`);
-        const result = await extractFiori(root);
-        if (result.type !== 'fiori-ui5')
-            throw new Error('wrong variant');
-        expect(result.controllers).toHaveLength(1);
-        expect(result.controllers[0]).toMatchObject({
-            name: 'Worklist',
-            path: 'webapp/controller/Worklist.controller.js',
-        });
-        expect(result.controllers[0].i18nKeys.sort()).toEqual([
-            'worklistDescription',
-            'worklistTitle',
-        ]);
-    });
-    it('handles controllers with no i18n usage', async () => {
-        await writeFile('webapp/controller/App.controller.js', `sap.ui.define([], function () { return Controller.extend("myapp.controller.App", {}); });`);
-        const result = await extractFiori(root);
-        if (result.type !== 'fiori-ui5')
-            throw new Error('wrong variant');
-        expect(result.controllers[0].i18nKeys).toEqual([]);
-    });
-    it('skips files that are not *.controller.js', async () => {
-        await writeFile('webapp/controller/helper.js', 'export function foo() {}');
-        await writeFile('webapp/controller/Real.controller.js', `Controller.extend("myapp.controller.Real", {});`);
-        const result = await extractFiori(root);
-        if (result.type !== 'fiori-ui5')
-            throw new Error('wrong variant');
-        expect(result.controllers.map((c) => c.name)).toEqual(['Real']);
-    });
-});
-describe('extractFiori — views and cross-linking', () => {
-    it('links view → controller via controllerName attribute', async () => {
-        await writeFile('webapp/controller/Worklist.controller.js', `Controller.extend("myapp.controller.Worklist", {});`);
-        await writeFile('webapp/view/Worklist.view.xml', `<mvc:View controllerName="myapp.controller.Worklist" xmlns:mvc="sap.ui.core.mvc" />`);
-        const result = await extractFiori(root);
-        if (result.type !== 'fiori-ui5')
-            throw new Error('wrong variant');
-        expect(result.views[0].controllerPath).toBe('webapp/controller/Worklist.controller.js');
-        expect(result.controllers[0].viewPath).toBe('webapp/view/Worklist.view.xml');
-    });
-    it('falls back to basename match when controllerName attr absent', async () => {
-        await writeFile('webapp/controller/Detail.controller.js', `Controller.extend("Detail", {});`);
-        await writeFile('webapp/view/Detail.view.xml', `<mvc:View />`);
-        const result = await extractFiori(root);
-        if (result.type !== 'fiori-ui5')
-            throw new Error('wrong variant');
-        expect(result.views[0].controllerPath).toBe('webapp/controller/Detail.controller.js');
-    });
-    it('extracts model paths from `{path: ...}` and `{/...}` bindings', async () => {
-        await writeFile('webapp/view/Worklist.view.xml', `<List items="{path: '/Worklist/items'}">
-         <Text text="{/header/title}" />
-         <Text text="{i18n>welcome}" />
-       </List>`);
-        const result = await extractFiori(root);
-        if (result.type !== 'fiori-ui5')
-            throw new Error('wrong variant');
-        expect(result.views[0].boundModelPaths.sort()).toEqual([
-            '/Worklist/items',
-            '/header/title',
-        ]);
-    });
-    it('captures composite bindings (text="prefix {/name} suffix")', async () => {
-        // Common UI5 pattern: a label that mixes literal text and a binding.
-        // Earlier regex required quote/brace boundaries either side of the
-        // binding; this ruled composite bindings out. Now they're captured.
-        await writeFile('webapp/view/Greeting.view.xml', `<mvc:View>
-         <Text text="Hello {/user/name}, welcome!" />
-         <Text text="{/header/title} — {/header/subtitle}" />
-       </mvc:View>`);
-        const result = await extractFiori(root);
-        if (result.type !== 'fiori-ui5')
-            throw new Error('wrong variant');
-        expect(result.views[0].boundModelPaths.sort()).toEqual([
-            '/header/subtitle',
-            '/header/title',
-            '/user/name',
-        ]);
-    });
-    it('captures multiple bindings in a single attribute', async () => {
-        await writeFile('webapp/view/MultiBind.view.xml', `<mvc:View>
-         <Text text="{/a} and {/b} and {/c}" />
-       </mvc:View>`);
-        const result = await extractFiori(root);
-        if (result.type !== 'fiori-ui5')
-            throw new Error('wrong variant');
-        expect(result.views[0].boundModelPaths).toEqual(['/a', '/b', '/c']);
-    });
-    it('skips named-model bindings like {i18n>title} and {modelAlias>path}', async () => {
-        await writeFile('webapp/view/Aliases.view.xml', `<mvc:View>
-         <Text text="{i18n>welcomeTitle}" />
-         <Text text="{customModel>/some/path}" />
-         <Text text="{/real/path}" />
-       </mvc:View>`);
-        const result = await extractFiori(root);
-        if (result.type !== 'fiori-ui5')
-            throw new Error('wrong variant');
-        // Only the unaliased absolute path survives.
-        expect(result.views[0].boundModelPaths).toEqual(['/real/path']);
-    });
-    it('view with no matching controller has controllerPath null', async () => {
-        await writeFile('webapp/view/Orphan.view.xml', `<mvc:View />`);
-        const result = await extractFiori(root);
-        if (result.type !== 'fiori-ui5')
-            throw new Error('wrong variant');
-        expect(result.views[0].controllerPath).toBeNull();
-    });
-});
-describe('extractFiori — i18n properties', () => {
-    it('collects keys from i18n.properties', async () => {
-        await writeFile('webapp/i18n/i18n.properties', `# This is a comment
-       ! Also a comment
-       worklistTitle=My Worklist
-       worklistDescription=A description
-       blank=
-      `);
-        const result = await extractFiori(root);
-        if (result.type !== 'fiori-ui5')
-            throw new Error('wrong variant');
-        expect(result.i18nKeys.sort()).toEqual([
-            'blank',
-            'worklistDescription',
-            'worklistTitle',
-        ]);
-    });
-    it('dedupes keys across multiple .properties files', async () => {
-        await writeFile('webapp/i18n/i18n.properties', 'shared=A\nonlyEN=hi\n');
-        await writeFile('webapp/i18n/i18n_de.properties', 'shared=A\nonlyDE=hallo\n');
-        const result = await extractFiori(root);
-        if (result.type !== 'fiori-ui5')
-            throw new Error('wrong variant');
-        expect(result.i18nKeys.sort()).toEqual(['onlyDE', 'onlyEN', 'shared']);
-    });
-    it('handles colon-separated and equals-separated entries', async () => {
-        await writeFile('webapp/i18n/i18n.properties', `keyEq=value\nkeyColon : value\n`);
-        const result = await extractFiori(root);
-        if (result.type !== 'fiori-ui5')
-            throw new Error('wrong variant');
-        expect(result.i18nKeys.sort()).toEqual(['keyColon', 'keyEq']);
-    });
-});
-describe('extractFiori — realistic Worklist app fixture', () => {
-    it('cross-links a small app end-to-end', async () => {
-        await writeFile('webapp/manifest.json', JSON.stringify({
-            'sap.app': { id: 'sap.ui.demo.worklist' },
-            'sap.ui5': {
-                routing: {
-                    routes: [
-                        { name: 'worklist', pattern: '', target: 'worklist' },
-                        { name: 'object', pattern: 'Objects/{objectId}', target: 'object' },
-                    ],
-                },
-            },
-        }));
-        await writeFile('webapp/controller/Worklist.controller.js', `Controller.extend("sap.ui.demo.worklist.controller.Worklist", {
-         onInit: function () {
-           this.getResourceBundle().getText("worklistTitleCount");
-         }
-       });`);
-        await writeFile('webapp/controller/Object.controller.js', `Controller.extend("sap.ui.demo.worklist.controller.Object", {
-         onInit: function () {
-           this.getResourceBundle().getText("objectTitle");
-         }
-       });`);
-        await writeFile('webapp/view/Worklist.view.xml', `<mvc:View controllerName="sap.ui.demo.worklist.controller.Worklist" xmlns:mvc="sap.ui.core.mvc">
-         <Table items="{path: '/Objects'}" />
-       </mvc:View>`);
-        await writeFile('webapp/view/Object.view.xml', `<mvc:View controllerName="sap.ui.demo.worklist.controller.Object" />`);
-        await writeFile('webapp/i18n/i18n.properties', `worklistTitleCount=Objects ({0})\nobjectTitle=Object\n`);
-        const result = await extractFiori(root);
-        if (result.type !== 'fiori-ui5')
-            throw new Error('wrong variant');
-        expect(result.routes.map((r) => r.name).sort()).toEqual(['object', 'worklist']);
-        expect(result.controllers.map((c) => c.name).sort()).toEqual(['Object', 'Worklist']);
-        expect(result.views.map((v) => v.name).sort()).toEqual(['Object', 'Worklist']);
-        const wlController = result.controllers.find((c) => c.name === 'Worklist');
-        const wlView = result.views.find((v) => v.name === 'Worklist');
-        expect(wlController.viewPath).toBe('webapp/view/Worklist.view.xml');
-        expect(wlView.controllerPath).toBe('webapp/controller/Worklist.controller.js');
-        expect(wlView.boundModelPaths).toEqual(['/Objects']);
-        expect(result.i18nKeys.sort()).toEqual(['objectTitle', 'worklistTitleCount']);
-    });
-});

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

@@ -1,131 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { spawn } from 'node:child_process';
-import { promises as fs } from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { getGitState } from '../git.js';
-let root;
-beforeEach(async () => {
-    root = await fs.mkdtemp(path.join(os.tmpdir(), 'cspeach-git-'));
-});
-afterEach(async () => {
-    await fs.rm(root, { recursive: true, force: true });
-});
-function runGit(cwd, args) {
-    return new Promise((resolve) => {
-        let stdout = '';
-        const child = spawn('git', args, {
-            cwd,
-            windowsHide: true,
-            stdio: ['ignore', 'pipe', 'inherit'],
-        });
-        child.stdout.on('data', (c) => {
-            stdout += c.toString('utf-8');
-        });
-        child.on('close', (code) => {
-            resolve({ code: code ?? 1, stdout });
-        });
-        child.on('error', () => resolve({ code: 1, stdout }));
-    });
-}
-async function gitInit(cwd) {
-    // Use a deterministic default branch name + identity so tests don't
-    // depend on the developer's global git config.
-    await runGit(cwd, ['init', '-b', 'main']);
-    await runGit(cwd, ['config', 'user.email', 'test@cspeach.dev']);
-    await runGit(cwd, ['config', 'user.name', 'Test User']);
-    await runGit(cwd, ['config', 'commit.gpgsign', 'false']);
-}
-async function gitCommit(cwd, file, message) {
-    await fs.writeFile(path.join(cwd, file), `content for ${file}\n`, 'utf-8');
-    await runGit(cwd, ['add', file]);
-    await runGit(cwd, ['commit', '-m', message]);
-}
-describe('getGitState — non-repo', () => {
-    it('returns empty state when cwd is not a git repo', async () => {
-        const state = await getGitState(root);
-        expect(state).toEqual({
-            isRepo: false,
-            branch: null,
-            headSha: null,
-            dirtyFileCount: 0,
-            recentCommits: [],
-        });
-    });
-    it('returns empty state when cwd does not exist', async () => {
-        const state = await getGitState(path.join(root, 'nope'));
-        expect(state.isRepo).toBe(false);
-    });
-});
-describe('getGitState — clean repo', () => {
-    it('returns branch, head sha, zero dirt, recent commits', async () => {
-        await gitInit(root);
-        await gitCommit(root, 'a.txt', 'first commit');
-        await gitCommit(root, 'b.txt', 'second commit');
-        const state = await getGitState(root);
-        expect(state.isRepo).toBe(true);
-        expect(state.branch).toBe('main');
-        expect(state.headSha).toMatch(/^[0-9a-f]{40}$/);
-        expect(state.dirtyFileCount).toBe(0);
-        expect(state.recentCommits).toHaveLength(2);
-        expect(state.recentCommits[0]).toMatch(/^[0-9a-f]{7,} second commit$/);
-        expect(state.recentCommits[1]).toMatch(/^[0-9a-f]{7,} first commit$/);
-    });
-    it('caps recent commits at 5', async () => {
-        // Bumped timeout: 8 sequential git commits spawn 16+ subprocesses
-        // (init + config + add + commit per loop). Under parallel-suite
-        // load on Windows, this can exceed the default 5s timeout. Same
-        // pattern as turn-stream and index-files truncate tests.
-        await gitInit(root);
-        for (let i = 1; i <= 8; i++) {
-            await gitCommit(root, `f${i}.txt`, `commit ${i}`);
-        }
-        const state = await getGitState(root);
-        expect(state.recentCommits).toHaveLength(5);
-        // Most recent first.
-        expect(state.recentCommits[0]).toMatch(/commit 8$/);
-        expect(state.recentCommits[4]).toMatch(/commit 4$/);
-    }, 30_000);
-});
-describe('getGitState — dirty repo', () => {
-    it('counts unstaged + staged + untracked files', async () => {
-        await gitInit(root);
-        await gitCommit(root, 'tracked.txt', 'initial');
-        // Modify tracked
-        await fs.writeFile(path.join(root, 'tracked.txt'), 'modified\n', 'utf-8');
-        // Add untracked
-        await fs.writeFile(path.join(root, 'new.txt'), 'new\n', 'utf-8');
-        // Add a staged file too
-        await fs.writeFile(path.join(root, 'staged.txt'), 'staged\n', 'utf-8');
-        await runGit(root, ['add', 'staged.txt']);
-        const state = await getGitState(root);
-        expect(state.isRepo).toBe(true);
-        expect(state.dirtyFileCount).toBe(3);
-    });
-});
-describe('getGitState — detached HEAD', () => {
-    it('returns "HEAD" as branch when in detached state', async () => {
-        await gitInit(root);
-        await gitCommit(root, 'a.txt', 'first');
-        await gitCommit(root, 'b.txt', 'second');
-        // Detach to first commit's SHA
-        const log = await runGit(root, ['rev-list', '--reverse', 'HEAD']);
-        const firstSha = log.stdout.trim().split('\n')[0];
-        await runGit(root, ['checkout', '--detach', firstSha]);
-        const state = await getGitState(root);
-        expect(state.isRepo).toBe(true);
-        expect(state.branch).toBe('HEAD');
-    });
-});
-describe('getGitState — empty repo (no commits)', () => {
-    it('reports isRepo=true with null sha and empty commits', async () => {
-        await gitInit(root);
-        const state = await getGitState(root);
-        expect(state.isRepo).toBe(true);
-        // branch may be 'main' (configured default) or empty depending on git
-        // version; we don't assert on it strictly. headSha is null because
-        // HEAD doesn't resolve before the first commit.
-        expect(state.headSha).toBeNull();
-        expect(state.recentCommits).toEqual([]);
-    });
-});

package/dist/project-context/__tests__/index-files.test.js

@@ -1,195 +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 { indexFiles } from '../index-files.js';
-let root;
-beforeEach(async () => {
-    root = await fs.mkdtemp(path.join(os.tmpdir(), 'cspeach-idx-'));
-});
-afterEach(async () => {
-    // maxRetries handles Windows fs.rm ENOTEMPTY when antivirus / indexer
-    // holds a transient handle on freshly-written files. The large-N
-    // writeFile loops in this file (600+ files) hit it intermittently
-    // under parallel-suite load.
-    await fs.rm(root, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 });
-});
-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 });
-}
-describe('indexFiles — base cases', () => {
-    it('empty directory → totalFiles=0, empty paths', async () => {
-        const idx = await indexFiles(root);
-        expect(idx.totalFiles).toBe(0);
-        expect(idx.paths).toEqual([]);
-        expect(idx.byExtension).toEqual({});
-        expect(idx.truncated).toBe(false);
-    });
-    it('non-existent directory → empty index (never throws)', async () => {
-        const idx = await indexFiles(path.join(root, 'nope'));
-        expect(idx.totalFiles).toBe(0);
-        expect(idx.truncated).toBe(false);
-    });
-    it('counts files by extension', async () => {
-        await writeFile('a.ts', 'export {};');
-        await writeFile('b.ts', 'export {};');
-        await writeFile('c.abap', 'REPORT zfoo.');
-        await writeFile('readme.md', '# hi');
-        const idx = await indexFiles(root);
-        expect(idx.totalFiles).toBe(4);
-        expect(idx.byExtension['.ts']).toBe(2);
-        expect(idx.byExtension['.abap']).toBe(1);
-        expect(idx.byExtension['.md']).toBe(1);
-    });
-    it('returns top-level dirs alphabetically (skipping always-skip dirs)', async () => {
-        await makeDir('src');
-        await makeDir('docs');
-        await makeDir('node_modules');
-        await makeDir('.git');
-        const idx = await indexFiles(root);
-        expect(idx.topLevelDirs).toEqual(['docs', 'src']);
-    });
-});
-describe('indexFiles — always-skipped noise dirs', () => {
-    it('skips node_modules entirely', async () => {
-        await writeFile('node_modules/junk.ts');
-        await writeFile('src/real.ts');
-        const idx = await indexFiles(root);
-        expect(idx.totalFiles).toBe(1);
-        expect(idx.paths).toEqual(['src/real.ts']);
-    });
-    it('skips .git, dist, build, .cspeach, .abapforge', async () => {
-        await writeFile('.git/HEAD');
-        await writeFile('dist/bundle.js');
-        await writeFile('build/output.js');
-        await writeFile('.cspeach/foo.json');
-        await writeFile('.abapforge/bar.json');
-        await writeFile('src/real.ts');
-        const idx = await indexFiles(root);
-        expect(idx.totalFiles).toBe(1);
-        expect(idx.paths).toEqual(['src/real.ts']);
-    });
-});
-describe('indexFiles — .gitignore handling', () => {
-    it('honors basename patterns from .gitignore', async () => {
-        await writeFile('.gitignore', 'secrets.env\n*.log\n');
-        await writeFile('secrets.env', 'PASSWORD=foo');
-        await writeFile('app.log', 'log content');
-        await writeFile('keep.ts', 'export {};');
-        const idx = await indexFiles(root);
-        // The two ignored files should NOT appear; .gitignore itself does
-        // (it's a useful project file the agent should be aware of).
-        expect(idx.paths).toContain('keep.ts');
-        expect(idx.paths).not.toContain('secrets.env');
-        expect(idx.paths).not.toContain('app.log');
-    });
-    it('honors directory patterns ending with /', async () => {
-        await writeFile('.gitignore', 'coverage/\n');
-        await writeFile('coverage/lcov.info');
-        await writeFile('coverage/sub/data.json');
-        await writeFile('keep.ts');
-        const idx = await indexFiles(root);
-        expect(idx.paths.includes('coverage/lcov.info')).toBe(false);
-        expect(idx.paths.includes('keep.ts')).toBe(true);
-    });
-    it('ignores comments and blank lines', async () => {
-        await writeFile('.gitignore', '# comment\n\n*.tmp\n# another\n');
-        await writeFile('throwaway.tmp');
-        await writeFile('keep.ts');
-        const idx = await indexFiles(root);
-        expect(idx.paths.includes('throwaway.tmp')).toBe(false);
-        expect(idx.paths.includes('keep.ts')).toBe(true);
-    });
-    it('does not crash on patterns we don\'t support (negation, root-rooted paths)', async () => {
-        // We silently ignore lines we can't parse — the file shouldn't crash the walker.
-        await writeFile('.gitignore', '!important.txt\n/specific/path\nname\n');
-        await writeFile('important.txt');
-        await writeFile('name');
-        await writeFile('keep.ts');
-        const idx = await indexFiles(root);
-        // 'name' is a basename match → skipped.
-        // 'important.txt' negation is not supported → still indexed.
-        // '/specific/path' is silently ignored.
-        expect(idx.paths.includes('keep.ts')).toBe(true);
-        expect(idx.paths.includes('name')).toBe(false);
-        expect(idx.paths.includes('important.txt')).toBe(true);
-    });
-    it('honors .cspeachignore as well (separate file)', async () => {
-        await writeFile('.cspeachignore', 'private-notes\n');
-        await writeFile('private-notes');
-        await writeFile('keep.ts');
-        const idx = await indexFiles(root);
-        expect(idx.paths.includes('private-notes')).toBe(false);
-        expect(idx.paths.includes('keep.ts')).toBe(true);
-    });
-});
-describe('indexFiles — ranking + caps', () => {
-    it('source files rank ahead of non-source files', async () => {
-        // Write same-mtime mix; source should sort first.
-        await writeFile('a.txt', 'plain');
-        await writeFile('b.ts', 'source');
-        await writeFile('c.abap', 'source');
-        const idx = await indexFiles(root);
-        // Source files come first in paths[].
-        const tsIdx = idx.paths.indexOf('b.ts');
-        const abapIdx = idx.paths.indexOf('c.abap');
-        const txtIdx = idx.paths.indexOf('a.txt');
-        expect(tsIdx).toBeGreaterThanOrEqual(0);
-        expect(abapIdx).toBeGreaterThanOrEqual(0);
-        expect(txtIdx).toBeGreaterThanOrEqual(0);
-        expect(Math.max(tsIdx, abapIdx)).toBeLessThan(txtIdx);
-    });
-    it('truncates paths[] to 500 entries on huge projects', async () => {
-        // Write 600 source files; expect paths capped at 500 + totalFiles=600.
-        // Bumped to 60s: on Windows with antivirus active, 600 sequential
-        // writeFile calls measure at ~50-60ms each (defender scans every new
-        // file). Logic is correct; this is FS/AV-bound, not the indexer.
-        for (let i = 0; i < 600; i++) {
-            await writeFile(`src/file-${i.toString().padStart(3, '0')}.ts`);
-        }
-        const idx = await indexFiles(root);
-        expect(idx.totalFiles).toBe(600);
-        expect(idx.paths.length).toBe(500);
-        expect(idx.truncated).toBe(false); // still under 10K traversed
-    }, 60_000);
-    it('marks truncated=true when MAX_FILES_TRAVERSED exceeded', async () => {
-        // Writing 10K+ files in a test would be slow. Skip this empirically;
-        // we trust the cap via code review. Sanity: cap exists and is > 0.
-        // (A targeted unit test of the cap behavior is sufficient.)
-        // This test just confirms the field exists and is false on a small project.
-        await writeFile('one.ts');
-        const idx = await indexFiles(root);
-        expect(idx.truncated).toBe(false);
-    });
-    it('sorts by mtime within source files (most recent first)', async () => {
-        await writeFile('old.ts');
-        // Force older mtime
-        const oldPath = path.join(root, 'old.ts');
-        const past = new Date('2020-01-01').getTime();
-        await fs.utimes(oldPath, past / 1000, past / 1000);
-        await writeFile('recent.ts');
-        const idx = await indexFiles(root);
-        // recent.ts should be before old.ts within the source-files group.
-        expect(idx.paths.indexOf('recent.ts')).toBeLessThan(idx.paths.indexOf('old.ts'));
-    });
-});
-describe('indexFiles — recursive + paths', () => {
-    it('uses forward-slash paths regardless of platform', async () => {
-        await writeFile('a/b/c/deep.ts');
-        const idx = await indexFiles(root);
-        expect(idx.paths).toContain('a/b/c/deep.ts');
-    });
-    it('counts files across nested directories', async () => {
-        await writeFile('a.ts');
-        await writeFile('src/b.ts');
-        await writeFile('src/lib/c.ts');
-        await writeFile('docs/notes.md');
-        const idx = await indexFiles(root);
-        expect(idx.totalFiles).toBe(4);
-    });
-});