vibebusiness 1.2.11

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "vibebusiness",
+  "version": "1.2.11",
+  "description": "AI-powered autonomous business analyst. Research. Build. Ship. Grow.",
+  "license": "SEE LICENSE IN LICENSE",
+  "private": false,
+  "bin": {
+    "vibebusiness": "./dist/bin/vibebusiness.js"
+  },
+  "files": [
+    "dist/",
+    "templates/",
+    ".next/standalone/",
+    ".next/static/",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "prepublishOnly": "npm run build && next build",
+    "dev": "next dev -p 3001",
+    "dev:dashboard": "next dev -p 3001",
+    "start": "next start -p 3001",
+    "lint": "next lint",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:e2e": "playwright test",
+    "test:e2e:ui": "playwright test --ui",
+    "test:e2e:headed": "playwright test --headed",
+    "analyze": "npx tsx scripts/analyze.ts",
+    "generate-idea": "npx tsx scripts/generate-idea.ts",
+    "implement": "npx tsx scripts/implement.ts",
+    "init": "npx tsx scripts/init.ts",
+    "heartbeat": "npx tsx scripts/heartbeat.ts",
+    "status": "npx tsx bin/ai-analyst.ts status"
+  },
+  "keywords": [
+    "ai",
+    "business-analyst",
+    "codebase-monitoring",
+    "autonomous",
+    "kpi-tracking",
+    "claude-code",
+    "devtools",
+    "100x",
+    "manager"
+  ],
+  "devDependencies": {
+    "@playwright/test": "^1.58.1",
+    "@types/node": "^20.14.0",
+    "@types/react": "^18.3.3",
+    "@types/react-dom": "^18.3.0",
+    "@types/uuid": "^9.0.8",
+    "autoprefixer": "^10.4.19",
+    "clsx": "^2.1.1",
+    "lucide-react": "^0.400.0",
+    "next": "^14.2.0",
+    "postcss": "^8.4.38",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "tailwindcss": "^3.4.4",
+    "tsup": "^8.5.1",
+    "tsx": "^4.15.0",
+    "typescript": "^5.4.5",
+    "uuid": "^9.0.1",
+    "vitest": "^4.0.18"
+  }
+}

package/templates/commands/build-page.md

