@cvr/repo 1.0.0

package/src/commands/prune.ts

@@ -0,0 +1,112 @@
+import { Command, Options } from "@effect/cli"
+import { Console, Effect, Option } from "effect"
+import { formatBytes, specToString } from "../types.js"
+import { CacheService } from "../services/cache.js"
+import { MetadataService } from "../services/metadata.js"
+
+const daysOption = Options.integer("days").pipe(
+  Options.withAlias("d"),
+  Options.optional,
+  Options.withDescription("Remove repos not accessed in N days")
+)
+
+const maxSizeOption = Options.text("max-size").pipe(
+  Options.optional,
+  Options.withDescription("Remove repos larger than size (e.g., 100M, 1G)")
+)
+
+const dryRunOption = Options.boolean("dry-run").pipe(
+  Options.withDefault(false),
+  Options.withDescription("Show what would be removed without actually removing")
+)
+
+function parseSize(sizeStr: string): number | null {
+  const match = sizeStr.match(/^(\d+(?:\.\d+)?)\s*(B|K|KB|M|MB|G|GB)?$/i)
+  if (!match) return null
+
+  const value = parseFloat(match[1]!)
+  const unit = (match[2] ?? "B").toUpperCase()
+
+  switch (unit) {
+    case "B":
+      return value
+    case "K":
+    case "KB":
+      return value * 1024
+    case "M":
+    case "MB":
+      return value * 1024 * 1024
+    case "G":
+    case "GB":
+      return value * 1024 * 1024 * 1024
+    default:
+      return null
+  }
+}
+
+export const prune = Command.make(
+  "prune",
+  { days: daysOption, maxSize: maxSizeOption, dryRun: dryRunOption },
+  ({ days, maxSize, dryRun }) =>
+    Effect.gen(function* () {
+      const cache = yield* CacheService
+      const metadata = yield* MetadataService
+
+      if (Option.isNone(days) && Option.isNone(maxSize)) {
+        yield* Console.log("Specify at least one of: --days or --max-size")
+        return
+      }
+
+      let toRemove = yield* metadata.all()
+
+      // Filter by age
+      if (Option.isSome(days)) {
+        const cutoff = Date.now() - days.value * 24 * 60 * 60 * 1000
+        toRemove = toRemove.filter(
+          (r) => new Date(r.lastAccessedAt).getTime() < cutoff
+        )
+      }
+
+      // Filter by size
+      if (Option.isSome(maxSize)) {
+        const maxBytes = parseSize(maxSize.value)
+        if (maxBytes === null) {
+          yield* Console.log(`Invalid size format: ${maxSize.value}`)
+          yield* Console.log("Use formats like: 100M, 1G, 500KB")
+          return
+        }
+        toRemove = toRemove.filter((r) => r.sizeBytes > maxBytes)
+      }
+
+      if (toRemove.length === 0) {
+        yield* Console.log("No repositories match the prune criteria.")
+        return
+      }
+
+      const totalSize = toRemove.reduce((sum, r) => sum + r.sizeBytes, 0)
+
+      if (dryRun) {
+        yield* Console.log(`Would remove ${toRemove.length} repositories:`)
+        yield* Console.log("")
+        for (const repo of toRemove) {
+          yield* Console.log(
+            `  ${specToString(repo.spec).padEnd(40)}  ${formatBytes(repo.sizeBytes)}`
+          )
+        }
+        yield* Console.log("")
+        yield* Console.log(`Total: ${formatBytes(totalSize)}`)
+        return
+      }
+
+      // Actually remove
+      for (const repo of toRemove) {
+        yield* cache.remove(repo.path)
+        yield* metadata.remove(repo.spec)
+        yield* Console.log(`Removed: ${specToString(repo.spec)}`)
+      }
+
+      yield* Console.log("")
+      yield* Console.log(`Removed ${toRemove.length} repositories.`)
+      yield* Console.log(`Freed: ${formatBytes(totalSize)}`)
+    })
+)

package/src/commands/remove.ts

