seo-intel 1.3.1 → 1.4.0

package/.env.example

@@ -27,9 +27,10 @@ GEMINI_API_KEY=
 # GOOGLE_CLIENT_SECRET=
 
 # ── Extraction Model (local Ollama) ───────────────────────────────────────
-# Recommended: qwen3.5:9b (balanced), qwen3.5:4b (budget), qwen3.5:27b (quality)
+# Recommended: gemma4:e4b (default), gemma4:e2b (budget), gemma4:26b (quality)
+# Also supported: qwen3.5:9b, qwen3.5:4b, qwen3.5:27b
 OLLAMA_URL=http://localhost:11434
-OLLAMA_MODEL=qwen3.5:9b
+OLLAMA_MODEL=gemma4:e4b
 OLLAMA_CTX=8192
 OLLAMA_TIMEOUT_MS=60000   # 60s default — increase to 120000 on slow hardware (BUG-008)
 

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 1.4.0 (2026-04-03)
+
+### New Feature: Gap Intelligence
+- `seo-intel gap-intel <project>` — topic/content gap analysis against competitors
+- Extracts topics from your pages and competitor pages via Ollama
+- Fuzzy set comparison identifies coverage gaps with substring matching
+- LLM-powered prioritisation ranks gaps by traffic potential and difficulty
+- Options: `--vs <domains>`, `--type docs|blog|landing|all`, `--limit <n>`, `--raw`, `--format`, `--out`
+- Available from dashboard terminal and CLI (Pro feature)
+
+### New Default: Gemma 4 Models
+- **Gemma 4 e4b** is now the default extraction model (was Qwen 3 4B)
+- Four extraction tiers: e2b (budget, 46 t/s), e4b (balanced, 23 t/s), 26b (quality), 31b (power)
+- Two analysis tiers: 26b (recommended 11GB+ VRAM), 31b (16GB+ VRAM)
+- Qwen models remain fully supported as alternatives
+- Setup wizard, model recommendations, and VRAM tiers updated for Gemma 4
+
+### Server
+- Added `gap-intel` to terminal command whitelist
+- Forward `--vs`, `--type`, `--limit`, `--raw`, `--out` params from dashboard to CLI
+
 ## 1.3.1 (2026-04-02)
 
 ### Fixes

package/README.md

@@ -157,14 +157,15 @@ SEO Intel uses Ollama for local AI extraction. Edit `.env`:
 
 ```bash
 OLLAMA_URL=http://localhost:11434
-OLLAMA_MODEL=qwen3.5:9b        # recommended (needs 6GB+ VRAM)
+OLLAMA_MODEL=gemma4:e4b         # recommended (MoE, needs 6GB+ VRAM)
 OLLAMA_CTX=16384
 ```
 
 Model recommendations by VRAM:
-- **3-4 GB** → `qwen3.5:4b`
-- **6-8 GB** → `qwen3.5:9b` (recommended)
-- **16+ GB** → `qwen3.5:27b`
+- **4-5 GB** → `gemma4:e2b` (MoE edge model)
+- **6-10 GB** → `gemma4:e4b` (recommended)
+- **12+ GB** → `gemma4:26b` (MoE, frontier quality)
+- Also supported: `qwen3.5:4b`, `qwen3.5:9b`, `qwen3.5:27b`
 
 ### Analysis (cloud, user's API key)
 

package/analyses/gap-intel/index.js

