coc-vscode-loader 1.1.9 → 1.2.0

package/converter/src/convert.ts

@@ -2,40 +2,70 @@ import { Project } from 'ts-morph'
 import * as fs from 'fs'
 import * as path from 'path'
 import { scan } from './scanner.js'
-import { TransformContext } from './types.js'
-import { transformImportMapping } from './transforms/import-mapping.js'
-import { transformLanguageClient } from './transforms/language-client.js'
-import { transformClassToFactory } from './transforms/class-to-factory.js'
-import { transformProviderRegister } from './transforms/provider-register.js'
-import { transformEnumOffset } from './transforms/enum-offset.js'
-import { getActivePresets, generateBridgeCode } from './presets.js'
-
-const TRANSFORMS = [
-  { name: 'import-mapping', fn: transformImportMapping },
-  { name: 'class-to-factory', fn: transformClassToFactory },
-  { name: 'provider-register', fn: transformProviderRegister },
-  { name: 'enum-offset', fn: transformEnumOffset },
-  { name: 'language-client', fn: transformLanguageClient },
-]
-
-interface Options {
+import {
+  ConvertStep,
+  isLanguageClientStep,
+  StepResult,
+} from './types.js'
+import { executeStep, getRegisteredStepTypes } from './steps/index.js'
+
+export interface ConvertOptions {
   input: string
   output: string
-  bridge?: boolean
+  convert: ConvertStep[]
+  presets?: Record<string, any>
   verbose?: boolean
 }
 
-export async function convert(opts: Options): Promise<void> {
-  const { input, output } = opts
+interface MergedResult {
+  generatedFiles: Array<{ path: string; content: string }>
+  entryPoint?: string
+  keepDeps: Record<string, string>
+  activationEvents: string[]
+  serverBinary?: {
+    repo: string
+    asset: string
+    binaryPath?: string
+    args?: string[]
+  }
+}
+
+export async function convert(opts: ConvertOptions): Promise<void> {
+  const { input, output, convert: steps, verbose } = opts
 
   if (!fs.existsSync(input)) {
     console.error(`input not found: ${input}`)
     process.exit(1)
   }
 
-  // 1. Scan
+  if (!steps || steps.length === 0) {
+    console.error('no convert steps provided (use --convert)')
+    process.exit(1)
+  }
+
+  // 1. Validate
+  const knownTypes = getRegisteredStepTypes()
+  for (const s of steps) {
+    if (!knownTypes.includes(s.type)) {
+      console.error(`unknown step type: "${s.type}". Available: ${knownTypes.join(', ')}`)
+      process.exit(1)
+    }
+    if (isLanguageClientStep(s) && s.server.kind === 'binary') {
+      if (s.server.binary?.asset) {
+        const vars = ['{{version}}', '{{platform}}', '{{arch}}', '{{rust-target}}']
+        for (const v of vars) {
+          if (s.server.binary.asset.includes(v)) break
+        }
+      }
+    }
+  }
+
+  // 2. Scan for summary (try src/ first, fall back to input root)
   console.log('Scanning...')
-  const result = scan(input)
+  let result = scan(path.join(input, 'src'))
+  if (result.files.length === 0) {
+    result = scan(input)
+  }
   console.log(result.summary)
 
   if (result.files.length === 0) {
@@ -43,285 +73,222 @@ export async function convert(opts: Options): Promise<void> {
     return
   }
 
-  // 2. Create output directory
-  if (fs.existsSync(output)) {
-    fs.rmSync(output, { recursive: true })
-  }
-  fs.mkdirSync(path.join(output, 'src'), { recursive: true })
-
   // 3. Read original package.json
   const origPkgPath = path.join(input, 'package.json')
   const origPkg = fs.existsSync(origPkgPath)
     ? JSON.parse(fs.readFileSync(origPkgPath, 'utf-8'))
     : {}
 
-  // 4. Copy source files (only .ts that have vscode usage)
-  const srcDir = path.join(input, 'src')
-  const copiedFiles: string[] = []
-  if (fs.existsSync(srcDir)) {
-    for (const file of fs.readdirSync(srcDir)) {
-      if (!file.endsWith('.ts')) continue
-      const srcPath = path.join(srcDir, file)
-      const destPath = path.join(output, 'src', file)
-      fs.copyFileSync(srcPath, destPath)
-      copiedFiles.push(file)
-    }
+  // 4. Create output directory
+  if (fs.existsSync(output)) {
+    fs.rmSync(output, { recursive: true })
   }
+  fs.mkdirSync(path.join(output, 'src'), { recursive: true })
 
-  // 5. Load files with ts-morph and apply transforms
+  // 5. Project for transforms
   const project = new Project()
-  const srcFiles = copiedFiles
-    .map(f => path.join(output, 'src', f))
-    .filter(f => fs.existsSync(f))
 
-  for (const fp of srcFiles) {
-    try { project.addSourceFileAtPath(fp) } catch {}
+  // 6. Execute steps
+  const ctx = { input, output, project, origPkg, verbose, presets: opts.presets }
+  const merged: MergedResult = {
+    generatedFiles: [],
+    entryPoint: undefined,
+    keepDeps: {},
+    activationEvents: [],
+    serverBinary: undefined,
   }
 
-  for (const file of project.getSourceFiles()) {
-    const ctx: TransformContext = { file, project }
-    for (const t of TRANSFORMS) {
-      try {
-        t.fn(ctx)
-        if (opts.verbose) console.log(`  ${t.name}: ${path.basename(file.getFilePath())}`)
-      } catch (e: any) {
-        console.warn(`  ${t.name} error: ${e.message}`)
-      }
+  const stepResults: StepResult[] = []
+  for (const step of steps) {
+    const stepVerbose = verbose || (step as any).verbose
+    if (stepVerbose) console.log(`  step: ${step.type}`)
+    const stepCtx = { ...ctx, verbose: stepVerbose }
+    const stepResult: StepResult = executeStep(stepCtx, step)
+    stepResults.push(stepResult)
+
+    // Merge
+    merged.generatedFiles.push(...stepResult.generatedFiles)
+    merged.entryPoint = stepResult.entryPoint || merged.entryPoint
+    Object.assign(merged.keepDeps, stepResult.keepDeps)
+    merged.activationEvents.push(...stepResult.activationEvents)
+    if (stepResult.serverBinary) {
+      merged.serverBinary = stepResult.serverBinary
     }
-    file.saveSync()
   }
 
-  // 6. Mark unsupported code patterns in source files
-  for (const file of result.files) {
-    if (!file.path.startsWith('src/') || !file.path.endsWith('.ts')) continue
-    const fp = path.join(output, file.path)
-    if (!fs.existsSync(fp)) continue
-
-    let content = fs.readFileSync(fp, 'utf-8')
-
-    // Mark unsupported lines
-    for (const { pattern, label } of [
-      { pattern: 'createTextEditorDecorationType', label: 'decoration API' },
-      { pattern: 'createWebviewPanel', label: 'webview API' },
-      { pattern: 'registerTreeDataProvider', label: 'tree data provider' },
-      { pattern: 'env.openExternal', label: 'env.openExternal' },
-    ]) {
-      content = content.replace(
-        new RegExp(`^(.*${pattern}.*)$`, 'gm'),
-        '// [converter] TODO: $1  — coc has no equivalent for ' + label
-      )
-    }
+  // 8. Apply code injections from steps (generic, no hardcoded plugin knowledge)
+  for (const stepResult of stepResults) {
+    if (!stepResult.codeInjections) continue
+    for (const inj of stepResult.codeInjections) {
+      const targetFile = merged.generatedFiles.find(f => f.path === inj.target)
+      if (!targetFile) continue
+
+      let content = targetFile.content
+
+      // Add import codes
+      if (inj.importCode) {
+        if (inj.importCode.endsWith(',')) {
+          // Import addition (adds a line to existing import block)
+          const marker = inj.insertBefore || "} from 'coc.nvim'"
+          if (!content.includes(inj.importCode.trim())) {
+            content = content.replace(marker, `${inj.importCode}\n${marker}`)
+          }
+        } else {
+          // Full import line
+          if (!content.includes(inj.importCode)) {
+            content = inj.importCode + '\n' + content
+          }
+        }
+      }
 
-    // Replace getWordRangeAtPosition calls with inline word boundary calculation.
-    // In coc's TextDocument there's no getWordRangeAtPosition.
-    content = content.replace(
-      /const range = document\.getWordRangeAtPosition\(([^,]+),\s*([^)]+)\)/g,
-      'const line = document.getText().split("\\n")[$1.line]; const pre = line.slice(0, $1.character); const m = pre.match($2); const range = m ? Range.create($1.line, $1.character - m[0].length, $1.line, $1.character) : undefined'
-    )
-    content = content.replace(
-      /const range = document\.getWordRangeAtPosition\(([^)]+)\)/g,
-      'const line = document.getText().split("\\n")[$1.line]; const pre = line.slice(0, $1.character); const m = pre.match(/[_a-zA-Z0-9-]+/); const range = m ? Range.create($1.line, $1.character - m[0].length, $1.line, $1.character) : undefined'
-    )
-    // Also replace usage without 'const' (already declared)
-    content = content.replace(
-      /range = document\.getWordRangeAtPosition\(([^,]+),\s*([^)]+)\)/g,
-      '(() => { const ln = document.getText().split("\\n")[$1.line]; const pr = ln.slice(0, $1.character); const mt = pr.match($2); return mt ? Range.create($1.line, $1.character - mt[0].length, $1.line, $1.character) : undefined; })()'
-    )
-    // fileName → uri (coc's DocumentUri is a string path)
-    if (content.includes('.fileName')) {
-      content = content.replace(/\.fileName/g, '.uri')
-      // uri is a full path in coc, but fileName might have had file:// prefix in vscode
-      // Add comment about potential file:// handling
-    }
+      // Insert code before a marker
+      if (inj.insertBefore && inj.code) {
+        if (!content.includes(inj.code.trim())) {
+          content = content.replace(inj.insertBefore, inj.code + inj.insertBefore)
+        }
+      }
 
-    // Remove unsupported import packages
-    content = content.replace(
-      /import .* from ['"]@volar\/vscode['"];?\n?/g,
-      ''
-    )
-    content = content.replace(
-      /import .* from ['"]reactive-vscode['"];?\n?/g,
-      ''
-    )
-    content = content.replace(
-      /import \* as lsp from ['"]@volar\/vscode\/node['"];?\n?/g,
-      ''
-    )
-
-    fs.writeFileSync(fp, content)
-  }
+      // Insert code after a marker
+      if (inj.insertAfter && inj.code) {
+        if (!content.includes(inj.code.trim())) {
+          content = content.replace(inj.insertAfter, inj.insertAfter + inj.code)
+        }
+      }
 
-  // 7. Detect config namespace from original properties
-  const origProps = origPkg.contributes?.configuration?.properties || {}
-  const configNamespace = Object.keys(origProps).length > 0
-    ? [...new Set(Object.keys(origProps).map(k => k.split('.')[0]))][0]
-    : origPkg.name || path.basename(input)
+      targetFile.content = content
+      if (verbose) console.log(`  injected into ${inj.target}: ${(inj.importCode || inj.code).substring(0, 60)}...`)
+    }
+  }
 
-  // 8. Detect server module from original source
-  const serverModuleNames = detectServerModules(input, result)
-  if (serverModuleNames.length > 0) {
-    console.log(`  detected server: ${serverModuleNames.join(', ')}`)
+  // 9. Write generated files
+  for (const gf of merged.generatedFiles) {
+    const fp = path.join(output, gf.path)
+    fs.mkdirSync(path.dirname(fp), { recursive: true })
+    fs.writeFileSync(fp, gf.content)
+    if (verbose) console.log(`  wrote: ${gf.path}`)
   }
 
-  // 9. Determine plugin type and entry point
-  const hasTsBridge = result.hasTsBridge
-  const hasServer = serverModuleNames.length > 0
-  const isDirectApi = !hasServer && !hasTsBridge
-  const pluginName = origPkg.name || path.basename(input)
-  const description = origPkg.description || ''
-  const activePresets = getActivePresets(hasTsBridge, result)
-
-  // Build server resolution code
-  const serverResolveCalls = serverModuleNames.map(name => {
-    return `\
-    try { serverModule = require.resolve('${escapeStr(name)}') } catch {}
-    try {
-      const _mainPath = require.resolve('${escapeStr(name)}/package.json');
-      let _dir = require('path').dirname(_mainPath);
-      while (_dir !== require('path').dirname(_dir)) {
-        const _pkgPath = require('path').join(_dir, 'package.json');
-        if (require('fs').existsSync(_pkgPath)) {
-          const _pkg = JSON.parse(require('fs').readFileSync(_pkgPath, 'utf-8'));
-          if (_pkg.bin) {
-            const _entry = typeof _pkg.bin === 'string' ? _pkg.bin : Object.values(_pkg.bin)[0];
-            serverModule = require('path').join(_dir, _entry);
-          }
-          break;
+  // 10. Apply text replacements to all source files (getWordRangeAtPosition, .fileName)
+  {
+    const outputSrc = path.join(output, 'src')
+    if (fs.existsSync(outputSrc)) {
+      for (const f of fs.readdirSync(outputSrc, { recursive: true })) {
+        const fp = typeof f === 'string' ? path.join(outputSrc, f) : f
+        if (!fp.endsWith('.ts')) continue
+        let content = fs.readFileSync(fp, 'utf-8')
+        let changed = false
+
+        if (content.includes('document.getWordRangeAtPosition')) {
+          // const range = document.getWordRangeAtPosition(pos, regex)
+          content = content.replace(
+            /const range = document\.getWordRangeAtPosition\(([^,]+),\s*([^)]+)\)/g,
+            'const line = document.getText().split("\\n")[$1.line]; const pre = line.slice(0, $1.character); const m = pre.match($2); const range = m ? { start: { line: $1.line, character: $1.character - m[0].length }, end: { line: $1.line, character: $1.character } } : undefined'
+          )
+          // const range = document.getWordRangeAtPosition(pos)
+          content = content.replace(
+            /const range = document\.getWordRangeAtPosition\(([^)]+)\)/g,
+            'const line = document.getText().split("\\n")[$1.line]; const pre = line.slice(0, $1.character); const m = pre.match(/[_a-zA-Z0-9-]+/); const range = m ? { start: { line: $1.line, character: $1.character - m[0].length }, end: { line: $1.line, character: $1.character } } : undefined'
+          )
+          // range = document.getWordRangeAtPosition(pos, regex) (without const)
+          content = content.replace(
+            /range = document\.getWordRangeAtPosition\(([^,]+),\s*([^)]+)\)/g,
+            '(() => { const ln = document.getText().split("\\n")[$1.line]; const pr = ln.slice(0, $1.character); const mt = pr.match($2); return mt ? { start: { line: $1.line, character: $1.character - mt[0].length }, end: { line: $1.line, character: $1.character } } : undefined; })()'
+          )
+          changed = true
         }
-        _dir = require('path').dirname(_dir);
-      }
-    } catch {}`
-  }).join('\n')
-
-  // Generate bridge code from presets
-  const bridgeCode = generateBridgeCode(activePresets)
-  const needsExtensions = activePresets.some(p => p.name === 'ts-bridge')
-  const needsCommands = activePresets.some(p => p.requiresCommand)
 
-  let fullCode = ''
-  let esbuildEntry = 'src/index.ts'
-  if (isDirectApi) {
-    esbuildEntry = 'src/extension.ts'
-  } else {
-    fullCode = `\
-import {
-  LanguageClient,
-  TransportKind,
-  workspace,
-  window,
-  commands,
-  services as cocServices,
-  ExtensionContext${needsExtensions ? ',\n  extensions' : ''},
-} from 'coc.nvim'
-import * as path from 'path'
-import * as fs from 'fs'
+        if (content.includes('.fileName') || content.includes('.uri.fsPath')) {
+          // .fileName → .uri (coc's TextDocument#uri returns a string path, not a URI object)
+          content = content.replace(/(document|this\.document|textDocument|scope)\.fileName/g, '$1.uri')
+          // .uri.fsPath → .uri (coc's uri is already a string path, not a URI object)
+          content = content.replace(/\.uri\.fsPath/g, '.uri')
+          changed = true
+        }
 
-export async function activate(context: ExtensionContext): Promise<void> {
-  try {
-${needsExtensions ? `\
-    const tsExt = extensions.all.find(e => e.id === 'coc-tsserver')
-    if (tsExt && !tsExt.isActive) { await tsExt.activate() }
-    const tsSvc = cocServices.getService('tsserver')
-    if (tsSvc) { await tsSvc.start() }
-` : ''}\
-    const config = workspace.getConfiguration('${escapeStr(configNamespace)}')
-    let serverModule = config.get<string>('server.path', '')
-    if (serverModule) {
-      serverModule = path.isAbsolute(serverModule) ? serverModule : path.join(workspace.root, serverModule)
-    }
-    if (!serverModule || !fs.existsSync(serverModule)) {
-${serverResolveCalls}
+        if (changed) fs.writeFileSync(fp, content)
+      }
     }
-    if (!serverModule) { window.showErrorMessage('Cannot find language server.'); return }
-
-    const client = new LanguageClient(
-      '${escapeStr(pluginName)}',
-      '${escapeStr(description || pluginName)}',
-      { module: serverModule, transport: TransportKind.ipc },
-      {
-        documentSelector: [{ language: '${escapeStr(configNamespace)}', scheme: 'file' }],
-        outputChannelName: '${escapeStr(description || pluginName)}',
-      },
-    )
-    context.subscriptions.push({ dispose: () => client.stop() })
-    context.subscriptions.push(cocServices.registerLanguageClient(client))
-    client.start()
-
-${bridgeCode ? bridgeCode + '\n\n' : ''}\
-    // Restart command
-    context.subscriptions.push(
-      commands.registerCommand('${escapeStr(pluginName)}.restartServer', async () => {
-        await client.stop()
-        client.start()
-      }),
-    )
-  } catch (e: any) {
-    window.showErrorMessage('${escapeStr(pluginName)} error: ' + (e.message || String(e)))
-  }
-}
-`
   }
-  if (fullCode) {
-    fs.writeFileSync(path.join(output, 'src', 'index.ts'), fullCode)
+
+  // 12. Determine entry point
+  const hasLanguageClient = steps.some(s => s.type === 'language-client')
+
+  // If language-client step exists, it generates src/index.ts as entry.
+  // If source step provides an entry point, the generated index.ts imports it.
+  // For source-only plugins, entry is the source entry.
+  let esbuildEntry = 'src/index.ts'
+  if (!hasLanguageClient) {
+    esbuildEntry = merged.entryPoint
+      ? `src/${merged.entryPoint.replace(/^src\//, '')}`
+      : 'src/extension.ts'
   }
 
-  // 10. Detect dependencies from original package.json + preset extras
+  // 13. Generate package.json
+  const pluginName = origPkg.name || path.basename(input)
+
+  // Detect config namespace (from original contributes.properties or name)
+  const origProps = origPkg.contributes?.configuration?.properties || {}
+  const configNamespace = Object.keys(origProps).length > 0
+    ? [...new Set(Object.keys(origProps).map((k: string) => k.split('.')[0]))][0]
+    : pluginName
+
+  // For bridge mode: detect TypeScript plugins from source + origPkg
+  const hasBridge = steps.some(s => s.type === 'bridge')
+  const tsPlugins = hasBridge ? scanTypeScriptPlugins(input, origPkg) : []
+  const description = origPkg.description || ''
+
+  const activationEvents = merged.activationEvents.length > 0
+    ? merged.activationEvents
+    : ['onLanguage']
+
+  // Gather server deps: for module-kind language-client steps
   const serverDeps: Record<string, string> = {}
-  // Add preset extra deps (e.g. typescript for ts-bridge)
-  for (const preset of activePresets) {
-    for (const dep of (preset.extraDeps || [])) {
-      if (!serverDeps[dep]) serverDeps[dep] = '*'
-    }
-  }
-  if (isDirectApi) {
-    // Non-LSP: keep all original deps (including devDeps, since they may be imported at runtime)
-    const allDeps = { ...origPkg.dependencies, ...origPkg.devDependencies }
-    for (const [dep, ver] of Object.entries(allDeps)) {
-      if (ver.startsWith('workspace:')) continue
-      if (dep.startsWith('@types/')) continue // skip type packages
-      if (['typescript', 'mocha', 'c8', 'prettier', 'rollup', '@vscode/'].some(p => dep.startsWith(p))) continue
-      if (['tslib'].includes(dep)) continue
-      serverDeps[dep] = ver as string
-    }
-  } else {
-    // LSP-based: only include server-related dependencies
-    const knownPatterns = ['language-server', 'language-server/node', '-server', 'languageserver', '/lsp']
-    for (const [dep, ver] of Object.entries(origPkg.dependencies || {})) {
-      if (ver.startsWith('workspace:')) {
-        // Workspace deps: if it matches a known server pattern, add with wildcard version
-        if (knownPatterns.some(p => dep.includes(p))) {
-          serverDeps[dep] = '*'
-        }
-        continue
-      }
-      if (knownPatterns.some(p => dep.includes(p))) {
-        serverDeps[dep] = ver as string
+  for (const s of steps) {
+    if (isLanguageClientStep(s) && s.server.kind === 'module') {
+      const pkg = s.server.package
+      const ver = origPkg.dependencies?.[pkg] || origPkg.devDependencies?.[pkg]
+      if (ver && ver.startsWith('workspace:')) {
+        serverDeps[pkg] = '*' // monorepo workspace → wildcard for npm
+      } else {
+        serverDeps[pkg] = ver || '*'
       }
     }
-    for (const name of serverModuleNames) {
-      const pkgName = name.startsWith('@') ? name.split('/').slice(0, 2).join('/') : name.split('/')[0]
-      if (!serverDeps[pkgName]) serverDeps[pkgName] = '*'
+  }
+
+  // Collect all runtime deps from origPkg (deps + devDeps, filtered)
+  const origDeps: Record<string, string> = {}
+  {
+    const allPkgDeps = { ...origPkg.dependencies, ...origPkg.devDependencies }
+    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
+      origDeps[dep] = v
     }
   }
-  const activationEvents = Array.isArray(origPkg.activationEvents) ? origPkg.activationEvents : []
-  const activationEvent = activationEvents.find((e: string) => e.startsWith('onLanguage:'))
-    || (activationEvents.includes('*') ? '*' : undefined)
-    || (activationEvents.includes('onStartupFinished') ? '*' : undefined)
-    || `onLanguage:${configNamespace}`
-    || 'onLanguage'
+
+  const deps: Record<string, string> = {
+    ...serverDeps,
+    ...origDeps,
+    ...merged.keepDeps,
+  }
+  // Fix workspace: protocol deps (monorepo, invalid in npm) → wildcard
+  for (const k of Object.keys(deps)) {
+    if (typeof deps[k] === 'string' && deps[k].startsWith('workspace:')) deps[k] = '*'
+  }
+
   const pkg = {
     name: pluginName.startsWith('coc-') ? pluginName : `coc-${pluginName}`,
     version: origPkg.version || '0.1.0',
-    dependencies: {
-      ...serverDeps,
-    },
+    description,
+    main: 'lib/index.js',
+    engines: { coc: '^0.0.82' },
+    activationEvents,
+    dependencies: deps,
     devDependencies: {
       esbuild: '^0.28.0',
     },
-    description: description,
-    main: 'lib/index.js',
-    engines: { coc: '^0.0.82' },
-    activationEvents: [activationEvent],
     contributes: {
       configuration: origPkg.contributes?.configuration ? {
         type: 'object',
@@ -332,39 +299,42 @@ ${bridgeCode ? bridgeCode + '\n\n' : ''}\
         command: c.command,
         title: c.title,
       })) || undefined,
-      ...(hasTsBridge ? {
-        typescriptServerPlugins: (origPkg.contributes?.typescriptServerPlugins?.length
-          ? origPkg.contributes?.typescriptServerPlugins
-          : scanTypeScriptPlugins(input, result).map(p => ({
-              ...p,
-              languages: p.languages.length ? p.languages : [configNamespace],
-            }))
-        ) || [],
+      ...(tsPlugins.length > 0 ? {
+        typescriptServerPlugins: tsPlugins.map(p => ({
+          ...p,
+          languages: p.languages.length ? p.languages : [configNamespace],
+        })),
       } : {}),
     },
   }
 
   // Clean null fields
-  for (const key of ['configuration', 'commands'] as const) {
-    if (!pkg.contributes[key]) delete pkg.contributes[key]
-  }
-  if (Object.keys(pkg.contributes).length === 0) delete pkg.contributes
+  if (!pkg.contributes?.configuration) delete (pkg.contributes as any).configuration
+  if (!pkg.contributes?.commands) delete (pkg.contributes as any).commands
+  if (Object.keys(pkg.contributes).length === 0) delete (pkg as any).contributes
 
   fs.writeFileSync(path.join(output, 'package.json'), JSON.stringify(pkg, null, 2))
 
-  // 10. Generate esbuild config
-  const externalMods = ['coc.nvim', ...serverModuleNames]
-    .map(n => n.startsWith('@') ? n.split('/').slice(0, 2).join('/') : n.split('/')[0])
-    .filter((v, i, a) => v && a.indexOf(v) === i)
+  // 14. Generate esbuild config — externalize all runtime deps
+  const externalMods = [
+    'coc.nvim',
+    ...Object.keys(serverDeps),
+    ...Object.keys(merged.keepDeps),
+    ...Object.keys(origDeps),
+  ].flatMap(n => {
+    if (n.startsWith('@')) return n.split('/').slice(0, 2).join('/')
+    return n.split('/')[0]
+  }).filter((v, i, a) => v && a.indexOf(v) === i)
+
   const esbuildConfig = `\
 import * as esbuild from 'esbuild'
 
 const options = {
-  entryPoints: ['${escapeStr(esbuildEntry)}'],
+  entryPoints: ['${esbuildEntry}'],
   bundle: true,
   minify: false,
   mainFields: ['module', 'main'],
-  external: [${externalMods.map(m => `'${escapeStr(m)}'`).join(', ')}],
+  external: [${externalMods.map(m => `'${m}'`).join(', ')}],
   platform: 'node',
   target: 'node18',
   outfile: 'lib/index.js',
@@ -378,35 +348,40 @@ if (result.errors.length) {
 `
   fs.writeFileSync(path.join(output, 'esbuild.mjs'), esbuildConfig)
 
-  // 11. Generate report
+  // 15. Write step metadata for pipeline
+  const meta = {
+    entryPoint: esbuildEntry,
+    activationEvents,
+    keepDeps: merged.keepDeps,
+    serverDeps,
+    serverBinary: merged.serverBinary,
+    hasLanguageClient,
+  }
+  fs.writeFileSync(path.join(output, 'coc-convert.json'), JSON.stringify(meta, null, 2))
+
+  // 16. Print report
   console.log('\n=== Conversion Report ===')
   console.log(`  Plugin: ${pkg.name}`)
-  console.log(`  Type: ${hasTsBridge ? 'ts-bridge' : 'pure-lsp'}`)
-  console.log(`  Source files: ${copiedFiles.length + (hasTsBridge ? 0 : 0)}`)
-
-  if (hasTsBridge) {
-    console.log('\n  ⚠ TS-bridge mode:')
-    console.log('    - Generated src/index.ts with tsserver/request bridge')
-    console.log('    - Package.json includes typescriptServerPlugins')
-    console.log('    - Requires modified coc-tsserver (PR #493)')
-    console.log('    - Install: cd ~/.config/coc/extensions && npm install ChuYanLon/coc-tsserver')
+  console.log(`  Steps: ${steps.map(s => s.type).join(' → ')}`)
+  console.log(`  Source files: ${result.files.length}`)
+  console.log(`  Activation: ${activationEvents.join(', ')}`)
+
+  if (merged.serverBinary) {
+    console.log(`  Server binary: ${merged.serverBinary.repo}`)
   }
 
   console.log(`\n  ${output}/`)
-  console.log('    ├── src/index.ts         ← main entry')
-  console.log('    ├── package.json         ← coc plugin config')
-  console.log('    ├── esbuild.mjs          ← build config')
-  console.log('    └── src/*.ts             ← converted source')
+  console.log('    ├── package.json')
+  console.log('    ├── esbuild.mjs')
+  console.log('    ├── coc-convert.json')
+  if (hasLanguageClient) console.log('    ├── src/index.ts         ← generated entry')
+  console.log('    ├── src/*.ts             ← converted source')
   console.log('\n  Next:')
   console.log(`    cd ${output}`)
   console.log('    npm install')
-  console.log('    npm run build')
+    console.log('    npx tsx esbuild.mjs')
 }
 
-/**
- * Scan original source for TypeScript plugin names used by the extension.
- * Checks: explicit imports, require() calls, package.json dependencies.
- */
 function walkTsFiles(dir: string): string[] {
   const files: string[] = []
   try {
@@ -414,6 +389,7 @@ function walkTsFiles(dir: string): string[] {
       const full = path.join(dir, entry)
       const stat = fs.statSync(full)
       if (stat.isDirectory()) {
+        if (entry.startsWith('.') || entry === 'node_modules') continue
         files.push(...walkTsFiles(full))
       } else if (entry.endsWith('.ts') || entry.endsWith('.d.ts')) {
         files.push(full)
@@ -423,79 +399,36 @@ function walkTsFiles(dir: string): string[] {
   return files
 }
 
-function scanTypeScriptPlugins(input: string, _result: any): Array<{ name: string; languages: string[]; enableForWorkspaceTypeScriptVersions: boolean }> {
+function scanTypeScriptPlugins(input: string, origPkg: Record<string, any>): Array<{ name: string; languages: string[]; enableForWorkspaceTypeScriptVersions: boolean }> {
+  // First check if origPkg already has typescriptServerPlugins configured
+  if (origPkg.contributes?.typescriptServerPlugins?.length) {
+    return origPkg.contributes.typescriptServerPlugins.map((p: any) => ({
+      name: p.name,
+      languages: p.languages || [],
+      enableForWorkspaceTypeScriptVersions: p.enableForWorkspaceTypeScriptVersions ?? true,
+    }))
+  }
+
+  // Otherwise scan source files for plugin references
   const plugins: Array<{ name: string; languages: string[]; enableForWorkspaceTypeScriptVersions: boolean }> = []
-  const scanDir = path.join(input, 'src')
+  let scanDir = path.join(input, 'src')
+  if (!fs.existsSync(scanDir)) scanDir = input
   if (!fs.existsSync(scanDir)) return plugins
 
-  // Collect all .ts file content (recursive)
-  const allContent = walkTsFiles(scanDir).map(f => fs.readFileSync(f, 'utf-8'))
-  const content = allContent.join('\n')
-
-  // Check for plugin names in require() / import statements
-  // Patterns like: @vue/typescript-plugin, @angular/language-service, etc.
-  const pluginRefs = content.matchAll(/['"](@[^'"]+\/(?:typescript-plugin|language-service)[^'"]*)['"]|['"](\w+(?:-typescript-plugin|-language-service))['"]/g)
-  for (const m of pluginRefs) {
+  const content = walkTsFiles(scanDir).map(f => fs.readFileSync(f, 'utf-8')).join('\n')
+  const refs = content.matchAll(/['"](@[^'"]+\/(?:typescript-plugin|language-service)[^'"]*)['"]|['"](\w+(?:-typescript-plugin|-language-service))['"]/g)
+  for (const m of refs) {
     const name = m[1] || m[2]
     if (name && !plugins.some(p => p.name === name)) {
       plugins.push({ name, languages: [], enableForWorkspaceTypeScriptVersions: true })
     }
   }
 
-  // Check package.json for typescript plugin dependencies
-  const pkgPath = path.join(input, 'package.json')
-  if (fs.existsSync(pkgPath)) {
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'))
-    for (const dep of Object.keys(pkg.dependencies || {})) {
-      if (dep.includes('typescript-plugin') || dep.includes('language-service')) {
-        if (!plugins.some(p => p.name === dep)) {
-          plugins.push({ name: dep, languages: [], enableForWorkspaceTypeScriptVersions: true })
-        }
-      }
+  for (const dep of Object.keys(origPkg.dependencies || {})) {
+    if ((dep.includes('typescript-plugin') || dep.includes('language-service')) && !plugins.some(p => p.name === dep)) {
+      plugins.push({ name: dep, languages: [], enableForWorkspaceTypeScriptVersions: true })
     }
   }
 
   return plugins
 }
-
-/** Escape string for template literal */
-function escapeStr(s: string): string {
-  return s.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$/g, '\\$')
-}
-
-/** Clean up server path: relative → bare package name, subpath → base */
-function sanitizeServerPath(p: string): string | null {
-  if (p.startsWith('../node_modules/')) p = p.replace(/^\.\.\/node_modules\//, '')
-  if (p.startsWith('./')) return null
-  if (p.startsWith('../')) return null
-  if (p.startsWith('@')) {
-    const parts = p.split('/')
-    if (parts.length > 2) return parts.slice(0, 2).join('/')
-  } else {
-    const parts = p.split('/')
-    if (parts.length > 1) return parts[0]
-  }
-  return p
-}
-
-/**
- * Detect language server module names from original source code.
- * Returns an array of `require.resolve` argument strings (bare module names).
- */
-function detectServerModules(input: string, _result: any): string[] {
-  const seen = new Set<string>()
-  const serverModules: string[] = []
-  const scanDir = path.join(input, 'src')
-  if (fs.existsSync(scanDir)) {
-    for (const file of walkTsFiles(scanDir)) {
-      const content = fs.readFileSync(file, 'utf-8')
-      for (const re of [/(?:require\s*(?:\.\s*resolve)?\s*\(|from\s+)['"]([^'"]+(?:language-server|server|Server|lsp)[^'"]*)['"]\s*\)?/g]) {
-        for (const m of content.matchAll(re)) {
-          const name = sanitizeServerPath(m[1])
-          if (name && !seen.has(name) && !name.includes('${')) { seen.add(name); serverModules.push(name) }
-        }
-      }
-    }
-  }
-  return serverModules
-}