ocx 0.1.1 → 1.0.0

package/src/commands/diff.ts

@@ -1,139 +0,0 @@
-/**
- * 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

@@ -1,90 +0,0 @@
-/**
- * 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

@@ -1,153 +0,0 @@
-/**
- * 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

@@ -1,159 +0,0 @@
-/**
- * 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

@@ -1,18 +0,0 @@
-/**
- * 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

@@ -1,42 +0,0 @@
-#!/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)
-})