onecoder 0.0.2__py3-none-any.whl

onecoder/config_manager.py

@@ -0,0 +1,87 @@
+import os
+import json
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+class ConfigManager:
+    def __init__(self):
+        self.config_dir = Path.home() / ".onecoder"
+        self.config_file = self.config_dir / "config.json"
+        self._ensure_config_dir()
+
+    def _ensure_config_dir(self):
+        if not self.config_dir.exists():
+            self.config_dir.mkdir(parents=True, exist_ok=True)
+            # Set restrictive permissions
+            os.chmod(self.config_dir, 0o700)
+
+    def load_config(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:
+            print(f"Error loading config: {e}")
+            return {}
+
+    def save_config(self, config: Dict[str, Any]):
+        try:
+            with open(self.config_file, "w") as f:
+                json.dump(config, f, indent=4)
+            # Set restrictive permissions
+            os.chmod(self.config_file, 0o600)
+        except Exception as e:
+            print(f"Error saving config: {e}")
+
+    def get_token(self) -> Optional[str]:
+        config = self.load_config()
+        return config.get("api_token")
+
+    def set_token(self, token: str):
+        config = self.load_config()
+        config["api_token"] = token
+        self.save_config(config)
+
+    def clear_token(self):
+        config = self.load_config()
+        if "api_token" in config:
+            del config["api_token"]
+            self.save_config(config)
+
+    def get_user(self) -> Optional[Dict[str, Any]]:
+        config = self.load_config()
+        return config.get("user")
+
+    def set_user(self, user: Dict[str, Any]):
+        config = self.load_config()
+        config["user"] = user
+        self.save_config(config)
+
+    def get_model_config(self) -> Optional[Dict[str, Any]]:
+        config = self.load_config()
+        return config.get("model")
+
+    def set_model_config(self, model_config: Dict[str, Any]):
+        config = self.load_config()
+        config["model"] = model_config
+        self.save_config(config)
+
+    def get_github_client_id(self) -> str:
+        """Get the GitHub Client ID from config or environment variable."""
+        # Environment variable takes highest precedence
+        env_id = os.getenv("GITHUB_CLIENT_ID")
+        if env_id:
+            return env_id
+            
+        config = self.load_config()
+        # Return from config or the production default
+        return config.get("github_client_id", "Iv23limfvipYiMLhjhq1")
+
+    def set_github_client_id(self, client_id: str):
+        """Set the GitHub Client ID in the config file."""
+        config = self.load_config()
+        config["github_client_id"] = client_id
+        self.save_config(config)
+
+config_manager = ConfigManager()

onecoder/constants.py

@@ -0,0 +1,9 @@
+import os
+from .config_manager import config_manager
+
+# Default to Production API URL
+ONECODER_API_URL = os.getenv("ONECODER_API_URL", "https://api.onecoder.dev")
+
+# Production GitHub App Client ID
+# This is safe to share as it is a public identifier, not a secret.
+GITHUB_CLIENT_ID = config_manager.get_github_client_id()

onecoder/diagnostics/__init__.py

@@ -0,0 +1,2 @@
+"""Diagnostics utilities for doctor/trace commands."""
+

onecoder/diagnostics/env_scan.py

@@ -0,0 +1,207 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Iterable, List, Optional
+
+from onecoder.metrics import find_repo_root
+
+ENV_FILENAMES = [".env", ".env.local", ".dev.vars"]
+SHARED_SECRETS = ["GITHUB_CLIENT_ID", "JWT_SECRET", "GEMINI_API_KEY"]
+COMPONENT_PATHS: Dict[str, List[Path]] = {
+    "onecoder-api": [Path("onecoder-api")],
+    "oneadmin": [Path("oneadmin/worker"), Path("oneadmin/client")],
+    "oneui": [Path("oneui"), Path("components/devcenter")],
+    "onewebsite": [Path("components/onewebsite")],
+    "sprint-cli": [Path("sprint-cli")],
+    "onecoder-cli": [Path("onecoder-cli")],
+}
+
+
+@dataclass
+class EnvFinding:
+    component: str
+    check: str
+    status: str
+    message: str
+    file: Optional[Path] = None
+    tt_id: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, str]:
+        return {
+            "component": self.component,
+            "check": self.check,
+            "status": self.status,
+            "message": self.message,
+            "file": str(self.file) if self.file else None,
+            "tt_id": self.tt_id,
+        }
+
+
+class EnvDoctor:
+    def __init__(self, repo_root: Optional[Path] = None) -> None:
+        self.repo_root = repo_root or find_repo_root()
+
+    def run(self) -> List[EnvFinding]:
+        findings: List[EnvFinding] = []
+        component_envs: Dict[str, Dict[str, str]] = {}
+
+        for name, rel_paths in COMPONENT_PATHS.items():
+            env_files: List[Path] = []
+            for rel_path in rel_paths:
+                env_files.extend(self._discover_env_files(self.repo_root / rel_path))
+
+            if not env_files:
+                findings.append(
+                    EnvFinding(
+                        component=name,
+                        check="env_files",
+                        status="warn",
+                        message=f"No env files found (searched: {', '.join(str(self.repo_root / p) for p in rel_paths)})",
+                    )
+                )
+                continue
+
+            merged_env: Dict[str, str] = {}
+            for env_file in env_files:
+                try:
+                    merged_env.update(self._load_env_file(env_file))
+                    findings.append(
+                        EnvFinding(
+                            component=name,
+                            check="env_files",
+                            status="pass",
+                            message=f"Found {env_file.name}",
+                            file=env_file,
+                        )
+                    )
+                except ValueError as exc:
+                    findings.append(
+                        EnvFinding(
+                            component=name,
+                            check="env_parse",
+                            status="fail",
+                            message=f"{env_file}: {exc}",
+                            file=env_file,
+                        )
+                    )
+            component_envs[name] = merged_env
+
+            for key in SHARED_SECRETS:
+                if key not in merged_env:
+                    findings.append(
+                        EnvFinding(
+                            component=name,
+                            check=key,
+                            status="warn",
+                            message=f"{key} missing in {', '.join(f.name for f in env_files)}",
+                        )
+                    )
+
+        findings.extend(self._compare_shared_secrets(component_envs))
+        return findings
+
+    def write_artifact(self, findings: List[EnvFinding]) -> Path:
+        debug_dir = self.repo_root / ".onecoder" / "debug"
+        debug_dir.mkdir(parents=True, exist_ok=True)
+        artifact_path = debug_dir / "doctor-env.json"
+        artifact_path.write_text(json.dumps([f.to_dict() for f in findings], indent=2))
+        return artifact_path
+
+    @staticmethod
+    def to_json(findings: List[EnvFinding]) -> str:
+        return json.dumps([f.to_dict() for f in findings], indent=2)
+
+    @staticmethod
+    def has_failures(findings: List[EnvFinding]) -> bool:
+        return any(f.status == "fail" for f in findings)
+
+    @staticmethod
+    def _discover_env_files(component_root: Path) -> List[Path]:
+        files: List[Path] = []
+        if not component_root.exists():
+            return files
+        for filename in ENV_FILENAMES:
+            for candidate in component_root.rglob(filename):
+                if "node_modules" in candidate.parts or ".git" in candidate.parts:
+                    continue
+                files.append(candidate)
+        return list(dict.fromkeys(files))
+
+    @staticmethod
+    def _load_env_file(path: Path) -> Dict[str, str]:
+        values: Dict[str, str] = {}
+        current_key: Optional[str] = None
+        multiline_buffer: List[str] = []
+        with path.open() as handle:
+            for line in handle:
+                raw_line = line.rstrip("\n")
+                stripped = raw_line.strip()
+
+                if current_key:
+                    closing = stripped.endswith('"')
+                    content = raw_line.rstrip()[:-1] if closing else raw_line
+                    multiline_buffer.append(content)
+                    if closing:
+                        values[current_key] = "\n".join(multiline_buffer)
+                        current_key = None
+                        multiline_buffer = []
+                    continue
+
+                if not stripped or stripped.startswith("#"):
+                    continue
+                if "=" not in stripped:
+                    raise ValueError("Invalid line (missing '=')")
+                key, value = stripped.split("=", 1)
+                clean_value = value.strip()
+                values[key.strip()] = clean_value.strip('"').strip("'")
+
+                if clean_value.startswith('"') and not clean_value.endswith('"'):
+                    current_key = key.strip()
+                    multiline_buffer.append(clean_value.lstrip('"'))
+        if current_key:
+            raise ValueError(f"Unterminated multiline value for {current_key}")
+        return values
+
+    def _compare_shared_secrets(
+        self, component_envs: Dict[str, Dict[str, str]]
+    ) -> List[EnvFinding]:
+        findings: List[EnvFinding] = []
+        for secret in SHARED_SECRETS:
+            values: Dict[str, str] = {
+                component: envs[secret]
+                for component, envs in component_envs.items()
+                if secret in envs
+            }
+            if len(values) <= 1:
+                continue
+            unique_values = set(values.values())
+            if len(unique_values) == 1:
+                continue
+
+            tt_id = "TT-032" if self._is_font_trap(unique_values) and secret == "GITHUB_CLIENT_ID" else None
+            message = "; ".join(
+                f"{component}={display_value}"
+                for component, display_value in values.items()
+            )
+            findings.append(
+                EnvFinding(
+                    component="shared",
+                    check=secret,
+                    status="fail",
+                    message=f"Mismatched {secret}: {message}",
+                    tt_id=tt_id,
+                )
+            )
+        return findings
+
+    @staticmethod
+    def _is_font_trap(values: Iterable[str]) -> bool:
+        normalized = {_font_normalize(value) for value in values}
+        return len(normalized) < len(set(values))
+
+
+def _font_normalize(value: str) -> str:
+    """Normalize ambiguous glyphs so I/l mix-ups collapse to the same value."""
+    return value.replace("I", "1").replace("l", "1")

