ocx 0.1.1 → 1.0.0

package/src/utils/spinner.ts

@@ -1,46 +0,0 @@
-/**
- * Spinner utility for async operations
- * Uses ora, disabled in CI/non-TTY environments
- */
-
-import ora, { type Ora } from "ora"
-import { isCI, isTTY } from "./env"
-
-export interface SpinnerOptions {
-	text: string
-	quiet?: boolean
-}
-
-/**
- * Create a spinner that works in TTY, falls back gracefully in CI
- */
-export function createSpinner(options: SpinnerOptions): Ora {
-	const shouldSpin = isTTY && !options.quiet
-
-	const spinner = ora({
-		text: options.text,
-		isSilent: !shouldSpin,
-	})
-
-	return spinner
-}
-
-/**
- * Run an async function with a spinner
- */
-export async function withSpinner<T>(
-	options: SpinnerOptions,
-	fn: (spinner: Ora) => Promise<T>,
-): Promise<T> {
-	const spinner = createSpinner(options)
-	spinner.start()
-
-	try {
-		const result = await fn(spinner)
-		spinner.succeed()
-		return result
-	} catch (error) {
-		spinner.fail()
-		throw error
-	}
-}

package/tests/add.test.ts

@@ -1,102 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll, afterEach } from "bun:test"
-import { existsSync } from "node:fs"
-import { readFile, writeFile } from "node:fs/promises"
-import { join } from "node:path"
-import { createTempDir, cleanupTempDir, runCLI, stripJsonc } from "./helpers"
-import { startMockRegistry, type MockRegistry } from "./mock-registry"
-
-describe("ocx add", () => {
-	let testDir: string
-	let registry: MockRegistry
-
-	beforeAll(() => {
-		registry = startMockRegistry()
-	})
-
-	afterAll(() => {
-		registry.stop()
-	})
-
-	afterEach(async () => {
-		if (testDir) {
-			await cleanupTempDir(testDir)
-		}
-	})
-
-	it("should fail if not initialized", async () => {
-		testDir = await createTempDir("add-no-init")
-		const { exitCode, output } = await runCLI(["add", "test-comp"], testDir)
-		expect(exitCode).not.toBe(0)
-		expect(output).toContain("Run 'ocx init' first")
-	})
-
-	it("should install a component and its dependencies", async () => {
-		testDir = await createTempDir("add-basic")
-
-		// Init and add registry
-		await runCLI(["init", "--yes"], testDir)
-
-		// Manually add registry to config since 'ocx registry add' might be flaky in parallel tests
-		const configPath = join(testDir, "ocx.jsonc")
-		const config = JSON.parse(stripJsonc(await readFile(configPath, "utf-8")))
-		config.registries = {
-			test: { url: registry.url },
-		}
-		await writeFile(configPath, JSON.stringify(config, null, 2))
-
-		// Install agent which depends on skill which depends on plugin
-		const { exitCode, output } = await runCLI(["add", "kdco-test-agent", "--yes"], testDir)
-
-		if (exitCode !== 0) {
-			console.log(output)
-		}
-		expect(exitCode).toBe(0)
-
-		// Verify files
-		expect(existsSync(join(testDir, ".opencode/agent/kdco-test-agent.md"))).toBe(true)
-		expect(existsSync(join(testDir, ".opencode/skill/kdco-test-skill/SKILL.md"))).toBe(true)
-		expect(existsSync(join(testDir, ".opencode/plugin/kdco-test-plugin.ts"))).toBe(true)
-
-		// Verify lock file
-		const lockPath = join(testDir, "ocx.lock")
-		expect(existsSync(lockPath)).toBe(true)
-		const lock = JSON.parse(stripJsonc(await readFile(lockPath, "utf-8")))
-		expect(lock.installed["kdco-test-agent"]).toBeDefined()
-		expect(lock.installed["kdco-test-skill"]).toBeDefined()
-		expect(lock.installed["kdco-test-plugin"]).toBeDefined()
-
-		// Verify opencode.json patching
-		const opencodePath = join(testDir, "opencode.json")
-		expect(existsSync(opencodePath)).toBe(true)
-		const opencode = JSON.parse(await readFile(opencodePath, "utf-8"))
-		expect(opencode.mcp["test-mcp"]).toBeDefined()
-		expect(opencode.mcp["test-mcp"].url).toBe("https://mcp.test.com")
-	})
-
-	it("should fail if integrity check fails", async () => {
-		testDir = await createTempDir("add-integrity-fail")
-
-		// Init and add registry
-		await runCLI(["init", "--yes"], testDir)
-
-		const configPath = join(testDir, "ocx.jsonc")
-		const config = JSON.parse(stripJsonc(await readFile(configPath, "utf-8")))
-		config.registries = {
-			test: { url: registry.url },
-		}
-		await writeFile(configPath, JSON.stringify(config, null, 2))
-
-		// 1. Install normally to create lock entry
-		await runCLI(["add", "kdco-test-plugin", "--yes"], testDir)
-
-		// 2. Tamper with the registry content
-		registry.setFileContent("kdco-test-plugin", "index.ts", "TAMPERED CONTENT")
-
-		// 3. Try to add again (should fail integrity check)
-		const { exitCode, output } = await runCLI(["add", "kdco-test-plugin", "--yes"], testDir)
-
-		expect(exitCode).not.toBe(0)
-		expect(output).toContain("Integrity verification failed")
-		expect(output).toContain("The registry content has changed since this component was locked")
-	})
-})