@@ -0,0 +1,41 @@
+import { Args, Command } from "@effect/cli"
+import { Console, Effect } from "effect"
+import { specToString, formatBytes } from "../types.js"
+import { CacheService } from "../services/cache.js"
+import { MetadataService } from "../services/metadata.js"
+import { RegistryService } from "../services/registry.js"
+
+const specArg = Args.text({ name: "spec" }).pipe(
+  Args.withDescription("Package spec to remove")
+)
+
+export const remove = Command.make("remove", { spec: specArg }, ({ spec }) =>
+  Effect.gen(function* () {
+    const registry = yield* RegistryService
+    const cache = yield* CacheService
+    const metadata = yield* MetadataService
+
+    // Parse the spec
+    const parsedSpec = yield* registry.parseSpec(spec)
+
+    // Find in metadata
+    const existing = yield* metadata.find(parsedSpec)
+    if (!existing) {
+      yield* Console.log(`Not found: ${specToString(parsedSpec)}`)
+      return
+    }
+
+    // Remove from cache
+    yield* cache.remove(existing.path)
+
+    // Remove from metadata
+    yield* metadata.remove(parsedSpec)
+
+    yield* Console.log(`Removed: ${specToString(parsedSpec)}`)
+    yield* Console.log(`Freed: ${formatBytes(existing.sizeBytes)}`)
+  }).pipe(
+    Effect.catchAll((error) =>
+      Console.error(`Error: ${error._tag}: ${JSON.stringify(error)}`)
+    )
+  )
+)

package/src/commands/search.ts

@@ -0,0 +1,102 @@
+import { Args, Command, Options } from "@effect/cli"
+import { Console, Effect, Option } from "effect"
+import { MetadataService } from "../services/metadata.js"
+
+const queryArg = Args.text({ name: "query" }).pipe(
+  Args.withDescription("Search pattern (regex supported)")
+)
+
+const registryOption = Options.choice("registry", [
+  "github",
+  "npm",
+  "pypi",
+  "crates",
+] as const).pipe(
+  Options.withAlias("r"),
+  Options.optional,
+  Options.withDescription("Filter by registry")
+)
+
+const typeOption = Options.text("type").pipe(
+  Options.withAlias("t"),
+  Options.optional,
+  Options.withDescription("File type filter (e.g., ts, py, rs)")
+)
+
+const contextOption = Options.integer("context").pipe(
+  Options.withDefault(2),
+  Options.withDescription("Lines of context around matches")
+)
+
+export const search = Command.make(
+  "search",
+  {
+    query: queryArg,
+    registry: registryOption,
+    type: typeOption,
+    context: contextOption,
+  },
+  ({ query, registry, type, context }) =>
+    Effect.gen(function* () {
+      const metadata = yield* MetadataService
+      let repos = yield* metadata.all()
+
+      // Filter by registry if specified
+      if (Option.isSome(registry)) {
+        repos = repos.filter((r) => r.spec.registry === registry.value)
+      }
+
+      if (repos.length === 0) {
+        yield* Console.log("No repositories cached.")
+        return
+      }
+
+      // Build ripgrep command
+      const paths = repos.map((r) => r.path)
+      const args = ["--color=always", "-n", `-C${context}`]
+
+      if (Option.isSome(type)) {
+        args.push(`--type=${type.value}`)
+      }
+
+      args.push(query, ...paths)
+
+      yield* Console.log(
+        `Searching ${repos.length} repositories for: ${query}`
+      )
+      yield* Console.log("")
+
+      // Run ripgrep
+      const proc = Bun.spawn(["rg", ...args], {
+        stdout: "pipe",
+        stderr: "pipe",
+      })
+
+      const output = yield* Effect.tryPromise({
+        try: async () => {
+          const stdout = await new Response(proc.stdout).text()
+          await proc.exited
+          return stdout
+        },
+        catch: () => "", // ripgrep returns non-zero when no matches
+      })
+
+      if (output.trim()) {
+        yield* Console.log(output)
+      } else {
+        yield* Console.log("No matches found.")
+      }
+    }).pipe(
+      Effect.catchAll((error) =>
+        Effect.gen(function* () {
+          if (typeof error === "object" && error !== null && "_tag" in error) {
+            yield* Console.error(
+              `Error: ${(error as { _tag: string })._tag}: ${JSON.stringify(error)}`
+            )
+          } else {
+            yield* Console.error(`Error: ${String(error)}`)
+          }
+        })
+      )
+    )
+)

package/src/commands/stats.ts

