robotframework-lint-lsp 1.0.0__py3-none-any.whl

robotframework_lint/__init__.py

@@ -0,0 +1,3 @@
+"""Robocop rule pack for Robot Framework."""
+
+__version__ = "0.1.0"

robotframework_lint/autofix.py

@@ -0,0 +1,63 @@
+"""PostToolUse hook: apply safe robocop fixes to a Robot file right after an agent edits it.
+
+A/B runs showed agents read "fix all: <command>" hints but never ran them, so the
+fixable findings stayed. Fixing here costs the agent no turns. Silent by design:
+the LSP push reports whatever is left.
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+from .hints import FIX_COMMANDS
+
+ROBOT_SUFFIXES = {".robot", ".resource"}
+# Two robocop runs must finish inside the hook's 120 s budget.
+TIMEOUT_S = 50
+
+
+def fix_file(path: Path) -> None:
+    # -I: the hook runs inside the edited repo, which must not shadow robocop with its own module.
+    robocop = [sys.executable, "-I", "-m", "robocop"]
+    check_rules = [rule for rule, cmd in FIX_COMMANDS.items() if cmd.startswith("robocop check")]
+    selects = [arg for rule in check_rules for arg in ("--select", rule)]
+    original = path.read_text(encoding="utf-8", newline="")
+    # A temp copy keeps robocop from reading the repo's config, which can name Python rule files.
+    with tempfile.TemporaryDirectory() as tmp:
+        copy = Path(tmp) / f"buffer{path.suffix}"
+        copy.write_text(original, encoding="utf-8", newline="")
+        # TMPDIR can sit under a folder with its own robocop config; an explicit empty one wins.
+        config = Path(tmp) / "robocop.toml"
+        config.write_text("", encoding="utf-8")
+        # Argument lists, never a shell: the path comes from the hook payload.
+        for args in (["format", "--select", "ReplaceWithVAR", "--silent"], ["check", "--fix", *selects]):
+            subprocess.run([*robocop, *args, "--config", str(config), "--root", tmp, "--", str(copy)], cwd=tmp,
+                           capture_output=True, timeout=TIMEOUT_S, check=False)
+        fixed = copy.read_text(encoding="utf-8")  # robocop writes the OS line ending
+    if "\r\n" in original:
+        fixed = fixed.replace("\n", "\r\n")
+    # The agent may have written again while robocop ran; never overwrite the newer text.
+    if fixed != original and path.read_text(encoding="utf-8", newline="") == original:
+        path.write_text(fixed, encoding="utf-8", newline="")
+
+
+def main() -> int:
+    try:
+        payload = json.loads(sys.stdin.read())
+        path = Path(payload["tool_input"]["file_path"])
+    except (ValueError, KeyError, TypeError):
+        return 0
+    if path.suffix.lower() in ROBOT_SUFFIXES and path.is_file():
+        try:
+            fix_file(path)
+        except (OSError, ValueError, subprocess.TimeoutExpired):
+            pass  # a failed fix must never block the agent's edit
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

robotframework_lint/hints.py

@@ -0,0 +1,24 @@
+"""One-line fix hints for the findings agents most often left unfixed.
+
+Robocop has no auto-fix for these, and agents without a hint spent extra
+edit rounds guessing the modern form or left the finding in place.
+"""
+
+# One shell command fixes every finding of the rule in the file (checked on robocop 9.4.0).
+FIX_COMMANDS = {
+    "DEPR05": "robocop format --select ReplaceWithVAR <file>",
+    "DEPR06": "robocop format --select ReplaceWithVAR <file>",
+    **{rule: f"robocop check --fix --select {rule} <file>"
+       for rule in ("DEPR03", "DEPR04", "DEPR07", "DEPR08", "DEPR09", "DEPR10", "DEPR11",
+                    "MISC04", "MISC09", "VAR01")},
+}
+
+FIX_HINTS = {
+    "MISC09": "use inline IF: IF    cond    Keyword    ELSE    Keyword",
+    "SPC03": "use exactly 2 empty lines between sections",
+    "VAR02": "drop the assignment or use the variable",
+    "VAR05": "pass the value as an argument or RETURN it",
+    "VAR06": "pass the value as an argument or RETURN it",
+    "VAR10": "spell the variable the same way everywhere",
+    "MISC04": "use one assignment style in the file",
+}

robotframework_lint/lsp.py

@@ -0,0 +1,237 @@
+"""Minimal LSP server: robocop defaults plus our rules, token-cheap diagnostics.
+
+Token controls: one short line per finding ("RULEID message", capped length),
+a per-file cap, a severity floor, dedup of identical findings, and no related
+information, code descriptions or data payloads.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import tempfile
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from lsprotocol import types
+from pygls.lsp.server import LanguageServer
+
+from .hints import FIX_COMMANDS, FIX_HINTS
+from .lsp_navigation import register as register_navigation
+from .lsp_navigation import scan_workspace
+from .navigation import WorkspaceIndex
+
+RULES_DIR = Path(__file__).parent / "rules"
+MAX_MESSAGE = 120
+MAX_LINT_BYTES = 1_000_000
+DEBOUNCE_SECONDS = 0.4
+SEVERITY_ORDER = {"info": 0, "warning": 1, "error": 2}
+LSP_SEVERITY = {
+    "info": types.DiagnosticSeverity.Information,
+    "warning": types.DiagnosticSeverity.Warning,
+    "error": types.DiagnosticSeverity.Error,
+}
+MAX_GROUP_LINES = 6
+
+
+@dataclass
+class Settings:
+    max_diagnostics: int = 20
+    min_severity: str = "warning"
+    select: list[str] = field(default_factory=list)
+    ignore: list[str] = field(default_factory=list)
+    group: bool = False  # v4 A/B: grouped findings left more DEPR05/06 unfixed
+
+    @classmethod
+    def from_options(cls, options: object) -> Settings:
+        opts = options if isinstance(options, dict) else {}
+        severity = str(opts.get("minSeverity", "warning")).lower()
+        if severity not in SEVERITY_ORDER:
+            severity = "warning"
+        cap = opts.get("maxDiagnostics", 20)
+        cap = cap if isinstance(cap, int) and cap > 0 else 20
+        group = opts.get("groupFindings", False) is True
+        return cls(cap, severity, _str_list(opts.get("select")), _str_list(opts.get("ignore")), group)
+
+
+def _str_list(value: object) -> list[str]:
+    return [str(v) for v in value] if isinstance(value, list) else []
+
+
+def _severity_name(robocop_severity: object) -> str:
+    letter = getattr(robocop_severity, "value", "W")
+    return {"I": "info", "W": "warning", "E": "error"}.get(letter, "warning")
+
+
+def _run_robocop(text: str, suffix: str, settings: Settings) -> list:
+    from robocop.config.manager import ConfigManager
+    from robocop.config.schema import RawConfig, RawLinterConfig
+    from robocop.linter.rules import RuleSeverity
+    from robocop.linter.runner import RobocopLinter
+    from robocop.source_file import SourceFile
+
+    with tempfile.TemporaryDirectory() as tmp:
+        path = Path(tmp) / f"buffer{suffix}"
+        path.write_text(text, encoding="utf-8")
+        linter_config = RawLinterConfig(
+            select=settings.select or None,
+            ignore=settings.ignore or None,
+            threshold=RuleSeverity("I"),  # floor applied after promotion in lint_text
+            custom_rules=[str(RULES_DIR)],
+            return_result=True,
+        )
+        config = RawConfig(sources=[str(path)], linter=linter_config, silent=True)
+        # A robocop or pyproject file above the temp dir must not pick rules or rule files.
+        manager = ConfigManager(sources=[str(path)], root=Path(tmp), ignore_file_config=True,
+                                overwrite_config=config)
+        linter = RobocopLinter(manager)
+        return list(linter.run_check(SourceFile(path=path, config=manager.default_config)))
+
+
+def lint_text(text: str, settings: Settings, suffix: str = ".robot") -> list[types.Diagnostic]:
+    """Lint a buffer and return capped, filtered, deduplicated LSP diagnostics."""
+    floor = SEVERITY_ORDER[settings.min_severity]
+    seen: set[tuple[int, str, str]] = set()
+    groups: dict[str, list[tuple]] = {}
+    found = sorted(_run_robocop(text, suffix, settings), key=lambda d: (d.range.start.line, d.range.start.character))
+    for diag in found:
+        rule_id = diag.rule.rule_id
+        severity = _severity_name(diag.severity)
+        # Promote only Info rules one command fixes; each promoted finding costs agents an edit turn.
+        if severity == "info" and rule_id in FIX_COMMANDS:
+            severity = "warning"
+        if SEVERITY_ORDER[severity] < floor:
+            continue
+        line = max(diag.range.start.line - 1, 0)
+        key = (line, rule_id, diag.message)
+        if key in seen:
+            continue
+        seen.add(key)
+        group_key = rule_id if settings.group else f"{rule_id}:{len(seen)}"
+        groups.setdefault(group_key, []).append((diag, rule_id, line, severity))
+    result = [_group_to_lsp(members) for members in groups.values()]
+    result.sort(key=lambda d: (d.range.start.line, d.range.start.character))
+    if len(result) <= settings.max_diagnostics:
+        return result
+    return result[: settings.max_diagnostics] + [_overflow(len(result) - settings.max_diagnostics, settings)]
+
+
+def _overflow(hidden: int, settings: Settings) -> types.Diagnostic:
+    # Without it an agent can't tell a clean tail from a truncated one.
+    return types.Diagnostic(
+        range=types.Range(types.Position(0, 0), types.Position(0, 0)),
+        message=f"overflow {hidden} more findings not shown (maxDiagnostics {settings.max_diagnostics})",
+        severity=types.DiagnosticSeverity.Information,
+        code="overflow",
+        source="rflint",
+    )
+
+
+def _group_to_lsp(members: list[tuple]) -> types.Diagnostic:
+    """One diagnostic per rule, anchored at its first finding, with the worst severity."""
+    diag, rule_id, line, _ = members[0]
+    severity = max((m[3] for m in members), key=SEVERITY_ORDER.__getitem__)
+    count = ""
+    if len(members) > 1:
+        lines = [str(m[2] + 1) for m in members[:MAX_GROUP_LINES]]
+        more = ",..." if len(members) > MAX_GROUP_LINES else ""
+        count = f"x{len(members)} (lines {','.join(lines)}{more}) "
+    return _to_lsp(diag, rule_id, line, severity, count)
+
+
+def _to_lsp(diag, rule_id: str, line: int, severity: str, count: str = "") -> types.Diagnostic:
+    start_col = max(diag.range.start.character - 1, 0)
+    end_line = max(diag.range.end.line - 1, line)
+    end_col = max(diag.range.end.character - 1, 0)
+    command = FIX_COMMANDS.get(rule_id)
+    hint = f"fix all: {command}" if command else FIX_HINTS.get(rule_id)
+    suffix = f"; {hint}" if hint else ""
+    base = f"{rule_id} {count}{diag.message}"
+    room = MAX_MESSAGE - len(suffix)
+    if len(base) > room:
+        base = base[: room - 3] + "..."
+    message = base + suffix
+    return types.Diagnostic(
+        range=types.Range(types.Position(line, start_col), types.Position(end_line, end_col)),
+        message=message,
+        severity=LSP_SEVERITY[severity],
+        code=rule_id,
+        source="rflint",
+    )
+
+
+class RflintServer(LanguageServer):
+    def __init__(self) -> None:
+        super().__init__("robotframework-lint-lsp", "0.1.0")
+        self.settings = Settings()
+        self.pending: dict[str, asyncio.Task] = {}
+        self.index = WorkspaceIndex()
+
+    def publish(self, uri: str) -> None:
+        doc = self.workspace.get_text_document(uri)
+        suffix = ".resource" if uri.endswith(".resource") else ".robot"
+        if len(doc.source) > MAX_LINT_BYTES:  # a generated blob would hold the event loop
+            self.text_document_publish_diagnostics(
+                types.PublishDiagnosticsParams(uri=uri, version=doc.version, diagnostics=[]))
+            return
+        try:
+            self.index.update(uri, doc.source)
+            diagnostics = lint_text(doc.source, self.settings, suffix)
+            for diag in diagnostics:  # robocop columns are code points
+                diag.range = self.workspace.position_codec.range_to_client_units(doc.lines, diag.range)
+        except Exception as exc:  # parse errors must not kill the server
+            self.window_log_message(types.LogMessageParams(types.MessageType.Warning, f"rflint: {exc}"[:200]))
+            diagnostics = []
+        self.text_document_publish_diagnostics(
+            types.PublishDiagnosticsParams(uri=uri, version=doc.version, diagnostics=diagnostics)
+        )
+
+
+server = RflintServer()
+register_navigation(server)
+
+
+@server.feature(types.INITIALIZE)
+def on_initialize(ls: RflintServer, params: types.InitializeParams) -> None:
+    ls.settings = Settings.from_options(params.initialization_options)
+    scan_workspace(ls.index, params.root_uri)
+
+
+@server.feature(types.TEXT_DOCUMENT_DID_OPEN)
+def on_open(ls: RflintServer, params: types.DidOpenTextDocumentParams) -> None:
+    ls.publish(params.text_document.uri)
+
+
+@server.feature(types.TEXT_DOCUMENT_DID_SAVE)
+def on_save(ls: RflintServer, params: types.DidSaveTextDocumentParams) -> None:
+    ls.publish(params.text_document.uri)
+
+
+@server.feature(types.TEXT_DOCUMENT_DID_CHANGE)
+async def on_change(ls: RflintServer, params: types.DidChangeTextDocumentParams) -> None:
+    uri = params.text_document.uri
+    previous = ls.pending.pop(uri, None)
+    if previous:
+        previous.cancel()
+
+    async def later() -> None:
+        await asyncio.sleep(DEBOUNCE_SECONDS)
+        ls.pending.pop(uri, None)
+        ls.publish(uri)
+
+    ls.pending[uri] = asyncio.ensure_future(later())
+
+
+@server.feature(types.TEXT_DOCUMENT_DID_CLOSE)
+def on_close(ls: RflintServer, params: types.DidCloseTextDocumentParams) -> None:
+    pending = ls.pending.pop(params.text_document.uri, None)
+    if pending:
+        pending.cancel()  # a late publish would bring back diagnostics for a closed file
+    ls.text_document_publish_diagnostics(types.PublishDiagnosticsParams(uri=params.text_document.uri, diagnostics=[]))
+
+
+def main() -> None:
+    server.start_io()
+
+
+if __name__ == "__main__":
+    main()

