@generacy-ai/workflow-engine 0.0.0-preview-20260304013206

package/LICENSE

@@ -0,0 +1,191 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by the Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding any notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 The Generacy AI Authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,265 @@
+# @generacy-ai/workflow-engine
+
+Core workflow execution engine for Generacy. Provides workflow loading, validation, and execution with extensible action handlers.
+
+## Installation
+
+```bash
+npm install @generacy-ai/workflow-engine
+```
+
+## Features
+
+- **YAML Workflow Definitions**: Define workflows in easy-to-read YAML format
+- **Validation**: Zod-based schema validation with detailed error messages
+- **Interpolation**: Variable substitution with `${inputs.*}`, `${steps.*}`, `${env.*}`
+- **Retry System**: Configurable retry with constant, linear, and exponential backoff
+- **Action Handlers**: Extensible action system for custom integrations
+- **Event System**: Subscribe to execution events for monitoring
+- **Cancellation**: AbortController support for graceful cancellation
+
+## Usage
+
+### Loading and Executing a Workflow
+
+```typescript
+import {
+  loadWorkflow,
+  prepareWorkflow,
+  WorkflowExecutor,
+  registerBuiltinActions,
+  ConsoleLogger,
+} from '@generacy-ai/workflow-engine';
+
+// Register built-in action handlers
+registerBuiltinActions();
+
+// Load workflow from file
+const definition = await loadWorkflow('./workflow.yaml');
+
+// Prepare for execution
+const workflow = prepareWorkflow(definition);
+
+// Create executor
+const executor = new WorkflowExecutor({
+  logger: new ConsoleLogger(),
+});
+
+// Execute with inputs
+const result = await executor.execute(
+  workflow,
+  {
+    workdir: process.cwd(),
+    env: process.env,
+  },
+  {
+    projectName: 'my-project',
+  }
+);
+
+console.log('Status:', result.status);
+```
+
+### Workflow Definition Format
+
+```yaml
+name: build-and-test
+description: Build and test a Node.js project
+
+inputs:
+  nodeVersion:
+    type: string
+    default: "20"
+    description: Node.js version to use
+
+phases:
+  - name: setup
+    steps:
+      - name: install-deps
+        action: shell
+        command: npm ci
+        env:
+          NODE_VERSION: ${inputs.nodeVersion}
+
+  - name: test
+    steps:
+      - name: run-tests
+        action: verification.check
+        command: npm test
+        retry:
+          maxAttempts: 3
+          backoff: exponential
+          delay: 1s
+```
+
+### Custom Action Handlers
+
+```typescript
+import {
+  BaseAction,
+  registerActionHandler,
+  type ActionContext,
+  type ActionResult,
+  type StepDefinition,
+} from '@generacy-ai/workflow-engine';
+
+class MyCustomAction extends BaseAction {
+  readonly type = 'my.custom';
+
+  canHandle(step: StepDefinition): boolean {
+    return step.action === 'my.custom';
+  }
+
+  protected async executeInternal(
+    step: StepDefinition,
+    context: ActionContext
+  ): Promise<Omit<ActionResult, 'duration'>> {
+    const input = this.getInput<string>(step, context, 'message');
+
+    // Do something custom
+    context.logger.info(`Custom action: ${input}`);
+
+    return this.successResult({ processed: true });
+  }
+}
+
+// Register the handler
+registerActionHandler(new MyCustomAction());
+```
+
+### Event Subscription
+
+```typescript
+const executor = new WorkflowExecutor({ logger });
+
+executor.addEventListener((event) => {
+  switch (event.type) {
+    case 'workflow:start':
+      console.log(`Starting workflow: ${event.workflowName}`);
+      break;
+    case 'step:complete':
+      console.log(`Step completed: ${event.stepName}`);
+      break;
+    case 'workflow:error':
+      console.error(`Workflow failed: ${event.message}`);
+      break;
+  }
+});
+```
+
+### Interpolation
+
+The engine supports variable interpolation in step configurations:
+
+- `${inputs.name}` - Access workflow inputs
+- `${steps.stepName.output.field}` - Access output from previous steps
+- `${env.VAR_NAME}` - Access environment variables
+
+### Retry Configuration
+
+Steps can be configured with retry settings:
+
+```yaml
+retry:
+  maxAttempts: 5
+  backoff: exponential  # constant, linear, or exponential
+  delay: 1s             # Initial delay
+  maxDelay: 30s         # Maximum delay (for exponential)
+  jitter: true          # Add randomness to delays
+```
+
+## Built-in Actions
+
+- **shell**: Execute shell commands
+- **workspace.prepare**: Git checkout/branch operations
+- **agent.invoke**: Invoke Claude CLI for AI tasks
+- **verification.check**: Run tests and linting
+- **github.pr-create**: Create GitHub pull requests
+- **speckit.\***: Spec-driven development methodology operations
+
+### Speckit Actions
+
+The speckit action handler implements a spec-driven development methodology with the following operations:
+
+**Deterministic Operations** (direct library calls):
+- `speckit.create_feature` - Create feature branch and initialize spec directory
+- `speckit.get_paths` - Get feature directory paths from branch name
+- `speckit.check_prereqs` - Validate required spec files exist
+- `speckit.copy_template` - Copy template files to feature directory
+
+**AI-Dependent Operations** (agent delegation via Claude CLI):
+- `speckit.specify` - Generate spec.md from feature description
+- `speckit.clarify` - Generate clarification questions and post to issue
+- `speckit.plan` - Generate implementation plan from spec
+- `speckit.tasks` - Generate task list from plan
+- `speckit.implement` - Execute tasks with progress tracking
+
+**Example usage:**
+
+```yaml
+phases:
+  - name: setup
+    steps:
+      - name: create-feature
+        uses: speckit.create_feature
+        with:
+          description: "Add user authentication"
+
+  - name: specification
+    steps:
+      - name: specify
+        uses: speckit.specify
+        with:
+          feature_dir: ${{ steps.create-feature.output.feature_dir }}
+        gate: spec-review  # Optional review checkpoint
+
+  - name: planning
+    steps:
+      - name: plan
+        uses: speckit.plan
+        with:
+          feature_dir: ${{ steps.create-feature.output.feature_dir }}
+        gate: plan-review
+```
+
+**Gate Configuration:**
+
+Steps can include a `gate` field to pause workflow for human review:
+- `spec-review` - Review specification before proceeding
+- `plan-review` - Review implementation plan
+- `tasks-review` - Review task breakdown
+
+See `workflows/speckit-feature.yaml` for a complete example workflow.
+
+## API Reference
+
+### Main Exports
+
+```typescript
+// Executor
+export { WorkflowExecutor, ExecutionEventEmitter };
+
+// Loader
+export { loadWorkflow, loadWorkflowFromString, prepareWorkflow, validateWorkflow };
+
+// Actions
+export { registerActionHandler, getActionHandler, BaseAction };
+
+// Interpolation
+export { interpolate, ExecutionContext };
+
+// Retry
+export { RetryManager, withTimeout };
+
+// Types
+export type {
+  WorkflowDefinition,
+  ExecutionResult,
+  ActionHandler,
+  // ... and more
+};
+```
+
+## License
+
+MIT