@@ -0,0 +1,100 @@
+import { Command, Options } from "@effect/cli"
+import { Console, Effect } from "effect"
+import { formatBytes, type Registry } from "../types.js"
+import { MetadataService } from "../services/metadata.js"
+import { CacheService } from "../services/cache.js"
+
+const jsonOption = Options.boolean("json").pipe(
+  Options.withDefault(false),
+  Options.withDescription("Output as JSON")
+)
+
+export const stats = Command.make("stats", { json: jsonOption }, ({ json }) =>
+  Effect.gen(function* () {
+    const metadata = yield* MetadataService
+    const cache = yield* CacheService
+
+    const repos = yield* metadata.all()
+
+    // Group by registry
+    const byRegistry: Record<Registry, { count: number; size: number }> = {
+      github: { count: 0, size: 0 },
+      npm: { count: 0, size: 0 },
+      pypi: { count: 0, size: 0 },
+      crates: { count: 0, size: 0 },
+    }
+
+    for (const repo of repos) {
+      byRegistry[repo.spec.registry].count++
+      byRegistry[repo.spec.registry].size += repo.sizeBytes
+    }
+
+    const totalCount = repos.length
+    const totalSize = repos.reduce((sum, r) => sum + r.sizeBytes, 0)
+
+    // Find oldest and newest
+    const sorted = [...repos].sort(
+      (a, b) =>
+        new Date(a.lastAccessedAt).getTime() -
+        new Date(b.lastAccessedAt).getTime()
+    )
+    const oldest = sorted[0]
+    const newest = sorted[sorted.length - 1]
+
+    if (json) {
+      yield* Console.log(
+        JSON.stringify(
+          {
+            cacheDir: cache.cacheDir,
+            totalCount,
+            totalSize,
+            byRegistry,
+            oldest: oldest
+              ? {
+                  name: oldest.spec.name,
+                  lastAccessed: oldest.lastAccessedAt,
+                }
+              : null,
+            newest: newest
+              ? {
+                  name: newest.spec.name,
+                  lastAccessed: newest.lastAccessedAt,
+                }
+              : null,
+          },
+          null,
+          2
+        )
+      )
+      return
+    }
+
+    yield* Console.log("")
+    yield* Console.log("Cache Statistics")
+    yield* Console.log("═".repeat(50))
+    yield* Console.log(`Cache directory: ${cache.cacheDir}`)
+    yield* Console.log("")
+
+    yield* Console.log("By Registry:")
+    yield* Console.log("─".repeat(50))
+    for (const [registry, data] of Object.entries(byRegistry)) {
+      if (data.count > 0) {
+        yield* Console.log(
+          `  ${registry.padEnd(10)} ${String(data.count).padStart(5)} repos  ${formatBytes(data.size).padStart(10)}`
+        )
+      }
+    }
+    yield* Console.log("─".repeat(50))
+    yield* Console.log(
+      `  ${"Total".padEnd(10)} ${String(totalCount).padStart(5)} repos  ${formatBytes(totalSize).padStart(10)}`
+    )
+
+    if (oldest) {
+      yield* Console.log("")
+      yield* Console.log(`Oldest: ${oldest.spec.name} (${oldest.lastAccessedAt})`)
+    }
+    if (newest) {
+      yield* Console.log(`Newest: ${newest.spec.name} (${newest.lastAccessedAt})`)
+    }
+  })
+)

package/src/main.ts

@@ -0,0 +1,77 @@
+#!/usr/bin/env bun
+import { Command } from "@effect/cli"
+import { BunContext, BunRuntime } from "@effect/platform-bun"
+import { Effect, Layer } from "effect"
+
+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 { CacheService } from "./services/cache.js"
+import { MetadataService } from "./services/metadata.js"
+import { GitService } from "./services/git.js"
+import { RegistryService } from "./services/registry.js"
+
+// Layer composition:
+// 1. CacheService.layer and MetadataService.layer need FileSystem+Path (from BunContext)
+// 2. GitService.layer is standalone (no deps)
+// 3. RegistryService.layer needs GitService + CacheService
+
+// First, provide BunContext to the platform-dependent services
+const PlatformServicesLayer = Layer.mergeAll(
+  CacheService.layer,
+  MetadataService.layer
+).pipe(Layer.provide(BunContext.layer))
+
+// GitService is standalone
+const GitLayer = GitService.layer
+
+// RegistryService needs Git and Cache
+const RegistryLayer = RegistryService.layer.pipe(
+  Layer.provide(GitLayer),
+  Layer.provide(PlatformServicesLayer)
+)
+
+// All services together, merged with BunContext for CLI
+const MainLayer = Layer.mergeAll(
+  PlatformServicesLayer,
+  GitLayer,
+  RegistryLayer,
+  BunContext.layer
+)
+
+// Root command
+const repo = Command.make("repo").pipe(
+  Command.withDescription("Multi-registry source code cache manager"),
+  Command.withSubcommands([
+    fetch,
+    list,
+    search,
+    remove,
+    clean,
+    prune,
+    stats,
+    open,
+    path,
+    info,
+  ])
+)
+
+// CLI runner
+const cli = Command.run(repo, {
+  name: "repo",
+  version: "1.0.0",
+})
+
+// Run with all services
+cli(process.argv).pipe(
+  Effect.provide(MainLayer),
+  BunRuntime.runMain
+)

