mdcontext 0.1.0 → 0.2.0

package/src/summarization/cli-providers/detection.test.ts

@@ -0,0 +1,273 @@
+/**
+ * Tests for CLI Provider Detection Module
+ */
+
+import { type ChildProcess, spawn } from 'node:child_process'
+import { EventEmitter } from 'node:events'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type { CLIProviderName } from '../types.js'
+import {
+  detectInstalledCLIs,
+  getCLIInfo,
+  isCLIInstalled,
+  KNOWN_CLIS,
+} from './detection.js'
+
+vi.mock('node:child_process', () => ({
+  spawn: vi.fn(),
+}))
+
+const mockSpawn = vi.mocked(spawn)
+
+const createMockProcess = (exitCode: number | null, emitError = false) => {
+  const proc = new EventEmitter() as ChildProcess
+  setTimeout(() => {
+    if (emitError) {
+      proc.emit('error', new Error('spawn ENOENT'))
+    } else {
+      proc.emit('close', exitCode)
+    }
+  }, 0)
+  return proc
+}
+
+describe('KNOWN_CLIS', () => {
+  const expectedProviders: CLIProviderName[] = [
+    'claude',
+    'opencode',
+    'copilot',
+    'aider',
+    'cline',
+    'amp',
+  ]
+
+  it('should contain all expected CLI providers', () => {
+    const names = KNOWN_CLIS.map((cli) => cli.name)
+    for (const provider of expectedProviders) {
+      expect(names).toContain(provider)
+    }
+  })
+
+  it('should have required fields for each CLI', () => {
+    for (const cli of KNOWN_CLIS) {
+      expect(cli).toHaveProperty('name')
+      expect(cli).toHaveProperty('command')
+      expect(cli).toHaveProperty('displayName')
+      expect(cli).toHaveProperty('args')
+      expect(cli).toHaveProperty('useStdin')
+
+      expect(typeof cli.name).toBe('string')
+      expect(typeof cli.command).toBe('string')
+      expect(typeof cli.displayName).toBe('string')
+      expect(Array.isArray(cli.args)).toBe(true)
+      expect(typeof cli.useStdin).toBe('boolean')
+    }
+  })
+
+  describe('individual CLI configurations', () => {
+    it('should have correct claude configuration', () => {
+      const claude = KNOWN_CLIS.find((cli) => cli.name === 'claude')
+      expect(claude).toBeDefined()
+      expect(claude!.command).toBe('claude')
+      expect(claude!.displayName).toBe('Claude Code')
+      expect(claude!.args).toContain('-p')
+      expect(claude!.useStdin).toBe(false)
+    })
+
+    it('should have correct opencode configuration', () => {
+      const opencode = KNOWN_CLIS.find((cli) => cli.name === 'opencode')
+      expect(opencode).toBeDefined()
+      expect(opencode!.command).toBe('opencode')
+      expect(opencode!.displayName).toBe('OpenCode')
+      expect(opencode!.useStdin).toBe(true)
+    })
+
+    it('should have correct copilot configuration', () => {
+      const copilot = KNOWN_CLIS.find((cli) => cli.name === 'copilot')
+      expect(copilot).toBeDefined()
+      expect(copilot!.command).toBe('gh')
+      expect(copilot!.displayName).toBe('GitHub Copilot CLI')
+      expect(copilot!.args).toContain('copilot')
+      expect(copilot!.useStdin).toBe(true)
+    })
+
+    it('should have correct aider configuration', () => {
+      const aider = KNOWN_CLIS.find((cli) => cli.name === 'aider')
+      expect(aider).toBeDefined()
+      expect(aider!.command).toBe('aider')
+      expect(aider!.displayName).toBe('Aider')
+      expect(aider!.useStdin).toBe(false)
+    })
+
+    it('should have correct cline configuration', () => {
+      const cline = KNOWN_CLIS.find((cli) => cli.name === 'cline')
+      expect(cline).toBeDefined()
+      expect(cline!.command).toBe('cline')
+      expect(cline!.displayName).toBe('Cline')
+      expect(cline!.useStdin).toBe(false)
+    })
+
+    it('should have correct amp configuration', () => {
+      const amp = KNOWN_CLIS.find((cli) => cli.name === 'amp')
+      expect(amp).toBeDefined()
+      expect(amp!.command).toBe('amp')
+      expect(amp!.displayName).toBe('Amp')
+      expect(amp!.useStdin).toBe(false)
+    })
+  })
+})
+
+describe('getCLIInfo', () => {
+  it('should return correct info for known providers', () => {
+    const claude = getCLIInfo('claude')
+    expect(claude).toBeDefined()
+    expect(claude!.name).toBe('claude')
+    expect(claude!.command).toBe('claude')
+
+    const copilot = getCLIInfo('copilot')
+    expect(copilot).toBeDefined()
+    expect(copilot!.name).toBe('copilot')
+    expect(copilot!.command).toBe('gh')
+  })
+
+  it('should return undefined for unknown provider', () => {
+    const unknown = getCLIInfo('unknown' as CLIProviderName)
+    expect(unknown).toBeUndefined()
+  })
+
+  it('should return all fields for a CLI', () => {
+    const cli = getCLIInfo('claude')
+    expect(cli).toMatchObject({
+      name: 'claude',
+      command: 'claude',
+      displayName: 'Claude Code',
+      args: expect.any(Array),
+      useStdin: false,
+    })
+  })
+})
+
+describe('isCLIInstalled', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it('should return true when CLI exists (exit code 0)', async () => {
+    mockSpawn.mockReturnValue(createMockProcess(0))
+
+    const result = await isCLIInstalled('claude')
+
+    expect(result).toBe(true)
+    expect(mockSpawn).toHaveBeenCalledWith(
+      expect.stringMatching(/^(which|where)$/),
+      ['claude'],
+      { stdio: ['ignore', 'pipe', 'ignore'] },
+    )
+  })
+
+  it('should return false when CLI does not exist (exit code 1)', async () => {
+    mockSpawn.mockReturnValue(createMockProcess(1))
+
+    const result = await isCLIInstalled('claude')
+
+    expect(result).toBe(false)
+  })
+
+  it('should return false when spawn emits an error', async () => {
+    mockSpawn.mockReturnValue(createMockProcess(null, true))
+
+    const result = await isCLIInstalled('claude')
+
+    expect(result).toBe(false)
+  })
+
+  it('should return false for unknown provider', async () => {
+    const result = await isCLIInstalled('unknown' as CLIProviderName)
+
+    expect(result).toBe(false)
+    expect(mockSpawn).not.toHaveBeenCalled()
+  })
+
+  it('should check the correct command for copilot (gh)', async () => {
+    mockSpawn.mockReturnValue(createMockProcess(0))
+
+    await isCLIInstalled('copilot')
+
+    expect(mockSpawn).toHaveBeenCalledWith(
+      expect.stringMatching(/^(which|where)$/),
+      ['gh'],
+      expect.any(Object),
+    )
+  })
+})
+
+describe('detectInstalledCLIs', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it('should return all CLIs when all are installed', async () => {
+    mockSpawn.mockReturnValue(createMockProcess(0))
+
+    const result = await detectInstalledCLIs()
+
+    expect(result.length).toBe(KNOWN_CLIS.length)
+    expect(result.map((cli) => cli.name)).toEqual(
+      expect.arrayContaining([
+        'claude',
+        'opencode',
+        'copilot',
+        'aider',
+        'cline',
+        'amp',
+      ]),
+    )
+  })
+
+  it('should return empty array when no CLIs are installed', async () => {
+    mockSpawn.mockReturnValue(createMockProcess(1))
+
+    const result = await detectInstalledCLIs()
+
+    expect(result).toEqual([])
+  })
+
+  it('should return only installed CLIs', async () => {
+    const installedCommands = new Set(['claude', 'gh'])
+    mockSpawn.mockImplementation((_cmd, args) => {
+      const command = args[0] as string
+      const isInstalled = installedCommands.has(command)
+      return createMockProcess(isInstalled ? 0 : 1)
+    })
+
+    const result = await detectInstalledCLIs()
+
+    expect(result.length).toBe(2)
+    expect(result.map((cli) => cli.name)).toContain('claude')
+    expect(result.map((cli) => cli.name)).toContain('copilot')
+  })
+
+  it('should handle errors gracefully', async () => {
+    mockSpawn.mockReturnValue(createMockProcess(null, true))
+
+    const result = await detectInstalledCLIs()
+
+    expect(result).toEqual([])
+  })
+
+  it('should check all known CLIs', async () => {
+    mockSpawn.mockReturnValue(createMockProcess(0))
+
+    await detectInstalledCLIs()
+
+    expect(mockSpawn).toHaveBeenCalledTimes(KNOWN_CLIS.length)
+  })
+})

