minimal-agent 0.11.0 → 0.12.0

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),
 };

package/src/tools/powershell/powershell.js

@@ -11,6 +11,8 @@ import { killTree } from '../shared/killTree.js';
 import { startBackgroundTask } from '../tasks/backgroundTaskService.js';
 import { processExecutionMetadata } from '../tasks/processEvidence.js';
 import { DEFAULT_MAX_RESULT_SIZE_CHARS } from '../types.js';
+import { permanentDeleteReason } from '../shared/permanentDeleteGuard.js';
+import { ToolOutputStore } from '../shared/toolOutputStore.js';
 const MAX_TIMEOUT_MS = 600_000;
 function findPowerShell() {
     if (process.platform !== 'win32')
@@ -35,23 +37,42 @@ const inputSchema = z.object({
     run_in_background: z.boolean().optional(),
 });
 function invocation(command) {
-    return ['-NoLogo', '-NoProfile', '-NonInteractive', '-Command', `$OutputEncoding=[Console]::OutputEncoding=[Text.UTF8Encoding]::new(); ${command}`];
+    return [
+        '-NoLogo',
+        '-NoProfile',
+        '-NonInteractive',
+        '-Command',
+        `$OutputEncoding=[Console]::OutputEncoding=[Text.UTF8Encoding]::new(); ${command}`,
+    ];
 }
 async function approved(command, signal) {
+    const permanentDelete = permanentDeleteReason(command, 'powershell');
+    if (permanentDelete)
+        return {
+            ok: false,
+            error: `永久删除检查拒绝执行：${permanentDelete}\n命令：${command}`,
+        };
     const forbidden = checkForbidden(command);
     if (forbidden)
-        return { ok: false, error: `安全检查拒绝执行：${forbidden}\n命令：${command}` };
+        return {
+            ok: false,
+            error: `安全检查拒绝执行：${forbidden}\n命令：${command}`,
+        };
     const irreversible = classifyCommand(command);
     if (!irreversible)
         return undefined;
-    const [answer] = await requestUserChoice([{
-            question: `这条命令不可逆：${irreversible.why}。\n\n命令：${command}\n\n确认执行吗？`, header: '不可逆操作',
+    const [answer] = await requestUserChoice([
+        {
+            question: `这条命令不可逆：${irreversible.why}。\n\n命令：${command}\n\n确认执行吗？`,
+            header: '不可逆操作',
             options: [
                 { label: '取消，不执行 (推荐)', description: '放弃并改用可回滚做法' },
                 { label: '我已确认后果，执行', description: '继续执行不可逆操作' },
             ],
-        }], signal);
-    return answer?.selected?.[0]?.includes('执行') && !answer.selected[0]?.includes('取消')
+        },
+    ], signal);
+    return answer?.selected?.[0]?.includes('执行') &&
+        !answer.selected[0]?.includes('取消')
         ? undefined
         : { ok: false, error: `已拒绝执行不可逆 PowerShell 命令：${command}` };
 }
@@ -66,39 +87,105 @@ async function call(input, signal, context) {
     const cwd = context?.cwd ?? getWorkingDir();
     if (input.run_in_background) {
         try {
-            const task = await startBackgroundTask({ command: input.command, executable, args, cwd, env: sanitizedChildEnv(), sessionId: context?.sessionId, shellKind: 'powershell' }, context?.sessionState?.backgroundTasks);
+            const task = await startBackgroundTask({
+                command: input.command,
+                executable,
+                args,
+                cwd,
+                env: sanitizedChildEnv(),
+                sessionId: context?.sessionId,
+                workspaceId: context?.workspaceId,
+                shellKind: 'powershell',
+            }, context?.sessionState?.backgroundTasks);
             return {
                 ok: true,
-                content: `PowerShell 后台任务已启动。task_id=${task.id}\nlog=${task.logPath}`,
-                metadata: processExecutionMetadata({ shell: 'powershell', mode: 'background', command: input.command, status: 'started', taskId: task.id }),
+                content: `PowerShell 后台任务已启动。task_id=${task.id.replace(/^proc_/, '')}\nprocess_id=${task.id}\nlog=${task.logPath}`,
+                metadata: processExecutionMetadata({
+                    shell: 'powershell',
+                    mode: 'background',
+                    command: input.command,
+                    status: 'started',
+                    taskId: task.id,
+                }),
             };
         }
         catch (error) {
-            return { ok: false, error: `PowerShell 后台任务启动失败：${error.message}` };
+            return {
+                ok: false,
+                error: `PowerShell 后台任务启动失败：${error.message}`,
+            };
         }
     }
     return await new Promise((resolvePromise) => {
-        const child = spawn(executable, args, { cwd, env: sanitizedChildEnv(), windowsHide: true, detached: false });
-        let stdout = '';
-        let stderr = '';
+        const child = spawn(executable, args, {
+            cwd,
+            env: sanitizedChildEnv(),
+            windowsHide: true,
+            detached: false,
+        });
         let finished = false;
-        const finish = (result) => { if (finished)
-            return; finished = true; clearTimeout(timer); signal?.removeEventListener('abort', abort); resolvePromise(result); };
-        const abort = () => { killTree(child); finish({ ok: false, error: `PowerShell 命令被中断\n${stdout}\n${stderr}`.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS), metadata: processExecutionMetadata({ shell: 'powershell', mode: 'foreground', command: input.command, status: 'stopped', exitCode: null }) }); };
+        const store = new ToolOutputStore({
+            workspaceId: context?.workspaceId,
+            sessionId: context?.sessionId,
+        });
+        const finish = async (status, code, prefix = '') => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', abort);
+            const output = await store.finish();
+            const reference = output.path
+                ? `\n[完整输出: ${output.path}; bytes=${output.bytes}; sha256=${output.sha256}; complete=${output.complete}]`
+                : '';
+            let text = `${prefix}${output.stdout ? `<stdout>\n${output.stdout.trimEnd()}\n</stdout>\n` : ''}${output.stderr ? `<stderr>\n${output.stderr.trimEnd()}\n</stderr>\n` : ''}[exit code: ${code ?? 'killed'}]`;
+            if (text.length + reference.length > DEFAULT_MAX_RESULT_SIZE_CHARS) {
+                const suffix = `\n... (输出预览已截断)${reference}`;
+                text =
+                    text.slice(0, Math.max(0, DEFAULT_MAX_RESULT_SIZE_CHARS - suffix.length)) + suffix;
+            }
+            else
+                text += reference;
+            const metadata = processExecutionMetadata({
+                shell: 'powershell',
+                mode: 'foreground',
+                command: input.command,
+                status,
+                exitCode: code,
+            });
+            resolvePromise(status === 'completed'
+                ? { ok: true, content: text, metadata }
+                : { ok: false, error: text, metadata });
+        };
+        const abort = () => {
+            killTree(child);
+            void finish('stopped', null, 'PowerShell 命令被中断\n');
+        };
         const timeout = input.timeout ?? 120_000;
-        const timer = setTimeout(() => { killTree(child); finish({ ok: false, error: `PowerShell 命令超时（${timeout}ms）\n${stdout}\n${stderr}`.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS), metadata: processExecutionMetadata({ shell: 'powershell', mode: 'foreground', command: input.command, status: 'failed', exitCode: null }) }); }, timeout);
+        const timer = setTimeout(() => {
+            killTree(child);
+            void finish('failed', null, `PowerShell 命令超时（${timeout}ms）\n`);
+        }, timeout);
         signal?.addEventListener('abort', abort, { once: true });
         child.stdout?.setEncoding('utf8');
         child.stderr?.setEncoding('utf8');
-        child.stdout?.on('data', (chunk) => { if (stdout.length < DEFAULT_MAX_RESULT_SIZE_CHARS * 2)
-            stdout += chunk; });
-        child.stderr?.on('data', (chunk) => { if (stderr.length < DEFAULT_MAX_RESULT_SIZE_CHARS * 2)
-            stderr += chunk; });
-        child.once('error', (error) => finish({ ok: false, error: `PowerShell 启动失败：${error.message}`, metadata: processExecutionMetadata({ shell: 'powershell', mode: 'foreground', command: input.command, status: 'failed', exitCode: null }) }));
+        child.stdout?.on('data', (chunk) => {
+            if (!store.append('stdout', chunk)) {
+                child.stdout?.pause();
+                store.onDrain(() => child.stdout?.resume());
+            }
+        });
+        child.stderr?.on('data', (chunk) => {
+            if (!store.append('stderr', chunk)) {
+                child.stderr?.pause();
+                store.onDrain(() => child.stderr?.resume());
+            }
+        });
+        child.once('error', (error) => {
+            void finish('failed', null, `PowerShell 启动失败：${error.message}\n`);
+        });
         child.once('close', (code) => {
-            const text = `${stdout ? `<stdout>\n${stdout.trimEnd()}\n</stdout>\n` : ''}${stderr ? `<stderr>\n${stderr.trimEnd()}\n</stderr>\n` : ''}[exit code: ${code}]`.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS);
-            const metadata = processExecutionMetadata({ shell: 'powershell', mode: 'foreground', command: input.command, status: code === 0 ? 'completed' : 'failed', exitCode: code });
-            finish(code === 0 ? { ok: true, content: text, metadata } : { ok: false, error: text, metadata });
+            void finish(code === 0 ? 'completed' : 'failed', code);
         });
     });
 }
@@ -113,7 +200,10 @@ export const powerShellTool = {
     interruptBehavior: () => 'block',
     resolveAvailability: () => {
         const executable = findPowerShell();
-        return { available: Boolean(executable), signature: executable ?? 'unavailable' };
+        return {
+            available: Boolean(executable),
+            signature: executable ?? 'unavailable',
+        };
     },
     call: (input, signal) => call(input, signal),
     callWithContext: (input, signal, context) => call(input, signal, context),