speckeeper 0.8.1 → 0.9.1

package/dist/cli.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 import { readFileSync, existsSync, writeFileSync, mkdirSync, readdirSync, statSync } from 'fs';
-import { dirname, join, resolve } from 'path';
+import { dirname, join, resolve, isAbsolute } from 'path';
 import { fileURLToPath } from 'url';
 import chalk4 from 'chalk';
 import { parse } from 'yaml';
 import 'crypto';
-import 'glob';
+import { glob } from 'glob';
 import { z } from 'zod';
+import nodeSqlParser from 'node-sql-parser';
 
 var defaultConfig = {
   srcDir: "src",
@@ -410,6 +411,516 @@ function outputDriftResults(results, _options) {
   console.log("");
   console.log(chalk4.gray(`  Summary: ${ok.length} ok, ${drifted.length} drifted, ${missing.length} missing`));
 }
+
+// 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/global-scanner.ts
+function resolveRef(doc, ref) {
+  if (!ref.startsWith("#/")) return void 0;
+  const parts = ref.substring(2).split("/");
+  let current = doc;
+  for (const part of parts) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function maybeResolveRef(doc, value) {
+  if (value && typeof value === "object" && typeof value.$ref === "string") {
+    return resolveRef(doc, value.$ref);
+  }
+  return value;
+}
+function findSpecIdInOpenAPI(doc, specId) {
+  const paths = doc.paths;
+  if (!paths || typeof paths !== "object") return null;
+  for (const [pathKey, pathItem] of Object.entries(paths)) {
+    if (pathItem == null || typeof pathItem !== "object") continue;
+    const methods = ["get", "post", "put", "delete", "patch", "options", "head"];
+    for (const method of methods) {
+      const op = pathItem[method];
+      if (!op) continue;
+      if (op.operationId === specId) return { pathKey, operation: op, method };
+      if (op["x-spec-id"] === specId) return { pathKey, operation: op, method };
+    }
+  }
+  for (const pathKey of Object.keys(paths)) {
+    const segments = pathKey.split("/").filter(Boolean);
+    const cleanSegments = segments.map((s) => s.replace(/^\{|\}$/g, ""));
+    if (cleanSegments.includes(specId)) return { pathKey };
+  }
+  const schemas = doc.components?.schemas;
+  if (schemas && typeof schemas === "object") {
+    if (specId in schemas) return { pathKey: `#/components/schemas/${specId}` };
+  }
+  function searchXSpecId(obj) {
+    if (obj == null || typeof obj !== "object") return false;
+    if (obj["x-spec-id"] === specId) return true;
+    for (const val of Object.values(obj)) {
+      if (searchXSpecId(val)) return true;
+    }
+    return false;
+  }
+  if (searchXSpecId(doc)) return { pathKey: "(x-spec-id match)" };
+  return null;
+}
+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 matches;
+  }
+};
+function stripSchemaPrefix(name) {
+  const dotIndex = name.lastIndexOf(".");
+  return dotIndex >= 0 ? name.substring(dotIndex + 1) : name;
+}
+function parseDDLWithParser(content) {
+  const parser = new nodeSqlParser.Parser();
+  const tables = [];
+  try {
+    const ast = parser.astify(content);
+    const statements = Array.isArray(ast) ? ast : [ast];
+    for (const stmt of statements) {
+      if (stmt.type !== "create" || stmt.keyword !== "table") continue;
+      const rawName = typeof stmt.table === "string" ? stmt.table : stmt.table?.[0]?.table ?? "";
+      const tableName = stripSchemaPrefix(rawName);
+      const columns = (stmt.create_definitions || []).filter((def) => def.resource === "column").map((def) => {
+        const colName = def.column?.column ?? "";
+        let colType = def.definition?.dataType ?? "";
+        if (def.definition?.length) {
+          colType += `(${def.definition.length})`;
+        }
+        if (def.definition?.scale) {
+          colType = colType.replace(/\)$/, `,${def.definition.scale})`);
+        }
+        return { name: colName, type: colType };
+      });
+      if (tableName) {
+        tables.push({ name: tableName, columns });
+      }
+    }
+    return tables.length > 0 ? tables : null;
+  } catch {
+    return null;
+  }
+}
+function parseDDLWithRegex(content) {
+  const tables = [];
+  const tableRegex = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(?:(?:[`"']?\w+[`"']?\s*\.\s*)?)[`"']?(\w+)[`"']?\s*\(([\s\S]*?)\);/gi;
+  let match;
+  while ((match = tableRegex.exec(content)) !== null) {
+    const tableName = match[1];
+    const body = match[2];
+    const columns = [];
+    const lines = body.split(",").map((l) => l.trim()).filter(Boolean);
+    for (const line of lines) {
+      if (/^\s*(PRIMARY\s+KEY|UNIQUE|CHECK|CONSTRAINT|INDEX|FOREIGN\s+KEY)/i.test(line)) continue;
+      const colMatch = line.match(/^(?:`|"|')?(\w+)(?:`|"|')?\s+(\w+(?:\([^)]*\))?)/i);
+      if (colMatch) {
+        columns.push({ name: colMatch[1], type: colMatch[2] });
+      }
+    }
+    if (tableName) {
+      tables.push({ name: tableName, columns });
+    }
+  }
+  return tables;
+}
+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() === specId.toLowerCase()
+      );
+      if (table) {
+        matches.push({
+          specId,
+          location: `${filePath}:${table.name}`,
+          context: { table }
+        });
+      }
+    }
+    return matches;
+  }
+};
+function extractSpecIds(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 = extractSpecIds(m[1] ?? "");
+        for (const id of ids) {
+          if (specIdSet.has(id)) {
+            matches.push({
+              specId: id,
+              location: `${filePath}:${lineNum}`,
+              context: { filePath, line: lineNum }
+            });
+          }
+        }
+      }
+    }
+    return matches;
+  }
+};
+function createAnnotationScanner(contentPatterns) {
+  return {
+    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 = extractSpecIds(m[1] ?? "");
+            for (const id of ids) {
+              if (specIdSet.has(id)) {
+                matches.push({
+                  specId: id,
+                  location: `${filePath}:${lineNum}`,
+                  context: { filePath, line: lineNum }
+                });
+              }
+            }
+          }
+        }
+      }
+      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);
+      }
+    }
+    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;
+      }
+      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 {
+          result.set(originalSpecId, [globalMatch]);
+        }
+      }
+    }
+  }
+  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
+  };
+}
+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
+        });
+      }
+    }
+  }
+}
+
+// src/cli/check.ts
 async function checkCommand(type, options) {
   console.log(chalk4.blue("speckeeper check"));
   console.log("");
@@ -422,43 +933,101 @@ async function checkCommand(type, options) {
   try {
     const models = config.models || [];
     const specs = config.specs;
+    const sources = config.sources ?? [];
     if (options.verbose) {
       console.log(chalk4.gray(`  Registered models: ${models.map((m) => m.id).join(", ")}`));
+      console.log(chalk4.gray(`  Sources: ${sources.length} configured`));
     }
     const results = [];
+    const allSpecIds = [];
+    const specIdToModel = /* @__PURE__ */ new Map();
+    const lookupKeyMap = /* @__PURE__ */ new Map();
     for (const model of models) {
       const modelSpecs = getSpecsFromConfig(specs, model.id);
-      if (modelSpecs.length === 0) continue;
+      const modelLookupKeys = model.getLookupKeys?.();
       for (const spec of modelSpecs) {
-        const sourcePath = model.getExternalSourcePath(spec);
-        if (!sourcePath) continue;
-        const fullPath = join(cwd, sourcePath);
-        if (!existsSync(fullPath)) {
-          results.push({
-            type: model.id,
-            success: false,
-            issues: [{
-              severity: "error",
-              message: `External source not found: ${sourcePath}`,
-              specId: spec.id
-            }]
-          });
-          continue;
+        const specId = spec.id;
+        allSpecIds.push(specId);
+        specIdToModel.set(specId, { modelId: model.id, spec });
+        if (modelLookupKeys) {
+          const overrides = {};
+          for (const [sourceType, mapper] of Object.entries(modelLookupKeys)) {
+            if (typeof mapper === "function") {
+              overrides[sourceType] = mapper(spec);
+            }
+          }
+          if (Object.keys(overrides).length > 0) {
+            lookupKeyMap.set(specId, overrides);
+          }
         }
-        const externalData = loadExternalData(fullPath);
-        const checkResult = model.check(spec, externalData);
-        if (!checkResult.success || checkResult.errors.length > 0 || checkResult.warnings.length > 0) {
-          results.push({
-            type: model.id,
-            success: checkResult.success,
-            issues: [
-              ...checkResult.errors.map((e) => ({ severity: "error", message: e.message, specId: e.specId, field: e.field })),
-              ...checkResult.warnings.map((w) => ({ severity: "warning", message: w.message, specId: w.specId, field: w.field }))
-            ]
-          });
+      }
+    }
+    if (sources.length > 0 && allSpecIds.length > 0) {
+      const filteredSources = checkType === "all" ? sources : sources.filter((s) => s.type === checkType);
+      const { matches, warnings: scanWarnings } = runGlobalScan(
+        filteredSources,
+        allSpecIds,
+        cwd,
+        lookupKeyMap.size > 0 ? lookupKeyMap : void 0
+      );
+      for (const sw of scanWarnings) {
+        results.push({
+          type: sw.sourceType,
+          success: true,
+          issues: [{
+            severity: "warning",
+            message: sw.message
+          }]
+        });
+      }
+      for (const [specId, entry] of specIdToModel) {
+        const specMatches = matches.get(specId);
+        if (specMatches && specMatches.length > 0) {
+          const model = models.find((m) => m.id === entry.modelId);
+          const deepValidation = model?.getDeepValidation?.();
+          if (deepValidation) {
+            const deepResult = runDeepValidation(specId, specMatches, deepValidation, entry.spec);
+            if (deepResult.errors.length > 0 || deepResult.warnings.length > 0) {
+              results.push({
+                type: entry.modelId,
+                success: deepResult.success,
+                issues: [
+                  ...deepResult.errors.map((e) => ({
+                    severity: "error",
+                    message: e.message,
+                    specId: e.specId,
+                    field: e.field
+                  })),
+                  ...deepResult.warnings.map((w) => ({
+                    severity: "warning",
+                    message: w.message,
+                    specId: w.specId,
+                    field: w.field
+                  }))
+                ]
+              });
+            }
+          }
+        }
+      }
+      if (options.verbose) {
+        for (const specId of allSpecIds) {
+          if (!matches.has(specId)) {
+            const entry = specIdToModel.get(specId);
+            results.push({
+              type: entry?.modelId ?? "unknown",
+              success: true,
+              issues: [{
+                severity: "warning",
+                message: `Spec ID "${specId}" not found in any configured source`,
+                specId
+              }]
+            });
+          }
         }
       }
     }
+    runLegacyChecks(models, specs, cwd, results);
     outputCheckResults(results);
     if (options.coverage) {
       console.log("");
@@ -511,6 +1080,41 @@ function loadExternalData(filePath) {
   }
   return content;
 }
+function runLegacyChecks(models, specs, cwd, results) {
+  for (const model of models) {
+    const modelSpecs = getSpecsFromConfig(specs, model.id);
+    if (modelSpecs.length === 0) continue;
+    for (const spec of modelSpecs) {
+      const sourcePath = model.getExternalSourcePath?.(spec);
+      if (!sourcePath) continue;
+      const fullPath = join(cwd, sourcePath);
+      if (!existsSync(fullPath)) {
+        results.push({
+          type: model.id,
+          success: false,
+          issues: [{
+            severity: "error",
+            message: `External source not found: ${sourcePath}`,
+            specId: spec.id
+          }]
+        });
+        continue;
+      }
+      const externalData = loadExternalData(fullPath);
+      const checkResult = model.check(spec, externalData);
+      if (!checkResult.success || checkResult.errors.length > 0 || checkResult.warnings.length > 0) {
+        results.push({
+          type: model.id,
+          success: checkResult.success,
+          issues: [
+            ...checkResult.errors.map((e) => ({ severity: "error", message: e.message, specId: e.specId, field: e.field })),
+            ...checkResult.warnings.map((w) => ({ severity: "warning", message: w.message, specId: w.specId, field: w.field }))
+          ]
+        });
+      }
+    }
+  }
+}
 function outputCheckResults(results) {
   console.log("");
   if (results.length === 0) {
@@ -1224,9 +1828,6 @@ function resolveEdges(edges, nodes, speckeeperClassName) {
   }
   return { resolved, diagnostics };
 }
-function isCheckEdge(entry) {
-  return entry.category === "check";
-}
 
 // src/scaffold/template-registry.ts
 var LEVEL_PATTERNS = [
@@ -1270,56 +1871,11 @@ function toKebabCase(s) {
   return s.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[_\s]+/g, "-").toLowerCase();
 }
 
-// src/scaffold/artifact-defaults.ts
-var SPECIALIZED_CHECKER_MAP = {
-  openapi: "externalOpenAPIChecker",
-  sqlschema: "externalSqlSchemaChecker"
-};
-function generateCheckerCode(bindings, modelName) {
-  const dslImports = /* @__PURE__ */ new Set(["annotationChecker"]);
-  for (const b of bindings) {
-    const specialized = SPECIALIZED_CHECKER_MAP[b.targetClass];
-    if (specialized) dslImports.add(specialized);
-  }
-  const checks = bindings.map((b) => {
-    const specialized = SPECIALIZED_CHECKER_MAP[b.targetClass];
-    const artifact = `'${b.targetClass}'`;
-    const relationType = `'${b.edgeType}'`;
-    if (specialized) {
-      return `{ artifact: ${artifact}, relationType: ${relationType}, checker: ${specialized}() }`;
-    }
-    return `{ artifact: ${artifact}, relationType: ${relationType} }`;
-  });
-  let config;
-  if (checks.length === 1) {
-    config = checks[0];
-  } else {
-    config = `{
-    checks: [
-      ${checks.join(",\n      ")}
-    ],
-  }`;
-  }
-  const code = `protected externalChecker = annotationChecker<${modelName}>(${config});`;
-  return {
-    code,
-    dslImports: Array.from(dslImports)
-  };
-}
-
 // src/scaffold/templates/base.ts
 function generateBaseModel(params) {
   const schemaName = `${params.modelName}Schema`;
   const className = `${params.modelName}Model`;
-  const hasCheckerBindings = params.checkerBindings && params.checkerBindings.length > 0;
-  const checkerGen = hasCheckerBindings ? generateCheckerCode(params.checkerBindings, params.modelName) : null;
-  const dslImportItems = ["requireField"];
-  if (checkerGen) {
-    dslImportItems.push(...checkerGen.dslImports);
-  }
-  const dslImportLine = `import { ${dslImportItems.join(", ")} } from 'speckeeper/dsl';`;
-  const externalCheckerLine = checkerGen ? `
-  ${checkerGen.code}` : "";
+  const dslImportLine = `import { requireField } from 'speckeeper/dsl';`;
   return `/**
  * ${params.modelName} Model Definition
  *
@@ -1364,7 +1920,7 @@ class ${className} extends Model<typeof ${schemaName}> {
     requireField<${params.modelName}>('description'),
   ];
 
-  protected exporters: Exporter<${params.modelName}>[] = [];${externalCheckerLine}
+  protected exporters: Exporter<${params.modelName}>[] = [];
 }
 
 export { ${className} };
@@ -1377,34 +1933,15 @@ var MODEL_TEMPLATE_FUNCTIONS = {
 };
 
 // src/scaffold/model-generator.ts
-function resolveCheckerBindings(_nodeId, outgoingEdges, nodes, speckeeperClassName) {
-  const isSpk = (id) => nodes.get(id)?.classes.includes(speckeeperClassName) ?? false;
-  const bindings = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const edge of outgoingEdges) {
-    if (!isCheckEdge(edge.vocabulary)) continue;
-    if (isSpk(edge.targetId)) continue;
-    if (seen.has(edge.targetId)) continue;
-    seen.add(edge.targetId);
-    const targetNode = nodes.get(edge.targetId);
-    const targetClass = targetNode?.classes.find((c) => c !== speckeeperClassName) ?? edge.targetId.toLowerCase();
-    const edgeType = edge.normalizedLabel === "verifiedBy" ? "verifiedBy" : "implements";
-    bindings.push({ edgeType, targetNodeId: edge.targetId, targetClass });
-  }
-  return bindings;
-}
-function generateModelFile(node, _incomingEdges, outgoingEdges, allNodes) {
+function generateModelFile(node, _incomingEdges, _outgoingEdges, _allNodes) {
   const templateInfo = resolveModelTemplate(node.id, node.classes, node.subgraph);
   const templateFn = MODEL_TEMPLATE_FUNCTIONS[templateInfo.templateName];
-  const bindings = allNodes ? resolveCheckerBindings(node.id, outgoingEdges, allNodes, "speckeeper") : [];
-  const checkerBindings = bindings.length > 0 ? bindings.map((b) => ({ edgeType: b.edgeType, targetClass: b.targetClass })) : void 0;
   const params = {
     modelId: templateInfo.fileName,
     modelName: templateInfo.modelName,
     idPrefix: templateInfo.defaultIdPrefix,
     level: templateInfo.defaultLevel,
-    description: node.label ?? node.id,
-    checkerBindings
+    description: node.label ?? node.id
   };
   const content = !templateFn ? MODEL_TEMPLATE_FUNCTIONS["base"](params) : templateFn(params);
   return {
@@ -1492,9 +2029,9 @@ function generateAllModelFiles(speckeeperNodes, resolvedEdges, allNodes) {
     generated.add(key);
     const groupNodes = templateNodeGroups.get(key) ?? [node];
     const groupNodeIds = new Set(groupNodes.map((n) => n.id));
-    const incoming = resolvedEdges.filter((e) => groupNodeIds.has(e.targetId));
-    const outgoing = resolvedEdges.filter((e) => groupNodeIds.has(e.sourceId));
-    files.push(generateModelFile(node, incoming, outgoing, allNodes));
+    resolvedEdges.filter((e) => groupNodeIds.has(e.targetId));
+    resolvedEdges.filter((e) => groupNodeIds.has(e.sourceId));
+    files.push(generateModelFile(node));
     files.push(generateSpecDataFile(node));
   }
   files.push(generateDesignIndex(speckeeperNodes));