context-gen-cli 1.0.0__py3-none-any.whl

context_gen/__init__.py

@@ -0,0 +1,3 @@
+"""context-gen-cli: Graph-based project context generator for LLM agents."""
+
+__version__ = "1.0.0"

context_gen/cli.py

@@ -0,0 +1,124 @@
+"""
+context_gen.cli: Typer-based CLI entry point for context-gen-cli.
+"""
+
+import json
+from enum import Enum
+from pathlib import Path
+from typing import Optional
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from context_gen.scanner import scan_project
+from context_gen.extractor import extract_metadata
+from context_gen.graph import build_dependency_graph
+from context_gen.generator import generate_agent_md, generate_agent_json
+
+app = typer.Typer(
+    name="context-gen",
+    help="⚡ Generate graph-based project context (agent.md / agent.json) for LLMs.",
+    add_completion=False,
+    no_args_is_help=False
+)
+console = Console()
+
+
+class OutputFormat(str, Enum):
+    """Supported output formats."""
+    MD = "md"
+    JSON = "json"
+
+
+@app.command()
+def main(
+    path: Path = typer.Argument(
+        default=Path("."),
+        help="Target project directory to analyze.",
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        readable=True,
+        resolve_path=True,
+    ),
+    format: OutputFormat = typer.Option(
+        OutputFormat.MD,
+        "--format",
+        "-f",
+        help="Output format: 'md' (Markdown) or 'json' (MCP JSON).",
+        case_sensitive=False,
+    ),
+    output: Optional[Path] = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Custom output file path (e.g. context/agent.md or custom.json).",
+    ),
+    max_depth: int = typer.Option(
+        3,
+        "--max-depth",
+        "-d",
+        help="Maximum directory depth to scan.",
+        min=1,
+        max=10,
+    ),
+) -> None:
+    """
+    Scan a project, build an AST-powered dependency graph, and generate LLM context.
+    """
+    target_dir = path.resolve()
+
+    console.print(
+        Panel.fit(
+            f"[bold cyan]⚡ context-gen-cli (Python Edition)[/bold cyan]\n"
+            f"[dim]Analyzing target:[/dim] [green]{target_dir}[/green]\n"
+            f"[dim]Format:[/dim] [yellow]{format.value.upper()}[/yellow]",
+            border_style="cyan"
+        )
+    )
+
+    with console.status("[bold green]Scanning directory and parsing AST graph...[/bold green]"):
+        scan_result = scan_project(str(target_dir), max_depth=max_depth)
+        files = scan_result["files"]
+        tree = scan_result["tree"]
+
+        metadata = extract_metadata(str(target_dir), files)
+        graph = build_dependency_graph(files, str(target_dir))
+
+    # Determine default destination if not provided
+    if output:
+        out_file = output.resolve()
+    else:
+        context_dir = target_dir / "context"
+        context_dir.mkdir(parents=True, exist_ok=True)
+        filename = f"agent.{format.value}"
+        out_file = context_dir / filename
+
+    out_file.parent.mkdir(parents=True, exist_ok=True)
+
+    if format == OutputFormat.JSON:
+        json_data = generate_agent_json(metadata, graph, tree, str(target_dir))
+        out_file.write_text(json.dumps(json_data, indent=2), encoding="utf-8")
+    else:
+        md_text = generate_agent_md(metadata, graph, tree)
+        out_file.write_text(md_text, encoding="utf-8")
+
+    # Display completion summary
+    table = Table(show_header=False, box=None)
+    table.add_row("[bold]Scanned Files:[/bold]", f"[cyan]{len(files)}[/cyan]")
+    table.add_row("[bold]AST Graph Edges:[/bold]", f"[cyan]{len(graph['edges'])}[/cyan]")
+    table.add_row("[bold]Tech Stack:[/bold]", f"[green]{', '.join(metadata['techStack'])}[/green]")
+    table.add_row("[bold]Output File:[/bold]", f"[yellow]{out_file}[/yellow]")
+
+    console.print(
+        Panel(
+            table,
+            title="[bold green]✅ Context Generated Successfully[/bold green]",
+            border_style="green"
+        )
+    )
+
+
+if __name__ == "__main__":
+    app()

context_gen/extractor.py

