flowsh-cli 0.4.2__tar.gz → 0.6.0__tar.gz

{flowsh_cli-0.4.2 → flowsh_cli-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowsh-cli
-Version: 0.4.2
+Version: 0.6.0
 Summary: Generate Bash harness scripts from workflow YAML files.
 License-Expression: MIT
 Classifier: Programming Language :: Python :: 3.11

{flowsh_cli-0.4.2 → flowsh_cli-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "flowsh-cli"
-version = "0.4.2"
+version = "0.6.0"
 description = "Generate Bash harness scripts from workflow YAML files."
 readme = "README.md"
 requires-python = ">=3.11"

{flowsh_cli-0.4.2 → flowsh_cli-0.6.0}/src/flowsh_cli/__init__.py

@@ -3,7 +3,7 @@
 from flowsh_cli.models import Workflow, WorkflowParseError, parse_workflows
 from flowsh_cli.render import harness_path, render_harness
 
-__version__ = "0.4.2"
+__version__ = "0.6.0"
 
 __all__ = [
     "Workflow",

{flowsh_cli-0.4.2 → flowsh_cli-0.6.0}/src/flowsh_cli/models.py

@@ -154,12 +154,52 @@ class VarsStep(BaseStep):
         return value
 
 
-Step = Annotated[VarsStep | BashStep | AgentStep, Field(discriminator="type")]
+class ForStep(BaseStep):
+    type: Literal["for"]
+    in_: str = Field(..., validation_alias="in")
+    item: str = Field(...)
+    steps: list[Step] = Field(min_length=1)
+
+    @field_validator("in_", "item")
+    @classmethod
+    def validate_var_name(cls, value: str) -> str:
+        if not re.fullmatch(r"[A-Z_][A-Z0-9_]*", value):
+            raise ValueError("must match ^[A-Z_][A-Z0-9_]*$")
+        return value
+
+
+class ParallelStep(BaseStep):
+    type: Literal["parallel"]
+    steps: list[Step] = Field(min_length=1)
+
+
+Step = Annotated[
+    VarsStep | BashStep | AgentStep | ForStep | ParallelStep,
+    Field(discriminator="type"),
+]
+
+
+ForStep.model_rebuild()
+ParallelStep.model_rebuild()
+
+
+class WorkflowParam(StrictModel):
+    name: str
+    description: str | None = None
+    required: bool = False
+
+    @field_validator("name")
+    @classmethod
+    def validate_name(cls, value: str) -> str:
+        if not re.fullmatch(r"[A-Z_][A-Z0-9_]*", value):
+            raise ValueError("must match ^[A-Z_][A-Z0-9_]*$")
+        return value
 
 
 class Workflow(StrictModel):
     id: str
     name: str
+    params: list[WorkflowParam] = []
     steps: list[Step]
 
     @field_validator("id")

{flowsh_cli-0.4.2 → flowsh_cli-0.6.0}/src/flowsh_cli/render.py

@@ -3,7 +3,16 @@ from __future__ import annotations
 import re
 from pathlib import Path
 
-from flowsh_cli.models import AgentStep, BashStep, Step, VarsStep, Workflow
+from flowsh_cli.models import (
+    AgentStep,
+    BashStep,
+    ForStep,
+    ParallelStep,
+    Step,
+    VarsStep,
+    Workflow,
+    WorkflowParam,
+)
 
 
 def harness_path(workflow: Workflow) -> Path:
@@ -26,13 +35,7 @@ def render_harness(workflow: Workflow) -> str:
         'LOG_BASENAME="flowsh-${WORKFLOW_SLUG}-${LOG_TIMESTAMP}-$$.log"',
         "",
         section("Argument handling"),
-        "DRY_RUN=false",
-        'if [[ $# -eq 1 && "$1" == "--dry-run" ]]; then',
-        "  DRY_RUN=true",
-        "elif [[ $# -gt 0 ]]; then",
-        '  printf "Usage: %s [--dry-run]\\n" "$0" >&2',
-        "  exit 2",
-        "fi",
+        *_render_arg_block(workflow.params),
         "",
         section("refuse_symlink_path() - keep generated logs inside plain relative paths"),
         "refuse_symlink_path() {",
@@ -227,8 +230,64 @@ def render_harness(workflow: Workflow) -> str:
 def render_step(index: int, step: Step, used_function_names: set[str] | None = None) -> list[str]:
     function_name = step_function_name(index, step.name, used_function_names)
     title = step.name or default_step_title(index, step)
-    lines = [section(f"Step {index} ({step.type}): {title}"), f"{function_name}() {{"]
 
+    prefix_lines: list[str] = []
+
+    if isinstance(step, ForStep):
+        inner_fns: list[str] = []
+        for i, inner_step in enumerate(step.steps, start=1):
+            inner_fn = _for_inner_function_name(index, i, inner_step, used_function_names)
+            inner_fns.append(inner_fn)
+            inner_title = inner_step.name or default_step_title(i, inner_step)
+            prefix_lines.append(section(f"For-inner step ({inner_step.type}): {inner_title}"))
+            prefix_lines.append(f"{inner_fn}() {{")
+            prefix_lines.extend(_render_step_body(inner_step))
+            prefix_lines.append("}")
+            prefix_lines.append("")
+
+        body_lines = [
+            f"  while IFS= read -r {step.item}; do",
+            f"    export {step.item}",
+            *[f"    run_step {fn}" for fn in inner_fns],
+            f'  done <<< "${{{step.in_}}}"',
+        ]
+    elif isinstance(step, ParallelStep):
+        child_fns: list[str] = []
+        for i, child in enumerate(step.steps, start=1):
+            child_title = child.name or default_step_title(i, child)
+            child_fn = step_function_name(i, child.name, used_function_names)
+            child_fns.append(child_fn)
+            prefix_lines.append(section(f"Parallel child {i} ({child.type}): {child_title}"))
+            prefix_lines.append(f"{child_fn}() {{")
+            prefix_lines.extend(_render_step_body(child))
+            prefix_lines.append("}")
+            prefix_lines.append("")
+
+        body_lines = ["  local status=0"]
+        for child_fn in child_fns:
+            body_lines.append(f'  "{child_fn}" &')
+            body_lines.append(f"  local pid_{child_fn}=$!")
+        for child_fn in child_fns:
+            body_lines.append(f'  wait "$pid_{child_fn}" || status=$?')
+        body_lines.append('  return "$status"')
+    else:
+        body_lines = _render_step_body(step)
+
+    runner = "run_stateful_step" if isinstance(step, (VarsStep, ForStep)) else "run_step"
+    outer_lines = [
+        section(f"Step {index} ({step.type}): {title}"),
+        f"{function_name}() {{",
+        *body_lines,
+        "}",
+        f"{runner} {function_name}",
+        "",
+    ]
+    return prefix_lines + outer_lines
+
+
+def _render_step_body(step: Step) -> list[str]:
+    """Return indented body lines for a step function (no wrapper, no run_step call)."""
+    lines: list[str] = []
     if isinstance(step, VarsStep):
         lines.append("  local status=0")
         for name, command in step.values.items():
@@ -275,7 +334,6 @@ def render_step(index: int, step: Step, used_function_names: set[str] | None = N
             for var in seen:
                 lines.append(f'  _p=\'${{{var}}}\'; prompt="${{prompt//"$_p"/"${var}"}}"')
                 lines.append(f'  _p=\'${var}\'; prompt="${{prompt//"$_p"/"${var}"}}"')
-
         lines.append(f"  local agent={bash_quote(step.agent or '')}")
         lines.append(f"  local model={bash_quote(step.model or '')}")
         lines.append(f"  local command={bash_quote(step.command or '')}")
@@ -284,14 +342,34 @@ def render_step(index: int, step: Step, used_function_names: set[str] | None = N
         lines.append(
             '  run_agent "$prompt" "$agent" "$model" "$command" "$dangerously_skip_permissions"'
         )
+    elif isinstance(step, ForStep):
+        raise AssertionError("nested for steps are not supported")
     else:
         raise AssertionError(f"Unsupported step type: {step}")
-
-    runner = "run_stateful_step" if isinstance(step, VarsStep) else "run_step"
-    lines.extend(["}", f"{runner} {function_name}", ""])
     return lines
 
 
+def _for_inner_function_name(
+    outer_index: int,
+    inner_index: int,
+    step: Step,
+    used_function_names: set[str] | None,
+) -> str:
+    source = step.name or f"step_{inner_index}"
+    slug = re.sub(r"[^A-Za-z0-9_]+", "_", source).strip("_").lower()
+    if not slug or slug[0].isdigit():
+        slug = f"step_{slug}" if slug else f"step_{inner_index}"
+    base = f"for_{outer_index}_{slug}"
+    fn = base
+    suffix = 2
+    while used_function_names is not None and fn in used_function_names:
+        fn = f"{base}_{suffix}"
+        suffix += 1
+    if used_function_names is not None:
+        used_function_names.add(fn)
+    return fn
+
+
 def default_step_title(index: int, step: Step) -> str:
     if isinstance(step, VarsStep):
         return ", ".join(step.values.keys())
@@ -299,6 +377,10 @@ def default_step_title(index: int, step: Step) -> str:
         return truncate_one_line(step.run)
     if isinstance(step, AgentStep):
         return truncate_one_line(step.prompt)
+    if isinstance(step, ForStep):
+        return f"for {step.item} in {step.in_}"
+    if isinstance(step, ParallelStep):
+        return f"parallel ({len(step.steps)} steps)"
     return f"step {index}"
 
 
@@ -353,6 +435,69 @@ def bash_quote(value: str) -> str:
     return "'" + value.replace("'", "'\\''") + "'"
 
 
+def _render_arg_block(params: list[WorkflowParam]) -> list[str]:
+    if not params:
+        return [
+            "DRY_RUN=false",
+            'if [[ $# -eq 1 && "$1" == "--dry-run" ]]; then',
+            "  DRY_RUN=true",
+            "elif [[ $# -gt 0 ]]; then",
+            '  printf "Usage: %s [--dry-run]\\n" "$0" >&2',
+            "  exit 2",
+            "fi",
+        ]
+
+    usage_parts: list[str] = ["[--dry-run]"]
+    for p in params:
+        usage_parts.append(f"<{p.name}>" if p.required else f"[{p.name}]")
+    usage_str = " ".join(usage_parts)
+
+    lines: list[str] = [
+        "DRY_RUN=false",
+        "POSITIONAL_ARGS=()",
+        "",
+        "while [[ $# -gt 0 ]]; do",
+        '  case "$1" in',
+        "    --dry-run)",
+        "      DRY_RUN=true",
+        "      shift",
+        "      ;;",
+        "    --*)",
+        '      printf "Unknown option: %s\\n" "$1" >&2',
+        "      exit 2",
+        "      ;;",
+        "    *)",
+        '      POSITIONAL_ARGS+=("$1")',
+        "      shift",
+        "      ;;",
+        "  esac",
+        "done",
+        "",
+    ]
+
+    for idx, param in enumerate(params):
+        lines += [
+            f"if [[ ${{#POSITIONAL_ARGS[@]}} -gt {idx} ]]; then",
+            f'  {param.name}="${{POSITIONAL_ARGS[{idx}]}}"',
+            f"  export {param.name}",
+            "fi",
+        ]
+
+    lines.append("")
+
+    required = [p for p in params if p.required]
+    if required:
+        for param in required:
+            lines += [
+                f'if [[ -z "${{{param.name}:-}}" ]]; then',
+                f'  printf "Usage: %s {usage_str}\\n" "$0" >&2',
+                "  exit 2",
+                "fi",
+            ]
+
+    return lines
+
+
 def section(title: str) -> str:
     safe_title = truncate_one_line(title, limit=120)
     return "\n".join(