@lpm-registry/cli 0.2.0

package/lib/commands/quality.js

@@ -0,0 +1,211 @@
+import chalk from "chalk"
+import ora from "ora"
+import { get } from "../api.js"
+
+const TIER_COLORS = {
+	excellent: chalk.green,
+	good: chalk.blue,
+	fair: chalk.yellow,
+	"needs-work": chalk.gray,
+}
+
+const TIER_LABELS = {
+	excellent: "Excellent",
+	good: "Good",
+	fair: "Fair",
+	"needs-work": "Needs Work",
+}
+
+const CATEGORY_LABELS = {
+	documentation: "Documentation",
+	code: "Code Quality",
+	testing: "Testing",
+	health: "Package Health",
+}
+
+function progressBar(value, max, width = 18) {
+	const ratio = Math.min(value / max, 1)
+	const filled = Math.round(ratio * width)
+	const empty = width - filled
+	return chalk.cyan("█".repeat(filled)) + chalk.gray("░".repeat(empty))
+}
+
+/**
+ * Parse package name input.
+ * Accepts: "owner.pkg", "@lpm.dev/owner.pkg"
+ * @param {string} input
+ * @returns {string|null} cleaned name as "owner.pkg" or null if invalid
+ */
+function parseName(input) {
+	let cleaned = input
+	if (cleaned.startsWith("@lpm.dev/")) {
+		cleaned = cleaned.replace("@lpm.dev/", "")
+	}
+	const dotIndex = cleaned.indexOf(".")
+	if (dotIndex === -1 || dotIndex === 0 || dotIndex === cleaned.length - 1) {
+		return null
+	}
+	return cleaned
+}
+
+const TIPS = {
+	"has-readme": "Add a README.md with at least 100 characters",
+	"readme-install": "Add an install/getting started section to your README",
+	"readme-usage": "Add usage examples with code blocks to your README",
+	"readme-api": "Add an API/reference section to your README",
+	"has-changelog": "Add a CHANGELOG.md file",
+	"has-license": "Add a LICENSE file",
+	"has-types": 'Add TypeScript types ("types" field or .d.ts files)',
+	"intellisense-coverage": "Add .d.ts type definitions or JSDoc comments",
+	"esm-exports": 'Add "type": "module" or "exports" to package.json',
+	"tree-shakable": 'Add "sideEffects": false to package.json',
+	"no-eval": "Remove eval() and new Function() usage",
+	"has-engines": 'Add "engines": { "node": ">=18" } to package.json',
+	"has-exports-map": 'Add an "exports" map to package.json',
+	"small-deps": "Reduce the number of production dependencies",
+	"source-maps": "Include .js.map source maps for easier debugging",
+	"has-test-files": "Add test files (*.test.js, *.spec.js)",
+	"has-test-script": "Add a test script to package.json",
+	"has-description": "Add a description (>10 chars) to package.json",
+	"has-keywords": "Add keywords to package.json",
+	"has-repository": "Add a repository field to package.json",
+	"has-homepage": "Add a homepage field to package.json",
+	"reasonable-size": "Reduce unpacked size (check for unnecessary files)",
+	"no-vulnerabilities": "Fix known vulnerabilities in dependencies",
+	"maintenance-health": "Publish updates regularly (within 90 days)",
+	"semver-consistency": "Use valid semantic versioning (major.minor.patch)",
+	"author-verified": "Link your GitHub or LinkedIn in your profile settings",
+}
+
+/**
+ * Fetch and display the server-side quality report for a package.
+ *
+ * @param {string} nameInput - Package name (e.g., "owner.pkg" or "@lpm.dev/owner.pkg")
+ * @param {Object} [options]
+ * @param {boolean} [options.json] - Output as JSON
+ */
+export async function quality(nameInput, options = {}) {
+	if (!nameInput || nameInput.trim() === "") {
+		if (options.json) {
+			console.log(JSON.stringify({ error: "Package name required." }))
+		} else {
+			console.error(chalk.red("Error: Package name required."))
+			console.log(chalk.dim("Usage: lpm quality owner.package-name"))
+		}
+		process.exit(1)
+	}
+
+	const cleaned = parseName(nameInput.trim())
+	if (!cleaned) {
+		if (options.json) {
+			console.log(
+				JSON.stringify({
+					error: "Invalid package name format. Use: owner.package-name",
+				}),
+			)
+		} else {
+			console.error(chalk.red("Error: Invalid package name format."))
+			console.log(chalk.dim("Expected: owner.package-name"))
+		}
+		process.exit(1)
+	}
+
+	const fullName = `@lpm.dev/${cleaned}`
+	const spinner = options.json
+		? null
+		: ora(`Fetching quality report for ${fullName}...`).start()
+
+	try {
+		const response = await get(`/quality?name=${encodeURIComponent(cleaned)}`, {
+			onRetry: spinner
+				? (attempt, max) => {
+						spinner.text = `Fetching (retry ${attempt}/${max})...`
+					}
+				: undefined,
+		})
+
+		const data = await response.json().catch(() => ({}))
+
+		if (!response.ok) {
+			throw new Error(data.error || `Request failed: ${response.status}`)
+		}
+
+		if (options.json) {
+			console.log(JSON.stringify(data, null, 2))
+			return
+		}
+
+		if (spinner) spinner.stop()
+
+		// No quality data
+		if (data.score === null || data.score === undefined) {
+			console.log("")
+			console.log(chalk.yellow(`  ${fullName}: No quality data available.`))
+			console.log(
+				chalk.dim("  Publish with lpm CLI v0.16+ to generate quality scores."),
+			)
+			console.log("")
+			return
+		}
+
+		// Display quality report
+		const tier = data.tier || "needs-work"
+		const tierColor = TIER_COLORS[tier] || chalk.white
+		const tierLabel = TIER_LABELS[tier] || tier
+
+		console.log("")
+		console.log(`  ${chalk.bold(fullName)}`)
+		console.log(
+			`  ${chalk.bold("Quality Score:")} ${tierColor(`${data.score}/${data.maxScore}`)} ${tierColor(`(${tierLabel})`)}`,
+		)
+		console.log("")
+
+		// Category bars
+		if (data.categories) {
+			for (const [cat, { score: catScore, max }] of Object.entries(
+				data.categories,
+			)) {
+				const label = (CATEGORY_LABELS[cat] || cat).padEnd(16)
+				const bar = progressBar(catScore, max)
+				console.log(`  ${label}${bar}  ${catScore}/${max}`)
+			}
+			console.log("")
+		}
+
+		// Individual checks
+		if (data.checks && data.checks.length > 0) {
+			for (const check of data.checks) {
+				const icon = check.passed ? chalk.green("✓") : chalk.red("✗")
+				const label = check.passed ? check.label : chalk.dim(check.label)
+				const points = check.passed
+					? chalk.dim(` ${check.points}/${check.maxPoints}`)
+					: chalk.dim(` 0/${check.maxPoints}`)
+				const detail = check.detail ? chalk.dim(` — ${check.detail}`) : ""
+				console.log(`  ${icon} ${label}${points}${detail}`)
+			}
+
+			// Tips for failed checks
+			const failed = data.checks.filter(c => !c.passed)
+			if (failed.length > 0) {
+				console.log("")
+				const tips = failed.slice(0, 3)
+				for (const check of tips) {
+					const tip = TIPS[check.id] || `Improve: ${check.id}`
+					console.log(chalk.dim(`  Tip: ${tip} (+${check.maxPoints} points)`))
+				}
+			}
+		}
+
+		console.log("")
+	} catch (error) {
+		if (spinner) spinner.fail(chalk.red("Failed to fetch quality report."))
+		if (options.json) {
+			console.log(JSON.stringify({ error: error.message }))
+		} else {
+			console.error(chalk.red(`  ${error.message}`))
+		}
+		process.exit(1)
+	}
+}
+
+export default quality

