coc-vscode-loader 1.1.9 → 1.2.0

package/converter/src/scanner.ts

@@ -3,122 +3,38 @@ import * as path from 'path'
 
 export interface ScanResult {
   files: ScannedFile[]
-  hasTsBridge: boolean
-  hasDecoration: boolean
-  hasWebview: boolean
   summary: string
 }
 
 export interface ScannedFile {
   path: string
   apis: string[]
-  actions: string[]
 }
 
-const UNSUPPORTED_PATTERNS = [
-  { pattern: 'createTextEditorDecorationType', action: 'mark-unsupported', label: 'decoration API' },
-  { pattern: 'setDecorations', action: 'mark-unsupported', label: 'decoration API' },
-  { pattern: 'createWebviewPanel', action: 'mark-unsupported', label: 'webview API' },
-  { pattern: 'registerTreeDataProvider', action: 'mark-unsupported', label: 'tree data provider' },
-  { pattern: 'window.showInputBox', action: 'needs-rewrite', label: 'use requestInput instead' },
-  { pattern: 'env.openExternal', action: 'mark-unsupported', label: 'no equivalent' },
-  { pattern: 'showOpenDialog', action: 'mark-unsupported', label: 'no equivalent' },
-  { pattern: 'showSaveDialog', action: 'mark-unsupported', label: 'no equivalent' },
-]
-
-const TS_BRIDGE_PATTERNS = [
-  'tsserver/request',
-  'tsserver/response',
-  '_vue:',
-  'typescript.tsserverRequest',
-]
-
 export function scan(dir: string): ScanResult {
   const files: ScannedFile[] = []
-  let hasTsBridge = false
-  let hasDecoration = false
-  let hasWebview = false
-
+  if (!fs.existsSync(dir)) {
+    return { files, summary: 'no source directory found' }
+  }
   const tsFiles = walk(dir).filter(f => f.endsWith('.ts') || f.endsWith('.tsx'))
 
   for (const filePath of tsFiles) {
     const content = fs.readFileSync(filePath, 'utf-8')
     const apis: string[] = []
-    const actions: string[] = []
     const relative = path.relative(dir, filePath)
 
-    // Check for vscode imports
     if (content.includes("from 'vscode'") || content.includes('from "vscode"') || content.includes('require("vscode")')) {
       apis.push('vscode')
     }
 
-    // Check for unsupported patterns
-    for (const { pattern, action, label } of UNSUPPORTED_PATTERNS) {
-      if (content.includes(pattern)) {
-        apis.push(label)
-        actions.push(action)
-        if (action === 'mark-unsupported') {
-          if (label.includes('decoration')) hasDecoration = true
-          if (label.includes('webview')) hasWebview = true
-        }
-      }
-    }
-
-    // Check for TS bridge
-    for (const pattern of TS_BRIDGE_PATTERNS) {
-      if (content.includes(pattern)) {
-        hasTsBridge = true
-        apis.push('tsserver bridge')
-        break
-      }
-    }
-
-    // Check for LanguageClient
-    if (content.includes('LanguageClient')) {
-      apis.push('LanguageClient')
-    }
-
-    // Check for typescriptServerPlugins in package.json
-    if (relative === 'package.json' || filePath.endsWith('package.json')) {
-      if (content.includes('typescriptServerPlugins')) {
-        hasTsBridge = true
-        apis.push('typescriptServerPlugins')
-      }
-    }
-
-    if (apis.length > 0) {
-      files.push({ path: relative, apis, actions })
-    }
-  }
-
-  // Read package.json
-  const pkgPath = path.join(dir, 'package.json')
-  if (fs.existsSync(pkgPath)) {
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'))
-    const apis: string[] = []
-    if (pkg.contributes?.typescriptServerPlugins) {
-      hasTsBridge = true
-      apis.push('typescriptServerPlugins')
-    }
-    if (pkg.activationEvents) {
-      apis.push(`activationEvents: ${pkg.activationEvents.length}`)
-    }
     if (apis.length > 0) {
-      files.push({ path: 'package.json', apis, actions: [] })
+      files.push({ path: relative, apis })
     }
   }
 
   return {
     files,
-    hasTsBridge,
-    hasDecoration,
-    hasWebview,
-    summary: [
-      `found ${files.length} files with vscode API`,
-      hasTsBridge ? ', ts-bridge detected' : '',
-      hasDecoration ? ', decoration API (marked)' : '',
-      hasWebview ? ', webview API (marked)' : '',
-    ].join(''),
+    summary: `found ${files.length} files with vscode API`,
   }
 }
 

