@ipation/specbridge 1.0.5 → 1.1.0

package/dist/index.js

@@ -66,8 +66,8 @@ function validateDecision(data) {
 }
 function formatValidationErrors(errors) {
   return errors.errors.map((err) => {
-    const path = err.path.join(".");
-    return `${path}: ${err.message}`;
+    const path3 = err.path.join(".");
+    return `${path3}: ${err.message}`;
   });
 }
 
@@ -147,10 +147,11 @@ var defaultConfig = {
 
 // 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);
   }
@@ -194,15 +195,15 @@ var InferenceError = class extends SpecBridgeError {
   }
 };
 var FileSystemError = class extends SpecBridgeError {
-  constructor(message, path) {
-    super(message, "FILE_SYSTEM_ERROR", { path });
-    this.path = path;
+  constructor(message, path3) {
+    super(message, "FILE_SYSTEM_ERROR", { path: path3 });
+    this.path = path3;
     this.name = "FileSystemError";
   }
 };
 var AlreadyInitializedError = class extends SpecBridgeError {
-  constructor(path) {
-    super(`SpecBridge is already initialized at ${path}`, "ALREADY_INITIALIZED", { path });
+  constructor(path3) {
+    super(`SpecBridge is already initialized at ${path3}`, "ALREADY_INITIALIZED", { path: path3 });
     this.name = "AlreadyInitializedError";
   }
 };
@@ -210,7 +211,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";
   }
@@ -246,6 +249,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}`;
@@ -255,31 +262,31 @@ ${detailsStr}`;
 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(path3) {
   try {
-    await access(path, constants.F_OK);
+    await access(path3, constants.F_OK);
     return true;
   } catch {
     return false;
   }
 }
