competitive-ops

Step 2: Configure System

Check if the system is configured:

1. Required: Check if data/competitors.md exists - If missing, create from template or empty file with headers:

     # Competitors Tracker
     | # | Company | Tier | Score | Status | Last Updated | Notes |
     |---|---------|------|-------|--------|--------------|-------|
     

Step 3: Summary

Output setup status:

✅ competitive-ops v2 ready!
Installed:
  ✅ Playwright (screenshots)
  ✅ ui-ux-pro-max (HTML reports: npx -y uipro-cli init --ai claude)
  ✅ Tavily MCP (fallback search)
  ✅ Python dependencies
Required:
  ✅ data/competitors.md
Optional (for scoring context):
  [?] cv.md (your product)
  [?] config/profile.yml

Add Mode

When {{mode}} is add:

1. Read {{company}} from args 2. Check if competitor already exists in data/competitors.md - If exists: Output warning: "⚠️ {company} already in tracker (score: X)" and skip - If new: Add entry with tier assignment (Tier 1/2/3) 3. Create initial research structure (snapshot folder) 4. Output confirmation with tier and initial score placeholder

Search Fallback Order

When researching competitors, use this search order:

1. web-search → Primary search tool 2. web-fetch → Fetch specific URLs for detailed info 3. Tavily MCP server → Fallback when native tools unavailable

Tavily MCP Usage:

Use Tavily MCP server for competitive intelligence search:
tavily-search for company overview, products, pricing
tavily-search with topic="business" for business intelligence
tavily-search with topic="news" for recent news

Fallback Detection:

Analyze Mode

When {{mode}} is analyze:

1. Read {{company}} and optional {{html}} flag from args 2. Check if competitor exists in data/competitors.md - If new: Add to data/competitors.md first - If exists: Note: "ℹ️ New analysis for {company}" 3. Run research (following fallback order above): - Try web-search first for company info - Try web-fetch for specific URLs - Fallback to Tavily MCP server if needed - Cross-validate from multiple sources 4. Generate SWOT analysis 5. Score across 6 dimensions 6. Generate report in data/reports/{date}/{company}-{date}.md - Always creates new file (never overwrites) - Update symlink to point to the new report:

     rm -f data/reports/latest/{company}.md
     ln -s ../{date}/{company}-{date}.md data/reports/latest/{company}.md
     

Note: For incremental change tracking, use update mode instead. analyze always creates fresh analysis.

Compare Mode

When {{mode}} is compare:

1. Parse A vs B and optional {{html}} flag from args 2. Load both companies' latest reports from data/reports/latest/ 3. Generate feature matrix comparison 4. Score delta analysis 5. Save comparison to data/reports/{date}/compare-{A}-vs-{B}-{date}.md 6. If html flag is present: - Read the comparison markdown - Use ui-ux-pro-max skill: /skill ui-ux-pro-max - Generate HTML report with Tailwind dark theme - Save to data/reports/html/compare-{A}-vs-{B}-{date}.html 7. Output path to comparison report

Update Mode

When {{mode}} is update:

1. Read {{company}} from args 2. Re-run research (following Search Fallback Order): - Try web-search/web-fetch first - Fallback to Tavily MCP if unavailable 3. Load the previous report from data/reports/{company}-{prev-date}.md as baseline 4. Generate new analysis: SWOT + scores → new data/reports/{company}-{date}.md 5. Diff analysis: Compare old vs new report, compute score delta per dimension 6. If score change ≥ 5% on any dimension → alert user with 🔴 flag 7. Save snapshot to data/snapshots/{company}/{date}.json 8. Output: - New report path - Score delta table (before → after per dimension) - Changelog: what changed (new features, pricing changes, etc.)

Pricing Mode

When {{mode}} is pricing:

1. Read {{company}} and optional {{html}} flag from args 2. Research pricing from (following fallback order): - Company website (try web-fetch first) - G2, Capterra, Glassdoor - News articles - Tavily MCP server as fallback for business intelligence 3. Compare to data/snapshots/pricing/{company}.json 4. If change detected, alert user with change details 5. Update data/snapshots/pricing/{company}.json 6. Save pricing report to data/reports/{date}/pricing-{company}-{date}.md 7. If html flag is present: - Read the pricing report markdown - Use ui-ux-pro-max skill: /skill ui-ux-pro-max - Generate HTML report with Tailwind dark theme - Save to data/reports/html/pricing-{company}-{date}.html 8. Output pricing table

Pricing Deep Dive Mode

