fluxloop-cli 0.1.0__py3-none-any.whl

fluxloop_cli/commands/generate.py

@@ -0,0 +1,304 @@
+"""Generate command for producing input datasets."""
+
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import typer
+from rich.console import Console
+from dotenv import dotenv_values
+
+from ..config_loader import load_experiment_config
+from ..input_generator import GenerationSettings, generate_inputs
+from ..llm_generator import DEFAULT_STRATEGIES
+from ..validators import parse_variation_strategies
+from ..constants import DEFAULT_CONFIG_PATH, DEFAULT_ROOT_DIR_NAME
+from ..project_paths import (
+    resolve_config_path,
+    resolve_project_relative,
+    resolve_root_dir,
+)
+from fluxloop.schemas import InputGenerationMode, VariationStrategy
+
+app = typer.Typer()
+console = Console()
+
+
+@app.command()
+def inputs(
+    config_file: Path = typer.Option(
+        DEFAULT_CONFIG_PATH,
+        "--config",
+        "-c",
+        help="Path to experiment configuration file",
+    ),
+    project: Optional[str] = typer.Option(
+        None,
+        "--project",
+        help="Project name under the FluxLoop root",
+    ),
+    root: Path = typer.Option(
+        Path(DEFAULT_ROOT_DIR_NAME),
+        "--root",
+        help="FluxLoop root directory",
+    ),
+    output_file: Optional[Path] = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Path to write generated inputs file (defaults to setting.yaml -> inputs_file)",
+    ),
+    limit: Optional[int] = typer.Option(
+        None,
+        "--limit",
+        "-l",
+        help="Maximum number of inputs to generate",
+    ),
+    dry_run: bool = typer.Option(
+        False,
+        "--dry-run",
+        help="Print planned generation without creating a file",
+    ),
+    overwrite: bool = typer.Option(
+        False,
+        "--overwrite",
+        help="Allow overwriting an existing output file",
+    ),
+    mode: Optional[InputGenerationMode] = typer.Option(
+        None,
+        "--mode",
+        case_sensitive=False,
+        help="Generation mode: deterministic or llm",
+    ),
+    strategy: List[str] = typer.Option(  # type: ignore[assignment]
+        None,
+        "--strategy",
+        "-s",
+        help="Variation strategy to request (repeatable)",
+    ),
+    llm_provider: Optional[str] = typer.Option(
+        None,
+        "--llm-provider",
+        help="Override LLM provider for input generation",
+    ),
+    llm_model: Optional[str] = typer.Option(
+        None,
+        "--llm-model",
+        help="Override LLM model identifier",
+    ),
+    llm_api_key: Optional[str] = typer.Option(
+        None,
+        "--llm-api-key",
+        help="API key for LLM provider (falls back to FLUXLOOP_LLM_API_KEY)",
+    ),
+    from_recording: Optional[Path] = typer.Option(
+        None,
+        "--from-recording",
+        help="Use a recorded call (JSONL) as template for generated inputs",
+    ),
+):
+    """Generate input variations for review before running experiments."""
+    resolved_config = resolve_config_path(config_file, project, root)
+    if not resolved_config.exists():
+        console.print(f"[red]Error:[/red] Configuration file not found: {config_file}")
+        raise typer.Exit(1)
+
+    # Generating inputs should not require the inputs file to exist yet.
+    require_inputs_file = False
+
+    # Load environment variables (project-level overrides root-level)
+    env_values: Dict[str, str] = {}
+
+    resolved_root = resolve_root_dir(root)
+    root_env_path = resolved_root / ".env"
+    if root_env_path.exists():
+        env_values.update(
+            {
+                key: value
+                for key, value in dotenv_values(root_env_path).items()
+                if value is not None
+            }
+        )
+
+    if project:
+        project_env_path = resolve_project_relative(Path(".env"), project, root)
+        if project_env_path.exists():
+            env_values.update(
+                {
+                    key: value
+                    for key, value in dotenv_values(project_env_path).items()
+                    if value is not None
+                }
+            )
+
+    try:
+        config = load_experiment_config(
+            resolved_config,
+            require_inputs_file=require_inputs_file,
+        )
+    except Exception as exc:
+        console.print(f"[red]Error loading configuration:[/red] {exc}")
+        raise typer.Exit(1)
+
+    # Determine output path (CLI option overrides config)
+    output_path = output_file or Path(config.inputs_file or "inputs/generated.yaml")
+    resolved_output = resolve_project_relative(output_path, project, root)
+
+    if resolved_output.exists() and not overwrite and not dry_run:
+        console.print(
+            f"[red]Error:[/red] Output file already exists: {resolved_output}\n"
+            "Use --overwrite to replace it."
+        )
+        raise typer.Exit(1)
+
+    console.print(f"📋 Loading configuration from: [cyan]{resolved_config}[/cyan]")
+
+    strategies: Optional[List[VariationStrategy]] = None
+    if strategy:
+        strategies = parse_variation_strategies(strategy)
+
+    # Apply CLI overrides to configuration
+    if mode:
+        config.input_generation.mode = mode
+        if mode == InputGenerationMode.LLM:
+            config.input_generation.llm.enabled = True
+
+    if llm_provider:
+        config.input_generation.llm.provider = llm_provider
+        config.input_generation.llm.enabled = True
+
+    if llm_model:
+        config.input_generation.llm.model = llm_model
+        config.input_generation.llm.enabled = True
+
+    resolved_api_key = (
+        llm_api_key
+        or config.input_generation.llm.api_key
+        or env_values.get("FLUXLOOP_LLM_API_KEY")
+        or env_values.get("OPENAI_API_KEY")
+        or os.getenv("FLUXLOOP_LLM_API_KEY")
+        or os.getenv("OPENAI_API_KEY")
+    )
+
+    if resolved_api_key:
+        config.input_generation.llm.api_key = resolved_api_key
+
+    if (
+        config.input_generation.mode == InputGenerationMode.LLM
+        and not config.input_generation.llm.api_key
+    ):
+        console.print(
+            "[yellow]Warning:[/yellow] LLM mode requested but no API key provided."
+        )
+
+    settings = GenerationSettings(
+        limit=limit,
+        dry_run=dry_run,
+        mode=mode,
+        strategies=strategies,
+        llm_api_key_override=llm_api_key,
+    )
+
+    recording_template = None
+    if from_recording:
+        try:
+            recording_template = _load_recording_template(from_recording, config)
+            console.print(
+                "📝 Generating inputs from recording"
+                f"\n  → Base content: [cyan]{recording_template['base_content'][:60]}[/cyan]"
+            )
+        except Exception as exc:
+            console.print(f"[red]Failed to load recording template:[/red] {exc}")
+            raise typer.Exit(1)
+
+    try:
+        result = generate_inputs(config, settings, recording_template=recording_template)
+    except Exception as exc:
+        console.print(f"[red]Generation failed:[/red] {exc}")
+        if "--debug" in sys.argv:
+            console.print_exception()
+        raise typer.Exit(1)
+
+    if dry_run:
+        console.print("\n[yellow]Dry run mode - no file written[/yellow]")
+        console.print(f"Planned inputs: {len(result.entries)}")
+        return
+
+    resolved_output.parent.mkdir(parents=True, exist_ok=True)
+    resolved_output.write_text(result.to_yaml(), encoding="utf-8")
+
+    strategies_used = result.metadata.get("strategies") or [s.value for s in DEFAULT_STRATEGIES]
+
+    console.print(
+        "\n[bold green]Generation complete![/bold green]"
+        f"\n📝 Inputs written to: [cyan]{resolved_output}[/cyan]"
+        f"\n✨ Total inputs: [green]{len(result.entries)}[/green]"
+        f"\n🧠 Mode: [magenta]{result.metadata.get('generation_mode', 'deterministic')}[/magenta]"
+        f"\n🎯 Strategies: [cyan]{', '.join(strategy for strategy in strategies_used)}[/cyan]"
+    )
+
+
+def _load_recording_template(path: Path, config: "ExperimentConfig") -> Dict[str, object]:
+    target_path = path
+    if not target_path.is_absolute():
+        source_dir = config.get_source_dir()
+        if source_dir:
+            target_path = (source_dir / target_path).resolve()
+        else:
+            target_path = target_path.resolve()
+
+    if not target_path.exists():
+        raise FileNotFoundError(f"Recording file not found: {target_path}")
+
+    with target_path.open("r", encoding="utf-8") as handle:
+        first_line = handle.readline()
+
+    if not first_line:
+        raise ValueError(f"Recording file is empty: {target_path}")
+
+    try:
+        record = json.loads(first_line)
+    except json.JSONDecodeError as exc:
+        raise ValueError(f"Invalid JSON in recording file {target_path}: {exc}")
+
+    kwargs = record.get("kwargs", {})
+    base_content = _extract_content(kwargs)
+    if not base_content:
+        sample = json.dumps(kwargs, indent=2)[:500]
+        raise ValueError(
+            "Unable to locate textual content in recording. "
+            "Expected keys such as data.content, input, input_text, message, query, text, or content." \
+            f"\nRecording snapshot:\n{sample}"
+        )
+
+    return {
+        "base_content": base_content,
+        "full_kwargs": kwargs,
+        "target": record.get("target"),
+    }
+
+
+def _extract_content(kwargs: Dict[str, Any]) -> Optional[str]:
+    content_paths = [
+        "data.content",
+        "input",
+        "input_text",
+        "message",
+        "query",
+        "text",
+        "content",
+    ]
+
+    for path in content_paths:
+        try:
+            current: Any = kwargs
+            for part in path.split('.'):
+                current = current[part]
+            if isinstance(current, str) and current:
+                return current
+        except (KeyError, TypeError):
+            continue
+
+    return None

