@cvr/repo 1.0.0

package/src/services/git.ts

@@ -0,0 +1,226 @@
+import { Context, Effect, Layer } from "effect"
+import { GitError } from "../types.js"
+
+// Service interface
+export class GitService extends Context.Tag("@repo/GitService")<
+  GitService,
+  {
+    readonly clone: (
+      url: string,
+      dest: string,
+      options?: { depth?: number; ref?: string }
+    ) => Effect.Effect<void, GitError>
+    readonly update: (path: string) => Effect.Effect<void, GitError>
+    readonly isGitRepo: (path: string) => Effect.Effect<boolean>
+    readonly getDefaultBranch: (url: string) => Effect.Effect<string, GitError>
+    readonly getCurrentRef: (path: string) => Effect.Effect<string, GitError>
+  }
+>() {
+  // Live layer using real git
+  static readonly layer = Layer.succeed(
+    GitService,
+    GitService.of({
+      clone: (url, dest, options) =>
+        Effect.gen(function* () {
+          const args = ["clone"]
+
+          if (options?.depth) {
+            args.push("--depth", String(options.depth))
+          }
+
+          if (options?.ref) {
+            args.push("--branch", options.ref)
+          }
+
+          args.push(url, dest)
+
+          const proc = Bun.spawn(["git", ...args], {
+            stdout: "pipe",
+            stderr: "pipe",
+          })
+
+          const exitCode = yield* Effect.tryPromise({
+            try: () => proc.exited,
+            catch: (cause) =>
+              new GitError({ operation: "clone", repo: url, cause }),
+          })
+
+          if (exitCode !== 0) {
+            // If ref failed, try without it (fallback to default branch)
+            if (options?.ref) {
+              const fallbackArgs = ["clone"]
+              if (options.depth) {
+                fallbackArgs.push("--depth", String(options.depth))
+              }
+              fallbackArgs.push(url, dest)
+
+              const fallbackProc = Bun.spawn(["git", ...fallbackArgs], {
+                stdout: "pipe",
+                stderr: "pipe",
+              })
+
+              const fallbackResult = yield* Effect.tryPromise({
+                try: () => fallbackProc.exited,
+                catch: (cause) =>
+                  new GitError({
+                    operation: "clone-fallback",
+                    repo: url,
+                    cause,
+                  }),
+              })
+
+              if (fallbackResult !== 0) {
+                return yield* Effect.fail(
+                  new GitError({
+                    operation: "clone",
+                    repo: url,
+                    cause: new Error(
+                      `git clone failed with exit code ${fallbackResult}`
+                    ),
+                  })
+                )
+              }
+            } else {
+              return yield* Effect.fail(
+                new GitError({
+                  operation: "clone",
+                  repo: url,
+                  cause: new Error(`git clone failed with exit code ${exitCode}`),
+                })
+              )
+            }
+          }
+        }),
+
+      update: (path) =>
+        Effect.gen(function* () {
+          // Fetch all updates
+          const fetchProc = Bun.spawn(["git", "-C", path, "fetch", "--all", "--prune"], {
+            stdout: "pipe",
+            stderr: "pipe",
+          })
+
+          const fetchExit = yield* Effect.tryPromise({
+            try: () => fetchProc.exited,
+            catch: (cause) =>
+              new GitError({ operation: "fetch", repo: path, cause }),
+          })
+
+          if (fetchExit !== 0) {
+            return yield* Effect.fail(
+              new GitError({
+                operation: "fetch",
+                repo: path,
+                cause: new Error(`git fetch failed with exit code ${fetchExit}`),
+              })
+            )
+          }
+
+          // Reset to origin/HEAD (or current branch's upstream)
+          const resetProc = Bun.spawn(
+            ["git", "-C", path, "reset", "--hard", "origin/HEAD"],
+            {
+              stdout: "pipe",
+              stderr: "pipe",
+            }
+          )
+
+          const resetExit = yield* Effect.tryPromise({
+            try: () => resetProc.exited,
+            catch: (cause) =>
+              new GitError({ operation: "reset", repo: path, cause }),
+          })
+
+          if (resetExit !== 0) {
+            // Try resetting to @{upstream} instead
+            const upstreamProc = Bun.spawn(
+              ["git", "-C", path, "reset", "--hard", "@{upstream}"],
+              {
+                stdout: "pipe",
+                stderr: "pipe",
+              }
+            )
+
+            const upstreamExit = yield* Effect.tryPromise({
+              try: () => upstreamProc.exited,
+              catch: (cause) =>
+                new GitError({ operation: "reset-upstream", repo: path, cause }),
+            })
+
+            if (upstreamExit !== 0) {
+              return yield* Effect.fail(
+                new GitError({
+                  operation: "reset",
+                  repo: path,
+                  cause: new Error(`git reset failed with exit code ${upstreamExit}`),
+                })
+              )
+            }
+          }
+        }),
+
+      isGitRepo: (path) =>
+        Effect.gen(function* () {
+          const proc = Bun.spawn(["git", "-C", path, "rev-parse", "--git-dir"], {
+            stdout: "pipe",
+            stderr: "pipe",
+          })
+
+          const exitCode = yield* Effect.promise(() => proc.exited).pipe(
+            Effect.orElseSucceed(() => 1)
+          )
+
+          return exitCode === 0
+        }),
+
+      getDefaultBranch: (url) =>
+        Effect.gen(function* () {
+          const proc = Bun.spawn(["git", "ls-remote", "--symref", url, "HEAD"], {
+            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: (cause) =>
+              new GitError({ operation: "getDefaultBranch", repo: url, cause }),
+          })
+
+          // Parse output like: ref: refs/heads/main\tHEAD
+          const match = output.match(/ref: refs\/heads\/(\S+)/)
+          if (match?.[1]) {
+            return match[1]
+          }
+          return "main" // fallback
+        }),
+
+      getCurrentRef: (path) =>
+        Effect.gen(function* () {
+          const proc = Bun.spawn(
+            ["git", "-C", path, "describe", "--tags", "--always"],
+            {
+              stdout: "pipe",
+              stderr: "pipe",
+            }
+          )
+
+          const output = yield* Effect.tryPromise({
+            try: async () => {
+              const stdout = await new Response(proc.stdout).text()
+              await proc.exited
+              return stdout.trim()
+            },
+            catch: (cause) =>
+              new GitError({ operation: "getCurrentRef", repo: path, cause }),
+          })
+
+          return output || "unknown"
+        }),
+    })
+  )
+
+}

