intelwatch 1.0.0

package/src/commands/check.js

@@ -0,0 +1,267 @@
+import chalk from 'chalk';
+import {
+  loadTrackers, updateTracker, saveSnapshot, loadLatestSnapshot
+} from '../storage.js';
+import { runCompetitorCheck, diffCompetitorSnapshots } from '../trackers/competitor.js';
+import { runKeywordCheck, diffKeywordSnapshots } from '../trackers/keyword.js';
+import { runBrandCheck, diffBrandSnapshots } from '../trackers/brand.js';
+import { runPersonCheck, diffPersonSnapshots } from '../trackers/person.js';
+import { header, section, diffLine, success, warn, error, trackerTypeIcon } from '../utils/display.js';
+
+export async function runCheck(options) {
+  const trackers = loadTrackers();
+
+  if (trackers.length === 0) {
+    warn('No trackers configured. Use `intelwatch track` to add one.');
+    return;
+  }
+
+  const toCheck = options.tracker
+    ? trackers.filter(t => t.id === options.tracker)
+    : trackers;
+
+  if (options.tracker && toCheck.length === 0) {
+    error(`Tracker not found: ${options.tracker}`);
+    process.exit(1);
+  }
+
+  let totalChanges = 0;
+
+  for (const tracker of toCheck) {
+    header(`${trackerTypeIcon(tracker.type)} ${tracker.name || tracker.keyword || tracker.brandName} [${tracker.id}]`);
+
+    try {
+      const prevSnapshot = loadLatestSnapshot(tracker.id);
+
+      let snapshot;
+      let changes = [];
+
+      console.log(chalk.gray(`  Checking ${tracker.url || tracker.keyword || tracker.brandName}...`));
+
+      if (tracker.type === 'competitor') {
+        snapshot = await runCompetitorCheck(tracker);
+        changes = diffCompetitorSnapshots(prevSnapshot, snapshot);
+      } else if (tracker.type === 'keyword') {
+        snapshot = await runKeywordCheck(tracker);
+        changes = diffKeywordSnapshots(prevSnapshot, snapshot);
+      } else if (tracker.type === 'brand') {
+        snapshot = await runBrandCheck(tracker);
+        changes = diffBrandSnapshots(prevSnapshot, snapshot);
+      } else if (tracker.type === 'person') {
+        snapshot = await runPersonCheck(tracker);
+        changes = diffPersonSnapshots(prevSnapshot, snapshot);
+      }
+
+      // Save snapshot
+      snapshot.changes = changes;
+      const filepath = saveSnapshot(tracker.id, snapshot);
+
+      updateTracker(tracker.id, {
+        lastCheckedAt: new Date().toISOString(),
+        lastSnapshotPath: filepath,
+        status: snapshot.error ? 'error' : 'active',
+        checkCount: (tracker.checkCount || 0) + 1,
+      });
+
+      if (snapshot.error) {
+        warn(`  Error: ${snapshot.error}`);
+      } else {
+        success(`  Check complete`);
+      }
+
+      if (changes.length === 0) {
+        console.log(chalk.gray('  No changes detected.'));
+      } else {
+        section('  Changes:');
+        for (const change of changes) {
+          console.log('  ' + diffLine(change.type, change.field, change.value));
+        }
+        totalChanges += changes.length;
+      }
+
+      // Show brief summary for keyword/brand
+      if (tracker.type === 'keyword' && snapshot.results?.length > 0) {
+        section('  Top 5 results:');
+        for (const r of snapshot.results.slice(0, 5)) {
+          const star = r.isFeaturedSnippet ? chalk.yellow(' ⭐') : '';
+          console.log(chalk.gray(`  #${r.position}`), chalk.white(r.domain) + star);
+        }
+      }
+
+      if (tracker.type === 'brand') {
+        console.log(chalk.gray(`  ${snapshot.mentionCount} mentions found`));
+        if (snapshot.socialMentions && Object.keys(snapshot.socialMentions).length > 0) {
+          const socialParts = Object.entries(snapshot.socialMentions)
+            .filter(([, arr]) => arr.length > 0)
+            .map(([platform, arr]) => {
+              const icon = platform === 'twitter' ? 'X' : platform === 'reddit' ? 'Reddit' : 'LinkedIn';
+              return `${icon}(${arr.length})`;
+            });
+          if (socialParts.length > 0) {
+            console.log(chalk.cyan(`  📱 Social: ${socialParts.join(' ')}`));
+          }
+        }
+      }
+
+      if (tracker.type === 'person') {
+        const s = snapshot;
+        const sent = s.sentimentBreakdown || {};
+        const sentStr = `👍${sent.positive || 0} 😐${sent.neutral || 0} 👎${sent.negative || 0}`;
+        console.log(chalk.magenta(`  👤 ${s.personName}: ${s.mentionCount} mentions | ${sentStr}`));
+        if (s.org) console.log(chalk.gray(`  Org filter: ${s.org}`));
+
+        // Social mentions summary
+        if (s.socialMentions && Object.keys(s.socialMentions).length > 0) {
+          const socialParts = Object.entries(s.socialMentions)
+            .filter(([, arr]) => arr.length > 0)
+            .map(([platform, arr]) => {
+              const icon = platform === 'twitter' ? 'X' : platform === 'reddit' ? 'Reddit' : 'LinkedIn';
+              return `${icon}(${arr.length})`;
+            });
+          if (socialParts.length > 0) {
+            console.log(chalk.cyan(`  📱 Social: ${socialParts.join(' ')}`));
+          }
+        }
+
+        // Top mentions
+        for (const m of (s.mentions || []).slice(0, 5)) {
+          const sentEmoji = m.sentiment === 'positive' || m.sentiment === 'slightly_positive' ? '👍'
+            : m.sentiment === 'negative' || m.sentiment === 'slightly_negative' ? '👎' : '😐';
+          console.log(chalk.gray(`    ${sentEmoji} [${m.category}] ${m.title?.substring(0, 80)} (${m.domain})`));
+        }
+      }
+
+      if (tracker.type === 'competitor') {
+        const techNames = (snapshot.techStack || []).map(t => t.name).join(', ') || 'none detected';
+        console.log(chalk.gray(`  Tech: ${techNames}`));
+        console.log(chalk.gray(`  Pages: ${snapshot.pageCount}`));
+        
+        // Performance
+        if (snapshot.performance) {
+          const p = snapshot.performance;
+          console.log(chalk.gray(`  Response: ${p.responseTimeMs}ms | HTML: ${p.htmlSizeKB}KB | Compressed: ${p.compressed ? 'yes' : 'no'}`));
+        }
+
+        // Security summary
+        if (snapshot.security) {
+          const s = snapshot.security;
+          const secScore = [s.https, s.hsts, s.xFrameOptions, s.csp, s.xContentType].filter(Boolean).length;
+          console.log(chalk.gray(`  Security: ${secScore}/5 (HTTPS:${s.https ? '✓' : '✗'} HSTS:${s.hsts ? '✓' : '✗'} XFO:${s.xFrameOptions ? '✓' : '✗'} CSP:${s.csp ? '✓' : '✗'})`));
+        }
+
+        // SEO signals
+        if (snapshot.seoSignals) {
+          const seo = snapshot.seoSignals;
+          console.log(chalk.gray(`  SEO: title=${seo.titleLength}ch | desc=${seo.descriptionLength}ch | H1:${seo.h1Count} H2:${seo.h2Count} | ${seo.imgCount} imgs (${seo.imgWithoutAlt} no alt) | ${seo.wordCount} words`));
+        }
+
+        // Key pages found
+        if (snapshot.keyPages && Object.keys(snapshot.keyPages).length > 0) {
+          const pageLabels = Object.keys(snapshot.keyPages).join(', ');
+          console.log(chalk.gray(`  Key pages: ${pageLabels}`));
+        }
+
+        // Pricing
+        if (snapshot.pricing && snapshot.pricing.prices?.length > 0) {
+          console.log(chalk.cyan(`  💰 Pricing detected: ${snapshot.pricing.prices.slice(0, 5).join(', ')}`));
+          if (snapshot.pricing.plans?.length > 0) {
+            console.log(chalk.gray(`  Plans: ${snapshot.pricing.plans.slice(0, 3).join(' | ')}`));
+          }
+        }
+
+        // Jobs
+        if (snapshot.jobs && snapshot.jobs.estimatedOpenings > 0) {
+          console.log(chalk.yellow(`  👥 Jobs: ~${snapshot.jobs.estimatedOpenings} openings detected`));
+          if (snapshot.jobs.titles?.length > 0) {
+            for (const t of snapshot.jobs.titles.slice(0, 5)) {
+              console.log(chalk.gray(`    - ${t}`));
+            }
+          }
+        }
+
+        // Content/blog activity
+        if (snapshot.contentStats && snapshot.contentStats.recentArticles?.length > 0) {
+          console.log(chalk.green(`  📝 Blog: ${snapshot.contentStats.articleCount} recent articles`));
+          for (const a of snapshot.contentStats.recentArticles.slice(0, 3)) {
+            const dateStr = a.date ? ` (${a.date})` : '';
+            console.log(chalk.gray(`    - ${a.title}${dateStr}`));
+          }
+        }
+
+        // Social links
+        if (snapshot.socialLinks && Object.keys(snapshot.socialLinks).length > 0) {
+          const socials = Object.entries(snapshot.socialLinks).map(([k, v]) => k).join(', ');
+          console.log(chalk.gray(`  Social: ${socials}`));
+        }
+
+        // Press & mentions
+        if (snapshot.press && snapshot.press.totalCount > 0) {
+          const p = snapshot.press;
+          const sentStr = `👍${p.sentimentBreakdown?.positive || 0} 😐${p.sentimentBreakdown?.neutral || 0} 👎${p.sentimentBreakdown?.negative || 0}`;
+          console.log(chalk.magenta(`  📰 Press: ${p.totalCount} mentions (${p.pressCount || 0} press, ${p.forumCount || 0} forum/social) | ${sentStr}`));
+          for (const a of (p.articles || []).slice(0, 5)) {
+            const sentEmoji = a.sentiment === 'positive' || a.sentiment === 'slightly_positive' ? '👍' 
+              : a.sentiment === 'negative' || a.sentiment === 'slightly_negative' ? '👎' : '😐';
+            console.log(chalk.gray(`    ${sentEmoji} [${a.category}] ${a.title.substring(0, 80)} (${a.domain})`));
+          }
+        } else if (snapshot.press) {
+          console.log(chalk.gray(`  📰 Press: no recent mentions found`));
+        }
+
+        // Reputation / reviews
+        if (snapshot.reputation) {
+          const r = snapshot.reputation;
+          const validPlatforms = (r.platforms || []).filter(p => p.rating);
+          if (validPlatforms.length > 0) {
+            const platStr = validPlatforms.map(p => {
+              const countStr = p.reviewCount ? ` (${p.reviewCount} avis)` : '';
+              return `${p.name}: ${p.rating}/5${countStr}`;
+            }).join(' | ');
+            console.log(chalk.yellow(`  ⭐ ${platStr}`));
+          }
+          const validReviews = (r.reviews || []).filter(rev => rev.title && rev.title.length > 10);
+          if (validReviews.length > 0) {
+            for (const rev of validReviews.slice(0, 3)) {
+              const sentEmoji = rev.sentiment === 'positive' || rev.sentiment === 'slightly_positive' ? '👍' : '👎';
+              console.log(chalk.gray(`    ${sentEmoji} ${rev.title.substring(0, 80)}`));
+            }
+          }
+          if (!validPlatforms.length && !validReviews.length) {
+            console.log(chalk.gray(`  ⭐ Reputation: no ratings found`));
+          }
+        }
+
+        // Pappers (French company data)
+        if (snapshot.pappers) {
+          const p = snapshot.pappers;
+          const parts = [`SIREN: ${p.siren || '?'}`];
+          if (p.formeJuridique) parts.push(p.formeJuridique);
+          if (p.dateCreation) parts.push(`créée ${p.dateCreation}`);
+          if (p.city) parts.push(p.city);
+          console.log(chalk.blue(`  🏛  Pappers: ${parts.join(' · ')}`));
+          if (p.effectifs) console.log(chalk.gray(`     Effectifs: ${p.effectifs}`));
+          if (p.ca) {
+            const caStr = p.ca >= 1_000_000 ? `${(p.ca / 1_000_000).toFixed(1)}M€` : `${(p.ca / 1000).toFixed(0)}K€`;
+            console.log(chalk.gray(`     CA: ${caStr}${p.caYear ? ` (${p.caYear})` : ''}`));
+          }
+          if (p.nafCode) console.log(chalk.gray(`     NAF: ${p.nafCode}${p.nafLabel ? ` — ${p.nafLabel}` : ''}`));
+          if (p.dirigeants?.length > 0) {
+            const dirs = p.dirigeants.slice(0, 3).map(d => `${d.prenom || ''} ${d.nom || ''} (${d.role || '?'})`).join(', ');
+            console.log(chalk.gray(`     Dirigeants: ${dirs}`));
+          }
+        }
+      }
+
+    } catch (err) {
+      error(`  Failed: ${err.message}`);
+      updateTracker(tracker.id, { status: 'error', lastError: err.message });
+    }
+  }
+
+  console.log('');
+  if (totalChanges > 0) {
+    success(`${totalChanges} total change(s) detected across ${toCheck.length} tracker(s).`);
+  } else {
+    console.log(chalk.gray('No changes detected.'));
+  }
+}