@@ -0,0 +1,339 @@
+/**
+ * Gap Intel — Topic/Content Gap Analysis
+ *
+ * Reads crawled pages for target + competitors from DB,
+ * extracts topic clusters via local LLM, compares coverage,
+ * and outputs a prioritised gap report.
+ *
+ * Zero network — reads from SQLite + Ollama only.
+ */
+
+import { getProjectDomains, getTargetDomains, getCompetitorDomains } from '../../exports/queries.js';
+
+// ── Page type URL patterns ───────────────────────────────────────────────────
+
+const PAGE_TYPE_PATTERNS = {
+  docs: ['/docs/', '/guide', '/api/', '/reference', '/quickstart', '/tutorial', '/learn'],
+  blog: ['/blog/', '/post/', '/article/', '/news/'],
+  landing: ['/pricing', '/features', '/product', '/solutions', '/use-case', '/compare'],
+};
+
+function matchesPageType(url, type) {
+  if (!type || type === 'all') return true;
+  const patterns = PAGE_TYPE_PATTERNS[type];
+  if (!patterns) return true;
+  const lower = url.toLowerCase();
+  return patterns.some(p => lower.includes(p));
+}
+
+// ── Load pages from DB ───────────────────────────────────────────────────────
+
+function loadPages(db, project, opts = {}) {
+  const { type = 'all', limit = 100, vsDomains = [] } = opts;
+
+  const domains = getProjectDomains(db, project);
+  const targetDomains = getTargetDomains(domains);
+  const competitorDomains = vsDomains.length
+    ? domains.filter(d => d.role === 'competitor' && vsDomains.some(v => d.domain.includes(v)))
+    : getCompetitorDomains(domains);
+
+  if (!targetDomains.length) return { target: [], competitors: new Map(), targetDomain: null, competitorDomainNames: [] };
+
+  const loadForDomains = (domainRows) => {
+    const allPages = [];
+    for (const d of domainRows) {
+      const pages = db.prepare(`
+        SELECT p.url, p.title, p.meta_desc, p.body_text, p.word_count
+        FROM pages p
+        WHERE p.domain_id = ?
+          AND p.status_code = 200
+          AND p.body_text IS NOT NULL AND p.body_text != ''
+        ORDER BY p.word_count DESC
+        LIMIT ?
+      `).all(d.id, limit);
+      allPages.push(...pages.filter(p => matchesPageType(p.url, type)).map(p => ({ ...p, domain: d.domain })));
+    }
+    return allPages;
+  };
+
+  const targetPages = loadForDomains(targetDomains);
+  const compPages = new Map();
+  for (const d of competitorDomains) {
+    const pages = loadForDomains([d]);
+    if (pages.length) compPages.set(d.domain, pages);
+  }
+
+  return {
+    target: targetPages,
+    competitors: compPages,
+    targetDomain: targetDomains[0]?.domain,
+    competitorDomainNames: competitorDomains.map(d => d.domain),
+  };
+}
+
+// ── Extract topics from pages (LLM) ─────────────────────────────────────────
+
+async function extractTopics(pages, domain, ollamaUrl, ollamaModel, log) {
+  const batchSize = 25;
+  const allTopics = new Set();
+
+  for (let i = 0; i < pages.length; i += batchSize) {
+    const batch = pages.slice(i, i + batchSize);
+    const listing = batch.map((p, idx) => {
+      const path = p.url.replace(/https?:\/\/[^/]+/, '') || '/';
+      return `${idx + 1}. ${p.title || path}\n   ${p.meta_desc || '(no description)'}`;
+    }).join('\n');
+
+    const prompt = `Given these ${batch.length} pages from ${domain}:\n\n${listing}\n\nExtract the main topics and capabilities this site covers.\nReturn ONLY a flat list of specific topic labels, one per line.\nBe specific: "RPC rate limits" not just "rate limits".\n"WebSocket subscription guide" not just "WebSockets".\nNo numbering, no bullets, no explanations — just topic labels.`;
+
+    try {
+      const res = await fetch(`${ollamaUrl}/api/generate`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          model: ollamaModel,
+          prompt,
+          stream: false,
+          options: { temperature: 0.2, num_ctx: 8192 },
+        }),
+      });
+
+      if (!res.ok) throw new Error(`Ollama ${res.status}`);
+      const data = await res.json();
+      const lines = (data.response || '').split('\n').map(l => l.trim()).filter(l => l && !l.startsWith('#'));
+      for (const line of lines) {
+        // Strip bullets, numbers, etc.
+        const clean = line.replace(/^[-*•\d.)\s]+/, '').trim();
+        if (clean.length > 2 && clean.length < 120) allTopics.add(clean);
+      }
+      log(`  ${domain}: batch ${Math.floor(i / batchSize) + 1} → ${lines.length} topics`);
+    } catch (e) {
+      log(`  ⚠️ ${domain} batch ${Math.floor(i / batchSize) + 1} failed: ${e.message}`);
+    }
+  }
+
+  return [...allTopics];
+}
+
+// ── Compare topic coverage ───────────────────────────────────────────────────
+
+function compareTopics(targetTopics, competitorTopicsMap) {
+  const targetSet = new Set(targetTopics.map(t => t.toLowerCase()));
+
+  const gaps = []; // topics competitors have, target doesn't
+  const depthGaps = []; // topics target has but competitors go deeper
+
+  for (const [domain, topics] of competitorTopicsMap) {
+    for (const topic of topics) {
+      const lower = topic.toLowerCase();
+      // Fuzzy match — check if target covers this topic (substring match)
+      const covered = [...targetSet].some(t =>
+        t.includes(lower) || lower.includes(t) ||
+        (lower.split(' ').length > 1 && t.split(' ').some(w => lower.includes(w) && w.length > 4))
+      );
+
+      if (!covered) {
+        const existing = gaps.find(g => g.topic.toLowerCase() === lower);
+        if (existing) {
+          if (!existing.coveredBy.includes(domain)) existing.coveredBy.push(domain);
+        } else {
+          gaps.push({ topic, coveredBy: [domain] });
+        }
+      }
+    }
+  }
+
+  return { gaps, depthGaps };
+}
+
+// ── LLM gap prioritisation ──────────────────────────────────────────────────
+
+async function prioritiseGaps(gaps, targetDomain, context, ollamaUrl, ollamaModel, log) {
+  if (!gaps.length) return [];
+
+  const gapList = gaps.slice(0, 40).map(g =>
+    `- ${g.topic} (covered by: ${g.coveredBy.join(', ')})`
+  ).join('\n');
+
+  const prompt = `Target site: ${targetDomain} (${context || 'business website'})
+Topics competitors cover that the target project lacks:
+
+${gapList}
+
+For each gap, return a markdown table row with these columns:
+| Topic | Covered by | Buyer Intent | Page Type | Why It Matters |
+
+Buyer Intent: high, medium, or low
+Page Type: guide, reference, landing, blog, or comparison
+Why It Matters: one sentence on SEO or sales impact
+
+Return ONLY the markdown table rows (no header, no explanation).
+Sort by buyer intent (high first).`;
+
+  try {
+    const res = await fetch(`${ollamaUrl}/api/generate`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model: ollamaModel,
+        prompt,
+        stream: false,
+        options: { temperature: 0.2, num_ctx: 8192 },
+      }),
+    });
+
+    if (!res.ok) throw new Error(`Ollama ${res.status}`);
+    const data = await res.json();
+    return (data.response || '').split('\n').filter(l => l.trim().startsWith('|'));
+  } catch (e) {
+    log(`  ⚠️ LLM prioritisation failed: ${e.message}`);
+    return null; // Fall back to raw output
+  }
+}
+
+// ── Generate report ─────────────────────────────────────────────────────────
+
+function generateReport(data) {
+  const { targetDomain, competitorDomainNames, targetTopics, competitorTopicsMap, gaps, prioritisedRows, pageData } = data;
+  const ts = new Date().toISOString().slice(0, 10);
+
+  let md = `# Gap Intel Report — ${targetDomain} vs ${competitorDomainNames.join(', ')}\n`;
+  md += `Generated: ${ts} | Pages analyzed: ${targetDomain}(${pageData.target.length})`;
+  for (const [dom, pages] of pageData.competitors) {
+    md += ` ${dom}(${pages.length})`;
+  }
+  md += '\n\n';
+
+  // Prioritised gaps
+  if (prioritisedRows && prioritisedRows.length) {
+    const high = prioritisedRows.filter(r => r.toLowerCase().includes('high'));
+    const medium = prioritisedRows.filter(r => r.toLowerCase().includes('medium'));
+    const low = prioritisedRows.filter(r => !r.toLowerCase().includes('high') && !r.toLowerCase().includes('medium'));
+
+    if (high.length) {
+      md += `## 🔴 High Priority Gaps\n\n`;
+      md += `| Topic | Covered by | Buyer Intent | Page Type | Why It Matters |\n`;
+      md += `|-------|-----------|--------------|-----------|----------------|\n`;
+      md += high.join('\n') + '\n\n';
+    }
+    if (medium.length) {
+      md += `## 🟡 Medium Priority Gaps\n\n`;
+      md += `| Topic | Covered by | Buyer Intent | Page Type | Why It Matters |\n`;
+      md += `|-------|-----------|--------------|-----------|----------------|\n`;
+      md += medium.join('\n') + '\n\n';
+    }
+    if (low.length) {
+      md += `## 🟢 Lower Priority Gaps\n\n`;
+      md += `| Topic | Covered by | Buyer Intent | Page Type | Why It Matters |\n`;
+      md += `|-------|-----------|--------------|-----------|----------------|\n`;
+      md += low.join('\n') + '\n\n';
+    }
+  } else {
+    // Raw gaps (LLM failed or --raw mode)
+    if (gaps.length) {
+      md += `## Content Gaps\n\n`;
+      md += `| Topic | Covered by |\n`;
+      md += `|-------|-----------|\n`;
+      for (const g of gaps) {
+        md += `| ${g.topic} | ${g.coveredBy.join(', ')} |\n`;
+      }
+      md += '\n';
+    } else {
+      md += `> No significant gaps found — target covers all competitor topics.\n\n`;
+    }
+  }
+
+  // Raw topic matrix
+  md += `## Raw Topic Matrix\n\n`;
+  md += `### ${targetDomain} (${targetTopics.length} topics)\n`;
+  for (const t of targetTopics.slice(0, 50)) md += `- ${t}\n`;
+  if (targetTopics.length > 50) md += `- ... and ${targetTopics.length - 50} more\n`;
+  md += '\n';
+
+  for (const [dom, topics] of competitorTopicsMap) {
+    md += `### ${dom} (${topics.length} topics)\n`;
+    for (const t of topics.slice(0, 50)) md += `- ${t}\n`;
+    if (topics.length > 50) md += `- ... and ${topics.length - 50} more\n`;
+    md += '\n';
+  }
+
+  return md;
+}
+
+// ── Main entry point ─────────────────────────────────────────────────────────
+
+/**
+ * Run gap-intel analysis.
+ *
+ * @param {import('node:sqlite').DatabaseSync} db
+ * @param {string} project
+ * @param {object} config - project config with context
+ * @param {object} opts
+ * @param {string[]} [opts.vs] - competitor domains to compare (default: all from config)
+ * @param {string} [opts.type] - page type filter: docs, blog, landing, all
+ * @param {number} [opts.limit] - max pages per domain
+ * @param {boolean} [opts.raw] - skip LLM prioritisation
+ * @param {string} [opts.ollamaUrl] - Ollama host
+ * @param {string} [opts.ollamaModel] - Ollama model
+ * @param {function} [opts.log] - logger function
+ * @returns {Promise<string>} markdown report
+ */
+export async function runGapIntel(db, project, config, opts = {}) {
+  const log = opts.log || console.log;
+  const ollamaUrl = opts.ollamaUrl || process.env.OLLAMA_URL || 'http://localhost:11434';
+  const ollamaModel = opts.ollamaModel || process.env.OLLAMA_MODEL || 'gemma4:e4b';
+  const type = opts.type || 'all';
+  const limit = opts.limit || 100;
+  const raw = opts.raw || false;
+  const vsDomains = opts.vs || [];
+
+  log('  Loading pages from DB...');
+  const pageData = loadPages(db, project, { type, limit, vsDomains });
+
+  if (!pageData.target.length) {
+    return `# Gap Intel — ${project}\n\n> ⚠️ No pages with body_text found for target.\n> Run: seo-intel crawl ${project}\n`;
+  }
+
+  if (!pageData.competitors.size) {
+    return `# Gap Intel — ${project}\n\n> ⚠️ No competitor pages found in DB.\n> Check project config competitors and run: seo-intel crawl ${project}\n`;
+  }
+
+  log(`  Target: ${pageData.targetDomain} (${pageData.target.length} pages)`);
+  for (const [dom, pages] of pageData.competitors) {
+    log(`  Competitor: ${dom} (${pages.length} pages)`);
+  }
+
+  // Step 2 — Extract topics
+  log('\n  Extracting topics via LLM...');
+  const targetTopics = await extractTopics(pageData.target, pageData.targetDomain, ollamaUrl, ollamaModel, log);
+
+  const competitorTopicsMap = new Map();
+  for (const [dom, pages] of pageData.competitors) {
+    const topics = await extractTopics(pages, dom, ollamaUrl, ollamaModel, log);
+    competitorTopicsMap.set(dom, topics);
+  }
+
+  // Step 3 — Compare coverage
+  log('\n  Comparing topic coverage...');
+  const { gaps } = compareTopics(targetTopics, competitorTopicsMap);
+  log(`  Found ${gaps.length} topic gaps`);
+
+  // Step 4 — LLM prioritisation (unless --raw)
+  let prioritisedRows = null;
+  if (!raw && gaps.length) {
+    log('\n  Prioritising gaps via LLM...');
+    const context = config?.context?.industry || config?.context?.goal || '';
+    prioritisedRows = await prioritiseGaps(gaps, pageData.targetDomain, context, ollamaUrl, ollamaModel, log);
+  }
+
+  // Step 5 — Generate report
+  return generateReport({
+    targetDomain: pageData.targetDomain,
+    competitorDomainNames: [...pageData.competitors.keys()],
+    targetTopics,
+    competitorTopicsMap,
+    gaps,
+    prioritisedRows,
+    pageData,
+  });
+}

