fluxloop-cli 0.3.3__py3-none-any.whl → 0.3.4__py3-none-any.whl

fluxloop_cli/__init__.py

@@ -2,7 +2,7 @@
 FluxLoop CLI - Command-line interface for running agent simulations.
 """
 
-__version__ = "0.3.3"
+__version__ = "0.3.4"
 
 from .main import app
 

fluxloop_cli/commands/__init__.py

@@ -7,6 +7,8 @@ from . import (
     config,
     context,
     criteria,
+    data,
+    evaluate,
     generate,
     init,
     inputs,
@@ -27,6 +29,8 @@ __all__ = [
     "config",
     "context",
     "criteria",
+    "data",
+    "evaluate",
     "generate",
     "init",
     "inputs",

fluxloop_cli/commands/data.py

@@ -0,0 +1,657 @@
+"""
+Project data management commands for FluxLoop CLI.
+
+Provides commands for uploading, listing, and managing project data (Knowledge/Dataset).
+Implements the data push → confirm → (optional) bind workflow.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import mimetypes
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import httpx
+import typer
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.table import Table
+
+from ..api_utils import handle_api_error, resolve_api_url
+from ..context_manager import (
+    get_current_scenario_id,
+    get_current_web_project_id,
+)
+from ..http_client import create_authenticated_client
+
+app = typer.Typer(help="Manage project data (Knowledge & Datasets)")
+console = Console()
+
+
+# Extension-based auto-detection for data category
+DATASET_EXTENSIONS = {".csv", ".json", ".jsonl", ".xlsx", ".xls", ".tsv"}
+DOCUMENT_EXTENSIONS = {".pdf", ".docx", ".doc", ".md", ".txt", ".html", ".htm"}
+
+
+def _infer_data_category(file_path: Path, override: Optional[str] = None) -> str:
+    """
+    Infer data category from file extension or explicit override.
+
+    Args:
+        file_path: Path to the file.
+        override: Explicit category override ('document' or 'dataset').
+
+    Returns:
+        'KNOWLEDGE' for documents, 'DATASET' for structured data.
+    """
+    if override:
+        override_lower = override.lower()
+        if override_lower == "dataset":
+            return "DATASET"
+        elif override_lower in {"document", "knowledge"}:
+            return "KNOWLEDGE"
+
+    ext = file_path.suffix.lower()
+    if ext in DATASET_EXTENSIONS:
+        return "DATASET"
+    return "KNOWLEDGE"
+
+
+def _infer_mime_type(file_path: Path) -> str:
+    """Infer MIME type from file extension."""
+    mime_type, _ = mimetypes.guess_type(str(file_path))
+    return mime_type or "application/octet-stream"
+
+
+def _compute_content_hash(file_path: Path) -> str:
+    """Compute SHA-256 hash of file contents."""
+    sha256 = hashlib.sha256()
+    with open(file_path, "rb") as f:
+        for chunk in iter(lambda: f.read(8192), b""):
+            sha256.update(chunk)
+    return sha256.hexdigest()
+
+
+def _infer_file_type(file_path: Path) -> str:
+    """Infer file type from extension."""
+    ext = file_path.suffix.lower().lstrip(".")
+    return ext or "unknown"
+
+
+@app.command()
+def push(
+    file: Path = typer.Argument(..., help="File to upload to project data library"),
+    as_type: Optional[str] = typer.Option(
+        None,
+        "--as",
+        help="Data category: 'document' (Knowledge) or 'dataset'. Auto-detected if not specified.",
+    ),
+    scenario: Optional[str] = typer.Option(
+        None,
+        "--scenario",
+        help="Scenario ID to bind after upload (uses current context if not specified)",
+    ),
+    bind: bool = typer.Option(
+        False,
+        "--bind",
+        help="Bind to current scenario after upload",
+    ),
+    project_id: Optional[str] = typer.Option(
+        None,
+        "--project-id",
+        help="Project ID (defaults to current context)",
+    ),
+    api_url: Optional[str] = typer.Option(
+        None,
+        "--api-url",
+        help="FluxLoop API base URL",
+    ),
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="Minimal output"),
+):
+    """
+    Upload a file to the project data library.
+
+    The file is automatically categorized as KNOWLEDGE (documents) or DATASET
+    based on its extension. Use --as to override the auto-detection.
+
+    Examples:
+        # Upload a document (auto-detected)
+        fluxloop data push spec.pdf
+
+        # Upload as dataset explicitly
+        fluxloop data push users.csv --as dataset
+
+        # Upload and bind to current scenario
+        fluxloop data push test_data.json --bind
+
+        # Upload and bind to specific scenario
+        fluxloop data push requirements.md --scenario abc123
+    """
+    # Validate file exists
+    file = file.expanduser().resolve()
+    if not file.exists():
+        console.print(f"[red]✗[/red] File not found: {file}")
+        raise typer.Exit(1)
+    if not file.is_file():
+        console.print(f"[red]✗[/red] Not a file: {file}")
+        raise typer.Exit(1)
+
+    # Resolve project
+    api_url = resolve_api_url(api_url)
+    if not project_id:
+        project_id = get_current_web_project_id()
+        if not project_id:
+            console.print("[yellow]No Web Project selected.[/yellow]")
+            console.print("[dim]Select one with: fluxloop projects select <id>[/dim]")
+            raise typer.Exit(1)
+
+    # Infer data category
+    data_category = _infer_data_category(file, as_type)
+    category_display = "Dataset" if data_category == "DATASET" else "Document"
+
+    # Get file metadata
+    filename = file.name
+    file_size = file.stat().st_size
+    mime_type = _infer_mime_type(file)
+    file_type = _infer_file_type(file)
+
+    if not quiet:
+        console.print(f"[cyan]Uploading {filename}...[/cyan]")
+        console.print(f"  Type: {category_display} ({data_category})")
+        console.print(f"  Size: {file_size:,} bytes")
+
+    try:
+        client = create_authenticated_client(api_url, use_jwt=True)
+
+        # Step 1: Create data record and get upload URL
+        create_payload = {
+            "filename": filename,
+            "file_type": file_type,
+            "mime_type": mime_type,
+            "file_size": file_size,
+            "data_category": data_category,
+            "processing_profile": "auto",
+        }
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+            transient=True,
+        ) as progress:
+            task = progress.add_task("Creating upload...", total=None)
+
+            resp = client.post(
+                f"/api/projects/{project_id}/data",
+                json=create_payload,
+            )
+            handle_api_error(resp, "data upload")
+            create_result = resp.json()
+
+            data_record = create_result.get("data", {})
+            data_id = data_record.get("id")
+            upload_info = create_result.get("upload", {})
+            upload_url = upload_info.get("upload_url")
+            upload_headers = upload_info.get("headers") or {}
+
+            if not data_id or not upload_url:
+                console.print("[red]✗[/red] Failed to get upload URL")
+                raise typer.Exit(1)
+
+            progress.update(task, description="Uploading file...")
+
+            # Step 2: Upload file to signed URL
+            with open(file, "rb") as f:
+                file_bytes = f.read()
+
+            # Compute content hash
+            content_hash = hashlib.sha256(file_bytes).hexdigest()
+
+            upload_resp = httpx.put(
+                upload_url,
+                content=file_bytes,
+                headers=upload_headers,
+                timeout=120.0,
+            )
+            if not upload_resp.is_success:
+                console.print(f"[red]✗[/red] Upload failed: {upload_resp.status_code}")
+                raise typer.Exit(1)
+
+            progress.update(task, description="Confirming upload...")
+
+            # Step 3: Confirm upload
+            confirm_payload = {
+                "file_size": file_size,
+                "mime_type": mime_type,
+                "content_hash": content_hash,
+            }
+
+            confirm_resp = client.post(
+                f"/api/projects/{project_id}/data/{data_id}/confirm",
+                json=confirm_payload,
+            )
+            handle_api_error(confirm_resp, "upload confirmation")
+            confirmed_data = confirm_resp.json()
+
+        if not quiet:
+            console.print(f"[green]✓[/green] Uploaded: {filename}")
+            console.print(f"  Data ID: [bold]{data_id}[/bold]")
+            console.print(f"  Status: {confirmed_data.get('processing_status', 'queued')}")
+
+        # Step 4: (Optional) Bind to scenario
+        scenario_id = scenario
+        if bind and not scenario_id:
+            scenario_id = get_current_scenario_id()
+
+        if scenario_id:
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                console=console,
+                transient=True,
+            ) as progress:
+                task = progress.add_task("Binding to scenario...", total=None)
+
+                bind_payload = {"data_id": data_id}
+                bind_resp = client.post(
+                    f"/api/scenarios/{scenario_id}/data/bind",
+                    json=bind_payload,
+                )
+
+                if bind_resp.status_code == 404:
+                    console.print(f"[yellow]⚠[/yellow] Scenario not found: {scenario_id}")
+                elif bind_resp.status_code == 409:
+                    if not quiet:
+                        console.print(f"[dim]Already bound to scenario[/dim]")
+                elif bind_resp.is_success:
+                    if not quiet:
+                        console.print(f"[green]✓[/green] Bound to scenario: {scenario_id}")
+                else:
+                    console.print(f"[yellow]⚠[/yellow] Binding failed: {bind_resp.status_code}")
+
+    except Exception as e:
+        console.print(f"[red]✗[/red] Upload failed: {e}", style="bold red")
+        raise typer.Exit(1)
+
+
+@app.command("list")
+def list_data(
+    project_id: Optional[str] = typer.Option(
+        None,
+        "--project-id",
+        help="Project ID (defaults to current context)",
+    ),
+    category: Optional[str] = typer.Option(
+        None,
+        "--category",
+        help="Filter by category: 'document' or 'dataset'",
+    ),
+    api_url: Optional[str] = typer.Option(
+        None,
+        "--api-url",
+        help="FluxLoop API base URL",
+    ),
+):
+    """
+    List all data in the project library.
+
+    Shows both KNOWLEDGE (documents) and DATASET entries with their processing status.
+    """
+    api_url = resolve_api_url(api_url)
+
+    if not project_id:
+        project_id = get_current_web_project_id()
+        if not project_id:
+            console.print("[yellow]No Web Project selected.[/yellow]")
+            console.print("[dim]Select one with: fluxloop projects select <id>[/dim]")
+            raise typer.Exit(1)
+
+    try:
+        client = create_authenticated_client(api_url, use_jwt=True)
+
+        resp = client.get(f"/api/projects/{project_id}/data")
+        handle_api_error(resp, "project data list")
+
+        data = resp.json()
+        items = data.get("items", [])
+
+        # Filter by category if specified
+        if category:
+            category_filter = "DATASET" if category.lower() == "dataset" else "KNOWLEDGE"
+            items = [item for item in items if item.get("data_category") == category_filter]
+
+        if not items:
+            console.print("[yellow]No data found.[/yellow]")
+            console.print("[dim]Upload with: fluxloop data push <file>[/dim]")
+            return
+
+        # Create table
+        table = Table(title=f"Project Data Library ({len(items)} items)")
+        table.add_column("ID", style="cyan", max_width=12)
+        table.add_column("Filename", style="bold")
+        table.add_column("Category", style="magenta")
+        table.add_column("Status", style="green")
+        table.add_column("Size", justify="right")
+
+        for item in items:
+            data_id = item.get("id", "N/A")
+            # Truncate ID for display
+            display_id = data_id[:8] + "..." if len(data_id) > 11 else data_id
+
+            filename = item.get("filename") or "N/A"
+            category_val = item.get("data_category", "KNOWLEDGE")
+            category_display = "Dataset" if category_val == "DATASET" else "Document"
+            status = item.get("processing_status", "unknown")
+
+            # Format file size
+            file_size = item.get("file_size")
+            if file_size:
+                if file_size >= 1024 * 1024:
+                    size_str = f"{file_size / (1024 * 1024):.1f} MB"
+                elif file_size >= 1024:
+                    size_str = f"{file_size / 1024:.1f} KB"
+                else:
+                    size_str = f"{file_size} B"
+            else:
+                size_str = "-"
+
+            # Color status
+            status_style = {
+                "completed": "[green]completed[/green]",
+                "processing": "[yellow]processing[/yellow]",
+                "queued": "[blue]queued[/blue]",
+                "pending": "[dim]pending[/dim]",
+                "failed": "[red]failed[/red]",
+            }.get(status, status)
+
+            table.add_row(display_id, filename, category_display, status_style, size_str)
+
+        console.print(table)
+        console.print()
+        console.print("[dim]View details: fluxloop data show <id>[/dim]")
+
+    except Exception as e:
+        console.print(f"[red]✗[/red] List failed: {e}", style="bold red")
+        raise typer.Exit(1)
+
+
+@app.command()
+def show(
+    data_id: str = typer.Argument(..., help="Data ID to show details"),
+    project_id: Optional[str] = typer.Option(
+        None,
+        "--project-id",
+        help="Project ID (defaults to current context)",
+    ),
+    api_url: Optional[str] = typer.Option(
+        None,
+        "--api-url",
+        help="FluxLoop API base URL",
+    ),
+):
+    """
+    Show details of a specific data record.
+    """
+    api_url = resolve_api_url(api_url)
+
+    if not project_id:
+        project_id = get_current_web_project_id()
+        if not project_id:
+            console.print("[yellow]No Web Project selected.[/yellow]")
+            console.print("[dim]Select one with: fluxloop projects select <id>[/dim]")
+            raise typer.Exit(1)
+
+    try:
+        client = create_authenticated_client(api_url, use_jwt=True)
+
+        # Get data list and find the matching record
+        # (API doesn't have a direct GET by ID, so we list and filter)
+        resp = client.get(f"/api/projects/{project_id}/data")
+        handle_api_error(resp, "project data")
+
+        data = resp.json()
+        items = data.get("items", [])
+
+        # Find matching record (support partial ID match)
+        matching = [
+            item for item in items
+            if item.get("id", "").startswith(data_id) or item.get("id") == data_id
+        ]
+
+        if not matching:
+            console.print(f"[red]✗[/red] Data not found: {data_id}")
+            raise typer.Exit(1)
+
+        if len(matching) > 1:
+            console.print(f"[yellow]⚠[/yellow] Multiple matches found. Please use a longer ID prefix.")
+            for item in matching[:5]:
+                console.print(f"  - {item.get('id')}: {item.get('filename')}")
+            raise typer.Exit(1)
+
+        item = matching[0]
+
+        # Display details
+        console.print()
+        console.print(f"[bold blue]Data: {item.get('id')}[/bold blue]")
+        console.print()
+
+        console.print(f"[bold]Filename:[/bold] {item.get('filename', 'N/A')}")
+        console.print(f"[bold]Category:[/bold] {item.get('data_category', 'KNOWLEDGE')}")
+        console.print(f"[bold]Status:[/bold] {item.get('processing_status', 'unknown')}")
+
+        file_size = item.get("file_size")
+        if file_size:
+            console.print(f"[bold]Size:[/bold] {file_size:,} bytes")
+
+        mime_type = item.get("mime_type")
+        if mime_type:
+            console.print(f"[bold]MIME Type:[/bold] {mime_type}")
+
+        content_hash = item.get("content_hash")
+        if content_hash:
+            console.print(f"[bold]Content Hash:[/bold] {content_hash[:16]}...")
+
+        created_at = item.get("created_at")
+        if created_at:
+            console.print(f"[bold]Created:[/bold] {created_at}")
+
+        # Show processing error if any
+        error = item.get("processing_error")
+        if error:
+            console.print()
+            console.print(f"[red][bold]Error:[/bold] {error}[/red]")
+
+        # Show summary excerpt if available
+        summary = item.get("extracted_summary")
+        if summary:
+            console.print()
+            console.print("[bold]Summary:[/bold]")
+            # Truncate long summaries
+            if len(summary) > 500:
+                console.print(f"[dim]{summary[:500]}...[/dim]")
+            else:
+                console.print(f"[dim]{summary}[/dim]")
+
+    except Exception as e:
+        console.print(f"[red]✗[/red] Show failed: {e}", style="bold red")
+        raise typer.Exit(1)
+
+
+@app.command()
+def bind(
+    data_id: str = typer.Argument(..., help="Data ID to bind"),
+    scenario_id: Optional[str] = typer.Option(
+        None,
+        "--scenario",
+        "-s",
+        help="Scenario ID (defaults to current context)",
+    ),
+    role: Optional[str] = typer.Option(
+        None,
+        "--role",
+        help="Data role (e.g., 'input', 'expected', 'ground_truth')",
+    ),
+    api_url: Optional[str] = typer.Option(
+        None,
+        "--api-url",
+        help="FluxLoop API base URL",
+    ),
+):
+    """
+    Bind project data to a scenario.
+
+    Creates an association between data in the project library and a scenario,
+    allowing the scenario to use this data for testing.
+    """
+    api_url = resolve_api_url(api_url)
+
+    if not scenario_id:
+        scenario_id = get_current_scenario_id()
+        if not scenario_id:
+            console.print("[yellow]No scenario selected.[/yellow]")
+            console.print("[dim]Select one with: fluxloop scenarios select <id>[/dim]")
+            raise typer.Exit(1)
+
+    try:
+        client = create_authenticated_client(api_url, use_jwt=True)
+
+        bind_payload: Dict[str, Any] = {"data_id": data_id}
+
+        if role:
+            bind_payload["binding_meta"] = {"role": role}
+
+        console.print(f"[cyan]Binding data to scenario...[/cyan]")
+
+        resp = client.post(
+            f"/api/scenarios/{scenario_id}/data/bind",
+            json=bind_payload,
+        )
+
+        if resp.status_code == 409:
+            console.print(f"[yellow]⚠[/yellow] Data already bound to this scenario")
+            return
+
+        handle_api_error(resp, "data binding")
+
+        console.print(f"[green]✓[/green] Data bound to scenario")
+        console.print(f"  Data ID: {data_id}")
+        console.print(f"  Scenario ID: {scenario_id}")
+
+    except Exception as e:
+        console.print(f"[red]✗[/red] Binding failed: {e}", style="bold red")
+        raise typer.Exit(1)
+
+
+@app.command()
+def unbind(
+    binding_id: str = typer.Argument(..., help="Binding ID to remove"),
+    scenario_id: Optional[str] = typer.Option(
+        None,
+        "--scenario",
+        "-s",
+        help="Scenario ID (defaults to current context)",
+    ),
+    api_url: Optional[str] = typer.Option(
+        None,
+        "--api-url",
+        help="FluxLoop API base URL",
+    ),
+):
+    """
+    Remove a data binding from a scenario.
+    """
+    api_url = resolve_api_url(api_url)
+
+    if not scenario_id:
+        scenario_id = get_current_scenario_id()
+        if not scenario_id:
+            console.print("[yellow]No scenario selected.[/yellow]")
+            console.print("[dim]Select one with: fluxloop scenarios select <id>[/dim]")
+            raise typer.Exit(1)
+
+    try:
+        client = create_authenticated_client(api_url, use_jwt=True)
+
+        console.print(f"[cyan]Removing data binding...[/cyan]")
+
+        resp = client.delete(
+            f"/api/scenarios/{scenario_id}/data/bind/{binding_id}",
+        )
+
+        handle_api_error(resp, "data unbinding")
+
+        console.print(f"[green]✓[/green] Binding removed")
+
+    except Exception as e:
+        console.print(f"[red]✗[/red] Unbinding failed: {e}", style="bold red")
+        raise typer.Exit(1)
+
+
+@app.command()
+def reprocess(
+    data_id: str = typer.Argument(..., help="Data ID to reprocess"),
+    as_type: Optional[str] = typer.Option(
+        None,
+        "--as",
+        help="Change data category: 'document' or 'dataset'",
+    ),
+    project_id: Optional[str] = typer.Option(
+        None,
+        "--project-id",
+        help="Project ID (defaults to current context)",
+    ),
+    api_url: Optional[str] = typer.Option(
+        None,
+        "--api-url",
+        help="FluxLoop API base URL",
+    ),
+):
+    """
+    Reprocess data with a different category or to fix processing errors.
+
+    Useful when:
+    - Initial processing failed
+    - You want to change the data category (document ↔ dataset)
+    """
+    api_url = resolve_api_url(api_url)
+
+    if not project_id:
+        project_id = get_current_web_project_id()
+        if not project_id:
+            console.print("[yellow]No Web Project selected.[/yellow]")
+            console.print("[dim]Select one with: fluxloop projects select <id>[/dim]")
+            raise typer.Exit(1)
+
+    try:
+        client = create_authenticated_client(api_url, use_jwt=True)
+
+        reprocess_payload: Dict[str, Any] = {}
+
+        if as_type:
+            as_type_lower = as_type.lower()
+            if as_type_lower == "dataset":
+                reprocess_payload["data_category"] = "DATASET"
+                reprocess_payload["processing_profile"] = "dataset"
+            elif as_type_lower in {"document", "knowledge"}:
+                reprocess_payload["data_category"] = "KNOWLEDGE"
+                reprocess_payload["processing_profile"] = "document"
+
+        console.print(f"[cyan]Reprocessing data...[/cyan]")
+
+        resp = client.post(
+            f"/api/projects/{project_id}/data/{data_id}/reprocess",
+            json=reprocess_payload,
+        )
+
+        handle_api_error(resp, "data reprocess")
+
+        result = resp.json()
+        console.print(f"[green]✓[/green] Reprocessing queued")
+        console.print(f"  Data ID: {data_id}")
+        console.print(f"  Status: {result.get('processing_status', 'queued')}")
+
+    except Exception as e:
+        console.print(f"[red]✗[/red] Reprocess failed: {e}", style="bold red")
+        raise typer.Exit(1)

