pipecraft 0.0.0-releaseit → 0.26.0

package/src/utils/idempotency.ts

@@ -1,215 +0,0 @@
-import { createHash } from 'crypto'
-import { readFileSync, existsSync, writeFileSync, statSync, rmSync } from 'fs'
-import { join } from 'path'
-import { PipecraftConfig } from '../types/index.js'
-
-export interface FileHash {
-  path: string
-  hash: string
-  mtime: number
-  size: number
-}
-
-export interface RebuildCache {
-  files: Record<string, FileHash>
-  configHash: string
-  lastGenerated: number
-  version: string
-}
-
-export class IdempotencyManager {
-  private cacheFile: string
-  private config: PipecraftConfig
-
-  constructor(config: PipecraftConfig, cacheFile = '.pipecraft-cache.json') {
-    this.config = config
-    this.cacheFile = cacheFile
-  }
-
-  /**
-   * Calculate hash for a file or directory
-   */
-  async calculateHash(filePath: string, algorithm: string = 'sha256'): Promise<string> {
-    if (!existsSync(filePath)) {
-      return ''
-    }
-
-    const stats = statSync(filePath)
-    if (stats.isDirectory()) {
-      // For directories, hash all files recursively
-      return await this.hashDirectory(filePath, algorithm)
-    } else {
-      // For files, hash content + metadata
-      const content = readFileSync(filePath)
-      const hash = createHash(algorithm)
-      hash.update(content)
-      hash.update(stats.mtime.toString())
-      hash.update(stats.size.toString())
-      return hash.digest('hex')
-    }
-  }
-
-  /**
-   * Hash directory contents recursively
-   */
-  private async hashDirectory(dirPath: string, algorithm: string): Promise<string> {
-    const fs = await import('fs')
-    const path = await import('path')
-    const hash = createHash(algorithm)
-    
-    const hashDir = (dir: string) => {
-      const items = fs.readdirSync(dir)
-      for (const item of items) {
-        const itemPath = path.join(dir, item)
-        const stats = fs.statSync(itemPath)
-        
-        if (stats.isDirectory()) {
-          hashDir(itemPath)
-        } else {
-          const content = fs.readFileSync(itemPath)
-          hash.update(content)
-          hash.update(stats.mtime.toString())
-          hash.update(stats.size.toString())
-        }
-      }
-    }
-    
-    hashDir(dirPath)
-    return hash.digest('hex')
-  }
-
-  /**
-   * Load rebuild cache from file
-   */
-  loadCache(): RebuildCache | null {
-    if (!existsSync(this.cacheFile)) {
-      return null
-    }
-
-    try {
-      const content = readFileSync(this.cacheFile, 'utf8')
-      return JSON.parse(content)
-    } catch (error: any) {
-      console.warn(`Failed to load cache file: ${error.message}`)
-      return null
-    }
-  }
-
-  /**
-   * Save rebuild cache to file
-   */
-  saveCache(cache: RebuildCache): void {
-    try {
-      writeFileSync(this.cacheFile, JSON.stringify(cache, null, 2))
-    } catch (error: any) {
-      console.warn(`Failed to save cache file: ${error.message}`)
-    }
-  }
-
-  /**
-   * Check if files have changed since last generation
-   */
-  async hasChanges(): Promise<boolean> {
-    if (!this.config.rebuild?.enabled) {
-      return true // Always regenerate if rebuild is disabled
-    }
-
-    if (this.config.rebuild?.forceRegenerate) {
-      return true // Force regeneration
-    }
-
-    const cache = this.loadCache()
-    if (!cache) {
-      return true // No cache, need to regenerate
-    }
-
-    // Check if config has changed
-    const configHash = await this.calculateHash('.pipecraftrc.json')
-    if (cache.configHash !== configHash) {
-      return true
-    }
-
-    // Check if template files have changed
-    const templateDir = 'src/templates'
-    if (existsSync(templateDir)) {
-      const templateHash = await this.calculateHash(templateDir)
-      if (cache.files[templateDir]?.hash !== templateHash) {
-        return true
-      }
-    }
-
-    // Check if source files have changed
-    const sourceDir = 'src/generators'
-    if (existsSync(sourceDir)) {
-      const sourceHash = await this.calculateHash(sourceDir)
-      if (cache.files[sourceDir]?.hash !== sourceHash) {
-        return true
-      }
-    }
-
-    return false
-  }
-
-  /**
-   * Update cache with current file states
-   */
-  async updateCache(): Promise<void> {
-    const cache: RebuildCache = {
-      files: {},
-      configHash: await this.calculateHash('.pipecraftrc.json'),
-      lastGenerated: Date.now(),
-      version: '1.0.0'
-    }
-
-    // Cache template files
-    const templateDir = 'src/templates'
-    if (existsSync(templateDir)) {
-      cache.files[templateDir] = {
-        path: templateDir,
-        hash: await this.calculateHash(templateDir),
-        mtime: statSync(templateDir).mtime.getTime(),
-        size: 0 // Directory size not meaningful
-      }
-    }
-
-    // Cache source files
-    const sourceDir = 'src/generators'
-    if (existsSync(sourceDir)) {
-      cache.files[sourceDir] = {
-        path: sourceDir,
-        hash: await this.calculateHash(sourceDir),
-        mtime: statSync(sourceDir).mtime.getTime(),
-        size: 0
-      }
-    }
-
-    this.saveCache(cache)
-  }
-
-  /**
-   * Check if specific file should be regenerated
-   */
-  async shouldRegenerateFile(filePath: string): Promise<boolean> {
-    if (!this.config.rebuild?.enabled) {
-      return true
-    }
-
-    if (this.config.rebuild?.forceRegenerate) {
-      return true
-    }
-
-    const cache = this.loadCache()
-    if (!cache) {
-      return true
-    }
-
-    const currentHash = await this.calculateHash(filePath)
-    const cachedFile = cache.files[filePath]
-    
-    if (!cachedFile) {
-      return true // File not in cache, needs generation
-    }
-
-    return cachedFile.hash !== currentHash
-  }
-}

