onecoder 0.0.2__py3-none-any.whl

onecoder/commands/issue.py

@@ -0,0 +1,136 @@
+import click
+import re
+from datetime import datetime
+from pathlib import Path
+from ..issues import IssueManager
+from ..config_manager import config_manager
+from ai_sprint.telemetry import FailureModeCapture
+
+@click.group()
+def issue():
+    """Manage platform governance issues."""
+    pass
+
+@issue.command(name="create")
+@click.option("--from-telemetry", is_flag=True, help="Create issue from latest telemetry failure")
+@click.option("--title", help="Manual title for the issue")
+def issue_create(from_telemetry, title):
+    """Create a new governance issue."""
+    from rich.console import Console
+    console = Console()
+    
+    manager = IssueManager()
+    
+    if from_telemetry:
+        capture = FailureModeCapture()
+        failures = capture.get_failures(limit=1)
+        if not failures:
+            console.print("[yellow]No recent failures found in telemetry.[/yellow]")
+            return
+            
+        failure = failures[0]
+        issue_path = manager.create_from_telemetry(failure, title=title)
+        console.print(f"[bold green]✓ Issue created from telemetry:[/bold green] {issue_path.name}")
+    else:
+        # Future: manual issue creation wizard
+        console.print("[yellow]Manual issue creation not yet implemented. Use --from-telemetry.[/yellow]")
+
+@issue.command(name="resolve")
+@click.argument("issue_id")
+@click.option("--message", "-m", help="Resolution message")
+@click.option("--pr", help="Pull Request URL")
+def issue_resolve(issue_id, message, pr):
+    """Mark an issue as resolved."""
+    from rich.console import Console
+    import subprocess
+    
+    console = Console()
+    manager = IssueManager()
+    
+    # 1. Get Resolution Metadata
+    resolution_meta = {
+        "user": config_manager.get_user(),
+        "resolved_at": datetime.now().isoformat(),
+        "pr_url": pr
+    }
+    
+    # Get Current Commit
+    try:
+        commit = subprocess.check_output(["git", "rev-parse", "HEAD"]).decode().strip()
+        resolution_meta["commit_sha"] = commit
+    except Exception:
+        resolution_meta["commit_sha"] = "unknown"
+        
+    # 2. Update Status
+    success = manager.update_status(issue_id, "resolved", resolution_meta)
+    
+    if success:
+        console.print(f"[bold green]✓ Issue {issue_id} marked as resolved.[/bold green]")
+        console.print(msg="Resolution metadata captured.", style="dim")
+    else:
+        console.print(f"[bold red]Error:[/bold red] Issue {issue_id} not found.")
+
+@issue.command(name="sync")
+@click.option("--input", "-i", type=click.Path(exists=True), help="Input issue file/directory (optional)")
+def issue_sync(input):
+    """Sync local governance issues to the OneCoder API."""
+    import asyncio
+    from ..sync import sync_issues, ProjectConfig
+    from ..api_client import get_api_client
+    
+    # Setup
+    token = config_manager.get_token()
+    if not token:
+        click.secho("Error: Not logged in.", fg="red")
+        return
+
+    repo_root = Path.cwd() # Should use find_repo_root from sync.py really, importing locally
+    proj_config = ProjectConfig(repo_root)
+    project_id = proj_config.get_project_id()
+    
+    if not project_id:
+        click.secho("Error: Project ID not found.", fg="red")
+        return
+
+    client = get_api_client(token)
+    
+    # Run Sync
+    asyncio.run(sync_issues(client, project_id))
+
+@issue.command(name="list")
+def issue_list():
+    """List all local governance issues."""
+    from rich.console import Console
+    from rich.table import Table
+    console = Console()
+    
+    manager = IssueManager()
+    issues_dir = manager.issues_dir
+    if not issues_dir.exists():
+        console.print("[yellow]No .issues directory found.[/yellow]")
+        return
+        
+    table = Table(title="Local Governance Issues")
+    table.add_column("ID", style="cyan")
+    table.add_column("Title", style="white")
+    table.add_column("Status", style="magenta")
+    
+    for item in sorted(issues_dir.iterdir()):
+        if item.is_file() and item.suffix == ".md" and item.name != "README.md":
+            match = re.match(r"^(\d{3})-(.+)\.md$", item.name)
+            if match:
+                issue_id = match.group(1)
+                issue_title = match.group(2).replace("-", " ").capitalize()
+                
+                # Try to parse status from file
+                content = item.read_text()
+                if any(x in content for x in ["Resolved", "🟢 Resolved", "🟢 **Resolved**"]):
+                    status = "[green]Resolved[/green]"
+                elif any(x in content for x in ["Open", "🔴 Open", "🔴 **Open**"]):
+                    status = "[red]Open[/red]"
+                else:
+                    status = "[yellow]Unknown[/yellow]"
+                    
+                table.add_row(issue_id, issue_title, status)
+                
+    console.print(table)

