Analyzers API Reference¶

Auto-generated from source code docstrings.

Context Compiler¶

analyzers.context_compiler ¶

Context Compiler - One-shot project understanding for AI agents.

Runs all analyzers and compresses their output into a single structured document optimized for AI consumption. This is the "drop an AI into a project and it immediately understands everything" tool.

The output is designed to fit within a reasonable context window while giving an AI agent enough information to: - Understand what the project does - Know where everything is - Understand the dependency structure - Know which components are extractable - Start working immediately

Usage

python context_compiler.py python context_compiler.py --output context.json python context_compiler.py --output context.md --markdown python context_compiler.py --budget 5000 # max ~5000 lines

Functions¶

compile_context ¶

compile_context(project_path: str, budget: int = 8000, skip_graph: bool = False) -> dict

Compile full project context.

Source code in Tools/analyzers/context_compiler.py

def compile_context(
    project_path: str,
    budget: int = 8000,
    skip_graph: bool = False,
) -> dict:
    """Compile full project context."""

    project = Path(project_path).resolve()
    print(f"\nCompiling context for: {project.name}", flush=True)
    print(f"{'='*50}", flush=True)

    context = {
        "meta": {
            "project": project.name,
            "root": str(project),
            "compiled_at": datetime.now().isoformat(),
            "compiler_version": "1.0.0",
        },
    }

    # 1. Structure overview
    print("  [1/6] Analyzing structure...", flush=True)
    try:
        structure = analyze_structure(str(project))
        context["structure"] = {
            "total_files": structure["total_files"],
            "total_dirs": structure["total_dirs"],
            "total_size": structure["total_size_bytes"],
            "top_level_dirs": structure["top_level_dirs"],
            "file_types": {
                ext: data["count"]
                for ext, data in sorted(
                    structure["file_types"].items(),
                    key=lambda x: x[1]["count"],
                    reverse=True
                )[:15]
            },
            "largest_files": [
                {"path": f["path"], "size": f["size"]}
                for f in structure["largest_files"][:10]
            ],
        }
    except Exception as e:
        context["structure"] = {"error": str(e)}

    # 2. Platform detection
    print("  [2/6] Detecting platforms...", flush=True)
    try:
        platforms = detect_all_platforms(project)
        context["platforms"] = {
            "detected": [
                {
                    "name": p.platform,
                    "version": p.version,
                    "confidence": p.confidence,
                }
                for p in platforms.platforms
            ],
            "is_multi_platform": platforms.is_multi_platform,
        }
    except Exception as e:
        context["platforms"] = {"error": str(e)}

    # 3. Frameworks
    print("  [3/6] Detecting frameworks...", flush=True)
    context["frameworks"] = detect_framework(project)

    # 4. Code map (condensed)
    print("  [4/6] Building code map...", flush=True)
    try:
        codemap = generate_codemap(str(project), max_files=1500)
        context["codemap"] = {
            "languages": codemap["summary"]["languages"],
            "entry_points": codemap["entry_points"],
            # Only include files that have structure (classes/functions)
            "key_files": [],
        }

        for f in codemap["files"]:
            has_structure = any(
                f.get(k) for k in
                ["classes", "functions", "structs", "traits",
                 "interfaces", "enums", "impls", "exports"]
            )
            if has_structure and f.get("role") == "source":
                # Condense: just names, not full details
                entry = {"path": f["path"], "lines": f.get("line_count", 0)}

                for k in ["classes", "structs"]:
                    items = f.get(k, [])
                    if items:
                        entry[k] = [
                            {
                                "name": c["name"],
                                "methods": len(c.get("methods", [])),
                                "bases": c.get("bases", []),
                            }
                            for c in items
                        ]

                funcs = f.get("functions", [])
                if funcs:
                    entry["functions"] = [fn["name"] for fn in funcs]

                for k in ["traits", "interfaces", "enums"]:
                    items = f.get(k, [])
                    if items:
                        entry[k] = [x["name"] for x in items]

                exports = f.get("exports", [])
                if exports:
                    entry["exports"] = [e["name"] for e in exports]

                context["codemap"]["key_files"].append(entry)

    except Exception as e:
        context["codemap"] = {"error": str(e)}

    # 5. Interfaces (condensed)
    print("  [5/6] Extracting interfaces...", flush=True)
    try:
        interfaces = extract_interfaces(str(project))
        # Only include modules with meaningful public APIs
        context["interfaces"] = {
            "module_count": interfaces["summary"]["modules_with_interfaces"],
            "modules": {},
        }

        for mod_path, iface in interfaces["modules"].items():
            condensed = {}

            for cls in iface.get("classes", []):
                public_methods = [
                    m["name"] for m in cls.get("methods", [])
                    if not m["name"].startswith('_') or m["name"] == '__init__'
                ]
                if public_methods:
                    condensed.setdefault("classes", []).append({
                        "name": cls["name"],
                        "bases": cls.get("bases", []),
                        "methods": public_methods,
                    })

            func_names = [f["name"] for f in iface.get("functions", [])]
            if func_names:
                condensed["functions"] = func_names

            type_names = [t["name"] for t in iface.get("types", [])]
            if type_names:
                condensed["types"] = type_names

            export_names = [
                e["name"] if isinstance(e, dict) else e
                for e in iface.get("exports", [])
            ]
            if export_names:
                condensed["exports"] = export_names

            if condensed:
                context["interfaces"]["modules"][mod_path] = condensed

    except Exception as e:
        context["interfaces"] = {"error": str(e)}

    # 6. Boundaries (if not skipped)
    if not skip_graph:
        print("  [6/6] Detecting boundaries...", flush=True)
        try:
            boundaries = detect_boundaries(str(project), min_cluster=2)
            context["boundaries"] = {
                "clusters": [
                    {
                        "name": c.get("common_prefix") or f"cluster-{c['id']}",
                        "files": c["file_count"],
                        "cohesion": c["cohesion"],
                        "external_deps": c["external_dep_count"],
                        "extraction_risk": (
                            "low" if c["external_dep_count"] == 0 else
                            "medium" if c["external_dep_count"] <= 3 else "high"
                        ),
                    }
                    for c in boundaries["clusters"]
                ],
                "bridge_files": [
                    {"file": b["file"], "connects": b["connects_dirs"]}
                    for b in boundaries["bridges"][:10]
                ],
                "orphan_count": len(boundaries["orphans"]),
                "orphans": boundaries["orphans"][:20],
            }
        except Exception as e:
            context["boundaries"] = {"error": str(e)}
    else:
        print("  [6/6] Skipping boundary detection", flush=True)

    # 7. Project docs (bonus)
    docs = read_project_docs(project)
    if docs:
        context["docs"] = docs

    return context

