keystone-cli 0.1.0 → 0.2.0

package/src/templates/batch-processor.yaml

@@ -0,0 +1,43 @@
+name: batch-processor
+description: "Process multiple files in parallel"
+
+inputs:
+  target_dir: { type: string, default: "./data" }
+
+outputs:
+  processed_count: ${{ steps.process_files.outputs.length }}
+
+env:
+  API_KEY: ${{ secrets.API_KEY }}
+
+steps:
+  # 1. Dynamic Input Generation
+  - id: list_files
+    type: shell
+    run: "ls ${{ inputs.target_dir }}/*.txt"
+    # Extract stdout lines into an array
+    transform: "stdout.split('\\n').filter(Boolean)"
+
+  # 2. Matrix/Looping (The Missing Piece)
+  - id: process_files
+    type: llm
+    needs: [list_files]
+    # Iterates over the array from the previous step
+    foreach: ${{ steps.list_files.output }}
+    concurrency: 5
+    # Robustness (The Missing Piece)
+    retry:
+      count: 3
+      backoff: "exponential"
+    timeout: 30000 # 30s limit per item
+    # Step Definition
+    agent: summarizer
+    prompt: "Summarize this file: ${{ item }}"
+
+  # 3. Conditional Logic
+  - id: notify
+    type: request
+    needs: [process_files]
+    if: ${{ steps.process_files.items.every(s => s.status == 'success') }}
+    method: POST
+    url: "https://webhook.site/..."

package/src/templates/cleanup-finally.yaml

@@ -0,0 +1,22 @@
+name: cleanup-finally
+description: "Test the finally block"
+
+steps:
+  - id: step1
+    type: shell
+    run: echo "Main step 1"
+
+  - id: fail_step
+    type: shell
+    run: "exit 1"
+    if: ${{ inputs.should_fail }}
+
+finally:
+  - id: cleanup
+    type: shell
+    run: echo "Cleanup task executed"
+  
+  - id: cleanup_with_dep
+    type: shell
+    needs: [cleanup]
+    run: echo "Cleanup with dependency executed"

package/src/templates/composition-child.yaml

@@ -0,0 +1,13 @@
+name: composition-child
+description: "A simple child workflow"
+
+inputs:
+  name: { type: string }
+
+outputs:
+  result: "Hello from child, ${{ inputs.name }}!"
+
+steps:
+  - id: echo_step
+    type: shell
+    run: echo "Processing ${{ inputs.name }}"

package/src/templates/composition-parent.yaml

@@ -0,0 +1,14 @@
+name: composition-parent
+description: "A parent workflow that calls a child workflow"
+
+steps:
+  - id: run_child
+    type: workflow
+    path: "workflows/composition-child.yaml"
+    inputs:
+      name: "Keystone User"
+
+  - id: print_result
+    type: shell
+    needs: [run_child]
+    run: echo "Child workflow result - ${{ steps.run_child.outputs.result }}"

package/src/templates/data-pipeline.yaml

@@ -0,0 +1,38 @@
+name: data-pipeline
+description: "A workflow that demonstrates file operations and cleanup with 'finally'"
+
+inputs:
+  input_file: { type: string, default: "input.txt" }
+  output_file: { type: string, default: "output.txt" }
+
+steps:
+  - id: prepare_data
+    type: file
+    op: write
+    path: ${{ inputs.input_file }}
+    content: "line 1\nline 2\nline 3"
+
+  - id: read_data
+    type: file
+    op: read
+    path: ${{ inputs.input_file }}
+    needs: [prepare_data]
+
+  - id: process_data
+    type: shell
+    run: |
+      echo "${{ steps.read_data.output }}" | tr '[:lower:]' '[:upper:]'
+    transform: "stdout.trim()"
+    needs: [read_data]
+
+  - id: save_result
+    type: file
+    op: write
+    path: ${{ inputs.output_file }}
+    content: ${{ steps.process_data.output }}
+    needs: [process_data]
+
+finally:
+  - id: cleanup
+    type: shell
+    run: rm ${{ inputs.input_file }}

package/src/templates/full-feature-demo.yaml

@@ -0,0 +1,64 @@
+name: full-feature-demo
+description: "A comprehensive workflow demonstrating multiple feature types"
+
+inputs:
+  message:
+    type: string
+    default: "Hello from Keystone!"
+
+outputs:
+  greeting: ${{ steps.greet.output }}
+  file_count: ${{ steps.count_files.output }}
+  timestamp: ${{ steps.get_date.output }}
+
+steps:
+  # Test shell execution
+  - id: greet
+    type: shell
+    run: echo "${{ inputs.message }}"
+
+  # Test shell with transform
+  - id: get_date
+    type: shell
+    run: date +%s
+    transform: parseInt(stdout.trim())
+
+  # Test file write
+  - id: write_file
+    type: file
+    op: write
+    path: /tmp/keystone-test.txt
+    content: "Test file created at ${{ steps.get_date.output }}"
+
+  # Test file read
+  - id: read_file
+    type: file
+    op: read
+    path: /tmp/keystone-test.txt
+    needs: [write_file]
+
+  # Test shell with dependencies
+  - id: count_files
+    type: shell
+    needs: [write_file]
+    run: ls /tmp/keystone-*.txt | wc -l
+    transform: parseInt(stdout.trim())
+
+  # Test conditional execution
+  - id: success_message
+    type: shell
+    if: ${{ steps.count_files.output > 0 }}
+    needs: [count_files]
+    run: echo "Found files!"
+
+  # Test HTTP request
+  - id: api_test
+    type: request
+    url: https://httpbin.org/get
+    method: GET
+
+  # Test sleep
+  - id: wait
+    type: sleep
+    duration: 100
+    needs: [api_test]

