vibesuite 1.0.0

package/.agent/skills/google-trends/scripts/search.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import googleTrends from 'google-trends-api';
+
+program
+    .name('search')
+    .description('Google Trends CLI for topic research')
+    .requiredOption('-k, --keyword <string>', 'Topic to search')
+    .option('-p, --property <string>', 'youtube | web | images | news | froogle', 'youtube')
+    .option('-t, --time <string>', 'Time range (now 7-d, now 1-m, today 3-m, today 12-m)', 'now 7-d')
+    .option('-c, --category <number>', 'Category ID (5 = Tech)', '5')
+    .option('-o, --output <string>', 'Output format: table | json | markdown', 'table')
+    .option('-f, --file <path>', 'Output file path')
+    .option('--interest', 'Include interest-over-time data', false)
+    .parse();
+
+const opts = program.opts();
+
+// Parse time range string to date
+function getStartTime(timeStr) {
+    const now = Date.now();
+    const match = timeStr.match(/^(now|today)\s+(\d+)-([dmy])$/);
+    if (!match) return new Date(now - 7 * 24 * 60 * 60 * 1000); // default 7 days
+
+    const [, , num, unit] = match;
+    const amount = parseInt(num, 10);
+    switch (unit) {
+        case 'd': return new Date(now - amount * 24 * 60 * 60 * 1000);
+        case 'm': return new Date(now - amount * 30 * 24 * 60 * 60 * 1000);
+        case 'y': return new Date(now - amount * 365 * 24 * 60 * 60 * 1000);
+        default: return new Date(now - 7 * 24 * 60 * 60 * 1000);
+    }
+}
+
+async function fetchRelatedQueries() {
+    const result = await googleTrends.relatedQueries({
+        keyword: opts.keyword,
+        startTime: getStartTime(opts.time),
+        property: opts.property === 'web' ? '' : opts.property,
+        category: parseInt(opts.category, 10),
+    });
+    return JSON.parse(result);
+}
+
+async function fetchInterestOverTime() {
+    if (!opts.interest) return null;
+    const result = await googleTrends.interestOverTime({
+        keyword: opts.keyword,
+        startTime: getStartTime(opts.time),
+        property: opts.property === 'web' ? '' : opts.property,
+        category: parseInt(opts.category, 10),
+    });
+    return JSON.parse(result);
+}
+
+function formatTable(data, interest) {
+    const lines = [];
+    lines.push(`\n[TrendProbe] Searching: "${opts.keyword}" on ${opts.property} (${opts.time})\n`);
+
+    const ranked = data?.default?.rankedList || [];
+    ranked.forEach((list, idx) => {
+        const label = idx === 0 ? 'Top' : 'Rising';
+        lines.push(`--- Related Queries (${label}) ---`);
+
+        (list.rankedKeyword || []).forEach((item, i) => {
+            const value = typeof item.value === 'string' ? item.value : item.value;
+            const display = item.formattedValue || (value === 'Breakout' ? 'BREAKOUT' : value);
+            lines.push(`${i + 1}. ${item.query} (${display})`);
+        });
+        lines.push('');
+    });
+
+    if (interest?.default?.timelineData) {
+        lines.push('--- Interest Over Time ---');
+        const timeline = interest.default.timelineData.slice(-7); // Last 7 data points
+        timeline.forEach(point => {
+            lines.push(`${point.formattedTime}: ${point.value[0]}`);
+        });
+        lines.push('');
+    }
+
+    return lines.join('\n');
+}
+
+function formatJSON(data, interest) {
+    const ranked = data?.default?.rankedList || [];
+    const result = {
+        keyword: opts.keyword,
+        property: opts.property,
+        time: opts.time,
+        category: opts.category,
+        top: (ranked[0]?.rankedKeyword || []).map(q => ({ query: q.query, value: q.value })),
+        rising: (ranked[1]?.rankedKeyword || []).map(q => ({ query: q.query, value: q.formattedValue || q.value })),
+    };
+    if (interest?.default?.timelineData) {
+        result.interest = interest.default.timelineData.map(p => ({ time: p.formattedTime, value: p.value[0] }));
+    }
+    return JSON.stringify(result, null, 2);
+}
+
+function formatMarkdown(data, interest) {
+    const lines = [];
+    lines.push(`## ${opts.keyword} (${opts.property}, ${opts.time})`);
+    lines.push('');
+
+    const ranked = data?.default?.rankedList || [];
+    if (ranked[0]?.rankedKeyword?.length) {
+        lines.push('### Top Queries');
+        ranked[0].rankedKeyword.forEach((q, i) => {
+            lines.push(`${i + 1}. ${q.query} (${q.value})`);
+        });
+        lines.push('');
+    }
+
+    if (ranked[1]?.rankedKeyword?.length) {
+        lines.push('### Rising Queries');
+        ranked[1].rankedKeyword.forEach((q, i) => {
+            const display = q.formattedValue || q.value;
+            lines.push(`${i + 1}. ${q.query} (${display})`);
+        });
+        lines.push('');
+    }
+
+    if (interest?.default?.timelineData) {
+        lines.push('### Interest Over Time');
+        interest.default.timelineData.slice(-7).forEach(p => {
+            lines.push(`- ${p.formattedTime}: ${p.value[0]}`);
+        });
+        lines.push('');
+    }
+
+    return lines.join('\n');
+}
+
+async function main() {
+    try {
+        const [relatedData, interestData] = await Promise.all([
+            fetchRelatedQueries(),
+            fetchInterestOverTime(),
+        ]);
+
+        let output;
+        switch (opts.output) {
+            case 'json':
+                output = formatJSON(relatedData, interestData);
+                break;
+            case 'markdown':
+                output = formatMarkdown(relatedData, interestData);
+                break;
+            default:
+                output = formatTable(relatedData, interestData);
+        }
+
+        console.log(output);
+
+        if (opts.file) {
+            const fs = await import('fs');
+            fs.writeFileSync(opts.file, output, 'utf-8');
+            console.log(`\n[Saved to ${opts.file}]`);
+        }
+
+    } catch (err) {
+        console.error('[Error]', err.message);
+        process.exit(1);
+    }
+}
+
+main();

