speckeeper 0.7.2 → 0.8.1

package/dist/dsl/index.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { d as LintRule, E as Exporter, c as ExternalChecker, a as CoverageChecker } from '../model-BPZMYasZ.js';
+import { q as LintRule, m as Exporter, n as ExternalChecker, k as CoverageChecker, A as ArtifactConfig } from '../config-api-U2pt1aHJ.js';
 
 /**
  * Core DSL — Base spec schema
@@ -125,6 +125,37 @@ interface TestCheckerConfig<T> {
 declare function testChecker<T extends {
     id: string;
 }>(config?: TestCheckerConfig<T>): ExternalChecker<T>;
+type AnnotationRelationType = 'verifiedBy' | 'implements' | 'traces';
+interface AnnotationCheckEntry {
+    artifact: string;
+    relationType: AnnotationRelationType;
+    contentPatterns?: RegExp[];
+    checker?: ExternalChecker<{
+        id: string;
+    }>;
+}
+interface AnnotationCheckerConfig<_T extends {
+    id: string;
+}> {
+    artifact?: string;
+    relationType?: AnnotationRelationType;
+    checks?: AnnotationCheckEntry[];
+    contentPatterns?: RegExp[];
+}
+declare function setArtifactsConfig(config: Record<string, ArtifactConfig>): void;
+declare function getArtifactsConfig(): Record<string, ArtifactConfig> | undefined;
+declare function annotationChecker<T extends {
+    id: string;
+}>(config?: AnnotationCheckerConfig<T>): ExternalChecker<T>;
+interface AnnotationCoverageConfig {
+    artifact: string;
+    relationType: AnnotationRelationType;
+    description: string;
+    contentPatterns?: RegExp[];
+}
+declare function annotationCoverage<T extends {
+    id: string;
+}>(config: AnnotationCoverageConfig): CoverageChecker<T>;
 interface OpenAPICheckerConfig<T> {
     sourcePath?: (spec: T) => string;
     mapper: (spec: T) => {
@@ -250,4 +281,4 @@ declare const VerifiedByRelationSchema: z.ZodObject<{
 }>;
 type VerifiedByRelation = z.infer<typeof VerifiedByRelationSchema>;
 
-export { type BaseSpec, type ImplementsRelation, ImplementsRelationSchema, type MarkdownExporterConfig, type VerifiedByRelation, VerifiedByRelationSchema, arrayMinLength, baseSpecSchema, childIdFormat, externalOpenAPIChecker, externalSqlSchemaChecker, idFormat, isTypeContainedBy, markdownExporter, relationCoverage, requireField, testChecker };
+export { type AnnotationCheckEntry, type AnnotationCheckerConfig, type AnnotationCoverageConfig, type BaseSpec, type ImplementsRelation, ImplementsRelationSchema, type MarkdownExporterConfig, type VerifiedByRelation, VerifiedByRelationSchema, annotationChecker, annotationCoverage, arrayMinLength, baseSpecSchema, childIdFormat, externalOpenAPIChecker, externalSqlSchemaChecker, getArtifactsConfig, idFormat, isTypeContainedBy, markdownExporter, relationCoverage, requireField, setArtifactsConfig, testChecker };

package/dist/dsl/index.js

@@ -290,6 +290,195 @@ function testChecker(config) {
     }
   };
 }
+function relationTypeToAnnotation(relationType) {
+  return relationType === "verifiedBy" ? "verifies" : relationType;
+}
+function getDefaultPatternForRelation(relationType) {
+  const ann = relationTypeToAnnotation(relationType);
+  return new RegExp(`@${ann}\\s+([\\w-]+(?:[,\\s]+[\\w-]+)*)`, "g");
+}
+function extractSpecIds(captured) {
+  return captured.split(/[,\s]+/).map((s) => s.trim()).filter(Boolean);
+}
+var _artifactsConfig;
+function setArtifactsConfig(config) {
+  _artifactsConfig = 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",
+    description: config.description,
+    check: (specs, _registry) => {
+      const basePath = process.cwd();
+      const allSpecIds = new Set(specs.map((s) => s.id));
+      const coveredIds = /* @__PURE__ */ new Set();
+      const artifactsConfig = getArtifactsConfig();
+      const artifactConfig = artifactsConfig?.[config.artifact];
+      if (!artifactConfig) {
+        return {
+          total: allSpecIds.size,
+          covered: 0,
+          uncovered: allSpecIds.size,
+          coveragePercent: 0,
+          coveredItems: [],
+          uncoveredItems: Array.from(allSpecIds).map((id) => ({ id }))
+        };
+      }
+      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 = config.contentPatterns ?? artifactConfig.contentPatterns ?? [getDefaultPatternForRelation(config.relationType)];
+      const patternList = Array.isArray(patterns) ? patterns : [patterns];
+      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 (const line of lines) {
+          for (const re of patternList) {
+            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 (allSpecIds.has(id)) {
+                  coveredIds.add(id);
+                }
+              }
+            }
+          }
+        }
+      }
+      const coveredItems = Array.from(coveredIds).map((id) => ({ id }));
+      const uncoveredItems = Array.from(allSpecIds).filter((id) => !coveredIds.has(id)).map((id) => ({ id }));
+      const total = allSpecIds.size;
+      const covered = coveredItems.length;
+      const coveragePercent = total > 0 ? Math.round(covered / total * 100) : 100;
+      return {
+        total,
+        covered,
+        uncovered: total - covered,
+        coveragePercent,
+        coveredItems,
+        uncoveredItems
+      };
+    }
+  };
+}
 function resolveRef(doc, ref) {
   if (!ref.startsWith("#/")) return void 0;
   const parts = ref.substring(2).split("/");
@@ -451,6 +640,10 @@ function externalOpenAPIChecker(config) {
     }
   };
 }
+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 = [];
@@ -459,7 +652,8 @@ function parseDDLWithParser(content) {
     const statements = Array.isArray(ast) ? ast : [ast];
     for (const stmt of statements) {
       if (stmt.type !== "create" || stmt.keyword !== "table") continue;
-      const tableName = typeof stmt.table === "string" ? stmt.table : stmt.table?.[0]?.table ?? "";
+      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 ?? "";
@@ -482,7 +676,7 @@ function parseDDLWithParser(content) {
 }
 function parseDDLWithRegex(content) {
   const tables = [];
-  const tableRegex = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(?:`|"|')?(\w+)(?:`|"|')?\s*\(([\s\S]*?)\);/gi;
+  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];
@@ -628,6 +822,6 @@ var VerifiedByRelationSchema = z.object({
   description: z.string().optional()
 });
 
-export { ImplementsRelationSchema, VerifiedByRelationSchema, arrayMinLength, baseSpecSchema, childIdFormat, externalOpenAPIChecker, externalSqlSchemaChecker, idFormat, isTypeContainedBy, markdownExporter, relationCoverage, requireField, testChecker };
+export { ImplementsRelationSchema, VerifiedByRelationSchema, annotationChecker, annotationCoverage, arrayMinLength, baseSpecSchema, childIdFormat, externalOpenAPIChecker, externalSqlSchemaChecker, getArtifactsConfig, idFormat, isTypeContainedBy, markdownExporter, relationCoverage, requireField, setArtifactsConfig, testChecker };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map