## Competitor Discovery Log

### Primary Keywords Searched
| Keyword | # Results | Competitors Found |
|---------|-----------|-------------------|
| [keyword 1] | [count] | [list] |
| [keyword 2] | [count] | [list] |

### Problem-Solution Searches
| Problem | Search Term | Competitors Found |
|---------|-------------|-------------------|
| [problem 1] | [search] | [list] |
| [problem 2] | [search] | [list] |

### Competitor Categories Identified
- **Direct Competitors**: [Extensions solving same problem]
- **Indirect Competitors**: [Alternative solutions]
- **Adjacent Tools**: [Related but different purpose]

## Feature Comparison Matrix

| Feature | Your Idea | Competitor A | Competitor B | Competitor C |
|---------|-----------|--------------|--------------|--------------|
| Feature 1 | [ ] | [✓] | [✓] | [ ] |
| Feature 2 | [✓] | [ ] | [✓] | [ ] |
| Feature 3 | [✓] | [✓] | [ ] | [ ] |
| Feature 4 | [ ] | [ ] | [ ] | [ ] |
| Feature 5 | [✓] | [✓] | [✓] | [✓] |

Legend: [✓] = Has feature, [ ] = Missing feature

## Gap Analysis Summary

### Market Gaps Identified
| Gap | Urgency | Your Solution |
|-----|---------|---------------|
| [Gap 1] | High/Medium/Low | [How you'll address] |
| [Gap 2] | High/Medium/Low | [How you'll address] |

### Differentiation Opportunities
1. [Opportunity 1]: [Why it's valuable]
2. [Opportunity 2]: [Why it's valuable]
3. [Opportunity 3]: [Why it's valuable]

## Pricing Analysis

### Competitor Pricing Models

| Extension | Free Tier | Paid Tier | Price Point | Payment Method |
|-----------|-----------|-----------|-------------|----------------|
| [Name] | [details] | [details] | $[X]/month | External/Stripe |
| [Name] | [details] | [details] | $[X] one-time | - |

### Pricing Insights
- Average price point in market: $[X]
- Common pricing strategies: [list]
- Opportunities for better pricing: [list]

## Review Analysis Template

### Positive Themes (What's Working)
| Theme | Occurrences | Insight |
|-------|-------------|---------|
| [Theme 1] | [count] | [What this tells us] |
| [Theme 2] | [count] | [What this tells us] |

### Negative Themes (Pain Points)
| Theme | Occurrences | Opportunity |
|-------|-------------|-------------|
| [Theme 1] | [count] | [How you can solve it] |
| [Theme 2] | [count] | [How you can solve it] |

### Feature Requests
| Request | Occurrences | Priority |
|---------|-------------|----------|
| [Request 1] | [count] | High/Medium/Low |
| [Request 2] | [count] | High/Medium/Low |

## Market Gap Analysis

### User Jobs-to-be-Done
| Job | Current Solutions | Pain Level | Gap Opportunity |
|-----|-------------------|-------------|-----------------|
| [Job 1] | [List solutions] | 1-10 | [High/Medium/Low] |
| [Job 2] | [List solutions] | 1-10 | [High/Medium/Low] |

### High-Opportunity Gaps
1. **[Gap 1]**: [Description] - [Why it matters]
2. **[Gap 2]**: [Description] - [Why it matters]
3. **[Gap 3]**: [Description] - [Why it matters]

## Differentiation Strategy

### Primary Differentiation: [Your key differentiator]

### Supporting Differentiators
| Differentiator | Priority | Implementation |
|----------------|----------|----------------|
| [Feature 1] | High | [How you'll do it] |
| [Feature 2] | Medium | [How you'll do it] |

### Competitive Positioning
- **Target User**: [Who you're building for]
- **Key Message**: [Your positioning statement]
- **Why Choose You**: [Top 3 reasons]

### Moat (Defensibility)
1. [What makes it hard for others to copy]
2. [Your unique assets/relationships]
3. [Network effects or integrations]

// competitor-tracker.ts
interface CompetitorEntry {
  name: string;
  url: string;
  lastUpdate: string;
  version: string;
  features: string[];
  notes: string;
}

const competitors: CompetitorEntry[] = [
  {
    name: "Competitor A",
    url: "https://chrome.google.com/webstore/detail/...",
    lastUpdate: "",
    version: "",
    features: [],
    notes: ""
  }
];

// Check for updates weekly
async function checkForUpdates() {
  for (const competitor of competitors) {
    const storeData = await fetchCWSData(competitor.url);
    if (storeData.version !== competitor.version) {
      console.log(`${competitor.name} updated: ${competitor.version} -> ${storeData.version}`);
      // Send notification, log change, etc.
    }
  }
}

## Competitor Update Response

### What Changed
- [Update description]

### Impact Assessment
- **Threat Level**: High/Medium/Low
- **Affected Users**: [Who it impacts]
- **Your Response Needed**: Yes/No

### Response Options
1. [Option 1]: [Description]
2. [Option 2]: [Description]

### Decision
- [Selected response]
- [Timeline]

// detect-competitor-features.ts
interface CompetitorFeature {
  name: string;
  category: string;
  implemented: boolean;
}

interface CompetitorAnalysis {
  competitorName: string;
  url: string;
  features: CompetitorFeature[];
  rating: number;
  reviewCount: number;
}

// Analyze competitor from CWS listing
async function analyzeCompetitor(url: string): Promise<CompetitorAnalysis> {
  const html = await fetch(url).then(r => r.text());
  
  // Extract key data from CWS page
  const name = extractName(html);
  const rating = extractRating(html);
  const description = extractDescription(html);
  
  return {
    competitorName: name,
    url,
    features: extractFeatures(description),
    rating,
    reviewCount: extractReviewCount(html)
  };
}

// Feature keywords to search for
const FEATURE_KEYWORDS = {
  'offline': ['offline', 'no internet', 'local'],
  'sync': ['sync', 'cloud', 'cross-device'],
  'automation': ['automate', 'workflow', 'schedule'],
  'export': ['export', 'download', 'backup'],
  'integration': ['integrate', 'connect', 'api']
};

function extractFeatures(description: string): CompetitorFeature[] {
  const features: CompetitorFeature[] = [];
  const lowerDesc = description.toLowerCase();
  
  for (const [category, keywords] of Object.entries(FEATURE_KEYWORDS)) {
    const hasFeature = keywords.some(kw => lowerDesc.includes(kw));
    features.push({ name: category, category, implemented: hasFeature });
  }
  
  return features;
}

// schedule-competitor-check.ts
import { createStorage } from '@theluckystrike/webext-storage';

const competitorStorage = createStorage({
  competitors: 'array',
  lastCheck: 'number'
}, 'local');

const CHECK_INTERVAL_HOURS = 24;

export async function scheduleCompetitorCheck() {
  const lastCheck = await competitorStorage.get('lastCheck');
  const now = Date.now();
  
  if (!lastCheck || now - lastCheck > CHECK_INTERVAL_HOURS * 3600000) {
    await checkCompetitors();
    await competitorStorage.set('lastCheck', now);
  }
}

async function checkCompetitors() {
  const competitors = await competitorStorage.get('competitors');
  
  for (const competitor of competitors) {
    try {
      const currentData = await fetchCWSData(competitor.url);
      
      if (currentData.version !== competitor.version) {
        await notifyCompetitorUpdate(competitor, currentData);
      }
    } catch (error) {
      console.error(`Failed to check ${competitor.name}:`, error);
    }
  }
}

async function notifyCompetitorUpdate(competitor: any, newData: any) {
  // Store update history
  const history = await competitorStorage.get('updateHistory') || [];
  history.push({
    name: competitor.name,
    oldVersion: competitor.version,
    newVersion: newData.version,
    timestamp: Date.now()
  });
  
  await competitorStorage.set('updateHistory', history);
  await competitorStorage.set('competitors', 
    competitors.map((c: any) => 
      c.name === competitor.name ? { ...c, ...newData } : c
    )
  );
}