codegraph-cli-ai 0.1.0__tar.gz

codegraph_cli_ai-0.1.0/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: codegraph-cli-ai
+Version: 0.1.0
+Summary: CLI tool to analyze codebases and visualize knowledge graphs using AST
+Author: Aditya Jogdand
+License: MIT
+Keywords: code-analysis,ast,graph,cli,developer-tools
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.9.0
+Requires-Dist: networkx>=3.0
+Requires-Dist: pyvis>=0.3.2

codegraph_cli_ai-0.1.0/codegraph/cli.py

@@ -0,0 +1,454 @@
+"""
+CodeGraph AI - CLI Entry Point
+"""
+
+import json
+import typer
+import webbrowser
+import networkx as nx
+from pathlib import Path
+from typing import Optional
+from codegraph.parsers.python_parser import PythonParser
+from codegraph.graph.builder import GraphBuilder
+
+app = typer.Typer()
+
+
+@app.callback()
+def main():
+    """CodeGraph AI - Understand your codebase using graphs and AI."""
+    pass
+
+
+@app.command()
+def index(
+    path: str = typer.Argument(".", help="Path to the repo or folder to index")
+):
+    """Scan a directory, parse all Python files, and save the knowledge graph."""
+    root = Path(path).resolve()
+
+    if not root.exists():
+        typer.echo(f"[error] Path does not exist: {root}", err=True)
+        raise typer.Exit(code=1)
+
+    typer.echo(f"Indexing: {root}\n")
+    py_files = list(root.rglob("*.py"))
+
+    if not py_files:
+        typer.echo("No Python files found.")
+        raise typer.Exit()
+
+    typer.echo(f"Found {len(py_files)} Python file(s)\n")
+
+    # Step 1 — Parse
+    parser = PythonParser()
+    parsed_files = []
+    failed_files = []
+
+    for filepath in py_files:
+        result = parser.parse_file(str(filepath))
+        if result.errors:
+            failed_files.append((str(filepath), result.errors))
+        else:
+            typer.echo(f"  ✔  {filepath.relative_to(root)}")
+            parsed_files.append(result)
+
+    # Step 2 — Build graph
+    typer.echo("\nBuilding graph...")
+    builder = GraphBuilder()
+    builder.build(parsed_files)
+    summary = builder.summary()
+
+    # Step 3 — Save to .codegraph/graph.json
+    output_dir = root / ".codegraph"
+    output_dir.mkdir(exist_ok=True)
+    output_file = output_dir / "graph.json"
+    with output_file.open("w", encoding="utf-8") as fp:
+        json.dump(builder.to_dict(), fp, indent=2)
+
+    # Step 4 — Summary
+    typer.echo("\n" + "=" * 50)
+    typer.echo("Index complete")
+    typer.echo(f"  Graph saved   : {output_file}")
+    typer.echo(f"  Files parsed  : {len(parsed_files)}")
+    typer.echo(f"  Graph nodes   : {summary['total_nodes']}")
+    typer.echo(f"  Graph edges   : {summary['total_edges']}")
+    typer.echo("\n  Node breakdown:")
+    for kind, count in summary["nodes_by_kind"].items():
+        typer.echo(f"    {kind:<12}: {count}")
+    typer.echo("\n  Edge breakdown:")
+    for rel, count in summary["edges_by_relation"].items():
+        typer.echo(f"    {rel:<12}: {count}")
+
+    if failed_files:
+        typer.echo(f"\n  Failed files  : {len(failed_files)}")
+        for fp, errors in failed_files:
+            typer.echo(f"    {fp}: {errors}")
+
+
+@app.command()
+def plot(
+    hide_external: bool = typer.Option(False, "--hide-external", help="Hide external/stdlib nodes"),
+    level: Optional[str] = typer.Option(None, "--level", help="Show only: file, function, class, method"),
+    focus: Optional[str] = typer.Option(None, "--focus", help="Focus on a specific file (e.g. cli.py)"),
+    edge_type: Optional[str] = typer.Option(None, "--edge-type", help="Filter edges: calls, imports, contains, all"),
+):
+    """Visualize the knowledge graph as a premium interactive HTML file."""
+    root = Path(".").resolve()
+    graph_file = root / ".codegraph" / "graph.json"
+
+    if not graph_file.exists():
+        typer.echo("[error] No graph found. Run 'codegraph index' first.", err=True)
+        raise typer.Exit(code=1)
+
+    typer.echo(f"Loading graph from {graph_file}...")
+    with graph_file.open("r", encoding="utf-8") as f:
+        data = json.load(f)
+
+    # Build NetworkX graph
+    G = nx.DiGraph()
+    for node in data.get("nodes", []):
+        G.add_node(node["id"], **{k: v for k, v in node.items() if k != "id"})
+    for edge in data.get("edges", []):
+        G.add_edge(edge["source"], edge["target"], **{k: v for k, v in edge.items() if k not in ["source", "target"]})
+
+    # --- Apply filters ---
+
+    # 1. Hide external nodes
+    if hide_external:
+        remove = [n for n, d in G.nodes(data=True) if d.get("external", False)]
+        G.remove_nodes_from(remove)
+
+    # 2. Filter by level (node kind)
+    if level:
+        allowed = set(level.split(","))
+        remove = [n for n, d in G.nodes(data=True) if d.get("kind") not in allowed]
+        G.remove_nodes_from(remove)
+
+    # 3. Focus on a specific file — keep only that file + its direct neighbors
+    if focus:
+        focus_id = f"file:{focus}"
+        if focus_id in G:
+            keep = {focus_id} | set(G.successors(focus_id)) | set(G.predecessors(focus_id))
+            remove = [n for n in G.nodes if n not in keep]
+            G.remove_nodes_from(remove)
+        else:
+            typer.echo(f"[warn] File '{focus}' not found in graph. Showing full graph.")
+
+    # 4. Filter edge types
+    if edge_type and edge_type != "all":
+        allowed_edges = set(edge_type.split(","))
+        remove_edges = [(s, t) for s, t, d in G.edges(data=True) if d.get("relation") not in allowed_edges]
+        G.remove_edges_from(remove_edges)
+        # Remove orphan nodes after edge removal
+        G.remove_nodes_from(list(nx.isolates(G)))
+
+    typer.echo(f"Rendering {G.number_of_nodes()} nodes, {G.number_of_edges()} edges...")
+
+    # --- Build HTML visualization ---
+    html = _build_premium_html(G)
+
+    output_path = root / "graph.html"
+    output_path.write_text(html, encoding="utf-8")
+
+    typer.echo(f"Saved to: {output_path}")
+    typer.echo("Opening in browser...")
+    webbrowser.open(f"file://{output_path.resolve()}")
+
+
+def _build_premium_html(G: nx.DiGraph) -> str:
+    """Generate a self-contained premium HTML visualization using vis.js."""
+
+    # --- Node styling ---
+    STYLES = {
+        "file":     {"color": "#4A90E2", "shape": "diamond", "size": 28, "font_color": "#ffffff"},
+        "class":    {"color": "#F5A623", "shape": "hexagon", "size": 24, "font_color": "#ffffff"},
+        "function": {"color": "#50C878", "shape": "dot", "size": 16, "font_color": "#ffffff"},
+        "method":   {"color": "#7ED6A8", "shape": "dot", "size": 14, "font_color": "#ffffff"},
+        "module":   {"color": "#B0BEC5", "shape": "box",     "size": 14, "font_color": "#ffffff"},
+    }
+
+    EDGE_COLORS = {
+        "contains":   "#4A90E2",
+        "calls":      "#50C878",
+        "imports":    "#B0BEC5",
+        "defined_in": "#E8E8E8",
+    }
+
+    nodes_js = []
+    for node_id, attrs in G.nodes(data=True):
+        kind = attrs.get("kind", "function")
+        label = attrs.get("label", node_id)
+        external = attrs.get("external", False)
+        style = STYLES.get(kind, STYLES["function"])
+
+        color = "#CFD8DC" if external else style["color"]
+        font_color = "#B0BEC5" if external else style["font_color"]
+        size = max(style["size"] - 4, 10) if external else style["size"]
+
+        # Tooltip
+        tooltip_parts = [f"<b>{label}</b>", f"Kind: {kind}"]
+        if attrs.get("file"):
+            tooltip_parts.append(f"File: {attrs['file'].replace('file:', '')}")
+        if attrs.get("cls"):
+            tooltip_parts.append(f"Class: {attrs['cls']}")
+        if external:
+            tooltip_parts.append("<i>external</i>")
+        tooltip = "<br>".join(tooltip_parts)
+
+        nodes_js.append(f"""{{
+            id: {json.dumps(node_id)},
+            label: {json.dumps(label)},
+            title: {json.dumps(tooltip)},
+            color: {{
+                background: {json.dumps(color)},
+                border: {json.dumps(_darken(color))},
+                highlight: {{ background: "#FFE082", border: "#FFA000" }},
+                hover: {{ background: "#E3F2FD", border: "#1E88E5" }}
+            }},
+            shape: {json.dumps(style["shape"])},
+            size: {size},
+            font: {{ color: {json.dumps(font_color)}, size: 13, face: "Inter, system-ui, sans-serif" }},
+            borderWidth: 1.5,
+            shadow: {{ enabled: true, color: "rgba(0,0,0,0.12)", size: 8, x: 2, y: 2 }}
+        }}""")
+
+    edges_js = []
+    for src, dst, attrs in G.edges(data=True):
+        relation = attrs.get("relation", "")
+        color = EDGE_COLORS.get(relation, "#BDBDBD")
+        dashed = relation in ("defined_in", "imports")
+
+        edges_js.append(f"""{{
+            from: {json.dumps(src)},
+            to: {json.dumps(dst)},
+            label: {json.dumps(relation)},
+            color: {{ color: {json.dumps(color)}, opacity: 0.7 }},
+            dashes: {"true" if dashed else "false"},
+            width: {"1" if dashed else "1.5"},
+            font: {{ color: "#9E9E9E", size: 10, face: "Inter, system-ui, sans-serif", align: "middle" }},
+            arrows: {{ to: {{ enabled: true, scaleFactor: 0.6 }} }},
+            smooth: {{ type: "curvedCW", roundness: 0.2 }}
+        }}""")
+
+    nodes_json = "[\n" + ",\n".join(nodes_js) + "\n]"
+    edges_json = "[\n" + ",\n".join(edges_js) + "\n]"
+
+    return f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>CodeGraph AI</title>
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&display=swap" rel="stylesheet">
+<script src="https://unpkg.com/vis-network/standalone/umd/vis-network.min.js"></script>
+<style>
+  * {{ box-sizing: border-box; margin: 0; padding: 0; }}
+  body {{ 
+    font-family: 'Inter', system-ui, sans-serif; 
+    background: #0F1117; 
+    color: #E0E0E0; 
+    height: 100vh; 
+    display: flex; 
+    flex-direction: column;
+    overflow: hidden;
+  }}
+
+  /* Background effect */
+  #graph-container::before {{
+    content: "";
+    position: absolute;
+    top: 0; left: 0; right: 0; bottom: 0;
+    background-image: radial-gradient(circle at 2px 2px, rgba(255,255,255,0.03) 1px, transparent 0);
+    background-size: 32px 32px;
+    pointer-events: none;
+    z-index: 0;
+  }}
+
+  #graph-container::after {{
+    content: "";
+    position: absolute;
+    top: 0; left: 0; right: 0; bottom: 0;
+    background: radial-gradient(circle at center, transparent 0%, rgba(15,17,23,0.4) 100%);
+    pointer-events: none;
+    z-index: 1;
+  }}
+
+  /* Header */
+  #header {{
+    display: flex; align-items: center; justify-content: space-between;
+    padding: 16px 24px;
+    background: rgba(26, 29, 39, 0.8);
+    backdrop-filter: blur(10px);
+    border-bottom: 1px solid rgba(255,255,255,0.05);
+    flex-shrink: 0;
+    z-index: 10;
+  }}
+  #header h1 {{ font-size: 18px; font-weight: 600; color: #fff; letter-spacing: -0.01em; }}
+  #header h1 span {{ color: #4A90E2; }}
+  #stats {{ display: flex; gap: 20px; font-size: 13px; color: #78909C; }}
+  #stats b {{ color: #ffffff; }}
+
+  /* Legend */
+  #legend {{
+    display: flex; gap: 16px; align-items: center;
+    padding: 10px 24px;
+    background: rgba(26, 29, 39, 0.6);
+    backdrop-filter: blur(8px);
+    border-bottom: 1px solid rgba(255,255,255,0.05);
+    flex-shrink: 0;
+    flex-wrap: wrap;
+    z-index: 10;
+  }}
+  .legend-item {{ display: flex; align-items: center; gap: 8px; font-size: 12px; color: #B0BEC5; font-weight: 500; }}
+  .legend-dot {{ width: 10px; height: 10px; border-radius: 50%; flex-shrink: 0; }}
+
+  /* Graph */
+  #graph-container {{ flex: 1; position: relative; background: #0F1117; }}
+  #graph {{ position: absolute; top: 0; left: 0; right: 0; bottom: 0; z-index: 2; }}
+
+  /* Tooltip override */
+  .vis-tooltip {{
+    background: #1E2130 !important;
+    border: 1px solid #2A2D3A !important;
+    color: #E0E0E0 !important;
+    font-size: 13px !important;
+    border-radius: 8px !important;
+    padding: 10px 14px !important;
+    box-shadow: 0 8px 24px rgba(0,0,0,0.5) !important;
+    backdrop-filter: blur(4px);
+  }}
+</style>
+</head>
+<body>
+
+<div id="header">
+  <h1>Code<span>Graph</span> AI</h1>
+  <div id="stats">
+    <span>Nodes: <b id="node-count">-</b></span>
+    <span>Edges: <b id="edge-count">-</b></span>
+  </div>
+</div>
+
+<div id="legend">
+  <span style="font-size:11px; color:#546E7A; font-weight: 700; margin-right:4px; letter-spacing: 0.05em;">NODES</span>
+  <div class="legend-item"><div class="legend-dot" style="background:#4A90E2;border-radius:2px;transform:rotate(45deg)"></div>File</div>
+  <div class="legend-item"><div class="legend-dot" style="background:#F5A623"></div>Class</div>
+  <div class="legend-item"><div class="legend-dot" style="background:#50C878"></div>Function</div>
+  <div class="legend-item"><div class="legend-dot" style="background:#7ED6A8"></div>Method</div>
+  <div class="legend-item"><div class="legend-dot" style="background:#B0BEC5;border-radius:2px"></div>Module</div>
+  <span style="font-size:11px; color:#546E7A; font-weight: 700; margin-left:12px; margin-right:4px; letter-spacing: 0.05em;">EDGES</span>
+  <div class="legend-item"><div style="width:20px;height:2px;background:#4A90E2;opacity:0.6"></div>contains</div>
+  <div class="legend-item"><div style="width:20px;height:2px;background:#50C878;opacity:0.6"></div>calls</div>
+  <div class="legend-item"><div style="width:20px;height:1px;background:#B0BEC5;border-top:1px dashed #B0BEC5"></div>imports</div>
+</div>
+
+<div id="graph-container">
+  <div id="graph"></div>
+</div>
+
+<script>
+const nodesRaw = {nodes_json};
+nodesRaw.forEach(node => {{
+  if (node.title) {{
+    const div = document.createElement("div");
+    div.innerHTML = node.title;
+    node.title = div;
+  }}
+}});
+
+const nodes = new vis.DataSet(nodesRaw);
+const edges = new vis.DataSet({edges_json});
+
+document.getElementById("node-count").textContent = nodes.length;
+document.getElementById("edge-count").textContent = edges.length;
+
+const container = document.getElementById("graph");
+const options = {{
+  physics: {{
+    enabled: true,
+    solver: "forceAtlas2Based",
+    forceAtlas2Based: {{
+      gravitationalConstant: -60,
+      centralGravity: 0.005,
+      springLength: 180,
+      springConstant: 0.04,
+      damping: 0.4,
+      avoidOverlap: 0.8
+    }},
+    maxVelocity: 50,
+    minVelocity: 0.5,
+    timestep: 0.3,
+    stabilization: {{ iterations: 200, updateInterval: 25 }}
+  }},
+  interaction: {{
+    hover: true,
+    tooltipDelay: 150,
+    navigationButtons: true,
+    keyboard: true,
+    zoomView: true,
+    hideEdgesOnDrag: false,
+    hideNodesOnDrag: false
+  }},
+  edges: {{
+    smooth: {{ type: "curvedCW", roundness: 0.15 }},
+    font: {{ strokeWidth: 2, strokeColor: "#0F1117", size: 11 }}
+  }},
+  nodes: {{
+    font: {{
+      size: 14,
+      face: "'Inter', system-ui, sans-serif",
+      strokeWidth: 3,
+      strokeColor: "#0F1117",
+      color: "#ffffff"
+    }},
+    shadow: {{
+      enabled: true,
+      color: "rgba(0,0,0,0.3)",
+      size: 10,
+      x: 0,
+      y: 0
+    }}
+  }}
+}};
+
+const network = new vis.Network(container, {{ nodes, edges }}, options);
+network.once("stabilized", () => {{
+  network.setOptions({{ physics: {{ enabled: false }} }});
+}});
+</script>
+</body>
+</html>"""
+
+
+def _darken(hex_color: str) -> str:
+    """Darken a hex color by ~15% for border contrast."""
+    try:
+        h = hex_color.lstrip("#")
+        r, g, b = int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16)
+        r, g, b = max(0, r - 35), max(0, g - 35), max(0, b - 35)
+        return f"#{r:02x}{g:02x}{b:02x}"
+    except Exception:
+        return hex_color
+
+
+@app.command()
+def ask(query: str = typer.Argument(..., help="Question about your codebase")):
+    """Ask a question about your codebase (coming soon)."""
+    typer.echo(f"ask: coming soon — query was: {query}")
+
+
+@app.command()
+def explain(file: str = typer.Argument(..., help="File to explain")):
+    """Get an AI-generated explanation of a file (coming soon)."""
+    typer.echo(f"explain: coming soon — file was: {file}")
+
+
+@app.command()
+def audit():
+    """Audit the codebase for missing docs, unused code, hidden deps (coming soon)."""
+    typer.echo("audit: coming soon")
+
+
+if __name__ == "__main__":
+    app()

codegraph_cli_ai-0.1.0/codegraph/graph/builder.py

@@ -0,0 +1,110 @@
+"""
+Graph Builder for CodeGraph AI
+
+Node types:
+  - file       : a .py file
+  - function   : top-level function
+  - class      : a class
+  - method     : a method belonging to a class
+  - module     : an imported module/package
+
+Edge types:
+  - contains   : file → function, file → class, class → method
+  - calls      : function/method → function/method
+  - imports    : file → module
+  - defined_in : function/method → file
+"""
+
+import builtins
+import networkx as nx
+from pathlib import Path
+from codegraph.parsers.python_parser import ParsedFile
+
+
+BUILTIN_FUNCTIONS = set(dir(builtins))
+
+
+class GraphBuilder:
+    def __init__(self):
+        self.graph = nx.DiGraph()
+        self._function_to_file: dict[str, str] = {}
+
+    def add_file(self, parsed: ParsedFile) -> None:
+        file_id = self._file_node_id(parsed.filepath)
+        filename = Path(parsed.filepath).name
+
+        self._add_node(file_id, kind="file", label=filename, external=False)
+
+        for cls in parsed.classes:
+            cls_id = f"class:{cls}"
+            self._add_node(cls_id, kind="class", label=cls, external=False, file=file_id)
+            self._add_edge(file_id, cls_id, relation="contains")
+
+        for func in parsed.functions:
+            func_id = f"func:{func}"
+            self._add_node(func_id, kind="function", label=func, external=False, file=file_id)
+            self._add_edge(file_id, func_id, relation="contains")
+            self._add_edge(func_id, file_id, relation="defined_in")
+            self._function_to_file[func] = file_id
+
+        for cls_name, method_name in parsed.methods:
+            cls_id = f"class:{cls_name}"
+            method_id = f"func:{method_name}"
+            self._add_node(method_id, kind="method", label=method_name, external=False, file=file_id, cls=cls_name)
+            self._add_edge(cls_id, method_id, relation="contains")
+            self._add_edge(method_id, file_id, relation="defined_in")
+            self._function_to_file[method_name] = file_id
+
+        for imp in parsed.imports:
+            mod_id = f"module:{imp}"
+            self._add_node(mod_id, kind="module", label=imp, external=True)
+            self._add_edge(file_id, mod_id, relation="imports")
+
+        for caller, callee in parsed.calls:
+            if callee in BUILTIN_FUNCTIONS:
+                continue
+            caller_id = f"func:{caller}"
+            callee_id = f"func:{callee}"
+            if not self.graph.has_node(callee_id):
+                self._add_node(callee_id, kind="function", label=callee, external=True)
+            self._add_edge(caller_id, callee_id, relation="calls")
+
+    def build(self, parsed_files: list[ParsedFile]) -> nx.DiGraph:
+        for parsed in parsed_files:
+            if not parsed.errors:
+                self.add_file(parsed)
+        return self.graph
+
+    def summary(self) -> dict:
+        nodes_by_kind = {}
+        for _, data in self.graph.nodes(data=True):
+            kind = data.get("kind", "unknown")
+            nodes_by_kind[kind] = nodes_by_kind.get(kind, 0) + 1
+
+        edges_by_relation = {}
+        for _, _, data in self.graph.edges(data=True):
+            rel = data.get("relation", "unknown")
+            edges_by_relation[rel] = edges_by_relation.get(rel, 0) + 1
+
+        return {
+            "total_nodes": self.graph.number_of_nodes(),
+            "total_edges": self.graph.number_of_edges(),
+            "nodes_by_kind": nodes_by_kind,
+            "edges_by_relation": edges_by_relation,
+        }
+
+    def to_dict(self) -> dict:
+        return {
+            "nodes": [{"id": node, **data} for node, data in self.graph.nodes(data=True)],
+            "edges": [{"source": src, "target": dst, **data} for src, dst, data in self.graph.edges(data=True)],
+        }
+
+    def _file_node_id(self, filepath: str) -> str:
+        return f"file:{Path(filepath).name}"
+
+    def _add_node(self, node_id: str, **attrs) -> None:
+        if not self.graph.has_node(node_id):
+            self.graph.add_node(node_id, **attrs)
+
+    def _add_edge(self, src: str, dst: str, **attrs) -> None:
+        self.graph.add_edge(src, dst, **attrs)

codegraph_cli_ai-0.1.0/codegraph/parsers/python_parser.py

@@ -0,0 +1,125 @@
+"""
+Python AST Parser for CodeGraph AI
+Extracts functions, classes, imports, and call graphs from Python files.
+"""
+from __future__ import annotations
+
+import ast
+from typing import Optional
+from pathlib import Path
+from dataclasses import dataclass, field
+
+
+@dataclass
+class ParsedFile:
+    filepath: str
+    functions: list[str] = field(default_factory=list)            # top-level only
+    classes: list[str] = field(default_factory=list)
+    methods: list[tuple[str, str]] = field(default_factory=list)  # (class_name, method_name)
+    imports: list[str] = field(default_factory=list)
+    calls: list[tuple[str, str]] = field(default_factory=list)    # (caller, callee)
+    errors: list[str] = field(default_factory=list)
+
+
+class PythonParser:
+    """
+    Parses a Python file using the built-in ast module.
+    Extracts structural information for graph construction.
+    """
+
+    def parse_file(self, filepath: str) -> ParsedFile:
+        result = ParsedFile(filepath=filepath)
+        source = self._read_file(filepath, result)
+
+        if source is None:
+            return result
+
+        tree = self._parse_source(source, filepath, result)
+
+        if tree is None:
+            return result
+
+        self._extract_imports(tree, result)
+        self._extract_functions_and_calls(tree, result)
+        self._extract_classes(tree, result)
+
+        return result
+
+    # -------------------------
+    # Private helpers
+    # -------------------------
+
+    def _read_file(self, filepath: str, result: ParsedFile) -> Optional[str]:
+        try:
+            return Path(filepath).read_text(encoding="utf-8")
+        except FileNotFoundError:
+            result.errors.append(f"File not found: {filepath}")
+            return None
+        except Exception as e:
+            result.errors.append(f"Could not read file: {e}")
+            return None
+
+    def _parse_source(self, source: str, filepath: str, result: ParsedFile) -> Optional[ast.AST]:
+        try:
+            return ast.parse(source, filename=filepath)
+        except SyntaxError as e:
+            result.errors.append(f"Syntax error: {e}")
+            return None
+
+    def _extract_imports(self, tree: ast.AST, result: ParsedFile):
+        for node in ast.walk(tree):
+            # e.g. import os, import sys
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    result.imports.append(alias.name)
+
+            # e.g. from pathlib import Path
+            elif isinstance(node, ast.ImportFrom):
+                module = node.module or ""
+                for alias in node.names:
+                    result.imports.append(f"{module}.{alias.name}")
+
+    def _extract_functions_and_calls(self, tree: ast.AST, result: ParsedFile):
+        # Collect method names per class first
+        class_method_names: set[str] = set()
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ClassDef):
+                for item in node.body:
+                    if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                        class_method_names.add(item.name)
+
+        # Walk top-level for standalone functions
+        for node in ast.iter_child_nodes(tree):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                result.functions.append(node.name)
+                self._extract_calls_in_func(node, node.name, result)
+
+            elif isinstance(node, ast.ClassDef):
+                for item in node.body:
+                    if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                        result.methods.append((node.name, item.name))
+                        self._extract_calls_in_func(item, item.name, result)
+
+    def _extract_calls_in_func(self, func_node: ast.AST, func_name: str, result: ParsedFile):
+        for child in ast.walk(func_node):
+            if isinstance(child, ast.Call):
+                callee = self._resolve_call_name(child)
+                if callee:
+                    result.calls.append((func_name, callee))
+
+    def _extract_classes(self, tree: ast.AST, result: ParsedFile):
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ClassDef):
+                result.classes.append(node.name)
+
+    def _resolve_call_name(self, call_node: ast.Call) -> Optional[str]:
+        """Extract the name of a function being called."""
+        func = call_node.func
+
+        if isinstance(func, ast.Name):
+            return func.id  # e.g. print(...)
+
+        if isinstance(func, ast.Attribute):
+            return func.attr  # e.g. self.login() → login
+
+        return None

codegraph_cli_ai-0.1.0/codegraph_cli_ai.egg-info/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: codegraph-cli-ai
+Version: 0.1.0
+Summary: CLI tool to analyze codebases and visualize knowledge graphs using AST
+Author: Aditya Jogdand
+License: MIT
+Keywords: code-analysis,ast,graph,cli,developer-tools
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.9.0
+Requires-Dist: networkx>=3.0
+Requires-Dist: pyvis>=0.3.2

codegraph_cli_ai-0.1.0/codegraph_cli_ai.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+pyproject.toml
+codegraph/cli.py
+codegraph/graph/builder.py
+codegraph/parsers/python_parser.py
+codegraph_cli_ai.egg-info/PKG-INFO
+codegraph_cli_ai.egg-info/SOURCES.txt
+codegraph_cli_ai.egg-info/dependency_links.txt
+codegraph_cli_ai.egg-info/entry_points.txt
+codegraph_cli_ai.egg-info/requires.txt
+codegraph_cli_ai.egg-info/top_level.txt

codegraph_cli_ai-0.1.0/codegraph_cli_ai.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

codegraph_cli_ai-0.1.0/codegraph_cli_ai.egg-info/entry_points.txt

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

codegraph_cli_ai-0.1.0/codegraph_cli_ai.egg-info/requires.txt

@@ -0,0 +1,3 @@
+typer>=0.9.0
+networkx>=3.0
+pyvis>=0.3.2

codegraph_cli_ai-0.1.0/codegraph_cli_ai.egg-info/top_level.txt

@@ -0,0 +1 @@
+codegraph

codegraph_cli_ai-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "codegraph-cli-ai"
+version = "0.1.0"
+description = "CLI tool to analyze codebases and visualize knowledge graphs using AST"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+
+authors = [
+  { name = "Aditya Jogdand" }
+]
+
+keywords = ["code-analysis", "ast", "graph", "cli", "developer-tools"]
+
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.9",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+]
+
+dependencies = [
+    "typer>=0.9.0",
+    "networkx>=3.0",
+    "pyvis>=0.3.2"
+]
+
+[project.scripts]
+codegraph = "codegraph.cli:app"

codegraph_cli_ai-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+