genomic 4.0.1 → 5.0.0

package/cache/cache-manager.d.ts

@@ -0,0 +1,60 @@
+import { AppStashResult } from 'appstash';
+import { CacheManagerConfig, CacheMetadata, CacheEntryInfo } from './types';
+export declare class CacheManager {
+    private config;
+    private dirs;
+    private reposDir;
+    private metadataDir;
+    constructor(config: CacheManagerConfig);
+    /**
+     * Public accessor for the repos cache directory path.
+     */
+    getReposDir(): string;
+    /**
+     * Public accessor for the metadata cache directory path.
+     */
+    getMetadataDir(): string;
+    /**
+     * Public accessor for resolved appstash directories.
+     */
+    getAppstashDirs(): AppStashResult;
+    /**
+     * Get cached directory path if exists and not expired
+     * Returns null if not cached or expired
+     */
+    get(key: string): string | null;
+    /**
+     * Store directory in cache with metadata
+     * Does NOT perform cloning - just registers the directory
+     */
+    set(key: string, sourcePath: string): string;
+    /**
+     * Check if cache entry is expired based on TTL
+     * Returns null if no metadata or not expired, returns metadata if expired
+     */
+    checkExpiration(key: string): CacheMetadata | null;
+    /**
+     * Clear specific cache entry
+     */
+    clear(key: string): void;
+    /**
+     * Clear all cache entries
+     */
+    clearAll(): void;
+    /**
+     * List all cache entries with expiration status
+     */
+    listAll(): CacheEntryInfo[];
+    /**
+     * Get metadata for a cache entry
+     */
+    getMetadata(key: string): CacheMetadata | null;
+    /**
+     * Create a cache key from identifier (e.g., git URL + branch)
+     */
+    createKey(identifier: string, variant?: string): string;
+    private ensureDirectories;
+    private isExpired;
+    private getCachePath;
+    private getMetadataPath;
+}

package/cache/cache-manager.js