package/converter/src/steps/bridge.ts

@@ -0,0 +1,142 @@
+import { StepGenerator, StepContext, BridgeStep, StepResult } from '../types.js'
+
+/**
+ * Safe, audited bridge code generators.
+ * Registry presets can only reference these types — no arbitrary code execution.
+ */
+interface BridgeTemplateResult {
+  code: string
+  injectExts: string[]
+  injectSvcs: string[]
+  callAfter: string | null
+  extraDeps: string[]
+}
+
+const BRIDGE_TEMPLATES: Record<string, (opts: any) => BridgeTemplateResult> = {
+  'tsserver-forward': (opts) => {
+    const command = opts.command || 'typescript.tsserverRequest'
+    return {
+      code: `\
+    client.onNotification('tsserver/request', async ([seq, command, args]: [number, string, any]) => {
+      try {
+        const result = await commands.executeCommand<any>('${command}', command, args, { isAsync: true, lowPriority: true })
+        client.sendNotification('tsserver/response', [seq, result?.body])
+      } catch { client.sendNotification('tsserver/response', [seq, undefined]) }
+    })`,
+      injectExts: opts.extensions || [],
+      injectSvcs: opts.services || [],
+      callAfter: 'registerBridge(context, client)',
+      extraDeps: ['typescript'],
+    }
+  },
+}
+
+export function getRegisteredBridgeTypes(): string[] {
+  return Object.keys(BRIDGE_TEMPLATES)
+}
+
+export const bridgeGenerator: StepGenerator = {
+  type: 'bridge',
+
+  generate(ctx: StepContext, step: any): StepResult {
+    const bs = step as BridgeStep
+
+    // Resolve preset config from registry
+    let type: string
+    let opts: Record<string, any>
+    if (bs.preset) {
+      const presetDef = ctx.presets?.[bs.preset]
+      if (!presetDef) {
+        throw new Error(`Unknown bridge preset: "${bs.preset}". Check presets.json in registry.`)
+      }
+      type = presetDef.type || ''
+      opts = { ...presetDef.options, ...(bs.options || {}) }
+    } else {
+      type = ''
+      opts = bs.options || {}
+    }
+
+    // Look up safe template
+    const template = BRIDGE_TEMPLATES[type]
+    if (!template) {
+      throw new Error(`Unknown bridge type: "${type}". Available types: ${Object.keys(BRIDGE_TEMPLATES).join(', ')}`)
+    }
+
+    const generated = template(opts)
+    let code = generated.code
+
+    if (bs.verbose) {
+      code = `\
+    console.log('[bridge] registerBridge called')
+    client.onReady().then(() => console.log('[bridge] client ready')).catch(e => console.log('[bridge] client error:', e.message))
+${code}`
+    }
+
+    // Generate the bridge module
+    const moduleContent = `\
+import { commands, ExtensionContext } from 'coc.nvim'
+
+export function registerBridge(context: ExtensionContext, client: any): void {
+${code}
+}
+`
+
+    // Build code injections
+    const codeInjections: StepResult['codeInjections'] = []
+    const extIds = generated.injectExts || []
+    const svcIds = generated.injectSvcs || []
+    const callAfter = generated.callAfter
+
+    if (callAfter) {
+      codeInjections.push({
+        target: 'src/index.ts',
+        importCode: `import { registerBridge } from './bridge'`,
+        insertBefore: `  } catch (e: any) {`,
+        code: `    ${callAfter}\n`,
+      })
+    }
+
+    if (extIds.length || svcIds.length) {
+      let activationCode = ''
+      for (const extId of extIds) {
+        const varName = extId.replace(/[^a-z0-9]/gi, '_')
+        activationCode += `\
+    const ${varName} = extensions.all.find(e => e.id === '${extId}')
+    if (${varName} && !${varName}.isActive) { await ${varName}.activate() }
+`
+      }
+      for (const svc of svcIds) {
+        const varName = svc.replace(/[^a-z0-9]/gi, '_') + 'Svc'
+        activationCode += `\
+    const ${varName} = services.getService('${svc}')
+    if (${varName}) { await ${varName}.start() }
+`
+      }
+      if (activationCode) {
+        codeInjections.push({
+          target: 'src/index.ts',
+          insertAfter: 'try {\n',
+          code: activationCode,
+        })
+      }
+      codeInjections.push({
+        target: 'src/index.ts',
+        importCode: `  extensions,`,
+        insertBefore: `} from 'coc.nvim'`,
+        code: '',
+      })
+    }
+
+    const result: StepResult = {
+      generatedFiles: [{ path: 'src/bridge.ts', content: moduleContent }],
+      entryPoint: undefined,
+      keepDeps: Object.fromEntries((generated.extraDeps || []).map((d: string) => {
+        const ver = ctx.origPkg.dependencies?.[d] || ctx.origPkg.devDependencies?.[d]
+        return [d, ver || '*']
+      })),
+      activationEvents: [],
+    }
+    if (codeInjections.length) result.codeInjections = codeInjections
+    return result
+  },
+}