@@ -0,0 +1,181 @@
+"""
+context_gen.extractor: Extracts project metadata, tech stack, dependencies, and file descriptions.
+"""
+
+import ast
+import re
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+FRAMEWORK_PATTERNS = {
+    "FastAPI": ["fastapi"],
+    "Django": ["django"],
+    "Flask": ["flask"],
+    "Typer": ["typer"],
+    "Click": ["click"],
+    "PyTorch": ["torch", "pytorch"],
+    "TensorFlow": ["tensorflow"],
+    "Pandas": ["pandas"],
+    "NumPy": ["numpy"],
+    "Pydantic": ["pydantic"],
+    "SQLAlchemy": ["sqlalchemy"],
+    "Celery": ["celery"],
+    "Pytest": ["pytest"],
+    "Rich": ["rich"]
+}
+
+
+def _strip_markdown(text: str) -> str:
+    """Removes markdown syntax like headers, asterisks, links, and bold tags."""
+    clean = re.sub(r"#+\s*", "", text)
+    clean = re.sub(r"\*\*([^*]+)\*\*", r"\1", clean)
+    clean = re.sub(r"\*([^*]+)\*", r"\1", clean)
+    clean = re.sub(r"`([^`]+)`", r"\1", clean)
+    clean = re.sub(r"\[([^\]]+)\]\([^)]+\)", r"\1", clean)
+    clean = re.sub(r"\n+", " ", clean)
+    return clean.strip()
+
+
+def extract_overview(root: Path, max_chars: int = 350) -> str:
+    """Extracts project overview summary from README.md or fallback."""
+    for readme_name in ["README.md", "readme.md", "README.rst", "README.txt", "README"]:
+        readme_path = root / readme_name
+        if readme_path.is_file():
+            try:
+                content = readme_path.read_text(encoding="utf-8", errors="ignore").strip()
+                if content:
+                    lines = [l.strip() for l in content.split("\n") if l.strip() and not l.startswith("#")]
+                    summary = " ".join(lines[:4])
+                    clean_summary = _strip_markdown(summary)
+                    if len(clean_summary) > max_chars:
+                        return clean_summary[:max_chars].rstrip() + "..."
+                    return clean_summary or f"Project overview based on {readme_name}."
+            except Exception:
+                pass
+
+    return f"Project workspace rooted at {root.name}."
+
+
+def extract_dependencies(root: Path) -> Dict[str, Dict[str, str]]:
+    """Extracts dependencies from requirements.txt, pyproject.toml, or setup.py."""
+    prod_deps: Dict[str, str] = {}
+    dev_deps: Dict[str, str] = {}
+
+    req_path = root / "requirements.txt"
+    if req_path.is_file():
+        try:
+            for line in req_path.read_text(encoding="utf-8", errors="ignore").splitlines():
+                line = line.strip()
+                if line and not line.startswith("#"):
+                    match = re.match(r"^([a-zA-Z0-9_\-\.]+)([=<>!~]+.*)?$", line)
+                    if match:
+                        prod_deps[match.group(1)] = match.group(2) or "latest"
+        except Exception:
+            pass
+
+    pyproject_path = root / "pyproject.toml"
+    if pyproject_path.is_file():
+        try:
+            content = pyproject_path.read_text(encoding="utf-8", errors="ignore")
+            # Simple regex parser for pyproject dependencies list
+            dep_matches = re.findall(r'"([a-zA-Z0-9_\-\.]+)([=<>!~]+[^"]*)?"', content)
+            for pkg, ver in dep_matches:
+                if pkg not in {"setuptools", "wheel", "pytest", "build", "twine"}:
+                    prod_deps[pkg] = ver or "latest"
+                else:
+                    dev_deps[pkg] = ver or "latest"
+        except Exception:
+            pass
+
+    return {
+        "production": prod_deps,
+        "development": dev_deps
+    }
+
+
+def extract_tech_stack(root: Path, files: List[str], deps: Dict[str, Dict[str, str]]) -> List[str]:
+    """Detects technologies and frameworks present in the codebase."""
+    stack: List[str] = []
+
+    has_py = any(f.endswith(".py") for f in files)
+    has_js = any(f.endswith((".js", ".ts", ".jsx", ".tsx")) for f in files)
+    has_html = any(f.endswith((".html", ".css")) for f in files)
+
+    if has_py or (root / "pyproject.toml").is_file() or (root / "requirements.txt").is_file():
+        stack.append("Python")
+    if has_js or (root / "package.json").is_file():
+        stack.append("JavaScript/Node.js")
+    if has_html:
+        stack.append("HTML/CSS")
+
+    all_dep_names = {k.lower() for k in deps.get("production", {})}
+
+    for framework, keywords in FRAMEWORK_PATTERNS.items():
+        if any(kw in all_dep_names for kw in keywords):
+            if framework not in stack:
+                stack.append(framework)
+
+    return stack or ["Python"]
+
+
+def extract_file_description(file_path: Path) -> str:
+    """Infers a file's purpose from module docstring or top comments."""
+    if file_path.suffix == ".py":
+        try:
+            source = file_path.read_text(encoding="utf-8", errors="ignore")
+            tree = ast.parse(source, filename=str(file_path))
+            docstring = ast.get_docstring(tree)
+            if docstring:
+                return _strip_markdown(docstring.strip().split("\n")[0])
+        except Exception:
+            pass
+
+    try:
+        lines = file_path.read_text(encoding="utf-8", errors="ignore").splitlines()[:15]
+        for line in lines:
+            line = line.strip()
+            if line.startswith(("#", "//", "/*")):
+                cleaned = _strip_markdown(line.lstrip("#/*").strip())
+                if cleaned and len(cleaned) > 5:
+                    return cleaned
+    except Exception:
+        pass
+
+    return f"Source file: {file_path.name}"
+
+
+def extract_metadata(root_path: str, files: List[str]) -> Dict[str, Any]:
+    """
+    Extracts high-level metadata, tech stack, descriptions, and dependencies.
+
+    Args:
+        root_path (str): Project root directory.
+        files (List[str]): Scanned project files.
+
+    Returns:
+        Dict[str, Any]: Extracted metadata.
+    """
+    root = Path(root_path).resolve()
+    overview = extract_overview(root)
+    dependencies = extract_dependencies(root)
+    tech_stack = extract_tech_stack(root, files, dependencies)
+
+    key_files: List[Dict[str, str]] = []
+    # Identify top priority files
+    top_candidates = [
+        f for f in files if f.endswith((".py", ".js", ".ts", ".json", ".toml", ".md"))
+        and not f.startswith("test")
+    ][:12]
+
+    for rel_file in top_candidates:
+        full_path = root / rel_file
+        desc = extract_file_description(full_path)
+        key_files.append({"path": rel_file, "description": desc})
+
+    return {
+        "overview": overview,
+        "techStack": tech_stack,
+        "dependencies": dependencies,
+        "keyFiles": key_files,
+        "projectPath": str(root)
+    }