onecoder/commands/logs.py

@@ -0,0 +1,45 @@
+import click
+from pathlib import Path
+import sys
+
+@click.command()
+@click.option("--n", default=50, help="Number of lines to show (default 50).")
+@click.option("--follow", "-f", is_flag=True, help="Follow log output that updates.")
+def logs(n, follow):
+    """View recent OneCoder logs."""
+    log_file = Path.home() / ".onecoder" / "logs" / "onecoder.log"
+    
+    if not log_file.exists():
+        click.echo(f"No log file found at {log_file}")
+        return
+
+    click.secho(f"Reading logs from {log_file}...", dim=True)
+    
+    try:
+        from collections import deque
+        with open(log_file, 'r') as f:
+            if follow:
+                # Print last n lines first
+                lines = deque(f, maxlen=n)
+                for line in lines:
+                    sys.stdout.write(line)
+                
+                # Follow loop
+                import time
+                while True:
+                    line = f.readline()
+                    if line:
+                        sys.stdout.write(line)
+                    else:
+                        time.sleep(0.1)
+            else:
+                # Just print last n lines
+                 lines = deque(f, maxlen=n)
+                 for line in lines:
+                     sys.stdout.write(line)
+
+    except KeyboardInterrupt:
+        pass
+    except Exception as e:
+        click.report_exception(e)  # Keep traceback if needed
+        click.secho(f"Error reading logs: {e}", fg="red")

onecoder/commands/project.py

