codebrain 0.1.0__py3-none-any.whl

codebrain/watcher/file_watcher.py

@@ -0,0 +1,173 @@
+"""Watchdog-based file monitor with debounced incremental updates."""
+
+from __future__ import annotations
+
+import threading
+import time
+from pathlib import Path
+
+from watchdog.events import FileSystemEvent, FileSystemEventHandler
+from watchdog.observers import Observer
+
+from codebrain.config import INDEXABLE_EXTENSIONS, WATCHER_DEBOUNCE_SECONDS
+from codebrain.graph.store import GraphStore
+from codebrain.indexer import incremental_update
+from codebrain.logging import get_logger
+from codebrain.settings import load_settings
+
+_log = get_logger("watcher")
+
+
+class _DebouncedHandler(FileSystemEventHandler):
+    """Collects file-change events and flushes them after a debounce window."""
+
+    def __init__(
+        self,
+        repo_root: Path,
+        store: GraphStore,
+        *,
+        debounce: float = WATCHER_DEBOUNCE_SECONDS,
+        extensions: frozenset[str] = INDEXABLE_EXTENSIONS,
+    ) -> None:
+        super().__init__()
+        self.repo_root = repo_root
+        self.store = store
+        self._debounce = debounce
+        self._extensions = extensions
+        self._changed: set[Path] = set()
+        self._deleted: set[Path] = set()
+        self._lock = threading.Lock()
+        self._timer: threading.Timer | None = None
+        self._last_validation: dict[str, object] = {}  # rel_path -> ValidationReport
+
+    def _schedule_flush(self) -> None:
+        if self._timer is not None:
+            self._timer.cancel()
+        self._timer = threading.Timer(self._debounce, self._flush)
+        self._timer.daemon = True
+        self._timer.start()
+
+    def _flush(self) -> None:
+        with self._lock:
+            changed = list(self._changed)
+            deleted = list(self._deleted)
+            self._changed.clear()
+            self._deleted.clear()
+
+        if not changed and not deleted:
+            return
+
+        # Validate changed files BEFORE re-indexing (graph still has old state)
+        if changed:
+            self._validate_changed(changed)
+
+        result = incremental_update(self.repo_root, changed, deleted, self.store)
+        total = result["files_updated"] + result["files_removed"]
+        if total:
+            _log.info(
+                "Updated %d, removed %d (%.3fs)",
+                result["files_updated"],
+                result["files_removed"],
+                result["elapsed_seconds"],
+            )
+
+    def _validate_changed(self, changed: list[Path]) -> None:
+        """Run structural validation on recently changed files."""
+        from codebrain.validator import ChangeValidator
+
+        validator = ChangeValidator(self.store)
+        for abs_path in changed:
+            rel_path = abs_path.relative_to(self.repo_root).as_posix()
+            try:
+                report = validator.validate_file(abs_path, self.repo_root)
+                if not report.is_valid:
+                    _log.warning(
+                        "STRUCTURAL BREAKAGE in %s: %d violation(s)",
+                        rel_path,
+                        len(report.violations),
+                    )
+                    for v in report.violations:
+                        if v.severity in ("critical", "high"):
+                            _log.warning("  [%s] %s", v.severity.upper(), v.message)
+                self._last_validation[rel_path] = report
+            except Exception as e:
+                _log.debug("Validation failed for %s: %s", rel_path, e)
+
+    def get_recent_validations(self) -> dict[str, dict]:
+        """Return validation results from the most recent flush."""
+        return {
+            path: report.to_dict()
+            for path, report in self._last_validation.items()
+        }
+
+    def _is_relevant(self, path: str) -> bool:
+        return Path(path).suffix in self._extensions
+
+    def on_modified(self, event: FileSystemEvent) -> None:
+        if event.is_directory or not self._is_relevant(event.src_path):
+            return
+        with self._lock:
+            self._changed.add(Path(event.src_path))
+        self._schedule_flush()
+
+    def on_created(self, event: FileSystemEvent) -> None:
+        if event.is_directory or not self._is_relevant(event.src_path):
+            return
+        with self._lock:
+            self._changed.add(Path(event.src_path))
+        self._schedule_flush()
+
+    def on_deleted(self, event: FileSystemEvent) -> None:
+        if event.is_directory or not self._is_relevant(event.src_path):
+            return
+        with self._lock:
+            self._deleted.add(Path(event.src_path))
+            self._changed.discard(Path(event.src_path))
+        self._schedule_flush()
+
+    def on_moved(self, event: FileSystemEvent) -> None:
+        if event.is_directory:
+            return
+        if self._is_relevant(event.src_path):
+            with self._lock:
+                self._deleted.add(Path(event.src_path))
+        if self._is_relevant(event.dest_path):
+            with self._lock:
+                self._changed.add(Path(event.dest_path))
+        self._schedule_flush()
+
+
+def start_watching_background(
+    repo_root: Path, db_path: Path,
+) -> tuple[Observer, GraphStore, _DebouncedHandler]:
+    """Start a non-blocking file watcher on a daemon thread.
+
+    Returns (observer, store, handler) so the caller can stop it later
+    and poll validation results via handler.get_recent_validations().
+    """
+    settings = load_settings(repo_root)
+    store = GraphStore(db_path)
+    handler = _DebouncedHandler(
+        repo_root,
+        store,
+        debounce=settings.watcher_debounce,
+        extensions=settings.indexable_extensions,
+    )
+    observer = Observer()
+    observer.daemon = True
+    observer.schedule(handler, str(repo_root), recursive=True)
+    observer.start()
+    _log.info("Background watcher started for %s", repo_root)
+    return observer, store, handler
+
+
+def start_watching(repo_root: Path, db_path: Path) -> None:
+    """Block forever, watching *repo_root* for file changes."""
+    observer, store, _handler = start_watching_background(repo_root, db_path)
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        observer.stop()
+    observer.join()
+    store.close()

