intelwatch 1.0.0

package/src/commands/discover.js

@@ -0,0 +1,301 @@
+import chalk from 'chalk';
+import { fetch } from '../utils/fetcher.js';
+import { load, extractMeta } from '../utils/parser.js';
+import { braveWebSearch } from '../scrapers/brave-search.js';
+import { callAI, hasAIKey } from '../ai/client.js';
+import { createTracker } from '../storage.js';
+import { header, section, success, warn, error } from '../utils/display.js';
+
+export async function runDiscover(url, options) {
+  let normalizedUrl = url;
+  if (!normalizedUrl.startsWith('http')) normalizedUrl = 'https://' + normalizedUrl;
+
+  try { new URL(normalizedUrl); } catch {
+    error(`Invalid URL: ${url}`);
+    process.exit(1);
+  }
+
+  header(`🔍 Discovering competitors for: ${normalizedUrl}`);
+
+  // ── Step 1: Analyze target site ────────────────────────────────────────────
+  console.log(chalk.gray('  Analyzing target site...'));
+
+  const siteInfo = { title: '', description: '', keywords: [], services: [], location: null };
+
+  try {
+    const response = await fetch(normalizedUrl, { retries: 2, delay: 1000 });
+    const $ = load(response.data);
+    const meta = extractMeta($);
+
+    siteInfo.title = meta.title || '';
+    siteInfo.description = meta.description || '';
+
+    const metaKeywords = $('meta[name="keywords"]').attr('content') || '';
+    siteInfo.keywords = metaKeywords.split(',').map(k => k.trim()).filter(Boolean).slice(0, 10);
+
+    $('h1, h2, h3').each((_, el) => {
+      const text = $(el).text().trim();
+      if (text.length > 3 && text.length < 100) siteInfo.services.push(text);
+    });
+    siteInfo.services = siteInfo.services.slice(0, 10);
+
+    const pageText = $.text();
+    const locationMatch = pageText.match(
+      /\b(Paris|Lyon|Marseille|Bordeaux|Toulouse|Nantes|Lille|Strasbourg|France|London|Berlin|New York|San Francisco|Amsterdam|Madrid|Barcelona)\b/i
+    );
+    if (locationMatch) siteInfo.location = locationMatch[0];
+  } catch (err) {
+    warn(`Could not fetch target site: ${err.message}. Proceeding with URL-based discovery...`);
+  }
+
+  const hostname = new URL(normalizedUrl).hostname.replace('www.', '');
+  const brandName = siteInfo.title.split(/[-|:]/)[0].trim() || hostname.split('.')[0];
+
+  console.log(chalk.gray(`  Brand   : ${brandName}`));
+  if (siteInfo.description) console.log(chalk.gray(`  Desc    : ${siteInfo.description.substring(0, 100)}`));
+  if (siteInfo.location) console.log(chalk.gray(`  Location: ${siteInfo.location}`));
+
+  // ── Step 2: Generate search queries ────────────────────────────────────────
+  let queries = buildQueries(brandName, siteInfo);
+
+  if (options.ai && hasAIKey()) {
+    console.log(chalk.gray('  Using AI to generate smarter queries...'));
+    try {
+      const aiQueries = await generateAIQueries(brandName, siteInfo);
+      if (aiQueries.length > 0) queries = aiQueries;
+    } catch {}
+  }
+
+  section('  Search queries:');
+  for (const q of queries) console.log(chalk.gray(`    · ${q}`));
+
+  // ── Step 3: Run searches and collect candidates ─────────────────────────────
+  console.log('\n' + chalk.gray('  Searching for competitors...'));
+  const candidates = new Map();
+
+  for (const query of queries) {
+    await new Promise(r => setTimeout(r, 600));
+    const { results, error: searchError } = await braveWebSearch(query, { count: 20 });
+    if (searchError) {
+      warn(`  Search error for "${query}": ${searchError}`);
+      continue;
+    }
+
+    for (const r of results) {
+      const domain = r.domain;
+      if (!domain || domain === hostname) continue;
+      // Skip aggregators, directories, and social networks
+      if (/wikipedia|linkedin|facebook|twitter|x\.com|youtube|yelp|trustpilot|pagesjaunes|societe\.com|pappers|capterra|g2\.com|glassdoor/i.test(domain)) continue;
+
+      if (!candidates.has(domain)) {
+        candidates.set(domain, {
+          domain,
+          url: r.url.match(/^https?:\/\/[^/]+/)?.[0] || `https://${domain}`,
+          name: r.title?.split(/[-|:]/)[0].trim() || domain,
+          snippet: r.snippet || '',
+          appearances: 0,
+          queries: [],
+        });
+      }
+
+      const c = candidates.get(domain);
+      c.appearances++;
+      c.queries.push(query);
+    }
+  }
+
+  if (candidates.size === 0) {
+    warn('No competitors found. Check that BRAVE_API_KEY is set and the URL is reachable.');
+    return;
+  }
+
+  // ── Step 4: Score candidates ────────────────────────────────────────────────
+  let scored = [...candidates.values()].map(c => {
+    let score = 0;
+
+    // More query appearances = stronger signal
+    score += Math.min(c.appearances * 15, 45);
+
+    // Domain extension match (e.g., both .fr)
+    const targetExt = hostname.split('.').pop();
+    const candExt = c.domain.split('.').pop();
+    if (candExt === targetExt) score += 10;
+
+    // Location match in snippet
+    if (siteInfo.location && c.snippet.toLowerCase().includes(siteInfo.location.toLowerCase())) {
+      score += 10;
+    }
+
+    // Service/keyword overlap in snippet
+    const relevantTerms = [
+      ...siteInfo.keywords,
+      ...siteInfo.services.map(s => s.toLowerCase().split(/\s+/).slice(0, 2).join(' ')),
+    ];
+    for (const term of relevantTerms) {
+      if (term.length > 3 && c.snippet.toLowerCase().includes(term.toLowerCase())) {
+        score += 5;
+      }
+    }
+
+    return {
+      ...c,
+      score: Math.min(score, 100),
+      whyMatch: buildWhyMatch(c, siteInfo, hostname),
+    };
+  });
+
+  // ── Step 5: Optional AI scoring ────────────────────────────────────────────
+  if (options.ai && hasAIKey() && scored.length > 0) {
+    console.log(chalk.gray('  Using AI for smarter relevance scoring...'));
+    try {
+      scored = await scoreWithAI(scored, siteInfo, brandName);
+    } catch {
+      scored = scored.sort((a, b) => b.score - a.score).slice(0, 15);
+    }
+  } else {
+    scored = scored.sort((a, b) => b.score - a.score).slice(0, 15);
+  }
+
+  // ── Step 6: Display results ────────────────────────────────────────────────
+  section(`\n  ${scored.length} competitors discovered:`);
+  console.log('');
+
+  for (let i = 0; i < scored.length; i++) {
+    const c = scored[i];
+    const rank = chalk.cyan(`#${i + 1}`);
+    const bar = scoreBar(c.score);
+    console.log(`  ${rank} ${chalk.white.bold(c.name)} ${chalk.gray(`(${c.domain})`)}`);
+    console.log(`     ${bar} ${chalk.yellow(`${c.score}%`)} similarity`);
+    console.log(`     ${chalk.gray(c.url)}`);
+    if (c.whyMatch) console.log(`     ${chalk.gray('→')} ${chalk.gray(c.whyMatch)}`);
+    console.log('');
+  }
+
+  // ── Step 7: Auto-track top results ─────────────────────────────────────────
+  if (options.autoTrack) {
+    const topN = scored.slice(0, 5);
+    section(`  Auto-tracking top ${topN.length} competitors...`);
+    for (const c of topN) {
+      try {
+        const { tracker, created } = createTracker('competitor', { url: c.url, name: c.name });
+        if (created) {
+          success(`  Created tracker: ${tracker.id} (${c.name})`);
+        } else {
+          warn(`  Already tracked: ${tracker.id} (${c.name})`);
+        }
+      } catch {}
+    }
+    console.log(chalk.gray('\n  Run `intelwatch check` to fetch initial snapshots.'));
+  } else {
+    console.log(chalk.gray('  Tip: use --auto-track to automatically create trackers for the top 5.'));
+  }
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function buildQueries(brandName, siteInfo) {
+  const queries = [];
+
+  // Alternative / competitor framing
+  queries.push(`alternative to ${brandName}`);
+
+  // Description-based query
+  if (siteInfo.description) {
+    const shortDesc = siteInfo.description.split(/[.!?]/)[0].substring(0, 80);
+    queries.push(shortDesc);
+  } else {
+    queries.push(`${brandName} competitor`);
+  }
+
+  // Main service heading
+  if (siteInfo.services.length > 0) {
+    queries.push(siteInfo.services[0].substring(0, 60));
+  }
+
+  // Location + service
+  if (siteInfo.location && siteInfo.services.length > 0) {
+    queries.push(`${siteInfo.services[0].substring(0, 40)} ${siteInfo.location}`);
+  }
+
+  // Top keywords
+  if (siteInfo.keywords.length >= 2) {
+    queries.push(siteInfo.keywords.slice(0, 3).join(' '));
+  }
+
+  return queries.slice(0, 5);
+}
+
+async function generateAIQueries(brandName, siteInfo) {
+  const systemPrompt = 'You are a competitive intelligence expert. Output only valid JSON.';
+  const userPrompt = `Generate 5 web search queries to find direct competitors of this business.
+
+Brand: ${brandName}
+Description: ${siteInfo.description || 'unknown'}
+Top services/headings: ${siteInfo.services.slice(0, 5).join(', ') || 'unknown'}
+Keywords: ${siteInfo.keywords.join(', ') || 'unknown'}
+Location: ${siteInfo.location || 'unknown'}
+
+Return ONLY a JSON array of 5 search query strings. Example: ["query one", "query two", ...]`;
+
+  const raw = await callAI(systemPrompt, userPrompt, { max_tokens: 300 });
+  const match = raw.match(/\[[\s\S]*?\]/);
+  if (!match) return [];
+  try {
+    return JSON.parse(match[0]).filter(q => typeof q === 'string').slice(0, 5);
+  } catch {
+    return [];
+  }
+}
+
+async function scoreWithAI(candidates, siteInfo, brandName) {
+  const simplified = candidates.slice(0, 20).map(c => ({
+    domain: c.domain,
+    name: c.name,
+    snippet: c.snippet?.substring(0, 150),
+    appearances: c.appearances,
+  }));
+
+  const systemPrompt = 'You are a competitive intelligence analyst. Output only valid JSON.';
+  const userPrompt = `Score these companies as potential competitors to "${brandName}".
+Target description: ${siteInfo.description?.substring(0, 200) || 'unknown'}
+
+Candidates:
+${JSON.stringify(simplified, null, 2)}
+
+Return ONLY a JSON array: [{"domain": "...", "score": 0-100, "reason": "short reason"}]
+Sort by score descending.`;
+
+  const raw = await callAI(systemPrompt, userPrompt, { max_tokens: 1000 });
+  const match = raw.match(/\[[\s\S]*?\]/);
+  if (!match) throw new Error('No JSON in AI response');
+
+  const aiScores = JSON.parse(match[0]);
+  return candidates
+    .map(c => {
+      const ai = aiScores.find(a => a.domain === c.domain);
+      return {
+        ...c,
+        score: ai?.score ?? c.score,
+        whyMatch: ai?.reason || c.whyMatch,
+      };
+    })
+    .sort((a, b) => b.score - a.score)
+    .slice(0, 15);
+}
+
+function buildWhyMatch(candidate, siteInfo, targetHostname) {
+  const reasons = [];
+  if (candidate.appearances > 1) reasons.push(`appeared in ${candidate.appearances} queries`);
+  if (siteInfo.location && candidate.snippet.toLowerCase().includes(siteInfo.location.toLowerCase())) {
+    reasons.push(`same location (${siteInfo.location})`);
+  }
+  const targetExt = targetHostname.split('.').pop();
+  const candExt = candidate.domain.split('.').pop();
+  if (candExt === targetExt) reasons.push(`.${candExt} domain`);
+  return reasons.join(', ') || 'matched search queries';
+}
+
+function scoreBar(score) {
+  const filled = Math.round(score / 10);
+  return chalk.green('█'.repeat(filled)) + chalk.gray('░'.repeat(10 - filled));
+}

package/src/commands/history.js

@@ -0,0 +1,60 @@
+import chalk from 'chalk';
+import { getTracker, listSnapshots, loadSnapshot } from '../storage.js';
+import { createTable, header, error, warn, trackerTypeIcon } from '../utils/display.js';
+
+export function runHistory(trackerId, options) {
+  const tracker = getTracker(trackerId);
+
+  if (!tracker) {
+    error(`Tracker not found: ${trackerId}`);
+    process.exit(1);
+  }
+
+  const limit = parseInt(options.limit || '20');
+  const snapshots = listSnapshots(trackerId, limit);
+
+  if (snapshots.length === 0) {
+    warn(`No snapshots for tracker: ${trackerId}`);
+    console.log(chalk.gray('Run `intelwatch check` first.'));
+    return;
+  }
+
+  const target = tracker.name || tracker.keyword || tracker.brandName || trackerId;
+  header(`${trackerTypeIcon(tracker.type)} History: ${target}`);
+  console.log(chalk.gray(`  Showing last ${snapshots.length} snapshot(s)\n`));
+
+  const table = createTable(['Date', 'Time', 'Changes', 'Summary']);
+
+  for (const snap of snapshots.reverse()) {
+    const snapshot = loadSnapshot(snap.filepath);
+    if (!snapshot) continue;
+
+    const date = new Date(snapshot.checkedAt);
+    const dateStr = date.toLocaleDateString();
+    const timeStr = date.toLocaleTimeString();
+
+    const changes = snapshot.changes || [];
+    const changeCount = changes.length > 0 ? chalk.yellow(String(changes.length)) : chalk.gray('0');
+    const summary = changes.length > 0
+      ? changes[0].value?.slice(0, 50) || changes[0].field
+      : chalk.gray('—');
+
+    let extra = '';
+    if (tracker.type === 'competitor') {
+      extra = `${snapshot.pageCount || 0} pages`;
+    } else if (tracker.type === 'keyword') {
+      extra = `${snapshot.resultCount || 0} results`;
+    } else if (tracker.type === 'brand') {
+      extra = `${snapshot.mentionCount || 0} mentions`;
+    }
+
+    table.push([
+      dateStr,
+      timeStr,
+      changeCount,
+      (extra ? chalk.gray(extra + ' | ') : '') + summary.slice(0, 45),
+    ]);
+  }
+
+  console.log(table.toString());
+}

package/src/commands/list.js

@@ -0,0 +1,43 @@
+import chalk from 'chalk';
+import { loadTrackers, removeTracker } from '../storage.js';
+import { createTable, formatDate, statusBadge, trackerTypeIcon, success, error, warn } from '../utils/display.js';
+
+export function listTrackers() {
+  const trackers = loadTrackers();
+
+  if (trackers.length === 0) {
+    warn('No trackers configured.');
+    console.log(chalk.gray('  Use `intelwatch track competitor <url>` to add your first tracker.'));
+    return;
+  }
+
+  const table = createTable(['ID', 'Type', 'Target', 'Status', 'Last Check', 'Checks']);
+
+  for (const t of trackers) {
+    const target = t.type === 'competitor' ? (t.name || t.url)
+      : t.type === 'keyword' ? `"${t.keyword}"`
+      : `"${t.brandName}"`;
+
+    table.push([
+      chalk.cyan(t.id.slice(0, 30)),
+      trackerTypeIcon(t.type) + ' ' + t.type,
+      target.slice(0, 40),
+      statusBadge(t.status || 'active'),
+      formatDate(t.lastCheckedAt),
+      String(t.checkCount || 0),
+    ]);
+  }
+
+  console.log(table.toString());
+  console.log(chalk.gray(`\n${trackers.length} tracker(s) total.`));
+}
+
+export function removeTrackerCmd(id) {
+  try {
+    const removed = removeTracker(id);
+    success(`Tracker removed: ${removed.id}`);
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+}

package/src/commands/notify.js

@@ -0,0 +1,121 @@
+import { loadConfig, saveConfig } from '../config.js';
+import { success, info, header } from '../utils/display.js';
+import chalk from 'chalk';
+import { fetch } from '../utils/fetcher.js';
+
+export async function setupNotifications(options) {
+  header('🔔 Notification Setup');
+
+  // Check if inquirer is available
+  let inquirer;
+  try {
+    const mod = await import('inquirer');
+    inquirer = mod.default;
+  } catch {
+    console.log(chalk.yellow('Interactive mode requires inquirer. Running in guided mode.\n'));
+    await guidedSetup();
+    return;
+  }
+
+  const config = loadConfig();
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'webhook',
+      message: 'Webhook URL (Slack/Discord, leave empty to skip):',
+      default: config.notifications.webhook || '',
+    },
+    {
+      type: 'checkbox',
+      name: 'events',
+      message: 'Which events should trigger notifications?',
+      choices: [
+        { name: 'Competitor: new page detected', value: 'competitor.new_page', checked: true },
+        { name: 'Competitor: pricing changed', value: 'competitor.price_change', checked: true },
+        { name: 'Competitor: tech stack changed', value: 'competitor.tech_change', checked: false },
+        { name: 'Keyword: position change', value: 'keyword.position_change', checked: true },
+        { name: 'Brand: new mention', value: 'brand.new_mention', checked: true },
+        { name: 'Brand: negative mention', value: 'brand.negative_mention', checked: true },
+      ],
+    },
+  ]);
+
+  const newConfig = {
+    ...config,
+    notifications: {
+      ...config.notifications,
+      webhook: answers.webhook || null,
+      events: answers.events,
+    },
+  };
+
+  saveConfig(newConfig);
+
+  if (answers.webhook) {
+    console.log(chalk.gray('\nTesting webhook...'));
+    await testWebhook(answers.webhook);
+  }
+
+  success('Notification settings saved!');
+  info(`Config file: ${(await import('../config.js')).CONFIG_FILE}`);
+}
+
+async function guidedSetup() {
+  const config = loadConfig();
+  console.log('Current configuration:');
+  console.log(JSON.stringify(config.notifications, null, 2));
+  console.log(chalk.gray('\nTo configure notifications, edit ~/.intelwatch/config.yml directly.'));
+  console.log(chalk.gray('Example:'));
+  console.log(chalk.gray(`
+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
+`));
+}
+
+export async function sendWebhookNotification(webhookUrl, event, data) {
+  if (!webhookUrl) return;
+
+  const payload = {
+    text: `*intelwatch alert*: ${event}`,
+    attachments: [
+      {
+        color: event.includes('negative') ? 'danger' : 'good',
+        fields: Object.entries(data).map(([title, value]) => ({
+          title,
+          value: String(value).slice(0, 200),
+          short: true,
+        })),
+      },
+    ],
+  };
+
+  try {
+    await fetch(webhookUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      data: JSON.stringify(payload),
+      retries: 1,
+    });
+  } catch {
+    // Silently fail notifications
+  }
+}
+
+async function testWebhook(url) {
+  try {
+    await sendWebhookNotification(url, 'test', {
+      message: 'intelwatch notification test — everything is working!',
+      time: new Date().toISOString(),
+    });
+    console.log(chalk.green('  ✓ Webhook test sent successfully'));
+  } catch (err) {
+    console.log(chalk.red(`  ✗ Webhook test failed: ${err.message}`));
+  }
+}

