speckeeper 0.8.1 → 0.9.1

package/dist/dsl/index.js

@@ -154,142 +154,6 @@ function markdownExporter(config) {
   }
   return exporter;
 }
-
-// src/core/dsl/type-compat.ts
-var ALIASES = {
-  INTEGER: "INT",
-  BOOL: "BOOLEAN",
-  REAL: "FLOAT",
-  "DOUBLE PRECISION": "DOUBLE",
-  SERIAL: "INT",
-  BIGSERIAL: "BIGINT",
-  SMALLSERIAL: "SMALLINT",
-  TIMESTAMPTZ: "TIMESTAMP",
-  "TIMESTAMP WITH TIME ZONE": "TIMESTAMP",
-  "TIMESTAMP WITHOUT TIME ZONE": "TIMESTAMP",
-  "CHARACTER VARYING": "VARCHAR",
-  CHARACTER: "CHAR",
-  INT2: "SMALLINT",
-  INT4: "INT",
-  INT8: "BIGINT",
-  FLOAT4: "FLOAT",
-  FLOAT8: "DOUBLE"
-};
-var CONTAINMENT_CHAINS = [
-  ["SMALLINT", "INT", "BIGINT"],
-  ["FLOAT", "DOUBLE"],
-  ["CHAR", "VARCHAR", "TEXT"],
-  ["INTEGER", "NUMBER"]
-];
-function parseType(raw) {
-  const trimmed = raw.trim().toUpperCase();
-  const match = trimmed.match(/^([A-Z\s]+?)(?:\(\s*(\d+)(?:\s*,\s*(\d+))?\s*\))?$/);
-  if (!match) {
-    return { base: trimmed };
-  }
-  const base = match[1].trim();
-  return {
-    base,
-    length: match[2] !== void 0 ? Number(match[2]) : void 0,
-    precision: match[2] !== void 0 ? Number(match[2]) : void 0,
-    scale: match[3] !== void 0 ? Number(match[3]) : void 0
-  };
-}
-function normalize(base) {
-  return ALIASES[base] ?? base;
-}
-function findAllChainPositions(base, chains) {
-  const results = [];
-  const resolved = normalize(base);
-  for (const chain of chains) {
-    let idx = chain.indexOf(base);
-    if (idx === -1) idx = chain.indexOf(resolved);
-    if (idx !== -1) results.push({ chain, index: idx });
-  }
-  return results;
-}
-function isTypeContainedBy(specType, ddlType) {
-  const spec = parseType(specType);
-  const ddl = parseType(ddlType);
-  const specNorm = normalize(spec.base);
-  const ddlNorm = normalize(ddl.base);
-  if (specNorm === ddlNorm) {
-    if (specNorm === "DECIMAL" || specNorm === "NUMERIC") {
-      if (spec.precision !== void 0 && ddl.precision !== void 0) {
-        if (ddl.precision < spec.precision) return false;
-      }
-      if (spec.scale !== void 0 && ddl.scale !== void 0) {
-        if (ddl.scale < spec.scale) return false;
-      }
-      return true;
-    }
-    if (spec.length !== void 0 && ddl.length !== void 0) {
-      return ddl.length >= spec.length;
-    }
-    return true;
-  }
-  const specPositions = findAllChainPositions(spec.base, CONTAINMENT_CHAINS);
-  const ddlPositions = findAllChainPositions(ddl.base, CONTAINMENT_CHAINS);
-  for (const sp of specPositions) {
-    for (const dp of ddlPositions) {
-      if (sp.chain === dp.chain) {
-        return dp.index >= sp.index;
-      }
-    }
-  }
-  return false;
-}
-
-// src/core/dsl/checkers.ts
-function testChecker(config) {
-  return {
-    targetType: "test",
-    sourcePath: config?.sourcePath ?? (() => "."),
-    check: (spec) => {
-      const errors = [];
-      const warnings = [];
-      const basePath = process.cwd();
-      const testPatterns = [
-        "test/**/*.test.ts",
-        "test/**/*.spec.ts",
-        "tests/**/*.test.ts",
-        "tests/**/*.spec.ts"
-      ];
-      let testFiles = [];
-      for (const pattern of testPatterns) {
-        testFiles = testFiles.concat(glob.sync(pattern, { cwd: basePath }));
-      }
-      if (testFiles.length === 0) {
-        warnings.push({ message: `No test files found for ${spec.id}`, specId: spec.id });
-        return { success: true, errors, warnings };
-      }
-      let specIdFound = false;
-      for (const testFile of testFiles) {
-        const fullPath = join(basePath, testFile);
-        try {
-          const content = readFileSync(fullPath, "utf-8");
-          const patterns = [
-            new RegExp(`describe\\s*\\(\\s*['"\`].*${spec.id}`, "m"),
-            new RegExp(`it\\s*\\(\\s*['"\`].*${spec.id}`, "m"),
-            new RegExp(`test\\s*\\(\\s*['"\`].*${spec.id}`, "m")
-          ];
-          if (patterns.some((p) => p.test(content))) {
-            specIdFound = true;
-            break;
-          }
-        } catch {
-        }
-      }
-      if (!specIdFound) {
-        warnings.push({
-          message: `Spec ID "${spec.id}" not found in any test file`,
-          specId: spec.id
-        });
-      }
-      return { success: errors.length === 0, errors, warnings };
-    }
-  };
-}
 function relationTypeToAnnotation(relationType) {
   return relationType === "verifiedBy" ? "verifies" : relationType;
 }
