@vibgrate/cli 1.0.13 → 1.0.15

package/DOCS.md

@@ -1,6 +1,6 @@
 # Vibgrate CLI — Full Documentation
 
-> Continuous Upgrade Drift Intelligence for Node & .NET
+> Continuous Drift Intelligence for Node & .NET
 
 For a quick overview, see the [README](./README.md). This document covers everything in detail.
 

package/dist/{baseline-OPUTCJOQ.js → baseline-M445KUZ4.js}

@@ -1,8 +1,8 @@
 import {
   baselineCommand,
   runBaseline
-} from "./chunk-QHBZIYWP.js";
-import "./chunk-S4C6KWCP.js";
+} from "./chunk-OPEOSIRY.js";
+import "./chunk-QZV77UWV.js";
 export {
   baselineCommand,
   runBaseline

package/dist/{chunk-QHBZIYWP.js → chunk-OPEOSIRY.js}

@@ -1,7 +1,7 @@
 import {
   runScan,
   writeJsonFile
-} from "./chunk-S4C6KWCP.js";
+} from "./chunk-QZV77UWV.js";
 
 // src/commands/baseline.ts
 import * as path from "path";

package/dist/{chunk-S4C6KWCP.js → chunk-QZV77UWV.js}

@@ -1,6 +1,38 @@
 // src/utils/fs.ts
 import * as fs from "fs/promises";
+import * as os from "os";
 import * as path from "path";