@@ -0,0 +1,129 @@
+# /build-page — Landing Page Builder
+
+## Usage
+```
+/build-page "landing page for SaaS founders"
+/build-page "pricing page"
+/build-page "comparison vs CompetitorX"
+/build-page "feature page for AI automation"
+```
+
+## Input
+- `$ARGUMENTS` — **required**: page type + target audience or comparison subject
+
+## Process
+
+### Step 1: Parse Intent
+Extract from `$ARGUMENTS`:
+- **Page type**: landing, pricing, comparison, feature, about
+- **Target audience**: who is this page for? (e.g., "developers", "SaaS founders", "lawyers")
+- **Comparison subject**: if comparison page, which competitor?
+
+### Step 2: Load Context
+1. Read `data/positioning.json` — select relevant copy for the audience and funnel stage
+2. Read `data/competitors.json` — for comparison pages, load the specific competitor
+3. Read `data/config.json` — detect project framework from repos (Next.js, plain HTML, etc.)
+4. Read `data/pages.json` — check if a similar page already exists
+
+### Step 3: Determine Page Architecture
+Based on page type, plan the section layout:
+
+**Landing page:**
+1. Hero — headline, subheadline, primary CTA, hero image/visual
+2. Pain points — 3 problems the audience faces
+3. Solution — how the product solves these problems
+4. Features — 3-4 key features with icons
+5. Social proof — testimonials, stats, logos
+6. How it works — 3-step process
+7. FAQ — 4-6 common questions
+8. Final CTA — repeat primary CTA with urgency
+
+**Pricing page:**
+1. Hero — pricing headline
+2. Pricing tiers — cards with features, highlighted recommended plan
+3. Feature comparison table
+4. FAQ — pricing-specific questions
+5. CTA — start trial / contact sales
+
+**Comparison page:**
+1. Hero — "[Product] vs [Competitor]"
+2. Quick comparison table
+3. Detailed feature-by-feature comparison
+4. Where [Product] wins
+5. Social proof from switchers
+6. Migration CTA
+
+**Feature page:**
+1. Hero — feature-specific headline
+2. Problem → Solution narrative
+3. Feature details with screenshots/visuals
+4. Use cases
+5. CTA
+
+### Step 4: Select Copy
+For each section, select or adapt copy from `positioning.json`:
+- Match headline by funnel stage and audience
+- Select relevant CTAs
+- Pull social proof
+- Adapt objection handlers for FAQ section
+
+If positioning data is insufficient, generate new copy consistent with the existing framework.
+
+### Step 5: Generate Code
+Detect the project framework and generate appropriate code:
+
+**For Next.js projects** (most common):
+- Create a React component with TypeScript
+- Use Tailwind CSS for styling
+- Make it fully responsive (mobile-first)
+- Include proper semantic HTML (h1, h2, sections, etc.)
+- Add meta tags / SEO metadata via Next.js metadata API
+- Use `'use client'` directive only if interactivity is needed
+
+**For plain HTML projects:**
+- Generate standalone HTML + CSS
+- Include responsive design
+
+**Code quality requirements:**
+- Production-ready — not a prototype
+- Accessible (proper ARIA labels, contrast ratios)
+- Fast (no unnecessary JS, optimized images via next/image)
+- SEO-friendly (semantic markup, proper heading hierarchy)
+
+### Step 6: Track Build
+Update `data/pages.json`:
+```json
+{
+  "last_updated": "YYYY-MM-DD",
+  "pages": [
+    {
+      "id": "page-001",
+      "name": "Landing Page for SaaS Founders",
+      "url_path": "/landing",
+      "type": "landing",
+      "status": "draft",
+      "created_at": "YYYY-MM-DD",
+      "positioning_snapshot": "YYYY-MM-DD",
+      "competitor_refs": [],
+      "files_created": ["src/app/landing/page.tsx"],
+      "metrics": {
+        "bounce_rate": null,
+        "conversion_rate": null,
+        "avg_time_on_page": null,
+        "visitors": null
+      }
+    }
+  ]
+}
+```
+
+### Step 7: Output
+Print:
+- Files created (with full paths)
+- Local dev URL to preview (e.g., `http://localhost:3000/landing`)
+- Page structure summary (sections and their copy)
+- Recommendation: review and run `/measure-page` once live
+
+## Output Files
+- Generated page source code (location depends on framework)
+- `data/pages.json` — updated page registry

package/templates/commands/growth-audit.md

