pipecraft 0.29.2 → 0.36.2

package/src/generators/workflows.tpl.ts

@@ -1,72 +1,70 @@
 /**
  * Workflows Template Generator
- * 
+ *
  * Main orchestrator for generating complete GitHub Actions CI/CD pipeline.
  * This generator creates all necessary workflow files including:
  * - Main pipeline workflow (path-based change detection)
  * - Reusable composite actions (tag creation, versioning, branch management, etc.)
- * 
+ *
  * The generator supports both initial generation and incremental updates, preserving
  * user modifications to existing workflows through intelligent merging.
- * 
+ *
  * @module generators/workflows.tpl
- * 
+ *
  * @example
  * ```typescript
  * import { generate } from './generators/workflows.tpl.js'
- * 
+ *
  * // Initial generation - creates all workflows
  * await generate({
  *   cwd: '/path/to/project',
  *   config: pipecraftConfig
  * })
- * 
+ *
  * // Incremental update - merges with existing pipeline
  * await generate({
  *   cwd: '/path/to/project',
  *   pipelinePath: '.github/workflows/pipeline.yml',
  *   config: pipecraftConfig
  * })
- * 
+ *
  * // Creates:
  * // .github/workflows/pipeline.yml         - Main pipeline
- * // .github/actions/detect-changes/...     - Change detection action
- * // .github/actions/calculate-version/...  - Version calculation action
- * // .github/actions/create-tag/...         - Tag creation action
- * // .github/actions/create-pr/...          - PR creation action
- * // .github/actions/manage-branch/...      - Branch management action
- * // .github/actions/promote-branch/...     - Branch promotion action
- * // .github/actions/create-release/...     - Release creation action
+ * // actions/detect-changes/...     - Change detection action
+ * // actions/calculate-version/...  - Version calculation action
+ * // actions/create-tag/...         - Tag creation action
+ * // actions/create-pr/...          - PR creation action
+ * // actions/manage-branch/...      - Branch management action
+ * // actions/promote-branch/...     - Branch promotion action
+ * // actions/create-release/...     - Release creation action
  * // .release-it.cjs                        - Release-it configuration
  * ```
  */
 
-import { PinionContext, toFile, renderTemplate, loadJSON, when } from '@featherscloud/pinion'
-import { IdempotencyManager } from '../utils/idempotency.js'
-import { PipecraftConfig } from '../types/index.js'
-import { readFileSync, existsSync } from 'fs'
+import { loadJSON, type PinionContext, renderTemplate, toFile, when } from '@featherscloud/pinion'
+import { existsSync, readFileSync } from 'fs'
 import { parse } from 'yaml'
-import { logger } from '../utils/logger.js'
-
+import { generate as generateVersionWorkflow } from '../templates/actions/calculate-version.yml.tpl.js'
+import { generate as generateCreatePRWorkflow } from '../templates/actions/create-pr.yml.tpl.js'
+import { generate as generateReleaseWorkflow } from '../templates/actions/create-release.yml.tpl.js'
 // Import individual workflow templates
 import { generate as generateTagWorkflow } from '../templates/actions/create-tag.yml.tpl.js'
 import { generate as generateChangesWorkflow } from '../templates/actions/detect-changes.yml.tpl.js'
-import { generate as generateChangesNxWorkflow } from '../templates/actions/detect-changes-nx.yml.tpl.js'
-import { generate as generateVersionWorkflow } from '../templates/actions/calculate-version.yml.tpl.js'
-import { generate as generateCreatePRWorkflow } from '../templates/actions/create-pr.yml.tpl.js'
 import { generate as generateBranchWorkflow } from '../templates/actions/manage-branch.yml.tpl.js'
 import { generate as generatePromoteBranchWorkflow } from '../templates/actions/promote-branch.yml.tpl.js'
-import { generate as generateReleaseWorkflow } from '../templates/actions/create-release.yml.tpl.js'
+import { generate as generateRunNxAffectedWorkflow } from '../templates/actions/run-nx-affected.yml.tpl.js'
+import { generate as generateReleaseItConfig } from '../templates/release-it.cjs.tpl.js'
+import { generate as generateEnforcePRTarget } from '../templates/workflows/enforce-pr-target.yml.tpl.js'
 import { generate as generatePathBasedPipeline } from '../templates/workflows/pipeline.yml.tpl.js'
 import { generate as generateNxPipeline } from '../templates/workflows/pipeline-nx.yml.tpl.js'