onecoder/discovery.py

@@ -0,0 +1,101 @@
+import importlib
+import pkgutil
+import inspect
+import logging
+import os
+from pathlib import Path
+from typing import List, Any
+from .tools.interface import BaseTool
+from .tools.registry import registry
+
+logger = logging.getLogger(__name__)
+
+class DiscoveryAgent:
+    """
+    DiscoveryAgent scans directories and modules to dynamically register tools.
+    """
+
+    def __init__(self, tools_package: str = "onecoder.tools"):
+        self.tools_package = tools_package
+
+    def discover_and_register(self):
+        """
+        Scans the tools package and register functions.
+        Also scans paths in ONECODER_TOOLS_PATH environment variable.
+        """
+        logger.info(f"Starting tool discovery in {self.tools_package}")
+        
+        # 1. Discover internal tools
+        try:
+            package = importlib.import_module(self.tools_package)
+            for loader, module_name, is_pkg in pkgutil.walk_packages(package.__path__, package.__name__ + "."):
+                if is_pkg:
+                    continue
+                try:
+                    module = importlib.import_module(module_name)
+                    self._scan_module(module)
+                except Exception as e:
+                    logger.error(f"Error scanning module {module_name}: {e}")
+        except ImportError as e:
+            logger.error(f"Could not import tools package {self.tools_package}: {e}")
+
+        # 2. Discover external tools from ONECODER_TOOLS_PATH
+        tools_path = os.environ.get("ONECODER_TOOLS_PATH")
+        if tools_path:
+            for path in tools_path.split(os.pathsep):
+                if not path:
+                    continue
+                p = Path(path).absolute()
+                if not p.exists():
+                    logger.warning(f"External tools path does not exist: {p}")
+                    continue
+                
+                logger.info(f"Scanning external tools path: {p}")
+                self._scan_directory(p)
+
+    def _scan_directory(self, directory: Path):
+        """Scans a directory for .py files and imports them."""
+        import sys
+        if str(directory) not in sys.path:
+            sys.path.insert(0, str(directory))
+            
+        for file in directory.glob("*.py"):
+            if file.name.startswith("__"):
+                continue
+            
+            module_name = file.stem
+            try:
+                # Use a unique namespace for external tools if needed, 
+                # but simple import works for discovery
+                module = importlib.import_module(module_name)
+                self._scan_module(module)
+            except Exception as e:
+                logger.error(f"Error loading external tool module {module_name}: {e}")
+
+    def _scan_module(self, module: Any):
+        """Scans a module for functions ending in '_tool'."""
+        for name, obj in inspect.getmembers(module):
+            if inspect.isfunction(obj) and (name.endswith("_tool") or hasattr(obj, "_is_agentic_tool")):
+                # Avoid registering if already exists
+                tool_name = getattr(obj, "_tool_name", name.replace("_tool", ""))
+                if registry.get_tool(tool_name):
+                    continue
+                
+                # Extract metadata from docstring
+                doc = inspect.getdoc(obj) or "No description provided."
+                
+                logger.debug(f"Discovered tool: {tool_name} in {module.__name__}")
+                
+                tool = BaseTool(
+                    name=tool_name,
+                    description=doc,
+                    func=obj
+                )
+                registry.register(tool)
+
+if __name__ == "__main__":
+    # Test discovery
+    logging.basicConfig(level=logging.DEBUG)
+    disco = DiscoveryAgent("onecoder.tools")
+    disco.discover_and_register()
+    print(f"Registered tools: {[t.name for t in registry.list_tools()]}")

