thachvd-kit 1.0.2 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "thachvd-kit",
-    "version": "1.0.2",
+    "version": "1.0.4",
     "description": "Universal Agent Kit for Antigravity, Claude Code, and OpenCode",
     "bin": {
         "thachvd-kit": "./bin/cli.js"
@@ -22,7 +22,10 @@
         "node": ">=16.7"
     },
     "scripts": {
-        "test": "echo \"Error: no test specified\" && exit 1"
+        "test": "echo \"Error: no test specified\" && exit 1",
+        "release:patch": "npm version patch",
+        "release:dry-run": "npm pack --dry-run",
+        "release:publish": "npm publish"
     },
     "keywords": [
         "ai",

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,236 @@ 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", 1),
+        ]), "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 +437,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 +471,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 +480,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 +504,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 +552,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 +674,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 +703,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 +757,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", "—"))