@archpilotlabs/archpilot 0.0.8 → 0.0.9

package/README.md

@@ -48,7 +48,46 @@ No runtime agents. No external services. Fully deterministic and local-first.
 
 ---
 
-## Local-first. Cloud-powered.
+## 🧩 Supported Stacks
+
+ArchPilot supports **practical deterministic architecture detection** across modern application stacks.
+
+### Backend
+
+* Node.js / TypeScript
+* NestJS
+* Express.js
+* Java
+* Spring / Spring Boot
+* Kotlin
+* FastAPI
+* Django
+* Flask
+* PHP
+* Laravel
+* Go
+* .NET
+* Ruby on Rails
+
+### Frontend
+
+* React
+* Next.js
+* Angular
+* Vue
+
+### Infrastructure
+
+* Terraform
+* Ansible
+
+ArchPilot detects stack shape from practical repository evidence - framework markers, manifests, project layout, and source structure - then applies conservative architecture discovery defaults locally.
+
+**No cloud scanning. No remote indexing. Deterministic local validation.**
+
+---
+
+## ☁️ Local-first. Cloud-powered.
 
 Start locally in minutes:
 
@@ -208,7 +247,7 @@ archpilot governance upload
 
 ---
 
-## 🧩 Core Capabilities
+## ⚙️ Core Capabilities
 
 * Architecture-as-code (`.archpilot/`)
 * Dependency validation and module contracts

package/dist/archpilot-cli.js

