@morya-ui/setup 0.3.4 → 0.3.6

package/src/copy-template.mjs

@@ -1,78 +1,78 @@
-import { cpSync, existsSync, mkdirSync, readdirSync, statSync } from 'node:fs'
-import { dirname, join, relative } from 'node:path'
-
-/**
- * Recursively list files under dir (relative to dir).
- * @param {string} dir
- * @returns {string[]}
- */
-function listFiles(dir) {
-  const out = []
-  function walk(current) {
-    for (const name of readdirSync(current)) {
-      const full = join(current, name)
-      const st = statSync(full)
-      if (st.isDirectory()) walk(full)
-      else out.push(relative(dir, full))
-    }
-  }
-  walk(dir)
-  return out
-}
-
-/**
- * @param {string} rel
- * @param {string[] | undefined} include
- */
-function matchesInclude(rel, include) {
-  if (!include || include.length === 0) return true
-  const norm = rel.replace(/\\/g, '/')
-  return include.some((prefix) => {
-    const p = prefix.replace(/\\/g, '/')
-    return norm === p || norm.startsWith(`${p}/`)
-  })
-}
-
-/**
- * Copy template tree into target cwd.
- * @param {string} templateRoot
- * @param {string} cwd
- * @param {{ force?: boolean, dryRun?: boolean, include?: string[] }} [options]
- * @returns {{ copied: string[], skipped: string[], forced: string[] }}
- */
-export function copyTemplate(templateRoot, cwd, { force = false, dryRun = false, include } = {}) {
-  const copied = []
-  const skipped = []
-  const forced = []
-
-  if (!existsSync(templateRoot)) {
-    throw new Error(
-      `Template missing at ${templateRoot}. Run sync-template / build before publishing.`,
-    )
-  }
-
-  const files = listFiles(templateRoot).filter((rel) => matchesInclude(rel, include))
-  for (const rel of files) {
-    const from = join(templateRoot, rel)
-    const to = join(cwd, rel)
-    const exists = existsSync(to)
-
-    if (exists && !force) {
-      skipped.push(rel)
-      continue
-    }
-
-    if (dryRun) {
-      if (exists) forced.push(rel)
-      else copied.push(rel)
-      continue
-    }
-
-    mkdirSync(dirname(to), { recursive: true })
-    cpSync(from, to)
-    if (exists) forced.push(rel)
-    else copied.push(rel)
-  }
-
-  return { copied, skipped, forced }
-}
+import { cpSync, existsSync, mkdirSync, readdirSync, statSync } from 'node:fs'
+import { dirname, join, relative } from 'node:path'
+
+/**
+ * Recursively list files under dir (relative to dir).
+ * @param {string} dir
+ * @returns {string[]}
+ */
+function listFiles(dir) {
+  const out = []
+  function walk(current) {
+    for (const name of readdirSync(current)) {
+      const full = join(current, name)
+      const st = statSync(full)
+      if (st.isDirectory()) walk(full)
+      else out.push(relative(dir, full))
+    }
+  }
+  walk(dir)
+  return out
+}
+
+/**
+ * @param {string} rel
+ * @param {string[] | undefined} include
+ */
+function matchesInclude(rel, include) {
+  if (!include || include.length === 0) return true
+  const norm = rel.replace(/\\/g, '/')
+  return include.some((prefix) => {
+    const p = prefix.replace(/\\/g, '/')
+    return norm === p || norm.startsWith(`${p}/`)
+  })
+}
+
+/**
+ * Copy template tree into target cwd.
+ * @param {string} templateRoot
+ * @param {string} cwd
+ * @param {{ force?: boolean, dryRun?: boolean, include?: string[] }} [options]
+ * @returns {{ copied: string[], skipped: string[], forced: string[] }}
+ */
+export function copyTemplate(templateRoot, cwd, { force = false, dryRun = false, include } = {}) {
+  const copied = []
+  const skipped = []
+  const forced = []
+
+  if (!existsSync(templateRoot)) {
+    throw new Error(
+      `Template missing at ${templateRoot}. Run sync-template / build before publishing.`,
+    )
+  }
+
+  const files = listFiles(templateRoot).filter((rel) => matchesInclude(rel, include))
+  for (const rel of files) {
+    const from = join(templateRoot, rel)
+    const to = join(cwd, rel)
+    const exists = existsSync(to)
+
+    if (exists && !force) {
+      skipped.push(rel)
+      continue
+    }
+
+    if (dryRun) {
+      if (exists) forced.push(rel)
+      else copied.push(rel)
+      continue
+    }
+
+    mkdirSync(dirname(to), { recursive: true })
+    cpSync(from, to)
+    if (exists) forced.push(rel)
+    else copied.push(rel)
+  }
+
+  return { copied, skipped, forced }
+}

