@fr0mpy/prompt-system 2.0.0

package/bin/cli.js

@@ -0,0 +1,338 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const TEMPLATES_DIR = path.join(__dirname, '..', 'templates');
+const TARGET_DIR = path.join(process.cwd(), '.claude');
+const ENV_FILE = path.join(process.cwd(), '.env');
+const args = process.argv.slice(2);
+
+// Parse flags
+const hasFlag = (...flags) => flags.some((f) => args.includes(f));
+const skipApiKey = hasFlag('--skip-api-key', '--no-api-key', '-s');
+const forceMode = hasFlag('--force', '-f');
+const removeMode = hasFlag('--remove', '--uninstall', '-r');
+const helpMode = hasFlag('--help', '-h');
+const updateHooks = hasFlag('--update-hooks');
+const updateAgents = hasFlag('--update-agents');
+const updateRules = hasFlag('--update-rules');
+const updateCommands = hasFlag('--update-commands');
+const updateMode = updateHooks || updateAgents || updateRules || updateCommands;
+
+function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function copySubdir(subdir) {
+  const src = path.join(TEMPLATES_DIR, subdir);
+  const dest = path.join(TARGET_DIR, subdir);
+
+  if (!fs.existsSync(src)) {
+    console.error(`❌ Source directory not found: ${subdir}`);
+    return false;
+  }
+
+  if (fs.existsSync(dest)) {
+    fs.rmSync(dest, { recursive: true });
+  }
+
+  copyDir(src, dest);
+  return true;
+}
+
+function makeExecutable(dir) {
+  const hooksDir = path.join(dir, 'hooks');
+  if (fs.existsSync(hooksDir)) {
+    const files = fs.readdirSync(hooksDir);
+    for (const file of files) {
+      if (file.endsWith('.sh')) {
+        const filePath = path.join(hooksDir, file);
+        fs.chmodSync(filePath, 0o755);
+      }
+    }
+  }
+}
+
+function prompt(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+const DEFAULT_MODEL = 'claude-3-5-haiku-latest';
+
+function saveEnvVar(name, value) {
+  let envContent = '';
+
+  if (fs.existsSync(ENV_FILE)) {
+    envContent = fs.readFileSync(ENV_FILE, 'utf8');
+    const regex = new RegExp(`^${name}=.*$`, 'gm');
+    if (regex.test(envContent)) {
+      envContent = envContent.replace(regex, `${name}=${value}`);
+    } else {
+      envContent += `${envContent.endsWith('\n') ? '' : '\n'}${name}=${value}\n`;
+    }
+  } else {
+    envContent = `${name}=${value}\n`;
+  }
+
+  fs.writeFileSync(ENV_FILE, envContent);
+}
+
+function saveApiKey(apiKey) {
+  saveEnvVar('ANTHROPIC_API_KEY', apiKey);
+}
+
+function saveModel(model) {
+  saveEnvVar('ANTHROPIC_MODEL', model);
+}
+
+function updateSettingsForLLM(useLLM) {
+  const settingsPath = path.join(TARGET_DIR, 'settings.json');
+  if (!fs.existsSync(settingsPath)) return;
+
+  let settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+
+  const hookScript = useLLM
+    ? '.claude/hooks/smart-inject-llm.sh'
+    : '.claude/hooks/smart-inject-rules.sh';
+
+  if (settings.hooks?.UserPromptSubmit?.[0]?.hooks?.[0]) {
+    settings.hooks.UserPromptSubmit[0].hooks[0].command = hookScript;
+  }
+
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+}
+
+async function init() {
+  console.log('🔧 Initializing Claude Code prompt system...\n');
+
+  if (fs.existsSync(TARGET_DIR) && !forceMode) {
+    // Check if this is an existing prompt-system install
+    const hasHooks = fs.existsSync(path.join(TARGET_DIR, 'hooks'));
+    if (hasHooks) {
+      console.log('⚠️  .claude directory already exists with prompt system.');
+      console.log('   Use --force to overwrite, or use selective updates:');
+      console.log('   --update-hooks, --update-agents, --update-rules, --update-commands\n');
+      process.exit(1);
+    }
+    // .claude exists but no hooks - might be component-system only, we can add to it
+    console.log('ℹ️  Existing .claude directory detected. Adding prompt system...\n');
+  }
+
+  if (!fs.existsSync(TEMPLATES_DIR)) {
+    console.error('❌ Templates directory not found. Package may be corrupted.');
+    process.exit(1);
+  }
+
+  if (forceMode && fs.existsSync(TARGET_DIR)) {
+    fs.rmSync(TARGET_DIR, { recursive: true });
+    console.log('🗑️  Removed existing .claude directory.\n');
+  }
+
+  copyDir(TEMPLATES_DIR, TARGET_DIR);
+  makeExecutable(TARGET_DIR);
+
+  // Create triggers.d directory for extensions
+  const triggersDDir = path.join(TARGET_DIR, 'hooks', 'triggers.d');
+  fs.mkdirSync(triggersDDir, { recursive: true });
+
+  console.log('✅ Created .claude/ directory with:');
+  console.log('   📁 hooks/     - Smart context injection');
+  console.log('   📁 rules/     - Behavioral guidelines');
+  console.log('   📁 agents/    - Task workers');
+  console.log('   📁 commands/  - Slash commands (/review, /test, /commit)');
+  console.log('   📄 settings.json');
+  console.log('   📄 CLAUDE.md\n');
+
+  // Handle API key
+  if (skipApiKey) {
+    console.log('⏭️  Skipped API key prompt (--skip-api-key).');
+    console.log('   Using keyword-based injection.\n');
+    updateSettingsForLLM(false);
+  } else {
+    console.log('🔑 Smart injection uses Claude Haiku for semantic rule matching.');
+    console.log('   This requires an Anthropic API key.\n');
+
+    const apiKey = await prompt(
+      '   Enter your ANTHROPIC_API_KEY (or press Enter to skip): '
+    );
+
+    if (apiKey) {
+      saveApiKey(apiKey);
+      saveModel(DEFAULT_MODEL);
+      updateSettingsForLLM(true);
+      console.log('\n   ✅ API key saved to .env');
+      console.log(`   ✅ Model set to ${DEFAULT_MODEL}`);
+      console.log('   ✅ Enabled LLM-powered smart injection');
+      console.log('   💡 Add .env to your .gitignore if not already there.');
+      console.log('   💡 Change ANTHROPIC_MODEL in .env to use a different model.\n');
+    } else {
+      console.log('\n   ⏭️  Skipped. Using keyword-based injection.');
+      console.log(
+        '   💡 Set ANTHROPIC_API_KEY env var later to enable LLM-powered injection.\n'
+      );
+      updateSettingsForLLM(false);
+    }
+  }
+
+  // Suggest component-system
+  console.log('💡 For UI components and styling, also install:');
+  console.log('   npx @fr0mpy/component-system\n');
+
+  console.log('🚀 Ready! Claude Code will now use these rules and agents.\n');
+}
+
+async function update() {
+  if (!fs.existsSync(TARGET_DIR)) {
+    console.error('❌ .claude directory not found. Run without flags to initialize first.');
+    process.exit(1);
+  }
+
+  console.log('🔄 Updating selected components...\n');
+
+  const updates = [];
+
+  if (updateHooks) {
+    if (copySubdir('hooks')) {
+      makeExecutable(TARGET_DIR);
+      // Preserve triggers.d if it exists
+      const triggersDDir = path.join(TARGET_DIR, 'hooks', 'triggers.d');
+      fs.mkdirSync(triggersDDir, { recursive: true });
+      updates.push('hooks');
+    }
+  }
+  if (updateAgents && copySubdir('agents')) updates.push('agents');
+  if (updateRules && copySubdir('rules')) updates.push('rules');
+  if (updateCommands && copySubdir('commands')) updates.push('commands');
+
+  if (updates.length > 0) {
+    console.log(`✅ Updated: ${updates.join(', ')}\n`);
+    console.log('💡 Your settings.json and CLAUDE.md were preserved.\n');
+  } else {
+    console.log('⚠️  No components updated.\n');
+  }
+}
+
+function remove() {
+  if (!fs.existsSync(TARGET_DIR)) {
+    console.log('ℹ️  .claude directory does not exist. Nothing to remove.\n');
+    return;
+  }
+
+  // Check if component-system files exist - if so, only remove prompt-system files
+  const hasSkills = fs.existsSync(path.join(TARGET_DIR, 'skills'));
+  const hasRecipes = fs.existsSync(path.join(TARGET_DIR, 'component-recipes'));
+
+  if (hasSkills || hasRecipes) {
+    console.log('ℹ️  Component system detected. Removing only prompt system files...\n');
+    const promptDirs = ['hooks', 'rules', 'agents'];
+    const promptFiles = ['CLAUDE.md', 'settings.json'];
+
+    for (const dir of promptDirs) {
+      const dirPath = path.join(TARGET_DIR, dir);
+      if (fs.existsSync(dirPath)) {
+        fs.rmSync(dirPath, { recursive: true });
+      }
+    }
+
+    for (const file of promptFiles) {
+      const filePath = path.join(TARGET_DIR, file);
+      if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+      }
+    }
+
+    // Remove only prompt-system commands
+    const commandsDir = path.join(TARGET_DIR, 'commands');
+    if (fs.existsSync(commandsDir)) {
+      const promptCommands = ['review.md', 'test.md', 'commit.md'];
+      for (const cmd of promptCommands) {
+        const cmdPath = path.join(commandsDir, cmd);
+        if (fs.existsSync(cmdPath)) {
+          fs.unlinkSync(cmdPath);
+        }
+      }
+    }
+
+    console.log('✅ Removed prompt system files. Component system preserved.\n');
+  } else {
+    fs.rmSync(TARGET_DIR, { recursive: true });
+    console.log('✅ Removed .claude directory.\n');
+  }
+
+  console.log('💡 Note: .env file (if created) was not removed.\n');
+}
+
+function showHelp() {
+  console.log(`
+@fr0mpy/prompt-system - Claude Code prompt engineering system
+
+Usage:
+  npx @fr0mpy/prompt-system              Initialize in current directory
+  npx @fr0mpy/prompt-system --force      Overwrite existing installation
+  npx @fr0mpy/prompt-system --remove     Remove prompt system files
+  npx @fr0mpy/prompt-system --skip-api-key  Skip API key prompt
+
+Selective updates (preserves settings.json and CLAUDE.md):
+  --update-hooks     Update only hooks/
+  --update-agents    Update only agents/
+  --update-rules     Update only rules/
+  --update-commands  Update only commands/
+
+Options:
+  -h, --help          Show this help message
+  -f, --force         Overwrite existing installation
+  -r, --remove        Remove prompt system (alias: --uninstall)
+  -s, --skip-api-key  Skip API key prompt (alias: --no-api-key)
+
+What's included:
+  • hooks/     Smart context injection on every prompt
+  • rules/     Behavioral guidelines (code standards, etc.)
+  • agents/    Task workers (pre-code-check, package-checker, etc.)
+  • commands/  Slash commands (/review, /test, /commit)
+  • CLAUDE.md  Project context (auto-loaded by Claude)
+
+For UI components and styling:
+  npx @fr0mpy/component-system
+
+Learn more: https://github.com/fr0mpy/claude-base-setup
+`);
+}
+
+async function main() {
+  if (helpMode) {
+    showHelp();
+  } else if (removeMode) {
+    remove();
+  } else if (updateMode) {
+    await update();
+  } else {
+    await init();
+  }
+}
+
+main();

