@aria-cli/tools 1.0.2 → 1.0.3

package/src/executors/lsp-client.ts

@@ -0,0 +1,355 @@
+/**
+ * Native LSP Client — uses vscode-jsonrpc for proper message framing.
+ *
+ * Same approach as Claude Code: createMessageConnection over stdio.
+ * Same configuration as Claude Code's LSP plugins.
+ * Supports: TypeScript, Python, Go, Rust, C/C++, Swift, Java, Kotlin, Lua, PHP, Ruby, C#.
+ */
+
+import { spawn, type ChildProcess } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+
+// vscode-jsonrpc: same library Claude Code uses for LSP message framing.
+// Direct import via createRequire (package lacks ESM exports field).
+const require_ = createRequire(fileURLToPath(import.meta.url));
+const { createMessageConnection, StreamMessageReader, StreamMessageWriter } = require_(
+  "vscode-jsonrpc/node",
+) as {
+  createMessageConnection: (reader: unknown, writer: unknown) => VscodeConnection;
+  StreamMessageReader: new (stream: NodeJS.ReadableStream) => unknown;
+  StreamMessageWriter: new (stream: NodeJS.WritableStream) => unknown;
+};
+
+interface VscodeConnection {
+  sendRequest(method: string, params?: unknown): Promise<unknown>;
+  sendNotification(method: string, params?: unknown): void;
+  onNotification(method: string, handler: (params: unknown) => void): void;
+  listen(): void;
+  dispose(): void;
+}
+
+// ---------------------------------------------------------------------------
+// Language server registry — same config as Claude Code LSP plugins
+// ---------------------------------------------------------------------------
+
+export interface LspServerConfig {
+  command: string;
+  args: string[];
+  extensionToLanguage: Record<string, string>;
+  startupTimeout: number;
+}
+
+export const LSP_SERVERS: Record<string, LspServerConfig> = {
+  typescript: {
+    command: "typescript-language-server",
+    args: ["--stdio"],
+    extensionToLanguage: {
+      ".ts": "typescript",
+      ".tsx": "typescriptreact",
+      ".js": "javascript",
+      ".jsx": "javascriptreact",
+      ".mts": "typescript",
+      ".cts": "typescript",
+      ".mjs": "javascript",
+      ".cjs": "javascript",
+    },
+    startupTimeout: 30_000,
+  },
+  python: {
+    command: "pyright-langserver",
+    args: ["--stdio"],
+    extensionToLanguage: { ".py": "python", ".pyi": "python" },
+    startupTimeout: 60_000,
+  },
+  go: {
+    command: "gopls",
+    args: [],
+    extensionToLanguage: { ".go": "go" },
+    startupTimeout: 30_000,
+  },
+  rust: {
+    command: "rust-analyzer",
+    args: [],
+    extensionToLanguage: { ".rs": "rust" },
+    startupTimeout: 60_000,
+  },
+  "c/cpp": {
+    command: "clangd",
+    args: ["--background-index"],
+    extensionToLanguage: {
+      ".c": "c",
+      ".h": "c",
+      ".cpp": "cpp",
+      ".cc": "cpp",
+      ".cxx": "cpp",
+      ".hpp": "cpp",
+      ".hxx": "cpp",
+    },
+    startupTimeout: 30_000,
+  },
+  swift: {
+    command: "sourcekit-lsp",
+    args: [],
+    extensionToLanguage: { ".swift": "swift" },
+    startupTimeout: 30_000,
+  },
+  java: {
+    command: "jdtls",
+    args: [],
+    extensionToLanguage: { ".java": "java" },
+    startupTimeout: 120_000,
+  },
+  kotlin: {
+    command: "kotlin-language-server",
+    args: ["--stdio"],
+    extensionToLanguage: { ".kt": "kotlin", ".kts": "kotlin" },
+    startupTimeout: 120_000,
+  },
+  lua: {
+    command: "lua-language-server",
+    args: [],
+    extensionToLanguage: { ".lua": "lua" },
+    startupTimeout: 30_000,
+  },
+  php: {
+    command: "intelephense",
+    args: ["--stdio"],
+    extensionToLanguage: { ".php": "php" },
+    startupTimeout: 30_000,
+  },
+  ruby: {
+    command: "ruby-lsp",
+    args: [],
+    extensionToLanguage: { ".rb": "ruby", ".rake": "ruby", ".gemspec": "ruby" },
+    startupTimeout: 30_000,
+  },
+  csharp: {
+    command: "csharp-ls",
+    args: [],
+    extensionToLanguage: { ".cs": "csharp" },
+    startupTimeout: 30_000,
+  },
+};
+
+// Build reverse lookup: file extension → server name
+const EXT_TO_SERVER = new Map<string, string>();
+for (const [serverName, config] of Object.entries(LSP_SERVERS)) {
+  for (const ext of Object.keys(config.extensionToLanguage)) {
+    EXT_TO_SERVER.set(ext, serverName);
+  }
+}
+
+export function getServerForFile(filePath: string): string | undefined {
+  const ext = filePath.slice(filePath.lastIndexOf("."));
+  return EXT_TO_SERVER.get(ext);
+}
+
+export function getLanguageId(filePath: string): string | undefined {
+  const ext = filePath.slice(filePath.lastIndexOf("."));
+  const serverName = EXT_TO_SERVER.get(ext);
+  if (!serverName) return undefined;
+  return LSP_SERVERS[serverName]?.extensionToLanguage[ext];
+}
+
+// ---------------------------------------------------------------------------
+// LSP Server Instance — uses vscode-jsonrpc createMessageConnection
+// ---------------------------------------------------------------------------
+
+export class LspServer {
+  private process: ChildProcess | null = null;
+  private connection: VscodeConnection | null = null;
+  private initialized = false;
+  private openFiles = new Set<string>();
+  private diagnosticsReceived = new Set<string>();
+  readonly serverName: string;
+  readonly config: LspServerConfig;
+  private rootUri: string;
+
+  constructor(serverName: string, rootPath: string) {
+    this.serverName = serverName;
+    const cfg = LSP_SERVERS[serverName];
+    if (!cfg) throw new Error(`Unknown LSP server: ${serverName}`);
+    this.config = cfg;
+    this.rootUri = `file://${resolve(rootPath)}`;
+  }
+
+  async start(): Promise<void> {
+    if (this.connection) return;
+
+    this.process = spawn(this.config.command, this.config.args, {
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    this.process.stderr?.on("data", () => {
+      // Swallow stderr — language servers are noisy
+    });
+
+    this.process.on("exit", () => {
+      this.connection?.dispose();
+      this.connection = null;
+      this.process = null;
+      this.initialized = false;
+      this.openFiles.clear();
+      this.diagnosticsReceived.clear();
+    });
+
+    // Create vscode-jsonrpc connection — handles Content-Length framing,
+    // request/response matching, notification routing. Same as Claude Code.
+    this.connection = createMessageConnection(
+      new StreamMessageReader(this.process.stdout!),
+      new StreamMessageWriter(this.process.stdin!),
+    );
+
+    // Listen for diagnostics notifications (signals file analysis complete)
+    this.connection.onNotification("textDocument/publishDiagnostics", (params: unknown) => {
+      const p = params as { uri?: string };
+      if (p.uri) this.diagnosticsReceived.add(p.uri);
+    });
+
+    this.connection.listen();
+
+    // Initialize handshake
+    await this.connection.sendRequest("initialize", {
+      processId: globalThis.process.pid,
+      rootUri: this.rootUri,
+      capabilities: {
+        textDocument: {
+          definition: { dynamicRegistration: false },
+          references: { dynamicRegistration: false },
+          hover: { dynamicRegistration: false, contentFormat: ["plaintext", "markdown"] },
+          documentSymbol: { dynamicRegistration: false },
+          rename: { dynamicRegistration: false, prepareSupport: false },
+          publishDiagnostics: { relatedInformation: true },
+        },
+        workspace: {
+          workspaceFolders: true,
+        },
+      },
+      workspaceFolders: [{ uri: this.rootUri, name: "root" }],
+    });
+
+    this.connection.sendNotification("initialized", {});
+    this.initialized = true;
+  }
+
+  async stop(): Promise<void> {
+    if (!this.connection) return;
+    try {
+      await this.connection.sendRequest("shutdown");
+      this.connection.sendNotification("exit");
+    } catch {
+      // Force kill if graceful shutdown fails
+    }
+    this.connection.dispose();
+    this.connection = null;
+    this.process?.kill("SIGTERM");
+    this.process = null;
+    this.initialized = false;
+  }
+
+  // Ensure a file is opened in the language server
+  async openFile(filePath: string): Promise<void> {
+    const uri = `file://${resolve(filePath)}`;
+    if (this.openFiles.has(uri)) return;
+
+    const languageId = getLanguageId(filePath);
+    if (!languageId) return;
+
+    let text: string;
+    try {
+      text = readFileSync(resolve(filePath), "utf-8");
+    } catch {
+      return;
+    }
+
+    this.connection?.sendNotification("textDocument/didOpen", {
+      textDocument: { uri, languageId, version: 1, text },
+    });
+    this.openFiles.add(uri);
+
+    // No wait needed. LSP servers queue requests after didOpen and respond
+    // when ready. Tested: TypeScript responds to hover in 239ms with zero
+    // wait (before diagnostics arrive). Pyright responds after its analysis.
+    // The sendRequest in the caller will block until the server responds.
+  }
+
+  // --- LSP Operations ---
+
+  async definition(filePath: string, line: number, character: number): Promise<unknown> {
+    await this.ensureReady(filePath);
+    return this.connection!.sendRequest("textDocument/definition", {
+      textDocument: { uri: `file://${resolve(filePath)}` },
+      position: { line, character },
+    });
+  }
+
+  async references(filePath: string, line: number, character: number): Promise<unknown> {
+    await this.ensureReady(filePath);
+    return this.connection!.sendRequest("textDocument/references", {
+      textDocument: { uri: `file://${resolve(filePath)}` },
+      position: { line, character },
+      context: { includeDeclaration: true },
+    });
+  }
+
+  async hover(filePath: string, line: number, character: number): Promise<unknown> {
+    await this.ensureReady(filePath);
+    return this.connection!.sendRequest("textDocument/hover", {
+      textDocument: { uri: `file://${resolve(filePath)}` },
+      position: { line, character },
+    });
+  }
+
+  async documentSymbols(filePath: string): Promise<unknown> {
+    await this.ensureReady(filePath);
+    return this.connection!.sendRequest("textDocument/documentSymbol", {
+      textDocument: { uri: `file://${resolve(filePath)}` },
+    });
+  }
+
+  async rename(
+    filePath: string,
+    line: number,
+    character: number,
+    newName: string,
+  ): Promise<unknown> {
+    await this.ensureReady(filePath);
+    return this.connection!.sendRequest("textDocument/rename", {
+      textDocument: { uri: `file://${resolve(filePath)}` },
+      position: { line, character },
+      newName,
+    });
+  }
+
+  // --- Internals ---
+
+  private async ensureReady(filePath: string): Promise<void> {
+    if (!this.initialized) await this.start();
+    await this.openFile(filePath);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Server Pool — one server per language, shared across queries
+// ---------------------------------------------------------------------------
+
+const serverPool = new Map<string, LspServer>();
+
+export function getOrCreateServer(serverName: string, rootPath: string): LspServer {
+  const key = `${serverName}:${rootPath}`;
+  let server = serverPool.get(key);
+  if (!server) {
+    server = new LspServer(serverName, rootPath);
+    serverPool.set(key, server);
+  }
+  return server;
+}
+
+export async function shutdownAll(): Promise<void> {
+  const stops = [...serverPool.values()].map((s) => s.stop());
+  await Promise.allSettled(stops);
+  serverPool.clear();
+}

package/src/executors/restart.ts

@@ -1,15 +1,10 @@
 /**
  * @aria/tools - Restart executor
  *
- * Two restart paths:
- *
- * 1. Supervised (TUI via relaunch.ts): ARIA_NO_RELAUNCH=true is set by the
- *    parent supervisor. Child exits with RELAUNCH_EXIT_CODE (199), parent
- *    respawns automatically.
- *
- * 2. Daemon (daemon-launcher): No supervisor loop. The executor spawns a
- *    replacement daemon on the process 'exit' event (after the singleton lock
- *    is released), then sends SIGINT to trigger graceful shutdown.
+ * Single restart path for both TUI and daemon:
+ * Register an 'exit' handler to spawn a replacement process, then SIGINT
+ * the current process for graceful shutdown. The replacement starts fresh
+ * and goes through normal startup (heap check, createCliContext, REPL/daemon).
  */
 
 import type { ToolContext, ToolResult } from "../types.js";
@@ -18,13 +13,7 @@ import { spawn } from "node:child_process";
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import * as os from "node:os";
-import {
-  NO_RELAUNCH_ENV,
-  RELAUNCH_EXIT_CODE,
-  RESUME_ARION_ENV,
-  RESUME_SESSION_ENV,
-  writeRelaunchMarker,
-} from "@aria-cli/types";
+import { RESUME_ARION_ENV, RESUME_SESSION_ENV, writeRelaunchMarker } from "@aria-cli/types";
 
 export interface RestartInput {
   reason?: string;
@@ -94,7 +83,6 @@ function findDaemonPid(): number | null {
 export async function executeRestart(input: RestartInput, ctx: ToolContext): Promise<ToolResult> {
   if (ctx.abortSignal?.aborted) return fail("Operation cancelled");
 
-  const supervised = process.env[NO_RELAUNCH_ENV] === "true";
   const reason = (input.reason ?? "").trim() || "Restart requested";
 
   // Note: tool definition has requiresConfirmation: true, so the framework
@@ -115,7 +103,7 @@ export async function executeRestart(input: RestartInput, ctx: ToolContext): Pro
   const sessionId = process.env[RESUME_SESSION_ENV] ?? null;
   const arionName = process.env[RESUME_ARION_ENV] || "ARIA";
 
-  // Write disk-backed marker as durable fallback in case IPC is lost.
+  // Write disk-backed marker so the replacement process can resume the session.
   writeRelaunchMarker({
     sessionId,
     arionName,
@@ -123,46 +111,23 @@ export async function executeRestart(input: RestartInput, ctx: ToolContext): Pro
     timestamp: new Date().toISOString(),
   });
 
-  if (supervised) {
-    // Path 1: Supervised by parent-child relaunch loop (TUI mode).
-    // Pass session forward via IPC, then exit with magic code for parent to respawn.
-    try {
-      const send = (process as NodeJS.Process & { send?: (msg: unknown) => void }).send;
-      if (typeof send === "function") {
-        send({
-          type: "aria-relaunch",
-          resumeSessionId: sessionId,
-          arionName,
-        });
-      }
-    } catch {
-      // non-fatal — disk marker is the fallback
-    }
-    process.exit(RELAUNCH_EXIT_CODE);
-  } else {
-    // Path 2: Daemon mode — no supervisor loop.
-    // Register an 'exit' handler to spawn the replacement AFTER the singleton
-    // lock is released (beforeExit releases it). Then SIGINT ourselves to
-    // trigger graceful daemon shutdown. The SIGINT handler fires synchronously
-    // (just sets controller.abort()), so the tool can still return success.
-    const daemonPid = findDaemonPid() ?? process.pid;
-
-    process.once("exit", () => {
-      spawn(process.execPath, [...process.execArgv, ...process.argv.slice(1)], {
-        detached: true,
-        stdio: "ignore",
-      }).unref();
-    });
+  // Spawn replacement on exit, then SIGINT for graceful shutdown.
+  // Works for both TUI and daemon — no supervisor needed.
+  const targetPid = findDaemonPid() ?? process.pid;
 
-    process.stderr.write(`[aria] Sending SIGINT to daemon pid ${daemonPid} for graceful restart\n`);
-    try {
-      process.kill(daemonPid, "SIGINT");
-    } catch {
-      // PID already dead or not our process — fall back to self
-      process.kill(process.pid, "SIGINT");
-    }
+  process.once("exit", () => {
+    spawn(process.execPath, [...process.execArgv, ...process.argv.slice(1)], {
+      detached: true,
+      stdio: "ignore",
+    }).unref();
+  });
+
+  process.stderr.write(`[aria] Sending SIGINT to pid ${targetPid} for graceful restart\n`);
+  try {
+    process.kill(targetPid, "SIGINT");
+  } catch {
+    process.kill(process.pid, "SIGINT");
   }
 
-  // Unreachable in supervised path (process.exit above), but returned in daemon path
   return success("Restarting...");
 }