loopflow 0.6.2__tar.gz → 0.6.3__tar.gz

{loopflow-0.6.2 → loopflow-0.6.3}/.gitignore

@@ -7,6 +7,7 @@ __pycache__/
 xcuserdata/
 .swiftpm/xcode/
 Maestro/Maestro.xcodeproj/
+Maestro/dist/
 
 # Claude Code (personal state)
 .claude/settings.local.json

{loopflow-0.6.2 → loopflow-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loopflow
-Version: 0.6.2
+Version: 0.6.3
 Summary: Run LLM coding agents from reusable prompt files
 Project-URL: Homepage, https://loopflowstudio.github.io/loopflow/
 Project-URL: Repository, https://github.com/loopflowstudio/loopflow

{loopflow-0.6.2 → loopflow-0.6.3}/pyproject.toml

@@ -79,4 +79,5 @@ path = "src/loopflow/__init__.py"
 [dependency-groups]
 dev = [
     "pytest>=9.0.2",
+    "boto3>=1.35.0",
 ]

loopflow-0.6.3/src/loopflow/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.6.3"

{loopflow-0.6.2 → loopflow-0.6.3}/src/loopflow/cli/__init__.py

@@ -1,17 +1,19 @@
 """Loopflow CLI: Arrange LLMs to code in harmony."""
 
 import sys
+from typing import Optional
 
 import typer
 
 from loopflow.config import ConfigError, load_config
-from loopflow.context import find_worktree_root, gather_task
+from loopflow.context import find_worktree_root, gather_task, list_all_tasks, _get_builtin_task
 from loopflow.init_check import check_init_status
+from loopflow.lfd.pipelines import load_pipeline
 
 app = typer.Typer(
     name="lf",
     help="Arrange LLMs to code in harmony.",
-    no_args_is_help=True,
+    no_args_is_help=False,
 )
 
 # Import and register subcommands
@@ -24,6 +26,33 @@ app.command(name="pipeline")(run_module.pipeline)
 app.command()(run_module.cp)
 
 
+def _list_tasks() -> None:
+    """List available tasks and pipelines."""
+    repo_root = find_worktree_root()
+    config = load_config(repo_root) if repo_root else None
+
+    user_tasks, builtin_only = list_all_tasks(repo_root)
+    pipelines = list(config.pipelines.keys()) if config else []
+
+    # Show pipelines
+    if pipelines:
+        typer.echo("Pipelines:")
+        for name in sorted(pipelines):
+            typer.echo(f"  {name}")
+        typer.echo()
+
+    # Show tasks
+    if user_tasks or builtin_only:
+        typer.echo("Tasks:")
+        for name in user_tasks:
+            typer.echo(f"  {name}")
+        for name in builtin_only:
+            typer.echo(f"  {name} (builtin)")
+    else:
+        typer.echo("No tasks found.")
+        typer.echo("Run: lfops init")
+
+
 def main():
     """Entry point that supports 'lf <task>' and 'lf <pipeline>' shorthand."""
     known_commands = {
@@ -36,6 +65,11 @@ def main():
     }
 
     try:
+        # Handle 'lf' with no arguments: list available tasks
+        if len(sys.argv) == 1:
+            _list_tasks()
+            raise SystemExit(0)
+
         if len(sys.argv) > 1:
             first_arg = sys.argv[1]
 
@@ -51,8 +85,16 @@ def main():
                 repo_root = find_worktree_root()
                 config = load_config(repo_root) if repo_root else None
 
-                has_pipeline = config and name in config.pipelines
-                has_task = repo_root and gather_task(repo_root, name) is not None
+                # Check for pipeline in config.yaml or .lf/pipelines/
+                has_config_pipeline = config and name in config.pipelines
+                has_file_pipeline = repo_root and load_pipeline(name, repo_root) is not None
+                has_pipeline = has_config_pipeline or has_file_pipeline
+
+                # gather_task now includes builtins
+                has_task = gather_task(repo_root, name) is not None if repo_root else False
+                # Also check builtin even without repo_root
+                if not has_task and not repo_root:
+                    has_task = _get_builtin_task(name) is not None
 
                 if has_pipeline and has_task:
                     typer.echo(f"Error: '{name}' exists as both a pipeline and a task", err=True)
@@ -66,18 +108,9 @@ def main():
                 elif has_task:
                     sys.argv.insert(1, "run")
                 else:
-                    # Check if repo is initialized
-                    status = check_init_status(repo_root) if repo_root else None
-                    if status and not status.has_commands and not status.has_lf_dir:
-                        # Uninitialized repo - suggest init
-                        typer.echo(f"No task named '{name}' found.", err=True)
-                        typer.echo("", err=True)
-                        typer.echo("This repo hasn't been set up for loopflow yet.", err=True)
-                        typer.echo("Run: lfops init", err=True)
-                    else:
-                        # Initialized but task missing - suggest creating it
-                        typer.echo(f"No task or pipeline named '{name}'", err=True)
-                        typer.echo(f"Create: .claude/commands/{name}.md", err=True)
+                    # Task not found
+                    typer.echo(f"No task or pipeline named '{name}'", err=True)
+                    typer.echo(f"Run 'lf' to see available tasks.", err=True)
                     raise SystemExit(1)
 
         app()

{loopflow-0.6.2 → loopflow-0.6.3}/src/loopflow/cli/run.py

@@ -23,7 +23,8 @@ from loopflow.launcher import (
 from loopflow.logging import get_model_env, write_prompt_file
 from loopflow.lfd.client import log_session_start, log_session_end
 from loopflow.lfd.models import Session, SessionStatus
-from loopflow.pipeline import run_pipeline
+from loopflow.lfd.pipelines import load_pipeline as load_pipeline_file, PipelineDef, PipelineStep, RaceConfig
+from loopflow.pipeline import run_pipeline_def, _run_race_step
 from loopflow.tokens import analyze_components
 from loopflow.worktrees import WorktreeError, create
 
@@ -78,6 +79,7 @@ def _execute_task(
             model_variant=model_variant,
             sandbox_root=repo_root.parent,
             workdir=repo_root,
+            images=components.image_files,
         )
     else:
         command = build_model_command(
@@ -88,6 +90,7 @@ def _execute_task(
             model_variant=model_variant,
             sandbox_root=repo_root.parent,
             workdir=repo_root,
+            images=components.image_files,
         )
 
     # For interactive mode, run CLI directly to preserve terminal
@@ -188,7 +191,10 @@ def run(
         None, "--voice", help="Voice(s) to use (comma-separated, e.g., 'architect,concise')"
     ),
     parallel: str = typer.Option(
-        None, "--parallel", help="Run in parallel with multiple models (e.g., 'claude,codex')"
+        None, "--parallel", help="Run in parallel with multiple models, keep worktrees (e.g., 'claude,codex')"
+    ),
+    race: str = typer.Option(
+        None, "--race", help="Race multiple models, auto-judge winner (e.g., 'claude,codex,gemini')"
     ),
 ):
     """Run a task with an LLM model."""
@@ -197,7 +203,29 @@ def run(
         typer.echo("Error: Not in a git repository", err=True)
         raise typer.Exit(1)
 
-    # Handle parallel execution
+    # Handle race execution
+    if race:
+        models = [m.strip() for m in race.split(",")]
+        config = load_config(repo_root)
+        main_repo = find_main_repo(repo_root) or repo_root
+        skip_permissions = config.yolo if config else False
+        exclude = list(config.exclude) if config and config.exclude else None
+
+        race_config = RaceConfig(models=models)
+        result_code = _run_race_step(
+            task,
+            race_config,
+            repo_root,
+            main_repo,
+            exclude,
+            skip_permissions,
+            list(context) if context else None,
+            1,  # step_num
+            1,  # total_steps
+        )
+        raise typer.Exit(result_code)
+
+    # Handle parallel execution (creates persistent worktrees)
     if parallel:
         models = [m.strip() for m in parallel.split(",")]
         for model_name in models:
@@ -518,7 +546,7 @@ def cp(
 
 
 def pipeline(
-    name: str = typer.Argument(help="Pipeline name from config.yaml"),
+    name: str = typer.Argument(help="Pipeline name from config.yaml or .lf/pipelines/"),
     context: list[str] = typer.Option(
         None, "-x", "--context", help="Context files for all tasks"
     ),
@@ -542,11 +570,16 @@ def pipeline(
         raise typer.Exit(1)
 
     config = load_config(repo_root)
-    if not config or name not in config.pipelines:
-        typer.echo(f"Error: Pipeline '{name}' not found in .lf/config.yaml", err=True)
+
+    # Check for pipeline in .lf/pipelines/ first, then config.yaml
+    pipeline_def = load_pipeline_file(name, repo_root)
+    config_pipeline = config.pipelines.get(name) if config else None
+
+    if not pipeline_def and not config_pipeline:
+        typer.echo(f"Error: Pipeline '{name}' not found in .lf/pipelines/ or .lf/config.yaml", err=True)
         raise typer.Exit(1)
 
-    agent_model = model or config.agent_model
+    agent_model = model or (config.agent_model if config else "claude:opus")
     backend, model_variant = parse_model(agent_model)
 
     try:
@@ -567,24 +600,32 @@ def pipeline(
             raise typer.Exit(1)
         repo_root = worktree_path
 
-    all_context = list(config.context) if config.context else []
+    all_context = list(config.context) if config and config.context else []
     if context:
         all_context.extend(context)
 
-    exclude = list(config.exclude) if config.exclude else None
+    exclude = list(config.exclude) if config and config.exclude else None
 
     if copy:
         # Show tokens for first task in pipeline
-        first_task = config.pipelines[name].tasks[0]
+        if pipeline_def:
+            first_task = pipeline_def.steps[0].task if pipeline_def.steps else None
+        else:
+            first_task = config_pipeline.tasks[0] if config_pipeline.tasks else None
+
+        if not first_task:
+            typer.echo("Error: Pipeline has no tasks", err=True)
+            raise typer.Exit(1)
+
         components = gather_prompt_components(
             repo_root,
             first_task,
             context=all_context or None,
             exclude=exclude,
             include_tests_for=config.include_tests_for if config else None,
-            include_loopflow_doc=config.include_loopflow_doc,
-            include_diff=config.diff,
-            include_diff_files=config.diff_files,
+            include_loopflow_doc=config.include_loopflow_doc if config else True,
+            include_diff=config.diff if config else False,
+            include_diff_files=config.diff_files if config else True,
         )
         prompt = format_prompt(components)
         _copy_to_clipboard(prompt)
@@ -594,16 +635,26 @@ def pipeline(
         typer.echo("\nCopied to clipboard.")
         raise typer.Exit(0)
 
-    push_enabled = config.push
-    pr_enabled = pr if pr is not None else config.pr
+    push_enabled = config.push if config else False
+    pr_enabled = pr if pr is not None else (config.pr if config else False)
+    skip_permissions = config.yolo if config else False
+
+    # Convert config.yaml pipeline to PipelineDef if needed
+    if not pipeline_def:
+        # PipelineConfig.push/pr override global settings
+        push_enabled = config_pipeline.push if config_pipeline.push is not None else push_enabled
+        pr_enabled = config_pipeline.pr if config_pipeline.pr is not None else pr_enabled
+        pipeline_def = PipelineDef(
+            name=name,
+            steps=[PipelineStep(task=t) for t in config_pipeline.tasks],
+        )
 
-    exit_code = run_pipeline(
-        config.pipelines[name],
+    exit_code = run_pipeline_def(
+        pipeline_def,
         repo_root,
         context=all_context or None,
         exclude=exclude,
-        include_tests_for=config.include_tests_for if config else None,
-        skip_permissions=config.yolo,
+        skip_permissions=skip_permissions,
         push_enabled=push_enabled,
         pr_enabled=pr_enabled,
         backend=backend,

{loopflow-0.6.2 → loopflow-0.6.3}/src/loopflow/context.py

@@ -7,11 +7,15 @@ from pathlib import Path
 from typing import Optional
 
 from loopflow.design import gather_design_docs
-from loopflow.files import gather_docs, gather_files, format_files
+from loopflow.files import gather_docs, gather_files, format_files, format_image_references
 from loopflow.frontmatter import TaskFile, parse_task_file
 from loopflow.voices import Voice, load_voice
 
 
+# Path to bundled builtin templates
+_TEMPLATES_DIR = Path(__file__).parent / "templates" / "commands"
+
+
 @dataclass
 class PromptComponents:
     """Raw components of a prompt before assembly."""
@@ -25,6 +29,7 @@ class PromptComponents:
     clipboard: str | None = None
     loopflow_doc: str | None = None  # Bundled system documentation
     voices: list[Voice] | None = None
+    image_files: list[Path] | None = None  # Images for visual context
 
 
 def find_worktree_root(start: Optional[Path] = None) -> Path | None:
@@ -65,6 +70,63 @@ def _read_clipboard() -> str | None:
     return None
 
 
+def _get_builtin_task(name: str) -> Path | None:
+    """Return path to bundled template if it exists."""
+    builtin = _TEMPLATES_DIR / f"{name}.md"
+    return builtin if builtin.exists() else None
+
+
+def list_builtin_tasks() -> list[str]:
+    """Return names of all builtin tasks."""
+    if not _TEMPLATES_DIR.exists():
+        return []
+    return sorted(p.stem for p in _TEMPLATES_DIR.glob("*.md"))
+
+
+def list_user_tasks(repo_root: Path) -> list[str]:
+    """Return names of user-defined tasks in the repo."""
+    tasks = set()
+
+    # .claude/commands/*.md
+    claude_dir = repo_root / ".claude" / "commands"
+    if claude_dir.exists():
+        for p in claude_dir.glob("*.md"):
+            tasks.add(p.stem)
+
+    # .lf/*
+    lf_dir = repo_root / ".lf"
+    if lf_dir.exists():
+        for p in lf_dir.iterdir():
+            if not p.is_file():
+                continue
+            # Skip config files
+            if p.name in ("config.yaml", "config.yml"):
+                continue
+            # Task name is filename without extension
+            if p.suffix:
+                tasks.add(p.stem)
+            else:
+                tasks.add(p.name)
+
+    return sorted(tasks)
+
+
+def list_all_tasks(repo_root: Path | None) -> tuple[list[str], list[str]]:
+    """Return (user_tasks, builtin_only_tasks) for discoverability.
+
+    User tasks include any that override builtins.
+    Builtin-only tasks are builtins not overridden by user tasks.
+    """
+    builtins = set(list_builtin_tasks())
+    if repo_root:
+        user = set(list_user_tasks(repo_root))
+    else:
+        user = set()
+
+    builtin_only = builtins - user
+    return sorted(user), sorted(builtin_only)
+
+
 def gather_task(repo_root: Path, name: str) -> TaskFile | None:
     """Gather and parse task file with frontmatter.
 
@@ -74,6 +136,7 @@ def gather_task(repo_root: Path, name: str) -> TaskFile | None:
     3. .lf/{name}.md
     4. .lf/{name}.* (any other extension)
     5. .lf/{name} (bare name)
+    6. templates/commands/{name}.md (builtin fallback)
 
     Returns TaskFile with parsed config, or None if not found.
     """
@@ -109,6 +172,13 @@ def gather_task(repo_root: Path, name: str) -> TaskFile | None:
     content = _read_file_if_named(lf_dir, name)
     if content:
         return parse_task_file(name, content)
+
+    # Fall back to builtin templates
+    builtin_path = _get_builtin_task(name)
+    if builtin_path:
+        content = builtin_path.read_text()
+        return parse_task_file(name, content)
+
     return None
 
 
@@ -250,7 +320,7 @@ def gather_prompt_components(
     # Merge: diff files first, then context paths not already in diff
     diff_set = set(diff_file_paths)
     all_file_paths = diff_file_paths + [p for p in context_paths if p not in diff_set]
-    all_files = gather_files(all_file_paths, repo_root, context_exclude)
+    gather_result = gather_files(all_file_paths, repo_root, context_exclude)
 
     clipboard = _read_clipboard() if paste else None
 
@@ -261,12 +331,13 @@ def gather_prompt_components(
         run_mode=run_mode,
         docs=docs,
         diff=diff,
-        diff_files=all_files,
+        diff_files=gather_result.text_files,
         task=task_result,
         repo_root=repo_root,
         clipboard=clipboard,
         loopflow_doc=loopflow_doc,
         voices=loaded_voices,
+        image_files=gather_result.image_files or None,
     )
 
 
@@ -322,6 +393,9 @@ def format_prompt(components: PromptComponents) -> str:
     if components.clipboard:
         parts.append(f"Content from clipboard.\n\n<lf:clipboard>\n{components.clipboard}\n</lf:clipboard>")
 
+    if components.image_files:
+        parts.append(format_image_references(components.image_files, components.repo_root))
+
     return "\n\n".join(parts)
 
 

{loopflow-0.6.2 → loopflow-0.6.3}/src/loopflow/files.py

@@ -1,5 +1,6 @@
 """File library gathering for LLM context."""
 
+from dataclasses import dataclass, field
 from functools import lru_cache
 from pathlib import Path
 from typing import Optional
@@ -7,10 +8,20 @@ from typing import Optional
 import pathspec
 
 
+@dataclass
+class GatherResult:
+    """Result of gathering files for context."""
+    text_files: list[tuple[Path, str]] = field(default_factory=list)
+    image_files: list[Path] = field(default_factory=list)
+
+
+# Image extensions (tracked separately, not embedded in text)
+_IMAGE_EXTENSIONS: set[str] = {
+    ".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".tiff", ".ico",
+}
+
 # Known binary extensions (skip without reading)
-_BINARY_EXTENSIONS: set[str] = {
-    # Images
-    ".png", ".jpg", ".jpeg", ".gif", ".ico", ".webp", ".bmp", ".tiff",
+_BINARY_EXTENSIONS: set[str] = _IMAGE_EXTENSIONS | {
     # Archives
     ".zip", ".tar", ".gz", ".bz2", ".7z", ".rar",
     # Executables/libraries
@@ -26,6 +37,11 @@ _BINARY_EXTENSIONS: set[str] = {
 }
 
 
+def is_image(path: Path) -> bool:
+    """Check if file is an image by extension."""
+    return path.suffix.lower() in _IMAGE_EXTENSIONS
+
+
 def is_binary(path: Path) -> bool:
     """Check if file is binary by extension or content sniffing."""
     # Fast path: check extension
@@ -166,15 +182,6 @@ def _gather_file(
     return (path, path.read_text())
 
 
-def gather_file(
-    path: Path,
-    repo_root: Path,
-    exclude: Optional[list[str]] = None,
-) -> tuple[Path, str] | None:
-    excluded_paths = _compile_exclude_patterns(exclude, repo_root) if exclude else None
-    return _gather_file(path, repo_root, excluded_paths)
-
-
 def _expand_path(path_str: str, repo_root: Path) -> list[Path]:
     """Expand a path string to a list of file paths.
 
@@ -198,13 +205,15 @@ def _expand_path(path_str: str, repo_root: Path) -> list[Path]:
     return []
 
 
-def gather_files(paths: list[str], repo_root: Path, exclude: Optional[list[str]] = None) -> list[tuple[Path, str]]:
+def gather_files(paths: list[str], repo_root: Path, exclude: Optional[list[str]] = None) -> GatherResult:
     """Gather files and their parent READMEs.
 
-    Returns list of (path, content) tuples, deduplicated and ordered.
+    Returns GatherResult with text files (path, content) and image file paths.
+    Images are tracked separately since they can't be embedded in text prompts.
     """
     seen: set[Path] = set()
-    results: list[tuple[Path, str]] = []
+    text_files: list[tuple[Path, str]] = []
+    image_files: list[Path] = []
 
     # Pre-compile exclude patterns once for the entire gather operation
     excluded_paths = _compile_exclude_patterns(exclude, repo_root) if exclude else None
@@ -213,19 +222,28 @@ def gather_files(paths: list[str], repo_root: Path, exclude: Optional[list[str]]
         expanded = _expand_path(path_str, repo_root)
 
         for path in expanded:
+            if path in seen:
+                continue
+
+            # Check if this is an image
+            if path.is_file() and is_image(path) and not _is_ignored(path, repo_root, excluded_paths):
+                seen.add(path)
+                image_files.append(path)
+                continue
+
             # Gather parent documentation first
             for doc_path, content in _gather_docs(path, repo_root, excluded_paths):
                 if doc_path not in seen:
                     seen.add(doc_path)
-                    results.append((doc_path, content))
+                    text_files.append((doc_path, content))
 
-            # Gather the file itself
+            # Gather the file itself (skips binary including images)
             file_result = _gather_file(path, repo_root, excluded_paths)
             if file_result and file_result[0] not in seen:
                 seen.add(file_result[0])
-                results.append(file_result)
+                text_files.append(file_result)
 
-    return results
+    return GatherResult(text_files=text_files, image_files=image_files)
 
 
 def format_files(files: list[tuple[Path, str]], repo_root: Path) -> str:
@@ -240,3 +258,20 @@ def format_files(files: list[tuple[Path, str]], repo_root: Path) -> str:
 
     body = "\n\n".join(parts)
     return f"Reference files for this task. Includes parent documentation for context.\n\n<lf:files>\n{body}\n</lf:files>"
+
+
+def format_image_references(images: list[Path], repo_root: Path) -> str:
+    """Format image file references for the prompt.
+
+    Images can't be embedded in text, but we tell the agent where they are
+    so it can read them using its file tools.
+    """
+    if not images:
+        return ""
+
+    lines = ["The following images are available. Use your Read tool to view them:"]
+    for img in images:
+        rel = img.relative_to(repo_root)
+        lines.append(f"- {rel}")
+
+    return "<lf:images>\n" + "\n".join(lines) + "\n</lf:images>"

{loopflow-0.6.2 → loopflow-0.6.3}/src/loopflow/launcher.py

@@ -230,6 +230,7 @@ def build_codex_command(
     model_variant: str | None = None,
     sandbox_root: Path | None = None,
     workdir: Path | None = None,
+    images: list[Path] | None = None,
 ) -> list[str]:
     """Build Codex CLI command for the requested run mode.
 
@@ -250,6 +251,11 @@ def build_codex_command(
     if sandbox_root:
         cmd.extend(["--add-dir", str(sandbox_root)])
 
+    # Attach images via -i flag
+    if images:
+        for img in images:
+            cmd.extend(["-i", str(img)])
+
     if skip_permissions:
         # Keep sandboxing but avoid approval prompts in exec mode.
         cmd.extend(["-c", 'approval_policy="never"'])
@@ -282,6 +288,7 @@ def build_codex_interactive_command(
     model_variant: str | None = None,
     sandbox_root: Path | None = None,
     workdir: Path | None = None,
+    images: list[Path] | None = None,
 ) -> list[str]:
     """Build Codex CLI command for interactive mode.
 
@@ -297,6 +304,10 @@ def build_codex_interactive_command(
     cmd.extend(["--sandbox", "workspace-write"])
     if sandbox_root:
         cmd.extend(["--add-dir", str(sandbox_root)])
+    # Attach images via -i flag
+    if images:
+        for img in images:
+            cmd.extend(["-i", str(img)])
     return cmd
 
 
@@ -368,10 +379,12 @@ def build_model_command(
     model_variant: str | None = None,
     sandbox_root: Path | None = None,
     workdir: Path | None = None,
+    images: list[Path] | None = None,
 ) -> list[str]:
     """Build a model command for auto/background execution.
 
     Prompt should be appended as a CLI argument.
+    Images are passed to Codex via -i flag; Claude/Gemini read from filesystem.
     """
     if model == "claude":
         return build_claude_command(auto=auto, stream=stream, skip_permissions=skip_permissions, model_variant=model_variant)
@@ -391,6 +404,7 @@ def build_model_command(
         model_variant=model_variant,
         sandbox_root=sandbox_root,
         workdir=workdir,
+        images=images,
     )
 
 
@@ -400,10 +414,12 @@ def build_model_interactive_command(
     model_variant: str | None = None,
     sandbox_root: Path | None = None,
     workdir: Path | None = None,
+    images: list[Path] | None = None,
 ) -> list[str]:
     """Build a model command for interactive execution.
 
     Prompt should be appended as a CLI argument.
+    Images are passed to Codex via -i flag; Claude/Gemini read from filesystem.
     """
     if model == "claude":
         return build_claude_command(auto=False, stream=False, skip_permissions=skip_permissions, model_variant=model_variant)
@@ -419,6 +435,7 @@ def build_model_interactive_command(
         model_variant=model_variant,
         sandbox_root=sandbox_root,
         workdir=workdir,
+        images=images,
     )