ocx 0.1.1 → 1.0.0

package/package.json

@@ -1,29 +1,62 @@
 {
-  "name": "ocx",
-  "version": "0.1.1",
-  "description": "OCX CLI - Install OpenCode extensions",
-  "type": "module",
-  "main": "./dist/index.js",
-  "bin": {
-    "ocx": "./dist/index.js"
-  },
-  "scripts": {
-    "build": "bun run scripts/build.ts",
-    "build:binary": "bun run scripts/build-binary.ts",
-    "dev": "bun run src/index.ts",
-    "typecheck": "tsc --noEmit",
-    "test": "bun test"
-  },
-  "dependencies": {
-    "commander": "^14.0.0",
-    "diff": "^8.0.0",
-    "fuzzysort": "^3.1.0",
-    "kleur": "^4.1.5",
-    "ora": "^8.2.0",
-    "zod": "^3.24.0"
-  },
-  "devDependencies": {
-    "@types/bun": "latest",
-    "@types/diff": "^8.0.0"
-  }
+	"name": "ocx",
+	"version": "1.0.0",
+	"description": "OCX CLI - ShadCN-style registry for OpenCode extensions. Install agents, plugins, skills, and MCP servers.",
+	"author": "kdcokenny",
+	"license": "MIT",
+	"type": "module",
+	"main": "./dist/index.js",
+	"bin": {
+		"ocx": "./dist/index.js"
+	},
+	"files": [
+		"dist/index.js",
+		"dist/index.js.map"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/kdcokenny/ocx.git"
+	},
+	"homepage": "https://github.com/kdcokenny/ocx#readme",
+	"bugs": {
+		"url": "https://github.com/kdcokenny/ocx/issues"
+	},
+	"keywords": [
+		"opencode",
+		"cli",
+		"extensions",
+		"agents",
+		"plugins",
+		"mcp",
+		"shadcn",
+		"registry"
+	],
+	"engines": {
+		"node": ">=18"
+	},
+	"scripts": {
+		"build": "bun run scripts/build.ts",
+		"build:binary": "bun run scripts/build-binary.ts",
+		"check": "bun check:biome && bun check:types",
+		"check:biome": "biome check .",
+		"check:types": "tsc --noEmit",
+		"dev": "bun run src/index.ts",
+		"prepublishOnly": "bun run build",
+		"test": "bun test"
+	},
+	"dependencies": {
+		"commander": "^14.0.0",
+		"diff": "^8.0.0",
+		"fuzzysort": "^3.1.0",
+		"kleur": "^4.1.5",
+		"ora": "^8.2.0",
+		"zod": "^3.24.0"
+	},
+	"devDependencies": {
+		"@types/bun": "latest",
+		"@types/diff": "^8.0.0"
+	}
 }

package/scripts/build-binary.ts

@@ -1,96 +0,0 @@
-/**
- * Build binary script for OCX CLI
- * Creates standalone executables for multiple platforms
- */
-
-export {}
-
-import { readFileSync } from "node:fs"
-import { join } from "node:path"
-
-const pkg = JSON.parse(readFileSync("./package.json", "utf-8"))
-const version = pkg.version
-
-const targets = [
-	"bun-darwin-arm64",
-	"bun-darwin-x64",
-	"bun-linux-x64",
-	"bun-linux-arm64",
-	"bun-windows-x64-baseline",
-] as const
-
-type Target = (typeof targets)[number]
-
-const outDir = "./dist/bin"
-
-async function buildBinary(target: Target) {
-	const ext = target.includes("windows") ? ".exe" : ""
-	const outfile = join(outDir, `ocx-${target.replace("bun-", "")}${ext}`)
-
-	console.log(`Building ${target}...`)
-
-	// Use bun's compile for the actual binary
-	const proc = Bun.spawn([
-		"bun",
-		"build",
-		"--compile",
-		`--target=${target}`,
-		"--minify",
-		`--outfile=${outfile}`,
-		"./src/index.ts",
-	])
-
-	await proc.exited
-
-	if (proc.exitCode !== 0) {
-		console.error(`Failed to compile binary for ${target}`)
-		process.exit(1)
-	}
-
-	console.log(`✓ ${outfile}`)
-}
-
-// Parse args
-const args = process.argv.slice(2)
-const targetArg = args.find((a) => a.startsWith("--target="))
-const allFlag = args.includes("--all")
-
-if (allFlag) {
-	// Build all targets
-	for (const target of targets) {
-		await buildBinary(target)
-	}
-} else if (targetArg) {
-	// Build specific target
-	const target = targetArg.replace("--target=", "") as Target
-	if (!targets.includes(target)) {
-		console.error(`Invalid target: ${target}`)
-		console.error(`Valid targets: ${targets.join(", ")}`)
-		process.exit(1)
-	}
-	await buildBinary(target)
-} else {
-	// Default: build for current platform
-	const platform = process.platform
-	const arch = process.arch
-
-	let target: Target
-	if (platform === "darwin" && arch === "arm64") {
-		target = "bun-darwin-arm64"
-	} else if (platform === "darwin") {
-		target = "bun-darwin-x64"
-	} else if (platform === "linux" && arch === "arm64") {
-		target = "bun-linux-arm64"
-	} else if (platform === "linux") {
-		target = "bun-linux-x64"
-	} else if (platform === "win32") {
-		target = "bun-windows-x64-baseline"
-	} else {
-		console.error(`Unsupported platform: ${platform}-${arch}`)
-		process.exit(1)
-	}
-
-	await buildBinary(target)
-}
-
-console.log("\n✓ Binary build complete")

