competitive-ops

v1.0.0

AI competitive intelligence pipeline -- analyze competitors, generate reports, track changes

0· 80· 1 versions· 0 current· 0 all-time· Updated 5h ago· MIT-0

Security Scans

VirusTotalBenign ClawScanSuspicious Static analysisBenign

Install

openclaw skills install competitive-ops

Competitive-Ops -- Router

Mode Routing

Determine the mode from {{mode}}:

Input	Mode
(empty / no args)	`discovery` -- Show command menu
`setup`	`setup` -- Install dependencies and configure system
`add <company>`	`add` -- Add competitor to tracking
`analyze <company> [html]`	`analyze` -- Full analysis with SWOT + report (add `html` for HTML output)
`compare <A> vs <B> [html]`	`compare` -- Side-by-side comparison (add `html` for HTML output)
`update <company>`	`update` -- Check for changes
`pricing <company> [html]`	`pricing` -- Pricing research (add `html` for HTML output)
`pricing-deep-dive <company>`	`pricing-deep-dive` -- Deep pricing analysis with value scoring
`batch`	`batch` -- Batch processing
`report [html]`	`report` -- Generate consolidated report (add `html` for HTML output)
`track`	`track` -- View tracking dashboard
`monitor [interval]`	`monitor` -- Set up scheduled monitoring (default: weekly)
`pdf [report]`	`pdf` -- Export report to PDF
`png [report]`	`png` -- Export report to PNG image

Discovery Mode (no arguments)

Show this menu:

competitive-ops -- Competitive Intelligence Command Center

Available commands:
  /competitive-ops add <company>      → Add competitor to tracking
  /competitive-ops analyze <company>  → Full analysis: SWOT + scoring + HTML report
  /competitive-ops compare <A> vs <B> → Side-by-side feature matrix
  /competitive-ops update <company>   → Check for changes since last analysis
  /competitive-ops pricing <company> → Pricing research with change detection
  /competitive-ops pricing-deep-dive <company> → Deep pricing analysis with value scoring
  /competitive-ops batch              → Batch process multiple competitors
  /competitive-ops report             → Generate consolidated report
  /competitive-ops track             → View tracking dashboard
  /competitive-ops monitor [daily|weekly|monthly] → Set up scheduled monitoring
  /competitive-ops pdf [report]      → Export report to PDF
  /competitive-ops png [report]      → Export report to PNG image

First time? Say "setup" to configure your company info.

Setup Mode

If {{mode}} is "setup":

Step 1: Install Dependencies

Check for required tools and install if missing:

Playwright for screenshots (required):
- Run: npx playwright install chromium
- Verify: npx playwright --version
ui-ux-pro-max for HTML reports:
- Install: npx -y uipro-cli init --ai claude (in project directory)
- Skill location: {project}/.claude/skills/ui-ux-pro-max/
- Usage: /skill ui-ux-pro-max
Tavily MCP (optional, for fallback search):
- Correct package name: tavily-mcp (NOT @tavily/tavily-mcp)
- Add with: claude mcp add tavily -- npx -y tavily-mcp
- Set API key: TAVILY_API_KEY=your_key
Python dependencies (required, use virtual environment):
```
python3 -m venv .venv && source .venv/bin/activate && pip install -r requirements.txt
```
- Or directly: pip install -r requirements.txt (in project directory)

Step 2: Configure System

Check if the system is configured:

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 |
|---|---------|------|-------|--------|--------------|-------|

Optional: cv.md and config/profile.yml
- These define your own product for scoring context
- Not required for basic competitive analysis
- If missing, skip and proceed with analysis

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:

Read {{company}} from args
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)
Create initial research structure (snapshot folder)
Output confirmation with tier and initial score placeholder

Search Fallback Order

When researching competitors, use this search order:

web-search → Primary search tool
web-fetch → Fetch specific URLs for detailed info
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:

If web-search returns no results or error → try web-fetch
If web-fetch fails or unavailable → invoke Tavily MCP server
Always log which search method was used in the report metadata

Analyze Mode

