epi-recorder 2.0.0__py3-none-any.whl → 2.1.1__py3-none-any.whl

epi_cli/__main__.py

@@ -1,5 +1,10 @@
 """
-EPI CLI entry point for python -m epi_cli
+EPI CLI - Main entry point for python -m epi_cli
+
+This allows users to run the CLI even if 'epi' is not in PATH:
+    python -m epi_cli run script.py
+    python -m epi_cli view recording.epi
+    etc.
 """
 from epi_cli.main import cli_main
 

epi_cli/main.py

@@ -161,6 +161,151 @@ def keys(
         raise typer.Exit(1)
 
 
+@app.command()
+def init(
+    demo_filename: str = typer.Option("epi_demo.py", "--name", "-n", help="Name of the demo script"),
+    no_open: bool = typer.Option(False, "--no-open", help="Don't open viewer automatically (for testing)")
+):
+    """
+    [Wizard] First-time setup wizard! Creates keys, demo script, and runs it.
+    """
+    console.print("\n[bold magenta]EPI Setup Wizard[/bold magenta]\n")
+
+    # 1. Keys
+    from epi_cli.keys import generate_default_keypair_if_missing
+    console.print("1. [dim]Checking security keys...[/dim]", end=" ")
+    if generate_default_keypair_if_missing(console_output=False):
+         console.print("[green]Created![/green]")
+    else:
+         console.print("[green]Found! [OK][/green]")
+
+    # 2. Demo Script
+    console.print(f"2. [dim]Creating demo script '{demo_filename}'...[/dim]", end=" ")
+    script_content = '''# Welcome to EPI!
+
+import time
+
+print("="*40)
+print("   Hello from your first EPI recording!")
+print("="*40)
+
+print("\\n1. Doing some math...")
+result = 123 * 456
+print(f"   123 * 456 = {result}")
+
+print("\\n2. Creating a file...")
+with open("epi_hello.txt", "w") as f:
+    f.write(f"Calculation result: {result}")
+print("   Saved 'epi_hello.txt'")
+
+print("\\n3. Finishing up...")
+time.sleep(0.5)
+print("[OK] Done! Now check the browser!")
+'''
+    import os
+    if not os.path.exists(demo_filename):
+         with open(demo_filename, "w") as f:
+             f.write(script_content)
+         console.print("[green]Created![/green]")
+    else:
+         console.print("[yellow]Exists (Skipped) >>[/yellow]")
+
+    # 3. Running
+    console.print("\n3. [bold cyan]Running the demo now...[/bold cyan]\n")
+    
+    # Call run command programmatically
+    # We use subprocess to keep it clean separate process
+    import subprocess
+    import sys
+    cmd = [sys.executable, "-m", "epi_cli.main", "run", demo_filename]
+    if no_open:
+        cmd.append("--no-open")
+    subprocess.run(cmd)
+
+    console.print("\n[bold green]You are all set![/bold green]")
+    console.print(f"[dim]Next time just run:[/dim] epi run {demo_filename}")
+
+
+@app.command()
+def doctor():
+    """
+    [Doctor] Self-healing doctor. Fixes common issues silently.
+    """
+    console.print("\n[bold blue]EPI Doctor - System Health Check[/bold blue]\n")
+    
+    issues = 0
+    fixed = 0
+    
+    # Check 1: Keys
+    console.print("1. Security Keys: ", end="")
+    from epi_cli.keys import generate_default_keypair_if_missing
+    if generate_default_keypair_if_missing(console_output=False):
+        console.print("[green][OK] FIXED (Generated)[/green]")
+        fixed += 1
+    else:
+        console.print("[green][OK][/green]")
+        
+    # Check 2: Command on PATH
+    console.print("2. 'epi' command: ", end="")
+    import shutil
+    if shutil.which("epi"):
+        console.print("[green][OK][/green]")
+    else:
+        console.print("[red][X] NOT IN PATH[/red]")
+        issues += 1
+        
+        # Try to auto-fix on Windows
+        import platform
+        if platform.system() == "Windows":
+            console.print("   [cyan]→ Attempting automatic PATH fix...[/cyan]")
+            try:
+                import epi_postinstall
+                from pathlib import Path
+                
+                scripts_dir = epi_postinstall.get_scripts_dir()
+                if scripts_dir and scripts_dir.exists():
+                    console.print(f"   [dim]Scripts directory: {scripts_dir}[/dim]")
+                    
+                    if epi_postinstall.add_to_user_path_windows(scripts_dir):
+                        console.print("   [green][OK] PATH updated successfully![/green]")
+                        console.print("   [yellow][!] Please restart your terminal for changes to take effect[/yellow]")
+                        fixed += 1
+                    else:
+                        console.print("   [yellow][!] Could not update PATH automatically[/yellow]")
+                        console.print("   [dim]Manual fix: Use 'python -m epi_cli' instead[/dim]")
+                else:
+                    console.print("   [red][X] Could not locate Scripts directory[/red]")
+            except Exception as e:
+                console.print(f"   [red][X] Auto-fix failed: {e}[/red]")
+                console.print("   [dim]Workaround: Use 'python -m epi_cli' instead[/dim]")
+        else:
+            console.print("   [dim]Workaround: Use 'python -m epi_cli' instead[/dim]")
+
+    # Check 3: Browser
+    console.print("3. Browser Check: ", end="")
+    try:
+        import webbrowser
+        webbrowser.get()
+        console.print("[green][OK][/green]")
+    except:
+        console.print("[yellow][!] WARNING (Headless?)[/yellow]")
+        
+    # Summary
+    print()
+    console.print("[bold]" + "="*70 + "[/bold]")
+    if issues == 0:
+        console.print("[bold green][OK] System Healthy![/bold green]")
+    else:
+        if fixed > 0:
+            console.print(f"[bold yellow][!] Fixed {fixed}/{issues} issues[/bold yellow]")
+            if fixed < issues:
+                console.print("[dim]Some issues require manual attention (see above)[/dim]")
+        else:
+            console.print(f"[bold yellow][!] Found {issues} issues[/bold yellow]")
+            console.print("[dim]See suggestions above[/dim]")
+    console.print("[bold]" + "="*70 + "[/bold]\n")
+
+
 # Entry point for CLI
 def cli_main():
     """CLI entry point (called by `epi` command)."""

epi_cli/run.py

@@ -157,7 +157,7 @@ def _open_viewer(epi_file: Path) -> bool:
 
 @app.command()
 def run(
-    script: Path = typer.Argument(..., help="Python script to record"),
+    script: Optional[Path] = typer.Argument(None, help="Python script to record (Optional - Interactive if missing)"),
     no_verify: bool = typer.Option(False, "--no-verify", help="Skip verification"),
     no_open: bool = typer.Option(False, "--no-open", help="Don't open viewer automatically"),
     # New metadata options
@@ -170,14 +170,65 @@ def run(
     """
     Zero-config recording: record + verify + view.
     
-    Example:
+    Interactive:
+        epi run  (Selects script from list)
+        
+    Direct:
         epi run my_script.py
-        epi run script.py --goal "improve accuracy" --notes "test run" --metric accuracy=0.92 --metric latency=210 --approved-by "bob" --tag test --tag v1
     """
+    
+    # --- SMART UX 1: INTERACTIVE MODE ---
+    if script is None:
+        # Find Python files in current directory
+        py_files = list(Path.cwd().glob("*.py"))
+        # Only exclude specific setup files, not everything starting with epi_
+        py_files = [f for f in py_files if f.name not in ["setup.py", "epi_setup.py"]]
+        
+        if not py_files:
+            console.print("[yellow]No Python scripts found in this directory.[/yellow]")
+            console.print("Create one or specify path: epi run [path/to/script.py]")
+            raise typer.Exit(1)
+            
+        console.print("\n[bold cyan]Select a script to record:[/bold cyan]")
+        for idx, f in enumerate(py_files, 1):
+            console.print(f"  [green]{idx}.[/green] {f.name}")
+            
+        from rich.prompt import Prompt
+        choice = Prompt.ask("\nNumber", default="1")
+        
+        try:
+            choice_idx = int(choice) - 1
+            if 0 <= choice_idx < len(py_files):
+                script = py_files[choice_idx]
+            else:
+                 console.print("[red]Invalid selection.[/red]")
+                 raise typer.Exit(1)
+        except ValueError:
+             console.print("[red]Invalid input.[/red]")
+             raise typer.Exit(1)
+             
+        console.print(f"[dim]Selected:[/dim] {script.name}\n")
+
+    # --- SMART UX 2: TYPO FIXER ---
     # Validate script exists
     if not script.exists():
-        console.print(f"[red][FAIL] Error:[/red] Script not found: {script}")
-        raise typer.Exit(1)
+        # Check for typos (simple close match)
+        import difflib
+        candidates = list(Path.cwd().glob("*.py"))
+        candidate_names = [c.name for c in candidates]
+        matches = difflib.get_close_matches(script.name, candidate_names, n=1, cutoff=0.6)
+        
+        if matches:
+            from rich.prompt import Confirm
+            suggestion = matches[0]
+            if Confirm.ask(f"[yellow]Script '{script}' not found. Did you mean '{suggestion}'?[/yellow]"):
+                script = Path(suggestion)
+            else:
+                console.print(f"[red][FAIL] Error:[/red] Script not found: {script}")
+                raise typer.Exit(1)
+        else:
+            console.print(f"[red][FAIL] Error:[/red] Script not found: {script}")
+            raise typer.Exit(1)
     
     # Parse metrics if provided
     metrics_dict = None
@@ -217,12 +268,25 @@ def run(
     
     console.print(f"[dim]Recording:[/dim] {script.name}")
     
+    # --- AUTO-FIX 1: KEYS ---
+    # Ensure default keys exist so it's never "Unsigned"
+    from epi_cli.keys import generate_default_keypair_if_missing
+    generated = generate_default_keypair_if_missing(console_output=False)
+    if generated:
+         console.print("[green]Created your secure cryptographic identity (keys/default)[/green]")
+    # -----------------------
+    
     import subprocess
     
     start = time.time()
-    with open(stdout_log, "wb") as out_f, open(stderr_log, "wb") as err_f:
-        proc = subprocess.Popen(cmd, env=child_env, stdout=out_f, stderr=err_f)
-        rc = proc.wait()
+    try:
+        with open(stdout_log, "wb") as out_f, open(stderr_log, "wb") as err_f:
+            proc = subprocess.Popen(cmd, env=child_env, stdout=out_f, stderr=err_f)
+            rc = proc.wait()
+    except Exception as e:
+        console.print(f"\n[bold red][FAIL] Could not execute command:[/bold red] {cmd[0]}")
+        console.print(f"[dim]Error detail: {e}[/dim]")
+        raise typer.Exit(1)
     duration = round(time.time() - start, 3)
     
     # Build manifest with metadata
@@ -238,6 +302,21 @@ def run(
     # Package into .epi
     EPIContainer.pack(temp_workspace, manifest, out)
     
+    # --- AUTO-FIX 2: EMPTY CHECK ---
+    # Check if we actually recorded anything
+    import json
+    timeline_path = temp_workspace / "timeline.json"
+    if timeline_path.exists():
+        try:
+            with open(timeline_path) as f:
+                timeline_data = json.load(f)
+            if not timeline_data:
+                console.print("\n[bold yellow][!] Warning: Your script ran but didn't record any steps![/bold yellow]")
+                console.print("[dim]Did you forget to print anything? Try adding: print('Hello EPI')[/dim]\n")
+        except:
+            pass
+    # -----------------------------
+    
     # Auto-sign
     signed = False
     try:

epi_cli/verify.py

@@ -84,7 +84,7 @@ def verify(
             else:
                 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}")
+                    console.print(f"    [red]-[/red] {filename}: {reason}")
         
         # ========== STEP 3: AUTHENTICITY CHECKS ==========
         if verbose:
@@ -203,7 +203,7 @@ def print_trust_report(report: dict, epi_file: Path, verbose: bool = False):
         content_lines.append("")
         content_lines.append("[bold red]File Mismatches:[/bold red]")
         for filename, reason in report["mismatches"].items():
-            content_lines.append(f"  [red]•[/red] {filename}: {reason}")
+            content_lines.append(f"  [red]-[/red] {filename}: {reason}")
     
     content = "\n".join(content_lines)
     

epi_core/__init__.py

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

epi_core/container.py

@@ -71,14 +71,16 @@ class EPIContainer:
         viewer_static_dir = Path(__file__).parent.parent / "epi_viewer_static"
         template_path = viewer_static_dir / "index.html"
         app_js_path = viewer_static_dir / "app.js"
+        css_path = viewer_static_dir / "viewer_lite.css"
         
         if not template_path.exists():
             # Fallback: minimal viewer if template not found
             return EPIContainer._create_minimal_viewer(manifest)
         
-        # Read template
+        # Read template and assets
         template_html = template_path.read_text(encoding="utf-8")
         app_js = app_js_path.read_text(encoding="utf-8") if app_js_path.exists() else ""
+        css_styles = css_path.read_text(encoding="utf-8") if css_path.exists() else ""
         
         # Read steps from steps.jsonl
         steps = []
@@ -104,8 +106,14 @@ class EPIContainer:
             f'<script id="epi-data" type="application/json">{data_json}</script>'
         )
         
+        # Replaces Tailwind CDN with local CSS
+        html_with_css = html_with_data.replace(
+            '<script src="https://cdn.tailwindcss.com"></script>',
+            f'<style>{css_styles}</style>'
+        )
+        
         # Inline app.js
-        html_with_js = html_with_data.replace(
+        html_with_js = html_with_css.replace(
             '<script src="app.js"></script>',
             f'<script>{app_js}</script>'
         )

epi_postinstall.py

@@ -0,0 +1,197 @@
+"""
+Post-installation script for EPI Recorder
+Automatically fixes PATH issues on Windows for better UX
+"""
+import sys
+import os
+import platform
+import subprocess
+from pathlib import Path
+
+
+def get_scripts_dir():
+    """Get the Scripts directory where pip installs executables"""
+    if platform.system() == "Windows":
+        # Get the site-packages directory
+        import site
+        user_site = site.getusersitepackages()
+        if user_site:
+            # Scripts is typically ../Scripts relative to site-packages
+            scripts_dir = Path(user_site).parent / "Scripts"
+            if scripts_dir.exists():
+                return scripts_dir
+        
+        # Fallback: try to find it from pip
+        try:
+            result = subprocess.run(
+                [sys.executable, "-m", "pip", "show", "epi-recorder"],
+                capture_output=True,
+                text=True
+            )
+            if result.returncode == 0:
+                for line in result.stdout.split('\n'):
+                    if line.startswith('Location:'):
+                        location = line.split(':', 1)[1].strip()
+                        scripts_dir = Path(location).parent / "Scripts"
+                        if scripts_dir.exists():
+                            return scripts_dir
+        except Exception:
+            pass
+    
+    return None
+
+
+def is_in_path(directory):
+    """Check if directory is in PATH"""
+    path_env = os.environ.get('PATH', '')
+    path_dirs = path_env.split(os.pathsep)
+    dir_str = str(directory)
+    return any(os.path.normcase(p) == os.path.normcase(dir_str) for p in path_dirs)
+
+
+def add_to_user_path_windows(directory):
+    """Add directory to user PATH on Windows"""
+    try:
+        import winreg
+        
+        # Open the user environment variables key
+        key = winreg.OpenKey(
+            winreg.HKEY_CURRENT_USER,
+            'Environment',
+            0,
+            winreg.KEY_READ | winreg.KEY_WRITE
+        )
+        
+        try:
+            # Get current PATH
+            current_path, _ = winreg.QueryValueEx(key, 'Path')
+        except WindowsError:
+            current_path = ''
+        
+        # Add our directory if not already there
+        path_parts = current_path.split(os.pathsep)
+        dir_str = str(directory)
+        
+        if not any(os.path.normcase(p) == os.path.normcase(dir_str) for p in path_parts):
+            new_path = current_path + os.pathsep + dir_str
+            winreg.SetValueEx(key, 'Path', 0, winreg.REG_EXPAND_SZ, new_path)
+            winreg.CloseKey(key)
+            
+            # Broadcast WM_SETTINGCHANGE to notify the system
+            try:
+                import ctypes
+                HWND_BROADCAST = 0xFFFF
+                WM_SETTINGCHANGE = 0x1A
+                ctypes.windll.user32.SendMessageW(
+                    HWND_BROADCAST, WM_SETTINGCHANGE, 0, 'Environment'
+                )
+            except Exception:
+                pass
+            
+            return True
+        
+        winreg.CloseKey(key)
+        return False
+        
+    except Exception as e:
+        print(f"Warning: Could not modify PATH: {e}")
+        return False
+
+
+def check_epi_command():
+    """Check if 'epi' command is accessible"""
+    try:
+        result = subprocess.run(
+            ['epi', '--version'],
+            capture_output=True,
+            timeout=2
+        )
+        return result.returncode == 0
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return False
+
+
+def post_install():
+    """Main post-install function"""
+    print("\n" + "="*70)
+    print("🎉 EPI Recorder Installation Complete!")
+    print("="*70)
+    
+    # Check if epi command works
+    if check_epi_command():
+        print("\n✅ The 'epi' command is ready to use!")
+        print("\nTry it now:")
+        print("  epi --help")
+        print("  epi init")
+        return
+    
+    # If not, try to fix it (Windows only for now)
+    if platform.system() == "Windows":
+        print("\n⚠️  'epi' command not found in PATH")
+        print("🔧 Attempting automatic fix...")
+        
+        scripts_dir = get_scripts_dir()
+        
+        if scripts_dir and scripts_dir.exists():
+            print(f"📁 Found Scripts directory: {scripts_dir}")
+            
+            if not is_in_path(scripts_dir):
+                print("➕ Adding to your user PATH...")
+                
+                try:
+                    if add_to_user_path_windows(scripts_dir):
+                        print("\n✅ SUCCESS! PATH updated.")
+                        print("\n⚠️  IMPORTANT: You must restart your terminal for changes to take effect!")
+                        print("\nAfter restarting your terminal, try:")
+                        print("  epi --help")
+                        print("  epi init")
+                    else:
+                        print("\n⚠️  Scripts directory already in PATH, but 'epi' not found.")
+                        print("This might require a terminal restart.")
+                        print("\nIf 'epi' still doesn't work after restarting, use:")
+                        print(f"  python -m epi_cli")
+                except Exception as e:
+                    print(f"\n❌ Automatic fix failed: {e}")
+                    show_manual_instructions(scripts_dir)
+            else:
+                print("✅ Scripts directory is in PATH")
+                print("⚠️  You may need to restart your terminal for the command to work.")
+        else:
+            print("❌ Could not locate Scripts directory")
+            show_fallback_instructions()
+    else:
+        # Linux/Mac
+        print("\n⚠️  'epi' command not found in PATH")
+        print("\nIf 'epi' doesn't work, use:")
+        print("  python -m epi_cli")
+        print("\nOr add pip's user base bin directory to PATH:")
+        print("  export PATH=$PATH:$(python -m site --user-base)/bin")
+    
+    print("\n" + "="*70 + "\n")
+
+
+def show_manual_instructions(scripts_dir):
+    """Show manual PATH update instructions"""
+    print("\n📖 MANUAL FIX REQUIRED:")
+    print("\nOption 1: Update PATH (Permanent)")
+    print("  1. Press Win + R, type: sysdm.cpl")
+    print("  2. Advanced → Environment Variables")
+    print("  3. Under 'User variables', select 'Path' → Edit")
+    print("  4. Click 'New' and add:")
+    print(f"     {scripts_dir}")
+    print("  5. Click OK, restart your terminal")
+    print("\nOption 2: Use python -m (Always works)")
+    print("  python -m epi_cli run script.py")
+
+
+def show_fallback_instructions():
+    """Show fallback instructions if automatic fix fails"""
+    print("\n📖 WORKAROUND:")
+    print("\nUse 'python -m epi_cli' instead of 'epi':")
+    print("  python -m epi_cli --help")
+    print("  python -m epi_cli run script.py")
+    print("  python -m epi_cli view recording.epi")
+
+
+if __name__ == "__main__":
+    post_install()

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__ = "2.0.0"
+__version__ = "2.1.0"
 
 # Export Python API
 from epi_recorder.api import (

epi_recorder/api.py

@@ -426,8 +426,15 @@ def _resolve_output_path(output_path: Optional[Path | str]) -> Path:
     # Add .epi extension if missing
     if path.suffix != ".epi":
         path = path.with_suffix(".epi")
-    
-    return path
+        
+    # If path is absolute, return it
+    if path.is_absolute():
+        return path
+        
+    # If path is relative, prepend recordings directory
+    recordings_dir = Path(os.getenv("EPI_RECORDINGS_DIR", "epi-recordings"))
+    recordings_dir.mkdir(parents=True, exist_ok=True)
+    return recordings_dir / path
 
 
 # Convenience function for users (supports zero-config)

epi_recorder/test_import.py

@@ -0,0 +1,18 @@
+
+try:
+    import epi_recorder.api
+    print("epi_recorder.api imported successfully")
+except ImportError as e:
+    print(f"Failed to import epi_recorder.api: {e}")
+
+try:
+    import epi_core
+    print("epi_core imported successfully")
+except ImportError as e:
+    print(f"Failed to import epi_core: {e}")
+
+try:
+    import epi_cli
+    print("epi_cli imported successfully")
+except ImportError as e:
+    print(f"Failed to import epi_cli: {e}")

epi_recorder/test_script.py

@@ -0,0 +1,4 @@
+
+print("Hello from EPI Test Script")
+import sys
+print(f"Python version: {sys.version}")