fluxloop_cli/commands/init.py

@@ -0,0 +1,225 @@
+"""
+Initialize command for creating new FluxLoop projects.
+"""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.prompt import Confirm
+from rich.tree import Tree
+
+from ..templates import (
+    create_experiment_config,
+    create_sample_agent,
+    create_gitignore,
+    create_env_file,
+)
+from ..project_paths import resolve_root_dir, resolve_project_dir
+from ..constants import DEFAULT_ROOT_DIR_NAME
+
+app = typer.Typer()
+console = Console()
+
+
+@app.command()
+def project(
+    path: Path = typer.Argument(
+        Path(DEFAULT_ROOT_DIR_NAME),
+        help="Root directory for FluxLoop projects",
+    ),
+    name: Optional[str] = typer.Option(
+        None,
+        "--name",
+        "-n",
+        help="Project name",
+    ),
+    with_example: bool = typer.Option(
+        True,
+        "--with-example/--no-example",
+        help="Include example agent",
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        "-f",
+        help="Overwrite existing files",
+    ),
+):
+    """
+    Initialize a new FluxLoop project.
+    
+    This command creates:
+    - setting.yaml: Default experiment configuration
+    - .env: Environment variables template
+    - examples/: Sample agent code (optional)
+    """
+    # Resolve path
+    root_dir = resolve_root_dir(path)
+
+    if not root_dir.exists():
+        console.print(f"[dim]Creating FluxLoop root directory at {root_dir}[/dim]")
+        root_dir.mkdir(parents=True, exist_ok=True)
+
+    if not name:
+        current = Path.cwd()
+        if current.parent == root_dir:
+            project_name = current.name
+        else:
+            console.print(
+                "[red]Error:[/red] Project name must be provided when running outside the FluxLoop root directory."
+            )
+            raise typer.Exit(1)
+    else:
+        project_name = name
+    project_path = resolve_project_dir(project_name, root_dir)
+
+    console.print(f"\n[bold blue]Initializing FluxLoop project:[/bold blue] {project_name}")
+    console.print(f"[dim]Location: {project_path}[/dim]\n")
+    
+    console.print(f"\n[bold blue]Initializing FluxLoop project:[/bold blue] {project_name}")
+    console.print(f"[dim]Location: {project_path}[/dim]\n")
+    
+    # Check if directory exists
+    if not project_path.exists():
+        if Confirm.ask(f"Directory {project_path} doesn't exist. Create it?"):
+            project_path.mkdir(parents=True)
+        else:
+            raise typer.Abort()
+    
+    # Check for existing files
+    config_file = project_path / "setting.yaml"
+    env_file = project_path / ".env"
+    gitignore_file = project_path / ".gitignore"
+    
+    if not force:
+        existing_files = []
+        if config_file.exists():
+            existing_files.append("setting.yaml")
+        if env_file.exists():
+            existing_files.append(".env")
+        
+        if existing_files:
+            console.print(
+                f"[yellow]Warning:[/yellow] The following files already exist: {', '.join(existing_files)}"
+            )
+            if not Confirm.ask("Overwrite existing files?", default=False):
+                raise typer.Abort()
+    
+    # Create configuration file
+    console.print("📝 Creating experiment configuration...")
+    config_content = create_experiment_config(project_name)
+    config_file.write_text(config_content)
+    
+    # Ensure root .env exists, create project override template
+    root_env_file = root_dir / ".env"
+    if not root_env_file.exists():
+        console.print("🔐 Creating root environment template...")
+        root_env_file.write_text(create_env_file())
+
+    console.print("🔐 Creating project .env template...")
+    recordings_dir = project_path / "recordings"
+    recordings_dir.mkdir(exist_ok=True)
+
+    project_env_content = "# Project-specific overrides\n"
+    env_file.write_text(project_env_content)
+    
+    # Update .gitignore
+    if not gitignore_file.exists():
+        console.print("📄 Creating .gitignore...")
+        gitignore_content = create_gitignore()
+        gitignore_file.write_text(gitignore_content)
+    
+    # Create example agent if requested
+    if with_example:
+        console.print("🤖 Creating example agent...")
+        examples_dir = project_path / "examples"
+        examples_dir.mkdir(exist_ok=True)
+        
+        agent_file = examples_dir / "simple_agent.py"
+        agent_content = create_sample_agent()
+        agent_file.write_text(agent_content)
+    
+    # Display created structure
+    console.print("\n[bold green]✓ Project initialized successfully![/bold green]\n")
+    
+    tree = Tree(f"[bold]{project_name}/[/bold]")
+    tree.add("📄 setting.yaml")
+    tree.add("🔐 .env")
+    tree.add("📄 .gitignore")
+    tree.add("📁 recordings/")
+    
+    if with_example:
+        examples_tree = tree.add("📁 examples/")
+        examples_tree.add("🐍 simple_agent.py")
+    
+    console.print(tree)
+    
+    # Show next steps
+    console.print("\n[bold]Next steps:[/bold]")
+    console.print("1. Edit [cyan]setting.yaml[/cyan] to configure your experiment")
+    console.print("2. Set up environment variables in [cyan].env[/cyan]")
+    if with_example:
+        console.print("3. Try running: [green]fluxloop run experiment[/green]")
+    else:
+        console.print("3. Add your agent code")
+        console.print("4. Run: [green]fluxloop run experiment[/green]")
+
+
+@app.command()
+def agent(
+    name: str = typer.Argument(
+        ...,
+        help="Name of the agent module",
+    ),
+    path: Path = typer.Option(
+        Path.cwd(),
+        "--path",
+        "-p",
+        help="Directory to create the agent in",
+    ),
+    template: str = typer.Option(
+        "simple",
+        "--template",
+        "-t",
+        help="Agent template to use (simple, langchain, langgraph)",
+    ),
+):
+    """
+    Create a new agent from a template.
+    """
+    # Validate template
+    valid_templates = ["simple", "langchain", "langgraph"]
+    if template not in valid_templates:
+        console.print(
+            f"[red]Error:[/red] Invalid template '{template}'. "
+            f"Choose from: {', '.join(valid_templates)}"
+        )
+        raise typer.Exit(1)
+    
+    # Create agent file
+    agent_dir = path / "agents"
+    agent_dir.mkdir(exist_ok=True)
+    
+    agent_file = agent_dir / f"{name}.py"
+    
+    if agent_file.exists():
+        if not Confirm.ask(f"Agent {name}.py already exists. Overwrite?", default=False):
+            raise typer.Abort()
+    
+    # Create agent based on template
+    console.print(f"🤖 Creating {template} agent: {name}")
+    
+    if template == "simple":
+        content = create_sample_agent()
+    else:
+        # TODO: Add more templates
+        content = create_sample_agent()
+    
+    agent_file.write_text(content)
+    
+    console.print(f"[green]✓[/green] Agent created: {agent_file}")
+    console.print("\nTo use this agent, update your setting.yaml:")
+    console.print(f"  runner.module_path: agents.{name}")
+    console.print("  runner.function_name: run")