@thegitai/cli 1.0.0-preview.27 → 1.0.0-preview.29

package/dist/src/tools/code-intel.js

@@ -1,472 +0,0 @@
-import { execFile } from 'node:child_process';
-import { readdirSync, readFileSync, statSync } from 'node:fs';
-import path from 'node:path';
-import { promisify } from 'node:util';
-import { ALWAYS_IGNORE_DIRS, listProjectFiles as listScannerProjectFiles, shouldIgnorePath, } from '../scanner.js';
-import { normalizeProjectRelativePath } from '../artifact-policy.js';
-import { getRipgrepPathCandidates, isRipgrepExecutionUnavailable, } from './ripgrep.js';
-import { getCommandExitCode } from './exec-utils.js';
-const MAX_RIPGREP_BUFFER = 2 * 1024 * 1024;
-const MAX_RIPGREP_TIMEOUT_MS = 10000;
-const DEFAULT_PROJECT_FILE_LIMIT = 400;
-const MAX_FALLBACK_FILES_TO_SCAN = 2000;
-const execFileAsync = promisify(execFile);
-const SOURCE_FILE_EXTENSIONS = new Set([
-    '.c',
-    '.cc',
-    '.cpp',
-    '.cs',
-    '.css',
-    '.cts',
-    '.cxx',
-    '.go',
-    '.h',
-    '.hpp',
-    '.html',
-    '.java',
-    '.js',
-    '.jsx',
-    '.kt',
-    '.kts',
-    '.m',
-    '.mjml',
-    '.mm',
-    '.mts',
-    '.php',
-    '.py',
-    '.rb',
-    '.rs',
-    '.swift',
-    '.ts',
-    '.tsx',
-    '.vue',
-]);
-const DEF_KEYWORDS = [
-    'def ',
-    'async def ',
-    'function ',
-    'async function ',
-    'class ',
-    'const ',
-    'let ',
-    'var ',
-    'interface ',
-    'type ',
-    'fn ',
-    'func ',
-    'pub fn ',
-    'pub async fn ',
-    'export function ',
-    'export async function ',
-    'export const ',
-    'export class ',
-    'export interface ',
-    'export type ',
-    'export default function ',
-    'export default class ',
-    'struct ',
-    'pub struct ',
-    'enum ',
-    'pub enum ',
-    'trait ',
-    'pub trait ',
-    'impl ',
-    'pub mod ',
-    'mod ',
-];
-const SYMBOL_PATTERNS = [
-    {
-        regex: /^\s*(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/,
-        kind: 'function',
-        nameGroup: 1,
-    },
-    { regex: /^\s*(?:pub\s+)?struct\s+(\w+)/, kind: 'struct', nameGroup: 1 },
-    { regex: /^\s*(?:pub\s+)?enum\s+(\w+)/, kind: 'enum', nameGroup: 1 },
-    { regex: /^\s*(?:pub\s+)?trait\s+(\w+)/, kind: 'interface', nameGroup: 1 },
-    { regex: /^\s*(?:pub\s+)?type\s+(\w+)/, kind: 'type', nameGroup: 1 },
-    {
-        regex: /^\s*(?:pub\s+)?(?:static|const)\s+(\w+)\s*:/,
-        kind: 'constant',
-        nameGroup: 1,
-    },
-    { regex: /^\s*impl(?:<[^>]*>)?\s+(\w+)/, kind: 'class', nameGroup: 1 },
-    { regex: /^\s*(?:pub\s+)?mod\s+(\w+)/, kind: 'module', nameGroup: 1 },
-    { regex: /^func\s+(?:\([^)]+\)\s+)?(\w+)/, kind: 'function', nameGroup: 1 },
-    { regex: /^type\s+(\w+)\s+struct\b/, kind: 'struct', nameGroup: 1 },
-    { regex: /^type\s+(\w+)\s+interface\b/, kind: 'interface', nameGroup: 1 },
-    { regex: /^type\s+(\w+)\b/, kind: 'type', nameGroup: 1 },
-    { regex: /^var\s+(\w+)\b/, kind: 'variable', nameGroup: 1 },
-    { regex: /^const\s+(\w+)\b/, kind: 'constant', nameGroup: 1 },
-    { regex: /^\s*(?:async\s+)?def\s+(\w+)/, kind: 'function', nameGroup: 1 },
-    { regex: /^\s*class\s+(\w+)/, kind: 'class', nameGroup: 1 },
-    {
-        regex: /^\s*(?:export\s+)?(?:default\s+)?(?:abstract\s+)?class\s+(\w+)/,
-        kind: 'class',
-        nameGroup: 1,
-    },
-    {
-        regex: /^\s*(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s*\*?\s+(\w+)/,
-        kind: 'function',
-        nameGroup: 1,
-    },
-    {
-        regex: /^\s*(?:export\s+)?interface\s+(\w+)/,
-        kind: 'interface',
-        nameGroup: 1,
-    },
-    {
-        regex: /^\s*(?:export\s+)?type\s+(\w+)\s*[<=]/,
-        kind: 'type',
-        nameGroup: 1,
-    },
-    {
-        regex: /^\s*(?:export\s+)?(?:const|let|var)\s+(\w+)\s*(?::\s*\S+\s*)?=\s*(?:async\s+)?(?:\([^)]*\)|[^=])\s*=>/,
-        kind: 'function',
-        nameGroup: 1,
-    },
-    {
-        regex: /^\s*(?:export\s+)?const\s+(\w+)\s*[=:]/,
-        kind: 'constant',
-        nameGroup: 1,
-    },
-    {
-        regex: /^\s*(?:export\s+)?(?:let|var)\s+(\w+)\b/,
-        kind: 'variable',
-        nameGroup: 1,
-    },
-    { regex: /^\s*(?:export\s+)?enum\s+(\w+)/, kind: 'enum', nameGroup: 1 },
-];
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-function isLikelySourceFile(filePath) {
-    return SOURCE_FILE_EXTENSIONS.has(path.extname(filePath).toLowerCase());
-}
-export function normalizeProjectFilePath(rootDir, filePath) {
-    if (!filePath)
-        return filePath;
-    const relativePath = normalizeProjectRelativePath(rootDir, filePath);
-    return relativePath ?? filePath.replace(/\\/g, '/').replace(/^\.\//, '');
-}
-export function readProjectText(rootDir, filePath) {
-    const normalizedPath = normalizeProjectRelativePath(rootDir, filePath);
-    if (!normalizedPath) {
-        throw Error(`Refusing to access path outside the project root: ${filePath}`);
-    }
-    if (shouldIgnorePath(normalizedPath)) {
-        throw Error(`Ignored artifact paths are off-limits: ${normalizedPath}`);
-    }
-    const fullPath = path.join(rootDir, normalizedPath);
-    return readFileSync(fullPath, 'utf8');
-}
-export function extractIdentifierAtPosition(content, line, column) {
-    const lines = content.split(/\r?\n/);
-    if (line < 1 || line > lines.length)
-        return null;
-    const text = (lines[line - 1] ?? '').replace(/\r$/, '');
-    if (column < 1 || column > text.length + 1)
-        return null;
-    const index = column - 1;
-    const identifierChar = /[\w$]/;
-    if (!identifierChar.test(text[index] ?? ''))
-        return null;
-    let start = index;
-    let end = index;
-    while (start > 0 && identifierChar.test(text[start - 1] ?? ''))
-        start--;
-    while (end < text.length - 1 && identifierChar.test(text[end + 1] ?? ''))
-        end++;
-    const symbol = text.slice(start, end + 1).trim();
-    return symbol || null;
-}
-export function isDefinitionLine(line, symbol) {
-    const trimmed = line.trim();
-    if (/^(\/\/|#|\/\*|\*)/.test(trimmed))
-        return false;
-    for (const keyword of DEF_KEYWORDS) {
-        const index = trimmed.indexOf(keyword);
-        if (index === -1)
-            continue;
-        const before = trimmed.slice(0, index);
-        if (before.length > 0 && !/^[a-zA-Z0-9_$\s]*$/.test(before))
-            continue;
-        const after = trimmed.slice(index + keyword.length).trimStart();
-        if (!after.startsWith(symbol))
-            continue;
-        const nextChar = after[symbol.length];
-        if (!nextChar || /[\s(<:{=[]/.test(nextChar)) {
-            return true;
-        }
-    }
-    return false;
-}
-export function buildIgnoreArgs() {
-    const args = [];
-    for (const dir of ALWAYS_IGNORE_DIRS) {
-        args.push('--glob', `!${dir}`, '--glob', `!**/${dir}/**`);
-    }
-    return args;
-}
-async function runRipgrep(rootDir, args) {
-    let unavailableError = null;
-    for (const candidate of getRipgrepPathCandidates()) {
-        try {
-            const { stdout } = await execFileAsync(candidate, args, {
-                cwd: rootDir,
-                encoding: 'utf-8',
-                maxBuffer: MAX_RIPGREP_BUFFER,
-                timeout: MAX_RIPGREP_TIMEOUT_MS,
-            });
-            return String(stdout ?? '');
-        }
-        catch (error) {
-            if (getCommandExitCode(error) === 1) {
-                return '';
-            }
-            if (!isRipgrepExecutionUnavailable(error)) {
-                throw error;
-            }
-            unavailableError = error;
-        }
-    }
-    if (unavailableError) {
-        return null;
-    }
-    return null;
-}
-function collectRelativeFilesUnder(rootDir, dirRel, out, maxFiles) {
-    if (out.length >= maxFiles)
-        return;
-    const absDir = path.join(rootDir, dirRel);
-    let entries;
-    try {
-        entries = readdirSync(absDir, { withFileTypes: true });
-    }
-    catch {
-        return;
-    }
-    for (const ent of entries) {
-        if (out.length >= maxFiles)
-            return;
-        const name = String(ent.name);
-        const rel = dirRel ? path.join(dirRel, name) : name;
-        const relPosix = rel.split(path.sep).join('/');
-        if (shouldIgnorePath(relPosix))
-            continue;
-        if (ent.isDirectory()) {
-            collectRelativeFilesUnder(rootDir, rel, out, maxFiles);
-        }
-        else if (ent.isFile()) {
-            out.push(relPosix);
-        }
-    }
-}
-function listRelativePathsForTextSearch(rootDir, targetRel) {
-    const absTarget = path.join(rootDir, targetRel);
-    let stat;
-    try {
-        stat = statSync(absTarget);
-    }
-    catch {
-        return [];
-    }
-    const out = [];
-    if (stat.isFile()) {
-        if (!shouldIgnorePath(normalizeProjectFilePath(rootDir, targetRel))) {
-            out.push(normalizeProjectFilePath(rootDir, targetRel));
-        }
-        return out;
-    }
-    if (stat.isDirectory()) {
-        collectRelativeFilesUnder(rootDir, targetRel === '.' ? '' : targetRel, out, MAX_FALLBACK_FILES_TO_SCAN);
-    }
-    return out;
-}
-function searchTextMatchesWithoutRipgrep(rootDir, searchTerm, options = {}) {
-    const target = options.filePath
-        ? normalizeProjectFilePath(rootDir, options.filePath)
-        : '.';
-    const limit = Math.max(1, Math.min(Number(options.limit ?? 80), 200));
-    const wordPattern = new RegExp(`\\b${escapeRegExp(searchTerm)}\\b`);
-    const files = listRelativePathsForTextSearch(rootDir, target);
-    const results = [];
-    for (const rel of files) {
-        if (results.length >= limit)
-            break;
-        let content;
-        try {
-            content = readFileSync(path.join(rootDir, rel), 'utf8');
-        }
-        catch {
-            continue;
-        }
-        const lines = content.split(/\r?\n/);
-        for (let i = 0; i < lines.length; i++) {
-            if (results.length >= limit)
-                break;
-            const line = lines[i] ?? '';
-            if (wordPattern.test(line)) {
-                results.push({
-                    filePath: normalizeProjectFilePath(rootDir, rel),
-                    line: i + 1,
-                    content: line,
-                });
-            }
-        }
-    }
-    return results.slice(0, limit);
-}
-function parseTextSearchMatch(rootDir, line) {
-    const match = line.match(/^(.+?):(\d+):(.*)$/);
-    if (!match)
-        return null;
-    return {
-        filePath: normalizeProjectFilePath(rootDir, match[1] ?? ''),
-        line: parseInt(match[2] ?? '1', 10),
-        content: match[3] ?? '',
-    };
-}
-export async function searchTextMatches(rootDir, searchTerm, options = {}) {
-    const target = options.filePath
-        ? normalizeProjectFilePath(rootDir, options.filePath)
-        : '.';
-    const limit = Math.max(1, Math.min(Number(options.limit ?? 80), 200));
-    const raw = await runRipgrep(rootDir, [
-        '-n',
-        '--no-heading',
-        '--color',
-        'never',
-        '--word-regexp',
-        '--fixed-strings',
-        ...buildIgnoreArgs(),
-        '-m',
-        String(limit),
-        '--',
-        searchTerm,
-        target,
-    ]);
-    if (raw === null) {
-        return searchTextMatchesWithoutRipgrep(rootDir, searchTerm, options);
-    }
-    return raw
-        .trim()
-        .split('\n')
-        .filter(Boolean)
-        .map((line) => parseTextSearchMatch(rootDir, line))
-        .filter((match) => match != null)
-        .slice(0, limit);
-}
-export async function searchSymbolOccurrences(rootDir, symbol, options = {}) {
-    const limit = Math.max(1, Math.min(Number(options.limit ?? 80), 200));
-    const matches = await searchTextMatches(rootDir, symbol, options);
-    const wordPattern = new RegExp(`\\b${escapeRegExp(symbol)}\\b`);
-    return matches
-        .map((match) => {
-        const filePath = match.filePath;
-        const startLine = match.line;
-        const content = match.content;
-        const columnMatch = content.match(wordPattern);
-        const startColumn = columnMatch?.index != null ? columnMatch.index + 1 : 1;
-        return {
-            filePath,
-            content,
-            startLine,
-            startColumn,
-            endLine: startLine,
-            endColumn: startColumn + symbol.length,
-        };
-    })
-        .slice(0, limit);
-}
-export function expandContext(rootDir, filePath, startLine, maxLines = 35) {
-    try {
-        const lines = readProjectText(rootDir, filePath).split('\n');
-        const start = Math.max(0, startLine - 1);
-        const end = Math.min(lines.length, start + maxLines);
-        return lines
-            .slice(start, end)
-            .map((line, index) => `${start + index + 1}: ${line}`)
-            .join('\n');
-    }
-    catch {
-        return '';
-    }
-}
-export function extractSymbolsFromFile(rootDir, filePath, query, limit = 40) {
-    let content;
-    try {
-        content = readProjectText(rootDir, filePath);
-    }
-    catch {
-        return [];
-    }
-    const lines = content.split('\n');
-    const symbols = [];
-    const seen = new Set();
-    const normalizedPath = normalizeProjectFilePath(rootDir, filePath);
-    for (let index = 0; index < lines.length; index++) {
-        const line = lines[index] ?? '';
-        const trimmed = line.trim();
-        if (trimmed.startsWith('//') ||
-            trimmed.startsWith('#') ||
-            trimmed.startsWith('/*') ||
-            trimmed.startsWith('*')) {
-            continue;
-        }
-        for (const pattern of SYMBOL_PATTERNS) {
-            const match = line.match(pattern.regex);
-            if (!match)
-                continue;
-            const name = match[pattern.nameGroup];
-            if (!name || name === '_' || name === 'self')
-                continue;
-            if (query && !name.toLowerCase().includes(query.toLowerCase()))
-                continue;
-            const key = `${pattern.kind}:${name}:${index + 1}`;
-            if (seen.has(key))
-                continue;
-            seen.add(key);
-            const startColumn = line.indexOf(name) + 1;
-            symbols.push({
-                name,
-                kind: pattern.kind,
-                filePath: normalizedPath,
-                startLine: index + 1,
-                startColumn,
-                endLine: index + 1,
-                endColumn: startColumn + name.length,
-                selectionLine: index + 1,
-                selectionColumn: startColumn,
-                searchSource: 'regex',
-            });
-            if (symbols.length >= limit) {
-                return symbols;
-            }
-            break;
-        }
-    }
-    return symbols;
-}
-export async function listProjectFiles(rootDir, options = {}) {
-    const limit = Math.max(1, Math.min(Number(options.limit ?? DEFAULT_PROJECT_FILE_LIMIT), 2000));
-    try {
-        const raw = await runRipgrep(rootDir, ['--files', ...buildIgnoreArgs()]);
-        if (raw === null) {
-            const scanned = listScannerProjectFiles(rootDir, { limit });
-            return scanned
-                .map((filePath) => filePath.split(path.sep).join('/'))
-                .filter((filePath) => !options.sourceOnly || isLikelySourceFile(filePath))
-                .slice(0, limit);
-        }
-        const files = raw
-            .split('\n')
-            .map((line) => line.trim())
-            .filter(Boolean)
-            .filter((filePath) => !options.sourceOnly || isLikelySourceFile(filePath));
-        return files.slice(0, limit);
-    }
-    catch (error) {
-        console.warn(`[code-intel] Failed to list project files: ${error?.message ?? String(error)}`);
-        return [];
-    }
-}

package/dist/src/tools/find-symbol.js

@@ -1,70 +0,0 @@
-import { expandContext, extractIdentifierAtPosition, isDefinitionLine, readProjectText, searchSymbolOccurrences, } from './code-intel.js';
-const MAX_CONTEXT_LINES = 35;
-const MAX_REFS = 30;
-const MAX_OUTPUT_CHARS = 8000;
-async function fallbackFindSymbol(rootDir, args) {
-    const symbol = resolveRequestedSymbol(rootDir, args);
-    if (!symbol)
-        return {
-            ok: false,
-            error: 'symbol or filePath + line + column is required',
-        };
-    const all = await searchSymbolOccurrences(rootDir, symbol, { limit: 80 });
-    const defs = all.filter((hit) => isDefinitionLine(hit.content, symbol));
-    const defKeys = new Set(defs.map((definition) => `${definition.filePath}:${definition.startLine}`));
-    const refs = args.includeReferences !== false
-        ? all.filter((hit) => !defKeys.has(`${hit.filePath}:${hit.startLine}`))
-        : [];
-    const sections = [];
-    if (defs.length === 0) {
-        sections.push(`No definition found for "${symbol}". Showing all occurrences as references.`);
-        for (const r of all.slice(0, MAX_REFS)) {
-            sections.push(`- ${r.filePath}:${r.startLine}: ${r.content.trim()}`);
-        }
-    }
-    else {
-        sections.push(`## Definitions (${defs.length})`);
-        for (const def of defs) {
-            sections.push(`\n### ${def.filePath}:${def.startLine}\n\`\`\`\n${expandContext(rootDir, def.filePath, def.startLine, MAX_CONTEXT_LINES)}\n\`\`\``);
-        }
-    }
-    if (refs.length > 0) {
-        const shown = refs.slice(0, MAX_REFS);
-        sections.push(`\n## References (${refs.length} total, showing ${shown.length})`);
-        for (const r of shown)
-            sections.push(`- ${r.filePath}:${r.startLine}: ${r.content.trim()}`);
-    }
-    const output = sections.join('\n');
-    return {
-        ok: true,
-        provider: 'text_search',
-        symbol,
-        definitions: defs,
-        references: refs,
-        definitionCount: defs.length,
-        referenceCount: refs.length,
-        output: output.length > MAX_OUTPUT_CHARS
-            ? `${output.slice(0, MAX_OUTPUT_CHARS)}\n...(truncated)`
-            : output,
-    };
-}
-export async function findSymbol(context, args) {
-    return fallbackFindSymbol(context.rootDir, args);
-}
-function resolveRequestedSymbol(rootDir, args) {
-    const symbol = String(args.symbol ?? '').trim();
-    if (symbol)
-        return symbol;
-    const filePath = String(args.filePath ?? '').trim();
-    const line = Number(args.line ?? 0);
-    const column = Number(args.column ?? 0);
-    if (!filePath || !line || !column)
-        return '';
-    try {
-        const content = readProjectText(rootDir, filePath);
-        return extractIdentifierAtPosition(content, line, column) ?? '';
-    }
-    catch {
-        return '';
-    }
-}

package/dist/src/tools/hover-symbol.js

@@ -1,95 +0,0 @@
-import { extractIdentifierAtPosition, isDefinitionLine, readProjectText, searchTextMatches, } from './code-intel.js';
-const MAX_CONTEXT_LINES = 15;
-const MAX_OUTPUT_CHARS = 4000;
-async function findDefinitionContext(rootDir, symbol) {
-    const matches = await searchTextMatches(rootDir, symbol, { limit: 40 });
-    for (const match of matches) {
-        if (!isDefinitionLine(match.content, symbol))
-            continue;
-        return extractDefinitionBlock(rootDir, match.filePath, match.line, symbol);
-    }
-    return null;
-}
-function extractDefinitionBlock(rootDir, filePath, lineNum, symbol) {
-    let fileContent;
-    try {
-        fileContent = readProjectText(rootDir, filePath);
-    }
-    catch {
-        return null;
-    }
-    const lines = fileContent.split('\n');
-    const defIdx = lineNum - 1;
-    let start = defIdx;
-    while (start > 0) {
-        const prev = lines[start - 1].trim();
-        if (prev.startsWith('///') ||
-            prev.startsWith('//!') ||
-            prev.startsWith('#[') ||
-            prev.startsWith('#![') ||
-            prev.startsWith('#') ||
-            prev.startsWith('@') ||
-            prev.startsWith('/**') ||
-            prev.startsWith('*') ||
-            prev.startsWith('//') ||
-            prev === '') {
-            if (prev === '' && start > 1) {
-                const prevPrev = lines[start - 2].trim();
-                if (!prevPrev.startsWith('//') &&
-                    !prevPrev.startsWith('*') &&
-                    !prevPrev.startsWith('#') &&
-                    !prevPrev.startsWith('@'))
-                    break;
-            }
-            start--;
-        }
-        else {
-            break;
-        }
-    }
-    const end = Math.min(lines.length, defIdx + MAX_CONTEXT_LINES);
-    const block = lines.slice(start, end);
-    return `${symbol} — ${filePath}:${lineNum}\n\`\`\`\n${block.join('\n')}\n\`\`\``;
-}
-export async function hoverSymbol(context, args) {
-    const filePath = String(args.filePath ?? '').trim();
-    const line = Number(args.line ?? 0);
-    const column = Number(args.column ?? 0);
-    if (!filePath || !line || !column) {
-        return {
-            ok: false,
-            error: 'hover_symbol requires filePath, line, and column.',
-        };
-    }
-    let content;
-    try {
-        content = readProjectText(context.rootDir, filePath);
-    }
-    catch {
-        return { ok: false, error: `Could not read ${filePath}.` };
-    }
-    const symbol = extractIdentifierAtPosition(content, line, column);
-    if (!symbol) {
-        return { ok: false, error: 'No identifier found at the given position.' };
-    }
-    const hoverContent = await findDefinitionContext(context.rootDir, symbol);
-    if (!hoverContent) {
-        return {
-            ok: false,
-            error: `Could not find definition for "${symbol}". Use find_symbol or grep_code.`,
-        };
-    }
-    const output = hoverContent.length > MAX_OUTPUT_CHARS
-        ? `${hoverContent.slice(0, MAX_OUTPUT_CHARS)}\n...(truncated)`
-        : hoverContent;
-    return {
-        ok: true,
-        provider: 'text_search',
-        available: true,
-        filePath,
-        line,
-        column,
-        contents: output,
-        output,
-    };
-}

package/dist/src/tools/list-symbols.js

@@ -1,55 +0,0 @@
-import { shouldIgnoreArtifactPath } from '../artifact-policy.js';
-import { extractSymbolsFromFile, listProjectFiles, normalizeProjectFilePath, } from './code-intel.js';
-function formatRegexSymbolsOutput(symbols) {
-    if (!symbols.length)
-        return 'No symbols found.';
-    const lines = symbols.map((s) => `- ${s.kind} ${s.name} @ ${s.filePath}:${s.selectionLine}:${s.selectionColumn}`);
-    return lines.join('\n');
-}
-export async function listSymbols(context, args) {
-    const scope = args.scope === 'workspace' ? 'workspace' : 'document';
-    const filePath = String(args.filePath ?? '').trim();
-    if (scope === 'document' && !filePath) {
-        return {
-            ok: false,
-            error: 'filePath is required for document symbol queries.',
-        };
-    }
-    if (scope === 'document' &&
-        shouldIgnoreArtifactPath(normalizeProjectFilePath(context.rootDir, filePath))) {
-        return {
-            ok: false,
-            error: 'This path is not permitted.',
-        };
-    }
-    const limit = Math.max(1, Math.min(Number(args.limit ?? 40), 100));
-    const query = String(args.query ?? '').trim() || undefined;
-    const symbols = scope === 'workspace'
-        ? await listWorkspaceSymbols(context.rootDir, query, limit)
-        : extractSymbolsFromFile(context.rootDir, filePath, query, limit);
-    return {
-        ok: true,
-        provider: 'regex',
-        available: true,
-        scope,
-        filePath: scope === 'document' ? filePath : undefined,
-        total: symbols.length,
-        symbols,
-        output: formatRegexSymbolsOutput(symbols),
-    };
-}
-async function listWorkspaceSymbols(rootDir, query, limit) {
-    const files = await listProjectFiles(rootDir, {
-        limit: 400,
-        sourceOnly: true,
-    });
-    const symbols = [];
-    for (const projectFile of files) {
-        const remaining = limit - symbols.length;
-        if (remaining <= 0)
-            break;
-        const fileSymbols = extractSymbolsFromFile(rootDir, projectFile, query, remaining);
-        symbols.push(...fileSymbols);
-    }
-    return symbols;
-}