sourcecode 0.35.0__tar.gz → 0.37.0__tar.gz

{sourcecode-0.35.0 → sourcecode-0.37.0}/PKG-INFO

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

{sourcecode-0.35.0 → sourcecode-0.37.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sourcecode"
-version = "0.35.0"
+version = "0.37.0"
 description = "Deterministic codebase context for AI coding agents"
 readme = "README.md"
 requires-python = ">=3.9"

{sourcecode-0.35.0 → sourcecode-0.37.0}/src/sourcecode/__init__.py

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

{sourcecode-0.35.0 → sourcecode-0.37.0}/src/sourcecode/ast_extractor.py

@@ -296,11 +296,20 @@ def _ts_exports(root: Any, src: bytes) -> list[ExportRecord]:
                 handled = True
 
         if not handled and is_default:
-            # export default <expression>
+            # export default <expression> — preserve local binding name when available
             for child in node.children:
                 if child.type not in ("export", "default", ";") and not child.type.startswith("comment"):
-                    name_n = _find_child(child, "identifier", "type_identifier")
-                    name = _text(name_n, src) if name_n else "default"
+                    if child.type in ("identifier", "type_identifier"):
+                        # export default app  →  name="app"
+                        name = _text(child, src)
+                    elif child.type == "call_expression":
+                        # export default defineConfig({})  →  name="defineConfig"
+                        fn_n = _find_child(child, "identifier")
+                        name = _text(fn_n, src) if fn_n else "default"
+                    else:
+                        # object/array/other expression — look one level deep
+                        name_n = _find_child(child, "identifier", "type_identifier")
+                        name = _text(name_n, src) if name_n else "default"
                     records.append(ExportRecord(name=name, kind="default"))
                     break
 
@@ -692,7 +701,7 @@ def _heuristic_ts_types(source: str) -> list[TypeDefinition]:
     return types
 
 
-def _extract_ts_js_heuristic(path: str, source: str, language: str) -> FileContract:
+def _extract_ts_js_heuristic(path: str, source: str, language: str, *, ts_installed: bool = False) -> FileContract:
     imports = _heuristic_ts_imports(source)
     exports = _heuristic_ts_exports(source)
     exported_names = {e.name for e in exports}
@@ -711,6 +720,12 @@ def _extract_ts_js_heuristic(path: str, source: str, language: str) -> FileContr
         if not imp.source.startswith(".") and not imp.source.startswith("/")
     })
 
+    # Distinguish "tree-sitter absent" from "language parser not loaded"
+    if ts_installed:
+        lim = f"ts_lang_missing: tree-sitter parser for {language!r} not loaded; install sourcecode[ast]"
+    else:
+        lim = "tree_sitter_unavailable: install sourcecode[ast] for full TS/JS extraction"
+
     return FileContract(
         path=path,
         language=language,
@@ -721,7 +736,7 @@ def _extract_ts_js_heuristic(path: str, source: str, language: str) -> FileContr
         hooks_used=hooks_used,
         dependencies=deps,
         extraction_method="heuristic",
-        limitations=["tree_sitter_unavailable: install sourcecode[ast] for full TS/JS extraction"],
+        limitations=[lim],
     )
 
 
@@ -1039,7 +1054,7 @@ class AstExtractor:
                 if lang_obj is not None:
                     contract = _extract_ts_js_tree_sitter(rel_path, source, lang_obj, language)
                 else:
-                    contract = _extract_ts_js_heuristic(rel_path, source, language)
+                    contract = _extract_ts_js_heuristic(rel_path, source, language, ts_installed=True)
             else:
                 contract = _extract_ts_js_heuristic(rel_path, source, language)
 

{sourcecode-0.35.0 → sourcecode-0.37.0}/src/sourcecode/cli.py

