Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
124 changes: 124 additions & 0 deletions packages/opencode/src/ockit/dependencies.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,124 @@
// OC Kit dependency resolution. Handles kit inter-dependencies with semver
// range checking, topological sort, and circular dependency detection.

import { Effect, Schema } from "effect"
import type { Kit } from "./types"
import { satisfiesRange } from "./versioning"

/** A resolved dependency reference. */
export const ResolvedDependency = Schema.Struct({
kitId: Schema.String,
version: Schema.String,
constraint: Schema.String,
})
export type ResolvedDependency = Schema.Schema.Type<typeof ResolvedDependency>

/** Error types for dependency resolution. */
export class DependencyError extends Schema.TaggedErrorClass<DependencyError>()("OCKitDependencyError", {
kind: Schema.Literals(["not-found", "version-conflict", "circular", "constraint"]),
detail: Schema.String,
}) {
override get message(): string {
return `OC Kit dependency: ${this.kind} — ${this.detail}`
}
}

/** A dependency declaration: kit ID + semver constraint. */
export interface DependencyDecl {
readonly id: string
readonly constraint: string
}

/**
* Resolve dependencies for a kit. Takes explicit dependency declarations
* (since Kit.type does not embed dependencies) and the available kits in
* the registry, returns a topologically sorted list.
*/
export function resolveDependencies(
deps: ReadonlyArray<DependencyDecl>,
available: ReadonlyArray<Kit>,
): Effect.Effect<ReadonlyArray<ResolvedDependency>, DependencyError> {
const availableMap = new Map(available.map((k) => [k.id, k]))
const resolved: ResolvedDependency[] = []
const visited = new Set<string>()
const inStack = new Set<string>()

function visit(id: string, constraint: string): void {
if (visited.has(id)) return
if (inStack.has(id)) {
throw new DependencyError({
kind: "circular",
detail: `Circular dependency detected: ${id}`,
})
}

inStack.add(id)

const depKit = availableMap.get(id)
if (!depKit) {
throw new DependencyError({
kind: "not-found",
detail: `Dependency "${id}" not found in registry`,
})
}

if (!satisfiesRange(depKit.version, constraint)) {
throw new DependencyError({
kind: "version-conflict",
detail: `${id}@${depKit.version} does not satisfy ${constraint}`,
})
}

resolved.push({
kitId: id,
version: depKit.version,
constraint,
})

inStack.delete(id)
visited.add(id)
}

try {
for (const dep of deps) {
visit(dep.id, dep.constraint)
}
} catch (err) {
if (err instanceof DependencyError) return Effect.fail(err)
return Effect.fail(new DependencyError({
kind: "constraint",
detail: `Unexpected error: ${String(err)}`,
}))
}

return Effect.succeed(resolved)
}

/**
* Detect conflicts in a set of dependency declarations. Returns a list of
* conflicts found, or an empty array if all dependencies are satisfiable.
*/
export function detectConflicts(
deps: ReadonlyArray<DependencyDecl>,
available: ReadonlyArray<Kit>,
): ReadonlyArray<{ kitA: string; kitB: string; reason: string }> {
const availableMap = new Map(available.map((k) => [k.id, k]))
const conflicts: Array<{ kitA: string; kitB: string; reason: string }> = []

for (const dep of deps) {
const depKit = availableMap.get(dep.id)
if (!depKit) {
conflicts.push({ kitA: "root", kitB: dep.id, reason: "not found" })
} else if (!satisfiesRange(depKit.version, dep.constraint)) {
conflicts.push({
kitA: "root",
kitB: dep.id,
reason: `${depKit.version} does not satisfy ${dep.constraint}`,
})
}
}

return conflicts
}

