onecoder 0.0.2__py3-none-any.whl

onecoder/sessions.py

@@ -0,0 +1,186 @@
+import os
+import json
+import time
+import copy
+import logging
+from typing import Any, Optional, Dict, List
+from pathlib import Path
+from pydantic import BaseModel
+
+from google.adk.sessions.base_session_service import BaseSessionService, GetSessionConfig, ListSessionsResponse
+from google.adk.sessions.session import Session
+from google.adk.events.event import Event
+from google.adk.sessions.state import State
+from google.adk.sessions import _session_util
+
+logger = logging.getLogger(__name__)
+
+class DurableSessionService(BaseSessionService):
+    """
+    A filesystem-backed session service for OneCoder.
+    Persists sessions, app state, and user state as JSON files.
+    """
+
+    def __init__(self, storage_dir: str = ".adk/sessions"):
+        self.storage_dir = Path(storage_dir)
+        self.sessions_dir = self.storage_dir / "sessions"
+        self.app_state_dir = self.storage_dir / "apps"
+        self.user_state_dir = self.storage_dir / "users"
+        
+        # Ensure directories exist
+        self.sessions_dir.mkdir(parents=True, exist_ok=True)
+        self.app_state_dir.mkdir(parents=True, exist_ok=True)
+        self.user_state_dir.mkdir(parents=True, exist_ok=True)
+
+    def _get_session_path(self, app_name: str, user_id: str, session_id: str) -> Path:
+        return self.sessions_dir / app_name / user_id / f"{session_id}.json"
+
+    def _get_app_state_path(self, app_name: str) -> Path:
+        return self.app_state_dir / f"{app_name}.json"
+
+    def _get_user_state_path(self, app_name: str, user_id: str) -> Path:
+        return self.user_state_dir / app_name / f"{user_id}.json"
+
+    def _save_json(self, path: Path, data: Any):
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with open(path, "w") as f:
+            if isinstance(data, BaseModel):
+                f.write(data.model_dump_json(by_alias=True, indent=2))
+            else:
+                json.dump(data, f, indent=2)
+
+    def _load_json(self, path: Path) -> Optional[Dict[str, Any]]:
+        if not path.exists():
+            return None
+        with open(path, "r") as f:
+            return json.load(f)
+
+    async def create_session(
+        self,
+        *,
+        app_name: str,
+        user_id: str,
+        state: Optional[dict[str, Any]] = None,
+        session_id: Optional[str] = None,
+    ) -> Session:
+        if not session_id:
+            session_id = f"session_{int(time.time())}"
+        
+        session = Session(
+            id=session_id,
+            app_name=app_name,
+            user_id=user_id,
+            state=state or {},
+            last_update_time=time.time()
+        )
+        
+        self._save_json(self._get_session_path(app_name, user_id, session_id), session)
+        return session
+
+    async def get_session(
+        self,
+        *,
+        app_name: str,
+        user_id: str,
+        session_id: str,
+        config: Optional[GetSessionConfig] = None,
+    ) -> Optional[Session]:
+        path = self._get_session_path(app_name, user_id, session_id)
+        data = self._load_json(path)
+        if not data:
+            return None
+            
+        session = Session.model_validate(data)
+        
+        # Filtering events based on config
+        if config:
+            if config.num_recent_events:
+                session.events = session.events[-config.num_recent_events:]
+            if config.after_timestamp:
+                session.events = [e for e in session.events if e.timestamp >= config.after_timestamp]
+        
+        return self._merge_state(app_name, user_id, session)
+
+    def _merge_state(self, app_name: str, user_id: str, session: Session) -> Session:
+        # Load and merge app state
+        app_state = self._load_json(self._get_app_state_path(app_name)) or {}
+        for key, value in app_state.items():
+            session.state[State.APP_PREFIX + key] = value
+            
+        # Load and merge user state
+        user_state = self._load_json(self._get_user_state_path(app_name, user_id)) or {}
+        for key, value in user_state.items():
+            session.state[State.USER_PREFIX + key] = value
+            
+        return session
+
+    async def list_sessions(
+        self, *, app_name: str, user_id: Optional[str] = None
+    ) -> ListSessionsResponse:
+        sessions = []
+        app_path = self.sessions_dir / app_name
+        if not app_path.exists():
+            return ListSessionsResponse(sessions=[])
+            
+        user_ids = [user_id] if user_id else [u.name for u in app_path.iterdir() if u.is_dir()]
+        
+        for uid in user_ids:
+            user_path = app_path / uid
+            if not user_path.exists():
+                continue
+            for session_file in user_path.glob("*.json"):
+                data = self._load_json(session_file)
+                if data:
+                    s = Session.model_validate(data)
+                    s.events = [] # Following list_sessions contract (no events)
+                    sessions.append(self._merge_state(app_name, uid, s))
+                    
+        return ListSessionsResponse(sessions=sessions)
+
+    async def delete_session(
+        self, *, app_name: str, user_id: str, session_id: str
+    ) -> None:
+        path = self._get_session_path(app_name, user_id, session_id)
+        if path.exists():
+            path.unlink()
+
+    async def append_event(self, session: Session, event: Event) -> Event:
+        if event.partial:
+            return event
+            
+        # Update session object in memory (handles state delta too)
+        await super().append_event(session, event)
+        session.last_update_time = event.timestamp
+        
+        # Load the stored session to apply events and state deltas
+        path = self._get_session_path(session.app_name, session.user_id, session.id)
+        data = self._load_json(path)
+        if not data:
+            logger.warning(f"Session file not found during append_event: {path}")
+            # If it's missing, we still save the passed session as a recovery
+            self._save_json(path, session)
+            return event
+            
+        storage_session = Session.model_validate(data)
+        storage_session.events.append(event)
+        storage_session.last_update_time = event.timestamp
+        
+        # Apply state deltas to persistent state files
+        if event.actions and event.actions.state_delta:
+            deltas = _session_util.extract_state_delta(event.actions.state_delta)
+            
+            if deltas["app"]:
+                app_state = self._load_json(self._get_app_state_path(session.app_name)) or {}
+                app_state.update(deltas["app"])
+                self._save_json(self._get_app_state_path(session.app_name), app_state)
+                
+            if deltas["user"]:
+                user_state = self._load_json(self._get_user_state_path(session.app_name, session.user_id)) or {}
+                user_state.update(deltas["user"])
+                self._save_json(self._get_user_state_path(session.app_name, session.user_id), user_state)
+                
+            if deltas["session"]:
+                storage_session.state.update(deltas["session"])
+                
+        self._save_json(path, storage_session)
+        return event

