savant-code 0.0.19 → 0.0.20

package/common/src/mcp/client.ts

@@ -1,308 +0,0 @@
-import { Client } from '@modelcontextprotocol/sdk/client/index.js'
-import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js'
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js'
-import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js'
-
-import { getErrorObject } from '../util/error'
-
-import type { MCPConfig } from '../types/mcp'
-import type { ToolResultOutput } from '../types/messages/content-part'
-import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js'
-import type {
-  BlobResourceContents,
-  CallToolResult,
-  TextResourceContents,
-} from '@modelcontextprotocol/sdk/types.js'
-
-// Cap on how much of a failed stdio server's stderr we retain for the error
-// message — enough to show the real failure without unbounded growth.
-const STDERR_BUFFER_CAP = 8192
-
-// Default timeout values (ms)
-const DEFAULT_CONNECT_TIMEOUT_MS = 30_000
-const DEFAULT_TOOL_TIMEOUT_MS = 60_000
-
-// Hard cap — user-configured timeout is clamped to this ceiling.
-const MAX_TIMEOUT_MS = 300_000
-
-const runningClients: Record<string, Client> = {}
-const listToolsCache: Record<
-  string,
-  ReturnType<typeof Client.prototype.listTools>
-> = {}
-
-// Per-client timeout for tool calls and listTools. Populated on successful
-// connect so that callMCPTool / listMCPTools can look it up by clientId.
-const clientTimeouts: Record<string, number> = {}
-
-/**
- * Races a promise against a timeout. Rejects with a timeout Error if the
- * promise does not settle within `ms` milliseconds. The timer is always
- * cleared (via .finally) to avoid leaks when the promise wins the race.
- */
-async function withTimeout<T>(
-  promise: Promise<T>,
-  ms: number,
-  errorMessage: string,
-): Promise<T> {
-  let timer: ReturnType<typeof setTimeout>
-  const timeoutPromise = new Promise<never>((_, reject) => {
-    timer = setTimeout(() => reject(new Error(errorMessage)), ms)
-  })
-  return Promise.race([promise, timeoutPromise]).finally(() =>
-    clearTimeout(timer),
-  )
-}
-
-/**
- * Clamps a user-supplied timeout to [1, MAX_TIMEOUT_MS].
- * Returns the default if the input is undefined.
- */
-function clampTimeout(value: number | undefined, defaultValue: number): number {
-  if (value === undefined) return defaultValue
-  return Math.min(Math.max(Math.round(value), 1), MAX_TIMEOUT_MS)
-}
-
-/**
- * Substitutes environment variable references ($VAR_NAME) in a string with their values.
- * Supports both simple replacement ("$VAR_NAME") and interpolation ("Bearer $VAR_NAME").
- */
-function substituteEnvInValue(value: string): string {
-  return value.replace(/\$([A-Z_][A-Z0-9_]*)/g, (match, varName) => {
-    const envValue = process.env[varName]
-    if (envValue === undefined) {
-      // Return original if env var not found
-      return match
-    }
-    return envValue
-  })
-}
-
-/**
- * Substitutes environment variable references in all values of a record.
- */
-function substituteEnvInRecord(
-  record: Record<string, string>,
-): Record<string, string> {
-  const result: Record<string, string> = {}
-  for (const [key, value] of Object.entries(record)) {
-    result[key] = substituteEnvInValue(value)
-  }
-  return result
-}
-
-function hashConfig(config: MCPConfig): string {
-  if (config.type === 'stdio') {
-    return JSON.stringify({
-      command: config.command,
-      args: config.args,
-      env: config.env,
-    })
-  }
-  if (config.type === 'http') {
-    return JSON.stringify({
-      type: 'http',
-      url: config.url,
-      params: config.params,
-    })
-  }
-  if (config.type === 'sse') {
-    return JSON.stringify({
-      type: 'sse',
-      url: config.url,
-      params: config.params,
-    })
-  }
-  config.type satisfies never
-  throw new Error(
-    `Internal error in hashConfig: invalid MCP config type ${config.type}`,
-  )
-}
-
-export async function getMCPClient(config: MCPConfig): Promise<string> {
-  let key = hashConfig(config)
-  if (key in runningClients) {
-    return key
-  }
-
-  let transport: Transport
-  // Buffer the child process's stderr so that a server which crashes during
-  // startup produces an actionable error instead of the opaque MCP SDK message
-  // "MCP error -32000: Connection closed".
-  let stderrBuffer = ''
-  if (config.type === 'stdio') {
-    const stdioTransport = new StdioClientTransport({
-      command: config.command,
-      args: config.args,
-      env: substituteEnvInRecord(config.env),
-      stderr: 'pipe',
-    })
-    // When stderr is 'pipe' the SDK exposes a PassThrough immediately (before
-    // the process is spawned), so attaching here captures even early output
-    // from a child that dies during the connection handshake.
-    stdioTransport.stderr?.on('data', (chunk: Buffer) => {
-      if (stderrBuffer.length < STDERR_BUFFER_CAP) {
-        stderrBuffer += chunk.toString('utf8')
-      }
-    })
-    transport = stdioTransport
-  } else {
-    const url = new URL(config.url)
-    for (const [key, value] of Object.entries(config.params)) {
-      url.searchParams.set(key, value)
-    }
-    const headers = substituteEnvInRecord(config.headers)
-    if (config.type === 'http') {
-      transport = new StreamableHTTPClientTransport(url, {
-        requestInit: {
-          headers,
-        },
-      })
-    } else if (config.type === 'sse') {
-      transport = new SSEClientTransport(url, {
-        requestInit: {
-          headers,
-        },
-      })
-    } else {
-      config.type satisfies never
-      throw new Error(`Internal error: invalid MCP config type ${config.type}`)
-    }
-  }
-
-  const client = new Client({
-    name: 'savant-code',
-    version: '1.0.0',
-  })
-
-  const connectTimeoutMs = clampTimeout(
-    config.timeout,
-    DEFAULT_CONNECT_TIMEOUT_MS,
-  )
-
-  try {
-    await withTimeout(
-      client.connect(transport),
-      connectTimeoutMs,
-      `MCP connection timed out after ${connectTimeoutMs}ms`,
-    )
-  } catch (error) {
-    // Clean up the transport to prevent orphaned child processes (stdio)
-    // or dangling network sockets (http/sse). This also handles the race
-    // condition where connect() resolves after the timeout — the transport
-    // is dead so the client will be safely GC'd.
-    try {
-      await transport.close()
-    } catch {
-      // Ignore close errors — we're already in the error path.
-    }
-
-    const baseMessage = getErrorObject(error).message
-    if (config.type === 'stdio') {
-      const commandStr = [config.command, ...(config.args ?? [])].join(' ')
-      const detail = stderrBuffer.trim()
-      throw new Error(
-        `${baseMessage}. Failed to start MCP server via \`${commandStr}\`. ` +
-          `Ensure the command is installed and runnable (e.g. an up-to-date ` +
-          `node/npm/npx, or python/uvx) and that any required env vars are set.` +
-          (detail ? `\nServer stderr:\n${detail}` : ''),
-      )
-    }
-    throw new Error(
-      `${baseMessage}. Failed to connect to MCP server at ${config.url}.`,
-    )
-  }
-  runningClients[key] = client
-  clientTimeouts[key] = clampTimeout(config.timeout, DEFAULT_TOOL_TIMEOUT_MS)
-
-  return key
-}
-
-export function listMCPTools(
-  clientId: string,
-  ...args: Parameters<typeof Client.prototype.listTools>
-): ReturnType<typeof Client.prototype.listTools> {
-  const client = runningClients[clientId]
-  if (!client) {
-    throw new Error(`listTools: client not found with id: ${clientId}`)
-  }
-  if (!listToolsCache[clientId]) {
-    const timeoutMs = clientTimeouts[clientId] ?? DEFAULT_TOOL_TIMEOUT_MS
-    listToolsCache[clientId] = withTimeout(
-      client.listTools(...args),
-      timeoutMs,
-      `MCP listTools timed out after ${timeoutMs}ms`,
-    ).catch((error) => {
-      // Clear the cached rejected promise so the next call retries
-      // instead of permanently returning the same timeout error.
-      delete listToolsCache[clientId]
-      throw error
-    })
-  }
-  return listToolsCache[clientId]
-}
-
-function getResourceData(
-  resource: TextResourceContents | BlobResourceContents,
-): string {
-  if ('text' in resource) return resource.text as string
-  if ('blob' in resource) return resource.blob as string
-  return ''
-}
-
-export async function callMCPTool(
-  clientId: string,
-  ...args: Parameters<typeof Client.prototype.callTool>
-): Promise<ToolResultOutput[]> {
-  const client = runningClients[clientId]
-  if (!client) {
-    throw new Error(`callTool: client not found with id: ${clientId}`)
-  }
-
-  const timeoutMs = clientTimeouts[clientId] ?? DEFAULT_TOOL_TIMEOUT_MS
-  const callResult = await withTimeout(
-    client.callTool(...args),
-    timeoutMs,
-    `MCP tool call timed out after ${timeoutMs}ms`,
-  )
-  const result = callResult as CallToolResult
-  const content = result.content
-
-  return content.map((c: (typeof content)[number]) => {
-    if (c.type === 'text') {
-      return {
-        type: 'json',
-        value: c.text,
-      } satisfies ToolResultOutput
-    }
-    if (c.type === 'audio') {
-      return {
-        type: 'media',
-        data: c.data,
-        mediaType: c.mimeType,
-      } satisfies ToolResultOutput
-    }
-    if (c.type === 'image') {
-      return {
-        type: 'media',
-        data: c.data,
-        mediaType: c.mimeType,
-      } satisfies ToolResultOutput
-    }
-    if (c.type === 'resource') {
-      return {
-        type: 'media',
-        data: getResourceData(c.resource),
-        mediaType: c.resource.mimeType ?? 'text/plain',
-      } satisfies ToolResultOutput
-    }
-    const fallbackValue =
-      'uri' in c && typeof (c as { uri: unknown }).uri === 'string'
-        ? (c as { uri: string }).uri
-        : JSON.stringify(c)
-    return {
-      type: 'json',
-      value: fallbackValue,
-    } satisfies ToolResultOutput
-  })
-}

