@aiready/contract-enforcement 0.2.0

package/.turbo/turbo-build.log

@@ -0,0 +1,18 @@
+
+> @aiready/contract-enforcement@0.2.0 build /Users/pengcao/projects/aiready/packages/contract-enforcement
+> tsup src/index.ts --format cjs,esm --dts
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Target: es2020
+CJS Build start
+ESM Build start
+ESM dist/index.mjs 15.46 KB
+ESM ⚡️ Build success in 76ms
+CJS dist/index.js 16.88 KB
+CJS ⚡️ Build success in 86ms
+DTS Build start
+DTS ⚡️ Build success in 4708ms
+DTS dist/index.d.ts  2.45 KB
+DTS dist/index.d.mts 2.45 KB

package/.turbo/turbo-test.log

@@ -0,0 +1,16 @@
+
+> @aiready/contract-enforcement@0.1.0 test /Users/pengcao/projects/aiready/packages/contract-enforcement
+> vitest run
+
+
+ RUN  v4.1.1 /Users/pengcao/projects/aiready/packages/contract-enforcement
+
+ ✓ src/__tests__/scoring.test.ts (7 tests) 3ms
+ ✓ src/__tests__/detector.test.ts (14 tests) 23ms
+ ✓ src/__tests__/provider.test.ts (5 tests) 2ms
+
+ Test Files  3 passed (3)
+      Tests  26 passed (26)
+   Start at  15:17:54
+   Duration  2.10s (transform 511ms, setup 0ms, import 3.00s, tests 28ms, environment 0ms)
+

package/dist/index.d.mts

@@ -0,0 +1,69 @@
+import * as _aiready_core from '@aiready/core';
+import { Issue, IssueType } from '@aiready/core';
+
+declare const ContractEnforcementProvider: _aiready_core.ToolProvider;
+
+type DefensivePattern = 'as-any' | 'as-unknown' | 'deep-optional-chain' | 'nullish-literal-default' | 'swallowed-error' | 'env-fallback' | 'unnecessary-guard' | 'any-parameter' | 'any-return';
+interface ContractEnforcementIssue extends Issue {
+    type: IssueType.ContractGap;
+    pattern: DefensivePattern;
+    context: string;
+}
+interface PatternCounts {
+    'as-any': number;
+    'as-unknown': number;
+    'deep-optional-chain': number;
+    'nullish-literal-default': number;
+    'swallowed-error': number;
+    'env-fallback': number;
+    'unnecessary-guard': number;
+    'any-parameter': number;
+    'any-return': number;
+}
+interface ContractEnforcementOptions {
+    rootDir: string;
+    include?: string[];
+    exclude?: string[];
+    onProgress?: (processed: number, total: number, message: string) => void;
+    minChainDepth?: number;
+}
+interface DetectionResult {
+    issues: ContractEnforcementIssue[];
+    counts: PatternCounts;
+    totalLines: number;
+}
+interface ScoreResult {
+    score: number;
+    rating: string;
+    dimensions: Record<string, number>;
+    recommendations: string[];
+}
+interface ContractEnforcementReport {
+    summary: {
+        sourceFiles: number;
+        totalDefensivePatterns: number;
+        defensiveDensity: number;
+        score: number;
+        rating: string;
+        dimensions: {
+            typeEscapeHatchScore: number;
+            fallbackCascadeScore: number;
+            errorTransparencyScore: number;
+            boundaryValidationScore: number;
+        };
+    };
+    issues: ContractEnforcementIssue[];
+    rawData: PatternCounts & {
+        sourceFiles: number;
+        totalLines: number;
+    };
+    recommendations: string[];
+}
+
+declare function analyzeContractEnforcement(options: ContractEnforcementOptions): Promise<ContractEnforcementReport>;
+
+declare function calculateContractEnforcementScore(counts: PatternCounts, totalLines: number, _fileCount: number): ScoreResult;
+
+declare function detectDefensivePatterns(filePath: string, code: string, minChainDepth?: number): DetectionResult;
+
+export { type ContractEnforcementIssue, type ContractEnforcementOptions, ContractEnforcementProvider, type ContractEnforcementReport, type DefensivePattern, type DetectionResult, type PatternCounts, analyzeContractEnforcement, calculateContractEnforcementScore, detectDefensivePatterns };

