wiggum-cli 0.1.0

package/src/generator/index.ts

@@ -0,0 +1,227 @@
+/**
+ * Generator Orchestrator
+ * Main entry point for generating ralph configuration files
+ */
+
+import { join } from 'node:path';
+import type { ScanResult } from '../scanner/types.js';
+import {
+  extractVariables,
+  processAllTemplates,
+  getTemplatesDir,
+  type TemplateVariables,
+} from './templates.js';
+import { generateConfig, generateConfigFile, type RalphConfig } from './config.js';
+import {
+  writeFiles,
+  createDirectoryStructure,
+  mapTemplateOutputPaths,
+  formatWriteSummary,
+  type WriteOptions,
+  type WriteSummary,
+  DEFAULT_WRITE_OPTIONS,
+} from './writer.js';
+
+// Re-export types and utilities
+export type { TemplateVariables } from './templates.js';
+export type { RalphConfig } from './config.js';
+export type { WriteOptions, WriteSummary, WriteResult } from './writer.js';
+export {
+  extractVariables,
+  processTemplate,
+  processTemplateFile,
+  getTemplatesDir,
+} from './templates.js';
+export { generateConfig, generateConfigFile } from './config.js';
+export { writeFileWithOptions, formatWriteSummary, DEFAULT_WRITE_OPTIONS } from './writer.js';
+
+/**
+ * Options for the generator
+ */
+export interface GeneratorOptions {
+  /** Custom variables to add/override */
+  customVariables?: Record<string, string>;
+  /** How to handle existing files */
+  existingFiles?: 'backup' | 'skip' | 'overwrite';
+  /** Whether to generate config file */
+  generateConfig?: boolean;
+  /** Verbose output */
+  verbose?: boolean;
+}
+
+/**
+ * Default generator options
+ */
+const DEFAULT_GENERATOR_OPTIONS: GeneratorOptions = {
+  customVariables: {},
+  existingFiles: 'backup',
+  generateConfig: true,
+  verbose: false,
+};
+
+/**
+ * Result of generation
+ */
+export interface GenerationResult {
+  /** Whether generation was successful */
+  success: boolean;
+  /** Template variables used */
+  variables: TemplateVariables;
+  /** Generated config */
+  config?: RalphConfig;
+  /** Write summary */
+  writeSummary: WriteSummary;
+  /** Errors encountered */
+  errors: string[];
+  /** Time taken in milliseconds */
+  generationTime: number;
+}
+
+/**
+ * Main Generator class
+ */
+export class Generator {
+  private options: GeneratorOptions;
+
+  constructor(options: GeneratorOptions = {}) {
+    this.options = { ...DEFAULT_GENERATOR_OPTIONS, ...options };
+  }
+
+  /**
+   * Generate all ralph files from scan result
+   */
+  async generate(scanResult: ScanResult): Promise<GenerationResult> {
+    const startTime = Date.now();
+    const errors: string[] = [];
+
+    // Extract variables from scan result
+    const variables = extractVariables(scanResult, this.options.customVariables || {});
+
+    // Get templates directory
+    const templatesDir = getTemplatesDir();
+
+    // Process all templates
+    let processedTemplates: Map<string, string>;
+    try {
+      processedTemplates = await processAllTemplates(templatesDir, variables);
+    } catch (error) {
+      errors.push(`Failed to process templates: ${error instanceof Error ? error.message : String(error)}`);
+      return {
+        success: false,
+        variables,
+        writeSummary: {
+          total: 0,
+          created: 0,
+          backedUp: 0,
+          skipped: 0,
+          overwritten: 0,
+          errors: 1,
+          results: [],
+        },
+        errors,
+        generationTime: Date.now() - startTime,
+      };
+    }
+
+    // Generate config if requested
+    let config: RalphConfig | undefined;
+    if (this.options.generateConfig) {
+      config = generateConfig(scanResult, this.options.customVariables || {});
+      const configContent = generateConfigFile(config);
+      processedTemplates.set('config/ralph.config.js', configContent);
+    }
+
+    // Map template outputs to final paths
+    const mappedOutputs = mapTemplateOutputPaths(processedTemplates);
+
+    // Create directory structure
+    try {
+      await createDirectoryStructure(scanResult.projectRoot);
+    } catch (error) {
+      errors.push(`Failed to create directory structure: ${error instanceof Error ? error.message : String(error)}`);
+    }
+
+    // Write all files
+    const writeOptions: WriteOptions = {
+      existingFiles: this.options.existingFiles || 'backup',
+      createBackups: this.options.existingFiles === 'backup',
+      verbose: this.options.verbose || false,
+    };
+
+    const writeSummary = await writeFiles(mappedOutputs, scanResult.projectRoot, writeOptions);
+
+    // Add any write errors to errors list
+    for (const result of writeSummary.results) {
+      if (result.action === 'error' && result.error) {
+        errors.push(`Failed to write ${result.path}: ${result.error}`);
+      }
+    }
+
+    const generationTime = Date.now() - startTime;
+
+    return {
+      success: errors.length === 0,
+      variables,
+      config,
+      writeSummary,
+      errors,
+      generationTime,
+    };
+  }
+}
+
+/**
+ * Convenience function to generate ralph files
+ */
+export async function generateRalph(
+  scanResult: ScanResult,
+  options: GeneratorOptions = {}
+): Promise<GenerationResult> {
+  const generator = new Generator(options);
+  return generator.generate(scanResult);
+}
+
+/**
+ * Format generation result for display
+ */
+export function formatGenerationResult(result: GenerationResult): string {
+  const lines: string[] = [];
+
+  if (result.success) {
+    lines.push('Generation completed successfully!');
+  } else {
+    lines.push('Generation completed with errors.');
+  }
+
+  lines.push(`Time: ${result.generationTime}ms`);
+  lines.push('');
+
+  // Show stack info
+  lines.push('Detected Stack:');
+  lines.push(`  Framework: ${result.variables.framework}${result.variables.frameworkVersion ? ' ' + result.variables.frameworkVersion : ''}`);
+  lines.push(`  Package Manager: ${result.variables.packageManager}`);
+  if (result.variables.unitTest !== 'none') {
+    lines.push(`  Unit Testing: ${result.variables.unitTest}`);
+  }
+  if (result.variables.e2eTest !== 'none') {
+    lines.push(`  E2E Testing: ${result.variables.e2eTest}`);
+  }
+  if (result.variables.styling !== 'css') {
+    lines.push(`  Styling: ${result.variables.styling}`);
+  }
+  lines.push('');
+
+  // Show write summary
+  lines.push(formatWriteSummary(result.writeSummary));
+
+  // Show errors
+  if (result.errors.length > 0) {
+    lines.push('');
+    lines.push('Errors:');
+    for (const error of result.errors) {
+      lines.push(`  - ${error}`);
+    }
+  }
+
+  return lines.join('\n');
+}

