coc-vscode-loader 1.2.9 → 1.4.0

package/converter/package.json

@@ -1,19 +1,24 @@
 {
   "name": "converter",
-  "version": "1.2.9",
+  "version": "1.4.0",
   "private": true,
   "description": "vscode → coc.nvim converter prototype",
   "type": "module",
   "scripts": {
-    "convert": "tsx src/cli.ts"
+    "convert": "tsx src/cli.ts",
+    "test": "npm run check:tests && vitest run",
+    "test:watch": "vitest",
+    "test:smoke": "tsx scripts/smoke-test.ts",
+    "check:tests": "tsx scripts/check-tests.ts"
   },
   "dependencies": {
-    "ts-morph": "^28.0.0",
     "commander": "^15.0.0",
+    "ts-morph": "^28.0.0",
     "typescript": "^6.0.3"
   },
   "devDependencies": {
     "@types/node": "^25.9.3",
-    "tsx": "^4.19.0"
+    "tsx": "^4.19.0",
+    "vitest": "^4.1.8"
   }
 }

package/converter/scripts/check-tests.ts

@@ -0,0 +1,58 @@
+import { readdirSync, existsSync, readFileSync } from 'fs'
+import { join, relative } from 'path'
+
+const srcDir = new URL('../src', import.meta.url).pathname
+
+const EXEMPT = ['types.ts', 'index.ts', 'cli.ts']
+const MIN_TEST_SIZE = 50
+
+function walk(dir: string): string[] {
+  const files: string[] = []
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const p = join(dir, entry.name)
+    if (entry.isDirectory() && entry.name !== 'node_modules' && !entry.name.startsWith('.')) {
+      files.push(...walk(p))
+    } else if (entry.isFile() && entry.name.endsWith('.ts')) {
+      files.push(p)
+    }
+  }
+  return files
+}
+
+const files = walk(srcDir)
+let exitCode = 0
+
+for (const fp of files) {
+  const name = relative(srcDir, fp)
+  if (name.endsWith('.test.ts')) continue
+  if (EXEMPT.some(e => name === e || name.endsWith('/' + e))) continue
+
+  const testFile = fp.replace(/\.ts$/, '.test.ts')
+  if (!existsSync(testFile)) {
+    console.error(`  MISSING TEST: ${name}`)
+    exitCode = 1
+    continue
+  }
+
+  // Validate test file is not empty or placeholder
+  const testContent = readFileSync(testFile, 'utf-8')
+  if (testContent.length < MIN_TEST_SIZE) {
+    console.error(`  EMPTY TEST: ${relative(srcDir, testFile)} (${testContent.length} bytes)`)
+    exitCode = 1
+    continue
+  }
+  if (!/\b(it|test)\s*\(/.test(testContent)) {
+    console.error(`  NO TEST CASES: ${relative(srcDir, testFile)} (no it() or test() calls)`)
+    exitCode = 1
+    continue
+  }
+}
+
+if (exitCode === 0) {
+  const sourceFiles = files.filter(f => {
+    const name = relative(srcDir, f)
+    return !name.endsWith('.test.ts') && !EXEMPT.some(e => name === e || name.endsWith('/' + e))
+  })
+  console.log(`All ${sourceFiles.length} source files have valid tests`)
+}
+process.exit(exitCode)

package/converter/scripts/smoke-test.ts

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+/**
+ * Registry smoke test: clone ALL registry entries, run the converter,
+ * validate output structure. Runs concurrently for speed.
+ *
+ * Usage: npm run test:smoke
+ *        CONCURRENCY=8 npm run test:smoke
+ *        NO_CACHE=1 npm run test:smoke
+ *        VERBOSE=1 npm run test:smoke
+ *
+ * Proxy: respects HTTPS_PROXY / HTTP_PROXY / ALL_PROXY
+ * Cache: ~/.cache/coc-converter-smoke/
+ */
+
+import * as fs from 'fs'
+import * as path from 'path'
+import * as os from 'os'
+import { execFileSync } from 'child_process'
+import { convert } from '../src/convert.js'
+import { fileURLToPath } from 'url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const REGISTRY_PATH = path.resolve(__dirname, '../../coc-vscode-registry/registry.json')
+const PRESETS_PATH = path.resolve(__dirname, '../../coc-vscode-registry/presets.json')
+const CACHE_DIR = path.join(os.homedir(), '.cache', 'coc-converter-smoke')
+const TEST_OUTPUT = path.join(os.tmpdir(), 'coc-smoke-output')
+const CONCURRENCY = parseInt(process.env.CONCURRENCY || '8', 10)
+const CACHE_TTL_DAYS = parseInt(process.env.CACHE_TTL || '7', 10)
+
+interface RegistryEntry {
+  name: string; displayName: string; type: string
+  source: { type: string; repo?: string; package?: string; subdir?: string }
+  convert: any[]
+}
+
+function cacheDir(e: RegistryEntry): string {
+  return path.join(CACHE_DIR, e.name.replace(/[^a-z0-9_-]/gi, '_'))
+}
+
+function downloadOrCached(entry: RegistryEntry): string {
+  const dest = cacheDir(entry)
+  const src = entry.source
+  const isSnippets = entry.convert.some(s => s.type === 'snippets')
+
+  if (src.type === 'github' && src.repo) {
+    const url = `https://github.com/${src.repo}.git`
+
+    if (fs.existsSync(path.join(dest, '.git'))) {
+      // Fast incremental update
+      try {
+        execFileSync('git', ['fetch', '--depth', '1', 'origin', 'main'], { cwd: dest, stdio: 'pipe', timeout: 30000 })
+        execFileSync('git', ['reset', '--hard', 'origin/main'], { cwd: dest, stdio: 'pipe', timeout: 30000 })
+      } catch {
+        // Fetch failed, re-clone
+        fs.rmSync(dest, { recursive: true, force: true })
+        fs.mkdirSync(dest, { recursive: true })
+        execFileSync('git', ['clone', '--depth', '1', '--single-branch', url, dest], { stdio: 'pipe', timeout: 300000 })
+      }
+    } else {
+      // Fresh clone
+      if (fs.existsSync(dest)) fs.rmSync(dest, { recursive: true, force: true })
+      fs.mkdirSync(dest, { recursive: true })
+      execFileSync('git', ['clone', '--depth', '1', '--single-branch', url, dest], { stdio: 'pipe', timeout: 300000 })
+    }
+
+    // Validate expected files exist
+    const checkDir = src.subdir ? path.join(dest, src.subdir) : dest
+    if (isSnippets) {
+      // Snippets need contributes.snippets in package.json
+      if (!fs.existsSync(path.join(checkDir, 'package.json')))
+        throw new Error(`package.json not found in ${src.subdir ? src.subdir : 'root'} of ${src.repo}`)
+    }
+    return checkDir
+  }
+
+  if (src.type === 'npm' && src.package) {
+    // npm packages: re-download if stale or missing
+    const metaPath = path.join(dest, '.npm-meta.json')
+    let stale = !fs.existsSync(dest) || !fs.existsSync(path.join(dest, 'package.json'))
+    if (!stale) {
+      try {
+        const meta = JSON.parse(fs.readFileSync(metaPath, 'utf-8'))
+        const age = (Date.now() - new Date(meta.fetched).getTime()) / 1000 / 86400
+        if (age > CACHE_TTL_DAYS) stale = true
+      } catch { stale = true }
+    }
+    if (stale || process.env.NO_CACHE) {
+      if (fs.existsSync(dest)) fs.rmSync(dest, { recursive: true, force: true })
+      fs.mkdirSync(dest, { recursive: true })
+      const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'npm-'))
+      try {
+        execFileSync('npm', ['pack', src.package], { cwd: tmp, stdio: 'pipe', timeout: 60000 })
+      } catch (e) {
+        fs.rmSync(tmp, { recursive: true, force: true })
+        fs.rmSync(dest, { recursive: true, force: true })
+        throw e
+      }
+      const tarball = fs.readdirSync(tmp).find(f => f.endsWith('.tgz'))
+      if (!tarball) { fs.rmSync(tmp, { recursive: true, force: true }); throw new Error(`npm pack failed for ${src.package}`) }
+      execFileSync('tar', ['xzf', path.join(tmp, tarball)], { cwd: dest, stdio: 'pipe' })
+      if (fs.existsSync(path.join(dest, 'package'))) {
+        for (const f of fs.readdirSync(path.join(dest, 'package')))
+          fs.cpSync(path.join(dest, 'package', f), path.join(dest, f), { recursive: true })
+        fs.rmSync(path.join(dest, 'package'), { recursive: true, force: true })
+      }
+      fs.rmSync(tmp, { recursive: true, force: true })
+      fs.writeFileSync(metaPath, JSON.stringify({ fetched: new Date().toISOString() }))
+    }
+    return dest
+  }
+
+  throw new Error(`Unknown source type: ${src.type}`)
+}
+
+async function testOne(entry: RegistryEntry, presets: any): Promise<string | null> {
+  let inputDir: string
+  try {
+    inputDir = downloadOrCached(entry)
+  } catch (e: any) {
+    return `download: ${e.message}`
+  }
+
+  const outputDir = path.join(TEST_OUTPUT, entry.name)
+  fs.mkdirSync(outputDir, { recursive: true })
+  try {
+    await convert({ input: inputDir, output: outputDir, convert: entry.convert, presets })
+  } catch (e: any) {
+    return `convert: ${e.message}`
+  }
+
+  const hasPkg = fs.existsSync(path.join(outputDir, 'package.json'))
+  const hasNonSource = entry.convert.some(s => s.type !== 'source' && s.type !== 'mark-unsupported')
+  const isSnippets = entry.convert.some(s => s.type === 'snippets')
+
+  // Read output package.json if it exists
+  let pkg: any = null
+  if (hasPkg) {
+    try { pkg = JSON.parse(fs.readFileSync(path.join(outputDir, 'package.json'), 'utf-8')) } catch {}
+  }
+
+  try {
+    if (isSnippets) {
+      // Snippets: must have package.json + activationEvents + src/index.ts + snippet files copied
+      if (!pkg) return 'missing package.json'
+      if (!pkg.name) return 'package.json missing name'
+      if (!pkg.activationEvents?.length) return 'package.json missing activationEvents'
+      if (!fs.existsSync(path.join(outputDir, 'src', 'index.ts'))) return 'missing src/index.ts'
+      // Check contributed snippet files actually exist in output
+      const contributed = pkg.contributes?.snippets
+      if (contributed?.length) {
+        const missing = contributed.filter((s: any) => !fs.existsSync(path.join(outputDir, s.path)))
+        if (missing.length > 0) {
+          return `${missing.length} snippet files not copied (e.g. ${missing[0].path})`
+        }
+      }
+    } else if (hasNonSource) {
+      // language-client / bridge: must have package.json + entry point + esbuild.mjs
+      if (!pkg) return 'no output (package.json missing)'
+      if (!pkg.name) return 'package.json missing name'
+      if (!pkg.main) return 'package.json missing main'
+      if (!fs.existsSync(path.join(outputDir, 'esbuild.mjs'))) return 'missing esbuild.mjs'
+      // Check generated entry point exists
+      if (!fs.existsSync(path.join(outputDir, 'src', 'index.ts')) && !fs.existsSync(path.join(outputDir, 'src', 'bridge.ts'))) {
+        return 'missing generated entry (src/index.ts or src/bridge.ts)'
+      }
+    } else {
+      // Source-only: conversion may produce no output if no vscode imports found (expected)
+      if (pkg) {
+        if (!pkg.name) return 'package.json missing name'
+        // Check at least some source files were copied
+        const srcDir = path.join(outputDir, 'src')
+        if (fs.existsSync(srcDir)) {
+          const files = fs.readdirSync(srcDir).filter(f => f.endsWith('.ts') || f.endsWith('.js'))
+          if (files.length === 0) return 'no source files in src/'
+        }
+      }
+    }
+  } catch (e: any) {
+    return `validate: ${e.message}`
+  }
+
+  return null // success
+}
+
+async function main() {
+  if (process.env.HTTPS_PROXY || process.env.HTTP_PROXY || process.env.ALL_PROXY)
+    console.log(`Proxy: ${process.env.HTTPS_PROXY || process.env.HTTP_PROXY || process.env.ALL_PROXY}`)
+  console.log(`Concurrency: ${CONCURRENCY}\n`)
+
+  const registry: RegistryEntry[] = JSON.parse(fs.readFileSync(REGISTRY_PATH, 'utf-8'))
+  const presets = fs.existsSync(PRESETS_PATH) ? JSON.parse(fs.readFileSync(PRESETS_PATH, 'utf-8')) : undefined
+  console.log(`Total: ${registry.length} entries\n`)
+
+  if (fs.existsSync(TEST_OUTPUT)) fs.rmSync(TEST_OUTPUT, { recursive: true, force: true })
+
+  let completed = 0
+  const failures: Array<{ name: string; error: string }> = []
+  const startTime = Date.now()
+  const total = registry.length
+
+  // Process with concurrency
+  const pool = new Set<Promise<void>>()
+  for (const entry of registry) {
+    const p = (async () => {
+      const err = await testOne(entry, presets)
+      completed++
+      const pct = (completed / total * 100).toFixed(0)
+      if (err) {
+        failures.push({ name: entry.name, error: err })
+        process.stdout.write(`\r[${pct}%] ${completed}/${total}  FAIL  ${entry.name}        \n`)
+      } else {
+        process.stdout.write(`\r[${pct}%] ${completed}/${total}  PASS  ${entry.name}            `)
+      }
+    })()
+    pool.add(p)
+    p.finally(() => pool.delete(p))
+    if (pool.size >= CONCURRENCY) await Promise.race(pool)
+  }
+  await Promise.allSettled(pool)
+  console.log('')
+
+  // Cleanup
+  if (fs.existsSync(TEST_OUTPUT)) fs.rmSync(TEST_OUTPUT, { recursive: true, force: true })
+
+  const elapsed = ((Date.now() - startTime) / 1000).toFixed(0)
+  console.log(`\n${completed} done in ${elapsed}s — ${total - failures.length} passed, ${failures.length} failed`)
+  if (failures.length > 0) {
+    console.log('\nFailures:')
+    for (const f of failures) console.log(`  ${f.name}: ${f.error}`)
+    process.exit(1)
+  }
+}
+
+main().catch(e => { console.error('\nFatal:', e); process.exit(1) })