robotframework_lint/lsp_navigation.py

@@ -0,0 +1,101 @@
+"""LSP handlers for document symbols, definition, references and hover."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from urllib.parse import urlparse
+from urllib.request import url2pathname
+
+from lsprotocol import types
+
+from .navigation import Location, WorkspaceIndex, document_symbols
+
+# A huge checkout must not stall startup; files past the cap index when opened.
+MAX_FILES = 2000
+SKIP_DIRS = {".git", ".venv", "venv", "node_modules", "__pycache__", "results"}
+SUFFIXES = {".robot", ".resource"}
+# A generated or binary file posing as .robot must not fill memory; open files still lint.
+MAX_BYTES = 1_000_000
+SYMBOL_KIND = {"test": types.SymbolKind.Method, "keyword": types.SymbolKind.Function,
+               "variable": types.SymbolKind.Variable}
+
+
+def _robot_files(root: Path):
+    """Prunes skipped dirs before descending and never follows links out of the tree."""
+    stack = [root]
+    while stack:
+        try:
+            entries = list(os.scandir(stack.pop()))
+        except OSError:
+            continue
+        for entry in entries:
+            if entry.is_symlink():
+                continue
+            if entry.is_dir() and entry.name not in SKIP_DIRS:
+                stack.append(Path(entry.path))
+            elif entry.is_file() and Path(entry.name).suffix in SUFFIXES and entry.stat().st_size <= MAX_BYTES:
+                yield Path(entry.path)
+
+
+def scan_workspace(index: WorkspaceIndex, root_uri: str | None) -> None:
+    if not root_uri or not root_uri.startswith("file:"):
+        return
+    root = Path(url2pathname(urlparse(root_uri).path))
+    for count, path in enumerate(_robot_files(root)):
+        if count >= MAX_FILES:
+            return
+        try:
+            index.update(path.as_uri(), path.read_text(encoding="utf-8", errors="replace"))
+        except Exception:  # one unparsable file must not stop the scan
+            continue
+
+
+def _range(line: int, start: int, end: int) -> types.Range:
+    return types.Range(types.Position(line, start), types.Position(line, end))
+
+
+def _location(ls, loc: Location) -> types.Location:
+    """Index columns are code points; the client counts in the negotiated encoding."""
+    codec = ls.workspace.position_codec
+    client_range = codec.range_to_client_units(ls.index.lines(loc.uri), _range(loc.line, loc.start, loc.end))
+    return types.Location(uri=loc.uri, range=client_range)
+
+
+def _at(ls, params) -> tuple[str, int, int]:
+    uri = params.text_document.uri
+    position = ls.workspace.position_codec.position_from_client_units(ls.index.lines(uri), params.position)
+    return uri, position.line, position.character
+
+
+def register(server) -> None:
+    @server.feature(types.TEXT_DOCUMENT_DOCUMENT_SYMBOL)
+    def on_symbols(ls, params: types.DocumentSymbolParams):
+        doc = ls.workspace.get_text_document(params.text_document.uri)
+        suffix = ".resource" if doc.uri.endswith(".resource") else ".robot"
+        return [types.DocumentSymbol(name=s.name, kind=SYMBOL_KIND[s.kind],
+                                     range=types.Range(types.Position(s.line, 0), types.Position(s.end_line, 0)),
+                                     selection_range=_range(s.line, 0, 0))
+                for s in document_symbols(doc.source, suffix)]
+
+    @server.feature(types.TEXT_DOCUMENT_DEFINITION)
+    def on_definition(ls, params: types.DefinitionParams):
+        found = ls.index.definition(*_at(ls, params))
+        return _location(ls, found) if found else None
+
+    @server.feature(types.TEXT_DOCUMENT_REFERENCES)
+    def on_references(ls, params: types.ReferenceParams):
+        found = ls.index.references(*_at(ls, params))
+        return [_location(ls, loc) for loc in found]
+
+    @server.feature(types.WORKSPACE_SYMBOL)
+    def on_workspace_symbol(ls, params: types.WorkspaceSymbolParams):
+        return [types.WorkspaceSymbol(name=f.name, kind=types.SymbolKind.Function, location=_location(ls, f.location))
+                for f in ls.index.find(params.query)]
+
+    @server.feature(types.TEXT_DOCUMENT_HOVER)
+    def on_hover(ls, params: types.HoverParams):
+        text = ls.index.hover(*_at(ls, params))
+        if text is None:
+            return None
+        return types.Hover(contents=types.MarkupContent(kind=types.MarkupKind.PlainText, value=text))

robotframework_lint/navigation.py

@@ -0,0 +1,188 @@
+"""Workspace index for document symbols, definition, references and hover.
+
+Pure functions over buffer text so the LSP layer stays thin. Positions are
+0-based lines and columns, as LSP sends them.
+"""
+
+from __future__ import annotations
+
+import io
+from dataclasses import dataclass, field
+
+from robot.api import Token, get_model, get_resource_model
+from robot.parsing.model.blocks import Keyword, TestCase
+from robot.parsing.model.statements import Arguments, Documentation, Variable
+from robot.utils import normalize
+
+MAX_HOVER = 200
+MAX_RESULTS = 50
+# Fixture settings name a keyword in a NAME token instead of a KEYWORD token.
+FIXTURES = {Token.SETUP, Token.TEARDOWN, Token.SUITE_SETUP, Token.SUITE_TEARDOWN,
+            Token.TEST_SETUP, Token.TEST_TEARDOWN}
+
+
+@dataclass(frozen=True)
+class Symbol:
+    name: str
+    kind: str
+    line: int
+    end_line: int
+
+
+@dataclass(frozen=True)
+class Location:
+    uri: str
+    line: int
+    start: int
+    end: int
+
+
+@dataclass(frozen=True)
+class Found:
+    name: str
+    location: Location
+
+
+@dataclass
+class _Definition:
+    name: str
+    location: Location
+    signature: str
+    doc: str
+
+
+def _key(name: str) -> str:
+    return normalize(name, ignore="_")
+
+
+def _parse(text: str, suffix: str):
+    parser = get_resource_model if suffix == ".resource" else get_model
+    return parser(io.StringIO(text))
+
+
+def _walk(node):
+    yield node
+    for child in getattr(node, "body", []) + getattr(node, "sections", []):
+        yield from _walk(child)
+
+
+def document_symbols(text: str, suffix: str) -> list[Symbol]:
+    """Tests, keywords and variables in file order."""
+    symbols = []
+    for node in _walk(_parse(text, suffix)):
+        if isinstance(node, (TestCase, Keyword)):
+            kind = "test" if isinstance(node, TestCase) else "keyword"
+            symbols.append(Symbol(node.name, kind, node.lineno - 1, node.end_lineno - 1))
+        elif isinstance(node, Variable) and node.name:
+            symbols.append(Symbol(node.name, "variable", node.lineno - 1, node.lineno - 1))
+    return symbols[:MAX_RESULTS]
+
+
+def _calls(model) -> list[Token]:
+    """Every token that names a called keyword."""
+    calls = []
+    for node in _walk(model):
+        if getattr(node, "type", None) in FIXTURES:
+            calls.extend(t for t in node.tokens if t.type == Token.NAME and t.value.upper() != "NONE")
+        elif hasattr(node, "tokens"):
+            calls.extend(t for t in node.tokens if t.type == Token.KEYWORD)
+    return calls
+
+
+def _definitions(uri: str, model) -> dict[str, _Definition]:
+    found = {}
+    for node in _walk(model):
+        if isinstance(node, Keyword):
+            name = node.header.get_token(Token.KEYWORD_NAME)
+            loc = Location(uri, name.lineno - 1, name.col_offset, name.end_col_offset)
+            found[_key(node.name)] = _Definition(node.name, loc, _signature(node), _first_doc_line(node))
+    return found
+
+
+def _signature(node: Keyword) -> str:
+    args = next((s.values for s in node.body if isinstance(s, Arguments)), ())
+    return f"{node.name}({', '.join(args)})"
+
+
+def _first_doc_line(node: Keyword) -> str:
+    doc = next((s.value for s in node.body if isinstance(s, Documentation)), "")
+    return doc.split("\n", 1)[0]
+
+
+@dataclass
+class _FileIndex:
+    calls: list[Location] = field(default_factory=list)
+    names: list[str] = field(default_factory=list)
+    definitions: dict[str, _Definition] = field(default_factory=dict)
+    lines: list[str] = field(default_factory=list)
+
+
+class WorkspaceIndex:
+    """Keyword definitions and calls across every indexed file."""
+
+    def __init__(self) -> None:
+        self.files: dict[str, _FileIndex] = {}
+
+    def update(self, uri: str, text: str) -> None:
+        model = _parse(text, ".resource" if uri.endswith(".resource") else ".robot")
+        tokens = _calls(model)
+        self.files[uri] = _FileIndex(
+            [Location(uri, t.lineno - 1, t.col_offset, t.end_col_offset) for t in tokens],
+            [_key(t.value) for t in tokens],
+            _definitions(uri, model),
+            text.splitlines(keepends=True),
+        )
+
+    def lines(self, uri: str) -> list[str]:
+        """Source lines, so the LSP layer can convert columns to the client's encoding."""
+        index = self.files.get(uri)
+        return index.lines if index else []
+
+    def _name_at(self, uri: str, line: int, character: int) -> str | None:
+        index = self.files.get(uri)
+        if index is None:
+            return None
+        for loc, name in zip(index.calls, index.names):
+            if loc.line == line and loc.start <= character <= loc.end:
+                return name
+        return next((k for k, d in index.definitions.items()
+                     if d.location.line == line and d.location.start <= character <= d.location.end), None)
+
+    def _lookup(self, uri: str, name: str) -> _Definition | None:
+        local = self.files[uri].definitions.get(name)
+        if local:
+            return local
+        return next((f.definitions[name] for f in self.files.values() if name in f.definitions), None)
+
+    def _resolve(self, uri: str, line: int, character: int) -> _Definition | None:
+        name = self._name_at(uri, line, character)
+        return self._lookup(uri, name) if name else None
+
+    def definition(self, uri: str, line: int, character: int) -> Location | None:
+        found = self._resolve(uri, line, character)
+        return found.location if found else None
+
+    def references(self, uri: str, line: int, character: int) -> list[Location]:
+        name = self._name_at(uri, line, character)
+        if name is None:
+            return []
+        found = [loc for f in self.files.values() for loc, n in zip(f.calls, f.names) if n == name]
+        return found[:MAX_RESULTS]
+
+    def find(self, query: str) -> list[Found]:
+        """Keywords whose name matches the query: exact, then prefix, then substring."""
+        wanted = _key(query)
+        ranked = []
+        for f in self.files.values():
+            for key, d in f.definitions.items():
+                if wanted in key:
+                    rank = 0 if key == wanted else 1 if key.startswith(wanted) else 2
+                    ranked.append((rank, d.name, Found(d.name, d.location)))
+        return [found for _, _, found in sorted(ranked, key=lambda r: r[:2])][:MAX_RESULTS]
+
+    def hover(self, uri: str, line: int, character: int) -> str | None:
+        found = self._resolve(uri, line, character)
+        if found is None:
+            return None
+        text = f"{found.signature}\n{found.doc}" if found.doc else found.signature
+        return text[:MAX_HOVER]

