@promptcellar/pc 0.1.0 → 0.2.0

package/README.md

@@ -14,7 +14,7 @@ npm install -g @promptcellar/pc
 # Login with your API key
 pc login
 
-# Set up auto-capture for Claude Code
+# Set up auto-capture for your AI CLI tools
 pc setup
 
 # Check status
@@ -38,12 +38,15 @@ pc setup     # Configure auto-capture for CLI tools
 pc unsetup   # Remove auto-capture hooks
 ```
 
-Currently supports:
-- Claude Code (via Stop hooks)
+Supported tools (auto-detected during setup):
+- **Claude Code** - via Stop hooks
+- **Codex CLI** - via notify hook
+- **Gemini CLI** - via AfterAgent hook
 
 Coming soon:
 - Cursor
 - Windsurf
+- Aider
 
 ### Manual Capture
 

package/hooks/codex-capture.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+
+/**
+ * Codex CLI notify hook for capturing prompts to PromptCellar.
+ *
+ * Codex calls this script with a JSON argument containing:
+ * - type: event type (e.g., 'agent-turn-complete')
+ * - thread-id: session identifier
+ * - turn-id: turn identifier
+ * - cwd: working directory
+ * - input-messages: array of user messages
+ * - last-assistant-message: final assistant response
+ */
+
+import { capturePrompt } from '../src/lib/api.js';
+import { getFullContext } from '../src/lib/context.js';
+import { isLoggedIn } from '../src/lib/config.js';
+
+async function main() {
+  // Codex passes JSON as first argument
+  const jsonArg = process.argv[2];
+
+  if (!jsonArg) {
+    // No argument, nothing to do
+    process.exit(0);
+  }
+
+  if (!isLoggedIn()) {
+    // Silently exit if not logged in
+    process.exit(0);
+  }
+
+  try {
+    const event = JSON.parse(jsonArg);
+
+    // Only capture on agent-turn-complete
+    if (event.type !== 'agent-turn-complete') {
+      process.exit(0);
+    }
+
+    // Extract the user's input messages
+    const inputMessages = event['input-messages'] || [];
+    if (inputMessages.length === 0) {
+      process.exit(0);
+    }
+
+    // Get the first user message as the prompt
+    const userMessage = inputMessages.find(m => m.role === 'user');
+    if (!userMessage || !userMessage.content) {
+      process.exit(0);
+    }
+
+    // Extract content (handle both string and array formats)
+    let content = userMessage.content;
+    if (Array.isArray(content)) {
+      content = content
+        .filter(c => c.type === 'text')
+        .map(c => c.text)
+        .join('\n');
+    }
+
+    if (!content.trim()) {
+      process.exit(0);
+    }
+
+    // Build context
+    const context = getFullContext('codex');
+
+    // Override working directory if provided
+    if (event.cwd) {
+      context.working_directory = event.cwd;
+    }
+
+    // Add session info
+    if (event['thread-id']) {
+      context.session_id = event['thread-id'];
+    }
+
+    await capturePrompt({
+      content: content.trim(),
+      ...context
+    });
+
+  } catch (error) {
+    // Fail silently to not disrupt Codex
+    process.exit(0);
+  }
+}
+
+main();

package/hooks/gemini-capture.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+/**
+ * Gemini CLI AfterAgent hook for capturing prompts to PromptCellar.
+ *
+ * Gemini hooks receive JSON via stdin with:
+ * - event_type: the hook event (e.g., 'AfterAgent')
+ * - prompt: the user's prompt
+ * - prompt_response: the agent's response (for AfterAgent)
+ * - session_id: session identifier
+ * - working_directory: current working directory
+ *
+ * The hook must output valid JSON to stdout.
+ */
+
+import { capturePrompt } from '../src/lib/api.js';
+import { getFullContext } from '../src/lib/context.js';
+import { isLoggedIn } from '../src/lib/config.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);
+  });
+}
+
+function respond(success = true) {
+  // Gemini expects JSON output
+  const response = {
+    action: 'continue',
+    success
+  };
+  console.log(JSON.stringify(response));
+}
+
+async function main() {
+  try {
+    const input = await readStdin();
+
+    if (!input.trim()) {
+      respond(true);
+      process.exit(0);
+    }
+
+    if (!isLoggedIn()) {
+      respond(true);
+      process.exit(0);
+    }
+
+    const event = JSON.parse(input);
+
+    // Only capture AfterAgent events with a prompt
+    if (event.event_type !== 'AfterAgent' || !event.prompt) {
+      respond(true);
+      process.exit(0);
+    }
+
+    const content = event.prompt.trim();
+    if (!content) {
+      respond(true);
+      process.exit(0);
+    }
+
+    // Build context
+    const context = getFullContext('gemini');
+
+    // Override with event data if available
+    if (event.working_directory) {
+      context.working_directory = event.working_directory;
+    }
+    if (event.session_id) {
+      context.session_id = event.session_id;
+    }
+
+    await capturePrompt({
+      content,
+      ...context
+    });
+
+    respond(true);
+  } catch (error) {
+    // Still respond successfully to not block Gemini
+    respond(true);
+  }
+}
+
+main();

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@promptcellar/pc",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "CLI for PromptCellar - sync prompts between your terminal and the cloud",
   "type": "module",
   "main": "src/index.js",
   "bin": {
-    "pc": "bin/pc.js",
-    "pc-capture": "hooks/prompt-capture.js"
+    "pc": "./bin/pc.js",
+    "pc-capture": "./hooks/prompt-capture.js",
+    "pc-codex-capture": "./hooks/codex-capture.js",
+    "pc-gemini-capture": "./hooks/gemini-capture.js"
   },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"

package/src/commands/setup.js

@@ -3,11 +3,42 @@ import chalk from 'chalk';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join, dirname } from 'path';
 import { homedir } from 'os';
+import { execFileSync } from 'child_process';
 
+// Config paths
 const CLAUDE_HOOKS_PATH = join(homedir(), '.claude', 'hooks.json');
+const CODEX_CONFIG_PATH = join(homedir(), '.codex', 'config.toml');
+const GEMINI_SETTINGS_PATH = join(homedir(), '.gemini', 'settings.json');
+
 const HOOK_SCRIPT_NAME = 'pc-capture';
 
-function getHooksConfig() {
+// 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 */ }
+
+  // Check for Codex CLI
+  try {
+    execFileSync('which', ['codex'], { stdio: 'pipe' });
+    tools.push('codex');
+  } catch { /* not installed */ }
+
+  // Check for Gemini CLI
+  try {
+    execFileSync('which', ['gemini'], { stdio: 'pipe' });
+    tools.push('gemini');
+  } catch { /* not installed */ }
+
+  return tools;
+}
+
+// Claude Code hooks
+function getClaudeHooksConfig() {
   if (existsSync(CLAUDE_HOOKS_PATH)) {
     try {
       return JSON.parse(readFileSync(CLAUDE_HOOKS_PATH, 'utf8'));
@@ -18,7 +49,7 @@ function getHooksConfig() {
   return {};
 }
 
-function saveHooksConfig(config) {
+function saveClaudeHooksConfig(config) {
   const dir = dirname(CLAUDE_HOOKS_PATH);
   if (!existsSync(dir)) {
     mkdirSync(dir, { recursive: true });
@@ -26,20 +57,85 @@ function saveHooksConfig(config) {
   writeFileSync(CLAUDE_HOOKS_PATH, JSON.stringify(config, null, 2));
 }
 
-function isHookInstalled(config) {
+function isClaudeHookInstalled(config) {
   const stopHooks = config.Stop || [];
   return stopHooks.some(hook =>
     hook.command && hook.command.includes(HOOK_SCRIPT_NAME)
   );
 }
 
+// Codex config (TOML)
+function getCodexConfig() {
+  if (existsSync(CODEX_CONFIG_PATH)) {
+    try {
+      return readFileSync(CODEX_CONFIG_PATH, 'utf8');
+    } catch {
+      return '';
+    }
+  }
+  return '';
+}
+
+function isCodexHookInstalled(config) {
+  return config.includes('pc-codex-capture');
+}
+
+function saveCodexConfig(content) {
+  const dir = dirname(CODEX_CONFIG_PATH);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(CODEX_CONFIG_PATH, content);
+}
+
+// Gemini settings (JSON)
+function getGeminiSettings() {
+  if (existsSync(GEMINI_SETTINGS_PATH)) {
+    try {
+      return JSON.parse(readFileSync(GEMINI_SETTINGS_PATH, 'utf8'));
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+
+function isGeminiHookInstalled(settings) {
+  const hooks = settings.hooks?.AfterAgent || [];
+  return hooks.some(h =>
+    h.hooks?.some(hook => hook.command?.includes('pc-gemini-capture'))
+  );
+}
+
+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));
+}
+
 export async function setup() {
   console.log(chalk.bold('\nPromptCellar CLI Setup\n'));
 
+  const installedTools = detectInstalledTools();
+
   const tools = [
-    { name: 'Claude Code', value: 'claude', checked: true },
-    { name: 'Cursor (coming soon)', value: 'cursor', disabled: true },
-    { name: 'Windsurf (coming soon)', value: 'windsurf', disabled: true }
+    {
+      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 { selectedTools } = await inquirer.prompt([{
@@ -57,6 +153,10 @@ export async function setup() {
   for (const tool of selectedTools) {
     if (tool === 'claude') {
       await setupClaudeCode();
+    } else if (tool === 'codex') {
+      await setupCodex();
+    } else if (tool === 'gemini') {
+      await setupGemini();
     }
   }
 
@@ -67,9 +167,9 @@ export async function setup() {
 async function setupClaudeCode() {
   console.log(chalk.cyan('\nConfiguring Claude Code...'));
 
-  const config = getHooksConfig();
+  const config = getClaudeHooksConfig();
 
-  if (isHookInstalled(config)) {
+  if (isClaudeHookInstalled(config)) {
     console.log(chalk.yellow('  Hook already installed.'));
 
     const { reinstall } = await inquirer.prompt([{
@@ -99,26 +199,150 @@ async function setupClaudeCode() {
     description: 'Capture prompts to PromptCellar'
   });
 
-  saveHooksConfig(config);
+  saveClaudeHooksConfig(config);
+  console.log(chalk.green('  Hook installed successfully.'));
+}
+
+async function setupCodex() {
+  console.log(chalk.cyan('\nConfiguring Codex CLI...'));
+
+  let config = getCodexConfig();
+
+  if (isCodexHookInstalled(config)) {
+    console.log(chalk.yellow('  Hook already installed.'));
+
+    const { reinstall } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'reinstall',
+      message: 'Reinstall the hook?',
+      default: false
+    }]);
+
+    if (!reinstall) {
+      return;
+    }
+
+    // Remove existing notify line
+    config = config.split('\n')
+      .filter(line => !line.includes('pc-codex-capture'))
+      .join('\n');
+  }
+
+  // Add the notify hook
+  const notifyLine = 'notify = ["pc-codex-capture"]';
+
+  if (config.includes('notify')) {
+    // Replace existing notify
+    config = config.replace(/notify\s*=\s*\[.*\]/, notifyLine);
+  } else {
+    // Add new notify line
+    config = config.trim() + '\n\n# PromptCellar capture hook\n' + notifyLine + '\n';
+  }
+
+  saveCodexConfig(config);
+  console.log(chalk.green('  Hook installed successfully.'));
+}
+
+async function setupGemini() {
+  console.log(chalk.cyan('\nConfiguring Gemini CLI...'));
+
+  const settings = getGeminiSettings();
+
+  if (isGeminiHookInstalled(settings)) {
+    console.log(chalk.yellow('  Hook already installed.'));
+
+    const { reinstall } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'reinstall',
+      message: 'Reinstall the hook?',
+      default: false
+    }]);
+
+    if (!reinstall) {
+      return;
+    }
+
+    // Remove existing hook
+    if (settings.hooks?.AfterAgent) {
+      settings.hooks.AfterAgent = settings.hooks.AfterAgent.filter(h =>
+        !h.hooks?.some(hook => hook.command?.includes('pc-gemini-capture'))
+      );
+    }
+  }
+
+  // Ensure hooks are enabled
+  if (!settings.hooksConfig) {
+    settings.hooksConfig = {};
+  }
+  settings.hooksConfig.enabled = true;
+
+  // Add the AfterAgent hook
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+  if (!settings.hooks.AfterAgent) {
+    settings.hooks.AfterAgent = [];
+  }
+
+  settings.hooks.AfterAgent.push({
+    matcher: '*',
+    hooks: [{
+      name: 'promptcellar-capture',
+      type: 'command',
+      command: 'pc-gemini-capture',
+      timeout: 5000
+    }]
+  });
+
+  saveGeminiSettings(settings);
   console.log(chalk.green('  Hook installed successfully.'));
 }
 
 export async function unsetup() {
   console.log(chalk.bold('\nRemoving PromptCellar hooks...\n'));
 
-  const config = getHooksConfig();
+  let removed = false;
 
-  if (!isHookInstalled(config)) {
-    console.log(chalk.yellow('No hooks installed.'));
-    return;
+  // Remove Claude hook
+  const claudeConfig = getClaudeHooksConfig();
+  if (isClaudeHookInstalled(claudeConfig)) {
+    claudeConfig.Stop = (claudeConfig.Stop || []).filter(hook =>
+      !hook.command || !hook.command.includes(HOOK_SCRIPT_NAME)
+    );
+    saveClaudeHooksConfig(claudeConfig);
+    console.log(chalk.green('  Removed Claude Code hook.'));
+    removed = true;
   }
 
-  config.Stop = (config.Stop || []).filter(hook =>
-    !hook.command || !hook.command.includes(HOOK_SCRIPT_NAME)
-  );
+  // Remove Codex hook
+  let codexConfig = getCodexConfig();
+  if (isCodexHookInstalled(codexConfig)) {
+    codexConfig = codexConfig.split('\n')
+      .filter(line => !line.includes('pc-codex-capture') && !line.includes('# PromptCellar'))
+      .join('\n');
+    saveCodexConfig(codexConfig);
+    console.log(chalk.green('  Removed Codex CLI hook.'));
+    removed = true;
+  }
+
+  // Remove Gemini hook
+  const geminiSettings = getGeminiSettings();
+  if (isGeminiHookInstalled(geminiSettings)) {
+    if (geminiSettings.hooks?.AfterAgent) {
+      geminiSettings.hooks.AfterAgent = geminiSettings.hooks.AfterAgent.filter(h =>
+        !h.hooks?.some(hook => hook.command?.includes('pc-gemini-capture'))
+      );
+    }
+    saveGeminiSettings(geminiSettings);
+    console.log(chalk.green('  Removed Gemini CLI hook.'));
+    removed = true;
+  }
 
-  saveHooksConfig(config);
-  console.log(chalk.green('Hooks removed successfully.'));
+  if (!removed) {
+    console.log(chalk.yellow('No hooks installed.'));
+  } else {
+    console.log(chalk.green('\nHooks removed successfully.'));
+  }
 }
 
 export default setup;