@@ -384,7 +384,8 @@ def main(
     no_tree: bool = typer.Option(
         False,
         "--no-tree",
-        help="(Deprecated) Previously suppressed file_tree. The file tree is excluded by default — this flag is now a no-op. Use --tree to include the file tree.",
+        hidden=True,
+        help="(Removed) No-op. File tree is excluded by default. Use --tree to include it.",
     ),
     tree: bool = typer.Option(
         False,
@@ -516,13 +517,13 @@ def main(
         "contract",
         "--mode",
         help=(
-            "Output mode: contract|minimal (default) | standard | deep | hybrid | raw. "
-            "contract/minimal: minimal per-file contracts — exports, signatures, deps. Smallest output. "
+            "Output mode: contract (default) | standard | raw. "
+            "contract: minimal per-file contracts — exports, signatures, deps. "
+            "Smallest output, recommended for AI agents. "
+            "minimal is accepted as an alias for contract. "
             "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/minimal is the recommended default for AI coding agents."
+            "raw: project-level analysis only (stacks, entry points, dependency summary). "
+            "No per-file contracts."
         ),
     ),
     max_symbols: Optional[int] = typer.Option(
@@ -534,7 +535,8 @@ def main(
     dependency_depth: int = typer.Option(
         0,
         "--dependency-depth",
-        help="Transitive import traversal depth for contract mode (0 = direct only, N = follow N levels).",
+        hidden=True,
+        help="(Removed) Transitive resolution is not implemented. Pass 0 or omit.",
         min=0,
         max=5,
     ),
@@ -561,7 +563,8 @@ def main(
     compress_types: bool = typer.Option(
         False,
         "--compress-types",
-        help="Contract mode: abbreviate verbose type signatures (React.FC → FC, Promise<X> stays).",
+        hidden=True,
+        help="(Removed) No observable effect when type signatures are not extracted. Omit.",
     ),
     symbol: Optional[str] = typer.Option(
         None,
@@ -589,8 +592,20 @@ def main(
     _t0 = time.monotonic()
 
     # Validate new flag choices
-    _MODE_CHOICES = ("contract", "minimal", "standard", "deep", "hybrid", "raw")
-    if mode not in _MODE_CHOICES:
+    _MODE_CHOICES = ("contract", "minimal", "standard", "raw")
+    _DEPRECATED_MODES: dict[str, str] = {
+        "hybrid": "contract",
+        "deep": "standard",
+    }
+    if mode in _DEPRECATED_MODES:
+        fallback = _DEPRECATED_MODES[mode]
+        typer.echo(
+            f"[deprecated] --mode {mode} is removed: produced identical output to --mode {fallback}. "
+            f"Using --mode {fallback}.",
+            err=True,
+        )
+        mode = fallback
+    elif mode not in _MODE_CHOICES:
         typer.echo(
             f"Error: invalid value '{mode}' for --mode. Valid options: {', '.join(_MODE_CHOICES)}",
             err=True,
@@ -604,6 +619,22 @@ def main(
         )
         raise typer.Exit(code=1)
 
+    if dependency_depth > 0:
+        typer.echo(
+            f"[warning] --dependency-depth {dependency_depth} has no effect: "
+            "transitive import resolution is not implemented for npm/yarn/pip projects. "
+            "Using depth=0 (direct dependencies only).",
+            err=True,
+        )
+        dependency_depth = 0
+
+    if compress_types:
+        typer.echo(
+            "[deprecated] --compress-types is removed: type signatures are rarely extracted "
+            "at default depth. Flag ignored.",
+            err=True,
+        )
+
     # Validate format choices
     if format not in FORMAT_CHOICES:
         typer.echo(
@@ -634,9 +665,9 @@ def main(
         raise typer.Exit(code=1)
 
     # Normalize mode aliases
-    _CONTRACT_MODES = frozenset({"contract", "minimal", "standard", "deep", "hybrid"})
+    _CONTRACT_MODES = frozenset({"contract", "minimal", "standard"})
     if mode == "minimal":
-        mode = "contract"   # minimal is the canonical default contract rendering
+        mode = "contract"   # minimal is a documented alias for contract
     elif mode not in _CONTRACT_MODES and mode != "raw":
         mode = "contract"   # unknown → safe default
 
@@ -648,15 +679,13 @@ 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 in ("contract", "standard", "deep") and _legacy_flags_active:
+    if mode in ("contract", "standard") 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 ---
@@ -746,6 +775,19 @@ def main(
     detector = ProjectDetector(build_default_detectors())
     workspace_analysis = WorkspaceAnalyzer().analyze(target, manifests)
 
+    # Warn when scanning a monorepo at default depth — typical package sources
+    # (packages/*/src/) live at depth 5+, so default depth=4 silently misses them.
+    # Only emit to TTY to avoid contaminating piped/CI output; agents read analysis_gaps.
+    import sys as _sys
+    if workspace_analysis.is_monorepo and depth <= 4 and effective_depth <= 4:
+        if _sys.stderr.isatty():
+            typer.echo(
+                f"[warning] monorepo detected with --depth {depth}. "
+                "Source files in packages/*/src/ (depth 5+) may be invisible. "
+                "Use --depth 6 or higher for full coverage.",
+                err=True,
+            )
+
     # --compact implicitly enables lightweight analysis passes so that
     # dependency_summary, env_summary and code_notes_summary are never null.
     if compact:
@@ -1244,7 +1286,7 @@ def main(
         sm = _replace(sm, pipeline_trace=_trace.build_trace())
 
     # Contract pipeline — runs for mode=contract|standard|deep|hybrid (skip for raw)
-    _is_contract_mode = mode in ("contract", "standard", "deep", "hybrid")
+    _is_contract_mode = mode in ("contract", "standard")
     if _is_contract_mode:
         from sourcecode.contract_pipeline import ContractPipeline
         _cp = ContractPipeline()
@@ -1263,6 +1305,13 @@ def main(
             compress_types=compress_types,
         )
         sm = _replace(sm, file_contracts=_contracts, contract_summary=_contract_summary)
+        if symbol is not None and len(_contracts) == 0:
+            typer.echo(
+                f"[warning] --symbol '{symbol}' matched 0 files. "
+                "The symbol may not exist at the current --depth, or the name may differ in case. "
+                "Try --depth 8 or verify the symbol name.",
+                err=True,
+            )
         if agent:
             typer.echo(f"[contract] {len(_contracts)} files extracted ({_contract_summary.method_breakdown})", err=True)
 

{sourcecode-0.35.0 → sourcecode-0.37.0}/src/sourcecode/contract_pipeline.py

@@ -8,6 +8,8 @@ Produces a list of FileContracts ranked by semantic importance,
 with fan-in/fan-out computed from the import graph.
 """
 
+import os
+import re
 import subprocess
 from collections import Counter
 from pathlib import Path
@@ -275,6 +277,16 @@ class ContractPipeline:
         # 8. Symbol filter — keep files that define or import the symbol
         if symbol:
             contracts = _filter_by_symbol(contracts, symbol)
+            # When shallow scan missed the defining file (deep monorepo), fall back
+            # to a grep-based filesystem search over the full directory tree.
+            if not contracts:
+                contracts = self._symbol_deep_scan(
+                    root, symbol,
+                    known_paths=set(src_paths),
+                    entry_paths=entry_paths,
+                    changed_files=changed_files,
+                    scorer=scorer,
+                )
 
         # 9. Entrypoints-only filter
         if entrypoints_only and not symbol:
@@ -340,6 +352,38 @@ class ContractPipeline:
         # Default: relevance
         return sorted(contracts, key=lambda c: (-c.is_entrypoint, -c.relevance_score))
 
+    def _symbol_deep_scan(
+        self,
+        root: Path,
+        symbol: str,
+        known_paths: set[str],
+        entry_paths: set[str],
+        changed_files: set[str],
+        scorer: RelevanceScorer,
+    ) -> list[FileContract]:
+        """Grep-based fallback when the shallow scan missed the defining files.
+
+        Searches the full directory tree for source files containing *symbol*,
+        extracts contracts for candidates not already processed, then re-applies
+        the symbol filter. Fan-in/fan-out are not computed for these contracts.
+        """
+        candidates = _find_symbol_files(root, symbol, known_paths, scorer)
+        if not candidates:
+            return []
+
+        extra: list[FileContract] = []
+        for rel_path in candidates[:300]:  # cap to prevent excessive extraction
+            abs_path = root / rel_path
+            contract = self._extractor.extract(abs_path, root)
+            if contract is None:
+                continue
+            contract.is_entrypoint = rel_path in entry_paths
+            contract.is_changed = rel_path in changed_files
+            contract.relevance_score = scorer.score(rel_path)
+            extra.append(contract)
+
+        return _filter_by_symbol(extra, symbol)
+
 
 # ---------------------------------------------------------------------------
 # Helpers
@@ -354,7 +398,6 @@ def _compress_contract_types(c: FileContract) -> None:
         (r"React\.ReactNode", "ReactNode"),
         (r"React\.ReactElement", "ReactElement"),
     ]
-    import re
     for fn in c.functions:
         for pattern, repl in _replacements:
             fn.signature = re.sub(pattern, repl, fn.signature)
@@ -396,41 +439,155 @@ def _limit_symbols(contracts: list[FileContract], max_symbols: int) -> list[File
 # ---------------------------------------------------------------------------
 
 def _filter_by_symbol(contracts: list[FileContract], symbol: str) -> list[FileContract]:
-    """Return contracts that define or import *symbol*.
+    """Return contracts that define, import, or structurally reference *symbol*.
 
-    Matching strategy:
-    1. Exact match on export/function/type names.
-    2. Case-insensitive fallback when exact match yields nothing.
-    3. Importer contracts: files that name the symbol in their imports.
+    Four tiers applied in order:
+    1. Exact name match — export/function/type names.
+    2. Case-insensitive name match when tier 1 yields nothing.
+    3. Import symbol match — name appears in import symbol list.
+    4. Type-reference match — symbol in extends clauses, field types, or
+       function signatures (word-boundary). Only used when tiers 1-3 fail.
 
-    Defining contracts are ranked first; importers follow.
+    Defining contracts are ranked first; importers and references follow.
     """
-    def _defines(c: FileContract, sym: str, case: bool) -> bool:
+    sym_l = symbol.lower()
+    word_re = re.compile(
+        r"(?<![A-Za-z0-9_])" + re.escape(symbol) + r"(?![A-Za-z0-9_])",
+        re.IGNORECASE,
+    )
+
+    def _defines(c: FileContract, case: bool) -> bool:
         cmp = (lambda a, b: a.lower() == b.lower()) if case else (lambda a, b: a == b)
         return (
-            any(cmp(e.name, sym) for e in c.exports)
-            or any(cmp(f.name, sym) for f in c.functions)
-            or any(cmp(t.name, sym) for t in c.types)
+            any(cmp(e.name, symbol) for e in c.exports)
+            or any(cmp(f.name, symbol) for f in c.functions)
+            or any(cmp(t.name, symbol) for t in c.types)
         )
 
-    def _imports(c: FileContract, sym: str, case: bool) -> bool:
+    def _imports_sym(c: FileContract, case: bool) -> bool:
         if case:
-            sym_l = sym.lower()
             return any(sym_l == s.lower() for imp in c.imports for s in imp.symbols)
-        return any(sym in imp.symbols for imp in c.imports)
+        return any(symbol in imp.symbols for imp in c.imports)
+
+    def _references_type(c: FileContract) -> bool:
+        """Tier 4: symbol appears in extends clauses, field types, or signatures."""
+        for t in c.types:
+            if any(sym_l in ext.lower() for ext in t.extends):
+                return True
+            for field in t.fields:
+                if sym_l in field.type.lower():
+                    return True
+        for f in c.functions:
+            if word_re.search(f.signature):
+                return True
+        return False
 
-    # Exact match first
-    defining = [c for c in contracts if _defines(c, symbol, case=False)]
+    # Tier 1: exact name match
+    defining = [c for c in contracts if _defines(c, case=False)]
+    # Tier 2: case-insensitive name match
     if not defining:
-        defining = [c for c in contracts if _defines(c, symbol, case=True)]
+        defining = [c for c in contracts if _defines(c, case=True)]
 
-    importer_paths = {c.path for c in contracts if _imports(c, symbol, case=len(defining) == 0)}
-    # Exclude files already in defining set
     defining_paths = {c.path for c in defining}
+
+    # Tier 3: import matching (case-insensitive when no definers found)
+    ci_imports = len(defining) == 0
+    importer_paths = {c.path for c in contracts if _imports_sym(c, case=ci_imports)}
     importers = [c for c in contracts if c.path in importer_paths and c.path not in defining_paths]
 
-    merged = list({c.path: c for c in defining + importers}.values())
-    return sorted(merged, key=lambda c: (c.path not in defining_paths, -c.relevance_score))
+    # Tier 4: type-reference matching (only when tiers 1-3 yield nothing)
+    references: list[FileContract] = []
+    if not defining and not importers:
+        ref_paths = {c.path for c in contracts if _references_type(c)}
+        references = [c for c in contracts if c.path in ref_paths]
+
+    # Merge in priority order: defining > importers > type-references
+    seen: set[str] = set()
+    merged: list[FileContract] = []
+    for c in defining + importers + references:
+        if c.path not in seen:
+            seen.add(c.path)
+            merged.append(c)
+
+    return sorted(merged, key=lambda c: (
+        c.path not in defining_paths,
+        c.path not in importer_paths,
+        -c.relevance_score,
+    ))
+
+
+# ---------------------------------------------------------------------------
+# Deep symbol scan — grep-based fallback for shallow-scanned repos
+# ---------------------------------------------------------------------------
+
+_DEEP_SCAN_NOISE_DIRS: frozenset[str] = frozenset({
+    "node_modules", ".git", "dist", "build", "__pycache__",
+    ".venv", "venv", "target", ".next", ".nuxt", ".turbo", "coverage",
+    ".nyc_output", ".mypy_cache", ".pytest_cache",
+})
+
+
+def _find_symbol_files(
+    root: Path,
+    symbol: str,
+    known_paths: set[str],
+    scorer: RelevanceScorer,
+) -> list[str]:
+    """Find source files outside *known_paths* that contain *symbol* as text.
+
+    Uses subprocess grep when available (fast); falls back to os.walk + read.
+    Returns repo-relative paths, noise-filtered.
+    """
+    found: list[str] = []
+
+    # Try grep (fast, available on Linux/Mac)
+    try:
+        result = subprocess.run(
+            [
+                "grep", "-rl",
+                "--include=*.ts", "--include=*.tsx",
+                "--include=*.js", "--include=*.jsx",
+                "--include=*.py",
+                symbol, ".",
+            ],
+            cwd=str(root),
+            capture_output=True,
+            text=True,
+            timeout=20,
+        )
+        for line in result.stdout.splitlines():
+            line = line.strip()
+            if line.startswith("./"):
+                line = line[2:]
+            line = line.replace("\\", "/")
+            if line and line not in known_paths and not scorer.is_noise(line):
+                found.append(line)
+        return found
+    except Exception:
+        pass
+
+    # Python fallback — os.walk + text search
+    for dirpath, dirnames, filenames in os.walk(str(root)):
+        dirnames[:] = sorted(d for d in dirnames if d not in _DEEP_SCAN_NOISE_DIRS)
+        for fname in filenames:
+            if Path(fname).suffix.lower() not in _SRC_EXTENSIONS:
+                continue
+            full = os.path.join(dirpath, fname)
+            try:
+                rel = Path(full).relative_to(root)
+                rel_str = str(rel).replace("\\", "/")
+            except ValueError:
+                continue
+            if rel_str in known_paths or scorer.is_noise(rel_str):
+                continue
+            try:
+                content = Path(full).read_text(encoding="utf-8", errors="replace")
+                if symbol in content:
+                    found.append(rel_str)
+            except OSError:
+                pass
+
+    return found
 
 
 # ---------------------------------------------------------------------------

{sourcecode-0.35.0 → sourcecode-0.37.0}/src/sourcecode/git_analyzer.py

@@ -198,6 +198,13 @@ def _is_hotspot_admin(path: str) -> bool:
     for suffix in _HOTSPOT_ADMIN_SUFFIXES:
         if filename.endswith(suffix):
             return True
+    # Localized changelogs: CHANGELOG.zh-CN.md, CHANGES.en-US.md, etc.
+    _lower = filename.lower()
+    if _lower.startswith("changelog.") or _lower.startswith("changes."):
+        return True
+    # lerna.json and root-level package.json are modified by version bumps, not dev work
+    if filename in ("lerna.json",):
+        return True
     return False
 
 

{sourcecode-0.35.0 → sourcecode-0.37.0}/src/sourcecode/metrics_analyzer.py

@@ -219,6 +219,16 @@ class MetricsAnalyzer:
             if fm.language != "unknown":
                 languages.add(fm.language)
 
+        # Emit explicit limitation when JS/TS files are present but complexity is unavailable.
+        # This prevents agents from assuming null complexity means "no functions found".
+        _js_ts_count = sum(1 for r in records if r.language in ("javascript", "typescript") and r.complexity_availability == "unavailable")
+        if _js_ts_count > 0:
+            limitations.append(
+                f"cyclomatic_complexity_unavailable: {_js_ts_count} JS/TS file(s) — "
+                "complexity requires tree-sitter (pip install 'sourcecode[ast]'). "
+                "null complexity fields are expected, not an error."
+            )
+
         summary = MetricsSummary(
             requested=True,
             file_count=len(records),

{sourcecode-0.35.0 → sourcecode-0.37.0}/src/sourcecode/serializer.py

@@ -923,7 +923,7 @@ def _contract_view_minimal(
 
     result: dict[str, Any] = {
         "schema_version": sm.metadata.schema_version,
-        "mode": "minimal",
+        "mode": "contract",
         "project": project,
     }
 
@@ -949,9 +949,28 @@ def _contract_view_minimal(
 
     if sm.env_summary is not None and sm.env_summary.requested:
         result["env_summary"] = asdict(sm.env_summary)
+        if sm.env_map:
+            # Include top-20 env entries sorted by required first, then name.
+            # Agents read the summary count but need the actual keys to act on them.
+            _sorted_env = sorted(sm.env_map, key=lambda e: (not getattr(e, "required", False), getattr(e, "name", "")))
+            result["env_map"] = [
+                {k: v for k, v in asdict(e).items() if v is not None and v != ""}
+                for e in _sorted_env[:20]
+            ]
 
     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.code_notes:
+            # Include top-20 notes by severity: BUG > FIXME > DEPRECATED > TODO > others.
+            _SEVERITY_ORDER = {"BUG": 0, "FIXME": 1, "DEPRECATED": 2, "TODO": 3, "HACK": 4, "WARNING": 5}
+            _sorted_notes = sorted(
+                sm.code_notes,
+                key=lambda n: (_SEVERITY_ORDER.get(getattr(n, "kind", "").upper(), 9), getattr(n, "path", "")),
+            )
+            result["code_notes"] = [
+                {k: v for k, v in asdict(n).items() if v is not None and v != ""}
+                for n in _sorted_notes[:20]
+            ]
 
     if sm.git_context is not None and sm.git_context.requested:
         result["git_context"] = asdict(sm.git_context)

{sourcecode-0.35.0 → sourcecode-0.37.0}/tests/test_contract_pipeline.py

@@ -160,7 +160,7 @@ def test_cli_contract_mode_default(tmp_path: Path) -> None:
     assert result.exit_code == 0, result.output
     data = json.loads(result.output)
     # Default contract mode renders as minimal
-    assert data["mode"] == "minimal"
+    assert data["mode"] == "contract"
     assert "contracts" in data
     assert "project" in data
     assert "schema_version" in data
@@ -174,7 +174,7 @@ def test_cli_contract_mode_explicit(tmp_path: Path) -> None:
     assert result.exit_code == 0, result.output
     data = json.loads(result.output)
     # --mode contract is an alias for minimal
-    assert data["mode"] == "minimal"
+    assert data["mode"] == "contract"
     assert isinstance(data["contracts"], list)
 
 

{sourcecode-0.35.0 → sourcecode-0.37.0}/tests/test_integration.py

@@ -31,7 +31,7 @@ def test_full_json_output(tmp_project: Path):
     data = json.loads(result.output)
     # Default mode is minimal contract — compact header + per-file contracts
     assert data["schema_version"] == "1.0"
-    assert data["mode"] == "minimal"
+    assert data["mode"] == "contract"
     assert "file_tree" not in data
     assert data["project"]["type"] == "cli"
     assert "contracts" in data