context_gen/generator.py

@@ -0,0 +1,153 @@
+"""
+context_gen.generator: Generates structured agent.md and MCP-compatible agent.json.
+"""
+
+from datetime import datetime, timezone
+from typing import Any, Dict, List
+
+
+def generate_agent_json(
+    metadata: Dict[str, Any],
+    graph: Dict[str, Any],
+    tree: str = "",
+    project_path: str = ""
+) -> Dict[str, Any]:
+    """
+    Generates structured, MCP-compatible JSON representation of project context.
+
+    Args:
+        metadata (Dict[str, Any]): Project metadata from extractor.
+        graph (Dict[str, Any]): AST dependency graph.
+        tree (str): Visual directory tree.
+        project_path (str): Absolute root project path.
+
+    Returns:
+        Dict[str, Any]: Exact 12-key MCP context dictionary.
+    """
+    path_val = project_path or metadata.get("projectPath", "")
+    now_iso = datetime.now(timezone.utc).isoformat()
+
+    # Filter entry points: only retain clean file paths
+    raw_entries: List[str] = graph.get("entryPoints", [])
+    entry_points = [
+        e for e in raw_entries
+        if not any(token in e for token in ["node ", "npm ", "python ", " "])
+    ]
+
+    return {
+        "version": "1.0.0",
+        "generatedAt": now_iso,
+        "projectPath": path_val,
+        "overview": metadata.get("overview", ""),
+        "techStack": metadata.get("techStack", []),
+        "directoryStructure": tree or "",
+        "keyFiles": metadata.get("keyFiles", []),
+        "dependencies": metadata.get("dependencies", {"production": {}, "development": {}}),
+        "dependencyGraph": {
+            "nodes": graph.get("nodes", []),
+            "edges": graph.get("edges", [])
+        },
+        "entryPoints": entry_points,
+        "utilities": graph.get("utilities", []),
+        "scripts": metadata.get("scripts", {})
+    }
+
+
+def generate_agent_md(
+    metadata: Dict[str, Any],
+    graph: Dict[str, Any],
+    tree: str = ""
+) -> str:
+    """
+    Generates human-readable Markdown context document (agent.md) for LLMs.
+
+    Args:
+        metadata (Dict[str, Any]): Project metadata from extractor.
+        graph (Dict[str, Any]): AST dependency graph.
+        tree (str): Visual directory tree.
+
+    Returns:
+        str: Formatted Markdown string.
+    """
+    lines: List[str] = [
+        "# Project Context & Architecture Guide",
+        "",
+        "> Auto-generated by `context-gen-cli` (Python Edition) for AI agent reasoning.",
+        "",
+        "## Overview",
+        metadata.get("overview", "No overview provided."),
+        "",
+        "## Tech Stack",
+    ]
+
+    stack = metadata.get("techStack", [])
+    if stack:
+        lines.extend([f"- **{tech}**" for tech in stack])
+    else:
+        lines.append("- Python")
+
+    lines.extend([
+        "",
+        "## Directory Structure",
+        "```",
+        tree.strip() if tree else "No directory tree available.",
+        "```",
+        "",
+        "## Key Files & Entry Points",
+    ])
+
+    key_files = metadata.get("keyFiles", [])
+    if key_files:
+        for kf in key_files:
+            lines.append(f"- **`{kf['path']}`**: {kf['description']}")
+    else:
+        lines.append("- No key files detected.")
+
+    lines.extend([
+        "",
+        "## Module Dependency Graph",
+        "",
+        "### Entry Points",
+    ])
+
+    entry_points = graph.get("entryPoints", [])
+    if entry_points:
+        for ep in entry_points:
+            lines.append(f"- `{ep}`")
+    else:
+        lines.append("- None detected.")
+
+    lines.extend([
+        "",
+        "### Core Modules & Utilities",
+    ])
+
+    utilities = graph.get("utilities", [])
+    if utilities:
+        for u in utilities:
+            lines.append(f"- `{u}`")
+    else:
+        lines.append("- None detected.")
+
+    lines.extend([
+        "",
+        "### Import Relationships (Edges)",
+        "```mermaid",
+        "graph TD;",
+    ])
+
+    edges = graph.get("edges", [])
+    if edges:
+        for edge in edges:
+            source = edge["from"].replace(".", "_").replace("/", "_").replace("-", "_")
+            target = edge["to"].replace(".", "_").replace("/", "_").replace("-", "_")
+            lines.append(f"  {source}[\"{edge['from']}\"] --> {target}[\"{edge['to']}\"]")
+    else:
+        lines.append("  %% No internal dependencies detected")
+
+    lines.extend([
+        "```",
+        ""
+    ])
+
+    return "\n".join(lines)

