codegraph-kit 0.1.0__py3-none-any.whl

codegraph_kit/__init__.py

@@ -0,0 +1,4 @@
+"""codegraph — cached, incremental code-graph maps so AI agents query structure
+instead of reading whole files."""
+
+__version__ = "0.1.0"

codegraph_kit/cli.py

@@ -0,0 +1,106 @@
+"""codegraph — cached, incremental code-graph maps so agents query structure
+instead of reading whole files. Backed by graphify (tree-sitter AST extraction).
+
+  codegraph build [dir]          full graph build (registers repo root)
+  codegraph ensure [dir]         incremental refresh (only changed files re-extracted)
+  codegraph map [dir]            compact overview: counts, per-dir breakdown, top hubs
+  codegraph file <path>          outline of one file (defs + line ranges -> sliced reads)
+  codegraph sym <name> [dir]     locate symbol by substring -> file + lines
+  codegraph callers <name> [dir] who calls it
+  codegraph callees <name> [dir] what it calls
+  codegraph deps <path>          imports of a file
+  codegraph touch <path>         re-extract one file into its repo's cache (hook use)
+  codegraph agent                print an instruction snippet for AGENTS.md / CLAUDE.md
+  codegraph mcp                  run as an MCP server (requires `pip install codegraph-kit[mcp]`)
+  codegraph --version            print version
+
+Queries auto-run `ensure` first, so the graph tracks the working tree.
+"""
+import sys
+from pathlib import Path
+
+from . import __version__, core, queries
+
+AGENT_SNIPPET = """\
+## Code navigation — graph first, read only what you need
+
+This repo has `codegraph` (cached tree-sitter code graphs). Before reading
+source files, query the graph and then read ONLY the located line ranges:
+
+- `codegraph map` — repo overview: size, per-directory breakdown, top hub symbols
+- `codegraph file <path>` — outline of a file (definitions + line ranges)
+- `codegraph sym <name>` — locate a symbol -> file:lines
+- `codegraph callers <name>` / `codegraph callees <name>` — trace call edges
+- `codegraph deps <path>` — what a file imports
+
+Run `codegraph build` once per repo; afterwards every query refreshes changed
+files automatically. Fall back to reading whole files only when the graph
+can't answer (unsupported language, dynamic dispatch, subtle logic).
+"""
+
+
+def main(argv=None):
+    args = sys.argv[1:] if argv is None else argv
+    if not args or args[0] in ("-h", "--help", "help"):
+        print(__doc__)
+        return 0
+    cmd = args[0]
+    tail = args[1:]
+
+    if cmd in ("--version", "-V", "version"):
+        print(f"codegraph {__version__}")
+        return 0
+    if cmd == "agent":
+        print(AGENT_SNIPPET)
+        return 0
+    if cmd == "mcp":
+        from .mcp_server import run  # lazy: needs the [mcp] extra
+        run()
+        return 0
+
+    target = None
+    if cmd in ("build", "ensure", "map", "hubs"):
+        root = core.find_root(Path(tail[0]).resolve() if tail else Path.cwd())
+    elif cmd in ("file", "deps", "touch"):
+        if not tail:
+            print(f"usage: codegraph {cmd} <path>", file=sys.stderr)
+            return 2
+        target = Path(tail[0]).resolve()
+        root = core.find_root(target)
+    elif cmd in ("sym", "callers", "callees"):
+        if not tail:
+            print(f"usage: codegraph {cmd} <name> [dir]", file=sys.stderr)
+            return 2
+        root = core.find_root(Path(tail[1]).resolve() if len(tail) > 1 else Path.cwd())
+    else:
+        print(f"unknown command: {cmd}")
+        print(__doc__)
+        return 2
+
+    if cmd == "build":
+        g, idx, n = core.build(root)
+        print(f"built {root}: {n} files -> {len(g['nodes'])} nodes, {len(g['edges'])} edges")
+        return 0
+    if cmd == "touch":
+        core.touch(target, root)
+        return 0
+
+    g = core.ensure(root)
+
+    if cmd == "ensure":
+        print(f"{root}: {len(g['nodes'])} nodes, {len(g['edges'])} edges (fresh)")
+    elif cmd in ("map", "hubs"):
+        print(queries.q_map(root, g))
+    elif cmd == "file":
+        print(queries.q_file(root, g, target))
+    elif cmd == "sym":
+        print(queries.q_sym(root, g, tail[0]))
+    elif cmd in ("callers", "callees"):
+        print(queries.q_calls(root, g, tail[0], cmd))
+    elif cmd == "deps":
+        print(queries.q_deps(root, g, target))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