robotframework_lint/rules/__init__.py

@@ -0,0 +1 @@
+"""Custom Robocop rules for Robot Framework 7.5."""

robotframework_lint/rules/arguments.py

@@ -0,0 +1,78 @@
+"""Rules for keyword call arguments."""
+
+import inspect
+
+from robot.libraries.BuiltIn import BuiltIn
+from robot.libraries.Collections import Collections
+from robot.utils import normalize
+
+from robocop.linter.rules import Rule, RuleSeverity, VisitorChecker
+
+DEPRECATED_NAMES = ("list_", "time_")
+
+
+def keywords_with_deprecated_args() -> dict[str, frozenset[str]]:
+    """Map normalized keyword name to its deprecated argument names, read from RF."""
+    found = {}
+    for library in (BuiltIn, Collections):
+        for attr, method in inspect.getmembers(library, inspect.isfunction):
+            if attr.startswith("_"):
+                continue
+            params = set(inspect.signature(method).parameters) & set(DEPRECATED_NAMES)
+            if not params:
+                continue
+            frozen = frozenset(params)
+            found[normalize(attr, ignore="_")] = frozen
+            found[normalize(f"{library.__name__}.{attr}", ignore="_")] = frozen
+    return found
+
+
+KEYWORDS = keywords_with_deprecated_args()
+
+
+class DeprecatedArgumentNameRule(Rule):
+    """
+    Deprecated argument name in a Collections or BuiltIn keyword call.
+
+    The rf-7.5 release notes, section "Deprecated features", say:
+    "`list_` argument used in Collections and `time_` argument used in Builtin
+    have been deprecated (`#5763`_). They will be renamed to `list` and `time`,
+    respectively, in Robot Framework 8.0. This only affects usages like
+    `time_=1 second`, not usages where values are passed positionally like
+    `1 second`." Keyword signatures come from Robot Framework's own library
+    classes. Source:
+    https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-7.5.rst
+
+    Incorrect code example:
+
+        Sleep    time_=1 second
+
+    Correct code:
+
+        Sleep    1 second
+    """
+
+    name = "deprecated-argument-name"
+    rule_id = "RFL006"
+    message = "'{arg}' is deprecated since RF 7.5; pass it positionally"
+    severity = RuleSeverity.WARNING
+    added_in_version = "0.1.0"
+
+
+class ArgumentNameChecker(VisitorChecker):
+    deprecated_argument_name: DeprecatedArgumentNameRule
+
+    def visit_KeywordCall(self, node):  # noqa: N802 - robot visitor naming
+        names = KEYWORDS.get(normalize(node.keyword or "", ignore="_"))
+        if not names:
+            return
+        for token in node.get_tokens("ARGUMENT"):
+            arg = token.value.split("=", 1)[0]
+            if "=" in token.value and arg in names:
+                self.report(
+                    self.deprecated_argument_name,
+                    arg=arg,
+                    lineno=token.lineno,
+                    col=token.col_offset + 1,
+                    end_col=token.end_col_offset + 1,
+                )

