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

{blitz_cli-0.6.0 → blitz_cli-0.8.0}/.github/workflows/publish.yml

@@ -28,3 +28,8 @@ jobs:
 
       - name: Publish to PyPI
         uses: pypa/gh-action-pypi-publish@release/v1
+
+  # The locker-room images are published from the sparepartslabs/blitz-locker-room
+  # repo, which declares the blitz-cli versions it supports and builds them itself
+  # (no cross-repo trigger or token here). After releasing a version blitz-cli,
+  # add it to that repo's supported-versions.txt to publish its images.

blitz_cli-0.8.0/.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.pyc
+*.egg-info/
+build/
+dist/
+.venv/
+.pytest_cache/
+
+# stray test artifacts from running the CLI in-repo
+/.claude/
+/.playbooks/

blitz_cli-0.8.0/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: blitz-cli
+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: train
+Requires-Dist: accelerate==1.2.1; extra == 'train'
+Requires-Dist: datasets==3.2.0; extra == 'train'
+Requires-Dist: liger-kernel==0.5.2; extra == 'train'
+Requires-Dist: mlflow==2.19.0; extra == 'train'
+Requires-Dist: peft==0.14.0; extra == 'train'
+Requires-Dist: sentencepiece==0.2.0; extra == 'train'
+Requires-Dist: transformers==4.48.0; extra == 'train'
+Requires-Dist: trl==0.13.0; extra == 'train'
+Description-Content-Type: text/markdown
+
+# blitz-cli
+
+Developer CLI for the Blitz **locker-room**: spec-driven playbooks for your
+coding agent, a local ontology graph of your codebase/huddles/features (served to
+agents over MCP), and the composable containers that keep it fresh.
+
+```bash
+pip install blitz-cli
+```
+
+The core CLI is stdlib plus `rich`. Two optional extras carry heavier deps only
+when you need them: `blitz-cli[locker-room]` (the MCP server) and
+`blitz-cli[train]` (the QLoRA trainer).
+
+Top-level commands: `playbooks`, `locker-room`, `activity`.
+
+## Playbooks: spec-driven development commands
+
+`blitz playbooks init` installs a set of spec-driven-development slash-commands
+into a repo, rendered for whichever agent you use (Claude Code, Cursor, GitHub
+Copilot, Gemini CLI, OpenCode), plus a shared `.playbooks/` working area.
+
+```bash
+blitz playbooks init                 # auto-detect the agent(s) in this repo
+blitz playbooks init --agent claude  # or target one explicitly
+blitz playbooks init --all           # install for every supported agent
+```
+
+The commands are `specify`, `plan`, `tasks`, `implement`, `playbook`, `clarify`,
+and `analyze`. Run at a folder of repos, `init` installs into each repo it finds
+(recursing through non-git folders) and adds a workspace-level `/huddle` command
+for coordinating a feature across repos. Use `--ignore PATH` to skip a repo and
+`--root` to force a single install.
+
+## Locker-room: ontology graph, watcher, trainer, MCP
+
+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 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
+cd locker-room
+blitz locker-room up            # start watch + graph + mcp
+blitz locker-room logs
+```
+
+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.
+
+### The graph agents 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.
+
+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 locker-room train` runs an on-demand QLoRA fine-tune of the watcher corpus
+in the trainer container (needs a GPU); adapters land in `./train-out`. Override
+the base model with `BASE_MODEL_HF` or `blitz locker-room init --base-model`.
+
+## Activity: replay a coding-agent session
+
+`blitz activity` reads your coding agent's own local session transcripts
+(currently Claude Code's, at `~/.claude/projects`) for the current repo and
+replays each prompt alongside the actions taken to resolve it (tool calls,
+sub-agents) and the final response:
+
+```bash
+blitz activity --list               # sessions for this repo, most recent first
+blitz activity                      # the most recent session's timeline
+blitz activity <session-id-prefix>  # a specific session
+blitz activity --full               # untruncated prompts/responses/tool I/O
+blitz activity --html report.html   # also write a self-contained HTML report
+```
+
+The terminal view is compact by default; `--full` shows untruncated text. The
+HTML report includes each action's full tool input/output, collapsed per action.
+Each turn shows its raw token usage and, where a pre-edit backup exists, a real
+diff of what an `Edit`/`Write` changed. Point at a different transcript root with
+`--sessions-dir`. This only reads local session data, no project id or API key.

blitz_cli-0.8.0/README.md

@@ -0,0 +1,99 @@
+# blitz-cli
+
+Developer CLI for the Blitz **locker-room**: spec-driven playbooks for your
+coding agent, a local ontology graph of your codebase/huddles/features (served to
+agents over MCP), and the composable containers that keep it fresh.
+
+```bash
+pip install blitz-cli
+```
+
+The core CLI is stdlib plus `rich`. Two optional extras carry heavier deps only
+when you need them: `blitz-cli[locker-room]` (the MCP server) and
+`blitz-cli[train]` (the QLoRA trainer).
+
+Top-level commands: `playbooks`, `locker-room`, `activity`.
+
+## Playbooks: spec-driven development commands
+
+`blitz playbooks init` installs a set of spec-driven-development slash-commands
+into a repo, rendered for whichever agent you use (Claude Code, Cursor, GitHub
+Copilot, Gemini CLI, OpenCode), plus a shared `.playbooks/` working area.
+
+```bash
+blitz playbooks init                 # auto-detect the agent(s) in this repo
+blitz playbooks init --agent claude  # or target one explicitly
+blitz playbooks init --all           # install for every supported agent
+```
+
+The commands are `specify`, `plan`, `tasks`, `implement`, `playbook`, `clarify`,
+and `analyze`. Run at a folder of repos, `init` installs into each repo it finds
+(recursing through non-git folders) and adds a workspace-level `/huddle` command
+for coordinating a feature across repos. Use `--ignore PATH` to skip a repo and
+`--root` to force a single install.
+
+## Locker-room: ontology graph, watcher, trainer, MCP
+
+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 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
+cd locker-room
+blitz locker-room up            # start watch + graph + mcp
+blitz locker-room logs
+```
+
+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.
+
+### The graph agents 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.
+
+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 locker-room train` runs an on-demand QLoRA fine-tune of the watcher corpus
+in the trainer container (needs a GPU); adapters land in `./train-out`. Override
+the base model with `BASE_MODEL_HF` or `blitz locker-room init --base-model`.
+
+## Activity: replay a coding-agent session
+
+`blitz activity` reads your coding agent's own local session transcripts
+(currently Claude Code's, at `~/.claude/projects`) for the current repo and
+replays each prompt alongside the actions taken to resolve it (tool calls,
+sub-agents) and the final response:
+
+```bash
+blitz activity --list               # sessions for this repo, most recent first
+blitz activity                      # the most recent session's timeline
+blitz activity <session-id-prefix>  # a specific session
+blitz activity --full               # untruncated prompts/responses/tool I/O
+blitz activity --html report.html   # also write a self-contained HTML report
+```
+
+The terminal view is compact by default; `--full` shows untruncated text. The
+HTML report includes each action's full tool input/output, collapsed per action.
+Each turn shows its raw token usage and, where a pre-edit backup exists, a real
+diff of what an `Edit`/`Write` changed. Point at a different transcript root with
+`--sessions-dir`. This only reads local session data, no project id or API key.

{blitz_cli-0.6.0 → blitz_cli-0.8.0}/blitz_cli/_activity.py

@@ -1,12 +1,13 @@
-"""`blitz activity` — replay a Claude Code session: what you asked, and how it
+"""`blitz activity` — replay a coding-agent session: what you asked, and how it
 was resolved.
 
-Reads Claude Code's own transcript store at ~/.claude/projects/<dash-encoded-
-cwd>/<session-id>.jsonl (not related to blitz's own captured LLM traces in
-_local.py's traces.db — this is Claude Code's conversation log, a different
-data source entirely). One JSON object per line; the schema isn't publicly
-documented, so this module errs on the side of skipping/ignoring unrecognized
-shapes rather than raising.
+The currently-supported transcript format is Claude Code's, at
+~/.claude/projects/<dash-encoded-cwd>/<session-id>.jsonl (an agent conversation
+log, distinct from any captured LLM traces). One JSON object per line; the schema
+isn't publicly documented, so this module errs on the side of skipping/ignoring
+unrecognized shapes rather than raising. Other agents' local transcript formats
+(Codex, OpenCode, ...) are not parsed yet; a future adapter would normalize them
+into the same session/turn shape this module already produces.
 """
 
 from __future__ import annotations
@@ -76,7 +77,8 @@ class SessionSummary:
     turn_count: int
 
 
-def default_claude_projects_dir() -> Path:
+def default_sessions_dir() -> Path:
+    # Claude Code is the currently-supported transcript source.
     return Path.home() / ".claude" / "projects"
 
 
@@ -92,8 +94,8 @@ def encode_project_path(path: Path) -> str:
     return str(path.resolve()).replace("/", "-")
 
 
-def resolve_project_dir(claude_dir: Path, project_path: Path) -> Optional[Path]:
-    candidate = claude_dir / encode_project_path(project_path)
+def resolve_project_dir(sessions_dir: Path, project_path: Path) -> Optional[Path]:
+    candidate = sessions_dir / encode_project_path(project_path)
     return candidate if candidate.is_dir() else None
 
 

blitz_cli-0.8.0/blitz_cli/_code_graph.py

@@ -0,0 +1,278 @@
+"""Static code graph for the locker-room ontology.
+
+Per repo, emits File/Symbol nodes and DEFINES/DECLARES/IMPORTS/CALLS edges so a
+spec's git-diff lineage (Feature -TOUCHES-> File/Symbol) can be walked out into
+the code that implements it. Python is parsed with stdlib ``ast`` (symbols +
+imports + best-effort intra-repo calls); JS/TS get File + relative-IMPORTS only;
+other recognized source files get a bare File node. A noise-dir prune list keeps
+big repos cheap, and a per-file sha cache (owned by the store) means only changed
+files are re-parsed on the periodic refresh.
+"""
+
+from __future__ import annotations
+
+import ast
+import hashlib
+import json
+import os
+from pathlib import Path
+
+# Directories that never hold first-party source worth indexing (pruned in place
+# so os.walk doesn't descend into them). Kept self-contained here so the code
+# graph has no cross-feature dependency.
+_PRUNE_DIRS = {
+    ".git", ".hg", ".svn", "node_modules", "venv", ".venv", "env", ".env",
+    "__pycache__", ".mypy_cache", ".pytest_cache", ".ruff_cache", "dist",
+    "build", ".next", ".nuxt", "out", "coverage", ".tox", "site-packages",
+    ".idea", ".vscode",
+}
+
+_PY_EXT = {".py"}
+_JS_EXT = {".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"}
+# Other first-party source we index at file level only (no symbols/imports).
+_OTHER_EXT = {
+    ".go", ".rs", ".java", ".kt", ".rb", ".php", ".c", ".h", ".cc", ".cpp",
+    ".hpp", ".cs", ".swift", ".scala", ".sh", ".bash", ".sql", ".proto",
+}
+_MAX_FILE_BYTES_DEFAULT = 1_000_000
+
+
+def _lang_for(ext: str) -> str | None:
+    if ext in _PY_EXT:
+        return "python"
+    if ext in _JS_EXT:
+        return "js"
+    if ext in _OTHER_EXT:
+        return "other"
+    return None
+
+
+def _iter_files(repo: Path):
+    """Yield (path, lang) for indexable files under repo, pruning noise dirs."""
+    for dirpath, dirnames, filenames in os.walk(repo):
+        dirnames[:] = [d for d in dirnames if d not in _PRUNE_DIRS and not d.startswith(".")]
+        for fn in filenames:
+            lang = _lang_for(Path(fn).suffix)
+            if lang:
+                yield Path(dirpath) / fn, lang
+
+
+def file_id(path: Path) -> str:
+    return f"file:{path.resolve()}"
+
+
+def symbol_id(path: Path, qualname: str) -> str:
+    return f"sym:{path.resolve()}:{qualname}"
+
+
+# --- python extraction -------------------------------------------------------
+
+
+def _resolve_module(repo_root: Path, file_path: Path, module: str, level: int) -> Path | None:
+    """Resolve a Python import target to a repo file (module.py or pkg/__init__.py)."""
+    if level and level > 0:
+        base = file_path.parent
+        for _ in range(level - 1):
+            base = base.parent
+        parts = module.split(".") if module else []
+        target = base.joinpath(*parts)
+    else:
+        parts = module.split(".") if module else []
+        if not parts:
+            return None
+        target = repo_root.joinpath(*parts)
+    for cand in (target.with_suffix(".py"), target / "__init__.py"):
+        if cand.is_file():
+            return cand
+    return None
+
+
+class _PyVisitor(ast.NodeVisitor):
+    def __init__(self, repo_root: Path, path: Path):
+        self.repo_root = repo_root
+        self.path = path
+        self.fid = file_id(path)
+        self.stack: list[str] = []
+        self.symbols: list[dict] = []  # {qualname,name,kind,lineno,endline,node,parent}
+        # alias name -> ("module", modfile) or ("symbol", modfile, realname)
+        self.aliases: dict[str, tuple] = {}
+        self.import_files: set[str] = set()
+        self.module_funcs: set[str] = set()  # top-level def names in this file
+
+    # -- imports --
+    def visit_Import(self, node: ast.Import) -> None:
+        for a in node.names:
+            modfile = _resolve_module(self.repo_root, self.path, a.name, 0)
+            bound = (a.asname or a.name.split(".")[0])
+            if modfile:
+                self.aliases[bound] = ("module", modfile)
+                self.import_files.add(str(modfile.resolve()))
+        self.generic_visit(node)
+
+    def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
+        modfile = _resolve_module(self.repo_root, self.path, node.module or "", node.level or 0)
+        if modfile:
+            self.import_files.add(str(modfile.resolve()))
+            for a in node.names:
+                if a.name == "*":
+                    continue
+                bound = a.asname or a.name
+                self.aliases[bound] = ("symbol", modfile, a.name)
+        self.generic_visit(node)
+
+    # -- defs --
+    def _add_symbol(self, node, kind: str) -> None:
+        name = node.name
+        qual = ".".join(self.stack + [name])
+        parent = ".".join(self.stack) if self.stack else None
+        if not self.stack:
+            self.module_funcs.add(name)
+        self.symbols.append({
+            "qualname": qual, "name": name, "kind": kind,
+            "lineno": node.lineno, "endline": getattr(node, "end_lineno", node.lineno),
+            "node": node, "parent": parent,
+        })
+        self.stack.append(name)
+        self.generic_visit(node)
+        self.stack.pop()
+
+    def visit_FunctionDef(self, node) -> None:
+        self._add_symbol(node, "method" if self.stack else "function")
+
+    def visit_AsyncFunctionDef(self, node) -> None:
+        self._add_symbol(node, "method" if self.stack else "function")
+
+    def visit_ClassDef(self, node) -> None:
+        self._add_symbol(node, "class")
+
+    # -- calls (resolved after the tree is walked) --
+    def _resolve_call(self, call: ast.Call) -> str | None:
+        f = call.func
+        if isinstance(f, ast.Name):
+            got = self.aliases.get(f.id)
+            if got and got[0] == "symbol":
+                return symbol_id(got[1], got[2])
+            if f.id in self.module_funcs:
+                return symbol_id(self.path, f.id)
+        elif isinstance(f, ast.Attribute) and isinstance(f.value, ast.Name):
+            got = self.aliases.get(f.value.id)
+            if got and got[0] == "module":
+                return symbol_id(got[1], f.attr)
+        return None
+
+    def call_edges(self) -> list[tuple[str, str]]:
+        edges: list[tuple[str, str]] = []
+        for sym in self.symbols:
+            if sym["kind"] == "class":
+                continue
+            src = symbol_id(self.path, sym["qualname"])
+            for sub in ast.walk(sym["node"]):
+                if isinstance(sub, ast.Call):
+                    tgt = self._resolve_call(sub)
+                    if tgt and tgt != src:
+                        edges.append((src, tgt))
+        return edges
+
+
+def _extract_python(repo_root: Path, path: Path, repo_id: str, text: str, lang: str) -> dict:
+    nodes: list[list] = [[file_id(path), "File",
+                          {"path": str(path), "repo": str(repo_root), "lang": lang}]]
+    edges: list[list] = [[repo_id, file_id(path), "HAS_FILE", {}]]
+    try:
+        tree = ast.parse(text)
+    except (SyntaxError, ValueError):
+        return {"nodes": nodes, "edges": edges}  # File node only
+    v = _PyVisitor(repo_root, path)
+    v.visit(tree)
+    for sym in v.symbols:
+        sid = symbol_id(path, sym["qualname"])
+        nodes.append([sid, "Symbol", {
+            "name": sym["name"], "qualname": sym["qualname"], "kind": sym["kind"],
+            "file": str(path), "lineno": sym["lineno"], "endline": sym["endline"],
+        }])
+        edges.append([file_id(path), sid, "DEFINES", {}])
+        if sym["parent"]:
+            edges.append([symbol_id(path, sym["parent"]), sid, "DECLARES", {}])
+    for imp in sorted(v.import_files):
+        edges.append([file_id(path), f"file:{imp}", "IMPORTS", {}])
+    for src, tgt in v.call_edges():
+        edges.append([src, tgt, "CALLS", {}])
+    return {"nodes": nodes, "edges": edges}
+
+
+# --- js / other extraction ---------------------------------------------------
+
+import re
+
+_JS_IMPORT = re.compile(r"""(?:import\s.*?from\s*|import\s*|require\s*\(\s*)['"]([^'"]+)['"]""")
+_JS_RESOLVE_EXT = (".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs")
+
+
+def _resolve_js(path: Path, spec: str) -> Path | None:
+    if not spec.startswith("."):
+        return None  # only intra-repo relative imports
+    target = (path.parent / spec).resolve()
+    cands = [target] + [target.with_suffix(e) for e in _JS_RESOLVE_EXT]
+    cands += [target / ("index" + e) for e in _JS_RESOLVE_EXT]
+    for c in cands:
+        if c.is_file():
+            return c
+    return None
+
+
+def _extract_js(repo_root: Path, path: Path, repo_id: str, text: str, lang: str) -> dict:
+    nodes = [[file_id(path), "File", {"path": str(path), "repo": str(repo_root), "lang": lang}]]
+    edges = [[repo_id, file_id(path), "HAS_FILE", {}]]
+    seen: set[str] = set()
+    for m in _JS_IMPORT.finditer(text):
+        tgt = _resolve_js(path, m.group(1))
+        if tgt and str(tgt) not in seen:
+            seen.add(str(tgt))
+            edges.append([file_id(path), file_id(tgt), "IMPORTS", {}])
+    return {"nodes": nodes, "edges": edges}
+
+
+def _extract_other(repo_root: Path, path: Path, repo_id: str, text: str, lang: str) -> dict:
+    return {
+        "nodes": [[file_id(path), "File", {"path": str(path), "repo": str(repo_root), "lang": lang}]],
+        "edges": [[repo_id, file_id(path), "HAS_FILE", {}]],
+    }
+
+
+_EXTRACTORS = {"python": _extract_python, "js": _extract_js, "other": _extract_other}
+
+
+# --- driver ------------------------------------------------------------------
+
+
+def scan_repo(store, repo: Path, repo_id: str, max_file_bytes: int = _MAX_FILE_BYTES_DEFAULT) -> None:
+    """Extract the code graph for ``repo`` into ``store`` (with a per-file cache).
+
+    ``store`` must provide file_cache_get/file_cache_put/file_cache_prune plus
+    add_node/add_edge (see OntologyStore). Only files whose content sha changed
+    since the last run are re-parsed; the rest replay cached rows.
+    """
+    repo = repo.resolve()
+    visited: list[str] = []
+    for path, lang in _iter_files(repo):
+        try:
+            raw = path.read_bytes()
+        except OSError:
+            continue
+        if len(raw) > max_file_bytes:
+            continue
+        abspath = str(path.resolve())
+        visited.append(abspath)
+        sha = hashlib.sha1(raw).hexdigest()
+        cached = store.file_cache_get(abspath)
+        if cached and cached[0] == sha:
+            rows = json.loads(cached[1])
+        else:
+            text = raw.decode("utf-8", errors="replace")
+            rows = _EXTRACTORS[lang](repo, path, repo_id, text, lang)
+            store.file_cache_put(abspath, sha, json.dumps(rows))
+        for nid, label, props in rows["nodes"]:
+            store.add_node(nid, label, props)
+        for src, dst, rel, props in rows["edges"]:
+            store.add_edge(src, dst, rel, props)
+    store.file_cache_prune(str(repo), set(visited))

blitz_cli-0.6.0/blitz_cli/_codeassist.py → blitz_cli-0.8.0/blitz_cli/_corpus.py

@@ -1,5 +1,5 @@
 """Convert Claude Code activity (parsed by `_activity.py`) into a fine-tuning
-corpus stored in SQLite, for the `blitz scaffold code-assist` watcher
+corpus stored in SQLite, for the `blitz locker-room watch`
 container.
 
 This is a wholly separate store from `_local.py`'s `spans` table —
@@ -137,7 +137,7 @@ def turn_to_row(
 
 
 class TurnStore:
-    """Writer for the code-assist fine-tuning corpus. Unlike _local.py's
+    """Writer for the locker-room activity fine-tuning corpus. Unlike _local.py's
     read-only LocalStore (which assumes an externally-stubbed db and returns
     None if missing), this store owns its schema and creates it on first
     connect — it's the one and only writer, structurally closer to
@@ -244,7 +244,7 @@ def ingest_once(projects_dir: Path, store: TurnStore, print_fn=print) -> int:
                 raw_text = session_path.read_text(encoding="utf-8", errors="replace")
                 session = _activity.parse_session(session_path)
             except Exception as exc:  # a malformed/mid-write file must never kill the watcher
-                print_fn(f"[code-assist] skip {session_path}: {exc}")
+                print_fn(f"[watch] skip {session_path}: {exc}")
                 continue
 
             store.upsert_raw_session(