package/src/commands/compare.js

@@ -0,0 +1,124 @@
+import chalk from 'chalk';
+import { getTracker, loadLatestSnapshot } from '../storage.js';
+import { createTable, header, section, error, warn } from '../utils/display.js';
+
+export function runCompare(id1, id2) {
+  const tracker1 = getTracker(id1);
+  const tracker2 = getTracker(id2);
+
+  if (!tracker1) { error(`Tracker not found: ${id1}`); process.exit(1); }
+  if (!tracker2) { error(`Tracker not found: ${id2}`); process.exit(1); }
+
+  if (tracker1.type !== 'competitor' || tracker2.type !== 'competitor') {
+    error('compare only works with competitor trackers.');
+    process.exit(1);
+  }
+
+  const snap1 = loadLatestSnapshot(id1);
+  const snap2 = loadLatestSnapshot(id2);
+
+  if (!snap1) { warn(`No snapshot for ${id1}. Run check first.`); return; }
+  if (!snap2) { warn(`No snapshot for ${id2}. Run check first.`); return; }
+
+  const name1 = tracker1.name || tracker1.url;
+  const name2 = tracker2.name || tracker2.url;
+
+  header(`🔄 Compare: ${name1} vs ${name2}`);
+
+  // Overview table
+  section('\nOverview:');
+  const overviewTable = createTable(['Metric', name1.slice(0, 25), name2.slice(0, 25)]);
+
+  overviewTable.push([
+    'Pages found',
+    String(snap1.pageCount || 0),
+    String(snap2.pageCount || 0),
+  ]);
+  overviewTable.push([
+    'Tech stack',
+    String((snap1.techStack || []).length),
+    String((snap2.techStack || []).length),
+  ]);
+  overviewTable.push([
+    'Social links',
+    String(Object.keys(snap1.socialLinks || {}).length),
+    String(Object.keys(snap2.socialLinks || {}).length),
+  ]);
+  overviewTable.push([
+    'Open jobs',
+    snap1.jobs ? String(snap1.jobs.estimatedOpenings) : chalk.gray('?'),
+    snap2.jobs ? String(snap2.jobs.estimatedOpenings) : chalk.gray('?'),
+  ]);
+  overviewTable.push([
+    'Pricing detected',
+    snap1.pricing ? chalk.green('yes') : chalk.gray('no'),
+    snap2.pricing ? chalk.green('yes') : chalk.gray('no'),
+  ]);
+  overviewTable.push([
+    'Last checked',
+    snap1.checkedAt ? new Date(snap1.checkedAt).toLocaleDateString() : chalk.gray('?'),
+    snap2.checkedAt ? new Date(snap2.checkedAt).toLocaleDateString() : chalk.gray('?'),
+  ]);
+
+  console.log(overviewTable.toString());
+
+  // Tech stack diff
+  section('\nTech Stack:');
+  const techTable = createTable(['Technology', 'Category', name1.slice(0, 20), name2.slice(0, 20)]);
+
+  const tech1Names = new Set((snap1.techStack || []).map(t => t.name));
+  const tech2Names = new Set((snap2.techStack || []).map(t => t.name));
+  const allTechs = [...new Set([...(snap1.techStack || []), ...(snap2.techStack || [])].map(t => JSON.stringify(t)))].map(t => JSON.parse(t));
+
+  for (const tech of allTechs) {
+    techTable.push([
+      tech.name,
+      chalk.gray(tech.category),
+      tech1Names.has(tech.name) ? chalk.green('✓') : chalk.gray('—'),
+      tech2Names.has(tech.name) ? chalk.green('✓') : chalk.gray('—'),
+    ]);
+  }
+
+  if (allTechs.length === 0) {
+    console.log(chalk.gray('  No tech detected for either tracker yet.'));
+  } else {
+    console.log(techTable.toString());
+  }
+
+  // Social links diff
+  section('\nSocial Links:');
+  const allPlatforms = new Set([
+    ...Object.keys(snap1.socialLinks || {}),
+    ...Object.keys(snap2.socialLinks || {}),
+  ]);
+
+  if (allPlatforms.size > 0) {
+    const socialTable = createTable(['Platform', name1.slice(0, 25), name2.slice(0, 25)]);
+    for (const platform of allPlatforms) {
+      socialTable.push([
+        platform,
+        snap1.socialLinks?.[platform] ? chalk.green('✓') : chalk.gray('—'),
+        snap2.socialLinks?.[platform] ? chalk.green('✓') : chalk.gray('—'),
+      ]);
+    }
+    console.log(socialTable.toString());
+  } else {
+    console.log(chalk.gray('  No social links detected.'));
+  }
+
+  // Pricing comparison
+  section('\nPricing:');
+  if (snap1.pricing?.prices?.length || snap2.pricing?.prices?.length) {
+    console.log(chalk.bold(`  ${name1}:`), (snap1.pricing?.prices || []).slice(0, 5).join(', ') || chalk.gray('none'));
+    console.log(chalk.bold(`  ${name2}:`), (snap2.pricing?.prices || []).slice(0, 5).join(', ') || chalk.gray('none'));
+  } else {
+    console.log(chalk.gray('  No pricing data detected.'));
+  }
+
+  // Homepage meta
+  section('\nHomepage Meta:');
+  const meta1 = snap1.keyPages?.['/'];
+  const meta2 = snap2.keyPages?.['/'];
+  console.log(chalk.bold(`  ${name1}: `) + chalk.gray((meta1?.title || '').slice(0, 70)));
+  console.log(chalk.bold(`  ${name2}: `) + chalk.gray((meta2?.title || '').slice(0, 70)));
+}

