@archpilotlabs/archpilot 0.2.2 → 0.2.4

package/dist/core/src/stackAdapters.js

@@ -0,0 +1,2475 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllStackAdapters = getAllStackAdapters;
+exports.getSmartInitDetectionAdapters = getSmartInitDetectionAdapters;
+exports.getStackAdapterById = getStackAdapterById;
+exports.resolveBackendAdapter = resolveBackendAdapter;
+exports.resolveFrontendAdapter = resolveFrontendAdapter;
+exports.resolveLibraryAdapter = resolveLibraryAdapter;
+exports.resolvePrimaryAdapter = resolvePrimaryAdapter;
+exports.resolvePrimaryAdapterFromContract = resolvePrimaryAdapterFromContract;
+exports.resolveDefaultModulesRootFromContract = resolveDefaultModulesRootFromContract;
+const stackMetadata_1 = require("./stackMetadata");
+function sortUnique(values) {
+    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+function sortUniqueKinds(values) {
+    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+function normalizeDefaults(defaults) {
+    return {
+        sourceRoots: sortUnique(defaults.sourceRoots),
+        moduleRootCandidates: sortUnique(defaults.moduleRootCandidates),
+        apiRoots: sortUnique(defaults.apiRoots),
+        databaseRoots: sortUnique(defaults.databaseRoots),
+        configFiles: sortUnique(defaults.configFiles),
+        fileExtensions: sortUnique(defaults.fileExtensions),
+        dependencyFileExtensions: sortUnique(defaults.dependencyFileExtensions),
+        ignoreDirectories: sortUnique(defaults.ignoreDirectories),
+        entrypointHints: sortUnique(defaults.entrypointHints),
+        publicEntrypointDirectories: sortUnique(defaults.publicEntrypointDirectories),
+        ...(defaults.moduleIndexFileName ? { moduleIndexFileName: defaults.moduleIndexFileName } : {}),
+    };
+}
+function toResult(input) {
+    const result = {
+        adapterId: input.adapterId,
+        confidence: input.confidence,
+        score: input.score,
+        evidence: sortUnique(input.evidence),
+    };
+    if ((input.projectKindHints?.length ?? 0) > 0) {
+        result.projectKindHints = sortUniqueKinds(input.projectKindHints ?? []);
+    }
+    if (input.apiStyleHint) {
+        result.apiStyleHint = input.apiStyleHint;
+    }
+    if ((input.databaseHints?.length ?? 0) > 0) {
+        result.databaseHints = sortUnique(input.databaseHints ?? []);
+    }
+    return result;
+}
+function buildAdapter(definition) {
+    const defaults = normalizeDefaults(definition.defaults);
+    const importMode = definition.getImportExtractionMode?.() ?? 'generic';
+    const adapter = {
+        id: definition.id,
+        displayName: definition.displayName,
+        ecosystem: definition.ecosystem,
+        category: definition.category,
+        priority: definition.priority,
+        detect: definition.detect,
+        getDefaults: () => ({ ...defaults }),
+        ...(definition.resolveProjectKinds ? { resolveProjectKinds: definition.resolveProjectKinds } : {}),
+        ...(definition.getImportExtractionMode
+            ? { getImportExtractionMode: definition.getImportExtractionMode }
+            : { getImportExtractionMode: () => importMode }),
+        label: definition.displayName,
+        manifestDetectionHints: sortUnique(definition.manifestDetectionHints),
+        buildToolHints: sortUnique(definition.buildToolHints),
+        defaultSourceRoots: [...defaults.sourceRoots],
+        defaultEntrypointHints: [...defaults.entrypointHints],
+        relevantFileExtensions: [...defaults.fileExtensions],
+        dependencyParsingFileExtensions: [...defaults.dependencyFileExtensions],
+        ignoreDirectoryNames: [...defaults.ignoreDirectories],
+        publicEntrypointDirectoryNames: [...defaults.publicEntrypointDirectories],
+        dependencyExtractionStrategyHint: importMode,
+        scaffoldingDefaults: {
+            modulesRoot: defaults.moduleRootCandidates[0] ?? defaults.sourceRoots[0] ?? 'src/modules',
+            moduleIndexFileName: defaults.moduleIndexFileName,
+        },
+    };
+    return adapter;
+}
+const commonIgnoreDirectories = [
+    'node_modules',
+    '.git',
+    '.vscode-test',
+    '.archpilot',
+    '.next',
+    'dist',
+    'build',
+    'out',
+    'coverage',
+    'fixtures',
+    '__fixtures__',
+];
+const commonApiRoots = ['src/api', 'api', 'app/api'];
+const commonDatabaseRoots = ['db', 'database', 'prisma', 'migrations'];
+function hasPythonEntrypointEvidence(context) {
+    return context.hasFile('app.py') ||
+        context.hasFile('main.py') ||
+        context.hasFile('__main__.py') ||
+        context.hasAnyPathMatchingPattern(/(^|\/)(app|src)\/(main|app|__main__)\.py$/u);
+}
+function hasPythonPackageEvidence(context) {
+    return context.hasAnyPathMatchingPattern(/(^|\/)(src\/)?[a-zA-Z_][\w-]*\/__init__\.py$/u);
+}
+function hasPythonRuntimeDependencyEvidence(context) {
+    return [
+        'fastapi',
+        'django',
+        'flask',
+        'uvicorn',
+        'gunicorn',
+        'sqlalchemy',
+        'pydantic',
+    ].some((dependency) => context.hasFileMatchingPattern('pyproject.toml', new RegExp(`\\b${dependency}\\b`, 'iu')) || context.hasFileMatchingPattern('requirements.txt', new RegExp(`\\b${dependency}\\b`, 'iu')));
+}
+function hasGoEntrypointEvidence(context) {
+    return context.hasFile('main.go') ||
+        context.hasAnyPathMatchingPattern(/(^|\/)cmd\/[^/]+\/main\.go$/u) ||
+        context.hasAnyFileMatchingPattern(/(^|\/).+\.go$/u, /\bpackage\s+main\b/u);
+}
+function hasGoServerDependencyEvidence(context) {
+    return context.hasFileMatchingPattern('go.mod', /\b(github\.com\/go-chi\/chi|github\.com\/gin-gonic\/gin|github\.com\/gorilla\/mux|github\.com\/labstack\/echo|connectrpc\.com\/connect)\b/u);
+}
+const genericDefaultAdapter = buildAdapter({
+    id: 'other',
+    displayName: stackMetadata_1.canonicalStackLabels.other,
+    ecosystem: 'other',
+    category: 'fallback',
+    priority: 0,
+    manifestDetectionHints: [],
+    buildToolHints: [],
+    defaults: {
+        sourceRoots: ['src'],
+        moduleRootCandidates: ['src/modules', 'src'],
+        apiRoots: [...commonApiRoots],
+        databaseRoots: [...commonDatabaseRoots],
+        configFiles: [],
+        fileExtensions: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.py', '.java', '.php', '.go'],
+        dependencyFileExtensions: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'],
+        ignoreDirectories: [...commonIgnoreDirectories],
+        entrypointHints: ['index.*', 'main.*'],
+        publicEntrypointDirectories: ['public'],
+        moduleIndexFileName: 'index.ts',
+    },
+    detect: () => null,
+    getImportExtractionMode: () => 'generic',
+});
+const nodeTypescriptAdapter = buildAdapter({
+    id: 'node_typescript',
+    displayName: stackMetadata_1.canonicalStackLabels.node_typescript,
+    ecosystem: 'node',
+    category: 'generic-language',
+    priority: 40,
+    manifestDetectionHints: ['package.json', 'tsconfig.json'],
+    buildToolHints: ['npm', 'pnpm', 'yarn'],
+    defaults: {
+        sourceRoots: ['src/modules', 'src'],
+        moduleRootCandidates: ['src/modules', 'src'],
+        apiRoots: ['src/api', 'api'],
+        databaseRoots: ['prisma', 'db', 'database', 'migrations'],
+        configFiles: ['package.json', 'tsconfig.json'],
+        fileExtensions: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'],
+        dependencyFileExtensions: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'],
+        ignoreDirectories: [...commonIgnoreDirectories],
+        entrypointHints: ['index.ts', 'index.tsx', 'main.ts', 'main.tsx', 'index.js', 'main.js'],
+        publicEntrypointDirectories: ['public'],
+        moduleIndexFileName: 'index.ts',
+    },
+    detect: (context) => {
+        const hasPackageJson = context.hasFile('package.json');
+        const hasTsConfig = context.hasFile('tsconfig.json');
+        if (hasPackageJson && hasTsConfig) {
+            return toResult({
+                adapterId: 'node_typescript',
+                confidence: 'high',
+                score: 88,
+                evidence: ['Found package.json', 'Found tsconfig.json'],
+                projectKindHints: ['backend', 'library'],
+            });
+        }
+        if (hasPackageJson) {
+            return toResult({
+                adapterId: 'node_typescript',
+                confidence: 'medium',
+                score: 54,
+                evidence: ['Found package.json without tsconfig.json'],
+                projectKindHints: ['backend', 'library'],
+            });
+        }
+        return null;
+    },
+    resolveProjectKinds: () => ['backend', 'library'],
+    getImportExtractionMode: () => 'typescript-imports',
+});
+const stackAdaptersById = {
+    other: genericDefaultAdapter,
+    node_typescript: nodeTypescriptAdapter,
+    express: buildAdapter({
+        id: 'express',
+        displayName: stackMetadata_1.canonicalStackLabels.express,
+        ecosystem: 'node',
+        category: 'framework',
+        priority: 70,
+        manifestDetectionHints: ['package.json', 'tsconfig.json', 'app.js', 'app.ts', 'server.js', 'server.ts'],
+        buildToolHints: ['npm', 'pnpm', 'yarn'],
+        defaults: {
+            sourceRoots: ['src', '.'],
+            moduleRootCandidates: ['src/modules', 'src/features', 'routes', 'src/routes', 'src'],
+            apiRoots: ['routes', 'src/routes', 'src/api', 'api'],
+            databaseRoots: ['prisma', 'db', 'database', 'migrations'],
+            configFiles: ['package.json', 'tsconfig.json'],
+            fileExtensions: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'],
+            dependencyFileExtensions: ['.ts', '.js', '.mjs', '.cjs'],
+            ignoreDirectories: ['node_modules', 'dist', 'coverage'],
+            entrypointHints: ['app.ts', 'server.ts', 'src/app.ts', 'src/server.ts', 'app.js', 'server.js', 'src/app.js', 'src/server.js'],
+            publicEntrypointDirectories: ['public'],
+            moduleIndexFileName: 'index.ts',
+        },
+        detect: (context) => {
+            const evidence = [];
+            let strongSignals = 0;
+            let mediumSignals = 0;
+            let score = 0;
+            const hasExpressDependency = context.hasPackageDependency('express');
+            const hasExpressFactory = context.hasAnyFileMatchingPattern(/\.(ts|js|mjs|cjs)$/iu, /\bexpress\s*\(\s*\)/u);
+            const hasExpressImport = context.hasAnyFileMatchingPattern(/\.(ts|js|mjs|cjs)$/iu, /\b(import\s+express\s+from\s+['"]express['"]|require\s*\(\s*['"]express['"]\s*\))/u);
+            const hasAppUse = context.hasAnyFileMatchingPattern(/\.(ts|js|mjs|cjs)$/iu, /\bapp\.use\s*\(/u);
+            const hasRouterUsage = context.hasAnyFileMatchingPattern(/\.(ts|js|mjs|cjs)$/iu, /\b(router|Router)\s*\.\s*(get|post|put|patch|delete|use)\s*\(/u);
+            const hasRoutesDirectory = context.hasDirectory('routes') || context.hasDirectory('src/routes');
+            const hasRouteFiles = context.hasAnyPathMatchingPattern(/(^|\/)(routes|src\/routes)\/.+\.(ts|js|mjs|cjs)$/iu);
+            if (hasExpressDependency) {
+                strongSignals += 1;
+                score += 46;
+                evidence.push('Found package.json with express dependency');
+            }
+            if (hasExpressFactory) {
+                strongSignals += 1;
+                score += 28;
+                evidence.push('Found express() app construction');
+            }
+            if (hasExpressImport) {
+                mediumSignals += 1;
+                score += 12;
+                evidence.push('Found Express import or require');
+            }
+            if (hasAppUse) {
+                mediumSignals += 1;
+                score += 10;
+                evidence.push('Found app.use(...) middleware or router mounting');
+            }
+            if (hasRouterUsage) {
+                mediumSignals += 1;
+                score += 10;
+                evidence.push('Found router HTTP method usage');
+            }
+            if (hasRoutesDirectory) {
+                mediumSignals += 1;
+                score += 6;
+                evidence.push('Found routes/ or src/routes/ directory');
+            }
+            if (hasRouteFiles) {
+                mediumSignals += 1;
+                score += 5;
+                evidence.push('Found route files under routes/');
+            }
+            const hasSafeExpressEvidence = hasExpressDependency &&
+                (hasExpressFactory || hasExpressImport || hasAppUse || hasRouterUsage || hasRoutesDirectory);
+            if (!hasSafeExpressEvidence) {
+                return null;
+            }
+            const confidence = strongSignals >= 2 || (strongSignals >= 1 && mediumSignals >= 2)
+                ? 'high'
+                : strongSignals >= 1
+                    ? 'medium'
+                    : 'low';
+            return toResult({
+                adapterId: 'express',
+                confidence,
+                score,
+                evidence,
+                projectKindHints: ['backend'],
+                apiStyleHint: 'rest',
+            });
+        },
+        resolveProjectKinds: () => ['backend'],
+        getImportExtractionMode: () => 'typescript-imports',
+    }),
+    nestjs: buildAdapter({
+        id: 'nestjs',
+        displayName: stackMetadata_1.canonicalStackLabels.nestjs,
+        ecosystem: 'node',
+        category: 'framework',
+        priority: 75,
+        manifestDetectionHints: ['package.json', 'nest-cli.json', 'tsconfig.json', 'tsconfig.build.json', 'main.ts', 'app.module.ts'],
+        buildToolHints: ['npm', 'pnpm', 'yarn'],
+        defaults: {
+            sourceRoots: ['src'],
+            moduleRootCandidates: ['src/modules', 'src', 'src/app'],
+            apiRoots: ['src'],
+            databaseRoots: ['prisma', 'src/database', 'src/db', 'src/persistence', 'migrations'],
+            configFiles: ['package.json', 'nest-cli.json', 'tsconfig.json', 'tsconfig.build.json'],
+            fileExtensions: ['.ts', '.js', '.json', '.prisma', '.sql', '.yaml', '.yml'],
+            dependencyFileExtensions: ['.ts', '.js'],
+            ignoreDirectories: ['node_modules', 'dist', 'coverage'],
+            entrypointHints: ['src/main.ts'],
+            publicEntrypointDirectories: [],
+            moduleIndexFileName: 'main.ts',
+        },
+        detect: (context) => {
+            const evidence = [];
+            let strongSignals = 0;
+            let mediumSignals = 0;
+            let weakSignals = 0;
+            let score = 0;
+            const hasNestCore = context.hasPackageDependency('@nestjs/core');
+            const hasNestCommon = context.hasPackageDependency('@nestjs/common');
+            const hasNestCli = context.hasPackageDependency('@nestjs/cli');
+            const hasModuleDecorator = context.hasAnyFileMatchingPattern(/\.(ts|js)$/iu, /@Module\s*\(/u);
+            const hasControllerDecorator = context.hasAnyFileMatchingPattern(/\.(ts|js)$/iu, /@Controller\s*\(/u);
+            const hasInjectableDecorator = context.hasAnyFileMatchingPattern(/\.(ts|js)$/iu, /@Injectable\s*\(/u);
+            const hasNestFactoryCreate = context.hasAnyFileMatchingPattern(/\.(ts|js)$/iu, /\bNestFactory\.create\s*\(/u);
+            const hasMainTsBootstrap = context.getPaths('main.ts').some((value) => value === 'src/main.ts') &&
+                context.hasFileMatchingPattern('main.ts', /\bNestFactory\.create(?:<[^>]+>)?\s*\(/u);
+            const hasSrcMainTsWithNestDeps = context.getPaths('main.ts').some((value) => value === 'src/main.ts') &&
+                (hasNestCore || hasNestCommon || hasNestCli);
+            const hasRouteDecorator = context.hasAnyFileMatchingPattern(/\.(ts|js)$/iu, /@(Get|Post|Put|Delete)\s*\(/u);
+            const hasNestFastifyBootstrap = context.hasAnyFileMatchingPattern(/\.(ts|js)$/iu, /\bNestFactory\.create<\s*NestFastifyApplication\s*>\s*\(/u);
+            const hasNestFastifyPlatform = context.hasPackageDependency('@nestjs/platform-fastify');
+            const hasNestExpressPlatform = context.hasPackageDependency('@nestjs/platform-express');
+            const hasAppModuleTs = context.getPaths('app.module.ts').some((value) => value === 'src/app.module.ts');
+            const hasModuleFile = context.hasAnyPathMatchingPattern(/(^|\/)src\/.+\.module\.ts$/iu);
+            const hasControllerFile = context.hasAnyPathMatchingPattern(/(^|\/)src\/.+\.controller\.ts$/iu);
+            const hasServiceFile = context.hasAnyPathMatchingPattern(/(^|\/)src\/.+\.service\.ts$/iu);
+            const hasFastifyDependency = context.hasPackageDependency('fastify');
+            const hasNestLayout = context.hasDirectory('src');
+            const hasTestDirectory = context.hasDirectory('test');
+            const hasNestCliConfig = context.hasFile('nest-cli.json');
+            const hasTsConfigBuild = context.hasFile('tsconfig.build.json');
+            const hasSafeNestCoreEvidence = hasNestCore ||
+                hasNestCommon ||
+                hasNestCli ||
+                ((hasModuleDecorator || hasControllerDecorator || hasInjectableDecorator || hasNestFactoryCreate) &&
+                    (hasNestLayout || hasAppModuleTs));
+            if (hasNestCore) {
+                strongSignals += 1;
+                score += 36;
+                evidence.push('Found package.json with @nestjs/core dependency');
+            }
+            if (hasNestCommon) {
+                strongSignals += 1;
+                score += 34;
+                evidence.push('Found package.json with @nestjs/common dependency');
+            }
+            if (hasNestCli) {
+                strongSignals += 1;
+                score += 24;
+                evidence.push('Found package.json with @nestjs/cli dependency');
+            }
+            if (hasModuleDecorator) {
+                strongSignals += 1;
+                score += 28;
+                evidence.push('Found @Module decorator in source');
+            }
+            if (hasControllerDecorator) {
+                strongSignals += 1;
+                score += 24;
+                evidence.push('Found @Controller decorator in source');
+            }
+            if (hasInjectableDecorator) {
+                strongSignals += 1;
+                score += 18;
+                evidence.push('Found @Injectable decorator in source');
+            }
+            if (hasNestFactoryCreate) {
+                strongSignals += 1;
+                score += 26;
+                evidence.push('Found NestFactory.create bootstrap');
+            }
+            if (hasMainTsBootstrap) {
+                strongSignals += 1;
+                score += 18;
+                evidence.push('Found NestFactory bootstrap in src/main.ts');
+            }
+            if (hasSrcMainTsWithNestDeps) {
+                strongSignals += 1;
+                score += 16;
+                evidence.push('Found src/main.ts with NestJS dependency evidence');
+            }
+            if (hasRouteDecorator) {
+                mediumSignals += 1;
+                score += 10;
+                evidence.push('Found Nest-style route decorator in source');
+            }
+            if (hasNestFastifyBootstrap) {
+                mediumSignals += 1;
+                score += 10;
+                evidence.push('Found NestFastifyApplication bootstrap evidence');
+            }
+            if (hasNestFastifyPlatform) {
+                mediumSignals += 1;
+                score += 8;
+                evidence.push('Found package.json with @nestjs/platform-fastify dependency');
+            }
+            if (hasNestExpressPlatform) {
+                mediumSignals += 1;
+                score += 7;
+                evidence.push('Found package.json with @nestjs/platform-express dependency');
+            }
+            if (hasAppModuleTs) {
+                mediumSignals += 1;
+                score += 8;
+                evidence.push('Found src/app.module.ts');
+            }
+            if (hasModuleFile) {
+                mediumSignals += 1;
+                score += 7;
+                evidence.push('Found module file under src/');
+            }
+            if (hasControllerFile) {
+                mediumSignals += 1;
+                score += 7;
+                evidence.push('Found controller file under src/');
+            }
+            if (hasServiceFile) {
+                mediumSignals += 1;
+                score += 6;
+                evidence.push('Found service file under src/');
+            }
+            if (hasNestLayout) {
+                weakSignals += 1;
+                score += 2;
+                evidence.push('Found typical NestJS src/ layout');
+            }
+            if (hasTestDirectory) {
+                weakSignals += 1;
+                score += 2;
+                evidence.push('Found test directory');
+            }
+            if (hasNestCliConfig) {
+                weakSignals += 1;
+                score += 3;
+                evidence.push('Found nest-cli.json');
+            }
+            if (hasTsConfigBuild) {
+                weakSignals += 1;
+                score += 2;
+                evidence.push('Found tsconfig.build.json');
+            }
+            if (hasFastifyDependency && hasSafeNestCoreEvidence) {
+                weakSignals += 1;
+                score += 3;
+                evidence.push('Found fastify dependency with NestJS evidence');
+            }
+            if (!hasSafeNestCoreEvidence || strongSignals === 0) {
+                return null;
+            }
+            const hasRestEvidence = hasControllerDecorator || hasRouteDecorator || hasControllerFile;
+            const confidence = strongSignals >= 2
+                ? 'high'
+                : strongSignals >= 1 || mediumSignals >= 3 || (mediumSignals >= 2 && weakSignals >= 1)
+                    ? 'medium'
+                    : 'low';
+            return toResult({
+                adapterId: 'nestjs',
+                confidence,
+                score,
+                evidence,
+                projectKindHints: ['backend'],
+                apiStyleHint: hasRestEvidence ? 'rest' : 'unknown',
+            });
+        },
+        resolveProjectKinds: () => ['backend'],
+        getImportExtractionMode: () => 'typescript-imports',
+    }),
+    java: buildAdapter({
+        id: 'java',
+        displayName: stackMetadata_1.canonicalStackLabels.java,
+        ecosystem: 'jvm',
+        category: 'generic-language',
+        priority: 40,
+        manifestDetectionHints: [
+            'pom.xml',
+            'build.gradle',
+            'build.gradle.kts',
+            'settings.gradle',
+            'settings.gradle.kts',
+        ],
+        buildToolHints: ['maven', 'gradle'],
+        defaults: {
+            sourceRoots: ['src/main/java', 'src'],
+            moduleRootCandidates: ['src/main/java', 'src'],
+            apiRoots: ['src/main/java', 'src/main/kotlin'],
+            databaseRoots: ['src/main/resources/db', 'src/main/resources/migrations'],
+            configFiles: ['pom.xml', 'build.gradle', 'build.gradle.kts'],
+            fileExtensions: ['.java'],
+            dependencyFileExtensions: ['.java'],
+            ignoreDirectories: [
+                'target',
+                'build',
+                '.gradle',
+                '.idea',
+                'out',
+                ...commonIgnoreDirectories,
+            ],
+            entrypointHints: ['Application.java', 'Main.java', '*Application.java', '*Module.java'],
+            publicEntrypointDirectories: [],
+            moduleIndexFileName: 'Application.java',
+        },
+        detect: (context) => {
+            if (context.hasFile('pom.xml')) {
+                return toResult({
+                    adapterId: 'java',
+                    confidence: 'high',
+                    score: 92,
+                    evidence: ['Found pom.xml'],
+                    projectKindHints: ['backend'],
+                    apiStyleHint: 'unknown',
+                });
+            }
+            if (context.hasFile('build.gradle') || context.hasFile('build.gradle.kts')) {
+                return toResult({
+                    adapterId: 'java',
+                    confidence: 'high',
+                    score: 90,
+                    evidence: [
+                        context.hasFile('build.gradle') ? 'Found build.gradle' : 'Found build.gradle.kts',
+                    ],
+                    projectKindHints: ['backend'],
+                    apiStyleHint: 'unknown',
+                });
+            }
+            if (context.hasFileExtension('.java')) {
+                return toResult({
+                    adapterId: 'java',
+                    confidence: 'medium',
+                    score: 64,
+                    evidence: ['Found .java source files'],
+                    projectKindHints: ['backend'],
+                    apiStyleHint: 'unknown',
+                });
+            }
+            return null;
+        },
+        resolveProjectKinds: () => ['backend'],
+        getImportExtractionMode: () => 'java-imports',
+    }),
+    spring: buildAdapter({
+        id: 'spring',
+        displayName: stackMetadata_1.canonicalStackLabels.spring,
+        ecosystem: 'jvm',
+        category: 'framework',
+        priority: 70,
+        manifestDetectionHints: [
+            'pom.xml',
+            'build.gradle',
+            'build.gradle.kts',
+            'application.yml',
+            'application.yaml',
+            'application.properties',
+            'bootstrap.yml',
+            'bootstrap.yaml',
+            'mvnw',
+            'gradlew',
+        ],
+        buildToolHints: ['maven', 'gradle'],
+        defaults: {
+            sourceRoots: ['src/main/java', 'src/main/kotlin', 'src'],
+            moduleRootCandidates: ['src/main/java', 'src/main/kotlin'],
+            apiRoots: ['src/main/java', 'src/main/kotlin'],
+            databaseRoots: ['src/main/resources', 'src/main/resources/db'],
+            configFiles: [
+                'pom.xml',
+                'build.gradle',
+                'build.gradle.kts',
+                'application.yml',
+                'application.yaml',
+                'application.properties',
+            ],
+            fileExtensions: ['.java', '.kt', '.yml', '.yaml', '.properties', '.sql'],
+            dependencyFileExtensions: ['.java', '.kt'],
+            ignoreDirectories: [
+                'target',
+                'build',
+                '.gradle',
+                '.idea',
+                'out',
+                ...commonIgnoreDirectories,
+            ],
+            entrypointHints: ['src/main/java', 'src/main/kotlin', 'Application.java', 'Application.kt'],
+            publicEntrypointDirectories: [],
+            moduleIndexFileName: 'Application.java',
+        },
+        detect: (context) => {
+            const evidence = [];
+            let strongSignals = 0;
+            let mediumSignals = 0;
+            let weakSignals = 0;
+            let score = 0;
+            const hasPomSpringDependency = context.hasFileMatchingPattern('pom.xml', /\b(org\.springframework\.boot|spring-boot-starter|spring-web)\b/iu);
+            const hasGradleSpringDependency = context.hasFileMatchingPattern('build.gradle', /\b(org\.springframework\.boot|spring-boot-starter|spring-web|id\s+['"]org\.springframework\.boot['"])\b/iu) ||
+                context.hasFileMatchingPattern('build.gradle.kts', /\b(org\.springframework\.boot|spring-boot-starter|spring-web|id\s*\(\s*["']org\.springframework\.boot["']\s*\))\b/iu);
+            const hasSpringDependencyEvidence = hasPomSpringDependency || hasGradleSpringDependency;
+            const hasSpringBootApplication = context.hasAnyFileMatchingPattern(/\.(java|kt)$/iu, /@SpringBootApplication\b/u);
+            const hasMainSourceWithDependencies = (context.hasDirectory('src/main/java') || context.hasDirectory('src/main/kotlin')) &&
+                hasSpringDependencyEvidence;
+            const hasApplicationConfigWithDependencies = (context.hasFile('application.yml') ||
+                context.hasFile('application.yaml') ||
+                context.hasFile('application.properties')) &&
+                hasSpringDependencyEvidence;
+            const hasRestController = context.hasAnyFileMatchingPattern(/\.(java|kt)$/iu, /@RestController\b/u);
+            const hasController = context.hasAnyFileMatchingPattern(/\.(java|kt)$/iu, /@Controller\b/u);
+            const hasService = context.hasAnyFileMatchingPattern(/\.(java|kt)$/iu, /@Service\b/u);
+            const hasRepository = context.hasAnyFileMatchingPattern(/\.(java|kt)$/iu, /@Repository\b/u);
+            const hasMappingAnnotation = context.hasAnyFileMatchingPattern(/\.(java|kt)$/iu, /@(RequestMapping|GetMapping|PostMapping|PutMapping|DeleteMapping)\b/u);
+            const hasResourcesDirectory = context.hasDirectory('src/main/resources');
+            const hasWrapperWithSpringEvidence = (context.hasFile('mvnw') || context.hasFile('gradlew')) && hasSpringDependencyEvidence;
+            const hasTestJvmSource = context.hasDirectory('src/test/java') || context.hasDirectory('src/test/kotlin');
+            const hasBootstrapConfig = context.hasFile('bootstrap.yml') || context.hasFile('bootstrap.yaml');
+            const hasJvmPackageShape = context.hasDirectory('src/main/java/com') ||
+                context.hasDirectory('src/main/java/org') ||
+                context.hasDirectory('src/main/kotlin/com') ||
+                context.hasDirectory('src/main/kotlin/org');
+            if (hasPomSpringDependency) {
+                strongSignals += 1;
+                score += 54;
+                evidence.push('Found pom.xml with Spring dependency markers');
+            }
+            if (hasGradleSpringDependency) {
+                strongSignals += 1;
+                score += 54;
+                evidence.push('Found Gradle build with Spring plugin or dependency markers');
+            }
+            if (hasSpringBootApplication) {
+                strongSignals += 1;
+                score += 44;
+                evidence.push('Found @SpringBootApplication in source');
+            }
+            if (hasMainSourceWithDependencies) {
+                strongSignals += 1;
+                score += 20;
+                evidence.push('Found JVM main source root with Spring dependency evidence');
+            }
+            if (hasApplicationConfigWithDependencies) {
+                strongSignals += 1;
+                score += 20;
+                evidence.push('Found application config with Spring dependency evidence');
+            }
+            if (hasRestController) {
+                mediumSignals += 1;
+                score += 10;
+                evidence.push('Found @RestController annotation');
+            }
+            if (hasController) {
+                mediumSignals += 1;
+                score += 7;
+                evidence.push('Found @Controller annotation');
+            }
+            if (hasService) {
+                mediumSignals += 1;
+                score += 6;
+                evidence.push('Found @Service annotation');
+            }
+            if (hasRepository) {
+                mediumSignals += 1;
+                score += 6;
+                evidence.push('Found @Repository annotation');
+            }
+            if (hasMappingAnnotation) {
+                mediumSignals += 1;
+                score += 9;
+                evidence.push('Found Spring request-mapping annotation');
+            }
+            if (hasResourcesDirectory) {
+                mediumSignals += 1;
+                score += 5;
+                evidence.push('Found src/main/resources directory');
+            }
+            if (hasWrapperWithSpringEvidence) {
+                mediumSignals += 1;
+                score += 4;
+                evidence.push('Found Maven/Gradle wrapper with Spring dependency evidence');
+            }
+            if (hasTestJvmSource) {
+                weakSignals += 1;
+                score += 2;
+                evidence.push('Found JVM test source directory');
+            }
+            if (hasBootstrapConfig) {
+                weakSignals += 1;
+                score += 2;
+                evidence.push('Found bootstrap.yml or bootstrap.yaml');
+            }
+            if (hasJvmPackageShape) {
+                weakSignals += 1;
+                score += 1;
+                evidence.push('Found conventional JVM package directory under main source root');
+            }
+            const hasSafeSpringCoreEvidence = hasSpringDependencyEvidence ||
+                hasSpringBootApplication ||
+                ((hasRestController || hasController || hasService || hasRepository || hasMappingAnnotation) &&
+                    (context.hasDirectory('src/main/java') || context.hasDirectory('src/main/kotlin') || hasResourcesDirectory));
+            if (!hasSafeSpringCoreEvidence || strongSignals === 0) {
+                return null;
+            }
+            const hasRestEvidence = hasRestController || hasController || hasMappingAnnotation;
+            const confidence = strongSignals >= 2
+                ? 'high'
+                : strongSignals >= 1 || mediumSignals >= 3 || (mediumSignals >= 2 && weakSignals >= 1)
+                    ? 'medium'
+                    : 'low';
+            return toResult({
+                adapterId: 'spring',
+                confidence,
+                score,
+                evidence,
+                projectKindHints: ['backend'],
+                apiStyleHint: hasRestEvidence ? 'rest' : 'unknown',
+            });
+        },
+        resolveProjectKinds: () => ['backend'],
+        getImportExtractionMode: () => 'java-imports',
+    }),
+    fastapi: buildAdapter({
+        id: 'fastapi',
+        displayName: stackMetadata_1.canonicalStackLabels.fastapi,
+        ecosystem: 'python',
+        category: 'framework',
+        priority: 70,
+        manifestDetectionHints: [
+            'requirements.txt',
+            'pyproject.toml',
+            'Pipfile',
+            'Pipfile.lock',
+            'poetry.lock',
+            'alembic.ini',
+            'main.py',
+            'app.py',
+        ],
+        buildToolHints: ['pip', 'poetry', 'uvicorn'],
+        defaults: {
+            sourceRoots: ['app', 'src', '.'],
+            moduleRootCandidates: ['app', 'src/app', 'src', 'routers', 'api'],
+            apiRoots: ['app', 'src', 'routers', 'api'],
+            databaseRoots: ['app/db', 'app/database', 'src/db', 'src/database', 'migrations', 'alembic'],
+            configFiles: [
+                'requirements.txt',
+                'pyproject.toml',
+                'Pipfile',
+                'Pipfile.lock',
+                'poetry.lock',
+                'alembic.ini',
+            ],
+            fileExtensions: ['.py', '.toml', '.txt', '.ini', '.sql', '.yaml', '.yml'],
+            dependencyFileExtensions: ['.py'],
+            ignoreDirectories: [
+                '__pycache__',
+                '.pytest_cache',
+                '.venv',
+                'venv',
+                'dist',
+                'build',
+                '.idea',
+                ...commonIgnoreDirectories,
+            ],
+            entrypointHints: ['main.py', 'app.py', 'app/main.py', 'src/main.py'],
+            publicEntrypointDirectories: [],
+            moduleIndexFileName: '__init__.py',
+        },
+        detect: (context) => {
+            const evidence = [];
+            let strongSignals = 0;
+            let mediumSignals = 0;
+            let weakSignals = 0;
+            let score = 0;
+            const hasRequirementsFastApi = context.hasFileMatchingPattern('requirements.txt', /(^|\s)fastapi([=<>~!]|$)/imu);
+            const hasPyprojectFastApi = context.hasFileMatchingPattern('pyproject.toml', /\bfastapi\b/iu);
+            const hasPoetryLockFastApi = context.hasFileMatchingPattern('poetry.lock', /\bname\s*=\s*["']fastapi["']/iu);
+            const hasPipfileFastApi = context.hasFileMatchingPattern('Pipfile', /\bfastapi\b/iu);
+            const hasPipfileLockFastApi = context.hasFileMatchingPattern('Pipfile.lock', /"fastapi"\s*:/iu);
+            const hasFastApiDependencyEvidence = hasRequirementsFastApi ||
+                hasPyprojectFastApi ||
+                hasPoetryLockFastApi ||
+                hasPipfileFastApi ||
+                hasPipfileLockFastApi;
+            const hasFastApiImport = context.hasAnyFileMatchingPattern(/\.py$/iu, /\bfrom\s+fastapi\s+import\s+FastAPI\b/u);
+            const hasFastApiConstruction = context.hasAnyFileMatchingPattern(/\.py$/iu, /\b\w+\s*=\s*FastAPI\s*\(/u);
+            const hasRouteDecorator = context.hasAnyFileMatchingPattern(/\.py$/iu, /@(?:app|router)\.(?:get|post|put|delete)\s*\(/u);
+            const hasApiRouter = context.hasAnyFileMatchingPattern(/\.py$/iu, /\bAPIRouter\b/u);
+            const hasUvicornDependency = context.hasFileMatchingPattern('requirements.txt', /(^|\s)uvicorn([=<>~!]|$)/imu) ||
+                context.hasFileMatchingPattern('pyproject.toml', /\buvicorn\b/iu) ||
+                context.hasFileMatchingPattern('poetry.lock', /\bname\s*=\s*["']uvicorn["']/iu) ||
+                context.hasFileMatchingPattern('Pipfile', /\buvicorn\b/iu) ||
+                context.hasFileMatchingPattern('Pipfile.lock', /"uvicorn"\s*:/iu);
+            const hasStarletteDependency = context.hasFileMatchingPattern('requirements.txt', /(^|\s)starlette([=<>~!]|$)/imu) ||
+                context.hasFileMatchingPattern('pyproject.toml', /\bstarlette\b/iu) ||
+                context.hasFileMatchingPattern('poetry.lock', /\bname\s*=\s*["']starlette["']/iu) ||
+                context.hasFileMatchingPattern('Pipfile', /\bstarlette\b/iu) ||
+                context.hasFileMatchingPattern('Pipfile.lock', /"starlette"\s*:/iu);
+            const hasPydanticDependency = context.hasFileMatchingPattern('requirements.txt', /(^|\s)pydantic([=<>~!]|$)/imu) ||
+                context.hasFileMatchingPattern('pyproject.toml', /\bpydantic\b/iu) ||
+                context.hasFileMatchingPattern('poetry.lock', /\bname\s*=\s*["']pydantic["']/iu) ||
+                context.hasFileMatchingPattern('Pipfile', /\bpydantic\b/iu) ||
+                context.hasFileMatchingPattern('Pipfile.lock', /"pydantic"\s*:/iu);
+            const hasUvicornWithFastApiEvidence = hasUvicornDependency && (hasFastApiDependencyEvidence || hasFastApiImport || hasFastApiConstruction);
+            const hasSrcOrAppWithImportEvidence = (context.hasDirectory('src') || context.hasDirectory('app')) && hasFastApiImport;
+            const hasEntryPointConstruction = context.hasAnyFileMatchingPattern(/(^|\/)(main|app)\.py$/iu, /\b\w+\s*=\s*FastAPI\s*\(/u);
+            const hasRoutersDirectoryWithImportEvidence = context.hasDirectory('routers') &&
+                (hasFastApiImport || hasApiRouter || hasRouteDecorator);
+            const hasUvicornOrStarletteWithFastApiEvidence = (hasUvicornDependency || hasStarletteDependency) &&
+                (hasFastApiDependencyEvidence || hasFastApiImport || hasFastApiConstruction);
+            const hasSupportingBackendLayout = context.hasDirectory('app') ||
+                context.hasDirectory('src') ||
+                context.hasDirectory('routers') ||
+                context.hasDirectory('api');
+            if (hasRequirementsFastApi) {
+                strongSignals += 1;
+                score += 54;
+                evidence.push('Found requirements.txt with fastapi dependency');
+            }
+            if (hasPyprojectFastApi) {
+                strongSignals += 1;
+                score += 54;
+                evidence.push('Found pyproject.toml with fastapi dependency');
+            }
+            if (hasPoetryLockFastApi || hasPipfileFastApi || hasPipfileLockFastApi) {
+                strongSignals += 1;
+                score += 52;
+                evidence.push('Found Pipfile/lock metadata with fastapi dependency');
+            }
+            if (hasFastApiImport) {
+                strongSignals += 1;
+                score += 44;
+                evidence.push('Found FastAPI import in source');
+            }
+            if (hasFastApiConstruction) {
+                strongSignals += 1;
+                score += 40;
+                evidence.push('Found FastAPI application construction in source');
+            }
+            if (hasRouteDecorator) {
+                strongSignals += 1;
+                score += 26;
+                evidence.push('Found FastAPI route decorator in source');
+            }
+            if (hasUvicornWithFastApiEvidence) {
+                strongSignals += 1;
+                score += 20;
+                evidence.push('Found uvicorn with FastAPI evidence');
+            }
+            if (hasApiRouter) {
+                mediumSignals += 1;
+                score += 10;
+                evidence.push('Found APIRouter usage');
+            }
+            if (hasSrcOrAppWithImportEvidence) {
+                mediumSignals += 1;
+                score += 8;
+                evidence.push('Found app/ or src/ directory with FastAPI import evidence');
+            }
+            if (hasEntryPointConstruction) {
+                mediumSignals += 1;
+                score += 8;
+                evidence.push('Found main.py or app.py with FastAPI application construction');
+            }
+            if (hasRoutersDirectoryWithImportEvidence) {
+                mediumSignals += 1;
+                score += 7;
+                evidence.push('Found routers/ directory with FastAPI source evidence');
+            }
+            if (hasUvicornOrStarletteWithFastApiEvidence) {
+                mediumSignals += 1;
+                score += 6;
+                evidence.push('Found uvicorn or starlette with FastAPI evidence');
+            }
+            if (hasSupportingBackendLayout) {
+                weakSignals += 1;
+                score += 2;
+                evidence.push('Found typical Python backend layout directory');
+            }
+            if (hasPydanticDependency) {
+                weakSignals += 1;
+                score += 1;
+                evidence.push('Found pydantic dependency as supporting evidence');
+            }
+            const hasSafeFastApiCoreEvidence = hasFastApiDependencyEvidence ||
+                (hasFastApiImport && hasFastApiConstruction) ||
+                (hasFastApiImport && (hasRouteDecorator || hasApiRouter));
+            if (!hasSafeFastApiCoreEvidence || strongSignals === 0) {
+                return null;
+            }
+            const hasRestEvidence = hasRouteDecorator || hasApiRouter;
+            const confidence = strongSignals >= 2
+                ? 'high'
+                : strongSignals >= 1 || mediumSignals >= 3 || (mediumSignals >= 2 && weakSignals >= 1)
+                    ? 'medium'
+                    : 'low';
+            return toResult({
+                adapterId: 'fastapi',
+                confidence,
+                score,
+                evidence,
+                projectKindHints: ['backend'],
+                apiStyleHint: hasRestEvidence ? 'rest' : 'unknown',
+            });
+        },
+        resolveProjectKinds: () => ['backend'],
+        getImportExtractionMode: () => 'python-imports',
+    }),
+    django: buildAdapter({
+        id: 'django',
+        displayName: stackMetadata_1.canonicalStackLabels.django,
+        ecosystem: 'python',
+        category: 'framework',
+        priority: 68,
+        manifestDetectionHints: [
+            'requirements.txt',
+            'pyproject.toml',
+            'Pipfile',
+            'Pipfile.lock',
+            'poetry.lock',
+            'manage.py',
+            'settings.py',
+            'urls.py',
+            'wsgi.py',
+            'asgi.py',
+        ],
+        buildToolHints: ['pip', 'poetry', 'django-admin'],
+        defaults: {
+            sourceRoots: ['.', 'src', 'app'],
+            moduleRootCandidates: ['.', 'src', 'app'],
+            apiRoots: ['.', 'src', 'app'],
+            databaseRoots: ['migrations', 'db', 'database'],
+            configFiles: ['requirements.txt', 'pyproject.toml', 'Pipfile', 'Pipfile.lock', 'poetry.lock', 'manage.py'],
+            fileExtensions: ['.py', '.toml', '.txt', '.sql', '.yaml', '.yml'],
+            dependencyFileExtensions: ['.py'],
+            ignoreDirectories: [
+                '__pycache__',
+                '.pytest_cache',
+                '.venv',
+                'venv',
+                'dist',
+                'build',
+                '.idea',
+                ...commonIgnoreDirectories,
+            ],
+            entrypointHints: ['manage.py', 'wsgi.py', 'asgi.py', 'settings.py', 'urls.py'],
+            publicEntrypointDirectories: [],
+            moduleIndexFileName: '__init__.py',
+        },
+        detect: (context) => {
+            const evidence = [];
+            let strongSignals = 0;
+            let mediumSignals = 0;
+            let weakSignals = 0;
+            let score = 0;
+            const hasRequirementsDjango = context.hasFileMatchingPattern('requirements.txt', /(^|\s)django([=<>~!]|$)/imu);
+            const hasPyprojectDjango = context.hasFileMatchingPattern('pyproject.toml', /\bdjango\b/iu);
+            const hasPoetryLockDjango = context.hasFileMatchingPattern('poetry.lock', /\bname\s*=\s*["']django["']/iu);
+            const hasPipfileDjango = context.hasFileMatchingPattern('Pipfile', /\bdjango\b/iu);
+            const hasPipfileLockDjango = context.hasFileMatchingPattern('Pipfile.lock', /"django"\s*:/iu);
+            const hasDjangoDependencyEvidence = hasRequirementsDjango ||
+                hasPyprojectDjango ||
+                hasPoetryLockDjango ||
+                hasPipfileDjango ||
+                hasPipfileLockDjango;
+            const hasManagePy = context.hasFile('manage.py');
+            const hasDjangoSettingsModule = context.hasFileMatchingPattern('manage.py', /\bDJANGO_SETTINGS_MODULE\b/u);
+            const hasSettingsPy = context.hasFile('settings.py');
+            const hasUrlsPy = context.hasFile('urls.py');
+            const hasWsgiOrAsgi = context.hasFile('wsgi.py') || context.hasFile('asgi.py');
+            const hasInstalledApps = context.hasFileMatchingPattern('settings.py', /\bINSTALLED_APPS\s*=/u);
+            const hasDjangoAdmin = context.hasAnyFileMatchingPattern(/(^|\/)(manage|settings|urls|wsgi|asgi)\.py$/iu, /\bdjango-admin\b/iu);
+            const hasDjangoImport = context.hasAnyFileMatchingPattern(/\.py$/iu, /\b(from|import)\s+django\b/u);
+            const hasDjangoUrlsImport = context.hasAnyFileMatchingPattern(/\.py$/iu, /\bfrom\s+django\.urls\s+import\s+(?:path|include|re_path)\b/u);
+            if (hasRequirementsDjango) {
+                strongSignals += 1;
+                score += 52;
+                evidence.push('Found requirements.txt with django dependency');
+            }
+            if (hasPyprojectDjango) {
+                strongSignals += 1;
+                score += 52;
+                evidence.push('Found pyproject.toml with django dependency');
+            }
+            if (hasPoetryLockDjango || hasPipfileDjango || hasPipfileLockDjango) {
+                strongSignals += 1;
+                score += 50;
+                evidence.push('Found Pipfile/lock metadata with django dependency');
+            }
+            if (hasManagePy) {
+                strongSignals += 1;
+                score += 34;
+                evidence.push('Found manage.py');
+            }
+            if (hasDjangoSettingsModule) {
+                strongSignals += 1;
+                score += 24;
+                evidence.push('Found DJANGO_SETTINGS_MODULE in manage.py');
+            }
+            if (hasInstalledApps) {
+                strongSignals += 1;
+                score += 24;
+                evidence.push('Found INSTALLED_APPS in settings.py');
+            }
+            if (hasDjangoImport) {
+                strongSignals += 1;
+                score += 22;
+                evidence.push('Found django import in source');
+            }
+            if (hasSettingsPy) {
+                mediumSignals += 1;
+                score += 12;
+                evidence.push('Found settings.py');
+            }
+            if (hasUrlsPy) {
+                mediumSignals += 1;
+                score += 10;
+                evidence.push('Found urls.py');
+            }
+            if (hasWsgiOrAsgi) {
+                mediumSignals += 1;
+                score += 10;
+                evidence.push('Found wsgi.py or asgi.py');
+            }
+            if (hasDjangoUrlsImport) {
+                mediumSignals += 1;
+                score += 10;
+                evidence.push('Found Django URL routing import');
+            }
+            if (hasDjangoAdmin) {
+                weakSignals += 1;
+                score += 3;
+                evidence.push('Found django-admin reference');
+            }
+            if (context.hasDirectory('migrations')) {
+                weakSignals += 1;
+                score += 2;
+                evidence.push('Found migrations directory');
+            }
+            const hasSafeDjangoCoreEvidence = hasDjangoDependencyEvidence ||
+                (hasManagePy && (hasDjangoSettingsModule || hasSettingsPy || hasUrlsPy || hasWsgiOrAsgi)) ||
+                (hasInstalledApps && (hasSettingsPy || hasDjangoImport)) ||
+                (hasDjangoImport && (hasDjangoUrlsImport || hasUrlsPy));
+            if (!hasSafeDjangoCoreEvidence || strongSignals === 0) {
+                return null;
+            }
+            const hasRestEvidence = hasUrlsPy || hasDjangoUrlsImport;
+            const confidence = strongSignals >= 2
+                ? 'high'
+                : strongSignals >= 1 || mediumSignals >= 3 || (mediumSignals >= 2 && weakSignals >= 1)
+                    ? 'medium'
+                    : 'low';
+            return toResult({
+                adapterId: 'django',
+                confidence,
+                score,
+                evidence,
+                projectKindHints: ['backend'],
+                apiStyleHint: hasRestEvidence ? 'rest' : 'unknown',
+            });
+        },
+        resolveProjectKinds: () => ['backend'],
+        getImportExtractionMode: () => 'python-imports',
+    }),
+    flask: buildAdapter({
+        id: 'flask',
+        displayName: stackMetadata_1.canonicalStackLabels.flask,
+        ecosystem: 'python',
+        category: 'framework',
+        priority: 66,
+        manifestDetectionHints: [
+            'requirements.txt',
+            'pyproject.toml',
+            'Pipfile',
+            'Pipfile.lock',
+            'poetry.lock',
+            'app.py',
+            'wsgi.py',
+            'main.py',
+        ],
+        buildToolHints: ['pip', 'poetry', 'flask'],
+        defaults: {
+            sourceRoots: ['app', 'src', '.'],
+            moduleRootCandidates: ['app', 'src/app', 'src', 'blueprints', 'api'],
+            apiRoots: ['app', 'src', 'blueprints', 'api'],
+            databaseRoots: ['migrations', 'app/db', 'app/database', 'src/db', 'src/database'],
+            configFiles: ['requirements.txt', 'pyproject.toml', 'Pipfile', 'Pipfile.lock', 'poetry.lock'],
+            fileExtensions: ['.py', '.toml', '.txt', '.sql', '.yaml', '.yml'],
+            dependencyFileExtensions: ['.py'],
+            ignoreDirectories: [
+                '__pycache__',
+                '.pytest_cache',
+                '.venv',
+                'venv',
+                'dist',
+                'build',
+                '.idea',
+                ...commonIgnoreDirectories,
+            ],
+            entrypointHints: ['app.py', 'main.py', 'wsgi.py', 'app/__init__.py'],
+            publicEntrypointDirectories: [],
+            moduleIndexFileName: '__init__.py',
+        },
+        detect: (context) => {
+            const evidence = [];
+            let strongSignals = 0;
+            let mediumSignals = 0;
+            let weakSignals = 0;
+            let score = 0;
+            const hasRequirementsFlask = context.hasFileMatchingPattern('requirements.txt', /(^|\s)flask([=<>~!]|$)/imu);
+            const hasPyprojectFlask = context.hasFileMatchingPattern('pyproject.toml', /\bflask\b/iu);
+            const hasPoetryLockFlask = context.hasFileMatchingPattern('poetry.lock', /\bname\s*=\s*["']flask["']/iu);
+            const hasPipfileFlask = context.hasFileMatchingPattern('Pipfile', /\bflask\b/iu);
+            const hasPipfileLockFlask = context.hasFileMatchingPattern('Pipfile.lock', /"flask"\s*:/iu);
+            const hasFlaskDependencyEvidence = hasRequirementsFlask ||
+                hasPyprojectFlask ||
+                hasPoetryLockFlask ||
+                hasPipfileFlask ||
+                hasPipfileLockFlask;
+            const hasFlaskImport = context.hasAnyFileMatchingPattern(/\.py$/iu, /\bfrom\s+flask\s+import\s+.*\bFlask\b/u);
+            const hasFlaskConstruction = context.hasAnyFileMatchingPattern(/\.py$/iu, /\b\w+\s*=\s*Flask\s*\(\s*__name__/u);
+            const hasRouteDecorator = context.hasAnyFileMatchingPattern(/\.py$/iu, /@\w+\.route\s*\(/u);
+            const hasMethodRouteDecorator = context.hasAnyFileMatchingPattern(/\.py$/iu, /@\w+\.(?:get|post|put|delete)\s*\(/u);
+            const hasBlueprintImport = context.hasAnyFileMatchingPattern(/\.py$/iu, /\bfrom\s+flask\s+import\s+.*\bBlueprint\b/u);
+            const hasBlueprintConstruction = context.hasAnyFileMatchingPattern(/\.py$/iu, /\b\w+\s*=\s*Blueprint\s*\(/u);
+            const hasFlaskEntrypointConstruction = context.hasAnyFileMatchingPattern(/(^|\/)(app|main|wsgi)\.py$/iu, /\b\w+\s*=\s*Flask\s*\(/u);
+            if (hasRequirementsFlask) {
+                strongSignals += 1;
+                score += 52;
+                evidence.push('Found requirements.txt with flask dependency');
+            }
+            if (hasPyprojectFlask) {
+                strongSignals += 1;
+                score += 52;
+                evidence.push('Found pyproject.toml with flask dependency');
+            }
+            if (hasPoetryLockFlask || hasPipfileFlask || hasPipfileLockFlask) {
+                strongSignals += 1;
+                score += 50;
+                evidence.push('Found Pipfile/lock metadata with flask dependency');
+            }
+            if (hasFlaskImport) {
+                strongSignals += 1;
+                score += 34;
+                evidence.push('Found Flask import in source');
+            }
+            if (hasFlaskConstruction) {
+                strongSignals += 1;
+                score += 34;
+                evidence.push('Found Flask application construction in source');
+            }
+            if (hasRouteDecorator) {
+                strongSignals += 1;
+                score += 22;
+                evidence.push('Found Flask route decorator in source');
+            }
+            if (hasMethodRouteDecorator) {
+                mediumSignals += 1;
+                score += 10;
+                evidence.push('Found Flask method route decorator in source');
+            }
+            if (hasBlueprintImport) {
+                mediumSignals += 1;
+                score += 10;
+                evidence.push('Found Blueprint import in source');
+            }
+            if (hasBlueprintConstruction) {
+                mediumSignals += 1;
+                score += 8;
+                evidence.push('Found Blueprint construction in source');
+            }
+            if (hasFlaskEntrypointConstruction) {
+                mediumSignals += 1;
+                score += 8;
+                evidence.push('Found Flask construction in app.py/main.py/wsgi.py');
+            }
+            if (context.hasDirectory('blueprints')) {
+                weakSignals += 1;
+                score += 2;
+                evidence.push('Found blueprints directory');
+            }
+            if (context.hasDirectory('app') || context.hasDirectory('src')) {
+                weakSignals += 1;
+                score += 2;
+                evidence.push('Found typical Python backend layout directory');
+            }
+            const hasSafeFlaskCoreEvidence = hasFlaskDependencyEvidence ||
+                (hasFlaskImport && hasFlaskConstruction) ||
+                (hasFlaskImport && (hasRouteDecorator || hasMethodRouteDecorator || hasBlueprintImport)) ||
+                (hasBlueprintImport && hasBlueprintConstruction);
+            if (!hasSafeFlaskCoreEvidence || strongSignals === 0) {
+                return null;
+            }
+            const hasRestEvidence = hasRouteDecorator || hasMethodRouteDecorator || hasBlueprintImport;
+            const confidence = strongSignals >= 2
+                ? 'high'
+                : strongSignals >= 1 || mediumSignals >= 3 || (mediumSignals >= 2 && weakSignals >= 1)
+                    ? 'medium'
+                    : 'low';
+            return toResult({
+                adapterId: 'flask',
+                confidence,
+                score,
+                evidence,
+                projectKindHints: ['backend'],
+                apiStyleHint: hasRestEvidence ? 'rest' : 'unknown',
+            });
+        },
+        resolveProjectKinds: () => ['backend'],
+        getImportExtractionMode: () => 'python-imports',
+    }),
+    python: buildAdapter({
+        id: 'python',
+        displayName: stackMetadata_1.canonicalStackLabels.python,
+        ecosystem: 'python',
+        category: 'generic-language',
+        priority: 40,
+        manifestDetectionHints: ['requirements.txt', 'pyproject.toml', 'setup.py', 'Pipfile'],
+        buildToolHints: ['pip', 'poetry'],
+        defaults: {
+            sourceRoots: ['src/features', 'src/modules', 'src', '.'],
+            moduleRootCandidates: ['src/features', 'src/modules', 'src', '.'],
+            apiRoots: ['src', '.'],
+            databaseRoots: ['migrations', 'alembic', 'db'],
+            configFiles: ['requirements.txt', 'pyproject.toml', 'setup.py', 'Pipfile'],
+            fileExtensions: ['.py'],
+            dependencyFileExtensions: ['.py'],
+            ignoreDirectories: [
+                '__pycache__',
+                '.venv',
+                'venv',
+                '.idea',
+                ...commonIgnoreDirectories,
+            ],
+            entrypointHints: ['app.py', 'main.py', '__init__.py'],
+            publicEntrypointDirectories: [],
+            moduleIndexFileName: '__init__.py',
+        },
+        detect: (context) => {
+            const hasPythonSource = context.hasFileExtension('.py');
+            const hasEntrypointEvidence = hasPythonEntrypointEvidence(context);
+            const hasPackageEvidence = hasPythonPackageEvidence(context);
+            const hasRuntimeDependencyEvidence = hasPythonRuntimeDependencyEvidence(context);
+            const hasRuntimeOrSourceEvidence = hasPythonSource ||
+                hasEntrypointEvidence ||
+                hasPackageEvidence ||
+                hasRuntimeDependencyEvidence;
+            if (context.hasFile('pyproject.toml')) {
+                const evidence = ['Found pyproject.toml'];
+                if (hasPythonSource) {
+                    evidence.push('Found Python source files');
+                }
+                if (hasEntrypointEvidence) {
+                    evidence.push('Found Python application entrypoint');
+                }
+                if (hasPackageEvidence) {
+                    evidence.push('Found Python package source');
+                }
+                if (hasRuntimeDependencyEvidence) {
+                    evidence.push('Found Python runtime dependency evidence');
+                }
+                if (!hasRuntimeOrSourceEvidence) {
+                    evidence.push('Treating pyproject.toml as tooling metadata because no Python runtime/source evidence was found');
+                }
+                return toResult({
+                    adapterId: 'python',
+                    confidence: hasRuntimeOrSourceEvidence ? 'high' : 'low',
+                    score: hasRuntimeOrSourceEvidence ? 90 : 42,
+                    evidence,
+                    projectKindHints: ['backend', 'library'],
+                });
+            }
+            if (context.hasFile('requirements.txt') || context.hasFile('setup.py')) {
+                const evidence = [
+                    context.hasFile('requirements.txt') ? 'Found requirements.txt' : 'Found setup.py',
+                ];
+                if (hasPythonSource) {
+                    evidence.push('Found Python source files');
+                }
+                if (hasEntrypointEvidence) {
+                    evidence.push('Found Python application entrypoint');
+                }
+                if (hasPackageEvidence) {
+                    evidence.push('Found Python package source');
+                }
+                if (hasRuntimeDependencyEvidence) {
+                    evidence.push('Found Python runtime dependency evidence');
+                }
+                return toResult({
+                    adapterId: 'python',
+                    confidence: hasRuntimeOrSourceEvidence ? 'high' : 'medium',
+                    score: hasRuntimeOrSourceEvidence ? 86 : 58,
+                    evidence,
+                    projectKindHints: ['backend', 'library'],
+                });
+            }
+            if (hasPythonSource) {
+                return toResult({
+                    adapterId: 'python',
+                    confidence: 'medium',
+                    score: 62,
+                    evidence: ['Found .py source files'],
+                    projectKindHints: ['backend', 'library'],
+                });
+            }
+            return null;
+        },
+        resolveProjectKinds: () => ['backend', 'library'],
+        getImportExtractionMode: () => 'python-imports',
+    }),
+    laravel: buildAdapter({
+        id: 'laravel',
+        displayName: stackMetadata_1.canonicalStackLabels.laravel,
+        ecosystem: 'php',
+        category: 'framework',
+        priority: 70,
+        manifestDetectionHints: ['composer.json', 'artisan', 'web.php', 'api.php', 'app.php'],
+        buildToolHints: ['composer', 'artisan'],
+        defaults: {
+            sourceRoots: ['app', 'routes', 'config'],
+            moduleRootCandidates: ['app/Modules', 'app/Services', 'app/Http/Controllers', 'app'],
+            apiRoots: ['routes', 'app/Http/Controllers'],
+            databaseRoots: ['database', 'database/migrations'],
+            configFiles: ['composer.json', 'artisan', 'config/app.php'],
+            fileExtensions: ['.php'],
+            dependencyFileExtensions: ['.php'],
+            ignoreDirectories: [
+                'vendor',
+                'storage',
+                'bootstrap/cache',
+                'public',
+                ...commonIgnoreDirectories,
+            ],
+            entrypointHints: ['artisan', 'public/index.php', 'bootstrap/app.php'],
+            publicEntrypointDirectories: [],
+            moduleIndexFileName: 'index.php',
+        },
+        detect: (context) => {
+            const evidence = [];
+            let strongSignals = 0;
+            let mediumSignals = 0;
+            let score = 0;
+            const hasLaravelComposer = context.hasFileMatchingPattern('composer.json', /["']laravel\/framework["']/iu);
+            const hasArtisan = context.hasFile('artisan');
+            const hasRoutesWeb = context.hasAnyPathMatchingPattern(/(^|\/)routes\/web\.php$/iu);
+            const hasRoutesApi = context.hasAnyPathMatchingPattern(/(^|\/)routes\/api\.php$/iu);
+            const hasControllers = context.hasDirectory('app/Http/Controllers');
+            const hasConfigApp = context.hasAnyPathMatchingPattern(/(^|\/)config\/app\.php$/iu);
+            const hasConfigDatabase = context.hasAnyPathMatchingPattern(/(^|\/)config\/database\.php$/iu);
+            const hasBootstrapApp = context.hasAnyPathMatchingPattern(/(^|\/)bootstrap\/app\.php$/iu);
+            const hasAppHttp = context.hasDirectory('app/Http');
+            const hasServiceProvider = context.hasAnyPathMatchingPattern(/(^|\/)app\/Providers\/.+ServiceProvider\.php$/iu);
+            const hasLaravelRouteFacade = context.hasAnyFileMatchingPattern(/(^|\/)routes\/.+\.php$/iu, /\bRoute::(get|post|put|patch|delete|middleware|group)\s*\(/u);
+            const hasMeaningfulApiRoute = context.hasAnyFileMatchingPattern(/(^|\/)routes\/api\.php$/iu, /\bRoute::(?:get|post|put|patch|delete|apiResource|resource)\s*\(\s*['"][^'"]*[A-Za-z0-9_{]/u);
+            const hasApiMiddlewareOrPrefix = context.hasAnyFileMatchingPattern(/(^|\/)routes\/api\.php$/iu, /\bRoute::(?:middleware\s*\(\s*['"]api['"]|prefix\s*\(\s*['"]api(?:\/|['"]))/u);
+            if (hasLaravelComposer) {
+                strongSignals += 1;
+                score += 50;
+                evidence.push('Found composer.json with laravel/framework dependency');
+            }
+            if (hasArtisan) {
+                strongSignals += 1;
+                score += 18;
+                evidence.push('Found artisan entrypoint');
+            }
+            if (hasRoutesWeb) {
+                mediumSignals += 1;
+                score += 10;
+                evidence.push('Found routes/web.php');
+            }
+            if (hasRoutesApi) {
+                mediumSignals += 1;
+                score += 10;
+                evidence.push('Found routes/api.php');
+            }
+            if (hasControllers) {
+                mediumSignals += 1;
+                score += 10;
+                evidence.push('Found app/Http/Controllers directory');
+            }
+            if (hasAppHttp) {
+                mediumSignals += 1;
+                score += 8;
+                evidence.push('Found app/Http directory');
+            }
+            if (hasConfigApp) {
+                mediumSignals += 1;
+                score += 6;
+                evidence.push('Found config/app.php');
+            }
+            if (hasConfigDatabase) {
+                mediumSignals += 1;
+                score += 5;
+                evidence.push('Found config/database.php');
+            }
+            if (hasBootstrapApp) {
+                mediumSignals += 1;
+                score += 7;
+                evidence.push('Found bootstrap/app.php');
+            }
+            if (hasServiceProvider) {
+                mediumSignals += 1;
+                score += 6;
+                evidence.push('Found Laravel service provider');
+            }
+            if (hasLaravelRouteFacade) {
+                mediumSignals += 1;
+                score += 8;
+                evidence.push('Found Laravel Route facade usage');
+            }
+            if (!hasLaravelComposer ||
+                !(hasArtisan || hasRoutesWeb || hasRoutesApi || hasControllers || hasAppHttp || hasConfigApp || hasConfigDatabase || hasBootstrapApp)) {
+                return null;
+            }
+            return toResult({
+                adapterId: 'laravel',
+                confidence: strongSignals >= 2 || mediumSignals >= 2 ? 'high' : 'medium',
+                score,
+                evidence,
+                projectKindHints: ['backend'],
+                apiStyleHint: hasMeaningfulApiRoute || hasApiMiddlewareOrPrefix ? 'rest' : 'unknown',
+            });
+        },
+        resolveProjectKinds: () => ['backend'],
+        getImportExtractionMode: () => 'php-imports',
+    }),
+    php: buildAdapter({
+        id: 'php',
+        displayName: stackMetadata_1.canonicalStackLabels.php,
+        ecosystem: 'php',
+        category: 'generic-language',
+        priority: 40,
+        manifestDetectionHints: ['composer.json'],
+        buildToolHints: ['composer'],
+        defaults: {
+            sourceRoots: ['app', 'src', '.'],
+            moduleRootCandidates: ['app', 'src', '.'],
+            apiRoots: ['app', 'public'],
+            databaseRoots: ['database', 'migrations'],
+            configFiles: ['composer.json'],
+            fileExtensions: ['.php'],
+            dependencyFileExtensions: ['.php'],
+            ignoreDirectories: [
+                'vendor',
+                'storage',
+                'bootstrap/cache',
+                'public',
+                ...commonIgnoreDirectories,
+            ],
+            entrypointHints: ['index.php', 'app.php', 'Application.php'],
+            publicEntrypointDirectories: [],
+            moduleIndexFileName: 'index.php',
+        },
+        detect: (context) => {
+            if (!context.hasFile('composer.json')) {
+                if (!context.hasFileExtension('.php')) {
+                    return null;
+                }
+                return toResult({
+                    adapterId: 'php',
+                    confidence: 'medium',
+                    score: 60,
+                    evidence: ['Found .php source files'],
+                    projectKindHints: ['backend', 'library'],
+                });
+            }
+            return toResult({
+                adapterId: 'php',
+                confidence: 'high',
+                score: 86,
+                evidence: ['Found composer.json'],
+                projectKindHints: ['backend', 'library'],
+            });
+        },
+        resolveProjectKinds: () => ['backend', 'library'],
+        getImportExtractionMode: () => 'php-imports',
+    }),
+    go: buildAdapter({
+        id: 'go',
+        displayName: stackMetadata_1.canonicalStackLabels.go,
+        ecosystem: 'go',
+        category: 'generic-language',
+        priority: 40,
+        manifestDetectionHints: ['go.mod', 'go.sum'],
+        buildToolHints: ['go'],
+        defaults: {
+            sourceRoots: ['cmd', 'internal', 'pkg', '.'],
+            moduleRootCandidates: ['internal', 'cmd', 'pkg', '.'],
+            apiRoots: ['cmd', 'internal'],
+            databaseRoots: ['internal/db', 'migrations'],
+            configFiles: ['go.mod', 'go.sum'],
+            fileExtensions: ['.go'],
+            dependencyFileExtensions: ['.go'],
+            ignoreDirectories: ['vendor', 'bin', ...commonIgnoreDirectories],
+            entrypointHints: ['main.go', 'app.go'],
+            publicEntrypointDirectories: [],
+            moduleIndexFileName: 'main.go',
+        },
+        detect: (context) => {
+            const hasGoSource = context.hasFileExtension('.go');
+            const hasEntrypointEvidence = hasGoEntrypointEvidence(context);
+            const hasServerDependencyEvidence = hasGoServerDependencyEvidence(context);
+            if (!context.hasFile('go.mod')) {
+                if (!hasGoSource) {
+                    return null;
+                }
+                return toResult({
+                    adapterId: 'go',
+                    confidence: 'medium',
+                    score: 60,
+                    evidence: ['Found .go source files'],
+                    projectKindHints: ['backend', 'library'],
+                });
+            }
+            const evidence = ['Found go.mod'];
+            let score = 86;
+            if (hasGoSource) {
+                score += 4;
+                evidence.push('Found Go source files');
+            }
+            if (hasEntrypointEvidence) {
+                score += 5;
+                evidence.push('Found Go application entrypoint');
+            }
+            if (context.hasDirectory('cmd')) {
+                score += 2;
+                evidence.push('Found Go cmd/ entrypoint directory');
+            }
+            if (hasServerDependencyEvidence) {
+                score += 2;
+                evidence.push('Found Go server/router dependency evidence');
+            }
+            return toResult({
+                adapterId: 'go',
+                confidence: 'high',
+                score: Math.min(score, 99),
+                evidence,
+                projectKindHints: ['backend', 'library'],
+            });
+        },
+        resolveProjectKinds: () => ['backend', 'library'],
+        getImportExtractionMode: () => 'go-imports',
+    }),
+    dotnet: buildAdapter({
+        id: 'dotnet',
+        displayName: stackMetadata_1.canonicalStackLabels.dotnet,
+        ecosystem: 'dotnet',
+        category: 'framework',
+        priority: 70,
+        manifestDetectionHints: [
+            'Program.cs',
+            'appsettings.json',
+            'appsettings.Development.json',
+            'launchSettings.json',
+        ],
+        buildToolHints: ['dotnet'],
+        defaults: {
+            sourceRoots: ['.'],
+            moduleRootCandidates: ['Controllers', 'Features', 'Modules', 'src'],
+            apiRoots: ['Controllers', 'Endpoints', 'src', '.'],
+            databaseRoots: ['Migrations', 'Data', 'Persistence', 'Infrastructure', 'src'],
+            configFiles: [
+                '*.sln',
+                '*.csproj',
+                'Program.cs',
+                'appsettings.json',
+                'appsettings.Development.json',
+                'Properties/launchSettings.json',
+            ],
+            fileExtensions: ['.cs', '.json', '.sql', '.http'],
+            dependencyFileExtensions: ['.cs'],
+            ignoreDirectories: ['bin', 'obj', '.vs', ...commonIgnoreDirectories],
+            entrypointHints: ['Program.cs'],
+            publicEntrypointDirectories: [],
+            moduleIndexFileName: 'Program.cs',
+        },
+        detect: (context) => {
+            const evidence = [];
+            let strongSignals = 0;
+            let mediumSignals = 0;
+            let weakSignals = 0;
+            let score = 0;
+            const hasCsproj = context.hasAnyPathMatchingPattern(/(^|\/)[^/]+\.csproj$/iu);
+            const hasSln = context.hasAnyPathMatchingPattern(/(^|\/)[^/]+\.sln$/iu);
+            const hasProgramCs = context.hasFile('Program.cs');
+            const hasWebSdkCsproj = context.hasAnyFileMatchingPattern(/(^|\/)[^/]+\.csproj$/iu, /\bMicrosoft\.NET\.Sdk\.Web\b/u);
+            const hasAspNetPackageReference = context.hasAnyFileMatchingPattern(/(^|\/)[^/]+\.csproj$/iu, /\b(Microsoft\.AspNetCore\.[A-Za-z0-9.]+|Swashbuckle\.AspNetCore|Microsoft\.AspNetCore\.OpenApi)\b/u) ||
+                context.hasAnyFileMatchingPattern(/\.cs$/iu, /\busing\s+Microsoft\.AspNetCore\.[A-Za-z0-9.]+;/u);
+            const hasBuilderServices = context.hasAnyFileMatchingPattern(/\.cs$/iu, /\bbuilder\.Services\b/u);
+            const hasCreateBuilder = context.hasAnyFileMatchingPattern(/\.cs$/iu, /\bWebApplication\.CreateBuilder\s*\(/u);
+            const hasMinimalApiMapping = context.hasAnyFileMatchingPattern(/\.cs$/iu, /\bapp\.(MapGet|MapPost)\s*\(/u);
+            const hasMapControllers = context.hasAnyFileMatchingPattern(/\.cs$/iu, /\bapp\.MapControllers\s*\(/u);
+            const hasApiController = context.hasAnyFileMatchingPattern(/\.cs$/iu, /\[ApiController\]/u);
+            const hasRouteAttribute = context.hasAnyFileMatchingPattern(/\.cs$/iu, /\[Route\s*\(/u);
+            const hasAppSettingsWithDotnetEvidence = context.hasFile('appsettings.json') && (hasCsproj || hasProgramCs || hasWebSdkCsproj || hasAspNetPackageReference);
+            const hasControllersDirectory = context.hasDirectory('Controllers');
+            const hasLaunchSettings = context.hasAnyPathMatchingPattern(/(^|\/)Properties\/launchSettings\.json$/iu);
+            const hasAppSettingsDevelopment = context.hasFile('appsettings.Development.json');
+            const hasWwwroot = context.hasDirectory('wwwroot');
+            const hasTypicalDotnetLayout = context.hasDirectory('Properties') ||
+                context.hasDirectory('Features') ||
+                context.hasDirectory('Modules') ||
+                context.hasDirectory('Endpoints') ||
+                context.hasDirectory('Migrations');
+            if (hasCsproj) {
+                strongSignals += 1;
+                score += 54;
+                evidence.push('Found one or more .csproj files');
+            }
+            if (hasSln && hasCsproj) {
+                strongSignals += 1;
+                score += 26;
+                evidence.push('Found .sln with .csproj project files');
+            }
+            if (hasProgramCs) {
+                strongSignals += 1;
+                score += 28;
+                evidence.push('Found Program.cs');
+            }
+            if (hasWebSdkCsproj) {
+                strongSignals += 1;
+                score += 42;
+                evidence.push('Found csproj using Microsoft.NET.Sdk.Web');
+            }
+            if (hasAspNetPackageReference) {
+                strongSignals += 1;
+                score += 34;
+                evidence.push('Found ASP.NET/OpenAPI package evidence');
+            }
+            if (hasBuilderServices) {
+                strongSignals += 1;
+                score += 16;
+                evidence.push('Found builder.Services usage');
+            }
+            if (hasCreateBuilder) {
+                strongSignals += 1;
+                score += 18;
+                evidence.push('Found WebApplication.CreateBuilder usage');
+            }
+            if (hasMinimalApiMapping) {
+                strongSignals += 1;
+                score += 20;
+                evidence.push('Found minimal API route mapping in source');
+            }
+            if (hasMapControllers) {
+                strongSignals += 1;
+                score += 18;
+                evidence.push('Found app.MapControllers usage');
+            }
+            if (hasApiController) {
+                strongSignals += 1;
+                score += 16;
+                evidence.push('Found [ApiController] attribute');
+            }
+            if (hasRouteAttribute) {
+                strongSignals += 1;
+                score += 12;
+                evidence.push('Found [Route(...)] attribute');
+            }
+            if (hasAppSettingsWithDotnetEvidence) {
+                strongSignals += 1;
+                score += 12;
+                evidence.push('Found appsettings.json with .NET backend evidence');
+            }
+            if (hasControllersDirectory) {
+                mediumSignals += 1;
+                score += 8;
+                evidence.push('Found Controllers directory');
+            }
+            if (hasLaunchSettings) {
+                mediumSignals += 1;
+                score += 8;
+                evidence.push('Found Properties/launchSettings.json');
+            }
+            if (hasAppSettingsDevelopment) {
+                mediumSignals += 1;
+                score += 5;
+                evidence.push('Found appsettings.Development.json');
+            }
+            if (hasWwwroot) {
+                mediumSignals += 1;
+                score += 2;
+                evidence.push('Found wwwroot directory as supporting evidence');
+            }
+            if (hasTypicalDotnetLayout) {
+                weakSignals += 1;
+                score += 2;
+                evidence.push('Found typical .NET backend layout directory');
+            }
+            const hasApiEvidence = hasMinimalApiMapping ||
+                hasMapControllers ||
+                hasApiController ||
+                hasRouteAttribute ||
+                hasControllersDirectory;
+            const hasSafeDotnetCoreEvidence = hasCsproj && (hasProgramCs ||
+                hasWebSdkCsproj ||
+                hasAspNetPackageReference ||
+                hasCreateBuilder ||
+                hasBuilderServices ||
+                hasApiEvidence);
+            if (!hasSafeDotnetCoreEvidence) {
+                return null;
+            }
+            const confidence = strongSignals >= 3
+                ? 'high'
+                : strongSignals >= 2 || mediumSignals >= 3 || (mediumSignals >= 2 && weakSignals >= 1)
+                    ? 'medium'
+                    : 'low';
+            return toResult({
+                adapterId: 'dotnet',
+                confidence,
+                score,
+                evidence,
+                projectKindHints: ['backend'],
+                apiStyleHint: hasApiEvidence ? 'rest' : 'unknown',
+            });
+        },
+        resolveProjectKinds: () => ['backend'],
+        getImportExtractionMode: () => 'csharp-imports',
+    }),
+    ruby_rails: buildAdapter({
+        id: 'ruby_rails',
+        displayName: stackMetadata_1.canonicalStackLabels.ruby_rails,
+        ecosystem: 'other',
+        category: 'framework',
+        priority: 70,
+        manifestDetectionHints: ['Gemfile', 'rails', 'routes.rb', 'application.rb'],
+        buildToolHints: ['bundle'],
+        defaults: {
+            sourceRoots: ['app', 'config'],
+            moduleRootCandidates: ['app/services', 'app/controllers', 'app/models', 'app'],
+            apiRoots: ['app/controllers', 'config/routes.rb'],
+            databaseRoots: ['db'],
+            configFiles: ['Gemfile', 'config/routes.rb', 'config/application.rb'],
+            fileExtensions: ['.rb'],
+            dependencyFileExtensions: ['.rb'],
+            ignoreDirectories: ['vendor', 'tmp', 'log', ...commonIgnoreDirectories],
+            entrypointHints: ['config/application.rb'],
+            publicEntrypointDirectories: [],
+            moduleIndexFileName: 'application.rb',
+        },
+        detect: (context) => {
+            const evidence = [];
+            let strongSignals = 0;
+            let mediumSignals = 0;
+            let score = 0;
+            const hasRailsGem = context.hasFileMatchingPattern('Gemfile', /\bgem\s+['"]rails['"]/u);
+            const hasBinRails = context.hasAnyPathMatchingPattern(/(^|\/)bin\/rails$/u);
+            const hasRoutes = context.hasAnyPathMatchingPattern(/(^|\/)config\/routes\.rb$/u);
+            const hasControllers = context.hasDirectory('app/controllers');
+            const hasModels = context.hasDirectory('app/models');
+            const hasServices = context.hasDirectory('app/services');
+            const hasRailsRoutesDraw = context.hasFileMatchingPattern('routes.rb', /\bRails\.application\.routes\.draw\b/u);
+            const hasApplicationClass = context.hasAnyFileMatchingPattern(/(^|\/)config\/application\.rb$/u, /\bclass\s+Application\s+<\s+Rails::Application\b/u);
+            const hasApplicationController = context.hasAnyFileMatchingPattern(/(^|\/)app\/controllers\/.+\.rb$/u, /\bApplicationController\b/u);
+            if (hasRailsGem) {
+                strongSignals += 1;
+                score += 48;
+                evidence.push('Found Gemfile with rails gem');
+            }
+            if (hasBinRails) {
+                strongSignals += 1;
+                score += 18;
+                evidence.push('Found bin/rails');
+            }
+            if (hasRoutes) {
+                mediumSignals += 1;
+                score += 10;
+                evidence.push('Found config/routes.rb');
+            }
+            if (hasControllers) {
+                mediumSignals += 1;
+                score += 8;
+                evidence.push('Found app/controllers directory');
+            }
+            if (hasModels) {
+                mediumSignals += 1;
+                score += 6;
+                evidence.push('Found app/models directory');
+            }
+            if (hasServices) {
+                mediumSignals += 1;
+                score += 5;
+                evidence.push('Found app/services directory');
+            }
+            if (hasRailsRoutesDraw) {
+                mediumSignals += 1;
+                score += 8;
+                evidence.push('Found Rails routes draw block');
+            }
+            if (hasApplicationClass) {
+                mediumSignals += 1;
+                score += 8;
+                evidence.push('Found Rails application class');
+            }
+            if (hasApplicationController) {
+                mediumSignals += 1;
+                score += 5;
+                evidence.push('Found ApplicationController inheritance');
+            }
+            if (!hasRailsGem || !(hasBinRails || hasRoutes || hasControllers || hasApplicationClass)) {
+                return null;
+            }
+            return toResult({
+                adapterId: 'ruby_rails',
+                confidence: strongSignals >= 2 || mediumSignals >= 3 ? 'high' : 'medium',
+                score,
+                evidence,
+                projectKindHints: ['backend'],
+                apiStyleHint: hasRoutes || hasControllers ? 'rest' : 'unknown',
+            });
+        },
+        resolveProjectKinds: () => ['backend'],
+        getImportExtractionMode: () => 'generic',
+    }),
+    kotlin: buildAdapter({
+        id: 'kotlin',
+        displayName: stackMetadata_1.canonicalStackLabels.kotlin,
+        ecosystem: 'jvm',
+        category: 'generic-language',
+        priority: 40,
+        manifestDetectionHints: ['build.gradle.kts', 'pom.xml', 'settings.gradle.kts'],
+        buildToolHints: ['gradle', 'maven'],
+        defaults: {
+            sourceRoots: ['src/main/kotlin', 'src'],
+            moduleRootCandidates: ['src/main/kotlin', 'src'],
+            apiRoots: ['src/main/kotlin'],
+            databaseRoots: ['src/main/resources/db', 'src/main/resources/migrations'],
+            configFiles: ['build.gradle.kts', 'pom.xml', 'settings.gradle.kts'],
+            fileExtensions: ['.kt', '.kts'],
+            dependencyFileExtensions: ['.kt', '.kts'],
+            ignoreDirectories: [
+                'target',
+                'build',
+                '.gradle',
+                '.idea',
+                'out',
+                ...commonIgnoreDirectories,
+            ],
+            entrypointHints: ['Application.kt', 'Main.kt'],
+            publicEntrypointDirectories: [],
+            moduleIndexFileName: 'Application.kt',
+        },
+        detect: (context) => {
+            const evidence = [];
+            let score = 0;
+            const hasBuildGradleKts = context.hasFile('build.gradle.kts');
+            const hasSettingsGradleKts = context.hasFile('settings.gradle.kts');
+            const hasKotlinPluginInGradle = context.hasFileMatchingPattern('build.gradle.kts', /\bkotlin\s*\(\s*["']jvm["']\s*\)/u) ||
+                context.hasFileMatchingPattern('build.gradle.kts', /\bid\s*\(\s*["']org\.jetbrains\.kotlin\.jvm["']\s*\)/u);
+            const hasPomKotlinPlugin = context.hasFileMatchingPattern('pom.xml', /\bkotlin-maven-plugin\b/u) ||
+                context.hasFileMatchingPattern('pom.xml', /\borg\.jetbrains\.kotlin\b/u);
+            const hasKotlinSourceRoot = context.hasDirectory('src/main/kotlin');
+            const hasKtFiles = context.hasFileExtension('.kt') || context.hasFileExtension('.kts');
+            const hasKotlinPackageShape = context.hasDirectory('src/main/kotlin/com') || context.hasDirectory('src/main/kotlin/org');
+            if (hasBuildGradleKts) {
+                score += 30;
+                evidence.push('Found build.gradle.kts');
+            }
+            if (hasSettingsGradleKts) {
+                score += 8;
+                evidence.push('Found settings.gradle.kts');
+            }
+            if (hasKotlinPluginInGradle) {
+                score += 32;
+                evidence.push('Found Kotlin JVM plugin in build.gradle.kts');
+            }
+            if (hasPomKotlinPlugin) {
+                score += 32;
+                evidence.push('Found Kotlin Maven plugin markers in pom.xml');
+            }
+            if (hasKotlinSourceRoot) {
+                score += 18;
+                evidence.push('Found src/main/kotlin source root');
+            }
+            if (hasKtFiles) {
+                score += 16;
+                evidence.push('Found Kotlin source files');
+            }
+            if (hasKotlinPackageShape) {
+                score += 4;
+                evidence.push('Found conventional Kotlin package directory under src/main/kotlin');
+            }
+            const hasSafeKotlinEvidence = hasKtFiles &&
+                (hasBuildGradleKts || hasKotlinPluginInGradle || hasPomKotlinPlugin || hasKotlinSourceRoot);
+            if (!hasSafeKotlinEvidence) {
+                return null;
+            }
+            return toResult({
+                adapterId: 'kotlin',
+                confidence: (hasKotlinPluginInGradle || hasPomKotlinPlugin) && hasKotlinSourceRoot
+                    ? 'high'
+                    : hasBuildGradleKts || hasKotlinSourceRoot
+                        ? 'medium'
+                        : 'low',
+                score,
+                evidence,
+                projectKindHints: ['backend', 'library'],
+                apiStyleHint: 'unknown',
+            });
+        },
+        resolveProjectKinds: () => ['backend', 'library'],
+        getImportExtractionMode: () => 'generic',
+    }),
+    kotlin_spring: buildAdapter({
+        id: 'kotlin_spring',
+        displayName: stackMetadata_1.canonicalStackLabels.kotlin_spring,
+        ecosystem: 'jvm',
+        category: 'framework',
+        priority: 20,
+        manifestDetectionHints: ['build.gradle.kts'],
+        buildToolHints: ['gradle'],
+        defaults: {
+            sourceRoots: ['src/main/kotlin'],
+            moduleRootCandidates: ['src/main/kotlin'],
+            apiRoots: ['src/main/kotlin'],
+            databaseRoots: ['src/main/resources/db'],
+            configFiles: ['build.gradle.kts'],
+            fileExtensions: ['.kt'],
+            dependencyFileExtensions: ['.kt'],
+            ignoreDirectories: [...commonIgnoreDirectories],
+            entrypointHints: ['Application.kt'],
+            publicEntrypointDirectories: [],
+            moduleIndexFileName: 'Application.kt',
+        },
+        detect: () => null,
+        getImportExtractionMode: () => 'generic',
+    }),
+    rust: buildAdapter({
+        id: 'rust',
+        displayName: stackMetadata_1.canonicalStackLabels.rust,
+        ecosystem: 'other',
+        category: 'generic-language',
+        priority: 20,
+        manifestDetectionHints: ['Cargo.toml'],
+        buildToolHints: ['cargo'],
+        defaults: {
+            sourceRoots: ['src'],
+            moduleRootCandidates: ['src'],
+            apiRoots: ['src'],
+            databaseRoots: ['migrations'],
+            configFiles: ['Cargo.toml'],
+            fileExtensions: ['.rs'],
+            dependencyFileExtensions: ['.rs'],
+            ignoreDirectories: [...commonIgnoreDirectories],
+            entrypointHints: ['main.rs', 'lib.rs'],
+            publicEntrypointDirectories: [],
+            moduleIndexFileName: 'main.rs',
+        },
+        detect: () => null,
+        getImportExtractionMode: () => 'generic',
+    }),
+    react: buildAdapter({
+        id: 'react',
+        displayName: stackMetadata_1.canonicalStackLabels.react,
+        ecosystem: 'node',
+        category: 'framework',
+        priority: 80,
+        manifestDetectionHints: [
+            'package.json',
+            'vite.config.ts',
+            'vite.config.js',
+            'webpack.config.js',
+            'tsconfig.json',
+        ],
+        buildToolHints: ['npm', 'yarn', 'pnpm', 'vite', 'webpack'],
+        defaults: {
+            sourceRoots: ['src', '.'],
+            moduleRootCandidates: ['src', '.'],
+            apiRoots: ['src/api', 'api'],
+            databaseRoots: ['prisma', 'db'],
+            configFiles: ['package.json', 'vite.config.ts', 'vite.config.js', 'webpack.config.js'],
+            fileExtensions: ['.ts', '.tsx', '.js', '.jsx'],
+            dependencyFileExtensions: ['.ts', '.tsx', '.js', '.jsx'],
+            ignoreDirectories: ['.next', ...commonIgnoreDirectories],
+            entrypointHints: ['main.tsx', 'main.jsx', 'index.tsx', 'index.jsx', 'App.tsx', 'App.jsx'],
+            publicEntrypointDirectories: [],
+            moduleIndexFileName: 'index.tsx',
+        },
+        detect: (context) => {
+            if (!context.hasPackageDependency('react')) {
+                return null;
+            }
+            const hasViteConfig = context.hasFile('vite.config.ts') || context.hasFile('vite.config.js');
+            const hasWebpackConfig = context.hasFile('webpack.config.js');
+            const confidence = hasViteConfig || hasWebpackConfig ? 'high' : 'medium';
+            const score = hasViteConfig || hasWebpackConfig ? 92 : 72;
+            const evidence = ['Found package.json with react dependency'];
+            if (hasViteConfig) {
+                evidence.push('Found vite.config.js or vite.config.ts');
+            }
+            if (hasWebpackConfig) {
+                evidence.push('Found webpack.config.js');
+            }
+            return toResult({
+                adapterId: 'react',
+                confidence,
+                score,
+                evidence,
+                projectKindHints: ['frontend'],
+            });
+        },
+        resolveProjectKinds: () => ['frontend'],
+        getImportExtractionMode: () => 'js-imports',
+    }),
+    angular: buildAdapter({
+        id: 'angular',
+        displayName: stackMetadata_1.canonicalStackLabels.angular,
+        ecosystem: 'node',
+        category: 'framework',
+        priority: 75,
+        manifestDetectionHints: [
+            'angular.json',
+            'package.json',
+            'tsconfig.app.json',
+            'polyfills.ts',
+            'main.ts',
+        ],
+        buildToolHints: ['npm', 'yarn', 'pnpm'],
+        defaults: {
+            sourceRoots: ['src'],
+            moduleRootCandidates: ['src/app'],
+            apiRoots: [],
+            databaseRoots: [],
+            configFiles: ['angular.json', 'tsconfig.json', 'package.json'],
+            fileExtensions: ['.ts', '.html', '.scss', '.css'],
+            dependencyFileExtensions: ['.ts'],
+            ignoreDirectories: ['node_modules', 'dist', 'coverage'],
+            entrypointHints: ['src/main.ts'],
+            publicEntrypointDirectories: [],
+            moduleIndexFileName: 'main.ts',
+        },
+        detect: (context) => {
+            const evidence = [];
+            let strongSignals = 0;
+            let mediumSignals = 0;
+            let score = 0;
+            if (context.hasFile('angular.json')) {
+                strongSignals += 1;
+                score += 28;
+                evidence.push('Found angular.json');
+            }
+            if (context.hasPackageDependency('@angular/core')) {
+                strongSignals += 1;
+                score += 24;
+                evidence.push('Found package.json with @angular/core dependency');
+            }
+            if (context.hasPackageDependency('@angular/cli')) {
+                strongSignals += 1;
+                score += 22;
+                evidence.push('Found package.json with @angular/cli dependency');
+            }
+            if (context.hasDirectory('src/app')) {
+                strongSignals += 1;
+                score += 16;
+                evidence.push('Found src/app directory');
+            }
+            if (context.hasFileMatchingPattern('main.ts', /\b(bootstrapApplication|platformBrowserDynamic|bootstrapModule)\s*\(/u)) {
+                strongSignals += 1;
+                score += 20;
+                evidence.push('Found Angular bootstrap in main.ts');
+            }
+            if (context.hasFile('tsconfig.app.json')) {
+                mediumSignals += 1;
+                score += 8;
+                evidence.push('Found tsconfig.app.json');
+            }
+            if (context.hasDirectory('projects')) {
+                mediumSignals += 1;
+                score += 7;
+                evidence.push('Found projects/ workspace directory');
+            }
+            if (context.hasFile('polyfills.ts')) {
+                mediumSignals += 1;
+                score += 6;
+                evidence.push('Found polyfills.ts');
+            }
+            if (context.hasDirectory('src/environments')) {
+                mediumSignals += 1;
+                score += 6;
+                evidence.push('Found src/environments directory');
+            }
+            if (strongSignals === 0) {
+                return null;
+            }
+            const confidence = strongSignals >= 2 ? 'high' : strongSignals >= 1 || mediumSignals >= 3 ? 'medium' : 'low';
+            return toResult({
+                adapterId: 'angular',
+                confidence,
+                score,
+                evidence,
+                projectKindHints: ['frontend'],
+                apiStyleHint: 'none',
+            });
+        },
+        resolveProjectKinds: () => ['frontend'],
+        getImportExtractionMode: () => 'js-imports',
+    }),
+    vue: buildAdapter({
+        id: 'vue',
+        displayName: stackMetadata_1.canonicalStackLabels.vue,
+        ecosystem: 'node',
+        category: 'framework',
+        priority: 75,
+        manifestDetectionHints: [
+            'package.json',
+            'vite.config.ts',
+            'vite.config.js',
+            'App.vue',
+            'main.ts',
+            'main.js',
+            'tsconfig.app.json',
+        ],
+        buildToolHints: ['npm', 'yarn', 'pnpm', 'vite'],
+        defaults: {
+            sourceRoots: ['src'],
+            moduleRootCandidates: ['src/components', 'src/views'],
+            apiRoots: [],
+            databaseRoots: [],
+            configFiles: ['vite.config.ts', 'vite.config.js', 'package.json', 'tsconfig.json'],
+            fileExtensions: ['.ts', '.js', '.vue', '.css', '.scss'],
+            dependencyFileExtensions: ['.ts', '.js', '.vue'],
+            ignoreDirectories: ['node_modules', 'dist', 'coverage'],
+            entrypointHints: ['src/main.ts', 'src/main.js'],
+            publicEntrypointDirectories: [],
+            moduleIndexFileName: 'main.ts',
+        },
+        detect: (context) => {
+            const hasVueDependency = context.hasPackageDependency('vue');
+            const hasAppVue = context.hasFile('App.vue');
+            const hasSrcComponents = context.hasDirectory('src/components');
+            const hasVitePluginInConfig = context.hasFileMatchingPattern('vite.config.ts', /\b(plugin-vue|@vitejs\/plugin-vue)\b/iu) ||
+                context.hasFileMatchingPattern('vite.config.js', /\b(plugin-vue|@vitejs\/plugin-vue)\b/iu);
+            const hasVitePluginDependency = context.hasPackageDependency('@vitejs/plugin-vue');
+            const hasSrcViews = context.hasDirectory('src/views');
+            const hasSrcRouter = context.hasDirectory('src/router');
+            const hasSrcMainTs = context.getPaths('main.ts').some((value) => value === 'src/main.ts');
+            const hasSrcMainJs = context.getPaths('main.js').some((value) => value === 'src/main.js');
+            const hasCreateAppReference = (hasSrcMainTs && context.hasFileMatchingPattern('main.ts', /\bcreateApp\s*\(/u)) ||
+                (hasSrcMainJs && context.hasFileMatchingPattern('main.js', /\bcreateApp\s*\(/u));
+            const hasViteConfig = context.hasFile('vite.config.ts') || context.hasFile('vite.config.js');
+            const hasTsConfigApp = context.hasFile('tsconfig.app.json');
+            const hasSrcAssets = context.hasDirectory('src/assets');
+            const evidence = [];
+            let strongSignals = 0;
+            let mediumSignals = 0;
+            let weakSignals = 0;
+            let score = 0;
+            if (hasVueDependency) {
+                strongSignals += 1;
+                score += 30;
+                evidence.push('Found package.json with vue dependency');
+            }
+            if (hasAppVue) {
+                strongSignals += 1;
+                score += 22;
+                evidence.push('Found App.vue');
+            }
+            if (hasSrcComponents) {
+                strongSignals += 1;
+                score += 14;
+                evidence.push('Found src/components directory');
+            }
+            if (hasVitePluginInConfig) {
+                strongSignals += 1;
+                score += 24;
+                evidence.push('Found Vue plugin usage in vite.config.ts or vite.config.js');
+            }
+            if (hasVitePluginDependency) {
+                strongSignals += 1;
+                score += 22;
+                evidence.push('Found package.json with @vitejs/plugin-vue dependency');
+            }
+            if (hasSrcViews) {
+                mediumSignals += 1;
+                score += 8;
+                evidence.push('Found src/views directory');
+            }
+            if (hasSrcRouter) {
+                mediumSignals += 1;
+                score += 8;
+                evidence.push('Found src/router directory');
+            }
+            if (hasCreateAppReference) {
+                mediumSignals += 1;
+                score += 12;
+                evidence.push('Found createApp usage in src/main.ts or src/main.js');
+            }
+            if (hasViteConfig && hasVueDependency) {
+                mediumSignals += 1;
+                score += 8;
+                evidence.push('Found vite.config.ts or vite.config.js with Vue package evidence');
+            }
+            if (hasTsConfigApp) {
+                weakSignals += 1;
+                score += 4;
+                evidence.push('Found tsconfig.app.json');
+            }
+            if (hasSrcAssets) {
+                weakSignals += 1;
+                score += 3;
+                evidence.push('Found src/assets directory');
+            }
+            const hasSafeCoreEvidence = (hasVueDependency && (hasAppVue || hasCreateAppReference || hasVitePluginDependency || hasVitePluginInConfig)) ||
+                (hasAppVue && (hasCreateAppReference || hasSrcComponents || hasVueDependency)) ||
+                (hasVitePluginDependency && hasVitePluginInConfig && hasCreateAppReference);
+            if (!hasSafeCoreEvidence) {
+                return null;
+            }
+            const confidence = strongSignals >= 2
+                ? 'high'
+                : strongSignals >= 1 || mediumSignals >= 2 || (mediumSignals >= 1 && weakSignals >= 2)
+                    ? 'medium'
+                    : 'low';
+            return toResult({
+                adapterId: 'vue',
+                confidence,
+                score,
+                evidence,
+                projectKindHints: ['frontend'],
+                apiStyleHint: 'none',
+            });
+        },
+        resolveProjectKinds: () => ['frontend'],
+        getImportExtractionMode: () => 'js-imports',
+    }),
+    nextjs: buildAdapter({
+        id: 'nextjs',
+        displayName: stackMetadata_1.canonicalStackLabels.nextjs,
+        ecosystem: 'node',
+        category: 'framework',
+        priority: 100,
+        manifestDetectionHints: ['package.json', 'next.config.js', 'next.config.mjs', 'next.config.ts', 'tsconfig.json'],
+        buildToolHints: ['npm', 'yarn', 'pnpm', 'next'],
+        defaults: {
+            sourceRoots: ['src/features', 'src/modules', 'src', 'app', 'src/app', 'pages', '.'],
+            moduleRootCandidates: ['src/features', 'src/modules', 'app', 'src/app', 'src', 'pages', '.'],
+            apiRoots: ['app/api', 'pages/api', 'src/app/api'],
+            databaseRoots: ['prisma', 'db'],
+            configFiles: ['package.json', 'next.config.js', 'next.config.ts', 'next.config.mjs'],
+            fileExtensions: ['.ts', '.tsx', '.js', '.jsx'],
+            dependencyFileExtensions: ['.ts', '.tsx', '.js', '.jsx'],
+            ignoreDirectories: ['.next', ...commonIgnoreDirectories],
+            entrypointHints: [
+                'app/page.tsx',
+                'app/page.jsx',
+                'pages/index.tsx',
+                'pages/index.jsx',
+                'src/app/page.tsx',
+                'src/app/page.jsx',
+                'src/pages/index.tsx',
+                'src/pages/index.jsx',
+            ],
+            publicEntrypointDirectories: [],
+            moduleIndexFileName: 'index.tsx',
+        },
+        detect: (context) => {
+            const nextConfigFile = ['next.config.js', 'next.config.ts', 'next.config.mjs']
+                .find((fileName) => context.hasFile(fileName));
+            const hasNextDependency = context.hasPackageDependency('next');
+            if (!nextConfigFile && !hasNextDependency) {
+                return null;
+            }
+            if (nextConfigFile) {
+                return toResult({
+                    adapterId: 'nextjs',
+                    confidence: 'high',
+                    score: hasNextDependency ? 98 : 94,
+                    evidence: [
+                        `Found ${nextConfigFile}`,
+                        ...(hasNextDependency ? ['Found package.json with next dependency'] : []),
+                    ],
+                    projectKindHints: ['frontend'],
+                });
+            }
+            return toResult({
+                adapterId: 'nextjs',
+                confidence: 'medium',
+                score: 82,
+                evidence: ['Found package.json with next dependency'],
+                projectKindHints: ['frontend'],
+            });
+        },
+        resolveProjectKinds: () => ['frontend'],
+        getImportExtractionMode: () => 'js-imports',
+    }),
+    terraform: buildAdapter({
+        id: 'terraform',
+        displayName: stackMetadata_1.canonicalStackLabels.terraform,
+        ecosystem: 'other',
+        category: 'runtime',
+        priority: 35,
+        manifestDetectionHints: ['main.tf', 'variables.tf', 'outputs.tf', 'providers.tf'],
+        buildToolHints: ['terraform'],
+        defaults: {
+            sourceRoots: ['modules', 'live', 'environments', 'stacks', '.'],
+            moduleRootCandidates: ['modules', 'live', 'environments', 'stacks', '.'],
+            apiRoots: [],
+            databaseRoots: [],
+            configFiles: ['main.tf', 'variables.tf', 'outputs.tf', 'providers.tf'],
+            fileExtensions: ['.tf', '.tfvars'],
+            dependencyFileExtensions: ['.tf', '.tfvars'],
+            ignoreDirectories: [...commonIgnoreDirectories, '.terraform'],
+            entrypointHints: ['main.tf'],
+            publicEntrypointDirectories: [],
+            moduleIndexFileName: 'main.tf',
+        },
+        detect: (context) => {
+            const hasTerraformFiles = context.hasFileExtension('.tf');
+            const hasTerraformLayout = context.hasDirectory('modules') ||
+                context.hasDirectory('environments') ||
+                context.hasDirectory('live') ||
+                context.hasDirectory('stacks');
+            const hasTerraformEntrypoints = context.hasFile('main.tf') ||
+                context.hasFile('variables.tf') ||
+                context.hasFile('outputs.tf') ||
+                context.hasFile('providers.tf');
+            if (!hasTerraformFiles && !hasTerraformLayout && !hasTerraformEntrypoints) {
+                return null;
+            }
+            const evidence = [];
+            let score = 0;
+            if (hasTerraformFiles) {
+                score += 28;
+                evidence.push('Found Terraform .tf files');
+            }
+            if (hasTerraformLayout) {
+                score += 24;
+                evidence.push('Found Terraform-style modules/environments/live/stacks layout');
+            }
+            if (hasTerraformEntrypoints) {
+                score += 22;
+                evidence.push('Found Terraform entrypoint files (main.tf/variables.tf/outputs.tf/providers.tf)');
+            }
+            return toResult({
+                adapterId: 'terraform',
+                confidence: hasTerraformLayout || hasTerraformEntrypoints ? 'high' : 'medium',
+                score,
+                evidence,
+                projectKindHints: ['library'],
+            });
+        },
+        resolveProjectKinds: () => ['library'],
+        getImportExtractionMode: () => 'generic',
+    }),
+    ansible: buildAdapter({
+        id: 'ansible',
+        displayName: stackMetadata_1.canonicalStackLabels.ansible,
+        ecosystem: 'other',
+        category: 'runtime',
+        priority: 34,
+        manifestDetectionHints: ['ansible.cfg', 'site.yml', 'site.yaml'],
+        buildToolHints: ['ansible'],
+        defaults: {
+            sourceRoots: ['roles', 'playbooks', 'inventories', '.'],
+            moduleRootCandidates: ['roles', 'playbooks', 'inventories', '.'],
+            apiRoots: [],
+            databaseRoots: [],
+            configFiles: ['ansible.cfg', 'site.yml', 'site.yaml'],
+            fileExtensions: ['.yml', '.yaml'],
+            dependencyFileExtensions: ['.yml', '.yaml'],
+            ignoreDirectories: [...commonIgnoreDirectories],
+            entrypointHints: ['site.yml', 'site.yaml'],
+            publicEntrypointDirectories: [],
+            moduleIndexFileName: 'site.yml',
+        },
+        detect: (context) => {
+            const hasAnsibleLayout = context.hasDirectory('roles') ||
+                context.hasDirectory('playbooks') ||
+                context.hasDirectory('inventories') ||
+                context.hasDirectory('group_vars') ||
+                context.hasDirectory('host_vars');
+            const hasAnsibleConfig = context.hasFile('ansible.cfg') ||
+                context.hasFile('site.yml') ||
+                context.hasFile('site.yaml');
+            const hasAnsibleYamlEvidence = context.hasAnyFileMatchingPattern(/\.(yml|yaml)$/iu, /^\s*-\s+hosts\s*:/imu) ||
+                context.hasAnyFileMatchingPattern(/\.(yml|yaml)$/iu, /^\s*hosts\s*:/imu) ||
+                context.hasAnyFileMatchingPattern(/\.(yml|yaml)$/iu, /^\s*roles\s*:/imu);
+            if (!hasAnsibleLayout && !hasAnsibleConfig && !hasAnsibleYamlEvidence) {
+                return null;
+            }
+            const evidence = [];
+            let score = 0;
+            if (hasAnsibleLayout) {
+                score += 28;
+                evidence.push('Found Ansible roles/playbooks/inventories layout');
+            }
+            if (hasAnsibleConfig) {
+                score += 18;
+                evidence.push('Found ansible.cfg or site.yml/site.yaml');
+            }
+            if (hasAnsibleYamlEvidence) {
+                score += 16;
+                evidence.push('Found ansible-style YAML structure');
+            }
+            return toResult({
+                adapterId: 'ansible',
+                confidence: hasAnsibleLayout ? 'high' : 'medium',
+                score,
+                evidence,
+                projectKindHints: ['library'],
+            });
+        },
+        resolveProjectKinds: () => ['library'],
+        getImportExtractionMode: () => 'generic',
+    }),
+    library_generic: buildAdapter({
+        id: 'library_generic',
+        displayName: stackMetadata_1.canonicalStackLabels.library_generic,
+        ecosystem: 'other',
+        category: 'runtime',
+        priority: 10,
+        manifestDetectionHints: ['package.json'],
+        buildToolHints: [],
+        defaults: {
+            sourceRoots: ['src'],
+            moduleRootCandidates: ['src'],
+            apiRoots: ['src'],
+            databaseRoots: [],
+            configFiles: ['package.json'],
+            fileExtensions: ['.ts', '.js', '.py', '.go'],
+            dependencyFileExtensions: ['.ts', '.js'],
+            ignoreDirectories: [...commonIgnoreDirectories],
+            entrypointHints: ['index.ts', 'index.js'],
+            publicEntrypointDirectories: [],
+            moduleIndexFileName: 'index.ts',
+        },
+        detect: () => null,
+        getImportExtractionMode: () => 'generic',
+    }),
+};
+function getStackFromSlots(slots, key) {
+    const value = slots[key];
+    return typeof value === 'string' ? value : undefined;
+}
+function getAllStackAdapters() {
+    return Object.values(stackAdaptersById)
+        .sort((left, right) => left.id.localeCompare(right.id));
+}
+function getSmartInitDetectionAdapters() {
+    return getAllStackAdapters().filter((adapter) => adapter.id !== 'other' && adapter.id !== 'library_generic');
+}
+function getStackAdapterById(stackId) {
+    if (!stackId || stackId === 'other') {
+        return genericDefaultAdapter;
+    }
+    return stackAdaptersById[stackId] ?? genericDefaultAdapter;
+}
+function resolveBackendAdapter(metadata) {
+    return getStackAdapterById(getStackFromSlots(metadata.stacks, 'backendStack'));
+}
+function resolveFrontendAdapter(metadata) {
+    return getStackAdapterById(getStackFromSlots(metadata.stacks, 'frontendStack'));
+}
+function resolveLibraryAdapter(metadata) {
+    return getStackAdapterById(getStackFromSlots(metadata.stacks, 'libraryStack'));
+}
+function resolvePrimaryAdapter(metadata) {
+    return getStackAdapterById(metadata.stacks.backendStack ??
+        metadata.stacks.frontendStack ??
+        metadata.stacks.libraryStack ??
+        'other');
+}
+function resolvePrimaryAdapterFromContract(contract) {
+    return resolvePrimaryAdapter((0, stackMetadata_1.normalizeStackMetadata)(contract));
+}
+function resolveDefaultModulesRootFromContract(contract, fallback = 'src/modules') {
+    const adapter = resolvePrimaryAdapterFromContract(contract);
+    const defaults = adapter.getDefaults();
+    return defaults.moduleRootCandidates[0] ?? defaults.sourceRoots[0] ?? fallback;
+}
+//# sourceMappingURL=stackAdapters.js.map