package/src/generator/templates.ts

@@ -0,0 +1,412 @@
+/**
+ * Template Processing System
+ * Reads template files with {{variable}} placeholders and substitutes values
+ */
+
+import { readFile, readdir, stat } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import type { ScanResult, DetectedStack } from '../scanner/types.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Template variables available for substitution
+ */
+export interface TemplateVariables {
+  // Project info
+  projectName: string;
+  projectRoot: string;
+
+  // Framework info
+  framework: string;
+  frameworkVersion: string;
+  frameworkVariant: string;
+
+  // Package manager
+  packageManager: string;
+  packageManagerVersion: string;
+
+  // Testing
+  unitTest: string;
+  unitTestVersion: string;
+  e2eTest: string;
+  e2eTestVersion: string;
+
+  // Styling
+  styling: string;
+  stylingVersion: string;
+  stylingVariant: string;
+
+  // Commands (derived from package manager)
+  devCommand: string;
+  buildCommand: string;
+  testCommand: string;
+  lintCommand: string;
+  typecheckCommand: string;
+  formatCommand: string;
+
+  // Paths
+  appDir: string;
+
+  // Custom variables
+  [key: string]: string;
+}
+
+/**
+ * Default template variables
+ */
+const DEFAULT_VARIABLES: Partial<TemplateVariables> = {
+  framework: 'unknown',
+  frameworkVersion: '',
+  frameworkVariant: '',
+  packageManager: 'npm',
+  packageManagerVersion: '',
+  unitTest: 'none',
+  unitTestVersion: '',
+  e2eTest: 'none',
+  e2eTestVersion: '',
+  styling: 'css',
+  stylingVersion: '',
+  stylingVariant: '',
+  appDir: 'app',
+};
+
+/**
+ * Derive commands from package manager
+ */
+function deriveCommands(packageManager: string): Pick<
+  TemplateVariables,
+  'devCommand' | 'buildCommand' | 'testCommand' | 'lintCommand' | 'typecheckCommand' | 'formatCommand'
+> {
+  const pm = packageManager.toLowerCase();
+  const run = pm === 'npm' ? 'npm run' : pm;
+
+  return {
+    devCommand: `${run} dev`,
+    buildCommand: `${run} build`,
+    testCommand: pm === 'npm' ? 'npm test' : `${pm} test`,
+    lintCommand: `${run} lint`,
+    typecheckCommand: pm === 'npm' ? 'npx tsc --noEmit' : `${pm} tsc --noEmit`,
+    formatCommand: pm === 'npm' ? 'npx prettier --write .' : `${pm} prettier --write .`,
+  };
+}
+
+/**
+ * Extract template variables from scan result
+ */
+export function extractVariables(scanResult: ScanResult, customVars: Record<string, string> = {}): TemplateVariables {
+  const { stack, projectRoot } = scanResult;
+
+  // Extract project name from path
+  const projectName = projectRoot.split('/').pop() || 'project';
+
+  // Extract framework info
+  const framework = stack.framework?.name || DEFAULT_VARIABLES.framework!;
+  const frameworkVersion = stack.framework?.version || DEFAULT_VARIABLES.frameworkVersion!;
+  const frameworkVariant = stack.framework?.variant || DEFAULT_VARIABLES.frameworkVariant!;
+
+  // Extract package manager info
+  const packageManager = stack.packageManager?.name || DEFAULT_VARIABLES.packageManager!;
+  const packageManagerVersion = stack.packageManager?.version || DEFAULT_VARIABLES.packageManagerVersion!;
+
+  // Extract testing info
+  const unitTest = stack.testing?.unit?.name || DEFAULT_VARIABLES.unitTest!;
+  const unitTestVersion = stack.testing?.unit?.version || DEFAULT_VARIABLES.unitTestVersion!;
+  const e2eTest = stack.testing?.e2e?.name || DEFAULT_VARIABLES.e2eTest!;
+  const e2eTestVersion = stack.testing?.e2e?.version || DEFAULT_VARIABLES.e2eTestVersion!;
+
+  // Extract styling info
+  const styling = stack.styling?.name || DEFAULT_VARIABLES.styling!;
+  const stylingVersion = stack.styling?.version || DEFAULT_VARIABLES.stylingVersion!;
+  const stylingVariant = stack.styling?.variant || DEFAULT_VARIABLES.stylingVariant!;
+
+  // Derive commands
+  const commands = deriveCommands(packageManager);
+
+  // Determine app directory
+  const appDir = frameworkVariant === 'app-router' || framework.toLowerCase().includes('next') ? 'app' : 'src';
+
+  return {
+    projectName,
+    projectRoot,
+    framework,
+    frameworkVersion,
+    frameworkVariant,
+    packageManager,
+    packageManagerVersion,
+    unitTest,
+    unitTestVersion,
+    e2eTest,
+    e2eTestVersion,
+    styling,
+    stylingVersion,
+    stylingVariant,
+    appDir,
+    ...commands,
+    ...customVars,
+  };
+}
+
+/**
+ * Check if a value is considered "truthy" for template conditionals
+ */
+function isTruthyValue(value: string | undefined): boolean {
+  return Boolean(value && value !== 'none' && value !== 'unknown' && value !== '');
+}
+
+/**
+ * Find matching closing tag for nested blocks
+ * Returns the index of the matching {{/tag}} or -1 if not found
+ */
+function findMatchingClose(content: string, openTag: string, closeTag: string, startIndex: number = 0): number {
+  let depth = 1;
+  let i = startIndex;
+
+  while (i < content.length && depth > 0) {
+    const openMatch = content.indexOf(openTag, i);
+    const closeMatch = content.indexOf(closeTag, i);
+
+    if (closeMatch === -1) {
+      return -1; // No more closing tags
+    }
+
+    if (openMatch !== -1 && openMatch < closeMatch) {
+      // Found another opening tag before the closing tag
+      depth++;
+      i = openMatch + openTag.length;
+    } else {
+      // Found a closing tag
+      depth--;
+      if (depth === 0) {
+        return closeMatch;
+      }
+      i = closeMatch + closeTag.length;
+    }
+  }
+
+  return -1;
+}
+
+/**
+ * Process a single if block (handles nesting via recursion)
+ */
+function processIfBlock(
+  template: string,
+  variables: TemplateVariables,
+  startIndex: number,
+  varName: string
+): { result: string; endIndex: number } {
+  const openTagEnd = template.indexOf('}}', startIndex) + 2;
+  const closeTag = '{{/if}}';
+
+  // Find the matching close tag (handling nesting)
+  let searchStart = openTagEnd;
+  let closeIndex = findMatchingClose(template, '{{#if', closeTag, searchStart);
+
+  if (closeIndex === -1) {
+    // No matching close, return as-is
+    return { result: template.slice(startIndex, openTagEnd), endIndex: openTagEnd };
+  }
+
+  const innerContent = template.slice(openTagEnd, closeIndex);
+
+  // Check for else clause (not inside nested if)
+  let elseIndex = -1;
+  let depth = 0;
+  for (let i = 0; i < innerContent.length; i++) {
+    if (innerContent.slice(i, i + 5) === '{{#if') {
+      depth++;
+    } else if (innerContent.slice(i, i + 7) === '{{/if}}') {
+      depth--;
+    } else if (depth === 0 && innerContent.slice(i, i + 8) === '{{else}}') {
+      elseIndex = i;
+      break;
+    }
+  }
+
+  const value = variables[varName as keyof TemplateVariables];
+  const isTruthy = isTruthyValue(value);
+
+  let selectedContent: string;
+  if (elseIndex !== -1) {
+    const ifPart = innerContent.slice(0, elseIndex);
+    const elsePart = innerContent.slice(elseIndex + 8);
+    selectedContent = isTruthy ? ifPart : elsePart;
+  } else {
+    selectedContent = isTruthy ? innerContent : '';
+  }
+
+  return { result: selectedContent, endIndex: closeIndex + closeTag.length };
+}
+
+/**
+ * Process conditional blocks in template
+ * Supports: {{#if variable}}...{{/if}} and {{#if variable}}...{{else}}...{{/if}}
+ * Handles nested conditionals correctly
+ */
+function processConditionals(template: string, variables: TemplateVariables): string {
+  let result = '';
+  let i = 0;
+
+  while (i < template.length) {
+    // Look for {{#if
+    const ifMatch = template.slice(i).match(/^\{\{#if\s+(\w+)\}\}/);
+    if (ifMatch) {
+      const varName = ifMatch[1];
+      const { result: blockResult, endIndex } = processIfBlock(template, variables, i, varName);
+      // Recursively process the content for nested conditionals
+      result += processConditionals(blockResult, variables);
+      i += endIndex - i;
+      continue;
+    }
+
+    // Look for {{#unless
+    const unlessMatch = template.slice(i).match(/^\{\{#unless\s+(\w+)\}\}/);
+    if (unlessMatch) {
+      const varName = unlessMatch[1];
+      const openTagEnd = i + unlessMatch[0].length;
+      const closeTag = '{{/unless}}';
+      const closeIndex = template.indexOf(closeTag, openTagEnd);
+
+      if (closeIndex !== -1) {
+        const innerContent = template.slice(openTagEnd, closeIndex);
+        const value = variables[varName as keyof TemplateVariables];
+        const isTruthy = isTruthyValue(value);
+
+        if (!isTruthy) {
+          result += processConditionals(innerContent, variables);
+        }
+        i = closeIndex + closeTag.length;
+        continue;
+      }
+    }
+
+    // Regular character, copy it
+    result += template[i];
+    i++;
+  }
+
+  return result;
+}
+
+/**
+ * Process variable substitution in template
+ * Supports: {{variable}} and {{variable || default}}
+ */
+function processVariables(template: string, variables: TemplateVariables): string {
+  // Process variables with defaults
+  const defaultRegex = /\{\{(\w+)\s*\|\|\s*([^}]+)\}\}/g;
+  let result = template.replace(defaultRegex, (_, varName, defaultValue) => {
+    const value = variables[varName as keyof TemplateVariables];
+    return value && value !== '' ? value : defaultValue.trim();
+  });
+
+  // Process simple variables
+  const varRegex = /\{\{(\w+)\}\}/g;
+  result = result.replace(varRegex, (_, varName) => {
+    const value = variables[varName as keyof TemplateVariables];
+    return value !== undefined ? value : '';
+  });
+
+  return result;
+}
+
+/**
+ * Process a template string with variable substitution
+ */
+export function processTemplate(template: string, variables: TemplateVariables): string {
+  // First process conditionals
+  let result = processConditionals(template, variables);
+
+  // Then substitute variables
+  result = processVariables(result, variables);
+
+  // Clean up multiple blank lines
+  result = result.replace(/\n{3,}/g, '\n\n');
+
+  return result;
+}
+
+/**
+ * Read and process a template file
+ */
+export async function processTemplateFile(templatePath: string, variables: TemplateVariables): Promise<string> {
+  const template = await readFile(templatePath, 'utf-8');
+  return processTemplate(template, variables);
+}
+
+/**
+ * Get the templates directory path
+ */
+export function getTemplatesDir(): string {
+  // In development (src), templates are at src/templates
+  // In production (dist), templates are at dist/templates
+  const srcTemplates = join(__dirname, '..', 'templates');
+  return srcTemplates;
+}
+
+/**
+ * Template file info
+ */
+export interface TemplateFile {
+  /** Source template path */
+  sourcePath: string;
+  /** Relative path from templates directory */
+  relativePath: string;
+  /** Output path (without .tmpl extension) */
+  outputPath: string;
+  /** Category (prompts, guides, specs, config) */
+  category: string;
+}
+
+/**
+ * Discover all template files
+ */
+export async function discoverTemplates(templatesDir: string): Promise<TemplateFile[]> {
+  const templates: TemplateFile[] = [];
+
+  async function scanDir(dir: string, category: string = ''): Promise<void> {
+    const entries = await readdir(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        await scanDir(fullPath, entry.name);
+      } else if (entry.name.endsWith('.tmpl')) {
+        const relativePath = fullPath.slice(templatesDir.length + 1);
+        const outputPath = relativePath.replace(/\.tmpl$/, '');
+
+        templates.push({
+          sourcePath: fullPath,
+          relativePath,
+          outputPath,
+          category,
+        });
+      }
+    }
+  }
+
+  await scanDir(templatesDir);
+  return templates;
+}
+
+/**
+ * Process all templates and return their contents
+ */
+export async function processAllTemplates(
+  templatesDir: string,
+  variables: TemplateVariables
+): Promise<Map<string, string>> {
+  const templates = await discoverTemplates(templatesDir);
+  const processed = new Map<string, string>();
+
+  for (const template of templates) {
+    const content = await processTemplateFile(template.sourcePath, variables);
+    processed.set(template.outputPath, content);
+  }
+
+  return processed;
+}