codegraph_kit/core.py

@@ -0,0 +1,181 @@
+"""Graph building, caching, and incremental refresh.
+
+Graphs are stored per-repo under the cache dir (default ~/.cache/codegraph,
+override with $CODEGRAPH_CACHE). Extraction is delegated to graphify
+(tree-sitter AST parsing); this layer adds root discovery, mtime-based
+incremental rebuilds, and root-relative path normalization.
+"""
+import hashlib
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+CODE_EXTS = {".py", ".js", ".ts", ".tsx", ".jsx", ".mjs", ".go", ".rs", ".java",
+             ".rb", ".c", ".h", ".cpp", ".hpp", ".cs", ".php", ".swift", ".kt", ".sh"}
+SKIP_DIRS = {".git", "node_modules", "venv", ".venv", "__pycache__", "dist", "build",
+             ".next", "target", ".cache", "vendor", "site-packages", ".tox", "coverage"}
+MAX_FILES = 5000
+MAX_FILE_BYTES = 1_000_000
+
+
+def cache_dir() -> Path:
+    env = os.environ.get("CODEGRAPH_CACHE")
+    return Path(env) if env else Path.home() / ".cache" / "codegraph"
+
+
+def roots_file() -> Path:
+    return cache_dir() / "roots.json"
+
+
+def repo_key(root: Path) -> Path:
+    return cache_dir() / hashlib.sha1(str(root).encode()).hexdigest()[:16]
+
+
+def find_root(start: Path) -> Path:
+    p = start if start.is_dir() else start.parent
+    for q in [p, *p.parents]:
+        if (q / ".git").exists():
+            return q
+    return p
+
+
+def code_files(root: Path):
+    out = []
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [d for d in dirnames if d not in SKIP_DIRS and not d.startswith(".")]
+        for f in filenames:
+            fp = Path(dirpath) / f
+            if fp.suffix in CODE_EXTS and fp.stat().st_size < MAX_FILE_BYTES:
+                out.append(fp)
+    if len(out) > MAX_FILES:
+        print(f"WARNING: {len(out)} code files; graphing first {MAX_FILES} "
+              f"(largest dirs may be partial)", file=sys.stderr)
+        out = out[:MAX_FILES]
+    return out
+
+
+def load(root: Path):
+    d = repo_key(root)
+    try:
+        graph = json.loads((d / "graph.json").read_text())
+        idx = json.loads((d / "index.json").read_text())
+        return graph, idx
+    except Exception:
+        return None, None
+
+
+def save(root: Path, graph, idx):
+    d = repo_key(root)
+    d.mkdir(parents=True, exist_ok=True)
+    (d / "graph.json").write_text(json.dumps(graph))
+    (d / "index.json").write_text(json.dumps(idx))
+    rf = roots_file()
+    try:
+        roots = json.loads(rf.read_text()) if rf.exists() else {}
+    except Exception:
+        roots = {}
+    roots[str(root)] = time.strftime("%Y-%m-%dT%H:%M:%S")
+    rf.write_text(json.dumps(roots, indent=1))
+
+
+def extract_files(paths, root):
+    """Extract and normalize source_file to root-relative. graphify stores paths
+    relative to the common ancestor of the batch (basename for single/same-dir
+    batches), so we resolve via that ancestor. Unattributable ('' semantic) nodes
+    are dropped — they'd break incremental dedup."""
+    from graphify.extract import extract
+    ok_nodes, ok_edges, failed = [], [], []
+    resolved = [p.resolve() for p in paths]
+    if not resolved:
+        return ok_nodes, ok_edges, failed
+    common = Path(os.path.commonpath([str(p) for p in resolved])) if len(resolved) > 1 else resolved[0].parent
+    if common.is_file():
+        common = common.parent
+
+    def norm(sf):
+        if not sf:
+            return None
+        try:
+            return str((common / sf).resolve().relative_to(root))
+        except ValueError:
+            return None
+
+    def collect(r):
+        for n in r["nodes"]:
+            sf = norm(n.get("source_file", ""))
+            if sf:
+                n["source_file"] = sf
+                ok_nodes.append(n)
+        for e in r["edges"]:
+            sf = norm(e.get("source_file", ""))
+            if sf:
+                e["source_file"] = sf
+                ok_edges.append(e)
+
+    try:
+        collect(extract(paths=resolved, parallel=len(resolved) > 4))
+    except Exception:
+        for p in resolved:
+            common = p.parent
+            try:
+                collect(extract(paths=[p], parallel=False))
+            except Exception:
+                failed.append(str(p))
+    return ok_nodes, ok_edges, failed
+
+
+def build(root: Path, only_changed=False):
+    files = code_files(root)
+    graph, idx = load(root)
+    mtimes = {str(f.relative_to(root)): f.stat().st_mtime for f in files}
+    if only_changed and graph and idx:
+        old = idx.get("mtimes", {})
+        changed = [f for f in files if old.get(str(f.relative_to(root))) != f.stat().st_mtime]
+        deleted = set(old) - set(mtimes)
+        if not changed and not deleted:
+            return graph, idx, 0
+        drop = {str(f.relative_to(root)) for f in changed} | deleted
+        nodes = [n for n in graph["nodes"] if n.get("source_file", "") not in drop]
+        edges = [e for e in graph["edges"] if e.get("source_file", "") not in drop]
+        new_n, new_e, failed = extract_files(changed, root)
+        graph = {"nodes": nodes + new_n, "edges": edges + new_e}
+        n_processed = len(changed)
+    else:
+        new_n, new_e, failed = extract_files(files, root)
+        graph = {"nodes": new_n, "edges": new_e}
+        n_processed = len(files)
+    if failed:
+        print(f"WARNING: {len(failed)} files failed extraction: {failed[:5]}", file=sys.stderr)
+    idx = {"root": str(root), "mtimes": mtimes, "built": time.strftime("%Y-%m-%dT%H:%M:%S"),
+           "failed": failed}
+    save(root, graph, idx)
+    return graph, idx, n_processed
+
+
+def ensure(root: Path):
+    graph, idx, n = build(root, only_changed=True)
+    if n:
+        print(f"[codegraph] refreshed {n} file(s)", file=sys.stderr)
+    return graph
+
+
+def touch(target: Path, root: Path):
+    """Re-extract one file into its repo's cached graph. No-op when the repo
+    has no graph yet (hooks call this on every edit)."""
+    g, idx = load(root)
+    if not g:
+        return
+    f = str(target.relative_to(root))
+    nodes = [n for n in g["nodes"] if n.get("source_file", "") != f]
+    edges = [e for e in g["edges"] if e.get("source_file", "") != f]
+    if target.exists() and target.suffix in CODE_EXTS:
+        nn, ne, _ = extract_files([target], root)
+        nodes += nn
+        edges += ne
+    if target.exists():
+        idx["mtimes"][f] = target.stat().st_mtime
+    else:
+        idx["mtimes"].pop(f, None)
+    save(root, {"nodes": nodes, "edges": edges}, idx)