@@ -210932,6 +210932,7 @@ var import_node_fs = require("node:fs");
 var validProjectKinds = /* @__PURE__ */ new Set(["backend", "frontend", "library"]);
 var validCanonicalStackIds = /* @__PURE__ */ new Set([
   "node_typescript",
+  "express",
   "nestjs",
   "java",
   "spring",
@@ -210940,9 +210941,11 @@ var validCanonicalStackIds = /* @__PURE__ */ new Set([
   "flask",
   "python",
   "php",
+  "laravel",
   "go",
   "dotnet",
   "ruby_rails",
+  "kotlin",
   "kotlin_spring",
   "rust",
   "react",
@@ -210956,6 +210959,7 @@ var validCanonicalStackIds = /* @__PURE__ */ new Set([
 ]);
 var canonicalStackLabels = {
   node_typescript: "TypeScript / Node.js",
+  express: "Express.js",
   nestjs: "NestJS",
   java: "Java",
   spring: "Spring",
@@ -210964,9 +210968,11 @@ var canonicalStackLabels = {
   flask: "Flask",
   python: "Python",
   php: "PHP",
+  laravel: "Laravel",
   go: "Go",
   dotnet: ".NET",
   ruby_rails: "Ruby / Rails",
+  kotlin: "Kotlin",
   kotlin_spring: "Kotlin / Spring",
   rust: "Rust",
   react: "React",
@@ -211177,6 +211183,103 @@ var nodeTypescriptAdapter = buildAdapter({
 var stackAdaptersById = {
   other: genericDefaultAdapter,
   node_typescript: nodeTypescriptAdapter,
+  express: buildAdapter({
+    id: "express",
+    displayName: canonicalStackLabels.express,
+    ecosystem: "node",
+    category: "framework",
+    priority: 70,
+    manifestDetectionHints: ["package.json", "tsconfig.json", "app.js", "app.ts", "server.js", "server.ts"],
+    buildToolHints: ["npm", "pnpm", "yarn"],
+    defaults: {
+      sourceRoots: ["src", "."],
+      moduleRootCandidates: ["src/modules", "src/features", "routes", "src/routes", "src"],
+      apiRoots: ["routes", "src/routes", "src/api", "api"],
+      databaseRoots: ["prisma", "db", "database", "migrations"],
+      configFiles: ["package.json", "tsconfig.json"],
+      fileExtensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"],
+      dependencyFileExtensions: [".ts", ".js", ".mjs", ".cjs"],
+      ignoreDirectories: ["node_modules", "dist", "coverage"],
+      entrypointHints: ["app.ts", "server.ts", "src/app.ts", "src/server.ts", "app.js", "server.js", "src/app.js", "src/server.js"],
+      publicEntrypointDirectories: ["public"],
+      moduleIndexFileName: "index.ts"
+    },
+    detect: (context) => {
+      const evidence = [];
+      let strongSignals = 0;
+      let mediumSignals = 0;
+      let score = 0;
+      const hasExpressDependency = context.hasPackageDependency("express");
+      const hasExpressFactory = context.hasAnyFileMatchingPattern(
+        /\.(ts|js|mjs|cjs)$/iu,
+        /\bexpress\s*\(\s*\)/u
+      );
+      const hasExpressImport = context.hasAnyFileMatchingPattern(
+        /\.(ts|js|mjs|cjs)$/iu,
+        /\b(import\s+express\s+from\s+['"]express['"]|require\s*\(\s*['"]express['"]\s*\))/u
+      );
+      const hasAppUse = context.hasAnyFileMatchingPattern(
+        /\.(ts|js|mjs|cjs)$/iu,
+        /\bapp\.use\s*\(/u
+      );
+      const hasRouterUsage = context.hasAnyFileMatchingPattern(
+        /\.(ts|js|mjs|cjs)$/iu,
+        /\b(router|Router)\s*\.\s*(get|post|put|patch|delete|use)\s*\(/u
+      );
+      const hasRoutesDirectory = context.hasDirectory("routes") || context.hasDirectory("src/routes");
+      const hasRouteFiles = context.hasAnyPathMatchingPattern(/(^|\/)(routes|src\/routes)\/.+\.(ts|js|mjs|cjs)$/iu);
+      if (hasExpressDependency) {
+        strongSignals += 1;
+        score += 46;
+        evidence.push("Found package.json with express dependency");
+      }
+      if (hasExpressFactory) {
+        strongSignals += 1;
+        score += 28;
+        evidence.push("Found express() app construction");
+      }
+      if (hasExpressImport) {
+        mediumSignals += 1;
+        score += 12;
+        evidence.push("Found Express import or require");
+      }
+      if (hasAppUse) {
+        mediumSignals += 1;
+        score += 10;
+        evidence.push("Found app.use(...) middleware or router mounting");
+      }
+      if (hasRouterUsage) {
+        mediumSignals += 1;
+        score += 10;
+        evidence.push("Found router HTTP method usage");
+      }
+      if (hasRoutesDirectory) {
+        mediumSignals += 1;
+        score += 6;
+        evidence.push("Found routes/ or src/routes/ directory");
+      }
+      if (hasRouteFiles) {
+        mediumSignals += 1;
+        score += 5;
+        evidence.push("Found route files under routes/");
+      }
+      const hasSafeExpressEvidence = hasExpressDependency && (hasExpressFactory || hasExpressImport || hasAppUse || hasRouterUsage || hasRoutesDirectory);
+      if (!hasSafeExpressEvidence) {
+        return null;
+      }
+      const confidence = strongSignals >= 2 || strongSignals >= 1 && mediumSignals >= 2 ? "high" : strongSignals >= 1 ? "medium" : "low";
+      return toResult({
+        adapterId: "express",
+        confidence,
+        score,
+        evidence,
+        projectKindHints: ["backend"],
+        apiStyleHint: "rest"
+      });
+    },
+    resolveProjectKinds: () => ["backend"],
+    getImportExtractionMode: () => "typescript-imports"
+  }),
   nestjs: buildAdapter({
     id: "nestjs",
     displayName: canonicalStackLabels.nestjs,
@@ -211452,9 +211555,9 @@ var stackAdaptersById = {
     ],
     buildToolHints: ["maven", "gradle"],
     defaults: {
-      sourceRoots: ["src/main/java", "src"],
-      moduleRootCandidates: ["src/main/java"],
-      apiRoots: ["src/main/java"],
+      sourceRoots: ["src/main/java", "src/main/kotlin", "src"],
+      moduleRootCandidates: ["src/main/java", "src/main/kotlin"],
+      apiRoots: ["src/main/java", "src/main/kotlin"],
       databaseRoots: ["src/main/resources", "src/main/resources/db"],
       configFiles: [
         "pom.xml",
@@ -211474,7 +211577,7 @@ var stackAdaptersById = {
         "out",
         ...commonIgnoreDirectories
       ],
-      entrypointHints: ["src/main/java"],
+      entrypointHints: ["src/main/java", "src/main/kotlin", "Application.java", "Application.kt"],
       publicEntrypointDirectories: [],
       moduleIndexFileName: "Application.java"
     },
@@ -211500,7 +211603,7 @@ var stackAdaptersById = {
         /\.(java|kt)$/iu,
         /@SpringBootApplication\b/u
       );
-      const hasMainJavaWithDependencies = context.hasDirectory("src/main/java") && hasSpringDependencyEvidence;
+      const hasMainSourceWithDependencies = (context.hasDirectory("src/main/java") || context.hasDirectory("src/main/kotlin")) && hasSpringDependencyEvidence;
       const hasApplicationConfigWithDependencies = (context.hasFile("application.yml") || context.hasFile("application.yaml") || context.hasFile("application.properties")) && hasSpringDependencyEvidence;
       const hasRestController = context.hasAnyFileMatchingPattern(
         /\.(java|kt)$/iu,
@@ -211524,9 +211627,9 @@ var stackAdaptersById = {
       );
       const hasResourcesDirectory = context.hasDirectory("src/main/resources");
       const hasWrapperWithSpringEvidence = (context.hasFile("mvnw") || context.hasFile("gradlew")) && hasSpringDependencyEvidence;
-      const hasTestJava = context.hasDirectory("src/test/java");
+      const hasTestJvmSource = context.hasDirectory("src/test/java") || context.hasDirectory("src/test/kotlin");
       const hasBootstrapConfig = context.hasFile("bootstrap.yml") || context.hasFile("bootstrap.yaml");
-      const hasJavaPackageShape = context.hasDirectory("src/main/java/com") || context.hasDirectory("src/main/java/org");
+      const hasJvmPackageShape = context.hasDirectory("src/main/java/com") || context.hasDirectory("src/main/java/org") || context.hasDirectory("src/main/kotlin/com") || context.hasDirectory("src/main/kotlin/org");
       if (hasPomSpringDependency) {
         strongSignals += 1;
         score += 54;
@@ -211542,10 +211645,10 @@ var stackAdaptersById = {
         score += 44;
         evidence.push("Found @SpringBootApplication in source");
       }
-      if (hasMainJavaWithDependencies) {
+      if (hasMainSourceWithDependencies) {
         strongSignals += 1;
         score += 20;
-        evidence.push("Found src/main/java with Spring dependency evidence");
+        evidence.push("Found JVM main source root with Spring dependency evidence");
       }
       if (hasApplicationConfigWithDependencies) {
         strongSignals += 1;
@@ -211587,22 +211690,22 @@ var stackAdaptersById = {
         score += 4;
         evidence.push("Found Maven/Gradle wrapper with Spring dependency evidence");
       }
-      if (hasTestJava) {
+      if (hasTestJvmSource) {
         weakSignals += 1;
         score += 2;
-        evidence.push("Found src/test/java directory");
+        evidence.push("Found JVM test source directory");
       }
       if (hasBootstrapConfig) {
         weakSignals += 1;
         score += 2;
         evidence.push("Found bootstrap.yml or bootstrap.yaml");
       }
-      if (hasJavaPackageShape) {
+      if (hasJvmPackageShape) {
         weakSignals += 1;
         score += 1;
-        evidence.push("Found conventional Java package directory under src/main/java");
+        evidence.push("Found conventional JVM package directory under main source root");
       }
-      const hasSafeSpringCoreEvidence = hasSpringDependencyEvidence || hasSpringBootApplication || (hasRestController || hasController || hasService || hasRepository || hasMappingAnnotation) && (context.hasDirectory("src/main/java") || hasResourcesDirectory);
+      const hasSafeSpringCoreEvidence = hasSpringDependencyEvidence || hasSpringBootApplication || (hasRestController || hasController || hasService || hasRepository || hasMappingAnnotation) && (context.hasDirectory("src/main/java") || context.hasDirectory("src/main/kotlin") || hasResourcesDirectory);
       if (!hasSafeSpringCoreEvidence || strongSignals === 0) {
         return null;
       }
@@ -212191,6 +212294,101 @@ var stackAdaptersById = {
     resolveProjectKinds: () => ["backend", "library"],
     getImportExtractionMode: () => "python-imports"
   }),
+  laravel: buildAdapter({
+    id: "laravel",
+    displayName: canonicalStackLabels.laravel,
+    ecosystem: "php",
+    category: "framework",
+    priority: 70,
+    manifestDetectionHints: ["composer.json", "artisan", "web.php", "api.php", "app.php"],
+    buildToolHints: ["composer", "artisan"],
+    defaults: {
+      sourceRoots: ["app", "routes", "config"],
+      moduleRootCandidates: ["app/Modules", "app/Services", "app/Http/Controllers", "app"],
+      apiRoots: ["routes", "app/Http/Controllers"],
+      databaseRoots: ["database", "database/migrations"],
+      configFiles: ["composer.json", "artisan", "config/app.php"],
+      fileExtensions: [".php"],
+      dependencyFileExtensions: [".php"],
+      ignoreDirectories: [
+        "vendor",
+        "storage",
+        "bootstrap/cache",
+        "public",
+        ...commonIgnoreDirectories
+      ],
+      entrypointHints: ["artisan", "public/index.php", "bootstrap/app.php"],
+      publicEntrypointDirectories: [],
+      moduleIndexFileName: "index.php"
+    },
+    detect: (context) => {
+      const evidence = [];
+      let strongSignals = 0;
+      let mediumSignals = 0;
+      let score = 0;
+      const hasLaravelComposer = context.hasFileMatchingPattern(
+        "composer.json",
+        /["']laravel\/framework["']/iu
+      );
+      const hasArtisan = context.hasFile("artisan");
+      const hasRoutesWeb = context.hasAnyPathMatchingPattern(/(^|\/)routes\/web\.php$/iu);
+      const hasRoutesApi = context.hasAnyPathMatchingPattern(/(^|\/)routes\/api\.php$/iu);
+      const hasControllers = context.hasDirectory("app/Http/Controllers");
+      const hasConfigApp = context.hasAnyPathMatchingPattern(/(^|\/)config\/app\.php$/iu);
+      const hasLaravelRouteFacade = context.hasAnyFileMatchingPattern(
+        /(^|\/)routes\/.+\.php$/iu,
+        /\bRoute::(get|post|put|patch|delete|middleware|group)\s*\(/u
+      );
+      if (hasLaravelComposer) {
+        strongSignals += 1;
+        score += 50;
+        evidence.push("Found composer.json with laravel/framework dependency");
+      }
+      if (hasArtisan) {
+        strongSignals += 1;
+        score += 18;
+        evidence.push("Found artisan entrypoint");
+      }
+      if (hasRoutesWeb) {
+        mediumSignals += 1;
+        score += 10;
+        evidence.push("Found routes/web.php");
+      }
+      if (hasRoutesApi) {
+        mediumSignals += 1;
+        score += 10;
+        evidence.push("Found routes/api.php");
+      }
+      if (hasControllers) {
+        mediumSignals += 1;
+        score += 10;
+        evidence.push("Found app/Http/Controllers directory");
+      }
+      if (hasConfigApp) {
+        mediumSignals += 1;
+        score += 6;
+        evidence.push("Found config/app.php");
+      }
+      if (hasLaravelRouteFacade) {
+        mediumSignals += 1;
+        score += 8;
+        evidence.push("Found Laravel Route facade usage");
+      }
+      if (!hasLaravelComposer || !(hasArtisan || hasRoutesWeb || hasRoutesApi || hasControllers)) {
+        return null;
+      }
+      return toResult({
+        adapterId: "laravel",
+        confidence: strongSignals >= 2 || mediumSignals >= 2 ? "high" : "medium",
+        score,
+        evidence,
+        projectKindHints: ["backend"],
+        apiStyleHint: hasRoutesApi || hasLaravelRouteFacade ? "rest" : "unknown"
+      });
+    },
+    resolveProjectKinds: () => ["backend"],
+    getImportExtractionMode: () => "php-imports"
+  }),
   php: buildAdapter({
     id: "php",
     displayName: canonicalStackLabels.php,
@@ -212478,23 +212676,182 @@ var stackAdaptersById = {
     displayName: canonicalStackLabels.ruby_rails,
     ecosystem: "other",
     category: "framework",
-    priority: 20,
-    manifestDetectionHints: ["Gemfile"],
+    priority: 70,
+    manifestDetectionHints: ["Gemfile", "rails", "routes.rb", "application.rb"],
     buildToolHints: ["bundle"],
     defaults: {
-      sourceRoots: ["app"],
-      moduleRootCandidates: ["app"],
-      apiRoots: ["app/controllers"],
+      sourceRoots: ["app", "config"],
+      moduleRootCandidates: ["app/services", "app/controllers", "app/models", "app"],
+      apiRoots: ["app/controllers", "config/routes.rb"],
       databaseRoots: ["db"],
-      configFiles: ["Gemfile"],
+      configFiles: ["Gemfile", "config/routes.rb", "config/application.rb"],
       fileExtensions: [".rb"],
       dependencyFileExtensions: [".rb"],
-      ignoreDirectories: [...commonIgnoreDirectories],
+      ignoreDirectories: ["vendor", "tmp", "log", ...commonIgnoreDirectories],
       entrypointHints: ["config/application.rb"],
       publicEntrypointDirectories: [],
       moduleIndexFileName: "application.rb"
     },
-    detect: () => null,
+    detect: (context) => {
+      const evidence = [];
+      let strongSignals = 0;
+      let mediumSignals = 0;
+      let score = 0;
+      const hasRailsGem = context.hasFileMatchingPattern("Gemfile", /\bgem\s+['"]rails['"]/u);
+      const hasBinRails = context.hasAnyPathMatchingPattern(/(^|\/)bin\/rails$/u);
+      const hasRoutes = context.hasAnyPathMatchingPattern(/(^|\/)config\/routes\.rb$/u);
+      const hasControllers = context.hasDirectory("app/controllers");
+      const hasModels = context.hasDirectory("app/models");
+      const hasServices = context.hasDirectory("app/services");
+      const hasRailsRoutesDraw = context.hasFileMatchingPattern("routes.rb", /\bRails\.application\.routes\.draw\b/u);
+      const hasApplicationClass = context.hasAnyFileMatchingPattern(
+        /(^|\/)config\/application\.rb$/u,
+        /\bclass\s+Application\s+<\s+Rails::Application\b/u
+      );
+      const hasApplicationController = context.hasAnyFileMatchingPattern(
+        /(^|\/)app\/controllers\/.+\.rb$/u,
+        /\bApplicationController\b/u
+      );
+      if (hasRailsGem) {
+        strongSignals += 1;
+        score += 48;
+        evidence.push("Found Gemfile with rails gem");
+      }
+      if (hasBinRails) {
+        strongSignals += 1;
+        score += 18;
+        evidence.push("Found bin/rails");
+      }
+      if (hasRoutes) {
+        mediumSignals += 1;
+        score += 10;
+        evidence.push("Found config/routes.rb");
+      }
+      if (hasControllers) {
+        mediumSignals += 1;
+        score += 8;
+        evidence.push("Found app/controllers directory");
+      }
+      if (hasModels) {
+        mediumSignals += 1;
+        score += 6;
+        evidence.push("Found app/models directory");
+      }
+      if (hasServices) {
+        mediumSignals += 1;
+        score += 5;
+        evidence.push("Found app/services directory");
+      }
+      if (hasRailsRoutesDraw) {
+        mediumSignals += 1;
+        score += 8;
+        evidence.push("Found Rails routes draw block");
+      }
+      if (hasApplicationClass) {
+        mediumSignals += 1;
+        score += 8;
+        evidence.push("Found Rails application class");
+      }
+      if (hasApplicationController) {
+        mediumSignals += 1;
+        score += 5;
+        evidence.push("Found ApplicationController inheritance");
+      }
+      if (!hasRailsGem || !(hasBinRails || hasRoutes || hasControllers || hasApplicationClass)) {
+        return null;
+      }
+      return toResult({
+        adapterId: "ruby_rails",
+        confidence: strongSignals >= 2 || mediumSignals >= 3 ? "high" : "medium",
+        score,
+        evidence,
+        projectKindHints: ["backend"],
+        apiStyleHint: hasRoutes || hasControllers ? "rest" : "unknown"
+      });
+    },
+    resolveProjectKinds: () => ["backend"],
+    getImportExtractionMode: () => "generic"
+  }),
+  kotlin: buildAdapter({
+    id: "kotlin",
+    displayName: canonicalStackLabels.kotlin,
+    ecosystem: "jvm",
+    category: "generic-language",
+    priority: 40,
+    manifestDetectionHints: ["build.gradle.kts", "pom.xml", "settings.gradle.kts"],
+    buildToolHints: ["gradle", "maven"],
+    defaults: {
+      sourceRoots: ["src/main/kotlin", "src"],
+      moduleRootCandidates: ["src/main/kotlin", "src"],
+      apiRoots: ["src/main/kotlin"],
+      databaseRoots: ["src/main/resources/db", "src/main/resources/migrations"],
+      configFiles: ["build.gradle.kts", "pom.xml", "settings.gradle.kts"],
+      fileExtensions: [".kt", ".kts"],
+      dependencyFileExtensions: [".kt", ".kts"],
+      ignoreDirectories: [
+        "target",
+        "build",
+        ".gradle",
+        ".idea",
+        "out",
+        ...commonIgnoreDirectories
+      ],
+      entrypointHints: ["Application.kt", "Main.kt"],
+      publicEntrypointDirectories: [],
+      moduleIndexFileName: "Application.kt"
+    },
+    detect: (context) => {
+      const evidence = [];
+      let score = 0;
+      const hasBuildGradleKts = context.hasFile("build.gradle.kts");
+      const hasSettingsGradleKts = context.hasFile("settings.gradle.kts");
+      const hasKotlinPluginInGradle = context.hasFileMatchingPattern("build.gradle.kts", /\bkotlin\s*\(\s*["']jvm["']\s*\)/u) || context.hasFileMatchingPattern("build.gradle.kts", /\bid\s*\(\s*["']org\.jetbrains\.kotlin\.jvm["']\s*\)/u);
+      const hasPomKotlinPlugin = context.hasFileMatchingPattern("pom.xml", /\bkotlin-maven-plugin\b/u) || context.hasFileMatchingPattern("pom.xml", /\borg\.jetbrains\.kotlin\b/u);
+      const hasKotlinSourceRoot = context.hasDirectory("src/main/kotlin");
+      const hasKtFiles = context.hasFileExtension(".kt") || context.hasFileExtension(".kts");
+      const hasKotlinPackageShape = context.hasDirectory("src/main/kotlin/com") || context.hasDirectory("src/main/kotlin/org");
+      if (hasBuildGradleKts) {
+        score += 30;
+        evidence.push("Found build.gradle.kts");
+      }
+      if (hasSettingsGradleKts) {
+        score += 8;
+        evidence.push("Found settings.gradle.kts");
+      }
+      if (hasKotlinPluginInGradle) {
+        score += 32;
+        evidence.push("Found Kotlin JVM plugin in build.gradle.kts");
+      }
+      if (hasPomKotlinPlugin) {
+        score += 32;
+        evidence.push("Found Kotlin Maven plugin markers in pom.xml");
+      }
+      if (hasKotlinSourceRoot) {
+        score += 18;
+        evidence.push("Found src/main/kotlin source root");
+      }
+      if (hasKtFiles) {
+        score += 16;
+        evidence.push("Found Kotlin source files");
+      }
+      if (hasKotlinPackageShape) {
+        score += 4;
+        evidence.push("Found conventional Kotlin package directory under src/main/kotlin");
+      }
+      const hasSafeKotlinEvidence = hasKtFiles && (hasBuildGradleKts || hasKotlinPluginInGradle || hasPomKotlinPlugin || hasKotlinSourceRoot);
+      if (!hasSafeKotlinEvidence) {
+        return null;
+      }
+      return toResult({
+        adapterId: "kotlin",
+        confidence: (hasKotlinPluginInGradle || hasPomKotlinPlugin) && hasKotlinSourceRoot ? "high" : hasBuildGradleKts || hasKotlinSourceRoot ? "medium" : "low",
+        score,
+        evidence,
+        projectKindHints: ["backend", "library"],
+        apiStyleHint: "unknown"
+      });
+    },
+    resolveProjectKinds: () => ["backend", "library"],
     getImportExtractionMode: () => "generic"
   }),
   kotlin_spring: buildAdapter({
@@ -212750,7 +213107,7 @@ var stackAdaptersById = {
       let score = 0;
       if (hasVueDependency) {
         strongSignals += 1;
-        score += 28;
+        score += 30;
         evidence.push("Found package.json with vue dependency");
       }
       if (hasAppVue) {
@@ -212765,12 +213122,12 @@ var stackAdaptersById = {
       }
       if (hasVitePluginInConfig) {
         strongSignals += 1;
-        score += 20;
+        score += 24;
         evidence.push("Found Vue plugin usage in vite.config.ts or vite.config.js");
       }
       if (hasVitePluginDependency) {
         strongSignals += 1;
-        score += 18;
+        score += 22;
         evidence.push("Found package.json with @vitejs/plugin-vue dependency");
       }
       if (hasSrcViews) {
@@ -212785,12 +213142,12 @@ var stackAdaptersById = {
       }
       if (hasCreateAppReference) {
         mediumSignals += 1;
-        score += 10;
+        score += 12;
         evidence.push("Found createApp usage in src/main.ts or src/main.js");
       }
       if (hasViteConfig && hasVueDependency) {
         mediumSignals += 1;
-        score += 6;
+        score += 8;
         evidence.push("Found vite.config.ts or vite.config.js with Vue package evidence");
       }
       if (hasTsConfigApp) {
@@ -231635,6 +231992,7 @@ var ignoredDirectoryNames2 = /* @__PURE__ */ new Set([
 ]);
 var backendStackIds = /* @__PURE__ */ new Set([
   "spring",
+  "express",
   "fastapi",
   "django",
   "flask",
@@ -231643,7 +232001,11 @@ var backendStackIds = /* @__PURE__ */ new Set([
   "java",
   "python",
   "php",
+  "laravel",
   "go",
+  "ruby_rails",
+  "kotlin",
+  "kotlin_spring",
   "node_typescript",
   "node_javascript"
 ]);
@@ -231861,6 +232223,7 @@ function buildDetectionContext(workspaceRoot, filePaths, pathsByFileName, extens
 function toDetectedStack(adapterId) {
   switch (adapterId) {
     case "node_typescript":
+    case "express":
     case "nestjs":
     case "java":
     case "spring":
@@ -231870,7 +232233,11 @@ function toDetectedStack(adapterId) {
     case "dotnet":
     case "python":
     case "php":
+    case "laravel":
     case "go":
+    case "ruby_rails":
+    case "kotlin":
+    case "kotlin_spring":
     case "react":
     case "nextjs":
     case "angular":
@@ -231891,6 +232258,9 @@ function resolveLanguages(stacks) {
   if (stacks.includes("spring")) {
     languages.add("java");
   }
+  if (stacks.includes("kotlin") || stacks.includes("kotlin_spring")) {
+    languages.add("kotlin");
+  }
   if (stacks.includes("dotnet")) {
     languages.add("csharp");
   }
@@ -231909,6 +232279,12 @@ function resolveLanguages(stacks) {
   if (stacks.includes("php")) {
     languages.add("php");
   }
+  if (stacks.includes("laravel")) {
+    languages.add("php");
+  }
+  if (stacks.includes("ruby_rails")) {
+    languages.add("ruby");
+  }
   if (stacks.includes("go")) {
     languages.add("go");
   }
@@ -231922,6 +232298,12 @@ function resolveLanguages(stacks) {
     languages.add("typescript");
     languages.add("javascript");
   }
+  if (stacks.includes("express")) {
+    languages.add("javascript");
+    if (stacks.includes("node_typescript")) {
+      languages.add("typescript");
+    }
+  }
   if (stacks.includes("react") || stacks.includes("nextjs") || stacks.includes("angular") || stacks.includes("vue")) {
     languages.add(stacks.includes("node_typescript") ? "typescript" : "javascript");
   }
@@ -232399,6 +232781,7 @@ var sourceFileExtensions = /* @__PURE__ */ new Set([
   ".tsx",
   ".js",
   ".jsx",
+  ".vue",
   ".java",
   ".py",
   ".php",
@@ -232433,7 +232816,9 @@ var roleFileHints = [
   "layout.tsx",
   "layout.jsx",
   "route.ts",
-  "route.js"
+  "route.js",
+  "view.vue",
+  "page.vue"
 ];
 function normalizePath13(value) {
   return value.replaceAll("\\", "/");
@@ -232663,6 +233048,12 @@ function collectExplicitRoots(workspaceRoot) {
     "backend/src/features",
     "frontend/src/modules",
     "frontend/src/features",
+    "frontend/src/views",
+    "src/views",
+    "routes",
+    "src/routes",
+    "app/Modules",
+    "app/services",
     "services",
     "packages",
     "libs"
@@ -232689,6 +233080,47 @@ function collectExplicitRoots(workspaceRoot) {
   }
   return uniqueSorted(roots);
 }
+function collectJavaPackageRoots(workspaceRoot) {
+  const roots = [];
+  for (const sourceRoot of ["src/main/java", "src/main/kotlin", "src"]) {
+    const absoluteSourceRoot = path53.join(workspaceRoot, ...sourceRoot.split("/"));
+    if (!pathExists15(absoluteSourceRoot)) {
+      continue;
+    }
+    const queue = [
+      { absolutePath: absoluteSourceRoot, relativePath: sourceRoot, depth: 0 }
+    ];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (!current) {
+        continue;
+      }
+      if (current.depth > 6) {
+        continue;
+      }
+      for (const entry of safeReadDirEntries(current.absolutePath)) {
+        if (!entry.isDirectory() || ignoredDirectoryNames4.has(entry.name)) {
+          continue;
+        }
+        const childRelativePath = normalizePath13(`${current.relativePath}/${entry.name}`);
+        const lowerName = entry.name.toLowerCase();
+        if (lowerName === "modules" || lowerName === "features") {
+          const childCount = safeReadDirEntries(path53.join(current.absolutePath, entry.name)).filter((child) => child.isDirectory() && !ignoredDirectoryNames4.has(child.name)).length;
+          if (childCount >= 2) {
+            roots.push(childRelativePath);
+          }
+          continue;
+        }
+        queue.push({
+          absolutePath: path53.join(current.absolutePath, entry.name),
+          relativePath: childRelativePath,
+          depth: current.depth + 1
+        });
+      }
+    }
+  }
+  return roots;
+}
 function collectFallbackSrcModules(workspaceRoot, context) {
   const srcRoot = path53.join(workspaceRoot, "src");
   const srcEntries = safeReadDirEntries(srcRoot).filter((entry) => entry.isDirectory() && !ignoredDirectoryNames4.has(entry.name)).sort((left, right) => left.name.localeCompare(right.name));
@@ -232726,6 +233158,14 @@ function detectModules(workspaceRoot, options) {
     projectKinds: options?.projectKinds,
     stacks: options?.stacks
   };
+  if (options?.stacks?.some((stack) => stack === "java" || stack === "spring" || stack === "kotlin" || stack === "kotlin_spring")) {
+    for (const root of collectJavaPackageRoots(workspaceRoot)) {
+      if (!explicitRoots.includes(root)) {
+        explicitRoots.push(root);
+      }
+    }
+    explicitRoots.sort((left, right) => left.localeCompare(right));
+  }
   for (const root of explicitRoots) {
     if (root.endsWith("/src/modules") || root === "src/modules" || root === "backend/src/modules") {
       evidence.push(`Found ${root} directory`);
@@ -233732,6 +234172,8 @@ function resolveImplementationProfile(input2) {
       return "frontend-vue";
     case "nestjs":
       return input2.apiStyleHint === "rest" ? "backend-nestjs-rest" : "backend-nestjs";
+    case "express":
+      return input2.apiStyleHint === "rest" ? "backend-express-rest" : "backend-express";
     case "spring":
       return input2.apiStyleHint === "rest" ? "backend-spring-rest" : "backend-spring";
     case "fastapi":
@@ -233748,6 +234190,14 @@ function resolveImplementationProfile(input2) {
       return "backend-python";
     case "php":
       return "backend-php";
+    case "laravel":
+      return input2.apiStyleHint === "rest" ? "backend-laravel-rest" : "backend-laravel";
+    case "ruby_rails":
+      return input2.apiStyleHint === "rest" ? "backend-rails-rest" : "backend-rails";
+    case "kotlin":
+      return "backend-kotlin";
+    case "kotlin_spring":
+      return input2.apiStyleHint === "rest" ? "backend-kotlin-spring-rest" : "backend-kotlin-spring";
     case "go":
       return "backend-go";
     case "node_typescript":
@@ -233910,7 +234360,7 @@ function resolveStackSelections(detection, projectKinds) {
   }
   if (projectKinds.includes("library")) {
     const selectedLibrary = detection.stacks.selectedAdapterId;
-    if (selectedLibrary === "terraform" || selectedLibrary === "ansible" || selectedLibrary === "node_typescript" || selectedLibrary === "python" || selectedLibrary === "go") {
+    if (selectedLibrary === "terraform" || selectedLibrary === "ansible" || selectedLibrary === "node_typescript" || selectedLibrary === "python" || selectedLibrary === "go" || selectedLibrary === "kotlin") {
       selections.library = selectedLibrary;
     }
   }

package/package.json

@@ -1,34 +1,34 @@
-{
-  "name": "@archpilotlabs/archpilot",
-  "version": "0.0.8",
-  "description": "Executable architecture governance CLI",
-  "homepage": "https://archpilot.org",
-  "bugs": {
-    "url": "https://archpilot.org/contact"
-  },
-  "license": "SEE LICENSE IN LICENSE",
-  "bin": {
-    "archpilot": "./dist/archpilot-cli.js"
-  },
-  "main": "./dist/archpilot-cli.js",
-  "files": [
-    "dist"
-  ],
-  "keywords": [
-    "architecture",
-    "architecture-validation",
-    "governance",
-    "cli",
-    "dependency-validation",
-    "adr",
-    "ci",
-    "developer-tools"
-  ],
-  "scripts": {
-    "build": "npm run compile",
-    "compile": "npm run check-types && npm run lint && node esbuild.js",
-    "watch": "node esbuild.js --watch",
-    "check-types": "tsc --noEmit -p tsconfig.json",
-    "lint": "eslint src"
-  }
-}
+{
+  "name": "@archpilotlabs/archpilot",
+  "version": "0.0.9",
+  "description": "Executable architecture governance CLI",
+  "homepage": "https://archpilot.org",
+  "bugs": {
+    "url": "https://archpilot.org/contact"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "bin": {
+    "archpilot": "./dist/archpilot-cli.js"
+  },
+  "main": "./dist/archpilot-cli.js",
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "architecture",
+    "architecture-validation",
+    "governance",
+    "cli",
+    "dependency-validation",
+    "adr",
+    "ci",
+    "developer-tools"
+  ],
+  "scripts": {
+    "build": "npm run compile",
+    "compile": "npm run check-types && npm run lint && node esbuild.js",
+    "watch": "node esbuild.js --watch",
+    "check-types": "tsc --noEmit -p tsconfig.json",
+    "lint": "eslint src"
+  }
+}