package/lib/commands/remove.js

@@ -0,0 +1,82 @@
+import * as p from "@clack/prompts"
+import chalk from "chalk"
+import { getRegistryUrl, getToken } from "../config.js"
+import { getHandler, hasCustomHandler } from "../install-targets.js"
+
+/**
+ * Remove a previously added package.
+ *
+ * For packages with custom install handlers (e.g., MCP servers), this
+ * delegates to the handler's remove function. For standard source packages,
+ * it advises manual removal since files were copied into the project.
+ *
+ * @param {string} pkgName - Package name (e.g., "@lpm.dev/owner.my-pkg")
+ * @param {object} options - CLI options
+ */
+export async function remove(pkgName, _options) {
+	p.intro(chalk.bgCyan(chalk.black(" lpm remove ")))
+
+	// 1. Auth Check
+	const token = await getToken()
+	if (!token) {
+		p.log.error("Not logged in. Run `lpm login` first.")
+		p.outro("")
+		return
+	}
+
+	// 2. Normalize package name
+	const name = pkgName.startsWith("@lpm.dev/") ? pkgName : `@lpm.dev/${pkgName}`
+
+	// 3. Fetch package metadata to determine type
+	const baseRegistryUrl = getRegistryUrl()
+	const registryUrl = baseRegistryUrl.endsWith("/api/registry")
+		? baseRegistryUrl
+		: `${baseRegistryUrl}/api/registry`
+	const encodedName = name.replace("/", "%2f")
+
+	let meta
+	try {
+		const res = await fetch(`${registryUrl}/${encodedName}`, {
+			headers: { Authorization: `Bearer ${token}` },
+		})
+
+		if (!res.ok) {
+			if (res.status === 404) {
+				p.log.error(`Package '${name}' not found.`)
+				p.outro("")
+				return
+			}
+			throw new Error(res.statusText)
+		}
+
+		meta = await res.json()
+	} catch (err) {
+		p.log.error(`Failed to fetch package info: ${err.message}`)
+		p.outro("")
+		return
+	}
+
+	// 4. Determine package type from latest version's lpmConfig
+	const latestVersion = meta["dist-tags"]?.latest
+	const versionData = latestVersion ? meta.versions[latestVersion] : null
+	const packageType = versionData?.lpmConfig?.type || meta.packageType
+
+	// 5. Route to type-specific handler or show manual instructions
+	if (packageType && hasCustomHandler(packageType)) {
+		const handler = getHandler(packageType)
+		const result = await handler.remove({ name })
+
+		if (result.success) {
+			p.log.success(result.message)
+		} else {
+			p.log.error(result.message)
+		}
+	} else {
+		p.log.info(
+			`${chalk.cyan(name)} was installed as source files copied into your project.`,
+		)
+		p.log.info("Remove the files manually from your project directory.")
+	}
+
+	p.outro("")
+}