package/src/commands/diff.js

@@ -0,0 +1,118 @@
+import chalk from 'chalk';
+import { getTracker, listSnapshots, loadSnapshot } from '../storage.js';
+import { diffCompetitorSnapshots } from '../trackers/competitor.js';
+import { diffKeywordSnapshots } from '../trackers/keyword.js';
+import { diffBrandSnapshots } from '../trackers/brand.js';
+import { header, section, diffLine, warn, error, trackerTypeIcon } from '../utils/display.js';
+
+export async function runDiff(trackerId, options) {
+  const tracker = getTracker(trackerId);
+
+  if (!tracker) {
+    error(`Tracker not found: ${trackerId}`);
+    console.log(chalk.gray('Use `intelwatch list` to see all tracker IDs.'));
+    process.exit(1);
+  }
+
+  const snapshots = listSnapshots(trackerId);
+
+  if (snapshots.length === 0) {
+    warn(`No snapshots for tracker: ${trackerId}`);
+    console.log(chalk.gray('Run `intelwatch check` first.'));
+    return;
+  }
+
+  let prevSnapshot, currSnapshot;
+
+  if (options.days) {
+    const daysMs = parseInt(options.days) * 24 * 60 * 60 * 1000;
+    const targetTime = Date.now() - daysMs;
+
+    // Find snapshot closest to targetTime
+    const targetSnap = snapshots.reduce((best, snap) => {
+      return Math.abs(snap.timestamp - targetTime) < Math.abs(best.timestamp - targetTime) ? snap : best;
+    });
+
+    prevSnapshot = loadSnapshot(targetSnap.filepath);
+    currSnapshot = loadSnapshot(snapshots[snapshots.length - 1].filepath);
+  } else {
+    currSnapshot = loadSnapshot(snapshots[snapshots.length - 1].filepath);
+    prevSnapshot = snapshots.length > 1
+      ? loadSnapshot(snapshots[snapshots.length - 2].filepath)
+      : null;
+  }
+
+  const target = tracker.name || tracker.keyword || tracker.brandName || trackerId;
+  header(`${trackerTypeIcon(tracker.type)} Diff: ${target}`);
+
+  if (options.days) {
+    console.log(chalk.gray(`  Comparing with snapshot from ${options.days} day(s) ago`));
+  } else {
+    console.log(chalk.gray(`  Comparing last 2 snapshots`));
+  }
+
+  const prevDate = prevSnapshot ? new Date(prevSnapshot.checkedAt).toLocaleString() : 'N/A';
+  const currDate = new Date(currSnapshot.checkedAt).toLocaleString();
+  console.log(chalk.gray(`  Before: ${prevDate}`));
+  console.log(chalk.gray(`  After:  ${currDate}`));
+  console.log('');
+
+  let changes = [];
+  if (tracker.type === 'competitor') {
+    changes = diffCompetitorSnapshots(prevSnapshot, currSnapshot);
+  } else if (tracker.type === 'keyword') {
+    changes = diffKeywordSnapshots(prevSnapshot, currSnapshot);
+  } else if (tracker.type === 'brand') {
+    changes = diffBrandSnapshots(prevSnapshot, currSnapshot);
+  }
+
+  if (changes.length === 0) {
+    console.log(chalk.green('✓ No changes between these snapshots.'));
+    return;
+  }
+
+  // Group changes by type
+  const newChanges = changes.filter(c => c.type === 'new');
+  const changedChanges = changes.filter(c => c.type === 'changed');
+  const removedChanges = changes.filter(c => c.type === 'removed');
+
+  if (newChanges.length > 0) {
+    section('  New:');
+    for (const c of newChanges) {
+      console.log('  ' + diffLine('new', c.field, c.value));
+    }
+  }
+
+  if (changedChanges.length > 0) {
+    section('  Changed:');
+    for (const c of changedChanges) {
+      console.log('  ' + diffLine('changed', c.field, c.value));
+    }
+  }
+
+  if (removedChanges.length > 0) {
+    section('  Removed:');
+    for (const c of removedChanges) {
+      console.log('  ' + diffLine('removed', c.field, c.value));
+    }
+  }
+
+  console.log('');
+  console.log(chalk.gray(`Total: ${changes.length} change(s)`));
+
+  // Detailed output for specific types
+  if (tracker.type === 'keyword' && currSnapshot.results?.length > 0) {
+    section('\n  Current Rankings:');
+    for (const r of currSnapshot.results.slice(0, 10)) {
+      const star = r.isFeaturedSnippet ? chalk.yellow(' ⭐ Featured') : '';
+      console.log(chalk.gray(`  #${String(r.position).padEnd(3)}`), chalk.white(r.domain.padEnd(30)), chalk.gray(r.title?.slice(0, 40) || '') + star);
+    }
+  }
+
+  if (tracker.type === 'competitor' && currSnapshot.techStack?.length > 0) {
+    section('\n  Current Tech Stack:');
+    for (const tech of currSnapshot.techStack) {
+      console.log(chalk.gray(`  • ${tech.name}`), chalk.gray(`[${tech.category}]`));
+    }
+  }
+}

