task-pipeliner 0.2.2 → 0.2.3

package/dist/core/executor.d.ts

@@ -1,172 +0,0 @@
-import type { Workflow } from '../types/workflow';
-import { Workspace } from './workspace';
-/**
- * Workflow Executor
- *
- * This class executes workflow steps sequentially, handling:
- * - Step execution (run, choose, prompt, parallel, fail)
- * - Condition evaluation (when clauses)
- * - Variable substitution
- * - Parallel execution with workspace cloning
- * - Error handling and reporting
- */
-export interface ExecutionContext {
-    workspace: Workspace;
-    stepIndex: number;
-    branchIndex?: number;
-    lineNumber?: number;
-    fileName?: string;
-}
-export declare class Executor {
-    private static readonly PARALLEL_STEP_INDEX_MULTIPLIER;
-    private workspace;
-    private taskRunner;
-    private choicePrompt;
-    private textPrompt;
-    private baseDir?;
-    constructor();
-    /**
-     * Resolve baseDir path from workflow configuration
-     *
-     * baseDir determines where commands will be executed:
-     * - If absolute path: use as-is
-     * - If relative path: resolve relative to YAML file location
-     * - If no _filePath: resolve relative to current working directory
-     */
-    private resolveBaseDir;
-    /**
-     * Create execution context for a step
-     *
-     * Context contains information needed to execute a step:
-     * - Workspace reference (for storing/reading state)
-     * - Step index (for tracking which step we're on)
-     * - Line number and file name (for error reporting)
-     */
-    private createStepContext;
-    /**
-     * Evaluate step condition and return whether step should execute
-     */
-    private evaluateStepCondition;
-    /**
-     * Calculate base step index for parallel execution
-     * When in parallel, stepIndex is encoded as: baseStepIndex * MULTIPLIER + branchIndex
-     * So we divide by MULTIPLIER to get the original step index
-     */
-    private calculateBaseStepIndex;
-    /**
-     * Execute workflow steps sequentially
-     *
-     * Main entry point for workflow execution:
-     * 1. Resolve baseDir for command execution
-     * 2. Loop through each step
-     * 3. Evaluate conditions (when clauses)
-     * 4. Execute step if condition passes
-     * 5. Check for failures and handle errors
-     */
-    execute(workflow: Workflow): Promise<void>;
-    /**
-     * Check if step result indicates success
-     */
-    private isStepSuccessful;
-    /**
-     * Fix malformed step (YAML indentation issue)
-     * When choose/prompt is null but properties exist at step level
-     * This happens when YAML is incorrectly indented
-     */
-    private fixMalformedStep;
-    /**
-     * Execute a single step based on its type
-     *
-     * Steps can be:
-     * - run: Execute a shell command
-     * - choose: Show user a choice menu
-     * - prompt: Ask user for text input
-     * - parallel: Execute multiple steps in parallel
-     * - fail: Intentionally fail with a message
-     *
-     * @param bufferOutput - If true, collect output instead of displaying immediately (for parallel)
-     * @param hasWhenCondition - If true, step has a condition (affects UI color)
-     */
-    private executeStep;
-    /**
-     * Execute a run step (shell command)
-     *
-     * Steps:
-     * 1. Calculate base step index (for parallel execution)
-     * 2. Substitute variables in command ({{variable}} syntax)
-     * 3. Run command via TaskRunner (with retry logic if specified)
-     * 4. Store result in workspace
-     */
-    private executeRunStep;
-    /**
-     * Execute a choose step (show user a selection menu)
-     *
-     * User selects from options, and the choice is stored:
-     * - As a choice (for when: { choice: 'id' } conditions) - uses choice id
-     * - As a variable (for {{variable}} substitution) - uses 'as' field if provided, otherwise choice id
-     */
-    private executeChooseStep;
-    /**
-     * Execute a prompt step (ask user for text input)
-     *
-     * User enters text, which is stored:
-     * - As a variable (for {{variable}} substitution)
-     * - As a fact (for when: { var: 'name' } conditions)
-     */
-    private executePromptStep;
-    /**
-     * Create execution contexts for parallel branches
-     * Encodes branch index into stepIndex: baseStepIndex * MULTIPLIER + branchIndex
-     * Each branch inherits line number and file name from the parallel step
-     */
-    private createParallelContexts;
-    /**
-     * Get display name for a parallel branch step
-     */
-    private getBranchDisplayName;
-    /**
-     * Execute all parallel branches simultaneously
-     *
-     * Each branch:
-     * 1. Has its own workspace clone (isolated state)
-     * 2. Evaluates its own conditions
-     * 3. Executes in buffer mode (collects output, don't display yet)
-     * 4. Returns result or error
-     *
-     * All branches run at the same time using Promise.all()
-     * Uses log-update to show all branch statuses in real-time
-     */
-    private executeParallelBranches;
-    /**
-     * Update parallel branches display using log-update
-     */
-    private updateParallelBranchesDisplay;
-    /**
-     * Display parallel execution results
-     * Status display is already done, now we show the detailed output
-     */
-    private displayParallelResults;
-    /**
-     * Merge facts and variables from parallel branches
-     */
-    private mergeParallelResults;
-    /**
-     * Count how many branches will actually execute (after when condition evaluation)
-     */
-    private countExecutableBranches;
-    /**
-     * Execute a parallel step (run multiple steps simultaneously)
-     *
-     * Process:
-     * 1. Create isolated contexts for each branch (with cloned workspaces)
-     * 2. Count how many branches will actually execute
-     * 3. Show header box with actual executable branch count
-     * 4. Execute all branches in parallel
-     * 5. Display results
-     * 6. Merge facts and variables from all branches back to main workspace
-     * 7. Throw error if any branch failed
-     */
-    private executeParallelStep;
-    private executeFailStep;
-}
-//# sourceMappingURL=executor.d.ts.map

package/dist/core/executor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../src/core/executor.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAQ,QAAQ,EAAsC,MAAM,mBAAmB,CAAC;AAK5F,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC;;;;;;;;;GASG;AACH,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,SAAS,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,qBAAa,QAAQ;IAGnB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,8BAA8B,CAAQ;IAE9D,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,OAAO,CAAC,CAAS;;IASzB;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc;IAoBtB;;;;;;;OAOG;IACH,OAAO,CAAC,iBAAiB;IAkBzB;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAS7B;;;;OAIG;IACH,OAAO,CAAC,sBAAsB;IAO9B;;;;;;;;;OASG;IACG,OAAO,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAuDhD;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAaxB;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAoCxB;;;;;;;;;;;;OAYG;YACW,WAAW;IAyCzB;;;;;;;;OAQG;YACW,cAAc;IA4D5B;;;;;;OAMG;YACW,iBAAiB;IA0B/B;;;;;;OAMG;YACW,iBAAiB;IAmB/B;;;;OAIG;IACH,OAAO,CAAC,sBAAsB;IAa9B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAgB5B;;;;;;;;;;;OAWG;YACW,uBAAuB;IA8FrC;;OAEG;IACH,OAAO,CAAC,6BAA6B;IA8CrC;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IA2D9B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAc5B;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAmB/B;;;;;;;;;;;OAWG;YACW,mBAAmB;YAmCnB,eAAe;CAS9B"}