context_gen/graph.py

@@ -0,0 +1,196 @@
+"""
+context_gen.graph: AST-based Python dependency graph builder.
+"""
+
+import ast
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Set
+
+logger = logging.getLogger("context_gen.graph")
+
+ENTRY_CANDIDATES = {"main.py", "app.py", "cli.py", "index.py", "server.py", "manage.py", "run.py"}
+UTIL_KEYWORDS = {"util", "utils", "helper", "helpers", "common", "tool", "tools", "config", "constant", "constants"}
+
+
+def _resolve_module_to_file(
+    module_name: str,
+    from_file: str,
+    level: int,
+    available_files: Set[str],
+    root_path: Path
+) -> List[str]:
+    """
+    Resolves an AST import target to a concrete file in available_files.
+
+    Args:
+        module_name (str): Module path (e.g. 'utils', 'models.user').
+        from_file (str): Relative path of the importing file.
+        level (int): Relative import level (0 for absolute, 1 for ., 2 for .., etc.).
+        available_files (Set[str]): Set of all scanned project files.
+        root_path (Path): Absolute project root path.
+
+    Returns:
+        List[str]: Resolved matching file paths in the project.
+    """
+    resolved: List[str] = []
+    current_file_path = Path(from_file)
+    current_dir = current_file_path.parent
+
+    # Determine base directory for resolution
+    if level > 0:
+        # Relative import
+        base_dir = current_dir
+        for _ in range(level - 1):
+            base_dir = base_dir.parent
+    else:
+        # Absolute import in project root or relative to current_dir
+        base_dir = Path(".")
+
+    module_parts = module_name.split(".") if module_name else []
+    module_rel_path = "/".join(module_parts)
+
+    candidates: List[str] = []
+
+    if module_rel_path:
+        # 1. module as a .py file from base_dir: base_dir/module.py
+        candidates.append((base_dir / f"{module_rel_path}.py").as_posix())
+        # 2. module as a package: base_dir/module/__init__.py
+        candidates.append((base_dir / module_rel_path / "__init__.py").as_posix())
+
+        # 3. If level == 0, also try relative to current_dir
+        if level == 0 and current_dir != Path("."):
+            candidates.append((current_dir / f"{module_rel_path}.py").as_posix())
+            candidates.append((current_dir / module_rel_path / "__init__.py").as_posix())
+
+    # Normalize candidate paths (strip leading './' etc.)
+    for cand in candidates:
+        norm = Path(cand).as_posix()
+        if norm.startswith("./"):
+            norm = norm[2:]
+        if norm in available_files:
+            resolved.append(norm)
+
+    return resolved
+
+
+def build_dependency_graph(files: List[str], root_path: str) -> Dict[str, Any]:
+    """
+    Builds a module dependency graph from project files using Python's AST parser.
+
+    Args:
+        files (List[str]): List of relative file paths in the project.
+        root_path (str): Root project directory path.
+
+    Returns:
+        Dict[str, Any]: Graph structure matching MCP context schema.
+    """
+    root = Path(root_path).resolve()
+    available_files: Set[str] = set(files)
+    py_files = [f for f in files if f.endswith(".py")]
+
+    imports_map: Dict[str, Set[str]] = {f: set() for f in py_files}
+    imported_by_map: Dict[str, Set[str]] = {f: set() for f in py_files}
+    edges: List[Dict[str, str]] = []
+    seen_edges: Set[tuple[str, str]] = set()
+
+    for py_file in py_files:
+        full_path = root / py_file
+        try:
+            with open(full_path, "r", encoding="utf-8", errors="ignore") as f:
+                source = f.read()
+            tree = ast.parse(source, filename=py_file)
+        except (SyntaxError, UnicodeDecodeError) as err:
+            logger.warning("Skipping syntax-invalid Python file %s: %s", py_file, err)
+            continue
+        except Exception as err:
+            logger.warning("Error reading %s: %s", py_file, err)
+            continue
+
+        for node in ast.walk(tree):
+            # Handle standard import statements: import a, b as c
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    targets = _resolve_module_to_file(
+                        alias.name,
+                        py_file,
+                        level=0,
+                        available_files=available_files,
+                        root_path=root
+                    )
+                    for target in targets:
+                        if target != py_file:
+                            imports_map[py_file].add(target)
+                            imported_by_map[target].add(py_file)
+                            edge_key = (py_file, target)
+                            if edge_key not in seen_edges:
+                                seen_edges.add(edge_key)
+                                edges.append({"from": py_file, "to": target, "type": "import"})
+
+            # Handle from ... import statements: from .models import User, or from utils import helper
+            elif isinstance(node, ast.ImportFrom):
+                module_name = node.module or ""
+                targets = _resolve_module_to_file(
+                    module_name,
+                    py_file,
+                    level=node.level,
+                    available_files=available_files,
+                    root_path=root
+                )
+
+                # If from package import submodule (e.g. from models import user)
+                if not targets and node.names:
+                    for alias in node.names:
+                        sub_module = f"{module_name}.{alias.name}" if module_name else alias.name
+                        sub_targets = _resolve_module_to_file(
+                            sub_module,
+                            py_file,
+                            level=node.level,
+                            available_files=available_files,
+                            root_path=root
+                        )
+                        targets.extend(sub_targets)
+
+                for target in targets:
+                    if target != py_file:
+                        imports_map[py_file].add(target)
+                        imported_by_map[target].add(py_file)
+                        edge_key = (py_file, target)
+                        if edge_key not in seen_edges:
+                            seen_edges.add(edge_key)
+                            edges.append({"from": py_file, "to": target, "type": "import"})
+
+    entry_points: List[str] = []
+    utilities: List[str] = []
+    nodes: List[Dict[str, Any]] = []
+
+    for f in sorted(py_files):
+        name_lower = Path(f).name.lower()
+        stem_lower = Path(f).stem.lower()
+
+        # Classify node type
+        if name_lower in ENTRY_CANDIDATES or (len(imported_by_map[f]) == 0 and len(imports_map[f]) > 0):
+            node_type = "entry"
+            entry_points.append(f)
+        elif any(k in stem_lower for k in UTIL_KEYWORDS):
+            node_type = "util"
+            utilities.append(f)
+        else:
+            node_type = "module"
+
+        nodes.append({
+            "file": f,
+            "type": node_type,
+            "imports": sorted(list(imports_map[f])),
+            "importedBy": sorted(list(imported_by_map[f]))
+        })
+
+    # Sort edges deterministically
+    edges.sort(key=lambda e: (e["from"], e["to"]))
+
+    return {
+        "nodes": nodes,
+        "edges": edges,
+        "entryPoints": sorted(entry_points),
+        "utilities": sorted(utilities)
+    }