robotframework_lint/rules/documentation.py

@@ -0,0 +1,78 @@
+"""Rules for keyword documentation."""
+
+from robot.running import docstringparser
+
+from robocop.linter.rules import Rule, RuleSeverity, VisitorChecker
+
+
+class _WarningRecorder:
+    def __init__(self):
+        self.warnings = []
+
+    def warn(self, message):
+        self.warnings.append(message)
+
+
+def has_tags_without_empty_row(doc: str) -> bool:
+    """Ask Robot Framework's own docstring parser whether it warns about Tags:."""
+    recorder = _WarningRecorder()
+    original = docstringparser.LOGGER
+    docstringparser.LOGGER = recorder
+    try:
+        docstringparser.parse_docstring(doc)
+    finally:
+        docstringparser.LOGGER = original
+    return any("before 'Tags:'" in message for message in recorder.warnings)
+
+
+class DocTagsWithoutEmptyRowRule(Rule):
+    """
+    Tags header in documentation without an empty row before it.
+
+    The rf-7.5 release notes, section "Deprecated features", say:
+    "When specifying tags as part of documentation, omitting an empty row
+    before the `Tags:` header is deprecated (`#5707`_)." Detection uses
+    Robot Framework's own ``parse_docstring``. Source:
+    https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-7.5.rst
+
+    Incorrect code example:
+
+        [Documentation]    Does a thing.
+        ...    Tags: smoke
+
+    Correct code:
+
+        [Documentation]    Does a thing.
+        ...
+        ...    Tags: smoke
+    """
+
+    name = "doc-tags-without-empty-row"
+    rule_id = "RFL005"
+    message = "No empty row before 'Tags:' is deprecated since RF 7.5"
+    severity = RuleSeverity.WARNING
+    added_in_version = "0.1.0"
+
+
+class DocTagsChecker(VisitorChecker):
+    doc_tags_without_empty_row: DocTagsWithoutEmptyRowRule
+
+    def visit_Keyword(self, node):  # noqa: N802 - robot visitor naming
+        for statement in node.body:
+            if getattr(statement, "type", None) == "DOCUMENTATION":
+                self.check_documentation(statement)
+
+    def check_documentation(self, node):
+        if not has_tags_without_empty_row(node.value):
+            return
+        tokens = node.get_tokens("ARGUMENT")
+        target = next(
+            (t for t in reversed(tokens) if t.value.strip().lower().startswith("tags:")),
+            node.data_tokens[0],
+        )
+        self.report(
+            self.doc_tags_without_empty_row,
+            lineno=target.lineno,
+            col=target.col_offset + 1,
+            end_col=target.end_col_offset + 1,
+        )

