alissa-tools-github-devloop 0.1.0__tar.gz

alissa_tools_github_devloop-0.1.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include requirements.txt
+include src/main/alissa/tools/github/devloop/version

alissa_tools_github_devloop-0.1.0/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: alissa-tools-github-devloop
+Version: 0.1.0
+Summary: ALISSA-TOOLS-GITHUB-DEVLOOP
+Home-page: https://alissa.app
+Author: Fahera
+Author-email: support@alissa.app
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-python
+Dynamic: summary
+
+# alissa-tools-github-devloop
+
+The `alissa.tools.github.devloop` module: a GitHub watcher that turns
+`alissa:develop`-labeled issues into fresh developer sessions — the
+developer-side counterpart of
+[`alissa-tools-github-reviewloop`](https://github.com/fahera-mx/alissa-github-review-daemon).
+
+This distribution ships **only** that module. Everything above it —
+`alissa`, `alissa.tools`, `alissa.tools.github` — is a
+[PEP 420](https://peps.python.org/pep-0420/) namespace package with no
+`__init__.py`, so other distributions in other repositories can contribute
+their own packages under the same namespace:
+
+```
+alissa/                                  ← namespace (no __init__.py)
+└── tools/                               ← namespace
+    └── github/                          ← namespace
+        ├── devloop/      __init__.py    ← THIS distribution
+        └── reviewloop/   __init__.py    ← ships from alissa-github-review-daemon
+```
+
+The rule: a distribution owns a leaf package and declares only that subtree
+(`find_namespace_packages(include=[PACKAGE, f"{PACKAGE}.*"])`). Adding an
+`__init__.py` at any namespace level would claim it for one distribution and
+shadow the others.
+
+## Install
+
+```sh
+pip install -e ./alissa-tools-github-devloop
+```
+
+## Console scripts
+
+| Command | Entry point |
+| --- | --- |
+| `alissa-devloop` | `alissa.tools.github.devloop.__main__:main` |
+
+## Layout
+
+`src/main` holds the package tree, `src/test` mirrors it as `test_*`. The
+distribution version lives in the plain-text `version` file next to the module
+it versions (`src/main/alissa/tools/github/devloop/version`), read by both
+`setup.py` and `version.py`.

alissa_tools_github_devloop-0.1.0/README.md

@@ -0,0 +1,44 @@
+# alissa-tools-github-devloop
+
+The `alissa.tools.github.devloop` module: a GitHub watcher that turns
+`alissa:develop`-labeled issues into fresh developer sessions — the
+developer-side counterpart of
+[`alissa-tools-github-reviewloop`](https://github.com/fahera-mx/alissa-github-review-daemon).
+
+This distribution ships **only** that module. Everything above it —
+`alissa`, `alissa.tools`, `alissa.tools.github` — is a
+[PEP 420](https://peps.python.org/pep-0420/) namespace package with no
+`__init__.py`, so other distributions in other repositories can contribute
+their own packages under the same namespace:
+
+```
+alissa/                                  ← namespace (no __init__.py)
+└── tools/                               ← namespace
+    └── github/                          ← namespace
+        ├── devloop/      __init__.py    ← THIS distribution
+        └── reviewloop/   __init__.py    ← ships from alissa-github-review-daemon
+```
+
+The rule: a distribution owns a leaf package and declares only that subtree
+(`find_namespace_packages(include=[PACKAGE, f"{PACKAGE}.*"])`). Adding an
+`__init__.py` at any namespace level would claim it for one distribution and
+shadow the others.
+
+## Install
+
+```sh
+pip install -e ./alissa-tools-github-devloop
+```
+
+## Console scripts
+
+| Command | Entry point |
+| --- | --- |
+| `alissa-devloop` | `alissa.tools.github.devloop.__main__:main` |
+
+## Layout
+
+`src/main` holds the package tree, `src/test` mirrors it as `test_*`. The
+distribution version lives in the plain-text `version` file next to the module
+it versions (`src/main/alissa/tools/github/devloop/version`), read by both
+`setup.py` and `version.py`.

alissa_tools_github_devloop-0.1.0/requirements.txt

@@ -0,0 +1,2 @@
+# No third-party runtime dependencies — everything shells out to `gh` and
+# `alissa`, which keep their own auth handling (same posture as reviewloop).

alissa_tools_github_devloop-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

alissa_tools_github_devloop-0.1.0/setup.py

@@ -0,0 +1,57 @@
+import os
+from setuptools import setup, find_namespace_packages
+
+
+CODEBASE_PATH = os.environ.get(
+    "CODEBASE_PATH",
+    default=os.path.join("src", "main"),
+)
+
+# Everything above `devloop` is a PEP 420 namespace package (no __init__.py),
+# so other distributions can ship their own alissa.tools.* / alissa.tools.github.*
+# concrete packages. This distribution declares only its own subtree.
+NAMESPACE = "alissa.tools.github"
+PACKAGE = f"{NAMESPACE}.devloop"
+
+with open("requirements.txt", "r") as file:
+    requirements = [line for line in file.read().splitlines() if line and not line.startswith("#")]
+
+version_filepath = os.path.join(CODEBASE_PATH, *PACKAGE.split("."), "version")
+with open(version_filepath, "r") as file:
+    version = file.read().strip()
+
+
+with open("README.md") as file:
+    readme = file.read()
+
+
+setup(
+    name="alissa-tools-github-devloop",
+    version=version,
+    description="ALISSA-TOOLS-GITHUB-DEVLOOP",
+    long_description=readme,
+    long_description_content_type='text/markdown',
+    url="https://alissa.app",
+    author="Fahera",
+    author_email="support@alissa.app",
+    packages=find_namespace_packages(
+        where=CODEBASE_PATH,
+        include=[PACKAGE, f"{PACKAGE}.*"],
+    ),
+    package_dir={
+        "": CODEBASE_PATH
+    },
+    package_data={
+        "": [
+            version_filepath,
+        ]
+    },
+    entry_points={
+        "console_scripts": [
+            "alissa-devloop=alissa.tools.github.devloop.__main__:main",
+        ]
+    },
+    install_requires=requirements,
+    include_package_data=True,
+    python_requires=">=3.11",
+)

alissa_tools_github_devloop-0.1.0/src/main/alissa/tools/github/devloop/__init__.py

@@ -0,0 +1,11 @@
+"""devloop — a GitHub watcher that turns `alissa:develop`-labeled issues into
+fresh developer sessions: the developer-side counterpart of reviewloop.
+
+The moving parts: `config` (three-layer settings + reviewer rails),
+`ghclient` (gh api access, self-assignment in-flight marker), `state` (the
+attempt ledger), `loop` (the DevWatcher decision state machine and the
+DEV_DIRECTIVE contract), `alissa` (session queue + worker plumbing), and
+`__main__` (the alissa-devloop CLI).
+"""
+
+__all__: list[str] = []

alissa_tools_github_devloop-0.1.0/src/main/alissa/tools/github/devloop/__main__.py

@@ -0,0 +1,217 @@
+"""CLI entry point: alissa-devloop (or python -m alissa.tools.github.devloop)"""
+
+from __future__ import annotations
+
+import argparse
+import dataclasses
+import logging
+import sys
+from pathlib import Path
+
+from .config import (
+    HUB_ADD,
+    HUB_SKIP,
+    ON_MISSING_SKIP,
+    ON_MISSING_SPAWN,
+    ON_MISSING_WARN,
+    Config,
+    load_config_file,
+    resolve_config_path,
+    resolve_reviewers,
+)
+from .ghclient import IdentityMismatch, RateLimited
+from .loop import DevWatcher
+from .proc import CommandError
+from .version import version
+
+log = logging.getLogger(__name__)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="alissa-devloop",
+        description="Watch GitHub for alissa:develop-labeled issues and spawn "
+        "fresh developer sessions — the developer-side counterpart of "
+        "alissa-reviewloop.",
+        epilog="Every setting below can also live in the config file; CLI "
+        "arguments win, and ALISSA_DEV_REVIEWERS wins over --reviewer. "
+        "workspace_root is CLI-only, so one config can drive several daemons "
+        "over different workspaces.",
+    )
+
+    p.add_argument(
+        "--version", action="version", version=f"%(prog)s {version.value}"
+    )
+    p.add_argument(
+        "--workspace-root",
+        type=Path,
+        default=None,
+        metavar="PATH",
+        help="the Alissa Code Workspace to watch (default: current directory)",
+    )
+    p.add_argument(
+        "-c",
+        "--config-path",
+        "--config",
+        dest="config_path",
+        type=Path,
+        default=None,
+        metavar="PATH",
+        help="config file; without it, ./devloop.config.json then "
+        "<workspace-root>/devloop.config.json, else defaults only",
+    )
+
+    mode = p.add_argument_group("mode")
+    mode.add_argument("--once", action="store_true", help="run a single poll pass and exit")
+    mode.add_argument("-v", "--verbose", action="store_true")
+
+    over = p.add_argument_group("config overrides (win over the config file)")
+    over.add_argument(
+        "--repo",
+        dest="repos",
+        action="append",
+        metavar="OWNER/REPO",
+        help="watch this repo for labeled issues; repeatable. When given, "
+        "REPLACES the config `repos` list; when absent, the config list "
+        "applies. Emptying the allowlist (which turns the daemon off — an "
+        "empty allowlist watches NOTHING) is done in the config file.",
+    )
+    over.add_argument("--poll-interval", type=int, metavar="SECONDS")
+    over.add_argument("--label", metavar="LABEL", help="issue label that marks dev-ready work")
+    over.add_argument("--hub-template", metavar="TEMPLATE")
+    over.add_argument("--agent-profile", metavar="NAME")
+    over.add_argument("--developer-login", metavar="LOGIN")
+    over.add_argument(
+        "--reviewer",
+        dest="reviewers",
+        action="append",
+        metavar="LOGIN",
+        help="request this reviewer at the ready-for-review flip; repeatable. "
+        "Replaces the config list. ALISSA_DEV_REVIEWERS overrides even this.",
+    )
+    over.add_argument("--state-path", type=Path, metavar="PATH")
+    over.add_argument("--attempt-cap", type=int, metavar="N", help="dev attempts per issue")
+    over.add_argument("--stale-minutes", type=int, metavar="MINUTES")
+    over.add_argument(
+        "--on-missing-origin-task",
+        choices=[ON_MISSING_WARN, ON_MISSING_SPAWN, ON_MISSING_SKIP],
+    )
+    over.add_argument("--on-missing-hub", choices=[HUB_SKIP, HUB_ADD])
+
+    dry = over.add_mutually_exclusive_group()
+    dry.add_argument(
+        "--dry-run",
+        dest="dry_run",
+        action="store_true",
+        default=None,
+        help="decide and log, but never spawn a session or touch GitHub state",
+    )
+    dry.add_argument(
+        "--no-dry-run",
+        dest="dry_run",
+        action="store_false",
+        help="act for real even if the config sets dry_run",
+    )
+    return p
+
+
+def overrides_from(args: argparse.Namespace) -> dict:
+    """CLI values, with None meaning 'not specified' so the config file shows
+    through. `repos`/`reviewers` become tuples so they match the file form."""
+    return {
+        "repos": tuple(args.repos) if args.repos else None,
+        "poll_interval": args.poll_interval,
+        "label": args.label,
+        "hub_template": args.hub_template,
+        "agent_profile": args.agent_profile,
+        "developer_login": args.developer_login,
+        "reviewers": tuple(args.reviewers) if args.reviewers else None,
+        "state_path": args.state_path,
+        "attempt_cap": args.attempt_cap,
+        "stale_minutes": args.stale_minutes,
+        "on_missing_origin_task": args.on_missing_origin_task,
+        "on_missing_hub": args.on_missing_hub,
+        "dry_run": args.dry_run,
+    }
+
+
+def resolve_config(args: argparse.Namespace) -> Config:
+    workspace_root = args.workspace_root or Path.cwd()
+    path = resolve_config_path(args.config_path, workspace_root)
+
+    file_data = load_config_file(path) if path else {}
+    log.info("config: %s", path or "none found — defaults + CLI arguments only")
+
+    config = Config.build(workspace_root, file_data, overrides_from(args))
+    return dataclasses.replace(
+        config,
+        reviewers=resolve_reviewers(config.reviewers, config.manifest_path),
+    )
+
+
+def log_effective_config(config: Config, login: str) -> None:
+    """The resolved settings, defaults and all. INFO carries the decisions an
+    operator needs; -v (DEBUG) shows the full surface."""
+    log.info("developing as GitHub user %s (from the gh token)", login)
+    log.info(
+        "watching %s for label %r",
+        ", ".join(config.repos) if config.repos
+        else "NO repos (empty allowlist — set `repos` or pass --repo)",
+        config.label,
+    )
+    log.info("reviewers: %s", ", ".join(config.reviewers) or "none")
+    log.info(
+        "poll every %ss; dry_run=%s; attempt_cap=%s; stale after %s min",
+        config.poll_interval, config.dry_run, config.attempt_cap, config.stale_minutes,
+    )
+    log.debug("hub_template: %s", config.hub_template)
+    log.debug("agent_profile: %s", config.agent_profile)
+    log.debug("developer_login: %s", config.developer_login or f"{login} (auto)")
+    log.debug("state_db: %s", config.state_db)
+    log.debug("on_missing_origin_task: %s", config.on_missing_origin_task)
+    log.debug("on_missing_hub: %s", config.on_missing_hub)
+
+
+def main(argv: "list[str] | None" = None) -> int:
+    args = build_parser().parse_args(argv)
+
+    logging.basicConfig(
+        level=logging.DEBUG if args.verbose else logging.INFO,
+        format="%(asctime)s %(levelname)-7s %(message)s",
+        datefmt="%H:%M:%S",
+    )
+
+    try:
+        config = resolve_config(args)
+        log.info("workspace: %s", config.workspace_root)
+
+        watcher = DevWatcher(config)
+        for warning in watcher.preflight():
+            log.warning(warning)
+        log_effective_config(config, watcher.github.login)
+
+        if args.once:
+            watcher.poll_once()
+        else:
+            watcher.run_forever()
+    except IdentityMismatch as exc:
+        print(f"identity error: {exc}", file=sys.stderr)
+        return 2
+    except (FileNotFoundError, ValueError) as exc:
+        print(f"config error: {exc}", file=sys.stderr)
+        return 2
+    except RateLimited as exc:
+        # Only --once can get here: run_forever absorbs rate limits by
+        # backing off, but a single pass has no next pass to wait for.
+        print(f"rate limited: {exc}", file=sys.stderr)
+        return 1
+    except CommandError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+    except KeyboardInterrupt:
+        return 0
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

alissa_tools_github_devloop-0.1.0/src/main/alissa/tools/github/devloop/alissa.py

@@ -0,0 +1,75 @@
+"""Alissa CLI access: enqueue the fresh developer session and probe the
+worker. The developer's Alissa task is created by the session itself (as a
+downstream of the origin task), so unlike reviewloop there is no task lookup
+here -- the daemon's only Alissa surfaces are the tmux queue and the worker."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from .proc import CommandError, run
+
+log = logging.getLogger(__name__)
+
+
+class Alissa:
+    def enqueue_developer(
+        self,
+        *,
+        session: str,
+        directive: str,
+        cwd: Path,
+        agent: str,
+        dry_run: bool = False,
+    ) -> None:
+        argv = [
+            "alissa",
+            "tmux",
+            "queue",
+            "add",
+            session,
+            "--agent",
+            agent,
+            "--cwd",
+            str(cwd),
+            directive,
+        ]
+
+        if dry_run:
+            log.info("[dry-run] would enqueue: %s", " ".join(argv[:-1]) + " <directive>")
+            return
+
+        run(argv, timeout=60)
+
+        # Developers are one-shot per attempt: a finished (or dead) session must
+        # never be respawned by the worker -- staleness handling re-enqueues as
+        # attempt k+1 with a fresh session name instead. Best-effort: an older
+        # CLI without `queue set` should not fail the enqueue.
+        try:
+            run(["alissa", "tmux", "queue", "set", session, "respawn", "off"],
+                timeout=30, check=False)
+        except CommandError:  # pragma: no cover - defence in depth
+            log.warning("could not set respawn off for %s", session)
+
+    def add_repo_to_workspace(
+        self, owner: str, repo: str, workspace_root: Path, *, dry_run: bool = False
+    ) -> None:
+        """Hub-ify a repo into the workspace (bare clone + main/ worktree) and
+        record it in alissa-workspace.yaml. Idempotent per the CLI's contract."""
+        argv = ["alissa", "code", "workspace", "add", f"{owner}/{repo}"]
+        if dry_run:
+            log.info("[dry-run] would run: %s (cwd=%s)", " ".join(argv), workspace_root)
+            return
+
+        log.info("hub-ifying %s/%s into %s", owner, repo, workspace_root)
+        # Cloning a repo can be slow; the poll loop tolerates a long pass.
+        run(argv, timeout=600, cwd=workspace_root)
+
+    def worker_running(self) -> bool:
+        """The queue only drains while `alissa worker` reconciles it."""
+        try:
+            out = run(["alissa", "worker", "status"], timeout=30, check=False)
+        except CommandError:
+            return False
+        return "not running" not in out.lower() and "no worker" not in out.lower()