thachvd-kit 1.0.2 → 1.0.4

package/bin/cli.js

@@ -4,24 +4,26 @@ const fs = require('fs');
 const path = require('path');
 const prompts = require('prompts');
 const pc = require('picocolors');
+const packageJson = require('../package.json');
 
 const sourceDir = path.resolve(__dirname, '..');
 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"],
@@ -29,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"],
 };
@@ -79,21 +92,27 @@ 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(`
 ${pc.bold('Usage:')}
   thachvd-kit init [--scan] [--yes]
+  thachvd-kit --version
   thachvd-kit --help
 
 ${pc.bold('Commands:')}
@@ -102,10 +121,20 @@ ${pc.bold('Commands:')}
 ${pc.bold('Options:')}
   --scan    Scan the current project to prefill PROJECT_CONTEXT.md
   --yes     Use detected/default values without prompting
+  --version Show the installed CLI version
   --help    Show this help message
 `);
 }
 
+async function askQuestions(questions) {
+    return prompts(questions, {
+        onCancel: () => {
+            console.log(pc.yellow('\nCancelled.'));
+            process.exit(130);
+        }
+    });
+}
+
 function fileExists(...parts) {
     return fs.existsSync(path.join(targetDir, ...parts));
 }
@@ -148,74 +177,448 @@ 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', 1)
+        ])
+    },
+    {
+        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');
@@ -237,12 +640,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'),
@@ -265,7 +675,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 => {
@@ -276,14 +686,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 => {
@@ -306,12 +716,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]}
@@ -335,11 +758,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 |
 |-----------|-------|----------------|
@@ -423,6 +848,11 @@ async function main() {
     const command = rawArgs[0] && !rawArgs[0].startsWith('-') ? rawArgs[0] : 'init';
     const args = command === 'init' ? rawArgs.slice(rawArgs[0] === 'init' ? 1 : 0) : rawArgs.slice(1);
 
+    if (rawArgs.includes('--version') || rawArgs.includes('-v')) {
+        console.log(packageJson.version);
+        return;
+    }
+
     if (rawArgs.includes('--help') || rawArgs.includes('-h')) {
         printHelp();
         return;
@@ -444,7 +874,7 @@ async function main() {
 
     let projectSetup = 'new';
     if (!useScan && !assumeYes) {
-        const modeAnswer = await prompts([
+        const modeAnswer = await askQuestions([
             {
                 type: 'select',
                 name: 'project_setup',
@@ -476,10 +906,10 @@ async function main() {
     }
 
     if (fs.existsSync(path.join(targetDir, 'PROJECT_CONTEXT.md')) && !assumeYes) {
-        const res = await prompts({
+        const res = await askQuestions({
             type: 'confirm',
             name: 'overwrite',
-            message: 'PROJECT_CONTEXT.md already exists in this folder. Overwrite?',
+            message: 'PROJECT_CONTEXT.md already exists in this folder. Overwrite?',
             initial: false
         });
         if (!res.overwrite) {
@@ -493,9 +923,14 @@ 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 prompts([
+    const { project_name, description, project_type } = await askQuestions([
         { type: assumeYes ? null : 'text', name: 'project_name', message: 'Project name:', initial: scanned?.project_name || path.basename(targetDir) },
         { type: assumeYes ? null : 'text', name: 'description', message: 'Short description:', initial: scanned?.description || 'A software project' },
         {
@@ -505,7 +940,7 @@ async function main() {
         }
     ]);
 
-    const { primary_language } = await prompts({
+    const { primary_language } = await askQuestions({
         type: assumeYes ? null : 'select',
         name: 'primary_language',
         message: 'Primary language:',
@@ -513,7 +948,7 @@ async function main() {
         initial: Math.max(LANGUAGE_CHOICES.indexOf(scanned?.primary_language || 'typescript'), 0)
     });
 
-    const { frameworks } = await prompts({
+    const { frameworks } = await askQuestions({
         type: assumeYes ? null : 'multiselect',
         name: 'frameworks',
         message: 'Frameworks (Space to select, Enter to confirm):',
@@ -521,7 +956,7 @@ async function main() {
         min: 0
     });
 
-    const dbAndInfra = await prompts([
+    const dbAndInfra = await askQuestions([
         {
             type: assumeYes ? null : 'select', name: 'database', message: 'Database / ORM:',
             choices: DATABASE_CHOICES.map(d => ({ title: d, value: d })),
@@ -535,7 +970,7 @@ async function main() {
         }
     ]);
 
-    const { package_manager, test_framework, max_file_lines } = await prompts([
+    const { package_manager, test_framework, max_file_lines } = await askQuestions([
         {
             type: assumeYes ? null : 'select', name: 'package_manager', message: 'Package Manager:',
             choices: PACKAGE_MANAGER_CHOICES.map(p => ({ title: p, value: p })),
@@ -561,6 +996,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);