format_markdown ¶

format_markdown(context: dict) -> str

Format compiled context as markdown.

Source code in Tools/analyzers/context_compiler.py

def format_markdown(context: dict) -> str:
    """Format compiled context as markdown."""
    lines = [
        f"# Project Context: {context['meta']['project']}",
        "",
        f"*Compiled: {context['meta']['compiled_at']}*",
        "",
    ]

    # Structure
    s = context.get("structure", {})
    if s and "error" not in s:
        lines.extend([
            "## Structure",
            "",
            f"**{s.get('total_files', '?')} files** | "
            f"**{s.get('total_dirs', '?')} dirs** | "
            f"Top-level: {', '.join(f'`{d}`' for d in s.get('top_level_dirs', [])[:10])}",
            "",
        ])

    # Platforms & Frameworks
    platforms = context.get("platforms", {})
    frameworks = context.get("frameworks", [])
    if platforms.get("detected") or frameworks:
        lines.append("## Tech Stack")
        lines.append("")
        for p in platforms.get("detected", []):
            ver = f" {p['version']}" if p.get("version") else ""
            lines.append(f"- **{p['name']}**{ver} ({p['confidence']})")
        for f in frameworks:
            lines.append(f"- {f}")
        lines.append("")

    # Entry Points
    eps = context.get("codemap", {}).get("entry_points", [])
    if eps:
        lines.extend(["## Entry Points", ""])
        for ep in eps:
            lines.append(f"- `{ep['path']}` ({ep['type']})")
        lines.append("")

    # Key Files
    key_files = context.get("codemap", {}).get("key_files", [])
    if key_files:
        lines.extend(["## Key Source Files", ""])
        for f in key_files:
            parts = []
            for cls in f.get("classes", []) + f.get("structs", []):
                parts.append(f"class {cls['name']}({cls.get('methods', 0)} methods)")
            for fn_name in f.get("functions", [])[:5]:
                parts.append(f"fn {fn_name}")
            for t in f.get("traits", []) + f.get("interfaces", []):
                parts.append(f"interface {t}")

            detail = f" - {', '.join(parts)}" if parts else ""
            lines.append(f"- `{f['path']}` ({f.get('lines', '?')}L){detail}")
        lines.append("")

    # Boundaries
    bounds = context.get("boundaries", {})
    if bounds and "error" not in bounds:
        clusters = bounds.get("clusters", [])
        if clusters:
            lines.extend(["## Component Boundaries", "",
                          "| Component | Files | Cohesion | External Deps | Risk |",
                          "|-----------|-------|----------|---------------|------|"])
            for c in clusters:
                lines.append(
                    f"| `{c['name']}` | {c['files']} | "
                    f"{c['cohesion']} | {c['external_deps']} | "
                    f"{c['extraction_risk']} |"
                )
            lines.append("")

        bridges = bounds.get("bridge_files", [])
        if bridges:
            lines.extend(["### Bridge Files", ""])
            for b in bridges:
                lines.append(f"- `{b['file']}` connects {', '.join(b['connects'][:4])}")
            lines.append("")

    # Docs
    docs = context.get("docs", {})
    if docs:
        lines.extend(["## Project Documentation", ""])
        for filename, content in docs.items():
            lines.append(f"### {filename}")
            lines.append("")
            # Only first ~50 lines
            doc_lines = content.split('\n')[:50]
            lines.extend(doc_lines)
            if len(content.split('\n')) > 50:
                lines.append("*(truncated)*")
            lines.append("")

    return "\n".join(lines)

