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

delphi_lsp/_version.py

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

delphi_lsp/agent_cli.py

@@ -67,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.")
@@ -139,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,
@@ -147,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

@@ -3,6 +3,7 @@ from __future__ import annotations
 from bisect import bisect_left, bisect_right
 from collections.abc import Mapping
 from dataclasses import dataclass
+from heapq import heappop, heappush
 import hashlib
 import json
 from pathlib import Path, PureWindowsPath
@@ -14,13 +15,12 @@ from .agent_protocol import (
     AgentResponse,
     ContextBudget,
     Focus,
-    Page,
     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 AgentWorkspace, unit_display_path, unit_source_path, unit_target_id
+from .agent_workspace import AgentUnit, 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
@@ -121,6 +121,10 @@ class _SourceDocument:
         self.tokens = tuple(_lex_delphi(text))
         self.token_starts = tuple(token.start for token in self.tokens)
         self.directive_starts = tuple(token.start for token in self.tokens if token.directive)
+        self.declaration_section_indexes = [0]
+        self.declaration_section_checkpoints: dict[int, tuple[str, int, int, int]] = {
+            0: ("", 0, 0, 0)
+        }
         words = [token for token in self.tokens if token.word and not token.escaped]
         self.unit_kind = next(
             (token.value for token in words if token.value in {"unit", "program", "library", "package"}),
@@ -129,6 +133,7 @@ class _SourceDocument:
         implementation = next((token for token in words if token.value == "implementation"), None)
         self.implementation_line = self.line_col(implementation.start)[0] if implementation else 0
         self.routine_spans: dict[int, tuple[int, int] | None] = {}
+        self.routine_token_spans: dict[int, tuple[int, int, int] | None] = {}
         self.parser_spans: dict[str, tuple[int, int] | None] = {}
         self._full_parse_attempted = False
         self._full_parse_result: object | None = None
@@ -230,6 +235,7 @@ class _Registry:
     entries: tuple[_SymbolEntry, ...]
     by_target: dict[str, _SymbolEntry]
     sources: dict[Path, _SourceDocument]
+    ranked_queries: dict[str, tuple[_SymbolEntry, ...]]
 
 
 class AgentContext:
@@ -280,7 +286,12 @@ class AgentContext:
             return self._handle_focus(parsed, revision)
         if parsed.action == "find":
             registry = self._require_registry(revision)
-            items = [entry.card() for entry in _ranked_entries(registry.entries, parsed.query)]
+            ranked = registry.ranked_queries.get(parsed.query)
+            if ranked is None:
+                ranked = tuple(_ranked_entries(registry.entries, parsed.query))
+                registry.ranked_queries.clear()
+                registry.ranked_queries[parsed.query] = ranked
+            items = [entry.card() for entry in ranked]
             return self._response(parsed, revision, items)
         if parsed.action == "inspect":
             registry = self._require_registry(revision)
@@ -293,9 +304,10 @@ class AgentContext:
         previous_project_id = self._workspace.active_project_id
         selected_project_id = requested_project_id or previous_project_id
         if selected_project_id:
-            self._workspace.select_project(selected_project_id)
+            revision = self._workspace._select_project_with_revision(selected_project_id)
+        else:
+            revision = self._workspace.workspace_revision
         current_project_id = self._workspace.active_project_id
-        revision = self._workspace.workspace_revision
 
         if current_project_id != previous_project_id:
             self._registry = None
@@ -782,6 +794,7 @@ def _build_registry(workspace: AgentWorkspace, project_id: str, revision: str) -
         entries=entries_tuple,
         by_target={entry.target_id: entry for entry in entries_tuple},
         sources=sources,
+        ranked_queries={},
     )
 
 
@@ -925,32 +938,47 @@ def _correct_outline_symbol_kind(document: _SourceDocument, symbol: Symbol) -> N
         symbol.kind = SymbolKind.TYPE
 
 
+def _advance_declaration_section(
+    state: tuple[str, int, int, int],
+    token: _Token,
+) -> tuple[str, int, int, int]:
+    section, parentheses, brackets, angles = state
+    if token.directive:
+        return state
+    if token.value == "(":
+        parentheses += 1
+    elif token.value == ")":
+        parentheses = max(0, parentheses - 1)
+    elif token.value == "[":
+        brackets += 1
+    elif token.value == "]":
+        brackets = max(0, brackets - 1)
+    elif token.value == "<":
+        angles += 1
+    elif token.value == ">":
+        angles = max(0, angles - 1)
+    elif not parentheses and not brackets and not angles and token.word:
+        if token.value in {"const", "resourcestring", "threadvar", "type", "var"}:
+            section = token.value
+        elif token.value in {"implementation", "initialization", "finalization"}:
+            section = ""
+    return section, parentheses, brackets, angles
+
+
 def _declaration_section(document: _SourceDocument, offset: int) -> str:
-    section = ""
-    parentheses = 0
-    brackets = 0
-    angles = 0
-    for token in document.tokens[:document.first_token_index(offset)]:
-        if token.directive:
-            continue
-        if token.value == "(":
-            parentheses += 1
-        elif token.value == ")":
-            parentheses = max(0, parentheses - 1)
-        elif token.value == "[":
-            brackets += 1
-        elif token.value == "]":
-            brackets = max(0, brackets - 1)
-        elif token.value == "<":
-            angles += 1
-        elif token.value == ">":
-            angles = max(0, angles - 1)
-        elif not any((parentheses, brackets, angles)) and token.word:
-            if token.value in {"const", "resourcestring", "threadvar", "type", "var"}:
-                section = token.value
-            elif token.value in {"implementation", "initialization", "finalization"}:
-                section = ""
-    return section
+    target_index = document.first_token_index(offset)
+    cached = document.declaration_section_checkpoints.get(target_index)
+    if cached is not None:
+        return cached[0]
+    checkpoint_position = bisect_right(document.declaration_section_indexes, target_index) - 1
+    checkpoint_index = document.declaration_section_indexes[checkpoint_position]
+    state = document.declaration_section_checkpoints[checkpoint_index]
+    for token in document.tokens[checkpoint_index:target_index]:
+        state = _advance_declaration_section(state, token)
+    insert_at = bisect_left(document.declaration_section_indexes, target_index)
+    document.declaration_section_indexes.insert(insert_at, target_index)
+    document.declaration_section_checkpoints[target_index] = state
+    return state[0]
 
 
 def _declared_symbol_name(document: _SourceDocument, symbol: Symbol) -> str:
@@ -1208,20 +1236,47 @@ def _exclude_routine_locals(
         span = _raw_routine_span(raw, document)
         if span is not None:
             containers.append((span[0], span[1], raw))
+    if not containers:
+        return symbols
 
-    filtered: list[_RawSymbol] = []
-    for raw in symbols:
-        offset = document.offset(
-            raw.symbol.decl_range.start_line,
-            raw.symbol.decl_range.start_col,
+    containers.sort(key=lambda item: (item[0], item[1]))
+    positioned = sorted(
+        (
+            document.offset(
+                raw.symbol.decl_range.start_line,
+                raw.symbol.decl_range.start_col,
+            ),
+            order,
+            raw,
         )
-        if any(
-            start < offset < end and raw is not container
-            for start, end, container in containers
+        for order, raw in enumerate(symbols)
+    )
+    active_ends: list[tuple[int, int, int]] = []
+    active_ids: set[int] = set()
+    excluded_orders: set[int] = set()
+    container_index = 0
+    for offset, order, raw in positioned:
+        while (
+            container_index < len(containers)
+            and containers[container_index][0] < offset
         ):
-            continue
-        filtered.append(raw)
-    return filtered
+            _, end, container = containers[container_index]
+            container_id = id(container)
+            heappush(active_ends, (end, container_index, container_id))
+            active_ids.add(container_id)
+            container_index += 1
+        while active_ends and active_ends[0][0] <= offset:
+            _, _, container_id = heappop(active_ends)
+            active_ids.discard(container_id)
+        raw_id = id(raw)
+        if active_ids and (raw_id not in active_ids or len(active_ids) > 1):
+            excluded_orders.add(order)
+
+    return [
+        raw
+        for order, raw in enumerate(symbols)
+        if order not in excluded_orders
+    ]
 
 
 def _raw_routine_span(
@@ -1523,6 +1578,7 @@ def _routine_span(
         document.tokens,
         document.token_starts,
         token_index,
+        cache=document.routine_token_spans,
     )
     span = (start, found[1]) if found is not None else None
     document.routine_spans[start] = span
@@ -1534,6 +1590,7 @@ def _find_routine_token_span(
     token_starts: tuple[int, ...],
     start_index: int,
     *,
+    cache: dict[int, tuple[int, int, int] | None] | None = None,
     depth: int = 0,
 ) -> tuple[int, int, int] | None:
     if depth > 64:
@@ -1541,56 +1598,100 @@ def _find_routine_token_span(
     routine_index = _routine_keyword_index(tokens, start_index)
     if routine_index is None:
         return None
+    spans = cache if cache is not None else {}
+    missing = object()
+    cached = spans.get(routine_index, missing)
+    if cached is not missing:
+        if cached is None:
+            return None
+        return tokens[start_index].start, cached[1], cached[2]
+
     heading_end = _heading_semicolon_index(tokens, routine_index)
     if heading_end is None:
+        spans[routine_index] = None
         return None
 
-    index = heading_end + 1
-    while index < len(tokens):
+    frames: list[list[int]] = [[routine_index, heading_end + 1]]
+
+    def reject_active_frames() -> None:
+        for active_routine_index, _ in frames:
+            spans[active_routine_index] = None
+        frames.clear()
+
+    while frames:
+        frame = frames[-1]
+        frame_routine_index, index = frame
+        if index >= len(tokens):
+            reject_active_frames()
+            continue
+
         token = tokens[index]
         if token.directive:
-            return None
+            reject_active_frames()
+            continue
         if token.word and not token.escaped:
             if token.value in _NO_BODY_DIRECTIVES:
-                return None
+                spans[frame_routine_index] = None
+                frames.pop()
+                continue
             if token.value in {"implementation", "initialization", "finalization"}:
-                return None
+                reject_active_frames()
+                continue
             if (
                 token.value in _STRUCTURED_TYPE_WORDS
                 and _is_structured_type_opener(tokens, index)
             ):
                 if index + 1 < len(tokens) and tokens[index + 1].value == ";":
-                    index += 2
+                    frame[1] = index + 2
                     continue
                 structured_end = _match_end_terminated_block(tokens, index)
                 if structured_end is None:
-                    return None
-                index = bisect_left(token_starts, structured_end)
+                    reject_active_frames()
+                    continue
+                frame[1] = bisect_left(token_starts, structured_end)
                 continue
             if token.value == "end":
-                return None
+                reject_active_frames()
+                continue
             if token.value in {"begin", "asm"}:
                 end = _match_end_terminated_block(tokens, index)
                 if end is None:
-                    return None
+                    reject_active_frames()
+                    continue
                 end_index = bisect_left(token_starts, end)
-                return tokens[start_index].start, end, end_index
-            if token.value in _ROUTINE_WORDS and _is_nested_routine_declaration(tokens, index):
-                nested = _find_routine_token_span(
-                    tokens,
-                    token_starts,
-                    index,
-                    depth=depth + 1,
+                spans[frame_routine_index] = (
+                    tokens[frame_routine_index].start,
+                    end,
+                    end_index,
                 )
+                frames.pop()
+                continue
+            if token.value in _ROUTINE_WORDS and _is_nested_routine_declaration(tokens, index):
+                nested_routine_index = _routine_keyword_index(tokens, index)
+                if nested_routine_index is None:
+                    frame[1] = index + 1
+                    continue
+                nested = spans.get(nested_routine_index, missing)
+                if nested is missing:
+                    nested_heading_end = _heading_semicolon_index(tokens, nested_routine_index)
+                    if nested_heading_end is None:
+                        spans[nested_routine_index] = None
+                        continue
+                    frames.append([nested_routine_index, nested_heading_end + 1])
+                    continue
                 if nested is not None:
-                    index = max(index + 1, nested[2])
+                    frame[1] = max(index + 1, nested[2])
                     continue
                 skipped = _routine_declaration_end_index(tokens, index)
                 if skipped is not None:
-                    index = skipped + 1
+                    frame[1] = skipped + 1
                     continue
-        index += 1
-    return None
+        frame[1] = index + 1
+
+    result = spans.get(routine_index)
+    if result is None:
+        return None
+    return tokens[start_index].start, result[1], result[2]
 
 
 def _routine_keyword_index(

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:
@@ -192,6 +236,42 @@ Prefer `summary` and `declaration`, narrow `max_items` and `max_chars`, and requ
 """
 
 
+def _agent_markdown() -> str:
+    return """---
+description: Inspect Delphi and Object Pascal codebases through python-delphi-lsp.
+mode: all
+temperature: 0
+permission:
+  delphi_codebase: allow
+  skill:
+    "*": deny
+    python-delphi-lsp: allow
+  lsp: deny
+  bash: deny
+  read: deny
+  glob: deny
+  grep: deny
+  list: deny
+  edit: deny
+  write: deny
+  patch: deny
+  task: deny
+  webfetch: deny
+  websearch: deny
+  question: deny
+  todowrite: deny
+  todoread: deny
+  codebase_map: deny
+  code_guidelines: deny
+---
+
+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.
+"""
+
+
 def _opencode_plugin(python_executable: str) -> str:
     python_json = json.dumps(python_executable)
     template = '''import { tool, type Plugin } from "@opencode-ai/plugin"
@@ -525,56 +605,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"]

delphi_lsp/agent_workspace.py

@@ -264,6 +264,9 @@ class AgentWorkspace:
         return f"workspace_v2_{fingerprint}"
 
     def select_project(self, project_id: str) -> None:
+        self._select_project_with_revision(project_id)
+
+    def _select_project_with_revision(self, project_id: str) -> str:
         if project_id not in self._project_paths:
             raise AgentProtocolError("project_not_found", f"Project not found: {project_id}.")
         project_path = self._project_paths[project_id]
@@ -280,7 +283,7 @@ class AgentWorkspace:
             fingerprint = _selection_fingerprint(discovery, cached.result, root=self._root)
             if fingerprint == cached.fingerprint:
                 self._activate_project(project_id, discovery, cached.result)
-                return
+                return f"workspace_v2_{fingerprint}"
 
         if project_path is None:
             result = _catalog_workspace_sources(discovery)
@@ -292,11 +295,13 @@ class AgentWorkspace:
                 source_transform=_outline_agent_source,
             )
             result = indexer.index(str(project_path))
+        fingerprint = _selection_fingerprint(discovery, result, root=self._root)
         self._project_cache[project_id] = _ProjectCache(
             result=result,
-            fingerprint=_selection_fingerprint(discovery, result, root=self._root),
+            fingerprint=fingerprint,
         )
         self._activate_project(project_id, discovery, result)
+        return f"workspace_v2_{fingerprint}"
 
     def _activate_project(
         self,

{python_delphi_lsp-2.0.1.dist-info → python_delphi_lsp-2.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-delphi-lsp
-Version: 2.0.1
+Version: 2.0.3
 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.1 is authored by Dark Light and supports Windows, macOS, and Linux.
+Version 2.0.3 is authored by Dark Light and supports Windows, macOS, and Linux.
 
 ## Install and quick start
 
@@ -177,7 +177,7 @@ delphi-lsp-agent view --root PATH [--project-file FILE] --layer LAYER
 delphi-lsp-agent index --root PATH [--project-file FILE] [--out FILE]
 delphi-lsp-agent skill install [--target PATH] [--force]
 delphi-lsp-agent opencode install [--target PATH] [--python PYTHON]
-                                  [--force] [--write-config]
+                                  [--force] [--write-agent|--write-config]
 delphi-lsp-agent worker --root PATH [--project-file FILE]
 ```
 
@@ -187,8 +187,9 @@ delphi-lsp-agent worker --root PATH [--project-file FILE]
 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.
+writes the skill; `opencode install` writes the package-named skill, Markdown
+agent, and plugin. The two deprecated write flags are harmless aliases and do
+not change user configuration.
 `worker` serves NDJSON over standard input/output.
 
 Protocol v2 actions are `open`, `find`, `inspect`, `trace`, `focus`,
@@ -225,49 +226,63 @@ optimization does not remove LSP functionality.
 Install the generated integration in a worktree:
 
 ```bash
-delphi-lsp-agent opencode install --target . --write-config
+delphi-lsp-agent opencode install --target .
 ```
 
 It writes:
 
 ```text
-.agents/skills/delphi-codebase-navigator/SKILL.md
+.agents/skills/python-delphi-lsp/SKILL.md
 .opencode/plugins/delphi_codebase.ts
+.opencode/agents/python-delphi-lsp.md
 ```
 
-The generated configuration enables only the named
-`delphi-codebase-navigator` skill and `delphi_codebase`. It denies
+The package-named Markdown agent enables only the
+`python-delphi-lsp` skill and `delphi_codebase`. It denies
 `bash`, `read`, `glob`, `grep`, and `lsp`, along with edit/write and
 other raw source tools. The skill is enabled. The installer does not use the
-retired `.opencode/tools` path.
+retired `.opencode/tools` path and never reads or changes `opencode.json`; that
+file remains entirely user-owned. The deprecated `--write-config` and
+`--write-agent` options are accepted harmlessly for compatibility.
 
 The plugin maintains one worker per session/root, reusing focus and indexes.
 During compaction it restores the focus and summary into the new context.
 Transport failure, session deletion, and plugin disposal clean up the worker.
 
-A generated OpenCode agent looks like this; providers and unrelated agents stay
-unchanged:
-
-```json
-{
-  "agent": {
-    "vllm-delphi-codebase": {
-      "tools": {
-        "delphi_codebase": true, "skill": true, "lsp": false,
-        "bash": false, "read": false, "glob": false, "grep": false
-      },
-      "permission": {
-        "delphi_codebase": "allow",
-        "skill": {"*": "deny", "delphi-codebase-navigator": "allow"},
-        "lsp": "deny"
-      }
-    }
-  }
-}
+A generated OpenCode agent starts with this Markdown frontmatter:
+
+```markdown
+---
+description: Inspect Delphi and Object Pascal codebases through python-delphi-lsp.
+mode: all
+temperature: 0
+permission:
+  delphi_codebase: allow
+  skill:
+    "*": deny
+    python-delphi-lsp: allow
+  lsp: deny
+  bash: deny
+  read: deny
+  glob: deny
+  grep: deny
+  list: deny
+  edit: deny
+  write: deny
+  patch: deny
+  task: deny
+  webfetch: deny
+  websearch: deny
+  question: deny
+  todowrite: deny
+  todoread: deny
+  codebase_map: deny
+  code_guidelines: deny
+---
 ```
 
-Select `vllm-delphi-codebase`, ask it to load
-`delphi-codebase-navigator`, then use `delphi_codebase` actions such as
+Select `python-delphi-lsp`, ask it to load the `python-delphi-lsp` skill, then
+use `delphi_codebase` actions such as
 `open`, `find`, `focus`, and `inspect`. Use semantic tool calls, not raw
 source tools.
 

{python_delphi_lsp-2.0.1.dist-info → python_delphi_lsp-2.0.3.dist-info}/RECORD

@@ -1,13 +1,13 @@
 delphi_lsp/__init__.py,sha256=Gtoeg_D3hLGCFi34wdYiKrIByAbkWe1zS84v6_KJ6_4,3768
-delphi_lsp/_version.py,sha256=wAxkK8w13vqoF47A8iqWdSlIgRRXmZiQ0R4wePZfzhs,22
-delphi_lsp/agent_cli.py,sha256=FY5h_rmbPLBAtr8NWL5IyzqEaJBJm7Y5IQptvlt8l4Y,9022
-delphi_lsp/agent_context.py,sha256=VCWiqIhLPQX6-_4P_kYHLKMZK7ia0c1mbFC7RcbQsOY,73316
+delphi_lsp/_version.py,sha256=_GEKEa6BYjBV34SZkSlAR87aCM5Y9G0aSI0LXL52iJg,22
+delphi_lsp/agent_cli.py,sha256=Mma4C1Ca_Hd_9dl0mePT7uIypw6j6gDWdKu9XxIMXQQ,9226
+delphi_lsp/agent_context.py,sha256=FdRQ2MFGDcqBDGMnD0w2X8p1kB3YwyTPDm_4cdCmwbA,77504
 delphi_lsp/agent_layers.py,sha256=7TmplTL7m_riS8BxZCD-3j1p8iOGiD9QWHay5ZcDYiw,21369
 delphi_lsp/agent_metrics.py,sha256=6y9DrSnKitZbwRFQrofanw6k89YGqbvEacqgSKHgh2c,2695
 delphi_lsp/agent_protocol.py,sha256=cZ1LIMhrkOb5CqiGcjSH1eZUNqtJCYySUc54h-PCyOs,12551
 delphi_lsp/agent_relations.py,sha256=pXhuCjfwmicG3VG7lYtGvKKv-mFPQ_hJ3w0eavqMoV0,32900
-delphi_lsp/agent_templates.py,sha256=U6ldX6RpdpttF5D0QSAi_OsqkcCe30Jc75hyhV3geHQ,21305
-delphi_lsp/agent_workspace.py,sha256=nnLwjLzkh_gsBxz8Czl_Q1OHRya7mHENGhmBi8br6AE,23527
+delphi_lsp/agent_templates.py,sha256=LXtbAPj0Nxvp3ycZARPELEb51BFoi2vtiCe-pYHNteE,21834
+delphi_lsp/agent_workspace.py,sha256=HvCWfMVv08Jlx257my4hkkXCLUNoPcy5AAnOnl_mNUU,23761
 delphi_lsp/binary.py,sha256=40mEpE0SBYmifwEoNHwSU7IU_D2usVyWYWHJ73aDfoo,8529
 delphi_lsp/comment_builder.py,sha256=XvFW7WTbYy7yGN3MG40gtabTvhGj1ea1MYkySDbVMDA,832
 delphi_lsp/consts.py,sha256=qM40iwxXmvEileWHJVLMYlQSkLoLyQaqM-Zscz3VJbs,5958
@@ -26,9 +26,9 @@ delphi_lsp/semantic_builder.py,sha256=ulA7xHJpltjc6cTo5wh9yTcYazuIykM-YLMXD1h-wz
 delphi_lsp/source_reader.py,sha256=HWiw25sLVZ6s1GGpMl17uZ-o68HoxTEd3Z0__m1vsSE,520
 delphi_lsp/workspace.py,sha256=TU__SujItRlW8hB2kuYC7ZJx1WQVOj7frYxvo7rDqeI,2137
 delphi_lsp/writer.py,sha256=j-cnyiHFNOTFECL7Ehm-m43ye7ev7qFeCCscFMjrAOY,2503
-python_delphi_lsp-2.0.1.dist-info/licenses/LICENSE,sha256=-rPda9qyJvHAhjCx3ZF-Efy07F4eAg4sFvg6ChOGPoU,16726
-python_delphi_lsp-2.0.1.dist-info/METADATA,sha256=4CthXJEauAQJm7-BDm1iDnMdj9-Eovu-py69_ALNiPY,14621
-python_delphi_lsp-2.0.1.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-python_delphi_lsp-2.0.1.dist-info/entry_points.txt,sha256=rh_yGH7diowge_acQcST87A-ewH1QezEsAYC8T5ineY,103
-python_delphi_lsp-2.0.1.dist-info/top_level.txt,sha256=0Zp0sjw5Qtic3EQX9zNeegURga8NuXk6c2e9PN-3OTs,11
-python_delphi_lsp-2.0.1.dist-info/RECORD,,
+python_delphi_lsp-2.0.3.dist-info/licenses/LICENSE,sha256=-rPda9qyJvHAhjCx3ZF-Efy07F4eAg4sFvg6ChOGPoU,16726
+python_delphi_lsp-2.0.3.dist-info/METADATA,sha256=Dw8iQ0nH5GwHL2eIbYPEMXpVcoMp0Mc0tkGltO7iUMo,14942
+python_delphi_lsp-2.0.3.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+python_delphi_lsp-2.0.3.dist-info/entry_points.txt,sha256=rh_yGH7diowge_acQcST87A-ewH1QezEsAYC8T5ineY,103
+python_delphi_lsp-2.0.3.dist-info/top_level.txt,sha256=0Zp0sjw5Qtic3EQX9zNeegURga8NuXk6c2e9PN-3OTs,11
+python_delphi_lsp-2.0.3.dist-info/RECORD,,