+
+// src/utils/semaphore.ts
+var Semaphore = class {
+  available;
+  queue = [];
+  constructor(max) {
+    this.available = max;
+  }
+  async run(fn) {
+    await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      this.release();
+    }
+  }
+  acquire() {
+    if (this.available > 0) {
+      this.available--;
+      return Promise.resolve();
+    }
+    return new Promise((resolve6) => this.queue.push(resolve6));
+  }
+  release() {
+    const next = this.queue.shift();
+    if (next) next();
+    else this.available++;
+  }
+};
+
+// src/utils/fs.ts
 var SKIP_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -20,28 +52,27 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([
 ]);
 async function findFiles(rootDir, predicate) {
   const results = [];
+  const maxConcurrentReads = Math.max(8, Math.min(64, os.availableParallelism() * 4));
+  const readDirSemaphore = new Semaphore(maxConcurrentReads);
   async function walk(dir) {
     let entries;
     try {
-      const dirents = await fs.readdir(dir, { withFileTypes: true });
-      entries = dirents.map((d) => ({
-        name: d.name,
-        isDirectory: d.isDirectory(),
-        isFile: d.isFile()
-      }));
+      entries = await fs.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
+    const subDirectoryWalks = [];
     for (const e of entries) {
-      if (e.isDirectory) {
+      if (e.isDirectory()) {
         if (SKIP_DIRS.has(e.name)) continue;
-        await walk(path.join(dir, e.name));
-      } else if (e.isFile && predicate(e.name)) {
+        subDirectoryWalks.push(readDirSemaphore.run(() => walk(path.join(dir, e.name))));
+      } else if (e.isFile() && predicate(e.name)) {
         results.push(path.join(dir, e.name));
       }
     }
+    await Promise.all(subDirectoryWalks);
   }
-  await walk(rootDir);
+  await readDirSemaphore.run(() => walk(rootDir));
   return results;
 }
 async function findPackageJsonFiles(rootDir) {
@@ -156,12 +187,12 @@ function eolScore(projects) {
 }
 function computeDriftScore(projects) {
   const rs = runtimeScore(projects);
-  const fs5 = frameworkScore(projects);
+  const fs6 = frameworkScore(projects);
   const ds = dependencyScore(projects);
   const es = eolScore(projects);
   const components = [
     { score: rs, weight: 0.25 },
-    { score: fs5, weight: 0.25 },
+    { score: fs6, weight: 0.25 },
     { score: ds, weight: 0.3 },
     { score: es, weight: 0.2 }
   ];
@@ -172,7 +203,7 @@ function computeDriftScore(projects) {
       riskLevel: "low",
       components: {
         runtimeScore: Math.round(rs ?? 100),
-        frameworkScore: Math.round(fs5 ?? 100),
+        frameworkScore: Math.round(fs6 ?? 100),
         dependencyScore: Math.round(ds ?? 100),
         eolScore: Math.round(es ?? 100)
       }
@@ -190,7 +221,7 @@ function computeDriftScore(projects) {
   else riskLevel = "high";
   const measured = [];
   if (rs !== null) measured.push("runtime");
-  if (fs5 !== null) measured.push("framework");
+  if (fs6 !== null) measured.push("framework");
   if (ds !== null) measured.push("dependency");
   if (es !== null) measured.push("eol");
   return {
@@ -198,7 +229,7 @@ function computeDriftScore(projects) {
     riskLevel,
     components: {
       runtimeScore: Math.round(rs ?? 100),
-      frameworkScore: Math.round(fs5 ?? 100),
+      frameworkScore: Math.round(fs6 ?? 100),
       dependencyScore: Math.round(ds ?? 100),
       eolScore: Math.round(es ?? 100)
     },
@@ -554,6 +585,122 @@ function formatExtended(ext) {
       lines.push("");
     }
   }
+  if (ext.architecture) {
+    lines.push(...formatArchitectureDiagram(ext.architecture));
+  }
+  return lines;
+}
+var LAYER_LABELS = {
+  "presentation": "Presentation",
+  "routing": "Routing",
+  "middleware": "Middleware",
+  "services": "Services",
+  "domain": "Domain",
+  "data-access": "Data Access",
+  "infrastructure": "Infrastructure",
+  "config": "Config",
+  "shared": "Shared",
+  "testing": "Testing"
+};
+var LAYER_ICONS = {
+  "presentation": "\u{1F5A5}",
+  "routing": "\u{1F500}",
+  "middleware": "\u{1F517}",
+  "services": "\u2699",
+  "domain": "\u{1F48E}",
+  "data-access": "\u{1F5C4}",
+  "infrastructure": "\u{1F3D7}",
+  "config": "\u2699",
+  "shared": "\u{1F4E6}",
+  "testing": "\u{1F9EA}"
+};
+function formatArchitectureDiagram(arch) {
+  const lines = [];
+  lines.push(chalk.bold.cyan("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"));
+  lines.push(chalk.bold.cyan("\u2551        Architecture Layers               \u2551"));
+  lines.push(chalk.bold.cyan("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"));
+  lines.push("");
+  const archetypeDisplay = arch.archetype === "unknown" ? "Unknown" : arch.archetype;
+  const confPct = Math.round(arch.archetypeConfidence * 100);
+  lines.push(chalk.bold("  Archetype: ") + chalk.cyan.bold(archetypeDisplay) + chalk.dim(` (${confPct}% confidence)`));
+  lines.push(chalk.dim(`  ${arch.totalClassified} files classified \xB7 ${arch.unclassified} unclassified`));
+  lines.push("");
+  const boxWidth = 44;
+  const visibleLayers = arch.layers.filter((l) => l.fileCount > 0 || l.techStack.length > 0 || l.services.length > 0);
+  if (visibleLayers.length === 0) {
+    lines.push(chalk.dim("  No layers detected"));
+    lines.push("");
+    return lines;
+  }
+  for (let i = 0; i < visibleLayers.length; i++) {
+    const layer = visibleLayers[i];
+    const icon = LAYER_ICONS[layer.layer] ?? "\xB7";
+    const label = LAYER_LABELS[layer.layer] ?? layer.layer;
+    const scoreColor = layer.driftScore >= 70 ? chalk.green : layer.driftScore >= 40 ? chalk.yellow : chalk.red;
+    const riskBadgeStr = layer.riskLevel === "low" ? chalk.bgGreen.black(" LOW ") : layer.riskLevel === "moderate" ? chalk.bgYellow.black(" MOD ") : chalk.bgRed.white(" HIGH ");
+    if (i === 0) {
+      lines.push(chalk.cyan(`  \u250C${"\u2500".repeat(boxWidth)}\u2510`));
+    }
+    const nameStr = `${icon}  ${label}`;
+    const scoreStr = `${layer.driftScore}/100`;
+    const fileSuffix = `${layer.fileCount} file${layer.fileCount !== 1 ? "s" : ""}`;
+    const leftContent = `  ${nameStr}`;
+    const rightContent = `${fileSuffix}  ${scoreStr}  `;
+    const leftLen = nameStr.length + 2;
+    const rightLen = rightContent.length;
+    const padLen = Math.max(1, boxWidth - leftLen - rightLen);
+    lines.push(
+      chalk.cyan("  \u2502") + `  ${icon}  ${chalk.bold(label)}` + " ".repeat(padLen) + chalk.dim(fileSuffix) + "  " + scoreColor.bold(scoreStr) + "  " + chalk.cyan("\u2502")
+    );
+    const barWidth = boxWidth - 8;
+    const filled = Math.round(layer.driftScore / 100 * barWidth);
+    const empty = barWidth - filled;
+    lines.push(
+      chalk.cyan("  \u2502") + "    " + scoreColor("\u2588".repeat(filled)) + chalk.dim("\u2591".repeat(empty)) + "    " + chalk.cyan("\u2502")
+    );
+    if (layer.techStack.length > 0) {
+      const techNames = layer.techStack.slice(0, 6).map((t) => t.name);
+      const moreCount = layer.techStack.length > 6 ? ` +${layer.techStack.length - 6}` : "";
+      const techLine = `Tech: ${techNames.join(", ")}${moreCount}`;
+      const truncated = techLine.length > boxWidth - 6 ? techLine.slice(0, boxWidth - 9) + "..." : techLine;
+      const techPad = Math.max(0, boxWidth - truncated.length - 4);
+      lines.push(
+        chalk.cyan("  \u2502") + "    " + chalk.dim(truncated) + " ".repeat(techPad) + chalk.cyan("\u2502")
+      );
+    }
+    if (layer.services.length > 0) {
+      const svcNames = layer.services.slice(0, 5).map((s) => s.name);
+      const moreCount = layer.services.length > 5 ? ` +${layer.services.length - 5}` : "";
+      const svcLine = `Services: ${svcNames.join(", ")}${moreCount}`;
+      const truncated = svcLine.length > boxWidth - 6 ? svcLine.slice(0, boxWidth - 9) + "..." : svcLine;
+      const svcPad = Math.max(0, boxWidth - truncated.length - 4);
+      lines.push(
+        chalk.cyan("  \u2502") + "    " + chalk.dim(truncated) + " ".repeat(svcPad) + chalk.cyan("\u2502")
+      );
+    }
+    const driftPkgs = layer.packages.filter((p) => p.majorsBehind !== null && p.majorsBehind > 0);
+    if (driftPkgs.length > 0) {
+      const worst = driftPkgs.sort((a, b) => (b.majorsBehind ?? 0) - (a.majorsBehind ?? 0));
+      const shown = worst.slice(0, 3);
+      const pkgStrs = shown.map((p) => {
+        const color = (p.majorsBehind ?? 0) >= 2 ? chalk.red : chalk.yellow;
+        return color(`${p.name} -${p.majorsBehind}`);
+      });
+      const moreCount = worst.length > 3 ? chalk.dim(` +${worst.length - 3}`) : "";
+      const pkgLine = pkgStrs.join(chalk.dim(", ")) + moreCount;
+      const roughLen = shown.map((p) => `${p.name} -${p.majorsBehind}`).join(", ").length + (worst.length > 3 ? ` +${worst.length - 3}`.length : 0);
+      const pkgPad = Math.max(0, boxWidth - roughLen - 4);
+      lines.push(
+        chalk.cyan("  \u2502") + "    " + pkgLine + " ".repeat(pkgPad) + chalk.cyan("\u2502")
+      );
+    }
+    if (i < visibleLayers.length - 1) {
+      lines.push(chalk.cyan(`  \u251C${"\u2500".repeat(boxWidth)}\u2524`));
+    } else {
+      lines.push(chalk.cyan(`  \u2514${"\u2500".repeat(boxWidth)}\u2518`));
+    }
+  }
+  lines.push("");
   return lines;
 }
 function generatePriorityActions(artifact) {
@@ -1019,7 +1166,7 @@ var pushCommand = new Command2("push").description("Push scan results to Vibgrat
 });
 
 // src/commands/scan.ts
-import * as path14 from "path";
+import * as path15 from "path";
 import { Command as Command3 } from "commander";
 import chalk5 from "chalk";
 
@@ -1620,35 +1767,6 @@ async function scanOneCsproj(csprojPath, rootDir) {
   };
 }
 
-// src/utils/semaphore.ts
-var Semaphore = class {
-  available;
-  queue = [];
-  constructor(max) {
-    this.available = max;
-  }
-  async run(fn) {
-    await this.acquire();
-    try {
-      return await fn();
-    } finally {
-      this.release();
-    }
-  }
-  acquire() {
-    if (this.available > 0) {
-      this.available--;
-      return Promise.resolve();
-    }
-    return new Promise((resolve6) => this.queue.push(resolve6));
-  }
-  release() {
-    const next = this.queue.shift();
-    if (next) next();
-    else this.available++;
-  }
-};
-
 // src/config.ts
 import * as path6 from "path";
 import * as fs2 from "fs/promises";
@@ -3907,6 +4025,528 @@ function scanServiceDependencies(projects) {
   return result;
 }
 
+// src/scanners/architecture.ts
+import * as path14 from "path";
+import * as fs5 from "fs/promises";
+var ARCHETYPE_SIGNALS = [
+  // Meta-frameworks (highest priority — they imply routing patterns)
+  { packages: ["next", "@next/core"], archetype: "nextjs", weight: 10 },
+  { packages: ["@remix-run/react", "@remix-run/node", "@remix-run/dev"], archetype: "remix", weight: 10 },
+  { packages: ["@sveltejs/kit"], archetype: "sveltekit", weight: 10 },
+  { packages: ["nuxt"], archetype: "nuxt", weight: 10 },
+  // Backend frameworks
+  { packages: ["@nestjs/core", "@nestjs/common"], archetype: "nestjs", weight: 9 },
+  { packages: ["fastify"], archetype: "fastify", weight: 8 },
+  { packages: ["hono"], archetype: "hono", weight: 8 },
+  { packages: ["koa"], archetype: "koa", weight: 8 },
+  { packages: ["express"], archetype: "express", weight: 7 },
+  // Serverless
+  { packages: ["serverless", "aws-lambda", "@aws-sdk/client-lambda", "middy", "@cloudflare/workers-types"], archetype: "serverless", weight: 6 },
+  // CLI
+  { packages: ["commander", "yargs", "meow", "cac", "clipanion", "oclif"], archetype: "cli", weight: 5 }
+];
+function detectArchetype(projects) {
+  const allPackages = /* @__PURE__ */ new Set();
+  for (const p of projects) {
+    for (const d of p.dependencies) {
+      allPackages.add(d.package);
+    }
+  }
+  if (projects.length > 2) {
+    return { archetype: "monorepo", confidence: 0.8 };
+  }
+  let bestArchetype = "unknown";
+  let bestScore = 0;
+  for (const signal of ARCHETYPE_SIGNALS) {
+    const matched = signal.packages.filter((p) => allPackages.has(p)).length;
+    if (matched > 0) {
+      const score = matched * signal.weight;
+      if (score > bestScore) {
+        bestScore = score;
+        bestArchetype = signal.archetype;
+      }
+    }
+  }
+  if (bestArchetype === "unknown") {
+    bestArchetype = "library";
+    bestScore = 3;
+  }
+  const confidence = Math.min(bestScore / 15, 1);
+  return { archetype: bestArchetype, confidence: Math.round(confidence * 100) / 100 };
+}
+var PATH_RULES = [
+  // ── Testing (high precision) ──
+  { pattern: /\/__tests__\//, layer: "testing", confidence: 0.95, signal: "__tests__ directory" },
+  { pattern: /\.test\.[jt]sx?$/, layer: "testing", confidence: 0.95, signal: ".test.* file" },
+  { pattern: /\.spec\.[jt]sx?$/, layer: "testing", confidence: 0.95, signal: ".spec.* file" },
+  { pattern: /\/test\//, layer: "testing", confidence: 0.85, signal: "test/ directory" },
+  { pattern: /\/tests\//, layer: "testing", confidence: 0.85, signal: "tests/ directory" },
+  { pattern: /\/__mocks__\//, layer: "testing", confidence: 0.9, signal: "__mocks__ directory" },
+  { pattern: /\/fixtures\//, layer: "testing", confidence: 0.8, signal: "fixtures/ directory" },
+  // ── Config/Infrastructure (high precision) ──
+  { pattern: /\/config\.[jt]sx?$/, layer: "config", confidence: 0.85, signal: "config.* file" },
+  { pattern: /\/config\//, layer: "config", confidence: 0.8, signal: "config/ directory" },
+  { pattern: /\.config\.[jt]sx?$/, layer: "config", confidence: 0.9, signal: ".config.* file" },
+  { pattern: /\/env\.[jt]sx?$/, layer: "config", confidence: 0.85, signal: "env.* file" },
+  { pattern: /\/bootstrap\.[jt]sx?$/, layer: "config", confidence: 0.85, signal: "bootstrap file" },
+  { pattern: /\/setup\.[jt]sx?$/, layer: "config", confidence: 0.8, signal: "setup file" },
+  // ── Next.js (archetype-specific) ──
+  { pattern: /(^|\/)app\/.*\/route\.[jt]sx?$/, layer: "routing", confidence: 0.95, signal: "Next.js App Router route", archetypes: ["nextjs"] },
+  { pattern: /(^|\/)pages\/api\//, layer: "routing", confidence: 0.95, signal: "Next.js Pages API route", archetypes: ["nextjs"] },
+  { pattern: /(^|\/)app\/.*page\.[jt]sx?$/, layer: "presentation", confidence: 0.9, signal: "Next.js page component", archetypes: ["nextjs"] },
+  { pattern: /(^|\/)app\/.*layout\.[jt]sx?$/, layer: "presentation", confidence: 0.9, signal: "Next.js layout component", archetypes: ["nextjs"] },
+  { pattern: /(^|\/)app\/.*loading\.[jt]sx?$/, layer: "presentation", confidence: 0.85, signal: "Next.js loading component", archetypes: ["nextjs"] },
+  { pattern: /(^|\/)app\/.*error\.[jt]sx?$/, layer: "presentation", confidence: 0.85, signal: "Next.js error component", archetypes: ["nextjs"] },
+  { pattern: /(^|\/)middleware\.[jt]sx?$/, layer: "middleware", confidence: 0.9, signal: "Next.js middleware", archetypes: ["nextjs"] },
+  // ── Remix (archetype-specific) ──
+  { pattern: /\/app\/routes\//, layer: "routing", confidence: 0.95, signal: "Remix route file", archetypes: ["remix"] },
+  { pattern: /\/app\/root\.[jt]sx?$/, layer: "presentation", confidence: 0.9, signal: "Remix root", archetypes: ["remix"] },
+  // ── SvelteKit (archetype-specific) ──
+  { pattern: /\/src\/routes\/.*\+server\.[jt]s$/, layer: "routing", confidence: 0.95, signal: "SvelteKit API route", archetypes: ["sveltekit"] },
+  { pattern: /\/src\/routes\/.*\+page\.svelte$/, layer: "presentation", confidence: 0.9, signal: "SvelteKit page", archetypes: ["sveltekit"] },
+  { pattern: /\/src\/routes\/.*\+layout\.svelte$/, layer: "presentation", confidence: 0.9, signal: "SvelteKit layout", archetypes: ["sveltekit"] },
+  { pattern: /\/src\/hooks\.server\.[jt]s$/, layer: "middleware", confidence: 0.9, signal: "SvelteKit server hooks", archetypes: ["sveltekit"] },
+  // ── Nuxt (archetype-specific) ──
+  { pattern: /\/server\/api\//, layer: "routing", confidence: 0.95, signal: "Nuxt server API", archetypes: ["nuxt"] },
+  { pattern: /\/server\/routes\//, layer: "routing", confidence: 0.95, signal: "Nuxt server route", archetypes: ["nuxt"] },
+  { pattern: /\/server\/middleware\//, layer: "middleware", confidence: 0.95, signal: "Nuxt server middleware", archetypes: ["nuxt"] },
+  { pattern: /\/pages\//, layer: "presentation", confidence: 0.85, signal: "Nuxt pages directory", archetypes: ["nuxt"] },
+  // ── NestJS (archetype-specific) ──
+  { pattern: /\.controller\.[jt]sx?$/, layer: "routing", confidence: 0.95, signal: "NestJS controller", archetypes: ["nestjs"] },
+  { pattern: /\.service\.[jt]sx?$/, layer: "services", confidence: 0.95, signal: "NestJS service", archetypes: ["nestjs"] },
+  { pattern: /\.module\.[jt]sx?$/, layer: "config", confidence: 0.9, signal: "NestJS module", archetypes: ["nestjs"] },
+  { pattern: /\.guard\.[jt]sx?$/, layer: "middleware", confidence: 0.9, signal: "NestJS guard", archetypes: ["nestjs"] },
+  { pattern: /\.interceptor\.[jt]sx?$/, layer: "middleware", confidence: 0.9, signal: "NestJS interceptor", archetypes: ["nestjs"] },
+  { pattern: /\.pipe\.[jt]sx?$/, layer: "middleware", confidence: 0.85, signal: "NestJS pipe", archetypes: ["nestjs"] },
+  { pattern: /\.middleware\.[jt]sx?$/, layer: "middleware", confidence: 0.9, signal: "NestJS middleware", archetypes: ["nestjs"] },
+  { pattern: /\.entity\.[jt]sx?$/, layer: "domain", confidence: 0.9, signal: "NestJS entity", archetypes: ["nestjs"] },
+  { pattern: /\.dto\.[jt]sx?$/, layer: "domain", confidence: 0.85, signal: "NestJS DTO", archetypes: ["nestjs"] },
+  { pattern: /\.repository\.[jt]sx?$/, layer: "data-access", confidence: 0.9, signal: "NestJS repository", archetypes: ["nestjs"] },
+  // ── Generic routing patterns ──
+  { pattern: /\/routes\//, layer: "routing", confidence: 0.8, signal: "routes/ directory" },
+  { pattern: /\/router\//, layer: "routing", confidence: 0.8, signal: "router/ directory" },
+  { pattern: /\/controllers\//, layer: "routing", confidence: 0.8, signal: "controllers/ directory" },
+  { pattern: /\/handlers\//, layer: "routing", confidence: 0.75, signal: "handlers/ directory" },
+  { pattern: /\/api\//, layer: "routing", confidence: 0.7, signal: "api/ directory" },
+  { pattern: /\/endpoints\//, layer: "routing", confidence: 0.8, signal: "endpoints/ directory" },
+  // ── Middleware ──
+  { pattern: /\/middleware\//, layer: "middleware", confidence: 0.85, signal: "middleware/ directory" },
+  { pattern: /\/middlewares\//, layer: "middleware", confidence: 0.85, signal: "middlewares/ directory" },
+  { pattern: /\/hooks\//, layer: "middleware", confidence: 0.6, signal: "hooks/ directory" },
+  { pattern: /\/plugins\//, layer: "middleware", confidence: 0.6, signal: "plugins/ directory" },
+  { pattern: /\/guards\//, layer: "middleware", confidence: 0.85, signal: "guards/ directory" },
+  { pattern: /\/interceptors\//, layer: "middleware", confidence: 0.85, signal: "interceptors/ directory" },
+  // ── Services / application layer ──
+  { pattern: /\/services\//, layer: "services", confidence: 0.85, signal: "services/ directory" },
+  { pattern: /\/service\//, layer: "services", confidence: 0.8, signal: "service/ directory" },
+  { pattern: /\/usecases\//, layer: "services", confidence: 0.85, signal: "usecases/ directory" },
+  { pattern: /\/use-cases\//, layer: "services", confidence: 0.85, signal: "use-cases/ directory" },
+  { pattern: /\/application\//, layer: "services", confidence: 0.7, signal: "application/ directory" },
+  { pattern: /\/actions\//, layer: "services", confidence: 0.65, signal: "actions/ directory" },
+  // ── Domain / models ──
+  { pattern: /\/domain\//, layer: "domain", confidence: 0.85, signal: "domain/ directory" },
+  { pattern: /\/models\//, layer: "domain", confidence: 0.8, signal: "models/ directory" },
+  { pattern: /\/entities\//, layer: "domain", confidence: 0.85, signal: "entities/ directory" },
+  { pattern: /\/types\//, layer: "domain", confidence: 0.7, signal: "types/ directory" },
+  { pattern: /\/schemas\//, layer: "domain", confidence: 0.7, signal: "schemas/ directory" },
+  { pattern: /\/validators\//, layer: "domain", confidence: 0.7, signal: "validators/ directory" },
+  // ── Data access ──
+  { pattern: /\/repositories\//, layer: "data-access", confidence: 0.9, signal: "repositories/ directory" },
+  { pattern: /\/repository\//, layer: "data-access", confidence: 0.85, signal: "repository/ directory" },
+  { pattern: /\/dao\//, layer: "data-access", confidence: 0.9, signal: "dao/ directory" },
+  { pattern: /\/db\//, layer: "data-access", confidence: 0.8, signal: "db/ directory" },
+  { pattern: /\/database\//, layer: "data-access", confidence: 0.8, signal: "database/ directory" },
+  { pattern: /\/persistence\//, layer: "data-access", confidence: 0.85, signal: "persistence/ directory" },
+  { pattern: /\/migrations\//, layer: "data-access", confidence: 0.9, signal: "migrations/ directory" },
+  { pattern: /\/seeds\//, layer: "data-access", confidence: 0.85, signal: "seeds/ directory" },
+  { pattern: /\/prisma\//, layer: "data-access", confidence: 0.85, signal: "prisma/ directory" },
+  { pattern: /\/drizzle\//, layer: "data-access", confidence: 0.85, signal: "drizzle/ directory" },
+  // ── Infrastructure ──
+  { pattern: /\/infra\//, layer: "infrastructure", confidence: 0.85, signal: "infra/ directory" },
+  { pattern: /\/infrastructure\//, layer: "infrastructure", confidence: 0.85, signal: "infrastructure/ directory" },
+  { pattern: /\/adapters\//, layer: "infrastructure", confidence: 0.8, signal: "adapters/ directory" },
+  { pattern: /\/clients\//, layer: "infrastructure", confidence: 0.75, signal: "clients/ directory" },
+  { pattern: /\/integrations\//, layer: "infrastructure", confidence: 0.8, signal: "integrations/ directory" },
+  { pattern: /\/external\//, layer: "infrastructure", confidence: 0.75, signal: "external/ directory" },
+  { pattern: /\/queue\//, layer: "infrastructure", confidence: 0.8, signal: "queue/ directory" },
+  { pattern: /\/jobs\//, layer: "infrastructure", confidence: 0.75, signal: "jobs/ directory" },
+  { pattern: /\/workers\//, layer: "infrastructure", confidence: 0.75, signal: "workers/ directory" },
+  { pattern: /\/cron\//, layer: "infrastructure", confidence: 0.8, signal: "cron/ directory" },
+  // ── Presentation (UI layer) ──
+  { pattern: /\/components\//, layer: "presentation", confidence: 0.85, signal: "components/ directory" },
+  { pattern: /\/views\//, layer: "presentation", confidence: 0.85, signal: "views/ directory" },
+  { pattern: /\/pages\//, layer: "presentation", confidence: 0.8, signal: "pages/ directory" },
+  { pattern: /\/layouts\//, layer: "presentation", confidence: 0.85, signal: "layouts/ directory" },
+  { pattern: /\/templates\//, layer: "presentation", confidence: 0.8, signal: "templates/ directory" },
+  { pattern: /\/widgets\//, layer: "presentation", confidence: 0.8, signal: "widgets/ directory" },
+  { pattern: /\/ui\//, layer: "presentation", confidence: 0.75, signal: "ui/ directory" },
+  // ── Shared / utils ──
+  { pattern: /\/utils\//, layer: "shared", confidence: 0.7, signal: "utils/ directory" },
+  { pattern: /\/helpers\//, layer: "shared", confidence: 0.7, signal: "helpers/ directory" },
+  { pattern: /\/lib\//, layer: "shared", confidence: 0.6, signal: "lib/ directory" },
+  { pattern: /\/common\//, layer: "shared", confidence: 0.65, signal: "common/ directory" },
+  { pattern: /\/shared\//, layer: "shared", confidence: 0.75, signal: "shared/ directory" },
+  { pattern: /\/constants\//, layer: "shared", confidence: 0.7, signal: "constants/ directory" },
+  // ── CLI-specific (command layer → routing) ──
+  { pattern: /\/commands\//, layer: "routing", confidence: 0.8, signal: "commands/ directory", archetypes: ["cli"] },
+  { pattern: /\/formatters\//, layer: "presentation", confidence: 0.8, signal: "formatters/ directory", archetypes: ["cli"] },
+  { pattern: /\/scanners\//, layer: "services", confidence: 0.8, signal: "scanners/ directory", archetypes: ["cli"] },
+  { pattern: /\/scoring\//, layer: "domain", confidence: 0.8, signal: "scoring/ directory", archetypes: ["cli"] },
+  // ── Serverless-specific ──
+  { pattern: /\/functions\//, layer: "routing", confidence: 0.8, signal: "functions/ directory", archetypes: ["serverless"] },
+  { pattern: /\/lambdas\//, layer: "routing", confidence: 0.85, signal: "lambdas/ directory", archetypes: ["serverless"] },
+  { pattern: /\/layers\//, layer: "shared", confidence: 0.7, signal: "Lambda layers/ directory", archetypes: ["serverless"] }
+];
+var SUFFIX_RULES = [
+  { suffix: ".controller", layer: "routing", confidence: 0.85, signal: "controller suffix" },
+  { suffix: ".route", layer: "routing", confidence: 0.85, signal: "route suffix" },
+  { suffix: ".router", layer: "routing", confidence: 0.85, signal: "router suffix" },
+  { suffix: ".handler", layer: "routing", confidence: 0.8, signal: "handler suffix" },
+  { suffix: ".middleware", layer: "middleware", confidence: 0.85, signal: "middleware suffix" },
+  { suffix: ".guard", layer: "middleware", confidence: 0.85, signal: "guard suffix" },
+  { suffix: ".interceptor", layer: "middleware", confidence: 0.85, signal: "interceptor suffix" },
+  { suffix: ".service", layer: "services", confidence: 0.85, signal: "service suffix" },
+  { suffix: ".usecase", layer: "services", confidence: 0.85, signal: "usecase suffix" },
+  { suffix: ".model", layer: "domain", confidence: 0.8, signal: "model suffix" },
+  { suffix: ".entity", layer: "domain", confidence: 0.85, signal: "entity suffix" },
+  { suffix: ".dto", layer: "domain", confidence: 0.8, signal: "DTO suffix" },
+  { suffix: ".schema", layer: "domain", confidence: 0.75, signal: "schema suffix" },
+  { suffix: ".validator", layer: "domain", confidence: 0.75, signal: "validator suffix" },
+  { suffix: ".repository", layer: "data-access", confidence: 0.9, signal: "repository suffix" },
+  { suffix: ".repo", layer: "data-access", confidence: 0.85, signal: "repo suffix" },
+  { suffix: ".dao", layer: "data-access", confidence: 0.9, signal: "dao suffix" },
+  { suffix: ".migration", layer: "data-access", confidence: 0.85, signal: "migration suffix" },
+  { suffix: ".adapter", layer: "infrastructure", confidence: 0.8, signal: "adapter suffix" },
+  { suffix: ".client", layer: "infrastructure", confidence: 0.75, signal: "client suffix" },
+  { suffix: ".provider", layer: "infrastructure", confidence: 0.7, signal: "provider suffix" },
+  { suffix: ".config", layer: "config", confidence: 0.8, signal: "config suffix" },
+  { suffix: ".component", layer: "presentation", confidence: 0.8, signal: "component suffix" },
+  { suffix: ".page", layer: "presentation", confidence: 0.85, signal: "page suffix" },
+  { suffix: ".view", layer: "presentation", confidence: 0.8, signal: "view suffix" },
+  { suffix: ".layout", layer: "presentation", confidence: 0.85, signal: "layout suffix" },
+  { suffix: ".util", layer: "shared", confidence: 0.7, signal: "util suffix" },
+  { suffix: ".helper", layer: "shared", confidence: 0.7, signal: "helper suffix" },
+  { suffix: ".constant", layer: "shared", confidence: 0.7, signal: "constant suffix" }
+];
+var PACKAGE_LAYER_MAP = {
+  // Routing/controllers
+  "express": "routing",
+  "fastify": "routing",
+  "@nestjs/core": "routing",
+  "hono": "routing",
+  "koa": "routing",
+  "koa-router": "routing",
+  "@hapi/hapi": "routing",
+  "h3": "routing",
+  // Middleware
+  "cors": "middleware",
+  "helmet": "middleware",
+  "passport": "middleware",
+  "express-rate-limit": "middleware",
+  "cookie-parser": "middleware",
+  "body-parser": "middleware",
+  "multer": "middleware",
+  "morgan": "middleware",
+  "compression": "middleware",
+  "express-session": "middleware",
+  // Services / application
+  "bullmq": "services",
+  "bull": "services",
+  "agenda": "services",
+  "pg-boss": "services",
+  "inngest": "services",
+  // Domain / validation
+  "zod": "domain",
+  "joi": "domain",
+  "yup": "domain",
+  "class-validator": "domain",
+  "class-transformer": "domain",
+  "superstruct": "domain",
+  "valibot": "domain",
+  // Data access / ORM
+  "prisma": "data-access",
+  "@prisma/client": "data-access",
+  "drizzle-orm": "data-access",
+  "typeorm": "data-access",
+  "sequelize": "data-access",
+  "knex": "data-access",
+  "pg": "data-access",
+  "mysql2": "data-access",
+  "mongodb": "data-access",
+  "mongoose": "data-access",
+  "ioredis": "data-access",
+  "redis": "data-access",
+  "better-sqlite3": "data-access",
+  "kysely": "data-access",
+  "@mikro-orm/core": "data-access",
+  // Infrastructure
+  "@aws-sdk/client-s3": "infrastructure",
+  "@aws-sdk/client-sqs": "infrastructure",
+  "@aws-sdk/client-sns": "infrastructure",
+  "@aws-sdk/client-ses": "infrastructure",
+  "@aws-sdk/client-lambda": "infrastructure",
+  "@google-cloud/storage": "infrastructure",
+  "@azure/storage-blob": "infrastructure",
+  "nodemailer": "infrastructure",
+  "@sendgrid/mail": "infrastructure",
+  "stripe": "infrastructure",
+  "kafkajs": "infrastructure",
+  "amqplib": "infrastructure",
+  // Presentation
+  "react": "presentation",
+  "react-dom": "presentation",
+  "vue": "presentation",
+  "@angular/core": "presentation",
+  "svelte": "presentation",
+  // Shared
+  "lodash": "shared",
+  "dayjs": "shared",
+  "date-fns": "shared",
+  "uuid": "shared",
+  "nanoid": "shared",
+  // Testing
+  "vitest": "testing",
+  "jest": "testing",
+  "mocha": "testing",
+  "@playwright/test": "testing",
+  "cypress": "testing",
+  "supertest": "testing",
+  // Observability → infrastructure
+  "@sentry/node": "infrastructure",
+  "@opentelemetry/api": "infrastructure",
+  "pino": "infrastructure",
+  "winston": "infrastructure",
+  "dd-trace": "infrastructure"
+};
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs", ".cts", ".cjs", ".svelte", ".vue"]);
+var IGNORE_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", ".nuxt", ".output", ".svelte-kit", "coverage", ".vibgrate"]);
+async function walkSourceFiles(rootDir) {
+  const files = [];
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await fs5.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && entry.name !== ".") continue;
+      const fullPath = path14.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!IGNORE_DIRS.has(entry.name)) {
+          await walk(fullPath);
+        }
+      } else if (entry.isFile()) {
+        const ext = path14.extname(entry.name);
+        if (SOURCE_EXTENSIONS.has(ext)) {
+          files.push(path14.relative(rootDir, fullPath));
+        }
+      }
+    }
+  }
+  await walk(rootDir);
+  return files;
+}
+function classifyFile(filePath, archetype) {
+  const normalised = filePath.replace(/\\/g, "/");
+  let bestMatch = null;
+  for (const rule of PATH_RULES) {
+    if (rule.archetypes && rule.archetypes.length > 0 && !rule.archetypes.includes(archetype)) {
+      continue;
+    }
+    if (rule.pattern.test(normalised)) {
+      const boost = rule.archetypes ? 0.05 : 0;
+      const adjustedConfidence = Math.min(rule.confidence + boost, 1);
+      if (!bestMatch || adjustedConfidence > bestMatch.confidence) {
+        bestMatch = { layer: rule.layer, confidence: adjustedConfidence, signal: rule.signal };
+      }
+    }
+  }
+  if (!bestMatch || bestMatch.confidence < 0.7) {
+    const baseName = path14.basename(filePath, path14.extname(filePath));
+    const cleanBase = baseName.replace(/\.(test|spec)$/, "");
+    for (const rule of SUFFIX_RULES) {
+      if (cleanBase.endsWith(rule.suffix)) {
+        if (!bestMatch || rule.confidence > bestMatch.confidence) {
+          bestMatch = { layer: rule.layer, confidence: rule.confidence, signal: rule.signal };
+        }
+      }
+    }
+  }
+  if (bestMatch) {
+    return {
+      filePath,
+      layer: bestMatch.layer,
+      confidence: bestMatch.confidence,
+      signals: [bestMatch.signal]
+    };
+  }
+  return null;
+}
+function computeLayerDrift(packages) {
+  if (packages.length === 0) {
+    return { score: 100, riskLevel: "low" };
+  }
+  let current = 0;
+  let oneBehind = 0;
+  let twoPlusBehind = 0;
+  let unknown = 0;
+  for (const pkg2 of packages) {
+    if (pkg2.majorsBehind === null) {
+      unknown++;
+    } else if (pkg2.majorsBehind === 0) {
+      current++;
+    } else if (pkg2.majorsBehind === 1) {
+      oneBehind++;
+    } else {
+      twoPlusBehind++;
+    }
+  }
+  const known = current + oneBehind + twoPlusBehind;
+  if (known === 0) return { score: 100, riskLevel: "low" };
+  const currentPct = current / known;
+  const onePct = oneBehind / known;
+  const twoPct = twoPlusBehind / known;
+  const score = Math.round(Math.max(0, Math.min(100, currentPct * 100 - onePct * 10 - twoPct * 40)));
+  const riskLevel = score >= 70 ? "low" : score >= 40 ? "moderate" : "high";
+  return { score, riskLevel };
+}
+function mapToolingToLayers(tooling, services, depsByLayer) {
+  const layerTooling = /* @__PURE__ */ new Map();
+  const layerServices = /* @__PURE__ */ new Map();
+  const pkgLayerLookup = /* @__PURE__ */ new Map();
+  for (const [layer, packages] of depsByLayer) {
+    for (const pkg2 of packages) {
+      pkgLayerLookup.set(pkg2, layer);
+    }
+  }
+  if (tooling) {
+    for (const [, items] of Object.entries(tooling)) {
+      for (const item of items) {
+        const layer = pkgLayerLookup.get(item.package) ?? PACKAGE_LAYER_MAP[item.package] ?? "shared";
+        if (!layerTooling.has(layer)) layerTooling.set(layer, []);
+        const existing = layerTooling.get(layer);
+        if (!existing.some((t) => t.package === item.package)) {
+          existing.push(item);
+        }
+      }
+    }
+  }
+  if (services) {
+    for (const [, items] of Object.entries(services)) {
+      for (const item of items) {
+        const layer = pkgLayerLookup.get(item.package) ?? PACKAGE_LAYER_MAP[item.package] ?? "infrastructure";
+        if (!layerServices.has(layer)) layerServices.set(layer, []);
+        const existing = layerServices.get(layer);
+        if (!existing.some((s) => s.package === item.package)) {
+          existing.push(item);
+        }
+      }
+    }
+  }
+  return { layerTooling, layerServices };
+}
+async function scanArchitecture(rootDir, projects, tooling, services) {
+  const { archetype, confidence: archetypeConfidence } = detectArchetype(projects);
+  const sourceFiles = await walkSourceFiles(rootDir);
+  const classifications = [];
+  let unclassified = 0;
+  for (const file of sourceFiles) {
+    const classification = classifyFile(file, archetype);
+    if (classification) {
+      classifications.push(classification);
+    } else {
+      unclassified++;
+    }
+  }
+  const allDeps = /* @__PURE__ */ new Map();
+  for (const p of projects) {
+    for (const d of p.dependencies) {
+      if (!allDeps.has(d.package)) {
+        allDeps.set(d.package, d);
+      }
+    }
+  }
+  const depsByLayer = /* @__PURE__ */ new Map();
+  for (const [pkg2] of allDeps) {
+    const layer = PACKAGE_LAYER_MAP[pkg2];
+    if (layer) {
+      if (!depsByLayer.has(layer)) depsByLayer.set(layer, /* @__PURE__ */ new Set());
+      depsByLayer.get(layer).add(pkg2);
+    }
+  }
+  const { layerTooling, layerServices } = mapToolingToLayers(tooling, services, depsByLayer);
+  const ALL_LAYERS = [
+    "routing",
+    "middleware",
+    "services",
+    "domain",
+    "data-access",
+    "infrastructure",
+    "presentation",
+    "config",
+    "testing",
+    "shared"
+  ];
+  const layerFileCounts = /* @__PURE__ */ new Map();
+  for (const c of classifications) {
+    layerFileCounts.set(c.layer, (layerFileCounts.get(c.layer) ?? 0) + 1);
+  }
+  const layers = [];
+  for (const layer of ALL_LAYERS) {
+    const fileCount = layerFileCounts.get(layer) ?? 0;
+    const layerPkgs = depsByLayer.get(layer) ?? /* @__PURE__ */ new Set();
+    const tech = layerTooling.get(layer) ?? [];
+    const svc = layerServices.get(layer) ?? [];
+    if (fileCount === 0 && layerPkgs.size === 0 && tech.length === 0 && svc.length === 0) {
+      continue;
+    }
+    const packages = [];
+    for (const pkg2 of layerPkgs) {
+      const dep = allDeps.get(pkg2);
+      if (dep) {
+        packages.push({
+          name: dep.package,
+          version: dep.resolvedVersion,
+          latestStable: dep.latestStable,
+          majorsBehind: dep.majorsBehind,
+          drift: dep.drift
+        });
+      }
+    }
+    const { score, riskLevel } = computeLayerDrift(packages);
+    layers.push({
+      layer,
+      fileCount,
+      driftScore: score,
+      riskLevel,
+      techStack: tech,
+      services: svc,
+      packages
+    });
+  }
+  const LAYER_ORDER = {
+    "presentation": 0,
+    "routing": 1,
+    "middleware": 2,
+    "services": 3,
+    "domain": 4,
+    "data-access": 5,
+    "infrastructure": 6,
+    "config": 7,
+    "shared": 8,
+    "testing": 9
+  };
+  layers.sort((a, b) => (LAYER_ORDER[a.layer] ?? 99) - (LAYER_ORDER[b.layer] ?? 99));
+  return {
+    archetype,
+    archetypeConfidence,
+    layers,
+    totalClassified: classifications.length,
+    unclassified
+  };
+}
+
 // src/commands/scan.ts
 async function runScan(rootDir, opts) {
   const scanStart = Date.now();
@@ -3931,7 +4571,8 @@ async function runScan(rootDir, opts) {
       ...scanners?.tsModernity?.enabled !== false ? [{ id: "ts", label: "TypeScript modernity" }] : [],
       ...scanners?.fileHotspots?.enabled !== false ? [{ id: "hotspots", label: "File hotspots" }] : [],
       ...scanners?.dependencyGraph?.enabled !== false ? [{ id: "depgraph", label: "Dependency graph" }] : [],
-      ...scanners?.dependencyRisk?.enabled !== false ? [{ id: "deprisk", label: "Dependency risk" }] : []
+      ...scanners?.dependencyRisk?.enabled !== false ? [{ id: "deprisk", label: "Dependency risk" }] : [],
+      ...scanners?.architecture?.enabled !== false ? [{ id: "architecture", label: "Architecture layers" }] : []
     ] : [],
     { id: "drift", label: "Computing drift score" },
     { id: "findings", label: "Generating findings" }
@@ -4088,6 +4729,22 @@ async function runScan(rootDir, opts) {
       );
     }
     await Promise.all(scannerTasks);
+    if (scanners?.architecture?.enabled !== false) {
+      progress.startStep("architecture");
+      extended.architecture = await scanArchitecture(
+        rootDir,
+        allProjects,
+        extended.toolingInventory,
+        extended.serviceDependencies
+      );
+      const arch = extended.architecture;
+      const layerCount = arch.layers.filter((l) => l.fileCount > 0).length;
+      progress.completeStep(
+        "architecture",
+        `${arch.archetype} \xB7 ${layerCount} layer${layerCount !== 1 ? "s" : ""} \xB7 ${arch.totalClassified} files`,
+        layerCount
+      );
+    }
   }
   progress.startStep("drift");
   const drift = computeDriftScore(allProjects);
@@ -4120,7 +4777,7 @@ async function runScan(rootDir, opts) {
     schemaVersion: "1.0",
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     vibgrateVersion: VERSION,
-    rootPath: path14.basename(rootDir),
+    rootPath: path15.basename(rootDir),
     ...vcs.type !== "unknown" ? { vcs } : {},
     projects: allProjects,
     drift,
@@ -4130,7 +4787,7 @@ async function runScan(rootDir, opts) {
     filesScanned
   };
   if (opts.baseline) {
-    const baselinePath = path14.resolve(opts.baseline);
+    const baselinePath = path15.resolve(opts.baseline);
     if (await pathExists(baselinePath)) {
       try {
         const baseline = await readJsonFile(baselinePath);
@@ -4141,15 +4798,15 @@ async function runScan(rootDir, opts) {
       }
     }
   }
-  const vibgrateDir = path14.join(rootDir, ".vibgrate");
+  const vibgrateDir = path15.join(rootDir, ".vibgrate");
   await ensureDir(vibgrateDir);
-  await writeJsonFile(path14.join(vibgrateDir, "scan_result.json"), artifact);
+  await writeJsonFile(path15.join(vibgrateDir, "scan_result.json"), artifact);
   for (const project of allProjects) {
     if (project.drift && project.path) {
-      const projectDir = path14.resolve(rootDir, project.path);
-      const projectVibgrateDir = path14.join(projectDir, ".vibgrate");
+      const projectDir = path15.resolve(rootDir, project.path);
+      const projectVibgrateDir = path15.join(projectDir, ".vibgrate");
       await ensureDir(projectVibgrateDir);
-      await writeJsonFile(path14.join(projectVibgrateDir, "project_score.json"), {
+      await writeJsonFile(path15.join(projectVibgrateDir, "project_score.json"), {
         projectId: project.projectId,
         name: project.name,
         type: project.type,
@@ -4166,7 +4823,7 @@ async function runScan(rootDir, opts) {
   if (opts.format === "json") {
     const jsonStr = JSON.stringify(artifact, null, 2);
     if (opts.out) {
-      await writeTextFile(path14.resolve(opts.out), jsonStr);
+      await writeTextFile(path15.resolve(opts.out), jsonStr);
       console.log(chalk5.green("\u2714") + ` JSON written to ${opts.out}`);
     } else {
       console.log(jsonStr);
@@ -4175,7 +4832,7 @@ async function runScan(rootDir, opts) {
     const sarif = formatSarif(artifact);
     const sarifStr = JSON.stringify(sarif, null, 2);
     if (opts.out) {
-      await writeTextFile(path14.resolve(opts.out), sarifStr);
+      await writeTextFile(path15.resolve(opts.out), sarifStr);
       console.log(chalk5.green("\u2714") + ` SARIF written to ${opts.out}`);
     } else {
       console.log(sarifStr);
@@ -4184,7 +4841,7 @@ async function runScan(rootDir, opts) {
     const text = formatText(artifact);
     console.log(text);
     if (opts.out) {
-      await writeTextFile(path14.resolve(opts.out), text);
+      await writeTextFile(path15.resolve(opts.out), text);
     }
   }
   return artifact;
@@ -4243,7 +4900,7 @@ async function autoPush(artifact, rootDir, opts) {
   }
 }
 var scanCommand = new Command3("scan").description("Scan a project for upgrade drift").argument("[path]", "Path to scan", ".").option("--out <file>", "Output file path").option("--format <format>", "Output format (text|json|sarif)", "text").option("--fail-on <level>", "Fail on warn or error").option("--baseline <file>", "Compare against baseline").option("--changed-only", "Only scan changed files").option("--concurrency <n>", "Max concurrent npm calls", "8").option("--push", "Auto-push results to Vibgrate API after scan").option("--dsn <dsn>", "DSN token for push (or use VIBGRATE_DSN env)").option("--region <region>", "Override data residency region for push (us, eu)").option("--strict", "Fail on push errors").action(async (targetPath, opts) => {
-  const rootDir = path14.resolve(targetPath);
+  const rootDir = path15.resolve(targetPath);
   if (!await pathExists(rootDir)) {
     console.error(chalk5.red(`Path does not exist: ${rootDir}`));
     process.exit(1);

package/dist/cli.js

@@ -4,7 +4,7 @@ import {
 } from "./chunk-VXZT34Y5.js";
 import {
   baselineCommand
-} from "./chunk-QHBZIYWP.js";
+} from "./chunk-OPEOSIRY.js";
 import {
   VERSION,
   dsnCommand,
@@ -15,7 +15,7 @@ import {
   readJsonFile,
   scanCommand,
   writeDefaultConfig
-} from "./chunk-S4C6KWCP.js";
+} from "./chunk-QZV77UWV.js";
 
 // src/cli.ts
 import { Command as Command4 } from "commander";
@@ -38,7 +38,7 @@ var initCommand = new Command("init").description("Initialize vibgrate in a proj
     console.log(chalk.green("\u2714") + ` Created ${chalk.bold("vibgrate.config.ts")}`);
   }
   if (opts.baseline) {
-    const { runBaseline } = await import("./baseline-OPUTCJOQ.js");
+    const { runBaseline } = await import("./baseline-M445KUZ4.js");
     await runBaseline(rootDir);
   }
   console.log("");
@@ -222,7 +222,7 @@ var updateCommand = new Command3("update").description("Update vibgrate to the l
 
 // src/cli.ts
 var program = new Command4();
-program.name("vibgrate").description("Continuous Upgrade Drift Intelligence for Node & .NET").version(VERSION);
+program.name("vibgrate").description("Continuous Drift Intelligence for Node & .NET").version(VERSION);
 program.addCommand(initCommand);
 program.addCommand(scanCommand);
 program.addCommand(baselineCommand);

package/dist/index.d.ts

@@ -110,6 +110,7 @@ interface ScannersConfig {
     fileHotspots?: ScannerToggle;
     securityPosture?: ScannerToggle;
     serviceDependencies?: ScannerToggle;
+    architecture?: ScannerToggle;
 }
 interface VibgrateConfig {
     include?: string[];
@@ -246,6 +247,48 @@ interface ServiceDependenciesResult {
     storage: ServiceDependencyItem[];
     search: ServiceDependencyItem[];
 }
+/** Detected project archetype (fingerprint) */
+type ProjectArchetype = 'nextjs' | 'remix' | 'sveltekit' | 'nuxt' | 'nestjs' | 'express' | 'fastify' | 'hono' | 'koa' | 'serverless' | 'library' | 'cli' | 'monorepo' | 'unknown';
+/** Architectural layer classification */
+type ArchitectureLayer = 'routing' | 'middleware' | 'services' | 'domain' | 'data-access' | 'infrastructure' | 'presentation' | 'config' | 'testing' | 'shared';
+/** Per-layer aggregated data */
+interface LayerSummary {
+    /** The layer name */
+    layer: ArchitectureLayer;
+    /** Number of files in this layer */
+    fileCount: number;
+    /** Drift score for dependencies used in this layer (0–100) */
+    driftScore: number;
+    /** Risk level derived from drift score */
+    riskLevel: RiskLevel;
+    /** Tech stack components detected in this layer */
+    techStack: InventoryItem[];
+    /** Services/integrations used in this layer */
+    services: ServiceDependencyItem[];
+    /** Packages referenced in this layer with their drift status */
+    packages: LayerPackageRef[];
+}
+/** Package reference within a layer */
+interface LayerPackageRef {
+    name: string;
+    version: string | null;
+    latestStable: string | null;
+    majorsBehind: number | null;
+    drift: 'current' | 'minor-behind' | 'major-behind' | 'unknown';
+}
+/** Full architecture detection result */
+interface ArchitectureResult {
+    /** Detected project archetype */
+    archetype: ProjectArchetype;
+    /** Confidence of archetype detection (0–1) */
+    archetypeConfidence: number;
+    /** Per-layer summaries with drift + tech data */
+    layers: LayerSummary[];
+    /** Total files classified */
+    totalClassified: number;
+    /** Files that could not be classified */
+    unclassified: number;
+}
 interface ExtendedScanResults {
     platformMatrix?: PlatformMatrixResult;
     dependencyRisk?: DependencyRiskResult;
@@ -257,6 +300,7 @@ interface ExtendedScanResults {
     fileHotspots?: FileHotspotsResult;
     securityPosture?: SecurityPostureResult;
     serviceDependencies?: ServiceDependenciesResult;
+    architecture?: ArchitectureResult;
 }
 
 declare function runScan(rootDir: string, opts: ScanOptions): Promise<ScanArtifact>;

package/dist/index.js

@@ -7,7 +7,7 @@ import {
   formatText,
   generateFindings,
   runScan
-} from "./chunk-S4C6KWCP.js";
+} from "./chunk-QZV77UWV.js";
 export {
   computeDriftScore,
   formatMarkdown,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibgrate/cli",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "CLI for measuring upgrade drift across Node & .NET projects",
   "type": "module",
   "bin": {