ontosight-codegraph 0.1.0__py3-none-any.whl

ontosight_codegraph/__init__.py

@@ -0,0 +1,38 @@
+"""CodeGraph → OntoSight integration for standalone and Hyper-Extract use."""
+
+from ontosight_codegraph.query import make_query_callback
+from ontosight_codegraph.store import (
+    INIT_HINT,
+    CALL_EDGE_KIND,
+    EXCLUDED_NODE_KINDS,
+    CodeCallEdge,
+    CodeGraphNotFoundError,
+    CodeGraphStore,
+    CodeSymbolNode,
+    SubgraphResult,
+    load_call_subgraph,
+    make_search_callback,
+    merge_query_params,
+    parse_codegraph_query,
+    resolve_codegraph_db,
+)
+from ontosight_codegraph.view import apply_subgraph_to_view, show_codegraph
+
+__all__ = [
+    "INIT_HINT",
+    "CALL_EDGE_KIND",
+    "EXCLUDED_NODE_KINDS",
+    "CodeCallEdge",
+    "CodeGraphNotFoundError",
+    "CodeGraphStore",
+    "CodeSymbolNode",
+    "SubgraphResult",
+    "apply_subgraph_to_view",
+    "load_call_subgraph",
+    "make_query_callback",
+    "make_search_callback",
+    "merge_query_params",
+    "parse_codegraph_query",
+    "resolve_codegraph_db",
+    "show_codegraph",
+]

ontosight_codegraph/cli.py

@@ -0,0 +1,96 @@
+"""CLI for visualizing CodeGraph call subgraphs in OntoSight."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from ontosight_codegraph.store import CodeGraphNotFoundError
+from ontosight_codegraph.view import show_codegraph
+
+app = typer.Typer(
+    help="Visualize CodeGraph call subgraphs with OntoSight.",
+    add_completion=False,
+    no_args_is_help=True,
+)
+
+
+@app.command()
+def show(
+    project_path: str = typer.Argument(
+        ".",
+        help="Project root containing .codegraph/codegraph.db",
+    ),
+    path_filter: Optional[str] = typer.Option(
+        None,
+        "--path",
+        help="Limit symbols to files under this path prefix",
+    ),
+    symbol: Optional[str] = typer.Option(
+        None,
+        "--symbol",
+        help="Seed symbol name for subgraph expansion",
+    ),
+    task: Optional[str] = typer.Option(
+        None,
+        "--task",
+        help="Natural-language task to seed subgraph (keyword match)",
+    ),
+    hops: int = typer.Option(
+        2,
+        "--hops",
+        min=0,
+        help="BFS hop depth for subgraph expansion",
+    ),
+    max_nodes: int = typer.Option(
+        200,
+        "--max-nodes",
+        min=1,
+        help="Maximum nodes in subgraph",
+    ),
+) -> None:
+    """Open OntoSight with a CodeGraph call subgraph."""
+    root = Path(project_path).resolve()
+    typer.echo(f"Project: {root}")
+    if path_filter:
+        typer.echo(f"Path filter: {path_filter}")
+    if symbol:
+        typer.echo(f"Symbol seed: {symbol}")
+    elif task:
+        typer.echo(f"Task seed: {task}")
+    typer.echo(f"Hops / max nodes: {hops} / {max_nodes}")
+    typer.echo()
+
+    try:
+        typer.echo("Visualizing CodeGraph with OntoSight...")
+        result = show_codegraph(
+            root,
+            path_filter=path_filter,
+            symbol=symbol,
+            task=task,
+            hops=hops,
+            max_nodes=max_nodes,
+            print_topology_summary=True,
+        )
+    except CodeGraphNotFoundError as exc:
+        typer.echo(f"Error: {exc}", err=True)
+        raise typer.Exit(1) from exc
+    except ValueError as exc:
+        typer.echo(f"Error: {exc}", err=True)
+        raise typer.Exit(1) from exc
+
+    typer.echo(
+        f"Loaded {len(result.nodes)} nodes, {len(result.edges)} call edges"
+    )
+    if result.truncated:
+        typer.echo(
+            f"Warning: Subgraph truncated at {max_nodes} nodes. "
+            "Use --symbol, --task, or --path to narrow scope.",
+            err=True,
+        )
+
+
+if __name__ == "__main__":
+    app()

ontosight_codegraph/query.py

@@ -0,0 +1,59 @@
+"""CodeGraph query callback for OntoSight live subgraph reload."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Callable, Dict, Optional
+
+from ontosight_codegraph.store import (
+    load_call_subgraph,
+    merge_query_params,
+)
+from ontosight_codegraph.view import apply_subgraph_to_view
+
+
+def make_query_callback(
+    project_path: Path,
+    *,
+    default_path_filter: Optional[str] = None,
+    default_hops: int = 2,
+    default_max_nodes: int = 200,
+    top_k_critical: int = 10,
+    highlight_critical: bool = True,
+) -> Callable[..., Dict[str, Any]]:
+    """Create OntoSight callback to reload CodeGraph subgraph from query input."""
+
+    def codegraph_query(
+        query: Optional[str] = None,
+        path_filter: Optional[str] = None,
+        symbol: Optional[str] = None,
+        task: Optional[str] = None,
+        hops: Optional[int] = None,
+        max_nodes: Optional[int] = None,
+        **_: Any,
+    ) -> Dict[str, Any]:
+        params = merge_query_params(
+            query=query,
+            path_filter=path_filter,
+            symbol=symbol,
+            task=task,
+            hops=hops if hops is not None else default_hops,
+            max_nodes=max_nodes if max_nodes is not None else default_max_nodes,
+            default_path_filter=default_path_filter,
+        )
+        load_kwargs = {
+            "path_filter": params.get("path_filter"),
+            "symbol": params.get("symbol"),
+            "task": params.get("task"),
+            "hops": params.get("hops", default_hops),
+            "max_nodes": params.get("max_nodes", default_max_nodes),
+        }
+        result = load_call_subgraph(project_path, **load_kwargs)
+        return apply_subgraph_to_view(
+            result,
+            max_nodes=load_kwargs["max_nodes"],
+            top_k_critical=top_k_critical,
+            highlight_critical=highlight_critical,
+        )
+
+    return codegraph_query