package/src/templates/human-interaction.yaml

@@ -0,0 +1,12 @@
+name: human-interaction
+description: A workflow that prompts the user for input and uses it in another step.
+
+steps:
+  - id: ask_name
+    type: human
+    message: "What is your name?"
+    inputType: text
+
+  - id: greet
+    type: shell
+    run: echo "Hello, ${{ escape(steps.ask_name.output) }}!"

package/src/templates/invalid.yaml

@@ -0,0 +1,5 @@
+name: invalid-workflow
+steps:
+  - id: step1
+    type: shell
+    # Missing 'run' property

package/src/templates/llm-agent.yaml

@@ -0,0 +1,8 @@
+name: llm-agent
+description: "Test LLM step"
+
+steps:
+  - id: ask_llm
+    type: llm
+    agent: summarizer
+    prompt: "Hello, who are you?"

package/src/templates/loop-parallel.yaml

@@ -0,0 +1,37 @@
+name: loop-parallel
+description: "Test the foreach race condition fix and .every() support"
+
+outputs:
+  all_success: ${{ steps.process_items.items.every(s => s.status == 'success') }}
+  item_count: ${{ steps.process_items.outputs.length }}
+  first_output: ${{ steps.process_items.items[0].output }}
+
+steps:
+  # Generate test data
+  - id: generate_items
+    type: shell
+    run: "echo 'item1\nitem2\nitem3\nitem4\nitem5'"
+    transform: "stdout.split('\\n').filter(Boolean)"
+
+  # Process items with concurrency (tests race condition fix)
+  - id: process_items
+    type: shell
+    needs: [generate_items]
+    foreach: ${{ steps.generate_items.output }}
+    concurrency: 3
+    run: "echo 'Processing: ${{ item }}' && sleep 0.1"
+    transform: "stdout.trim()"
+
+  # Test conditional using .every() (tests aggregation fix)
+  - id: success_notification
+    type: shell
+    needs: [process_items]
+    if: ${{ steps.process_items.items.every(s => s.status == 'success') }}
+    run: "echo 'All items processed successfully!'"
+
+  # Test accessing individual item status
+  - id: check_first
+    type: shell
+    needs: [process_items]
+    if: ${{ steps.process_items.items[0].status == 'success' }}
+    run: "echo 'First item was successful'"

package/src/templates/retry-policy.yaml

@@ -0,0 +1,36 @@
+name: retry-policy
+description: "Test retry and timeout features"
+
+steps:
+  # Test retry with a command that fails first few times
+  - id: flaky_command
+    type: shell
+    run: |
+      if [ ! -f /tmp/keystone-retry-test ]; then
+        echo "1" > /tmp/keystone-retry-test
+        exit 1
+      else
+        count=$(cat /tmp/keystone-retry-test)
+        count=$((count + 1))
+        echo $count > /tmp/keystone-retry-test
+        if [ $count -lt 3 ]; then
+          exit 1
+        fi
+        echo "Success after $count attempts"
+      fi
+    retry:
+      count: 3
+      backoff: exponential
+
+  # Test timeout (should complete before timeout)
+  - id: quick_task
+    type: shell
+    run: sleep 0.1 && echo "Completed"
+    timeout: 5000
+    needs: [flaky_command]
+
+  # Cleanup
+  - id: cleanup
+    type: shell
+    run: rm -f /tmp/keystone-retry-test
+    needs: [quick_task]

package/src/templates/scaffold-feature.yaml

@@ -0,0 +1,48 @@
+name: scaffold-feature
+description: "Autonomously build new Keystone workflows and agents"
+
+steps:
+  - id: get_requirements
+    type: human
+    message: "Describe the workflow you want to build:"
+    inputType: text
+
+  - id: design
+    type: llm
+    agent: keystone-architect
+    needs: [get_requirements]
+    prompt: |
+      The user wants to build the following:
+      <user_requirements>
+        ${{ steps.get_requirements.output }}
+      </user_requirements>
+      Generate the necessary Keystone workflow and optionally create an agent where appropriate.
+    schema:
+      type: object
+      properties:
+        files:
+          type: array
+          items:
+            type: object
+            properties:
+              path:
+                type: string
+              content:
+                type: string
+            required: [path, content]
+      required: [files]
+
+  - id: write_files
+    type: file
+    needs: [design]
+    foreach: ${{ steps.design.output.files }}
+    op: write
+    path: ${{ item.path }}
+    content: ${{ item.content }}
+
+  - id: summary
+    type: shell
+    needs: [write_files]
+    run: |
+      echo "Scaffolding complete. Files created:"
+      echo "${{ steps.design.output.files.map(f => f.path).join('\n') }}"

package/src/templates/stop-watch.yaml

@@ -0,0 +1,17 @@
+name: stop-watch
+description: "A simple stopwatch workflow"
+steps:
+  - id: get_duration
+    type: human
+    message: "Please enter the duration (in seconds) for the stopwatch."
+    inputType: text
+  - id: waiting_period
+    type: sleep
+    needs: [get_duration]
+    duration: ${{ Number(steps.get_duration.output) * 1000 }}
+  - id: notify_completion
+    type: human
+    needs: [waiting_period]
+    message: "The stopwatch is complete."
+    inputType: confirm
+outputs: {}

package/src/utils/config-loader.test.ts

@@ -1,6 +1,6 @@
-import { describe, expect, it, afterEach } from 'bun:test';
-import { ConfigLoader } from './config-loader';
+import { afterEach, describe, expect, it } from 'bun:test';
 import type { Config } from '../parser/config-schema';
+import { ConfigLoader } from './config-loader';
 
 describe('ConfigLoader', () => {
   afterEach(() => {