tokensafe 1.1.0 → 1.1.1

package/README.md

@@ -56,13 +56,34 @@ Traditional AI code interactions suffer from massive context bloat:
 3. **Stuck Loops & Bloated Diffs:** Terminal `git diff` and repetitive failed commands spiral context into overflow.
 
 ### TokenSafe Solves All Three Autonomously:
+- **Graph-Guided AST Skeletonization:** Folds inactive function bodies into signatures, keeping target functions and 1-hop dependencies full while collapsing unrelated code (`-85% to -92%`).
+- **God Nodes & Architectural Hub Detection:** Calculates Degree Centrality to identify structural project hubs and injects topology awareness into agent sessions without expensive file crawling.
 - **TOCP Prompt Distillation:** Intercepts prompts and distills intent into lean S-Expressions via **Google Gemini (2.0 Flash-Lite), OpenAI ChatGPT (gpt-4o-mini), or DeepSeek-Flash** (`-40% to -70%`). Automatically detects `GEMINI_API_KEY`, `OPENAI_API_KEY`, or `DEEPSEEK_API_KEY`.
-- **AST Skeletonization & Slicing:** Folds inactive function bodies into signatures and windows targeted symbols (`-80% to -92%`).
+- **API Surface Map Generator:** Generates high-density `tokensafe-out/API_SURFACE.md` (~1.5k tokens) for instant agent codebase onboarding.
 - **Predictive Dependency Prefetcher:** Attaches imported symbol signatures to eliminate downstream exploratory `read_file` roundtrips.
+- **Local Secret Redactor:** Sanitizes Stripe, AWS, JWT, and database credentials before network transmission.
 - **Output Guard & Loop Guard:** Blocks destructive full-file rewrites on files $\ge 40$ lines and halts command loops.
 
 ---
 
+## ⚡ TokenSafe vs. Graphify: Dynamic In-Flight Defense vs. Static Reports
+
+How TokenSafe complements or supersedes static graph tools like **Graphify** (`graphify-labs/graphify`):
+
+| Capability | Graphify | TokenSafe |
+|---|---|---|
+| **Primary Focus** | Static knowledge graph reports & MCP queries | **In-flight real-time token compression & defense** |
+| **Indexing Cost** | Expensive LLM tokens / heavy graph extraction | **0 tokens, 100% deterministic local AST (< 30ms)** |
+| **Execution Latency** | Offline / CLI-initiated build | **Sub-millisecond inline proxy & lifecycle hooks** |
+| **Active Slicing** | Static file output (`GRAPH_REPORT.md`) | **Dynamic call-graph skeletonization (85–92% saved)** |
+| **Multi-Project Workspace** | Requires manual directory targeting | **Auto-detects project roots per file on the fly** |
+| **Agent Prompt Optimization** | None | **TOCP S-Expression prompt distillation (-40% to -70%)** |
+| **Safety & Runaway Prevention** | None | **Output rewrite guard, loop detector, secret scrubbing** |
+
+> **Complements & Replaces**: If you already use Graphify for repository mapping, TokenSafe works alongside it by compressing real-time agent tool reads on the wire. Or use TokenSafe standalone for a zero-configuration, zero-cost, sub-30ms architecture engine out of the box.
+
+---
+
 ## 🤖 Universal LLM Distillation Providers
 
 TokenSafe supports any key you already have:
@@ -110,6 +131,12 @@ Verified across 5 real-world production scenarios:
 ## 🛠️ CLI Quickstart
 
 ```bash
+# Analyze repository God Nodes and dependency topology
+tokensafe graph
+
+# Generate compact tokensafe-out/API_SURFACE.md interface snapshot
+tokensafe map
+
 # View live savings dashboard in your terminal
 tokensafe stats
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokensafe",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Autonomous Zero-Loss Token Economy & Context Optimizer for AI Coding Agents",
   "main": "bin/tokensafe.js",
   "bin": {

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agy-token-optimizer",
   "displayName": "TokenSafe",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Zero-Loss Token Economy & Context Optimizer for AI Agents. Compresses prompts, slices AST/tool outputs, and prevents stuck loops.",
   "logo": "assets/logo.svg",
   "author": {

package/src/__init__.py

@@ -2,5 +2,5 @@
 TokenSafe: Autonomous Zero-Loss Token Economy & Context Optimizer for AI Coding Agents.
 """
 
-__version__ = "1.1.0"
+__version__ = "1.1.1"
 __author__ = "TokenSafe Team"

package/src/graph_engine.py

@@ -415,20 +415,48 @@ class CodeGraph:
 
 
 class GraphEngine:
-    """Singleton Manager for automatic background graph execution."""
+    """Multi-Project Manager for automatic background graph execution."""
 
-    _instance: Optional[CodeGraph] = None
+    _instances: Dict[str, CodeGraph] = {}
+
+    @classmethod
+    def find_project_root(cls, start_path: str) -> str:
+        """Walks up from start_path to locate project boundary markers."""
+        curr = os.path.abspath(start_path)
+        if os.path.isfile(curr):
+            curr = os.path.dirname(curr)
+
+        root = os.path.abspath(os.sep)
+        while curr and curr != root:
+            for marker in (".git", "package.json", "pyproject.toml", "go.mod", "Cargo.toml", "requirements.txt"):
+                if os.path.exists(os.path.join(curr, marker)):
+                    return curr
+            parent = os.path.dirname(curr)
+            if parent == curr:
+                break
+            curr = parent
+        return os.path.abspath(start_path if os.path.isdir(start_path) else os.path.dirname(start_path))
 
     @classmethod
     def get_instance(cls, root_dir: str = ".") -> CodeGraph:
-        if cls._instance is None or cls._instance.root_dir != os.path.abspath(root_dir):
-            cls._instance = CodeGraph(root_dir)
-            cls._instance.scan()
+        root_abs = os.path.abspath(root_dir)
+        if root_abs not in cls._instances:
+            graph = CodeGraph(root_abs)
+            graph.scan()
+            cls._instances[root_abs] = graph
         else:
-            # Incremental scan if older than 3 seconds
-            if time.time() - cls._instance.last_scanned > 3.0:
-                cls._instance.scan()
-        return cls._instance
+            graph = cls._instances[root_abs]
+            if time.time() - graph.last_scanned > 3.0:
+                graph.scan()
+        return graph
+
+    @classmethod
+    def for_file(cls, file_path: str) -> Tuple[CodeGraph, str]:
+        """Resolves the owning project graph and relative file path for any arbitrary file."""
+        root = cls.find_project_root(file_path)
+        graph = cls.get_instance(root)
+        rel_path = os.path.relpath(os.path.abspath(file_path), root).replace("\\", "/")
+        return graph, rel_path
 
 def main():
     import sys

package/src/mcp_server.py

@@ -21,10 +21,11 @@ from src.command_sanitizer import CommandSanitizer
 from src.loop_detector import LoopDetector
 from src.metrics import MetricsTracker
 from src.dashboard import Dashboard
+from src.graph_engine import GraphEngine
 
 SERVER_INFO = {
     "name": "tokensafe-mcp",
-    "version": "1.0.0"
+    "version": "1.1.1"
 }
 
 TOOLS = [
@@ -35,13 +36,33 @@ TOOLS = [
             "type": "object",
             "properties": {
                 "path": {"type": "string", "description": "Absolute path to the code file"},
-                "symbol": {"type": "string", "description": "Optional: targeted function or class name"},
+                "symbol": {"type": "string", "description": "Optional: targeted function or class name for graph-guided skeletonization"},
                 "start_line": {"type": "integer", "description": "Optional: starting line number"},
                 "end_line": {"type": "integer", "description": "Optional: ending line number"}
             },
             "required": ["path"]
         }
     },
+    {
+        "name": "get_architecture_graph",
+        "description": "Returns top architectural God Nodes and dependency topology for the target project.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "project_path": {"type": "string", "description": "Optional: root directory or file path of the project"}
+            }
+        }
+    },
+    {
+        "name": "get_api_surface",
+        "description": "Generates and returns a compact markdown map of all exported interfaces, classes, and types in the project.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "project_path": {"type": "string", "description": "Optional: root directory or file path of the project"}
+            }
+        }
+    },
     {
         "name": "compress_prompt",
         "description": "Compresses a verbose developer prompt into an ultra-dense TOCP S-Expression via DeepSeek-V3 / Regex.",
@@ -102,6 +123,15 @@ def handle_tool_call(name: str, args: dict) -> dict:
             return {"content": [{"type": "text", "text": (prefetch_block or "") + content}]}
 
         if symbol:
+            try:
+                graph, rel_path = GraphEngine.for_file(path)
+                graph_skel = graph.graph_guided_skeletonize(path, target_symbol=symbol)
+                if graph_skel:
+                    header = f"// [TokenSafe Graph-Guided Skeleton for '{symbol}' | Full body + 1-hop dependencies]\n"
+                    return {"content": [{"type": "text", "text": (prefetch_block or "") + header + graph_skel}]}
+            except Exception:
+                pass
+
             overwrite, metrics = ToolSlicer.optimize_read_file({"Path": path}, context_hint=symbol)
             if overwrite:
                 with open(path, "r", encoding="utf-8", errors="replace") as f:
@@ -144,6 +174,26 @@ def handle_tool_call(name: str, args: dict) -> dict:
         dashboard = Dashboard(tracker)
         return {"content": [{"type": "text", "text": dashboard.render_markdown()}]}
 
+    elif name == "get_architecture_graph":
+        target = args.get("project_path") or os.getcwd()
+        graph = GraphEngine.get_instance(target)
+        god_nodes = graph.get_god_nodes(7)
+        banner = graph.format_topology_banner()
+        payload = {
+            "project_root": graph.root_dir,
+            "banner": banner,
+            "total_files": len(graph.file_symbols),
+            "total_symbols": len(graph.symbols),
+            "god_nodes": god_nodes
+        }
+        return {"content": [{"type": "text", "text": json.dumps(payload, indent=2, ensure_ascii=False)}]}
+
+    elif name == "get_api_surface":
+        target = args.get("project_path") or os.getcwd()
+        graph = GraphEngine.get_instance(target)
+        surface_md = graph.generate_api_surface()
+        return {"content": [{"type": "text", "text": surface_md}]}
+
     return {"isError": True, "content": [{"type": "text", "text": f"Unknown tool: {name}"}]}
 
 def run_mcp_server():