package/src/commands/pitch.js

@@ -0,0 +1,156 @@
+import { writeFileSync } from 'fs';
+import chalk from 'chalk';
+import { getTracker, loadLatestSnapshot } from '../storage.js';
+import { header, error, warn } from '../utils/display.js';
+import { callAI, hasAIKey, getAIConfig } from '../ai/client.js';
+
+export async function runPitch(competitorId, 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'));
+    process.exit(1);
+  }
+
+  const tracker = getTracker(competitorId);
+  if (!tracker) {
+    error(`Tracker not found: ${competitorId}`);
+    process.exit(1);
+  }
+
+  if (tracker.type !== 'competitor') {
+    error('pitch only works with competitor trackers.');
+    process.exit(1);
+  }
+
+  const snapshot = loadLatestSnapshot(competitorId);
+  if (!snapshot) {
+    warn(`No snapshot for ${competitorId}. Run \`intelwatch check\` first.`);
+    return;
+  }
+
+  const competitorName = tracker.name || tracker.url;
+  const yourSite = options.for || 'your product';
+  const format = options.format || 'md';
+
+  const aiConfig = getAIConfig();
+  header(`📝 Competitive Pitch: ${yourSite} vs ${competitorName}`);
+  console.log(chalk.gray(`Provider: ${aiConfig.provider} / ${aiConfig.model}\n`));
+
+  let pitch;
+  try {
+    pitch = await generatePitch(tracker, snapshot, yourSite, format);
+  } catch (err) {
+    error(`AI error: ${err.message}`);
+    process.exit(1);
+  }
+
+  console.log('\n' + pitch + '\n');
+
+  if (options.output) {
+    writeFileSync(options.output, pitch, 'utf8');
+    console.log(chalk.green(`✓ Pitch saved to ${options.output}`));
+  }
+}
+
+async function generatePitch(tracker, snapshot, yourSite, format) {
+  const competitorName = tracker.name || tracker.url;
+
+  const systemPrompt =
+    'You are a sales strategist and competitive intelligence expert. ' +
+    'Generate crisp, data-backed competitive pitch documents. ' +
+    'Be specific about weaknesses you can exploit. Use the actual data points provided. ' +
+    'Be direct and sales-ready — this document may be shared with prospects or internal teams. ' +
+    'Only reference data that was actually provided. Do not invent statistics.';
+
+  const context = buildPitchContext(competitorName, snapshot);
+  const outputFormat = format === 'html' ? 'HTML' : 'Markdown';
+
+  const userPrompt =
+    `Generate a competitive pitch document: "${yourSite}" vs "${competitorName}".\n\n` +
+    `Competitor data:\n${context}\n\n` +
+    `Write in ${outputFormat} with these sections:\n\n` +
+    `1. Executive Summary — 2-3 sentences on why ${yourSite} is the better choice\n` +
+    `2. Competitor Weaknesses — specific, data-backed points from the data provided\n` +
+    `3. Your Advantages — frame based on their weaknesses (say "where they struggle, you excel")\n` +
+    `4. Talking Points — 3-5 bullet points to use with prospects\n` +
+    `5. Data Snapshot — table of key metrics\n\n` +
+    `Use actual numbers from the data. Omit sections that have no supporting data.`;
+
+  return await callAI(systemPrompt, userPrompt, { maxTokens: 1200 });
+}
+
+function buildPitchContext(name, snap) {
+  const lines = [];
+
+  lines.push(`Competitor: ${name}`);
+  lines.push(`URL: ${snap.url}`);
+  lines.push(`Pages indexed: ${snap.pageCount || 0}`);
+
+  if (snap.techStack?.length) {
+    lines.push(`Tech stack: ${snap.techStack.map(t => `${t.name} (${t.category})`).join(', ')}`);
+  }
+
+  if (snap.performance) {
+    const p = snap.performance;
+    lines.push(`Page speed: load ${p.loadTime}ms, TTFB ${p.ttfb}ms`);
+  }
+
+  if (snap.security) {
+    const s = snap.security;
+    const issues = [];
+    if (!s.hsts) issues.push('missing HSTS');
+    if (!s.httpsRedirect) issues.push('no HTTPS redirect');
+    if (!s.xFrameOptions) issues.push('no X-Frame-Options');
+    if (!s.contentSecurityPolicy) issues.push('no CSP header');
+    if (issues.length) lines.push(`Security issues: ${issues.join(', ')}`);
+    else lines.push('Security: all common headers present');
+  }
+
+  if (snap.seoSignals) {
+    const seo = snap.seoSignals;
+    const signals = [];
+    if (seo.missingAlt > 0) signals.push(`${seo.missingAlt} images without alt text`);
+    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 weaknesses: ${signals.join(', ')}`);
+  }
+
+  if (snap.pricing?.prices?.length) {
+    lines.push(`Pricing: ${snap.pricing.prices.slice(0, 8).join(', ')}`);
+  } else {
+    lines.push('Pricing: not publicly listed');
+  }
+
+  if (snap.jobs?.estimatedOpenings) {
+    lines.push(`Hiring: ~${snap.jobs.estimatedOpenings} open positions`);
+  }
+
+  if (snap.press?.articles?.length) {
+    const p = snap.press;
+    lines.push(
+      `Press coverage: ${p.totalCount} mentions ` +
+      `(${p.sentimentBreakdown?.positive || 0} positive, ${p.sentimentBreakdown?.negative || 0} negative)`
+    );
+    const negatives = p.articles
+      .filter(a => a.sentiment === 'negative' || a.sentiment === 'slightly_negative')
+      .slice(0, 3);
+    if (negatives.length) {
+      lines.push(`Negative coverage: ${negatives.map(a => `"${a.title}"`).join('; ')}`);
+    }
+  }
+
+  if (snap.reputation?.platforms?.length) {
+    lines.push(`Customer ratings: ${snap.reputation.platforms.map(p => `${p.platform} ${p.rating}/5`).join(', ')}`);
+  }
+
+  if (snap.meta?.title) {
+    lines.push(`Their positioning: "${snap.meta.title}"`);
+  }
+
+  if (snap.socialLinks) {
+    const platforms = Object.keys(snap.socialLinks);
+    if (platforms.length) lines.push(`Social presence: ${platforms.join(', ')}`);
+  }
+
+  return lines.join('\n');
+}