@ipation/specbridge 1.0.5 → 1.1.0

package/dist/cli.js

@@ -1,18 +1,19 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { Command as Command12 } from "commander";
-import chalk12 from "chalk";
-import { readFileSync } from "fs";
-import { fileURLToPath } from "url";
-import { dirname as dirname3, join as join9 } from "path";
+import { Command as Command16 } from "commander";
+import chalk14 from "chalk";
+import { readFileSync as readFileSync2 } from "fs";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { dirname as dirname4, join as join10 } from "path";
 
 // src/core/errors/index.ts
 var SpecBridgeError = class extends Error {
-  constructor(message, code, details) {
+  constructor(message, code, details, suggestion) {
     super(message);
     this.code = code;
     this.details = details;
+    this.suggestion = suggestion;
     this.name = "SpecBridgeError";
     Error.captureStackTrace(this, this.constructor);
   }
@@ -38,15 +39,15 @@ var DecisionNotFoundError = class extends SpecBridgeError {
   }
 };
 var FileSystemError = class extends SpecBridgeError {
-  constructor(message, path) {
-    super(message, "FILE_SYSTEM_ERROR", { path });
-    this.path = path;
+  constructor(message, path5) {
+    super(message, "FILE_SYSTEM_ERROR", { path: path5 });
+    this.path = path5;
     this.name = "FileSystemError";
   }
 };
 var AlreadyInitializedError = class extends SpecBridgeError {
-  constructor(path) {
-    super(`SpecBridge is already initialized at ${path}`, "ALREADY_INITIALIZED", { path });
+  constructor(path5) {
+    super(`SpecBridge is already initialized at ${path5}`, "ALREADY_INITIALIZED", { path: path5 });
     this.name = "AlreadyInitializedError";
   }
 };
@@ -54,7 +55,9 @@ var NotInitializedError = class extends SpecBridgeError {
   constructor() {
     super(
       'SpecBridge is not initialized. Run "specbridge init" first.',
-      "NOT_INITIALIZED"
+      "NOT_INITIALIZED",
+      void 0,
+      "Run `specbridge init` in this directory to create .specbridge/"
     );
     this.name = "NotInitializedError";
   }
@@ -78,6 +81,10 @@ ${detailsStr}`;
     if (error instanceof DecisionValidationError && error.validationErrors.length > 0) {
       message += "\nValidation errors:\n" + error.validationErrors.map((e) => `  - ${e}`).join("\n");
     }
+    if (error.suggestion) {
+      message += `
+Suggestion: ${error.suggestion}`;
+    }
     return message;
   }
   return `Error: ${error.message}`;
@@ -93,23 +100,23 @@ import { join as join2 } from "path";
 import { readFile, writeFile, mkdir, access, readdir, stat } from "fs/promises";
 import { join, dirname } from "path";
 import { constants } from "fs";
-async function pathExists(path) {
+async function pathExists(path5) {
   try {
-    await access(path, constants.F_OK);
+    await access(path5, constants.F_OK);
     return true;
   } catch {
     return false;
   }
 }
-async function ensureDir(path) {
-  await mkdir(path, { recursive: true });
+async function ensureDir(path5) {
+  await mkdir(path5, { recursive: true });
 }
-async function readTextFile(path) {
-  return readFile(path, "utf-8");
+async function readTextFile(path5) {
+  return readFile(path5, "utf-8");
 }
-async function writeTextFile(path, content) {
-  await ensureDir(dirname(path));
-  await writeFile(path, content, "utf-8");
+async function writeTextFile(path5, content) {
+  await ensureDir(dirname(path5));
+  await writeFile(path5, content, "utf-8");
 }
 async function readFilesInDir(dirPath, filter) {
   try {
@@ -419,8 +426,8 @@ var CodeScanner = class {
   /**
    * Get a specific file
    */
-  getFile(path) {
-    return this.scannedFiles.get(path);
+  getFile(path5) {
+    return this.scannedFiles.get(path5);
   }
   /**
    * Get project instance for advanced analysis
@@ -433,12 +440,12 @@ var CodeScanner = class {
    */
   findClasses() {
     const classes = [];
-    for (const { path, sourceFile } of this.scannedFiles.values()) {
+    for (const { path: path5, sourceFile } of this.scannedFiles.values()) {
       for (const classDecl of sourceFile.getClasses()) {
         const name = classDecl.getName();
         if (name) {
           classes.push({
-            file: path,
+            file: path5,
             name,
             line: classDecl.getStartLineNumber()
           });
@@ -452,12 +459,12 @@ var CodeScanner = class {
    */
   findFunctions() {
     const functions = [];
-    for (const { path, sourceFile } of this.scannedFiles.values()) {
+    for (const { path: path5, sourceFile } of this.scannedFiles.values()) {
       for (const funcDecl of sourceFile.getFunctions()) {
         const name = funcDecl.getName();
         if (name) {
           functions.push({
-            file: path,
+            file: path5,
             name,
             line: funcDecl.getStartLineNumber(),
             isExported: funcDecl.isExported()
@@ -468,7 +475,7 @@ var CodeScanner = class {
         const init = varDecl.getInitializer();
         if (init && Node.isArrowFunction(init)) {
           functions.push({
-            file: path,
+            file: path5,
             name: varDecl.getName(),
             line: varDecl.getStartLineNumber(),
             isExported: varDecl.isExported()
@@ -483,12 +490,12 @@ var CodeScanner = class {
    */
   findImports() {
     const imports = [];
-    for (const { path, sourceFile } of this.scannedFiles.values()) {
+    for (const { path: path5, sourceFile } of this.scannedFiles.values()) {
       for (const importDecl of sourceFile.getImportDeclarations()) {
         const module = importDecl.getModuleSpecifierValue();
         const namedImports = importDecl.getNamedImports().map((n) => n.getName());
         imports.push({
-          file: path,
+          file: path5,
           module,
           named: namedImports,
           line: importDecl.getStartLineNumber()
@@ -502,10 +509,10 @@ var CodeScanner = class {
    */
   findInterfaces() {
     const interfaces = [];
-    for (const { path, sourceFile } of this.scannedFiles.values()) {
+    for (const { path: path5, sourceFile } of this.scannedFiles.values()) {
       for (const interfaceDecl of sourceFile.getInterfaces()) {
         interfaces.push({
-          file: path,
+          file: path5,
           name: interfaceDecl.getName(),
           line: interfaceDecl.getStartLineNumber()
         });
@@ -518,10 +525,10 @@ var CodeScanner = class {
    */
   findTypeAliases() {
     const types = [];
-    for (const { path, sourceFile } of this.scannedFiles.values()) {
+    for (const { path: path5, sourceFile } of this.scannedFiles.values()) {
       for (const typeAlias of sourceFile.getTypeAliases()) {
         types.push({
-          file: path,
+          file: path5,
           name: typeAlias.getName(),
           line: typeAlias.getStartLineNumber()
         });
@@ -534,13 +541,13 @@ var CodeScanner = class {
    */
   findTryCatchBlocks() {
     const blocks = [];
-    for (const { path, sourceFile } of this.scannedFiles.values()) {
+    for (const { path: path5, sourceFile } of this.scannedFiles.values()) {
       sourceFile.forEachDescendant((node) => {
         if (Node.isTryStatement(node)) {
           const catchClause = node.getCatchClause();
           const hasThrow = catchClause ? catchClause.getDescendantsOfKind(SyntaxKind.ThrowStatement).length > 0 : false;
           blocks.push({
-            file: path,
+            file: path5,
             line: node.getStartLineNumber(),
             hasThrow
           });
@@ -1105,7 +1112,7 @@ var ErrorsAnalyzer = class {
     let throwNewError = 0;
     let throwCustom = 0;
     const examples = [];
-    for (const { path, sourceFile } of files) {
+    for (const { path: path5, sourceFile } of files) {
       sourceFile.forEachDescendant((node) => {
         if (Node2.isThrowStatement(node)) {
           const expression = node.getExpression();
@@ -1118,7 +1125,7 @@ var ErrorsAnalyzer = class {
               if (examples.length < 3) {
                 const snippet = text.length > 50 ? text.slice(0, 50) + "..." : text;
                 examples.push({
-                  file: path,
+                  file: path5,
                   line: node.getStartLineNumber(),
                   snippet: `throw ${snippet}`
                 });
@@ -1415,8 +1422,8 @@ function validateDecision(data) {
 }
 function formatValidationErrors(errors) {
   return errors.errors.map((err) => {
-    const path = err.path.join(".");
-    return `${path}: ${err.message}`;
+    const path5 = err.path.join(".");
+    return `${path5}: ${err.message}`;
   });
 }
 
@@ -1795,6 +1802,7 @@ var NamingVerifier = class {
 };
 
 // src/verification/verifiers/imports.ts
+import path from "path";
 var ImportsVerifier = class {
   id = "imports";
   name = "Import Pattern Verifier";
@@ -1803,6 +1811,39 @@ var ImportsVerifier = class {
     const violations = [];
     const { sourceFile, constraint, decisionId, filePath } = ctx;
     const rule = constraint.rule.toLowerCase();
+    if (rule.includes(".js") && rule.includes("extension") || rule.includes("esm") || rule.includes("add .js")) {
+      for (const importDecl of sourceFile.getImportDeclarations()) {
+        const moduleSpec = importDecl.getModuleSpecifierValue();
+        if (!moduleSpec.startsWith(".")) continue;
+        const ext = path.posix.extname(moduleSpec);
+        let suggested = null;
+        if (!ext) {
+          suggested = `${moduleSpec}.js`;
+        } else if (ext === ".ts" || ext === ".tsx" || ext === ".jsx") {
+          suggested = moduleSpec.slice(0, -ext.length) + ".js";
+        } else if (ext !== ".js") {
+          continue;
+        }
+        if (!suggested || suggested === moduleSpec) continue;
+        const ms = importDecl.getModuleSpecifier();
+        const start = ms.getStart() + 1;
+        const end = ms.getEnd() - 1;
+        violations.push(createViolation({
+          decisionId,
+          constraintId: constraint.id,
+          type: constraint.type,
+          severity: constraint.severity,
+          message: `Relative import "${moduleSpec}" should include a .js extension`,
+          file: filePath,
+          line: importDecl.getStartLineNumber(),
+          suggestion: `Update to "${suggested}"`,
+          autofix: {
+            description: "Add/normalize .js extension in import specifier",
+            edits: [{ start, end, text: suggested }]
+          }
+        }));
+      }
+    }
     if (rule.includes("barrel") || rule.includes("index")) {
       for (const importDecl of sourceFile.getImportDeclarations()) {
         const moduleSpec = importDecl.getModuleSpecifierValue();
@@ -2041,12 +2082,590 @@ var RegexVerifier = class {
   }
 };
 
+// src/verification/verifiers/dependencies.ts
+import path2 from "path";
+var graphCache = /* @__PURE__ */ new WeakMap();
+function normalizeFsPath(p) {
+  return p.replaceAll("\\", "/");
+}
+function joinLike(fromFilePath, relative2) {
+  const fromNorm = normalizeFsPath(fromFilePath);
+  const relNorm = normalizeFsPath(relative2);
+  if (path2.isAbsolute(fromNorm)) {
+    return normalizeFsPath(path2.resolve(path2.dirname(fromNorm), relNorm));
+  }
+  const dir = path2.posix.dirname(fromNorm);
+  return path2.posix.normalize(path2.posix.join(dir, relNorm));
+}
+function resolveToSourceFilePath(project, fromFilePath, moduleSpec) {
+  if (!moduleSpec.startsWith(".")) return null;
+  const candidates = [];
+  const raw = joinLike(fromFilePath, moduleSpec);
+  const addCandidate = (p) => candidates.push(normalizeFsPath(p));
+  const ext = path2.posix.extname(raw);
+  if (ext) {
+    addCandidate(raw);
+    if (ext === ".js") addCandidate(raw.slice(0, -3) + ".ts");
+    if (ext === ".jsx") addCandidate(raw.slice(0, -4) + ".tsx");
+    if (ext === ".ts") addCandidate(raw.slice(0, -3) + ".js");
+    if (ext === ".tsx") addCandidate(raw.slice(0, -4) + ".jsx");
+    addCandidate(path2.posix.join(raw.replace(/\/$/, ""), "index.ts"));
+    addCandidate(path2.posix.join(raw.replace(/\/$/, ""), "index.tsx"));
+    addCandidate(path2.posix.join(raw.replace(/\/$/, ""), "index.js"));
+    addCandidate(path2.posix.join(raw.replace(/\/$/, ""), "index.jsx"));
+  } else {
+    addCandidate(raw + ".ts");
+    addCandidate(raw + ".tsx");
+    addCandidate(raw + ".js");
+    addCandidate(raw + ".jsx");
+    addCandidate(path2.posix.join(raw, "index.ts"));
+    addCandidate(path2.posix.join(raw, "index.tsx"));
+    addCandidate(path2.posix.join(raw, "index.js"));
+    addCandidate(path2.posix.join(raw, "index.jsx"));
+  }
+  for (const candidate of candidates) {
+    const sf = project.getSourceFile(candidate);
+    if (sf) return sf.getFilePath();
+  }
+  return null;
+}
+function buildDependencyGraph(project) {
+  const cached = graphCache.get(project);
+  const sourceFiles = project.getSourceFiles();
+  if (cached && cached.fileCount === sourceFiles.length) {
+    return cached.graph;
+  }
+  const graph = /* @__PURE__ */ new Map();
+  for (const sf of sourceFiles) {
+    const from = normalizeFsPath(sf.getFilePath());
+    if (!graph.has(from)) graph.set(from, /* @__PURE__ */ new Set());
+    for (const importDecl of sf.getImportDeclarations()) {
+      const moduleSpec = importDecl.getModuleSpecifierValue();
+      const resolved = resolveToSourceFilePath(project, from, moduleSpec);
+      if (resolved) {
+        graph.get(from).add(normalizeFsPath(resolved));
+      }
+    }
+  }
+  graphCache.set(project, { fileCount: sourceFiles.length, graph });
+  return graph;
+}
+function tarjanScc(graph) {
+  let index = 0;
+  const stack = [];
+  const onStack = /* @__PURE__ */ new Set();
+  const indices = /* @__PURE__ */ new Map();
+  const lowlink = /* @__PURE__ */ new Map();
+  const result = [];
+  const strongConnect = (v) => {
+    indices.set(v, index);
+    lowlink.set(v, index);
+    index++;
+    stack.push(v);
+    onStack.add(v);
+    const edges = graph.get(v) || /* @__PURE__ */ new Set();
+    for (const w of edges) {
+      if (!indices.has(w)) {
+        strongConnect(w);
+        lowlink.set(v, Math.min(lowlink.get(v), lowlink.get(w)));
+      } else if (onStack.has(w)) {
+        lowlink.set(v, Math.min(lowlink.get(v), indices.get(w)));
+      }
+    }
+    if (lowlink.get(v) === indices.get(v)) {
+      const scc = [];
+      while (stack.length > 0) {
+        const w = stack.pop();
+        if (!w) break;
+        onStack.delete(w);
+        scc.push(w);
+        if (w === v) break;
+      }
+      result.push(scc);
+    }
+  };
+  for (const v of graph.keys()) {
+    if (!indices.has(v)) strongConnect(v);
+  }
+  return result;
+}
+function parseMaxImportDepth(rule) {
+  const m = rule.match(/maximum\s+import\s+depth\s*[:=]?\s*(\d+)/i);
+  return m ? Number.parseInt(m[1], 10) : null;
+}
+function parseBannedDependency(rule) {
+  const m = rule.match(/no\s+dependencies?\s+on\s+(?:package\s+)?(.+?)(?:\.|$)/i);
+  if (!m) return null;
+  const value = m[1].trim();
+  return value.length > 0 ? value : null;
+}
+function parseLayerRule(rule) {
+  const m = rule.match(/(\w+)\s+layer\s+cannot\s+depend\s+on\s+(\w+)\s+layer/i);
+  if (!m) return null;
+  return { fromLayer: m[1].toLowerCase(), toLayer: m[2].toLowerCase() };
+}
+function fileInLayer(filePath, layer) {
+  const fp = normalizeFsPath(filePath).toLowerCase();
+  return fp.includes(`/${layer}/`) || fp.endsWith(`/${layer}.ts`) || fp.endsWith(`/${layer}.tsx`);
+}
+var DependencyVerifier = class {
+  id = "dependencies";
+  name = "Dependency Verifier";
+  description = "Checks dependency constraints, import depth, and circular dependencies";
+  async verify(ctx) {
+    const violations = [];
+    const { sourceFile, constraint, decisionId, filePath } = ctx;
+    const rule = constraint.rule;
+    const lowerRule = rule.toLowerCase();
+    const project = sourceFile.getProject();
+    const projectFilePath = normalizeFsPath(sourceFile.getFilePath());
+    if (lowerRule.includes("circular") || lowerRule.includes("cycle")) {
+      const graph = buildDependencyGraph(project);
+      const sccs = tarjanScc(graph);
+      const current = projectFilePath;
+      for (const scc of sccs) {
+        const hasSelfLoop = scc.length === 1 && (graph.get(scc[0])?.has(scc[0]) ?? false);
+        const isCycle = scc.length > 1 || hasSelfLoop;
+        if (!isCycle) continue;
+        if (!scc.includes(current)) continue;
+        const sorted = [...scc].sort();
+        if (sorted[0] !== current) continue;
+        violations.push(createViolation({
+          decisionId,
+          constraintId: constraint.id,
+          type: constraint.type,
+          severity: constraint.severity,
+          message: `Circular dependency detected across: ${sorted.join(" -> ")}`,
+          file: filePath,
+          line: 1,
+          suggestion: "Break the cycle by extracting shared abstractions or reversing the dependency"
+        }));
+      }
+    }
+    const layerRule = parseLayerRule(rule);
+    if (layerRule && fileInLayer(projectFilePath, layerRule.fromLayer)) {
+      for (const importDecl of sourceFile.getImportDeclarations()) {
+        const moduleSpec = importDecl.getModuleSpecifierValue();
+        const resolved = resolveToSourceFilePath(project, projectFilePath, moduleSpec);
+        if (!resolved) continue;
+        if (fileInLayer(resolved, layerRule.toLayer)) {
+          violations.push(createViolation({
+            decisionId,
+            constraintId: constraint.id,
+            type: constraint.type,
+            severity: constraint.severity,
+            message: `Layer violation: ${layerRule.fromLayer} depends on ${layerRule.toLayer} via import "${moduleSpec}"`,
+            file: filePath,
+            line: importDecl.getStartLineNumber(),
+            suggestion: `Refactor to remove dependency from ${layerRule.fromLayer} to ${layerRule.toLayer}`
+          }));
+        }
+      }
+    }
+    const banned = parseBannedDependency(rule);
+    if (banned) {
+      const bannedLower = banned.toLowerCase();
+      for (const importDecl of sourceFile.getImportDeclarations()) {
+        const moduleSpec = importDecl.getModuleSpecifierValue();
+        if (moduleSpec.toLowerCase().includes(bannedLower)) {
+          violations.push(createViolation({
+            decisionId,
+            constraintId: constraint.id,
+            type: constraint.type,
+            severity: constraint.severity,
+            message: `Banned dependency import detected: "${moduleSpec}"`,
+            file: filePath,
+            line: importDecl.getStartLineNumber(),
+            suggestion: `Remove or replace dependency "${banned}"`
+          }));
+        }
+      }
+    }
+    const maxDepth = parseMaxImportDepth(rule);
+    if (maxDepth !== null) {
+      for (const importDecl of sourceFile.getImportDeclarations()) {
+        const moduleSpec = importDecl.getModuleSpecifierValue();
+        if (!moduleSpec.startsWith(".")) continue;
+        const depth = (moduleSpec.match(/\.\.\//g) || []).length;
+        if (depth > maxDepth) {
+          violations.push(createViolation({
+            decisionId,
+            constraintId: constraint.id,
+            type: constraint.type,
+            severity: constraint.severity,
+            message: `Import depth ${depth} exceeds maximum ${maxDepth}: "${moduleSpec}"`,
+            file: filePath,
+            line: importDecl.getStartLineNumber(),
+            suggestion: "Use a shallower module boundary (or introduce a public entrypoint for this dependency)"
+          }));
+        }
+      }
+    }
+    return violations;
+  }
+};
+
+// src/verification/verifiers/complexity.ts
+import { SyntaxKind as SyntaxKind2 } from "ts-morph";
+function parseLimit(rule, pattern) {
+  const m = rule.match(pattern);
+  return m ? Number.parseInt(m[1], 10) : null;
+}
+function getFileLineCount(text) {
+  if (text.length === 0) return 0;
+  return text.split("\n").length;
+}
+function getDecisionPoints(fn) {
+  let points = 0;
+  for (const d of fn.getDescendants()) {
+    switch (d.getKind()) {
+      case SyntaxKind2.IfStatement:
+      case SyntaxKind2.ForStatement:
+      case SyntaxKind2.ForInStatement:
+      case SyntaxKind2.ForOfStatement:
+      case SyntaxKind2.WhileStatement:
+      case SyntaxKind2.DoStatement:
+      case SyntaxKind2.CatchClause:
+      case SyntaxKind2.ConditionalExpression:
+      case SyntaxKind2.CaseClause:
+        points++;
+        break;
+      case SyntaxKind2.BinaryExpression: {
+        const text = d.getText();
+        if (text.includes("&&") || text.includes("||")) points++;
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return points;
+}
+function calculateCyclomaticComplexity(fn) {
+  return 1 + getDecisionPoints(fn);
+}
+function getFunctionDisplayName(fn) {
+  if ("getName" in fn && typeof fn.getName === "function") {
+    const name = fn.getName();
+    if (typeof name === "string" && name.length > 0) return name;
+  }
+  const parent = fn.getParent();
+  if (parent?.getKind() === SyntaxKind2.VariableDeclaration) {
+    const vd = parent;
+    if (typeof vd.getName === "function") return vd.getName();
+  }
+  return "<anonymous>";
+}
+function maxNestingDepth(node) {
+  let maxDepth = 0;
+  const walk = (n, depth) => {
+    maxDepth = Math.max(maxDepth, depth);
+    const kind = n.getKind();
+    const isNestingNode = kind === SyntaxKind2.IfStatement || kind === SyntaxKind2.ForStatement || kind === SyntaxKind2.ForInStatement || kind === SyntaxKind2.ForOfStatement || kind === SyntaxKind2.WhileStatement || kind === SyntaxKind2.DoStatement || kind === SyntaxKind2.SwitchStatement || kind === SyntaxKind2.TryStatement;
+    for (const child of n.getChildren()) {
+      if (child.getKind() === SyntaxKind2.FunctionDeclaration || child.getKind() === SyntaxKind2.FunctionExpression || child.getKind() === SyntaxKind2.ArrowFunction || child.getKind() === SyntaxKind2.MethodDeclaration) {
+        continue;
+      }
+      walk(child, isNestingNode ? depth + 1 : depth);
+    }
+  };
+  walk(node, 0);
+  return maxDepth;
+}
+var ComplexityVerifier = class {
+  id = "complexity";
+  name = "Complexity Verifier";
+  description = "Checks cyclomatic complexity, file size, parameters, and nesting depth";
+  async verify(ctx) {
+    const violations = [];
+    const { sourceFile, constraint, decisionId, filePath } = ctx;
+    const rule = constraint.rule;
+    const maxComplexity = parseLimit(rule, /complexity\s+(?:must\s+)?not\s+exceed\s+(\d+)/i);
+    const maxLines = parseLimit(rule, /file\s+size\s+(?:must\s+)?not\s+exceed\s+(\d+)\s+lines?/i);
+    const maxParams = parseLimit(rule, /at\s+most\s+(\d+)\s+parameters?/i) ?? parseLimit(rule, /parameters?\s+(?:must\s+)?not\s+exceed\s+(\d+)/i);
+    const maxNesting = parseLimit(rule, /nesting\s+depth\s+(?:must\s+)?not\s+exceed\s+(\d+)/i);
+    if (maxLines !== null) {
+      const lineCount = getFileLineCount(sourceFile.getFullText());
+      if (lineCount > maxLines) {
+        violations.push(createViolation({
+          decisionId,
+          constraintId: constraint.id,
+          type: constraint.type,
+          severity: constraint.severity,
+          message: `File has ${lineCount} lines which exceeds maximum ${maxLines}`,
+          file: filePath,
+          line: 1,
+          suggestion: "Split the file into smaller modules"
+        }));
+      }
+    }
+    const functionLikes = [
+      ...sourceFile.getDescendantsOfKind(SyntaxKind2.FunctionDeclaration),
+      ...sourceFile.getDescendantsOfKind(SyntaxKind2.FunctionExpression),
+      ...sourceFile.getDescendantsOfKind(SyntaxKind2.ArrowFunction),
+      ...sourceFile.getDescendantsOfKind(SyntaxKind2.MethodDeclaration)
+    ];
+    for (const fn of functionLikes) {
+      const fnName = getFunctionDisplayName(fn);
+      if (maxComplexity !== null) {
+        const complexity = calculateCyclomaticComplexity(fn);
+        if (complexity > maxComplexity) {
+          violations.push(createViolation({
+            decisionId,
+            constraintId: constraint.id,
+            type: constraint.type,
+            severity: constraint.severity,
+            message: `Function ${fnName} has cyclomatic complexity ${complexity} which exceeds maximum ${maxComplexity}`,
+            file: filePath,
+            line: fn.getStartLineNumber(),
+            suggestion: "Refactor to reduce branching or extract smaller functions"
+          }));
+        }
+      }
+      if (maxParams !== null && "getParameters" in fn) {
+        const params = fn.getParameters();
+        const paramCount = Array.isArray(params) ? params.length : 0;
+        if (paramCount > maxParams) {
+          violations.push(createViolation({
+            decisionId,
+            constraintId: constraint.id,
+            type: constraint.type,
+            severity: constraint.severity,
+            message: `Function ${fnName} has ${paramCount} parameters which exceeds maximum ${maxParams}`,
+            file: filePath,
+            line: fn.getStartLineNumber(),
+            suggestion: "Consider grouping parameters into an options object"
+          }));
+        }
+      }
+      if (maxNesting !== null) {
+        const depth = maxNestingDepth(fn);
+        if (depth > maxNesting) {
+          violations.push(createViolation({
+            decisionId,
+            constraintId: constraint.id,
+            type: constraint.type,
+            severity: constraint.severity,
+            message: `Function ${fnName} has nesting depth ${depth} which exceeds maximum ${maxNesting}`,
+            file: filePath,
+            line: fn.getStartLineNumber(),
+            suggestion: "Reduce nesting by using early returns or extracting functions"
+          }));
+        }
+      }
+    }
+    return violations;
+  }
+};
+
+// src/verification/verifiers/security.ts
+import { SyntaxKind as SyntaxKind3 } from "ts-morph";
+var SECRET_NAME_RE = /(api[_-]?key|password|secret|token)/i;
+function isStringLiteralLike(node) {
+  const k = node.getKind();
+  return k === SyntaxKind3.StringLiteral || k === SyntaxKind3.NoSubstitutionTemplateLiteral;
+}
+var SecurityVerifier = class {
+  id = "security";
+  name = "Security Verifier";
+  description = "Detects common security footguns (secrets, eval, XSS/SQL injection heuristics)";
+  async verify(ctx) {
+    const violations = [];
+    const { sourceFile, constraint, decisionId, filePath } = ctx;
+    const rule = constraint.rule.toLowerCase();
+    const checkSecrets = rule.includes("secret") || rule.includes("password") || rule.includes("token") || rule.includes("api key") || rule.includes("hardcoded");
+    const checkEval = rule.includes("eval") || rule.includes("function constructor");
+    const checkXss = rule.includes("xss") || rule.includes("innerhtml") || rule.includes("dangerouslysetinnerhtml");
+    const checkSql = rule.includes("sql") || rule.includes("injection");
+    const checkProto = rule.includes("prototype pollution") || rule.includes("__proto__");
+    if (checkSecrets) {
+      for (const vd of sourceFile.getVariableDeclarations()) {
+        const name = vd.getName();
+        if (!SECRET_NAME_RE.test(name)) continue;
+        const init = vd.getInitializer();
+        if (!init || !isStringLiteralLike(init)) continue;
+        const value = init.getText().slice(1, -1);
+        if (value.length === 0) continue;
+        violations.push(createViolation({
+          decisionId,
+          constraintId: constraint.id,
+          type: constraint.type,
+          severity: constraint.severity,
+          message: `Possible hardcoded secret in variable "${name}"`,
+          file: filePath,
+          line: vd.getStartLineNumber(),
+          suggestion: "Move secrets to environment variables or a secret manager"
+        }));
+      }
+      for (const pa of sourceFile.getDescendantsOfKind(SyntaxKind3.PropertyAssignment)) {
+        const nameNode = pa.getNameNode?.();
+        const propName = nameNode?.getText?.() ?? "";
+        if (!SECRET_NAME_RE.test(propName)) continue;
+        const init = pa.getInitializer();
+        if (!init || !isStringLiteralLike(init)) continue;
+        violations.push(createViolation({
+          decisionId,
+          constraintId: constraint.id,
+          type: constraint.type,
+          severity: constraint.severity,
+          message: `Possible hardcoded secret in object property ${propName}`,
+          file: filePath,
+          line: pa.getStartLineNumber(),
+          suggestion: "Move secrets to environment variables or a secret manager"
+        }));
+      }
+    }
+    if (checkEval) {
+      for (const call of sourceFile.getDescendantsOfKind(SyntaxKind3.CallExpression)) {
+        const exprText = call.getExpression().getText();
+        if (exprText === "eval" || exprText === "Function") {
+          violations.push(createViolation({
+            decisionId,
+            constraintId: constraint.id,
+            type: constraint.type,
+            severity: constraint.severity,
+            message: `Unsafe dynamic code execution via ${exprText}()`,
+            file: filePath,
+            line: call.getStartLineNumber(),
+            suggestion: "Avoid eval/Function; use safer alternatives"
+          }));
+        }
+      }
+    }
+    if (checkXss) {
+      for (const bin of sourceFile.getDescendantsOfKind(SyntaxKind3.BinaryExpression)) {
+        const left = bin.getLeft();
+        if (left.getKind() !== SyntaxKind3.PropertyAccessExpression) continue;
+        const pa = left;
+        if (pa.getName?.() === "innerHTML") {
+          violations.push(createViolation({
+            decisionId,
+            constraintId: constraint.id,
+            type: constraint.type,
+            severity: constraint.severity,
+            message: "Potential XSS: assignment to innerHTML",
+            file: filePath,
+            line: bin.getStartLineNumber(),
+            suggestion: "Prefer textContent or a safe templating/escaping strategy"
+          }));
+        }
+      }
+      if (sourceFile.getFullText().includes("dangerouslySetInnerHTML")) {
+        violations.push(createViolation({
+          decisionId,
+          constraintId: constraint.id,
+          type: constraint.type,
+          severity: constraint.severity,
+          message: "Potential XSS: usage of dangerouslySetInnerHTML",
+          file: filePath,
+          line: 1,
+          suggestion: "Avoid dangerouslySetInnerHTML or ensure content is sanitized"
+        }));
+      }
+    }
+    if (checkSql) {
+      for (const call of sourceFile.getDescendantsOfKind(SyntaxKind3.CallExpression)) {
+        const expr = call.getExpression();
+        if (expr.getKind() !== SyntaxKind3.PropertyAccessExpression) continue;
+        const name = expr.getName?.();
+        if (name !== "query" && name !== "execute") continue;
+        const arg = call.getArguments()[0];
+        if (!arg) continue;
+        const isTemplate = arg.getKind() === SyntaxKind3.TemplateExpression;
+        const isConcat = arg.getKind() === SyntaxKind3.BinaryExpression && arg.getText().includes("+");
+        if (!isTemplate && !isConcat) continue;
+        const text = arg.getText().toLowerCase();
+        if (!text.includes("select") && !text.includes("insert") && !text.includes("update") && !text.includes("delete")) {
+          continue;
+        }
+        violations.push(createViolation({
+          decisionId,
+          constraintId: constraint.id,
+          type: constraint.type,
+          severity: constraint.severity,
+          message: "Potential SQL injection: dynamically constructed SQL query",
+          file: filePath,
+          line: call.getStartLineNumber(),
+          suggestion: "Use parameterized queries / prepared statements"
+        }));
+      }
+    }
+    if (checkProto) {
+      const text = sourceFile.getFullText();
+      if (text.includes("__proto__") || text.includes("constructor.prototype")) {
+        violations.push(createViolation({
+          decisionId,
+          constraintId: constraint.id,
+          type: constraint.type,
+          severity: constraint.severity,
+          message: "Potential prototype pollution pattern detected",
+          file: filePath,
+          line: 1,
+          suggestion: "Avoid writing to __proto__/prototype; validate object keys"
+        }));
+      }
+    }
+    return violations;
+  }
+};
+
+// src/verification/verifiers/api.ts
+import { SyntaxKind as SyntaxKind4 } from "ts-morph";
+var HTTP_METHODS = /* @__PURE__ */ new Set(["get", "post", "put", "patch", "delete", "options", "head", "all"]);
+function isKebabPath(pathValue) {
+  const parts = pathValue.split("/").filter(Boolean);
+  for (const part of parts) {
+    if (part.startsWith(":")) continue;
+    if (!/^[a-z0-9-]+$/.test(part)) return false;
+  }
+  return true;
+}
+var ApiVerifier = class {
+  id = "api";
+  name = "API Consistency Verifier";
+  description = "Checks basic REST endpoint naming conventions in common frameworks";
+  async verify(ctx) {
+    const violations = [];
+    const { sourceFile, constraint, decisionId, filePath } = ctx;
+    const rule = constraint.rule.toLowerCase();
+    const enforceKebab = rule.includes("kebab") || rule.includes("kebab-case");
+    if (!enforceKebab) return violations;
+    for (const call of sourceFile.getDescendantsOfKind(SyntaxKind4.CallExpression)) {
+      const expr = call.getExpression();
+      if (expr.getKind() !== SyntaxKind4.PropertyAccessExpression) continue;
+      const method = expr.getName?.();
+      if (!method || !HTTP_METHODS.has(String(method))) continue;
+      const firstArg = call.getArguments()[0];
+      if (!firstArg || firstArg.getKind() !== SyntaxKind4.StringLiteral) continue;
+      const pathValue = firstArg.getLiteralValue?.() ?? firstArg.getText().slice(1, -1);
+      if (typeof pathValue !== "string") continue;
+      if (!isKebabPath(pathValue)) {
+        violations.push(createViolation({
+          decisionId,
+          constraintId: constraint.id,
+          type: constraint.type,
+          severity: constraint.severity,
+          message: `Endpoint path "${pathValue}" is not kebab-case`,
+          file: filePath,
+          line: call.getStartLineNumber(),
+          suggestion: "Use lowercase and hyphens in static path segments (e.g., /user-settings)"
+        }));
+      }
+    }
+    return violations;
+  }
+};
+
 // src/verification/verifiers/index.ts
 var builtinVerifiers = {
   naming: () => new NamingVerifier(),
   imports: () => new ImportsVerifier(),
   errors: () => new ErrorsVerifier(),
-  regex: () => new RegexVerifier()
+  regex: () => new RegexVerifier(),
+  dependencies: () => new DependencyVerifier(),
+  complexity: () => new ComplexityVerifier(),
+  security: () => new SecurityVerifier(),
+  api: () => new ApiVerifier()
 };
 function getVerifier(id) {
   const factory = builtinVerifiers[id];
@@ -2057,6 +2676,18 @@ function selectVerifierForConstraint(rule, specifiedVerifier) {
     return getVerifier(specifiedVerifier);
   }
   const lowerRule = rule.toLowerCase();
+  if (lowerRule.includes("dependency") || lowerRule.includes("circular dependenc") || lowerRule.includes("import depth") || lowerRule.includes("layer") && lowerRule.includes("depend on")) {
+    return getVerifier("dependencies");
+  }
+  if (lowerRule.includes("cyclomatic") || lowerRule.includes("complexity") || lowerRule.includes("nesting") || lowerRule.includes("parameters") || lowerRule.includes("file size")) {
+    return getVerifier("complexity");
+  }
+  if (lowerRule.includes("security") || lowerRule.includes("secret") || lowerRule.includes("password") || lowerRule.includes("token") || lowerRule.includes("xss") || lowerRule.includes("sql") || lowerRule.includes("eval")) {
+    return getVerifier("security");
+  }
+  if (lowerRule.includes("endpoint") || lowerRule.includes("rest") || lowerRule.includes("api") && lowerRule.includes("path")) {
+    return getVerifier("api");
+  }
   if (lowerRule.includes("naming") || lowerRule.includes("case")) {
     return getVerifier("naming");
   }
@@ -2072,10 +2703,60 @@ function selectVerifierForConstraint(rule, specifiedVerifier) {
   return getVerifier("regex");
 }
 
+// src/verification/cache.ts
+import { stat as stat2 } from "fs/promises";
+var AstCache = class {
+  cache = /* @__PURE__ */ new Map();
+  async get(filePath, project) {
+    try {
+      const info = await stat2(filePath);
+      const cached = this.cache.get(filePath);
+      if (cached && cached.mtimeMs >= info.mtimeMs) {
+        return cached.sourceFile;
+      }
+      let sourceFile = project.getSourceFile(filePath);
+      if (!sourceFile) {
+        sourceFile = project.addSourceFileAtPath(filePath);
+      } else {
+        sourceFile.refreshFromFileSystemSync();
+      }
+      this.cache.set(filePath, { sourceFile, mtimeMs: info.mtimeMs });
+      return sourceFile;
+    } catch {
+      return null;
+    }
+  }
+  clear() {
+    this.cache.clear();
+  }
+};
+
+// src/verification/applicability.ts
+function isConstraintExcepted(filePath, constraint, cwd) {
+  if (!constraint.exceptions) return false;
+  return constraint.exceptions.some((exception) => {
+    if (exception.expiresAt) {
+      const expiryDate = new Date(exception.expiresAt);
+      if (expiryDate < /* @__PURE__ */ new Date()) {
+        return false;
+      }
+    }
+    return matchesPattern(filePath, exception.pattern, { cwd });
+  });
+}
+function shouldApplyConstraintToFile(params) {
+  const { filePath, constraint, cwd, severityFilter } = params;
+  if (!matchesPattern(filePath, constraint.scope, { cwd })) return false;
+  if (severityFilter && !severityFilter.includes(constraint.severity)) return false;
+  if (isConstraintExcepted(filePath, constraint, cwd)) return false;
+  return true;
+}
+
 // src/verification/engine.ts
 var VerificationEngine = class {
   registry;
   project;
+  astCache;
   constructor(registry) {
     this.registry = registry || createRegistry();
     this.project = new Project2({
@@ -2087,6 +2768,7 @@ var VerificationEngine = class {
       },
       skipAddingFilesFromTsConfig: true
     });
+    this.astCache = new AstCache();
   }
   /**
    * Run verification
@@ -2129,8 +2811,8 @@ var VerificationEngine = class {
     let failed = 0;
     const skipped = 0;
     let timeoutHandle = null;
-    const timeoutPromise = new Promise((resolve) => {
-      timeoutHandle = setTimeout(() => resolve("timeout"), timeout);
+    const timeoutPromise = new Promise((resolve2) => {
+      timeoutHandle = setTimeout(() => resolve2("timeout"), timeout);
       timeoutHandle.unref();
     });
     const verificationPromise = this.verifyFiles(
@@ -2192,23 +2874,11 @@ var VerificationEngine = class {
    */
   async verifyFile(filePath, decisions, severityFilter, cwd = process.cwd()) {
     const violations = [];
-    let sourceFile = this.project.getSourceFile(filePath);
-    if (!sourceFile) {
-      try {
-        sourceFile = this.project.addSourceFileAtPath(filePath);
-      } catch {
-        return violations;
-      }
-    }
+    const sourceFile = await this.astCache.get(filePath, this.project);
+    if (!sourceFile) return violations;
     for (const decision of decisions) {
       for (const constraint of decision.constraints) {
-        if (!matchesPattern(filePath, constraint.scope, { cwd })) {
-          continue;
-        }
-        if (severityFilter && !severityFilter.includes(constraint.severity)) {
-          continue;
-        }
-        if (this.isExcepted(filePath, constraint, cwd)) {
+        if (!shouldApplyConstraintToFile({ filePath, constraint, cwd, severityFilter })) {
           continue;
         }
         const verifier = selectVerifierForConstraint(constraint.rule, constraint.verifier);
@@ -2234,25 +2904,16 @@ var VerificationEngine = class {
    * Verify multiple files
    */
   async verifyFiles(files, decisions, severityFilter, cwd, onFileVerified) {
-    for (const file of files) {
-      const violations = await this.verifyFile(file, decisions, severityFilter, cwd);
-      onFileVerified(violations);
-    }
-  }
-  /**
-   * Check if file is excepted from constraint
-   */
-  isExcepted(filePath, constraint, cwd) {
-    if (!constraint.exceptions) return false;
-    return constraint.exceptions.some((exception) => {
-      if (exception.expiresAt) {
-        const expiryDate = new Date(exception.expiresAt);
-        if (expiryDate < /* @__PURE__ */ new Date()) {
-          return false;
-        }
+    const BATCH_SIZE = 10;
+    for (let i = 0; i < files.length; i += BATCH_SIZE) {
+      const batch = files.slice(i, i + BATCH_SIZE);
+      const results = await Promise.all(
+        batch.map((file) => this.verifyFile(file, decisions, severityFilter, cwd))
+      );
+      for (const violations of results) {
+        onFileVerified(violations);
       }
-      return matchesPattern(filePath, exception.pattern, { cwd });
-    });
+    }
   }
   /**
    * Get registry
@@ -2265,8 +2926,111 @@ function createVerificationEngine(registry) {
   return new VerificationEngine(registry);
 }
 
+// src/verification/autofix/engine.ts
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import readline from "readline/promises";
+import { stdin, stdout } from "process";
+function applyEdits(content, edits) {
+  const sorted = [...edits].sort((a, b) => b.start - a.start);
+  let next = content;
+  const patches = [];
+  let skippedEdits = 0;
+  let lastStart = Number.POSITIVE_INFINITY;
+  for (const edit of sorted) {
+    if (edit.start < 0 || edit.end < edit.start || edit.end > next.length) {
+      skippedEdits++;
+      continue;
+    }
+    if (edit.end > lastStart) {
+      skippedEdits++;
+      continue;
+    }
+    lastStart = edit.start;
+    const originalText = next.slice(edit.start, edit.end);
+    next = next.slice(0, edit.start) + edit.text + next.slice(edit.end);
+    patches.push({
+      filePath: "",
+      description: edit.description,
+      start: edit.start,
+      end: edit.end,
+      originalText,
+      fixedText: edit.text
+    });
+  }
+  return { next, patches, skippedEdits };
+}
+async function confirmFix(prompt) {
+  const rl = readline.createInterface({ input: stdin, output: stdout });
+  try {
+    const answer = await rl.question(`${prompt} (y/N) `);
+    return answer.trim().toLowerCase() === "y";
+  } finally {
+    rl.close();
+  }
+}
+var AutofixEngine = class {
+  async applyFixes(violations, options = {}) {
+    const fixable = violations.filter((v) => v.autofix && v.autofix.edits.length > 0);
+    const byFile = /* @__PURE__ */ new Map();
+    for (const v of fixable) {
+      const list = byFile.get(v.file) ?? [];
+      list.push(v);
+      byFile.set(v.file, list);
+    }
+    const applied = [];
+    let skippedViolations = 0;
+    for (const [filePath, fileViolations] of byFile) {
+      const original = await readFile2(filePath, "utf-8");
+      const edits = [];
+      for (const violation of fileViolations) {
+        const fix = violation.autofix;
+        if (options.interactive) {
+          const ok = await confirmFix(`Apply fix: ${fix.description} (${filePath}:${violation.line ?? 1})?`);
+          if (!ok) {
+            skippedViolations++;
+            continue;
+          }
+        }
+        for (const edit of fix.edits) {
+          edits.push({ ...edit, description: fix.description });
+        }
+      }
+      if (edits.length === 0) continue;
+      const { next, patches, skippedEdits } = applyEdits(original, edits);
+      skippedViolations += skippedEdits;
+      if (!options.dryRun) {
+        await writeFile2(filePath, next, "utf-8");
+      }
+      for (const patch of patches) {
+        applied.push({ ...patch, filePath });
+      }
+    }
+    return { applied, skipped: skippedViolations };
+  }
+};
+
+// src/verification/incremental.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { resolve } from "path";
+var execFileAsync = promisify(execFile);
+async function getChangedFiles(cwd) {
+  try {
+    const { stdout: stdout2 } = await execFileAsync("git", ["diff", "--name-only", "--diff-filter=AM", "HEAD"], { cwd });
+    const rel = stdout2.trim().split("\n").map((s) => s.trim()).filter(Boolean);
+    const abs = [];
+    for (const file of rel) {
+      const full = resolve(cwd, file);
+      if (await pathExists(full)) abs.push(full);
+    }
+    return abs;
+  } catch {
+    return [];
+  }
+}
+
 // src/cli/commands/verify.ts
-var verifyCommand = new Command3("verify").description("Verify code compliance against decisions").option("-l, --level <level>", "Verification level (commit, pr, full)", "full").option("-f, --files <patterns>", "Comma-separated file patterns to check").option("-d, --decisions <ids>", "Comma-separated decision IDs to check").option("-s, --severity <levels>", "Comma-separated severity levels (critical, high, medium, low)").option("--json", "Output as JSON").option("--fix", "Attempt to auto-fix violations (not yet implemented)").action(async (options) => {
+var verifyCommand = new Command3("verify").description("Verify code compliance against decisions").option("-l, --level <level>", "Verification level (commit, pr, full)", "full").option("-f, --files <patterns>", "Comma-separated file patterns to check").option("-d, --decisions <ids>", "Comma-separated decision IDs to check").option("-s, --severity <levels>", "Comma-separated severity levels (critical, high, medium, low)").option("--json", "Output as JSON").option("--incremental", "Only verify changed files (git diff --name-only --diff-filter=AM HEAD)").option("--fix", "Apply auto-fixes for supported violations").option("--dry-run", "Show what would be fixed without applying (requires --fix)").option("--interactive", "Confirm each fix interactively (requires --fix)").action(async (options) => {
   const cwd = process.cwd();
   if (!await pathExists(getSpecBridgeDir(cwd))) {
     throw new NotInitializedError();
@@ -2275,23 +3039,60 @@ var verifyCommand = new Command3("verify").description("Verify code compliance a
   try {
     const config = await loadConfig(cwd);
     const level = options.level || "full";
-    const files = options.files?.split(",").map((f) => f.trim());
+    let files = options.files?.split(",").map((f) => f.trim());
     const decisions = options.decisions?.split(",").map((d) => d.trim());
     const severity = options.severity?.split(",").map((s) => s.trim());
+    if (options.incremental) {
+      const changed = await getChangedFiles(cwd);
+      files = changed.length > 0 ? changed : [];
+    }
     spinner.text = `Running ${level}-level verification...`;
     const engine = createVerificationEngine();
-    const result = await engine.verify(config, {
+    let result = await engine.verify(config, {
       level,
       files,
       decisions,
       severity,
       cwd
     });
+    let fixResult;
+    if (options.fix && result.violations.length > 0) {
+      const fixableCount = result.violations.filter((v) => v.autofix).length;
+      if (fixableCount === 0) {
+        spinner.stop();
+        if (!options.json) {
+          console.log(chalk3.yellow("No auto-fixable violations found"));
+        }
+      } else {
+        spinner.text = `Applying ${fixableCount} auto-fix(es)...`;
+        const fixer = new AutofixEngine();
+        fixResult = await fixer.applyFixes(result.violations, {
+          dryRun: options.dryRun,
+          interactive: options.interactive
+        });
+        if (!options.dryRun && fixResult.applied.length > 0) {
+          result = await engine.verify(config, {
+            level,
+            files,
+            decisions,
+            severity,
+            cwd
+          });
+        }
+      }
+    }
     spinner.stop();
     if (options.json) {
-      console.log(JSON.stringify(result, null, 2));
+      console.log(JSON.stringify({ ...result, autofix: fixResult }, null, 2));
     } else {
       printResult(result, level);
+      if (options.fix && fixResult) {
+        console.log(chalk3.green(`\u2713 Applied ${fixResult.applied.length} fix(es)`));
+        if (fixResult.skipped > 0) {
+          console.log(chalk3.yellow(`\u2298 Skipped ${fixResult.skipped} fix(es)`));
+        }
+        console.log("");
+      }
     }
     if (!result.success) {
       process.exit(1);
@@ -2748,17 +3549,10 @@ var HOOK_SCRIPT = `#!/bin/sh
 # SpecBridge pre-commit hook
 # Runs verification on staged files
 
-# Get list of staged TypeScript files
-STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep -E '\\.(ts|tsx)$')
-
-if [ -z "$STAGED_FILES" ]; then
-  exit 0
-fi
-
 echo "Running SpecBridge verification..."
 
-# Run specbridge verify on staged files
-npx specbridge hook run --level commit --files "$STAGED_FILES"
+# Run specbridge hook (it will detect staged files automatically)
+npx specbridge hook run --level commit
 
 exit $?
 `;
@@ -2840,7 +3634,18 @@ function createHookCommand() {
     try {
       const config = await loadConfig(cwd);
       const level = options.level || "commit";
-      const files = options.files ? options.files.split(/[\s,]+/).filter((f) => f.length > 0) : void 0;
+      let files = options.files ? options.files.split(/[\s,]+/).filter((f) => f.length > 0) : void 0;
+      if (!files || files.length === 0) {
+        const { execFile: execFile2 } = await import("child_process");
+        const { promisify: promisify2 } = await import("util");
+        const execFileAsync2 = promisify2(execFile2);
+        try {
+          const { stdout: stdout2 } = await execFileAsync2("git", ["diff", "--cached", "--name-only", "--diff-filter=AM"], { cwd });
+          files = stdout2.trim().split("\n").map((s) => s.trim()).filter(Boolean).filter((f) => /\.(ts|tsx|js|jsx)$/.test(f));
+        } catch {
+          files = [];
+        }
+      }
       if (!files || files.length === 0) {
         process.exit(0);
       }
@@ -3322,11 +4127,547 @@ var contextCommand = new Command11("context").description("Generate architectura
   }
 });
 
+// src/cli/commands/lsp.ts
+import { Command as Command12 } from "commander";
+
+// src/lsp/server.ts
+import { createConnection, ProposedFeatures, TextDocuments, TextDocumentSyncKind, DiagnosticSeverity, CodeActionKind } from "vscode-languageserver/node.js";
+import { TextDocument } from "vscode-languageserver-textdocument";
+import { fileURLToPath } from "url";
+import path3 from "path";
+import { Project as Project3 } from "ts-morph";
+import chalk12 from "chalk";
+function severityToDiagnostic(severity) {
+  switch (severity) {
+    case "critical":
+      return DiagnosticSeverity.Error;
+    case "high":
+      return DiagnosticSeverity.Warning;
+    case "medium":
+      return DiagnosticSeverity.Information;
+    case "low":
+      return DiagnosticSeverity.Hint;
+    default:
+      return DiagnosticSeverity.Information;
+  }
+}
+function uriToFilePath(uri) {
+  if (uri.startsWith("file://")) return fileURLToPath(uri);
+  return uri;
+}
+function violationToRange(doc, v) {
+  const edit = v.autofix?.edits?.[0];
+  if (edit) {
+    return {
+      start: doc.positionAt(edit.start),
+      end: doc.positionAt(edit.end)
+    };
+  }
+  const line = Math.max(0, (v.line ?? 1) - 1);
+  const char = Math.max(0, (v.column ?? 1) - 1);
+  return {
+    start: { line, character: char },
+    end: { line, character: char + 1 }
+  };
+}
+var SpecBridgeLspServer = class {
+  connection = createConnection(ProposedFeatures.all);
+  documents = new TextDocuments(TextDocument);
+  options;
+  registry = null;
+  decisions = [];
+  cwd;
+  project;
+  cache = /* @__PURE__ */ new Map();
+  initError = null;
+  constructor(options) {
+    this.options = options;
+    this.cwd = options.cwd;
+    this.project = new Project3({
+      compilerOptions: {
+        allowJs: true,
+        checkJs: false,
+        noEmit: true,
+        skipLibCheck: true
+      },
+      skipAddingFilesFromTsConfig: true
+    });
+  }
+  async initialize() {
+    this.connection.onInitialize(async () => {
+      await this.initializeWorkspace();
+      return {
+        capabilities: {
+          textDocumentSync: TextDocumentSyncKind.Incremental,
+          codeActionProvider: true
+        }
+      };
+    });
+    this.documents.onDidOpen((e) => {
+      void this.validateDocument(e.document);
+    });
+    this.documents.onDidChangeContent((change) => {
+      void this.validateDocument(change.document);
+    });
+    this.documents.onDidClose((e) => {
+      this.cache.delete(e.document.uri);
+      this.connection.sendDiagnostics({ uri: e.document.uri, diagnostics: [] });
+    });
+    this.connection.onCodeAction((params) => {
+      const violations = this.cache.get(params.textDocument.uri) || [];
+      const doc = this.documents.get(params.textDocument.uri);
+      if (!doc) return [];
+      return violations.filter((v) => v.autofix && v.autofix.edits.length > 0).map((v) => {
+        const edits = v.autofix.edits.map((edit) => ({
+          range: {
+            start: doc.positionAt(edit.start),
+            end: doc.positionAt(edit.end)
+          },
+          newText: edit.text
+        }));
+        return {
+          title: v.autofix.description,
+          kind: CodeActionKind.QuickFix,
+          edit: {
+            changes: {
+              [params.textDocument.uri]: edits
+            }
+          }
+        };
+      });
+    });
+    this.documents.listen(this.connection);
+    this.connection.listen();
+  }
+  async initializeWorkspace() {
+    if (!await pathExists(getSpecBridgeDir(this.cwd))) {
+      const err = new NotInitializedError();
+      this.initError = err.message;
+      if (this.options.verbose) this.connection.console.error(chalk12.red(this.initError));
+      return;
+    }
+    try {
+      const config = await loadConfig(this.cwd);
+      this.registry = createRegistry({ basePath: this.cwd });
+      await this.registry.load();
+      this.decisions = this.registry.getActive();
+      for (const root of config.project.sourceRoots) {
+        const rootPath = path3.isAbsolute(root) ? root : path3.join(this.cwd, root);
+        const dir = rootPath.includes("*") ? rootPath.split("*")[0] : rootPath;
+        if (dir && await pathExists(dir)) {
+          this.project.addSourceFilesAtPaths(path3.join(dir, "**/*.{ts,tsx,js,jsx}"));
+        }
+      }
+      if (this.options.verbose) {
+        this.connection.console.log(chalk12.dim(`Loaded ${this.decisions.length} active decision(s)`));
+      }
+    } catch (error) {
+      this.initError = error instanceof Error ? error.message : String(error);
+      if (this.options.verbose) this.connection.console.error(chalk12.red(this.initError));
+    }
+  }
+  async verifyTextDocument(doc) {
+    if (this.initError) {
+      throw new Error(this.initError);
+    }
+    if (!this.registry) return [];
+    const filePath = uriToFilePath(doc.uri);
+    const sourceFile = this.project.createSourceFile(filePath, doc.getText(), { overwrite: true });
+    const violations = [];
+    for (const decision of this.decisions) {
+      for (const constraint of decision.constraints) {
+        if (!shouldApplyConstraintToFile({ filePath, constraint, cwd: this.cwd })) continue;
+        const verifier = selectVerifierForConstraint(constraint.rule, constraint.verifier);
+        if (!verifier) continue;
+        const ctx = {
+          filePath,
+          sourceFile,
+          constraint,
+          decisionId: decision.metadata.id
+        };
+        try {
+          const constraintViolations = await verifier.verify(ctx);
+          violations.push(...constraintViolations);
+        } catch {
+        }
+      }
+    }
+    return violations;
+  }
+  async validateDocument(doc) {
+    try {
+      const violations = await this.verifyTextDocument(doc);
+      this.cache.set(doc.uri, violations);
+      const diagnostics = violations.map((v) => ({
+        range: violationToRange(doc, v),
+        severity: severityToDiagnostic(v.severity),
+        message: v.message,
+        source: "specbridge"
+      }));
+      this.connection.sendDiagnostics({ uri: doc.uri, diagnostics });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      this.connection.sendDiagnostics({
+        uri: doc.uri,
+        diagnostics: [
+          {
+            range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } },
+            severity: DiagnosticSeverity.Error,
+            message: msg,
+            source: "specbridge"
+          }
+        ]
+      });
+    }
+  }
+};
+
+// src/lsp/index.ts
+async function startLspServer(options) {
+  const server = new SpecBridgeLspServer(options);
+  await server.initialize();
+}
+
+// src/cli/commands/lsp.ts
+var lspCommand = new Command12("lsp").description("Start SpecBridge language server (stdio)").option("--verbose", "Enable verbose server logging", false).action(async (options) => {
+  await startLspServer({ cwd: process.cwd(), verbose: Boolean(options.verbose) });
+});
+
+// src/cli/commands/watch.ts
+import { Command as Command13 } from "commander";
+import chalk13 from "chalk";
+import chokidar from "chokidar";
+import path4 from "path";
+var watchCommand = new Command13("watch").description("Watch for changes and verify files continuously").option("-l, --level <level>", "Verification level (commit, pr, full)", "full").option("--debounce <ms>", "Debounce verify on rapid changes", "150").action(async (options) => {
+  const cwd = process.cwd();
+  if (!await pathExists(getSpecBridgeDir(cwd))) {
+    throw new NotInitializedError();
+  }
+  const config = await loadConfig(cwd);
+  const engine = createVerificationEngine();
+  const level = options.level || "full";
+  const debounceMs = Number.parseInt(options.debounce || "150", 10);
+  let timer = null;
+  let pendingPath = null;
+  const run = async (changedPath) => {
+    const absolutePath = path4.isAbsolute(changedPath) ? changedPath : path4.join(cwd, changedPath);
+    const result = await engine.verify(config, {
+      level,
+      files: [absolutePath],
+      cwd
+    });
+    const prefix = result.success ? chalk13.green("\u2713") : chalk13.red("\u2717");
+    const summary = `${prefix} ${path4.relative(cwd, absolutePath)}: ${result.violations.length} violation(s)`;
+    console.log(summary);
+    for (const v of result.violations.slice(0, 20)) {
+      const loc = v.line ? `:${v.line}${v.column ? `:${v.column}` : ""}` : "";
+      console.log(chalk13.dim(`  - ${v.file}${loc}: ${v.message} [${v.severity}]`));
+    }
+    if (result.violations.length > 20) {
+      console.log(chalk13.dim(`  \u2026 ${result.violations.length - 20} more`));
+    }
+  };
+  const watcher = chokidar.watch(config.project.sourceRoots, {
+    cwd,
+    ignored: config.project.exclude,
+    ignoreInitial: true,
+    persistent: true
+  });
+  console.log(chalk13.blue("Watching for changes..."));
+  watcher.on("change", (changedPath) => {
+    pendingPath = changedPath;
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      if (!pendingPath) return;
+      void run(pendingPath);
+      pendingPath = null;
+    }, debounceMs);
+  });
+});
+
+// src/cli/commands/mcp-server.ts
+import { Command as Command14 } from "commander";
+import { readFileSync } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname3, join as join9 } from "path";
+
+// src/mcp/server.ts
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z as z3 } from "zod";
+var SpecBridgeMcpServer = class {
+  server;
+  cwd;
+  config = null;
+  registry = null;
+  constructor(options) {
+    this.cwd = options.cwd;
+    this.server = new McpServer({ name: "specbridge", version: options.version });
+  }
+  async initialize() {
+    this.config = await loadConfig(this.cwd);
+    this.registry = createRegistry({ basePath: this.cwd });
+    await this.registry.load();
+    this.registerResources();
+    this.registerTools();
+  }
+  async startStdio() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+  }
+  getReady() {
+    if (!this.config || !this.registry) {
+      throw new Error("SpecBridge MCP server not initialized. Call initialize() first.");
+    }
+    return { config: this.config, registry: this.registry };
+  }
+  registerResources() {
+    const { config, registry } = this.getReady();
+    this.server.registerResource(
+      "decisions",
+      "decision:///",
+      {
+        title: "Architectural Decisions",
+        description: "List of all architectural decisions",
+        mimeType: "application/json"
+      },
+      async (uri) => {
+        const decisions = registry.getAll();
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify(decisions, null, 2)
+            }
+          ]
+        };
+      }
+    );
+    this.server.registerResource(
+      "decision",
+      new ResourceTemplate("decision://{id}", { list: void 0 }),
+      {
+        title: "Architectural Decision",
+        description: "A specific architectural decision by id",
+        mimeType: "application/json"
+      },
+      async (uri, variables) => {
+        const raw = variables.id;
+        const decisionId = Array.isArray(raw) ? raw[0] ?? "" : raw ?? "";
+        const decision = registry.get(String(decisionId));
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify(decision, null, 2)
+            }
+          ]
+        };
+      }
+    );
+    this.server.registerResource(
+      "latest_report",
+      "report:///latest",
+      {
+        title: "Latest Compliance Report",
+        description: "Most recent compliance report (generated on demand)",
+        mimeType: "application/json"
+      },
+      async (uri) => {
+        const report = await generateReport(config, { cwd: this.cwd });
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify(report, null, 2)
+            }
+          ]
+        };
+      }
+    );
+  }
+  registerTools() {
+    const { config } = this.getReady();
+    this.server.registerTool(
+      "generate_context",
+      {
+        title: "Generate architectural context",
+        description: "Generate architectural context for a file from applicable decisions",
+        inputSchema: {
+          filePath: z3.string().describe("Path to the file to analyze"),
+          includeRationale: z3.boolean().optional().default(true),
+          format: z3.enum(["markdown", "json", "mcp"]).optional().default("markdown")
+        }
+      },
+      async (args) => {
+        const text = await generateFormattedContext(args.filePath, config, {
+          includeRationale: args.includeRationale,
+          format: args.format,
+          cwd: this.cwd
+        });
+        return { content: [{ type: "text", text }] };
+      }
+    );
+    this.server.registerTool(
+      "verify_compliance",
+      {
+        title: "Verify compliance",
+        description: "Verify code compliance against constraints",
+        inputSchema: {
+          level: z3.enum(["commit", "pr", "full"]).optional().default("full"),
+          files: z3.array(z3.string()).optional(),
+          decisions: z3.array(z3.string()).optional(),
+          severity: z3.array(z3.enum(["critical", "high", "medium", "low"])).optional()
+        }
+      },
+      async (args) => {
+        const engine = createVerificationEngine();
+        const result = await engine.verify(config, {
+          level: args.level,
+          files: args.files,
+          decisions: args.decisions,
+          severity: args.severity,
+          cwd: this.cwd
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+    );
+    this.server.registerTool(
+      "get_report",
+      {
+        title: "Get compliance report",
+        description: "Generate a compliance report for the current workspace",
+        inputSchema: {
+          format: z3.enum(["summary", "detailed", "json", "markdown"]).optional().default("summary"),
+          includeAll: z3.boolean().optional().default(false)
+        }
+      },
+      async (args) => {
+        const report = await generateReport(config, { cwd: this.cwd, includeAll: args.includeAll });
+        if (args.format === "json") {
+          return { content: [{ type: "text", text: JSON.stringify(report, null, 2) }] };
+        }
+        if (args.format === "markdown") {
+          return { content: [{ type: "text", text: formatMarkdownReport(report) }] };
+        }
+        if (args.format === "detailed") {
+          return { content: [{ type: "text", text: formatConsoleReport(report) }] };
+        }
+        const summary = {
+          timestamp: report.timestamp,
+          project: report.project,
+          compliance: report.summary.compliance,
+          violations: report.summary.violations,
+          decisions: report.summary.activeDecisions
+        };
+        return { content: [{ type: "text", text: JSON.stringify(summary, null, 2) }] };
+      }
+    );
+  }
+};
+
+// src/cli/commands/mcp-server.ts
+function getCliVersion() {
+  try {
+    const __dirname2 = dirname3(fileURLToPath2(import.meta.url));
+    const packageJsonPath2 = join9(__dirname2, "../package.json");
+    const pkg = JSON.parse(readFileSync(packageJsonPath2, "utf-8"));
+    return String(pkg.version || "0.0.0");
+  } catch {
+    return "0.0.0";
+  }
+}
+var mcpServerCommand = new Command14("mcp-server").description("Start SpecBridge MCP server (stdio)").action(async () => {
+  const server = new SpecBridgeMcpServer({
+    cwd: process.cwd(),
+    version: getCliVersion()
+  });
+  await server.initialize();
+  console.error("SpecBridge MCP server starting (stdio)...");
+  await server.startStdio();
+});
+
+// src/cli/commands/prompt.ts
+import { Command as Command15 } from "commander";
+
+// src/agent/templates.ts
+var templates = {
+  "code-review": {
+    name: "Code Review",
+    description: "Review code for architectural compliance",
+    generate: (context) => {
+      return [
+        "You are reviewing code for architectural compliance.",
+        "",
+        formatContextAsMarkdown(context),
+        "",
+        "Task:",
+        "- Identify violations of the constraints above.",
+        "- Suggest concrete changes to achieve compliance."
+      ].join("\n");
+    }
+  },
+  refactoring: {
+    name: "Refactoring Guidance",
+    description: "Guide refactoring to meet constraints",
+    generate: (context) => {
+      return [
+        "You are helping refactor code to meet architectural constraints.",
+        "",
+        formatContextAsMarkdown(context),
+        "",
+        "Task:",
+        "- Propose a step-by-step refactoring plan to satisfy all invariants first, then conventions/guidelines.",
+        "- Highlight risky changes and suggest safe incremental steps."
+      ].join("\n");
+    }
+  },
+  migration: {
+    name: "Migration Plan",
+    description: "Generate a migration plan for a new/changed decision",
+    generate: (context, options) => {
+      const decisionId = String(options?.decisionId ?? "");
+      return [
+        `A new architectural decision has been introduced: ${decisionId || "<decision-id>"}`,
+        "",
+        formatContextAsMarkdown(context),
+        "",
+        "Task:",
+        "- Provide an impact analysis.",
+        "- Produce a step-by-step migration plan.",
+        "- Include a checklist for completion."
+      ].join("\n");
+    }
+  }
+};
+
+// src/cli/commands/prompt.ts
+var promptCommand = new Command15("prompt").description("Generate AI agent prompt templates").argument("<template>", "Template name (code-review|refactoring|migration)").argument("<file>", "File path (used to select applicable decisions)").option("--decision <id>", "Decision id (required for migration)").action(async (templateName, file, options) => {
+  const cwd = process.cwd();
+  if (!await pathExists(getSpecBridgeDir(cwd))) {
+    throw new NotInitializedError();
+  }
+  const tpl = templates[templateName];
+  if (!tpl) {
+    throw new Error(`Unknown template: ${templateName}`);
+  }
+  if (templateName === "migration" && !options.decision) {
+    throw new Error("Missing --decision <id> for migration template");
+  }
+  const config = await loadConfig(cwd);
+  const context = await generateContext(file, config, { cwd, includeRationale: true });
+  const prompt = tpl.generate(context, { decisionId: options.decision });
+  console.log(prompt);
+});
+
 // src/cli/index.ts
-var __dirname = dirname3(fileURLToPath(import.meta.url));
-var packageJsonPath = join9(__dirname, "../package.json");
-var packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-var program = new Command12();
+var __dirname = dirname4(fileURLToPath3(import.meta.url));
+var packageJsonPath = join10(__dirname, "../package.json");
+var packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+var program = new Command16();
 program.name("specbridge").description("Architecture Decision Runtime - Transform architectural decisions into executable, verifiable constraints").version(packageJson.version);
 program.addCommand(initCommand);
 program.addCommand(inferCommand);
@@ -3335,6 +4676,10 @@ program.addCommand(decisionCommand);
 program.addCommand(hookCommand);
 program.addCommand(reportCommand);
 program.addCommand(contextCommand);
+program.addCommand(lspCommand);
+program.addCommand(watchCommand);
+program.addCommand(mcpServerCommand);
+program.addCommand(promptCommand);
 program.exitOverride((err) => {
   if (err.code === "commander.help" || err.code === "commander.helpDisplayed") {
     process.exit(0);
@@ -3342,11 +4687,11 @@ program.exitOverride((err) => {
   if (err.code === "commander.version") {
     process.exit(0);
   }
-  console.error(chalk12.red(formatError(err)));
+  console.error(chalk14.red(formatError(err)));
   process.exit(1);
 });
 program.parseAsync(process.argv).catch((error) => {
-  console.error(chalk12.red(formatError(error)));
+  console.error(chalk14.red(formatError(error)));
   process.exit(1);
 });
 //# sourceMappingURL=cli.js.map