own-your-code 0.1.3__py3-none-any.whl

api/__init__.py

@@ -0,0 +1 @@
+# FastAPI app package (see main.py).

api/main.py

@@ -0,0 +1,277 @@
+"""
+FastAPI backend for the Own Your Code UI.
+
+Local: ``uvicorn api.main:app --reload --port 8002``
+
+Production: set ``PORT`` (e.g. Render/Fly). Optional ``OWN_YOUR_CODE_DB`` for SQLite path.
+
+Auth:
+  Set ``OWN_YOUR_CODE_API_KEY`` to require ``X-Api-Key: <key>`` on every request.
+  Leave unset to run without auth (local / trusted-network only).
+
+CORS:
+  Set ``OWN_YOUR_CODE_CORS_ORIGINS`` to a comma-separated list of allowed origins
+  (e.g. ``https://myapp.example.com,https://admin.example.com``).
+  Defaults to ``*`` (open) when unset.
+"""
+import os
+import sys
+import uuid
+from pathlib import Path
+from typing import Optional
+
+from fastapi import BackgroundTasks, Depends, FastAPI, Header, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+from src import db
+from src import embeddings as emb
+from src.extractor import scan_project_multi
+
+# ── config from environment ────────────────────────────────────────────────
+
+_API_KEY = os.environ.get("OWN_YOUR_CODE_API_KEY", "").strip()
+_CORS_RAW = os.environ.get("OWN_YOUR_CODE_CORS_ORIGINS", "*")
+_CORS_ORIGINS = [o.strip() for o in _CORS_RAW.split(",") if o.strip()]
+
+# ── auth ───────────────────────────────────────────────────────────────────
+
+def _auth(x_api_key: Optional[str] = Header(None, alias="X-Api-Key")):
+    """Require X-Api-Key header when OWN_YOUR_CODE_API_KEY is set."""
+    if _API_KEY and x_api_key != _API_KEY:
+        raise HTTPException(401, "Invalid or missing API key. Set X-Api-Key header.")
+
+# ── app ────────────────────────────────────────────────────────────────────
+
+app = FastAPI(
+    title="Own Your Code",
+    description="Living intent map — why your code exists, captured as you build via MCP.",
+    dependencies=[Depends(_auth)],
+)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=_CORS_ORIGINS,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# ── background embed job tracking ─────────────────────────────────────────
+
+_embed_jobs: dict[str, dict] = {}  # job_id -> {status, ...}
+
+
+@app.get("/health")
+def health():
+    return {"status": "ok", "service": "own-your-code"}
+
+
+class RegisterReq(BaseModel):
+    path: str
+    name: str = ""
+    languages: list[str] = []
+    include_globs: list[str] = []
+    ignore_dirs: list[str] = []
+
+class SearchReq(BaseModel):
+    project_path: str
+    query: str
+    mode: str = "keyword"          # keyword | semantic | hybrid
+    limit: int = 20
+    semantic_weight: float = 0.5
+
+
+@app.get("/projects")
+def list_projects():
+    return {"projects": db.list_projects()}
+
+
+@app.post("/register")
+def register(req: RegisterReq):
+    if not Path(req.path).exists():
+        raise HTTPException(400, f"Path not found: {req.path}")
+    pid = db.upsert_project(req.path, req.name or None)
+    functions, errors = scan_project_multi(
+        req.path,
+        include_globs=req.include_globs or None,
+        ignore_dirs=req.ignore_dirs or None,
+        languages=req.languages or None,
+    )
+    new = 0
+    lang_counts: dict[str, int] = {}
+    for fn in functions:
+        _, is_new = db.upsert_function(pid, fn)
+        if is_new:
+            new += 1
+        lang = fn.get("language", "python")
+        lang_counts[lang] = lang_counts.get(lang, 0) + 1
+    return {"project_id": pid, "path": req.path, "functions": len(functions),
+            "new": new, "by_language": lang_counts, "errors": errors}
+
+
+@app.get("/map")
+def codebase_map(project_path: str, file: Optional[str] = None):
+    proj = db.get_project(project_path)
+    if not proj: raise HTTPException(404, "Project not registered")
+    cmap = db.get_codebase_map(proj["id"])
+    if file:
+        if file not in cmap["by_file"]:
+            raise HTTPException(404, f"File '{file}' not in project map")
+        cmap["by_file"] = {file: cmap["by_file"][file]}
+    return cmap
+
+
+@app.get("/features")
+def features(project_path: str):
+    proj = db.get_project(project_path)
+    if not proj: raise HTTPException(404, "Not registered")
+    return {"features": db.get_features(proj["id"])}
+
+
+@app.get("/function")
+def explain(project_path: str, function_name: str, file: str = ""):
+    proj = db.get_project(project_path)
+    if not proj: raise HTTPException(404, "Not registered")
+    fn = db.get_function(proj["id"], function_name, file or None)
+    if not fn: raise HTTPException(404, f"Function '{function_name}' not found")
+    intents   = db.get_intents(fn["id"])
+    decisions = db.get_decisions(fn["id"])
+    evolution = db.get_evolution(fn["id"])
+    for row in intents:
+        if row.get("claude_reasoning") is not None:
+            row["agent_reasoning"] = row["claude_reasoning"]
+    return {**dict(fn), "intents": intents, "decisions": decisions, "evolution": evolution}
+
+
+@app.post("/search")
+def search(req: SearchReq):
+    proj = db.get_project(req.project_path)
+    if not proj:
+        raise HTTPException(404, "Not registered")
+
+    mode = req.mode
+    if mode == "semantic":
+        results, available = emb.semantic_search(proj["id"], req.query, limit=req.limit)
+        if not available:
+            raise HTTPException(422, "sentence-transformers not installed. Run: pip install sentence-transformers numpy")
+        mode_used = "semantic"
+    elif mode == "hybrid":
+        results, mode_used = emb.hybrid_search(
+            proj["id"], req.query, limit=req.limit, semantic_weight=req.semantic_weight
+        )
+    else:
+        results = db.search_intents(proj["id"], req.query)[: req.limit]
+        mode_used = "keyword"
+
+    return {"query": req.query, "mode": mode_used, "results": results}
+
+
+@app.post("/embed", status_code=202)
+def embed_intents(project_path: str, background_tasks: BackgroundTasks, model: str = emb.DEFAULT_MODEL):
+    """Start embedding in the background. Returns a job_id to poll with GET /embed/{job_id}."""
+    proj = db.get_project(project_path)
+    if not proj:
+        raise HTTPException(404, "Not registered")
+    job_id = uuid.uuid4().hex[:10]
+    _embed_jobs[job_id] = {"status": "running", "project_path": project_path, "model": model}
+
+    def _run():
+        try:
+            result = emb.embed_project(proj["id"], model_name=model)
+            _embed_jobs[job_id] = {"status": "done", **result}
+        except Exception as e:
+            _embed_jobs[job_id] = {"status": "error", "error": str(e)}
+
+    background_tasks.add_task(_run)
+    return {"job_id": job_id, "status": "running"}
+
+
+@app.get("/embed/{job_id}")
+def embed_status(job_id: str):
+    """Poll the status of a background embed job."""
+    job = _embed_jobs.get(job_id)
+    if not job:
+        raise HTTPException(404, f"Job '{job_id}' not found")
+    return job
+
+
+@app.get("/stats")
+def stats(project_path: str):
+    proj = db.get_project(project_path)
+    if not proj: raise HTTPException(404, "Not registered")
+    cmap = db.get_codebase_map(proj["id"])
+    total = cmap["total_functions"]
+    annotated = cmap["annotated"]
+    backlog = cmap.get("hook_backlog") or []
+    return {
+        "total": total,
+        "annotated": annotated,
+        "coverage": round(annotated / total * 100, 1) if total else 0,
+        "features": len(cmap["features"]),
+        "unannotated_files": cmap["unannotated_files"],
+        "hook_backlog": backlog,
+        "pending_hook_files": len(backlog),
+    }
+
+
+@app.get("/graph")
+def intent_graph(project_path: str):
+    """ReactFlow nodes + edges coloured by annotation status and feature."""
+    proj = db.get_project(project_path)
+    if not proj: raise HTTPException(404, "Not registered")
+
+    cmap = db.get_codebase_map(proj["id"])
+    features = {f["title"]: i for i, f in enumerate(cmap["features"])}
+
+    FEATURE_PALETTE = [
+        "#388bfd","#3fb950","#d29922","#bc8cff","#39d353",
+        "#f0883e","#58a6ff","#f85149","#79c0ff","#56d364",
+    ]
+
+    nodes, edges = [], []
+    fn_index: dict[str, int] = {}
+    i = 0
+
+    for file, fns in cmap["by_file"].items():
+        for fn in fns:
+            node_id = fn["qualname"]
+            fn_index[fn["qualname"]] = i
+
+            # figure out feature colour
+            intent = fn.get("intent")
+            color = "#484f58"  # unannotated
+            if intent:
+                color = "#3fb950"  # annotated but no feature
+
+            nodes.append({
+                "id": node_id,
+                "type": "intentNode",
+                "data": {
+                    "label":        fn["name"],
+                    "qualname":     fn["qualname"],
+                    "file":         fn["file"],
+                    "has_intent":   fn["has_intent"],
+                    "exists_because": intent["user_request"] if intent else None,
+                    "confidence":   intent["confidence"] if intent else None,
+                    "color":        color,
+                },
+                "position": {"x": (i % 6) * 280, "y": (i // 6) * 130},
+            })
+            i += 1
+
+    seen_edges = set()
+    for file, fns in cmap["by_file"].items():
+        pass  # call graph edges would come from extractor — omitted to keep response lean
+
+    return {"nodes": nodes, "edges": edges}
+
+
+# serve built UI
+UI_DIST = Path(__file__).parent.parent / "ui" / "dist"
+if UI_DIST.exists():
+    app.mount("/assets", StaticFiles(directory=UI_DIST / "assets"), name="assets")
+    @app.get("/{full_path:path}")
+    def serve_ui(full_path: str):
+        return FileResponse(UI_DIST / "index.html")

own_your_code-0.1.3.dist-info/METADATA

@@ -0,0 +1,396 @@
+Metadata-Version: 2.4
+Name: own-your-code
+Version: 0.1.3
+Summary: Own Your Code — MCP server + UI: record why each function exists, tradeoffs, and evolution (SQLite)
+Project-URL: Repository, https://github.com/khirodsahoo93/mcp-own-your-code
+License-Expression: MIT
+License-File: LICENSE
+Keywords: codebase,documentation,intent,mcp,sqlite
+Classifier: Development Status :: 4 - Beta
+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 :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: uvicorn[standard]>=0.32.0
+Provides-Extra: dev
+Requires-Dist: httpx>=0.27.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.4.0; extra == 'dev'
+Provides-Extra: full
+Requires-Dist: numpy>=1.26.0; extra == 'full'
+Requires-Dist: sentence-transformers>=2.7.0; extra == 'full'
+Requires-Dist: tree-sitter-go>=0.23.0; extra == 'full'
+Requires-Dist: tree-sitter-javascript>=0.23.0; extra == 'full'
+Requires-Dist: tree-sitter>=0.23.0; extra == 'full'
+Provides-Extra: multilang
+Requires-Dist: tree-sitter-go>=0.23.0; extra == 'multilang'
+Requires-Dist: tree-sitter-javascript>=0.23.0; extra == 'multilang'
+Requires-Dist: tree-sitter>=0.23.0; extra == 'multilang'
+Provides-Extra: semantic
+Requires-Dist: numpy>=1.26.0; extra == 'semantic'
+Requires-Dist: sentence-transformers>=2.7.0; extra == 'semantic'
+Description-Content-Type: text/markdown
+
+# Own Your Code
+
+**A living intent ledger for your codebase.**
+
+Own Your Code captures the *why* behind every function — user requests, tradeoffs, decisions, and evolution — recorded via MCP as you work. Search by keyword or semantic similarity. Browse in a React UI or query the MCP server directly.
+
+---
+
+## The problem
+
+Code is easy to read. It's impossible to understand.
+
+You can read `hybrid_search()` in 5 minutes and know what it does. You can't know:
+- Why cosine similarity instead of BM25?
+- Was keyword-only search tried and rejected?
+- What user request triggered this function?
+- How did it behave before the last refactor?
+
+That context lives in someone's head, a Slack thread, or nowhere.
+
+**Own Your Code captures it at the moment it's created — while you’re implementing the change.**
+
+---
+
+## Features
+
+- **Intent recording** — `record_intent` captures user request, reasoning, implementation notes, and confidence (typically from your MCP workflow).
+- **Decision log** — tradeoffs, alternatives considered, constraints that forced a choice.
+- **Evolution timeline** — every behavioral change with the reason and triggering request.
+- **Multi-language AST indexing** — Python, TypeScript, JavaScript, Go. Pluggable extractor architecture.
+- **Semantic search** — vector embeddings via `sentence-transformers`. Find `charge_card` by searching "what handles payments?".
+- **Hybrid search** — merges keyword rank + semantic cosine score with tunable weight.
+- **React UI** — Intent Map, Feature clusters, Search tab (keyword/semantic/hybrid), coverage bar, function detail panel.
+- **MCP server** — works with any host that supports the Model Context Protocol.
+- **FastAPI REST backend** — full API, suitable for team deployment.
+- **Production-ready** — API key auth, SQLite WAL mode, configurable CORS, background embed jobs, 47 tests.
+
+---
+
+## Quick start
+
+### 1. Install (pick one)
+
+**PyPI (after you publish, or use TestPyPI):**
+
+```bash
+pipx install own-your-code # recommended — puts own-your-code-mcp on PATH
+own-your-code install               # merges MCP config (see platform IDs below)
+```
+
+```bash
+python3 -m pip install own-your-code
+own-your-code install --platform editor-a
+own-your-code install --platform editor-b
+```
+
+**npm (wrapper — still requires Python 3.11+ on PATH):**
+
+```bash
+npx own-your-code-mcp install
+```
+
+This runs `pip install -U own-your-code` if needed, then the same `own-your-code install` as above. Publish the shim from `npm/own-your-code-mcp/` to the npm registry when you are ready.
+
+Use **`own-your-code-mcp` on PATH** (pipx/pip) for the actual MCP stdio server. The npm package is mainly so people who live in Node can run **`npx … install`** without memorizing pip; running MCP through `npx` is possible (`bin/mcp-shim.cjs`) but adds latency — prefer the Python binary when you can.
+
+**From source:**
+
+```bash
+git clone https://github.com/khirodsahoo93/mcp-own-your-code
+cd mcp-own-your-code
+python -m venv .venv && source .venv/bin/activate
+pip install -e .
+
+# With semantic search support
+pip install -e ".[semantic]"
+
+# With multi-language AST support (TypeScript, Go)
+pip install -e ".[full]"
+```
+
+Manual JSON fragment (if you skip `install`):
+
+```bash
+own-your-code print-config
+```
+
+**uv users:** if `own-your-code-mcp` is not on PATH but `uvx` is, `own-your-code install` writes a block that runs `uvx --from own-your-code own-your-code-mcp` (once the package is on PyPI).
+
+**`own-your-code install --platform` IDs** — each maps to a known config location on disk (see `src/cli.py` for exact paths). Use `all` to update every configured location.
+
+### 2. Add to your MCP host
+
+After `own-your-code install`, restart the editor. To configure by hand from a git checkout:
+
+```json
+{
+  "mcpServers": {
+    "own-your-code": {
+      "command": "/path/to/.venv/bin/python",
+      "args": ["-m", "src.server"],
+      "cwd": "/path/to/mcp-own-your-code"
+    }
+  }
+}
+```
+
+Or if installed as a package:
+
+```json
+{
+  "mcpServers": {
+    "own-your-code": {
+      "command": "own-your-code-mcp"
+    }
+  }
+}
+```
+
+### 3. Register your project
+
+From your MCP client:
+
+```
+register_project path="/path/to/your/project"
+```
+
+This scans all Python, TypeScript, JavaScript, and Go files and indexes every function.
+
+### 4. Start building
+
+As you write code, use `record_intent` from MCP (manually or via your host’s automation):
+
+```
+record_intent
+  project_path="/path/to/your/project"
+  file="src/auth.py"
+  function_name="verify_token"
+  user_request="Add JWT verification so the API rejects unsigned requests"
+  reasoning="Using PyJWT with RS256. Chose asymmetric keys so the public key can be distributed to services without exposing the signing key."
+  decisions=[{"decision": "RS256 over HS256", "reason": "Asymmetric — services can verify without the secret", "alternatives": ["HS256"]}]
+```
+
+### 5. Open the UI
+
+```bash
+uvicorn api.main:app --reload --port 8002
+```
+
+Open [http://localhost:8002](http://localhost:8002).
+
+---
+
+## MCP tools
+
+| Tool | Description |
+|------|-------------|
+| `register_project` | Scan and index a codebase (Python, TypeScript, JavaScript, Go) |
+| `record_intent` | Record why a function exists — user request, reasoning, decisions |
+| `record_evolution` | Log a behavioral change with the reason it happened |
+| `explain_function` | Get the full story: intent, decisions, evolution timeline |
+| `find_by_intent` | Search by keyword, semantic similarity, or hybrid |
+| `embed_intents` | Backfill vector embeddings for semantic search |
+| `get_codebase_map` | Full structured map: coverage, hook backlog, functions by file |
+| `get_evolution` | Timeline of changes for a specific function |
+| `annotate_existing` | Retroactively infer intents on a legacy codebase |
+| `mark_file_reviewed` | Clear hook backlog for a file without adding intent |
+
+---
+
+## REST API
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| `GET` | `/health` | Health check |
+| `GET` | `/projects` | List registered projects |
+| `POST` | `/register` | Register and index a project |
+| `GET` | `/map` | Full codebase map (supports `?file=` filter) |
+| `GET` | `/function` | Intent, decisions, evolution for one function |
+| `POST` | `/search` | Search intents (keyword / semantic / hybrid) |
+| `POST` | `/embed` | Start background embedding job (returns `job_id`) |
+| `GET` | `/embed/{job_id}` | Poll embedding job status |
+| `GET` | `/stats` | Coverage and hook backlog summary |
+| `GET` | `/features` | Feature clusters |
+| `GET` | `/graph` | ReactFlow-compatible node graph |
+
+---
+
+## Search modes
+
+```bash
+# Keyword — fast LIKE search over intent text
+find_by_intent project_path="..." query="authentication" mode="keyword"
+
+# Semantic — vector cosine similarity (run embed_intents first)
+find_by_intent project_path="..." query="what handles retries?" mode="semantic"
+
+# Hybrid — merges keyword rank + semantic score
+find_by_intent project_path="..." query="payment processing" mode="hybrid" semantic_weight=0.6
+```
+
+Via REST:
+
+```bash
+curl -X POST http://localhost:8002/search \
+  -H "Content-Type: application/json" \
+  -d '{"project_path": "/my/project", "query": "what handles payments?", "mode": "hybrid"}'
+```
+
+---
+
+## Multi-language support
+
+| Language | Parser | Fallback |
+|----------|--------|---------|
+| Python | `ast` (stdlib) | — |
+| TypeScript / JavaScript | `tree-sitter-javascript` | regex |
+| Go | `tree-sitter-go` | regex |
+
+Configure indexing:
+
+```json
+{
+  "path": "/my/project",
+  "languages": ["python", "typescript"],
+  "include_globs": ["src/**/*.ts", "src/**/*.py"],
+  "ignore_dirs": ["vendor", "generated"]
+}
+```
+
+---
+
+## Production deployment
+
+### Environment variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `OWN_YOUR_CODE_DB` | `owns.db` | Path to SQLite file |
+| `OWN_YOUR_CODE_API_KEY` | *(unset)* | Require `X-Api-Key` header. Leave unset for local use. |
+| `OWN_YOUR_CODE_CORS_ORIGINS` | `*` | Comma-separated allowed origins |
+| `OWN_YOUR_CODE_EMBED_MODEL` | `all-MiniLM-L6-v2` | Sentence-transformers model name |
+
+### Docker
+
+```bash
+docker compose up
+```
+
+Or standalone:
+
+```bash
+docker build -t own-your-code .
+docker run -p 8002:8002 \
+  -e OWN_YOUR_CODE_API_KEY=your-secret \
+  -e OWN_YOUR_CODE_CORS_ORIGINS=https://yourapp.com \
+  -v $(pwd)/data:/data \
+  -e OWN_YOUR_CODE_DB=/data/owns.db \
+  own-your-code
+```
+
+### Render / Fly.io
+
+A `render.yaml` is included. Set `OWN_YOUR_CODE_API_KEY` and `OWN_YOUR_CODE_DB` as environment variables in your deployment dashboard.
+
+---
+
+## Post-write hook
+
+The post-write hook fires when your editor saves a file and records it in the backlog. Any file written without a subsequent `record_intent` appears in `get_codebase_map` as pending.
+
+```bash
+# Install the hook script for non-pip use
+cp hooks/post_write.py .git/hooks/post-write && chmod +x .git/hooks/post-write
+
+# Or use the installed entry point
+own-your-code-hook
+```
+
+---
+
+## Development
+
+```bash
+# Install dev dependencies
+pip install -e ".[dev,full]"
+
+# Run tests
+pytest
+
+# Lint
+ruff check src/ api/ tests/
+
+# Build UI
+cd ui && npm install && npm run build
+```
+
+CI runs on Python 3.11, 3.12, and 3.13.
+
+---
+
+## Schema
+
+SQLite. Tables:
+
+| Table | Purpose |
+|-------|---------|
+| `projects` | Registered codebase roots |
+| `functions` | Every known function (AST-extracted) |
+| `intents` | Why a function exists — user request, reasoning, confidence |
+| `intent_embeddings` | Vector blobs for semantic search (schema v2) |
+| `decisions` | Tradeoffs and alternatives considered |
+| `evolution` | Timeline of behavioral changes |
+| `features` | High-level feature labels |
+| `feature_links` | Many-to-many: functions ↔ features |
+| `hook_events` | Files written by editor but not yet annotated |
+
+Schema version tracked via `PRAGMA user_version`. Migrations are safe to run on existing databases.
+
+---
+
+## Publishing (maintainers)
+
+### One-time setup
+
+1. **PyPI** — Create the project `own-your-code` on [pypi.org](https://pypi.org). Under **Manage → Publishing**, add a **trusted publisher** for this GitHub repo and workflow **`.github/workflows/release.yml`** (see [PyPI docs](https://docs.pypi.org/trusted-publishers/)).
+2. **npm** — Log in locally (`npm login`) once, or create a granular **Automation** token and add it as the GitHub secret **`NPM_TOKEN`** for this repository.
+
+### Automated (recommended)
+
+Push a **semver tag** after bumping `version` in `pyproject.toml` and `npm/own-your-code-mcp/package.json`:
+
+```bash
+# bump versions first, commit, then:
+git tag v0.1.0
+git push origin main && git push origin v0.1.0
+```
+
+GitHub Actions **Release** workflow uploads the wheel + sdist to **PyPI** and publishes **`own-your-code-mcp`** to npm.
+
+### Manual
+
+```bash
+python3 -m pip install build twine
+python3 -m build
+TWINE_USERNAME=__token__ TWINE_PASSWORD=pypi-YOUR_PYPI_API_TOKEN python3 -m twine upload dist/*
+```
+
+```bash
+cd npm/own-your-code-mcp
+npm publish --access public
+```
+
+## License
+
+MIT

own_your_code-0.1.3.dist-info/RECORD

@@ -0,0 +1,19 @@
+api/__init__.py,sha256=3QSkCx7ORWq_qIrtudYk1Ey39DlliYGIQHewa2v135s,38
+api/main.py,sha256=-vI887qYw9a3ZTpC_IYpDwvP0NwPje3HZpb8nAD1IuA,9953
+src/__init__.py,sha256=9ExkN107xEM1KrR7S31MneKnEC2IMZQ3v70ueM_Obag,57
+src/cli.py,sha256=S0DUl7xSkFeYWdidSZnOkVsaOljiuzuQCuPKbMM20mk,5449
+src/db.py,sha256=3SnjpEpvgB97DXdQHoD0EbaJJxZPVGTzF5V_V5OsR4A,21700
+src/embeddings.py,sha256=IRA9eLI8hvQh8rr0mPofbBjg3W-h1OtxL65hpjydHOA,7381
+src/extractor.py,sha256=1fh0O_grn1erjS3VX4vk1IdLqvWJsza1yftGDbKXKoc,6512
+src/post_write_hook.py,sha256=JvMGkKOWf71tBSp67QSVR_N41rqkjK5Nb5PBu9l8Csk,1925
+src/server.py,sha256=_raaDk0UR1HK7SNdhHGIg6eojtXCje6I0R21cBULizg,29058
+src/extractors/__init__.py,sha256=buFheF-09XS2QsdIbWetcoYI7lhYfHRXd2stT9xJeQY,1213
+src/extractors/base.py,sha256=vkl0HrFrrSr7VA4Al5pF7dLz1qqmSDd38oYsfRzJDa8,1554
+src/extractors/go_extractor.py,sha256=oCkLTEZQwrfexOv0DZKe6loh6D-sIwuv-TUoa3jY71I,5460
+src/extractors/python_extractor.py,sha256=7LnX364VUvvGDrlFgnf4qRUcoHcmVoP6sMwgq8-_W7I,563
+src/extractors/typescript_extractor.py,sha256=R0xQaxUo3bjphqX-4ELdWmx5iJVJ2kwACFXdeK71mYc,5961
+own_your_code-0.1.3.dist-info/METADATA,sha256=3acAZzEmBD_ybDbDdi8txFNEhOkpzRHBz1_LTD4yfrI,12785
+own_your_code-0.1.3.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+own_your_code-0.1.3.dist-info/entry_points.txt,sha256=5vIpnbN6LRlnaYcPN6GrE8jfx11bmLnFNjAIEFzD7Ms,129
+own_your_code-0.1.3.dist-info/licenses/LICENSE,sha256=F12SGcNKMiUvkSX_n9QSe-IwAw22i5d0szKsnTFMka4,1063
+own_your_code-0.1.3.dist-info/RECORD,,

own_your_code-0.1.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any