@garyr/pt-cli 0.25.0

package/dist/config.js

@@ -0,0 +1,283 @@
+import YAML from 'yaml';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import chalk from 'chalk';
+export const HOME_DIR = path.join(os.homedir(), '.pt');
+export const CONFIG_PATH = path.join(HOME_DIR, 'config.yaml');
+export function ensureConfigDir() {
+    if (!fs.existsSync(HOME_DIR)) {
+        fs.mkdirSync(HOME_DIR, { recursive: true });
+    }
+}
+export function loadConfig() {
+    ensureConfigDir();
+    if (!fs.existsSync(CONFIG_PATH)) {
+        const defaultConfig = {
+            version: '3.0',
+            templates: {},
+            default_post_config: [],
+            variables: []
+        };
+        // Don't automatically save a default config on load.
+        // This prevents accidental creation of mostly-empty configs 
+        // if the home directory is temporarily mapped incorrectly.
+        return defaultConfig;
+    }
+    try {
+        const content = fs.readFileSync(CONFIG_PATH, 'utf-8');
+        if (!content.trim()) {
+            throw new Error("Config file is empty");
+        }
+        const config = YAML.parse(content);
+        // Initialize ignore for legacy configs that don't have it
+        if (config.ignore === undefined) {
+            config.ignore = [];
+        }
+        // Initialize default_post_config for configs that don't have it
+        if (config.default_post_config === undefined) {
+            // Migrate from global_post_config if it exists
+            if (config.global_post_config !== undefined) {
+                config.default_post_config = config.global_post_config;
+                delete config.global_post_config;
+                saveConfig(config);
+            }
+            else {
+                config.default_post_config = [];
+            }
+        }
+        // Initialize variables for configs that don't have it
+        if (config.variables === undefined) {
+            config.variables = [];
+        }
+        else if (!Array.isArray(config.variables)) {
+            // Migrate from Record<string, string> to TemplateVariable[]
+            const oldVars = config.variables;
+            config.variables = Object.entries(oldVars).map(([name, value]) => ({
+                name,
+                prompt: `Enter ${name}:`,
+                default: value
+            }));
+        }
+        // Migration from 2.0 to 3.0
+        if (config.version === '2.0') {
+            for (const key in config.templates) {
+                const t = config.templates[key];
+                if (t.description === undefined && t.name) {
+                    t.description = t.name;
+                    delete t.name;
+                }
+                if (t.type) {
+                    delete t.type;
+                }
+            }
+            config.version = '3.0';
+            saveConfig(config);
+            console.log(`\nConfig migrated to version 3.0 (renamed 'name' to 'description', removed 'type')`);
+        }
+        return config;
+    }
+    catch (err) {
+        const error = err;
+        console.error(chalk.red(`\nError loading config: ${error.message}`));
+        // If we have a backup, maybe suggest using it
+        const backupPath = CONFIG_PATH + '.bak';
+        if (fs.existsSync(backupPath)) {
+            console.error(chalk.yellow(`A backup exists at ${backupPath}. You may want to restore it.`));
+        }
+        process.exit(1);
+    }
+}
+export function saveConfig(config) {
+    ensureConfigDir();
+    const content = YAML.stringify(config);
+    const tempPath = CONFIG_PATH + '.tmp';
+    const backupPath = CONFIG_PATH + '.bak';
+    try {
+        // 1. Create a backup of the current valid config if it exists
+        if (fs.existsSync(CONFIG_PATH)) {
+            fs.copyFileSync(CONFIG_PATH, backupPath);
+        }
+        // 2. Write to a temporary file first (atomic save)
+        fs.writeFileSync(tempPath, content);
+        // 3. Rename temp file to actual config path
+        fs.renameSync(tempPath, CONFIG_PATH);
+    }
+    catch (err) {
+        const error = err;
+        console.error(chalk.red(`\nFailed to save config: ${error.message}`));
+        if (fs.existsSync(tempPath)) {
+            try {
+                fs.unlinkSync(tempPath);
+            }
+            catch (e) { }
+        }
+        throw error;
+    }
+}
+export function getTemplateNames(config) {
+    return Object.keys(config.templates || {});
+}
+/**
+ * Get default post-config tasks with defaults applied for unchecked entries.
+ * Default tasks that have checked=true (or undefined, which defaults to true)
+ * will be auto-checked. Tasks with checked=false stay unchecked by default.
+ */
+export function getDefaultPostConfig(config) {
+    const defaults = config.default_post_config || [];
+    return defaults.map(t => ({
+        ...t,
+        checked: t.checked !== false // default to true if not explicitly false
+    }));
+}
+// Default exclusions for template scanning
+export const DEFAULT_EXCLUDES = [
+    '.git',
+    '.gitea',
+    '.vscode',
+    'node_modules',
+    'dist',
+    'build',
+    'bin',
+    '.DS_Store',
+    'Thumbs.db',
+    '.stignore',
+    '.stfolder',
+    '.stversions',
+];
+// Check if a path should be excluded
+export function shouldExclude(dirPath, fullPath, excludes) {
+    const name = path.basename(fullPath); // Check the entry name, not the parent dir
+    const allExcludes = [...DEFAULT_EXCLUDES, ...(excludes || [])];
+    // Check if any entry is a git submodule
+    if (name === '.git' && fs.existsSync(path.join(fullPath, 'modules'))) {
+        return true;
+    }
+    // Check for submodules in the parent
+    const gitmodulesPath = path.join(fullPath, '..', '.gitmodules');
+    if (fs.existsSync(gitmodulesPath)) {
+        try {
+            const gitmodules = fs.readFileSync(gitmodulesPath, 'utf-8');
+            const regex = new RegExp(`path = ${name}\\s*$`, 'm');
+            if (regex.test(gitmodules)) {
+                return true;
+            }
+        }
+        catch (e) {
+            // Ignore errors reading gitmodules
+        }
+    }
+    return allExcludes.includes(name);
+}
+// Check if a folder should be ignored based on ignore patterns.
+// Patterns support glob-style wildcards:
+//   DAILIES/*      - ignore everything inside DAILIES (DAILIES itself is kept)
+//   DAILIES/**     - same as DAILIES/* (deep match from root)
+//   **/FOLDER/     - ignore any folder named FOLDER at any depth
+//   FOLDER         - ignore this specific folder (at root or as name)
+export function shouldIgnore(folderName, relativePath, ignorePatterns) {
+    if (!ignorePatterns || ignorePatterns.length === 0)
+        return false;
+    // Normalize relativePath to use forward slashes for consistent pattern matching
+    const normalizedPath = relativePath.split(path.sep).join('/');
+    const parts = normalizedPath.split('/');
+    for (let pattern of ignorePatterns) {
+        // Normalize pattern slashes
+        pattern = pattern.split(/[/\\]/).join('/');
+        // 1. Deep match: "**/NAME" or "**/NAME/"
+        if (pattern.startsWith('**/')) {
+            let target = pattern.substring(3);
+            if (target.endsWith('/'))
+                target = target.slice(0, -1);
+            // Match if any segment of the path matches the target
+            if (parts.includes(target))
+                return true;
+            continue;
+        }
+        // 2. Wildcard children at root: "FOLDER/*" or "FOLDER/**"
+        // Matches children of the named folder, NOT the folder itself
+        if (pattern.endsWith('/*') || pattern.endsWith('/**')) {
+            const suffix = pattern.endsWith('/**') ? 3 : 2;
+            const parentName = pattern.slice(0, -suffix);
+            if (parts[0] === parentName && parts.length > 1) {
+                return true;
+            }
+            continue;
+        }
+        // 3. Exact match (name or path)
+        let cleanPattern = pattern;
+        if (cleanPattern.endsWith('/'))
+            cleanPattern = cleanPattern.slice(0, -1);
+        if (folderName === cleanPattern || normalizedPath === cleanPattern) {
+            return true;
+        }
+    }
+    return false;
+}
+// Check if a file should be excluded (e.g., .gitignore patterns)
+export function shouldExcludeFile(fileName) {
+    const excludePatterns = [
+        '*.pyc',
+        '*.pyo',
+        '*.pyd',
+        '.Python',
+        '*.egg-info',
+        '*.egg',
+        '*.whl',
+        '*.so',
+        '*.dll',
+        '*.dylib',
+        '*.exe',
+        '*.o',
+        '*.a',
+        '*.lib',
+        '*.class',
+        '*.jar',
+        '*.war',
+        '*.ear',
+        '*.log',
+        '*.tmp',
+        '*.swp',
+        '*.swo',
+        '*~',
+        '.bak',
+        '*.md',
+        '*.txt',
+        '*.json',
+        '*.yaml',
+        '*.yml',
+        '*.ini',
+        '*.conf',
+        '*.config',
+        '.gitconfig',
+        '.makerc',
+        'Gemfile.lock',
+        'package.json',
+        'package-lock.json',
+        'yarn.lock',
+        'pnpm-lock.yaml',
+        'composer.json',
+        'composer.lock',
+    ];
+    for (const pattern of excludePatterns) {
+        if (pattern.startsWith('*')) {
+            const ext = pattern.substring(1);
+            if (fileName.endsWith(ext)) {
+                return true;
+            }
+        }
+        else if (fileName === pattern) {
+            return true;
+        }
+    }
+    return false;
+}
+// Sanitize path to prevent traversal
+export function sanitizePath(p) {
+    // Remove any path segments that attempt to go up, and trim whitespace
+    const segments = p.split(/[/\\]/);
+    const safeSegments = segments
+        .map(s => s.trim())
+        .filter(s => s !== '..' && s !== '.' && s !== '');
+    return safeSegments.join(path.sep);
+}