package/dist/actions/base-action.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Abstract base action class implementing common functionality.
+ * Provides logging, timing, error wrapping, and shared utilities.
+ */
+import type { ActionHandler, ActionContext, ActionResult, ActionIdentifier, ValidationResult, StepDefinition } from '../types/index.js';
+/**
+ * Abstract base class for action handlers.
+ * Provides common functionality like timing, logging, and error handling.
+ */
+export declare abstract class BaseAction implements ActionHandler {
+    abstract readonly type: ActionIdentifier;
+    /**
+     * Check if this handler can process the given step
+     */
+    abstract canHandle(step: StepDefinition): boolean;
+    /**
+     * Internal execution implementation to be overridden by subclasses
+     */
+    protected abstract executeInternal(step: StepDefinition, context: ActionContext): Promise<Omit<ActionResult, 'duration'>>;
+    /**
+     * Execute the action with timing and error handling
+     */
+    execute(step: StepDefinition, context: ActionContext): Promise<ActionResult>;
+    /**
+     * Default validation implementation - can be overridden
+     */
+    validate(_step: StepDefinition): ValidationResult;
+    /**
+     * Helper to get step input with optional default
+     */
+    protected getInput<T>(step: StepDefinition, context: ActionContext, key: string, defaultValue?: T): T | undefined;
+    /**
+     * Helper to get required input, throwing if not present
+     */
+    protected getRequiredInput<T>(step: StepDefinition, context: ActionContext, key: string): T;
+    /**
+     * Helper to create a successful result
+     */
+    protected successResult(output: unknown, options?: {
+        stdout?: string;
+        stderr?: string;
+        exitCode?: number;
+        filesModified?: string[];
+    }): Omit<ActionResult, 'duration'>;
+    /**
+     * Helper to create a failure result
+     */
+    protected failureResult(error: string, options?: {
+        output?: unknown;
+        stdout?: string;
+        stderr?: string;
+        exitCode?: number;
+    }): Omit<ActionResult, 'duration'>;
+    /**
+     * Helper to check if signal is aborted (for long-running operations)
+     */
+    protected checkCancellation(context: ActionContext): void;
+    /**
+     * Helper to merge environment variables
+     */
+    protected mergeEnv(context: ActionContext, stepEnv?: Record<string, string>): Record<string, string>;
+}
+//# sourceMappingURL=base-action.d.ts.map

