@markjaquith/agency 0.5.0 → 0.6.0

package/src/services/GitService.ts

@@ -246,7 +246,7 @@ export class GitService extends Effect.Service<GitService>()("GitService", {
 			gitRoot: string,
 			baseBranch?: string,
 		) => {
-			const args = ["git", "checkout", "-b", branchName]
+			const args = ["git", "checkout", "--no-track", "-b", branchName]
 			if (baseBranch) {
 				args.push(baseBranch)
 			}
@@ -404,6 +404,66 @@ export class GitService extends Effect.Service<GitService>()("GitService", {
 		setMainBranchConfig: (mainBranch: string, gitRoot: string) =>
 			setGitConfigEffect("agency.mainBranch", mainBranch, gitRoot),
 
+		/**
+		 * Resolves the main branch, preferring remote branches over local ones.
+		 *
+		 * Logic:
+		 * 1. Get the configured main branch (e.g., "main")
+		 * 2. If not configured, use findMainBranch() which already prefers remote
+		 * 3. If configured branch doesn't have a remote prefix, try to find a remote version
+		 * 4. Check if ${remote}/${branch} exists (e.g., "origin/main")
+		 * 5. Use remote version if it exists, fall back to local if not
+		 *
+		 * This ensures we always use the most up-to-date code from the remote
+		 * when creating new branches.
+		 */
+		resolveMainBranch: (gitRoot: string) =>
+			Effect.gen(function* () {
+				// Get the configured main branch
+				const configuredBranch = yield* getGitConfigEffect(
+					"agency.mainBranch",
+					gitRoot,
+				).pipe(Effect.catchAll(() => Effect.succeed(null)))
+
+				// If no config, use findMainBranch which already prefers remote
+				if (!configuredBranch) {
+					return yield* findMainBranchEffect(gitRoot)
+				}
+
+				// Check if the configured branch already has a remote prefix (e.g., "origin/main")
+				const hasRemotePrefix = configuredBranch.includes("/")
+				if (hasRemotePrefix) {
+					// Already a remote branch, use as-is
+					return configuredBranch
+				}
+
+				// Try to resolve the configured remote
+				const configuredRemote = yield* getGitConfigEffect(
+					"agency.remote",
+					gitRoot,
+				).pipe(Effect.catchAll(() => Effect.succeed(null)))
+
+				// If no configured remote, try to find the default remote
+				const remote =
+					configuredRemote || (yield* findDefaultRemoteEffect(gitRoot))
+
+				if (remote) {
+					// Check if the remote version of the branch exists
+					const remoteBranch = `${remote}/${configuredBranch}`
+					const remoteExists = yield* branchExistsEffect(gitRoot, remoteBranch)
+					if (remoteExists) {
+						return remoteBranch
+					}
+				}
+
+				// Fall back to the configured local branch
+				return configuredBranch
+			}).pipe(
+				Effect.mapError(
+					() => new GitError({ message: "Failed to resolve main branch" }),
+				),
+			),
+
 		getDefaultBaseBranchConfig: (gitRoot: string) =>
 			pipe(
 				getGitConfigEffect("agency.baseBranch", gitRoot),

package/src/utils/glob.test.ts

@@ -0,0 +1,154 @@
+import { test, expect, describe, beforeAll, afterAll } from "bun:test"
+import { mkdtemp, rm, mkdir, writeFile } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import {
+	isGlobPattern,
+	matchesGlob,
+	expandGlobs,
+	dirToGlobPattern,
+	getTopLevelDir,
+} from "./glob"
+
+describe("isGlobPattern", () => {
+	test("returns true for patterns with asterisk", () => {
+		expect(isGlobPattern("*.ts")).toBe(true)
+		expect(isGlobPattern("**/*.ts")).toBe(true)
+		expect(isGlobPattern("plans/*")).toBe(true)
+		expect(isGlobPattern("plans/**")).toBe(true)
+	})
+
+	test("returns true for patterns with question mark", () => {
+		expect(isGlobPattern("file?.ts")).toBe(true)
+	})
+
+	test("returns true for patterns with character classes", () => {
+		expect(isGlobPattern("[abc].ts")).toBe(true)
+		expect(isGlobPattern("file[0-9].ts")).toBe(true)
+	})
+
+	test("returns false for plain file paths", () => {
+		expect(isGlobPattern("foo.ts")).toBe(false)
+		expect(isGlobPattern("plans/README.md")).toBe(false)
+		expect(isGlobPattern("src/utils/glob.ts")).toBe(false)
+	})
+})
+
+describe("matchesGlob", () => {
+	test("matches files with simple wildcard", () => {
+		expect(matchesGlob("*.ts", "file.ts")).toBe(true)
+		expect(matchesGlob("*.ts", "file.js")).toBe(false)
+	})
+
+	test("matches files in directories with **", () => {
+		expect(matchesGlob("plans/**", "plans/foo.md")).toBe(true)
+		expect(matchesGlob("plans/**", "plans/sub/bar.md")).toBe(true)
+		expect(matchesGlob("plans/**", "other/foo.md")).toBe(false)
+	})
+
+	test("matches nested directory patterns", () => {
+		expect(matchesGlob("src/**/*.ts", "src/utils/glob.ts")).toBe(true)
+		expect(matchesGlob("src/**/*.ts", "src/glob.ts")).toBe(true)
+		expect(matchesGlob("src/**/*.ts", "lib/glob.ts")).toBe(false)
+	})
+})
+
+describe("dirToGlobPattern", () => {
+	test("converts directory to glob pattern", () => {
+		expect(dirToGlobPattern("plans")).toBe("plans/**")
+		expect(dirToGlobPattern("src/components")).toBe("src/components/**")
+	})
+
+	test("removes trailing slash before adding glob", () => {
+		expect(dirToGlobPattern("plans/")).toBe("plans/**")
+		expect(dirToGlobPattern("plans//")).toBe("plans/**")
+	})
+})
+
+describe("getTopLevelDir", () => {
+	test("returns top-level directory from path", () => {
+		expect(getTopLevelDir("plans/foo.md")).toBe("plans")
+		expect(getTopLevelDir("plans/sub/bar.md")).toBe("plans")
+		expect(getTopLevelDir("src/utils/glob.ts")).toBe("src")
+	})
+
+	test("returns null for root-level files", () => {
+		expect(getTopLevelDir("README.md")).toBe(null)
+		expect(getTopLevelDir("file.ts")).toBe(null)
+	})
+})
+
+describe("expandGlobs", () => {
+	let tempDir: string
+
+	beforeAll(async () => {
+		// Create temp directory with test files
+		tempDir = await mkdtemp(join(tmpdir(), "glob-test-"))
+
+		// Create directory structure:
+		// tempDir/
+		//   plans/
+		//     foo.md
+		//     sub/
+		//       bar.md
+		//   other/
+		//     baz.md
+		//   root.txt
+		await mkdir(join(tempDir, "plans"))
+		await mkdir(join(tempDir, "plans", "sub"))
+		await mkdir(join(tempDir, "other"))
+
+		await writeFile(join(tempDir, "plans", "foo.md"), "foo")
+		await writeFile(join(tempDir, "plans", "sub", "bar.md"), "bar")
+		await writeFile(join(tempDir, "other", "baz.md"), "baz")
+		await writeFile(join(tempDir, "root.txt"), "root")
+	})
+
+	afterAll(async () => {
+		await rm(tempDir, { recursive: true })
+	})
+
+	test("expands glob pattern to matching files", async () => {
+		const files = await expandGlobs(["plans/**"], tempDir)
+		expect(files.sort()).toEqual(["plans/foo.md", "plans/sub/bar.md"].sort())
+	})
+
+	test("preserves non-glob paths as-is", async () => {
+		const files = await expandGlobs(["root.txt"], tempDir)
+		expect(files).toEqual(["root.txt"])
+	})
+
+	test("combines glob and non-glob patterns", async () => {
+		const files = await expandGlobs(["plans/**", "root.txt"], tempDir)
+		expect(files.sort()).toEqual(
+			["plans/foo.md", "plans/sub/bar.md", "root.txt"].sort(),
+		)
+	})
+
+	test("deduplicates results", async () => {
+		const files = await expandGlobs(
+			["plans/**", "plans/foo.md", "plans/**"],
+			tempDir,
+		)
+		// Should not have duplicates
+		const uniqueFiles = [...new Set(files)]
+		expect(files.length).toBe(uniqueFiles.length)
+	})
+
+	test("returns non-glob paths even if they don't exist", async () => {
+		const files = await expandGlobs(["nonexistent.txt"], tempDir)
+		expect(files).toEqual(["nonexistent.txt"])
+	})
+
+	test("returns empty array for non-matching glob", async () => {
+		const files = await expandGlobs(["nonexistent/**"], tempDir)
+		expect(files).toEqual([])
+	})
+
+	test("handles multiple glob patterns", async () => {
+		const files = await expandGlobs(["plans/**", "other/**"], tempDir)
+		expect(files.sort()).toEqual(
+			["plans/foo.md", "plans/sub/bar.md", "other/baz.md"].sort(),
+		)
+	})
+})

package/src/utils/glob.ts

@@ -0,0 +1,78 @@
+/**
+ * Utilities for glob pattern matching and expansion.
+ * Uses Bun's built-in Glob API.
+ */
+
+/**
+ * Check if a string contains glob pattern characters.
+ * This detects wildcards like *, **, ?, and character classes like [abc].
+ */
+export function isGlobPattern(str: string): boolean {
+	return /[*?[\]]/.test(str)
+}
+
+/**
+ * Check if a path matches a glob pattern.
+ * Uses Bun.Glob for pattern matching.
+ */
+export function matchesGlob(pattern: string, path: string): boolean {
+	const glob = new Bun.Glob(pattern)
+	return glob.match(path)
+}
+
+/**
+ * Expand glob patterns to actual file paths.
+ * Non-glob paths are returned as-is.
+ *
+ * @param patterns - Array of file paths or glob patterns
+ * @param cwd - Working directory to resolve patterns against
+ * @returns Array of expanded file paths (deduplicated)
+ */
+export async function expandGlobs(
+	patterns: string[],
+	cwd: string,
+): Promise<string[]> {
+	const files = new Set<string>()
+
+	for (const pattern of patterns) {
+		if (isGlobPattern(pattern)) {
+			// Expand glob pattern
+			const glob = new Bun.Glob(pattern)
+			for await (const file of glob.scan({ cwd })) {
+				files.add(file)
+			}
+		} else {
+			// Non-glob path, add as-is
+			files.add(pattern)
+		}
+	}
+
+	return Array.from(files)
+}
+
+/**
+ * Convert a directory path to a glob pattern.
+ * Appends /** to match all files recursively in the directory.
+ *
+ * @param dirPath - Directory path (e.g., "plans" or "plans/")
+ * @returns Glob pattern (e.g., "plans/**")
+ */
+export function dirToGlobPattern(dirPath: string): string {
+	// Remove trailing slash if present
+	const normalized = dirPath.replace(/\/+$/, "")
+	return `${normalized}/**`
+}
+
+/**
+ * Extract the top-level directory from a file path.
+ *
+ * @param filePath - File path (e.g., "plans/foo/bar.md")
+ * @returns Top-level directory name (e.g., "plans") or null if no directory
+ */
+export function getTopLevelDir(filePath: string): string | null {
+	const parts = filePath.split("/")
+	if (parts.length > 1) {
+		return parts[0] || null
+	}
+	return null
+}