python-delphi-lsp 2.0.0__tar.gz → 2.0.1__tar.gz

{python_delphi_lsp-2.0.0/python_delphi_lsp.egg-info → python_delphi_lsp-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-delphi-lsp
-Version: 2.0.0
+Version: 2.0.1
 Summary: Python Delphi/Object Pascal parser, semantic indexer, and language server.
 Author: Dark Light
 License-Expression: MPL-2.0
@@ -41,7 +41,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 2.0.0 is authored by Dark Light and supports Windows, macOS, and Linux.
+Version 2.0.1 is authored by Dark Light and supports Windows, macOS, and Linux.
 
 ## Install and quick start
 
@@ -82,6 +82,39 @@ project = ProjectIndexer(
 print(project.parsed_units)
 ```
 
+## Architecture metrics
+
+The public metrics API analyzes a single unit or aggregates a complete project:
+
+```python
+from delphi_lsp import analyze_project, analyze_unit
+
+unit = analyze_unit(
+    "unit Alpha; interface implementation procedure Run; begin end; end.",
+    "Alpha.pas",
+)
+print(unit.lines.total_lines, unit.cyclomatic.maximum)
+
+project = analyze_project({
+    "Main.dpr": "program Main; uses Alpha; begin end.",
+    "Alpha.pas": "unit Alpha; interface implementation end.",
+})
+print(project.total_loc)
+```
+
+Line results distinguish total, source, blank, comment-only, mixed-comment, and
+compiler-directive lines. Project `total_loc` counts each `.dpr`, `.dpk`, and
+`.pas` source once; `include_loc` counts unique `.inc` inputs separately, and
+`total_loc_with_includes` combines both totals.
+
+Cyclomatic complexity is reported per routine and as unit/project aggregates.
+The result also includes complete Halstead counts and derived values, a
+normalized 0–100 maintainability index, symbol counts, dependency edges,
+afferent coupling (fan-in), efferent coupling (fan-out), instability,
+abstractness, and distance from the main sequence. Coupling detail separates
+internal from external dependencies. Empty or partial inputs produce finite
+JSON values; unreadable agent-workspace inputs are reported as metric problems.
+
 Run the stdio language server with `delphi-lsp`, or equivalently:
 
 ```bash
@@ -149,14 +182,21 @@ delphi-lsp-agent worker --root PATH [--project-file FILE]
 ```
 
 `view --layer` accepts `overview`, `projects`, `units`, `unit`,
-`symbols`, `symbol`, `implementation`, `references`, and `problems`.
+`symbols`, `symbol`, `implementation`, `references`, `problems`, and
+`metrics`. For example, `delphi-lsp-agent view --layer metrics --format json`
+returns a project summary and detailed unit metric objects; `--query` filters
+units by name or path.
 `index` materializes overview, projects, and problems JSON. `skill install`
 writes the skill; `opencode install` writes both integration files, while
 `--write-config` additionally writes the restricted agent configuration.
 `worker` serves NDJSON over standard input/output.
 
 Protocol v2 actions are `open`, `find`, `inspect`, `trace`, `focus`,
-and `problems`. Detail values are `summary`, `declaration`, `members`,
+`problems`, and `metrics`. A `metrics` request without a query returns the
+project summary followed by unit cards. A query filters units, while a unit
+`target_id` from `open` selects one unit; `detail: "members"` adds routine,
+Halstead, dependency, and symbol-count detail without returning source text.
+Detail values are `summary`, `declaration`, `members`,
 `context`, `body`, and `implementations`. Relations are `references`,
 `callers`, `callees`, `uses`, `used_by`, `inherits`, and
 `implements`.
@@ -231,6 +271,10 @@ Select `vllm-delphi-codebase`, ask it to load
 `open`, `find`, `focus`, and `inspect`. Use semantic tool calls, not raw
 source tools.
 
+For architecture questions, call `metrics` without a query to compare unit
+cards and read project LOC. Then select a returned unit ID with another
+`metrics` call and `detail: "members"` to inspect its routines and coupling.
+
 For the root LSP configuration, a local model can be used as follows:
 
 ```bash
@@ -297,6 +341,18 @@ local model server, increase it explicitly with `--probe-timeout SECONDS`.
 
 The bundled automatic helper is not a cross-platform startup mechanism.
 
+The architecture-metrics proof uses a separate deterministic 34-LOC project.
+It requires the restricted model to load the skill, call `metrics` for the
+project and most-complex unit, and report exact LOC, cyclomatic maximum, and
+instability values. Raw source, search, shell, and write tools remain forbidden:
+
+```bash
+python scripts/bootstrap_vllm_codebase_skill_test.py --probe metrics --use-running-server
+```
+
+Use `--probe metrics --start-vllm --max-model-len 24576` for the cached macOS
+auto-start path when no endpoint is already running.
+
 ## Migration to 2.0
 
 `delphi_lsp` is the only supported import namespace. Update imports directly;

{python_delphi_lsp-2.0.0 → python_delphi_lsp-2.0.1}/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 2.0.0 is authored by Dark Light and supports Windows, macOS, and Linux.
+Version 2.0.1 is authored by Dark Light and supports Windows, macOS, and Linux.
 
 ## Install and quick start
 
@@ -43,6 +43,39 @@ project = ProjectIndexer(
 print(project.parsed_units)
 ```
 
+## Architecture metrics
+
+The public metrics API analyzes a single unit or aggregates a complete project:
+
+```python
+from delphi_lsp import analyze_project, analyze_unit
+
+unit = analyze_unit(
+    "unit Alpha; interface implementation procedure Run; begin end; end.",
+    "Alpha.pas",
+)
+print(unit.lines.total_lines, unit.cyclomatic.maximum)
+
+project = analyze_project({
+    "Main.dpr": "program Main; uses Alpha; begin end.",
+    "Alpha.pas": "unit Alpha; interface implementation end.",
+})
+print(project.total_loc)
+```
+
+Line results distinguish total, source, blank, comment-only, mixed-comment, and
+compiler-directive lines. Project `total_loc` counts each `.dpr`, `.dpk`, and
+`.pas` source once; `include_loc` counts unique `.inc` inputs separately, and
+`total_loc_with_includes` combines both totals.
+
+Cyclomatic complexity is reported per routine and as unit/project aggregates.
+The result also includes complete Halstead counts and derived values, a
+normalized 0–100 maintainability index, symbol counts, dependency edges,
+afferent coupling (fan-in), efferent coupling (fan-out), instability,
+abstractness, and distance from the main sequence. Coupling detail separates
+internal from external dependencies. Empty or partial inputs produce finite
+JSON values; unreadable agent-workspace inputs are reported as metric problems.
+
 Run the stdio language server with `delphi-lsp`, or equivalently:
 
 ```bash
@@ -110,14 +143,21 @@ delphi-lsp-agent worker --root PATH [--project-file FILE]
 ```
 
 `view --layer` accepts `overview`, `projects`, `units`, `unit`,
-`symbols`, `symbol`, `implementation`, `references`, and `problems`.
+`symbols`, `symbol`, `implementation`, `references`, `problems`, and
+`metrics`. For example, `delphi-lsp-agent view --layer metrics --format json`
+returns a project summary and detailed unit metric objects; `--query` filters
+units by name or path.
 `index` materializes overview, projects, and problems JSON. `skill install`
 writes the skill; `opencode install` writes both integration files, while
 `--write-config` additionally writes the restricted agent configuration.
 `worker` serves NDJSON over standard input/output.
 
 Protocol v2 actions are `open`, `find`, `inspect`, `trace`, `focus`,
-and `problems`. Detail values are `summary`, `declaration`, `members`,
+`problems`, and `metrics`. A `metrics` request without a query returns the
+project summary followed by unit cards. A query filters units, while a unit
+`target_id` from `open` selects one unit; `detail: "members"` adds routine,
+Halstead, dependency, and symbol-count detail without returning source text.
+Detail values are `summary`, `declaration`, `members`,
 `context`, `body`, and `implementations`. Relations are `references`,
 `callers`, `callees`, `uses`, `used_by`, `inherits`, and
 `implements`.
@@ -192,6 +232,10 @@ Select `vllm-delphi-codebase`, ask it to load
 `open`, `find`, `focus`, and `inspect`. Use semantic tool calls, not raw
 source tools.
 
+For architecture questions, call `metrics` without a query to compare unit
+cards and read project LOC. Then select a returned unit ID with another
+`metrics` call and `detail: "members"` to inspect its routines and coupling.
+
 For the root LSP configuration, a local model can be used as follows:
 
 ```bash
@@ -258,6 +302,18 @@ local model server, increase it explicitly with `--probe-timeout SECONDS`.
 
 The bundled automatic helper is not a cross-platform startup mechanism.
 
+The architecture-metrics proof uses a separate deterministic 34-LOC project.
+It requires the restricted model to load the skill, call `metrics` for the
+project and most-complex unit, and report exact LOC, cyclomatic maximum, and
+instability values. Raw source, search, shell, and write tools remain forbidden:
+
+```bash
+python scripts/bootstrap_vllm_codebase_skill_test.py --probe metrics --use-running-server
+```
+
+Use `--probe metrics --start-vllm --max-model-len 24576` for the cached macOS
+auto-start path when no endpoint is already running.
+
 ## Migration to 2.0
 
 `delphi_lsp` is the only supported import namespace. Update imports directly;

{python_delphi_lsp-2.0.0 → python_delphi_lsp-2.0.1}/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',
 ]

python_delphi_lsp-2.0.1/delphi_lsp/_version.py

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

{python_delphi_lsp-2.0.0 → python_delphi_lsp-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="")

{python_delphi_lsp-2.0.0 → python_delphi_lsp-2.0.1}/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"

{python_delphi_lsp-2.0.0 → python_delphi_lsp-2.0.1}/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"
 
 

python_delphi_lsp-2.0.1/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"]

{python_delphi_lsp-2.0.0 → python_delphi_lsp-2.0.1}/delphi_lsp/agent_protocol.py

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

{python_delphi_lsp-2.0.0 → python_delphi_lsp-2.0.1}/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(),