minimal-agent 0.11.0 → 0.13.0

package/src/tools/lsp/lsp.js

@@ -1,29 +1,71 @@
 import { stat } from 'node:fs/promises';
 import { isAbsolute, relative, resolve, sep } from 'node:path';
 import { pathToFileURL } from 'node:url';
+import { fileURLToPath } from 'node:url';
 import { z } from 'zod';
 import { getWorkingDir } from '../../bootstrap/workingDir.js';
 import { toToolParameters } from '../../utils/zodToJson.js';
 import { DEFAULT_MAX_RESULT_SIZE_CHARS } from '../types.js';
 import { discoverLspServers, lspAvailabilitySignature } from './config.js';
 import { getLspManager } from './service.js';
-const positionOperations = new Set(['goToDefinition', 'findReferences', 'hover', 'goToImplementation', 'incomingCalls', 'outgoingCalls']);
-const inputSchema = z.object({
+const positionOperations = new Set([
+    'goToDefinition',
+    'findReferences',
+    'hover',
+    'goToImplementation',
+    'incomingCalls',
+    'outgoingCalls',
+]);
+const inputSchema = z
+    .object({
     operation: z.enum([
-        'goToDefinition', 'findReferences', 'hover', 'documentSymbols', 'workspaceSymbols',
-        'goToImplementation', 'incomingCalls', 'outgoingCalls', 'diagnostics',
+        'goToDefinition',
+        'findReferences',
+        'hover',
+        'documentSymbols',
+        'workspaceSymbols',
+        'goToImplementation',
+        'incomingCalls',
+        'outgoingCalls',
+        'diagnostics',
     ]),
     file_path: z.string().min(1),
-    line: z.number().int().positive().optional().describe('1-based source line for position operations'),
-    character: z.number().int().positive().optional().describe('1-based UTF-16 character for position operations'),
+    line: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe('1-based source line for position operations'),
+    character: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe('1-based UTF-16 character for position operations'),
     query: z.string().optional().describe('Symbol query for workspaceSymbols'),
-    limit: z.number().int().min(1).max(500).optional().describe('Maximum formatted results, default 200'),
-}).superRefine((input, context) => {
-    if (positionOperations.has(input.operation) && (!input.line || !input.character)) {
-        context.addIssue({ code: z.ZodIssueCode.custom, message: `${input.operation} requires line and character` });
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(500)
+        .optional()
+        .describe('Maximum formatted results, default 200'),
+    output_format: z.enum(['compact', 'json']).default('compact').optional(),
+})
+    .superRefine((input, context) => {
+    if (positionOperations.has(input.operation) &&
+        (!input.line || !input.character)) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `${input.operation} requires line and character`,
+        });
     }
     if (input.operation === 'workspaceSymbols' && !input.query?.trim()) {
-        context.addIssue({ code: z.ZodIssueCode.custom, path: ['query'], message: 'workspaceSymbols requires a non-empty query' });
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['query'],
+            message: 'workspaceSymbols requires a non-empty query',
+        });
     }
 });
 function compact(value, limit) {
@@ -35,6 +77,74 @@ function compact(value, limit) {
         ? `${text.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS)}\n... (LSP result truncated)`
         : text;
 }
+function compactSemantic(value, cwd, limit) {
+    if (value == null)
+        return 'No results.';
+    const rows = [];
+    const walk = (item, label) => {
+        if (item == null)
+            return;
+        if (Array.isArray(item)) {
+            item.forEach((v) => walk(v, label));
+            return;
+        }
+        if (typeof item !== 'object') {
+            rows.push(String(item));
+            return;
+        }
+        const location = item.location ?? item.fromRanges?.[0] ?? item;
+        const uri = location.uri ?? location.targetUri ?? item.uri;
+        const range = location.range ??
+            location.targetSelectionRange ??
+            item.range ??
+            item.selectionRange;
+        let where = '';
+        if (typeof uri === 'string') {
+            let path = uri;
+            try {
+                path = uri.startsWith('file:') ? fileURLToPath(uri) : uri;
+            }
+            catch { }
+            const rel = relative(resolve(cwd), path);
+            where = (rel && !rel.startsWith('..') ? rel : path).split(sep).join('/');
+        }
+        if (range?.start)
+            where += `:${Number(range.start.line) + 1}:${Number(range.start.character) + 1}`;
+        const message = item.message ?? item.name ?? item.detail ?? item.kind ?? label;
+        const severity = item.severity
+            ? `[${['', 'error', 'warning', 'info', 'hint'][item.severity] ?? item.severity}] `
+            : '';
+        const code = item.code !== undefined ? `(${String(item.code)}) ` : '';
+        if (where || message)
+            rows.push(`${severity}${where || '<symbol>'} — ${code}${typeof message === 'string' ? message : JSON.stringify(message)}`);
+        if (item.contents) {
+            const contents = Array.isArray(item.contents)
+                ? item.contents
+                : [item.contents];
+            for (const c of contents)
+                rows.push(typeof c === 'string'
+                    ? c
+                    : typeof c?.value === 'string'
+                        ? c.value
+                        : JSON.stringify(c));
+        }
+        if (item.from)
+            walk(item.from, 'caller');
+        if (item.to)
+            walk(item.to, 'callee');
+        if (Array.isArray(item.children))
+            item.children.forEach((v) => walk(v));
+    };
+    walk(value);
+    const unique = [...new Set(rows)].sort();
+    const selected = unique.slice(0, limit);
+    let text = selected.join('\n') || 'No results.';
+    if (unique.length > selected.length)
+        text += `\n... (${unique.length - selected.length} more; total=${unique.length})`;
+    return text.length > DEFAULT_MAX_RESULT_SIZE_CHARS
+        ? `${text.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS)}\n... (LSP result truncated)`
+        : text;
+}
 async function call(input, cwd = getWorkingDir()) {
     const filePath = resolve(cwd, input.file_path);
     const rel = relative(resolve(cwd), filePath);
@@ -52,32 +162,54 @@ async function call(input, cwd = getWorkingDir()) {
     try {
         await server.openFile(filePath);
         const uri = pathToFileURL(filePath).href;
-        const position = { line: (input.line ?? 1) - 1, character: (input.character ?? 1) - 1 };
+        const position = {
+            line: (input.line ?? 1) - 1,
+            character: (input.character ?? 1) - 1,
+        };
         let result;
         switch (input.operation) {
             case 'goToDefinition':
-                result = await server.request('textDocument/definition', { textDocument: { uri }, position });
+                result = await server.request('textDocument/definition', {
+                    textDocument: { uri },
+                    position,
+                });
                 break;
             case 'findReferences':
-                result = await server.request('textDocument/references', { textDocument: { uri }, position, context: { includeDeclaration: true } });
+                result = await server.request('textDocument/references', {
+                    textDocument: { uri },
+                    position,
+                    context: { includeDeclaration: true },
+                });
                 break;
             case 'hover':
-                result = await server.request('textDocument/hover', { textDocument: { uri }, position });
+                result = await server.request('textDocument/hover', {
+                    textDocument: { uri },
+                    position,
+                });
                 break;
             case 'documentSymbols':
-                result = await server.request('textDocument/documentSymbol', { textDocument: { uri } });
+                result = await server.request('textDocument/documentSymbol', {
+                    textDocument: { uri },
+                });
                 break;
             case 'workspaceSymbols':
-                result = await server.request('workspace/symbol', { query: input.query });
+                result = await server.request('workspace/symbol', {
+                    query: input.query,
+                });
                 break;
             case 'goToImplementation':
-                result = await server.request('textDocument/implementation', { textDocument: { uri }, position });
+                result = await server.request('textDocument/implementation', {
+                    textDocument: { uri },
+                    position,
+                });
                 break;
             case 'incomingCalls':
             case 'outgoingCalls': {
                 const prepared = await server.request('textDocument/prepareCallHierarchy', { textDocument: { uri }, position });
                 const item = prepared?.[0];
-                result = item ? await server.request(`callHierarchy/${input.operation}`, { item }) : [];
+                result = item
+                    ? await server.request(`callHierarchy/${input.operation}`, { item })
+                    : [];
                 break;
             }
             case 'diagnostics': {
@@ -87,10 +219,18 @@ async function call(input, cwd = getWorkingDir()) {
                 break;
             }
         }
-        return { ok: true, content: compact(result, input.limit ?? 200) };
+        return {
+            ok: true,
+            content: input.output_format === 'json'
+                ? compact(result, input.limit ?? 200)
+                : compactSemantic(result, cwd, input.limit ?? 200),
+        };
     }
     catch (error) {
-        return { ok: false, error: `LSP ${input.operation} failed: ${error.message}` };
+        return {
+            ok: false,
+            error: `LSP ${input.operation} failed: ${error.message}`,
+        };
     }
 }
 export const lspTool = {
@@ -106,7 +246,10 @@ export const lspTool = {
     maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
     resolveAvailability(runtime) {
         const servers = discoverLspServers(runtime.cwd);
-        return { available: servers.length > 0, signature: lspAvailabilitySignature(runtime.cwd, servers) };
+        return {
+            available: servers.length > 0,
+            signature: lspAvailabilitySignature(runtime.cwd, servers),
+        };
     },
     call: (input) => call(input),
     callWithContext: (input, _signal, context) => call(input, context.cwd),

package/src/tools/lsp/lsp.ts

@@ -1,6 +1,7 @@
 import { stat } from 'node:fs/promises';
 import { isAbsolute, relative, resolve, sep } from 'node:path';
 import { pathToFileURL } from 'node:url';
+import { fileURLToPath } from 'node:url';
 import { z } from 'zod';
 
 import { getWorkingDir } from '../../bootstrap/workingDir.js';
@@ -11,25 +12,68 @@ import { DEFAULT_MAX_RESULT_SIZE_CHARS } from '../types.js';
 import { discoverLspServers, lspAvailabilitySignature } from './config.js';
 import { getLspManager } from './service.js';
 
-const positionOperations = new Set(['goToDefinition', 'findReferences', 'hover', 'goToImplementation', 'incomingCalls', 'outgoingCalls']);
-const inputSchema = z.object({
-  operation: z.enum([
-    'goToDefinition', 'findReferences', 'hover', 'documentSymbols', 'workspaceSymbols',
-    'goToImplementation', 'incomingCalls', 'outgoingCalls', 'diagnostics',
-  ]),
-  file_path: z.string().min(1),
-  line: z.number().int().positive().optional().describe('1-based source line for position operations'),
-  character: z.number().int().positive().optional().describe('1-based UTF-16 character for position operations'),
-  query: z.string().optional().describe('Symbol query for workspaceSymbols'),
-  limit: z.number().int().min(1).max(500).optional().describe('Maximum formatted results, default 200'),
-}).superRefine((input, context) => {
-  if (positionOperations.has(input.operation) && (!input.line || !input.character)) {
-    context.addIssue({ code: z.ZodIssueCode.custom, message: `${input.operation} requires line and character` });
-  }
-  if (input.operation === 'workspaceSymbols' && !input.query?.trim()) {
-    context.addIssue({ code: z.ZodIssueCode.custom, path: ['query'], message: 'workspaceSymbols requires a non-empty query' });
-  }
-});
+const positionOperations = new Set([
+  'goToDefinition',
+  'findReferences',
+  'hover',
+  'goToImplementation',
+  'incomingCalls',
+  'outgoingCalls',
+]);
+const inputSchema = z
+  .object({
+    operation: z.enum([
+      'goToDefinition',
+      'findReferences',
+      'hover',
+      'documentSymbols',
+      'workspaceSymbols',
+      'goToImplementation',
+      'incomingCalls',
+      'outgoingCalls',
+      'diagnostics',
+    ]),
+    file_path: z.string().min(1),
+    line: z
+      .number()
+      .int()
+      .positive()
+      .optional()
+      .describe('1-based source line for position operations'),
+    character: z
+      .number()
+      .int()
+      .positive()
+      .optional()
+      .describe('1-based UTF-16 character for position operations'),
+    query: z.string().optional().describe('Symbol query for workspaceSymbols'),
+    limit: z
+      .number()
+      .int()
+      .min(1)
+      .max(500)
+      .optional()
+      .describe('Maximum formatted results, default 200'),
+    output_format: z.enum(['compact', 'json']).default('compact').optional(),
+  })
+  .superRefine((input, context) => {
+    if (
+      positionOperations.has(input.operation) &&
+      (!input.line || !input.character)
+    ) {
+      context.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `${input.operation} requires line and character`,
+      });
+    }
+    if (input.operation === 'workspaceSymbols' && !input.query?.trim()) {
+      context.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['query'],
+        message: 'workspaceSymbols requires a non-empty query',
+      });
+    }
+  });
 type LspInput = z.infer<typeof inputSchema>;
 
 function compact(value: unknown, limit: number): string {
@@ -41,34 +85,147 @@ function compact(value: unknown, limit: number): string {
     : text;
 }
 
-async function call(input: LspInput, cwd = getWorkingDir()): Promise<ToolResult> {
+function compactSemantic(value: unknown, cwd: string, limit: number): string {
+  if (value == null) return 'No results.';
+  const rows: string[] = [];
+  const walk = (item: any, label?: string) => {
+    if (item == null) return;
+    if (Array.isArray(item)) {
+      item.forEach((v) => walk(v, label));
+      return;
+    }
+    if (typeof item !== 'object') {
+      rows.push(String(item));
+      return;
+    }
+    const location = item.location ?? item.fromRanges?.[0] ?? item;
+    const uri = location.uri ?? location.targetUri ?? item.uri;
+    const range =
+      location.range ??
+      location.targetSelectionRange ??
+      item.range ??
+      item.selectionRange;
+    let where = '';
+    if (typeof uri === 'string') {
+      let path = uri;
+      try {
+        path = uri.startsWith('file:') ? fileURLToPath(uri) : uri;
+      } catch {}
+      const rel = relative(resolve(cwd), path);
+      where = (rel && !rel.startsWith('..') ? rel : path).split(sep).join('/');
+    }
+    if (range?.start)
+      where += `:${Number(range.start.line) + 1}:${Number(range.start.character) + 1}`;
+    const message =
+      item.message ?? item.name ?? item.detail ?? item.kind ?? label;
+    const severity = item.severity
+      ? `[${['', 'error', 'warning', 'info', 'hint'][item.severity] ?? item.severity}] `
+      : '';
+    const code = item.code !== undefined ? `(${String(item.code)}) ` : '';
+    if (where || message)
+      rows.push(
+        `${severity}${where || '<symbol>'} — ${code}${typeof message === 'string' ? message : JSON.stringify(message)}`,
+      );
+    if (item.contents) {
+      const contents = Array.isArray(item.contents)
+        ? item.contents
+        : [item.contents];
+      for (const c of contents)
+        rows.push(
+          typeof c === 'string'
+            ? c
+            : typeof c?.value === 'string'
+              ? c.value
+              : JSON.stringify(c),
+        );
+    }
+    if (item.from) walk(item.from, 'caller');
+    if (item.to) walk(item.to, 'callee');
+    if (Array.isArray(item.children))
+      item.children.forEach((v: any) => walk(v));
+  };
+  walk(value);
+  const unique = [...new Set(rows)].sort();
+  const selected = unique.slice(0, limit);
+  let text = selected.join('\n') || 'No results.';
+  if (unique.length > selected.length)
+    text += `\n... (${unique.length - selected.length} more; total=${unique.length})`;
+  return text.length > DEFAULT_MAX_RESULT_SIZE_CHARS
+    ? `${text.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS)}\n... (LSP result truncated)`
+    : text;
+}
+
+async function call(
+  input: LspInput,
+  cwd = getWorkingDir(),
+): Promise<ToolResult> {
   const filePath = resolve(cwd, input.file_path);
   const rel = relative(resolve(cwd), filePath);
   if (rel === '..' || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
     return { ok: false, error: `LSP 只处理当前工作区内的文件：${filePath}` };
   }
   const info = await stat(filePath).catch(() => null);
-  if (!info?.isFile()) return { ok: false, error: `LSP file does not exist: ${filePath}` };
-  if (info.size > 10_000_000) return { ok: false, error: 'LSP refuses files larger than 10 MB' };
+  if (!info?.isFile())
+    return { ok: false, error: `LSP file does not exist: ${filePath}` };
+  if (info.size > 10_000_000)
+    return { ok: false, error: 'LSP refuses files larger than 10 MB' };
   const server = getLspManager(cwd).serverFor(filePath);
-  if (!server) return { ok: false, error: `No configured LSP server handles ${filePath}` };
+  if (!server)
+    return { ok: false, error: `No configured LSP server handles ${filePath}` };
   try {
     await server.openFile(filePath);
     const uri = pathToFileURL(filePath).href;
-    const position = { line: (input.line ?? 1) - 1, character: (input.character ?? 1) - 1 };
+    const position = {
+      line: (input.line ?? 1) - 1,
+      character: (input.character ?? 1) - 1,
+    };
     let result: unknown;
     switch (input.operation) {
-      case 'goToDefinition': result = await server.request('textDocument/definition', { textDocument: { uri }, position }); break;
-      case 'findReferences': result = await server.request('textDocument/references', { textDocument: { uri }, position, context: { includeDeclaration: true } }); break;
-      case 'hover': result = await server.request('textDocument/hover', { textDocument: { uri }, position }); break;
-      case 'documentSymbols': result = await server.request('textDocument/documentSymbol', { textDocument: { uri } }); break;
-      case 'workspaceSymbols': result = await server.request('workspace/symbol', { query: input.query }); break;
-      case 'goToImplementation': result = await server.request('textDocument/implementation', { textDocument: { uri }, position }); break;
+      case 'goToDefinition':
+        result = await server.request('textDocument/definition', {
+          textDocument: { uri },
+          position,
+        });
+        break;
+      case 'findReferences':
+        result = await server.request('textDocument/references', {
+          textDocument: { uri },
+          position,
+          context: { includeDeclaration: true },
+        });
+        break;
+      case 'hover':
+        result = await server.request('textDocument/hover', {
+          textDocument: { uri },
+          position,
+        });
+        break;
+      case 'documentSymbols':
+        result = await server.request('textDocument/documentSymbol', {
+          textDocument: { uri },
+        });
+        break;
+      case 'workspaceSymbols':
+        result = await server.request('workspace/symbol', {
+          query: input.query,
+        });
+        break;
+      case 'goToImplementation':
+        result = await server.request('textDocument/implementation', {
+          textDocument: { uri },
+          position,
+        });
+        break;
       case 'incomingCalls':
       case 'outgoingCalls': {
-        const prepared = await server.request<unknown[]>('textDocument/prepareCallHierarchy', { textDocument: { uri }, position });
+        const prepared = await server.request<unknown[]>(
+          'textDocument/prepareCallHierarchy',
+          { textDocument: { uri }, position },
+        );
         const item = prepared?.[0];
-        result = item ? await server.request(`callHierarchy/${input.operation}`, { item }) : [];
+        result = item
+          ? await server.request(`callHierarchy/${input.operation}`, { item })
+          : [];
         break;
       }
       case 'diagnostics': {
@@ -78,9 +235,18 @@ async function call(input: LspInput, cwd = getWorkingDir()): Promise<ToolResult>
         break;
       }
     }
-    return { ok: true, content: compact(result, input.limit ?? 200) };
+    return {
+      ok: true,
+      content:
+        input.output_format === 'json'
+          ? compact(result, input.limit ?? 200)
+          : compactSemantic(result, cwd, input.limit ?? 200),
+    };
   } catch (error) {
-    return { ok: false, error: `LSP ${input.operation} failed: ${(error as Error).message}` };
+    return {
+      ok: false,
+      error: `LSP ${input.operation} failed: ${(error as Error).message}`,
+    };
   }
 }
 
@@ -97,8 +263,12 @@ export const lspTool: Tool<LspInput> = {
   maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
   resolveAvailability(runtime: AgentRuntimeContext) {
     const servers = discoverLspServers(runtime.cwd);
-    return { available: servers.length > 0, signature: lspAvailabilitySignature(runtime.cwd, servers) };
+    return {
+      available: servers.length > 0,
+      signature: lspAvailabilitySignature(runtime.cwd, servers),
+    };
   },
   call: (input) => call(input),
-  callWithContext: (input, _signal, context: ToolCallContext) => call(input, context.cwd),
+  callWithContext: (input, _signal, context: ToolCallContext) =>
+    call(input, context.cwd),
 };