Code Map¶

analyzers.codemap ¶

Code Map Generator - The most important AI agent accelerator.

Scans a codebase and produces a structured index of everything an AI agent needs to understand the project without reading every file: - File roles (config, source, test, docs, build) - Classes with methods and inheritance - Functions with signatures - Exports and entry points - Key constants and type definitions

Supports: Python, JavaScript/TypeScript, Rust, Go, C#, Java

Output: JSON (default) or markdown (--markdown)

Usage

python codemap.py python codemap.py --output codemap.json python codemap.py --markdown --output codemap.md python codemap.py --depth 3 --max-files 500

Functions¶

generate_codemap ¶

generate_codemap(project_path: str, max_files: int = 2000) -> dict

Generate a complete code map for a project.

Source code in Tools/analyzers/codemap.py

def generate_codemap(project_path: str, max_files: int = 2000) -> dict:
    """Generate a complete code map for a project."""

    project = Path(project_path).resolve()
    if not project.exists():
        raise FileNotFoundError(f"Project path not found: {project_path}")

    file_entries = []
    lang_stats = defaultdict(lambda: {"files": 0, "lines": 0})
    role_stats = defaultdict(int)
    file_count = 0

    for root, dirs, files in os.walk(project):
        # Skip ignored directories
        dirs[:] = [d for d in dirs if d not in SKIP_DIRS and not d.startswith('.')]

        for filename in sorted(files):
            if filename in SKIP_FILES or filename.startswith('.'):
                continue

            file_count += 1
            if file_count > max_files:
                break

            filepath = Path(root) / filename
            entry = scan_file(filepath, project)

            if entry:
                file_entries.append(entry)
                role_stats[entry.get("role", "unknown")] += 1
                if entry.get("lang"):
                    lang_stats[entry["lang"]]["files"] += 1
                    lang_stats[entry["lang"]]["lines"] += entry.get("line_count", 0)

        if file_count > max_files:
            break

    # Detect entry points
    entry_points = find_entry_points(project, file_entries)

    # Build summary
    codemap = {
        "project": project.name,
        "root": str(project),
        "summary": {
            "total_files": len(file_entries),
            "languages": dict(lang_stats),
            "roles": dict(role_stats),
            "truncated": file_count > max_files,
        },
        "entry_points": entry_points,
        "files": file_entries,
    }

    return codemap

scan_file ¶

scan_file(filepath: Path, project_root: Path) -> Optional[dict]

Scan a single file and return its map entry.

Source code in Tools/analyzers/codemap.py