context_gen/scanner.py

@@ -0,0 +1,149 @@
+"""
+context_gen.scanner: Directory walker and .gitignore filtering.
+"""
+
+from pathlib import Path
+from typing import Any, List
+import pathspec
+
+DEFAULT_IGNORES: List[str] = [
+    "__pycache__",
+    "__pycache__/**",
+    "*.pyc",
+    ".git",
+    ".git/**",
+    ".venv",
+    ".venv/**",
+    "venv",
+    "venv/**",
+    "env",
+    "env/**",
+    "node_modules",
+    "node_modules/**",
+    ".DS_Store",
+    "context",
+    "context/**",
+    ".env*",
+    "secrets",
+    "secrets/**",
+    "*.pem",
+    "*.key",
+    "dist",
+    "dist/**",
+    "build",
+    "build/**",
+    "*.egg-info",
+    "*.egg-info/**"
+]
+
+
+def load_gitignore(root: Path) -> pathspec.PathSpec:
+    """
+    Loads and compiles .gitignore rules along with default ignores.
+
+    Args:
+        root (Path): The project root directory.
+
+    Returns:
+        pathspec.PathSpec: Compiled path matcher.
+    """
+    patterns: List[str] = list(DEFAULT_IGNORES)
+
+    gitignore_path = root / ".gitignore"
+    if gitignore_path.is_file():
+        try:
+            with open(gitignore_path, "r", encoding="utf-8", errors="ignore") as f:
+                for line in f:
+                    stripped = line.strip()
+                    if stripped and not stripped.startswith("#"):
+                        patterns.append(stripped)
+        except Exception:
+            pass
+
+    return pathspec.PathSpec.from_lines("gitwildmatch", patterns)
+
+
+def generate_tree(root: Path, spec: pathspec.PathSpec, max_depth: int = 3) -> str:
+    """
+    Builds a visual ASCII directory tree string.
+
+    Args:
+        root (Path): Project root directory.
+        spec (pathspec.PathSpec): Ignore pattern matcher.
+        max_depth (int): Max level of recursion (1-indexed).
+
+    Returns:
+        str: Formatted tree string.
+    """
+    lines: List[str] = [f"{root.name}/"]
+
+    def _build_tree(current_dir: Path, prefix: str = "", depth: int = 1) -> None:
+        if depth > max_depth:
+            return
+
+        try:
+            entries = sorted(list(current_dir.iterdir()), key=lambda e: (not e.is_dir(), e.name.lower()))
+        except PermissionError:
+            return
+
+        # Filter out ignored entries
+        visible_entries: List[Path] = []
+        for entry in entries:
+            try:
+                rel = entry.relative_to(root).as_posix()
+            except ValueError:
+                continue
+
+            rel_test = f"{rel}/" if entry.is_dir() else rel
+            if not spec.match_file(rel_test):
+                visible_entries.append(entry)
+
+        for i, entry in enumerate(visible_entries):
+            is_last = (i == len(visible_entries) - 1)
+            connector = "└── " if is_last else "├── "
+            display_name = f"{entry.name}/" if entry.is_dir() else entry.name
+            lines.append(f"{prefix}{connector}{display_name}")
+
+            if entry.is_dir():
+                sub_prefix = prefix + ("    " if is_last else "│   ")
+                _build_tree(entry, sub_prefix, depth + 1)
+
+    _build_tree(root, "", 1)
+    return "\n".join(lines)
+
+
+def scan_project(root_path: str, max_depth: int = 3) -> dict[str, Any]:
+    """
+    Scans a directory, filtering against .gitignore, and constructs a file list and tree.
+
+    Args:
+        root_path (str): Path to the target project directory.
+        max_depth (int): Depth limit for directory tree rendering.
+
+    Returns:
+        dict[str, Any]: Dictionary containing 'files' (list of relative paths) and 'tree' (string).
+    """
+    root = Path(root_path).resolve()
+    if not root.exists() or not root.is_dir():
+        raise ValueError(f"Target path does not exist or is not a directory: {root_path}")
+
+    spec = load_gitignore(root)
+    files: List[str] = []
+
+    for item in root.rglob("*"):
+        if item.is_file():
+            try:
+                rel = item.relative_to(root).as_posix()
+            except ValueError:
+                continue
+
+            if not spec.match_file(rel):
+                files.append(rel)
+
+    files = sorted(files)
+    tree_str = generate_tree(root, spec, max_depth)
+
+    return {
+        "files": files,
+        "tree": tree_str
+    }