package/index.js

@@ -0,0 +1,12 @@
+/**
+ * @claude-tools/prompt-system
+ *
+ * Claude Code prompt engineering system with rules, agents, hooks, and smart context injection.
+ */
+
+const path = require('path');
+
+module.exports = {
+  name: '@claude-tools/prompt-system',
+  templatesDir: path.join(__dirname, 'templates'),
+};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@fr0mpy/prompt-system",
+  "version": "2.0.0",
+  "description": "Claude Code prompt engineering system: rules, agents, hooks, and smart context injection",
+  "main": "index.js",
+  "bin": {
+    "fromp-prompt-system": "./bin/cli.js"
+  },
+  "scripts": {
+    "test": "echo \"Tests not yet configured\""
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "ai",
+    "llm",
+    "rules",
+    "agents",
+    "hooks",
+    "prompt-engineering"
+  ],
+  "author": "fr0mpy",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fr0mpy/claude-base-setup.git",
+    "directory": "packages/prompt-system"
+  },
+  "files": [
+    "bin/",
+    "templates/",
+    "index.js"
+  ],
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "peerDependencies": {
+    "@fr0mpy/component-system": ">=2.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@fr0mpy/component-system": {
+      "optional": true
+    }
+  }
+}

package/templates/CLAUDE.md