package/dist/index.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+// Command imports
+import { learn } from './commands/learnCommand.js';
+import { init } from './commands/initCommand.js';
+import { configCommand } from './commands/configCommand.js';
+import { ignoreCommand } from './commands/ignoreCommand.js';
+import { variablesCommand } from './commands/variablesCommand.js';
+import { addCommand } from './commands/addCommand.js';
+import { removeCommand } from './commands/removeCommand.js';
+import pkg from '../package.json' with { type: 'json' };
+const program = new Command();
+program
+    .name('pt')
+    .description('Project Template CLI - Learn project structures and initialize new ones')
+    .version(pkg.version, '-v', 'output the version number');
+program
+    .command('learn [path]')
+    .description('Learn a project structure from an existing directory')
+    .option('--ignore <patterns>', 'Folder patterns to ignore (comma-separated)')
+    .option('-y, --yes', 'Automatically confirm prompts')
+    .option('--name <name>', 'Template name (skip prompt)')
+    .option('--desc <description>', 'Template description (skip prompt)')
+    .option('--json', 'Output template structure as JSON for sharing instead of saving')
+    .action(async (pathArg, options) => {
+    await learn(pathArg || '.', null, options);
+});
+program
+    .command('update <templateName> [sourcePath]')
+    .description('Update an existing template with new structure/files')
+    .option('--ignore <patterns>', 'Folder patterns to ignore (comma-separated)')
+    .option('-y, --yes', 'Automatically confirm prompts')
+    .option('--desc <description>', 'Template description (skip prompt)')
+    .action(async (templateName, sourcePath, options) => {
+    await learn(sourcePath || '.', templateName, options);
+});
+program
+    .command('init [templateName] [destPath]')
+    .description('Initialize a new project from a learned template')
+    .option('--skip-post-config', 'Skip running post-config tasks')
+    .option('--dry-run', 'Show what would be created without making changes')
+    .option('-y, --yes', 'Automatically answer yes to prompts')
+    .option('--vars <variables>', 'Comma-separated key=value variables (e.g. key1=val1,key2=val2)')
+    .action(async (typeName, destPath, options) => {
+    await init(typeName, destPath, options);
+});
+program
+    .command('config [templateName]')
+    .description('Show current config location and list templates, or export a specific template')
+    .option('--json', 'Output config or specific template as JSON')
+    .action(configCommand);
+program
+    .command('ignore [patterns]')
+    .description('View or set global ignore patterns (comma-separated)')
+    .option('--set', 'Set the ignore patterns to the provided value')
+    .action(ignoreCommand);
+program
+    .command('variables [pairs]')
+    .description('View or set global variables (comma-separated key=value)')
+    .option('--set', 'Set the variables to the provided pairs')
+    .option('--json <data>', 'Set variables via JSON string or file')
+    .option('--delete <key>', 'Delete a specific global variable')
+    .action(variablesCommand);
+program
+    .command('add <name> [json]')
+    .description('Import/add a template from a JSON string or file')
+    .option('-f, --file <path>', 'Path to JSON file containing template data')
+    .action(addCommand);
+program
+    .command('remove <template>')
+    .alias('rm')
+    .description('Remove a learned template from the config')
+    .option('-y, --yes', 'Automatically confirm removal')
+    .action(removeCommand);
+program.parse(process.argv);

