@xortex/xcode 3.0.0

package/tools/LSPTool/schemas.ts

@@ -0,0 +1,215 @@
+import { z } from 'zod/v4'
+import { lazySchema } from '../../utils/lazySchema.js'
+
+/**
+ * Discriminated union of all LSP operations
+ * Uses 'operation' as the discriminator field
+ */
+export const lspToolInputSchema = lazySchema(() => {
+  /**
+   * Go to Definition operation
+   * Finds the definition location of a symbol at the given position
+   */
+  const goToDefinitionSchema = z.strictObject({
+    operation: z.literal('goToDefinition'),
+    filePath: z.string().describe('The absolute or relative path to the file'),
+    line: z
+      .number()
+      .int()
+      .positive()
+      .describe('The line number (1-based, as shown in editors)'),
+    character: z
+      .number()
+      .int()
+      .positive()
+      .describe('The character offset (1-based, as shown in editors)'),
+  })
+
+  /**
+   * Find References operation
+   * Finds all references to a symbol at the given position
+   */
+  const findReferencesSchema = z.strictObject({
+    operation: z.literal('findReferences'),
+    filePath: z.string().describe('The absolute or relative path to the file'),
+    line: z
+      .number()
+      .int()
+      .positive()
+      .describe('The line number (1-based, as shown in editors)'),
+    character: z
+      .number()
+      .int()
+      .positive()
+      .describe('The character offset (1-based, as shown in editors)'),
+  })
+
+  /**
+   * Hover operation
+   * Gets hover information (documentation, type info) for a symbol at the given position
+   */
+  const hoverSchema = z.strictObject({
+    operation: z.literal('hover'),
+    filePath: z.string().describe('The absolute or relative path to the file'),
+    line: z
+      .number()
+      .int()
+      .positive()
+      .describe('The line number (1-based, as shown in editors)'),
+    character: z
+      .number()
+      .int()
+      .positive()
+      .describe('The character offset (1-based, as shown in editors)'),
+  })
+
+  /**
+   * Document Symbol operation
+   * Gets all symbols (functions, classes, variables) in a document
+   */
+  const documentSymbolSchema = z.strictObject({
+    operation: z.literal('documentSymbol'),
+    filePath: z.string().describe('The absolute or relative path to the file'),
+    line: z
+      .number()
+      .int()
+      .positive()
+      .describe('The line number (1-based, as shown in editors)'),
+    character: z
+      .number()
+      .int()
+      .positive()
+      .describe('The character offset (1-based, as shown in editors)'),
+  })
+
+  /**
+   * Workspace Symbol operation
+   * Searches for symbols across the entire workspace
+   */
+  const workspaceSymbolSchema = z.strictObject({
+    operation: z.literal('workspaceSymbol'),
+    filePath: z.string().describe('The absolute or relative path to the file'),
+    line: z
+      .number()
+      .int()
+      .positive()
+      .describe('The line number (1-based, as shown in editors)'),
+    character: z
+      .number()
+      .int()
+      .positive()
+      .describe('The character offset (1-based, as shown in editors)'),
+  })
+
+  /**
+   * Go to Implementation operation
+   * Finds the implementation locations of an interface or abstract method
+   */
+  const goToImplementationSchema = z.strictObject({
+    operation: z.literal('goToImplementation'),
+    filePath: z.string().describe('The absolute or relative path to the file'),
+    line: z
+      .number()
+      .int()
+      .positive()
+      .describe('The line number (1-based, as shown in editors)'),
+    character: z
+      .number()
+      .int()
+      .positive()
+      .describe('The character offset (1-based, as shown in editors)'),
+  })
+
+  /**
+   * Prepare Call Hierarchy operation
+   * Prepares a call hierarchy item at the given position (first step for call hierarchy)
+   */
+  const prepareCallHierarchySchema = z.strictObject({
+    operation: z.literal('prepareCallHierarchy'),
+    filePath: z.string().describe('The absolute or relative path to the file'),
+    line: z
+      .number()
+      .int()
+      .positive()
+      .describe('The line number (1-based, as shown in editors)'),
+    character: z
+      .number()
+      .int()
+      .positive()
+      .describe('The character offset (1-based, as shown in editors)'),
+  })
+
+  /**
+   * Incoming Calls operation
+   * Finds all functions/methods that call the function at the given position
+   */
+  const incomingCallsSchema = z.strictObject({
+    operation: z.literal('incomingCalls'),
+    filePath: z.string().describe('The absolute or relative path to the file'),
+    line: z
+      .number()
+      .int()
+      .positive()
+      .describe('The line number (1-based, as shown in editors)'),
+    character: z
+      .number()
+      .int()
+      .positive()
+      .describe('The character offset (1-based, as shown in editors)'),
+  })
+
+  /**
+   * Outgoing Calls operation
+   * Finds all functions/methods called by the function at the given position
+   */
+  const outgoingCallsSchema = z.strictObject({
+    operation: z.literal('outgoingCalls'),
+    filePath: z.string().describe('The absolute or relative path to the file'),
+    line: z
+      .number()
+      .int()
+      .positive()
+      .describe('The line number (1-based, as shown in editors)'),
+    character: z
+      .number()
+      .int()
+      .positive()
+      .describe('The character offset (1-based, as shown in editors)'),
+  })
+
+  return z.discriminatedUnion('operation', [
+    goToDefinitionSchema,
+    findReferencesSchema,
+    hoverSchema,
+    documentSymbolSchema,
+    workspaceSymbolSchema,
+    goToImplementationSchema,
+    prepareCallHierarchySchema,
+    incomingCallsSchema,
+    outgoingCallsSchema,
+  ])
+})
+
+/**
+ * TypeScript type for LSPTool input
+ */
+export type LSPToolInput = z.infer<ReturnType<typeof lspToolInputSchema>>
+
+/**
+ * Type guard to check if an operation is a valid LSP operation
+ */
+export function isValidLSPOperation(
+  operation: string,
+): operation is LSPToolInput['operation'] {
+  return [
+    'goToDefinition',
+    'findReferences',
+    'hover',
+    'documentSymbol',
+    'workspaceSymbol',
+    'goToImplementation',
+    'prepareCallHierarchy',
+    'incomingCalls',
+    'outgoingCalls',
+  ].includes(operation)
+}