package/src/summarization/cli-providers/detection.ts

@@ -0,0 +1,118 @@
+/**
+ * CLI Provider Detection
+ *
+ * Detects installed CLI tools that can be used for AI summarization.
+ * Uses spawn() with argument arrays for security - NEVER exec() with string interpolation.
+ */
+
+import { spawn } from 'node:child_process'
+import type { CLIInfo, CLIProviderName } from '../types.js'
+
+/**
+ * Known CLI tools with their configuration.
+ *
+ * SECURITY: All CLI invocations use spawn() with argument arrays.
+ * The args array is used directly, never interpolated into strings.
+ */
+export const KNOWN_CLIS: readonly CLIInfo[] = [
+  {
+    name: 'claude',
+    command: 'claude',
+    displayName: 'Claude Code',
+    args: ['-p', '--output-format', 'text'],
+    useStdin: false, // Uses -p flag for prompt, not stdin
+  },
+  {
+    name: 'opencode',
+    command: 'opencode',
+    displayName: 'OpenCode',
+    args: ['run', '--format', 'text'],
+    useStdin: true,
+  },
+  {
+    name: 'copilot',
+    command: 'gh',
+    displayName: 'GitHub Copilot CLI',
+    args: ['copilot', 'explain'],
+    useStdin: true,
+  },
+  {
+    name: 'aider',
+    command: 'aider',
+    displayName: 'Aider',
+    args: ['--message'],
+    useStdin: false,
+  },
+  {
+    name: 'cline',
+    command: 'cline',
+    displayName: 'Cline',
+    args: ['--prompt'],
+    useStdin: false,
+  },
+  {
+    name: 'amp',
+    command: 'amp',
+    displayName: 'Amp',
+    args: ['--prompt'],
+    useStdin: false,
+  },
+] as const
+
+/**
+ * Check if a command exists on the system.
+ *
+ * SECURITY: Uses spawn() with argument array, not exec() with string interpolation.
+ */
+const commandExists = (command: string): Promise<boolean> => {
+  return new Promise((resolve) => {
+    // Use 'which' on Unix, 'where' on Windows
+    const checkCommand = process.platform === 'win32' ? 'where' : 'which'
+
+    const proc = spawn(checkCommand, [command], {
+      stdio: ['ignore', 'pipe', 'ignore'],
+    })
+
+    proc.on('close', (code) => {
+      resolve(code === 0)
+    })
+
+    proc.on('error', () => {
+      resolve(false)
+    })
+  })
+}
+
+/**
+ * Detect all installed CLI tools that can be used for summarization.
+ *
+ * @returns Array of CLIInfo for installed tools
+ */
+export const detectInstalledCLIs = async (): Promise<CLIInfo[]> => {
+  const results = await Promise.all(
+    KNOWN_CLIS.map(async (cli) => {
+      const exists = await commandExists(cli.command)
+      return exists ? cli : null
+    }),
+  )
+
+  return results.filter((cli): cli is CLIInfo => cli !== null)
+}
+
+/**
+ * Get CLI info by name.
+ */
+export const getCLIInfo = (name: CLIProviderName): CLIInfo | undefined => {
+  return KNOWN_CLIS.find((cli) => cli.name === name)
+}
+
+/**
+ * Check if a specific CLI is installed.
+ */
+export const isCLIInstalled = async (
+  name: CLIProviderName,
+): Promise<boolean> => {
+  const cli = getCLIInfo(name)
+  if (!cli) return false
+  return commandExists(cli.command)
+}