package/tests/build.test.ts

@@ -1,136 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test"
-import { createTempDir, cleanupTempDir, runCLI, stripJsonc } from "./helpers"
-import { join } from "node:path"
-import { existsSync } from "node:fs"
-import { mkdir, writeFile, readFile } from "node:fs/promises"
-
-describe("ocx build", () => {
-	let testDir: string
-
-	beforeEach(async () => {
-		testDir = await createTempDir("build-test")
-	})
-
-	afterEach(async () => {
-		await cleanupTempDir(testDir)
-	})
-
-	it("should build a valid registry from source", async () => {
-		// Create registry source
-		const sourceDir = join(testDir, "registry")
-		await mkdir(sourceDir, { recursive: true })
-
-		const registryJson = {
-			name: "Test Registry",
-			prefix: "kdco",
-			version: "1.0.0",
-			author: "Test Author",
-			components: [
-				{
-					name: "kdco-comp-1",
-					type: "ocx:plugin",
-					description: "Test component 1",
-					files: [{ path: "index.ts", target: ".opencode/plugin/kdco-comp-1.ts" }],
-					dependencies: [],
-				},
-				{
-					name: "kdco-comp-2",
-					type: "ocx:agent",
-					description: "Test component 2",
-					files: [{ path: "agent.md", target: ".opencode/agent/kdco-comp-2.md" }],
-					dependencies: ["kdco-comp-1"],
-				},
-			],
-		}
-
-		await writeFile(join(sourceDir, "registry.json"), JSON.stringify(registryJson, null, 2))
-
-		// Create the files directory and source files
-		const filesDir = join(sourceDir, "files")
-		await mkdir(filesDir, { recursive: true })
-		await writeFile(join(filesDir, "index.ts"), "// Test plugin content")
-		await writeFile(join(filesDir, "agent.md"), "# Test agent content")
-
-		// Run build
-		const outDir = "dist"
-		const { exitCode, output } = await runCLI(["build", "registry", "--out", outDir], testDir)
-
-		if (exitCode !== 0) {
-			console.log(output)
-		}
-		expect(exitCode).toBe(0)
-		expect(output).toContain("Built 2 components")
-
-		// Verify output files
-		const fullOutDir = join(testDir, outDir)
-		expect(existsSync(join(fullOutDir, "index.json"))).toBe(true)
-		expect(existsSync(join(fullOutDir, "components", "kdco-comp-1.json"))).toBe(true)
-		expect(existsSync(join(fullOutDir, "components", "kdco-comp-2.json"))).toBe(true)
-
-		// Verify index.json content
-		const index = JSON.parse(await readFile(join(fullOutDir, "index.json"), "utf-8"))
-		expect(index.name).toBe("Test Registry")
-		expect(index.components.length).toBe(2)
-		expect(index.components[0].name).toBe("kdco-comp-1")
-	})
-
-	it("should fail if component prefix is missing", async () => {
-		const sourceDir = join(testDir, "registry-invalid")
-		await mkdir(sourceDir, { recursive: true })
-
-		const registryJson = {
-			name: "Invalid Registry",
-			prefix: "kdco",
-			version: "1.0.0",
-			author: "Test Author",
-			components: [
-				{
-					name: "wrong-prefix",
-					type: "ocx:plugin",
-					description: "Invalid component",
-					files: [{ path: "index.ts", target: ".opencode/plugin/wrong-prefix.ts" }],
-					dependencies: [],
-				},
-			],
-		}
-
-		await writeFile(join(sourceDir, "registry.json"), JSON.stringify(registryJson, null, 2))
-
-		const { exitCode, output } = await runCLI(["build", "registry-invalid"], testDir)
-
-		expect(exitCode).not.toBe(0)
-		// Match the actual Zod error message
-		expect(output).toContain("All component names must start with the registry prefix")
-	})
-
-	it("should fail on missing dependencies", async () => {
-		const sourceDir = join(testDir, "registry-missing-dep")
-		await mkdir(sourceDir, { recursive: true })
-
-		const registryJson = {
-			name: "Missing Dep Registry",
-			prefix: "kdco",
-			version: "1.0.0",
-			author: "Test Author",
-			components: [
-				{
-					name: "kdco-comp",
-					type: "ocx:plugin",
-					description: "Component with missing dep",
-					files: [{ path: "index.ts", target: ".opencode/plugin/kdco-comp.ts" }],
-					dependencies: ["kdco-non-existent"],
-				},
-			],
-		}
-
-		await writeFile(join(sourceDir, "registry.json"), JSON.stringify(registryJson, null, 2))
-
-		const { exitCode, output } = await runCLI(["build", "registry-missing-dep"], testDir)
-
-		expect(exitCode).not.toBe(0)
-		// Match the actual Zod error message
-		expect(output).toContain(
-			"All dependencies must reference components that exist in the registry",
-		)
-	})
-})

