brainiac-cli 0.16.0__py3-none-any.whl

brain/vectors.py

@@ -0,0 +1,225 @@
+"""Dense-vector backend ADAPTER INTERFACE + a fallback backend.
+
+CORE-01 hardening (r2-codex): "Define an adapter interface with a fallback
+vector backend BEFORE any retrieval code is written." sqlite-vec is pre-v1
+(breaking changes expected) and may fail to load on a locked Windows install or
+an unbuilt Cowork VM. The retrieval layer therefore depends ONLY on the
+``VectorBackend`` protocol, never on sqlite-vec directly.
+
+Two backends ship:
+  * ``SqliteVecBackend``    — sqlite-vec ``vec0`` virtual table (fast ANN). Used
+                              when the extension loads.
+  * ``BruteForceBackend``   — vectors stored as BLOBs in a plain table; cosine
+                              computed in Python. No extension, works with ANY
+                              sqlite build (including a future SQLCipher build),
+                              correct everywhere. The guaranteed fallback.
+
+``get_backend()`` selects sqlite-vec when available and degrades to brute force
+otherwise — the caller's retrieval code is identical either way.
+"""
+from __future__ import annotations
+
+import math
+import sqlite3
+import struct
+from typing import Protocol, Sequence, runtime_checkable
+
+
+def pack_vector(vec: Sequence[float]) -> bytes:
+    return struct.pack(f"{len(vec)}f", *vec)
+
+
+def unpack_vector(blob: bytes) -> list[float]:
+    return list(struct.unpack(f"{len(blob) // 4}f", blob))
+
+
+def cosine(a: Sequence[float], b: Sequence[float]) -> float:
+    dot = sum(x * y for x, y in zip(a, b))
+    na = math.sqrt(sum(x * x for x in a))
+    nb = math.sqrt(sum(y * y for y in b))
+    if na == 0.0 or nb == 0.0:
+        return 0.0
+    return dot / (na * nb)
+
+
+@runtime_checkable
+class VectorBackend(Protocol):
+    """The only contract the retrieval layer is allowed to depend on."""
+
+    name: str
+
+    def setup(self, conn: sqlite3.Connection, dim: int) -> None: ...
+    def upsert(self, conn: sqlite3.Connection, rowid: int, vec: Sequence[float]) -> None: ...
+    def delete(self, conn: sqlite3.Connection, rowid: int) -> None: ...
+    def delete_all(self, conn: sqlite3.Connection) -> None: ...
+    def search(
+        self, conn: sqlite3.Connection, query: Sequence[float], k: int
+    ) -> list[tuple[int, float]]:
+        """Return [(rowid, similarity 0..1)] best-first."""
+
+    def get_vectors(
+        self, conn: sqlite3.Connection, rowids: Sequence[int]
+    ) -> dict[int, list[float]]:
+        """Fetch stored vectors for the given chunk rowids (missing rowids are
+        simply absent from the result). Used by retrieval-time diversity /
+        near-duplicate suppression, which needs candidate-vs-candidate cosine
+        without re-embedding."""
+
+
+class SqliteVecBackend:
+    name = "sqlite-vec"
+
+    def __init__(self) -> None:
+        import sqlite_vec  # noqa: F401  (import-time check; raises if absent)
+
+        self._sqlite_vec = sqlite_vec
+        self._dim = 0
+
+    @staticmethod
+    def available() -> bool:
+        try:
+            import sqlite_vec  # noqa: F401
+
+            return True
+        except Exception:
+            return False
+
+    @staticmethod
+    def loadable() -> bool:
+        """True iff the native ``vec0`` extension actually DLOPENS — not just that
+        the Python wrapper imports. A packaged build can ship the ``sqlite_vec``
+        Python module but omit the native ``vec0.dylib``/``.so``/``.dll`` (observed
+        S10: macOS PyInstaller bundle). ``available()`` (import-only) returns True
+        in that case but ``setup()`` then crashes on dlopen — so the ``auto``
+        selector probes a real load here and degrades to brute-force on failure."""
+        try:
+            import sqlite3 as _sq
+
+            be = SqliteVecBackend()
+            con = _sq.connect(":memory:")
+            try:
+                be.load_into(con)
+                return True
+            finally:
+                con.close()
+        except Exception:
+            return False
+
+    def load_into(self, conn: sqlite3.Connection) -> None:
+        conn.enable_load_extension(True)
+        self._sqlite_vec.load(conn)
+        conn.enable_load_extension(False)
+
+    def setup(self, conn: sqlite3.Connection, dim: int) -> None:
+        self._dim = dim
+        self.load_into(conn)
+        conn.execute("DROP TABLE IF EXISTS vec_index")
+        conn.execute(f"CREATE VIRTUAL TABLE vec_index USING vec0(embedding float[{dim}])")
+
+    def upsert(self, conn: sqlite3.Connection, rowid: int, vec: Sequence[float]) -> None:
+        conn.execute("DELETE FROM vec_index WHERE rowid = ?", (rowid,))
+        conn.execute(
+            "INSERT INTO vec_index(rowid, embedding) VALUES (?, ?)",
+            (rowid, pack_vector(vec)),
+        )
+
+    def delete(self, conn: sqlite3.Connection, rowid: int) -> None:
+        conn.execute("DELETE FROM vec_index WHERE rowid = ?", (rowid,))
+
+    def delete_all(self, conn: sqlite3.Connection) -> None:
+        conn.execute("DELETE FROM vec_index")
+
+    def search(self, conn, query, k):
+        # Express k as an ``AND k = ?`` MATCH constraint, NOT a bound ``LIMIT ?``.
+        # Newer sqlite (>=~3.41) pushes a parameterised LIMIT into vec0's query
+        # planner so ``ORDER BY distance LIMIT ?`` works, but older builds (e.g.
+        # the Cowork device VM's bundled sqlite) do not, and vec0 then raises
+        # "A LIMIT or 'k = ?' constraint is required on vec0 knn queries". The
+        # ``k = ?`` form is sqlite-vec's canonical KNN API and is version-robust.
+        rows = conn.execute(
+            "SELECT rowid, distance FROM vec_index "
+            "WHERE embedding MATCH ? AND k = ? ORDER BY distance",
+            (pack_vector(query), k),
+        ).fetchall()
+        # vec0 default metric is L2; convert to a 0..1 similarity for a uniform
+        # contract with the brute-force backend.
+        return [(int(r[0]), 1.0 / (1.0 + float(r[1]))) for r in rows]
+
+    def get_vectors(self, conn, rowids):
+        if not rowids:
+            return {}
+        qmarks = ",".join("?" * len(rowids))
+        out: dict[int, list[float]] = {}
+        for rowid, blob in conn.execute(
+            f"SELECT rowid, embedding FROM vec_index WHERE rowid IN ({qmarks})",
+            tuple(int(r) for r in rowids),
+        ):
+            out[int(rowid)] = unpack_vector(blob)
+        return out
+
+
+class BruteForceBackend:
+    """Pure-Python fallback. Stores vectors as BLOBs in a normal table and ranks
+    by cosine in Python. Slower at scale but correct and dependency-free; the
+    SQLCipher-safe path (no loadable extension required)."""
+
+    name = "brute-force"
+
+    def setup(self, conn: sqlite3.Connection, dim: int) -> None:
+        conn.execute("DROP TABLE IF EXISTS vec_blob")
+        conn.execute(
+            "CREATE TABLE vec_blob (rowid INTEGER PRIMARY KEY, embedding BLOB NOT NULL)"
+        )
+
+    def upsert(self, conn: sqlite3.Connection, rowid: int, vec: Sequence[float]) -> None:
+        conn.execute(
+            "INSERT OR REPLACE INTO vec_blob(rowid, embedding) VALUES (?, ?)",
+            (rowid, pack_vector(vec)),
+        )
+
+    def delete(self, conn: sqlite3.Connection, rowid: int) -> None:
+        conn.execute("DELETE FROM vec_blob WHERE rowid = ?", (rowid,))
+
+    def delete_all(self, conn: sqlite3.Connection) -> None:
+        conn.execute("DELETE FROM vec_blob")
+
+    def search(self, conn, query, k):
+        scored = [
+            (int(rowid), cosine(query, unpack_vector(blob)))
+            for rowid, blob in conn.execute("SELECT rowid, embedding FROM vec_blob")
+        ]
+        scored.sort(key=lambda t: t[1], reverse=True)
+        return scored[:k]
+
+    def get_vectors(self, conn, rowids):
+        if not rowids:
+            return {}
+        qmarks = ",".join("?" * len(rowids))
+        out: dict[int, list[float]] = {}
+        for rowid, blob in conn.execute(
+            f"SELECT rowid, embedding FROM vec_blob WHERE rowid IN ({qmarks})",
+            tuple(int(r) for r in rowids),
+        ):
+            out[int(rowid)] = unpack_vector(blob)
+        return out
+
+
+def get_backend(prefer: str = "auto") -> VectorBackend:
+    """Adapter selection. ``auto`` uses sqlite-vec if loadable, else brute force.
+
+    ``prefer`` may also be ``"sqlite-vec"`` (raises if unavailable) or
+    ``"brute-force"`` (forces the fallback — used by tests and SQLCipher mode).
+    """
+    if prefer == "brute-force":
+        return BruteForceBackend()
+    if prefer == "sqlite-vec":
+        return SqliteVecBackend()
+    # auto — probe a REAL extension load (not just the import) so a packaged
+    # build that ships the wrapper but omits the native vec0 lib degrades to
+    # brute-force instead of crashing at setup() (S10 finding).
+    if SqliteVecBackend.available() and SqliteVecBackend.loadable():
+        try:
+            return SqliteVecBackend()
+        except Exception:
+            pass
+    return BruteForceBackend()