@@ -0,0 +1,228 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheManager = void 0;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const appstash_1 = require("appstash");
+class CacheManager {
+    config;
+    dirs;
+    reposDir;
+    metadataDir;
+    constructor(config) {
+        // Validate required toolName
+        if (!config.toolName) {
+            throw new Error('CacheManager requires toolName parameter');
+        }
+        this.config = {
+            toolName: config.toolName,
+            baseDir: config.baseDir,
+            ttl: config.ttl,
+            dirs: config.dirs,
+        };
+        this.dirs =
+            config.dirs ??
+                (0, appstash_1.appstash)(this.config.toolName, {
+                    ensure: true,
+                    baseDir: this.config.baseDir,
+                });
+        this.reposDir = (0, appstash_1.resolve)(this.dirs, 'cache', 'repos');
+        this.metadataDir = (0, appstash_1.resolve)(this.dirs, 'cache', 'metadata');
+        this.ensureDirectories();
+    }
+    /**
+     * Public accessor for the repos cache directory path.
+     */
+    getReposDir() {
+        return this.reposDir;
+    }
+    /**
+     * Public accessor for the metadata cache directory path.
+     */
+    getMetadataDir() {
+        return this.metadataDir;
+    }
+    /**
+     * Public accessor for resolved appstash directories.
+     */
+    getAppstashDirs() {
+        return this.dirs;
+    }
+    /**
+     * Get cached directory path if exists and not expired
+     * Returns null if not cached or expired
+     */
+    get(key) {
+        const cachePath = this.getCachePath(key);
+        if (!fs.existsSync(cachePath)) {
+            return null;
+        }
+        // Check expiration - if expired, return null
+        const expired = this.checkExpiration(key);
+        if (expired) {
+            return null;
+        }
+        return cachePath;
+    }
+    /**
+     * Store directory in cache with metadata
+     * Does NOT perform cloning - just registers the directory
+     */
+    set(key, sourcePath) {
+        const cachePath = this.getCachePath(key);
+        // Write metadata with current timestamp
+        const metadata = {
+            key,
+            identifier: sourcePath,
+            lastUpdated: Date.now(),
+        };
+        fs.writeFileSync(this.getMetadataPath(key), JSON.stringify(metadata, null, 2));
+        return cachePath;
+    }
+    /**
+     * Check if cache entry is expired based on TTL
+     * Returns null if no metadata or not expired, returns metadata if expired
+     */
+    checkExpiration(key) {
+        const metadata = this.getMetadata(key);
+        if (!metadata) {
+            return null;
+        }
+        if (this.isExpired(metadata)) {
+            return metadata;
+        }
+        return null;
+    }
+    /**
+     * Clear specific cache entry
+     */
+    clear(key) {
+        const cachePath = this.getCachePath(key);
+        const metadataPath = this.getMetadataPath(key);
+        if (fs.existsSync(cachePath)) {
+            fs.rmSync(cachePath, { recursive: true, force: true });
+        }
+        if (fs.existsSync(metadataPath)) {
+            fs.rmSync(metadataPath, { force: true });
+        }
+    }
+    /**
+     * Clear all cache entries
+     */
+    clearAll() {
+        if (fs.existsSync(this.reposDir)) {
+            fs.rmSync(this.reposDir, { recursive: true, force: true });
+            fs.mkdirSync(this.reposDir, { recursive: true });
+        }
+        if (fs.existsSync(this.metadataDir)) {
+            fs.rmSync(this.metadataDir, { recursive: true, force: true });
+            fs.mkdirSync(this.metadataDir, { recursive: true });
+        }
+    }
+    /**
+     * List all cache entries with expiration status
+     */
+    listAll() {
+        if (!fs.existsSync(this.metadataDir)) {
+            return [];
+        }
+        const results = [];
+        const files = fs.readdirSync(this.metadataDir);
+        for (const file of files) {
+            if (!file.endsWith('.json')) {
+                continue;
+            }
+            const metadataPath = path.join(this.metadataDir, file);
+            try {
+                const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf-8'));
+                results.push({
+                    ...metadata,
+                    path: this.getCachePath(metadata.key),
+                    expired: this.isExpired(metadata),
+                });
+            }
+            catch {
+                // Skip corrupted metadata
+            }
+        }
+        return results;
+    }
+    /**
+     * Get metadata for a cache entry
+     */
+    getMetadata(key) {
+        const metadataPath = this.getMetadataPath(key);
+        if (!fs.existsSync(metadataPath)) {
+            return null;
+        }
+        try {
+            return JSON.parse(fs.readFileSync(metadataPath, 'utf-8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Create a cache key from identifier (e.g., git URL + branch)
+     */
+    createKey(identifier, variant) {
+        const input = variant ? `${identifier}#${variant}` : identifier;
+        return crypto.createHash('md5').update(input).digest('hex');
+    }
+    ensureDirectories() {
+        if (!fs.existsSync(this.reposDir)) {
+            fs.mkdirSync(this.reposDir, { recursive: true });
+        }
+        if (!fs.existsSync(this.metadataDir)) {
+            fs.mkdirSync(this.metadataDir, { recursive: true });
+        }
+    }
+    isExpired(metadata) {
+        if (!this.config.ttl) {
+            return false;
+        }
+        const age = Date.now() - metadata.lastUpdated;
+        return age > this.config.ttl;
+    }
+    getCachePath(key) {
+        return path.join(this.reposDir, key);
+    }
+    getMetadataPath(key) {
+        return path.join(this.metadataDir, `${key}.json`);
+    }
+}
+exports.CacheManager = CacheManager;

package/cache/types.d.ts

@@ -0,0 +1,22 @@
+import { AppStashResult } from 'appstash';
+export interface CacheManagerConfig {
+    toolName: string;
+    baseDir?: string;
+    ttl?: number;
+    /**
+     * Optional pre-resolved appstash directories owned by the caller.
+     * When provided, CacheManager will use these instead of creating its own.
+     */
+    dirs?: AppStashResult;
+}
+export interface CacheMetadata {
+    key: string;
+    identifier: string;
+    variant?: string;
+    lastUpdated: number;
+    source?: string;
+}
+export interface CacheEntryInfo extends CacheMetadata {
+    path: string;
+    expired: boolean;
+}

package/esm/cache/cache-manager.js

@@ -0,0 +1,191 @@
+import * as crypto from 'crypto';
+import * as fs from 'fs';
+import * as path from 'path';
+import { appstash, resolve as resolveAppstash } from 'appstash';
+export class CacheManager {
+    config;
+    dirs;
+    reposDir;
+    metadataDir;
+    constructor(config) {
+        // Validate required toolName
+        if (!config.toolName) {
+            throw new Error('CacheManager requires toolName parameter');
+        }
+        this.config = {
+            toolName: config.toolName,
+            baseDir: config.baseDir,
+            ttl: config.ttl,
+            dirs: config.dirs,
+        };
+        this.dirs =
+            config.dirs ??
+                appstash(this.config.toolName, {
+                    ensure: true,
+                    baseDir: this.config.baseDir,
+                });
+        this.reposDir = resolveAppstash(this.dirs, 'cache', 'repos');
+        this.metadataDir = resolveAppstash(this.dirs, 'cache', 'metadata');
+        this.ensureDirectories();
+    }
+    /**
+     * Public accessor for the repos cache directory path.
+     */
+    getReposDir() {
+        return this.reposDir;
+    }
+    /**
+     * Public accessor for the metadata cache directory path.
+     */
+    getMetadataDir() {
+        return this.metadataDir;
+    }
+    /**
+     * Public accessor for resolved appstash directories.
+     */
+    getAppstashDirs() {
+        return this.dirs;
+    }
+    /**
+     * Get cached directory path if exists and not expired
+     * Returns null if not cached or expired
+     */
+    get(key) {
+        const cachePath = this.getCachePath(key);
+        if (!fs.existsSync(cachePath)) {
+            return null;
+        }
+        // Check expiration - if expired, return null
+        const expired = this.checkExpiration(key);
+        if (expired) {
+            return null;
+        }
+        return cachePath;
+    }
+    /**
+     * Store directory in cache with metadata
+     * Does NOT perform cloning - just registers the directory
+     */
+    set(key, sourcePath) {
+        const cachePath = this.getCachePath(key);
+        // Write metadata with current timestamp
+        const metadata = {
+            key,
+            identifier: sourcePath,
+            lastUpdated: Date.now(),
+        };
+        fs.writeFileSync(this.getMetadataPath(key), JSON.stringify(metadata, null, 2));
+        return cachePath;
+    }
+    /**
+     * Check if cache entry is expired based on TTL
+     * Returns null if no metadata or not expired, returns metadata if expired
+     */
+    checkExpiration(key) {
+        const metadata = this.getMetadata(key);
+        if (!metadata) {
+            return null;
+        }
+        if (this.isExpired(metadata)) {
+            return metadata;
+        }
+        return null;
+    }
+    /**
+     * Clear specific cache entry
+     */
+    clear(key) {
+        const cachePath = this.getCachePath(key);
+        const metadataPath = this.getMetadataPath(key);
+        if (fs.existsSync(cachePath)) {
+            fs.rmSync(cachePath, { recursive: true, force: true });
+        }
+        if (fs.existsSync(metadataPath)) {
+            fs.rmSync(metadataPath, { force: true });
+        }
+    }
+    /**
+     * Clear all cache entries
+     */
+    clearAll() {
+        if (fs.existsSync(this.reposDir)) {
+            fs.rmSync(this.reposDir, { recursive: true, force: true });
+            fs.mkdirSync(this.reposDir, { recursive: true });
+        }
+        if (fs.existsSync(this.metadataDir)) {
+            fs.rmSync(this.metadataDir, { recursive: true, force: true });
+            fs.mkdirSync(this.metadataDir, { recursive: true });
+        }
+    }
+    /**
+     * List all cache entries with expiration status
+     */
+    listAll() {
+        if (!fs.existsSync(this.metadataDir)) {
+            return [];
+        }
+        const results = [];
+        const files = fs.readdirSync(this.metadataDir);
+        for (const file of files) {
+            if (!file.endsWith('.json')) {
+                continue;
+            }
+            const metadataPath = path.join(this.metadataDir, file);
+            try {
+                const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf-8'));
+                results.push({
+                    ...metadata,
+                    path: this.getCachePath(metadata.key),
+                    expired: this.isExpired(metadata),
+                });
+            }
+            catch {
+                // Skip corrupted metadata
+            }
+        }
+        return results;
+    }
+    /**
+     * Get metadata for a cache entry
+     */
+    getMetadata(key) {
+        const metadataPath = this.getMetadataPath(key);
+        if (!fs.existsSync(metadataPath)) {
+            return null;
+        }
+        try {
+            return JSON.parse(fs.readFileSync(metadataPath, 'utf-8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Create a cache key from identifier (e.g., git URL + branch)
+     */
+    createKey(identifier, variant) {
+        const input = variant ? `${identifier}#${variant}` : identifier;
+        return crypto.createHash('md5').update(input).digest('hex');
+    }
+    ensureDirectories() {
+        if (!fs.existsSync(this.reposDir)) {
+            fs.mkdirSync(this.reposDir, { recursive: true });
+        }
+        if (!fs.existsSync(this.metadataDir)) {
+            fs.mkdirSync(this.metadataDir, { recursive: true });
+        }
+    }
+    isExpired(metadata) {
+        if (!this.config.ttl) {
+            return false;
+        }
+        const age = Date.now() - metadata.lastUpdated;
+        return age > this.config.ttl;
+    }
+    getCachePath(key) {
+        return path.join(this.reposDir, key);
+    }
+    getMetadataPath(key) {
+        return path.join(this.metadataDir, `${key}.json`);
+    }
+}

package/esm/git/git-cloner.js

@@ -0,0 +1,92 @@
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+export class GitCloner {
+    /**
+     * Clone a git repository to a destination
+     * @param url - Repository URL (will be normalized)
+     * @param destination - Target directory path
+     * @param options - Clone options (branch, depth)
+     * @returns Clone result with normalized URL and destination
+     */
+    clone(url, destination, options) {
+        const normalizedUrl = this.normalizeUrl(url);
+        // Clean destination if exists
+        if (fs.existsSync(destination)) {
+            fs.rmSync(destination, { recursive: true, force: true });
+        }
+        this.executeClone(normalizedUrl, destination, options);
+        this.removeGitDir(destination);
+        return {
+            destination,
+            normalizedUrl,
+            branch: options?.branch,
+        };
+    }
+    /**
+     * Clone to a temporary directory
+     * @param url - Repository URL
+     * @param options - Clone options
+     * @returns Clone result with temp directory path
+     */
+    cloneToTemp(url, options) {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'create-gen-'));
+        return this.clone(url, tempDir, options);
+    }
+    /**
+     * Normalize a URL to git-cloneable format
+     * Handles: org/repo -> https://github.com/org/repo.git
+     */
+    normalizeUrl(url) {
+        // Already a full URL
+        if (url.startsWith('git@') ||
+            url.startsWith('https://') ||
+            url.startsWith('http://')) {
+            return url;
+        }
+        // org/repo shorthand
+        if (/^[\w-]+\/[\w-]+$/.test(url)) {
+            return `https://github.com/${url}.git`;
+        }
+        return url;
+    }
+    /**
+     * Validate git URL format
+     */
+    validateUrl(url) {
+        const normalized = this.normalizeUrl(url);
+        return (normalized.startsWith('git@') ||
+            normalized.startsWith('https://') ||
+            normalized.startsWith('http://'));
+    }
+    /**
+     * Remove .git directory from cloned repo
+     */
+    removeGitDir(directory) {
+        const gitDir = path.join(directory, '.git');
+        if (fs.existsSync(gitDir)) {
+            fs.rmSync(gitDir, { recursive: true, force: true });
+        }
+    }
+    executeClone(url, destination, options) {
+        const branch = options?.branch;
+        const depth = options?.depth ?? 1;
+        const singleBranch = options?.singleBranch ?? true;
+        const branchArgs = branch ? ` --branch ${branch}` : '';
+        const singleBranchArgs = singleBranch ? ' --single-branch' : '';
+        const depthArgs = ` --depth ${depth}`;
+        const command = `git clone${branchArgs}${singleBranchArgs}${depthArgs} ${url} ${destination}`;
+        try {
+            execSync(command, { stdio: 'inherit' });
+        }
+        catch (error) {
+            // Clean up on failure
+            if (fs.existsSync(destination)) {
+                fs.rmSync(destination, { recursive: true, force: true });
+            }
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to clone repository: ${errorMessage}`);
+        }
+    }
+}

package/esm/index.js

@@ -1,4 +1,41 @@
-export * from './commander';
-export * from './prompt';
-export * from './question';
-export * from './resolvers';
+import { registerDefaultResolver } from 'inquirerer';
+import { extractVariables } from './template/extract';
+import { promptUser } from './template/prompt';
+import { replaceVariables } from './template/replace';
+import { listSupportedLicenses } from './licenses';
+// Register the 'licenses' resolver for optionsFrom support
+// This allows boilerplate templates to use: "optionsFrom": "licenses"
+registerDefaultResolver('licenses', () => listSupportedLicenses());
+// Export new modular classes
+export * from './cache/cache-manager';
+export * from './cache/types';
+export * from './git/git-cloner';
+export * from './git/types';
+export * from './scaffolder/template-scaffolder';
+export * from './scaffolder/types';
+export * from './template/templatizer';
+export * from './template/types';
+export * from './utils/npm-version-check';
+export * from './utils/types';
+// Export template processing functions
+export * from './template/extract';
+export * from './template/prompt';
+export * from './template/replace';
+// Export shared types
+export * from './types';
+// DEPRECATED: Legacy exports for backward compatibility (will be removed in future)
+// Use CacheManager, GitCloner, and Templatizer classes instead
+export { extractVariables, promptUser, replaceVariables };
+/**
+ * @deprecated This function is deprecated and will be removed in the next major version.
+ * Use the modular approach with CacheManager, GitCloner, and Templatizer classes instead.
+ * See @genomic/scaffolds-test package for an example of the new orchestration pattern.
+ *
+ * Create a new project from a template repository
+ * @param options - Options for creating the project
+ * @returns Path to the generated project
+ */
+export async function createGen(options) {
+    throw new Error('createGen() has been deprecated. Please use CacheManager, GitCloner, and Templatizer classes for modular template processing. ' +
+        'See @genomic/scaffolds-test package for the new orchestration pattern.');
+}