onecoder 0.0.2__py3-none-any.whl

onecoder/logger.py

@@ -0,0 +1,42 @@
+import logging
+import os
+from pathlib import Path
+from logging.handlers import RotatingFileHandler
+
+def configure_logging(verbose: bool = False):
+    """Configures logging for the OneCoder CLI."""
+    
+    # define logs directory
+    log_dir = Path.home() / ".onecoder" / "logs"
+    log_dir.mkdir(parents=True, exist_ok=True)
+    log_file = log_dir / "onecoder.log"
+
+    # Set base level
+    level = logging.DEBUG if verbose else logging.INFO
+    
+    # Create root logger
+    root_logger = logging.getLogger()
+    root_logger.setLevel(level)
+    
+    # Clear existing handlers
+    if root_logger.handlers:
+        root_logger.handlers.clear()
+
+    # File Handler (Always logs DEBUG)
+    file_handler = RotatingFileHandler(log_file, maxBytes=10*1024*1024, backupCount=5)
+    file_handler.setLevel(logging.DEBUG)
+    file_formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+    file_handler.setFormatter(file_formatter)
+    root_logger.addHandler(file_handler)
+
+    # Console Handler (Logs INFO by default, DEBUG if verbose)
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(level)
+    console_formatter = logging.Formatter('%(message)s') # Simple format for console
+    console_handler.setFormatter(console_formatter)
+    root_logger.addHandler(console_handler)
+    
+    logging.debug(f"Logging initialized. Verbose: {verbose}")
+    return log_file

onecoder/metrics.py

@@ -0,0 +1,129 @@
+import os
+import json
+from pathlib import Path
+from datetime import datetime
+from typing import Optional, Dict, Any
+
+def find_repo_root() -> Path:
+    current = Path.cwd()
+    while current != current.parent:
+        if (current / ".git").exists():
+            return current
+        current = current.parent
+    return Path.cwd()
+
+class TTUMetrics:
+    _instance = None
+    _first_tool_called = False
+
+    def __init__(self):
+        self.repo_root = find_repo_root()
+        self.sprint_dir = self.repo_root / ".sprint"
+
+    @classmethod
+    def get_instance(cls):
+        if cls._instance is None:
+            cls._instance = cls()
+        return cls._instance
+
+    def track_first_tool_call(self):
+        """Called by tools or agent to mark the first actual action."""
+        if self._first_tool_called:
+            return
+        
+        self._first_tool_called = True
+        self._record_ttu()
+
+    def _record_ttu(self):
+        """Finds the active task and records TTU if not already set."""
+        if not self.sprint_dir.exists():
+            return
+
+        # 1. Find the active sprint
+        active_sprint_id = os.environ.get("ACTIVE_SPRINT_ID")
+        if not active_sprint_id:
+             # Try to find an active sprint directory
+             sprint_dirs = [d for d in self.sprint_dir.iterdir() if d.is_dir() and d.name[0].isdigit()]
+             if not sprint_dirs:
+                 return
+             # Heuristic: the one with the highest number is likely active
+             active_sprint_dir = sorted(sprint_dirs)[-1]
+        else:
+            active_sprint_dir = self.sprint_dir / active_sprint_id
+
+        if not active_sprint_dir.exists():
+            return
+
+        sprint_json_path = active_sprint_dir / "sprint.json"
+        if not sprint_json_path.exists():
+            return
+
+        try:
+            with open(sprint_json_path, 'r') as f:
+                state = json.load(f)
+
+            # 2. Find in-progress task
+            tasks = state.get("tasks", [])
+            active_task = None
+            for task in tasks:
+                if task.get("status") == "in-progress":
+                    active_task = task
+                    break
+            
+            if not active_task:
+                 # Fallback: check if any tasks were started but not completed
+                for task in tasks:
+                    if task.get("startedAt") and not task.get("completedAt"):
+                        active_task = task
+                        break
+
+            if not active_task:
+                return
+
+            # 3. Check if TTU already recorded
+            if active_task.get("ttuSeconds") is not None:
+                return
+
+            # 4. Calculate TTU
+            started_at_str = active_task.get("startedAt")
+            if not started_at_str:
+                return
+
+            # Handle ISO format (might have 'Z' or offset)
+            try:
+                started_at = datetime.fromisoformat(started_at_str.replace('Z', '+00:00'))
+            except ValueError:
+                # Fallback for older formats or varying ISO implementations
+                return
+
+            now = datetime.now().astimezone() # Ensure timezone awareness if started_at has it
+            
+            # If started_at is naive, make now naive too
+            if started_at.tzinfo is None:
+                now = datetime.now()
+            else:
+                # started_at has tz, ensuring now has the same or comparable tz
+                pass
+
+            diff = now - started_at
+            ttu_seconds = int(diff.total_seconds())
+
+            # Don't record negative TTU (clock skew or start after first call?)
+            if ttu_seconds < 0:
+                ttu_seconds = 0
+
+            # 5. Update state and save
+            active_task["ttuSeconds"] = ttu_seconds
+
+            with open(sprint_json_path, 'w') as f:
+                json.dump(state, f, indent=2)
+
+            # Passive logging
+            log_dir = active_sprint_dir / "logs"
+            log_dir.mkdir(exist_ok=True)
+            with open(log_dir / "metrics.log", "a") as log:
+                log.write(f"[{datetime.now().isoformat()}] TTU: {ttu_seconds}s for task {active_task.get('id')}\n")
+
+        except Exception:
+            # Passive tracking should never crash the main flow
+            pass