package/lib/commands/run.js

@@ -0,0 +1,14 @@
+import { spawn } from "node:child_process"
+import { log } from "../ui.js"
+
+export async function run(script, _options, command) {
+	const args = ["run", script, ...command.args]
+
+	const child = spawn("npm", args, { stdio: "inherit" })
+
+	child.on("close", code => process.exit(code))
+	child.on("error", err => {
+		log.error(`Failed to start npm: ${err.message}`)
+		process.exit(1)
+	})
+}

package/lib/commands/search.js

@@ -0,0 +1,143 @@
+/**
+ * Search Command
+ *
+ * Search for packages using hybrid keyword + semantic search.
+ *
+ * Usage:
+ *   lpm search <query> [options]
+ *
+ * Options:
+ *   --limit <n>  Maximum number of results (default: 20)
+ *   --json       Output in JSON format
+ *
+ * @module cli/lib/commands/search
+ */
+
+import chalk from "chalk"
+import ora from "ora"
+import { searchGet } from "../api.js"
+import { DEFAULT_PAGE_LIMIT } from "../constants.js"
+
+/**
+ * Format downloads count.
+ * @param {number} count
+ * @returns {string}
+ */
+function formatDownloads(count) {
+	if (count >= 1000000) {
+		return `${(count / 1000000).toFixed(1)}M`
+	}
+	if (count >= 1000) {
+		return `${(count / 1000).toFixed(1)}K`
+	}
+	return String(count)
+}
+
+/**
+ * Execute the search command.
+ *
+ * @param {string} query - Search query
+ * @param {Object} options - Command options
+ * @param {number} [options.limit] - Maximum results
+ * @param {boolean} [options.json] - Output as JSON
+ */
+export async function search(query, options = {}) {
+	if (!query || query.trim() === "") {
+		console.error(chalk.red("Error: Search query required."))
+		console.log(chalk.dim("Usage: lpm search <query>"))
+		process.exit(1)
+	}
+
+	const limit = options.limit || DEFAULT_PAGE_LIMIT
+	const spinner = ora(`Searching for "${query}"...`).start()
+
+	try {
+		const params = new URLSearchParams({
+			q: query,
+			mode: "semantic",
+			limit: String(limit),
+		})
+
+		const response = await searchGet(`/packages?${params.toString()}`, {
+			onRetry: (attempt, max) => {
+				spinner.text = `Searching (retry ${attempt}/${max})...`
+			},
+		})
+
+		if (!response.ok) {
+			const data = await response.json().catch(() => ({}))
+			throw new Error(
+				data.error || `Search failed with status ${response.status}`,
+			)
+		}
+
+		const data = await response.json()
+		const packages = data.packages || []
+
+		spinner.stop()
+
+		if (options.json) {
+			console.log(JSON.stringify(packages, null, 2))
+			return
+		}
+
+		if (packages.length === 0) {
+			console.log(chalk.yellow(`\nNo packages found for "${query}".`))
+			return
+		}
+
+		console.log(
+			chalk.bold(
+				`\nFound ${packages.length} package${packages.length > 1 ? "s" : ""}:\n`,
+			),
+		)
+
+		// Calculate column widths (use LPM format: @lpm.dev/owner.name)
+		const maxNameLength = Math.max(
+			...packages.map(p => {
+				const owner = p.ownerSlug || p.owner
+				return (owner ? `@lpm.dev/${owner}.${p.name}` : p.name).length
+			}),
+			10,
+		)
+
+		for (const pkg of packages) {
+			const owner = pkg.ownerSlug || pkg.owner
+			const fullName = owner ? `@lpm.dev/${owner}.${pkg.name}` : pkg.name
+			const paddedName = fullName.padEnd(maxNameLength)
+			const version = chalk.dim(
+				`v${pkg.latestVersion || pkg.version || "unknown"}`.padEnd(12),
+			)
+			const downloads = chalk.green(
+				`↓ ${formatDownloads(pkg.downloadCount ?? pkg.downloads ?? 0)}`.padEnd(
+					10,
+				),
+			)
+
+			console.log(`  ${chalk.cyan(paddedName)}  ${version}  ${downloads}`)
+
+			if (pkg.description) {
+				const truncatedDesc =
+					pkg.description.length > 60
+						? `${pkg.description.slice(0, 57)}...`
+						: pkg.description
+				console.log(`  ${chalk.dim(truncatedDesc)}`)
+			}
+
+			console.log("")
+		}
+
+		if (packages.length === limit) {
+			console.log(
+				chalk.dim(`  Showing first ${limit} results. Use --limit to see more.`),
+			)
+			console.log("")
+		}
+	} catch (error) {
+		spinner.fail(chalk.red("Search failed."))
+		console.error(chalk.red(`  ${error.message}`))
+		process.exit(1)
+	}
+}
+
+export default search

