ocx 0.1.1

package/src/commands/diff.ts

@@ -0,0 +1,139 @@
+/**
+ * Diff Command
+ *
+ * Compare installed components with upstream registry versions.
+ */
+
+import { Command } from "commander"
+import * as Diff from "diff"
+import kleur from "kleur"
+import { readOcxLock, readOcxConfig } from "../schemas/config.js"
+import { fetchComponent, fetchFileContent } from "../registry/fetcher.js"
+import { logger, handleError, outputJson } from "../utils/index.js"
+
+interface DiffOptions {
+	cwd: string
+	json: boolean
+	quiet: boolean
+}
+
+export function registerDiffCommand(program: Command): void {
+	program
+		.command("diff")
+		.description("Compare installed components with upstream")
+		.argument("[component]", "Component to diff (optional, diffs all if omitted)")
+		.option("--cwd <path>", "Working directory", process.cwd())
+		.option("--json", "Output as JSON", false)
+		.option("-q, --quiet", "Suppress output", false)
+		.action(async (component: string | undefined, options: DiffOptions) => {
+			try {
+				const lock = await readOcxLock(options.cwd)
+				if (!lock) {
+					if (options.json) {
+						outputJson({
+							success: false,
+							error: { code: "NOT_FOUND", message: "No ocx.lock found" },
+						})
+					} else {
+						logger.warn("No ocx.lock found. Run 'ocx add' first.")
+					}
+					return
+				}
+
+				const config = await readOcxConfig(options.cwd)
+				if (!config) {
+					if (options.json) {
+						outputJson({
+							success: false,
+							error: { code: "NOT_FOUND", message: "No ocx.jsonc found" },
+						})
+					} else {
+						logger.warn("No ocx.jsonc found. Run 'ocx init' first.")
+					}
+					return
+				}
+
+				const componentNames = component ? [component] : Object.keys(lock.installed)
+
+				if (componentNames.length === 0) {
+					if (options.json) {
+						outputJson({ success: true, data: { diffs: [] } })
+					} else {
+						logger.info("No components installed.")
+					}
+					return
+				}
+
+				const results: Array<{ name: string; hasChanges: boolean; diff?: string }> = []
+
+				for (const name of componentNames) {
+					const installed = lock.installed[name]
+					if (!installed) {
+						if (component) {
+							logger.warn(`Component '${name}' not found in lockfile.`)
+						}
+						continue
+					}
+
+					// Read local file
+					const localPath = `${options.cwd}/${installed.target}`
+					const localFile = Bun.file(localPath)
+					if (!(await localFile.exists())) {
+						results.push({ name, hasChanges: true, diff: "Local file missing" })
+						continue
+					}
+					const localContent = await localFile.text()
+
+					// Fetch upstream
+					const registryConfig = config.registries[installed.registry]
+					if (!registryConfig) {
+						logger.warn(`Registry '${installed.registry}' not configured for component '${name}'.`)
+						continue
+					}
+
+					try {
+						const upstream = await fetchComponent(registryConfig.url, name)
+
+						// Assume first file for simplicity in this MVP
+						// In a full implementation we'd diff all files in the component
+						const upstreamFile = upstream.files[0]
+						if (!upstreamFile) {
+							results.push({ name, hasChanges: false })
+							continue
+						}
+
+						// Fetch actual content from registry
+						const upstreamContent = await fetchFileContent(
+							registryConfig.url,
+							name,
+							upstreamFile.path,
+						)
+
+						if (localContent === upstreamContent) {
+							results.push({ name, hasChanges: false })
+						} else {
+							const patch = Diff.createPatch(name, upstreamContent, localContent)
+							results.push({ name, hasChanges: true, diff: patch })
+						}
+					} catch (err) {
+						logger.warn(`Could not fetch upstream for ${name}: ${String(err)}`)
+					}
+				}
+
+				if (options.json) {
+					outputJson({ success: true, data: { diffs: results } })
+				} else {
+					for (const res of results) {
+						if (res.hasChanges) {
+							console.log(kleur.yellow(`\nDiff for ${res.name}:`))
+							console.log(res.diff || "Changes detected (no diff available)")
+						} else if (!options.quiet) {
+							logger.success(`${res.name}: No changes`)
+						}
+					}
+				}
+			} catch (error) {
+				handleError(error, { json: options.json })
+			}
+		})
+}

package/src/commands/init.ts

