nemonix-cli 1.0.0

package/src/config/claude-code-config/commands/prompts/saas-create-tasks.md

@@ -0,0 +1,240 @@
+---
+description: Generate implementation task files from PRD and Architecture documents
+---
+
+<objective>
+Generate a structured set of implementation task files from existing PRD and Architecture documents.
+
+Create well-scoped, coherent tasks that an AI agent can execute autonomously. Each task represents 1-3 hours of focused work with clear deliverables and success criteria. This comes AFTER PRD and ARCHI - both must exist first.
+</objective>
+
+<context>
+Current project: !`ls -la`
+Existing specs folder: !`ls specs/ 2>/dev/null || echo "No specs folder"`
+Package.json: !`cat package.json 2>/dev/null | head -20 || echo "No package.json"`
+</context>
+
+<process>
+## Phase 1: Understanding
+
+1. **Ask for project location**:
+   > "Where is your project located? Are you starting from scratch or using a boilerplate?"
+
+2. **Explore existing codebase**:
+   - Read `package.json` for dependencies
+   - Check folder structure (`app/`, `src/`, `components/`)
+   - Identify what's already implemented
+
+3. **Document current state**:
+   - ✅ Already implemented: [list]
+   - 🚧 Partially implemented: [list]
+   - ❌ Not yet built: [list]
+
+4. **Ask for PRD location**, then read completely:
+   - Extract all features
+   - Note user flows
+   - Identify MVP scope vs post-MVP
+
+5. **Ask for ARCHI location**, then read completely:
+   - Note all technology choices
+   - Understand patterns to follow
+   - Identify integration points
+
+## Phase 2: Deep Analysis
+
+6. **Map features to implementation**:
+   - [Feature 1] → Database models, UI, API, validation needed
+   - [Feature 2] → Real-time, file storage, background jobs needed
+   - [Feature 3] → Auth, permissions, notifications needed
+
+7. **Create dependency graph**:
+```
+Foundation Layer (Database, Auth, Base UI)
+    ↓
+Core Features Layer (Primary user functionality)
+    ↓
+Integration Layer (Third-party services)
+    ↓
+Polish Layer (Error handling, optimization)
+```
+
+8. **Identify what can be parallelized** vs what is sequential
+
+## Phase 3: Verify Before Creating
+
+9. **Confirm checklist complete**:
+   - ✅ Codebase understood
+   - ✅ All PRD features extracted
+   - ✅ All ARCHI decisions understood
+   - ✅ Dependencies mapped
+   - ✅ Foundation identified
+   - ✅ Integration points clear
+   - ✅ Success criteria defined
+
+**IF ANY MISSING**: Do more analysis first. Do NOT create tasks with gaps.
+
+## Phase 4: Generate Task Files
+
+10. **Create folder structure**:
+    ```bash
+    mkdir -p specs/01-mvp
+    ```
+
+11. **Create individual task files** in `specs/01-mvp/`:
+    - Naming: `01-task-name.md`, `02-task-name.md`
+    - Use 2-digit numbering with kebab-case names
+
+12. **Task file structure**:
+
+```markdown
+# Task [Number]: [Action-Oriented Title]
+
+## Context
+[Connection to PRD feature and overall vision]
+
+## Scope
+[Specific deliverables for this task]
+
+## Implementation Details
+
+### Files to Create/Modify
+- `path/to/file.ts` - [Purpose]
+
+### Key Functionality
+- [What the code should do]
+
+### Technologies Used
+- [From ARCHI with how it's used]
+
+### Architectural Patterns
+[Patterns from ARCHI to follow]
+
+## Success Criteria
+- [ ] [Testable outcome 1]
+- [ ] [Testable outcome 2]
+- [ ] [Testable outcome 3]
+
+## Testing & Validation
+
+### Manual Testing Steps
+1. [Step]
+2. [Step]
+
+### Edge Cases
+- [Edge case]
+
+## Dependencies
+
+**Must complete first**:
+- Task [N]: [Name]
+
+**Blocks**:
+- Task [X]: [Name]
+
+## Related Documentation
+- **PRD**: [Reference]
+- **ARCHI**: [Reference]
+
+---
+**Estimated Time**: [1-3 hours]
+**Phase**: [Foundation / Core / Integration / Polish]
+```
+
+13. **Create README overview** at `specs/README.md`:
+
+```markdown
+# Implementation Tasks Overview
+
+## Project Summary
+**From PRD**: [Summary]
+**Tech Stack**: [From ARCHI]
+**Current State**: [What exists]
+
+## Task Execution Guidelines
+- Read complete task before starting
+- Check dependencies are met
+- Follow ARCHI patterns
+- Validate against success criteria
+
+## MVP Tasks (specs/01-mvp/)
+
+### Phase 1: Foundation
+- [ ] `01-name.md` - [Description]
+- [ ] `02-name.md` - [Description]
+
+### Phase 2: Core Features
+- [ ] `03-name.md` - [Description]
+- [ ] `04-name.md` - [Description]
+
+### Phase 3: Integration
+- [ ] `05-name.md` - [Description]
+
+### Phase 4: Polish
+- [ ] `06-name.md` - [Description]
+
+## Dependency Map
+[Visual dependency graph]
+
+## PRD Coverage
+- ✅ [Feature]: Task [N]
+- ✅ [Feature]: Task [N]
+
+## Total Estimated Time: [X-Y hours]
+```
+</process>
+
+<constraints>
+**TASK SIZING**:
+
+❌ **Too Small**:
+- "Add TypeScript type"
+- "Create button component"
+- "Add validation to field"
+
+❌ **Too Large**:
+- "Implement complete auth system"
+- "Build entire dashboard"
+
+✅ **Just Right** (1-3 hours):
+- "Create user authentication flow with email/password and session management"
+- "Build dashboard layout with navigation and responsive design"
+- "Implement checkout with Stripe integration and webhooks"
+
+**OUTPUT FORMAT**:
+- NEVER create single document with all tasks
+- ALWAYS create individual files in `specs/01-mvp/`
+- ALWAYS create `specs/README.md` overview
+- Use 2-digit numbering (01-, 02-, 03-)
+
+**QUALITY**:
+- Every task links to PRD feature
+- Every task follows ARCHI patterns
+- Every task has testable success criteria
+- Every task has clear dependencies
+</constraints>
+
+<output>
+**Created files**:
+- `specs/README.md` - Overview with dependency map
+- `specs/01-mvp/01-name.md` through `specs/01-mvp/[N]-name.md` - Individual task files
+
+**Each task file contains**:
+- Context connecting to PRD
+- Specific scope and deliverables
+- Files to create/modify
+- Technologies from ARCHI
+- Testable success criteria
+- Dependencies (before and blocks)
+- Time estimate
+</output>
+
+<success_criteria>
+- All PRD features mapped to specific tasks
+- All ARCHI decisions reflected in task patterns
+- Tasks ordered correctly by dependencies
+- Each task is 1-3 hours of work
+- Each task has clear success criteria
+- Individual files created in `specs/01-mvp/`
+- README created with complete overview
+- No orphan tasks (everything connected)
+</success_criteria>

