codegraph-gen 1.1.0__tar.gz → 1.3.2__tar.gz

{codegraph_gen-1.1.0 → codegraph_gen-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: codegraph-gen
-Version: 1.1.0
+Version: 1.3.2
 Summary: AST-based codebase knowledge graph generator in Markdown
 Keywords: knowledge-graph,ast,codebase,markdown,tree-sitter,visualization,static-analysis,ai-agent,obsidian
 Author: twn39
@@ -28,6 +28,7 @@ Requires-Dist: pydantic>=2.0.0
 Requires-Dist: tree-sitter-c>=0.24.2
 Requires-Dist: tree-sitter-cpp>=0.23.4
 Requires-Dist: tree-sitter-kotlin>=1.1.0
+Requires-Dist: tree-sitter-ocaml>=0.25.0
 Requires-Python: >=3.11
 Project-URL: Homepage, https://github.com/twn39/codegraph
 Project-URL: Repository, https://github.com/twn39/codegraph
@@ -51,7 +52,7 @@ Description-Content-Type: text/markdown
 
 ## 🚀 核心特性
 
-- **多语言 AST 解析**：基于 `tree-sitter`，原生支持 **Python, JavaScript, TypeScript, Kotlin, Go, Rust, Swift**。
+- **多语言 AST 解析**：基于 `tree-sitter`，原生支持 **Python, JavaScript, TypeScript, Kotlin, Go, Rust, Swift, C, C++**。
 - **语义边解析与绑定**：静态解析跨文件的函数/方法调用（`calls`）、类型继承/接口实现（`inherits`/`implements`）以及文件导入关系（`imports`）。
 - **逻辑组件自动聚类**：利用贪心模块度社区发现算法（Louvain Modularity Clustering）将紧密耦合的文件和符号自动聚类为 **Component（逻辑组件）**，并根据组件核心节点智能命名。
 - **架构脆弱性分析**：自动识别 **God Nodes（度数最高的核心抽象）**，并静态检测文件级别的 **循环导入依赖（Circular Imports）**。
@@ -61,7 +62,16 @@ Description-Content-Type: text/markdown
 
 ## 📦 架构概览
 
-- **工作区源码 Workspace** -> **detect: 语言识别与过滤** -> **parser: Tree-Sitter AST 符号提取** -> **builder: NetworkX 语义图组装与绑定** -> **cluster: 社区模块度聚类命名** -> **analyze: 上帝节点与循环导入分析** -> **export: 导出至 .codegraph/** -> **生成 AGENT_PROMPT.md / AGENTS.md / README.md / nodes / components**
+```mermaid
+flowchart LR
+    Workspace["工作区源码 Workspace"] --> Detect["detect: 语言识别与过滤"]
+    Detect --> Parser["parser: Tree-Sitter AST 符号提取"]
+    Parser --> Builder["builder: NetworkX 语义图组装与绑定"]
+    Builder --> Cluster["cluster: 社区模块度聚类命名"]
+    Cluster --> Analyze["analyze: 上帝节点与循环导入分析"]
+    Analyze --> Export["export: 导出至 .codegraph/"]
+    Export --> Generate["生成 AGENT_PROMPT.md / AGENTS.md / README.md / nodes / components"]
+```
 
 ---
 
@@ -83,11 +93,11 @@ uv pip install codegraph-gen
 
 ### 注册 AI Agent 斜杠命令
 
-`codegraph-gen` 支持一键将 `/codegraph` 自定义斜杠命令注册到您的 AI Agent（如 Codex 或 Antigravity）的全局配置中：
+`codegraph-gen` 支持一键将 `/codegraph` 自定义斜杠命令注册到您的 AI Agent（如 Codex、Antigravity 或 Crush）的全局配置中：
 
 ```bash
-# 为 Codex / Antigravity 注入 /codegraph 全局斜杠命令
-codegraph install --platform codex
+# 为 Codex / Antigravity / Crush 注入 /codegraph 全局斜杠命令
+codegraph install --platform crush
 ```
 
 注册完成后，在对应的 Agent 终端中，您只需输入 `/codegraph` 即可全自动运行整个图谱的提取、分析与回写流程。

{codegraph_gen-1.1.0 → codegraph_gen-1.3.2}/README.md

@@ -15,7 +15,7 @@
 
 ## 🚀 核心特性
 
-- **多语言 AST 解析**：基于 `tree-sitter`，原生支持 **Python, JavaScript, TypeScript, Kotlin, Go, Rust, Swift**。
+- **多语言 AST 解析**：基于 `tree-sitter`，原生支持 **Python, JavaScript, TypeScript, Kotlin, Go, Rust, Swift, C, C++**。
 - **语义边解析与绑定**：静态解析跨文件的函数/方法调用（`calls`）、类型继承/接口实现（`inherits`/`implements`）以及文件导入关系（`imports`）。
 - **逻辑组件自动聚类**：利用贪心模块度社区发现算法（Louvain Modularity Clustering）将紧密耦合的文件和符号自动聚类为 **Component（逻辑组件）**，并根据组件核心节点智能命名。
 - **架构脆弱性分析**：自动识别 **God Nodes（度数最高的核心抽象）**，并静态检测文件级别的 **循环导入依赖（Circular Imports）**。
@@ -25,7 +25,16 @@
 
 ## 📦 架构概览
 
-- **工作区源码 Workspace** -> **detect: 语言识别与过滤** -> **parser: Tree-Sitter AST 符号提取** -> **builder: NetworkX 语义图组装与绑定** -> **cluster: 社区模块度聚类命名** -> **analyze: 上帝节点与循环导入分析** -> **export: 导出至 .codegraph/** -> **生成 AGENT_PROMPT.md / AGENTS.md / README.md / nodes / components**
+```mermaid
+flowchart LR
+    Workspace["工作区源码 Workspace"] --> Detect["detect: 语言识别与过滤"]
+    Detect --> Parser["parser: Tree-Sitter AST 符号提取"]
+    Parser --> Builder["builder: NetworkX 语义图组装与绑定"]
+    Builder --> Cluster["cluster: 社区模块度聚类命名"]
+    Cluster --> Analyze["analyze: 上帝节点与循环导入分析"]
+    Analyze --> Export["export: 导出至 .codegraph/"]
+    Export --> Generate["生成 AGENT_PROMPT.md / AGENTS.md / README.md / nodes / components"]
+```
 
 ---
 
@@ -47,11 +56,11 @@ uv pip install codegraph-gen
 
 ### 注册 AI Agent 斜杠命令
 
-`codegraph-gen` 支持一键将 `/codegraph` 自定义斜杠命令注册到您的 AI Agent（如 Codex 或 Antigravity）的全局配置中：
+`codegraph-gen` 支持一键将 `/codegraph` 自定义斜杠命令注册到您的 AI Agent（如 Codex、Antigravity 或 Crush）的全局配置中：
 
 ```bash
-# 为 Codex / Antigravity 注入 /codegraph 全局斜杠命令
-codegraph install --platform codex
+# 为 Codex / Antigravity / Crush 注入 /codegraph 全局斜杠命令
+codegraph install --platform crush
 ```
 
 注册完成后，在对应的 Agent 终端中，您只需输入 `/codegraph` 即可全自动运行整个图谱的提取、分析与回写流程。

{codegraph_gen-1.1.0 → codegraph_gen-1.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codegraph-gen"
-version = "1.1.0"
+version = "1.3.2"
 description = "AST-based codebase knowledge graph generator in Markdown"
 readme = "README.md"
 authors = [
@@ -44,6 +44,7 @@ dependencies = [
     "tree-sitter-c>=0.24.2",
     "tree-sitter-cpp>=0.23.4",
     "tree-sitter-kotlin>=1.1.0",
+    "tree-sitter-ocaml>=0.25.0",
 ]
 
 [dependency-groups]
@@ -51,6 +52,8 @@ dev = [
     "pytest>=8.0.0",
     "ruff>=0.15.16",
     "ty>=0.0.44",
+    "plotly>=5.0.0",
+    "numpy>=1.20.0",
 ]
 
 [project.urls]

{codegraph_gen-1.1.0 → codegraph_gen-1.3.2}/src/codegraph_gen/__main__.py

@@ -10,12 +10,26 @@ from rich.progress import (
     MofNCompleteColumn,
 )
 
-from codegraph_gen.config import CodegraphConfig, DEFAULT_EXCLUSIONS
+from codegraph_gen.config import (
+    CodegraphConfig,
+    DEFAULT_EXCLUSIONS,
+    LANGUAGE_EXTENSIONS,
+    load_project_config,
+    PROJECT_CONFIG_FILE,
+)
 
 console = Console()
 
+try:
+    from importlib.metadata import version
+
+    __version__ = version("codegraph-gen")
+except Exception:
+    __version__ = "1.3.2"
+
 
 @click.group()
+@click.version_option(version=__version__, prog_name="codegraph")
 def cli():
     """codegraph - Build a Markdown knowledge graph of your codebase for AI analysis."""
     pass
@@ -69,26 +83,99 @@ def build(
     """Parses the codebase in SRC_DIR and exports the Markdown graph vault."""
     console.print("[bold blue]Starting codegraph analysis...[/bold blue]")
 
-    # 1. Prepare configuration
+    workspace = src_dir.resolve()
+
+    # ── Load project config file (.codegraphrc) ────────────────────────────
+    project_cfg = load_project_config(workspace)
+
+    if project_cfg is not None:
+        console.print(
+            f"[dim]📄 Found project config: [underline]{workspace / PROJECT_CONFIG_FILE}[/underline][/dim]"
+        )
+
+    # ── Merge: CLI args take priority over .codegraphrc ────────────────────
+    # Exclusions: default set + .codegraphrc extras + CLI --exclude (cumulative)
     exclusions = set(DEFAULT_EXCLUSIONS)
+    if project_cfg and project_cfg.exclude:
+        exclusions.update(project_cfg.exclude)
     if exclude:
         exclusions.update(exclude)
 
+    # Output directory: CLI --output > .codegraphrc output > default
+    if output != Path(".codegraph"):
+        # User explicitly passed --output on CLI
+        resolved_output = output.resolve()
+    elif project_cfg and project_cfg.output != ".codegraph":
+        resolved_output = (workspace / project_cfg.output).resolve()
+    else:
+        resolved_output = (workspace / ".codegraph").resolve()
+
+    # Languages: CLI has no language filter option yet; use .codegraphrc if present
+    all_languages = set(LANGUAGE_EXTENSIONS.keys())
+    if project_cfg and project_cfg.languages:
+        valid = {lang for lang in project_cfg.languages if lang in all_languages}
+        invalid = set(project_cfg.languages) - valid
+        if invalid:
+            console.print(
+                f"[yellow]⚠ .codegraphrc: unknown languages ignored: {', '.join(sorted(invalid))}[/yellow]"
+            )
+        languages = valid if valid else all_languages
+    else:
+        languages = all_languages
+
+    # Workers: CLI --workers > .codegraphrc workers > CPU count
     import os
 
     if not parallel:
         max_workers = 1
     elif workers is not None:
         max_workers = workers
+    elif project_cfg and project_cfg.workers is not None:
+        max_workers = project_cfg.workers
     else:
         max_workers = os.cpu_count() or 4
 
+    # Cache: CLI --cache/--no-cache flag always applies; .codegraphrc only when CLI default
+    # (click default for cache is True, so we trust project_cfg when CLI wasn't explicitly set)
+    effective_cache = (
+        cache if cache is not None else (project_cfg.cache if project_cfg else True)
+    )
+
+    # Include dirs: from .codegraphrc include whitelist (no CLI equivalent)
+    include_dirs = None
+    if project_cfg and project_cfg.include:
+        include_dirs = []
+        for subdir in project_cfg.include:
+            resolved = (workspace / subdir).resolve()
+            if not resolved.exists():
+                console.print(
+                    f"[yellow]⚠ .codegraphrc include '{subdir}' does not exist, skipping.[/yellow]"
+                )
+            else:
+                include_dirs.append(resolved)
+        if not include_dirs:
+            include_dirs = None  # All entries invalid → fall back to full scan
+
+    # Print effective config summary when a project config was loaded
+    if project_cfg is not None:
+        parts = []
+        if include_dirs:
+            parts.append(f"include: {', '.join(p.name for p in include_dirs)}")
+        if project_cfg.exclude:
+            parts.append(f"extra exclude: {', '.join(project_cfg.exclude)}")
+        if project_cfg.languages:
+            parts.append(f"languages: {', '.join(sorted(languages))}")
+        if parts:
+            console.print(f"[dim]   {' | '.join(parts)}[/dim]")
+
     config = CodegraphConfig(
-        workspace_dir=src_dir.resolve(),
-        output_dir=output.resolve(),
+        workspace_dir=workspace,
+        output_dir=resolved_output,
         exclusions=exclusions,
+        languages=languages,
         max_workers=max_workers,
-        use_cache=cache,
+        use_cache=effective_cache,
+        include_dirs=include_dirs,
     )
 
     from codegraph_gen.engine import CodegraphEngine, PipelineStage
@@ -176,7 +263,7 @@ def build(
     "--platform",
     "-p",
     default="codex",
-    type=click.Choice(["codex", "antigravity"]),
+    type=click.Choice(["codex", "antigravity", "crush"]),
     help="The AI agent platform to integrate with.",
 )
 def install(platform: str):
@@ -190,6 +277,8 @@ def install(platform: str):
         skills_dir = Path.home() / ".codex" / "skills" / "codegraph"
     elif platform == "antigravity":
         skills_dir = Path.home() / ".gemini" / "config" / "skills" / "codegraph"
+    elif platform == "crush":
+        skills_dir = Path.home() / ".config" / "crush" / "skills" / "codegraph"
     else:
         skills_dir = Path.home() / ".codex" / "skills" / "codegraph"
 
@@ -212,9 +301,41 @@ Build a codebase knowledge graph using `codegraph` for any folder, cluster symbo
 /codegraph --exclude <pattern>                        # Build and exclude specific folders/patterns
 ```
 
+### Project Configuration File (`.codegraphrc`)
+
+Projects can place a `.codegraphrc` JSON file in their root directory to persist build settings. When present, `codegraph build` automatically loads it — no extra flags needed.
+
+```json
+{
+  "include": ["src", "tests"],
+  "exclude": ["dist", "third_party"],
+  "output": ".codegraph",
+  "languages": ["python", "typescript"],
+  "workers": 4,
+  "cache": true
+}
+```
+
+| Field | Type | Description |
+|---|---|---|
+| `include` | `string[]` | Subdirectory whitelist — only these dirs are scanned. Omit to scan the entire workspace. |
+| `exclude` | `string[]` | Extra directory names to exclude (appended to built-in defaults). |
+| `output` | `string` | Output directory, relative to workspace root. Default: `.codegraph` |
+| `languages` | `string[]` | Language whitelist. Omit to include all supported languages. |
+| `workers` | `int` | Number of parallel worker processes. |
+| `cache` | `bool` | Enable incremental parse cache. Default: `true` |
+
+CLI flags always take priority over `.codegraphrc` values. `--exclude` is cumulative (appends to the config file list).
+
 ## What You Must Do When Invoked
 
-If the user invoked `/codegraph` with no path, do not ask the user for a path. Instead of scanning the entire project root directory `.` (which may include non-essential scripts, docs, or huge subfolders), you MUST prioritize targeting the primary source directory (e.g. `src/`, `lib/`, `app/`) and test directory (e.g. `tests/`, `test/`).
+### Check for a project config file first
+
+Before deciding which directory or flags to use, check if a `.codegraphrc` file exists in the project root:
+- If it exists, read it to understand which directories the project wants scanned (`include`) and excluded (`exclude`). Honor those settings — do NOT override them with your own guesses.
+- If it does NOT exist, follow the fallback rules below.
+
+If the user invoked `/codegraph` with no path and there is NO `.codegraphrc`, do not ask the user for a path. Instead, prioritize targeting the primary source directory (e.g. `src/`, `lib/`, `app/`) and test directory (e.g. `tests/`, `test/`).
 - If specific source or test folders are found, run the build targeting those folders, or build the root `.` but exclude other non-code/non-test directories (e.g., `docs/`, `scripts/`, `examples/`) using the `--exclude` flag to keep the graph focused on code and tests.
 - Otherwise, default to `.` (current directory).
 
@@ -234,7 +355,7 @@ elif [ -f "venv/bin/codegraph" ]; then
     CODEGRAPH_BIN="venv/bin/codegraph"
 else
     if ! command -v codegraph >/dev/null 2>&1; then
-        uv tool install codegraph
+        uv tool install codegraph-gen
     fi
     CODEGRAPH_BIN="codegraph"
 fi
@@ -243,7 +364,7 @@ echo "Using codegraph binary: $CODEGRAPH_BIN"
 
 ### Step 2 - Build the Knowledge Graph
 
-Run the resolved `$CODEGRAPH_BIN` on the specified directory:
+Run the resolved `$CODEGRAPH_BIN` on the specified directory. If a `.codegraphrc` is present in the project root, simply run without extra flags — the config file is picked up automatically:
 ```bash
 $CODEGRAPH_BIN build INPUT_PATH
 # Or with additional exclude arguments if provided by the user
@@ -289,17 +410,66 @@ Finally, reply to the user in English, summarizing:
 
 
 @cli.command()
-def info():
-    """Prints tool info and supported languages."""
+@click.argument(
+    "src_dir",
+    type=click.Path(exists=True, file_okay=False, path_type=Path),
+    default=".",
+)
+@click.option(
+    "--output",
+    "-o",
+    type=click.Path(path_type=Path),
+    default=Path(".codegraph"),
+    help="Directory where the Markdown vault was written.",
+)
+@click.option(
+    "--open/--no-open",
+    "open_browser",
+    default=True,
+    help="Automatically open the interactive HTML page in the browser.",
+)
+def visualize(src_dir: Path, output: Path, open_browser: bool):
+    """Generates an interactive Plotly-based HTML visualization of the graph."""
+    import sys
+
+    console.print(
+        "[bold blue]Generating interactive graph visualization...[/bold blue]"
+    )
+
+    workspace = src_dir.resolve()
+
+    # Resolve output directory using same logic as build
+    project_cfg = load_project_config(workspace)
+    if output != Path(".codegraph"):
+        resolved_output = output.resolve()
+    elif project_cfg and project_cfg.output != ".codegraph":
+        resolved_output = (workspace / project_cfg.output).resolve()
+    else:
+        resolved_output = (workspace / ".codegraph").resolve()
+
     try:
-        from importlib.metadata import version
+        from codegraph_gen.visualizer import generate_visualization
 
-        ver = version("codegraph-gen")
-    except Exception:
-        ver = "1.1.0"
-    console.print(f"[bold]codegraph v{ver}[/bold]")
+        html_path = generate_visualization(
+            workspace, resolved_output, open_browser=open_browser
+        )
+        console.print(
+            f"[bold green]Success![/bold green] Interactive graph exported to: [bold underline]{html_path}[/bold underline]"
+        )
+    except ImportError as e:
+        console.print(f"[bold red]Error: {e}[/bold red]")
+        sys.exit(1)
+    except Exception as e:
+        console.print(f"[bold red]Error generating visualization: {e}[/bold red]")
+        sys.exit(1)
+
+
+@cli.command()
+def info():
+    """Prints tool info and supported languages."""
+    console.print(f"[bold]codegraph v{__version__}[/bold]")
     console.print(
-        "Supported languages: Python, JavaScript, TypeScript, Kotlin, Go, Rust, Swift"
+        "Supported languages: Python, JavaScript, TypeScript, Kotlin, Go, Rust, Swift, C, C++"
     )
 
 

codegraph_gen-1.3.2/src/codegraph_gen/config.py

@@ -0,0 +1,132 @@
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Optional
+from pydantic import BaseModel, Field
+from codegraph_gen.schema import ExtractionResult
+
+logger = logging.getLogger(__name__)
+
+PROJECT_CONFIG_FILE = ".codegraphrc"
+
+# Default exclusions for files and directories we want to ignore
+DEFAULT_EXCLUSIONS = {
+    ".git",
+    ".venv",
+    "venv",
+    "node_modules",
+    "third_party",
+    "dist",
+    "build",
+    ".build",
+    "__pycache__",
+    ".pytest_cache",
+    ".codegraph",
+    ".idea",
+    ".vscode",
+    "target",
+    "out",
+    "bin",
+    "obj",
+    "vendor",
+    "Pods",
+    "Carthage",
+    "DerivedData",
+    "build_output",
+    ".next",
+    ".nuxt",
+    ".cache",
+    "build_mac",
+    "build_ios",
+    "build_ios_sim",
+}
+
+
+# Mapping of supported languages to file extensions
+LANGUAGE_EXTENSIONS = {
+    "python": {".py"},
+    "javascript": {".js", ".mjs", ".cjs"},
+    "typescript": {".ts", ".tsx"},
+    "kotlin": {".kt", ".kts"},
+    "go": {".go"},
+    "rust": {".rs"},
+    "swift": {".swift"},
+    "c": {".c", ".h"},
+    "cpp": {".cpp", ".cc", ".cxx", ".hpp", ".hxx"},
+    "ocaml": {".ml", ".mli"},
+}
+
+ALL_EXTENSIONS = {ext for exts in LANGUAGE_EXTENSIONS.values() for ext in exts}
+
+
+class CacheEntry(BaseModel):
+    mtime: float
+    size: int
+    hash: str
+    result: ExtractionResult
+
+
+class ProjectConfig(BaseModel):
+    """Schema for the .codegraphrc project-level configuration file."""
+
+    include: Optional[list[str]] = None
+    """Subdirectory whitelist (relative to workspace root). None = scan entire workspace."""
+
+    exclude: list[str] = []
+    """Extra directory names/patterns to exclude (appended to DEFAULT_EXCLUSIONS)."""
+
+    output: str = ".codegraph"
+    """Output directory path (relative to workspace root)."""
+
+    languages: Optional[list[str]] = None
+    """Language whitelist. None = all supported languages."""
+
+    workers: Optional[int] = None
+    """Number of parallel worker processes. None = use CPU count."""
+
+    cache: bool = True
+    """Enable incremental parse cache."""
+
+
+def load_project_config(workspace_dir: Path) -> Optional[ProjectConfig]:
+    """
+    Loads .codegraphrc from the workspace root directory.
+    Returns None (silently) if the file does not exist.
+    Returns None (with a warning) if the file is malformed.
+    No upward traversal — the file must be in workspace_dir itself.
+    """
+    config_path = workspace_dir / PROJECT_CONFIG_FILE
+    if not config_path.is_file():
+        return None
+    try:
+        data = json.loads(config_path.read_text(encoding="utf-8"))
+        cfg = ProjectConfig.model_validate(data)
+        logger.info(f"Loaded project config from {config_path}")
+        return cfg
+    except json.JSONDecodeError as e:
+        logger.warning(
+            f"{PROJECT_CONFIG_FILE}: JSON parse error — {e}. Using defaults."
+        )
+    except Exception as e:
+        logger.warning(f"{PROJECT_CONFIG_FILE}: Failed to load — {e}. Using defaults.")
+    return None
+
+
+class CodegraphConfig(BaseModel):
+    """Configuration class for codegraph parsing and exporting."""
+
+    workspace_dir: Path
+    output_dir: Path = Field(default_factory=lambda: Path(".codegraph"))
+    exclusions: set[str] = Field(default_factory=lambda: DEFAULT_EXCLUSIONS)
+    languages: set[str] = Field(default_factory=lambda: set(LANGUAGE_EXTENSIONS.keys()))
+    max_workers: int = Field(default_factory=lambda: os.cpu_count() or 4)
+    use_cache: bool = Field(default=True)
+    include_dirs: Optional[list[Path]] = Field(default=None)
+    """Absolute paths of subdirectories to scan. None = scan entire workspace_dir."""
+
+    @property
+    def absolute_output_dir(self) -> Path:
+        if self.output_dir.is_absolute():
+            return self.output_dir
+        return self.workspace_dir / self.output_dir

{codegraph_gen-1.1.0 → codegraph_gen-1.3.2}/src/codegraph_gen/detect.py

@@ -9,11 +9,20 @@ def discover_files(
     workspace_dir: Path,
     languages: set[str],
     exclusions: set[str],
+    include_dirs: list[Path] | None = None,
 ) -> list[tuple[Path, str]]:
     """
     Recursively discovers source files in the workspace directory.
     Filters by allowed languages and ignores files/directories in exclusions.
 
+    Args:
+        workspace_dir: Root of the workspace (used to compute relative paths / node IDs).
+        languages: Set of language names to include.
+        exclusions: Directory names/patterns to exclude.
+        include_dirs: Optional whitelist of absolute directories to scan.
+                      When provided, only these directories are scanned.
+                      When None, the entire workspace_dir is scanned.
+
     Returns:
         List of tuples: (absolute_file_path, language_name)
     """
@@ -59,5 +68,20 @@ def discover_files(
         except Exception as e:
             logger.error(f"Error scanning {directory}: {e}")
 
-    scan_dir(workspace)
+    # Determine which root directories to scan
+    if include_dirs:
+        for root in include_dirs:
+            root = root.resolve()
+            if not root.exists():
+                logger.warning(f"include_dirs entry does not exist, skipping: {root}")
+                continue
+            if not root.is_dir():
+                logger.warning(
+                    f"include_dirs entry is not a directory, skipping: {root}"
+                )
+                continue
+            scan_dir(root)
+    else:
+        scan_dir(workspace)
+
     return found_files

{codegraph_gen-1.1.0 → codegraph_gen-1.3.2}/src/codegraph_gen/engine.py

@@ -100,7 +100,10 @@ class CodegraphEngine:
         if progress_callback:
             progress_callback(PipelineStage.DISCOVERING, None, 0, 0)
         files = discover_files(
-            config.workspace_dir, config.languages, config.exclusions
+            config.workspace_dir,
+            config.languages,
+            config.exclusions,
+            config.include_dirs,
         )
         if not files:
             logger.warning("No supported files found.")