@garyr/pt-cli 0.25.0

package/src/config.ts

@@ -0,0 +1,356 @@
+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 interface FolderNode {
+  name: string;
+  info: string;
+  children?: FolderNode[];
+  is_file?: boolean;
+}
+
+export interface PostConfigTask {
+  command?: string;       // shell command to run
+  description: string;   // shown to user
+  type?: string;          // only run for matching project type (optional)
+  always_prompt?: boolean; // if true, ask per-task even if user says "yes"
+  script?: string;        // path to script relative to template root
+  cross_platform?: boolean; // if true, use platform-safe runner
+  checked?: boolean;      // default checkbox state (only for global tasks)
+}
+
+export interface CopyFileEntry {
+  src: string;       // relative to template root
+  dest: string;      // relative to project root
+  substitute_variables?: boolean;
+  chmod?: string;    // e.g., "0755"
+}
+
+
+export interface PostCopyFile {
+  src: string;       // relative to templateRoot
+  dest?: string;     // relative to project root (defaults to src)
+}
+export interface TemplateConfig {
+  description: string;
+  templateRoot?: string;    // path to source directory (set by `pt learn`)
+  variables?: TemplateVariable[];
+  folders: FolderNode[];
+  exclude?: string[];
+  copy_files?: CopyFileEntry[];
+  post_copy?: PostCopyFile[];    // auto-detected executables/scripts
+  post_config?: PostConfigTask[];  // NEW
+}
+
+export interface TemplateVariable {
+  name: string;
+  prompt: string;
+  default?: string;
+  required?: boolean;
+}
+
+export interface PtConfig {
+  version: string;
+  templates: Record<string, TemplateConfig>;
+  ignore?: string[];  // top-level folder ignore patterns for pt learn
+  default_post_config?: PostConfigTask[];  // default post-config tasks applied to all projects
+  variables?: TemplateVariable[];         // global variables for substitution
+}
+
+export function ensureConfigDir() {
+  if (!fs.existsSync(HOME_DIR)) {
+    fs.mkdirSync(HOME_DIR, { recursive: true });
+  }
+}
+
+export function loadConfig(): PtConfig {
+  ensureConfigDir();
+  if (!fs.existsSync(CONFIG_PATH)) {
+    const defaultConfig: PtConfig = {
+      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: PtConfig = 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 as any).global_post_config !== undefined) {
+        config.default_post_config = (config as any).global_post_config;
+        delete (config as any).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 as unknown as Record<string, string>;
+      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 as any).name) {
+          t.description = (t as any).name;
+          delete (t as any).name;
+        }
+        if ((t as any).type) {
+          delete (t as any).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 as Error;
+    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: PtConfig) {
+  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 as Error;
+    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: PtConfig): string[] {
+  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: PtConfig): PostConfigTask[] {
+  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: string, fullPath: string, excludes?: string[]): boolean {
+  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: string, relativePath: string, ignorePatterns?: string[]): boolean {
+  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: string): boolean {
+  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: string): string {
+  // 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/src/index.ts

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+// 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: string | undefined, 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: string, sourcePath: string | undefined, 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: string | undefined, destPath: string | undefined, 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/src/postconfig.ts

@@ -0,0 +1,87 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { PostConfigTask } from './config.js';
+
+export interface PostConfigOptions {
+  skipPostConfig?: boolean;
+  dryRun?: boolean;
+  yes?: boolean;
+}
+
+/**
+ * Runs post-configuration tasks for a project.
+ */
+export async function runPostConfig(
+  destPath: string,
+  tasks: PostConfigTask[],
+  projectType: string,
+  options: PostConfigOptions = {}
+): Promise<void> {
+  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/src/substitute.ts

@@ -0,0 +1,122 @@
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { TemplateConfig } from './config.js';
+import { sanitizePath } from './config.js';
+
+/**
+ * Replaces all {{var}} patterns in the content with values from the variables object.
+ */
+export function substituteVariables(
+  content: string,
+  variables: Record<string, string>
+): string {
+  return content.replace(/\{\{\s*(\w+)\s*\}\}/g, (_, varName) => {
+    return variables[varName] ?? `{{${varName}}}`;
+  });
+}
+
+/**
+ * Processes copy_files tasks from a template.
+ */
+export async function processCopyFiles(
+  templateRoot: string,
+  resolvedDest: string,
+  template: TemplateConfig,
+  variables: Record<string, string>,
+  dryRun: boolean = false
+): Promise<void> {
+  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: string,
+  dest: string,
+  variables: Record<string, string>,
+  substitute: boolean,
+  chmod?: string
+) {
+  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) {}
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "NodeNext",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "NodeNext"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}