package/common/src/old-constants.ts

@@ -1,10 +0,0 @@
-/**
- * @deprecated Import from '@savant-code/common/constants' or specific files instead:
- * - '@savant-code/common/constants/model-config' for model-related constants
- * - '@savant-code/common/constants/limits' for billing and numeric limits
- * - '@savant-code/common/constants/ui' for auth/user state
- * - '@savant-code/common/constants/paths' for file paths and markers
- *
- * This file re-exports all constants for backwards compatibility.
- */
-export * from './constants'

package/common/src/project-file-tree.ts

@@ -1,361 +0,0 @@
-import path from 'path'
-
-import * as ignore from 'ignore'
-import { sortBy } from 'lodash'
-
-import { DEFAULT_IGNORED_PATHS } from './constants/paths'
-import { fileExists, isValidProjectRoot } from './util/file'
-
-import type { SavantCodeFileSystem } from './types/filesystem'
-import type { DirectoryNode, FileTreeNode } from './util/file'
-
-/**
- * Logs file tree errors in debug mode only.
- * Errors are logged but not thrown to preserve tree-building behavior.
- *
- * File tree operations commonly encounter expected errors (permissions,
- * deleted files) that are not fatal. We only log in debug mode to avoid
- * noisy output during normal operation.
- */
-function logFileTreeError(
-  operation: string,
-  filePath: string,
-  error: Error,
-): void {
-  // Only log in debug mode to avoid noisy output
-  if (!process.env.DEBUG && !process.env.SAVANT_CODE_DEBUG) {
-    return
-  }
-
-  const code = hasErrnoCode(error) ? error.code : undefined
-  const errorMessage = error.message
-
-  // eslint-disable-next-line no-console -- controlled debug logging for file tree operations
-  console.debug(
-    `[FileTree] ${operation} failed for "${filePath}"${
-      code ? ` (${code})` : ''
-    }: ${errorMessage}`,
-  )
-}
-
-function hasErrnoCode(error: Error): error is Error & { code?: string } {
-  return 'code' in error
-}
-
-export const DEFAULT_MAX_FILES = 10_000
-
-// When the project root is the home directory (or an ancestor), a full scan
-// could crawl the user's entire disk. Instead of disabling the file tree
-// entirely, do a shallow capped scan so @ mentions still surface
-// `project/docs/file.md`-style paths.
-export const SHALLOW_SCAN_MAX_DEPTH = 3
-const SHALLOW_SCAN_MAX_FILES = 2_000
-const SHALLOW_SCAN_MAX_DIRS = 500
-
-/** Whether `getProjectFileTree` will shallow-scan this root (see above). */
-export function isShallowScanRoot(
-  projectRoot: string | undefined,
-): projectRoot is string {
-  return !!projectRoot && !isValidProjectRoot(projectRoot)
-}
-
-export async function getProjectFileTree(params: {
-  projectRoot: string
-  maxFiles?: number
-  fs: SavantCodeFileSystem
-}): Promise<FileTreeNode[]> {
-  const withDefaults = { maxFiles: DEFAULT_MAX_FILES, ...params }
-  const { projectRoot, fs } = withDefaults
-  let { maxFiles } = withDefaults
-  let maxDepth = Infinity
-  let maxDirs = Infinity
-
-  const _start = Date.now()
-  const defaultIgnore = ignore.default()
-  for (const pattern of DEFAULT_IGNORED_PATHS) {
-    defaultIgnore.add(pattern)
-  }
-
-  if (isShallowScanRoot(projectRoot)) {
-    defaultIgnore.add('.*')
-    maxDepth = SHALLOW_SCAN_MAX_DEPTH
-    maxFiles = Math.min(maxFiles, SHALLOW_SCAN_MAX_FILES)
-    maxDirs = SHALLOW_SCAN_MAX_DIRS
-  }
-
-  const root: DirectoryNode = {
-    name: path.basename(projectRoot),
-    type: 'directory',
-    children: [],
-    filePath: '',
-  }
-  const queue: {
-    node: DirectoryNode
-    fullPath: string
-    ignore: ignore.Ignore
-    depth: number
-  }[] = [
-    {
-      node: root,
-      fullPath: projectRoot,
-      ignore: defaultIgnore,
-      depth: 0,
-    },
-  ]
-  let totalFiles = 0
-  let dirsScanned = 0
-
-  while (queue.length > 0 && totalFiles < maxFiles && dirsScanned < maxDirs) {
-    const head = queue.shift()
-    if (!head) break
-    const { node, fullPath, ignore: currentIgnore, depth } = head
-    dirsScanned++
-    const parsedIgnore = await parseGitignore({
-      fullDirPath: fullPath,
-      projectRoot,
-      fs,
-    })
-    const mergedIgnore = ignore.default().add(currentIgnore).add(parsedIgnore)
-
-    try {
-      const files = await fs.readdir(fullPath)
-      for (const file of files) {
-        if (totalFiles >= maxFiles) break
-
-        const filePath = path.join(fullPath, file)
-        const relativeFilePath = path.relative(projectRoot, filePath)
-
-        if (mergedIgnore.ignores(relativeFilePath)) continue
-
-        try {
-          const stats = await fs.stat(filePath)
-          if (stats.isDirectory()) {
-            const childNode: DirectoryNode = {
-              name: file,
-              type: 'directory',
-              children: [],
-              filePath: relativeFilePath,
-            }
-            node.children.push(childNode)
-            // Past maxDepth the directory still shows up as a node above, but
-            // its contents are not scanned.
-            if (depth + 1 < maxDepth) {
-              queue.push({
-                node: childNode,
-                fullPath: filePath,
-                ignore: mergedIgnore,
-                depth: depth + 1,
-              })
-            }
-          } else {
-            const lastReadTime = stats.atimeMs
-            node.children.push({
-              name: file,
-              type: 'file',
-              lastReadTime,
-              filePath: relativeFilePath,
-            })
-            totalFiles++
-          }
-        } catch (error) {
-          // File may be inaccessible due to permissions or may have been deleted.
-          // Log with context for debugging, but continue building the tree.
-          logFileTreeError(
-            'fs.stat',
-            filePath,
-            error instanceof Error ? error : new Error(String(error)),
-          )
-        }
-      }
-    } catch (error) {
-      // Directory may be inaccessible due to permissions.
-      // Log with context for debugging, but continue building the tree.
-      logFileTreeError(
-        'fs.readdir',
-        fullPath,
-        error instanceof Error ? error : new Error(String(error)),
-      )
-    }
-  }
-  return root.children
-}
-
-function rebaseGitignorePattern(
-  rawPattern: string,
-  relativeDirPath: string,
-): string {
-  // Preserve negation and directory-only flags
-  const isNegated = rawPattern.startsWith('!')
-  let pattern = isNegated ? rawPattern.slice(1) : rawPattern
-
-  const dirOnly = pattern.endsWith('/')
-  // Strip the trailing slash for slash-detection only
-  const core = dirOnly ? pattern.slice(0, -1) : pattern
-
-  const anchored = core.startsWith('/') // anchored to .gitignore dir
-  // Detect if the "meaningful" part (minus optional leading '/' and trailing '/')
-  // contains a slash. If not, git treats it as recursive.
-  const coreNoLead = anchored ? core.slice(1) : core
-  const hasSlash = coreNoLead.includes('/')
-
-  // Build the base (where this .gitignore lives relative to projectRoot)
-  const base = relativeDirPath.replace(/\\/g, '/') // normalize
-
-  let rebased: string
-  if (anchored) {
-    // "/foo" from evals/.gitignore -> "evals/foo"
-    rebased = base ? `${base}/${coreNoLead}` : coreNoLead
-  } else if (!hasSlash) {
-    // "logs" or "logs/" should recurse from evals/: "evals/**/logs[/]"
-    if (base) {
-      rebased = `${base}/**/${coreNoLead}`
-    } else {
-      // At project root already; "logs" stays "logs" to keep recursive semantics
-      rebased = coreNoLead
-    }
-  } else {
-    // "foo/bar" relative to evals/: "evals/foo/bar"
-    rebased = base ? `${base}/${coreNoLead}` : coreNoLead
-  }
-
-  if (dirOnly && !rebased.endsWith('/')) {
-    rebased += '/'
-  }
-
-  // Normalize to forward slashes
-  rebased = rebased.replace(/\\/g, '/')
-
-  return isNegated ? `!${rebased}` : rebased
-}
-
-export async function parseGitignore(params: {
-  fullDirPath: string
-  projectRoot: string
-  fs: SavantCodeFileSystem
-}): Promise<ignore.Ignore> {
-  const { fullDirPath, projectRoot, fs } = params
-
-  const ig = ignore.default()
-  const relativeDirPath = path.relative(projectRoot, fullDirPath)
-  const ignoreFiles = [
-    path.join(fullDirPath, '.gitignore'),
-    path.join(fullDirPath, '.savantignore'),
-    path.join(fullDirPath, '.manicodeignore'), // Legacy support
-  ]
-
-  for (const ignoreFilePath of ignoreFiles) {
-    const ignoreFileExists = await fileExists({ filePath: ignoreFilePath, fs })
-    if (!ignoreFileExists) continue
-
-    let ignoreContent: string
-    try {
-      ignoreContent = await fs.readFile(ignoreFilePath, 'utf8')
-    } catch (error) {
-      // Ignore file may be inaccessible or deleted after existence check.
-      // Log with context for debugging, but continue without these ignore rules.
-      logFileTreeError(
-        'fs.readFile (ignore file)',
-        ignoreFilePath,
-        error instanceof Error ? error : new Error(String(error)),
-      )
-      continue
-    }
-    const lines = ignoreContent.split('\n')
-    for (let line of lines) {
-      line = line.trim()
-      if (line === '' || line.startsWith('#')) continue
-
-      const finalPattern = rebaseGitignorePattern(line, relativeDirPath)
-
-      ig.add(finalPattern)
-    }
-  }
-
-  return ig
-}
-
-export function getAllFilePaths(
-  nodes: FileTreeNode[],
-  basePath: string = '',
-): string[] {
-  return nodes.flatMap((node) => {
-    if (node.type === 'file') {
-      return [path.join(basePath, node.name)]
-    }
-    return getAllFilePaths(node.children || [], path.join(basePath, node.name))
-  })
-}
-
-export interface PathInfo {
-  path: string
-  isDirectory: boolean
-}
-
-export function getAllPathsWithDirectories(
-  nodes: FileTreeNode[],
-  basePath: string = '',
-): PathInfo[] {
-  return nodes.flatMap((node) => {
-    const nodePath = basePath ? path.join(basePath, node.name) : node.name
-    if (node.type === 'file') {
-      return [{ path: nodePath, isDirectory: false }]
-    }
-    // Include the directory itself, plus recurse into children
-    const dirEntry: PathInfo = { path: nodePath, isDirectory: true }
-    const children = getAllPathsWithDirectories(node.children || [], nodePath)
-    return [dirEntry, ...children]
-  })
-}
-
-export function flattenTree(nodes: FileTreeNode[]): FileTreeNode[] {
-  return nodes.flatMap((node) => {
-    if (node.type === 'file') {
-      return [node]
-    }
-    return flattenTree(node.children ?? [])
-  })
-}
-
-export function getLastReadFilePaths(
-  flattenedNodes: FileTreeNode[],
-  count: number,
-) {
-  return sortBy(
-    flattenedNodes.filter((node) => node.lastReadTime),
-    'lastReadTime',
-  )
-    .reverse()
-    .slice(0, count)
-    .map((node) => node.filePath)
-}
-
-export async function isFileIgnored(params: {
-  filePath: string
-  projectRoot: string
-  fs: SavantCodeFileSystem
-}): Promise<boolean> {
-  const { filePath, projectRoot, fs } = params
-
-  const defaultIgnore = ignore.default()
-  for (const pattern of DEFAULT_IGNORED_PATHS) {
-    defaultIgnore.add(pattern)
-  }
-
-  const relativeFilePath = path.relative(
-    projectRoot,
-    path.join(projectRoot, filePath),
-  )
-  const dirPath = path.dirname(path.join(projectRoot, filePath))
-
-  // Get ignore patterns from the directory containing the file and all parent directories
-  const mergedIgnore = ignore.default().add(defaultIgnore)
-  let currentDir = dirPath
-  while (currentDir.startsWith(projectRoot)) {
-    mergedIgnore.add(
-      await parseGitignore({ fullDirPath: currentDir, projectRoot, fs }),
-    )
-    currentDir = path.dirname(currentDir)
-  }
-
-  return mergedIgnore.ignores(relativeFilePath)
-}