thachvd-kit 1.0.3 → 1.0.5

package/README.md

@@ -17,6 +17,7 @@ npx github:thachvd/thachvd-kit init
 
 The interactive wizard will first ask whether this is a new project or an existing one.
 If it is an existing project, it can scan the current codebase to prefill `PROJECT_CONTEXT.md`, or let you enter everything manually.
+The scan mode uses evidence-based detectors and shows why a framework was inferred, so you can quickly confirm or correct it.
 
 ```bash
 thachvd-kit init --scan

package/bin/cli.js

@@ -11,18 +11,19 @@ const targetDir = process.cwd();
 
 // --- Skill Resolver ---
 
-const LANG_SKILLS = {
-    javascript: ["nodejs-best-practices", "api-design"],
-    typescript: ["nodejs-best-practices", "api-design"],
-    python: ["python-patterns"],
-    go: ["golang-patterns", "golang-testing"],
-    php: ["laravel-patterns", "laravel-security", "laravel-tdd"],
-    rust: ["rust-pro"],
-    java: ["api-design"],
-    swift: ["mobile-design"],
-    kotlin: ["mobile-design"],
-    csharp: ["api-design"],
-};
+const LANG_SKILLS = {
+    javascript: ["nodejs-best-practices", "api-design"],
+    typescript: ["nodejs-best-practices", "api-design"],
+    python: ["python-patterns"],
+    go: ["golang-patterns", "golang-testing"],
+    php: ["api-design"],
+    rust: ["rust-pro"],
+    java: ["api-design"],
+    ruby: ["api-design"],
+    swift: ["mobile-design"],
+    kotlin: ["mobile-design"],
+    csharp: ["api-design"],
+};
 
 const FRAMEWORK_SKILLS = {
     vue: ["frontend-design", "tailwind-patterns"],
@@ -30,14 +31,25 @@ const FRAMEWORK_SKILLS = {
     next: ["nextjs-react-expert", "frontend-design"],
     nuxt: ["frontend-design"],
     svelte: ["frontend-design"],
-    laravel: ["laravel-patterns", "laravel-security", "laravel-tdd"],
-    express: ["nodejs-best-practices", "api-design"],
-    fastapi: ["python-patterns", "api-design"],
-    django: ["python-patterns", "api-design"],
-    gin: ["golang-patterns", "golang-testing"],
-    fiber: ["golang-patterns", "golang-testing"],
-    nestjs: ["nodejs-best-practices", "api-design"],
+    angular: ["frontend-design"],
+    laravel: ["laravel-patterns", "laravel-security", "laravel-tdd"],
+    cakephp: ["api-design"],
+    symfony: ["api-design"],
+    codeigniter: ["api-design"],
+    express: ["nodejs-best-practices", "api-design"],
+    fastapi: ["python-patterns", "api-design"],
+    django: ["python-patterns", "api-design"],
+    flask: ["python-patterns", "api-design"],
+    gin: ["golang-patterns", "golang-testing"],
+    fiber: ["golang-patterns", "golang-testing"],
+    echo: ["golang-patterns", "golang-testing"],
+    nestjs: ["nodejs-best-practices", "api-design"],
+    rails: ["api-design"],
+    spring: ["api-design"],
+    aspnet: ["api-design"],
     tauri: ["rust-pro", "desktop-design"],
+    axum: ["rust-pro", "api-design"],
+    actix: ["rust-pro", "api-design"],
     flutter: ["mobile-design"],
     "react-native": ["mobile-design"],
 };
@@ -80,16 +92,21 @@ function resolveSkills(data) {
 
 const FRAMEWORK_CHOICES = [
     'vue', 'react', 'next', 'nuxt', 'svelte', 'angular',
-    'laravel', 'express', 'fastapi', 'django', 'gin', 'fiber', 'nestjs',
-    'tauri', 'flutter', 'react-native'
+    'laravel', 'cakephp', 'symfony', 'codeigniter',
+    'express', 'fastapi', 'django', 'flask', 'gin', 'fiber', 'echo', 'nestjs',
+    'rails', 'spring', 'aspnet',
+    'tauri', 'axum', 'actix', 'flutter', 'react-native'
 ];
 
-const LANGUAGE_CHOICES = ['typescript', 'javascript', 'python', 'go', 'php', 'rust', 'java', 'swift', 'kotlin', 'csharp', 'cpp'];
+const LANGUAGE_CHOICES = ['typescript', 'javascript', 'python', 'go', 'php', 'rust', 'java', 'ruby', 'swift', 'kotlin', 'csharp', 'cpp'];
 const PROJECT_TYPE_CHOICES = ['web-app', 'api', 'mobile', 'desktop', 'cli', 'fullstack'];
 const DATABASE_CHOICES = ['postgres', 'mysql', 'sqlite', 'mongodb', 'redis', 'dynamodb', 'none'];
 const PACKAGE_MANAGER_CHOICES = ['npm', 'pnpm', 'yarn', 'bun', 'pip', 'uv', 'go mod', 'cargo', 'composer', 'auto-detect'];
 const TEST_FRAMEWORK_CHOICES = ['jest', 'vitest', 'pytest', 'go test', 'phpunit', 'pest', 'rspec', 'junit', 'auto-detect'];
 const CLOUD_CHOICES = ['aws', 'gcp', 'azure', 'vercel', 'fly', 'railway', 'none'];
+const FRONTEND_FRAMEWORKS = ['vue', 'react', 'next', 'nuxt', 'svelte', 'angular'];
+const BACKEND_FRAMEWORKS = ['laravel', 'cakephp', 'symfony', 'codeigniter', 'express', 'fastapi', 'django', 'flask', 'gin', 'fiber', 'echo', 'nestjs', 'rails', 'spring', 'aspnet', 'axum', 'actix'];
+const MOBILE_DESKTOP_FRAMEWORKS = ['tauri', 'flutter', 'react-native'];
 
 function printHelp() {
     console.log(`
@@ -160,74 +177,453 @@ function uniq(values) {
     return Array.from(new Set(values.filter(Boolean)));
 }
 