package/.agent/skills/high-fidelity-extraction/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: high-fidelity-extraction
+description: Advanced protocol for extracting granular social media and web intelligence using browser automation and DOM analysis.
+---
+
+# High Fidelity Data Extraction Protocol
+
+This skill enables the agent to extract deep intelligence from social media platforms (Instagram, TikTok, YouTube, etc.) and complex web environments with high precision.
+
+## 🚀 Core Philosophy: The Extraction Spectrum
+
+When tasked with extraction, always check the prompt for specific limitations. If no limitations are provided, assume **Standard Level**.
+
+### Extraction Capability Matrix
+
+| Feature | Basic (Standard) | Deep (Advanced) | Elite (Full Intelligence) |
+| :--- | :--- | :--- | :--- |
+| **Captions** | Full Text + Hashtags | + Edited timestamps | + OCR from video overlays |
+| **Comments** | Top 3-5 (Top Level) | Top 10 + Threaded replies | Full sentiment & pain point mapping |
+| **Engagement** | Likes / Views count | Engagement Rate % | Share/Save estimates & Viral Velocity |
+| **Brand Intel** | @Mentions in caption | + Link-in-bio analysis | + Competitor comparison vs Meta Ad Library |
+| **Visuals** | Profile Screen/Grid | Individual Post Screenshots | UI/UX Reverse Engineering of Funnel |
+| **Technical** | URL collection | Precise ISO Timestamps | API Pattern Mapping & DB Schema generation |
+
+## 📊 Tabular Output Format
+
+Unless the user specifies otherwise, all extracted data should be compiled into a Markdown table for maximum scannability.
+
+### Standard Template:
+```markdown
+| Post Type | Caption Snippet | Top Comments (Synthesized) | Key Metrics | Brand/Tags |
+| :--- | :--- | :--- | :--- | :--- |
+| Pinned | "How to be..." | Users asking about discipline tips | 30k Likes | @Adidas, #NYC |
+| Recent 1 | "Day in life..." | High praise for work/life balance | 15k Views | @CeraVe |
+```
+
+## 🧠 Smart Filtering Strategy (Instagram Reels)
+When the goal involves "high-performing" content or maximizing engagement:
+
+1.  **Reels First**: Navigate to the `/reels/` tab immediately. View counts are not visible on the main grid but are overlayed on Reel thumbnails.
+2.  **Baseline Calculation**: 
+    - Extract view counts from the first 6-12 visible Reels.
+    - Calculate the **average (mean)** view count.
+3.  **Filtration**:
+    - Only click/extract posts that exceed this average.
+    - This ensures we focus valuable browser resources on proven content.
+
+## 🛠️ Execution Instructions for the Subagent
+
+1.  **DOM First**: Never navigate blindly. Use `browser_get_dom` to identify the obfuscated class names for captions and comments.
+2.  **Surgical Navigation**: To avoid 429 errors (Too Many Requests), navigate directly to post URLs once the links are gathered from the grid, rather than infinite scrolling.
+3.  **Expansion Logic**: Always look for `... more` or "View all comments" buttons and trigger them via JavaScript to ensure data completeness.
+4.  **Verification**: Always capture a final screenshot of the "Main Extraction Target" to verify text accuracy against the visual truth.
+
+## 🛑 Limitations & Compliance
+
+- **Obey Prompt Bounds**: If the user says "Only get usernames," do NOT extract captions. 
+- **Privacy**: Respect platform TOS by focusing on public-facing data and ignoring private user details.
+- **Anti-Spam**: Filter out "Promote on..." or generic bot comments automatically.

