@timeax/scaffold 0.0.2 → 0.0.4

package/dist/cli.cjs

@@ -1,1141 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-var readline = require('readline');
-var path2 = require('path');
-var fs7 = require('fs');
-var commander = require('commander');
-var os = require('os');
-var crypto = require('crypto');
-var url = require('url');
-var esbuild = require('esbuild');
-var minimatch = require('minimatch');
-var chokidar = require('chokidar');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var readline__default = /*#__PURE__*/_interopDefault(readline);
-var path2__default = /*#__PURE__*/_interopDefault(path2);
-var fs7__default = /*#__PURE__*/_interopDefault(fs7);
-var os__default = /*#__PURE__*/_interopDefault(os);
-var crypto__default = /*#__PURE__*/_interopDefault(crypto);
-var chokidar__default = /*#__PURE__*/_interopDefault(chokidar);
-
-// src/util/logger.ts
-var supportsColor = typeof process !== "undefined" && process.stdout && process.stdout.isTTY && process.env.NO_COLOR !== "1";
-function wrap(code) {
-  const open = `\x1B[${code}m`;
-  const close = `\x1B[0m`;
-  return (text) => supportsColor ? `${open}${text}${close}` : text;
-}
-var color = {
-  red: wrap(31),
-  yellow: wrap(33),
-  green: wrap(32),
-  cyan: wrap(36),
-  magenta: wrap(35),
-  dim: wrap(2),
-  bold: wrap(1),
-  gray: wrap(90)
-};
-function colorForLevel(level) {
-  switch (level) {
-    case "error":
-      return color.red;
-    case "warn":
-      return color.yellow;
-    case "info":
-      return color.cyan;
-    case "debug":
-      return color.gray;
-    default:
-      return (s) => s;
-  }
-}
-var Logger = class _Logger {
-  level;
-  prefix;
-  constructor(options = {}) {
-    this.level = options.level ?? "info";
-    this.prefix = options.prefix;
-  }
-  setLevel(level) {
-    this.level = level;
-  }
-  getLevel() {
-    return this.level;
-  }
-  /**
-   * Create a child logger with an additional prefix.
-   */
-  child(prefix) {
-    const combined = this.prefix ? `${this.prefix}${prefix}` : prefix;
-    return new _Logger({ level: this.level, prefix: combined });
-  }
-  formatMessage(msg, lvl) {
-    const text = typeof msg === "string" ? msg : msg instanceof Error ? msg.message : String(msg);
-    const levelColor = colorForLevel(lvl);
-    const prefixColored = this.prefix ? color.magenta(this.prefix) : void 0;
-    const textColored = lvl === "debug" ? color.dim(text) : levelColor(text);
-    if (prefixColored) {
-      return `${prefixColored} ${textColored}`;
-    }
-    return textColored;
-  }
-  shouldLog(targetLevel) {
-    const order = ["silent", "error", "warn", "info", "debug"];
-    const currentIdx = order.indexOf(this.level);
-    const targetIdx = order.indexOf(targetLevel);
-    if (currentIdx === -1 || targetIdx === -1) return true;
-    if (this.level === "silent") return false;
-    return targetIdx <= currentIdx || targetLevel === "error";
-  }
-  error(msg, ...rest) {
-    if (!this.shouldLog("error")) return;
-    console.error(this.formatMessage(msg, "error"), ...rest);
-  }
-  warn(msg, ...rest) {
-    if (!this.shouldLog("warn")) return;
-    console.warn(this.formatMessage(msg, "warn"), ...rest);
-  }
-  info(msg, ...rest) {
-    if (!this.shouldLog("info")) return;
-    console.log(this.formatMessage(msg, "info"), ...rest);
-  }
-  debug(msg, ...rest) {
-    if (!this.shouldLog("debug")) return;
-    console.debug(this.formatMessage(msg, "debug"), ...rest);
-  }
-};
-var defaultLogger = new Logger({
-  level: process.env.SCAFFOLD_LOG_LEVEL ?? "info",
-  prefix: "[scaffold]"
-});
-function toPosixPath(p) {
-  return p.replace(/\\/g, "/");
-}
-function ensureDirSync(dirPath) {
-  if (!fs7__default.default.existsSync(dirPath)) {
-    fs7__default.default.mkdirSync(dirPath, { recursive: true });
-  }
-  return dirPath;
-}
-function statSafeSync(targetPath) {
-  try {
-    return fs7__default.default.statSync(targetPath);
-  } catch {
-    return null;
-  }
-}
-function toProjectRelativePath(projectRoot, absolutePath) {
-  const absRoot = path2__default.default.resolve(projectRoot);
-  const absTarget = path2__default.default.resolve(absolutePath);
-  const rootWithSep = absRoot.endsWith(path2__default.default.sep) ? absRoot : absRoot + path2__default.default.sep;
-  if (!absTarget.startsWith(rootWithSep) && absTarget !== absRoot) {
-    throw new Error(
-      `Path "${absTarget}" is not inside project root "${absRoot}".`
-    );
-  }
-  const rel = path2__default.default.relative(absRoot, absTarget);
-  return toPosixPath(rel);
-}
-
-// src/core/config-loader.ts
-var logger = defaultLogger.child("[config]");
-async function loadScaffoldConfig(cwd, options = {}) {
-  const absCwd = path2__default.default.resolve(cwd);
-  const initialScaffoldDir = options.scaffoldDir ? path2__default.default.resolve(absCwd, options.scaffoldDir) : path2__default.default.join(absCwd, "scaffold");
-  const configPath = options.configPath ?? resolveConfigPath(initialScaffoldDir);
-  const config = await importConfig(configPath);
-  let configRoot = absCwd;
-  if (config.root) {
-    configRoot = path2__default.default.resolve(absCwd, config.root);
-  }
-  const scaffoldDir = options.scaffoldDir ? path2__default.default.resolve(absCwd, options.scaffoldDir) : path2__default.default.join(configRoot, "scaffold");
-  const baseRoot = config.base ? path2__default.default.resolve(configRoot, config.base) : configRoot;
-  logger.debug(
-    `Loaded config: configRoot=${configRoot}, baseRoot=${baseRoot}, scaffoldDir=${scaffoldDir}`
-  );
-  return {
-    config,
-    scaffoldDir,
-    projectRoot: baseRoot
-  };
-}
-function resolveConfigPath(scaffoldDir) {
-  const candidates = [
-    "config.ts",
-    "config.mts",
-    "config.mjs",
-    "config.js",
-    "config.cjs"
-  ];
-  for (const file of candidates) {
-    const full = path2__default.default.join(scaffoldDir, file);
-    if (fs7__default.default.existsSync(full)) {
-      return full;
-    }
-  }
-  throw new Error(
-    `Could not find scaffold config in ${scaffoldDir}. Looked for: ${candidates.join(
-      ", "
-    )}`
-  );
-}
-async function importConfig(configPath) {
-  const ext = path2__default.default.extname(configPath).toLowerCase();
-  if (ext === ".ts" || ext === ".tsx") {
-    return importTsConfig(configPath);
-  }
-  const url$1 = url.pathToFileURL(configPath).href;
-  const mod = await import(url$1);
-  return mod.default ?? mod;
-}
-async function importTsConfig(configPath) {
-  const source = fs7__default.default.readFileSync(configPath, "utf8");
-  const stat = fs7__default.default.statSync(configPath);
-  const hash = crypto__default.default.createHash("sha1").update(configPath).update(String(stat.mtimeMs)).digest("hex");
-  const tmpDir = path2__default.default.join(os__default.default.tmpdir(), "timeax-scaffold-config");
-  ensureDirSync(tmpDir);
-  const tmpFile = path2__default.default.join(tmpDir, `${hash}.mjs`);
-  if (!fs7__default.default.existsSync(tmpFile)) {
-    const result = await esbuild.transform(source, {
-      loader: "ts",
-      format: "esm",
-      sourcemap: "inline",
-      target: "ESNext",
-      tsconfigRaw: {
-        compilerOptions: {}
-      }
-    });
-    fs7__default.default.writeFileSync(tmpFile, result.code, "utf8");
-  }
-  const url$1 = url.pathToFileURL(tmpFile).href;
-  const mod = await import(url$1);
-  return mod.default ?? mod;
-}
-
-// src/core/structure-txt.ts
-function parseLine(line, lineNo) {
-  const match = line.match(/^(\s*)(.+)$/);
-  if (!match) return null;
-  const indentSpaces = match[1].length;
-  const rest = match[2].trim();
-  if (!rest || rest.startsWith("#")) return null;
-  const parts = rest.split(/\s+/);
-  const pathToken = parts[0];
-  let stub;
-  const include = [];
-  const exclude = [];
-  for (const token of parts.slice(1)) {
-    if (token.startsWith("@stub:")) {
-      stub = token.slice("@stub:".length);
-    } else if (token.startsWith("@include:")) {
-      const val = token.slice("@include:".length);
-      if (val) {
-        include.push(
-          ...val.split(",").map((s) => s.trim()).filter(Boolean)
-        );
-      }
-    } else if (token.startsWith("@exclude:")) {
-      const val = token.slice("@exclude:".length);
-      if (val) {
-        exclude.push(
-          ...val.split(",").map((s) => s.trim()).filter(Boolean)
-        );
-      }
-    }
-  }
-  return {
-    lineNo,
-    indentSpaces,
-    rawPath: pathToken,
-    stub,
-    include: include.length ? include : void 0,
-    exclude: exclude.length ? exclude : void 0
-  };
-}
-function parseStructureText(text) {
-  const lines = text.split(/\r?\n/);
-  const parsed = [];
-  for (let i = 0; i < lines.length; i++) {
-    const lineNo = i + 1;
-    const p = parseLine(lines[i], lineNo);
-    if (p) parsed.push(p);
-  }
-  const rootEntries = [];
-  const stack = [];
-  const INDENT_STEP = 2;
-  for (const p of parsed) {
-    const { indentSpaces, lineNo } = p;
-    if (indentSpaces % INDENT_STEP !== 0) {
-      throw new Error(
-        `structure.txt: Invalid indent on line ${lineNo}. Indent must be multiples of ${INDENT_STEP} spaces.`
-      );
-    }
-    const level = indentSpaces / INDENT_STEP;
-    if (level > stack.length) {
-      if (level !== stack.length + 1) {
-        throw new Error(
-          `structure.txt: Invalid indentation on line ${lineNo}. You cannot jump more than one level at a time. Previous depth: ${stack.length}, this line depth: ${level}.`
-        );
-      }
-    }
-    if (level > 0) {
-      const parent2 = stack[level - 1];
-      if (!parent2) {
-        throw new Error(
-          `structure.txt: Indented entry without a parent on line ${lineNo}.`
-        );
-      }
-      if (!parent2.isDir) {
-        throw new Error(
-          `structure.txt: Cannot indent under a file on line ${lineNo}. Files cannot have children. Parent: "${parent2.entry.path}".`
-        );
-      }
-    }
-    const isDir = p.rawPath.endsWith("/");
-    const clean = p.rawPath.replace(/\/$/, "");
-    const basePath = toPosixPath(clean);
-    while (stack.length > level) {
-      stack.pop();
-    }
-    const parent = stack[stack.length - 1]?.entry;
-    const parentPath = parent ? parent.path.replace(/\/$/, "") : "";
-    const fullPath = parentPath ? `${parentPath}/${basePath}${isDir ? "/" : ""}` : `${basePath}${isDir ? "/" : ""}`;
-    if (isDir) {
-      const dirEntry = {
-        type: "dir",
-        path: fullPath,
-        children: [],
-        ...p.stub ? { stub: p.stub } : {},
-        ...p.include ? { include: p.include } : {},
-        ...p.exclude ? { exclude: p.exclude } : {}
-      };
-      if (parent && parent.type === "dir") {
-        parent.children = parent.children ?? [];
-        parent.children.push(dirEntry);
-      } else if (!parent) {
-        rootEntries.push(dirEntry);
-      }
-      stack.push({ level, entry: dirEntry, isDir: true });
-    } else {
-      const fileEntry = {
-        type: "file",
-        path: fullPath,
-        ...p.stub ? { stub: p.stub } : {},
-        ...p.include ? { include: p.include } : {},
-        ...p.exclude ? { exclude: p.exclude } : {}
-      };
-      if (parent && parent.type === "dir") {
-        parent.children = parent.children ?? [];
-        parent.children.push(fileEntry);
-      } else if (!parent) {
-        rootEntries.push(fileEntry);
-      }
-      stack.push({ level, entry: fileEntry, isDir: false });
-    }
-  }
-  return rootEntries;
-}
-
-// src/core/resolve-structure.ts
-var logger2 = defaultLogger.child("[structure]");
-function resolveGroupStructure(scaffoldDir, group) {
-  if (group.structure && group.structure.length) {
-    logger2.debug(`Using inline structure for group "${group.name}"`);
-    return group.structure;
-  }
-  const fileName = group.structureFile ?? `${group.name}.txt`;
-  const filePath = path2__default.default.join(scaffoldDir, fileName);
-  if (!fs7__default.default.existsSync(filePath)) {
-    throw new Error(
-      `@timeax/scaffold: Group "${group.name}" has no structure. Expected file "${fileName}" in "${scaffoldDir}".`
-    );
-  }
-  logger2.debug(`Reading structure for group "${group.name}" from ${filePath}`);
-  const raw = fs7__default.default.readFileSync(filePath, "utf8");
-  return parseStructureText(raw);
-}
-function resolveSingleStructure(scaffoldDir, config) {
-  if (config.structure && config.structure.length) {
-    logger2.debug("Using inline single structure (no groups)");
-    return config.structure;
-  }
-  const fileName = config.structureFile ?? "structure.txt";
-  const filePath = path2__default.default.join(scaffoldDir, fileName);
-  if (!fs7__default.default.existsSync(filePath)) {
-    throw new Error(
-      `@timeax/scaffold: No structure defined. Expected "${fileName}" in "${scaffoldDir}".`
-    );
-  }
-  logger2.debug(`Reading single structure from ${filePath}`);
-  const raw = fs7__default.default.readFileSync(filePath, "utf8");
-  return parseStructureText(raw);
-}
-var logger3 = defaultLogger.child("[cache]");
-var DEFAULT_CACHE = {
-  version: 1,
-  entries: {}
-};
-var CacheManager = class {
-  constructor(projectRoot, cacheFileRelPath) {
-    this.projectRoot = projectRoot;
-    this.cacheFileRelPath = cacheFileRelPath;
-  }
-  cache = DEFAULT_CACHE;
-  get cachePathAbs() {
-    return path2__default.default.resolve(this.projectRoot, this.cacheFileRelPath);
-  }
-  load() {
-    const cachePath = this.cachePathAbs;
-    if (!fs7__default.default.existsSync(cachePath)) {
-      this.cache = { ...DEFAULT_CACHE, entries: {} };
-      return;
-    }
-    try {
-      const raw = fs7__default.default.readFileSync(cachePath, "utf8");
-      const parsed = JSON.parse(raw);
-      if (parsed.version === 1 && parsed.entries) {
-        this.cache = parsed;
-      } else {
-        logger3.warn("Cache file version mismatch or invalid, resetting cache.");
-        this.cache = { ...DEFAULT_CACHE, entries: {} };
-      }
-    } catch (err) {
-      logger3.warn("Failed to read cache file, resetting cache.", err);
-      this.cache = { ...DEFAULT_CACHE, entries: {} };
-    }
-  }
-  save() {
-    const cachePath = this.cachePathAbs;
-    const dir = path2__default.default.dirname(cachePath);
-    ensureDirSync(dir);
-    fs7__default.default.writeFileSync(cachePath, JSON.stringify(this.cache, null, 2), "utf8");
-  }
-  get(relPath) {
-    const key = toPosixPath(relPath);
-    return this.cache.entries[key];
-  }
-  set(entry) {
-    const key = toPosixPath(entry.path);
-    this.cache.entries[key] = {
-      ...entry,
-      path: key
-    };
-  }
-  delete(relPath) {
-    const key = toPosixPath(relPath);
-    delete this.cache.entries[key];
-  }
-  allPaths() {
-    return Object.keys(this.cache.entries);
-  }
-  allEntries() {
-    return Object.values(this.cache.entries);
-  }
-};
-function matchesFilter(pathRel, cfg) {
-  const { include, exclude, files } = cfg;
-  const patterns = [];
-  if (include?.length) patterns.push(...include);
-  if (files?.length) patterns.push(...files);
-  if (patterns.length) {
-    const ok = patterns.some((p) => minimatch.minimatch(pathRel, p));
-    if (!ok) return false;
-  }
-  if (exclude?.length) {
-    const blocked = exclude.some((p) => minimatch.minimatch(pathRel, p));
-    if (blocked) return false;
-  }
-  return true;
-}
-var HookRunner = class {
-  constructor(config) {
-    this.config = config;
-  }
-  async runRegular(kind, ctx) {
-    const configs = this.config.hooks?.[kind] ?? [];
-    for (const cfg of configs) {
-      if (!matchesFilter(ctx.targetPath, cfg)) continue;
-      await cfg.fn(ctx);
-    }
-  }
-  getStubConfig(stubName) {
-    if (!stubName) return void 0;
-    return this.config.stubs?.[stubName];
-  }
-  async runStub(kind, ctx) {
-    const stub = this.getStubConfig(ctx.stubName);
-    if (!stub?.hooks) return;
-    const configs = kind === "preStub" ? stub.hooks.preStub ?? [] : stub.hooks.postStub ?? [];
-    for (const cfg of configs) {
-      if (!matchesFilter(ctx.targetPath, cfg)) continue;
-      await cfg.fn(ctx);
-    }
-  }
-  async renderStubContent(ctx) {
-    const stub = this.getStubConfig(ctx.stubName);
-    if (!stub?.getContent) return void 0;
-    return stub.getContent(ctx);
-  }
-};
-async function applyStructure(opts) {
-  const {
-    config,
-    projectRoot,
-    baseDir,
-    structure,
-    cache,
-    hooks,
-    groupName,
-    groupRoot,
-    sizePromptThreshold,
-    interactiveDelete
-  } = opts;
-  const logger6 = opts.logger ?? defaultLogger.child(groupName ? `[apply:${groupName}]` : "[apply]");
-  const desiredPaths = /* @__PURE__ */ new Set();
-  const threshold = sizePromptThreshold ?? config.sizePromptThreshold ?? 128 * 1024;
-  async function walk(entry, inheritedStub) {
-    const effectiveStub = entry.stub ?? inheritedStub;
-    if (entry.type === "dir") {
-      await handleDir(entry, effectiveStub);
-    } else {
-      await handleFile(entry, effectiveStub);
-    }
-  }
-  async function handleDir(entry, inheritedStub) {
-    const relFromBase = entry.path.replace(/^[./]+/, "");
-    const absDir = path2__default.default.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) {
-        await walk(child, nextStub);
-      }
-    }
-  }
-  async function handleFile(entry, inheritedStub) {
-    const relFromBase = entry.path.replace(/^[./]+/, "");
-    const absFile = path2__default.default.resolve(baseDir, relFromBase);
-    const relFromRoot = toPosixPath(
-      toProjectRelativePath(projectRoot, absFile)
-    );
-    desiredPaths.add(relFromRoot);
-    const stubName = entry.stub ?? inheritedStub;
-    const ctx = {
-      projectRoot,
-      targetPath: relFromRoot,
-      absolutePath: absFile,
-      isDirectory: false,
-      stubName
-    };
-    if (fs7__default.default.existsSync(absFile)) {
-      return;
-    }
-    await hooks.runRegular("preCreateFile", ctx);
-    const dir = path2__default.default.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;
-    }
-    fs7__default.default.writeFileSync(absFile, content, "utf8");
-    const stats = fs7__default.default.statSync(absFile);
-    cache.set({
-      path: relFromRoot,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      sizeAtCreate: stats.size,
-      createdByStub: stubName,
-      groupName,
-      groupRoot
-    });
-    logger6.info(`created ${relFromRoot}`);
-    if (stubName) {
-      await hooks.runStub("postStub", ctx);
-    }
-    await hooks.runRegular("postCreateFile", ctx);
-  }
-  for (const entry of structure) {
-    await walk(entry);
-  }
-  for (const cachedPath of cache.allPaths()) {
-    if (desiredPaths.has(cachedPath)) continue;
-    const abs = path2__default.default.resolve(projectRoot, cachedPath);
-    const stats = statSafeSync(abs);
-    if (!stats) {
-      cache.delete(cachedPath);
-      continue;
-    }
-    if (!stats.isFile()) {
-      cache.delete(cachedPath);
-      continue;
-    }
-    const entry = cache.get(cachedPath);
-    const ctx = {
-      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);
-        logger6.info(`keeping ${cachedPath} (removed from cache)`);
-      }
-    }
-    if (shouldDelete) {
-      try {
-        fs7__default.default.unlinkSync(abs);
-        logger6.info(`deleted ${cachedPath}`);
-      } catch (err) {
-        logger6.warn(`failed to delete ${cachedPath}`, err);
-      }
-      cache.delete(cachedPath);
-      await hooks.runRegular("postDeleteFile", ctx);
-    }
-  }
-}
-
-// src/core/runner.ts
-async function runOnce(cwd, options = {}) {
-  const logger6 = options.logger ?? defaultLogger.child("[runner]");
-  const { config, scaffoldDir, projectRoot } = await loadScaffoldConfig(cwd, {
-    scaffoldDir: options.scaffoldDir,
-    configPath: options.configPath
-  });
-  const cachePath = config.cacheFile ?? ".scaffold-cache.json";
-  const cache = new CacheManager(projectRoot, cachePath);
-  cache.load();
-  const hooks = new HookRunner(config);
-  if (config.groups && config.groups.length > 0) {
-    for (const group of config.groups) {
-      const groupRootAbs = path2__default.default.resolve(projectRoot, group.root);
-      const structure = resolveGroupStructure(scaffoldDir, group);
-      const groupLogger = logger6.child(`[group:${group.name}]`);
-      await applyStructure({
-        config,
-        projectRoot,
-        baseDir: groupRootAbs,
-        structure,
-        cache,
-        hooks,
-        groupName: group.name,
-        groupRoot: group.root,
-        interactiveDelete: options.interactiveDelete,
-        logger: groupLogger
-      });
-    }
-  } else {
-    const structure = resolveSingleStructure(scaffoldDir, config);
-    const baseLogger = logger6.child("[group:default]");
-    await applyStructure({
-      config,
-      projectRoot,
-      baseDir: projectRoot,
-      structure,
-      cache,
-      hooks,
-      groupName: "default",
-      groupRoot: ".",
-      interactiveDelete: options.interactiveDelete,
-      logger: baseLogger
-    });
-  }
-  cache.save();
-}
-function watchScaffold(cwd, options = {}) {
-  const logger6 = options.logger ?? defaultLogger.child("[watch]");
-  const scaffoldDir = options.scaffoldDir ? path2__default.default.resolve(cwd, options.scaffoldDir) : path2__default.default.resolve(cwd, "scaffold");
-  const debounceMs = options.debounceMs ?? 150;
-  logger6.info(`Watching scaffold directory: ${scaffoldDir}`);
-  let timer;
-  let running = false;
-  let pending = false;
-  async function run() {
-    if (running) {
-      pending = true;
-      return;
-    }
-    running = true;
-    try {
-      logger6.info("Change detected \u2192 running scaffold...");
-      await runOnce(cwd, {
-        ...options,
-        // we already resolved scaffoldDir for watcher; pass it down
-        scaffoldDir
-      });
-      logger6.info("Scaffold run completed.");
-    } catch (err) {
-      logger6.error("Scaffold run failed:", err);
-    } finally {
-      running = false;
-      if (pending) {
-        pending = false;
-        timer = setTimeout(run, debounceMs);
-      }
-    }
-  }
-  function scheduleRun() {
-    if (timer) clearTimeout(timer);
-    timer = setTimeout(run, debounceMs);
-  }
-  const watcher = chokidar__default.default.watch(
-    [
-      path2__default.default.join(scaffoldDir, "config.*"),
-      path2__default.default.join(scaffoldDir, "*.txt")
-    ],
-    {
-      ignoreInitial: false
-    }
-  );
-  watcher.on("add", (filePath) => {
-    logger6.debug(`File added: ${filePath}`);
-    scheduleRun();
-  }).on("change", (filePath) => {
-    logger6.debug(`File changed: ${filePath}`);
-    scheduleRun();
-  }).on("unlink", (filePath) => {
-    logger6.debug(`File removed: ${filePath}`);
-    scheduleRun();
-  }).on("error", (error) => {
-    logger6.error("Watcher error:", error);
-  });
-  scheduleRun();
-}
-var logger4 = defaultLogger.child("[scan]");
-var DEFAULT_IGNORE = [
-  "node_modules/**",
-  ".git/**",
-  "dist/**",
-  "build/**",
-  ".turbo/**",
-  ".next/**",
-  "coverage/**"
-];
-function scanDirectoryToStructureText(rootDir, options = {}) {
-  const absRoot = path2__default.default.resolve(rootDir);
-  const lines = [];
-  const ignorePatterns = options.ignore ?? DEFAULT_IGNORE;
-  const maxDepth = options.maxDepth ?? Infinity;
-  function isIgnored(absPath) {
-    const rel = toPosixPath(path2__default.default.relative(absRoot, absPath));
-    if (!rel || rel === ".") return false;
-    return ignorePatterns.some(
-      (pattern) => minimatch.minimatch(rel, pattern, { dot: true })
-    );
-  }
-  function walk(currentAbs, depth) {
-    if (depth > maxDepth) return;
-    let dirents;
-    try {
-      dirents = fs7__default.default.readdirSync(currentAbs, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    dirents.sort((a, b) => {
-      if (a.isDirectory() && !b.isDirectory()) return -1;
-      if (!a.isDirectory() && b.isDirectory()) return 1;
-      return a.name.localeCompare(b.name);
-    });
-    for (const dirent of dirents) {
-      const name = dirent.name;
-      const absPath = path2__default.default.join(currentAbs, name);
-      if (isIgnored(absPath)) continue;
-      const indent = "  ".repeat(depth);
-      if (dirent.isDirectory()) {
-        lines.push(`${indent}${name}/`);
-        walk(absPath, depth + 1);
-      } else if (dirent.isFile()) {
-        lines.push(`${indent}${name}`);
-      }
-    }
-  }
-  walk(absRoot, 0);
-  return lines.join("\n");
-}
-async function scanProjectFromConfig(cwd, options = {}) {
-  const { config, scaffoldDir, projectRoot } = await loadScaffoldConfig(cwd, {
-    scaffoldDir: options.scaffoldDir
-  });
-  const ignorePatterns = options.ignore ?? DEFAULT_IGNORE;
-  const maxDepth = options.maxDepth ?? Infinity;
-  const onlyGroups = options.groups;
-  const results = [];
-  function scanGroup(cfg, group) {
-    const rootAbs = path2__default.default.resolve(projectRoot, group.root);
-    const text = scanDirectoryToStructureText(rootAbs, {
-      ignore: ignorePatterns,
-      maxDepth
-    });
-    const structureFileName = group.structureFile ?? `${group.name}.txt`;
-    const structureFilePath = path2__default.default.join(scaffoldDir, structureFileName);
-    return {
-      groupName: group.name,
-      groupRoot: group.root,
-      structureFileName,
-      structureFilePath,
-      text
-    };
-  }
-  if (config.groups && config.groups.length > 0) {
-    logger4.debug(
-      `Scanning project from config with ${config.groups.length} group(s).`
-    );
-    for (const group of config.groups) {
-      if (onlyGroups && !onlyGroups.includes(group.name)) {
-        continue;
-      }
-      const result = scanGroup(config, group);
-      results.push(result);
-    }
-  } else {
-    logger4.debug("Scanning project in single-root mode (no groups).");
-    const text = scanDirectoryToStructureText(projectRoot, {
-      ignore: ignorePatterns,
-      maxDepth
-    });
-    const structureFileName = config.structureFile ?? "structure.txt";
-    const structureFilePath = path2__default.default.join(scaffoldDir, structureFileName);
-    results.push({
-      groupName: "default",
-      groupRoot: ".",
-      structureFileName,
-      structureFilePath,
-      text
-    });
-  }
-  return results;
-}
-async function writeScannedStructuresFromConfig(cwd, options = {}) {
-  const { scaffoldDir } = await loadScaffoldConfig(cwd, {
-    scaffoldDir: options.scaffoldDir
-  });
-  ensureDirSync(scaffoldDir);
-  const results = await scanProjectFromConfig(cwd, options);
-  for (const result of results) {
-    fs7__default.default.writeFileSync(result.structureFilePath, result.text, "utf8");
-    logger4.info(
-      `Wrote structure for group "${result.groupName}" to ${result.structureFilePath}`
-    );
-  }
-}
-async function ensureStructureFilesFromConfig(cwd, options = {}) {
-  const { config, scaffoldDir } = await loadScaffoldConfig(cwd, {
-    scaffoldDir: options.scaffoldDirOverride
-  });
-  ensureDirSync(scaffoldDir);
-  const created = [];
-  const existing = [];
-  const seen = /* @__PURE__ */ new Set();
-  const ensureFile = (fileName) => {
-    if (!fileName) return;
-    const filePath = path2__default.default.join(scaffoldDir, fileName);
-    const key = path2__default.default.resolve(filePath);
-    if (seen.has(key)) return;
-    seen.add(key);
-    if (fs7__default.default.existsSync(filePath)) {
-      existing.push(filePath);
-      return;
-    }
-    const header = `# ${fileName}
-# Structure file for @timeax/scaffold
-# Define your desired folders/files here.
-`;
-    fs7__default.default.writeFileSync(filePath, header, "utf8");
-    created.push(filePath);
-  };
-  if (config.groups && config.groups.length > 0) {
-    for (const group of config.groups) {
-      const fileName = group.structureFile ?? `${group.name}.txt`;
-      ensureFile(fileName);
-    }
-  } else {
-    const fileName = config.structureFile ?? "structure.txt";
-    ensureFile(fileName);
-  }
-  logger4.debug(
-    `ensureStructureFilesFromConfig: created=${created.length}, existing=${existing.length}`
-  );
-  return { created, existing };
-}
-var logger5 = defaultLogger.child("[init]");
-var DEFAULT_CONFIG_TS = `import type { ScaffoldConfig } from '@timeax/scaffold';
-
-const config: ScaffoldConfig = {
-  // Root for resolving the scaffold/ folder & this config file.
-  // By default, this is the directory where you run \`scaffold\`.
-  // Example:
-  //   root: '.',          // scaffold/ at <cwd>/scaffold
-  //   root: 'tools',      // scaffold/ at <cwd>/tools/scaffold
-  // root: '.',
-
-  // Base directory where structures are applied and files/folders are created.
-  // This is resolved relative to \`root\` above. Defaults to the same as root.
-  // Example:
-  //   base: '.',          // apply to <root>
-  //   base: 'src',        // apply to <root>/src
-  //   base: '..',         // apply to parent of <root>
-  // base: '.',
-
-  // Cache file path, relative to base.
-  // cacheFile: '.scaffold-cache.json',
-
-  // --- Single-structure mode (simple) ---
-  // structureFile: 'structure.txt',
-
-  // --- Grouped mode (uncomment and adjust) ---
-  // groups: [
-  //   { name: 'app', root: 'app', structureFile: 'app.txt' },
-  //   { name: 'frontend', root: 'resources/js', structureFile: 'frontend.txt' },
-  // ],
-
-  hooks: {
-    // preCreateFile: [],
-    // postCreateFile: [],
-    // preDeleteFile: [],
-    // postDeleteFile: [],
-  },
-
-  stubs: {
-    // Example:
-    // page: {
-    //   name: 'page',
-    //   getContent: (ctx) =>
-    //     \`export default function Page() { return <div>\${ctx.targetPath}</div>; }\`,
-    // },
-  },
-};
-
-export default config;
-`;
-var DEFAULT_STRUCTURE_TXT = `# scaffold/structure.txt
-# Example structure definition.
-# - Indent with 2 spaces per level
-# - Directories must end with "/"
-# - Files do not
-# - Lines starting with "#" are comments and ignored by parser
-
-# Example:
-# src/
-#   index.ts
-`;
-async function initScaffold(cwd, options = {}) {
-  const scaffoldDirRel = options.scaffoldDir ?? "scaffold";
-  const scaffoldDirAbs = path2__default.default.resolve(cwd, scaffoldDirRel);
-  const configFileName = options.configFileName ?? "config.ts";
-  const structureFileName = options.structureFileName ?? "structure.txt";
-  ensureDirSync(scaffoldDirAbs);
-  const configPath = path2__default.default.join(scaffoldDirAbs, configFileName);
-  const structurePath = path2__default.default.join(scaffoldDirAbs, structureFileName);
-  let createdConfig = false;
-  let createdStructure = false;
-  if (fs7__default.default.existsSync(configPath) && !options.force) {
-    logger5.info(`Config already exists at ${configPath} (use --force to overwrite).`);
-  } else {
-    fs7__default.default.writeFileSync(configPath, DEFAULT_CONFIG_TS, "utf8");
-    createdConfig = true;
-    logger5.info(
-      `${fs7__default.default.existsSync(configPath) ? "Overwrote" : "Created"} config at ${configPath}`
-    );
-  }
-  if (fs7__default.default.existsSync(structurePath) && !options.force) {
-    logger5.info(
-      `Structure file already exists at ${structurePath} (use --force to overwrite).`
-    );
-  } else {
-    fs7__default.default.writeFileSync(structurePath, DEFAULT_STRUCTURE_TXT, "utf8");
-    createdStructure = true;
-    logger5.info(
-      `${fs7__default.default.existsSync(structurePath) ? "Overwrote" : "Created"} structure file at ${structurePath}`
-    );
-  }
-  return {
-    scaffoldDir: scaffoldDirAbs,
-    configPath,
-    structurePath,
-    created: {
-      config: createdConfig,
-      structure: createdStructure
-    }
-  };
-}
-
-// src/cli/main.ts
-function createCliLogger(opts) {
-  if (opts.quiet) {
-    defaultLogger.setLevel("silent");
-  } else if (opts.debug) {
-    defaultLogger.setLevel("debug");
-  }
-  return defaultLogger.child("[cli]");
-}
-function askYesNo(question) {
-  const rl = readline__default.default.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  return new Promise((resolve) => {
-    rl.question(`${question} [y/N] `, (answer) => {
-      rl.close();
-      const val = answer.trim().toLowerCase();
-      if (val === "y" || val === "yes") {
-        resolve("delete");
-      } else {
-        resolve("keep");
-      }
-    });
-  });
-}
-async function handleRunCommand(cwd, baseOpts) {
-  const logger6 = createCliLogger(baseOpts);
-  const configPath = baseOpts.config ? path2__default.default.resolve(cwd, baseOpts.config) : void 0;
-  const scaffoldDir = baseOpts.dir ? path2__default.default.resolve(cwd, baseOpts.dir) : void 0;
-  logger6.debug(
-    `Starting scaffold (cwd=${cwd}, config=${configPath ?? "auto"}, dir=${scaffoldDir ?? "scaffold/"}, watch=${baseOpts.watch ? "yes" : "no"})`
-  );
-  const runnerOptions = {
-    configPath,
-    scaffoldDir,
-    logger: logger6,
-    interactiveDelete: async ({
-      relativePath,
-      size,
-      createdByStub,
-      groupName
-    }) => {
-      const sizeKb = (size / 1024).toFixed(1);
-      const stubInfo = createdByStub ? ` (stub: ${createdByStub})` : "";
-      const groupInfo = groupName ? ` [group: ${groupName}]` : "";
-      const question = `File "${relativePath}"${groupInfo} is ~${sizeKb}KB and no longer in structure${stubInfo}. Delete it?`;
-      return askYesNo(question);
-    }
-  };
-  if (baseOpts.watch) {
-    watchScaffold(cwd, runnerOptions);
-  } else {
-    await runOnce(cwd, runnerOptions);
-  }
-}
-async function handleScanCommand(cwd, scanOpts, baseOpts) {
-  const logger6 = createCliLogger(baseOpts);
-  const useConfigMode = scanOpts.fromConfig || !scanOpts.root && !scanOpts.out;
-  if (useConfigMode) {
-    logger6.info("Scanning project using scaffold config/groups...");
-    await writeScannedStructuresFromConfig(cwd, {
-      ignore: scanOpts.ignore,
-      groups: scanOpts.groups
-    });
-    return;
-  }
-  const rootDir = path2__default.default.resolve(cwd, scanOpts.root ?? ".");
-  const ignore = scanOpts.ignore ?? [];
-  logger6.info(`Scanning directory for structure: ${rootDir}`);
-  const text = scanDirectoryToStructureText(rootDir, {
-    ignore
-  });
-  if (scanOpts.out) {
-    const outPath = path2__default.default.resolve(cwd, scanOpts.out);
-    const dir = path2__default.default.dirname(outPath);
-    ensureDirSync(dir);
-    fs7__default.default.writeFileSync(outPath, text, "utf8");
-    logger6.info(`Wrote structure to ${outPath}`);
-  } else {
-    process.stdout.write(text + "\n");
-  }
-}
-async function handleInitCommand(cwd, initOpts, baseOpts) {
-  const logger6 = createCliLogger(baseOpts);
-  const scaffoldDirRel = baseOpts.dir ?? "scaffold";
-  logger6.info(`Initializing scaffold directory at "${scaffoldDirRel}"...`);
-  const result = await initScaffold(cwd, {
-    scaffoldDir: scaffoldDirRel,
-    force: initOpts.force
-  });
-  logger6.info(
-    `Done. Config: ${result.configPath}, Structure: ${result.structurePath}`
-  );
-}
-async function handleStructuresCommand(cwd, baseOpts) {
-  const logger6 = createCliLogger(baseOpts);
-  logger6.info("Ensuring structure files declared in config exist...");
-  const { created, existing } = await ensureStructureFilesFromConfig(cwd, {
-    scaffoldDirOverride: baseOpts.dir
-  });
-  if (created.length === 0) {
-    logger6.info("All structure files already exist. Nothing to do.");
-  } else {
-    for (const filePath of created) {
-      logger6.info(`Created structure file: ${filePath}`);
-    }
-  }
-  existing.forEach((p) => logger6.debug(`Structure file already exists: ${p}`));
-}
-async function main() {
-  const cwd = process.cwd();
-  const program = new commander.Command();
-  program.name("scaffold").description("@timeax/scaffold \u2013 structure-based project scaffolding").option("-c, --config <path>", "Path to scaffold config file").option("-d, --dir <path>", "Path to scaffold directory (default: ./scaffold)").option("-w, --watch", "Watch scaffold directory for changes").option("--quiet", "Silence logs").option("--debug", "Enable debug logging");
-  program.command("scan").description(
-    "Generate structure.txt-style output (config-aware by default, or manual root/out)"
-  ).option(
-    "--from-config",
-    "Scan based on scaffold config/groups and write structure files into scaffold/ (default if no root/out specified)"
-  ).option(
-    "-r, --root <path>",
-    "Root directory to scan (manual mode)"
-  ).option(
-    "-o, --out <path>",
-    "Output file path (manual mode)"
-  ).option(
-    "--ignore <patterns...>",
-    "Additional glob patterns to ignore (relative to root)"
-  ).option(
-    "--groups <names...>",
-    "Limit config-based scanning to specific groups (by name)"
-  ).action(async (scanOpts, cmd) => {
-    const baseOpts = cmd.parent?.opts() ?? {};
-    await handleScanCommand(cwd, scanOpts, baseOpts);
-  });
-  program.command("init").description("Initialize scaffold folder and config/structure files").option(
-    "--force",
-    "Overwrite existing config/structure files if they already exist"
-  ).action(async (initOpts, cmd) => {
-    const baseOpts = cmd.parent?.opts() ?? {};
-    await handleInitCommand(cwd, initOpts, baseOpts);
-  });
-  program.action(async (opts) => {
-    await handleRunCommand(cwd, opts);
-  });
-  program.command("structures").description(
-    "Create missing structure files specified in the config (does not overwrite existing files)"
-  ).action(async (_opts, cmd) => {
-    const baseOpts = cmd.parent?.opts() ?? {};
-    await handleStructuresCommand(cwd, baseOpts);
-  });
-  await program.parseAsync(process.argv);
-}
-main().catch((err) => {
-  defaultLogger.error(err);
-  process.exit(1);
-});
-//# sourceMappingURL=cli.cjs.map
-//# sourceMappingURL=cli.cjs.map