package/cli.js

@@ -68,24 +68,24 @@ function defaultSiteUrl(domain) {
 
 function resolveExtractionRuntime(config) {
   const primaryUrl = config?.crawl?.ollamaHost || process.env.OLLAMA_URL || 'http://localhost:11434';
-  const primaryModel = config?.crawl?.extractionModel || process.env.OLLAMA_MODEL || 'qwen3:4b';
+  const primaryModel = config?.crawl?.extractionModel || process.env.OLLAMA_MODEL || 'gemma4:e4b';
   const fallbackUrl = process.env.OLLAMA_FALLBACK_URL || '';
   const fallbackModel = process.env.OLLAMA_FALLBACK_MODEL || primaryModel;
   const localhost = 'http://localhost:11434';
 
   const candidates = [
-    { host: String(primaryUrl).trim().replace(/\/+$/, ''), model: String(primaryModel).trim() || 'qwen3:4b' },
+    { host: String(primaryUrl).trim().replace(/\/+$/, ''), model: String(primaryModel).trim() || 'gemma4:e4b' },
   ];
 
   if (fallbackUrl) {
     candidates.push({
       host: String(fallbackUrl).trim().replace(/\/+$/, ''),
-      model: String(fallbackModel).trim() || String(primaryModel).trim() || 'qwen3:4b',
+      model: String(fallbackModel).trim() || String(primaryModel).trim() || 'gemma4:e4b',
     });
   }
 
   if (!candidates.some(candidate => candidate.host === localhost)) {
-    candidates.push({ host: localhost, model: String(primaryModel).trim() || 'qwen3:4b' });
+    candidates.push({ host: localhost, model: String(primaryModel).trim() || 'gemma4:e4b' });
   }
 
   const seen = new Set();
@@ -134,8 +134,8 @@ async function checkOllamaAvailability(config) {
 
   if (sawReachableHost) {
     const primary = candidates[0];
-    console.log(chalk.yellow(`  ⚠️  Ollama is reachable but model "${primary?.model || 'qwen3:4b'}" was not found on any live host`));
-    console.log(chalk.dim(`  Run: ollama pull ${primary?.model || 'qwen3:4b'}`));
+    console.log(chalk.yellow(`  ⚠️  Ollama is reachable but model "${primary?.model || 'gemma4:e4b'}" was not found on any live host`));
+    console.log(chalk.dim(`  Run: ollama pull ${primary?.model || 'gemma4:e4b'}`));
   }
 
   return false;
@@ -474,7 +474,7 @@ program
       if (!ollamaAvailable) {
         console.log(chalk.yellow('\n  ⚠️  No AI extraction available (Ollama unreachable, no API keys configured)'));
         console.log(chalk.white('  → Switching to ') + chalk.bold.green('crawl-only mode') + chalk.white(' — raw data will be collected without AI extraction'));
-        console.log(chalk.dim('  Tip: Install Ollama (ollama.com) + run `ollama pull qwen3:4b` to enable local AI extraction\n'));
+        console.log(chalk.dim('  Tip: Install Ollama (ollama.com) + run `ollama pull gemma4:e4b` to enable local AI extraction\n'));
         opts.extract = false;
       }
     }
@@ -4069,6 +4069,54 @@ program
     }
   });
 
