@promptcellar/pc 0.6.0 → 0.7.0

package/hooks/amazonq-capture.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+/**
+ * Amazon Q Developer CLI hook for capturing prompts to Prompt Cellar.
+ *
+ * Amazon Q userPromptSubmit hooks receive JSON via stdin with
+ * prompt and session context.
+ */
+
+import { readStdin, runCapture } from './lib/capture-pipeline.js';
+
+async function main() {
+  try {
+    const input = await readStdin();
+    if (!input.trim()) process.exit(0);
+
+    const event = JSON.parse(input);
+    const prompt = event.prompt?.trim();
+    if (!prompt) process.exit(0);
+
+    await runCapture({
+      toolName: 'amazon-q',
+      prompt,
+      cwd: event.cwd,
+      sessionId: event.session_id,
+    });
+  } catch {
+    // Fail silently
+  }
+  process.exit(0);
+}
+
+main();

package/hooks/codex-capture.js

@@ -15,11 +15,8 @@
  * state tracking to avoid duplicates.
  */
 
-import { capturePrompt } from '../src/lib/api.js';
-import { getFullContext, collectContextFileContents } from '../src/lib/context.js';
-import { isLoggedIn, isVaultAvailable } from '../src/lib/config.js';
+import { checkAuth, getVaultKey, buildContext, buildContextFiles, submitCapture } from './lib/capture-pipeline.js';
 import { encryptPrompt } from '../src/lib/crypto.js';
