python-delphi-lsp 2.0.0__py3-none-any.whl → 2.0.2__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.2"

delphi_lsp/agent_cli.py

@@ -44,6 +44,7 @@ def build_parser() -> argparse.ArgumentParser:
             "implementation",
             "references",
             "problems",
+            "metrics",
         ],
     )
     view.add_argument("--query", default="")
@@ -66,11 +67,19 @@ def build_parser() -> argparse.ArgumentParser:
 
     opencode = subcommands.add_parser("opencode", help="Install opencode integration.")
     opencode_commands = opencode.add_subparsers(dest="opencode_command", required=True)
-    opencode_install = opencode_commands.add_parser("install", help="Install .agents skill and opencode plugin.")
+    opencode_install = opencode_commands.add_parser(
+        "install", help="Install the package-named skill, Markdown agent, and OpenCode plugin."
+    )
     opencode_install.add_argument("--target", type=Path, default=Path("."))
     opencode_install.add_argument("--python", default=sys.executable)
     opencode_install.add_argument("--force", action="store_true")
-    opencode_install.add_argument("--write-config", action="store_true")
+    opencode_install.add_argument(
+        "--write-agent",
+        "--write-config",
+        dest="write_config",
+        action="store_true",
+        help="Deprecated compatibility option; the Markdown agent is always installed and opencode.json is never touched.",
+    )
     opencode_install.set_defaults(func=_opencode_install)
 
     worker = subcommands.add_parser("worker", help="Serve Protocol v2 NDJSON requests.")
@@ -138,7 +147,7 @@ def _skill_install(args: argparse.Namespace) -> None:
 
 
 def _opencode_install(args: argparse.Namespace) -> None:
-    skill_path, plugin_path, config_path = install_opencode_support(
+    skill_path, plugin_path, agent_path = install_opencode_support(
         args.target,
         python_executable=args.python,
         force=args.force,
@@ -146,8 +155,7 @@ def _opencode_install(args: argparse.Namespace) -> None:
     )
     print(skill_path)
     print(plugin_path)
-    if config_path is not None:
-        print(config_path)
+    print(agent_path)
 
 
 def _worker(args: argparse.Namespace) -> None:

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

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import hashlib
 from pathlib import Path
 import json
 import os
@@ -7,14 +8,20 @@ import secrets
 import stat
 
 
-SKILL_NAME = "delphi-codebase-navigator"
+SKILL_NAME = "python-delphi-lsp"
+AGENT_NAME = "python-delphi-lsp"
+_LEGACY_SKILL_NAME = "delphi-codebase-navigator"
+_LEGACY_SKILL_RELATIVE_PATH = Path(".agents") / "skills" / _LEGACY_SKILL_NAME / "SKILL.md"
+_LEGACY_SKILL_SHA256 = "0843d37bd48431c2b992f191b985175a3c60fe5b56d28e0a46b5e18db6383b28"
 _LEGACY_TOOL_RELATIVE_PATH = Path(".opencode") / "tools" / "delphi_codebase.ts"
 
 
 def install_skill(target: str | Path, *, force: bool = False) -> Path:
     target_path = Path(target).expanduser().resolve()
+    legacy_path = _preflight_legacy_skill(target_path, force=force)
     skill_path = target_path / ".agents" / "skills" / SKILL_NAME / "SKILL.md"
     _write_text(skill_path, _skill_markdown(), force=force)
+    _remove_legacy_skill(legacy_path)
     return skill_path
 
 
@@ -24,26 +31,30 @@ def install_opencode_support(
     python_executable: str,
     force: bool = False,
     write_config: bool = False,
-) -> tuple[Path, Path, Path | None]:
+) -> tuple[Path, Path, Path]:
     target_path = Path(target).expanduser().resolve()
     legacy_path = target_path / _LEGACY_TOOL_RELATIVE_PATH
+    legacy_skill_path = _preflight_legacy_skill(target_path, force=force)
     skill_path = target_path / ".agents" / "skills" / SKILL_NAME / "SKILL.md"
     plugin_path = target_path / ".opencode" / "plugins" / "delphi_codebase.ts"
-    config_path = target_path / "opencode.json" if write_config else None
+    agent_path = target_path / ".opencode" / "agents" / f"{AGENT_NAME}.md"
     skill_text = _skill_markdown()
     plugin_text = _opencode_plugin(python_executable)
+    agent_text = _agent_markdown()
 
     legacy_before = _preflight_legacy(legacy_path, force=force)
     snapshots: dict[Path, bytes | None] = {
         legacy_path: legacy_before,
+        **(
+            {legacy_skill_path: legacy_skill_path.read_bytes()}
+            if legacy_skill_path is not None
+            else {}
+        ),
         skill_path: _preflight_destination(skill_path, skill_text, force=force),
         plugin_path: _preflight_destination(plugin_path, plugin_text, force=force),
+        agent_path: _preflight_destination(agent_path, agent_text, force=force),
     }
-    writes = [(skill_path, skill_text), (plugin_path, plugin_text)]
-    if config_path is not None:
-        config_before, config_text = _render_opencode_config(config_path)
-        snapshots[config_path] = config_before
-        writes.append((config_path, config_text))
+    writes = [(skill_path, skill_text), (plugin_path, plugin_text), (agent_path, agent_text)]
 
     try:
         for path, text in writes:
@@ -51,11 +62,39 @@ def install_opencode_support(
                 _write_text(path, text, force=True)
         if legacy_before is not None:
             legacy_path.unlink()
+        _remove_legacy_skill(legacy_skill_path)
     except BaseException:
         for path, content in reversed(tuple(snapshots.items())):
             _restore_file(path, content)
         raise
-    return skill_path, plugin_path, config_path
+    _ = write_config  # Deprecated compatibility input; user configuration is never touched.
+    return skill_path, plugin_path, agent_path
+
+
+def _preflight_legacy_skill(target: Path, *, force: bool) -> Path | None:
+    legacy_path = target / _LEGACY_SKILL_RELATIVE_PATH
+    legacy_path.relative_to(target)
+    _reject_symbolic_link(legacy_path)
+    if not legacy_path.exists():
+        return None
+    if not legacy_path.is_file():
+        raise FileExistsError(f"Legacy skill path is not a file: {legacy_path}")
+    digest = hashlib.sha256(legacy_path.read_bytes()).hexdigest()
+    if digest != _LEGACY_SKILL_SHA256 and not force:
+        raise FileExistsError(
+            f"Refusing to remove modified legacy skill without force: {legacy_path}"
+        )
+    return legacy_path
+
+
+def _remove_legacy_skill(path: Path | None) -> None:
+    if path is None:
+        return
+    path.unlink()
+    try:
+        path.parent.rmdir()
+    except OSError:
+        pass
 
 
 def _preflight_legacy(legacy_path: Path, *, force: bool) -> bytes | None:
@@ -157,13 +196,18 @@ def _write_bytes_atomic(path: Path, content: bytes) -> None:
 
 
 def _reject_symbolic_link(path: Path) -> None:
-    if path.is_symlink():
-        raise FileExistsError(f"Generated destination must not be a symbolic link: {path}")
+    current = path
+    while current != current.parent:
+        if current.is_symlink():
+            raise FileExistsError(
+                f"Generated destination must not contain a symbolic link: {current}"
+            )
+        current = current.parent
 
 
 def _skill_markdown() -> str:
     return """---
-name: delphi-codebase-navigator
+name: python-delphi-lsp
 description: Inspect Delphi and Object Pascal codebases through the Protocol v2 semantic navigator.
 compatibility: opencode
 metadata:
@@ -181,13 +225,47 @@ 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.
+"""
+
+
+def _agent_markdown() -> str:
+    return """---
+description: Inspect Delphi and Object Pascal codebases through python-delphi-lsp.
+mode: subagent
+temperature: 0
+tools:
+  delphi_codebase: true
+  skill: true
+  lsp: false
+  bash: false
+  read: false
+  glob: false
+  grep: false
+  edit: false
+  write: false
+  task: false
+  webfetch: false
+  todowrite: false
+permission:
+  "*": deny
+  delphi_codebase: allow
+  skill:
+    "*": deny
+    python-delphi-lsp: allow
+---
+
+Load `python-delphi-lsp` first, then use only `delphi_codebase` for Delphi and
+Object Pascal codebase inspection. Do not use `lsp`, `bash`, `read`, `glob`,
+`grep`, `edit`, `write`, `task`, `webfetch`, or `todowrite`. Preserve returned
+citations exactly and report partial or ambiguous semantic evidence explicitly.
 """
 
 
@@ -199,7 +277,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 +542,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(),
@@ -524,56 +602,4 @@ export const DelphiCodebasePlugin: Plugin = async (_input) => {
     return template.replace("__PYTHON_EXECUTABLE__", python_json)
 
 
-def _render_opencode_config(config_path: Path) -> tuple[bytes | None, str]:
-    _reject_symbolic_link(config_path)
-    if config_path.exists():
-        if not config_path.is_file():
-            raise ValueError(f"opencode config path is not a file: {config_path}")
-        config_before = config_path.read_bytes()
-        config = json.loads(config_before.decode("utf-8"))
-    else:
-        config_before = None
-        config = {"$schema": "https://opencode.ai/config.json"}
-    if not isinstance(config, dict):
-        raise ValueError("opencode config must be a JSON object")
-    if "agent" not in config:
-        agents = {}
-        config["agent"] = agents
-    else:
-        agents = config["agent"]
-    if not isinstance(agents, dict):
-        raise ValueError("opencode config field 'agent' must be a JSON object")
-    agents["vllm-delphi-codebase"] = {
-        "description": "Use the Delphi codebase navigator skill and plugin without direct filesystem source inspection.",
-        "temperature": 0,
-        "prompt": (
-            "load delphi-codebase-navigator first, then use only delphi_codebase for Delphi/Object Pascal "
-            "codebase inspection. Do not use lsp, bash, read, glob, grep, edit, write, task, webfetch, or todowrite."
-        ),
-        "tools": {
-            "delphi_codebase": True,
-            "skill": True,
-            "lsp": False,
-            "bash": False,
-            "read": False,
-            "glob": False,
-            "grep": False,
-            "edit": False,
-            "write": False,
-            "task": False,
-            "webfetch": False,
-            "todowrite": False,
-        },
-        "permission": {
-            "delphi_codebase": "allow",
-            "skill": {
-                "*": "deny",
-                SKILL_NAME: "allow",
-            },
-            "lsp": "deny",
-        },
-    }
-    return config_before, json.dumps(config, indent=2, sort_keys=True) + "\n"
-
-
 __all__ = ["SKILL_NAME", "install_opencode_support", "install_skill"]