Merge pull request #10 from callowayproject/phase5

Enhance error visibility and fix polling issues in core tasks

Author: coordt

.gitignore

@@ -116,6 +116,7 @@ celerybeat.pid
 
 # Environments
 .env
+.api-env
 .venv
 env/
 venv/

config.example.yaml

@@ -15,8 +15,8 @@ polling:
   interval_seconds: 60               # how often to poll GitHub (seconds)
 
 repos:
-  - owner: my-org
-    name: my-repo
+  - owner: callowayproject
+    name: bump-my-version
     agents:
       - type: issue-triage
         allow_close: false           # set to true to allow the agent to close issues

foreman/__main__.py

@@ -1,9 +1,213 @@
-"""Foreman CLI entrypoint."""
+"""Foreman CLI entrypoint.
 
+Usage::
 
-def main() -> None:
-    """Run the Foreman harness."""
-    raise NotImplementedError("Entrypoint not yet implemented — see Task 12.")
+    foreman start --config config.yaml
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import structlog
+import uvicorn
+
+from foreman.config import ConfigError, load_config
+from foreman.memory import MemoryStore
+from foreman.poller import GitHubPoller
+from foreman.routers import Router, RoutingError
+from foreman.server import Dispatcher, app
+
+if TYPE_CHECKING:
+    from foreman.config import ForemanConfig, RepoConfig
+
+logger = structlog.get_logger(__name__)
+
+#: Default memory DB path.
+_DEFAULT_DB_PATH = Path.home() / ".agent-harness" / "memory.db"
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    """Build the argument parser for the Foreman CLI.
+
+    Returns:
+        Configured :class:`argparse.ArgumentParser`.
+    """
+    parser = argparse.ArgumentParser(
+        prog="foreman",
+        description="Foreman — AI OSS co-maintainer harness",
+    )
+    subparsers = parser.add_subparsers(dest="command")
+
+    start = subparsers.add_parser("start", help="Start the Foreman harness")
+    start.add_argument(
+        "--config",
+        required=True,
+        metavar="CONFIG",
+        help="Path to the YAML configuration file",
+    )
+    start.add_argument(
+        "--db",
+        default=str(_DEFAULT_DB_PATH),
+        metavar="DB_PATH",
+        help="Path to the SQLite memory database (default: ~/.agent-harness/memory.db)",
+    )
+    start.add_argument(
+        "--host",
+        default="0.0.0.0",
+        metavar="HOST",
+        help="Host to bind the HTTP server to (default: 0.0.0.0)",
+    )
+    start.add_argument(
+        "--port",
+        type=int,
+        default=8000,
+        metavar="PORT",
+        help="Port for the HTTP server (default: 8000)",
+    )
+    return parser
+
+
+def main(argv: list[str] | None = None) -> None:
+    """Parse CLI arguments and run Foreman.
+
+    Args:
+        argv: Argument list (defaults to ``sys.argv[1:]`` when ``None``).
+
+    Raises:
+        SystemExit: On invalid arguments or configuration errors.
+    """
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+
+    if args.command is None:
+        parser.print_help(sys.stderr)
+        sys.exit(2)
+
+    if args.command == "start":
+        _run_start(args)
+
+
+def _run_start(args: Any) -> None:
+    """Execute the ``start`` sub-command.
+
+    Validates config, initialises the memory DB, then runs the poller and
+    HTTP server concurrently inside a single asyncio event loop.
+
+    Args:
+        args: Parsed namespace from argparse.
+
+    Raises:
+        SystemExit: On config validation failure.
+    """
+    # 1. Load and validate config — fail fast with a clear message.
+    try:
+        config = load_config(args.config)
+    except ConfigError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        sys.exit(1)
+
+    # 2. Initialise memory DB.
+    db_path = Path(args.db)
+    memory = MemoryStore(db_path)
+
+    # 3. Create core components.
+    poller = GitHubPoller(token=str(config.identity.github_token), memory=memory)
+    dispatcher = Dispatcher(config=config, memory=memory)
+
+    logger.info(
+        "Foreman initialised",
+        config=args.config,
+        db=str(db_path),
+        repos=[f"{r.owner}/{r.name}" for r in config.repos],
+        poll_interval_seconds=config.polling.interval_seconds,
+    )
+
+    # 4. Run the poller and HTTP server concurrently.
+    asyncio.run(_run_loop(config, memory, poller, dispatcher, args.host, args.port))
+
+
+async def _run_loop(
+    config: ForemanConfig,
+    memory: MemoryStore,
+    poller: GitHubPoller,
+    dispatcher: Dispatcher,
+    host: str,
+    port: int,
+) -> None:
+    """Run the poll loop and HTTP server concurrently.
+
+    The poller is started as an asyncio task alongside the uvicorn server.
+    On shutdown (SIGINT/SIGTERM), the poller task is cancelled cleanly.
+
+    Args:
+        config: Validated runtime configuration.
+        memory: Open memory store (passed through for context).
+        poller: Initialised :class:`~foreman.poller.GitHubPoller`.
+        dispatcher: Initialised :class:`~foreman.server.Dispatcher`.
+        host: Bind address for the HTTP server.
+        port: Port for the HTTP server.
+    """
+    router = Router(config)
+
+    async def on_event(repo_config: RepoConfig, event: dict[str, Any]) -> None:
+        """Handle one poller event: route it and dispatch to the appropriate agent.
+
+        Args:
+            repo_config: The repo configuration that produced this event.
+            event: Event dict with ``repo``, ``issue_number``, and ``payload``.
+        """
+        repo = event["repo"]
+        issue_number = event["issue_number"]
+        logger.info("Issue event", repo=repo, issue_number=issue_number)
+        try:
+            route_target = router.route("issue.triage", repo)
+        except RoutingError:
+            logger.warning("Repo not in config — skipping", repo=repo)
+            return
+        if route_target is None:
+            logger.debug("No agent handles issue.triage for this repo", repo=repo)
+            return
+        logger.info(
+            "Routing to agent",
+            repo=repo,
+            issue_number=issue_number,
+            agent_url=route_target.url,
+        )
+        await dispatcher.dispatch(event, route_target)
+
+    uv_server = uvicorn.Server(uvicorn.Config(app, host=host, port=port, log_config=None))
+
+    logger.info(
+        "Foreman started — polling every %d seconds, server on %s:%d",
+        config.polling.interval_seconds,
+        host,
+        port,
+    )
+
+    poller_task = asyncio.create_task(poller.run(config.repos, config.polling.interval_seconds, on_event))
+
+    def _on_poller_done(task: asyncio.Task) -> None:
+        """Log unexpected poller task termination."""
+        if not task.cancelled():
+            exc = task.exception()
+            if exc is not None:
+                logger.critical("Poller task crashed unexpectedly", exc_info=exc)
+
+    poller_task.add_done_callback(_on_poller_done)
+
+    try:
+        await uv_server.serve()
+    finally:
+        poller_task.cancel()
+        try:
+            await poller_task
+        except asyncio.CancelledError:
+            logger.info("Poller stopped cleanly")
 
 
 if __name__ == "__main__":

foreman/memory.py

@@ -60,7 +60,7 @@ class MemoryStore:
     def __init__(self, db_path: Path) -> None:
         self.db_path = db_path
         db_path.parent.mkdir(parents=True, exist_ok=True)
-        self._conn = sqlite3.connect(str(db_path))
+        self._conn = sqlite3.connect(str(db_path), check_same_thread=False)
         self._conn.executescript(_SCHEMA)
         self._conn.commit()
 

foreman/poller.py

@@ -81,6 +81,13 @@ def poll_repo(self, repo_config: RepoConfig) -> list[dict[str, Any]]:
 
         issues = list(gh_repo.get_issues(**get_issues_kwargs))
 
+        logger.info(
+            "Polled repo",
+            repo=repo_name,
+            issues_found=len(issues),
+            since=last_polled.isoformat() if last_polled else "beginning",
+        )
+
         events: list[dict[str, Any]] = []
         for issue in issues:
             if issue.user.login in collaborator_logins:
@@ -171,7 +178,20 @@ async def _poll_with_backoff(
                     )
                     return
                 else:
-                    raise
+                    if exc.status == 401:
+                        logger.critical(
+                            "Bad GitHub credentials — check GITHUB_TOKEN; skipping repo this cycle",
+                            repo=f"{repo_cfg.owner}/{repo_cfg.name}",
+                            status=exc.status,
+                        )
+                    else:
+                        logger.error(
+                            "GitHub API error polling repo; skipping this cycle",
+                            repo=f"{repo_cfg.owner}/{repo_cfg.name}",
+                            status=exc.status,
+                            error=str(exc),
+                        )
+                    return
 
     # ------------------------------------------------------------------
     # Continuous polling loop

foreman/routers/__init__.py

@@ -1 +1,5 @@
 """Router submodule."""
+
+from foreman.routers.agent import Router, RouteTarget, RoutingError
+
+__all__ = ["RouteTarget", "Router", "RoutingError"]