@elevasis/core 0.11.2 → 0.12.0

package/src/scaffold-registry/index.ts

@@ -1,4 +1,5 @@
-import { existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { createHash } from 'node:crypto'
+import { existsSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs'
 import path from 'node:path'
 import { parse as parseYaml } from 'yaml'
 import { type ScaffoldRegistry, type ScaffoldRegistryEntry, ScaffoldRegistrySchema } from './schema'
@@ -86,15 +87,23 @@ export function loadScaffoldRegistry(): ScaffoldRegistry {
 
   const registry = result.data
 
-  // Drift check: if compiled JSON exists, verify entry count matches
+  // Drift check: if compiled JSON exists, verify the full normalized content matches.
   const jsonPath = path.join(root, JSON_FILENAME)
   try {
     const compiledRaw = readFileSync(jsonPath, 'utf-8')
-    const compiled = JSON.parse(compiledRaw) as { entries?: unknown[] }
-    if (compiled.entries?.length !== registry.entries.length) {
+    const compiledParsed = JSON.parse(compiledRaw) as unknown
+    const compiledResult = ScaffoldRegistrySchema.safeParse(compiledParsed)
+    if (!compiledResult.success) {
+      const issues = compiledResult.error.issues.map((i) => `  [${i.path.join('.')}] ${i.message}`).join('\n')
+      throw new Error(`scaffold-registry: compiled JSON validation failed:\n${issues}`)
+    }
+
+    const yamlHash = stableRegistryHash(registry)
+    const compiledHash = stableRegistryHash(compiledResult.data)
+    if (compiledHash !== yamlHash) {
       throw new Error(
         `scaffold-registry: compiled JSON is out of sync with YAML ` +
-          `(YAML has ${registry.entries.length} entries, JSON has ${compiled.entries?.length ?? 0}). ` +
+          `(YAML hash ${yamlHash.slice(0, 12)}, JSON hash ${compiledHash.slice(0, 12)}). ` +
           `Run compileScaffoldRegistry() to regenerate.`
       )
     }
@@ -131,6 +140,17 @@ export function compileScaffoldRegistry(): ScaffoldRegistry {
     )
   }
 
+  const emptySources = findEmptySourcePatterns(registry, root)
+  if (emptySources.length > 0) {
+    const formatted = emptySources
+      .map((source) => `  [${source.entryId}] ${source.pattern}`)
+      .join('\n')
+    throw new Error(
+      `scaffold-registry: ${emptySources.length} source pattern(s) match no files or directories:\n${formatted}\n` +
+        `Fix the stale source glob, create the scaffold surface, or add explicit registry support for intentional empty patterns.`
+    )
+  }
+
   const jsonPath = path.join(root, JSON_FILENAME)
   writeFileSync(jsonPath, JSON.stringify(registry, null, 2) + '\n', 'utf-8')
 
@@ -166,6 +186,29 @@ export function findMissingDependentPaths(
   return missing
 }
 
+/**
+ * Return source patterns that do not currently match any file or directory.
+ * Symbolic sources are skipped because they intentionally do not resolve to
+ * monorepo paths.
+ */
+export function findEmptySourcePatterns(
+  registry: ScaffoldRegistry,
+  monorepoRootDir: string
+): Array<{ entryId: string; pattern: string }> {
+  const empty: Array<{ entryId: string; pattern: string }> = []
+
+  for (const entry of registry.entries) {
+    for (const sourcePattern of entry.sources) {
+      if (isSymbolicTarget(sourcePattern)) continue
+      if (!sourcePatternMatchesAnyPath(sourcePattern, monorepoRootDir)) {
+        empty.push({ entryId: entry.id, pattern: sourcePattern })
+      }
+    }
+  }
+
+  return empty
+}
+
 // ---------------------------------------------------------------------------
 // Lookup helpers (used by hooks for fast path matching)
 // ---------------------------------------------------------------------------
@@ -197,7 +240,9 @@ export function loadScaffoldRegistryFast(): ScaffoldRegistry {
  * is implemented.
  */
 export function findMatchingEntries(registry: ScaffoldRegistry, filePath: string): ScaffoldRegistryEntry[] {
-  return registry.entries.filter((entry) => entry.sources.some((pattern) => pathMatchesPattern(filePath, pattern)))
+  return registry.entries.filter((entry) =>
+    entry.sources.some((pattern) => scaffoldPathMatchesPattern(filePath, pattern))
+  )
 }
 
 // ---------------------------------------------------------------------------
@@ -221,6 +266,24 @@ function loadScaffoldRegistryNoSyncCheck(root: string): ScaffoldRegistry {
   return result.data
 }
 
+export function normalizeScaffoldPath(p: string): string {
+  return p.replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/+$/, '')
+}
+
+export function scaffoldPathMatchesPattern(filePath: string, pattern: string): boolean {
+  const normalizedFile = normalizeScaffoldPath(filePath)
+  const normalizedPattern = normalizeScaffoldPath(pattern)
+
+  if (!normalizedFile || !normalizedPattern) return false
+  if (normalizedFile === normalizedPattern) return true
+
+  if (!isGlobPattern(normalizedPattern)) {
+    return normalizedFile.startsWith(normalizedPattern + '/')
+  }
+
+  return globToRegExp(normalizedPattern).test(normalizedFile)
+}
+
 function isSymbolicTarget(p: string): boolean {
   return p.startsWith('docs:') || p.startsWith('autogen-target:')
 }
@@ -229,30 +292,100 @@ function isGlobPattern(p: string): boolean {
   return /[*?[]/.test(p)
 }
 
-/**
- * Lightweight pattern match: handles exact paths, directory prefixes, and
- * simple `*` wildcards at the end of a segment. Full micromatch lands in Step 3.
- */
-function pathMatchesPattern(filePath: string, pattern: string): boolean {
-  // Normalize separators
-  const normalizedFile = filePath.replace(/\\/g, '/')
-  const normalizedPattern = pattern.replace(/\\/g, '/')
+function stableRegistryHash(registry: ScaffoldRegistry): string {
+  return createHash('sha256').update(JSON.stringify(registry)).digest('hex')
+}
 
-  // Exact match
-  if (normalizedFile === normalizedPattern) return true
+function globToRegExp(pattern: string): RegExp {
+  const segments = pattern.split('/')
+  let regex = '^'
+
+  for (let index = 0; index < segments.length; index++) {
+    const segment = segments[index]
+    const isLast = index === segments.length - 1
+
+    if (segment === '**') {
+      regex += isLast ? '(?:.*)?' : '(?:[^/]+/)*'
+      continue
+    }
+
+    regex += segmentToRegExpSource(segment)
+    if (!isLast) regex += '/'
+  }
+
+  regex += '$'
+  return new RegExp(regex)
+}
+
+function segmentToRegExpSource(segment: string): string {
+  let source = ''
+  for (let index = 0; index < segment.length; index++) {
+    const char = segment[index]
+    if (char === '*') {
+      source += '[^/]*'
+    } else if (char === '?') {
+      source += '[^/]'
+    } else {
+      source += escapeRegExp(char)
+    }
+  }
+  return source
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&')
+}
 
-  // If pattern ends with `/**` or `/*`, check prefix
-  if (normalizedPattern.endsWith('/**') || normalizedPattern.endsWith('/*')) {
-    const prefix = normalizedPattern.slice(0, normalizedPattern.lastIndexOf('/*'))
-    return normalizedFile.startsWith(prefix + '/')
+function sourcePatternMatchesAnyPath(sourcePattern: string, monorepoRootDir: string): boolean {
+  const normalizedPattern = normalizeScaffoldPath(sourcePattern)
+
+  if (!isGlobPattern(normalizedPattern)) {
+    return existsSync(path.join(monorepoRootDir, normalizedPattern))
+  }
+
+  const baseDir = findGlobBaseDirectory(normalizedPattern)
+  const absoluteBase = path.join(monorepoRootDir, baseDir)
+  if (!existsSync(absoluteBase)) return false
+
+  return walkUntilMatch(absoluteBase, monorepoRootDir, normalizedPattern)
+}
+
+function findGlobBaseDirectory(pattern: string): string {
+  const segments = pattern.split('/')
+  const baseSegments: string[] = []
+  for (const segment of segments) {
+    if (isGlobPattern(segment)) break
+    baseSegments.push(segment)
   }
+  return baseSegments.join('/')
+}
+
+function walkUntilMatch(currentPath: string, monorepoRootDir: string, pattern: string): boolean {
+  const rel = normalizeScaffoldPath(path.relative(monorepoRootDir, currentPath))
+  if (rel && scaffoldPathMatchesPattern(rel, pattern)) return true
 
-  // If pattern contains `*`, convert to simple regex
-  if (normalizedPattern.includes('*')) {
-    const escaped = normalizedPattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '[^/]*')
-    return new RegExp(`^${escaped}$`).test(normalizedFile)
+  let entries
+  try {
+    entries = readdirSync(currentPath, { withFileTypes: true })
+  } catch {
+    return false
+  }
+
+  for (const entry of entries) {
+    const absolutePath = path.join(currentPath, entry.name)
+    const relativePath = normalizeScaffoldPath(path.relative(monorepoRootDir, absolutePath))
+
+    if (scaffoldPathMatchesPattern(relativePath, pattern)) return true
+    if (entry.isDirectory()) {
+      try {
+        if (statSync(absolutePath).isDirectory() && walkUntilMatch(absolutePath, monorepoRootDir, pattern)) {
+          return true
+        }
+      } catch {
+        continue
+      }
+    }
   }
 
-  // Directory prefix match (pattern is a directory)
-  return normalizedFile.startsWith(normalizedPattern + '/')
+  return false
 }