package/tools/LSPTool/symbolContext.ts

@@ -0,0 +1,90 @@
+import { logForDebugging } from '../../utils/debug.js'
+import { truncate } from '../../utils/format.js'
+import { getFsImplementation } from '../../utils/fsOperations.js'
+import { expandPath } from '../../utils/path.js'
+
+const MAX_READ_BYTES = 64 * 1024
+
+/**
+ * Extracts the symbol/word at a specific position in a file.
+ * Used to show context in tool use messages.
+ *
+ * @param filePath - The file path (absolute or relative)
+ * @param line - 0-indexed line number
+ * @param character - 0-indexed character position on the line
+ *
+ * Note: This uses synchronous file I/O because it is called from
+ * renderToolUseMessage (a synchronous React render function). The read is
+ * wrapped in try/catch so ENOENT and other errors fall back gracefully.
+ * @returns The symbol at that position, or null if extraction fails
+ */
+export function getSymbolAtPosition(
+  filePath: string,
+  line: number,
+  character: number,
+): string | null {
+  try {
+    const fs = getFsImplementation()
+    const absolutePath = expandPath(filePath)
+
+    // Read only the first 64KB instead of the whole file. Most LSP hover/goto
+    // targets are near recent edits; 64KB covers ~1000 lines of typical code.
+    // If the target line is past this window we fall back to null (the UI
+    // already handles that by showing `position: line:char`).
+    // eslint-disable-next-line custom-rules/no-sync-fs -- called from sync React render (renderToolUseMessage)
+    const { buffer, bytesRead } = fs.readSync(absolutePath, {
+      length: MAX_READ_BYTES,
+    })
+    const content = buffer.toString('utf-8', 0, bytesRead)
+    const lines = content.split('\n')
+
+    if (line < 0 || line >= lines.length) {
+      return null
+    }
+    // If we filled the full buffer the file continues past our window,
+    // so the last split element may be truncated mid-line.
+    if (bytesRead === MAX_READ_BYTES && line === lines.length - 1) {
+      return null
+    }
+
+    const lineContent = lines[line]
+    if (!lineContent || character < 0 || character >= lineContent.length) {
+      return null
+    }
+
+    // Extract the word/symbol at the character position
+    // Pattern matches:
+    // - Standard identifiers: alphanumeric + underscore + dollar
+    // - Rust lifetimes: 'a, 'static
+    // - Rust macros: macro_name!
+    // - Operators and special symbols: +, -, *, etc.
+    // This is more inclusive to handle various programming languages
+    const symbolPattern = /[\w$'!]+|[+\-*/%&|^~<>=]+/g
+    let match: RegExpExecArray | null
+
+    while ((match = symbolPattern.exec(lineContent)) !== null) {
+      const start = match.index
+      const end = start + match[0].length
+
+      // Check if the character position falls within this match
+      if (character >= start && character < end) {
+        const symbol = match[0]
+        // Limit length to 30 characters to avoid overly long symbols
+        return truncate(symbol, 30)
+      }
+    }
+
+    return null
+  } catch (error) {
+    // Log unexpected errors for debugging (permission issues, encoding problems, etc.)
+    // Use logForDebugging since this is a display enhancement, not a critical error
+    if (error instanceof Error) {
+      logForDebugging(
+        `Symbol extraction failed for ${filePath}:${line}:${character}: ${error.message}`,
+        { level: 'warn' },
+      )
+    }
+    // Still return null for graceful fallback to position display
+    return null
+  }
+}

package/tools/ListMcpResourcesTool/ListMcpResourcesTool.ts

@@ -0,0 +1,123 @@
+import { z } from 'zod/v4'
+import {
+  ensureConnectedClient,
+  fetchResourcesForClient,
+} from '../../services/mcp/client.js'
+import { buildTool, type ToolDef } from '../../Tool.js'
+import { errorMessage } from '../../utils/errors.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+import { logMCPError } from '../../utils/log.js'
+import { jsonStringify } from '../../utils/slowOperations.js'
+import { isOutputLineTruncated } from '../../utils/terminal.js'
+import { DESCRIPTION, LIST_MCP_RESOURCES_TOOL_NAME, PROMPT } from './prompt.js'
+import { renderToolResultMessage, renderToolUseMessage } from './UI.js'
+
+const inputSchema = lazySchema(() =>
+  z.object({
+    server: z
+      .string()
+      .optional()
+      .describe('Optional server name to filter resources by'),
+  }),
+)
+type InputSchema = ReturnType<typeof inputSchema>
+
+const outputSchema = lazySchema(() =>
+  z.array(
+    z.object({
+      uri: z.string().describe('Resource URI'),
+      name: z.string().describe('Resource name'),
+      mimeType: z.string().optional().describe('MIME type of the resource'),
+      description: z.string().optional().describe('Resource description'),
+      server: z.string().describe('Server that provides this resource'),
+    }),
+  ),
+)
+type OutputSchema = ReturnType<typeof outputSchema>
+
+export type Output = z.infer<OutputSchema>
+
+export const ListMcpResourcesTool = buildTool({
+  isConcurrencySafe() {
+    return true
+  },
+  isReadOnly() {
+    return true
+  },
+  toAutoClassifierInput(input) {
+    return input.server ?? ''
+  },
+  shouldDefer: true,
+  name: LIST_MCP_RESOURCES_TOOL_NAME,
+  searchHint: 'list resources from connected MCP servers',
+  maxResultSizeChars: 100_000,
+  async description() {
+    return DESCRIPTION
+  },
+  async prompt() {
+    return PROMPT
+  },
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+  get outputSchema(): OutputSchema {
+    return outputSchema()
+  },
+  async call(input, { options: { mcpClients } }) {
+    const { server: targetServer } = input
+
+    const clientsToProcess = targetServer
+      ? mcpClients.filter(client => client.name === targetServer)
+      : mcpClients
+
+    if (targetServer && clientsToProcess.length === 0) {
+      throw new Error(
+        `Server "${targetServer}" not found. Available servers: ${mcpClients.map(c => c.name).join(', ')}`,
+      )
+    }
+
+    // fetchResourcesForClient is LRU-cached (by server name) and already
+    // warm from startup prefetch. Cache is invalidated on onclose and on
+    // resources/list_changed notifications, so results are never stale.
+    // ensureConnectedClient is a no-op when healthy (memoize hit), but after
+    // onclose it returns a fresh connection so the re-fetch succeeds.
+    const results = await Promise.all(
+      clientsToProcess.map(async client => {
+        if (client.type !== 'connected') return []
+        try {
+          const fresh = await ensureConnectedClient(client)
+          return await fetchResourcesForClient(fresh)
+        } catch (error) {
+          // One server's reconnect failure shouldn't sink the whole result.
+          logMCPError(client.name, errorMessage(error))
+          return []
+        }
+      }),
+    )
+
+    return {
+      data: results.flat(),
+    }
+  },
+  renderToolUseMessage,
+  userFacingName: () => 'listMcpResources',
+  renderToolResultMessage,
+  isResultTruncated(output: Output): boolean {
+    return isOutputLineTruncated(jsonStringify(output))
+  },
+  mapToolResultToToolResultBlockParam(content, toolUseID) {
+    if (!content || content.length === 0) {
+      return {
+        tool_use_id: toolUseID,
+        type: 'tool_result',
+        content:
+          'No resources found. MCP servers may still provide tools even if they have no resources.',
+      }
+    }
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result',
+      content: jsonStringify(content),
+    }
+  },
+} satisfies ToolDef<InputSchema, Output>)