robotframework_lint/rules/for_loops.py

@@ -0,0 +1,55 @@
+"""Rules for FOR loops."""
+
+from robot.api import Token
+
+from robocop.linter.rules import Rule, RuleSeverity, VisitorChecker
+
+RF_70_NOTES = (
+    "https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-7.0.rst"
+)
+
+
+class ForInZipWithoutModeRule(Rule):
+    """
+    FOR IN ZIP without an explicit ``mode``.
+
+    Robot Framework 7.0 added ``mode=STRICT``, ``mode=SHORTEST`` and
+    ``mode=LONGEST`` to FOR IN ZIP. Lists of different lengths are planned to
+    fail in a later release, so the release notes advise setting ``mode``
+    explicitly. Source: rf-7.0 release notes,
+    https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-7.0.rst
+
+    Incorrect code example:
+
+        FOR    ${a}    ${b}    IN ZIP    ${LIST_A}    ${LIST_B}
+            Log    ${a} ${b}
+        END
+
+    Correct code:
+
+        FOR    ${a}    ${b}    IN ZIP    ${LIST_A}    ${LIST_B}    mode=STRICT
+            Log    ${a} ${b}
+        END
+    """
+
+    name = "for-in-zip-without-mode"
+    rule_id = "RFL001"
+    message = "FOR IN ZIP without mode=; set STRICT, SHORTEST or LONGEST"
+    severity = RuleSeverity.WARNING
+    added_in_version = "0.1.0"
+
+
+class ForLoopChecker(VisitorChecker):
+    for_in_zip_without_mode: ForInZipWithoutModeRule
+
+    def visit_For(self, node):  # noqa: N802 - robot visitor naming
+        if node.flavor == "IN ZIP" and not node.mode:
+            header = node.header
+            separator = header.get_token(Token.FOR_SEPARATOR)
+            self.report(
+                self.for_in_zip_without_mode,
+                node=header,
+                col=separator.col_offset + 1,
+                end_col=separator.end_col_offset + 1,
+            )
+        self.generic_visit(node)

