epi-recorder 1.0.0__py3-none-any.whl → 1.1.1__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/__init__.py

@@ -2,7 +2,7 @@
 EPI Core - Core data structures, serialization, and container management.
 """
 
-__version__ = "1.0.0-keystone"
+__version__ = "1.1.1"
 
 from epi_core.schemas import ManifestModel, StepModel
 from epi_core.serialize import get_canonical_hash

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/__init__.py

@@ -4,7 +4,7 @@ EPI Recorder - Runtime interception and workflow capture.
 Python API for recording AI workflows with cryptographic verification.
 """
 
-__version__ = "1.0.0-keystone"
+__version__ = "1.1.1"
 
 # Export Python API
 from epi_recorder.api import (