When {{mode}} is analyze:

Read {{company}} and optional {{html}} flag from args
Check if competitor exists in data/competitors.md
- If new: Add to data/competitors.md first
- If exists: Note: "ℹ️ New analysis for {company}"
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
Generate SWOT analysis
Score across 6 dimensions
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
```
  This ensures latest/ always reflects the most recent analysis, regardless of date.
If html flag is present in args:
- Read the markdown report
- Use ui-ux-pro-max skill: /skill ui-ux-pro-max
- Generate HTML report with Tailwind dark theme
- Save to data/reports/html/{company}-{date}.html
Update data/competitors.md with new score and date
Output summary with score and confidence
- Include path to HTML report if generated

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

Compare Mode

When {{mode}} is compare:

Parse A vs B and optional {{html}} flag from args
Load both companies' latest reports from data/reports/latest/
Generate feature matrix comparison
Score delta analysis
Save comparison to data/reports/{date}/compare-{A}-vs-{B}-{date}.md
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
Output path to comparison report

Update Mode

When {{mode}} is update:

Read {{company}} from args
Re-run research (following Search Fallback Order):
- Try web-search/web-fetch first
- Fallback to Tavily MCP if unavailable
Load the previous report from data/reports/{company}-{prev-date}.md as baseline
Generate new analysis: SWOT + scores → new data/reports/{company}-{date}.md
Diff analysis: Compare old vs new report, compute score delta per dimension
If score change ≥ 5% on any dimension → alert user with 🔴 flag
Save snapshot to data/snapshots/{company}/{date}.json
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:

Read {{company}} and optional {{html}} flag from args
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
Compare to data/snapshots/pricing/{company}.json
If change detected, alert user with change details
Update data/snapshots/pricing/{company}.json
Save pricing report to data/reports/{date}/pricing-{company}-{date}.md
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
Output pricing table

Pricing Deep Dive Mode

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

Read {{company}} from args
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
Load previous snapshot from data/pricing-snapshots/{company}.json (if exists)

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"]
)

Compute value scores using PricingAnalyzer:

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}")

Detect changes using PricingChangeDetector:

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}")

Save snapshot to data/pricing-snapshots/{company}.json
Generate deep dive report using template:
- Read templates/report/markdown/pricing-deep-dive-template.md
- Fill in all sections: Executive Summary, Value Comparison, Plan Breakdown, Pricing History, Alert Log
- Save to data/reports/{date}/pricing-deep-dive-{company}-{date}.md
Output summary with value scores and any detected changes

Key Features:

Value Score = (Feature Count / Price) * Market Normalization Factor
AI API baseline: $1/1M tokens = score 3.0
SaaS baseline: $10/user/mo = score 3.0
ANY pricing change triggers alert (no threshold)
Stores $/token data in JSON format for programmatic access

Batch Mode

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

When {{mode}} is batch:

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

Check for optional html flag and filters in args (company, date range)
Aggregate all reports in data/reports/
Generate consolidated report in data/reports/{date}/consolidated-{date}.md
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
Output path to report (include HTML path if generated)

ECharts Integration:

Use ECharts 5.x via CDN: https://cdn.jsdelivr.net/npm/echarts@5.4.3/dist/echarts.min.js
Charts should be responsive and dark-themed to match Tailwind dark mode

HTML Template CSS (include in <head>):

<style>
    section { page-break-inside: avoid; break-inside: avoid; }
    div { page-break-inside: avoid; break-inside: avoid; }
    table { page-break-inside: avoid; break-inside: avoid; }
</style>

Every section, inner div, and table should have page-break-inside: avoid to prevent content from splitting across PDF pages.

Chart Layout Guidelines:

Bar chart: Grid left margin ~15% to prevent y-axis label cutoff, height 320px
Radar chart: Legend positioned on right (vertical) to avoid overlap with 7 companies, height 400px
Heatmap: Model names shortened (e.g., "Gemini 3.1 Flash" → "Gemini 3.1") to prevent label overlap, height 400px
Use grid-cols-2 for radar + heatmap side-by-side layout
Include tooltips showing exact values on hover

Monitor Mode

When {{mode}} is monitor:

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

Read optional interval from args (e.g., monitor daily, monitor weekly)
- Default: weekly
- Options: daily, weekly, monthly
Parse companies from data/competitors.md

Set up cron job using /loop:

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

For full batch monitoring:

/loop [interval] /competitive-ops batch

Store schedule in data/.monitor-schedule.json:

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

Output confirmation with schedule details

Available Intervals:

daily -- 57 8 * * * (8:57 AM local, off-minute to avoid load spike)
weekly -- 57 8 * * 1 (Monday 8:57 AM local)
monthly -- 57 8 1 * * (1st of month 8:57 AM local)

Monitoring Scope:

Tier 1 competitors: Weekly update recommended
Tier 2 competitors: Bi-weekly acceptable
Pricing changes: Monthly review

PDF Mode

When {{mode}} is pdf:

Export reports to PDF for external sharing:

Read optional report arg (default: latest consolidated report)
- pdf → export data/reports/html/index.html
- pdf anthropic → export data/reports/html/anthropic-{date}.html
Run PDF export script:
```
node scripts/export_pdf.js data/reports/html/index.html
```
The script uses Playwright to:
- Wait for ECharts to fully render (3 second delay)
- Verify 3 ECharts instances are present
- Generate A4 PDF with header/footer
Save PDF to data/reports/pdf/{date}/{report}-{date}.pdf
Output PDF path and file size

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 <head> of HTML reports:

<style>
    section { page-break-inside: avoid; break-inside: avoid; }
    div { page-break-inside: avoid; break-inside: avoid; }
    table { page-break-inside: avoid; break-inside: avoid; }
</style>

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:

ECharts rendered via Playwright with 3s wait for JS execution
CSS page-break properties prevent section splitting across pages
A4 format with 15mm margins
Dark-themed with printed background colors

PNG Mode

When {{mode}} is png:

Export reports to PNG/JPEG image for visual sharing:

Read optional report arg (default: latest consolidated report)
- png → export data/reports/html/index.html
- png anthropic → export specific company report
Run image export script:
```
node scripts/export_image.js data/reports/html/index.html
```
The script uses Playwright to:
- Wait for ECharts to fully render (3 second delay)
- Verify ECharts instances are present
- Capture viewport screenshot (default 1400x900) or full page
Save image to data/reports/images/{date}/{report}-{date}.png
Output image path, file size, and format

Image Script Options (scripts/export_image.js):

node scripts/export_image.js [html-path] [options]
  -o, --output <path>   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:

High-resolution screenshot with ECharts fully rendered
Dark background preserved (omitBackground: false)
PNG default with JPEG quality option
Viewport or full page capture modes

Track Mode

When {{mode}} is track:

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

Shared Context

All modes have access to:

cv.md -- Your company/product definition
config/profile.yml -- Configuration
config/sources.yml -- Trusted data sources
modes/_shared.md -- Scoring system, archetypes, rules
modes/_profile.md -- Your customizations

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):

🟢 High: 3+ sources agree
🟡 Medium: 2 sources agree
🔴 Low: Conflicting or insufficient data

Archetypes

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

Classify competitors into:

Direct Competitor -- Same product, same market
Indirect Competitor -- Different approach, same need
Emerging Threat -- New technology, new model
Replacement Threat -- Alternative solution
Adjacent Player -- Overlapping users
Reference Model -- Industry benchmark

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:

update mode compares old vs new report scores (default ≥5% triggers alert, customizable)
pricing mode compares historical pricing changes
Auto-saved after each analyze/update

Playwright Usage:

Generates competitor website screenshots for analyze / report mode
Used when visual evidence is needed
Optional feature, does not affect core analysis flow

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:

modes/{mode}.md for mode-specific instructions
modes/_shared.md for system context
modes/_profile.md for user customizations

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.

Version tags

latestvk978n3pb3kpgdbe6dcwdtnq6bx84fzz8