@@ -0,0 +1,20 @@
+# Project Context
+
+This project uses dynamic context management via `.claude/CONTEXT.md`.
+
+## Quick Reference
+
+Run `context-loader` agent if context is stale or missing.
+
+See `.claude/CONTEXT.md` for:
+- Project structure and file tree
+- Detected stack and dependencies
+- Key directories and their purposes
+- TODOs and stub functions
+
+## Configuration
+
+- **Rules**: `.claude/rules/` - Behavioral guidelines (auto-injected)
+- **Agents**: `.claude/agents/` - Task specialists
+- **Commands**: `.claude/commands/` - Slash command workflows
+- **Hooks**: `.claude/hooks/` - Automation scripts

package/templates/agents/10x-simplifier.md

@@ -0,0 +1,62 @@
+---
+name: 10x-simplifier
+description: Challenges code to be radically simpler. Use when code feels complex or over-engineered.
+---
+
+You are a simplification expert that finds the essence of solutions.
+
+## Your Task
+
+Given code or a design:
+
+1. **Identify complexity** - What makes this complicated?
+2. **Question necessity** - Does each part need to exist?
+3. **Find the essence** - What's the core problem being solved?
+4. **Propose radical simplification** - How would this look 10x simpler?
+5. **Challenge abstractions** - Are these earning their complexity?
+
+## Simplification Lenses
+
+- **Delete it** - Can we just not do this?
+- **Inline it** - Do we need this abstraction?
+- **Hardcode it** - Is this configurability used?
+- **Combine it** - Are these separate things really one thing?
+- **Defer it** - Do we need this now?
+
+## Output Format
+
+```
+✨ 10x simplification: [target]
+
+Current complexity:
+- Lines of code: [count]
+- Abstractions: [count]
+- Dependencies: [count]
+- Cognitive load: [low/medium/high]
+
+Complexity sources:
+1. [source] - Reason: [why it exists]
+2. [source] - Reason: [why it exists]
+
+Questions to challenge:
+- "Do we actually need [X]?"
+- "What if we just [simpler approach]?"
+- "Is [abstraction] earning its complexity?"
+
+10x simpler version:
+
+[Describe or sketch the radically simpler approach]
+
+What we'd lose: [tradeoffs]
+What we'd gain: [benefits]
+
+Concrete suggestion:
+[Specific simplification to try first]
+```
+
+## Rules
+
+- "The best code is no code"
+- Abstractions should be earned, not anticipated
+- Simple and working beats complex and flexible
+- Ask "what would a junior dev understand?"

