python-delphi-lsp 3.2.1__tar.gz → 3.2.2__tar.gz

{python_delphi_lsp-3.2.1/python_delphi_lsp.egg-info → python_delphi_lsp-3.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-delphi-lsp
-Version: 3.2.1
+Version: 3.2.2
 Summary: Python Delphi/Object Pascal parser, semantic indexer, and language server.
 Author: Dark Light
 License-Expression: MPL-2.0
@@ -45,7 +45,7 @@ Dynamic: license-file
 
 `python-delphi-lsp` parses Delphi/Object Pascal, builds semantic and project
 indexes, serves LSP, and provides bounded codebase navigation for agents.
-Version 3.2.1 is authored by Dark Light and supports Windows, macOS, and Linux.
+Version 3.2.2 is authored by Dark Light and supports Windows, macOS, and Linux.
 
 ## Install and quick start
 
@@ -226,7 +226,8 @@ delphi-lsp-agent worker --root PATH [--project-file FILE] [--workers auto|N]
 ```
 
 `--deep-projects` opts into per-project dependency parsing for the `projects`
-layer. It is off by default because it dominates run time on real repositories:
+and `problems` layers. It is off by default because it dominates run time on
+real repositories:
 on a 60-project corpus it cost 36.9 s against 1.0 s for the same index, and it
 adds nothing to the unit model set. Without it the `projects` and `problems`
 layers report `deep_indexed: false`, and `index` records `deep_projects` at the

{python_delphi_lsp-3.2.1 → python_delphi_lsp-3.2.2}/README.md

@@ -2,7 +2,7 @@
 
 `python-delphi-lsp` parses Delphi/Object Pascal, builds semantic and project
 indexes, serves LSP, and provides bounded codebase navigation for agents.
-Version 3.2.1 is authored by Dark Light and supports Windows, macOS, and Linux.
+Version 3.2.2 is authored by Dark Light and supports Windows, macOS, and Linux.
 
 ## Install and quick start
 
@@ -183,7 +183,8 @@ delphi-lsp-agent worker --root PATH [--project-file FILE] [--workers auto|N]
 ```
 
 `--deep-projects` opts into per-project dependency parsing for the `projects`
-layer. It is off by default because it dominates run time on real repositories:
+and `problems` layers. It is off by default because it dominates run time on
+real repositories:
 on a 60-project corpus it cost 36.9 s against 1.0 s for the same index, and it
 adds nothing to the unit model set. Without it the `projects` and `problems`
 layers report `deep_indexed: false`, and `index` records `deep_projects` at the

python_delphi_lsp-3.2.2/delphi_lsp/_version.py

@@ -0,0 +1 @@
+__version__ = "3.2.2"

{python_delphi_lsp-3.2.1 → python_delphi_lsp-3.2.2}/delphi_lsp/agent_cli.py

@@ -320,7 +320,7 @@ def _view(args: argparse.Namespace) -> None:
     index = build_codebase_index(
         args.root,
         project_file=args.project_file,
-        index_projects=args.deep_projects or args.layer == "problems",
+        index_projects=args.deep_projects,
         workers=args.workers,
     )
     sys.stdout.write(render_layer(index, args.layer, query=args.query, output_format=args.format))

python_delphi_lsp-3.2.2/docs/release-3.2.2.md

@@ -0,0 +1,52 @@
+# Python Delphi LSP 3.2.2
+
+Version 3.2.2 is a backwards-compatible patch release. It fixes the remaining
+CLI performance defect in `view --layer problems` and adds ground-truth content
+tests for the agent-facing CLI.
+
+## `view --layer problems` no longer forces deep indexing
+
+Python Delphi LSP 3.2.1 made the expensive per-project dependency pass opt-in
+for `index`, but the `problems` view still enabled that pass unconditionally.
+The view therefore paid the full deep-index cost even when callers only needed
+the discovery findings.
+
+Measured before and after on the same Apple M4 machine:
+
+| Corpus | 3.2.1 | 3.2.2 |
+|---|---:|---:|
+| python4delphi | 43.66 s | 0.57 s |
+| mORMot2 | 24.4 s | 2.24 s |
+
+The default view still preserves all discovery problems. On mORMot2 that is
+all 228 reported items. Its payload now states `deep_indexed: false`, making
+the scope explicit instead of implying that project parsing ran.
+
+Callers that need project-parse problems can pass `--deep-projects`. That
+restores the original deep pass and marks the payload `deep_indexed: true`; the
+reference python4delphi run reports 2,854 items in approximately 42.7 seconds.
+
+## Ground-truth CLI verification
+
+`tests/test_agent_cli_content.py` builds a small, hand-authored Pascal
+workspace and checks content rather than merely checking exit codes or item
+counts. It verifies:
+
+- the exact unit, symbol, member, and cross-unit symbol-location sets;
+- empty results for a symbol name absent from the fixture;
+- the intentionally broken unit's exact deep-project diagnostic;
+- shallow and deep completeness markers;
+- the exact top-level `index` document contract and hand-counted unit total;
+- Markdown names, stable CLI error prefixes, and native path separators; and
+- one opt-in DUnitX occurrence against a hand-verified source line.
+
+The path-invariance test runs on every supported OS. Windows itself was not
+executed during the local release run; the next pushed CI matrix remains the
+direct Windows verification.
+
+## Verification
+
+The release gates run the standard suite in two environments, enforce the
+existing Ruff and mypy debt ceilings, repeat the real-corpus CLI and wiki
+regression measurements, inspect both distribution artifacts, and execute a
+clean-room functional check from the built wheel.

{python_delphi_lsp-3.2.1 → python_delphi_lsp-3.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-delphi-lsp"
-version = "3.2.1"
+version = "3.2.2"
 description = "Python Delphi/Object Pascal parser, semantic indexer, and language server."
 readme = "README.md"
 requires-python = ">=3.10"

{python_delphi_lsp-3.2.1 → python_delphi_lsp-3.2.2/python_delphi_lsp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-delphi-lsp
-Version: 3.2.1
+Version: 3.2.2
 Summary: Python Delphi/Object Pascal parser, semantic indexer, and language server.
 Author: Dark Light
 License-Expression: MPL-2.0
@@ -45,7 +45,7 @@ Dynamic: license-file
 
 `python-delphi-lsp` parses Delphi/Object Pascal, builds semantic and project
 indexes, serves LSP, and provides bounded codebase navigation for agents.
-Version 3.2.1 is authored by Dark Light and supports Windows, macOS, and Linux.
+Version 3.2.2 is authored by Dark Light and supports Windows, macOS, and Linux.
 
 ## Install and quick start
 
@@ -226,7 +226,8 @@ delphi-lsp-agent worker --root PATH [--project-file FILE] [--workers auto|N]
 ```
 
 `--deep-projects` opts into per-project dependency parsing for the `projects`
-layer. It is off by default because it dominates run time on real repositories:
+and `problems` layers. It is off by default because it dominates run time on
+real repositories:
 on a 60-project corpus it cost 36.9 s against 1.0 s for the same index, and it
 adds nothing to the unit model set. Without it the `projects` and `problems`
 layers report `deep_indexed: false`, and `index` records `deep_projects` at the

{python_delphi_lsp-3.2.1 → python_delphi_lsp-3.2.2}/python_delphi_lsp.egg-info/SOURCES.txt

@@ -56,6 +56,7 @@ docs/release-3.1.1.md
 docs/release-3.1.2.md
 docs/release-3.2.0.md
 docs/release-3.2.1.md
+docs/release-3.2.2.md
 docs/superpowers/plans/2026-07-16-architecture-metrics-implementation.md
 docs/superpowers/plans/2026-07-17-large-codebase-performance.md
 docs/superpowers/plans/2026-07-22-conditional-outline-ranges.md
@@ -286,6 +287,7 @@ test_projects/github_repos/mORMot2/src/ui/mormot.ui.pdf.pas
 tests/corpora.performance.lock.json
 tests/fpc_parse_quality.baseline.json
 tests/test_agent_cache.py
+tests/test_agent_cli_content.py
 tests/test_agent_cli_errors.py
 tests/test_agent_codebase.py
 tests/test_agent_context.py

python_delphi_lsp-3.2.2/tests/test_agent_cli_content.py

@@ -0,0 +1,467 @@
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+from collections.abc import Iterator
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+DUNITX_ROOT = REPO_ROOT / "test_projects" / "github_repos" / "DUnitX"
+
+MAIN_SOURCE = """\
+program Main;
+
+uses
+  Alpha in 'Alpha.pas',
+  Beta in 'Beta.pas',
+  Gamma in 'Gamma.pas',
+  Broken in 'Broken.pas';
+
+begin
+end.
+"""
+
+ALPHA_SOURCE = """\
+unit Alpha;
+
+interface
+
+const
+  CrossMarker = 11;
+
+type
+  AlphaToken = Integer;
+
+implementation
+
+end.
+"""
+
+BETA_SOURCE = """\
+unit Beta;
+
+interface
+
+const
+  CrossMarker = 22;
+
+type
+  BetaToken = Integer;
+
+implementation
+
+end.
+"""
+
+GAMMA_SOURCE = """\
+unit Gamma;
+
+interface
+
+{$I gamma_defs.txt}
+
+implementation
+
+end.
+"""
+
+GAMMA_INCLUDE_SOURCE = """\
+const
+  GammaIncluded = 33;
+"""
+
+BROKEN_SOURCE = """\
+unit Broken;
+
+interface
+
+{$I broken_fragment.txt}
+
+implementation
+
+end.
+"""
+
+BROKEN_INCLUDE_SOURCE = "{ unterminated comment\n"
+
+
+@pytest.fixture
+def ground_truth_workspace(tmp_path: Path) -> Path:
+    sources = {
+        "Main.dpr": MAIN_SOURCE,
+        "Alpha.pas": ALPHA_SOURCE,
+        "Beta.pas": BETA_SOURCE,
+        "Gamma.pas": GAMMA_SOURCE,
+        "gamma_defs.txt": GAMMA_INCLUDE_SOURCE,
+        "Broken.pas": BROKEN_SOURCE,
+        "broken_fragment.txt": BROKEN_INCLUDE_SOURCE,
+    }
+    for relative, source in sources.items():
+        (tmp_path / relative).write_text(source, encoding="utf-8")
+    return tmp_path
+
+
+def _run_cli(*arguments: str) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        [sys.executable, "-m", "delphi_lsp.agent_cli", *arguments],
+        cwd=REPO_ROOT,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+
+
+def _run_view(
+    root: Path,
+    layer: str,
+    *,
+    query: str = "",
+    output_format: str = "json",
+    deep_projects: bool = False,
+) -> subprocess.CompletedProcess[str]:
+    arguments = [
+        "view",
+        "--root",
+        str(root),
+        "--layer",
+        layer,
+        "--format",
+        output_format,
+    ]
+    if query:
+        arguments.extend(["--query", query])
+    if deep_projects:
+        arguments.append("--deep-projects")
+    return _run_cli(*arguments)
+
+
+def _json_output(completed: subprocess.CompletedProcess[str]) -> dict[str, Any]:
+    assert completed.returncode == 0, completed.stderr
+    assert completed.stderr == ""
+    payload = json.loads(completed.stdout)
+    assert isinstance(payload, dict)
+    return payload
+
+
+def _run_index(root: Path, name: str, *, deep_projects: bool) -> dict[str, Any]:
+    output = root / name
+    arguments = [
+        "index",
+        "--root",
+        str(root),
+        "--out",
+        str(output),
+    ]
+    if deep_projects:
+        arguments.append("--deep-projects")
+    completed = _run_cli(*arguments)
+    assert completed.returncode == 0, completed.stderr
+    assert completed.stderr == ""
+    assert completed.stdout == f"{output}\n"
+    payload = json.loads(output.read_text(encoding="utf-8"))
+    assert isinstance(payload, dict)
+    return payload
+
+
+def _absolute_path_values(value: object, key: str = "") -> Iterator[str]:
+    scalar_path_keys = {"file", "origin", "path", "root"}
+    sequence_path_keys = {"include_paths", "projects", "search_paths"}
+    if isinstance(value, dict):
+        for child_key, child in value.items():
+            if (
+                child_key in scalar_path_keys
+                and isinstance(child, str)
+                and Path(child).is_absolute()
+            ):
+                yield child
+            elif child_key in sequence_path_keys and isinstance(child, list):
+                yield from (
+                    item
+                    for item in child
+                    if isinstance(item, str) and Path(item).is_absolute()
+                )
+            yield from _absolute_path_values(child, child_key)
+    elif isinstance(value, list):
+        for child in value:
+            yield from _absolute_path_values(child, key)
+
+
+def test_view_units_matches_hand_authored_workspace_exactly(
+    ground_truth_workspace: Path,
+) -> None:
+    """Five source declarations define the complete expected unit-name set."""
+    payload = _json_output(_run_view(ground_truth_workspace, "units"))
+
+    assert payload["layer"] == "units"
+    assert {item["name"] for item in payload["items"]} == {
+        "Alpha",
+        "Beta",
+        "Broken",
+        "Gamma",
+        "Main",
+    }
+    assert {Path(item["path"]).name for item in payload["items"]} == {
+        "Alpha.pas",
+        "Beta.pas",
+        "Broken.pas",
+        "Gamma.pas",
+        "Main.dpr",
+    }
+
+
+def test_view_symbols_matches_hand_authored_declaration_and_empty_query(
+    ground_truth_workspace: Path,
+) -> None:
+    """AlphaToken is declared once, on hand-counted Alpha.pas line 9."""
+    payload = _json_output(
+        _run_view(ground_truth_workspace, "symbols", query="AlphaToken")
+    )
+
+    assert {
+        (item["name"], item["kind"], Path(item["path"]).name, item["line"])
+        for item in payload["items"]
+    } == {("AlphaToken", "type", "Alpha.pas", 9)}
+
+    absent = _json_output(
+        _run_view(
+            ground_truth_workspace,
+            "symbols",
+            query="NameThatCannotExistInTheFixture",
+        )
+    )
+    assert absent["items"] == []
+
+
+def test_view_unit_returns_exact_hand_authored_members(
+    ground_truth_workspace: Path,
+) -> None:
+    """Alpha.pas declares only CrossMarker (line 6) and AlphaToken (line 9)."""
+    payload = _json_output(
+        _run_view(ground_truth_workspace, "unit", query="Alpha")
+    )
+
+    assert len(payload["items"]) == 1
+    unit = payload["items"][0]
+    assert unit["name"] == "Alpha"
+    assert {
+        (item["name"], item["kind"], item["line"])
+        for item in unit["symbols"]
+    } == {
+        ("AlphaToken", "type", 9),
+        ("CrossMarker", "constant", 6),
+    }
+
+
+def test_view_references_returns_two_hand_counted_symbol_locations(
+    ground_truth_workspace: Path,
+) -> None:
+    """CrossMarker is declared at line 6 in exactly Alpha.pas and Beta.pas."""
+    payload = _json_output(
+        _run_view(ground_truth_workspace, "references", query="CrossMarker")
+    )
+
+    assert {
+        (item["name"], item["kind"], Path(item["path"]).name, item["line"])
+        for item in payload["items"]
+    } == {
+        ("CrossMarker", "constant", "Alpha.pas", 6),
+        ("CrossMarker", "constant", "Beta.pas", 6),
+    }
+
+
+def test_view_problems_distinguishes_shallow_and_deep_project_findings(
+    ground_truth_workspace: Path,
+) -> None:
+    """The invalid include token is expanded at hand-counted Broken.pas line 5."""
+    shallow = _json_output(_run_view(ground_truth_workspace, "problems"))
+    deep = _json_output(
+        _run_view(ground_truth_workspace, "problems", deep_projects=True)
+    )
+
+    assert shallow["deep_indexed"] is False
+    assert shallow["items"] == []
+    assert deep["deep_indexed"] is True
+    assert {
+        (
+            item["kind"],
+            Path(item["origin"]).name,
+            Path(item["file"]).name,
+            item["message"],
+        )
+        for item in deep["items"]
+    } == {
+        (
+            "cant_parse_file",
+            "Main.dpr",
+            "Broken.pas",
+            (
+                f"{ground_truth_workspace / 'Broken.pas'}:5:1: "
+                "No terminal matches '{' in the current parser context, "
+                "at line 5 col 1"
+            ),
+        )
+    }
+
+
+def test_index_document_contract_uses_hand_counted_unit_total_in_both_modes(
+    ground_truth_workspace: Path,
+) -> None:
+    """Main plus four unit declarations make an exact unit_count of five."""
+    shallow = _run_index(
+        ground_truth_workspace,
+        "index-shallow.json",
+        deep_projects=False,
+    )
+    deep = _run_index(
+        ground_truth_workspace,
+        "index-deep.json",
+        deep_projects=True,
+    )
+
+    for payload, expected_deep in ((shallow, False), (deep, True)):
+        assert set(payload) == {
+            "deep_projects",
+            "overview",
+            "problems",
+            "projects",
+        }
+        assert payload["deep_projects"] is expected_deep
+        assert payload["overview"]["unit_count"] == 5
+    assert shallow["problems"]["deep_indexed"] is False
+    assert deep["problems"]["deep_indexed"] is True
+
+
+def test_markdown_contains_hand_authored_unit_and_symbol_names(
+    ground_truth_workspace: Path,
+) -> None:
+    units = _run_view(
+        ground_truth_workspace,
+        "units",
+        query="Alpha",
+        output_format="markdown",
+    )
+    symbols = _run_view(
+        ground_truth_workspace,
+        "symbols",
+        query="AlphaToken",
+        output_format="markdown",
+    )
+
+    assert units.returncode == 0
+    assert units.stderr == ""
+    assert "`Alpha` unit" in units.stdout
+    assert f"`{ground_truth_workspace / 'Alpha.pas'}:1`" in units.stdout
+    assert symbols.returncode == 0
+    assert symbols.stderr == ""
+    assert "`AlphaToken` type" in symbols.stdout
+    assert f"`{ground_truth_workspace / 'Alpha.pas'}:9`" in symbols.stdout
+
+
+def test_nonexistent_root_has_workspace_not_found_error_contract(
+    tmp_path: Path,
+) -> None:
+    missing = tmp_path / "does-not-exist"
+    completed = _run_view(missing, "overview")
+
+    assert completed.returncode == 1
+    assert completed.stdout == ""
+    assert completed.stderr.startswith(
+        "cli_error:workspace_not_found: Workspace root does not exist: "
+    )
+    assert completed.stderr == (
+        f"cli_error:workspace_not_found: Workspace root does not exist: {missing}\n"
+    )
+
+
+def test_missing_project_file_has_project_file_not_found_error_contract(
+    tmp_path: Path,
+) -> None:
+    missing = Path("projects") / "Missing.dpr"
+    completed = _run_cli(
+        "view",
+        "--root",
+        str(tmp_path),
+        "--project-file",
+        str(missing),
+        "--layer",
+        "overview",
+        "--format",
+        "json",
+    )
+
+    assert completed.returncode == 1
+    assert completed.stdout == ""
+    assert completed.stderr.startswith(
+        "cli_error:project_file_not_found: Explicit project file does not exist: "
+    )
+    assert completed.stderr == (
+        "cli_error:project_file_not_found: Explicit project file does not "
+        f"exist: {(tmp_path / missing).resolve()}\n"
+    )
+
+
+def test_unknown_layer_has_argparse_error_contract(tmp_path: Path) -> None:
+    completed = _run_cli(
+        "view",
+        "--root",
+        str(tmp_path),
+        "--layer",
+        "unknown-layer",
+        "--format",
+        "json",
+    )
+
+    assert completed.returncode == 2
+    assert completed.stdout == ""
+    assert completed.stderr.startswith("usage: delphi-lsp-agent view ")
+    assert (
+        "delphi-lsp-agent view: error: argument --layer: invalid choice: "
+        "'unknown-layer'"
+    ) in completed.stderr
+
+
+def test_index_payload_paths_use_only_the_native_separator(
+    ground_truth_workspace: Path,
+) -> None:
+    payload = _run_index(
+        ground_truth_workspace,
+        "index-paths.json",
+        deep_projects=True,
+    )
+    paths = tuple(_absolute_path_values(payload))
+    alternate_separator = "/" if os.sep == "\\" else "\\"
+
+    assert paths
+    assert all(os.sep in path for path in paths)
+    assert all(alternate_separator not in path for path in paths)
+    assert all(str(Path(path)) == path for path in paths)
+
+
+@pytest.mark.perf
+@pytest.mark.skipif(
+    not DUNITX_ROOT.is_dir(),
+    reason="requires the local DUnitX corpus under test_projects/",
+)
+def test_dunitx_references_contains_hand_verified_itest_runner_declaration() -> None:
+    source = DUNITX_ROOT / "Source" / "DUnitX.TestFramework.pas"
+    source_lines = source.read_text(encoding="utf-8-sig").splitlines()
+    assert source_lines[493].strip() == "ITestRunner = interface"
+
+    payload = _json_output(
+        _run_view(DUNITX_ROOT, "references", query="ITestRunner")
+    )
+
+    assert (
+        "ITestRunner",
+        "interface",
+        "DUnitX.TestFramework.pas",
+        494,
+    ) in {
+        (item["name"], item["kind"], Path(item["path"]).name, item["line"])
+        for item in payload["items"]
+    }

{python_delphi_lsp-3.2.1 → python_delphi_lsp-3.2.2}/tests/test_agent_cli_errors.py

@@ -299,11 +299,19 @@ def test_cli_reports_parallel_setup_failure_without_traceback(
     )
 
 
-def test_problems_view_deep_indexes_project_diagnostics(
+def test_problems_view_deep_indexes_only_on_request(
     monkeypatch: pytest.MonkeyPatch,
     capsys: pytest.CaptureFixture[str],
     tmp_path: Path,
 ) -> None:
+    """The problems layer no longer forces the per-project dependency pass.
+
+    Forcing it made ``view --layer problems`` cost 43.7 s on a 78k-line
+    workspace with 60 projects -- the same defect class that made ``index``
+    unusable before 3.2.1. The payload carries ``deep_indexed`` so consumers
+    can tell a shallow problems report from a complete one, and
+    ``--deep-projects`` opts back into the full pass.
+    """
     calls: list[dict[str, object]] = []
     sentinel = object()
 
@@ -322,22 +330,15 @@ def test_problems_view_deep_indexes_project_diagnostics(
         ),
     )
 
-    result = agent_cli.main(
-        [
-            "view",
-            "--root",
-            str(tmp_path),
-            "--layer",
-            "problems",
-            "--format",
-            "json",
-        ]
-    )
+    base = ["view", "--root", str(tmp_path), "--layer", "problems", "--format", "json"]
 
-    assert result == 0
-    assert calls[0]["index_projects"] is True
+    assert agent_cli.main(base) == 0
+    assert calls[0]["index_projects"] is False
     assert json.loads(capsys.readouterr().out)["layer"] == "problems"
 
+    assert agent_cli.main([*base, "--deep-projects"]) == 0
+    assert calls[1]["index_projects"] is True
+
 
 def test_view_resolves_relative_project_file_from_root(tmp_path: Path) -> None:
     workspace = tmp_path / "workspace"