codegraph-cli-ai 0.1.7__tar.gz → 0.1.8__tar.gz

{codegraph_cli_ai-0.1.7 → codegraph_cli_ai-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraph-cli-ai
-Version: 0.1.7
+Version: 0.1.8
 Summary: CLI tool to analyze codebases and visualize knowledge graphs using AST
 Author: Aditya Jogdand
 License: MIT

{codegraph_cli_ai-0.1.7 → codegraph_cli_ai-0.1.8}/codegraph/cli.py

@@ -9,6 +9,7 @@ import networkx as nx
 from pathlib import Path
 from typing import Optional
 from codegraph.parsers.python_parser import PythonParser
+from codegraph.parsers.multimodal_parser import MultiModalParser
 from codegraph.graph.builder import GraphBuilder
 
 app = typer.Typer()
@@ -20,6 +21,23 @@ def main():
     pass
 
 
+IGNORE_DIRS = {
+    "venv", ".venv", "env", "bin", "Scripts",
+    ".git", "__pycache__", "node_modules", ".codegraph"
+}
+IGNORE_FILES = {"graph.json", ".DS_Store"}
+IGNORE_EXTENSIONS = {".pyc", ".log", ".pyo", ".pyd"}
+
+
+def is_virtualenv(path: Path) -> bool:
+    """Detect if a directory is a virtual environment based on its structure."""
+    return (
+        (path / "pyvenv.cfg").exists()
+        or (path / "bin" / "python").exists()
+        or (path / "Scripts" / "python.exe").exists()
+    )
+
+
 @app.command()
 def index(
     path: str = typer.Argument(".", help="Path to the repo or folder to index")
@@ -32,31 +50,81 @@ def index(
         raise typer.Exit(code=1)
 
     typer.echo(f"Indexing: {root}\n")
-    py_files = list(root.rglob("*.py"))
+    
+    # Phase A: Identify top-level custom virtualenvs
+    venv_dirs = set()
+    for item in root.iterdir():
+        if item.is_dir() and is_virtualenv(item):
+            venv_dirs.add(item)
+
+    # Phase B: Filtered Scan
+    all_files = []
+    for p in root.rglob("*"):
+        if not p.is_file():
+            continue
+            
+        # 1. Skip if any parent directory is in IGNORE_DIRS
+        if any(part in IGNORE_DIRS for part in p.parts):
+            continue
+            
+        # 2. Skip if inside a detected custom venv
+        if any(v_dir in p.parents for v_dir in venv_dirs):
+            continue
+            
+        # 3. Skip if filename is ignored
+        if p.name in IGNORE_FILES:
+            continue
+            
+        # 4. Skip if extension is ignored
+        if p.suffix.lower() in IGNORE_EXTENSIONS:
+            continue
+            
+        all_files.append(p)
+
+    py_files = [f for f in all_files if f.suffix == ".py"]
+    asset_exts = {
+        ".csv", ".json", ".db", ".sqlite",
+        ".pdf",
+        ".png", ".jpg", ".jpeg"
+    }
+    asset_files = [f for f in all_files if f.suffix.lower() in asset_exts]
 
-    if not py_files:
-        typer.echo("No Python files found.")
+    if not py_files and not asset_files:
+        typer.echo("No supported files found (everything might be ignored).")
         raise typer.Exit()
 
-    typer.echo(f"Found {len(py_files)} Python file(s)\n")
+    typer.echo(f"Found {len(py_files)} Python file(s) and {len(asset_files)} asset(s)\n")
 
     # Step 1 — Parse
-    parser = PythonParser()
+    py_parser = PythonParser()
+    mm_parser = MultiModalParser()
+    
     parsed_files = []
+    parsed_assets = []
     failed_files = []
 
+    # Parse Python files
     for filepath in py_files:
-        result = parser.parse_file(str(filepath))
+        result = py_parser.parse_file(str(filepath))
         if result.errors:
             failed_files.append((str(filepath), result.errors))
         else:
-            typer.echo(f"  ✔  {filepath.relative_to(root)}")
+            typer.echo(f"  ✔ [code]  {filepath.relative_to(root)}")
             parsed_files.append(result)
 
+    # Parse assets
+    for filepath in asset_files:
+        try:
+            asset = mm_parser.parse(str(filepath))
+            typer.echo(f"  ✔ [asset] {filepath.relative_to(root)}")
+            parsed_assets.append(asset)
+        except Exception as e:
+            failed_files.append((str(filepath), [str(e)]))
+
     # Step 2 — Build graph
     typer.echo("\nBuilding graph...")
     builder = GraphBuilder()
-    builder.build(parsed_files)
+    builder.build(parsed_files, parsed_assets)
     summary = builder.summary()
 
     # Step 3 — Save to .codegraph/graph.json
@@ -163,9 +231,13 @@ def _build_premium_html(G: nx.DiGraph) -> str:
     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"},
+        "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"},
+        "dataset":  {"color": "#FFD700", "shape": "diamond", "size": 22, "font_color": "#ffffff"},
+        "database": {"color": "#FF69B4", "shape": "database", "size": 24, "font_color": "#ffffff"},
+        "document": {"color": "#9B59B6", "shape": "diamond", "size": 24, "font_color": "#ffffff"},
+        "image":    {"color": "#5DADE2", "shape": "diamond", "size": 24, "font_color": "#ffffff"},
     }
 
     EDGE_COLORS = {
@@ -173,6 +245,8 @@ def _build_premium_html(G: nx.DiGraph) -> str:
         "calls":      "#50C878",
         "imports":    "#B0BEC5",
         "defined_in": "#E8E8E8",
+        "uses":       "#FFD700",
+        "references": "#9B59B6",
     }
 
     nodes_js = []
@@ -188,10 +262,41 @@ def _build_premium_html(G: nx.DiGraph) -> str:
 
         # Tooltip
         tooltip_parts = [f"<b>{label}</b>", f"Kind: {kind}"]
-        if attrs.get("file"):
+        if attrs.get("filename"):
+            tooltip_parts.append(f"File: {attrs['filename']}")
+        elif attrs.get("file"):
             tooltip_parts.append(f"File: {attrs['file'].replace('file:', '')}")
         if attrs.get("cls"):
             tooltip_parts.append(f"Class: {attrs['cls']}")
+        
+        # MultiModal Metadata for tooltips
+        metadata = attrs.get("metadata", {})
+        if kind == "dataset":
+            if "columns" in metadata: tooltip_parts.append(f"Columns: {', '.join(metadata['columns'])}")
+            if "keys" in metadata: tooltip_parts.append(f"Keys: {', '.join(metadata['keys'])}")
+        elif kind == "database":
+            if "tables" in metadata: tooltip_parts.append(f"Tables: {', '.join(metadata['tables'])}")
+        elif kind == "document":
+            if "num_pages" in metadata: tooltip_parts.append(f"Pages: {metadata['num_pages']}")
+            if "text_preview" in metadata: tooltip_parts.append(f"<br>Preview: <i>{metadata['text_preview']}</i>")
+        elif kind == "image":
+            if "text" in metadata and metadata["text"]: tooltip_parts.append(f"<br>OCR Text: <i>{metadata['text']}</i>")
+        
+        # Add metadata for datasets/databases
+        metadata = attrs.get("metadata", {})
+        if metadata:
+            if "columns" in metadata:
+                cols = ", ".join(metadata["columns"][:5])
+                if len(metadata["columns"]) > 5: cols += "..."
+                tooltip_parts.append(f"Columns: {cols}")
+            if "tables" in metadata:
+                tbls = ", ".join(metadata["tables"])
+                tooltip_parts.append(f"Tables: {tbls}")
+            if "keys" in metadata:
+                keys = ", ".join(metadata["keys"][:5])
+                if len(metadata["keys"]) > 5: keys += "..."
+                tooltip_parts.append(f"Keys: {keys}")
+
         if external:
             tooltip_parts.append("<i>external</i>")
         tooltip = "<br>".join(tooltip_parts)
@@ -337,10 +442,15 @@ def _build_premium_html(G: nx.DiGraph) -> str:
   <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>
+  <div class="legend-item"><div class="legend-dot" style="background:#FFD700;clip-path:polygon(50% 0%, 100% 50%, 50% 100%, 0% 50%)"></div>Dataset</div>
+  <div class="legend-item"><div class="legend-dot" style="background:#FF69B4;border-radius:2px"></div>Database</div>
+  <div class="legend-item"><div class="legend-dot" style="background:#9B59B6;clip-path:polygon(50% 0%, 100% 50%, 50% 100%, 0% 50%)"></div>Document</div>
+  <div class="legend-item"><div class="legend-dot" style="background:#5DADE2;clip-path:polygon(50% 0%, 100% 50%, 50% 100%, 0% 50%)"></div>Image</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 class="legend-item"><div style="width:20px;height:2px;background:#FFD700;opacity:0.6"></div>uses</div>
 </div>
 
 <div id="graph-container">

codegraph_cli_ai-0.1.8/codegraph/graph/builder.py

@@ -0,0 +1,190 @@
+"""
+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
+from codegraph.parsers.multimodal_parser import ParsedAsset
+
+
+BUILTIN_FUNCTIONS = set(dir(builtins))
+
+
+class GraphBuilder:
+    def __init__(self):
+        self.graph = nx.DiGraph()
+        self._function_to_file: dict[str, str] = {}
+        self._assets: list[ParsedAsset] = []
+        self._parsed_files: list[ParsedFile] = []
+
+    def add_file(self, parsed: ParsedFile) -> None:
+        self._parsed_files.append(parsed)
+        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:{file_id}:{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:{file_id}:{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:{file_id}:{cls_name}"
+            method_id = f"func:{file_id}:{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
+            
+            # Use file context for caller
+            caller_id = f"func:{file_id}:{caller}"
+            
+            # Resolve callee ID using global map or default to external
+            target_file_id = self._function_to_file.get(callee)
+            if target_file_id:
+                callee_id = f"func:{target_file_id}:{callee}"
+            else:
+                callee_id = f"func:external:{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 add_asset(self, asset: ParsedAsset) -> None:
+        self._assets.append(asset)
+        filename = Path(asset.filepath).name
+        node_id = f"{asset.kind}:{filename}"
+        
+        self._add_node(
+            node_id, 
+            kind=asset.kind, 
+            label=filename, 
+            filename=filename, # keep raw filename for linking
+            external=False, 
+            metadata=asset.metadata
+        )
+
+    def link_code_to_assets(self) -> None:
+        """
+        Connect code nodes to assets if the filename appears in:
+        - function name
+        - call list
+        - string usage
+        """
+        for node_id, data in list(self.graph.nodes(data=True)):
+            if data.get("kind") not in ("function", "method"):
+                continue
+            
+            # Get function metadata from parsed files
+            func_name = data.get("label")
+            file_id = data.get("file")
+            
+            # Find the parsed file this function belongs to
+            parsed = next((p for p in self._parsed_files if self._file_node_id(p.filepath) == file_id), None)
+            if not parsed:
+                continue
+
+            # Check each asset
+            for asset in self._assets:
+                asset_filename = Path(asset.filepath).name
+                asset_id = f"{asset.kind}:{asset_filename}"
+                relation = "uses" if asset.kind in ("dataset", "database") else "references"
+                
+                # Check 1: function name
+                if asset_filename in func_name:
+                    self._add_edge(node_id, asset_id, relation=relation)
+                    continue
+                
+                # Check 2: call list for this function
+                calls = [c[1] for c in parsed.calls if c[0] == func_name]
+                if any(asset_filename in callee for callee in calls):
+                    self._add_edge(node_id, asset_id, relation=relation)
+                    continue
+                
+                # Check 3: string usage
+                strings = parsed.strings.get(func_name, [])
+                if any(asset_filename in s for s in strings):
+                    self._add_edge(node_id, asset_id, relation=relation)
+                    continue
+
+    def build(self, parsed_files: list[ParsedFile], assets: list[ParsedAsset] = None) -> nx.DiGraph:
+        # First pass: add all files to populate function-to-file map
+        for parsed in parsed_files:
+            if not parsed.errors:
+                self.add_file(parsed)
+        
+        # Second pass: add assets
+        if assets:
+            for asset in assets:
+                self.add_asset(asset)
+        
+        # Third pass: link code to assets
+        self.link_code_to_assets()
+        
+        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.8/codegraph/parsers/database_parser.py

@@ -0,0 +1,25 @@
+"""
+Database Parser for CodeGraph AI
+Extracts metadata from SQLite databases.
+"""
+import sqlite3
+from pathlib import Path
+
+class DatabaseParser:
+    """
+    Parses SQLite files to extract table names.
+    """
+    
+    def parse(self, filepath: str) -> dict:
+        metadata = {"tables": []}
+        try:
+            conn = sqlite3.connect(filepath)
+            cursor = conn.cursor()
+            cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
+            tables = [row[0] for row in cursor.fetchall()]
+            metadata["tables"] = tables
+            conn.close()
+        except Exception as e:
+            metadata["error"] = str(e)
+            
+        return metadata

codegraph_cli_ai-0.1.8/codegraph/parsers/image_parser.py

@@ -0,0 +1,39 @@
+"""
+Image Parser for CodeGraph AI
+Extracts text from images using pytesseract (OCR).
+"""
+import pytesseract
+from PIL import Image
+from pathlib import Path
+
+class ImageParser:
+    """
+    Parses Image files to extract text via OCR.
+    """
+    
+    def parse(self, filepath: str) -> dict:
+        """
+        Attempts OCR on the image. Falls back gracefully if OCR is unavailable.
+        """
+        metadata = {
+            "text": ""
+        }
+        
+        try:
+            # Check if tesseract is installed
+            # (In a real system we'd handle TesseractNotFoundError specifically)
+            img = Image.open(filepath)
+            ocr_text = pytesseract.image_to_string(img)
+            
+            # Limit the text length
+            if len(ocr_text) > 500:
+                ocr_text = ocr_text[:500] + "..."
+            
+            metadata["text"] = ocr_text.strip()
+            
+        except Exception as e:
+            # If tesseract is not found or fails, we still return success with empty text
+            # as requested in the requirements (handle failure gracefully)
+            metadata["error"] = f"OCR failed or not available: {str(e)}"
+            
+        return metadata

codegraph_cli_ai-0.1.8/codegraph/parsers/multimodal_parser.py

@@ -0,0 +1,86 @@
+"""
+MultiModal Parser for CodeGraph AI
+Extracts metadata from non-code assets like CSV, JSON, SQLite, PDF, and Images.
+"""
+import json
+import csv
+import sqlite3
+from pathlib import Path
+from dataclasses import dataclass, field
+
+from codegraph.parsers.pdf_parser import PDFParser
+from codegraph.parsers.image_parser import ImageParser
+from codegraph.parsers.database_parser import DatabaseParser
+
+
+@dataclass
+class ParsedAsset:
+    filepath: str
+    kind: str  # "dataset" | "database" | "document" | "image"
+    metadata: dict = field(default_factory=dict)
+
+
+class MultiModalParser:
+    """
+    Parses non-Python files (CSV, JSON, SQLite, PDF, Image) to extract metadata.
+    """
+
+    def __init__(self):
+        self.pdf_parser = PDFParser()
+        self.image_parser = ImageParser()
+        self.database_parser = DatabaseParser()
+
+    def parse(self, filepath: str) -> ParsedAsset:
+        path = Path(filepath)
+        suffix = path.suffix.lower()
+
+        if suffix == ".csv":
+            return self._parse_csv(path)
+        elif suffix == ".json":
+            return self._parse_json(path)
+        elif suffix in (".db", ".sqlite"):
+            return self._parse_sqlite(path)
+        elif suffix == ".pdf":
+            return self._parse_pdf(path)
+        elif suffix in (".png", ".jpg", ".jpeg"):
+            return self._parse_image(path)
+        else:
+            return ParsedAsset(filepath=str(path), kind="unknown")
+
+    def _parse_csv(self, path: Path) -> ParsedAsset:
+        metadata = {"columns": []}
+        try:
+            with path.open("r", encoding="utf-8") as f:
+                reader = csv.reader(f)
+                header = next(reader, [])
+                metadata["columns"] = header
+        except Exception as e:
+            metadata["error"] = str(e)
+        
+        return ParsedAsset(filepath=str(path), kind="dataset", metadata=metadata)
+
+    def _parse_json(self, path: Path) -> ParsedAsset:
+        metadata = {"keys": []}
+        try:
+            with path.open("r", encoding="utf-8") as f:
+                data = json.load(f)
+                if isinstance(data, dict):
+                    metadata["keys"] = list(data.keys())
+                elif isinstance(data, list) and len(data) > 0 and isinstance(data[0], dict):
+                    metadata["keys"] = list(data[0].keys())
+        except Exception as e:
+            metadata["error"] = str(e)
+            
+        return ParsedAsset(filepath=str(path), kind="dataset", metadata=metadata)
+
+    def _parse_sqlite(self, path: Path) -> ParsedAsset:
+        metadata = self.database_parser.parse(str(path))
+        return ParsedAsset(filepath=str(path), kind="database", metadata=metadata)
+
+    def _parse_pdf(self, path: Path) -> ParsedAsset:
+        metadata = self.pdf_parser.parse(str(path))
+        return ParsedAsset(filepath=str(path), kind="document", metadata=metadata)
+
+    def _parse_image(self, path: Path) -> ParsedAsset:
+        metadata = self.image_parser.parse(str(path))
+        return ParsedAsset(filepath=str(path), kind="image", metadata=metadata)

codegraph_cli_ai-0.1.8/codegraph/parsers/pdf_parser.py

@@ -0,0 +1,43 @@
+"""
+PDF Parser for CodeGraph AI
+Extracts text and metadata from PDF files using pypdf.
+"""
+from pathlib import Path
+from pypdf import PdfReader
+
+class PDFParser:
+    """
+    Parses PDF files to extract basic text preview and page count.
+    """
+    
+    def parse(self, filepath: str) -> dict:
+        """
+        Extracts metadata from the first few pages of a PDF.
+        """
+        metadata = {
+            "num_pages": 0,
+            "text_preview": ""
+        }
+        
+        try:
+            reader = PdfReader(filepath)
+            metadata["num_pages"] = len(reader.pages)
+            
+            # Extract text from first 2 pages as a preview
+            preview_text = []
+            for i in range(min(2, len(reader.pages))):
+                text = reader.pages[i].extract_text()
+                if text:
+                    preview_text.append(text.strip())
+            
+            # Limit the preview length to avoid huge tooltips
+            full_preview = "\n---\n".join(preview_text)
+            if len(full_preview) > 500:
+                full_preview = full_preview[:500] + "..."
+            
+            metadata["text_preview"] = full_preview
+            
+        except Exception as e:
+            metadata["error"] = str(e)
+            
+        return metadata

{codegraph_cli_ai-0.1.7 → codegraph_cli_ai-0.1.8}/codegraph/parsers/python_parser.py

@@ -18,6 +18,7 @@ class ParsedFile:
     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)
+    strings: dict[str, list[str]] = field(default_factory=list)   # func_name -> list of strings
     errors: list[str] = field(default_factory=list)
 
 
@@ -28,7 +29,7 @@ class PythonParser:
     """
 
     def parse_file(self, filepath: str) -> ParsedFile:
-        result = ParsedFile(filepath=filepath)
+        result = ParsedFile(filepath=filepath, strings={})
         source = self._read_file(filepath, result)
 
         if source is None:
@@ -93,12 +94,14 @@ class PythonParser:
             if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
                 result.functions.append(node.name)
                 self._extract_calls_in_func(node, node.name, result)
+                self._extract_strings_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)
+                        self._extract_strings_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):
@@ -107,6 +110,15 @@ class PythonParser:
                 if callee:
                     result.calls.append((func_name, callee))
 
