agent-codinglanguage-mapper 1.0.0__py3-none-any.whl

agent_codinglanguage_mapper/workspace.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import dataclass, field, fields, is_dataclass
+from types import MappingProxyType
+from typing import Any, Callable, Mapping, TypeVar, cast
+
+from .models import Language, Problem, Project, Reference, Relation, SourceFile, Symbol
+
+
+def stable_id(kind: str, *parts: str) -> str:
+    material = "\x1f".join((kind, *parts)).encode("utf-8")
+    return f"{kind}:{hashlib.sha256(material).hexdigest()[:20]}"
+
+
+def _record(value: object) -> object:
+    if hasattr(value, "value"):
+        return getattr(value, "value")
+    if isinstance(value, tuple):
+        return [_record(item) for item in value]
+    if isinstance(value, dict):
+        return {key: _record(item) for key, item in sorted(value.items())}
+    if is_dataclass(value) and not isinstance(value, type):
+        instance = cast(Any, value)
+        return {item.name: _record(getattr(instance, item.name)) for item in fields(instance)}
+    return value
+
+
+_T = TypeVar("_T")
+
+
+def _group(items: tuple[_T, ...], key: Callable[[_T], str]) -> dict[str, tuple[_T, ...]]:
+    grouped: dict[str, list[_T]] = {}
+    for item in items:
+        grouped.setdefault(key(item), []).append(item)
+    return {key: tuple(value) for key, value in grouped.items()}
+
+
+@dataclass(frozen=True)
+class WorkspaceSnapshot:
+    projects: tuple[Project, ...] = ()
+    files: tuple[SourceFile, ...] = ()
+    symbols: tuple[Symbol, ...] = ()
+    references: tuple[Reference, ...] = ()
+    relations: tuple[Relation, ...] = ()
+    problems: tuple[Problem, ...] = ()
+    source_digests: tuple[tuple[str, str], ...] = ()
+    metadata_digests: tuple[tuple[str, str], ...] = ()
+    revision: str = field(init=False)
+    projects_by_id: Mapping[str, Project] = field(init=False, repr=False)
+    files_by_id: Mapping[str, SourceFile] = field(init=False, repr=False)
+    symbols_by_id: Mapping[str, Symbol] = field(init=False, repr=False)
+    symbols_by_file: Mapping[str, tuple[Symbol, ...]] = field(init=False, repr=False)
+    symbol_aliases_by_id: Mapping[str, tuple[Symbol, ...]] = field(init=False, repr=False)
+    relations_by_source: Mapping[str, tuple[Relation, ...]] = field(init=False, repr=False)
+    relations_by_target: Mapping[str, tuple[Relation, ...]] = field(init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        names = (
+            "projects",
+            "files",
+            "symbols",
+            "references",
+            "relations",
+            "problems",
+            "source_digests",
+            "metadata_digests",
+        )
+        for name in names:
+            object.__setattr__(self, name, tuple(getattr(self, name)))
+        revision_names = ("projects", "files", "source_digests", "metadata_digests")
+        payload = {name: _record(getattr(self, name)) for name in revision_names}
+        encoded = json.dumps(payload, sort_keys=True, separators=(",", ":"), ensure_ascii=True).encode("utf-8")
+        object.__setattr__(self, "revision", hashlib.sha256(encoded).hexdigest())
+        object.__setattr__(self, "projects_by_id", MappingProxyType({item.project_id: item for item in self.projects}))
+        object.__setattr__(self, "files_by_id", MappingProxyType({item.file_id: item for item in self.files}))
+        object.__setattr__(self, "symbols_by_id", MappingProxyType({item.target_id: item for item in self.symbols}))
+        object.__setattr__(self, "symbols_by_file", MappingProxyType(_group(self.symbols, lambda item: item.file_id)))
+        alias_groups: dict[tuple[object, ...], list[Symbol]] = {}
+        for symbol in self.symbols:
+            alias_groups.setdefault(_symbol_alias_key(symbol), []).append(symbol)
+        aliases_by_id = {
+            symbol.target_id: tuple(group)
+            for group in alias_groups.values()
+            for symbol in group
+        }
+        object.__setattr__(self, "symbol_aliases_by_id", MappingProxyType(aliases_by_id))
+        object.__setattr__(
+            self,
+            "relations_by_source",
+            MappingProxyType(_group(self.relations, lambda item: item.source_id)),
+        )
+        object.__setattr__(
+            self,
+            "relations_by_target",
+            MappingProxyType(_group(self.relations, lambda item: item.target_id)),
+        )
+
+
+def _symbol_alias_key(symbol: Symbol) -> tuple[object, ...]:
+    if symbol.language is not Language.DELPHI:
+        return (symbol.target_id,)
+    anchor = symbol.name_range or symbol.range
+    return (
+        symbol.project_id,
+        symbol.language,
+        symbol.kind,
+        symbol.role,
+        symbol.name.casefold(),
+        symbol.qualified_name.casefold(),
+        " ".join(symbol.signature.casefold().split()),
+        anchor,
+    )

agent_codinglanguage_mapper-1.0.0.dist-info/METADATA

@@ -0,0 +1,383 @@
+Metadata-Version: 2.4
+Name: agent-codinglanguage-mapper
+Version: 1.0.0
+Summary: Agent-focused semantic mapping and language services for mixed-language codebases.
+Author: Dark Light
+License-Expression: MPL-2.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: <3.15,>=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: lark<2,>=1.1.9
+Requires-Dist: lsprotocol>=2023.0.1
+Requires-Dist: pathspec<1,>=0.12
+Requires-Dist: pygls<2,>=1.3.0
+Requires-Dist: tomli>=2; python_version < "3.11"
+Requires-Dist: tree-sitter==0.26.0
+Requires-Dist: tree-sitter-python==0.25.0
+Requires-Dist: tree-sitter-rust==0.24.2
+Requires-Dist: tree-sitter-c-sharp==0.23.5
+Requires-Dist: tree-sitter-cpp==0.23.4
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Requires-Dist: pytest-cov>=5; extra == "test"
+Requires-Dist: tomli>=2; python_version < "3.11" and extra == "test"
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: mypy==1.19.1; extra == "dev"
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-cov>=5; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Requires-Dist: tomli>=2; extra == "dev"
+Requires-Dist: twine>=5; extra == "dev"
+Dynamic: license-file
+
+# Agent Coding Language Mapper
+
+`agent-codinglanguage-mapper` gives coding agents a bounded semantic view of mixed-language repositories. It maps Python, Rust, C#, Delphi, and C++ into one language-neutral index and exposes that index through a Python API, a command-line interface, Protocol 3, an LSP server, and an OpenCode skill/plugin pair.
+
+The mapper is designed for code investigation without sending whole files through `grep`, `cat`, or generic file-reading tools. Responses are paginated, carry stable target IDs and source citations, distinguish proven from partial relations, and preserve focus across follow-up requests.
+
+## Installation
+
+```bash
+python -m pip install agent-codinglanguage-mapper
+```
+
+Python 3.10 through 3.14 is supported on Windows, macOS, and Linux.
+
+Check the installation against a repository:
+
+```bash
+codinglanguage-mapper doctor --root .
+codinglanguage-mapper view --root . --layer overview --format markdown
+```
+
+## Python API
+
+```python
+from agent_codinglanguage_mapper import AgentRequest, CodebaseMapper, Language
+
+with CodebaseMapper.open(".", languages="auto") as mapper:
+    found = mapper.request(
+        AgentRequest(
+            action="find",
+            query="PaymentService",
+            languages=(Language.PYTHON, Language.CSHARP),
+        )
+    )
+
+    item = found.result["items"][0]
+    detail = mapper.request(
+        AgentRequest(
+            action="inspect",
+            target_id=item["target_id"],
+            detail="body",
+        )
+    )
+    print(detail.to_mapping())
+```
+
+The public types are:
+
+- `CodebaseMapper`
+- `AgentRequest` and `AgentResponse`
+- `Language`
+- `Project` and `SourceFile`
+- `Symbol`, `Reference`, and `Relation`
+- `Problem` and `SourceRange`
+
+Parser-native nodes are intentionally private. Ranges are zero-based and half-open. Rendered citations use one-based line numbers, for example `src/payment.py:42`.
+
+`CodebaseMapper.open()` creates an outline index first. `inspect`, `focus`, and outgoing `callees`/`uses` traces load detail only for the selected source file. Incoming `references`/`callers`/`used_by` traces load the remaining workspace detail because their evidence can originate in any indexed file. Parsed detail and focus remain resident for the mapper session. The same optimized path is used for small and large files.
+
+The private session index retains each parser-native outline tree, its source buffer, a source digest, and a lightweight file fingerprint. A detail upgrade therefore queries the existing tree instead of rereading or reparsing every indexed source. When an indexed source changes during a worker session, the mapper rebuilds the outline snapshot, updates `workspace_revision`, clears stale detail/focus state, and invalidates old cursors before answering the next request. Parser-native nodes never appear in the public result types.
+
+## CLI
+
+The installed command is `codinglanguage-mapper`.
+
+```bash
+# Layered views
+codinglanguage-mapper view --root . --layer projects --format markdown
+codinglanguage-mapper view --root . --layer files --language rust --format json
+codinglanguage-mapper view --root . --layer symbols --query PaymentService
+codinglanguage-mapper view --root . --layer implementation --query PaymentService
+codinglanguage-mapper view --root . --layer references --query PaymentService
+
+# Persistent JSON index
+codinglanguage-mapper index --root . --out .mapper/index.json
+
+# Discovery and parser diagnostics
+codinglanguage-mapper doctor --root . --format json
+
+# Language Server Protocol over stdio
+codinglanguage-mapper lsp --root .
+
+# Protocol 3 NDJSON worker
+codinglanguage-mapper worker --root .
+```
+
+Available view layers are `overview`, `projects`, `languages`, `files`, `file`, `symbols`, `symbol`, `implementation`, `references`, and `problems`.
+
+## Protocol 3
+
+Protocol 3 is the bounded request/response contract used by the worker and OpenCode plugin.
+
+Actions:
+
+| Action | Purpose |
+| --- | --- |
+| `open` | Return projects and establish the workspace revision. |
+| `find` | Search indexed symbols with optional project, file, and language filters. |
+| `inspect` | Return one selected detail layer for a target. |
+| `trace` | Follow one explicit relation from a target. |
+| `focus` | Select a target while preserving project/file/language focus. |
+| `problems` | Return structured discovery, syntax, and semantic problems. |
+
+Details are `summary`, `declaration`, `members`, `context`, `body`, and `implementations`. Relations are `references`, `callers`, `callees`, `uses`, `used_by`, `inherits`, `implements`, and `ffi`.
+
+```json
+{
+  "action": "trace",
+  "target_id": "symbol:...",
+  "relation": "callers",
+  "languages": ["csharp", "cpp"],
+  "max_items": 12,
+  "max_chars": 12000
+}
+```
+
+Each response contains:
+
+- `schema`: always `3`
+- `workspace_revision`: invalidates stale cursors after codebase changes
+- `focus`: current project, file, target, and language selection
+- `result`: bounded result items
+- `page`: returned/total counts, truncation state, and `next_cursor`
+- `context`: character count and approximate token count
+
+Symbol items include a one-based `citation` and a `role` value. `role` is `declaration`, `implementation`, or `definition`; clients must use it when the language distinguishes a declaration from its implementation and must copy `citation` verbatim instead of recalculating it from the zero-based ranges.
+
+Relation items include `target_name` and, for statically identifiable native imports, `target_library`. Parser-native nodes and recovery artifacts are never exposed through Protocol 3.
+
+After `focus`, an unfiltered `find` inherits the focused project, file, and languages. An explicit `file_id` replaces the focused file. An explicit project or language filter starts a broader scope and clears incompatible narrower inherited filters; include `file_id` explicitly when that narrower restriction is still intended.
+
+Defaults are 12 items and 12,000 characters. `max_chars` is capped at 40,000. Source bodies are chunked at 6,000 characters. When `page.truncated` is true, continue with the non-empty `next_cursor`; do not infer omitted items. An individual bounded summary can also contain `"truncated": true` while still exposing its `target_id`, name, language, and citation so the target can be inspected directly.
+
+## Resolution Semantics
+
+The mapper never fabricates a relation to make a graph look complete.
+
+| Resolution | Meaning |
+| --- | --- |
+| `complete` | The relation is proven inside the indexed workspace. |
+| `sound_partial` | Returned evidence is valid, but the available static information may be incomplete. |
+| `ambiguous` | More than one valid target remains. |
+| `unresolved` | No defensible target can be selected. |
+
+Same-language cross-file targets become `complete` only when the target is visible in the same project through an explicit Python/Rust import, C/C++ include, Delphi `uses` clause, or the applicable C# namespace rules. A same-name symbol elsewhere in the workspace is not sufficient.
+
+Cross-language FFI is recognized only from explicit declarations: Rust `extern`, C/C++ ABI exports, C# `DllImport`/`LibraryImport`, Delphi `external`/`exports`, and statically identifiable Python `ctypes`/`cffi` usage. An import becomes `complete` only when its literal library identity also matches the exporter identity after conventional `lib` prefix and `.dll`/`.dylib`/`.so` suffix normalization. C/C++ exporter identity comes from explicit loadable CMake targets such as `add_library(metrics SHARED metrics.cpp)` or `MODULE` libraries; static libraries, executables, and unspecified library kinds are not treated as runtime FFI outputs. Delphi exporter identity comes from the `library metrics;` declaration. A source filename is never treated as proof of a native output name, and custom or unresolved outputs remain `sound_partial` or `unresolved`.
+
+A resolved `ffi` trace includes complete `source_symbol` and `target_symbol` mappings. Their `language`, `role`, and `citation` fields provide both endpoints without a second name-based search.
+
+## Project Discovery
+
+No environment variable is required for normal discovery. The workspace scanner respects `.gitignore` files at every directory level, applies each pattern relative to its directory, skips standard build/cache directories, and enforces the repository boundary. Directory symlinks are not followed, and workspace-escaping source roots are reported instead of indexed.
+
+Supported metadata includes:
+
+- Python `pyproject.toml`, `setup.cfg`, and conventional/source layouts
+- Cargo packages and workspaces
+- `.sln` and `.csproj`
+- Delphi `.dpr`, `.dpk`, `.dproj`, and `.groupproj`, including unit search paths, include paths, source paths, project defines, and source declarations; `.dpr` and `.dpk` files are also indexed as source
+- C/C++ `compile_commands.json`, `CMakeLists.txt`, and `.vcxproj`
+
+Build scripts are parsed as data and are never executed. Cargo custom library and binary paths are combined rather than treated as alternatives, and solution files resolve their referenced C# project membership. Multiple named project files in one directory keep distinct project identities; matching `.dpr`/`.dproj` pairs share one Delphi project identity. Explicit source membership has priority over broad solution or group metadata. If multiple implicit projects remain equally valid owners, the file is assigned to the synthetic workspace project and an `ambiguous-project-ownership` problem lists the candidate project files. Unresolved variables, missing generated files, missing project references, missing include roots, and paths outside the workspace become structured `Problem` records.
+
+## Language Coverage
+
+Release-blocking fixtures and LSP assertions cover:
+
+| Language | Supported stable range |
+| --- | --- |
+| Python | 2.7 and 3.0 through 3.14 |
+| Rust | Editions 2015, 2018, 2021, and 2024 |
+| C# | C# 1 through C# 14 |
+| Delphi | Delphi 7 through Delphi 13 Florence |
+| C++ | C++98/03 through C++23 |
+
+Stable GNU/MSVC C++ extensions and Delphi compiler directives have dedicated fixtures. Preview, Nightly, compiler-internal, and draft syntax is Best-Effort and is reported through explicit compatibility handlers. Unknown stable syntax remains a release-blocking `syntax-error`; parser recovery is never silently accepted.
+
+Run the offline formal audit:
+
+```bash
+python scripts/audit_language_matrix.py
+pytest -q tests/test_language_matrix.py
+```
+
+Pinned external evaluations cover CPython, Rust, Roslyn, LLVM, DUnitX, and the official corpora for each pinned Tree-sitter grammar. Populate a missing corpus cache only as an explicit evaluation operation:
+
+```bash
+python scripts/evaluate_external_corpora.py --fetch --max-files 20
+```
+
+Every subsequent run is offline and rejects a dirty or revision-mismatched cache:
+
+```bash
+python scripts/evaluate_external_corpora.py \
+  --output benchmarks/results/external-corpora.json
+```
+
+Corpora are evaluation inputs only. They are not vendored and are never accessed at package runtime.
+
+## LSP Configuration
+
+Start the server with:
+
+```bash
+codinglanguage-mapper lsp --root /absolute/path/to/workspace
+```
+
+An editor client should launch that command over stdio with the workspace directory as its root. The server advertises diagnostics, definition, hover, references, safe rename, document symbols, workspace symbols, and completion for all five languages.
+
+Safe rename requires an exact declaration range and refuses unresolved or ambiguous references. Diagnostics retain the mapper's structured severity and source ranges.
+
+Example generic client configuration:
+
+```json
+{
+  "command": "codinglanguage-mapper",
+  "args": ["lsp", "--root", "/absolute/path/to/workspace"],
+  "transport": "stdio",
+  "filetypes": ["python", "rust", "cs", "pascal", "cpp"]
+}
+```
+
+## OpenCode Integration
+
+Install the packaged skill, plugin, and restricted agent configuration into a repository:
+
+```bash
+codinglanguage-mapper opencode install --target . --write
+```
+
+This creates:
+
+```text
+.agents/skills/mixed-codebase-navigator/SKILL.md
+.opencode/plugins/codebase_map.ts
+opencode.json
+```
+
+The generated `mixed-codebase-navigator` agent denies all tools by default and permits only `skill` and `codebase_map`. The plugin maps the active OpenCode directory, serializes Protocol 3 requests through one worker, applies a hard timeout, reports bounded worker `stderr`, restarts after failure, and preserves focus plus warm parser indexes across short idle gaps. It stops the worker when the session is deleted or after 60 seconds without another mapper request.
+
+Run it with:
+
+```bash
+opencode run \
+  --agent mixed-codebase-navigator \
+  "Find PaymentService, inspect its implementation, and cite the callers. Use only the installed skill and codebase_map."
+```
+
+A typical investigation should:
+
+1. Call `codebase_map` with `action: open`.
+2. Use `find` with the narrowest useful language/project/file filters.
+3. Select a returned `target_id` with `focus`.
+4. Request only the required `inspect` detail.
+5. Use `trace` only for explicit Protocol 3 relations.
+6. Follow `next_cursor` when evidence is truncated.
+
+## Large-Workspace Performance
+
+The release benchmark generates one valid file above 100,000 lines for each language and a mixed workspace above 500,000 lines. On the reference Apple Silicon Mac, release budgets are:
+
+- cold parse P95 per 100k file: 3 seconds
+- mixed overview P95: 5 seconds
+- warm search P95: 1.5 seconds
+- inspect and focus P95: 0.5 seconds each
+
+Reproduce the benchmark:
+
+```bash
+python scripts/benchmark_large_workspaces.py \
+  --lines 100000 \
+  --samples 5 \
+  --output benchmarks/results/macos-current.json
+```
+
+The command exits nonzero when any budget is exceeded.
+Private Linux CI records and uploads the same measurements with `--report-only`; the Apple Silicon release budgets are enforced only on the documented reference Mac and are not applied to unrelated hosted hardware.
+
+## Offline Ornith/OpenCode Evaluation
+
+The repository contains six release E2Es: Python, Rust, C#, Delphi, C++, and a mixed-language FFI workspace. They use the pinned local Ornith revision through vLLM 0.23.0 and OpenCode 1.17.18. The Python scenario continues the same session through a headless OpenCode server and must inspect the focused symbol in a second turn without another `find` or explicit `target_id`, proving that the plugin preserves its warm worker. It then opens an independent session whose target-less `inspect` must be empty, proving that focus never crosses chat boundaries. The harness fails if a model shard is missing, a download is attempted, an unapproved tool is called, any assistant message uses a different agent, model, or provider, a worker survives server shutdown, or golden file/line evidence is absent.
+
+Inspect the plan without launching a model:
+
+```bash
+python scripts/run_opencode_e2e.py --plan
+```
+
+Verify the exact local executables, versions, model revision, and weight shards:
+
+```bash
+python scripts/run_opencode_e2e.py --verify-runtime
+```
+
+Run all six scenarios and retain complete evidence:
+
+```bash
+HF_HUB_OFFLINE=1 \
+TRANSFORMERS_OFFLINE=1 \
+HF_DATASETS_OFFLINE=1 \
+PIP_NO_INDEX=1 \
+UV_OFFLINE=1 \
+OPENCODE_DISABLE_AUTOUPDATE=1 \
+python scripts/run_opencode_e2e.py \
+  --artifacts artifacts/opencode-ornith-vllm
+```
+
+The harness stores server logs, isolated OpenCode stdout/stderr, exported sessions, extracted tool calls, runtime metadata, and per-scenario assertions below the selected artifact directory. It probes `/v1/chat/completions`; a successful `/v1/models` response alone is not accepted as server readiness.
+
+For a diagnostic run of one scenario, keep the same release checks and add a selector:
+
+```bash
+python scripts/run_opencode_e2e.py \
+  --scenario python \
+  --artifacts artifacts/opencode-ornith-python
+```
+
+The pinned Metal runtime uses `VLLM_METAL_MEMORY_FRACTION=0.90`. Before launch, the harness waits for at least 20.5 GB of available unified memory. The 24,576-token context keeps enough room for OpenCode's system prompt, mapped source evidence, tool-calling rounds, and up to 4,096 output tokens on the 32 GB reference Mac. OpenCode receives this context limit directly from the same runtime lock as vLLM, so client and server limits cannot drift. The harness supplies an explicit session title so OpenCode does not spend the single local inference slot generating one, and it runs the restricted agent deterministically with a bounded iteration count. The server log must show a KV-cache capacity above 24,576 tokens.
+
+## Development and Release Gates
+
+```bash
+python -m pytest -q
+ruff check src tests scripts
+mypy src scripts
+python scripts/audit_language_matrix.py
+python -m build
+python -m twine check dist/*
+```
+
+Release artifacts must be tested from a fresh virtual environment. The wheel must contain the skill/plugin templates and must not contain, depend on, or import `python-delphi-lsp`.
+
+## License
+
+Copyright is attributed to `Dark Light`. The package is licensed under MPL-2.0. Ported Delphi frontend files remain under the same license; `python-delphi-lsp` is not installed, imported, bundled as a subpackage, or modified by this project.

agent_codinglanguage_mapper-1.0.0.dist-info/RECORD

@@ -0,0 +1,42 @@
+agent_codinglanguage_mapper/__init__.py,sha256=obrrVAfq6Y_Qh5UHZ8YuJWV6BDdiofqAvoVWr5RHru0,448
+agent_codinglanguage_mapper/__main__.py,sha256=D31U8_ux95qF64EQ8ReT25nabzxh7ped5avpobXz_bM,49
+agent_codinglanguage_mapper/_version.py,sha256=uyfGiipFnhOCQlqywx7wsgp6d-SYnqPqsPQd_xePZl8,23
+agent_codinglanguage_mapper/cli.py,sha256=2y-Ued0B57inojA_xOAThaBLJ_q1xTqo8bC2wAOosRE,5422
+agent_codinglanguage_mapper/discovery.py,sha256=rzZ3iSOrFZ3eXXCRFTw0rN2yxoW9Z1SSxIZrhPlf1Y8,50756
+agent_codinglanguage_mapper/indexer.py,sha256=-s_3Yyq_D26ljOcDMAlJ-QyG05w79qfHnYk5spzuL7c,39260
+agent_codinglanguage_mapper/integration.py,sha256=0lFo4oXOtkrOy9iJS1OCvSO0hBhrYDDPUUlJJSzcgrE,6976
+agent_codinglanguage_mapper/lsp_server.py,sha256=LtXalnGP9mmwdCHudCHE80lkR-CO-zcg575dGbX-xgA,15123
+agent_codinglanguage_mapper/lsp_service.py,sha256=M-ACQT45Yii57ObbJAVYttgtS3NhZw35kaIIxREPvC8,19031
+agent_codinglanguage_mapper/mapper.py,sha256=iBhau3-jehmNawoeN-TAaYXMc6_sEovraoSuMSSbINM,25474
+agent_codinglanguage_mapper/models.py,sha256=YCMp0tmOyCqyaAH7XKgUdGAfr9wskdbJYMrtT3Pafd8,2083
+agent_codinglanguage_mapper/protocol.py,sha256=SXAJUzdi2b8L1amQgmT9Fd3SpeZ-Hr-jSvA5uZlCLqs,6421
+agent_codinglanguage_mapper/rendering.py,sha256=rqmlpHp3vxwoh-tES1X7VBy3vr30atGyHQ6egz80rEY,6054
+agent_codinglanguage_mapper/worker.py,sha256=6wcIDJ2SNUASDD5DJngm5SrOurOw52GWj52AhGchC8Q,1140
+agent_codinglanguage_mapper/workspace.py,sha256=5vPgt7h9YQcKgVkVDq7m8dUzGuuN4y5UL9aPhhOLozA,4724
+agent_codinglanguage_mapper/adapters/__init__.py,sha256=qLG_Oz2EtTDGXjkyCFaFJjfifbyeF0HOBDJMQV9HB5U,401
+agent_codinglanguage_mapper/adapters/delphi.py,sha256=9POkTqsS0DqkAQGR1LWZVuS5zQ4dRG4AdQKoWFAjaY0,33645
+agent_codinglanguage_mapper/adapters/tree_sitter.py,sha256=A3l5kVWzyNu362Zft-fqvKOv4EomUs7YlQKDQ2CuN3E,71786
+agent_codinglanguage_mapper/adapters/delphi_frontend/__init__.py,sha256=Y7__997bmRQ7BKZoM0qLbp6S6s5W5m8se7ILL7Vw0Js,199
+agent_codinglanguage_mapper/adapters/delphi_frontend/comment_builder.py,sha256=XvFW7WTbYy7yGN3MG40gtabTvhGj1ea1MYkySDbVMDA,832
+agent_codinglanguage_mapper/adapters/delphi_frontend/consts.py,sha256=qM40iwxXmvEileWHJVLMYlQSkLoLyQaqM-Zscz3VJbs,5958
+agent_codinglanguage_mapper/adapters/delphi_frontend/grammar.py,sha256=QWEMSUKr0e1xlJOveZtp7K-MvhlkvDgxkD0iUKIyxKU,18577
+agent_codinglanguage_mapper/adapters/delphi_frontend/lark_builder.py,sha256=KTXxr5WrLMvzdb0F71JMzFqExLiEPF1_cwGrZkurgqQ,118651
+agent_codinglanguage_mapper/adapters/delphi_frontend/lark_tokens.py,sha256=xT_GES2z6p1IdN3EnoKE9RcUM6suu1RV3J-0FEJN2r8,4176
+agent_codinglanguage_mapper/adapters/delphi_frontend/lsp_server.py,sha256=fznUAhcvwTgdiiDrv1nEqW_UsiOJ6Lldd_x-ooGSCLk,65940
+agent_codinglanguage_mapper/adapters/delphi_frontend/nodes.py,sha256=LW8KUgNCg9MHK_2NmzrgCMMJNcBwa4C76XwKoS7kt4E,13556
+agent_codinglanguage_mapper/adapters/delphi_frontend/parser.py,sha256=-NGETYDomzko-OpQtCLEGUfGpxQKVKeLp23_FY1DL1M,6559
+agent_codinglanguage_mapper/adapters/delphi_frontend/preprocessor.py,sha256=7cEfbN7zhWezAiroZ5t-S3H22v4aNTcimQRAigWMvtw,36727
+agent_codinglanguage_mapper/adapters/delphi_frontend/project_discovery.py,sha256=ei7Iy19EMpTWjOFpKPc9hDG2oH1MUGxKwCLnibJp_TM,17336
+agent_codinglanguage_mapper/adapters/delphi_frontend/project_indexer.py,sha256=R5oD4sYsIi2nAlOCr-Mq3-CFkINeC19t0vtKkciCRmg,11227
+agent_codinglanguage_mapper/adapters/delphi_frontend/semantic.py,sha256=FZ9x_QsIS_u-1DlzVlYgRqH9gQZ5ySnDAD-xHwzblU8,9808
+agent_codinglanguage_mapper/adapters/delphi_frontend/semantic_builder.py,sha256=ulA7xHJpltjc6cTo5wh9yTcYazuIykM-YLMXD1h-wzk,58680
+agent_codinglanguage_mapper/adapters/delphi_frontend/source_reader.py,sha256=HWiw25sLVZ6s1GGpMl17uZ-o68HoxTEd3Z0__m1vsSE,520
+agent_codinglanguage_mapper/adapters/delphi_frontend/workspace.py,sha256=TU__SujItRlW8hB2kuYC7ZJx1WQVOj7frYxvo7rDqeI,2137
+agent_codinglanguage_mapper/templates/opencode/plugins/codebase_map.ts,sha256=RdXvLtL9ieyrhkxv3khbrEjXBeroVyZVSAG4dAzKYk4,6838
+agent_codinglanguage_mapper/templates/skill/SKILL.md,sha256=pyKVldpHWezuiswG5FKI3Rxpmjc9fEYwAHJ3-W4WjTs,3227
+agent_codinglanguage_mapper-1.0.0.dist-info/licenses/LICENSE,sha256=-rPda9qyJvHAhjCx3ZF-Efy07F4eAg4sFvg6ChOGPoU,16726
+agent_codinglanguage_mapper-1.0.0.dist-info/METADATA,sha256=gI1ywuU2NvjKRVJCN7bw8AeAbYuQxRsVQIRP2v8Ias0,19102
+agent_codinglanguage_mapper-1.0.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+agent_codinglanguage_mapper-1.0.0.dist-info/entry_points.txt,sha256=WaoNMRnakxcGmddrFFn74vcpa66YDQHMgDpXF2lbKsI,79
+agent_codinglanguage_mapper-1.0.0.dist-info/top_level.txt,sha256=EYFF-VOTZBm6V7KzaUxkbs0qVTF3w_WT2bsLc6B3Ry0,28
+agent_codinglanguage_mapper-1.0.0.dist-info/RECORD,,

agent_codinglanguage_mapper-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

agent_codinglanguage_mapper-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+codinglanguage-mapper = agent_codinglanguage_mapper.cli:main