package/dist/index.d.ts

@@ -0,0 +1,69 @@
+import * as _aiready_core from '@aiready/core';
+import { Issue, IssueType } from '@aiready/core';
+
+declare const ContractEnforcementProvider: _aiready_core.ToolProvider;
+
+type DefensivePattern = 'as-any' | 'as-unknown' | 'deep-optional-chain' | 'nullish-literal-default' | 'swallowed-error' | 'env-fallback' | 'unnecessary-guard' | 'any-parameter' | 'any-return';
+interface ContractEnforcementIssue extends Issue {
+    type: IssueType.ContractGap;
+    pattern: DefensivePattern;
+    context: string;
+}
+interface PatternCounts {
+    'as-any': number;
+    'as-unknown': number;
+    'deep-optional-chain': number;
+    'nullish-literal-default': number;
+    'swallowed-error': number;
+    'env-fallback': number;
+    'unnecessary-guard': number;
+    'any-parameter': number;
+    'any-return': number;
+}
+interface ContractEnforcementOptions {
+    rootDir: string;
+    include?: string[];
+    exclude?: string[];
+    onProgress?: (processed: number, total: number, message: string) => void;
+    minChainDepth?: number;
+}
+interface DetectionResult {
+    issues: ContractEnforcementIssue[];
+    counts: PatternCounts;
+    totalLines: number;
+}
+interface ScoreResult {
+    score: number;
+    rating: string;
+    dimensions: Record<string, number>;
+    recommendations: string[];
+}
+interface ContractEnforcementReport {
+    summary: {
+        sourceFiles: number;
+        totalDefensivePatterns: number;
+        defensiveDensity: number;
+        score: number;
+        rating: string;
+        dimensions: {
+            typeEscapeHatchScore: number;
+            fallbackCascadeScore: number;
+            errorTransparencyScore: number;
+            boundaryValidationScore: number;
+        };
+    };
+    issues: ContractEnforcementIssue[];
+    rawData: PatternCounts & {
+        sourceFiles: number;
+        totalLines: number;
+    };
+    recommendations: string[];
+}
+
+declare function analyzeContractEnforcement(options: ContractEnforcementOptions): Promise<ContractEnforcementReport>;
+
+declare function calculateContractEnforcementScore(counts: PatternCounts, totalLines: number, _fileCount: number): ScoreResult;
+
+declare function detectDefensivePatterns(filePath: string, code: string, minChainDepth?: number): DetectionResult;
+
+export { type ContractEnforcementIssue, type ContractEnforcementOptions, ContractEnforcementProvider, type ContractEnforcementReport, type DefensivePattern, type DetectionResult, type PatternCounts, analyzeContractEnforcement, calculateContractEnforcementScore, detectDefensivePatterns };

package/dist/index.js

