@elevasis/core 0.10.0 → 0.11.1

package/src/scaffold-registry/__tests__/index.test.ts

@@ -1,5 +1,24 @@
 import { describe, expect, it } from 'vitest'
-import { loadScaffoldRegistryFast } from '../index'
+import { findMatchingEntries, findMissingDependentPaths, loadScaffoldRegistryFast } from '../index'
+import type { ScaffoldRegistry, ScaffoldRegistryEntry } from '../schema'
+
+function makeEntry(id: string, sources: string[]): ScaffoldRegistryEntry {
+  return {
+    id,
+    kind: 'manual-scaffold',
+    owner: 'packages/core',
+    sources,
+    dependents: [{ path: 'packages/core/package.json', regen: 'manual', hint: 'h' }]
+  }
+}
+
+function registryFromEntries(entries: ScaffoldRegistryEntry[]): ScaffoldRegistry {
+  return { version: '1', entries }
+}
+
+function matchedIds(registry: ScaffoldRegistry, filePath: string): string[] {
+  return findMatchingEntries(registry, filePath).map((e) => e.id)
+}
 
 describe('loadScaffoldRegistryFast', () => {
   it('preserves external sync metadata from the compiled registry', () => {
@@ -15,3 +34,108 @@ describe('loadScaffoldRegistryFast', () => {
     })
   })
 })
+
+describe('findMissingDependentPaths', () => {
+  const baseEntry = {
+    id: 'fake-entry',
+    kind: 'manual-scaffold' as const,
+    owner: 'packages/core',
+    sources: ['packages/core/src/**'],
+    dependents: [{ path: 'packages/core/this-file-does-not-exist.ts', regen: 'manual', hint: 'h' }]
+  }
+
+  it('flags dependents whose paths are missing on disk', () => {
+    const registry: ScaffoldRegistry = { version: '1', entries: [baseEntry] }
+    const missing = findMissingDependentPaths(registry, process.cwd())
+    expect(missing).toEqual([{ entryId: 'fake-entry', path: 'packages/core/this-file-does-not-exist.ts' }])
+  })
+
+  it('skips symbolic targets, globs, and (self)', () => {
+    const registry: ScaffoldRegistry = {
+      version: '1',
+      entries: [
+        {
+          ...baseEntry,
+          dependents: [
+            { path: 'docs: sync-preservation-matrix', regen: 'manual', hint: 'h' },
+            { path: 'autogen-target:foo', regen: 'manual', hint: 'h' },
+            { path: 'packages/core/src/**/*.ts', regen: 'manual', hint: 'h' },
+            { path: '(self)', regen: 'manual', hint: 'h' }
+          ]
+        }
+      ]
+    }
+    expect(findMissingDependentPaths(registry, process.cwd())).toEqual([])
+  })
+
+  it('skips sync-preservation entries (their paths target derived external projects)', () => {
+    const registry: ScaffoldRegistry = {
+      version: '1',
+      entries: [
+        {
+          id: 'sync-entry',
+          kind: 'sync-preservation',
+          owner: '@elevasis/core',
+          category: 'merge',
+          strategy: 'merge-regions',
+          delete_policy: 'none',
+          sources: ['external/_template/foo.ts'],
+          dependents: [{ path: 'core/src/foo-not-in-monorepo.ts', regen: 'manual', hint: 'h' }]
+        }
+      ]
+    }
+    expect(findMissingDependentPaths(registry, process.cwd())).toEqual([])
+  })
+})
+
+describe('findMatchingEntries (pattern matching)', () => {
+  it('matches exact paths', () => {
+    const reg = registryFromEntries([makeEntry('exact', ['packages/core/src/index.ts'])])
+    expect(matchedIds(reg, 'packages/core/src/index.ts')).toEqual(['exact'])
+    expect(matchedIds(reg, 'packages/core/src/other.ts')).toEqual([])
+  })
+
+  it('matches /** suffix as deep prefix', () => {
+    const reg = registryFromEntries([makeEntry('deep', ['packages/core/src/**'])])
+    expect(matchedIds(reg, 'packages/core/src/foo.ts')).toEqual(['deep'])
+    expect(matchedIds(reg, 'packages/core/src/nested/deeply/foo.ts')).toEqual(['deep'])
+    expect(matchedIds(reg, 'packages/core/package.json')).toEqual([])
+    expect(matchedIds(reg, 'packages/core/src')).toEqual([])
+  })
+
+  it('matches /* suffix as single-level prefix', () => {
+    const reg = registryFromEntries([makeEntry('shallow', ['packages/*/package.json'])])
+    expect(matchedIds(reg, 'packages/core/package.json')).toEqual(['shallow'])
+    expect(matchedIds(reg, 'packages/ui/package.json')).toEqual(['shallow'])
+    expect(matchedIds(reg, 'packages/core/nested/package.json')).toEqual([])
+  })
+
+  it('current matcher does NOT support mixed **/*.ext patterns (Step 3 upgrade)', () => {
+    // The simple matcher's `/*` suffix branch only handles a single trailing
+    // wildcard. Patterns like `**/*.ts` fall through and effectively miss real
+    // files. Locked in to flag any change when full micromatch lands.
+    const reg = registryFromEntries([makeEntry('ext', ['apps/api/src/**/*.ts'])])
+    expect(matchedIds(reg, 'apps/api/src/foo.ts')).toEqual([])
+  })
+
+  it('normalizes Windows backslashes to forward slashes', () => {
+    const reg = registryFromEntries([makeEntry('winpath', ['packages/core/src/**'])])
+    expect(matchedIds(reg, 'packages\\core\\src\\foo.ts')).toEqual(['winpath'])
+  })
+
+  it('matches a directory-prefix pattern (no glob characters)', () => {
+    const reg = registryFromEntries([makeEntry('dir', ['packages/core/src'])])
+    expect(matchedIds(reg, 'packages/core/src/foo.ts')).toEqual(['dir'])
+    expect(matchedIds(reg, 'packages/core/srcfoo.ts')).toEqual([])
+  })
+
+  it('returns multiple entries when several match the same file', () => {
+    const reg = registryFromEntries([makeEntry('a', ['packages/core/src/**']), makeEntry('b', ['packages/core/src'])])
+    expect(matchedIds(reg, 'packages/core/src/foo.ts').sort()).toEqual(['a', 'b'])
+  })
+
+  it('returns empty when no entries match', () => {
+    const reg = registryFromEntries([makeEntry('a', ['packages/core/src/**'])])
+    expect(matchedIds(reg, 'apps/api/src/foo.ts')).toEqual([])
+  })
+})