package/src/config/claude-code-config/commands/prompts/saas-define-pricing.md

@@ -0,0 +1,293 @@
+---
+description: Create a data-driven SaaS pricing strategy with competitor research and value-based pricing
+---
+
+<objective>
+Create a comprehensive pricing strategy for a SaaS application using value-based pricing frameworks.
+
+Research competitors, select the optimal value metric, calculate price points using proven frameworks, and design a tier structure that aligns with customer success. This comes AFTER the PRD and ARCHI - both must be read first.
+</objective>
+
+<process>
+## Phase 1: Read Foundation Documents
+
+1. **Ask for PRD location**, then read completely:
+   - Core features and value proposition
+   - Target users and personas
+   - Problem solved and outcomes delivered
+   - Differentiation from competitors
+
+2. **Ask for ARCHI location**, then read completely:
+   - Technical capabilities and scale
+   - Infrastructure costs (variable costs)
+   - Feature complexity (premium justification)
+
+3. **Note pricing implications**:
+   - Enterprise target → Higher prices, annual contracts
+   - Self-serve PLG → Need free/starter tier
+   - AI features → Usage-based or tiered by capabilities
+   - Multi-user → Per-seat or team pricing
+   - High infrastructure costs → Usage-based component
+
+## Phase 2: Information Gathering
+
+4. **Ask questions progressively** (not all at once):
+
+**Pricing Goals**:
+
+- Primary goal? (Fast growth, profitability, market share)
+- Target segments? (SMB, mid-market, enterprise, or all)
+- Target ARPU?
+- Any constraints? (Must be under $X, must have free tier)
+
+**Competitive Context**:
+
+- Top 3-5 direct competitors?
+- Mature market or new category?
+- Positioning goal? (Premium, competitive, penetration)
+
+**Customer Value**:
+
+- What value does product deliver? (Time saved, revenue, costs reduced)
+- Can you quantify? (e.g., "Saves 10 hours/week")
+- What do current solutions cost?
+- Cost of the problem you solve?
+
+**Usage Patterns**:
+
+- How do users naturally scale? (More projects, users, data)
+- Main resource constraint? (Storage, API calls, seats, features)
+- Do different users get different value?
+
+## Phase 3: Competitor Research
+
+5. **Research 5-10 competitors** using web search:
+   - Search: "[Competitor] pricing"
+   - Document for each:
+     - Pricing model (Freemium, tiered, usage-based)
+     - Value metric (What they charge for)
+     - Tier names and exact prices
+     - Features per tier
+     - Free tier limits
+
+6. **Create comparison table**:
+
+```
+| Competitor | Model | Value Metric | Starter | Pro | Enterprise |
+|------------|-------|--------------|---------|-----|------------|
+```
+
+## Phase 4: Value Metric Selection
+
+7. **List potential metrics** for the product:
+   - Per-seat/users
+   - Usage-based (API calls, operations)
+   - Storage/data (GB, records)
+   - Projects/workspaces
+   - Features/tiers
+   - Outcomes (revenue %, savings)
+
+8. **Score each metric** using Todd Gardner's 7 Criteria (1-10):
+   1. Easy to Understand: Can explain in elevator ride?
+   2. Fair Perception: Does customer feel it's equitable?
+   3. Competitive Alignment: Familiar in category?
+   4. Measurable: Can track automatically?
+   5. Correlates with Value: Grows as customer succeeds?
+   6. Scalable: No artificial ceilings?
+   7. Predictable Revenue: Enables forecasting?
+
+9. **Select metric** scoring 7+ on ALL criteria
+
+## Phase 5: Price Calculation
+
+10. **Apply Lincoln Murphy's 10x Rule**:
+    - Price = 10-30% of value created
+
+11. **Calculate for each persona**:
+    - Quantify customer value (time saved, revenue, costs)
+    - Calculate: Value × 10-20%
+
+12. **Apply competitive context**:
+    - Premium: 110-150% of market leader
+    - Competitive: 90-110% of leader
+    - Penetration: 60-90% of leader
+
+13. **Apply psychological pricing**:
+    - SMB/PLG: Charm pricing ($29, $99, $299)
+    - Enterprise: Round numbers ($500, $1000)
+
+## Phase 6: Tier Structure
+
+14. **Design 3-4 tiers**:
+
+**Free/Starter** ($0 or $19-49):
+
+- Purpose: Lead generation, product validation
+- Limits: Entry level (can demonstrate value)
+- Features: Core only
+
+**Professional** ($Y - TARGET 50-60% of customers):
+
+- Purpose: Primary revenue driver
+- Price: 2-3x Starter
+- Limits: 2-5x Starter
+- Features: Full core + key differentiators
+
+**Business** ($Z):
+
+- Purpose: High-value customers
+- Price: 2-3x Pro
+- Limits: 5-10x Starter or unlimited
+- Features: Everything + advanced
+
+**Enterprise** (Custom):
+
+- Purpose: Strategic accounts
+- Features: SSO, dedicated support, custom SLAs
+
+## Phase 7: Generate PRICING.md
+
+15. **Create PRICING.md** in same directory as PRD:
+
+```markdown
+# SaaS Pricing Strategy: [Product Name]
+
+## Executive Summary
+
+[2-3 paragraphs: approach, value metric, positioning, expected outcomes]
+
+## Value Metric
+
+**Selected**: [Primary metric]
+**Justification** (7 Criteria scores):
+
+1. Easy to Understand: [Score]
+2. Fair Perception: [Score]
+3. Competitive Alignment: [Score]
+4. Measurable: [Score]
+5. Correlates with Value: [Score]
+6. Scalable: [Score]
+7. Predictable Revenue: [Score]
+
+## Pricing Tiers
+
+### Free/Starter - $X/month
+
+**Target**: [Segment]
+**Limits**: [Primary metric limit]
+**Features**: [List]
+**Best for**: [Use case]
+
+### Professional - $Y/month ⭐ RECOMMENDED
+
+**Target**: [Segment]
+**Limits**: [Limits]
+**Features**: [List]
+**Upgrade trigger**: [What makes users outgrow Starter]
+
+### Business - $Z/month
+
+**Target**: [Segment]
+**Limits**: [Limits]
+**Features**: [List]
+
+### Enterprise - Custom
+
+**Target**: Large organizations
+**Features**: SSO, dedicated support, custom SLAs
+
+## Competitive Positioning
+
+**Strategy**: [Premium/Competitive/Value]
+**Rationale**: [Based on research and PRD]
+
+| Competitor | Model      | Metric       | Starter | Pro    | Enterprise |
+| ---------- | ---------- | ------------ | ------- | ------ | ---------- |
+| [Name]     | [Type]     | [Metric]     | $X      | $Y     | $Z         |
+| **Ours**   | **[Type]** | **[Metric]** | **$X**  | **$Y** | **$Z**     |
+
+## Pricing Justification
+
+### Value Calculation (10x Rule)
+
+**[Persona 1]**:
+
+- Value created: $[Amount]/month
+- Our price: $[Amount] ([X]% of value)
+- Customer ROI: [X]x
+
+## Implementation Roadmap
+
+### Phase 1: Launch (Month 1-3)
+
+- Launch tiers: [Which]
+- Free trial: [Duration]
+
+### Phase 2: Validation (Month 4-6)
+
+- A/B tests: [What]
+- Metrics: Conversion, ARPU, churn by tier
+
+### Phase 3: Optimization (Month 7-12)
+
+- Price adjustments
+- Feature migration
+
+## Success Metrics
+
+- Pricing page → trial: [X]%
+- Trial → paid: [X]%
+- ARPU: $[X]
+- [50-60]% in Pro tier
+- Monthly churn: <[X]%
+```
+
+</process>
+
+<constraints>
+**MANDATORY STEPS**:
+- ALWAYS read PRD and ARCHI first
+- ALWAYS research 5-10 competitors with actual prices
+- ALWAYS use Todd Gardner's 7 Criteria for metric selection
+- ALWAYS use Lincoln Murphy's 10x Rule for calculation
+- ALWAYS design 3-4 tiers (not more)
+
+**VALUE-BASED PRICING**:
+
+- Price on customer value, NOT your costs
+- 1% pricing improvement = 11% profit increase
+- Value metric selection > price point
+
+**DO NOT**:
+
+- Recommend pricing without competitor research
+- Skip value metric scoring
+- Copy competitors without understanding why
+- Create more than 4 tiers
+- Generate PRICING.md with gaps in research
+  </constraints>
+
+<output>
+**File created**: `PRICING.md` in same directory as PRD
+
+**Contains**:
+
+- Executive summary
+- Value metric with 7-criteria scoring
+- 3-4 tier structure with limits and features
+- Competitor comparison table
+- Pricing justification using 10x Rule
+- Implementation roadmap
+- Success metrics to track
+  </output>
+
+<success_criteria>
+
+- PRD and ARCHI read and understood
+- 5-10 competitors researched with actual prices
+- Value metric scored on all 7 criteria (all 7+)
+- Price calculated using 10x Rule
+- 3-4 tiers designed with clear upgrade triggers
+- Competitive positioning defined
+- PRICING.md created with complete research
+  </success_criteria>

