fivocell 1.0.5 → 2.0.0

package/dist/onboarding-scan.js

@@ -0,0 +1,1039 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverFiles = discoverFiles;
+exports.detectStack = detectStack;
+exports.extractPatterns = extractPatterns;
+exports.buildHubMap = buildHubMap;
+exports.detectIssues = detectIssues;
+exports.scanCodebase = scanCodebase;
+exports.saveOnboarding = saveOnboarding;
+exports.loadOnboarding = loadOnboarding;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const SUPPORTED_EXTS = new Set([
+    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+    '.py', '.go', '.html', '.htm',
+]);
+const SKIP_DIRS = new Set([
+    'node_modules', '.git', 'dist', 'build', 'coverage',
+    '.fivo', '.next', '.cache', 'vendor', 'target',
+    '__pycache__', '.venv', 'venv', 'env', '.env',
+    '.idea', '.vscode', '.pytest_cache', 'out',
+    'sdks', 'sdk', 'examples', 'example', 'samples', 'sample',
+    'demo', 'demos', 'tutorial', 'tutorials', 'docs', 'doc',
+    'fixtures', 'mocks', 'mocks-examples',
+]);
+const SKIP_PATH_PATTERNS = [
+    /[\\/]node_modules[\\/]/,
+    /[\\/]\.git[\\/]/,
+    /[\\/](dist|build|out|coverage|target|vendor|__pycache__|\.next|\.cache)[\\/]/,
+    /[\\/](sdks?|examples?|samples?|demos?|tutorials?|docs?|fixtures?|mocks?)[\\/]/i,
+];
+const MAX_FILE_LINES = 5000;
+const MAX_FILES = 2000;
+function discoverFiles(rootDir, opts = {}) {
+    const max = opts.maxFiles || MAX_FILES;
+    const found = [];
+    function walk(dir) {
+        if (found.length >= max)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (found.length >= max)
+                return;
+            if (e.name.startsWith('.') && e.name !== '.eslintrc' && e.name !== '.prettierrc') {
+                if (e.isDirectory() && SKIP_DIRS.has(e.name))
+                    continue;
+            }
+            if (e.isDirectory()) {
+                if (SKIP_DIRS.has(e.name))
+                    continue;
+                walk(path.join(dir, e.name));
+            }
+            else if (e.isFile()) {
+                const fullPath = path.join(dir, e.name);
+                const normalized = fullPath.replace(/\\/g, '/');
+                if (SKIP_PATH_PATTERNS.some(p => p.test(normalized)))
+                    continue;
+                const ext = path.extname(e.name).toLowerCase();
+                if (SUPPORTED_EXTS.has(ext)) {
+                    try {
+                        const st = fs.statSync(path.join(dir, e.name));
+                        found.push({ path: path.join(dir, e.name), ext, size: st.size });
+                    }
+                    catch { }
+                }
+            }
+        }
+    }
+    walk(rootDir);
+    return found;
+}
+function detectStack(rootDir) {
+    const stack = [];
+    const pkgPath = path.join(rootDir, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+            const known = {
+                typescript: { name: 'TypeScript', language: 'typescript' },
+                react: { name: 'React', language: 'typescript' },
+                vue: { name: 'Vue', language: 'typescript' },
+                next: { name: 'Next.js', language: 'typescript' },
+                express: { name: 'Express', language: 'typescript' },
+                fastify: { name: 'Fastify', language: 'typescript' },
+                nestjs: { name: 'NestJS', language: 'typescript' },
+                '@nestjs/core': { name: 'NestJS', language: 'typescript' },
+                vitest: { name: 'Vitest', language: 'typescript' },
+                jest: { name: 'Jest', language: 'typescript' },
+                mocha: { name: 'Mocha', language: 'typescript' },
+                webpack: { name: 'Webpack', language: 'typescript' },
+                vite: { name: 'Vite', language: 'typescript' },
+                tailwindcss: { name: 'Tailwind CSS', language: 'typescript' },
+                prisma: { name: 'Prisma', language: 'typescript' },
+                typeorm: { name: 'TypeORM', language: 'typescript' },
+                sequelize: { name: 'Sequelize', language: 'typescript' },
+                mongoose: { name: 'Mongoose', language: 'typescript' },
+                socketio: { name: 'Socket.IO', language: 'typescript' },
+                'socket.io': { name: 'Socket.IO', language: 'typescript' },
+                axios: { name: 'Axios', language: 'typescript' },
+                zod: { name: 'Zod', language: 'typescript' },
+                yup: { name: 'Yup', language: 'typescript' },
+                redux: { name: 'Redux', language: 'typescript' },
+                mobx: { name: 'MobX', language: 'typescript' },
+                rxjs: { name: 'RxJS', language: 'typescript' },
+            };
+            for (const [dep, version] of Object.entries(deps)) {
+                const k = known[dep];
+                if (k) {
+                    const v = String(version).replace(/^[~^]/, '');
+                    stack.push({ name: k.name, version: v, confidence: 1.0, language: k.language });
+                }
+            }
+            if (pkg.engines?.node) {
+                stack.push({ name: 'Node', version: String(pkg.engines.node).replace(/^[~^>=< ]+/, ''), confidence: 1.0, language: 'typescript' });
+            }
+        }
+        catch { }
+    }
+    const goMod = path.join(rootDir, 'go.mod');
+    if (fs.existsSync(goMod)) {
+        try {
+            const content = fs.readFileSync(goMod, 'utf-8');
+            const verMatch = content.match(/^go (\d+\.\d+)/m);
+            if (verMatch)
+                stack.push({ name: 'Go', version: verMatch[1], confidence: 1.0, language: 'go' });
+        }
+        catch { }
+    }
+    const reqTxt = path.join(rootDir, 'requirements.txt');
+    const pyproject = path.join(rootDir, 'pyproject.toml');
+    if (fs.existsSync(reqTxt) || fs.existsSync(pyproject)) {
+        stack.push({ name: 'Python', version: '3.x', confidence: 1.0, language: 'python' });
+        try {
+            if (fs.existsSync(reqTxt)) {
+                const reqs = fs.readFileSync(reqTxt, 'utf-8').toLowerCase();
+                if (reqs.includes('django'))
+                    stack.push({ name: 'Django', version: '', confidence: 1.0, language: 'python' });
+                if (reqs.includes('flask'))
+                    stack.push({ name: 'Flask', version: '', confidence: 1.0, language: 'python' });
+                if (reqs.includes('fastapi'))
+                    stack.push({ name: 'FastAPI', version: '', confidence: 1.0, language: 'python' });
+                if (reqs.includes('pytest'))
+                    stack.push({ name: 'pytest', version: '', confidence: 1.0, language: 'python' });
+                if (reqs.includes('numpy'))
+                    stack.push({ name: 'NumPy', version: '', confidence: 1.0, language: 'python' });
+                if (reqs.includes('pandas'))
+                    stack.push({ name: 'Pandas', version: '', confidence: 1.0, language: 'python' });
+                if (reqs.includes('sqlalchemy'))
+                    stack.push({ name: 'SQLAlchemy', version: '', confidence: 1.0, language: 'python' });
+                if (reqs.includes('requests'))
+                    stack.push({ name: 'Requests', version: '', confidence: 1.0, language: 'python' });
+            }
+        }
+        catch { }
+    }
+    return stack;
+}
+function emptyStats() {
+    return {
+        arrowFunctions: 0, functionDecls: 0, constDecls: 0, letDecls: 0,
+        singleQuotes: 0, doubleQuotes: 0, semicolons: 0, noSemicolons: 0,
+        asyncAwait: 0, thenChains: 0, tryCatch: 0, catchIgnored: 0,
+        destructureImports: 0, namespaceImports: 0, typeOnlyImports: 0, typeAny: 0,
+        typeUnknown: 0, typeNever: 0, typeVoid: 0, optionalChaining: 0, nullishCoalescing: 0,
+        templateLiterals: 0, templateStringsPy: 0, interfaces: 0, typeAliases: 0, generics: 0,
+        enums: 0, classes: 0, abstractClasses: 0, testFiles: 0, mockUsage: 0, describeBlocks: 0,
+        itBlocks: 0, customErrors: 0, consoleLog: 0, structuredLog: 0, jsdocComments: 0,
+        esmImports: 0, cjsRequires: 0, totalImports: 0, todoComments: 0, fixmeComments: 0,
+        xxxComments: 0, defaultExports: 0, namedExports: 0, promiseAll: 0, promiseRace: 0,
+        earlyReturns: 0, guardClauses: 0, shortFunctions: 0, longFunctions: 0,
+        restParams: 0, defaultParams: 0, destructuredParams: 0, readonlyModifier: 0,
+        privateModifier: 0, staticModifier: 0, barrelExports: 0, indexFiles: 0,
+        zodUsage: 0, yupUsage: 0, joiUsage: 0, expressMiddleware: 0, expressRoutes: 0,
+        processEnv: 0, envValidation: 0, parameterizedQueries: 0, regexPatterns: 0,
+        switchStatements: 0, forLoops: 0, forOfLoops: 0, whileLoops: 0, reduceUsage: 0,
+        mapUsage: 0, filterUsage: 0, spreadOperator: 0, indexedAccess: 0, lengthChecks: 0,
+        magicNumbers: 0, licenseHeaders: 0, deferUsage: 0, goroutineUsage: 0, channelUsage: 0,
+        semanticTags: 0, ariaAttributes: 0, altAttributes: 0, inlineStyles: 0, inlineScripts: 0,
+    };
+}
+function scanFileContent(content, ext) {
+    const s = emptyStats();
+    const lines = content.split('\n');
+    if (ext === '.ts' || ext === '.tsx' || ext === '.js' || ext === '.jsx' || ext === '.mjs' || ext === '.cjs') {
+        s.arrowFunctions = (content.match(/=>/g) || []).length;
+        s.functionDecls = (content.match(/function\s+\w+/g) || []).length;
+        s.constDecls = (content.match(/^\s*const\s+/gm) || []).length;
+        s.letDecls = (content.match(/^\s*let\s+/gm) || []).length;
+        s.singleQuotes = (content.match(/'/g) || []).length;
+        s.doubleQuotes = (content.match(/"/g) || []).length;
+        s.semicolons = lines.filter(l => l.trim().endsWith(';') && !l.trim().startsWith('//')).length;
+        s.noSemicolons = lines.filter(l => l.trim().length > 0 && !l.trim().endsWith(';') && !l.trim().endsWith('{') && !l.trim().endsWith('}') && !l.trim().startsWith('//') && !l.trim().startsWith('*') && !l.trim().endsWith(',') && !l.trim().endsWith('(') && !l.trim().endsWith(')')).length;
+        s.asyncAwait = (content.match(/await\s+/g) || []).length;
+        s.thenChains = (content.match(/\.then\(/g) || []).length;
+        s.tryCatch = (content.match(/try\s*\{/g) || []).length;
+        s.catchIgnored = (content.match(/catch\s*\([^)]*\)\s*\{\s*\}/g) || []).length;
+        s.destructureImports = (content.match(/import\s*\{/g) || []).length;
+        s.namespaceImports = (content.match(/import\s*\*\s+as/g) || []).length;
+        s.typeOnlyImports = (content.match(/import\s+type\s+/g) || []).length;
+        s.typeAny = (content.match(/:\s*any[\s,;)\]>]/g) || []).length;
+        s.typeUnknown = (content.match(/:\s*unknown[\s,;)\]>]/g) || []).length;
+        s.typeNever = (content.match(/:\s*never[\s,;)\]>]/g) || []).length;
+        s.typeVoid = (content.match(/:\s*void[\s,;)\]>]/g) || []).length;
+        s.optionalChaining = (content.match(/\?\./g) || []).length;
+        s.nullishCoalescing = (content.match(/\?\?/g) || []).length;
+        s.templateLiterals = (content.match(/`/g) || []).length / 2;
+        s.interfaces = (content.match(/^\s*(export\s+)?interface\s+\w+/gm) || []).length;
+        s.typeAliases = (content.match(/^\s*(export\s+)?type\s+\w+\s*=/gm) || []).length;
+        s.generics = (content.match(/<[A-Z]\w*>/g) || []).length;
+        s.enums = (content.match(/^\s*(export\s+)?enum\s+\w+/gm) || []).length;
+        s.classes = (content.match(/^\s*(export\s+)?class\s+\w+/gm) || []).length;
+        s.abstractClasses = (content.match(/^\s*(export\s+)?abstract\s+class\s+\w+/gm) || []).length;
+        s.testFiles = /\.(test|spec)\.(ts|tsx|js|jsx)$/.test(content) ? 1 : 0;
+        s.mockUsage = (content.match(/vi\.mock\(|jest\.mock\(/g) || []).length;
+        s.describeBlocks = (content.match(/describe\s*\(/g) || []).length;
+        s.itBlocks = (content.match(/(it|test)\s*\(/g) || []).length;
+        s.customErrors = (content.match(/class\s+\w+Error\s+extends\s+(Error|BaseError)/g) || []).length;
+        s.consoleLog = (content.match(/console\.(log|debug|info)/g) || []).length;
+        s.structuredLog = (content.match(/logger\.(info|warn|error|debug)\(/g) || []).length;
+        s.jsdocComments = (content.match(/\/\*\*[\s\S]*?\*\//g) || []).length;
+        s.esmImports = (content.match(/^import\s+/gm) || []).length;
+        s.cjsRequires = (content.match(/require\(['"]/g) || []).length;
+        s.totalImports = s.esmImports + s.cjsRequires;
+        s.todoComments = (content.match(/\b(TODO|FIXME|XXX|HACK)\b/gi) || []).length;
+        s.fixmeComments = (content.match(/\b(FIXME|XXX)\b/g) || []).length;
+        s.xxxComments = (content.match(/\bXXX\b/g) || []).length;
+        s.defaultExports = (content.match(/export\s+default\s+/g) || []).length;
+        s.namedExports = (content.match(/^export\s+(?:const|let|var|function|class|interface|type|enum)\s+/gm) || []).length;
+        s.promiseAll = (content.match(/Promise\.all\(/g) || []).length;
+        s.promiseRace = (content.match(/Promise\.race\(/g) || []).length;
+        s.earlyReturns = (content.match(/^\s*(if\s*\([^)]+\)\s*\{\s*return[^}]*\}|return\s+null;|return\s+undefined;)/gm) || []).length;
+        s.guardClauses = (content.match(/^\s*if\s*\(![^)]+\)\s*(return|throw)/gm) || []).length;
+        s.restParams = (content.match(/\.\.\.\w+\s*:\s*\w+\[\]/g) || []).length;
+        s.defaultParams = (content.match(/\w+\s*:\s*\w+\s*=\s*[^,)]+/g) || []).length;
+        s.destructuredParams = (content.match(/\(\s*\{\s*\w+(:\s*\w+)?(\s*,\s*\w+(:\s*\w+)?)*\s*\}\s*[:)]/g) || []).length;
+        s.readonlyModifier = (content.match(/\breadonly\s+/g) || []).length;
+        s.privateModifier = (content.match(/\bprivate\s+/g) || []).length;
+        s.staticModifier = (content.match(/\bstatic\s+/g) || []).length;
+        s.zodUsage = (content.match(/from\s+['"]zod['"]/g) || []).length;
+        s.yupUsage = (content.match(/from\s+['"]yup['"]/g) || []).length;
+        s.joiUsage = (content.match(/from\s+['"]joi['"]/g) || []).length;
+        s.expressMiddleware = (content.match(/\.(use|get|post|put|delete|patch)\s*\(\s*['"`]/g) || []).length;
+        s.expressRoutes = (content.match(/\.(get|post|put|delete|patch)\s*\(\s*['"`][^'"`]+['"`]/g) || []).length;
+        s.processEnv = (content.match(/process\.env\.\w+/g) || []).length;
+        s.envValidation = (content.match(/z\.string\(\)\.parse\(process\.env|\.parse\(process\.env\)/g) || []).length;
+        s.parameterizedQueries = (content.match(/\$\{|\?\s*,\s*\[|sql\.query.*\?/g) || []).length;
+        s.regexPatterns = (content.match(/\/[^/\n]+\/[gimsuy]*/g) || []).length;
+        s.switchStatements = (content.match(/^\s*switch\s*\(/gm) || []).length;
+        s.forLoops = (content.match(/^\s*for\s*\(\s*(let|var)\s+\w+\s*=/gm) || []).length;
+        s.forOfLoops = (content.match(/^\s*for\s*\(\s*(const|let)\s+\w+\s+of\s+/gm) || []).length;
+        s.whileLoops = (content.match(/^\s*while\s*\(/gm) || []).length;
+        s.reduceUsage = (content.match(/\.reduce\(/g) || []).length;
+        s.mapUsage = (content.match(/\.map\(/g) || []).length;
+        s.filterUsage = (content.match(/\.filter\(/g) || []).length;
+        s.spreadOperator = (content.match(/\.\.\.[\w${]/g) || []).length;
+        s.indexedAccess = (content.match(/\[\d+\]/g) || []).length;
+        s.lengthChecks = (content.match(/\.length\s*[><=!]/g) || []).length;
+        s.licenseHeaders = (content.match(/Copyright|License|@license|Apache License|MIT License/im) || []).length > 0 ? 1 : 0;
+        s.barrelExports = (content.match(/^export\s*\{\s*\n/gm) || []).length;
+    }
+    else if (ext === '.py') {
+        s.functionDecls = (content.match(/^\s*def\s+\w+/gm) || []).length;
+        s.asyncAwait = (content.match(/^\s*async\s+def\s+/gm) || []).length;
+        s.classes = (content.match(/^\s*class\s+\w+/gm) || []).length;
+        s.typeAliases = (content.match(/^\s*from\s+typing\s+import/gm) || []).length;
+        s.interfaces = (content.match(/^\s*from\s+typing\s+import.*Protocol/gm) || []).length;
+        s.generics = (content.match(/^[^#]*def\s+\w+\[.*?\]/gm) || []).length;
+        s.testFiles = content.includes('pytest') || content.includes('def test_') || /test_\w+\(/.test(content) ? 1 : 0;
+        s.mockUsage = (content.match(/mock\.(Mock|MagicMock|patch)/g) || []).length;
+        s.describeBlocks = (content.match(/^\s*class\s+Test\w+/gm) || []).length;
+        s.itBlocks = (content.match(/^\s*def\s+test_\w+/gm) || []).length;
+        s.customErrors = (content.match(/class\s+\w+(Error|Exception)\b/g) || []).length;
+        s.consoleLog = (content.match(/print\(/g) || []).length;
+        s.structuredLog = (content.match(/logger\.(info|warn|error|debug)\(/g) || []).length;
+        s.jsdocComments = (content.match(/""".*?"""/gs) || []).length;
+        s.templateStringsPy = (content.match(/f['"]/g) || []).length;
+        s.tryCatch = (content.match(/^\s*try:/gm) || []).length;
+        s.catchIgnored = (content.match(/except[^:]*:\s*pass/g) || []).length;
+        s.destructureImports = (content.match(/from\s+\w+\s+import\s+\(/g) || []).length;
+        s.typeOnlyImports = (content.match(/from\s+typing\s+import/g) || []).length;
+        s.optionalChaining = (content.match(/getattr\(|\.get\(/g) || []).length;
+        s.totalImports = (content.match(/^\s*(import|from)\s+/gm) || []).length;
+        s.todoComments = (content.match(/#.*\b(TODO|FIXME|XXX|HACK)\b/gi) || []).length;
+        s.fixmeComments = (content.match(/#.*\bFIXME\b/gi) || []).length;
+        s.guardClauses = (content.match(/^\s*if\s+not\s+\w+.*:\s*\n\s*return/gm) || []).length;
+        s.defaultParams = (content.match(/def\s+\w+\([^)]*=\s*[^,)]+/g) || []).length;
+        s.zodUsage = (content.match(/from\s+pydantic\s+import|from\s+marshmallow\s+import/g) || []).length;
+        s.processEnv = (content.match(/os\.environ\[|os\.getenv\(/g) || []).length;
+        s.envValidation = (content.match(/BaseSettings|pydantic_settings|os\.getenv\(.*required/g) || []).length;
+        s.parameterizedQueries = (content.match(/cursor\.execute\([^,]+,\s*\(/g) || []).length;
+        s.regexPatterns = (content.match(/r['"][^'"]+['"]/g) || []).length;
+        s.forLoops = (content.match(/^\s*for\s+\w+\s+in\s+/gm) || []).length;
+        s.mapUsage = (content.match(/\.map\(|\blist\(map\(/g) || []).length;
+        s.filterUsage = (content.match(/\.filter\(|\blist\(filter\(/g) || []).length;
+        s.reduceUsage = (content.match(/from\s+functools\s+import\s+reduce|functools\.reduce/g) || []).length;
+        s.spreadOperator = (content.match(/\*\*?\w+/g) || []).length;
+        s.lengthChecks = (content.match(/len\([^)]+\)\s*[><=!]/g) || []).length;
+        s.licenseHeaders = (content.match(/Copyright|License|Apache License|MIT License/im) || []).length > 0 ? 1 : 0;
+    }
+    else if (ext === '.go') {
+        s.functionDecls = (content.match(/^\s*func\s+\w+/gm) || []).length;
+        s.classes = (content.match(/^\s*type\s+\w+\s+struct/gm) || []).length;
+        s.interfaces = (content.match(/^\s*type\s+\w+\s+interface/gm) || []).length;
+        s.enums = (content.match(/^\s*const\s*\(\s*$/gm) || []).length;
+        s.testFiles = content.includes('testing.T') || content.includes('func Test') ? 1 : 0;
+        s.itBlocks = (content.match(/func\s+Test\w+\(/g) || []).length;
+        s.customErrors = (content.match(/type\s+\w+Error\s+struct/g) || []).length;
+        s.tryCatch = (content.match(/if\s+err\s*!=\s*nil\s*\{/g) || []).length;
+        s.catchIgnored = (content.match(/_\s*=\s*\w+/g) || []).length;
+        s.jsdocComments = (content.match(/^\s*\/\/.*$/gm) || []).length;
+        s.totalImports = (content.match(/^\s*import\s*\(/gm) || []).length;
+        s.todoComments = (content.match(/\/\/.*\b(TODO|FIXME|XXX|HACK)\b/gi) || []).length;
+        s.fixmeComments = (content.match(/\/\/.*\bFIXME\b/gi) || []).length;
+        s.guardClauses = (content.match(/if\s+\w+\s*==\s*nil\s*\{[\s\S]*?return/g) || []).length;
+        s.deferUsage = (content.match(/\bdefer\s+/g) || []).length;
+        s.goroutineUsage = (content.match(/\bgo\s+\w+\(/g) || []).length;
+        s.channelUsage = (content.match(/\bchan\s+\w+/g) || []).length;
+        s.processEnv = (content.match(/os\.Getenv\(/g) || []).length;
+        s.regexPatterns = (content.match(/regexp\.MustCompile/g) || []).length;
+        s.forLoops = (content.match(/^\s*for\s+\w+\s*:=\s*range\s+/gm) || []).length;
+        s.lengthChecks = (content.match(/len\([^)]+\)\s*[><=!]/g) || []).length;
+        s.licenseHeaders = (content.match(/Copyright|License|Apache License|MIT License/im) || []).length > 0 ? 1 : 0;
+    }
+    else if (ext === '.html' || ext === '.htm') {
+        s.jsdocComments = (content.match(/<!--[\s\S]*?-->/g) || []).length;
+        s.semanticTags = (content.match(/<(header|footer|nav|main|article|section|aside)\b/gi) || []).length;
+        s.ariaAttributes = (content.match(/\baria-\w+=/g) || []).length;
+        s.altAttributes = (content.match(/<img[^>]+alt\s*=/gi) || []).length;
+        s.inlineStyles = (content.match(/style\s*=/gi) || []).length;
+        s.inlineScripts = (content.match(/<script(?!\s+src=)/gi) || []).length;
+    }
+    return s;
+}
+function aggregateStats(stats) {
+    const out = emptyStats();
+    for (const s of stats) {
+        for (const k of Object.keys(s)) {
+            out[k] += s[k];
+        }
+    }
+    return out;
+}
+function makePattern(category, description, occurrences, total, examples, language) {
+    if (total === 0 || occurrences === 0)
+        return null;
+    const confidence = Math.min(1, occurrences / Math.max(1, total));
+    if (confidence < 0.3)
+        return null;
+    return { category, description, confidence, evidence: occurrences, total, examples, language };
+}
+function extractPatterns(stats, perFile) {
+    const patterns = [];
+    const jsFiles = perFile.filter(f => ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'].includes(f.ext));
+    const pyFiles = perFile.filter(f => f.ext === '.py');
+    const goFiles = perFile.filter(f => f.ext === '.go');
+    const tsTotal = jsFiles.length;
+    if (tsTotal > 0) {
+        const arrowVsFunc = stats.arrowFunctions;
+        const funcDecl = stats.functionDecls;
+        if (arrowVsFunc > 0 && arrowVsFunc >= funcDecl) {
+            const examples = jsFiles.filter(f => f.stats.arrowFunctions > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('style', 'Prefers arrow functions over function declarations', arrowVsFunc, arrowVsFunc + funcDecl, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.constDecls + stats.letDecls > 0) {
+            const examples = jsFiles.filter(f => f.stats.constDecls > f.stats.letDecls).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('style', 'Uses const over let for variable declarations', stats.constDecls, stats.constDecls + stats.letDecls, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.singleQuotes + stats.doubleQuotes > 50) {
+            const examples = jsFiles.filter(f => f.stats.singleQuotes > f.stats.doubleQuotes).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('style', 'Prefers single quotes over double quotes', stats.singleQuotes, stats.singleQuotes + stats.doubleQuotes, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.semicolons + stats.noSemicolons > 50) {
+            const examples = jsFiles.filter(f => f.stats.semicolons > f.stats.noSemicolons).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('style', 'Uses semicolons to terminate statements', stats.semicolons, stats.semicolons + stats.noSemicolons, examples);
+            if (p)
+                patterns.push(p);
+        }
+        else if (stats.noSemicolons > stats.semicolons * 3) {
+            const examples = jsFiles.filter(f => f.stats.noSemicolons > f.stats.semicolons).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('style', 'Omits semicolons (Prettier-style)', stats.noSemicolons, stats.semicolons + stats.noSemicolons, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.asyncAwait > 0) {
+            const examples = jsFiles.filter(f => f.stats.asyncAwait > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('async', 'Uses async/await for asynchronous code', stats.asyncAwait, stats.asyncAwait + stats.thenChains * 3, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.thenChains > 0 && stats.thenChains > stats.asyncAwait) {
+            const examples = jsFiles.filter(f => f.stats.thenChains > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('async', 'Uses Promise.then() chains over async/await', stats.thenChains, stats.thenChains + stats.asyncAwait, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.tryCatch > 0) {
+            const examples = jsFiles.filter(f => f.stats.tryCatch > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('errors', 'Wraps risky operations in try/catch', stats.tryCatch, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.destructureImports > 0) {
+            const examples = jsFiles.filter(f => f.stats.destructureImports > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('imports', 'Destructures named imports', stats.destructureImports, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.typeOnlyImports > 0) {
+            const examples = jsFiles.filter(f => f.stats.typeOnlyImports > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('types', 'Uses type-only imports for type-only modules', stats.typeOnlyImports, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.interfaces > 0) {
+            const examples = jsFiles.filter(f => f.stats.interfaces > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('types', 'Defines object shapes with interfaces', stats.interfaces, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.typeAliases > 0 && stats.typeAliases > stats.interfaces) {
+            const examples = jsFiles.filter(f => f.stats.typeAliases > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('types', 'Prefers type aliases over interfaces for object shapes', stats.typeAliases, stats.typeAliases + stats.interfaces, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.generics > 0) {
+            const examples = jsFiles.filter(f => f.stats.generics > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('types', 'Uses generic type parameters', stats.generics, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.optionalChaining > 0) {
+            const examples = jsFiles.filter(f => f.stats.optionalChaining > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('types', 'Uses optional chaining (?.) for safe access', stats.optionalChaining, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.nullishCoalescing > 0) {
+            const examples = jsFiles.filter(f => f.stats.nullishCoalescing > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('types', 'Uses nullish coalescing (??) for default values', stats.nullishCoalescing, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.typeUnknown > stats.typeAny && stats.typeUnknown > 0) {
+            const examples = jsFiles.filter(f => f.stats.typeUnknown > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('types', 'Prefers `unknown` over `any` for type safety', stats.typeUnknown, stats.typeUnknown + stats.typeAny, examples);
+            if (p)
+                patterns.push(p);
+        }
+        else if (stats.typeAny > 0) {
+            const examples = jsFiles.filter(f => f.stats.typeAny > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('types', 'Has some `any` types (consider replacing with `unknown`)', stats.typeAny, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.templateLiterals > 0) {
+            const examples = jsFiles.filter(f => f.stats.templateLiterals > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('style', 'Uses template literals for string interpolation', stats.templateLiterals, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.customErrors > 0) {
+            const examples = jsFiles.filter(f => f.stats.customErrors > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('errors', 'Defines custom error classes that extend Error', stats.customErrors, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.classes > 0) {
+            const examples = jsFiles.filter(f => f.stats.classes > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('architecture', 'Organizes behavior into classes', stats.classes, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.esmImports > 0 && stats.cjsRequires === 0) {
+            const examples = jsFiles.filter(f => f.stats.esmImports > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('imports', 'Uses ES Modules (import/export) exclusively', stats.esmImports, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        else if (stats.cjsRequires > 0 && stats.esmImports === 0) {
+            const examples = jsFiles.filter(f => f.stats.cjsRequires > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('imports', 'Uses CommonJS (require) exclusively', stats.cjsRequires, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        else if (stats.esmImports > 0 && stats.cjsRequires > 0) {
+            const examples = jsFiles.filter(f => f.stats.cjsRequires > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('imports', 'Mixes ESM and CommonJS modules', Math.max(stats.esmImports, stats.cjsRequires), tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.describeBlocks > 0) {
+            const examples = jsFiles.filter(f => f.stats.describeBlocks > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('testing', 'Organizes tests in describe blocks', stats.describeBlocks, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.itBlocks > 0) {
+            const examples = jsFiles.filter(f => f.stats.itBlocks > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('testing', 'Writes many focused test cases (it/test blocks)', stats.itBlocks, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.mockUsage > 0) {
+            const examples = jsFiles.filter(f => f.stats.mockUsage > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('testing', 'Mocks dependencies in tests', stats.mockUsage, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.structuredLog > stats.consoleLog) {
+            const examples = jsFiles.filter(f => f.stats.structuredLog > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('quality', 'Uses a structured logger instead of console.log', stats.structuredLog, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        else if (stats.consoleLog > 0) {
+            const examples = jsFiles.filter(f => f.stats.consoleLog > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('quality', 'Has some console.log usage (consider structured logger)', stats.consoleLog, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.jsdocComments > 0) {
+            const examples = jsFiles.filter(f => f.stats.jsdocComments > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('documentation', 'Documents functions with JSDoc/** comments', stats.jsdocComments, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.abstractClasses > 0) {
+            const examples = jsFiles.filter(f => f.stats.abstractClasses > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('architecture', 'Uses abstract classes for extensibility', stats.abstractClasses, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.readonlyModifier > 0) {
+            const examples = jsFiles.filter(f => f.stats.readonlyModifier > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('types', 'Uses readonly modifier for immutability', stats.readonlyModifier, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.privateModifier > 0) {
+            const examples = jsFiles.filter(f => f.stats.privateModifier > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('architecture', 'Marks class members as private for encapsulation', stats.privateModifier, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.staticModifier > 0) {
+            const examples = jsFiles.filter(f => f.stats.staticModifier > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('architecture', 'Uses static methods/properties on classes', stats.staticModifier, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.defaultExports > stats.namedExports && stats.defaultExports > 0) {
+            const examples = jsFiles.filter(f => f.stats.defaultExports > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('imports', 'Prefers default exports over named exports', stats.defaultExports, stats.defaultExports + stats.namedExports, examples);
+            if (p)
+                patterns.push(p);
+        }
+        else if (stats.namedExports > stats.defaultExports && stats.namedExports > 0) {
+            const examples = jsFiles.filter(f => f.stats.namedExports > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('imports', 'Prefers named exports over default exports', stats.namedExports, stats.defaultExports + stats.namedExports, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.promiseAll > 0) {
+            const examples = jsFiles.filter(f => f.stats.promiseAll > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('async', 'Parallelizes async work using Promise.all()', stats.promiseAll, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.guardClauses > 0) {
+            const examples = jsFiles.filter(f => f.stats.guardClauses > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('style', 'Uses guard clauses for early returns', stats.guardClauses, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.restParams > 0) {
+            const examples = jsFiles.filter(f => f.stats.restParams > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('style', 'Uses rest parameters for variadic functions', stats.restParams, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.defaultParams > 0) {
+            const examples = jsFiles.filter(f => f.stats.defaultParams > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('style', 'Uses default parameter values', stats.defaultParams, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.destructuredParams > 0) {
+            const examples = jsFiles.filter(f => f.stats.destructuredParams > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('style', 'Destructures object parameters', stats.destructuredParams, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.zodUsage > 0) {
+            const examples = jsFiles.filter(f => f.stats.zodUsage > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('validation', 'Validates input with Zod schemas', stats.zodUsage, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.yupUsage > 0) {
+            const examples = jsFiles.filter(f => f.stats.yupUsage > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('validation', 'Validates input with Yup schemas', stats.yupUsage, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.expressRoutes > 0) {
+            const examples = jsFiles.filter(f => f.stats.expressRoutes > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('architecture', 'Defines HTTP routes with Express handlers', stats.expressRoutes, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.expressMiddleware > 0) {
+            const examples = jsFiles.filter(f => f.stats.expressMiddleware > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('architecture', 'Uses Express middleware for request processing', stats.expressMiddleware, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.processEnv > 0) {
+            const examples = jsFiles.filter(f => f.stats.processEnv > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('config', 'Reads configuration from process.env', stats.processEnv, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.envValidation > 0) {
+            const examples = jsFiles.filter(f => f.stats.envValidation > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('config', 'Validates environment variables at startup', stats.envValidation, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.parameterizedQueries > 0) {
+            const examples = jsFiles.filter(f => f.stats.parameterizedQueries > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('security', 'Uses parameterized queries (SQL injection safe)', stats.parameterizedQueries, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.regexPatterns > 0) {
+            const examples = jsFiles.filter(f => f.stats.regexPatterns > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('style', 'Uses regular expressions for pattern matching', stats.regexPatterns, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.forOfLoops > stats.forLoops && stats.forOfLoops > 0) {
+            const examples = jsFiles.filter(f => f.stats.forOfLoops > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('style', 'Prefers for-of over classic for loops', stats.forOfLoops, stats.forOfLoops + stats.forLoops, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.mapUsage > 0) {
+            const examples = jsFiles.filter(f => f.stats.mapUsage > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('style', 'Transforms collections with .map()', stats.mapUsage, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.filterUsage > 0) {
+            const examples = jsFiles.filter(f => f.stats.filterUsage > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('style', 'Filters collections with .filter()', stats.filterUsage, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.reduceUsage > 0) {
+            const examples = jsFiles.filter(f => f.stats.reduceUsage > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('style', 'Reduces collections with .reduce()', stats.reduceUsage, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.spreadOperator > 0) {
+            const examples = jsFiles.filter(f => f.stats.spreadOperator > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('style', 'Uses spread operator for shallow copies', stats.spreadOperator, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.catchIgnored > 0) {
+            const examples = jsFiles.filter(f => f.stats.catchIgnored > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('quality', 'Has some empty catch blocks (consider logging)', stats.catchIgnored, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.todoComments > 0) {
+            const examples = jsFiles.filter(f => f.stats.todoComments > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('quality', 'Has TODO/FIXME comments in the code', stats.todoComments, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+        if (stats.barrelExports > 0) {
+            const examples = jsFiles.filter(f => f.stats.barrelExports > 0).slice(0, 3).map(f => path.basename(f.file));
+            const p = makePattern('architecture', 'Uses barrel exports (index.ts re-exports)', stats.barrelExports, tsTotal, examples);
+            if (p)
+                patterns.push(p);
+        }
+    }
+    if (pyFiles.length > 0) {
+        const examples = pyFiles.slice(0, 3).map(f => path.basename(f.file));
+        if (stats.asyncAwait > 0) {
+            patterns.push({ category: 'async', description: 'Python uses async def for coroutines', confidence: 0.9, evidence: stats.asyncAwait, total: pyFiles.length, examples, language: 'python' });
+        }
+        if (stats.typeAliases > 0) {
+            patterns.push({ category: 'types', description: 'Python uses typing module annotations', confidence: 0.8, evidence: stats.typeAliases, total: pyFiles.length, examples, language: 'python' });
+        }
+        if (stats.itBlocks > 0) {
+            patterns.push({ category: 'testing', description: 'Python uses pytest-style test_ functions', confidence: 0.9, evidence: stats.itBlocks, total: pyFiles.length, examples, language: 'python' });
+        }
+        if (stats.customErrors > 0) {
+            patterns.push({ category: 'errors', description: 'Python defines custom Exception classes', confidence: 0.7, evidence: stats.customErrors, total: pyFiles.length, examples, language: 'python' });
+        }
+        if (stats.jsdocComments > 0) {
+            patterns.push({ category: 'documentation', description: 'Python uses docstrings for documentation', confidence: 0.9, evidence: stats.jsdocComments, total: pyFiles.length, examples, language: 'python' });
+        }
+    }
+    if (goFiles.length > 0) {
+        const examples = goFiles.slice(0, 3).map(f => path.basename(f.file));
+        if (stats.interfaces > 0) {
+            patterns.push({ category: 'types', description: 'Go uses interfaces for behavior contracts', confidence: 0.95, evidence: stats.interfaces, total: goFiles.length, examples, language: 'go' });
+        }
+        if (stats.tryCatch > 0) {
+            patterns.push({ category: 'errors', description: 'Go checks errors explicitly (if err != nil)', confidence: 0.95, evidence: stats.tryCatch, total: goFiles.length, examples, language: 'go' });
+        }
+        if (stats.itBlocks > 0) {
+            patterns.push({ category: 'testing', description: 'Go uses standard testing package (func TestXxx)', confidence: 0.95, evidence: stats.itBlocks, total: goFiles.length, examples, language: 'go' });
+        }
+        if (stats.classes > 0) {
+            patterns.push({ category: 'architecture', description: 'Go models data with structs', confidence: 0.95, evidence: stats.classes, total: goFiles.length, examples, language: 'go' });
+        }
+    }
+    return patterns;
+}
+function buildHubMap(perFile) {
+    const importCounts = new Map();
+    const importPattern = /import\s+(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s+from\s+['"]([^'"]+)['"]/g;
+    const requirePattern = /require\(['"]([^'"]+)['"]\)/g;
+    const pyImport = /(?:^|\n)\s*(?:from\s+([\w.]+)\s+import|import\s+([\w.]+))/g;
+    const goImport = /^\s*"([^"]+)"\s*$/gm;
+    for (const f of perFile) {
+        const imports = new Set();
+        let m;
+        importPattern.lastIndex = 0;
+        while ((m = importPattern.exec(f.content)) !== null) {
+            const imp = m[1];
+            if (imp.startsWith('.') || imp.startsWith('/')) {
+                imports.add(imp);
+            }
+        }
+        requirePattern.lastIndex = 0;
+        while ((m = requirePattern.exec(f.content)) !== null) {
+            const imp = m[1];
+            if (imp.startsWith('.'))
+                imports.add(imp);
+        }
+        pyImport.lastIndex = 0;
+        while ((m = pyImport.exec(f.content)) !== null) {
+            const imp = m[1] || m[2];
+            if (imp && imp.startsWith('.'))
+                imports.add(imp);
+        }
+        goImport.lastIndex = 0;
+        while ((m = goImport.exec(f.content)) !== null) {
+            if (m[1].startsWith('.'))
+                imports.add(m[1]);
+        }
+        for (const imp of imports) {
+            const resolved = path.resolve(path.dirname(f.file), imp);
+            importCounts.set(resolved, (importCounts.get(resolved) || 0) + 1);
+        }
+    }
+    const hubs = [];
+    for (const [file, count] of importCounts) {
+        if (count >= 2) {
+            hubs.push({ file: path.relative(process.cwd(), file), importedBy: count });
+        }
+    }
+    hubs.sort((a, b) => b.importedBy - a.importedBy);
+    return hubs.slice(0, 5);
+}
+function detectIssues(perFile, importMap) {
+    const issues = [];
+    const largeFiles = perFile.filter(f => f.lines > 500);
+    if (largeFiles.length > 0) {
+        issues.push({
+            severity: 'medium',
+            type: 'large_file',
+            description: `${largeFiles.length} file${largeFiles.length > 1 ? 's' : ''} >500 lines (consider splitting)`,
+            files: largeFiles.slice(0, 3).map(f => path.relative(process.cwd(), f.file)),
+        });
+    }
+    const circular = [];
+    function findCircular(start, current, path, visited) {
+        if (path.length > 5)
+            return;
+        const imports = importMap.get(current) || [];
+        for (const imp of imports) {
+            if (imp === start && path.length > 0) {
+                circular.push([...path, current, start]);
+                return;
+            }
+            if (!visited.has(imp) && path.length < 5) {
+                visited.add(imp);
+                findCircular(start, imp, [...path, current], visited);
+            }
+        }
+    }
+    let checked = 0;
+    for (const file of importMap.keys()) {
+        if (++checked > 100)
+            break;
+        findCircular(file, file, [], new Set([file]));
+    }
+    if (circular.length > 0) {
+        const seen = new Set();
+        const unique = [];
+        for (const c of circular) {
+            const key = c.slice(0, -1).sort().join('|');
+            if (!seen.has(key)) {
+                seen.add(key);
+                unique.push(c);
+            }
+        }
+        if (unique.length > 0) {
+            issues.push({
+                severity: 'high',
+                type: 'circular_dep',
+                description: `${unique.length} circular dependenc${unique.length > 1 ? 'ies' : 'y'} detected`,
+                files: unique.slice(0, 2).map(c => c.slice(0, -1).map(f => path.relative(process.cwd(), f)).join(' → ')),
+            });
+        }
+    }
+    const testCount = perFile.filter(f => /\.(test|spec)\.(ts|tsx|js|jsx)$/.test(f.file) || /test_\w+\.py$/.test(f.file) || /_test\.go$/.test(f.file)).length;
+    const sourceCount = perFile.length - testCount;
+    if (sourceCount > 10 && testCount < sourceCount * 0.1) {
+        issues.push({
+            severity: 'low',
+            type: 'low_test_coverage',
+            description: `Test ratio is low: ${testCount} test files for ${sourceCount} source files`,
+            files: [],
+        });
+    }
+    return issues;
+}
+function buildImportMap(perFile) {
+    const m = new Map();
+    for (const f of perFile) {
+        const imports = [];
+        let match;
+        const importRe = /import\s+(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s+from\s+['"]([^'"]+)['"]/g;
+        while ((match = importRe.exec(f.content)) !== null) {
+            if (match[1].startsWith('.') || match[1].startsWith('/')) {
+                try {
+                    const resolved = path.resolve(path.dirname(f.file), match[1]);
+                    imports.push(resolved);
+                }
+                catch { }
+            }
+        }
+        const requireRe = /require\(['"]([^'"]+)['"]\)/g;
+        while ((match = requireRe.exec(f.content)) !== null) {
+            if (match[1].startsWith('.')) {
+                try {
+                    const resolved = path.resolve(path.dirname(f.file), match[1]);
+                    imports.push(resolved);
+                }
+                catch { }
+            }
+        }
+        m.set(f.file, imports);
+    }
+    return m;
+}
+function scanCodebase(rootDir, opts = {}) {
+    const startTime = Date.now();
+    const budget = opts.timeBudgetMs || 5000;
+    const maxFiles = opts.maxFiles || (opts.detectAllStacks ? 20000 : 2000);
+    const files = discoverFiles(rootDir, { maxFiles });
+    if (opts.onProgress)
+        opts.onProgress({ phase: 'discover', progress: 1.0 });
+    let stack = detectStack(rootDir);
+    if (opts.detectAllStacks) {
+        const subStacks = [];
+        let entries;
+        try {
+            entries = fs.readdirSync(rootDir, { withFileTypes: true });
+        }
+        catch {
+            entries = [];
+        }
+        for (const e of entries) {
+            if (e.isDirectory() && !SKIP_DIRS.has(e.name) && !e.name.startsWith('.')) {
+                const subStack = detectStack(path.join(rootDir, e.name));
+                for (const s of subStack) {
+                    if (!subStacks.some(x => x.name === s.name)) {
+                        subStacks.push(s);
+                    }
+                }
+            }
+        }
+        stack = subStacks.length > 0 ? subStacks : stack;
+    }
+    const perFile = [];
+    const languages = {};
+    let totalLines = 0;
+    let totalFunctions = 0;
+    const elapsed = () => Date.now() - startTime;
+    for (let i = 0; i < files.length; i++) {
+        if (elapsed() > budget && perFile.length > 0) {
+            break;
+        }
+        const f = files[i];
+        let content;
+        try {
+            content = fs.readFileSync(f.path, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        const lines = content.split('\n').length;
+        if (lines > MAX_FILE_LINES) {
+            const truncated = content.split('\n').slice(0, MAX_FILE_LINES).join('\n');
+            content = truncated;
+        }
+        const stats = scanFileContent(content, f.ext);
+        perFile.push({ file: f.path, content, ext: f.ext, lines, stats });
+        totalLines += lines;
+        totalFunctions += stats.functionDecls + stats.arrowFunctions + stats.classes;
+        const lang = f.ext === '.ts' || f.ext === '.tsx' ? 'typescript'
+            : f.ext === '.js' || f.ext === '.jsx' || f.ext === '.mjs' || f.ext === '.cjs' ? 'javascript'
+                : f.ext === '.py' ? 'python'
+                    : f.ext === '.go' ? 'go'
+                        : f.ext === '.html' || f.ext === '.htm' ? 'html'
+                            : 'other';
+        languages[lang] = (languages[lang] || 0) + 1;
+    }
+    const allStats = aggregateStats(perFile.map(p => p.stats));
+    const patterns = extractPatterns(allStats, perFile);
+    const importMap = buildImportMap(perFile);
+    const hubs = buildHubMap(perFile);
+    const issues = detectIssues(perFile, importMap);
+    const fileSignatures = [];
+    for (const f of perFile) {
+        const aspects = [];
+        if (f.stats.arrowFunctions > f.stats.functionDecls)
+            aspects.push('arrow');
+        if (f.stats.asyncAwait > 0)
+            aspects.push('async');
+        if (f.stats.tryCatch > 0)
+            aspects.push('trycatch');
+        if (f.stats.optionalChaining > 0)
+            aspects.push('optional');
+        if (f.stats.interfaces > 0)
+            aspects.push('interface');
+        if (f.stats.classes > 0)
+            aspects.push('class');
+        if (f.stats.todoComments > 0)
+            aspects.push('todo');
+        if (aspects.length > 0) {
+            fileSignatures.push({
+                category: 'file-signature',
+                description: `${path.relative(process.cwd(), f.file)}: ${aspects.join('+')}`,
+                confidence: 1.0,
+                evidence: 1,
+                total: 1,
+                examples: [path.relative(process.cwd(), f.file)],
+                language: f.ext,
+            });
+        }
+    }
+    return {
+        duration: Date.now() - startTime,
+        filesScanned: perFile.length,
+        totalLines,
+        totalFunctions,
+        stack,
+        patterns: [...patterns, ...fileSignatures],
+        hubs,
+        issues,
+        languages,
+    };
+}
+function saveOnboarding(result, dir = path.join(os.homedir(), '.fivo', 'cell')) {
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    const file = path.join(dir, 'onboarding.json');
+    fs.writeFileSync(file, JSON.stringify(result, null, 2), 'utf-8');
+}
+function loadOnboarding(dir = path.join(os.homedir(), '.fivo', 'cell')) {
+    const file = path.join(dir, 'onboarding.json');
+    if (!fs.existsSync(file))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=onboarding-scan.js.map