package/.agent/skills/prime-agent/SKILL.md

@@ -0,0 +1,97 @@
+---
+name: prime-agent
+description: Load project context including coding guidelines, styling rules, and folder structure before starting work.
+---
+
+# Prime Agent Skill
+
+Load the "brain" of the project — coding guidelines, styling rules, and architectural decisions.
+
+## When to Use
+- Start of session
+- Before complex work
+- After `/migrate` to supplement snapshot
+- When context seems lost
+
+## Load Core Documentation
+
+```bash
+# Coding Guidelines
+cat docs/coding_guidelines.md 2>/dev/null || \
+cat docs/Coding_Guidelines.md 2>/dev/null
+
+# Styling Guide
+cat docs/Styling*.md 2>/dev/null || \
+cat docs/design/*.md 2>/dev/null
+
+# Styling Addendum (project-specific)
+cat docs/Styling-Addendum.md 2>/dev/null
+```
+
+## Check for UI Mockups
+
+```bash
+ls docs/mockups/ 2>/dev/null
+ls docs/design/mockups/ 2>/dev/null
+ls docs/design/design-system.html 2>/dev/null
+```
+
+> **IMPORTANT**: If mockups exist, they are the **UNQUESTIONABLE source of truth** for UI. Replicate exactly.
+
+## Key Rules to Internalize
+
+### From Coding Guidelines
+- **Blueprint Protocol**: Plan before code, docs in `docs/features/`
+- **200-Line Rule**: Refactor if exceeded
+- **File Structure**: Feature-sliced design (`src/features/[Name]/`)
+- **Server vs Client**: RSCs by default, `'use client'` sparingly
+- **Service Pattern**: Route Handlers = controllers, Services = business logic
+- **Validation**: Zod for all inputs
+
+### From Styling Guide
+- **Tailwind v4**: CSS-first with `@theme` tokens
+- **Core Tokens**: `--color-background`, `--color-foreground`, `--color-border`
+- **Dark Mode**: `@theme .dark { }` overrides
+- **Animations**: Define in CSS with `@keyframes`
+
+## Acknowledgment
+
+After loading, state:
+
+"✅ **Agent Primed.** Internalized:
+
+**Coding Guidelines:**
+- Blueprint Protocol: Plan → Approve → Build → Document
+- 200-line component limit
+- Feature-sliced architecture
+- Server Components default
+
+**Styling Rules:**
+- Tailwind v4 with `@theme` tokens
+- Dark mode via `.dark` class
+
+**UI Mockups:** [List any found or 'None']
+
+What would you like to build?"
+
+## Quick Reference Card
+
+```
+src/
+├── app/           # Next.js App Router pages
+├── features/      # Feature-sliced modules
+│   └── [Name]/    # Components, hooks, services
+├── components/ui/ # Reusable UI components
+├── lib/           # Utilities, API clients
+└── scripts/       # Build/automation scripts
+```
+
+**Key Commands:**
+- `npm run dev` — Start development
+- `npm run build` — Production build
+- `npm run db:seed` — Seed database
+
+**Style Tokens:**
+- `bg-background` / `text-foreground`
+- `bg-primary` / `text-primary`
+- `dark:` prefix for dark mode