package/src/config/claude-code-config/commands/prompts/saas-find-domain-name.md

@@ -0,0 +1,190 @@
+---
+description: Generate and validate domain name options with availability checking for brand and utility domains
+---
+
+<objective>
+Find the perfect domain name for a SaaS application through strategic generation and availability validation.
+
+Generate 15-25 domain options mixing brand names (memorable, unique) and utility names (descriptive, SEO-friendly), check availability via WHOIS, and provide top recommendations. This comes AFTER PRD and ARCHI.
+</objective>
+
+<process>
+## Phase 1: Read Foundation Documents
+
+1. **Ask for PRD and ARCHI file paths**, then read completely
+
+2. **Extract from PRD**:
+   - Core problem (informs utility names)
+   - Target users (informs tone)
+   - Unique value (informs brand positioning)
+   - Product category (informs naming conventions)
+
+3. **Extract from ARCHI**:
+   - Tech positioning (affects TLD choice)
+   - Developer focus (makes .dev, .io acceptable)
+   - Target market B2C/B2B/B2D (affects TLD priority)
+
+4. **Note naming implications**:
+   - B2C → Prefer .com
+   - Developer tool → .dev, .io acceptable
+   - Speed focus → Include Fast, Quick, Instant
+   - Monitoring → Include Watch, Monitor, Track
+   - AI-powered → Modern, tech-forward naming
+
+## Phase 2: Strategy Discussion
+
+5. **Ask user preferences**:
+
+**Brand vs Utility**:
+- Memorable brand or clear utility?
+- Serious company or fun tool tone?
+- Long-term brand or specific tool?
+
+**Domain Preferences**:
+- TLD priority: .com, .io, .dev, .app?
+- Budget: Standard ($10-50) or premium ($500+)?
+- Words to avoid or must include?
+
+**Tone**:
+- Professional (Stripe, Linear)?
+- Fun (Notion, Slack)?
+- Technical (Vercel, Supabase)?
+- Abstract (Aura, Flux)?
+
+## Phase 3: Generate Domain Options
+
+6. **Generate 15-25 domains** (40% brand, 60% utility):
+
+**Brand Domain Techniques**:
+- Invented words: Syllable combinations (Figma, Vercel)
+- Modified real words: Twisted existing words (Slack, Stripe)
+- Abstract concepts: Evocative words (Notion, Linear)
+- Short real words: Simple, memorable (Bolt, Frame)
+
+**Utility Domain Patterns**:
+- [Action][Noun]: MonitorFast, CheckPage
+- [Adjective][Noun]: FastMonitor, QuickCheck
+- [Noun][Action]: PageMonitor, SiteChecker
+- [Noun][Noun]: PageWatch, WebPulse
+
+**Word Banks by Category**:
+- Monitoring: Sentinel, Beacon, Pulse, Radar, Watch
+- Speed: Rapid, Swift, Bolt, Flash, Instant
+- Simplicity: Plain, Clear, Simple, Stark
+- AI/Intelligence: Sage, Cortex, Neural, Prism
+- Building: Forge, Craft, Build, Studio, Lab
+
+## Phase 4: Check Availability
+
+7. **Use WHOIS for each domain**:
+```bash
+whois example.com | grep -E "No match|NOT FOUND|Status: free"
+```
+
+8. **Check TLDs in priority order**:
+   - B2C SaaS: .com > .io > .app
+   - Developer Tools: .dev > .io > .com
+   - Modern Web Apps: .app > .io > .com
+
+9. **Document availability**:
+   - ✅ Available: Can register immediately
+   - ❌ Taken: Already registered
+   - ⚠️ Premium: Available at premium price
+
+## Phase 5: Generate Names.md
+
+10. **Create Names.md** in project directory:
+
+```markdown
+# Domain Names for [Project Name]
+
+## Brand Domains
+
+### Available
+
+**DomainName.com** - Available
+Short description of brand feeling.
+
+**DomainName.dev** - Available
+Short description of brand feeling.
+
+### Unavailable (Reference)
+
+**DomainName.io** - Taken
+Description for context.
+
+## Utility Domains
+
+### Available
+
+**DomainName.app** - Available
+Short description of what it communicates.
+
+### Unavailable (Reference)
+
+**DomainName.com** - Taken
+Description for reference.
+
+## Top Recommendations
+
+1. **[Domain.tld]** - [One sentence why best choice]
+2. **[Domain.tld]** - [One sentence why second]
+3. **[Domain.tld]** - [One sentence why third]
+```
+</process>
+
+<constraints>
+**DOMAIN QUALITY CRITERIA**:
+
+Brand Domains:
+- ✅ Easy to pronounce (phone test)
+- ✅ Easy to spell (no weird spellings)
+- ✅ Memorable and distinctive
+- ✅ No negative connotations
+- ✅ 2-3 syllables (5-10 chars)
+
+Utility Domains:
+- ✅ Immediately clear what it does
+- ✅ Contains relevant keywords
+- ✅ Professional and trustworthy
+- ✅ Length: 12-18 chars max
+
+**MANDATORY**:
+- ALWAYS read PRD and ARCHI first
+- ALWAYS check availability via WHOIS (don't guess)
+- ALWAYS generate 15-25 options
+- ALWAYS provide top 3 recommendations
+
+**DO NOT**:
+- Suggest domains without checking availability
+- Skip the strategy discussion
+- Generate only brand OR only utility (mix both)
+- Create overly long output file
+</constraints>
+
+<output>
+**File created**: `Names.md` in project directory
+
+**Contains**:
+- Brand domains (available + unavailable for reference)
+- Utility domains (available + unavailable for reference)
+- Top 3 recommendations with rationale
+- Clean, scannable format
+
+**Formatting**:
+- Domain names in bold
+- TLD included in name
+- Availability status on same line
+- One short sentence description (max 15 words)
+- Grouped by type and availability
+</output>
+
+<success_criteria>
+- PRD and ARCHI read and naming implications extracted
+- Strategy discussion completed (tone, TLD, budget)
+- 15-25 domain options generated (40% brand, 60% utility)
+- All domains checked via WHOIS
+- Names.md created with clean format
+- Top 3 recommendations with clear rationale
+- Available domains clearly separated from taken
+</success_criteria>