-import { requireVaultKey } from '../src/lib/keychain.js';
 import { getLastCapturedIndex, saveLastCapturedIndex, cleanupStaleThreads } from '../src/lib/state.js';
 
 function extractContent(message) {
@@ -35,96 +32,57 @@ function extractContent(message) {
 }
 
 async function main() {
-  // Codex passes JSON as first argument
   const jsonArg = process.argv[2];
-
-  if (!jsonArg) {
-    process.exit(0);
-  }
-
-  if (!isLoggedIn()) {
-    process.exit(0);
-  }
-
-  if (!isVaultAvailable()) {
-    process.exit(0);
-  }
+  if (!jsonArg) process.exit(0);
+  if (!checkAuth()) process.exit(0);
 
   try {
     const event = JSON.parse(jsonArg);
-
-    // Only capture on agent-turn-complete
-    if (event.type !== 'agent-turn-complete') {
-      process.exit(0);
-    }
+    if (event.type !== 'agent-turn-complete') process.exit(0);
 
     const inputMessages = event['input-messages'] || [];
-    if (inputMessages.length === 0) {
-      process.exit(0);
-    }
-
     const threadId = event['thread-id'];
-    if (!threadId) {
-      process.exit(0);
-    }
+    if (!inputMessages.length || !threadId) process.exit(0);
 
-    // Clean up stale threads periodically
     cleanupStaleThreads();
 
-    // Get last captured index to avoid duplicates
     const lastIndex = getLastCapturedIndex(threadId);
     const newMessages = inputMessages.slice(lastIndex);
+    if (!newMessages.length) process.exit(0);
 
-    if (newMessages.length === 0) {
-      process.exit(0);
-    }
+    const vaultKey = await getVaultKey();
+    if (!vaultKey) process.exit(0);
 
-    const vaultKey = await requireVaultKey({ silent: true });
-    if (!vaultKey) {
-      process.exit(0);
-    }
+    const effectiveCwd = event.cwd || process.cwd();
 
-    // Collect and encrypt context files once for the session
+    // Encrypt context files once for all messages in this batch
     let encrypted_context_files, context_files_iv;
-    const contextFileContents = collectContextFileContents('codex', event.cwd || process.cwd());
+    const contextFileContents = buildContextFiles('codex', effectiveCwd);
     if (contextFileContents) {
       const enc = encryptPrompt(JSON.stringify(contextFileContents), vaultKey);
       encrypted_context_files = enc.encrypted_content;
       context_files_iv = enc.content_iv;
     }
 
-    // Capture each new message
     for (const message of newMessages) {
       const content = extractContent(message);
-      if (!content || !content.trim()) {
-        continue;
-      }
+      if (!content?.trim()) continue;
 
       const promptText = content.trim();
-      const context = getFullContext('codex', null, {
-        cwd: event.cwd || process.cwd(),
+      const context = buildContext('codex', {
+        cwd: effectiveCwd,
         sessionId: threadId,
         promptText,
       });
 
-      const { encrypted_content, content_iv } = encryptPrompt(promptText, vaultKey);
-
-      await capturePrompt({
-        ...context,
-        encrypted_content,
-        content_iv,
-        encrypted_context_files,
-        context_files_iv,
-      });
+      await submitCapture({ context, prompt: promptText, vaultKey, encrypted_context_files, context_files_iv });
     }
 
-    // Update state with new index
     saveLastCapturedIndex(threadId, inputMessages.length);
-
   } catch {
     // Fail silently to not disrupt Codex
-    process.exit(0);
   }
+  process.exit(0);
 }
 
 main();

package/hooks/copilot-capture.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+/**
+ * GitHub Copilot CLI hook for capturing prompts to Prompt Cellar.
+ *
+ * Copilot userPromptSubmitted hooks receive JSON via stdin with
+ * prompt and session context.
+ */
+
+import { readStdin, runCapture } from './lib/capture-pipeline.js';
+
+async function main() {
+  try {
+    const input = await readStdin();
+    if (!input.trim()) process.exit(0);
+
+    const event = JSON.parse(input);
+    const prompt = event.prompt?.trim();
+    if (!prompt) process.exit(0);
+
+    await runCapture({
+      toolName: 'copilot',
+      prompt,
+      cwd: event.cwd,
+      sessionId: event.session_id,
+    });
+  } catch {
+    // Fail silently
+  }
+  process.exit(0);
+}
+
+main();

package/hooks/cursor-capture.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+
+/**
+ * Cursor IDE hook for capturing prompts to Prompt Cellar.
+ *
+ * Cursor hooks receive JSON via stdin with prompt and session context.
+ */
+
+import { readStdin, runCapture } from './lib/capture-pipeline.js';
+
+async function main() {
+  try {
+    const input = await readStdin();
+    if (!input.trim()) process.exit(0);
+
+    const event = JSON.parse(input);
+    const prompt = event.prompt?.trim();
+    if (!prompt) process.exit(0);
+
+    await runCapture({
+      toolName: 'cursor',
+      prompt,
+      cwd: event.cwd,
+      sessionId: event.session_id,
+    });
+  } catch {
+    // Fail silently
+  }
+  process.exit(0);
+}
+
+main();

package/hooks/gemini-capture.js

@@ -15,97 +15,33 @@
  * Return {} for pass-through, or { decision: "block", reason: "..." } to block.
  */
 
-import { capturePrompt } from '../src/lib/api.js';
-import { getFullContext, collectContextFileContents } from '../src/lib/context.js';
-import { isLoggedIn, isVaultAvailable } from '../src/lib/config.js';
-import { encryptPrompt } from '../src/lib/crypto.js';
-import { requireVaultKey } from '../src/lib/keychain.js';
-
-async function readStdin() {
-  return new Promise((resolve) => {
-    let data = '';
-    process.stdin.setEncoding('utf8');
-    process.stdin.on('data', chunk => data += chunk);
-    process.stdin.on('end', () => resolve(data));
-
-    // Timeout after 1 second if no input
-    setTimeout(() => resolve(data), 1000);
-  });
-}
+import { readStdin, runCapture } from './lib/capture-pipeline.js';
 
 function respond() {
-  // Gemini expects JSON output; empty object means pass-through
   console.log('{}');
 }
 
 async function main() {
   try {
     const input = await readStdin();
-
-    if (!input.trim()) {
-      respond();
-      process.exit(0);
-    }
-
-    if (!isLoggedIn()) {
-      respond();
-      process.exit(0);
-    }
-
-    if (!isVaultAvailable()) {
-      respond();
-      process.exit(0);
-    }
+    if (!input.trim()) { respond(); process.exit(0); }
 
     const event = JSON.parse(input);
+    const prompt = event.prompt?.trim();
+    if (!prompt) { respond(); process.exit(0); }
 
-    // Extract the user's prompt
-    if (!event.prompt) {
-      respond();
-      process.exit(0);
-    }
-
-    const content = event.prompt.trim();
-    if (!content) {
-      respond();
-      process.exit(0);
-    }
-
-    // Build context
-    const context = getFullContext('gemini', null, {
-      cwd: event.cwd || process.cwd(),
+    await runCapture({
+      toolName: 'gemini',
+      prompt,
+      cwd: event.cwd,
       sessionId: event.session_id,
-      promptText: content,
-    });
-
-    const vaultKey = await requireVaultKey({ silent: true });
-    if (!vaultKey) {
-      respond();
-      process.exit(0);
-    }
-    const { encrypted_content, content_iv } = encryptPrompt(content, vaultKey);
-
-    let encrypted_context_files, context_files_iv;
-    const contextFileContents = collectContextFileContents('gemini', event.cwd || process.cwd());
-    if (contextFileContents) {
-      const enc = encryptPrompt(JSON.stringify(contextFileContents), vaultKey);
-      encrypted_context_files = enc.encrypted_content;
-      context_files_iv = enc.content_iv;
-    }
-
-    await capturePrompt({
-      ...context,
-      encrypted_content,
-      content_iv,
-      encrypted_context_files,
-      context_files_iv,
     });
 
     respond();
-  } catch (error) {
-    // Still respond successfully to not block Gemini
+  } catch {
     respond();
   }
+  process.exit(0);
 }
 
 main();

package/hooks/lib/capture-pipeline.js

@@ -0,0 +1,81 @@
+/**
+ * Shared capture pipeline for all hook scripts.
+ *
+ * Provides the common logic: login/vault validation, context building,
+ * encryption, and API capture. Each tool's hook script is a thin adapter
+ * that parses input and calls runCapture().
+ */
+
+import { capturePrompt } from '../../src/lib/api.js';
+import { getFullContext, collectContextFileContents } from '../../src/lib/context.js';
+import { isLoggedIn, isVaultAvailable } from '../../src/lib/config.js';
+import { encryptPrompt } from '../../src/lib/crypto.js';
+import { requireVaultKey } from '../../src/lib/keychain.js';
+
+export async function readStdin(timeoutMs = 1000) {
+  return new Promise((resolve) => {
+    let data = '';
+    const onData = chunk => data += chunk;
+    const onEnd = () => { cleanup(); resolve(data); };
+    const cleanup = () => {
+      process.stdin.removeListener('data', onData);
+      process.stdin.removeListener('end', onEnd);
+    };
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', onData);
+    process.stdin.on('end', onEnd);
+    setTimeout(() => { cleanup(); resolve(data); }, timeoutMs);
+  });
+}
+
+export function checkAuth() {
+  return isLoggedIn() && isVaultAvailable();
+}
+
+export async function getVaultKey() {
+  return requireVaultKey({ silent: true });
+}
+
+export function buildContext(toolName, { cwd, sessionId, promptText }) {
+  return getFullContext(toolName, null, { cwd, sessionId, promptText });
+}
+
+export function buildContextFiles(toolName, cwd) {
+  return collectContextFileContents(toolName, cwd);
+}
+
+export async function submitCapture({ context, prompt, vaultKey, encrypted_context_files, context_files_iv }) {
+  const { encrypted_content, content_iv } = encryptPrompt(prompt, vaultKey);
+  await capturePrompt({
+    ...context,
+    encrypted_content,
+    content_iv,
+    encrypted_context_files,
+    context_files_iv,
+  });
+}
+
+export async function runCapture({ toolName, prompt, cwd, sessionId }) {
+  if (!checkAuth()) return;
+
+  const effectiveCwd = cwd || process.cwd();
+
+  const context = buildContext(toolName, {
+    cwd: effectiveCwd,
+    sessionId,
+    promptText: prompt,
+  });
+
+  const vaultKey = await getVaultKey();
+  if (!vaultKey) return;
+
+  let encrypted_context_files, context_files_iv;
+  const contextFileContents = buildContextFiles(toolName, effectiveCwd);
+  if (contextFileContents) {
+    const enc = encryptPrompt(JSON.stringify(contextFileContents), vaultKey);
+    encrypted_context_files = enc.encrypted_content;
+    context_files_iv = enc.content_iv;
+  }
+
+  await submitCapture({ context, prompt, vaultKey, encrypted_context_files, context_files_iv });
+}

package/hooks/prompt-capture.js

@@ -10,84 +10,27 @@
  * - cwd: working directory
  */
 
-import { capturePrompt } from '../src/lib/api.js';
-import { getFullContext, collectContextFileContents } from '../src/lib/context.js';
-import { isLoggedIn, isVaultAvailable } from '../src/lib/config.js';
-import { encryptPrompt } from '../src/lib/crypto.js';
-import { requireVaultKey } from '../src/lib/keychain.js';
-
-async function readStdin() {
-  return new Promise((resolve) => {
-    let data = '';
-    process.stdin.setEncoding('utf8');
-    process.stdin.on('data', chunk => data += chunk);
-    process.stdin.on('end', () => resolve(data));
-
-    // Timeout after 1 second if no input
-    setTimeout(() => resolve(data), 1000);
-  });
-}
+import { readStdin, runCapture } from './lib/capture-pipeline.js';
 
 async function main() {
   try {
     const input = await readStdin();
-
-    if (!input.trim()) {
-      process.exit(0);
-    }
-
-    if (!isLoggedIn()) {
-      process.exit(0);
-    }
-
-    if (!isVaultAvailable()) {
-      process.exit(0);
-    }
+    if (!input.trim()) process.exit(0);
 
     const event = JSON.parse(input);
+    const prompt = event.prompt?.trim();
+    if (!prompt) process.exit(0);
 
-    // UserPromptSubmit provides the prompt directly
-    if (!event.prompt) {
-      process.exit(0);
-    }
-
-    const promptContent = event.prompt.trim();
-    if (!promptContent) {
-      process.exit(0);
-    }
-
-    const context = getFullContext('claude-code', null, {
-      cwd: event.cwd || process.cwd(),
+    await runCapture({
+      toolName: 'claude-code',
+      prompt,
+      cwd: event.cwd,
       sessionId: event.session_id,
-      promptText: promptContent,
-    });
-
-    const vaultKey = await requireVaultKey({ silent: true });
-    if (!vaultKey) {
-      process.exit(0);
-    }
-    const { encrypted_content, content_iv } = encryptPrompt(promptContent, vaultKey);
-
-    let encrypted_context_files, context_files_iv;
-    const contextFileContents = collectContextFileContents('claude-code', event.cwd || process.cwd());
-    if (contextFileContents) {
-      const enc = encryptPrompt(JSON.stringify(contextFileContents), vaultKey);
-      encrypted_context_files = enc.encrypted_content;
-      context_files_iv = enc.content_iv;
-    }
-
-    await capturePrompt({
-      ...context,
-      encrypted_content,
-      content_iv,
-      encrypted_context_files,
-      context_files_iv,
     });
-
   } catch {
     // Fail silently — stderr from hooks can cause issues
-    process.exit(0);
   }
+  process.exit(0);
 }
 
 main();

package/hooks/windsurf-capture.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+/**
+ * Windsurf IDE (Codeium) hook for capturing prompts to Prompt Cellar.
+ *
+ * Windsurf pre_user_prompt hooks receive JSON via stdin with prompt
+ * and session context including trajectory_id and execution_id.
+ */
+
+import { readStdin, runCapture } from './lib/capture-pipeline.js';
+
+async function main() {
+  try {
+    const input = await readStdin();
+    if (!input.trim()) process.exit(0);
+
+    const event = JSON.parse(input);
+    const prompt = event.prompt?.trim();
+    if (!prompt) process.exit(0);
+
+    await runCapture({
+      toolName: 'windsurf',
+      prompt,
+      cwd: event.cwd,
+      sessionId: event.session_id || event.trajectory_id,
+    });
+  } catch {
+    // Fail silently
+  }
+  process.exit(0);
+}
+
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@promptcellar/pc",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "CLI for Prompt Cellar - sync prompts between your terminal and the cloud",
   "type": "module",
   "main": "src/index.js",
@@ -8,7 +8,11 @@
     "pc": "bin/pc.js",
     "pc-capture": "hooks/prompt-capture.js",
     "pc-codex-capture": "hooks/codex-capture.js",
-    "pc-gemini-capture": "hooks/gemini-capture.js"
+    "pc-gemini-capture": "hooks/gemini-capture.js",
+    "pc-cursor-capture": "hooks/cursor-capture.js",
+    "pc-windsurf-capture": "hooks/windsurf-capture.js",
+    "pc-copilot-capture": "hooks/copilot-capture.js",
+    "pc-amazonq-capture": "hooks/amazonq-capture.js"
   },
   "scripts": {
     "test": "node --test"
@@ -21,7 +25,11 @@
     "llm",
     "claude",
     "codex",
-    "gemini"
+    "gemini",
+    "cursor",
+    "windsurf",
+    "copilot",
+    "amazon-q"
   ],
   "author": "Welded Anvil Technologies LLC",
   "license": "MIT",

package/src/commands/setup.js

@@ -1,6 +1,6 @@
 import inquirer from 'inquirer';
 import chalk from 'chalk';
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync } from 'fs';
 import { join, dirname } from 'path';
 import { homedir } from 'os';
 import { execFileSync } from 'child_process';
@@ -9,152 +9,138 @@ import { execFileSync } from 'child_process';
 const CLAUDE_SETTINGS_PATH = join(homedir(), '.claude', 'settings.json');
 const CODEX_CONFIG_PATH = join(homedir(), '.codex', 'config.toml');
 const GEMINI_SETTINGS_PATH = join(homedir(), '.gemini', 'settings.json');
+const CURSOR_HOOKS_PATH = join(homedir(), '.cursor', 'hooks.json');
+const WINDSURF_HOOKS_PATH = join(homedir(), '.codeium', 'windsurf', 'hooks.json');
+const COPILOT_HOOKS_DIR = join(homedir(), '.copilot', 'hooks');
+const COPILOT_HOOK_FILE = join(COPILOT_HOOKS_DIR, 'promptcellar-capture.json');
+const AMAZONQ_AGENTS_DIR = join(homedir(), '.aws', 'amazonq', 'cli-agents');
+const AMAZONQ_AGENT_FILE = join(AMAZONQ_AGENTS_DIR, 'promptcellar.json');
+
+// Hook script names
+const HOOK_SCRIPTS = {
+  claude: 'pc-capture',
+  codex: 'pc-codex-capture',
+  gemini: 'pc-gemini-capture',
+  cursor: 'pc-cursor-capture',
+  windsurf: 'pc-windsurf-capture',
+  copilot: 'pc-copilot-capture',
+  'amazon-q': 'pc-amazonq-capture',
+};
+
+// --- Shared helpers ---
+
+function readJsonConfig(path) {
+  if (existsSync(path)) {
+    try { return JSON.parse(readFileSync(path, 'utf8')); } catch { /* ignore */ }
+  }
+  return {};
+}
 
-const HOOK_SCRIPT_NAME = 'pc-capture';
-
-// Detect which tools are installed
-function detectInstalledTools() {
-  const tools = [];
-
-  // Check for Claude Code
-  try {
-    execFileSync('which', ['claude'], { stdio: 'pipe' });
-    tools.push('claude');
-  } catch { /* not installed */ }
+function writeConfigFile(filePath, content) {
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(filePath, typeof content === 'string' ? content : JSON.stringify(content, null, 2));
+}
 
-  // Check for Codex CLI
-  try {
-    execFileSync('which', ['codex'], { stdio: 'pipe' });
-    tools.push('codex');
-  } catch { /* not installed */ }
+async function confirmReinstall() {
+  const { reinstall } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'reinstall',
+    message: 'Reinstall the hook?',
+    default: false
+  }]);
+  return reinstall;
+}
 
-  // Check for Gemini CLI
+function isCommandAvailable(cmd) {
   try {
-    execFileSync('which', ['gemini'], { stdio: 'pipe' });
-    tools.push('gemini');
-  } catch { /* not installed */ }
-
-  return tools;
+    execFileSync('which', [cmd], { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
 }
 
-// Claude Code settings (hooks are in settings.json under "hooks" key)
-function getClaudeSettings() {
-  if (existsSync(CLAUDE_SETTINGS_PATH)) {
-    try {
-      return JSON.parse(readFileSync(CLAUDE_SETTINGS_PATH, 'utf8'));
-    } catch {
-      return {};
-    }
-  }
-  return {};
+function hasJsonHook(config, eventKey, scriptName) {
+  const matchers = config.hooks?.[eventKey] || [];
+  return matchers.some(m => m.hooks?.some(h => h.command?.includes(scriptName)));
 }
 
-function saveClaudeSettings(settings) {
-  const dir = dirname(CLAUDE_SETTINGS_PATH);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
+function removeJsonHook(config, eventKey, scriptName) {
+  if (config.hooks?.[eventKey]) {
+    config.hooks[eventKey] = config.hooks[eventKey].filter(m =>
+      !m.hooks?.some(h => h.command?.includes(scriptName))
+    );
   }
-  writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2));
 }
 
-function isClaudeHookInstalled(settings) {
-  const matchers = settings.hooks?.UserPromptSubmit || [];
-  return matchers.some(matcher =>
-    matcher.hooks?.some(hook => hook.command?.includes(HOOK_SCRIPT_NAME))
-  );
+function addJsonHook(config, eventKey, hookEntry) {
+  if (!config.hooks) config.hooks = {};
+  if (!config.hooks[eventKey]) config.hooks[eventKey] = [];
+  config.hooks[eventKey].push(hookEntry);
 }
 
-// Check for legacy Stop hook (pre-0.5.0)
-function hasLegacyClaudeHook(settings) {
-  const stopMatchers = settings.hooks?.Stop || [];
-  return stopMatchers.some(matcher =>
-    matcher.hooks?.some(hook => hook.command?.includes(HOOK_SCRIPT_NAME))
-  );
-}
+// --- Tool detection ---
 
-// Remove legacy Stop hook if present
-function removeLegacyClaudeHook(settings) {
-  if (settings.hooks?.Stop) {
-    settings.hooks.Stop = settings.hooks.Stop.filter(matcher =>
-      !matcher.hooks?.some(hook => hook.command?.includes(HOOK_SCRIPT_NAME))
-    );
+function detectInstalledTools() {
+  const tools = [];
+  const simpleBinaries = [
+    { binary: 'claude', key: 'claude' },
+    { binary: 'codex', key: 'codex' },
+    { binary: 'gemini', key: 'gemini' },
+    { binary: 'cursor', key: 'cursor' },
+    { binary: 'windsurf', key: 'windsurf' },
+    { binary: 'q', key: 'amazon-q' },
+  ];
+
+  for (const { binary, key } of simpleBinaries) {
+    if (isCommandAvailable(binary)) tools.push(key);
   }
-}
 
-// Codex config (TOML)
-function getCodexConfig() {
-  if (existsSync(CODEX_CONFIG_PATH)) {
-    try {
-      return readFileSync(CODEX_CONFIG_PATH, 'utf8');
-    } catch {
-      return '';
-    }
+  // Copilot: gh binary + ~/.copilot directory
+  if (isCommandAvailable('gh') && existsSync(join(homedir(), '.copilot'))) {
+    tools.push('copilot');
   }
-  return '';
-}
 
-function isCodexHookInstalled(config) {
-  return config.includes('pc-codex-capture');
+  return tools;
 }
 
-function saveCodexConfig(content) {
-  const dir = dirname(CODEX_CONFIG_PATH);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  writeFileSync(CODEX_CONFIG_PATH, content);
-}
+// --- Codex (TOML — special case) ---
 
-// Gemini settings (JSON)
-function getGeminiSettings() {
-  if (existsSync(GEMINI_SETTINGS_PATH)) {
-    try {
-      return JSON.parse(readFileSync(GEMINI_SETTINGS_PATH, 'utf8'));
-    } catch {
-      return {};
-    }
+function getCodexConfig() {
+  if (existsSync(CODEX_CONFIG_PATH)) {
+    try { return readFileSync(CODEX_CONFIG_PATH, 'utf8'); } catch { return ''; }
   }
-  return {};
+  return '';
 }
 
-function isGeminiHookInstalled(settings) {
-  const hooks = settings.hooks?.BeforeAgent || [];
-  return hooks.some(h =>
-    h.hooks?.some(hook => hook.command?.includes('pc-gemini-capture'))
-  );
+function isCodexHookInstalled(config) {
+  return config.includes(HOOK_SCRIPTS.codex);
 }
 
-function saveGeminiSettings(settings) {
-  const dir = dirname(GEMINI_SETTINGS_PATH);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  writeFileSync(GEMINI_SETTINGS_PATH, JSON.stringify(settings, null, 2));
-}
+// --- Setup functions ---
 
 export async function setup() {
   console.log(chalk.bold('\nPrompt Cellar CLI Setup\n'));
 
   const installedTools = detectInstalledTools();
 
-  const tools = [
-    {
-      name: `Claude Code${installedTools.includes('claude') ? chalk.green(' (detected)') : ''}`,
-      value: 'claude',
-      checked: installedTools.includes('claude')
-    },
-    {
-      name: `Codex CLI${installedTools.includes('codex') ? chalk.green(' (detected)') : ''}`,
-      value: 'codex',
-      checked: installedTools.includes('codex')
-    },
-    {
-      name: `Gemini CLI${installedTools.includes('gemini') ? chalk.green(' (detected)') : ''}`,
-      value: 'gemini',
-      checked: installedTools.includes('gemini')
-    }
+  const toolDefs = [
+    { label: 'Claude Code', value: 'claude' },
+    { label: 'Codex CLI', value: 'codex' },
+    { label: 'Gemini CLI', value: 'gemini' },
+    { label: 'Cursor', value: 'cursor' },
+    { label: 'Windsurf', value: 'windsurf' },
+    { label: 'GitHub Copilot CLI', value: 'copilot' },
+    { label: 'Amazon Q Developer', value: 'amazon-q' },
   ];
 
+  const tools = toolDefs.map(t => ({
+    name: `${t.label}${installedTools.includes(t.value) ? chalk.green(' (detected)') : ''}`,
+    value: t.value,
+    checked: installedTools.includes(t.value),
+  }));
+
   const { selectedTools } = await inquirer.prompt([{
     type: 'checkbox',
     name: 'selectedTools',
@@ -167,14 +153,19 @@ export async function setup() {
     return;
   }
 
+  const setupFns = {
+    claude: setupClaudeCode,
+    codex: setupCodex,
+    gemini: setupGemini,
+    cursor: setupCursor,
+    windsurf: setupWindsurf,
+    copilot: setupCopilot,
+    'amazon-q': setupAmazonQ,
+  };
+
   for (const tool of selectedTools) {
-    if (tool === 'claude') {
-      await setupClaudeCode();
-    } else if (tool === 'codex') {
-      await setupCodex();
-    } else if (tool === 'gemini') {
-      await setupGemini();
-    }
+    const fn = setupFns[tool];
+    if (fn) await fn();
   }
 
   console.log(chalk.green('\nSetup complete!'));
@@ -184,59 +175,33 @@ export async function setup() {
 async function setupClaudeCode() {
   console.log(chalk.cyan('\nConfiguring Claude Code...'));
 
-  const settings = getClaudeSettings();
-  const hasLegacy = hasLegacyClaudeHook(settings);
-  const hasCurrent = isClaudeHookInstalled(settings);
+  const settings = readJsonConfig(CLAUDE_SETTINGS_PATH);
+  const script = HOOK_SCRIPTS.claude;
+  const hasLegacy = hasJsonHook(settings, 'Stop', script);
+  const hasCurrent = hasJsonHook(settings, 'UserPromptSubmit', script);
 
   if (hasCurrent) {
     console.log(chalk.yellow('  Hook already installed.'));
-
-    const { reinstall } = await inquirer.prompt([{
-      type: 'confirm',
-      name: 'reinstall',
-      message: 'Reinstall the hook?',
-      default: false
-    }]);
-
-    if (!reinstall) {
-      // Still remove legacy hook if present
+    if (!await confirmReinstall()) {
       if (hasLegacy) {
-        removeLegacyClaudeHook(settings);
-        saveClaudeSettings(settings);
+        removeJsonHook(settings, 'Stop', script);
+        writeConfigFile(CLAUDE_SETTINGS_PATH, settings);
         console.log(chalk.green('  Removed legacy Stop hook.'));
       }
       return;
     }
-
-    // Remove existing hook matchers that contain our hook
-    settings.hooks.UserPromptSubmit = (settings.hooks.UserPromptSubmit || []).filter(matcher =>
-      !matcher.hooks?.some(hook => hook.command?.includes(HOOK_SCRIPT_NAME))
-    );
+    removeJsonHook(settings, 'UserPromptSubmit', script);
   } else if (hasLegacy) {
     console.log(chalk.yellow('  Migrating from legacy Stop hook to UserPromptSubmit...'));
   }
 
-  // Always remove legacy Stop hook if present
-  removeLegacyClaudeHook(settings);
-
-  // Ensure hooks.UserPromptSubmit exists
-  if (!settings.hooks) {
-    settings.hooks = {};
-  }
-  if (!settings.hooks.UserPromptSubmit) {
-    settings.hooks.UserPromptSubmit = [];
-  }
-
-  // Add the UserPromptSubmit hook
-  settings.hooks.UserPromptSubmit.push({
+  removeJsonHook(settings, 'Stop', script);
+  addJsonHook(settings, 'UserPromptSubmit', {
     matcher: '*',
-    hooks: [{
-      type: 'command',
-      command: 'pc-capture'
-    }]
+    hooks: [{ type: 'command', command: script }]
   });
 
-  saveClaudeSettings(settings);
+  writeConfigFile(CLAUDE_SETTINGS_PATH, settings);
   console.log(chalk.green('  Hook installed successfully.'));
 }
 
@@ -244,35 +209,22 @@ async function setupCodex() {
   console.log(chalk.cyan('\nConfiguring Codex CLI...'));
 
   let config = getCodexConfig();
+  const script = HOOK_SCRIPTS.codex;
 
   if (isCodexHookInstalled(config)) {
     console.log(chalk.yellow('  Hook already installed.'));
+    if (!await confirmReinstall()) return;
 
-    const { reinstall } = await inquirer.prompt([{
-      type: 'confirm',
-      name: 'reinstall',
-      message: 'Reinstall the hook?',
-      default: false
-    }]);
-
-    if (!reinstall) {
-      return;
-    }
-
-    // Remove existing notify line and comment
     config = config.split('\n')
-      .filter(line => !line.includes('pc-codex-capture') && !line.includes('# Prompt Cellar capture hook'))
+      .filter(line => !line.includes(script) && !line.includes('# Prompt Cellar capture hook'))
       .join('\n');
   }
 
-  // Add the notify hook at root level (before any [table] sections)
-  const notifyLine = 'notify = ["pc-codex-capture"]';
+  const notifyLine = `notify = ["${script}"]`;
 
   if (config.match(/^notify\s*=/m)) {
-    // Replace existing root-level notify
     config = config.replace(/^notify\s*=.*$/m, notifyLine);
   } else {
-    // Insert at root level — before the first [table] section
     const firstTableMatch = config.match(/^\[/m);
     if (firstTableMatch) {
       const insertPos = firstTableMatch.index;
@@ -280,112 +232,174 @@ async function setupCodex() {
       const after = config.slice(insertPos);
       config = before + '\n\n# Prompt Cellar capture hook\n' + notifyLine + '\n\n' + after;
     } else {
-      // No table sections — safe to append
       config = config.trimEnd() + '\n\n# Prompt Cellar capture hook\n' + notifyLine + '\n';
     }
   }
 
-  saveCodexConfig(config);
+  writeConfigFile(CODEX_CONFIG_PATH, config);
   console.log(chalk.green('  Hook installed successfully.'));
 }
 
-async function setupGemini() {
-  console.log(chalk.cyan('\nConfiguring Gemini CLI...'));
+async function setupJsonHookTool({ label, configPath, eventKey, hookEntry, scriptName }) {
+  console.log(chalk.cyan(`\nConfiguring ${label}...`));
 
-  const settings = getGeminiSettings();
+  const config = readJsonConfig(configPath);
 
-  if (isGeminiHookInstalled(settings)) {
+  if (hasJsonHook(config, eventKey, scriptName)) {
     console.log(chalk.yellow('  Hook already installed.'));
+    if (!await confirmReinstall()) return;
+    removeJsonHook(config, eventKey, scriptName);
+  }
 
-    const { reinstall } = await inquirer.prompt([{
-      type: 'confirm',
-      name: 'reinstall',
-      message: 'Reinstall the hook?',
-      default: false
-    }]);
+  addJsonHook(config, eventKey, hookEntry);
+  writeConfigFile(configPath, config);
+  console.log(chalk.green('  Hook installed successfully.'));
+}
 
-    if (!reinstall) {
-      return;
-    }
+async function setupGemini() {
+  return setupJsonHookTool({
+    label: 'Gemini CLI',
+    configPath: GEMINI_SETTINGS_PATH,
+    eventKey: 'BeforeAgent',
+    scriptName: HOOK_SCRIPTS.gemini,
+    hookEntry: {
+      matcher: '*',
+      hooks: [{
+        name: 'promptcellar-capture',
+        type: 'command',
+        command: HOOK_SCRIPTS.gemini,
+        timeout: 5000
+      }]
+    },
+  });
+}
 
-    // Remove existing hook
-    if (settings.hooks?.BeforeAgent) {
-      settings.hooks.BeforeAgent = settings.hooks.BeforeAgent.filter(h =>
-        !h.hooks?.some(hook => hook.command?.includes('pc-gemini-capture'))
-      );
-    }
-  }
+async function setupCursor() {
+  return setupJsonHookTool({
+    label: 'Cursor',
+    configPath: CURSOR_HOOKS_PATH,
+    eventKey: 'UserPromptSubmit',
+    scriptName: HOOK_SCRIPTS.cursor,
+    hookEntry: {
+      matcher: '*',
+      hooks: [{ type: 'command', command: HOOK_SCRIPTS.cursor }]
+    },
+  });
+}
 
-  // Add the BeforeAgent hook
-  if (!settings.hooks) {
-    settings.hooks = {};
-  }
-  if (!settings.hooks.BeforeAgent) {
-    settings.hooks.BeforeAgent = [];
+async function setupWindsurf() {
+  return setupJsonHookTool({
+    label: 'Windsurf',
+    configPath: WINDSURF_HOOKS_PATH,
+    eventKey: 'pre_user_prompt',
+    scriptName: HOOK_SCRIPTS.windsurf,
+    hookEntry: {
+      matcher: '*',
+      hooks: [{ type: 'command', command: HOOK_SCRIPTS.windsurf }]
+    },
+  });
+}
+
+async function setupFileTool({ label, filePath, content }) {
+  console.log(chalk.cyan(`\nConfiguring ${label}...`));
+
+  if (existsSync(filePath)) {
+    console.log(chalk.yellow('  Hook already installed.'));
+    if (!await confirmReinstall()) return;
   }
 
-  settings.hooks.BeforeAgent.push({
-    matcher: '*',
-    hooks: [{
+  writeConfigFile(filePath, content);
+  console.log(chalk.green('  Hook installed successfully.'));
+}
+
+async function setupCopilot() {
+  return setupFileTool({
+    label: 'GitHub Copilot CLI',
+    filePath: COPILOT_HOOK_FILE,
+    content: {
       name: 'promptcellar-capture',
-      type: 'command',
-      command: 'pc-gemini-capture',
+      event: 'userPromptSubmitted',
+      command: HOOK_SCRIPTS.copilot,
       timeout: 5000
-    }]
+    },
   });
+}
 
-  saveGeminiSettings(settings);
-  console.log(chalk.green('  Hook installed successfully.'));
+async function setupAmazonQ() {
+  return setupFileTool({
+    label: 'Amazon Q Developer',
+    filePath: AMAZONQ_AGENT_FILE,
+    content: {
+      name: 'promptcellar',
+      hooks: {
+        userPromptSubmit: [{
+          command: HOOK_SCRIPTS['amazon-q'],
+          timeout_ms: 5000
+        }]
+      }
+    },
+  });
 }
 
+// --- Unsetup ---
+
 export async function unsetup() {
   console.log(chalk.bold('\nRemoving Prompt Cellar hooks...\n'));
 
   let removed = false;
 
-  // Remove Claude hook (both current and legacy)
-  const claudeSettings = getClaudeSettings();
-  const hasCurrent = isClaudeHookInstalled(claudeSettings);
-  const hasLegacy = hasLegacyClaudeHook(claudeSettings);
-
-  if (hasCurrent || hasLegacy) {
-    if (hasCurrent) {
-      claudeSettings.hooks.UserPromptSubmit = (claudeSettings.hooks.UserPromptSubmit || []).filter(matcher =>
-        !matcher.hooks?.some(hook => hook.command?.includes(HOOK_SCRIPT_NAME))
-      );
-    }
-    if (hasLegacy) {
-      removeLegacyClaudeHook(claudeSettings);
-    }
-    saveClaudeSettings(claudeSettings);
+  // Claude (both current and legacy)
+  const claudeSettings = readJsonConfig(CLAUDE_SETTINGS_PATH);
+  const claudeScript = HOOK_SCRIPTS.claude;
+  if (hasJsonHook(claudeSettings, 'UserPromptSubmit', claudeScript) || hasJsonHook(claudeSettings, 'Stop', claudeScript)) {
+    removeJsonHook(claudeSettings, 'UserPromptSubmit', claudeScript);
+    removeJsonHook(claudeSettings, 'Stop', claudeScript);
+    writeConfigFile(CLAUDE_SETTINGS_PATH, claudeSettings);
     console.log(chalk.green('  Removed Claude Code hook.'));
     removed = true;
   }
 
-  // Remove Codex hook
+  // Codex
   let codexConfig = getCodexConfig();
   if (isCodexHookInstalled(codexConfig)) {
     codexConfig = codexConfig.split('\n')
-      .filter(line => !line.includes('pc-codex-capture') && !line.includes('# Prompt Cellar capture hook'))
-      .join('\n');
-    // Clean up extra blank lines left behind
-    codexConfig = codexConfig.replace(/\n{3,}/g, '\n\n');
-    saveCodexConfig(codexConfig);
+      .filter(line => !line.includes(HOOK_SCRIPTS.codex) && !line.includes('# Prompt Cellar capture hook'))
+      .join('\n')
+      .replace(/\n{3,}/g, '\n\n');
+    writeConfigFile(CODEX_CONFIG_PATH, codexConfig);
     console.log(chalk.green('  Removed Codex CLI hook.'));
     removed = true;
   }
 
-  // Remove Gemini hook
-  const geminiSettings = getGeminiSettings();
-  if (isGeminiHookInstalled(geminiSettings)) {
-    if (geminiSettings.hooks?.BeforeAgent) {
-      geminiSettings.hooks.BeforeAgent = geminiSettings.hooks.BeforeAgent.filter(h =>
-        !h.hooks?.some(hook => hook.command?.includes('pc-gemini-capture'))
-      );
+  // JSON hook tools (Gemini, Cursor, Windsurf)
+  const jsonHookTools = [
+    { label: 'Gemini CLI', path: GEMINI_SETTINGS_PATH, eventKey: 'BeforeAgent', key: 'gemini' },
+    { label: 'Cursor', path: CURSOR_HOOKS_PATH, eventKey: 'UserPromptSubmit', key: 'cursor' },
+    { label: 'Windsurf', path: WINDSURF_HOOKS_PATH, eventKey: 'pre_user_prompt', key: 'windsurf' },
+  ];
+
+  for (const { label, path, eventKey, key } of jsonHookTools) {
+    const config = readJsonConfig(path);
+    if (hasJsonHook(config, eventKey, HOOK_SCRIPTS[key])) {
+      removeJsonHook(config, eventKey, HOOK_SCRIPTS[key]);
+      writeConfigFile(path, config);
+      console.log(chalk.green(`  Removed ${label} hook.`));
+      removed = true;
+    }
+  }
+
+  // File-based tools (Copilot, Amazon Q)
+  const fileTools = [
+    { label: 'GitHub Copilot CLI', path: COPILOT_HOOK_FILE },
+    { label: 'Amazon Q Developer', path: AMAZONQ_AGENT_FILE },
+  ];
+
+  for (const { label, path } of fileTools) {
+    if (existsSync(path)) {
+      try { unlinkSync(path); } catch { /* already removed */ }
+      console.log(chalk.green(`  Removed ${label} hook.`));
+      removed = true;
     }
-    saveGeminiSettings(geminiSettings);
-    console.log(chalk.green('  Removed Gemini CLI hook.'));
-    removed = true;
   }
 
   if (!removed) {