onecoder/sprint_collector.py

@@ -0,0 +1,165 @@
+"""
+Sprint data collection module.
+
+Scans .sprint/ directories and extracts sprint and task data for syncing to the API.
+"""
+
+import re
+import logging
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+
+try:
+    from ai_sprint.state import SprintStateManager
+    HAS_SPRINT_SDK = True
+except ImportError:
+    HAS_SPRINT_SDK = False
+
+logger = logging.getLogger(__name__)
+
+
+class SprintCollector:
+    """Collects sprint data from .sprint/ directories or via SDK."""
+    
+    def __init__(self, repo_root: Path):
+        self.repo_root = repo_root
+        self.sprint_dir = repo_root / ".sprint"
+        self.state_manager = None
+        if HAS_SPRINT_SDK:
+            try:
+                self.state_manager = SprintStateManager(self.sprint_dir)
+            except Exception as e:
+                logger.warning(f"Could not initialize SprintStateManager: {e}")
+    
+    def collect_all_sprints(self) -> List[Dict[str, Any]]:
+        """Scans .sprint/ and returns list of sprint data."""
+        sprints = []
+        
+        if not self.sprint_dir.exists():
+            return sprints
+        
+        for sprint_path in self.sprint_dir.iterdir():
+            if not sprint_path.is_dir():
+                continue
+            
+            # Skip hidden directories
+            if sprint_path.name.startswith('.'):
+                continue
+            
+            sprint_data = self._parse_sprint(sprint_path)
+            if sprint_data:
+                sprints.append(sprint_data)
+        
+        return sprints
+    
+    def _parse_sprint(self, sprint_path: Path) -> Optional[Dict[str, Any]]:
+        """Parses a single sprint directory."""
+        readme = sprint_path / "README.md"
+        todo = sprint_path / "TODO.md"
+        retro = sprint_path / "RETRO.md"
+        
+        sprint_id = sprint_path.name
+        
+        # Extract goal from README
+        goal = ""
+        title = sprint_id.replace("-", " ").title()
+        
+        if readme.exists():
+            content = readme.read_text()
+            
+            # Extract title from first heading
+            title_match = re.search(r'^#\s+Sprint:\s+(.+)$', content, re.MULTILINE)
+            if title_match:
+                title = title_match.group(1)
+            
+            # Extract goal from ## Goal section
+            goal_match = re.search(r'##\s+Goal\s*\n+(.+?)(?:\n\n|\n##|$)', content, re.DOTALL)
+            if goal_match:
+                goal = goal_match.group(1).strip()
+        
+        # Extract tasks from TODO.md
+        tasks = []
+        if todo.exists():
+            tasks = self._parse_todo(todo, sprint_id)
+        
+        # Determine status
+        status = "closed" if retro.exists() else "active"
+        
+        # Extract learnings from RETRO.md if available
+        learnings = []
+        if retro.exists():
+            learnings = self._parse_retro(retro)
+
+        return {
+            "id": sprint_id,
+            "title": title,
+            "status": status,
+            "goals": goal,
+            "tasks": tasks,
+            "learnings": learnings
+        }
+
+    def get_recent_context(self, limit: int = 3) -> List[Dict[str, Any]]:
+        """Returns context from the most recent sprints."""
+        all_sprints = self.collect_all_sprints()
+        # Sort by sprint ID (assuming lexicographical order roughly matches chronological or use metadata if available)
+        # Using simple string sort on ID for now, assuming format '000-name'
+        sorted_sprints = sorted(all_sprints, key=lambda x: x['id'], reverse=True)
+        return sorted_sprints[:limit]
+
+    def _parse_retro(self, retro_path: Path) -> List[str]:
+        """Mechanically extracts learnings from RETRO.md."""
+        learnings = []
+        content = retro_path.read_text()
+        capture = False
+        for line in content.split("\n"):
+            line_stripped = line.strip()
+            # Start capturing after these headers
+            if line_stripped.startswith("## ") and any(x in line_stripped for x in ["Learnings", "Learning", "Went Well", "To Improve", "Could Be Improved", "Action Items"]):
+                capture = True
+                continue
+            elif line_stripped.startswith("## "):
+                capture = False
+            
+            if capture:
+                if line_stripped.startswith("- "):
+                    learnings.append(line_stripped[2:].strip())
+                elif re.match(r'^\d+\.\s+', line_stripped):
+                     learnings.append(re.sub(r'^\d+\.\s+', '', line_stripped).strip())
+        return learnings
+    
+    def _parse_todo(self, todo_path: Path, sprint_id: str) -> List[Dict[str, Any]]:
+        """Parses TODO.md and extracts tasks."""
+        tasks = []
+        content = todo_path.read_text()
+        
+        task_counter = 1
+        for line in content.split("\n"):
+            line_stripped = line.strip()
+            
+            # Match task lines: - [ ], - [x], - [/]
+            if re.match(r'^-\s+\[.\]', line_stripped):
+                # Extract checkbox status
+                is_done = re.match(r'^-\s+\[x\]', line_stripped, re.IGNORECASE)
+                is_in_progress = re.match(r'^-\s+\[/\]', line_stripped)
+                
+                # Extract task title (everything after the checkbox)
+                title_match = re.search(r'^-\s+\[.\]\s+(.+)$', line_stripped)
+                if not title_match:
+                    continue
+                
+                title = title_match.group(1).strip()
+                
+                # Generate task ID
+                task_id = f"{sprint_id}-task-{task_counter:03d}"
+                
+                tasks.append({
+                    "id": task_id,
+                    "title": title,
+                    "status": "done" if is_done else ("in-progress" if is_in_progress else "todo"),
+                    "metadata": {}
+                })
+                
+                task_counter += 1
+        
+        return tasks

