blitz-cli 0.7.0__tar.gz → 0.8.0__tar.gz

{blitz_cli-0.7.0 → blitz_cli-0.8.0}/PKG-INFO

@@ -1,13 +1,11 @@
 Metadata-Version: 2.4
 Name: blitz-cli
-Version: 0.7.0
+Version: 0.8.0
 Summary: Developer CLI for Blitz locker-room: spec-driven playbooks, a codebase/huddle ontology graph with an MCP tool, and the composable watcher/trainer/graph containers.
 License: MIT
 License-File: LICENSE
 Requires-Python: >=3.9
 Requires-Dist: rich>=13
-Provides-Extra: locker-room
-Requires-Dist: mcp>=1.0; extra == 'locker-room'
 Provides-Extra: train
 Requires-Dist: accelerate==1.2.1; extra == 'train'
 Requires-Dist: datasets==3.2.0; extra == 'train'
@@ -55,14 +53,17 @@ for coordinating a feature across repos. Use `--ignore PATH` to skip a repo and
 
 ## Locker-room: ontology graph, watcher, trainer, MCP
 
-`blitz locker-room init` scaffolds a `docker-compose.yml` that pulls prebuilt
-images (from `sparepartslabs/blitz-locker-room`, pinned to this CLI version) for
-three roles sharing `./data`:
+The locker-room is a **context node**: a set of containers that ingest, build,
+and serve an ontology of your codebase to agents (on your machine, a VPN, or a
+team host). `blitz locker-room init` scaffolds a `docker-compose.yml` that pulls
+the prebuilt node images (from `sparepartslabs/blitz-locker-room`) for four roles
+sharing `./data`:
 
 - **watch**: ingests your coding agent's session transcripts into a corpus.
 - **graph**: rebuilds an ontology of your playbook-enabled repos, huddles,
   features, and their code lineage into `data/ontology.db` on a loop.
-- **mcp**: serves that ontology to agents over SSE.
+- **mcp**: serves that ontology to agents over MCP (SSE) and a browser graph view.
+- **train**: on-demand QLoRA trainer (needs a GPU).
 
 ```bash
 blitz locker-room init          # write ./locker-room/docker-compose.yml
@@ -71,24 +72,23 @@ blitz locker-room up            # start watch + graph + mcp
 blitz locker-room logs
 ```
 
-The ontology is also usable directly on the host, no containers required:
+The CLI is just these static commands (`init`, and the `up`/`down`/`logs`/`pull`/
+`train` lifecycle passthroughs). The runtime (ingest, graph build, serving) lives
+in the node images, not the CLI.
 
-```bash
-blitz locker-room ontologize    # scan a workspace into ./data/ontology.db
-blitz locker-room list          # list playbook-enabled repos + their active feature
-blitz locker-room mcp           # stdio MCP server for a local agent
-```
+### The graph agents can query
 
-### The graph an agent can query
+The graph engine (a blitz-cli library the node runs) reuses playbook discovery and
+static code parsing (Python symbols + imports + calls; File nodes for other
+languages) to build `Workspace`, `Repo`, `AgentTool`, `Playbook`, `Feature` (with
+lifecycle stage), `Huddle`, `File`, and `Symbol` nodes. Each feature's git branch
+diff links it to the code it touches (`Feature -TOUCHES-> File/Symbol`), so an
+agent can walk a spec out to the full lineage of code it implements, and back.
 
-`ontologize` reuses playbook discovery and static code parsing (Python symbols +
-imports + calls; File nodes for other languages) to build a graph of `Workspace`,
-`Repo`, `AgentTool`, `Playbook`, `Feature` (with lifecycle stage), `Huddle`,
-`File`, and `Symbol` nodes. Each feature's git branch diff links it to the code
-it touches (`Feature -TOUCHES-> File/Symbol`), so an agent can walk a spec out to
-the full lineage of code it implements, and back. The MCP tools expose this:
-`list_repos`, `get_repo`, `list_huddles`, `get_huddle`, `get_playbooks`,
-`get_lineage`, `impact_of`, `get_file`, `get_symbol`, and a generic `neighbors`.
+The `mcp` role serves this: point an agent's MCP config at
+`http://<node>:8848/sse` (tools `list_repos`, `get_repo`, `list_huddles`,
+`get_huddle`, `get_playbooks`, `get_lineage`, `impact_of`, `get_file`,
+`get_symbol`, `neighbors`), or open `http://<node>:8848/graph` in a browser.
 
 ### Training (optional)
 

{blitz_cli-0.7.0 → blitz_cli-0.8.0}/README.md

