subagent-cli 0.3.0 → 0.3.1

package/src/services/lsp/manager.ts

@@ -1,289 +0,0 @@
-import { logForDebugging } from '../../utils/debug.js'
-import { isBareMode } from '../../utils/envUtils.js'
-import { errorMessage } from '../../utils/errors.js'
-import { logError } from '../../utils/log.js'
-import {
-  createLSPServerManager,
-  type LSPServerManager,
-} from './LSPServerManager.js'
-import { registerLSPNotificationHandlers } from './passiveFeedback.js'
-
-/**
- * Initialization state of the LSP server manager
- */
-type InitializationState = 'not-started' | 'pending' | 'success' | 'failed'
-
-/**
- * Global singleton instance of the LSP server manager.
- * Initialized during Claude Code startup.
- */
-let lspManagerInstance: LSPServerManager | undefined
-
-/**
- * Current initialization state
- */
-let initializationState: InitializationState = 'not-started'
-
-/**
- * Error from last initialization attempt, if any
- */
-let initializationError: Error | undefined
-
-/**
- * Generation counter to prevent stale initialization promises from updating state
- */
-let initializationGeneration = 0
-
-/**
- * Promise that resolves when initialization completes (success or failure)
- */
-let initializationPromise: Promise<void> | undefined
-
-/**
- * Test-only sync reset. shutdownLspServerManager() is async and tears down
- * real connections; this only clears the module-scope singleton state so
- * reinitializeLspServerManager() early-returns on 'not-started' in downstream
- * tests on the same shard.
- */
-export function _resetLspManagerForTesting(): void {
-  initializationState = 'not-started'
-  initializationError = undefined
-  initializationPromise = undefined
-  initializationGeneration++
-}
-
-/**
- * Get the singleton LSP server manager instance.
- * Returns undefined if not yet initialized, initialization failed, or still pending.
- *
- * Callers should check for undefined and handle gracefully, as initialization happens
- * asynchronously during Claude Code startup. Use getInitializationStatus() to
- * distinguish between pending, failed, and not-started states.
- */
-export function getLspServerManager(): LSPServerManager | undefined {
-  // Don't return a broken instance if initialization failed
-  if (initializationState === 'failed') {
-    return undefined
-  }
-  return lspManagerInstance
-}
-
-/**
- * Get the current initialization status of the LSP server manager.
- *
- * @returns Status object with current state and error (if failed)
- */
-export function getInitializationStatus():
-  | { status: 'not-started' }
-  | { status: 'pending' }
-  | { status: 'success' }
-  | { status: 'failed'; error: Error } {
-  if (initializationState === 'failed') {
-    return {
-      status: 'failed',
-      error: initializationError || new Error('Initialization failed'),
-    }
-  }
-  if (initializationState === 'not-started') {
-    return { status: 'not-started' }
-  }
-  if (initializationState === 'pending') {
-    return { status: 'pending' }
-  }
-  return { status: 'success' }
-}
-
-/**
- * Check whether at least one language server is connected and healthy.
- * Backs LSPTool.isEnabled().
- */
-export function isLspConnected(): boolean {
-  if (initializationState === 'failed') return false
-  const manager = getLspServerManager()
-  if (!manager) return false
-  const servers = manager.getAllServers()
-  if (servers.size === 0) return false
-  for (const server of servers.values()) {
-    if (server.state !== 'error') return true
-  }
-  return false
-}
-
-/**
- * Wait for LSP server manager initialization to complete.
- *
- * Returns immediately if initialization has already completed (success or failure).
- * If initialization is pending, waits for it to complete.
- * If initialization hasn't started, returns immediately.
- *
- * @returns Promise that resolves when initialization is complete
- */
-export async function waitForInitialization(): Promise<void> {
-  // If already initialized or failed, return immediately
-  if (initializationState === 'success' || initializationState === 'failed') {
-    return
-  }
-
-  // If pending and we have a promise, wait for it
-  if (initializationState === 'pending' && initializationPromise) {
-    await initializationPromise
-  }
-
-  // If not started, return immediately (nothing to wait for)
-}
-
-/**
- * Initialize the LSP server manager singleton.
- *
- * This function is called during Claude Code startup. It synchronously creates
- * the manager instance, then starts async initialization (loading LSP configs)
- * in the background without blocking the startup process.
- *
- * Safe to call multiple times - will only initialize once (idempotent).
- * However, if initialization previously failed, calling again will retry.
- */
-export function initializeLspServerManager(): void {
-  // --bare / SIMPLE: no LSP. LSP is for editor integration (diagnostics,
-  // hover, go-to-def in the REPL). Scripted -p calls have no use for it.
-  if (isBareMode()) {
-    return
-  }
-  logForDebugging('[LSP MANAGER] initializeLspServerManager() called')
-
-  // Skip if already initialized or currently initializing
-  if (lspManagerInstance !== undefined && initializationState !== 'failed') {
-    logForDebugging(
-      '[LSP MANAGER] Already initialized or initializing, skipping',
-    )
-    return
-  }
-
-  // Reset state for retry if previous initialization failed
-  if (initializationState === 'failed') {
-    lspManagerInstance = undefined
-    initializationError = undefined
-  }
-
-  // Create the manager instance and mark as pending
-  lspManagerInstance = createLSPServerManager()
-  initializationState = 'pending'
-  logForDebugging('[LSP MANAGER] Created manager instance, state=pending')
-
-  // Increment generation to invalidate any pending initializations
-  const currentGeneration = ++initializationGeneration
-  logForDebugging(
-    `[LSP MANAGER] Starting async initialization (generation ${currentGeneration})`,
-  )
-
-  // Start initialization asynchronously without blocking
-  // Store the promise so callers can await it via waitForInitialization()
-  initializationPromise = lspManagerInstance
-    .initialize()
-    .then(() => {
-      // Only update state if this is still the current initialization
-      if (currentGeneration === initializationGeneration) {
-        initializationState = 'success'
-        logForDebugging('LSP server manager initialized successfully')
-
-        // Register passive notification handlers for diagnostics
-        if (lspManagerInstance) {
-          registerLSPNotificationHandlers(lspManagerInstance)
-        }
-      }
-    })
-    .catch((error: unknown) => {
-      // Only update state if this is still the current initialization
-      if (currentGeneration === initializationGeneration) {
-        initializationState = 'failed'
-        initializationError = error as Error
-        // Clear the instance since it's not usable
-        lspManagerInstance = undefined
-
-        logError(error as Error)
-        logForDebugging(
-          `Failed to initialize LSP server manager: ${errorMessage(error)}`,
-        )
-      }
-    })
-}
-
-/**
- * Force re-initialization of the LSP server manager, even after a prior
- * successful init. Called from refreshActivePlugins() after plugin caches
- * are cleared, so newly-loaded plugin LSP servers are picked up.
- *
- * Fixes https://github.com/anthropics/claude-code/issues/15521:
- * loadAllPlugins() is memoized and can be called very early in startup
- * (via getCommands prefetch in setup.ts) before marketplaces are reconciled,
- * caching an empty plugin list. initializeLspServerManager() then reads that
- * stale memoized result and initializes with 0 servers. Unlike commands/agents/
- * hooks/MCP, LSP was never re-initialized on plugin refresh.
- *
- * Safe to call when no LSP plugins changed: initialize() is just config
- * parsing (servers are lazy-started on first use). Also safe during pending
- * init: the generation counter invalidates the in-flight promise.
- */
-export function reinitializeLspServerManager(): void {
-  if (initializationState === 'not-started') {
-    // initializeLspServerManager() was never called (e.g. headless subcommand
-    // path). Don't start it now.
-    return
-  }
-
-  logForDebugging('[LSP MANAGER] reinitializeLspServerManager() called')
-
-  // Best-effort shutdown of any running servers on the old instance so
-  // /reload-plugins doesn't leak child processes. Fire-and-forget: the
-  // primary use case (issue #15521) has 0 servers so this is usually a no-op.
-  if (lspManagerInstance) {
-    void lspManagerInstance.shutdown().catch(err => {
-      logForDebugging(
-        `[LSP MANAGER] old instance shutdown during reinit failed: ${errorMessage(err)}`,
-      )
-    })
-  }
-
-  // Force the idempotence check in initializeLspServerManager() to fall
-  // through. Generation counter handles invalidating any in-flight init.
-  lspManagerInstance = undefined
-  initializationState = 'not-started'
-  initializationError = undefined
-
-  initializeLspServerManager()
-}
-
-/**
- * Shutdown the LSP server manager and clean up resources.
- *
- * This should be called during Claude Code shutdown. Stops all running LSP servers
- * and clears internal state. Safe to call when not initialized (no-op).
- *
- * NOTE: Errors during shutdown are logged for monitoring but NOT propagated to the caller.
- * State is always cleared even if shutdown fails, to prevent resource accumulation.
- * This is acceptable during application exit when recovery is not possible.
- *
- * @returns Promise that resolves when shutdown completes (errors are swallowed)
- */
-export async function shutdownLspServerManager(): Promise<void> {
-  if (lspManagerInstance === undefined) {
-    return
-  }
-
-  try {
-    await lspManagerInstance.shutdown()
-    logForDebugging('LSP server manager shut down successfully')
-  } catch (error: unknown) {
-    logError(error as Error)
-    logForDebugging(
-      `Failed to shutdown LSP server manager: ${errorMessage(error)}`,
-    )
-  } finally {
-    // Always clear state even if shutdown failed
-    lspManagerInstance = undefined
-    initializationState = 'not-started'
-    initializationError = undefined
-    initializationPromise = undefined
-    // Increment generation to invalidate any pending initializations
-    initializationGeneration++
-  }
-}

