@markjaquith/agency 1.5.0 → 1.5.2

package/cli.ts

@@ -124,14 +124,24 @@ const commands: Record<string, Command> = {
 	pr: {
 		name: "pr",
 		description: "Run gh pr with the emitted branch name",
-		run: async (args: string[], options: Record<string, any>) => {
+		run: async (
+			_args: string[],
+			options: Record<string, any>,
+			rawArgs?: string[],
+		) => {
 			if (options.help) {
 				console.log(prHelp)
 				return
 			}
+			// Pass raw args (after filtering agency flags) directly to gh pr
+			// This allows flags like --web to pass through without needing --
+			const agencyFlags = ["--help", "-h", "--silent", "-s", "--verbose", "-v"]
+			const filteredArgs = (rawArgs ?? []).filter(
+				(arg) => !agencyFlags.includes(arg),
+			)
 			await runCommand(
 				pr({
-					args,
+					args: filteredArgs,
 					silent: options.silent,
 					verbose: options.verbose,
 				}),
@@ -621,8 +631,8 @@ try {
 		allowPositionals: true,
 	})
 
-	// Run the command
-	await command.run(cmdPositionals, cmdValues)
+	// Run the command, passing raw args for commands that need them (like pr)
+	await command.run(cmdPositionals, cmdValues, commandArgs)
 } catch (error) {
 	if (error instanceof Error) {
 		console.error(`ⓘ ${error.message}`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "1.5.0",
+  "version": "1.5.2",
   "description": "Manages personal agents files",
   "license": "MIT",
   "author": "Mark Jaquith",

package/src/commands/emit.test.ts

@@ -1,5 +1,6 @@
 import { test, expect, describe, beforeEach, afterEach } from "bun:test"
 import { join } from "path"
+import { symlink } from "fs/promises"
 import { emit } from "../commands/emit"
 import { task } from "../commands/task"
 import {
@@ -323,5 +324,47 @@ describe("emit command", () => {
 			// Should have GIT_CONFIG_GLOBAL env set
 			expect(lastCall!.env?.GIT_CONFIG_GLOBAL).toBe("")
 		})
+
+		test("includes symlink targets in files to filter", async () => {
+			// Set up fresh branch
+			await checkoutBranch(tempDir, "main")
+			await createBranch(tempDir, "agency/symlink-test")
+
+			// Create AGENTS.md as the real file
+			await Bun.write(join(tempDir, "AGENTS.md"), "# Real file\n")
+
+			// Create CLAUDE.md as a symlink to AGENTS.md
+			await symlink("AGENTS.md", join(tempDir, "CLAUDE.md"))
+
+			// Create agency.json
+			await Bun.write(
+				join(tempDir, "agency.json"),
+				JSON.stringify({
+					version: 1,
+					injectedFiles: [],
+					template: "test",
+					createdAt: new Date().toISOString(),
+				}),
+			)
+			await addAndCommit(
+				tempDir,
+				["AGENTS.md", "CLAUDE.md", "agency.json"],
+				"Add files with symlink",
+			)
+
+			// Run emit with mock filter-repo
+			await runTestEffectWithMockFilterRepo(emit({ silent: true }))
+
+			// Verify filter-repo was called with both CLAUDE.md AND AGENTS.md
+			const lastCall = getLastCapturedFilterRepoCall()
+			expect(lastCall).toBeDefined()
+
+			// Should include CLAUDE.md (the symlink)
+			expect(lastCall!.args).toContain("CLAUDE.md")
+
+			// Should also include AGENTS.md (the symlink target)
+			// This is the key assertion - the symlink target should be filtered too
+			expect(lastCall!.args).toContain("AGENTS.md")
+		})
 	})
 })

package/src/services/AgencyMetadataService.ts

@@ -1,4 +1,4 @@
-import { join } from "node:path"
+import { join, dirname, resolve, relative } from "node:path"
 import { Context, Data, Effect, Layer } from "effect"
 import { Schema } from "@effect/schema"
 import { AgencyMetadata } from "../schemas"
@@ -104,6 +104,49 @@ const parseAgencyMetadata = (content: string) =>
 		return metadata
 	}).pipe(Effect.catchAll(() => Effect.succeed(null)))
 
+/**
+ * Resolve symlink targets for a list of files.
+ * For each file, if it's a symlink, also adds the target path to the result.
+ * This ensures that when filtering files from git history, both the symlink
+ * and its target are filtered (important when CLAUDE.md → AGENTS.md, for example).
+ */
+const resolveSymlinkTargets = (
+	fs: FileSystemService,
+	gitRoot: string,
+	files: string[],
+) =>
+	Effect.gen(function* () {
+		const result = new Set<string>(files)
+
+		for (const file of files) {
+			const fullPath = join(gitRoot, file)
+			const target = yield* fs.readSymlinkTarget(fullPath)
+
+			if (target) {
+				// The target path could be relative or absolute
+				// If relative, it's relative to the symlink's location
+				// We need to normalize it to be relative to gitRoot
+				let targetPath: string
+				if (target.startsWith("/")) {
+					// Absolute path - make it relative to gitRoot
+					targetPath = relative(gitRoot, target)
+				} else {
+					// Relative path - resolve from the symlink's directory
+					const symlinkDir = dirname(fullPath)
+					const absoluteTarget = resolve(symlinkDir, target)
+					targetPath = relative(gitRoot, absoluteTarget)
+				}
+
+				// Only add if it's within the gitRoot (not escaping the repo)
+				if (!targetPath.startsWith("..")) {
+					result.add(targetPath)
+				}
+			}
+		}
+
+		return Array.from(result)
+	})
+
 /**
  * Implementation of AgencyMetadataService
  */
@@ -164,7 +207,8 @@ export const AgencyMetadataServiceLive = Layer.succeed(
 				const baseFiles = ["TASK.md", "AGENCY.md", "CLAUDE.md", "agency.json"]
 
 				if (!exists) {
-					return baseFiles
+					// Resolve symlinks even for base files
+					return yield* resolveSymlinkTargets(fs, gitRoot, baseFiles)
 				}
 
 				const content = yield* fs
@@ -172,13 +216,13 @@ export const AgencyMetadataServiceLive = Layer.succeed(
 					.pipe(Effect.catchAll(() => Effect.succeed("")))
 
 				if (!content) {
-					return baseFiles
+					return yield* resolveSymlinkTargets(fs, gitRoot, baseFiles)
 				}
 
 				const metadata = yield* parseAgencyMetadata(content)
 
 				if (!metadata) {
-					return baseFiles
+					return yield* resolveSymlinkTargets(fs, gitRoot, baseFiles)
 				}
 
 				// Expand any glob patterns in injectedFiles to actual file paths
@@ -188,7 +232,8 @@ export const AgencyMetadataServiceLive = Layer.succeed(
 					catch: () => new Error("Failed to expand glob patterns"),
 				})
 
-				return expandedFiles
+				// Resolve symlinks and add their targets
+				return yield* resolveSymlinkTargets(fs, gitRoot, expandedFiles)
 			}).pipe(
 				Effect.catchAll(() =>
 					Effect.succeed(["TASK.md", "AGENCY.md", "CLAUDE.md", "agency.json"]),

package/src/services/FileSystemService.ts

@@ -1,5 +1,11 @@
 import { Effect, Data, pipe } from "effect"
-import { mkdir, copyFile as fsCopyFile, unlink } from "node:fs/promises"
+import {
+	mkdir,
+	copyFile as fsCopyFile,
+	unlink,
+	lstat,
+	readlink,
+} from "node:fs/promises"
 import { spawnProcess } from "../utils/process"
 
 // Error types for FileSystem operations
@@ -219,6 +225,37 @@ export class FileSystemService extends Effect.Service<FileSystemService>()(
 							cause: error,
 						}),
 				}),