export * as Dependencies from "./dependencies"
4 changes: 4 additions & 0 deletions packages/opencode/src/ockit/index.ts
Original file line number Diff line number Diff line change
Expand Up @@ -30,3 +30,7 @@ export {

export { Service as Registry, node as registryNode } from "./registry"
export * as OCKitCli from "./cli"
export * as OCKitDependencies from "./dependencies"
export * as OCKitVersioning from "./versioning"
export * as OCKitMarketplace from "./marketplace"
export * as OCKitTesting from "./testing"
148 changes: 148 additions & 0 deletions packages/opencode/src/ockit/marketplace.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,148 @@
// OC Kit marketplace. Discover, search, and rate kits from the registry.
// Provides a higher-level API over the base registry for marketplace features.

import { Effect, Schema } from "effect"
import type { Kit } from "./types"

/** Search result for a kit. */
export class KitSearchResult extends Schema.Class<KitSearchResult>("OCKit.KitSearchResult")({
kitId: Schema.String,
name: Schema.String,
version: Schema.String,
description: Schema.String,
rating: Schema.Number,
downloads: Schema.Number,
stars: Schema.Number,
}) {}

/** Kit metadata for marketplace display. */
export class KitMetadata extends Schema.Class<KitMetadata>("OCKit.KitMetadata")({
kitId: Schema.String,
name: Schema.String,
version: Schema.String,
description: Schema.String,
author: Schema.String,
license: Schema.String,
repository: Schema.optional(Schema.String),
homepage: Schema.optional(Schema.String),
keywords: Schema.Array(Schema.String),
downloads: Schema.Number,
stars: Schema.Number,
rating: Schema.Number,
}) {}

/** Search filters for the marketplace. */
export interface KitSearchFilters {
readonly query?: string
readonly tags?: ReadonlyArray<string>
readonly minRating?: number
readonly sortBy?: "relevance" | "downloads" | "stars" | "rating" | "updated"
readonly limit?: number
readonly offset?: number
}

/** In-memory marketplace store. */
const marketplaceStore = new Map<string, KitMetadata>()

/** Register a kit in the marketplace. */
export function registerKit(metadata: KitMetadata): void {
marketplaceStore.set(metadata.kitId, metadata)
}

/** Get kit metadata from the marketplace. */
export function getKit(kitId: string): KitMetadata | undefined {
return marketplaceStore.get(kitId)
}

/** List all kits in the marketplace. */
export function listKits(): ReadonlyArray<KitMetadata> {
return Array.from(marketplaceStore.values())
}

/**
* Search for kits in the marketplace. Returns results sorted by the
* specified criteria, with optional filtering by query and tags.
*/
export function searchKits(filters: KitSearchFilters = {}): ReadonlyArray<KitSearchResult> {
let results = Array.from(marketplaceStore.values())

// Filter by query
if (filters.query) {
const q = filters.query.toLowerCase()
results = results.filter(
(k) =>
k.name.toLowerCase().includes(q) ||
k.description.toLowerCase().includes(q) ||
k.keywords.some((kw) => kw.toLowerCase().includes(q)),
)
}

// Filter by tags
if (filters.tags && filters.tags.length > 0) {
results = results.filter((k) =>
filters.tags!.some((tag) => k.keywords.includes(tag)),
)
}

// Filter by rating
if (filters.minRating !== undefined) {
results = results.filter((k) => k.rating >= filters.minRating!)
}

// Sort
const sortBy = filters.sortBy ?? "relevance"
results.sort((a, b) => {
switch (sortBy) {
case "downloads":
return b.downloads - a.downloads
case "stars":
return b.stars - a.stars
case "rating":
return b.rating - a.rating
case "updated":
return 0 // Would need timestamp field
default:
return b.rating - a.rating
}
})

// Paginate
const offset = filters.offset ?? 0
const limit = filters.limit ?? 20
results = results.slice(offset, offset + limit)

return results.map((k) => ({
kitId: k.kitId,
name: k.name,
version: k.version,
description: k.description,
rating: k.rating,
downloads: k.downloads,
stars: k.stars,
}))
}

/** Update a kit's star count. */
export function starKit(kitId: string): KitMetadata | undefined {
const kit = marketplaceStore.get(kitId)
if (!kit) return undefined
const updated = { ...kit, stars: kit.stars + 1 }
marketplaceStore.set(kitId, updated)
return updated
}

/** Update a kit's rating. */
export function rateKit(kitId: string, rating: number): KitMetadata | undefined {
const kit = marketplaceStore.get(kitId)
if (!kit) return undefined
const updated = { ...kit, rating }
marketplaceStore.set(kitId, updated)
return updated
}

/** Clear the marketplace store (for testing). */
export function clearMarketplace(): void {
marketplaceStore.clear()
}

export * as Marketplace from "./marketplace"
Loading
Loading