package/src/services/lsp/passiveFeedback.ts

@@ -1,328 +0,0 @@
-import { fileURLToPath } from 'url'
-import type { PublishDiagnosticsParams } from 'vscode-languageserver-protocol'
-import { logForDebugging } from '../../utils/debug.js'
-import { toError } from '../../utils/errors.js'
-import { logError } from '../../utils/log.js'
-import { jsonStringify } from '../../utils/slowOperations.js'
-import type { DiagnosticFile } from '../diagnosticTracking.js'
-import { registerPendingLSPDiagnostic } from './LSPDiagnosticRegistry.js'
-import type { LSPServerManager } from './LSPServerManager.js'
-
-/**
- * Map LSP severity to Claude diagnostic severity
- *
- * Maps LSP severity numbers to Claude diagnostic severity strings.
- * Accepts numeric severity values (1=Error, 2=Warning, 3=Information, 4=Hint)
- * or undefined, defaulting to 'Error' for invalid/missing values.
- */
-function mapLSPSeverity(
-  lspSeverity: number | undefined,
-): 'Error' | 'Warning' | 'Info' | 'Hint' {
-  // LSP DiagnosticSeverity enum:
-  // 1 = Error, 2 = Warning, 3 = Information, 4 = Hint
-  switch (lspSeverity) {
-    case 1:
-      return 'Error'
-    case 2:
-      return 'Warning'
-    case 3:
-      return 'Info'
-    case 4:
-      return 'Hint'
-    default:
-      return 'Error'
-  }
-}
-
-/**
- * Convert LSP diagnostics to Claude diagnostic format
- *
- * Converts LSP PublishDiagnosticsParams to DiagnosticFile[] format
- * used by Claude's attachment system.
- */
-export function formatDiagnosticsForAttachment(
-  params: PublishDiagnosticsParams,
-): DiagnosticFile[] {
-  // Parse URI (may be file:// or plain path) and normalize to file system path
-  let uri: string
-  try {
-    // Handle both file:// URIs and plain paths
-    uri = params.uri.startsWith('file://')
-      ? fileURLToPath(params.uri)
-      : params.uri
-  } catch (error) {
-    const err = toError(error)
-    logError(err)
-    logForDebugging(
-      `Failed to convert URI to file path: ${params.uri}. Error: ${err.message}. Using original URI as fallback.`,
-    )
-    // Gracefully fallback to original URI - LSP servers may send malformed URIs
-    uri = params.uri
-  }
-
-  const diagnostics = params.diagnostics.map(
-    (diag: {
-      message: string
-      severity?: number
-      range: {
-        start: { line: number; character: number }
-        end: { line: number; character: number }
-      }
-      source?: string
-      code?: string | number
-    }) => ({
-      message: diag.message,
-      severity: mapLSPSeverity(diag.severity),
-      range: {
-        start: {
-          line: diag.range.start.line,
-          character: diag.range.start.character,
-        },
-        end: {
-          line: diag.range.end.line,
-          character: diag.range.end.character,
-        },
-      },
-      source: diag.source,
-      code:
-        diag.code !== undefined && diag.code !== null
-          ? String(diag.code)
-          : undefined,
-    }),
-  )
-
-  return [
-    {
-      uri,
-      diagnostics,
-    },
-  ]
-}
-
-/**
- * Handler registration result with tracking data
- */
-export type HandlerRegistrationResult = {
-  /** Total number of servers */
-  totalServers: number
-  /** Number of successful registrations */
-  successCount: number
-  /** Registration errors per server */
-  registrationErrors: Array<{ serverName: string; error: string }>
-  /** Runtime failure tracking (shared across all handler invocations) */
-  diagnosticFailures: Map<string, { count: number; lastError: string }>
-}
-
-/**
- * Register LSP notification handlers on all servers
- *
- * Sets up handlers to listen for textDocument/publishDiagnostics notifications
- * from all LSP servers and routes them to Claude's diagnostic system.
- * Uses public getAllServers() API for clean access to server instances.
- *
- * @returns Tracking data for registration status and runtime failures
- */
-export function registerLSPNotificationHandlers(
-  manager: LSPServerManager,
-): HandlerRegistrationResult {
-  // Register handlers on all configured servers to capture diagnostics from any language
-  const servers = manager.getAllServers()
-
-  // Track partial failures - allow successful server registrations even if some fail
-  const registrationErrors: Array<{ serverName: string; error: string }> = []
-  let successCount = 0
-
-  // Track consecutive failures per server to warn users after 3+ failures
-  const diagnosticFailures: Map<string, { count: number; lastError: string }> =
-    new Map()
-
-  for (const [serverName, serverInstance] of servers.entries()) {
-    try {
-      // Validate server instance has onNotification method
-      if (
-        !serverInstance ||
-        typeof serverInstance.onNotification !== 'function'
-      ) {
-        const errorMsg = !serverInstance
-          ? 'Server instance is null/undefined'
-          : 'Server instance has no onNotification method'
-
-        registrationErrors.push({ serverName, error: errorMsg })
-
-        const err = new Error(`${errorMsg} for ${serverName}`)
-        logError(err)
-        logForDebugging(
-          `Skipping handler registration for ${serverName}: ${errorMsg}`,
-        )
-        continue // Skip this server but track the failure
-      }
-
-      // Errors are isolated to avoid breaking other servers
-      serverInstance.onNotification(
-        'textDocument/publishDiagnostics',
-        (params: unknown) => {
-          logForDebugging(
-            `[PASSIVE DIAGNOSTICS] Handler invoked for ${serverName}! Params type: ${typeof params}`,
-          )
-          try {
-            // Validate params structure before casting
-            if (
-              !params ||
-              typeof params !== 'object' ||
-              !('uri' in params) ||
-              !('diagnostics' in params)
-            ) {
-              const err = new Error(
-                `LSP server ${serverName} sent invalid diagnostic params (missing uri or diagnostics)`,
-              )
-              logError(err)
-              logForDebugging(
-                `Invalid diagnostic params from ${serverName}: ${jsonStringify(params)}`,
-              )
-              return
-            }
-
-            const diagnosticParams = params as PublishDiagnosticsParams
-            logForDebugging(
-              `Received diagnostics from ${serverName}: ${diagnosticParams.diagnostics.length} diagnostic(s) for ${diagnosticParams.uri}`,
-            )
-
-            // Convert LSP diagnostics to Claude format (can throw on invalid URIs)
-            const diagnosticFiles =
-              formatDiagnosticsForAttachment(diagnosticParams)
-
-            // Only send notification if there are diagnostics
-            const firstFile = diagnosticFiles[0]
-            if (
-              !firstFile ||
-              diagnosticFiles.length === 0 ||
-              firstFile.diagnostics.length === 0
-            ) {
-              logForDebugging(
-                `Skipping empty diagnostics from ${serverName} for ${diagnosticParams.uri}`,
-              )
-              return
-            }
-
-            // Register diagnostics for async delivery via attachment system
-            // Follows same pattern as AsyncHookRegistry for consistent async attachment delivery
-            try {
-              registerPendingLSPDiagnostic({
-                serverName,
-                files: diagnosticFiles,
-              })
-
-              logForDebugging(
-                `LSP Diagnostics: Registered ${diagnosticFiles.length} diagnostic file(s) from ${serverName} for async delivery`,
-              )
-
-              // Success - reset failure counter for this server
-              diagnosticFailures.delete(serverName)
-            } catch (error) {
-              const err = toError(error)
-              logError(err)
-              logForDebugging(
-                `Error registering LSP diagnostics from ${serverName}: ` +
-                  `URI: ${diagnosticParams.uri}, ` +
-                  `Diagnostic count: ${firstFile.diagnostics.length}, ` +
-                  `Error: ${err.message}`,
-              )
-
-              // Track consecutive failures and warn after 3+
-              const failures = diagnosticFailures.get(serverName) || {
-                count: 0,
-                lastError: '',
-              }
-              failures.count++
-              failures.lastError = err.message
-              diagnosticFailures.set(serverName, failures)
-
-              if (failures.count >= 3) {
-                logForDebugging(
-                  `WARNING: LSP diagnostic handler for ${serverName} has failed ${failures.count} times consecutively. ` +
-                    `Last error: ${failures.lastError}. ` +
-                    `This may indicate a problem with the LSP server or diagnostic processing. ` +
-                    `Check logs for details.`,
-                )
-              }
-            }
-          } catch (error) {
-            // Catch any unexpected errors from the entire handler to prevent breaking the notification loop
-            const err = toError(error)
-            logError(err)
-            logForDebugging(
-              `Unexpected error processing diagnostics from ${serverName}: ${err.message}`,
-            )
-
-            // Track consecutive failures and warn after 3+
-            const failures = diagnosticFailures.get(serverName) || {
-              count: 0,
-              lastError: '',
-            }
-            failures.count++
-            failures.lastError = err.message
-            diagnosticFailures.set(serverName, failures)
-
-            if (failures.count >= 3) {
-              logForDebugging(
-                `WARNING: LSP diagnostic handler for ${serverName} has failed ${failures.count} times consecutively. ` +
-                  `Last error: ${failures.lastError}. ` +
-                  `This may indicate a problem with the LSP server or diagnostic processing. ` +
-                  `Check logs for details.`,
-              )
-            }
-
-            // Don't re-throw - isolate errors to this server only
-          }
-        },
-      )
-
-      logForDebugging(`Registered diagnostics handler for ${serverName}`)
-      successCount++
-    } catch (error) {
-      const err = toError(error)
-
-      registrationErrors.push({
-        serverName,
-        error: err.message,
-      })
-
-      logError(err)
-      logForDebugging(
-        `Failed to register diagnostics handler for ${serverName}: ` +
-          `Error: ${err.message}`,
-      )
-    }
-  }
-
-  // Report overall registration status
-  const totalServers = servers.size
-  if (registrationErrors.length > 0) {
-    const failedServers = registrationErrors
-      .map(e => `${e.serverName} (${e.error})`)
-      .join(', ')
-    // Log aggregate failures for tracking
-    logError(
-      new Error(
-        `Failed to register diagnostics for ${registrationErrors.length} LSP server(s): ${failedServers}`,
-      ),
-    )
-    logForDebugging(
-      `LSP notification handler registration: ${successCount}/${totalServers} succeeded. ` +
-        `Failed servers: ${failedServers}. ` +
-        `Diagnostics from failed servers will not be delivered.`,
-    )
-  } else {
-    logForDebugging(
-      `LSP notification handlers registered successfully for all ${totalServers} server(s)`,
-    )
-  }
-
-  // Return tracking data for monitoring and testing
-  return {
-    totalServers,
-    successCount,
-    registrationErrors,
-    diagnosticFailures,
-  }
-}

