@riligar/agents-kit 1.10.0 → 1.12.0

package/.agent/skills/riligar-business-startup/references/financial-model.md

@@ -0,0 +1,215 @@
+# Financial Projections
+
+Create comprehensive 3-5 year financial model with revenue projections, cost structure, headcount planning, cash flow analysis, and three-scenario modeling.
+
+## What This Module Creates
+
+1. Cohort-based revenue projections
+2. Detailed cost structure (COGS, S&M, R&D, G&A)
+3. Headcount planning by role
+4. Monthly cash flow analysis
+5. Key metrics (CAC, LTV, burn rate, runway)
+6. Three-scenario analysis
+
+## Step 1: Gather Inputs
+
+**Business Model:**
+- Revenue model (SaaS, marketplace, transaction)
+- Pricing structure (tiers, average price)
+- Target customer segments
+
+**Starting Point:**
+- Current MRR/ARR (if any)
+- Current customer count
+- Current team size
+- Current cash balance
+
+**Growth Assumptions:**
+- Expected monthly customer acquisition
+- Customer retention/churn rate
+- Average contract value (ACV)
+- Sales cycle length
+
+**Cost Assumptions:**
+- Gross margin or COGS %
+- S&M budget or CAC target
+- Current burn rate
+
+**Funding:**
+- Planned fundraising (amount, timing)
+- Pre/post-money valuation
+
+## Step 2: Build Revenue Model
+
+### Cohort-Based Approach
+
+For each month, track:
+1. New customers acquired
+2. Existing customers retained (apply churn)
+3. Revenue per cohort (customers × ARPU)
+4. Expansion revenue (upsells)
+
+**Formula:**
+```
+MRR (Month N) = Σ across all cohorts:
+  (Cohort Size × Retention Rate × ARPU) + Expansion
+```
+
+**Project:**
+- Monthly detail for Year 1-2
+- Quarterly detail for Year 3
+- Annual for Years 4-5
+
+## Step 3: Cost Structure
+
+### 1. Cost of Goods Sold (COGS)
+- Hosting/infrastructure
+- Payment processing
+- Variable customer support
+- Third-party services
+
+Target gross margin:
+- SaaS: 75-85%
+- Marketplace: 60-70%
+- E-commerce: 40-60%
+
+### 2. Sales & Marketing (S&M)
+- Sales team compensation
+- Marketing programs
+- Tools and software
+- Target: 40-60% of revenue (early stage)
+
+### 3. Research & Development (R&D)
+- Engineering team
+- Product management
+- Design
+- Target: 30-40% of revenue
+
+### 4. General & Administrative (G&A)
+- Executive team
+- Finance, legal, HR
+- Office and facilities
+- Target: 15-25% of revenue
+
+## Step 4: Headcount Planning
+
+**For each role:**
+- Title and department
+- Start date (month/quarter)
+- Base salary
+- Fully-loaded cost (salary × 1.3-1.4)
+
+**Departmental ratios:**
+- Engineering: 40-50% of team
+- Sales & Marketing: 25-35%
+- G&A: 10-15%
+- Product/CS: 10-15%
+
+## Step 5: Cash Flow
+
+Monthly cash flow projection:
+
+```
+Beginning Cash Balance
++ Cash Collected (revenue, consider payment terms)
+- Operating Expenses
+- CapEx
+= Ending Cash Balance
+
+Monthly Burn = Revenue - Expenses (if negative)
+Runway = Cash Balance / Monthly Burn Rate
+```
+
+**Include Funding Events:**
+- Timing of raises
+- Amount raised
+- Impact on cash balance
+
+## Step 6: Key Metrics
+
+### Unit Economics
+- CAC (S&M spend / new customers)
+- LTV (ARPU × margin% / churn rate)
+- LTV:CAC ratio (target > 3.0)
+- CAC payback period (target < 18 months)
+
+### Efficiency Metrics
+- Burn multiple (net burn / net new ARR) - target < 2.0
+- Magic number (net new ARR / S&M spend) - target > 0.5
+- Rule of 40 (growth% + margin%) - target > 40%
+
+### Cash Metrics
+- Monthly burn rate
+- Runway in months
+
+## Step 7: Three Scenarios
+
+### Conservative (P10)
+- New customers: -30% vs. base
+- Churn: +20% vs. base
+- Pricing: -15% vs. base
+- CAC: +25% vs. base
+
+### Base (P50)
+- Most likely assumptions
+- Primary planning scenario
+
+### Optimistic (P90)
+- New customers: +30% vs. base
+- Churn: -20% vs. base
+- Pricing: +15% vs. base
+- CAC: -25% vs. base
+
+## Report Tables
+
+### Revenue Projections
+```
+| Month | New Customers | Total Customers | MRR | ARR | Growth % |
+|-------|---------------|-----------------|-----|-----|----------|
+```
+
+### Cost Breakdown
+```
+| Department | Year 1 | Year 2 | Year 3 | % Revenue |
+|------------|--------|--------|--------|-----------|
+| COGS       | $X     | $Y     | $Z     | XX%       |
+| S&M        | $X     | $Y     | $Z     | XX%       |
+| R&D        | $X     | $Y     | $Z     | XX%       |
+| G&A        | $X     | $Y     | $Z     | XX%       |
+```
+
+### Key Metrics
+```
+| Metric | Year 1 | Year 2 | Year 3 | Target |
+|--------|--------|--------|--------|--------|
+| CAC | $X | $Y | $Z | <$A |
+| LTV | $X | $Y | $Z | >$B |
+| LTV:CAC | X | Y | Z | >3.0 |
+| Burn Multiple | X | Y | Z | <2.0 |
+```
+
+### Scenario Comparison
+```
+| Scenario | Year 3 ARR | Customers | Burn | Runway |
+|----------|------------|-----------|------|--------|
+| Conservative | $X | Y | $Z | W mo |
+| Base | $X | Y | $Z | W mo |
+| Optimistic | $X | Y | $Z | W mo |
+```
+
+## Best Practices
+
+**Do:**
+- Use cohort-based revenue model
+- Include 3 scenarios
+- Show monthly detail (Year 1-2)
+- Calculate key metrics
+- Validate against benchmarks
+- Document all assumptions
+
+**Don't:**
+- Be overly optimistic on growth
+- Underestimate costs
+- Forget fully-loaded compensation
+- Ignore cash timing
+- Skip scenario analysis