package/tests/diff.test.ts

@@ -1,47 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test"
-import { createTempDir, cleanupTempDir, runCLI } from "./helpers"
-import { startMockRegistry, type MockRegistry } from "./mock-registry"
-import { join } from "node:path"
-import { writeFile, mkdir } from "node:fs/promises"
-
-describe("ocx diff", () => {
-	let testDir: string
-	let registry: MockRegistry
-
-	beforeEach(async () => {
-		testDir = await createTempDir("diff-test")
-		registry = startMockRegistry()
-		await runCLI(["init", "--yes"], testDir)
-		await runCLI(["registry", "add", registry.url, "--name", "test-reg"], testDir)
-	})
-
-	afterEach(async () => {
-		registry.stop()
-		await cleanupTempDir(testDir)
-	})
-
-	it("should show no changes when local matches upstream", async () => {
-		// Mock an install
-		await runCLI(["add", "kdco-test-plugin", "--yes"], testDir)
-
-		const { exitCode, output } = await runCLI(["diff", "kdco-test-plugin"], testDir)
-
-		expect(exitCode).toBe(0)
-		expect(output).toContain("No changes")
-	})
-
-	it("should detect changes when local file is modified", async () => {
-		// Mock an install
-		await runCLI(["add", "kdco-test-plugin", "--yes"], testDir)
-
-		// Modify the local file
-		const pluginPath = join(testDir, ".opencode/plugin/kdco-test-plugin.ts")
-		await writeFile(pluginPath, "console.log('modified')")
-
-		const { exitCode, output } = await runCLI(["diff", "kdco-test-plugin"], testDir)
-
-		expect(exitCode).toBe(0)
-		expect(output).toContain("Diff for kdco-test-plugin")
-    expect(output).toContain("+console.log('modified')")
-	})
-})

package/tests/helpers.ts