+
+			/**
+			 * Check if a path is a symbolic link.
+			 * Returns false if the file doesn't exist or if it's not a symlink.
+			 */
+			isSymlink: (path: string) =>
+				Effect.tryPromise({
+					try: async () => {
+						const stats = await lstat(path)
+						return stats.isSymbolicLink()
+					},
+					catch: () =>
+						// If we can't lstat, it's not a symlink (or doesn't exist)
+						false,
+				}).pipe(Effect.catchAll(() => Effect.succeed(false))),
+
+			/**
+			 * Read the target of a symbolic link.
+			 * Returns null if the file is not a symlink or doesn't exist.
+			 */
+			readSymlinkTarget: (path: string) =>
+				Effect.tryPromise({
+					try: async () => {
+						const stats = await lstat(path)
+						if (!stats.isSymbolicLink()) {
+							return null
+						}
+						return await readlink(path)
+					},
+					catch: () => null,
+				}).pipe(Effect.catchAll(() => Effect.succeed(null))),
 		}),
 	},
 ) {}

package/src/types.ts

@@ -12,7 +12,11 @@ import { GitService } from "./services/GitService"
 export interface Command {
 	name: string
 	description: string
-	run: (args: string[], options: Record<string, any>) => Promise<void>
+	run: (
+		args: string[],
+		options: Record<string, any>,
+		rawArgs?: string[],
+	) => Promise<void>
 	help?: string
 }