codesearch-mcp 0.2.3-alpha → 0.4.0-alpha

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

@@ -0,0 +1,31 @@
+import type { IDatabase, ILogger } from '../interfaces';
+import type { IToolPaths, PathFailure, ResolvedToolPath } from '../interfaces/IToolPaths';
+import { type WorkspaceFs } from './fs-access';
+import type { ProjectRoots } from './ProjectRoots';
+export declare class ToolPaths implements IToolPaths {
+    private db;
+    private roots;
+    private logger;
+    private fs;
+    private realRootCache?;
+    constructor(db: IDatabase, roots: ProjectRoots, logger: ILogger, fs: WorkspaceFs);
+    private realWorkspaceRoot;
+    resolveToolPath(input: string | null | undefined): Promise<ResolvedToolPath>;
+    private realLocation;
+    checkRealLocation(relPath: string, absPath: string, kind: 'file' | 'dir'): Promise<{
+        ok: true;
+    } | Extract<PathFailure, {
+        reason: 'outside_workspace' | 'unreadable';
+    }>>;
+    grepSearchDir(project: string): Promise<string | null>;
+    private pathExists;
+    isIndexedPath(relPath: string): Promise<boolean>;
+    isContentPath(relPath: string): Promise<boolean>;
+    private hasContentUnder;
+    findPathCandidates(relPath: string, kind: 'file' | 'dir'): Promise<string[]>;
+    candidatesOrNone(relPath: string, kind: 'file' | 'dir'): Promise<string[]>;
+    private nearNames;
+    private substituteProjectName;
+    checkGraphPath(relPath: string): Promise<PathFailure | null>;
+    private explainNotIndexed;
+}

package/dist/src/workspace/ToolPaths.js

