codesearch-mcp 0.3.0-alpha → 0.4.0-alpha

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;

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;
+}