-import { generate as generateEnforcePRTarget } from '../templates/workflows/enforce-pr-target.yml.tpl.js'
 import { generate as generatePRTitleCheck } from '../templates/workflows/pr-title-check.yml.tpl.js'
-import { generate as generateReleaseItConfig } from '../templates/release-it.cjs.tpl.js'
+import { PipecraftConfig } from '../types/index.js'
+import { logger } from '../utils/logger.js'
 
 /**
  * Default fallback configuration when no config file exists.
  * Mirrors `defaultConfig` from init.tpl.ts to ensure consistent behavior.
- * 
+ *
  * @const
  * @see {@link module:generators/init.tpl~defaultConfig}
  */
@@ -94,22 +92,22 @@ const defaultConfig = {
 
 /**
  * Workflows generator main entry point.
- * 
+ *
  * Orchestrates the complete workflow generation process:
  * 1. Loads existing pipeline (if specified) for merging
  * 2. Merges configuration with defaults
  * 3. Generates all composite actions in parallel
  * 4. Generates the main pipeline workflow
- * 
+ *
  * @param {PinionContext & { pipelinePath?: string, outputPipelinePath?: string, config?: any }} ctx - Extended Pinion context
  * @param {string} [ctx.pipelinePath] - Path to existing pipeline for incremental updates
  * @param {string} [ctx.outputPipelinePath] - Custom output path for pipeline (defaults to .github/workflows/pipeline.yml)
  * @param {PipecraftConfig} [ctx.config] - PipeCraft configuration (overrides defaults)
  * @returns {Promise<PinionContext>} Updated context after workflow generation
- * 
+ *
  * @throws {Error} If workflow files cannot be written
  * @throws {Error} If existing pipeline cannot be parsed
- * 
+ *
  * @example
  * ```typescript
  * // Initial generation with config
@@ -121,7 +119,7 @@ const defaultConfig = {
  *     domains: { api: { paths: ['src/api/**'] } }
  *   }
  * })
- * 
+ *
  * // Update existing pipeline
  * await generate({
  *   cwd: '/path/to/project',
@@ -129,18 +127,20 @@ const defaultConfig = {
  *   config: updatedConfig
  * })
  * ```
- * 
+ *
  * @note The generator creates 9 files:
  * - 1 main workflow (pipeline.yml)
- * - 7 composite actions (in .github/actions/)
+ * - 7 composite actions (in actions/)
  * - 1 release-it configuration (.release-it.cjs)
- * 
+ *
  * All actions are generated in parallel for performance, followed by
  * the main pipeline which may reference the actions.
  */
-export const generate = (ctx: PinionContext & { pipelinePath?: string, outputPipelinePath?: string, config?: any }) =>
+export const generate = (
+  ctx: PinionContext & { pipelinePath?: string; outputPipelinePath?: string; config?: any }
+) =>
   Promise.resolve(ctx)
-    .then((ctx) => {
+    .then(ctx => {
       logger.info('🔧 Generating GitHub Actions...')
 
       // Load existing pipeline if provided
@@ -156,11 +156,20 @@ export const generate = (ctx: PinionContext & { pipelinePath?: string, outputPip
         }
       }
 
-      return { ...ctx, ...defaultConfig, ...ctx.config, ...ctx, existingPipeline, existingPipelineContent, outputPipelinePath: ctx.outputPipelinePath }
+      return {
+        ...ctx,
+        ...defaultConfig,
+        ...ctx.config,
+        ...ctx,
+        existingPipeline,
+        existingPipelineContent,
+        outputPipelinePath: ctx.outputPipelinePath
+      }
     })
-    .then((ctx) => {
+    .then(ctx => {
       // Generate individual GitHub Actions and release-it config
       const generators = [
+        // Unified detect-changes action works for all stacks
         generateChangesWorkflow(ctx),
         generateTagWorkflow(ctx),
         generateVersionWorkflow(ctx),
@@ -173,12 +182,12 @@ export const generate = (ctx: PinionContext & { pipelinePath?: string, outputPip
 
       // Add Nx-specific action if Nx is enabled
       if (ctx.config?.nx?.enabled) {
-        generators.push(generateChangesNxWorkflow(ctx))
+        generators.push(generateRunNxAffectedWorkflow(ctx))
       }
 
       return Promise.all(generators).then(() => ctx)
     })
-    .then((ctx) => {
+    .then(ctx => {
       // Generate the main pipeline (Nx or path-based)
       if (ctx.config?.nx?.enabled) {
         logger.info('🔧 Generating Nx-optimized pipeline...')
@@ -187,15 +196,15 @@ export const generate = (ctx: PinionContext & { pipelinePath?: string, outputPip
         return generatePathBasedPipeline(ctx)
       }
     })
-    .then((ctx) => {
+    .then(ctx => {
       // Generate the enforce PR target workflow
       return generateEnforcePRTarget(ctx)
     })
-    .then((ctx) => {
+    .then(ctx => {
       // Generate the PR title check workflow
       return generatePRTitleCheck(ctx)
     })
-    .then((ctx) => {
+    .then(ctx => {
       logger.success('✅ Generated workflows in: .github/workflows')
       return ctx
-    })
+    })

package/dist/templates/actions/detect-changes-nx.yml.tpl.d.ts

@@ -1,32 +0,0 @@
-/**
- * Detect Changes Nx Action Template
- *
- * Generates a GitHub composite action that detects which domains have changed
- * using Nx dependency graph analysis with path-based fallback.
- *
- * ## Purpose
- *
- * For Nx monorepos, this action uses `nx show projects --affected` to leverage
- * the dependency graph for intelligent change detection. It maps affected Nx
- * projects to configured domains and falls back to path-based detection when
- * Nx is unavailable.
- *
- * ## Generated Action Location
- *
- * `.github/actions/detect-changes-nx/action.yml`
- *
- * @module templates/actions/detect-changes-nx.yml.tpl
- */
-import { PinionContext } from '@featherscloud/pinion';
-/**
- * Generator entry point for detect-changes-nx composite action.
- *
- * Generates the `.github/actions/detect-changes-nx/action.yml` file with Nx-aware
- * change detection logic. This action is used by Nx-enabled pipelines.
- *
- * @param {PinionContext} ctx - Pinion generator context
- * @param {Record<string, DomainConfig>} ctx.domains - Domain configurations
- * @returns {Promise<PinionContext>} Updated context after file generation
- */
-export declare const generate: (ctx: PinionContext) => Promise<any>;
-//# sourceMappingURL=detect-changes-nx.yml.tpl.d.ts.map

package/dist/templates/actions/detect-changes-nx.yml.tpl.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"detect-changes-nx.yml.tpl.d.ts","sourceRoot":"","sources":["../../../src/templates/actions/detect-changes-nx.yml.tpl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,aAAa,EAA0B,MAAM,uBAAuB,CAAA;AAmN7E;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ,GAAI,KAAK,aAAa,iBAU+D,CAAA"}

package/dist/templates/actions/detect-changes-nx.yml.tpl.js

@@ -1,227 +0,0 @@
-/**
- * Detect Changes Nx Action Template
- *
- * Generates a GitHub composite action that detects which domains have changed
- * using Nx dependency graph analysis with path-based fallback.
- *
- * ## Purpose
- *
- * For Nx monorepos, this action uses `nx show projects --affected` to leverage
- * the dependency graph for intelligent change detection. It maps affected Nx
- * projects to configured domains and falls back to path-based detection when
- * Nx is unavailable.
- *
- * ## Generated Action Location
- *
- * `.github/actions/detect-changes-nx/action.yml`
- *
- * @module templates/actions/detect-changes-nx.yml.tpl
- */
-import { toFile, renderTemplate } from '@featherscloud/pinion';
-import fs from 'fs';
-import { logger } from '../../utils/logger.js';
-/**
- * Generates the detect-changes-nx composite action YAML content.
- *
- * Creates a GitHub Actions composite action that:
- * - Checks for Nx availability in the repository
- * - Uses `nx show projects --affected` for dependency graph analysis
- * - Maps affected projects to domains
- * - Falls back to path-based detection if Nx isn't available
- * - Outputs Nx-specific information (affected projects, Nx availability)
- *
- * @param {any} ctx - Context containing domains configuration
- * @param {Record<string, DomainConfig>} ctx.domains - Domain configurations with path patterns
- * @returns {string} YAML content for the composite action
- */
-const changesNxActionTemplate = (ctx) => {
-    const domainOutputs = Object.entries(ctx.domains).map((entry) => {
-        const [domainName, domainConfig] = entry;
-        return `  ${domainName}:
-    description: 'Whether ${domainName} domain has changes'
-    value: \${{ steps.merge.outputs.${domainName} }}`;
-    }).join('\n');
-    const domainFilters = Object.entries(ctx.domains).map((entry) => {
-        const [domainName, domainConfig] = entry;
-        return `          ${domainName}:\n            - '${domainConfig.paths.join("'\\n            - '")}'`;
-    }).join('\n');
-    // Generate Nx pattern matching logic for each domain
-    const domainNames = Object.keys(ctx.domains);
-    const nxPatternMatching = domainNames.map(domainName => {
-        return `              # Check ${domainName} domain patterns
-              if echo "$project" | grep -qE "(${domainName}|$(echo "${domainName}" | sed 's/-/[-_]/g'))"; then
-                ${domainName.toUpperCase()}_AFFECTED=true
-                echo "  ✅ $project matches ${domainName} domain"
-              fi`;
-    }).join('\n');
-    const nxFlagInit = domainNames.map(domainName => `            ${domainName.toUpperCase()}_AFFECTED=false`).join('\n');
-    const nxOutputs = domainNames.map(domainName => `            echo "${domainName}=$${domainName.toUpperCase()}_AFFECTED" >> $GITHUB_OUTPUT`).join('\n');
-    const nxFallbackOutputs = domainNames.map(domainName => `            echo "${domainName}=false" >> $GITHUB_OUTPUT`).join('\n');
-    const pathFilterOutputs = domainNames.map(domainName => `          echo "${domainName}=\${{ contains(steps.filter.outputs.changes, '${domainName}') }}" >> $GITHUB_OUTPUT`).join('\n');
-    const nxMergeOutputs = domainNames.map(domainName => `          echo "${domainName}=\${{ steps.nx-filter.outputs.${domainName} }}" >> $GITHUB_OUTPUT`).join('\n');
-    const resultEchoes = domainNames.map(domainName => `        echo "  ${domainName}: \${{ steps.merge.outputs.${domainName} }}"`).join('\n');
-    // Generate the composite action YAML
-    return `name: 'Detect Changes with Nx Support'
-description: 'Enhanced change detection using Nx dependency graph with path-based fallback'
-author: 'Pipecraft'
-
-inputs:
-  baseRef:
-    description: 'Base reference to compare against'
-    required: false
-    default: 'main'
-  useNx:
-    description: 'Whether to use Nx dependency graph for change detection'
-    required: false
-    default: 'true'
-
-outputs:
-${domainOutputs}
-  nxAvailable:
-    description: 'Whether Nx is available in the repository'
-    value: \${{ steps.nx-check.outputs.available }}
-  affectedProjects:
-    description: 'Comma-separated list of affected Nx projects'
-    value: \${{ steps.nx-filter.outputs.affectedProjects }}
-
-runs:
-  using: 'composite'
-  steps:
-    - name: Checkout Code
-      uses: actions/checkout@v4
-      with:
-        fetch-depth: 0
-
-    - name: Set Base Branch
-      id: set-base
-      shell: bash
-      run: |
-        base_branch=\${{ inputs.baseRef || 'main' }}
-        echo "base_branch=$base_branch" >> $GITHUB_OUTPUT
-        echo "base_branch=$base_branch" >> $GITHUB_ENV
-
-    - name: Check for Nx
-      id: nx-check
-      shell: bash
-      run: |
-        if [ -f "nx.json" ] || ([ -f "package.json" ] && grep -q '"nx"' package.json); then
-          echo "available=true" >> $GITHUB_OUTPUT
-          echo "🔍 Nx detected in repository"
-        else
-          echo "available=false" >> $GITHUB_OUTPUT
-          echo "⚠️  Nx not detected, falling back to path-based detection"
-        fi
-
-    - name: Setup Node.js
-      if: steps.nx-check.outputs.available == 'true' && inputs.useNx == 'true'
-      uses: actions/setup-node@v4
-      with:
-        node-version: '20'
-
-    - name: Install Dependencies
-      if: steps.nx-check.outputs.available == 'true' && inputs.useNx == 'true'
-      shell: bash
-      run: |
-        echo "📦 Installing dependencies for Nx..."
-        if [ -f "pnpm-lock.yaml" ]; then
-          corepack enable
-          pnpm install --frozen-lockfile || pnpm install
-        elif [ -f "yarn.lock" ]; then
-          yarn install --frozen-lockfile || yarn install
-        elif [ -f "package-lock.json" ]; then
-          npm ci || npm install
-        else
-          npm install
-        fi
-
-    - name: Detect Changes with Nx (if available)
-      id: nx-filter
-      if: steps.nx-check.outputs.available == 'true' && inputs.useNx == 'true'
-      shell: bash
-      run: |
-        echo "🚀 Using Nx dependency graph for change detection"
-
-        # Get affected projects using Nx
-        if command -v npx >/dev/null 2>&1; then
-          # Get list of affected projects (newline-separated)
-          AFFECTED_PROJECTS_RAW=$(npx nx show projects --affected --base=\${{ steps.set-base.outputs.base_branch }} 2>/dev/null || echo "")
-
-          # Convert newlines to commas for storage
-          AFFECTED_PROJECTS=$(echo "$AFFECTED_PROJECTS_RAW" | tr '\\n' ',' | sed 's/,$//')
-          echo "affectedProjects=$AFFECTED_PROJECTS" >> $GITHUB_OUTPUT
-
-          if [ -n "$AFFECTED_PROJECTS" ]; then
-            echo "📦 Affected Nx projects: $AFFECTED_PROJECTS"
-
-            # Initialize domain flags
-${nxFlagInit}
-
-            # Check each affected project against domain patterns (comma-separated)
-            IFS=',' read -ra PROJECTS <<< "$AFFECTED_PROJECTS"
-            for project in "\${PROJECTS[@]}"; do
-              project=$(echo "$project" | xargs) # trim whitespace
-${nxPatternMatching}
-            done
-
-            # Set outputs
-${nxOutputs}
-
-          else
-            echo "No affected projects detected"
-${nxFallbackOutputs}
-          fi
-        else
-          echo "⚠️  npx not available, falling back to path-based detection"
-${nxFallbackOutputs}
-          echo "affectedProjects=" >> $GITHUB_OUTPUT
-        fi
-
-    - name: Detect Changes with Paths Filter (fallback)
-      uses: dorny/paths-filter@v3
-      id: filter
-      if: steps.nx-check.outputs.available != 'true' || inputs.useNx != 'true'
-      with:
-        base: \${{ steps.set-base.outputs.base_branch }}
-        filters: |
-${domainFilters}
-
-    - name: Merge filter outputs
-      id: merge
-      shell: bash
-      run: |
-        # Use Nx results if available, otherwise use path filter results
-        if [ "\${{ steps.nx-check.outputs.available }}" == "true" ] && [ "\${{ inputs.useNx }}" == "true" ]; then
-${nxMergeOutputs}
-          echo "🔍 Using Nx dependency analysis results"
-          echo "📦 Affected projects: \${{ steps.nx-filter.outputs.affectedProjects }}"
-        else
-${pathFilterOutputs}
-          echo "📁 Using path-based change detection"
-        fi
-
-        echo "📋 Change Detection Results:"
-${resultEchoes}
-        echo "  nx-available: \${{ steps.nx-check.outputs.available }}"
-`;
-};
-/**
- * Generator entry point for detect-changes-nx composite action.
- *
- * Generates the `.github/actions/detect-changes-nx/action.yml` file with Nx-aware
- * change detection logic. This action is used by Nx-enabled pipelines.
- *
- * @param {PinionContext} ctx - Pinion generator context
- * @param {Record<string, DomainConfig>} ctx.domains - Domain configurations
- * @returns {Promise<PinionContext>} Updated context after file generation
- */
-export const generate = (ctx) => Promise.resolve(ctx)
-    .then((ctx) => {
-    // Check if file exists to determine merge status
-    const filePath = '.github/actions/detect-changes-nx/action.yml';
-    const exists = fs.existsSync(filePath);
-    const status = exists ? '🔄 Merged with existing' : '📝 Created new';
-    logger.verbose(`${status} ${filePath}`);
-    return ctx;
-})
-    .then(renderTemplate(changesNxActionTemplate, toFile('.github/actions/detect-changes-nx/action.yml')));
-//# sourceMappingURL=detect-changes-nx.yml.tpl.js.map

package/dist/templates/actions/detect-changes-nx.yml.tpl.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"detect-changes-nx.yml.tpl.js","sourceRoot":"","sources":["../../../src/templates/actions/detect-changes-nx.yml.tpl.ts"],"names":[],"mappings":"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"}

package/dist/utils/idempotency.d.ts

@@ -1,187 +0,0 @@
-/**
- * Idempotency and Caching Utilities
- *
- * This module implements intelligent caching to avoid unnecessary workflow regeneration.
- * It tracks file hashes and modification times for:
- * - Configuration files (.pipecraftrc.json)
- * - Template source files (src/templates/)
- * - Generator code (src/generators/)
- *
- * Workflows are only regenerated when relevant source files have changed,
- * significantly improving performance during iterative development.
- *
- * The cache is stored in `.pipecraft-cache.json` and contains hashes
- * of all tracked files along with metadata.
- *
- * @module utils/idempotency
- */
-import { PipecraftConfig } from '../types/index.js';
-/**
- * Metadata and hash information for a tracked file.
- */
-export interface FileHash {
-    /** Relative path to the file */
-    path: string;
-    /** Cryptographic hash of file content and metadata */
-    hash: string;
-    /** Last modification time (Unix timestamp in milliseconds) */
-    mtime: number;
-    /** File size in bytes */
-    size: number;
-}
-/**
- * Complete rebuild cache structure stored in .pipecraft-cache.json.
- *
- * This cache enables idempotent workflow generation by tracking when
- * configuration or template files change.
- */
-export interface RebuildCache {
-    /** Map of file paths to their hash metadata */
-    files: Record<string, FileHash>;
-    /** Hash of the configuration file (.pipecraftrc.json) */
-    configHash: string;
-    /** Timestamp when workflows were last generated */
-    lastGenerated: number;
-    /** Cache format version for future migration compatibility */
-    version: string;
-}
-/**
- * Manager for idempotent workflow generation through intelligent caching.
- *
- * This class tracks changes to configuration and template files to determine
- * when workflows need to be regenerated. It creates cryptographic hashes of
- * files and directories to detect changes efficiently.
- *
- * @example
- * ```typescript
- * const manager = new IdempotencyManager(config)
- *
- * if (await manager.hasChanges()) {
- *   // Generate workflows
- *   await generateWorkflows()
- *   // Update cache after successful generation
- *   await manager.updateCache()
- * } else {
- *   console.log('No changes detected, skipping regeneration')
- * }
- * ```
- */
-export declare class IdempotencyManager {
-    private cacheFile;
-    private config;
-    /**
-     * Create a new IdempotencyManager instance.
-     *
-     * @param config - PipeCraft configuration object
-     * @param cacheFile - Path to cache file (default: .pipecraft-cache.json)
-     */
-    constructor(config: PipecraftConfig, cacheFile?: string);
-    /**
-     * Calculate cryptographic hash for a file or directory.
-     *
-     * For files: Hashes content + mtime + size to detect any changes
-     * For directories: Recursively hashes all files within
-     *
-     * Returns empty string if the path doesn't exist.
-     *
-     * @param filePath - Path to file or directory to hash
-     * @param algorithm - Hashing algorithm (default: sha256)
-     * @returns Hex-encoded hash string
-     *
-     * @example
-     * ```typescript
-     * const configHash = await manager.calculateHash('.pipecraftrc.json')
-     * const templateHash = await manager.calculateHash('src/templates')
-     * ```
-     */
-    calculateHash(filePath: string, algorithm?: string): Promise<string>;
-    /**
-     * Hash directory contents recursively.
-     *
-     * Traverses all files in the directory tree and combines their hashes
-     * along with metadata into a single directory hash. This allows detecting
-     * when any file within the directory structure has changed.
-     *
-     * @param dirPath - Path to directory to hash
-     * @param algorithm - Hashing algorithm
-     * @returns Hex-encoded hash string representing the entire directory
-     * @private
-     */
-    private hashDirectory;
-    /**
-     * Load rebuild cache from filesystem.
-     *
-     * Reads and parses the cache file containing previous generation state.
-     * Returns null if cache doesn't exist or can't be parsed.
-     *
-     * @returns Parsed cache object or null if unavailable
-     */
-    loadCache(): RebuildCache | null;
-    /**
-     * Save rebuild cache to filesystem.
-     *
-     * Writes the cache object to disk as formatted JSON.
-     * Failures are logged as warnings but don't throw errors.
-     *
-     * @param cache - Cache object to persist
-     */
-    saveCache(cache: RebuildCache): void;
-    /**
-     * Check if any tracked files have changed since last generation.
-     *
-     * Compares current file hashes against cached values to detect changes in:
-     * - Configuration file (.pipecraftrc.json)
-     * - Template source files (src/templates/)
-     * - Generator code (src/generators/)
-     *
-     * Returns true if:
-     * - Rebuild is disabled (always regenerate)
-     * - Force regenerate flag is set
-     * - No cache exists
-     * - Any tracked file has changed
-     *
-     * @returns true if workflows should be regenerated
-     *
-     * @example
-     * ```typescript
-     * if (await manager.hasChanges()) {
-     *   console.log('Changes detected, regenerating workflows...')
-     *   await generateWorkflows()
-     *   await manager.updateCache()
-     * }
-     * ```
-     */
-    hasChanges(): Promise<boolean>;
-    /**
-     * Update cache with current file states after successful generation.
-     *
-     * Should be called after workflows are successfully generated to save
-     * the current state of all tracked files. This allows future runs to
-     * skip regeneration if nothing has changed.
-     *
-     * @example
-     * ```typescript
-     * await generateWorkflows()
-     * await manager.updateCache() // Save current state
-     * ```
-     */
-    updateCache(): Promise<void>;
-    /**
-     * Check if a specific file should be regenerated.
-     *
-     * Similar to hasChanges() but checks a single file instead of the
-     * entire project. Useful for selective regeneration.
-     *
-     * @param filePath - Path to file to check
-     * @returns true if file should be regenerated
-     *
-     * @example
-     * ```typescript
-     * if (await manager.shouldRegenerateFile('.github/workflows/pipeline.yml')) {
-     *   await generatePipeline()
-     * }
-     * ```
-     */
-    shouldRegenerateFile(filePath: string): Promise<boolean>;
-}
-//# sourceMappingURL=idempotency.d.ts.map

package/dist/utils/idempotency.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"idempotency.d.ts","sourceRoot":"","sources":["../../src/utils/idempotency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAKH,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAEnD;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAA;IAEZ,sDAAsD;IACtD,IAAI,EAAE,MAAM,CAAA;IAEZ,8DAA8D;IAC9D,KAAK,EAAE,MAAM,CAAA;IAEb,yBAAyB;IACzB,IAAI,EAAE,MAAM,CAAA;CACb;AAED;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,+CAA+C;IAC/C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;IAE/B,yDAAyD;IACzD,UAAU,EAAE,MAAM,CAAA;IAElB,mDAAmD;IACnD,aAAa,EAAE,MAAM,CAAA;IAErB,8DAA8D;IAC9D,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,MAAM,CAAiB;IAE/B;;;;;OAKG;gBACS,MAAM,EAAE,eAAe,EAAE,SAAS,SAA0B;IAKxE;;;;;;;;;;;;;;;;;OAiBG;IACG,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,GAAE,MAAiB,GAAG,OAAO,CAAC,MAAM,CAAC;IAqBpF;;;;;;;;;;;OAWG;YACW,aAAa;IA4B3B;;;;;;;OAOG;IACH,SAAS,IAAI,YAAY,GAAG,IAAI;IAchC;;;;;;;OAOG;IACH,SAAS,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAQpC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACG,UAAU,IAAI,OAAO,CAAC,OAAO,CAAC;IA2CpC;;;;;;;;;;;;OAYG;IACG,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAiClC;;;;;;;;;;;;;;;OAeG;IACG,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAuB/D"}