@open-mercato/cli 0.6.8-develop.6898.1.8b42ed5e41 → 0.6.8-develop.6903.1.0ec850a22b

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-mercato/cli",
-  "version": "0.6.8-develop.6898.1.8b42ed5e41",
+  "version": "0.6.8-develop.6903.1.0ec850a22b",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",
@@ -60,9 +60,9 @@
     "@mikro-orm/decorators": "^7.1.8",
     "@mikro-orm/migrations": "^7.1.8",
     "@mikro-orm/postgresql": "^7.1.8",
-    "@open-mercato/queue": "0.6.8-develop.6898.1.8b42ed5e41",
-    "@open-mercato/shared": "0.6.8-develop.6898.1.8b42ed5e41",
-    "@open-mercato/telemetry": "0.6.8-develop.6898.1.8b42ed5e41",
+    "@open-mercato/queue": "0.6.8-develop.6903.1.0ec850a22b",
+    "@open-mercato/shared": "0.6.8-develop.6903.1.0ec850a22b",
+    "@open-mercato/telemetry": "0.6.8-develop.6903.1.0ec850a22b",
     "cross-spawn": "^7.0.6",
     "pg": "8.22.0",
     "semver": "^7.8.5",
@@ -73,10 +73,10 @@
     "typescript-js": "npm:typescript@6.0.3"
   },
   "peerDependencies": {
-    "@open-mercato/shared": "0.6.8-develop.6898.1.8b42ed5e41"
+    "@open-mercato/shared": "0.6.8-develop.6903.1.0ec850a22b"
   },
   "devDependencies": {
-    "@open-mercato/shared": "0.6.8-develop.6898.1.8b42ed5e41",
+    "@open-mercato/shared": "0.6.8-develop.6903.1.0ec850a22b",
     "@types/jest": "^30.0.0",
     "jest": "^30.4.2",
     "ts-jest": "^29.4.12"

package/src/lib/__tests__/generate-watch-events.test.ts

@@ -1,3 +1,5 @@
+import fs from 'node:fs'
+import os from 'node:os'
 import path from 'node:path'
 import {
   createGenerateWatchChangeSignal,
@@ -26,6 +28,7 @@ function createWatchHarness(initialTargets: GenerateWatchTarget[]) {
   const signal = createGenerateWatchChangeSignal({
     getWatchTargets: () => targets,
     watchDirectory,
+    directoryExists: () => true,
   })
 
   return {
@@ -37,6 +40,78 @@ function createWatchHarness(initialTargets: GenerateWatchTarget[]) {
 }
 
 describe('createGenerateWatchChangeSignal', () => {
+  it('skips missing directories without falling back and retries them on refresh', async () => {
+    const present = path.resolve('./modules-present')
+    const delayed = path.resolve('./modules-delayed')
+    const existing = new Set([present])
+    const registered: GenerateWatchTarget[] = []
+    const signal = createGenerateWatchChangeSignal({
+      getWatchTargets: () => [
+        { directory: present, recursive: true },
+        { directory: delayed, recursive: true },
+      ],
+      directoryExists: (directory) => existing.has(directory),
+      watchDirectory: (target) => {
+        registered.push(target)
+        return { close: jest.fn() }
+      },
+    })
+
+    await signal.refresh()
+    expect(registered.map((target) => target.directory)).toEqual([present])
+    expect(signal.hasSkippedTargets?.()).toBe(true)
+    expect(signal.usesPollingFallback()).toBe(false)
+
+    existing.add(delayed)
+    await signal.refresh()
+    expect(registered.map((target) => target.directory)).toEqual([present, delayed])
+    expect(signal.hasSkippedTargets?.()).toBe(false)
+    expect(signal.usesPollingFallback()).toBe(false)
+  })
+
+  it('reports a missing directory once while it remains skipped', async () => {
+    const missing = path.resolve('./modules-missing')
+    const onSkippedDirectory = jest.fn()
+    const options = {
+      getWatchTargets: () => [{ directory: missing, recursive: true }],
+      directoryExists: () => false,
+      watchDirectory: jest.fn(() => ({ close: jest.fn() })),
+      onSkippedDirectory,
+    }
+    const signal = createGenerateWatchChangeSignal(options)
+
+    await signal.refresh()
+    await signal.refresh()
+
+    expect(onSkippedDirectory).toHaveBeenCalledTimes(1)
+    expect(onSkippedDirectory).toHaveBeenCalledWith(missing)
+  })
+
+  it('uses filesystem existence checks by default', async () => {
+    const present = fs.mkdtempSync(path.join(os.tmpdir(), 'mercato-generate-watch-'))
+    const missing = path.join(present, 'missing')
+    const registered: string[] = []
+    const signal = createGenerateWatchChangeSignal({
+      getWatchTargets: () => [
+        { directory: present, recursive: true },
+        { directory: missing, recursive: true },
+      ],
+      watchDirectory: (target) => {
+        registered.push(target.directory)
+        return { close: jest.fn() }
+      },
+    })
+
+    try {
+      await signal.refresh()
+      expect(registered).toEqual([present])
+      expect(signal.usesPollingFallback()).toBe(false)
+    } finally {
+      await signal.close()
+      fs.rmSync(present, { recursive: true, force: true })
+    }
+  })
+
   it('deduplicates targets and increments its version on filesystem events', async () => {
     const target = { directory: './modules', recursive: true }
     const { signal, registered, watchDirectory } = createWatchHarness([target, target])
@@ -80,6 +155,7 @@ describe('createGenerateWatchChangeSignal', () => {
         { directory: './modules-b', recursive: true },
       ],
       watchDirectory,
+      directoryExists: () => true,
     })
 
     await signal.refresh()

package/src/lib/__tests__/in-process-generate-watcher.test.ts

@@ -14,15 +14,26 @@ async function flushAsync(times = 5): Promise<void> {
 function createFakeChangeSignal() {
   let version = 0
   let fallback = false
+  let skippedTargets = false
+  let discoverSkippedTargets = false
+  const refresh = jest.fn(async () => {
+    if (discoverSkippedTargets) {
+      skippedTargets = false
+      discoverSkippedTargets = false
+    }
+  })
   const signal: GenerateWatcherChangeSignal = {
     currentVersion: () => version,
-    refresh: jest.fn(async () => undefined),
+    refresh,
     usesPollingFallback: () => fallback,
+    hasSkippedTargets: () => skippedTargets,
     close: jest.fn(async () => undefined),
   }
   return {
     signal,
     markChanged: () => { version += 1 },
+    markSkippedTarget: () => { skippedTargets = true },
+    discoverSkippedTargetOnNextRefresh: () => { discoverSkippedTargets = true },
     usePollingFallback: () => { fallback = true },
   }
 }
@@ -142,6 +153,46 @@ describe('startInProcessGenerateWatcher', () => {
     await handle.close()
   })
 
+  it('discovers skipped roots during event-gated idle polling', async () => {
+    const runGenerators = jest.fn(async () => undefined)
+    const computeStructureChecksum = jest.fn()
+      .mockResolvedValueOnce('before')
+      .mockResolvedValue('after')
+    const {
+      signal,
+      markSkippedTarget,
+      discoverSkippedTargetOnNextRefresh,
+    } = createFakeChangeSignal()
+    markSkippedTarget()
+    const handle = startInProcessGenerateWatcher({
+      pollMs: 1000,
+      skipInitial: true,
+      quiet: true,
+      logger: silentLogger,
+      changeSignal: signal,
+      computeStructureChecksum,
+      runGenerators,
+    })
+
+    await flushAsync(8)
+    expect(computeStructureChecksum).toHaveBeenCalledTimes(1)
+
+    jest.advanceTimersByTime(1000)
+    await flushAsync(12)
+
+    expect(signal.refresh).toHaveBeenCalledTimes(2)
+    expect(computeStructureChecksum).toHaveBeenCalledTimes(1)
+    discoverSkippedTargetOnNextRefresh()
+
+    jest.advanceTimersByTime(1000)
+    await flushAsync(12)
+
+    expect(signal.refresh).toHaveBeenCalledTimes(3)
+    expect(computeStructureChecksum).toHaveBeenCalledTimes(2)
+    expect(runGenerators).toHaveBeenCalledWith('structure change')
+    await handle.close()
+  })
+
   it('coalesces filesystem event bursts into one checksum and regeneration', async () => {
     let currentChecksum = 'before'
     const runGenerators = jest.fn(async () => undefined)

package/src/lib/generate-watch-events.ts

@@ -21,6 +21,8 @@ type WatchDirectory = (
 export type GenerateWatchChangeSignalOptions = {
   getWatchTargets: () => Promise<GenerateWatchTarget[]> | GenerateWatchTarget[]
   watchDirectory?: WatchDirectory
+  directoryExists?: (directory: string) => boolean
+  onSkippedDirectory?: (directory: string) => void
 }
 
 function targetKey(target: GenerateWatchTarget): string {
@@ -49,7 +51,9 @@ export function createGenerateWatchChangeSignal(
   options: GenerateWatchChangeSignalOptions,
 ): GenerateWatcherChangeSignal {
   const watchDirectory = options.watchDirectory ?? defaultWatchDirectory
+  const directoryExists = options.directoryExists ?? fs.existsSync
   const watchers = new Map<string, WatchHandle>()
+  let skippedDirectories = new Set<string>()
   let version = 0
   let pollingFallback = false
   let closed = false
@@ -70,6 +74,7 @@ export function createGenerateWatchChangeSignal(
 
   return {
     currentVersion: () => version,
+    hasSkippedTargets: () => skippedDirectories.size > 0,
     usesPollingFallback: () => pollingFallback,
     refresh: async () => {
       if (closed || pollingFallback) return
@@ -83,13 +88,22 @@ export function createGenerateWatchChangeSignal(
       }
 
       const normalizedTargets = new Map<string, GenerateWatchTarget>()
+      const nextSkippedDirectories = new Set<string>()
       for (const target of targets) {
         const normalized: GenerateWatchTarget = {
           ...target,
           directory: path.resolve(target.directory),
         }
+        if (!directoryExists(normalized.directory)) {
+          nextSkippedDirectories.add(normalized.directory)
+          if (!skippedDirectories.has(normalized.directory)) {
+            try { options.onSkippedDirectory?.(normalized.directory) } catch {}
+          }
+          continue
+        }
         normalizedTargets.set(targetKey(normalized), normalized)
       }
+      skippedDirectories = nextSkippedDirectories
 
       for (const [key, watcher] of watchers) {
         if (normalizedTargets.has(key)) continue

package/src/lib/in-process-generate-watcher.ts

@@ -24,6 +24,8 @@ export type GenerateWatcherChangeSignal = {
   currentVersion(): number
   /** Refresh filesystem subscriptions after module configuration changes. */
   refresh(): Promise<void> | void
+  /** Whether configured roots are missing and should be retried on idle polls. */
+  hasSkippedTargets?(): boolean
   /** When true, preserve the legacy full-checksum-on-every-poll behavior. */
   usesPollingFallback(): boolean
   /** Close filesystem subscriptions. Idempotent. */
@@ -130,16 +132,23 @@ export function startInProcessGenerateWatcher(
         if (stopping) return
         try {
           const changeVersion = changeSignal?.currentVersion() ?? 0
-          if (
+          const eventGatedIdle = Boolean(
             changeSignal
             && !changeSignal.usesPollingFallback()
             && changeVersion === observedChangeVersion
-          ) {
-            return
+          )
+          let refreshedSkippedTargets = false
+          if (eventGatedIdle) {
+            if (!changeSignal?.hasSkippedTargets?.()) return
+            await changeSignal.refresh()
+            refreshedSkippedTargets = true
+            if (changeSignal.hasSkippedTargets?.()) return
           }
           const nextChecksum = await computeStructureChecksum()
           observedChangeVersion = changeVersion
-          await changeSignal?.refresh()
+          if (!refreshedSkippedTargets) {
+            await changeSignal?.refresh()
+          }
           if (nextChecksum !== previousChecksum) {
             previousChecksum = nextChecksum
             await runOnce('structure change')

package/src/mercato.ts

@@ -794,7 +794,7 @@ async function runGeneratorSuiteWithStructuralInvalidation(quiet: boolean): Prom
  * watchers. Filesystem events mark the tree dirty; the existing full content
  * checksum remains the final authority and the fallback when watching fails.
  */
-async function createGenerateWatchRuntime() {
+async function createGenerateWatchRuntime(quiet = false) {
   const [
     { createResolver },
     { calculateGenerateWatchStructureChecksum },
@@ -825,6 +825,9 @@ async function createGenerateWatchRuntime() {
       return calculateGenerateWatchStructureChecksum(collectWatchState())
     },
     changeSignal: createGenerateWatchChangeSignal({
+      onSkippedDirectory: quiet
+        ? undefined
+        : (directory) => console.log(`[generate:watch] Skipping missing watch directory: ${directory}`),
       getWatchTargets: () => {
         const state = collectWatchState()
         const targets: Array<{ directory: string; recursive: boolean; fileName?: string }> = [{
@@ -1864,7 +1867,7 @@ export async function run(argv = process.argv) {
           const parsedInterval = intervalArg ? Number.parseInt(intervalArg.split('=')[1] ?? '', 10) : NaN
           const intervalMs = Number.isFinite(parsedInterval) && parsedInterval >= 250 ? parsedInterval : 1000
 
-          const generateWatchRuntime = await createGenerateWatchRuntime()
+          const generateWatchRuntime = await createGenerateWatchRuntime(quiet)
           const watcher = startInProcessGenerateWatcher({
             pollMs: intervalMs,
             skipInitial,