@@ -0,0 +1,85 @@
+# /growth-audit — Growth Channel Audit
+
+## Usage
+```
+/growth-audit                # Full channel comparison (default)
+/growth-audit seo            # Deep-dive on SEO channel
+/growth-audit paid           # Deep-dive on paid acquisition
+/growth-audit content        # Deep-dive on content marketing
+/growth-audit referral       # Deep-dive on referral/partnerships
+```
+
+## Input
+- `$ARGUMENTS` — optional: specific channel to deep-dive
+
+## Process
+
+### Step 1: Load Context
+1. Read `data/competitors.json` — all competitor growth channel data
+2. Read `data/business-context.json` — our current funnels, channels, KPIs
+3. Read `data/ideas.json` — existing growth ideas (to avoid duplicates)
+
+### Step 2: Map Channel Landscape
+If no competitor data exists, run quick WebSearch queries:
+- `"[product category] growth channels"`
+- `"[product category] marketing strategy"`
+- `"how to grow [product category] startup"`
+
+Build a channel comparison matrix:
+
+| Channel | Us | Competitor A | Competitor B | Competitor C |
+|---------|-----|-------------|-------------|-------------|
+| SEO/Blog | ... | ... | ... | ... |
+| Paid Search | ... | ... | ... | ... |
+| Social Media | ... | ... | ... | ... |
+| Content Marketing | ... | ... | ... | ... |
+| Email/Newsletter | ... | ... | ... | ... |
+| Referral Program | ... | ... | ... | ... |
+| Partnerships | ... | ... | ... | ... |
+| Community | ... | ... | ... | ... |
+
+For each channel, note: active/inactive, estimated investment level, content frequency.
+
+### Step 3: Gap Analysis
+Identify:
+1. **Channels competitors use that we don't** — potential opportunities
+2. **Channels we use that competitors don't** — potential advantages
+3. **Channels everyone uses** — table stakes, must maintain
+4. **Channels nobody uses** — either untapped opportunity or proven dead-end
+
+### Step 4: Channel Deep-Dive
+If `$ARGUMENTS` specifies a channel, or for the top 3 opportunity channels:
+
+Run WebSearch for best practices:
+- `"[channel] strategy for [product category] [year]"`
+- `"[channel] benchmarks SaaS [year]"`
+
+For each channel, estimate:
+- **Effort**: How much work to start? (1-10)
+- **Time to results**: Weeks/months until impact
+- **Impact potential**: Revenue/traffic uplift estimate
+- **Prerequisites**: What needs to exist first? (e.g., blog infrastructure for content)
+
+### Step 5: Generate Growth Experiments
+Create ranked growth experiments as ideas in `data/ideas.json`:
+
+For each recommended experiment:
+- Title: specific, actionable (e.g., "Launch SEO blog targeting [keyword cluster]")
+- Category: "growth"
+- Priority: based on effort/impact ratio
+- Implementation plan: step-by-step
+- Success metrics: measurable outcomes
+- Tags: include channel name
+
+Generate 3-5 experiments, ranked by estimated ROI.
+
+### Step 6: Output
+Print:
+- Channel comparison matrix
+- Gap analysis summary
+- Top 3 growth channel recommendations with rationale
+- Experiments generated (linked to ideas.json)
+- Recommendation for next step
+
+## Output Files
+- `data/ideas.json` — new growth experiment ideas

package/templates/commands/manage.md