codegraph_kit/mcp_server.py

@@ -0,0 +1,84 @@
+"""MCP server exposing codegraph queries as tools, for agents that speak MCP
+instead of shelling out. Requires the `mcp` extra: pip install codegraph-kit[mcp]
+
+Run:  codegraph mcp        (stdio transport)
+"""
+from pathlib import Path
+
+from . import core, queries
+
+try:
+    from mcp.server.fastmcp import FastMCP
+except ImportError as e:  # pragma: no cover
+    raise SystemExit(
+        "MCP support needs the optional dependency: pip install codegraph-kit[mcp]"
+    ) from e
+
+server = FastMCP(
+    "codegraph",
+    instructions=(
+        "Cached tree-sitter code graphs. Query structure (outlines, symbols, "
+        "call edges, imports) instead of reading whole files; then read only "
+        "the located line ranges."
+    ),
+)
+
+
+def _root(directory: str) -> Path:
+    return core.find_root(Path(directory).resolve())
+
+
+@server.tool()
+def graph_map(directory: str) -> str:
+    """Repo overview: node/edge counts, per-directory breakdown, top hub symbols."""
+    root = _root(directory)
+    return queries.q_map(root, core.ensure(root))
+
+
+@server.tool()
+def file_outline(path: str) -> str:
+    """Outline of one source file: definitions with line ranges."""
+    target = Path(path).resolve()
+    root = core.find_root(target)
+    return queries.q_file(root, core.ensure(root), target)
+
+
+@server.tool()
+def find_symbol(name: str, directory: str = ".") -> str:
+    """Locate a symbol by substring -> file:lines."""
+    root = _root(directory)
+    return queries.q_sym(root, core.ensure(root), name)
+
+
+@server.tool()
+def callers(name: str, directory: str = ".") -> str:
+    """Who calls this symbol (matched by substring)."""
+    root = _root(directory)
+    return queries.q_calls(root, core.ensure(root), name, "callers")
+
+
+@server.tool()
+def callees(name: str, directory: str = ".") -> str:
+    """What this symbol calls (matched by substring)."""
+    root = _root(directory)
+    return queries.q_calls(root, core.ensure(root), name, "callees")
+
+
+@server.tool()
+def file_deps(path: str) -> str:
+    """Imports of a source file."""
+    target = Path(path).resolve()
+    root = core.find_root(target)
+    return queries.q_deps(root, core.ensure(root), target)
+
+
+@server.tool()
+def build_graph(directory: str) -> str:
+    """Full (re)build of a repo's graph. Run once per repo; queries refresh incrementally."""
+    root = _root(directory)
+    g, _idx, n = core.build(root)
+    return f"built {root}: {n} files -> {len(g['nodes'])} nodes, {len(g['edges'])} edges"
+
+
+def run():
+    server.run()

