@promptcellar/pc 0.1.0

package/README.md

@@ -0,0 +1,111 @@
+# PromptCellar CLI
+
+Command-line tool for capturing, managing, and reusing AI prompts with [PromptCellar](https://prompts.weldedanvil.com).
+
+## Installation
+
+```bash
+npm install -g @promptcellar/pc
+```
+
+## Quick Start
+
+```bash
+# Login with your API key
+pc login
+
+# Set up auto-capture for Claude Code
+pc setup
+
+# Check status
+pc status
+```
+
+## Commands
+
+### Authentication
+
+```bash
+pc login     # Login with your API key
+pc logout    # Remove stored credentials
+pc status    # Show current status and connection info
+```
+
+### Auto-Capture Setup
+
+```bash
+pc setup     # Configure auto-capture for CLI tools
+pc unsetup   # Remove auto-capture hooks
+```
+
+Currently supports:
+- Claude Code (via Stop hooks)
+
+Coming soon:
+- Cursor
+- Windsurf
+
+### Manual Capture
+
+```bash
+# Save a prompt manually
+pc save -m "Your prompt text here"
+
+# Open editor to write prompt
+pc save
+
+# Specify tool and model
+pc save -m "prompt" -t aider -M gpt-4
+```
+
+### Push Prompts
+
+```bash
+# Fetch and display a prompt by slug
+pc push my-project/useful-prompt
+```
+
+### Configuration
+
+```bash
+# View/change capture level
+pc config
+
+# Set capture level directly
+pc config --level minimal   # Tool + timestamp only
+pc config --level standard  # + working directory, git repo/branch
+pc config --level rich      # + session ID, git commit, remote URL
+```
+
+### Update
+
+```bash
+pc update    # Update to latest version
+```
+
+## Capture Levels
+
+Control how much context is captured with your prompts:
+
+| Level | Captured Data |
+|-------|--------------|
+| `minimal` | Tool, timestamp |
+| `standard` | + Working directory, git repo, git branch |
+| `rich` | + Session ID, git commit hash, remote URL |
+
+## Environment
+
+Configuration is stored in:
+- macOS: `~/Library/Preferences/promptcellar-nodejs/`
+- Linux: `~/.config/promptcellar-nodejs/`
+- Windows: `%APPDATA%/promptcellar-nodejs/`
+
+## API
+
+The CLI communicates with your PromptCellar instance. Get your API key from:
+
+Settings > API Keys in your PromptCellar dashboard.
+
+## License
+
+MIT

package/bin/pc.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+
+import { program } from 'commander';
+import { login } from '../src/commands/login.js';
+import { logout } from '../src/commands/logout.js';
+import { status } from '../src/commands/status.js';
+import { setup, unsetup } from '../src/commands/setup.js';
+import { save } from '../src/commands/save.js';
+import { push } from '../src/commands/push.js';
+import { config } from '../src/commands/config.js';
+import { update } from '../src/commands/update.js';
+
+program
+  .name('pc')
+  .description('PromptCellar CLI - sync prompts between your terminal and the cloud')
+  .version('0.1.0');
+
+program
+  .command('login')
+  .description('Authenticate with PromptCellar')
+  .action(login);
+
+program
+  .command('logout')
+  .description('Clear stored credentials')
+  .action(logout);
+
+program
+  .command('status')
+  .description('Show connection status and active sessions')
+  .action(status);
+
+program
+  .command('setup')
+  .description('Auto-detect installed tools and configure hooks/wrappers')
+  .option('--force', 'Overwrite existing hooks/wrappers')
+  .action(setup);
+
+program
+  .command('save')
+  .description('Manually save a prompt to current project')
+  .option('-m, --message <prompt>', 'Prompt content (opens editor if not provided)')
+  .option('-t, --tool <tool>', 'Tool name (default: manual)')
+  .option('-M, --model <model>', 'Model used')
+  .action(save);
+
+program
+  .command('unsetup')
+  .description('Remove auto-capture hooks')
+  .action(unsetup);
+
+program
+  .command('push <slug>')
+  .description('Push a prompt to the active CLI session')
+  .option('-t, --tool <tool>', 'Target tool (default: claude)')
+  .action(push);
+
+program
+  .command('config')
+  .description('Adjust privacy/capture settings')
+  .option('-l, --level <level>', 'Set capture level: minimal, standard, or rich')
+  .action(config);
+
+program
+  .command('update')
+  .description('Self-update to latest version')
+  .action(update);
+
+program.parse();

package/hooks/prompt-capture.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+
+/**
+ * Claude Code Stop hook for capturing prompts to PromptCellar.
+ *
+ * This script is called by Claude Code when a session ends.
+ * It parses the transcript file and extracts user prompts to capture.
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { capturePrompt } from '../src/lib/api.js';
+import { getFullContext } from '../src/lib/context.js';
+import { isLoggedIn } from '../src/lib/config.js';
+
+async function main() {
+  const transcriptPath = process.argv[2];
+
+  if (!transcriptPath) {
+    console.error('Usage: pc-capture <transcript-file>');
+    process.exit(1);
+  }
+
+  if (!existsSync(transcriptPath)) {
+    console.error('Transcript file not found:', transcriptPath);
+    process.exit(1);
+  }
+
+  if (!isLoggedIn()) {
+    // Silently exit if not logged in
+    process.exit(0);
+  }
+
+  try {
+    const content = readFileSync(transcriptPath, 'utf8');
+    const lines = content.split('\n').filter(line => line.trim());
+
+    // Parse JSONL format
+    const messages = [];
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === 'human' && entry.message?.content) {
+          messages.push({
+            content: entry.message.content,
+            timestamp: entry.timestamp
+          });
+        }
+      } catch {
+        // Skip invalid JSON lines
+      }
+    }
+
+    if (messages.length === 0) {
+      process.exit(0);
+    }
+
+    // Capture the first user message (initial prompt)
+    const initialPrompt = messages[0];
+    const context = getFullContext('claude-code');
+
+    await capturePrompt({
+      content: initialPrompt.content,
+      ...context,
+      captured_at: initialPrompt.timestamp
+    });
+
+    // Optionally capture all prompts if configured
+    // For now, just capture the initial prompt
+
+  } catch (error) {
+    console.error('Error capturing prompt:', error.message);
+    process.exit(1);
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@promptcellar/pc",
+  "version": "0.1.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"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "promptcellar",
+    "prompts",
+    "cli",
+    "ai",
+    "llm",
+    "claude",
+    "codex",
+    "gemini"
+  ],
+  "author": "Welded Anvil Technologies LLC",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/WeldedAnvil/pc-cli.git"
+  },
+  "homepage": "https://prompts.weldedanvil.com",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "conf": "^12.0.0",
+    "chalk": "^5.3.0",
+    "ora": "^8.0.0",
+    "inquirer": "^9.2.0",
+    "socket.io-client": "^4.6.0",
+    "node-fetch": "^3.3.0"
+  }
+}

package/src/commands/config.js

@@ -0,0 +1,45 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { getCaptureLevel, setCaptureLevel } from '../lib/config.js';
+
+const CAPTURE_LEVELS = {
+  minimal: 'Just tool and timestamp',
+  standard: 'Tool, timestamp, working directory, git repo/branch',
+  rich: 'Everything including session ID, git commit, remote URL'
+};
+
+export async function config(options) {
+  if (options.level) {
+    try {
+      setCaptureLevel(options.level);
+      console.log(chalk.green(`Capture level set to: ${options.level}`));
+      console.log(chalk.dim(CAPTURE_LEVELS[options.level]));
+    } catch (error) {
+      console.log(chalk.red(error.message));
+    }
+    return;
+  }
+
+  const currentLevel = getCaptureLevel();
+
+  console.log(chalk.bold('\nCapture Level Configuration\n'));
+  console.log(`Current level: ${chalk.cyan(currentLevel)}\n`);
+
+  const choices = Object.entries(CAPTURE_LEVELS).map(([level, desc]) => ({
+    name: `${level} - ${desc}`,
+    value: level
+  }));
+
+  const { level } = await inquirer.prompt([{
+    type: 'list',
+    name: 'level',
+    message: 'Select capture level:',
+    choices,
+    default: currentLevel
+  }]);
+
+  setCaptureLevel(level);
+  console.log(chalk.green(`\nCapture level set to: ${level}`));
+}
+
+export default config;

package/src/commands/login.js

@@ -0,0 +1,57 @@
+import inquirer from 'inquirer';
+import ora from 'ora';
+import chalk from 'chalk';
+import { setApiKey, setApiUrl, isLoggedIn } from '../lib/config.js';
+import { testConnection } from '../lib/api.js';
+
+export async function login() {
+  if (isLoggedIn()) {
+    const { overwrite } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'overwrite',
+      message: 'Already logged in. Replace existing credentials?',
+      default: false
+    }]);
+
+    if (!overwrite) {
+      console.log('Login cancelled.');
+      return;
+    }
+  }
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'apiKey',
+      message: 'Enter your PromptCellar API key:',
+      validate: (input) => {
+        if (!input.trim()) return 'API key is required';
+        if (!input.startsWith('pk_')) return 'Invalid API key format (should start with pk_)';
+        return true;
+      }
+    },
+    {
+      type: 'input',
+      name: 'apiUrl',
+      message: 'API URL (press enter for default):',
+      default: 'https://prompts.weldedanvil.com'
+    }
+  ]);
+
+  const spinner = ora('Testing connection...').start();
+
+  setApiKey(answers.apiKey.trim());
+  setApiUrl(answers.apiUrl.trim());
+
+  const result = await testConnection();
+
+  if (result.success) {
+    spinner.succeed(chalk.green('Logged in successfully!'));
+    console.log('\nRun ' + chalk.cyan('pc setup') + ' to configure auto-capture for your CLI tools.');
+  } else {
+    spinner.fail(chalk.red('Connection failed: ' + result.error));
+    console.log('Check your API key and try again.');
+  }
+}
+
+export default login;

package/src/commands/logout.js

@@ -0,0 +1,14 @@
+import chalk from 'chalk';
+import { clearApiKey, isLoggedIn } from '../lib/config.js';
+
+export async function logout() {
+  if (!isLoggedIn()) {
+    console.log('Not logged in.');
+    return;
+  }
+
+  clearApiKey();
+  console.log(chalk.green('Logged out successfully.'));
+}
+
+export default logout;

package/src/commands/push.js

@@ -0,0 +1,56 @@
+import ora from 'ora';
+import chalk from 'chalk';
+import { getPrompt } from '../lib/api.js';
+import { connect, disconnect } from '../lib/websocket.js';
+import { isLoggedIn } from '../lib/config.js';
+
+export async function push(slug, options) {
+  if (!isLoggedIn()) {
+    console.log(chalk.red('Not logged in.') + ' Run: pc login');
+    return;
+  }
+
+  const spinner = ora('Fetching prompt...').start();
+
+  try {
+    const prompt = await getPrompt(slug);
+    spinner.text = 'Connecting to session...';
+
+    const socket = connect(options.tool || 'claude');
+
+    // Wait for connection
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error('Connection timeout'));
+      }, 10000);
+
+      socket.on('registered', () => {
+        clearTimeout(timeout);
+        resolve();
+      });
+
+      socket.on('error', (err) => {
+        clearTimeout(timeout);
+        reject(new Error(err.message));
+      });
+    });
+
+    spinner.text = 'Pushing prompt...';
+
+    // Push the prompt to ourselves (for now, just copy to clipboard simulation)
+    console.log('\n' + chalk.cyan('Prompt content:'));
+    console.log(chalk.dim('─'.repeat(50)));
+    console.log(prompt.content);
+    console.log(chalk.dim('─'.repeat(50)));
+
+    spinner.succeed(chalk.green('Prompt fetched!'));
+    console.log('\nCopy the prompt above to use it in your session.');
+
+    disconnect();
+  } catch (error) {
+    spinner.fail(chalk.red('Failed: ' + error.message));
+    disconnect();
+  }
+}
+
+export default push;

package/src/commands/save.js

@@ -0,0 +1,46 @@
+import inquirer from 'inquirer';
+import ora from 'ora';
+import chalk from 'chalk';
+import { capturePrompt } from '../lib/api.js';
+import { getFullContext } from '../lib/context.js';
+import { isLoggedIn } from '../lib/config.js';
+
+export async function save(options) {
+  if (!isLoggedIn()) {
+    console.log(chalk.red('Not logged in.') + ' Run: pc login');
+    return;
+  }
+
+  let content = options.message;
+
+  if (!content) {
+    const { promptContent } = await inquirer.prompt([{
+      type: 'editor',
+      name: 'promptContent',
+      message: 'Enter your prompt (opens editor):',
+      validate: (input) => {
+        if (!input.trim()) return 'Prompt content is required';
+        return true;
+      }
+    }]);
+    content = promptContent;
+  }
+
+  const context = getFullContext(options.tool || 'manual', options.model);
+
+  const spinner = ora('Saving prompt...').start();
+
+  try {
+    const result = await capturePrompt({
+      content: content.trim(),
+      ...context
+    });
+
+    spinner.succeed(chalk.green('Prompt saved!'));
+    console.log(`  ID: ${chalk.dim(result.id)}`);
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to save: ' + error.message));
+  }
+}
+
+export default save;

package/src/commands/setup.js

@@ -0,0 +1,124 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+
+const CLAUDE_HOOKS_PATH = join(homedir(), '.claude', 'hooks.json');
+const HOOK_SCRIPT_NAME = 'pc-capture';
+
+function getHooksConfig() {
+  if (existsSync(CLAUDE_HOOKS_PATH)) {
+    try {
+      return JSON.parse(readFileSync(CLAUDE_HOOKS_PATH, 'utf8'));
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+
+function saveHooksConfig(config) {
+  const dir = dirname(CLAUDE_HOOKS_PATH);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(CLAUDE_HOOKS_PATH, JSON.stringify(config, null, 2));
+}
+
+function isHookInstalled(config) {
+  const stopHooks = config.Stop || [];
+  return stopHooks.some(hook =>
+    hook.command && hook.command.includes(HOOK_SCRIPT_NAME)
+  );
+}
+
+export async function setup() {
+  console.log(chalk.bold('\nPromptCellar CLI Setup\n'));
+
+  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 }
+  ];
+
+  const { selectedTools } = await inquirer.prompt([{
+    type: 'checkbox',
+    name: 'selectedTools',
+    message: 'Which tools do you want to capture prompts from?',
+    choices: tools
+  }]);
+
+  if (selectedTools.length === 0) {
+    console.log(chalk.yellow('No tools selected. Setup cancelled.'));
+    return;
+  }
+
+  for (const tool of selectedTools) {
+    if (tool === 'claude') {
+      await setupClaudeCode();
+    }
+  }
+
+  console.log(chalk.green('\nSetup complete!'));
+  console.log('Your prompts will be automatically captured to PromptCellar.\n');
+}
+
+async function setupClaudeCode() {
+  console.log(chalk.cyan('\nConfiguring Claude Code...'));
+
+  const config = getHooksConfig();
+
+  if (isHookInstalled(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 hook
+    config.Stop = (config.Stop || []).filter(hook =>
+      !hook.command || !hook.command.includes(HOOK_SCRIPT_NAME)
+    );
+  }
+
+  // Add the hook
+  if (!config.Stop) {
+    config.Stop = [];
+  }
+
+  config.Stop.push({
+    command: `pc-capture "$CLAUDE_TRANSCRIPT_FILE"`,
+    description: 'Capture prompts to PromptCellar'
+  });
+
+  saveHooksConfig(config);
+  console.log(chalk.green('  Hook installed successfully.'));
+}
+
+export async function unsetup() {
+  console.log(chalk.bold('\nRemoving PromptCellar hooks...\n'));
+
+  const config = getHooksConfig();
+
+  if (!isHookInstalled(config)) {
+    console.log(chalk.yellow('No hooks installed.'));
+    return;
+  }
+
+  config.Stop = (config.Stop || []).filter(hook =>
+    !hook.command || !hook.command.includes(HOOK_SCRIPT_NAME)
+  );
+
+  saveHooksConfig(config);
+  console.log(chalk.green('Hooks removed successfully.'));
+}
+
+export default setup;

package/src/commands/status.js

@@ -0,0 +1,41 @@
+import chalk from 'chalk';
+import { isLoggedIn, getApiUrl, getCaptureLevel, getSessionId } from '../lib/config.js';
+import { testConnection } from '../lib/api.js';
+import { getGitContext } from '../lib/context.js';
+
+export async function status() {
+  console.log(chalk.bold('\nPromptCellar CLI Status\n'));
+
+  // Auth status
+  if (isLoggedIn()) {
+    const result = await testConnection();
+    if (result.success) {
+      console.log(chalk.green('  Logged in') + ` to ${getApiUrl()}`);
+    } else {
+      console.log(chalk.yellow('  Logged in') + ` but connection failed: ${result.error}`);
+    }
+  } else {
+    console.log(chalk.red('  Not logged in') + ' - Run: pc login');
+  }
+
+  // Capture level
+  console.log(`  Capture level: ${chalk.cyan(getCaptureLevel())}`);
+
+  // Session ID
+  console.log(`  Session ID: ${chalk.dim(getSessionId().slice(0, 8))}...`);
+
+  // Git context
+  const git = getGitContext();
+  if (git.git_repo) {
+    console.log(`\n  Git repo: ${chalk.cyan(git.git_repo)}`);
+    if (git.git_branch) {
+      console.log(`  Branch: ${chalk.cyan(git.git_branch)}`);
+    }
+  } else {
+    console.log(chalk.dim('\n  Not in a git repository'));
+  }
+
+  console.log('');
+}
+
+export default status;

package/src/commands/update.js

@@ -0,0 +1,45 @@
+import { execFileSync } from 'child_process';
+import ora from 'ora';
+import chalk from 'chalk';
+
+export async function update() {
+  const spinner = ora('Checking for updates...').start();
+
+  try {
+    // Check current version
+    const currentVersion = JSON.parse(
+      execFileSync('npm', ['pkg', 'get', 'version'], { encoding: 'utf8' })
+    ).replace(/"/g, '');
+
+    // Check latest version from npm
+    let latestVersion;
+    try {
+      const output = execFileSync('npm', ['view', '@promptcellar/pc', 'version'], {
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'pipe']
+      }).trim();
+      latestVersion = output;
+    } catch {
+      spinner.fail(chalk.red('Failed to check for updates.'));
+      return;
+    }
+
+    if (currentVersion === latestVersion) {
+      spinner.succeed(chalk.green(`Already on latest version (${currentVersion})`));
+      return;
+    }
+
+    spinner.text = `Updating from ${currentVersion} to ${latestVersion}...`;
+
+    execFileSync('npm', ['install', '-g', '@promptcellar/pc@latest'], {
+      stdio: 'inherit'
+    });
+
+    spinner.succeed(chalk.green(`Updated to version ${latestVersion}`));
+  } catch (error) {
+    spinner.fail(chalk.red('Update failed: ' + error.message));
+    console.log('Try running: npm install -g @promptcellar/pc@latest');
+  }
+}
+
+export default update;

package/src/index.js

@@ -0,0 +1,15 @@
+// PromptCellar CLI - Main exports
+
+export { login } from './commands/login.js';
+export { logout } from './commands/logout.js';
+export { status } from './commands/status.js';
+export { setup, unsetup } from './commands/setup.js';
+export { save } from './commands/save.js';
+export { push } from './commands/push.js';
+export { config } from './commands/config.js';
+export { update } from './commands/update.js';
+
+export * from './lib/config.js';
+export * from './lib/api.js';
+export * from './lib/context.js';
+export * from './lib/websocket.js';

package/src/lib/api.js

@@ -0,0 +1,72 @@
+import fetch from 'node-fetch';
+import { getApiKey, getApiUrl } from './config.js';
+
+async function request(endpoint, options = {}) {
+  const apiKey = getApiKey();
+  const apiUrl = getApiUrl();
+
+  if (!apiKey) {
+    throw new Error('Not logged in. Run: pc login');
+  }
+
+  const url = `${apiUrl}${endpoint}`;
+  const headers = {
+    'Authorization': `Bearer ${apiKey}`,
+    'Content-Type': 'application/json',
+    ...options.headers
+  };
+
+  const response = await fetch(url, {
+    ...options,
+    headers
+  });
+
+  if (!response.ok) {
+    const data = await response.json().catch(() => ({}));
+    throw new Error(data.error || `HTTP ${response.status}`);
+  }
+
+  return response.json();
+}
+
+export async function testConnection() {
+  const apiKey = getApiKey();
+  const apiUrl = getApiUrl();
+
+  if (!apiKey) {
+    return { success: false, error: 'Not logged in' };
+  }
+
+  try {
+    const response = await fetch(`${apiUrl}/health`);
+    if (response.ok) {
+      return { success: true };
+    }
+    return { success: false, error: 'Server not responding' };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+export async function capturePrompt(data) {
+  return request('/api/v1/capture', {
+    method: 'POST',
+    body: JSON.stringify(data)
+  });
+}
+
+export async function listCaptured(options = {}) {
+  const params = new URLSearchParams();
+  if (options.page) params.set('page', options.page);
+  if (options.tool) params.set('tool', options.tool);
+  if (options.starred) params.set('starred', 'true');
+
+  const query = params.toString();
+  return request(`/api/v1/captured${query ? '?' + query : ''}`);
+}
+
+export async function getPrompt(slug) {
+  return request(`/api/v1/prompts/${slug}`);
+}
+
+export default { testConnection, capturePrompt, listCaptured, getPrompt };

package/src/lib/config.js

@@ -0,0 +1,70 @@
+import Conf from 'conf';
+
+const config = new Conf({
+  projectName: 'promptcellar',
+  schema: {
+    apiKey: {
+      type: 'string',
+      default: ''
+    },
+    apiUrl: {
+      type: 'string',
+      default: 'https://prompts.weldedanvil.com'
+    },
+    captureLevel: {
+      type: 'string',
+      enum: ['minimal', 'standard', 'rich'],
+      default: 'rich'
+    },
+    sessionId: {
+      type: 'string',
+      default: ''
+    }
+  }
+});
+
+export function getApiKey() {
+  return config.get('apiKey');
+}
+
+export function setApiKey(key) {
+  config.set('apiKey', key);
+}
+
+export function clearApiKey() {
+  config.delete('apiKey');
+}
+
+export function getApiUrl() {
+  return config.get('apiUrl');
+}
+
+export function setApiUrl(url) {
+  config.set('apiUrl', url);
+}
+
+export function getCaptureLevel() {
+  return config.get('captureLevel');
+}
+
+export function setCaptureLevel(level) {
+  if (!['minimal', 'standard', 'rich'].includes(level)) {
+    throw new Error('Invalid capture level. Must be: minimal, standard, or rich');
+  }
+  config.set('captureLevel', level);
+}
+
+export function getSessionId() {
+  let sessionId = config.get('sessionId');
+  if (!sessionId) {
+    sessionId = crypto.randomUUID();
+    config.set('sessionId', sessionId);
+  }
+  return sessionId;
+}
+
+export function isLoggedIn() {
+  return !!config.get('apiKey');
+}
+
+export default config;

package/src/lib/context.js

@@ -0,0 +1,69 @@
+import { execFileSync } from 'child_process';
+import { getCaptureLevel, getSessionId } from './config.js';
+
+function execGit(...args) {
+  try {
+    return execFileSync('git', args, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+  } catch {
+    return null;
+  }
+}
+
+export function getGitContext() {
+  const level = getCaptureLevel();
+
+  // Minimal: no git context
+  if (level === 'minimal') {
+    return {};
+  }
+
+  const context = {};
+
+  // Standard: repo name and branch
+  const topLevel = execGit('rev-parse', '--show-toplevel');
+  if (topLevel) {
+    context.git_repo = topLevel.split('/').pop();
+    context.git_branch = execGit('rev-parse', '--abbrev-ref', 'HEAD');
+  }
+
+  // Rich: add remote URL and commit hash
+  if (level === 'rich' && topLevel) {
+    context.git_remote_url = execGit('remote', 'get-url', 'origin');
+    context.git_commit = execGit('rev-parse', 'HEAD');
+  }
+
+  return context;
+}
+
+export function getFullContext(tool, model) {
+  const level = getCaptureLevel();
+  const sessionId = getSessionId();
+
+  const context = {
+    tool,
+    captured_at: new Date().toISOString()
+  };
+
+  // Minimal: just tool and timestamp
+  if (level === 'minimal') {
+    return context;
+  }
+
+  // Standard: add working directory and model
+  context.working_directory = process.cwd();
+  if (model) {
+    context.model = model;
+  }
+
+  // Add git context
+  Object.assign(context, getGitContext());
+
+  // Rich: add session ID
+  if (level === 'rich') {
+    context.session_id = sessionId;
+  }
+
+  return context;
+}
+
+export default { getGitContext, getFullContext };

package/src/lib/websocket.js

@@ -0,0 +1,78 @@
+import { io } from 'socket.io-client';
+import { getApiKey, getApiUrl, getSessionId } from './config.js';
+import { getFullContext } from './context.js';
+
+let socket = null;
+let reconnectTimer = null;
+
+export function connect(tool, onPromptReceived) {
+  const apiKey = getApiKey();
+  const apiUrl = getApiUrl();
+
+  if (!apiKey) {
+    throw new Error('Not logged in. Run: pc login');
+  }
+
+  if (socket?.connected) {
+    return socket;
+  }
+
+  socket = io(apiUrl, {
+    transports: ['websocket'],
+    reconnection: true,
+    reconnectionDelay: 1000,
+    reconnectionDelayMax: 5000
+  });
+
+  socket.on('connect', () => {
+    const context = getFullContext(tool);
+    socket.emit('register_cli', {
+      api_key: apiKey,
+      session_id: getSessionId(),
+      tool,
+      working_directory: context.working_directory,
+      git_repo: context.git_repo,
+      git_branch: context.git_branch
+    });
+  });
+
+  socket.on('registered', (data) => {
+    console.log(`Connected to PromptCellar (session: ${data.session_id})`);
+  });
+
+  socket.on('prompt_pushed', (data) => {
+    if (onPromptReceived) {
+      onPromptReceived(data);
+    }
+  });
+
+  socket.on('error', (data) => {
+    console.error('WebSocket error:', data.message);
+  });
+
+  socket.on('disconnect', (reason) => {
+    if (reason === 'io server disconnect') {
+      // Server disconnected, try to reconnect
+      socket.connect();
+    }
+  });
+
+  return socket;
+}
+
+export function disconnect() {
+  if (socket) {
+    socket.disconnect();
+    socket = null;
+  }
+  if (reconnectTimer) {
+    clearTimeout(reconnectTimer);
+    reconnectTimer = null;
+  }
+}
+
+export function isConnected() {
+  return socket?.connected || false;
+}
+
+export default { connect, disconnect, isConnected };