@@ -307,106 +171,6 @@ function setArtifactsConfig(config) {
 function getArtifactsConfig() {
   return _artifactsConfig;
 }
-function runAnnotationScan(specId, artifact, relationType, contentPatterns, basePath) {
-  const matchedFiles = [];
-  const warnings = [];
-  const artifactsConfig = getArtifactsConfig();
-  const artifactConfig = artifactsConfig?.[artifact];
-  if (!artifactConfig) {
-    warnings.push({
-      message: `Artifact config "${artifact}" not found; set artifacts in config and call setArtifactsConfig()`,
-      specId
-    });
-    return { matchedFiles, warnings };
-  }
-  const allFiles = /* @__PURE__ */ new Set();
-  for (const pattern of artifactConfig.globs) {
-    const found = glob.sync(pattern, {
-      cwd: basePath,
-      ignore: artifactConfig.exclude ?? []
-    });
-    for (const f of found) {
-      allFiles.add(f);
-    }
-  }
-  const patterns = contentPatterns.length > 0 ? contentPatterns : [getDefaultPatternForRelation(relationType)];
-  for (const filePath of allFiles) {
-    const fullPath = join(basePath, filePath);
-    let content;
-    try {
-      content = readFileSync(fullPath, "utf-8");
-    } catch {
-      continue;
-    }
-    const lines = content.split("\n");
-    for (let lineNum = 1; lineNum <= lines.length; lineNum++) {
-      const line = lines[lineNum - 1];
-      for (const re of patterns) {
-        const copy = new RegExp(re.source, re.flags);
-        let m;
-        while ((m = copy.exec(line)) !== null) {
-          const ids = extractSpecIds(m[1] ?? "");
-          if (ids.includes(specId)) {
-            matchedFiles.push({ specId, filePath, line: lineNum, relationType });
-          }
-        }
-      }
-    }
-  }
-  return { matchedFiles, warnings };
-}
-function annotationChecker(config) {
-  return {
-    targetType: "annotation",
-    sourcePath: () => ".",
-    check: (spec, _externalData) => {
-      const errors = [];
-      const warnings = [];
-      const allMatchedFiles = [];
-      const basePath = process.cwd();
-      const checks = config?.artifact && config?.relationType ? [
-        {
-          artifact: config.artifact,
-          relationType: config.relationType,
-          contentPatterns: config.contentPatterns
-        }
-      ] : config?.checks ?? [];
-      for (const entry of checks) {
-        if (entry.checker) {
-          const result = entry.checker.check(spec, void 0);
-          errors.push(...result.errors);
-          warnings.push(...result.warnings);
-          if (result.matchedFiles) {
-            allMatchedFiles.push(...result.matchedFiles);
-          }
-        } else {
-          const patterns = entry.contentPatterns ?? getArtifactsConfig()?.[entry.artifact]?.contentPatterns ?? [];
-          const { matchedFiles, warnings: w } = runAnnotationScan(
-            spec.id,
-            entry.artifact,
-            entry.relationType,
-            Array.isArray(patterns) ? patterns : [patterns],
-            basePath
-          );
-          warnings.push(...w);
-          allMatchedFiles.push(...matchedFiles);
-        }
-      }
-      if (checks.length > 0 && allMatchedFiles.length === 0) {
-        warnings.push({
-          message: `No annotation matches found for spec "${spec.id}"`,
-          specId: spec.id
-        });
-      }
-      return {
-        success: errors.length === 0,
-        errors,
-        warnings,
-        matchedFiles: allMatchedFiles.length > 0 ? allMatchedFiles : void 0
-      };
-    }
-  };
-}
 function annotationCoverage(config) {
   return {
     targetModel: "annotation",
@@ -479,6 +243,144 @@ function annotationCoverage(config) {
     }
   };
 }
+function relationCoverage(config) {
+  return {
+    targetModel: config.targetModel,
+    description: config.description,
+    check: (specs, registry) => {
+      const targets = registry[config.targetModel];
+      if (!targets) {
+        return { total: 0, covered: 0, uncovered: 0, coveragePercent: 100, coveredItems: [], uncoveredItems: [] };
+      }
+      const allTargetIds = /* @__PURE__ */ new Set();
+      const targetDescriptions = /* @__PURE__ */ new Map();
+      for (const t of targets.values()) {
+        if (config.targetPrefix && !t.id.startsWith(config.targetPrefix)) continue;
+        allTargetIds.add(t.id);
+        targetDescriptions.set(t.id, t.name ?? t.description ?? t.id);
+      }
+      const coveredIds = /* @__PURE__ */ new Set();
+      for (const spec of specs) {
+        if (!spec.relations) continue;
+        for (const rel of spec.relations) {
+          if (config.relationType && rel.type !== config.relationType) continue;
+          if (allTargetIds.has(rel.target)) coveredIds.add(rel.target);
+        }
+      }
+      const coveredItems = [];
+      const uncoveredItems = [];
+      for (const id of allTargetIds) {
+        const desc = targetDescriptions.get(id);
+        if (coveredIds.has(id)) {
+          coveredItems.push({ id, description: desc });
+        } else {
+          uncoveredItems.push({ id, description: desc });
+        }
+      }
+      const total = allTargetIds.size;
+      const covered = coveredItems.length;
+      const coveragePercent = total > 0 ? Math.round(covered / total * 100) : 100;
+      return { total, covered, uncovered: total - covered, coveragePercent, coveredItems, uncoveredItems };
+    }
+  };
+}
+
+// src/core/dsl/type-compat.ts
+var ALIASES = {
+  INTEGER: "INT",
+  BOOL: "BOOLEAN",
+  REAL: "FLOAT",
+  "DOUBLE PRECISION": "DOUBLE",
+  SERIAL: "INT",
+  BIGSERIAL: "BIGINT",
+  SMALLSERIAL: "SMALLINT",
+  TIMESTAMPTZ: "TIMESTAMP",
+  "TIMESTAMP WITH TIME ZONE": "TIMESTAMP",
+  "TIMESTAMP WITHOUT TIME ZONE": "TIMESTAMP",
+  "CHARACTER VARYING": "VARCHAR",
+  CHARACTER: "CHAR",
+  INT2: "SMALLINT",
+  INT4: "INT",
+  INT8: "BIGINT",
+  FLOAT4: "FLOAT",
+  FLOAT8: "DOUBLE"
+};
+var CONTAINMENT_CHAINS = [
+  ["SMALLINT", "INT", "BIGINT"],
+  ["FLOAT", "DOUBLE"],
+  ["CHAR", "VARCHAR", "TEXT"],
+  ["INTEGER", "NUMBER"]
+];
+function parseType(raw) {
+  const trimmed = raw.trim().toUpperCase();
+  const match = trimmed.match(/^([A-Z\s]+?)(?:\(\s*(\d+)(?:\s*,\s*(\d+))?\s*\))?$/);
+  if (!match) {
+    return { base: trimmed };
+  }
+  const base = match[1].trim();
+  return {
+    base,
+    length: match[2] !== void 0 ? Number(match[2]) : void 0,
+    precision: match[2] !== void 0 ? Number(match[2]) : void 0,
+    scale: match[3] !== void 0 ? Number(match[3]) : void 0
+  };
+}
+function normalize(base) {
+  return ALIASES[base] ?? base;
+}
+function findAllChainPositions(base, chains) {
+  const results = [];
+  const resolved = normalize(base);
+  for (const chain of chains) {
+    let idx = chain.indexOf(base);
+    if (idx === -1) idx = chain.indexOf(resolved);
+    if (idx !== -1) results.push({ chain, index: idx });
+  }
+  return results;
+}
+function isTypeContainedBy(specType, ddlType) {
+  const spec = parseType(specType);
+  const ddl = parseType(ddlType);
+  const specNorm = normalize(spec.base);
+  const ddlNorm = normalize(ddl.base);
+  if (specNorm === ddlNorm) {
+    if (specNorm === "DECIMAL" || specNorm === "NUMERIC") {
+      if (spec.precision !== void 0 && ddl.precision !== void 0) {
+        if (ddl.precision < spec.precision) return false;
+      }
+      if (spec.scale !== void 0 && ddl.scale !== void 0) {
+        if (ddl.scale < spec.scale) return false;
+      }
+      return true;
+    }
+    if (spec.length !== void 0 && ddl.length !== void 0) {
+      return ddl.length >= spec.length;
+    }
+    return true;
+  }
+  const specPositions = findAllChainPositions(spec.base, CONTAINMENT_CHAINS);
+  const ddlPositions = findAllChainPositions(ddl.base, CONTAINMENT_CHAINS);
+  for (const sp of specPositions) {
+    for (const dp of ddlPositions) {
+      if (sp.chain === dp.chain) {
+        return dp.index >= sp.index;
+      }
+    }
+  }
+  return false;
+}
+var ImplementsRelationSchema = z.object({
+  target: z.string(),
+  targetType: z.string(),
+  sourcePath: z.string().optional(),
+  description: z.string().optional()
+});
+var VerifiedByRelationSchema = z.object({
+  target: z.string(),
+  testPath: z.string().optional(),
+  framework: z.string().optional(),
+  description: z.string().optional()
+});
 function resolveRef(doc, ref) {
   if (!ref.startsWith("#/")) return void 0;
   const parts = ref.substring(2).split("/");
@@ -528,118 +430,24 @@ function findSpecIdInOpenAPI(doc, specId) {
   if (searchXSpecId(doc)) return { pathKey: "(x-spec-id match)" };
   return null;
 }
-function externalOpenAPIChecker(config) {
-  return {
-    targetType: "openapi",
-    sourcePath: config?.sourcePath ?? (() => "api/openapi.yaml"),
-    check: (spec) => {
-      const errors = [];
-      const warnings = [];
-      const filePath = (config?.sourcePath ?? (() => "api/openapi.yaml"))(spec);
-      const fullPath = isAbsolute(filePath) ? filePath : join(process.cwd(), filePath);
-      if (!existsSync(fullPath)) {
-        errors.push({ message: `OpenAPI file not found: ${filePath}`, specId: spec.id });
-        return { success: false, errors, warnings };
-      }
-      let content;
-      try {
-        content = readFileSync(fullPath, "utf-8");
-      } catch {
-        errors.push({ message: `Failed to read OpenAPI file: ${filePath}`, specId: spec.id });
-        return { success: false, errors, warnings };
-      }
-      if (content.length === 0) {
-        errors.push({ message: `OpenAPI file is empty: ${filePath}`, specId: spec.id });
-        return { success: false, errors, warnings };
-      }
-      let doc;
-      try {
-        if (fullPath.endsWith(".json")) {
-          doc = JSON.parse(content);
-        } else {
-          doc = parse(content);
-        }
-      } catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
-        errors.push({ message: `Failed to parse OpenAPI file ${filePath}: ${msg}`, specId: spec.id });
-        return { success: false, errors, warnings };
-      }
-      const match = findSpecIdInOpenAPI(doc, spec.id);
-      if (!match) {
-        warnings.push({ message: `Spec ID "${spec.id}" not found in OpenAPI document ${filePath}`, specId: spec.id });
-        return { success: true, errors, warnings };
-      }
-      if (!config?.mapper) {
-        return { success: errors.length === 0, errors, warnings };
-      }
-      const mapping = config.mapper(spec);
-      if (mapping.method && match.operation) {
-        const expectedMethod = mapping.method.toLowerCase();
-        const actualMethod = match.method?.toLowerCase();
-        if (actualMethod && actualMethod !== expectedMethod) {
-          warnings.push({
-            message: `Method mismatch for "${spec.id}": expected ${expectedMethod.toUpperCase()}, found ${actualMethod.toUpperCase()}`,
-            specId: spec.id
-          });
-        }
-      }
-      if (match.operation && mapping.parameters) {
-        const opParams = (match.operation.parameters || []).map(
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          (p) => maybeResolveRef(doc, p)
-        );
-        for (const expectedParam of mapping.parameters) {
-          const found = opParams.find(
-            (p) => p?.name === expectedParam.name && (!expectedParam.in || p?.in === expectedParam.in)
-          );
-          if (!found) {
-            warnings.push({
-              message: `Parameter "${expectedParam.name}" not found in operation "${spec.id}"`,
-              specId: spec.id,
-              field: expectedParam.name
-            });
-          } else if (expectedParam.type && found.schema?.type) {
-            if (!isTypeContainedBy(expectedParam.type, found.schema.type)) {
-              warnings.push({
-                message: `Parameter "${expectedParam.name}" type mismatch: expected ${expectedParam.type}, found ${found.schema.type}`,
-                specId: spec.id,
-                field: expectedParam.name
-              });
-            }
-          }
-        }
-      }
-      if (match.operation && mapping.responseProperties) {
-        const successResponse = match.operation.responses?.["200"] || match.operation.responses?.["201"];
-        let responseSchema = successResponse?.content?.["application/json"]?.schema;
-        responseSchema = maybeResolveRef(doc, responseSchema);
-        if (responseSchema?.type === "array") {
-          responseSchema = maybeResolveRef(doc, responseSchema.items);
-        }
-        const responseProps = responseSchema?.properties || {};
-        for (const expectedProp of mapping.responseProperties) {
-          const foundProp = responseProps[expectedProp.name];
-          if (!foundProp) {
-            warnings.push({
-              message: `Response property "${expectedProp.name}" not found in operation "${spec.id}"`,
-              specId: spec.id,
-              field: expectedProp.name
-            });
-          } else if (expectedProp.type && foundProp.type) {
-            if (!isTypeContainedBy(expectedProp.type, foundProp.type)) {
-              warnings.push({
-                message: `Response property "${expectedProp.name}" type mismatch: expected ${expectedProp.type}, found ${foundProp.type}`,
-                specId: spec.id,
-                field: expectedProp.name
-              });
-            }
-          }
-        }
+var openapiScanner = {
+  findSpecIds(content, specIds, filePath) {
+    const doc = content;
+    if (!doc || typeof doc !== "object") return [];
+    const matches = [];
+    for (const specId of specIds) {
+      const match = findSpecIdInOpenAPI(doc, specId);
+      if (match) {
+        matches.push({
+          specId,
+          location: `${filePath}:${match.pathKey}`,
+          context: { doc, match }
+        });
       }
-      return { success: errors.length === 0, errors, warnings };
     }
-  };
-}
+    return matches;
+  }
+};
 function stripSchemaPrefix(name) {
   const dotIndex = name.lastIndexOf(".");
   return dotIndex >= 0 ? name.substring(dotIndex + 1) : name;
@@ -696,132 +504,305 @@ function parseDDLWithRegex(content) {
   }
   return tables;
 }
-function externalSqlSchemaChecker(config) {
-  return {
-    targetType: "ddl",
-    sourcePath: config?.sourcePath ?? (() => "db/schema.sql"),
-    check: (spec) => {
-      const errors = [];
-      const warnings = [];
-      const filePath = (config?.sourcePath ?? (() => "db/schema.sql"))(spec);
-      const fullPath = isAbsolute(filePath) ? filePath : join(process.cwd(), filePath);
-      if (!existsSync(fullPath)) {
-        errors.push({ message: `DDL file not found: ${filePath}`, specId: spec.id });
-        return { success: false, errors, warnings };
-      }
-      let content;
-      try {
-        content = readFileSync(fullPath, "utf-8");
-      } catch {
-        errors.push({ message: `Failed to read DDL file: ${filePath}`, specId: spec.id });
-        return { success: false, errors, warnings };
-      }
-      if (content.length === 0) {
-        errors.push({ message: `DDL file is empty: ${filePath}`, specId: spec.id });
-        return { success: false, errors, warnings };
-      }
-      let tables = parseDDLWithParser(content);
-      if (!tables) {
-        warnings.push({ message: `DDL parser failed for ${filePath}, using regex fallback`, specId: spec.id });
-        tables = parseDDLWithRegex(content);
-      }
-      if (!config?.mapper) {
-        return { success: errors.length === 0, errors, warnings };
-      }
-      const mapping = config.mapper(spec);
+var ddlScanner = {
+  findSpecIds(content, specIds, filePath) {
+    if (typeof content !== "string") return [];
+    let tables = parseDDLWithParser(content);
+    if (!tables) {
+      tables = parseDDLWithRegex(content);
+    }
+    const matches = [];
+    for (const specId of specIds) {
       const table = tables.find(
-        (t) => t.name.toLowerCase() === mapping.tableName.toLowerCase()
+        (t) => t.name.toLowerCase() === specId.toLowerCase()
       );
-      if (!table) {
-        warnings.push({
-          message: `Table "${mapping.tableName}" not found in DDL file ${filePath}`,
-          specId: spec.id
+      if (table) {
+        matches.push({
+          specId,
+          location: `${filePath}:${table.name}`,
+          context: { table }
         });
-        return { success: errors.length === 0, errors, warnings };
       }
-      if (!mapping.columns) {
-        return { success: errors.length === 0, errors, warnings };
-      }
-      for (const expectedCol of mapping.columns) {
-        const foundCol = table.columns.find(
-          (c) => c.name.toLowerCase() === expectedCol.name.toLowerCase()
-        );
-        if (!foundCol) {
-          warnings.push({
-            message: `Column "${expectedCol.name}" not found in table "${mapping.tableName}"`,
-            specId: spec.id,
-            field: expectedCol.name
-          });
-          continue;
-        }
-        if (config.checkTypes && expectedCol.type && foundCol.type) {
-          if (!isTypeContainedBy(expectedCol.type, foundCol.type)) {
-            warnings.push({
-              message: `Column "${expectedCol.name}" type mismatch in table "${mapping.tableName}": expected ${expectedCol.type}, found ${foundCol.type}`,
-              specId: spec.id,
-              field: expectedCol.name
+    }
+    return matches;
+  }
+};
+function extractSpecIds2(captured) {
+  return captured.split(/[,\s]+/).map((s) => s.trim()).filter(Boolean);
+}
+var annotationScanner = {
+  findSpecIds(content, specIds, filePath) {
+    if (typeof content !== "string") return [];
+    const specIdSet = new Set(specIds);
+    const matches = [];
+    const defaultPattern = /@(?:verifies|implements|traces)\s+([\w-]+(?:[,\s]+[\w-]+)*)/g;
+    const lines = content.split("\n");
+    for (let lineNum = 1; lineNum <= lines.length; lineNum++) {
+      const line = lines[lineNum - 1];
+      const copy = new RegExp(defaultPattern.source, defaultPattern.flags);
+      let m;
+      while ((m = copy.exec(line)) !== null) {
+        const ids = extractSpecIds2(m[1] ?? "");
+        for (const id of ids) {
+          if (specIdSet.has(id)) {
+            matches.push({
+              specId: id,
+              location: `${filePath}:${lineNum}`,
+              context: { filePath, line: lineNum }
             });
           }
         }
       }
-      return { success: errors.length === 0, errors, warnings };
     }
-  };
-}
-function relationCoverage(config) {
+    return matches;
+  }
+};
+function createAnnotationScanner(contentPatterns) {
   return {
-    targetModel: config.targetModel,
-    description: config.description,
-    check: (specs, registry) => {
-      const targets = registry[config.targetModel];
-      if (!targets) {
-        return { total: 0, covered: 0, uncovered: 0, coveragePercent: 100, coveredItems: [], uncoveredItems: [] };
+    findSpecIds(content, specIds, filePath) {
+      if (typeof content !== "string") return [];
+      const specIdSet = new Set(specIds);
+      const matches = [];
+      const lines = content.split("\n");
+      for (let lineNum = 1; lineNum <= lines.length; lineNum++) {
+        const line = lines[lineNum - 1];
+        for (const re of contentPatterns) {
+          const copy = new RegExp(re.source, re.flags);
+          let m;
+          while ((m = copy.exec(line)) !== null) {
+            const ids = extractSpecIds2(m[1] ?? "");
+            for (const id of ids) {
+              if (specIdSet.has(id)) {
+                matches.push({
+                  specId: id,
+                  location: `${filePath}:${lineNum}`,
+                  context: { filePath, line: lineNum }
+                });
+              }
+            }
+          }
+        }
       }
-      const allTargetIds = /* @__PURE__ */ new Set();
-      const targetDescriptions = /* @__PURE__ */ new Map();
-      for (const t of targets.values()) {
-        if (config.targetPrefix && !t.id.startsWith(config.targetPrefix)) continue;
-        allTargetIds.add(t.id);
-        targetDescriptions.set(t.id, t.name ?? t.description ?? t.id);
+      return matches;
+    }
+  };
+}
+var BUILT_IN_SCANNERS = {
+  openapi: openapiScanner,
+  ddl: ddlScanner,
+  annotation: annotationScanner
+};
+function getScannerForSource(source) {
+  if (source.scanner) return source.scanner;
+  if (source.type === "annotation" && source.contentPatterns && source.contentPatterns.length > 0) {
+    return createAnnotationScanner(source.contentPatterns);
+  }
+  return BUILT_IN_SCANNERS[source.type] ?? null;
+}
+function loadFileContent(filePath, sourceType) {
+  const content = readFileSync(filePath, "utf-8");
+  if (!content || content.length === 0) return null;
+  if (sourceType === "openapi") {
+    if (filePath.endsWith(".json")) {
+      return JSON.parse(content);
+    }
+    return parse(content);
+  }
+  return content;
+}
+function runGlobalScan(sources, specIds, basePath, lookupKeyMap) {
+  const cwd = basePath ?? process.cwd();
+  const result = /* @__PURE__ */ new Map();
+  const warnings = [];
+  for (const source of sources) {
+    const scanner = getScannerForSource(source);
+    if (!scanner) {
+      warnings.push({
+        message: `No scanner found for source type "${source.type}". Provide a custom scanner.`,
+        sourceType: source.type
+      });
+      continue;
+    }
+    const keyToSpecId = /* @__PURE__ */ new Map();
+    for (const specId of specIds) {
+      const overrides = lookupKeyMap?.get(specId);
+      const key = overrides?.[source.type] ?? specId;
+      keyToSpecId.set(key, specId);
+    }
+    const keysToSearch = Array.from(keyToSpecId.keys());
+    const allFiles = /* @__PURE__ */ new Set();
+    for (const pattern of source.paths) {
+      const found = glob.sync(pattern, {
+        cwd,
+        ignore: source.exclude ?? []
+      });
+      for (const f of found) {
+        allFiles.add(f);
       }
-      const coveredIds = /* @__PURE__ */ new Set();
-      for (const spec of specs) {
-        if (!spec.relations) continue;
-        for (const rel of spec.relations) {
-          if (config.relationType && rel.type !== config.relationType) continue;
-          if (allTargetIds.has(rel.target)) coveredIds.add(rel.target);
-        }
+    }
+    for (const relPath of allFiles) {
+      const fullPath = isAbsolute(relPath) ? relPath : join(cwd, relPath);
+      if (!existsSync(fullPath)) continue;
+      let content;
+      try {
+        content = loadFileContent(fullPath, source.type);
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        warnings.push({
+          message: `Failed to load ${relPath}: ${msg}`,
+          sourceType: source.type,
+          filePath: relPath
+        });
+        continue;
       }
-      const coveredItems = [];
-      const uncoveredItems = [];
-      for (const id of allTargetIds) {
-        const desc = targetDescriptions.get(id);
-        if (coveredIds.has(id)) {
-          coveredItems.push({ id, description: desc });
+      if (content == null) continue;
+      let matches;
+      try {
+        matches = scanner.findSpecIds(content, keysToSearch, relPath);
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        warnings.push({
+          message: `Scanner error for ${relPath}: ${msg}`,
+          sourceType: source.type,
+          filePath: relPath
+        });
+        continue;
+      }
+      for (const match of matches) {
+        const originalSpecId = keyToSpecId.get(match.specId) ?? match.specId;
+        const globalMatch = {
+          ...match,
+          specId: originalSpecId,
+          sourceType: source.type,
+          relation: source.relation,
+          filePath: relPath
+        };
+        const existing = result.get(originalSpecId);
+        if (existing) {
+          existing.push(globalMatch);
         } else {
-          uncoveredItems.push({ id, description: desc });
+          result.set(originalSpecId, [globalMatch]);
         }
       }
-      const total = allTargetIds.size;
-      const covered = coveredItems.length;
-      const coveragePercent = total > 0 ? Math.round(covered / total * 100) : 100;
-      return { total, covered, uncovered: total - covered, coveragePercent, coveredItems, uncoveredItems };
     }
+  }
+  return { matches: result, warnings };
+}
+function runDeepValidation(specId, matches, deepValidation, spec) {
+  const errors = [];
+  const warnings = [];
+  for (const match of matches) {
+    const rule = deepValidation[match.sourceType];
+    if (!rule) continue;
+    if (match.sourceType === "openapi") {
+      const mapping = rule.mapper(spec);
+      const ctx = match.context;
+      if (!ctx?.match?.operation) continue;
+      validateOpenAPIDeep(specId, mapping, ctx.doc, ctx.match, warnings);
+    } else if (match.sourceType === "ddl") {
+      const mapping = rule.mapper(spec);
+      const ctx = match.context;
+      if (!ctx?.table) continue;
+      validateDDLDeep(specId, mapping, ctx.table, warnings);
+    }
+  }
+  return {
+    success: errors.length === 0,
+    errors,
+    warnings
   };
 }
-var ImplementsRelationSchema = z.object({
-  target: z.string(),
-  targetType: z.string(),
-  sourcePath: z.string().optional(),
-  description: z.string().optional()
-});
-var VerifiedByRelationSchema = z.object({
-  target: z.string(),
-  testPath: z.string().optional(),
-  framework: z.string().optional(),
-  description: z.string().optional()
-});
+function validateOpenAPIDeep(specId, mapping, doc, match, warnings) {
+  if (mapping.method && match.operation) {
+    const expectedMethod = mapping.method.toLowerCase();
+    const actualMethod = match.method?.toLowerCase();
+    if (actualMethod && actualMethod !== expectedMethod) {
+      warnings.push({
+        message: `Method mismatch for "${specId}": expected ${expectedMethod.toUpperCase()}, found ${actualMethod.toUpperCase()}`,
+        specId
+      });
+    }
+  }
+  if (match.operation && mapping.parameters) {
+    const opParams = (match.operation.parameters || []).map(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (p) => maybeResolveRef(doc, p)
+    );
+    for (const expectedParam of mapping.parameters) {
+      const found = opParams.find(
+        (p) => p?.name === expectedParam.name && (!expectedParam.in || p?.in === expectedParam.in)
+      );
+      if (!found) {
+        warnings.push({
+          message: `Parameter "${expectedParam.name}" not found in operation "${specId}"`,
+          specId,
+          field: expectedParam.name
+        });
+      } else if (expectedParam.type && found.schema?.type) {
+        if (!isTypeContainedBy(expectedParam.type, found.schema.type)) {
+          warnings.push({
+            message: `Parameter "${expectedParam.name}" type mismatch: expected ${expectedParam.type}, found ${found.schema.type}`,
+            specId,
+            field: expectedParam.name
+          });
+        }
+      }
+    }
+  }
+  if (match.operation && mapping.responseProperties) {
+    const successResponse = match.operation.responses?.["200"] || match.operation.responses?.["201"];
+    let responseSchema = successResponse?.content?.["application/json"]?.schema;
+    responseSchema = maybeResolveRef(doc, responseSchema);
+    if (responseSchema?.type === "array") {
+      responseSchema = maybeResolveRef(doc, responseSchema.items);
+    }
+    const responseProps = responseSchema?.properties || {};
+    for (const expectedProp of mapping.responseProperties) {
+      const foundProp = responseProps[expectedProp.name];
+      if (!foundProp) {
+        warnings.push({
+          message: `Response property "${expectedProp.name}" not found in operation "${specId}"`,
+          specId,
+          field: expectedProp.name
+        });
+      } else if (expectedProp.type && foundProp.type) {
+        if (!isTypeContainedBy(expectedProp.type, foundProp.type)) {
+          warnings.push({
+            message: `Response property "${expectedProp.name}" type mismatch: expected ${expectedProp.type}, found ${foundProp.type}`,
+            specId,
+            field: expectedProp.name
+          });
+        }
+      }
+    }
+  }
+}
+function validateDDLDeep(specId, mapping, table, warnings) {
+  if (!mapping.columns) return;
+  for (const expectedCol of mapping.columns) {
+    const foundCol = table.columns.find(
+      (c) => c.name.toLowerCase() === expectedCol.name.toLowerCase()
+    );
+    if (!foundCol) {
+      warnings.push({
+        message: `Column "${expectedCol.name}" not found in table "${mapping.tableName}"`,
+        specId,
+        field: expectedCol.name
+      });
+      continue;
+    }
+    if (mapping.checkTypes && expectedCol.type && foundCol.type) {
+      if (!isTypeContainedBy(expectedCol.type, foundCol.type)) {
+        warnings.push({
+          message: `Column "${expectedCol.name}" type mismatch in table "${mapping.tableName}": expected ${expectedCol.type}, found ${foundCol.type}`,
+          specId,
+          field: expectedCol.name
+        });
+      }
+    }
+  }
+}
 
-export { ImplementsRelationSchema, VerifiedByRelationSchema, annotationChecker, annotationCoverage, arrayMinLength, baseSpecSchema, childIdFormat, externalOpenAPIChecker, externalSqlSchemaChecker, getArtifactsConfig, idFormat, isTypeContainedBy, markdownExporter, relationCoverage, requireField, setArtifactsConfig, testChecker };
+export { ImplementsRelationSchema, VerifiedByRelationSchema, annotationCoverage, annotationScanner, arrayMinLength, baseSpecSchema, childIdFormat, createAnnotationScanner, ddlScanner, getArtifactsConfig, idFormat, isTypeContainedBy, markdownExporter, openapiScanner, relationCoverage, requireField, runDeepValidation, runGlobalScan, setArtifactsConfig };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map