package/converter/src/steps/index.ts

@@ -0,0 +1,29 @@
+import { StepGenerator, StepContext, ConvertStep, StepResult } from '../types.js'
+import { languageClientGenerator } from './language-client.js'
+import { sourceGenerator } from './source.js'
+import { bridgeGenerator } from './bridge.js'
+import { markUnsupportedGenerator } from './mark-unsupported.js'
+
+const REGISTRY: Record<string, StepGenerator> = {}
+
+export function registerGenerator(g: StepGenerator): void {
+  REGISTRY[g.type] = g
+}
+
+export function getRegisteredStepTypes(): string[] {
+  return Object.keys(REGISTRY)
+}
+
+export function executeStep(ctx: StepContext, step: ConvertStep): StepResult {
+  const gen = REGISTRY[step.type]
+  if (!gen) {
+    throw new Error(`Unknown step type: "${step.type}". Available: ${Object.keys(REGISTRY).join(', ')}`)
+  }
+  return gen.generate(ctx, step)
+}
+
+// Register built-in generators
+registerGenerator(languageClientGenerator)
+registerGenerator(sourceGenerator)
+registerGenerator(bridgeGenerator)
+registerGenerator(markUnsupportedGenerator)

package/converter/src/steps/language-client.ts

@@ -0,0 +1,150 @@
+import { StepGenerator, StepContext, LanguageClientStep, StepResult } from '../types.js'
+
+function escapeStr(s: string): string {
+  return s.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/`/g, '\\`').replace(/\$/g, '\\$')
+}
+
+export const languageClientGenerator: StepGenerator = {
+  type: 'language-client',
+
+  generate(ctx: StepContext, step: any): StepResult {
+    const ls = step as LanguageClientStep
+    const id = ls.id || (ctx.origPkg.name || 'language-client')
+    const transport = ls.transport || (ls.server.kind === 'binary' ? 'stdio' : 'ipc')
+    const transportExpr = transport === 'stdio' ? 'TransportKind.stdio' : 'TransportKind.ipc'
+    const languages = ls.languages
+    const multiRoot = ls.multiRoot ?? false
+    const pluginName = ctx.origPkg.name || 'plugin'
+    const description = ctx.origPkg.description || pluginName
+
+    let serverPathCode: string
+    let serverOptionsCode: string
+    let binaryDownloaded = false
+
+    if (ls.server.kind === 'binary') {
+      const pkg = ls.server.package
+      const binary = ls.server.binary
+      const args = ls.server.args || []
+      const argsStr = args.length ? `[${args.map(a => `'${escapeStr(a)}'`).join(', ')}]` : '[]'
+
+      serverPathCode = `\
+    let serverPath: string | undefined
+    try {
+      serverPath = require.resolve('${escapeStr(pkg)}')
+    } catch {}
+    if (!serverPath) {
+      serverPath = require('path').join(__dirname, '..', 'server', '${escapeStr(binary.binaryPath || pkg)}')
+    }`
+      serverOptionsCode = `{ command: serverPath, args: ${argsStr} }`
+      binaryDownloaded = true
+    } else {
+      const pkg = ls.server.package
+      const entry = ls.server.entry || 'main'
+
+      // Same resolution as old converter: resolve main entry first, then walk for bin
+      serverPathCode = `\
+    let serverPath: string | undefined
+    try {
+      serverPath = require.resolve('${escapeStr(pkg)}')
+    } catch {}
+    try {
+      // Walk up from the resolved main entry to find the package's package.json
+      // We can't use require.resolve('pkg/package.json') because exports field may block it
+      let _dir = require('path').dirname(require.resolve('${escapeStr(pkg)}'));
+      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];
+            serverPath = require('path').join(_dir, _entry);
+          }
+          break;
+        }
+        _dir = require('path').dirname(_dir);
+      }
+    } catch {}`
+      // Use full require.resolve path (including bin walking) if available, else fallback to simple main entry
+      serverOptionsCode = `{ module: serverPath || require.resolve('${escapeStr(pkg)}'), transport: ${transportExpr} }`
+    }
+
+    const docSelectorCode = `[${languages.map(l => `{ scheme: 'file', language: '${l}' }`).join(', ')}]`
+    const code = `\
+import {
+  LanguageClient,
+  TransportKind,
+  services,
+  workspace,
+  window,
+  commands,
+  ExtensionContext,
+} from 'coc.nvim'
+import * as path from 'path'
+
+export async function activate(context: ExtensionContext): Promise<void> {
+  try {
+${ls.verbose ? `    console.log('[${escapeStr(id)}] activate() called')\n` : ''}${serverPathCode}
+    if (!serverPath) {
+${ls.verbose ? `    console.log('[${escapeStr(id)}] serverPath undefined')\n` : ''}\
+      window.showErrorMessage('Cannot find language server.')
+      return
+    }
+${ls.verbose ? `    console.log('[${escapeStr(id)}] serverPath =', serverPath)\n` : ''}\
+${ls.verbose ? `    console.log('[${escapeStr(id)}] creating LanguageClient')\n` : ''}\
+    const createClient = () => {
+      const c = new LanguageClient(
+        '${escapeStr(id)}',
+        '${escapeStr(description)}',
+        ${serverOptionsCode},
+        {
+          documentSelector: ${docSelectorCode},
+          outputChannelName: '${escapeStr(description)}',
+        },
+      )
+      context.subscriptions.push({ dispose: () => c.stop() })
+      context.subscriptions.push(services.registerLanguageClient(c))
+      return c
+    }
+
+${ls.verbose ? `    console.log('[${escapeStr(id)}] registering LanguageClient')\n` : ''}\
+    let client: LanguageClient
+    if (${multiRoot ? 'workspace.workspaceFolders && workspace.workspaceFolders.length > 1' : 'false'}) {
+${ls.verbose ? `      console.log('[${escapeStr(id)}] multiRoot mode')\n` : ''}\
+      for (const folder of workspace.workspaceFolders) {
+        client = createClient()
+        client.start()
+      }
+    } else {
+      client = createClient()
+${ls.verbose ? `      console.log('[${escapeStr(id)}] starting client')\n` : ''}\
+      client.start()
+    }
+
+    context.subscriptions.push(
+      commands.registerCommand('${escapeStr(pluginName)}.restart', async () => {
+        await client.stop()
+        await client.start()
+      }),
+    )
+  } catch (e: any) {
+    window.showErrorMessage('${escapeStr(pluginName)} error: ' + (e.message || String(e)))
+  }
+}
+`
+
+    const activationEvents = languages.map(l => `onLanguage:${l}`)
+
+    return {
+      generatedFiles: [{ path: 'src/index.ts', content: code }],
+      entryPoint: 'src/index.ts',
+      keepDeps: {},
+      activationEvents,
+      serverBinary: ls.server.kind === 'binary' ? {
+        repo: ls.server.binary.repo,
+        asset: ls.server.binary.asset,
+        binaryPath: ls.server.binary.binaryPath,
+        args: ls.server.args,
+      } : undefined,
+    }
+  },
+}