context_gen_cli-1.0.0.dist-info/METADATA

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: context-gen-cli
+Version: 1.0.0
+Summary: A modern CLI tool that scans any project, builds an AST-based dependency graph, and generates structured LLM context (agent.md / agent.json).
+Author: yakkshit
+License-Expression: MIT
+Keywords: llm,context,agent,cli,code-analysis,ast,graph,mcp
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: typer[all]>=0.12.0
+Requires-Dist: rich>=13.7.0
+Requires-Dist: pathspec>=0.12.1
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: build>=1.1.0; extra == "dev"
+Requires-Dist: twine>=5.0.0; extra == "dev"
+
+# context-gen-cli (Python Edition)
+
+> ⚡ Fast, AST-powered CLI tool that scans any project, extracts architecture models, and generates structured LLM context (`agent.md` & `agent.json`).
+
+## Features
+- **100% Accurate Python Dependency Graphs**: Built using Python's native `ast` (Abstract Syntax Tree) module.
+- **Gitignore Respect**: Uses `pathspec` to ignore unwanted directories and secrets.
+- **Dual Output**: Generates both human-readable Markdown (`agent.md`) and MCP-compatible structured JSON (`agent.json`).
+- **Modern CLI**: Powered by `typer` and `rich`.
+
+## Installation
+```bash
+pip install context-gen-cli
+```
+
+## Quick Start
+```bash
+# Generate agent.md in context/ directory
+context-gen .
+
+# Generate agent.json
+context-gen . --format json
+
+# Custom output path
+context-gen ./my-project -o custom/path/context.md
+```

