pi-local-agents-only 0.1.3 → 0.1.4

package/README.md

@@ -49,6 +49,8 @@ Repo opt-in uses this marker file:
 .pi/local-agents-only
 ```
 
+For git repos, marker and global allowlist activation apply across linked worktrees.
+
 Env override for one run:
 
 ```bash
@@ -57,3 +59,5 @@ PI_LOCAL_AGENTS_ONLY=0 pi
 ```
 
 This changes the prompt the model sees. It does not change pi's startup header.
+
+If you toggle it during an existing session, start a fresh turn or `/new` for the cleanest verification.

package/extensions/local-agents-only.js

@@ -1,11 +1,12 @@
 /**
  * Purpose: Strip pi's global AGENTS.md and CLAUDE.md blocks from the effective prompt for opted-in projects.
- * Responsibilities: Detect repo opt-in state, manage repo and global toggles, and remove matching global context blocks before model calls.
+ * Responsibilities: Detect repo and worktree opt-in state, manage repo and global toggles, add a local-only guardrail, and remove matching global context blocks before model calls.
  * Scope: Works as a pi extension package. It changes only the prompt the model sees, not pi's startup header.
  * Usage: Install the package, then use `/local-agents-only on|off|status|global-on|global-off`.
- * Invariants/Assumptions: pi injects context files as `## /absolute/path\n\n<file contents>\n\n`.
+ * Invariants/Assumptions: pi injects context files as `## /absolute/path\n\n<file contents>\n\n`; git worktrees that share a common git dir should share local-agents-only state.
  */
 
