@jokerized/getresearchdone 0.4.1

package/dist/lib/wireup/discovery.js

@@ -0,0 +1,934 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require('fs');
+const path = require('path');
+const { safeReadFile, } = require('../utils');
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+/**
+ * Recursively collect all files under a directory matching given extensions.
+ * Returns absolute paths.
+ */
+function _collectFiles(dir, extensions) {
+    const results = [];
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return results;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (entry.name === 'node_modules' || entry.name.startsWith('.'))
+                continue;
+            results.push(..._collectFiles(fullPath, extensions));
+        }
+        else if (entry.isFile()) {
+            const ext = path.extname(entry.name);
+            if (extensions.includes(ext)) {
+                results.push(fullPath);
+            }
+        }
+    }
+    return results;
+}
+/**
+ * Extract exported function/value names from a TypeScript/JavaScript source file.
+ *
+ * Handles CJS and ES module patterns:
+ * - module.exports = { name1, name2, ... }
+ * - exports.name = ...
+ * - export function name / export const name / export class name
+ * - export default function name
+ */
+function _extractExports(content) {
+    const names = [];
+    // Pattern 1: module.exports = { name1, name2, ... }
+    const moduleExportMatch = content.match(/module\.exports\s*=\s*\{([^}]+)\}/);
+    if (moduleExportMatch) {
+        const inner = moduleExportMatch[1];
+        const parts = inner.split(',');
+        for (const part of parts) {
+            const trimmed = part.trim();
+            if (!trimmed)
+                continue;
+            const colonIdx = trimmed.indexOf(':');
+            const name = colonIdx >= 0 ? trimmed.slice(0, colonIdx).trim() : trimmed;
+            if (/^\w+$/.test(name)) {
+                names.push(name);
+            }
+        }
+    }
+    // Pattern 2: exports.name = ...
+    const exportsPattern = /\bexports\.(\w+)\s*=/g;
+    let match;
+    while ((match = exportsPattern.exec(content)) !== null) {
+        if (!names.includes(match[1])) {
+            names.push(match[1]);
+        }
+    }
+    // Pattern 3: ES module exports — export [async] function/const/class/let/var name
+    const esExportPattern = /export\s+(?:async\s+)?(?:function|const|class|let|var)\s+(\w+)/g;
+    while ((match = esExportPattern.exec(content)) !== null) {
+        if (!names.includes(match[1])) {
+            names.push(match[1]);
+        }
+    }
+    // Pattern 4: export default function name (skip anonymous defaults)
+    const defaultExportPattern = /export\s+default\s+(?:async\s+)?(?:function|class)\s+(\w+)/g;
+    while ((match = defaultExportPattern.exec(content)) !== null) {
+        if (match[1] !== 'default' && !names.includes(match[1])) {
+            names.push(match[1]);
+        }
+    }
+    return names;
+}
+// ─── Scanner: exported-but-uncalled ─────────────────────────────────────────
+/**
+ * Scan lib/*.ts files for exported functions that are never called/imported
+ * in lib/, bin/, or commands/.
+ */
+function scanExportedButUncalled(cwd) {
+    const libDir = path.join(cwd, 'lib');
+    const binDir = path.join(cwd, 'bin');
+    const commandsDir = path.join(cwd, 'commands');
+    let libEntries;
+    try {
+        libEntries = fs.readdirSync(libDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const libFiles = libEntries
+        .filter((e) => e.isFile() && e.name.endsWith('.ts'))
+        .map((e) => path.join(libDir, e.name));
+    const exportMap = new Map();
+    const fileContents = new Map();
+    for (const filePath of libFiles) {
+        const content = safeReadFile(filePath);
+        if (!content)
+            continue;
+        fileContents.set(filePath, content);
+        const relPath = path.relative(cwd, filePath);
+        const exportedNames = _extractExports(content);
+        for (const name of exportedNames) {
+            if (!exportMap.has(name)) {
+                exportMap.set(name, relPath);
+            }
+        }
+    }
+    const searchFiles = [
+        ..._collectFiles(libDir, ['.ts', '.js', '.md']),
+        ..._collectFiles(binDir, ['.ts', '.js', '.md']),
+        ..._collectFiles(commandsDir, ['.ts', '.js', '.md']),
+    ];
+    const features = [];
+    for (const [funcName, relFilePath] of exportMap) {
+        const absFilePath = path.join(cwd, relFilePath);
+        let referenced = false;
+        for (const searchFile of searchFiles) {
+            if (path.resolve(searchFile) === path.resolve(absFilePath))
+                continue;
+            const content = safeReadFile(searchFile);
+            if (!content)
+                continue;
+            if (new RegExp(`\\b${funcName}\\b`).test(content)) {
+                referenced = true;
+                break;
+            }
+        }
+        if (!referenced) {
+            features.push({
+                category: 'exported-but-uncalled',
+                filePath: relFilePath,
+                functionName: funcName,
+                suggestedAction: 'Add call site in a command, route, or test',
+            });
+        }
+    }
+    return features;
+}
+// ─── Scanner: config-without-surface ────────────────────────────────────────
+/**
+ * Scan .planning/config.json for top-level config keys that are not referenced
+ * in commands/*.md or bin/*.ts.
+ */
+function scanConfigWithoutSurface(cwd) {
+    const configPath = path.join(cwd, '.planning', 'config.json');
+    const content = safeReadFile(configPath);
+    if (!content)
+        return [];
+    let configObj;
+    try {
+        configObj = JSON.parse(content);
+    }
+    catch {
+        return [];
+    }
+    const configKeys = Object.keys(configObj);
+    if (configKeys.length === 0)
+        return [];
+    const searchDirs = [
+        { dir: path.join(cwd, 'commands'), exts: ['.md'] },
+        { dir: path.join(cwd, 'bin'), exts: ['.ts', '.js'] },
+        { dir: path.join(cwd, 'lib'), exts: ['.ts', '.js'] },
+        { dir: path.join(cwd, 'src'), exts: ['.ts', '.js'] },
+    ];
+    const searchFiles = [];
+    for (const { dir, exts } of searchDirs) {
+        try {
+            fs.readdirSync(dir);
+            searchFiles.push(..._collectFiles(dir, exts));
+        }
+        catch {
+            // dir doesn't exist
+        }
+    }
+    const combinedContent = searchFiles
+        .map((f) => safeReadFile(f) || '')
+        .join('\n');
+    const features = [];
+    for (const key of configKeys) {
+        if (key.startsWith('_'))
+            continue;
+        if (!new RegExp(`\\b${key}\\b`).test(combinedContent)) {
+            features.push({
+                category: 'config-without-surface',
+                filePath: '.planning/config.json',
+                functionName: key,
+                suggestedAction: 'Expose via CLI flag, command option, or settings UI',
+            });
+        }
+    }
+    return features;
+}
+// ─── Scanner: endpoint-without-integration-test ──────────────────────────────
+/**
+ * Scan lib/mcp-server.ts for registered MCP tool names and check if they
+ * are referenced in tests/integration/.
+ */
+function scanEndpointsWithoutTests(cwd) {
+    const serverPath = path.join(cwd, 'lib', 'mcp-server.ts');
+    const content = safeReadFile(serverPath);
+    if (!content)
+        return [];
+    const toolNamePattern = /name:\s*['"](\w+)['"]/g;
+    const toolNames = [];
+    let match;
+    while ((match = toolNamePattern.exec(content)) !== null) {
+        const name = match[1];
+        if (name.startsWith('grd_') && !toolNames.includes(name)) {
+            toolNames.push(name);
+        }
+    }
+    if (toolNames.length === 0)
+        return [];
+    const integrationDir = path.join(cwd, 'tests', 'integration');
+    const integrationFiles = _collectFiles(integrationDir, ['.ts', '.js']);
+    const combinedIntegration = integrationFiles
+        .map((f) => safeReadFile(f) || '')
+        .join('\n');
+    const features = [];
+    for (const toolName of toolNames) {
+        if (!combinedIntegration.includes(toolName)) {
+            features.push({
+                category: 'endpoint-without-integration-test',
+                filePath: 'lib/mcp-server.ts',
+                functionName: toolName,
+                suggestedAction: 'Add integration test covering this endpoint',
+            });
+        }
+    }
+    return features;
+}
+// ─── Application-Aware Scanners ──────────────────────────────────────────────
+/** Directories to skip when scanning for application source code. */
+const SKIP_DIRS = new Set([
+    'node_modules', '.git', '.planning', '.claude-plugin', 'dist', 'build', 'out',
+    'coverage', '.next', '.nuxt', '.svelte-kit', '__pycache__', '.venv', 'venv',
+    'vendor', 'target', '.cache', '.turbo', '.vercel', '.output',
+    // GRD-internal directories — skip so we don't double-count with GRD scanners
+    'agents', 'commands', 'templates', 'examples', 'docs', 'references',
+]);
+/**
+ * Detect source directories in the project by scanning all top-level directories
+ * and filtering out infrastructure/config dirs. This is NOT a whitelist — any
+ * directory that contains .ts/.js/.tsx/.jsx files is a candidate.
+ */
+function _detectAppSourceDirs(cwd) {
+    const found = [];
+    let entries;
+    try {
+        entries = fs.readdirSync(cwd, { withFileTypes: true });
+    }
+    catch {
+        return found;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (entry.name.startsWith('.'))
+            continue;
+        if (SKIP_DIRS.has(entry.name))
+            continue;
+        // Check if this dir contains at least one source file (quick heuristic)
+        const dirPath = path.join(cwd, entry.name);
+        const files = _collectFiles(dirPath, ['.ts', '.js', '.tsx', '.jsx']);
+        if (files.length > 0) {
+            found.push(entry.name);
+        }
+    }
+    return found;
+}
+/**
+ * Extract route registrations from Express/Fastify/Hono-style source files.
+ *
+ * Detects patterns like:
+ *   app.get('/path', handler)
+ *   router.post('/path', handler)
+ *   export async function GET(req)  — Next.js App Router
+ *   @Get('/path') — NestJS
+ */
+function _extractRoutes(content, filePath) {
+    const routes = [];
+    // Express/Fastify/Hono: app.method('/path', ...) or router.method('/path', ...)
+    const expressPattern = /(?:app|router|server|fastify|hono)\s*\.\s*(get|post|put|patch|delete|all|use)\s*\(\s*['"`]([^'"`]+)['"`]/gi;
+    let match;
+    while ((match = expressPattern.exec(content)) !== null) {
+        routes.push({ method: match[1].toUpperCase(), route: match[2], filePath });
+    }
+    // Next.js App Router: export async function GET/POST/PUT/DELETE/PATCH
+    const nextAppPattern = /export\s+(?:async\s+)?function\s+(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\s*\(/gi;
+    while ((match = nextAppPattern.exec(content)) !== null) {
+        const routePath = _filePathToRoute(filePath);
+        routes.push({ method: match[1].toUpperCase(), route: routePath, filePath });
+    }
+    // Decorator patterns: @Get('/path'), @Post('/path') etc (NestJS)
+    const decoratorPattern = /@(Get|Post|Put|Patch|Delete)\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/gi;
+    while ((match = decoratorPattern.exec(content)) !== null) {
+        routes.push({ method: match[1].toUpperCase(), route: match[2], filePath });
+    }
+    return routes;
+}
+/**
+ * Convert a file path like `app/api/users/route.ts` or `pages/api/users.ts`
+ * to a route path like `/api/users`.
+ */
+function _filePathToRoute(filePath) {
+    let route = filePath
+        .replace(/\\/g, '/')
+        .replace(/^.*?\b(app|pages)\//, '/')
+        .replace(/\/route\.(ts|js|tsx|jsx)$/, '')
+        .replace(/\.(ts|js|tsx|jsx)$/, '')
+        .replace(/\/index$/, '');
+    if (!route.startsWith('/'))
+        route = '/' + route;
+    return route;
+}
+/**
+ * Scan for application routes/endpoints that have no corresponding test file.
+ */
+function scanAppRoutes(cwd) {
+    const features = [];
+    const appDirs = _detectAppSourceDirs(cwd);
+    if (appDirs.length === 0)
+        return features;
+    // Collect all source files from app directories
+    const sourceFiles = [];
+    for (const dir of appDirs) {
+        sourceFiles.push(..._collectFiles(path.join(cwd, dir), ['.ts', '.js', '.tsx', '.jsx']));
+    }
+    // Also check root-level route files
+    const rootFiles = ['routes.ts', 'routes.js', 'server.ts', 'server.js'];
+    for (const file of rootFiles) {
+        const fullPath = path.join(cwd, file);
+        try {
+            if (fs.statSync(fullPath).isFile())
+                sourceFiles.push(fullPath);
+        }
+        catch {
+            // doesn't exist
+        }
+    }
+    // Extract routes from all source files
+    const allRoutes = [];
+    for (const file of sourceFiles) {
+        const content = safeReadFile(file);
+        if (!content)
+            continue;
+        const relPath = path.relative(cwd, file);
+        allRoutes.push(..._extractRoutes(content, relPath));
+    }
+    if (allRoutes.length === 0)
+        return features;
+    // Collect test files
+    const testDirs = ['tests', 'test', '__tests__', 'spec'];
+    const testFiles = [];
+    for (const dir of testDirs) {
+        testFiles.push(..._collectFiles(path.join(cwd, dir), ['.ts', '.js', '.tsx', '.jsx']));
+    }
+    // Also collect *.test.* and *.spec.* from source dirs
+    for (const dir of appDirs) {
+        const allFiles = _collectFiles(path.join(cwd, dir), ['.ts', '.js', '.tsx', '.jsx']);
+        for (const f of allFiles) {
+            const basename = path.basename(f);
+            if (basename.includes('.test.') || basename.includes('.spec.')) {
+                testFiles.push(f);
+            }
+        }
+    }
+    const combinedTests = testFiles
+        .map((f) => safeReadFile(f) || '')
+        .join('\n');
+    // Check each route for test coverage
+    const seen = new Set();
+    for (const route of allRoutes) {
+        const key = `${route.method} ${route.route}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const routeEscaped = route.route.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const routeReferenced = new RegExp(routeEscaped).test(combinedTests) ||
+            combinedTests.includes(route.route);
+        if (!routeReferenced) {
+            features.push({
+                category: 'app-route-without-test',
+                filePath: route.filePath,
+                functionName: `${route.method} ${route.route}`,
+                suggestedAction: `Add integration test for ${route.method} ${route.route}`,
+            });
+        }
+    }
+    return features;
+}
+/**
+ * Scan src/ (or similar) for exported functions/classes that are never imported
+ * anywhere in the project.
+ */
+function scanAppExportedButUncalled(cwd) {
+    const appDirs = _detectAppSourceDirs(cwd);
+    if (appDirs.length === 0)
+        return [];
+    const exportMap = new Map();
+    const allAppFiles = [];
+    for (const dir of appDirs) {
+        allAppFiles.push(..._collectFiles(path.join(cwd, dir), ['.ts', '.js', '.tsx', '.jsx']));
+    }
+    for (const filePath of allAppFiles) {
+        const content = safeReadFile(filePath);
+        if (!content)
+            continue;
+        const relPath = path.relative(cwd, filePath);
+        // Skip test files
+        const basename = path.basename(filePath);
+        if (basename.includes('.test.') || basename.includes('.spec.'))
+            continue;
+        const exportedNames = _extractExports(content);
+        // Also detect ES module exports: export function name / export const name
+        const esExportPattern = /export\s+(?:async\s+)?(?:function|const|class|let|var)\s+(\w+)/g;
+        let match;
+        while ((match = esExportPattern.exec(content)) !== null) {
+            if (!exportedNames.includes(match[1])) {
+                exportedNames.push(match[1]);
+            }
+        }
+        for (const name of exportedNames) {
+            if (name === 'default')
+                continue;
+            if (!exportMap.has(name)) {
+                exportMap.set(name, relPath);
+            }
+        }
+    }
+    // Search all project files for references
+    const searchFiles = [...allAppFiles];
+    const testDirs = ['tests', 'test', '__tests__'];
+    for (const dir of testDirs) {
+        searchFiles.push(..._collectFiles(path.join(cwd, dir), ['.ts', '.js', '.tsx', '.jsx']));
+    }
+    const features = [];
+    for (const [funcName, relFilePath] of exportMap) {
+        const absFilePath = path.join(cwd, relFilePath);
+        let referenced = false;
+        for (const searchFile of searchFiles) {
+            if (path.resolve(searchFile) === path.resolve(absFilePath))
+                continue;
+            const content = safeReadFile(searchFile);
+            if (!content)
+                continue;
+            if (new RegExp(`\\b${funcName}\\b`).test(content)) {
+                referenced = true;
+                break;
+            }
+        }
+        if (!referenced) {
+            features.push({
+                category: 'app-exported-but-uncalled',
+                filePath: relFilePath,
+                functionName: funcName,
+                suggestedAction: 'Exported but never imported — wire into a route, component, or remove',
+            });
+        }
+    }
+    return features;
+}
+/**
+ * Scan for ORM model/entity definitions without corresponding CRUD route handlers.
+ *
+ * Detects Prisma models, TypeORM @Entity classes, and Drizzle table definitions.
+ */
+function scanAppModelsWithoutHandlers(cwd) {
+    const features = [];
+    const modelNames = [];
+    // Prisma schema
+    const prismaPath = path.join(cwd, 'prisma', 'schema.prisma');
+    const prismaContent = safeReadFile(prismaPath);
+    if (prismaContent) {
+        const modelPattern = /model\s+(\w+)\s*\{/g;
+        let match;
+        while ((match = modelPattern.exec(prismaContent)) !== null) {
+            modelNames.push({ name: match[1], filePath: 'prisma/schema.prisma' });
+        }
+    }
+    // TypeORM/MikroORM entity decorators and Drizzle table definitions
+    const appDirs = _detectAppSourceDirs(cwd);
+    const sourceFiles = [];
+    for (const dir of appDirs) {
+        sourceFiles.push(..._collectFiles(path.join(cwd, dir), ['.ts', '.js']));
+    }
+    for (const file of sourceFiles) {
+        const content = safeReadFile(file);
+        if (!content)
+            continue;
+        const relPath = path.relative(cwd, file);
+        // @Entity() class ClassName
+        const entityPattern = /@Entity\s*\([^)]*\)\s*(?:export\s+)?class\s+(\w+)/g;
+        let match;
+        while ((match = entityPattern.exec(content)) !== null) {
+            modelNames.push({ name: match[1], filePath: relPath });
+        }
+        // Drizzle: const <tableName> = pgTable/mysqlTable/sqliteTable(...)
+        const drizzlePattern = /(?:export\s+)?const\s+(\w+)\s*=\s*(?:pgTable|mysqlTable|sqliteTable)\s*\(/g;
+        while ((match = drizzlePattern.exec(content)) !== null) {
+            modelNames.push({ name: match[1], filePath: relPath });
+        }
+    }
+    if (modelNames.length === 0)
+        return features;
+    // Check if each model is referenced in route/handler files
+    const allSourceFiles = [];
+    for (const dir of appDirs) {
+        allSourceFiles.push(..._collectFiles(path.join(cwd, dir), ['.ts', '.js', '.tsx', '.jsx']));
+    }
+    const combinedSource = allSourceFiles
+        .map((f) => safeReadFile(f) || '')
+        .join('\n');
+    for (const model of modelNames) {
+        const modelLower = model.name.toLowerCase();
+        const hasRoute = new RegExp(`['"\`/]${modelLower}`, 'i').test(combinedSource) ||
+            new RegExp(`${model.name}\\.(find|create|update|delete|save|remove|insert|select)`, 'i').test(combinedSource);
+        if (!hasRoute) {
+            features.push({
+                category: 'app-model-without-handler',
+                filePath: model.filePath,
+                functionName: model.name,
+                suggestedAction: `Model "${model.name}" has no CRUD handlers — add routes or remove unused model`,
+            });
+        }
+    }
+    return features;
+}
+/**
+ * Scan for React/Vue components that are defined but never imported anywhere.
+ */
+function scanAppComponentsWithoutImport(cwd) {
+    const features = [];
+    const appDirs = _detectAppSourceDirs(cwd);
+    if (appDirs.length === 0)
+        return [];
+    const componentFiles = [];
+    for (const dir of appDirs) {
+        componentFiles.push(..._collectFiles(path.join(cwd, dir), ['.tsx', '.jsx']));
+    }
+    const componentMap = new Map();
+    for (const file of componentFiles) {
+        const basename = path.basename(file);
+        if (basename.includes('.test.') || basename.includes('.spec.'))
+            continue;
+        if (basename.startsWith('index.'))
+            continue;
+        const content = safeReadFile(file);
+        if (!content)
+            continue;
+        const relPath = path.relative(cwd, file);
+        // Detect: export default function ComponentName / export function ComponentName
+        // Only PascalCase names (React components)
+        const componentPattern = /export\s+(?:default\s+)?(?:function|const)\s+([A-Z]\w+)/g;
+        let match;
+        while ((match = componentPattern.exec(content)) !== null) {
+            componentMap.set(match[1], relPath);
+        }
+    }
+    // Search for imports of each component
+    const allFiles = [];
+    for (const dir of appDirs) {
+        allFiles.push(..._collectFiles(path.join(cwd, dir), ['.ts', '.js', '.tsx', '.jsx']));
+    }
+    for (const [componentName, relFilePath] of componentMap) {
+        const absFilePath = path.join(cwd, relFilePath);
+        let referenced = false;
+        for (const searchFile of allFiles) {
+            if (path.resolve(searchFile) === path.resolve(absFilePath))
+                continue;
+            const content = safeReadFile(searchFile);
+            if (!content)
+                continue;
+            if (new RegExp(`import\\s+.*\\b${componentName}\\b`).test(content) ||
+                new RegExp(`<${componentName}[\\s/>]`).test(content)) {
+                referenced = true;
+                break;
+            }
+        }
+        if (!referenced) {
+            features.push({
+                category: 'app-component-without-import',
+                filePath: relFilePath,
+                functionName: componentName,
+                suggestedAction: `Component "${componentName}" is never imported — wire into a page or remove`,
+            });
+        }
+    }
+    return features;
+}
+// ─── Generic CLI/Library Scanners ────────────────────────────────────────────
+/** Check if a directory exists. */
+function _dirExists(dirPath) {
+    try {
+        return fs.statSync(dirPath).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Scan lib/*.ts for exported functions that have no corresponding test.
+ * A function is considered tested if its name appears in any tests/ file.
+ */
+function scanLibExportedWithoutTest(cwd) {
+    const libDir = path.join(cwd, 'lib');
+    const testDirs = ['tests', 'test', '__tests__'];
+    const testFiles = [];
+    for (const dir of testDirs) {
+        testFiles.push(..._collectFiles(path.join(cwd, dir), ['.ts', '.js']));
+    }
+    if (testFiles.length === 0)
+        return [];
+    const combinedTests = testFiles
+        .map((f) => safeReadFile(f) || '')
+        .join('\n');
+    let libEntries;
+    try {
+        libEntries = fs.readdirSync(libDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const features = [];
+    for (const entry of libEntries) {
+        if (!entry.isFile() || !entry.name.endsWith('.ts'))
+            continue;
+        const filePath = path.join(libDir, entry.name);
+        const content = safeReadFile(filePath);
+        if (!content)
+            continue;
+        const exports = _extractExports(content);
+        for (const funcName of exports) {
+            if (!new RegExp(`\\b${funcName}\\b`).test(combinedTests)) {
+                features.push({
+                    category: 'lib-exported-without-test',
+                    filePath: path.relative(cwd, filePath),
+                    functionName: funcName,
+                    suggestedAction: `Add test coverage for ${funcName}`,
+                });
+            }
+        }
+    }
+    return features;
+}
+/**
+ * Scan bin/*.ts entry points for scripts that have no corresponding test.
+ * Checks if the bin file's basename (without extension) appears in any test filename.
+ */
+function scanBinEntriesWithoutTest(cwd) {
+    const binDir = path.join(cwd, 'bin');
+    const testDirs = ['tests', 'test', '__tests__'];
+    const testFileNames = new Set();
+    for (const dir of testDirs) {
+        const files = _collectFiles(path.join(cwd, dir), ['.ts', '.js']);
+        for (const f of files) {
+            testFileNames.add(path.basename(f).toLowerCase());
+        }
+    }
+    // Also collect all test file content for reference checks
+    const testFiles = [];
+    for (const dir of testDirs) {
+        testFiles.push(..._collectFiles(path.join(cwd, dir), ['.ts', '.js']));
+    }
+    const combinedTests = testFiles
+        .map((f) => safeReadFile(f) || '')
+        .join('\n');
+    let binEntries;
+    try {
+        binEntries = fs.readdirSync(binDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const features = [];
+    for (const entry of binEntries) {
+        if (!entry.isFile())
+            continue;
+        if (!entry.name.endsWith('.ts') && !entry.name.endsWith('.js'))
+            continue;
+        const baseName = entry.name.replace(/\.(ts|js)$/, '');
+        // Check if any test file references this bin entry
+        const hasTestFile = testFileNames.has(`${baseName}.test.ts`) ||
+            testFileNames.has(`${baseName}.test.js`) ||
+            testFileNames.has(`${baseName}.spec.ts`);
+        const hasReference = new RegExp(`\\b${baseName}\\b`).test(combinedTests);
+        if (!hasTestFile && !hasReference) {
+            features.push({
+                category: 'bin-entry-without-test',
+                filePath: path.relative(cwd, path.join(binDir, entry.name)),
+                functionName: baseName,
+                suggestedAction: `Add integration test for bin/${entry.name}`,
+            });
+        }
+    }
+    return features;
+}
+// ─── Claude Code Plugin Scanners ─────────────────────────────────────────────
+/**
+ * Detect if this is a Claude Code plugin project by checking for
+ * commands/ and/or agents/ directories with .md files.
+ */
+function _isPluginProject(cwd) {
+    const commandsDir = path.join(cwd, 'commands');
+    const agentsDir = path.join(cwd, 'agents');
+    return _dirExists(commandsDir) || _dirExists(agentsDir);
+}
+/**
+ * Read .md filenames from a directory, returning basenames without extension.
+ */
+function _readMdNames(dir) {
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        return entries
+            .filter((e) => e.isFile() && e.name.endsWith('.md'))
+            .map((e) => e.name.replace(/\.md$/, ''));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Extract the set of registered command names from the CLI registry file.
+ * Reads lib/cli/index.ts (or similar) and parses TOOL_COMMANDS and AGENT_COMMANDS sets.
+ */
+function _extractRegisteredCommands(cwd) {
+    const registered = new Set();
+    const candidates = [
+        path.join(cwd, 'lib', 'cli', 'index.ts'),
+        path.join(cwd, 'lib', 'cli', 'index.js'),
+        path.join(cwd, 'lib', 'cli.ts'),
+        path.join(cwd, 'lib', 'cli.js'),
+    ];
+    for (const candidate of candidates) {
+        const content = safeReadFile(candidate);
+        if (!content)
+            continue;
+        // Match strings inside Set([...]) or array literals
+        const stringPattern = /['"]([a-z][\w-]*)['"],?/g;
+        let match;
+        while ((match = stringPattern.exec(content)) !== null) {
+            registered.add(match[1]);
+        }
+    }
+    return registered;
+}
+/**
+ * Extract agent names referenced by commands via subagent_type="grd:grd-{name}" patterns.
+ */
+function _extractReferencedAgents(cwd) {
+    const referenced = new Set();
+    const commandsDir = path.join(cwd, 'commands');
+    const commandFiles = _collectFiles(commandsDir, ['.md']);
+    for (const file of commandFiles) {
+        const content = safeReadFile(file);
+        if (!content)
+            continue;
+        // Match subagent_type="grd:grd-{name}" or subagent_type="grd:{name}"
+        const agentRefPattern = /subagent_type\s*[=:]\s*["']grd:(?:grd-)?([^"']+)["']/g;
+        let match;
+        while ((match = agentRefPattern.exec(content)) !== null) {
+            referenced.add(match[1]);
+        }
+        // Also match Agent tool calls with description referencing agents
+        const agentFilePattern = /agents\/grd-([^."'\s]+)\.md/g;
+        while ((match = agentFilePattern.exec(content)) !== null) {
+            referenced.add(match[1]);
+        }
+    }
+    // Also check lib/ files for agent references
+    const libFiles = _collectFiles(path.join(cwd, 'lib'), ['.ts', '.js']);
+    for (const file of libFiles) {
+        const content = safeReadFile(file);
+        if (!content)
+            continue;
+        const agentRefPattern = /subagent_type\s*[=:]\s*["']grd:(?:grd-)?([^"']+)["']/g;
+        let match;
+        while ((match = agentRefPattern.exec(content)) !== null) {
+            referenced.add(match[1]);
+        }
+    }
+    return referenced;
+}
+/**
+ * Scan for commands/ .md files that are not registered in the CLI command registry.
+ */
+function scanCommandsWithoutRegistration(cwd) {
+    const commandNames = _readMdNames(path.join(cwd, 'commands'));
+    if (commandNames.length === 0)
+        return [];
+    const registered = _extractRegisteredCommands(cwd);
+    if (registered.size === 0)
+        return []; // No registry found — skip
+    const features = [];
+    for (const name of commandNames) {
+        if (!registered.has(name)) {
+            features.push({
+                category: 'command-without-registration',
+                filePath: `commands/${name}.md`,
+                functionName: name,
+                suggestedAction: `Register "${name}" in TOOL_COMMANDS or AGENT_COMMANDS in the CLI registry`,
+            });
+        }
+    }
+    return features;
+}
+/**
+ * Scan for agents/ .md files that are not referenced by any command.
+ */
+function scanAgentsWithoutCommand(cwd) {
+    const agentNames = _readMdNames(path.join(cwd, 'agents'));
+    if (agentNames.length === 0)
+        return [];
+    const referenced = _extractReferencedAgents(cwd);
+    const features = [];
+    for (const name of agentNames) {
+        // Normalize: agent files are grd-{name}.md, references may be just {name} or grd-{name}
+        const shortName = name.replace(/^grd-/, '');
+        if (!referenced.has(shortName) && !referenced.has(name)) {
+            features.push({
+                category: 'agent-without-command',
+                filePath: `agents/${name}.md`,
+                functionName: name,
+                suggestedAction: `Agent "${name}" is not spawned by any command — wire it via subagent_type or remove`,
+            });
+        }
+    }
+    return features;
+}
+/**
+ * Scan commands for agent references that point to non-existent agent files.
+ */
+function scanCommandsWithMissingAgents(cwd) {
+    const commandsDir = path.join(cwd, 'commands');
+    const agentsDir = path.join(cwd, 'agents');
+    const commandFiles = _collectFiles(commandsDir, ['.md']);
+    if (commandFiles.length === 0)
+        return [];
+    const existingAgents = new Set(_readMdNames(agentsDir));
+    const features = [];
+    const seen = new Set();
+    for (const file of commandFiles) {
+        const content = safeReadFile(file);
+        if (!content)
+            continue;
+        const relPath = path.relative(cwd, file);
+        // Match subagent_type references
+        const agentRefPattern = /subagent_type\s*[=:]\s*["']grd:(?:grd-)?([^"']+)["']/g;
+        let match;
+        while ((match = agentRefPattern.exec(content)) !== null) {
+            const agentName = match[1];
+            const fullName = agentName.startsWith('grd-') ? agentName : `grd-${agentName}`;
+            if (!existingAgents.has(fullName) && !seen.has(fullName)) {
+                seen.add(fullName);
+                features.push({
+                    category: 'command-without-agent-file',
+                    filePath: relPath,
+                    functionName: fullName,
+                    suggestedAction: `Command references agent "${fullName}" but agents/${fullName}.md does not exist`,
+                });
+            }
+        }
+    }
+    return features;
+}
+// ─── Public Orchestrator ─────────────────────────────────────────────────────
+/**
+ * Discover all unwired features in the codebase using pure filesystem analysis.
+ *
+ * Runs structural scanners when matching directories exist (lib/, bin/, tests/)
+ * AND application-aware scanners that detect routes, exports, models, and
+ * components in the target project. Works for web apps, CLI tools, and libraries.
+ *
+ * NEVER spawns child processes — pure fs.readFileSync/readdirSync only.
+ *
+ * @param cwd - Absolute path to the project root
+ * @returns Array of UnwiredFeature objects describing integration gaps
+ */
+function discoverUnwiredFeatures(cwd) {
+    const allFeatures = [];
+    // Structural scanners — run when matching directories exist (not gated to GRD)
+    const hasLib = _dirExists(path.join(cwd, 'lib'));
+    const hasBin = _dirExists(path.join(cwd, 'bin'));
+    const hasMcpServer = (() => {
+        try {
+            return fs.statSync(path.join(cwd, 'lib', 'mcp-server.ts')).isFile();
+        }
+        catch {
+            return false;
+        }
+    })();
+    if (hasLib) {
+        allFeatures.push(...scanExportedButUncalled(cwd));
+        allFeatures.push(...scanLibExportedWithoutTest(cwd));
+    }
+    if (hasLib || hasBin) {
+        allFeatures.push(...scanConfigWithoutSurface(cwd));
+    }
+    if (hasMcpServer) {
+        allFeatures.push(...scanEndpointsWithoutTests(cwd));
+    }
+    if (hasBin) {
+        allFeatures.push(...scanBinEntriesWithoutTest(cwd));
+    }
+    // Plugin-aware scanners — run when commands/ or agents/ exist
+    if (_isPluginProject(cwd)) {
+        allFeatures.push(...scanCommandsWithoutRegistration(cwd), ...scanAgentsWithoutCommand(cwd), ...scanCommandsWithMissingAgents(cwd));
+    }
+    // Application-aware scanners — always run
+    allFeatures.push(...scanAppRoutes(cwd), ...scanAppExportedButUncalled(cwd), ...scanAppModelsWithoutHandlers(cwd), ...scanAppComponentsWithoutImport(cwd));
+    allFeatures.sort((a, b) => {
+        const catCmp = a.category.localeCompare(b.category);
+        if (catCmp !== 0)
+            return catCmp;
+        return a.filePath.localeCompare(b.filePath);
+    });
+    return allFeatures;
+}
+// ─── Exports ─────────────────────────────────────────────────────────────────
+module.exports = { discoverUnwiredFeatures };
+//# sourceMappingURL=discovery.js.map