package/.agent/skills/riligar-business-startup/references/market-analysis.md

@@ -0,0 +1,151 @@
+# Market Opportunity Analysis
+
+Generate comprehensive market opportunity analysis with TAM/SAM/SOM calculations using both bottom-up and top-down methodologies.
+
+## Process Overview
+
+1. Define the target market and customer segments
+2. Gather relevant market data
+3. Calculate TAM using bottom-up methodology
+4. Validate with top-down analysis
+5. Narrow to SAM with appropriate filters
+6. Estimate realistic SOM (3-5 year opportunity)
+7. Present findings in a formatted report
+
+## Step 1: Gather Context
+
+Ask for essential information:
+
+**Product/Service:**
+- What problem is being solved?
+- How does pricing work? (subscription, transaction, etc.)
+
+**Target Customers:**
+- Who is the ideal customer? (industry, size, geography)
+- Initial target market (US, North America, Global)
+
+**Stage:**
+- What stage is the company? (pre-launch, seed, Series A)
+
+## Step 2: Bottom-Up Analysis
+
+### For B2B/SaaS
+
+1. Define customer segments (company size, industry, use case)
+2. Estimate number of companies in each segment
+3. Determine average contract value (ACV) per segment
+4. Calculate TAM: Σ (Segment Size × ACV)
+
+### For Consumer/Marketplace
+
+1. Define target user demographics
+2. Estimate total addressable users
+3. Determine average revenue per user (ARPU)
+4. Calculate TAM: Total Users × ARPU × Frequency
+
+### For Transactions/E-commerce
+
+1. Estimate total transaction volume (GMV)
+2. Determine take rate or margin
+3. Calculate TAM: Total GMV × Take Rate
+
+## Step 3: Data Sources
+
+Recommended sources:
+- Government data (Census, BLS)
+- Industry reports (Gartner, Forrester, Statista)
+- Public company filings (10-K reports)
+- Trade associations
+- Academic research
+
+**Always cite sources with URLs and publication dates.**
+
+## Step 4: Top-Down Validation
+
+1. Find total market category size from research
+2. Apply geographic filters
+3. Apply segment/product filters
+4. Compare to bottom-up TAM (should be within 30%)
+
+If variance > 30%, investigate and explain differences.
+
+## Step 5: Calculate SAM
+
+Apply realistic filters to narrow TAM:
+
+- **Geographic:** Regions actually serviceable
+- **Product Capability:** Features needed to serve
+- **Market Readiness:** Customers ready to adopt
+- **Addressable Switching:** Can reach and convert
+
+Formula:
+```
+SAM = TAM × Geographic % × Product Fit % × Market Readiness %
+```
+
+## Step 6: Estimate SOM
+
+Calculate realistic obtainable market share:
+
+**Conservative Approach (Recommended):**
+- Year 3: 2-3% of SAM
+- Year 5: 4-6% of SAM
+
+**Consider:**
+- Competitive intensity
+- Available resources (funding, team)
+- Go-to-market effectiveness
+- Differentiation strength
+
+## Report Structure
+
+### Section 1: Executive Summary
+- Market opportunity in one paragraph
+- TAM/SAM/SOM headline numbers
+
+### Section 2: Market Definition
+- Problem being solved
+- Target customer profile
+- Geographic scope
+
+### Section 3: Bottom-Up Analysis
+- Customer segment breakdown
+- Segment sizing with sources
+- TAM calculation with formula
+
+### Section 4: Top-Down Validation
+- Industry category and size
+- Validated TAM
+- Comparison to bottom-up
+
+### Section 5: SAM Calculation
+- Filters applied with rationale
+- SAM formula and result
+
+### Section 6: SOM Projection
+- Market share assumptions
+- Year 3 and Year 5 estimates
+- Revenue projections
+
+### Section 7: Market Growth
+- Industry growth rate (CAGR)
+- Key growth drivers
+
+### Section 8: Validation
+- Public company comparisons
+- Competitive context
+
+## Best Practices
+
+**Do:**
+- Start with bottom-up (most credible)
+- Always triangulate with top-down
+- Cite all data sources
+- Be conservative on SOM
+- Compare to public company benchmarks
+
+**Don't:**
+- Rely solely on top-down
+- Cherry-pick optimistic data
+- Claim >10% SOM without strong justification
+- Skip validation steps