def scan_file(filepath: Path, project_root: Path) -> Optional[dict]:
    """Scan a single file and return its map entry."""
    rel_path = str(filepath.relative_to(project_root))
    ext = filepath.suffix.lower()
    lang = LANG_MAP.get(ext)
    role = classify_role(rel_path)

    try:
        stat = filepath.stat()
        size = stat.st_size
    except OSError:
        return None

    # Skip very large files (likely generated)
    if size > 500_000:
        return {
            "path": rel_path,
            "lang": lang,
            "role": role,
            "size": size,
            "skipped": "too_large",
        }

    entry = {
        "path": rel_path,
        "lang": lang,
        "role": role,
        "size": size,
        "line_count": 0,
    }

    # Only parse source files with known languages
    if lang and role == "source" and lang in PARSERS:
        try:
            content = filepath.read_text(encoding='utf-8', errors='ignore')
            entry["line_count"] = content.count('\n') + 1
            parsed = PARSERS[lang](filepath, content)
            # Only include non-empty sections
            for key, value in parsed.items():
                if value:
                    entry[key] = value
        except Exception:
            pass
    elif lang:
        try:
            content = filepath.read_text(encoding='utf-8', errors='ignore')
            entry["line_count"] = content.count('\n') + 1
        except Exception:
            pass

    return entry

find_entry_points ¶

find_entry_points(project_root: Path, file_entries: list[dict]) -> list[dict]

Detect likely entry points for the project.

Source code in Tools/analyzers/codemap.py

def find_entry_points(project_root: Path, file_entries: list[dict]) -> list[dict]:
    """Detect likely entry points for the project."""
    entry_points = []

    indicators = [
        ("main.py", "python"),
        ("app.py", "python"),
        ("server.py", "python"),
        ("__main__.py", "python"),
        ("manage.py", "python (django)"),
        ("wsgi.py", "python (wsgi)"),
        ("asgi.py", "python (asgi)"),
        ("index.js", "javascript"),
        ("index.ts", "typescript"),
        ("server.js", "javascript"),
        ("server.ts", "typescript"),
        ("app.js", "javascript"),
        ("app.ts", "typescript"),
        ("main.rs", "rust"),
        ("lib.rs", "rust (library)"),
        ("main.go", "go"),
        ("Program.cs", "csharp"),
        ("Main.java", "java"),
    ]

    paths_set = {e["path"] for e in file_entries}

    for filename, lang in indicators:
        for path in paths_set:
            if path.endswith(filename):
                entry_points.append({"path": path, "type": lang})

    # Check package.json for scripts
    pkg_json = project_root / "package.json"
    if pkg_json.exists():
        try:
            data = json.loads(pkg_json.read_text())
            if "main" in data:
                entry_points.append({"path": data["main"], "type": "package.json main"})
            if "scripts" in data:
                for key in ("start", "dev", "serve"):
                    if key in data["scripts"]:
                        entry_points.append({
                            "path": f"package.json scripts.{key}",
                            "type": data["scripts"][key][:60],
                        })
        except Exception:
            pass

    # Check pyproject.toml for entry points
    pyproject = project_root / "pyproject.toml"
    if pyproject.exists():
        try:
            content = pyproject.read_text()
            # Simple regex for [project.scripts]
            m = re.search(r'\[project\.scripts\]\s*\n((?:\w+\s*=.*\n?)+)', content)
            if m:
                for line in m.group(1).strip().split('\n'):
                    parts = line.split('=', 1)
                    if len(parts) == 2:
                        entry_points.append({
                            "path": f"pyproject.toml scripts.{parts[0].strip()}",
                            "type": parts[1].strip().strip('"\''),
                        })
        except Exception:
            pass

    return entry_points

classify_role ¶

classify_role(filepath: str) -> str

Classify a file's role based on its path and name.

Source code in Tools/analyzers/codemap.py

def classify_role(filepath: str) -> str:
    """Classify a file's role based on its path and name."""
    for role, patterns in ROLE_PATTERNS.items():
        for pattern in patterns:
            if re.search(pattern, filepath, re.IGNORECASE):
                return role
    return "source"

Boundary Detector¶

analyzers.boundary_detector ¶

Boundary Detector - Find natural component boundaries in codebases.

Analyzes the import/dependency graph to detect clusters of files that naturally belong together. Helps AI agents decide WHERE to cut when extracting components.

Outputs

Detected component clusters (files that import each other heavily)
Bridge files (connect multiple clusters - extract carefully)
Orphan files (no imports to/from - easy to extract or remove)
Suggested extraction units with dependency counts
Cross-cluster dependencies (what breaks if you extract)

Supports: Python, JavaScript/TypeScript, Go, Rust

Usage

python boundary_detector.py python boundary_detector.py --output boundaries.json python boundary_detector.py --markdown python boundary_detector.py --min-cluster 3

Functions¶

detect_boundaries ¶

