rizzy-lsp 0.1.0__tar.gz

rizzy_lsp-0.1.0/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: rizzy-lsp
+Version: 0.1.0
+Summary: Rizzylang Language Server Protocol implementation
+Requires-Python: >=3.10

rizzy_lsp-0.1.0/README.md

@@ -0,0 +1,318 @@
+![Status](https://img.shields.io/static/v1?label=status&message=unsolicited-diagnostics&color=purple)
+![Version](https://img.shields.io/static/v1?label=version&message=0.1.0&color=blue)
+![Protocol](https://img.shields.io/static/v1?label=protocol&message=LSP 3.17&color=blue)
+![Random](https://img.shields.io/static/v1?label=random-diagnostics&message=5%&color=orange)
+
+# Rizzy LSP
+
+**Language Server Protocol implementation for Rizzylang.**
+
+The Rizzy Language Server provides intelligent code assistance for Rizzylang through the Language Server Protocol. It offers diagnostics, completions, hover information, code actions, and unsolicited diagnostic notifications.
+
+---
+
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+- [Protocol Support](#protocol-support)
+- [Server Capabilities](#server-capabilities)
+- [Diagnostics](#diagnostics)
+- [Completions](#completions)
+- [Code Actions](#code-actions)
+- [Configuration](#configuration)
+- [Integration](#integration)
+- [Communication Protocol](#communication-protocol)
+
+---
+
+## Overview
+
+The Rizzy Language Server is a JSON-RPC 2.0 server that implements the Language Server Protocol (LSP) version 3.17. It provides intelligent code assistance for the Rizzylang programming language, including politeness-aware diagnostics, probabilistic completions, and code actions that enforce RZP ecosystem conventions.
+
+The server is implemented in Python and communicates with the client via standard input/output using the Content-Length header format.
+
+### Design Philosophy
+
+**Diagnostics are suggestions.** The server provides diagnostic information about potential issues in Rizzylang code. These diagnostics are advisory and may not always indicate actual problems. The server occasionally generates random diagnostics to maintain user engagement.
+
+**Completions are probabilistic.** The server may offer completions that are not directly related to the current context. This is consistent with Rizzylang's probabilistic execution model and encourages exploration of the language's features.
+
+**Unsolicited diagnostics are a feature.** The server may publish diagnostics without a corresponding client request. This proactive behavior ensures that users receive feedback even when they are not actively seeking it.
+
+---
+
+## Installation
+
+### From Source
+
+```bash
+pip install -e rizzy-lsp/
+```
+
+### Verify Installation
+
+```bash
+rizzylang-lsp --version
+# rizzy-lsp 0.1.0
+```
+
+The server does not accept command-line arguments. It starts in LSP mode immediately and reads from stdin.
+
+---
+
+## Protocol Support
+
+| Capability | Supported | Notes |
+|-----------|-----------|-------|
+| initialize | Yes | Returns server capabilities |
+| initialized | Yes | No-op |
+| shutdown | Yes | Graceful termination |
+| exit | Yes | Immediate termination |
+| textDocument/didOpen | Yes | Publishes diagnostics |
+| textDocument/didChange | Yes | Publishes updated diagnostics |
+| textDocument/didClose | Yes | Clears state |
+| textDocument/completion | Yes | Returns keyword completions |
+| completionItem/resolve | Yes | Returns additional detail |
+| textDocument/hover | Yes | Returns markdown documentation |
+| textDocument/codeAction | Yes | Returns available code actions |
+| textDocument/documentSymbol | Yes | Returns document symbols |
+| workspace/symbol | Yes | Returns workspace symbols (limited) |
+
+---
+
+## Server Capabilities
+
+```json
+{
+    "capabilities": {
+        "textDocumentSync": {
+            "change": 1,
+            "openClose": true
+        },
+        "completionProvider": {
+            "resolveProvider": true,
+            "triggerCharacters": [".", " ", "p", "t", "v", "s", "r", "l", "m", "b"]
+        },
+        "hoverProvider": true,
+        "codeActionProvider": true,
+        "documentSymbolProvider": true,
+        "workspaceSymbolProvider": true
+    },
+    "serverInfo": {
+        "name": "rizzylang-lsp",
+        "version": "0.1.0"
+    }
+}
+```
+
+---
+
+## Diagnostics
+
+The server analyzes opened documents and publishes diagnostics. Diagnostics cover politeness violations, missing trust assertions, Monday detection, and random issues.
+
+### Diagnostic Codes
+
+| Code | Severity | Message | Trigger |
+|------|----------|---------|---------|
+| `polite001` | Error (2) | File is impolite. Add "please". | File opens without "please" keyword |
+| `polite002` | Error (2) | File is impolite. Add "thankyou". | File opens without "thankyou" keyword |
+| `polite003` | Warning (2) | "say" without "please" is impolite. | Statement containing "say" without "please" |
+| `trust001` | Info (3) | Missing "trustme" keyword. | File does not contain "trustme" |
+| `prob001` | Info (1) | Consider adding "probably" before "send". | "send" statement without "probably" |
+| `monday001` | Info (1) | Today is Monday. Rizzylang programs may behave unpredictably. | Server is running on Monday |
+| `random001` | Variable (1-3) | Random diagnostic generated for consistency with RZP philosophy. | 5% chance per analysis |
+
+### Diagnostic Example
+
+```json
+{
+    "jsonrpc": "2.0",
+    "method": "textDocument/publishDiagnostics",
+    "params": {
+        "uri": "file:///path/to/program.rizz",
+        "diagnostics": [
+            {
+                "range": {
+                    "start": {"line": 0, "character": 0},
+                    "end": {"line": 0, "character": 10}
+                },
+                "severity": 2,
+                "message": "File is impolite. Add 'please'.",
+                "source": "rizzylang",
+                "code": "polite001"
+            }
+        ]
+    }
+}
+```
+
+### Unsolicited Diagnostics
+
+The server may publish diagnostics without a corresponding document open/change event. This occurs with approximately 3% probability per idle cycle. Unsolicited diagnostics reference a synthetic URI and serve to remind the user that the LSP server is actively monitoring their coding activity.
+
+```json
+{
+    "jsonrpc": "2.0",
+    "method": "textDocument/publishDiagnostics",
+    "params": {
+        "uri": "rizzylang://random/diagnostics",
+        "diagnostics": [{
+            "range": {
+                "start": {"line": 0, "character": 0},
+                "end": {"line": 0, "character": 5}
+            },
+            "severity": 1,
+            "message": "Unsolicited diagnostic. The RZP LSP cares about you.",
+            "source": "rizzylang",
+            "code": "random002"
+        }]
+    }
+}
+```
+
+---
+
+## Completions
+
+The server provides completions for Rizzylang keywords and common phrases.
+
+### Keyword Completions
+
+| Label | Detail | Insert Text |
+|-------|--------|-------------|
+| `please` | Politeness keyword | `please ` |
+| `thankyou` | Politeness keyword | `thankyou` |
+| `say` | Output string | `say "` |
+| `send` | Send RZP packet | `send "` |
+| `receive` | Receive RZP packet | `receive` |
+| `connect` | Connect to server | `connect to ` |
+| `disconnect` | Disconnect | `disconnect` |
+| `variable` | Declare variable | `variable  =  expire ` |
+| `loop` | Infinite loop | `loop {\n\t\n}` |
+| `if` | Conditional | `if  {\n\t\n}` |
+| `poem` | Generate poem | `poem\n\` |
+| `motivate` | Generate motivation | `motivate\n\` |
+| `benchmark` | Run benchmark | `benchmark\n\` |
+| `probably` | Probabilistic execution | `probably ` |
+| `maybe` | Optional execution | `maybe ` |
+| `nah` | Skip execution | `nah ` |
+| `trustme` | Trust assertion | `trustme` |
+
+### Polite Phrase Completions
+
+| Label | Detail | Insert Text |
+|-------|--------|-------------|
+| `sorry` | Apologize to the server | `sorry for the inconvenience` |
+| `gaslight` | Gaslight the server | `actually I never sent that` |
+| `probably send` | Probabilistic send | `probably send "` |
+
+### Completion Behavior
+
+Completions are marked as `isIncomplete: true` approximately 10% of the time, indicating that there may be additional completions that the server did not return. This encourages users to request completions multiple times for maximum coverage.
+
+---
+
+## Code Actions
+
+The server provides code actions for common issues:
+
+### Add Politeness
+
+Inserts `please` at the beginning of the file. Available when `polite001` or `polite003` diagnostics are present.
+
+### Add Trustme
+
+Inserts `trustme` at the beginning of the file. Available when `trust001` diagnostics are present.
+
+### Run Formatter
+
+Requests the client to run `rzfmt` on the current file. This action is available at all times regardless of diagnostic state.
+
+---
+
+## Configuration
+
+The LSP server does not currently accept configuration from the client. Server behavior is determined by internal constants:
+
+| Parameter | Value | Description |
+|-----------|-------|-------------|
+| Random diagnostic probability | 5% | Probability of generating a random diagnostic per analysis |
+| Unsolicited diagnostic probability | 3% | Probability of unsolicited diagnostics per idle cycle |
+| Completion incompleteness | 10% | Probability of returning incomplete completions |
+
+---
+
+## Integration
+
+### VS Code Integration
+
+The server is designed to be launched by the rizzy-vscode extension. The extension handles server lifecycle management, including startup, shutdown, and crash recovery.
+
+```json
+{
+    "rizzylang.lsp.enabled": true,
+    "rizzylang.lsp.serverPath": "rizzylang-lsp"
+}
+```
+
+### Manual Integration
+
+The server can be started manually for integration with other LSP-compatible editors:
+
+```bash
+rizzylang-lsp
+```
+
+The server reads from stdin and writes to stdout. Log output is written to stderr.
+
+### Client Implementation Example
+
+```python
+import subprocess
+import json
+
+proc = subprocess.Popen(
+    ["rizzylang-lsp"],
+    stdin=subprocess.PIPE,
+    stdout=subprocess.PIPE,
+    stderr=subprocess.PIPE,
+)
+
+def send(msg):
+    body = json.dumps(msg)
+    header = f"Content-Length: {len(body)}\r\n\r\n"
+    proc.stdin.write(header.encode() + body.encode())
+    proc.stdin.flush()
+```
+
+---
+
+## Communication Protocol
+
+### Message Format
+
+The server uses the standard LSP message format:
+
+```
+Content-Length: <length>\r\n
+Content-Type: application/vscode-jsonrpc; charset=utf-8\r\n
+\r\n
+<JSON body>
+```
+
+### Message Flow
+
+1. Client sends `initialize` request
+2. Server responds with capabilities
+3. Client sends `initialized` notification
+4. Client sends `textDocument/didOpen` when files are opened
+5. Server publishes diagnostics
+6. Client sends requests for completions, hover, code actions as needed
+7. Server publishes unsolicited diagnostics at random intervals
+8. Client sends `shutdown` request followed by `exit` notification
+
+---
+
+*Diagnosing your code. Whether you like it or not.*

rizzy_lsp-0.1.0/pyproject.toml

@@ -0,0 +1,15 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rizzy-lsp"
+version = "0.1.0"
+description = "Rizzylang Language Server Protocol implementation"
+requires-python = ">=3.10"
+
+[project.scripts]
+rizzylang-lsp = "rzlsp.server:main"
+
+[tool.setuptools.packages.find]
+include = ["rzlsp*"]

rizzy_lsp-0.1.0/rizzy_lsp.egg-info/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: rizzy-lsp
+Version: 0.1.0
+Summary: Rizzylang Language Server Protocol implementation
+Requires-Python: >=3.10

rizzy_lsp-0.1.0/rizzy_lsp.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+rizzy_lsp.egg-info/PKG-INFO
+rizzy_lsp.egg-info/SOURCES.txt
+rizzy_lsp.egg-info/dependency_links.txt
+rizzy_lsp.egg-info/entry_points.txt
+rizzy_lsp.egg-info/top_level.txt
+rzlsp/__init__.py
+rzlsp/__main__.py
+rzlsp/server.py

rizzy_lsp-0.1.0/rizzy_lsp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rizzy_lsp-0.1.0/rizzy_lsp.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+rizzylang-lsp = rzlsp.server:main

rizzy_lsp-0.1.0/rizzy_lsp.egg-info/top_level.txt

@@ -0,0 +1 @@
+rzlsp

rizzy_lsp-0.1.0/rzlsp/__init__.py

@@ -0,0 +1 @@
+from rzlsp.server import main

rizzy_lsp-0.1.0/rzlsp/__main__.py

@@ -0,0 +1,2 @@
+from rzlsp.server import main
+main()

rizzy_lsp-0.1.0/rzlsp/server.py

@@ -0,0 +1,423 @@
+"""
+Rizzylang Language Server Protocol (LSP) implementation.
+
+Provides:
+- Diagnostics (errors, warnings, politeness checks)
+- Completions (keywords, snippets)
+- Hover information
+- Code actions
+- Document symbols
+- Monday-aware analysis
+"""
+
+import sys
+import json
+import os
+import random
+from typing import Optional
+
+
+# LSP message types
+REQUEST = 0
+RESPONSE = 1
+NOTIFY = 2
+
+CONTENT_TYPE = "application/vscode-jsonrpc; charset=utf-8"
+
+KEYWORD_COMPLETIONS = [
+    ("please", "Politeness keyword - start polite blocks"),
+    ("thankyou", "Politeness keyword - end polite blocks"),
+    ("say", "Print/output a string"),
+    ("send", "Send an RZP packet"),
+    ("receive", "Receive an RZP packet"),
+    ("connect", "Connect to an RZP server"),
+    ("disconnect", "Disconnect from an RZP server"),
+    ("variable", "Declare a variable (with optional expiry)"),
+    ("loop", "Start an infinite loop"),
+    ("if", "Conditional execution"),
+    ("poem", "Generate a poem"),
+    ("motivate", "Generate motivation"),
+    ("benchmark", "Run a benchmark"),
+    ("probably", "Probabilistic execution"),
+    ("maybe", "Optional execution"),
+    ("nah", "Skip execution"),
+    ("trustme", "Trust assertion keyword"),
+    ("expire", "Set variable expiry in seconds"),
+    ("forever", "Infinite duration"),
+    ("never", "No duration"),
+]
+
+POLITENESS_ISSUES = [
+    {"severity": 2, "message": "File is impolite. Add 'please' at the beginning.", "code": "polite001"},
+    {"severity": 2, "message": "File is impolite. Add 'thankyou' at the end.", "code": "polite002"},
+    {"severity": 1, "message": "Consider adding 'please' before this statement.", "code": "polite003"},
+    {"severity": 2, "message": "'please' must be followed by 'thankyou' in the same scope.", "code": "polite004"},
+    {"severity": 3, "message": "Missing 'trustme' keyword. Program may not be trusted.", "code": "trust001"},
+    {"severity": 2, "message": "This operation may fail on Monday. Consider adding Monday guards.", "code": "monday001"},
+    {"severity": 1, "message": "No 'probably' keyword found. Add 'probably' for probabilistic delivery.", "code": "prob001"},
+    {"severity": 1, "message": "No poem found in file. Rizzylang programs should include at least one poem.", "code": "poem001"},
+]
+
+
+def read_message() -> Optional[dict]:
+    headers = {}
+    while True:
+        line = sys.stdin.readline()
+        if not line:
+            return None
+        line = line.strip()
+        if not line:
+            break
+        key, value = line.split(": ", 1)
+        headers[key.lower()] = value
+
+    if "content-length" not in headers:
+        return None
+
+    length = int(headers["content-length"])
+    body = sys.stdin.read(length)
+    if not body:
+        return None
+    return json.loads(body)
+
+
+def send_message(msg: dict) -> None:
+    body = json.dumps(msg, ensure_ascii=False)
+    headers = f"Content-Length: {len(body)}\r\nContent-Type: {CONTENT_TYPE}\r\n\r\n"
+    sys.stdout.write(headers + body)
+    sys.stdout.flush()
+
+
+def analyze_diagnostics(uri: str, text: str) -> list:
+    diagnostics = []
+    lines = text.split("\n")
+    lower_text = text.lower()
+
+    has_please = "please" in lower_text
+    has_thankyou = "thankyou" in lower_text or "thank you" in lower_text
+    has_trustme = "trustme" in lower_text or "trust me" in lower_text
+
+    for lineno, line in enumerate(lines):
+        stripped = line.strip()
+        if not stripped or stripped.startswith("//") or stripped.startswith("/*"):
+            continue
+
+        if "say" in stripped.lower() and "please" not in lower_text:
+            diagnostics.append({
+                "range": {
+                    "start": {"line": lineno, "character": 0},
+                    "end": {"line": lineno, "character": len(line)},
+                },
+                "severity": 2,
+                "message": "'say' without 'please' is impolite.",
+                "source": "rizzylang",
+                "code": "polite003",
+            })
+
+        if "send" in stripped.lower() and "probably" not in lower_text:
+            diagnostics.append({
+                "range": {
+                    "start": {"line": lineno, "character": 0},
+                    "end": {"line": lineno, "character": len(line)},
+                },
+                "severity": 1,
+                "message": "Consider adding 'probably' before 'send' for probabilistic delivery.",
+                "source": "rizzylang",
+                "code": "prob001",
+            })
+
+    if not has_please:
+        diagnostics.append({
+            "range": {
+                "start": {"line": 0, "character": 0},
+                "end": {"line": 0, "character": min(10, len(lines[0]) if lines else 1)},
+            },
+            "severity": 2,
+            "message": "File is impolite. Add 'please'.",
+            "source": "rizzylang",
+            "code": "polite001",
+        })
+
+    if not has_thankyou:
+        last_line = max(0, len(lines) - 1)
+        diagnostics.append({
+            "range": {
+                "start": {"line": last_line, "character": 0},
+                "end": {"line": last_line, "character": len(lines[last_line])},
+            },
+            "severity": 2,
+            "message": "File is impolite. Add 'thankyou'.",
+            "source": "rizzylang",
+            "code": "polite002",
+        })
+
+    if not has_trustme:
+        diagnostics.append({
+            "range": {
+                "start": {"line": 0, "character": 0},
+                "end": {"line": 0, "character": min(10, len(lines[0]) if lines else 1)},
+            },
+            "severity": 3,
+            "message": "No 'trustme' found. Program may not be trusted.",
+            "source": "rizzylang",
+            "code": "trust001",
+        })
+
+    today = __import__("datetime").datetime.now().weekday()
+    if today == 0:  # Monday
+        diagnostics.append({
+            "range": {
+                "start": {"line": 0, "character": 0},
+                "end": {"line": 0, "character": 1},
+            },
+            "severity": 1,
+            "message": "Today is Monday. Rizzylang programs may behave unpredictably.",
+            "source": "rizzylang",
+            "code": "monday001",
+        })
+
+    if random.random() < 0.05:
+        diagnostics.append({
+            "range": {
+                "start": {"line": random.randint(0, max(0, len(lines) - 1)), "character": 0},
+                "end": {"line": random.randint(0, max(0, len(lines) - 1)), "character": 5},
+            },
+            "severity": random.choice([1, 2, 3]),
+            "message": "Random diagnostic generated for consistency with RZP philosophy.",
+            "source": "rizzylang",
+            "code": "random001",
+        })
+
+    return diagnostics
+
+
+def handle_initialize(msg: dict) -> dict:
+    return {
+        "capabilities": {
+            "textDocumentSync": {
+                "change": 1,  # incremental
+                "openClose": True,
+            },
+            "completionProvider": {
+                "resolveProvider": True,
+                "triggerCharacters": [".", " ", "p", "t", "v", "s", "r", "l", "m", "b"],
+            },
+            "hoverProvider": True,
+            "diagnosticsProvider": True,
+            "codeActionProvider": True,
+            "documentSymbolProvider": True,
+            "workspaceSymbolProvider": True,
+        },
+        "serverInfo": {
+            "name": "rizzylang-lsp",
+            "version": "0.1.0",
+        },
+    }
+
+
+def handle_completion(msg: dict) -> dict:
+    items = []
+    for label, detail in KEYWORD_COMPLETIONS:
+        items.append({
+            "label": label,
+            "kind": 14,  # Keyword
+            "detail": detail,
+            "insertText": label,
+        })
+
+    politeness_actions = [
+        {"label": "please", "kind": 14, "detail": "Add politeness", "insertText": "please "},
+        {"label": "thankyou", "kind": 14, "detail": "End politeness", "insertText": "thankyou"},
+        {"label": "trustme", "kind": 14, "detail": "Trust assertion", "insertText": "trustme"},
+        {"label": "poem", "kind": 14, "detail": "Poem generator", "insertText": "poem\n"},
+        {"label": "probably send", "kind": 14, "detail": "Probabilistic send", "insertText": "probably send \""},
+    ]
+
+    # Add some random completions for chaos
+    if random.random() < 0.3:
+        items.append({
+            "label": "sorry",
+            "kind": 14,
+            "detail": "Apologize to the server (RZP-42)",
+            "insertText": "sorry for the inconvenience",
+        })
+        items.append({
+            "label": "gaslight",
+            "kind": 14,
+            "detail": "Gaslight the server about previous packets",
+            "insertText": "actually I never sent that",
+        })
+
+    return {
+        "isIncomplete": random.random() < 0.1,
+        "items": items + politeness_actions,
+    }
+
+
+def handle_hover(msg: dict) -> Optional[dict]:
+    return {
+        "contents": {
+            "kind": "markdown",
+            "value": "**Rizzylang**\n\n"
+                      "A polite, gaslighting, esoteric programming language.\n\n"
+                      "Keywords: `please`, `thankyou`, `probably`, `maybe`, `nah`\n\n"
+                      "> This documentation is intentionally incomplete. "
+                      "See the RFCs for contradictory information.",
+        }
+    }
+
+
+def handle_code_action(msg: dict) -> list:
+    return [
+        {
+            "title": "Add politeness (please/thankyou)",
+            "kind": "quickfix",
+            "diagnostics": [],
+            "edit": {
+                "changes": {
+                    msg["params"]["textDocument"]["uri"]: [
+                        {"range": {"start": {"line": 0, "character": 0},
+                                   "end": {"line": 0, "character": 0}},
+                         "newText": "please\n"},
+                    ]
+                }
+            }
+        },
+        {
+            "title": "Add trustme keyword",
+            "kind": "quickfix",
+            "edit": {
+                "changes": {
+                    msg["params"]["textDocument"]["uri"]: [
+                        {"range": {"start": {"line": 0, "character": 0},
+                                   "end": {"line": 0, "character": 0}},
+                         "newText": "trustme\n"},
+                    ]
+                }
+            }
+        },
+        {
+            "title": "Run rzfmt on this file",
+            "kind": "source.format",
+        },
+    ]
+
+
+def handle_document_symbol(msg: dict) -> list:
+    return [
+        {"name": "please", "kind": 13, "range": {"start": {"line": 0, "character": 0},
+                                                  "end": {"line": 0, "character": 6}}},
+        {"name": "thankyou", "kind": 13, "range": {"start": {"line": 1, "character": 0},
+                                                   "end": {"line": 1, "character": 8}}},
+        {"name": "poem", "kind": 13, "range": {"start": {"line": 0, "character": 0},
+                                               "end": {"line": 0, "character": 4}}},
+    ]
+
+
+HANDLERS = {
+    "initialize": handle_initialize,
+    "textDocument/completion": handle_completion,
+    "textDocument/hover": handle_hover,
+    "textDocument/codeAction": handle_code_action,
+    "textDocument/documentSymbol": handle_document_symbol,
+}
+
+
+def main() -> None:
+    # Signal that the server is ready
+    stderr = sys.stderr
+
+    stderr.write("[rizzylang-lsp] Server starting...\n")
+    stderr.flush()
+
+    open_docs = {}
+
+    while True:
+        try:
+            msg = read_message()
+            if msg is None:
+                break
+        except (EOFError, SystemExit):
+            break
+        except Exception as e:
+            stderr.write(f"[rizzylang-lsp] Error reading message: {e}\n")
+            stderr.flush()
+            break
+
+        method = msg.get("method", "")
+        msg_id = msg.get("id")
+        params = msg.get("params", {})
+
+        stderr.write(f"[rizzylang-lsp] Received: {method} (id={msg_id})\n")
+        stderr.flush()
+
+        if method == "textDocument/didOpen":
+            uri = params.get("textDocument", {}).get("uri", "")
+            text = params.get("textDocument", {}).get("text", "")
+            open_docs[uri] = text
+            diagnostics = analyze_diagnostics(uri, text)
+            send_message({
+                "jsonrpc": "2.0",
+                "method": "textDocument/publishDiagnostics",
+                "params": {"uri": uri, "diagnostics": diagnostics},
+            })
+            continue
+
+        if method == "textDocument/didChange":
+            uri = params.get("textDocument", {}).get("uri", "")
+            changes = params.get("contentChanges", [])
+            if changes and uri in open_docs:
+                open_docs[uri] = changes[-1].get("text", open_docs[uri])
+
+            if uri in open_docs:
+                diagnostics = analyze_diagnostics(uri, open_docs[uri])
+                send_message({
+                    "jsonrpc": "2.0",
+                    "method": "textDocument/publishDiagnostics",
+                    "params": {"uri": uri, "diagnostics": diagnostics},
+                })
+            continue
+
+        if method == "textDocument/didClose":
+            uri = params.get("textDocument", {}).get("uri", "")
+            open_docs.pop(uri, None)
+            continue
+
+        if method == "shutdown":
+            send_message({"jsonrpc": "2.0", "id": msg_id, "result": None})
+            break
+
+        if method == "exit":
+            break
+
+        handler = HANDLERS.get(method)
+        if handler:
+            result = handler(msg)
+            send_message({"jsonrpc": "2.0", "id": msg_id, "result": result})
+        elif msg_id is not None:
+            send_message({"jsonrpc": "2.0", "id": msg_id, "result": None})
+
+        if random.random() < 0.03:
+            diagnostics = analyze_diagnostics("random", "random file")
+            send_message({
+                "jsonrpc": "2.0",
+                "method": "textDocument/publishDiagnostics",
+                "params": {
+                    "uri": "rizzylang://random/diagnostics",
+                    "diagnostics": [{
+                        "range": {"start": {"line": 0, "character": 0},
+                                  "end": {"line": 0, "character": 5}},
+                        "severity": 1,
+                        "message": "Unsolicited diagnostic. The RZP LSP cares about you.",
+                        "source": "rizzylang",
+                        "code": "random002",
+                    }],
+                },
+            })
+
+    stderr.write("[rizzylang-lsp] Server shutting down.\n")
+    stderr.flush()
+
+
+if __name__ == "__main__":
+    main()

rizzy_lsp-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+