@timeax/scaffold 0.0.10 → 0.0.12

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@timeax/scaffold",
   "private": false,
-  "version": "0.0.10",
+  "version": "0.0.12",
   "description": "A CLI tool that scaffolds project file structures based on a user-defined, type-safe configuration file.",
   "keywords": [
     "scaffold"

package/src/core/apply-structure.ts

@@ -1,255 +1,306 @@
-// src/core/apply-structure.ts
-
-import fs from 'fs';
-import path from 'path';
-import type {
-   ScaffoldConfig,
-   StructureEntry,
-   FileEntry,
-   DirEntry,
-   HookContext,
-} from '../schema';
-import { CacheManager } from './cache-manager';
-import { HookRunner } from './hook-runner';
-import {
-   ensureDirSync,
-   statSafeSync,
-   toProjectRelativePath,
-   toPosixPath,
-} from '../util/fs-utils';
-import type { Logger } from '../util/logger';
-import { defaultLogger } from '../util/logger';
-
-export interface InteractiveDeleteParams {
-   absolutePath: string;
-   relativePath: string; // project-root relative, POSIX
-   size: number;
-   createdByStub?: string;
-   groupName?: string;
-}
-
-export interface ApplyOptions {
-   config: ScaffoldConfig;
-
-   /**
-    * Global project root for this run.
-    */
-   projectRoot: string;
-
-   /**
-    * Absolute directory where this structure group should be applied.
-    * For grouped mode, this is projectRoot + group.root.
-    * For single mode, this will simply be projectRoot.
-    */
-   baseDir: string;
-
-   /**
-    * Which structure entries to apply (already resolved from txt or inline).
-    */
-   structure: StructureEntry[];
-
-   cache: CacheManager;
-   hooks: HookRunner;
-
-   /**
-    * Optional group metadata (only set for groups).
-    */
-   groupName?: string;
-   groupRoot?: string;
-
-   /**
-    * Optional override for deletion threshold.
-    * Falls back to config.sizePromptThreshold or internal default.
-    */
-   sizePromptThreshold?: number;
-
-   /**
-    * Optional interactive delete callback.
-    * Should ask the user and return 'delete' or 'keep'.
-    */
-   interactiveDelete?: (
-      params: InteractiveDeleteParams,
-   ) => Promise<'delete' | 'keep'>;
-
-   /**
-    * Optional logger; defaults to defaultLogger.child('[apply]').
-    */
-   logger?: Logger;
-}
-
-export async function applyStructure(opts: ApplyOptions): Promise<void> {
-   const {
-      config,
-      projectRoot,
-      baseDir,
-      structure,
-      cache,
-      hooks,
-      groupName,
-      groupRoot,
-      sizePromptThreshold,
-      interactiveDelete,
-   } = opts;
-
-   const logger =
-      opts.logger ?? defaultLogger.child(groupName ? `[apply:${groupName}]` : '[apply]');
-
-   const desiredPaths = new Set<string>(); // project-root relative, POSIX
-
-   const threshold = sizePromptThreshold ?? config.sizePromptThreshold ?? 128 * 1024;
-
-   async function walk(entry: StructureEntry, inheritedStub?: string): Promise<void> {
-      const effectiveStub = entry.stub ?? inheritedStub;
-      if (entry.type === 'dir') {
-         await handleDir(entry as DirEntry, effectiveStub);
-      } else {
-         await handleFile(entry as FileEntry, effectiveStub);
-      }
-   }
-
-   async function handleDir(entry: DirEntry, inheritedStub?: string): Promise<void> {
-      const relFromBase = entry.path.replace(/^[./]+/, '');
-      const absDir = path.resolve(baseDir, relFromBase);
-      const relFromRoot = toPosixPath(
-         toProjectRelativePath(projectRoot, absDir),
-      );
-
-      desiredPaths.add(relFromRoot);
-
-      ensureDirSync(absDir);
-
-      const nextStub = entry.stub ?? inheritedStub;
-
-      if (entry.children) {
-         for (const child of entry.children) {
-            // eslint-disable-next-line no-await-in-loop
-            await walk(child, nextStub);
-         }
-      }
-   }
-
-   async function handleFile(entry: FileEntry, inheritedStub?: string): Promise<void> {
-      const relFromBase = entry.path.replace(/^[./]+/, '');
-      const absFile = path.resolve(baseDir, relFromBase);
-      const relFromRoot = toPosixPath(
-         toProjectRelativePath(projectRoot, absFile),
-      );
-
-      desiredPaths.add(relFromRoot);
-
-      const stubName = entry.stub ?? inheritedStub;
-
-      const ctx: HookContext = {
-         projectRoot,
-         targetPath: relFromRoot,
-         absolutePath: absFile,
-         isDirectory: false,
-         stubName,
-      };
-
-      // If file already exists, do not overwrite; just ensure hooks
-      if (fs.existsSync(absFile)) {
-         return;
-      }
-
-      await hooks.runRegular('preCreateFile', ctx);
-
-      const dir = path.dirname(absFile);
-      ensureDirSync(dir);
-
-      if (stubName) {
-         await hooks.runStub('preStub', ctx);
-      }
-
-      let content = '';
-      const stubContent = await hooks.renderStubContent(ctx);
-      if (typeof stubContent === 'string') {
-         content = stubContent;
-      }
-
-      fs.writeFileSync(absFile, content, 'utf8');
-      const stats = fs.statSync(absFile);
-
-      cache.set({
-         path: relFromRoot,
-         createdAt: new Date().toISOString(),
-         sizeAtCreate: stats.size,
-         createdByStub: stubName,
-         groupName,
-         groupRoot,
-      });
-
-      logger.info(`created ${relFromRoot}`);
-
-      if (stubName) {
-         await hooks.runStub('postStub', ctx);
-      }
-
-      await hooks.runRegular('postCreateFile', ctx);
-   }
-
-   // 1) Create/update from structure
-   for (const entry of structure) {
-      // eslint-disable-next-line no-await-in-loop
-      await walk(entry);
-   }
-
-   // 2) Handle deletions: any cached path not in desiredPaths
-   for (const cachedPath of cache.allPaths()) {
-      if (desiredPaths.has(cachedPath)) continue;
-
-      const abs = path.resolve(projectRoot, cachedPath);
-      const stats = statSafeSync(abs);
-
-      if (!stats) {
-         cache.delete(cachedPath);
-         continue;
-      }
-
-      // Only handle files here; dirs are not tracked in cache.
-      if (!stats.isFile()) {
-         cache.delete(cachedPath);
-         continue;
-      }
-
-      const entry = cache.get(cachedPath);
-      const ctx: HookContext = {
-         projectRoot,
-         targetPath: cachedPath,
-         absolutePath: abs,
-         isDirectory: false,
-         stubName: entry?.createdByStub,
-      };
-
-      await hooks.runRegular('preDeleteFile', ctx);
-
-      let shouldDelete = true;
-      if (stats.size > threshold && interactiveDelete) {
-         const res = await interactiveDelete({
-            absolutePath: abs,
-            relativePath: cachedPath,
-            size: stats.size,
-            createdByStub: entry?.createdByStub,
-            groupName: entry?.groupName,
-         });
-
-         if (res === 'keep') {
-            shouldDelete = false;
-            cache.delete(cachedPath); // user takes ownership
-            logger.info(`keeping ${cachedPath} (removed from cache)`);
-         }
-      }
-
-      if (shouldDelete) {
-         try {
-            fs.unlinkSync(abs);
-            logger.info(`deleted ${cachedPath}`);
-         } catch (err) {
-            logger.warn(`failed to delete ${cachedPath}`, err);
-         }
-
-         cache.delete(cachedPath);
-         await hooks.runRegular('postDeleteFile', ctx);
-      }
-   }
-}
+// src/core/apply-structure.ts
+
+import fs from "fs";
+import path from "path";
+import type {
+  ScaffoldConfig,
+  StructureEntry,
+  FileEntry,
+  DirEntry,
+  HookContext,
+} from "../schema";
+import { CacheManager } from "./cache-manager";
+import { HookRunner } from "./hook-runner";
+import {
+  ensureDirSync,
+  statSafeSync,
+  toProjectRelativePath,
+  toPosixPath,
+} from "../util/fs-utils";
+import type { Logger } from "../util/logger";
+import { defaultLogger } from "../util/logger";
+
+export interface InteractiveDeleteParams {
+  absolutePath: string;
+  relativePath: string; // project-root relative, POSIX
+  size: number;
+  createdByStub?: string;
+  groupName?: string;
+}
+
+export interface ApplyOptions {
+  config: ScaffoldConfig;
+
+  /**
+   * Global project root for this run (absolute or relative to CWD).
+   */
+  projectRoot: string;
+
+  /**
+   * Absolute directory where this structure group should be applied.
+   * For grouped mode, this is projectRoot + group.root.
+   * For single mode, this will simply be projectRoot.
+   */
+  baseDir: string;
+
+  /**
+   * Which structure entries to apply (already resolved from txt or inline).
+   */
+  structure: StructureEntry[];
+
+  cache: CacheManager;
+  hooks: HookRunner;
+
+  /**
+   * Optional group metadata (only set for groups).
+   */
+  groupName?: string;
+  groupRoot?: string;
+
+  /**
+   * Optional override for deletion threshold.
+   * Falls back to config.sizePromptThreshold or internal default.
+   */
+  sizePromptThreshold?: number;
+
+  /**
+   * Optional interactive delete callback.
+   * Should ask the user and return 'delete' or 'keep'.
+   */
+  interactiveDelete?: (
+    params: InteractiveDeleteParams,
+  ) => Promise<"delete" | "keep">;
+
+  /**
+   * Optional logger; defaults to defaultLogger.child('[apply]').
+   */
+  logger?: Logger;
+}
+
+export async function applyStructure(opts: ApplyOptions): Promise<void> {
+  const {
+    config,
+    projectRoot,
+    baseDir,
+    structure,
+    cache,
+    hooks,
+    groupName,
+    groupRoot,
+    sizePromptThreshold,
+    interactiveDelete,
+  } = opts;
+
+  const logger =
+    opts.logger ??
+    defaultLogger.child(groupName ? `[apply:${groupName}]` : "[apply]");
+
+  // Normalize roots to absolute, consistent paths
+  const projectRootAbs = path.resolve(projectRoot);
+  const baseDirAbs = path.resolve(baseDir);
+
+  // Helper for “is this absolute path inside this baseDir?”
+  const baseDirAbsWithSep = baseDirAbs.endsWith(path.sep)
+    ? baseDirAbs
+    : baseDirAbs + path.sep;
+
+  function isUnderBaseDir(absPath: string): boolean {
+    const norm = path.resolve(absPath);
+    return norm === baseDirAbs || norm.startsWith(baseDirAbsWithSep);
+  }
+
+  const desiredPaths = new Set<string>(); // project-root relative, POSIX
+
+  const threshold =
+    sizePromptThreshold ?? config.sizePromptThreshold ?? 128 * 1024;
+
+  async function walk(
+    entry: StructureEntry,
+    inheritedStub?: string,
+  ): Promise<void> {
+    const effectiveStub = entry.stub ?? inheritedStub;
+    if (entry.type === "dir") {
+      await handleDir(entry as DirEntry, effectiveStub);
+    } else {
+      await handleFile(entry as FileEntry, effectiveStub);
+    }
+  }
+
+  async function handleDir(
+    entry: DirEntry,
+    inheritedStub?: string,
+  ): Promise<void> {
+    const relFromBase = entry.path.replace(/^[./]+/, "");
+    const absDir = path.resolve(baseDirAbs, relFromBase);
+    const relFromRoot = toPosixPath(
+      toProjectRelativePath(projectRootAbs, absDir),
+    );
+
+    desiredPaths.add(relFromRoot);
+
+    ensureDirSync(absDir);
+
+    const nextStub = entry.stub ?? inheritedStub;
+
+    if (entry.children) {
+      for (const child of entry.children) {
+        // eslint-disable-next-line no-await-in-loop
+        await walk(child, nextStub);
+      }
+    }
+  }
+
+  async function handleFile(
+    entry: FileEntry,
+    inheritedStub?: string,
+  ): Promise<void> {
+    const relFromBase = entry.path.replace(/^[./]+/, "");
+    const absFile = path.resolve(baseDirAbs, relFromBase);
+    const relFromRoot = toPosixPath(
+      toProjectRelativePath(projectRootAbs, absFile),
+    );
+
+    desiredPaths.add(relFromRoot);
+
+    const stubName = entry.stub ?? inheritedStub;
+
+    const ctx: HookContext = {
+      projectRoot: projectRootAbs,
+      targetPath: relFromRoot,
+      absolutePath: absFile,
+      isDirectory: false,
+      stubName,
+    };
+
+    // If file already exists, do not overwrite; just ensure hooks (later we might
+    // add an "onExistingFile" hook, but right now we simply skip creation).
+    if (fs.existsSync(absFile)) {
+      return;
+    }
+
+    await hooks.runRegular("preCreateFile", ctx);
+
+    const dir = path.dirname(absFile);
+    ensureDirSync(dir);
+
+    if (stubName) {
+      await hooks.runStub("preStub", ctx);
+    }
+
+    let content = "";
+    const stubContent = await hooks.renderStubContent(ctx);
+    if (typeof stubContent === "string") {
+      content = stubContent;
+    }
+
+    fs.writeFileSync(absFile, content, "utf8");
+    const stats = fs.statSync(absFile);
+
+    cache.set({
+      path: relFromRoot,
+      createdAt: new Date().toISOString(),
+      sizeAtCreate: stats.size,
+      createdByStub: stubName,
+      groupName,
+      groupRoot,
+    });
+
+    logger.info(`created ${relFromRoot}`);
+
+    if (stubName) {
+      await hooks.runStub("postStub", ctx);
+    }
+
+    await hooks.runRegular("postCreateFile", ctx);
+  }
+
+  // 1) Create/update from structure
+  for (const entry of structure) {
+    // eslint-disable-next-line no-await-in-loop
+    await walk(entry);
+  }
+
+  // 2) Handle deletions: any cached path not in desiredPaths
+  //
+  // IMPORTANT:
+  // We *only* consider cached files that live under this run's baseDir.
+  // This prevents group A from deleting files owned by group B when
+  // applyStructure is called multiple times with different baseDir values.
+  // 2) Handle deletions: any cached path not in desiredPaths
+  for (const cachedPath of cache.allPaths()) {
+    const entry = cache.get(cachedPath);
+
+    // Group-aware deletion:
+    // - If we're in a group, only touch entries for this group.
+    // - If we're in single-root mode (no groupName), only touch entries
+    //   that also have no groupName (legacy / single-structure runs).
+    if (groupName) {
+      if (!entry || entry.groupName !== groupName) {
+        continue;
+      }
+    } else {
+      if (entry && entry.groupName) {
+        continue;
+      }
+    }
+
+    // If this path is still desired within this group, skip it.
+    if (desiredPaths.has(cachedPath)) {
+      continue;
+    }
+
+    const abs = path.resolve(projectRoot, cachedPath);
+    const stats = statSafeSync(abs);
+
+    if (!stats) {
+      // File disappeared on disk – just clean cache.
+      cache.delete(cachedPath);
+      continue;
+    }
+
+    // Only handle files here; dirs are not tracked in cache.
+    if (!stats.isFile()) {
+      cache.delete(cachedPath);
+      continue;
+    }
+
+    const ctx: HookContext = {
+      projectRoot,
+      targetPath: cachedPath,
+      absolutePath: abs,
+      isDirectory: false,
+      stubName: entry?.createdByStub,
+    };
+
+    await hooks.runRegular("preDeleteFile", ctx);
+
+    let shouldDelete = true;
+    if (stats.size > threshold && interactiveDelete) {
+      const res = await interactiveDelete({
+        absolutePath: abs,
+        relativePath: cachedPath,
+        size: stats.size,
+        createdByStub: entry?.createdByStub,
+        groupName: entry?.groupName,
+      });
+
+      if (res === "keep") {
+        shouldDelete = false;
+        cache.delete(cachedPath); // user takes ownership
+        logger.info(`keeping ${cachedPath} (removed from cache)`);
+      }
+    }
+
+    if (shouldDelete) {
+      try {
+        fs.unlinkSync(abs);
+        logger.info(`deleted ${cachedPath}`);
+      } catch (err) {
+        logger.warn(`failed to delete ${cachedPath}`, err);
+      }
+
+      cache.delete(cachedPath);
+      await hooks.runRegular("postDeleteFile", ctx);
+    }
+  }
+}

package/src/core/watcher.ts

@@ -2,9 +2,9 @@
 
 import path from 'path';
 import chokidar from 'chokidar';
-import {runOnce, type RunOptions} from './runner';
-import {defaultLogger, type Logger} from '../util/logger';
-import {SCAFFOLD_ROOT_DIR} from '..';
+import { runOnce, type RunOptions } from './runner';
+import { defaultLogger, type Logger } from '../util/logger';
+import { SCAFFOLD_ROOT_DIR } from '..';
 
 export interface WatchOptions extends RunOptions {
     /**
@@ -24,11 +24,11 @@ export interface WatchOptions extends RunOptions {
 /**
  * Watch the scaffold directory and re-run scaffold on changes.
  *
- * This watches:
- * - .scaffold/config.* files
- * - .scaffold/*.txt / *.tss / *.stx files (structures)
+ * This watches the entire .scaffold folder and then filters events
+ * in-process to:
+ *   - config.* files
+ *   - *.txt / *.tss / *.stx
  *
- * CLI can call this when `--watch` is enabled.
  * Any `format` options in RunOptions are passed straight through to `runOnce`,
  * so formatting from config / CLI is applied on each re-run.
  */
@@ -60,7 +60,7 @@ export function watchScaffold(cwd: string, options: WatchOptions = {}): void {
                 // we already resolved scaffoldDir for watcher; pass it down
                 scaffoldDir,
             });
-            logger.info('Scaffold run completed.');
+            logger.info('Scaffold run completed');
         } catch (err) {
             logger.error('Scaffold run failed:', err);
         } finally {
@@ -77,32 +77,29 @@ export function watchScaffold(cwd: string, options: WatchOptions = {}): void {
         timer = setTimeout(run, debounceMs);
     }
 
-    const watcher = chokidar.watch(
-        [
-            // config files (ts/js/etc.)
-            path.join(scaffoldDir, 'config.*'),
-
-            // structure files: plain txt + our custom extensions
-            path.join(scaffoldDir, '*.txt'),
-            path.join(scaffoldDir, '*.tss'),
-            path.join(scaffoldDir, '*.stx'),
-        ],
-        {
-            ignoreInitial: false,
-        },
-    );
+    // Only react to config.* and structure files inside scaffoldDir
+    function isInteresting(filePath: string): boolean {
+        const rel = path.relative(scaffoldDir, filePath);
+        // Outside .scaffold or in parent → ignore
+        if (rel.startsWith('..')) return false;
+
+        const base = path.basename(filePath).toLowerCase();
+        // config.ts / config.js / config.mts / etc.
+        if (base.startsWith('config.')) return true;
+
+        const ext = path.extname(base);
+        return ext === '.txt' || ext === '.tss' || ext === '.stx';
+    }
+
+    const watcher = chokidar.watch(scaffoldDir, {
+        ignoreInitial: false,
+        persistent: true,
+    });
 
     watcher
-        .on('add', (filePath) => {
-            logger.debug(`File added: ${filePath}`);
-            scheduleRun();
-        })
-        .on('change', (filePath) => {
-            logger.debug(`File changed: ${filePath}`);
-            scheduleRun();
-        })
-        .on('unlink', (filePath) => {
-            logger.debug(`File removed: ${filePath}`);
+        .on('all', (event, filePath) => {
+            if (!isInteresting(filePath)) return;
+            logger.debug(`Event ${event} on ${filePath}`);
             scheduleRun();
         })
         .on('error', (error) => {