@@ -0,0 +1,147 @@
+# /manage — Interactive Data Editor
+
+## Usage
+```
+/manage show me all ideas with priority=critical
+/manage change the priority of idea-emergency-001 to high
+/manage add a new idea: "Add telemetry dashboard for command usage"
+/manage move idea-003 to approved stage
+/manage update our MRR to 5000 in business context
+/manage show ideas stuck in inbox for more than 7 days
+/manage delete hypothesis hyp-005
+/manage list all goals that are behind
+```
+
+## Input
+- `$ARGUMENTS` — **required**: natural-language request describing what to query, create, update, or delete
+
+## Data File Map
+
+| File | Structure | Contains |
+|------|-----------|----------|
+| `data/ideas.json` | `{ ideas: BusinessIdea[] }` | Innovation pipeline |
+| `data/goals.json` | `{ goals: BusinessGoal[] }` | Business goals + KPIs |
+| `data/hypotheses.json` | `{ hypotheses: BusinessHypothesis[] }` | Testable hypotheses |
+| `data/business-context.json` | `BusinessConfig` | Product info, funnels, monetization |
+| `data/config.json` | `AnalystConfig` | Repos, schedules, autonomy settings |
+| `data/competitors.json` | `{ competitors[], last_updated }` | Competitor intelligence |
+| `data/positioning.json` | `PositioningData` | Brand positioning & copy bank |
+| `data/sessions.json` | `{ sessions: AnalysisSession[] }` | Analysis session history |
+
+## Schema Reference (Valid Enum Values)
+
+```
+Priority:          critical | high | medium | low
+Stage:             inbox | under_review | approved | in_progress | testing | shipped | deferred | rejected | rolled_back
+Category:          product | ux_design | growth | performance | tech_debt | security | infrastructure | content | analytics | integration
+Effort (size):     xs | s | m | l | xl
+Impact (size):     xs | s | m | l | xl
+GoalCategory:      acquisition | activation | retention | revenue | referral
+GoalStatus:        on_track | at_risk | behind | achieved
+HypothesisStatus:  stated | testing | validated | invalidated | deferred
+SourceType:        codebase_analysis | metrics_review | market_research | seo_audit | manual
+KPISource:         manual | rest_api | posthog | firestore | stripe | whatsapp
+KPIDirection:      higher_is_better | lower_is_better
+```
+
+## Process
+
+### Step 1: Parse Request
+Analyze `$ARGUMENTS` to determine:
+- **Intent**: query, create, update, delete, or bulk operation
+- **Entity type**: idea, goal, hypothesis, business-context, config, competitor, positioning, session
+- **Target**: specific ID (e.g., `idea-emergency-001`) or filter criteria (e.g., `priority=critical`)
+- **Fields to change**: which fields and their new values
+
+### Step 2: Load State
+Read **only** the data file(s) needed for this operation. Do NOT read all files.
+
+- Idea operations → `data/ideas.json`
+- Goal operations → `data/goals.json`
+- Hypothesis operations → `data/hypotheses.json`
+- Business context → `data/business-context.json`
+- Config changes → `data/config.json`
+- Competitor operations → `data/competitors.json`
+- Positioning operations → `data/positioning.json`
+- Session queries → `data/sessions.json`
+
+### Step 3: Execute
+
+#### For **queries** (show, list, find, count):
+- Filter the data based on the request criteria
+- Format results as a readable table or summary
+- Include relevant fields (id, title, stage, priority at minimum for ideas)
+- For time-based queries (e.g., "stuck in inbox for 7 days"), compare `created_at` or `updated_at` against current date
+
+#### For **create** (add, new, create):
+- Generate an ID following the existing pattern:
+  - Ideas: `idea-[slug]-NNN` (e.g., `idea-telemetry-001`)
+  - Goals: `goal-NNN` (e.g., `goal-005`)
+  - Hypotheses: `hyp-NNN` (e.g., `hyp-010`)
+- Set `created_at` and `updated_at` to current ISO timestamp
+- Set defaults for required fields not specified by the user:
+  - Ideas: `stage: "inbox"`, `priority: "medium"`, `source: { type: "manual" }`
+  - Hypotheses: `status: "stated"`, `priority: "medium"`
+  - Goals: `status: "on_track"`, `kpis: []`
+- Append to the appropriate array in the JSON file
+- Show the full created entity
+
+#### For **update** (change, set, move, update):
+- Find the entity by ID (exact match)
+- If ID is ambiguous or not found, search by title substring and ask for confirmation
+- Record the **before** value of changed fields
+- Apply the changes
+- Set `updated_at` to current ISO timestamp
+- Show a before/after diff
+
+#### For **delete** (remove, delete):
+- Find the entity by ID
+- Show what will be deleted and ask for confirmation before proceeding
+- Remove the entity from the array
+- Show confirmation of deletion
+
+#### For **bulk operations** (e.g., "move all inbox ideas older than 30 days to deferred"):
+- Show all entities that match the criteria
+- Ask for confirmation before applying changes
+- Apply changes to all matching entities
+- Show summary of changes
+
+### Step 4: Validate
+Before writing any changes, verify:
+1. **Enum values are valid** — check against the Schema Reference above
+2. **Required fields are present** — id, title, created_at, updated_at at minimum
+3. **IDs are unique** — no duplicate IDs in the array
+4. **Array structure preserved** — the file still has the correct top-level structure (e.g., `{ "ideas": [...] }`)
+5. **Timestamps are ISO 8601** — format: `2026-02-16T12:00:00Z`
+
+If validation fails, report the error and do NOT write the file.
+
+### Step 5: Report
+After executing, print a summary:
+
+**For queries:**
+```
+📋 Found N [entities] matching "[criteria]"
+[formatted table or list]
+```
+
+**For mutations (create/update/delete):**
+```
+✅ [Action] completed
+
+Entity: [id]
+File: data/[file].json
+
+[Before → After diff for changed fields]
+```
+
+## Safety Rules
+1. **Always read before writing** — never modify a file without reading it first
+2. **Preserve structure** — maintain the JSON array wrapper and all unchanged fields
+3. **Validate enums** — reject invalid enum values with a helpful error message listing valid options
+4. **Update timestamps** — set `updated_at` on every mutation
+5. **Confirm destructive actions** — ask before delete or bulk operations
+6. **One file at a time** — avoid writing multiple data files in a single operation unless explicitly requested
+
+## Output Files
+- The specific `data/*.json` file(s) modified by the operation

