nemonix-cli 1.0.0

package/src/config/claude-code-config/skills/aibuilder-create-saas/references/architecture-template.md

@@ -0,0 +1,436 @@
+# Architecture Template & Guidelines
+
+Reference for designing technical architecture.
+
+---
+
+## Architecture Philosophy
+
+**Good architecture is:**
+- Simple (minimum complexity for requirements)
+- Documented (decisions and rationale)
+- Cost-aware (solo dev budget reality)
+- Practical (uses proven patterns)
+
+**Over-engineering signs:**
+- Tools you don't need yet
+- "Future-proofing" for unknown requirements
+- Complex patterns for simple problems
+- More than 2 weeks to MVP
+
+---
+
+## Architecture Document Structure
+
+```markdown
+# Technical Architecture: {Product Name}
+
+## Overview
+
+**Stack Summary:**
+- Framework: Next.js 15 with App Router
+- Database: {choice} + Prisma
+- Auth: Better Auth with {method}
+- Deployment: Vercel
+
+## Frontend Architecture
+
+### Core Stack
+| Tool | Purpose |
+|------|---------|
+| Next.js 15 | Framework |
+| TypeScript | Type safety |
+| Tailwind CSS | Styling |
+| shadcn/ui | Components |
+
+### State Management
+| Type | Solution |
+|------|----------|
+| Server state | TanStack Query |
+| URL state | nuqs |
+| Form state | React Hook Form + Zod |
+| Client state | Zustand (if needed) |
+
+### Data Fetching
+- Default: Server Components
+- Dynamic: TanStack Query
+- Mutations: Server Actions
+
+## Backend Architecture
+
+### API Layer
+- Server Actions via next-safe-action
+- Validation with Zod v4
+- Rate limiting: {approach}
+
+### Database
+- ORM: Prisma
+- Database: {Neon/Supabase}
+- Migrations: Prisma Migrate
+
+### Schema Overview
+```prisma
+model User {
+  id        String   @id @default(cuid())
+  email     String   @unique
+  name      String?
+  createdAt DateTime @default(now())
+}
+
+// Feature-specific models...
+```
+
+## Infrastructure
+
+### Deployment
+- Platform: Vercel
+- Environments: dev, preview, production
+
+### External Services
+| Service | Purpose | When to add |
+|---------|---------|-------------|
+| Resend | Email | When sending emails |
+| Stripe | Payments | When monetizing |
+
+## Folder Structure
+
+```
+/
+├── app/
+│   ├── (auth)/
+│   ├── (dashboard)/
+│   └── api/
+├── src/
+│   ├── components/
+│   ├── lib/
+│   ├── actions/
+│   └── hooks/
+└── prisma/
+```
+
+## Feature Implementation Map
+
+| PRD Feature | How to Build |
+|-------------|--------------|
+| {Feature 1} | {Implementation approach} |
+| {Feature 2} | {Implementation approach} |
+
+## Architecture Decisions
+
+### ADR-001: {Decision Title}
+- **Context**: {Why needed}
+- **Decision**: {What we chose}
+- **Rationale**: {Why this choice}
+- **Trade-offs**: {What we give up}
+
+## Cost Estimation
+
+| Service | Monthly Cost |
+|---------|-------------|
+| Vercel | $0-20 |
+| Database | $0-19 |
+| Email | $0 |
+| **Total** | ~$0-40 |
+```
+
+---
+
+## Common Patterns
+
+### Authentication Pattern
+```
+User → Login Page → Better Auth → Session Cookie → Protected Routes
+```
+
+### Data Mutation Pattern
+```
+Form Submit → Server Action → Zod Validation → Prisma → Revalidate → UI Update
+```
+
+### API Route Pattern
+```
+Request → Route Handler → Zod Validation → Business Logic → Response
+```
+
+---
+
+## Folder Structure Explained
+
+```
+app/
+├── (auth)/              # Public auth pages
+│   ├── login/
+│   └── signup/
+├── (dashboard)/         # Protected pages (layout with auth check)
+│   ├── dashboard/
+│   ├── settings/
+│   └── [feature]/
+├── (marketing)/         # Public marketing pages
+│   └── page.tsx         # Landing page
+└── api/                 # API routes (if needed)
+    └── webhooks/
+
+src/
+├── components/
+│   ├── ui/              # shadcn components
+│   ├── forms/           # Form components
+│   └── [feature]/       # Feature-specific components
+├── lib/
+│   ├── auth.ts          # Auth configuration
+│   ├── prisma.ts        # Prisma client
+│   └── utils.ts         # Utility functions
+├── actions/             # Server actions
+│   ├── auth.ts
+│   └── [feature].ts
+└── hooks/               # Custom React hooks
+```
+
+---
+
+## Decision Checklist
+
+Before adding any tool, ask:
+
+1. **Does the PRD require this?**
+   - If no, don't add it
+
+2. **What's the simplest solution?**
+   - Built-in > Library > Service
+
+3. **What's the cost?**
+   - Free tier limits?
+   - Scaling costs?
+
+4. **What's the trade-off?**
+   - Complexity added?
+   - Vendor lock-in?
+
+---
+
+## Plans & Limits Architecture (Better-Auth)
+
+**🚨 CRITICAL: Keep it simple - NO extra abstraction layers!**
+
+### Data Model
+
+```
+Organization → Resources (projects, files, etc.)
+Organization → Subscription → Plan → Limits
+```
+
+**❌ NEVER add:**
+- Workspace level
+- Team level (separate from Organization)
+- Project-level plans
+- Any other abstraction layer
+
+### Implementation Pattern
+
+**File: `src/lib/auth/stripe/auth-plans.ts`**
+
+```typescript
+// 1. Define default limits
+const DEFAULT_LIMIT = {
+  projects: 5,
+  storage: 10,      // in GB
+  members: 3,
+  aiCredits: 20,    // $ worth
+};
+
+export type PlanLimit = typeof DEFAULT_LIMIT;
+export type OverrideLimits = Partial<PlanLimit>;
+
+// 2. Define plans with Better-Auth structure
+export type AppAuthPlan = {
+  priceId?: string;
+  annualDiscountPriceId?: string;
+  name: string;
+  limits: PlanLimit;
+  description: string;
+  isPopular?: boolean;
+  price: number;
+  yearlyPrice?: number;
+  currency: string;
+  freeTrial?: {
+    days: number;
+    onTrialStart?: (subscription, ctx) => Promise<void>;
+    onTrialEnd?: (data, ctx) => Promise<void>;
+    onTrialExpired?: (subscription, ctx) => Promise<void>;
+  };
+  onSubscriptionCanceled?: (subscription, ctx) => Promise<void>;
+};
+
+// 3. Define your plans
+export const AUTH_PLANS: AppAuthPlan[] = [
+  {
+    name: "free",
+    description: "For individuals and small projects",
+    limits: DEFAULT_LIMIT,
+    price: 0,
+    currency: "USD",
+  },
+  {
+    name: "pro",
+    isPopular: true,
+    description: "For growing teams",
+    priceId: process.env.STRIPE_PRO_PLAN_ID ?? "",
+    annualDiscountPriceId: process.env.STRIPE_PRO_YEARLY_PLAN_ID ?? "",
+    limits: {
+      projects: 20,
+      storage: 50,
+      members: 10,
+      aiCredits: 50,
+    },
+    freeTrial: { days: 14 },
+    price: 49,
+    yearlyPrice: 400,
+    currency: "USD",
+  },
+  {
+    name: "ultra",
+    description: "Enterprise-grade",
+    priceId: process.env.STRIPE_ULTRA_PLAN_ID ?? "",
+    annualDiscountPriceId: process.env.STRIPE_ULTRA_YEARLY_PLAN_ID ?? "",
+    limits: {
+      projects: 100,
+      storage: 1000,
+      members: 100,
+      aiCredits: 200,
+    },
+    freeTrial: { days: 14 },
+    price: 100,
+    yearlyPrice: 1000,
+    currency: "USD",
+  },
+];
+
+// 4. Helper to get plan limits (with override support)
+export const getPlanLimits = (
+  plan = "free",
+  overrideLimits?: OverrideLimits | null,
+): PlanLimit => {
+  const planLimits = AUTH_PLANS.find((p) => p.name === plan)?.limits;
+  const baseLimits = planLimits ?? DEFAULT_LIMIT;
+
+  if (!overrideLimits) return baseLimits;
+
+  return { ...baseLimits, ...overrideLimits };
+};
+```
+
+### UI Configuration for Limits
+
+```typescript
+// Display config for pricing page
+export const LIMITS_CONFIG: Record<
+  keyof PlanLimit,
+  {
+    icon: React.ElementType;
+    getLabel: (value: number) => string;
+    description: string;
+  }
+> = {
+  projects: {
+    icon: FolderArchive,
+    getLabel: (value) => `${value} ${value === 1 ? "Project" : "Projects"}`,
+    description: "Create and manage projects",
+  },
+  storage: {
+    icon: HardDrive,
+    getLabel: (value) => `${value} GB Storage`,
+    description: "Cloud storage for your files",
+  },
+  members: {
+    icon: Users,
+    getLabel: (value) => `${value} Team ${value === 1 ? "Member" : "Members"}`,
+    description: "Invite team members",
+  },
+  aiCredits: {
+    icon: Bot,
+    getLabel: (value) => `$${value} AI Credits`,
+    description: "AI-powered features",
+  },
+};
+```
+
+### Checking Limits in Code
+
+```typescript
+// In server action or API route
+import { getPlanLimits } from "@/lib/auth/stripe/auth-plans";
+
+export async function createProject(orgId: string) {
+  const org = await prisma.organization.findUnique({
+    where: { id: orgId },
+    include: { subscription: true },
+  });
+
+  const limits = getPlanLimits(
+    org?.subscription?.plan ?? "free",
+    org?.subscription?.overrideLimits
+  );
+
+  const projectCount = await prisma.project.count({
+    where: { organizationId: orgId },
+  });
+
+  if (projectCount >= limits.projects) {
+    throw new Error("Project limit reached. Please upgrade your plan.");
+  }
+
+  // Create project...
+}
+```
+
+### Key Principles
+
+1. **Organization is the billing entity** - Plans are tied to Organizations, not Users
+2. **Limits are in Better-Auth config** - Centralized in `auth-plans.ts`
+3. **Override support** - Allow per-organization limit overrides (for enterprise deals)
+4. **No extra layers** - Organization → Resources, that's it
+
+---
+
+## Anti-Patterns
+
+❌ **Microservices for MVP** - Monolith is fine
+❌ **Kubernetes** - Vercel handles scaling
+❌ **Custom auth** - Use Better Auth or Clerk
+❌ **GraphQL** - REST/Server Actions are simpler
+❌ **Redis for everything** - Start without caching
+❌ **Message queues** - Direct calls are fine initially
+❌ **Workspace abstraction** - Organization is enough, don't add layers
+❌ **User-level plans** - Plans belong to Organizations, not Users
+❌ **1-1 relationships** - Don't create separate tables just to "organize data". Put fields directly on the parent model
+
+### 1-1 Relationships Anti-Pattern
+
+**❌ BAD - Separate table for no reason:**
+```prisma
+model User {
+  id       String       @id
+  profile  UserProfile?
+}
+
+model UserProfile {
+  id     String @id
+  bio    String?
+  avatar String?
+  userId String @unique
+  user   User   @relation(fields: [userId], references: [id])
+}
+```
+
+**✅ GOOD - Fields directly on User:**
+```prisma
+model User {
+  id     String  @id
+  bio    String?
+  avatar String?
+}
+```
+
+**When 1-1 is acceptable:**
+- External system integration (e.g., StripeCustomer linked to User)
+- Better-Auth managed tables (Session, Account, etc.)
+- Genuinely optional large data that's rarely loaded