package/converter/src/cli.ts

@@ -23,7 +23,10 @@ program
     let steps: any[]
     let presets: any
     if (opts.presetsFile) {
-      try { presets = JSON.parse(fs.readFileSync(opts.presetsFile, 'utf-8')) } catch {}
+      try { presets = JSON.parse(fs.readFileSync(opts.presetsFile, 'utf-8')) } catch (e: any) {
+        console.error(`invalid --presets-file: ${e.message}`)
+        process.exit(1)
+      }
     }
     if (opts.convertFile) {
       try {

package/converter/src/convert.test.ts

@@ -0,0 +1,292 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import * as path from 'path'
+import * as os from 'os'
+import * as fs from 'fs'
+
+describe('convert main flow', () => {
+  let tmpdir: string
+  let outdir: string
+
+  beforeEach(() => {
+    tmpdir = fs.mkdtempSync(path.join(os.tmpdir(), 'convert-test-'))
+    outdir = tmpdir + '/output'
+    // Create minimal input
+    fs.mkdirSync(path.join(tmpdir, 'src'), { recursive: true })
+  })
+
+  afterEach(() => {
+    fs.rmSync(tmpdir, { recursive: true, force: true })
+  })
+
+  function writeInput(rel: string, content: string) {
+    const fp = path.join(tmpdir, rel)
+    fs.mkdirSync(path.dirname(fp), { recursive: true })
+    fs.writeFileSync(fp, content)
+  }
+
+  it('produces package.json with correct structure', async () => {
+    writeInput('package.json', JSON.stringify({ name: 'test-ext', description: 'Test' }))
+    writeInput('src/extension.ts', `import * as vscode from 'vscode'\nexport function activate() {}`)
+    const { convert } = await import('./convert.js')
+    await convert({
+      input: tmpdir,
+      output: outdir,
+      convert: [{ type: 'source', transforms: ['import-mapping'] }],
+    })
+    const pkg = JSON.parse(fs.readFileSync(path.join(outdir, 'package.json'), 'utf-8'))
+    expect(pkg.name).toBe('coc-test-ext')
+    expect(pkg.main).toBe('lib/index.js')
+    expect(pkg.engines.coc).toBe('^0.0.82')
+    expect(pkg.activationEvents).toEqual(['onLanguage'])
+  })
+
+  it('generates esbuild.mjs config', async () => {
+    writeInput('package.json', JSON.stringify({ name: 'test-ext' }))
+    writeInput('src/extension.ts', `import * as vscode from 'vscode'\nexport function activate() {}`)
+    const { convert } = await import('./convert.js')
+    await convert({
+      input: tmpdir,
+      output: outdir,
+      convert: [{ type: 'source', transforms: [] }],
+    })
+    expect(fs.existsSync(path.join(outdir, 'esbuild.mjs'))).toBe(true)
+    const esbuild = fs.readFileSync(path.join(outdir, 'esbuild.mjs'), 'utf-8')
+    expect(esbuild).toContain("entryPoints: ['src/extension.ts']")
+    expect(esbuild).toContain('external:')
+    expect(esbuild).toContain("outfile: 'lib/index.js'")
+  })
+
+  it('generates coc-convert.json metadata', async () => {
+    writeInput('package.json', JSON.stringify({ name: 'test-ext' }))
+    writeInput('src/extension.ts', `import * as vscode from 'vscode'\nexport function activate() {}`)
+    const { convert } = await import('./convert.js')
+    await convert({
+      input: tmpdir,
+      output: outdir,
+      convert: [{ type: 'source', transforms: [] }],
+    })
+    const meta = JSON.parse(fs.readFileSync(path.join(outdir, 'coc-convert.json'), 'utf-8'))
+    expect(meta.entryPoint).toBeTruthy()
+    expect(meta.activationEvents).toBeDefined()
+    expect(meta.hasLanguageClient).toBe(false)
+  })
+
+  it('replaces getWordRangeAtPosition in source files', async () => {
+    writeInput('package.json', JSON.stringify({ name: 'test-ext' }))
+    writeInput('src/extension.ts', `import * as vscode from 'vscode'\nconst range = document.getWordRangeAtPosition(pos, /\\w+/)`)
+    const { convert } = await import('./convert.js')
+    await convert({
+      input: tmpdir,
+      output: outdir,
+      convert: [{ type: 'source', transforms: [] }],
+    })
+    const content = fs.readFileSync(path.join(outdir, 'src', 'extension.ts'), 'utf-8')
+    expect(content).toContain('document.getText()')
+    expect(content).not.toContain('const range = document.getWordRangeAtPosition(')
+  })
+
+  it('replaces .fileName with Uri.parse().fsPath', async () => {
+    writeInput('package.json', JSON.stringify({ name: 'test-ext' }))
+    writeInput('src/extension.ts', `import * as vscode from 'vscode'\nconst name = document.fileName`)
+    const { convert } = await import('./convert.js')
+    await convert({
+      input: tmpdir,
+      output: outdir,
+      convert: [{ type: 'source', transforms: [] }],
+    })
+    const content = fs.readFileSync(path.join(outdir, 'src', 'extension.ts'), 'utf-8')
+    expect(content).toContain('Uri.parse(document.uri).fsPath')
+    expect(content).not.toContain('document.fileName')
+  })
+
+  it('replaces .uri.fsPath with Uri.parse().fsPath', async () => {
+    writeInput('package.json', JSON.stringify({ name: 'test-ext' }))
+    writeInput('src/extension.ts', `import * as vscode from 'vscode'\nconst p = document.uri.fsPath`)
+    const { convert } = await import('./convert.js')
+    await convert({
+      input: tmpdir,
+      output: outdir,
+      convert: [{ type: 'source', transforms: [] }],
+    })
+    const content = fs.readFileSync(path.join(outdir, 'src', 'extension.ts'), 'utf-8')
+    expect(content).toContain('Uri.parse(document.uri).fsPath')
+    expect(content).not.toContain('document.uri.fsPath')
+  })
+
+  it('injects Uri import when Uri.parse() is introduced', async () => {
+    writeInput('package.json', JSON.stringify({ name: 'test-ext' }))
+    writeInput('src/extension.ts', `import * as vscode from 'vscode'\nimport { workspace } from 'coc.nvim'\nconst p = document.uri.fsPath`)
+    const { convert } = await import('./convert.js')
+    await convert({
+      input: tmpdir,
+      output: outdir,
+      convert: [{ type: 'source', transforms: [] }],
+    })
+    const content = fs.readFileSync(path.join(outdir, 'src', 'extension.ts'), 'utf-8')
+    expect(content).toContain('Uri')
+  })
+
+  it('handles fileName destructuring', async () => {
+    writeInput('package.json', JSON.stringify({ name: 'test-ext' }))
+    writeInput('src/extension.ts', `import * as vscode from 'vscode'\nconst { fileName } = document;`)
+    const { convert } = await import('./convert.js')
+    await convert({
+      input: tmpdir,
+      output: outdir,
+      convert: [{ type: 'source', transforms: [] }],
+    })
+    const content = fs.readFileSync(path.join(outdir, 'src', 'extension.ts'), 'utf-8')
+    expect(content).toContain('fileName = Uri.parse')
+    expect(content).not.toContain('{ fileName }')
+  })
+
+  it('preserves source plugin contributes.configuration in output package.json', async () => {
+    writeInput('package.json', JSON.stringify({
+      name: 'test-ext',
+      contributes: {
+        configuration: {
+          title: 'Test',
+          properties: {
+            'test.enable': { type: 'boolean', default: true },
+          },
+        },
+      },
+    }))
+    writeInput('src/extension.ts', `import * as vscode from 'vscode'\nexport function activate() {}`)
+    const { convert } = await import('./convert.js')
+    await convert({
+      input: tmpdir,
+      output: outdir,
+      convert: [{ type: 'source', transforms: [] }],
+    })
+    const pkg = JSON.parse(fs.readFileSync(path.join(outdir, 'package.json'), 'utf-8'))
+    expect(pkg.contributes.configuration.properties['test.enable']).toBeTruthy()
+  })
+
+  it('preserves source contributes.commands in output package.json', async () => {
+    writeInput('package.json', JSON.stringify({
+      name: 'test-ext',
+      contributes: {
+        commands: [{ command: 'test.doStuff', title: 'Do Stuff' }],
+      },
+    }))
+    writeInput('src/extension.ts', `import * as vscode from 'vscode'\nexport function activate() {}`)
+    const { convert } = await import('./convert.js')
+    await convert({
+      input: tmpdir,
+      output: outdir,
+      convert: [{ type: 'source', transforms: [] }],
+    })
+    const pkg = JSON.parse(fs.readFileSync(path.join(outdir, 'package.json'), 'utf-8'))
+    expect(pkg.contributes.commands).toHaveLength(1)
+    expect(pkg.contributes.commands[0].command).toBe('test.doStuff')
+  })
+
+  it('preserves contributes.snippets in output', async () => {
+    writeInput('package.json', JSON.stringify({
+      name: 'test-snippets',
+      contributes: {
+        snippets: [{ language: 'javascript', path: './snippets/javascript.json' }],
+      },
+    }))
+    writeInput('src/extension.ts', `import * as vscode from 'vscode'\nexport function activate() {}`)
+    const { convert } = await import('./convert.js')
+    await convert({
+      input: tmpdir,
+      output: outdir,
+      convert: [{ type: 'source', transforms: [] }],
+    })
+    const pkg = JSON.parse(fs.readFileSync(path.join(outdir, 'package.json'), 'utf-8'))
+    expect(pkg.contributes.snippets).toHaveLength(1)
+    expect(pkg.contributes.snippets[0].language).toBe('javascript')
+  })
+
+  it('handles language-client step with module server', async () => {
+    writeInput('package.json', JSON.stringify({
+      name: 'test-ls',
+      description: 'Test LS',
+      dependencies: { 'test-server': '^1.0.0' },
+    }))
+    writeInput('src/extension.ts', `import * as vscode from 'vscode'\nexport function activate() {}`)
+    const { convert } = await import('./convert.js')
+    await convert({
+      input: tmpdir,
+      output: outdir,
+      convert: [
+        {
+          type: 'language-client',
+          server: { kind: 'module', package: 'test-server' },
+          languages: ['test'],
+        },
+        { type: 'source', transforms: ['import-mapping'] },
+      ],
+    })
+    expect(fs.existsSync(path.join(outdir, 'src', 'index.ts'))).toBe(true)
+    const index = fs.readFileSync(path.join(outdir, 'src', 'index.ts'), 'utf-8')
+    expect(index).toContain('LanguageClient')
+    expect(index).toContain("from 'coc.nvim'")
+
+    const pkg = JSON.parse(fs.readFileSync(path.join(outdir, 'package.json'), 'utf-8'))
+    expect(pkg.dependencies['test-server']).toBe('^1.0.0')
+  })
+
+  it('handles binary server language-client step', async () => {
+    writeInput('package.json', JSON.stringify({ name: 'binary-ls' }))
+    writeInput('src/extension.ts', `import * as vscode from 'vscode'\nexport function activate() {}`)
+    const { convert } = await import('./convert.js')
+    await convert({
+      input: tmpdir,
+      output: outdir,
+      convert: [
+        {
+          type: 'language-client',
+          server: {
+            kind: 'binary',
+            package: 'my-server',
+            binary: { repo: 'user/repo', asset: 'server-{{version}}.tar.gz', binaryPath: 'bin/srv' },
+          },
+          languages: ['test'],
+        },
+      ],
+    })
+    const meta = JSON.parse(fs.readFileSync(path.join(outdir, 'coc-convert.json'), 'utf-8'))
+    expect(meta.serverBinary).toBeTruthy()
+    expect(meta.serverBinary.repo).toBe('user/repo')
+    expect(meta.hasLanguageClient).toBe(true)
+  })
+
+  it('copies .ts and .js source files to output', async () => {
+    writeInput('package.json', JSON.stringify({ name: 'test-ext' }))
+    writeInput('src/extension.ts', `import * as vscode from 'vscode'\nexport function activate() {}`)
+    writeInput('src/helper.ts', `export function helper() {}`)
+    writeInput('src/legacy.js', `module.exports = {}`)
+    const { convert } = await import('./convert.js')
+    await convert({
+      input: tmpdir,
+      output: outdir,
+      convert: [{ type: 'source', transforms: [] }],
+    })
+    expect(fs.existsSync(path.join(outdir, 'src', 'extension.ts'))).toBe(true)
+    expect(fs.existsSync(path.join(outdir, 'src', 'helper.ts'))).toBe(true)
+    expect(fs.existsSync(path.join(outdir, 'src', 'legacy.js'))).toBe(true)
+  })
+
+  it('outputs entry point src/index.ts for language-client', async () => {
+    writeInput('package.json', JSON.stringify({ name: 'ls-ext' }))
+    writeInput('src/extension.ts', `import * as vscode from 'vscode'\nexport function activate() {}`)
+    const { convert } = await import('./convert.js')
+    await convert({
+      input: tmpdir,
+      output: outdir,
+      convert: [
+        {
+          type: 'language-client',
+          server: { kind: 'module', package: 'ls-srv' },
+          languages: ['test'],
+        },
+      ],
+    })
+    const esbuild = fs.readFileSync(path.join(outdir, 'esbuild.mjs'), 'utf-8')
+    expect(esbuild).toContain("entryPoints: ['src/index.ts']")
+  })
+})

package/converter/src/convert.ts

@@ -199,7 +199,9 @@ export async function convert(opts: ConvertOptions): Promise<void> {
           changed = true
         }
 
-        if (content.includes('.fileName') || content.includes('.uri.fsPath')) {
+        const hasFileNameRef = content.includes('.fileName') || content.includes('.uri.fsPath')
+        const hasFileNameDestructuring = /(const|let|var)\s*\{[^}]*\bfileName\b[^}]*\}\s*=\s*(document|doc|textDocument)/.test(content)
+        if (hasFileNameRef || hasFileNameDestructuring) {
           // .fileName → Uri.parse($1.uri).fsPath (coc's TextDocument#uri returns a file:// URI string)
           content = content.replace(/(document|this\.document|textDocument|scope|doc)\.fileName/g, 'Uri.parse($1.uri).fsPath')
           // Handle destructuring: const { fileName, ...rest } = document/doc/textDocument
@@ -285,12 +287,12 @@ export async function convert(opts: ConvertOptions): Promise<void> {
   // Collect all runtime deps from origPkg (deps + devDeps, filtered)
   const origDeps: Record<string, string> = {}
   {
-    const allPkgDeps = { ...origPkg.dependencies, ...origPkg.devDependencies }
+    const allPkgDeps = { ...origPkg.devDependencies, ...origPkg.dependencies }
     for (const [dep, ver] of Object.entries(allPkgDeps)) {
       const v = ver as string
       if (v.startsWith('workspace:')) continue
       if (dep.startsWith('@types/')) continue
-      if (['typescript', 'mocha', 'c8', 'prettier', 'rollup', 'esbuild', '@vscode/'].some(p => dep.startsWith(p))) continue
+      if (['typescript', 'mocha', 'c8', 'prettier', 'rollup', 'esbuild', '@vscode/test-electron'].some(p => dep.startsWith(p))) continue
       origDeps[dep] = v
     }
   }