onecoder/sync.py

@@ -0,0 +1,167 @@
+import os
+import json
+import click
+from pathlib import Path
+from typing import Optional, Dict, Any
+from .api_client import get_api_client
+from .config_manager import config_manager
+from .sprint_collector import SprintCollector
+from .issues import IssueManager
+
+class ProjectConfig:
+    def __init__(self, repo_root: Path):
+        self.repo_root = repo_root
+        self.config_file = repo_root / ".onecoder.json"
+
+    def load(self) -> Dict[str, Any]:
+        if not self.config_file.exists():
+            return {}
+        try:
+            with open(self.config_file, "r") as f:
+                return json.load(f)
+        except Exception as e:
+            click.echo(f"Error loading project config: {e}")
+            return {}
+
+    def save(self, config: Dict[str, Any]):
+        try:
+            with open(self.config_file, "w") as f:
+                json.dump(config, f, indent=4)
+        except Exception as e:
+            click.echo(f"Error saving project config: {e}")
+
+    def get_project_id(self) -> Optional[str]:
+        # Priority: Env Var > Local Config
+        project_id = os.getenv("ONECODER_PROJECT_ID")
+        if project_id:
+            return project_id
+        return self.load().get("project_id")
+
+def find_repo_root() -> Path:
+    current = Path.cwd()
+    while current != current.parent:
+        if (current / ".git").exists():
+            return current
+        current = current.parent
+    return Path.cwd()
+
+async def sync_sprint(client, project_id: str, sprint: Dict[str, Any]):
+    """Syncs a single sprint to the API."""
+    try:
+        payload = {
+            "sprint": {
+                "id": sprint["id"],
+                "title": sprint["title"],
+                "status": sprint["status"],
+                "goals": sprint["goals"]
+            },
+            "tasks": sprint["tasks"],
+            "projectId": project_id
+        }
+        
+        result = await client.sync_sprint(payload)
+        click.secho(f"  ✓ {sprint['id']}: {len(sprint['tasks'])} tasks", fg="green")
+        return result
+    except Exception as e:
+        click.secho(f"  ✗ {sprint['id']}: {e}", fg="red")
+        return None
+
+async def sync_project_context():
+    """Aggregates local context and syncs with the API."""
+    repo_root = find_repo_root()
+    proj_config = ProjectConfig(repo_root)
+    project_id = proj_config.get_project_id()
+
+    if not project_id:
+        click.secho("Error: No project ID found. Run 'onecoder login' or set ONECODER_PROJECT_ID.", fg="red")
+        return
+
+    token = config_manager.get_token()
+    if not token:
+        click.secho("Error: Not logged in. Run 'onecoder login'.", fg="red")
+        return
+
+    # Aggregate context
+    spec_path = repo_root / "SPECIFICATION.md"
+    gov_path = repo_root / "governance.yaml"
+    learnings_path = repo_root / "ANTIGRAVITY.md"
+
+    sync_data = {
+        "metadata": {}
+    }
+
+    if spec_path.exists():
+        sync_data["specification"] = spec_path.read_text()
+    
+    if gov_path.exists():
+        sync_data["governance"] = gov_path.read_text()
+
+    if learnings_path.exists():
+        sync_data["metadata"]["learnings"] = learnings_path.read_text()
+
+    # Get project name from folder if not in config
+    if not sync_data.get("name"):
+        sync_data["name"] = repo_root.name
+
+    try:
+        client = get_api_client(token)
+        
+        # Sync project metadata
+        result = await client.sync_project(project_id, sync_data)
+        click.secho(f"✅ Project context synced successfully for ID: {project_id}", fg="green")
+        
+        # NEW: Sync sprint data
+        collector = SprintCollector(repo_root)
+        sprints = collector.collect_all_sprints()
+        
+        if sprints:
+            click.secho(f"\n📦 Syncing {len(sprints)} sprints...", fg="cyan")
+            for sprint in sprints:
+                await sync_sprint(client, project_id, sprint)
+            click.secho(f"✅ All sprints synced successfully", fg="green")
+        else:
+            click.secho("\nℹ️  No sprints found to sync", fg="yellow")
+        
+        return result
+        return result
+    except Exception as e:
+        click.secho(f"❌ Failed to sync project: {e}", fg="red")
+        return None
+
+async def sync_issues(client, project_id: str):
+    """Syncs local issues to the API."""
+    manager = IssueManager()
+    issues = manager.get_all_issues()
+    
+    if not issues:
+        click.secho("ℹ️  No issues found to sync", fg="yellow")
+        return
+
+    click.secho(f"📦 Syncing {len(issues)} issues...", fg="cyan")
+    
+    try:
+        payload = {
+            "projectId": project_id,
+            "issues": issues
+        }
+        
+        # We need to add sync_issues to api_client first? 
+        # Or we can just use client.post directly if method not exists.
+        # Let's assume client has a generic method or we add specific one.
+        # Actually, let's look at api_client.py later. For now, assuming client.sync_issues exists or using _request.
+        # Wait, I should check api_client.py. But for now I'll use a generic call pattern if possible 
+        # or assume I'll update api_client.py too.
+        # Let's just use the direct route for now if client exposes request.
+        
+        # Checking previous code, client seems to have typed methods.
+        # I should probably update api_client.py as well.
+        # But let's write the call here assuming the method exists, and then go fix api_client.
+        
+        result = await client.sync_issues(payload)
+        
+        stats = result.get("stats", {})
+        click.secho(f"✅ Issues synced: {stats.get('upserted', 0)} upserted, {stats.get('errors', 0)} errors", fg="green")
+        
+    except Exception as e:
+        click.secho(f"❌ Failed to sync issues: {e}", fg="red")
+