robotframework_lint/rules/imports.py

@@ -0,0 +1,55 @@
+"""Rules for library imports."""
+
+from robocop.linter.rules import Rule, RuleSeverity, VisitorChecker
+
+RF_75_NOTES = (
+    "https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-7.5.rst"
+)
+
+# Standard libraries deprecated in RF 7.5, mapped to the replacement named there.
+DEPRECATED_LIBRARIES = {"Telnet": "TelnetLibrary"}
+
+
+class DeprecatedStandardLibraryRule(Rule):
+    """
+    Import of a standard library deprecated in Robot Framework 7.5.
+
+    The rf-7.5 release notes, section "Deprecated features", say: "The Telnet
+    library has been deprecated (#5786). The new external TelnetLibrary
+    should be used instead." Telnet is the only standard library that section
+    deprecates. Source: rf-7.5 release notes,
+    https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-7.5.rst
+
+    Incorrect code example:
+
+        *** Settings ***
+        Library    Telnet
+
+    Correct code:
+
+        *** Settings ***
+        Library    TelnetLibrary
+    """
+
+    name = "deprecated-standard-library"
+    rule_id = "RFL002"
+    message = "{name} is deprecated since RF 7.5; use {replacement}"
+    severity = RuleSeverity.WARNING
+    added_in_version = "0.1.0"
+
+
+class ImportChecker(VisitorChecker):
+    deprecated_standard_library: DeprecatedStandardLibraryRule
+
+    def visit_LibraryImport(self, node):  # noqa: N802 - robot visitor naming
+        replacement = DEPRECATED_LIBRARIES.get(node.name)
+        if replacement:
+            token = node.get_token("NAME")
+            self.report(
+                self.deprecated_standard_library,
+                name=node.name,
+                replacement=replacement,
+                node=node,
+                col=token.col_offset + 1,
+                end_col=token.end_col_offset + 1,
+            )

robotframework_lint/rules/tag_patterns.py

@@ -0,0 +1,88 @@
+"""Rules for tag patterns."""
+
+import re
+import warnings
+
+from robot.api import Token
+from robot.model.tags import TagPatterns
+
+from robocop.linter.rules import Rule, RuleSeverity, VisitorChecker
+
+# Operator named in the Robot Framework 7.5 TagPatterns deprecation warning.
+WARNED_OPERATOR = re.compile(r"'(AND|OR|NOT)' is currently considered")
+# Keywords whose arguments are tag patterns.
+PATTERN_KEYWORDS = {"removetags"}
+
+
+def deprecated_form(pattern: str) -> str | None:
+    if "&" in pattern:
+        return "&"
+    with warnings.catch_warnings(record=True) as caught:
+        warnings.simplefilter("always")
+        TagPatterns([pattern])
+    for warning in caught:
+        match = WARNED_OPERATOR.search(str(warning.message))
+        if match:
+            return match.group(1)
+    return None
+
+
+class DeprecatedTagPatternRule(Rule):
+    """
+    Tag pattern form deprecated in Robot Framework 7.5.
+
+    The rf-7.5 release notes, section "Deprecated features", say:
+    "Boolean operators used with tag patterns need to be separated from tags
+    more clearly and usages like `XORY` are deprecated (`#5657`_). Operators
+    can be surrounded with spaces like `X OR Y` or tags can be specified in
+    lower case like `xORy`." and "Using `&` as a Boolean operator with tag
+    patterns is deprecated and `AND` should be used instead (`#5661`_)."
+    Checked: ``-tag`` removals in Test Tags, Keyword Tags, Force Tags,
+    Default Tags and [Tags], and Remove Tags arguments. Source:
+    https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-7.5.rst
+
+    Incorrect code example:
+
+        [Tags]    -smoke&slow
+        Remove Tags    SMOKEORSLOW
+
+    Correct code:
+
+        [Tags]    -smoke AND slow
+        Remove Tags    SMOKE OR SLOW
+    """
+
+    name = "deprecated-tag-pattern"
+    rule_id = "RFL003"
+    message = "'{operator}' tag pattern is deprecated since RF 7.5; use spaced AND/OR/NOT"
+    severity = RuleSeverity.WARNING
+    added_in_version = "0.1.0"
+
+
+class TagPatternChecker(VisitorChecker):
+    deprecated_tag_pattern: DeprecatedTagPatternRule
+
+    def check_token(self, token, pattern):
+        operator = deprecated_form(pattern)
+        if operator:
+            self.report(
+                self.deprecated_tag_pattern,
+                operator=operator,
+                lineno=token.lineno,
+                col=token.col_offset + 1,
+                end_col=token.end_col_offset + 1,
+            )
+
+    def check_tag_removals(self, node):
+        for token in node.get_tokens(Token.ARGUMENT):
+            if token.value.startswith("-"):
+                self.check_token(token, token.value[1:])
+
+    visit_TestTags = visit_KeywordTags = visit_ForceTags = check_tag_removals  # noqa: N815
+    visit_DefaultTags = visit_Tags = check_tag_removals  # noqa: N815
+
+    def visit_KeywordCall(self, node):  # noqa: N802 - robot visitor naming
+        name = (node.keyword or "").split(".")[-1].replace(" ", "").replace("_", "").lower()
+        if name in PATTERN_KEYWORDS:
+            for token in node.get_tokens(Token.ARGUMENT):
+                self.check_token(token, token.value)

