@cvr/repo 1.0.0

package/src/test-utils/layers/registry.ts

@@ -0,0 +1,201 @@
+import { Effect, Layer, Option, Ref } from "effect"
+import { RegistryService } from "../../services/registry.js"
+import type { PackageSpec, Registry } from "../../types.js"
+import { SpecParseError } from "../../types.js"
+import { recordCall, type SequenceRef } from "../sequence.js"
+
+// ─── Mock State ───────────────────────────────────────────────────────────────
+
+export interface MockRegistryState {
+  fetchedSpecs: Map<string, PackageSpec>
+}
+
+export const defaultMockRegistryState: MockRegistryState = {
+  fetchedSpecs: new Map(),
+}
+
+// ─── Mock Implementation ──────────────────────────────────────────────────────
+
+export interface CreateMockRegistryServiceOptions {
+  initialState?: Partial<MockRegistryState>
+  sequenceRef?: SequenceRef
+}
+
+export function createMockRegistryService(options: CreateMockRegistryServiceOptions = {}): {
+  layer: Layer.Layer<RegistryService>
+  stateRef: Ref.Ref<MockRegistryState>
+  getState: () => Effect.Effect<MockRegistryState>
+} {
+  const initialState = options.initialState ?? {}
+  const sequenceRef = options.sequenceRef
+
+  const state: MockRegistryState = {
+    ...defaultMockRegistryState,
+    ...initialState,
+    fetchedSpecs: new Map(initialState.fetchedSpecs ?? []),
+  }
+  const stateRef = Ref.unsafeMake(state)
+
+  const record = (method: string, args: unknown, result?: unknown): Effect.Effect<void> =>
+    sequenceRef ? recordCall(sequenceRef, { service: "registry", method, args, result }) : Effect.void
+
+  const layer = Layer.succeed(
+    RegistryService,
+    RegistryService.of({
+      parseSpec: (input) =>
+        Effect.gen(function* () {
+          const result = parseSpecSync(input)
+          yield* record("parseSpec", { input }, result)
+          return result
+        }),
+
+      fetch: (spec, destPath, options) =>
+        Effect.gen(function* () {
+          yield* record("fetch", { spec, destPath, options })
+          yield* Ref.update(stateRef, (s) => {
+            const newFetched = new Map(s.fetchedSpecs)
+            newFetched.set(destPath, spec)
+            return { ...s, fetchedSpecs: newFetched }
+          })
+        }),
+    })
+  )
+
+  return {
+    layer,
+    stateRef,
+    getState: () => Ref.get(stateRef),
+  }
+}
+
+// ─── Spec Parsing (copied from registry.ts for test layer) ────────────────────
+
+type ParseResult = PackageSpec | { error: string }
+
+function parseGithubSpec(input: string): ParseResult {
+  const refMatch = input.match(/^([^@#]+)[@#](.+)$/)
+  if (refMatch) {
+    const [, name, ref] = refMatch
+    if (!name?.includes("/")) {
+      return { error: "GitHub spec must be owner/repo format" }
+    }
+    return {
+      registry: "github" as Registry,
+      name: name,
+      version: Option.some(ref!),
+    }
+  }
+
+  if (!input.includes("/")) {
+    return { error: "GitHub spec must be owner/repo format" }
+  }
+
+  return {
+    registry: "github" as Registry,
+    name: input,
+    version: Option.none(),
+  }
+}
+
+function parseNpmSpec(input: string): ParseResult {
+  if (input.startsWith("@")) {
+    const match = input.match(/^(@[^@]+)(?:@(.+))?$/)
+    if (!match) {
+      return { error: "Invalid scoped npm package spec" }
+    }
+    const [, name, version] = match
+    return {
+      registry: "npm" as Registry,
+      name: name!,
+      version: version ? Option.some(version) : Option.none(),
+    }
+  }
+
+  const parts = input.split("@")
+  if (parts.length > 2) {
+    return { error: "Invalid npm package spec" }
+  }
+
+  const [name, version] = parts
+  if (!name) {
+    return { error: "Package name is required" }
+  }
+
+  return {
+    registry: "npm" as Registry,
+    name,
+    version: version ? Option.some(version) : Option.none(),
+  }
+}
+
+function parsePypiSpec(input: string): ParseResult {
+  const match = input.match(/^([^@=]+)(?:[@=]=?(.+))?$/)
+  if (!match) {
+    return { error: "Invalid PyPI package spec" }
+  }
+
+  const [, name, version] = match
+  if (!name) {
+    return { error: "Package name is required" }
+  }
+
+  return {
+    registry: "pypi" as Registry,
+    name: name.trim(),
+    version: version ? Option.some(version.trim()) : Option.none(),
+  }
+}
+
+function parseCratesSpec(input: string): ParseResult {
+  const parts = input.split("@")
+  if (parts.length > 2) {
+    return { error: "Invalid crates.io spec" }
+  }
+
+  const [name, version] = parts
+  if (!name) {
+    return { error: "Crate name is required" }
+  }
+
+  return {
+    registry: "crates" as Registry,
+    name: name.trim(),
+    version: version ? Option.some(version.trim()) : Option.none(),
+  }
+}
+
+function parseSpecSync(input: string): PackageSpec {
+  const trimmed = input.trim()
+
+  let result: ParseResult
+
+  if (trimmed.startsWith("npm:")) {
+    result = parseNpmSpec(trimmed.slice(4))
+  } else if (trimmed.startsWith("pypi:") || trimmed.startsWith("pip:")) {
+    const prefix = trimmed.startsWith("pypi:") ? "pypi:" : "pip:"
+    result = parsePypiSpec(trimmed.slice(prefix.length))
+  } else if (
+    trimmed.startsWith("crates:") ||
+    trimmed.startsWith("cargo:") ||
+    trimmed.startsWith("rust:")
+  ) {
+    const prefixLen = trimmed.indexOf(":") + 1
+    result = parseCratesSpec(trimmed.slice(prefixLen))
+  } else if (trimmed.startsWith("github:")) {
+    result = parseGithubSpec(trimmed.slice(7))
+  } else if (trimmed.includes("/") && !trimmed.startsWith("@")) {
+    result = parseGithubSpec(trimmed)
+  } else {
+    result = parseNpmSpec(trimmed)
+  }
+
+  if ("error" in result) {
+    throw new SpecParseError({ input, message: result.error })
+  }
+
+  return result
+}
+
+// ─── Preset Configurations ────────────────────────────────────────────────────
+
+export const MockRegistryServiceDefault = createMockRegistryService()

package/src/test-utils/run-cli.ts

@@ -0,0 +1,157 @@
+import { Command } from "@effect/cli"
+import { BunContext } from "@effect/platform-bun"
+import { Effect, Either, Layer, Ref } from "effect"
+import { expect } from "vitest"
+
+import { fetch } from "../commands/fetch.js"
+import { list } from "../commands/list.js"
+import { search } from "../commands/search.js"
+import { remove } from "../commands/remove.js"
+import { clean } from "../commands/clean.js"
+import { prune } from "../commands/prune.js"
+import { stats } from "../commands/stats.js"
+import { open } from "../commands/open.js"
+import { path } from "../commands/path.js"
+import { info } from "../commands/info.js"
+
+import { createTestLayer, type CreateTestLayerOptions } from "./index.js"
+import type { ExpectedCall, RecordedCall } from "./sequence.js"
+
+// ─── Root Command ──────────────────────────────────────────────────────────────
+
+const rootCommand = Command.make("repo").pipe(
+  Command.withDescription("Multi-registry source code cache manager"),
+  Command.withSubcommands([fetch, list, search, remove, clean, prune, stats, open, path, info])
+)
+
+// ─── Re-export types ───────────────────────────────────────────────────────────
+
+export type { ExpectedCall } from "./sequence.js"
+
+// ─── Sequence Matching ────────────────────────────────────────────────────────
+
+function assertSequenceContains(actual: RecordedCall[], expected: ExpectedCall[]): void {
+  let actualIndex = 0
+
+  for (const exp of expected) {
+    let found = false
+
+    while (actualIndex < actual.length) {
+      const act = actual[actualIndex]!
+      actualIndex++
+
+      if (act.service === exp.service && act.method === exp.method) {
+        if (exp.match) {
+          expect(act.args).toMatchObject(exp.match)
+        }
+        found = true
+        break
+      }
+    }
+
+    if (!found) {
+      const remainingCalls = actual.slice(Math.max(0, actualIndex - 1))
+      const formattedCalls = remainingCalls.map((c) => `  ${c.service}.${c.method}`).join("\n")
+      throw new Error(
+        `Expected ${exp.service}.${exp.method} not found in sequence.\n` +
+          `Remaining calls:\n${formattedCalls || "  (none)"}\n` +
+          `Full sequence:\n${actual.map((c) => `  ${c.service}.${c.method}`).join("\n")}`
+      )
+    }
+  }
+}
+
+// ─── CLI Test Runner ──────────────────────────────────────────────────────────
+
+export class CliTestRunner {
+  constructor(
+    private args: string[],
+    private options: CreateTestLayerOptions
+  ) {}
+
+  expectSequence(expected: ExpectedCall[]): Effect.Effect<void> {
+    return Effect.gen(this, function* () {
+      const { layer, sequenceRef } = createTestLayer(this.options)
+
+      const cli = Command.run(rootCommand, { name: "repo", version: "0.0.0-test" })
+      const argv = ["bun", "repo", ...this.args]
+      const fullLayer = layer.pipe(Layer.provideMerge(BunContext.layer))
+      yield* cli(argv).pipe(Effect.provide(fullLayer), Effect.either)
+
+      const actual = yield* Ref.get(sequenceRef)
+      assertSequenceContains(actual, expected)
+    })
+  }
+
+  expectError(errorTag: string): Effect.Effect<void> {
+    return Effect.gen(this, function* () {
+      const { layer } = createTestLayer(this.options)
+
+      const cli = Command.run(rootCommand, { name: "repo", version: "0.0.0-test" })
+      const fullLayer = layer.pipe(Layer.provideMerge(BunContext.layer))
+      const result = yield* cli(["bun", "repo", ...this.args]).pipe(
+        Effect.provide(fullLayer),
+        Effect.either
+      )
+
+      expect(Either.isLeft(result)).toBe(true)
+      if (Either.isLeft(result)) {
+        const error = result.left as { _tag?: string }
+        expect(error._tag).toBe(errorTag)
+      }
+    })
+  }
+
+  expectSuccess(): Effect.Effect<void> {
+    return this.expectSequence([])
+  }
+
+  getSequence(): Effect.Effect<RecordedCall[]> {
+    return Effect.gen(this, function* () {
+      const { layer, sequenceRef } = createTestLayer(this.options)
+
+      const cli = Command.run(rootCommand, { name: "repo", version: "0.0.0-test" })
+      const fullLayer = layer.pipe(Layer.provideMerge(BunContext.layer))
+      yield* cli(["bun", "repo", ...this.args]).pipe(
+        Effect.provide(fullLayer),
+        Effect.either
+      )
+
+      return yield* Ref.get(sequenceRef)
+    })
+  }
+}
+
+// ─── Main API ─────────────────────────────────────────────────────────────────
+
+/**
+ * Creates a CLI test runner with the given arguments and options.
+ *
+ * IMPORTANT: Due to @effect/cli parser behavior, options with space-separated values
+ * must come BEFORE positional arguments. Alternatively, use equals syntax (--option=value).
+ *
+ * @example
+ * ```ts
+ * // CORRECT: options before positional arg
+ * runCli('fetch -f vercel/next.js', {...})
+ *
+ * // CORRECT: equals syntax
+ * runCli('fetch vercel/next.js --force', {...})
+ *
+ * // Full example:
+ * it.effect('fetches a GitHub repo', () =>
+ *   runCli('fetch vercel/next.js', {
+ *     cache: { cacheDir: '/tmp/test' },
+ *   }).expectSequence([
+ *     { service: 'registry', method: 'parseSpec' },
+ *     { service: 'cache', method: 'getPath' },
+ *     { service: 'cache', method: 'exists' },
+ *     { service: 'git', method: 'clone' },
+ *     { service: 'metadata', method: 'add' },
+ *   ])
+ * );
+ * ```
+ */
+export function runCli(args: string, options: CreateTestLayerOptions = {}): CliTestRunner {
+  return new CliTestRunner(args.split(/\s+/), options)
+}

package/src/test-utils/sequence.ts

@@ -0,0 +1,57 @@
+import { Effect, Ref } from "effect"
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+/**
+ * A recorded call to a mock service method.
+ * Used for sequence-based test assertions.
+ */
+export interface RecordedCall {
+  /** Service name (e.g., 'git', 'cache', 'registry') */
+  service: string
+  /** Method name (e.g., 'clone', 'getPath', 'parseSpec') */
+  method: string
+  /** Arguments passed to the method */
+  args: unknown
+  /** Return value (optional, for debugging) */
+  result?: unknown
+}
+
+/**
+ * Expected call for sequence matching.
+ * Uses partial matching - only specified fields are checked.
+ */
+export interface ExpectedCall {
+  service: string
+  method: string
+  /** Partial match on args - uses expect().toMatchObject() */
+  match?: Record<string, unknown>
+}
+
+// ─── Sequence Ref ─────────────────────────────────────────────────────────────
+
+export type SequenceRef = Ref.Ref<RecordedCall[]>
+
+/**
+ * Create a new sequence ref for recording calls.
+ */
+export function createSequenceRef(): SequenceRef {
+  return Ref.unsafeMake<RecordedCall[]>([])
+}
+
+/**
+ * Record a call to the sequence.
+ */
+export function recordCall(
+  sequenceRef: SequenceRef,
+  call: Omit<RecordedCall, "result"> & { result?: unknown }
+): Effect.Effect<void> {
+  return Ref.update(sequenceRef, (seq) => [...seq, call])
+}
+
+/**
+ * Get all recorded calls.
+ */
+export function getSequence(sequenceRef: SequenceRef): Effect.Effect<RecordedCall[]> {
+  return Ref.get(sequenceRef)
+}

package/src/types.ts

@@ -0,0 +1,101 @@
+import { Data, Schema } from "effect"
+
+// Registry types
+export type Registry = "github" | "npm" | "pypi" | "crates"
+
+// Package spec - identifies a package/repo across registries
+export const PackageSpec = Schema.Struct({
+  registry: Schema.Literal("github", "npm", "pypi", "crates"),
+  name: Schema.String,
+  version: Schema.optionalWith(Schema.String, { as: "Option" }),
+})
+export type PackageSpec = typeof PackageSpec.Type
+
+// Metadata stored per-cached entry
+export const RepoMetadata = Schema.Struct({
+  spec: PackageSpec,
+  fetchedAt: Schema.String,
+  lastAccessedAt: Schema.String,
+  sizeBytes: Schema.Number,
+  path: Schema.String,
+})
+export type RepoMetadata = typeof RepoMetadata.Type
+
+// Global metadata index
+export const MetadataIndex = Schema.Struct({
+  version: Schema.Number,
+  repos: Schema.Array(RepoMetadata),
+})
+export type MetadataIndex = typeof MetadataIndex.Type
+
+// Tagged Errors
+export class SpecParseError extends Data.TaggedError("SpecParseError")<{
+  readonly input: string
+  readonly message: string
+}> {}
+
+export class RegistryError extends Data.TaggedError("RegistryError")<{
+  readonly registry: Registry
+  readonly operation: string
+  readonly cause: unknown
+}> {}
+
+export class GitError extends Data.TaggedError("GitError")<{
+  readonly operation: string
+  readonly repo: string
+  readonly cause: unknown
+}> {}
+
+export class CacheError extends Data.TaggedError("CacheError")<{
+  readonly operation: string
+  readonly path: string
+  readonly cause: unknown
+}> {}
+
+export class MetadataError extends Data.TaggedError("MetadataError")<{
+  readonly operation: string
+  readonly cause: unknown
+}> {}
+
+export class NotFoundError extends Data.TaggedError("NotFoundError")<{
+  readonly spec: PackageSpec
+}> {}
+
+export class NetworkError extends Data.TaggedError("NetworkError")<{
+  readonly url: string
+  readonly cause: unknown
+}> {}
+
+export class OpenError extends Data.TaggedError("OpenError")<{
+  readonly command: string
+  readonly cause: unknown
+}> {}
+
+// Utility to format bytes
+export const formatBytes = (bytes: number): string => {
+  if (bytes < 1024) return `${bytes} B`
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`
+}
+
+// Utility to format relative time
+export const formatRelativeTime = (date: Date): string => {
+  const now = new Date()
+  const diffMs = now.getTime() - date.getTime()
+  const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24))
+
+  if (diffDays === 0) return "today"
+  if (diffDays === 1) return "yesterday"
+  if (diffDays < 7) return `${diffDays} days ago`
+  if (diffDays < 30) return `${Math.floor(diffDays / 7)} weeks ago`
+  if (diffDays < 365) return `${Math.floor(diffDays / 30)} months ago`
+  return `${Math.floor(diffDays / 365)} years ago`
+}
+
+// Spec display helper
+export const specToString = (spec: PackageSpec): string => {
+  const prefix = spec.registry === "github" ? "" : `${spec.registry}:`
+  const version = spec.version._tag === "Some" ? `@${spec.version.value}` : ""
+  return `${prefix}${spec.name}${version}`
+}

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "preserve",
+    "moduleResolution": "bundler",
+    "moduleDetection": "force",
+    "strict": true,
+    "exactOptionalPropertyTypes": true,
+    "noUnusedLocals": true,
+    "noImplicitOverride": true,
+    "noUncheckedIndexedAccess": true,
+    "verbatimModuleSyntax": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "noEmit": true,
+    "types": ["bun-types"],
+    "plugins": [{ "name": "@effect/language-service" }]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}