@@ -0,0 +1,484 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ContractEnforcementProvider: () => ContractEnforcementProvider,
+  analyzeContractEnforcement: () => analyzeContractEnforcement,
+  calculateContractEnforcementScore: () => calculateContractEnforcementScore,
+  detectDefensivePatterns: () => detectDefensivePatterns
+});
+module.exports = __toCommonJS(index_exports);
+var import_core4 = require("@aiready/core");
+
+// src/provider.ts
+var import_core3 = require("@aiready/core");
+
+// src/analyzer.ts
+var import_fs = require("fs");
+var import_core2 = require("@aiready/core");
+
+// src/detector.ts
+var import_typescript_estree = require("@typescript-eslint/typescript-estree");
+var import_core = require("@aiready/core");
+
+// src/types.ts
+var ZERO_COUNTS = {
+  "as-any": 0,
+  "as-unknown": 0,
+  "deep-optional-chain": 0,
+  "nullish-literal-default": 0,
+  "swallowed-error": 0,
+  "env-fallback": 0,
+  "unnecessary-guard": 0,
+  "any-parameter": 0,
+  "any-return": 0
+};
+
+// src/detector.ts
+function makeIssue(pattern, severity, message, filePath, line, column, context) {
+  return {
+    type: import_core.IssueType.ContractGap,
+    severity,
+    pattern,
+    message,
+    location: { file: filePath, line, column },
+    context,
+    suggestion: getSuggestion(pattern)
+  };
+}
+function getSuggestion(pattern) {
+  switch (pattern) {
+    case "as-any":
+      return "Define a proper type or use type narrowing instead of `as any`.";
+    case "as-unknown":
+      return "Use a single validated type assertion or schema validation instead of `as unknown as`.";
+    case "deep-optional-chain":
+      return "Enforce a non-nullable type at the source to eliminate deep optional chaining.";
+    case "nullish-literal-default":
+      return "Define defaults in a typed config object rather than inline literal fallbacks.";
+    case "swallowed-error":
+      return "Log or propagate errors \u2014 silent catch blocks hide failures.";
+    case "env-fallback":
+      return "Use a validated env schema (e.g., Zod) to enforce required variables at startup.";
+    case "unnecessary-guard":
+      return "Make the parameter non-nullable in the type signature to eliminate the guard.";
+    case "any-parameter":
+      return "Define a proper type for this parameter instead of `any`.";
+    case "any-return":
+      return "Define a proper return type instead of `any`.";
+  }
+}
+function getLineContent(code, line) {
+  const lines = code.split("\n");
+  return (lines[line - 1] || "").trim().slice(0, 120);
+}
+function countOptionalChainDepth(node) {
+  let depth = 0;
+  let current = node;
+  while (current) {
+    if (current.type === "MemberExpression" && current.optional) {
+      depth++;
+      current = current.object;
+    } else if (current.type === "ChainExpression") {
+      current = current.expression;
+    } else if (current.type === "CallExpression" && current.optional) {
+      depth++;
+      current = current.callee;
+    } else {
+      break;
+    }
+  }
+  return depth;
+}
+function isLiteral(node) {
+  if (!node) return false;
+  if (node.type === "Literal") return true;
+  if (node.type === "TemplateLiteral" && node.expressions.length === 0)
+    return true;
+  if (node.type === "UnaryExpression" && (node.operator === "-" || node.operator === "+")) {
+    return isLiteral(node.argument);
+  }
+  return false;
+}
+function isProcessEnvAccess(node) {
+  return node?.type === "MemberExpression" && node.object?.type === "MemberExpression" && node.object.object?.name === "process" && node.object.property?.name === "env";
+}
+function isSwallowedCatch(body) {
+  if (body.length === 0) return true;
+  if (body.length === 1) {
+    const stmt = body[0];
+    if (stmt.type === "ExpressionStatement" && stmt.expression?.type === "CallExpression") {
+      const callee = stmt.expression.callee;
+      if (callee?.object?.name === "console") return true;
+    }
+    if (stmt.type === "ThrowStatement") return false;
+  }
+  return false;
+}
+function detectDefensivePatterns(filePath, code, minChainDepth = 3) {
+  const issues = [];
+  const counts = { ...ZERO_COUNTS };
+  const totalLines = code.split("\n").length;
+  let ast;
+  try {
+    ast = (0, import_typescript_estree.parse)(code, {
+      filePath,
+      loc: true,
+      range: true,
+      jsx: filePath.endsWith("x")
+    });
+  } catch {
+    return { issues, counts, totalLines };
+  }
+  const nodesAtFunctionStart = /* @__PURE__ */ new WeakSet();
+  function markFunctionParamNodes(node) {
+    if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+      const body = node.body?.type === "BlockStatement" ? node.body.body : null;
+      if (body && body.length > 0) {
+        nodesAtFunctionStart.add(body[0]);
+      }
+    }
+  }
+  function visit(node, _parent, _keyInParent) {
+    if (!node || typeof node !== "object") return;
+    markFunctionParamNodes(node);
+    if (node.type === "TSAsExpression" && node.typeAnnotation?.type === "TSAnyKeyword") {
+      counts["as-any"]++;
+      issues.push(
+        makeIssue(
+          "as-any",
+          import_core.Severity.Major,
+          "`as any` type assertion bypasses type safety",
+          filePath,
+          node.loc?.start.line ?? 0,
+          node.loc?.start.column ?? 0,
+          getLineContent(code, node.loc?.start.line ?? 0)
+        )
+      );
+    }
+    if (node.type === "TSAsExpression" && node.typeAnnotation?.type === "TSUnknownKeyword") {
+      counts["as-unknown"]++;
+      issues.push(
+        makeIssue(
+          "as-unknown",
+          import_core.Severity.Major,
+          "`as unknown` double-cast bypasses type safety",
+          filePath,
+          node.loc?.start.line ?? 0,
+          node.loc?.start.column ?? 0,
+          getLineContent(code, node.loc?.start.line ?? 0)
+        )
+      );
+    }
+    if (node.type === "ChainExpression") {
+      const depth = countOptionalChainDepth(node);
+      if (depth >= minChainDepth) {
+        counts["deep-optional-chain"]++;
+        issues.push(
+          makeIssue(
+            "deep-optional-chain",
+            import_core.Severity.Minor,
+            `Optional chain depth of ${depth} indicates missing structural guarantees`,
+            filePath,
+            node.loc?.start.line ?? 0,
+            node.loc?.start.column ?? 0,
+            getLineContent(code, node.loc?.start.line ?? 0)
+          )
+        );
+      }
+    }
+    if (node.type === "LogicalExpression" && node.operator === "??" && isLiteral(node.right)) {
+      counts["nullish-literal-default"]++;
+      issues.push(
+        makeIssue(
+          "nullish-literal-default",
+          import_core.Severity.Minor,
+          "Nullish coalescing with literal default suggests missing upstream type guarantee",
+          filePath,
+          node.loc?.start.line ?? 0,
+          node.loc?.start.column ?? 0,
+          getLineContent(code, node.loc?.start.line ?? 0)
+        )
+      );
+    }
+    if (node.type === "TryStatement" && node.handler) {
+      const catchBody = node.handler.body?.body;
+      if (catchBody && isSwallowedCatch(catchBody)) {
+        counts["swallowed-error"]++;
+        issues.push(
+          makeIssue(
+            "swallowed-error",
+            import_core.Severity.Major,
+            "Error is swallowed in catch block \u2014 failures will be silent",
+            filePath,
+            node.handler.loc?.start.line ?? 0,
+            node.handler.loc?.start.column ?? 0,
+            getLineContent(code, node.handler.loc?.start.line ?? 0)
+          )
+        );
+      }
+    }
+    if (node.type === "LogicalExpression" && node.operator === "||" && isProcessEnvAccess(node.left)) {
+      counts["env-fallback"]++;
+      issues.push(
+        makeIssue(
+          "env-fallback",
+          import_core.Severity.Minor,
+          "Environment variable with fallback \u2014 use a validated env schema instead",
+          filePath,
+          node.loc?.start.line ?? 0,
+          node.loc?.start.column ?? 0,
+          getLineContent(code, node.loc?.start.line ?? 0)
+        )
+      );
+    }
+    if (node.type === "IfStatement" && node.test?.type === "UnaryExpression" && node.test.operator === "!") {
+      const consequent = node.consequent;
+      let isReturn = false;
+      if (consequent.type === "ReturnStatement") {
+        isReturn = true;
+      } else if (consequent.type === "BlockStatement" && consequent.body?.length === 1 && consequent.body[0].type === "ReturnStatement") {
+        isReturn = true;
+      }
+      if (isReturn && nodesAtFunctionStart.has(node)) {
+        counts["unnecessary-guard"]++;
+        issues.push(
+          makeIssue(
+            "unnecessary-guard",
+            import_core.Severity.Info,
+            "Guard clause could be eliminated with non-nullable type at source",
+            filePath,
+            node.loc?.start.line ?? 0,
+            node.loc?.start.column ?? 0,
+            getLineContent(code, node.loc?.start.line ?? 0)
+          )
+        );
+      }
+    }
+    if ((node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") && node.params) {
+      for (const param of node.params) {
+        const typeAnno = param.typeAnnotation?.typeAnnotation ?? param.typeAnnotation;
+        if (typeAnno?.type === "TSAnyKeyword") {
+          counts["any-parameter"]++;
+          issues.push(
+            makeIssue(
+              "any-parameter",
+              import_core.Severity.Major,
+              "Parameter typed as `any` bypasses type safety",
+              filePath,
+              param.loc?.start.line ?? 0,
+              param.loc?.start.column ?? 0,
+              getLineContent(code, param.loc?.start.line ?? 0)
+            )
+          );
+        }
+      }
+      const returnAnno = node.returnType?.typeAnnotation ?? node.returnType;
+      if (returnAnno?.type === "TSAnyKeyword") {
+        counts["any-return"]++;
+        issues.push(
+          makeIssue(
+            "any-return",
+            import_core.Severity.Major,
+            "Return type is `any` \u2014 callers cannot rely on the result shape",
+            filePath,
+            node.returnType?.loc?.start.line ?? 0,
+            node.returnType?.loc?.start.column ?? 0,
+            getLineContent(code, node.returnType?.loc?.start.line ?? 0)
+          )
+        );
+      }
+    }
+    for (const key in node) {
+      if (key === "loc" || key === "range" || key === "parent") continue;
+      const child = node[key];
+      if (Array.isArray(child)) {
+        for (const item of child) {
+          if (item && typeof item.type === "string") {
+            visit(item, node, key);
+          }
+        }
+      } else if (child && typeof child === "object" && typeof child.type === "string") {
+        visit(child, node, key);
+      }
+    }
+  }
+  visit(ast);
+  return { issues, counts, totalLines };
+}
+
+// src/scoring.ts
+var DIMENSION_WEIGHTS = {
+  typeEscapeHatch: 0.35,
+  fallbackCascade: 0.25,
+  errorTransparency: 0.2,
+  boundaryValidation: 0.2
+};
+function clamp(v, min, max) {
+  return Math.max(min, Math.min(max, v));
+}
+function calculateContractEnforcementScore(counts, totalLines, _fileCount) {
+  const loc = Math.max(1, totalLines);
+  const typeEscapeCount = counts["as-any"] + counts["as-unknown"] + counts["any-parameter"] + counts["any-return"];
+  const fallbackCount = counts["deep-optional-chain"] + counts["nullish-literal-default"];
+  const errorCount = counts["swallowed-error"];
+  const boundaryCount = counts["env-fallback"] + counts["unnecessary-guard"];
+  const typeDensity = typeEscapeCount / loc * 1e3;
+  const fallbackDensity = fallbackCount / loc * 1e3;
+  const errorDensity = errorCount / loc * 1e3;
+  const boundaryDensity = boundaryCount / loc * 1e3;
+  const typeEscapeHatchScore = clamp(100 - typeDensity * 15, 0, 100);
+  const fallbackCascadeScore = clamp(100 - fallbackDensity * 12, 0, 100);
+  const errorTransparencyScore = clamp(100 - errorDensity * 25, 0, 100);
+  const boundaryValidationScore = clamp(100 - boundaryDensity * 10, 0, 100);
+  const score = Math.round(
+    typeEscapeHatchScore * DIMENSION_WEIGHTS.typeEscapeHatch + fallbackCascadeScore * DIMENSION_WEIGHTS.fallbackCascade + errorTransparencyScore * DIMENSION_WEIGHTS.errorTransparency + boundaryValidationScore * DIMENSION_WEIGHTS.boundaryValidation
+  );
+  const rating = score >= 90 ? "excellent" : score >= 75 ? "good" : score >= 60 ? "moderate" : score >= 40 ? "needs-work" : "critical";
+  const recommendations = [];
+  if (typeEscapeHatchScore < 60) {
+    recommendations.push(
+      `Reduce type escape hatches (${typeEscapeCount} found): define proper types at system boundaries instead of \`as any\`/parameter \`any\`.`
+    );
+  }
+  if (fallbackCascadeScore < 60) {
+    recommendations.push(
+      `Reduce fallback cascades (${fallbackCount} found): enforce non-nullable types at the source so consumers don't need \`?.\`/?? fallbacks.`
+    );
+  }
+  if (errorTransparencyScore < 60) {
+    recommendations.push(
+      `Fix swallowed errors (${errorCount} found): log or propagate errors so failures are visible.`
+    );
+  }
+  if (boundaryValidationScore < 60) {
+    recommendations.push(
+      `Add boundary validation (${boundaryCount} gaps): use a Zod schema for env vars and API inputs instead of inline fallbacks.`
+    );
+  }
+  return {
+    score,
+    rating,
+    dimensions: {
+      typeEscapeHatchScore: Math.round(typeEscapeHatchScore),
+      fallbackCascadeScore: Math.round(fallbackCascadeScore),
+      errorTransparencyScore: Math.round(errorTransparencyScore),
+      boundaryValidationScore: Math.round(boundaryValidationScore)
+    },
+    recommendations
+  };
+}
+
+// src/analyzer.ts
+async function analyzeContractEnforcement(options) {
+  const files = await (0, import_core2.scanFiles)({
+    ...options,
+    include: options.include || ["**/*.{ts,tsx,js,jsx}"]
+  });
+  const allIssues = [];
+  const aggregate = { ...ZERO_COUNTS };
+  let totalLines = 0;
+  await (0, import_core2.runBatchAnalysis)(
+    files,
+    "scanning for defensive patterns",
+    "contract-enforcement",
+    options.onProgress,
+    async (f) => {
+      let code;
+      try {
+        code = (0, import_fs.readFileSync)(f, "utf-8");
+      } catch {
+        return { issues: [], counts: { ...ZERO_COUNTS }, totalLines: 0 };
+      }
+      return detectDefensivePatterns(f, code, options.minChainDepth ?? 3);
+    },
+    (result) => {
+      allIssues.push(...result.issues);
+      totalLines += result.totalLines;
+      for (const key of Object.keys(aggregate)) {
+        aggregate[key] += result.counts[key];
+      }
+    }
+  );
+  const totalPatterns = Object.values(aggregate).reduce((a, b) => a + b, 0);
+  const density = totalLines > 0 ? Math.round(totalPatterns / totalLines * 1e4) / 10 : 0;
+  const scoreResult = calculateContractEnforcementScore(
+    aggregate,
+    totalLines,
+    files.length
+  );
+  return {
+    summary: {
+      sourceFiles: files.length,
+      totalDefensivePatterns: totalPatterns,
+      defensiveDensity: density,
+      score: scoreResult.score,
+      rating: scoreResult.rating,
+      dimensions: {
+        typeEscapeHatchScore: scoreResult.dimensions.typeEscapeHatchScore,
+        fallbackCascadeScore: scoreResult.dimensions.fallbackCascadeScore,
+        errorTransparencyScore: scoreResult.dimensions.errorTransparencyScore,
+        boundaryValidationScore: scoreResult.dimensions.boundaryValidationScore
+      }
+    },
+    issues: allIssues,
+    rawData: { ...aggregate, sourceFiles: files.length, totalLines },
+    recommendations: scoreResult.recommendations
+  };
+}
+
+// src/provider.ts
+var ContractEnforcementProvider = (0, import_core3.createProvider)({
+  id: import_core3.ToolName.ContractEnforcement,
+  alias: ["contract", "ce", "enforcement"],
+  version: "0.1.0",
+  defaultWeight: 10,
+  async analyzeReport(options) {
+    return analyzeContractEnforcement(options);
+  },
+  getResults(report) {
+    return (0, import_core3.groupIssuesByFile)(report.issues);
+  },
+  getSummary(report) {
+    return report.summary;
+  },
+  getMetadata(report) {
+    return { rawData: report.rawData };
+  },
+  score(output, _options) {
+    const rawData = output.metadata?.rawData ?? {};
+    return calculateContractEnforcementScore(
+      rawData,
+      rawData.totalLines ?? 1,
+      rawData.sourceFiles ?? 1
+    );
+  }
+});
+
+// src/index.ts
+import_core4.ToolRegistry.register(ContractEnforcementProvider);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContractEnforcementProvider,
+  analyzeContractEnforcement,
+  calculateContractEnforcementScore,
+  detectDefensivePatterns
+});