package/.agent/skills/security-audit/SKILL.md

@@ -0,0 +1,81 @@
+---
+name: security-audit
+description: Perform a meticulous deep code audit covering Security, Logic, Completeness, and Quality. Manual analysis for critical systems.
+---
+
+# Security Audit Skill
+
+A comprehensive, manual deep code audit protocol for security-critical systems.
+
+## When to Use
+- Before major releases
+- Security review requests
+- Auditing authentication/payment flows
+- When "audit" or "security" is mentioned
+
+## Audit Phases
+
+### Phase 0: Scope Definition
+Define boundaries:
+- **FULL_SCAN**: Entire codebase
+- **FEATURE_SCAN**: Specific feature (`docs/features/[Name].md`)
+- **DIFF_SCAN**: `git diff --staged` or `git diff HEAD~1`
+
+### Phase 1: The Detective (Static Analysis)
+```bash
+# 1. Dependency audit
+pnpm audit  # or npm audit
+
+# 2. Secret scanning (use jstar if available)
+jstar detect
+
+# 3. Manual grep patterns:
+# Secrets
+grep -rE "(api_key|secret|password|token)\s*[:=]\s*['\"\`][a-zA-Z0-9_\-\.]{10,}['\"\`]"
+
+# RCE/Injection
+grep -rE "(dangerouslySetInnerHTML|eval\(|exec\(|\.queryRaw)"
+
+# Debugging
+grep -rE "(console\.log|debugger|todo)"
+```
+
+### Phase 2: The Graph (Data Flow)
+- Identify Entry Points (Routes, Actions, CLI)
+- **Trace Input**: User input → Service → Database
+- **Verify Validation**: Zod/Typebox at edge boundaries
+
+### Phase 3: The Auditor (Spec vs Code)
+- Read `docs/features/*.md` for scope
+- **Gap Analysis**: Features in Docs but missing in Code
+- **Orphan Analysis**: Code not in Docs (zombie code)
+
+### Phase 4: The Judge (Logic Probing)
+Pick highest-risk file and simulate:
+- "What if I send `null`? Empty string? Negative ID?"
+- "What if two requests hit this at once?" (race conditions)
+- "Can I access this Service function directly?" (auth bypass)
+
+### Phase 5: The Architect (Quality)
+- **Performance**: `await` in loops → N+1 queries
+- **Bloat**: Files > 200 lines? Functions > 50 lines?
+- **Types**: Any use of `any` or `as unknown`?
+- **Structure**: Feature-Sliced Design compliance?
+
+### Phase 6: Report
+Create `.jstar/audit_report.md`:
+
+| Severity | Category | Location | Issue | Recommendation |
+|----------|----------|----------|-------|----------------|
+| CRITICAL | SECURITY | `api/auth` | ... | ... |
+| HIGH | LOGIC | `service.ts:42` | ... | ... |
+
+Severities: `CRITICAL`, `HIGH`, `WARNING`, `INFO`
+Categories: `SECURITY`, `LOGIC`, `COMPLETENESS`, `QUALITY`
+
+### Phase 7: Remediation
+For each CRITICAL/HIGH:
+1. Implement fix
+2. Run build/tests
+3. Re-verify with grep/logic check
+4. Stage changes

