@aiscene/aiserver 2.0.8 → 2.1.0

package/dist/task/local-code-service.js

@@ -0,0 +1,907 @@
+import { execFile } from 'child_process';
+import { createHash } from 'crypto';
+import fs from 'fs/promises';
+import path from 'path';
+import { promisify } from 'util';
+import { createLogger } from '../core/logger.js';
+const execFileAsync = promisify(execFile);
+const logger = createLogger('LocalCodeService');
+const LOCAL_CODE_CAPABILITIES = [
+    'local_code',
+    'local_git',
+    'local_codegraph',
+    'local_code.open_project',
+    'local_code.list_projects',
+    'local_git.snapshot',
+    'local_code.search',
+    'local_code.read_file',
+    'local_codegraph.build',
+    'local_codegraph.query',
+    'local_codegraph.trace',
+    'local_code_open_project',
+    'local_code_list_projects',
+    'local_git_snapshot',
+    'local_code_search',
+    'local_code_read_file',
+    'local_codegraph_build',
+    'local_codegraph_query',
+    'local_codegraph_trace',
+];
+const EXCLUDED_DIR_NAMES = new Set([
+    '.git',
+    '.hg',
+    '.svn',
+    '.idea',
+    '.vscode',
+    'node_modules',
+    'dist',
+    'build',
+    'coverage',
+    '.next',
+    '.nuxt',
+    '.turbo',
+    '.cache',
+    'target',
+    'out',
+    'vendor',
+    '__pycache__',
+]);
+const TEXT_EXTENSIONS = new Set([
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.cjs',
+    '.vue',
+    '.java',
+    '.kt',
+    '.kts',
+    '.go',
+    '.py',
+    '.rb',
+    '.php',
+    '.rs',
+    '.c',
+    '.cc',
+    '.cpp',
+    '.h',
+    '.hpp',
+    '.cs',
+    '.swift',
+    '.dart',
+    '.json',
+    '.jsonc',
+    '.yaml',
+    '.yml',
+    '.xml',
+    '.html',
+    '.css',
+    '.scss',
+    '.less',
+    '.md',
+    '.mdx',
+    '.txt',
+    '.sql',
+    '.sh',
+    '.bash',
+    '.zsh',
+    '.gradle',
+    '.properties',
+]);
+const EXTENSION_CANDIDATES = [
+    '',
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.cjs',
+    '.vue',
+    '.java',
+    '.kt',
+    '.go',
+    '.py',
+    '.json',
+    '/index.ts',
+    '/index.tsx',
+    '/index.js',
+    '/index.jsx',
+    '/index.vue',
+];
+function getLocalCodeCapabilities() {
+    return [...LOCAL_CODE_CAPABILITIES];
+}
+function normalizeMethod(method) {
+    return method.replace(/\./g, '_');
+}
+function truncateText(value, maxBytes) {
+    const buffer = Buffer.from(value);
+    if (buffer.byteLength <= maxBytes)
+        return value;
+    return `${buffer.subarray(0, maxBytes).toString('utf8')}\n...[truncated ${buffer.byteLength - maxBytes} bytes]`;
+}
+function toPosix(value) {
+    return value.split(path.sep).join('/');
+}
+function unique(values) {
+    return Array.from(new Set(values));
+}
+function normalizeBranchName(value) {
+    return String(value || '')
+        .trim()
+        .replace(/^\*\s*/, '')
+        .replace(/^refs\/heads\//, '')
+        .replace(/^refs\/remotes\//, '')
+        .replace(/^remotes\//, '')
+        .trim();
+}
+function isRealBranchName(value) {
+    return Boolean(value) && value !== 'HEAD' && value !== 'origin' && !/\/HEAD$/.test(value) && !/HEAD\s*->/.test(value);
+}
+function parseBranchRefs(text) {
+    return unique(String(text || '')
+        .split(/\r?\n/)
+        .map(normalizeBranchName)
+        .filter(isRealBranchName));
+}
+export class LocalCodeService {
+    projects = new Map();
+    graphs = new Map();
+    canHandle(method) {
+        return new Set([
+            'local_code_open_project',
+            'local_code_list_projects',
+            'local_git_snapshot',
+            'local_code_search',
+            'local_code_read_file',
+            'local_codegraph_build',
+            'local_codegraph_query',
+            'local_codegraph_trace',
+        ]).has(normalizeMethod(method));
+    }
+    getCapabilities() {
+        return getLocalCodeCapabilities();
+    }
+    async execute(method, params = {}) {
+        switch (normalizeMethod(method)) {
+            case 'local_code_open_project':
+                return this.openProject(params);
+            case 'local_code_list_projects':
+                return this.listProjects(params);
+            case 'local_git_snapshot':
+                return this.gitSnapshot(params);
+            case 'local_code_search':
+                return this.searchCode(params);
+            case 'local_code_read_file':
+                return this.readFile(params);
+            case 'local_codegraph_build':
+                return this.buildCodegraph(params);
+            case 'local_codegraph_query':
+                return this.queryCodegraph(params);
+            case 'local_codegraph_trace':
+                return this.traceCodegraph(params);
+            default:
+                throw new Error(`Unsupported local code method: ${method}`);
+        }
+    }
+    async openProject(params) {
+        const rootPath = await this.resolveDirectory(String(params.path || ''));
+        const name = String(params.projectName || params.project_name || path.basename(rootPath) || 'local-project');
+        const sessionId = stringValue(params.sessionId || params.session_id);
+        const baseBranch = stringValue(params.baseBranch || params.base_branch);
+        const id = this.projectIdFor(rootPath, sessionId);
+        const now = Date.now();
+        const project = {
+            id,
+            name,
+            rootPath,
+            sessionId,
+            baseBranch,
+            createdAt: this.projects.get(id)?.createdAt || now,
+            updatedAt: now,
+        };
+        this.projects.set(id, project);
+        const [tree, git] = await Promise.all([
+            this.buildTree(rootPath, 2, 120),
+            this.getGitSnapshot(project, {
+                includeDiff: false,
+                baseBranch,
+                maxDiffBytes: 60000,
+            }).catch((error) => ({ isGitRepo: false, error: error.message })),
+        ]);
+        logger.info(`Local project opened: id=${id}, path=${rootPath}, sessionId=${sessionId || '-'}`);
+        return {
+            success: true,
+            projectId: id,
+            project_id: id,
+            name,
+            path: rootPath,
+            sessionId,
+            session_id: sessionId,
+            capabilities: this.getCapabilities(),
+            git,
+            tree,
+        };
+    }
+    listProjects(params) {
+        const sessionId = stringValue(params.sessionId || params.session_id);
+        const projects = Array.from(this.projects.values())
+            .filter((project) => !sessionId || project.sessionId === sessionId)
+            .map((project) => ({
+            projectId: project.id,
+            project_id: project.id,
+            name: project.name,
+            path: project.rootPath,
+            sessionId: project.sessionId,
+            session_id: project.sessionId,
+            baseBranch: project.baseBranch,
+            base_branch: project.baseBranch,
+            createdAt: new Date(project.createdAt).toISOString(),
+            updatedAt: new Date(project.updatedAt).toISOString(),
+        }));
+        return { success: true, projects };
+    }
+    async gitSnapshot(params) {
+        const project = await this.resolveProject(params);
+        return this.getGitSnapshot(project, {
+            baseBranch: stringValue(params.baseBranch || params.base_branch || project.baseBranch),
+            includeDiff: params.includeDiff ?? params.include_diff ?? true,
+            maxDiffBytes: numberValue(params.maxDiffBytes || params.max_diff_bytes, 200000),
+        });
+    }
+    async searchCode(params) {
+        const project = await this.resolveProject(params);
+        const query = String(params.query || '').trim();
+        if (!query)
+            throw new Error('query is required');
+        const maxResults = Math.min(numberValue(params.maxResults || params.max_results, 50), 200);
+        const type = String(params.type || 'text');
+        const includeGlobs = stringArray(params.includeGlobs || params.include_globs);
+        const excludeGlobs = stringArray(params.excludeGlobs || params.exclude_globs);
+        const files = await this.collectFiles(project.rootPath, {
+            maxFiles: 20000,
+            includePatterns: includeGlobs,
+            excludePatterns: excludeGlobs,
+        });
+        const regex = type === 'regex' ? new RegExp(query, 'i') : null;
+        const symbolRegex = type === 'symbol' ? new RegExp(`\\b${escapeRegExp(query)}\\b`, 'i') : null;
+        const lowerQuery = query.toLowerCase();
+        const results = [];
+        for (const filePath of files) {
+            if (results.length >= maxResults)
+                break;
+            const content = await this.readSmallTextFile(filePath, 900000).catch(() => '');
+            if (!content)
+                continue;
+            const lines = content.split(/\r?\n/);
+            for (let index = 0; index < lines.length && results.length < maxResults; index += 1) {
+                const line = lines[index];
+                const matched = regex
+                    ? regex.test(line)
+                    : symbolRegex
+                        ? symbolRegex.test(line)
+                        : line.toLowerCase().includes(lowerQuery);
+                if (!matched)
+                    continue;
+                results.push({
+                    filePath: toPosix(path.relative(project.rootPath, filePath)),
+                    file_path: toPosix(path.relative(project.rootPath, filePath)),
+                    line: index + 1,
+                    snippet: line.trim().slice(0, 500),
+                });
+            }
+        }
+        return {
+            success: true,
+            projectId: project.id,
+            project_id: project.id,
+            query,
+            type,
+            total: results.length,
+            truncated: results.length >= maxResults,
+            results,
+        };
+    }
+    async readFile(params) {
+        const project = await this.resolveProject(params);
+        const rawFilePath = String(params.filePath || params.file_path || '');
+        if (!rawFilePath.trim())
+            throw new Error('file_path is required');
+        const filePath = await this.resolveFileInProject(project, rawFilePath);
+        const content = await this.readSmallTextFile(filePath, Math.min(numberValue(params.maxBytes || params.max_bytes, 120000), 500000));
+        const lines = content.split(/\r?\n/);
+        const startLine = Math.max(1, numberValue(params.startLine || params.start_line, 1));
+        const endLine = Math.min(lines.length, numberValue(params.endLine || params.end_line, params.startLine || params.start_line ? startLine + 220 : lines.length));
+        const selected = lines.slice(startLine - 1, endLine);
+        return {
+            success: true,
+            projectId: project.id,
+            project_id: project.id,
+            filePath: toPosix(path.relative(project.rootPath, filePath)),
+            file_path: toPosix(path.relative(project.rootPath, filePath)),
+            absolutePath: filePath,
+            absolute_path: filePath,
+            startLine,
+            start_line: startLine,
+            endLine,
+            end_line: endLine,
+            totalLines: lines.length,
+            total_lines: lines.length,
+            content: selected.join('\n'),
+        };
+    }
+    async buildCodegraph(params) {
+        const project = await this.resolveProject(params);
+        const maxFiles = Math.min(numberValue(params.maxFiles || params.max_files, 6000), 20000);
+        const files = await this.collectFiles(project.rootPath, {
+            maxFiles,
+            includePatterns: stringArray(params.includePatterns || params.include_patterns),
+            excludePatterns: stringArray(params.excludePatterns || params.exclude_patterns),
+        });
+        const graphFiles = [];
+        const skippedCount = Math.max(0, files.length - maxFiles);
+        for (const filePath of files.slice(0, maxFiles)) {
+            const content = await this.readSmallTextFile(filePath, 900000).catch(() => '');
+            if (!content)
+                continue;
+            const relativePath = toPosix(path.relative(project.rootPath, filePath));
+            graphFiles.push({
+                path: relativePath,
+                language: detectLanguage(filePath),
+                lines: content.split(/\r?\n/).length,
+                imports: unique(extractImports(content, filePath)),
+                symbols: unique(extractSymbols(content, filePath)).slice(0, 120),
+            });
+        }
+        const fileSet = new Set(graphFiles.map((file) => file.path));
+        const edges = [];
+        for (const file of graphFiles) {
+            for (const specifier of file.imports) {
+                const resolved = this.resolveImport(project.rootPath, file.path, specifier, fileSet);
+                edges.push({
+                    from: file.path,
+                    to: resolved || `external:${specifier}`,
+                    type: resolved ? 'imports' : 'external',
+                    specifier,
+                });
+            }
+        }
+        const graph = {
+            projectId: project.id,
+            rootPath: project.rootPath,
+            builtAt: Date.now(),
+            fileCount: graphFiles.length,
+            skippedCount,
+            files: graphFiles,
+            edges,
+        };
+        this.graphs.set(project.id, graph);
+        return {
+            success: true,
+            projectId: project.id,
+            project_id: project.id,
+            builtAt: new Date(graph.builtAt).toISOString(),
+            built_at: new Date(graph.builtAt).toISOString(),
+            fileCount: graph.fileCount,
+            file_count: graph.fileCount,
+            skippedCount: graph.skippedCount,
+            skipped_count: graph.skippedCount,
+            edgeCount: graph.edges.length,
+            edge_count: graph.edges.length,
+            topFiles: graph.files.slice(0, 80),
+            top_files: graph.files.slice(0, 80),
+            note: 'Codegraph is stored in local AIServer memory. Query or trace it by project_id.',
+        };
+    }
+    async queryCodegraph(params) {
+        const project = await this.resolveProject(params);
+        const graph = await this.ensureGraph(project, params);
+        const type = String(params.type || 'overview');
+        const query = String(params.query || '').trim().toLowerCase();
+        const maxResults = Math.min(numberValue(params.maxResults || params.max_results, 80), 200);
+        if (type === 'overview') {
+            const languages = countBy(graph.files.map((file) => file.language));
+            const highDegreeFiles = [...graph.files]
+                .map((file) => ({
+                path: file.path,
+                imports: graph.edges.filter((edge) => edge.from === file.path && edge.type === 'imports').length,
+                importedBy: graph.edges.filter((edge) => edge.to === file.path).length,
+                symbols: file.symbols.slice(0, 20),
+            }))
+                .sort((a, b) => b.importedBy + b.imports - (a.importedBy + a.imports))
+                .slice(0, maxResults);
+            return {
+                success: true,
+                projectId: project.id,
+                project_id: project.id,
+                type,
+                fileCount: graph.fileCount,
+                file_count: graph.fileCount,
+                edgeCount: graph.edges.length,
+                edge_count: graph.edges.length,
+                languages,
+                highDegreeFiles,
+                high_degree_files: highDegreeFiles,
+            };
+        }
+        if (type === 'dependency') {
+            const edges = graph.edges
+                .filter((edge) => !query || edge.from.toLowerCase().includes(query) || edge.to.toLowerCase().includes(query) || edge.specifier.toLowerCase().includes(query))
+                .slice(0, maxResults);
+            return { success: true, projectId: project.id, project_id: project.id, type, query, results: edges };
+        }
+        if (type === 'reference') {
+            const results = graph.files
+                .filter((file) => !query || file.imports.some((item) => item.toLowerCase().includes(query)) || file.symbols.some((item) => item.toLowerCase().includes(query)))
+                .slice(0, maxResults);
+            return { success: true, projectId: project.id, project_id: project.id, type, query, results };
+        }
+        const results = graph.files
+            .filter((file) => {
+            if (!query)
+                return true;
+            if (type === 'file')
+                return file.path.toLowerCase().includes(query);
+            if (type === 'symbol')
+                return file.symbols.some((symbol) => symbol.toLowerCase().includes(query));
+            return file.path.toLowerCase().includes(query) || file.symbols.some((symbol) => symbol.toLowerCase().includes(query));
+        })
+            .slice(0, maxResults);
+        return { success: true, projectId: project.id, project_id: project.id, type, query, results };
+    }
+    async traceCodegraph(params) {
+        const project = await this.resolveProject(params);
+        const graph = await this.ensureGraph(project, params);
+        const target = String(params.target || '').trim();
+        if (!target)
+            throw new Error('target is required');
+        const direction = String(params.direction || 'both');
+        const depth = Math.min(numberValue(params.depth, 1), 3);
+        const maxResults = Math.min(numberValue(params.maxResults || params.max_results, 80), 200);
+        const startFiles = this.findTargetFiles(graph, target);
+        const visited = new Set(startFiles);
+        const queue = startFiles.map((file) => ({ file, depth: 0 }));
+        const edges = [];
+        while (queue.length && edges.length < maxResults) {
+            const current = queue.shift();
+            if (current.depth >= depth)
+                continue;
+            const related = graph.edges.filter((edge) => {
+                if (edge.type !== 'imports')
+                    return false;
+                if (direction === 'imports')
+                    return edge.from === current.file;
+                if (direction === 'imported_by')
+                    return edge.to === current.file;
+                if (direction === 'references')
+                    return edge.to === current.file || edge.specifier.includes(target);
+                return edge.from === current.file || edge.to === current.file;
+            });
+            for (const edge of related) {
+                if (edges.length >= maxResults)
+                    break;
+                edges.push(edge);
+                const next = edge.from === current.file ? edge.to : edge.from;
+                if (!visited.has(next)) {
+                    visited.add(next);
+                    queue.push({ file: next, depth: current.depth + 1 });
+                }
+            }
+        }
+        const files = graph.files.filter((file) => visited.has(file.path));
+        return {
+            success: true,
+            projectId: project.id,
+            project_id: project.id,
+            target,
+            direction,
+            depth,
+            startFiles,
+            start_files: startFiles,
+            files,
+            edges,
+            truncated: edges.length >= maxResults,
+        };
+    }
+    async ensureGraph(project, params) {
+        const existing = this.graphs.get(project.id);
+        if (existing)
+            return existing;
+        await this.buildCodegraph({ ...params, projectId: project.id });
+        const built = this.graphs.get(project.id);
+        if (!built)
+            throw new Error('Failed to build local codegraph');
+        return built;
+    }
+    async resolveProject(params) {
+        const projectId = stringValue(params.projectId || params.project_id);
+        if (projectId) {
+            const project = this.projects.get(projectId);
+            if (!project)
+                throw new Error(`Local project not found: ${projectId}. Please call open_local_project first.`);
+            project.updatedAt = Date.now();
+            return project;
+        }
+        const rawPath = stringValue(params.path);
+        if (rawPath) {
+            const rootPath = await this.resolveDirectory(rawPath);
+            const sessionId = stringValue(params.sessionId || params.session_id);
+            const id = this.projectIdFor(rootPath, sessionId);
+            const existing = this.projects.get(id);
+            if (existing) {
+                existing.updatedAt = Date.now();
+                return existing;
+            }
+            await this.openProject({
+                path: rootPath,
+                projectName: params.projectName || params.project_name,
+                baseBranch: params.baseBranch || params.base_branch,
+                sessionId,
+            });
+            return this.projects.get(id);
+        }
+        throw new Error('project_id or path is required');
+    }
+    async resolveDirectory(rawPath) {
+        if (!rawPath.trim())
+            throw new Error('path is required');
+        const resolved = path.resolve(rawPath);
+        const realPath = await fs.realpath(resolved);
+        const stat = await fs.stat(realPath);
+        if (!stat.isDirectory())
+            throw new Error(`Path is not a directory: ${rawPath}`);
+        return realPath;
+    }
+    async resolveFileInProject(project, rawFilePath) {
+        const candidate = path.isAbsolute(rawFilePath)
+            ? path.resolve(rawFilePath)
+            : path.resolve(project.rootPath, rawFilePath);
+        const realPath = await fs.realpath(candidate);
+        this.ensureInsideProject(project.rootPath, realPath);
+        const stat = await fs.stat(realPath);
+        if (!stat.isFile())
+            throw new Error(`Path is not a file: ${rawFilePath}`);
+        return realPath;
+    }
+    ensureInsideProject(rootPath, candidate) {
+        const relative = path.relative(rootPath, candidate);
+        if (relative === '')
+            return;
+        if (relative.startsWith('..') || path.isAbsolute(relative)) {
+            throw new Error('Requested path is outside of the opened local project');
+        }
+    }
+    projectIdFor(rootPath, sessionId) {
+        const hash = createHash('sha1').update(`${sessionId || 'global'}:${rootPath}`).digest('hex').slice(0, 12);
+        return `local_${hash}`;
+    }
+    async getGitSnapshot(project, options) {
+        const root = project.rootPath;
+        const insideWorkTree = await this.gitOutput(root, ['rev-parse', '--is-inside-work-tree']).catch(() => '');
+        if (insideWorkTree.trim() !== 'true') {
+            return { success: true, isGitRepo: false, is_git_repo: false, path: root };
+        }
+        const [branch, head, statusText, localBranchesText, remoteBranchesText, defaultRemoteRef] = await Promise.all([
+            this.gitOutput(root, ['rev-parse', '--abbrev-ref', 'HEAD']).catch(() => ''),
+            this.gitOutput(root, ['rev-parse', '--short', 'HEAD']).catch(() => ''),
+            this.gitOutput(root, ['status', '--porcelain=v1']).catch(() => ''),
+            this.gitOutput(root, ['for-each-ref', '--format=%(refname:short)', 'refs/heads'], 4 * 1024 * 1024).catch(() => ''),
+            this.gitOutput(root, ['for-each-ref', '--format=%(refname:short)', 'refs/remotes'], 4 * 1024 * 1024).catch(() => ''),
+            this.gitOutput(root, ['symbolic-ref', '--quiet', '--short', 'refs/remotes/origin/HEAD']).catch(() => ''),
+        ]);
+        const currentBranch = normalizeBranchName(branch);
+        const localBranches = unique([
+            ...parseBranchRefs(localBranchesText),
+            currentBranch,
+        ].filter(isRealBranchName));
+        const remoteBranches = parseBranchRefs(remoteBranchesText);
+        const branches = unique([...localBranches, ...remoteBranches]);
+        const defaultRemoteBranch = normalizeBranchName(defaultRemoteRef).replace(/\/HEAD$/, '');
+        const baseBranch = options.baseBranch || defaultRemoteBranch || await this.detectBaseBranch(root);
+        const changedFiles = parseGitStatus(statusText);
+        const result = {
+            success: true,
+            isGitRepo: true,
+            is_git_repo: true,
+            path: root,
+            projectId: project.id,
+            project_id: project.id,
+            branch: currentBranch || undefined,
+            currentBranch: currentBranch || undefined,
+            current_branch: currentBranch || undefined,
+            head: head.trim() || undefined,
+            baseBranch,
+            base_branch: baseBranch,
+            defaultBranch: defaultRemoteBranch || undefined,
+            default_branch: defaultRemoteBranch || undefined,
+            branches,
+            branchList: branches,
+            branch_list: branches,
+            allBranches: branches,
+            all_branches: branches,
+            localBranches,
+            local_branches: localBranches,
+            remoteBranches,
+            remote_branches: remoteBranches,
+            changedFiles,
+            changed_files: changedFiles,
+            status: statusText.trim(),
+        };
+        if (baseBranch) {
+            const mergeBase = await this.gitOutput(root, ['merge-base', 'HEAD', baseBranch]).catch(() => '');
+            if (mergeBase.trim()) {
+                const filesAgainstBase = await this.gitOutput(root, ['diff', '--name-status', mergeBase.trim(), 'HEAD']).catch(() => '');
+                result.committedChangedFiles = parseNameStatus(filesAgainstBase);
+                result.committed_changed_files = result.committedChangedFiles;
+            }
+        }
+        if (options.includeDiff !== false) {
+            const diffArgs = baseBranch
+                ? ['diff', '--stat', baseBranch, 'HEAD']
+                : ['diff', '--stat'];
+            const patchArgs = baseBranch
+                ? ['diff', baseBranch, 'HEAD']
+                : ['diff'];
+            result.diffStat = await this.gitOutput(root, diffArgs).catch(() => '');
+            result.diff_stat = result.diffStat;
+            result.diff = truncateText(await this.gitOutput(root, patchArgs, options.maxDiffBytes || 200000).catch(() => ''), options.maxDiffBytes || 200000);
+            result.diffTruncated = Buffer.byteLength(result.diff || '') >= (options.maxDiffBytes || 200000);
+            result.diff_truncated = result.diffTruncated;
+        }
+        return result;
+    }
+    async detectBaseBranch(rootPath) {
+        const candidates = ['origin/master', 'master', 'origin/main', 'main', 'origin/develop', 'develop'];
+        for (const candidate of candidates) {
+            const exists = await this.gitOutput(rootPath, ['rev-parse', '--verify', candidate]).then(() => true).catch(() => false);
+            if (exists)
+                return candidate;
+        }
+        return undefined;
+    }
+    async gitOutput(rootPath, args, maxBuffer = 1024 * 1024) {
+        const { stdout } = await execFileAsync('git', ['-C', rootPath, ...args], {
+            timeout: 30000,
+            maxBuffer,
+            env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+        });
+        return String(stdout || '');
+    }
+    async collectFiles(rootPath, options) {
+        const results = [];
+        await this.walk(rootPath, rootPath, results, options);
+        return results;
+    }
+    async walk(rootPath, currentPath, results, options) {
+        if (results.length >= options.maxFiles)
+            return;
+        const entries = await fs.readdir(currentPath, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            if (results.length >= options.maxFiles)
+                break;
+            if (entry.name.startsWith('.') && entry.name !== '.env.example') {
+                if (entry.isDirectory() || EXCLUDED_DIR_NAMES.has(entry.name))
+                    continue;
+            }
+            const absolutePath = path.join(currentPath, entry.name);
+            const relativePath = toPosix(path.relative(rootPath, absolutePath));
+            if (entry.isDirectory()) {
+                if (EXCLUDED_DIR_NAMES.has(entry.name) || this.matchesAny(relativePath, options.excludePatterns || []))
+                    continue;
+                await this.walk(rootPath, absolutePath, results, options);
+            }
+            else if (entry.isFile()) {
+                if (!this.isTextLike(absolutePath))
+                    continue;
+                if (options.includePatterns?.length && !this.matchesAny(relativePath, options.includePatterns))
+                    continue;
+                if (this.matchesAny(relativePath, options.excludePatterns || []))
+                    continue;
+                results.push(absolutePath);
+            }
+        }
+    }
+    isTextLike(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        if (TEXT_EXTENSIONS.has(ext))
+            return true;
+        const base = path.basename(filePath).toLowerCase();
+        return ['dockerfile', 'makefile', 'gradlew', 'pom.xml'].includes(base);
+    }
+    async readSmallTextFile(filePath, maxBytes) {
+        const stat = await fs.stat(filePath);
+        if (stat.size > maxBytes) {
+            const handle = await fs.open(filePath, 'r');
+            try {
+                const buffer = Buffer.alloc(maxBytes);
+                const { bytesRead } = await handle.read(buffer, 0, maxBytes, 0);
+                return `${buffer.subarray(0, bytesRead).toString('utf8')}\n...[truncated ${stat.size - bytesRead} bytes]`;
+            }
+            finally {
+                await handle.close();
+            }
+        }
+        return fs.readFile(filePath, 'utf8');
+    }
+    async buildTree(rootPath, maxDepth, maxEntries) {
+        const entries = [];
+        await this.appendTree(rootPath, rootPath, entries, 0, maxDepth, maxEntries);
+        return entries;
+    }
+    async appendTree(rootPath, currentPath, entries, depth, maxDepth, maxEntries) {
+        if (entries.length >= maxEntries || depth > maxDepth)
+            return;
+        const dirents = await fs.readdir(currentPath, { withFileTypes: true }).catch(() => []);
+        for (const dirent of dirents) {
+            if (entries.length >= maxEntries)
+                break;
+            if (EXCLUDED_DIR_NAMES.has(dirent.name))
+                continue;
+            if (dirent.name.startsWith('.') && dirent.name !== '.env.example')
+                continue;
+            const absolutePath = path.join(currentPath, dirent.name);
+            entries.push({
+                path: toPosix(path.relative(rootPath, absolutePath)),
+                type: dirent.isDirectory() ? 'directory' : 'file',
+            });
+            if (dirent.isDirectory()) {
+                await this.appendTree(rootPath, absolutePath, entries, depth + 1, maxDepth, maxEntries);
+            }
+        }
+    }
+    resolveImport(rootPath, fromRelativePath, specifier, fileSet) {
+        if (!specifier.startsWith('.'))
+            return null;
+        const fromDir = path.dirname(path.resolve(rootPath, fromRelativePath));
+        const basePath = path.resolve(fromDir, specifier);
+        for (const suffix of EXTENSION_CANDIDATES) {
+            const relative = toPosix(path.relative(rootPath, `${basePath}${suffix}`));
+            if (fileSet.has(relative))
+                return relative;
+        }
+        return null;
+    }
+    findTargetFiles(graph, target) {
+        const lower = target.toLowerCase();
+        const matches = graph.files
+            .filter((file) => (file.path.toLowerCase() === lower ||
+            file.path.toLowerCase().endsWith(lower) ||
+            file.path.toLowerCase().includes(lower) ||
+            file.symbols.some((symbol) => symbol.toLowerCase().includes(lower))))
+            .map((file) => file.path);
+        return matches.slice(0, 20);
+    }
+    matchesAny(relativePath, patterns) {
+        return patterns.some((pattern) => globToRegExp(pattern).test(relativePath));
+    }
+}
+export const localCodeService = new LocalCodeService();
+export function localCodeCapabilities() {
+    return localCodeService.getCapabilities();
+}
+function stringValue(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    const text = String(value).trim();
+    return text || undefined;
+}
+function numberValue(value, fallback) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : fallback;
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.map((item) => String(item)).filter(Boolean) : [];
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function globToRegExp(pattern) {
+    const escaped = pattern
+        .split('*')
+        .map((part) => escapeRegExp(part))
+        .join('.*')
+        .replace(/\.\\\*\\\*\/?/g, '(?:.*/)?');
+    return new RegExp(`^${escaped}$`);
+}
+function detectLanguage(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const map = {
+        '.ts': 'typescript',
+        '.tsx': 'typescript-react',
+        '.js': 'javascript',
+        '.jsx': 'javascript-react',
+        '.vue': 'vue',
+        '.java': 'java',
+        '.kt': 'kotlin',
+        '.go': 'go',
+        '.py': 'python',
+        '.rb': 'ruby',
+        '.php': 'php',
+        '.rs': 'rust',
+        '.cs': 'csharp',
+        '.swift': 'swift',
+        '.dart': 'dart',
+    };
+    return map[ext] || ext.replace('.', '') || 'text';
+}
+function extractImports(content, filePath) {
+    const imports = [];
+    const ext = path.extname(filePath).toLowerCase();
+    const patterns = [
+        /\bimport\s+(?:type\s+)?(?:[^'"]+\s+from\s+)?['"]([^'"]+)['"]/g,
+        /\bexport\s+[^'"]+\s+from\s+['"]([^'"]+)['"]/g,
+        /\brequire\(\s*['"]([^'"]+)['"]\s*\)/g,
+        /\bimport\(\s*['"]([^'"]+)['"]\s*\)/g,
+    ];
+    if (['.py'].includes(ext)) {
+        patterns.push(/^\s*from\s+([A-Za-z0-9_.$]+)\s+import\s+/gm, /^\s*import\s+([A-Za-z0-9_.$]+)/gm);
+    }
+    if (['.java', '.kt'].includes(ext)) {
+        patterns.push(/^\s*import\s+(?:static\s+)?([A-Za-z0-9_.*]+);?/gm);
+    }
+    if (['.go'].includes(ext)) {
+        patterns.push(/^\s*import\s+(?:\(\s*)?["`]([^"`]+)["`]/gm);
+    }
+    for (const pattern of patterns) {
+        for (const match of content.matchAll(pattern)) {
+            if (match[1])
+                imports.push(match[1]);
+        }
+    }
+    return imports;
+}
+function extractSymbols(content, filePath) {
+    const symbols = [];
+    const ext = path.extname(filePath).toLowerCase();
+    const patterns = [
+        /\b(?:export\s+)?(?:default\s+)?class\s+([A-Za-z_$][\w$]*)/g,
+        /\b(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)/g,
+        /\b(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=/g,
+        /\b(?:export\s+)?interface\s+([A-Za-z_$][\w$]*)/g,
+        /\b(?:export\s+)?type\s+([A-Za-z_$][\w$]*)\s*=/g,
+    ];
+    if (['.java', '.kt', '.cs'].includes(ext)) {
+        patterns.push(/\b(?:public|private|protected|internal)?\s*(?:class|interface|enum)\s+([A-Za-z_$][\w$]*)/g);
+    }
+    if (ext === '.py') {
+        patterns.push(/^\s*(?:async\s+)?def\s+([A-Za-z_][\w]*)\s*\(/gm, /^\s*class\s+([A-Za-z_][\w]*)\s*[:(]/gm);
+    }
+    if (ext === '.go') {
+        patterns.push(/\bfunc\s+(?:\([^)]+\)\s*)?([A-Za-z_][\w]*)\s*\(/g, /\btype\s+([A-Za-z_][\w]*)\s+(?:struct|interface)/g);
+    }
+    for (const pattern of patterns) {
+        for (const match of content.matchAll(pattern)) {
+            if (match[1])
+                symbols.push(match[1]);
+        }
+    }
+    return symbols;
+}
+function parseGitStatus(statusText) {
+    return statusText
+        .split(/\r?\n/)
+        .map((line) => line.trimEnd())
+        .filter(Boolean)
+        .map((line) => ({
+        status: line.slice(0, 2).trim(),
+        path: line.slice(3),
+    }));
+}
+function parseNameStatus(text) {
+    return text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => {
+        const [status, ...rest] = line.split(/\s+/);
+        return { status, path: rest.join(' ') };
+    });
+}
+function countBy(values) {
+    return values.reduce((acc, value) => {
+        acc[value] = (acc[value] || 0) + 1;
+        return acc;
+    }, {});
+}
+//# sourceMappingURL=local-code-service.js.map