Clarify pending sync completion names

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: huntercaron

packages/code-link-cli/src/controller.ts

@@ -26,7 +26,7 @@ import {
 import { tryGitInit } from "./helpers/git.ts"
 import { Installer } from "./helpers/installer.ts"
 import { initWatcher } from "./helpers/watcher.ts"
-import { type ConflictPromptChange, type PendingSyncCompleteResult, SyncRuntime } from "./runtime.ts"
+import { type ConflictPromptChange, SyncRuntime } from "./runtime.ts"
 import type { Effect, SyncEvent, SyncState, WriteEchoPolicy } from "./sync-events.ts"
 import type { Config, Conflict, FileInfo } from "./types.ts"
 import {
@@ -805,7 +805,7 @@ async function applyConflictChange(change: ConflictPromptChange, ctx: ApplyCtx):
 async function applySyncComplete(effect: Extract<Effect, { type: "SYNC_COMPLETE" }>, ctx: ApplyCtx): Promise<void> {
     const { config, runtime, syncState, shutdown } = ctx
     if (runtime.hasAnyActivePrompt()) {
-        runtime.addPendingSyncComplete({
+        runtime.deferSyncComplete({
             totalCount: effect.totalCount,
             updatedCount: effect.updatedCount,
             unchangedCount: effect.unchangedCount,
@@ -841,12 +841,12 @@ async function applySyncComplete(effect: Extract<Effect, { type: "SYNC_COMPLETE"
     if (shouldShutdown) await shutdown()
 }
 
-async function flushPendingSyncComplete(ctx: ApplyCtx): Promise<PendingSyncCompleteResult["is"]> {
-    const result = ctx.runtime.checkPendingSyncComplete()
-    if (result.is === "ready") {
+async function flushPendingSyncComplete(ctx: ApplyCtx): Promise<"ready" | "blocked" | "empty"> {
+    const result = ctx.runtime.claimPendingSyncComplete()
+    if (result.status === "ready") {
         await applySyncComplete({ type: "SYNC_COMPLETE", ...result.payload }, ctx)
     }
-    return result.is
+    return result.status
 }
 
 export async function applyEffect(effect: Effect, ctx: ApplyCtx): Promise<SyncEvent[]> {

packages/code-link-cli/src/runtime.test.ts

@@ -123,19 +123,19 @@ describe("SyncRuntime pending sync-complete", () => {
     it("returns empty when no sync-complete is pending", () => {
         const runtime = new SyncRuntime()
 
-        expect(runtime.checkPendingSyncComplete()).toEqual({ is: "empty" })
+        expect(runtime.claimPendingSyncComplete()).toEqual({ status: "empty" })
     })
 
     it("merges pending sync-complete payloads and clears them when ready", () => {
         const runtime = new SyncRuntime()
-        runtime.addPendingSyncComplete({ totalCount: 1, updatedCount: 1, unchangedCount: 0 })
-        runtime.addPendingSyncComplete({ totalCount: 2, updatedCount: 1, unchangedCount: 1 })
+        runtime.deferSyncComplete({ totalCount: 1, updatedCount: 1, unchangedCount: 0 })
+        runtime.deferSyncComplete({ totalCount: 2, updatedCount: 1, unchangedCount: 1 })
 
-        expect(runtime.checkPendingSyncComplete()).toEqual({
-            is: "ready",
+        expect(runtime.claimPendingSyncComplete()).toEqual({
+            status: "ready",
             payload: { totalCount: 3, updatedCount: 2, unchangedCount: 1 },
         })
-        expect(runtime.checkPendingSyncComplete()).toEqual({ is: "empty" })
+        expect(runtime.claimPendingSyncComplete()).toEqual({ status: "empty" })
     })
 
     it("keeps pending sync-complete blocked while prompts are active", () => {
@@ -144,12 +144,12 @@ describe("SyncRuntime pending sync-complete", () => {
         const prompt = runtime.startDeletePrompt(["A.tsx"])
         if (!prompt) throw new Error("Expected delete prompt")
 
-        runtime.addPendingSyncComplete({ totalCount: 1, updatedCount: 1, unchangedCount: 0 })
+        runtime.deferSyncComplete({ totalCount: 1, updatedCount: 1, unchangedCount: 0 })
 
-        expect(runtime.checkPendingSyncComplete()).toEqual({ is: "blocked" })
+        expect(runtime.claimPendingSyncComplete()).toEqual({ status: "blocked" })
         runtime.clearDeletePromptFiles(prompt.session, ["A.tsx"])
-        expect(runtime.checkPendingSyncComplete()).toEqual({
-            is: "ready",
+        expect(runtime.claimPendingSyncComplete()).toEqual({
+            status: "ready",
             payload: { totalCount: 1, updatedCount: 1, unchangedCount: 0 },
         })
     })

packages/code-link-cli/src/runtime.ts

@@ -23,16 +23,16 @@ interface DeletePromptState {
     fileNames: Set<string>
 }
 
-interface DeferredSyncComplete {
+export interface PendingSyncCompletionEvent {
     totalCount: number
     updatedCount: number
     unchangedCount: number
 }
 
-export type PendingSyncCompleteResult =
-    | { is: "ready"; payload: DeferredSyncComplete }
-    | { is: "blocked" }
-    | { is: "empty" }
+type ClaimPendingSyncCompleteResult =
+    | { status: "ready"; payload: PendingSyncCompletionEvent }
+    | { status: "blocked" }
+    | { status: "empty" }
 
 interface ConflictPromptState {
     session: PromptSession
@@ -99,7 +99,7 @@ export class SyncRuntime {
 
     private activeDeletePrompt: DeletePromptState | null = null
     private activeConflictPrompt: ConflictPromptState | null = null
-    private pendingSyncComplete: DeferredSyncComplete | null = null
+    private pendingSyncCompletionEvent: PendingSyncCompletionEvent | null = null
 
     installer: Installer | null = null
 
@@ -248,29 +248,29 @@ export class SyncRuntime {
         return this.activeDeletePrompt !== null || this.activeConflictPrompt !== null
     }
 
-    addPendingSyncComplete(syncComplete: DeferredSyncComplete): void {
-        this.pendingSyncComplete =
-            this.pendingSyncComplete === null
+    deferSyncComplete(syncComplete: PendingSyncCompletionEvent): void {
+        this.pendingSyncCompletionEvent =
+            this.pendingSyncCompletionEvent === null
                 ? syncComplete
                 : {
-                      totalCount: this.pendingSyncComplete.totalCount + syncComplete.totalCount,
-                      updatedCount: this.pendingSyncComplete.updatedCount + syncComplete.updatedCount,
-                      unchangedCount: this.pendingSyncComplete.unchangedCount + syncComplete.unchangedCount,
+                      totalCount: this.pendingSyncCompletionEvent.totalCount + syncComplete.totalCount,
+                      updatedCount: this.pendingSyncCompletionEvent.updatedCount + syncComplete.updatedCount,
+                      unchangedCount: this.pendingSyncCompletionEvent.unchangedCount + syncComplete.unchangedCount,
                   }
     }
 
     /**
-     * Reads the pending sync-complete and clears it when ready to fire.
+     * Claims the pending sync-complete event and clears it when ready to fire.
      * - `ready`: payload is returned and the slot is cleared.
      * - `blocked`: payload remains pending until prompts clear.
      * - `empty`: nothing was pending.
      */
-    checkPendingSyncComplete(): PendingSyncCompleteResult {
-        if (this.pendingSyncComplete === null) return { is: "empty" }
-        if (this.hasAnyActivePrompt()) return { is: "blocked" }
-        const syncComplete = this.pendingSyncComplete
-        this.pendingSyncComplete = null
-        return { is: "ready", payload: syncComplete }
+    claimPendingSyncComplete(): ClaimPendingSyncCompleteResult {
+        if (this.pendingSyncCompletionEvent === null) return { status: "empty" }
+        if (this.hasAnyActivePrompt()) return { status: "blocked" }
+        const syncComplete = this.pendingSyncCompletionEvent
+        this.pendingSyncCompletionEvent = null
+        return { status: "ready", payload: syncComplete }
     }
 
     invalidateDeletePromptPath(filePath: string): DeletePromptChange {
@@ -391,7 +391,7 @@ export class SyncRuntime {
     resetPrompts(): void {
         this.activeDeletePrompt = null
         this.activeConflictPrompt = null
-        this.pendingSyncComplete = null
+        this.pendingSyncCompletionEvent = null
     }
 
     cleanupUserActions(): void {