package/src/services/lsp/types.ts

@@ -1,3 +0,0 @@
-export type LspServerConfig = any
-export type ScopedLspServerConfig = any
-export type LspServerState = any

package/src/services/mcp/InProcessTransport.ts

@@ -1,63 +0,0 @@
-import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js'
-import type { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js'
-
-/**
- * In-process linked transport pair for running an MCP server and client
- * in the same process without spawning a subprocess.
- *
- * `send()` on one side delivers to `onmessage` on the other.
- * `close()` on either side calls `onclose` on both.
- */
-class InProcessTransport implements Transport {
-  private peer: InProcessTransport | undefined
-  private closed = false
-
-  onclose?: () => void
-  onerror?: (error: Error) => void
-  onmessage?: (message: JSONRPCMessage) => void
-
-  /** @internal */
-  _setPeer(peer: InProcessTransport): void {
-    this.peer = peer
-  }
-
-  async start(): Promise<void> {}
-
-  async send(message: JSONRPCMessage): Promise<void> {
-    if (this.closed) {
-      throw new Error('Transport is closed')
-    }
-    // Deliver to the other side asynchronously to avoid stack depth issues
-    // with synchronous request/response cycles
-    queueMicrotask(() => {
-      this.peer?.onmessage?.(message)
-    })
-  }
-
-  async close(): Promise<void> {
-    if (this.closed) {
-      return
-    }
-    this.closed = true
-    this.onclose?.()
-    // Close the peer if it hasn't already closed
-    if (this.peer && !this.peer.closed) {
-      this.peer.closed = true
-      this.peer.onclose?.()
-    }
-  }
-}
-
-/**
- * Creates a pair of linked transports for in-process MCP communication.
- * Messages sent on one transport are delivered to the other's `onmessage`.
- *
- * @returns [clientTransport, serverTransport]
- */
-export function createLinkedTransportPair(): [Transport, Transport] {
-  const a = new InProcessTransport()
-  const b = new InProcessTransport()
-  a._setPeer(b)
-  b._setPeer(a)
-  return [a, b]
-}