robotframework_lint/rules/translations.py

@@ -0,0 +1,75 @@
+"""Rules for localized section headers and settings."""
+
+from robot.api import Token
+from robot.conf.languages import Language
+
+from robocop.linter.rules import Rule, RuleSeverity, VisitorChecker
+
+MARKER_TYPES = frozenset(Token.HEADER_TOKENS) | frozenset(Token.SETTING_TOKENS)
+
+
+def normalize(marker: str) -> str:
+    return " ".join(marker.strip("*[] ").split()).title()
+
+
+def deprecated_markers() -> dict[str, tuple[str, str]]:
+    """Map old term to (new term, version) from Robot Framework's own languages."""
+    found = {}
+    for language in Language.__subclasses__():
+        for old, (new, version) in language.deprecations.items():
+            found[normalize(old)] = (new, version or "")
+    return found
+
+
+DEPRECATED = deprecated_markers()
+
+
+class DeprecatedTranslationRule(Rule):
+    """
+    Translation deprecated in Robot Framework 7.5.
+
+    The rf-7.5 release notes, section "Deprecated features", say:
+    "French "Test Cases" translation "Unites de test" has been deprecated in
+    favor of "Cas de test" (`#5510`_)." and "Finnish "Tags" translation
+    "Tagit" has been deprecated and "Tunnisteet" should be used instead
+    (`#5726`_)." (the French term carries an accented e). Terms come from
+    Robot Framework's own ``Language.deprecations``. A term is only reported
+    when Robot Framework parsed it as a header or setting, so only files
+    whose language is set to French or Finnish. Source:
+    https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-7.5.rst
+
+    Incorrect code example (``language: fi``):
+
+        [Tagit]    smoke
+
+    Correct code:
+
+        [Tunnisteet]    smoke
+    """
+
+    name = "deprecated-translation"
+    rule_id = "RFL004"
+    message = "'{old}' is deprecated since RF {version}; use '{new}'"
+    severity = RuleSeverity.WARNING
+    added_in_version = "0.1.0"
+
+
+class TranslationChecker(VisitorChecker):
+    deprecated_translation: DeprecatedTranslationRule
+
+    def visit_Statement(self, node):  # noqa: N802 - robot visitor naming
+        token = node.data_tokens[0] if node.data_tokens else None
+        if token is None or token.type not in MARKER_TYPES:
+            return
+        old = normalize(token.value)
+        if old in DEPRECATED:
+            new, version = DEPRECATED[old]
+            self.report(
+                self.deprecated_translation,
+                old=" ".join(token.value.strip("*[] ").split()),
+                new=new,
+                version=version,
+                lineno=token.lineno,
+                col=token.col_offset + 1,
+                end_col=token.end_col_offset + 1,
+            )