package/lib/commands/setup.js

@@ -0,0 +1,92 @@
+import fs from "node:fs"
+import path from "node:path"
+import * as p from "@clack/prompts"
+import chalk from "chalk"
+import { getRegistryUrl } from "../config.js"
+import { log, printHeader } from "../ui.js"
+
+/**
+ * Configure .npmrc for LPM packages.
+ * Sets up the @lpm.dev scope to point to the LPM registry.
+ */
+export async function setup(options) {
+	printHeader()
+
+	p.intro(chalk.bgCyan(chalk.black(" lpm setup ")))
+
+	const registryUrl = options?.registry || getRegistryUrl()
+	const projectRoot = process.cwd()
+	const npmrcPath = path.join(projectRoot, ".npmrc")
+
+	// Check for package.json
+	const pkgJsonPath = path.join(projectRoot, "package.json")
+	if (!fs.existsSync(pkgJsonPath)) {
+		log.warn("No package.json found. Run this command in your project root.")
+	}
+
+	// Check for existing .npmrc
+	let npmrcContent = ""
+	if (fs.existsSync(npmrcPath)) {
+		npmrcContent = fs.readFileSync(npmrcPath, "utf8")
+
+		// Check if already configured
+		if (npmrcContent.includes("@lpm.dev:registry")) {
+			const overwrite = await p.confirm({
+				message: ".npmrc already has LPM configuration. Overwrite?",
+				initialValue: false,
+			})
+
+			if (p.isCancel(overwrite) || !overwrite) {
+				p.outro("Setup cancelled.")
+				return
+			}
+
+			// Remove existing LPM config lines
+			npmrcContent = npmrcContent
+				.split("\n")
+				.filter(line => {
+					return (
+						!line.includes("@lpm.dev:registry") &&
+						!line.includes("lpm.dev/api/registry/:_authToken") &&
+						!line.includes("# LPM Registry")
+					)
+				})
+				.join("\n")
+				.trim()
+		}
+	}
+
+	// Build registry URL
+	const fullRegistryUrl = registryUrl.endsWith("/api/registry")
+		? registryUrl
+		: `${registryUrl}/api/registry`
+
+	// Remove protocol for auth token config
+	const registryHost = fullRegistryUrl.replace(/^https?:/, "")
+
+	// Add LPM registry config
+	const lpmConfig = `
+# LPM Registry
+@lpm.dev:registry=${fullRegistryUrl}
+${registryHost}/:_authToken=\${LPM_TOKEN}
+`.trim()
+
+	// Combine with existing content
+	npmrcContent = npmrcContent ? `${npmrcContent}\n\n${lpmConfig}` : lpmConfig
+
+	// Write .npmrc
+	fs.writeFileSync(npmrcPath, `${npmrcContent}\n`)
+
+	p.note(
+		`@lpm.dev:registry=${fullRegistryUrl}\n${registryHost}/:_authToken=\${LPM_TOKEN}`,
+		".npmrc configuration",
+	)
+
+	console.log("")
+	log.success(".npmrc configured for LPM packages.")
+	log.info("For local development: Run `lpm login` to authenticate.")
+	log.info("For CI/CD: Set the LPM_TOKEN environment variable.")
+	console.log("")
+
+	p.outro("Setup complete!")
+}