@cvr/repo 1.1.1 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cvr/repo",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/cevr/repo.git"

package/src/commands/fetch.ts

@@ -19,12 +19,6 @@ const forceOption = Options.boolean("force").pipe(
   Options.withDescription("Force re-clone (removes existing and clones fresh)"),
 );
 
-const updateOption = Options.boolean("update").pipe(
-  Options.withAlias("u"),
-  Options.withDefault(false),
-  Options.withDescription("Update existing repo (git pull)"),
-);
-
 const fullHistoryOption = Options.boolean("full").pipe(
   Options.withDefault(false),
   Options.withDescription("Clone full git history (default: shallow clone with depth 100)"),
@@ -32,8 +26,8 @@ const fullHistoryOption = Options.boolean("full").pipe(
 
 export const fetch = Command.make(
   "fetch",
-  { spec: specArg, force: forceOption, update: updateOption, full: fullHistoryOption },
-  ({ spec, force, update, full }) =>
+  { spec: specArg, force: forceOption, full: fullHistoryOption },
+  ({ spec, force, full }) =>
     Effect.gen(function* () {
       const registry = yield* RegistryService;
       const cache = yield* CacheService;
@@ -56,52 +50,40 @@ export const fetch = Command.make(
           yield* Console.log(`Force re-fetching ${specStr}...`);
           yield* cache.remove(existing.path);
           yield* metadata.remove(parsedSpec);
-        } else if (update) {
-          // Explicit update requested
-          if (isGit) {
-            yield* Console.log(`Updating ${specStr}...`);
-            yield* git
-              .update(existing.path)
-              .pipe(
-                Effect.catchAll((e) =>
-                  Console.log(`Update failed, repo may be up to date: ${e._tag}`),
-                ),
-              );
-
-            // Recalculate size after update
-            const sizeBytes = yield* cache.getSize(existing.path);
-            const currentRef = yield* git
-              .getCurrentRef(existing.path)
-              .pipe(Effect.orElseSucceed(() => "unknown"));
-
-            yield* metadata.add({
-              spec: parsedSpec,
-              fetchedAt: existing.fetchedAt,
-              lastAccessedAt: new Date().toISOString(),
-              sizeBytes,
-              path: existing.path,
-            });
-
-            yield* Console.log(`Updated: ${existing.path}`);
-            yield* Console.log(`Current ref: ${currentRef}`);
-            yield* Console.log(`Size: ${formatBytes(sizeBytes)}`);
-            return;
-          } else {
-            // Not a git repo, can't update
-            yield* metadata.updateAccessTime(parsedSpec);
-            yield* Console.log(`Already cached at: ${existing.path}`);
-            yield* Console.log(`Size: ${formatBytes(existing.sizeBytes)}`);
-            yield* Console.log(`(Not a git repo - use --force to re-fetch)`);
-            return;
-          }
+        } else if (isGit) {
+          // Git repo: always pull latest
+          yield* Console.log(`Updating ${specStr}...`);
+          yield* git
+            .update(existing.path)
+            .pipe(
+              Effect.catchAll((e) =>
+                Console.log(`Update failed, repo may be up to date: ${e._tag}`),
+              ),
+            );
+
+          // Recalculate size after update
+          const sizeBytes = yield* cache.getSize(existing.path);
+          const currentRef = yield* git
+            .getCurrentRef(existing.path)
+            .pipe(Effect.orElseSucceed(() => "unknown"));
+
+          yield* metadata.add({
+            spec: parsedSpec,
+            fetchedAt: existing.fetchedAt,
+            lastAccessedAt: new Date().toISOString(),
+            sizeBytes,
+            path: existing.path,
+          });
+
+          yield* Console.log(`Updated: ${existing.path}`);
+          yield* Console.log(`Current ref: ${currentRef}`);
+          yield* Console.log(`Size: ${formatBytes(sizeBytes)}`);
+          return;
         } else {
-          // Already cached, just update access time
+          // Not a git repo, can't update
           yield* metadata.updateAccessTime(parsedSpec);
           yield* Console.log(`Already cached at: ${existing.path}`);
           yield* Console.log(`Size: ${formatBytes(existing.sizeBytes)}`);
-          if (isGit) {
-            yield* Console.log(`Use --update to pull latest changes`);
-          }
           yield* Console.log(`Use --force to re-fetch from scratch`);
           return;
         }

package/src/commands/path.ts

@@ -3,6 +3,7 @@ import { Console, Effect } from "effect";
 import { NotFoundError, specToString } from "../types.js";
 import { MetadataService } from "../services/metadata.js";
 import { RegistryService } from "../services/registry.js";
+import { GitService } from "../services/git.js";
 
 const specArg = Args.text({ name: "spec" }).pipe(
   Args.withDescription("Package spec to get path for"),
@@ -18,6 +19,7 @@ export const path = Command.make("path", { spec: specArg, quiet: quietOption },
   Effect.gen(function* () {
     const registry = yield* RegistryService;
     const metadata = yield* MetadataService;
+    const git = yield* GitService;
 
     const parsedSpec = yield* registry.parseSpec(spec);
     const existing = yield* metadata.find(parsedSpec);
@@ -31,5 +33,15 @@ export const path = Command.make("path", { spec: specArg, quiet: quietOption },
     }
 
     yield* Console.log(existing.path);
+    yield* metadata.updateAccessTime(parsedSpec);
+
+    // Background refresh for git repos — fire-and-forget so we don't block the caller
+    const isGit = yield* git.isGitRepo(existing.path);
+    if (isGit) {
+      yield* git.fetchRefs(existing.path).pipe(
+        Effect.catchAll(() => Effect.void),
+        Effect.fork,
+      );
+    }
   }).pipe(Effect.catchAll(() => Effect.void)),
 );

package/src/services/git.ts

@@ -11,6 +11,7 @@ export class GitService extends Context.Tag("@cvr/repo/services/git/GitService")
       options?: { depth?: number; ref?: string },
     ) => Effect.Effect<void, GitError>;
     readonly update: (path: string) => Effect.Effect<void, GitError>;
+    readonly fetchRefs: (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>;
@@ -85,6 +86,27 @@ export class GitService extends Context.Tag("@cvr/repo/services/git/GitService")
           }
         }),
 
+      fetchRefs: (path) =>
+        Effect.gen(function* () {
+          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* new GitError({
+              operation: "fetch",
+              repo: path,
+              cause: new Error(`git fetch failed with exit code ${fetchExit}`),
+            });
+          }
+        }),
+
       update: (path) =>
         Effect.gen(function* () {
           // Fetch all updates

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

@@ -70,6 +70,8 @@ export function createMockGitService(options: CreateMockGitServiceOptions = {}):
           }));
         }),
 
+      fetchRefs: (path) => record("fetchRefs", { path }),
+
       isGitRepo: (path) =>
         Effect.gen(function* () {
           const s = yield* Ref.get(stateRef);