package/src/fs-utils.mjs

@@ -1,24 +1,24 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
-import { dirname } from 'node:path'
-
-export function readJson(path) {
-  const text = readFileSync(path, 'utf8').replace(/^\uFEFF/, '')
-  return JSON.parse(text)
-}
-
-export function writeJson(path, value, { dryRun = false } = {}) {
-  const text = `${JSON.stringify(value, null, 2)}\n`
-  if (dryRun) return text
-  mkdirSync(dirname(path), { recursive: true })
-  writeFileSync(path, text, 'utf8')
-  return text
-}
-
-export function ensureDir(path, { dryRun = false } = {}) {
-  if (dryRun || existsSync(path)) return
-  mkdirSync(path, { recursive: true })
-}
-
-export function fileExists(path) {
-  return existsSync(path)
-}
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { dirname } from 'node:path'
+
+export function readJson(path) {
+  const text = readFileSync(path, 'utf8').replace(/^\uFEFF/, '')
+  return JSON.parse(text)
+}
+
+export function writeJson(path, value, { dryRun = false } = {}) {
+  const text = `${JSON.stringify(value, null, 2)}\n`
+  if (dryRun) return text
+  mkdirSync(dirname(path), { recursive: true })
+  writeFileSync(path, text, 'utf8')
+  return text
+}
+
+export function ensureDir(path, { dryRun = false } = {}) {
+  if (dryRun || existsSync(path)) return
+  mkdirSync(path, { recursive: true })
+}
+
+export function fileExists(path) {
+  return existsSync(path)
+}

package/src/install.mjs