detect_boundaries(project_path: str, min_cluster: int = 2) -> dict

Run full boundary detection.

Source code in Tools/analyzers/boundary_detector.py

def detect_boundaries(project_path: str, min_cluster: int = 2) -> dict:
    """Run full boundary detection."""
    project = Path(project_path).resolve()

    print("  Building import graph...", flush=True)
    graph = build_import_graph(str(project))

    print("  Detecting clusters...", flush=True)
    clusters = detect_clusters(graph, min_cluster)

    print("  Finding bridge files...", flush=True)
    bridges = find_bridge_files(graph)

    print("  Finding orphans...", flush=True)
    orphans = find_orphans(graph, set(graph["files"].values()))

    # Build extraction suggestions
    suggestions = []
    for cluster in clusters:
        extractable = cluster["external_dep_count"] == 0
        risk = "low" if extractable else (
            "medium" if cluster["external_dep_count"] <= 3 else "high"
        )

        suggestions.append({
            "cluster_id": cluster["id"],
            "name": cluster["common_prefix"] or f"cluster-{cluster['id']}",
            "files": cluster["file_count"],
            "extraction_risk": risk,
            "reason": (
                "No external dependencies - clean extraction"
                if extractable else
                f"{cluster['external_dep_count']} external deps, "
                f"{cluster['external_dependent_count']} external dependents"
            ),
        })

    return {
        "project": project.name,
        "root": str(project),
        "summary": {
            "total_source_files": len(graph["files"]),
            "total_import_edges": sum(len(v) for v in graph["imports"].values()),
            "clusters_found": len(clusters),
            "bridge_files": len(bridges),
            "orphan_files": len(orphans),
        },
        "clusters": clusters,
        "bridges": bridges,
        "orphans": orphans,
        "extraction_suggestions": suggestions,
        "import_graph": graph["imports"],
    }

build_import_graph ¶

build_import_graph(project_path: str) -> dict

Build a full import graph for the project.

Source code in Tools/analyzers/boundary_detector.py

def build_import_graph(project_path: str) -> dict:
    """Build a full import graph for the project."""
    project = Path(project_path).resolve()

    # Map all source files
    all_files = {}  # normalized_path -> real relative path
    for root, dirs, files in os.walk(project):
        dirs[:] = [d for d in dirs if d not in SKIP_DIRS and not d.startswith('.')]

        for filename in files:
            filepath = Path(root) / filename
            ext = filepath.suffix.lower()
            if ext in EXTRACTORS:
                rel = str(filepath.relative_to(project))
                # Create normalized keys (without extension, for matching)
                norm = rel.rsplit('.', 1)[0]
                all_files[norm] = rel
                # Also index without /index suffix
                if norm.endswith('/index'):
                    all_files[norm[:-6]] = rel

    # Build graph
    graph = defaultdict(set)  # file -> set of files it imports
    reverse_graph = defaultdict(set)  # file -> set of files that import it

    for norm_path, rel_path in all_files.items():
        filepath = project / rel_path
        ext = filepath.suffix.lower()
        extractor = EXTRACTORS.get(ext)
        if not extractor:
            continue

        raw_imports = extractor(filepath, project)

        for imp in raw_imports:
            # Try to resolve to a known file
            candidates = [
                imp,
                imp + '/index',
                imp + '/__init__',
            ]
            for candidate in candidates:
                if candidate in all_files:
                    target = all_files[candidate]
                    if target != rel_path:  # No self-imports
                        graph[rel_path].add(target)
                        reverse_graph[target].add(rel_path)
                    break

    return {
        "files": {v: norm for norm, v in all_files.items()},
        "imports": {k: sorted(v) for k, v in graph.items()},
        "imported_by": {k: sorted(v) for k, v in reverse_graph.items()},
    }

detect_clusters ¶

detect_clusters(graph: dict, min_cluster: int = 2) -> list[dict]

Detect clusters of tightly connected files using simple community detection.

Uses a greedy approach: start from each unvisited file, expand to include files that share the most import connections with the current cluster.

Source code in Tools/analyzers/boundary_detector.py