@@ -34,14 +34,17 @@ for coordinating a feature across repos. Use `--ignore PATH` to skip a repo and
 
 ## Locker-room: ontology graph, watcher, trainer, MCP
 
-`blitz locker-room init` scaffolds a `docker-compose.yml` that pulls prebuilt
-images (from `sparepartslabs/blitz-locker-room`, pinned to this CLI version) for
-three roles sharing `./data`:
+The locker-room is a **context node**: a set of containers that ingest, build,
+and serve an ontology of your codebase to agents (on your machine, a VPN, or a
+team host). `blitz locker-room init` scaffolds a `docker-compose.yml` that pulls
+the prebuilt node images (from `sparepartslabs/blitz-locker-room`) for four roles
+sharing `./data`:
 
 - **watch**: ingests your coding agent's session transcripts into a corpus.
 - **graph**: rebuilds an ontology of your playbook-enabled repos, huddles,
   features, and their code lineage into `data/ontology.db` on a loop.
-- **mcp**: serves that ontology to agents over SSE.
+- **mcp**: serves that ontology to agents over MCP (SSE) and a browser graph view.
+- **train**: on-demand QLoRA trainer (needs a GPU).
 
 ```bash
 blitz locker-room init          # write ./locker-room/docker-compose.yml
@@ -50,24 +53,23 @@ blitz locker-room up            # start watch + graph + mcp
 blitz locker-room logs
 ```
 
-The ontology is also usable directly on the host, no containers required:
+The CLI is just these static commands (`init`, and the `up`/`down`/`logs`/`pull`/
+`train` lifecycle passthroughs). The runtime (ingest, graph build, serving) lives
+in the node images, not the CLI.
 
-```bash
-blitz locker-room ontologize    # scan a workspace into ./data/ontology.db
-blitz locker-room list          # list playbook-enabled repos + their active feature
-blitz locker-room mcp           # stdio MCP server for a local agent
-```
+### The graph agents can query
 
-### The graph an agent can query
+The graph engine (a blitz-cli library the node runs) reuses playbook discovery and
+static code parsing (Python symbols + imports + calls; File nodes for other
+languages) to build `Workspace`, `Repo`, `AgentTool`, `Playbook`, `Feature` (with
+lifecycle stage), `Huddle`, `File`, and `Symbol` nodes. Each feature's git branch
+diff links it to the code it touches (`Feature -TOUCHES-> File/Symbol`), so an
+agent can walk a spec out to the full lineage of code it implements, and back.
 
-`ontologize` reuses playbook discovery and static code parsing (Python symbols +
-imports + calls; File nodes for other languages) to build a graph of `Workspace`,
-`Repo`, `AgentTool`, `Playbook`, `Feature` (with lifecycle stage), `Huddle`,
-`File`, and `Symbol` nodes. Each feature's git branch diff links it to the code
-it touches (`Feature -TOUCHES-> File/Symbol`), so an agent can walk a spec out to
-the full lineage of code it implements, and back. The MCP tools expose this:
-`list_repos`, `get_repo`, `list_huddles`, `get_huddle`, `get_playbooks`,
-`get_lineage`, `impact_of`, `get_file`, `get_symbol`, and a generic `neighbors`.
+The `mcp` role serves this: point an agent's MCP config at
+`http://<node>:8848/sse` (tools `list_repos`, `get_repo`, `list_huddles`,
+`get_huddle`, `get_playbooks`, `get_lineage`, `impact_of`, `get_file`,
+`get_symbol`, `neighbors`), or open `http://<node>:8848/graph` in a browser.
 
 ### Training (optional)
 

{blitz_cli-0.7.0 → blitz_cli-0.8.0}/blitz_cli/_ontology.py