onecoder/tmux.py

@@ -0,0 +1,86 @@
+import subprocess
+import logging
+from typing import List, Optional
+
+logger = logging.getLogger(__name__)
+
+class TmuxManager:
+    """
+    Manages tmux sessions and panes for delegated tasks.
+    """
+
+    def __init__(self):
+        self._check_tmux()
+
+    def _check_tmux(self):
+        try:
+            subprocess.run(["tmux", "-V"], capture_output=True, check=True)
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            raise RuntimeError("tmux is not installed or not available in PATH")
+
+    def _run_tmux(self, args: List[str]) -> str:
+        command = ["tmux"] + args
+        result = subprocess.run(command, capture_output=True, text=True, check=False)
+        if result.returncode != 0:
+            logger.debug(f"Tmux command failed: {' '.join(command)}\nError: {result.stderr}")
+            raise RuntimeError(f"Tmux error: {result.stderr.strip()}")
+        return result.stdout.strip()
+
+    def has_session(self, name: str) -> bool:
+        try:
+            self._run_tmux(["has-session", "-t", name])
+            return True
+        except RuntimeError:
+            return False
+
+    def create_session(self, name: str, command: Optional[str] = None, cwd: Optional[str] = None) -> None:
+        """Creates a new detached tmux session."""
+        args = ["new-session", "-d", "-s", name]
+        if cwd:
+            args += ["-c", cwd]
+        if command:
+            args.append(command)
+        self._run_tmux(args)
+
+    def split_window(self, target_session: str, command: Optional[str] = None, horizontal: bool = True) -> None:
+        """Splits the current window of a session."""
+        args = ["split-window", "-t", target_session]
+        if horizontal:
+            args.append("-h")
+        else:
+            args.append("-v")
+        if command:
+            args.append(command)
+        self._run_tmux(args)
+
+    def kill_session(self, name: str) -> None:
+        """Kills a tmux session."""
+        if self.has_session(name):
+            self._run_tmux(["kill-session", "-t", name])
+
+    def list_sessions(self) -> List[str]:
+        """Lists all tmux sessions."""
+        try:
+            output = self._run_tmux(["list-sessions", "-F", "#S"])
+            return output.split("\n")
+        except RuntimeError:
+            return []
+
+    def send_keys(self, target: str, keys: str, enter: bool = True) -> None:
+        """Sends keys to a tmux session/pane."""
+        args = ["send-keys", "-t", target, keys]
+        if enter:
+            args.append("C-m")
+        self._run_tmux(args)
+
+if __name__ == "__main__":
+    # Quick test
+    import time
+    mgr = TmuxManager()
+    session = "test-session"
+    print(f"Creating session: {session}")
+    mgr.create_session(session, "top")
+    time.sleep(2)
+    print(f"Sessions: {mgr.list_sessions()}")
+    mgr.kill_session(session)
+    print("Session killed.")

