@markjaquith/agency 1.9.1 → 1.9.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "1.9.1",
+  "version": "1.9.3",
   "description": "Manages personal agents files",
   "keywords": [
     "agents",

package/src/commands/emit.test.ts

@@ -125,6 +125,50 @@ describe("emit command", () => {
 			expect(currentBranch).toBe("agency--feature")
 		})
 
+		test("sets emit branch upstream when remote branch exists", async () => {
+			await checkoutBranch(tempDir, "main")
+			await createBranch(tempDir, "agency--feature")
+			await Bun.write(
+				join(tempDir, "agency.json"),
+				JSON.stringify({
+					version: 1,
+					injectedFiles: ["AGENTS.md"],
+					template: "test",
+					createdAt: new Date().toISOString(),
+				}),
+			)
+			await addAndCommit(tempDir, "agency.json", "Feature commit")
+
+			await getGitOutput(tempDir, [
+				"update-ref",
+				"refs/remotes/origin/feature",
+				"HEAD",
+			])
+
+			await runTestEffect(emit({ silent: true, skipFilter: true }))
+
+			const remote = await getGitOutput(tempDir, [
+				"config",
+				"--get",
+				"branch.feature.remote",
+			])
+			const merge = await getGitOutput(tempDir, [
+				"config",
+				"--get",
+				"branch.feature.merge",
+			])
+			expect(remote.trim()).toBe("origin")
+			expect(merge.trim()).toBe("refs/heads/feature")
+
+			await checkoutBranch(tempDir, "feature")
+			const pushRef = await getGitOutput(tempDir, [
+				"rev-parse",
+				"--abbrev-ref",
+				"@{push}",
+			])
+			expect(pushRef.trim()).toBe("origin/feature")
+		})
+
 		test("creates emit branch with custom name", async () => {
 			await createBranch(tempDir, "agency--feature")
 			await createCommit(tempDir, "Feature commit")

package/src/commands/emit.ts

@@ -158,9 +158,7 @@ export const emitCore = (gitRoot: string, options: EmitOptions) =>
 			)
 			branchExisted = existed
 
-			// Unset any remote tracking branch for the emit branch
-			yield* git.unsetGitConfig(`branch.${emitBranchName}.remote`, gitRoot)
-			yield* git.unsetGitConfig(`branch.${emitBranchName}.merge`, gitRoot)
+			yield* configureEmitBranchTracking(gitRoot, emitBranchName, verboseLog)
 		})
 
 		yield* withSpinner(createBranch, {
@@ -435,6 +433,48 @@ const getFilterRepoStateDir = (gitRoot: string) =>
 		return resolveGitInternalPath(gitRoot, gitPath)
 	})
 