package/src/scaffold-registry/__tests__/schema.test.ts

@@ -18,12 +18,9 @@ describe('ScaffoldEntryKindSchema', () => {
     const validKinds = [
       'autogen',
       'manual-scaffold',
-      'typed-id',
-      'sync-preservation',
-      'vibe-gated',
-      'sdk-cli-generator',
-      'validator',
-      'other'
+      'sync-preservation',
+      'validator',
+      'other'
     ]
     for (const kind of validKinds) {
       expect(ScaffoldEntryKindSchema.safeParse(kind).success).toBe(true)
@@ -91,9 +88,8 @@ const validEntry = {
   dependents: [
     {
       path: '.navigation/_generated/skeleton.md',
-      regen: 'pnpm navigation:generate',
-      kind: 'autogen',
-      hint: 'Regenerate after rename.'
+      regen: 'pnpm navigation:generate',
+      hint: 'Regenerate after rename.'
     }
   ]
 }
@@ -176,10 +172,24 @@ describe('ScaffoldRegistryEntrySchema — valid entry', () => {
     expect(ScaffoldRegistryEntrySchema.safeParse(withBadAutoRegen).success).toBe(false)
   })
 
-  it('parses all six seed-entry kinds', () => {
-    const kinds = ['autogen', 'manual-scaffold', 'typed-id', 'sync-preservation', 'vibe-gated', 'validator']
-    for (const kind of kinds) {
-      const result = ScaffoldRegistryEntrySchema.safeParse({ ...validEntry, kind })
+  it('parses all seed-entry kinds with required invariants', () => {
+    const entries = [
+      { ...validEntry, kind: 'autogen', regen: 'pnpm navigation:generate' },
+      { ...validEntry, kind: 'manual-scaffold' },
+      {
+        ...validEntry,
+        kind: 'sync-preservation',
+        owner: 'template',
+        category: 'replace',
+        strategy: 'replace-all',
+        delete_policy: 'none'
+      },
+      { ...validEntry, kind: 'validator', dependents: [{ path: '(self)', regen: 'pnpm meta:verify' }] },
+      { ...validEntry, kind: 'other', notes: 'Vendor generated.' }
+    ]
+    for (const entry of entries) {
+      const result = ScaffoldRegistryEntrySchema.safeParse(entry)
+      const kind = entry.kind
       expect(result.success, `kind ${kind} should parse`).toBe(true)
     }
   })
@@ -201,6 +211,21 @@ describe('ScaffoldRegistryEntrySchema — valid entry', () => {
     }
   })
 
+  it('rejects autogen entries without top-level regen', () => {
+    const result = ScaffoldRegistryEntrySchema.safeParse({ ...validEntry, kind: 'autogen' })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects other entries without notes', () => {
+    const result = ScaffoldRegistryEntrySchema.safeParse({ ...validEntry, kind: 'other' })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects sync-preservation entries without external sync metadata', () => {
+    const result = ScaffoldRegistryEntrySchema.safeParse({ ...validEntry, kind: 'sync-preservation' })
+    expect(result.success).toBe(false)
+  })
+
   it('keeps legacy free-form owner values valid when external sync fields are omitted', () => {
     const result = ScaffoldRegistryEntrySchema.safeParse({
       ...validEntry,
@@ -361,13 +386,16 @@ describe('ScaffoldRegistrySchema', () => {
           sources: ['apps/docs/content/docs/**/meta.json'],
           dependents: [{ path: '(self)', regen: 'pnpm check-docs-meta' }]
         },
-        {
-          id: 'external-template-hook-added',
-          kind: 'sync-preservation',
-          owner: 'external/_template',
-          sources: ['external/_template/.claude/hooks/*.mjs'],
-          dependents: [{ path: 'external/_template/.claude/settings.json', regen: 'manual' }]
-        }
+        {
+          id: 'external-template-hook-added',
+          kind: 'sync-preservation',
+          owner: 'template',
+          category: 'replace',
+          strategy: 'replace-all',
+          delete_policy: 'none',
+          sources: ['external/_template/.claude/hooks/*.mjs'],
+          dependents: [{ path: 'external/_template/.claude/settings.json', regen: 'manual' }]
+        }
       ]
     }
     const result = ScaffoldRegistrySchema.safeParse(multiEntry)