@esreekarreddy/ai-prompts 1.0.0

package/templates/claude-md/auto-enhance.md

@@ -0,0 +1,258 @@
+# AI Library Auto-Enhancement Integration
+
+Add this snippet to your project's `CLAUDE.md` or `.claude/instructions.md` to enable automatic prompt enhancement.
+
+---
+
+## Quick Setup (Copy This)
+
+```markdown
+## AI Library Integration
+
+You have access to the AI Library MCP server with powerful prompts, skills, and workflows.
+
+### Automatic Enhancement Protocol
+
+**CRITICAL: For any substantial task, ALWAYS enhance first:**
+
+1. **Before starting work**, call `enhance_prompt` with the user's request
+2. **Load recommended prompts** using `get_prompt` for each suggestion
+3. **Apply the guidance** to produce higher-quality output
+
+### When to Enhance
+
+ALWAYS call `enhance_prompt` when asked to:
+- Build, create, or implement features
+- Fix bugs or debug issues  
+- Review or refactor code
+- Design systems or architecture
+- Write documentation or specs
+
+### Enhancement Examples
+
+**User asks:** "Build a user authentication system"
+**You do:**
+1. `enhance_prompt("Build a user authentication system")` → gets security-review, new-feature chain
+2. `get_prompt("security-review")` → load security guidance
+3. `run_chain("new-feature")` → follow structured development flow
+4. Build with all context applied
+
+**User asks:** "This API is slow, fix it"
+**You do:**
+1. `enhance_prompt("This API is slow, fix it")` → gets deep-debugger, performance patterns
+2. `get_prompt("deep-debugger")` → load systematic debugging methodology
+3. Apply the 5-phase debugging process
+
+### Thinking Depth
+
+For complex problems, use thinking modifiers:
+- `get_prompt("ultrathink")` - Deep analysis with multiple perspectives
+- `get_prompt("megathink")` - Maximum depth for architecture decisions
+
+### Available Tools
+
+- `list_prompts` - Browse all available prompts
+- `get_prompt(name)` - Load a specific prompt
+- `search_prompts(query)` - Find relevant prompts
+- `enhance_prompt(request)` - Auto-detect and suggest prompts
+- `run_chain(name)` - Execute multi-step workflows
+- `compose_prompt(prompts[])` - Combine multiple prompts
+```
+
+---
+
+## Full Integration (Recommended for Teams)
+
+For comprehensive integration, add this expanded version:
+
+```markdown
+## AI Library Integration
+
+You have access to the AI Library MCP server - a curated collection of world-class prompts, skills, and workflows developed to Anthropic engineer standards.
+
+### Core Principle
+
+**Never work without context.** The library contains hard-won patterns for:
+- Secure, performant code
+- Systematic debugging
+- Thorough code review
+- Production-ready features
+
+### Automatic Enhancement Protocol
+
+**For EVERY substantial task:**
+
+1. **Enhance First**
+   - Call `enhance_prompt(user_request)` immediately
+   - This detects task type and returns relevant resources
+   
+2. **Load Resources**
+   - Call `get_prompt(name)` for each recommended prompt
+   - These contain detailed methodologies and checklists
+   
+3. **Apply Guidance**
+   - Integrate the patterns into your work
+   - Follow any checklists or phase structures
+
+4. **Use Chains for Multi-Step Work**
+   - `run_chain("new-feature")` for feature development
+   - `run_chain("bug-fix")` for debugging
+   - `run_chain("code-review")` for thorough reviews
+
+### Task-Specific Protocols
+
+#### Building Features
+```
+enhance_prompt("build X") → new-feature chain, prd-generator
+get_prompt("prd-generator") → create proper requirements
+run_chain("new-feature") → follow implementation phases
+```
+
+#### Debugging
+```
+enhance_prompt("fix/debug X") → deep-debugger, systematic approach
+get_prompt("deep-debugger") → 5-phase methodology
+Apply: Observe → Hypothesize → Test → Fix → Verify
+```
+
+#### Code Review
+```
+enhance_prompt("review X") → code-review-advanced
+get_prompt("code-review-advanced") → 4-lens analysis
+Check: Correctness → Security → Performance → Maintainability
+```
+
+#### Architecture
+```
+enhance_prompt("design/architect X") → megathink, system-design
+get_prompt("megathink") → maximum thinking depth
+Apply structured analysis before any code
+```
+
+### Thinking Depth Modifiers
+
+Load these for complex reasoning:
+
+| Modifier | When to Use |
+|----------|-------------|
+| `ultrathink` | Multi-file changes, tricky bugs, design decisions |
+| `megathink` | Architecture, security-critical, breaking changes |
+
+### Quality Standards
+
+When the library prompts specify standards, follow them:
+- Security checklists must pass before completion
+- Performance considerations must be documented
+- Edge cases must be explicitly handled
+- Error handling must be comprehensive
+
+### Available Tools Reference
+
+| Tool | Purpose |
+|------|---------|
+| `list_prompts` | Browse all prompts by category |
+| `get_prompt(name)` | Load specific prompt content |
+| `search_prompts(query)` | Find prompts by keyword |
+| `enhance_prompt(request)` | Auto-enhance any request |
+| `run_chain(name)` | Execute workflow chains |
+| `compose_prompt(names[])` | Combine multiple prompts |
+| `get_context(name)` | Load stack/pattern guides |
+| `quick_prompt(type, context)` | Generate instant prompts |
+```
+
+---
+
+## Minimal Integration (Just the Essentials)
+
+For quick setup, add just this:
+
+```markdown
+## AI Library
+
+Use `enhance_prompt(request)` before any substantial task.
+Use `get_prompt("ultrathink")` for complex problems.
+```
+
+---
+
+## How It Works
+
+### The Enhancement Flow
+
+```
+User Request
+     ↓
+enhance_prompt() ← Detects: building? debugging? reviewing?
+     ↓
+Returns: Relevant prompts, chains, guidance
+     ↓
+get_prompt() ← Load each recommended resource
+     ↓
+Apply patterns to produce better output
+```
+
+### Why This Works
+
+1. **No forgotten context** - Enhancement catches what you might miss
+2. **Consistent quality** - Same methodology every time
+3. **Security by default** - Security prompts auto-loaded for auth, data, APIs
+4. **Faster debugging** - Systematic approach beats random trying
+
+---
+
+## Verification
+
+To verify the integration is working:
+
+1. Ask Claude to "build a login form"
+2. Claude should automatically call `enhance_prompt`
+3. Claude should load security and feature prompts
+4. The implementation should follow structured methodology
+
+If Claude doesn't auto-enhance, ensure:
+- The MCP server is running
+- The CLAUDE.md snippet is in your project
+- You're using a supported Claude interface
+
+---
+
+## Customization
+
+### Add Project-Specific Prompts
+
+Extend the library with your patterns:
+
+```markdown
+### Project-Specific Enhancement
+
+In addition to AI Library tools, also load:
+- Our API design doc at `/docs/api-standards.md`
+- Our component patterns at `/docs/component-guide.md`
+```
+
+### Enforce Specific Standards
+
+```markdown
+### Mandatory Standards
+
+ALWAYS apply these after enhancement:
+- Run `get_prompt("security-review")` for any auth/data code
+- Use `get_prompt("typescript-react")` for frontend work
+- Apply `get_prompt("code-review-advanced")` before completing PRs
+```
+
+---
+
+## Troubleshooting
+
+**Claude isn't using enhance_prompt automatically**
+- Add explicit instruction: "ALWAYS call enhance_prompt FIRST for any substantial task"
+- Check MCP server is connected in Claude Desktop settings
+
+**Prompts aren't loading**
+- Run `list_prompts` to verify server connection
+- Check server logs for errors
+
+**Enhancement suggestions don't match task**
+- The `enhance_prompt` tool uses keyword detection
+- For edge cases, manually call `search_prompts(query)`