package/src/services/metadata.ts

@@ -0,0 +1,141 @@
+import { FileSystem, Path } from "@effect/platform"
+import { Context, Effect, Layer, Option, Schema } from "effect"
+import type { PackageSpec, RepoMetadata } from "../types.js"
+import { MetadataIndex } from "../types.js"
+
+// Create encode/decode functions for proper JSON serialization
+const encodeMetadata = Schema.encodeSync(MetadataIndex)
+const decodeMetadata = Schema.decodeUnknownSync(MetadataIndex)
+
+// Service interface
+export class MetadataService extends Context.Tag("@repo/MetadataService")<
+  MetadataService,
+  {
+    readonly load: () => Effect.Effect<MetadataIndex>
+    readonly save: (index: MetadataIndex) => Effect.Effect<void>
+    readonly add: (metadata: RepoMetadata) => Effect.Effect<void>
+    readonly remove: (spec: PackageSpec) => Effect.Effect<boolean>
+    readonly find: (spec: PackageSpec) => Effect.Effect<RepoMetadata | null>
+    readonly updateAccessTime: (spec: PackageSpec) => Effect.Effect<void>
+    readonly findOlderThan: (days: number) => Effect.Effect<readonly RepoMetadata[]>
+    readonly findLargerThan: (bytes: number) => Effect.Effect<readonly RepoMetadata[]>
+    readonly all: () => Effect.Effect<readonly RepoMetadata[]>
+  }
+>() {
+  // Live layer using real filesystem
+  static readonly layer = Layer.effect(
+    MetadataService,
+    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")
+      const metadataPath = pathService.join(cacheDir, "metadata.json")
+
+      const specMatches = (a: PackageSpec, b: PackageSpec): boolean => {
+        if (a.registry !== b.registry || a.name !== b.name) return false
+        const aVersion = Option.getOrElse(a.version, () => "")
+        const bVersion = Option.getOrElse(b.version, () => "")
+        return aVersion === bVersion
+      }
+
+      const load = (): Effect.Effect<MetadataIndex> =>
+        Effect.gen(function* () {
+          const exists = yield* fs.exists(metadataPath)
+          if (!exists) {
+            return { version: 1, repos: [] }
+          }
+          const content = yield* fs.readFileString(metadataPath)
+          return decodeMetadata(JSON.parse(content))
+        }).pipe(Effect.orElse(() => Effect.succeed({ version: 1, repos: [] })))
+
+      const save = (index: MetadataIndex): Effect.Effect<void> =>
+        Effect.gen(function* () {
+          yield* fs.makeDirectory(cacheDir, { recursive: true })
+          const encoded = encodeMetadata(index)
+          yield* fs.writeFileString(metadataPath, JSON.stringify(encoded, null, 2))
+        }).pipe(Effect.ignore)
+
+      const add = (metadata: RepoMetadata): Effect.Effect<void> =>
+        Effect.gen(function* () {
+          const index = yield* load()
+          const filtered = index.repos.filter(
+            (r) => !specMatches(r.spec, metadata.spec)
+          )
+          const newIndex: MetadataIndex = {
+            ...index,
+            repos: [...filtered, metadata],
+          }
+          yield* save(newIndex)
+        })
+
+      const remove = (spec: PackageSpec): Effect.Effect<boolean> =>
+        Effect.gen(function* () {
+          const index = yield* load()
+          const originalLength = index.repos.length
+          const filtered = index.repos.filter((r) => !specMatches(r.spec, spec))
+          if (filtered.length === originalLength) {
+            return false
+          }
+          yield* save({ ...index, repos: filtered })
+          return true
+        })
+
+      const find = (spec: PackageSpec): Effect.Effect<RepoMetadata | null> =>
+        Effect.gen(function* () {
+          const index = yield* load()
+          return index.repos.find((r) => specMatches(r.spec, spec)) ?? null
+        })
+
+      const updateAccessTime = (spec: PackageSpec): Effect.Effect<void> =>
+        Effect.gen(function* () {
+          const index = yield* load()
+          const updated = index.repos.map((r) => {
+            if (specMatches(r.spec, spec)) {
+              return { ...r, lastAccessedAt: new Date().toISOString() }
+            }
+            return r
+          })
+          yield* save({ ...index, repos: updated })
+        })
+
+      const findOlderThan = (
+        days: number
+      ): Effect.Effect<readonly RepoMetadata[]> =>
+        Effect.gen(function* () {
+          const index = yield* load()
+          const cutoff = Date.now() - days * 24 * 60 * 60 * 1000
+          return index.repos.filter(
+            (r) => new Date(r.lastAccessedAt).getTime() < cutoff
+          )
+        })
+
+      const findLargerThan = (
+        bytes: number
+      ): Effect.Effect<readonly RepoMetadata[]> =>
+        Effect.gen(function* () {
+          const index = yield* load()
+          return index.repos.filter((r) => r.sizeBytes > bytes)
+        })
+
+      const all = (): Effect.Effect<readonly RepoMetadata[]> =>
+        Effect.gen(function* () {
+          const index = yield* load()
+          return index.repos
+        })
+
+      return MetadataService.of({
+        load,
+        save,
+        add,
+        remove,
+        find,
+        updateAccessTime,
+        findOlderThan,
+        findLargerThan,
+        all,
+      })
+    })
+  )
+
+}