package/dist/actions/base-action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-action.d.ts","sourceRoot":"","sources":["../../src/actions/base-action.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EACV,aAAa,EACb,aAAa,EACb,YAAY,EACZ,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,EACf,MAAM,mBAAmB,CAAC;AAE3B;;;GAGG;AACH,8BAAsB,UAAW,YAAW,aAAa;IACvD,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAEzC;;OAEG;IACH,QAAQ,CAAC,SAAS,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO;IAEjD;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,eAAe,CAChC,IAAI,EAAE,cAAc,EACpB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,IAAI,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;IAE1C;;OAEG;IACG,OAAO,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAgDlF;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,cAAc,GAAG,gBAAgB;IAQjD;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,CAAC,EAClB,IAAI,EAAE,cAAc,EACpB,OAAO,EAAE,aAAa,EACtB,GAAG,EAAE,MAAM,EACX,YAAY,CAAC,EAAE,CAAC,GACf,CAAC,GAAG,SAAS;IAehB;;OAEG;IACH,SAAS,CAAC,gBAAgB,CAAC,CAAC,EAC1B,IAAI,EAAE,cAAc,EACpB,OAAO,EAAE,aAAa,EACtB,GAAG,EAAE,MAAM,GACV,CAAC;IAQJ;;OAEG;IACH,SAAS,CAAC,aAAa,CACrB,MAAM,EAAE,OAAO,EACf,OAAO,CAAC,EAAE;QACR,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;KAC1B,GACA,IAAI,CAAC,YAAY,EAAE,UAAU,CAAC;IAWjC;;OAEG;IACH,SAAS,CAAC,aAAa,CACrB,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE;QACR,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GACA,IAAI,CAAC,YAAY,EAAE,UAAU,CAAC;IAWjC;;OAEG;IACH,SAAS,CAAC,iBAAiB,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;IAMzD;;OAEG;IACH,SAAS,CAAC,QAAQ,CAChB,OAAO,EAAE,aAAa,EACtB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC/B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;CAO1B"}

package/dist/actions/base-action.js

