intelwatch 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,39 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [1.1.0] — 2026-03-02 (in progress)
+
+### Added
+- **discover** — Automatic competitor discovery from a URL (analyzes site, searches similar businesses)
+- **track person** — New tracker type for people and public figures (press + social mentions)
+- Social media monitoring via Brave Search (Twitter/X, Reddit, LinkedIn)
+- Pappers API integration (BYOK) — French company data (SIREN, CA, dirigeants, effectifs)
+
+## [1.0.0] — 2026-03-02
+
+### Added
+- Initial release
+- **track competitor** — Track a competitor website (tech stack, pages, SEO, security, press)
+- **track keyword** — Track a keyword in search engine results (SERP positions)
+- **track brand** — Track brand mentions across press and web
+- **list** — List all active trackers
+- **remove** — Remove a tracker
+- **check** — Fetch fresh snapshots for all or specific trackers
+- **digest** — Summary of recent changes across all trackers
+- **diff** — Compare two snapshots of the same tracker
+- **report** — Generate a full intelligence report in markdown
+- **history** — View snapshot history for a tracker
+- **compare** — Side-by-side comparison of multiple competitors
+- **notify** — Send alerts when significant changes are detected
+- **ai-summary** — AI-powered intelligence brief from tracker data (BYOK)
+- **pitch** — AI-generated competitive sales pitch against a tracked competitor (BYOK)
+- Deep site analysis: tech detection, page crawl, key pages, job listings, social profiles
+- Press & reputation monitoring via Brave Search API (with Google scraping fallback)
+- Sentiment analysis (French + English) for press mentions
+- BYOK AI: supports OpenAI (`gpt-4o-mini` default) and Anthropic (`claude-3-5-haiku-latest`)
+- Cost tracking for AI operations
+
+### Fixed
+- Array headers bug in tech-detect.js
+- Anthropic model name updated to `claude-3-5-haiku-latest`

package/README.md

@@ -0,0 +1,175 @@
+# intelwatch
+
+> Competitive intelligence from the terminal. Track competitors, keywords, and brand mentions — no expensive SaaS required.
+
+## Install
+
+```bash
+npm install -g intelwatch
+# or from source:
+npm link
+```
+
+**Requirements:** Node.js >=18
+
+## Quick Start
+
+```bash
+# Add trackers
+intelwatch track competitor https://competitor.com --name "Acme Corp"
+intelwatch track keyword "audit SEO"
+intelwatch track brand "Recognity"
+
+# Run checks
+intelwatch check
+
+# See what changed
+intelwatch digest
+
+# Full report
+intelwatch report --format html
+```
+
+## Commands
+
+### Tracker Management
+
+#### `intelwatch track competitor <url> [--name <alias>]`
+Tracks a competitor website. Captures:
+- Pages found (via link extraction)
+- Pricing page content and price changes
+- Technology stack (35+ technologies detected)
+- Open job positions (/careers, /jobs)
+- Social links
+- Meta title/description changes on key pages
+
+```bash
+intelwatch track competitor https://acme.com --name "Acme"
+intelwatch track competitor https://rival.io
+```
+
+#### `intelwatch track keyword <keyword> [--engine google]`
+Tracks Google SERP rankings for a keyword. Records top 20 results, detects position changes, new entrants/exits, and featured snippet holders.
+
+```bash
+intelwatch track keyword "project management software"
+intelwatch track keyword "audit SEO" --engine google
+```
+
+#### `intelwatch track brand <name>`
+Tracks brand mentions across Google News and recent web results. Detects sentiment (positive/negative) and categorizes mentions (press, blog, forum, social, review).
+
+```bash
+intelwatch track brand "Recognity"
+intelwatch track brand "My Company Name"
+```
+
+### Listing & Removing
+
+```bash
+intelwatch list                    # List all trackers
+intelwatch remove <tracker-id>     # Remove a tracker
+```
+
+### Checking & Diffs
+
+```bash
+intelwatch check                   # Check all trackers
+intelwatch check --tracker acme-com  # Check one tracker
+
+intelwatch diff acme-com           # Compare last 2 snapshots
+intelwatch diff acme-com --days 7  # Compare with 7 days ago
+```
+
+### Reports
+
+```bash
+intelwatch digest                        # Quick summary table
+intelwatch report                        # Markdown report (stdout)
+intelwatch report --format html          # HTML report (saved to ~/.intelwatch/reports/)
+intelwatch report --format json          # JSON report (stdout)
+intelwatch report --format md --output ./weekly.md  # Custom output file
+```
+
+### History & Comparison
+
+```bash
+intelwatch history acme-com              # Show snapshot history
+intelwatch history acme-com --limit 10  # Last 10 snapshots
+
+intelwatch compare acme-com rival-com    # Side-by-side comparison
+```
+
+### Notifications
+
+```bash
+intelwatch notify --setup    # Interactive setup (Slack, Discord webhook)
+```
+
+Notifications config is stored at `~/.intelwatch/config.yml`:
+
+```yaml
+notifications:
+  webhook: https://hooks.slack.com/services/xxx/yyy/zzz
+  events:
+    - competitor.new_page
+    - competitor.price_change
+    - keyword.position_change
+    - brand.new_mention
+    - brand.negative_mention
+```
+
+## Data Storage
+
+All data is stored locally in `~/.intelwatch/`:
+
+```
+~/.intelwatch/
+├── config.yml           # Notification settings
+├── trackers.json        # Active trackers
+├── snapshots/           # Historical snapshots (JSON)
+└── reports/             # Generated HTML reports
+```
+
+## Technology Detection
+
+Detects 35+ technologies via headers, meta tags, scripts, HTML patterns:
+
+| Category | Technologies |
+|----------|-------------|
+| CMS | WordPress, Drupal, Joomla |
+| E-commerce | Shopify, Magento |
+| Website Builder | Wix, Squarespace, Webflow |
+| JS Framework | React, Vue.js, Angular, Next.js, Nuxt.js, Gatsby, Svelte |
+| JS Library | jQuery |
+| CSS Framework | Bootstrap, Tailwind CSS |
+| Analytics | Google Analytics, Google Tag Manager, Facebook Pixel, Hotjar |
+| CRM/Marketing | HubSpot, Mailchimp, Intercom |
+| CDN/Security | Cloudflare |
+| Web Server | nginx, Apache |
+| Hosting | Vercel, Netlify |
+| Backend | PHP, Django, Ruby on Rails, Node.js/Express |
+| Payment | Stripe |
+
+## Sentiment Analysis
+
+English and French word lists for positive/negative detection in brand mentions. Categorizes mentions as: press, blog, forum, social, or review.
+
+## Design Principles
+
+- **No external APIs** — everything via respectful web scraping
+- **Respectful scraping** — 1-2s delays, user-agent rotation, retry backoff
+- **Graceful degradation** — saves what it can if a check partially fails
+- **Local-first** — all data stays on your machine
+
+## Tests
+
+```bash
+npm test
+```
+
+40 tests covering storage logic, technology detection, and sentiment analysis.
+
+## License
+
+MIT

