create-gen-app 0.7.0 → 0.8.0

package/esm/scaffolder/template-scaffolder.js

@@ -62,6 +62,30 @@ export class TemplateScaffolder {
         }
         return this.scaffoldFromRemote(resolvedTemplate, branch, options);
     }
+    /**
+     * Inspect a template without scaffolding.
+     * Clones/caches the template and reads its .boilerplate.json configuration
+     * without copying any files to an output directory.
+     *
+     * This is useful for metadata-driven workflows where you need to know
+     * the template's type or other configuration before deciding how to handle it.
+     *
+     * @param options - Inspect options
+     * @returns Inspect result with template metadata
+     */
+    inspect(options) {
+        const template = options.template ?? this.config.defaultRepo;
+        if (!template) {
+            throw new Error('No template specified and no defaultRepo configured. ' +
+                'Either pass template in options or set defaultRepo in config.');
+        }
+        const branch = options.branch ?? this.config.defaultBranch;
+        const resolvedTemplate = this.resolveTemplatePath(template);
+        if (this.isLocalPath(resolvedTemplate) && fs.existsSync(resolvedTemplate)) {
+            return this.inspectLocal(resolvedTemplate, options.fromPath);
+        }
+        return this.inspectRemote(resolvedTemplate, branch, options.fromPath);
+    }
     /**
      * Read the .boilerplates.json configuration from a template repository root.
      */