context_gen_cli-1.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+context_gen/__init__.py,sha256=-aT4LUzkmwYQ-vN2C_e6B6Tss3oIymGDgoKJsoD9pvY,100
+context_gen/cli.py,sha256=hIXCo4IvUQUEmGOIVyV1PMP1yhPynwpQfB7RqEmVDZ0,3766
+context_gen/extractor.py,sha256=HP_I9-PjDqtosXbJ1CrF7-N25WWcGNK644mkI-o51DY,6487
+context_gen/generator.py,sha256=RjdHxlfvU3MiTZ49KrxXYz372R06322sSrozXA2J4Mc,4289
+context_gen/graph.py,sha256=JyjfP8xID4bKs3eNAmauaBnN9Xgba1ZVxbYyMwHDCac,7356
+context_gen/scanner.py,sha256=sC5hqsVZ7svMyYDQelYvqhdUCb07fPekW4XgnBi4tM0,4110
+context_gen_cli-1.0.0.dist-info/METADATA,sha256=SXYh7uzTTehl67Pkm5p6KkgFflBEr-1dqv82YrlA1cg,1963
+context_gen_cli-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+context_gen_cli-1.0.0.dist-info/entry_points.txt,sha256=WLhR993vsDawV47KG6dBlpwfzD05pMr6St1ewlj9z6c,52
+context_gen_cli-1.0.0.dist-info/top_level.txt,sha256=-VtsrQ0fM4J14HSdaF5LhT25F10DJaALb0vK8haFjto,12
+context_gen_cli-1.0.0.dist-info/RECORD,,

context_gen_cli-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

context_gen_cli-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+context-gen = context_gen.cli:app

context_gen_cli-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+context_gen