def detect_clusters(graph: dict, min_cluster: int = 2) -> list[dict]:
    """
    Detect clusters of tightly connected files using simple community detection.

    Uses a greedy approach: start from each unvisited file, expand to include
    files that share the most import connections with the current cluster.
    """
    imports = graph["imports"]
    imported_by = graph["imported_by"]

    # Build bidirectional adjacency
    adjacency = defaultdict(set)
    for source, targets in imports.items():
        for target in targets:
            adjacency[source].add(target)
            adjacency[target].add(source)

    all_nodes = set(imports.keys()) | set(imported_by.keys())
    visited = set()
    clusters = []

    # Sort by connectivity (most connected first)
    nodes_by_degree = sorted(all_nodes, key=lambda n: len(adjacency[n]), reverse=True)

    for seed in nodes_by_degree:
        if seed in visited:
            continue

        # BFS to find connected component
        cluster = set()
        queue = [seed]

        while queue:
            node = queue.pop(0)
            if node in visited:
                continue
            visited.add(node)
            cluster.add(node)

            for neighbor in adjacency[node]:
                if neighbor not in visited:
                    queue.append(neighbor)

        if len(cluster) >= min_cluster:
            # Find common directory prefix
            parts_list = [f.split('/') for f in cluster]
            common_prefix = []
            if parts_list:
                for level_parts in zip(*parts_list):
                    if len(set(level_parts)) == 1:
                        common_prefix.append(level_parts[0])
                    else:
                        break

            # Calculate internal vs external imports
            internal_edges = 0
            external_deps = set()
            external_dependents = set()

            for f in cluster:
                for imp in imports.get(f, []):
                    if imp in cluster:
                        internal_edges += 1
                    else:
                        external_deps.add(imp)

                for dep in imported_by.get(f, []):
                    if dep not in cluster:
                        external_dependents.add(dep)

            cohesion = internal_edges / max(len(cluster), 1)

            clusters.append({
                "id": len(clusters),
                "files": sorted(cluster),
                "file_count": len(cluster),
                "common_prefix": '/'.join(common_prefix) if common_prefix else None,
                "internal_edges": internal_edges,
                "cohesion": round(cohesion, 2),
                "external_deps": sorted(external_deps),
                "external_dep_count": len(external_deps),
                "external_dependents": sorted(external_dependents),
                "external_dependent_count": len(external_dependents),
            })

    # Sort by size
    clusters.sort(key=lambda c: c["file_count"], reverse=True)
    return clusters

find_bridge_files ¶

find_bridge_files(graph: dict) -> list[dict]

Find files that connect multiple clusters (high betweenness).

Source code in Tools/analyzers/boundary_detector.py

def find_bridge_files(graph: dict) -> list[dict]:
    """Find files that connect multiple clusters (high betweenness)."""
    imports = graph["imports"]
    imported_by = graph["imported_by"]

    bridges = []

    for filepath in set(imports.keys()) | set(imported_by.keys()):
        importers = set(imported_by.get(filepath, []))
        importees = set(imports.get(filepath, []))

        # A bridge connects different directories
        all_connected = importers | importees
        dirs = set()
        for f in all_connected:
            parts = f.split('/')
            if len(parts) > 1:
                dirs.add(parts[0] if len(parts) <= 2 else '/'.join(parts[:2]))

        if len(dirs) >= 2:
            bridges.append({
                "file": filepath,
                "connects_dirs": sorted(dirs),
                "imported_by_count": len(importers),
                "imports_count": len(importees),
                "total_connections": len(all_connected),
            })

    bridges.sort(key=lambda b: b["total_connections"], reverse=True)
    return bridges[:30]

find_orphans ¶

find_orphans(graph: dict, all_source_files: set) -> list[str]

Find files with no import relationships (easy to extract/remove).

Source code in Tools/analyzers/boundary_detector.py

def find_orphans(graph: dict, all_source_files: set) -> list[str]:
    """Find files with no import relationships (easy to extract/remove)."""
    connected = set(graph["imports"].keys()) | set(graph["imported_by"].keys())
    return sorted(all_source_files - connected)

Interface Extractor¶

analyzers.interface_extractor ¶

Interface Extractor - Extract public API surfaces from codebases.

Answers: "What does this module/package expose?" without reading implementations. An AI agent uses this to understand boundaries - what can be imported, called, or composed from each part of a project.

Extracts

Public function signatures (with types)
Public class interfaces (public methods, no internals)
Exported types, interfaces, enums
Module-level all / export declarations
Package-level re-exports

Supports: Python, JavaScript/TypeScript, Rust, Go, C#

Output: JSON (default) or markdown (--markdown)

Usage

python interface_extractor.py python interface_extractor.py --output interfaces.json python interface_extractor.py src/core/ --markdown