oh-my-agent 15.0.2 → 15.0.4

package/assets/serena/dart_check.py

@@ -0,0 +1,129 @@
+"""Read-only hook client for the project's already-running Serena daemon."""
+
+import argparse
+import asyncio
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+from mcp import ClientSession
+from mcp.client.streamable_http import streamablehttp_client
+
+
+def git(root, *args):
+    return subprocess.check_output(["git", "-C", str(root), *args])
+
+
+def check_index(root, package):
+    # Whole-project diagnostics are only an index check when that whole scope
+    # matches disk. Never stash/rewrite a concurrent worker's files.
+    changes = git(root, "diff", "--name-only", "-z", "--", package)
+    untracked = git(
+        root, "ls-files", "--others", "--exclude-standard", "-z", "--", package
+    )
+    relevant = [
+        p.decode()
+        for p in (changes + untracked).split(b"\0")
+        if p and (p.endswith((b".dart", b".yaml", b".yml", b".lock")))
+    ]
+    if relevant:
+        raise ValueError(
+            "Mobile analysis inputs differ from the index: " + ", ".join(relevant[:10])
+        )
+    return git(root, "ls-files", "--stage", "-z", "--", package)
+
+
+def validate_result(result, package, expected_sdk):
+    if result.get("complete") is not True or result.get("scope") != package:
+        raise ValueError(
+            "Serena did not return completed analysis for the requested package"
+        )
+    if Path(result.get("sdk_executable", "")).resolve() != expected_sdk.resolve():
+        raise ValueError(
+            "Serena uses a different Dart SDK; restart it with the project SDK"
+        )
+    diagnostics = result.get("diagnostics")
+    if not isinstance(diagnostics, dict):
+        raise ValueError("Malformed Serena diagnostics response")
+    return diagnostics
+
+
+async def run(args):
+    root = Path(args.root).resolve() if args.root else Path(
+        git(Path.cwd(), "rev-parse", "--show-toplevel").decode().strip()
+    ).resolve()
+    package = str((root / args.project).resolve().relative_to(root))
+    sdk = Path(args.dart_sdk).expanduser().resolve(strict=True)
+    index = check_index(root, package) if args.staged else None
+    url = args.url
+    async with streamablehttp_client(
+        url, timeout=args.timeout, sse_read_timeout=args.timeout
+    ) as (read, write, _):
+        async with ClientSession(read, write) as session:
+            await session.initialize()
+            response = await session.call_tool(
+                "get_dart_project_diagnostics",
+                {
+                    "relative_path": package,
+                    "timeout_seconds": args.timeout,
+                },
+            )
+            if response.isError:
+                raise ValueError("Serena analysis failed: " + str(response.content))
+            blocks = [
+                c.text for c in response.content if getattr(c, "type", "") == "text"
+            ]
+            if len(blocks) != 1:
+                raise ValueError("Unexpected Serena response")
+            result = json.loads(blocks[0])
+    diagnostics = validate_result(result, package, sdk)
+    if result.get("project_root") != str(root):
+        raise ValueError("Serena returned diagnostics for a different repository")
+    if args.staged and index != check_index(root, package):
+        raise ValueError("Git index changed during analysis; retry")
+    issues = 0
+    for path, entries in diagnostics.items():
+        for entry in entries:
+            if entry.get("severity", 1) <= 3:
+                issues += 1
+                line = entry["range"]["start"]["line"] + 1
+                print(
+                    f"{path}:{line}: {entry.get('code', 'diagnostic')}: "
+                    f"{entry['message']}"
+                )
+    print(f"Serena Dart: analysis complete, {issues} issue(s); {result['sdk_version']}")
+    return 1 if issues else 0
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--project", default="apps/mobile")
+    parser.add_argument("--root")
+    parser.add_argument("--url", required=True)
+    parser.add_argument(
+        "--dart-sdk", required=True, help="Project Dart executable (not a mise shim)"
+    )
+    parser.add_argument("--timeout", type=int, default=60)
+    parser.add_argument("--staged", action="store_true")
+    args = parser.parse_args()
+    if not 1 <= args.timeout <= 120:
+        parser.error("--timeout must be between 1 and 120")
+    try:
+        return asyncio.run(asyncio.wait_for(run(args), timeout=args.timeout))
+    except (Exception, KeyboardInterrupt) as error:
+
+        def details(exc):
+            children = getattr(exc, "exceptions", None)
+            return (
+                "; ".join(details(child) for child in children)
+                if children
+                else str(exc) or type(exc).__name__
+            )
+
+        print(f"Serena Dart check incomplete: {details(error)}", file=sys.stderr)
+        return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/assets/serena/install.py