package/scripts/build.ts

@@ -1,17 +0,0 @@
-/**
- * Build script for OCX CLI
- * Compiles TypeScript to JavaScript
- */
-
-export {}
-
-await Bun.build({
-	entrypoints: ["./src/index.ts"],
-	outdir: "./dist",
-	target: "bun",
-	format: "esm",
-	minify: false,
-	sourcemap: "external",
-})
-
-console.log("✓ Build complete: ./dist/index.js")

package/scripts/install.sh

@@ -1,65 +0,0 @@
-#!/bin/bash
-# OCX Installer
-
-set -e
-
-REPO="kdcokenny/ocx"
-GITHUB_URL="https://github.com/$REPO"
-
-# Detect OS
-OS="$(uname -s | tr '[:upper:]' '[:lower:]')"
-case "$OS" in
-  darwin)  PLATFORM="darwin" ;;
-  linux)   PLATFORM="linux" ;;
-  *)       echo "Unsupported OS: $OS"; exit 1 ;;
-esac
-
-# Detect Architecture
-ARCH="$(uname -m)"
-case "$ARCH" in
-  arm64|aarch64) ARCH="arm64" ;;
-  x86_64|amd64)  ARCH="x64" ;;
-  *)             echo "Unsupported architecture: $ARCH"; exit 1 ;;
-esac
-
-# Construct binary name
-BINARY_NAME="ocx-$PLATFORM-$ARCH"
-if [ "$PLATFORM" = "windows" ]; then
-    BINARY_NAME="ocx-windows-x64-baseline.exe"
-fi
-
-# Get latest release version
-LATEST_TAG=$(curl -s "https://api.github.com/repos/$REPO/releases/latest" | grep '"tag_name":' | sed -E 's/.*"([^"]+)".*/\1/')
-
-if [ -z "$LATEST_TAG" ]; then
-    echo "Could not find latest release for $REPO"
-    exit 1
-fi
-
-DOWNLOAD_URL="$GITHUB_URL/releases/download/$LATEST_TAG/$BINARY_NAME"
-
-echo "Downloading OCX $LATEST_TAG for $PLATFORM-$ARCH..."
-echo "URL: $DOWNLOAD_URL"
-
-# Create temp directory
-TMP_DIR=$(mktemp -d)
-trap 'rm -rf "$TMP_DIR"' EXIT
-
-# Download
-curl -L "$DOWNLOAD_URL" -o "$TMP_DIR/ocx"
-
-# Installation path
-INSTALL_DIR="/usr/local/bin"
-if [ ! -w "$INSTALL_DIR" ]; then
-    INSTALL_DIR="$HOME/.local/bin"
-    mkdir -p "$INSTALL_DIR"
-    echo "Warning: /usr/local/bin is not writable. Installing to $INSTALL_DIR instead."
-    echo "Make sure $INSTALL_DIR is in your PATH."
-fi
-
-# Move to install dir
-chmod +x "$TMP_DIR/ocx"
-mv "$TMP_DIR/ocx" "$INSTALL_DIR/ocx"
-
-echo "OCX has been installed to $INSTALL_DIR/ocx"
-echo "Run 'ocx --version' to verify installation."

