codegraph-brain 0.6.0__tar.gz → 0.7.1__tar.gz

codegraph_brain-0.7.1/.claude-plugin/marketplace.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
+  "name": "codegraph-brain",
+  "description": "Code Graph Intelligence for AI agents — a deterministic semantic graph of your codebase, exposed as MCP tools.",
+  "owner": {
+    "name": "Andrey G",
+    "url": "https://github.com/zaebee"
+  },
+  "plugins": [
+    {
+      "name": "cgis",
+      "source": "./plugin",
+      "description": "Gives Claude a deterministic semantic graph of your codebase instead of flat text. Exact callers, real blast radius, and scoped context in a few hundred tokens rather than whole files.",
+      "version": "0.6.0",
+      "category": "development",
+      "author": {
+        "name": "Andrey G",
+        "url": "https://github.com/zaebee"
+      },
+      "homepage": "https://github.com/zaebee/codegraph-brain",
+      "tags": [
+        "code-graph",
+        "static-analysis",
+        "impact-analysis",
+        "architecture",
+        "python",
+        "typescript"
+      ]
+    }
+  ]
+}

{codegraph_brain-0.6.0 → codegraph_brain-0.7.1}/.github/workflows/autodoc.yml

@@ -26,7 +26,6 @@ jobs:
         uses: astral-sh/setup-uv@caf0cab7a618c569241d31dcd442f54681755d39  # v3
         with:
           enable-cache: true
-          python-version: "3.12"
 
       - name: Install CGIS
         run: uv sync

{codegraph_brain-0.6.0 → codegraph_brain-0.7.1}/.github/workflows/ci.yml

@@ -18,7 +18,6 @@ jobs:
         uses: astral-sh/setup-uv@caf0cab7a618c569241d31dcd442f54681755d39  # v3
         with:
           enable-cache: true
-          python-version: "3.12"
 
       - name: Install Dependencies
         run: uv sync --group dev

{codegraph_brain-0.6.0 → codegraph_brain-0.7.1}/.github/workflows/release-please.yml

@@ -51,7 +51,6 @@ jobs:
         uses: astral-sh/setup-uv@caf0cab7a618c569241d31dcd442f54681755d39  # v3
         with:
           enable-cache: true
-          python-version: "3.12"
 
       - name: Build sdist and wheel
         run: uv build

codegraph_brain-0.7.1/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.7.1"
+}