package/src/summarization/cli-providers/index.ts

@@ -0,0 +1,8 @@
+/**
+ * CLI Providers Module
+ *
+ * Exports all CLI-based summarizers and detection utilities.
+ */
+
+export * from './claude.js'
+export * from './detection.js'

package/src/summarization/cost.test.ts

@@ -0,0 +1,139 @@
+/**
+ * Tests for Cost Estimation Module
+ */
+
+import { describe, expect, it } from 'vitest'
+import {
+  API_PRICING,
+  estimateSummaryCost,
+  estimateTokens,
+  formatCostDisplay,
+} from './cost.js'
+
+describe('estimateTokens', () => {
+  it('should estimate ~4 chars per token', () => {
+    expect(estimateTokens('test')).toBe(1)
+    expect(estimateTokens('testtest')).toBe(2)
+    expect(estimateTokens('x'.repeat(100))).toBe(25)
+  })
+
+  it('should round up partial tokens', () => {
+    expect(estimateTokens('abc')).toBe(1) // 0.75 -> 1
+    expect(estimateTokens('abcde')).toBe(2) // 1.25 -> 2
+  })
+
+  it('should handle empty string', () => {
+    expect(estimateTokens('')).toBe(0)
+  })
+})
+
+describe('estimateSummaryCost', () => {
+  describe('CLI providers (free)', () => {
+    it('should return isPaid=false for CLI mode', () => {
+      const result = estimateSummaryCost('test input', 'cli', 'claude')
+      expect(result.isPaid).toBe(false)
+      expect(result.estimatedCost).toBe(0)
+      expect(result.formattedCost).toBe('FREE (subscription)')
+    })
+
+    it('should still estimate tokens for CLI mode', () => {
+      const input = 'x'.repeat(400) // ~100 tokens
+      const result = estimateSummaryCost(input, 'cli', 'claude')
+      expect(result.inputTokens).toBe(100)
+      expect(result.outputTokens).toBe(500) // default
+    })
+  })
+
+  describe('API providers (paid)', () => {
+    it('should calculate cost for DeepSeek', () => {
+      const input = 'x'.repeat(4000) // ~1000 tokens
+      const result = estimateSummaryCost(input, 'api', 'deepseek', 500)
+
+      expect(result.inputTokens).toBe(1000)
+      expect(result.outputTokens).toBe(500)
+      expect(result.isPaid).toBe(true)
+      // Input: 1000 * 0.14 / 1M = 0.00014
+      // Output: 500 * 0.56 / 1M = 0.00028
+      // Total: 0.00042
+      expect(result.estimatedCost).toBeCloseTo(0.00042, 5)
+    })
+
+    it('should calculate cost for Anthropic (more expensive)', () => {
+      const input = 'x'.repeat(4000) // ~1000 tokens
+      const result = estimateSummaryCost(input, 'api', 'anthropic', 500)
+
+      expect(result.isPaid).toBe(true)
+      // Input: 1000 * 3.0 / 1M = 0.003
+      // Output: 500 * 15.0 / 1M = 0.0075
+      // Total: 0.0105
+      expect(result.estimatedCost).toBeCloseTo(0.0105, 4)
+    })
+
+    it('should calculate cost for OpenAI', () => {
+      const input = 'x'.repeat(4000)
+      const result = estimateSummaryCost(input, 'api', 'openai', 500)
+
+      expect(result.isPaid).toBe(true)
+      // Input: 1000 * 1.75 / 1M = 0.00175
+      // Output: 500 * 14.0 / 1M = 0.007
+      // Total: 0.00875
+      expect(result.estimatedCost).toBeCloseTo(0.00875, 5)
+    })
+
+    it('should handle CLI provider used with API mode (falls back to deepseek pricing)', () => {
+      const input = 'x'.repeat(4000)
+      // When a CLI provider is used with API mode, it falls back to deepseek pricing
+      const result = estimateSummaryCost(input, 'api', 'claude', 500)
+
+      expect(result.isPaid).toBe(true)
+      expect(result.estimatedCost).toBeCloseTo(0.00042, 5)
+    })
+  })
+
+  describe('provider comparison', () => {
+    it('should show Qwen as cheapest API provider', () => {
+      const input = 'x'.repeat(4000)
+      const qwen = estimateSummaryCost(input, 'api', 'qwen', 500)
+      const deepseek = estimateSummaryCost(input, 'api', 'deepseek', 500)
+      const anthropic = estimateSummaryCost(input, 'api', 'anthropic', 500)
+
+      expect(qwen.estimatedCost).toBeLessThan(deepseek.estimatedCost)
+      expect(deepseek.estimatedCost).toBeLessThan(anthropic.estimatedCost)
+    })
+  })
+})
+
+describe('formatCostDisplay', () => {
+  it('should format free CLI cost', () => {
+    const estimate = estimateSummaryCost('test', 'cli', 'claude')
+    const display = formatCostDisplay(estimate)
+    expect(display).toContain('FREE')
+    expect(display).toContain('claude')
+  })
+
+  it('should format paid API cost', () => {
+    const estimate = estimateSummaryCost('test', 'api', 'deepseek')
+    const display = formatCostDisplay(estimate)
+    expect(display).toContain('Estimated cost')
+    expect(display).toContain('$')
+  })
+})
+
+describe('API_PRICING', () => {
+  it('should have all expected providers', () => {
+    expect(API_PRICING.deepseek).toBeDefined()
+    expect(API_PRICING.qwen).toBeDefined()
+    expect(API_PRICING.anthropic).toBeDefined()
+    expect(API_PRICING.openai).toBeDefined()
+    expect(API_PRICING.gemini).toBeDefined()
+  })
+
+  it('should have valid pricing (input < output)', () => {
+    for (const pricing of Object.values(API_PRICING)) {
+      expect(pricing.input).toBeGreaterThan(0)
+      expect(pricing.output).toBeGreaterThan(0)
+      // Output tokens typically cost more
+      expect(pricing.output).toBeGreaterThanOrEqual(pricing.input)
+    }
+  })
+})