codegraph_kit/queries.py

@@ -0,0 +1,81 @@
+"""Query functions over a built graph. Each returns a plain string ready to
+show to a human or an agent — the CLI prints it, the MCP server returns it."""
+from collections import Counter
+from pathlib import Path
+
+from . import core
+
+
+def loc(n):
+    return f"{n.get('source_file', '?')}:{n.get('source_location', '?')}"
+
+
+def fmt_node(n):
+    return f"{n.get('label', n['id'])}  [{n.get('type', n.get('_origin', '?'))}]  {loc(n)}"
+
+
+def fresh_graph(root: Path):
+    return core.ensure(root)
+
+
+def q_map(root: Path, g) -> str:
+    nodes, edges = g["nodes"], g["edges"]
+    deg = Counter()
+    for e in edges:
+        deg[e["source"]] += 1
+        deg[e["target"]] += 1
+    byid = {n["id"]: n for n in nodes}
+    per_dir = Counter(n.get("source_file", "?").split("/")[0] for n in nodes)
+    rels = Counter(e.get("relation", "?") for e in edges)
+    lines = [f"{root} — {len(nodes)} nodes, {len(edges)} edges",
+             f"per-dir: {dict(per_dir.most_common(12))}",
+             f"relations: {dict(rels.most_common())}",
+             "top hubs:"]
+    for nid, d in deg.most_common(15):
+        n = byid.get(nid)
+        if n:
+            lines.append(f"  {d:4d}  {fmt_node(n)}")
+    return "\n".join(lines)
+
+
+def q_file(root: Path, g, target: Path) -> str:
+    f = str(target.resolve().relative_to(root))
+    mine = [n for n in g["nodes"] if n.get("source_file", "") == f]
+    if not mine:
+        return f"(no graph entries for {f} — unsupported language or empty; read it directly)"
+    return "\n".join(fmt_node(n) for n in sorted(mine, key=lambda x: x.get("source_location", "")))
+
+
+def q_sym(root: Path, g, query: str, limit: int = 30) -> str:
+    q = query.lower()
+    hits = [n for n in g["nodes"] if q in n.get("label", "").lower() or q in n["id"].lower()]
+    if not hits:
+        return f"no symbol matching '{query}' — try grep"
+    lines = [fmt_node(n) for n in hits[:limit]]
+    if len(hits) > limit:
+        lines.append(f"... {len(hits) - limit} more (narrow the query)")
+    return "\n".join(lines)
+
+
+def q_calls(root: Path, g, query: str, direction: str, limit: int = 40) -> str:
+    """direction: 'callers' (who calls it) or 'callees' (what it calls)."""
+    q = query.lower()
+    byid = {n["id"]: n for n in g["nodes"]}
+    key, other = ("target", "source") if direction == "callers" else ("source", "target")
+    hits = [e for e in g["edges"] if e.get("relation") == "calls" and q in e[key].lower()]
+    if not hits:
+        return (f"no call edges matching '{query}' "
+                "(dynamic dispatch isn't captured — fall back to grep)")
+    lines = []
+    for e in hits[:limit]:
+        n = byid.get(e[other])
+        lines.append(fmt_node(n) if n else
+                     f"{e[other]}  ({e.get('source_file', '?')}:{e.get('source_location', '?')})")
+    return "\n".join(lines)
+
+
+def q_deps(root: Path, g, target: Path) -> str:
+    f = str(target.resolve().relative_to(root))
+    lines = [f"{e['relation']:13s} {e['target']}" for e in g["edges"]
+             if e.get("source_file", "") == f and e.get("relation") in ("imports", "imports_from")]
+    return "\n".join(lines) if lines else f"(no import edges recorded for {f})"