package/tools/ListMcpResourcesTool/UI.tsx

@@ -0,0 +1,29 @@
+import * as React from 'react';
+import { MessageResponse } from '../../components/MessageResponse.js';
+import { OutputLine } from '../../components/shell/OutputLine.js';
+import { Text } from '../../ink.js';
+import type { ToolProgressData } from '../../Tool.js';
+import type { ProgressMessage } from '../../types/message.js';
+import { jsonStringify } from '../../utils/slowOperations.js';
+import type { Output } from './ListMcpResourcesTool.js';
+export function renderToolUseMessage(input: Partial<{
+  server?: string;
+}>): React.ReactNode {
+  return input.server ? `List MCP resources from server "${input.server}"` : `List all MCP resources`;
+}
+export function renderToolResultMessage(output: Output, _progressMessagesForMessage: ProgressMessage<ToolProgressData>[], {
+  verbose
+}: {
+  verbose: boolean;
+}): React.ReactNode {
+  if (!output || output.length === 0) {
+    return <MessageResponse height={1}>
+        <Text dimColor>(No resources found)</Text>
+      </MessageResponse>;
+  }
+
+  // eslint-disable-next-line no-restricted-syntax -- human-facing UI, not tool_result
+  const formattedOutput = jsonStringify(output, null, 2);
+  return <OutputLine content={formattedOutput} verbose={verbose} />;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/tools/ListMcpResourcesTool/prompt.ts

@@ -0,0 +1,20 @@
+export const LIST_MCP_RESOURCES_TOOL_NAME = 'ListMcpResourcesTool'
+
+export const DESCRIPTION = `
+Lists available resources from configured MCP servers.
+Each resource object includes a 'server' field indicating which server it's from.
+
+Usage examples:
+- List all resources from all servers: \`listMcpResources\`
+- List resources from a specific server: \`listMcpResources({ server: "myserver" })\`
+`
+
+export const PROMPT = `
+List available resources from configured MCP servers.
+Each returned resource will include all standard MCP resource fields plus a 'server' field 
+indicating which server the resource belongs to.
+
+Parameters:
+- server (optional): The name of a specific MCP server to get resources from. If not provided,
+  resources from all servers will be returned.
+`

package/tools/MCPTool/MCPTool.ts

@@ -0,0 +1,77 @@
+import { z } from 'zod/v4'
+import { buildTool, type ToolDef } from '../../Tool.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+import type { PermissionResult } from '../../utils/permissions/PermissionResult.js'
+import { isOutputLineTruncated } from '../../utils/terminal.js'
+import { DESCRIPTION, PROMPT } from './prompt.js'
+import {
+  renderToolResultMessage,
+  renderToolUseMessage,
+  renderToolUseProgressMessage,
+} from './UI.js'
+
+// Allow any input object since MCP tools define their own schemas
+export const inputSchema = lazySchema(() => z.object({}).passthrough())
+type InputSchema = ReturnType<typeof inputSchema>
+
+export const outputSchema = lazySchema(() =>
+  z.string().describe('MCP tool execution result'),
+)
+type OutputSchema = ReturnType<typeof outputSchema>
+
+export type Output = z.infer<OutputSchema>
+
+// Re-export MCPProgress from centralized types to break import cycles
+export type { MCPProgress } from '../../types/tools.js'
+
+export const MCPTool = buildTool({
+  isMcp: true,
+  // Overridden in mcpClient.ts with the real MCP tool name + args
+  isOpenWorld() {
+    return false
+  },
+  // Overridden in mcpClient.ts
+  name: 'mcp',
+  maxResultSizeChars: 100_000,
+  // Overridden in mcpClient.ts
+  async description() {
+    return DESCRIPTION
+  },
+  // Overridden in mcpClient.ts
+  async prompt() {
+    return PROMPT
+  },
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+  get outputSchema(): OutputSchema {
+    return outputSchema()
+  },
+  // Overridden in mcpClient.ts
+  async call() {
+    return {
+      data: '',
+    }
+  },
+  async checkPermissions(): Promise<PermissionResult> {
+    return {
+      behavior: 'passthrough',
+      message: 'MCPTool requires permission.',
+    }
+  },
+  renderToolUseMessage,
+  // Overridden in mcpClient.ts
+  userFacingName: () => 'mcp',
+  renderToolUseProgressMessage,
+  renderToolResultMessage,
+  isResultTruncated(output: Output): boolean {
+    return isOutputLineTruncated(output)
+  },
+  mapToolResultToToolResultBlockParam(content, toolUseID) {
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result',
+      content,
+    }
+  },
+} satisfies ToolDef<InputSchema, Output>)