onecoder 0.0.2__py3-none-any.whl

onecoder/alignment.py

@@ -0,0 +1,236 @@
+import os
+import json
+import subprocess
+import datetime
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+from .agent import get_model
+
+class AlignmentTracker:
+    def __init__(self, repo_root: Optional[Path] = None):
+        self.repo_root = repo_root or self._find_repo_root()
+        self.alignment_dir = self.repo_root / ".onecoder" / "alignment"
+        self.logs_dir = self.alignment_dir / "logs"
+        self.logs_dir.mkdir(parents=True, exist_ok=True)
+
+    def _find_repo_root(self) -> Path:
+        current = Path.cwd().resolve()
+        while current != current.parent:
+            if (current / ".git").exists():
+                return current
+            current = current.parent
+        return Path.cwd().resolve()
+
+    def get_time_window(self, hour: int) -> str:
+        if 6 <= hour < 12:
+            return "Morning"
+        elif 12 <= hour < 18:
+            return "Afternoon"
+        elif 18 <= hour < 24:
+            return "Evening"
+        else:
+            return "Night"
+
+    def fetch_recent_prs(self, limit: int = 5) -> List[Dict[str, Any]]:
+        """Fetches recent merged PRs using gh CLI."""
+        try:
+            result = subprocess.run(
+                ["gh", "pr", "list", "--state", "merged", "--limit", str(limit), "--json", "number,title,mergedAt,author,url"],
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            return json.loads(result.stdout)
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            return []
+
+    def log_current_state(self) -> str:
+        """Logs the current commit and PR status to the filesystem."""
+        now = datetime.datetime.now()
+        date_str = now.strftime("%Y-%m-%d")
+        window = self.get_time_window(now.hour)
+        
+        # Get latest commit
+        try:
+            commit_hash = subprocess.check_output(["git", "rev-parse", "HEAD"], text=True).strip()
+            commit_msg = subprocess.check_output(["git", "log", "-1", "--pretty=%B"], text=True).strip()
+        except subprocess.CalledProcessError:
+            commit_hash = "unknown"
+            commit_msg = "unknown"
+
+        recent_prs = self.fetch_recent_prs()
+        
+        log_file = self.logs_dir / f"{date_str}.json"
+        
+        if log_file.exists():
+            with open(log_file, "r") as f:
+                try:
+                    daily_logs = json.load(f)
+                except json.JSONDecodeError:
+                    daily_logs = {}
+        else:
+            daily_logs = {}
+
+        if window not in daily_logs:
+            daily_logs[window] = []
+
+        entry = {
+            "timestamp": now.isoformat(),
+            "commit_hash": commit_hash,
+            "commit_message": commit_msg,
+            "recent_prs": recent_prs
+        }
+        
+        daily_logs[window].append(entry)
+        
+        with open(log_file, "w") as f:
+            json.dump(daily_logs, f, indent=4)
+            
+        return f"Logged state for {window} in {log_file.name}"
+
+    def check_roadmap_alignment(self) -> Dict[str, Any]:
+        """Checks current activity against MVP_ROADMAP.md."""
+        roadmap_path = self.repo_root / "MVP_ROADMAP.md"
+        if not roadmap_path.exists():
+            return {"status": "unknown", "message": "MVP_ROADMAP.md not found"}
+        
+        roadmap_content = roadmap_path.read_text()
+        
+        # Simple heuristic check: find active sections mentioned in recent commits
+        try:
+            recent_commits = subprocess.check_output(["git", "log", "-n", "10", "--pretty=%s"], text=True).split("\n")
+        except subprocess.CalledProcessError:
+            recent_commits = []
+
+        aligned_items = []
+        for line in roadmap_content.split("\n"):
+            if "###" in line or "- **" in line:
+                item = line.strip("#-* ").split(" (")[0]
+                for commit in recent_commits:
+                    if item.lower() in commit.lower():
+                        aligned_items.append(item)
+                        break
+        
+        return {
+            "status": "aligned" if aligned_items else "diverged",
+            "aligned_items": list(set(aligned_items)),
+            "message": f"Found {len(aligned_items)} items aligned with roadmap."
+        }
+
+    def capture_suggestions(self) -> List[str]:
+        """Scans ANTIGRAVITY.md and recent RETRO.md files for suggestions."""
+        suggestions = []
+        
+        # Scan ANTIGRAVITY.md
+        antigravity_path = self.repo_root / "ANTIGRAVITY.md"
+        if antigravity_path.exists():
+            content = antigravity_path.read_text()
+            # Simple heuristic: lines in 'Future' or 'To Watch' sections
+            capture = False
+            for line in content.split("\n"):
+                if "##" in line and any(x in line for x in ["Future", "Watch", "Improvement"]):
+                    capture = True
+                elif "##" in line:
+                    capture = False
+                
+                if capture and line.strip().startswith("-"):
+                    suggestions.append(line.strip("- ").strip())
+
+        # Scan recent RETRO.md
+        sprint_dir = self.repo_root / ".sprint"
+        if sprint_dir.exists():
+            retro_files = sorted(list(sprint_dir.glob("*/RETRO.md")), key=os.path.getmtime, reverse=True)[:3]
+            for retro_path in retro_files:
+                content = retro_path.read_text()
+                # Simple heuristic: bullet points under 'To Improve' or 'Learnings'
+                capture = False
+                for line in content.split("\n"):
+                    if "##" in line and any(x in line for x in ["Improve", "Learning", "Next"]):
+                        capture = True
+                    elif "##" in line:
+                        capture = False
+                    
+                    if capture and line.strip().startswith("-"):
+                        suggestions.append(line.strip("- ").strip())
+        
+        return list(set(suggestions))
+
+    def summarize_alignment_agentic(self, alignment_data: Dict[str, Any], recent_prs: List[Dict[str, Any]], suggestions: List[str]) -> str:
+        """Uses LLM to summarize the alignment status."""
+        try:
+            from google.adk.agents import LlmAgent
+            model = get_model()
+            agent = LlmAgent(
+                name="alignment_summarizer",
+                model=model,
+                instruction="You are a project manager analyst. Provide a 2-3 sentence summary of project health."
+            )
+            
+            prompt = f"""
+            Analyze current alignment:
+            Roadmap Status: {alignment_data['status']}
+            Aligned Items: {alignment_data['aligned_items']}
+            Recent PRs: {json.dumps(recent_prs)}
+            Suggestions: {json.dumps(suggestions[:5])}
+            """
+            
+            response = agent.run(prompt)
+            return response
+                
+        except Exception as e:
+            return f"Agentic summary unavailable: {e}"
+
+                
+        except Exception as e:
+            return {"status": "DRIFTING", "message": f"Semantic check fallback: {e}", "aligned_items": [], "drift_items": []}
+
+    def check_roadmap_alignment_agentic(self) -> Dict[str, Any]:
+        """Uses LLM to semantically compare activity against MVP_ROADMAP.md."""
+        roadmap_path = self.repo_root / "MVP_ROADMAP.md"
+        if not roadmap_path.exists():
+            return {"status": "unknown", "message": "MVP_ROADMAP.md not found"}
+        
+        roadmap_content = roadmap_path.read_text()
+        
+        try:
+            recent_commits = subprocess.check_output(["git", "log", "-n", "20", "--pretty=%s"], text=True)
+            recent_prs = self.fetch_recent_prs(limit=10)
+            
+            model = get_model()
+            
+            prompt = f"""
+            Analyze the following Roadmap and recent development activity (commits and PRs). 
+            Perform a semantic mapping of the activity to the Roadmap items.
+            
+            ROADMAP:
+            {roadmap_content}
+            
+            RECENT COMMITS:
+            {recent_commits}
+            
+            RECENT PRS:
+            {json.dumps(recent_prs)}
+            
+            Categorize the project status as:
+            - **ALIGNED**: Work is directly advancing items in the Roadmap.
+            - **DRIFTING**: Work is valuable but not explicitly in the Roadmap.
+            - **DIVERGED**: Work is unrelated to the Roadmap goals.
+            
+            Format your response as a JSON object:
+            {{
+                "status": "ALIGNED" | "DRIFTING" | "DIVERGED",
+                "aligned_items": ["List of items from the roadmap that the work aligns with"],
+                "drift_items": ["List of work items that are not in the roadmap"],
+                "message": "A brief explanation of the alignment status (1-2 sentences)"
+            }}
+            """
+            
+            if hasattr(model, "completion"):
+                response = model.completion(messages=[{"role": "user", "content": prompt}], response_format={ "type": "json_object" })
+                data = json.loads(response.choices[0].message.content)
+                return data
+            else:
+                return {"status": "DRIFTING", "aligned_items": [], "drift_items": [], "message": "LiteLLM fallback. Run with GEMINI_API_KEY for semantic analysis."}
+                
+        except Exception as e:
+            return {"status": "error", "message": f"Semantic check failed: {e}", "aligned_items": [], "drift_items": []}

onecoder/api.py

@@ -0,0 +1,162 @@
+import json
+import asyncio
+import os
+from typing import Any
+from pathlib import Path
+from fastapi import FastAPI, Request, HTTPException, Depends
+from fastapi.responses import StreamingResponse, RedirectResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+from google.adk.runners import Runner
+from .sessions import DurableSessionService
+from google.genai.types import Content, Part
+from .ipc_auth import TOKEN_STORE
+from .agent import get_root_agent
+from .distillation import capture_engine
+
+app = FastAPI(title="OneCoder Agent API")
+
+# Add CORS middleware for local development
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Mount static files for web UI
+static_dir = Path(__file__).parent / "static"
+if static_dir.exists():
+    app.mount("/static", StaticFiles(directory=str(static_dir)), name="static")
+
+# Setup ADK session service and runner
+session_service = DurableSessionService()
+runner = Runner(
+    session_service=session_service, agent=get_root_agent(), app_name="onecoder-unified-api"
+)
+
+
+@app.get("/")
+async def root(token: str | None = None):
+    """Root endpoint - redirects to web UI if token provided."""
+    if token:
+        return RedirectResponse(url=f"/static/index.html?token={token}")
+    return {
+        "message": "OneCoder API",
+        "version": "0.1.0",
+        "endpoints": {
+            "web_ui": "/static/index.html?token=<token>",
+            "chat": "POST /chat",
+            "stream": "GET /stream",
+        },
+    }
+
+
+async def verify_token(request: Request):
+    """
+    Middleware-like dependency to verify session-based tokens.
+    The token can be passed in 'Authorization: Bearer <token>' or '?token=<token>'.
+    """
+    token = request.query_params.get("token")
+    auth_header = request.headers.get("Authorization")
+
+    if auth_header and auth_header.startswith("Bearer "):
+        token = auth_header.split(" ")[1]
+
+    if not token or not TOKEN_STORE.validate_token(token):
+        raise HTTPException(
+            status_code=401, detail="Unauthorized: Invalid or expired token"
+        )
+
+
+@app.post("/chat")
+async def chat(user_id: str, session_id: str, message: str, _=Depends(verify_token)):
+    """
+    Standard synchronous chat endpoint (returns full response).
+    """
+    session = await session_service.get_session(
+        app_name="onecoder-unified-api", user_id=user_id, session_id=session_id
+    )
+    if not session:
+        session = await session_service.create_session(
+            app_name="onecoder-unified-api", user_id=user_id, session_id=session_id
+        )
+
+    final_text = ""
+    async for event in runner.run_async(
+        user_id=user_id,
+        session_id=session_id,
+        new_message=Content(parts=[Part(text=message)], role="user"),
+    ):
+        if hasattr(event, "content") and event.content and event.content.parts:
+            text_part = next((part for part in event.content.parts if part.text), None)
+            if text_part and text_part.text:
+                final_text += text_part.text
+
+    return {"response": final_text}
+
+
+@app.get("/stream")
+async def stream(user_id: str, session_id: str, message: str, token: str):
+    """
+    SSE endpoint for streaming agent responses and events.
+    FastAPI handles StreamingResponse well for this.
+    Note: Token validation is done inside since SSE doesn't always support headers easily.
+    """
+    if not TOKEN_STORE.validate_token(token):
+        raise HTTPException(status_code=401, detail="Unauthorized")
+
+    session = await session_service.get_session(
+        app_name="onecoder-unified-api", user_id=user_id, session_id=session_id
+    )
+    if not session:
+        session = await session_service.create_session(
+            app_name="onecoder-unified-api", user_id=user_id, session_id=session_id
+        )
+
+    async def event_generator():
+        capture_engine.start_session(session_id)
+        try:
+            async for event in runner.run_async(
+                user_id=user_id,
+                session_id=session_id,
+                new_message=Content(parts=[Part(text=message)], role="user"),
+            ):
+                # Format event for SSE
+                event_data: dict[str, str | dict[str, Any] | None] = {
+                    "type": type(event).__name__,
+                }
+
+                if hasattr(event, "content") and event.content and event.content.parts:
+                    text_part = next(
+                        (part for part in event.content.parts if part.text), None
+                    )
+                    if text_part and text_part.text:
+                        event_data["text"] = text_part.text
+
+                    # Capture tool calls or delegation events if present
+                    tool_call = next(
+                        (part for part in event.content.parts if part.function_call),
+                        None,
+                    )
+                    if tool_call and tool_call.function_call:
+                        event_data["tool_call"] = {
+                            "name": tool_call.function_call.name,
+                            "args": tool_call.function_call.args,
+                        }
+
+                capture_engine.log_event(event_data)
+                yield f"data: {json.dumps(event_data)}\n\n"
+            
+            capture_engine.save_session()
+        except Exception as e:
+            yield f"data: {json.dumps({'type': 'Error', 'message': str(e)})}\n\n"
+
+    return StreamingResponse(event_generator(), media_type="text/event-stream")
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(app, host="127.0.0.1", port=8000)

onecoder/api_client.py

@@ -0,0 +1,112 @@
+import httpx
+import os
+import json
+from typing import Optional, Dict, Any, List
+
+class OneCoderAPIClient:
+    def __init__(self, base_url: str, token: Optional[str] = None):
+        self.base_url = base_url.rstrip("/")
+        self.token = token
+        self.headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }
+        if self.token:
+            self.headers["Authorization"] = f"Bearer {self.token}"
+
+    def set_token(self, token: str):
+        """Update the client's token."""
+        self.token = token
+        self.headers["Authorization"] = f"Bearer {token}"
+
+    async def _request(self, method: str, path: str, **kwargs) -> Dict[str, Any]:
+        """Internal helper for API requests."""
+        url = f"{self.base_url}/api/v1{path}"
+        if path.startswith("/api/v1"):
+            url = f"{self.base_url}{path}"
+            
+        import logging
+        logging.debug(f"Making request to: {url}")
+            
+        async with httpx.AsyncClient() as client:
+            response = await client.request(method, url, headers=self.headers, **kwargs)
+            response.raise_for_status()
+            return response.json()
+
+    async def login_with_github(self, code: str) -> Dict[str, Any]:
+        """Exchange GitHub OAuth code for a JWT token."""
+        data = await self._request("POST", "/auth/github", json={"code": code})
+        if "token" not in data:
+            raise ValueError(f"Invalid API response: Missing 'token' field. Got keys: {list(data.keys())}")
+        self.set_token(data["token"])
+        return data
+
+    async def get_preferences(self) -> Dict[str, Any]:
+        """Fetch user preferences from the API."""
+        return await self._request("GET", "/users/me/preferences")
+
+    async def update_preferences(self, preferences: Dict[str, Any]) -> Dict[str, Any]:
+        """Update user preferences via the API."""
+        return await self._request("PUT", "/users/me/preferences", json=preferences)
+
+    async def get_me(self) -> Dict[str, Any]:
+        """Get current user information."""
+        url = f"{self.base_url}/api/v1/users/me"
+        # Since /api/v1/users/me is not explicitly implemented in my last edit, 
+        # I'll use /api/v1/auth/me or similar if I implement it, or just stick to what exists.
+        # Actually, let's implement /api/v1/users/me in the API later or use the token payload.
+        pass
+
+    async def sync_project(self, project_id: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Sync project durable context (specs, metadata) to the API."""
+        url = f"{self.base_url}/api/v1/projects/{project_id}/sync"
+        return await self._request("POST", f"/projects/{project_id}/sync", json=data)
+
+    async def sync_sprint(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Sync sprint state (tasks, status) to the API."""
+        return await self._request("POST", "/sprints/sync", json=data)
+
+    async def sync_issues(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Syncs issue data."""
+        return await self._request("POST", "/issues/sync", json=data)
+
+    async def get_workspaces(self) -> List[Dict[str, Any]]:
+        """Fetch list of available workspaces."""
+        data = await self._request("GET", "/workspaces")
+        return data.get("workspaces", [])
+
+    async def create_workspace(self, name: str) -> Dict[str, Any]:
+        """Create a new workspace."""
+        data = await self._request("POST", "/workspaces", json={"name": name})
+        return data.get("workspace", {})
+
+    async def create_project(self, name: str, workspace_id: Optional[str] = None) -> Dict[str, Any]:
+        """Create a new project."""
+        payload = {"name": name}
+        if workspace_id:
+            payload["workspaceId"] = workspace_id
+        data = await self._request("POST", "/projects", json=payload)
+        return data.get("project", {})
+
+    async def join_workspace(self, workspace_id: str, project_id: str) -> Dict[str, Any]:
+        """Associate a project with a workspace."""
+        return await self._request("POST", f"/workspaces/{workspace_id}/projects", json={"projectId": project_id})
+
+    async def upload_failure(self, failure_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Upload a single failure mode to the API."""
+        return await self._request("POST", "/failure-modes", json=failure_data)
+
+    async def analyze_project(self, scan_data: Dict[str, Any], user_feedback: Optional[str] = None) -> Dict[str, Any]:
+        """Request server-side analysis of a project."""
+        payload = {"scanData": scan_data}
+        if user_feedback:
+            payload["userFeedback"] = user_feedback
+            
+        # Increase timeout for analysis as it involves LLM processing
+        return await self._request("POST", "/projects/analyze", json=payload, timeout=60.0)
+
+from .constants import ONECODER_API_URL
+
+def get_api_client(token: Optional[str] = None) -> OneCoderAPIClient:
+    base_url = ONECODER_API_URL
+    return OneCoderAPIClient(base_url, token)

onecoder/backends/base.py

@@ -0,0 +1,22 @@
+from abc import ABC, abstractmethod
+from typing import Optional
+from ..models.delegation import DelegationSession
+
+class BaseBackend(ABC):
+    """
+    Base class for delegation backends.
+    """
+    
+    @abstractmethod
+    async def spawn(self, session: DelegationSession) -> str:
+        """
+        Spawns the delegated task and returns a connection string or identifier.
+        """
+        pass
+
+    @abstractmethod
+    async def cleanup(self, session: DelegationSession):
+        """
+        Cleans up resources associated with the session.
+        """
+        pass

onecoder/backends/local_tui.py

@@ -0,0 +1,65 @@
+import os
+import logging
+from pathlib import Path
+from .base import BaseBackend
+from ..models.delegation import DelegationSession
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..services.delegation_service import DelegationService
+
+logger = logging.getLogger(__name__)
+
+class LocalTUIBackend(BaseBackend):
+    """
+    Spawns a local terminal UI (via tmux) in an isolated worktree.
+    """
+
+    def __init__(self, delegation_service: 'DelegationService'):
+        self.service = delegation_service
+
+    async def spawn(self, session: DelegationSession) -> str:
+        # Use delegation service to handle the heavy lifting
+        logger.info(f"Spawning local TUI for session {session.id}")
+        
+        # 1. Create worktree
+        wt_path = self.service.worktree_mgr.create_worktree(session.id)
+        
+        # 2. Reduce TTU: Inject context
+        self.service._inject_context(wt_path, session)
+        
+        # 3. Define tmux session name
+        tmux_name = f"onecoder-{session.id[:8]}"
+        
+        # 4. Create tmux session
+        # Use gemini as default command if available, fallback to shell
+        # We also pass the task prompt to a temporary file for the agent to read
+        agent_cmd = "gemini"
+        
+        # Check if gemini is in path
+        import shutil
+        if not shutil.which("gemini"):
+            logger.warning("Gemini CLI not found in PATH, falling back to shell.")
+            agent_cmd = "$SHELL"
+
+        cmd = f"cd {wt_path} && export ACTIVE_SPRINT_ID={os.environ.get('ACTIVE_SPRINT_ID', '')} && {agent_cmd}"
+        if session.command:
+            # Provide the prompt to the agent via a dedicated instruction file
+            instruction_path = wt_path / "INSTRUCTIONS.md"
+            instruction_path.write_text(f"# Task\n{session.command}")
+            # In some agents, we can pass the prompt as an argument
+            if agent_cmd == "gemini":
+                cmd = f"cd {wt_path} && export ACTIVE_SPRINT_ID={os.environ.get('ACTIVE_SPRINT_ID', '')} && {agent_cmd} 'Review INSTRUCTIONS.md and execute the task.'"
+            else:
+                cmd = f"cd {wt_path} && echo '# {session.command}' >> BOOTSTRAP.md && {agent_cmd}"
+
+        self.service.tmux_mgr.create_session(tmux_name, cmd, cwd=str(wt_path))
+        
+        # 5. Update session status
+        session.mark_running(tmux_session=tmux_name, worktree_path=str(wt_path))
+        self.service._save_session(session)
+        
+        return f"tmux attach -t {tmux_name}"
+
+    async def cleanup(self, session: DelegationSession):
+        self.service.stop_session(session.id)