@@ -0,0 +1,90 @@
+/**
+ * OCX CLI - init command
+ * Initialize OCX configuration in a project
+ */
+
+import { existsSync } from "node:fs"
+import { writeFile } from "node:fs/promises"
+import { join } from "node:path"
+import { Command } from "commander"
+import { OCX_SCHEMA_URL } from "../constants.js"
+import { ocxConfigSchema } from "../schemas/config.js"
+import { logger, createSpinner, handleError } from "../utils/index.js"
+
+interface InitOptions {
+	yes?: boolean
+	cwd?: string
+	quiet?: boolean
+	verbose?: boolean
+	json?: boolean
+}
+
+export function registerInitCommand(program: Command): void {
+	program
+		.command("init")
+		.description("Initialize OCX configuration in your project")
+		.option("-y, --yes", "Skip prompts and use defaults")
+		.option("--cwd <path>", "Working directory", process.cwd())
+		.option("-q, --quiet", "Suppress output")
+		.option("-v, --verbose", "Verbose output")
+		.option("--json", "Output as JSON")
+		.action(async (options: InitOptions) => {
+			try {
+				await runInit(options)
+			} catch (error) {
+				handleError(error, { json: options.json })
+			}
+		})
+}
+
+async function runInit(options: InitOptions): Promise<void> {
+	const cwd = options.cwd ?? process.cwd()
+	const configPath = join(cwd, "ocx.jsonc")
+
+	// Check for existing config
+	if (existsSync(configPath)) {
+		if (!options.yes) {
+			logger.warn("ocx.jsonc already exists")
+			logger.info("Use --yes to overwrite")
+			return
+		}
+		logger.info("Overwriting existing ocx.jsonc")
+	}
+
+	const spin = options.quiet ? null : createSpinner({ text: "Initializing OCX..." })
+	spin?.start()
+
+	try {
+		// Create minimal config - schema will apply defaults
+		const rawConfig = {
+			$schema: OCX_SCHEMA_URL,
+			registries: {},
+		}
+
+		// Validate with schema (applies defaults)
+		const config = ocxConfigSchema.parse(rawConfig)
+
+		// Write config file
+		const content = JSON.stringify(config, null, 2)
+		await writeFile(configPath, content, "utf-8")
+
+		if (!options.quiet && !options.json) {
+			logger.success("Initialized OCX configuration")
+		}
+
+		spin?.succeed("Initialized OCX configuration")
+
+		if (options.json) {
+			console.log(JSON.stringify({ success: true, path: configPath }))
+		} else if (!options.quiet) {
+			logger.info(`Created ${configPath}`)
+			logger.info("")
+			logger.info("Next steps:")
+			logger.info("  1. Add a registry: ocx registry add <url>")
+			logger.info("  2. Install components: ocx add <component>")
+		}
+	} catch (error) {
+		spin?.fail("Failed to initialize")
+		throw error
+	}
+}

package/src/commands/registry.ts

