python-delphi-lsp 1.1.0__tar.gz → 1.1.1__tar.gz

{python_delphi_lsp-1.1.0/python_delphi_lsp.egg-info → python_delphi_lsp-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-delphi-lsp
-Version: 1.1.0
+Version: 1.1.1
 Summary: Python Delphi/Object Pascal parser, semantic indexer, and language server.
 Author: Dark Light
 License-Expression: MPL-2.0
@@ -191,13 +191,19 @@ delphi-lsp-agent view --root . --layer overview
 delphi-lsp-agent view --root . --layer projects
 delphi-lsp-agent view --root . --layer unit --query Mega100kUnit
 delphi-lsp-agent view --root . --layer symbols --query TWorker --format json
+delphi-lsp-agent view --root . --layer implementation --query TWorker.Run
+delphi-lsp-agent view --root . --layer implementation --query TWorker --format json
 delphi-lsp-agent view --root . --layer problems
 ```
 
 Available layers are `overview`, `projects`, `units`, `unit`, `symbols`,
-`symbol`, `references`, and `problems`. The output includes file and line
-citations, declarations, ownership, visibility, type information, and
-dependency/problem summaries. Routine bodies are not emitted.
+`symbol`, `implementation`, `references`, and `problems`. The output includes
+file and line citations, declarations, ownership, visibility, type information,
+and dependency/problem summaries. Outline layers keep routine bodies out of the
+agent context. Use `implementation` with a concrete class, routine, or member
+query to read only that complete source fragment from the original file. For a
+class query, the layer returns the class declaration plus matching method
+implementations; for a routine query, it returns the full routine body.
 
 ## opencode Usage
 
@@ -380,13 +386,17 @@ python scripts/bootstrap_vllm_codebase_skill_test.py --start-vllm
 ```
 
 This skill probe defaults the vLLM helper to `MAX_MODEL_LEN=32768`, which was
-the stable local Metal setting for the complete skill + `delphi_codebase` tool
-call. Override with `--max-model-len` when your machine has enough headroom.
-
-The probe requires opencode to load `delphi-codebase-navigator`, call
-`delphi_codebase`, and find `MegaProc02500`. It fails if opencode uses `bash`,
-`read`, `glob`, `grep`, `edit`, `write`, `task`, `webfetch`, or `todowrite`
-before the required evidence is complete.
+the stable local Metal setting for the reduced codebase-agent prompt plus the
+`delphi_codebase` tool call. Override with `--max-model-len` when your machine
+has enough headroom.
+
+The probe verifies that the `delphi-codebase-navigator` skill is installed, then
+requires opencode to call `delphi_codebase`, find `MegaProc02500`, and read the
+method body through the `implementation` layer. The vLLM test agent keeps
+opencode's generic `skill` tool disabled so the model context stays focused on
+the Delphi navigation tool. The probe fails if opencode uses `bash`, `read`,
+`glob`, `grep`, `edit`, `write`, `task`, `webfetch`, or `todowrite` before the
+required evidence is complete.
 
 ## Verification
 

{python_delphi_lsp-1.1.0 → python_delphi_lsp-1.1.1}/README.md

@@ -152,13 +152,19 @@ delphi-lsp-agent view --root . --layer overview
 delphi-lsp-agent view --root . --layer projects
 delphi-lsp-agent view --root . --layer unit --query Mega100kUnit
 delphi-lsp-agent view --root . --layer symbols --query TWorker --format json
+delphi-lsp-agent view --root . --layer implementation --query TWorker.Run
+delphi-lsp-agent view --root . --layer implementation --query TWorker --format json
 delphi-lsp-agent view --root . --layer problems
 ```
 
 Available layers are `overview`, `projects`, `units`, `unit`, `symbols`,
-`symbol`, `references`, and `problems`. The output includes file and line
-citations, declarations, ownership, visibility, type information, and
-dependency/problem summaries. Routine bodies are not emitted.
+`symbol`, `implementation`, `references`, and `problems`. The output includes
+file and line citations, declarations, ownership, visibility, type information,
+and dependency/problem summaries. Outline layers keep routine bodies out of the
+agent context. Use `implementation` with a concrete class, routine, or member
+query to read only that complete source fragment from the original file. For a
+class query, the layer returns the class declaration plus matching method
+implementations; for a routine query, it returns the full routine body.
 
 ## opencode Usage
 
@@ -341,13 +347,17 @@ python scripts/bootstrap_vllm_codebase_skill_test.py --start-vllm
 ```
 
 This skill probe defaults the vLLM helper to `MAX_MODEL_LEN=32768`, which was
-the stable local Metal setting for the complete skill + `delphi_codebase` tool
-call. Override with `--max-model-len` when your machine has enough headroom.
-
-The probe requires opencode to load `delphi-codebase-navigator`, call
-`delphi_codebase`, and find `MegaProc02500`. It fails if opencode uses `bash`,
-`read`, `glob`, `grep`, `edit`, `write`, `task`, `webfetch`, or `todowrite`
-before the required evidence is complete.
+the stable local Metal setting for the reduced codebase-agent prompt plus the
+`delphi_codebase` tool call. Override with `--max-model-len` when your machine
+has enough headroom.
+
+The probe verifies that the `delphi-codebase-navigator` skill is installed, then
+requires opencode to call `delphi_codebase`, find `MegaProc02500`, and read the
+method body through the `implementation` layer. The vLLM test agent keeps
+opencode's generic `skill` tool disabled so the model context stays focused on
+the Delphi navigation tool. The probe fails if opencode uses `bash`, `read`,
+`glob`, `grep`, `edit`, `write`, `task`, `webfetch`, or `todowrite` before the
+required evidence is complete.
 
 ## Verification
 

{python_delphi_lsp-1.1.0 → python_delphi_lsp-1.1.1}/delphiast/agent_cli.py

@@ -19,7 +19,21 @@ def build_parser() -> argparse.ArgumentParser:
     view = subcommands.add_parser("view", help="Render a layered codebase view.")
     view.add_argument("--root", type=Path, default=Path("."))
     view.add_argument("--project-file", type=Path)
-    view.add_argument("--layer", required=True, choices=["overview", "projects", "units", "unit", "symbols", "symbol", "references", "problems"])
+    view.add_argument(
+        "--layer",
+        required=True,
+        choices=[
+            "overview",
+            "projects",
+            "units",
+            "unit",
+            "symbols",
+            "symbol",
+            "implementation",
+            "references",
+            "problems",
+        ],
+    )
     view.add_argument("--query", default="")
     view.add_argument("--format", default="markdown", choices=["markdown", "json"])
     view.add_argument("--deep-projects", action="store_true", help="Deep-parse project dependencies for the projects layer.")

{python_delphi_lsp-1.1.0 → python_delphi_lsp-1.1.1}/delphiast/agent_layers.py

@@ -8,7 +8,7 @@ import json
 from .lsp_server import build_outline_semantic_model, outline_large_source
 from .project_discovery import DelphiProjectDiscovery, discover_delphi_project
 from .project_indexer import ProjectIndexResult, ProjectIndexer
-from .semantic import Scope, SourceRange, Symbol, SymbolIndex
+from .semantic import Scope, SourceRange, Symbol, SymbolIndex, SymbolKind
 from .semantic_builder import SemanticModel
 from .source_reader import read_source_text
 
@@ -92,6 +92,8 @@ def layer_payload(index: CodebaseIndex, layer: str, *, query: str = "") -> dict[
         return _symbols_payload(index, query=query)
     if normalized_layer == "symbol":
         return _symbol_payload(index, query=query)
+    if normalized_layer == "implementation":
+        return _implementation_payload(index, query=query)
     if normalized_layer == "references":
         return _references_payload(index, query=query)
     if normalized_layer == "problems":
@@ -206,6 +208,142 @@ def _symbol_payload(index: CodebaseIndex, *, query: str) -> dict[str, Any]:
     return {"layer": "symbol", "root": index.root, "query": query, "items": matches[:50]}
 
 
+def _implementation_payload(index: CodebaseIndex, *, query: str) -> dict[str, Any]:
+    needle = query.casefold().strip()
+    if not needle:
+        return {
+            "layer": "implementation",
+            "root": index.root,
+            "query": query,
+            "items": [],
+            "message": "Pass a class, routine, or member name in query to read focused source.",
+        }
+
+    matches = [symbol for symbol in _all_symbols(index) if symbol.name.casefold() == needle]
+    if not matches:
+        matches = [
+            symbol
+            for symbol in _all_symbols(index)
+            if symbol.kind.value != "unit" and needle in symbol.name.casefold()
+        ]
+
+    items: list[dict[str, Any]] = []
+    source_cache: dict[str, list[str]] = {}
+    seen_keys: set[tuple[str, str, int, str]] = set()
+    for symbol in matches:
+        item = _implementation_item(index, symbol, source_cache)
+        if item is None:
+            continue
+        key = (item["name"].casefold(), item["path"], item["line"], item["kind"])
+        if key in seen_keys:
+            continue
+        seen_keys.add(key)
+        items.append(item)
+    items.sort(key=lambda item: (item["path"].casefold(), item["line"], item["name"].casefold()))
+    return {"layer": "implementation", "root": index.root, "query": query, "items": items[:50]}
+
+
+def _implementation_item(
+    index: CodebaseIndex,
+    symbol: Symbol,
+    source_cache: dict[str, list[str]],
+) -> dict[str, Any] | None:
+    fragments: list[dict[str, Any]] = []
+    if symbol.kind in {SymbolKind.CLASS, SymbolKind.RECORD, SymbolKind.INTERFACE}:
+        declaration = _source_fragment(symbol.decl_range, "declaration", source_cache)
+        if declaration is not None:
+            fragments.append(declaration)
+        fragments.extend(_implementation_fragments_for_type(index, symbol, source_cache))
+    elif symbol.kind in _ROUTINE_KINDS:
+        fragment = _source_fragment(symbol.decl_range, "implementation", source_cache)
+        if fragment is not None:
+            fragments.append(fragment)
+    else:
+        fragment = _source_fragment(symbol.decl_range, "declaration", source_cache)
+        if fragment is not None:
+            fragments.append(fragment)
+        fragments.extend(_implementation_fragments_for_member(index, symbol, source_cache))
+    if not fragments:
+        return None
+    item = _symbol_item(symbol)
+    item["fragments"] = fragments
+    return item
+
+
+def _implementation_fragments_for_type(
+    index: CodebaseIndex,
+    symbol: Symbol,
+    source_cache: dict[str, list[str]],
+) -> list[dict[str, Any]]:
+    prefix = f"{symbol.name.casefold()}."
+    fragments: list[dict[str, Any]] = []
+    seen_ranges: set[SourceRange] = set()
+    for candidate in _all_symbols(index):
+        if candidate.kind not in _ROUTINE_KINDS:
+            continue
+        if candidate.decl_range.file_name != symbol.decl_range.file_name:
+            continue
+        if not candidate.name.casefold().startswith(prefix):
+            continue
+        fragment = _source_fragment(candidate.decl_range, "implementation", source_cache)
+        if fragment is None or candidate.decl_range in seen_ranges:
+            continue
+        seen_ranges.add(candidate.decl_range)
+        fragment["symbol"] = candidate.name
+        fragments.append(fragment)
+    fragments.sort(key=lambda item: (item["range"]["start_line"], item["range"]["start_col"]))
+    return fragments
+
+
+def _implementation_fragments_for_member(
+    index: CodebaseIndex,
+    symbol: Symbol,
+    source_cache: dict[str, list[str]],
+) -> list[dict[str, Any]]:
+    owner = symbol.scope.owner
+    if owner is None or owner.kind not in {SymbolKind.CLASS, SymbolKind.RECORD, SymbolKind.INTERFACE}:
+        return []
+    qualified_name = f"{owner.name.casefold()}.{symbol.name.casefold()}"
+    fragments: list[dict[str, Any]] = []
+    for candidate in _all_symbols(index):
+        if candidate.kind not in _ROUTINE_KINDS:
+            continue
+        if candidate.decl_range.file_name != symbol.decl_range.file_name:
+            continue
+        if candidate.name.casefold() != qualified_name:
+            continue
+        fragment = _source_fragment(candidate.decl_range, "implementation", source_cache)
+        if fragment is not None:
+            fragment["symbol"] = candidate.name
+            fragments.append(fragment)
+    return fragments
+
+
+def _source_fragment(
+    source_range: SourceRange,
+    fragment_kind: str,
+    source_cache: dict[str, list[str]],
+) -> dict[str, Any] | None:
+    lines = source_cache.get(source_range.file_name)
+    if lines is None:
+        try:
+            text = read_source_text(Path(source_range.file_name))
+        except (OSError, UnicodeError):
+            return None
+        lines = text.splitlines(keepends=True)
+        source_cache[source_range.file_name] = lines
+    if source_range.start_line < 1 or source_range.start_line > len(lines):
+        return None
+    end_line = min(max(source_range.end_line, source_range.start_line), len(lines))
+    snippet = "".join(lines[source_range.start_line - 1 : end_line]).rstrip("\r\n")
+    return {
+        "fragment_kind": fragment_kind,
+        "range": _range_item(source_range),
+        "line_count": end_line - source_range.start_line + 1,
+        "text": snippet,
+    }
+
+
 def _references_payload(index: CodebaseIndex, *, query: str) -> dict[str, Any]:
     needle = query.casefold().strip()
     items = []
@@ -265,6 +403,14 @@ def _symbol_item(symbol: Symbol) -> dict[str, Any]:
     }
 
 
+_ROUTINE_KINDS = {
+    SymbolKind.PROCEDURE,
+    SymbolKind.FUNCTION,
+    SymbolKind.CONSTRUCTOR,
+    SymbolKind.DESTRUCTOR,
+}
+
+
 def _range_item(source_range: SourceRange) -> dict[str, int | str]:
     return {
         "path": source_range.file_name,
@@ -312,6 +458,26 @@ def _render_markdown(payload: dict[str, Any]) -> str:
                 lines.append(
                     f"- `{symbol['name']}` {symbol['kind']} at `{symbol['path']}:{symbol['line']}`"
                 )
+    elif payload["layer"] == "implementation":
+        if payload.get("message"):
+            lines.append(payload["message"])
+        for item in payload["items"]:
+            lines.append(f"## {item['name']}")
+            lines.append(f"- Kind: `{item['kind']}`")
+            lines.append(f"- Path: `{item['path']}`")
+            for fragment in item["fragments"]:
+                source_range = fragment["range"]
+                lines.append("")
+                lines.append(
+                    f"### {fragment['fragment_kind']} `{source_range['path']}:{source_range['start_line']}`"
+                )
+                if fragment.get("symbol"):
+                    lines.append(f"- Symbol: `{fragment['symbol']}`")
+                lines.append(f"- Lines: {fragment['line_count']}")
+                lines.append("")
+                lines.append("```pascal")
+                lines.append(fragment["text"])
+                lines.append("```")
     elif payload["layer"] == "projects":
         for item in payload["items"]:
             lines.append(f"## `{item['path']}`")

{python_delphi_lsp-1.1.0 → python_delphi_lsp-1.1.1}/delphiast/agent_templates.py

@@ -58,6 +58,7 @@ Use this skill when a task asks you to understand a Delphi/Object Pascal codebas
 - Do not use shell text-search commands for Delphi navigation.
 - Use the `delphi_codebase` opencode tool when it is available.
 - If the tool is not available, run `delphi-lsp-agent view` commands only after the user permits command execution.
+- When a task asks for codebase inspection, call `delphi_codebase` first; do not write "let me inspect" text before the tool call.
 - Cite files and line numbers from the layer output.
 
 ## Workflow
@@ -67,14 +68,16 @@ Use this skill when a task asks you to understand a Delphi/Object Pascal codebas
 3. Use `units` and `unit` to inspect outlines without routine bodies.
 4. Use `symbols` to find a type, routine, property, field, constant, or variable.
 5. Use `symbol` for a focused symbol card and children.
-6. Use `references` for definition/reference-oriented evidence.
-7. Use `problems` before concluding that code is missing.
+6. Use `implementation` with a concrete class, routine, or member query when you need the complete source for that one symbol.
+7. Use `references` for definition/reference-oriented evidence.
+8. Use `problems` before concluding that code is missing.
 
 ## Tool examples
 
 - `delphi_codebase({ "layer": "overview" })`
 - `delphi_codebase({ "layer": "unit", "query": "Worker" })`
 - `delphi_codebase({ "layer": "symbols", "query": "TWorker", "format": "json" })`
+- `delphi_codebase({ "layer": "implementation", "query": "TWorker.Run" })`
 
 Prefer narrow follow-up queries over broad output.
 """
@@ -82,37 +85,26 @@ Prefer narrow follow-up queries over broad output.
 
 def _opencode_tool(python_executable: str) -> str:
     python_json = json.dumps(python_executable)
-    return f"""const PYTHON = {python_json}
+    return f"""import {{ tool }} from "@opencode-ai/plugin"
+
+const PYTHON = {python_json}
 
 async function streamToText(stream: ReadableStream | null): Promise<string> {{
   if (!stream) return ""
   return await new Response(stream).text()
 }}
 
-export default {{
+export default tool({{
   description: "Inspect a Delphi/Object Pascal codebase through python-delphi-lsp layered semantic views.",
   args: {{
-    layer: {{
-      type: "string",
-      enum: ["overview", "projects", "units", "unit", "symbols", "symbol", "references", "problems"],
-      description: "Layer to inspect",
-    }},
-    query: {{
-      type: "string",
-      description: "Optional unit, file, or symbol filter",
-    }},
-    root: {{
-      type: "string",
-      description: "Workspace root; defaults to current worktree or directory",
-    }},
-    format: {{
-      type: "string",
-      enum: ["markdown", "json"],
-      description: "Output format",
-    }},
+    layer: tool.schema.enum(["overview", "projects", "units", "unit", "symbols", "symbol", "implementation", "references", "problems"]).describe("Layer to inspect"),
+    query: tool.schema.string().optional().describe("Unit, file, or symbol filter"),
+    root: tool.schema.string().optional().describe("Workspace root; defaults to current worktree or directory"),
+    format: tool.schema.enum(["markdown", "json"]).optional().describe("Output format; defaults to markdown"),
   }},
   async execute(args, context) {{
-    const root = args.root ?? context.worktree ?? context.directory
+    const contextDirectory = context.directory && context.directory !== "/" ? context.directory : undefined
+    const root = args.root ?? context.worktree ?? contextDirectory ?? process.cwd()
     const command = [
       PYTHON,
       "-m",
@@ -143,7 +135,7 @@ export default {{
     }}
     return stdout.trim()
   }},
-}}
+}})
 """
 
 
@@ -155,10 +147,17 @@ def _merge_opencode_config(config_path: Path) -> None:
     agents = config.setdefault("agent", {})
     agents["vllm-delphi-codebase"] = {
         "description": "Use the Delphi codebase navigator skill and tool without direct filesystem source inspection.",
+        "temperature": 0,
+        "prompt": (
+            "You are a tool-calling assistant. When the user asks for a tool call, call the matching tool. "
+            "The matching tool for Delphi/Object Pascal codebase inspection is delphi_codebase. "
+            "Use delphi_codebase before answering Delphi codebase questions. "
+            "Use implementation for complete source of one concrete class, routine, or member."
+        ),
         "tools": {
             "delphi_codebase": True,
-            "skill": True,
-            "lsp": True,
+            "skill": False,
+            "lsp": False,
             "bash": False,
             "read": False,
             "glob": False,
@@ -170,9 +169,9 @@ def _merge_opencode_config(config_path: Path) -> None:
             "todowrite": False,
         },
         "permission": {
-            "skill": {
-                SKILL_NAME: "allow",
-            }
+            "delphi_codebase": "allow",
+            "lsp": "deny",
+            "skill": "deny",
         },
     }
     config_path.write_text(json.dumps(config, indent=2, sort_keys=True) + "\n", encoding="utf-8")

{python_delphi_lsp-1.1.0 → python_delphi_lsp-1.1.1}/pyproject.toml

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

{python_delphi_lsp-1.1.0 → python_delphi_lsp-1.1.1/python_delphi_lsp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-delphi-lsp
-Version: 1.1.0
+Version: 1.1.1
 Summary: Python Delphi/Object Pascal parser, semantic indexer, and language server.
 Author: Dark Light
 License-Expression: MPL-2.0
@@ -191,13 +191,19 @@ delphi-lsp-agent view --root . --layer overview
 delphi-lsp-agent view --root . --layer projects
 delphi-lsp-agent view --root . --layer unit --query Mega100kUnit
 delphi-lsp-agent view --root . --layer symbols --query TWorker --format json
+delphi-lsp-agent view --root . --layer implementation --query TWorker.Run
+delphi-lsp-agent view --root . --layer implementation --query TWorker --format json
 delphi-lsp-agent view --root . --layer problems
 ```
 
 Available layers are `overview`, `projects`, `units`, `unit`, `symbols`,
-`symbol`, `references`, and `problems`. The output includes file and line
-citations, declarations, ownership, visibility, type information, and
-dependency/problem summaries. Routine bodies are not emitted.
+`symbol`, `implementation`, `references`, and `problems`. The output includes
+file and line citations, declarations, ownership, visibility, type information,
+and dependency/problem summaries. Outline layers keep routine bodies out of the
+agent context. Use `implementation` with a concrete class, routine, or member
+query to read only that complete source fragment from the original file. For a
+class query, the layer returns the class declaration plus matching method
+implementations; for a routine query, it returns the full routine body.
 
 ## opencode Usage
 
@@ -380,13 +386,17 @@ python scripts/bootstrap_vllm_codebase_skill_test.py --start-vllm
 ```
 
 This skill probe defaults the vLLM helper to `MAX_MODEL_LEN=32768`, which was
-the stable local Metal setting for the complete skill + `delphi_codebase` tool
-call. Override with `--max-model-len` when your machine has enough headroom.
-
-The probe requires opencode to load `delphi-codebase-navigator`, call
-`delphi_codebase`, and find `MegaProc02500`. It fails if opencode uses `bash`,
-`read`, `glob`, `grep`, `edit`, `write`, `task`, `webfetch`, or `todowrite`
-before the required evidence is complete.
+the stable local Metal setting for the reduced codebase-agent prompt plus the
+`delphi_codebase` tool call. Override with `--max-model-len` when your machine
+has enough headroom.
+
+The probe verifies that the `delphi-codebase-navigator` skill is installed, then
+requires opencode to call `delphi_codebase`, find `MegaProc02500`, and read the
+method body through the `implementation` layer. The vLLM test agent keeps
+opencode's generic `skill` tool disabled so the model context stays focused on
+the Delphi navigation tool. The probe fails if opencode uses `bash`, `read`,
+`glob`, `grep`, `edit`, `write`, `task`, `webfetch`, or `todowrite` before the
+required evidence is complete.
 
 ## Verification
 

{python_delphi_lsp-1.1.0 → python_delphi_lsp-1.1.1}/scripts/bootstrap_vllm_codebase_skill_test.py

@@ -101,9 +101,11 @@ def build_probe_command(
 ) -> list[str]:
     output_path = output or sandbox / "bootstrap_vllm_codebase_skill_probe.jsonl"
     prompt = (
-        "Load the delphi-codebase-navigator skill. Use only the delphi_codebase tool to inspect the "
-        "Delphi project. Find MegaProc02500 through the symbols layer and explain which project and unit "
-        "contain it with file and line evidence."
+        "Use only the delphi_codebase tool to inspect the Delphi project. Do not write "
+        "any explanatory text before calling that tool. First call delphi_codebase with layer symbols, "
+        'query "MegaProc02500", and format json. Then call delphi_codebase with layer implementation, '
+        'query "MegaProc02500", and format markdown. After both tool calls, explain which project and '
+        "unit contain it with file and line evidence, and cite one statement from the method body."
     )
     return [
         str(python_executable),
@@ -115,9 +117,9 @@ def build_probe_command(
         "--agent",
         DEFAULT_AGENT,
         "--require-tool",
-        "skill:delphi-codebase-navigator",
-        "--require-tool",
         f"delphi_codebase:{DEFAULT_SYMBOL}",
+        "--require-tool",
+        "delphi_codebase:Value := Value + 40",
         "--forbid-tool",
         "bash",
         "--forbid-tool",
@@ -202,6 +204,12 @@ def main() -> int:
         wait_for_endpoint(args.base_url, args.ready_timeout, api_key=args.api_key)
         env = os.environ.copy()
         env["OPENCODE_EXPERIMENTAL_LSP_TOOL"] = "true"
+        npm_cache = sandbox / ".opencode" / ".npm-cache"
+        bun_cache = sandbox / ".opencode" / ".bun-cache"
+        npm_cache.mkdir(parents=True, exist_ok=True)
+        bun_cache.mkdir(parents=True, exist_ok=True)
+        env.setdefault("NPM_CONFIG_CACHE", str(npm_cache))
+        env.setdefault("BUN_INSTALL_CACHE_DIR", str(bun_cache))
         run(
             build_probe_command(
                 root=ROOT,

{python_delphi_lsp-1.1.0 → python_delphi_lsp-1.1.1}/tests/test_agent_codebase.py

@@ -51,6 +51,32 @@ def make_project(root: Path) -> None:
     )
 
 
+def make_mega_project(root: Path, *, proc_count: int = 2500, statements_per_proc: int = 40) -> None:
+    lines = [
+        "unit Mega100kUnit;",
+        "",
+        "interface",
+        "",
+        "type",
+        "  TMegaValue = Integer;",
+        "",
+        "implementation",
+        "",
+    ]
+    for index in range(1, proc_count + 1):
+        lines.append(f"procedure MegaProc{index:05d};")
+        lines.append("var")
+        lines.append("  Value: Integer;")
+        lines.append("begin")
+        lines.append("  Value := 0;")
+        for statement in range(1, statements_per_proc + 1):
+            lines.append(f"  Value := Value + {statement};")
+        lines.append("end;")
+        lines.append("")
+    lines.append("end.")
+    write_text(root / "Mega100kUnit.pas", "\n".join(lines) + "\n")
+
+
 def test_builds_layered_markdown_without_exposing_routine_bodies(tmp_path: Path) -> None:
     make_project(tmp_path)
 
@@ -63,6 +89,52 @@ def test_builds_layered_markdown_without_exposing_routine_bodies(tmp_path: Path)
     assert "body must not be exposed" not in markdown
 
 
+def test_implementation_layer_exposes_only_queried_method_body(tmp_path: Path) -> None:
+    make_project(tmp_path)
+
+    index = build_codebase_index(tmp_path)
+    markdown = render_layer(index, "implementation", query="TWorker.Run", output_format="markdown")
+
+    assert "TWorker.Run" in markdown
+    assert "procedure TWorker.Run;" in markdown
+    assert "body must not be exposed in the layer output" in markdown
+    assert "unit Worker;" not in markdown
+
+
+def test_implementation_layer_exposes_class_declaration_and_method_bodies(tmp_path: Path) -> None:
+    make_project(tmp_path)
+
+    index = build_codebase_index(tmp_path)
+    payload = json.loads(render_layer(index, "implementation", query="TWorker", output_format="json"))
+
+    assert payload["layer"] == "implementation"
+    [item] = payload["items"]
+    fragment_kinds = {fragment["fragment_kind"] for fragment in item["fragments"]}
+    fragment_text = "\n".join(fragment["text"] for fragment in item["fragments"])
+    assert fragment_kinds == {"declaration", "implementation"}
+    assert "TWorker = class" in fragment_text
+    assert "procedure TWorker.Run;" in fragment_text
+    assert "body must not be exposed in the layer output" in fragment_text
+
+
+def test_implementation_layer_slices_single_method_from_100k_line_file(tmp_path: Path) -> None:
+    make_mega_project(tmp_path)
+    source = (tmp_path / "Mega100kUnit.pas").read_text(encoding="utf-8")
+    assert source.count("\n") > 100_000
+
+    index = build_codebase_index(tmp_path)
+    payload = json.loads(render_layer(index, "implementation", query="MegaProc02500", output_format="json"))
+
+    [item] = payload["items"]
+    text = item["fragments"][0]["text"]
+    assert item["name"] == "MegaProc02500"
+    assert "procedure MegaProc02500;" in text
+    assert "  Value := Value + 40;" in text
+    assert "procedure MegaProc02499;" not in text
+    assert "procedure MegaProc02498;" not in text
+    assert item["fragments"][0]["range"]["start_line"] > 100_000
+
+
 def test_default_layer_index_does_not_deep_parse_project_dependencies(tmp_path: Path, monkeypatch) -> None:
     make_project(tmp_path)
 
@@ -91,9 +163,9 @@ def test_agent_cli_outputs_symbol_layer_as_json(tmp_path: Path) -> None:
             "--root",
             str(tmp_path),
             "--layer",
-            "symbols",
+            "implementation",
             "--query",
-            "TWorker",
+            "TWorker.Run",
             "--format",
             "json",
         ],
@@ -103,8 +175,9 @@ def test_agent_cli_outputs_symbol_layer_as_json(tmp_path: Path) -> None:
     )
 
     payload = json.loads(completed.stdout)
-    assert payload["layer"] == "symbols"
-    assert any(item["name"] == "TWorker" for item in payload["items"])
+    assert payload["layer"] == "implementation"
+    assert any(item["name"] == "TWorker.Run" for item in payload["items"])
+    assert "procedure TWorker.Run;" in completed.stdout
 
 
 def test_opencode_install_writes_skill_and_custom_tool(tmp_path: Path) -> None:
@@ -133,6 +206,12 @@ def test_opencode_install_writes_skill_and_custom_tool(tmp_path: Path) -> None:
     tool_text = tool.read_text(encoding="utf-8")
     assert sys.executable in tool_text
     assert "delphiast.agent_cli" in tool_text
-    assert "@opencode-ai/plugin" not in tool_text
+    assert '@opencode-ai/plugin' in tool_text
+    assert "tool.schema.enum" in tool_text
+    assert "tool.schema.string().optional()" in tool_text
+    assert 'args.format ?? "markdown"' in tool_text
+    assert '"implementation"' in tool_text
+    assert 'context.directory !== "/"' in tool_text
+    assert "process.cwd()" in tool_text
     assert "grep" not in tool_text.casefold()
     assert str(skill) in completed.stdout

{python_delphi_lsp-1.1.0 → python_delphi_lsp-1.1.1}/tests/test_bootstrap_vllm_codebase_skill.py

@@ -31,6 +31,12 @@ def test_writes_codebase_skill_sandbox_with_project_paths(tmp_path: Path) -> Non
     config = (tmp_path / "opencode.json").read_text(encoding="utf-8")
     assert "vllm-delphi-codebase" in config
     assert '"delphi_codebase": true' in config
+    assert '"skill": false' in config
+    assert '"lsp": false' in config
+    assert '"delphi_codebase": "allow"' in config
+    assert '"skill": "deny"' in config
+    assert '"temperature": 0' in config
+    assert "When the user asks for a tool call" in config
     assert '"read": false' in config
 
 
@@ -42,7 +48,11 @@ def test_probe_command_requires_delphi_codebase_tool_and_forbids_raw_tools(tmp_p
     assert command[:2] == [str(python_exe), str(ROOT / "scripts" / "run_opencode_lsp_probe.py")]
     assert "vllm/ornith-lspctx" in command
     assert "vllm-delphi-codebase" in command
+    assert "skill:delphi-codebase-navigator" not in command
     assert "delphi_codebase:MegaProc02500" in command
+    assert "delphi_codebase:Value := Value + 40" in command
+    assert "Do not write any explanatory text before calling that tool" in command[-1]
+    assert "layer implementation" in command[-1]
     forbidden = [command[index + 1] for index, item in enumerate(command) if item == "--forbid-tool"]
     assert {"bash", "read", "glob", "grep", "edit", "write", "task", "webfetch", "todowrite"}.issubset(
         set(forbidden)
@@ -54,3 +64,5 @@ def test_skill_bootstrap_defaults_to_smaller_vllm_context_for_metal_stability()
 
     assert 'DEFAULT_MAX_MODEL_LEN = "32768"' in script
     assert 'os.environ["MAX_MODEL_LEN"] = args.max_model_len' in script
+    assert 'env.setdefault("NPM_CONFIG_CACHE"' in script
+    assert 'env.setdefault("BUN_INSTALL_CACHE_DIR"' in script

{python_delphi_lsp-1.1.0 → python_delphi_lsp-1.1.1}/tests/test_package_metadata.py

@@ -24,11 +24,11 @@ def test_lsp_console_script_dependencies_are_installed_by_default() -> None:
     assert '"lsprotocol>=2023.0.1"' in project
 
 
-def test_release_metadata_declares_1_1_0_and_windows_support() -> None:
+def test_release_metadata_declares_1_1_1_and_windows_support() -> None:
     pyproject = (ROOT / 'pyproject.toml').read_text(encoding='utf-8')
     project = _section('project', pyproject)
 
-    assert 'version = "1.1.0"' in project
+    assert 'version = "1.1.1"' in project
     assert '"Operating System :: OS Independent"' in project
     assert '"Operating System :: Microsoft :: Windows"' in project
     assert '"Operating System :: MacOS"' in project