package/src/services/cache.ts

@@ -0,0 +1,109 @@
+import { FileSystem, Path } from "@effect/platform"
+import { Context, Effect, Layer, Option } from "effect"
+import type { PackageSpec } from "../types.js"
+
+// Service interface
+export class CacheService extends Context.Tag("@repo/CacheService")<
+  CacheService,
+  {
+    readonly cacheDir: string
+    readonly getPath: (spec: PackageSpec) => Effect.Effect<string>
+    readonly exists: (spec: PackageSpec) => Effect.Effect<boolean>
+    readonly remove: (path: string) => Effect.Effect<void>
+    readonly removeAll: () => Effect.Effect<void>
+    readonly getSize: (path: string) => Effect.Effect<number>
+    readonly ensureDir: (path: string) => Effect.Effect<void>
+  }
+>() {
+  // Live layer using real filesystem
+  static readonly layer = Layer.effect(
+    CacheService,
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem
+      const pathService = yield* Path.Path
+      const home = process.env.HOME ?? "~"
+      const cacheDir = pathService.join(home, ".cache", "repo")
+
+      // Ensure cache root exists
+      yield* fs.makeDirectory(cacheDir, { recursive: true }).pipe(Effect.ignore)
+
+      const getPath = (spec: PackageSpec) =>
+        Effect.sync(() => {
+          // All repos stored as: ~/.cache/repo/{name}[@version]
+          // GitHub: owner/repo -> ~/.cache/repo/owner/repo
+          // npm: package@version -> ~/.cache/repo/package/version (or package/default)
+          // pypi/crates: same pattern
+          const version = Option.getOrElse(spec.version, () => "default")
+          switch (spec.registry) {
+            case "github":
+              // GitHub repos don't have versions in path (use git refs)
+              return pathService.join(cacheDir, spec.name)
+            case "npm":
+            case "pypi":
+            case "crates":
+              // Package registries include version in path
+              return pathService.join(cacheDir, spec.name, version)
+          }
+        })
+
+      const exists = (spec: PackageSpec) =>
+        Effect.gen(function* () {
+          const path = yield* getPath(spec)
+          return yield* fs.exists(path)
+        }).pipe(Effect.orElse(() => Effect.succeed(false)))
+
+      const remove = (path: string) =>
+        Effect.gen(function* () {
+          const pathExists = yield* fs.exists(path)
+          if (pathExists) {
+            yield* fs.remove(path, { recursive: true })
+          }
+        }).pipe(Effect.ignore)
+
+      const removeAll = () =>
+        Effect.gen(function* () {
+          const pathExists = yield* fs.exists(cacheDir)
+          if (pathExists) {
+            yield* fs.remove(cacheDir, { recursive: true })
+            yield* fs.makeDirectory(cacheDir, { recursive: true })
+          }
+        }).pipe(Effect.ignore)
+
+      const getSize = (path: string): Effect.Effect<number> =>
+        Effect.gen(function* () {
+          const pathExists = yield* fs.exists(path)
+          if (!pathExists) return 0
+
+          const calculateSize = (dir: string): Effect.Effect<number> =>
+            Effect.gen(function* () {
+              const stat = yield* fs.stat(dir)
+
+              if (stat.type === "Directory") {
+                const entries = yield* fs.readDirectory(dir)
+                const sizes = yield* Effect.forEach(entries, (entry) =>
+                  calculateSize(pathService.join(dir, entry))
+                )
+                return sizes.reduce((a, b) => a + b, 0)
+              }
+              return Number(stat.size)
+            }).pipe(Effect.orElse(() => Effect.succeed(0)))
+
+          return yield* calculateSize(path)
+        }).pipe(Effect.orElse(() => Effect.succeed(0)))
+
+      const ensureDir = (path: string) =>
+        fs.makeDirectory(path, { recursive: true }).pipe(Effect.ignore)
+
+      return CacheService.of({
+        cacheDir,
+        getPath,
+        exists,
+        remove,
+        removeAll,
+        getSize,
+        ensureDir,
+      })
+    })
+  )
+
+}