onecoder/models/delegation.py

@@ -0,0 +1,46 @@
+from typing import Optional, Dict, Any
+from datetime import datetime
+from pydantic import BaseModel, Field
+import uuid
+
+class DelegationSession(BaseModel):
+    """
+    Represents a delegated task session.
+    """
+    id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    task_id: str
+    backend: str  # local-tui, jules, browser, etc.
+    status: str = "pending"  # pending, running, completed, failed
+    
+    # Context
+    worktree_path: Optional[str] = None
+    tmux_session: Optional[str] = None
+    command: Optional[str] = None
+    parent_branch: Optional[str] = None
+    sprint_id: Optional[str] = None
+    spec_id: Optional[str] = None
+    external_id: Optional[str] = None # For remote sessions (e.g. Jules ID)
+    
+    # Results
+    result: Optional[str] = None
+    error: Optional[str] = None
+    
+    # Metadata
+    created_at: datetime = Field(default_factory=datetime.now)
+    updated_at: datetime = Field(default_factory=datetime.now)
+
+    def mark_running(self, tmux_session: Optional[str] = None, worktree_path: Optional[str] = None):
+        self.status = "running"
+        self.tmux_session = tmux_session
+        self.worktree_path = worktree_path
+        self.updated_at = datetime.now()
+
+    def mark_completed(self, result: str):
+        self.status = "completed"
+        self.result = result
+        self.updated_at = datetime.now()
+
+    def mark_failed(self, error: str):
+        self.status = "failed"
+        self.error = error
+        self.updated_at = datetime.now()

onecoder/onboarding.py