@@ -0,0 +1,153 @@
+/**
+ * Registry Command
+ * 
+ * Manage configured registries.
+ */
+
+import { Command } from "commander"
+import kleur from "kleur"
+import { readOcxConfig, writeOcxConfig, type OcxConfig } from "../schemas/config.js"
+import { logger, handleError, outputJson } from "../utils/index.js"
+
+interface RegistryOptions {
+  cwd: string
+  json: boolean
+  quiet: boolean
+}
+
+export function registerRegistryCommand(program: Command): void {
+  const registry = program
+    .command("registry")
+    .description("Manage registries")
+
+  // registry add
+  registry
+    .command("add")
+    .description("Add a registry")
+    .argument("<url>", "Registry URL")
+    .option("--name <name>", "Registry alias (defaults to hostname)")
+    .option("--version <version>", "Pin to specific version")
+    .option("--cwd <path>", "Working directory", process.cwd())
+    .option("--json", "Output as JSON", false)
+    .option("-q, --quiet", "Suppress output", false)
+    .action(async (url: string, options: RegistryOptions & { name?: string; version?: string }) => {
+      try {
+        let config = await readOcxConfig(options.cwd)
+        if (!config) {
+          logger.error("No ocx.jsonc found. Run 'ocx init' first.")
+          process.exit(1)
+        }
+
+        if (config.lockRegistries) {
+          logger.error("Registries are locked. Cannot add.")
+          process.exit(1)
+        }
+
+        // Derive name from URL if not provided
+        const name = options.name || new URL(url).hostname.replace(/\./g, "-")
+
+        if (config.registries[name]) {
+          logger.warn(`Registry '${name}' already exists. Use a different name.`)
+          return
+        }
+
+        config.registries[name] = {
+          url,
+          version: options.version,
+        }
+
+        await writeOcxConfig(options.cwd, config)
+
+        if (options.json) {
+          outputJson({ success: true, data: { name, url } })
+        } else {
+          logger.success(`Added registry: ${name} -> ${url}`)
+        }
+      } catch (error) {
+        handleError(error)
+      }
+    })
+
+  // registry remove
+  registry
+    .command("remove")
+    .description("Remove a registry")
+    .argument("<name>", "Registry name")
+    .option("--cwd <path>", "Working directory", process.cwd())
+    .option("--json", "Output as JSON", false)
+    .option("-q, --quiet", "Suppress output", false)
+    .action(async (name: string, options: RegistryOptions) => {
+      try {
+        let config = await readOcxConfig(options.cwd)
+        if (!config) {
+          logger.error("No ocx.jsonc found. Run 'ocx init' first.")
+          process.exit(1)
+        }
+
+        if (config.lockRegistries) {
+          logger.error("Registries are locked. Cannot remove.")
+          process.exit(1)
+        }
+
+        if (!config.registries[name]) {
+          logger.warn(`Registry '${name}' not found.`)
+          return
+        }
+
+        delete config.registries[name]
+        await writeOcxConfig(options.cwd, config)
+
+        if (options.json) {
+          outputJson({ success: true, data: { removed: name } })
+        } else {
+          logger.success(`Removed registry: ${name}`)
+        }
+      } catch (error) {
+        handleError(error)
+      }
+    })
+
+  // registry list
+  registry
+    .command("list")
+    .description("List configured registries")
+    .option("--cwd <path>", "Working directory", process.cwd())
+    .option("--json", "Output as JSON", false)
+    .option("-q, --quiet", "Suppress output", false)
+    .action(async (options: RegistryOptions) => {
+      try {
+        const config = await readOcxConfig(options.cwd)
+        if (!config) {
+          logger.warn("No ocx.jsonc found. Run 'ocx init' first.")
+          return
+        }
+
+        const registries = Object.entries(config.registries).map(([name, cfg]) => ({
+          name,
+          url: cfg.url,
+          version: cfg.version || "latest",
+        }))
+
+        if (options.json) {
+          outputJson({ 
+            success: true, 
+            data: { 
+              registries,
+              locked: config.lockRegistries,
+            } 
+          })
+        } else {
+          if (registries.length === 0) {
+            logger.info("No registries configured.")
+          } else {
+            logger.info(`Configured registries${config.lockRegistries ? kleur.yellow(" (locked)") : ""}:`)
+            for (const reg of registries) {
+              console.log(`  ${kleur.cyan(reg.name)}: ${reg.url} ${kleur.dim(`(${reg.version})`)}`)
+            }
+          }
+        }
+      } catch (error) {
+        handleError(error)
+      }
+    })
+}

package/src/commands/search.ts