package/converter/src/steps/mark-unsupported.ts

@@ -0,0 +1,81 @@
+import * as fs from 'fs'
+import * as path from 'path'
+import { StepGenerator, StepContext, MarkUnsupportedStep, StepResult } from '../types.js'
+
+const FEATURE_WARNINGS: Record<string, string> = {
+  'decoration': 'Decoration API is not supported in coc.nvim',
+  'webview': 'Webview API is not supported in coc.nvim',
+  'tree-data-provider': 'Tree data provider is not supported in coc.nvim',
+  'open-external': 'env.openExternal has no equivalent in coc.nvim',
+}
+
+const FEATURE_PATTERNS: Record<string, RegExp[]> = {
+  'decoration': [/createTextEditorDecorationType/g, /setDecorations/g],
+  'webview': [/createWebviewPanel/g],
+  'tree-data-provider': [/registerTreeDataProvider/g],
+  'open-external': [/env\.openExternal/g],
+}
+
+function walkFiles(dir: string): string[] {
+  const files: string[] = []
+  try {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const p = path.join(dir, entry.name)
+      if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
+        files.push(...walkFiles(p))
+      } else if (entry.isFile()) {
+        files.push(p)
+      }
+    }
+  } catch {}
+  return files
+}
+
+export const markUnsupportedGenerator: StepGenerator = {
+  type: 'mark-unsupported',
+
+  generate(ctx: StepContext, step: any): StepResult {
+    const ms = step as MarkUnsupportedStep
+    const { output, verbose } = ctx
+    const srcDir = path.join(output, 'src')
+
+    const results: Array<{ path: string; content: string }> = []
+    const appliedFeatures: string[] = []
+
+    if (!fs.existsSync(srcDir)) return { generatedFiles: [], keepDeps: {}, activationEvents: [] }
+
+    for (const feature of ms.features) {
+      const warning = FEATURE_WARNINGS[feature]
+      const patterns = FEATURE_PATTERNS[feature]
+      if (!warning || !patterns) {
+        if (verbose) console.warn(`  unknown feature: ${feature}`)
+        continue
+      }
+
+      for (const fp of walkFiles(srcDir)) {
+        if (!fp.endsWith('.ts')) continue
+        let content = fs.readFileSync(fp, 'utf-8')
+        let changed = false
+
+      for (const re of patterns) {
+        content = content.replace(re, (match) => {
+          changed = true
+          return `/* [converter] TODO: ${warning} — removed: ${match} */ void 0`
+        })
+      }
+
+        if (changed) {
+          fs.writeFileSync(fp, content)
+          if (verbose) console.log(`  mark-unsupported(${feature}): ${path.relative(output, fp)}`)
+        }
+      }
+      appliedFeatures.push(feature)
+    }
+
+    return {
+      generatedFiles: results,
+      keepDeps: {},
+      activationEvents: [],
+    }
+  },
+}