+function evidenceIf(condition, label, weight = 1) {
+    return condition ? { label, weight } : null;
+}
+
+function buildDetection(id, evidence, meta = {}) {
+    const hits = evidence.filter(Boolean);
+    const score = hits.reduce((sum, hit) => sum + hit.weight, 0);
+    return {
+        id,
+        score,
+        evidence: hits.map(hit => hit.label),
+        ...meta
+    };
+}
+
+function confidenceLabel(score) {
+    if (score >= 6) return 'high';
+    if (score >= 3) return 'medium';
+    return 'low';
+}
+
+function hasDependency(depNames, ...names) {
+    return names.some(name => depNames.has(name));
+}
+
+function hasComposerDependency(composerDepNames, ...names) {
+    return names.some(name => composerDepNames.has(name));
+}
+
+function hasRootFile(rootEntries, ...filenames) {
+    return filenames.some(name => rootEntries.has(name));
+}
+
+function textMatches(text, pattern) {
+    return Boolean(text && pattern.test(text));
+}
+
+const LANGUAGE_DETECTORS = [
+    {
+        id: 'typescript',
+        detect: ctx => buildDetection('typescript', [
+            evidenceIf(ctx.fileExists('tsconfig.json'), 'found tsconfig.json', 4),
+            evidenceIf(hasDependency(ctx.depNames, 'typescript', 'ts-node', 'tsx'), 'package.json -> typescript toolchain', 2)
+        ])
+    },
+    {
+        id: 'javascript',
+        detect: ctx => buildDetection('javascript', [
+            evidenceIf(ctx.fileExists('package.json'), 'found package.json', 2),
+            evidenceIf(ctx.depNames.size > 0, 'package.json -> JavaScript dependency graph', 1)
+        ])
+    },
+    {
+        id: 'python',
+        detect: ctx => buildDetection('python', [
+            evidenceIf(ctx.fileExists('requirements.txt'), 'found requirements.txt', 3),
+            evidenceIf(ctx.fileExists('pyproject.toml'), 'found pyproject.toml', 2),
+            evidenceIf(textMatches(ctx.pyprojectText, /\[tool\.(poetry|uv|hatch|pdm)\]/i), 'pyproject.toml -> Python tool section', 2)
+        ])
+    },
+    {
+        id: 'go',
+        detect: ctx => buildDetection('go', [
+            evidenceIf(ctx.fileExists('go.mod'), 'found go.mod', 4)
+        ])
+    },
+    {
+        id: 'php',
+        detect: ctx => buildDetection('php', [
+            evidenceIf(ctx.fileExists('composer.json'), 'found composer.json', 4),
+            evidenceIf(ctx.composerDepNames.size > 0, 'composer.json -> PHP dependency graph', 1)
+        ])
+    },
+    {
+        id: 'rust',
+        detect: ctx => buildDetection('rust', [
+            evidenceIf(ctx.fileExists('Cargo.toml'), 'found Cargo.toml', 4),
+            evidenceIf(ctx.fileExists('src-tauri', 'Cargo.toml'), 'found src-tauri/Cargo.toml', 5)
+        ])
+    },
+    {
+        id: 'java',
+        detect: ctx => buildDetection('java', [
+            evidenceIf(ctx.fileExists('pom.xml'), 'found pom.xml', 4),
+            evidenceIf(ctx.fileExists('build.gradle') || ctx.fileExists('build.gradle.kts'), 'found Gradle build file', 3)
+        ])
+    },
+    {
+        id: 'ruby',
+        detect: ctx => buildDetection('ruby', [
+            evidenceIf(ctx.fileExists('Gemfile'), 'found Gemfile', 4),
+            evidenceIf(ctx.fileExists('config.ru'), 'found config.ru', 1)
+        ])
+    },
+    {
+        id: 'csharp',
+        detect: ctx => buildDetection('csharp', [
+            evidenceIf(ctx.rootEntries.some(name => name.endsWith('.sln') || name.endsWith('.csproj')), 'found .sln/.csproj', 4),
+            evidenceIf(ctx.fileExists('Program.cs'), 'found Program.cs', 1)
+        ])
+    }
+];
+
+const FRAMEWORK_DETECTORS = [
+    {
+        id: 'next',
+        kind: 'frontend',
+        projectType: 'web-app',
+        detect: ctx => buildDetection('next', [
+            evidenceIf(hasDependency(ctx.depNames, 'next'), 'package.json -> next', 4),
+            evidenceIf(ctx.fileExists('next.config.js') || ctx.fileExists('next.config.mjs') || ctx.fileExists('next.config.ts'), 'found next.config.*', 3),
+            evidenceIf(ctx.fileExists('app') || ctx.fileExists('pages'), 'found app/ or pages/', 1)
+        ])
+    },
+    {
+        id: 'react',
+        kind: 'frontend',
+        projectType: 'web-app',
+        detect: ctx => buildDetection('react', [
+            evidenceIf(hasDependency(ctx.depNames, 'react'), 'package.json -> react', 4),
+            evidenceIf(hasDependency(ctx.depNames, 'react-dom'), 'package.json -> react-dom', 2)
+        ])
+    },
+    {
+        id: 'vue',
+        kind: 'frontend',
+        projectType: 'web-app',
+        detect: ctx => buildDetection('vue', [
+            evidenceIf(hasDependency(ctx.depNames, 'vue'), 'package.json -> vue', 4)
+        ])
+    },
+    {
+        id: 'nuxt',
+        kind: 'frontend',
+        projectType: 'web-app',
+        detect: ctx => buildDetection('nuxt', [
+            evidenceIf(hasDependency(ctx.depNames, 'nuxt'), 'package.json -> nuxt', 4),
+            evidenceIf(ctx.fileExists('nuxt.config.ts') || ctx.fileExists('nuxt.config.js'), 'found nuxt.config.*', 3)
+        ])
+    },
+    {
+        id: 'svelte',
+        kind: 'frontend',
+        projectType: 'web-app',
+        detect: ctx => buildDetection('svelte', [
+            evidenceIf(hasDependency(ctx.depNames, 'svelte', '@sveltejs/kit'), 'package.json -> svelte', 4)
+        ])
+    },
+    {
+        id: 'angular',
+        kind: 'frontend',
+        projectType: 'web-app',
+        detect: ctx => buildDetection('angular', [
+            evidenceIf(hasDependency(ctx.depNames, '@angular/core'), 'package.json -> @angular/core', 4),
+            evidenceIf(ctx.fileExists('angular.json'), 'found angular.json', 3)
+        ])
+    },
+    {
+        id: 'express',
+        kind: 'backend',
+        language: 'javascript',
+        projectType: 'api',
+        detect: ctx => buildDetection('express', [
+            evidenceIf(hasDependency(ctx.depNames, 'express'), 'package.json -> express', 4)
+        ])
+    },
+    {
+        id: 'nestjs',
+        kind: 'backend',
+        language: 'javascript',
+        projectType: 'api',
+        detect: ctx => buildDetection('nestjs', [
+            evidenceIf(hasDependency(ctx.depNames, '@nestjs/core'), 'package.json -> @nestjs/core', 4)
+        ])
+    },
+    {
+        id: 'fastapi',
+        kind: 'backend',
+        language: 'python',
+        projectType: 'api',
+        detect: ctx => buildDetection('fastapi', [
+            evidenceIf(textMatches(ctx.requirementsText, /\bfastapi\b/i) || textMatches(ctx.pyprojectText, /\bfastapi\b/i), 'Python deps -> fastapi', 4)
+        ])
+    },
+    {
+        id: 'django',
+        kind: 'backend',
+        language: 'python',
+        projectType: 'api',
+        detect: ctx => buildDetection('django', [
+            evidenceIf(textMatches(ctx.requirementsText, /\bdjango\b/i) || textMatches(ctx.pyprojectText, /\bdjango\b/i), 'Python deps -> django', 4),
+            evidenceIf(ctx.fileExists('manage.py'), 'found manage.py', 2)
+        ])
+    },
+    {
+        id: 'flask',
+        kind: 'backend',
+        language: 'python',
+        projectType: 'api',
+        detect: ctx => buildDetection('flask', [
+            evidenceIf(textMatches(ctx.requirementsText, /\bflask\b/i) || textMatches(ctx.pyprojectText, /\bflask\b/i), 'Python deps -> flask', 4)
+        ])
+    },
+    {
+        id: 'laravel',
+        kind: 'backend',
+        language: 'php',
+        projectType: 'api',
+        detect: ctx => buildDetection('laravel', [
+            evidenceIf(hasComposerDependency(ctx.composerDepNames, 'laravel/framework'), 'composer.json -> laravel/framework', 4),
+            evidenceIf(ctx.fileExists('artisan'), 'found artisan', 3)
+        ])
+    },
+    {
+        id: 'cakephp',
+        kind: 'backend',
+        language: 'php',
+        projectType: 'api',
+        detect: ctx => buildDetection('cakephp', [
+            evidenceIf(hasComposerDependency(ctx.composerDepNames, 'cakephp/cakephp'), 'composer.json -> cakephp/cakephp', 4),
+            evidenceIf(ctx.fileExists('bin', 'cake'), 'found bin/cake', 3),
+            evidenceIf(ctx.fileExists('config', 'app.php'), 'found config/app.php', 2),
+            evidenceIf(ctx.fileExists('app', 'Config', 'core.php'), 'found app/Config/core.php (CakePHP legacy)', 3),
+            evidenceIf(ctx.fileExists('app', 'Controller', 'AppController.php'), 'found app/Controller/AppController.php', 2),
+            evidenceIf(ctx.fileExists('app', 'Model', 'AppModel.php'), 'found app/Model/AppModel.php', 2),
+            evidenceIf(ctx.fileExists('lib', 'Cake'), 'found lib/Cake', 3),
+            evidenceIf(ctx.fileExists('cake', 'console', 'cake'), 'found cake/console/cake', 3)
+        ])
+    },
+    {
+        id: 'symfony',
+        kind: 'backend',
+        language: 'php',
+        projectType: 'api',
+        detect: ctx => buildDetection('symfony', [
+            evidenceIf(hasComposerDependency(ctx.composerDepNames, 'symfony/framework-bundle'), 'composer.json -> symfony/framework-bundle', 4),
+            evidenceIf(ctx.fileExists('bin', 'console'), 'found bin/console', 2),
+            evidenceIf(ctx.fileExists('config', 'bundles.php'), 'found config/bundles.php', 1)
+        ])
+    },
+    {
+        id: 'codeigniter',
+        kind: 'backend',
+        language: 'php',
+        projectType: 'api',
+        detect: ctx => buildDetection('codeigniter', [
+            evidenceIf(hasComposerDependency(ctx.composerDepNames, 'codeigniter4/framework'), 'composer.json -> codeigniter4/framework', 4),
+            evidenceIf(ctx.fileExists('spark'), 'found spark', 2),
+            evidenceIf(ctx.fileExists('app', 'Config', 'App.php'), 'found app/Config/App.php', 1)
+        ])
+    },
+    {
+        id: 'gin',
+        kind: 'backend',
+        language: 'go',
+        projectType: 'api',
+        detect: ctx => buildDetection('gin', [
+            evidenceIf(textMatches(ctx.goModText, /\bgithub\.com\/gin-gonic\/gin\b/i), 'go.mod -> github.com/gin-gonic/gin', 4)
+        ])
+    },
+    {
+        id: 'fiber',
+        kind: 'backend',
+        language: 'go',
+        projectType: 'api',
+        detect: ctx => buildDetection('fiber', [
+            evidenceIf(textMatches(ctx.goModText, /\bgithub\.com\/gofiber\/fiber\b/i), 'go.mod -> github.com/gofiber/fiber', 4)
+        ])
+    },
+    {
+        id: 'echo',
+        kind: 'backend',
+        language: 'go',
+        projectType: 'api',
+        detect: ctx => buildDetection('echo', [
+            evidenceIf(textMatches(ctx.goModText, /\bgithub\.com\/labstack\/echo\b/i), 'go.mod -> github.com/labstack/echo', 4)
+        ])
+    },
+    {
+        id: 'rails',
+        kind: 'backend',
+        language: 'ruby',
+        projectType: 'api',
+        detect: ctx => buildDetection('rails', [
+            evidenceIf(textMatches(ctx.gemfileText, /^\s*gem\s+["']rails["']/im), 'Gemfile -> rails', 4),
+            evidenceIf(ctx.fileExists('bin', 'rails'), 'found bin/rails', 2)
+        ])
+    },
+    {
+        id: 'spring',
+        kind: 'backend',
+        language: 'java',
+        projectType: 'api',
+        detect: ctx => buildDetection('spring', [
+            evidenceIf(textMatches(ctx.pomText, /spring-boot/i) || textMatches(ctx.gradleText, /spring-boot/i), 'Java build -> spring-boot', 4)
+        ])
+    },
+    {
+        id: 'aspnet',
+        kind: 'backend',
+        language: 'csharp',
+        projectType: 'api',
+        detect: ctx => buildDetection('aspnet', [
+            evidenceIf(textMatches(ctx.csprojText, /Microsoft\.NET\.Sdk\.Web/i), '.csproj -> Microsoft.NET.Sdk.Web', 4),
+            evidenceIf(textMatches(ctx.programCsText, /WebApplication\.CreateBuilder/i), 'Program.cs -> WebApplication.CreateBuilder', 2)
+        ])
+    },
+    {
+        id: 'tauri',
+        kind: 'desktop',
+        language: 'rust',
+        projectType: 'desktop',
+        detect: ctx => buildDetection('tauri', [
+            evidenceIf(hasDependency(ctx.depNames, '@tauri-apps/api'), 'package.json -> @tauri-apps/api', 4),
+            evidenceIf(ctx.fileExists('src-tauri', 'tauri.conf.json') || ctx.fileExists('src-tauri', 'tauri.conf.json5'), 'found src-tauri/tauri.conf.*', 4),
+            evidenceIf(ctx.fileExists('src-tauri', 'Cargo.toml'), 'found src-tauri/Cargo.toml', 2)
+        ])
+    },
+    {
+        id: 'axum',
+        kind: 'backend',
+        language: 'rust',
+        projectType: 'api',
+        detect: ctx => buildDetection('axum', [
+            evidenceIf(textMatches(ctx.cargoText, /\baxum\b/i), 'Cargo.toml -> axum', 4)
+        ])
+    },
+    {
+        id: 'actix',
+        kind: 'backend',
+        language: 'rust',
+        projectType: 'api',
+        detect: ctx => buildDetection('actix', [
+            evidenceIf(textMatches(ctx.cargoText, /\bactix-web\b/i), 'Cargo.toml -> actix-web', 4)
+        ])
+    },
+    {
+        id: 'flutter',
+        kind: 'mobile',
+        projectType: 'mobile',
+        detect: ctx => buildDetection('flutter', [
+            evidenceIf(textMatches(ctx.pubspecText, /^\s*flutter\s*:/im), 'pubspec.yaml -> flutter', 4)
+        ])
+    },
+    {
+        id: 'react-native',
+        kind: 'mobile',
+        projectType: 'mobile',
+        detect: ctx => buildDetection('react-native', [
+            evidenceIf(hasDependency(ctx.depNames, 'react-native', 'expo'), 'package.json -> react-native/expo', 4)
+        ])
+    }
+];
+
 function scanProject() {
     const pkg = readJsonIfExists('package.json') || {};
+    const composer = readJsonIfExists('composer.json') || {};
+    const rootEntries = fs.existsSync(targetDir) ? fs.readdirSync(targetDir) : [];
+    const rootCsproj = rootEntries.find(name => name.endsWith('.csproj')) || '';
     const deps = {
         ...(pkg.dependencies || {}),
         ...(pkg.devDependencies || {}),
         ...(pkg.peerDependencies || {})
     };
     const depNames = new Set(Object.keys(deps));
-    const frameworks = [];
+    const composerDeps = {
+        ...(composer.require || {}),
+        ...(composer['require-dev'] || {})
+    };
+    const composerDepNames = new Set(Object.keys(composerDeps));
+    const ctx = {
+        pkg,
+        composer,
+        depNames,
+        composerDepNames,
+        rootEntries,
+        fileExists,
+        requirementsText: readTextIfExists('requirements.txt'),
+        pyprojectText: readTextIfExists('pyproject.toml'),
+        goModText: readTextIfExists('go.mod'),
+        pubspecText: readTextIfExists('pubspec.yaml'),
+        gemfileText: readTextIfExists('Gemfile'),
+        pomText: readTextIfExists('pom.xml'),
+        gradleText: `${readTextIfExists('build.gradle')}\n${readTextIfExists('build.gradle.kts')}`,
+        cargoText: `${readTextIfExists('Cargo.toml')}\n${readTextIfExists('src-tauri', 'Cargo.toml')}`,
+        csprojText: rootCsproj ? readTextIfExists(rootCsproj) : '',
+        programCsText: readTextIfExists('Program.cs')
+    };
+
+    const languageDetections = LANGUAGE_DETECTORS
+        .map(detector => detector.detect(ctx))
+        .filter(result => result.score >= 2)
+        .sort((a, b) => b.score - a.score);
+
+    const frameworkDetails = FRAMEWORK_DETECTORS
+        .map(detector => {
+            const result = detector.detect(ctx);
+            if (result.score < 3) return null;
+            return {
+                ...result,
+                kind: detector.kind,
+                language: detector.language,
+                projectType: detector.projectType,
+                confidence: confidenceLabel(result.score)
+            };
+        })
+        .filter(Boolean)
+        .sort((a, b) => b.score - a.score);
+
+    const frameworkLanguageScores = frameworkDetails.reduce((acc, item) => {
+        if (!item.language) return acc;
+        acc[item.language] = (acc[item.language] || 0) + item.score;
+        return acc;
+    }, {});
+    const primaryLanguage = Object.keys(frameworkLanguageScores).sort((a, b) => frameworkLanguageScores[b] - frameworkLanguageScores[a])[0]
+        || languageDetections[0]?.id
+        || 'typescript';
+    const frameworks = uniq(frameworkDetails.map(item => item.id)).filter(name => FRAMEWORK_CHOICES.includes(name));
     const infrastructure = [];
-    let primaryLanguage = '';
     let projectType = '';
     let database = 'none';
     let testFramework = 'auto-detect';
     let cloud = 'none';
     let ciCd = 'none';
 
-    const addFramework = (name, condition) => {
-        if (condition) frameworks.push(name);
-    };
+    if (frameworkDetails.some(item => item.projectType === 'desktop')) projectType = 'desktop';
+    else if (frameworkDetails.some(item => item.projectType === 'mobile')) projectType = 'mobile';
+    else if (frameworkDetails.some(item => item.kind === 'frontend') && frameworkDetails.some(item => item.kind === 'backend')) projectType = 'fullstack';
+    else if (frameworkDetails.some(item => item.kind === 'backend')) projectType = 'api';
+    else if (frameworkDetails.some(item => item.kind === 'frontend')) projectType = 'web-app';
+    else if (fileExists('package.json') && pkg.bin) projectType = 'cli';
+    else if (['php', 'python', 'go', 'java', 'ruby', 'csharp', 'rust'].includes(primaryLanguage)) projectType = 'api';
 
-    addFramework('next', depNames.has('next'));
-    addFramework('react', depNames.has('react'));
-    addFramework('vue', depNames.has('vue'));
-    addFramework('nuxt', depNames.has('nuxt'));
-    addFramework('svelte', depNames.has('svelte') || depNames.has('@sveltejs/kit'));
-    addFramework('angular', depNames.has('@angular/core'));
-    addFramework('express', depNames.has('express'));
-    addFramework('nestjs', depNames.has('@nestjs/core'));
-    addFramework('fastapi', fileExists('requirements.txt') && /fastapi/i.test(readTextIfExists('requirements.txt')));
-    addFramework('django', fileExists('requirements.txt') && /django/i.test(readTextIfExists('requirements.txt')));
-    addFramework('tauri', depNames.has('@tauri-apps/api') || fileExists('src-tauri', 'tauri.conf.json') || fileExists('src-tauri', 'tauri.conf.json5'));
-    addFramework('flutter', fileExists('pubspec.yaml') && /flutter:/i.test(readTextIfExists('pubspec.yaml')));
-    addFramework('react-native', depNames.has('react-native') || depNames.has('expo'));
-    addFramework('laravel', fileExists('artisan') || depNames.has('laravel'));
-    addFramework('gin', fileExists('go.mod') && /\bgithub\.com\/gin-gonic\/gin\b/i.test(readTextIfExists('go.mod')));
-    addFramework('fiber', fileExists('go.mod') && /\bgithub\.com\/gofiber\/fiber\b/i.test(readTextIfExists('go.mod')));
-
-    if (fileExists('tsconfig.json') || depNames.has('typescript')) primaryLanguage = 'typescript';
-    else if (fileExists('Cargo.toml') || fileExists('src-tauri', 'Cargo.toml')) primaryLanguage = 'rust';
-    else if (fileExists('go.mod')) primaryLanguage = 'go';
-    else if (fileExists('requirements.txt') || fileExists('pyproject.toml')) primaryLanguage = 'python';
-    else if (fileExists('composer.json')) primaryLanguage = 'php';
-    else if (depNames.size > 0 || fileExists('package.json')) primaryLanguage = 'javascript';
-
-    if (frameworks.includes('tauri')) projectType = 'desktop';
-    else if (frameworks.includes('flutter') || frameworks.includes('react-native')) projectType = 'mobile';
-    else if (frameworks.some(f => ['express', 'fastapi', 'django', 'laravel', 'gin', 'fiber', 'nestjs'].includes(f))) {
-        projectType = frameworks.some(f => ['react', 'next', 'vue', 'nuxt', 'svelte', 'angular'].includes(f)) ? 'fullstack' : 'api';
-    } else if (frameworks.some(f => ['react', 'next', 'vue', 'nuxt', 'svelte', 'angular'].includes(f))) {
-        projectType = 'web-app';
-    } else if (fileExists('package.json') && pkg.bin) {
-        projectType = 'cli';
-    }
+    if (hasDependency(depNames, 'pg', 'postgres', '@prisma/client') || /postgres/i.test(JSON.stringify(pkg))) database = 'postgres';
+    else if (hasDependency(depNames, 'mysql', 'mysql2')) database = 'mysql';
+    else if (hasDependency(depNames, 'sqlite3', 'better-sqlite3', 'rusqlite')) database = 'sqlite';
+    else if (hasDependency(depNames, 'mongodb', 'mongoose')) database = 'mongodb';
+    else if (hasDependency(depNames, 'redis', 'ioredis')) database = 'redis';
+    else if (hasDependency(depNames, '@aws-sdk/client-dynamodb')) database = 'dynamodb';
 
-    if (depNames.has('pg') || depNames.has('postgres') || depNames.has('@prisma/client') || /postgres/i.test(JSON.stringify(pkg))) database = 'postgres';
-    else if (depNames.has('mysql') || depNames.has('mysql2')) database = 'mysql';
-    else if (depNames.has('sqlite3') || depNames.has('better-sqlite3') || depNames.has('rusqlite')) database = 'sqlite';
-    else if (depNames.has('mongodb') || depNames.has('mongoose')) database = 'mongodb';
-    else if (depNames.has('redis') || depNames.has('ioredis')) database = 'redis';
-    else if (depNames.has('@aws-sdk/client-dynamodb')) database = 'dynamodb';
-
-    if (depNames.has('vitest')) testFramework = 'vitest';
-    else if (depNames.has('jest')) testFramework = 'jest';
-    else if (depNames.has('pytest') || /pytest/i.test(readTextIfExists('requirements.txt'))) testFramework = 'pytest';
-    else if (depNames.has('phpunit')) testFramework = 'phpunit';
-    else if (depNames.has('pest')) testFramework = 'pest';
+    if (hasDependency(depNames, 'vitest')) testFramework = 'vitest';
+    else if (hasDependency(depNames, 'jest')) testFramework = 'jest';
+    else if (hasDependency(depNames, 'pytest') || textMatches(ctx.requirementsText, /\bpytest\b/i) || textMatches(ctx.pyprojectText, /\bpytest\b/i)) testFramework = 'pytest';
+    else if (hasComposerDependency(composerDepNames, 'phpunit/phpunit')) testFramework = 'phpunit';
+    else if (hasComposerDependency(composerDepNames, 'pestphp/pest')) testFramework = 'pest';
     else if (fileExists('go.mod')) testFramework = 'go test';
+    else if (textMatches(ctx.gemfileText, /^\s*gem\s+["']rspec["']/im)) testFramework = 'rspec';
 
     if (fileExists('Dockerfile') || fileExists('docker-compose.yml') || fileExists('docker-compose.yaml')) {
         infrastructure.push('docker');
@@ -249,12 +645,19 @@ function scanProject() {
     else if (fileExists('.circleci', 'config.yml')) ciCd = 'circleci';
     else if (fileExists('Jenkinsfile')) ciCd = 'jenkins';
 
+    const scanEvidence = [
+        ...(languageDetections[0] ? [`language:${languageDetections[0].id} => ${languageDetections[0].evidence.join('; ')}`] : []),
+        ...frameworkDetails.map(item => `${item.id} [${item.confidence}] => ${item.evidence.join('; ')}`)
+    ];
+
     return {
         project_name: path.basename(targetDir),
-        description: pkg.description || 'A software project',
+        description: pkg.description || composer.description || 'A software project',
         project_type: PROJECT_TYPE_CHOICES.includes(projectType) ? projectType : 'web-app',
         primary_language: LANGUAGE_CHOICES.includes(primaryLanguage) ? primaryLanguage : 'typescript',
-        frameworks: uniq(frameworks),
+        frameworks,
+        framework_details: frameworkDetails,
+        scan_evidence: scanEvidence,
         database: DATABASE_CHOICES.includes(database) ? database : 'none',
         package_manager: PACKAGE_MANAGER_CHOICES.includes(detectPackageManager()) ? detectPackageManager() : 'auto-detect',
         uses_docker: infrastructure.includes('docker'),
@@ -277,7 +680,7 @@ function resolveAgentTable(data) {
     const lang = (data.primary_language || "").toLowerCase();
 
     // Frontend
-    const frontendFws = frameworks.filter(f => ["vue", "react", "next", "nuxt", "svelte", "angular"].includes(f));
+    const frontendFws = frameworks.filter(f => FRONTEND_FRAMEWORKS.includes(f));
     if (frontendFws.length > 0) {
         let feSkills = [];
         frontendFws.forEach(fw => {
@@ -288,14 +691,14 @@ function resolveAgentTable(data) {
 
     // Backend
     let beSkills = [...(LANG_SKILLS[lang] || ["api-design"])];
-    const backendFws = frameworks.filter(f => ["laravel", "express", "fastapi", "django", "gin", "fiber", "nestjs"].includes(f));
+    const backendFws = frameworks.filter(f => BACKEND_FRAMEWORKS.includes(f));
     backendFws.forEach(fw => {
         beSkills.push(...(FRAMEWORK_SKILLS[fw] || []));
     });
     rows.push(["Backend API", "backend-specialist", Array.from(new Set(beSkills)).slice(0, 3).join(", ")]);
 
     // Mobile/Desktop
-    const mobileFws = frameworks.filter(f => ["tauri", "flutter", "react-native"].includes(f));
+    const mobileFws = frameworks.filter(f => MOBILE_DESKTOP_FRAMEWORKS.includes(f));
     if (mobileFws.length > 0) {
         let mobileSkills = [];
         mobileFws.forEach(fw => {
@@ -318,12 +721,25 @@ function resolveAgentTable(data) {
 
 // --- File Generators ---
 
-function generateProjectContext(data) {
-    const agentTable = resolveAgentTable(data);
-    const autoSkills = resolveSkills(data);
-
-    const agentRows = agentTable.map(([task, agent, skills]) => `| ${task} | \`${agent}\` | ${skills} |`).join('\n');
-    const autoSkillsList = autoSkills.map(s => `- ${s}`).join('\n');
+function generateProjectContext(data) {
+    const agentTable = resolveAgentTable(data);
+    const autoSkills = resolveSkills(data);
+    const scanEvidenceBlock = (data.scan_evidence || []).length > 0
+        ? `
+---
+
+## Scan Evidence
+
+These detections were inferred from the current codebase during \`init --scan\`:
+
+\`\`\`text
+${(data.scan_evidence || []).map(line => '- ' + line).join('\n')}
+\`\`\`
+`
+        : '';
+
+    const agentRows = agentTable.map(([task, agent, skills]) => `| ${task} | \`${agent}\` | ${skills} |`).join('\n');
+    const autoSkillsList = autoSkills.map(s => `- ${s}`).join('\n');
 
     return `# PROJECT_CONTEXT.md
 # Generated by thachvd-kit init wizard on ${new Date().toISOString().split('T')[0]}
@@ -347,11 +763,13 @@ stack:
   infrastructure: [${(data.infrastructure || []).join(', ')}]
   package_manager: ${data.package_manager || 'auto-detect'}
   test_framework: ${data.test_framework || 'auto-detect'}
-\`\`\`
-
----
-
-## Agent Routing
+\`\`\`
+
+${scanEvidenceBlock}
+
+---
+
+## Agent Routing
 
 | Task Type | Agent | Primary Skills |
 |-----------|-------|----------------|
@@ -510,6 +928,11 @@ async function main() {
     if (useScan) {
         console.log(`${pc.bold('  Scan result:')} ${scanned.primary_language} | ${scanned.frameworks.join(', ') || 'no framework'}`);
         console.log(`  ${pc.bold('Detected infra:')} ${scanned.infrastructure.join(', ') || 'none'}\n`);
+        if ((scanned.scan_evidence || []).length > 0) {
+            console.log(`  ${pc.bold('Evidence:')}`);
+            scanned.scan_evidence.forEach(line => console.log(`    · ${line}`));
+            console.log('');
+        }
     }
 
     const { project_name, description, project_type } = await askQuestions([
@@ -578,6 +1001,8 @@ async function main() {
     data.package_manager = data.package_manager || scanned?.package_manager || 'auto-detect';
     data.test_framework = data.test_framework || scanned?.test_framework || 'auto-detect';
     data.max_file_lines = data.max_file_lines || scanned?.max_file_lines || '300';
+    data.framework_details = scanned?.framework_details || [];
+    data.scan_evidence = scanned?.scan_evidence || [];
     data.infrastructure = [];
     if (data.uses_docker) data.infrastructure.push('docker');
     if (data.cloud !== 'none') data.infrastructure.push(data.cloud);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "thachvd-kit",
-    "version": "1.0.3",
+    "version": "1.0.5",
     "description": "Universal Agent Kit for Antigravity, Claude Code, and OpenCode",
     "bin": {
         "thachvd-kit": "./bin/cli.js"

package/scripts/init.py

@@ -13,6 +13,7 @@ import sys
 import os
 import argparse
 import json
+import re
 from pathlib import Path
 from datetime import datetime
 
@@ -35,12 +36,13 @@ def ask(prompt, default="", choices=None):
     value = input(f"  {bold('→')} {prompt}{display_default}: ").strip()
     return value if value else default
 
-def ask_multi(prompt, choices, default=None):
-    """Prompt for comma-separated selection from choices."""
-    print(f"\n  {cyan('Available:')} {', '.join(f'{i+1}) {c}' for i, c in enumerate(choices))}")
-    raw = input(f"  {bold('→')} {prompt} (numbers or names, comma-separated) [{dim(default or 'none')}]: ").strip()
-    if not raw:
-        return default or []
+def ask_multi(prompt, choices, default=None):
+    """Prompt for comma-separated selection from choices."""
+    display_default = ", ".join(default) if isinstance(default, list) else (default or "none")
+    print(f"\n  {cyan('Available:')} {', '.join(f'{i+1}) {c}' for i, c in enumerate(choices))}")
+    raw = input(f"  {bold('→')} {prompt} (numbers or names, comma-separated) [{dim(display_default)}]: ").strip()
+    if not raw:
+        return default or []
     selected = []
     for part in raw.replace(",", " ").split():
         part = part.strip()
@@ -71,32 +73,45 @@ def section(title):
 
 # ─── Skill resolver ──────────────────────────────────────────────────────────
 
-LANG_SKILLS = {
-    "typescript": ["nodejs-best-practices", "api-design"],
-    "javascript": ["nodejs-best-practices", "api-design"],
-    "python":     ["python-patterns"],
-    "go":         ["golang-patterns", "golang-testing"],
-    "php":        ["laravel-patterns", "laravel-security", "laravel-tdd"],
-    "rust":       ["rust-pro"],
-    "java":       ["api-design"],
-    "swift":      ["mobile-design"],
-    "kotlin":     ["mobile-design"],
-    "csharp":     ["api-design"],
-}
+LANG_SKILLS = {
+    "typescript": ["nodejs-best-practices", "api-design"],
+    "javascript": ["nodejs-best-practices", "api-design"],
+    "python":     ["python-patterns"],
+    "go":         ["golang-patterns", "golang-testing"],
+    "php":        ["api-design"],
+    "rust":       ["rust-pro"],
+    "java":       ["api-design"],
+    "ruby":       ["api-design"],
+    "swift":      ["mobile-design"],
+    "kotlin":     ["mobile-design"],
+    "csharp":     ["api-design"],
+}
 
 FRAMEWORK_SKILLS = {
     "vue":           ["frontend-design", "tailwind-patterns"],
     "react":         ["react-frontend", "frontend-design"],
     "next":          ["nextjs-react-expert", "frontend-design"],
-    "nuxt":          ["frontend-design"],
-    "svelte":        ["frontend-design"],
-    "laravel":       ["laravel-patterns", "laravel-security", "laravel-tdd"],
-    "express":       ["nodejs-best-practices", "api-design"],
-    "fastapi":       ["python-patterns", "api-design"],
-    "django":        ["python-patterns", "api-design"],
-    "gin":           ["golang-patterns", "golang-testing"],
-    "fiber":         ["golang-patterns", "golang-testing"],
+    "nuxt":          ["frontend-design"],
+    "svelte":        ["frontend-design"],
+    "angular":       ["frontend-design"],
+    "laravel":       ["laravel-patterns", "laravel-security", "laravel-tdd"],
+    "cakephp":       ["api-design"],
+    "symfony":       ["api-design"],
+    "codeigniter":   ["api-design"],
+    "express":       ["nodejs-best-practices", "api-design"],
+    "fastapi":       ["python-patterns", "api-design"],
+    "django":        ["python-patterns", "api-design"],
+    "flask":         ["python-patterns", "api-design"],
+    "gin":           ["golang-patterns", "golang-testing"],
+    "fiber":         ["golang-patterns", "golang-testing"],
+    "echo":          ["golang-patterns", "golang-testing"],
+    "nestjs":        ["nodejs-best-practices", "api-design"],
     "tauri":         ["rust-pro", "desktop-design"],
+    "axum":          ["rust-pro", "api-design"],
+    "actix":         ["rust-pro", "api-design"],
+    "rails":         ["api-design"],
+    "spring":        ["api-design"],
+    "aspnet":        ["api-design"],
     "flutter":       ["mobile-design"],
     "react-native":  ["mobile-design"],
 }
@@ -128,14 +143,19 @@ def resolve_skills(data):
     return sorted(skills)
 
 FRAMEWORKS_ALL = ["vue", "react", "next", "nuxt", "svelte", "angular",
-                  "laravel", "express", "fastapi", "django", "gin", "fiber", "nestjs",
-                  "tauri", "flutter", "react-native"]
-LANGUAGES_ALL = ["typescript", "javascript", "python", "go", "php", "rust", "java", "swift", "kotlin", "csharp", "c", "cpp"]
+                  "laravel", "cakephp", "symfony", "codeigniter",
+                  "express", "fastapi", "django", "flask", "gin", "fiber", "echo", "nestjs",
+                  "rails", "spring", "aspnet",
+                  "tauri", "axum", "actix", "flutter", "react-native"]
+LANGUAGES_ALL = ["typescript", "javascript", "python", "go", "php", "rust", "java", "ruby", "swift", "kotlin", "csharp", "c", "cpp"]
 PROJECT_TYPES_ALL = ["web-app", "api", "mobile", "desktop", "cli", "library", "fullstack"]
 DATABASES_ALL = ["postgres", "mysql", "sqlite", "mongodb", "redis", "dynamodb", "supabase", "prisma", "none"]
 PACKAGE_MANAGERS_ALL = ["npm", "pnpm", "yarn", "bun", "pip", "uv", "poetry", "go mod", "cargo", "composer", "auto-detect"]
 TEST_FRAMEWORKS_ALL = ["jest", "vitest", "pytest", "go test", "phpunit", "pest", "rspec", "junit", "auto-detect"]
 CLOUDS_ALL = ["aws", "gcp", "azure", "vercel", "fly", "railway", "digitalocean", "none"]
+FRONTEND_FRAMEWORKS = ["vue", "react", "next", "nuxt", "svelte", "angular"]
+BACKEND_FRAMEWORKS = ["laravel", "cakephp", "symfony", "codeigniter", "express", "fastapi", "django", "flask", "gin", "fiber", "echo", "nestjs", "rails", "spring", "aspnet", "axum", "actix"]
+MOBILE_DESKTOP_FRAMEWORKS = ["tauri", "flutter", "react-native"]
 
 def read_text_if_exists(*parts):
     path = Path.cwd().joinpath(*parts)
@@ -168,75 +188,241 @@ def detect_package_manager():
 def uniq(values):
     return list(dict.fromkeys(v for v in values if v))
 
+def evidence_if(condition, label, weight=1):
+    return {"label": label, "weight": weight} if condition else None
+
+def build_detection(id, evidence, **meta):
+    hits = [hit for hit in evidence if hit]
+    score = sum(hit["weight"] for hit in hits)
+    return {
+        "id": id,
+        "score": score,
+        "evidence": [hit["label"] for hit in hits],
+        **meta,
+    }
+
+def confidence_label(score):
+    if score >= 6: return "high"
+    if score >= 3: return "medium"
+    return "low"
+
+def has_dependency(dep_names, *names):
+    return any(name in dep_names for name in names)
+
+def has_composer_dependency(composer_dep_names, *names):
+    return any(name in composer_dep_names for name in names)
+
+def text_matches(text, pattern):
+    return bool(text and re.search(pattern, text, re.IGNORECASE | re.MULTILINE))
+
 def scan_project():
     pkg = read_json_if_exists("package.json") or {}
+    composer = read_json_if_exists("composer.json") or {}
+    root_entries = [p.name for p in Path.cwd().iterdir()] if Path.cwd().exists() else []
+    root_csproj = next((name for name in root_entries if name.endswith(".csproj")), "")
     deps = {}
     for key in ("dependencies", "devDependencies", "peerDependencies"):
         deps.update(pkg.get(key, {}) or {})
     dep_names = set(deps.keys())
-    frameworks = []
+    composer_deps = {}
+    for key in ("require", "require-dev"):
+        composer_deps.update(composer.get(key, {}) or {})
+    composer_dep_names = set(composer_deps.keys())
+    requirements = read_text_if_exists("requirements.txt")
+    pyproject = read_text_if_exists("pyproject.toml")
+    go_mod = read_text_if_exists("go.mod")
+    pubspec = read_text_if_exists("pubspec.yaml")
+    gemfile = read_text_if_exists("Gemfile")
+    pom = read_text_if_exists("pom.xml")
+    gradle = f"{read_text_if_exists('build.gradle')}\n{read_text_if_exists('build.gradle.kts')}"
+    cargo = f"{read_text_if_exists('Cargo.toml')}\n{read_text_if_exists('src-tauri/Cargo.toml')}"
+    csproj = read_text_if_exists(root_csproj) if root_csproj else ""
+    program_cs = read_text_if_exists("Program.cs")
+
+    language_detections = [
+        build_detection("typescript", [
+            evidence_if(Path("tsconfig.json").exists(), "found tsconfig.json", 4),
+            evidence_if(has_dependency(dep_names, "typescript", "ts-node", "tsx"), "package.json -> typescript toolchain", 2),
+        ]),
+        build_detection("javascript", [
+            evidence_if(Path("package.json").exists(), "found package.json", 2),
+            evidence_if(bool(dep_names), "package.json -> JavaScript dependency graph", 1),
+        ]),
+        build_detection("python", [
+            evidence_if(Path("requirements.txt").exists(), "found requirements.txt", 3),
+            evidence_if(Path("pyproject.toml").exists(), "found pyproject.toml", 2),
+            evidence_if(text_matches(pyproject, r"\[tool\.(poetry|uv|hatch|pdm)\]"), "pyproject.toml -> Python tool section", 2),
+        ]),
+        build_detection("go", [
+            evidence_if(Path("go.mod").exists(), "found go.mod", 4),
+        ]),
+        build_detection("php", [
+            evidence_if(Path("composer.json").exists(), "found composer.json", 4),
+            evidence_if(bool(composer_dep_names), "composer.json -> PHP dependency graph", 1),
+        ]),
+        build_detection("rust", [
+            evidence_if(Path("Cargo.toml").exists(), "found Cargo.toml", 4),
+            evidence_if(Path("src-tauri/Cargo.toml").exists(), "found src-tauri/Cargo.toml", 5),
+        ]),
+        build_detection("java", [
+            evidence_if(Path("pom.xml").exists(), "found pom.xml", 4),
+            evidence_if(Path("build.gradle").exists() or Path("build.gradle.kts").exists(), "found Gradle build file", 3),
+        ]),
+        build_detection("ruby", [
+            evidence_if(Path("Gemfile").exists(), "found Gemfile", 4),
+            evidence_if(Path("config.ru").exists(), "found config.ru", 1),
+        ]),
+        build_detection("csharp", [
+            evidence_if(any(name.endswith(".sln") or name.endswith(".csproj") for name in root_entries), "found .sln/.csproj", 4),
+            evidence_if(Path("Program.cs").exists(), "found Program.cs", 1),
+        ]),
+    ]
+    language_detections = [item for item in language_detections if item["score"] >= 2]
+    language_detections.sort(key=lambda item: item["score"], reverse=True)
+
+    framework_details = [
+        {**build_detection("next", [
+            evidence_if(has_dependency(dep_names, "next"), "package.json -> next", 4),
+            evidence_if(Path("next.config.js").exists() or Path("next.config.mjs").exists() or Path("next.config.ts").exists(), "found next.config.*", 3),
+            evidence_if(Path("app").exists() or Path("pages").exists(), "found app/ or pages/", 1),
+        ]), "kind": "frontend", "project_type": "web-app"},
+        {**build_detection("react", [
+            evidence_if(has_dependency(dep_names, "react"), "package.json -> react", 4),
+            evidence_if(has_dependency(dep_names, "react-dom"), "package.json -> react-dom", 2),
+        ]), "kind": "frontend", "project_type": "web-app"},
+        {**build_detection("vue", [
+            evidence_if(has_dependency(dep_names, "vue"), "package.json -> vue", 4),
+        ]), "kind": "frontend", "project_type": "web-app"},
+        {**build_detection("nuxt", [
+            evidence_if(has_dependency(dep_names, "nuxt"), "package.json -> nuxt", 4),
+            evidence_if(Path("nuxt.config.ts").exists() or Path("nuxt.config.js").exists(), "found nuxt.config.*", 3),
+        ]), "kind": "frontend", "project_type": "web-app"},
+        {**build_detection("svelte", [
+            evidence_if(has_dependency(dep_names, "svelte", "@sveltejs/kit"), "package.json -> svelte", 4),
+        ]), "kind": "frontend", "project_type": "web-app"},
+        {**build_detection("angular", [
+            evidence_if(has_dependency(dep_names, "@angular/core"), "package.json -> @angular/core", 4),
+            evidence_if(Path("angular.json").exists(), "found angular.json", 3),
+        ]), "kind": "frontend", "project_type": "web-app"},
+        {**build_detection("express", [
+            evidence_if(has_dependency(dep_names, "express"), "package.json -> express", 4),
+        ]), "kind": "backend", "project_type": "api", "language": "javascript"},
+        {**build_detection("nestjs", [
+            evidence_if(has_dependency(dep_names, "@nestjs/core"), "package.json -> @nestjs/core", 4),
+        ]), "kind": "backend", "project_type": "api", "language": "javascript"},
+        {**build_detection("fastapi", [
+            evidence_if(text_matches(requirements, r"\bfastapi\b") or text_matches(pyproject, r"\bfastapi\b"), "Python deps -> fastapi", 4),
+        ]), "kind": "backend", "project_type": "api", "language": "python"},
+        {**build_detection("django", [
+            evidence_if(text_matches(requirements, r"\bdjango\b") or text_matches(pyproject, r"\bdjango\b"), "Python deps -> django", 4),
+            evidence_if(Path("manage.py").exists(), "found manage.py", 2),
+        ]), "kind": "backend", "project_type": "api", "language": "python"},
+        {**build_detection("flask", [
+            evidence_if(text_matches(requirements, r"\bflask\b") or text_matches(pyproject, r"\bflask\b"), "Python deps -> flask", 4),
+        ]), "kind": "backend", "project_type": "api", "language": "python"},
+        {**build_detection("laravel", [
+            evidence_if(has_composer_dependency(composer_dep_names, "laravel/framework"), "composer.json -> laravel/framework", 4),
+            evidence_if(Path("artisan").exists(), "found artisan", 3),
+        ]), "kind": "backend", "project_type": "api", "language": "php"},
+        {**build_detection("cakephp", [
+            evidence_if(has_composer_dependency(composer_dep_names, "cakephp/cakephp"), "composer.json -> cakephp/cakephp", 4),
+            evidence_if(Path("bin/cake").exists(), "found bin/cake", 3),
+            evidence_if(Path("config/app.php").exists(), "found config/app.php", 2),
+            evidence_if(Path("app/Config/core.php").exists(), "found app/Config/core.php (CakePHP legacy)", 3),
+            evidence_if(Path("app/Controller/AppController.php").exists(), "found app/Controller/AppController.php", 2),
+            evidence_if(Path("app/Model/AppModel.php").exists(), "found app/Model/AppModel.php", 2),
+            evidence_if(Path("lib/Cake").exists(), "found lib/Cake", 3),
+            evidence_if(Path("cake/console/cake").exists(), "found cake/console/cake", 3),
+        ]), "kind": "backend", "project_type": "api", "language": "php"},
+        {**build_detection("symfony", [
+            evidence_if(has_composer_dependency(composer_dep_names, "symfony/framework-bundle"), "composer.json -> symfony/framework-bundle", 4),
+            evidence_if(Path("bin/console").exists(), "found bin/console", 2),
+            evidence_if(Path("config/bundles.php").exists(), "found config/bundles.php", 1),
+        ]), "kind": "backend", "project_type": "api", "language": "php"},
+        {**build_detection("codeigniter", [
+            evidence_if(has_composer_dependency(composer_dep_names, "codeigniter4/framework"), "composer.json -> codeigniter4/framework", 4),
+            evidence_if(Path("spark").exists(), "found spark", 2),
+            evidence_if(Path("app/Config/App.php").exists(), "found app/Config/App.php", 1),
+        ]), "kind": "backend", "project_type": "api", "language": "php"},
+        {**build_detection("gin", [
+            evidence_if(text_matches(go_mod, r"\bgithub\.com\/gin-gonic\/gin\b"), "go.mod -> github.com/gin-gonic/gin", 4),
+        ]), "kind": "backend", "project_type": "api", "language": "go"},
+        {**build_detection("fiber", [
+            evidence_if(text_matches(go_mod, r"\bgithub\.com\/gofiber\/fiber\b"), "go.mod -> github.com/gofiber/fiber", 4),
+        ]), "kind": "backend", "project_type": "api", "language": "go"},
+        {**build_detection("echo", [
+            evidence_if(text_matches(go_mod, r"\bgithub\.com\/labstack\/echo\b"), "go.mod -> github.com/labstack/echo", 4),
+        ]), "kind": "backend", "project_type": "api", "language": "go"},
+        {**build_detection("rails", [
+            evidence_if(text_matches(gemfile, r'^\s*gem\s+["\']rails["\']'), "Gemfile -> rails", 4),
+            evidence_if(Path("bin/rails").exists(), "found bin/rails", 2),
+        ]), "kind": "backend", "project_type": "api", "language": "ruby"},
+        {**build_detection("spring", [
+            evidence_if(text_matches(pom, r"spring-boot") or text_matches(gradle, r"spring-boot"), "Java build -> spring-boot", 4),
+        ]), "kind": "backend", "project_type": "api", "language": "java"},
+        {**build_detection("aspnet", [
+            evidence_if(text_matches(csproj, r"Microsoft\.NET\.Sdk\.Web"), ".csproj -> Microsoft.NET.Sdk.Web", 4),
+            evidence_if(text_matches(program_cs, r"WebApplication\.CreateBuilder"), "Program.cs -> WebApplication.CreateBuilder", 2),
+        ]), "kind": "backend", "project_type": "api", "language": "csharp"},
+        {**build_detection("tauri", [
+            evidence_if(has_dependency(dep_names, "@tauri-apps/api"), "package.json -> @tauri-apps/api", 4),
+            evidence_if(Path("src-tauri/tauri.conf.json").exists() or Path("src-tauri/tauri.conf.json5").exists(), "found src-tauri/tauri.conf.*", 4),
+            evidence_if(Path("src-tauri/Cargo.toml").exists(), "found src-tauri/Cargo.toml", 2),
+        ]), "kind": "desktop", "project_type": "desktop", "language": "rust"},
+        {**build_detection("axum", [
+            evidence_if(text_matches(cargo, r"\baxum\b"), "Cargo.toml -> axum", 4),
+        ]), "kind": "backend", "project_type": "api", "language": "rust"},
+        {**build_detection("actix", [
+            evidence_if(text_matches(cargo, r"\bactix-web\b"), "Cargo.toml -> actix-web", 4),
+        ]), "kind": "backend", "project_type": "api", "language": "rust"},
+        {**build_detection("flutter", [
+            evidence_if(text_matches(pubspec, r"^\s*flutter\s*:"), "pubspec.yaml -> flutter", 4),
+        ]), "kind": "mobile", "project_type": "mobile"},
+        {**build_detection("react-native", [
+            evidence_if(has_dependency(dep_names, "react-native", "expo"), "package.json -> react-native/expo", 4),
+        ]), "kind": "mobile", "project_type": "mobile"},
+    ]
+    framework_details = [item for item in framework_details if item["score"] >= 3]
+    framework_details.sort(key=lambda item: item["score"], reverse=True)
+    for item in framework_details:
+        item["confidence"] = confidence_label(item["score"])
+
+    framework_language_scores = {}
+    for item in framework_details:
+        if item.get("language"):
+            framework_language_scores[item["language"]] = framework_language_scores.get(item["language"], 0) + item["score"]
+    primary_language = max(framework_language_scores, key=framework_language_scores.get) if framework_language_scores else (language_detections[0]["id"] if language_detections else "typescript")
+    frameworks = [item["id"] for item in framework_details if item["id"] in FRAMEWORKS_ALL]
+    frameworks = uniq(frameworks)
     infrastructure = []
-    primary_language = ""
     project_type = ""
     database = "none"
     test_framework = "auto-detect"
     cloud = "none"
     ci_cd = "none"
 
-    def add_framework(name, condition):
-        if condition:
-            frameworks.append(name)
-
-    requirements = read_text_if_exists("requirements.txt")
-    go_mod = read_text_if_exists("go.mod")
-    pubspec = read_text_if_exists("pubspec.yaml")
-
-    add_framework("next", "next" in dep_names)
-    add_framework("react", "react" in dep_names)
-    add_framework("vue", "vue" in dep_names)
-    add_framework("nuxt", "nuxt" in dep_names)
-    add_framework("svelte", "svelte" in dep_names or "@sveltejs/kit" in dep_names)
-    add_framework("angular", "@angular/core" in dep_names)
-    add_framework("express", "express" in dep_names)
-    add_framework("nestjs", "@nestjs/core" in dep_names)
-    add_framework("fastapi", "fastapi" in requirements.lower())
-    add_framework("django", "django" in requirements.lower())
-    add_framework("tauri", "@tauri-apps/api" in dep_names or Path("src-tauri/tauri.conf.json").exists() or Path("src-tauri/tauri.conf.json5").exists())
-    add_framework("flutter", "flutter:" in pubspec.lower())
-    add_framework("react-native", "react-native" in dep_names or "expo" in dep_names)
-    add_framework("laravel", Path("artisan").exists())
-    add_framework("gin", "github.com/gin-gonic/gin" in go_mod.lower())
-    add_framework("fiber", "github.com/gofiber/fiber" in go_mod.lower())
-
-    if Path("tsconfig.json").exists() or "typescript" in dep_names: primary_language = "typescript"
-    elif Path("Cargo.toml").exists() or Path("src-tauri/Cargo.toml").exists(): primary_language = "rust"
-    elif Path("go.mod").exists(): primary_language = "go"
-    elif Path("requirements.txt").exists() or Path("pyproject.toml").exists(): primary_language = "python"
-    elif Path("composer.json").exists(): primary_language = "php"
-    elif dep_names or Path("package.json").exists(): primary_language = "javascript"
-
-    if "tauri" in frameworks: project_type = "desktop"
-    elif "flutter" in frameworks or "react-native" in frameworks: project_type = "mobile"
-    elif any(f in frameworks for f in ["express", "fastapi", "django", "laravel", "gin", "fiber", "nestjs"]):
-        project_type = "fullstack" if any(f in frameworks for f in ["react", "next", "vue", "nuxt", "svelte", "angular"]) else "api"
-    elif any(f in frameworks for f in ["react", "next", "vue", "nuxt", "svelte", "angular"]):
-        project_type = "web-app"
-    elif Path("package.json").exists() and pkg.get("bin"):
-        project_type = "cli"
-
-    if "pg" in dep_names or "postgres" in dep_names or "@prisma/client" in dep_names or "postgres" in json.dumps(pkg).lower(): database = "postgres"
-    elif "mysql" in dep_names or "mysql2" in dep_names: database = "mysql"
-    elif "sqlite3" in dep_names or "better-sqlite3" in dep_names or "rusqlite" in dep_names: database = "sqlite"
-    elif "mongodb" in dep_names or "mongoose" in dep_names: database = "mongodb"
-    elif "redis" in dep_names or "ioredis" in dep_names: database = "redis"
-    elif "@aws-sdk/client-dynamodb" in dep_names: database = "dynamodb"
-
-    if "vitest" in dep_names: test_framework = "vitest"
-    elif "jest" in dep_names: test_framework = "jest"
-    elif "pytest" in dep_names or "pytest" in requirements.lower(): test_framework = "pytest"
-    elif "phpunit" in dep_names: test_framework = "phpunit"
-    elif "pest" in dep_names: test_framework = "pest"
+    if any(item["project_type"] == "desktop" for item in framework_details): project_type = "desktop"
+    elif any(item["project_type"] == "mobile" for item in framework_details): project_type = "mobile"
+    elif any(item["kind"] == "frontend" for item in framework_details) and any(item["kind"] == "backend" for item in framework_details): project_type = "fullstack"
+    elif any(item["kind"] == "backend" for item in framework_details): project_type = "api"
+    elif any(item["kind"] == "frontend" for item in framework_details): project_type = "web-app"
+    elif Path("package.json").exists() and pkg.get("bin"): project_type = "cli"
+    elif primary_language in ["php", "python", "go", "java", "ruby", "csharp", "rust"]: project_type = "api"
+
+    if has_dependency(dep_names, "pg", "postgres", "@prisma/client") or "postgres" in json.dumps(pkg).lower(): database = "postgres"
+    elif has_dependency(dep_names, "mysql", "mysql2"): database = "mysql"
+    elif has_dependency(dep_names, "sqlite3", "better-sqlite3", "rusqlite"): database = "sqlite"
+    elif has_dependency(dep_names, "mongodb", "mongoose"): database = "mongodb"
+    elif has_dependency(dep_names, "redis", "ioredis"): database = "redis"
+    elif has_dependency(dep_names, "@aws-sdk/client-dynamodb"): database = "dynamodb"
+
+    if has_dependency(dep_names, "vitest"): test_framework = "vitest"
+    elif has_dependency(dep_names, "jest"): test_framework = "jest"
+    elif has_dependency(dep_names, "pytest") or text_matches(requirements, r"\bpytest\b") or text_matches(pyproject, r"\bpytest\b"): test_framework = "pytest"
+    elif has_composer_dependency(composer_dep_names, "phpunit/phpunit"): test_framework = "phpunit"
+    elif has_composer_dependency(composer_dep_names, "pestphp/pest"): test_framework = "pest"
     elif Path("go.mod").exists(): test_framework = "go test"
+    elif text_matches(gemfile, r'^\s*gem\s+["\']rspec["\']'): test_framework = "rspec"
 
     if Path("Dockerfile").exists() or Path("docker-compose.yml").exists() or Path("docker-compose.yaml").exists():
         infrastructure.append("docker")
@@ -256,12 +442,19 @@ def scan_project():
     elif Path(".circleci/config.yml").exists(): ci_cd = "circleci"
     elif Path("Jenkinsfile").exists(): ci_cd = "jenkins"
 
+    scan_evidence = []
+    if language_detections:
+        scan_evidence.append(f"language:{language_detections[0]['id']} => {'; '.join(language_detections[0]['evidence'])}")
+    scan_evidence.extend(f"{item['id']} [{item['confidence']}] => {'; '.join(item['evidence'])}" for item in framework_details)
+
     return {
         "project_name": Path.cwd().name,
-        "description": pkg.get("description", "A software project"),
+        "description": pkg.get("description") or composer.get("description", "A software project"),
         "project_type": project_type if project_type in PROJECT_TYPES_ALL else "web-app",
         "primary_language": primary_language if primary_language in LANGUAGES_ALL else "typescript",
-        "frameworks": uniq(frameworks),
+        "frameworks": frameworks,
+        "framework_details": framework_details,
+        "scan_evidence": scan_evidence,
         "database": database if database in DATABASES_ALL else "none",
         "package_manager": detect_package_manager(),
         "uses_docker": "docker" in infrastructure,
@@ -283,7 +476,7 @@ def resolve_agent_table(data):
     lang = data.get("primary_language", "").lower()
 
     # Determine frontend agent
-    frontend_fws = [f for f in frameworks if f in ["vue", "react", "next", "nuxt", "svelte", "angular"]]
+    frontend_fws = [f for f in frameworks if f in FRONTEND_FRAMEWORKS]
     if frontend_fws:
         fe_skills = []
         for fw in frontend_fws:
@@ -292,13 +485,13 @@ def resolve_agent_table(data):
 
     # Backend
     be_skills = list(LANG_SKILLS.get(lang, ["api-design"]))
-    backend_fws = [f for f in frameworks if f in ["laravel", "express", "fastapi", "django", "gin", "fiber"]]
+    backend_fws = [f for f in frameworks if f in BACKEND_FRAMEWORKS]
     for fw in backend_fws:
         be_skills.extend(FRAMEWORK_SKILLS.get(fw, []))
     rows.append(("Backend API", "backend-specialist", ", ".join(set(be_skills[:3]))))
 
     # Mobile/Desktop
-    mobile_fws = [f for f in frameworks if f in ["tauri", "flutter", "react-native"]]
+    mobile_fws = [f for f in frameworks if f in MOBILE_DESKTOP_FRAMEWORKS]
     if mobile_fws:
         mobile_skills = []
         for fw in mobile_fws:
@@ -316,20 +509,35 @@ def resolve_agent_table(data):
 
 # ─── Generators ──────────────────────────────────────────────────────────────
 
-def generate_project_context(data):
-    frameworks = data.get("frameworks", [])
-    infrastructure = data.get("infrastructure", [])
-    agent_table = resolve_agent_table(data)
-    auto_skills = resolve_skills(data)
+def generate_project_context(data):
+    frameworks = data.get("frameworks", [])
+    infrastructure = data.get("infrastructure", [])
+    agent_table = resolve_agent_table(data)
+    auto_skills = resolve_skills(data)
+    scan_evidence = data.get("scan_evidence", [])
 
     agent_rows = "\n".join(
         f"| {task} | `{agent}` | {skills} |"
         for task, agent, skills in agent_table
     )
 
-    return f"""# PROJECT_CONTEXT.md
-# Generated by thachvd-kit init wizard on {datetime.now().strftime('%Y-%m-%d')}
-# Edit freely — this is your project's brain.
+    scan_evidence_block = ""
+    if scan_evidence:
+        scan_evidence_block = f"""
+---
+
+## Scan Evidence
+
+These detections were inferred from the current codebase during `init --scan`:
+
+```
+{chr(10).join('- ' + line for line in scan_evidence)}
+```
+"""
+
+    return f"""# PROJECT_CONTEXT.md
+# Generated by thachvd-kit init wizard on {datetime.now().strftime('%Y-%m-%d')}
+# Edit freely — this is your project's brain.
 
 ## Project
 
@@ -349,9 +557,11 @@ stack:
   infrastructure: [{', '.join(infrastructure)}]
   package_manager: {data.get('package_manager', 'auto-detect')}
   test_framework: {data.get('test_framework', 'auto-detect')}
-```
-
----
+```
+
+{scan_evidence_block}
+
+---
 
 ## Agent Routing
 
@@ -469,6 +679,11 @@ def main():
         print(f"  {dim('Scan mode: detecting stack from current project files...')}")
         print(f"  {bold('Scan result:')} {scanned['primary_language']} | {', '.join(scanned['frameworks']) or 'no framework'}")
         print(f"  {bold('Detected infra:')} {', '.join(scanned['infrastructure']) or 'none'}\n")
+        if scanned.get("scan_evidence"):
+            print(f"  {bold('Evidence:')}")
+            for line in scanned["scan_evidence"]:
+                print(f"    · {line}")
+            print()
     elif not args.yes:
         print(f"  {dim('Manual mode: asking for project context explicitly.')}\n")
 
@@ -493,7 +708,7 @@ def main():
             default=(scanned or {}).get("primary_language", "typescript"),
             choices=LANGUAGES_ALL)
 
-        frameworks = ask_multi("Frameworks (select all that apply)", FRAMEWORKS_ALL, default=", ".join((scanned or {}).get("frameworks", [])) or None)
+        frameworks = ask_multi("Frameworks (select all that apply)", FRAMEWORKS_ALL, default=(scanned or {}).get("frameworks", None))
         data["frameworks"] = frameworks or []
 
         data["database"] = ask("Database / ORM", default=(scanned or {}).get("database", "postgres"), choices=DATABASES_ALL)
@@ -547,6 +762,8 @@ def main():
     data["test_framework"] = data.get("test_framework", (scanned or {}).get("test_framework", "auto-detect"))
     data["max_file_lines"] = data.get("max_file_lines", (scanned or {}).get("max_file_lines", "300"))
     data["code_style"] = data.get("code_style", (scanned or {}).get("code_style", "project-standard"))
+    data["framework_details"] = data.get("framework_details", (scanned or {}).get("framework_details", []))
+    data["scan_evidence"] = data.get("scan_evidence", (scanned or {}).get("scan_evidence", []))
     data["architecture_notes"] = data.get("architecture_notes", (scanned or {}).get("architecture_notes", "<!-- Add notes -->"))
     data["current_phase"] = data.get("current_phase", (scanned or {}).get("current_phase", "Initial setup"))
     data["next_phase"] = data.get("next_phase", (scanned or {}).get("next_phase", "—"))