onecoder/tools/__init__.py

@@ -0,0 +1,10 @@
+from .registry import registry
+from .interface import BaseTool
+
+# Dynamic Discovery
+def _initialize_tools():
+    from ..discovery import DiscoveryAgent
+    disco = DiscoveryAgent("onecoder.tools")
+    disco.discover_and_register()
+
+_initialize_tools()

onecoder/tools/executor.py

@@ -0,0 +1,53 @@
+
+import re
+from typing import Any, Dict, Optional, List
+from rank_bm25 import BM25Okapi
+from .registry import registry
+
+class DynamicToolExecutor:
+    """
+    Manages discovery and execution of tools using BM25 for ranking.
+    """
+    def __init__(self):
+        self.registry = registry
+
+    def _tokenize(self, text: str) -> List[str]:
+        return re.findall(r'\w+', text.lower())
+
+    async def find_and_execute_tool(self, query: str, **tool_args) -> Any:
+        """
+        Finds the best tool for the query using BM25 and executes it.
+        """
+        tools = self.registry.list_tools()
+        if not tools:
+            return "No tools registered in the system."
+
+        # Prepare corpus
+        tool_descriptions = [tool.description for tool in tools]
+        tokenized_corpus = [self._tokenize(doc) for doc in tool_descriptions]
+        
+        # Init BM25
+        bm25 = BM25Okapi(tokenized_corpus)
+        
+        # Query
+        tokenized_query = self._tokenize(query)
+        scores = bm25.get_scores(tokenized_query)
+        
+        # Find best
+        best_index = scores.argmax()
+        best_score = scores[best_index]
+        best_tool = tools[best_index]
+
+        print(f"[DynamicToolExecutor] Selected tool: '{best_tool.name}' (Score: {best_score:.4f}) for query: '{query}'")
+        
+        # Heuristic threshold could be added here, but for now we just take the top one
+        if best_score == 0:
+             print(f"[DynamicToolExecutor] Warning: Zero score match for query '{query}'. Defaulting to '{best_tool.name}'")
+
+        try:
+            return await best_tool.execute_async(**tool_args)
+        except Exception as e:
+            return f"Error executing tool '{best_tool.name}': {e}"
+
+# Global executor instance
+executor = DynamicToolExecutor()