onecoder/distillation.py

@@ -0,0 +1,236 @@
+import os
+import json
+import re
+import datetime
+from typing import Any, List, Dict
+from pathlib import Path
+
+class SessionCapture:
+    """
+    Captures session events (text, tool calls) for later distillation.
+    """
+    def __init__(self, directory: str = "."):
+        self.directory = directory
+        self.logs_dir = os.path.join(directory, ".sprint", "logs")
+        
+        self.current_session_id = None
+        self.events: List[Dict[str, Any]] = []
+
+    def start_session(self, session_id: str):
+        os.makedirs(self.logs_dir, exist_ok=True)
+        self.current_session_id = session_id
+        self.events = []
+
+    def log_event(self, event_data: Dict[str, Any]):
+        """Logs an event within the current session."""
+        event_entry = {
+            "timestamp": datetime.datetime.now().isoformat(),
+            "data": event_data
+        }
+        self.events.append(event_entry)
+
+    def save_session(self):
+        """Saves the current session logs to the .sprint/logs directory."""
+        if not self.current_session_id:
+            return
+            
+        filename = f"session_{self.current_session_id}_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        filepath = os.path.join(self.logs_dir, filename)
+        
+        with open(filepath, "w") as f:
+            json.dump({
+                "session_id": self.current_session_id,
+                "events": self.events
+            }, f, indent=2)
+        
+        print(f"Session logs saved to {filepath}")
+        
+    def distill_patterns(self) -> str:
+        """
+        [v0.1.0 Mechanical] Implementation for pattern capture.
+        In the future, this will use an LLM to extract reusable skills.
+        """
+        patterns = []
+        for event in self.events:
+            data = event.get("data", {})
+            if "tool_call" in data:
+                patterns.append(data["tool_call"])
+        
+        return f"Captured {len(patterns)} tool call patterns."
+
+# Singleton instance for the API to use
+capture_engine = SessionCapture()
+
+class SprintDistiller:
+    """
+    Distills learnings from a sprint and updates project awareness.
+    """
+    def __init__(self, project_root: str = "."):
+        self.project_root = self._find_repo_root(Path(project_root).absolute())
+        self.antigravity_md = self.project_root / "ANTIGRAVITY.md"
+
+    def _find_repo_root(self, start_path: Path) -> Path:
+        """Traverses upwards to find the repository root."""
+        curr = start_path
+        while curr != curr.parent:
+            if (curr / ".sprint").exists() or (curr / ".git").exists():
+                return curr
+            curr = curr.parent
+        return start_path # Fallback to start_path
+
+    def distill_sprint(self, sprint_id: str) -> Dict[str, Any]:
+        """
+        Analyzes a finished sprint and extracts learnings.
+        """
+        sprint_dir = self.project_root / ".sprint" / sprint_id
+        retro_path = sprint_dir / "RETRO.md"
+        
+        if not retro_path.exists():
+            return {"error": f"RETRO.md not found in {sprint_id}"}
+
+        content = retro_path.read_text()
+        
+        # Use LLM with mechanical fallback
+        try:
+            learnings = self._extract_learnings_llm(content)
+        except Exception as e:
+            print(f"Warning: LLM distillation failed ({e}). Falling back to mechanical extraction.")
+            learnings = self._extract_learnings_mechanical(content)
+        
+        if learnings:
+            self._update_awareness(sprint_id, learnings)
+            
+        return {
+            "sprint_id": sprint_id,
+            "learnings_extracted": len(learnings),
+            "updated": self.antigravity_md.name if learnings else None,
+            "method": "llm" if hasattr(self, "_llm_used") and self._llm_used else "mechanical"
+        }
+
+    def _extract_learnings_llm(self, content: str) -> List[str]:
+        """Uses LLM to semantically extract learnings from retro content."""
+        import litellm
+        import os
+        
+        api_key = os.getenv("OPENROUTER_API_KEY")
+        if not api_key:
+            raise ValueError("OPENROUTER_API_KEY not found")
+
+        model = "openrouter/xiaomi/mimo-v2-flash:free"
+        
+        prompt = f"""
+        Analyze the following Sprint Retro (RETRO.md) content and extract key engineering/architectural learnings.
+        Focus on reusable patterns, failure modes to avoid, and optimized workflows.
+        
+        Format your response EXACTLY as a JSON list of strings. Each string should be a concise, action-oriented learning.
+        DO NOT include any other text in your response.
+        
+        RETRO CONTENT:
+        {content}
+        
+        Example Output: ["Always use relative paths in sprint-cli", "Verify JWT presence before syncing secrets"]
+        """
+        
+        response = litellm.completion(
+            model=model,
+            messages=[{"role": "user", "content": prompt}],
+            api_key=api_key,
+            base_url="https://openrouter.ai/api/v1",
+            response_format={ "type": "json_object" } # Try to enforce JSON
+        )
+        
+        text = response.choices[0].message.content
+        try:
+            # Handle if LLM returned a JSON object with a 'learnings' key instead of a list
+            data = json.loads(text)
+            if isinstance(data, list):
+                learnings = data
+            elif isinstance(data, dict):
+                # Look for common keys
+                learnings = data.get("learnings", data.get("items", list(data.values())[0]))
+            else:
+                learnings = []
+        except:
+             # Fallback: extract anything that looks like a list
+             match = re.search(r'\[.*\]', text, re.DOTALL)
+             if match:
+                 learnings = json.loads(match.group(0))
+             else:
+                 raise ValueError("Could not parse LLM response as JSON list")
+
+        self._llm_used = True
+        return learnings
+
+    def _extract_learnings_mechanical(self, content: str) -> List[str]:
+        """
+        Extracts bullet points and numbered items from 'Learnings', 'To Improve', or 'Went Well' sections.
+        This is a simple mechanical extraction fallback.
+        """
+        learnings = []
+        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"]):
+                capture = True
+                continue
+            # Stop if we hit another header or end of section
+            elif line_stripped.startswith("## "):
+                capture = False
+            
+            if capture:
+                # Match bullet points: - text
+                if line_stripped.startswith("- "):
+                    learning = line_stripped[2:].strip()
+                    if learning:
+                        learnings.append(learning)
+                # Match numbered lists: 1. text, 2. text, etc.
+                elif re.match(r'^\d+\.\s+', line_stripped):
+                    learning = re.sub(r'^\d+\.\s+', '', line_stripped).strip()
+                    if learning:
+                        learnings.append(learning)
+        
+        self._llm_used = False
+        return learnings
+
+    def _update_awareness(self, sprint_id: str, learnings: List[str]):
+        """
+        Injects learnings into ANTIGRAVITY.md.
+        """
+        if not self.antigravity_md.exists():
+            return
+
+        lines = self.antigravity_md.read_text().split("\n")
+        new_lines = []
+        in_learned_section = False
+        injected = False
+        
+        marker = "### 🛡️ Distilled from Sprints"
+        
+        # Check if the marker already exists
+        content = self.antigravity_md.read_text()
+        if marker not in content:
+            # Inject it after ## 🛠️ Environmental Awareness (Learned)
+            for line in lines:
+                new_lines.append(line)
+                if "## 🛠️ Environmental Awareness (Learned)" in line:
+                    new_lines.append("")
+                    new_lines.append(marker)
+                    for l in learnings:
+                        new_lines.append(f"- {l} (distilled from {sprint_id})")
+                    new_lines.append("")
+                    injected = True
+        else:
+            # Append to the existing section, but avoid duplicates
+            content = self.antigravity_md.read_text()
+            for line in lines:
+                new_lines.append(line)
+                if marker in line:
+                    for l in learnings:
+                        entry = f"- {l} (distilled from {sprint_id})"
+                        if entry not in content:
+                            new_lines.append(entry)
+                    injected = True
+
+        if injected:
+            self.antigravity_md.write_text("\n".join(new_lines))

onecoder/evaluation/__init__.py

@@ -0,0 +1 @@
+from .ttu import TTUEvaluator, TTUResult