@parallel-cli/parallel 0.4.8 → 0.5.0

package/dist/project-context.js

@@ -0,0 +1,477 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { redactPersistedText, sanitizeForPersistence, writeFileAtomicPrivate } from './security.js';
+const SCHEMA_VERSION = 1;
+const MAX_CONTEXT_CHARS = 12_000;
+const MAX_SEED_CHARS = 28_000;
+const IGNORED = new Set([
+    '.git',
+    '.parallel',
+    '.cursor',
+    'node_modules',
+    'dist',
+    'build',
+    'coverage',
+    '.next',
+    '__pycache__',
+    '.venv',
+    'venv',
+]);
+const SEED_FILES = [
+    'AGENTS.md',
+    'README.md',
+    'CHANGELOG.md',
+    'package.json',
+    'pyproject.toml',
+    'Cargo.toml',
+    'go.mod',
+    'Makefile',
+    'tsconfig.json',
+];
+function ignoredName(name) {
+    const lower = name.toLowerCase();
+    return (IGNORED.has(name) ||
+        lower === '.env' ||
+        lower.startsWith('.env.') ||
+        /(^|[._-])(secret|secrets|credential|credentials|private-key|id_rsa)([._-]|$)/.test(lower));
+}
+function hashText(content) {
+    return crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
+}
+function safeJsonObject(text) {
+    const trimmed = text.trim().replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '');
+    try {
+        const parsed = JSON.parse(trimmed);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function stringArray(value, max) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((item) => String(item ?? '').replace(/\s+/g, ' ').trim())
+        .filter(Boolean)
+        .slice(0, max);
+}
+function safeRelativePath(value) {
+    const rel = String(value ?? '').replace(/\\/g, '/').replace(/^\.\/+/, '');
+    if (!rel || path.isAbsolute(rel) || rel === '..' || rel.startsWith('../'))
+        return null;
+    return rel;
+}
+function contextFiles(value) {
+    if (!Array.isArray(value))
+        return [];
+    const files = [];
+    for (const item of value.slice(-200)) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const raw = item;
+        const filePath = safeRelativePath(raw.path);
+        const hash = String(raw.hash ?? '');
+        if (!filePath || !/^[a-f0-9]{16}$/.test(hash))
+            continue;
+        files.push({ path: filePath, hash, inspectedAt: String(raw.inspectedAt ?? '') });
+    }
+    return files;
+}
+function contextWork(value) {
+    if (!Array.isArray(value))
+        return [];
+    const work = [];
+    for (const item of value.slice(-20)) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const raw = item;
+        const task = String(raw.task ?? '').trim();
+        const result = String(raw.result ?? '').trim();
+        if (!task || !result)
+            continue;
+        work.push({
+            agentName: String(raw.agentName ?? 'agent').slice(0, 80),
+            task: task.slice(0, 2_000),
+            result: result.slice(0, 5_000),
+            inspectedFiles: stringArray(raw.inspectedFiles, 100).flatMap((file) => {
+                const safe = safeRelativePath(file);
+                return safe ? [safe] : [];
+            }),
+            changedFiles: stringArray(raw.changedFiles, 100).flatMap((file) => {
+                const safe = safeRelativePath(file);
+                return safe ? [safe] : [];
+            }),
+            completedAt: String(raw.completedAt ?? ''),
+        });
+    }
+    return work;
+}
+export class ProjectContextStore {
+    projectRoot;
+    onStatus;
+    data = null;
+    status = 'idle';
+    generation = null;
+    refreshTimer = null;
+    inspectedByAgent = new Map();
+    error;
+    constructor(projectRoot, onStatus) {
+        this.projectRoot = projectRoot;
+        this.onStatus = onStatus;
+        this.data = this.load();
+        if (this.data)
+            this.status = this.data.fingerprint === this.fingerprint() ? 'ready' : 'idle';
+    }
+    file() {
+        return path.join(this.projectRoot, '.parallel', 'project-context.json');
+    }
+    load() {
+        try {
+            const raw = JSON.parse(fs.readFileSync(this.file(), 'utf8'));
+            if (raw.schemaVersion !== SCHEMA_VERSION || raw.projectRoot !== this.projectRoot)
+                return null;
+            if (typeof raw.architecture !== 'string' || typeof raw.fingerprint !== 'string')
+                return null;
+            return {
+                schemaVersion: SCHEMA_VERSION,
+                generatedAt: String(raw.generatedAt ?? ''),
+                projectRoot: this.projectRoot,
+                gitHead: String(raw.gitHead ?? ''),
+                fingerprint: raw.fingerprint,
+                model: raw.model,
+                architecture: raw.architecture,
+                entryPoints: stringArray(raw.entryPoints, 20),
+                conventions: stringArray(raw.conventions, 20),
+                pitfalls: stringArray(raw.pitfalls, 20),
+                files: contextFiles(raw.files),
+                recentWork: contextWork(raw.recentWork),
+                deterministicSeed: String(raw.deterministicSeed ?? ''),
+                tokensIn: Number(raw.tokensIn ?? 0),
+                tokensOut: Number(raw.tokensOut ?? 0),
+                cost: raw.cost === null ? null : Number(raw.cost ?? 0),
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    persist() {
+        if (!this.data)
+            return;
+        writeFileAtomicPrivate(this.file(), sanitizeForPersistence(JSON.stringify(this.data, null, 2)));
+    }
+    gitHead() {
+        try {
+            return String(execFileSync('git', ['rev-parse', 'HEAD'], { cwd: this.projectRoot, stdio: 'pipe' })).trim();
+        }
+        catch {
+            return '';
+        }
+    }
+    fingerprint() {
+        let worktree = '';
+        try {
+            worktree = String(execFileSync('git', ['diff', '--no-ext-diff', '--binary', '--', '.'], {
+                cwd: this.projectRoot,
+                stdio: 'pipe',
+                maxBuffer: 4 * 1024 * 1024,
+            }));
+        }
+        catch { }
+        const untrackedBits = [];
+        try {
+            const files = String(execFileSync('git', ['ls-files', '--others', '--exclude-standard'], {
+                cwd: this.projectRoot,
+                stdio: 'pipe',
+            }))
+                .split('\n')
+                .filter(Boolean)
+                .filter((rel) => !rel.split('/').some(ignoredName))
+                .slice(0, 100);
+            for (const rel of files) {
+                try {
+                    const content = fs.readFileSync(path.join(this.projectRoot, rel));
+                    untrackedBits.push(`${rel}:${hashText(content.subarray(0, 200_000).toString('binary'))}`);
+                }
+                catch { }
+            }
+        }
+        catch { }
+        const manifestBits = [];
+        for (const rel of SEED_FILES) {
+            try {
+                const content = fs.readFileSync(path.join(this.projectRoot, rel), 'utf8');
+                manifestBits.push(`${rel}:${hashText(content)}`);
+            }
+            catch { }
+        }
+        return hashText([this.gitHead(), worktree, ...untrackedBits, ...manifestBits].join('\n'));
+    }
+    projectTree() {
+        const out = [];
+        const walk = (dir, depth) => {
+            if (depth > 5 || out.length >= 400)
+                return;
+            let entries;
+            try {
+                entries = fs.readdirSync(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+                if (ignoredName(entry.name) || entry.name.startsWith('.git'))
+                    continue;
+                const full = path.join(dir, entry.name);
+                const rel = path.relative(this.projectRoot, full);
+                if (entry.isDirectory()) {
+                    out.push(`${rel}/`);
+                    walk(full, depth + 1);
+                }
+                else if (entry.isFile()) {
+                    out.push(rel);
+                }
+                if (out.length >= 400)
+                    break;
+            }
+        };
+        walk(this.projectRoot, 0);
+        return out;
+    }
+    deterministicSeed() {
+        const sections = [
+            `PROJECT ROOT\n${this.projectRoot}`,
+            `GIT HEAD\n${this.gitHead() || '(not a git repository)'}`,
+            `PROJECT TREE\n${this.projectTree().join('\n')}`,
+        ];
+        for (const rel of SEED_FILES) {
+            try {
+                const content = fs.readFileSync(path.join(this.projectRoot, rel), 'utf8').slice(0, 8_000);
+                sections.push(`${rel}\n${redactPersistedText(content)}`);
+            }
+            catch { }
+        }
+        try {
+            const memory = fs.readFileSync(path.join(this.projectRoot, '.parallel', 'memory.md'), 'utf8').slice(-8_000);
+            sections.push(`DURABLE USER/AGENT FACTS\n${redactPersistedText(memory)}`);
+        }
+        catch { }
+        if (this.data?.recentWork.length) {
+            sections.push(`RECENT WORK\n${redactPersistedText(this.data.recentWork
+                .slice(-10)
+                .map((work) => `${work.agentName}: ${work.task}\n${work.result}\nfiles: ${[...work.inspectedFiles, ...work.changedFiles].join(', ')}`)
+                .join('\n\n'))}`);
+        }
+        return sections.join('\n\n---\n\n').slice(0, MAX_SEED_CHARS);
+    }
+    statusSnapshot() {
+        return {
+            status: this.status,
+            generatedAt: this.data?.generatedAt,
+            fingerprint: this.data?.fingerprint ?? this.fingerprint(),
+            model: this.data?.model,
+            tokensIn: this.data?.tokensIn ?? 0,
+            tokensOut: this.data?.tokensOut ?? 0,
+            cost: this.data?.cost ?? null,
+            error: this.error,
+        };
+    }
+    recordInspection(agentId, relPath, content) {
+        const normalized = relPath.replace(/\\/g, '/');
+        let files = this.inspectedByAgent.get(agentId);
+        if (!files) {
+            files = new Map();
+            this.inspectedByAgent.set(agentId, files);
+        }
+        files.set(normalized, {
+            path: normalized,
+            hash: hashText(content),
+            inspectedAt: new Date().toISOString(),
+        });
+    }
+    inspectedFiles(agentId) {
+        return [...(this.inspectedByAgent.get(agentId)?.keys() ?? [])].sort();
+    }
+    recordOutcome(agentId, work) {
+        const inspected = [...(this.inspectedByAgent.get(agentId)?.values() ?? [])];
+        const base = this.data ?? this.fallbackData();
+        const byPath = new Map(base.files.map((file) => [file.path, file]));
+        for (const file of inspected)
+            byPath.set(file.path, file);
+        base.files = [...byPath.values()].slice(-200);
+        base.recentWork = [
+            ...base.recentWork,
+            {
+                ...work,
+                inspectedFiles: inspected.map((file) => file.path),
+                completedAt: new Date().toISOString(),
+            },
+        ].slice(-20);
+        base.fingerprint = this.fingerprint();
+        base.gitHead = this.gitHead();
+        base.generatedAt = new Date().toISOString();
+        base.deterministicSeed = this.deterministicSeed();
+        this.data = base;
+        this.persist();
+    }
+    fallbackData() {
+        const seed = this.deterministicSeed();
+        return {
+            schemaVersion: SCHEMA_VERSION,
+            generatedAt: new Date().toISOString(),
+            projectRoot: this.projectRoot,
+            gitHead: this.gitHead(),
+            fingerprint: this.fingerprint(),
+            architecture: 'No validated architecture summary is available yet. Use the project tree and targeted file reads.',
+            entryPoints: [],
+            conventions: [],
+            pitfalls: [],
+            files: this.data?.files ?? [],
+            recentWork: this.data?.recentWork ?? [],
+            deterministicSeed: seed,
+            tokensIn: 0,
+            tokensOut: 0,
+            cost: null,
+        };
+    }
+    async refresh(generator, force = false) {
+        const currentFingerprint = this.fingerprint();
+        if (!force && this.data?.fingerprint === currentFingerprint && this.status === 'ready')
+            return this.data;
+        if (this.generation)
+            return this.generation;
+        this.status = 'indexing';
+        this.error = undefined;
+        this.onStatus?.('indexing');
+        this.generation = (async () => {
+            const seed = this.deterministicSeed();
+            if (!generator) {
+                this.data = this.fallbackData();
+                this.status = 'fallback';
+                this.onStatus?.('fallback');
+                this.persist();
+                return this.data;
+            }
+            try {
+                const response = await generator([
+                    {
+                        role: 'system',
+                        content: 'Build a compact, factual software-project map. Return ONLY JSON with keys architecture (string), entryPoints (string[]), conventions (string[]), pitfalls (string[]). Do not include secrets, credentials, prose outside JSON, or guesses not grounded in the supplied repository seed.',
+                    },
+                    { role: 'user', content: seed },
+                ]);
+                const parsed = safeJsonObject(response.content);
+                if (!parsed || typeof parsed.architecture !== 'string')
+                    throw new Error('invalid project-context JSON');
+                this.data = {
+                    schemaVersion: SCHEMA_VERSION,
+                    generatedAt: new Date().toISOString(),
+                    projectRoot: this.projectRoot,
+                    gitHead: this.gitHead(),
+                    fingerprint: this.fingerprint(),
+                    model: response.model,
+                    architecture: parsed.architecture.slice(0, 5_000),
+                    entryPoints: stringArray(parsed.entryPoints, 20),
+                    conventions: stringArray(parsed.conventions, 20),
+                    pitfalls: stringArray(parsed.pitfalls, 20),
+                    files: this.data?.files ?? [],
+                    recentWork: this.data?.recentWork ?? [],
+                    deterministicSeed: seed,
+                    tokensIn: response.tokensIn,
+                    tokensOut: response.tokensOut,
+                    cost: response.cost,
+                };
+                this.status = 'ready';
+                this.onStatus?.('ready');
+                this.persist();
+                return this.data;
+            }
+            catch (error) {
+                this.error = String(error?.message ?? error).slice(0, 200);
+                this.data = this.fallbackData();
+                this.status = 'fallback';
+                this.onStatus?.('fallback', this.error);
+                this.persist();
+                return this.data;
+            }
+            finally {
+                this.generation = null;
+            }
+        })();
+        return this.generation;
+    }
+    scheduleRefresh(generator) {
+        if (this.refreshTimer)
+            clearTimeout(this.refreshTimer);
+        this.refreshTimer = setTimeout(() => {
+            this.refreshTimer = null;
+            void this.refresh(generator, true);
+        }, 750);
+        this.refreshTimer.unref?.();
+    }
+    async bootstrap(generator, timeoutMs = 20_000) {
+        const refresh = this.refresh(generator);
+        let timer;
+        try {
+            const data = await Promise.race([
+                refresh,
+                new Promise((resolve) => {
+                    timer = setTimeout(() => resolve(this.data ?? this.fallbackData()), timeoutMs);
+                }),
+            ]);
+            return this.format(data);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    snapshot() {
+        return this.format();
+    }
+    format(data = this.data ?? this.fallbackData()) {
+        const currentFingerprint = this.fingerprint();
+        const stale = data.fingerprint !== currentFingerprint;
+        const knownFiles = data.files
+            .slice(-80)
+            .map((file) => {
+            try {
+                const current = hashText(fs.readFileSync(path.join(this.projectRoot, file.path), 'utf8'));
+                return `- ${file.path} [${current === file.hash ? 'fresh' : 'STALE: re-read before relying on it'}]`;
+            }
+            catch {
+                return `- ${file.path} [missing or unreadable]`;
+            }
+        })
+            .join('\n');
+        const recent = data.recentWork
+            .slice(-8)
+            .map((work) => `- ${work.agentName}: ${work.task}\n  result: ${work.result.slice(0, 800)}\n  inspected: ${work.inspectedFiles.join(', ') || '(none)'}\n  changed: ${work.changedFiles.join(', ') || '(none)'}`)
+            .join('\n');
+        return `PROJECT CONTEXT v${data.schemaVersion}
+Generated: ${data.generatedAt}
+Freshness: ${stale ? 'STALE globally — verify task-relevant files' : 'current project fingerprint'}
+Architecture:
+${data.architecture}
+
+Entry points:
+${data.entryPoints.map((item) => `- ${item}`).join('\n') || '- unknown'}
+
+Conventions:
+${data.conventions.map((item) => `- ${item}`).join('\n') || '- none recorded'}
+
+Pitfalls:
+${data.pitfalls.map((item) => `- ${item}`).join('\n') || '- none recorded'}
+
+Known inspected files:
+${knownFiles || '- none recorded'}
+
+Recent completed work:
+${recent || '- none recorded'}
+
+Use this map to orient yourself. Do not perform a generic repository exploration when it already answers the architecture question. Re-read only task-relevant files that are unknown, stale, or about to be modified.`.slice(0, MAX_CONTEXT_CHARS);
+    }
+}

package/dist/project-index.js

@@ -0,0 +1,186 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { writeFileAtomicPrivate } from './security.js';
+const INDEX_VERSION = 1;
+const IGNORED = new Set(['.git', '.parallel', '.cursor', 'node_modules', 'dist', 'build', 'coverage', '.next']);
+const TEXT_EXTENSIONS = new Set([
+    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.json', '.md', '.py', '.rs', '.go', '.java', '.kt', '.sh', '.yaml', '.yml', '.toml',
+]);
+function hash(content) {
+    return crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
+}
+function safeTextFile(name, size) {
+    const lower = name.toLowerCase();
+    const sensitive = lower === '.env' || lower.startsWith('.env.') || /(^|[._-])(secret|credential|private-key|id_rsa)([._-]|$)/.test(lower);
+    return !sensitive && size <= 750_000 && TEXT_EXTENSIONS.has(path.extname(name).toLowerCase());
+}
+function symbolsOf(content) {
+    const out = [];
+    const patterns = [
+        { kind: 'class', re: /\bclass\s+([A-Za-z_$][\w$]*)/g },
+        { kind: 'function', re: /\b(?:async\s+)?function\s+([A-Za-z_$][\w$]*)/g },
+        { kind: 'type', re: /\b(?:interface|type|enum)\s+([A-Za-z_$][\w$]*)/g },
+        { kind: 'export', re: /\bexport\s+(?:const|let|var)\s+([A-Za-z_$][\w$]*)/g },
+        { kind: 'method', re: /(?:^|[;{}]\s*)(?:private\s+|public\s+|protected\s+|static\s+|async\s+)*([A-Za-z_$][\w$]*)\s*\([^)]*\)\s*[:{]/gm },
+    ];
+    for (const { kind, re } of patterns) {
+        for (const match of content.matchAll(re)) {
+            const index = match.index ?? 0;
+            out.push({ name: match[1], line: content.slice(0, index).split('\n').length, kind });
+            if (out.length >= 200)
+                return out;
+        }
+    }
+    return out;
+}
+function importsOf(content) {
+    const imports = new Set();
+    for (const match of content.matchAll(/\b(?:from\s+|import\s*\(|require\s*\()\s*['"]([^'"]+)['"]/g))
+        imports.add(match[1]);
+    return [...imports].slice(0, 100);
+}
+function termsOf(content, relPath) {
+    const terms = new Set();
+    const source = `${relPath} ${content.slice(0, 250_000)}`;
+    for (const term of source.match(/[A-Za-z_$][A-Za-z0-9_$-]{2,}/g) ?? []) {
+        if (term.length <= 40)
+            terms.add(term.toLowerCase());
+        if (terms.size >= 2_000)
+            break;
+    }
+    return [...terms];
+}
+export class ProjectIndex {
+    projectRoot;
+    data = { version: INDEX_VERSION, generatedAt: '', files: [] };
+    constructor(projectRoot) {
+        this.projectRoot = projectRoot;
+        this.load();
+    }
+    file() {
+        return path.join(this.projectRoot, '.parallel', 'index', 'manifest.json');
+    }
+    load() {
+        try {
+            const raw = JSON.parse(fs.readFileSync(this.file(), 'utf8'));
+            if (raw.version === INDEX_VERSION && Array.isArray(raw.files))
+                this.data = raw;
+        }
+        catch { }
+    }
+    paths() {
+        const out = [];
+        const walk = (dir, depth) => {
+            if (depth > 10 || out.length > 10_000)
+                return;
+            let entries;
+            try {
+                entries = fs.readdirSync(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                if (IGNORED.has(entry.name) || entry.name.startsWith('.env'))
+                    continue;
+                const full = path.join(dir, entry.name);
+                if (entry.isDirectory())
+                    walk(full, depth + 1);
+                else if (entry.isFile()) {
+                    try {
+                        if (safeTextFile(entry.name, fs.statSync(full).size))
+                            out.push(path.relative(this.projectRoot, full));
+                    }
+                    catch { }
+                }
+            }
+        };
+        walk(this.projectRoot, 0);
+        return out.sort();
+    }
+    refresh() {
+        const previous = new Map(this.data.files.map((file) => [file.path, file]));
+        const files = [];
+        for (const relPath of this.paths()) {
+            try {
+                const absolute = path.join(this.projectRoot, relPath);
+                const stat = fs.statSync(absolute);
+                const old = previous.get(relPath);
+                if (old?.size === stat.size && old.mtimeMs === stat.mtimeMs) {
+                    files.push(old);
+                    continue;
+                }
+                const content = fs.readFileSync(absolute, 'utf8');
+                const currentHash = hash(content);
+                if (old?.hash === currentHash) {
+                    files.push({ ...old, mtimeMs: stat.mtimeMs, size: stat.size });
+                    continue;
+                }
+                files.push({
+                    path: relPath,
+                    hash: currentHash,
+                    size: stat.size,
+                    mtimeMs: stat.mtimeMs,
+                    symbols: symbolsOf(content),
+                    imports: importsOf(content),
+                    terms: termsOf(content, relPath),
+                });
+            }
+            catch { }
+        }
+        this.data = { version: INDEX_VERSION, generatedAt: new Date().toISOString(), files };
+        writeFileAtomicPrivate(this.file(), JSON.stringify(this.data));
+        return this.status();
+    }
+    status() {
+        return {
+            files: this.data.files.length,
+            symbols: this.data.files.reduce((sum, file) => sum + file.symbols.length, 0),
+            generatedAt: this.data.generatedAt || undefined,
+        };
+    }
+    retrieve(task = '', limit = 8) {
+        this.refresh();
+        const stop = new Set(['the', 'and', 'for', 'with', 'why', 'how', 'does', 'this', 'that', 'dans', 'avec', 'pour', 'une', 'les', 'des']);
+        const query = new Set((task.toLowerCase().match(/[a-z_$][a-z0-9_$-]{2,}/g) ?? []).filter((term) => !stop.has(term)).slice(0, 80));
+        const ranked = this.data.files
+            .map((file) => {
+            let score = 0;
+            const lowerPath = file.path.toLowerCase();
+            for (const term of query) {
+                if (lowerPath.includes(term))
+                    score += 8;
+                if (file.symbols.some((symbol) => symbol.name.toLowerCase().includes(term)))
+                    score += 6;
+                if (file.terms.includes(term))
+                    score += 1;
+            }
+            return { file, score };
+        })
+            .filter((item) => item.score > 0)
+            .sort((a, b) => b.score - a.score || a.file.path.localeCompare(b.file.path))
+            .slice(0, limit);
+        if (ranked.length === 0)
+            return 'Task-oriented index matches: none. Use one bounded search.';
+        const lines = ranked.map(({ file, score }) => {
+            const symbols = file.symbols.slice(0, 8).map((symbol) => `${symbol.name}@${symbol.line}`).join(', ');
+            let matches = '';
+            try {
+                const contentLines = fs.readFileSync(path.join(this.projectRoot, file.path), 'utf8').split('\n');
+                const excerpts = [];
+                for (let index = 0; index < contentLines.length && excerpts.length < 3; index++) {
+                    const lower = contentLines[index].toLowerCase();
+                    if ([...query].some((term) => lower.includes(term))) {
+                        excerpts.push(`${index + 1}:${contentLines[index].trim().slice(0, 160)}`);
+                    }
+                }
+                if (excerpts.length > 0)
+                    matches = ` matches: ${excerpts.join(' | ')}`;
+            }
+            catch { }
+            return `- ${file.path} [score ${score}]${symbols ? ` symbols: ${symbols}` : ''}${matches}`;
+        });
+        return `TASK-ORIENTED LOCAL INDEX\n${lines.join('\n')}\nStart with these candidates; do not explore unrelated folders.`;
+    }
+}