@@ -0,0 +1,270 @@
+import click
+import json
+import asyncio
+from pathlib import Path
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+
+from .auth import require_login
+from ..onboarding import onboard_project
+from ..knowledge import ProjectKnowledge
+from ..distillation import SprintDistiller
+from ..sync import sync_project_context
+from ..alignment import AlignmentTracker
+
+@click.command()
+@click.option("--directory", default=".", help="Project directory")
+@require_login
+def init(directory):
+    """Onboards the current project into OneCoder."""
+    onboard_project(directory)
+
+@click.command()
+@click.option("--directory", default=".", help="Root directory to scan")
+def status(directory):
+    """Shows the platform-wide status by aggregating all sub-project sprints."""
+    console = Console()
+    root_path = Path(directory).resolve()
+    
+    console.print(f"[bold cyan]Scanning for OneCoder sub-projects in:[/bold cyan] {root_path}")
+    
+    # Discovery logic
+    sprint_dirs = []
+    for p in root_path.rglob(".sprint"):
+        if "node_modules" in p.parts or ".git" in p.parts:
+            continue
+        sprint_dirs.append(p)
+    
+    if not sprint_dirs:
+        console.print("[yellow]No .sprint directories found.[/yellow]")
+        return
+
+    table = Table(title="Platform-Wide Sprint Status")
+    table.add_column("Component", style="cyan")
+    table.add_column("Current Sprint", style="magenta")
+    table.add_column("Status", style="green")
+    table.add_column("Primary Goal", style="white")
+    table.add_column("Tasks (D/T)", justify="right")
+
+    for sd in sprint_dirs:
+        component_name = sd.parent.name
+        # Look for active sprint (usually the most recent subdirectory that isn't empty)
+        sprint_shards = [d for d in sd.iterdir() if d.is_dir()]
+        if not sprint_shards:
+            continue
+            
+        # For now, let's take the latest/active one. 
+        # In a real scenario, we might want to check sprint.json for status.
+        active_sprint = sorted(sprint_shards)[-1]
+        state_file = active_sprint / "sprint.json"
+        
+        if state_file.exists():
+            try:
+                with open(state_file, "r") as f:
+                    state = json.load(f)
+                
+                sprint_id = state.get("sprintId", active_sprint.name)
+                status_obj = state.get("status", {})
+                status_str = f"{status_obj.get('state', 'unknown')} ({status_obj.get('phase', 'init')})"
+                goal = state.get("goals", {}).get("primary", "N/A")
+                
+                tasks = state.get("tasks", [])
+                done_tasks = len([t for t in tasks if t.get("status") == "done"])
+                total_tasks = len(tasks)
+                
+                table.add_row(
+                    component_name,
+                    sprint_id,
+                    status_str,
+                    goal or "N/A",
+                    f"{done_tasks}/{total_tasks}"
+                )
+            except Exception as e:
+                table.add_row(component_name, active_sprint.name, "Error", str(e), "-")
+        else:
+            table.add_row(component_name, active_sprint.name, "No sprint.json", "-", "-")
+
+    console.print(table)
+
+@click.command(name="suggest")
+@click.option("--limit", default=3, help="Number of past sprints to analyze")
+@click.option("--dry-run", is_flag=True, help="Don't call LLM, just show context")
+def sprint_suggest(limit, dry_run):
+    """
+    Suggests next tasks based on sprint history and learnings.
+    """
+    from ..sprint_collector import SprintCollector
+    from ..agents import TaskSuggester
+
+    console = Console()
+    repo_root = Path.cwd()
+    
+    # 1. Collect Context
+    with console.status("[bold green]Harvesting sprint context..."):
+        collector = SprintCollector(repo_root)
+        context = collector.get_recent_context(limit=limit)
+    
+    if not context:
+        console.print("[yellow]No sprint context found. Run this from a repository with .sprint history.[/yellow]")
+        return
+
+    if dry_run:
+        console.print(Panel(json.dumps(context, indent=2), title="Captured Context (Dry Run)"))
+        return
+
+    # 2. Get Suggestions from LLM
+    with console.status("[bold purple]Analyzing patterns and generating suggestions..."):
+        suggester = TaskSuggester()
+        suggestions = suggester.suggest_next_tasks(context)
+
+    if not suggestions:
+        console.print("[yellow]No suggestions generated (or LLM unavailable).[/yellow]")
+        return
+
+    # 3. Present Suggestions
+    console.print("\n[bold]Suggested Next Tasks:[/bold]")
+    for i, task in enumerate(suggestions, 1):
+        type_style = {
+            "feature": "blue",
+            "fix": "red",
+            "chore": "dim",
+            "governance": "magenta"
+        }.get(task.get("type", "task"), "white")
+        
+        console.print(f"\n{i}. [{type_style}]{task['title']}[/{type_style}]")
+        console.print(f"   [dim]{task['rationale']}[/dim]")
+
+    # 4. Interactive Delegation (Optional)
+    if click.confirm("\nDelegate one of these tasks now?", default=False):
+        choice = click.prompt("Enter task number", type=int, default=1)
+        if 1 <= choice <= len(suggestions):
+            selected = suggestions[choice-1]
+            prompt = selected['title']
+            click.echo(f"\nrun: onecoder delegate \"{prompt}\"")
+
+@click.command()
+@click.option("--json", "json_output", is_flag=True, help="Output as JSON for machine consumption")
+def knowledge(json_output):
+    """
+    Shows the platform-wide knowledge awareness.
+    Aggregates L2 (Durable Project Guidelines) and L1 (Active Sprint Context).
+    """
+    pk = ProjectKnowledge()
+    
+    if json_output:
+        click.echo(json.dumps(pk.aggregate_knowledge(), indent=2))
+    else:
+        click.echo(pk.get_rag_ready_output())
+
+@click.command()
+@click.option("--sprint", "sprint_id", required=True, help="Sprint ID to distill learnings from")
+@click.option("--json", "json_output", is_flag=True, help="Output as JSON for machine consumption")
+def distill(sprint_id, json_output):
+    """
+    Distills learnings from a completed sprint and updates ANTIGRAVITY.md.
+    """
+    console = Console()
+    distiller = SprintDistiller()
+    
+    if not json_output:
+        console.print(f"[bold green]Distilling learnings from {sprint_id}...[/bold green]")
+    
+    result = distiller.distill_sprint(sprint_id)
+        
+    if "error" in result:
+        if json_output:
+            click.echo(json.dumps(result))
+        else:
+            console.print(f"[bold red]Error:[/bold red] {result['error']}")
+    else:
+        if json_output:
+            click.echo(json.dumps(result))
+        else:
+            console.print(f"[bold green]Success![/bold green] Extracted {result['learnings_extracted']} learnings from {sprint_id}.")
+            if result["updated"]:
+                console.print(f"Updated awareness file: [cyan]{result['updated']}[/cyan]")
+
+@click.command()
+@click.option("--dry-run", is_flag=True, help="Show what would be synced without actually syncing")
+@click.option("--json", "json_output", is_flag=True, help="Output as JSON for machine consumption")
+def sync(dry_run, json_output):
+    """
+    Syncs the local project context (specifications, governance, learnings, sprints) to the API.
+    """
+    if json_output:
+        # We might want to pass this down to sync_project_context
+        pass
+        
+    asyncio.run(sync_project_context())
+
+@click.command()
+@click.option("--sync", is_flag=True, help="Sync alignment data to API")
+def alignment(sync):
+    """
+    Tracks project progress, aligns with roadmap, and captures PR/commit aspects.
+    """
+    console = Console()
+    tracker = AlignmentTracker()
+    
+    with console.status("[bold green]Analyzing alignment..."):
+        # Log current state
+        log_msg = tracker.log_current_state()
+        
+        # Analyze roadmap (Agentic Semantic Check)
+        alignment_data = tracker.check_roadmap_alignment_agentic()
+        
+        # Fetch PRs
+        prs = tracker.fetch_recent_prs()
+        
+        # Capture suggestions
+        suggestions = tracker.capture_suggestions()
+
+        # Agentic Summary (Pass the detailed alignment data)
+        summary = tracker.summarize_alignment_agentic(alignment_data, prs, suggestions)
+
+    console.print(Panel(f"[bold]{log_msg}[/bold]", title="Alignment Log", expand=False))
+    
+    # Agentic Summary Panel
+    console.print(Panel(summary, title="🤖 Agentic Assessment", border_style="cyan"))
+
+    # Roadmap Table
+    roadmap_table = Table(title="Semantic Roadmap Alignment")
+    roadmap_table.add_column("Status", style="bold")
+    roadmap_table.add_column("Aligned Items", style="cyan")
+    
+    status_style = "green" if alignment_data["status"] == "ALIGNED" else ("yellow" if alignment_data["status"] == "DRIFTING" else "red")
+    
+    roadmap_table.add_row(
+        f"[{status_style}]{alignment_data['status']}[/]",
+        ", ".join(alignment_data["aligned_items"]) if alignment_data["aligned_items"] else "None"
+    )
+    console.print(roadmap_table)
+
+    # Drift Items
+    if alignment_data.get("drift_items"):
+        console.print("\n[bold yellow]Detected Drift (Work not in Roadmap):[/bold yellow]")
+        for item in alignment_data["drift_items"]:
+            console.print(f"  • {item}")
+    
+    # PRs Table
+    if prs:
+        pr_table = Table(title="Recent Merged PRs")
+        pr_table.add_column("PR #", style="dim")
+        pr_table.add_column("Title", style="white")
+        pr_table.add_column("Author", style="cyan")
+        
+        for pr in prs:
+            pr_table.add_row(str(pr["number"]), pr["title"], pr["author"]["login"])
+        console.print(pr_table)
+    
+    # Suggestions
+    if suggestions:
+        console.print("\n[bold]Suggestions for Next Sprint:[/bold]")
+        for s in suggestions[:5]:
+            console.print(f"  • {s}")
+
+    if sync:
+        click.echo("\nSyncing alignment data to API...")
+        # TODO: Implement API sync once endpoints are ready
+        click.echo("Sync scheduled for next platform update.")