package/dist/postconfig.js

@@ -0,0 +1,73 @@
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+/**
+ * Runs post-configuration tasks for a project.
+ */
+export async function runPostConfig(destPath, tasks, projectType, options = {}) {
+    if (options.skipPostConfig)
+        return;
+    // 1. Filter tasks by type
+    const applicableTasks = tasks.filter(t => !t.type || t.type === projectType);
+    if (applicableTasks.length === 0) {
+        return;
+    }
+    // 2. Ask user (skip in dryRun or yes mode)
+    let run = false;
+    if (options.dryRun) {
+        console.log(chalk.yellow(`\n[DRY RUN] Applicable post-config tasks:`));
+        run = true;
+    }
+    else if (options.yes) {
+        run = true;
+    }
+    else {
+        const response = await inquirer.prompt({
+            type: 'confirm',
+            name: 'run',
+            message: 'Run post-config tasks?',
+            default: false
+        });
+        run = response.run;
+    }
+    if (!run)
+        return;
+    // 3. Show and run each task
+    for (let i = 0; i < applicableTasks.length; i++) {
+        const task = applicableTasks[i];
+        const progress = `[${i + 1}/${applicableTasks.length}]`;
+        if (task.command) {
+            if (options.dryRun) {
+                console.log(chalk.gray(`  [DRY RUN] Would run: ${task.command}`));
+            }
+            else {
+                try {
+                    console.log(chalk.yellow(`\n${progress} Running: ${task.command}`));
+                    execSync(task.command, {
+                        cwd: destPath,
+                        stdio: 'inherit'
+                    });
+                    console.log(chalk.green('  ✓ Command completed successfully'));
+                }
+                catch (err) {
+                    console.log(chalk.red('  ✗ Command failed'));
+                }
+            }
+        }
+        if (task.script) {
+            if (options.dryRun) {
+                console.log(chalk.gray(`  [DRY RUN] Would run script: ${task.script}`));
+            }
+            else {
+                try {
+                    process.stdout.write(`${progress} ${task.script} `);
+                    // Logic to run script would go here
+                    console.log(chalk.yellow('(not yet implemented)'));
+                }
+                catch (err) {
+                    console.log(chalk.red('✗'));
+                }
+            }
+        }
+    }
+}