-async function isDirectory(path) {
+async function isDirectory(path3) {
   try {
-    const stats = await stat(path);
+    const stats = await stat(path3);
     return stats.isDirectory();
   } catch {
     return false;
   }
 }
-async function ensureDir(path) {
-  await mkdir(path, { recursive: true });
+async function ensureDir(path3) {
+  await mkdir(path3, { recursive: true });
 }
-async function readTextFile(path) {
-  return readFile(path, "utf-8");
+async function readTextFile(path3) {
+  return readFile(path3, "utf-8");
 }
-async function writeTextFile(path, content) {
-  await ensureDir(dirname(path));
-  await writeFile(path, content, "utf-8");
+async function writeTextFile(path3, content) {
+  await ensureDir(dirname(path3));
+  await writeFile(path3, content, "utf-8");
 }
 async function readFilesInDir(dirPath, filter) {
   try {
@@ -327,15 +334,15 @@ function stringifyYaml(data, options) {
 function parseYamlDocument(content) {
   return parseDocument(content);
 }
-function updateYamlDocument(doc, path, value) {
+function updateYamlDocument(doc, path3, value) {
   let current = doc.contents;
-  for (let i = 0; i < path.length - 1; i++) {
-    const key = path[i];
+  for (let i = 0; i < path3.length - 1; i++) {
+    const key = path3[i];
     if (key && current && typeof current === "object" && "get" in current) {
       current = current.get(key);
     }
   }
-  const lastKey = path[path.length - 1];
+  const lastKey = path3[path3.length - 1];
   if (lastKey && current && typeof current === "object" && "set" in current) {
     current.set(lastKey, value);
   }
@@ -728,8 +735,8 @@ var CodeScanner = class {
   /**
    * Get a specific file
    */
-  getFile(path) {
-    return this.scannedFiles.get(path);
+  getFile(path3) {
+    return this.scannedFiles.get(path3);
   }
   /**
    * Get project instance for advanced analysis
@@ -742,12 +749,12 @@ var CodeScanner = class {
    */
   findClasses() {
     const classes = [];
-    for (const { path, sourceFile } of this.scannedFiles.values()) {
+    for (const { path: path3, sourceFile } of this.scannedFiles.values()) {
       for (const classDecl of sourceFile.getClasses()) {
         const name = classDecl.getName();
         if (name) {
           classes.push({
-            file: path,
+            file: path3,
             name,
             line: classDecl.getStartLineNumber()
           });
@@ -761,12 +768,12 @@ var CodeScanner = class {
    */
   findFunctions() {
     const functions = [];
-    for (const { path, sourceFile } of this.scannedFiles.values()) {
+    for (const { path: path3, sourceFile } of this.scannedFiles.values()) {
       for (const funcDecl of sourceFile.getFunctions()) {
         const name = funcDecl.getName();
         if (name) {
           functions.push({
-            file: path,
+            file: path3,
             name,
             line: funcDecl.getStartLineNumber(),
             isExported: funcDecl.isExported()
@@ -777,7 +784,7 @@ var CodeScanner = class {
         const init = varDecl.getInitializer();
         if (init && Node.isArrowFunction(init)) {
           functions.push({
-            file: path,
+            file: path3,
             name: varDecl.getName(),
             line: varDecl.getStartLineNumber(),
             isExported: varDecl.isExported()
@@ -792,12 +799,12 @@ var CodeScanner = class {
    */
   findImports() {
     const imports = [];
-    for (const { path, sourceFile } of this.scannedFiles.values()) {
+    for (const { path: path3, 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: path3,
           module,
           named: namedImports,
           line: importDecl.getStartLineNumber()
@@ -811,10 +818,10 @@ var CodeScanner = class {
    */
   findInterfaces() {
     const interfaces = [];
-    for (const { path, sourceFile } of this.scannedFiles.values()) {
+    for (const { path: path3, sourceFile } of this.scannedFiles.values()) {
       for (const interfaceDecl of sourceFile.getInterfaces()) {
         interfaces.push({
-          file: path,
+          file: path3,
           name: interfaceDecl.getName(),
           line: interfaceDecl.getStartLineNumber()
         });
@@ -827,10 +834,10 @@ var CodeScanner = class {
    */
   findTypeAliases() {
     const types = [];
-    for (const { path, sourceFile } of this.scannedFiles.values()) {
+    for (const { path: path3, sourceFile } of this.scannedFiles.values()) {
       for (const typeAlias of sourceFile.getTypeAliases()) {
         types.push({
-          file: path,
+          file: path3,
           name: typeAlias.getName(),
           line: typeAlias.getStartLineNumber()
         });
@@ -843,13 +850,13 @@ var CodeScanner = class {
    */
   findTryCatchBlocks() {
     const blocks = [];
-    for (const { path, sourceFile } of this.scannedFiles.values()) {
+    for (const { path: path3, 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: path3,
             line: node.getStartLineNumber(),
             hasThrow
           });
@@ -1423,7 +1430,7 @@ var ErrorsAnalyzer = class {
     let throwNewError = 0;
     let throwCustom = 0;
     const examples = [];
-    for (const { path, sourceFile } of files) {
+    for (const { path: path3, sourceFile } of files) {
       sourceFile.forEachDescendant((node) => {
         if (Node2.isThrowStatement(node)) {
           const expression = node.getExpression();
@@ -1436,7 +1443,7 @@ var ErrorsAnalyzer = class {
               if (examples.length < 3) {
                 const snippet = text.length > 50 ? text.slice(0, 50) + "..." : text;
                 examples.push({
-                  file: path,
+                  file: path3,
                   line: node.getStartLineNumber(),
                   snippet: `throw ${snippet}`
                 });
@@ -1698,6 +1705,7 @@ var NamingVerifier = class {
 };
 
 // src/verification/verifiers/imports.ts
+import path from "path";
 var ImportsVerifier = class {
   id = "imports";
   name = "Import Pattern Verifier";
@@ -1706,6 +1714,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();
@@ -1944,12 +1985,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];
@@ -1963,6 +2582,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");
   }
@@ -1978,10 +2609,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({
@@ -1993,6 +2674,7 @@ var VerificationEngine = class {
       },
       skipAddingFilesFromTsConfig: true
     });
+    this.astCache = new AstCache();
   }
   /**
    * Run verification
@@ -2035,8 +2717,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(
@@ -2098,23 +2780,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);
@@ -2140,25 +2810,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
@@ -2171,8 +2832,111 @@ function createVerificationEngine(registry) {
   return new VerificationEngine(registry);
 }
 
+// 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/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/propagation/graph.ts
-async function buildDependencyGraph(decisions, files) {
+async function buildDependencyGraph2(decisions, files) {
   const nodes = /* @__PURE__ */ new Map();
   const decisionToFiles = /* @__PURE__ */ new Map();
   const fileToDecisions = /* @__PURE__ */ new Map();
@@ -2263,7 +3027,7 @@ var PropagationEngine = class {
       absolute: true
     });
     const decisions = this.registry.getActive();
-    this.graph = await buildDependencyGraph(decisions, files);
+    this.graph = await buildDependencyGraph2(decisions, files);
   }
   /**
    * Analyze impact of changing a decision
@@ -2289,10 +3053,10 @@ var PropagationEngine = class {
       }
       fileViolations.set(violation.file, existing);
     }
-    const affectedFiles = affectedFilePaths.map((path) => ({
-      path,
-      violations: fileViolations.get(path)?.total || 0,
-      autoFixable: fileViolations.get(path)?.autoFixable || 0
+    const affectedFiles = affectedFilePaths.map((path3) => ({
+      path: path3,
+      violations: fileViolations.get(path3)?.total || 0,
+      autoFixable: fileViolations.get(path3)?.autoFixable || 0
     }));
     affectedFiles.sort((a, b) => b.violations - a.violations);
     const totalViolations = result.violations.length;
@@ -2981,11 +3745,244 @@ ${decision.decision.summary}
     );
   }
 };
+
+// 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/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) }] };
+      }
+    );
+  }
+};
 export {
   AgentContextGenerator,
   AlreadyInitializedError,
   AnalyzerNotFoundError,
+  ApiVerifier,
+  AstCache,
+  AutofixEngine,
   CodeScanner,
+  ComplexityVerifier,
   ConfigError,
   ConstraintExceptionSchema,
   ConstraintSchema,
@@ -2996,6 +3993,7 @@ export {
   DecisionSchema,
   DecisionStatusSchema,
   DecisionValidationError,
+  DependencyVerifier,
   ErrorsAnalyzer,
   ErrorsVerifier,
   FileSystemError,
@@ -3013,16 +4011,18 @@ export {
   Registry,
   RegistryError,
   Reporter,
+  SecurityVerifier,
   SeveritySchema,
   SpecBridgeConfigSchema,
   SpecBridgeError,
+  SpecBridgeMcpServer,
   StructureAnalyzer,
   VerificationConfigSchema,
   VerificationEngine,
   VerificationError,
   VerificationFrequencySchema,
   VerifierNotFoundError,
-  buildDependencyGraph,
+  buildDependencyGraph2 as buildDependencyGraph,
   builtinAnalyzers,
   builtinVerifiers,
   calculateConfidence,
@@ -3051,6 +4051,7 @@ export {
   getAffectingDecisions,
   getAnalyzer,
   getAnalyzerIds,
+  getChangedFiles,
   getConfigPath,
   getDecisionsDir,
   getInferredDir,
@@ -3061,6 +4062,7 @@ export {
   getVerifierIds,
   getVerifiersDir,
   glob,
+  isConstraintExcepted,
   isDirectory,
   loadConfig,
   loadDecisionFile,
@@ -3077,7 +4079,9 @@ export {
   readTextFile,
   runInference,
   selectVerifierForConstraint,
+  shouldApplyConstraintToFile,
   stringifyYaml,
+  templates,
   updateYamlDocument,
   validateConfig,
   validateDecision,