onecoder 0.0.2__py3-none-any.whl

onecoder/blackboard.py

@@ -0,0 +1,102 @@
+import sqlite3
+import json
+import logging
+import datetime
+from pathlib import Path
+from typing import Any, Optional, Dict, List
+
+logger = logging.getLogger(__name__)
+
+class BlackboardMemory:
+    """
+    A SQLite-backed shared memory (Blackboard) for agents.
+    Allows persistent key-value storage with scoping.
+    """
+
+    def __init__(self, db_path: str = ".adk/blackboard.db"):
+        self.db_path = Path(db_path)
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        self._init_db()
+
+    def _init_db(self):
+        with sqlite3.connect(self.db_path) as conn:
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS blackboard (
+                    scope TEXT,
+                    namespace TEXT,
+                    key TEXT,
+                    value TEXT,
+                    updated_at DATETIME,
+                    PRIMARY KEY (scope, namespace, key)
+                )
+            """)
+            conn.commit()
+
+    def set(self, key: str, value: Any, scope: str = "global", namespace: str = "shared"):
+        """Sets a value in the blackboard."""
+        val_str = json.dumps(value)
+        now = datetime.datetime.now().isoformat()
+        with sqlite3.connect(self.db_path) as conn:
+            conn.execute("""
+                INSERT OR REPLACE INTO blackboard (scope, namespace, key, value, updated_at)
+                VALUES (?, ?, ?, ?, ?)
+            """, (scope, namespace, key, val_str, now))
+            conn.commit()
+
+    def get(self, key: str, scope: str = "global", namespace: str = "shared") -> Any:
+        """Gets a value from the blackboard."""
+        with sqlite3.connect(self.db_path) as conn:
+            row = conn.execute("""
+                SELECT value FROM blackboard WHERE scope = ? AND namespace = ? AND key = ?
+            """, (scope, namespace, key)).fetchone()
+            if row:
+                return json.loads(row[0])
+            return None
+
+    def delete(self, key: str, scope: str = "global", namespace: str = "shared"):
+        """Deletes a key from the blackboard."""
+        with sqlite3.connect(self.db_path) as conn:
+            conn.execute("""
+                DELETE FROM blackboard WHERE scope = ? AND namespace = ? AND key = ?
+            """, (scope, namespace, key))
+            conn.commit()
+
+    def list_keys(self, scope: Optional[str] = None, namespace: Optional[str] = None) -> List[Dict[str, str]]:
+        """Lists keys in the blackboard, optionally filtered by scope/namespace."""
+        query = "SELECT scope, namespace, key, updated_at FROM blackboard"
+        params = []
+        if scope and namespace:
+            query += " WHERE scope = ? AND namespace = ?"
+            params = [scope, namespace]
+        elif scope:
+            query += " WHERE scope = ?"
+            params = [scope]
+        elif namespace:
+            query += " WHERE namespace = ?"
+            params = [namespace]
+
+        with sqlite3.connect(self.db_path) as conn:
+            rows = conn.execute(query, params).fetchall()
+            return [
+                {"scope": r[0], "namespace": r[1], "key": r[2], "updated_at": r[3]}
+                for r in rows
+            ]
+
+    def get_all(self, scope: str = "global", namespace: str = "shared") -> Dict[str, Any]:
+        """Gets all key-value pairs for a specific scope and namespace."""
+        with sqlite3.connect(self.db_path) as conn:
+            rows = conn.execute("""
+                SELECT key, value FROM blackboard WHERE scope = ? AND namespace = ?
+            """, (scope, namespace)).fetchall()
+            return {r[0]: json.loads(r[1]) for r in rows}
+
+if __name__ == "__main__":
+    # Quick test
+    bb = BlackboardMemory("test_blackboard.db")
+    bb.set("status", "scanning", scope="sprint-025")
+    print(f"Status: {bb.get('status', scope='sprint-025')}")
+    print(f"All keys: {bb.list_keys()}")
+    bb.delete("status", scope="sprint-025")
+    import os
+    if os.path.exists("test_blackboard.db"):
+        os.remove("test_blackboard.db")

onecoder/cli.py

@@ -0,0 +1,108 @@
+import click
+import sys
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+
+# Load environment variables
+# env_path = Path(__file__).resolve().parent.parent / ".env"
+# load_dotenv(env_path)
+
+from .commands.auth import login, logout, whoami
+from .commands.server import serve, web, tui
+from .commands.issue import issue
+from .commands.logs import logs
+from .commands.project import (
+    init, status, knowledge, distill, sync, alignment, sprint_suggest
+)
+from .commands.delegate import (
+    delegate, delegate_list, delegate_status, delegate_validate, delegate_finish, jules_sessions
+)
+from .commands.doctor import doctor
+from .commands.ci import ci
+from .review import CodeReviewer
+
+from .logger import configure_logging
+
+@click.group()
+@click.version_option(version="0.0.2", prog_name="onecoder")
+@click.option("--verbose", is_flag=True, help="Enable verbose logging.")
+def cli(verbose):
+    """OneCoder: Unified Agent Architecture."""
+    configure_logging(verbose=verbose)
+
+def main():
+    """Main entry point with telemetry wrapper."""
+    try:
+        cli()
+    except Exception as e:
+        # Don't capture Click-internal exit exceptions as failures
+        if isinstance(e, (click.exceptions.Exit, click.exceptions.Abort, click.exceptions.ClickException)):
+            raise e
+            
+        from ai_sprint.telemetry import FailureModeCapture
+        capture = FailureModeCapture()
+        capture.capture(e, context={"command_args": sys.argv[1:]})
+        raise e
+
+# Register Commands
+def is_internal_features_enabled():
+    """Check if internal features should be enabled."""
+    return os.getenv("ONECODER_INTERNAL", "false").lower() == "true" or \
+           os.getenv("ONE_CODER_DEV", "false").lower() == "true"
+
+# Register Commands
+cli.add_command(login)
+cli.add_command(logout)
+cli.add_command(whoami)
+
+cli.add_command(serve)
+cli.add_command(web)
+cli.add_command(tui)
+
+cli.add_command(issue)
+cli.add_command(logs)
+cli.add_command(doctor)
+
+cli.add_command(init)
+cli.add_command(status)
+cli.add_command(knowledge)
+cli.add_command(distill)
+cli.add_command(sync)
+cli.add_command(alignment)
+cli.add_command(ci)
+
+if is_internal_features_enabled():
+    cli.add_command(delegate)
+    cli.add_command(delegate_list)
+    cli.add_command(delegate_status)
+    cli.add_command(delegate_validate)
+    cli.add_command(delegate_finish)
+    cli.add_command(jules_sessions)
+
+@cli.command()
+@click.argument("pr_id", required=False)
+@click.option("--local", is_flag=True, help="Review local changes against main")
+def review(pr_id, local):
+    """Run a policy-grounded AI review on a PR or local code."""
+    reviewer = CodeReviewer()
+    reviewer.review(pr_id=pr_id, local=local)
+
+# Sprint Group Integration
+if is_internal_features_enabled():
+    try:
+        from ai_sprint.cli import main as sprint_main
+        # Attempt to add the command to the existing group
+        if sprint_suggest not in sprint_main.commands.values():
+             sprint_main.add_command(sprint_suggest)
+        cli.add_command(sprint_main, name="sprint")
+    except ImportError:
+        @cli.group(name="sprint")
+        def sprint_group():
+            """Sprint management commands."""
+            pass
+        sprint_group.add_command(sprint_suggest)
+        cli.add_command(sprint_group)
+
+if __name__ == "__main__":
+    cli()

onecoder/commands/__init__.py

@@ -0,0 +1 @@
+# Command package

onecoder/commands/auth.py

@@ -0,0 +1,78 @@
+import click
+import os
+import asyncio
+import webbrowser
+from functools import wraps
+from ..api_client import get_api_client
+from ..config_manager import config_manager
+
+def require_login(f):
+    """Decorator to enforce login."""
+    @wraps(f)
+    def wrapper(*args, **kwargs):
+        token = config_manager.get_token()
+        if not token:
+            click.echo("Error: You must be logged in to run this command.")
+            click.echo("Run 'onecoder login' first.")
+            return
+        return f(*args, **kwargs)
+    return wrapper
+
+from ..constants import GITHUB_CLIENT_ID
+
+@click.command()
+def login():
+    """Authenticates with OneCoder via GitHub."""
+    client_id = GITHUB_CLIENT_ID
+    
+    # Debug info
+    if client_id == "your_github_client_id":
+        click.secho(f"Debug: CWD is {os.getcwd()}", fg="yellow")
+        click.secho("Debug: GITHUB_CLIENT_ID is using placeholder!", fg="red")
+        
+    auth_url = f"https://github.com/login/oauth/authorize?client_id={client_id}&scope=user:email"
+    
+    click.echo("To authenticate, please visit the following URL in your browser:")
+    click.echo(f"\n  {auth_url}\n")
+    click.secho("Note: If you haven't installed the OneCoder GitHub App yet, please do so from the App Profile page.", fg="yellow")
+    
+    if click.confirm("Open browser automatically?", default=True):
+        webbrowser.open(auth_url)
+    
+    code = click.prompt("Enter the authorization code provided by GitHub")
+    
+    async def do_login():
+        try:
+            client = get_api_client()
+            result = await client.login_with_github(code)
+            config_manager.set_token(result["token"])
+            config_manager.set_user(result["user"])
+            click.echo(f"Successfully logged in as {result['user']['username']}!")
+            
+            if "github" in result and result["github"].get("expiresIn"):
+                 click.echo(f"  (Token expires in {result['github']['expiresIn']} seconds)")
+                 
+        except Exception as e:
+            import logging
+            logging.exception("Login process failed")
+            click.echo(f"Error: Login failed: {e}")
+
+    asyncio.run(do_login())
+
+@click.command()
+def logout():
+    """Logs out of OneCoder."""
+    config_manager.clear_token()
+    click.echo("Successfully logged out.")
+
+@click.command()
+def whoami():
+    """Shows the currently authenticated user."""
+    user = config_manager.get_user()
+    if user:
+        click.echo(f"Logged in as: {user['username']}")
+        token = config_manager.get_token()
+        if token:
+            click.echo(f"Token: {token[:10]}...{token[-10:]}")
+    else:
+        click.echo("Not logged in.")

onecoder/commands/ci.py

@@ -0,0 +1,29 @@
+import click
+import subprocess
+import sys
+from pathlib import Path
+
+@click.command(context_settings=dict(ignore_unknown_options=True, allow_extra_args=True))
+@click.argument("args", nargs=-1, type=click.UNPROCESSED)
+def ci(args):
+    """Run local CI/CD workflows using OneCoder CI."""
+    # Assumption: User runs this from the repo root where `scripts/onecoder-ci.sh` exists.
+    # Future improvement: Auto-detect repo root.
+    script_path = Path("scripts/onecoder-ci.sh")
+    
+    if not script_path.exists():
+        click.echo("❌ Error: 'scripts/onecoder-ci.sh' not found.")
+        click.echo("   Please run this command from the root of the 'platform' repository.")
+        sys.exit(1)
+        
+    # Prepare command: bash scripts/onecoder-ci.sh [args]
+    cmd = ["bash", str(script_path)] + list(args)
+    
+    try:
+        # Use subprocess.call or run to stream output directly
+        subprocess.run(cmd, check=True)
+    except subprocess.CalledProcessError as e:
+        sys.exit(e.returncode)
+    except Exception as e:
+        click.echo(f"❌ Error executing OneCoder CI: {str(e)}")
+        sys.exit(1)