@@ -0,0 +1,159 @@
+/**
+ * Search/List Command
+ *
+ * Search for components across registries or list installed.
+ */
+
+import { Command } from "commander"
+import kleur from "kleur"
+import fuzzysort from "fuzzysort"
+import { readOcxConfig, readOcxLock } from "../schemas/config.js"
+import { fetchRegistryIndex } from "../registry/fetcher.js"
+import { logger, handleError, outputJson, createSpinner } from "../utils/index.js"
+
+interface SearchOptions {
+	cwd: string
+	json: boolean
+	quiet: boolean
+	verbose: boolean
+	installed: boolean
+	limit: number
+}
+
+export function registerSearchCommand(program: Command): void {
+	program
+		.command("search")
+		.alias("list")
+		.description("Search for components across registries or list installed")
+		.argument("[query]", "Search query")
+		.option("--cwd <path>", "Working directory", process.cwd())
+		.option("--json", "Output as JSON", false)
+		.option("-q, --quiet", "Suppress output", false)
+		.option("-v, --verbose", "Verbose output", false)
+		.option("-i, --installed", "List installed components only", false)
+		.option("-l, --limit <n>", "Limit results", "20")
+		.action(async (query: string | undefined, options: SearchOptions) => {
+			try {
+				const limit = parseInt(String(options.limit), 10)
+
+				// List installed only
+				if (options.installed) {
+					const lock = await readOcxLock(options.cwd)
+					if (!lock) {
+						if (options.json) {
+							outputJson({ success: true, data: { components: [] } })
+						} else {
+							logger.info("No components installed.")
+						}
+						return
+					}
+
+					const installed = Object.entries(lock.installed).map(([name, info]) => ({
+						name,
+						registry: info.registry,
+						version: info.version,
+						installedAt: info.installedAt,
+					}))
+
+					if (options.json) {
+						outputJson({ success: true, data: { components: installed } })
+					} else {
+						logger.info(`Installed components (${installed.length}):`)
+						for (const comp of installed) {
+							console.log(
+								`  ${kleur.cyan(comp.name)} ${kleur.dim(`v${comp.version}`)} from ${comp.registry}`,
+							)
+						}
+					}
+					return
+				}
+
+				// Search across registries
+				const config = await readOcxConfig(options.cwd)
+				if (!config) {
+					logger.warn("No ocx.jsonc found. Run 'ocx init' first.")
+					return
+				}
+
+				if (options.verbose) {
+					logger.info(`Searching in ${Object.keys(config.registries).length} registries...`)
+				}
+
+				const allComponents: Array<{
+					name: string
+					description: string
+					type: string
+					registry: string
+				}> = []
+
+				const spinner = createSpinner({
+					text: "Searching registries...",
+					quiet: options.quiet || options.verbose,
+				})
+
+				if (!options.json && !options.verbose) {
+					spinner.start()
+				}
+
+				for (const [registryName, registryConfig] of Object.entries(config.registries)) {
+					try {
+						if (options.verbose) {
+							logger.info(`Fetching index from ${registryName} (${registryConfig.url})...`)
+						}
+						const index = await fetchRegistryIndex(registryConfig.url)
+						if (options.verbose) {
+							logger.info(`Found ${index.components.length} components in ${registryName}`)
+						}
+						for (const comp of index.components) {
+							allComponents.push({
+								name: comp.name,
+								description: comp.description,
+								type: comp.type,
+								registry: registryName,
+							})
+						}
+					} catch (error) {
+						if (options.verbose) {
+							logger.warn(
+								`Failed to fetch registry ${registryName}: ${error instanceof Error ? error.message : String(error)}`,
+							)
+						}
+						// Skip failed registries
+					}
+				}
+
+				if (!options.json && !options.verbose) {
+					spinner.stop()
+				}
+
+				// Filter by query if provided
+				let results = allComponents
+				if (query) {
+					const fuzzyResults = fuzzysort.go(query, allComponents, {
+						keys: ["name", "description"],
+						limit,
+					})
+					results = fuzzyResults.map((r) => r.obj)
+				} else {
+					results = results.slice(0, limit)
+				}
+
+				if (options.json) {
+					outputJson({ success: true, data: { components: results } })
+				} else {
+					if (results.length === 0) {
+						logger.info("No components found.")
+					} else {
+						logger.info(`Found ${results.length} components:`)
+						for (const comp of results) {
+							console.log(
+								`  ${kleur.cyan(comp.name)} ${kleur.dim(`(${comp.type})`)} - ${comp.description}`,
+							)
+						}
+					}
+				}
+			} catch (error) {
+				handleError(error, { json: options.json })
+			}
+		})
+}

package/src/constants.ts

@@ -0,0 +1,18 @@
+/**
+ * OCX URL Constants
+ *
+ * Centralized URL definitions to avoid hardcoding throughout the codebase.
+ */
+
+// Base domains
+export const OCX_DOMAIN = "ocx.kdco.dev"
+export const GITHUB_REPO = "kdcokenny/ocx"
+
+// OCX URLs
+export const OCX_SCHEMA_URL = `https://${OCX_DOMAIN}/schema.json`
+export const OCX_LOCK_SCHEMA_URL = `https://${OCX_DOMAIN}/lock.schema.json`
+export const OCX_INSTALL_URL = `https://${OCX_DOMAIN}/install.sh`
+
+// GitHub URLs
+export const GITHUB_RELEASES_URL = `https://github.com/${GITHUB_REPO}/releases`
+export const GITHUB_RAW_URL = `https://raw.githubusercontent.com/${GITHUB_REPO}/main`

package/src/index.ts

@@ -0,0 +1,42 @@
+#!/usr/bin/env bun
+/**
+ * OCX CLI - OpenCode Extensions
+ * 
+ * A ShadCN-style CLI for installing agents, skills, plugins, and commands
+ * into OpenCode projects.
+ */
+
+import { Command } from "commander"
+import { registerInitCommand } from "./commands/init.js"
+import { registerAddCommand } from "./commands/add.js"
+import { registerDiffCommand } from "./commands/diff.js"
+import { registerSearchCommand } from "./commands/search.js"
+import { registerRegistryCommand } from "./commands/registry.js"
+import { registerBuildCommand } from "./commands/build.js"
+import { handleError } from "./utils/index.js"
+
+// Version injected at build time
+declare const __VERSION__: string
+const version = typeof __VERSION__ !== "undefined" ? __VERSION__ : "0.0.0-dev"
+
+async function main() {
+  const program = new Command()
+    .name("ocx")
+    .description("OpenCode Extensions - Install agents, skills, plugins, and commands")
+    .version(version)
+
+  // Register all commands using the registration pattern
+  registerInitCommand(program)
+  registerAddCommand(program)
+  registerDiffCommand(program)
+  registerSearchCommand(program)
+  registerRegistryCommand(program)
+  registerBuildCommand(program)
+
+  // Parse and handle errors
+  await program.parseAsync(process.argv)
+}
+
+main().catch((err) => {
+  handleError(err)
+})