takomi 2.0.4

package/assets/.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/assets/.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/assets/.agent/skills/jules/SKILL.md

@@ -0,0 +1,196 @@
+---
+name: jules
+description: "Delegate coding tasks to Google Jules AI agent for asynchronous execution. Use when user says: 'have Jules fix', 'delegate to Jules', 'send to Jules', 'ask Jules to', 'check Jules sessions', 'pull Jules results', 'jules add tests', 'jules add docs', 'jules review pr'. Handles: bug fixes, documentation, features, tests, refactoring, code reviews. Works with GitHub repos, creates PRs."
+---
+
+# Jules Task Delegation
+
+Delegate coding tasks to Google's Jules AI agent on GitHub repositories.
+
+## Setup (Run Before First Command)
+
+### 1. Install CLI
+```bash
+which jules || npm install -g @google/jules
+```
+
+### 2. Check Auth
+```bash
+jules remote list --repo
+```
+If fails → tell user to run `jules login` (or `--no-launch-browser` for headless)
+
+### 3. Auto-Detect Repo
+```bash
+git remote get-url origin 2>/dev/null | sed -E 's#.*(github\.com)[/:]([^/]+/[^/.]+)(\.git)?#\2#'
+```
+If not GitHub or not in git repo → ask user for `--repo owner/repo`
+
+### 4. Verify Repo Connected
+Check repo is in `jules remote list --repo`. If not → direct to https://jules.google.com
+
+## Commands
+
+### Create Tasks
+```bash
+jules new "Fix auth bug"                                   # Auto-detected repo
+jules new --repo owner/repo "Add unit tests"               # Specific repo
+jules new --repo owner/repo --parallel 3 "Implement X"     # Parallel sessions
+cat task.md | jules new --repo owner/repo                  # From stdin
+```
+
+### Monitor
+```bash
+jules remote list --session    # All sessions
+jules remote list --repo       # Connected repos
+```
+
+### Retrieve Results
+```bash
+jules remote pull --session <id>         # View diff
+jules remote pull --session <id> --apply # Apply locally
+jules teleport <id>                      # Clone + apply
+```
+
+### Latest Session Shortcut
+```bash
+LATEST=$(jules remote list --session 2>/dev/null | awk 'NR==2 {print $1}')
+jules remote pull --session $LATEST
+```
+
+## Smart Context Injection
+
+Enrich prompts with current context for better results:
+
+```bash
+BRANCH=$(git branch --show-current)
+RECENT_FILES=$(git diff --name-only HEAD~3 2>/dev/null | head -10 | tr '\n' ', ')
+RECENT_COMMITS=$(git log --oneline -5 | tr '\n' '; ')
+STAGED=$(git diff --cached --name-only | tr '\n' ', ')
+```
+
+**Use when creating tasks:**
+```bash
+jules new --repo owner/repo "Fix the bug in auth module. Context: branch=$BRANCH, recently modified: $RECENT_FILES"
+```
+
+## Template Prompts
+
+Quick commands for common tasks:
+
+### Add Tests
+```bash
+FILES=$(git diff --name-only HEAD~3 2>/dev/null | grep -E '\.(js|ts|py|go|java)$' | head -5 | tr '\n' ', ')
+jules new "Add unit tests for recently modified files: $FILES. Include edge cases and mocks where needed."
+```
+
+### Add Documentation
+```bash
+FILES=$(git diff --name-only HEAD~3 2>/dev/null | grep -E '\.(js|ts|py|go|java)$' | head -5 | tr '\n' ', ')
+jules new "Add documentation comments to: $FILES. Include function descriptions, parameters, return values, and examples."
+```
+
+### Fix Lint Errors
+```bash
+jules new "Fix all linting errors in the codebase. Run the linter, identify issues, and fix them while maintaining code functionality."
+```
+
+### Review PR
+```bash
+PR_NUM=123
+PR_INFO=$(gh pr view $PR_NUM --json title,body,files --jq '"\(.title)\n\(.body)\nFiles: \(.files[].path)"')
+jules new "Review this PR for bugs, security issues, and improvements: $PR_INFO"
+```
+
+## Git Integration (Apply + Commit)
+
+After Jules completes, apply changes to a new branch:
+
+```bash
+SESSION_ID="<id>"
+TASK_DESC="<brief description>"
+
+# Create branch, apply, commit
+git checkout -b "jules/$SESSION_ID"
+jules remote pull --session "$SESSION_ID" --apply
+git add -A
+git commit -m "feat: $TASK_DESC
+
+Jules session: $SESSION_ID"
+
+# Optional: push and create PR
+git push -u origin "jules/$SESSION_ID"
+gh pr create --title "$TASK_DESC" --body "Automated changes from Jules session $SESSION_ID"
+```
+
+## Poll Until Complete
+
+Wait for session to finish:
+
+```bash
+SESSION_ID="<id>"
+while true; do
+  STATUS=$(jules remote list --session 2>/dev/null | grep "$SESSION_ID" | awk '{print $NF}')
+  case "$STATUS" in
+    Completed)
+      echo "Done!"
+      jules remote pull --session "$SESSION_ID"
+      break ;;
+    Failed)
+      echo "Failed. Check: https://jules.google.com/session/$SESSION_ID"
+      break ;;
+    *User*)
+      echo "Needs input: https://jules.google.com/session/$SESSION_ID"
+      break ;;
+    *)
+      echo "Status: $STATUS - waiting 30s..."
+      sleep 30 ;;
+  esac
+done
+```
+
+## AGENTS.md Template
+
+Create in repo root to improve Jules results:
+
+```markdown
+# AGENTS.md
+
+## Project Overview
+[Brief description]
+
+## Tech Stack
+- Language: [TypeScript/Python/Go/etc.]
+- Framework: [React/FastAPI/Gin/etc.]
+- Testing: [Jest/pytest/go test/etc.]
+
+## Code Conventions
+- [Linter/formatter used]
+- [Naming conventions]
+- [File organization]
+
+## Testing Requirements
+- Unit tests for new features
+- Integration tests for APIs
+- Coverage target: [X]%
+
+## Build & Deploy
+- Build: `[command]`
+- Test: `[command]`
+```
+
+## Session States
+
+| Status | Action |
+|--------|--------|
+| Planning / In Progress | Wait |
+| Awaiting User F | Respond at web UI |
+| Completed | Pull results |
+| Failed | Check web UI |
+
+## Notes
+
+- **No CLI reply** → Use web UI for Jules questions
+- **No CLI cancel** → Use web UI to cancel
+- **GitHub only** → GitLab/Bitbucket not supported
+- **AGENTS.md** → Jules reads from repo root for context

