aiblueprint-cli 1.4.59 → 1.4.61

package/agents-config/commands/prompts/nextjs-setup-project.md

@@ -0,0 +1,200 @@
+---
+description: Setup a complete Next.js project with TypeScript, Tailwind, shadcn/ui, TanStack Query, and theme support
+---
+
+<objective>
+Setup a production-ready Next.js project in the current directory with the complete AIBlueprint stack.
+
+This creates a Next.js 15 App Router project with TypeScript, Tailwind CSS, shadcn/ui components, TanStack Query, dark/light theme toggle, dialog manager, server toast, and a landing page with navbar.
+</objective>
+
+<context>
+Current directory: !`pwd`
+Directory contents: !`ls -la`
+Existing package.json: !`cat package.json 2>/dev/null | head -10 || echo "No package.json"`
+</context>
+
+<process>
+## Phase 1: Project Initialization
+
+1. **Create Next.js project**:
+   ```bash
+   npx create-next-app@latest . --typescript --tailwind --eslint --app --no-src-dir --import-alias "@/*" --yes
+   ```
+
+2. **Create src directory structure**:
+   ```bash
+   mkdir -p src/components src/lib src/features/landing
+   ```
+
+3. **Update tsconfig.json** - Configure path aliases:
+   ```json
+   {
+     "compilerOptions": {
+       "baseUrl": ".",
+       "paths": {
+         "@/*": ["./src/*"]
+       }
+     }
+   }
+   ```
+
+4. **Clean default files** - Replace `app/page.tsx` with simple placeholder
+
+## Phase 2: Core Libraries
+
+5. **Install TanStack Query**:
+   ```bash
+   pnpm add @tanstack/react-query
+   ```
+
+6. **Create providers** - `app/providers.tsx`:
+   ```typescript
+   "use client";
+
+   import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+   import { ThemeProvider } from "next-themes";
+   import { useState } from "react";
+
+   export function Providers({ children }: { children: React.ReactNode }) {
+     const [queryClient] = useState(
+       () => new QueryClient({
+         defaultOptions: {
+           queries: { staleTime: 60 * 1000 },
+         },
+       })
+     );
+
+     return (
+       <QueryClientProvider client={queryClient}>
+         <ThemeProvider attribute="class" defaultTheme="system" enableSystem>
+           {children}
+         </ThemeProvider>
+       </QueryClientProvider>
+     );
+   }
+   ```
+
+7. **Wrap layout with providers** - Update `app/layout.tsx`
+
+## Phase 3: UI Components
+
+8. **Initialize shadcn/ui**:
+   ```bash
+   pnpm dlx shadcn@latest init
+   ```
+   Configure paths: Components `@/components`, Utils `@/lib/utils`
+
+9. **Install base components**:
+   ```bash
+   pnpm dlx shadcn@latest add button input card
+   ```
+
+10. **Install next-themes**:
+    ```bash
+    pnpm add next-themes
+    ```
+
+11. **Create theme toggle** - `src/components/theme-toggle.tsx`:
+    - Use `useTheme` from next-themes
+    - Handle mounted state for hydration
+    - Toggle between dark and light
+
+## Phase 4: UI Utilities
+
+12. **Install dialog manager**:
+    ```bash
+    pnpm dlx shadcn@latest add https://ui.nowts.app/r/dialog-manager.json
+    ```
+
+13. **Install server toast**:
+    ```bash
+    pnpm dlx shadcn@latest add https://ui.nowts.app/r/server-toast.json
+    ```
+
+14. **Update layout** - Add to `app/layout.tsx`:
+    ```typescript
+    import { DialogManagerRenderer } from "@/lib/dialog-manager/dialog-manager-renderer";
+    import { ServerToaster } from "@/components/server-toast/server-toast.server";
+    import { Suspense } from "react";
+
+    // Inside body after Providers:
+    <DialogManagerRenderer />
+    <Suspense>
+      <ServerToaster />
+    </Suspense>
+    ```
+
+## Phase 5: Landing Page
+
+15. **Install navbar**:
+    ```bash
+    pnpm dlx shadcn@latest add https://coss.com/origin/r/comp-577.json
+    ```
+    Rename to `navbar.tsx` with semantic component name
+
+16. **Install landing sections**:
+    ```bash
+    pnpm dlx shadcn@latest add https://shadcn-ui-blocks.akashmoradiya.com/r/hero-03.json
+    pnpm dlx shadcn@latest add https://shadcn-ui-blocks.akashmoradiya.com/r/footer-05.json
+    pnpm dlx shadcn@latest add https://shadcn-ui-blocks.akashmoradiya.com/r/faq-02.json
+    ```
+
+17. **Organize landing components**:
+    - Move to `src/features/landing/`
+    - Rename: `hero.tsx`, `footer.tsx`, `faq.tsx`
+    - Update component names inside files
+
+18. **Assemble landing page** - Update `app/page.tsx`:
+    - Import all landing components
+    - Navbar with logo, signin link, theme toggle
+    - Hero, FAQ, Footer sections
+
+## Phase 6: Quality & Documentation
+
+19. **Add quality scripts** to `package.json`:
+    ```json
+    {
+      "lint": "eslint .",
+      "ts": "tsc --noEmit"
+    }
+    ```
+
+20. **Run quality checks**:
+    ```bash
+    pnpm lint
+    pnpm ts
+    ```
+    Fix any errors before completing
+
+21. **Create CLAUDE.md** with:
+    - Stack overview (Next.js 15, TanStack Query, shadcn/ui)
+    - Directory structure explanation
+    - UI Utilities section (dialog manager, server toast usage)
+    - Project structure section
+
+22. **Create AGENTS.md** as symlink:
+    ```bash
+    ln -s CLAUDE.md AGENTS.md
+    ```
+</process>
+
+<output>
+**Files created**:
+- `app/` - Next.js App Router pages and layouts
+- `src/components/` - UI components including shadcn/ui
+- `src/lib/` - Utilities and helpers
+- `src/features/landing/` - Landing page components
+- `CLAUDE.md` - Project documentation
+- `AGENTS.md` - Symlink to CLAUDE.md
+</output>
+
+<success_criteria>
+- `pnpm dev` starts without errors
+- `pnpm lint` passes
+- `pnpm ts` passes (no TypeScript errors)
+- Landing page renders with navbar, hero, FAQ, footer
+- Theme toggle switches between dark/light mode
+- Dialog manager and server toast are integrated
+- CLAUDE.md contains complete stack documentation
+</success_criteria>

