@lpm-registry/cli 0.2.0

package/lib/import-rewriter.js

@@ -0,0 +1,364 @@
+/**
+ * Smart Import Rewriter for LPM Source Packages
+ *
+ * Resolves import specifiers against the installed file set and rewrites
+ * internal imports to match the buyer's project alias setup.
+ *
+ * Pure-function module — no I/O, no fs, no side effects.
+ * All path logic uses forward-slash (POSIX) conventions.
+ *
+ * @module cli/lib/import-rewriter
+ */
+
+/**
+ * @typedef {Object} RewriteOptions
+ * @property {string} fileDestPath - Dest-relative path of the file being processed
+ * @property {Set<string>} destFileSet - All dest-relative paths being installed
+ * @property {string} [fileSrcPath] - Src-relative path (for relative import resolution)
+ * @property {Map<string,string>} [srcToDestMap] - Maps src paths → dest paths
+ * @property {string} [authorAlias] - Author's import alias prefix (e.g., "@/")
+ * @property {string} [buyerAlias] - Buyer's alias for the dest directory (e.g., "@/components/design-system")
+ */
+
+/** File extensions to try when resolving extensionless imports */
+const EXTENSIONS = [".js", ".jsx", ".ts", ".tsx"]
+
+/**
+ * Matches import/export specifiers on a single line.
+ *
+ * Captures:
+ *   - from 'specifier' / from "specifier"
+ *   - import 'specifier' / import "specifier" (side-effect)
+ *   - import('specifier') / import("specifier") (dynamic)
+ *   - export { x } from 'specifier'
+ *
+ * Groups: $1 = keyword prefix, $2 = quote char, $3 = specifier
+ */
+const SPECIFIER_RE = /(from\s+|import\s*\(\s*|import\s+)(['"])(.*?)\2/g
+
+/**
+ * Rewrite internal imports in file content to use the buyer's alias.
+ *
+ * @param {string} content - File source content
+ * @param {RewriteOptions} options
+ * @returns {string} Content with internal imports rewritten
+ */
+export function rewriteImports(content, options) {
+	const {
+		fileDestPath,
+		destFileSet,
+		fileSrcPath,
+		srcToDestMap,
+		authorAlias,
+		buyerAlias,
+	} = options
+
+	// Nothing to do if no buyer alias (relative imports already work)
+	// and no author alias to resolve
+	if (!buyerAlias && !authorAlias) return content
+
+	const fileDestDir = dirname(fileDestPath)
+	const fileSrcDir = fileSrcPath ? dirname(fileSrcPath) : fileDestDir
+
+	// Build src file set from srcToDestMap keys for author alias lookups
+	const srcFileSet = srcToDestMap ? new Set(srcToDestMap.keys()) : null
+
+	const lines = content.split("\n")
+	const result = []
+	let inBlockComment = false
+
+	for (const line of lines) {
+		// Track block comments (best-effort)
+		if (inBlockComment) {
+			if (line.includes("*/")) inBlockComment = false
+			result.push(line)
+			continue
+		}
+		if (line.trimStart().startsWith("/*")) {
+			if (!line.includes("*/")) inBlockComment = true
+			result.push(line)
+			continue
+		}
+		// Skip single-line comments
+		if (line.trimStart().startsWith("//")) {
+			result.push(line)
+			continue
+		}
+
+		result.push(
+			rewriteLineImports(
+				line,
+				fileDestDir,
+				fileSrcDir,
+				destFileSet,
+				srcFileSet,
+				srcToDestMap,
+				authorAlias,
+				buyerAlias,
+			),
+		)
+	}
+
+	return result.join("\n")
+}
+
+/**
+ * Rewrite import specifiers on a single line.
+ *
+ * @param {string} line
+ * @param {string} fileDestDir
+ * @param {string} fileSrcDir
+ * @param {Set<string>} destFileSet
+ * @param {Set<string>|null} srcFileSet
+ * @param {Map<string,string>|null} srcToDestMap
+ * @param {string} [authorAlias]
+ * @param {string} [buyerAlias]
+ * @returns {string}
+ */
+function rewriteLineImports(
+	line,
+	fileDestDir,
+	fileSrcDir,
+	destFileSet,
+	srcFileSet,
+	srcToDestMap,
+	authorAlias,
+	buyerAlias,
+) {
+	return line.replace(SPECIFIER_RE, (match, prefix, quote, specifier) => {
+		const resolvedDestPath = resolveSpecifier(
+			specifier,
+			fileDestDir,
+			fileSrcDir,
+			destFileSet,
+			srcFileSet,
+			srcToDestMap,
+			authorAlias,
+		)
+
+		if (!resolvedDestPath) {
+			// External import or unresolvable — leave unchanged
+			return match
+		}
+
+		// Internal import — compute new specifier
+		const newSpecifier = computeNewSpecifier(
+			resolvedDestPath,
+			fileDestDir,
+			buyerAlias,
+		)
+
+		if (!newSpecifier) {
+			// No buyer alias and cannot compute — leave unchanged
+			return match
+		}
+
+		return `${prefix}${quote}${newSpecifier}${quote}`
+	})
+}
+
+/**
+ * Resolve an import specifier to a dest file path if it's internal.
+ *
+ * @param {string} specifier - The import specifier
+ * @param {string} fileDestDir - Dest directory of the importing file
+ * @param {string} fileSrcDir - Src directory of the importing file
+ * @param {Set<string>} destFileSet - All dest paths
+ * @param {Set<string>|null} srcFileSet - All src paths (for author alias)
+ * @param {Map<string,string>|null} srcToDestMap - src → dest mapping
+ * @param {string} [authorAlias] - Author's import alias prefix
+ * @returns {string|null} Resolved dest path, or null if external
+ */
+function resolveSpecifier(
+	specifier,
+	fileDestDir,
+	fileSrcDir,
+	destFileSet,
+	srcFileSet,
+	srcToDestMap,
+	authorAlias,
+) {
+	// 1. Relative import: ./foo or ../bar
+	if (specifier.startsWith("./") || specifier.startsWith("../")) {
+		// Resolve against src directory, then map to dest
+		if (srcToDestMap && srcToDestMap.size > 0) {
+			const resolvedSrc = normalizePath(joinPath(fileSrcDir, specifier))
+			const srcMatch = tryResolveFile(resolvedSrc, new Set(srcToDestMap.keys()))
+			if (srcMatch) {
+				return srcToDestMap.get(srcMatch) || null
+			}
+		}
+
+		// Fallback: resolve against dest directory directly
+		const resolvedDest = normalizePath(joinPath(fileDestDir, specifier))
+		return tryResolveFile(resolvedDest, destFileSet)
+	}
+
+	// 2. Author alias import: starts with the declared importAlias
+	if (authorAlias && specifier.startsWith(authorAlias)) {
+		const aliasRelative = specifier.slice(authorAlias.length)
+
+		// Look up in src file set, then map to dest
+		if (srcFileSet && srcToDestMap) {
+			const srcMatch = tryResolveFile(aliasRelative, srcFileSet)
+			if (srcMatch) {
+				return srcToDestMap.get(srcMatch) || null
+			}
+		}
+
+		// Fallback: try direct match in dest file set
+		return tryResolveFile(aliasRelative, destFileSet)
+	}
+
+	// 3. Bare specifier (react, next/link, @scope/pkg) — external
+	return null
+}
+
+/**
+ * Resolve an import specifier to a dest file path.
+ *
+ * Exported for testing.
+ *
+ * @param {string} specifier - Import specifier
+ * @param {string} fileDir - Directory of the importing file
+ * @param {Set<string>} fileSet - File paths to match against
+ * @param {string} [authorAlias] - Author's import alias prefix
+ * @returns {string|null} Matching file path, or null if external
+ */
+export function resolveImportToFilePath(
+	specifier,
+	fileDir,
+	fileSet,
+	authorAlias,
+) {
+	if (specifier.startsWith("./") || specifier.startsWith("../")) {
+		const resolved = normalizePath(joinPath(fileDir, specifier))
+		return tryResolveFile(resolved, fileSet)
+	}
+
+	if (authorAlias && specifier.startsWith(authorAlias)) {
+		const aliasRelative = specifier.slice(authorAlias.length)
+		return tryResolveFile(aliasRelative, fileSet)
+	}
+
+	return null
+}
+
+/**
+ * Try to resolve a path against a file set, trying extensions and index files.
+ *
+ * @param {string} candidatePath - Path to resolve (no leading ./)
+ * @param {Set<string>} fileSet - Set of file paths
+ * @returns {string|null} Matching path or null
+ */
+function tryResolveFile(candidatePath, fileSet) {
+	// Normalize: remove leading ./
+	candidatePath = candidatePath.replace(/^\.\//, "")
+
+	// 1. Exact match
+	if (fileSet.has(candidatePath)) return candidatePath
+
+	// 2. Try appending extensions
+	for (const ext of EXTENSIONS) {
+		const withExt = candidatePath + ext
+		if (fileSet.has(withExt)) return withExt
+	}
+
+	// 3. Try as directory: append /index.ext
+	for (const ext of EXTENSIONS) {
+		const indexPath = `${candidatePath}/index${ext}`
+		if (fileSet.has(indexPath)) return indexPath
+	}
+
+	return null
+}
+
+/**
+ * Compute the new import specifier for an internal file.
+ *
+ * @param {string} resolvedDestPath - Dest path of the imported file
+ * @param {string} fileDestDir - Dest directory of the importing file
+ * @param {string} [buyerAlias] - Buyer's alias (e.g., "@/components/design-system")
+ * @returns {string|null} New specifier, or null if no rewrite needed
+ */
+function computeNewSpecifier(resolvedDestPath, _fileDestDir, buyerAlias) {
+	const cleanPath = stripImportExtension(resolvedDestPath)
+
+	if (buyerAlias) {
+		// Buyer wants alias-based imports
+		const alias = buyerAlias.endsWith("/") ? buyerAlias : `${buyerAlias}/`
+		return alias + cleanPath
+	}
+
+	// No buyer alias — no rewrite needed
+	return null
+}
+
+/**
+ * Strip file extension and /index suffix for clean import paths.
+ *
+ * "components/dialog/Dialog.jsx" → "components/dialog/Dialog"
+ * "components/dialog/index.js" → "components/dialog"
+ *
+ * @param {string} filePath
+ * @returns {string}
+ */
+function stripImportExtension(filePath) {
+	// Strip /index.ext → parent dir
+	const indexMatch = filePath.match(/\/index\.(js|jsx|ts|tsx)$/)
+	if (indexMatch) {
+		return filePath.slice(0, -`/index.${indexMatch[1]}`.length)
+	}
+
+	// Strip .ext
+	const extMatch = filePath.match(/\.(js|jsx|ts|tsx)$/)
+	if (extMatch) {
+		return filePath.slice(0, -`.${extMatch[1]}`.length)
+	}
+
+	return filePath
+}
+
+/**
+ * Normalize a path by resolving . and .. segments.
+ * Pure string operation — no filesystem access.
+ *
+ * @param {string} p - Path with forward slashes
+ * @returns {string} Normalized path
+ */
+function normalizePath(p) {
+	const segments = p.split("/")
+	const resolved = []
+	for (const seg of segments) {
+		if (seg === "..") {
+			resolved.pop()
+		} else if (seg !== "." && seg !== "") {
+			resolved.push(seg)
+		}
+	}
+	return resolved.join("/")
+}
+
+/**
+ * Join two path segments with forward slashes.
+ *
+ * @param {string} base
+ * @param {string} relative
+ * @returns {string}
+ */
+function joinPath(base, relative) {
+	if (!base || base === ".") return relative
+	return `${base}/${relative}`
+}
+
+/**
+ * Get the directory portion of a path.
+ *
+ * @param {string} filePath
+ * @returns {string}
+ */
+function dirname(filePath) {
+	const lastSlash = filePath.lastIndexOf("/")
+	if (lastSlash === -1) return ""
+	return filePath.substring(0, lastSlash)
+}

package/lib/install-targets/mcp-server.js

@@ -0,0 +1,245 @@
+/**
+ * MCP Server Install Target
+ *
+ * Handles `lpm add` for packages with `type: "mcp-server"` in lpm.config.json.
+ *
+ * Instead of copying source files into the project, this handler:
+ * 1. Installs the package globally (so `npx` can find it, or node can run it)
+ * 2. Detects installed AI editors
+ * 3. Prompts for env vars defined in mcpConfig.env
+ * 4. Writes MCP server config entries to each editor
+ *
+ * @module cli/lib/install-targets/mcp-server
+ */
+
+import * as p from "@clack/prompts"
+import chalk from "chalk"
+import {
+	addMcpServer,
+	detectEditors,
+	EDITORS,
+	hasMcpServer,
+	removeMcpServerEntry,
+	shortPath,
+} from "../editors.js"
+
+/**
+ * Derive the MCP server name from the package name.
+ * @lpm.dev/owner.my-mcp → "lpm-owner-my-mcp"
+ * @param {string} pkgName - Full package reference (e.g., "@lpm.dev/owner.my-mcp")
+ * @returns {string}
+ */
+function deriveServerName(pkgName) {
+	// Strip @lpm.dev/ prefix and replace dots/slashes with dashes
+	return `lpm-${pkgName.replace("@lpm.dev/", "").replace(/[./]/g, "-")}`
+}
+
+/**
+ * Build the server config object from lpm.config.json's mcpConfig + user answers.
+ *
+ * @param {object} mcpConfig - mcpConfig from lpm.config.json
+ * @param {string} pkgName - Package name for npx fallback
+ * @param {object} envAnswers - User-provided env var values
+ * @returns {object} MCP server config for editor JSON
+ */
+function buildServerConfig(mcpConfig, pkgName, envAnswers) {
+	const config = {}
+
+	if (mcpConfig?.command) {
+		config.command = mcpConfig.command
+		config.args = mcpConfig.args || []
+	} else {
+		// Fallback: use npx to run the package
+		config.command = "npx"
+		config.args = [pkgName]
+	}
+
+	// Add env vars (only non-empty values)
+	const env = {}
+	for (const [key, value] of Object.entries(envAnswers)) {
+		if (value) env[key] = value
+	}
+	if (Object.keys(env).length > 0) {
+		config.env = env
+	}
+
+	return config
+}
+
+/**
+ * Prompt user for env vars defined in mcpConfig.env.
+ *
+ * @param {object} envSchema - env field from mcpConfig (key → { prompt, required })
+ * @returns {Promise<object>} key → value answers
+ */
+async function promptForEnvVars(envSchema) {
+	if (!envSchema || Object.keys(envSchema).length === 0) return {}
+
+	const answers = {}
+
+	for (const [key, schema] of Object.entries(envSchema)) {
+		const label =
+			typeof schema === "object" ? schema.prompt : `Enter value for ${key}`
+		const required = typeof schema === "object" ? schema.required : false
+
+		const value = await p.text({
+			message: label || `Enter value for ${key}`,
+			placeholder: required ? "(required)" : "(optional, press Enter to skip)",
+			validate: val => {
+				if (required && !val?.trim()) return `${key} is required`
+			},
+		})
+
+		if (p.isCancel(value)) {
+			p.cancel("Installation cancelled.")
+			process.exit(0)
+		}
+
+		if (value?.trim()) {
+			answers[key] = value.trim()
+		}
+	}
+
+	return answers
+}
+
+/**
+ * Install an MCP server package into the user's AI editors.
+ *
+ * Called by `lpm add` when the package has `type: "mcp-server"` in lpm.config.json.
+ *
+ * @param {object} params
+ * @param {string} params.name - Package name (e.g., "@lpm.dev/owner.my-mcp")
+ * @param {string} params.version - Package version
+ * @param {object} params.lpmConfig - Parsed lpm.config.json
+ * @param {string} params.extractDir - Temp directory with extracted package files
+ * @param {object} params.options - CLI options (force, yes)
+ * @returns {Promise<{ success: boolean, message: string }>}
+ */
+export async function installMcpServer({
+	name,
+	version: _version,
+	lpmConfig,
+	extractDir: _extractDir,
+	options,
+}) {
+	const mcpConfig = lpmConfig?.mcpConfig || {}
+	const serverName = deriveServerName(name)
+
+	// 1. Detect installed editors
+	const detected = detectEditors()
+
+	if (detected.length === 0) {
+		return {
+			success: false,
+			message:
+				"No supported AI editors detected. Install Claude Code, Cursor, VS Code, Claude Desktop, or Windsurf first.",
+		}
+	}
+
+	// 2. Prompt for env vars (unless --yes)
+	let envAnswers = {}
+	if (mcpConfig.env && !options?.yes) {
+		envAnswers = await promptForEnvVars(mcpConfig.env)
+	}
+
+	// 3. Build server config
+	const serverConfig = buildServerConfig(mcpConfig, name, envAnswers)
+
+	// 4. Let user select editors (unless --yes → all detected)
+	let selectedEditors = detected
+
+	if (!options?.yes && detected.length > 1) {
+		const selectOptions = detected.map(editor => {
+			const installed = hasMcpServer(
+				editor.globalPath,
+				editor.serverKey,
+				serverName,
+			)
+			return {
+				value: editor.id,
+				label: installed
+					? `${editor.name} ${chalk.dim("(will update)")}`
+					: editor.name,
+				hint: shortPath(editor.globalPath),
+			}
+		})
+
+		const selected = await p.multiselect({
+			message: "Configure MCP server in:",
+			options: selectOptions,
+			initialValues: selectOptions.map(o => o.value),
+			required: true,
+		})
+
+		if (p.isCancel(selected)) {
+			p.cancel("Installation cancelled.")
+			process.exit(0)
+		}
+
+		selectedEditors = detected.filter(e => selected.includes(e.id))
+	}
+
+	// 5. Write config to each editor
+	let count = 0
+	const configured = []
+
+	for (const editor of selectedEditors) {
+		try {
+			addMcpServer(
+				editor.globalPath,
+				editor.serverKey,
+				serverName,
+				serverConfig,
+			)
+			configured.push(editor.name)
+			count++
+		} catch (err) {
+			console.error(
+				chalk.red(`  Failed to configure ${editor.name}: ${err.message}`),
+			)
+		}
+	}
+
+	if (count === 0) {
+		return {
+			success: false,
+			message: "Failed to configure any editors.",
+		}
+	}
+
+	return {
+		success: true,
+		message: `MCP server configured in ${configured.join(", ")}. Restart your editors to activate.`,
+	}
+}
+
+/**
+ * Remove an MCP server package from the user's AI editors.
+ *
+ * @param {object} params
+ * @param {string} params.name - Package name
+ * @returns {Promise<{ success: boolean, message: string }>}
+ */
+export async function removeMcpServer({ name }) {
+	const serverName = deriveServerName(name)
+	let count = 0
+
+	for (const editor of EDITORS) {
+		if (removeMcpServerEntry(editor.globalPath, editor.serverKey, serverName)) {
+			count++
+		}
+	}
+
+	if (count === 0) {
+		return {
+			success: true,
+			message: "MCP server was not configured in any editor.",
+		}
+	}
+
+	return {
+		success: true,
+		message: `Removed MCP server from ${count} editor${count > 1 ? "s" : ""}. Restart your editors to apply.`,
+	}
+}