package/templates/commands/measure-page.md

@@ -0,0 +1,89 @@
+# /measure-page — Page Performance Check
+
+## Usage
+```
+/measure-page /landing              # Measure by URL path
+/measure-page page-001              # Measure by page ID
+/measure-page all                   # Measure all tracked pages
+```
+
+## Input
+- `$ARGUMENTS` — **required**: page URL path, page ID, or "all"
+
+## Process
+
+### Step 1: Identify Page
+1. Read `data/pages.json`
+2. Find the page by:
+   - URL path match (e.g., `/landing`)
+   - Page ID match (e.g., `page-001`)
+   - If "all", process all pages with status "live"
+3. If page not found, list available pages and exit
+
+### Step 2: Gather Metrics
+Check for analytics integration:
+
+1. **KPI Adapters** — check `data/business-context.json` for configured analytics adapters
+2. **Manual Input** — if no adapter, ask the user for metrics:
+   - Bounce rate (%)
+   - Conversion rate (%)
+   - Average time on page (seconds)
+   - Total visitors (in measurement period)
+
+### Step 3: Benchmark Comparison
+Compare metrics against:
+
+1. **Industry benchmarks** (use WebSearch if needed):
+   - Landing page average bounce rate: 40-60%
+   - Landing page average conversion rate: 2-5%
+   - Good time on page: >60 seconds
+
+2. **Competitor pages** — if competitor data exists in `data/competitors.json`, compare:
+   - Our CTA clarity vs. theirs
+   - Our social proof depth vs. theirs
+   - Our headline specificity vs. theirs
+
+### Step 4: Identify Improvements
+Based on metrics and benchmarks, identify specific improvement opportunities:
+
+- **High bounce rate (>60%)** → headline mismatch, slow load, unclear value prop
+- **Low conversion (<2%)** → weak CTA, missing social proof, too many options
+- **Low time on page (<30s)** → content not engaging, poor above-the-fold
+- **Good metrics** → consider A/B test variations for further optimization
+
+For each issue, provide:
+- The specific problem
+- Evidence from the metrics
+- Recommended fix (referencing positioning data)
+- Expected impact
+
+### Step 5: Update Pages Data
+Update `data/pages.json` with the measurements:
+```json
+{
+  "metrics": {
+    "bounce_rate": 45.2,
+    "conversion_rate": 3.1,
+    "avg_time_on_page": 87,
+    "visitors": 1250
+  }
+}
+```
+
+### Step 6: Generate Optimization Ideas
+If metrics are below benchmarks, generate improvement ideas in `data/ideas.json`:
+- Category: "growth" or "ux_design"
+- Tag with page ID
+- Include specific, actionable implementation plan
+- Reference positioning data for copy improvements
+
+### Step 7: Output
+Print:
+- Current metrics vs. benchmarks (table format)
+- Performance grade (A/B/C/D/F)
+- Top 3 improvement recommendations
+- Ideas generated (if any)
+
+## Output Files
+- `data/pages.json` — updated metrics
+- `data/ideas.json` — new optimization ideas (if applicable)

package/templates/commands/positioning.md