package/agents-config/commands/prompts/prompt.md

@@ -0,0 +1,55 @@
+You are an expert logo designer. I want you to create minimalist SVG logo variations for my app.
+
+Use extended thinking to deeply analyze my app and create the best logos possible.
+
+App Name: [YOUR APP NAME]
+Description: [WHAT YOUR APP DOES]
+
+Before starting, ask me these 4 questions:
+
+1. What logo style do you prefer? (Lettermark like Stripe's S, Abstract symbol like Claude, Geometric shape like Airbnb, or Wordmark)
+
+2. What brand personality? (Modern & Tech, Playful & Friendly, Professional, Bold & Edgy, or Minimal & Clean)
+
+3. Which companies inspire you visually? (Stripe, Google, Linear, Notion, Discord)
+
+4. How many logos do you want? (between 1 and 100)
+
+Wait for my answers before generating anything.
+
+After my answers, create an HTML artifact with all the logos.
+
+Artifact constraints (follow exactly):
+
+Layout:
+- Responsive grid that takes the full page width
+- No fixed width, adapts to viewport
+- Each cell is square (aspect-ratio: 1)
+- Cells automatically fill available space
+- Light gray border between cells
+- White background
+- Logo centered in each cell
+
+Cell content:
+- Number in the corner (1, 2, 3...) so I can easily say "I like 4 and 5"
+- Logo in the center
+- Short description below (1-2 sentences max)
+- Description explains the concept and why it fits the app
+
+Page:
+- No title
+- No header
+- No footer
+- Just the grid taking the full page
+
+Logos:
+- Black color only
+- No gradients
+- No shadows
+- Opacity allowed (play with transparency for depth)
+- Simple geometric shapes
+- Maximum 3-4 elements per logo
+- Must be recognizable at 16px
+- Clean paths, no complexity
+
+After showing the grid, ask me which ones I prefer to create more variations based on my favorites.

package/agents-config/commands/prompts/saas-challenge-idea.md

@@ -0,0 +1,135 @@
+---
+description: Challenge and validate a business idea through competitive research and brutally honest market analysis
+---
+
+<objective>
+Challenge and validate a business idea through competitive research and market analysis.
+
+Provide brutally honest, evidence-based feedback on whether the idea has genuine market potential or should be abandoned/pivoted. Save founders from wasting time on bad ideas.
+</objective>
+
+<process>
+## Phase 1: Gather the Idea
+
+1. **If idea not provided**, ask the user:
+   > "Tell me about your idea:
+   > - What problem does it solve?
+   > - Who is it for?
+   > - What's your proposed solution?
+   > - What makes it different?"
+
+2. **Do NOT proceed** until you understand:
+   - The specific problem being solved
+   - The target user/customer
+   - The proposed solution
+   - Any claimed differentiation
+
+## Phase 2: Research Competitors
+
+3. **Use web search** to find existing solutions:
+   - Search: "[problem] tool", "[solution] software", "[target user] platform"
+   - Check: Product Hunt, Y Combinator portfolio, Crunchbase
+   - Search: Reddit discussions, Alternative.to
+
+4. **For each competitor**, document:
+   - Name and URL
+   - What they do (brief description)
+   - Pricing model (free/paid/freemium)
+   - Revenue signals: funding, team size, visible traction
+   - Market positioning
+
+5. **Find 5-10 competitors minimum** - both direct and indirect:
+   - **Direct**: Same problem, same solution approach
+   - **Indirect**: Same problem, different solution approach
+
+## Phase 3: Analyze the Market
+
+6. **Assess market saturation**:
+   - 10+ competitors = Crowded (high risk, need strong differentiation)
+   - 3-9 competitors = Moderate (validated demand, need positioning)
+   - 1-2 competitors = Sparse (early market or weak demand)
+   - 0 competitors = Usually no market (rarely means opportunity)
+
+7. **Evaluate revenue signals**:
+   - **Strong**: Paid tiers, funding raised, growing teams
+   - **Weak**: Free only, abandoned projects, no monetization
+
+8. **Check opportunity**:
+   - Is there proof people PAY for this?
+   - Is there room for another player?
+   - What would truly differentiate this idea?
+
+## Phase 4: Deliver Honest Feedback
+
+9. **Generate validation report** in this format:
+
+```markdown
+# Validation: [Idea Name]
+
+## Quick Summary
+[1 sentence - what their idea is]
+
+## What I Found
+
+**Competitors**:
+1. [Name] - [What they do, pricing, traction signals]
+2. [Name] - [What they do, pricing, traction signals]
+3. [Continue for 3-5 key competitors]
+
+**Market**: [Crowded/Moderate/Sparse] - [1 sentence why]
+**Revenue proof**: [Yes/No] - [Evidence people pay for this]
+
+## Viability Score: [X/10]
+
+[2-3 sentences explaining the score - be direct, no fluff]
+
+## The Hard Truth
+
+**What's actually unique**: [What truly differentiates this, if anything]
+**What's NOT unique**: [What they claim is unique but competitors already do]
+
+**Biggest problems**:
+- [Problem 1]
+- [Problem 2]
+- [Problem 3]
+
+## My Take
+
+**Would I build this?** [Yes/No/Maybe]
+
+**Why**: [Honest opinion in 1-2 sentences - don't hold back]
+
+**If you proceed**: [Specific advice on how to differentiate]
+**If you pivot**: [Specific pivot suggestion based on research]
+
+**Bottom line**: [Final direct recommendation - pursue, pivot, or kill]
+```
+</process>
+
+<constraints>
+**BE BRUTALLY HONEST**:
+- Don't sugarcoat bad ideas
+- Be rude if necessary - founders need truth
+- Call out red flags directly
+- Use evidence from research, not opinions
+
+**ALWAYS RESEARCH FIRST**:
+- Never give feedback without finding real competitors
+- Challenge claims of "no competitors exist"
+- Focus on whether people actually PAY for solutions
+
+**RED FLAGS TO CALL OUT**:
+- "Uber for X" without unique insight
+- Solution looking for a problem
+- Targeting "everyone" (no clear user)
+- Ignoring dominant market leaders
+- Claims no competitors exist (almost always false)
+</constraints>
+
+<success_criteria>
+- Found and documented 5+ real competitors with web research
+- Provided specific pricing and revenue signals for competitors
+- Gave honest viability score with clear reasoning
+- Called out what's NOT unique about the idea
+- Provided actionable recommendation: pursue, pivot, or kill
+</success_criteria>

package/agents-config/commands/prompts/saas-create-architecture.md

@@ -0,0 +1,242 @@
+---
+description: Design technical architecture for a Next.js SaaS application based on PRD requirements
+---
+
+<objective>
+Design the complete technical architecture for a Next.js application based on the Product Requirements Document.
+
+Define tool selection, technology stack decisions, infrastructure choices, and architecture patterns. Challenge every decision to ensure the best fit for specific needs. This comes AFTER the PRD - the PRD defines WHAT to build, this defines HOW to build it.
+</objective>
+
+<context>
+Tools reference: @https://github.com/Melvynx/aiblueprint/blob/main/ai-coding/tools.md
+</context>
+
+<process>
+## Phase 1: Read PRD
+
+1. **Ask for PRD location**:
+   > "Where is your PRD? Please provide the file path or paste the content."
+
+2. **Extract from PRD**:
+   - **Core Features**: What features drive architecture decisions
+   - **User Personas**: Who uses this (impacts willingness to pay for tools)
+   - **Success Metrics**: Performance/scale targets
+   - **Timeline**: MVP timeline (impacts complexity decisions)
+   - **Out of Scope**: What WON'T be built in v1
+
+3. **Map technical implications**:
+   - Real-time features → Need WebSocket/real-time database
+   - File uploads → Need storage solution
+   - AI features → Need LLM integration
+   - Multi-user/teams → Need robust auth and permissions
+   - High traffic → Need caching and performance optimization
+
+## Phase 2: Read Tools Reference
+
+4. **Fetch tools.md** - Read the complete tool reference at:
+   https://github.com/Melvynx/aiblueprint/blob/main/ai-coding/tools.md
+
+5. **Use as primary source** for tool recommendations
+
+## Phase 3: Information Gathering
+
+6. **Ask questions progressively** (don't ask all at once):
+
+**Frontend Requirements**:
+- UI component strategy? (shadcn/ui, custom, other)
+- Client-side state management beyond React?
+- URL state requirements? (filters, search, pagination)
+- Data fetching pattern? (Server Components, TanStack Query, mix)
+
+**Backend & API**:
+- API pattern preference? (Server Actions, API Routes, both)
+- External API access needed?
+- Validation/security layer? (Zod, rate limiting)
+- Third-party API integrations?
+
+**Authentication & Authorization**:
+- Authentication method? (email/password, OAuth, magic link, OTP)
+- Organizations/team features?
+- Permission model? (simple roles, complex RBAC, none)
+
+**Database & Data**:
+- Data type? (relational, document, real-time, files)
+- SQL vs NoSQL preference?
+- Real-time features? (live updates, collaborative editing)
+- Expected data volume and query patterns?
+- ORM preference? (Prisma, Drizzle)
+
+**AI & LLM** (if applicable):
+- AI features needed? (chat, completion, embeddings, vision)
+- LLM providers? (OpenAI, Anthropic, multiple)
+- Streaming responses needed?
+
+**Infrastructure**:
+- Deployment platform? (default: Vercel)
+- Expected traffic/scale?
+- Background jobs or cron tasks?
+- Budget constraints?
+
+**Additional**:
+- Email sending? (transactional, marketing)
+- File uploads/storage?
+- Payment processing?
+- Analytics/monitoring?
+
+## Phase 4: Challenge Every Decision
+
+7. **For EVERY tool choice**, challenge with:
+
+**"Why This?" Challenge**:
+- Why this tool specifically?
+- What are the alternatives?
+- What's the trade-off?
+
+**"Do You Really Need It?" Challenge**:
+- Can you ship without this?
+- Is this solving a real problem or hypothetical future problem?
+- What's the simplest solution that could work?
+
+**"What's The Cost?" Challenge**:
+- Learning curve for the team?
+- Monetary cost at scale?
+- Maintenance burden?
+
+## Phase 5: Generate Architecture Document
+
+8. **Only after gathering ALL information**, create ARCHI.md:
+
+```markdown
+# Technical Architecture: [Project Name]
+
+## Architecture Overview
+
+**Philosophy**: [2-3 sentences on approach and principles]
+
+**Tech Stack Summary**:
+- Framework: [e.g., Next.js 15 with App Router]
+- Deployment: [e.g., Vercel serverless]
+- Database: [e.g., Neon PostgreSQL with Prisma]
+- Authentication: [e.g., Better Auth with email/password]
+
+## Frontend Architecture
+
+### Core Stack
+- **Framework**: [Tool + version]
+  - **Why**: [Specific reason]
+  - **Trade-off**: [What you gain vs sacrifice]
+
+- **UI Components**: [Tool]
+  - **Why**: [Reason]
+  - **Trade-off**: [Analysis]
+
+### State Management
+- **Global State**: [Tool or "React hooks only"]
+- **Server State**: [Tool + pattern]
+- **URL State**: [Tool or "Not needed"]
+
+### Data Fetching Strategy
+[Describe pattern - Server Components first, Client when needed, etc.]
+
+## Backend Architecture
+
+### API Layer
+- **Pattern**: [Server Actions / API Routes / Both]
+- **Validation**: [Tool]
+- **Security**: [Rate limiting, CORS config]
+
+### Authentication & Authorization
+- **Provider**: [Tool] - **Why**: [Reason]
+- **Method**: [Email/password, OAuth, etc.]
+- **Authorization**: [Permission model description]
+
+### Database & Data Layer
+- **Database**: [Tool + type] - **Why**: [Reason]
+- **ORM**: [Tool] - **Why**: [Justification]
+- **Real-time**: [Tool/approach if needed]
+
+### AI Integration (if applicable)
+- **SDK**: [Tool]
+- **Providers**: [Primary + fallback]
+- **Use Cases**: [Feature → model mapping]
+
+## Infrastructure & Deployment
+
+- **Platform**: [Platform] - **Why**: [Reason]
+- **Region Strategy**: [Single/multi/edge]
+- **Background Jobs**: [Tool or "Not needed"]
+- **Monitoring**: [Tools for app monitoring, errors, analytics]
+
+## Additional Services
+
+- **Email**: [Provider or "Not needed"]
+- **Storage**: [Provider or "Not needed"]
+- **Payments**: [Provider or "Not needed"]
+
+## Architecture Decision Records
+
+### ADR-001: [Key Decision Title]
+- **Context**: [Why decision was needed]
+- **Decision**: [What was decided]
+- **Alternatives**: [What else was evaluated]
+- **Rationale**: [Why this choice]
+- **Consequences**: [Trade-offs]
+
+## Folder Structure
+[Project structure diagram]
+
+## Cost Estimation
+
+### Monthly at Scale
+- Database: $[amount]
+- Hosting: $[amount]
+- [Other services]
+- **Total**: ~$[total]/month at [expected scale]
+
+### Free Tier Limits
+- [Service]: [Limits]
+
+## Implementation Priority
+
+### Phase 1: Foundation
+1. [Setup task]
+2. [Setup task]
+
+### Phase 2: Core Features
+1. [Feature]
+2. [Feature]
+
+### Phase 3: Enhancement
+1. [Enhancement]
+```
+</process>
+
+<constraints>
+**MANDATORY BEFORE WRITING**:
+- PRD read completely
+- Tools reference read
+- ALL 8 information areas answered
+- Every tool choice challenged
+
+**CHECKLIST**:
+- ✅ PRD understanding complete
+- ✅ Frontend stack decided (aligned with PRD UI needs)
+- ✅ Backend stack decided (supporting PRD features)
+- ✅ Auth strategy decided (matching PRD user personas)
+- ✅ Database choice made (based on PRD data requirements)
+- ✅ AI requirements specified (from PRD AI features)
+- ✅ Infrastructure decided (based on PRD timeline/metrics)
+- ✅ Additional services identified (driven by PRD features)
+
+**IF ANY MISSING**: Ask more questions first
+</constraints>
+
+<success_criteria>
+- Every technology choice has clear "Why" and "Trade-off"
+- Architecture aligns with ALL PRD features
+- Cost estimation included
+- Implementation phases defined
+- Architecture Decision Records for key choices
+- ARCHI.md saved in same directory as PRD
+</success_criteria>