package/.agent/skills/seo-ready/SKILL.md

@@ -0,0 +1,133 @@
+---
+name: seo-ready
+description: Make any Next.js page SEO-ready with metadata, structured data, sitemap, and accessibility best practices.
+---
+
+# SEO Ready Skill
+
+Transform Next.js pages into fully SEO-optimized pages.
+
+## When to Use
+- SEO optimization requests
+- Before launching pages to production
+- When asked about metadata or search visibility
+- Accessibility audits
+
+## Phase 1: Global Setup (Once Per Project)
+
+### Check Root Metadata
+```bash
+head -50 src/app/layout.tsx
+```
+
+Required in `layout.tsx`:
+```typescript
+export const metadata: Metadata = {
+  title: { default: "Site Name", template: "%s | Site Name" },
+  description: "...",
+  metadataBase: new URL("https://your-domain.com"),
+  openGraph: { /* ... */ },
+  twitter: { /* ... */ },
+};
+```
+
+### Sitemap
+```bash
+ls src/app/sitemap.ts 2>/dev/null || echo "MISSING"
+```
+
+If missing, create `src/app/sitemap.ts`:
+```typescript
+import { MetadataRoute } from 'next'
+
+export default function sitemap(): MetadataRoute.Sitemap {
+  const baseUrl = 'https://your-domain.com'
+  return [
+    { url: baseUrl, lastModified: new Date(), changeFrequency: 'yearly', priority: 1 },
+  ]
+}
+```
+
+### Robots.txt
+Create `src/app/robots.ts` if missing.
+
+### Web Manifest (PWA)
+Create `src/app/manifest.ts` if missing.
+
+### Icons
+Check: `src/app/icon.png`, `src/app/apple-icon.png`
+
+### OpenGraph Image
+Options:
+- **Static**: `src/app/opengraph-image.png` (1200x630px)
+- **Dynamic**: `src/app/opengraph-image.tsx`
+
+### JSON-LD Structured Data
+Add to `<body>` in layout:
+```tsx
+<script
+  type="application/ld+json"
+  dangerouslySetInnerHTML={{
+    __html: JSON.stringify({
+      "@context": "https://schema.org",
+      "@type": "SoftwareApplication",
+      "name": "Your App",
+    })
+  }}
+/>
+```
+
+## Phase 2: Per-Page Optimization
+
+### Server Component Check
+If page starts with `'use client'`, refactor:
+- Move client logic to `src/features/<feature>/components/`
+- Page file becomes Server Component that imports client component
+
+### Page Metadata
+```typescript
+import { Metadata } from 'next';
+
+export const metadata: Metadata = {
+  title: "Page Title",  // Becomes "Page Title | Site Name"
+  description: "Specific description for this page.",
+};
+```
+
+### Semantic HTML Audit
+- `<main>` for primary content
+- `<section>` with `id` for anchors
+- `<article>` for standalone content
+- Proper heading hierarchy (`<h1>` → `<h2>` etc.)
+
+### Image Optimization
+- Use `<Image>` component
+- Required: `alt`, `width`, `height`
+
+## Phase 3: Accessibility
+
+- ARIA labels on interactive elements
+- `<html lang="en">` set correctly
+- Keyboard navigable
+
+## Phase 4: Verification
+
+```bash
+pnpm build
+pnpm dev
+# Visit /sitemap.xml and /robots.txt
+```
+
+## Checklist
+| Item | Status |
+|------|--------|
+| Root metadata | [ ] |
+| sitemap.ts | [ ] |
+| robots.ts | [ ] |
+| manifest.ts | [ ] |
+| Icons | [ ] |
+| OpenGraph image | [ ] |
+| JSON-LD | [ ] |
+| Page metadata | [ ] |
+| Semantic HTML | [ ] |
+| Build passes | [ ] |