{codegraph_brain-0.6.0 → codegraph_brain-0.7.1}/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [0.7.1](https://github.com/zaebee/codegraph-brain/compare/codegraph-brain-v0.7.0...codegraph-brain-v0.7.1) (2026-07-31)
+
+
+### Documentation
+
+* add privacy policy ([#293](https://github.com/zaebee/codegraph-brain/issues/293)) ([33e45c2](https://github.com/zaebee/codegraph-brain/commit/33e45c2623d6d4a4c05106631fe2815ce1acf62e))
+* add the architecture audit offering ([#296](https://github.com/zaebee/codegraph-brain/issues/296)) ([086396d](https://github.com/zaebee/codegraph-brain/commit/086396dbfa569a5091439811d6ec00e1b094386f))
+
+## [0.7.0](https://github.com/zaebee/codegraph-brain/compare/codegraph-brain-v0.6.0...codegraph-brain-v0.7.0) (2026-07-31)
+
+
+### Features
+
+* **plugin:** ship CGIS as a Claude Code plugin ([#290](https://github.com/zaebee/codegraph-brain/issues/290)) ([c93c7ed](https://github.com/zaebee/codegraph-brain/commit/c93c7ed377943081525c8965bc3a7ce5e5ccf7c1))
+
+
+### Documentation
+
+* **plugin:** disclose the PyPI fetch and the local-only guarantee ([#291](https://github.com/zaebee/codegraph-brain/issues/291)) ([278560c](https://github.com/zaebee/codegraph-brain/commit/278560c74d7d9deae076511ce8659c233c41bcfc))
+* **specs:** finder bug-class taxonomy + a real Resource Management fixture ([#258](https://github.com/zaebee/codegraph-brain/issues/258)) ([#288](https://github.com/zaebee/codegraph-brain/issues/288)) ([1e02d06](https://github.com/zaebee/codegraph-brain/commit/1e02d06a1599d87dbc4958cb6e6db6e0acaae605))
+
 ## [0.6.0](https://github.com/zaebee/codegraph-brain/compare/codegraph-brain-v0.5.0...codegraph-brain-v0.6.0) (2026-07-31)
 
 

{codegraph_brain-0.6.0 → codegraph_brain-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraph-brain
-Version: 0.6.0
+Version: 0.7.1
 Summary: Semantic code graph for AI agents — deterministic FQN resolution, impact analysis and architectural drift gates, exposed over MCP.
 Project-URL: Homepage, https://github.com/zaebee/codegraph-brain
 Project-URL: Repository, https://github.com/zaebee/codegraph-brain
@@ -124,6 +124,19 @@ cgis impact "my_module.core_function" --depth 5
 
 ---
 
+## 🔌 Install as a Claude Code plugin
+
+The fastest path — no config files, no paths to wire up:
+
+```bash
+/plugin marketplace add zaebee/codegraph-brain
+/plugin install cgis@codegraph-brain
+```
+
+That ships the MCP server, a skill that teaches the agent *when* to query the graph instead of reading files, and `/cgis:ingest` to build the graph on first use. The server is pulled from PyPI on demand via `uvx`, so there is nothing to clone or build.
+
+---
+
 ## 🤖 Agent Integration (MCP)
 
 CGIS is designed to be plugged into your AI workflow via the **Model Context Protocol (MCP)**. Once running, your agent gains "Superpowers":
@@ -222,6 +235,20 @@ classDef externalNode fill:#fff3e0,stroke:#e65100,stroke-width:1px,stroke-dashar
 
 ---
 
+## 💼 Architecture Audit
+
+CGIS is free and you can run it yourself. If you would rather have the analysis than the tool, I run a fixed-price audit of your codebase's structure — authorisation coverage, blast radius, coupling, architectural drift — delivered in five working days.
+
+**[Read what's included →](docs/AUDIT.md)** — $2,400 fixed, with an explicit list of what the analysis cannot see.
+
+---
+
+## 🔒 Privacy
+
+CGIS collects nothing: no telemetry, no analytics, no account. Your code and the graph built from it stay on your machine. See [PRIVACY.md](PRIVACY.md).
+
+---
+
 ## 🛠️ Development
 
 ### Requirements

codegraph_brain-0.7.1/PRIVACY.md

@@ -0,0 +1,45 @@
+# Privacy Policy
+
+**Last updated:** 31 July 2026
+
+This policy covers the **CGIS Claude Code plugin** and the **`codegraph-brain`** package it installs.
+
+## The short version
+
+CGIS collects nothing. There is no telemetry, no analytics, no usage reporting, no crash reporting, and no account. Your source code and the graph built from it stay on your machine. Nothing is sent to the author of this software, and there is no server to send it to.
+
+## What runs where
+
+**On your machine.** CGIS parses your source files with Tree-sitter and writes the resulting graph to a SQLite file (`graph.db` by default) in your project directory. Parsing, storage and every query happen locally. The graph contains structural information derived from your code — file paths, symbol names, line numbers and the call relationships between them — and it never leaves your disk.
+
+**Over the network, once.** On first use the plugin fetches the `codegraph-brain` package from the Python Package Index using `uvx`. This is an ordinary package download. PyPI is operated by the Python Software Foundation and applies its own logging and privacy practices to that request; see the [PSF Privacy Notice](https://www.python.org/privacy/). After the download is cached, the plugin makes no further network requests.
+
+## Data we collect
+
+None.
+
+We do not collect, transmit, store or have access to: your source code, the graphs built from it, file or repository names, prompts, tool calls, IP addresses, machine identifiers, usage counts, error reports, or anything else. This is not a matter of policy but of architecture — the software has no code that sends data anywhere, and no infrastructure to receive it.
+
+## Guardian, and when data does leave your machine
+
+The `codegraph-brain` package also contains **Guardian**, a code reviewer that sends diffs and graph context to a large language model. **Guardian is not part of the Claude Code plugin**: the plugin neither ships nor invokes it, and it does nothing unless you configure it and run it deliberately, normally in CI.
+
+If you choose to use Guardian, you select the model provider yourself — Google Gemini, Mistral, Cohere, or a local Ollama instance — and supply your own credentials. In that case the code being reviewed is sent to whichever provider you chose, under **that provider's** privacy policy and terms, not this one. Choosing Ollama keeps it local. We never see that traffic and never receive a copy.
+
+Credentials for those providers are read from your environment and used only to call the provider they belong to. They are not logged, stored or transmitted anywhere else.
+
+## What CGIS never touches
+
+CGIS reads source files under the path you point it at. It does not read your SSH keys, cloud credentials, browser data, keychain, clipboard, shell history, or files outside the directory you ingest. The plugin registers no Claude Code hooks, so it observes nothing about sessions, prompts or tool calls beyond its own tool invocations.
+
+## Children
+
+This is a developer tool and is not directed at children.
+
+## Changes
+
+Material changes to this policy will be recorded in this file, and its history is public in the repository's git log.
+
+## Contact
+
+Questions about privacy: open an issue at [github.com/zaebee/codegraph-brain/issues](https://github.com/zaebee/codegraph-brain/issues), or email zaebuntu@gmail.com.

{codegraph_brain-0.6.0 → codegraph_brain-0.7.1}/README.md

@@ -74,6 +74,19 @@ cgis impact "my_module.core_function" --depth 5
 
 ---
 
+## 🔌 Install as a Claude Code plugin
+
+The fastest path — no config files, no paths to wire up:
+
+```bash
+/plugin marketplace add zaebee/codegraph-brain
+/plugin install cgis@codegraph-brain
+```
+
+That ships the MCP server, a skill that teaches the agent *when* to query the graph instead of reading files, and `/cgis:ingest` to build the graph on first use. The server is pulled from PyPI on demand via `uvx`, so there is nothing to clone or build.
+
+---
+
 ## 🤖 Agent Integration (MCP)
 
 CGIS is designed to be plugged into your AI workflow via the **Model Context Protocol (MCP)**. Once running, your agent gains "Superpowers":
@@ -172,6 +185,20 @@ classDef externalNode fill:#fff3e0,stroke:#e65100,stroke-width:1px,stroke-dashar
 
 ---
 
+## 💼 Architecture Audit
+
+CGIS is free and you can run it yourself. If you would rather have the analysis than the tool, I run a fixed-price audit of your codebase's structure — authorisation coverage, blast radius, coupling, architectural drift — delivered in five working days.
+
+**[Read what's included →](docs/AUDIT.md)** — $2,400 fixed, with an explicit list of what the analysis cannot see.
+
+---
+
+## 🔒 Privacy
+
+CGIS collects nothing: no telemetry, no analytics, no account. Your code and the graph built from it stay on your machine. See [PRIVACY.md](PRIVACY.md).
+
+---
+
 ## 🛠️ Development
 
 ### Requirements

{codegraph_brain-0.6.0 → codegraph_brain-0.7.1}/benchmarks/guardian/CURATION.md

@@ -172,7 +172,6 @@ Ambiguous (3 declined clips, gemini agreed with rationale):
 - **review_head = 6ee175e553c784a363c190e00021be5d365fb8dd** (later commits on
   the branch postdate the review)
 
-GT findings: NONE → recall vacuously 1.0; this PR measures precision only.
 Guardian returned 10 findings, all skeptic-confirmed, all refuted (#279):
 
 - `base.py:102` remove the "unreachable" `raise AssertionError` — **would break
@@ -189,3 +188,21 @@ Guardian returned 10 findings, all skeptic-confirmed, all refuted (#279):
   module has any; it is a plain dict → JSON
 - two test findings on brittle call counts — one's premise is false, the test
   already derives its expectation from `MAX_ATTEMPTS`
+
+### PR 278 — one GT finding added 2026-07-31 (#258)
+
+Originally filed with `findings: []` as a pure precision entry. It now carries one:
+
+- `gemini-client-never-closed` (`src/cgis/guardian/providers/gemini.py`, lines
+  41-58, minor, contract, source `fix-commit`)
+
+The diff **modified** the `client = genai.Client(...)` construction line and left
+both httpx pools unclosed. Guardian reviewed that hunk and returned ten findings,
+none about resource cleanup — Resource Management is a class absent from the
+finder's focus areas (see `docs/specs/2026-07-31-finder-bug-class-taxonomy.md`).
+Fixed later by human-directed review as #283 (`b2ae97b`), which is the
+`fix-commit` provenance.
+
+Precision is unaffected: `matched` stays 0, so the entry still scores `0/10`. The
+addition supplies a recall signal — a real **0/1** where the empty ground truth
+gave a vacuous 1.0.

codegraph_brain-0.7.1/benchmarks/guardian/pr-278.yaml

@@ -0,0 +1,22 @@
+# PR 278 — fix(guardian): explicit request timeout + bounded retry. See CURATION.md.
+# Guardian produced 10 findings, skeptic-confirmed 10/10, ALL refuted (#279).
+# head = review head (the snapshot guardian actually ran on); the two later
+# commits on that branch postdate the review.
+# One GT finding added 2026-07-31 (#258): the diff MODIFIED the genai.Client
+# construction line and left both httpx pools unclosed. Guardian saw that hunk
+# and returned 10 findings, none about resource cleanup — a class absent from
+# the finder's focus areas. Fixed later in #283 (b2ae97b).
+# Precision is unchanged by the addition (matched stays 0, so 0/10); what it adds
+# is a recall signal: 0/1 instead of a vacuous 1.0.
+pr: 278
+base: 2e768cef585f10481970697657b0a9b40a411f47
+head: 6ee175e553c784a363c190e00021be5d365fb8dd
+findings:
+  - id: gemini-client-never-closed
+    file: src/cgis/guardian/providers/gemini.py
+    lines: [41, 58]
+    severity: minor
+    category: contract
+    summary: genai.Client opens a sync and an async httpx pool; neither is closed
+    source: fix-commit
+ambiguous: []

codegraph_brain-0.7.1/docs/AUDIT.md

@@ -0,0 +1,88 @@
+# 🔎 Architecture Audit
+
+**A measured read of your codebase's structure, delivered in five working days. $2,400 fixed.**
+
+CGIS is free and you can run it yourself. This is for teams who want the analysis rather than the tool: someone who has read a lot of these graphs telling you what yours says.
+
+---
+
+## What you get
+
+A written report, the graph itself, and ninety minutes on a call to walk through it.
+
+| Section | Measured with | The question it answers |
+| :--- | :--- | :--- |
+| **Authorisation coverage** | `cgis_audit_reachability` | Does every route handler actually reach its authz guard? |
+| **Blast radius** | `cgis_analyze_impact` | What breaks if we make the three changes we are planning? |
+| **Coupling and god-classes** | `cgis_metrics` | Which parts will fight back hardest during a refactor? |
+| **Architectural drift** | `cgis_drift` | How far has each domain moved from the pattern we said we follow? |
+| **Graph integrity** | `cgis_validate` | How much of this codebase is even amenable to static analysis? |
+
+The first row is the one that usually pays for the engagement. *"Is there a route in our API that reaches the database without passing a permission check?"* is a question with money attached, and nobody checks it by hand because on a few hundred endpoints it is a week of tedium. On the graph it is a traversal.
+
+The report names specific handlers, files and line numbers. It is not a maturity score out of ten.
+
+**You keep the graph.** The `graph.db` is handed over with the report, so your team can keep asking it questions after the engagement ends — including from Claude Code, via the plugin.
+
+---
+
+## How it runs
+
+1. **Access.** A read-only clone or a tarball. No production access, no credentials, no environment.
+2. **Ingest.** Your repositories go into a graph. If resolution comes out unusually low, you hear about it on day one, not in the report.
+3. **Analysis.** The five sections above, plus whatever the graph turns up that I did not expect. That last part is usually the interesting one.
+4. **Report.** Written, specific, with file and line references throughout.
+5. **Walkthrough.** Ninety minutes with whoever needs to act on it. Recorded if you want it.
+
+Five working days from receiving the code.
+
+---
+
+## Price
+
+**$2,400** for up to **three repositories** and **150,000 lines** of Python and TypeScript.
+
+Larger estates are quoted after a look at the tree — the honest number depends on how many resolution edge cases the code has, not on line count alone. There is no hourly rate and no change-order mechanism: the scope above is the scope.
+
+**Included:** the report, the graph, the walkthrough, and one round of follow-up questions by email within thirty days.
+
+**Not included:** implementing the fixes. If you want the drift gates wired into CI or Guardian reviewing your pull requests, that is separate work and we can talk about it after you have read the report — not before.
+
+---
+
+## What this is not
+
+The graph is static structure. That boundary is real, and it is better stated here than discovered halfway through.
+
+- **Not a penetration test.** Authorisation *coverage* means every handler has a static path to a guard. It does not mean the guard is correct, that the logic behind it is sound, or that the endpoint is unexploitable.
+- **Not a runtime analysis.** Nothing is executed. Behaviour that only appears under load, concurrency or real data is out of scope.
+- **Not a business-logic review.** The report says how your code is wired, not whether the wiring implements the right rules.
+- **Not language-complete.** Extractors cover Python and TypeScript. Vue, Astro, Go, Rust and everything else are invisible to the graph, and the report will say which parts of your codebase it could not see.
+- **Not a substitute for judgement.** An empty impact result means *no static callers found*, not *safe to delete*. Dynamic dispatch, registries and framework decorators do not appear in any static graph. The report flags where this matters instead of asserting a safety it cannot see.
+
+Roughly a tenth of call edges in a typical Python codebase cannot be resolved statically at all — they are calls on objects typed at runtime. That number is in the report too, because it tells you how much of the analysis to trust.
+
+---
+
+## Who this is for
+
+**A good fit if:** you have a Python or TypeScript codebase large enough that no one holds it in their head, you are planning a migration or a significant refactor, you are onboarding AI agents onto the codebase and getting confident nonsense back, or someone has asked whether your authorisation is actually complete and nobody can answer.
+
+**A poor fit if:** the codebase is small enough to read, the languages are outside the extractors, or what you actually need is a security assessment — in which case hire a security firm, and this is at best a first pass that tells them where to look.
+
+---
+
+## Evidence
+
+Before commissioning anything, read the [case study](CASE_STUDY.md). It is CGIS run against a real twelve-repository estate — 8,146 commits, four languages — with every figure measured and a section on what the analysis could not cover.
+
+If that page reads as honest to you, this engagement will run the same way. If it does not, we should not work together.
+
+---
+
+## Get in touch
+
+- **Email:** zaebuntu@gmail.com
+- **GitHub:** [open an issue](https://github.com/zaebee/codegraph-brain/issues) — fine for questions about scope, though most people prefer email for anything involving their own codebase
+
+Tell me roughly how large the codebase is and what you are trying to decide. If the audit is not the right thing for your situation, I will say so.

codegraph_brain-0.7.1/docs/specs/2026-07-31-finder-bug-class-taxonomy.md

@@ -0,0 +1,155 @@
+# Finder bug-class taxonomy — gap analysis (#258)
+
+**Status:** research input, **nothing shipped** (2026-07-31)
+**Issue:** #258
+**Lane:** guardian
+
+## What this is, and what it deliberately is not
+
+#258 asks to broaden the finder's focus areas using
+[alibaba/open-code-review](https://github.com/alibaba/open-code-review) (Apache-2.0)
+as a source. This document does the mining and the gap analysis. It **does not
+change the prompt**, and the reason is in the evidence below: a taxonomy checklist
+is not a proven recall lever in this project, and the one adjacent experiment
+regressed a class the finder was reliably catching.
+
+What it produces instead is the two things that were missing before that decision
+can be made: a grounded class list, and a benchmark fixture that contains a real
+instance of the top gap.
+
+## The source
+
+The taxonomy lives in `internal/config/rules/rule_docs/*.md` — per-language rule
+documents, not a single ruleset file. Read `python.md` (language-specific) and
+`default.md` (language-agnostic axes).
+
+`default.md` gives five axes: **Correctness, Security, Performance,
+Maintainability, Test Coverage.**
+
+`python.md` names ten classes:
+
+| # | class | representative rules |
+|---|-------|----------------------|
+| 1 | Obvious Typos or Spelling Errors | misspellings at declaration sites, in log/exception strings |
+| 2 | Dead Code | unreachable branches, unread variables/imports, commented-out blocks |
+| 3 | Mutable Default Arguments and Shared State | `def f(x=[])`, class-level mutables, loop-variable closures |
+| 4 | Boundary and Edge-Case Handling | empty-collection indexing, off-by-one, `None` reaching non-optional code, **float `==`**, `d[k]` vs `d.get(k)` |
+| 5 | Error Handling and Exceptions | bare `except:`, over-broad `except Exception`, silently discarded exceptions, lost traceback, over-wide `try`, `assert` for runtime validation |
+| 6 | Identity and Equality Comparisons | `is` against literals, `== True`, `== None` |
+| 7 | **Resource Management** | files/sockets/locks/connections without `with`; **"resources acquired in a `try` whose `finally` cleanup is missing or incomplete on the error path"** |
+| 8 | Performance | `+=` string building, list membership tests, loop-invariant recomputation, eager f-strings in logging |
+| 9 | Concurrency and Async | check-then-act races, blocking calls inside `async def`, **asyncio tasks created and never awaited**, unsynchronised shared state |
+| 10 | Security-Sensitive Code | `eval`/`exec`, `subprocess(shell=True)`, `pickle`/`yaml.load` without SafeLoader, string-built SQL, secrets in logs, weak crypto, path traversal |
+
+## A framing incompatibility that must not be copied
+
+`python.md` opens with:
+
+> Favor precision over recall: only raise an issue when you are confident it is a
+> real defect, and stay silent when the surrounding context is unclear.
+
+That is the **opposite** of this project's finder, which was deliberately moved to
+the max-recall end in #249 (cap removed, confidence gate dropped, "surface every
+plausible finding") on the recall-then-filter architecture. Their rules also
+repeatedly instruct the model to *confirm with a file read before flagging* —
+an agentic capability our finder does not have.
+
+**Borrow the class names. Do not borrow the framing.** Lifting their preamble
+would undo #249.
+
+## Gap analysis against the current focus areas
+
+`prompts.py` currently names seven: Logic bugs, Unvalidated external data,
+Exact-equality on floats/money, Missing test coverage, Type safety, Library
+boundary contracts, Ontology compliance.
+
+Mapped against the source:
+
+| source class | our coverage |
+|---|---|
+| Boundary and Edge-Case Handling | **covered** — split across "Logic bugs" and "Exact-equality on floats" |
+| Test Coverage | **covered** — "Missing test coverage" |
+| Security-Sensitive Code | **absent** |
+| Concurrency and Async | **absent** |
+| Resource Management | **absent** |
+| Error Handling and Exceptions | **absent** |
+| Mutable Default Arguments | absent |
+| Identity and Equality Comparisons | absent |
+| Dead Code | absent |
+| Performance | absent |
+| — | "Type safety" and "Ontology compliance" are ours alone (mypy-strict and the cgis graph contract); no counterpart, and correctly so |
+
+### Four gaps have evidence in this repository, not just in the abstract
+
+- **Resource Management.** PR #278's diff *modified* the
+  `client = genai.Client(...)` line in `gemini.py` and left both httpx pools
+  unclosed. Guardian reviewed that hunk and returned 10 findings, none about
+  resource cleanup. Fixed later by human-directed review as #283. The source's
+  wording — cleanup "missing or incomplete on the error path" — even covers the
+  follow-on defect found in review of that fix, where a throwing `aclose()`
+  skipped `client.close()`.
+- **Error Handling and Exceptions.** The recording guard added in #279 was written
+  as `except Exception` and was too broad: it swallowed the `ValueError` a
+  mistyped path raises. Caught by an independent reviewer, not by the finder.
+- **Security-Sensitive Code.** This repo parses YAML (`load_ground_truth`,
+  `patterns.yaml`) and shells out to `git` and `gh` throughout `guardian_bench.py`
+  and `collector.py`. Two of the source's rules — `yaml.load` without `SafeLoader`,
+  `subprocess` with `shell=True` — target exactly those surfaces.
+- **Concurrency and Async.** The whole guardian path is async: providers, chunked
+  review, `judge_all`'s concurrency. "asyncio tasks created and never awaited" and
+  "blocking calls inside `async def`" are live risks here.
+
+The remaining four gaps (mutable defaults, identity comparisons, dead code,
+performance) have no observed instance in this codebase. They are candidates, not
+findings.
+
+## Why the prompt is not being changed here
+
+Two independent pieces of evidence:
+
+1. **The lever is unproven.** The deep-research synthesis behind #249 ranked levers
+   by vote; "refined checklist raised recall 0.66→0.93" was **killed 0-3**, and
+   "few-shot beats taxonomy+CoT" was also killed. The defect checklist was
+   explicitly demoted to "a light scaffold, NOT the main bet" — the main bets being
+   cap removal, the max-recall instruction, and sampling.
+2. **The adjacent experiment regressed.** Expanding few-shot with a targeted float
+   example did not crack the float class *and* dropped pr-144 from a median 3/5 to
+   1/5 — it pulled finder attention away from the yaml class it was catching
+   reliably. Reverted on no-evidence-no-ship (#247's over-anchoring lesson, which
+   #258 itself cites).
+
+A compact named-class checklist is a weaker intervention than the few-shot that
+burned us, so it may well be safe. But "may well be" is not a measurement, and
+this system has swung on single-finding deltas before.
+
+## What would make the change decidable
+
+#258 says to validate "once a suitable fixture exists". One now does:
+`benchmarks/guardian/pr-278.yaml` carries a real Resource Management defect
+(`gemini-client-never-closed`) that the current finder demonstrably missed, on a
+diff whose review head is pinned.
+
+Adding the ground truth does not disturb the precision baseline published in #279:
+`precision = matched / (matched + noise)` and matched stays 0, so it remains
+`0/10 = 0.0`. What it adds is a recall signal — a real **0/1** where an empty
+ground truth gave a vacuous 1.0.
+
+The experiment that decides #258:
+
+1. Freeze a finder set on pr-278 with `--record-finder` (no skeptic).
+2. Replay with the current prompt: expect recall 0.0 on that entry.
+3. Add the compact class checklist and re-run the frozen-set comparison across
+   pr-278 **and** the existing entries — the point is not only "does it catch the
+   leak" but "does it stop catching what it caught", which is how the float
+   experiment failed.
+4. Ship only if recall does not regress elsewhere.
+
+Steps 2–4 need a provider key, which is why they are not done here.
+
+## Out of scope
+
+- Any edit to `prompts.py`.
+- Adopting the source's precision-over-recall framing, or its file-read-before-flag
+  instructions (we have no such capability in the finder).
+- Copying rule text verbatim — the source is Apache-2.0 Go/agentic tooling for a
+  different stack; #258 asks for the taxonomy only.

codegraph_brain-0.7.1/plugin/.claude-plugin/plugin.json

@@ -0,0 +1,22 @@
+{
+  "name": "cgis",
+  "displayName": "CGIS — Code Graph Intelligence",
+  "version": "0.6.0",
+  "description": "Gives Claude a deterministic semantic graph of your codebase instead of flat text — exact callers, real blast radius, and scoped context in a few hundred tokens rather than whole files. Runs fully locally: on first use it fetches the open-source codegraph-brain package from PyPI via uvx, then analyses your code on your machine. No hooks, no telemetry, nothing sent anywhere.",
+  "author": {
+    "name": "Andrey G",
+    "url": "https://github.com/zaebee"
+  },
+  "homepage": "https://github.com/zaebee/codegraph-brain",
+  "repository": "https://github.com/zaebee/codegraph-brain",
+  "license": "MIT",
+  "keywords": [
+    "code-graph",
+    "static-analysis",
+    "impact-analysis",
+    "call-graph",
+    "architecture",
+    "python",
+    "typescript"
+  ]
+}

codegraph_brain-0.7.1/plugin/.mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "cgis": {
+      "command": "uvx",
+      "args": ["--from", "codegraph-brain>=0.6.0", "cgis-mcp"]
+    }
+  }
+}

codegraph_brain-0.7.1/plugin/README.md

@@ -0,0 +1,45 @@
+# CGIS — Code Graph Intelligence
+
+Gives Claude a deterministic semantic graph of your codebase instead of flat text. Exact callers, real blast radius, and scoped context in a few hundred tokens rather than whole files.
+
+```bash
+/plugin marketplace add zaebee/codegraph-brain
+/plugin install cgis@codegraph-brain
+```
+
+Then, in any repository, run `/cgis:ingest` once to build the graph.
+
+## What it ships
+
+| Component | What it does |
+| :--- | :--- |
+| MCP server `cgis` | 13 tools: impact analysis, flow tracing, structure, symbol search, metrics, architectural drift, authz reachability |
+| Skill `cgis` | Teaches the agent *when* to query the graph instead of reading files |
+| Skill `/cgis:ingest`  | Builds the graph on first use and reports what it found |
+
+## What it does on your machine
+
+**On first use it downloads a package.** The MCP server is the open-source [`codegraph-brain`](https://pypi.org/project/codegraph-brain/) package (MIT), fetched from PyPI with `uvx --from "codegraph-brain>=0.6.0" cgis-mcp` and cached by `uv` afterwards. That download is the only thing this plugin fetches.
+
+**Everything else is local.** Your source code is parsed on your machine with Tree-sitter, and the resulting graph is written to `graph.db` in your project root. No source, no graph, and no usage data leaves your machine.
+
+- **No hooks.** The plugin registers none, so it observes nothing outside its own tool calls.
+- **No telemetry.** No analytics, usage pings, crash reporting or feature-flag fetches.
+- **No credential access.** It reads source files under the path you point it at; nothing else.
+
+`graph.db` should go in your `.gitignore`.
+
+## Guardian is not part of this plugin
+
+The repository also contains **Guardian**, a graph-aware LLM code reviewer that *does* call an external model provider (Gemini, Mistral, Cohere, or a local Ollama). It is a CI tool, it requires explicit configuration, and this plugin neither ships nor invokes it. See the [repository README](https://github.com/zaebee/codegraph-brain#-guardian-graph-aware-code-review) if you want it in your pipeline.
+
+## Coverage
+
+Extractors exist for **Python** and **TypeScript** (`.py`, `.ts`, `.tsx`). Other languages are invisible to the graph — see the [case study](https://github.com/zaebee/codegraph-brain/blob/main/docs/CASE_STUDY.md) for measured coverage on a real twelve-repository codebase, including what it misses.
+
+## Links
+
+- Source: [github.com/zaebee/codegraph-brain](https://github.com/zaebee/codegraph-brain)
+- Package: [pypi.org/project/codegraph-brain](https://pypi.org/project/codegraph-brain/)
+- Licence: MIT
+- Privacy: [PRIVACY.md](https://github.com/zaebee/codegraph-brain/blob/main/PRIVACY.md) — nothing is collected