package/src/commands/add.ts

@@ -1,229 +0,0 @@
-/**
- * OCX CLI - add command
- * Install components from registries
- */
-
-import { existsSync } from "node:fs"
-import { mkdir, readFile, writeFile } from "node:fs/promises"
-import { dirname, join } from "node:path"
-import { createHash } from "node:crypto"
-import type { Command } from "commander"
-import { ocxConfigSchema, ocxLockSchema, type OcxLock } from "../schemas/config.js"
-import type { ComponentManifest } from "../schemas/registry.js"
-import { fetchRegistryIndex, fetchFileContent } from "../registry/fetcher.js"
-import { resolveDependencies, type ResolvedDependencies } from "../registry/resolver.js"
-import { updateOpencodeConfig } from "../registry/opencode-config.js"
-import { logger, createSpinner, handleError } from "../utils/index.js"
-import { ConfigError, IntegrityError } from "../utils/errors.js"
-
-interface AddOptions {
-	yes?: boolean
-	dryRun?: boolean
-	cwd?: string
-	quiet?: boolean
-	verbose?: boolean
-	json?: boolean
-}
-
-export function registerAddCommand(program: Command): void {
-	program
-		.command("add")
-		.description("Add components to your project")
-		.argument("<components...>", "Components to install")
-		.option("-y, --yes", "Skip prompts")
-		.option("--dry-run", "Show what would be installed without making changes")
-		.option("--cwd <path>", "Working directory", process.cwd())
-		.option("-q, --quiet", "Suppress output")
-		.option("-v, --verbose", "Verbose output")
-		.option("--json", "Output as JSON")
-		.action(async (components: string[], options: AddOptions) => {
-			try {
-				await runAdd(components, options)
-			} catch (error) {
-				handleError(error, { json: options.json })
-			}
-		})
-}
-
-async function runAdd(componentNames: string[], options: AddOptions): Promise<void> {
-	const cwd = options.cwd ?? process.cwd()
-	const configPath = join(cwd, "ocx.jsonc")
-	const lockPath = join(cwd, "ocx.lock")
-
-	// Load config
-	if (!existsSync(configPath)) {
-		throw new ConfigError("No ocx.jsonc found. Run 'ocx init' first.")
-	}
-
-	const configContent = await readFile(configPath, "utf-8")
-	const config = ocxConfigSchema.parse(JSON.parse(configContent))
-
-	// Load or create lock
-	let lock: OcxLock = { lockVersion: 1, installed: {} }
-	if (existsSync(lockPath)) {
-		const lockContent = await readFile(lockPath, "utf-8")
-		lock = ocxLockSchema.parse(JSON.parse(lockContent))
-	}
-
-	const spin = options.quiet ? null : createSpinner({ text: "Resolving dependencies..." })
-	spin?.start()
-
-	try {
-		// Resolve all dependencies across all configured registries
-		const resolved = await resolveDependencies(config.registries, componentNames)
-
-		spin?.succeed(`Resolved ${resolved.components.length} components`)
-
-		if (options.verbose) {
-			logger.info("Install order:")
-			for (const name of resolved.installOrder) {
-				logger.info(`  - ${name}`)
-			}
-		}
-
-		if (options.dryRun) {
-			logger.info("")
-			logger.info("Dry run - no changes made")
-			logResolved(resolved)
-			return
-		}
-
-		// Install components
-		const installSpin = options.quiet ? null : createSpinner({ text: "Installing components..." })
-		installSpin?.start()
-
-		for (const component of resolved.components) {
-			// Fetch component files and compute bundle hash
-			const files: { path: string; content: Buffer }[] = []
-			for (const file of component.files) {
-				const content = await fetchFileContent(component.baseUrl, component.name, file.path)
-				files.push({ path: file.path, content: Buffer.from(content) })
-			}
-
-			const computedHash = await hashBundle(files)
-
-			// Verify integrity if already in lock
-			const existingEntry = lock.installed[component.name]
-			if (existingEntry && existingEntry.hash !== computedHash) {
-				throw new IntegrityError(component.name, existingEntry.hash, computedHash)
-			}
-
-			// Install components
-			await installComponent(component, files, cwd)
-
-			// Fetch registry index to get version for lockfile
-			const index = await fetchRegistryIndex(component.baseUrl)
-
-			// Update lock
-			lock.installed[component.name] = {
-				registry: component.registryName,
-				version: index.version,
-				hash: computedHash,
-				target: getTargetPath(component),
-				installedAt: new Date().toISOString(),
-			}
-		}
-
-		installSpin?.succeed(`Installed ${resolved.components.length} components`)
-
-		// Apply opencode.json changes
-		if (Object.keys(resolved.mcpServers).length > 0) {
-			const result = await updateOpencodeConfig(cwd, {
-				mcpServers: resolved.mcpServers,
-			})
-
-			if (result.mcpSkipped.length > 0 && !options.quiet) {
-				for (const name of result.mcpSkipped) {
-					logger.warn(`MCP server "${name}" already configured, skipped`)
-				}
-			}
-
-			if (!options.quiet && result.mcpAdded.length > 0) {
-				logger.info(`Configured ${result.mcpAdded.length} MCP servers`)
-			}
-		}
-
-		// Save lock file
-		await writeFile(lockPath, JSON.stringify(lock, null, 2), "utf-8")
-
-		if (options.json) {
-			console.log(
-				JSON.stringify(
-					{
-						success: true,
-						installed: resolved.installOrder,
-						mcpServers: Object.keys(resolved.mcpServers),
-					},
-					null,
-					2,
-				),
-			)
-		} else if (!options.quiet) {
-			logger.info("")
-			logger.success(`Done! Installed ${resolved.components.length} components.`)
-		}
-	} catch (error) {
-		spin?.fail("Failed to resolve dependencies")
-		throw error
-	}
-}
-
-async function installComponent(
-	component: ComponentManifest,
-	files: { path: string; content: Buffer }[],
-	cwd: string,
-): Promise<void> {
-	for (const file of files) {
-		const componentFile = component.files.find((f) => f.path === file.path)
-		if (!componentFile) continue
-
-		const targetPath = join(cwd, componentFile.target)
-		const targetDir = dirname(targetPath)
-
-		// Create directory if needed
-		if (!existsSync(targetDir)) {
-			await mkdir(targetDir, { recursive: true })
-		}
-
-		await writeFile(targetPath, file.content)
-	}
-}
-
-function getTargetPath(component: ComponentManifest): string {
-	return component.files[0]?.target ?? `.opencode/${component.type}/${component.name}`
-}
-
-async function hashContent(content: string | Buffer): Promise<string> {
-	return createHash("sha256").update(content).digest("hex")
-}
-
-async function hashBundle(files: { path: string; content: Buffer }[]): Promise<string> {
-	// Sort files for deterministic hashing
-	const sorted = [...files].sort((a, b) => a.path.localeCompare(b.path))
-
-	// Create a manifest of file hashes
-	const manifestParts: string[] = []
-	for (const file of sorted) {
-		const hash = await hashContent(file.content)
-		manifestParts.push(`${file.path}:${hash}`)
-	}
-
-	// Hash the manifest itself
-	return hashContent(manifestParts.join("\n"))
-}
-
-function logResolved(resolved: ResolvedDependencies): void {
-	logger.info("")
-	logger.info("Would install:")
-	for (const component of resolved.components) {
-		logger.info(`  ${component.name} (${component.type}) from ${component.registryName}`)
-	}
-
-	if (Object.keys(resolved.mcpServers).length > 0) {
-		logger.info("")
-		logger.info("Would configure MCP servers:")
-		for (const name of Object.keys(resolved.mcpServers)) {
-			logger.info(`  ${name}`)
-		}
-	}
-}