+const configureEmitBranchTracking = (
+	gitRoot: string,
+	emitBranchName: string,
+	verboseLog: (message: string) => void,
+) =>
+	Effect.gen(function* () {
+		const git = yield* GitService
+		const remote = yield* git.resolveRemote(gitRoot).pipe(Effect.option)
+
+		if (remote._tag === "None") {
+			yield* git.unsetGitConfig(`branch.${emitBranchName}.remote`, gitRoot)
+			yield* git.unsetGitConfig(`branch.${emitBranchName}.merge`, gitRoot)
+			return
+		}
+
+		const remoteBranch = `${remote.value}/${emitBranchName}`
+		const remoteBranchExists = yield* git.branchExists(gitRoot, remoteBranch)
+
+		if (!remoteBranchExists) {
+			yield* git.unsetGitConfig(`branch.${emitBranchName}.remote`, gitRoot)
+			yield* git.unsetGitConfig(`branch.${emitBranchName}.merge`, gitRoot)
+			verboseLog(
+				`No existing remote branch ${highlight.branch(remoteBranch)}; leaving ${highlight.branch(emitBranchName)} without upstream`,
+			)
+			return
+		}
+
+		yield* git.setGitConfig(
+			`branch.${emitBranchName}.remote`,
+			remote.value,
+			gitRoot,
+		)
+		yield* git.setGitConfig(
+			`branch.${emitBranchName}.merge`,
+			`refs/heads/${emitBranchName}`,
+			gitRoot,
+		)
+		verboseLog(
+			`Set ${highlight.branch(emitBranchName)} upstream to ${highlight.branch(remoteBranch)}`,
+		)
+	})
+
 /**
  * Find the best fork point by checking both local and remote tracking branches.
  *

package/src/utils/spinner.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, test } from "bun:test"
+import { Effect } from "effect"
+import { withSpinner } from "./spinner"
+
+describe("withSpinner", () => {
+	test("clears and stops the spinner when an Effect failure has no fail text", async () => {
+		const originalNodeEnv = process.env.NODE_ENV
+		const originalBunEnv = process.env.BUN_ENV
+		delete process.env.NODE_ENV
+		delete process.env.BUN_ENV
+
+		const calls: string[] = []
+		const error = new Error("boom")
+
+		try {
+			await expect(
+				Effect.runPromise(
+					withSpinner(Effect.fail(error), {
+						text: "Working",
+						createSpinner: () => ({
+							succeed: () => calls.push("succeed"),
+							fail: () => calls.push("fail"),
+							clear: () => calls.push("clear"),
+							stop: () => calls.push("stop"),
+						}),
+					}),
+				),
+			).rejects.toThrow("boom")
+
+			expect(calls).toEqual(["clear", "stop"])
+		} finally {
+			if (originalNodeEnv === undefined) {
+				delete process.env.NODE_ENV
+			} else {
+				process.env.NODE_ENV = originalNodeEnv
+			}
+
+			if (originalBunEnv === undefined) {
+				delete process.env.BUN_ENV
+			} else {
+				process.env.BUN_ENV = originalBunEnv
+			}
+		}
+	})
+})

package/src/utils/spinner.ts

@@ -1,5 +1,12 @@
 import ora from "ora"
-import { Effect } from "effect"
+import { Effect, Exit } from "effect"
+
+interface Spinner {
+	succeed: (text?: string) => unknown
+	fail: (text?: string) => unknown
+	clear: () => unknown
+	stop: () => unknown
+}
 
 /**
  * Check if we're running in a test environment
@@ -20,6 +27,8 @@ interface SpinnerConfig {
 	failText?: string
 	/** Whether the spinner is enabled (defaults to true) */
 	enabled?: boolean
+	/** Creates the spinner instance. Intended for tests. */
+	createSpinner?: (text: string) => Spinner
 }
 
 /**
@@ -53,31 +62,35 @@ export const withSpinner = <A, E, R>(
 		return effect
 	}
 
-	return Effect.gen(function* () {
-		const spinner = ora({
-			text,
-			spinner: "dots",
-			color: "cyan",
-		}).start()
-
-		try {
-			const result = yield* effect
+	const createSpinner =
+		config.createSpinner ??
+		((text: string) =>
+			ora({
+				text,
+				spinner: "dots",
+				color: "cyan",
+			}).start())
 
-			if (successText) {
-				spinner.succeed(successText)
-			} else {
-				spinner.stop()
-			}
+	return Effect.acquireUseRelease(
+		Effect.sync(() => createSpinner(text)),
+		() => effect,
+		(spinner, exit) =>
+			Effect.sync(() => {
+				if (Exit.isSuccess(exit)) {
+					if (successText) {
+						spinner.succeed(successText)
+					} else {
+						spinner.stop()
+					}
+					return
+				}
 
-			return result
-		} catch (error) {
-			if (failText) {
-				spinner.fail(failText)
-			} else {
-				spinner.clear()
-				spinner.stop()
-			}
-			throw error
-		}
-	})
+				if (failText) {
+					spinner.fail(failText)
+				} else {
+					spinner.clear()
+					spinner.stop()
+				}
+			}),
+	)
 }