fluxloop_cli/commands/evaluate.py

@@ -0,0 +1,188 @@
+"""
+Trigger server-side evaluation for an experiment.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+import time
+from typing import List, Optional
+
+import typer
+from rich.console import Console
+
+from ..api_utils import handle_api_error, resolve_api_url
+from ..context_manager import get_current_web_project_id
+from ..http_client import create_authenticated_client, post_with_retry
+
+
+app = typer.Typer(help="Trigger evaluation for an experiment (server-side).")
+console = Console()
+
+def _parse_iso_datetime(value: Optional[str]) -> Optional[datetime]:
+    if not value:
+        return None
+    try:
+        if value.endswith("Z"):
+            value = value[:-1] + "+00:00"
+        return datetime.fromisoformat(value)
+    except ValueError:
+        return None
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    experiment_id: str = typer.Option(..., "--experiment-id", help="Experiment ID"),
+    project_id: Optional[str] = typer.Option(
+        None, "--project-id", help="Project ID (auto-detected from context)"
+    ),
+    config_id: Optional[str] = typer.Option(
+        None, "--config-id", help="Evaluation config ID (optional)"
+    ),
+    run_ids: Optional[List[str]] = typer.Option(
+        None, "--run-id", help="Specific run IDs to evaluate (repeatable)"
+    ),
+    force_rerun: bool = typer.Option(
+        False, "--force-rerun", help="Force re-run even if job exists"
+    ),
+    wait: bool = typer.Option(
+        False, "--wait", help="Wait for the evaluation job to complete"
+    ),
+    timeout: int = typer.Option(
+        600, "--timeout", help="Max seconds to wait for completion"
+    ),
+    poll_interval: int = typer.Option(
+        3, "--poll-interval", help="Polling interval in seconds"
+    ),
+    api_url: Optional[str] = typer.Option(
+        None, "--api-url", help="FluxLoop API base URL"
+    ),
+):
+    """
+    Trigger server-side evaluation for an experiment.
+
+    Uses the current logged-in user (JWT). If no config is provided, the server
+    will auto-select or use scenario defaults.
+    """
+    api_url = resolve_api_url(api_url)
+
+    if not project_id:
+        project_id = get_current_web_project_id()
+        if not project_id:
+            console.print("[yellow]No Web Project selected.[/yellow]")
+            console.print("[dim]Select one with: fluxloop projects select <id>[/dim]")
+            raise typer.Exit(1)
+
+    payload = {
+        "project_id": project_id,
+        "experiment_id": experiment_id,
+        "config_id": config_id,
+        "run_ids": run_ids,
+        "force_rerun": force_rerun,
+        "source": "cli",
+    }
+    payload = {k: v for k, v in payload.items() if v is not None}
+
+    client = create_authenticated_client(api_url, use_jwt=True)
+    resp = post_with_retry(client, "/api/evaluations", payload=payload)
+    handle_api_error(resp, "evaluation")
+    result = resp.json()
+
+    console.print("[green]✓[/green] Evaluation triggered")
+    console.print(f"  id: {result.get('evaluation_id')}")
+    console.print(f"  status: {result.get('status')}")
+
+    if not wait:
+        return
+
+    evaluation_id = result.get("evaluation_id")
+    if not evaluation_id:
+        console.print("[red]✗[/red] Missing evaluation_id in response.")
+        raise typer.Exit(1)
+
+    console.print("[dim]Waiting for evaluation job to complete...[/dim]")
+    start = time.monotonic()
+    warned = False
+    last_status = None
+
+    while True:
+        if time.monotonic() - start > timeout:
+            console.print("[red]✗[/red] Timed out waiting for evaluation job.")
+            raise typer.Exit(1)
+
+        resp = client.get(
+            f"/api/experiments/{experiment_id}/evaluations",
+            params={"project_id": project_id},
+        )
+        handle_api_error(resp, "evaluation jobs")
+        jobs = resp.json()
+        job = next((j for j in jobs if j.get("id") == evaluation_id), None)
+
+        if not job:
+            if last_status != "missing":
+                console.print("[yellow]⚠[/yellow] Evaluation job not visible yet. Retrying...")
+                last_status = "missing"
+            time.sleep(poll_interval)
+            continue
+
+        status = job.get("status") or "queued"
+        progress = job.get("progress") or {}
+        if status != last_status:
+            status_line = f"  status: {status}"
+            total = progress.get("total")
+            completed = progress.get("completed")
+            failed = progress.get("failed")
+            if total is not None:
+                status_line += f" ({completed or 0}/{total}"
+                if failed:
+                    status_line += f", failed {failed}"
+                status_line += ")"
+            console.print(status_line)
+            last_status = status
+
+        if status in ("completed", "partial", "failed", "cancelled"):
+            break
+
+        if status == "queued" and not warned:
+            created_at = _parse_iso_datetime(job.get("created_at"))
+            locked_at = _parse_iso_datetime(job.get("locked_at"))
+            if created_at and not locked_at:
+                age_seconds = (datetime.now(timezone.utc) - created_at).total_seconds()
+                if age_seconds > 30:
+                    console.print(
+                        "[yellow]⚠[/yellow] Evaluation job still queued. "
+                        "Worker may not be running or backlog is high."
+                    )
+                    warned = True
+
+        time.sleep(poll_interval)
+
+    if status in ("completed", "partial"):
+        insights_resp = client.get(
+            f"/api/experiments/{experiment_id}/insights",
+            params={"project_id": project_id},
+        )
+        handle_api_error(insights_resp, "insights")
+        insights = insights_resp.json()
+        insight_headline = None
+        if insights:
+            content = insights[0].get("content") or {}
+            summary = content.get("summary") or {}
+            insight_headline = summary.get("headline")
+
+        recos_resp = client.get(
+            f"/api/experiments/{experiment_id}/recommendations",
+            params={"project_id": project_id},
+        )
+        handle_api_error(recos_resp, "recommendations")
+        recos = recos_resp.json()
+        reco_headline = None
+        if recos:
+            content = recos[0].get("content") or {}
+            summary = content.get("summary") or {}
+            reco_headline = summary.get("headline")
+
+        if insight_headline:
+            console.print(f"[green]Insights[/green]: {insight_headline}")
+        if reco_headline:
+            console.print(f"[green]Recommendations[/green]: {reco_headline}")

fluxloop_cli/commands/inputs.py

@@ -57,6 +57,17 @@ def synthesize(
     count_per_persona: Optional[int] = typer.Option(
         None, "--count-per-persona", help="Number of inputs per persona"
     ),
+    include_data_context: Optional[bool] = typer.Option(
+        None,
+        "--include-data-context/--no-include-data-context",
+        help="Include scenario data summary as grounding context (default: true)",
+    ),
+    grounding_test_ratio: Optional[float] = typer.Option(
+        None,
+        "--grounding-ratio",
+        "--grounding-test-ratio",
+        help="Ratio of grounding tests when data context is available (0-1, default 0.3)",
+    ),
     bundle_version_id: Optional[str] = typer.Option(
         None, "--bundle-version-id", help="Bundle version ID to use for synthesis"
     ),
@@ -144,6 +155,12 @@ def synthesize(
     if count_per_persona is not None:
         payload["count_per_persona"] = count_per_persona
 
+    if include_data_context is not None:
+        payload["include_data_context"] = include_data_context
+
+    if grounding_test_ratio is not None:
+        payload["grounding_test_ratio"] = grounding_test_ratio
+
     if bundle_version_id:
         payload["bundle_version_id"] = bundle_version_id
 

fluxloop_cli/commands/personas.py

@@ -102,17 +102,22 @@ def suggest(
         table.add_column("Description")
 
         for persona in personas:
-            difficulty = persona.get("difficulty", "unknown")
+            attrs = persona.get("attributes") or {}
+            difficulty = attrs.get("difficulty") or persona.get("difficulty", "unknown")
             difficulty_display = {
                 "easy": "[green]Easy[/green]",
                 "medium": "[yellow]Medium[/yellow]",
                 "hard": "[red]Hard[/red]",
             }.get(difficulty, difficulty)
+            description = (
+                attrs.get("character_summary")
+                or persona.get("description", "N/A")
+            )
 
             table.add_row(
                 difficulty_display,
                 persona.get("name", "N/A"),
-                persona.get("description", "N/A"),
+                description,
             )
 
         console.print(table)
@@ -177,18 +182,23 @@ def list_personas(
         table.add_column("Description")
 
         for persona in personas:
-            difficulty = persona.get("difficulty", "unknown")
+            attrs = persona.get("attributes") or {}
+            difficulty = attrs.get("difficulty") or persona.get("difficulty", "unknown")
             difficulty_display = {
                 "easy": "[green]Easy[/green]",
                 "medium": "[yellow]Medium[/yellow]",
                 "hard": "[red]Hard[/red]",
             }.get(difficulty, difficulty)
+            description = (
+                attrs.get("character_summary")
+                or persona.get("description", "N/A")
+            )
 
             table.add_row(
                 persona.get("id", "N/A"),
                 persona.get("name", "N/A"),
                 difficulty_display,
-                persona.get("description", "N/A")[:50] + "..." if len(persona.get("description", "")) > 50 else persona.get("description", "N/A"),
+                description[:50] + "..." if len(description) > 50 else description,
             )
 
         console.print(table)

fluxloop_cli/commands/sync.py

@@ -361,6 +361,34 @@ def _write_criteria(criteria_dir: Path, criteria_pack: List[Dict[str, Any]]) ->
         )
 
 
+def _write_contracts(contracts_dir: Path, contracts: List[Dict[str, Any]]) -> None:
+    """Write contracts to individual YAML files.
+    
+    Contract structure from backend:
+    {
+        "type": "must" | "should" | "must_not",
+        "description": "...",
+        "category": "response" | "safety" | "ux" | ...
+    }
+    """
+    contracts_dir.mkdir(parents=True, exist_ok=True)
+    for idx, item in enumerate(contracts):
+        if not isinstance(item, dict):
+            continue
+        contract_type = item.get("type") or "contract"
+        category = item.get("category") or ""
+        if category:
+            name = f"{contract_type}_{category}_{idx + 1}"
+        else:
+            name = f"{contract_type}_{idx + 1}"
+        filename = _slugify(name)
+        path = contracts_dir / f"{filename}.yaml"
+        path.write_text(
+            yaml.safe_dump(item, sort_keys=False, allow_unicode=True),
+            encoding="utf-8",
+        )
+
+
 def _extract_input_text(messages: Any) -> str:
     if isinstance(messages, list):
         for entry in messages:
@@ -578,9 +606,20 @@ def pull(
     _write_json(sync_dir / "criteria.json", {"items": criteria_pack})
     _write_criteria(state_dir / "criteria", criteria_pack if isinstance(criteria_pack, list) else [])
 
+    # Save scenario_context (scenario info + contracts)
+    scenario_context = data.get("scenario_context") or {}
+    scenario_info = scenario_context.get("scenario") if isinstance(scenario_context, dict) else {}
+    contracts = scenario_context.get("contracts", []) if isinstance(scenario_context, dict) else []
+    if scenario_info:
+        _write_json(sync_dir / "scenario.json", scenario_info)
+    if contracts:
+        _write_json(sync_dir / "contracts.json", {"items": contracts})
+        _write_contracts(state_dir / "contracts", contracts if isinstance(contracts, list) else [])
+
     sync_state = {
         "project_id": data.get("bundle_version", {}).get("project_id") or project_id,
         "bundle_version_id": data.get("bundle_version", {}).get("id"),
+        "scenario_id": scenario_info.get("id") if scenario_info else None,
         "inputs_file": inputs_file,
         "pulled_at": data.get("sync_meta", {}).get("pulled_at"),
         "api_url": api_url,
@@ -589,6 +628,8 @@ def pull(
 
     if not quiet:
         console.print(f"[green]✓[/green] Pulled {len(inputs_payload['inputs'])} inputs")
+        if contracts:
+            console.print(f"[green]✓[/green] Pulled {len(contracts)} contracts")
         console.print(f"[green]✓[/green] Saved inputs to {inputs_path}")
         console.print(f"[green]✓[/green] Saved sync metadata to {_sync_state_paths(scenario_root)[0]}")
 

fluxloop_cli/commands/test.py

@@ -18,9 +18,11 @@ from ..config_loader import load_experiment_config, load_project_config
 from ..constants import DEFAULT_CONFIG_PATH, FLUXLOOP_DIR_NAME, SCENARIOS_DIR_NAME, STATE_DIR_NAME
 from ..project_paths import resolve_config_path
 from ..runner import ExperimentRunner
+from fluxloop.schemas import MultiTurnConfig
 from ..turns import (
     TurnRecorder,
     format_warning_for_display,
+    load_contracts,
     load_criteria_items,
     load_guardrails_from_config,
     render_result_markdown,
@@ -58,6 +60,31 @@ def main(
         "--stream-after-upload/--stream-during-run",
         help="Stream turns only after upload completes (default: during run)",
     ),
+    multi_turn: Optional[bool] = typer.Option(
+        None,
+        "--multi-turn/--no-multi-turn",
+        help="Enable or disable multi-turn supervisor loop",
+    ),
+    max_turns: Optional[int] = typer.Option(
+        None,
+        "--max-turns",
+        help="Maximum number of turns per conversation (requires --multi-turn)",
+    ),
+    supervisor_provider: Optional[str] = typer.Option(
+        None,
+        "--supervisor-provider",
+        help="Supervisor LLM provider (openai, anthropic)",
+    ),
+    supervisor_model: Optional[str] = typer.Option(
+        None,
+        "--supervisor-model",
+        help="Supervisor LLM model (e.g., gpt-5-mini, claude-sonnet-4-5-20250514)",
+    ),
+    supervisor_api_key: Optional[str] = typer.Option(
+        None,
+        "--supervisor-api-key",
+        help="API key for supervisor LLM (or use OPENAI_API_KEY/ANTHROPIC_API_KEY env)",
+    ),
     smoke: bool = typer.Option(False, "--smoke", help="Run a smoke test"),
     full: bool = typer.Option(False, "--full", help="Run full test"),
     quiet: bool = typer.Option(False, "--quiet", help="Minimal output"),
@@ -94,6 +121,21 @@ def main(
         require_inputs_file=False,
     )
 
+    # Apply multi-turn options
+    if any(v is not None for v in [multi_turn, max_turns, supervisor_provider, supervisor_model, supervisor_api_key]):
+        if config.multi_turn is None:
+            config.multi_turn = MultiTurnConfig()
+        if multi_turn is not None:
+            config.multi_turn.enabled = multi_turn
+        if max_turns is not None:
+            config.multi_turn.max_turns = max_turns
+        if supervisor_provider is not None:
+            config.multi_turn.supervisor.provider = supervisor_provider
+        if supervisor_model is not None:
+            config.multi_turn.supervisor.model = supervisor_model
+        if supervisor_api_key is not None:
+            config.multi_turn.supervisor.api_key = supervisor_api_key
+
     # Check if inputs file exists
     if config.inputs_file:
         source_dir = config.get_source_dir()
@@ -141,6 +183,7 @@ def main(
     recorder = TurnRecorder(runner.output_dir / "turns.jsonl", guardrails)
     state_dir = scenario_root / STATE_DIR_NAME
     criteria_items = load_criteria_items(state_dir / "criteria")
+    contracts = load_contracts(state_dir / "contracts")
     result_path = runner.output_dir / "result.md"
     result_path.write_text("", encoding="utf-8")
     latest_path = write_latest_result_link(scenario_root, result_path)
@@ -425,6 +468,15 @@ def main(
     console.print(
         f"결과: {summary.total_turns} turns, {summary.warning_turns} warning turns"
     )
+    if contracts:
+        console.print("\n[Contracts]")
+        for contract in contracts:
+            ctype = contract.get("type", "contract")
+            desc = contract.get("description", "")
+            category = contract.get("category", "")
+            prefix = {"must": "✓", "should": "○", "must_not": "✗"}.get(ctype, "•")
+            cat_label = f" [{category}]" if category else ""
+            console.print(f"  {prefix} {ctype.upper()}{cat_label}: {desc}")
     if criteria_items:
         console.print("\n[평가 기준]")
         for item in criteria_items:

fluxloop_cli/conversation_supervisor.py

@@ -149,6 +149,8 @@ class ConversationSupervisor:
             return self._mock_decision(conversation_state)
         if provider == "openai":
             response_text = await self._call_openai(prompt)
+        elif provider == "anthropic":
+            response_text = await self._call_anthropic(prompt)
         else:
             raise ValueError(f"Unsupported supervisor provider: {self.config.provider}")
 
@@ -279,6 +281,67 @@ class ConversationSupervisor:
 
         return content
 
+    async def _call_anthropic(self, prompt: str) -> str:
+        """Call Anthropic messages endpoint."""
+
+        api_key = (
+            self.config.api_key
+            or self.config.metadata.get("api_key")
+            or os.getenv("FLUXLOOP_SUPERVISOR_API_KEY")
+            or os.getenv("ANTHROPIC_API_KEY")
+        )
+
+        if not api_key:
+            raise RuntimeError(
+                "Anthropic supervisor requires an API key. "
+                "Set multi_turn.supervisor.api_key or FLUXLOOP_SUPERVISOR_API_KEY/ANTHROPIC_API_KEY."
+            )
+
+        messages: List[Dict[str, str]] = [{"role": "user", "content": prompt}]
+
+        payload: Dict[str, Any] = {
+            "model": self.config.model or "claude-sonnet-4-5-20250514",
+            "max_tokens": 1024,
+            "messages": messages,
+        }
+        if self.config.system_prompt:
+            payload["system"] = self.config.system_prompt
+        if self.config.temperature is not None:
+            payload["temperature"] = self.config.temperature
+
+        async with httpx.AsyncClient(timeout=60) as client:
+            response = await client.post(
+                "https://api.anthropic.com/v1/messages",
+                headers={
+                    "x-api-key": api_key,
+                    "anthropic-version": "2023-06-01",
+                    "Content-Type": "application/json",
+                },
+                json=payload,
+            )
+
+        if response.status_code >= 400:
+            raise RuntimeError(
+                f"Anthropic supervisor request failed ({response.status_code}): {response.text}"
+            )
+
+        data = response.json()
+        content_blocks = data.get("content") or []
+        if not content_blocks:
+            raise RuntimeError("Anthropic supervisor response contained no content.")
+
+        # Extract text from content blocks
+        text_parts = []
+        for block in content_blocks:
+            if block.get("type") == "text":
+                text_parts.append(block.get("text", ""))
+
+        content = "".join(text_parts)
+        if not content:
+            raise RuntimeError("Anthropic supervisor response missing text content.")
+
+        return content
+
     def _parse_decision(self, content: str) -> SupervisorDecision:
         """Extract JSON payload from supervisor response and convert to decision."""
 

fluxloop_cli/main.py

@@ -17,6 +17,8 @@ from .commands import (
     config,
     context,
     criteria,
+    data,
+    evaluate,
     generate,
     init,
     inputs,
@@ -66,6 +68,7 @@ app.add_typer(config.app, name="config", help="Manage configuration")
 app.add_typer(generate.app, name="generate", help="Generate input datasets")
 app.add_typer(sync.app, name="sync", help="Sync bundles and upload results")
 app.add_typer(criteria.app, name="criteria", help="Show pulled evaluation criteria")
+app.add_typer(evaluate.app, name="evaluate", help="Trigger server-side evaluation")
 app.add_typer(test.app, name="test", help="Run pull -> run -> upload test workflow")
 app.add_typer(auth.app, name="auth", help="Manage authentication")
 app.add_typer(apikeys.app, name="apikeys", help="Manage API Keys for sync operations")
@@ -76,6 +79,7 @@ app.add_typer(local_context.app, name="context", help="Manage local working cont
 app.add_typer(personas.app, name="personas", help="Manage test personas")
 app.add_typer(inputs.app, name="inputs", help="Synthesize and manage test inputs")
 app.add_typer(bundles.app, name="bundles", help="Manage test bundles")
+app.add_typer(data.app, name="data", help="Manage project data (Knowledge & Datasets)")
 
 
 def version_callback(value: bool):

fluxloop_cli/turns.py

@@ -78,6 +78,29 @@ def load_criteria_items(criteria_dir: Path) -> List[str]:
     return items
 
 
+def load_contracts(contracts_dir: Path) -> List[Dict[str, Any]]:
+    """Load contracts from YAML files in contracts directory.
+    
+    Contract structure:
+    {
+        "type": "must" | "should" | "must_not",
+        "description": "...",
+        "category": "response" | "safety" | "ux" | ...
+    }
+    
+    Returns:
+        List of contract dictionaries.
+    """
+    if not contracts_dir.exists():
+        return []
+    contracts: List[Dict[str, Any]] = []
+    for path in sorted(contracts_dir.glob("*.yaml")):
+        payload = yaml.safe_load(path.read_text()) or {}
+        if isinstance(payload, dict):
+            contracts.append(payload)
+    return contracts
+
+
 def _slugify(value: str) -> str:
     value = value.strip().lower()
     value = re.sub(r"[^a-z0-9_-]+", "_", value)

{fluxloop_cli-0.3.3.dist-info → fluxloop_cli-0.3.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fluxloop-cli
-Version: 0.3.3
+Version: 0.3.4
 Summary: FluxLoop CLI for running agent simulations
 Author-email: FluxLoop Team <team@fluxloop.dev>
 License: Apache-2.0

{fluxloop_cli-0.3.3.dist-info → fluxloop_cli-0.3.4.dist-info}/RECORD

@@ -1,4 +1,4 @@
-fluxloop_cli/__init__.py,sha256=knPR9CZHtyDIQa-LiVPEB_HyDsZGCtcwxVIpKdYr5pc,142
+fluxloop_cli/__init__.py,sha256=ERNY4HfqVBiouvq4533yUMZVFVih-RaJCDFKXbw_Un0,142
 fluxloop_cli/api_utils.py,sha256=5286hlpGBbBPrpTID0B2YGwZ7aIVL4V6S_mUKJUS30s,5849
 fluxloop_cli/arg_binder.py,sha256=8nWMWtItzL0z0UNIfWTjy2kyZa4Fbf2w2RChBcU9-_U,12661
 fluxloop_cli/auth_manager.py,sha256=9O8rHVMY4oJS3f9mfL19PWzSWjMKcLgLAugdWqtj8s0,12272
@@ -7,42 +7,44 @@ fluxloop_cli/config_loader.py,sha256=lZ_JSJT6Vmt-RpiNCUWBRsbqFZYTknOUZ4XjuPDEctc
 fluxloop_cli/config_schema.py,sha256=c78ZTGPp4biVEQ1DSTl-wZxUAPsR3gke6RwPvR-CxYQ,2232
 fluxloop_cli/constants.py,sha256=uAVI5xaGRFWizQFLptac8MI8Y805Nw87Fhz-UTJFUIw,1622
 fluxloop_cli/context_manager.py,sha256=vg8-Tyu_Dk1iMWKPn3dd-3mQ3e2M9UGoAC47Hsq7vog,19794
-fluxloop_cli/conversation_supervisor.py,sha256=2GZLyryj6_2O22BVLhRarT24NoQHtxIG-_YrH0SscEY,11539
+fluxloop_cli/conversation_supervisor.py,sha256=4mSYBQCMJ0leebnLYyJOhfuf7knI5yDV_R1LCG2ZJu8,13831
 fluxloop_cli/environment.py,sha256=mUvb4okk4CMeCDK48J6rv44Mvo3uV1Ab6e-EMHlc2Eo,1957
 fluxloop_cli/http_client.py,sha256=9SIReADgqp8s3YOPa845j8TdKYI67yVnXgDjGxIx114,4309
 fluxloop_cli/input_generator.py,sha256=xGASayR3rgdfqtcMCIXHVzI6RpRfMK6EWfgwojvcWjM,8668
 fluxloop_cli/llm_generator.py,sha256=K8Qn658j59YdfAMO301ZNVgHqTCs0lHgitoPAIyfnPg,12939
-fluxloop_cli/main.py,sha256=H0POgtyKmAIwQQNFHiDuWhsjyDxXSJ6PMg7ZUwEujwE,4077
+fluxloop_cli/main.py,sha256=i5JGxXAOtJ6lpp9s2kh3a0I5X5i4yD4V0iIoz1FsqLU,4273
 fluxloop_cli/project_paths.py,sha256=ZxdrGPsNS9csUcgocdWUKlHfuJLJp0Zf3OjYZXh3ONk,9504
 fluxloop_cli/runner.py,sha256=c9HdOVh7urXUjCC4YB9FmkZiyd6yndg7nX9fc-qzpp8,58101
 fluxloop_cli/target_loader.py,sha256=ACCu2izqGKoOrEiNnAajH0FgLZcw3j1pWn5rAhEuWFU,5528
 fluxloop_cli/templates.py,sha256=Vc0DU8jouuTo965mej2SkFDCFcqlNvCAOtAtftqPgA4,19958
 fluxloop_cli/token_usage.py,sha256=uhFLLj7XmjX1KqpsoYMzdpjLAu3L_IzPE6Wn42eb4Mo,5767
-fluxloop_cli/turns.py,sha256=ss3plXmW3cHZ92lF0YarPHyNoLCN6UD7iDN0rzpWYlw,8781
+fluxloop_cli/turns.py,sha256=A5ideezc6qF8lwA-Ix3hNqnZi2SDVNbsQXfm_XEaJeE,9451
 fluxloop_cli/validators.py,sha256=_bLXmxUSzVrDtLjqyTba0bDqamRIaOUHhV4xZ7K36Xw,1155
-fluxloop_cli/commands/__init__.py,sha256=s_1AllEdgmxuFU-6YITH0GoQBFluD5t81NxzLCl2jeU,516
+fluxloop_cli/commands/__init__.py,sha256=POaiw0YHFAUULUMw9KwlI3lByk2Cwjz691Zk1hycgrU,568
 fluxloop_cli/commands/apikeys.py,sha256=WW76OYZcnMuA45j5DENkhipK8kbrco91uDLvOw4QWsQ,9324
 fluxloop_cli/commands/auth.py,sha256=YrHfjHjtM3SxAIBr4ohRMfJtNm2RXPmo6D8UXCt-REY,12849
 fluxloop_cli/commands/bundles.py,sha256=Ohs1YKhYNtB5QtlcV_wGVFwpTPxX0cjDlsLm2nA1IW8,13643
 fluxloop_cli/commands/config.py,sha256=M2e6Kt6-faKoLTfbe5PI0-5RbNlDtSrlsEgVK9ZXPKM,13665
 fluxloop_cli/commands/context.py,sha256=w2fjNAlj_dWPc5hlu1b2e8aiwZfsLd1fdY_rtm8nt0o,3675
 fluxloop_cli/commands/criteria.py,sha256=EI9due-7DxeO79h16Cp3ANUEeB-mGcUsXWnn_eqXGtU,2072
+fluxloop_cli/commands/data.py,sha256=BfN5kf_LbFPgiPLzPS5KhLC69a-biqhqLn5M90i-xFA,21861
+fluxloop_cli/commands/evaluate.py,sha256=xIUbk166pYWK6CQwljHmq1ko-E7qRlj5lvGBs-yDtqI,6620
 fluxloop_cli/commands/generate.py,sha256=6tBanI8gj5Zzwz2cv1YeW60bYiO7iWivD0AgOcJ-GUU,7172
 fluxloop_cli/commands/init.py,sha256=_rJmlr0vU7na-b4Tu--4pzuUoQA3RKBo2YxL8WJzrnk,9399
-fluxloop_cli/commands/inputs.py,sha256=Gp-ZJJKXddOaRNIeWm8pHThqnnRNzTmH4hmLHmEhJTA,20041
+fluxloop_cli/commands/inputs.py,sha256=ietOkhdveNLwu-75IV4JWCCpux-cr7RNAe2Wqxv8eQo,20705
 fluxloop_cli/commands/local_context.py,sha256=wD60pbrbqUrC7U6wHyEnJ6Ggg6JQ0VNizFEbalBX7rI,6300
-fluxloop_cli/commands/personas.py,sha256=ZkHR0JW1Too-kdDGCl2zFRAGMMQkk90HoAgrIlBnv4Y,7931
+fluxloop_cli/commands/personas.py,sha256=5AYqHdsdTDAVgg1x1ojOlP0Igsn-Ri2rsCAaRy7Rqy0,8288
 fluxloop_cli/commands/projects.py,sha256=MJvG4isb49GkeFTOVQnktfVXlQMwijUlf-WFhPTMy8Y,8733
 fluxloop_cli/commands/run.py,sha256=PCW-W7-nTrpMjuLhtag6qQdJP3ZOCgve4jKSeLE2QJY,16404
 fluxloop_cli/commands/scenarios.py,sha256=1_4nFr5Q3Q_S7eMkLSTZX8Y7lLG_rMXO8US5tSR0gqE,18014
 fluxloop_cli/commands/status.py,sha256=B3MoMUAxRrwdxUBOlnQvQoJF-FMKKCCjdR8RK3t7kmc,7916
-fluxloop_cli/commands/sync.py,sha256=9UhsD6NJuoWw1Axu3pVcc_vWbJ172UA2_U6-hqbkfwg,29194
-fluxloop_cli/commands/test.py,sha256=vJ-GnimkErUwlGmDmMWgI9A6uFauxHEw8hAP9Dsp21M,18780
+fluxloop_cli/commands/sync.py,sha256=UukrXl4Mg5eb-G3ioG0Cl_FgCKJE3tRInbyeHoY60bM,30911
+fluxloop_cli/commands/test.py,sha256=bx_Q1Skw_zPQVRh7GIlFJI6T2qRomcWyHHOJNgI8bns,21015
 fluxloop_cli/testing/__init__.py,sha256=3FZ0JzA6gbeDAOlvplEiNDplbOXmNT-TYQ-4C7eHUlo,482
 fluxloop_cli/testing/pytest_plugin.py,sha256=LcQaxEa3qr5SS4eM5ujRsmd8j0PaqjICpXFZG4fbF2w,12896
 fluxloop_cli/testing/types.py,sha256=CcpoSnV-eOBc_Ngvg6ZRpeb-Bnz4eT2zBdGz0-icVB4,6190
-fluxloop_cli-0.3.3.dist-info/METADATA,sha256=GlRRHbVJlUXBDWwO5cEyRhpA7YX-clzvV4aVHpageP4,7296
-fluxloop_cli-0.3.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-fluxloop_cli-0.3.3.dist-info/entry_points.txt,sha256=NxOEMku4yLMY5kp_Qcd3JcevfXP6A98FsSf9xHcwkyE,51
-fluxloop_cli-0.3.3.dist-info/top_level.txt,sha256=ahLkaxzwhmVU4z-YhkmQVzAbW3-wez9cKnwPiDK7uKM,13
-fluxloop_cli-0.3.3.dist-info/RECORD,,
+fluxloop_cli-0.3.4.dist-info/METADATA,sha256=aPjDxA-PBnl11DyK_ClmX2bR44HVGDuSomd155yzE4o,7296
+fluxloop_cli-0.3.4.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+fluxloop_cli-0.3.4.dist-info/entry_points.txt,sha256=NxOEMku4yLMY5kp_Qcd3JcevfXP6A98FsSf9xHcwkyE,51
+fluxloop_cli-0.3.4.dist-info/top_level.txt,sha256=ahLkaxzwhmVU4z-YhkmQVzAbW3-wez9cKnwPiDK7uKM,13
+fluxloop_cli-0.3.4.dist-info/RECORD,,

{fluxloop_cli-0.3.3.dist-info → fluxloop_cli-0.3.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.2)
+Generator: setuptools (82.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any