package/src/commands/build.ts

@@ -1,150 +0,0 @@
-/**
- * Build Command (for Registry Authors)
- * 
- * Validate and build a registry from source.
- */
-
-import { Command } from "commander"
-import { join, relative, dirname } from "node:path"
-import { mkdir } from "node:fs/promises"
-import { existsSync } from "node:fs"
-import kleur from "kleur"
-import { registrySchema, componentManifestSchema } from "../schemas/registry.js"
-import { logger, handleError, outputJson, createSpinner } from "../utils/index.js"
-
-interface BuildOptions {
-  cwd: string
-  out: string
-  json: boolean
-  quiet: boolean
-}
-
-export function registerBuildCommand(program: Command): void {
-  program
-    .command("build")
-    .description("Build a registry from source (for registry authors)")
-    .argument("[path]", "Registry source directory", ".")
-    .option("--out <dir>", "Output directory", "./dist")
-    .option("--cwd <path>", "Working directory", process.cwd())
-    .option("--json", "Output as JSON", false)
-    .option("-q, --quiet", "Suppress output", false)
-    .action(async (path: string, options: BuildOptions) => {
-      try {
-        const sourcePath = join(options.cwd, path)
-        const outPath = join(options.cwd, options.out)
-
-        const spinner = createSpinner({ text: "Building registry...", quiet: options.quiet || options.json })
-        if (!options.json) spinner.start()
-
-        // Read registry.json from source
-        const registryFile = Bun.file(join(sourcePath, "registry.json"))
-        if (!(await registryFile.exists())) {
-          if (!options.json) spinner.fail("No registry.json found in source directory")
-          process.exit(1)
-        }
-
-        const registryData = await registryFile.json()
-        
-        // Validate registry schema
-        const parseResult = registrySchema.safeParse(registryData)
-        if (!parseResult.success) {
-          if (!options.json) {
-            spinner.fail("Registry validation failed")
-            const errors = parseResult.error.errors.map(e => `  ${e.path.join(".")}: ${e.message}`)
-            for (const err of errors) {
-              console.log(kleur.red(err))
-            }
-          }
-          process.exit(1)
-        }
-
-        const registry = parseResult.data
-        const validationErrors: string[] = []
-
-        // Create output directory structure
-        const componentsDir = join(outPath, "components")
-        await mkdir(componentsDir, { recursive: true })
-
-        // Generate packument and copy files for each component
-        for (const component of registry.components) {
-          const packument = {
-            name: component.name,
-            versions: {
-              [registry.version]: component,
-            },
-            "dist-tags": {
-              latest: registry.version,
-            },
-          }
-
-          // Write manifest to components/[name].json
-          const packumentPath = join(componentsDir, `${component.name}.json`)
-          await Bun.write(packumentPath, JSON.stringify(packument, null, 2))
-
-          // Copy files to components/[name]/[path]
-          for (const file of component.files) {
-            const sourceFilePath = join(sourcePath, "files", file.path)
-            const destFilePath = join(componentsDir, component.name, file.path)
-            const destFileDir = dirname(destFilePath)
-
-            if (!(await Bun.file(sourceFilePath).exists())) {
-              validationErrors.push(`${component.name}: Source file not found at ${sourceFilePath}`)
-              continue
-            }
-
-            await mkdir(destFileDir, { recursive: true })
-            const sourceFile = Bun.file(sourceFilePath)
-            await Bun.write(destFilePath, sourceFile)
-          }
-        }
-
-        // Fail fast if source files were missing during copy
-        if (validationErrors.length > 0) {
-          if (!options.json) {
-            spinner.fail(`Build failed with ${validationErrors.length} errors`)
-            for (const err of validationErrors) {
-              console.log(kleur.red(`  ${err}`))
-            }
-          }
-          process.exit(1)
-        }
-
-        // Generate index.json at the root
-        const index = {
-          name: registry.name,
-          prefix: registry.prefix,
-          version: registry.version,
-          author: registry.author,
-          components: registry.components.map(c => ({
-            name: c.name,
-            type: c.type,
-            description: c.description,
-          })),
-        }
-
-        await Bun.write(join(outPath, "index.json"), JSON.stringify(index, null, 2))
-
-        if (!options.json) {
-          const msg = `Built ${registry.components.length} components to ${relative(options.cwd, outPath)}`
-          spinner.succeed(msg)
-          if (process.env.NODE_ENV === "test" || !process.stdout.isTTY) {
-            logger.success(`Built ${registry.components.length} components`)
-          }
-        }
-
-        if (options.json) {
-          outputJson({
-            success: true,
-            data: {
-              name: registry.name,
-              version: registry.version,
-              components: registry.components.length,
-              output: outPath,
-            },
-          })
-        }
-      } catch (error) {
-        handleError(error, { json: options.json })
-      }
-    })
-}