sourcecode 1.52.0__tar.gz → 1.53.0__tar.gz

{sourcecode-1.52.0 → sourcecode-1.53.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 1.52.0
+Version: 1.53.0
 Summary: Persistent structural context and ultra-fast repeated analysis for AI coding agents
 License-File: LICENSE
 Keywords: agents,ai,codebase,context,developer-tools,llm
@@ -40,7 +40,7 @@ Description-Content-Type: text/markdown
 
 **Persistent structural context and ultra-fast repeated analysis for AI coding agents.**
 
-![Version](https://img.shields.io/badge/version-1.52.0-blue)
+![Version](https://img.shields.io/badge/version-1.53.0-blue)
 ![Python](https://img.shields.io/badge/python-3.9%2B-green)
 
 ---
@@ -114,7 +114,7 @@ pipx install sourcecode
 
 ```bash
 sourcecode version
-# sourcecode 1.52.0
+# sourcecode 1.53.0
 ```
 
 ---
@@ -364,9 +364,10 @@ sourcecode impact OrderService . --depth 2                 # limit BFS depth
 ```bash
 sourcecode endpoints /path/to/repo
 sourcecode endpoints /path/to/repo --output endpoints.json
+sourcecode endpoints /path/to/repo --by-controller
 ```
 
-Extracts all Spring MVC (`@GetMapping`, `@PostMapping`, `@RequestMapping`, etc.) and JAX-RS (`@GET`, `@POST`, `@Path`) endpoint methods. Returns HTTP method, path, controller class, and handler method.
+Extracts all Spring MVC (`@GetMapping`, `@PostMapping`, `@RequestMapping`, etc.) and JAX-RS (`@GET`, `@POST`, `@Path`) endpoint methods. Returns HTTP method, path, controller class, and handler method. Each endpoint also carries its `return_type`. `--by-controller` groups the surface per controller (`{by_controller, controller_count, total}`) for an API-surface view.
 
 **Functional / WebFlux routing (honest limitation).** Routes registered via the functional DSL — `route().GET("/path", handler)` / `RouterFunction` / `CustomEndpoint`, common in reactive Spring apps — are **not** modeled (their real paths depend on `nest()`/group-version prefixes that can't be resolved statically). Rather than emit partial paths that would mislead, the output reports a `functional_routing` block (`files`, `route_registrations`, `modeled: false`) plus a warning. When the annotation surface is empty but functional routes exist, the warning explicitly tells you not to read it as "no endpoints". Annotation-based (MVC/JAX-RS) repos are unaffected.
 
@@ -387,6 +388,26 @@ Extracts all Spring MVC (`@GetMapping`, `@PostMapping`, `@RequestMapping`, etc.)
 
 Matching endpoints then report `policy: "custom"` with `annotation`, `resourceName`, and `requiredLevel`, and are no longer counted in `no_security_signal`. Repos without the config behave exactly as before.
 
+### `export` — architecture views for downstream tooling
+
+```bash
+sourcecode export /path/to/repo --by-directory      # code map, path:line refs
+sourcecode export /path/to/repo --module-graph       # module→module dependencies
+sourcecode export /path/to/repo --integrations       # outbound HTTP/LDAP/JMS clients
+sourcecode export /path/to/repo --c4                  # unified architecture + manifest
+```
+
+Emits **structured, tool-agnostic** codebase views as plain JSON/YAML — the kind of input an architecture-doc generator, diagram renderer, or code-search agent can consume directly instead of walking the tree file by file. Section labels map to the open [C4 model](https://c4model.com) (an open architecture notation, not a product); the schema is vendor-neutral.
+
+| Flag | Output |
+|------|--------|
+| `--by-directory` | One group per source directory, each symbol with a `source_file:line` reference. |
+| `--module-graph` | `{nodes, edges, summary}` — directories as modules, inter-module dependencies rolled up from class-level relation edges with hit counts + edge types. |
+| `--integrations` | Outbound integrations (`RestTemplate`, `WebClient`, `@FeignClient`, `LdapTemplate`, `JmsTemplate`, ActiveMQ) with `file:line` evidence and a literal `target` URL/name when present. |
+| `--c4` | Unified document: `c4.{context, containers, components, code}` + `api_surface` + a `manifest` with per-directory content hashes for **incremental** consumers (skip directories whose hash is unchanged). |
+
+The section flags compose (pass several for one multi-section document); `--c4` assembles the full export on its own. URLs assembled at runtime yield `target: null` (honest absence, never a guess); containers are derived from build files (Maven/Gradle) and reported as a limitation when none are found.
+
 ### `spring-audit` — Spring semantic audit [free]
 
 ```bash

{sourcecode-1.52.0 → sourcecode-1.53.0}/README.md

@@ -2,7 +2,7 @@
 
 **Persistent structural context and ultra-fast repeated analysis for AI coding agents.**
 
-![Version](https://img.shields.io/badge/version-1.52.0-blue)
+![Version](https://img.shields.io/badge/version-1.53.0-blue)
 ![Python](https://img.shields.io/badge/python-3.9%2B-green)
 
 ---
@@ -76,7 +76,7 @@ pipx install sourcecode
 
 ```bash
 sourcecode version
-# sourcecode 1.52.0
+# sourcecode 1.53.0
 ```
 
 ---
@@ -326,9 +326,10 @@ sourcecode impact OrderService . --depth 2                 # limit BFS depth
 ```bash
 sourcecode endpoints /path/to/repo
 sourcecode endpoints /path/to/repo --output endpoints.json
+sourcecode endpoints /path/to/repo --by-controller
 ```
 
-Extracts all Spring MVC (`@GetMapping`, `@PostMapping`, `@RequestMapping`, etc.) and JAX-RS (`@GET`, `@POST`, `@Path`) endpoint methods. Returns HTTP method, path, controller class, and handler method.
+Extracts all Spring MVC (`@GetMapping`, `@PostMapping`, `@RequestMapping`, etc.) and JAX-RS (`@GET`, `@POST`, `@Path`) endpoint methods. Returns HTTP method, path, controller class, and handler method. Each endpoint also carries its `return_type`. `--by-controller` groups the surface per controller (`{by_controller, controller_count, total}`) for an API-surface view.
 
 **Functional / WebFlux routing (honest limitation).** Routes registered via the functional DSL — `route().GET("/path", handler)` / `RouterFunction` / `CustomEndpoint`, common in reactive Spring apps — are **not** modeled (their real paths depend on `nest()`/group-version prefixes that can't be resolved statically). Rather than emit partial paths that would mislead, the output reports a `functional_routing` block (`files`, `route_registrations`, `modeled: false`) plus a warning. When the annotation surface is empty but functional routes exist, the warning explicitly tells you not to read it as "no endpoints". Annotation-based (MVC/JAX-RS) repos are unaffected.
 
@@ -349,6 +350,26 @@ Extracts all Spring MVC (`@GetMapping`, `@PostMapping`, `@RequestMapping`, etc.)
 
 Matching endpoints then report `policy: "custom"` with `annotation`, `resourceName`, and `requiredLevel`, and are no longer counted in `no_security_signal`. Repos without the config behave exactly as before.
 
+### `export` — architecture views for downstream tooling
+
+```bash
+sourcecode export /path/to/repo --by-directory      # code map, path:line refs
+sourcecode export /path/to/repo --module-graph       # module→module dependencies
+sourcecode export /path/to/repo --integrations       # outbound HTTP/LDAP/JMS clients
+sourcecode export /path/to/repo --c4                  # unified architecture + manifest
+```
+
+Emits **structured, tool-agnostic** codebase views as plain JSON/YAML — the kind of input an architecture-doc generator, diagram renderer, or code-search agent can consume directly instead of walking the tree file by file. Section labels map to the open [C4 model](https://c4model.com) (an open architecture notation, not a product); the schema is vendor-neutral.
+
+| Flag | Output |
+|------|--------|
+| `--by-directory` | One group per source directory, each symbol with a `source_file:line` reference. |
+| `--module-graph` | `{nodes, edges, summary}` — directories as modules, inter-module dependencies rolled up from class-level relation edges with hit counts + edge types. |
+| `--integrations` | Outbound integrations (`RestTemplate`, `WebClient`, `@FeignClient`, `LdapTemplate`, `JmsTemplate`, ActiveMQ) with `file:line` evidence and a literal `target` URL/name when present. |
+| `--c4` | Unified document: `c4.{context, containers, components, code}` + `api_surface` + a `manifest` with per-directory content hashes for **incremental** consumers (skip directories whose hash is unchanged). |
+
+The section flags compose (pass several for one multi-section document); `--c4` assembles the full export on its own. URLs assembled at runtime yield `target: null` (honest absence, never a guess); containers are derived from build files (Maven/Gradle) and reported as a limitation when none are found.
+
 ### `spring-audit` — Spring semantic audit [free]
 
 ```bash

{sourcecode-1.52.0 → sourcecode-1.53.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sourcecode"
-version = "1.52.0"
+version = "1.53.0"
 description = "Persistent structural context and ultra-fast repeated analysis for AI coding agents"
 readme = "README.md"
 requires-python = ">=3.9"

{sourcecode-1.52.0 → sourcecode-1.53.0}/src/sourcecode/__init__.py

@@ -1,3 +1,3 @@
 """sourcecode — Deterministic codebase context maps for AI coding agents."""
 
-__version__ = "1.52.0"
+__version__ = "1.53.0"

{sourcecode-1.52.0 → sourcecode-1.53.0}/src/sourcecode/cli.py

@@ -219,7 +219,7 @@ _HELP = _build_help_text()
 _SUBCOMMANDS: frozenset[str] = frozenset(
     {
         "telemetry", "prepare-context", "version", "config",
-        "repo-ir", "mcp", "endpoints", "impact",
+        "repo-ir", "mcp", "endpoints", "impact", "export",
         # Enterprise workflow commands
         "onboard", "modernize", "fix-bug", "review-pr",
         # License / auth
@@ -3804,6 +3804,30 @@ def impact_cmd(
 # canonical single-source-of-truth endpoint extractor.
 
 
+def _group_endpoints_by_controller(endpoints: "list[dict]") -> "dict":
+    """Group endpoints by their controller FQN into a structured API surface.
+
+    Returns ``{"by_controller": {fqn: [{method, path, return_type}, ...]},
+    "controller_count": int, "total": int}``. Controllers and their routes are
+    ordered deterministically (controllers by name, routes by path then method).
+    """
+    by_ctrl: "dict[str, list[dict]]" = {}
+    for ep in endpoints:
+        ctrl = ep.get("controller", "") or "<unknown>"
+        by_ctrl.setdefault(ctrl, []).append({
+            "method": ep.get("method", ""),
+            "path": ep.get("path", ""),
+            "return_type": ep.get("return_type", "void"),
+        })
+    for ctrl in by_ctrl:
+        by_ctrl[ctrl].sort(key=lambda r: (r["path"], r["method"]))
+    ordered = {k: by_ctrl[k] for k in sorted(by_ctrl)}
+    return {
+        "by_controller": ordered,
+        "controller_count": len(ordered),
+        "total": len(endpoints),
+    }
+
 
 @app.command("endpoints")
 def endpoints_cmd(
@@ -3844,6 +3868,10 @@ def endpoints_cmd(
         False, "--no-cache",
         help="Accepted for compatibility; this command always reads fresh source (no snapshot cache). No-op.",
     ),
+    by_controller: bool = typer.Option(
+        False, "--by-controller",
+        help="Group endpoints by controller class (structured API surface for C4/Container synthesis).",
+    ),
 ) -> None:
     """Extract REST API endpoint surface from Java source files.
 
@@ -3929,6 +3957,11 @@ def endpoints_cmd(
             "undocumented_before_filter": _undoc_before,
         }
 
+    if by_controller:
+        _grouped = _group_endpoints_by_controller(data.get("endpoints", []))
+        data["by_controller"] = _grouped["by_controller"]
+        data["controller_count"] = _grouped["controller_count"]
+
     output = _serialize_dict(data, format)
 
     _emit_command_output(output, output_path, copy,
@@ -3938,6 +3971,362 @@ def endpoints_cmd(
     _nudge()
 
 
+# ── export ──────────────────────────────────────────────────────────────────
+
+def _group_symbols_by_directory(nodes: "list[dict]") -> "dict":
+    """Group repo-ir graph nodes by source directory with path:line refs.
+
+    Returns ``{dir: [{symbol, kind, ref}]}`` ordered deterministically (dirs by
+    name, symbols by ref). ``ref`` is ``source_file:line`` when the line is known,
+    otherwise just ``source_file``. This is the per-directory, file:line-anchored
+    code-level export — the file:line-anchored input an architecture/code-map
+    consumer needs to proceed by file write instead of per-directory LLM reads.
+    """
+    import posixpath
+    by_dir: "dict[str, list[dict]]" = {}
+    for n in nodes:
+        sf = n.get("source_file") or ""
+        if not sf:
+            continue
+        d = posixpath.dirname(sf) or "."
+        ln = n.get("line")
+        ref = f"{sf}:{ln}" if ln else sf
+        by_dir.setdefault(d, []).append({
+            "symbol": n.get("canonical_name") or n.get("fqn"),
+            "kind": n.get("symbol_kind"),
+            "ref": ref,
+        })
+    for d in by_dir:
+        by_dir[d].sort(key=lambda r: r["ref"])
+    return {k: by_dir[k] for k in sorted(by_dir)}
+
+
+def _build_module_graph(nodes: "list[dict]", edges: "list[dict]") -> "dict":
+    """Roll class-level relation edges up into a module→module dependency graph.
+
+    A *module* is the source directory of a symbol (same grouping key as
+    ``--by-directory``), giving C4 a container/component-level dependency view.
+    Every node FQN maps to its module; each edge whose endpoints resolve to two
+    *different* modules contributes one inter-module dependency, aggregated by
+    ``(from, to)`` with a hit count and the set of underlying edge types.
+
+    Edges whose endpoints are not internal nodes (e.g. imports of external
+    library types) are skipped — only resolvable, internal module→module
+    dependencies are reported. Returns ``{nodes, edges, summary}`` deterministically.
+    """
+    import posixpath
+
+    fqn_to_module: "dict[str, str]" = {}
+    module_symbols: "dict[str, int]" = {}
+    for n in nodes:
+        sf = n.get("source_file") or ""
+        if not sf:
+            continue
+        mod = posixpath.dirname(sf) or "."
+        fqn = n.get("fqn")
+        if fqn:
+            fqn_to_module[fqn] = mod
+        module_symbols[mod] = module_symbols.get(mod, 0) + 1
+
+    # (from_mod, to_mod) -> {"count": int, "types": set[str]}
+    agg: "dict[tuple[str, str], dict]" = {}
+    for e in edges:
+        fm = fqn_to_module.get(e.get("from"))
+        tm = fqn_to_module.get(e.get("to"))
+        if fm is None or tm is None or fm == tm:
+            continue
+        slot = agg.setdefault((fm, tm), {"count": 0, "types": set()})
+        slot["count"] += 1
+        et = e.get("type")
+        if et:
+            slot["types"].add(et)
+
+    graph_edges = [
+        {
+            "from": fm,
+            "to": tm,
+            "count": slot["count"],
+            "types": sorted(slot["types"]),
+        }
+        for (fm, tm), slot in sorted(agg.items())
+    ]
+    out_deg: "dict[str, int]" = {}
+    in_deg: "dict[str, int]" = {}
+    for ed in graph_edges:
+        out_deg[ed["from"]] = out_deg.get(ed["from"], 0) + 1
+        in_deg[ed["to"]] = in_deg.get(ed["to"], 0) + 1
+    graph_nodes = [
+        {
+            "module": mod,
+            "symbol_count": module_symbols[mod],
+            "out_degree": out_deg.get(mod, 0),
+            "in_degree": in_deg.get(mod, 0),
+        }
+        for mod in sorted(module_symbols)
+    ]
+    return {
+        "nodes": graph_nodes,
+        "edges": graph_edges,
+        "summary": {
+            "module_count": len(graph_nodes),
+            "edge_count": len(graph_edges),
+        },
+    }
+
+
+# Build-system markers that identify a deployable/buildable unit (C4 container).
+_BUILD_MARKERS: "tuple[str, ...]" = (
+    "pom.xml", "build.gradle", "build.gradle.kts", "settings.gradle",
+)
+
+
+def _detect_containers(root: "Path") -> "list[dict]":
+    """Detect build-module roots as C4 containers (deployable/buildable units).
+
+    A *container* is a directory holding a recognized build file
+    (Maven/Gradle). Detection is purely structural — no build is run. Returns
+    ``[{root, build_file}]`` (relative paths, deterministic order). Empty when no
+    build files are found; the caller records that as a limitation rather than
+    fabricating containers.
+    """
+    import os
+    found: "list[dict]" = []
+    seen: "set[str]" = set()
+    _SKIP = {".git", "node_modules", "target", "build", ".gradle", ".idea", "dist"}
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [d for d in dirnames if d not in _SKIP and not d.startswith(".")]
+        for marker in _BUILD_MARKERS:
+            if marker in filenames:
+                rel = os.path.relpath(dirpath, root).replace(os.sep, "/")
+                rel = "." if rel == "." else rel
+                if rel in seen:
+                    continue
+                seen.add(rel)
+                found.append({"root": rel, "build_file": marker})
+                break
+    found.sort(key=lambda c: c["root"])
+    return found
+
+
+def _directory_hashes(file_list: "list[str]", root: "Path") -> "dict[str, str]":
+    """Content-addressed sha256 per source directory for incremental consumers.
+
+    Hash inputs are the directory's source files as ``(relpath, bytes)`` in
+    sorted order, so the digest is stable across runs and changes iff a file in
+    that directory changes. A consumer compares hashes to skip unchanged
+    directories. Tool-agnostic: just a map ``{dir: sha256[:16]}``.
+    """
+    import hashlib
+    import posixpath
+    by_dir: "dict[str, list[str]]" = {}
+    for rel in file_list:
+        d = posixpath.dirname(rel) or "."
+        by_dir.setdefault(d, []).append(rel)
+    out: "dict[str, str]" = {}
+    for d in sorted(by_dir):
+        h = hashlib.sha256()
+        for rel in sorted(by_dir[d]):
+            h.update(rel.encode("utf-8"))
+            h.update(b"\0")
+            try:
+                h.update((root / rel).read_bytes())
+            except OSError:
+                h.update(b"<unreadable>")
+            h.update(b"\0")
+        out[d] = h.hexdigest()[:16]
+    return out
+
+
+def _build_c4_export(
+    root: "Path",
+    file_list: "list[str]",
+    nodes: "list[dict]",
+    edges: "list[dict]",
+    endpoints: "list[dict]",
+    integrations: "dict",
+) -> "dict":
+    """Assemble a unified, tool-agnostic C4 architecture export + incremental manifest.
+
+    Maps the four already-built views onto the open C4 model (a public notation,
+    not a product): code (L4), components (L3/L2), context external systems (L1),
+    plus build-module containers and an interface-contract API surface. The
+    ``manifest`` carries per-directory content hashes so a downstream consumer can
+    process incrementally. No third-party tool or format is hardcoded.
+    """
+    by_directory = _group_symbols_by_directory(nodes)
+    module_graph = _build_module_graph(nodes, edges)
+    api_surface = _group_endpoints_by_controller(endpoints)
+    containers = _detect_containers(root)
+
+    limitations: "list[str]" = []
+    if not containers:
+        limitations.append(
+            "No build files (Maven/Gradle) found; containers not derived. "
+            "Treat the repository as a single implicit container."
+        )
+
+    return {
+        "schema_version": "c4-v1",
+        "c4": {
+            "context": {
+                "system": {"name": root.name, "file_count": len(file_list)},
+                "external_systems": integrations,
+            },
+            "containers": containers,
+            "components": module_graph,
+            "code": by_directory,
+        },
+        "api_surface": api_surface,
+        "manifest": {
+            "directory_hashes": _directory_hashes(file_list, root),
+            "generated": {
+                "tool": "sourcecode",
+                "schema": "c4-v1",
+                "file_count": len(file_list),
+            },
+        },
+        "limitations": limitations,
+    }
+
+
+@app.command("export")
+def export_cmd(
+    path: Path = typer.Argument(
+        Path("."),
+        help="Repository path to export (default: current directory)",
+    ),
+    output_path: Optional[Path] = typer.Option(
+        None, "--output", "-o",
+        help="Write output to a file instead of stdout.",
+    ),
+    format: str = typer.Option(
+        "json", "--format", "-f",
+        help="Output format: json (default) or yaml.",
+    ),
+    copy: bool = typer.Option(
+        False, "--copy", "-c",
+        help="Copy output to system clipboard after a successful run.",
+    ),
+    by_directory: bool = typer.Option(
+        False, "--by-directory",
+        help="Group symbols by source directory with path:line refs (C4 code-level export).",
+    ),
+    module_graph: bool = typer.Option(
+        False, "--module-graph",
+        help="Emit a module→module dependency graph (C4 container/component level).",
+    ),
+    integrations: bool = typer.Option(
+        False, "--integrations",
+        help="Detect outbound integrations (HTTP/LDAP/JMS clients) with file:line evidence.",
+    ),
+    c4: bool = typer.Option(
+        False, "--c4",
+        help="Unified C4 architecture export (context/containers/components/code) "
+             "+ per-directory incremental manifest. Vendor-neutral.",
+    ),
+) -> None:
+    """Export structured, tool-agnostic codebase views for downstream tooling.
+
+    Output is plain JSON/YAML that any consumer (architecture-doc generators,
+    diagram renderers, code-search agents) can ingest. Section labels map to the
+    open C4 model (an open architecture notation, not a product) but the schema
+    is vendor-neutral.
+
+    \b
+    --by-directory   One group per source directory, each symbol carrying a
+                     path:line reference — the file:line-anchored code map that
+                     lets a consumer proceed by file write instead of per-dir reads.
+    --module-graph   Module→module dependency graph (container/component level)
+                     rolled up from class-level relation edges.
+    --integrations   Outbound integrations (RestTemplate/WebClient/Feign/LDAP/JMS)
+                     with file:line evidence — external-system dependency arrows.
+    --c4             Unified architecture document mapped onto the open C4 model
+                     (context/containers/components/code) + an API surface and a
+                     per-directory content-hash manifest for incremental consumers.
+
+    The section flags compose; pass several to emit multiple sections in one
+    document. --c4 assembles the full architecture export on its own.
+    """
+    from sourcecode.repository_ir import build_repo_ir, find_java_files
+
+    _enforce_format("export", format)
+
+    root = path.resolve()
+    if not root.is_dir():
+        _emit_error_json(
+            INVALID_INPUT_CODE,
+            f"'{root}' is not a valid directory.",
+            path=str(root),
+            hint="Pass an existing repository directory.",
+            expected="A directory path.",
+        )
+        raise typer.Exit(1)
+
+    if not (by_directory or module_graph or integrations or c4):
+        _emit_error_json(
+            INVALID_INPUT_CODE,
+            "export requires a mode flag.",
+            path=str(root),
+            hint="Pass --c4 for the full architecture export, or one of "
+                 "--by-directory / --module-graph / --integrations for a section.",
+            expected="--c4 | --by-directory | --module-graph | --integrations",
+        )
+        raise typer.Exit(1)
+
+    file_list = [
+        f for f in find_java_files(root)
+        if "/test/" not in f and "/tests/" not in f
+    ]
+
+    if c4:
+        # Unified architecture export: assembles every section + manifest.
+        from sourcecode.integration_detector import detect_integrations
+        from sourcecode.repository_ir import extract_java_endpoints
+        ir = build_repo_ir(file_list, root)
+        graph = ir.get("graph", {})
+        endpoints = extract_java_endpoints(root).get("endpoints", [])
+        data = _build_c4_export(
+            root,
+            file_list,
+            graph.get("nodes", []),
+            graph.get("edges", []),
+            endpoints,
+            detect_integrations(file_list, root),
+        )
+        output = _serialize_dict(data, format)
+        _emit_command_output(output, output_path, copy,
+                             success_msg=f"C4 architecture export written to {output_path}")
+        from sourcecode.mcp_nudge import nudge_mcp_if_needed as _nudge
+        _nudge()
+        return
+
+    data: "dict" = {}
+    # IR is only needed for the symbol/graph-derived views, not for the
+    # source-scanned integration detector.
+    if by_directory or module_graph:
+        ir = build_repo_ir(file_list, root)
+        graph = ir.get("graph", {})
+        nodes = graph.get("nodes", [])
+        if by_directory:
+            grouped = _group_symbols_by_directory(nodes)
+            data["by_directory"] = grouped
+            data["directory_count"] = len(grouped)
+            data["symbol_count"] = sum(len(v) for v in grouped.values())
+        if module_graph:
+            data["module_graph"] = _build_module_graph(nodes, graph.get("edges", []))
+
+    if integrations:
+        from sourcecode.integration_detector import detect_integrations
+        data["integrations"] = detect_integrations(file_list, root)
+
+    output = _serialize_dict(data, format)
+    _emit_command_output(output, output_path, copy,
+                         success_msg=f"Export written to {output_path}")
+
+    from sourcecode.mcp_nudge import nudge_mcp_if_needed as _nudge
+    _nudge()
+
+
 @app.command("validation")
 def validation_cmd(
     path: Path = typer.Argument(

{sourcecode-1.52.0 → sourcecode-1.53.0}/src/sourcecode/format_contract.py

@@ -27,6 +27,7 @@ FORMAT_REGISTRY: "dict[str, tuple[str, ...]]" = {
     "repo-ir": ("json", "yaml"),
     "impact": ("json", "yaml"),
     "endpoints": ("json", "yaml"),
+    "export": ("json", "yaml"),
     "validation": ("json", "yaml"),
     "impact-chain": ("json", "yaml"),
     "pr-impact": ("text", "json"),