@zhijiewang/openharness 2.22.0 → 2.22.1

package/dist/lsp/client.d.ts

@@ -51,7 +51,16 @@ export declare class LspClient {
     getDefinition(filePath: string, line: number, character: number): Promise<Location[]>;
     /** Find references */
     getReferences(filePath: string, line: number, character: number): Promise<Location[]>;
+    /**
+     * Hover at a position — returns the text content of the LSP hover response,
+     * or `null` if the server returned no hover information / doesn't support
+     * the `textDocument/hover` capability. The LSP `MarkupContent` envelope is
+     * unwrapped so callers see plain text or markdown.
+     */
+    getHover(filePath: string, line: number, character: number): Promise<string | null>;
     private guessLanguage;
+    /** @internal Exposed for unit tests of the hover-content unwrapper. */
+    static unwrapHoverContents(result: unknown): string | null;
     disconnect(): void;
 }
 export {};

package/dist/lsp/client.js

@@ -4,6 +4,38 @@
  */
 import { spawn } from "node:child_process";
 import { readFileSync } from "node:fs";
+/**
+ * Unwrap a `textDocument/hover` result into a plain string. LSP allows three
+ * `contents` shapes: a bare string, a `{ kind, value }` envelope, or an
+ * array of either. Returns null when nothing is hoverable. Pure — exposed
+ * via `LspClient.unwrapHoverContents` for unit tests.
+ */
+function unwrapHoverContents(result) {
+    if (!result || typeof result !== "object")
+        return null;
+    const r = result;
+    if (!r.contents)
+        return null;
+    const c = r.contents;
+    if (typeof c === "string")
+        return c;
+    if (Array.isArray(c)) {
+        const parts = c.map((item) => {
+            if (typeof item === "string")
+                return item;
+            if (item && typeof item === "object" && typeof item.value === "string") {
+                return item.value;
+            }
+            return "";
+        });
+        const joined = parts.filter(Boolean).join("\n");
+        return joined || null;
+    }
+    if (typeof c === "object" && typeof c.value === "string") {
+        return c.value;
+    }
+    return null;
+}
 export class LspClient {
     proc;
     nextId = 1;
@@ -150,6 +182,20 @@ export class LspClient {
         });
         return result ?? [];
     }
+    /**
+     * Hover at a position — returns the text content of the LSP hover response,
+     * or `null` if the server returned no hover information / doesn't support
+     * the `textDocument/hover` capability. The LSP `MarkupContent` envelope is
+     * unwrapped so callers see plain text or markdown.
+     */
+    async getHover(filePath, line, character) {
+        const uri = `file://${filePath.replace(/\\/g, "/")}`;
+        const result = await this.send("textDocument/hover", {
+            textDocument: { uri },
+            position: { line, character },
+        });
+        return unwrapHoverContents(result);
+    }
     guessLanguage(path) {
         if (path.endsWith(".ts") || path.endsWith(".tsx"))
             return "typescript";
@@ -165,6 +211,10 @@ export class LspClient {
             return "java";
         return "plaintext";
     }
+    /** @internal Exposed for unit tests of the hover-content unwrapper. */
+    static unwrapHoverContents(result) {
+        return unwrapHoverContents(result);
+    }
     disconnect() {
         this.send("shutdown", {})
             .then(() => {

package/dist/tools/DiagnosticsTool/index.js

@@ -44,7 +44,7 @@ async function getClient(filePath, workingDir) {
 }
 export const DiagnosticsTool = {
     name: "Diagnostics",
-    description: "Get code diagnostics (errors, warnings), go-to-definition, or find-references using the language server.",
+    description: "Language Server Protocol (LSP) code intelligence — pick action: diagnostics (errors/warnings), definition (go-to-def), references (find-refs), or hover (type info / docs). Supports TypeScript, JavaScript, Python, Go, Rust.",
     inputSchema,
     riskLevel: "low",
     isReadOnly() {
@@ -101,22 +101,10 @@ export const DiagnosticsTool = {
                     return { output: "line and character are required for hover.", isError: true };
                 }
                 await client.openFile(input.file_path);
-                // Hover uses textDocument/hover which returns MarkupContent
-                try {
-                    const result = await client.send("textDocument/hover", {
-                        textDocument: { uri: `file://${input.file_path.replace(/\\/g, "/")}` },
-                        position: { line: input.line, character: input.character },
-                    });
-                    if (!result?.contents)
-                        return { output: "No hover information.", isError: false };
-                    const content = typeof result.contents === "string"
-                        ? result.contents
-                        : (result.contents.value ?? JSON.stringify(result.contents));
-                    return { output: content, isError: false };
-                }
-                catch {
-                    return { output: "Hover not supported by this language server.", isError: false };
-                }
+                const content = await client.getHover(input.file_path, input.line, input.character);
+                if (!content)
+                    return { output: "No hover information.", isError: false };
+                return { output: content, isError: false };
             }
             return { output: `Unknown action: ${input.action}`, isError: true };
         }
@@ -128,11 +116,11 @@ export const DiagnosticsTool = {
         }
     },
     prompt() {
-        return `Get code intelligence from the language server. Supports TypeScript, JavaScript, Python, Go, and Rust. Actions:
-- diagnostics: Get errors and warnings for a file
-- definition: Go to definition of a symbol at a given position
-- references: Find all references to a symbol at a given position
-- hover: Get type information and documentation for a symbol
+        return `LSP code intelligence — diagnostics, go-to-definition, find-references, hover. Supports TypeScript, JavaScript, Python, Go, Rust (a language server must be installed: typescript-language-server / pylsp / gopls / rust-analyzer). Actions:
+- diagnostics: Errors and warnings for the file
+- definition: Resolve the symbol at (line, character) to its declaration
+- references: Find all references to the symbol at (line, character)
+- hover: Type information and documentation for the symbol at (line, character)
 Parameters:
 - file_path (string, required): Absolute path to the file
 - action (string): "diagnostics" | "definition" | "references" | "hover" (default: diagnostics)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhijiewang/openharness",
-  "version": "2.22.0",
+  "version": "2.22.1",
   "description": "Open-source terminal coding agent. Works with any LLM.",
   "type": "module",
   "bin": {