codebrain-0.1.0.dist-info/METADATA

@@ -0,0 +1,360 @@
+Metadata-Version: 2.4
+Name: codebrain
+Version: 0.1.0
+Summary: Persistent structural knowledge graph for codebases — lets LLM agents skip grep and understand repos in seconds.
+Author: CodeBrain Contributors
+License: MIT
+Project-URL: Homepage, https://github.com/monk0062006/CodeBrain
+Project-URL: Repository, https://github.com/monk0062006/CodeBrain
+Project-URL: Issues, https://github.com/monk0062006/CodeBrain/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.1
+Requires-Dist: watchdog>=3.0
+Requires-Dist: mcp<1.20,>=1.0
+Requires-Dist: jinja2>=3.1
+Provides-Extra: api
+Requires-Dist: fastapi>=0.110; extra == "api"
+Requires-Dist: uvicorn>=0.27; extra == "api"
+Provides-Extra: llm
+Requires-Dist: httpx>=0.27; extra == "llm"
+Provides-Extra: ts
+Requires-Dist: tree-sitter>=0.21; extra == "ts"
+Requires-Dist: tree-sitter-languages>=1.10; extra == "ts"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-tmp-files>=0.0.2; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: mypy>=1.8; extra == "dev"
+Requires-Dist: ruff>=0.3; extra == "dev"
+Requires-Dist: httpx>=0.27; extra == "dev"
+Provides-Extra: all
+Requires-Dist: codebrain[api,llm,ts]; extra == "all"
+Dynamic: license-file
+
+# CodeBrain
+
+Structural intelligence for AI-assisted development. CodeBrain builds a
+persistent knowledge graph of your codebase and validates changes before
+they land — preventing AI coding agents from silently breaking things.
+
+## The Problem
+
+AI coding agents (Claude Code, Cursor, Copilot) generate code faster than
+you can review it. They grep fragments, apply local fixes, and don't
+maintain a mental model. When the AI removes a function, it doesn't know
+3 other files call it.
+
+CodeBrain knows.
+
+## Quick Start
+
+### 1. Install
+
+```bash
+pip install codebrain
+```
+
+Optional extras:
+
+```bash
+pip install codebrain[api]   # REST API server
+pip install codebrain[llm]   # LLM-enhanced explanations
+pip install codebrain[ts]    # TypeScript AST parser (tree-sitter)
+pip install codebrain[all]   # Everything
+```
+
+### 2. Index your project
+
+```bash
+cd your-project
+brain init
+```
+
+### 3. Connect to Claude Code
+
+```bash
+brain agent  # generates CLAUDE.md + MCP config
+```
+
+Or add to your MCP config manually:
+
+```json
+{
+  "mcpServers": {
+    "codebrain": {
+      "command": "python",
+      "args": ["-m", "codebrain.mcp_server"],
+      "cwd": "/path/to/your/repo"
+    }
+  }
+}
+```
+
+### 4. That's it
+
+CodeBrain will automatically validate changes before Claude writes them.
+When a change would break something, it says so — with the specific files
+and callers that would be affected.
+
+## What It Does
+
+### Structural Safety Gate
+
+Before an AI agent writes a file, CodeBrain checks if the change would break
+callers in other files. If it would, the agent is told to fix the breakage first.
+
+### Impact Analysis
+
+"What would break if I change this?" — answers with specific files, symbols,
+and call chains. Not grep results. Deterministic graph traversal.
+
+### Risk Hotspots
+
+Identifies the most structurally dangerous code — functions called by many files,
+modules with high coupling, symbols where a signature change would cascade.
+
+### Dead Code Detection
+
+Finds unused symbols with confidence levels. High-confidence means it's really dead.
+Medium means the file uses dynamic patterns. Low means it might be used indirectly.
+
+### Comprehension Narratives
+
+Plain English explanations: "store.py is the most depended-on file — 8 modules
+import from it. Changes here have the highest blast radius in the codebase."
+
+## CLI Commands
+
+| Command | Description |
+|---------|-------------|
+| `brain init` | Index the current repository |
+| `brain reindex` | Force a full rebuild |
+| `brain status [--json]` | Show index statistics |
+| `brain search <query> [--json]` | Find symbols by name |
+| `brain trace <name> [--depth N] [--json]` | Forward call chain |
+| `brain impact <name> [--depth N] [--json]` | Reverse impact analysis |
+| `brain deps <name> [--json]` | Dependencies of a symbol or file |
+| `brain deadcode [--json]` | Find unused functions/classes |
+| `brain cycles [--json]` | Detect import cycles |
+| `brain validate <file> [--json]` | Check if a file change is safe |
+| `brain overview [--json]` | System-level codebase overview |
+| `brain module <file> [--json]` | Module-level view |
+| `brain context <name> [--json]` | LLM-optimized symbol context |
+| `brain hotspots [--top N] [--json]` | Riskiest symbols |
+| `brain coupling [--json]` | Module coupling analysis |
+| `brain contracts [--json]` | Implicit contract detection |
+| `brain layers [--json]` | Architectural layer inference |
+| `brain doctor` | Diagnostic health check |
+| `brain zoom [target] [--json]` | Multi-resolution navigation (system/package/module/symbol) |
+| `brain ci [--base B] [--fail-on F] [--json]` | CI validation of changed files |
+| `brain diff` | Show files changed since last index |
+| `brain watch` | Start file watcher daemon |
+| `brain repair` | Check database integrity, rebuild if corrupted |
+| `brain mcp` | Start MCP server (stdio) |
+| `brain hook install` | Install pre-commit hook |
+| `brain hook uninstall` | Remove pre-commit hook |
+| `brain agent` | Generate agent integration files |
+| `brain serve [--host H] [--port P]` | Start REST API server |
+
+All commands accept `--repo <path>` to specify a different repository root, `--verbose` for debug logging, and `--timeout N` to set analysis timeout in seconds (default: 120).
+
+## MCP Tools (for AI agents)
+
+22+ tools available via MCP protocol. Key tools:
+
+| Tool | Purpose |
+|------|---------|
+| `propose_change` | Validate before writing — the structural safety gate |
+| `impact_analysis` | Trace transitive dependents of any symbol |
+| `get_file_context` | Full file understanding for LLM context |
+| `get_symbol_context` | Full symbol understanding for LLM context |
+| `ask_codebase` | Natural language questions about the codebase |
+| `validate_change` | Check if a file change would break callers |
+| `risk_hotspots` | Find structurally dangerous symbols |
+| `find_dead_code` | Unused symbols with confidence levels |
+| `codebase_overview` | System-level architecture summary |
+| `get_task_context` | Pull relevant context for a development task |
+
+See [docs/mcp-tools.md](docs/mcp-tools.md) for full documentation.
+
+## Configuration
+
+Create `.codebrain.toml` in your repo root:
+
+```toml
+[codebrain]
+# Extra directories to skip during indexing
+skip_dirs = ["__pycache__", ".git", "node_modules", "vendor"]
+
+# File extensions to index
+extensions = [".py", ".ts", ".tsx", ".js", ".jsx"]
+
+# Watcher debounce interval (seconds)
+watcher_debounce = 0.5
+
+# File count threshold for parallel parsing
+parallel_threshold = 50
+
+# Maximum file size to index (KB)
+max_file_size_kb = 1024
+```
+
+Environment variables override the config file:
+
+| Variable | Description |
+|----------|-------------|
+| `CODEBRAIN_SKIP_DIRS` | Comma-separated skip directories |
+| `CODEBRAIN_EXTENSIONS` | Comma-separated file extensions |
+| `CODEBRAIN_DEBOUNCE` | Watcher debounce seconds |
+| `CODEBRAIN_PARALLEL_THRESHOLD` | Parallel parsing threshold |
+| `CODEBRAIN_MAX_WORKERS` | Max parallel worker processes |
+| `CODEBRAIN_CLI_TIMEOUT` | CLI analysis timeout in seconds (default: 120) |
+
+See [docs/configuration.md](docs/configuration.md) for full reference.
+
+## Language Support
+
+- **Python**: Full AST parsing (stable)
+- **TypeScript/JavaScript**: tree-sitter parsing (`pip install codebrain[ts]`)
+- **TypeScript fallback**: regex-based (experimental, limited coverage)
+
+## CI Integration
+
+### Pre-commit Hook
+
+```bash
+brain hook install   # validates staged files before every commit
+brain hook uninstall # remove the hook
+```
+
+The hook blocks commits with critical structural violations. Use `git commit --no-verify` to bypass.
+
+### CI Pipeline
+
+```bash
+brain ci --base main           # exits 1 if UNSAFE changes detected
+brain ci --base main --json    # machine-readable output
+brain ci --fail-on caution     # stricter: also fail on CAUTION
+```
+
+### GitHub Action
+
+```yaml
+# .github/workflows/codebrain.yml
+name: CodeBrain Validation
+on: [pull_request]
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - run: pip install codebrain
+      - run: brain ci --base origin/main --json
+```
+
+Or use the reusable composite action:
+
+```yaml
+- uses: ./.github/actions/codebrain-validate
+  with:
+    base-branch: main
+    fail-on: unsafe
+```
+
+## VS Code Extension
+
+See [`vscode-extension/`](vscode-extension/) — 5 commands (impact, context, search, validate, hotspots) plus validate-on-save with inline diagnostics.
+
+## REST API
+
+```bash
+pip install codebrain[api]
+brain serve --port 8484
+```
+
+~20 endpoints at `/api/status`, `/api/search`, `/api/impact/{name}`, `/api/hotspots`, etc. Interactive docs at `/docs`.
+
+## Plugin System
+
+Add custom language parsers by implementing `BaseParser` and registering via entry points:
+
+```python
+from codebrain.parser.base import BaseParser
+
+class RustParser(BaseParser):
+    def extensions(self) -> frozenset[str]:
+        return frozenset({".rs"})
+
+    def parse(self, path, repo_root):
+        ...  # return ParsedFile
+```
+
+```toml
+# pyproject.toml
+[project.entry-points."codebrain.parsers"]
+rust = "your_package.parser:RustParser"
+```
+
+## Architecture
+
+```
+Source Files  -->  Parser (Python/TS)  -->  ParsedFile (Nodes + Edges)
+                                                  |
+                                            GraphStore (SQLite)
+                                                  |
+                                            QueryEngine
+                                                  |
+                          CLI / MCP / REST API / VS Code / Agent Bridge
+```
+
+**Key abstractions:**
+
+- **Node** — a code symbol (function, class, method, variable)
+- **Edge** — a relationship (CALLS, IMPORTS, CONTAINS, EXTENDS, DATAFLOW)
+- **GraphStore** — CRUD over the SQLite knowledge graph
+- **QueryEngine** — impact analysis, call chains, dead code, cycles
+
+## Validated on Real Codebases
+
+CodeBrain has been tested on a 1,328-file mixed Python + TypeScript project (17,756 symbols, 111,793 edges):
+
+- **Indexing**: 1,328 files in 135s, zero errors
+- **Health score**: 93/100 in under 5s
+- **Impact analysis**: Traces `getAstroData` → 48 dependents across 69 files
+- **Contracts**: Found `Colors` + `Spacing` co-imported in 141/141 files (confidence 1.0)
+- **Coupling**: Identified `logger.py` ↔ `main.py` (score 140)
+- **Layers**: Detected architectural cycles in `kp-astrology` module
+- **752 tests passing** across unit, integration, and real-world validation
+
+## Development
+
+```bash
+git clone https://github.com/monk0062006/CodeBrain.git
+cd CodeBrain
+pip install -e ".[dev]"
+
+pytest tests/ -v              # Run tests
+mypy codebrain/               # Type checking
+ruff check codebrain/         # Linting
+pytest --cov=codebrain        # Coverage
+```
+
+## License
+
+MIT