@@ -1,68 +0,0 @@
-import { join } from "node:path"
-import { mkdir, rm } from "node:fs/promises"
-import { existsSync } from "node:fs"
-
-export interface CLIResult {
-	stdout: string
-	stderr: string
-	output: string
-	exitCode: number
-}
-
-export async function createTempDir(prefix: string): Promise<string> {
-	const path = join(
-		process.cwd(),
-		"tests/fixtures",
-		`tmp-${prefix}-${Math.random().toString(36).slice(2)}`,
-	)
-	await mkdir(path, { recursive: true })
-	return path
-}
-
-export async function cleanupTempDir(path: string): Promise<void> {
-	if (existsSync(path)) {
-		await rm(path, { recursive: true, force: true })
-	}
-}
-
-/**
- * Strips JSONC comments for parsing in tests
- * Minimal version that avoids breaking URLs
- */
-export function stripJsonc(content: string): string {
-	return content
-		.split("\n")
-		.map((line) => {
-			const trimmed = line.trim()
-			if (trimmed.startsWith("//")) return ""
-			// This is still naive but better for our tests which don't use complex JSONC
-			return line
-		})
-		.join("\n")
-		.replace(/\/\*[\s\S]*?\*\//g, "")
-}
-
-export async function runCLI(args: string[], cwd: string): Promise<CLIResult> {
-	const indexPath = join(process.cwd(), "packages/cli/src/index.ts")
-
-	const proc = Bun.spawn(["bun", "run", indexPath, ...args], {
-		cwd,
-		env: {
-			...process.env,
-			FORCE_COLOR: "0",
-		},
-		stdout: "pipe",
-		stderr: "pipe",
-	})
-
-	const stdout = await new Response(proc.stdout).text()
-	const stderr = await new Response(proc.stderr).text()
-	const exitCode = await proc.exited
-
-	return {
-		stdout,
-		stderr,
-		output: stdout + stderr,
-		exitCode,
-	}
-}

package/tests/init.test.ts

@@ -1,52 +0,0 @@
-import { describe, it, expect, afterEach } from "bun:test"
-import { existsSync } from "node:fs"
-import { readFile } from "node:fs/promises"
-import { join } from "node:path"
-import { createTempDir, cleanupTempDir, runCLI, stripJsonc } from "./helpers"
-
-describe("ocx init", () => {
-	let testDir: string
-
-	afterEach(async () => {
-		if (testDir) {
-			await cleanupTempDir(testDir)
-		}
-	})
-
-	it("should create ocx.jsonc with default config", async () => {
-		testDir = await createTempDir("init-basic")
-		const { exitCode, output } = await runCLI(["init", "--yes"], testDir)
-
-		expect(exitCode).toBe(0)
-		// Success message from logger.success
-		expect(output).toContain("Initialized OCX configuration")
-
-		const configPath = join(testDir, "ocx.jsonc")
-		expect(existsSync(configPath)).toBe(true)
-
-		const content = await readFile(configPath, "utf-8")
-		const config = JSON.parse(stripJsonc(content))
-		expect(config.registries).toBeDefined()
-		expect(config.lockRegistries).toBe(false)
-	})
-
-	it("should warn if ocx.jsonc already exists", async () => {
-		testDir = await createTempDir("init-exists")
-		const configPath = join(testDir, "ocx.jsonc")
-		await Bun.write(configPath, "{}")
-
-		const { exitCode, output } = await runCLI(["init"], testDir)
-		expect(exitCode).toBe(0)
-		expect(output).toContain("ocx.jsonc already exists")
-	})
-
-	it("should output JSON when requested", async () => {
-		testDir = await createTempDir("init-json")
-		const { exitCode, output } = await runCLI(["init", "--yes", "--json"], testDir)
-
-		expect(exitCode).toBe(0)
-		const json = JSON.parse(output)
-		expect(json.success).toBe(true)
-		expect(json.path).toContain("ocx.jsonc")
-	})
-})

package/tests/mock-registry.ts

@@ -1,105 +0,0 @@
-import { type Server } from "bun"
-
-export interface MockRegistry {
-	server: Server
-	url: string
-	stop: () => void
-	setFileContent: (componentName: string, fileName: string, content: string) => void
-}
-
-/**
- * Start a mock HTTP registry server for testing
- */
-export function startMockRegistry(): MockRegistry {
-	const customFiles = new Map<string, string>()
-
-	const components = {
-		"kdco-test-plugin": {
-			name: "kdco-test-plugin",
-			type: "ocx:plugin",
-			description: "A test plugin",
-			files: [{ path: "index.ts", target: ".opencode/plugin/kdco-test-plugin.ts" }],
-			dependencies: [],
-		},
-		"kdco-test-skill": {
-			name: "kdco-test-skill",
-			type: "ocx:skill",
-			description: "A test skill",
-			files: [{ path: "SKILL.md", target: ".opencode/skill/kdco-test-skill/SKILL.md" }],
-			dependencies: ["kdco-test-plugin"],
-		},
-		"kdco-test-agent": {
-			name: "kdco-test-agent",
-			type: "ocx:agent",
-			description: "A test agent",
-			files: [{ path: "agent.md", target: ".opencode/agent/kdco-test-agent.md" }],
-			dependencies: ["kdco-test-skill"],
-			mcpServers: {
-				"test-mcp": {
-					type: "remote",
-					url: "https://mcp.test.com",
-				},
-			},
-		},
-	}
-
-	const server = Bun.serve({
-		port: 0, // Random port
-		fetch(req) {
-			const url = new URL(req.url)
-			const path = url.pathname
-
-			if (path === "/index.json") {
-				return Response.json({
-					name: "Test Registry",
-					prefix: "kdco",
-					version: "1.0.0",
-					author: "Test Author",
-					components: Object.values(components).map((c) => ({
-						name: c.name,
-						type: c.type,
-						description: c.description,
-					})),
-				})
-			}
-
-			const componentMatch = path.match(/^\/components\/(.+)\.json$/)
-			if (componentMatch) {
-				const name = componentMatch[1]
-				const component = components[name as keyof typeof components]
-				if (component) {
-					return Response.json({
-						name: component.name,
-						"dist-tags": {
-							latest: "1.0.0",
-						},
-						versions: {
-							"1.0.0": component,
-						},
-					})
-				}
-			}
-
-			const fileMatch = path.match(/^\/components\/(.+)\/(.+)$/)
-			if (fileMatch) {
-				const [, name, filePath] = fileMatch
-				const customKey = `${name}:${filePath}`
-				if (customFiles.has(customKey)) {
-					return new Response(customFiles.get(customKey))
-				}
-				return new Response(`Content of ${filePath} for ${name}`)
-			}
-
-			return new Response("Not Found", { status: 404 })
-		},
-	})
-
-	return {
-		server,
-		url: `http://localhost:${server.port}`,
-		stop: () => server.stop(),
-		setFileContent: (componentName: string, fileName: string, content: string) => {
-			customFiles.set(`${componentName}:${fileName}`, content)
-		},
-	}
-}

package/tests/registry.test.ts

@@ -1,78 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test"
-import { createTempDir, cleanupTempDir, runCLI, stripJsonc } from "./helpers"
-import { startMockRegistry, type MockRegistry } from "./mock-registry"
-import { join } from "node:path"
-import { existsSync } from "node:fs"
-
-describe("ocx registry", () => {
-	let testDir: string
-	let registry: MockRegistry
-
-	beforeEach(async () => {
-		testDir = await createTempDir("registry-test")
-		registry = startMockRegistry()
-		await runCLI(["init", "--yes"], testDir)
-	})
-
-	afterEach(async () => {
-		registry.stop()
-		await cleanupTempDir(testDir)
-	})
-
-	it("should add a registry", async () => {
-		const { exitCode, output } = await runCLI(
-			["registry", "add", registry.url, "--name", "test-reg"],
-			testDir,
-		)
-
-		if (exitCode !== 0) {
-			console.log(output)
-		}
-		expect(exitCode).toBe(0)
-		expect(output).toContain("Added registry: test-reg")
-
-		const configPath = join(testDir, "ocx.jsonc")
-		const configContent = await Bun.file(configPath).text()
-		const config = JSON.parse(stripJsonc(configContent))
-		expect(config.registries["test-reg"]).toBeDefined()
-		expect(config.registries["test-reg"].url).toBe(registry.url)
-	})
-
-	it("should list configured registries", async () => {
-		await runCLI(["registry", "add", registry.url, "--name", "test-reg"], testDir)
-
-		const { exitCode, output } = await runCLI(["registry", "list"], testDir)
-
-		expect(exitCode).toBe(0)
-		expect(output).toContain("test-reg")
-		expect(output).toContain(registry.url)
-	})
-
-	it("should remove a registry", async () => {
-		await runCLI(["registry", "add", registry.url, "--name", "test-reg"], testDir)
-
-		const { exitCode, output } = await runCLI(["registry", "remove", "test-reg"], testDir)
-
-		expect(exitCode).toBe(0)
-		expect(output).toContain("Removed registry: test-reg")
-
-		const configPath = join(testDir, "ocx.jsonc")
-		const configContent = await Bun.file(configPath).text()
-		const config = JSON.parse(stripJsonc(configContent))
-		expect(config.registries["test-reg"]).toBeUndefined()
-	})
-
-	it("should fail if adding to locked registries", async () => {
-		// Manually lock registries
-		const configPath = join(testDir, "ocx.jsonc")
-		const configContent = await Bun.file(configPath).text()
-		const config = JSON.parse(stripJsonc(configContent))
-		config.lockRegistries = true
-		await Bun.write(configPath, JSON.stringify(config, null, 2))
-
-		const { exitCode, output } = await runCLI(["registry", "add", "http://example.com"], testDir)
-
-		expect(exitCode).not.toBe(0)
-		expect(output).toContain("Registries are locked")
-	})
-})