@@ -0,0 +1,128 @@
+# /positioning — Positioning & Copy Framework
+
+## Usage
+```
+/positioning                # Full analysis (default)
+/positioning copy-bank      # Regenerate copy variations using existing positioning
+/positioning refresh        # Re-analyze after new competitor data
+```
+
+## Input
+- `$ARGUMENTS` — optional: "copy-bank" or "refresh"
+
+## Process
+
+### Step 1: Load Context
+1. Read `data/competitors.json` — all competitor profiles
+2. Read `data/business-context.json` — product info, funnels, monetization
+3. Read `data/positioning.json` — existing positioning (if any)
+4. Determine mode:
+   - Empty → full analysis
+   - `"copy-bank"` → skip positioning analysis, regenerate copy only
+   - `"refresh"` → full re-analysis treating existing positioning as draft
+
+### Step 2: Market Landscape Analysis
+**Skip if mode is "copy-bank".**
+
+If no competitor data exists, run lightweight WebSearch queries:
+- `"[product category] market landscape [year]"`
+- `"[product category] comparison"`
+
+Map all competitors on these axes:
+- **Price vs. Features** — who's premium vs. budget?
+- **Audience segments** — developers, SMBs, enterprise, specific verticals?
+- **Positioning angles** — speed, simplicity, power, price, trust?
+
+Identify:
+- Which quadrants are crowded vs. empty?
+- Which audience segments are underserved?
+- What messaging angles are overused?
+
+### Step 3: Positioning Definition
+Define or refine:
+
+1. **Ideal Customer Profile (ICP)**:
+   - Primary audience: who benefits most?
+   - Secondary audiences: who else uses this?
+   - Anti-personas: who is NOT our customer? (important for focus)
+
+2. **Value Proposition**: One clear sentence — what do we do, for whom, and why is it better?
+
+3. **Differentiators**: 3-5 specific things that make us different. Each must be:
+   - True (we actually do this)
+   - Relevant (customers care about this)
+   - Unique (competitors don't do this or do it worse)
+
+4. **Messaging Pillars**: 3-4 themes that all our messaging reinforces. For each:
+   - Pillar name (e.g., "Simplicity", "Speed", "Trust")
+   - Proof points (specific evidence)
+   - Counter-objections (how to respond when challenged)
+
+### Step 4: Generate Copy Bank
+Generate copy variations segmented by funnel stage (TOFU/MOFU/BOFU) and audience:
+
+1. **Headlines** (5+ variations):
+   - TOFU: awareness/education focused
+   - MOFU: consideration/comparison focused
+   - BOFU: decision/urgency focused
+
+2. **Subheadlines** (3+ variations): support the headline with specifics
+
+3. **CTAs** (5+ variations):
+   - Primary: main action (e.g., "Start Free Trial")
+   - Secondary: lower commitment (e.g., "See Demo")
+   - Micro: in-content (e.g., "Learn More")
+
+4. **Social Proof** snippets: stats, testimonials, logos, case studies
+
+5. **Objection Handlers**: for each common objection, a concise response
+   - "Too expensive" → ...
+   - "I already use X" → ...
+   - "Is it secure?" → ...
+
+6. **Pain Points**: ranked by intensity and audience segment
+
+### Step 5: Write Output
+Write to `data/positioning.json`:
+```json
+{
+  "last_updated": "YYYY-MM-DD",
+  "current": {
+    "tagline": "...",
+    "value_proposition": "...",
+    "target_audience": {
+      "primary": "...",
+      "secondary": ["..."],
+      "anti_personas": ["..."]
+    },
+    "differentiators": ["..."],
+    "messaging_pillars": [
+      {
+        "pillar": "...",
+        "proof_points": ["..."],
+        "counter_objections": ["..."]
+      }
+    ]
+  },
+  "copy_bank": {
+    "headlines": [{ "text": "...", "audience": "...", "funnel_stage": "tofu" }],
+    "subheadlines": [{ "text": "...", "audience": "...", "funnel_stage": "tofu" }],
+    "ctas": [{ "text": "...", "context": "...", "conversion_rate": null }],
+    "social_proof": [{ "text": "...", "type": "stat" }],
+    "objection_handlers": [{ "objection": "...", "response": "..." }],
+    "pain_points": [{ "pain": "...", "audience": "...", "intensity": "high" }]
+  }
+}
+```
+
+### Step 6: Print Summary
+Print a positioning canvas:
+- Tagline and value proposition
+- ICP summary
+- Top 3 differentiators
+- Messaging pillars overview
+- Copy bank stats (N headlines, N CTAs, etc.)
+- Recommendation for next step (usually: run `/build-page`)
+
+## Output Files
+- `data/positioning.json` — positioning framework and copy bank