package/templates/claude-md/cli-tool.md

@@ -0,0 +1,243 @@
+# CLAUDE.md - CLI Tool Template
+
+> Project context for command-line tools
+
+Copy this file to your project root as `CLAUDE.md`.
+
+---
+
+# Project: [CLI Name]
+
+A command-line tool for [purpose].
+
+## Quick Start
+
+```bash
+# Install dependencies
+npm install
+
+# Run in development
+npm run dev -- [command] [args]
+
+# Build
+npm run build
+
+# Install globally (for testing)
+npm link
+
+# Run tests
+npm test
+```
+
+## Tech Stack
+
+- **Language**: TypeScript
+- **CLI Framework**: Commander.js / Yargs
+- **Output**: Chalk + Ora (spinners)
+- **Config**: Cosmiconfig
+- **Testing**: Vitest
+
+## Project Structure
+
+```
+.
+├── src/
+│   ├── index.ts              # Entry point
+│   ├── cli.ts                # CLI setup and commands
+│   ├── commands/
+│   │   ├── init.ts
+│   │   ├── run.ts
+│   │   └── config.ts
+│   ├── lib/
+│   │   ├── config.ts         # Config loading
+│   │   ├── logger.ts         # Console output
+│   │   └── utils.ts
+│   └── types/
+│       └── index.ts
+├── tests/
+├── bin/
+│   └── cli.js                # Executable entry
+├── package.json
+└── tsconfig.json
+```
+
+## CLI Structure
+
+### Entry Point
+```typescript
+// src/cli.ts
+import { Command } from 'commander';
+import { initCommand } from './commands/init';
+import { runCommand } from './commands/run';
+
+const program = new Command();
+
+program
+  .name('mycli')
+  .description('Description of what this CLI does')
+  .version('1.0.0');
+
+program
+  .command('init')
+  .description('Initialize a new project')
+  .option('-t, --template <name>', 'Template to use', 'default')
+  .action(initCommand);
+
+program
+  .command('run <file>')
+  .description('Run a file')
+  .option('-w, --watch', 'Watch for changes')
+  .action(runCommand);
+
+program.parse();
+```
+
+### Command Pattern
+```typescript
+// src/commands/init.ts
+import { logger } from '../lib/logger';
+import { loadConfig } from '../lib/config';
+
+interface InitOptions {
+  template: string;
+}
+
+export async function initCommand(options: InitOptions) {
+  const spinner = logger.spinner('Initializing project...');
+  
+  try {
+    // Do the work
+    await createProject(options.template);
+    
+    spinner.succeed('Project initialized!');
+  } catch (error) {
+    spinner.fail('Failed to initialize');
+    logger.error(error.message);
+    process.exit(1);
+  }
+}
+```
+
+### Logger Utility
+```typescript
+// src/lib/logger.ts
+import chalk from 'chalk';
+import ora from 'ora';
+
+export const logger = {
+  info: (msg: string) => console.log(chalk.blue('ℹ'), msg),
+  success: (msg: string) => console.log(chalk.green('✓'), msg),
+  warn: (msg: string) => console.log(chalk.yellow('⚠'), msg),
+  error: (msg: string) => console.log(chalk.red('✗'), msg),
+  spinner: (msg: string) => ora(msg).start(),
+};
+```
+
+### Configuration Loading
+```typescript
+// src/lib/config.ts
+import { cosmiconfig } from 'cosmiconfig';
+
+const explorer = cosmiconfig('mycli');
+
+export async function loadConfig() {
+  const result = await explorer.search();
+  if (!result) {
+    return getDefaultConfig();
+  }
+  return { ...getDefaultConfig(), ...result.config };
+}
+```
+
+## Coding Standards
+
+### Error Handling
+```typescript
+// Always exit with proper codes
+process.exit(0);  // Success
+process.exit(1);  // Error
+
+// Catch and format errors
+try {
+  await riskyOperation();
+} catch (error) {
+  if (error instanceof UserError) {
+    logger.error(error.message);
+    process.exit(1);
+  }
+  // Unexpected error - show stack in debug mode
+  throw error;
+}
+```
+
+### User Prompts
+```typescript
+import { confirm, input, select } from '@inquirer/prompts';
+
+const name = await input({ message: 'Project name:' });
+const confirmed = await confirm({ message: 'Continue?' });
+const choice = await select({
+  message: 'Select template:',
+  choices: [
+    { value: 'basic', name: 'Basic' },
+    { value: 'full', name: 'Full' },
+  ],
+});
+```
+
+### Progress Indication
+```typescript
+import ora from 'ora';
+
+const spinner = ora('Loading...').start();
+// Do work
+spinner.text = 'Processing...';
+// More work
+spinner.succeed('Done!');
+// Or on error
+spinner.fail('Failed');
+```
+
+## Testing CLIs
+
+```typescript
+// tests/cli.test.ts
+import { execSync } from 'child_process';
+
+describe('CLI', () => {
+  it('should show help', () => {
+    const output = execSync('node ./bin/cli.js --help').toString();
+    expect(output).toContain('Usage:');
+  });
+
+  it('should init project', () => {
+    const output = execSync('node ./bin/cli.js init --template basic').toString();
+    expect(output).toContain('initialized');
+  });
+});
+```
+
+## Package.json Setup
+
+```json
+{
+  "name": "mycli",
+  "bin": {
+    "mycli": "./bin/cli.js"
+  },
+  "files": ["bin", "dist"],
+  "scripts": {
+    "dev": "tsx src/cli.ts",
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  }
+}
+```
+
+## Executable Entry
+
+```javascript
+// bin/cli.js
+#!/usr/bin/env node
+require('../dist/cli.js');
+```