+// ── GAP INTEL ────────────────────────────────────────────────────────────
+
+program
+  .command('gap-intel <project>')
+  .description('Topic/content gap analysis — find what competitors cover that you don\'t')
+  .option('--vs <domains>', 'Competitor domains to compare (comma-separated)')
+  .option('--type <type>', 'Page type filter: docs, blog, landing, all', 'all')
+  .option('--limit <n>', 'Max pages per domain', '100')
+  .option('--raw', 'Skip LLM prioritisation, output raw topic matrix only')
+  .option('--format <type>', 'Output format: markdown or json', 'markdown')
+  .option('--out <path>', 'Write report to file (default: stdout)')
+  .action(async (project, opts) => {
+    if (!requirePro('gap-intel')) return;
+    const db = getDb();
+    const config = loadConfig(project);
+
+    printAttackHeader('🔍 Gap Intel — Topic Gap Analysis', project);
+
+    const { runGapIntel } = await import('./analyses/gap-intel/index.js');
+
+    const vsDomains = opts.vs ? opts.vs.split(',').map(s => s.trim()) : [];
+
+    const report = await runGapIntel(db, project, config, {
+      vs: vsDomains,
+      type: opts.type,
+      limit: parseInt(opts.limit, 10) || 100,
+      raw: opts.raw || false,
+      log: (msg) => console.log(chalk.gray(msg)),
+    });
+
+    if (opts.format === 'markdown') {
+      console.log(report);
+    } else {
+      console.log(report);
+    }
+
+    if (opts.out) {
+      writeFileSync(opts.out, report, 'utf8');
+      console.log(chalk.green(`\n  ✅ Report saved: ${opts.out}\n`));
+    }
+
+    // Regenerate dashboard
+    try {
+      const configs = loadAllConfigs();
+      generateMultiDashboard(db, configs);
+    } catch {}
+  });
+
 // ── AEO BLOG DRAFT GENERATOR ─────────────────────────────────────────────
 
 let _blogDraftModule;
