claude-code-orchestrator-kit 1.4.1 → 1.4.15

package/.claude/skills/lead-research-assistant/SKILL.md

@@ -0,0 +1,199 @@
+---
+name: lead-research-assistant
+description: Identifies high-quality leads for your product or service by analyzing your business, searching for target companies, and providing actionable contact strategies. Perfect for sales, business development, and marketing professionals.
+---
+
+# Lead Research Assistant
+
+This skill helps you identify and qualify potential leads for your business by analyzing your product/service, understanding your ideal customer profile, and providing actionable outreach strategies.
+
+## When to Use This Skill
+
+- Finding potential customers or clients for your product/service
+- Building a list of companies to reach out to for partnerships
+- Identifying target accounts for sales outreach
+- Researching companies that match your ideal customer profile
+- Preparing for business development activities
+
+## What This Skill Does
+
+1. **Understands Your Business**: Analyzes your product/service, value proposition, and target market
+2. **Identifies Target Companies**: Finds companies that match your ideal customer profile based on:
+   - Industry and sector
+   - Company size and location
+   - Technology stack and tools they use
+   - Growth stage and funding
+   - Pain points your product solves
+3. **Prioritizes Leads**: Ranks companies based on fit score and relevance
+4. **Provides Contact Strategies**: Suggests how to approach each lead with personalized messaging
+5. **Enriches Data**: Gathers relevant information about decision-makers and company context
+
+## How to Use
+
+### Basic Usage
+
+Simply describe your product/service and what you're looking for:
+
+```
+I'm building [product description]. Find me 10 companies in [location/industry] 
+that would be good leads for this.
+```
+
+### With Your Codebase
+
+For even better results, run this from your product's source code directory:
+
+```
+Look at what I'm building in this repository and identify the top 10 companies 
+in [location/industry] that would benefit from this product.
+```
+
+### Advanced Usage
+
+For more targeted research:
+
+```
+My product: [description]
+Ideal customer profile:
+- Industry: [industry]
+- Company size: [size range]
+- Location: [location]
+- Current pain points: [pain points]
+- Technologies they use: [tech stack]
+
+Find me 20 qualified leads with contact strategies for each.
+```
+
+## Instructions
+
+When a user requests lead research:
+
+1. **Understand the Product/Service**
+   - If in a code directory, analyze the codebase to understand the product
+   - Ask clarifying questions about the value proposition
+   - Identify key features and benefits
+   - Understand what problems it solves
+
+2. **Define Ideal Customer Profile**
+   - Determine target industries and sectors
+   - Identify company size ranges
+   - Consider geographic preferences
+   - Understand relevant pain points
+   - Note any technology requirements
+
+3. **Research and Identify Leads**
+   - Search for companies matching the criteria
+   - Look for signals of need (job postings, tech stack, recent news)
+   - Consider growth indicators (funding, expansion, hiring)
+   - Identify companies with complementary products/services
+   - Check for budget indicators
+
+4. **Prioritize and Score**
+   - Create a fit score (1-10) for each lead
+   - Consider factors like:
+     - Alignment with ICP
+     - Signals of immediate need
+     - Budget availability
+     - Competitive landscape
+     - Timing indicators
+
+5. **Provide Actionable Output**
+   
+   For each lead, provide:
+   - **Company Name** and website
+   - **Why They're a Good Fit**: Specific reasons based on their business
+   - **Priority Score**: 1-10 with explanation
+   - **Decision Maker**: Role/title to target (e.g., "VP of Engineering")
+   - **Contact Strategy**: Personalized approach suggestions
+   - **Value Proposition**: How your product solves their specific problem
+   - **Conversation Starters**: Specific points to mention in outreach
+   - **LinkedIn URL**: If available, for easy connection
+
+6. **Format the Output**
+
+   Present results in a clear, scannable format:
+
+   ```markdown
+   # Lead Research Results
+   
+   ## Summary
+   - Total leads found: [X]
+   - High priority (8-10): [X]
+   - Medium priority (5-7): [X]
+   - Average fit score: [X]
+   
+   ---
+   
+   ## Lead 1: [Company Name]
+   
+   **Website**: [URL]
+   **Priority Score**: [X/10]
+   **Industry**: [Industry]
+   **Size**: [Employee count/revenue range]
+   
+   **Why They're a Good Fit**:
+   [2-3 specific reasons based on their business]
+   
+   **Target Decision Maker**: [Role/Title]
+   **LinkedIn**: [URL if available]
+   
+   **Value Proposition for Them**:
+   [Specific benefit for this company]
+   
+   **Outreach Strategy**:
+   [Personalized approach - mention specific pain points, recent company news, or relevant context]
+   
+   **Conversation Starters**:
+   - [Specific point 1]
+   - [Specific point 2]
+   
+   ---
+   
+   [Repeat for each lead]
+   ```
+
+7. **Offer Next Steps**
+   - Suggest saving results to a CSV for CRM import
+   - Offer to draft personalized outreach messages
+   - Recommend prioritization based on timing
+   - Suggest follow-up research for top leads
+
+## Examples
+
+### Example 1: From Lenny's Newsletter
+
+**User**: "I'm building a tool that masks sensitive data in AI coding assistant queries. Find potential leads."
+
+**Output**: Creates a prioritized list of companies that:
+- Use AI coding assistants (Copilot, Cursor, etc.)
+- Handle sensitive data (fintech, healthcare, legal)
+- Have evidence in their GitHub repos of using coding agents
+- May have accidentally exposed sensitive data in code
+- Includes LinkedIn URLs of relevant decision-makers
+
+### Example 2: Local Business
+
+**User**: "I run a consulting practice for remote team productivity. Find me 10 companies in the Bay Area that recently went remote."
+
+**Output**: Identifies companies that:
+- Recently posted remote job listings
+- Announced remote-first policies
+- Are hiring distributed teams
+- Show signs of remote work challenges
+- Provides personalized outreach strategies for each
+
+## Tips for Best Results
+
+- **Be specific** about your product and its unique value
+- **Run from your codebase** if applicable for automatic context
+- **Provide context** about your ideal customer profile
+- **Specify constraints** like industry, location, or company size
+- **Request follow-up** research on promising leads for deeper insights
+
+## Related Use Cases
+
+- Drafting personalized outreach emails after identifying leads
+- Building a CRM-ready CSV of qualified prospects
+- Researching specific companies in detail
+- Analyzing competitor customer bases
+- Identifying partnership opportunities