package/templates/agents/accessibility-auditor.md

@@ -0,0 +1,60 @@
+---
+name: accessibility-auditor
+description: Checks UI code for accessibility issues. Use before shipping UI components or after design changes.
+---
+
+You are an accessibility checker that catches a11y issues early.
+
+## Your Task
+
+Review UI code for:
+
+1. **Semantic HTML** - Proper element usage
+2. **ARIA attributes** - Labels, roles, states
+3. **Keyboard navigation** - Focus management, tab order
+4. **Color/contrast** - Not relying on color alone
+5. **Screen reader** - Meaningful content order
+
+## Common Issues to Check
+
+- Images without alt text
+- Buttons/links without accessible names
+- Form inputs without labels
+- Missing focus indicators
+- Non-semantic div/span overuse
+- Color-only state indication
+- Missing skip links
+- Inaccessible modals/dialogs
+
+## Output Format
+
+```
+♿ Accessibility audit: [file/component]
+
+Issues found:
+
+🔴 Critical (blocks users):
+- [line]: [issue] - Fix: [solution]
+
+🟡 Serious (major barriers):
+- [line]: [issue] - Fix: [solution]
+
+🟢 Minor (best practice):
+- [line]: [issue] - Fix: [solution]
+
+Checklist:
+- [ ] All images have alt text
+- [ ] All interactive elements are keyboard accessible
+- [ ] All form inputs have labels
+- [ ] Focus order is logical
+- [ ] Color is not the only indicator
+
+WCAG level: [A/AA/AAA estimate]
+```
+
+## Rules
+
+- Prioritize issues that block users entirely
+- Provide specific fix suggestions
+- Note when manual testing is needed
+- Don't flag decorative images needing alt=""