package/.agent/skills/riligar-dev-backend/SKILL.md

@@ -1,15 +1,12 @@
 ---
 name: riligar-dev-backend
 type: development
-description: API design principles and decision-making. REST vs GraphQL vs tRPC selection, response formats, versioning, pagination. Use when designing APIs or backend services.
+description: Elysia backend development patterns for Bun. Use when building APIs, routes, plugins, validation, middleware, and error handling with Elysia framework.
 ---
 
-# API Patterns
+# Elysia Backend Development
 
-> API design principles and decision-making for 2025.
-> **Learn to THINK, not copy fixed patterns.**
-
----
+> Build fast, type-safe APIs with Elysia + Bun.
 
 ## Mandatory Guidelines
 
@@ -17,84 +14,122 @@ description: API design principles and decision-making. REST vs GraphQL vs tRPC
 > All work in this skill MUST adhere to:
 >
 > - @[.agent/skills/riligar-dev-clean-code] (Clean Code Standards)
-
----
-
-## 🎯 Selective Reading Rule
-
-**Read ONLY files relevant to the request!** Check the content map, find what you need.
-
----
-
-## 📑 Content Map
-
-| File                  | Description                                 | When to Read           |
-| --------------------- | ------------------------------------------- | ---------------------- |
-| `api-style.md`        | REST vs GraphQL vs tRPC decision tree       | Choosing API type      |
-| `rest.md`             | Resource naming, HTTP methods, status codes | Designing REST API     |
-| `response.md`         | Envelope pattern, error format, pagination  | Response structure     |
-| `graphql.md`          | Schema design, when to use, security        | Considering GraphQL    |
-| `trpc.md`             | TypeScript monorepo, type safety            | TS fullstack projects  |
-| `versioning.md`       | URI/Header/Query versioning                 | API evolution planning |
-| `auth.md`             | JWT, OAuth, Passkey, API Keys               | Auth pattern selection |
-| `rate-limiting.md`    | Token bucket, sliding window                | API protection         |
-| `documentation.md`    | OpenAPI/Swagger best practices              | Documentation          |
-| `security-testing.md` | OWASP API Top 10, auth/authz testing        | Security audits        |
-
----
-
-## 🔗 Related Skills
-
-| Need                | Skill                                             |
-| ------------------- | ------------------------------------------------- |
-| **Core Standards**  | @[.agent/skills/riligar-dev-clean-code]           |
-| **Architecture**    | @[.agent/skills/riligar-dev-architecture]         |
-| **Database**        | @[.agent/skills/riligar-dev-database]             |
-| **Infrastructure**  | @[.agent/skills/riligar-infrastructure]           |
-| **Tech Stack**      | @[.agent/skills/riligar-tech-stack]               |
-| **Business Case**   | @[.agent/skills/riligar-business-startup-analyst] |
-| **Market Analysis** | @[.agent/skills/riligar-business-startup-market]  |
-| **Code Review**     | @[.agent/skills/riligar-dev-code-review]          |
-| **Task Planning**   | @[.agent/skills/riligar-plan-writing]             |
-| **SEO Tech**        | @[.agent/skills/riligar-dev-seo]                  |
-
----
-
-## ✅ Decision Checklist
-
-Before designing an API:
-
-- [ ] **Asked user about API consumers?**
-- [ ] **Chosen API style for THIS context?** (REST/GraphQL/tRPC)
-- [ ] **Defined consistent response format?**
-- [ ] **Planned versioning strategy?**
-- [ ] **Considered authentication needs?**
-- [ ] **Planned rate limiting?**
-- [ ] **Documentation approach defined?**
-
----
-
-## ❌ Anti-Patterns
-
-**DON'T:**
-
-- Default to REST for everything
-- Use verbs in REST endpoints (/getUsers)
-- Return inconsistent response formats
-- Expose internal errors to clients
-- Skip rate limiting
-
-**DO:**
-
-- Choose API style based on context
-- Ask about client requirements
-- Document thoroughly
-- Use appropriate status codes
-
----
-
-## Script
-
-| Script                     | Purpose                 | Command                                          |
-| -------------------------- | ----------------------- | ------------------------------------------------ |
-| `scripts/api_validator.py` | API endpoint validation | `python scripts/api_validator.py <project_path>` |
+> - @[.agent/skills/riligar-tech-stack] (Tech Stack - Bun, Elysia, SQLite, Drizzle)
+
+## Quick Reference
+
+```javascript
+import { Elysia, t } from 'elysia'
+
+const app = new Elysia()
+    .get('/', () => 'Hello Elysia')
+    .post('/users', ({ body }) => createUser(body), {
+        body: t.Object({
+            name: t.String(),
+            email: t.String({ format: 'email' })
+        })
+    })
+    .listen(3000)
+```
+
+## Content Map
+
+| File | Description | When to Read |
+| --- | --- | --- |
+| [elysia-basics.md](references/elysia-basics.md) | Setup, routes, handlers, context | Starting new project |
+| [elysia-plugins.md](references/elysia-plugins.md) | Plugins, guards, modular design | Organizing code |
+| [elysia-validation.md](references/elysia-validation.md) | TypeBox validation (body, query, params) | Input validation |
+| [elysia-lifecycle.md](references/elysia-lifecycle.md) | Hooks (onBeforeHandle, onError, etc.) | Middleware, auth checks |
+| [elysia-patterns.md](references/elysia-patterns.md) | REST patterns, responses, pagination | API design |
+
+## Project Structure
+
+```
+src/
+├── index.js           # Entry point
+├── routes/
+│   ├── index.js       # Route aggregator
+│   ├── users.js       # User routes plugin
+│   └── posts.js       # Post routes plugin
+├── services/
+│   ├── user.js        # Business logic
+│   └── post.js
+├── database/
+│   ├── db.js          # Drizzle connection
+│   ├── schema.js      # Drizzle schema
+│   └── migrations/
+└── middleware/
+    ├── auth.js        # Auth middleware
+    └── logger.js      # Request logging
+```
+
+## Core Patterns
+
+### Route Plugin
+
+```javascript
+// routes/users.js
+import { Elysia, t } from 'elysia'
+import { getUserById, createUser } from '../services/user'
+
+export const userRoutes = new Elysia({ prefix: '/users' })
+    .get('/', () => getAllUsers())
+    .get('/:id', ({ params }) => getUserById(params.id))
+    .post('/', ({ body }) => createUser(body), {
+        body: t.Object({
+            name: t.String({ minLength: 1 }),
+            email: t.String({ format: 'email' })
+        })
+    })
+```
+
+### Main App
+
+```javascript
+// index.js
+import { Elysia } from 'elysia'
+import { userRoutes } from './routes/users'
+import { postRoutes } from './routes/posts'
+
+const app = new Elysia()
+    .onError(({ error, set }) => {
+        console.error(error)
+        set.status = 500
+        return { error: 'Internal Server Error' }
+    })
+    .use(userRoutes)
+    .use(postRoutes)
+    .listen(3000)
+
+console.log(`Server running at ${app.server?.url}`)
+```
+
+## Related Skills
+
+| Need | Skill |
+| --- | --- |
+| **Authentication** | @[.agent/skills/riligar-dev-auth-elysia] |
+| **Database** | @[.agent/skills/riligar-dev-database] |
+| **Tech Stack** | @[.agent/skills/riligar-tech-stack] |
+| **Clean Code** | @[.agent/skills/riligar-dev-clean-code] |
+| **Infrastructure** | @[.agent/skills/riligar-infrastructure] |
+
+## Decision Checklist
+
+Before building an API:
+
+- [ ] Defined route structure and prefixes?
+- [ ] Planned validation for all inputs?
+- [ ] Error handling configured?
+- [ ] Auth middleware needed? → Use `riligar-dev-auth-elysia`
+- [ ] Database connection setup? → Use `riligar-dev-database`
+
+## Anti-Patterns
+
+| Don't | Do |
+| --- | --- |
+| Put business logic in handlers | Extract to `services/` |
+| Skip input validation | Use TypeBox (`t.Object`) |
+| Ignore error handling | Use `onError` lifecycle |
+| Create monolithic files | Split into plugins |
+| Use verbs in routes (`/getUser`) | Use nouns (`/users/:id`) |