sourcecode 0.33.0__py3-none-any.whl → 0.34.0__py3-none-any.whl

sourcecode/__init__.py

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

sourcecode/ast_extractor.py

@@ -13,6 +13,7 @@ Install tree-sitter for best TS/JS results:
 
 import ast
 import re
+import sys
 from pathlib import Path
 from typing import Any, Iterator, Optional
 
@@ -31,6 +32,45 @@ from sourcecode.contract_model import (
 
 _MAX_FILE_SIZE = 200_000  # bytes — skip files larger than this
 
+# Python stdlib module names — used to filter noise from import lists.
+# sys.stdlib_module_names is available in Python 3.10+; fall back to a
+# curated set for 3.9 compatibility.
+if hasattr(sys, "stdlib_module_names"):
+    _PY_STDLIB: frozenset[str] = sys.stdlib_module_names  # type: ignore[attr-defined]
+else:
+    _PY_STDLIB: frozenset[str] = frozenset({  # type: ignore[no-redef]
+        "__future__", "_thread", "abc", "aifc", "argparse", "array", "ast",
+        "asynchat", "asyncio", "asyncore", "atexit", "audioop", "base64",
+        "bdb", "binascii", "binhex", "bisect", "builtins", "bz2", "calendar",
+        "cgi", "cgitb", "chunk", "cmath", "cmd", "code", "codecs", "codeop",
+        "collections", "colorsys", "compileall", "concurrent", "configparser",
+        "contextlib", "contextvars", "copy", "copyreg", "cProfile", "csv",
+        "ctypes", "curses", "dataclasses", "datetime", "dbm", "decimal",
+        "difflib", "dis", "doctest", "email", "encodings", "enum", "errno",
+        "faulthandler", "fcntl", "filecmp", "fileinput", "fnmatch", "fractions",
+        "ftplib", "functools", "gc", "getopt", "getpass", "gettext", "glob",
+        "grp", "gzip", "hashlib", "heapq", "hmac", "html", "http", "idlelib",
+        "imaplib", "importlib", "inspect", "io", "ipaddress", "itertools",
+        "json", "keyword", "lib2to3", "linecache", "locale", "logging", "lzma",
+        "mailbox", "marshal", "math", "mimetypes", "mmap", "modulefinder",
+        "multiprocessing", "netrc", "nntplib", "numbers", "operator", "optparse",
+        "os", "pathlib", "pdb", "pickle", "pickletools", "pipes", "pkgutil",
+        "platform", "plistlib", "poplib", "posix", "posixpath", "pprint",
+        "profile", "pstats", "pty", "pwd", "py_compile", "pyclbr", "pydoc",
+        "queue", "quopri", "random", "re", "readline", "reprlib", "resource",
+        "rlcompleter", "runpy", "sched", "secrets", "select", "selectors",
+        "shelve", "shlex", "shutil", "signal", "site", "smtpd", "smtplib",
+        "sndhdr", "socket", "socketserver", "sqlite3", "ssl", "stat",
+        "statistics", "string", "stringprep", "struct", "subprocess", "sunau",
+        "symtable", "sys", "sysconfig", "syslog", "tabnanny", "tarfile",
+        "tempfile", "termios", "test", "textwrap", "threading", "time",
+        "timeit", "tkinter", "token", "tokenize", "tomllib", "trace",
+        "traceback", "tracemalloc", "tty", "types", "typing", "unicodedata",
+        "unittest", "urllib", "uuid", "venv", "warnings", "wave", "weakref",
+        "webbrowser", "wsgiref", "xml", "xmlrpc", "zipapp", "zipfile",
+        "zipimport", "zlib", "zoneinfo",
+    })
+
 _LANGUAGE_MAP: dict[str, str] = {
     ".py": "python",
     ".ts": "typescript",
@@ -729,9 +769,10 @@ def _py_signature(node: ast.FunctionDef | ast.AsyncFunctionDef) -> str:
             sig += f" -> {ast.unparse(node.returns)}"
         except Exception:
             pass
-    # Truncate runaway signatures (e.g. typer.Option() defaults)
-    if len(sig) > 300:
-        sig = sig[:297] + "..."
+    # Keep full signature — serializer applies per-mode compression.
+    # Hard cap at 2000 to prevent pathological cases.
+    if len(sig) > 2000:
+        sig = sig[:1997] + "..."
     return sig
 
 
@@ -840,6 +881,10 @@ def _extract_python(path: str, source: str) -> FileContract:
             if exported or name in all_names:
                 exports.append(ExportRecord(name=name, kind="class"))
 
+    # Filter stdlib from imports — they add noise without signal for agents
+    _stdlib_roots = {m.split(".")[0] for m in _PY_STDLIB}
+    imports = [i for i in imports if i.source.split(".")[0] not in _stdlib_roots]
+
     deps = sorted({
         imp.source.split(".")[0]
         for imp in imports

sourcecode/cli.py

@@ -516,11 +516,13 @@ def main(
         "contract",
         "--mode",
         help=(
-            "Output mode: contract (default) | hybrid | raw. "
-            "contract: per-file semantic contracts — exports, signatures, types, imports. No bodies. "
+            "Output mode: contract|minimal (default) | standard | deep | hybrid | raw. "
+            "contract/minimal: minimal per-file contracts — exports, signatures, deps. Smallest output. "
+            "standard: full per-file detail with imports, relevance scores, extraction method. "
+            "deep: standard + optional analysis sections (deps, env, git). "
             "hybrid: contracts + compact bodies for top-ranked files. "
             "raw: legacy project-level analysis (stacks, entry points, dependencies). "
-            "contract mode is the recommended default for AI coding agents."
+            "contract/minimal is the recommended default for AI coding agents."
         ),
     ),
     max_symbols: Optional[int] = typer.Option(
@@ -587,7 +589,7 @@ def main(
     _t0 = time.monotonic()
 
     # Validate new flag choices
-    _MODE_CHOICES = ("contract", "hybrid", "raw")
+    _MODE_CHOICES = ("contract", "minimal", "standard", "deep", "hybrid", "raw")
     if mode not in _MODE_CHOICES:
         typer.echo(
             f"Error: invalid value '{mode}' for --mode. Valid options: {', '.join(_MODE_CHOICES)}",
@@ -631,6 +633,13 @@ def main(
         typer.echo(f"Error: '{target}' is not a directory.", err=True)
         raise typer.Exit(code=1)
 
+    # Normalize mode aliases
+    _CONTRACT_MODES = frozenset({"contract", "minimal", "standard", "deep", "hybrid"})
+    if mode == "minimal":
+        mode = "contract"   # minimal is the canonical default contract rendering
+    elif mode not in _CONTRACT_MODES and mode != "raw":
+        mode = "contract"   # unknown → safe default
+
     # Legacy flags imply raw mode unless --mode was explicitly overridden.
     # These flags produce standard_view-only output sections not in contract_view.
     # Preserves backward compat: callers using any legacy flag get their previous format.
@@ -639,9 +648,17 @@ def main(
         compact or agent or tree or format == "yaml" or trace_pipeline
         or docs or semantics or graph_modules or full_metrics or architecture
     )
-    if mode == "contract" and _legacy_flags_active:
+    if mode in ("contract", "standard", "deep") and _legacy_flags_active:
         mode = "raw"
 
+    # Map mode to contract_view depth
+    _CONTRACT_DEPTH = {
+        "contract": "minimal",
+        "standard": "standard",
+        "deep": "deep",
+        "hybrid": "minimal",  # hybrid adds bodies via pipeline, minimal header
+    }
+
     # --- Import analysis modules ---
     from dataclasses import asdict, replace
 
@@ -1226,8 +1243,9 @@ def main(
                         ))
         sm = _replace(sm, pipeline_trace=_trace.build_trace())
 
-    # Contract pipeline — runs for mode=contract|hybrid (skip for raw)
-    if mode in ("contract", "hybrid"):
+    # Contract pipeline — runs for mode=contract|standard|deep|hybrid (skip for raw)
+    _is_contract_mode = mode in ("contract", "standard", "deep", "hybrid")
+    if _is_contract_mode:
         from sourcecode.contract_pipeline import ContractPipeline
         _cp = ContractPipeline()
         _contracts, _contract_summary = _cp.run(
@@ -1249,9 +1267,10 @@ def main(
             typer.echo(f"[contract] {len(_contracts)} files extracted ({_contract_summary.method_breakdown})", err=True)
 
     # 4. Serialize
-    if mode in ("contract", "hybrid"):
+    if _is_contract_mode:
         from sourcecode.serializer import contract_view as _contract_view
-        data = _contract_view(sm, emit_graph=emit_graph)
+        _depth = _CONTRACT_DEPTH.get(mode, "minimal")
+        data = _contract_view(sm, emit_graph=emit_graph, depth=_depth)
         if not no_redact:
             data = redact_dict(data)
         content = json.dumps(data, indent=2, ensure_ascii=False)

sourcecode/relevance_scorer.py

@@ -82,8 +82,30 @@ _AUXILIARY_DIR_PATTERNS: list[re.Pattern[str]] = [
     re.compile(r"(?:^|/)scripts?(?:/|$)"),
     re.compile(r"(?:^|/)tools?(?:/|$)"),
     re.compile(r"(?:^|/)ci(?:/|$)"),
+    re.compile(r"(?:^|/)migrations?(?:/|$)"),
+    re.compile(r"(?:^|/)generated?(?:/|$)"),
+    re.compile(r"(?:^|/)storybook(?:/|$)"),
+    re.compile(r"(?:^|/)stories(?:/|$)"),
 ]
 
+# Test file patterns — scored low, excluded from default contract output
+_TEST_FILE_PATTERNS: tuple[str, ...] = (
+    "_test.", ".test.", ".spec.", "test_", "conftest", "_spec.",
+)
+_TEST_DIR_MARKERS: frozenset[str] = frozenset({
+    "/test/", "/tests/", "/spec/", "/specs/", "/__tests__/", "/__mocks__/",
+})
+
+# Config/tooling filenames that are low runtime-relevance
+_LOW_RUNTIME_STEMS: frozenset[str] = frozenset({
+    "setup", "setup.cfg", "pyproject", "package", "package-lock",
+    "yarn.lock", "pnpm-lock", "composer", "gemfile", "podfile",
+    "dockerfile", "docker-compose", "makefile", "rakefile",
+    "gruntfile", "gulpfile", "webpack.config", "vite.config",
+    "rollup.config", "babel.config", "jest.config", "vitest.config",
+    "tsconfig", "jsconfig", ".eslintrc", ".prettierrc", ".editorconfig",
+})
+
 _HIGH_VALUE_SUFFIXES: frozenset[str] = frozenset({
     ".py", ".ts", ".tsx", ".js", ".jsx", ".mjs",
     ".go", ".java", ".kt", ".rs", ".rb", ".cs",
@@ -114,7 +136,7 @@ class RelevanceScorer:
 
         base = 0.3
 
-        # Package role boost
+        # Package role boost — runtime code scores high, tooling/docs low
         role = self._package_role(norm)
         role_boost = {
             "runtime_core": 0.4,
@@ -124,10 +146,10 @@ class RelevanceScorer:
             "composition_layer": 0.2,
             "plugin_package": 0.15,
             "infrastructure_layer": 0.15,
-            "tooling_layer": -0.1,
-            "docs_layer": -0.15,
-            "test_layer": 0.05,
-            "benchmark_layer": -0.2,
+            "tooling_layer": -0.15,
+            "docs_layer": -0.25,
+            "test_layer": -0.1,
+            "benchmark_layer": -0.25,
         }.get(role, 0.0)
         base += role_boost
 
@@ -141,7 +163,19 @@ class RelevanceScorer:
         if stem in _ENTRYPOINT_STEMS:
             base += 0.15
 
-        # Penalize auxiliary dirs
+        # Test file penalty — tests are useful for coverage but not for
+        # understanding architecture or editing production code
+        fname = Path(norm).name.lower()
+        if (any(m in f"/{norm}/" for m in _TEST_DIR_MARKERS)
+                or any(fname.startswith(p.strip(".")) or p in fname
+                       for p in _TEST_FILE_PATTERNS)):
+            base -= 0.25
+
+        # Config/tooling filename penalty
+        if stem.lower() in _LOW_RUNTIME_STEMS:
+            base -= 0.2
+
+        # Auxiliary dir penalty
         if self._is_auxiliary(norm):
             base -= 0.2
 

sourcecode/serializer.py

@@ -868,26 +868,266 @@ def contract_view(
     sm: SourceMap,
     *,
     emit_graph: bool = False,
+    depth: str = "minimal",
 ) -> dict[str, Any]:
-    """Contract-mode output: project context + per-file semantic contracts.
+    """Contract-mode output: project header + per-file semantic contracts.
 
-    Emits:
-      - Project identity (stacks, entry_points, summary)
-      - Per-file FileContracts ranked by relevance
-      - Optional dependency graph (--emit-graph)
-      - ContractSummary
+    depth="minimal" (default): compact header, filtered imports, no ranking
+      metadata, no per-file method/limitations. Smallest token footprint.
+    depth="standard": full per-file detail — imports, relevance scores,
+      fan metrics, extraction method. Current v0.33 behavior.
+    depth="deep": standard + optional analysis sections (deps, env, git).
 
-    Never includes: raw file contents, function bodies, implementation logic,
-    comments, formatting, or low-signal metadata.
+    Never includes: file bodies, function implementations, comments, or
+    low-signal metadata regardless of depth.
     """
-    from dataclasses import asdict as _asdict
+    contracts = sm.file_contracts or []
+
+    if depth == "minimal":
+        return _contract_view_minimal(sm, contracts, emit_graph=emit_graph)
+    if depth in ("standard", "deep"):
+        return _contract_view_standard(sm, contracts, emit_graph=emit_graph,
+                                       include_optional=(depth == "deep"))
+    return _contract_view_minimal(sm, contracts, emit_graph=emit_graph)
+
 
-    # ── Project context (compact) ────────────────────────────────────────────
+# ---------------------------------------------------------------------------
+# Minimal contract renderer — smallest token footprint
+# ---------------------------------------------------------------------------
+
+def _contract_view_minimal(
+    sm: SourceMap,
+    contracts: list[Any],
+    *,
+    emit_graph: bool = False,
+) -> dict[str, Any]:
+    """Minimal contract: project header + stripped per-file contracts."""
     primary = next((s for s in sm.stacks if s.primary), sm.stacks[0] if sm.stacks else None)
-    project: dict[str, Any] = {
-        "type": sm.project_type,
-        "summary": sm.project_summary,
+
+    # Entry point paths only (production)
+    ep_paths = sorted({
+        ep.path.replace("\\", "/")
+        for ep in sm.entry_points
+        if is_production_entry_point(ep)
+    })
+
+    project: dict[str, Any] = {"type": sm.project_type}
+    if primary:
+        project["stack"] = primary.stack
+        if primary.frameworks:
+            project["frameworks"] = [f.name for f in primary.frameworks]
+    if ep_paths:
+        project["entry_points"] = ep_paths
+    if sm.project_summary:
+        project["summary"] = sm.project_summary
+
+    result: dict[str, Any] = {
+        "schema_version": sm.metadata.schema_version,
+        "mode": "minimal",
+        "project": project,
     }
+
+    # Per-file contracts
+    if contracts:
+        serialized: list[dict[str, Any]] = []
+        for c in contracts:
+            item = _serialize_contract_minimal(c)
+            serialized.append(item)
+        result["contracts"] = serialized
+
+    # Optional analysis sections — included when the analyzer explicitly ran
+    # (user passed --dependencies, --env-map, --code-notes, --git-context)
+    if sm.dependency_summary is not None and sm.dependency_summary.requested:
+        dep_dict = asdict(sm.dependency_summary)
+        dep_dict.pop("dependencies", None)
+        result["dependency_summary"] = dep_dict
+        result["key_dependencies"] = [
+            {k: v for k, v in asdict(d).items() if v is not None and k != "parent"}
+            for d in sm.key_dependencies
+            if (d.role or "unknown") in _PRODUCTION_DEP_ROLES and d.scope not in {"dev"}
+        ]
+
+    if sm.env_summary is not None and sm.env_summary.requested:
+        result["env_summary"] = asdict(sm.env_summary)
+
+    if sm.code_notes_summary is not None and sm.code_notes_summary.requested:
+        result["code_notes_summary"] = asdict(sm.code_notes_summary)
+
+    if sm.git_context is not None and sm.git_context.requested:
+        result["git_context"] = asdict(sm.git_context)
+
+    # Optional graph (--emit-graph)
+    if emit_graph and contracts:
+        from sourcecode.contract_pipeline import build_dependency_graph
+        result["dependency_graph"] = build_dependency_graph(contracts)
+
+    # Compact summary
+    if sm.contract_summary is not None:
+        cs = sm.contract_summary
+        degraded = bool(cs.method_breakdown.get("heuristic", 0))
+        summary: dict[str, Any] = {
+            "files": cs.extracted_files,
+            "total": cs.total_files,
+        }
+        if cs.method_breakdown:
+            summary["methods"] = cs.method_breakdown
+        if degraded:
+            summary["degraded"] = True
+            summary["degraded_hint"] = "install sourcecode[ast] for full TS/JS extraction"
+        result["summary"] = summary
+
+    return result
+
+
+def _split_params(param_str: str) -> list[str]:
+    """Split parameter string at top-level commas."""
+    params: list[str] = []
+    depth = 0
+    current: list[str] = []
+    for ch in param_str:
+        if ch in "([{":
+            depth += 1
+            current.append(ch)
+        elif ch in ")]}":
+            depth -= 1
+            current.append(ch)
+        elif ch == "," and depth == 0:
+            p = "".join(current).strip()
+            if p:
+                params.append(p)
+            current = []
+        else:
+            current.append(ch)
+    if current:
+        p = "".join(current).strip()
+        if p:
+            params.append(p)
+    return params
+
+
+def _strip_param_default(param: str) -> str:
+    """Remove '= <default>' from a single parameter, keeping type annotation."""
+    depth = 0
+    for i, ch in enumerate(param):
+        if ch in "([{":
+            depth += 1
+        elif ch in ")]}":
+            depth -= 1
+        elif ch == "=" and depth == 0:
+            return param[:i].rstrip()
+    return param
+
+
+def _compress_sig(name: str, sig: str, max_len: int = 100) -> str:
+    """Compress a function signature — strip defaults, preserve type annotations."""
+    paren_start = sig.find("(")
+    if paren_start < 0:
+        full = f"{name}{sig}"
+        return full[:max_len - 3] + "..." if len(full) > max_len else full
+
+    # Find matching close paren
+    depth = 0
+    paren_end = -1
+    for i, ch in enumerate(sig[paren_start:], paren_start):
+        if ch == "(":
+            depth += 1
+        elif ch == ")":
+            depth -= 1
+            if depth == 0:
+                paren_end = i
+                break
+
+    if paren_end >= 0:
+        param_str = sig[paren_start + 1:paren_end]
+        ret_str = sig[paren_end + 1:]
+        clean_params = [_strip_param_default(p) for p in _split_params(param_str)]
+        full = f"{name}({', '.join(clean_params)}){ret_str}"
+    else:
+        # Truncated signature (e.g. 2000-char cap hit) — best-effort strip of visible params
+        visible = sig[paren_start + 1:]
+        partial = _split_params(visible)
+        clean_params = [_strip_param_default(p) for p in partial]
+        full = f"{name}({', '.join(clean_params)}"
+
+    if len(full) > max_len:
+        full = full[:max_len - 3] + "..."
+    return full
+
+
+def _serialize_contract_minimal(c: Any) -> dict[str, Any]:
+    """Serialize one FileContract to minimal format."""
+    item: dict[str, Any] = {"path": c.path, "role": c.role}
+
+    if c.is_changed:
+        item["changed"] = True
+
+    # Exports: flat string for functions/unknown, {name,k} for others
+    # When all exports are same non-function kind, group them
+    if c.exports:
+        exs: list[Any] = []
+        kinds = {e.kind for e in c.exports}
+        if len(kinds) == 1 and "function" not in kinds and "unknown" not in kinds:
+            # All same non-function kind — compact: {"k": "class", "names": [...]}
+            only_kind = next(iter(kinds))
+            exs = [{"k": only_kind, "names": sorted(e.name for e in c.exports)}]
+        else:
+            for e in sorted(c.exports, key=lambda e: e.name):
+                if e.kind in ("function", "unknown"):
+                    exs.append(e.name)
+                else:
+                    exs.append({"name": e.name, "k": e.kind})
+        item["exports"] = exs
+
+    # External deps (non-stdlib already filtered in extractor)
+    if c.dependencies:
+        item["deps"] = sorted(c.dependencies)
+
+    # Exported function signatures — compressed
+    exported_names = {e.name for e in c.exports}
+    if c.functions:
+        fns = []
+        for f in sorted(c.functions, key=lambda f: f.name):
+            if not (f.exported or f.name in exported_names):
+                continue
+            fns.append(_compress_sig(f.name, f.signature))
+        if fns:
+            item["fn"] = fns
+
+    # Types: skip if fully covered by exports (avoids duplication in model files)
+    if c.types:
+        export_names_set = {e.name for e in c.exports}
+        non_redundant = [t for t in c.types if t.name not in export_names_set]
+        if non_redundant:
+            item["types"] = [
+                {"name": t.name, "k": t.kind} if t.kind not in ("interface", "class") else t.name
+                for t in sorted(non_redundant, key=lambda t: t.name)
+            ]
+
+    # Hooks (TSX/JSX — usually short list)
+    if c.hooks_used:
+        item["hooks"] = c.hooks_used
+
+    return item
+
+
+# ---------------------------------------------------------------------------
+# Standard contract renderer — full per-file detail (v0.33 behavior)
+# ---------------------------------------------------------------------------
+
+def _contract_view_standard(
+    sm: SourceMap,
+    contracts: list[Any],
+    *,
+    emit_graph: bool = False,
+    include_optional: bool = False,
+) -> dict[str, Any]:
+    """Standard contract: full per-file detail — mirrors v0.33 output."""
+    from dataclasses import asdict as _asdict
+
+    primary = next((s for s in sm.stacks if s.primary), sm.stacks[0] if sm.stacks else None)
+    project: dict[str, Any] = {"type": sm.project_type}
+    if sm.project_summary:
+        project["summary"] = sm.project_summary
     if primary:
         project["primary_stack"] = primary.stack
         if primary.frameworks:
@@ -898,20 +1138,19 @@ def contract_view(
     ep_groups = _entry_point_groups(sm.entry_points)
 
     result: dict[str, Any] = {
-        # Keep metadata and top-level fields for backward compat with callers
-        # that inspect schema_version, stacks, project_type, project_summary.
-        "metadata": asdict(sm.metadata),
         "schema_version": sm.metadata.schema_version,
-        "mode": "contract",
-        "project_type": sm.project_type,
-        "project_summary": sm.project_summary,
-        "architecture_summary": sm.architecture_summary,
+        "mode": "standard",
         "project": project,
-        "stacks": [asdict(s) for s in sm.stacks],
+        "stacks": [
+            {"stack": s.stack, "primary": s.primary,
+             "frameworks": [f.name for f in (s.frameworks or [])],
+             "package_manager": s.package_manager}
+            for s in sm.stacks
+        ],
         "entry_points": ep_groups["production"],
     }
-    result["development_entry_points"] = ep_groups["development"]
-    result["auxiliary_entry_points"] = ep_groups["auxiliary"]
+    if ep_groups["development"]:
+        result["development_entry_points"] = ep_groups["development"]
 
     if sm.confidence_summary is not None:
         result["confidence"] = {
@@ -919,8 +1158,7 @@ def contract_view(
             "stack": sm.confidence_summary.stack_confidence,
         }
 
-    # ── File contracts ───────────────────────────────────────────────────────
-    contracts = sm.file_contracts  # list[FileContract]
+    # Per-file contracts (full detail)
     if contracts:
         serialized: list[dict[str, Any]] = []
         for c in contracts:
@@ -939,22 +1177,26 @@ def contract_view(
                 item["is_changed"] = True
             if c.exports:
                 item["exports"] = [
-                    {k: v for k, v in _asdict(e).items() if v is not None and v is not False and v != "unknown"}
+                    {k: v for k, v in _asdict(e).items()
+                     if v is not None and v is not False and v != "unknown"}
                     for e in c.exports
                 ]
             if c.imports:
                 item["imports"] = [
-                    {k: v for k, v in _asdict(i).items() if v is not None and v != [] and k != "kind" or v not in ("named", "side_effect")}
+                    {"source": i.source, "symbols": i.symbols}
+                    if i.symbols else {"source": i.source}
                     for i in c.imports
                 ]
             if c.functions:
                 item["functions"] = [
-                    {k: v for k, v in _asdict(f).items() if v is not None and v is not False and v != []}
+                    {k: v for k, v in _asdict(f).items()
+                     if v is not None and v is not False and v != []}
                     for f in c.functions
                 ]
             if c.types:
                 item["types"] = [
-                    {k: v for k, v in _asdict(t).items() if v is not None and v != [] and v != "unknown"}
+                    {k: v for k, v in _asdict(t).items()
+                     if v is not None and v != [] and v != "unknown"}
                     for t in c.types
                 ]
             if c.hooks_used:
@@ -967,35 +1209,28 @@ def contract_view(
             serialized.append(item)
         result["file_contracts"] = serialized
 
-    # ── Optional analysis sections (pass-through when analyzers ran) ─────────
-    # Include summary-level data from optional analyzers so that callers using
-    # --dependencies, --env-map, --code-notes alongside --mode contract
-    # still receive the expected keys in the output.
-    if sm.dependency_summary is not None and sm.dependency_summary.requested:
-        dep_dict = asdict(sm.dependency_summary)
-        dep_dict.pop("dependencies", None)
-        result["dependency_summary"] = dep_dict
-        result["key_dependencies"] = [
-            {k: v for k, v in asdict(d).items() if v is not None and k != "parent"}
-            for d in sm.key_dependencies
-            if (d.role or "unknown") in _PRODUCTION_DEP_ROLES and d.scope not in {"dev"}
-        ]
-
-    if sm.env_summary is not None and sm.env_summary.requested:
-        result["env_summary"] = asdict(sm.env_summary)
-
-    if sm.code_notes_summary is not None and sm.code_notes_summary.requested:
-        result["code_notes_summary"] = asdict(sm.code_notes_summary)
-
-    if sm.git_context is not None and sm.git_context.requested:
-        result["git_context"] = asdict(sm.git_context)
+    # Optional analysis sections (deep mode or when analyzers ran)
+    if include_optional:
+        if sm.dependency_summary is not None and sm.dependency_summary.requested:
+            dep_dict = asdict(sm.dependency_summary)
+            dep_dict.pop("dependencies", None)
+            result["dependency_summary"] = dep_dict
+            result["key_dependencies"] = [
+                {k: v for k, v in asdict(d).items() if v is not None and k != "parent"}
+                for d in sm.key_dependencies
+                if (d.role or "unknown") in _PRODUCTION_DEP_ROLES and d.scope not in {"dev"}
+            ]
+        if sm.env_summary is not None and sm.env_summary.requested:
+            result["env_summary"] = asdict(sm.env_summary)
+        if sm.code_notes_summary is not None and sm.code_notes_summary.requested:
+            result["code_notes_summary"] = asdict(sm.code_notes_summary)
+        if sm.git_context is not None and sm.git_context.requested:
+            result["git_context"] = asdict(sm.git_context)
 
-    # ── Dependency graph ─────────────────────────────────────────────────────
     if emit_graph and contracts:
         from sourcecode.contract_pipeline import build_dependency_graph
         result["dependency_graph"] = build_dependency_graph(contracts)
 
-    # ── Contract summary ─────────────────────────────────────────────────────
     if sm.contract_summary is not None:
         cs = sm.contract_summary
         result["contract_summary"] = {

{sourcecode-0.33.0.dist-info → sourcecode-0.34.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 0.33.0
+Version: 0.34.0
 Summary: Deterministic codebase context for AI coding agents
 License:                                  Apache License
                                    Version 2.0, January 2004

{sourcecode-0.33.0.dist-info → sourcecode-0.34.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
-sourcecode/__init__.py,sha256=WPrr-Lw7JGDFbBhRr-n0AhpquPRsep-3Xx2oy1zTpQE,103
+sourcecode/__init__.py,sha256=fYdoUeHpMCvt6KgjSCq7EwaVElY_1iqG4Ugp2NKdgxU,103
 sourcecode/architecture_analyzer.py,sha256=H6noGgVArUJ25z1qC0fFA0KvJJeHZYyhKvKSkOyWHUk,23096
 sourcecode/architecture_summary.py,sha256=rSY5MRiaz4N1YdG0pqDTDuFjSN7PO_Zplx-dtNzv2Yo,19985
-sourcecode/ast_extractor.py,sha256=KrxFpegjS_rWdBrdckx7smDly1UYtxxQtzoxkUt1DuE,36293
+sourcecode/ast_extractor.py,sha256=qiYWdXXdKpTVqTt2fRIHrkZJUTnpHPvPJKYchV_dnWE,39219
 sourcecode/classifier.py,sha256=GKTMN8qKZX7ponSwDJfN08RrasI4CVpq1_gFBgEopps,7093
-sourcecode/cli.py,sha256=C2Ix8dtV63eRP670nJWiafTj4PASyDBFzDzoAxLTV2I,62186
+sourcecode/cli.py,sha256=O1ObfcxvhMYMXjd6otx6G0fE9ethIAX4qDUpUUjOxgY,63167
 sourcecode/code_notes_analyzer.py,sha256=rRd8bFYV0krjlxxQV0wenwE9K7pVpUQSR7KvSvUQKw4,9226
 sourcecode/confidence_analyzer.py,sha256=HxJMPLI5ulqtkncnv98W4iVO6yMbpQo87VuxiuNbDmY,12167
 sourcecode/context_summarizer.py,sha256=CiQrfBEzun949bWvmLabWoj2HhPn6Lw62ofqnsy0FlQ,6503
@@ -20,12 +20,12 @@ sourcecode/graph_analyzer.py,sha256=hMOsLLz9B0UnQ4xwbHdgr3bFvqpw0bQ8kN-xmEn3Krk,
 sourcecode/metrics_analyzer.py,sha256=4uh11v-Q0gdrN87BOxuFWUym3N3AOkOuy21K5N8peB8,20126
 sourcecode/prepare_context.py,sha256=vxEzr8czS3MFbdTx4hBJQlJLrl9cuvbHdL3ZokxFkvo,31384
 sourcecode/redactor.py,sha256=xuGcadGEHaPw4qZXlMDvzMCsr4VOkdp3oBQptHyJk8c,2884
-sourcecode/relevance_scorer.py,sha256=2yvxDFnz9YGrHEJubgx9soiVIDZHKv_pntOtTARtKow,5928
+sourcecode/relevance_scorer.py,sha256=w-vOYcTWB-c2OAi8F5-y16ZB1QMPPtvxUNJnMrzGKCo,7470
 sourcecode/runtime_classifier.py,sha256=zWX3r3HCKHc-qtIobErOa8aKMmaoPYREtJKvPcBGPjQ,14792
 sourcecode/scanner.py,sha256=aM3h9-DCQ3xKpeHpHYdo2vX6T5P95HA_YwZbkAVNwmo,8288
 sourcecode/schema.py,sha256=AShu_bcP30TYaw4Dl1nYy8aFnBCKxrUli3LhU3MZTjs,20739
 sourcecode/semantic_analyzer.py,sha256=asQfJf-EhzYaOTA-iMuZsrVXtbW7SV2WEKCxgsxa88Y,79413
-sourcecode/serializer.py,sha256=55Prw0BhSC3CD0IAuhpvhEHaTuvLu38Rb1iRf89g0wU,42169
+sourcecode/serializer.py,sha256=en11Au-YhpO1hYPugbCCPNvHkqBiTSRuGVoiLxDAKeQ,49888
 sourcecode/summarizer.py,sha256=ZuzIdm3t8A-d5MuQL0TSNLrd-L0IQIuguIxeNXMNJf8,16070
 sourcecode/tree_utils.py,sha256=Fj9OIuUksBvgibNd3feog0sMDjVypJzPexp5lvMoYWI,1424
 sourcecode/workspace.py,sha256=fQlVoNx8S-fSHpKoJ0JBvEHCFkxszH0KZVJed1i3TRk,6845
@@ -56,8 +56,8 @@ sourcecode/telemetry/consent.py,sha256=wLMvGNJeSSyZoNkQXpoUioY6mMv4Qdvuw7S9jAEWn
 sourcecode/telemetry/events.py,sha256=oEvvulfsv5GIDWG2174gSS6tNB95w38AIYiYeifGKlE,2294
 sourcecode/telemetry/filters.py,sha256=Asa71oRl7q3Wt_FMwuufIZJFzSYdgRNKS8LHCIyFeYE,4805
 sourcecode/telemetry/transport.py,sha256=KJeIPCPWMdmbCP3ySGs2iUlia34U6vWne2dZsUezesw,1560
-sourcecode-0.33.0.dist-info/METADATA,sha256=5XU8eGZ_tBs3f4xl5PW9FUU4ciT1ZovvbVjDnf7Q-50,25209
-sourcecode-0.33.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-0.33.0.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
-sourcecode-0.33.0.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
-sourcecode-0.33.0.dist-info/RECORD,,
+sourcecode-0.34.0.dist-info/METADATA,sha256=Xg-K2zPoLVH0BfwsjhgqyFyVamkBsPfp6o8mxZdl-HY,25209
+sourcecode-0.34.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-0.34.0.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
+sourcecode-0.34.0.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
+sourcecode-0.34.0.dist-info/RECORD,,