@@ -4266,7 +4314,7 @@ program
           'Optionally saves Gemini/OpenAI API key to .env',
           hasOllama && hasAnalysisKey ? chalk.green('  → You\'re fully set up!') :
           hasOllama ? chalk.yellow('  → Add an API key for analysis: edit .env') :
-          chalk.yellow('  → Install Ollama: https://ollama.com  then: ollama pull qwen3:4b'),
+          chalk.yellow('  → Install Ollama: https://ollama.com  then: ollama pull gemma4:e4b'),
         ].filter(Boolean),
       },
       {

package/config/setup-wizard.js

@@ -265,7 +265,7 @@ async function run() {
   } else {
     warn('No Ollama available. Extraction will use degraded mode (regex only).');
     info('Install Ollama (https://ollama.com) and pull a model for better results.');
-    info('Recommended: ollama pull qwen3.5:9b');
+    info('Recommended: ollama pull gemma4:e4b');
   }
 
   // ── Analysis tier ──

package/extractor/qwen.js

@@ -1,7 +1,7 @@
 import fetch from 'node-fetch';
 
 const DEFAULT_OLLAMA_URL = 'http://localhost:11434';
-const DEFAULT_OLLAMA_MODEL = 'qwen3:4b';
+const DEFAULT_OLLAMA_MODEL = 'gemma4:e4b';
 const OLLAMA_CTX = parseInt(process.env.OLLAMA_CTX || '8192', 10);
 const OLLAMA_TIMEOUT_MS = parseInt(process.env.OLLAMA_TIMEOUT_MS || '60000', 10); // BUG-008: was 5000ms, too short for slow machines
 const OLLAMA_PREFLIGHT_TIMEOUT_MS = parseInt(process.env.OLLAMA_PREFLIGHT_TIMEOUT_MS || '2500', 10);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "seo-intel",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "description": "Local Ahrefs-style SEO competitor intelligence. Crawl → SQLite → cloud analysis.",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE",

package/server.js

@@ -596,7 +596,7 @@ async function handleRequest(req, res) {
     const ALLOWED = ['crawl', 'extract', 'analyze', 'export-actions', 'competitive-actions',
       'suggest-usecases', 'html', 'status', 'brief', 'keywords', 'report', 'guide',
       'schemas', 'headings-audit', 'orphans', 'entities', 'friction', 'shallow', 'decay', 'export', 'templates',
-      'aeo', 'blog-draft'];
+      'aeo', 'blog-draft', 'gap-intel'];
 
     if (!command || !ALLOWED.includes(command)) {
       json(res, 400, { error: `Invalid command. Allowed: ${ALLOWED.join(', ')}` });
@@ -613,6 +613,11 @@ async function handleRequest(req, res) {
     if (params.get('lang')) args.push('--lang', params.get('lang'));
     if (params.get('model')) args.push('--model', params.get('model'));
     if (params.has('save')) args.push('--save');
+    if (params.get('vs')) args.push('--vs', params.get('vs'));
+    if (params.get('type')) args.push('--type', params.get('type'));
+    if (params.get('limit')) args.push('--limit', params.get('limit'));
+    if (params.has('raw')) args.push('--raw');
+    if (params.get('out')) args.push('--out', params.get('out'));
 
     // Auto-save exports from dashboard to reports/
     const EXPORT_CMDS = ['export-actions', 'suggest-usecases', 'competitive-actions'];

package/setup/installers.js

@@ -148,7 +148,7 @@ export function* createEnvFile(rootDir = ROOT) {
       '',
       '# Local Ollama for extraction',
       'OLLAMA_URL=http://localhost:11434',
-      'OLLAMA_MODEL=qwen3.5:9b',
+      'OLLAMA_MODEL=gemma4:e4b',
       'OLLAMA_CTX=8192',
       '',
       '# Crawler settings',

package/setup/models.js

@@ -17,6 +17,56 @@
 //   Minimum viable: 4B parameters for reliable JSON output
 
 export const EXTRACTION_MODELS = [
+  // ── Gemma 4 (Google, MoE) — new recommended default ──
+  {
+    id: 'gemma4:e2b',
+    name: 'Gemma 4 E2B',
+    family: 'gemma4',
+    tier: 'budget',
+    vram: '~5 GB',
+    minVramMB: 4000,
+    speed: '~1.5s/page',
+    quality: 'good',
+    description: 'Google Gemma 4 edge model. MoE (5.1B total, 2.3B active) — fast inference with good JSON output. Great for laptops.',
+    recommended: false,
+  },
+  {
+    id: 'gemma4:e4b',
+    name: 'Gemma 4 E4B',
+    family: 'gemma4',
+    tier: 'balanced',
+    vram: '~7 GB',
+    minVramMB: 5500,
+    speed: '~2s/page',
+    quality: 'great',
+    description: 'Default recommendation. MoE (8B total, 4.5B active) — excellent extraction quality at edge-model speed. Best quality/speed ratio.',
+    recommended: true,
+  },
+  {
+    id: 'gemma4:26b',
+    name: 'Gemma 4 26B',
+    family: 'gemma4',
+    tier: 'quality',
+    vram: '~13 GB',
+    minVramMB: 11000,
+    speed: '~4s/page',
+    quality: 'excellent',
+    description: 'MoE (25.2B total, 3.8B active) — frontier quality at efficient compute. Needs RTX 3090+ or M-series with 16GB+.',
+    recommended: false,
+  },
+  {
+    id: 'gemma4:31b',
+    name: 'Gemma 4 31B (Dense)',
+    family: 'gemma4',
+    tier: 'power',
+    vram: '~20 GB',
+    minVramMB: 16000,
+    speed: '~7s/page',
+    quality: 'excellent',
+    description: 'Dense 30.7B model — maximum extraction quality. Needs RTX 3090/4090 or M2 Pro+ with 24GB+.',
+    recommended: false,
+  },
+  // ── Qwen 3.5 (Alibaba) ──
   {
     id: 'qwen3.5:4b',
     name: 'Qwen 3.5 4B',
@@ -26,7 +76,7 @@ export const EXTRACTION_MODELS = [
     minVramMB: 2500,
     speed: '~2s/page',
     quality: 'good',
-    description: 'Minimum recommended. Reliable JSON extraction, decent keyword detection. Great for laptops and older GPUs.',
+    description: 'Reliable JSON extraction, decent keyword detection. Great for laptops and older GPUs.',
     recommended: false,
   },
   {
@@ -38,8 +88,8 @@ export const EXTRACTION_MODELS = [
     minVramMB: 4500,
     speed: '~3s/page',
     quality: 'better',
-    description: 'Default recommendation. Better entity detection and intent classification. Works on most modern GPUs.',
-    recommended: true,
+    description: 'Good entity detection and intent classification. Works on most modern GPUs.',
+    recommended: false,
   },
   {
     id: 'qwen3.5:27b',
@@ -62,10 +112,10 @@ export const EXTRACTION_MODELS = [
     minVramMB: 18000,
     speed: '~8s/page',
     quality: 'excellent',
-    description: 'Near-cloud quality extraction. Needs RTX 3090/4090 or M2 Ultra. Overkill for most users.',
+    description: 'Near-cloud quality extraction. Needs RTX 3090/4090 or M2 Ultra.',
     recommended: false,
   },
-  // Alternative providers
+  // ── Alternative providers ──
   {
     id: 'nemotron-nano:4b',
     name: 'Nemotron 3 Nano 4B',
@@ -78,7 +128,7 @@ export const EXTRACTION_MODELS = [
     description: 'NVIDIA agentic model. Efficient extraction with tool-use training. Good alternative to Qwen 3.5 4B.',
     recommended: false,
   },
-  // Legacy / fallback models (already installed by many users)
+  // ── Legacy / fallback models (already installed by many users) ──
   {
     id: 'qwen3:4b',
     name: 'Qwen 3 4B (legacy)',
@@ -88,7 +138,7 @@ export const EXTRACTION_MODELS = [
     minVramMB: 2500,
     speed: '~2s/page',
     quality: 'good',
-    description: 'Previous generation. Works well but Qwen 3.5 is better if you can upgrade.',
+    description: 'Previous generation. Gemma 4 or Qwen 3.5 recommended for new installs.',
     recommended: false,
     legacy: true,
   },
@@ -101,7 +151,7 @@ export const EXTRACTION_MODELS = [
     minVramMB: 4500,
     speed: '~3s/page',
     quality: 'better',
-    description: 'Previous generation. Solid extraction. Qwen 3.5 recommended for new installs.',
+    description: 'Previous generation. Gemma 4 or Qwen 3.5 recommended for new installs.',
     recommended: false,
     legacy: true,
   },
@@ -117,6 +167,32 @@ export const EXTRACTION_MODELS = [
 //   Cloud models (Claude, GPT-5.4, Gemini) available via OpenClaw agent setup
 
 export const ANALYSIS_MODELS = [
+  {
+    id: 'gemma4:26b',
+    name: 'Gemma 4 26B (MoE)',
+    family: 'gemma4',
+    type: 'local',
+    vram: '~13 GB',
+    minVramMB: 11000,
+    context: '128K tokens',
+    costNote: 'Free (your GPU)',
+    quality: 'great',
+    recommended: true,
+    description: 'Google Gemma 4 MoE — 25.2B total, 3.8B active. Fast analysis with frontier quality. Best local value.',
+  },
+  {
+    id: 'gemma4:31b',
+    name: 'Gemma 4 31B (Dense)',
+    family: 'gemma4',
+    type: 'local',
+    vram: '~20 GB',
+    minVramMB: 16000,
+    context: '128K tokens',
+    costNote: 'Free (your GPU)',
+    quality: 'excellent',
+    recommended: false,
+    description: 'Google Gemma 4 dense model — maximum quality for local analysis. Needs RTX 3090+ or M2 Pro+ with 24GB.',
+  },
   {
     id: 'qwen3:14b',
     name: 'Qwen 3 14B',
@@ -140,8 +216,8 @@ export const ANALYSIS_MODELS = [
     context: '32K tokens',
     costNote: 'Free (your GPU)',
     quality: 'good',
-    recommended: true,
-    description: 'Sweet spot for local analysis. Strong reasoning with 27.8B params. Needs RTX 3090/4080+ or M-series with 24GB+.',
+    recommended: false,
+    description: 'Strong reasoning with 27.8B params. Needs RTX 3090/4080+ or M-series with 24GB+.',
   },
   {
     id: 'qwen3.5:35b',
@@ -228,12 +304,13 @@ export const ANALYSIS_MODELS = [
 // ── VRAM-Based Recommendations ──────────────────────────────────────────────
 
 const VRAM_TIERS = [
-  { maxMB: 2500,  extraction: null,          note: 'Not enough VRAM for local extraction. Use cloud or CPU mode (slow).' },
-  { maxMB: 4500,  extraction: 'qwen3.5:4b',  note: 'Budget tier — Qwen 3.5 4B fits your GPU.' },
-  { maxMB: 8000,  extraction: 'qwen3.5:9b',  note: 'Balanced tier — Qwen 3.5 9B recommended for best quality/speed.' },
-  { maxMB: 18000, extraction: 'qwen3.5:27b', note: 'Quality tier — Qwen 3.5 27B for nuanced extraction.' },
-  { maxMB: 48000, extraction: 'qwen3.5:35b', note: 'Power tier — Qwen 3.5 35B for near-cloud quality.' },
-  { maxMB: Infinity, extraction: 'qwen3.5:35b', note: 'Power tier — Qwen 3.5 35B recommended. Your GPU can handle anything.' },
+  { maxMB: 2500,  extraction: null,           note: 'Not enough VRAM for local extraction. Use cloud or CPU mode (slow).' },
+  { maxMB: 4500,  extraction: 'qwen3.5:4b',   note: 'Budget tier — Qwen 3.5 4B fits your GPU.' },
+  { maxMB: 6000,  extraction: 'gemma4:e2b',   note: 'Edge tier — Gemma 4 E2B (MoE, fast).' },
+  { maxMB: 12000, extraction: 'gemma4:e4b',   note: 'Balanced tier — Gemma 4 E4B recommended. MoE gives best quality/speed.' },
+  { maxMB: 18000, extraction: 'gemma4:26b',   note: 'Quality tier — Gemma 4 26B MoE for frontier extraction.' },
+  { maxMB: 48000, extraction: 'gemma4:31b',   note: 'Power tier — Gemma 4 31B Dense for maximum quality.' },
+  { maxMB: Infinity, extraction: 'gemma4:31b', note: 'Power tier — Gemma 4 31B Dense recommended. Your GPU can handle anything.' },
 ];
 
 /**
@@ -250,8 +327,9 @@ export function recommendExtractionModel(availableModels = [], vramMB = 0) {
 
   // Preferred model order (newest → legacy)
   const preferenceOrder = [
+    'gemma4:e4b', 'gemma4:26b', 'gemma4:e2b', 'gemma4:31b',
     'qwen3.5:9b', 'qwen3.5:27b', 'qwen3.5:4b', 'qwen3.5:35b',
-    'qwen3:8b', 'qwen3:4b', 'qwen3.5:0.6b',
+    'qwen3:8b', 'qwen3:4b',
   ];
 
   // Filter to models that fit VRAM
@@ -310,7 +388,7 @@ export function recommendExtractionModel(availableModels = [], vramMB = 0) {
  */
 export function recommendAnalysisModel(availableModels = [], vramMB = 0) {
   const preferenceOrder = [
-    'qwen3.5:27b', 'qwen3.5:35b', 'qwen3:14b', 'nemotron-3-super:120b',
+    'gemma4:26b', 'gemma4:31b', 'qwen3.5:27b', 'qwen3.5:35b', 'qwen3:14b', 'nemotron-3-super:120b',
   ];
 
   // Filter to models that fit VRAM
@@ -332,8 +410,9 @@ export function recommendAnalysisModel(availableModels = [], vramMB = 0) {
   // 2. VRAM-based recommendation
   let recId = 'qwen3:14b'; // default minimum
   if (vramMB >= 48000) recId = 'nemotron-3-super:120b';
-  else if (vramMB >= 18000) recId = 'qwen3.5:35b';
-  else if (vramMB >= 15000) recId = 'qwen3.5:27b';
+  else if (vramMB >= 16000) recId = 'gemma4:31b';
+  else if (vramMB >= 11000) recId = 'gemma4:26b';
+  else if (vramMB >= 8000) recId = 'qwen3:14b';
 
   const recModel = ANALYSIS_MODELS.find(m => m.id === recId);
   if (recModel) {

package/setup/openclaw-bridge.js

@@ -188,7 +188,7 @@ AVAILABLE COMMANDS (run these from ${ROOT}):
 TO INSTALL THINGS:
 - npm install (in ${ROOT}) → install Node dependencies
 - npx playwright install chromium → install browser
-- ollama pull qwen3.5:9b → install extraction model
+- ollama pull gemma4:e4b → install extraction model
 
 TO CONFIGURE:
 - Edit ${ROOT}/.env for API keys and settings
@@ -201,9 +201,10 @@ ANALYSIS MODELS (user needs at least one API key):
 - DeepSeek: Budget option (~$0.02-0.08) → DEEPSEEK_API_KEY
 
 EXTRACTION MODELS (local, free):
-- qwen3.5:9b (recommended, needs 6GB+ VRAM)
-- qwen3.5:4b (budget, needs 3GB+ VRAM)
-- qwen3.5:27b (quality, needs 16GB+ VRAM)`;
+- gemma4:e4b (recommended, MoE, needs 6GB+ VRAM)
+- gemma4:e2b (budget, MoE, needs 4GB+ VRAM)
+- gemma4:26b (quality, MoE, needs 12GB+ VRAM)
+- qwen3.5:9b (alternative, needs 5GB+ VRAM)`;
 
 // ── Agent-Driven Setup Flow ────────────────────────────────────────────────
 

package/setup/validator.js

@@ -21,7 +21,7 @@ const ROOT = join(__dirname, '..');
  * Test Ollama host + model by sending a tiny prompt.
  *
  * @param {string} host - e.g. 'http://localhost:11434'
- * @param {string} model - e.g. 'qwen3.5:9b'
+ * @param {string} model - e.g. 'gemma4:e4b'
  * @returns {{ success: boolean, latencyMs: number, response?: string, error?: string }}
  */
 export async function testOllamaConnectivity(host, model) {

package/setup/wizard.html

@@ -1359,7 +1359,7 @@ Start by checking what's already installed.</div>
 Tasks:
 1. Verify Node.js 22.5+ (install via nvm if needed)
 2. Install Ollama (https://ollama.com) if not present
-3. Pull qwen3.5:9b or smaller if VRAM < 6GB
+3. Pull gemma4:e4b or smaller if VRAM < 6GB
 4. Create ./config/myproject.json — ask me for my target domain and up to 3 competitor domains
 5. Add GEMINI_API_KEY or ANTHROPIC_API_KEY to .env if I have one
 6. Run: seo-intel crawl myproject
@@ -1380,7 +1380,7 @@ It's installed via: npm install -g seo-intel
 Please help me:
 1. Check that Node.js 22.5+ is installed on my machine
 2. Install Ollama (ollama.com) if it's not there
-3. Download a Qwen AI model that fits my machine's RAM
+3. Download a Gemma 4 AI model that fits my machine's RAM
 4. Create a project config file pointing at my website and competitors
 5. Run the first crawl and show me the results
 
@@ -1403,15 +1403,15 @@ Ask me for my website URL before starting.</div>
           <button class="btn btn-sm agent-runtime-tab-min" data-runtime="openclaw" onclick="selectAgentRuntimeMin('openclaw', this)" style="font-size:0.62rem;"><i class="fa-solid fa-wand-magic-sparkles" style="margin-right:3px;"></i>OpenClaw</button>
         </div>
         <div id="minRuntime-claudecode" class="min-runtime-panel" style="position:relative; padding:7px 9px; background:rgba(10,10,10,0.5); border:1px solid var(--border-subtle); border-radius:var(--radius); font-family:var(--font-mono); font-size:0.6rem; color:var(--text-secondary); line-height:1.5;">
-          <div>Set up seo-intel: check Node 22.5+, install Ollama, pull qwen3.5:9b, create config, run crawl.</div>
+          <div>Set up seo-intel: check Node 22.5+, install Ollama, pull gemma4:e4b, create config, run crawl.</div>
           <button class="btn btn-sm" style="position:absolute; top:4px; right:4px; padding:2px 5px; font-size:0.48rem;" onclick="navigator.clipboard.writeText(this.previousElementSibling.textContent.trim());this.textContent='Copied!';setTimeout(()=>this.textContent='Copy',1500);">Copy</button>
         </div>
         <div id="minRuntime-codex" class="min-runtime-panel" style="display:none; position:relative; padding:7px 9px; background:rgba(10,10,10,0.5); border:1px solid var(--border-subtle); border-radius:var(--radius); font-family:var(--font-mono); font-size:0.6rem; color:var(--text-secondary); line-height:1.5;">
-          <div>Install seo-intel deps (Node 22.5+, Ollama, qwen3.5:9b), create project config, run: seo-intel crawl myproject. Use full disk access.</div>
+          <div>Install seo-intel deps (Node 22.5+, Ollama, gemma4:e4b), create project config, run: seo-intel crawl myproject. Use full disk access.</div>
           <button class="btn btn-sm" style="position:absolute; top:4px; right:4px; padding:2px 5px; font-size:0.48rem;" onclick="navigator.clipboard.writeText(this.previousElementSibling.textContent.trim());this.textContent='Copied!';setTimeout(()=>this.textContent='Copy',1500);">Copy</button>
         </div>
         <div id="minRuntime-perplexity" class="min-runtime-panel" style="display:none; position:relative; padding:7px 9px; background:rgba(10,10,10,0.5); border:1px solid var(--border-subtle); border-radius:var(--radius); font-family:var(--font-mono); font-size:0.6rem; color:var(--text-secondary); line-height:1.5;">
-          <div>Help me set up SEO Intel local SEO tool: install Node.js 22.5+, Ollama, download a Qwen model, create config for my website. Ask for my URL.</div>
+          <div>Help me set up SEO Intel local SEO tool: install Node.js 22.5+, Ollama, download Gemma 4 model, create config for my website. Ask for my URL.</div>
           <button class="btn btn-sm" style="position:absolute; top:4px; right:4px; padding:2px 5px; font-size:0.48rem;" onclick="navigator.clipboard.writeText(this.previousElementSibling.textContent.trim());this.textContent='Copied!';setTimeout(()=>this.textContent='Copy',1500);">Copy</button>
         </div>
         <div id="minRuntime-openclaw" class="min-runtime-panel" style="display:none; position:relative; padding:7px 9px; background:rgba(10,10,10,0.5); border:1px solid var(--border-subtle); border-radius:var(--radius); font-family:var(--font-mono); font-size:0.6rem; color:var(--text-secondary); line-height:1.5;">