@timeax/scaffold 0.0.1 → 0.0.2

package/src/cli/main.ts

@@ -5,6 +5,7 @@ import { Command } from 'commander';
 import { runOnce, RunOptions } from '../core/runner';
 import { watchScaffold } from '../core/watcher';
 import {
+  ensureStructureFilesFromConfig,
   scanDirectoryToStructureText,
   writeScannedStructuresFromConfig,
 } from '../core/scan-structure';
@@ -170,6 +171,30 @@ async function handleInitCommand(
   );
 }
 
+
+async function handleStructuresCommand(
+  cwd: string,
+  baseOpts: BaseCliOptions,
+) {
+  const logger = createCliLogger(baseOpts);
+
+  logger.info('Ensuring structure files declared in config exist...');
+
+  const { created, existing } = await ensureStructureFilesFromConfig(cwd, {
+    scaffoldDirOverride: baseOpts.dir,
+  });
+
+  if (created.length === 0) {
+    logger.info('All structure files already exist. Nothing to do.');
+  } else {
+    for (const filePath of created) {
+      logger.info(`Created structure file: ${filePath}`);
+    }
+  }
+
+  existing.forEach((p) => logger.debug(`Structure file already exists: ${p}`));
+}
+
 async function main() {
   const cwd = process.cwd();
 
@@ -234,9 +259,22 @@ async function main() {
     await handleRunCommand(cwd, opts);
   });
 
+  interface StructuresCliOptions { }
+
+  program
+    .command('structures')
+    .description(
+      'Create missing structure files specified in the config (does not overwrite existing files)',
+    )
+    .action(async (_opts: StructuresCliOptions, cmd: Command) => {
+      const baseOpts = cmd.parent?.opts<BaseCliOptions>() ?? {};
+      await handleStructuresCommand(cwd, baseOpts);
+    });
+
   await program.parseAsync(process.argv);
 }
 
+
 // Run and handle errors
 main().catch((err) => {
   defaultLogger.error(err);

package/src/core/scan-structure.ts

@@ -211,4 +211,75 @@ export async function writeScannedStructuresFromConfig(
          `Wrote structure for group "${result.groupName}" to ${result.structureFilePath}`,
       );
    }
+}
+
+
+
+export interface EnsureStructuresResult {
+   created: string[];
+   existing: string[];
+}
+
+/**
+ * Ensure all structure files declared in the config exist.
+ *
+ * - Grouped mode: one file per group (group.structureFile || `${group.name}.txt`)
+ * - Single-root mode: config.structureFile || "structure.txt"
+ *
+ * Existing files are left untouched. Only missing files are created with
+ * a small header comment.
+ */
+export async function ensureStructureFilesFromConfig(
+   cwd: string,
+   options: { scaffoldDirOverride?: string } = {},
+): Promise<EnsureStructuresResult> {
+   const { config, scaffoldDir } = await loadScaffoldConfig(cwd, {
+      scaffoldDir: options.scaffoldDirOverride,
+   });
+
+   ensureDirSync(scaffoldDir);
+
+   const created: string[] = [];
+   const existing: string[] = [];
+
+   const seen = new Set<string>();
+
+   const ensureFile = (fileName: string) => {
+      if (!fileName) return;
+
+      const filePath = path.join(scaffoldDir, fileName);
+      const key = path.resolve(filePath);
+
+      if (seen.has(key)) return;
+      seen.add(key);
+
+      if (fs.existsSync(filePath)) {
+         existing.push(filePath);
+         return;
+      }
+
+      const header =
+         `# ${fileName}\n` +
+         `# Structure file for @timeax/scaffold\n` +
+         `# Define your desired folders/files here.\n`;
+
+      fs.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);
+   }
+
+   logger.debug(
+      `ensureStructureFilesFromConfig: created=${created.length}, existing=${existing.length}`,
+   );
+
+   return { created, existing };
 }