python-delphi-lsp 2.0.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

delphi_lsp/__init__.py

@@ -59,6 +59,17 @@ from .project_indexer import (
     UnitInfo,
     UnitParsedHook,
 )
+from .metrics import (
+    CyclomaticMetrics,
+    HalsteadMetrics,
+    LineMetrics,
+    MetricProblem,
+    ProjectMetrics,
+    RoutineComplexity,
+    UnitMetrics,
+    analyze_project,
+    analyze_unit,
+)
 
 __all__ = [
     '__version__',
@@ -134,6 +145,15 @@ __all__ = [
     'IncludeFileInfo',
     'GetUnitSyntaxHook',
     'UnitParsedHook',
+    'MetricProblem',
+    'LineMetrics',
+    'HalsteadMetrics',
+    'RoutineComplexity',
+    'CyclomaticMetrics',
+    'UnitMetrics',
+    'ProjectMetrics',
+    'analyze_unit',
+    'analyze_project',
     'dumps',
     'loads',
 ]

delphi_lsp/_version.py

@@ -1 +1 @@
-__version__ = "2.0.0"
+__version__ = "2.0.1"

delphi_lsp/agent_cli.py

@@ -44,6 +44,7 @@ def build_parser() -> argparse.ArgumentParser:
             "implementation",
             "references",
             "problems",
+            "metrics",
         ],
     )
     view.add_argument("--query", default="")

delphi_lsp/agent_context.py

@@ -18,14 +18,16 @@ from .agent_protocol import (
     make_target_id,
     paginate_items,
 )
+from .agent_metrics import build_workspace_metrics, project_metric_item, unit_metric_item
 from .agent_relations import ProjectRelationIndex, RelationTarget
-from .agent_workspace import AgentUnit, AgentWorkspace
+from .agent_workspace import AgentWorkspace, unit_display_path, unit_source_path, unit_target_id
 from .consts import AttributeName, SyntaxNodeType
 from .lsp_server import build_outline_semantic_model, multiline_string_block_end
 from .nodes import CompoundSyntaxNode, SyntaxNode
 from .parser import DelphiParser
 from .semantic import Scope, ScopeKind, Symbol, SymbolKind
 from .source_reader import read_source_text
