epi-recorder 1.0.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

epi_cli/verify.py

@@ -46,7 +46,7 @@ def verify(
     """
     # Ensure file exists
     if not epi_file.exists():
-        console.print(f"[red]❌ Error:[/red] File not found: {epi_file}")
+        console.print(f"[red][FAIL] Error:[/red] File not found: {epi_file}")
         raise typer.Exit(1)
     
     # Initialize verification state
@@ -65,11 +65,11 @@ def verify(
         try:
             manifest = EPIContainer.read_manifest(epi_file)
             if verbose:
-                console.print("  [green]✅[/green] Valid ZIP format")
-                console.print("  [green]✅[/green] Valid mimetype")
-                console.print("  [green]✅[/green] Valid manifest schema")
+                console.print("  [green][OK][/green] Valid ZIP format")
+                console.print("  [green][OK][/green] Valid mimetype")
+                console.print("  [green][OK][/green] Valid manifest schema")
         except Exception as e:
-            console.print(f"[red]❌ Structural validation failed:[/red] {e}")
+            console.print(f"[red][FAIL] Structural validation failed:[/red] {e}")
             raise typer.Exit(1)
         
         # ========== STEP 2: INTEGRITY CHECKS ==========
@@ -80,9 +80,9 @@ def verify(
         
         if verbose:
             if integrity_ok:
-                console.print(f"  [green]✅[/green] All {len(manifest.file_manifest)} files verified")
+                console.print(f"  [green][OK][/green] All {len(manifest.file_manifest)} files verified")
             else:
-                console.print(f"  [red]❌[/red] {len(mismatches)} file(s) failed verification")
+                console.print(f"  [red][FAIL][/red] {len(mismatches)} file(s) failed verification")
                 for filename, reason in mismatches.items():
                     console.print(f"    [red]•[/red] {filename}: {reason}")
         
@@ -101,19 +101,19 @@ def verify(
                 
                 if verbose:
                     if signature_valid:
-                        console.print(f"  [green]✅[/green] {sig_message}")
+                        console.print(f"  [green][OK][/green] {sig_message}")
                     else:
-                        console.print(f"  [red]❌[/red] {sig_message}")
+                        console.print(f"  [red][FAIL][/red] {sig_message}")
             
             except FileNotFoundError:
                 signature_valid = False
                 if verbose:
-                    console.print(f"  [yellow]⚠️[/yellow]  Public key not found: {signer_name}")
+                    console.print(f"  [yellow][WARN][/yellow]  Public key not found: {signer_name}")
                     console.print("  [dim]Cannot verify signature without public key[/dim]")
         else:
             signature_valid = None
             if verbose:
-                console.print("  [yellow]⚠️[/yellow]  No signature present (unsigned)")
+                console.print("  [yellow][WARN][/yellow]  No signature present (unsigned)")
         
         # ========== CREATE REPORT ==========
         report = create_verification_report(
@@ -143,7 +143,7 @@ def verify(
         if verbose:
             console.print_exception()
         else:
-            console.print(f"[red]❌ Verification failed:[/red] {e}")
+            console.print(f"[red][FAIL] Verification failed:[/red] {e}")
         raise typer.Exit(1)
 
 
@@ -158,15 +158,15 @@ def print_trust_report(report: dict, epi_file: Path, verbose: bool = False):
     """
     # Determine overall status symbol and color
     if report["trust_level"] == "HIGH":
-        status_symbol = "✅"
+        status_symbol = "[OK]"
         status_color = "green"
         panel_style = "green"
     elif report["trust_level"] == "MEDIUM":
-        status_symbol = "⚠️"
+        status_symbol = "[WARN]"
         status_color = "yellow"
         panel_style = "yellow"
     else:
-        status_symbol = "❌"
+        status_symbol = "[FAIL]"
         status_color = "red"
         panel_style = "red"
     
@@ -179,17 +179,17 @@ def print_trust_report(report: dict, epi_file: Path, verbose: bool = False):
     
     # Integrity status
     if report["integrity_ok"]:
-        content_lines.append(f"[green]✅ Integrity:[/green] Verified ({report['files_checked']} files)")
+        content_lines.append(f"[green][OK] Integrity:[/green] Verified ({report['files_checked']} files)")
     else:
-        content_lines.append(f"[red]❌ Integrity:[/red] Failed ({report['mismatches_count']} mismatches)")
+        content_lines.append(f"[red][FAIL] Integrity:[/red] Failed ({report['mismatches_count']} mismatches)")
     
     # Signature status
     if report["signature_valid"]:
-        content_lines.append(f"[green]✅ Signature:[/green] Valid (key: {report['signer']})")
+        content_lines.append(f"[green][OK] Signature:[/green] Valid (key: {report['signer']})")
     elif report["signature_valid"] is None:
-        content_lines.append("[yellow]⚠️  Signature:[/yellow] Not signed")
+        content_lines.append("[yellow][WARN]  Signature:[/yellow] Not signed")
     else:
-        content_lines.append(f"[red]❌ Signature:[/red] Invalid")
+        content_lines.append(f"[red][FAIL] Signature:[/red] Invalid")
     
     # Show metadata if verbose
     if verbose:

epi_cli/view.py

@@ -17,26 +17,81 @@ console = Console()
 
 app = typer.Typer(name="view", help="View .epi file in browser")
 
+DEFAULT_DIR = Path("epi-recordings")
+
+
+def _resolve_epi_file(name_or_path: str) -> Path:
+    """
+    Resolve a name or path to an .epi file.
+    
+    Tries in order:
+    1. Exact path if it exists
+    2. Add .epi extension if missing
+    3. Look in ./epi-recordings/ directory
+    
+    Args:
+        name_or_path: User input (name or path)
+        
+    Returns:
+        Resolved Path object
+        
+    Raises:
+        FileNotFoundError if file cannot be found
+    """
+    path = Path(name_or_path)
+    
+    # Try exact path
+    if path.exists() and path.is_file():
+        return path
+    
+    # Try adding .epi extension
+    if not str(path).endswith(".epi"):
+        with_ext = path.with_suffix(".epi")
+        if with_ext.exists():
+            return with_ext
+    
+    # Try in default directory
+    in_default = DEFAULT_DIR / path.name
+    if in_default.exists():
+        return in_default
+    
+    # Try in default directory with .epi extension
+    in_default_with_ext = DEFAULT_DIR / f"{path.stem}.epi"
+    if in_default_with_ext.exists():
+        return in_default_with_ext
+    
+    # Not found
+    raise FileNotFoundError(f"Recording not found: {name_or_path}")
+
 
 @app.callback(invoke_without_command=True)
 def view(
     ctx: typer.Context,
-    epi_file: Path = typer.Argument(..., help="Path to .epi file to view"),
+    epi_file: str = typer.Argument(..., help="Path or name of .epi file to view"),
 ):
     """
     Open .epi file in browser viewer.
     
-    Extracts the embedded viewer.html and opens it in your default browser.
-    All data is pre-embedded, no server required.
+    Accepts file path, name, or base name. Automatically resolves:
+    - foo -> ./epi-recordings/foo.epi
+    - foo.epi -> ./epi-recordings/foo.epi
+    - /path/to/file.epi -> /path/to/file.epi
+    
+    Example:
+        epi view my_script_20251121_231501
+        epi view my_recording.epi
     """
-    # Validate file exists
-    if not epi_file.exists():
-        console.print(f"[red]❌ Error:[/red] File not found: {epi_file}")
+    # Resolve the file path
+    try:
+        resolved_path = _resolve_epi_file(epi_file)
+    except FileNotFoundError as e:
+        console.print(f"[red][FAIL] Error:[/red] {e}")
+        console.print(f"[dim]Tip: Run 'epi ls' to see available recordings[/dim]")
         raise typer.Exit(1)
     
     # Validate it's a ZIP file
-    if not zipfile.is_zipfile(epi_file):
-        console.print(f"[red]❌ Error:[/red] Not a valid .epi file: {epi_file}")
+    if not zipfile.is_zipfile(resolved_path):
+        console.print(f"[red][FAIL] Error:[/red] Not a valid .epi file: {resolved_path}")
         raise typer.Exit(1)
     
     try:
@@ -45,9 +100,9 @@ def view(
         viewer_path = temp_dir / "viewer.html"
         
         # Extract viewer.html
-        with zipfile.ZipFile(epi_file, "r") as zf:
+        with zipfile.ZipFile(resolved_path, "r") as zf:
             if "viewer.html" not in zf.namelist():
-                console.print("[red]❌ Error:[/red] No viewer found in .epi file")
+                console.print("[red][FAIL] Error:[/red] No viewer found in .epi file")
                 console.print("[dim]This file may have been created with an older version of EPI[/dim]")
                 raise typer.Exit(1)
             
@@ -61,14 +116,14 @@ def view(
         success = webbrowser.open(file_url)
         
         if success:
-            console.print("[green]✅[/green] Viewer opened in browser")
+            console.print("[green][OK][/green] Viewer opened in browser")
         else:
-            console.print("[yellow]⚠️  Could not open browser automatically[/yellow]")
+            console.print("[yellow][WARN]  Could not open browser automatically[/yellow]")
             console.print(f"[dim]Open manually:[/dim] {file_url}")
         
     except KeyboardInterrupt:
         console.print("\n[yellow]Cancelled[/yellow]")
         raise typer.Exit(130)
     except Exception as e:
-        console.print(f"[red]❌ Error:[/red] {e}")
+        console.print(f"[red][FAIL] Error:[/red] {e}")
         raise typer.Exit(1)

epi_core/redactor.py

@@ -78,17 +78,19 @@ class Redactor:
     from captured workflow data.
     """
     
-    def __init__(self, config_path: Path | None = None, enabled: bool = True):
+    def __init__(self, config_path: Path | None = None, enabled: bool = True, allowlist: List[str] = None):
         """
         Initialize redactor with optional custom configuration.
         
         Args:
             config_path: Optional path to config.toml with custom patterns
             enabled: Whether redaction is enabled (default: True)
+            allowlist: Optional list of strings to NEVER redact
         """
         self.enabled = enabled
         self.patterns: List[Tuple[re.Pattern, str]] = []
         self.env_vars_to_redact = REDACT_ENV_VARS.copy()
+        self.allowlist = set(allowlist) if allowlist else set()
         
         # Compile default patterns
         for pattern_str, description in DEFAULT_REDACTION_PATTERNS:
@@ -132,6 +134,10 @@ class Redactor:
             # Load custom env vars
             if 'redaction' in config and 'env_vars' in config['redaction']:
                 self.env_vars_to_redact.update(config['redaction']['env_vars'])
+                
+            # Load allowlist
+            if 'redaction' in config and 'allowlist' in config['redaction']:
+                self.allowlist.update(config['redaction']['allowlist'])
         
         except Exception as e:
             print(f"Warning: Could not load config from {config_path}: {e}")
@@ -176,6 +182,10 @@ class Redactor:
             return redacted_list, redaction_count
         
         elif isinstance(data, str):
+            # Check allowlist first
+            if data in self.allowlist:
+                return data, 0
+                
             redacted_str = data
             for pattern, description in self.patterns:
                 matches = pattern.findall(redacted_str)
@@ -239,6 +249,9 @@ enabled = true
 
 # Additional environment variable names to redact
 # env_vars = ["MY_SECRET_VAR", "CUSTOM_TOKEN"]
+
+# Allowlist: Strings that should NEVER be redacted (exact match)
+# allowlist = ["sk-not-actually-a-key", "my-public-token"]
 """
     
     config_path.parent.mkdir(parents=True, exist_ok=True)

epi_core/schemas.py

@@ -3,7 +3,7 @@ EPI Core Schemas - Pydantic models for manifest and steps.
 """
 
 from datetime import datetime
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, List, Union
 from uuid import UUID, uuid4
 
 from pydantic import BaseModel, ConfigDict, Field
@@ -52,6 +52,32 @@ class ManifestModel(BaseModel):
         description="Ed25519 signature of the canonical CBOR hash of this manifest (excluding signature field)"
     )
     
+    # New metadata fields for decision tracking
+    goal: Optional[str] = Field(
+        default=None,
+        description="Goal or objective of this workflow execution"
+    )
+    
+    notes: Optional[str] = Field(
+        default=None,
+        description="Additional notes or context about this workflow"
+    )
+    
+    metrics: Optional[Dict[str, Union[float, str]]] = Field(
+        default=None,
+        description="Key-value metrics for this workflow (accuracy, latency, etc.)"
+    )
+    
+    approved_by: Optional[str] = Field(
+        default=None,
+        description="Person or entity who approved this workflow execution"
+    )
+    
+    tags: Optional[List[str]] = Field(
+        default=None,
+        description="Tags for categorizing this workflow"
+    )
+    
     model_config = ConfigDict(
         json_schema_extra={
             "example": {
@@ -65,7 +91,12 @@ class ManifestModel(BaseModel):
                     "env.json": "a3c5f...",
                     "artifacts/output.txt": "c7f8a..."
                 },
-                "signature": "ed25519:3a4b5c6d..."
+                "signature": "ed25519:3a4b5c6d...",
+                "goal": "Improve model accuracy",
+                "notes": "Switched to GPT-4 for better reasoning",
+                "metrics": {"accuracy": 0.92, "latency": 210},
+                "approved_by": "alice@company.com",
+                "tags": ["prod-candidate", "v1.0"]
             }
         }
     )
@@ -109,4 +140,4 @@ class StepModel(BaseModel):
                 }
             }
         }
-    )
+    )

epi_recorder/api.py

@@ -5,13 +5,15 @@ Provides a context manager for recording EPI packages programmatically
 with minimal code changes.
 """
 
+import functools
 import json
+import os
 import shutil
 import tempfile
 import threading
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Callable, Dict, List, Optional, Union
 
 from epi_core.container import EPIContainer
 from epi_core.schemas import ManifestModel
@@ -45,7 +47,13 @@ class EpiRecorderSession:
         tags: Optional[List[str]] = None,
         auto_sign: bool = True,
         redact: bool = True,
-        default_key_name: str = "default"
+        default_key_name: str = "default",
+        # New metadata fields
+        goal: Optional[str] = None,
+        notes: Optional[str] = None,
+        metrics: Optional[Dict[str, Union[float, str]]] = None,
+        approved_by: Optional[str] = None,
+        metadata_tags: Optional[List[str]] = None,  # Renamed to avoid conflict with tags parameter
     ):
         """
         Initialize EPI recording session.
@@ -57,6 +65,11 @@ class EpiRecorderSession:
             auto_sign: Whether to automatically sign on exit (default: True)
             redact: Whether to redact secrets (default: True)
             default_key_name: Name of key to use for signing (default: "default")
+            goal: Goal or objective of this workflow execution
+            notes: Additional notes or context about this workflow
+            metrics: Key-value metrics for this workflow (accuracy, latency, etc.)
+            approved_by: Person or entity who approved this workflow execution
+            metadata_tags: Tags for categorizing this workflow (renamed from tags to avoid conflict)
         """
         self.output_path = Path(output_path)
         self.workflow_name = workflow_name or "untitled"
@@ -65,6 +78,13 @@ class EpiRecorderSession:
         self.redact = redact
         self.default_key_name = default_key_name
         
+        # New metadata fields
+        self.goal = goal
+        self.notes = notes
+        self.metrics = metrics
+        self.approved_by = approved_by
+        self.metadata_tags = metadata_tags
+        
         # Runtime state
         self.temp_dir: Optional[Path] = None
         self.recording_context: Optional[RecordingContext] = None
@@ -97,9 +117,9 @@ class EpiRecorderSession:
         set_recording_context(self.recording_context)
         _thread_local.active_session = self
         
-        # Patch LLM libraries
-        patch_openai()  # Patches OpenAI if available
-        # TODO: Add more patchers (Anthropic, etc.)
+        # Patch LLM libraries and HTTP
+        from epi_recorder.patcher import patch_all
+        patch_all()
         
         # Log session start
         self.log_step("session.start", {
@@ -134,16 +154,19 @@ class EpiRecorderSession:
             duration = (end_time - self.start_time).total_seconds()
             
             self.log_step("session.end", {
-                "workflow_name": self.workflow_name,
                 "timestamp": end_time.isoformat(),
                 "duration_seconds": duration,
                 "success": exc_type is None
             })
             
-            # Create manifest  
-            # Note: workflow_name and tags are logged in steps, not manifest
+            # Create manifest with metadata
             manifest = ManifestModel(
-                created_at=self.start_time
+                created_at=self.start_time,
+                goal=self.goal,
+                notes=self.notes,
+                metrics=self.metrics,
+                approved_by=self.approved_by,
+                tags=self.metadata_tags
             )
             
             # Pack into .epi file
@@ -333,9 +356,10 @@ class EpiRecorderSession:
                 )
                 
                 # Repack the ZIP with signed manifest
-                self.output_path.unlink()  # Remove old file
+                # CRITICAL: Write to temp file first to prevent data loss
+                temp_output = self.output_path.with_suffix('.epi.tmp')
                 
-                with zipfile.ZipFile(self.output_path, 'w', zipfile.ZIP_DEFLATED) as zf:
+                with zipfile.ZipFile(temp_output, 'w', zipfile.ZIP_DEFLATED) as zf:
                     # Write mimetype first (uncompressed)
                     from epi_core.container import EPI_MIMETYPE
                     zf.writestr("mimetype", EPI_MIMETYPE, compress_type=zipfile.ZIP_STORED)
@@ -346,36 +370,209 @@ class EpiRecorderSession:
                             arc_name = str(file_path.relative_to(tmp_path)).replace("\\", "/")
                             zf.write(file_path, arc_name)
                 
+                # Successfully created signed file, now safely replace original
+                self.output_path.unlink()
+                temp_output.rename(self.output_path)
+                
         except Exception as e:
             # Non-fatal: log warning but continue
             print(f"Warning: Failed to sign .epi file: {e}")
 
 
-# Convenience function for users
+def _auto_generate_output_path(name_hint: Optional[str] = None) -> Path:
+    """
+    Auto-generate output path in ./epi-recordings/ directory.
+    
+    Args:
+        name_hint: Optional base name hint (script name, function name, etc.)
+        
+    Returns:
+        Path object for the .epi file
+    """
+    # Get recordings directory from env or default
+    recordings_dir = Path(os.getenv("EPI_RECORDINGS_DIR", "epi-recordings"))
+    recordings_dir.mkdir(parents=True, exist_ok=True)
+    
+    # Generate base name
+    if name_hint:
+        base = Path(name_hint).stem if "." in name_hint else name_hint
+    else:
+        base = "recording"
+    
+    # Generate timestamp
+    timestamp = datetime.utcnow().strftime("%Y%m%d_%H%M%S")
+    
+    # Ensure .epi extension
+    filename = f"{base}_{timestamp}.epi"
+    
+    return recordings_dir / filename
+
+
+def _resolve_output_path(output_path: Optional[Path | str]) -> Path:
+    """
+    Resolve output path, adding .epi extension and default directory if needed.
+    
+    Args:
+        output_path: User-provided path or None for auto-generation
+        
+    Returns:
+        Resolved Path object
+    """
+    if output_path is None:
+        return _auto_generate_output_path()
+    
+    path = Path(output_path)
+    
+    # Add .epi extension if missing
+    if path.suffix != ".epi":
+        path = path.with_suffix(".epi")
+    
+    return path
+
+
+# Convenience function for users (supports zero-config)
 def record(
-    output_path: Path | str,
+    output_path: Optional[Path | str] = None,
     workflow_name: Optional[str] = None,
+    tags: Optional[List[str]] = None,
+    auto_sign: bool = True,
+    redact: bool = True,
+    default_key_name: str = "default",
+    # New metadata fields
+    goal: Optional[str] = None,
+    notes: Optional[str] = None,
+    metrics: Optional[Dict[str, Union[float, str]]] = None,
+    approved_by: Optional[str] = None,
+    metadata_tags: Optional[List[str]] = None,  # Renamed to avoid conflict
     **kwargs
-) -> EpiRecorderSession:
+) -> Union[EpiRecorderSession, Callable]:
     """
     Create an EPI recording session (context manager).
     
     Args:
-        output_path: Path for output .epi file
+        output_path: Path for output .epi file (optional - auto-generates if None)
         workflow_name: Descriptive name for workflow
-        **kwargs: Additional arguments (tags, auto_sign, redact, default_key_name)
+        tags: Tags for categorization
+        auto_sign: Whether to automatically sign on exit (default: True)
+        redact: Whether to redact secrets (default: True)
+        default_key_name: Name of key to use for signing (default: "default")
+        goal: Goal or objective of this workflow execution
+        notes: Additional notes or context about this workflow
+        metrics: Key-value metrics for this workflow (accuracy, latency, etc.)
+        approved_by: Person or entity who approved this workflow execution
+        metadata_tags: Tags for categorizing this workflow (renamed from tags to avoid conflict)
+        **kwargs: Additional arguments (backward compatibility)
         
     Returns:
-        EpiRecorderSession context manager
+        EpiRecorderSession context manager or decorated function
         
     Example:
         from epi_recorder import record
         
-        with record("my_workflow.epi", workflow_name="Demo"):
+        # Zero-config (auto-generates filename in ./epi-recordings/)
+        with record():
+            # Your code here
+            pass
+        
+        # With custom name
+        with record("my_workflow"):
+            # Your code here
+            pass
+        
+        # With metadata
+        with record(
+            goal="reduce hallucinations",
+            notes="switched to GPT-4",
+            metrics={"accuracy": 0.89},
+            approved_by="alice@company.com",
+            metadata_tags=["prod-candidate"]
+        ):
+            # Your code here
+            pass
+        
+        # Decorator usage
+        @record
+        def main():
+            # Your code here
+            pass
+            
+        # Decorator with metadata
+        @record(goal="decorator test", metrics={"test_score": 0.95})
+        def main():
             # Your code here
             pass
     """
-    return EpiRecorderSession(output_path, workflow_name, **kwargs)
+    # Check if this is being used as a decorator with arguments
+    # If the first argument is not a path but keyword arguments are provided,
+    # we need to return a decorator function
+    if output_path is None and (goal is not None or notes is not None or metrics is not None or 
+                               approved_by is not None or metadata_tags is not None):
+        # This is a decorator with arguments, return a decorator function
+        def decorator(func):
+            @functools.wraps(func)
+            def wrapper(*args, **kwargs):
+                # Auto-generate path based on function name
+                auto_path = _auto_generate_output_path(func.__name__)
+                with EpiRecorderSession(
+                    auto_path, 
+                    workflow_name or func.__name__,
+                    tags=tags,
+                    auto_sign=auto_sign,
+                    redact=redact,
+                    default_key_name=default_key_name,
+                    goal=goal,
+                    notes=notes,
+                    metrics=metrics,
+                    approved_by=approved_by,
+                    metadata_tags=metadata_tags,
+                    **kwargs
+                ):
+                    return func(*args, **kwargs)
+            return wrapper
+        return decorator
+    
+    # Handle decorator usage: record is called without parentheses
+    if callable(output_path):
+        func = output_path
+        
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            # Auto-generate path based on function name
+            auto_path = _auto_generate_output_path(func.__name__)
+            with EpiRecorderSession(
+                auto_path, 
+                workflow_name or func.__name__,
+                tags=tags,
+                auto_sign=auto_sign,
+                redact=redact,
+                default_key_name=default_key_name,
+                goal=goal,
+                notes=notes,
+                metrics=metrics,
+                approved_by=approved_by,
+                metadata_tags=metadata_tags,
+                **kwargs
+            ):
+                return func(*args, **kwargs)
+        
+        return wrapper
+    
+    # Normal context manager usage
+    resolved_path = _resolve_output_path(output_path)
+    return EpiRecorderSession(
+        resolved_path,
+        workflow_name,
+        tags=tags,
+        auto_sign=auto_sign,
+        redact=redact,
+        default_key_name=default_key_name,
+        goal=goal,
+        notes=notes,
+        metrics=metrics,
+        approved_by=approved_by,
+        metadata_tags=metadata_tags,
+        **kwargs
+    )
 
 
 # Make it easy to get current session
@@ -386,4 +583,4 @@ def get_current_session() -> Optional[EpiRecorderSession]:
     Returns:
         EpiRecorderSession or None
     """
-    return getattr(_thread_local, 'active_session', None)
+    return getattr(_thread_local, 'active_session', None)