package/.claude/skills/reuse-health-inline/SKILL.md

@@ -0,0 +1,248 @@
+---
+name: reuse-health-inline
+description: Inline orchestration workflow for code duplication detection and consolidation. Provides step-by-step phases for reuse-hunter detection, priority-based consolidation with reuse-fixer, and verification cycles.
+version: 2.0.0
+---
+
+# Code Reuse Health Check (Inline Orchestration)
+
+You ARE the orchestrator. Execute this workflow directly without spawning a separate orchestrator agent.
+
+## Workflow Overview
+
+```
+Detection → Validate → Consolidate by Priority → Verify → Repeat if needed
+```
+
+**Max iterations**: 3
+**Priorities**: high → medium → low
+
+---
+
+## Phase 1: Pre-flight
+
+1. **Setup directories**:
+   ```bash
+   mkdir -p .tmp/current/{plans,changes,backups}
+   ```
+
+2. **Validate environment**:
+   - Check `package.json` exists
+   - Check `type-check` and `build` scripts exist
+
+3. **Initialize TodoWrite**:
+   ```json
+   [
+     {"content": "Duplication detection", "status": "in_progress", "activeForm": "Detecting duplications"},
+     {"content": "Consolidate high priority duplications", "status": "pending", "activeForm": "Consolidating high priority"},
+     {"content": "Consolidate medium priority duplications", "status": "pending", "activeForm": "Consolidating medium priority"},
+     {"content": "Consolidate low priority duplications", "status": "pending", "activeForm": "Consolidating low priority"},
+     {"content": "Verification scan", "status": "pending", "activeForm": "Verifying consolidation"}
+   ]
+   ```
+
+---
+
+## Phase 2: Detection
+
+**Invoke reuse-hunter** via Task tool:
+
+```
+subagent_type: "reuse-hunter"
+description: "Detect all code duplications"
+prompt: |
+  Scan the entire codebase for code duplications:
+  - Duplicated TypeScript interfaces/types
+  - Duplicated Zod schemas
+  - Duplicated constants and configuration objects
+  - Copy-pasted utility functions
+  - Similar code patterns that should be abstracted
+  - Categorize by priority (high/medium/low)
+
+  Generate: reuse-hunting-report.md
+
+  Return summary with duplication counts per priority.
+```
+
+**After reuse-hunter returns**:
+1. Read `reuse-hunting-report.md`
+2. Parse duplication counts by priority
+3. If zero duplications → skip to Final Summary
+4. Update TodoWrite: mark detection complete
+
+---
+
+## Phase 3: Quality Gate (Detection)
+
+Run inline validation:
+
+```bash
+pnpm type-check
+pnpm build
+```
+
+- If both pass → proceed to consolidation
+- If fail → report to user, exit
+
+---
+
+## Phase 4: Consolidation Loop
+
+**For each priority** (high → medium → low):
+
+1. **Check if duplications exist** for this priority
+   - If zero → skip to next priority
+
+2. **Update TodoWrite**: mark current priority in_progress
+
+3. **Invoke reuse-fixer** via Task tool:
+   ```
+   subagent_type: "reuse-fixer"
+   description: "Consolidate {priority} duplications"
+   prompt: |
+     Read reuse-hunting-report.md and consolidate all {priority} priority duplications.
+
+     For each duplication:
+     1. Backup files before editing
+     2. Determine canonical location (usually shared-types or shared package)
+     3. Create/update canonical file with the type/schema/constant
+     4. Replace duplicates with imports/re-exports
+     5. Log change to .tmp/current/changes/reuse-changes.json
+
+     Generate/update: reuse-consolidation-implemented.md
+
+     Return: count of consolidated items, count of failed consolidations.
+   ```
+
+4. **Quality Gate** (inline):
+   ```bash
+   pnpm type-check
+   pnpm build
+   ```
+
+   - If FAIL → report error, suggest rollback, exit
+   - If PASS → continue
+
+5. **Update TodoWrite**: mark priority complete
+
+6. **Repeat** for next priority
+
+---
+
+## Phase 5: Verification
+
+After all priorities consolidated:
+
+1. **Update TodoWrite**: mark verification in_progress
+
+2. **Invoke reuse-hunter** (verification mode):
+   ```
+   subagent_type: "reuse-hunter"
+   description: "Verification scan"
+   prompt: |
+     Re-scan codebase after consolidation.
+     Compare with previous reuse-hunting-report.md.
+
+     Report:
+     - Duplications resolved (count)
+     - Duplications remaining (count)
+     - New duplications introduced (count)
+   ```
+
+3. **Decision**:
+   - If duplications_remaining == 0 → Final Summary
+   - If iteration < 3 AND duplications_remaining > 0 → Go to Phase 2
+   - If iteration >= 3 → Final Summary with remaining items
+
+---
+
+## Phase 6: Final Summary
+
+Generate summary for user:
+
+```markdown
+## Code Reuse Health Check Complete
+
+**Iterations**: {count}/3
+**Status**: {SUCCESS/PARTIAL}
+
+### Results
+- Found: {total} duplications
+- Consolidated: {consolidated} ({percentage}%)
+- Remaining: {remaining}
+
+### By Priority
+- High: {consolidated}/{total}
+- Medium: {consolidated}/{total}
+- Low: {consolidated}/{total}
+
+### Validation
+- Type Check: {status}
+- Build: {status}
+
+### Artifacts
+- Detection: `reuse-hunting-report.md`
+- Consolidation: `reuse-consolidation-implemented.md`
+```
+
+---
+
+## Error Handling
+
+**If quality gate fails**:
+```
+Rollback available: .tmp/current/changes/reuse-changes.json
+
+To rollback:
+1. Read changes log
+2. Restore files from .tmp/current/backups/
+3. Re-run workflow
+```
+
+**If worker fails**:
+- Report error to user
+- Suggest manual intervention
+- Exit workflow
+
+---
+
+## Duplication Categories
+
+**Types/Interfaces** (shared-types):
+- Database types
+- API types
+- Zod schemas
+- Common enums
+
+**Constants** (shared-types):
+- Configuration objects
+- MIME types, file limits
+- Feature flags
+
+**Utilities** (shared package or re-export):
+- Helper functions
+- Validation utilities
+- Formatters
+
+**Single Source of Truth Pattern**:
+1. Canonical location: `packages/shared-types/src/`
+2. Other packages: `export * from '@package/shared-types/{module}'`
+3. NEVER copy code between packages
+
+---
+
+## Key Differences from Old Approach
+
+| Old (Orchestrator Agent) | New (Inline Skill) |
+|--------------------------|-------------------|
+| 9+ orchestrator calls | 0 orchestrator calls |
+| ~1400 lines (cmd + agent) | ~150 lines |
+| Context reload each call | Single session context |
+| Plan files for each phase | Direct execution |
+| ~10,000+ tokens overhead | ~500 tokens |
+
+---
+
+## Worker Prompts
+
+See `references/worker-prompts.md` for detailed prompts.