@ipation/specbridge 0.2.1

package/dist/index.js

@@ -0,0 +1,3059 @@
+// src/core/schemas/decision.schema.ts
+import { z } from "zod";
+var DecisionStatusSchema = z.enum(["draft", "active", "deprecated", "superseded"]);
+var ConstraintTypeSchema = z.enum(["invariant", "convention", "guideline"]);
+var SeveritySchema = z.enum(["critical", "high", "medium", "low"]);
+var VerificationFrequencySchema = z.enum(["commit", "pr", "daily", "weekly"]);
+var DecisionMetadataSchema = z.object({
+  id: z.string().min(1).regex(/^[a-z0-9-]+$/, "ID must be lowercase alphanumeric with hyphens"),
+  title: z.string().min(1).max(200),
+  status: DecisionStatusSchema,
+  owners: z.array(z.string().min(1)).min(1),
+  createdAt: z.string().datetime().optional(),
+  updatedAt: z.string().datetime().optional(),
+  supersededBy: z.string().optional(),
+  tags: z.array(z.string()).optional()
+});
+var DecisionContentSchema = z.object({
+  summary: z.string().min(1).max(500),
+  rationale: z.string().min(1),
+  context: z.string().optional(),
+  consequences: z.array(z.string()).optional()
+});
+var ConstraintExceptionSchema = z.object({
+  pattern: z.string().min(1),
+  reason: z.string().min(1),
+  approvedBy: z.string().optional(),
+  expiresAt: z.string().datetime().optional()
+});
+var ConstraintSchema = z.object({
+  id: z.string().min(1).regex(/^[a-z0-9-]+$/, "Constraint ID must be lowercase alphanumeric with hyphens"),
+  type: ConstraintTypeSchema,
+  rule: z.string().min(1),
+  severity: SeveritySchema,
+  scope: z.string().min(1),
+  verifier: z.string().optional(),
+  autofix: z.boolean().optional(),
+  exceptions: z.array(ConstraintExceptionSchema).optional()
+});
+var VerificationConfigSchema = z.object({
+  check: z.string().min(1),
+  target: z.string().min(1),
+  frequency: VerificationFrequencySchema,
+  timeout: z.number().positive().optional()
+});
+var LinksSchema = z.object({
+  related: z.array(z.string()).optional(),
+  supersedes: z.array(z.string()).optional(),
+  references: z.array(z.string().url()).optional()
+});
+var DecisionSchema = z.object({
+  kind: z.literal("Decision"),
+  metadata: DecisionMetadataSchema,
+  decision: DecisionContentSchema,
+  constraints: z.array(ConstraintSchema).min(1),
+  verification: z.object({
+    automated: z.array(VerificationConfigSchema).optional()
+  }).optional(),
+  links: LinksSchema.optional()
+});
+function validateDecision(data) {
+  const result = DecisionSchema.safeParse(data);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, errors: result.error };
+}
+function formatValidationErrors(errors) {
+  return errors.errors.map((err) => {
+    const path = err.path.join(".");
+    return `${path}: ${err.message}`;
+  });
+}
+
+// src/core/schemas/config.schema.ts
+import { z as z2 } from "zod";
+var SeveritySchema2 = z2.enum(["critical", "high", "medium", "low"]);
+var LevelConfigSchema = z2.object({
+  timeout: z2.number().positive().optional(),
+  severity: z2.array(SeveritySchema2).optional()
+});
+var ProjectConfigSchema = z2.object({
+  name: z2.string().min(1),
+  sourceRoots: z2.array(z2.string().min(1)).min(1),
+  exclude: z2.array(z2.string()).optional()
+});
+var InferenceConfigSchema = z2.object({
+  minConfidence: z2.number().min(0).max(100).optional(),
+  analyzers: z2.array(z2.string()).optional()
+});
+var VerificationConfigSchema2 = z2.object({
+  levels: z2.object({
+    commit: LevelConfigSchema.optional(),
+    pr: LevelConfigSchema.optional(),
+    full: LevelConfigSchema.optional()
+  }).optional()
+});
+var AgentConfigSchema = z2.object({
+  format: z2.enum(["markdown", "json", "mcp"]).optional(),
+  includeRationale: z2.boolean().optional()
+});
+var SpecBridgeConfigSchema = z2.object({
+  version: z2.string().regex(/^\d+\.\d+$/, "Version must be in format X.Y"),
+  project: ProjectConfigSchema,
+  inference: InferenceConfigSchema.optional(),
+  verification: VerificationConfigSchema2.optional(),
+  agent: AgentConfigSchema.optional()
+});
+function validateConfig(data) {
+  const result = SpecBridgeConfigSchema.safeParse(data);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, errors: result.error };
+}
+var defaultConfig = {
+  version: "1.0",
+  project: {
+    name: "my-project",
+    sourceRoots: ["src/**/*.ts", "src/**/*.tsx"],
+    exclude: ["**/*.test.ts", "**/*.spec.ts", "**/node_modules/**", "**/dist/**"]
+  },
+  inference: {
+    minConfidence: 70,
+    analyzers: ["naming", "structure", "imports", "errors"]
+  },
+  verification: {
+    levels: {
+      commit: {
+        timeout: 5e3,
+        severity: ["critical"]
+      },
+      pr: {
+        timeout: 6e4,
+        severity: ["critical", "high"]
+      },
+      full: {
+        timeout: 3e5,
+        severity: ["critical", "high", "medium", "low"]
+      }
+    }
+  },
+  agent: {
+    format: "markdown",
+    includeRationale: true
+  }
+};
+
+// src/core/errors/index.ts
+var SpecBridgeError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "SpecBridgeError";
+    Error.captureStackTrace(this, this.constructor);
+  }
+};
+var ConfigError = class extends SpecBridgeError {
+  constructor(message, details) {
+    super(message, "CONFIG_ERROR", details);
+    this.name = "ConfigError";
+  }
+};
+var DecisionValidationError = class extends SpecBridgeError {
+  constructor(message, decisionId, validationErrors) {
+    super(message, "DECISION_VALIDATION_ERROR", { decisionId, validationErrors });
+    this.decisionId = decisionId;
+    this.validationErrors = validationErrors;
+    this.name = "DecisionValidationError";
+  }
+};
+var DecisionNotFoundError = class extends SpecBridgeError {
+  constructor(decisionId) {
+    super(`Decision not found: ${decisionId}`, "DECISION_NOT_FOUND", { decisionId });
+    this.name = "DecisionNotFoundError";
+  }
+};
+var RegistryError = class extends SpecBridgeError {
+  constructor(message, details) {
+    super(message, "REGISTRY_ERROR", details);
+    this.name = "RegistryError";
+  }
+};
+var VerificationError = class extends SpecBridgeError {
+  constructor(message, details) {
+    super(message, "VERIFICATION_ERROR", details);
+    this.name = "VerificationError";
+  }
+};
+var InferenceError = class extends SpecBridgeError {
+  constructor(message, details) {
+    super(message, "INFERENCE_ERROR", details);
+    this.name = "InferenceError";
+  }
+};
+var FileSystemError = class extends SpecBridgeError {
+  constructor(message, path) {
+    super(message, "FILE_SYSTEM_ERROR", { path });
+    this.path = path;
+    this.name = "FileSystemError";
+  }
+};
+var AlreadyInitializedError = class extends SpecBridgeError {
+  constructor(path) {
+    super(`SpecBridge is already initialized at ${path}`, "ALREADY_INITIALIZED", { path });
+    this.name = "AlreadyInitializedError";
+  }
+};
+var NotInitializedError = class extends SpecBridgeError {
+  constructor() {
+    super(
+      'SpecBridge is not initialized. Run "specbridge init" first.',
+      "NOT_INITIALIZED"
+    );
+    this.name = "NotInitializedError";
+  }
+};
+var VerifierNotFoundError = class extends SpecBridgeError {
+  constructor(verifierId) {
+    super(`Verifier not found: ${verifierId}`, "VERIFIER_NOT_FOUND", { verifierId });
+    this.name = "VerifierNotFoundError";
+  }
+};
+var AnalyzerNotFoundError = class extends SpecBridgeError {
+  constructor(analyzerId) {
+    super(`Analyzer not found: ${analyzerId}`, "ANALYZER_NOT_FOUND", { analyzerId });
+    this.name = "AnalyzerNotFoundError";
+  }
+};
+var HookError = class extends SpecBridgeError {
+  constructor(message, details) {
+    super(message, "HOOK_ERROR", details);
+    this.name = "HookError";
+  }
+};
+function formatError(error) {
+  if (error instanceof SpecBridgeError) {
+    let message = `Error [${error.code}]: ${error.message}`;
+    if (error.details) {
+      const detailsStr = Object.entries(error.details).filter(([key]) => key !== "validationErrors").map(([key, value]) => `  ${key}: ${value}`).join("\n");
+      if (detailsStr) {
+        message += `
+${detailsStr}`;
+      }
+    }
+    if (error instanceof DecisionValidationError && error.validationErrors.length > 0) {
+      message += "\nValidation errors:\n" + error.validationErrors.map((e) => `  - ${e}`).join("\n");
+    }
+    return message;
+  }
+  return `Error: ${error.message}`;
+}
+
+// src/utils/fs.ts
+import { readFile, writeFile, mkdir, access, readdir, stat } from "fs/promises";
+import { join, dirname } from "path";
+import { constants } from "fs";
+async function pathExists(path) {
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isDirectory(path) {
+  try {
+    const stats = await stat(path);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function ensureDir(path) {
+  await mkdir(path, { recursive: true });
+}
+async function readTextFile(path) {
+  return readFile(path, "utf-8");
+}
+async function writeTextFile(path, content) {
+  await ensureDir(dirname(path));
+  await writeFile(path, content, "utf-8");
+}
+async function readFilesInDir(dirPath, filter) {
+  try {
+    const entries = await readdir(dirPath, { withFileTypes: true });
+    const files = entries.filter((entry) => entry.isFile()).map((entry) => entry.name);
+    if (filter) {
+      return files.filter(filter);
+    }
+    return files;
+  } catch {
+    return [];
+  }
+}
+function getSpecBridgeDir(basePath = process.cwd()) {
+  return join(basePath, ".specbridge");
+}
+function getDecisionsDir(basePath = process.cwd()) {
+  return join(getSpecBridgeDir(basePath), "decisions");
+}
+function getVerifiersDir(basePath = process.cwd()) {
+  return join(getSpecBridgeDir(basePath), "verifiers");
+}
+function getInferredDir(basePath = process.cwd()) {
+  return join(getSpecBridgeDir(basePath), "inferred");
+}
+function getReportsDir(basePath = process.cwd()) {
+  return join(getSpecBridgeDir(basePath), "reports");
+}
+function getConfigPath(basePath = process.cwd()) {
+  return join(getSpecBridgeDir(basePath), "config.yaml");
+}
+
+// src/utils/yaml.ts
+import { parse, stringify, parseDocument } from "yaml";
+function parseYaml(content) {
+  return parse(content);
+}
+function stringifyYaml(data, options) {
+  return stringify(data, {
+    indent: options?.indent ?? 2,
+    lineWidth: 100,
+    minContentWidth: 20
+  });
+}
+function parseYamlDocument(content) {
+  return parseDocument(content);
+}
+function updateYamlDocument(doc, path, value) {
+  let current = doc.contents;
+  for (let i = 0; i < path.length - 1; i++) {
+    const key = path[i];
+    if (key && current && typeof current === "object" && "get" in current) {
+      current = current.get(key);
+    }
+  }
+  const lastKey = path[path.length - 1];
+  if (lastKey && current && typeof current === "object" && "set" in current) {
+    current.set(lastKey, value);
+  }
+}
+
+// src/config/loader.ts
+async function loadConfig(basePath = process.cwd()) {
+  const specbridgeDir = getSpecBridgeDir(basePath);
+  const configPath = getConfigPath(basePath);
+  if (!await pathExists(specbridgeDir)) {
+    throw new NotInitializedError();
+  }
+  if (!await pathExists(configPath)) {
+    return defaultConfig;
+  }
+  const content = await readTextFile(configPath);
+  const parsed = parseYaml(content);
+  const result = validateConfig(parsed);
+  if (!result.success) {
+    const errors = result.errors.errors.map((e) => `${e.path.join(".")}: ${e.message}`);
+    throw new ConfigError(`Invalid configuration in ${configPath}`, { errors });
+  }
+  return result.data;
+}
+function mergeWithDefaults(partial) {
+  return {
+    ...defaultConfig,
+    ...partial,
+    project: {
+      ...defaultConfig.project,
+      ...partial.project
+    },
+    inference: {
+      ...defaultConfig.inference,
+      ...partial.inference
+    },
+    verification: {
+      ...defaultConfig.verification,
+      ...partial.verification,
+      levels: {
+        ...defaultConfig.verification?.levels,
+        ...partial.verification?.levels
+      }
+    },
+    agent: {
+      ...defaultConfig.agent,
+      ...partial.agent
+    }
+  };
+}
+
+// src/registry/loader.ts
+import { join as join2 } from "path";
+async function loadDecisionFile(filePath) {
+  if (!await pathExists(filePath)) {
+    throw new FileSystemError(`Decision file not found: ${filePath}`, filePath);
+  }
+  const content = await readTextFile(filePath);
+  const parsed = parseYaml(content);
+  const result = validateDecision(parsed);
+  if (!result.success) {
+    const errors = formatValidationErrors(result.errors);
+    throw new DecisionValidationError(
+      `Invalid decision file: ${filePath}`,
+      typeof parsed === "object" && parsed !== null && "metadata" in parsed ? parsed.metadata?.id || "unknown" : "unknown",
+      errors
+    );
+  }
+  return result.data;
+}
+async function loadDecisionsFromDir(dirPath) {
+  const decisions = [];
+  const errors = [];
+  if (!await pathExists(dirPath)) {
+    return { decisions, errors };
+  }
+  const files = await readFilesInDir(dirPath, (f) => f.endsWith(".decision.yaml"));
+  for (const file of files) {
+    const filePath = join2(dirPath, file);
+    try {
+      const decision = await loadDecisionFile(filePath);
+      decisions.push({ decision, filePath });
+    } catch (error) {
+      errors.push({
+        filePath,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return { decisions, errors };
+}
+async function validateDecisionFile(filePath) {
+  try {
+    if (!await pathExists(filePath)) {
+      return { valid: false, errors: [`File not found: ${filePath}`] };
+    }
+    const content = await readTextFile(filePath);
+    const parsed = parseYaml(content);
+    const result = validateDecision(parsed);
+    if (!result.success) {
+      return { valid: false, errors: formatValidationErrors(result.errors) };
+    }
+    return { valid: true, errors: [] };
+  } catch (error) {
+    return {
+      valid: false,
+      errors: [error instanceof Error ? error.message : String(error)]
+    };
+  }
+}
+
+// src/utils/glob.ts
+import fg from "fast-glob";
+import { minimatch } from "minimatch";
+async function glob(patterns, options = {}) {
+  const {
+    cwd = process.cwd(),
+    ignore = [],
+    absolute = false,
+    onlyFiles = true
+  } = options;
+  return fg(patterns, {
+    cwd,
+    ignore,
+    absolute,
+    onlyFiles,
+    dot: false
+  });
+}
+function matchesPattern(filePath, pattern) {
+  return minimatch(filePath, pattern, { matchBase: true });
+}
+function matchesAnyPattern(filePath, patterns) {
+  return patterns.some((pattern) => matchesPattern(filePath, pattern));
+}
+
+// src/registry/registry.ts
+var Registry = class {
+  decisions = /* @__PURE__ */ new Map();
+  basePath;
+  loaded = false;
+  constructor(options = {}) {
+    this.basePath = options.basePath || process.cwd();
+  }
+  /**
+   * Load all decisions from the decisions directory
+   */
+  async load() {
+    if (!await pathExists(getSpecBridgeDir(this.basePath))) {
+      throw new NotInitializedError();
+    }
+    const decisionsDir = getDecisionsDir(this.basePath);
+    const result = await loadDecisionsFromDir(decisionsDir);
+    this.decisions.clear();
+    for (const loaded of result.decisions) {
+      this.decisions.set(loaded.decision.metadata.id, loaded);
+    }
+    this.loaded = true;
+    return result;
+  }
+  /**
+   * Ensure registry is loaded
+   */
+  ensureLoaded() {
+    if (!this.loaded) {
+      throw new Error("Registry not loaded. Call load() first.");
+    }
+  }
+  /**
+   * Get all decisions
+   */
+  getAll(filter) {
+    this.ensureLoaded();
+    let decisions = Array.from(this.decisions.values()).map((d) => d.decision);
+    if (filter) {
+      decisions = this.applyFilter(decisions, filter);
+    }
+    return decisions;
+  }
+  /**
+   * Get active decisions only
+   */
+  getActive() {
+    return this.getAll({ status: ["active"] });
+  }
+  /**
+   * Get a decision by ID
+   */
+  get(id) {
+    this.ensureLoaded();
+    const loaded = this.decisions.get(id);
+    if (!loaded) {
+      throw new DecisionNotFoundError(id);
+    }
+    return loaded.decision;
+  }
+  /**
+   * Get a decision with its file path
+   */
+  getWithPath(id) {
+    this.ensureLoaded();
+    const loaded = this.decisions.get(id);
+    if (!loaded) {
+      throw new DecisionNotFoundError(id);
+    }
+    return loaded;
+  }
+  /**
+   * Check if a decision exists
+   */
+  has(id) {
+    this.ensureLoaded();
+    return this.decisions.has(id);
+  }
+  /**
+   * Get all decision IDs
+   */
+  getIds() {
+    this.ensureLoaded();
+    return Array.from(this.decisions.keys());
+  }
+  /**
+   * Get constraints applicable to a specific file
+   */
+  getConstraintsForFile(filePath, filter) {
+    this.ensureLoaded();
+    const applicable = [];
+    let decisions = this.getActive();
+    if (filter) {
+      decisions = this.applyFilter(decisions, filter);
+    }
+    for (const decision of decisions) {
+      for (const constraint of decision.constraints) {
+        if (matchesPattern(filePath, constraint.scope)) {
+          applicable.push({
+            decisionId: decision.metadata.id,
+            decisionTitle: decision.metadata.title,
+            constraintId: constraint.id,
+            type: constraint.type,
+            rule: constraint.rule,
+            severity: constraint.severity,
+            scope: constraint.scope
+          });
+        }
+      }
+    }
+    return applicable;
+  }
+  /**
+   * Get decisions by tag
+   */
+  getByTag(tag) {
+    return this.getAll().filter(
+      (d) => d.metadata.tags?.includes(tag)
+    );
+  }
+  /**
+   * Get decisions by owner
+   */
+  getByOwner(owner) {
+    return this.getAll().filter(
+      (d) => d.metadata.owners.includes(owner)
+    );
+  }
+  /**
+   * Apply filter to decisions
+   */
+  applyFilter(decisions, filter) {
+    return decisions.filter((decision) => {
+      if (filter.status && !filter.status.includes(decision.metadata.status)) {
+        return false;
+      }
+      if (filter.tags) {
+        const hasTags = filter.tags.some(
+          (tag) => decision.metadata.tags?.includes(tag)
+        );
+        if (!hasTags) return false;
+      }
+      if (filter.constraintType) {
+        const hasType = decision.constraints.some(
+          (c) => filter.constraintType?.includes(c.type)
+        );
+        if (!hasType) return false;
+      }
+      if (filter.severity) {
+        const hasSeverity = decision.constraints.some(
+          (c) => filter.severity?.includes(c.severity)
+        );
+        if (!hasSeverity) return false;
+      }
+      return true;
+    });
+  }
+  /**
+   * Get count of decisions by status
+   */
+  getStatusCounts() {
+    this.ensureLoaded();
+    const counts = {
+      draft: 0,
+      active: 0,
+      deprecated: 0,
+      superseded: 0
+    };
+    for (const loaded of this.decisions.values()) {
+      counts[loaded.decision.metadata.status]++;
+    }
+    return counts;
+  }
+  /**
+   * Get total constraint count
+   */
+  getConstraintCount() {
+    this.ensureLoaded();
+    let count = 0;
+    for (const loaded of this.decisions.values()) {
+      count += loaded.decision.constraints.length;
+    }
+    return count;
+  }
+};
+function createRegistry(options) {
+  return new Registry(options);
+}
+
+// src/inference/scanner.ts
+import { Project, Node, SyntaxKind } from "ts-morph";
+var CodeScanner = class {
+  project;
+  scannedFiles = /* @__PURE__ */ new Map();
+  constructor() {
+    this.project = new Project({
+      compilerOptions: {
+        allowJs: true,
+        checkJs: false,
+        noEmit: true,
+        skipLibCheck: true
+      },
+      skipAddingFilesFromTsConfig: true
+    });
+  }
+  /**
+   * Scan files matching the given patterns
+   */
+  async scan(options) {
+    const { sourceRoots, exclude = [], cwd = process.cwd() } = options;
+    const files = await glob(sourceRoots, {
+      cwd,
+      ignore: exclude,
+      absolute: true
+    });
+    for (const filePath of files) {
+      try {
+        const sourceFile = this.project.addSourceFileAtPath(filePath);
+        const lines = sourceFile.getEndLineNumber();
+        this.scannedFiles.set(filePath, {
+          path: filePath,
+          sourceFile,
+          lines
+        });
+      } catch {
+      }
+    }
+    const scannedArray = Array.from(this.scannedFiles.values());
+    const totalLines = scannedArray.reduce((sum, f) => sum + f.lines, 0);
+    return {
+      files: scannedArray,
+      totalFiles: scannedArray.length,
+      totalLines
+    };
+  }
+  /**
+   * Get all scanned files
+   */
+  getFiles() {
+    return Array.from(this.scannedFiles.values());
+  }
+  /**
+   * Get a specific file
+   */
+  getFile(path) {
+    return this.scannedFiles.get(path);
+  }
+  /**
+   * Get project instance for advanced analysis
+   */
+  getProject() {
+    return this.project;
+  }
+  /**
+   * Find all classes in scanned files
+   */
+  findClasses() {
+    const classes = [];
+    for (const { path, sourceFile } of this.scannedFiles.values()) {
+      for (const classDecl of sourceFile.getClasses()) {
+        const name = classDecl.getName();
+        if (name) {
+          classes.push({
+            file: path,
+            name,
+            line: classDecl.getStartLineNumber()
+          });
+        }
+      }
+    }
+    return classes;
+  }
+  /**
+   * Find all functions in scanned files
+   */
+  findFunctions() {
+    const functions = [];
+    for (const { path, sourceFile } of this.scannedFiles.values()) {
+      for (const funcDecl of sourceFile.getFunctions()) {
+        const name = funcDecl.getName();
+        if (name) {
+          functions.push({
+            file: path,
+            name,
+            line: funcDecl.getStartLineNumber(),
+            isExported: funcDecl.isExported()
+          });
+        }
+      }
+      for (const varDecl of sourceFile.getVariableDeclarations()) {
+        const init = varDecl.getInitializer();
+        if (init && Node.isArrowFunction(init)) {
+          functions.push({
+            file: path,
+            name: varDecl.getName(),
+            line: varDecl.getStartLineNumber(),
+            isExported: varDecl.isExported()
+          });
+        }
+      }
+    }
+    return functions;
+  }
+  /**
+   * Find all imports in scanned files
+   */
+  findImports() {
+    const imports = [];
+    for (const { path, 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,
+          module,
+          named: namedImports,
+          line: importDecl.getStartLineNumber()
+        });
+      }
+    }
+    return imports;
+  }
+  /**
+   * Find all interfaces in scanned files
+   */
+  findInterfaces() {
+    const interfaces = [];
+    for (const { path, sourceFile } of this.scannedFiles.values()) {
+      for (const interfaceDecl of sourceFile.getInterfaces()) {
+        interfaces.push({
+          file: path,
+          name: interfaceDecl.getName(),
+          line: interfaceDecl.getStartLineNumber()
+        });
+      }
+    }
+    return interfaces;
+  }
+  /**
+   * Find all type aliases in scanned files
+   */
+  findTypeAliases() {
+    const types = [];
+    for (const { path, sourceFile } of this.scannedFiles.values()) {
+      for (const typeAlias of sourceFile.getTypeAliases()) {
+        types.push({
+          file: path,
+          name: typeAlias.getName(),
+          line: typeAlias.getStartLineNumber()
+        });
+      }
+    }
+    return types;
+  }
+  /**
+   * Find try-catch blocks in scanned files
+   */
+  findTryCatchBlocks() {
+    const blocks = [];
+    for (const { path, 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,
+            line: node.getStartLineNumber(),
+            hasThrow
+          });
+        }
+      });
+    }
+    return blocks;
+  }
+};
+function createScannerFromConfig(_config) {
+  return new CodeScanner();
+}
+
+// src/inference/analyzers/base.ts
+function createPattern(analyzer, params) {
+  return {
+    analyzer,
+    ...params
+  };
+}
+function calculateConfidence(occurrences, total, minOccurrences = 3) {
+  if (occurrences < minOccurrences) {
+    return 0;
+  }
+  const ratio = occurrences / total;
+  return Math.min(100, Math.round(50 + ratio * 50));
+}
+function extractSnippet(content, line, contextLines = 1) {
+  const lines = content.split("\n");
+  const start = Math.max(0, line - 1 - contextLines);
+  const end = Math.min(lines.length, line + contextLines);
+  return lines.slice(start, end).join("\n");
+}
+
+// src/inference/analyzers/naming.ts
+var CLASS_PATTERNS = [
+  { convention: "PascalCase", regex: /^[A-Z][a-zA-Z0-9]*$/, description: "Classes use PascalCase" }
+];
+var FUNCTION_PATTERNS = [
+  { convention: "camelCase", regex: /^[a-z][a-zA-Z0-9]*$/, description: "Functions use camelCase" },
+  { convention: "snake_case", regex: /^[a-z][a-z0-9_]*$/, description: "Functions use snake_case" }
+];
+var INTERFACE_PATTERNS = [
+  { convention: "PascalCase", regex: /^[A-Z][a-zA-Z0-9]*$/, description: "Interfaces use PascalCase" },
+  { convention: "IPrefixed", regex: /^I[A-Z][a-zA-Z0-9]*$/, description: "Interfaces are prefixed with I" }
+];
+var TYPE_PATTERNS = [
+  { convention: "PascalCase", regex: /^[A-Z][a-zA-Z0-9]*$/, description: "Types use PascalCase" },
+  { convention: "TSuffixed", regex: /^[A-Z][a-zA-Z0-9]*Type$/, description: "Types are suffixed with Type" }
+];
+var NamingAnalyzer = class {
+  id = "naming";
+  name = "Naming Convention Analyzer";
+  description = "Detects naming conventions for classes, functions, interfaces, and types";
+  async analyze(scanner) {
+    const patterns = [];
+    const classPattern = this.analyzeClassNaming(scanner);
+    if (classPattern) patterns.push(classPattern);
+    const functionPattern = this.analyzeFunctionNaming(scanner);
+    if (functionPattern) patterns.push(functionPattern);
+    const interfacePattern = this.analyzeInterfaceNaming(scanner);
+    if (interfacePattern) patterns.push(interfacePattern);
+    const typePattern = this.analyzeTypeNaming(scanner);
+    if (typePattern) patterns.push(typePattern);
+    return patterns;
+  }
+  analyzeClassNaming(scanner) {
+    const classes = scanner.findClasses();
+    if (classes.length < 3) return null;
+    const matches = this.findBestMatch(classes.map((c) => c.name), CLASS_PATTERNS);
+    if (!matches) return null;
+    return createPattern(this.id, {
+      id: "naming-classes",
+      name: "Class Naming Convention",
+      description: `Classes follow ${matches.convention} naming convention`,
+      confidence: matches.confidence,
+      occurrences: matches.matchCount,
+      examples: classes.slice(0, 3).map((c) => ({
+        file: c.file,
+        line: c.line,
+        snippet: `class ${c.name}`
+      })),
+      suggestedConstraint: {
+        type: "convention",
+        rule: `Classes should use ${matches.convention} naming convention`,
+        severity: "medium",
+        scope: "src/**/*.ts"
+      }
+    });
+  }
+  analyzeFunctionNaming(scanner) {
+    const functions = scanner.findFunctions();
+    if (functions.length < 3) return null;
+    const matches = this.findBestMatch(functions.map((f) => f.name), FUNCTION_PATTERNS);
+    if (!matches) return null;
+    return createPattern(this.id, {
+      id: "naming-functions",
+      name: "Function Naming Convention",
+      description: `Functions follow ${matches.convention} naming convention`,
+      confidence: matches.confidence,
+      occurrences: matches.matchCount,
+      examples: functions.slice(0, 3).map((f) => ({
+        file: f.file,
+        line: f.line,
+        snippet: `function ${f.name}`
+      })),
+      suggestedConstraint: {
+        type: "convention",
+        rule: `Functions should use ${matches.convention} naming convention`,
+        severity: "low",
+        scope: "src/**/*.ts"
+      }
+    });
+  }
+  analyzeInterfaceNaming(scanner) {
+    const interfaces = scanner.findInterfaces();
+    if (interfaces.length < 3) return null;
+    const matches = this.findBestMatch(interfaces.map((i) => i.name), INTERFACE_PATTERNS);
+    if (!matches) return null;
+    return createPattern(this.id, {
+      id: "naming-interfaces",
+      name: "Interface Naming Convention",
+      description: `Interfaces follow ${matches.convention} naming convention`,
+      confidence: matches.confidence,
+      occurrences: matches.matchCount,
+      examples: interfaces.slice(0, 3).map((i) => ({
+        file: i.file,
+        line: i.line,
+        snippet: `interface ${i.name}`
+      })),
+      suggestedConstraint: {
+        type: "convention",
+        rule: `Interfaces should use ${matches.convention} naming convention`,
+        severity: "low",
+        scope: "src/**/*.ts"
+      }
+    });
+  }
+  analyzeTypeNaming(scanner) {
+    const types = scanner.findTypeAliases();
+    if (types.length < 3) return null;
+    const matches = this.findBestMatch(types.map((t) => t.name), TYPE_PATTERNS);
+    if (!matches) return null;
+    return createPattern(this.id, {
+      id: "naming-types",
+      name: "Type Alias Naming Convention",
+      description: `Type aliases follow ${matches.convention} naming convention`,
+      confidence: matches.confidence,
+      occurrences: matches.matchCount,
+      examples: types.slice(0, 3).map((t) => ({
+        file: t.file,
+        line: t.line,
+        snippet: `type ${t.name}`
+      })),
+      suggestedConstraint: {
+        type: "guideline",
+        rule: `Type aliases should use ${matches.convention} naming convention`,
+        severity: "low",
+        scope: "src/**/*.ts"
+      }
+    });
+  }
+  findBestMatch(names, patterns) {
+    let bestMatch = null;
+    for (const pattern of patterns) {
+      const matchCount = names.filter((name) => pattern.regex.test(name)).length;
+      if (!bestMatch || matchCount > bestMatch.matchCount) {
+        bestMatch = { convention: pattern.convention, matchCount };
+      }
+    }
+    if (!bestMatch || bestMatch.matchCount < 3) return null;
+    const confidence = calculateConfidence(bestMatch.matchCount, names.length);
+    if (confidence < 50) return null;
+    return {
+      convention: bestMatch.convention,
+      confidence,
+      matchCount: bestMatch.matchCount
+    };
+  }
+};
+
+// src/inference/analyzers/imports.ts
+var ImportsAnalyzer = class {
+  id = "imports";
+  name = "Import Pattern Analyzer";
+  description = "Detects import organization patterns and module usage conventions";
+  async analyze(scanner) {
+    const patterns = [];
+    const barrelPattern = this.analyzeBarrelImports(scanner);
+    if (barrelPattern) patterns.push(barrelPattern);
+    const relativePattern = this.analyzeRelativeImports(scanner);
+    if (relativePattern) patterns.push(relativePattern);
+    const modulePatterns = this.analyzeCommonModules(scanner);
+    patterns.push(...modulePatterns);
+    return patterns;
+  }
+  analyzeBarrelImports(scanner) {
+    const imports = scanner.findImports();
+    const barrelImports = imports.filter((i) => {
+      const modulePath = i.module;
+      return modulePath.startsWith(".") && !modulePath.includes(".js") && !modulePath.includes(".ts");
+    });
+    const indexImports = barrelImports.filter((i) => {
+      return i.module.endsWith("/index") || !i.module.includes("/");
+    });
+    if (indexImports.length < 3) return null;
+    const confidence = calculateConfidence(indexImports.length, barrelImports.length);
+    if (confidence < 50) return null;
+    return createPattern(this.id, {
+      id: "imports-barrel",
+      name: "Barrel Import Pattern",
+      description: "Modules are imported through barrel (index) files",
+      confidence,
+      occurrences: indexImports.length,
+      examples: indexImports.slice(0, 3).map((i) => ({
+        file: i.file,
+        line: i.line,
+        snippet: `import { ${i.named.slice(0, 3).join(", ")} } from '${i.module}'`
+      })),
+      suggestedConstraint: {
+        type: "convention",
+        rule: "Import from barrel (index) files rather than individual modules",
+        severity: "low",
+        scope: "src/**/*.ts"
+      }
+    });
+  }
+  analyzeRelativeImports(scanner) {
+    const imports = scanner.findImports();
+    const relativeImports = imports.filter((i) => i.module.startsWith("."));
+    const absoluteImports = imports.filter((i) => !i.module.startsWith(".") && !i.module.startsWith("@"));
+    const aliasImports = imports.filter((i) => i.module.startsWith("@/") || i.module.startsWith("~"));
+    const total = relativeImports.length + absoluteImports.length + aliasImports.length;
+    if (total < 10) return null;
+    if (aliasImports.length > relativeImports.length && aliasImports.length >= 5) {
+      const confidence = calculateConfidence(aliasImports.length, total);
+      if (confidence < 50) return null;
+      return createPattern(this.id, {
+        id: "imports-alias",
+        name: "Path Alias Import Pattern",
+        description: "Imports use path aliases (@ or ~) instead of relative paths",
+        confidence,
+        occurrences: aliasImports.length,
+        examples: aliasImports.slice(0, 3).map((i) => ({
+          file: i.file,
+          line: i.line,
+          snippet: `import { ${i.named.slice(0, 2).join(", ")} } from '${i.module}'`
+        })),
+        suggestedConstraint: {
+          type: "convention",
+          rule: "Use path aliases instead of relative imports",
+          severity: "low",
+          scope: "src/**/*.ts"
+        }
+      });
+    }
+    if (relativeImports.length > aliasImports.length * 2 && relativeImports.length >= 5) {
+      const confidence = calculateConfidence(relativeImports.length, total);
+      if (confidence < 50) return null;
+      return createPattern(this.id, {
+        id: "imports-relative",
+        name: "Relative Import Pattern",
+        description: "Imports use relative paths",
+        confidence,
+        occurrences: relativeImports.length,
+        examples: relativeImports.slice(0, 3).map((i) => ({
+          file: i.file,
+          line: i.line,
+          snippet: `import { ${i.named.slice(0, 2).join(", ")} } from '${i.module}'`
+        })),
+        suggestedConstraint: {
+          type: "guideline",
+          rule: "Use relative imports for local modules",
+          severity: "low",
+          scope: "src/**/*.ts"
+        }
+      });
+    }
+    return null;
+  }
+  analyzeCommonModules(scanner) {
+    const patterns = [];
+    const imports = scanner.findImports();
+    const moduleCounts = /* @__PURE__ */ new Map();
+    for (const imp of imports) {
+      if (imp.module.startsWith(".")) continue;
+      const parts = imp.module.split("/");
+      const packageName = imp.module.startsWith("@") && parts.length > 1 ? `${parts[0]}/${parts[1]}` : parts[0];
+      if (packageName) {
+        const existing = moduleCounts.get(packageName) || { count: 0, examples: [] };
+        existing.count++;
+        existing.examples.push(imp);
+        moduleCounts.set(packageName, existing);
+      }
+    }
+    for (const [packageName, data] of moduleCounts) {
+      if (data.count >= 5) {
+        const confidence = Math.min(100, 50 + data.count * 2);
+        patterns.push(createPattern(this.id, {
+          id: `imports-module-${packageName.replace(/[/@]/g, "-")}`,
+          name: `${packageName} Usage`,
+          description: `${packageName} is used across ${data.count} files`,
+          confidence,
+          occurrences: data.count,
+          examples: data.examples.slice(0, 3).map((i) => ({
+            file: i.file,
+            line: i.line,
+            snippet: `import { ${i.named.slice(0, 2).join(", ") || "..."} } from '${i.module}'`
+          }))
+        }));
+      }
+    }
+    return patterns;
+  }
+};
+
+// src/inference/analyzers/structure.ts
+import { basename, dirname as dirname2 } from "path";
+var StructureAnalyzer = class {
+  id = "structure";
+  name = "Code Structure Analyzer";
+  description = "Detects file organization and directory structure patterns";
+  async analyze(scanner) {
+    const patterns = [];
+    const files = scanner.getFiles();
+    const dirPatterns = this.analyzeDirectoryConventions(files);
+    patterns.push(...dirPatterns);
+    const filePatterns = this.analyzeFileNaming(files);
+    patterns.push(...filePatterns);
+    const colocationPattern = this.analyzeColocation(files);
+    if (colocationPattern) patterns.push(colocationPattern);
+    return patterns;
+  }
+  analyzeDirectoryConventions(files) {
+    const patterns = [];
+    const dirCounts = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      const dir = basename(dirname2(file.path));
+      dirCounts.set(dir, (dirCounts.get(dir) || 0) + 1);
+    }
+    const commonDirs = [
+      { name: "components", description: "UI components are organized in a components directory" },
+      { name: "hooks", description: "Custom hooks are organized in a hooks directory" },
+      { name: "utils", description: "Utility functions are organized in a utils directory" },
+      { name: "services", description: "Service modules are organized in a services directory" },
+      { name: "types", description: "Type definitions are organized in a types directory" },
+      { name: "api", description: "API modules are organized in an api directory" },
+      { name: "lib", description: "Library code is organized in a lib directory" },
+      { name: "core", description: "Core modules are organized in a core directory" }
+    ];
+    for (const { name, description } of commonDirs) {
+      const count = dirCounts.get(name);
+      if (count && count >= 3) {
+        const exampleFiles = files.filter((f) => basename(dirname2(f.path)) === name).slice(0, 3);
+        patterns.push(createPattern(this.id, {
+          id: `structure-dir-${name}`,
+          name: `${name}/ Directory Convention`,
+          description,
+          confidence: Math.min(100, 60 + count * 5),
+          occurrences: count,
+          examples: exampleFiles.map((f) => ({
+            file: f.path,
+            line: 1,
+            snippet: basename(f.path)
+          })),
+          suggestedConstraint: {
+            type: "convention",
+            rule: `${name.charAt(0).toUpperCase() + name.slice(1)} should be placed in the ${name}/ directory`,
+            severity: "low",
+            scope: `src/**/${name}/**/*.ts`
+          }
+        }));
+      }
+    }
+    return patterns;
+  }
+  analyzeFileNaming(files) {
+    const patterns = [];
+    const suffixPatterns = [
+      { suffix: ".test.ts", pattern: /\.test\.ts$/, description: "Test files use .test.ts suffix" },
+      { suffix: ".spec.ts", pattern: /\.spec\.ts$/, description: "Test files use .spec.ts suffix" },
+      { suffix: ".types.ts", pattern: /\.types\.ts$/, description: "Type definition files use .types.ts suffix" },
+      { suffix: ".utils.ts", pattern: /\.utils\.ts$/, description: "Utility files use .utils.ts suffix" },
+      { suffix: ".service.ts", pattern: /\.service\.ts$/, description: "Service files use .service.ts suffix" },
+      { suffix: ".controller.ts", pattern: /\.controller\.ts$/, description: "Controller files use .controller.ts suffix" },
+      { suffix: ".model.ts", pattern: /\.model\.ts$/, description: "Model files use .model.ts suffix" },
+      { suffix: ".schema.ts", pattern: /\.schema\.ts$/, description: "Schema files use .schema.ts suffix" }
+    ];
+    for (const { suffix, pattern, description } of suffixPatterns) {
+      const matchingFiles = files.filter((f) => pattern.test(f.path));
+      if (matchingFiles.length >= 3) {
+        const confidence = Math.min(100, 60 + matchingFiles.length * 3);
+        patterns.push(createPattern(this.id, {
+          id: `structure-suffix-${suffix.replace(/\./g, "-")}`,
+          name: `${suffix} File Naming`,
+          description,
+          confidence,
+          occurrences: matchingFiles.length,
+          examples: matchingFiles.slice(0, 3).map((f) => ({
+            file: f.path,
+            line: 1,
+            snippet: basename(f.path)
+          }))
+        }));
+      }
+    }
+    return patterns;
+  }
+  analyzeColocation(files) {
+    const testFiles = files.filter((f) => /\.(test|spec)\.tsx?$/.test(f.path));
+    const sourceFiles = files.filter((f) => !/\.(test|spec)\.tsx?$/.test(f.path));
+    if (testFiles.length < 3) return null;
+    let colocatedCount = 0;
+    const colocatedExamples = [];
+    for (const testFile of testFiles) {
+      const testDir = dirname2(testFile.path);
+      const testName = basename(testFile.path).replace(/\.(test|spec)\.tsx?$/, "");
+      const hasColocatedSource = sourceFiles.some(
+        (s) => dirname2(s.path) === testDir && basename(s.path).startsWith(testName)
+      );
+      if (hasColocatedSource) {
+        colocatedCount++;
+        if (colocatedExamples.length < 3) {
+          colocatedExamples.push({
+            file: testFile.path,
+            line: 1,
+            snippet: basename(testFile.path)
+          });
+        }
+      }
+    }
+    const confidence = calculateConfidence(colocatedCount, testFiles.length);
+    if (confidence < 60) return null;
+    return createPattern(this.id, {
+      id: "structure-colocation",
+      name: "Test Colocation Pattern",
+      description: "Test files are colocated with their source files",
+      confidence,
+      occurrences: colocatedCount,
+      examples: colocatedExamples,
+      suggestedConstraint: {
+        type: "guideline",
+        rule: "Test files should be colocated with their source files",
+        severity: "low",
+        scope: "src/**/*.test.ts"
+      }
+    });
+  }
+};
+
+// src/inference/analyzers/errors.ts
+import { Node as Node2 } from "ts-morph";
+var ErrorsAnalyzer = class {
+  id = "errors";
+  name = "Error Handling Analyzer";
+  description = "Detects error handling patterns and custom error class usage";
+  async analyze(scanner) {
+    const patterns = [];
+    const errorClassPattern = this.analyzeCustomErrorClasses(scanner);
+    if (errorClassPattern) patterns.push(errorClassPattern);
+    const tryCatchPattern = this.analyzeTryCatchPatterns(scanner);
+    if (tryCatchPattern) patterns.push(tryCatchPattern);
+    const throwPattern = this.analyzeThrowPatterns(scanner);
+    if (throwPattern) patterns.push(throwPattern);
+    return patterns;
+  }
+  analyzeCustomErrorClasses(scanner) {
+    const classes = scanner.findClasses();
+    const errorClasses = classes.filter(
+      (c) => c.name.endsWith("Error") || c.name.endsWith("Exception")
+    );
+    if (errorClasses.length < 2) return null;
+    const files = scanner.getFiles();
+    let extendsError = 0;
+    let extendsCustomBase = 0;
+    let customBaseName = null;
+    for (const errorClass of errorClasses) {
+      const file = files.find((f) => f.path === errorClass.file);
+      if (!file) continue;
+      const classDecl = file.sourceFile.getClass(errorClass.name);
+      if (!classDecl) continue;
+      const extendClause = classDecl.getExtends();
+      if (extendClause) {
+        const baseName = extendClause.getText();
+        if (baseName === "Error") {
+          extendsError++;
+        } else if (baseName.endsWith("Error")) {
+          extendsCustomBase++;
+          customBaseName = customBaseName || baseName;
+        }
+      }
+    }
+    if (extendsCustomBase >= 2 && customBaseName) {
+      const confidence = calculateConfidence(extendsCustomBase, errorClasses.length);
+      return createPattern(this.id, {
+        id: "errors-custom-base",
+        name: "Custom Error Base Class",
+        description: `Custom errors extend a common base class (${customBaseName})`,
+        confidence,
+        occurrences: extendsCustomBase,
+        examples: errorClasses.slice(0, 3).map((c) => ({
+          file: c.file,
+          line: c.line,
+          snippet: `class ${c.name} extends ${customBaseName}`
+        })),
+        suggestedConstraint: {
+          type: "convention",
+          rule: `Custom error classes should extend ${customBaseName}`,
+          severity: "medium",
+          scope: "src/**/*.ts",
+          verifier: "error-hierarchy"
+        }
+      });
+    }
+    if (errorClasses.length >= 3) {
+      const confidence = Math.min(100, 50 + errorClasses.length * 5);
+      return createPattern(this.id, {
+        id: "errors-custom-classes",
+        name: "Custom Error Classes",
+        description: "Custom error classes are used for domain-specific errors",
+        confidence,
+        occurrences: errorClasses.length,
+        examples: errorClasses.slice(0, 3).map((c) => ({
+          file: c.file,
+          line: c.line,
+          snippet: `class ${c.name}`
+        })),
+        suggestedConstraint: {
+          type: "guideline",
+          rule: "Use custom error classes for domain-specific errors",
+          severity: "low",
+          scope: "src/**/*.ts"
+        }
+      });
+    }
+    return null;
+  }
+  analyzeTryCatchPatterns(scanner) {
+    const tryCatchBlocks = scanner.findTryCatchBlocks();
+    if (tryCatchBlocks.length < 3) return null;
+    const rethrowCount = tryCatchBlocks.filter((b) => b.hasThrow).length;
+    const swallowCount = tryCatchBlocks.length - rethrowCount;
+    if (rethrowCount >= 3 && rethrowCount > swallowCount) {
+      const confidence = calculateConfidence(rethrowCount, tryCatchBlocks.length);
+      return createPattern(this.id, {
+        id: "errors-rethrow",
+        name: "Error Rethrow Pattern",
+        description: "Caught errors are typically rethrown after handling",
+        confidence,
+        occurrences: rethrowCount,
+        examples: tryCatchBlocks.filter((b) => b.hasThrow).slice(0, 3).map((b) => ({
+          file: b.file,
+          line: b.line,
+          snippet: "try { ... } catch (e) { ... throw ... }"
+        })),
+        suggestedConstraint: {
+          type: "guideline",
+          rule: "Caught errors should be rethrown or wrapped after handling",
+          severity: "low",
+          scope: "src/**/*.ts"
+        }
+      });
+    }
+    return null;
+  }
+  analyzeThrowPatterns(scanner) {
+    const files = scanner.getFiles();
+    let throwNewError = 0;
+    let throwCustom = 0;
+    const examples = [];
+    for (const { path, sourceFile } of files) {
+      sourceFile.forEachDescendant((node) => {
+        if (Node2.isThrowStatement(node)) {
+          const expression = node.getExpression();
+          if (expression) {
+            const text = expression.getText();
+            if (text.startsWith("new Error(")) {
+              throwNewError++;
+            } else if (text.startsWith("new ") && text.includes("Error")) {
+              throwCustom++;
+              if (examples.length < 3) {
+                examples.push({
+                  file: path,
+                  line: node.getStartLineNumber(),
+                  snippet: `throw ${text.slice(0, 50)}${text.length > 50 ? "..." : ""}`
+                });
+              }
+            }
+          }
+        }
+      });
+    }
+    if (throwCustom >= 3 && throwCustom > throwNewError) {
+      const confidence = calculateConfidence(throwCustom, throwCustom + throwNewError);
+      return createPattern(this.id, {
+        id: "errors-throw-custom",
+        name: "Custom Error Throwing",
+        description: "Custom error classes are thrown instead of generic Error",
+        confidence,
+        occurrences: throwCustom,
+        examples,
+        suggestedConstraint: {
+          type: "convention",
+          rule: "Throw custom error classes instead of generic Error",
+          severity: "medium",
+          scope: "src/**/*.ts",
+          verifier: "custom-errors-only"
+        }
+      });
+    }
+    return null;
+  }
+};
+
+// src/inference/analyzers/index.ts
+var builtinAnalyzers = {
+  naming: () => new NamingAnalyzer(),
+  imports: () => new ImportsAnalyzer(),
+  structure: () => new StructureAnalyzer(),
+  errors: () => new ErrorsAnalyzer()
+};
+function getAnalyzer(id) {
+  const factory = builtinAnalyzers[id];
+  return factory ? factory() : null;
+}
+function getAnalyzerIds() {
+  return Object.keys(builtinAnalyzers);
+}
+
+// src/inference/engine.ts
+var InferenceEngine = class {
+  scanner;
+  analyzers = [];
+  constructor() {
+    this.scanner = new CodeScanner();
+  }
+  /**
+   * Configure analyzers to use
+   */
+  configureAnalyzers(analyzerIds) {
+    this.analyzers = [];
+    for (const id of analyzerIds) {
+      const analyzer = getAnalyzer(id);
+      if (!analyzer) {
+        throw new AnalyzerNotFoundError(id);
+      }
+      this.analyzers.push(analyzer);
+    }
+  }
+  /**
+   * Run inference on the codebase
+   */
+  async infer(options) {
+    const startTime = Date.now();
+    const {
+      analyzers: analyzerIds = getAnalyzerIds(),
+      minConfidence = 50,
+      sourceRoots = ["src/**/*.ts", "src/**/*.tsx"],
+      exclude = ["**/*.test.ts", "**/*.spec.ts", "**/node_modules/**", "**/dist/**"],
+      cwd = process.cwd()
+    } = options;
+    this.configureAnalyzers(analyzerIds);
+    const scanResult = await this.scanner.scan({
+      sourceRoots,
+      exclude,
+      cwd
+    });
+    if (scanResult.totalFiles === 0) {
+      return {
+        patterns: [],
+        analyzersRun: analyzerIds,
+        filesScanned: 0,
+        duration: Date.now() - startTime
+      };
+    }
+    const allPatterns = [];
+    for (const analyzer of this.analyzers) {
+      try {
+        const patterns = await analyzer.analyze(this.scanner);
+        allPatterns.push(...patterns);
+      } catch (error) {
+        console.warn(`Analyzer ${analyzer.id} failed:`, error);
+      }
+    }
+    const filteredPatterns = allPatterns.filter((p) => p.confidence >= minConfidence);
+    filteredPatterns.sort((a, b) => b.confidence - a.confidence);
+    return {
+      patterns: filteredPatterns,
+      analyzersRun: analyzerIds,
+      filesScanned: scanResult.totalFiles,
+      duration: Date.now() - startTime
+    };
+  }
+  /**
+   * Get scanner for direct access
+   */
+  getScanner() {
+    return this.scanner;
+  }
+};
+function createInferenceEngine() {
+  return new InferenceEngine();
+}
+async function runInference(config, options) {
+  const engine = createInferenceEngine();
+  return engine.infer({
+    analyzers: config.inference?.analyzers,
+    minConfidence: config.inference?.minConfidence,
+    sourceRoots: config.project.sourceRoots,
+    exclude: config.project.exclude,
+    ...options
+  });
+}
+
+// src/verification/engine.ts
+import { Project as Project2 } from "ts-morph";
+
+// src/verification/verifiers/base.ts
+function createViolation(params) {
+  return params;
+}
+
+// src/verification/verifiers/naming.ts
+var NAMING_PATTERNS = {
+  PascalCase: {
+    regex: /^[A-Z][a-zA-Z0-9]*$/,
+    description: "PascalCase (e.g., MyClass)"
+  },
+  camelCase: {
+    regex: /^[a-z][a-zA-Z0-9]*$/,
+    description: "camelCase (e.g., myFunction)"
+  },
+  UPPER_SNAKE_CASE: {
+    regex: /^[A-Z][A-Z0-9_]*$/,
+    description: "UPPER_SNAKE_CASE (e.g., MAX_VALUE)"
+  },
+  snake_case: {
+    regex: /^[a-z][a-z0-9_]*$/,
+    description: "snake_case (e.g., my_variable)"
+  },
+  "kebab-case": {
+    regex: /^[a-z][a-z0-9-]*$/,
+    description: "kebab-case (e.g., my-component)"
+  }
+};
+var NamingVerifier = class {
+  id = "naming";
+  name = "Naming Convention Verifier";
+  description = "Verifies naming conventions for classes, functions, and variables";
+  async verify(ctx) {
+    const violations = [];
+    const { sourceFile, constraint, decisionId, filePath } = ctx;
+    const rule = constraint.rule.toLowerCase();
+    let convention = null;
+    let targetType = null;
+    for (const [name] of Object.entries(NAMING_PATTERNS)) {
+      if (rule.includes(name.toLowerCase())) {
+        convention = name;
+        break;
+      }
+    }
+    if (rule.includes("class")) targetType = "class";
+    else if (rule.includes("function")) targetType = "function";
+    else if (rule.includes("interface")) targetType = "interface";
+    else if (rule.includes("type")) targetType = "type";
+    if (!convention || !targetType) {
+      return violations;
+    }
+    const pattern = NAMING_PATTERNS[convention];
+    if (!pattern) return violations;
+    if (targetType === "class") {
+      for (const classDecl of sourceFile.getClasses()) {
+        const name = classDecl.getName();
+        if (name && !pattern.regex.test(name)) {
+          violations.push(createViolation({
+            decisionId,
+            constraintId: constraint.id,
+            type: constraint.type,
+            severity: constraint.severity,
+            message: `Class "${name}" does not follow ${pattern.description} naming convention`,
+            file: filePath,
+            line: classDecl.getStartLineNumber(),
+            column: classDecl.getStart() - classDecl.getStartLinePos(),
+            suggestion: `Rename to follow ${pattern.description}`
+          }));
+        }
+      }
+    }
+    if (targetType === "function") {
+      for (const funcDecl of sourceFile.getFunctions()) {
+        const name = funcDecl.getName();
+        if (name && !pattern.regex.test(name)) {
+          violations.push(createViolation({
+            decisionId,
+            constraintId: constraint.id,
+            type: constraint.type,
+            severity: constraint.severity,
+            message: `Function "${name}" does not follow ${pattern.description} naming convention`,
+            file: filePath,
+            line: funcDecl.getStartLineNumber(),
+            suggestion: `Rename to follow ${pattern.description}`
+          }));
+        }
+      }
+    }
+    if (targetType === "interface") {
+      for (const interfaceDecl of sourceFile.getInterfaces()) {
+        const name = interfaceDecl.getName();
+        if (!pattern.regex.test(name)) {
+          violations.push(createViolation({
+            decisionId,
+            constraintId: constraint.id,
+            type: constraint.type,
+            severity: constraint.severity,
+            message: `Interface "${name}" does not follow ${pattern.description} naming convention`,
+            file: filePath,
+            line: interfaceDecl.getStartLineNumber(),
+            suggestion: `Rename to follow ${pattern.description}`
+          }));
+        }
+      }
+    }
+    if (targetType === "type") {
+      for (const typeAlias of sourceFile.getTypeAliases()) {
+        const name = typeAlias.getName();
+        if (!pattern.regex.test(name)) {
+          violations.push(createViolation({
+            decisionId,
+            constraintId: constraint.id,
+            type: constraint.type,
+            severity: constraint.severity,
+            message: `Type "${name}" does not follow ${pattern.description} naming convention`,
+            file: filePath,
+            line: typeAlias.getStartLineNumber(),
+            suggestion: `Rename to follow ${pattern.description}`
+          }));
+        }
+      }
+    }
+    return violations;
+  }
+};
+
+// src/verification/verifiers/imports.ts
+var ImportsVerifier = class {
+  id = "imports";
+  name = "Import Pattern Verifier";
+  description = "Verifies import patterns like barrel imports, path aliases, etc.";
+  async verify(ctx) {
+    const violations = [];
+    const { sourceFile, constraint, decisionId, filePath } = ctx;
+    const rule = constraint.rule.toLowerCase();
+    if (rule.includes("barrel") || rule.includes("index")) {
+      for (const importDecl of sourceFile.getImportDeclarations()) {
+        const moduleSpec = importDecl.getModuleSpecifierValue();
+        if (!moduleSpec.startsWith(".")) continue;
+        if (moduleSpec.match(/\.(ts|js|tsx|jsx)$/) || moduleSpec.match(/\/[^/]+$/)) {
+          if (!moduleSpec.endsWith("/index") && !moduleSpec.endsWith("index")) {
+            violations.push(createViolation({
+              decisionId,
+              constraintId: constraint.id,
+              type: constraint.type,
+              severity: constraint.severity,
+              message: `Import from "${moduleSpec}" should use barrel (index) import`,
+              file: filePath,
+              line: importDecl.getStartLineNumber(),
+              suggestion: "Import from the parent directory index file instead"
+            }));
+          }
+        }
+      }
+    }
+    if (rule.includes("alias") || rule.includes("@/") || rule.includes("path alias")) {
+      for (const importDecl of sourceFile.getImportDeclarations()) {
+        const moduleSpec = importDecl.getModuleSpecifierValue();
+        if (moduleSpec.match(/^\.\.\/\.\.\/\.\.\//)) {
+          violations.push(createViolation({
+            decisionId,
+            constraintId: constraint.id,
+            type: constraint.type,
+            severity: constraint.severity,
+            message: `Deep relative import "${moduleSpec}" should use path alias`,
+            file: filePath,
+            line: importDecl.getStartLineNumber(),
+            suggestion: "Use path alias (e.g., @/module) for deep imports"
+          }));
+        }
+      }
+    }
+    if (rule.includes("circular") || rule.includes("cycle")) {
+      const currentFilename = filePath.replace(/\.[jt]sx?$/, "");
+      for (const importDecl of sourceFile.getImportDeclarations()) {
+        const moduleSpec = importDecl.getModuleSpecifierValue();
+        if (moduleSpec.includes(currentFilename.split("/").pop() || "")) {
+          violations.push(createViolation({
+            decisionId,
+            constraintId: constraint.id,
+            type: constraint.type,
+            severity: constraint.severity,
+            message: `Possible circular import detected: "${moduleSpec}"`,
+            file: filePath,
+            line: importDecl.getStartLineNumber(),
+            suggestion: "Review import structure for circular dependencies"
+          }));
+        }
+      }
+    }
+    if (rule.includes("wildcard") || rule.includes("* as") || rule.includes("no namespace")) {
+      for (const importDecl of sourceFile.getImportDeclarations()) {
+        const namespaceImport = importDecl.getNamespaceImport();
+        if (namespaceImport) {
+          violations.push(createViolation({
+            decisionId,
+            constraintId: constraint.id,
+            type: constraint.type,
+            severity: constraint.severity,
+            message: `Namespace import "* as ${namespaceImport.getText()}" should use named imports`,
+            file: filePath,
+            line: importDecl.getStartLineNumber(),
+            suggestion: "Use specific named imports instead of namespace import"
+          }));
+        }
+      }
+    }
+    return violations;
+  }
+};
+
+// src/verification/verifiers/errors.ts
+import { Node as Node3 } from "ts-morph";
+var ErrorsVerifier = class {
+  id = "errors";
+  name = "Error Handling Verifier";
+  description = "Verifies error handling patterns";
+  async verify(ctx) {
+    const violations = [];
+    const { sourceFile, constraint, decisionId, filePath } = ctx;
+    const rule = constraint.rule.toLowerCase();
+    if (rule.includes("extend") || rule.includes("base") || rule.includes("hierarchy")) {
+      const baseClassMatch = rule.match(/extend\s+(\w+)/i) || rule.match(/(\w+Error)\s+class/i);
+      const requiredBase = baseClassMatch ? baseClassMatch[1] : null;
+      for (const classDecl of sourceFile.getClasses()) {
+        const className = classDecl.getName();
+        if (!className?.endsWith("Error") && !className?.endsWith("Exception")) continue;
+        const extendsClause = classDecl.getExtends();
+        if (!extendsClause) {
+          violations.push(createViolation({
+            decisionId,
+            constraintId: constraint.id,
+            type: constraint.type,
+            severity: constraint.severity,
+            message: `Error class "${className}" does not extend any base class`,
+            file: filePath,
+            line: classDecl.getStartLineNumber(),
+            suggestion: requiredBase ? `Extend ${requiredBase}` : "Extend a base error class for consistent error handling"
+          }));
+        } else if (requiredBase) {
+          const baseName = extendsClause.getText();
+          if (baseName !== requiredBase && baseName !== "Error") {
+          }
+        }
+      }
+    }
+    if (rule.includes("custom error") || rule.includes("throw custom")) {
+      sourceFile.forEachDescendant((node) => {
+        if (Node3.isThrowStatement(node)) {
+          const expression = node.getExpression();
+          if (expression) {
+            const text = expression.getText();
+            if (text.startsWith("new Error(")) {
+              violations.push(createViolation({
+                decisionId,
+                constraintId: constraint.id,
+                type: constraint.type,
+                severity: constraint.severity,
+                message: "Throwing generic Error instead of custom error class",
+                file: filePath,
+                line: node.getStartLineNumber(),
+                suggestion: "Use a custom error class for better error handling"
+              }));
+            }
+          }
+        }
+      });
+    }
+    if (rule.includes("empty catch") || rule.includes("swallow") || rule.includes("handle")) {
+      sourceFile.forEachDescendant((node) => {
+        if (Node3.isTryStatement(node)) {
+          const catchClause = node.getCatchClause();
+          if (catchClause) {
+            const block = catchClause.getBlock();
+            const statements = block.getStatements();
+            if (statements.length === 0) {
+              violations.push(createViolation({
+                decisionId,
+                constraintId: constraint.id,
+                type: constraint.type,
+                severity: constraint.severity,
+                message: "Empty catch block swallows error without handling",
+                file: filePath,
+                line: catchClause.getStartLineNumber(),
+                suggestion: "Add error handling, logging, or rethrow the error"
+              }));
+            }
+          }
+        }
+      });
+    }
+    if (rule.includes("logging") || rule.includes("logger") || rule.includes("no console")) {
+      sourceFile.forEachDescendant((node) => {
+        if (Node3.isCallExpression(node)) {
+          const expression = node.getExpression();
+          const text = expression.getText();
+          if (text === "console.error" || text === "console.log") {
+            violations.push(createViolation({
+              decisionId,
+              constraintId: constraint.id,
+              type: constraint.type,
+              severity: constraint.severity,
+              message: `Using ${text} instead of proper logging`,
+              file: filePath,
+              line: node.getStartLineNumber(),
+              suggestion: "Use a proper logging library"
+            }));
+          }
+        }
+      });
+    }
+    return violations;
+  }
+};
+
+// src/verification/verifiers/regex.ts
+var RegexVerifier = class {
+  id = "regex";
+  name = "Regex Pattern Verifier";
+  description = "Verifies code against regex patterns specified in constraints";
+  async verify(ctx) {
+    const violations = [];
+    const { sourceFile, constraint, decisionId, filePath } = ctx;
+    const rule = constraint.rule;
+    const mustNotMatch = rule.match(/must\s+not\s+(?:contain|match|use)\s+\/(.+?)\//i);
+    const shouldMatch = rule.match(/(?:should|must)\s+(?:contain|match|use)\s+\/(.+?)\//i);
+    const forbiddenPattern = rule.match(/forbidden:\s*\/(.+?)\//i);
+    const requiredPattern = rule.match(/required:\s*\/(.+?)\//i);
+    const fileText = sourceFile.getFullText();
+    const patternToForbid = mustNotMatch?.[1] || forbiddenPattern?.[1];
+    if (patternToForbid) {
+      try {
+        const regex = new RegExp(patternToForbid, "g");
+        let match;
+        while ((match = regex.exec(fileText)) !== null) {
+          const beforeMatch = fileText.substring(0, match.index);
+          const lineNumber = beforeMatch.split("\n").length;
+          violations.push(createViolation({
+            decisionId,
+            constraintId: constraint.id,
+            type: constraint.type,
+            severity: constraint.severity,
+            message: `Found forbidden pattern: "${match[0]}"`,
+            file: filePath,
+            line: lineNumber,
+            suggestion: `Remove or replace the pattern matching /${patternToForbid}/`
+          }));
+        }
+      } catch {
+      }
+    }
+    const patternToRequire = shouldMatch?.[1] || requiredPattern?.[1];
+    if (patternToRequire && !mustNotMatch) {
+      try {
+        const regex = new RegExp(patternToRequire);
+        if (!regex.test(fileText)) {
+          violations.push(createViolation({
+            decisionId,
+            constraintId: constraint.id,
+            type: constraint.type,
+            severity: constraint.severity,
+            message: `File does not contain required pattern: /${patternToRequire}/`,
+            file: filePath,
+            suggestion: `Add code matching /${patternToRequire}/`
+          }));
+        }
+      } catch {
+      }
+    }
+    return violations;
+  }
+};
+
+// src/verification/verifiers/index.ts
+var builtinVerifiers = {
+  naming: () => new NamingVerifier(),
+  imports: () => new ImportsVerifier(),
+  errors: () => new ErrorsVerifier(),
+  regex: () => new RegexVerifier()
+};
+function getVerifier(id) {
+  const factory = builtinVerifiers[id];
+  return factory ? factory() : null;
+}
+function getVerifierIds() {
+  return Object.keys(builtinVerifiers);
+}
+function selectVerifierForConstraint(rule, specifiedVerifier) {
+  if (specifiedVerifier) {
+    return getVerifier(specifiedVerifier);
+  }
+  const lowerRule = rule.toLowerCase();
+  if (lowerRule.includes("naming") || lowerRule.includes("case")) {
+    return getVerifier("naming");
+  }
+  if (lowerRule.includes("import") || lowerRule.includes("barrel") || lowerRule.includes("alias")) {
+    return getVerifier("imports");
+  }
+  if (lowerRule.includes("error") || lowerRule.includes("throw") || lowerRule.includes("catch")) {
+    return getVerifier("errors");
+  }
+  if (lowerRule.includes("/") || lowerRule.includes("pattern") || lowerRule.includes("regex")) {
+    return getVerifier("regex");
+  }
+  return getVerifier("regex");
+}
+
+// src/verification/engine.ts
+var VerificationEngine = class {
+  registry;
+  project;
+  constructor(registry) {
+    this.registry = registry || createRegistry();
+    this.project = new Project2({
+      compilerOptions: {
+        allowJs: true,
+        checkJs: false,
+        noEmit: true,
+        skipLibCheck: true
+      },
+      skipAddingFilesFromTsConfig: true
+    });
+  }
+  /**
+   * Run verification
+   */
+  async verify(config, options = {}) {
+    const startTime = Date.now();
+    const {
+      level = "full",
+      files: specificFiles,
+      decisions: decisionIds,
+      cwd = process.cwd()
+    } = options;
+    const levelConfig = config.verification?.levels?.[level];
+    const severityFilter = options.severity || levelConfig?.severity;
+    const timeout = options.timeout || levelConfig?.timeout || 6e4;
+    await this.registry.load();
+    let decisions = this.registry.getActive();
+    if (decisionIds && decisionIds.length > 0) {
+      decisions = decisions.filter((d) => decisionIds.includes(d.metadata.id));
+    }
+    const filesToVerify = specificFiles ? specificFiles : await glob(config.project.sourceRoots, {
+      cwd,
+      ignore: config.project.exclude,
+      absolute: true
+    });
+    if (filesToVerify.length === 0) {
+      return {
+        success: true,
+        violations: [],
+        checked: 0,
+        passed: 0,
+        failed: 0,
+        skipped: 0,
+        duration: Date.now() - startTime
+      };
+    }
+    const allViolations = [];
+    let checked = 0;
+    let passed = 0;
+    let failed = 0;
+    let skipped = 0;
+    const timeoutPromise = new Promise(
+      (resolve) => setTimeout(() => resolve("timeout"), timeout)
+    );
+    const verificationPromise = this.verifyFiles(
+      filesToVerify,
+      decisions,
+      severityFilter,
+      (violations) => {
+        allViolations.push(...violations);
+        checked++;
+        if (violations.length > 0) {
+          failed++;
+        } else {
+          passed++;
+        }
+      }
+    );
+    const result = await Promise.race([verificationPromise, timeoutPromise]);
+    if (result === "timeout") {
+      return {
+        success: false,
+        violations: allViolations,
+        checked,
+        passed,
+        failed,
+        skipped: filesToVerify.length - checked,
+        duration: timeout
+      };
+    }
+    const hasBlockingViolations = allViolations.some((v) => {
+      if (level === "commit") {
+        return v.type === "invariant" || v.severity === "critical";
+      }
+      if (level === "pr") {
+        return v.type === "invariant" || v.severity === "critical" || v.severity === "high";
+      }
+      return v.type === "invariant";
+    });
+    return {
+      success: !hasBlockingViolations,
+      violations: allViolations,
+      checked,
+      passed,
+      failed,
+      skipped,
+      duration: Date.now() - startTime
+    };
+  }
+  /**
+   * Verify a single file
+   */
+  async verifyFile(filePath, decisions, severityFilter) {
+    const violations = [];
+    let sourceFile = this.project.getSourceFile(filePath);
+    if (!sourceFile) {
+      try {
+        sourceFile = this.project.addSourceFileAtPath(filePath);
+      } catch {
+        return violations;
+      }
+    }
+    for (const decision of decisions) {
+      for (const constraint of decision.constraints) {
+        if (!matchesPattern(filePath, constraint.scope)) {
+          continue;
+        }
+        if (severityFilter && !severityFilter.includes(constraint.severity)) {
+          continue;
+        }
+        if (this.isExcepted(filePath, constraint)) {
+          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;
+  }
+  /**
+   * Verify multiple files
+   */
+  async verifyFiles(files, decisions, severityFilter, onFileVerified) {
+    for (const file of files) {
+      const violations = await this.verifyFile(file, decisions, severityFilter);
+      onFileVerified(violations);
+    }
+  }
+  /**
+   * Check if file is excepted from constraint
+   */
+  isExcepted(filePath, constraint) {
+    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);
+    });
+  }
+  /**
+   * Get registry
+   */
+  getRegistry() {
+    return this.registry;
+  }
+};
+function createVerificationEngine(registry) {
+  return new VerificationEngine(registry);
+}
+
+// src/propagation/graph.ts
+async function buildDependencyGraph(decisions, files) {
+  const nodes = /* @__PURE__ */ new Map();
+  const decisionToFiles = /* @__PURE__ */ new Map();
+  const fileToDecisions = /* @__PURE__ */ new Map();
+  for (const decision of decisions) {
+    const decisionId = `decision:${decision.metadata.id}`;
+    nodes.set(decisionId, {
+      type: "decision",
+      id: decision.metadata.id,
+      edges: decision.constraints.map((c) => `constraint:${decision.metadata.id}/${c.id}`)
+    });
+    for (const constraint of decision.constraints) {
+      const constraintId = `constraint:${decision.metadata.id}/${constraint.id}`;
+      const matchingFiles = [];
+      for (const file of files) {
+        if (matchesPattern(file, constraint.scope)) {
+          matchingFiles.push(`file:${file}`);
+          const fileDecisions = fileToDecisions.get(file) || /* @__PURE__ */ new Set();
+          fileDecisions.add(decision.metadata.id);
+          fileToDecisions.set(file, fileDecisions);
+          const decFiles = decisionToFiles.get(decision.metadata.id) || /* @__PURE__ */ new Set();
+          decFiles.add(file);
+          decisionToFiles.set(decision.metadata.id, decFiles);
+        }
+      }
+      nodes.set(constraintId, {
+        type: "constraint",
+        id: `${decision.metadata.id}/${constraint.id}`,
+        edges: matchingFiles
+      });
+    }
+  }
+  for (const file of files) {
+    const fileId = `file:${file}`;
+    if (!nodes.has(fileId)) {
+      nodes.set(fileId, {
+        type: "file",
+        id: file,
+        edges: []
+      });
+    }
+  }
+  return {
+    nodes,
+    decisionToFiles,
+    fileToDecisions
+  };
+}
+function getAffectedFiles(graph, decisionId) {
+  const files = graph.decisionToFiles.get(decisionId);
+  return files ? Array.from(files) : [];
+}
+function getAffectingDecisions(graph, filePath) {
+  const decisions = graph.fileToDecisions.get(filePath);
+  return decisions ? Array.from(decisions) : [];
+}
+function getTransitiveDependencies(graph, nodeId, visited = /* @__PURE__ */ new Set()) {
+  if (visited.has(nodeId)) {
+    return [];
+  }
+  visited.add(nodeId);
+  const node = graph.nodes.get(nodeId);
+  if (!node) {
+    return [];
+  }
+  const deps = [nodeId];
+  for (const edge of node.edges) {
+    deps.push(...getTransitiveDependencies(graph, edge, visited));
+  }
+  return deps;
+}
+
+// src/propagation/engine.ts
+var PropagationEngine = class {
+  registry;
+  graph = null;
+  constructor(registry) {
+    this.registry = registry || createRegistry();
+  }
+  /**
+   * Initialize the engine with current state
+   */
+  async initialize(config, options = {}) {
+    const { cwd = process.cwd() } = options;
+    await this.registry.load();
+    const files = await glob(config.project.sourceRoots, {
+      cwd,
+      ignore: config.project.exclude,
+      absolute: true
+    });
+    const decisions = this.registry.getActive();
+    this.graph = await buildDependencyGraph(decisions, files);
+  }
+  /**
+   * Analyze impact of changing a decision
+   */
+  async analyzeImpact(decisionId, change, config, options = {}) {
+    const { cwd = process.cwd() } = options;
+    if (!this.graph) {
+      await this.initialize(config, options);
+    }
+    const affectedFilePaths = getAffectedFiles(this.graph, decisionId);
+    const verificationEngine = createVerificationEngine(this.registry);
+    const result = await verificationEngine.verify(config, {
+      files: affectedFilePaths,
+      decisions: [decisionId],
+      cwd
+    });
+    const fileViolations = /* @__PURE__ */ new Map();
+    for (const violation of result.violations) {
+      const existing = fileViolations.get(violation.file) || { total: 0, autoFixable: 0 };
+      existing.total++;
+      if (violation.autofix) {
+        existing.autoFixable++;
+      }
+      fileViolations.set(violation.file, existing);
+    }
+    const affectedFiles = affectedFilePaths.map((path) => ({
+      path,
+      violations: fileViolations.get(path)?.total || 0,
+      autoFixable: fileViolations.get(path)?.autoFixable || 0
+    }));
+    affectedFiles.sort((a, b) => b.violations - a.violations);
+    const totalViolations = result.violations.length;
+    const totalAutoFixable = result.violations.filter((v) => v.autofix).length;
+    const manualFixes = totalViolations - totalAutoFixable;
+    let estimatedEffort;
+    if (manualFixes === 0) {
+      estimatedEffort = "low";
+    } else if (manualFixes <= 10) {
+      estimatedEffort = "medium";
+    } else {
+      estimatedEffort = "high";
+    }
+    const migrationSteps = this.generateMigrationSteps(
+      affectedFiles,
+      totalAutoFixable > 0
+    );
+    return {
+      decision: decisionId,
+      change,
+      affectedFiles,
+      estimatedEffort,
+      migrationSteps
+    };
+  }
+  /**
+   * Generate migration steps
+   */
+  generateMigrationSteps(affectedFiles, hasAutoFixes) {
+    const steps = [];
+    let order = 1;
+    if (hasAutoFixes) {
+      steps.push({
+        order: order++,
+        description: "Run auto-fix for mechanical violations",
+        files: affectedFiles.filter((f) => f.autoFixable > 0).map((f) => f.path),
+        automated: true
+      });
+    }
+    const filesWithManualFixes = affectedFiles.filter(
+      (f) => f.violations > f.autoFixable
+    );
+    if (filesWithManualFixes.length > 0) {
+      const highPriority = filesWithManualFixes.filter((f) => f.violations > 5);
+      const mediumPriority = filesWithManualFixes.filter(
+        (f) => f.violations <= 5 && f.violations > 1
+      );
+      const lowPriority = filesWithManualFixes.filter((f) => f.violations === 1);
+      if (highPriority.length > 0) {
+        steps.push({
+          order: order++,
+          description: "Fix high-violation files first",
+          files: highPriority.map((f) => f.path),
+          automated: false
+        });
+      }
+      if (mediumPriority.length > 0) {
+        steps.push({
+          order: order++,
+          description: "Fix medium-violation files",
+          files: mediumPriority.map((f) => f.path),
+          automated: false
+        });
+      }
+      if (lowPriority.length > 0) {
+        steps.push({
+          order: order++,
+          description: "Fix remaining files",
+          files: lowPriority.map((f) => f.path),
+          automated: false
+        });
+      }
+    }
+    steps.push({
+      order: order++,
+      description: "Run verification to confirm all violations resolved",
+      files: [],
+      automated: true
+    });
+    return steps;
+  }
+  /**
+   * Get dependency graph
+   */
+  getGraph() {
+    return this.graph;
+  }
+};
+function createPropagationEngine(registry) {
+  return new PropagationEngine(registry);
+}
+
+// src/reporting/reporter.ts
+async function generateReport(config, options = {}) {
+  const { includeAll = false, cwd = process.cwd() } = options;
+  const registry = createRegistry({ basePath: cwd });
+  await registry.load();
+  const engine = createVerificationEngine(registry);
+  const result = await engine.verify(config, { level: "full", cwd });
+  const decisions = includeAll ? registry.getAll() : registry.getActive();
+  const byDecision = [];
+  for (const decision of decisions) {
+    const decisionViolations = result.violations.filter(
+      (v) => v.decisionId === decision.metadata.id
+    );
+    const constraintCount = decision.constraints.length;
+    const violationCount = decisionViolations.length;
+    const compliance = violationCount === 0 ? 100 : Math.max(0, 100 - Math.min(violationCount * 10, 100));
+    byDecision.push({
+      decisionId: decision.metadata.id,
+      title: decision.metadata.title,
+      status: decision.metadata.status,
+      constraints: constraintCount,
+      violations: violationCount,
+      compliance
+    });
+  }
+  byDecision.sort((a, b) => a.compliance - b.compliance);
+  const totalDecisions = decisions.length;
+  const activeDecisions = decisions.filter((d) => d.metadata.status === "active").length;
+  const totalConstraints = decisions.reduce((sum, d) => sum + d.constraints.length, 0);
+  const violationsBySeverity = {
+    critical: result.violations.filter((v) => v.severity === "critical").length,
+    high: result.violations.filter((v) => v.severity === "high").length,
+    medium: result.violations.filter((v) => v.severity === "medium").length,
+    low: result.violations.filter((v) => v.severity === "low").length
+  };
+  const overallCompliance = byDecision.length > 0 ? Math.round(byDecision.reduce((sum, d) => sum + d.compliance, 0) / byDecision.length) : 100;
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    project: config.project.name,
+    summary: {
+      totalDecisions,
+      activeDecisions,
+      totalConstraints,
+      violations: violationsBySeverity,
+      compliance: overallCompliance
+    },
+    byDecision
+  };
+}
+function checkDegradation(current, previous) {
+  if (!previous) {
+    return { degraded: false, details: [] };
+  }
+  const details = [];
+  let degraded = false;
+  if (current.summary.compliance < previous.summary.compliance) {
+    degraded = true;
+    details.push(
+      `Overall compliance dropped from ${previous.summary.compliance}% to ${current.summary.compliance}%`
+    );
+  }
+  const newCritical = current.summary.violations.critical - previous.summary.violations.critical;
+  const newHigh = current.summary.violations.high - previous.summary.violations.high;
+  if (newCritical > 0) {
+    degraded = true;
+    details.push(`${newCritical} new critical violation(s)`);
+  }
+  if (newHigh > 0) {
+    degraded = true;
+    details.push(`${newHigh} new high severity violation(s)`);
+  }
+  return { degraded, details };
+}
+var Reporter = class {
+  /**
+   * Generate formatted report from verification result
+   */
+  generate(result, options = {}) {
+    const { format = "table", groupBy } = options;
+    switch (format) {
+      case "json":
+        return JSON.stringify(result, null, 2);
+      case "markdown":
+        return this.formatAsMarkdown(result);
+      case "table":
+      default:
+        return groupBy ? this.formatAsTableGrouped(result, groupBy) : this.formatAsTable(result);
+    }
+  }
+  /**
+   * Generate compliance overview from multiple results
+   */
+  generateComplianceReport(results) {
+    const lines = [];
+    lines.push("# Compliance Report\n");
+    if (results.length === 0) {
+      lines.push("No results to report.\n");
+      return lines.join("\n");
+    }
+    const totalViolations = results.reduce(
+      (sum, r) => sum + (r.summary?.totalViolations || r.violations?.length || 0),
+      0
+    );
+    const avgViolations = totalViolations / results.length;
+    lines.push(`## Overall Statistics
+`);
+    lines.push(`- Total Results: ${results.length}`);
+    lines.push(`- Total Violations: ${totalViolations}`);
+    lines.push(`- Average Violations per Result: ${avgViolations.toFixed(1)}`);
+    const complianceRate = results.length > 0 ? results.filter((r) => (r.violations?.length || 0) === 0).length / results.length * 100 : 100;
+    lines.push(`- Compliance Rate: ${complianceRate.toFixed(1)}%
+`);
+    return lines.join("\n");
+  }
+  formatAsTable(result) {
+    const lines = [];
+    lines.push("Verification Report");
+    lines.push("=".repeat(50));
+    lines.push("");
+    if (result.summary) {
+      lines.push("Summary:");
+      lines.push(`  Decisions Checked: ${result.summary.decisionsChecked || 0}`);
+      lines.push(`  Files Checked: ${result.summary.filesChecked || 0}`);
+      lines.push(`  Total Violations: ${result.summary.totalViolations || result.violations?.length || 0}`);
+      lines.push(`  Critical: ${result.summary.critical || 0}`);
+      lines.push(`  High: ${result.summary.high || 0}`);
+      lines.push(`  Medium: ${result.summary.medium || 0}`);
+      lines.push(`  Low: ${result.summary.low || 0}`);
+      lines.push(`  Duration: ${result.summary.duration || 0}ms`);
+      lines.push("");
+    }
+    const totalViolations = result.summary?.totalViolations ?? result.violations?.length ?? 0;
+    if (totalViolations > 0 && result.violations && result.violations.length > 0) {
+      lines.push("Violations:");
+      lines.push("-".repeat(50));
+      result.violations.forEach((v) => {
+        const severity = v.severity.toLowerCase();
+        lines.push(`  [${v.severity.toUpperCase()}] ${v.decisionId} - ${v.constraintId} (${severity})`);
+        lines.push(`    ${v.message}`);
+        lines.push(`    Location: ${v.location?.file || v.file}:${v.location?.line || 0}:${v.location?.column || 0}`);
+        lines.push("");
+      });
+    } else {
+      lines.push("No violations found.");
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+  formatAsTableGrouped(result, groupBy) {
+    const lines = [];
+    lines.push("Verification Report");
+    lines.push("=".repeat(50));
+    lines.push("");
+    if (result.summary) {
+      lines.push("Summary:");
+      lines.push(`  Total Violations: ${result.summary.totalViolations || result.violations?.length || 0}`);
+      lines.push("");
+    }
+    if (result.violations && result.violations.length > 0) {
+      if (groupBy === "severity") {
+        const grouped = /* @__PURE__ */ new Map();
+        result.violations.forEach((v) => {
+          const key = v.severity;
+          if (!grouped.has(key)) grouped.set(key, []);
+          grouped.get(key).push(v);
+        });
+        for (const [severity, violations] of grouped.entries()) {
+          lines.push(`Severity: ${severity}`);
+          lines.push("-".repeat(30));
+          violations.forEach((v) => {
+            lines.push(`  ${v.decisionId} - ${v.message}`);
+          });
+          lines.push("");
+        }
+      } else if (groupBy === "file") {
+        const grouped = /* @__PURE__ */ new Map();
+        result.violations.forEach((v) => {
+          const key = v.location?.file || v.file || "unknown";
+          if (!grouped.has(key)) grouped.set(key, []);
+          grouped.get(key).push(v);
+        });
+        for (const [file, violations] of grouped.entries()) {
+          lines.push(`File: ${file}`);
+          lines.push("-".repeat(30));
+          violations.forEach((v) => {
+            lines.push(`  [${v.severity}] ${v.message}`);
+          });
+          lines.push("");
+        }
+      }
+    } else {
+      lines.push("No violations found.");
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+  formatAsMarkdown(result) {
+    const lines = [];
+    lines.push("## Verification Report\n");
+    if (result.summary) {
+      lines.push("### Summary\n");
+      lines.push(`- **Decisions Checked:** ${result.summary.decisionsChecked || 0}`);
+      lines.push(`- **Files Checked:** ${result.summary.filesChecked || 0}`);
+      lines.push(`- **Total Violations:** ${result.summary.totalViolations || result.violations?.length || 0}`);
+      lines.push(`- **Critical:** ${result.summary.critical || 0}`);
+      lines.push(`- **High:** ${result.summary.high || 0}`);
+      lines.push(`- **Medium:** ${result.summary.medium || 0}`);
+      lines.push(`- **Low:** ${result.summary.low || 0}
+`);
+    }
+    if (result.violations && result.violations.length > 0) {
+      lines.push("### Violations\n");
+      result.violations.forEach((v) => {
+        lines.push(`#### [${v.severity.toUpperCase()}] ${v.decisionId}`);
+        lines.push(`**Message:** ${v.message}`);
+        lines.push(`**Location:** \`${v.location?.file || v.file}:${v.location?.line || 0}\`
+`);
+      });
+    } else {
+      lines.push("No violations found.\n");
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/reporting/formats/console.ts
+import chalk from "chalk";
+import { table } from "table";
+function formatConsoleReport(report) {
+  const lines = [];
+  lines.push("");
+  lines.push(chalk.bold.blue("SpecBridge Compliance Report"));
+  lines.push(chalk.dim(`Generated: ${new Date(report.timestamp).toLocaleString()}`));
+  lines.push(chalk.dim(`Project: ${report.project}`));
+  lines.push("");
+  const complianceColor = getComplianceColor(report.summary.compliance);
+  lines.push(chalk.bold("Overall Compliance"));
+  lines.push(`  ${complianceColor(formatComplianceBar(report.summary.compliance))} ${complianceColor(`${report.summary.compliance}%`)}`);
+  lines.push("");
+  lines.push(chalk.bold("Summary"));
+  lines.push(`  Decisions: ${report.summary.activeDecisions} active / ${report.summary.totalDecisions} total`);
+  lines.push(`  Constraints: ${report.summary.totalConstraints}`);
+  lines.push("");
+  lines.push(chalk.bold("Violations"));
+  const { violations } = report.summary;
+  const violationParts = [];
+  if (violations.critical > 0) {
+    violationParts.push(chalk.red(`${violations.critical} critical`));
+  }
+  if (violations.high > 0) {
+    violationParts.push(chalk.yellow(`${violations.high} high`));
+  }
+  if (violations.medium > 0) {
+    violationParts.push(chalk.cyan(`${violations.medium} medium`));
+  }
+  if (violations.low > 0) {
+    violationParts.push(chalk.dim(`${violations.low} low`));
+  }
+  if (violationParts.length > 0) {
+    lines.push(`  ${violationParts.join(" | ")}`);
+  } else {
+    lines.push(chalk.green("  No violations"));
+  }
+  lines.push("");
+  if (report.byDecision.length > 0) {
+    lines.push(chalk.bold("By Decision"));
+    lines.push("");
+    const tableData = [
+      [
+        chalk.bold("Decision"),
+        chalk.bold("Status"),
+        chalk.bold("Constraints"),
+        chalk.bold("Violations"),
+        chalk.bold("Compliance")
+      ]
+    ];
+    for (const dec of report.byDecision) {
+      const compColor = getComplianceColor(dec.compliance);
+      const statusColor = getStatusColor(dec.status);
+      tableData.push([
+        truncate(dec.title, 40),
+        statusColor(dec.status),
+        String(dec.constraints),
+        dec.violations > 0 ? chalk.red(String(dec.violations)) : chalk.green("0"),
+        compColor(`${dec.compliance}%`)
+      ]);
+    }
+    const tableOutput = table(tableData, {
+      border: {
+        topBody: "",
+        topJoin: "",
+        topLeft: "",
+        topRight: "",
+        bottomBody: "",
+        bottomJoin: "",
+        bottomLeft: "",
+        bottomRight: "",
+        bodyLeft: "  ",
+        bodyRight: "",
+        bodyJoin: "  ",
+        joinBody: "",
+        joinLeft: "",
+        joinRight: "",
+        joinJoin: ""
+      },
+      drawHorizontalLine: (index) => index === 1
+    });
+    lines.push(tableOutput);
+  }
+  return lines.join("\n");
+}
+function formatComplianceBar(compliance) {
+  const filled = Math.round(compliance / 10);
+  const empty = 10 - filled;
+  return "\u2588".repeat(filled) + "\u2591".repeat(empty);
+}
+function getComplianceColor(compliance) {
+  if (compliance >= 90) return chalk.green;
+  if (compliance >= 70) return chalk.yellow;
+  if (compliance >= 50) return chalk.hex("#FFA500");
+  return chalk.red;
+}
+function getStatusColor(status) {
+  switch (status) {
+    case "active":
+      return chalk.green;
+    case "draft":
+      return chalk.yellow;
+    case "deprecated":
+      return chalk.gray;
+    case "superseded":
+      return chalk.blue;
+    default:
+      return chalk.white;
+  }
+}
+function truncate(str, length) {
+  if (str.length <= length) return str;
+  return str.slice(0, length - 3) + "...";
+}
+
+// src/reporting/formats/markdown.ts
+function formatMarkdownReport(report) {
+  const lines = [];
+  lines.push("# SpecBridge Compliance Report");
+  lines.push("");
+  lines.push(`**Project:** ${report.project}`);
+  lines.push(`**Generated:** ${new Date(report.timestamp).toLocaleString()}`);
+  lines.push("");
+  lines.push("## Overall Compliance");
+  lines.push("");
+  lines.push(`**Score:** ${report.summary.compliance}%`);
+  lines.push("");
+  lines.push(formatProgressBar(report.summary.compliance));
+  lines.push("");
+  lines.push("## Summary");
+  lines.push("");
+  lines.push(`- **Active Decisions:** ${report.summary.activeDecisions} / ${report.summary.totalDecisions}`);
+  lines.push(`- **Total Constraints:** ${report.summary.totalConstraints}`);
+  lines.push("");
+  lines.push("### Violations");
+  lines.push("");
+  const { violations } = report.summary;
+  const totalViolations = violations.critical + violations.high + violations.medium + violations.low;
+  if (totalViolations === 0) {
+    lines.push("No violations found.");
+  } else {
+    lines.push(`| Severity | Count |`);
+    lines.push(`|----------|-------|`);
+    lines.push(`| Critical | ${violations.critical} |`);
+    lines.push(`| High | ${violations.high} |`);
+    lines.push(`| Medium | ${violations.medium} |`);
+    lines.push(`| Low | ${violations.low} |`);
+    lines.push(`| **Total** | **${totalViolations}** |`);
+  }
+  lines.push("");
+  if (report.byDecision.length > 0) {
+    lines.push("## By Decision");
+    lines.push("");
+    lines.push("| Decision | Status | Constraints | Violations | Compliance |");
+    lines.push("|----------|--------|-------------|------------|------------|");
+    for (const dec of report.byDecision) {
+      const complianceEmoji = dec.compliance >= 90 ? "" : dec.compliance >= 70 ? "" : "";
+      lines.push(
+        `| ${dec.title} | ${dec.status} | ${dec.constraints} | ${dec.violations} | ${complianceEmoji} ${dec.compliance}% |`
+      );
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("*Generated by [SpecBridge](https://github.com/specbridge/specbridge)*");
+  return lines.join("\n");
+}
+function formatProgressBar(percentage) {
+  const width = 20;
+  const filled = Math.round(percentage / 100 * width);
+  const empty = width - filled;
+  const filledChar = "";
+  const emptyChar = "";
+  return `\`${filledChar.repeat(filled)}${emptyChar.repeat(empty)}\` ${percentage}%`;
+}
+
+// src/agent/context.generator.ts
+async function generateContext(filePath, config, options = {}) {
+  const { includeRationale = config.agent?.includeRationale ?? true, cwd = process.cwd() } = options;
+  const registry = createRegistry({ basePath: cwd });
+  await registry.load();
+  const decisions = registry.getActive();
+  const applicableDecisions = [];
+  for (const decision of decisions) {
+    const applicableConstraints = [];
+    for (const constraint of decision.constraints) {
+      if (matchesPattern(filePath, constraint.scope)) {
+        applicableConstraints.push({
+          id: constraint.id,
+          type: constraint.type,
+          rule: constraint.rule,
+          severity: constraint.severity
+        });
+      }
+    }
+    if (applicableConstraints.length > 0) {
+      applicableDecisions.push({
+        id: decision.metadata.id,
+        title: decision.metadata.title,
+        summary: includeRationale ? decision.decision.summary : "",
+        constraints: applicableConstraints
+      });
+    }
+  }
+  return {
+    file: filePath,
+    applicableDecisions,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function formatContextAsMarkdown(context) {
+  const lines = [];
+  lines.push("# Architectural Constraints");
+  lines.push("");
+  lines.push(`File: \`${context.file}\``);
+  lines.push("");
+  if (context.applicableDecisions.length === 0) {
+    lines.push("No specific architectural constraints apply to this file.");
+    return lines.join("\n");
+  }
+  lines.push("The following architectural decisions apply to this file:");
+  lines.push("");
+  for (const decision of context.applicableDecisions) {
+    lines.push(`## ${decision.title}`);
+    lines.push("");
+    if (decision.summary) {
+      lines.push(decision.summary);
+      lines.push("");
+    }
+    lines.push("### Constraints");
+    lines.push("");
+    for (const constraint of decision.constraints) {
+      const typeEmoji = constraint.type === "invariant" ? "" : constraint.type === "convention" ? "" : "";
+      const severityBadge = `[${constraint.severity.toUpperCase()}]`;
+      lines.push(`- ${typeEmoji} **${severityBadge}** ${constraint.rule}`);
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("Please ensure your code complies with these constraints.");
+  return lines.join("\n");
+}
+function formatContextAsJson(context) {
+  return JSON.stringify(context, null, 2);
+}
+function formatContextAsMcp(context) {
+  return {
+    type: "architectural_context",
+    version: "1.0",
+    file: context.file,
+    timestamp: context.generatedAt,
+    decisions: context.applicableDecisions.map((d) => ({
+      id: d.id,
+      title: d.title,
+      summary: d.summary,
+      constraints: d.constraints.map((c) => ({
+        id: c.id,
+        type: c.type,
+        severity: c.severity,
+        rule: c.rule
+      }))
+    }))
+  };
+}
+async function generateFormattedContext(filePath, config, options = {}) {
+  const context = await generateContext(filePath, config, options);
+  const format = options.format || config.agent?.format || "markdown";
+  switch (format) {
+    case "json":
+      return formatContextAsJson(context);
+    case "mcp":
+      return JSON.stringify(formatContextAsMcp(context), null, 2);
+    case "markdown":
+    default:
+      return formatContextAsMarkdown(context);
+  }
+}
+var AgentContextGenerator = class {
+  /**
+   * Generate context from decisions
+   */
+  generateContext(options) {
+    const { decisions, filePattern, format = "markdown", concise = false, minSeverity } = options;
+    const activeDecisions = decisions.filter((d) => d.metadata.status !== "deprecated");
+    let filteredDecisions = activeDecisions;
+    if (filePattern) {
+      filteredDecisions = activeDecisions.filter(
+        (d) => d.constraints.some((c) => matchesPattern(filePattern, c.scope))
+      );
+    }
+    if (minSeverity) {
+      const severityOrder = { low: 0, medium: 1, high: 2, critical: 3 };
+      const minLevel = severityOrder[minSeverity] || 0;
+      filteredDecisions = filteredDecisions.map((d) => ({
+        ...d,
+        constraints: d.constraints.filter((c) => {
+          const level = severityOrder[c.severity] || 0;
+          return level >= minLevel;
+        })
+      })).filter((d) => d.constraints.length > 0);
+    }
+    if (filteredDecisions.length === 0) {
+      return "No architectural decisions apply.";
+    }
+    if (format === "json") {
+      return JSON.stringify({ decisions: filteredDecisions }, null, 2);
+    }
+    const lines = [];
+    if (format === "markdown") {
+      lines.push("# Architectural Decisions\n");
+      for (const decision of filteredDecisions) {
+        lines.push(`## ${decision.metadata.title}`);
+        if (!concise && decision.decision.summary) {
+          lines.push(`
+${decision.decision.summary}
+`);
+        }
+        lines.push("### Constraints\n");
+        for (const constraint of decision.constraints) {
+          lines.push(`- **[${constraint.severity.toUpperCase()}]** ${constraint.rule}`);
+        }
+        lines.push("");
+      }
+    } else {
+      for (const decision of filteredDecisions) {
+        lines.push(`${decision.metadata.title}`);
+        if (!concise && decision.decision.summary) {
+          lines.push(`${decision.decision.summary}`);
+        }
+        for (const constraint of decision.constraints) {
+          lines.push(`  - ${constraint.rule}`);
+        }
+        lines.push("");
+      }
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Generate prompt suffix for AI agents
+   */
+  generatePromptSuffix(options) {
+    const { decisions } = options;
+    if (decisions.length === 0) {
+      return "No architectural decisions to follow.";
+    }
+    const lines = [];
+    lines.push("Please follow these architectural decisions and constraints:");
+    lines.push("");
+    for (const decision of decisions) {
+      lines.push(`- ${decision.metadata.title}`);
+      for (const constraint of decision.constraints) {
+        lines.push(`  - ${constraint.rule}`);
+      }
+    }
+    lines.push("");
+    lines.push("Ensure your code complies with all constraints listed above.");
+    return lines.join("\n");
+  }
+  /**
+   * Extract relevant decisions for a specific file
+   */
+  extractRelevantDecisions(options) {
+    const { decisions, filePath } = options;
+    return decisions.filter(
+      (d) => d.constraints.some((c) => matchesPattern(filePath, c.scope))
+    );
+  }
+};
+export {
+  AgentContextGenerator,
+  AlreadyInitializedError,
+  AnalyzerNotFoundError,
+  CodeScanner,
+  ConfigError,
+  ConstraintExceptionSchema,
+  ConstraintSchema,
+  ConstraintTypeSchema,
+  DecisionContentSchema,
+  DecisionMetadataSchema,
+  DecisionNotFoundError,
+  DecisionSchema,
+  DecisionStatusSchema,
+  DecisionValidationError,
+  ErrorsAnalyzer,
+  ErrorsVerifier,
+  FileSystemError,
+  HookError,
+  ImportsAnalyzer,
+  ImportsVerifier,
+  InferenceEngine,
+  InferenceError,
+  LinksSchema,
+  NamingAnalyzer,
+  NamingVerifier,
+  NotInitializedError,
+  PropagationEngine,
+  RegexVerifier,
+  Registry,
+  RegistryError,
+  Reporter,
+  SeveritySchema,
+  SpecBridgeConfigSchema,
+  SpecBridgeError,
+  StructureAnalyzer,
+  VerificationConfigSchema,
+  VerificationEngine,
+  VerificationError,
+  VerificationFrequencySchema,
+  VerifierNotFoundError,
+  buildDependencyGraph,
+  builtinAnalyzers,
+  builtinVerifiers,
+  calculateConfidence,
+  checkDegradation,
+  createInferenceEngine,
+  createPattern,
+  createPropagationEngine,
+  createRegistry,
+  createScannerFromConfig,
+  createVerificationEngine,
+  createViolation,
+  defaultConfig,
+  ensureDir,
+  extractSnippet,
+  formatConsoleReport,
+  formatContextAsJson,
+  formatContextAsMarkdown,
+  formatContextAsMcp,
+  formatError,
+  formatMarkdownReport,
+  formatValidationErrors,
+  generateContext,
+  generateFormattedContext,
+  generateReport,
+  getAffectedFiles,
+  getAffectingDecisions,
+  getAnalyzer,
+  getAnalyzerIds,
+  getConfigPath,
+  getDecisionsDir,
+  getInferredDir,
+  getReportsDir,
+  getSpecBridgeDir,
+  getTransitiveDependencies,
+  getVerifier,
+  getVerifierIds,
+  getVerifiersDir,
+  glob,
+  isDirectory,
+  loadConfig,
+  loadDecisionFile,
+  loadDecisionsFromDir,
+  matchesAnyPattern,
+  matchesPattern,
+  mergeWithDefaults,
+  minimatch,
+  parseYaml,
+  parseYamlDocument,
+  pathExists,
+  readFilesInDir,
+  readTextFile,
+  runInference,
+  selectVerifierForConstraint,
+  stringifyYaml,
+  updateYamlDocument,
+  validateConfig,
+  validateDecision,
+  validateDecisionFile,
+  writeTextFile
+};
+//# sourceMappingURL=index.js.map