@@ -1,11 +1,12 @@
-"""Local ontology graph of playbook-enabled workspaces/repos/huddles/features.
-
-`blitz locker-room ontologize` scans a workspace and upserts a small graph into a
-SQLite file (``./data/ontology.db`` by default), which the stdio MCP server
-(:mod:`blitz_cli._locker_room_mcp`) and ``blitz locker-room list`` read back. The
-graph is deliberately tiny (dozens of repos, a handful of huddles) and stored as
-generic ``nodes``/``edges`` tables so the query surface stays engine-agnostic — a
-Neo4j/Memgraph backend could drop in behind the same query helpers later.
+"""Ontology graph engine for playbook-enabled workspaces/repos/huddles/features.
+
+This is a library: ``ontologize()`` scans a workspace and upserts a small graph
+into a SQLite file, and ``OntologyStore`` reads it back. The locker-room context
+node (the blitz-locker-room images) runs both -- its ontologize loop builds the
+graph and its server serves it over MCP/HTTP. The graph is deliberately tiny
+(dozens of repos, a handful of huddles) and stored as generic ``nodes``/``edges``
+tables so the query surface stays engine-agnostic; a Neo4j/Memgraph backend could
+drop in behind the same query helpers later.
 """
 
 from __future__ import annotations
@@ -178,6 +179,22 @@ class OntologyStore:
         node["coordinates"] = self.neighbors(node["id"], rel="COORDINATES")
         return node
 
+    def graph_data(self, include_code: bool = False) -> dict:
+        """Nodes + edges for visualization. Structural labels only by default
+        (Workspace/Repo/Playbook/AgentTool/Feature/Stage/Huddle); pass
+        ``include_code`` to add File/Symbol (much larger)."""
+        nodes = []
+        for r in self.conn.execute("SELECT id, label, props FROM nodes").fetchall():
+            if not include_code and r["label"] in ("File", "Symbol"):
+                continue
+            nodes.append({"id": r["id"], "label": r["label"], **json.loads(r["props"])})
+        ids = {n["id"] for n in nodes}
+        edges = []
+        for e in self.conn.execute("SELECT src, dst, rel FROM edges").fetchall():
+            if e["src"] in ids and e["dst"] in ids:
+                edges.append({"source": e["src"], "target": e["dst"], "rel": e["rel"]})
+        return {"nodes": nodes, "edges": edges}
+
     def get_playbooks(self, repo: str | None = None) -> list[dict]:
         if repo:
             node = self.get_node(repo) or self.get_node(f"repo:{Path(repo).resolve()}")

{blitz_cli-0.7.0 → blitz_cli-0.8.0}/blitz_cli/cli.py

@@ -3,10 +3,8 @@
 from __future__ import annotations
 
 import argparse
-import json
 import os
 import sys
-import time
 from pathlib import Path
 from typing import Optional
 
@@ -51,81 +49,14 @@ def _cmd_locker_room_make(args: argparse.Namespace) -> int:
     return _make.run_make(Path(args.run_dir), args.target)
 
 
-def _cmd_locker_room_ontologize(args: argparse.Namespace) -> int:
-    from blitz_cli import _ontology
 
-    ignore = [Path(p) for p in getattr(args, "ignore", [])]
-
-    def once() -> str:
-        counts = _ontology.ontologize(
-            args.workspace, args.db, ignore=ignore,
-            code=args.code, max_file_bytes=args.max_file_bytes,
-        )
-        return ", ".join(f"{k}={v}" for k, v in sorted(counts.items())) or "empty"
-
-    if not args.loop:
-        print(f"Ontologized {Path(args.workspace).resolve()} -> {args.db} ({once()})")
-        return 0
-
-    # Daemon mode (the graph container): rebuild on an interval forever.
-    print(f"ontologize: {Path(args.workspace).resolve()} -> {args.db} every {args.interval}s")
-    while True:
-        try:
-            print(f"ontologize: rebuilt ({once()})", flush=True)
-        except Exception as exc:  # never let one bad scan kill the loop
-            print(f"ontologize: error {exc!r}", flush=True)
-        time.sleep(args.interval)
-
-
-def _cmd_locker_room_watch(args: argparse.Namespace) -> int:
-    """Activity-ingest daemon (the watch container): tail coding-agent session
-    transcripts into a local corpus on a loop (currently Claude Code's format)."""
-    from blitz_cli import _corpus
 
-    store = _corpus.TurnStore(args.db)
-    print(f"watch: {args.projects_dir} -> {args.db} every {args.interval}s")
-    while True:
-        try:
-            n = _corpus.ingest_once(args.projects_dir, store)
-            if n:
-                print(f"watch: upserted {n} turns", flush=True)
-        except Exception as exc:
-            print(f"watch: error {exc!r}", flush=True)
-        time.sleep(args.interval)
 
 
-def _cmd_locker_room_list(args: argparse.Namespace) -> int:
-    from blitz_cli import _ontology
 
-    if not Path(args.db).exists():
-        _eprint(f"error: no ontology graph at {args.db}. Run `blitz locker-room ontologize` first.")
-        return 2
-    repos = _ontology.OntologyStore(args.db, read_only=True).list_repos()
-    if args.json:
-        print(json.dumps(repos, indent=2))
-        return 0
-    if not repos:
-        print("No playbook-enabled repos in the graph.")
-        return 0
-    for r in repos:
-        feat = f"{r['active_feature']} ({r['active_stage']})" if r.get("active_feature") else "-"
-        agents = ",".join(r.get("agents", [])) or "-"
-        print(f"{r['name']:<24} agents={agents:<28} active={feat}  {r['path']}")
-    return 0
 
 
-def _cmd_locker_room_train_run(args: argparse.Namespace) -> int:
-    from blitz_cli import _train
 
-    return _train.run()
-
-
-def _cmd_locker_room_mcp(args: argparse.Namespace) -> int:
-    from blitz_cli import _locker_room_mcp
-
-    return _locker_room_mcp.serve(
-        args.db, transport=args.transport, host=args.host, port=args.port
-    )
 
 
 def _cmd_activity(args: argparse.Namespace) -> int:
@@ -412,15 +343,15 @@ def build_parser() -> argparse.ArgumentParser:
 
     lr = sub.add_parser(
         "locker-room",
-        help="Create and manage the locker-room (watcher, trainer, ontology graph) "
-        "and its MCP tool.",
+        help="Scaffold and manage a locker-room context node (watcher, ontology "
+        "graph, MCP/graph server, trainer) as containers.",
     )
     lr_sub = lr.add_subparsers(dest="locker_room_cmd", required=True)
 
     lr_init = lr_sub.add_parser(
         "init",
         help="Scaffold a locker-room project here: a docker-compose that pulls the "
-        "watcher/trainer/graph images plus an ontology MCP tool.",
+        "prebuilt node images (watch / graph / mcp-web / trainer).",
     )
     lr_init.add_argument(
         "-o", "--out", default="./locker-room", help="Output dir (default ./locker-room)"
@@ -444,74 +375,6 @@ def build_parser() -> argparse.ArgumentParser:
         )
         leaf.set_defaults(func=_cmd_locker_room_make, target=target)
 
-    lr_ont = lr_sub.add_parser(
-        "ontologize", help="Scan a workspace of playbook-enabled repos into the ontology graph."
-    )
-    lr_ont.add_argument("--workspace", default=".", help="Workspace root to scan (default: cwd)")
-    lr_ont.add_argument("--db", default="./data/ontology.db", help="Ontology SQLite path")
-    lr_ont.add_argument(
-        "--ignore", action="append", metavar="PATH", default=[],
-        help="Path to skip during discovery (repeatable)",
-    )
-    lr_ont.add_argument(
-        "--no-code", dest="code", action="store_false", default=True,
-        help="Skip the code graph (File/Symbol/imports/calls); structural ontology only",
-    )
-    lr_ont.add_argument(
-        "--max-file-bytes", type=int, default=1_000_000,
-        help="Skip source files larger than this when building the code graph (default 1MB)",
-    )
-    lr_ont.add_argument(
-        "--loop", action="store_true",
-        help="Rebuild forever on --interval (the graph container runs this)",
-    )
-    lr_ont.add_argument(
-        "--interval", type=int, default=300, help="Seconds between rebuilds in --loop mode",
-    )
-    lr_ont.set_defaults(func=_cmd_locker_room_ontologize)
-
-    lr_watch = lr_sub.add_parser(
-        "watch", help="Ingest coding-agent transcripts into a corpus on a loop (the watch container)."
-    )
-    lr_watch.add_argument(
-        "--projects-dir", default=os.environ.get("CLAUDE_PROJECTS_DIR", str(Path.home() / ".claude" / "projects")),
-        help="Agent transcript dir to ingest (default: ~/.claude/projects; env CLAUDE_PROJECTS_DIR)",
-    )
-    lr_watch.add_argument("--db", default="./data/activity.db", help="Corpus SQLite path")
-    lr_watch.add_argument(
-        "--interval", type=int, default=int(os.environ.get("WATCH_INTERVAL_SECONDS", "45")),
-        help="Seconds between ingests (env WATCH_INTERVAL_SECONDS)",
-    )
-    lr_watch.set_defaults(func=_cmd_locker_room_watch)
-
-    lr_train_run = lr_sub.add_parser(
-        "train-run",
-        help="Run the QLoRA training job in-process (the trainer container's entrypoint; "
-        "needs blitz-cli[train] + a GPU).",
-    )
-    lr_train_run.set_defaults(func=_cmd_locker_room_train_run)
-
-    lr_list = lr_sub.add_parser("list", help="List playbook-enabled repos from the ontology graph.")
-    lr_list.add_argument("--db", default="./data/ontology.db", help="Ontology SQLite path")
-    lr_list.add_argument("--json", action="store_true", help="Emit JSON")
-    lr_list.set_defaults(func=_cmd_locker_room_list)
-
-    lr_mcp = lr_sub.add_parser(
-        "mcp", help="Serve the ontology graph to agents over MCP (needs blitz-cli[locker-room])."
-    )
-    lr_mcp.add_argument("--db", default="./data/ontology.db", help="Ontology SQLite path")
-    lr_mcp.add_argument(
-        "--transport", choices=["stdio", "sse", "http"], default="stdio",
-        help="stdio (agent spawns it, default) or sse/http (bind a port so a "
-        "container can host it and agents connect over the network)",
-    )
-    lr_mcp.add_argument(
-        "--host", default="127.0.0.1",
-        help="Bind host for sse/http (use 0.0.0.0 inside a container)",
-    )
-    lr_mcp.add_argument("--port", type=int, default=8848, help="Bind port for sse/http")
-    lr_mcp.set_defaults(func=_cmd_locker_room_mcp)
-
     return parser
 
 

blitz_cli-0.8.0/blitz_cli/templates/locker_room_README.md.tmpl

@@ -0,0 +1,38 @@
+# locker-room
+
+A locker-room **context node**: a containerized watcher + ontology graph + MCP/web
+server (+ on-demand trainer), scaffolded by `blitz locker-room init`. This dir
+holds only a `docker-compose.yml` that pulls **prebuilt node images** (`:latest`,
+from `sparepartslabs/blitz-locker-room`). Nothing is built locally. Refresh with
+`blitz locker-room pull`.
+
+## Roles (all share `./data`)
+
+- **watch** — ingests coding-agent session transcripts into `data/activity.db`.
+- **graph** — rebuilds the ontology of your playbook-enabled repos/huddles/features
+  and their code lineage into `data/ontology.db` on a loop. Scans `WORKSPACE_DIR`.
+- **mcp** — serves the ontology to agents over MCP (SSE) and a browser graph view.
+- **train** — on-demand QLoRA trainer (profile `train`, needs a GPU).
+
+## Run
+
+```
+blitz locker-room pull          # pull the node images
+blitz locker-room up            # start watch + graph + mcp
+blitz locker-room logs
+blitz locker-room train         # on-demand QLoRA (GPU); outputs -> ./train-out
+blitz locker-room down
+```
+
+Override host paths via env, e.g. `WORKSPACE_DIR=/path/to/code blitz locker-room up`.
+Defaults: `CLAUDE_PROJECTS_DIR=$projects_dir`, `WORKSPACE_DIR=$workspace_dir`.
+
+## Use the node
+
+- **MCP for agents:** the `mcp` service serves SSE at
+  `http://localhost:$${MCP_PORT:-8848}/sse` — add that URL to your agent's MCP config
+  (on a VPN / team host, point agents at the node's address instead of localhost).
+- **Browser graph view:** open `http://localhost:$${MCP_PORT:-8848}/graph`.
+
+The ontology is built and served entirely by the node; there are no host-side
+`ontologize`/`list`/`mcp` commands — query it through the MCP tools or `/graph`.

{blitz_cli-0.7.0 → blitz_cli-0.8.0}/blitz_cli/templates/locker_room_compose.yml.tmpl

@@ -1,9 +1,9 @@
-# Generated by `blitz locker-room init`. The watch/graph/mcp roles all run the
-# SAME core image (blitz-cli); only the command differs. The trainer is the one
-# genuinely-separate image (CUDA/torch base). `:latest` tracks the top of the
-# supported blitz-cli range; `blitz locker-room pull` refreshes it. Manage with
-# `blitz locker-room <up|down|logs|pull|train>` or `docker compose` directly.
-# Override the ${VAR:-default} paths via the shell env.
+# Generated by `blitz locker-room init`. This runs a locker-room context node:
+# the watch/graph/mcp roles all run the SAME core image (a baked entrypoint per
+# role); the trainer is the one genuinely-separate image (CUDA/torch base).
+# `:latest` tracks the top of the supported blitz-cli range; `blitz locker-room
+# pull` refreshes it. Manage with `blitz locker-room <up|down|logs|pull|train>` or
+# `docker compose` directly. Override the ${VAR:-default} paths via the shell env.
 name: locker-room
 
 x-core: &core
@@ -11,39 +11,42 @@ x-core: &core
   restart: unless-stopped
 
 services:
-  # Ingest Claude Code transcripts (ALL projects) -> data/activity.db
+  # Ingest coding-agent transcripts -> data/activity.db
   watch:
     <<: *core
-    command: ["blitz", "locker-room", "watch",
-              "--projects-dir", "/claude-projects",
-              "--db", "/workspace/data/activity.db"]
+    command: ["python", "/app/watch.py"]
     volumes:
       - "$${CLAUDE_PROJECTS_DIR:-$projects_dir}:/claude-projects:ro"
       - ./data:/workspace/data
     environment:
+      PROJECTS_DIR: /claude-projects
+      ACTIVITY_DB_PATH: /workspace/data/activity.db
       WATCH_INTERVAL_SECONDS: "$${WATCH_INTERVAL_SECONDS:-$interval}"
 
   # Rebuild the ontology (repos/huddles/features + code lineage) on a loop.
   graph:
     <<: *core
-    command: ["blitz", "locker-room", "ontologize", "--loop",
-              "--workspace", "/repos",
-              "--db", "/workspace/data/ontology.db",
-              "--interval", "$${ONTOLOGIZE_INTERVAL_SECONDS:-300}"]
+    command: ["python", "/app/ontologize.py"]
     volumes:
       - "$${WORKSPACE_DIR:-$workspace_dir}:/repos:ro"
       - ./data:/workspace/data
+    environment:
+      SCAN_DIR: /repos
+      ONTOLOGY_DB_PATH: /workspace/data/ontology.db
+      ONTOLOGIZE_INTERVAL_SECONDS: "$${ONTOLOGIZE_INTERVAL_SECONDS:-300}"
 
-  # Serve the ontology to agents over SSE.
+  # Serve the ontology to agents over MCP (SSE) + a /graph web view.
   mcp:
     <<: *core
-    command: ["blitz", "locker-room", "mcp",
-              "--transport", "sse", "--host", "0.0.0.0", "--port", "8848",
-              "--db", "/workspace/data/ontology.db"]
+    command: ["python", "/app/server.py"]
     ports:
       - "$${MCP_PORT:-8848}:8848"
     volumes:
       - ./data:/workspace/data:ro
+    environment:
+      ONTOLOGY_DB_PATH: /workspace/data/ontology.db
+      MCP_HOST: 0.0.0.0
+      MCP_PORT: 8848
 
   # On-demand (profile "train"): `docker compose run --rm train` / `make train`.
   train:

{blitz_cli-0.7.0 → blitz_cli-0.8.0}/pyproject.toml

@@ -1,24 +1,21 @@
 [project]
 name = "blitz-cli"
-version = "0.7.0"
+version = "0.8.0"
 description = "Developer CLI for Blitz locker-room: spec-driven playbooks, a codebase/huddle ontology graph with an MCP tool, and the composable watcher/trainer/graph containers."
 readme = "README.md"
 license = { text = "MIT" }
 requires-python = ">=3.9"
 # `rich` (the `blitz activity` session viewer) is the only runtime dependency for
-# the core CLI; everything else uses the stdlib (urllib, sqlite3, string.Template,
-# importlib.resources). The MCP server and the trainer bring their own heavy deps
-# via the optional extras below, so a bare install stays light.
+# the core CLI; everything else uses the stdlib (sqlite3, string.Template,
+# importlib.resources). The ontology engine here is a plain-SQLite library the
+# locker-room node imports; the node (blitz-locker-room images) brings the server
+# deps (mcp). The trainer's heavy ML deps are the optional [train] extra below.
 dependencies = ["rich>=13"]
 
-# The locker-room ontology MCP server (`blitz locker-room mcp`) needs the `mcp`
-# package. It's optional so the core CLI stays dep-light — the ontology graph
-# itself is plain SQLite (stdlib). Install with: pip install 'blitz-cli[locker-room]'.
-[project.optional-dependencies]
-locker-room = ["mcp>=1.0"]
-# The locker-room trainer (`blitz locker-room train-run`, run inside the trainer
+# The locker-room trainer library (blitz_cli._train.run, run inside the trainer
 # image). torch is intentionally omitted -- the CUDA base image ships the matching
 # build, and reinstalling it via pip risks a CPU-only/wrong-arch wheel.
+[project.optional-dependencies]
 train = [
   "transformers==4.48.0",
   "trl==0.13.0",

{blitz_cli-0.7.0 → blitz_cli-0.8.0}/tests/test_cli.py

@@ -1,7 +1,8 @@
 """Argparse-shape tests: these don't exercise command behavior (that's
 covered per-module elsewhere), just that `build_parser()` wires tokens to the
-right handler — the `locker-room init` scaffolder and the `locker-room` verb
-group (make-passthroughs vs native ontologize/watch/list/mcp)."""
+right handler — the `locker-room init` scaffolder and the `locker-room`
+container-lifecycle make-passthroughs. (The runtime commands moved to the
+locker-room node images; the CLI is static commands only.)"""
 
 from blitz_cli import cli
 
@@ -42,25 +43,10 @@ def test_locker_room_make_verbs_resolve_to_the_make_passthrough():
     assert logs.run_dir == "./x"
 
 
-def test_locker_room_native_verbs_resolve_to_their_handlers():
+def test_runtime_commands_are_not_in_the_cli():
+    # The node runs watch/ontologize/mcp; the CLI must not expose them.
     parser = cli.build_parser()
-
-    ont = parser.parse_args(["locker-room", "ontologize", "--workspace", "."])
-    assert ont.func is cli._cmd_locker_room_ontologize
-    assert ont.code is True  # code graph on by default
-    assert ont.loop is False
-
-    watch = parser.parse_args(["locker-room", "watch"])
-    assert watch.func is cli._cmd_locker_room_watch
-
-    lst = parser.parse_args(["locker-room", "list", "--json"])
-    assert lst.func is cli._cmd_locker_room_list
-    assert lst.json is True
-
-    mcp = parser.parse_args(["locker-room", "mcp"])
-    assert mcp.func is cli._cmd_locker_room_mcp
-    assert mcp.transport == "stdio"  # stdio by default; sse/http for the container
-
-    mcp_sse = parser.parse_args(["locker-room", "mcp", "--transport", "sse", "--port", "9000"])
-    assert mcp_sse.transport == "sse"
-    assert mcp_sse.port == 9000
+    import pytest
+    for verb in ("ontologize", "watch", "mcp", "train-run", "list"):
+        with pytest.raises(SystemExit):
+            parser.parse_args(["locker-room", verb])

{blitz_cli-0.7.0 → blitz_cli-0.8.0}/tests/test_scaffold.py

@@ -110,13 +110,14 @@ def test_render_locker_room_compose_pulls_latest_and_shares_core(tmp_path):
     compose = (out / "docker-compose.yml").read_text()
 
     # watch/graph/mcp all run the one core image (shared via a YAML anchor) at
-    # :latest (top of the supported blitz-cli range); only the command differs
+    # :latest (top of the supported blitz-cli range); each runs a baked node
+    # entrypoint (the runtime lives in the images, not the CLI)
     assert "ghcr.io/sparepartslabs/blitz-locker-room/core:latest" in compose
     assert compose.count("<<: *core") == 3
     assert "ghcr.io/sparepartslabs/blitz-locker-room/train:latest" in compose
-    assert '"blitz", "locker-room", "watch"' in compose
-    assert '"blitz", "locker-room", "ontologize", "--loop"' in compose
-    assert '"blitz", "locker-room", "mcp"' in compose
+    assert '"python", "/app/watch.py"' in compose
+    assert '"python", "/app/ontologize.py"' in compose
+    assert '"python", "/app/server.py"' in compose
     # trainer is opt-in via a compose profile
     assert 'profiles: ["train"]' in compose
     # substitutions resolved; no raw template vars leak through

blitz_cli-0.7.0/blitz_cli/_locker_room_mcp.py

@@ -1,117 +0,0 @@
-"""stdio MCP server exposing the locker-room ontology graph to agentic coders.
-
-Run via ``blitz locker-room mcp --db ./data/ontology.db``. Agents add it to their
-MCP config (e.g. ``{"command": "blitz", "args": ["locker-room", "mcp"]}``) and get
-cheap read access to the ontology of playbook-enabled repos, huddles, and
-playbooks. The ``mcp`` package is an optional dependency (``pip install
-blitz-cli[locker-room]``); it is imported lazily so the core CLI stays dep-light.
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-_MISSING_MCP = (
-    "The MCP server needs the optional 'mcp' dependency.\n"
-    "Install it with:  pip install 'blitz-cli[locker-room]'"
-)
-
-
-# CLI transport name -> FastMCP transport. "http" is the modern streamable-HTTP.
-_TRANSPORTS = {"stdio": "stdio", "sse": "sse", "http": "streamable-http"}
-
-
-def serve(db_path: str, transport: str = "stdio", host: str = "127.0.0.1", port: int = 8848) -> int:
-    """Serve the ontology graph at ``db_path`` over MCP.
-
-    ``stdio`` (default) is for an agent that spawns the process locally; ``sse``/
-    ``http`` bind ``host``:``port`` so a container can host the server and agents
-    connect over the network (e.g. the scaffolded `make mcp`)."""
-    import sys
-
-    try:
-        from mcp.server.fastmcp import FastMCP
-    except ImportError:
-        print(_MISSING_MCP, file=sys.stderr)
-        return 2
-
-    from blitz_cli._ontology import OntologyStore
-
-    db = Path(db_path)
-    if not db.exists():
-        print(
-            f"error: no ontology graph at {db}. Run `blitz locker-room ontologize` first.",
-            file=sys.stderr,
-        )
-        return 2
-
-    mcp = FastMCP("blitz-locker-room", host=host, port=port)
-
-    def _store() -> OntologyStore:
-        # Open read-only per call — cheap, and safe against the periodic rebuild.
-        return OntologyStore(db, read_only=True)
-
-    @mcp.tool()
-    def list_workspaces() -> list[dict]:
-        """List the playbook-enabled workspaces in the ontology."""
-        return _store().list_workspaces()
-
-    @mcp.tool()
-    def list_repos() -> list[dict]:
-        """List playbook-enabled repos with their active feature and stage."""
-        return _store().list_repos()
-
-    @mcp.tool()
-    def get_repo(repo: str) -> dict | None:
-        """Get one repo (by node id or filesystem path): agents, playbooks, features."""
-        return _store().get_repo(repo)
-
-    @mcp.tool()
-    def list_huddles() -> list[dict]:
-        """List cross-repo huddles and which repos each coordinates."""
-        return _store().list_huddles()
-
-    @mcp.tool()
-    def get_huddle(huddle: str) -> dict | None:
-        """Get one huddle (by node id): title, status, coordinated repos + roles."""
-        return _store().get_huddle(huddle)
-
-    @mcp.tool()
-    def get_playbooks(repo: str | None = None) -> list[dict]:
-        """List playbooks (slash-commands); pass a repo to scope to that repo."""
-        return _store().get_playbooks(repo)
-
-    @mcp.tool()
-    def neighbors(node_id: str, rel: str | None = None, incoming: bool = False) -> list[dict]:
-        """Generic graph traversal: nodes adjacent to ``node_id`` (optionally by relation)."""
-        return _store().neighbors(node_id, rel=rel, incoming=incoming)
-
-    @mcp.tool()
-    def get_lineage(feature: str, depth: int = 3) -> dict:
-        """Code lineage of a spec/feature (by id or slug): the files/symbols it
-        touches plus the transitive CALLS/IMPORTS closure of that code."""
-        return _store().lineage(feature, max_depth=depth)
-
-    @mcp.tool()
-    def impact_of(node: str, depth: int = 3) -> dict:
-        """Reverse lineage of a file or symbol (by id or path): what transitively
-        depends on it, and which features touch it."""
-        return _store().impact(node, max_depth=depth)
-
-    @mcp.tool()
-    def get_file(path: str) -> dict | None:
-        """Get a File node by id or filesystem path."""
-        return _store().get_file(path)
-
-    @mcp.tool()
-    def get_symbol(symbol_id: str) -> dict | None:
-        """Get a Symbol node (function/class/method) by id."""
-        return _store().get_symbol(symbol_id)
-
-    if transport != "stdio":
-        print(
-            f"blitz locker-room mcp: serving {transport} on {host}:{port} (db {db})",
-            file=sys.stderr,
-        )
-    mcp.run(transport=_TRANSPORTS[transport])
-    return 0

blitz_cli-0.7.0/blitz_cli/templates/locker_room_README.md.tmpl

@@ -1,39 +0,0 @@
-# locker-room
-
-Composable, containerized watcher + trainer + ontology-graph/MCP stack, scaffolded
-by `blitz locker-room init`. This dir holds only a `docker-compose.yml` that pulls
-**prebuilt images** (`:latest`, from `sparepartslabs/blitz-locker-room`, which
-ship the newest blitz-cli in their supported range). Nothing is built locally.
-Refresh with `blitz locker-room pull`.
-
-## Pieces (all share `./data`)
-
-- **watch** — ingests Claude Code session transcripts (ALL projects) into
-  `data/activity.db`.
-- **graph** — rebuilds the ontology of your playbook-enabled repos/huddles/features
-  and their code lineage into `data/ontology.db` on a loop. Scans `WORKSPACE_DIR`.
-- **mcp** — serves the ontology to agents over SSE at `http://localhost:$${MCP_PORT:-8848}/sse`.
-- **train** — on-demand QLoRA trainer (profile `train`, needs a GPU).
-
-## Run
-
-```
-blitz locker-room pull          # pull the pinned images
-blitz locker-room up            # start watch + graph + mcp
-blitz locker-room logs
-blitz locker-room train         # on-demand QLoRA (GPU); outputs -> ./train-out
-blitz locker-room down
-```
-
-Override host paths via env, e.g. `WORKSPACE_DIR=/path/to/code blitz locker-room up`.
-Defaults: `CLAUDE_PROJECTS_DIR=$projects_dir`, `WORKSPACE_DIR=$workspace_dir`.
-
-## Point your agent at the ontology MCP
-
-- **Networked (container):** the `mcp` service serves SSE at
-  `http://localhost:$${MCP_PORT:-8848}/sse` — add that URL to your agent's MCP config.
-- **Local (no container):** `blitz locker-room mcp` speaks stdio; add
-  `{"command": "blitz", "args": ["locker-room", "mcp"]}`.
-
-You can also drive the graph host-side without containers:
-`blitz locker-room ontologize` then `blitz locker-room list`.