package/converter/src/steps/source.ts

@@ -0,0 +1,159 @@
+import * as fs from 'fs'
+import * as path from 'path'
+import { StepGenerator, StepContext, SourceStep, StepResult } from '../types.js'
+import { transformImportMapping } from '../transforms/import-mapping.js'
+import { transformClassToFactory } from '../transforms/class-to-factory.js'
+import { transformProviderRegister } from '../transforms/provider-register.js'
+import { transformEnumOffset } from '../transforms/enum-offset.js'
+import { transformStripVolar } from '../transforms/strip-volar.js'
+
+const TRANSFORM_MAP: Record<string, (ctx: any) => void> = {
+  'import-mapping': transformImportMapping,
+  'class-to-factory': transformClassToFactory,
+  'provider-register': transformProviderRegister,
+  'enum-offset': transformEnumOffset,
+  'strip-volar': transformStripVolar,
+}
+
+function walkFiles(dir: string): string[] {
+  const files: string[] = []
+  try {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const p = path.join(dir, entry.name)
+      if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
+        files.push(...walkFiles(p))
+      } else if (entry.isFile()) {
+        files.push(p)
+      }
+    }
+  } catch {}
+  return files
+}
+
+export const sourceGenerator: StepGenerator = {
+  type: 'source',
+
+  generate(ctx: StepContext, step: any): StepResult {
+    const ss = step as SourceStep
+    const { input, output, project, verbose } = ctx
+    const outputsDir = path.join(output, 'src')
+    fs.mkdirSync(outputsDir, { recursive: true })
+
+    // Copy ALL .ts/.tsx files from source directory (try src/ first, fall back to input root)
+    let srcDir = path.join(input, 'src')
+    if (!fs.existsSync(srcDir)) {
+      srcDir = input
+    }
+    const hasStripVolar = ss.transforms.includes('strip-volar')
+    const allFiles: Array<{ src: string; rel: string }> = []
+    const vscodeFiles: string[] = []
+
+    for (const f of walkFiles(srcDir)) {
+      const rel = path.relative(srcDir, f)
+      if (!rel.endsWith('.ts') && !rel.endsWith('.tsx')) continue
+
+      // Skip framework files that are replaced by generated code
+      if (hasStripVolar) {
+        const content = fs.readFileSync(f, 'utf-8')
+        if (content.includes('@volar/vscode') || content.includes('reactive-vscode')) continue
+      }
+
+      allFiles.push({ src: f, rel })
+
+      const content = fs.readFileSync(f, 'utf-8')
+      if (content.includes("from 'vscode'") || content.includes('from "vscode"') || content.includes('require("vscode")')) {
+        vscodeFiles.push(rel)
+      }
+    }
+
+    // Copy all files to output
+    for (const { src, rel } of allFiles) {
+      const dest = path.join(outputsDir, rel)
+      fs.mkdirSync(path.dirname(dest), { recursive: true })
+      fs.copyFileSync(src, dest)
+    }
+
+    if (verbose) {
+      console.log(`  source: copied ${allFiles.length} files (${vscodeFiles.length} with vscode imports)`)
+    }
+
+    // Apply transforms via ts-morph (only to files with vscode imports)
+    for (const rel of vscodeFiles) {
+      const fp = path.join(outputsDir, rel)
+      if (!fs.existsSync(fp)) continue
+      try { project.addSourceFileAtPath(fp) } catch {}
+    }
+
+    for (const sf of project.getSourceFiles()) {
+      const relPath = path.relative(outputsDir, sf.getFilePath())
+      if (!vscodeFiles.some(f => sf.getFilePath().endsWith(f))) continue
+
+      for (const t of ss.transforms) {
+        const fn = TRANSFORM_MAP[t]
+        if (!fn) {
+          if (verbose) console.warn(`  unknown transform: ${t}`)
+          continue
+        }
+        try {
+          fn({ file: sf, project })
+          if (verbose) console.log(`  ${t}: ${relPath}`)
+        } catch (e: any) {
+          if (verbose) console.warn(`  ${t} error on ${relPath}: ${e.message}`)
+        }
+      }
+      sf.saveSync()
+    }
+
+    // Resolve keepDeps from origPkg (with workspace root fallback)
+    const keepDeps: Record<string, string> = {}
+    if (ss.keepDeps) {
+      if (Array.isArray(ss.keepDeps)) {
+        for (const dep of ss.keepDeps) {
+          const ver = resolveDepVersion(ctx.origPkg, dep, input)
+          if (ver) {
+            keepDeps[dep] = ver
+          } else {
+            throw new Error(`keepDeps: cannot find version for "${dep}" in source package.json, devDependencies, or workspace root. Use object syntax in registry to specify version manually.`)
+          }
+        }
+      } else {
+        Object.assign(keepDeps, ss.keepDeps)
+      }
+    }
+
+    return {
+      generatedFiles: [],
+      entryPoint: ss.entry,
+      keepDeps,
+      activationEvents: ss.activationEvents || [],
+    }
+  },
+}
+
+function resolveDepVersion(pkg: Record<string, any>, name: string, inputDir?: string): string | undefined {
+  // 1. Check source package's dependencies
+  if (pkg.dependencies?.[name]) return pkg.dependencies[name]
+  // 2. Check source package's devDependencies
+  if (pkg.devDependencies?.[name]) return pkg.devDependencies[name]
+  // 3. Walk up for workspace root
+  if (inputDir) {
+    let dir = inputDir
+    const fs = require('fs') as typeof import('fs')
+    const path = require('path') as typeof import('path')
+    while (dir !== path.dirname(dir)) {
+      dir = path.dirname(dir)
+      const wsPkgPath = path.join(dir, 'package.json')
+      if (fs.existsSync(wsPkgPath)) {
+        try {
+          const wsPkg = JSON.parse(fs.readFileSync(wsPkgPath, 'utf-8'))
+          if (wsPkg.dependencies?.[name]) return wsPkg.dependencies[name]
+          if (wsPkg.devDependencies?.[name]) return wsPkg.devDependencies[name]
+        } catch {}
+      }
+      // Stop at filesystem root
+      if (dir === path.dirname(dir)) break
+    }
+  }
+  // 4. Not found
+  return undefined
+}