@@ -1,63 +1,134 @@
-import { existsSync } from 'node:fs'
-import { join } from 'node:path'
-import { execSync } from 'node:child_process'
-
-const LOCKFILES = [
-  { pm: 'pnpm', file: 'pnpm-lock.yaml' },
-  { pm: 'yarn', file: 'yarn.lock' },
-  { pm: 'npm', file: 'package-lock.json' },
-]
-
-export function detectPackageManager(cwd, explicit) {
-  if (explicit) {
-    if (!['pnpm', 'yarn', 'npm'].includes(explicit)) {
-      throw new Error(`Unsupported --pm value: ${explicit}. Use pnpm, yarn, or npm.`)
-    }
-    return explicit
-  }
-  for (const { pm, file } of LOCKFILES) {
-    if (existsSync(join(cwd, file))) return pm
-  }
-  return 'pnpm'
-}
-
-function installCommand(pm) {
-  switch (pm) {
-    case 'pnpm':
-      return 'pnpm add morya-ui'
-    case 'yarn':
-      return 'yarn add morya-ui'
-    case 'npm':
-      return 'npm install morya-ui'
-    default:
-      throw new Error(`Unknown package manager: ${pm}`)
-  }
-}
-
-/**
- * @returns {{ pm: string, command: string, skipped?: boolean, reason?: string }}
- */
-export function installMoryaUi(cwd, { pm, dryRun = false, skipInstall = false } = {}) {
-  const resolved = detectPackageManager(cwd, pm)
-  const command = installCommand(resolved)
-
-  if (skipInstall) {
-    return { pm: resolved, command, skipped: true, reason: 'skip-install' }
-  }
-
-  if (!existsSync(join(cwd, 'package.json'))) {
-    return {
-      pm: resolved,
-      command,
-      skipped: true,
-      reason: 'no-package-json',
-    }
-  }
-
-  if (dryRun) {
-    return { pm: resolved, command, skipped: true, reason: 'dry-run' }
-  }
-
-  execSync(command, { cwd, stdio: 'inherit', shell: true })
-  return { pm: resolved, command }
-}
+import { existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { execSync } from 'node:child_process'
+import { readJson } from './fs-utils.mjs'
+
+const LOCKFILES = [
+  { pm: 'pnpm', file: 'pnpm-lock.yaml' },
+  { pm: 'yarn', file: 'yarn.lock' },
+  { pm: 'npm', file: 'package-lock.json' },
+]
+
+const CORE_PACKAGE = 'morya-ui'
+const SCOPE_PREFIX = '@morya-ui/'
+
+export function detectPackageManager(cwd, explicit) {
+  if (explicit) {
+    if (!['pnpm', 'yarn', 'npm'].includes(explicit)) {
+      throw new Error(`Unsupported --pm value: ${explicit}. Use pnpm, yarn, or npm.`)
+    }
+    return explicit
+  }
+  for (const { pm, file } of LOCKFILES) {
+    if (existsSync(join(cwd, file))) return pm
+  }
+  return 'pnpm'
+}
+
+/**
+ * Collect morya-ui / @morya-ui/* names from package.json.
+ * Always includes `morya-ui` when ensureCore is true (full / app).
+ * @param {Record<string, unknown> | null} pkg
+ * @param {{ ensureCore?: boolean }} [opts]
+ * @returns {string[]}
+ */
+export function collectMoryaPackages(pkg, { ensureCore = true } = {}) {
+  const names = new Set()
+  if (pkg && typeof pkg === 'object') {
+    for (const field of ['dependencies', 'devDependencies', 'optionalDependencies']) {
+      const deps = pkg[field]
+      if (!deps || typeof deps !== 'object') continue
+      for (const name of Object.keys(deps)) {
+        if (name === CORE_PACKAGE || name.startsWith(SCOPE_PREFIX)) {
+          names.add(name)
+        }
+      }
+    }
+  }
+  if (ensureCore) names.add(CORE_PACKAGE)
+  return [...names].sort()
+}
+
+/**
+ * @param {string} pm
+ * @param {string[]} packages bare package names
+ */
+export function installCommand(pm, packages) {
+  const specs = packages.map((name) => `${name}@latest`)
+  const joined = specs.join(' ')
+  switch (pm) {
+    case 'pnpm':
+      return `pnpm add ${joined}`
+    case 'yarn':
+      return `yarn add ${joined}`
+    case 'npm':
+      return `npm install ${joined}`
+    default:
+      throw new Error(`Unknown package manager: ${pm}`)
+  }
+}
+
+/**
+ * Install / upgrade `morya-ui` and any existing `@morya-ui/*` deps to the npm `latest` tag.
+ * @returns {{
+ *   pm: string,
+ *   command: string,
+ *   packages: string[],
+ *   skipped?: boolean,
+ *   reason?: string,
+ * }}
+ */
+export function installMoryaUi(cwd, {
+  pm,
+  dryRun = false,
+  skipInstall = false,
+  ensureCore = true,
+} = {}) {
+  const resolved = detectPackageManager(cwd, pm)
+  const pkgPath = join(cwd, 'package.json')
+
+  let pkg = null
+  if (existsSync(pkgPath)) {
+    try {
+      pkg = readJson(pkgPath)
+    } catch {
+      pkg = null
+    }
+  }
+
+  const packages = collectMoryaPackages(pkg, { ensureCore })
+  const command = packages.length
+    ? installCommand(resolved, packages)
+    : installCommand(resolved, [CORE_PACKAGE])
+
+  if (skipInstall) {
+    return { pm: resolved, command, packages, skipped: true, reason: 'skip-install' }
+  }
+
+  if (!existsSync(pkgPath)) {
+    return {
+      pm: resolved,
+      command,
+      packages,
+      skipped: true,
+      reason: 'no-package-json',
+    }
+  }
+
+  if (!packages.length) {
+    return {
+      pm: resolved,
+      command,
+      packages,
+      skipped: true,
+      reason: 'no-morya-packages',
+    }
+  }
+
+  if (dryRun) {
+    return { pm: resolved, command, packages, skipped: true, reason: 'dry-run' }
+  }
+
+  execSync(command, { cwd, stdio: 'inherit', shell: true })
+  return { pm: resolved, command, packages }
+}

package/src/mcp.mjs

@@ -1,50 +1,220 @@
-import { existsSync } from 'node:fs'
-import { join } from 'node:path'
-import { readJson, writeJson } from './fs-utils.mjs'
-
-const SERVER_NAME = 'morya-ui'
-const SERVER_CONFIG = {
-  command: 'npx',
-  args: ['-y', '@morya-ui/mcp'],
-}
-
-/**
- * Merge Cursor MCP config for morya-ui.
- * @returns {{ path: string, action: 'created' | 'merged' | 'skipped' | 'forced', dryRun?: boolean }}
- */
-export function mergeMcpConfig(cwd, { force = false, dryRun = false } = {}) {
-  const path = join(cwd, '.cursor', 'mcp.json')
-  const exists = existsSync(path)
-
-  let data = { mcpServers: {} }
-  if (exists) {
-    try {
-      data = readJson(path)
-    } catch {
-      throw new Error(`Invalid JSON in ${path}`)
-    }
-    if (!data || typeof data !== 'object') {
-      throw new Error(`Invalid MCP config shape in ${path}`)
-    }
-    if (!data.mcpServers || typeof data.mcpServers !== 'object') {
-      data.mcpServers = {}
-    }
-  }
-
-  const hasExisting = Boolean(data.mcpServers[SERVER_NAME])
-  if (hasExisting && !force) {
-    return { path, action: 'skipped' }
-  }
-
-  data.mcpServers[SERVER_NAME] = { ...SERVER_CONFIG }
-
-  if (!dryRun) {
-    writeJson(path, data)
-  }
-
-  let action = 'created'
-  if (exists && hasExisting && force) action = 'forced'
-  else if (exists) action = 'merged'
-
-  return { path, action, dryRun }
-}
+import { existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { readJson, writeJson } from './fs-utils.mjs'
+
+export const SERVER_NAME = 'morya-ui'
+
+export const SERVER_CONFIG = {
+  command: 'npx',
+  args: ['-y', '@morya-ui/mcp@latest'],
+}
+
+/** VS Code workspace MCP uses `servers` + optional stdio `type`. */
+export const VSCODE_SERVER_CONFIG = {
+  type: 'stdio',
+  ...SERVER_CONFIG,
+}
+
+export const KNOWN_EDITORS = ['cursor', 'vscode', 'zed']
+
+export const DEFAULT_EDITORS = [...KNOWN_EDITORS]
+
+/**
+ * @param {string | undefined} raw
+ * @returns {string[]}
+ */
+export function parseEditorsFlag(raw) {
+  if (raw == null || raw.trim() === '' || raw.trim() === 'all') {
+    return [...DEFAULT_EDITORS]
+  }
+  const ids = raw
+    .split(',')
+    .map((part) => part.trim().toLowerCase())
+    .filter(Boolean)
+  if (!ids.length) return [...DEFAULT_EDITORS]
+
+  const unknown = ids.filter((id) => !KNOWN_EDITORS.includes(id))
+  if (unknown.length) {
+    throw new Error(
+      `Unknown editor id(s): ${unknown.join(', ')}. Available: ${KNOWN_EDITORS.join(', ')}, or all`,
+    )
+  }
+  // Preserve declared order; dedupe
+  return [...new Set(ids)]
+}
+
+/**
+ * @param {unknown} data
+ * @param {string} path
+ */
+function assertObject(data, path) {
+  if (!data || typeof data !== 'object' || Array.isArray(data)) {
+    throw new Error(`Invalid MCP config shape in ${path}`)
+  }
+}
+
+/**
+ * @param {string} path
+ * @param {Record<string, unknown>} fallback
+ */
+function readConfigOrDefault(path, fallback) {
+  if (!existsSync(path)) return { data: structuredClone(fallback), exists: false }
+  try {
+    const data = readJson(path)
+    assertObject(data, path)
+    return { data, exists: true }
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith('Invalid MCP')) {
+      throw error
+    }
+    if (error instanceof SyntaxError) {
+      throw new Error(`Invalid JSON in ${path}`)
+    }
+    throw error
+  }
+}
+
+/**
+ * @param {object} args
+ * @param {string} args.path
+ * @param {boolean} args.exists
+ * @param {Record<string, unknown>} args.data
+ * @param {string} args.bucketKey
+ * @param {Record<string, unknown>} args.serverConfig
+ * @param {boolean} args.force
+ * @param {boolean} args.dryRun
+ * @param {string} args.editor
+ * @returns {{ editor: string, path: string, action: 'created' | 'merged' | 'skipped' | 'forced', dryRun?: boolean }}
+ */
+function mergeServerEntry({ path, exists, data, bucketKey, serverConfig, force, dryRun, editor }) {
+  if (!data[bucketKey] || typeof data[bucketKey] !== 'object' || Array.isArray(data[bucketKey])) {
+    data[bucketKey] = {}
+  }
+  const bucket = /** @type {Record<string, unknown>} */ (data[bucketKey])
+  const hasExisting = Boolean(bucket[SERVER_NAME])
+  if (hasExisting && !force) {
+    return { editor, path, action: 'skipped', dryRun }
+  }
+
+  bucket[SERVER_NAME] = { ...serverConfig }
+
+  if (!dryRun) {
+    writeJson(path, data)
+  }
+
+  let action = 'created'
+  if (exists && hasExisting && force) action = 'forced'
+  else if (exists) action = 'merged'
+
+  return { editor, path, action, dryRun }
+}
+
+/**
+ * @param {string} cwd
+ * @param {{ force?: boolean, dryRun?: boolean }} [options]
+ */
+function mergeCursorMcp(cwd, { force = false, dryRun = false } = {}) {
+  const path = join(cwd, '.cursor', 'mcp.json')
+  const { data, exists } = readConfigOrDefault(path, { mcpServers: {} })
+  return mergeServerEntry({
+    path,
+    exists,
+    data,
+    bucketKey: 'mcpServers',
+    serverConfig: SERVER_CONFIG,
+    force,
+    dryRun,
+    editor: 'cursor',
+  })
+}
+
+/**
+ * Portable root config (Agent Host / cross-tool discovery).
+ * @param {string} cwd
+ * @param {{ force?: boolean, dryRun?: boolean }} [options]
+ */
+function mergePortableMcp(cwd, { force = false, dryRun = false } = {}) {
+  const path = join(cwd, '.mcp.json')
+  const { data, exists } = readConfigOrDefault(path, { mcpServers: {} })
+  return mergeServerEntry({
+    path,
+    exists,
+    data,
+    bucketKey: 'mcpServers',
+    serverConfig: SERVER_CONFIG,
+    force,
+    dryRun,
+    editor: 'portable',
+  })
+}
+
+/**
+ * @param {string} cwd
+ * @param {{ force?: boolean, dryRun?: boolean }} [options]
+ */
+function mergeVscodeMcp(cwd, { force = false, dryRun = false } = {}) {
+  const path = join(cwd, '.vscode', 'mcp.json')
+  const { data, exists } = readConfigOrDefault(path, { servers: {} })
+  return mergeServerEntry({
+    path,
+    exists,
+    data,
+    bucketKey: 'servers',
+    serverConfig: VSCODE_SERVER_CONFIG,
+    force,
+    dryRun,
+    editor: 'vscode',
+  })
+}
+
+/**
+ * Merge into `.zed/settings.json` under `context_servers` without wiping other settings.
+ * @param {string} cwd
+ * @param {{ force?: boolean, dryRun?: boolean }} [options]
+ */
+function mergeZedMcp(cwd, { force = false, dryRun = false } = {}) {
+  const path = join(cwd, '.zed', 'settings.json')
+  const { data, exists } = readConfigOrDefault(path, {})
+  return mergeServerEntry({
+    path,
+    exists,
+    data,
+    bucketKey: 'context_servers',
+    serverConfig: SERVER_CONFIG,
+    force,
+    dryRun,
+    editor: 'zed',
+  })
+}
+
+const EDITOR_MERGERS = {
+  cursor: mergeCursorMcp,
+  vscode: mergeVscodeMcp,
+  zed: mergeZedMcp,
+}
+
+/**
+ * Merge morya-ui MCP into the selected editors plus root `.mcp.json`.
+ *
+ * @param {string} cwd
+ * @param {{ force?: boolean, dryRun?: boolean, editors?: string[] }} [options]
+ * @returns {{ results: Array<{ editor: string, path: string, action: string, dryRun?: boolean }>, dryRun?: boolean }}
+ */
+export function mergeMcpConfig(cwd, { force = false, dryRun = false, editors = DEFAULT_EDITORS } = {}) {
+  const selected = Array.isArray(editors)
+    ? parseEditorsFlag(editors.join(','))
+    : parseEditorsFlag(editors)
+  /** @type {Array<{ editor: string, path: string, action: string, dryRun?: boolean }>} */
+  const results = []
+
+  for (const editor of selected) {
+    const merge = EDITOR_MERGERS[editor]
+    if (!merge) throw new Error(`Unknown editor: ${editor}`)
+    results.push(merge(cwd, { force, dryRun }))
+  }
+
+  // Always write portable root config when MCP step runs.
+  results.push(mergePortableMcp(cwd, { force, dryRun }))
+
+  return { results, dryRun }
+}