codegraph-engine 2.3.0__py3-none-any.whl → 3.0.1__py3-none-any.whl

codegraph/runtime/runner.py

@@ -35,13 +35,35 @@ const fs = require('fs');
 
 const logPath = {escaped_log_path};
 
+let _cg_buffer = [];
+let _cg_last_flush = Date.now();
+const _CG_BATCH_SIZE = 50;
+const _CG_FLUSH_INTERVAL_MS = 1500;
+
+function _cg_flush_buffer() {{
+  if (_cg_buffer.length === 0) return;
+  const content = _cg_buffer.join('');
+  _cg_buffer = [];
+  _cg_last_flush = Date.now();
+  try {{
+    fs.appendFileSync(logPath, content);
+  }} catch (_) {{}}
+}}
+
 function emitEvent(event) {{
   try {{
-    fs.appendFileSync(logPath, JSON.stringify(event) + '\\n');
+    _cg_buffer.push(JSON.stringify(event) + '\\n');
+    if (_cg_buffer.length >= _CG_BATCH_SIZE || (Date.now() - _cg_last_flush) >= _CG_FLUSH_INTERVAL_MS) {{
+      _cg_flush_buffer();
+    }}
   }} catch (_) {{}}
 }}
 
+setInterval(_cg_flush_buffer, _CG_FLUSH_INTERVAL_MS);
+process.on('exit', _cg_flush_buffer);
+
 function hookServer(serverProto) {{
+
   const origEmit = serverProto.emit;
   serverProto.emit = function(event, req, res) {{
     if (event === 'request' && req && res) {{
@@ -87,23 +109,64 @@ process.on('uncaughtExceptionMonitor', (err) => {{
 
 
 def _generate_python_interceptor(output_jsonl: Path) -> str:
-    """Generate lightweight Python WSGI/ASGI/FastAPI request interceptor."""
+    """Generate lightweight Python WSGI/ASGI/FastAPI request interceptor with in-memory buffering."""
     escaped_log_path = repr(str(output_jsonl))
     return f"""# CodeGraph Python Runtime Interceptor
-import sys
+import atexit
 import json
+import os
+import sys
+import threading
 import time
 
 LOG_PATH = {escaped_log_path}
 
+_cg_buffer = []
+_cg_lock = threading.Lock()
+_cg_last_flush = time.time()
+_cg_batch_size = 50
+_cg_flush_interval = 1.5
+
+def _cg_flush():
+    global _cg_last_flush
+    lines = None
+    with _cg_lock:
+        if _cg_buffer:
+            lines = "".join(_cg_buffer)
+            _cg_buffer.clear()
+            _cg_last_flush = time.time()
+    if lines:
+        try:
+            with open(LOG_PATH, "a", encoding="utf-8") as f:
+                f.write(lines)
+        except Exception:
+            pass
+
 def emit_event(event):
     try:
-        with open(LOG_PATH, "a", encoding="utf-8") as f:
-            f.write(json.dumps(event) + "\\n")
+        line = json.dumps(event) + "\\n"
+        should_flush = False
+        with _cg_lock:
+            _cg_buffer.append(line)
+            if len(_cg_buffer) >= _cg_batch_size or (time.time() - _cg_last_flush) >= _cg_flush_interval:
+                should_flush = True
+        if should_flush:
+            _cg_flush()
     except Exception:
         pass
 
-# Intercept uncaught exceptions
+def _cg_bg_flusher():
+    while True:
+        time.sleep(_cg_flush_interval)
+        if _cg_buffer:
+            _cg_flush()
+
+_cg_flusher_thread = threading.Thread(target=_cg_bg_flusher, daemon=True)
+_cg_flusher_thread.start()
+atexit.register(_cg_flush)
+
+
+# 1. Intercept uncaught exceptions
 _orig_excepthook = sys.excepthook
 def _cg_excepthook(exc_type, exc_value, exc_traceback):
     emit_event({{
@@ -118,6 +181,92 @@ def _cg_excepthook(exc_type, exc_value, exc_traceback):
     return _orig_excepthook(exc_type, exc_value, exc_traceback)
 
 sys.excepthook = _cg_excepthook
+
+# 2. Intercept SQLite query executions
+try:
+    import sqlite3
+    _orig_connect = sqlite3.connect
+
+    def _cg_connect(*args, **kwargs):
+        con = _orig_connect(*args, **kwargs)
+        def _sql_trace(statement):
+            if statement and isinstance(statement, str) and statement.strip():
+                emit_event({{
+                    "trace_id": "tr_sql_" + str(int(time.time())),
+                    "span_id": "sp_sql_" + str(id(con)),
+                    "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+                    "sql": statement,
+                    "duration_ms": 1.0,
+                    "service_name": "python_dev_server",
+                    "source_format": "otel",
+                }})
+        try:
+            con.set_trace_callback(_sql_trace)
+        except Exception:
+            pass
+        return con
+
+    sqlite3.connect = _cg_connect
+except Exception:
+    pass
+
+
+# 3. Intercept SQLAlchemy engine query executions if imported
+try:
+    import sqlalchemy.event
+    import sqlalchemy.engine
+
+    @sqlalchemy.event.listens_for(sqlalchemy.engine.Engine, "after_cursor_execute")
+    def _cg_after_cursor_execute(conn, cursor, statement, parameters, context, executemany):
+        if statement and str(statement).strip():
+            emit_event({{
+                "trace_id": "tr_sql_" + str(int(time.time())),
+                "span_id": "sp_sql_" + str(id(cursor)),
+                "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+                "sql": str(statement),
+                "duration_ms": 1.0,
+                "service_name": "python_dev_server",
+                "source_format": "otel",
+            }})
+except Exception:
+    pass
+
+# 4. Intercept Werkzeug/Flask dev server requests
+try:
+    import werkzeug.serving
+    _orig_run_simple = werkzeug.serving.run_simple
+
+    def _cg_run_simple(hostname, port, application, *args, **kwargs):
+        def _wrapped_app(environ, start_response):
+            path = environ.get("PATH_INFO", "/")
+            method = environ.get("REQUEST_METHOD", "GET")
+            status_box = [200]
+            def _wrapped_sr(status, headers, exc_info=None):
+                try:
+                    status_box[0] = int(status.split()[0])
+                except Exception:
+                    pass
+                return start_response(status, headers, exc_info)
+            st = time.time()
+            try:
+                return application(environ, _wrapped_sr)
+            finally:
+                emit_event({{
+                    "trace_id": "tr_http_" + str(int(time.time())),
+                    "span_id": "sp_http_" + str(int(time.time())),
+                    "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+                    "http_method": method,
+                    "route": path,
+                    "status_code": status_box[0],
+                    "duration_ms": (time.time() - st) * 1000.0,
+                    "service_name": "python_dev_server",
+                    "source_format": "otel",
+                }})
+        return _orig_run_simple(hostname, port, _wrapped_app, *args, **kwargs)
+
+    werkzeug.serving.run_simple = _cg_run_simple
+except Exception:
+    pass
 """
 
 

codegraph/runtime/trace_linker.py

@@ -0,0 +1,175 @@
+"""Cross-Service & Multi-Localhost Distributed Trace Linker.
+
+Stitches W3C distributed traces across multiple localhost ports:
+- Frontend (e.g. Next.js on localhost:3000)
+- Backend API (e.g. FastAPI / NestJS on localhost:8000)
+- Database mutation (e.g. PostgreSQL on localhost:5432)
+
+Attributes every step to:
+1. Participating localhost service & port.
+2. Static AST symbol / route handler.
+3. Actual latency and HTTP status code.
+"""
+from __future__ import annotations
+
+import sqlite3
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+@dataclass(frozen=True)
+class TraceSpanNode:
+    span_id: str
+    parent_span_id: str
+    service_name: str
+    port: int | None
+    route_path: str
+    handler_symbol: str
+    db_operation: str
+    db_table: str
+    status_code: int | None
+    duration_ms: float
+    children: tuple[TraceSpanNode, ...] = ()
+
+    def as_dict(self) -> dict[str, Any]:
+        return {
+            "span_id": self.span_id,
+            "parent_span_id": self.parent_span_id,
+            "service_name": self.service_name,
+            "port": self.port,
+            "route_path": self.route_path,
+            "handler_symbol": self.handler_symbol,
+            "db_operation": self.db_operation,
+            "db_table": self.db_table,
+            "status_code": self.status_code,
+            "duration_ms": self.duration_ms,
+            "children": [c.as_dict() for c in self.children],
+        }
+
+
+@dataclass(frozen=True)
+class DistributedTraceReport:
+    trace_id: str
+    total_duration_ms: float
+    services_involved: tuple[dict[str, Any], ...]
+    root_spans: tuple[TraceSpanNode, ...]
+    db_queries_count: int
+    has_errors: bool
+    summary: str
+
+    def as_dict(self) -> dict[str, Any]:
+        return {
+            "trace_id": self.trace_id,
+            "total_duration_ms": self.total_duration_ms,
+            "services_involved": list(self.services_involved),
+            "root_spans": [s.as_dict() for s in self.root_spans],
+            "db_queries_count": self.db_queries_count,
+            "has_errors": self.has_errors,
+            "summary": self.summary,
+        }
+
+
+def link_distributed_trace(
+    con: sqlite3.Connection,
+    repo_root: Path,
+    trace_id: str,
+) -> DistributedTraceReport | None:
+    """Reconstruct multi-service distributed execution graph for a given trace_id."""
+    clean_tid = trace_id.strip()
+    if not clean_tid:
+        return None
+
+    rows = con.execute(
+        """SELECT event_id, trace_id, span_id, parent_span_id, http_method, route_path,
+                  handler_symbol, service_name, db_operation, db_table, status_code,
+                  duration_ms
+           FROM runtime_observations
+           WHERE trace_id = ?
+           ORDER BY duration_ms DESC""",
+        (clean_tid,),
+    ).fetchall()
+
+    if not rows:
+        return None
+
+    # Group spans
+    spans_by_id: dict[str, dict[str, Any]] = {}
+    children_by_parent: dict[str, list[str]] = {}
+    services_set: set[str] = set()
+    db_queries = 0
+    has_err = False
+    total_time = 0.0
+
+    for r in rows:
+        sid = str(r["span_id"] or r["event_id"])
+        pid = str(r["parent_span_id"] or "")
+        s_name = str(r["service_name"] or "unknown_service")
+        services_set.add(s_name)
+        dur = float(r["duration_ms"] or 0.0)
+        total_time = max(total_time, dur)
+        sc = r["status_code"]
+        if sc and int(sc) >= 400:
+            has_err = True
+        if r["db_operation"]:
+            db_queries += 1
+
+        spans_by_id[sid] = {
+            "span_id": sid,
+            "parent_span_id": pid,
+            "service_name": s_name,
+            "port": None,
+            "route_path": str(r["route_path"] or ""),
+            "handler_symbol": str(r["handler_symbol"] or ""),
+            "db_operation": str(r["db_operation"] or ""),
+            "db_table": str(r["db_table"] or ""),
+            "status_code": sc,
+            "duration_ms": dur,
+        }
+        if pid not in children_by_parent:
+            children_by_parent[pid] = []
+        children_by_parent[pid].append(sid)
+
+    # Build tree
+    def _build_node(sid: str) -> TraceSpanNode:
+        data = spans_by_id[sid]
+        child_sids = children_by_parent.get(sid, [])
+        children = tuple(_build_node(cid) for cid in child_sids if cid in spans_by_id)
+        return TraceSpanNode(
+            span_id=data["span_id"],
+            parent_span_id=data["parent_span_id"],
+            service_name=data["service_name"],
+            port=data["port"],
+            route_path=data["route_path"],
+            handler_symbol=data["handler_symbol"],
+            db_operation=data["db_operation"],
+            db_table=data["db_table"],
+            status_code=data["status_code"],
+            duration_ms=data["duration_ms"],
+            children=children,
+        )
+
+    # Root spans: parent_span_id is empty or not in spans_by_id
+    roots: list[TraceSpanNode] = []
+    for sid, data in spans_by_id.items():
+        pid = data["parent_span_id"]
+        if not pid or pid not in spans_by_id:
+            roots.append(_build_node(sid))
+
+    # Resolve services
+    services_list: list[dict[str, Any]] = [{"name": s} for s in sorted(services_set)]
+
+    summary = (
+        f"Trace {clean_tid[:8]}: {len(rows)} spans across {len(services_set)} service(s), "
+        f"{db_queries} DB queries, total duration {total_time:.1f}ms."
+    )
+
+    return DistributedTraceReport(
+        trace_id=clean_tid,
+        total_duration_ms=total_time,
+        services_involved=tuple(services_list),
+        root_spans=tuple(roots),
+        db_queries_count=db_queries,
+        has_errors=has_err,
+        summary=summary,
+    )

codegraph/sandbox.py

@@ -0,0 +1,215 @@
+"""In-Memory Speculative "What-If" Execution Sandbox for CodeGraph.
+
+Enables AI agents to project virtual AST branches in RAM in <5ms without modifying disk:
+- Applies unified diffs or in-memory file content substitutions
+- Parses affected files into virtual AST nodes (Python, TS, Go, Rust, Java, C++)
+- Computes virtual caller contract breaks, parameter mismatches, and route mutations
+- Validates blast radius before writing code to disk
+"""
+from __future__ import annotations
+
+import difflib
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any
+
+from codegraph.indexing.parser import parse
+
+
+@dataclass(frozen=True)
+class VirtualContractBreak:
+    """A breaking change to an existing symbol contract detected in speculative branch."""
+
+    symbol: str
+    break_type: str  # PARAMETER_REMOVED | TYPE_MISMATCH | RETURN_TYPE_CHANGED | SYMBOL_DELETED
+    file_path: str
+    line: int
+    impacted_callers_count: int
+    message: str
+
+    def as_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass(frozen=True)
+class VirtualRouteMutation:
+    """A mutation to an API endpoint detected in speculative branch."""
+
+    http_method: str
+    old_route: str
+    new_route: str
+    file_path: str
+    mutation_type: str  # ROUTE_ADDED | ROUTE_MODIFIED | ROUTE_REMOVED
+
+    def as_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class SpeculativeEvaluationReport:
+    """Complete evaluation report of an in-memory speculative patch."""
+
+    is_safe: bool
+    modified_files: list[str] = field(default_factory=list)
+    contract_breaks: list[VirtualContractBreak] = field(default_factory=list)
+    route_mutations: list[VirtualRouteMutation] = field(default_factory=list)
+    affected_caller_count: int = 0
+    diff_summary: str = ""
+    evaluation_time_ms: float = 0.0
+
+    def as_dict(self) -> dict[str, Any]:
+        return {
+            "is_safe": self.is_safe,
+            "modified_files": self.modified_files,
+            "contract_breaks": [b.as_dict() for b in self.contract_breaks],
+            "route_mutations": [m.as_dict() for m in self.route_mutations],
+            "affected_caller_count": self.affected_caller_count,
+            "diff_summary": self.diff_summary,
+            "evaluation_time_ms": round(self.evaluation_time_ms, 2),
+        }
+
+
+def _infer_language(file_path: str) -> str:
+    ext = Path(file_path).suffix.lower()
+    mapping = {
+        ".py": "python",
+        ".ts": "typescript",
+        ".tsx": "typescript",
+        ".js": "javascript",
+        ".jsx": "javascript",
+        ".go": "go",
+        ".rs": "rust",
+        ".java": "java",
+        ".kt": "kotlin",
+        ".cpp": "cpp",
+        ".cc": "cpp",
+        ".h": "c_header",
+        ".hpp": "cpp_header",
+    }
+    return mapping.get(ext, "python")
+
+
+def evaluate_speculative_patch(
+    repository: Path,
+    file_patches: dict[str, str],  # relative_path -> new_content
+    con: Any = None,
+) -> SpeculativeEvaluationReport:
+    """Evaluate candidate file contents in memory without modifying the repository on disk."""
+    import time
+    t0 = time.perf_counter()
+    repo = repository.resolve()
+
+    contract_breaks: list[VirtualContractBreak] = []
+    route_mutations: list[VirtualRouteMutation] = []
+    modified_files = list(file_patches.keys())
+    affected_callers_total = 0
+    diff_lines: list[str] = []
+
+    for rel_path, new_content in file_patches.items():
+        disk_file = repo / rel_path
+        old_content = disk_file.read_text(encoding="utf-8", errors="replace") if disk_file.is_file() else ""
+        lang = _infer_language(rel_path)
+
+        # Compute unified diff summary
+        diff = list(difflib.unified_diff(
+            old_content.splitlines(),
+            new_content.splitlines(),
+            fromfile=f"a/{rel_path}",
+            tofile=f"b/{rel_path}",
+            lineterm="",
+        ))
+        if diff:
+            diff_lines.extend(diff[:20])
+
+        # Parse baseline vs speculative in memory
+        old_res = parse(old_content, lang, rel_path) if old_content else None
+        new_res = parse(new_content, lang, rel_path)
+
+        old_syms = {s.name: s for s in old_res.symbols} if old_res else {}
+        new_syms = {s.name: s for s in new_res.symbols}
+
+        # 1. Detect Deleted Symbols & Modified Signatures
+        for name, old_s in old_syms.items():
+            if name not in new_syms:
+                # Symbol deleted
+                callers_count = 0
+                if con is not None:
+                    try:
+                        cur = con.execute("SELECT COUNT(*) FROM calls WHERE callee = ?;", (name,))
+                        callers_count = cur.fetchone()[0]
+                    except Exception:
+                        pass
+                affected_callers_total += callers_count
+                contract_breaks.append(
+                    VirtualContractBreak(
+                        symbol=name,
+                        break_type="SYMBOL_DELETED",
+                        file_path=rel_path,
+                        line=old_s.start_line,
+                        impacted_callers_count=callers_count,
+                        message=f"Symbol '{name}' was deleted but has {callers_count} downstream callers.",
+                    )
+                )
+            else:
+                new_s = new_syms[name]
+                # Check parameter count reductions
+                if (old_s.parameter_count or 0) > (new_s.parameter_count or 0):
+                    callers_count = 0
+                    if con is not None:
+                        try:
+                            cur = con.execute("SELECT COUNT(*) FROM calls WHERE callee = ?;", (name,))
+                            callers_count = cur.fetchone()[0]
+                        except Exception:
+                            pass
+                    affected_callers_total += callers_count
+                    contract_breaks.append(
+                        VirtualContractBreak(
+                            symbol=name,
+                            break_type="PARAMETER_REMOVED",
+                            file_path=rel_path,
+                            line=new_s.start_line,
+                            impacted_callers_count=callers_count,
+                            message=f"Parameter count reduced from {old_s.parameter_count} to {new_s.parameter_count} on '{name}'.",
+                        )
+                    )
+
+        # 2. Detect Route Mutations
+        old_routes = {f"{r.http_method} {r.route_path}": r for r in old_res.routes} if old_res else {}
+        new_routes = {f"{r.http_method} {r.route_path}": r for r in new_res.routes}
+
+        for key, r in new_routes.items():
+            if key not in old_routes:
+                route_mutations.append(
+                    VirtualRouteMutation(
+                        http_method=r.http_method,
+                        old_route="",
+                        new_route=r.route_path,
+                        file_path=rel_path,
+                        mutation_type="ROUTE_ADDED",
+                    )
+                )
+
+        for key, r in old_routes.items():
+            if key not in new_routes:
+                route_mutations.append(
+                    VirtualRouteMutation(
+                        http_method=r.http_method,
+                        old_route=r.route_path,
+                        new_route="",
+                        file_path=rel_path,
+                        mutation_type="ROUTE_REMOVED",
+                    )
+                )
+
+    is_safe = len(contract_breaks) == 0
+    elapsed = (time.perf_counter() - t0) * 1000.0
+
+    return SpeculativeEvaluationReport(
+        is_safe=is_safe,
+        modified_files=modified_files,
+        contract_breaks=contract_breaks,
+        route_mutations=route_mutations,
+        affected_caller_count=affected_callers_total,
+        diff_summary="\n".join(diff_lines),
+        evaluation_time_ms=elapsed,
+    )

codegraph/search/hybrid.py

@@ -623,6 +623,11 @@ def search_code(
 
     config_exts = {".json", ".yaml", ".yml", ".toml", ".ini", ".cfg", ".conf"}
     filtered: list[dict[str, object]] = []
+    seen_file_lines: set[tuple[str, int]] = set()
+    files_with_exact_matches: set[str] = set()
+
+    query_terms = _safe_fts5_terms(clean_query)
+    query_terms_lower = [t.lower() for t in query_terms]
 
     for item in raw_hits:
         rel_path = item.path or item.file
@@ -659,6 +664,27 @@ def search_code(
             d["match_type"] = "case_insensitive"
         else:
             d["match_type"] = "token"
+
+        hit_line = item.line
+        file_line_key = (rel_path, hit_line)
+        if file_line_key in seen_file_lines:
+            continue
+
+        # If multi-word query and this hit is only a token match:
+        # verify that all query terms appear in the snippet or matched text
+        if len(query_terms_lower) >= 2 and d["match_type"] == "token":
+            haystack = (str(d.get("snippet", "")) + " " + str(d.get("matched_text", ""))).lower()
+            if not all(t in haystack for t in query_terms_lower):
+                continue
+
+        # If a file already had an exact/case-insensitive match, discard subsequent loose token matches
+        if rel_path in files_with_exact_matches and d["match_type"] == "token":
+            continue
+
+        if d["match_type"] in ("exact", "case_insensitive"):
+            files_with_exact_matches.add(rel_path)
+
+        seen_file_lines.add(file_line_key)
         filtered.append(d)
         if len(filtered) >= effective_limit:
             break