onecoder/commands/server.py

@@ -0,0 +1,170 @@
+import click
+import asyncio
+import threading
+import uvicorn
+import webbrowser
+import signal
+import sys
+import socket
+from ..ipc_auth import IPCAuthServer, get_token_from_ipc
+
+# Global flag for graceful shutdown
+shutdown_event = asyncio.Event()
+
+def check_port_available(port: int) -> bool:
+    """Check if a port is available."""
+    try:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.bind(("127.0.0.1", port))
+            return True
+    except OSError:
+        return False
+
+async def check_servers_running() -> bool:
+    """Check if OneCoder servers are running."""
+    try:
+        token = await get_token_from_ipc()
+        return token is not None
+    except:
+        return False
+
+def run_api_server(port: int = 8000):
+    """Runs the FastAPI server."""
+    from ..api import app
+    uvicorn.run(app, host="127.0.0.1", port=port, log_level="info")
+
+async def run_servers_async(port: int = 8000):
+    """Run both API and IPC servers concurrently."""
+    # Start API server in a thread
+    api_thread = threading.Thread(target=run_api_server, args=(port,), daemon=True)
+    api_thread.start()
+
+    # Give API server time to start
+    await asyncio.sleep(1)
+
+    # Start IPC server in main async loop
+    ipc_server = IPCAuthServer()
+    try:
+        await ipc_server.start()
+    except asyncio.CancelledError:
+        click.echo("Shutting down gracefully...")
+
+def signal_handler(signum, frame):
+    """Handle shutdown signals."""
+    click.echo("\nReceived shutdown signal. Cleaning up...")
+    sys.exit(0)
+
+@click.command()
+@click.option("--port", default=8000, help="API server port")
+def serve(port):
+    """Starts the Agent API and IPC Auth servers."""
+    # Check if port is available
+    if not check_port_available(port):
+        click.echo(f"Error: Port {port} is already in use.")
+        click.echo(f"Check for running processes: lsof -i :{port}")
+        return
+
+    click.echo(f"Starting OneCoder servers on port {port}...")
+    click.echo("Press Ctrl+C to stop.")
+
+    # Set up signal handlers
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+
+    # Run servers
+    try:
+        asyncio.run(run_servers_async(port))
+    except KeyboardInterrupt:
+        click.echo("\nShutting down...")
+
+@click.command()
+@click.option("--auto-start", is_flag=True, help="Auto-start servers if not running")
+def web(auto_start):
+    """Launches the secure Web UI."""
+
+    async def launch():
+        # Check if servers are running
+        servers_running = await check_servers_running()
+
+        if not servers_running:
+            if auto_start:
+                click.echo("Servers not running. Starting in background...")
+                # Start servers in background thread
+                server_thread = threading.Thread(
+                    target=lambda: asyncio.run(run_servers_async()), daemon=True
+                )
+                server_thread.start()
+                # Wait for servers to be ready
+                await asyncio.sleep(2)
+
+                # Verify they started
+                if not await check_servers_running():
+                    click.echo("Error: Failed to start servers automatically.")
+                    return
+            else:
+                click.echo("Error: Servers not running.")
+                click.echo(
+                    "Run 'onecoder serve' in another terminal or use --auto-start"
+                )
+                return
+
+        # Fetch token
+        token = await get_token_from_ipc()
+        if not token:
+            click.echo("Error: Could not fetch authentication token.")
+            return
+
+        # Launch browser
+        url = f"http://127.0.0.1:8000/?token={token}"
+        click.echo(f"Launching Web UI: {url}")
+        webbrowser.open(url)
+
+        if auto_start:
+            click.echo("\nServers running in background. Press Ctrl+C to stop.")
+            try:
+                # Keep running if we auto-started
+                await asyncio.Event().wait()
+            except KeyboardInterrupt:
+                click.echo("\nShutting down...")
+
+    asyncio.run(launch())
+
+@click.command()
+@click.option("--auto-start", is_flag=True, help="Auto-start servers if not running")
+@click.option("--api-url", help="Override the API URL")
+def tui(auto_start, api_url):
+    """Launches the modern Textual TUI."""
+
+    async def launch():
+        # Check if servers are running
+        servers_running = await check_servers_running()
+
+        if not servers_running:
+            if auto_start:
+                click.echo("Servers not running. Starting in background...")
+                # Start servers in background thread
+                server_thread = threading.Thread(
+                    target=lambda: asyncio.run(run_servers_async()), daemon=True
+                )
+                server_thread.start()
+                # Wait for servers to be ready
+                await asyncio.sleep(2)
+
+                # Verify they started
+                if not await check_servers_running():
+                    click.echo("Error: Failed to start servers automatically.")
+                    return
+            else:
+                click.echo("Error: Servers not running.")
+                click.echo(
+                    "Run 'onecoder serve' in another terminal or use --auto-start"
+                )
+                return
+
+        # Launch Textual TUI
+        from ..tui.app import OneCoderApp
+
+        app = OneCoderApp(api_url=api_url)
+        await app.run_async()
+
+    asyncio.run(launch())