@@ -112,6 +136,53 @@ export class TemplateScaffolder {
     getTemplatizer() {
         return this.templatizer;
     }
+    inspectLocal(templateDir, fromPath) {
+        const { fromPath: resolvedFromPath, resolvedTemplatePath } = this.resolveFromPath(templateDir, fromPath);
+        const config = this.readBoilerplateConfig(resolvedTemplatePath);
+        return {
+            templateDir,
+            resolvedFromPath,
+            resolvedTemplatePath,
+            cacheUsed: false,
+            cacheExpired: false,
+            config,
+        };
+    }
+    inspectRemote(templateUrl, branch, fromPath) {
+        const normalizedUrl = this.gitCloner.normalizeUrl(templateUrl);
+        const cacheKey = this.cacheManager.createKey(normalizedUrl, branch);
+        const expiredMetadata = this.cacheManager.checkExpiration(cacheKey);
+        if (expiredMetadata) {
+            this.cacheManager.clear(cacheKey);
+        }
+        let templateDir;
+        let cacheUsed = false;
+        const cachedPath = this.cacheManager.get(cacheKey);
+        if (cachedPath && !expiredMetadata) {
+            templateDir = cachedPath;
+            cacheUsed = true;
+        }
+        else {
+            const tempDest = path.join(this.cacheManager.getReposDir(), cacheKey);
+            this.gitCloner.clone(normalizedUrl, tempDest, {
+                branch,
+                depth: 1,
+                singleBranch: true,
+            });
+            this.cacheManager.set(cacheKey, tempDest);
+            templateDir = tempDest;
+        }
+        const { fromPath: resolvedFromPath, resolvedTemplatePath } = this.resolveFromPath(templateDir, fromPath);
+        const config = this.readBoilerplateConfig(resolvedTemplatePath);
+        return {
+            templateDir,
+            resolvedFromPath,
+            resolvedTemplatePath,
+            cacheUsed,
+            cacheExpired: Boolean(expiredMetadata),
+            config,
+        };
+    }
     async scaffoldFromLocal(templateDir, options) {
         const { fromPath, resolvedTemplatePath } = this.resolveFromPath(templateDir, options.fromPath);
         const boilerplateConfig = this.readBoilerplateConfig(resolvedTemplatePath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-gen-app",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "author": "Constructive <developers@constructive.io>",
   "description": "Clone and customize template repositories with variable replacement",
   "main": "index.js",
@@ -36,5 +36,5 @@
     "makage": "0.1.8"
   },
   "keywords": [],
-  "gitHead": "a4a39f0cf2bc5a9e36801ea67b4f1ae9c3cf5faa"
+  "gitHead": "9ab0a7a8b90ccedd5f9bbde7dcdaef424c7f5acd"
 }

package/scaffolder/template-scaffolder.d.ts

@@ -1,7 +1,7 @@
 import { CacheManager } from '../cache/cache-manager';
 import { GitCloner } from '../git/git-cloner';
 import { Templatizer } from '../template/templatizer';
-import { TemplateScaffolderConfig, ScaffoldOptions, ScaffoldResult, BoilerplatesConfig, BoilerplateConfig } from './types';
+import { TemplateScaffolderConfig, ScaffoldOptions, ScaffoldResult, BoilerplatesConfig, BoilerplateConfig, InspectOptions, InspectResult } from './types';
 /**
  * High-level orchestrator for template scaffolding operations.
  * Combines CacheManager, GitCloner, and Templatizer into a single, easy-to-use API.
@@ -37,6 +37,18 @@ export declare class TemplateScaffolder {
      * @returns Scaffold result with output path and metadata
      */
     scaffold(options: ScaffoldOptions): Promise<ScaffoldResult>;
+    /**
+     * Inspect a template without scaffolding.
+     * Clones/caches the template and reads its .boilerplate.json configuration
+     * without copying any files to an output directory.
+     *
+     * This is useful for metadata-driven workflows where you need to know
+     * the template's type or other configuration before deciding how to handle it.
+     *
+     * @param options - Inspect options
+     * @returns Inspect result with template metadata
+     */
+    inspect(options: InspectOptions): InspectResult;
     /**
      * Read the .boilerplates.json configuration from a template repository root.
      */
@@ -57,6 +69,8 @@ export declare class TemplateScaffolder {
      * Get the underlying Templatizer instance for advanced template operations.
      */
     getTemplatizer(): Templatizer;
+    private inspectLocal;
+    private inspectRemote;
     private scaffoldFromLocal;
     private scaffoldFromRemote;
     /**

package/scaffolder/template-scaffolder.js

@@ -98,6 +98,30 @@ class TemplateScaffolder {
         }
         return this.scaffoldFromRemote(resolvedTemplate, branch, options);
     }
+    /**
+     * Inspect a template without scaffolding.
+     * Clones/caches the template and reads its .boilerplate.json configuration
+     * without copying any files to an output directory.
+     *
+     * This is useful for metadata-driven workflows where you need to know
+     * the template's type or other configuration before deciding how to handle it.
+     *
+     * @param options - Inspect options
+     * @returns Inspect result with template metadata
+     */
+    inspect(options) {
+        const template = options.template ?? this.config.defaultRepo;
+        if (!template) {
+            throw new Error('No template specified and no defaultRepo configured. ' +
+                'Either pass template in options or set defaultRepo in config.');
+        }
+        const branch = options.branch ?? this.config.defaultBranch;
+        const resolvedTemplate = this.resolveTemplatePath(template);
+        if (this.isLocalPath(resolvedTemplate) && fs.existsSync(resolvedTemplate)) {
+            return this.inspectLocal(resolvedTemplate, options.fromPath);
+        }
+        return this.inspectRemote(resolvedTemplate, branch, options.fromPath);
+    }
     /**
      * Read the .boilerplates.json configuration from a template repository root.
      */
@@ -148,6 +172,53 @@ class TemplateScaffolder {
     getTemplatizer() {
         return this.templatizer;
     }
+    inspectLocal(templateDir, fromPath) {
+        const { fromPath: resolvedFromPath, resolvedTemplatePath } = this.resolveFromPath(templateDir, fromPath);
+        const config = this.readBoilerplateConfig(resolvedTemplatePath);
+        return {
+            templateDir,
+            resolvedFromPath,
+            resolvedTemplatePath,
+            cacheUsed: false,
+            cacheExpired: false,
+            config,
+        };
+    }
+    inspectRemote(templateUrl, branch, fromPath) {
+        const normalizedUrl = this.gitCloner.normalizeUrl(templateUrl);
+        const cacheKey = this.cacheManager.createKey(normalizedUrl, branch);
+        const expiredMetadata = this.cacheManager.checkExpiration(cacheKey);
+        if (expiredMetadata) {
+            this.cacheManager.clear(cacheKey);
+        }
+        let templateDir;
+        let cacheUsed = false;
+        const cachedPath = this.cacheManager.get(cacheKey);
+        if (cachedPath && !expiredMetadata) {
+            templateDir = cachedPath;
+            cacheUsed = true;
+        }
+        else {
+            const tempDest = path.join(this.cacheManager.getReposDir(), cacheKey);
+            this.gitCloner.clone(normalizedUrl, tempDest, {
+                branch,
+                depth: 1,
+                singleBranch: true,
+            });
+            this.cacheManager.set(cacheKey, tempDest);
+            templateDir = tempDest;
+        }
+        const { fromPath: resolvedFromPath, resolvedTemplatePath } = this.resolveFromPath(templateDir, fromPath);
+        const config = this.readBoilerplateConfig(resolvedTemplatePath);
+        return {
+            templateDir,
+            resolvedFromPath,
+            resolvedTemplatePath,
+            cacheUsed,
+            cacheExpired: Boolean(expiredMetadata),
+            config,
+        };
+    }
     async scaffoldFromLocal(templateDir, options) {
         const { fromPath, resolvedTemplatePath } = this.resolveFromPath(templateDir, options.fromPath);
         const boilerplateConfig = this.readBoilerplateConfig(resolvedTemplatePath);

package/scaffolder/types.d.ts

@@ -123,3 +123,53 @@ export interface BoilerplateConfig {
      */
     questions?: Question[];
 }
+/**
+ * Options for inspecting a template without scaffolding.
+ * Used to read template metadata before deciding how to handle it.
+ */
+export interface InspectOptions {
+    /**
+     * Template repository URL, local path, or org/repo shorthand.
+     * If not provided, uses the defaultRepo from config.
+     */
+    template?: string;
+    /**
+     * Branch to clone (for remote repositories)
+     */
+    branch?: string;
+    /**
+     * Subdirectory within the template repository to inspect.
+     * Can be a direct path or a variant name that gets resolved via .boilerplates.json
+     */
+    fromPath?: string;
+}
+/**
+ * Result of inspecting a template.
+ * Contains metadata about the template without copying any files.
+ */
+export interface InspectResult {
+    /**
+     * Path to the cached/cloned template directory
+     */
+    templateDir: string;
+    /**
+     * The resolved fromPath after .boilerplates.json resolution
+     */
+    resolvedFromPath?: string;
+    /**
+     * Full path to the resolved template directory
+     */
+    resolvedTemplatePath: string;
+    /**
+     * Whether a cached template was used
+     */
+    cacheUsed: boolean;
+    /**
+     * Whether the cache was expired and refreshed
+     */
+    cacheExpired: boolean;
+    /**
+     * The .boilerplate.json configuration from the template, if present
+     */
+    config: BoilerplateConfig | null;
+}