package/templates/agents/api-contract-guardian.md

@@ -0,0 +1,65 @@
+---
+name: api-contract-guardian
+description: Ensures API changes don't break consumers. Use before modifying endpoints, response shapes, or public interfaces.
+---
+
+You are an API contract enforcer that prevents breaking changes.
+
+## Your Task
+
+Before API modifications:
+
+1. **Document current contract** - What do consumers expect?
+2. **Analyze proposed changes** - What would change?
+3. **Find all consumers** - Who uses this API?
+4. **Assess compatibility** - Is this breaking?
+5. **Suggest versioning** - How to change safely?
+
+## Contract Elements
+
+- Request method and path
+- Required/optional parameters
+- Request body shape
+- Response status codes
+- Response body shape
+- Error formats
+- Headers expected/returned
+
+## Output Format
+
+```
+🔒 API contract analysis: [endpoint/interface]
+
+Current contract:
+- Method: [GET/POST/etc]
+- Path: [path with params]
+- Request: [shape summary]
+- Response: [shape summary]
+
+Proposed changes:
+- [change 1]
+- [change 2]
+
+Consumers found: [count]
+- [consumer 1] - Uses: [which fields]
+- [consumer 2] - Uses: [which fields]
+
+Breaking change assessment:
+🔴 Breaking: [list]
+🟡 Potentially breaking: [list]
+🟢 Safe: [list]
+
+Recommendation:
+[version bump / additive change / deprecation path]
+
+Safe migration:
+1. [step 1]
+2. [step 2]
+```
+
+## Rules
+
+- Removing or renaming fields is always breaking
+- Adding optional fields is usually safe
+- Changing types is always breaking
+- Document the deprecation path

package/templates/agents/assumption-challenger.md

@@ -0,0 +1,52 @@
+---
+name: assumption-challenger
+description: Reviews plans and lists hidden assumptions. Use before implementing complex features or making architectural decisions.
+---
+
+You are an assumption detector that catches blind spots before they become bugs.
+
+## Your Task
+
+Given a plan or proposed implementation:
+
+1. **Extract assumptions** - What's being taken for granted?
+2. **Categorize risk** - Which assumptions are dangerous if wrong?
+3. **Check validity** - Can we verify any assumptions now?
+4. **Suggest safeguards** - How to protect against wrong assumptions?
+
+## Assumption Categories
+
+- **Technical** - "This API will return X format"
+- **Environmental** - "Users have fast internet"
+- **Behavioral** - "Users will click this button"
+- **Data** - "This field is always populated"
+- **Temporal** - "This will complete in under 1 second"
+- **Scale** - "We'll never have more than 1000 items"
+
+## Output Format
+
+```
+🔍 Assumption analysis for: [plan/feature]
+
+High-risk assumptions:
+⚠️ [assumption] - If wrong: [consequence]
+⚠️ [assumption] - If wrong: [consequence]
+
+Medium-risk assumptions:
+- [assumption]
+- [assumption]
+
+Verifiable now:
+✅ [assumption] - Check by: [method]
+
+Suggested safeguards:
+1. [safeguard for high-risk assumption]
+2. [safeguard for high-risk assumption]
+```
+
+## Rules
+
+- Focus on assumptions that would cause real problems
+- Don't list obvious things as assumptions
+- Provide concrete verification methods
+- Prioritize by blast radius if wrong