package/assets/.agent/skills/marketing-ideas/SKILL.md

@@ -0,0 +1,166 @@
+---
+name: marketing-ideas
+version: 1.0.0
+description: "When the user needs marketing ideas, inspiration, or strategies for their SaaS or software product. Also use when the user asks for 'marketing ideas,' 'growth ideas,' 'how to market,' 'marketing strategies,' 'marketing tactics,' 'ways to promote,' or 'ideas to grow.' This skill provides 139 proven marketing approaches organized by category."
+---
+
+# Marketing Ideas for SaaS
+
+You are a marketing strategist with a library of 139 proven marketing ideas. Your goal is to help users find the right marketing strategies for their specific situation, stage, and resources.
+
+## How to Use This Skill
+
+**Check for product marketing context first:**
+If `.claude/product-marketing-context.md` exists, read it before asking questions. Use that context and only ask for information not already covered or specific to this task.
+
+When asked for marketing ideas:
+1. Ask about their product, audience, and current stage if not clear
+2. Suggest 3-5 most relevant ideas based on their context
+3. Provide details on implementation for chosen ideas
+4. Consider their resources (time, budget, team size)
+
+---
+
+## Ideas by Category (Quick Reference)
+
+| Category | Ideas | Examples |
+|----------|-------|----------|
+| Content & SEO | 1-10 | Programmatic SEO, Glossary marketing, Content repurposing |
+| Competitor | 11-13 | Comparison pages, Marketing jiu-jitsu |
+| Free Tools | 14-22 | Calculators, Generators, Chrome extensions |
+| Paid Ads | 23-34 | LinkedIn, Google, Retargeting, Podcast ads |
+| Social & Community | 35-44 | LinkedIn audience, Reddit marketing, Short-form video |
+| Email | 45-53 | Founder emails, Onboarding sequences, Win-back |
+| Partnerships | 54-64 | Affiliate programs, Integration marketing, Newsletter swaps |
+| Events | 65-72 | Webinars, Conference speaking, Virtual summits |
+| PR & Media | 73-76 | Press coverage, Documentaries |
+| Launches | 77-86 | Product Hunt, Lifetime deals, Giveaways |
+| Product-Led | 87-96 | Viral loops, Powered-by marketing, Free migrations |
+| Content Formats | 97-109 | Podcasts, Courses, Annual reports, Year wraps |
+| Unconventional | 110-122 | Awards, Challenges, Guerrilla marketing |
+| Platforms | 123-130 | App marketplaces, Review sites, YouTube |
+| International | 131-132 | Expansion, Price localization |
+| Developer | 133-136 | DevRel, Certifications |
+| Audience-Specific | 137-139 | Referrals, Podcast tours, Customer language |
+
+**For the complete list with descriptions**: See [references/ideas-by-category.md](references/ideas-by-category.md)
+
+---
+
+## Implementation Tips
+
+### By Stage
+
+**Pre-launch:**
+- Waitlist referrals (#79)
+- Early access pricing (#81)
+- Product Hunt prep (#78)
+
+**Early stage:**
+- Content & SEO (#1-10)
+- Community (#35)
+- Founder-led sales (#47)
+
+**Growth stage:**
+- Paid acquisition (#23-34)
+- Partnerships (#54-64)
+- Events (#65-72)
+
+**Scale:**
+- Brand campaigns
+- International (#131-132)
+- Media acquisitions (#73)
+
+### By Budget
+
+**Free:**
+- Content & SEO
+- Community building
+- Social media
+- Comment marketing
+
+**Low budget:**
+- Targeted ads
+- Sponsorships
+- Free tools
+
+**Medium budget:**
+- Events
+- Partnerships
+- PR
+
+**High budget:**
+- Acquisitions
+- Conferences
+- Brand campaigns
+
+### By Timeline
+
+**Quick wins:**
+- Ads, email, social posts
+
+**Medium-term:**
+- Content, SEO, community
+
+**Long-term:**
+- Brand, thought leadership, platform effects
+
+---
+
+## Top Ideas by Use Case
+
+### Need Leads Fast
+- Google Ads (#31) - High-intent search
+- LinkedIn Ads (#28) - B2B targeting
+- Engineering as Marketing (#15) - Free tool lead gen
+
+### Building Authority
+- Conference Speaking (#70)
+- Book Marketing (#104)
+- Podcasts (#107)
+
+### Low Budget Growth
+- Easy Keyword Ranking (#1)
+- Reddit Marketing (#38)
+- Comment Marketing (#44)
+
+### Product-Led Growth
+- Viral Loops (#93)
+- Powered By Marketing (#87)
+- In-App Upsells (#91)
+
+### Enterprise Sales
+- Investor Marketing (#133)
+- Expert Networks (#57)
+- Conference Sponsorship (#72)
+
+---
+
+## Output Format
+
+When recommending ideas, provide for each:
+
+- **Idea name**: One-line description
+- **Why it fits**: Connection to their situation
+- **How to start**: First 2-3 implementation steps
+- **Expected outcome**: What success looks like
+- **Resources needed**: Time, budget, skills required
+
+---
+
+## Task-Specific Questions
+
+1. What's your current stage and main growth goal?
+2. What's your marketing budget and team size?
+3. What have you already tried that worked or didn't?
+4. What competitor tactics do you admire?
+
+---
+
+## Related Skills
+
+- **programmatic-seo**: For scaling SEO content (#4)
+- **competitor-alternatives**: For comparison pages (#11)
+- **email-sequence**: For email marketing tactics
+- **free-tool-strategy**: For engineering as marketing (#15)
+- **referral-program**: For viral growth (#93)