@@ -0,0 +1,264 @@
+import os
+import click
+import json
+import asyncio
+from pathlib import Path
+from typing import Dict, Any, Optional
+from .tools.kit_tools import kit_index_tool, kit_file_tree_tool, kit_symbols_tool
+from .api_client import get_api_client
+from .config_manager import config_manager
+from .sync import sync_project_context, ProjectConfig
+
+async def _ensure_project_setup(client, directory: str) -> Optional[str]:
+    """
+    Ensures a workspace is associated and a project is created on the server.
+    Returns the project_id.
+    """
+    click.secho("\n[Project Setup] Verifying workspace and project association...", fg="cyan", bold=True)
+    
+    # Load local config
+    p_config = ProjectConfig(Path(directory))
+    config_data = p_config.load()
+    workspace_id = config_data.get("workspace_id")
+    project_id = config_data.get("project_id")
+
+    # 1. Ensure Workspace
+    if not workspace_id:
+        workspaces = await client.get_workspaces()
+        if workspaces:
+            click.echo("Found available workspaces:")
+            for idx, ws in enumerate(workspaces, 1):
+                click.echo(f"  {idx}. {ws['name']} ({ws['id']})")
+            
+            choice = click.prompt("Select a workspace number or type 'new' to create one", default="1")
+            if choice.lower() == "new":
+                ws_name = click.prompt("Enter new workspace name")
+                ws_result = await client.create_workspace(ws_name)
+                workspace_id = ws_result["id"]
+            else:
+                workspace_id = workspaces[int(choice)-1]["id"]
+        else:
+            click.echo("No workspaces found.")
+            ws_name = click.prompt("Create default workspace name", default="Personal")
+            ws_result = await client.create_workspace(ws_name)
+            workspace_id = ws_result["id"]
+        
+        # Save workspace ID
+        config_data["workspace_id"] = workspace_id
+        p_config.save(config_data)
+        click.secho(f"✓ Associated with workspace ID: {workspace_id}", fg="green")
+    else:
+        click.echo(f"✓ Using existing workspace ID: {workspace_id}")
+
+    # 2. Ensure Project
+    if not project_id:
+        # Check if project exists on server (by name or some other linking? For now just create)
+        # We assume if we don't have an ID, we haven't linked it.
+        # Use directory name as default project name
+        default_name = os.path.basename(os.path.abspath(directory))
+        proj_name = click.prompt("Enter project name on server", default=default_name)
+        
+        try:
+            # We try to create. If name collision logic isn't robust in API, this might error.
+            # Assuming API handles duplicates or we just handle error.
+            # Ideally we check list first, but create is fine.
+            new_project = await client.create_project(proj_name, workspace_id)
+            project_id = new_project["id"]
+            
+            config_data["project_id"] = project_id
+            p_config.save(config_data)
+            click.secho(f"✓ Created/Linked project ID: {project_id}", fg="green")
+            
+        except Exception as e:
+            click.secho(f"Warning: Failed to create project: {e}", fg="yellow")
+            # Fallback: maybe list projects and let user select? 
+            # For now, proceed without ID (some features might be limited)
+            return None
+    else:
+        click.echo(f"✓ Using existing project ID: {project_id}")
+
+    return project_id
+
+def onboard_project(directory: str = "."):
+    """
+    Onboards a project into the OneCoder platform.
+    """
+    directory = os.path.abspath(directory)
+    click.secho(f"🚀 Kickstarting OneCoder Onboarding for: {directory}", fg="cyan", bold=True)
+    
+    # Check for existing .sprint directory
+    sprint_dir = os.path.join(directory, ".sprint")
+    if not os.path.exists(sprint_dir):
+        click.echo("No .sprint directory found. Setting up 'Sprint 000'...")
+        os.makedirs(sprint_dir, exist_ok=True)
+        with open(os.path.join(sprint_dir, "README.md"), "w") as f:
+            f.write("# Sprint 000: Initialization\n\nInitial onboarding and project setup.")
+
+    # --- Sync Preferences ---
+    token = config_manager.get_token()
+    preferences = {
+        "artifacts": {
+            "auto_capture": True,
+            "destination": "sprint_context",
+            "types": ["assessment", "implementation_plan", "task", "walkthrough"]
+        },
+        "sprint": {
+            "auto_close_validation": True,
+            "require_walkthrough": True
+        }
+    }
+
+    if token:
+        click.echo("Syncing preferences from API...")
+        try:
+            client = get_api_client(token)
+            api_prefs = asyncio.run(client.get_preferences())
+            preferences.update(api_prefs)
+            click.echo("✓ Preferences synced successfully.")
+        except Exception as e:
+            click.secho(f"! Failed to sync preferences: {e}. Aborting.", fg="red")
+            return
+    else:
+        click.secho("Error: No authentication token found. Please run 'onecoder login'.", fg="red")
+        return
+
+    # --- Check for Existing Agent/Config Docs (Refinement) ---
+    agent_docs = {
+        "AGENTS.md": Path(directory) / "AGENTS.md",
+        "CLAUDE.md": Path(directory) / "CLAUDE.md",
+        "GEMINI.md": Path(directory) / "GEMINI.md",
+        ".cursorrules": Path(directory) / ".cursorrules"
+    }
+    readme_path = Path(directory) / "README.md"
+    
+    detected_agent_docs = {name: p for name, p in agent_docs.items() if p.exists()}
+    
+    scan_data = {}
+    skip_deep_scan = False
+
+    if detected_agent_docs:
+        click.secho("🤖 Agent configuration detected. Optimizing onboarding...", fg="green")
+        combined_context = ""
+        if readme_path.exists():
+            combined_context += f"--- README.md ---\n{readme_path.read_text()}\n\n"
+        
+        for name, p in detected_agent_docs.items():
+            combined_context += f"--- {name} ---\n{p.read_text()}\n\n"
+        
+        scan_data["focused_context"] = combined_context
+        skip_deep_scan = True
+    
+    # --- Check for Existing Artifacts (Optimization - Legacy Path) ---
+    spec_path = Path(directory) / "SPECIFICATION.md"
+    gov_path = Path(directory) / "governance.yaml"
+    
+    if spec_path.exists() and gov_path.exists():
+        if click.confirm("\n📋 Existing project artifacts/configuration detected. Skip analysis and sync to remote?", default=True):
+            click.echo("Skipping analysis...")
+            try:
+                # Ensure project setup
+                asyncio.run(_ensure_project_setup(client, directory))
+                # Invoke Sync
+                click.echo("Syncing project context...")
+                asyncio.run(sync_project_context())
+                return
+            except Exception as e:
+                click.secho(f"Error during optimized sync: {e}", fg="red")
+                return
+
+    # --- Phase 1: Deep Codebase Scan (Skipped if focused context available) ---
+    if not skip_deep_scan:
+        click.secho("\n[Phase 1] Running deep codebase scan...", fg="yellow")
+        
+        index_json = kit_index_tool(directory)
+        file_tree = kit_file_tree_tool(directory)
+        symbols = kit_symbols_tool(directory)
+        
+        scan_data.update({
+            "index_summary": index_json[:2000] + "..." if len(index_json) > 2000 else index_json,
+            "file_tree": file_tree,
+            "symbols_summary": symbols[:2000] + "..." if len(symbols) > 2000 else symbols
+        })
+    else:
+        click.secho("\n[Phase 1] Skipping deep codebase scan (Agent Docs found).", fg="yellow")
+
+    # --- Phase 2: Agent Insight Generation (Server-Side) ---
+    click.secho("[Phase 2] Analyzing codebase insights (Server-Side)...", fg="yellow")
+    
+    try:
+        results = asyncio.run(client.analyze_project(scan_data))
+        insights = results.get("insights", {})
+        click.echo(f"Insights generated. Architecture detected: {insights.get('architecture', 'Unknown')}")
+    except Exception as e:
+        click.secho(f"❌ Analysis failed: {e}", fg="red")
+        return
+
+    # --- Phase 2.5: Workspace & Project Setup ---
+    # Used same helper as optimization path
+    try:
+        asyncio.run(_ensure_project_setup(client, directory))
+    except Exception as e:
+         click.secho(f"! Project setup failed: {e}", fg="yellow")
+         # Continue locally? Or abort? 
+         # We continue to allow local artifact generation even if sync setup invalid.
+
+    # --- Phase 3: Clarification Interview ---
+    click.secho("\n[Phase 3] Clarification Interview", fg="magenta", bold=True)
+    click.echo("The agent has some clarifying questions based on the scan:")
+    
+    user_feedback = _conduct_interview(insights.get("clarifications", []))
+
+    # --- Phase 4: Artifact Finalization (Server-Side) ---
+    click.secho("\n[Phase 4] Finalizing Artifacts...", fg="yellow")
+    
+    try:
+        feedback_str = json.dumps(user_feedback)
+        final_results = asyncio.run(client.analyze_project(scan_data, user_feedback=feedback_str))
+        final_specs = final_results.get("artifacts", {})
+        
+        if not final_specs:
+             click.secho("⚠️ Server returned no artifacts. Using fallbacks.", fg="yellow")
+             final_specs = {}
+
+        _write_project_artifacts(directory, final_specs)
+        update_agents_md(directory, insights.get("summary", "Project initialized."))
+        
+        click.secho("\n✅ Onboarding complete!", fg="green", bold=True)
+        click.echo("Review SPECIFICATION.md and governance.yaml.")
+        
+        # Auto-Sync after successful onboarding
+        if click.confirm("Sync generated artifacts to remote?", default=True):
+             asyncio.run(sync_project_context())
+        
+    except Exception as e:
+        click.secho(f"❌ Artifact generation failed: {e}", fg="red")
+
+def _conduct_interview(questions: list) -> Dict[str, str]:
+    """Interactive CLI interview."""
+    responses = {}
+    for i, q in enumerate(questions, 1):
+        click.echo(f"\nQ{i}: {q}")
+        response = click.prompt("Answer", type=str)
+        responses[q] = response
+    return responses
+
+def _write_project_artifacts(directory: str, artifacts: Dict):
+    """Writes the final artifacts to disk."""
+    spec_path = os.path.join(directory, "SPECIFICATION.md")
+    gov_path = os.path.join(directory, "governance.yaml")
+    
+    with open(spec_path, "w") as f:
+        f.write(artifacts.get("specification_md", ""))
+    click.echo(f"Created {spec_path}")
+    
+    with open(gov_path, "w") as f:
+        f.write(artifacts.get("governance_yaml", ""))
+    click.echo(f"Created {gov_path}")
+
+def update_agents_md(directory: str, summary: str):
+    """Updates AGENTS.md."""
+    agents_path = os.path.join(directory, "AGENTS.md")
+    content = f"# Agent Guidelines\n\n## Summary\n{summary}\n\n## Rules\n1. Follow specs.\n2. Adhere to governance.yaml."
+    with open(agents_path, "w") as f:
+        f.write(content)
+    click.echo(f"Updated {agents_path}")