package/src/utils/preflight.ts

@@ -1,306 +0,0 @@
-/**
- * Pre-flight checks for PipeCraft commands
- * Validates environment and prerequisites before executing commands
- */
-
-import { existsSync, mkdirSync, writeFileSync, unlinkSync } from 'fs'
-import { execSync } from 'child_process'
-import { join } from 'path'
-import { cosmiconfigSync } from 'cosmiconfig'
-
-export interface PreflightResult {
-  passed: boolean
-  message: string
-  suggestion?: string
-}
-
-export interface PreflightChecks {
-  configExists: PreflightResult
-  configValid: PreflightResult
-  inGitRepo: PreflightResult
-  hasGitRemote: PreflightResult
-  canWriteGithubDir: PreflightResult
-}
-
-/**
- * Check if config file exists using cosmiconfig
- * Searches for .pipecraftrc.json, .pipecraftrc, or package.json pipecraft key
- */
-export function checkConfigExists(): PreflightResult {
-  const explorer = cosmiconfigSync('pipecraft')
-  const result = explorer.search()
-
-  if (!result) {
-    return {
-      passed: false,
-      message: 'No PipeCraft configuration found',
-      suggestion: "Run 'pipecraft init' to create a configuration file"
-    }
-  }
-
-  return {
-    passed: true,
-    message: `Configuration found: ${result.filepath}`
-  }
-}
-
-/**
- * Check if config file is valid and has required fields
- */
-export function checkConfigValid(): PreflightResult {
-  const explorer = cosmiconfigSync('pipecraft')
-  const result = explorer.search()
-
-  if (!result) {
-    return {
-      passed: false,
-      message: 'No configuration file found',
-      suggestion: "Run 'pipecraft init' first"
-    }
-  }
-
-  try {
-    const config = result.config
-
-    // Check for required fields
-    const requiredFields = ['ciProvider', 'branchFlow', 'domains']
-    const missingFields = requiredFields.filter(field => !(field in config))
-
-    if (missingFields.length > 0) {
-      return {
-        passed: false,
-        message: `Config is missing required fields: ${missingFields.join(', ')}`,
-        suggestion: "Run 'pipecraft init --force' to recreate config"
-      }
-    }
-
-    // Check domains is not empty
-    if (!config.domains || Object.keys(config.domains).length === 0) {
-      return {
-        passed: false,
-        message: 'Config has no domains configured',
-        suggestion: "Add at least one domain to your config file"
-      }
-    }
-
-    return {
-      passed: true,
-      message: 'Configuration is valid'
-    }
-  } catch (error: any) {
-    if (error instanceof SyntaxError) {
-      return {
-        passed: false,
-        message: `Invalid JSON in config file: ${error.message}`,
-        suggestion: 'Fix JSON syntax in your config file'
-      }
-    }
-
-    return {
-      passed: false,
-      message: `Error reading config: ${error.message}`,
-      suggestion: 'Check file permissions for your config file'
-    }
-  }
-}
-
-/**
- * Check if current directory is a git repository
- */
-export function checkInGitRepo(): PreflightResult {
-  try {
-    execSync('git rev-parse --is-inside-work-tree', {
-      stdio: 'pipe',
-      encoding: 'utf8'
-    })
-
-    return {
-      passed: true,
-      message: 'Current directory is a git repository'
-    }
-  } catch (error) {
-    return {
-      passed: false,
-      message: 'Not in a git repository',
-      suggestion: "Initialize git: 'git init' or clone an existing repository"
-    }
-  }
-}
-
-/**
- * Check if git remote is configured
- */
-export function checkHasGitRemote(): PreflightResult {
-  try {
-    const remote = execSync('git remote get-url origin', {
-      stdio: 'pipe',
-      encoding: 'utf8'
-    }).trim()
-
-    if (!remote) {
-      return {
-        passed: false,
-        message: 'No git remote configured',
-        suggestion: "Add remote: 'git remote add origin <url>'"
-      }
-    }
-
-    // Check if it's a GitHub remote
-    const isGitHub = remote.includes('github.com')
-
-    return {
-      passed: true,
-      message: `Git remote configured: ${remote}`,
-      suggestion: !isGitHub
-        ? 'Note: PipeCraft is optimized for GitHub. GitLab support is experimental.'
-        : undefined
-    }
-  } catch (error) {
-    return {
-      passed: false,
-      message: 'No git remote named "origin"',
-      suggestion: "Add remote: 'git remote add origin <url>'"
-    }
-  }
-}
-
-/**
- * Check if .github directory is writable
- */
-export function checkCanWriteGithubDir(): PreflightResult {
-  const githubDir = '.github'
-  const workflowsDir = join(githubDir, 'workflows')
-
-  try {
-    if (!existsSync(githubDir)) {
-      // Try to create it
-      mkdirSync(githubDir, { recursive: true })
-      mkdirSync(workflowsDir, { recursive: true })
-
-      return {
-        passed: true,
-        message: 'Created .github/workflows directory'
-      }
-    }
-
-    // Directory exists, check if writable
-    if (existsSync(workflowsDir)) {
-      // Try to write a test file
-      const testFile = join(workflowsDir, '.pipecraft-test')
-      writeFileSync(testFile, 'test')
-      unlinkSync(testFile)
-
-      return {
-        passed: true,
-        message: '.github/workflows directory is writable'
-      }
-    } else {
-      mkdirSync(workflowsDir, { recursive: true })
-      return {
-        passed: true,
-        message: 'Created .github/workflows directory'
-      }
-    }
-  } catch (error: any) {
-    return {
-      passed: false,
-      message: `Cannot write to .github directory: ${error.message}`,
-      suggestion: 'Check directory permissions'
-    }
-  }
-}
-
-/**
- * Check Node.js version
- */
-export function checkNodeVersion(minVersion: string = '18.0.0'): PreflightResult {
-  const currentVersion = process.version.slice(1) // Remove 'v' prefix
-
-  const [currentMajor] = currentVersion.split('.').map(Number)
-  const [minMajor] = minVersion.split('.').map(Number)
-
-  if (currentMajor < minMajor) {
-    return {
-      passed: false,
-      message: `Node.js ${currentVersion} is too old (minimum: ${minVersion})`,
-      suggestion: 'Update Node.js: https://nodejs.org'
-    }
-  }
-
-  return {
-    passed: true,
-    message: `Node.js ${currentVersion} (>= ${minVersion})`
-  }
-}
-
-/**
- * Run all pre-flight checks for generate command
- * Note: No longer needs configPath - uses cosmiconfig to search automatically
- */
-export function runPreflightChecks(): PreflightChecks {
-  return {
-    configExists: checkConfigExists(),
-    configValid: checkConfigValid(),
-    inGitRepo: checkInGitRepo(),
-    hasGitRemote: checkHasGitRemote(),
-    canWriteGithubDir: checkCanWriteGithubDir()
-  }
-}
-
-/**
- * Format preflight results for display
- */
-export function formatPreflightResults(checks: PreflightChecks): {
-  allPassed: boolean
-  output: string
-  nextSteps?: string[]
-} {
-  const results: string[] = []
-  let allPassed = true
-
-  for (const [key, result] of Object.entries(checks)) {
-    const icon = result.passed ? '✅' : '❌'
-    results.push(`${icon} ${result.message}`)
-
-    if (!result.passed) {
-      allPassed = false
-      if (result.suggestion) {
-        results.push(`   💡 ${result.suggestion}`)
-      }
-    }
-  }
-
-  // Provide next steps if all checks passed
-  const nextSteps: string[] | undefined = allPassed ? [
-    'Your environment is ready to generate workflows!',
-    '',
-    'Next steps:',
-    '  1. Validate the pipeline: pipecraft validate:pipeline',
-    '  2. Set up GitHub tokens: pipecraft setup-github --verify',
-    '  3. Commit the generated workflows: git add .github && git commit -m "chore: add workflows"',
-    '  4. Push to remote: git push origin ' + getCurrentBranch(),
-    '',
-    '⚠️  Important: Set up GitHub tokens (step 2) BEFORE pushing to ensure workflows run correctly!'
-  ] : undefined
-
-  return {
-    allPassed,
-    output: results.join('\n'),
-    nextSteps
-  }
-}
-
-/**
- * Get current git branch name
- */
-function getCurrentBranch(): string {
-  try {
-    const branch = execSync('git branch --show-current', {
-      stdio: 'pipe',
-      encoding: 'utf8'
-    }).trim()
-    return branch || 'main'
-  } catch (error) {
-    return 'main'
-  }
-}