robotframework_lint_lsp-1.0.0.dist-info/METADATA

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: robotframework-lint-lsp
+Version: 1.0.0
+Summary: Robot Framework lint for coding agents: robocop rules, an LSP server and an auto-fix hook
+Author: Abdulwahab Isam
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ai94iq/robotframework-lint-lsp
+Project-URL: Documentation, https://github.com/ai94iq/robotframework-lint-lsp/blob/main/docs/agents.md
+Project-URL: Issues, https://github.com/ai94iq/robotframework-lint-lsp/issues
+Keywords: robotframework,robocop,lint,lsp,claude-code
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: Robot Framework
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: robotframework==7.5.1
+Requires-Dist: robotframework-robocop==9.4.0
+Requires-Dist: pygls==2.1.1
+Provides-Extra: dev
+Requires-Dist: pytest==9.2.0; extra == "dev"
+Dynamic: license-file
+
+# robotframework-lint-lsp
+
+Extra [Robocop](https://github.com/MarketSquare/robotframework-robocop) rules
+for Robot Framework 7.5. When Robocop and the Robot Framework docs disagree,
+these rules follow Robot Framework.
+
+## Install
+
+```bash
+python -m venv .venv
+.venv/Scripts/python -m pip install -e ".[dev]"   # Windows
+.venv/bin/python -m pip install -e ".[dev]"       # Linux, macOS
+```
+
+Pinned: robotframework 7.5.1, robotframework-robocop 9.4.0, pytest 9.2.0.
+
+## Run
+
+```bash
+robocop check --custom-rules robotframework_lint path/to/tests
+```
+
+The installed package registers the `robotframework_lint` Robocop plugin, so
+the rules load by plugin name, no path needed. Run only these rules with
+`--select RFL001 --select RFL002`.
+
+## Rules
+
+| ID | Name | Source |
+|---|---|---|
+| RFL001 | for-in-zip-without-mode | [RF 7.0 release notes](https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-7.0.rst) |
+| RFL002 | deprecated-standard-library (Telnet) | [RF 7.5 release notes](https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-7.5.rst) |
+| RFL003 | deprecated-tag-pattern (`XORY`, `&`) | [RF 7.5 release notes](https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-7.5.rst) |
+| RFL004 | deprecated-translation (French `Unités de test`, Finnish `Tagit`) | [RF 7.5 release notes](https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-7.5.rst) |
+| RFL005 | doc-tags-without-empty-row (`Tags:` in keyword docs) | [RF 7.5 release notes](https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-7.5.rst) |
+| RFL006 | deprecated-argument-name (`list_=`, `time_=`) | [RF 7.5 release notes](https://github.com/robotframework/robotframework/blob/master/doc/releasenotes/rf-7.5.rst) |
+
+RFL003 asks Robot Framework's own `TagPatterns` whether a pattern is deprecated,
+so it reports exactly what RF 7.5.1 warns about. That includes all-caps tags
+holding an operator word, such as `-DONOTX` or `-ORANGE`: RF reads them as
+`DO NOT X` and `OR ANGE`. Write such tags in lower case.
+
+RFL004 reads the deprecated terms from Robot Framework's own language
+definitions. It reports a term only when RF parsed it as a header or setting,
+that is, when the file's language is French or Finnish (`language: fr` or
+`language: fi` in the file, or `--language`).
+
+## LSP server (Claude Code and other agents)
+
+`robotframework-lint-lsp` is a stdio language server. It lints the open
+buffer in process with the robocop defaults plus these rules, on open, save
+and change (debounced 0.4 s). Output is kept small for AI agents:
+
+- one line per finding: `RULEID message`, at most 120 characters
+- at most 20 findings per file (`maxDiagnostics`), then one `overflow` line
+  that says how many more were cut
+- at most 50 symbols or references per answer
+- warnings and errors only by default (`minSeverity`: info, warning, error)
+- identical findings on one line reported once; no related information
+
+- a finding robocop can fix ends with `fix all: <command>`; fixable Info
+  rules are raised to warning
+
+Settings go in `initializationOptions`: `maxDiagnostics`, `minSeverity`,
+`select`, `ignore`, `groupFindings` (default off). For Claude Code, copy
+`.lsp.json` from this repo into your plugin; it maps `.robot` and
+`.resource` to `robotframework`.
+
+The plugin also ships a PostToolUse hook, `robotframework-lint-autofix`
+(`hooks/hooks.json`): after each Edit or Write of a `.robot` or `.resource`
+file it applies robocop's safe fixes, so the agent only sees what is left.
+
+Setup for Claude Code, opencode, Crush, Codex and GLM:
+[docs/agents.md](docs/agents.md). Measured results (cost, turns and issues
+left, with and without the LSP, per model):
+[docs/benchmarks.html](docs/benchmarks.html)
+and [docs/benchmarks](docs/benchmarks).
+
+The server also answers code navigation for user keywords:
+
+- document symbols: tests, keywords and variables in a file
+- definition and references: matched the way Robot matches names, so
+  `say_hello` finds `Say Hello`
+- workspace symbols: find a keyword by name, exact matches first, then
+  prefix, then substring
+- hover: the keyword signature and the first doc line, at most 200 characters
+
+On start it indexes every `.robot` and `.resource` file under the workspace
+root, up to 2000 files. It skips `.git`, `.venv`, `node_modules` and
+`results`. Open files are indexed again on every change. Library keywords
+such as `Log` and keywords with embedded arguments aren't indexed.
+
+## Tests
+
+```bash
+python -m pytest
+```
+
+## License
+
+MIT

robotframework_lint_lsp-1.0.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+robotframework_lint/__init__.py,sha256=TKAkEyJwR1cQHKseS2EUxluKGzs6R0axCN9MRHGDcC8,68
+robotframework_lint/autofix.py,sha256=W53eP3AIYfqiDRevZNZwscet10pg5LEDa68YPlqSg80,2709
+robotframework_lint/hints.py,sha256=MFVDhTTMB3ReMP0s5yMmo8efCbT6ETxKA7OiXfcH2bY,1090
+robotframework_lint/lsp.py,sha256=pfZLH8so-Igqpgc6ZTL9hJkykqZYAtTHvqZ8MEnhkos,9618
+robotframework_lint/lsp_navigation.py,sha256=0bmBo_S8tjRstSk_Fot0tP_8Q5wg68k0P9KNNY2bNtM,4285
+robotframework_lint/navigation.py,sha256=FV96jr8ZOkSXKt7n4vJcageBMXU37pY-YdXuGkheZhw,6601
+robotframework_lint/rules/__init__.py,sha256=Kuwq_plVqzz0_HDw_4PJitWuAn5twXc2XJNo4oaKiP4,52
+robotframework_lint/rules/arguments.py,sha256=SA2OnRTy9qGZwstgN5ZuZ23ow6YGZEv0Zs8XYYspXuU,2733
+robotframework_lint/rules/documentation.py,sha256=7qZM91lfvlxtL0X22IL0nfugeBQiMdql5Gfl8bbcpq4,2452
+robotframework_lint/rules/for_loops.py,sha256=2Y02bpJ1SE0aGVEe7OznpKVxSnLKW5uWesyFerqx7Qw,1735
+robotframework_lint/rules/imports.py,sha256=QjJhUzpIYNNv445mxNvoCBwnZ5UGChOYbFSTZSAp9ww,1794
+robotframework_lint/rules/tag_patterns.py,sha256=ORDKgTVo9JFHRINSFZHmRetRattGWPk-E6bsl9rr1wQ,3121
+robotframework_lint/rules/translations.py,sha256=_MbxBK-ZnNWPya6f3SCew5UXgKx93ApIqgVTuSJffEc,2606
+robotframework_lint_lsp-1.0.0.dist-info/licenses/LICENSE,sha256=Nq1bZgAWPJZM65BczwEj9JEP9_rC1-5ITtAV57GgubI,1072
+robotframework_lint_lsp-1.0.0.dist-info/METADATA,sha256=3hFIaRmtDH8fRGFXZ1IQERUgio0FTIakWNbbD3BjU2c,5690
+robotframework_lint_lsp-1.0.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+robotframework_lint_lsp-1.0.0.dist-info/entry_points.txt,sha256=qojLs7x0AxD16V1ZgPrzMQMQZaCep8JDKM6nyA3Lil8,203
+robotframework_lint_lsp-1.0.0.dist-info/top_level.txt,sha256=Hui6NmOdNR_OIDQKL2CCiRTVlA4q76w-AjK7P5-B0tQ,20
+robotframework_lint_lsp-1.0.0.dist-info/RECORD,,

robotframework_lint_lsp-1.0.0.dist-info/WHEEL

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

robotframework_lint_lsp-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,6 @@
+[console_scripts]
+robotframework-lint-autofix = robotframework_lint.autofix:main
+robotframework-lint-lsp = robotframework_lint.lsp:main
+
+[robocop.plugins]
+robotframework_lint = robotframework_lint.rules

robotframework_lint_lsp-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Abdulwahab Isam
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

robotframework_lint_lsp-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+robotframework_lint