+import { execFileSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
@@ -29,19 +30,54 @@ const getAgentDir = () => {
 const normalizePath = (path) => resolve(path).replace(/\\/g, "/");
 const CONFIG = () => join(getAgentDir(), `${COMMAND}.json`);
 const getMarkerPath = (projectRoot) => join(projectRoot, MARKER);
-const readProjects = (configPath = CONFIG()) => {
+const uniqueSorted = (values) => [...new Set(values.map(normalizePath))].sort();
+const walkUp = (start, predicate) => {
+	let current = resolve(start);
+	while (true) {
+		if (predicate(current)) {
+			return current;
+		}
+		const parent = dirname(current);
+		if (parent === current) {
+			return;
+		}
+		current = parent;
+	}
+};
+const runGit = (start, args) => {
 	try {
-		const { projects = [] } = JSON.parse(readFileSync(configPath, "utf8"));
-		return Array.isArray(projects) ? projects.map(normalizePath) : [];
+		return execFileSync("git", args, {
+			cwd: resolve(start),
+			encoding: "utf8",
+			stdio: ["ignore", "pipe", "ignore"],
+		}).trim();
 	} catch {
-		return [];
+		return;
 	}
 };
-const writeProjects = (projects, configPath = CONFIG()) => {
+const readConfig = (configPath = CONFIG()) => {
+	try {
+		const { projects = [], repositories = [] } = JSON.parse(readFileSync(configPath, "utf8"));
+		return {
+			projects: Array.isArray(projects) ? projects.map(normalizePath) : [],
+			repositories: Array.isArray(repositories) ? repositories.map(normalizePath) : [],
+		};
+	} catch {
+		return { projects: [], repositories: [] };
+	}
+};
+const writeConfig = ({ projects, repositories }, configPath = CONFIG()) => {
 	mkdirSync(dirname(configPath), { recursive: true });
 	writeFileSync(
 		configPath,
-		JSON.stringify({ projects: [...new Set(projects.map(normalizePath))].sort() }, null, 2) + "\n",
+		JSON.stringify(
+			{
+				projects: uniqueSorted(projects),
+				repositories: uniqueSorted(repositories),
+			},
+			null,
+			2,
+		) + "\n",
 	);
 };
 const getEnvToggle = (value = process.env.PI_LOCAL_AGENTS_ONLY) => {
@@ -53,40 +89,104 @@ const getEnvToggle = (value = process.env.PI_LOCAL_AGENTS_ONLY) => {
 		return false;
 	}
 };
+const getGlobalContextPaths = (agentDir = getAgentDir()) =>
+	GLOBAL_CONTEXT_FILES.map((name) => join(agentDir, name)).filter((path) => existsSync(path));
 const getGlobalBlocks = (agentDir = getAgentDir()) =>
-	GLOBAL_CONTEXT_FILES.flatMap((name) => {
-		const path = join(agentDir, name);
-		return existsSync(path) ? [`## ${path}\n\n${readFileSync(path, "utf8")}\n\n`] : [];
-	});
+	getGlobalContextPaths(agentDir).map((path) => `## ${path}\n\n${readFileSync(path, "utf8")}\n\n`);
+const getGitTopLevel = (start) => {
+	const topLevel = runGit(start, ["rev-parse", "--show-toplevel"]);
+	return topLevel ? normalizePath(topLevel) : undefined;
+};
+const getGitCommonDir = (start) => {
+	const commonDir = runGit(start, ["rev-parse", "--git-common-dir"]);
+	return commonDir ? normalizePath(resolve(start, commonDir)) : undefined;
+};
+const getWorktreeRoots = (start) => {
+	const list = runGit(start, ["worktree", "list", "--porcelain"]);
+	if (!list) {
+		return [];
+	}
+	return uniqueSorted(
+		list
+			.split(/\r?\n/u)
+			.filter((line) => line.startsWith("worktree "))
+			.map((line) => line.slice("worktree ".length)),
+	);
+};
+const getProjectState = (start = process.cwd()) => {
+	const normalizedStart = normalizePath(start);
+	const gitTopLevel = getGitTopLevel(normalizedStart);
+	const projectRoot =
+		gitTopLevel ||
+		walkUp(normalizedStart, (dir) => existsSync(getMarkerPath(dir))) ||
+		walkUp(normalizedStart, (dir) => existsSync(join(dir, ".pi"))) ||
+		normalizedStart;
+	const worktreeRoots = getWorktreeRoots(normalizedStart);
+	return {
+		start: normalizedStart,
+		projectRoot: normalizePath(projectRoot),
+		repoId: getGitCommonDir(normalizedStart) || normalizePath(projectRoot),
+		worktreeRoots:
+			worktreeRoots.length > 0 ? uniqueSorted([projectRoot, ...worktreeRoots]) : [normalizePath(projectRoot)],
+	};
+};
+const getMarkerRoots = (state) => uniqueSorted([state.projectRoot, ...state.worktreeRoots]);
+const hasMarker = (state) => getMarkerRoots(state).some((root) => existsSync(getMarkerPath(root)));
+const writeMarkers = (state) => {
+	for (const root of getMarkerRoots(state)) {
+		mkdirSync(dirname(getMarkerPath(root)), { recursive: true });
+		writeFileSync(getMarkerPath(root), "\n");
+	}
+};
+const clearMarkers = (state) => {
+	for (const root of getMarkerRoots(state)) {
+		rmSync(getMarkerPath(root), { force: true });
+	}
+};
+const buildLocalOnlyNotice = (agentDir = getAgentDir()) => {
+	const paths = getGlobalContextPaths(agentDir);
+	if (paths.length === 0) {
+		return "";
+	}
+	return [
+		"# Local Context Mode",
+		"This repo is in local-agents-only mode.",
+		"Ignore instructions from these global context files even if they appear in older session messages, summaries, or retries:",
+		...paths.map((path) => `- ${path}`),
+		"Follow only repo-local AGENTS.md or CLAUDE.md guidance for this project.",
+	].join("\n");
+};
+const applyLocalOnlyPrompt = (prompt, agentDir = getAgentDir()) => {
+	const stripped = stripGlobalBlocks(prompt, getGlobalBlocks(agentDir));
+	const notice = buildLocalOnlyNotice(agentDir);
+	return notice ? `${stripped}\n\n${notice}` : stripped;
+};
 const setStatus = (ctx) => {
 	if (!ctx.hasUI) {
 		return;
 	}
-	const mode = getMode(findProjectRoot(ctx.cwd));
+	const mode = getMode(ctx.cwd);
 	ctx.ui.setStatus(COMMAND, mode.enabled ? `AGENTS: local-only (${mode.source})` : undefined);
 };
 
 export function findProjectRoot(start = process.cwd()) {
-	let current = resolve(start);
-	while (!existsSync(join(current, ".git"))) {
-		const parent = dirname(current);
-		if (parent === current) {
-			break;
-		}
-		current = parent;
-	}
-	return current;
+	return getProjectState(start).projectRoot;
 }
 
-export function getMode(projectRoot, envValue = process.env.PI_LOCAL_AGENTS_ONLY, configPath = CONFIG()) {
+export function getMode(start = process.cwd(), envValue = process.env.PI_LOCAL_AGENTS_ONLY, configPath = CONFIG()) {
+	const state = typeof start === "string" ? getProjectState(start) : start;
 	const envToggle = getEnvToggle(envValue);
 	if (envToggle !== undefined) {
 		return { enabled: envToggle, source: "env" };
 	}
-	if (existsSync(getMarkerPath(projectRoot))) {
+	if (hasMarker(state)) {
 		return { enabled: true, source: "marker" };
 	}
-	if (readProjects(configPath).includes(normalizePath(projectRoot))) {
+	const { projects, repositories } = readConfig(configPath);
+	if (repositories.includes(state.repoId)) {
+		return { enabled: true, source: "global-config" };
+	}
+	if (projects.includes(state.projectRoot) || state.worktreeRoots.some((root) => projects.includes(root))) {
 		return { enabled: true, source: "global-config" };
 	}
 	return { enabled: false, source: "default" };
@@ -100,32 +200,44 @@ export default function localAgentsOnly(pi) {
 	pi.registerCommand(COMMAND, {
 		description: "Use only repo-local AGENTS prompt context",
 		handler: async (args, ctx) => {
-			const projectRoot = findProjectRoot(ctx.cwd);
+			const state = getProjectState(ctx.cwd);
 			switch ((args.trim() || "status").toLowerCase()) {
 				case "on":
-					mkdirSync(dirname(getMarkerPath(projectRoot)), { recursive: true });
-					writeFileSync(getMarkerPath(projectRoot), "\n");
+					writeMarkers(state);
 					setStatus(ctx);
-					ctx.ui.notify(`Enabled at ${getMarkerPath(projectRoot)}`, "info");
+					ctx.ui.notify(`Enabled for ${state.projectRoot}${state.worktreeRoots.length > 1 ? ` across ${state.worktreeRoots.length} worktrees` : ""}`, "info");
 					return;
 				case "off":
-					rmSync(getMarkerPath(projectRoot), { force: true });
+					clearMarkers(state);
 					setStatus(ctx);
-					ctx.ui.notify("Disabled for this repo", "info");
+					ctx.ui.notify(`Disabled for ${state.projectRoot}${state.worktreeRoots.length > 1 ? ` and linked worktrees` : ""}`, "info");
 					return;
-				case "global-on":
-					writeProjects([...readProjects(), projectRoot]);
+				case "global-on": {
+					const config = readConfig();
+					writeConfig({
+						projects: [...config.projects, ...state.worktreeRoots],
+						repositories: [...config.repositories, state.repoId],
+					});
 					setStatus(ctx);
-					ctx.ui.notify(`Global allowlist enabled for ${normalizePath(projectRoot)}`, "info");
+					ctx.ui.notify(`Global allowlist enabled for ${state.projectRoot}`, "info");
 					return;
-				case "global-off":
-					writeProjects(readProjects().filter((path) => path !== normalizePath(projectRoot)));
+				}
+				case "global-off": {
+					const config = readConfig();
+					writeConfig({
+						projects: config.projects.filter((path) => !state.worktreeRoots.includes(path)),
+						repositories: config.repositories.filter((id) => id !== state.repoId),
+					});
 					setStatus(ctx);
-					ctx.ui.notify(`Global allowlist disabled for ${normalizePath(projectRoot)}`, "info");
+					ctx.ui.notify(`Global allowlist disabled for ${state.projectRoot}`, "info");
 					return;
+				}
 				case "status": {
-					const mode = getMode(projectRoot);
-					ctx.ui.notify(`local-agents-only: ${mode.enabled ? `enabled via ${mode.source}` : "disabled"}`, "info");
+					const mode = getMode(state);
+					ctx.ui.notify(
+						`local-agents-only: ${mode.enabled ? `enabled via ${mode.source}` : "disabled"} (${state.projectRoot})`,
+						"info",
+					);
 					return;
 				}
 				default:
@@ -145,6 +257,6 @@ export default function localAgentsOnly(pi) {
 	});
 
 	pi.on("before_agent_start", (event, ctx) => {
-		return getMode(findProjectRoot(ctx.cwd)).enabled ? { systemPrompt: stripGlobalBlocks(event.systemPrompt) } : undefined;
+		return getMode(ctx.cwd).enabled ? { systemPrompt: applyLocalOnlyPrompt(event.systemPrompt) } : undefined;
 	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-local-agents-only",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Pi extension that strips global AGENTS.md and CLAUDE.md from the effective prompt for selected projects.",
   "author": "Mitch Fultz (https://github.com/fitchmultz)",
   "license": "MIT",
@@ -14,7 +14,7 @@
     "url": "https://github.com/fitchmultz/pi-local-agents-only/issues"
   },
   "homepage": "https://github.com/fitchmultz/pi-local-agents-only#readme",
-  "files": ["extensions", "README.md"],
+  "files": ["extensions", "README.md", "LICENSE"],
   "pi": {
     "extensions": ["./extensions"]
   },