+from .metrics import ProjectMetrics
 
 
 _ROUTINE_KINDS = frozenset(
@@ -238,6 +240,8 @@ class AgentContext:
         self._last_revision = workspace.workspace_revision
         self._registry: _Registry | None = None
         self._relation_index: ProjectRelationIndex | None = None
+        self._metrics: ProjectMetrics | None = None
+        self._metrics_revision = ""
 
     @classmethod
     def open(
@@ -270,6 +274,8 @@ class AgentContext:
             self._require_selected_project()
             items = self._problem_items()
             return self._response(parsed, revision, items)
+        if parsed.action == "metrics":
+            return self._handle_metrics(parsed, revision)
         if parsed.action == "focus":
             return self._handle_focus(parsed, revision)
         if parsed.action == "find":
@@ -294,10 +300,14 @@ class AgentContext:
         if current_project_id != previous_project_id:
             self._registry = None
             self._relation_index = None
+            self._metrics = None
+            self._metrics_revision = ""
             self._focus = Focus(project_id=current_project_id) if current_project_id else Focus()
         elif revision != self._last_revision:
             self._registry = None
             self._relation_index = None
+            self._metrics = None
+            self._metrics_revision = ""
         elif self._focus.project_id != current_project_id:
             self._focus = Focus(project_id=current_project_id) if current_project_id else Focus()
         self._last_revision = revision
@@ -323,12 +333,11 @@ class AgentContext:
             return items
 
         for unit in self._workspace.units:
-            source_path = _unit_source_path(self._workspace.root, unit)
-            display_path = _stable_source_display_path(self._workspace.root, unit, source_path)
+            display_path = unit_display_path(self._workspace.root, unit)
             items.append(
                 {
                     "item_type": "unit",
-                    "unit_id": make_target_id("unit", display_path, unit.name),
+                    "unit_id": unit_target_id(self._workspace.root, unit),
                     "name": unit.name,
                     "path": display_path,
                     "has_error": unit.has_error,
@@ -407,6 +416,55 @@ class AgentContext:
             self._focus = Focus(project_id=self._workspace.active_project_id)
         return self._response(request, revision, [self._focus.to_mapping()])
 
+    def _handle_metrics(self, request: AgentRequest, revision: str) -> AgentResponse:
+        if request.detail not in {"summary", "members"}:
+            raise AgentProtocolError(
+                "invalid_detail",
+                "Metrics supports only summary or members detail.",
+            )
+        metrics = self._require_metrics(revision)
+        detail = request.detail == "members"
+        if request.target_id:
+            unit = next(
+                (candidate for candidate in metrics.units if candidate.unit_id == request.target_id),
+                None,
+            )
+            if unit is None:
+                raise AgentProtocolError(
+                    "target_not_found",
+                    f"Target not found: {request.target_id}.",
+                )
+            return self._response(
+                request,
+                revision,
+                [unit_metric_item(unit, detail=detail)],
+                target_id=unit.unit_id,
+            )
+
+        units = metrics.units
+        if request.query:
+            query = request.query.casefold()
+            units = tuple(
+                unit
+                for unit in units
+                if query in unit.name.casefold() or query in unit.path.casefold()
+            )
+            items = [unit_metric_item(unit, detail=detail) for unit in units]
+        else:
+            items = [
+                project_metric_item(metrics),
+                *(unit_metric_item(unit, detail=detail) for unit in units),
+            ]
+        return self._response(request, revision, items)
+
+    def _require_metrics(self, revision: str) -> ProjectMetrics:
+        self._require_selected_project()
+        if self._metrics is not None and self._metrics_revision == revision:
+            return self._metrics
+        self._metrics = build_workspace_metrics(self._workspace)
+        self._metrics_revision = revision
+        return self._metrics
+
     def _require_registry(self, revision: str) -> _Registry:
         project_id = self._require_selected_project()
         if (
@@ -608,8 +666,8 @@ def _build_registry(workspace: AgentWorkspace, project_id: str, revision: str) -
     raw_symbols: list[_RawSymbol] = []
     sources: dict[Path, _SourceDocument] = {}
     for unit in workspace.units:
-        source_path = _unit_source_path(workspace.root, unit)
-        display_path = _stable_source_display_path(workspace.root, unit, source_path)
+        source_path = unit_source_path(workspace.root, unit)
+        display_path = unit_display_path(workspace.root, unit)
         try:
             text = read_source_text(source_path)
         except OSError as exc:
@@ -727,22 +785,6 @@ def _build_registry(workspace: AgentWorkspace, project_id: str, revision: str) -
     )
 
 
-def _unit_source_path(root: Path, unit: AgentUnit) -> Path:
-    path = Path(unit.path)
-    if not path.is_absolute():
-        path = root / path
-    return path.expanduser().resolve()
-
-
-def _stable_source_display_path(root: Path, unit: AgentUnit, source_path: Path) -> str:
-    try:
-        return source_path.relative_to(root).as_posix()
-    except ValueError:
-        unit_component = _stable_path_component(unit.name or source_path.stem)
-        file_component = _stable_path_component(source_path.name)
-        return f"@external/{unit_component}/{file_component}"
-
-
 def _stable_path_component(value: str) -> str:
     normalized = unicodedata.normalize("NFC", value).replace("\\", "_").replace("/", "_")
     return normalized or "unknown"

delphi_lsp/agent_layers.py

@@ -6,6 +6,7 @@ from typing import Any, Iterable
 import json
 
 from .lsp_server import build_outline_semantic_model, outline_source
+from .metrics import analyze_project
 from .project_discovery import DelphiProjectDiscovery, discover_delphi_project
 from .project_indexer import ProjectIndexResult, ProjectIndexer
 from .semantic import Scope, SourceRange, Symbol, SymbolIndex, SymbolKind
@@ -98,6 +99,8 @@ def layer_payload(index: CodebaseIndex, layer: str, *, query: str = "") -> dict[
         return _references_payload(index, query=query)
     if normalized_layer == "problems":
         return _problems_payload(index)
+    if normalized_layer == "metrics":
+        return _metrics_payload(index, query=query)
     raise ValueError(f"Unknown layer: {layer}")
 
 
@@ -369,6 +372,44 @@ def _problems_payload(index: CodebaseIndex) -> dict[str, Any]:
     return {"layer": "problems", "root": index.root, "items": items}
 
 
+def _metrics_payload(index: CodebaseIndex, *, query: str) -> dict[str, Any]:
+    sources: dict[str, str] = {}
+    include_sources: dict[str, str] = {}
+    for value in index.discovery.source_files:
+        path = Path(value)
+        try:
+            text = read_source_text(path)
+        except (OSError, UnicodeError):
+            continue
+        if path.suffix.casefold() == ".inc":
+            include_sources[str(path)] = text
+        elif path.suffix.casefold() in {".pas", ".dpr", ".dpk"}:
+            sources[str(path)] = text
+
+    project_name = "Workspace"
+    if len(index.discovery.project_files) == 1:
+        project_name = Path(index.discovery.project_files[0]).stem
+    metrics = analyze_project(
+        sources,
+        include_sources=include_sources,
+        defines=index.discovery.defines,
+        include_paths=index.discovery.include_paths,
+        project_name=project_name,
+    )
+    needle = query.casefold().strip()
+    units = [
+        unit.to_mapping(detail=True)
+        for unit in metrics.units
+        if not needle or needle in unit.name.casefold() or needle in unit.path.casefold()
+    ]
+    return {
+        "layer": "metrics",
+        "root": index.root,
+        "project": metrics.to_mapping(),
+        "items": units,
+    }
+
+
 def _all_symbols(index: CodebaseIndex) -> Iterable[Symbol]:
     for model in index.models.values():
         yield from _iter_symbols(model.unit_scope)
@@ -486,6 +527,30 @@ def _render_markdown(payload: dict[str, Any]) -> str:
     elif payload["layer"] == "problems":
         for item in payload["items"]:
             lines.append(f"- {item['kind']}: {item['message']} (`{item.get('origin', '')}`)")
+    elif payload["layer"] == "metrics":
+        project = payload["project"]
+        lines.extend(
+            [
+                f"- Project LOC: {project['total_loc']}",
+                f"- Project LOC with includes: {project['total_loc_with_includes']}",
+                f"- Units: {project['unit_count']}",
+                f"- Maintainability index: {project['maintainability_index']:.2f}",
+            ]
+        )
+        for item in payload["items"]:
+            lines.extend(
+                [
+                    "",
+                    f"## {item['name']}",
+                    f"- Path: `{item['path']}`",
+                    f"- LOC: {item['lines']['total_lines']}",
+                    f"- Cyclomatic maximum: {item['cyclomatic']['maximum']}",
+                    f"- Maintainability index: {item['maintainability_index']:.2f}",
+                    f"- Instability: {item['instability']:.3f}",
+                    f"- Abstractness: {item['abstractness']:.3f}",
+                    f"- Distance: {item['distance']:.3f}",
+                ]
+            )
     return "\n".join(lines).rstrip() + "\n"
 
 

delphi_lsp/agent_metrics.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from dataclasses import replace
+from pathlib import Path
+
+from .agent_workspace import (
+    AgentWorkspace,
+    unit_display_path,
+    unit_source_path,
+    unit_target_id,
+)
+from .metrics import MetricProblem, ProjectMetrics, UnitMetrics, analyze_project
+from .source_reader import read_source_text
+
+
+def build_workspace_metrics(workspace: AgentWorkspace) -> ProjectMetrics:
+    sources: dict[str, str] = {}
+    include_sources: dict[str, str] = {}
+    unit_ids: dict[str, str] = {}
+    problems: list[MetricProblem] = []
+
+    for unit in workspace.units:
+        display_path = unit_display_path(workspace.root, unit)
+        source_path = unit_source_path(workspace.root, unit)
+        try:
+            sources[display_path] = read_source_text(source_path)
+        except OSError:
+            problems.append(
+                MetricProblem(
+                    kind="source_unavailable",
+                    path=display_path,
+                    message="Could not read source.",
+                )
+            )
+            continue
+        unit_ids[display_path] = unit_target_id(workspace.root, unit)
+
+    for include_file in workspace.include_files:
+        display_path = include_file["path"]
+        source_path = _workspace_path(workspace.root, display_path)
+        try:
+            include_sources[display_path] = read_source_text(source_path)
+        except OSError:
+            problems.append(
+                MetricProblem(
+                    kind="include_unavailable",
+                    path=display_path,
+                    message="Could not read include file.",
+                )
+            )
+
+    project = workspace.active_project
+    metrics = analyze_project(
+        sources,
+        include_sources=include_sources,
+        defines=workspace.defines,
+        include_paths=workspace.include_paths,
+        project_id=workspace.active_project_id,
+        project_name=project.name if project is not None else "",
+        unit_ids=unit_ids,
+    )
+    if problems:
+        metrics = replace(metrics, problems=(*metrics.problems, *problems))
+    return metrics
+
+
+def project_metric_item(metrics: ProjectMetrics) -> dict[str, object]:
+    return {"item_type": "project_metrics", **metrics.to_mapping()}
+
+
+def unit_metric_item(metrics: UnitMetrics, *, detail: bool = False) -> dict[str, object]:
+    return {"item_type": "unit_metrics", **metrics.to_mapping(detail=detail)}
+
+
+def _workspace_path(root: Path, value: str) -> Path:
+    path = Path(value).expanduser()
+    if not path.is_absolute():
+        path = root / path
+    return path.resolve()
+
+
+__all__ = ["build_workspace_metrics", "project_metric_item", "unit_metric_item"]

delphi_lsp/agent_protocol.py

@@ -19,6 +19,7 @@ SUPPORTED_ACTIONS = (
     'trace',
     'focus',
     'problems',
+    'metrics',
 )
 
 SUPPORTED_DETAILS = (

delphi_lsp/agent_templates.py

@@ -181,13 +181,14 @@ Inspect Delphi/Object Pascal only through `delphi_codebase`; never raw bash/read
 3. Inspect focused details in this order as needed: `summary`, `declaration`, `members`, `context`, `body`, `implementations`.
 4. Trace relations with `references`, `callers`, `callees`, `uses`, `used_by`, `inherits`, or `implements`.
 5. Call `problems` before declaring evidence missing. Explain any `sound_partial` relation metadata rather than treating partial results as complete.
-6. Follow `page.next_cursor` with `cursor` until the needed evidence is available.
+6. Call `metrics` for project LOC and architecture metrics. Use `query` for unit summaries or a unit `target_id` with `detail=members` for full Halstead, complexity, coupling, abstractness, instability, and distance details.
+7. Follow `page.next_cursor` with `cursor` until the needed evidence is available.
 
 Prefer `summary` and `declaration`, narrow `max_items` and `max_chars`, and request `body` only when it is necessary. Keep the focused target stable while collecting evidence.
 
 ## Tool calls
 
-`delphi_codebase` accepts `action` (`open`, `find`, `inspect`, `trace`, `focus`, `problems`), optional `query`, `target_id`, `project_id`, `detail`, `relation`, `cursor`, `max_items` (1-50), and `max_chars` (256-40000). It has no root or path argument; the active OpenCode worktree is used.
+`delphi_codebase` accepts `action` (`open`, `find`, `inspect`, `trace`, `focus`, `problems`, `metrics`), optional `query`, `target_id`, `project_id`, `detail`, `relation`, `cursor`, `max_items` (1-50), and `max_chars` (256-40000). It has no root or path argument; the active OpenCode worktree is used.
 """
 
 
@@ -199,7 +200,7 @@ const PYTHON = __PYTHON_EXECUTABLE__
 const DEFAULT_REQUEST_TIMEOUT_MS = 120_000
 
 type AgentRequest = {
-  action: "open" | "find" | "inspect" | "trace" | "focus" | "problems"
+  action: "open" | "find" | "inspect" | "trace" | "focus" | "problems" | "metrics"
   query?: string
   target_id?: string
   project_id?: string
@@ -464,7 +465,7 @@ export const DelphiCodebasePlugin: Plugin = async (_input) => {
       delphi_codebase: tool({
         description: "Protocol v2 semantic Delphi/Object Pascal codebase navigation.",
         args: {
-          action: tool.schema.enum(["open", "find", "inspect", "trace", "focus", "problems"]),
+          action: tool.schema.enum(["open", "find", "inspect", "trace", "focus", "problems", "metrics"]),
           query: tool.schema.string().optional(),
           target_id: tool.schema.string().optional(),
           project_id: tool.schema.string().optional(),

delphi_lsp/agent_workspace.py

@@ -4,6 +4,7 @@ from dataclasses import dataclass
 import hashlib
 import json
 from pathlib import Path
+import unicodedata
 
 from .agent_protocol import AgentProtocolError, Focus, make_target_id
 from .consts import AttributeName, SyntaxNodeType
@@ -369,6 +370,32 @@ def _display_path(path: Path, root: Path) -> str:
         return resolved.as_posix()
 
 
+def unit_source_path(root: Path, unit: AgentUnit) -> Path:
+    path = Path(unit.path)
+    if not path.is_absolute():
+        path = root / path
+    return path.expanduser().resolve()
+
+
+def unit_display_path(root: Path, unit: AgentUnit) -> str:
+    source_path = unit_source_path(root, unit)
+    try:
+        return source_path.relative_to(root).as_posix()
+    except ValueError:
+        unit_component = _stable_path_component(unit.name or source_path.stem)
+        file_component = _stable_path_component(source_path.name)
+        return f"@external/{unit_component}/{file_component}"
+
+
+def unit_target_id(root: Path, unit: AgentUnit) -> str:
+    return make_target_id("unit", unit_display_path(root, unit), unit.name)
+
+
+def _stable_path_component(value: str) -> str:
+    normalized = unicodedata.normalize("NFC", value).replace("\\", "_").replace("/", "_")
+    return normalized or "unknown"
+
+
 def _outline_agent_source(text: str) -> str:
     return _compact_outline_whitespace(outline_source(text))
 
@@ -658,4 +685,11 @@ def _file_records(
     return records
 
 
-__all__ = ["AgentProject", "AgentUnit", "AgentWorkspace"]
+__all__ = [
+    "AgentProject",
+    "AgentUnit",
+    "AgentWorkspace",
+    "unit_display_path",
+    "unit_source_path",
+    "unit_target_id",
+]

delphi_lsp/lark_builder.py

@@ -654,7 +654,19 @@ def build_syntax_tree(
                     for item in child:
                         if isinstance(item, SyntaxNode):
                             node.add_child(item)
-            return node
+                elif isinstance(child, set):
+                    if 'abstract' in child:
+                        node.set_attribute(AttributeName.anAbstract, 'true')
+                    if 'sealed' in child:
+                        node.set_attribute(AttributeName.anSealed, 'true')
+            return node
+
+        def class_modifiers(self, meta: Any, *children: Any) -> set[str]:
+            return {
+                token_value(child).casefold()
+                for child in children
+                if self._is_text(child) or is_token(child)
+            }
 
         def forward_class_decl(self, meta: Any, *children: Any) -> SyntaxNode:
             node = self._make_node(SyntaxNodeType.ntType, meta)
@@ -1957,7 +1969,7 @@ def build_syntax_tree(
 
         def case_statement(self, meta: Any, *children: Any) -> SyntaxNode:
             node = self._make_node(SyntaxNodeType.ntCase, meta)
-            for child in children:
+            for child in self._flatten(children):
                 if isinstance(child, SyntaxNode):
                     node.add_child(child)
             return node