token-pilot 0.8.2 → 0.9.0

package/dist/handlers/project-overview.js

@@ -1,78 +1,109 @@
-import { readFile } from 'node:fs/promises';
-import { resolve, basename } from 'node:path';
-export async function handleProjectOverview(projectRoot, astIndex) {
+import { detectProject } from '../core/project-detector.js';
+export async function handleProjectOverview(args, projectRoot, astIndex) {
     const lines = [];
-    // 1. Project info from package.json / Cargo.toml etc.
-    const projectInfo = await detectProjectInfo(projectRoot);
-    if (projectInfo) {
-        lines.push(`PROJECT: ${projectInfo.name} v${projectInfo.version}`);
-        if (projectInfo.description)
-            lines.push(`  ${projectInfo.description}`);
-        lines.push('');
-    }
-    else {
-        lines.push(`PROJECT: ${basename(projectRoot)}`);
-        lines.push('');
-    }
-    // 2. ast-index map — directory structure with file counts and symbol kinds
+    // 1. Dual detection: ast-index + config scanner
+    let astIndexType;
+    let mapData = null;
+    let convData = null;
     if (astIndex.isAvailable() && !astIndex.isOversized() && !astIndex.isDisabled()) {
-        const [mapData, convData] = await Promise.all([
+        [mapData, convData] = await Promise.all([
             astIndex.map(),
             astIndex.conventions(),
         ]);
         if (mapData) {
-            lines.push(`TYPE: ${mapData.project_type} (${mapData.file_count} files)`);
-            lines.push('');
-            // Conventions
-            if (convData) {
-                if (convData.architecture.length > 0) {
-                    lines.push(`ARCHITECTURE: ${convData.architecture.join(', ')}`);
-                }
-                const fwList = [];
-                for (const [category, frameworks] of Object.entries(convData.frameworks)) {
-                    for (const fw of frameworks) {
-                        fwList.push(`${fw.name} (${category})`);
-                    }
-                }
-                if (fwList.length > 0) {
-                    lines.push(`FRAMEWORKS: ${fwList.join(', ')}`);
-                }
-                if (convData.naming_patterns.length > 0) {
-                    const patterns = convData.naming_patterns
-                        .slice(0, 8)
-                        .map(p => `${p.suffix}(${p.count})`)
-                        .join(', ');
-                    lines.push(`PATTERNS: ${patterns}`);
-                }
-                lines.push('');
-            }
-            // Directory map
-            lines.push('MAP:');
-            for (const group of mapData.groups) {
-                const kinds = group.kinds
-                    ? ' — ' + Object.entries(group.kinds).map(([k, v]) => `${v} ${k}`).join(', ')
-                    : '';
-                lines.push(`  ${group.path} (${group.file_count} files${kinds})`);
-            }
-            lines.push('');
+            astIndexType = mapData.project_type;
+        }
+    }
+    const detection = await detectProject(projectRoot, astIndexType);
+    // Determine which sections to include
+    const include = args.include ?? ['stack', 'ci', 'quality', 'architecture'];
+    const showStack = include.includes('stack');
+    const showCI = include.includes('ci');
+    const showQuality = include.includes('quality');
+    const showArch = include.includes('architecture');
+    // 2. Project identity
+    lines.push(`PROJECT: ${detection.projectName} v${detection.projectVersion}`);
+    if (detection.projectDescription)
+        lines.push(`  ${detection.projectDescription}`);
+    lines.push('');
+    // 3. TYPE — dual detection
+    if (showStack) {
+        if (astIndexType) {
+            lines.push(`TYPE (ast-index): ${astIndexType}${mapData ? ` (${mapData.file_count} files)` : ''}`);
+        }
+        if (detection.configStacks.length > 0) {
+            const configLine = formatConfigStacks(detection);
+            lines.push(`TYPE (config): ${configLine}`);
+        }
+        if (detection.configStacks.length === 0 && !astIndexType) {
+            lines.push('TYPE: unknown (no config files found)');
+        }
+        // Confidence
+        lines.push(`CONFIDENCE: ${detection.confidence}${getConfidenceHint(detection)}`);
+        lines.push('');
+    }
+    // 4. Architecture & frameworks (from ast-index conventions)
+    if (showArch && convData) {
+        if (convData.architecture.length > 0) {
+            lines.push(`ARCHITECTURE: ${convData.architecture.join(', ')}`);
+        }
+        // Merge framework info: ast-index conventions + config detection
+        const fwList = buildFrameworkList(convData, detection);
+        if (fwList.length > 0) {
+            lines.push(`FRAMEWORKS: ${fwList.join(', ')}`);
+        }
+        if (convData.naming_patterns.length > 0) {
+            const patterns = convData.naming_patterns
+                .slice(0, 8)
+                .map(p => `${p.suffix}(${p.count})`)
+                .join(', ');
+            lines.push(`PATTERNS: ${patterns}`);
+        }
+        lines.push('');
+    }
+    // 5. Quality tools
+    if (showQuality && detection.qualityTools.length > 0) {
+        lines.push(`QUALITY: ${detection.qualityTools.join(', ')}`);
+    }
+    // 6. CI pipelines
+    if (showCI && detection.ciPipelines.length > 0) {
+        lines.push(`CI: ${detection.ciPipelines.join(', ')}`);
+    }
+    // Docker
+    if (showCI && detection.hasDocker) {
+        lines.push('DOCKER: yes');
+    }
+    if ((showQuality && detection.qualityTools.length > 0) || (showCI && detection.ciPipelines.length > 0)) {
+        lines.push('');
+    }
+    // 7. Directory map (from ast-index)
+    if (showArch && mapData) {
+        lines.push('MAP:');
+        for (const group of mapData.groups) {
+            const kinds = group.kinds
+                ? ' — ' + Object.entries(group.kinds).map(([k, v]) => `${v} ${k}`).join(', ')
+                : '';
+            lines.push(`  ${group.path} (${group.file_count} files${kinds})`);
         }
-        else {
-            // Fallback to stats
-            try {
-                const statsText = await astIndex.stats();
-                if (statsText) {
-                    const filesMatch = statsText.match(/Files:\s*(\d+)/);
-                    const symbolsMatch = statsText.match(/Symbols:\s*(\d+)/);
-                    if (filesMatch)
-                        lines.push(`Files indexed: ${filesMatch[1]}`);
-                    if (symbolsMatch)
-                        lines.push(`Symbols: ${symbolsMatch[1]}`);
-                    lines.push('');
-                }
+        lines.push('');
+    }
+    else if (showArch && !mapData && astIndex.isAvailable() && !astIndex.isDisabled() && !astIndex.isOversized()) {
+        // Fallback to stats
+        try {
+            const statsText = await astIndex.stats();
+            if (statsText) {
+                const filesMatch = statsText.match(/Files:\s*(\d+)/);
+                const symbolsMatch = statsText.match(/Symbols:\s*(\d+)/);
+                if (filesMatch)
+                    lines.push(`Files indexed: ${filesMatch[1]}`);
+                if (symbolsMatch)
+                    lines.push(`Symbols: ${symbolsMatch[1]}`);
+                lines.push('');
             }
-            catch { /* ignore */ }
         }
+        catch { /* ignore */ }
     }
+    // 8. Degradation warnings
     if (astIndex.isDisabled()) {
         lines.push('⚠ ast-index: project root not detected. Call smart_read() on any project file first.');
         lines.push('  Working tools: smart_read, smart_read_many, outline, read_symbol, read_range');
@@ -88,47 +119,55 @@ export async function handleProjectOverview(projectRoot, astIndex) {
     lines.push('HINT: Use smart_read() on files, find_usages() for symbol references, outline() for directory overview.');
     return { content: [{ type: 'text', text: lines.join('\n') }] };
 }
-async function detectProjectInfo(projectRoot) {
-    try {
-        const pkg = JSON.parse(await readFile(resolve(projectRoot, 'package.json'), 'utf-8'));
-        return {
-            name: pkg.name ?? basename(projectRoot),
-            version: pkg.version ?? '0.0.0',
-            description: pkg.description,
-            type: 'Node.js/TypeScript',
-        };
-    }
-    catch { /* not a node project */ }
-    try {
-        const composer = JSON.parse(await readFile(resolve(projectRoot, 'composer.json'), 'utf-8'));
-        return {
-            name: composer.name ?? 'unknown',
-            version: composer.version ?? '0.0.0',
-            description: composer.description,
-            type: 'PHP',
-        };
-    }
-    catch { /* not a php project */ }
-    try {
-        const cargo = await readFile(resolve(projectRoot, 'Cargo.toml'), 'utf-8');
-        const name = cargo.match(/^name\s*=\s*"(.+?)"/m)?.[1] ?? 'unknown';
-        const version = cargo.match(/^version\s*=\s*"(.+?)"/m)?.[1] ?? '0.0.0';
-        return { name, version, type: 'Rust' };
-    }
-    catch { /* not a rust project */ }
-    try {
-        const pyproject = await readFile(resolve(projectRoot, 'pyproject.toml'), 'utf-8');
-        const name = pyproject.match(/^name\s*=\s*"(.+?)"/m)?.[1] ?? 'unknown';
-        const version = pyproject.match(/^version\s*=\s*"(.+?)"/m)?.[1] ?? '0.0.0';
-        return { name, version, type: 'Python' };
-    }
-    catch { /* not a python project */ }
-    try {
-        const gomod = await readFile(resolve(projectRoot, 'go.mod'), 'utf-8');
-        const name = gomod.match(/^module\s+(.+)/m)?.[1] ?? 'unknown';
-        return { name, version: '0.0.0', type: 'Go' };
-    }
-    catch { /* not a go project */ }
-    return null;
+// ──────────────────────────────────────────────
+// Formatters
+// ──────────────────────────────────────────────
+function formatConfigStacks(detection) {
+    if (detection.configStacks.length === 0)
+        return 'unknown';
+    const parts = [];
+    for (const stack of detection.configStacks) {
+        let part = stack.type;
+        if (stack.langVersion)
+            part = stack.langVersion;
+        if (stack.framework)
+            part += ` (${stack.framework})`;
+        parts.push(part);
+    }
+    if (detection.primaryStack && detection.configStacks.length > 1) {
+        // Put primary first, mark others
+        const primaryIdx = detection.configStacks.indexOf(detection.primaryStack);
+        if (primaryIdx > 0) {
+            const [primary] = parts.splice(primaryIdx, 1);
+            parts.unshift(primary);
+        }
+        return parts[0] + (parts.length > 1 ? ` + ${parts.slice(1).join(', ')}` : '');
+    }
+    return parts.join(', ');
+}
+function getConfidenceHint(detection) {
+    if (detection.confidence === 'low') {
+        return ` — ast-index and config files disagree on project type`;
+    }
+    if (detection.confidence === 'medium' && detection.configStacks.length > 1) {
+        return ` — multi-stack project detected`;
+    }
+    return '';
+}
+function buildFrameworkList(convData, detection) {
+    const fwSet = new Set();
+    // From ast-index conventions
+    for (const [category, frameworks] of Object.entries(convData.frameworks)) {
+        for (const fw of frameworks) {
+            fwSet.add(`${fw.name} (${category})`);
+        }
+    }
+    // From config detection (may have version info that conventions don't)
+    for (const stack of detection.configStacks) {
+        if (stack.framework && !Array.from(fwSet).some(f => f.includes(stack.framework.split(' ')[0]))) {
+            fwSet.add(stack.framework);
+        }
+    }
+    return Array.from(fwSet);
 }
 //# sourceMappingURL=project-overview.js.map

package/dist/server.js

@@ -27,9 +27,10 @@ import { handleReadForEdit } from './handlers/read-for-edit.js';
 import { handleRelatedFiles } from './handlers/related-files.js';
 import { handleOutline } from './handlers/outline.js';
 import { handleCodeAudit } from './handlers/code-audit.js';
+import { handleModuleInfo } from './handlers/module-info.js';
 import { detectContextMode } from './integration/context-mode-detector.js';
 import { estimateTokens } from './core/token-estimator.js';
-import { resolveSafePath, validateSmartReadArgs, validateReadSymbolArgs, validateReadRangeArgs, validateReadDiffArgs, validateFindUsagesArgs, validateSmartReadManyArgs, validateReadForEditArgs, validateRelatedFilesArgs, validateOutlineArgs, validateFindUnusedArgs, validateCodeAuditArgs, } from './core/validation.js';
+import { resolveSafePath, validateSmartReadArgs, validateReadSymbolArgs, validateReadRangeArgs, validateReadDiffArgs, validateFindUsagesArgs, validateSmartReadManyArgs, validateReadForEditArgs, validateRelatedFilesArgs, validateOutlineArgs, validateFindUnusedArgs, validateCodeAuditArgs, validateProjectOverviewArgs, validateModuleInfoArgs, } from './core/validation.js';
 export async function createServer(projectRoot, options) {
     const config = await loadConfig(projectRoot);
     const astIndex = new AstIndexClient(projectRoot, config.astIndex.timeout, {
@@ -198,6 +199,7 @@ export async function createServer(projectRoot, options) {
             '• Text pattern search/counting → Grep (regex, count mode)',
             '• Security audit → Grep for: password, token, secret, credential, hardcoded, api_key, TODO.*security',
             '• Deep dive into specific code → read_symbol (after finding issues)',
+            '• Module architecture → module_info (deps, dependents, public API, unused deps)',
             '',
             'WORKFLOW: project_overview → smart_read → read_symbol → read_for_edit → edit → read_diff',
         ].join('\n'),
@@ -291,21 +293,31 @@ export async function createServer(projectRoot, options) {
             // --- Search & navigation ---
             {
                 name: 'find_usages',
-                description: 'Use INSTEAD OF Grep/ripgrep for finding symbol references. Semantic search across the project — groups results by: definitions, imports, usages.',
+                description: 'Use INSTEAD OF Grep/ripgrep for finding symbol references. Semantic search across the project — groups results by: definitions, imports, usages. (v1.1: added scope, kind, limit, lang filters)',
                 inputSchema: {
                     type: 'object',
                     properties: {
                         symbol: { type: 'string', description: 'Symbol name to find usages of' },
+                        scope: { type: 'string', description: 'Filter results by path prefix (e.g., "src/Domain/")' },
+                        kind: { type: 'string', enum: ['definitions', 'imports', 'usages', 'all'], description: 'Show only specific section (default: "all")' },
+                        limit: { type: 'number', description: 'Max results per category (default: 50, max: 500)' },
+                        lang: { type: 'string', description: 'Filter by language/extension (e.g., "php", "typescript")' },
                     },
                     required: ['symbol'],
                 },
             },
             {
                 name: 'project_overview',
-                description: 'START HERE for unfamiliar codebases. Shows project type, architecture, framework detection, directory structure with symbol counts. Use before exploring code.',
+                description: 'START HERE for unfamiliar codebases. Shows project type (dual-detection: ast-index + config files), architecture, framework detection, quality tools, CI, directory map. (v1.1: added include filter)',
                 inputSchema: {
                     type: 'object',
-                    properties: {},
+                    properties: {
+                        include: {
+                            type: 'array',
+                            items: { type: 'string', enum: ['stack', 'ci', 'quality', 'architecture'] },
+                            description: 'Sections to include (default: all). Use ["stack"] for quick type check, ["quality","ci"] for tooling overview.',
+                        },
+                    },
                 },
             },
             {
@@ -321,11 +333,13 @@ export async function createServer(projectRoot, options) {
             },
             {
                 name: 'outline',
-                description: 'Use INSTEAD OF listing dir + reading each file. One call returns all symbols (classes, functions, methods, routes) for every code file in a directory.',
+                description: 'Use INSTEAD OF listing dir + reading each file. One call returns all symbols (classes, functions, methods, routes) for every code file in a directory. (v1.1: added recursive, max_depth)',
                 inputSchema: {
                     type: 'object',
                     properties: {
                         path: { type: 'string', description: 'Directory path' },
+                        recursive: { type: 'boolean', description: 'Recursively outline subdirectories (default: false)' },
+                        max_depth: { type: 'number', description: 'Max recursion depth when recursive=true (default: 2, max: 5)' },
                     },
                     required: ['path'],
                 },
@@ -371,6 +385,22 @@ export async function createServer(projectRoot, options) {
                     required: ['check'],
                 },
             },
+            {
+                name: 'module_info',
+                description: 'Analyze module dependencies, dependents, public API, and unused deps. Use for architecture understanding and dependency cleanup.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        module: { type: 'string', description: 'Module name or path pattern (e.g., "auth", "src/Domain/")' },
+                        check: {
+                            type: 'string',
+                            enum: ['deps', 'dependents', 'api', 'unused-deps', 'all'],
+                            description: 'What to check: "deps" (dependencies), "dependents" (who depends on this), "api" (public symbols), "unused-deps" (dead dependencies), "all" (everything). Default: "all"',
+                        },
+                    },
+                    required: ['module'],
+                },
+            },
         ],
     }));
     // Helper: get real full-file token count for honest analytics
@@ -476,7 +506,8 @@ export async function createServer(projectRoot, options) {
                     return usagesResult;
                 }
                 case 'project_overview': {
-                    const overviewResult = await handleProjectOverview(projectRoot, astIndex);
+                    const overviewArgs = validateProjectOverviewArgs(args);
+                    const overviewResult = await handleProjectOverview(overviewArgs, projectRoot, astIndex);
                     const overviewText = overviewResult.content[0]?.text ?? '';
                     overviewResult.content[0] = { type: 'text', text: `TOKEN PILOT v${pkgVersion}\n\n${overviewText}` };
                     const ovTokens = estimateTokens(overviewResult.content[0].text);
@@ -513,6 +544,15 @@ export async function createServer(projectRoot, options) {
                     analytics.record({ tool: 'code_audit', path: auditArgs.check, tokensReturned: estimateTokens(auditText), tokensWouldBe: estimateTokens(auditText), timestamp: Date.now() });
                     return auditResult;
                 }
+                case 'module_info': {
+                    const moduleArgs = validateModuleInfoArgs(args);
+                    const moduleResult = await handleModuleInfo(moduleArgs, projectRoot, astIndex);
+                    const moduleText = moduleResult.content[0]?.text ?? '';
+                    // Estimate: manual analysis would require reading all module files + grepping deps
+                    const moduleWouldBe = estimateTokens(moduleText) * 5;
+                    analytics.record({ tool: 'module_info', path: moduleArgs.module, tokensReturned: estimateTokens(moduleText), tokensWouldBe: moduleWouldBe, timestamp: Date.now() });
+                    return moduleResult;
+                }
                 default:
                     return {
                         content: [{ type: 'text', text: `Unknown tool: ${name}` }],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "token-pilot",
-  "version": "0.8.2",
+  "version": "0.9.0",
   "description": "Save 60-80% tokens when AI reads code — MCP server for token-efficient code navigation, AST-aware structural reading instead of dumping full files into context window",
   "type": "module",
   "main": "dist/index.js",