package/.agent/skills/spawn-task/SKILL.md

@@ -0,0 +1,130 @@
+---
+name: spawn-task
+description: Create comprehensive, self-contained task prompts for implementing features or fixing bugs.
+---
+
+# Spawn Task Skill
+
+Create detailed task prompts that another agent (or future self) can execute without additional context.
+
+## When to Use
+- Breaking down complex features
+- Creating implementation specs
+- When user says "spawn a task for..."
+- Planning multi-phase work
+
+## Task Discovery
+
+Gather from user:
+- **Task Description**: What needs to be done?
+- **Priority**: High / Medium / Low
+- **Scope**: What's included/excluded?
+- **Timeline**: Expected completion (optional)
+
+## Current State Analysis
+
+```bash
+# Check related files
+find src -name "*relevant*" -type f
+
+# Check documentation
+ls docs/features/
+
+# Check GitHub issues
+gh issue list --search "[related term]"
+```
+
+## Task Prompt Template
+
+Create `docs/tasks/[TaskName].md`:
+
+```markdown
+# 🎯 Task: [Task Name]
+
+**Objective:** [Clear, measurable goal]
+**Priority:** [High/Medium/Low]
+**Scope:** [What's included/excluded]
+
+---
+
+## 📋 Requirements
+
+### Functional Requirements
+- **[REQ-001]** [Requirement with acceptance criteria]
+
+### Technical Requirements
+- **[TECH-001]** [Technical specification]
+
+---
+
+## 🏗️ Implementation Plan
+
+### Phase 1: Setup
+- [ ] [Setup task]
+
+### Phase 2: Core Implementation
+- [ ] [Core task]
+
+### Phase 3: Enhancement
+- [ ] [Enhancement task]
+
+### Phase 4: Testing & Documentation
+- [ ] [Testing task]
+
+---
+
+## 📁 Files to Create/Modify
+
+| File | Action | Purpose |
+|------|--------|---------|
+| `src/features/[Feature]/...` | Create | [Purpose] |
+
+---
+
+## ✅ Success Criteria
+
+### Code Quality
+- [ ] TypeScript compliant (no `any`)
+- [ ] Passes ESLint
+- [ ] Unit tests with >80% coverage
+
+### Performance
+- [ ] Bundle size increase < 5KB
+- [ ] Load time < 1.5s
+
+### Functionality
+- [ ] All requirements implemented
+- [ ] Mobile responsive
+
+---
+
+## 🔗 Dependencies
+
+**Depends on:** [Other components]
+**Used by:** [Components that use this]
+
+---
+
+## 🚀 Getting Started
+
+1. Read this task prompt completely
+2. Review related files
+3. Begin with Phase 1
+4. Provide progress updates after each phase
+```
+
+## Options After Spawning
+- **A)** Start implementing now
+- **B)** Create GitHub Issue to track
+- **C)** Save task for later
+
+## Task Categories
+- 🆕 **Feature**: New functionality
+- 🐛 **Bug Fix**: Fixing broken behavior
+- ♻️ **Refactor**: Improving existing code
+- 📚 **Documentation**: Writing docs
+
+## Priority Guidelines
+- **High**: Blocking other work, user-facing bugs
+- **Medium**: Important features, non-blocking issues
+- **Low**: Nice-to-haves, minor improvements