package/src/summarization/cost.ts

@@ -0,0 +1,102 @@
+/**
+ * Cost Estimation for AI Summarization
+ *
+ * Provides cost estimates for API providers before running queries.
+ * CLI providers are free (subscription-based), so cost is always 0.
+ */
+
+import type {
+  APIProviderName,
+  CLIProviderName,
+  SummarizationMode,
+} from './types.js'
+
+/**
+ * Type guard to check if a provider is an API provider
+ */
+const isAPIProvider = (provider: string): provider is APIProviderName => {
+  return ['deepseek', 'anthropic', 'openai', 'gemini', 'qwen'].includes(
+    provider,
+  )
+}
+
+/**
+ * Pricing per 1 million tokens for each provider.
+ * Values as of January 2026.
+ */
+export const API_PRICING: Record<
+  APIProviderName,
+  { input: number; output: number; displayName: string }
+> = {
+  deepseek: { input: 0.14, output: 0.56, displayName: 'DeepSeek' },
+  qwen: { input: 0.03, output: 0.12, displayName: 'Qwen' },
+  anthropic: { input: 3.0, output: 15.0, displayName: 'Anthropic Claude' },
+  openai: { input: 1.75, output: 14.0, displayName: 'OpenAI GPT' },
+  gemini: { input: 0.3, output: 2.5, displayName: 'Google Gemini' },
+}
+
+/**
+ * Cost estimate result
+ */
+export interface CostEstimate {
+  readonly inputTokens: number
+  readonly outputTokens: number
+  readonly estimatedCost: number
+  readonly provider: string
+  readonly isPaid: boolean
+  readonly formattedCost: string
+}
+
+/**
+ * Simple token estimation (4 chars ≈ 1 token).
+ */
+export const estimateTokens = (text: string): number => {
+  return Math.ceil(text.length / 4)
+}
+
+/**
+ * Estimate the cost of summarizing text.
+ */
+export const estimateSummaryCost = (
+  input: string,
+  mode: SummarizationMode,
+  provider: CLIProviderName | APIProviderName,
+  maxOutputTokens: number = 500,
+): CostEstimate => {
+  const inputTokens = estimateTokens(input)
+
+  if (mode === 'cli') {
+    return {
+      inputTokens,
+      outputTokens: maxOutputTokens,
+      estimatedCost: 0,
+      provider,
+      isPaid: false,
+      formattedCost: 'FREE (subscription)',
+    }
+  }
+
+  // For API mode, use API pricing (default to deepseek if provider not found)
+  const pricing = isAPIProvider(provider)
+    ? API_PRICING[provider]
+    : API_PRICING.deepseek
+  const inputCost = (inputTokens * pricing.input) / 1_000_000
+  const outputCost = (maxOutputTokens * pricing.output) / 1_000_000
+  const totalCost = inputCost + outputCost
+
+  return {
+    inputTokens,
+    outputTokens: maxOutputTokens,
+    estimatedCost: totalCost,
+    provider,
+    isPaid: true,
+    formattedCost: `$${totalCost.toFixed(4)}`,
+  }
+}
+
+export const formatCostDisplay = (estimate: CostEstimate): string => {
+  if (!estimate.isPaid) {
+    return `Using ${estimate.provider} (subscription - FREE)`
+  }
+  return `Estimated cost: ${estimate.formattedCost}`
+}