brainiac_cli-0.16.0.dist-info/METADATA

@@ -0,0 +1,306 @@
+Metadata-Version: 2.4
+Name: brainiac-cli
+Version: 0.16.0
+Summary: Brainiac — local any-LLM second-brain core engine + brain CLI (Markdown truth, derived SQLite index).
+License-Expression: Apache-2.0
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: onnxruntime>=1.17
+Requires-Dist: tokenizers>=0.15
+Requires-Dist: numpy<3,>=1.24
+Requires-Dist: sqlite-vec>=0.1.6
+Requires-Dist: huggingface-hub>=0.20
+Requires-Dist: cryptography>=41
+Requires-Dist: PyYAML>=6
+Requires-Dist: regex>=2023.0.0
+Requires-Dist: keyring>=24; sys_platform == "win32"
+Requires-Dist: pypdf>=4.0
+Requires-Dist: python-docx>=1.1
+Requires-Dist: python-pptx>=0.6.23
+Requires-Dist: openpyxl>=3.1
+Requires-Dist: Pillow>=10
+Provides-Extra: vec
+Requires-Dist: sqlite-vec>=0.1.6; extra == "vec"
+Provides-Extra: audit
+Requires-Dist: cryptography>=41; extra == "audit"
+Provides-Extra: embed
+Requires-Dist: fastembed>=0.3; extra == "embed"
+Provides-Extra: corporate
+Requires-Dist: onnxruntime>=1.17; extra == "corporate"
+Requires-Dist: tokenizers>=0.15; extra == "corporate"
+Requires-Dist: numpy<3,>=1.24; extra == "corporate"
+Requires-Dist: sqlite-vec>=0.1.6; extra == "corporate"
+Requires-Dist: huggingface-hub>=0.20; extra == "corporate"
+Requires-Dist: cryptography>=41; extra == "corporate"
+Requires-Dist: PyYAML>=6; extra == "corporate"
+Provides-Extra: yaml
+Requires-Dist: PyYAML>=6; extra == "yaml"
+Provides-Extra: ingest
+Requires-Dist: pypdf>=4.0; extra == "ingest"
+Requires-Dist: python-docx>=1.1; extra == "ingest"
+Requires-Dist: python-pptx>=0.6.23; extra == "ingest"
+Requires-Dist: openpyxl>=3.1; extra == "ingest"
+Requires-Dist: Pillow>=10; extra == "ingest"
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: build>=1; extra == "dev"
+Provides-Extra: eval
+Requires-Dist: ranx>=0.3.20; extra == "eval"
+Requires-Dist: numpy>=1.24; extra == "eval"
+Provides-Extra: quant-tools
+Requires-Dist: onnx>=1.14; extra == "quant-tools"
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.0; extra == "mcp"
+Provides-Extra: index
+Requires-Dist: regex>=2023.0.0; extra == "index"
+Dynamic: license-file
+
+# Brainiac
+
+A local, any-LLM **second brain**: your notes stay plain Markdown + YAML on
+your own disk, and the `brain` CLI gives any LLM harness (Claude Code, Codex,
+Gemini CLI, Claude Desktop / Cowork, ...) fast, sourced search over them — no
+vendor lock-in, no cloud index, no plugin ecosystem to keep alive.
+
+## Why
+
+Retrieval-augmented note-taking usually means picking a proprietary app and
+trusting its plugin/embedding pipeline forever. Brainiac inverts that: the
+substrate is just files (`vault/brain/`, `vault/raw/`), the search index is a
+disposable cache you can rebuild any time, and every read goes through a
+deny-by-default classification filter (the **egress gate** — see
+`docs/glossary.md`) before it reaches a model — so you control what an LLM is
+allowed to see, note by note. See `AGENTS.md` for the full conventions and
+security model.
+
+## Installing Brainiac for the first time
+
+**Installing? → [`docs/install/README.md`](docs/install/README.md) (pick your
+platform: Claude Code, Cowork, Codex, or Gemini CLI).**
+
+The single most common path (Claude Code, on your own machine):
+
+```text
+claude> /plugin marketplace add Autopsias/brainiac
+claude> /plugin install brainiac-manager@brainiac
+claude> /brainiac-install <path-to-your-vault>
+```
+
+**Or the one-command way** (PyPI-first, no clone needed):
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/Autopsias/brainiac/main/install.sh -o /tmp/brainiac-install.sh
+bash /tmp/brainiac-install.sh
+```
+
+`install.sh` tries, in order, `uv tool install`, `pipx install`, then
+`pip install --user` — first success wins, and it tells you which one it
+used. Every channel installs `brainiac-cli[mcp]` so `brain-mcp` (the
+optional Claude Desktop bridge) works out of the box. Plain `pip install
+brainiac-cli[mcp]` works too, without the channel-fallback convenience.
+
+**Windows (PowerShell)?** Same install, no bash/WSL required:
+
+```powershell
+irm https://raw.githubusercontent.com/Autopsias/brainiac/main/install.ps1 -OutFile install.ps1
+.\install.ps1
+```
+
+**Contributing to Brainiac, or no PyPI/network access?** Clone and pass
+`--dev` / `-Dev` — an editable install from the checkout, the pre-PyPI
+behavior:
+
+```bash
+git clone https://github.com/Autopsias/brainiac.git && cd brainiac
+./install.sh --dev          # macOS/Linux
+# or: .\install.ps1 -Dev    # Windows
+```
+
+The `--dev` path also builds a **lexical-only** index for the checkout's
+bundled sample vault (`BRAIN_EMBEDDER=hash` — no model download, no network
+needed) — try `brain search "arctic-embed vs e5" --json` against it right
+away. The default PyPI-first path has no local sample vault to index — run
+this against your own vault instead (see `docs/install/README.md`):
+
+```bash
+BRAIN_VAULT=<workspace>/vault brain init --full --apply   # scaffolds + seeds 3 sample notes AND indexes them
+BRAIN_VAULT=<workspace>/vault brain search "welcome" --json   # first search works right away
+```
+
+Either way, semantic search downloads its embedding model (a few hundred MB)
+lazily on first real use, or run `brain warmup` up front.
+
+Then ask your first question:
+
+```bash
+brain search "welcome" --json          # fresh vault (matches the seeded sample notes)
+brain search "arctic-embed vs e5" --json   # --dev checkout's own bundled vault
+```
+
+Every search hit carries the note's file path and its classification tier,
+and an `egress` block reports how many notes were withheld by the
+classification filter.
+
+Two things worth knowing about where files live:
+
+- **Your notes** live in the vault (`vault/` by default — plain Markdown, the
+  single source of truth).
+- **The search index** lives in your per-user app-data folder
+  (`~/Library/Application Support/profile-a-brain` on macOS,
+  `%LOCALAPPDATA%\profile-a-brain` on Windows, `~/.local/share/...` on
+  Linux). It is a derived cache — deleting it loses nothing; `brain rebuild`
+  recreates it from the vault.
+
+Per-client walkthroughs (Claude Code vs Codex vs Cowork):
+`docs/install/README.md`. Run `brain --help` any time — the CLI is self-describing and is the one
+source of truth for what's shipped.
+
+## Updating an existing install
+
+Already installed? Don't re-run the first-time setup — update in place.
+
+**Check where you stand (read-only).** In your terminal:
+
+```
+brain doctor
+```
+
+prints one health + version table across every surface — engine venv, CLI
+plugins, staged Cowork workspaces, marketplace cache, and the Desktop/Cowork
+store — each ✅/⚠️ with the exact command to fix anything stale. It changes
+nothing and exits non-zero when a required surface is behind. (Available from
+v0.10.0 onward.)
+
+**Bring everything current.** In Claude Code on the host:
+
+```
+/brainiac-update
+```
+
+now **runs** the update instead of printing a checklist: marketplace refresh →
+downgrade-safe CLI-plugin reinstall → engine venv reinstall → every registered
+Cowork workspace re-staged → a final `brain doctor` verify — then a before→after
+version table and one pass/fail. It handles the reconciliation downgrade
+(installed newer than the marketplace) automatically and never touches your
+notes, audit chain, or runtime state. Prefer the terminal? `brain update` is the
+same flow — add `--dry-run` to preview every decision without mutating anything.
+Full detail: **`docs/install/README.md`** (§ Updating).
+
+**Installed under the old names?** Marketplace `profile-a-marketplace` and
+plugins `profile-a-kernel`/`profile-a-extras` were renamed to `brainiac` /
+`brainiac-kernel`/`brainiac-extras` (2026-07-11). `brain doctor` flags a
+stale-name registration under either old name. Recovery (add-new-before-
+remove-old — never the reverse):
+
+```
+claude plugin marketplace add Autopsias/brainiac
+claude plugin install brainiac-manager@brainiac
+```
+
+then run `/brainiac-update` — it detects the old-name registrations and
+finishes the migration automatically (installs the new-name plugins,
+verifies the lifecycle skills resolve, then removes the old marketplace and
+plugins). See `docs/adr/0006-distribution-naming.md`.
+
+## Using it with a new project (second vault, third, ...)
+
+The install is **per machine**; vaults are **per project**. You never
+reinstall — you point the same `brain` at a different vault folder, and each
+vault automatically gets its own index and audit chain (no configuration):
+
+```bash
+export BRAIN_VAULT=~/vaults/my-new-project   # which vault to use
+brain init --full --apply                     # once per vault: scaffold + seed + index
+```
+
+Full detail (per-vault overlay, the scheduled-task gotcha):
+**`docs/install/second-vault.md`**.
+
+## For technical & security teams
+
+A plain summary of what this repo does and doesn't do, for a corporate
+review:
+
+- **All data stays on the local disk.** Notes are plain Markdown; the index
+  is a local SQLite file. There is no server, no telemetry, no cloud sync,
+  and the project holds **no model API keys** — the only egress is whatever
+  LLM client the owner already runs.
+- **Deny-by-default egress gate.** Every read command filters notes by their
+  `classification` tier before printing; a note with a missing or unknown
+  label is treated as most-restrictive and withheld. Scheme:
+  `docs/classification-scheme.md`.
+- **Signed audit chain.** Every committed write is Ed25519-signed and
+  hash-chained; the key lives in the OS secret store, fail-closed (no file
+  fallback). Rotation runbook and stated limitations: `SECURITY.md`.
+- **Trust split.** Untrusted/sandboxed legs (the Cowork Linux VM) get a
+  read-only snapshot and a draft inbox — they can never sign, index, or
+  mutate the canonical store. `AGENTS.md` §6.
+- **Dependencies.** The default install pulls a small, auditable set
+  (onnxruntime, tokenizers, numpy, sqlite-vec, huggingface-hub,
+  cryptography, PyYAML, regex — see `pyproject.toml`, which documents why
+  each exists). The code degrades gracefully without any of them, so a
+  constrained deployment (Intune, air-gapped) can install with
+  `pip install --no-deps .` and re-add only what policy allows; an SBOM
+  generator ships at `tools/generate_sbom.py`. Offline model provisioning:
+  set `$BRAIN_MODEL_CACHE` to a pre-fetched model dir and no download is
+  attempted.
+- **License & provenance.** Apache-2.0. Built clean-room; the AGPL project
+  consulted as a design reference was never forked or vendored — log and
+  audit gate: `docs/clean-room-log.md`, `tools/code_origin_audit.py`.
+- **Vulnerability reporting:** `SECURITY.md`. Deeper notes:
+  `docs/SECURITY_NOTES.md`, `docs/operations/`.
+
+## How the AI assistants are wired
+
+`AGENTS.md` is the canonical instruction file. `CLAUDE.md` imports it
+verbatim (`@AGENTS.md`) so Claude Code reads the same contract; Codex reads
+`AGENTS.md` natively; Gemini CLI is pointed at it via `.gemini/`. All of them
+call the `brain` CLI through their normal shell — **no MCP required**. The
+one exception is the Claude Desktop **Chat tab** (the only surface that
+can't run a command): for that, `pip install -e ".[mcp]"` adds the optional,
+deletable `brain-mcp` bridge. Full matrix: `docs/harness-wiring.md`.
+
+## More
+
+- **`AGENTS.md`** — the conventions/schema every harness reads at startup:
+  note shape, link style, capture rules, the four agent-facing verbs
+  (search/get/recent/draft-capture), and the security posture.
+- **`docs/install/`** — installation, starting at the
+  [platform picker](docs/install/README.md) (Claude Code, Cowork — the Claude
+  Desktop Linux VM sandbox client — Codex, Gemini CLI) and
+  `docs/install/new-owner.md` for the five-minute "what runs where" mental model.
+- **`docs/glossary.md`** — one-line definitions for the jargon used across
+  these docs (PARA, MNPI, egress gate, Cowork, host-broker, overlay, ...).
+- **`SECURITY.md`** — vulnerability reporting, supported versions, audit-key
+  rotation.
+- **`LICENSE`** — Apache-2.0.
+
+## Layout
+
+```
+AGENTS.md            conventions + frontmatter schema
+src/brain/           the brain CLI + engine (index, search, audit, ...)
+docs/                specs (substrate, classification, install, security notes)
+tools/validate.py    conventions validator (stdlib-only; PyYAML optional)
+vault/               the tiny sample vault used in the quickstart above
+  raw/   immutable captured sources
+  brain/ agent-owned atomic notes + index.md + generated backlinks.md
+  .brain/  per-vault runtime (published snapshot, capture inbox) — gitignored
+```
+
+## Validate
+
+```bash
+python3 tools/validate.py vault              # exit 0 = conventions clean
+python3 tools/validate.py vault --backlinks  # regenerate brain/backlinks.md
+python3 tools/validate.py vault --okf        # + optional OKF lint
+```
+
+## Scope note
+
+Substrate readiness is not the same as operational cutover. This repo makes
+the substrate *ready* to replace an existing tool (e.g. Obsidian + Smart
+Connections) and emits the cutover hooks (`docs/corpus-migration.md`,
+`docs/dependency-inventory.md`); actually retiring your old setup is a
+separate, owner-specific step. See `AGENTS.md` §7.

brainiac_cli-0.16.0.dist-info/RECORD

@@ -0,0 +1,77 @@
+brain/__init__.py,sha256=X1-_-A7-DOJrM53MjcgFvkV6gyTmMcKxq0adY_Ve-pk,1870
+brain/__main__.py,sha256=RnmXo52qFPkq9WQH2i-PTZZdpKYdfkmo9PaQ2Ncvdx4,431
+brain/_version.py,sha256=IVFuOcK8mkureEFjMM6_nu3-Yad3LY6tBzCF3H1u5TQ,621
+brain/anchor.py,sha256=0ThDeoXmI3CDc2oF4qMzPeZh34b5hE0VU6TUOtMIuNI,5148
+brain/audit.py,sha256=HkA2Z2Gw9X4vfV-t-Y7EDsP2-EC6N_yApsbckN5DvKc,16681
+brain/backup.py,sha256=_oWERCSKaSHp-ku0oY1118peXhGs7tzRnQfNiR7nEpQ,8868
+brain/brief.py,sha256=SRkFuw9Ic3sVoqRGsOQM3JZLPlCDeDUJWFvGdCGKbe8,16802
+brain/capture.py,sha256=UWZPSho_4IxxHic9inS5BAY9k2jl5zZGhnNh9P5h5RQ,3997
+brain/chunk.py,sha256=r6iTnx2sF86wyN8i4jx7EYfy-R08Cf2hwbd4Ly0y9jI,10089
+brain/classification.py,sha256=ihR5fwUR76Pud18dYoCqP0X_6YY20q60f7tBvztvfJs,5659
+brain/cli.py,sha256=4EaWYpswVCWKXVpp6CD5_Q5EoE-IqTqp2ChN9S64ISQ,98442
+brain/config.py,sha256=Zk2EmS0aoth8fl1r63iGBSi420qXjYYFpwsad3-91KQ,17646
+brain/connect.py,sha256=WGXEkthfT-G-2IMAwSHVI7_PaYyITeLz_Z18UE8Bf6Q,15471
+brain/context.py,sha256=e25fvfyFzi5JqdIzFMrJwGqVFjygp6M8yRixQVZuvuU,4707
+brain/core.py,sha256=KKf-AKcUBCkIAzQzI6O7V1lvwfSI7O9fptenxpJMo04,159636
+brain/doctor.py,sha256=u94HD2LDDNV2tKWK1y0HZecLU-JRlSiEaGoxKAxA9NA,57560
+brain/egress.py,sha256=EGcxDkdE1OeDxR8bI0G9Tg6mqJPe6CQrOBXOU-NsjO8,7476
+brain/embed.py,sha256=zfQmiAxoCJaF3WYCu5A1PFk2GywdkP09pd24oNkg0zo,38550
+brain/encryption.py,sha256=zRZ9mg4E_kBD_0Y3HDF-4D3sngy2wPaLV9zn3m6PeM4,8968
+brain/frontmatter.py,sha256=3s39Y9hEBTebTZ1fCGVbm9D7KDUtGJsvlhtIQYwEAGY,3624
+brain/golden_probe.py,sha256=M-paNnwMS7nt88IZHKJ6RMfVIrq71EH2iy3MEuKMX5U,32963
+brain/graph.py,sha256=VKNGg3yHV-wg7VSudKlc4dQlfBv6DkGKqzkNhVmO1V4,14807
+brain/graphify.py,sha256=yjxN7w5d6aZlu1Tj93BHMR7KumIPShgtVDEIW4iwiWM,16040
+brain/index.py,sha256=7VnYmgwqxbfoXRRAXl1vnLSPn9yOICfFAwVUqD7NGzk,77479
+brain/init.py,sha256=_8bX4o_QH0jzYJaYdZ2KvzTXapmCvM1l1n6PpCEs4Lw,36393
+brain/maintenance.py,sha256=uR3MCFjE16pOmbl5SaOs_tPrNg4BMASo_2-8Pe0STqk,107955
+brain/mcp_adapter.py,sha256=yDUPVsWm7CroJTH1U_AAzExRavX3dBfxJRmtwYpxfs0,11400
+brain/multihop.py,sha256=SEOYB1fNY3YPyPd9LhOFRva4sV-Ifl16NQn1i9IrEGE,9683
+brain/notes.py,sha256=7otaNlAfamsfkBdfVDMptFHX_E_jd6koIZMNHoT7Y8c,7632
+brain/overlay.py,sha256=9rsuS3STthgshYkcNUPL5bI7w3xJlok_l0LuED279Hk,6966
+brain/projection.py,sha256=XyAZPBAoZ5MQLgCd2jBgNgyTMGjV3HcWGPIoEHLRlfk,2885
+brain/rerank.py,sha256=yyMp80zsguvYM_hztHhEmpy4Tvg4BMVImvVTSZ73PGw,18399
+brain/snapshot.py,sha256=g7BCq2ofzDZYvoiiGx-1gEWS1YbV5YhXFgOu9do3Pi8,8199
+brain/update.py,sha256=FyBfTNZ8-y5f9VrwfnJElN4SCzY0RmNsS4hO0xS5qu4,37039
+brain/vectors.py,sha256=EdBRBI6_rAcbelGU1QOpZEld01wgJGyOlkoeY7lIQ0s,8813
+brain/_assets/AGENTS.md,sha256=MsbBXm_Vdmp-1lr41Tmgvdvgoi0zu60-QVO043DOr4E,33235
+brain/_assets/overlay/template/brand/brand-guide.md,sha256=osiarUtl0BDdy-FkdIKrO4TxYWwyXLopqpjaf-BzW3U,735
+brain/_assets/overlay/template/keywords/glossary.md,sha256=L5pHOlGNDFeUJKy2Gkpr9Pm9yRWPULdGOgZRC8S-vJI,387
+brain/_assets/overlay/template/people/roster.md,sha256=ZO8NOvkqY3vqU9y-KjSQAYw8jICwlgNxMk_6CZLxUUk,377
+brain/_assets/overlay/template/voice/voice-profile.md,sha256=srRWsWz11TEmB4N0qH4upfetlY8HPdGtFwwyOeRzHBI,932
+brain/_assets/routines/manifest.json,sha256=ZfNIFDsokQyUqkcTuajjjN4bg-fUIT9Ied_3eeuwnOk,23599
+brain/_assets/scripts/brain-brief-mac.plist,sha256=yUCCyTbG2ssocvC4NUXNHB_NWjzEbg3Le_mW5VqtNKg,2665
+brain/_assets/scripts/brain-brief.sh,sha256=1fh4o9s9nDqQ9Pu9Xps-pAFfXtKp7OEaS77f51HdBzs,3896
+brain/_assets/scripts/brain-synthesis-mac.plist,sha256=kLA__aADJi6C2YtkUWPJRiL-9r3DyGCPu88w1yp-11I,1715
+brain/_assets/scripts/brain-synthesis.sh,sha256=gpSUJUfCfRiIgRwFGi08pR1THhHp2RVCNwMB9JR4uYs,9886
+brain/_assets/scripts/install-brief-mac.sh,sha256=zw2T_I28nXAknNyX1ep3K3iozN9Fc_DhioWvOT6QDzQ,7048
+brain/_assets/scripts/install-brief-windows.ps1,sha256=VE6SJg64hON8O6K1_7AWey0qa6KDILa9zyj9mZsNQs0,4665
+brain/_assets/scripts/register_tasks.py,sha256=XDWtn6WpBZ7d9RRqpcI-zYxe6c3bb6zc0Qtyb3WSnD8,17838
+brain/_assets/templates/company.md,sha256=ZFjeepGAoFdZlvtmPg19__5C-_pe9HH7oiRnl64yE-k,231
+brain/_assets/templates/concept.md,sha256=852qP9pqhwtOLblwYlkLnhFr9GgpNvaqR7eqptabA0g,438
+brain/_assets/templates/daily.md,sha256=G0t_oUTlPBYS8nQK7_gt1Rb2FaZZPtRIX4fHerBoHrc,217
+brain/_assets/templates/decision.md,sha256=Bkb-dHXTjZ6x_ENVqxdwRIJ8v126SRJ8mCZBNWlQXIw,914
+brain/_assets/templates/meeting.md,sha256=tzLwoihXdUXv3aXoJyNKPifOPT2xXWK5UR-CGCzbh8c,531
+brain/_assets/templates/person.md,sha256=ENbuUsR79EdVebLhyEu4REgCFg1MlmoUqnFR2tHj9bI,228
+brain/_assets/templates/project.md,sha256=gZYTGUqJz_woVZqTWju-E3hkDlv7-2b4aU-SgEEGsr4,241
+brain/_assets/templates/state-moc.md,sha256=ZSusJ73sUpMF6uCYFdUeWw-XvivYiOruAwKRpXpd0J4,1009
+brain/ingest/__init__.py,sha256=YWIwBJXGDwj59BKrJPd-QZvXBYRC6kI0omDC2QT2sCI,918
+brain/ingest/pipeline.py,sha256=tlikO2z4hppJaNGLqRP75b-j-EKcyBkBEOIrvH5H7V8,38009
+brain/ingest/transcript.py,sha256=dtT3rAj0Wm147XGhw5sui5fIFdrtx7aIc13QhnxJKjY,6430
+brain/ingest/handlers/__init__.py,sha256=0iU29LmHTi-glc5tmyunXAHoqVtol1wTC7hxaGhevIw,1321
+brain/ingest/handlers/base.py,sha256=2gFybMPzzx7ixiNh9BsD--4IUQ-GPWi4OtNsFOnaO2c,3619
+brain/ingest/handlers/docx.py,sha256=KiQl-6khxEZsHHNzml2xoqo58owKXGYBqQ534zzR7UU,2983
+brain/ingest/handlers/email.py,sha256=ky3q68Ya5VuaBjvN1QJtzBDqAP-61GRdsw8QZvj5iW0,8291
+brain/ingest/handlers/html.py,sha256=KKwaF_RrgmA9dextJVYqSrpBeRUgLg52XUst_lS5XVM,5022
+brain/ingest/handlers/image.py,sha256=UC7CbyMYpMhoR6b-RLkbrt9Xebr5NlNINi3pbPQHuGI,3373
+brain/ingest/handlers/pdf.py,sha256=b3EJw8XTHatfgZSiUYH9MlhdJ_m5u96lomNy12F0EXY,3655
+brain/ingest/handlers/pptx.py,sha256=eqkI6Gm11hvBqAzOS7OJ_48ioNhjSFFCwgJQFVQHHlc,2328
+brain/ingest/handlers/tables.py,sha256=wKYnBwNkPBLRuABJKzGSEbkEs8MDVl4phUKXg0N7GE4,1563
+brain/ingest/handlers/text.py,sha256=2NUxvphrnIow8X3U1ChFS7IMYbuIKbSS5w_qIceIMX8,1478
+brain/ingest/handlers/xlsx.py,sha256=EoLqKN-DTGmxbYF5F-xX3KvoLkUKNEPYxChJLzWiGoA,4102
+brain/ingest/handlers/zip.py,sha256=aTOO6DR418IGwYonWLdscpEjzB1Ngg63bQy7Admv6Fk,7450
+brainiac_cli-0.16.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+brainiac_cli-0.16.0.dist-info/METADATA,sha256=x4isWPqPZJHa693yZqPWW3Lhd9Vnn-AfWjeFbBFpGR8,13144
+brainiac_cli-0.16.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+brainiac_cli-0.16.0.dist-info/entry_points.txt,sha256=gaRS9IrVXze1IdVJm_BcN7kAXzst2FDou63OEwpsQNU,122
+brainiac_cli-0.16.0.dist-info/top_level.txt,sha256=0pJ5ecu89EDo7ZExlRWAh7IWxf55ZhTYilz2jLXwRSg,6
+brainiac_cli-0.16.0.dist-info/RECORD,,

brainiac_cli-0.16.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

brainiac_cli-0.16.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+brain = brain.cli:main
+brain-golden-probe = brain.golden_probe:main
+brain-mcp = brain.mcp_adapter:serve