@@ -0,0 +1,130 @@
+/**
+ * Abstract base class for action handlers.
+ * Provides common functionality like timing, logging, and error handling.
+ */
+export class BaseAction {
+    /**
+     * Execute the action with timing and error handling
+     */
+    async execute(step, context) {
+        const startTime = Date.now();
+        // Log action start
+        context.logger.info(`Starting action [${this.type}]: ${step.name}`);
+        try {
+            // Check for cancellation before execution
+            if (context.signal.aborted) {
+                return {
+                    success: false,
+                    output: null,
+                    error: 'Action cancelled before execution',
+                    duration: Date.now() - startTime,
+                };
+            }
+            // Execute the action
+            const result = await this.executeInternal(step, context);
+            const duration = Date.now() - startTime;
+            // Log completion
+            if (result.success) {
+                context.logger.info(`Action [${this.type}] completed successfully in ${duration}ms`);
+            }
+            else {
+                context.logger.error(`Action [${this.type}] failed: ${result.error ?? 'Unknown error'}`);
+            }
+            return {
+                ...result,
+                duration,
+            };
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            context.logger.error(`Action [${this.type}] threw error: ${errorMessage}`);
+            return {
+                success: false,
+                output: null,
+                error: errorMessage,
+                duration,
+            };
+        }
+    }
+    /**
+     * Default validation implementation - can be overridden
+     */
+    validate(_step) {
+        return {
+            valid: true,
+            errors: [],
+            warnings: [],
+        };
+    }
+    /**
+     * Helper to get step input with optional default
+     */
+    getInput(step, context, key, defaultValue) {
+        // Check step-level inputs first (from 'with' field in YAML)
+        const stepInputs = step.with;
+        if (stepInputs && key in stepInputs) {
+            return stepInputs[key];
+        }
+        // Check workflow-level inputs
+        if (key in context.inputs) {
+            return context.inputs[key];
+        }
+        return defaultValue;
+    }
+    /**
+     * Helper to get required input, throwing if not present
+     */
+    getRequiredInput(step, context, key) {
+        const value = this.getInput(step, context, key);
+        if (value === undefined) {
+            throw new Error(`Required input '${key}' not provided for step '${step.name}'`);
+        }
+        return value;
+    }
+    /**
+     * Helper to create a successful result
+     */
+    successResult(output, options) {
+        return {
+            success: true,
+            output,
+            exitCode: options?.exitCode ?? 0,
+            stdout: options?.stdout,
+            stderr: options?.stderr,
+            filesModified: options?.filesModified,
+        };
+    }
+    /**
+     * Helper to create a failure result
+     */
+    failureResult(error, options) {
+        return {
+            success: false,
+            output: options?.output ?? null,
+            error,
+            exitCode: options?.exitCode ?? 1,
+            stdout: options?.stdout,
+            stderr: options?.stderr,
+        };
+    }
+    /**
+     * Helper to check if signal is aborted (for long-running operations)
+     */
+    checkCancellation(context) {
+        if (context.signal.aborted) {
+            throw new Error('Action cancelled');
+        }
+    }
+    /**
+     * Helper to merge environment variables
+     */
+    mergeEnv(context, stepEnv) {
+        return {
+            ...process.env,
+            ...context.env,
+            ...stepEnv,
+        };
+    }
+}
+//# sourceMappingURL=base-action.js.map

package/dist/actions/base-action.js.map

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

package/dist/actions/builtin/agent-invoke.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Agent invoke action handler.
+ * Handles Claude CLI invocation for AI agent tasks.
+ */
+import { BaseAction } from '../base-action.js';
+import type { ActionContext, ActionResult, ActionType, ValidationResult, StepDefinition } from '../../types/index.js';
+/**
+ * Action handler for agent (Claude CLI) invocation
+ */
+export declare class AgentInvokeAction extends BaseAction {
+    readonly type: ActionType;
+    canHandle(step: StepDefinition): boolean;
+    validate(step: StepDefinition): ValidationResult;
+    protected executeInternal(step: StepDefinition, context: ActionContext): Promise<Omit<ActionResult, 'duration'>>;
+}
+//# sourceMappingURL=agent-invoke.d.ts.map

package/dist/actions/builtin/agent-invoke.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-invoke.d.ts","sourceRoot":"","sources":["../../../src/actions/builtin/agent-invoke.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,KAAK,EACV,aAAa,EACb,YAAY,EACZ,UAAU,EACV,gBAAgB,EAGhB,cAAc,EAGf,MAAM,sBAAsB,CAAC;AAI9B;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,UAAU;IAC/C,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAkB;IAE3C,SAAS,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO;IAIxC,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG,gBAAgB;cAsBhC,eAAe,CAC7B,IAAI,EAAE,cAAc,EACpB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,IAAI,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;CAwF3C"}