package/src/config/claude-code-config/skills/aibuilder-create-saas/references/challenge-framework.md

@@ -0,0 +1,289 @@
+# Smart Validation Framework
+
+Pragmatic validation for indie hackers who want to ship fast BUT make smart decisions.
+
+**Two modes:** Pick your speed.
+
+---
+
+## Choose Your Path
+
+### 🚀 Speed Mode (Ship in 1-2 weeks)
+
+**Best for:**
+- Scratching your own itch
+- Side projects
+- Learning projects
+- Low-stakes experiments
+
+**Validation approach:**
+1. Quick competitor check (30 min)
+2. Build MVP
+3. Ship to 10 people
+4. Learn from real usage
+
+### 🎯 Thorough Mode (Ship in 2-4 weeks)
+
+**Best for:**
+- Planning to monetize seriously
+- Quitting job for this
+- Significant time investment
+- Competitive market
+
+**Validation approach:**
+1. Competitor deep-dive
+2. Talk to 5-10 potential users
+3. Test with landing page
+4. Build with confidence
+
+---
+
+## Quick Sanity Check (Both Modes)
+
+Before building, answer these 5 questions honestly:
+
+### 1. Would YOU use this?
+
+| Answer | What it means |
+|--------|---------------|
+| "Hell yes, daily" | 🟢 Great — you understand the user |
+| "Sometimes, maybe" | 🟡 Okay — but make sure others need it too |
+| "No, but others would" | 🟠 Risky — hard to build for users you don't understand |
+
+### 2. Can you explain it in one sentence?
+
+**Test:** Tell someone in 10 seconds what it does.
+
+✅ Good: "Notion for meal planning"
+✅ Good: "Auto-post to Twitter when you ship on GitHub"
+❌ Bad: "A platform that leverages AI to optimize workflow synergies"
+
+### 3. Who else has tried this?
+
+| Competitors | What it means | Action |
+|-------------|---------------|--------|
+| 0 | Either genius or no market | Proceed with caution |
+| 1-3 | Sweet spot — validated, room to win | Go for it |
+| 5-10 | Crowded — need an angle | Find your niche |
+| 10+ | Very crowded | Need 10x better at ONE thing |
+
+### 4. How hard is this to build?
+
+| Complexity | Examples | Reality check |
+|------------|----------|---------------|
+| 🟢 Easy | CRUD app, forms, basic auth | 1-2 weeks with Claude Code |
+| 🟡 Medium | Integrations, payments, real-time | 2-4 weeks |
+| 🔴 Hard | AI/ML, complex algorithms, scale | Might be too ambitious for MVP |
+
+### 5. How will you reach users?
+
+| Channel | Effort | Good for |
+|---------|--------|----------|
+| Your own audience | 🟢 Low | If you have one |
+| Communities (Reddit, Discord) | 🟢 Low | Niche products |
+| Twitter/LinkedIn build in public | 🟡 Medium | Dev tools, SaaS |
+| Content/SEO | 🔴 High (slow) | Long-term play |
+| Paid ads | 🔴 High (expensive) | Only if you have budget |
+
+---
+
+## Speed Mode: 30-Minute Validation
+
+### Step 1: Quick Competitor Search (15 min)
+
+Search for:
+- "{problem} tool"
+- "{solution} app"
+- "alternative to {similar product}"
+
+**Find 3-5 competitors. For each, note:**
+- Name + URL
+- Pricing (free? $X/month?)
+- What they do well
+- What reviews complain about ← **Your opportunity**
+
+### Step 2: Gut Check (5 min)
+
+Answer honestly:
+- [ ] I would use this myself
+- [ ] I can build MVP in 2 weeks
+- [ ] I know where to find first 10 users
+- [ ] It's okay if this fails (learning experience)
+
+**If 3+ checked → Build it.**
+
+### Step 3: Define MVP Scope (10 min)
+
+Write down:
+1. **THE ONE thing** it must do (core feature)
+2. **TWO supporting features** max
+3. **Everything else** → v2 (after launch)
+
+---
+
+## Thorough Mode: Deep Validation
+
+### Phase 1: Market Reality Check
+
+**Competitor Analysis (1-2 hours)**
+
+For each competitor, document:
+
+```markdown
+## [Competitor Name]
+- **URL:**
+- **Pricing:** Free / $X/month
+- **What they do well:**
+- **What users complain about:** (check reviews, Twitter, Reddit)
+- **Your angle:** How you'd be different
+```
+
+**Where to find competitors:**
+- Product Hunt
+- AlternativeTo
+- G2 / Capterra
+- "best {category} tools" Google search
+- Reddit: "what do you use for {problem}?"
+
+### Phase 2: Talk to Real People (Optional but valuable)
+
+**You don't need 30 interviews. 5-10 quick chats is enough.**
+
+**The Mom Test approach (simplified):**
+
+Don't ask: "Would you use this?"
+Ask instead: "How do you currently handle {problem}?"
+
+Don't ask: "Would you pay $20/month?"
+Ask instead: "What have you already tried/paid for?"
+
+**3 questions that work:**
+1. "Tell me about the last time you dealt with {problem}"
+2. "What's the most annoying part?"
+3. "What have you tried? What worked/didn't work?"
+
+### Phase 3: Landing Page Test (Optional)
+
+**Quick validation with a fake door:**
+
+1. Create simple landing page (1-2 hours)
+2. Describe what it does + pricing
+3. "Get Early Access" button → email signup
+4. Share in relevant communities
+5. See if anyone signs up
+
+**Good signals:**
+- 3-5% of visitors sign up
+- People ask "when is this launching?"
+- Someone offers to pay early
+
+---
+
+## Idea Development Template
+
+Once you've done your sanity check, develop the idea:
+
+```markdown
+## [Idea Name]
+
+### One-liner
+[What it does in one sentence]
+
+### The Problem
+[Who has this problem? When does it happen?]
+
+### The Solution
+[What's your approach?]
+
+### Target User
+[Be specific: "Freelance designers who..." not "designers"]
+
+### Business Model
+- [ ] Subscription ($X/month)
+- [ ] One-time ($X)
+- [ ] Freemium (free + paid tier)
+- [ ] Usage-based (pay per X)
+
+### Competitors
+1. [Name] - [What they do] - [Your angle vs them]
+2. [Name] - [What they do] - [Your angle vs them]
+
+### Why You?
+[Why are YOU the right person to build this?]
+- Personal experience with the problem?
+- Technical skills?
+- Existing audience?
+
+### MVP Scope
+**Core feature:** [THE ONE thing]
+**Supporting:** [2-3 features max]
+**NOT in MVP:** [Everything else]
+
+### First 10 Users
+[Where will you find them?]
+```
+
+---
+
+## Viability Score (Quick Version)
+
+Rate 1-5 for each:
+
+| Factor | Score | Notes |
+|--------|-------|-------|
+| Personal interest | /5 | Would you use it? |
+| Build feasibility | /5 | Can you ship in 2 weeks? |
+| Market exists | /5 | Do competitors exist? People pay? |
+| Reach | /5 | Can you find users? |
+| Differentiation | /5 | What's your angle? |
+
+**Total: /25**
+
+| Score | Verdict |
+|-------|---------|
+| 20-25 | 🚀 Strong — build it |
+| 15-19 | ✅ Good — worth trying |
+| 10-14 | 🤔 Okay — consider adjustments |
+| <10 | ⚠️ Weak — maybe pivot |
+
+---
+
+## When to Pivot (Be Honest)
+
+**Red flags after shipping:**
+- No one uses it after 2 weeks
+- You stopped using it yourself
+- Can't explain why it's better than alternatives
+- No path to first paying customer
+
+**Pivot options:**
+1. Same problem, different solution
+2. Same solution, different audience
+3. Narrow down to specific niche
+4. Kill it and try something else (it's okay!)
+
+---
+
+## The Indie Hacker Mindset
+
+### Remember:
+
+✅ **Shipping > Planning** — You learn more from launching than researching
+✅ **Small > Big** — Start tiny, expand based on feedback
+✅ **Done > Perfect** — v1 can be ugly, v2 can be better
+✅ **Fail fast > Fail slow** — If it's not working, pivot quickly
+✅ **Fun matters** — Build something you're excited about
+
+### It's okay if:
+
+- Your first idea fails (most do)
+- Only 10 people use it (that's 10 real users!)
+- You pivot 3 times (normal)
+- It never makes money (you learned a ton)
+
+### What matters:
+
+- You shipped something
+- You learned what users want
+- You improved your skills
+- You're ready for the next one