@@ -0,0 +1,82 @@
+"""Reconcile OMA's adapter with the interpreter that owns the Serena executable."""
+
+import argparse
+import hashlib
+import importlib.metadata
+import importlib.util
+import json
+import os
+from pathlib import Path
+import tempfile
+
+IMPORT = "from .oma_dart import GetDartProjectDiagnosticsTool\n"
+CACHE_IMPORT = "from .oma_symbol_cache import install_symbol_cache as _install_symbol_cache\n_install_symbol_cache()\n"
+SUPPORTED = {"1.7.0"}
+
+
+def atomic_write(path, content):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd, temporary = tempfile.mkstemp(dir=path.parent, prefix=".oma-")
+    try:
+        with os.fdopen(fd, "w") as output:
+            output.write(content)
+        if path.exists():
+            os.chmod(temporary, path.stat().st_mode & 0o777)
+        os.replace(temporary, path)
+    finally:
+        Path(temporary).unlink(missing_ok=True)
+
+
+def reconcile(package, version, source, check_only=False):
+    if version not in SUPPORTED:
+        return {
+            "status": "unsupported",
+            "version": version,
+            "error": f"Serena {version} is not supported by this OMA adapter (tested: 1.7.0)",
+        }
+    payload = (source / "oma_dart.py").read_text()
+    cache_payload = (source / "oma_symbol_cache.py").read_text()
+    init = package / "tools/__init__.py"
+    text = init.read_text()
+    updated = text if IMPORT in text else text.rstrip() + "\n" + IMPORT
+    if CACHE_IMPORT not in updated:
+        updated = updated.rstrip() + "\n" + CACHE_IMPORT
+    target = package / "tools/oma_dart.py"
+    cache_target = package / "tools/oma_symbol_cache.py"
+    changed = (
+        updated != text
+        or not target.is_file()
+        or target.read_text() != payload
+        or not cache_target.is_file()
+        or cache_target.read_text() != cache_payload
+    )
+    if changed and not check_only:
+        atomic_write(target, payload)
+        atomic_write(cache_target, cache_payload)
+        if updated != text:
+            atomic_write(init, updated)
+    revision = hashlib.sha256((version + payload + cache_payload).encode()).hexdigest()
+    return {
+        "status": "missing" if check_only and changed else "ready",
+        "version": version,
+        "changed": changed and not check_only,
+        "revision": revision,
+        "package": str(package),
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--check", action="store_true")
+    args = parser.parse_args()
+    try:
+        version = importlib.metadata.version("serena-agent")
+        package = Path(importlib.util.find_spec("serena").origin).parent
+        result = reconcile(package, version, Path(__file__).parent, args.check)
+    except Exception as error:
+        result = {"status": "error", "error": str(error)}
+    print(json.dumps(result))
+
+
+if __name__ == "__main__":
+    main()

package/assets/serena/oma_dart.py

@@ -0,0 +1,277 @@
+"""Dart project diagnostics on Serena's existing language server (Serena 1.7).
+
+Installed as serena.tools.oma_dart. No second analysis server is launched.
+"""
+
+import hashlib
+import json
+import os
+import subprocess
+import threading
+import time
+from contextvars import ContextVar
+from pathlib import Path
+from urllib.parse import unquote, urlparse
+
+from serena.tools.tools_base import Tool, ToolMarkerSymbolicRead
+from solidlsp.language_servers.dart_language_server import DartLanguageServer
+from solidlsp.ls_config import LanguageServerId
+
+
+def snapshot(root):
+    """Detect edits during analysis, including new/deleted files and options."""
+    result = {}
+    for directory, dirs, files in os.walk(root, followlinks=False):
+        dirs[:] = [
+            d
+            for d in dirs
+            if d
+            not in {
+                ".git",
+                ".dart_tool",
+                "build",
+                "node_modules",
+                ".venv",
+                "android",
+                "ios",
+                "macos",
+                "windows",
+                "linux",
+            }
+            and not Path(directory, d).is_symlink()
+        ]
+        for name in files:
+            path = Path(directory, name)
+            if (
+                path.suffix in {".dart", ".yaml", ".yml", ".lock"}
+                or name == "package_config.json"
+            ):
+                result[str(path.relative_to(root))] = hashlib.sha256(
+                    path.read_bytes()
+                ).hexdigest()
+    package_config = root / ".dart_tool/package_config.json"
+    if package_config.is_file():
+        result[".dart_tool/package_config.json"] = hashlib.sha256(
+            package_config.read_bytes()
+        ).hexdigest()
+    return result
+
+
+_original_setup = DartLanguageServer._setup_runtime_dependencies
+_original_init = DartLanguageServer.__init__
+_original_observe = DartLanguageServer._observe_server_notification
+_sdk_root = ContextVar("oma_dart_project_root", default=None)
+
+
+class AnalysisBarrier:
+    """Require a new start/end pair, as the Dart 3.13 reanalyze test does."""
+
+    def __init__(self):
+        self.condition = threading.Condition()
+        self.started = 0
+        self.completed = 0
+        self.busy = False
+
+    def notify(self, busy):
+        with self.condition:
+            if busy:
+                self.started += 1
+            else:
+                self.completed = self.started
+            self.busy = busy
+            self.condition.notify_all()
+
+    def wait(self, after, timeout):
+        with self.condition:
+            if not self.condition.wait_for(
+                lambda: (
+                    self.started > after
+                    and self.completed == self.started
+                    and not self.busy
+                ),
+                timeout=timeout,
+            ):
+                raise TimeoutError("Dart did not report a new completed analysis cycle")
+
+
+def _init(self, *args, **kwargs):
+    self._oma_analysis = AnalysisBarrier()
+    root = args[1] if len(args) > 1 else kwargs["repository_root_path"]
+    token = _sdk_root.set(root)
+    try:
+        _original_init(self, *args, **kwargs)
+    finally:
+        _sdk_root.reset(token)
+    command = self._get_process_launch_info().cmd
+    self._oma_sdk_executable = command[0] if isinstance(command, list) else None
+    self.server.on_notification("$/analyzerStatus", lambda _: None)
+
+
+def _observe(self, method, params):
+    _original_observe(self, method, params)
+    if method == "$/analyzerStatus" and isinstance(params, dict):
+        busy = params.get("isAnalyzing")
+        if isinstance(busy, bool):
+            self._oma_analysis.notify(busy)
+
+
+def _setup(cls, settings):
+    executable = settings.get_ls_specific_settings(LanguageServerId.DART).get(
+        "dart_executable"
+    )
+    if not executable:
+        return _original_setup(settings)
+    if executable == "mise":
+        try:
+            flutter = subprocess.check_output(
+                ["mise", "which", "flutter"], cwd=_sdk_root.get(),
+                text=True, stderr=subprocess.PIPE, timeout=5,
+            ).strip()
+            executable = str(Path(flutter).parent / "cache/dart-sdk/bin/dart")
+            if not Path(executable).is_file():
+                raise FileNotFoundError(executable)
+        except (subprocess.SubprocessError, FileNotFoundError):
+            executable = subprocess.check_output(
+                ["mise", "which", "dart"], cwd=_sdk_root.get(),
+                text=True, timeout=5,
+            ).strip()
+    path = Path(executable).expanduser().resolve(strict=True)
+    if not path.is_file() or not os.access(path, os.X_OK):
+        raise ValueError(f"Not an executable Dart SDK: {path}")
+    # An argv list also supports SDK paths containing spaces.
+    return [str(path), "language-server", "--client-id", "oma.serena"]
+
+
+DartLanguageServer._setup_runtime_dependencies = classmethod(_setup)
+DartLanguageServer.__init__ = _init
+DartLanguageServer._observe_server_notification = _observe
+
+
+def refresh(ls, timeout):
+    barrier = ls._oma_analysis
+    baseline = barrier.started
+    started_at = time.monotonic()
+    ls.server.send_request("dart/reanalyze")
+    barrier.wait(baseline, max(0, timeout - (time.monotonic() - started_at)))
+
+
+def file_diagnostics(
+    self, relative_file_path, start_line=0, end_line=-1, min_severity=4
+):
+    uri = self._validate_text_document_diagnostics_request(
+        relative_file_path,
+        start_line,
+        end_line,
+        min_severity,
+    )
+    with self.open_file(relative_file_path):
+        refresh(self, 60)
+        diagnostics = self._get_cached_published_diagnostics(uri) or []
+    return self._filter_diagnostics(diagnostics, start_line, end_line, min_severity)
+
+
+DartLanguageServer.request_text_document_diagnostics = file_diagnostics
+
+
+def collect(ls, package, repository, timeout):
+    """A missing completion method/timeout is an error, never empty diagnostics."""
+    before = snapshot(package)
+    candidates = sorted(name for name in before if name.endswith(".dart"))
+    if not candidates:
+        raise ValueError("No Dart source files in the requested package")
+    entry = (
+        "lib/main.dart"
+        if "lib/main.dart" in candidates
+        else next(
+            (name for name in candidates if name.startswith("lib/")), candidates[0]
+        )
+    )
+    anchor = str((package / entry).relative_to(repository))
+    # Keep one real file open per package, preserving its analysis context
+    # between hook calls. open_file refreshes an existing buffer from disk.
+    anchors = getattr(ls, "_oma_dart_anchors", {})
+    for name in list(anchors):
+        if not (repository / name).is_file():
+            anchors.pop(name).__exit__(None, None, None)
+    if anchor not in anchors:
+        context = ls.open_file(anchor)
+        context.__enter__()
+        anchors[anchor] = context
+        ls._oma_dart_anchors = anchors
+    old_timeout = ls.server._request_timeout
+    try:
+        ls.server._request_timeout = timeout
+        with ls.open_file(anchor):
+            # The server watches disk asynchronously; explicitly refresh before
+            # asking for its completion barrier, including package/config edits.
+            # Dart 3.13.4 does not yet implement workspace/analysis/complete.
+            # Do not mistake an old idle event for completion of this refresh.
+            refresh(ls, timeout)
+            diagnostics = {}
+            with ls._published_diagnostics_condition:
+                for uri, entries in ls._published_diagnostics.items():
+                    path = Path(unquote(urlparse(uri).path))
+                    if path.is_relative_to(package) and path.is_file() and entries:
+                        diagnostics[str(path.relative_to(repository))] = entries.copy()
+    finally:
+        ls.server._request_timeout = old_timeout
+    if before != snapshot(package):
+        raise RuntimeError(
+            "Project changed during analysis; retry on a stable working tree"
+        )
+    return diagnostics
+
+
+class GetDartProjectDiagnosticsTool(Tool, ToolMarkerSymbolicRead):
+    """Wait for Dart project analysis and return all published diagnostics."""
+
+    def apply(self, relative_path: str, timeout_seconds: int = 60) -> str:
+        """Analyze a pub package using the existing Dart LSP.
+
+        :param relative_path: package directory containing pubspec.yaml.
+        :param timeout_seconds: maximum wait per analysis request (1..120).
+        :return: complete diagnostics, SDK identity, and package scope.
+        """
+        if not 1 <= timeout_seconds <= 120:
+            raise ValueError("timeout_seconds must be between 1 and 120")
+        repository = Path(self.project.project_root).resolve()
+        package = (repository / relative_path).resolve()
+        if (
+            not package.is_relative_to(repository)
+            or not (package / "pubspec.yaml").is_file()
+        ):
+            raise ValueError("Expected a pub package inside the active project")
+        self.project.ls_sync_file_system_changes()
+        sources = sorted(package.glob("lib/**/*.dart")) or sorted(
+            package.glob("*.dart")
+        )
+        if not sources:
+            raise ValueError("Package has no Dart entry file")
+        ls = self.create_language_server_symbol_retriever().get_language_server(
+            str(sources[0].relative_to(repository))
+        )
+        if not isinstance(ls, DartLanguageServer):
+            raise ValueError("Requested file is not managed by Dart LSP")
+        executable = ls.custom_settings.get("dart_executable")
+        if not executable:
+            raise ValueError(
+                "Set ls_specific_settings.dart.dart_executable to the project SDK, "
+                "then restart Serena"
+            )
+        if executable == "mise":
+            # Query the actual launched argv, not the possibly changed PATH.
+            executable = ls._oma_sdk_executable
+        version = subprocess.check_output(
+            [executable, "--version"], text=True, timeout=5
+        ).strip()
+        diagnostics = collect(ls, package, repository, timeout_seconds)
+        return json.dumps(
+            {
+                "complete": True,
+                "project_root": str(repository),
+                "scope": str(package.relative_to(repository)),
+                "sdk_executable": str(Path(executable).resolve()),
+                "sdk_version": version,
+                "diagnostics": diagnostics,
+            }
+        )

package/assets/serena/oma_symbol_cache.py

@@ -0,0 +1,133 @@
+"""File-granular symbol caching for Serena 1.7.0's long-lived Python process.
+
+Legacy pickles eagerly restore every file and retain mutable workspace trees.
+SQLite keeps cold files on disk; serialized entries isolate request mutations.
+"""
+
+import hashlib
+import logging
+import pickle
+import sqlite3
+import threading
+from collections.abc import MutableMapping
+
+log = logging.getLogger(__name__)
+FORMAT_VERSION = 1
+MAX_ENTRY_BYTES = 16 * 1024 * 1024
+
+
+class DiskSymbolCache(MutableMapping):
+    def __init__(self, directory, kind, version):
+        self._lock = threading.RLock()
+        self._connection = None
+        digest = hashlib.sha256(pickle.dumps((FORMAT_VERSION, version))).hexdigest()[
+            :24
+        ]
+        self.path = directory / f"oma-{kind}-{digest}.sqlite3"
+        try:
+            self._connection = sqlite3.connect(
+                self.path, timeout=2, isolation_level=None, check_same_thread=False
+            )
+            self._connection.execute("PRAGMA journal_mode=WAL")
+            self._connection.execute("PRAGMA cache_size=-2048")
+            self._connection.execute("PRAGMA mmap_size=0")
+            self._connection.execute(
+                "CREATE TABLE IF NOT EXISTS symbols (path TEXT PRIMARY KEY, value BLOB NOT NULL)"
+            )
+        except (OSError, sqlite3.Error) as error:
+            self._disable(error)
+
+    def _disable(self, error):
+        # A disposable cache must never make code intelligence unavailable.
+        log.warning(
+            "OMA symbol cache unavailable at %s; using uncached requests: %s",
+            self.path,
+            error,
+        )
+        self.close()
+
+    def _query(self, sql, params=()):
+        with self._lock:
+            if self._connection is None:
+                return []
+            try:
+                return self._connection.execute(sql, params).fetchall()
+            except sqlite3.Error as error:
+                self._disable(error)
+                return []
+
+    def __getitem__(self, key):
+        rows = self._query("SELECT value FROM symbols WHERE path=?", (key,))
+        if not rows:
+            raise KeyError(key)
+        try:
+            # Each request owns its decoded graph. Attaching a parent package
+            # in request_full_symbol_tree cannot mutate the persistent cache.
+            return pickle.loads(rows[0][0])
+        except Exception:
+            self._query("DELETE FROM symbols WHERE path=?", (key,))
+            raise KeyError(key) from None
+
+    def __setitem__(self, key, value):
+        with self._lock:
+            if self._connection is None:
+                return
+            try:
+                payload = pickle.dumps(value, protocol=pickle.HIGHEST_PROTOCOL)
+            except Exception:
+                return
+            if len(payload) > MAX_ENTRY_BYTES:
+                self._query("DELETE FROM symbols WHERE path=?", (key,))
+                return
+            self._query("INSERT OR REPLACE INTO symbols VALUES (?, ?)", (key, payload))
+
+    def __delitem__(self, key):
+        with self._lock:
+            if not self._query("SELECT 1 FROM symbols WHERE path=?", (key,)):
+                raise KeyError(key)
+            self._query("DELETE FROM symbols WHERE path=?", (key,))
+
+    def __iter__(self):
+        return iter(row[0] for row in self._query("SELECT path FROM symbols"))
+
+    def __len__(self):
+        rows = self._query("SELECT count(*) FROM symbols")
+        return rows[0][0] if rows else 0
+
+    def close(self):
+        with self._lock:
+            if self._connection is not None:
+                self._connection.close()
+                self._connection = None
+
+    def __del__(self):
+        self.close()
+
+
+def _load_raw(self):
+    self._raw_document_symbols_cache = DiskSymbolCache(
+        self.cache_dir, "raw-symbols", self._raw_document_symbols_cache_version()
+    )
+
+
+def _load_documents(self):
+    self._document_symbols_cache = DiskSymbolCache(
+        self.cache_dir, "document-symbols", self._document_symbols_cache_version()
+    )
+
+
+def _save_raw(self):
+    self._raw_document_symbols_cache_is_modified = False
+
+
+def _save_documents(self):
+    self._document_symbols_cache_is_modified = False
+
+
+def install_symbol_cache():
+    from solidlsp.ls import SolidLanguageServer
+
+    SolidLanguageServer._load_raw_document_symbols_cache = _load_raw
+    SolidLanguageServer._load_document_symbols_cache = _load_documents
+    SolidLanguageServer._save_raw_document_symbols_cache = _save_raw
+    SolidLanguageServer._save_document_symbols_cache = _save_documents