+    def _extract_strings_in_func(self, func_node: ast.AST, func_name: str, result: ParsedFile):
+        if func_name not in result.strings:
+            result.strings[func_name] = []
+        
+        for child in ast.walk(func_node):
+            # Python 3.8+ handles strings as ast.Constant
+            if isinstance(child, ast.Constant) and isinstance(child.value, str):
+                result.strings[func_name].append(child.value)
+
     def _extract_classes(self, tree: ast.AST, result: ParsedFile):
         for node in ast.walk(tree):
             if isinstance(node, ast.ClassDef):

{codegraph_cli_ai-0.1.7 → codegraph_cli_ai-0.1.8}/codegraph_cli_ai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraph-cli-ai
-Version: 0.1.7
+Version: 0.1.8
 Summary: CLI tool to analyze codebases and visualize knowledge graphs using AST
 Author: Aditya Jogdand
 License: MIT

{codegraph_cli_ai-0.1.7 → codegraph_cli_ai-0.1.8}/codegraph_cli_ai.egg-info/SOURCES.txt

@@ -3,6 +3,10 @@ README.md
 pyproject.toml
 codegraph/cli.py
 codegraph/graph/builder.py
+codegraph/parsers/database_parser.py
+codegraph/parsers/image_parser.py
+codegraph/parsers/multimodal_parser.py
+codegraph/parsers/pdf_parser.py
 codegraph/parsers/python_parser.py
 codegraph_cli_ai.egg-info/PKG-INFO
 codegraph_cli_ai.egg-info/SOURCES.txt

{codegraph_cli_ai-0.1.7 → codegraph_cli_ai-0.1.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codegraph-cli-ai"
-version = "0.1.7"
+version = "0.1.8"
 description = "CLI tool to analyze codebases and visualize knowledge graphs using AST"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.9"

codegraph_cli_ai-0.1.7/codegraph/graph/builder.py

@@ -1,110 +0,0 @@
-"""
-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)