@promptscript/cli 1.5.0 → 1.6.0

package/index.js

@@ -19761,20 +19761,20 @@ var init_factory = __esm({
         return commands;
       }
       generateCommandFile(config) {
-        const factoryConfig = config;
+        const factoryConfig2 = config;
         const lines = [];
         lines.push("---");
-        lines.push(`description: ${this.yamlString(factoryConfig.description)}`);
-        if (factoryConfig.agent) {
-          lines.push(`agent: ${factoryConfig.agent}`);
+        lines.push(`description: ${this.yamlString(factoryConfig2.description)}`);
+        if (factoryConfig2.agent) {
+          lines.push(`agent: ${factoryConfig2.agent}`);
         }
-        if (factoryConfig.tools && factoryConfig.tools.length > 0) {
-          const toolsArray = factoryConfig.tools.map((t) => `'${t}'`).join(", ");
+        if (factoryConfig2.tools && factoryConfig2.tools.length > 0) {
+          const toolsArray = factoryConfig2.tools.map((t) => `'${t}'`).join(", ");
           lines.push(`tools: [${toolsArray}]`);
         }
-        if (factoryConfig.handoffs && factoryConfig.handoffs.length > 0) {
+        if (factoryConfig2.handoffs && factoryConfig2.handoffs.length > 0) {
           lines.push("handoffs: ");
-          for (const handoff of factoryConfig.handoffs) {
+          for (const handoff of factoryConfig2.handoffs) {
             lines.push(`  - label: ${this.yamlString(handoff.label)}`);
             lines.push(`    agent: ${handoff.agent}`);
             if (handoff.prompt) {
@@ -19787,12 +19787,12 @@ var init_factory = __esm({
         }
         lines.push("---");
         lines.push("");
-        if (factoryConfig.content) {
-          const dedentedContent = this.dedent(factoryConfig.content);
+        if (factoryConfig2.content) {
+          const dedentedContent = this.dedent(factoryConfig2.content);
           lines.push(dedentedContent);
         }
         return {
-          path: `.factory/commands/${factoryConfig.name}.md`,
+          path: `.factory/commands/${factoryConfig2.name}.md`,
           content: lines.join("\n") + "\n"
         };
       }
@@ -19825,30 +19825,30 @@ var init_factory = __esm({
         return skills;
       }
       generateSkillFile(config) {
-        const factoryConfig = config;
+        const factoryConfig2 = config;
         const lines = [];
-        const skillName = factoryConfig.name.replace(/\./g, "-");
+        const skillName = factoryConfig2.name.replace(/\./g, "-");
         lines.push("---");
         lines.push(`name: ${skillName}`);
-        lines.push(`description: ${this.yamlString(factoryConfig.description)}`);
-        if (factoryConfig.userInvocable === false) {
+        lines.push(`description: ${this.yamlString(factoryConfig2.description)}`);
+        if (factoryConfig2.userInvocable === false) {
           lines.push("user-invocable: false");
         }
-        if (factoryConfig.disableModelInvocation === true) {
+        if (factoryConfig2.disableModelInvocation === true) {
           lines.push("disable-model-invocation: true");
         }
-        if (factoryConfig.allowedTools && factoryConfig.allowedTools.length > 0) {
-          const toolsArray = factoryConfig.allowedTools.map((t) => `"${t}"`).join(", ");
+        if (factoryConfig2.allowedTools && factoryConfig2.allowedTools.length > 0) {
+          const toolsArray = factoryConfig2.allowedTools.map((t) => `"${t}"`).join(", ");
           lines.push(`allowed-tools: [${toolsArray}]`);
         }
         lines.push("---");
         lines.push("");
-        if (factoryConfig.content) {
-          const dedentedContent = this.dedent(factoryConfig.content);
+        if (factoryConfig2.content) {
+          const dedentedContent = this.dedent(factoryConfig2.content);
           lines.push(dedentedContent);
         }
-        const skillDirPath = `.factory/skills/${factoryConfig.name}`;
-        const resourceFiles = this.sanitizeResourceFiles(factoryConfig.resources, skillDirPath);
+        const skillDirPath = `.factory/skills/${factoryConfig2.name}`;
+        const resourceFiles = this.sanitizeResourceFiles(factoryConfig2.resources, skillDirPath);
         return {
           path: `${skillDirPath}/SKILL.md`,
           content: lines.join("\n") + "\n",
@@ -21991,6 +21991,9 @@ async function initCommand(options, services = createDefaultServices()) {
         }
       }
     }
+    ConsoleOutput.muted(
+      "\n  Tip: Run prs hooks install to set up auto-compilation hooks for your AI tools.\n"
+    );
   } catch (error) {
     if (error instanceof Error && error.name === "ExitPromptError") {
       ConsoleOutput.newline();
@@ -23622,9 +23625,9 @@ var require_rate_limit = __commonJS({
       let ttl = 0;
       let ttlInSeconds = 0;
       try {
-        const res = await new Promise((resolve17, reject2) => {
+        const res = await new Promise((resolve18, reject2) => {
           store.incr(key, (err, res2) => {
-            err ? reject2(err) : resolve17(res2);
+            err ? reject2(err) : resolve18(res2);
           }, timeWindow, max);
         });
         current = res.current;
@@ -23730,13 +23733,13 @@ var init_health = __esm({
 });
 
 // packages/server/src/source-dirs.ts
-import { readFile as readFile18 } from "fs/promises";
-import { join as join19, dirname as dirname10 } from "path";
+import { readFile as readFile20 } from "fs/promises";
+import { join as join20, dirname as dirname11 } from "path";
 import { parse as parseYaml12 } from "yaml";
 async function readProjectConfig(workspace) {
   for (const filename of CONFIG_FILENAMES) {
     try {
-      const raw = await readFile18(join19(workspace, filename), "utf-8");
+      const raw = await readFile20(join20(workspace, filename), "utf-8");
       const config = parseYaml12(raw);
       if (config) return config;
     } catch {
@@ -23747,10 +23750,10 @@ async function readProjectConfig(workspace) {
 async function resolveSourceDir(workspace) {
   for (const filename of CONFIG_FILENAMES) {
     try {
-      const raw = await readFile18(join19(workspace, filename), "utf-8");
+      const raw = await readFile20(join20(workspace, filename), "utf-8");
       const config = parseYaml12(raw);
       if (config?.input?.entry) {
-        return dirname10(config.input.entry);
+        return dirname11(config.input.entry);
       }
     } catch {
     }
@@ -23764,9 +23767,9 @@ async function resolveFileGlobs(workspace) {
 async function resolveWatchPaths(workspace) {
   const sourceDir = await resolveSourceDir(workspace);
   return [
-    join19(workspace, sourceDir),
-    join19(workspace, "promptscript.yaml"),
-    join19(workspace, "promptscript.yml")
+    join20(workspace, sourceDir),
+    join20(workspace, "promptscript.yaml"),
+    join20(workspace, "promptscript.yml")
   ];
 }
 var DEFAULT_SOURCE_DIR, CONFIG_FILENAMES;
@@ -23793,13 +23796,13 @@ var init_config2 = __esm({
 });
 
 // packages/server/src/path-guard.ts
-import { resolve as resolve16, relative as relative2, isAbsolute as isAbsolute4 } from "path";
+import { resolve as resolve17, relative as relative2, isAbsolute as isAbsolute4 } from "path";
 function resolveSafePath(workspace, requestedPath) {
   const decoded = decodeURIComponent(requestedPath);
   if (isAbsolute4(decoded)) {
     throw new PathTraversalError(requestedPath);
   }
-  const resolved = resolve16(workspace, decoded);
+  const resolved = resolve17(workspace, decoded);
   const rel = relative2(workspace, resolved);
   if (rel.startsWith("..") || isAbsolute4(rel)) {
     throw new PathTraversalError(requestedPath);
@@ -23820,8 +23823,8 @@ var init_path_guard = __esm({
 });
 
 // packages/server/src/routes/files.ts
-import { readFile as readFile19, writeFile as writeFile10, unlink, stat as stat2, mkdir as mkdir8 } from "fs/promises";
-import { dirname as dirname11 } from "path";
+import { readFile as readFile21, writeFile as writeFile11, unlink as unlink2, stat as stat2, mkdir as mkdir9 } from "fs/promises";
+import { dirname as dirname12 } from "path";
 import fg from "fast-glob";
 function registerRoutes(app, workspace, readOnly) {
   app.get("/api/files", async () => {
@@ -23841,7 +23844,7 @@ function registerRoutes(app, workspace, readOnly) {
     const filePath = request.params["*"];
     try {
       const resolved = resolveSafePath(workspace, filePath);
-      const content = await readFile19(resolved, "utf-8");
+      const content = await readFile21(resolved, "utf-8");
       return { path: filePath, content };
     } catch (err) {
       if (err instanceof PathTraversalError) {
@@ -23858,7 +23861,7 @@ function registerRoutes(app, workspace, readOnly) {
       const filePath = request.params["*"];
       try {
         const resolved = resolveSafePath(workspace, filePath);
-        await writeFile10(resolved, request.body.content, "utf-8");
+        await writeFile11(resolved, request.body.content, "utf-8");
         return { path: filePath, status: "updated" };
       } catch (err) {
         if (err instanceof PathTraversalError) {
@@ -23881,8 +23884,8 @@ function registerRoutes(app, workspace, readOnly) {
           return reply.status(409).send({ error: "File already exists" });
         } catch {
         }
-        await mkdir8(dirname11(resolved), { recursive: true });
-        await writeFile10(resolved, request.body.content, "utf-8");
+        await mkdir9(dirname12(resolved), { recursive: true });
+        await writeFile11(resolved, request.body.content, "utf-8");
         return reply.status(201).send({ path: filePath, status: "created" });
       } catch (err) {
         if (err instanceof PathTraversalError) {
@@ -23897,7 +23900,7 @@ function registerRoutes(app, workspace, readOnly) {
     const filePath = request.params["*"];
     try {
       const resolved = resolveSafePath(workspace, filePath);
-      await unlink(resolved);
+      await unlink2(resolved);
       return { path: filePath, status: "deleted" };
     } catch (err) {
       if (err instanceof PathTraversalError) {
@@ -24107,7 +24110,7 @@ init_src();
 init_init();
 import { Command } from "commander";
 import { fileURLToPath as fileURLToPath4 } from "url";
-import { dirname as dirname12 } from "path";
+import { dirname as dirname13 } from "path";
 
 // packages/cli/src/commands/compile.ts
 init_src();
@@ -27460,7 +27463,7 @@ var HttpRegistry = class {
    * Sleep for specified milliseconds.
    */
   sleep(ms) {
-    return new Promise((resolve17) => setTimeout(resolve17, ms));
+    return new Promise((resolve18) => setTimeout(resolve18, ms));
   }
   /**
    * Fetch with timeout.
@@ -29938,15 +29941,15 @@ var SECURITY_STRICT_MULTILINGUAL = {
 };
 
 // packages/compiler/src/compiler.ts
-function generateHtmlMarker() {
+function generateHtmlMarker(source, target) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  return `<!-- PromptScript ${timestamp} - do not edit -->`;
+  return `<!-- PromptScript ${timestamp} | source: ${source} | target: ${target} - do not edit -->`;
 }
-function generateYamlMarker() {
+function generateYamlMarker(source, target) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  return `# promptscript-generated: ${timestamp}`;
+  return `# promptscript-generated: ${timestamp} | source: ${source} | target: ${target}`;
 }
-function addMarkerToOutput(output) {
+function addMarkerToOutput(output, source, target) {
   const { content, path } = output;
   if (content.includes("<!-- PromptScript") || content.includes("# promptscript-generated:")) {
     return output;
@@ -29959,11 +29962,11 @@ function addMarkerToOutput(output) {
     if (closingIndex !== -1) {
       const afterOpening = content.slice(3);
       const newContent = `---
-${generateYamlMarker()}${afterOpening}`;
+${generateYamlMarker(source, target)}${afterOpening}`;
       return { ...output, content: newContent };
     }
   }
-  const marker = generateHtmlMarker();
+  const marker = generateHtmlMarker(source, target);
   const lines = content.split("\n");
   if (lines[0]?.startsWith("# ")) {
     lines.splice(1, 0, "", marker);
@@ -30077,7 +30080,7 @@ var Compiler = class _Compiler {
           });
         }
         outputPathOwners.set(output.path, formatter.name);
-        outputs.set(output.path, addMarkerToOutput(output));
+        outputs.set(output.path, addMarkerToOutput(output, entryPath, formatter.name));
         if (output.additionalFiles) {
           const queue = [...output.additionalFiles];
           while (queue.length > 0) {
@@ -30098,7 +30101,10 @@ var Compiler = class _Compiler {
               continue;
             }
             outputPathOwners.set(additionalFile.path, formatter.name);
-            outputs.set(additionalFile.path, addMarkerToOutput(additionalFile));
+            outputs.set(
+              additionalFile.path,
+              addMarkerToOutput(additionalFile, entryPath, formatter.name)
+            );
             if (additionalFile.additionalFiles) {
               queue.push(...additionalFile.additionalFiles);
             }
@@ -30123,13 +30129,19 @@ var Compiler = class _Compiler {
         const skillPath = `${skillBasePath}/promptscript/${skillFileName}`;
         const existingOwner = outputPathOwners.get(skillPath);
         if (existingOwner) {
-          formatWarnings.push({
-            ruleId: "PS4001",
-            ruleName: "output-path-collision",
-            severity: "warning",
-            message: `Output path '${skillPath}' is already written by '${existingOwner}'. Skipping auto-injected PromptScript skill for '${formatter.name}'.`,
-            suggestion: `The user-defined skill takes precedence. To use the bundled skill, remove the custom one or rename it.`
-          });
+          if (existingOwner !== formatter.name) {
+            formatWarnings.push({
+              ruleId: "PS4001",
+              ruleName: "output-path-collision",
+              severity: "warning",
+              message: `Output path '${skillPath}' is already written by '${existingOwner}'. Skipping auto-injected PromptScript skill for '${formatter.name}'.`,
+              suggestion: `The user-defined skill takes precedence. To use the bundled skill, remove the custom one or rename it.`
+            });
+          } else {
+            this.logger.debug(
+              `  Skill path '${skillPath}' already output by '${formatter.name}' (auto-discovered). Skipping auto-injection.`
+            );
+          }
           continue;
         }
         outputPathOwners.set(skillPath, `${formatter.name}:promptscript-skill`);
@@ -30137,7 +30149,7 @@ var Compiler = class _Compiler {
           path: skillPath,
           content: this.options.skillContent
         };
-        outputs.set(skillPath, addMarkerToOutput(skillOutput));
+        outputs.set(skillPath, addMarkerToOutput(skillOutput, entryPath, "promptscript"));
         this.logger.verbose(`  \u2192 ${skillPath} (auto-injected promptscript skill)`);
       }
     }
@@ -30216,12 +30228,12 @@ var Compiler = class _Compiler {
    */
   async watch(entryPath, options = {}) {
     const { default: chokidar2 } = await import("chokidar");
-    const { dirname: dirname13, resolve: resolve17 } = await import("path");
-    const baseDir = dirname13(resolve17(entryPath));
+    const { dirname: dirname14, resolve: resolve18 } = await import("path");
+    const baseDir = dirname14(resolve18(entryPath));
     const includePatterns = options.include ?? ["**/*.prs"];
     const excludePatterns = options.exclude ?? ["**/node_modules/**"];
     const debounceMs = options.debounce ?? 300;
-    const watchPatterns = includePatterns.map((p) => resolve17(baseDir, p));
+    const watchPatterns = includePatterns.map((p) => resolve18(baseDir, p));
     let debounceTimer = null;
     let pendingChanges = [];
     const handleChange = async (changedFiles) => {
@@ -30395,7 +30407,7 @@ var Pager = class {
       }
       return;
     }
-    return new Promise((resolve17) => {
+    return new Promise((resolve18) => {
       const pagerCmd = getPagerCommand();
       const [cmd, ...args] = pagerCmd.split(" ");
       if (cmd === "less" && !args.includes("-R")) {
@@ -30403,7 +30415,7 @@ var Pager = class {
       }
       if (!cmd) {
         console.log(content);
-        resolve17();
+        resolve18();
         return;
       }
       const pager = spawn(cmd, args, {
@@ -30416,17 +30428,17 @@ var Pager = class {
       });
       pager.on("error", (_err) => {
         console.log(content);
-        resolve17();
+        resolve18();
       });
       pager.on("close", () => {
-        resolve17();
+        resolve18();
       });
       if (pager.stdin) {
         pager.stdin.write(content);
         pager.stdin.end();
       } else {
         console.log(content);
-        resolve17();
+        resolve18();
       }
     });
   }
@@ -33126,9 +33138,837 @@ async function upgradeCommand(options) {
 ${upgradedCount} file(s) ${verb}, ${skippedCount} skipped.`);
 }
 
+// packages/cli/src/hooks/extract-file-path.ts
+function extractFilePath(input2) {
+  if (typeof input2 !== "object" || input2 === null) return null;
+  const obj = input2;
+  const toolInput = obj["tool_input"];
+  if (typeof toolInput === "object" && toolInput !== null) {
+    const filePath = toolInput["file_path"];
+    if (typeof filePath === "string") return filePath;
+  }
+  const toolName = obj["tool_name"];
+  if (typeof toolName === "string" && /^write_|^edit_/.test(toolName)) {
+    const args = obj["arguments"];
+    if (typeof args === "object" && args !== null) {
+      const filePath = args["file_path"];
+      if (typeof filePath === "string") return filePath;
+    }
+  }
+  if (typeof obj["filePath"] === "string") return obj["filePath"];
+  if (typeof obj["file_path"] === "string" && !toolInput) return obj["file_path"];
+  if (typeof obj["file"] === "string") return obj["file"];
+  return null;
+}
+
+// packages/cli/src/hooks/detect-marker.ts
+import { readFile as readFile18 } from "node:fs/promises";
+var MARKER_PATTERNS = [
+  "<!-- PromptScript",
+  "# promptscript-generated:",
+  "> Auto-generated by PromptScript"
+];
+var SOURCE_TARGET_RE = /\|\s*source:\s*(\S+)\s*\|\s*target:\s*(\S+)/;
+async function detectMarker(filePath) {
+  let content;
+  try {
+    content = await readFile18(filePath, "utf-8");
+  } catch {
+    return { isGenerated: false, source: null, target: null };
+  }
+  const lines = content.split("\n").slice(0, 50);
+  for (const line of lines) {
+    if (MARKER_PATTERNS.some((pattern) => line.includes(pattern))) {
+      const match = SOURCE_TARGET_RE.exec(line);
+      return {
+        isGenerated: true,
+        source: match?.[1] ?? null,
+        target: match?.[2] ?? null
+      };
+    }
+  }
+  return { isGenerated: false, source: null, target: null };
+}
+
+// packages/cli/src/hooks/debounce-lock.ts
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync as existsSync21, writeFileSync as writeFileSync4, unlinkSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join19 } from "node:path";
+var STALE_THRESHOLD_MS = 3e4;
+function getLockPath(projectDir) {
+  const hash = createHash2("md5").update(projectDir).digest("hex").slice(0, 12);
+  return join19(tmpdir(), `prs-compile-${hash}.lock`);
+}
+function acquireLock(projectDir) {
+  const lockPath = getLockPath(projectDir);
+  if (existsSync21(lockPath)) {
+    try {
+      const stat3 = statSync(lockPath);
+      const age = Date.now() - stat3.mtimeMs;
+      if (age < STALE_THRESHOLD_MS) return false;
+      unlinkSync(lockPath);
+    } catch {
+    }
+  }
+  try {
+    writeFileSync4(lockPath, String(process.pid), { flag: "wx" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function releaseLock(projectDir) {
+  try {
+    unlinkSync(getLockPath(projectDir));
+  } catch {
+  }
+}
+
+// packages/cli/src/commands/hook.ts
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+function parseInput(raw) {
+  if (raw.trim() === "") return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    return parsed;
+  } catch {
+    process.exitCode = 1;
+    process.stderr.write("prs hook: malformed JSON on stdin\n");
+    return null;
+  }
+}
+async function handlePreEdit(payload) {
+  const filePath = extractFilePath(payload);
+  if (!filePath) return;
+  const marker = await detectMarker(filePath);
+  if (!marker.isGenerated) return;
+  process.exitCode = 2;
+  if (marker.source) {
+    process.stderr.write(
+      `prs hook: ${filePath} is generated by PromptScript from ${marker.source} \u2014 edit the source instead
+`
+    );
+  } else {
+    process.stderr.write(
+      `prs hook: ${filePath} is generated by PromptScript \u2014 run prs compile after editing the source
+`
+    );
+  }
+}
+async function handlePostEdit(payload) {
+  const filePath = extractFilePath(payload);
+  if (!filePath) return;
+  if (!filePath.endsWith(".prs")) return;
+  const cwd = typeof payload["cwd"] === "string" ? payload["cwd"] : process.cwd();
+  if (!acquireLock(cwd)) return;
+  try {
+    await compileCommand({ cwd });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`prs hook: compile error: ${message}
+`);
+  } finally {
+    releaseLock(cwd);
+  }
+}
+async function hookCommand(action, internalOpts) {
+  const raw = internalOpts?.stdin !== void 0 ? internalOpts.stdin : await readStdin();
+  const payload = parseInput(raw);
+  if (!payload) return;
+  switch (action) {
+    case "pre-edit":
+      await handlePreEdit(payload);
+      break;
+    case "post-edit":
+      await handlePostEdit(payload);
+      break;
+    default:
+      process.exitCode = 1;
+      process.stderr.write(`prs hook: unknown action "${action}"
+`);
+  }
+}
+
+// packages/cli/src/commands/hooks.ts
+init_console();
+import { existsSync as existsSync22 } from "node:fs";
+import { readFile as readFile19, writeFile as writeFile10, mkdir as mkdir8, chmod, unlink } from "node:fs/promises";
+import { dirname as dirname10, resolve as resolve16 } from "node:path";
+
+// packages/cli/src/hooks/tool-configs/claude.ts
+function isPrsHookEntry(entry) {
+  if (typeof entry !== "object" || entry === null) {
+    return false;
+  }
+  const obj = entry;
+  const hooks = obj["hooks"];
+  if (!Array.isArray(hooks)) {
+    return false;
+  }
+  return hooks.some((h) => {
+    if (typeof h !== "object" || h === null) return false;
+    const hook = h;
+    return typeof hook["command"] === "string" && hook["command"].includes("prs hook");
+  });
+}
+function getHooksSection(existing) {
+  const hooks = existing["hooks"];
+  if (typeof hooks === "object" && hooks !== null && !Array.isArray(hooks)) {
+    return hooks;
+  }
+  return {};
+}
+function getHookArray(hooksSection, key) {
+  const arr = hooksSection[key];
+  return Array.isArray(arr) ? arr : [];
+}
+var claudeConfig = {
+  name: "claude",
+  detectPaths: [".claude"],
+  settingsPath: ".claude/settings.json",
+  timeoutUnit: "seconds",
+  generatePreEditHook(prsPath) {
+    return {
+      matcher: "Edit|Write",
+      hooks: [
+        {
+          type: "command",
+          command: `${prsPath} hook pre-edit`,
+          timeout: 5,
+          statusMessage: "PromptScript: checking generated files..."
+        }
+      ]
+    };
+  },
+  generatePostEditHook(prsPath) {
+    return {
+      matcher: "Edit|Write",
+      hooks: [
+        {
+          type: "command",
+          command: `${prsPath} hook post-edit`,
+          timeout: 15,
+          statusMessage: "PromptScript: compiling..."
+        }
+      ]
+    };
+  },
+  mergeIntoSettings(existing, prsPath) {
+    const hooksSection = getHooksSection(existing);
+    const preToolUse = getHookArray(hooksSection, "PreToolUse");
+    const postToolUse = getHookArray(hooksSection, "PostToolUse");
+    const preAlreadyInstalled = preToolUse.some(isPrsHookEntry);
+    const postAlreadyInstalled = postToolUse.some(isPrsHookEntry);
+    const newPreToolUse = preAlreadyInstalled ? preToolUse : [...preToolUse, this.generatePreEditHook(prsPath)];
+    const newPostToolUse = postAlreadyInstalled ? postToolUse : [...postToolUse, this.generatePostEditHook(prsPath)];
+    return {
+      ...existing,
+      hooks: {
+        ...hooksSection,
+        PreToolUse: newPreToolUse,
+        PostToolUse: newPostToolUse
+      }
+    };
+  },
+  removeFromSettings(existing) {
+    const hooksSection = getHooksSection(existing);
+    const preToolUse = getHookArray(hooksSection, "PreToolUse");
+    const postToolUse = getHookArray(hooksSection, "PostToolUse");
+    return {
+      ...existing,
+      hooks: {
+        ...hooksSection,
+        PreToolUse: preToolUse.filter((e) => !isPrsHookEntry(e)),
+        PostToolUse: postToolUse.filter((e) => !isPrsHookEntry(e))
+      }
+    };
+  }
+};
+
+// packages/cli/src/hooks/tool-configs/factory.ts
+function getHooksSection2(existing) {
+  const hooks = existing["hooks"];
+  if (typeof hooks === "object" && hooks !== null && !Array.isArray(hooks)) {
+    return hooks;
+  }
+  return {};
+}
+function getHookArray2(hooksSection, key) {
+  const arr = hooksSection[key];
+  return Array.isArray(arr) ? arr : [];
+}
+var factoryConfig = {
+  name: "factory",
+  detectPaths: [".factory"],
+  settingsPath: ".factory/settings.json",
+  timeoutUnit: "seconds",
+  generatePreEditHook(prsPath) {
+    return {
+      matcher: "Create|Edit",
+      hooks: [
+        {
+          type: "command",
+          command: `${prsPath} hook pre-edit`,
+          timeout: 5,
+          statusMessage: "PromptScript: checking generated files..."
+        }
+      ]
+    };
+  },
+  generatePostEditHook(prsPath) {
+    return {
+      matcher: "Create|Edit",
+      hooks: [
+        {
+          type: "command",
+          command: `${prsPath} hook post-edit`,
+          timeout: 15,
+          statusMessage: "PromptScript: compiling..."
+        }
+      ]
+    };
+  },
+  mergeIntoSettings(existing, prsPath) {
+    const hooksSection = getHooksSection2(existing);
+    const preToolUse = getHookArray2(hooksSection, "PreToolUse");
+    const postToolUse = getHookArray2(hooksSection, "PostToolUse");
+    const newPreToolUse = preToolUse.some(isPrsHookEntry) ? preToolUse : [...preToolUse, this.generatePreEditHook(prsPath)];
+    const newPostToolUse = postToolUse.some(isPrsHookEntry) ? postToolUse : [...postToolUse, this.generatePostEditHook(prsPath)];
+    return {
+      ...existing,
+      hooks: {
+        ...hooksSection,
+        PreToolUse: newPreToolUse,
+        PostToolUse: newPostToolUse
+      }
+    };
+  },
+  removeFromSettings(existing) {
+    const hooksSection = getHooksSection2(existing);
+    const preToolUse = getHookArray2(hooksSection, "PreToolUse");
+    const postToolUse = getHookArray2(hooksSection, "PostToolUse");
+    return {
+      ...existing,
+      hooks: {
+        ...hooksSection,
+        PreToolUse: preToolUse.filter((e) => !isPrsHookEntry(e)),
+        PostToolUse: postToolUse.filter((e) => !isPrsHookEntry(e))
+      }
+    };
+  }
+};
+
+// packages/cli/src/hooks/tool-configs/cursor.ts
+function getHooksSection3(existing) {
+  const hooks = existing["hooks"];
+  if (typeof hooks === "object" && hooks !== null && !Array.isArray(hooks)) {
+    return hooks;
+  }
+  return {};
+}
+function getHookArray3(hooksSection, key) {
+  const arr = hooksSection[key];
+  return Array.isArray(arr) ? arr : [];
+}
+function isPrsCursorHookEntry(entry) {
+  if (typeof entry !== "object" || entry === null) {
+    return false;
+  }
+  const obj = entry;
+  const command = obj["command"];
+  if (!Array.isArray(command)) {
+    return false;
+  }
+  return command.some((part) => typeof part === "string" && part.includes("prs hook"));
+}
+var cursorConfig = {
+  name: "cursor",
+  detectPaths: [".cursor"],
+  settingsPath: ".cursor/hooks.json",
+  timeoutUnit: "milliseconds",
+  generatePreEditHook(prsPath) {
+    return {
+      hooks: {
+        beforeFileEdit: [
+          {
+            command: ["bash", "-c", `${prsPath} hook pre-edit`],
+            timeout_ms: 5e3
+          }
+        ]
+      }
+    };
+  },
+  generatePostEditHook(prsPath) {
+    return {
+      hooks: {
+        afterFileEdit: [
+          {
+            command: ["bash", "-c", `${prsPath} hook post-edit`],
+            timeout_ms: 15e3
+          }
+        ]
+      }
+    };
+  },
+  mergeIntoSettings(existing, prsPath) {
+    const hooksSection = getHooksSection3(existing);
+    const beforeFileEdit = getHookArray3(hooksSection, "beforeFileEdit");
+    const afterFileEdit = getHookArray3(hooksSection, "afterFileEdit");
+    const newBeforeFileEdit = beforeFileEdit.some(isPrsCursorHookEntry) ? beforeFileEdit : [
+      ...beforeFileEdit,
+      {
+        command: ["bash", "-c", `${prsPath} hook pre-edit`],
+        timeout_ms: 5e3
+      }
+    ];
+    const newAfterFileEdit = afterFileEdit.some(isPrsCursorHookEntry) ? afterFileEdit : [
+      ...afterFileEdit,
+      {
+        command: ["bash", "-c", `${prsPath} hook post-edit`],
+        timeout_ms: 15e3
+      }
+    ];
+    return {
+      ...existing,
+      hooks: {
+        ...hooksSection,
+        beforeFileEdit: newBeforeFileEdit,
+        afterFileEdit: newAfterFileEdit
+      }
+    };
+  },
+  removeFromSettings(existing) {
+    const hooksSection = getHooksSection3(existing);
+    const beforeFileEdit = getHookArray3(hooksSection, "beforeFileEdit");
+    const afterFileEdit = getHookArray3(hooksSection, "afterFileEdit");
+    return {
+      ...existing,
+      hooks: {
+        ...hooksSection,
+        beforeFileEdit: beforeFileEdit.filter((e) => !isPrsCursorHookEntry(e)),
+        afterFileEdit: afterFileEdit.filter((e) => !isPrsCursorHookEntry(e))
+      }
+    };
+  }
+};
+
+// packages/cli/src/hooks/tool-configs/windsurf.ts
+function getHooksSection4(existing) {
+  const hooks = existing["hooks"];
+  if (typeof hooks === "object" && hooks !== null && !Array.isArray(hooks)) {
+    return hooks;
+  }
+  return {};
+}
+function getHookArray4(hooksSection, key) {
+  const arr = hooksSection[key];
+  return Array.isArray(arr) ? arr : [];
+}
+var windsurfConfig = {
+  name: "windsurf",
+  detectPaths: [".windsurf"],
+  settingsPath: ".windsurf/hooks.json",
+  timeoutUnit: "milliseconds",
+  generatePreEditHook(prsPath) {
+    return {
+      matcher: "Edit|Write",
+      hooks: [
+        {
+          type: "command",
+          command: `${prsPath} hook pre-edit`,
+          timeout: 5e3,
+          statusMessage: "PromptScript: checking generated files..."
+        }
+      ]
+    };
+  },
+  generatePostEditHook(prsPath) {
+    return {
+      matcher: "Edit|Write",
+      hooks: [
+        {
+          type: "command",
+          command: `${prsPath} hook post-edit`,
+          timeout: 15e3,
+          statusMessage: "PromptScript: compiling..."
+        }
+      ]
+    };
+  },
+  mergeIntoSettings(existing, prsPath) {
+    const hooksSection = getHooksSection4(existing);
+    const preWriteCode = getHookArray4(hooksSection, "pre_write_code");
+    const postWriteCode = getHookArray4(hooksSection, "post_write_code");
+    const newPreWriteCode = preWriteCode.some(isPrsHookEntry) ? preWriteCode : [...preWriteCode, this.generatePreEditHook(prsPath)];
+    const newPostWriteCode = postWriteCode.some(isPrsHookEntry) ? postWriteCode : [...postWriteCode, this.generatePostEditHook(prsPath)];
+    return {
+      ...existing,
+      hooks: {
+        ...hooksSection,
+        pre_write_code: newPreWriteCode,
+        post_write_code: newPostWriteCode
+      }
+    };
+  },
+  removeFromSettings(existing) {
+    const hooksSection = getHooksSection4(existing);
+    const preWriteCode = getHookArray4(hooksSection, "pre_write_code");
+    const postWriteCode = getHookArray4(hooksSection, "post_write_code");
+    return {
+      ...existing,
+      hooks: {
+        ...hooksSection,
+        pre_write_code: preWriteCode.filter((e) => !isPrsHookEntry(e)),
+        post_write_code: postWriteCode.filter((e) => !isPrsHookEntry(e))
+      }
+    };
+  }
+};
+
+// packages/cli/src/hooks/tool-configs/cline.ts
+var clineConfig = {
+  name: "cline",
+  detectPaths: [".clinerules"],
+  settingsPath: ".clinerules/hooks/",
+  timeoutUnit: "n/a",
+  generatePreEditHook(prsPath) {
+    return {
+      scriptPath: ".clinerules/hooks/prs-pre-edit.sh",
+      content: `#!/bin/bash
+${prsPath} hook pre-edit`
+    };
+  },
+  generatePostEditHook(prsPath) {
+    return {
+      scriptPath: ".clinerules/hooks/prs-post-edit.sh",
+      content: `#!/bin/bash
+${prsPath} hook post-edit`
+    };
+  },
+  mergeIntoSettings(existing, _prsPath) {
+    return existing;
+  },
+  removeFromSettings(existing) {
+    return existing;
+  }
+};
+
+// packages/cli/src/hooks/tool-configs/copilot.ts
+function getHooksSection5(existing) {
+  const hooks = existing["hooks"];
+  if (typeof hooks === "object" && hooks !== null && !Array.isArray(hooks)) {
+    return hooks;
+  }
+  return {};
+}
+function getHookArray5(hooksSection, key) {
+  const arr = hooksSection[key];
+  return Array.isArray(arr) ? arr : [];
+}
+var copilotConfig = {
+  name: "copilot",
+  detectPaths: [".vscode", ".github/copilot-instructions.md"],
+  settingsPath: ".vscode/hooks.json",
+  timeoutUnit: "seconds",
+  generatePreEditHook(prsPath) {
+    return {
+      matcher: "Edit|Write",
+      hooks: [
+        {
+          type: "command",
+          command: `${prsPath} hook pre-edit`,
+          timeout: 5,
+          statusMessage: "PromptScript: checking generated files..."
+        }
+      ]
+    };
+  },
+  generatePostEditHook(prsPath) {
+    return {
+      matcher: "Edit|Write",
+      hooks: [
+        {
+          type: "command",
+          command: `${prsPath} hook post-edit`,
+          timeout: 15,
+          statusMessage: "PromptScript: compiling..."
+        }
+      ]
+    };
+  },
+  mergeIntoSettings(existing, prsPath) {
+    const hooksSection = getHooksSection5(existing);
+    const preToolUse = getHookArray5(hooksSection, "PreToolUse");
+    const postToolUse = getHookArray5(hooksSection, "PostToolUse");
+    const newPreToolUse = preToolUse.some(isPrsHookEntry) ? preToolUse : [...preToolUse, this.generatePreEditHook(prsPath)];
+    const newPostToolUse = postToolUse.some(isPrsHookEntry) ? postToolUse : [...postToolUse, this.generatePostEditHook(prsPath)];
+    return {
+      ...existing,
+      hooks: {
+        ...hooksSection,
+        PreToolUse: newPreToolUse,
+        PostToolUse: newPostToolUse
+      }
+    };
+  },
+  removeFromSettings(existing) {
+    const hooksSection = getHooksSection5(existing);
+    const preToolUse = getHookArray5(hooksSection, "PreToolUse");
+    const postToolUse = getHookArray5(hooksSection, "PostToolUse");
+    return {
+      ...existing,
+      hooks: {
+        ...hooksSection,
+        PreToolUse: preToolUse.filter((e) => !isPrsHookEntry(e)),
+        PostToolUse: postToolUse.filter((e) => !isPrsHookEntry(e))
+      }
+    };
+  }
+};
+
+// packages/cli/src/hooks/tool-configs/gemini.ts
+function getHooksSection6(existing) {
+  const hooks = existing["hooks"];
+  if (typeof hooks === "object" && hooks !== null && !Array.isArray(hooks)) {
+    return hooks;
+  }
+  return {};
+}
+function getHookArray6(hooksSection, key) {
+  const arr = hooksSection[key];
+  return Array.isArray(arr) ? arr : [];
+}
+function isPrsGeminiHookEntry(entry) {
+  if (typeof entry !== "object" || entry === null) {
+    return false;
+  }
+  const obj = entry;
+  const hooks = obj["hooks"];
+  if (!Array.isArray(hooks)) {
+    return false;
+  }
+  return hooks.some((h) => {
+    if (typeof h !== "object" || h === null) return false;
+    const hook = h;
+    return typeof hook["command"] === "string" && hook["command"].includes("prs hook");
+  });
+}
+var geminiConfig = {
+  name: "gemini",
+  detectPaths: [".gemini"],
+  settingsPath: ".gemini/settings.json",
+  timeoutUnit: "milliseconds",
+  generatePreEditHook(prsPath) {
+    return {
+      matcher: "write_.*|edit_.*",
+      hooks: [
+        {
+          type: "command",
+          command: `${prsPath} hook pre-edit`,
+          timeout: 5e3
+        }
+      ]
+    };
+  },
+  generatePostEditHook(prsPath) {
+    return {
+      matcher: "write_.*|edit_.*",
+      hooks: [
+        {
+          type: "command",
+          command: `${prsPath} hook post-edit`,
+          timeout: 15e3
+        }
+      ]
+    };
+  },
+  mergeIntoSettings(existing, prsPath) {
+    const hooksSection = getHooksSection6(existing);
+    const beforeTool = getHookArray6(hooksSection, "BeforeTool");
+    const afterTool = getHookArray6(hooksSection, "AfterTool");
+    const newBeforeTool = beforeTool.some(isPrsGeminiHookEntry) ? beforeTool : [...beforeTool, this.generatePreEditHook(prsPath)];
+    const newAfterTool = afterTool.some(isPrsGeminiHookEntry) ? afterTool : [...afterTool, this.generatePostEditHook(prsPath)];
+    return {
+      ...existing,
+      hooks: {
+        ...hooksSection,
+        BeforeTool: newBeforeTool,
+        AfterTool: newAfterTool
+      }
+    };
+  },
+  removeFromSettings(existing) {
+    const hooksSection = getHooksSection6(existing);
+    const beforeTool = getHookArray6(hooksSection, "BeforeTool");
+    const afterTool = getHookArray6(hooksSection, "AfterTool");
+    return {
+      ...existing,
+      hooks: {
+        ...hooksSection,
+        BeforeTool: beforeTool.filter((e) => !isPrsGeminiHookEntry(e)),
+        AfterTool: afterTool.filter((e) => !isPrsGeminiHookEntry(e))
+      }
+    };
+  }
+};
+
+// packages/cli/src/hooks/tool-configs/index.ts
+var ALL_TOOL_CONFIGS = [
+  claudeConfig,
+  factoryConfig,
+  cursorConfig,
+  windsurfConfig,
+  clineConfig,
+  copilotConfig,
+  geminiConfig
+];
+function getToolConfig(name) {
+  return ALL_TOOL_CONFIGS.find((c) => c.name === name);
+}
+
+// packages/cli/src/commands/hooks.ts
+function resolvePrsPath() {
+  const scriptPath = process.argv[1];
+  if (scriptPath && !scriptPath.includes("node_modules/.bin") && !scriptPath.includes("pnpm")) {
+    return scriptPath;
+  }
+  if (scriptPath) {
+    ConsoleOutput.warning(
+      `Detected ephemeral script path (${scriptPath}), using bare "prs" instead`
+    );
+  }
+  return "prs";
+}
+function detectTools() {
+  const cwd = process.cwd();
+  return ALL_TOOL_CONFIGS.filter(
+    (config) => config.detectPaths.some((p) => existsSync22(resolve16(cwd, p)))
+  );
+}
+async function readSettingsFile(path) {
+  try {
+    const content = await readFile19(path, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+async function writeSettingsFile(path, data) {
+  await mkdir8(dirname10(path), { recursive: true });
+  await writeFile10(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+function settingsUnchanged(original, merged) {
+  return JSON.stringify(original) === JSON.stringify(merged);
+}
+async function installForTool(config, prsPath) {
+  const cwd = process.cwd();
+  const settingsPath = resolve16(cwd, config.settingsPath);
+  if (config.name === "cline") {
+    await installCline(config, prsPath, cwd);
+    return;
+  }
+  const existing = await readSettingsFile(settingsPath);
+  const merged = config.mergeIntoSettings(existing, prsPath);
+  if (settingsUnchanged(existing, merged)) {
+    ConsoleOutput.info(`${config.name}: hooks already installed`);
+    return;
+  }
+  await writeSettingsFile(settingsPath, merged);
+  ConsoleOutput.success(`${config.name}: hooks installed (${config.settingsPath})`);
+}
+async function installCline(config, prsPath, cwd) {
+  const preHook = config.generatePreEditHook(prsPath);
+  const postHook = config.generatePostEditHook(prsPath);
+  for (const hook of [preHook, postHook]) {
+    const fullPath = resolve16(cwd, hook.scriptPath);
+    await mkdir8(dirname10(fullPath), { recursive: true });
+    await writeFile10(fullPath, hook.content, "utf-8");
+    await chmod(fullPath, 493);
+  }
+  ConsoleOutput.success(`${config.name}: hooks installed`);
+}
+async function uninstallForTool(config) {
+  const cwd = process.cwd();
+  const settingsPath = resolve16(cwd, config.settingsPath);
+  if (config.name === "cline") {
+    await uninstallCline(config, cwd);
+    return;
+  }
+  let existing;
+  try {
+    const content = await readFile19(settingsPath, "utf-8");
+    existing = JSON.parse(content);
+  } catch {
+    ConsoleOutput.info(`${config.name}: hooks not installed (no settings file)`);
+    return;
+  }
+  const cleaned = config.removeFromSettings(existing);
+  await writeSettingsFile(settingsPath, cleaned);
+  ConsoleOutput.success(`${config.name}: hooks uninstalled`);
+}
+async function uninstallCline(config, cwd) {
+  const prsPath = "prs";
+  const preHook = config.generatePreEditHook(prsPath);
+  const postHook = config.generatePostEditHook(prsPath);
+  for (const hook of [preHook, postHook]) {
+    const fullPath = resolve16(cwd, hook.scriptPath);
+    if (existsSync22(fullPath)) {
+      await unlink(fullPath);
+    }
+  }
+  ConsoleOutput.success(`${config.name}: hooks uninstalled`);
+}
+function resolveTools(tool, _options) {
+  if (tool) {
+    const config = getToolConfig(tool);
+    if (!config) {
+      ConsoleOutput.error(
+        `Unknown tool "${tool}". Available: ${ALL_TOOL_CONFIGS.map((c) => c.name).join(", ")}`
+      );
+      process.exitCode = 1;
+      return null;
+    }
+    return [config];
+  }
+  const detected = detectTools();
+  if (detected.length === 0) {
+    ConsoleOutput.error(
+      "No AI tools detected. Specify a tool name or create the tool config directory first."
+    );
+    process.exitCode = 1;
+    return null;
+  }
+  return detected;
+}
+async function hooksCommand(action, tool, options = {}) {
+  if (action !== "install" && action !== "uninstall") {
+    ConsoleOutput.error(`Unknown action "${action}". Use "install" or "uninstall".`);
+    process.exitCode = 1;
+    return;
+  }
+  const tools = resolveTools(tool, options);
+  if (!tools) return;
+  const prsPath = resolvePrsPath();
+  for (const config of tools) {
+    if (action === "install") {
+      await installForTool(config, prsPath);
+    } else {
+      await uninstallForTool(config);
+    }
+  }
+}
+
 // packages/cli/src/cli.ts
 var __filename4 = fileURLToPath4(import.meta.url);
-var __dirname4 = dirname12(__filename4);
+var __dirname4 = dirname13(__filename4);
 var program = new Command();
 program.name("prs").description("PromptScript CLI - Standardize AI instructions").version(getPackageVersion(__dirname3, "./package.json")).option("--verbose", "Enable verbose output").option("--debug", "Enable debug output (includes verbose)").option("--quiet", "Suppress non-error output").hook("preAction", async (thisCommand, actionCommand) => {
   const opts = thisCommand.opts();
@@ -33182,6 +34022,8 @@ var vendor = program.command("vendor").description("Manage vendored dependencies
 vendor.command("sync").description("Copy all cached dependencies to .promptscript/vendor/").option("--dry-run", "Preview without copying files").action((opts) => vendorSyncCommand(opts));
 vendor.command("check").description("Verify vendor directory matches lockfile").action((opts) => vendorCheckCommand(opts));
 program.command("resolve <import>").description("Show full resolution chain for an import path (debug)").action((importPath, opts) => resolveCommand(importPath, opts));
+program.command("hook").argument("<action>", "Hook action: pre-edit or post-edit").description("Hook handler invoked by AI tools (not for direct use)").action(hookCommand);
+program.command("hooks").argument("<action>", "Action: install or uninstall").argument("[tool]", "Tool: claude, gemini, copilot, cursor, windsurf, factory, cline").option("--all", "Install/uninstall for all detected tools").description("Manage PromptScript hooks for AI tools").action(hooksCommand);
 var registry = program.command("registry").description("Manage PromptScript registries");
 registerRegistryCommands(registry);
 function run(args = process.argv) {