mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-11-16 19:36:54 +00:00
Pinning settings per server left every other server free to run project code: rust-analyzer runs cargo check (build.rs, proc-macros) on each didSave despite the disabled init options, and jdtls, kotlin-language-server, elixir-ls, zls, clojure-lsp and haskell-language-server evaluate build files when they start. In an untrusted workspace only UNTRUSTED_SAFE_SERVERS now start (pyright, typescript, vue, svelte with their pinned settings; bash, yaml, dockerfile, intelephense, clangd without --query-driver). Every other built-in or user-declared server is skipped at the spawn chokepoint and in enabled_for, logged once per root and listed by hermes lsp status. The rust-analyzer init tweak is gone: it never starts untrusted now. On a local backend the npx tsc and rustfmt --check fallbacks are skipped the same way, since npx resolves the repo's node_modules/.bin/tsc (or its .npmrc registry) and rustup honours its rust-toolchain.toml.
139 lines
5.8 KiB
Python
139 lines
5.8 KiB
Python
"""Skip the per-file shell linter when LSP will handle the same file.
|
|
|
|
The per-file ``npx tsc --noEmit FILE.ts`` shell linter cannot see
|
|
``tsconfig.json`` (a documented ``tsc`` quirk: explicit file args bypass
|
|
the project config), so it defaults to no-lib / ES5 and floods the
|
|
agent's lint field with phantom "Cannot find 'Promise' / 'Map' / 'Set' /
|
|
'ReadonlySet' / 'Iterable' / 'imul' / …" errors on every edit — up to
|
|
25K tokens per patch. The LSP tier (``tsserver`` via
|
|
typescript-language-server) reads tsconfig correctly and surfaces real
|
|
diagnostics in the ``lsp_diagnostics`` field of the WriteResult /
|
|
PatchResult.
|
|
|
|
These tests pin the contract:
|
|
|
|
- When LSP is active AND ``enabled_for(path)`` for a ``.ts`` / ``.go``
|
|
/ ``.rs`` file, ``_check_lint`` returns ``skipped`` without invoking
|
|
the shell linter at all.
|
|
- When LSP is inactive or disabled-for-path, the shell linter runs
|
|
exactly as before (regression guard for the default config).
|
|
- The skip only applies to extensions in
|
|
``_SHELL_LINTER_LSP_REDUNDANT`` — Python ``py_compile`` and
|
|
``node --check`` keep running unconditionally because they're fast,
|
|
file-local, and correct.
|
|
- ``.tsx`` is intentionally NOT in either ``LINTERS`` or
|
|
``_SHELL_LINTER_LSP_REDUNDANT``: it had no ``LINTERS`` entry
|
|
pre-PR (so it was already implicitly ``skipped`` via the
|
|
``ext not in LINTERS`` branch) and adding one would have inherited
|
|
``.ts``'s broken ``tsc --noEmit FILE`` invocation for LSP-disabled
|
|
users. When LSP IS enabled, ``.tsx`` is still covered by
|
|
typescript-language-server via ``_maybe_lsp_diagnostics`` — the
|
|
diagnostics show up on ``lsp_diagnostics``, not ``lint``.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
import pytest
|
|
|
|
|
|
def _make_fops():
|
|
from tools.environments.local import LocalEnvironment
|
|
from tools.file_operations import ShellFileOperations
|
|
return ShellFileOperations(LocalEnvironment())
|
|
|
|
|
|
@pytest.mark.parametrize("ext", [".ts", ".go", ".rs"])
|
|
def test_shell_linter_skipped_when_lsp_will_handle(ext, tmp_path):
|
|
"""When LSP is active and enabled_for(path), shell linter is skipped.
|
|
|
|
The shell linter's _exec must NOT be called — that's the whole
|
|
point. We assert by patching ``_exec`` to raise, so any accidental
|
|
invocation surfaces as a test failure.
|
|
"""
|
|
fops = _make_fops()
|
|
src = tmp_path / f"bad{ext}"
|
|
src.write_text("intentionally invalid content\n")
|
|
|
|
def _exec_must_not_run(*args, **kwargs): # pragma: no cover
|
|
raise AssertionError(
|
|
"shell linter was invoked despite LSP claiming the file"
|
|
)
|
|
|
|
with patch.object(fops, "_lsp_will_handle", return_value=True), \
|
|
patch.object(fops, "_exec", side_effect=_exec_must_not_run), \
|
|
patch.object(fops, "_has_command", return_value=True):
|
|
result = fops._check_lint(str(src))
|
|
|
|
assert result.skipped is True
|
|
assert "LSP" in (result.message or "")
|
|
|
|
|
|
def test_lsp_will_handle_swallows_enabled_for_exception(tmp_path):
|
|
"""A flaky LSP service must never break the shell-linter fallback —
|
|
if ``enabled_for`` raises, we treat the file as "not handled" so the
|
|
shell linter still runs."""
|
|
fops = _make_fops()
|
|
src = tmp_path / "foo.ts"
|
|
src.write_text("const x = 1\n")
|
|
|
|
fake_svc = MagicMock()
|
|
fake_svc.enabled_for.side_effect = RuntimeError("server crashed")
|
|
|
|
with patch.object(fops, "_lsp_local_only", return_value=True), \
|
|
patch("agent.lsp.get_service", return_value=fake_svc):
|
|
assert fops._lsp_will_handle(str(src)) is False
|
|
|
|
|
|
def test_ts_shell_linter_skipped_when_ancestor_tsconfig_present(tmp_path):
|
|
"""A .ts file under a dir tree containing tsconfig.json skips the per-file
|
|
shell tsc EVEN WHEN LSP is inactive — single-file tsc can't read the
|
|
project config, so its diagnostics are pure noise. This closes the
|
|
LSP-disabled gap (the common default).
|
|
|
|
_exec is patched to raise so any accidental shell-linter invocation fails
|
|
the test.
|
|
"""
|
|
fops = _make_fops()
|
|
(tmp_path / "tsconfig.json").write_text('{"compilerOptions":{}}\n')
|
|
sub = tmp_path / "src" / "app"
|
|
sub.mkdir(parents=True)
|
|
src = sub / "thing.ts"
|
|
src.write_text("import { x } from '@/store'\nexport const y = x\n")
|
|
|
|
def _exec_must_not_run(*args, **kwargs): # pragma: no cover
|
|
raise AssertionError("shell tsc ran despite an ancestor tsconfig.json")
|
|
|
|
with patch.object(fops, "_lsp_local_only", return_value=True), \
|
|
patch.object(fops, "_lsp_will_handle", return_value=False), \
|
|
patch.object(fops, "_exec", side_effect=_exec_must_not_run), \
|
|
patch.object(fops, "_has_command", return_value=True):
|
|
result = fops._check_lint(str(src))
|
|
|
|
assert result.skipped is True
|
|
assert "tsconfig.json" in (result.message or "")
|
|
|
|
|
|
def test_ts_shell_linter_runs_when_no_ancestor_tsconfig(tmp_path):
|
|
"""Without any ancestor tsconfig.json (a standalone .ts file), the shell
|
|
tsc still runs — the ancestor-skip must not suppress lint for non-project
|
|
files. We assert _exec IS reached (LSP inactive)."""
|
|
fops = _make_fops()
|
|
src = tmp_path / "loose.ts"
|
|
src.write_text("const x: number = 'nope'\n")
|
|
|
|
exec_result = MagicMock()
|
|
exec_result.exit_code = 2
|
|
exec_result.stdout = "loose.ts(1,7): error TS2322: Type 'string' ...\n"
|
|
|
|
with patch.object(fops, "_lsp_local_only", return_value=True), \
|
|
patch.object(fops, "_lsp_will_handle", return_value=False), \
|
|
patch.object(fops, "_local_workspace_untrusted", return_value=False), \
|
|
patch.object(fops, "_run_managed_node_linter", return_value=exec_result) as exec_mock:
|
|
fops._check_lint(str(src))
|
|
|
|
assert exec_mock.called, "tsc should run when there's no project tsconfig"
|
|
|
|
|
|
if __name__ == "__main__": # pragma: no cover
|
|
pytest.main([__file__, "-v"])
|