codegraph_kit-0.1.0.dist-info/METADATA

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: codegraph-kit
+Version: 0.1.0
+Summary: Cached, incremental code-graph maps so AI agents query code structure instead of reading whole files. Works with any agent: CLI for Claude Code/Codex/Cursor/Aider, optional MCP server.
+Project-URL: Homepage, https://github.com/nguyenminhduc9988/codegraph
+Project-URL: Repository, https://github.com/nguyenminhduc9988/codegraph
+Project-URL: Issues, https://github.com/nguyenminhduc9988/codegraph/issues
+Author: Duc Nguyen
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai-agents,claude-code,code-graph,codebase-map,mcp,static-analysis,token-efficiency,tree-sitter
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+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
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.10
+Requires-Dist: graphifyy>=0.9
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.0; extra == 'mcp'
+Description-Content-Type: text/markdown
+
+# codegraph
+
+**Cached, incremental code-graph maps so AI agents query code structure instead of reading whole files.**
+
+Agents burn most of their tokens reading source files to answer structural questions — "where is this defined?", "who calls this?", "what does this file import?". `codegraph` answers those questions from a cached tree-sitter AST graph in milliseconds, so the agent reads only the exact line ranges it needs.
+
+```
+$ codegraph sym cli_fallback
+CLIFallback  [class]  agent/cli_fallback.py:24-210
+run_cascade  [function]  agent/cli_fallback.py:96-158
+
+$ codegraph callers run_cascade
+handle_turn  [function]  agent/loop.py:311-360
+retry_turn   [function]  agent/loop.py:402-431
+```
+
+One `build` per repo; after that, every query auto-refreshes only the files that changed since the last call (mtime-based). No daemon, no database, no API keys — a JSON cache under `~/.cache/codegraph`.
+
+## Install
+
+```bash
+pip install codegraph-kit          # CLI
+pip install "codegraph-kit[mcp]"   # CLI + MCP server
+```
+
+Python ≥ 3.10. Parsing is done by [graphify](https://pypi.org/project/graphifyy/) (tree-sitter), which ships wheels for Python, JavaScript, TypeScript, Go, Rust, Java, Ruby, C, C++, C#, PHP, Swift, Kotlin, shell, and more.
+
+## Commands
+
+| Command | What it answers |
+|---|---|
+| `codegraph build [dir]` | full graph build (run once per repo) |
+| `codegraph map [dir]` | repo overview: size, per-directory breakdown, top hub symbols |
+| `codegraph file <path>` | outline of one file: definitions + line ranges |
+| `codegraph sym <name>` | where is this symbol defined? |
+| `codegraph callers <name>` | who calls it? |
+| `codegraph callees <name>` | what does it call? |
+| `codegraph deps <path>` | what does this file import? |
+| `codegraph ensure [dir]` | incremental refresh (queries do this automatically) |
+| `codegraph touch <path>` | re-extract one file (for editor/agent hooks) |
+| `codegraph agent` | print an instruction snippet for your agent's context file |
+| `codegraph mcp` | run as an MCP server (stdio) |
+
+## Integrate with any agent
+
+`codegraph` is plain CLI-over-stdout, so **any agent that can run shell commands can use it** — Claude Code, Codex CLI, Cursor, Aider, OpenHands, Goose, custom agents. Two steps:
+
+**1. Tell the agent the graph exists.** Append the ready-made snippet to your agent's context file:
+
+```bash
+codegraph agent >> AGENTS.md      # or CLAUDE.md, .cursorrules, .github/copilot-instructions.md
+```
+
+**2. (Optional) Keep the graph fresh on every edit.** For Claude Code, install the bundled PostToolUse hook so each `Edit`/`Write` re-extracts just that file:
+
+```bash
+cp integrations/claude-code/codegraph-touch.sh ~/.claude/hooks/
+chmod +x ~/.claude/hooks/codegraph-touch.sh
+# then merge integrations/claude-code/settings-snippet.json into ~/.claude/settings.json
+```
+
+Even without a hook, queries stay correct: every query runs an mtime check first and re-extracts anything stale.
+
+### MCP (for agents that don't shell out)
+
+```bash
+pip install "codegraph-kit[mcp]"
+```
+
+Register `codegraph mcp` as a stdio server. For Claude Code:
+
+```bash
+claude mcp add codegraph -- codegraph mcp
+```
+
+Tools exposed: `build_graph`, `graph_map`, `file_outline`, `find_symbol`, `callers`, `callees`, `file_deps` — same output as the CLI.
+
+## Why not just let the agent read files?
+
+Reading a 1,500-line file to find one function costs ~15k tokens; `codegraph file` returns the outline in ~200 tokens, and the agent then reads only the 40-line range it needs. On large repos the difference compounds — structural questions (symbol lookup, call tracing, import mapping) stop costing file-reads entirely.
+
+Honest limitations, printed in the output when they apply:
+
+- **Dynamic dispatch isn't captured** — call edges come from static AST analysis; `getattr`-style calls need grep.
+- **Unsupported/exotic languages** fall back to "read it directly".
+- Caps: 5,000 files per repo, 1 MB per file (warned, not silent).
+
+## How it works
+
+1. `build` walks the repo (skipping `node_modules`, `venv`, `dist`, …), runs tree-sitter extraction via graphify, normalizes all paths root-relative, and writes `graph.json` + an mtime index to `~/.cache/codegraph/<repo-hash>/`.
+2. Every query calls `ensure` first: files whose mtime changed are re-extracted and spliced into the graph; deleted files are dropped. Typical refresh is a handful of files, so queries stay fast.
+3. Output is deliberately plain text with `file:line` locations — clickable in most agent UIs and trivially parseable.
+
+Set `CODEGRAPH_CACHE` to relocate the cache (useful in CI and sandboxes).
+
+## License
+
+MIT

codegraph_kit-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+codegraph_kit/__init__.py,sha256=hvT298W9v1mmnYe6HKgi4U1MfRNt6u7-aBa4nW2Th4k,140
+codegraph_kit/cli.py,sha256=Q70kSZp5LLigQVrukoWg6bRDN7ixJQzeQ7cPxkadUOU,4042
+codegraph_kit/core.py,sha256=QrGDrZc32ODJt6HFj4TedxrGJkwJcvyc7Br7wnEKqW8,6359
+codegraph_kit/mcp_server.py,sha256=mICw1h5P9oiwEg1LWYTfi7j8Y8ow9zbtFd_cryc1bVE,2494
+codegraph_kit/queries.py,sha256=_1E6KhyBhfxE1-BVxwIBbthSFFoeBoDKcn9OT97WS98,3164
+codegraph_kit-0.1.0.dist-info/METADATA,sha256=LCFlHepudvDuCNLE-vL-29JMj8GH9j7T37TEwSZjeNY,6071
+codegraph_kit-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+codegraph_kit-0.1.0.dist-info/entry_points.txt,sha256=0h9B03fi5q4ApHocwXm6W6fbzwZno_Z7cf-W6HW-PSE,53
+codegraph_kit-0.1.0.dist-info/licenses/LICENSE,sha256=bIcrUqZy4o04kz-4Awxz8HWXHjdwL0YlBZ-GhsuQqgk,1067
+codegraph_kit-0.1.0.dist-info/RECORD,,

codegraph_kit-0.1.0.dist-info/WHEEL

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

codegraph_kit-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+codegraph = codegraph_kit.cli:main

codegraph_kit-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Duc Nguyen
+
+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.