package/bin/intelwatch.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+import { program } from '../src/index.js';
+
+program.parseAsync(process.argv).catch(err => {
+  console.error('Fatal error:', err.message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "intelwatch",
+  "version": "1.0.0",
+  "description": "Competitive intelligence CLI — track competitors, keywords, and brand mentions from the terminal",
+  "type": "module",
+  "license": "MIT",
+  "bin": {
+    "intelwatch": "./bin/intelwatch.js"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.js",
+    "start": "node bin/intelwatch.js"
+  },
+  "dependencies": {
+    "axios": "^1.7.9",
+    "chalk": "^5.3.0",
+    "cheerio": "^1.0.0",
+    "cli-table3": "^0.6.5",
+    "commander": "^12.1.0",
+    "inquirer": "^10.2.2",
+    "yaml": "^2.6.1"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "author": "Recognity <anthony@recognity.fr> (https://recognity.fr)",
+  "homepage": "https://recognity.fr",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/recognity/intelwatch.git"
+  },
+  "keywords": [
+    "competitive-intelligence",
+    "osint",
+    "cli",
+    "competitor",
+    "brand-monitoring",
+    "press",
+    "sentiment",
+    "ai",
+    "pappers"
+  ]
+}

package/src/ai/client.js

@@ -0,0 +1,130 @@
+import { loadConfig } from '../config.js';
+
+/**
+ * Resolve AI provider config: env vars take priority, then config file.
+ * Returns null if no key is configured.
+ */
+export function getAIConfig() {
+  const envOpenAI = process.env.OPENAI_API_KEY;
+  const envAnthropic = process.env.ANTHROPIC_API_KEY;
+
+  if (envOpenAI) {
+    return { provider: 'openai', apiKey: envOpenAI, model: 'gpt-4o-mini' };
+  }
+  if (envAnthropic) {
+    return { provider: 'anthropic', apiKey: envAnthropic, model: 'claude-haiku-4-5-20251001' };
+  }
+
+  // Fall back to ~/.intelwatch/config.yml ai section
+  try {
+    const config = loadConfig();
+    const ai = config.ai;
+    if (ai?.api_key) {
+      const provider = ai.provider || 'openai';
+      const defaultModel = provider === 'anthropic' ? 'claude-haiku-4-5-20251001' : 'gpt-4o-mini';
+      return {
+        provider,
+        apiKey: ai.api_key,
+        model: ai.model || defaultModel,
+      };
+    }
+  } catch {
+    // config load failure — no AI
+  }
+
+  return null;
+}
+
+export function hasAIKey() {
+  return getAIConfig() !== null;
+}
+
+/**
+ * Call the AI with a system + user prompt. Returns the response text.
+ * Throws on API errors.
+ */
+export async function callAI(systemPrompt, userPrompt, options = {}) {
+  const aiConfig = getAIConfig();
+  if (!aiConfig) {
+    throw new Error(
+      'No AI API key configured. Set OPENAI_API_KEY or ANTHROPIC_API_KEY, ' +
+      'or add ai.api_key to ~/.intelwatch/config.yml'
+    );
+  }
+
+  const { provider, apiKey, model } = aiConfig;
+  const maxTokens = options.maxTokens || 1000;
+
+  if (provider === 'anthropic') {
+    return callAnthropic(apiKey, model, systemPrompt, userPrompt, maxTokens);
+  }
+  return callOpenAI(apiKey, model, systemPrompt, userPrompt, maxTokens);
+}
+
+async function callOpenAI(apiKey, model, systemPrompt, userPrompt, maxTokens) {
+  const res = await fetch('https://api.openai.com/v1/chat/completions', {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      model,
+      max_tokens: maxTokens,
+      messages: [
+        { role: 'system', content: systemPrompt },
+        { role: 'user', content: userPrompt },
+      ],
+    }),
+  });
+
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`OpenAI API ${res.status}: ${body.slice(0, 200)}`);
+  }
+
+  const data = await res.json();
+  return data.choices[0].message.content.trim();
+}
+
+async function callAnthropic(apiKey, model, systemPrompt, userPrompt, maxTokens) {
+  const res = await fetch('https://api.anthropic.com/v1/messages', {
+    method: 'POST',
+    headers: {
+      'x-api-key': apiKey,
+      'anthropic-version': '2023-06-01',
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      model,
+      max_tokens: maxTokens,
+      system: systemPrompt,
+      messages: [{ role: 'user', content: userPrompt }],
+    }),
+  });
+
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Anthropic API ${res.status}: ${body.slice(0, 200)}`);
+  }
+
+  const data = await res.json();
+  return data.content[0].text.trim();
+}
+
+/**
+ * Rough cost estimate for display (assumes 4 chars ≈ 1 token).
+ */
+export function estimateCost(inputChars, outputChars, provider = 'openai') {
+  const inputTokens = Math.ceil(inputChars / 4);
+  const outputTokens = Math.ceil(outputChars / 4);
+
+  // gpt-4o-mini: $0.15/1M in, $0.60/1M out
+  // claude-haiku: $0.25/1M in, $1.25/1M out
+  const rates = provider === 'anthropic'
+    ? { in: 0.25 / 1_000_000, out: 1.25 / 1_000_000 }
+    : { in: 0.15 / 1_000_000, out: 0.60 / 1_000_000 };
+
+  const cost = inputTokens * rates.in + outputTokens * rates.out;
+  return { inputTokens, outputTokens, cost: cost.toFixed(5) };
+}

package/src/commands/ai-summary.js

@@ -0,0 +1,147 @@
+import chalk from 'chalk';
+import { loadTrackers, getTracker, listSnapshots, loadSnapshot } from '../storage.js';
+import { diffCompetitorSnapshots } from '../trackers/competitor.js';
+import { header, section, error, warn } from '../utils/display.js';
+import { callAI, hasAIKey, getAIConfig } from '../ai/client.js';
+
+export async function runAISummary(options = {}) {
+  if (!hasAIKey()) {
+    error('No AI API key configured.');
+    console.log(chalk.gray('Set OPENAI_API_KEY or ANTHROPIC_API_KEY env var, or add to ~/.intelwatch/config.yml:'));
+    console.log(chalk.gray('  ai:\n    api_key: sk-xxx\n    provider: openai  # or anthropic'));
+    process.exit(1);
+  }
+
+  let trackers;
+  if (options.tracker) {
+    const t = getTracker(options.tracker);
+    if (!t) {
+      error(`Tracker not found: ${options.tracker}`);
+      process.exit(1);
+    }
+    trackers = [t];
+  } else {
+    trackers = loadTrackers().filter(t => t.type === 'competitor');
+  }
+
+  if (trackers.length === 0) {
+    warn('No competitor trackers found. Use `intelwatch track competitor <url>` to add one.');
+    return;
+  }
+
+  const aiConfig = getAIConfig();
+  const dateStr = new Date().toLocaleDateString('en-US', { month: 'long', day: 'numeric', year: 'numeric' });
+
+  header(`📊 Weekly Intelligence Brief — ${dateStr}`);
+  console.log(chalk.gray(`Provider: ${aiConfig.provider} / ${aiConfig.model}\n`));
+
+  for (const tracker of trackers) {
+    const snapshots = listSnapshots(tracker.id);
+    if (snapshots.length === 0) {
+      console.log(chalk.yellow(`⚠ ${tracker.name || tracker.url}: No snapshots yet. Run \`intelwatch check\` first.\n`));
+      continue;
+    }
+
+    const latest = loadSnapshot(snapshots[snapshots.length - 1].filepath);
+    const prev = snapshots.length > 1 ? loadSnapshot(snapshots[snapshots.length - 2].filepath) : null;
+    const changes = diffCompetitorSnapshots(prev, latest);
+
+    const name = tracker.name || tracker.url;
+    section(`${name}:`);
+
+    try {
+      const brief = await generateCompetitorBrief(tracker, latest, changes);
+      console.log('\n' + brief + '\n');
+    } catch (err) {
+      console.log(chalk.red(`  AI error: ${err.message}\n`));
+    }
+  }
+}
+
+async function generateCompetitorBrief(tracker, snapshot, changes) {
+  const name = tracker.name || tracker.url;
+
+  const systemPrompt =
+    'You are a competitive intelligence analyst. Write concise, actionable intelligence briefs. ' +
+    'Be specific and data-driven, not vague. Write in plain English prose (no bullet lists). ' +
+    'Keep the analysis to 2-4 sentences, then add one Recommendation sentence.';
+
+  const context = buildSnapshotContext(snapshot, changes);
+
+  const userPrompt =
+    `Write an intelligence brief for competitor: ${name}\n\n` +
+    `Data:\n${context}\n\n` +
+    `Format exactly:\n` +
+    `${name} ([domain]):\n` +
+    `[2-4 sentence narrative covering their current state, recent activity, and notable signals. ` +
+    `Reference specific data points — press headlines, tech stack issues, job growth, ratings.]\n\n` +
+    `Recommendation: [1 sentence actionable advice for competing against them right now.]`;
+
+  return await callAI(systemPrompt, userPrompt, { maxTokens: 450 });
+}
+
+function buildSnapshotContext(snap, changes) {
+  const lines = [];
+
+  lines.push(`URL: ${snap.url}`);
+  lines.push(`Last checked: ${snap.checkedAt}`);
+  lines.push(`Pages found: ${snap.pageCount || 0}`);
+
+  if (snap.techStack?.length) {
+    lines.push(`Tech stack: ${snap.techStack.map(t => t.name).join(', ')}`);
+  }
+
+  if (snap.jobs?.estimatedOpenings) {
+    lines.push(`Open jobs: ~${snap.jobs.estimatedOpenings}`);
+  }
+
+  if (snap.pricing?.prices?.length) {
+    lines.push(`Pricing: ${snap.pricing.prices.slice(0, 5).join(', ')}`);
+  }
+
+  if (snap.performance) {
+    const p = snap.performance;
+    lines.push(`Performance: load ${p.loadTime}ms, TTFB ${p.ttfb}ms`);
+  }
+
+  if (snap.security) {
+    const s = snap.security;
+    const issues = [];
+    if (!s.hsts) issues.push('no HSTS');
+    if (!s.httpsRedirect) issues.push('no HTTPS redirect');
+    if (issues.length) lines.push(`Security issues: ${issues.join(', ')}`);
+  }
+
+  if (snap.seoSignals) {
+    const seo = snap.seoSignals;
+    const signals = [];
+    if (seo.missingAlt > 0) signals.push(`${seo.missingAlt} images without alt`);
+    if (seo.htmlSize) signals.push(`${Math.round(seo.htmlSize / 1024)}KB uncompressed HTML`);
+    if (seo.brokenLinks > 0) signals.push(`${seo.brokenLinks} broken links`);
+    if (signals.length) lines.push(`SEO signals: ${signals.join(', ')}`);
+  }
+
+  if (snap.press?.articles?.length) {
+    const p = snap.press;
+    lines.push(
+      `Press mentions: ${p.totalCount} total ` +
+      `(${p.sentimentBreakdown?.positive || 0} positive, ${p.sentimentBreakdown?.negative || 0} negative)`
+    );
+    const headlines = p.articles.slice(0, 3).map(a => `"${a.title}"`).join('; ');
+    lines.push(`Recent headlines: ${headlines}`);
+  }
+
+  if (snap.reputation?.platforms?.length) {
+    const ratings = snap.reputation.platforms.map(p => `${p.platform}: ${p.rating}/5`).join(', ');
+    lines.push(`Ratings: ${ratings}`);
+  }
+
+  if (changes.length > 0) {
+    const changeSummary = changes.slice(0, 8).map(c => `  ${c.type}: ${c.field} — ${c.value}`).join('\n');
+    lines.push(`\nRecent changes:\n${changeSummary}`);
+  } else {
+    lines.push('Recent changes: none detected');
+  }
+
+  return lines.join('\n');
+}