package/src/commands/digest.js

@@ -0,0 +1,156 @@
+import chalk from 'chalk';
+import { loadTrackers, loadLatestSnapshot, listSnapshots, loadSnapshot } from '../storage.js';
+import { diffCompetitorSnapshots } from '../trackers/competitor.js';
+import { diffKeywordSnapshots } from '../trackers/keyword.js';
+import { diffBrandSnapshots } from '../trackers/brand.js';
+import { createTable, header, section, trackerTypeIcon, warn } from '../utils/display.js';
+import { hasAIKey, callAI, getAIConfig } from '../ai/client.js';
+
+export async function runDigest() {
+  const trackers = loadTrackers();
+
+  if (trackers.length === 0) {
+    warn('No trackers configured. Use `intelwatch track` to add one.');
+    return;
+  }
+
+  header('📊 Intelligence Digest');
+  console.log(chalk.gray(`Generated: ${new Date().toLocaleString()}\n`));
+
+  const table = createTable(['Tracker', 'Type', 'Changes', 'Summary']);
+  let totalChanges = 0;
+
+  for (const tracker of trackers) {
+    const snapshots = listSnapshots(tracker.id);
+
+    if (snapshots.length === 0) {
+      table.push([
+        chalk.cyan(tracker.id.slice(0, 25)),
+        trackerTypeIcon(tracker.type),
+        chalk.gray('—'),
+        chalk.gray('No snapshots yet'),
+      ]);
+      continue;
+    }
+
+    const latest = loadSnapshot(snapshots[snapshots.length - 1].filepath);
+    const prev = snapshots.length > 1 ? loadSnapshot(snapshots[snapshots.length - 2].filepath) : null;
+
+    let changes = [];
+    if (tracker.type === 'competitor') changes = diffCompetitorSnapshots(prev, latest);
+    else if (tracker.type === 'keyword') changes = diffKeywordSnapshots(prev, latest);
+    else if (tracker.type === 'brand') changes = diffBrandSnapshots(prev, latest);
+
+    // Use stored changes if available and no prev
+    if (!prev && latest.changes) {
+      changes = latest.changes;
+    }
+
+    const target = tracker.name || tracker.keyword || tracker.brandName || tracker.id;
+    const changeStr = changes.length > 0
+      ? chalk.yellow(String(changes.length))
+      : chalk.gray('0');
+
+    const summary = changes.length > 0
+      ? changes.slice(0, 2).map(c => c.value?.slice(0, 40) || c.field).join('; ')
+      : chalk.gray('no changes');
+
+    table.push([
+      chalk.cyan(target.slice(0, 25)),
+      trackerTypeIcon(tracker.type) + ' ' + tracker.type,
+      changeStr,
+      summary.slice(0, 50),
+    ]);
+
+    totalChanges += changes.length;
+  }
+
+  console.log(table.toString());
+  console.log('');
+
+  if (totalChanges > 0) {
+    console.log(chalk.yellow(`⚡ ${totalChanges} total change(s) across all trackers.`));
+    console.log(chalk.gray('Run `intelwatch diff <tracker-id>` for details on any tracker.'));
+  } else {
+    console.log(chalk.green('✓ No significant changes detected across all trackers.'));
+  }
+
+  console.log(chalk.gray('\nRun `intelwatch report --format html` for a full report.'));
+
+  // ── AI enhancement (optional) ─────────────────────────────────────────────
+  if (hasAIKey()) {
+    await runAIDigestSummary(trackers);
+  } else {
+    console.log(chalk.gray('\nTip: set OPENAI_API_KEY or ANTHROPIC_API_KEY for AI-powered digest analysis.'));
+  }
+}
+
+async function runAIDigestSummary(trackers) {
+  const competitors = trackers.filter(t => t.type === 'competitor');
+  if (competitors.length === 0) return;
+
+  const aiConfig = getAIConfig();
+  section('\n🤖 AI Digest Analysis');
+  console.log(chalk.gray(`Provider: ${aiConfig.provider} / ${aiConfig.model}\n`));
+
+  // Build a compact snapshot of all competitors for a combined analysis
+  const competitorData = [];
+  for (const tracker of competitors) {
+    const snapshots = listSnapshots(tracker.id);
+    if (snapshots.length === 0) 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);
+
+    competitorData.push({ tracker, latest, changes });
+  }
+
+  if (competitorData.length === 0) {
+    console.log(chalk.gray('  No competitor snapshots available for AI analysis.\n'));
+    return;
+  }
+
+  try {
+    const analysis = await generateDigestAnalysis(competitorData);
+    console.log(analysis + '\n');
+  } catch (err) {
+    console.log(chalk.red(`  AI error: ${err.message}\n`));
+  }
+}
+
+async function generateDigestAnalysis(competitorData) {
+  const systemPrompt =
+    'You are a competitive intelligence analyst producing a concise weekly digest. ' +
+    'Be specific, actionable, and brief. Write in plain English prose. ' +
+    'Focus on what changed and what it means strategically.';
+
+  const summaries = competitorData.map(({ tracker, latest, changes }) => {
+    const name = tracker.name || tracker.url;
+    const changesText = changes.length > 0
+      ? changes.slice(0, 5).map(c => `${c.type}: ${c.field} — ${c.value}`).join('; ')
+      : 'no changes detected';
+
+    const pressNote = latest.press?.totalCount
+      ? ` Press: ${latest.press.totalCount} mentions (${latest.press.sentimentBreakdown?.negative || 0} negative).`
+      : '';
+
+    const jobsNote = latest.jobs?.estimatedOpenings
+      ? ` Hiring: ~${latest.jobs.estimatedOpenings} openings.`
+      : '';
+
+    return `${name}: changes=[${changesText}]${pressNote}${jobsNote}`;
+  }).join('\n');
+
+  const userPrompt =
+    `Weekly competitive digest for ${competitorData.length} competitor(s):\n\n` +
+    `${summaries}\n\n` +
+    `Provide:\n` +
+    `1. **Overall Assessment** (2-3 sentences): What's the most important competitive development this week?\n` +
+    `2. **Threat Levels**: For each competitor, one line: "[Name]: [LOW/MEDIUM/HIGH] — [reason]"\n` +
+    `3. **Recommended Actions**: 2-3 bullet points of what to do right now\n` +
+    `4. **Team One-liner**: One sentence to forward to your team summarizing the week\n\n` +
+    `Be concise and specific.`;
+
+  return await callAI(systemPrompt, userPrompt, { maxTokens: 600 });
+}