codebrain-0.1.0.dist-info/RECORD

@@ -0,0 +1,44 @@
+codebrain/__init__.py,sha256=-WRZcHGUiNGGA052ikAc1EU5u5afbBeiPIkC4XAYGtU,96
+codebrain/__main__.py,sha256=dgd9lRZovV1k1tScEW_wvPPjPEACXc-EcLtJ7AN3M48,115
+codebrain/agent_bridge.py,sha256=JDny3232R6rfFsQTWOoYygGgykx6rb8ektLRENPUcDQ,6262
+codebrain/analyzer.py,sha256=Y4GDvgkpIgQfjG6rHWvPielkiWwA81Bsr8P9t6V_nvY,39607
+codebrain/api.py,sha256=uciazx-n97O5Q6hNvVdBu5w1kWxbhIXcDiSrBpTWQ54,21195
+codebrain/api_models.py,sha256=mE5sIsf8WLEWjGm2w6-baeyVoJH_65FOglHwFe3aJhs,1989
+codebrain/cli.py,sha256=M9EMI_4xMMGlZXRJ_4SM6DtcNK_1vuRWpv1e0-YXpj8,74305
+codebrain/comprehension.py,sha256=66quIcwUxtij_EtfoxJksdcWCTtqVXSBckcpBF4F-Sk,79271
+codebrain/config.py,sha256=90G-cem6OluNRzLUOFv6xZNdpqngrbafdVUdEHrPa6w,902
+codebrain/context.py,sha256=DfKgOwL-3-3tDUtku5o1gfqaIZPAp4dKUQam2Bamd8I,10932
+codebrain/export.py,sha256=A4zdzJ2MVmo-sxJQjwoZlMRkm-QXCxE14lYDm9RrQEY,11576
+codebrain/hook_runner.py,sha256=R4h9KSWY0k9-pBtB4m9pHNXUxo3mc_9x6_SnKRuuQIg,2085
+codebrain/hooks.py,sha256=x6VGEWKD863g2d6Nt-Yk1UYQz3nk3BKXDUCb4jFGR1g,3126
+codebrain/indexer.py,sha256=Hz5hwa3HxCYe_rzZ7PCJHoF8009RoM4DsXkuV0OV1TM,15534
+codebrain/llm.py,sha256=0D5c5BJMVkLz2OoybfMxlUdJEbz16cZoNgVmm-LzFH0,25606
+codebrain/logging.py,sha256=ORR5L8REVlh4aJz9vqErmi76aqjLN2xVKoA2gSv_jas,1110
+codebrain/mcp_server.py,sha256=q_NBNW4f8TwxeruHluk4lRefCQMljXhl9acEtgM-LWM,61329
+codebrain/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+codebrain/resolver.py,sha256=rLKzfCrfEnEuBRn1OzukjgJoWL4jDvkUNXA3zuXr_ac,6388
+codebrain/settings.py,sha256=mlsqsSFztSbcKYp8342S3OR8YOoByNVpM0PiGvQe3oA,3210
+codebrain/utils.py,sha256=lO4cDMPlHgGAOkm_99x1hToKOye7NapFXj0DZ9bwAMg,1743
+codebrain/validator.py,sha256=B-54GH-pl_XYKpsuNRtfv-5fYXKvkefC1vF_fChDOr0,25002
+codebrain/graph/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+codebrain/graph/query.py,sha256=a2_z0yCXOWVEZeA0mI3dz9TaZMT7k3Z5jwep20qMVlw,28804
+codebrain/graph/schema.py,sha256=yj0foabC7U4NJHOE2yp-FBUnOVCIxuAIwKaP3d5z_zA,3910
+codebrain/graph/store.py,sha256=E__BQc_Aln5ilPkgSI-J03CWKZy6lLM4fnK985SOr64,12558
+codebrain/memory/__init__.py,sha256=PuFR35m1GPIbRAuUxKu4JYBDlPXJWMPbyrWiggFT2sU,158
+codebrain/memory/store.py,sha256=W31fe4aNTkdi-Woe8bZ8SZ9aUHpWrfBkb-9dQs0geyI,9394
+codebrain/parser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+codebrain/parser/base.py,sha256=EBP0_EtSgYcwxm8u9ZZNR4UdnsPEJm9tTUXiUEKAPoM,711
+codebrain/parser/config_parser.py,sha256=q0N5Vt7kc8RSv5qOUAwRXh1ey1VxJczvHKnhwMqcZME,7612
+codebrain/parser/models.py,sha256=zbDFbRb1eave-wcswW1Nw9DJBiyrtVJ5rvjeDfqDp7g,1281
+codebrain/parser/python_parser.py,sha256=G_XGWcve8rrOXT2tPzZBPGkrWYTuh6W8ylsaiabMXl0,26110
+codebrain/parser/registry.py,sha256=CR0uGVCNmQKb8h_7zaPwhnDD2R_TR28OOB2GysBcDVQ,5612
+codebrain/parser/typescript_parser.py,sha256=fi0DoXLCi_L0aQzpadumDpFHaSyekfp3wmVFaASvuks,47891
+codebrain/parser/typescript_treesitter.py,sha256=fxoettUXAEyNqqz1EWF54amAN8O9j7ry-xIlq_nU18o,23722
+codebrain/watcher/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+codebrain/watcher/file_watcher.py,sha256=r1VYK6L5bkN9XuVSd8yQs0FMdLmu_8Z0q1hR1Kx_LGY,6139
+codebrain-0.1.0.dist-info/licenses/LICENSE,sha256=2CvMb23aV7m-hC2tXAOjDGC6YOtScvtHlWiYIMhMBrk,1079
+codebrain-0.1.0.dist-info/METADATA,sha256=A0tbwlBswqF33ebGSQ--jNp-VpOpTrVe5IIwMIEFhLg,11983
+codebrain-0.1.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+codebrain-0.1.0.dist-info/entry_points.txt,sha256=BFbv0eKiaRBIvpCZKr-BB8MPHWPUKfvBCXuBxPbEMdc,183
+codebrain-0.1.0.dist-info/top_level.txt,sha256=mUxCZc80EyNOMzd2vAm22uIhnOb1Aw7ZOAUT_u-ksx4,10
+codebrain-0.1.0.dist-info/RECORD,,

codebrain-0.1.0.dist-info/WHEEL

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

codebrain-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,6 @@
+[codebrain.parsers]
+python = codebrain.parser.python_parser:PythonParser
+typescript = codebrain.parser.typescript_parser:TypeScriptParser
+
+[console_scripts]
+brain = codebrain.cli:cli

codebrain-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 CodeBrain Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

codebrain-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+codebrain