codesearch-mcp 0.2.3-alpha → 0.4.0-alpha

package/dist/src/tools/format-helpers.js

@@ -7,6 +7,9 @@ exports.formatChunk = formatChunk;
 exports.formatGraphContext = formatGraphContext;
 exports.formatDependencies = formatDependencies;
 exports.formatDependents = formatDependents;
+exports.formatTransitiveSection = formatTransitiveSection;
+exports.formatDependenciesFilterMiss = formatDependenciesFilterMiss;
+exports.formatDependentsFilterMiss = formatDependentsFilterMiss;
 exports.pathArgDescription = pathArgDescription;
 exports.pathErrorText = pathErrorText;
 exports.pathErrorResponse = pathErrorResponse;
@@ -28,40 +31,159 @@ function formatGraphContext(ctx) {
         parts.push(`**Used by:** ${ctx.usedBy.join(' · ')}`);
     return parts.length > 0 ? '\n' + parts.join('\n') : '';
 }
-function formatDependencies(filePath, rows, transitive) {
+const MAX_NAMES = 8;
+const MAX_IN = 3;
+function nameEntry(r) {
+    switch (r.depType) {
+        case 'import': return r.toSymbol ? { text: r.toSymbol, isReexport: false } : null;
+        case 'import-default': return { text: r.toSymbol ?? 'default', isReexport: false };
+        case 'import-namespace': return { text: r.toSymbol ?? '* as namespace', isReexport: false };
+        case 'import-side-effect': return { text: 'side-effect', isReexport: false };
+        case 'reexport': return r.toSymbol ? { text: r.toSymbol, isReexport: true } : null;
+        case 'reexport-namespace': return { text: r.toSymbol ?? 'export *', isReexport: true };
+        default: return null;
+    }
+}
+function codeSpan(value) {
+    const text = value.replace(/\s+/g, ' ');
+    const fence = '`'.repeat(Math.max(0, ...(text.match(/`+/g) ?? []).map(run => run.length)) + 1);
+    const pad = text.startsWith('`') || text.endsWith('`') ? ' ' : '';
+    return `${fence}${pad}${text}${pad}${fence}`;
+}
+function capped(values, max) {
+    const shown = values.slice(0, max);
+    const more = values.length - shown.length;
+    const text = shown.map(codeSpan).join(', ');
+    return more > 0 ? `${text} (+${more} more)` : text;
+}
+function groupNames(rows) {
+    const plain = [];
+    const reexport = [];
+    for (const r of rows) {
+        const e = nameEntry(r);
+        if (!e)
+            continue;
+        const bucket = e.isReexport ? reexport : plain;
+        if (!bucket.includes(e.text))
+            bucket.push(e.text);
+    }
+    const total = plain.length + reexport.length;
+    const shownPlainCount = Math.min(plain.length, MAX_NAMES);
+    const shownReexportCount = Math.min(reexport.length, MAX_NAMES - shownPlainCount);
+    const more = total - shownPlainCount - shownReexportCount;
+    const parts = [];
+    if (shownPlainCount > 0) {
+        parts.push(plain.slice(0, shownPlainCount).map(codeSpan).join(', '));
+    }
+    if (shownReexportCount > 0) {
+        parts.push(`re-export ${reexport.slice(0, shownReexportCount).map(codeSpan).join(', ')}`);
+    }
+    let text = parts.join(', ');
+    if (more > 0)
+        text += ` (+${more} more)`;
+    return text;
+}
+function groupIn(rows) {
+    const values = [];
+    for (const r of rows) {
+        if (r.fromSymbol && !values.includes(r.fromSymbol))
+            values.push(r.fromSymbol);
+    }
+    return capped(values, MAX_IN);
+}
+function groupByFile(rows, key) {
+    const groups = new Map();
+    for (const r of rows) {
+        const k = r[key];
+        if (!groups.has(k))
+            groups.set(k, []);
+        groups.get(k).push(r);
+    }
+    return groups;
+}
+function directHeader(fileCount) {
+    return `**Direct:** ${fileCount} file${fileCount === 1 ? '' : 's'}`;
+}
+function transitiveLines(indirect, symbol, line) {
+    const note = symbol ? ' *(not filtered by `symbol`, which applies to direct imports only)*' : '';
+    return [`**Transitive:**${note}`, ...indirect.map(line)];
+}
+const dependencyLine = (r) => `  → \`${r.toFile}\` (depth ${r.depth}, via \`${r.via}\`)`;
+const dependentLine = (r) => `  ← \`${r.fromFile}\` (depth ${r.depth}, via \`${r.via}\`)`;
+function formatDependencies(filePath, rows, transitive, symbol = null) {
     const direct = rows.filter(r => !transitive || (r.depth ?? 1) === 1);
     const indirect = transitive ? rows.filter(r => (r.depth ?? 1) > 1) : [];
-    const lines = [`**Dependencies of** \`${filePath}\`\n`, '**Direct:**'];
-    for (const r of direct) {
-        const sym = r.toSymbol ? ` (${r.depType} \`${r.toSymbol}\`)` : ` (${r.depType})`;
-        lines.push(`  → \`${r.toFile}\`${sym}`);
-    }
-    if (indirect.length > 0) {
-        lines.push('\n**Transitive:**');
-        for (const r of indirect) {
-            lines.push(`  → \`${r.toFile}\` (depth ${r.depth}, via \`${r.via}\`)`);
-        }
+    const groups = groupByFile(direct, 'toFile');
+    const lines = [`**Dependencies of** \`${filePath}\`\n`, directHeader(groups.size)];
+    for (const [toFile, groupRows] of groups) {
+        const names = groupNames(groupRows);
+        lines.push(`  → \`${toFile}\`${names ? ` — ${names}` : ''}`);
     }
+    if (indirect.length > 0)
+        lines.push('', ...transitiveLines(indirect, symbol, dependencyLine));
     return lines.join('\n');
 }
-function formatDependents(filePath, rows, transitive) {
+function formatDependents(filePath, rows, transitive, symbol = null) {
     const direct = rows.filter(r => !transitive || (r.depth ?? 1) === 1);
     const indirect = transitive ? rows.filter(r => (r.depth ?? 1) > 1) : [];
-    const lines = [`**Dependents of** \`${filePath}\`\n`, '**Direct:**'];
-    for (const r of direct) {
-        const sym = r.fromSymbol ? ` (in \`${r.fromSymbol}\`)` : '';
-        lines.push(`  ← \`${r.fromFile}\`${sym}`);
-    }
-    if (indirect.length > 0) {
-        lines.push('\n**Transitive:**');
-        for (const r of indirect) {
-            lines.push(`  ← \`${r.fromFile}\` (depth ${r.depth}, via \`${r.via}\`)`);
-        }
+    const groups = groupByFile(direct, 'fromFile');
+    const lines = [`**Dependents of** \`${filePath}\`\n`, directHeader(groups.size)];
+    for (const [fromFile, groupRows] of groups) {
+        const names = groupNames(groupRows);
+        const inPart = groupIn(groupRows);
+        let line = `  ← \`${fromFile}\`${names ? ` — ${names}` : ''}`;
+        if (inPart)
+            line += ` · in ${inPart}`;
+        lines.push(line);
     }
+    if (indirect.length > 0)
+        lines.push('', ...transitiveLines(indirect, symbol, dependentLine));
     return lines.join('\n');
 }
+function formatTransitiveSection(rows, symbol, side) {
+    const indirect = rows.filter(r => (r.depth ?? 1) > 1);
+    if (indirect.length === 0)
+        return '';
+    return transitiveLines(indirect, symbol, side === 'dependencies' ? dependencyLine : dependentLine).join('\n');
+}
+function filterMissSummary(rows, key) {
+    const groups = groupByFile(rows, key);
+    const names = [];
+    for (const r of rows) {
+        if (r.toSymbol !== null && !names.includes(r.toSymbol))
+            names.push(r.toSymbol);
+    }
+    const nameless = [...groups.values()].filter(g => g.some(r => r.toSymbol === null)).length;
+    return { files: groups.size, names: capped(names, MAX_NAMES), nameless };
+}
+function filterMissTail(nameless) {
+    const lines = [];
+    if (nameless > 0) {
+        lines.push(`${nameless} of them ${nameless === 1 ? 'uses' : 'use'} a default, namespace, side-effect or \`export *\` import, which the \`symbol\` filter cannot match.`);
+    }
+    lines.push('Retry without `symbol` to list them.');
+    return lines;
+}
+function formatDependenciesFilterMiss(filePath, symbol, unfiltered) {
+    const { files, names, nameless } = filterMissSummary(unfiltered, 'toFile');
+    const importing = names ? `, importing: ${names}` : '';
+    return [
+        `No import of \`${symbol}\` found in: ${filePath}`,
+        `It has ${files} direct ${files === 1 ? 'dependency' : 'dependencies'}${importing}.`,
+        ...filterMissTail(nameless),
+    ].join('\n');
+}
+function formatDependentsFilterMiss(filePath, symbol, unfiltered) {
+    const { files, names, nameless } = filterMissSummary(unfiltered, 'fromFile');
+    const using = names ? `, using: ${names}` : '';
+    return [
+        `**Dependents of** \`${filePath}\``,
+        '',
+        `**Direct:** No direct import of \`${symbol}\`. ${files} ${files === 1 ? 'file imports' : 'files import'} this file${using}.`,
+        ...filterMissTail(nameless),
+    ].join('\n');
+}
 exports.PATH_EXAMPLE = { file: 'my-app/src/index.ts', directory: 'my-app/src' };
-/** Description of a path argument; `kind` names what the path points at. */
 function pathArgDescription(kind = 'file') {
     const root = kind === 'directory' ? ', "." for the workspace root' : '';
     const noun = kind === 'directory' ? 'directory' : 'path';
@@ -83,10 +205,6 @@ function notIndexedExplanation(e) {
                 '(run rag-index), or it has no indexable content (empty, comments only, or imports of external packages only).';
     }
 }
-/**
- * Text of a path error. `input` is the raw argument (echoed by refusals);
- * `relPath` its canonical form, printed by every other message.
- */
 function pathErrorText(argName, input, relPath, err, kind = 'file') {
     const example = exports.PATH_EXAMPLE[kind];
     switch (err.reason) {
@@ -110,12 +228,12 @@ function pathErrorText(argName, input, relPath, err, kind = 'file') {
             return `Not indexed: ${relPath}\n${notIndexedExplanation(err.explanation)}`;
         case 'not_a_file': return `Not a file: ${relPath}`;
         case 'not_a_directory': return `Not a directory: ${relPath}`;
+        case 'binary': return `Binary file: ${relPath}`;
         case 'unreadable': return `Cannot read: ${relPath} (${err.code})`;
         case 'past_end': return `${relPath} has ${err.lineCount} lines; start_line ${err.startLine} is past the end`;
         case 'bad_range': return `end_line ${err.endLine} is before start_line ${err.startLine}`;
     }
 }
-/** Error response for a path error, logged at `warn` — a caller or index-freshness problem, not a server fault. */
 function pathErrorResponse(logger, tool, argName, input, relPath, err, kind = 'file') {
     logger.warn('Tool path error', { tool, input, reason: err.reason });
     return errorResponse(pathErrorText(argName, input, relPath, err, kind));

package/dist/src/tools/tool-args.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import type { PathKind } from './format-helpers';
+export declare function requiredText(description?: string): z.ZodType<string>;
+export declare function optionalText(description?: string): z.ZodType<string | undefined>;
+export declare function pathArg(description: string, kind?: PathKind): z.ZodType<string>;
+export declare function optionalPathArg(description: string): z.ZodType<string | undefined>;
+interface IntRange {
+    min?: number;
+    max?: number;
+}
+export declare function intInRange(description: string, range: IntRange & {
+    fallback: number;
+}): z.ZodType<number>;
+export declare function intInRange(description: string, range?: IntRange): z.ZodType<number | undefined>;
+export declare function numberInRange(description: string, range: {
+    min: number;
+    max: number;
+}): z.ZodType<number | undefined>;
+export declare function flag(description: string): z.ZodType<boolean | undefined>;
+export declare function oneOf<T extends string>(description: string, values: readonly T[], fallback: T): z.ZodType<T>;
+export declare function toInputSchema(schema: z.ZodObject): Record<string, unknown>;
+export type ArgFailure = {
+    kind: 'missing-path';
+    arg: string;
+    pathKind: PathKind;
+} | {
+    kind: 'invalid';
+    text: string;
+};
+export type ParsedArgs<T> = {
+    ok: true;
+    args: T;
+} | {
+    ok: false;
+    failure: ArgFailure;
+};
+export declare function parseToolArgs<S extends z.ZodObject>(schema: S, raw: Record<string, unknown>): ParsedArgs<z.output<S>>;
+export {};

package/dist/src/tools/tool-args.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requiredText = requiredText;
+exports.optionalText = optionalText;
+exports.pathArg = pathArg;
+exports.optionalPathArg = optionalPathArg;
+exports.intInRange = intInRange;
+exports.numberInRange = numberInRange;
+exports.flag = flag;
+exports.oneOf = oneOf;
+exports.toInputSchema = toInputSchema;
+exports.parseToolArgs = parseToolArgs;
+const zod_1 = require("zod");
+const requiredPaths = zod_1.z.registry();
+const isBlank = (value) => value == null || (typeof value === 'string' && !value.trim());
+const blankToUndefined = (value) => (isBlank(value) ? undefined : value);
+const emptyPathToUndefined = (value) => (value === '' ? undefined : value ?? undefined);
+const readNumber = (value) => {
+    const present = blankToUndefined(value);
+    return typeof present === 'string' ? Number(present) : present;
+};
+const readFlag = (value) => {
+    const present = blankToUndefined(value);
+    if (present === 'true')
+        return true;
+    if (present === 'false')
+        return false;
+    return present;
+};
+const clamp = (value, min = -Infinity, max = Infinity) => Math.min(Math.max(min, value), max);
+function described(schema, description) {
+    return description === undefined ? schema : schema.describe(description);
+}
+function requiredText(description) {
+    return described(zod_1.z.preprocess(blankToUndefined, zod_1.z.string()), description);
+}
+function optionalText(description) {
+    return described(zod_1.z.preprocess(blankToUndefined, zod_1.z.string().optional()), description);
+}
+function pathArg(description, kind = 'file') {
+    const schema = zod_1.z.preprocess(emptyPathToUndefined, zod_1.z.string()).describe(description);
+    requiredPaths.add(schema, { pathKind: kind });
+    return schema;
+}
+function optionalPathArg(description) {
+    return zod_1.z.preprocess(emptyPathToUndefined, zod_1.z.string().optional()).describe(description);
+}
+function intInRange(description, range = {}) {
+    const { min, max, fallback } = range;
+    const inRange = zod_1.z.number().optional().transform(value => {
+        const picked = value === undefined ? fallback : Math.trunc(value);
+        return picked === undefined ? undefined : clamp(picked, min, max);
+    });
+    return zod_1.z.preprocess(readNumber, inRange).describe(description);
+}
+function numberInRange(description, range) {
+    const inRange = zod_1.z.number().optional().transform(value => value === undefined ? undefined : clamp(value, range.min, range.max));
+    return zod_1.z.preprocess(readNumber, inRange).describe(description);
+}
+function flag(description) {
+    return zod_1.z.preprocess(readFlag, zod_1.z.boolean().optional()).describe(description);
+}
+function oneOf(description, values, fallback) {
+    const member = zod_1.z.enum(values).optional().transform(value => (value ?? fallback));
+    return zod_1.z.preprocess(blankToUndefined, member).describe(description);
+}
+function toInputSchema(schema) {
+    const { $schema: _, ...inputSchema } = zod_1.z.toJSONSchema(schema, { io: 'input' });
+    return inputSchema;
+}
+function expectation(issue) {
+    return issue.code === 'invalid_value'
+        ? `one of ${issue.values.join(', ')}`
+        : `a ${issue.expected}`;
+}
+function parseToolArgs(schema, raw) {
+    const parsed = schema.safeParse(raw);
+    if (parsed.success)
+        return { ok: true, args: parsed.data };
+    const lines = [];
+    for (const [arg, argSchema] of Object.entries(schema.shape)) {
+        const issue = parsed.error.issues.find(i => i.path[0] === arg);
+        if (!issue)
+            continue;
+        if (!isBlank(raw[arg])) {
+            lines.push(`Invalid ${arg}: expected ${expectation(issue)}`);
+            continue;
+        }
+        const path = requiredPaths.get(argSchema);
+        if (path)
+            return { ok: false, failure: { kind: 'missing-path', arg, pathKind: path.pathKind } };
+        lines.push(`Missing ${arg}`);
+    }
+    return { ok: false, failure: { kind: 'invalid', text: lines.join('\n') } };
+}

package/dist/src/web/dashboard.d.ts

@@ -1,9 +1 @@
-/**
- * Renders the RAG dashboard as a single self-contained HTML page (inline CSS +
- * JS), mirroring the approach in graph.ts. The page is schema-driven: it fetches
- * /api/schema (from buildJsonSchema — the same source as Step 1's editor support)
- * and /api/config, then renders a typed form. The Graph tab embeds the full
- * standalone graph page (GET /graph — same buildHtml as project-graph.html) in
- * an iframe rather than re-implementing the network here.
- */
 export declare function renderDashboardHtml(): string;

package/dist/src/web/dashboard.js

@@ -1,14 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderDashboardHtml = renderDashboardHtml;
-/**
- * Renders the RAG dashboard as a single self-contained HTML page (inline CSS +
- * JS), mirroring the approach in graph.ts. The page is schema-driven: it fetches
- * /api/schema (from buildJsonSchema — the same source as Step 1's editor support)
- * and /api/config, then renders a typed form. The Graph tab embeds the full
- * standalone graph page (GET /graph — same buildHtml as project-graph.html) in
- * an iframe rather than re-implementing the network here.
- */
 function renderDashboardHtml() {
     return `<!DOCTYPE html>
 <html lang="en">
@@ -168,7 +160,12 @@ function renderDashboardHtml() {
     if (spec.type === 'boolean') {
       const cb = document.createElement('input');
       cb.type = 'checkbox'; cb.dataset.key = key; cb.dataset.type = 'boolean';
-      cb.checked = value === true;
+      cb.checked = isUnset ? def === true : value === true;
+      // An absent boolean can resolve from context (reranker.enabled), so it is saved only once changed.
+      if (isUnset) {
+        cb.dataset.unset = '1';
+        cb.addEventListener('change', () => { delete cb.dataset.unset; });
+      }
       return cb;
     }
     if (Array.isArray(enumVals)) return selectEl(key, enumVals, value, def);
@@ -236,7 +233,7 @@ function renderDashboardHtml() {
     document.querySelectorAll('[data-key]').forEach(el => {
       const key = el.dataset.key, type = el.dataset.type;
       let val;
-      if (type === 'boolean') val = el.checked;
+      if (type === 'boolean') { if (el.dataset.unset) return; val = el.checked; }
       else if (el.value === '') return; // unset → omit (stay minimal)
       else if (type === 'number') { const n = Number(el.value); if (Number.isNaN(n)) return; val = n; }
       else val = el.value;

package/dist/src/workspace/GrepRunner.d.ts

@@ -0,0 +1,15 @@
+import type { ILogger } from '../interfaces';
+export interface GrepRun {
+    ok: boolean;
+    output: string | null;
+    failure: string | null;
+}
+export declare class GrepRunner {
+    private logger;
+    private readonly liveGreps;
+    private readonly killLiveGreps;
+    constructor(logger: ILogger);
+    run(args: string[]): Promise<GrepRun>;
+    private trackGrep;
+    private untrackGrep;
+}

package/dist/src/workspace/GrepRunner.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrepRunner = void 0;
+const child_process_1 = require("child_process");
+const fs_access_1 = require("./fs-access");
+const GREP_TIMEOUT_MS = 60_000;
+const FAILURE_MAX_CHARS = 200;
+const STDERR_MAX_BYTES = 4096;
+const capFailure = (text) => {
+    const capped = text.slice(0, FAILURE_MAX_CHARS);
+    return /[\uD800-\uDBFF]$/.test(capped) ? capped.slice(0, -1) : capped;
+};
+class GrepRunner {
+    logger;
+    liveGreps = new Set();
+    killLiveGreps = () => {
+        for (const proc of this.liveGreps)
+            proc.kill('SIGKILL');
+    };
+    constructor(logger) {
+        this.logger = logger;
+    }
+    run(args) {
+        return new Promise((resolve) => {
+            let proc;
+            try {
+                proc = (0, child_process_1.spawn)('grep', args, { stdio: ['ignore', 'pipe', 'pipe'] });
+            }
+            catch (err) {
+                this.logger.error('GrepRunner: grep spawn failed', { err });
+                resolve({ ok: false, output: null, failure: capFailure((0, fs_access_1.errorCode)(err)) });
+                return;
+            }
+            this.trackGrep(proc);
+            const chunks = [];
+            let totalBytes = 0;
+            const MAX_BUFFER = 10 * 1024 * 1024;
+            const printed = () => (chunks.length === 0 ? null : Buffer.concat(chunks).toString('utf-8'));
+            const stderrChunks = [];
+            let stderrBytes = 0;
+            const stderrLine = () => {
+                const text = Buffer.concat(stderrChunks).toString('utf-8');
+                const line = text.split('\n').map(l => l.trim()).find(l => l !== '');
+                return line ?? null;
+            };
+            const timer = setTimeout(() => {
+                this.logger.warn('GrepRunner: grep timed out', { ms: GREP_TIMEOUT_MS });
+                finish({ ok: false, output: printed(), failure: `timed out after ${GREP_TIMEOUT_MS / 1000} seconds` });
+                proc.kill('SIGKILL');
+                proc.stdout?.destroy();
+                proc.stderr?.destroy();
+            }, GREP_TIMEOUT_MS);
+            timer.unref();
+            let settled = false;
+            const finish = (result) => {
+                settled = true;
+                clearTimeout(timer);
+                this.untrackGrep(proc);
+                resolve(result);
+            };
+            proc.stdout?.on('data', (chunk) => {
+                totalBytes += chunk.length;
+                if (totalBytes <= MAX_BUFFER) {
+                    chunks.push(chunk);
+                }
+            });
+            proc.stderr?.on('data', (chunk) => {
+                if (stderrBytes >= STDERR_MAX_BYTES)
+                    return;
+                stderrChunks.push(chunk);
+                stderrBytes += chunk.length;
+            });
+            proc.on('error', (err) => {
+                if (settled)
+                    return;
+                this.logger.error('GrepRunner: grep spawn failed', { err });
+                finish({ ok: false, output: null, failure: capFailure((0, fs_access_1.errorCode)(err)) });
+            });
+            proc.on('close', (code, signal) => {
+                if (settled)
+                    return;
+                const output = printed();
+                if (code === 0 || code === 1) {
+                    finish({ ok: true, output, failure: null });
+                    return;
+                }
+                this.logger.warn('GrepRunner: grep exited with code', { code, signal });
+                const cause = stderrLine() ?? (code !== null ? `exit status ${code}` : `signal ${signal}`);
+                finish({ ok: false, output, failure: capFailure(cause) });
+            });
+        });
+    }
+    trackGrep(proc) {
+        if (this.liveGreps.size === 0)
+            process.on('exit', this.killLiveGreps);
+        this.liveGreps.add(proc);
+    }
+    untrackGrep(proc) {
+        this.liveGreps.delete(proc);
+        if (this.liveGreps.size === 0)
+            process.off('exit', this.killLiveGreps);
+    }
+}
+exports.GrepRunner = GrepRunner;

package/dist/src/workspace/ProjectRoots.d.ts

@@ -0,0 +1,22 @@
+import type { Config } from '../config';
+import type { IProjectDiscovery } from '../interfaces';
+import type { IProjectRoots } from '../interfaces/IProjectRoots';
+export declare class ProjectRoots implements IProjectRoots {
+    private discovery;
+    private config;
+    private rootMap?;
+    constructor(discovery: IProjectDiscovery, config: Config);
+    private projectRootMap;
+    entries(): IterableIterator<[string, string]>;
+    refresh(): void;
+    resolveProjectRoot(name: string): string;
+    toRel(absPath: string): string;
+    toAbs(relPath: string): string;
+    workspaceRoot(): string;
+    findProjectRootByName(name: string): string | null;
+    findProjectRoot(match: (rel: string) => boolean): {
+        name: string;
+        rel: string;
+    } | null;
+    fallbackRoot(relPath: string): string | null;
+}

package/dist/src/workspace/ProjectRoots.js

@@ -0,0 +1,102 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectRoots = void 0;
+const path = __importStar(require("path"));
+const MonorepoAwareDiscoveryService_1 = require("../services/MonorepoAwareDiscoveryService");
+const path_helpers_1 = require("./path-helpers");
+class ProjectRoots {
+    discovery;
+    config;
+    rootMap;
+    constructor(discovery, config) {
+        this.discovery = discovery;
+        this.config = config;
+    }
+    projectRootMap() {
+        if (!this.rootMap) {
+            this.rootMap = new Map((0, MonorepoAwareDiscoveryService_1.toLeafProjects)(this.discovery.discover(this.config.workspaceRoot)).map(p => [p.name, p.path]));
+        }
+        return this.rootMap;
+    }
+    entries() {
+        return this.projectRootMap().entries();
+    }
+    refresh() {
+        this.rootMap = undefined;
+    }
+    resolveProjectRoot(name) {
+        let root = this.projectRootMap().get(name);
+        if (root === undefined) {
+            this.rootMap = undefined;
+            root = this.projectRootMap().get(name);
+        }
+        return root ?? path.join(this.config.workspaceRoot, name);
+    }
+    toRel(absPath) {
+        return path.relative(this.config.workspaceRoot, absPath) || '.';
+    }
+    toAbs(relPath) {
+        return relPath === '.' ? this.workspaceRoot() : path.join(this.workspaceRoot(), relPath);
+    }
+    workspaceRoot() {
+        return (0, path_helpers_1.stripTrailingSlash)(path.posix.normalize(this.config.workspaceRoot));
+    }
+    findProjectRootByName(name) {
+        let root = this.projectRootMap().get(name);
+        if (root === undefined) {
+            this.rootMap = undefined;
+            root = this.projectRootMap().get(name);
+        }
+        return root === undefined ? null : this.toRel(root);
+    }
+    findProjectRoot(match) {
+        for (let attempt = 0; attempt < 2; attempt++) {
+            if (attempt === 1)
+                this.rootMap = undefined;
+            const best = [...this.projectRootMap().entries()]
+                .map(([name, abs]) => ({ name, rel: this.toRel(abs) }))
+                .filter(r => match(r.rel))
+                .sort((a, b) => b.rel.length - a.rel.length)[0];
+            if (best)
+                return best;
+        }
+        return null;
+    }
+    fallbackRoot(relPath) {
+        return this.findProjectRoot(r => (0, path_helpers_1.isWithin)(relPath, r))?.rel ?? null;
+    }
+}
+exports.ProjectRoots = ProjectRoots;