When {{mode}} is pricing-deep-dive:

1. Read {{company}} from args 2. Research comprehensive pricing data from (following fallback order): - Company website (web-fetch first for pricing pages) - G2, Capterra, TrustRadius for verified pricing - News articles mentioning pricing changes - Tavily MCP server for business intelligence 3. Load previous snapshot from data/pricing-snapshots/{company}.json (if exists) 4. Build PricingSnapshot using scripts/pricing_analyzer.py:

   from scripts.pricing_analyzer import PricingSnapshot, Plan, PricingAnalyzer, save_snapshot
   snapshot = PricingSnapshot(
       company="CompanyName",
       last_updated="2026-04-07",
       plans=[
           Plan(
               name="Pro",
               type="subscription",
               price=20.0,
               period="monthly",
               users=10,
               api_access=True,
               price_per_1m_input=1.0,
               price_per_1m_output=3.0,
               features=["API Access", "Advanced Analytics", "Priority Support"]
           )
       ],
       enterprise=True,
       free_tier=True,
       sources=["https://example.com/pricing"]
   )
   

   analyzer = PricingAnalyzer(subscription_baseline=10.0, api_baseline=1.0)
   for plan in snapshot.plans:
       score = analyzer.compute_value_score(plan)
       print(f"{plan.name}: {score:.2f}")
   

   from scripts.pricing_analyzer import PricingChangeDetector
   detector = PricingChangeDetector(any_change=True)  # Alert on ANY change
   if old_snapshot:
       changes = detector.detect_change(old_snapshot, new_snapshot)
       for change in changes:
           print(f"ALERT: {change.description}")
   

Key Features:

Batch Mode

Multi-Agent Parallel Implementation (see modes/batch.md for full details)

When {{mode}} is batch:

1. Read optional tier filter from args (e.g., batch tier 1 → only Tier 1) 2. Check for data/batch-queue.md file with list of companies 3. If file doesn't exist, prompt user to create it 4. Filter by tier if specified (e.g., tier 1 → only ## Tier 1 section) 5. Create agent team using TeamCreate 6. Spawn parallel agents - one per company (max 5 concurrent) 7. Each agent runs full analyze workflow independently 8. Track progress in data/batch-status.json 9. Consolidate results from all agents 10. Output batch summary

Key Feature: Uses Claude Code multi-agent for ~3x speedup

Batch Queue Format

Create data/batch-queue.md:

# Batch Queue
Tier 1 (Direct Competitors)
Anthropic
OpenAI
Google DeepMind
Tier 2 (Indirect Competitors)
Mistral
Cohere
Meta AI
Tier 3 (Emerging)
Character.AI
Inflection

Or use CSV format in data/batch-queue.csv:

company,tier,priority
Anthropic,1,high
OpenAI,1,high
Mistral,2,medium

Report Mode

When {{mode}} is report:

1. Check for optional html flag and filters in args (company, date range) 2. Aggregate all reports in data/reports/ 3. Generate consolidated report in data/reports/{date}/consolidated-{date}.md 4. If html flag is present in args: - Read the consolidated markdown report - Generate HTML with ECharts visualizations: - Score bar chart (ranking by overall score) - Radar chart (6 dimensions across all competitors) - Pricing heatmap (input/output prices by model) - Pricing change detection: - Compare with data/snapshots/pricing/{company}.json - Highlight price changes with 🔴 alert badges - Show delta (e.g., "-67%", "+20%") - Generate HTML report with Tailwind dark theme + ECharts - Save to data/reports/html/index.html 5. Output path to report (include HTML path if generated)

ECharts Integration:

HTML Template CSS (include in ):

Chart Layout Guidelines:

Monitor Mode

When {{mode}} is monitor:

Use /loop skill to set up continuous competitive intelligence monitoring:

1. Read optional interval from args (e.g., monitor daily, monitor weekly) - Default: weekly - Options: daily, weekly, monthly 2. Parse companies from data/competitors.md 3. Set up cron job using /loop:

   /loop [interval] /competitive-ops update [company]
   

   /loop [interval] /competitive-ops batch
   

   {
     "enabled": true,
     "interval": "weekly",
     "last_run": "2026-04-07",
     "next_run": "2026-04-14",
     "companies": ["Anthropic", "OpenAI", "..."]
   }
   

Available Intervals:

Monitoring Scope:

PDF Mode

When {{mode}} is pdf:

Export reports to PDF for external sharing:

1. Read optional report arg (default: latest consolidated report) - pdf → export data/reports/html/index.html - pdf anthropic → export data/reports/html/anthropic-{date}.html 2. Run PDF export script:

   node scripts/export_pdf.js data/reports/html/index.html
   

PDF Script Implementation (scripts/export_pdf.js):

const { chromium } = require('playwright');
// - Launches headless Chromium
// - Sets viewport to 1200x1600 for proper rendering
// - Waits for networkidle + 3s for ECharts
// - Generates A4 PDF with margins and page numbers
// - Adds footer: "Page X of Y | competitive-ops v2 | {date}"

HTML CSS for PDF Page Breaks: Add to of HTML reports:

PDF Output Locations: | Report | PDF Location | |--------|-------------| | Consolidated | data/reports/pdf/{date}/index-{date}.pdf | | Company | data/reports/pdf/{date}/{company}-{date}.pdf | | Comparison | data/reports/pdf/{date}/compare-{A}-vs-{B}-{date}.pdf |

Styling for PDF:

PNG Mode

When {{mode}} is png:

Export reports to PNG/JPEG image for visual sharing:

1. Read optional report arg (default: latest consolidated report) - png → export data/reports/html/index.html - png anthropic → export specific company report 2. Run image export script:

   node scripts/export_image.js data/reports/html/index.html
   

Image Script Options (scripts/export_image.js):

node scripts/export_image.js [html-path] [options]
  -o, --output    Output file path
  -f, --full            Capture full page (not just viewport)
  -j, --jpeg            Export as JPEG (default: PNG)

Image Output Locations: | Report | Image Location | |--------|---------------| | Consolidated | data/reports/images/{date}/index-{date}.png | | Company | data/reports/images/{date}/{company}-{date}.png |

Image Features:

Track Mode

When {{mode}} is track:

1. Read data/competitors.md 2. Display dashboard: - All competitors with scores - Last updated dates - Alert indicators (stale data, significant changes) - Filter by tier, score, status 3. Output formatted table

Shared Context

All modes have access to:

Scoring System

Reference values (customizable in modes/_profile.md or config/profile.yml):

| Dimension | Default Weight | |-----------|---------------| | Product Maturity | 20% | | Feature Coverage | 20% | | Pricing | 15% | | Market Presence | 15% | | Growth Trajectory | 10% | | Brand Strength | 10% |

Confidence Levels (customizable):

Archetypes

Reference types (customizable in modes/_profile.md or config/profile.yml):

Classify competitors into:

Output Locations

Standard Structure: All reports are organized by date in data/reports/{date}/, with latest/ containing symlinks only.

| Output | Location | |--------|----------| | Analysis Report | data/reports/{date}/{company}-{date}.md | | Latest Symlink | data/reports/latest/{company}.md → ../{date}/{company}-{date}.md | | Comparison Report | data/reports/{date}/compare-{A}-vs-{B}-{date}.md | | Pricing Report | data/reports/{date}/pricing-{company}-{date}.md | | Pricing Deep Dive Report | data/reports/{date}/pricing-deep-dive-{company}-{date}.md | | Pricing Snapshot (JSON) | data/pricing-snapshots/{company}.json | | Consolidated Report | data/reports/{date}/consolidated-{date}.md | | HTML Report | data/reports/html/{company}-{date}.html | | PDF Report | data/reports/pdf/{date}/{company}-{date}.pdf | | Image (PNG) | data/reports/images/{date}/{company}-{date}.png | | Snapshot (update diff) | data/snapshots/{company}/{date}.json | | Pricing Snapshot | data/snapshots/pricing/{company}.json | | Monitor Schedule | data/.monitor-schedule.json | | Screenshot (Playwright) | data/reports/screenshots/{company}-{date}.png | | Competitor Tracker | data/competitors.md |

Snapshot Usage:

Playwright Usage:

Note: Reports are never overwritten — each run creates a new dated file. Use update mode for incremental change tracking.

Next Steps

After routing, execute the selected mode by reading:

Agent Implementation

For batch mode, use multi-agent architecture:

/competitive-ops batch tier 1
    ↓
TeamCreate: competitive-batch-{timestamp}
    ↓
Agent analyzer-1 → analyze Anthropic (parallel)
Agent analyzer-2 → analyze OpenAI (parallel)
Agent analyzer-3 → analyze Google DeepMind (parallel)
    ↓
Wait for all agents to complete
    ↓
Consolidate results → output batch summary

Each agent executes independently using the analyze workflow.