@@ -0,0 +1,312 @@
+"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.ToolPaths = void 0;
+const path = __importStar(require("path"));
+const file_utils_1 = require("../file-utils");
+const symbol_name_1 = require("../symbol-name");
+const index_paths_1 = require("../search/index-paths");
+const fs_access_1 = require("./fs-access");
+const path_helpers_1 = require("./path-helpers");
+const PATH_MAX_BYTES = 4096;
+const PATH_CANDIDATE_LIMIT = 3;
+const NEAR_NAME_MAX_DISTANCE = 2;
+const INDEX_PATH_COLUMNS = [
+    { table: 'code_chunk', column: '"filePath"', content: true },
+    { table: 'code_symbol', column: '"filePath"', content: true },
+    { table: 'code_dependency', column: '"fromFile"', content: true },
+    { table: 'code_call', column: '"fromFile"', content: true },
+    { table: 'code_dependency', column: '"toFile"', content: false },
+    { table: 'code_call', column: '"calleeFile"', content: false },
+];
+class ToolPaths {
+    db;
+    roots;
+    logger;
+    fs;
+    realRootCache;
+    constructor(db, roots, logger, fs) {
+        this.db = db;
+        this.roots = roots;
+        this.logger = logger;
+        this.fs = fs;
+    }
+    async realWorkspaceRoot() {
+        if (this.realRootCache !== undefined)
+            return this.realRootCache;
+        try {
+            this.realRootCache = await this.fs.realpath(this.roots.workspaceRoot());
+            return this.realRootCache;
+        }
+        catch (err) {
+            this.logger.warn('ToolPaths: workspaceRoot real path unavailable', { reason: (0, fs_access_1.errorCode)(err) });
+            return null;
+        }
+    }
+    async resolveToolPath(input) {
+        if (input == null || input === '')
+            return { ok: false, reason: 'invalid', missing: true };
+        if (input.includes('\\'))
+            return { ok: false, reason: 'invalid', missing: false };
+        if (Buffer.byteLength(input) >= PATH_MAX_BYTES)
+            return { ok: false, reason: 'unreadable', code: 'ENAMETOOLONG' };
+        if (path.posix.isAbsolute(input)) {
+            const abs = (0, path_helpers_1.stripTrailingSlash)(path.posix.normalize(input));
+            const realRoot = await this.realWorkspaceRoot();
+            for (const root of realRoot ? [this.roots.workspaceRoot(), realRoot] : [this.roots.workspaceRoot()]) {
+                if (!(0, path_helpers_1.isWithin)(abs, root))
+                    continue;
+                const relative = abs === root ? '.' : abs.slice(root === '/' ? 1 : root.length + 1);
+                return { ok: false, reason: 'absolute', relative };
+            }
+            return { ok: false, reason: 'outside_workspace' };
+        }
+        const relPath = (0, path_helpers_1.stripTrailingSlash)(path.posix.normalize(input));
+        if (relPath === '..' || relPath.startsWith('../'))
+            return { ok: false, reason: 'outside_workspace' };
+        return { ok: true, relPath, absPath: this.roots.toAbs(relPath) };
+    }
+    async realLocation(absPath) {
+        if (Buffer.byteLength(absPath) >= PATH_MAX_BYTES)
+            return { ok: false, code: 'ENAMETOOLONG' };
+        const root = (await this.realWorkspaceRoot()) ?? this.roots.workspaceRoot();
+        let existing = absPath;
+        const rest = [];
+        for (;;) {
+            try {
+                const real = path.join(await this.fs.realpath(existing), ...rest);
+                return { ok: true, inside: (0, path_helpers_1.isWithin)(real, root) };
+            }
+            catch (err) {
+                if ((0, fs_access_1.errorCode)(err) !== 'ENOENT')
+                    return { ok: false, code: (0, fs_access_1.errorCode)(err) };
+                const parent = path.dirname(existing);
+                if (parent === existing)
+                    return { ok: true, inside: false };
+                rest.unshift(path.basename(existing));
+                existing = parent;
+            }
+        }
+    }
+    async checkRealLocation(relPath, absPath, kind) {
+        const loc = await this.realLocation(absPath);
+        if (!loc.ok)
+            return { ok: false, reason: 'unreadable', code: loc.code };
+        if (loc.inside)
+            return { ok: true };
+        const exempt = kind === 'file' ? await this.isContentPath(relPath) : await this.hasContentUnder(relPath);
+        return exempt ? { ok: true } : { ok: false, reason: 'outside_workspace' };
+    }
+    async grepSearchDir(project) {
+        let discovered;
+        try {
+            discovered = this.roots.findProjectRootByName(project);
+        }
+        catch (err) {
+            this.logger.error('ToolPaths: project discovery failed', { project, err });
+            return null;
+        }
+        let absDir;
+        if (discovered !== null) {
+            absDir = this.roots.toAbs(discovered);
+        }
+        else {
+            if (Buffer.byteLength(project) >= PATH_MAX_BYTES)
+                return null;
+            absDir = path.join(this.roots.workspaceRoot(), project);
+            const loc = await this.realLocation(absDir);
+            if (!loc.ok || !loc.inside)
+                return null;
+        }
+        try {
+            return (await this.fs.stat(absDir)).isDirectory() ? absDir : null;
+        }
+        catch (err) {
+            const code = (0, fs_access_1.errorCode)(err);
+            return code === 'ENOENT' || code === 'ENOTDIR' ? null : absDir;
+        }
+    }
+    async pathExists(columns, predicate, param) {
+        const branches = columns.map(c => `SELECT 1 FROM ${c.table} WHERE ${predicate.replace(/\$col/g, c.column)}`);
+        const [{ exists }] = await this.db.query(`SELECT EXISTS (${branches.join(' UNION ALL ')}) AS exists`, [param]);
+        return exists;
+    }
+    isIndexedPath(relPath) {
+        return this.pathExists(INDEX_PATH_COLUMNS, '$col = $1', relPath);
+    }
+    isContentPath(relPath) {
+        return this.pathExists(INDEX_PATH_COLUMNS.filter(c => c.content), '$col = $1', relPath);
+    }
+    hasContentUnder(relPath) {
+        const prefix = relPath === '.' ? '' : (0, symbol_name_1.escapeLike)(relPath) + '/';
+        return this.pathExists(INDEX_PATH_COLUMNS.filter(c => c.content), `$col LIKE $1 ESCAPE '\\'`, prefix + '%');
+    }
+    async findPathCandidates(relPath, kind) {
+        const union = INDEX_PATH_COLUMNS.map(c => `SELECT ${c.column} AS p FROM ${c.table}`).join(' UNION ALL ');
+        const notOutside = `NOT ${(0, index_paths_1.OUTSIDE_WORKSPACE_VALUE)('p')}`;
+        if (kind === 'file') {
+            const substituted = await this.substituteProjectName(relPath);
+            const rows = await this.db.query(`SELECT p FROM (${union}) s
+         WHERE p LIKE $1 ESCAPE '\\' AND ${notOutside}
+         GROUP BY p ORDER BY p COLLATE "C" LIMIT ${PATH_CANDIDATE_LIMIT + 1}`, ['%/' + (0, symbol_name_1.escapeLike)(relPath)]);
+            const first = substituted ? [substituted] : [];
+            return [...first, ...rows.map(r => r.p).filter(p => p !== substituted)].slice(0, PATH_CANDIDATE_LIMIT);
+        }
+        const projectRoot = this.roots.findProjectRootByName(relPath);
+        const first = projectRoot && projectRoot !== relPath ? [projectRoot] : [];
+        const rows = await this.db.query(`SELECT d AS p FROM (
+         SELECT substring(p FROM 1 FOR position($2::text IN p) + length($3::text)) AS d
+         FROM (${union}) s
+         WHERE p LIKE $1 ESCAPE '\\' AND ${notOutside}
+       ) dirs
+       GROUP BY d ORDER BY d COLLATE "C" LIMIT ${PATH_CANDIDATE_LIMIT + 1}`, ['%/' + (0, symbol_name_1.escapeLike)(relPath) + '/%', '/' + relPath + '/', relPath]);
+        const rest = rows.map(r => r.p).filter(p => !first.includes(p));
+        return [...first, ...rest].slice(0, PATH_CANDIDATE_LIMIT);
+    }
+    async candidatesOrNone(relPath, kind) {
+        let candidates;
+        try {
+            candidates = await this.findPathCandidates(relPath, kind);
+        }
+        catch (err) {
+            this.logger.error('ToolPaths: path candidate lookup failed', { relPath, err });
+            return [];
+        }
+        if (candidates.length >= PATH_CANDIDATE_LIMIT)
+            return candidates;
+        const near = (await this.nearNames(relPath, kind)).filter(p => !candidates.includes(p));
+        return [...candidates, ...near].slice(0, PATH_CANDIDATE_LIMIT);
+    }
+    async nearNames(relPath, kind) {
+        if (relPath === '.')
+            return [];
+        const parent = path.posix.dirname(relPath);
+        const segment = path.posix.basename(relPath);
+        const absParent = this.roots.toAbs(parent);
+        let entries;
+        try {
+            const loc = await this.realLocation(absParent);
+            if (!loc.ok)
+                throw Object.assign(new Error(`real location unavailable: ${loc.code}`), { code: loc.code });
+            if (!loc.inside)
+                return [];
+            entries = await this.fs.readdir(absParent);
+        }
+        catch (err) {
+            const code = (0, fs_access_1.errorCode)(err);
+            if (code === 'ENOENT' || code === 'ENOTDIR')
+                return [];
+            this.logger.error('ToolPaths: near-name lookup failed', { relPath, err });
+            return [];
+        }
+        const segmentLength = [...segment].length;
+        const near = [];
+        for (const entry of entries) {
+            if (kind === 'file' ? !entry.isFile() : !entry.isDirectory())
+                continue;
+            if (file_utils_1.IGNORE_DIRS.has(entry.name))
+                continue;
+            const distance = (0, path_helpers_1.editDistance)(entry.name, segment, NEAR_NAME_MAX_DISTANCE);
+            if (distance > NEAR_NAME_MAX_DISTANCE || distance >= segmentLength / 2)
+                continue;
+            near.push({ name: entry.name, distance });
+        }
+        near.sort((a, b) => a.distance - b.distance || Buffer.compare(Buffer.from(a.name, 'utf8'), Buffer.from(b.name, 'utf8')));
+        return near.slice(0, PATH_CANDIDATE_LIMIT).map(e => (parent === '.' ? e.name : `${parent}/${e.name}`));
+    }
+    async substituteProjectName(relPath) {
+        let named = [];
+        for (let attempt = 0; attempt < 2 && named.length === 0; attempt++) {
+            if (attempt === 1)
+                this.roots.refresh();
+            named = [...this.roots.entries()].filter(([name]) => relPath.startsWith(name + '/'));
+        }
+        const longest = named.sort((a, b) => b[0].length - a[0].length)[0];
+        if (!longest)
+            return null;
+        const [name, absRoot] = longest;
+        const root = this.roots.toRel(absRoot);
+        if (root === name)
+            return null;
+        const candidate = (root === '.' ? '' : root + '/') + relPath.slice(name.length + 1);
+        if (await this.isIndexedPath(candidate))
+            return candidate;
+        try {
+            return (await this.fs.stat(this.roots.toAbs(candidate))).isFile() ? candidate : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async checkGraphPath(relPath) {
+        if (await this.isIndexedPath(relPath))
+            return null;
+        const absPath = this.roots.toAbs(relPath);
+        const loc = await this.realLocation(absPath);
+        if (!loc.ok)
+            return { ok: false, reason: 'unreadable', code: loc.code };
+        if (!loc.inside)
+            return { ok: false, reason: 'not_found', candidates: await this.candidatesOrNone(relPath, 'file') };
+        let stat;
+        try {
+            stat = await this.fs.stat(absPath);
+        }
+        catch (err) {
+            if ((0, fs_access_1.errorCode)(err) !== 'ENOENT')
+                return { ok: false, reason: 'unreadable', code: (0, fs_access_1.errorCode)(err) };
+            return { ok: false, reason: 'not_found', candidates: await this.candidatesOrNone(relPath, 'file') };
+        }
+        if (!stat.isFile())
+            return { ok: false, reason: 'not_a_file' };
+        return { ok: false, reason: 'not_indexed', explanation: await this.explainNotIndexed(relPath) };
+    }
+    async explainNotIndexed(relPath) {
+        const owner = this.roots.findProjectRoot(r => r !== relPath && (0, path_helpers_1.isWithin)(relPath, r));
+        if (!owner)
+            return { kind: 'no_project' };
+        const inProject = owner.rel === '.' ? relPath : relPath.slice(owner.rel.length + 1);
+        const exclusion = (0, file_utils_1.indexingExclusion)(inProject, (0, file_utils_1.loadIgnore)(this.roots.toAbs(owner.rel)));
+        if (exclusion)
+            return exclusion;
+        const [{ exists }] = await this.db.query(`SELECT EXISTS (
+         SELECT 1 FROM code_chunk WHERE "serviceName" = $1
+         UNION ALL SELECT 1 FROM code_symbol WHERE project = $1
+         UNION ALL SELECT 1 FROM code_dependency WHERE project = $1
+         UNION ALL SELECT 1 FROM code_call WHERE project = $1
+       ) AS exists`, [owner.name]);
+        return exists ? { kind: 'unknown' } : { kind: 'project_not_indexed', project: owner.name };
+    }
+}
+exports.ToolPaths = ToolPaths;

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

@@ -0,0 +1,19 @@
+import type { ILogger } from '../interfaces';
+import type { FileRangeResult, IWorkspaceFiles, ListFilesResult } from '../interfaces/IWorkspaceFiles';
+import { type WorkspaceFs } from './fs-access';
+import type { ProjectRoots } from './ProjectRoots';
+import type { ToolPaths } from './ToolPaths';
+export declare class WorkspaceFiles implements IWorkspaceFiles {
+    private paths;
+    private roots;
+    private logger;
+    private fs;
+    constructor(paths: ToolPaths, roots: ProjectRoots, logger: ILogger, fs: WorkspaceFs);
+    listFiles(relPath: string, depth: number, pattern: string | null): Promise<ListFilesResult>;
+    private openableFile;
+    private readLines;
+    private readFailure;
+    readFile(relPath: string, maxLines: number): Promise<FileRangeResult>;
+    readFileRange(relPath: string, startLine: number, endLine: number): Promise<FileRangeResult>;
+    private walkDir;
+}

package/dist/src/workspace/WorkspaceFiles.js

@@ -0,0 +1,285 @@
+"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.WorkspaceFiles = void 0;
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const stream_1 = require("stream");
+const file_utils_1 = require("../file-utils");
+const fs_access_1 = require("./fs-access");
+const MAX_LINE_BYTES = 64 * 1024 * 1024;
+const LINE_TOO_LONG = 'ELINETOOLONG';
+const BINARY_FILE = 'EBINARY';
+const BINARY_SNIFF_BYTES = 8 * 1024;
+const LF = 0x0a;
+const CR = 0x0d;
+function openLineBytes(open, chunk) {
+    const breaks = [chunk.indexOf(LF), chunk.indexOf(CR)].filter(i => i >= 0);
+    const head = breaks.length === 0 ? chunk.length : Math.min(...breaks);
+    const total = open + head;
+    if (total > MAX_LINE_BYTES)
+        return null;
+    if (breaks.length === 0)
+        return total;
+    return chunk.length - 1 - Math.max(chunk.lastIndexOf(LF), chunk.lastIndexOf(CR));
+}
+function lineLimitGuard() {
+    let open = 0;
+    let sniffed = 0;
+    let held = [];
+    const lineLimit = (chunk) => {
+        const next = openLineBytes(open, chunk);
+        if (next === null)
+            return Object.assign(new Error('line too long'), { code: LINE_TOO_LONG });
+        open = next;
+        return null;
+    };
+    return new stream_1.Transform({
+        encoding: 'utf-8',
+        transform(chunk, _encoding, done) {
+            if (sniffed < BINARY_SNIFF_BYTES) {
+                const head = chunk.subarray(0, BINARY_SNIFF_BYTES - sniffed);
+                if (head.includes(0)) {
+                    done(Object.assign(new Error('binary file'), { code: BINARY_FILE }));
+                    return;
+                }
+                sniffed += head.length;
+                held.push(chunk);
+                if (sniffed < BINARY_SNIFF_BYTES) {
+                    done();
+                    return;
+                }
+                chunk = Buffer.concat(held);
+                held = [];
+            }
+            const err = lineLimit(chunk);
+            if (err)
+                done(err);
+            else
+                done(null, chunk);
+        },
+        flush(done) {
+            if (held.length === 0) {
+                done();
+                return;
+            }
+            const chunk = Buffer.concat(held);
+            held = [];
+            const err = lineLimit(chunk);
+            if (err)
+                done(err);
+            else
+                done(null, chunk);
+        },
+    });
+}
+class WorkspaceFiles {
+    paths;
+    roots;
+    logger;
+    fs;
+    constructor(paths, roots, logger, fs) {
+        this.paths = paths;
+        this.roots = roots;
+        this.logger = logger;
+        this.fs = fs;
+    }
+    async listFiles(relPath, depth, pattern) {
+        const t0 = Date.now();
+        this.logger.debug('WorkspaceFiles: listFiles', { relPath, depth, pattern });
+        const absPath = this.roots.toAbs(relPath);
+        const loc = await this.paths.checkRealLocation(relPath, absPath, 'dir');
+        if (!loc.ok)
+            return loc;
+        let stat;
+        try {
+            stat = await this.fs.stat(absPath);
+        }
+        catch (err) {
+            if ((0, fs_access_1.errorCode)(err) !== 'ENOENT')
+                return { ok: false, reason: 'unreadable', code: (0, fs_access_1.errorCode)(err) };
+            return { ok: false, reason: 'not_found', candidates: await this.paths.candidatesOrNone(relPath, 'dir') };
+        }
+        if (!stat.isDirectory())
+            return { ok: false, reason: 'not_a_directory' };
+        const clampedDepth = Math.min(5, Math.max(1, depth));
+        const lines = [];
+        try {
+            await this.walkDir(absPath, 0, clampedDepth - 1, pattern, lines);
+        }
+        catch (err) {
+            return { ok: false, reason: 'unreadable', code: (0, fs_access_1.errorCode)(err) };
+        }
+        this.logger.debug('WorkspaceFiles: listFiles result', { entries: lines.length, ms: Date.now() - t0 });
+        if (lines.length === 0) {
+            return { ok: true, tree: pattern ? `No files matching "${pattern}" found within depth ${clampedDepth}.` : '(empty directory)' };
+        }
+        return { ok: true, tree: lines.join('\n') };
+    }
+    async openableFile(relPath, absPath) {
+        const loc = await this.paths.checkRealLocation(relPath, absPath, 'file');
+        if (!loc.ok)
+            return loc;
+        let stat;
+        try {
+            stat = await this.fs.stat(absPath);
+        }
+        catch (err) {
+            if ((0, fs_access_1.errorCode)(err) !== 'ENOENT')
+                return { ok: false, reason: 'unreadable', code: (0, fs_access_1.errorCode)(err) };
+            if (await this.paths.isIndexedPath(relPath))
+                return { ok: false, reason: 'deleted' };
+            return { ok: false, reason: 'not_found', candidates: await this.paths.candidatesOrNone(relPath, 'file') };
+        }
+        return stat.isFile() ? null : { ok: false, reason: 'not_a_file' };
+    }
+    async readLines(absPath, onLine) {
+        const stream = this.fs.createReadStream(absPath);
+        const guard = lineLimitGuard();
+        guard.on('error', () => { });
+        stream.on('error', err => guard.destroy(err));
+        stream.pipe(guard);
+        const rl = readline.createInterface({ input: guard, crlfDelay: Infinity });
+        let lineNo = 0;
+        try {
+            for await (const line of rl) {
+                lineNo++;
+                if (!onLine(line, lineNo))
+                    break;
+            }
+            return { ok: true, lineCount: lineNo };
+        }
+        catch (err) {
+            if ((0, fs_access_1.errorCode)(err) === LINE_TOO_LONG && !onLine('', lineNo + 1))
+                return { ok: true, lineCount: lineNo };
+            return { ok: false, code: (0, fs_access_1.errorCode)(err) };
+        }
+        finally {
+            rl.close();
+            guard.destroy();
+            stream.destroy?.();
+        }
+    }
+    readFailure(code) {
+        return code === BINARY_FILE ? { ok: false, reason: 'binary' } : { ok: false, reason: 'unreadable', code };
+    }
+    async readFile(relPath, maxLines) {
+        const t0 = Date.now();
+        this.logger.debug('WorkspaceFiles: readFile', { relPath, maxLines });
+        const absPath = this.roots.toAbs(relPath);
+        const failure = await this.openableFile(relPath, absPath);
+        if (failure)
+            return failure;
+        const lines = [];
+        let hasMore = false;
+        const read = await this.readLines(absPath, line => {
+            if (lines.length < maxLines) {
+                lines.push(line);
+                return true;
+            }
+            hasMore = true;
+            return false;
+        });
+        if (!read.ok)
+            return this.readFailure(read.code);
+        this.logger.debug('WorkspaceFiles: readFile result', { linesRead: lines.length, hasMore, ms: Date.now() - t0 });
+        return { ok: true, filePath: relPath, startLine: 1, endLine: lines.length, lines, hasMore };
+    }
+    async readFileRange(relPath, startLine, endLine) {
+        const t0 = Date.now();
+        this.logger.debug('WorkspaceFiles: readFileRange', { relPath, startLine, endLine });
+        if (endLine < startLine)
+            return { ok: false, reason: 'bad_range', startLine, endLine };
+        const absPath = this.roots.toAbs(relPath);
+        const failure = await this.openableFile(relPath, absPath);
+        if (failure)
+            return failure;
+        const lines = [];
+        let lastRead = 0;
+        let hasMore = false;
+        const read = await this.readLines(absPath, (line, lineNo) => {
+            if (lineNo > endLine) {
+                hasMore = true;
+                return false;
+            }
+            if (lineNo >= startLine)
+                lines.push(line);
+            lastRead = lineNo;
+            return true;
+        });
+        if (!read.ok)
+            return this.readFailure(read.code);
+        if (!hasMore && startLine > Math.max(read.lineCount, 1)) {
+            return { ok: false, reason: 'past_end', lineCount: read.lineCount, startLine };
+        }
+        this.logger.debug('WorkspaceFiles: readFileRange result', { linesRead: lines.length, hasMore, ms: Date.now() - t0 });
+        return { ok: true, filePath: relPath, startLine, endLine: Math.min(endLine, lastRead), lines, hasMore };
+    }
+    async walkDir(absDir, currentDepth, maxDepth, pattern, lines) {
+        const entries = await this.fs.readdir(absDir);
+        entries.sort((a, b) => {
+            const ad = a.isDirectory() ? 0 : 1;
+            const bd = b.isDirectory() ? 0 : 1;
+            if (ad !== bd)
+                return ad - bd;
+            return a.name.localeCompare(b.name);
+        });
+        for (const entry of entries) {
+            if (file_utils_1.IGNORE_DIRS.has(entry.name))
+                continue;
+            const indent = '  '.repeat(currentDepth);
+            if (entry.isDirectory()) {
+                const at = lines.push(`${indent}${entry.name}/`) - 1;
+                if (currentDepth < maxDepth) {
+                    try {
+                        await this.walkDir(path.join(absDir, entry.name), currentDepth + 1, maxDepth, pattern, lines);
+                    }
+                    catch {
+                        lines[at] += ' (unreadable)';
+                        continue;
+                    }
+                }
+                if (pattern && lines.length === at + 1)
+                    lines.pop();
+            }
+            else {
+                if (pattern && !entry.name.includes(pattern))
+                    continue;
+                lines.push(`${indent}${entry.name}`);
+            }
+        }
+    }
+}
+exports.WorkspaceFiles = WorkspaceFiles;

package/dist/src/workspace/fs-access.d.ts

@@ -0,0 +1,9 @@
+import * as fs from 'fs';
+export interface WorkspaceFs {
+    realpath(p: string): Promise<string>;
+    stat(p: string): Promise<fs.Stats>;
+    readdir(p: string): Promise<fs.Dirent[]>;
+    createReadStream(p: string): NodeJS.ReadableStream;
+}
+export declare const NODE_FS: WorkspaceFs;
+export declare function errorCode(err: unknown): string;