@garyr/pt-cli 0.40.0 → 0.41.0

package/src/commands/template-detection.ts

@@ -0,0 +1,269 @@
+import fs from 'fs';
+import path from 'path';
+import { FolderNode, TemplateConfig, CopyFileEntry, PostConfigTask, PostCopyFile, shouldIgnore, shouldExclude, shouldExcludeFile } from '../config.js';
+
+/**
+ * Extract folder structure skeleton from a directory
+ * Only includes directories, with optional .info.md content
+ */
+export function extractStructure(dirPath: string, rootPath: string, ignorePatterns?: string[]): FolderNode[] {
+  const nodes: FolderNode[] = [];
+  try {
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dirPath, entry.name);
+      const relativePath = path.relative(rootPath, fullPath);
+
+      // Only include directories in the structure skeleton
+      const isDirectory = entry.isDirectory() || (entry.isSymbolicLink() && fs.existsSync(fullPath) && fs.statSync(fullPath).isDirectory());
+      if (!isDirectory) continue;
+
+      if (shouldIgnore(entry.name, relativePath, ignorePatterns)) continue;
+      if (shouldExclude(dirPath, fullPath)) continue;
+
+      const children = extractStructure(fullPath, rootPath, ignorePatterns);
+      let info = '';
+      const gitkeepPath = path.join(fullPath, '.gitkeep.md');
+      const infoPath = path.join(fullPath, '.info.md');
+      if (fs.existsSync(infoPath)) info = fs.readFileSync(infoPath, 'utf-8').trim();
+      else if (fs.existsSync(gitkeepPath)) info = fs.readFileSync(gitkeepPath, 'utf-8').trim();
+      nodes.push({ name: entry.name, info, children });
+    }
+  } catch (e) {
+    // Ignore directory read errors
+  }
+  return nodes;
+}
+
+/**
+ * Scan text files in top-level and 1st-level subdirectories for {{ variable_name }} placeholders.
+ */
+export function findVariablesInFiles(dirPath: string, rootPath: string, ignorePatterns?: string[]): string[] {
+  const variables = new Set<string>();
+  const regex = /\{\{\s*([a-zA-Z0-9_]+)\s*\}\}/g;
+
+  const textExtensions = ['.md', '.txt', '.makerc', '.json', '.yaml', '.yml', '.ini', '.conf', '.config', '.sh', '.py', '.js', '.ts', '.html', '.css', '.makefile'];
+
+  const scan = (currentPath: string, depth: number) => {
+    if (depth > 1) return; // Top level (0) and 1st level subfolders (1)
+
+    try {
+      const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(currentPath, entry.name);
+        const relativePath = path.relative(rootPath, fullPath);
+
+        if (entry.isDirectory()) {
+          if (shouldIgnore(entry.name, relativePath, ignorePatterns)) continue;
+          if (shouldExclude(currentPath, fullPath)) continue;
+          scan(fullPath, depth + 1);
+        } else if (entry.isFile()) {
+          const ext = path.extname(entry.name).toLowerCase();
+          const isMakefile = entry.name.toLowerCase() === 'makefile';
+
+          if (textExtensions.includes(ext) || isMakefile || ext === '') {
+            try {
+              const content = fs.readFileSync(fullPath, 'utf-8');
+              let match;
+              regex.lastIndex = 0;
+              while ((match = regex.exec(content)) !== null) {
+                variables.add(match[1]);
+              }
+            } catch (e) {
+              // Skip files that can't be read or aren't text
+            }
+          }
+        }
+      }
+    } catch (e) {
+      // Ignore directory read errors
+    }
+  };
+
+  scan(dirPath, 0);
+  return Array.from(variables);
+}
+
+/**
+ * Check if a file is executable (by extension or permissions)
+ */
+export function isExecutable(fullPath: string, fileName: string): boolean {
+  if (shouldExcludeFile(fileName)) return false;
+  const ext = path.extname(fileName).toLowerCase();
+  if (['.sh', '.py', '.bash', '.bat', '.cmd'].includes(ext)) return true;
+  if (fileName.toLowerCase() === 'makefile') return true;
+  try {
+    const stat = fs.statSync(fullPath);
+    return !!(stat.mode & 0o111);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Parse .info.md file for name and description
+ */
+export function parseInfoFile(infoPath: string): { name: string; description: string } {
+  let name = '';
+  let description = '';
+  if (fs.existsSync(infoPath)) {
+    const content = fs.readFileSync(infoPath, 'utf-8');
+    const lines = content.split('\n');
+    for (const line of lines) {
+      if (line.startsWith('# ')) {
+        name = line.substring(2).trim();
+      } else if (line.trim() !== '' && !description && !line.startsWith('#')) {
+        description = line.trim();
+      }
+    }
+  }
+  return { name, description };
+}
+
+/**
+ * Load JSON template config from .pt-template.json or template.json
+ */
+export function loadJsonTemplateConfig(dirPath: string): Partial<TemplateConfig> & { name?: string } {
+  const jsonConfigPaths = [
+    path.join(dirPath, '.pt-template.json'),
+    path.join(dirPath, 'template.json')
+  ];
+  for (const jPath of jsonConfigPaths) {
+    if (fs.existsSync(jPath)) {
+      try {
+        const content = fs.readFileSync(jPath, 'utf-8');
+        return JSON.parse(content);
+      } catch (e) {
+        console.warn(`Warning: Failed to parse ${path.basename(jPath)}: ${(e as Error).message}`);
+      }
+    }
+  }
+  return {};
+}
+
+/**
+ * Get root-level files and directories (for copy_files selection)
+ */
+export function getRootEntries(dirPath: string, ignorePatterns?: string[]): { files: string[]; dirs: string[] } {
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true })
+    .filter(e => !shouldExclude(dirPath, path.join(dirPath, e.name), ignorePatterns))
+    .filter(e => !shouldIgnore(e.name, e.name, ignorePatterns));
+
+  const files = entries.filter(e => e.isFile()).map(e => e.name);
+  const dirs = entries.filter(e => e.isDirectory()).map(e => e.name);
+  return { files, dirs };
+}
+
+/**
+ * Detect executable files at root level
+ */
+export function detectRootExecutables(dirPath: string, ignorePatterns?: string[]): string[] {
+  const { files } = getRootEntries(dirPath, ignorePatterns);
+  return files.filter(file => isExecutable(path.join(dirPath, file), file));
+}
+
+/**
+ * Parse post_config.sh or post_config.bat for commands
+ */
+export function parsePostConfigScript(shPath: string, batPath: string): PostConfigTask[] {
+  const tasks: PostConfigTask[] = [];
+  
+  if (fs.existsSync(shPath)) {
+    const lines = fs.readFileSync(shPath, 'utf-8').split('\n');
+    let currentDesc = '';
+    for (const line of lines) {
+      if (line.startsWith('echo "Running: ')) {
+        currentDesc = line.substring(15, line.length - 1).replace(/"$/, '');
+      } else if (line.trim() && !line.startsWith('#') && !line.startsWith('echo ')) {
+        tasks.push({ command: line.trim(), description: currentDesc || line.trim() });
+        currentDesc = '';
+      }
+    }
+  } else if (fs.existsSync(batPath)) {
+    const lines = fs.readFileSync(batPath, 'utf-8').split('\n');
+    let currentDesc = '';
+    for (const line of lines) {
+      if (line.startsWith('echo Running: ')) {
+        currentDesc = line.substring(14).trim();
+      } else if (line.trim() && !line.startsWith('::') && !line.startsWith('@echo') && !line.startsWith('echo ')) {
+        tasks.push({ command: line.trim(), description: currentDesc || line.trim() });
+        currentDesc = '';
+      }
+    }
+  }
+  return tasks;
+}
+
+/**
+ * Build copy_files array from selected files and folders
+ */
+export function buildCopyFiles(
+  selectedFiles: string[],
+  selectedFolders: string[],
+  existingCopyFiles: CopyFileEntry[] = []
+): CopyFileEntry[] {
+  const copyFiles: CopyFileEntry[] = [];
+  const existingSrcs = new Set(existingCopyFiles.map(e => e.src));
+
+  // Start with existing entries (preserves substitute_variables, chmod settings)
+  copyFiles.push(...existingCopyFiles);
+
+  // Add new files
+  for (const f of selectedFiles) {
+    if (existingSrcs.has(f)) continue;
+    copyFiles.push({ src: f, dest: f, substitute_variables: true });
+  }
+  // Add new directories
+  for (const d of selectedFolders) {
+    if (existingSrcs.has(d)) continue;
+    copyFiles.push({ src: d, dest: d, substitute_variables: true });
+  }
+  return copyFiles;
+}
+
+/**
+ * Merge post_config tasks from JSON config and/or detected scripts
+ */
+export function mergePostConfigTasks(
+  existingTasks: PostConfigTask[],
+  jsonTasks: PostConfigTask[] | undefined,
+  detectedTasks: PostConfigTask[]
+): PostConfigTask[] {
+  let tasks = [...existingTasks];
+  
+  // JSON config takes precedence (full replacement)
+  if (jsonTasks && jsonTasks.length > 0) {
+    tasks = [...jsonTasks];
+  } else if (detectedTasks.length > 0) {
+    // Add detected tasks that don't already exist
+    for (const dt of detectedTasks) {
+      const exists = tasks.some(t => t.command === dt.command || (t.script && t.script === dt.script));
+      if (!exists) tasks.push(dt);
+    }
+  }
+  return tasks;
+}
+
+/**
+ * Merge post_copy files from JSON config and/or detected executables
+ */
+export function mergePostCopyFiles(
+  existingFiles: PostCopyFile[],
+  jsonFiles: PostCopyFile[] | undefined,
+  detectedFiles: string[]
+): PostCopyFile[] {
+  let files = [...existingFiles];
+  
+  if (jsonFiles && jsonFiles.length > 0) {
+    for (const jf of jsonFiles) {
+      if (!files.some(ef => ef.src === jf.src)) files.push(jf);
+    }
+  }
+  
+  for (const df of detectedFiles) {
+    if (!files.some(ef => ef.src === df)) {
+      files.push({ src: df, dest: df });
+    }
+  }
+  return files;
+}

package/src/commands/template-prompts.ts

@@ -0,0 +1,406 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { TemplateVariable, FolderNode, CopyFileEntry, PostConfigTask } from '../config.js';
+
+/**
+ * Prompt for template name with auto-detection and confirmation
+ */
+export async function promptTemplateName(
+  currentName: string,
+  existingNames: string[],
+  sourceName: string | null,
+  options: { yes?: boolean; json?: boolean } = {}
+): Promise<string> {
+  if (options.yes || options.json) return currentName;
+
+  // If name came from source (.info.md or JSON), confirm it
+  if (sourceName && sourceName === currentName) {
+    const { confirmName } = await inquirer.prompt({
+      type: 'confirm',
+      name: 'confirmName',
+      message: `Use "${currentName}" as the template name?`,
+      default: true
+    });
+    if (!confirmName) {
+      const { newName } = await inquirer.prompt({
+        type: 'input',
+        name: 'newName',
+        message: 'Name this template:',
+        default: currentName
+      });
+      return newName;
+    }
+  }
+
+  // Check for existing template name
+  if (existingNames.includes(currentName)) {
+    console.warn(chalk.yellow(`⚠ Warning: "${currentName}" already exists. Using this name will overwrite.`));
+  }
+  return currentName;
+}
+
+/**
+ * Prompt for template description
+ */
+export async function promptDescription(
+  currentDesc: string,
+  options: { yes?: boolean; json?: boolean } = {}
+): Promise<string> {
+  if (options.yes || options.json) return currentDesc;
+
+  const { description } = await inquirer.prompt({
+    type: 'input',
+    name: 'description',
+    message: 'Template description:',
+    default: currentDesc
+  });
+  return description;
+}
+
+/**
+ * Prompt for template root directory
+ */
+export async function promptTemplateRoot(
+  currentRoot: string,
+  options: { yes?: boolean; json?: boolean } = {}
+): Promise<string> {
+  if (options.yes || options.json) return currentRoot;
+
+  const { templateRoot } = await inquirer.prompt({
+    type: 'input',
+    name: 'templateRoot',
+    message: 'Template root folder:',
+    default: currentRoot
+  });
+  return templateRoot;
+}
+
+/**
+ * Prompt for new variables (checkbox selection)
+ */
+export async function promptNewVariables(
+  newVars: TemplateVariable[],
+  options: { yes?: boolean; json?: boolean } = {}
+): Promise<TemplateVariable[]> {
+  if (newVars.length === 0) return [];
+  
+  if (options.yes || options.json) return newVars;
+
+  console.log(chalk.cyan(`\n📊 New Variables:`));
+  console.log(chalk.green(`  + ${newVars.length} new variable(s): ${newVars.map(v => v.name).join(', ')}`));
+
+  const { selectedVars } = await inquirer.prompt({
+    type: 'checkbox',
+    name: 'selectedVars',
+    message: 'Select variables to include (space to toggle):',
+    loop: false,
+    theme: {
+      icon: {
+        checked: chalk.green('[x] '),
+        unchecked: '[ ] ',
+      }
+    },
+    choices: newVars.map(v => ({ name: v.name, checked: true }))
+  });
+
+  return newVars.filter(v => selectedVars.includes(v.name));
+}
+
+/**
+ * Prompt for global/default variables to include
+ */
+export async function promptGlobalVariables(
+  globalVars: TemplateVariable[],
+  options: { yes?: boolean; json?: boolean } = {}
+): Promise<TemplateVariable[]> {
+  if (globalVars.length === 0) return [];
+  
+  if (options.yes || options.json) return globalVars;
+
+  const { selectedGlobals } = await inquirer.prompt({
+    type: 'checkbox',
+    name: 'selectedGlobals',
+    message: 'Select default/global variables to include (space to toggle):',
+    loop: false,
+    theme: {
+      icon: {
+        checked: chalk.green('[x] '),
+        unchecked: '[ ] ',
+      }
+    },
+    choices: globalVars.map(v => ({ name: v.name, checked: true }))
+  });
+
+  return globalVars.filter(v => selectedGlobals.includes(v.name));
+}
+
+/**
+ * Prompt for additional custom variables
+ */
+export async function promptAdditionalVariables(
+  existingVars: TemplateVariable[],
+  options: { yes?: boolean; json?: boolean } = {}
+): Promise<TemplateVariable[]> {
+  if (options.yes || options.json) return [];
+
+  const message = existingVars.length > 0 
+    ? `Existing variables: ${existingVars.map(v => v.name).join(', ')}. Define more?`
+    : 'Define template variables (e.g., client_name, project_type)?';
+
+  const { hasMore } = await inquirer.prompt({
+    type: 'confirm',
+    name: 'hasMore',
+    message,
+    default: false
+  });
+
+  if (!hasMore) return [];
+
+  const { variableDefs } = await inquirer.prompt({
+    type: 'input',
+    name: 'variableDefs',
+    message: 'Define additional variables as comma-separated names:'
+  });
+
+  if (!variableDefs) return [];
+
+  const additionalVars = variableDefs.split(',').map((v: string) => v.trim()).filter(Boolean);
+  return additionalVars
+    .filter((v: string) => !existingVars.some((existing: TemplateVariable) => existing.name === v))
+    .map((v: string) => ({ name: v, prompt: `Enter ${v}:`, required: true }));
+}
+
+/**
+ * Prompt for new folders (checkbox selection)
+ */
+export async function promptNewFolders(
+  newFolders: FolderNode[],
+  options: { yes?: boolean; json?: boolean } = {}
+): Promise<FolderNode[]> {
+  if (newFolders.length === 0) return [];
+  
+  if (options.yes || options.json) return newFolders;
+
+  console.log(chalk.cyan(`\n📊 New Folders:`));
+  console.log(chalk.green(`  + ${newFolders.length} new folder(s): ${newFolders.map(f => f.name).join(', ')}`));
+
+  const { selectedFolders } = await inquirer.prompt({
+    type: 'checkbox',
+    name: 'selectedFolders',
+    message: 'Select folders to include in template structure (space to toggle):',
+    loop: false,
+    theme: {
+      icon: {
+        checked: chalk.green('[x] '),
+        unchecked: '[ ] ',
+      }
+    },
+    choices: newFolders.map(f => ({ name: f.name, checked: true }))
+  });
+
+  return newFolders.filter(f => selectedFolders.includes(f.name));
+}
+
+/**
+ * Prompt for root files (checkbox selection)
+ */
+export async function promptRootFiles(
+  files: string[],
+  defaults: string[] = ['.makerc', 'readme.md', 'README.md', '.gitattributes', '.gitignore', 'Makefile', 'makefile', 'package.json'],
+  options: { yes?: boolean; json?: boolean } = {}
+): Promise<string[]> {
+  if (files.length === 0) return [];
+  
+  if (options.yes || options.json) {
+    return files.filter(f => defaults.some(d => f.toLowerCase() === d.toLowerCase()));
+  }
+
+  const { selectedFiles } = await inquirer.prompt({
+    type: 'checkbox',
+    name: 'selectedFiles',
+    message: 'Select root files to include as boilerplate:',
+    loop: false,
+    theme: {
+      icon: {
+        checked: chalk.green('[x] '),
+        unchecked: '[ ] ',
+      }
+    },
+    choices: files.map(f => ({
+      name: f,
+      checked: defaults.some(d => f.toLowerCase() === d.toLowerCase())
+    }))
+  });
+
+  return selectedFiles;
+}
+
+/**
+ * Prompt for folders in structure (checkbox selection)
+ */
+export async function promptStructureFolders(
+  dirs: string[],
+  options: { yes?: boolean; json?: boolean } = {}
+): Promise<string[]> {
+  if (dirs.length === 0) return [];
+  
+  if (options.yes || options.json) return dirs;
+
+  const { selectedStructure } = await inquirer.prompt({
+    type: 'checkbox',
+    name: 'selectedStructure',
+    message: 'Select folders to include in the template structure (skeleton):',
+    loop: false,
+    theme: {
+      icon: {
+        checked: chalk.green('[x] '),
+        unchecked: '[ ] ',
+      }
+    },
+    choices: dirs.map(d => ({ name: d, checked: true }))
+  });
+
+  return selectedStructure;
+}
+
+/**
+ * Prompt for folders to copy recursively (checkbox selection)
+ */
+export async function promptCopyFolders(
+  structureFolders: string[],
+  defaults: string[] = ['APP', 'scripts', 'bin'],
+  options: { yes?: boolean; json?: boolean } = {}
+): Promise<string[]> {
+  if (structureFolders.length === 0) return [];
+  
+  if (options.yes || options.json) {
+    return structureFolders.filter(d => defaults.includes(d));
+  }
+
+  const { selectedFolders } = await inquirer.prompt({
+    type: 'checkbox',
+    name: 'selectedFolders',
+    message: 'Select folders to copy RECURSIVELY as boilerplate (with contents):',
+    loop: false,
+    theme: {
+      icon: {
+        checked: chalk.green('[x] '),
+        unchecked: '[ ] ',
+      }
+    },
+    choices: structureFolders.map(d => ({
+      name: d,
+      checked: defaults.includes(d)
+    }))
+  });
+
+  return selectedFolders;
+}
+
+/**
+ * Prompt for post-config tasks
+ */
+export async function promptPostConfigTasks(
+  tasks: PostConfigTask[],
+  options: { yes?: boolean; json?: boolean; dryRun?: boolean } = {}
+): Promise<string[]> {
+  if (tasks.length === 0) return [];
+  
+  if (options.dryRun) return tasks.map(t => t.command || `./${t.script}` || '');
+  if (options.yes || options.json) return tasks.map(t => t.command || `./${t.script}` || '');
+
+  const choices = tasks.map(t => ({
+    name: `${t.command || `./${t.script}` || '(no command)'}${t.description ? ` (${t.description})` : ''}`,
+    value: t.command || `./${t.script}` || '',
+    checked: true
+  }));
+
+  const { selected } = await inquirer.prompt({
+    type: 'checkbox',
+    name: 'selected',
+    message: 'Select post-config tasks to run:',
+    loop: false,
+    theme: {
+      icon: {
+        checked: chalk.green('[x] '),
+        unchecked: '[ ] ',
+      }
+    },
+    choices
+  });
+
+  return selected || [];
+}
+
+/**
+ * Prompt to add detected executables to post_copy
+ */
+export async function promptAddPostCopy(
+  executables: string[],
+  options: { yes?: boolean; json?: boolean } = {}
+): Promise<boolean> {
+  if (executables.length === 0) return false;
+  if (options.yes || options.json) return true;
+
+  const { addPostCopy } = await inquirer.prompt({
+    type: 'confirm',
+    name: 'addPostCopy',
+    message: 'Add these to post_copy (auto-chmod)?',
+    default: true
+  });
+  return addPostCopy;
+}
+
+/**
+ * Print new files detection message
+ */
+export function printNewFiles(fileCount: number, fileNames: string[]): void {
+  if (fileCount > 0) {
+    console.log(chalk.cyan(`\n📊 New Files:`));
+    console.log(chalk.green(`  + ${fileCount} new file(s): ${fileNames.join(', ')}`));
+  } else {
+    console.log(chalk.cyan("No new files detected"));
+  }
+}
+
+/**
+ * Print no new folders message
+ */
+export function printNoNewFolders(): void {
+  console.log(chalk.cyan("No new folders detected"));
+}
+
+/**
+ * Print no new variables message
+ */
+export function printNoNewVariables(): void {
+  console.log(chalk.cyan("No new variables detected"));
+}
+
+/**
+ * Prompt for new files (checkbox selection)
+ */
+export async function promptNewFiles(
+  newFiles: string[],
+  options: { yes?: boolean; json?: boolean } = {}
+): Promise<string[]> {
+  if (newFiles.length === 0) return [];
+  
+  if (options.yes || options.json) return newFiles;
+
+  const { selectedFileChoices } = await inquirer.prompt({
+    type: 'checkbox',
+    name: 'selectedFileChoices',
+    message: 'Select files to include (space to toggle):',
+    loop: false,
+    theme: {
+      icon: {
+        checked: chalk.green('[x] '),
+        unchecked: '[ ] ',
+      }
+    },
+    choices: newFiles.map(f => ({ name: f, checked: true }))
+  });
+
+  return newFiles.filter(f => selectedFileChoices.includes(f));
+}