package/dist/substitute.js

@@ -0,0 +1,98 @@
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import { sanitizePath } from './config.js';
+/**
+ * Replaces all {{var}} patterns in the content with values from the variables object.
+ */
+export function substituteVariables(content, variables) {
+    return content.replace(/\{\{\s*(\w+)\s*\}\}/g, (_, varName) => {
+        return variables[varName] ?? `{{${varName}}}`;
+    });
+}
+/**
+ * Processes copy_files tasks from a template.
+ */
+export async function processCopyFiles(templateRoot, resolvedDest, template, variables, dryRun = false) {
+    if (!template.copy_files)
+        return;
+    for (const copyFile of template.copy_files) {
+        const srcPath = path.join(templateRoot, copyFile.src);
+        const destPath = path.join(resolvedDest, sanitizePath(copyFile.dest));
+        if (!fs.existsSync(srcPath)) {
+            console.warn(chalk.yellow(`Warning: ${copyFile.src} not found in template`));
+            continue;
+        }
+        const stat = fs.statSync(srcPath);
+        if (stat.isDirectory()) {
+            // Recursive directory copy
+            if (dryRun) {
+                console.log(chalk.gray(`  [DRY RUN] Would recursively copy directory ${copyFile.src} → ${copyFile.dest}`));
+            }
+            else {
+                copyDirRecursive(srcPath, destPath, variables, copyFile.substitute_variables || false, copyFile.chmod);
+            }
+            console.log(chalk.green(`  ✓ ${copyFile.dest} (recursive)`));
+        }
+        else {
+            // Single file copy
+            if (dryRun) {
+                console.log(chalk.gray(`  [DRY RUN] Would copy ${copyFile.src} → ${copyFile.dest}`));
+                if (copyFile.substitute_variables) {
+                    console.log(chalk.gray(`  [DRY RUN] Would substitute variables in ${copyFile.dest}`));
+                }
+                if (copyFile.chmod) {
+                    console.log(chalk.gray(`  [DRY RUN] Would chmod ${copyFile.chmod} ${copyFile.dest}`));
+                }
+                continue;
+            }
+            // Ensure destination directory exists
+            fs.mkdirSync(path.dirname(destPath), { recursive: true });
+            let content = fs.readFileSync(srcPath, 'utf-8');
+            if (copyFile.substitute_variables) {
+                content = substituteVariables(content, variables);
+            }
+            fs.writeFileSync(destPath, content);
+            if (copyFile.chmod) {
+                try {
+                    fs.chmodSync(destPath, parseInt(copyFile.chmod, 8));
+                }
+                catch (e) {
+                    if (process.platform !== 'win32') {
+                        console.error(chalk.red(`Failed to set chmod ${copyFile.chmod} on ${copyFile.dest}`));
+                    }
+                }
+            }
+            console.log(chalk.green(`  ✓ ${copyFile.dest}`));
+        }
+    }
+}
+function copyDirRecursive(src, dest, variables, substitute, chmod) {
+    fs.mkdirSync(dest, { recursive: true });
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDirRecursive(srcPath, destPath, variables, substitute, chmod);
+        }
+        else {
+            let content = fs.readFileSync(srcPath, 'utf-8');
+            if (substitute) {
+                content = substituteVariables(content, variables);
+            }
+            fs.writeFileSync(destPath, content);
+            // Preserve execute permission if it exists in source
+            try {
+                const srcStat = fs.statSync(srcPath);
+                if (srcStat.mode & 0o111) {
+                    fs.chmodSync(destPath, 0o755);
+                }
+                else if (chmod) {
+                    fs.chmodSync(destPath, parseInt(chmod, 8));
+                }
+            }
+            catch (e) { }
+        }
+    }
+}