ctxgraph 0.5.3__tar.gz → 0.5.4__tar.gz

{ctxgraph-0.5.3 → ctxgraph-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ctxgraph
-Version: 0.5.3
+Version: 0.5.4
 Summary: 97% cheaper AI coding. ctxgraph builds a knowledge graph of your Python codebase, then generates token-efficient context capsules for any AI tool. Or hook up Ollama/Claude/OpenAI and use it as a code-aware coding assistant — like ChatGPT or Claude Code, but with built-in graph context. Cut token costs by 97%, work offline with just a graph, or connect your favorite LLM.
 Author: ctxgraph contributors
 License: MIT
@@ -177,6 +177,60 @@ ctx capsule "user authentication" --savings
 
 ---
 
+## Approach Comparison
+
+Independent analysis by Claude compared ctxgraph's token efficiency against other common approaches for the same task — answering `"how does InventoryService link to OrderService"` in a real codebase:
+
+![Approach comparison](docs/approach-comparison.png)
+
+### How each approach works step-by-step
+
+**ctxgraph (graph-based surgical fetch)**
+```
+search_graph("InventoryService OrderService")   → paths only (~50 tok)
+get_file_dependencies()                          → dependency map
+read_file × 2                                    → exact files needed
+Done. 0 irrelevant tokens.
+```
+
+**Claude Code (agentic filesystem access)**
+```
+Load system prompt (~1,500 tok)
+Glob("**/*service*")                              → list paths
+Grep("InventoryService")                          → narrow hits
+Read × 2–3 (target files + maybe models.py)
+Answer. Small extra overhead from explore steps.
+```
+
+**CLAUDE.md approach (static map)**
+```
+Load full index (~2,800 tok) — paid every session
+Scan index manually, pick files
+Read × 2 (explicit paths)
+Index cost is fixed — paid even for unrelated queries.
+```
+
+**No tooling (full dump)**
+```
+All 34 files pasted in (~85k tok)
+Context overflow risk above ~200 files
+Early files pushed out, answers degrade
+Not viable at scale.
+```
+
+| Approach | Total Input Tokens | Tool Calls | Session Overhead |
+|---|---|---|---|
+| ctxgraph | **~5,600** | 3 | ~0 |
+| Claude Code | ~8,000 | 4–6 | ~1,500 (system prompt) |
+| CLAUDE.md | ~8,400 | 2 | ~2,800 (static index) |
+| No tooling | ~85,000+ | 0 | — |
+
+The key insight: **ctxgraph's graph is pre-built.** `search_graph` returns file paths for ~50 tokens, then you fetch only what you need. Agentic approaches (Claude Code) burn tokens exploring the filesystem dynamically. Static index approaches (CLAUDE.md) burn tokens loading a full index on every session — even for unrelated queries.
+
+---
+
+
+
 ## Commands
 
 ### `ctx init` — Scaffold project

{ctxgraph-0.5.3 → ctxgraph-0.5.4}/README.md

@@ -148,6 +148,60 @@ ctx capsule "user authentication" --savings
 
 ---
 
+## Approach Comparison
+
+Independent analysis by Claude compared ctxgraph's token efficiency against other common approaches for the same task — answering `"how does InventoryService link to OrderService"` in a real codebase:
+
+![Approach comparison](docs/approach-comparison.png)
+
+### How each approach works step-by-step
+
+**ctxgraph (graph-based surgical fetch)**
+```
+search_graph("InventoryService OrderService")   → paths only (~50 tok)
+get_file_dependencies()                          → dependency map
+read_file × 2                                    → exact files needed
+Done. 0 irrelevant tokens.
+```
+
+**Claude Code (agentic filesystem access)**
+```
+Load system prompt (~1,500 tok)
+Glob("**/*service*")                              → list paths
+Grep("InventoryService")                          → narrow hits
+Read × 2–3 (target files + maybe models.py)
+Answer. Small extra overhead from explore steps.
+```
+
+**CLAUDE.md approach (static map)**
+```
+Load full index (~2,800 tok) — paid every session
+Scan index manually, pick files
+Read × 2 (explicit paths)
+Index cost is fixed — paid even for unrelated queries.
+```
+
+**No tooling (full dump)**
+```
+All 34 files pasted in (~85k tok)
+Context overflow risk above ~200 files
+Early files pushed out, answers degrade
+Not viable at scale.
+```
+
+| Approach | Total Input Tokens | Tool Calls | Session Overhead |
+|---|---|---|---|
+| ctxgraph | **~5,600** | 3 | ~0 |
+| Claude Code | ~8,000 | 4–6 | ~1,500 (system prompt) |
+| CLAUDE.md | ~8,400 | 2 | ~2,800 (static index) |
+| No tooling | ~85,000+ | 0 | — |
+
+The key insight: **ctxgraph's graph is pre-built.** `search_graph` returns file paths for ~50 tokens, then you fetch only what you need. Agentic approaches (Claude Code) burn tokens exploring the filesystem dynamically. Static index approaches (CLAUDE.md) burn tokens loading a full index on every session — even for unrelated queries.
+
+---
+
+
+
 ## Commands
 
 ### `ctx init` — Scaffold project

{ctxgraph-0.5.3 → ctxgraph-0.5.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ctxgraph"
-version = "0.5.3"
+version = "0.5.4"
 description = "97% cheaper AI coding. ctxgraph builds a knowledge graph of your Python codebase, then generates token-efficient context capsules for any AI tool. Or hook up Ollama/Claude/OpenAI and use it as a code-aware coding assistant — like ChatGPT or Claude Code, but with built-in graph context. Cut token costs by 97%, work offline with just a graph, or connect your favorite LLM."
 readme = "README.md"
 license = {text = "MIT"}

{ctxgraph-0.5.3 → ctxgraph-0.5.4}/src/ctxgraph/chat.py

@@ -177,6 +177,8 @@ def interactive_session_picker(repo_path: Path) -> Optional[str]:
     table.add_column("Last", style="white")
 
     def render_table(highlight: int) -> Table:
+        from rich.markup import escape
+
         t = Table(title="Chat Sessions  (↑/↓ select, Enter confirm, Esc cancel)", show_header=True)
         t.add_column("#", style="dim", width=3)
         t.add_column("ID", style="cyan")
@@ -184,13 +186,14 @@ def interactive_session_picker(repo_path: Path) -> Optional[str]:
         t.add_column("Tokens", style="magenta", justify="right")
         t.add_column("Last", style="white")
         for i, s in enumerate(sessions):
-            style = "reverse" if i == highlight else ""
+            row_style = "reverse" if i == highlight else None
             t.add_row(
-                f"{i + 1}",
-                f"[{style}]{s['id']}[/{style}]",
-                f"[{style}]{s['turns']}[/{style}]",
-                f"[{style}]{s['tokens']}[/{style}]",
-                f"[{style}]{s['last_message']}[/{style}]",
+                str(i + 1),
+                escape(s["id"]),
+                str(s["turns"]),
+                str(s["tokens"]),
+                escape(s["last_message"]),
+                style=row_style,
             )
         return t
 

{ctxgraph-0.5.3 → ctxgraph-0.5.4}/src/ctxgraph.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ctxgraph
-Version: 0.5.3
+Version: 0.5.4
 Summary: 97% cheaper AI coding. ctxgraph builds a knowledge graph of your Python codebase, then generates token-efficient context capsules for any AI tool. Or hook up Ollama/Claude/OpenAI and use it as a code-aware coding assistant — like ChatGPT or Claude Code, but with built-in graph context. Cut token costs by 97%, work offline with just a graph, or connect your favorite LLM.
 Author: ctxgraph contributors
 License: MIT
@@ -177,6 +177,60 @@ ctx capsule "user authentication" --savings
 
 ---
 
+## Approach Comparison
+
+Independent analysis by Claude compared ctxgraph's token efficiency against other common approaches for the same task — answering `"how does InventoryService link to OrderService"` in a real codebase:
+
+![Approach comparison](docs/approach-comparison.png)
+
+### How each approach works step-by-step
+
+**ctxgraph (graph-based surgical fetch)**
+```
+search_graph("InventoryService OrderService")   → paths only (~50 tok)
+get_file_dependencies()                          → dependency map
+read_file × 2                                    → exact files needed
+Done. 0 irrelevant tokens.
+```
+
+**Claude Code (agentic filesystem access)**
+```
+Load system prompt (~1,500 tok)
+Glob("**/*service*")                              → list paths
+Grep("InventoryService")                          → narrow hits
+Read × 2–3 (target files + maybe models.py)
+Answer. Small extra overhead from explore steps.
+```
+
+**CLAUDE.md approach (static map)**
+```
+Load full index (~2,800 tok) — paid every session
+Scan index manually, pick files
+Read × 2 (explicit paths)
+Index cost is fixed — paid even for unrelated queries.
+```
+
+**No tooling (full dump)**
+```
+All 34 files pasted in (~85k tok)
+Context overflow risk above ~200 files
+Early files pushed out, answers degrade
+Not viable at scale.
+```
+
+| Approach | Total Input Tokens | Tool Calls | Session Overhead |
+|---|---|---|---|
+| ctxgraph | **~5,600** | 3 | ~0 |
+| Claude Code | ~8,000 | 4–6 | ~1,500 (system prompt) |
+| CLAUDE.md | ~8,400 | 2 | ~2,800 (static index) |
+| No tooling | ~85,000+ | 0 | — |
+
+The key insight: **ctxgraph's graph is pre-built.** `search_graph` returns file paths for ~50 tokens, then you fetch only what you need. Agentic approaches (Claude Code) burn tokens exploring the filesystem dynamically. Static index approaches (CLAUDE.md) burn tokens loading a full index on every session — even for unrelated queries.
+
+---
+
+
+
 ## Commands
 
 ### `ctx init` — Scaffold project