ship-safe 6.4.0 → 7.0.0

package/cli/bin/ship-safe.js

@@ -47,6 +47,7 @@ import { abomCommand } from '../commands/abom.js';
 import { updateIntelCommand } from '../commands/update-intel.js';
 import { hooksCommand } from '../commands/hooks.js';
 import { legalCommand } from '../commands/legal.js';
+import { runLiveAdvisories } from '../commands/live-advisories.js';
 import { ABOMGenerator } from '../agents/abom-generator.js';
 import { PolicyEngine } from '../agents/policy-engine.js';
 import { SBOMGenerator } from '../agents/sbom-generator.js';
@@ -268,8 +269,60 @@ program
   .description('Continuous monitoring: watch files for security issues in real-time')
   .option('--poll', 'Use polling mode (for network drives)')
   .option('--configs', 'Watch only agent config files (openclaw.json, .cursorrules, mcp.json, etc.)')
+  .option('--deep', 'Run full agent scanning on changes (not just pattern matching)')
+  .option('--status', 'Show current watch status and exit')
+  .option('--threshold <score>', 'Alert when score drops below threshold', parseInt)
+  .option('--debounce <ms>', 'Debounce interval in ms (default: 1500)', parseInt)
   .action(watchCommand);
 
+// -----------------------------------------------------------------------------
+// ADVISORIES COMMAND
+// -----------------------------------------------------------------------------
+program
+  .command('advisories [path]')
+  .description('Check dependencies against live advisory feeds (OSV.dev, GitHub Advisories)')
+  .option('--ecosystem <type>', 'Filter by ecosystem (npm, PyPI)')
+  .option('--json', 'Output as JSON')
+  .action(async (targetPath = '.', options) => {
+    const { resolve } = await import('path');
+    const absolutePath = resolve(targetPath);
+    try {
+      const result = await runLiveAdvisories(absolutePath, options);
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+      console.log();
+      console.log(chalk.cyan.bold('  Ship Safe — Live Advisories'));
+      console.log(chalk.gray(`  Checked ${result.checked} dependencies against OSV.dev`));
+      console.log();
+      if (result.advisories.length === 0) {
+        console.log(chalk.green('  ✔ No known advisories for your current dependency versions.\n'));
+      } else {
+        const malware = result.advisories.filter(a => a.isMalware);
+        const vulns = result.advisories.filter(a => !a.isMalware);
+        if (malware.length > 0) {
+          console.log(chalk.red.bold(`  !! ${malware.length} MALWARE ADVISORY(S) FOUND`));
+          for (const a of malware) {
+            console.log(chalk.red(`     ${a.package}@${a.version} — ${a.id}: ${a.summary.slice(0, 80)}`));
+          }
+          console.log();
+        }
+        if (vulns.length > 0) {
+          console.log(chalk.yellow(`  ${vulns.length} vulnerability advisory(s):`));
+          for (const a of vulns) {
+            const sev = a.severity === 'critical' ? chalk.red.bold(a.severity) : a.severity === 'high' ? chalk.yellow(a.severity) : chalk.blue(a.severity);
+            console.log(`    ${sev} ${a.package}@${a.version} — ${a.id}`);
+          }
+          console.log();
+        }
+      }
+    } catch (err) {
+      console.error(chalk.red(`  Error: ${err.message}\n`));
+      process.exit(1);
+    }
+  });
+
 // -----------------------------------------------------------------------------
 // SBOM COMMAND
 // -----------------------------------------------------------------------------

package/cli/commands/live-advisories.js

@@ -0,0 +1,241 @@
+/**
+ * Live Advisory Feed
+ * ===================
+ *
+ * Queries the GitHub Advisory Database and OSV.dev API for real-time
+ * advisories on your exact dependency versions. Unlike static CVE checks,
+ * this catches actively-compromised packages (Axios 1.8.2, LiteLLM 1.82.7)
+ * within hours of publication.
+ *
+ * USAGE:
+ *   ship-safe advisories .              # Check npm + PyPI deps
+ *   ship-safe advisories . --ecosystem npm
+ *   ship-safe advisories . --json
+ *
+ * APIs used:
+ *   - OSV.dev (https://api.osv.dev) — aggregates GitHub Advisories, PyPI, npm
+ *   - No API key needed — fully open, rate-limited to 1000 req/min
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+// =============================================================================
+// DEPENDENCY EXTRACTION
+// =============================================================================
+
+/**
+ * Extract package names + versions from project manifests.
+ * Returns: [{ name, version, ecosystem, file }]
+ */
+export function extractDependencies(rootPath) {
+  const deps = [];
+
+  // npm / Node.js
+  const pkgPath = path.join(rootPath, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+      const allDeps = {
+        ...(pkg.dependencies || {}),
+        ...(pkg.devDependencies || {}),
+      };
+      for (const [name, versionRange] of Object.entries(allDeps)) {
+        // Strip semver prefix (^, ~, >=)
+        const version = String(versionRange).replace(/^[\^~>=<]+/, '').trim();
+        if (/^\d/.test(version)) {
+          deps.push({ name, version, ecosystem: 'npm', file: pkgPath });
+        }
+      }
+    } catch { /* skip */ }
+  }
+
+  // Also check package-lock.json for pinned versions (more accurate)
+  const lockPath = path.join(rootPath, 'package-lock.json');
+  if (fs.existsSync(lockPath)) {
+    try {
+      const lock = JSON.parse(fs.readFileSync(lockPath, 'utf-8'));
+      const packages = lock.packages || {};
+      for (const [pkgKey, info] of Object.entries(packages)) {
+        if (!pkgKey || pkgKey === '') continue; // root entry
+        const name = pkgKey.replace(/^node_modules\//, '');
+        if (info.version && /^\d/.test(info.version)) {
+          // Only add if not already present from package.json
+          if (!deps.find(d => d.name === name && d.ecosystem === 'npm')) {
+            deps.push({ name, version: info.version, ecosystem: 'npm', file: lockPath });
+          }
+        }
+      }
+    } catch { /* skip */ }
+  }
+
+  // Python
+  const reqPath = path.join(rootPath, 'requirements.txt');
+  if (fs.existsSync(reqPath)) {
+    try {
+      const lines = fs.readFileSync(reqPath, 'utf-8').split('\n');
+      for (const line of lines) {
+        const m = line.trim().match(/^([\w-]+)==([\d.]+)/);
+        if (m) {
+          deps.push({ name: m[1], version: m[2], ecosystem: 'PyPI', file: reqPath });
+        }
+      }
+    } catch { /* skip */ }
+  }
+
+  // Poetry (pyproject.toml)
+  const pyprojectPath = path.join(rootPath, 'pyproject.toml');
+  if (fs.existsSync(pyprojectPath)) {
+    try {
+      const content = fs.readFileSync(pyprojectPath, 'utf-8');
+      const depSection = content.match(/\[tool\.poetry\.dependencies\]([\s\S]*?)(?:\n\[|$)/);
+      if (depSection) {
+        const lines = depSection[1].split('\n');
+        for (const line of lines) {
+          const m = line.match(/^([\w-]+)\s*=\s*"([\d.]+)"/);
+          if (m) {
+            deps.push({ name: m[1], version: m[2], ecosystem: 'PyPI', file: pyprojectPath });
+          }
+        }
+      }
+    } catch { /* skip */ }
+  }
+
+  return deps;
+}
+
+// =============================================================================
+// OSV.DEV API
+// =============================================================================
+
+/**
+ * Query OSV.dev for known vulnerabilities affecting a specific package version.
+ * Uses the batch query endpoint for efficiency.
+ *
+ * @param {{ name: string, version: string, ecosystem: string }[]} deps
+ * @returns {Promise<object[]>} — Array of advisory objects
+ */
+export async function queryOSV(deps) {
+  if (deps.length === 0) return [];
+
+  // OSV batch query supports up to 1000 packages per request
+  const batchSize = 1000;
+  const allResults = [];
+
+  for (let i = 0; i < deps.length; i += batchSize) {
+    const batch = deps.slice(i, i + batchSize);
+    const queries = batch.map(d => ({
+      package: { name: d.name, ecosystem: d.ecosystem },
+      version: d.version,
+    }));
+
+    try {
+      const response = await fetch('https://api.osv.dev/v1/querybatch', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ queries }),
+      });
+
+      if (!response.ok) {
+        throw new Error(`OSV API error: HTTP ${response.status}`);
+      }
+
+      const data = await response.json();
+      const results = data.results || [];
+
+      for (let j = 0; j < results.length; j++) {
+        const vulns = results[j].vulns || [];
+        for (const vuln of vulns) {
+          allResults.push({
+            id: vuln.id,
+            summary: vuln.summary || '',
+            severity: extractSeverity(vuln),
+            package: batch[j].name,
+            version: batch[j].version,
+            ecosystem: batch[j].ecosystem,
+            file: deps[i + j].file,
+            aliases: vuln.aliases || [],
+            published: vuln.published || null,
+            modified: vuln.modified || null,
+            isMalware: (vuln.id || '').startsWith('MAL-') ||
+                       (vuln.summary || '').toLowerCase().includes('malicious') ||
+                       (vuln.summary || '').toLowerCase().includes('malware'),
+          });
+        }
+      }
+    } catch (err) {
+      // Network error — return what we have so far
+      if (allResults.length === 0) {
+        throw new Error(`Failed to reach OSV.dev: ${err.message}. Run with --offline to skip live checks.`);
+      }
+    }
+  }
+
+  return allResults;
+}
+
+/**
+ * Extract the highest severity from an OSV vulnerability object.
+ */
+function extractSeverity(vuln) {
+  // Check database_specific severity first
+  if (vuln.database_specific?.severity) {
+    return vuln.database_specific.severity.toLowerCase();
+  }
+
+  // Check CVSS in severity array
+  const sevEntries = vuln.severity || [];
+  for (const entry of sevEntries) {
+    if (entry.type === 'CVSS_V3') {
+      const score = parseFloat(entry.score) || 0;
+      if (score >= 9.0) return 'critical';
+      if (score >= 7.0) return 'high';
+      if (score >= 4.0) return 'medium';
+      return 'low';
+    }
+  }
+
+  // Malware is always critical
+  if ((vuln.id || '').startsWith('MAL-')) return 'critical';
+
+  return 'medium';
+}
+
+// =============================================================================
+// MAIN COMMAND
+// =============================================================================
+
+/**
+ * Run the live advisory check.
+ * Returns findings in ship-safe standard format.
+ */
+export async function runLiveAdvisories(rootPath, options = {}) {
+  const deps = extractDependencies(rootPath);
+
+  if (deps.length === 0) {
+    return { advisories: [], deps: 0, checked: 0 };
+  }
+
+  // Filter by ecosystem if requested
+  const filtered = options.ecosystem
+    ? deps.filter(d => d.ecosystem.toLowerCase() === options.ecosystem.toLowerCase())
+    : deps;
+
+  const advisories = await queryOSV(filtered);
+
+  // Sort: malware first, then by severity
+  const sevOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+  advisories.sort((a, b) => {
+    if (a.isMalware && !b.isMalware) return -1;
+    if (!a.isMalware && b.isMalware) return 1;
+    return (sevOrder[a.severity] || 2) - (sevOrder[b.severity] || 2);
+  });
+
+  return {
+    advisories,
+    deps: filtered.length,
+    checked: filtered.length,
+  };
+}
+
+export default { extractDependencies, queryOSV, runLiveAdvisories };

package/cli/commands/watch.js

@@ -16,6 +16,7 @@ import chalk from 'chalk';
 import { SKIP_DIRS, SKIP_EXTENSIONS, SKIP_FILENAMES, SECRET_PATTERNS, SECURITY_PATTERNS } from '../utils/patterns.js';
 import { isHighEntropyMatch, getConfidence } from '../utils/entropy.js';
 import * as output from '../utils/output.js';
+import { ScoringEngine } from '../agents/scoring-engine.js';
 
 // Agent config files to watch
 const AGENT_CONFIG_PATTERNS = [
@@ -26,6 +27,10 @@ const AGENT_CONFIG_PATTERNS = [
   '.cursor/mcp.json', '.vscode/mcp.json',
 ];
 
+// Watch state persistence
+const WATCH_DB_DIR = '.ship-safe';
+const WATCH_DB_FILE = 'watch.json';
+
 export async function watchCommand(targetPath = '.', options = {}) {
   const absolutePath = path.resolve(targetPath);
 
@@ -34,15 +39,26 @@ export async function watchCommand(targetPath = '.', options = {}) {
     process.exit(1);
   }
 
+  // Status mode: print current watch state and exit
+  if (options.status) {
+    return showWatchStatus(absolutePath);
+  }
+
   // Config-only watch mode
   if (options.configs) {
     return watchConfigs(absolutePath);
   }
 
+  // Deep mode: run full orchestrator on changes
+  if (options.deep) {
+    return watchDeep(absolutePath, options);
+  }
+
   console.log();
   output.header('Ship Safe — Watch Mode');
   console.log();
   console.log(chalk.cyan('  Watching for file changes...'));
+  console.log(chalk.gray('  Use --deep for full agent scanning, --status for current findings'));
   console.log(chalk.gray('  Press Ctrl+C to stop'));
   console.log();
 
@@ -230,6 +246,195 @@ async function watchConfigs(absolutePath) {
   }
 }
 
+// =============================================================================
+// STATUS MODE
+// =============================================================================
+
+function showWatchStatus(rootPath) {
+  const dbFile = path.join(rootPath, WATCH_DB_DIR, WATCH_DB_FILE);
+  if (!fs.existsSync(dbFile)) {
+    console.log('\n  No watch data found. Run: ship-safe watch . --deep\n');
+    return;
+  }
+
+  try {
+    const data = JSON.parse(fs.readFileSync(dbFile, 'utf-8'));
+    console.log(`\n  ${chalk.cyan.bold('Ship Safe Watch — Status')}`);
+    console.log(`  ${'─'.repeat(40)}`);
+    console.log(`  Last scan:  ${data.lastScan || 'never'}`);
+    console.log(`  Scans run:  ${data.scanCount || 0}`);
+    console.log(`  Score:      ${data.score?.score ?? '?'}/100 ${data.score?.grade ?? ''}`);
+    console.log(`  Findings:   ${data.score?.totalFindings ?? 0}`);
+
+    if (data.agentic) {
+      console.log(`  Agentic:    ${data.agentic.flagged}/${data.agentic.total} OWASP Agentic risks flagged`);
+    }
+
+    // Severity breakdown
+    const sevCounts = { critical: 0, high: 0, medium: 0, low: 0 };
+    for (const f of (data.findings || [])) {
+      sevCounts[f.severity] = (sevCounts[f.severity] || 0) + 1;
+    }
+    console.log(`    Critical: ${sevCounts.critical}`);
+    console.log(`    High:     ${sevCounts.high}`);
+    console.log(`    Medium:   ${sevCounts.medium}`);
+    console.log(`    Low:      ${sevCounts.low}\n`);
+  } catch {
+    console.log('\n  Failed to read watch data. File may be corrupted.\n');
+  }
+}
+
+// =============================================================================
+// DEEP WATCH MODE (full orchestrator)
+// =============================================================================
+
+async function watchDeep(absolutePath, options = {}) {
+  const { buildOrchestrator } = await import('../agents/index.js');
+  const { ReconAgent } = await import('../agents/recon-agent.js');
+
+  const debounceMs = options.debounce || 1500;
+  const threshold = options.threshold || null;
+  const scoringEngine = new ScoringEngine();
+
+  console.log();
+  output.header('Ship Safe — Deep Watch Mode');
+  console.log();
+  console.log(chalk.cyan('  Running full agent scans on file changes'));
+  console.log(chalk.gray(`  Debounce: ${debounceMs}ms`));
+  if (threshold) console.log(chalk.gray(`  Threshold: ${threshold}/100`));
+  console.log(chalk.gray('  Press Ctrl+C to stop'));
+  console.log();
+
+  // Initial recon
+  const reconAgent = new ReconAgent();
+  console.log(chalk.gray('  Running initial recon...'));
+  let recon;
+  try {
+    const reconResults = await reconAgent.analyze({ rootPath: absolutePath });
+    recon = Array.isArray(reconResults) ? {} : reconResults;
+  } catch { recon = {}; }
+  console.log(chalk.gray('  Recon complete. Watching...\n'));
+
+  let pendingFiles = new Set();
+  let debounceTimer = null;
+  let scanCount = 0;
+
+  const dbDir = path.join(absolutePath, WATCH_DB_DIR);
+  const dbFile = path.join(dbDir, WATCH_DB_FILE);
+
+  const processChanges = async () => {
+    const files = [...pendingFiles];
+    pendingFiles.clear();
+    if (files.length === 0) return;
+
+    scanCount++;
+    const timestamp = new Date().toLocaleTimeString();
+    console.log(chalk.gray(`  [${timestamp}] ${files.length} file(s) changed — deep scanning...`));
+
+    try {
+      const orchestrator = buildOrchestrator();
+      const context = {
+        rootPath: absolutePath,
+        files,
+        changedFiles: files,
+        recon,
+        options: { incremental: true },
+      };
+
+      const findings = await orchestrator.run(context);
+      const scoreResult = scoringEngine.compute(findings);
+
+      // Persist results
+      try {
+        if (!fs.existsSync(dbDir)) fs.mkdirSync(dbDir, { recursive: true });
+        fs.writeFileSync(dbFile, JSON.stringify({
+          lastScan: new Date().toISOString(),
+          scanCount,
+          score: {
+            score: scoreResult.score,
+            grade: scoreResult.grade?.letter,
+            totalFindings: scoreResult.totalFindings,
+          },
+          agentic: scoreResult.agenticSummary
+            ? { flagged: scoreResult.agenticSummary.flagged, total: scoreResult.agenticSummary.total }
+            : null,
+          findings: findings.map(f => ({
+            file: path.relative(absolutePath, f.file || ''),
+            line: f.line,
+            severity: f.severity,
+            rule: f.rule,
+            title: f.title,
+            agenticRisk: f.agenticRisk || null,
+          })),
+        }, null, 2));
+      } catch { /* non-fatal */ }
+
+      // Output
+      const criticals = findings.filter(f => f.severity === 'critical').length;
+      const highs = findings.filter(f => f.severity === 'high').length;
+
+      if (findings.length === 0) {
+        console.log(chalk.green(`  [${timestamp}] ✔ Clean — Score: ${scoreResult.score}/100 ${scoreResult.grade?.letter}\n`));
+      } else {
+        const scoreColor = scoreResult.score >= 75 ? chalk.cyan : scoreResult.score >= 50 ? chalk.yellow : chalk.red;
+        console.log(`  [${timestamp}] ${chalk.white(`${findings.length} finding(s)`)}: ${criticals ? chalk.red.bold(`${criticals} critical`) : ''}${criticals && highs ? ', ' : ''}${highs ? chalk.yellow(`${highs} high`) : ''}. Score: ${scoreColor(`${scoreResult.score}/100 ${scoreResult.grade?.letter}`)}`);
+
+        for (const f of findings.filter(f => f.severity === 'critical' || f.severity === 'high')) {
+          const relFile = path.relative(absolutePath, f.file || '');
+          const sev = f.severity === 'critical' ? chalk.red.bold('!!') : chalk.yellow(' !');
+          const agentic = f.agenticRisk ? chalk.gray(` [${f.agenticRisk.id}]`) : '';
+          console.log(`    ${sev} ${f.title} — ${relFile}:${f.line}${agentic}`);
+        }
+        console.log('');
+      }
+
+      if (threshold && scoreResult.score < threshold) {
+        console.log(chalk.red.bold(`  ⚠ Score ${scoreResult.score} below threshold ${threshold}\n`));
+      }
+    } catch (err) {
+      console.log(chalk.red(`  [${timestamp}] Scan error: ${err.message}\n`));
+    }
+  };
+
+  try {
+    const watcher = fs.watch(absolutePath, { recursive: true }, (eventType, filename) => {
+      if (!filename) return;
+
+      // Skip non-scannable
+      const relPath = filename.replace(/\\/g, '/');
+      for (const skipDir of SKIP_DIRS) {
+        if (relPath.includes(`${skipDir}/`)) return;
+      }
+      const ext = path.extname(filename).toLowerCase();
+      if (SKIP_EXTENSIONS.has(ext)) return;
+      if (SKIP_FILENAMES.has(path.basename(filename))) return;
+      if (filename.endsWith('.min.js') || filename.endsWith('.min.css')) return;
+
+      const fullPath = path.join(absolutePath, filename);
+      if (!fs.existsSync(fullPath)) return;
+
+      pendingFiles.add(fullPath);
+      if (debounceTimer) clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(processChanges, debounceMs);
+    });
+
+    process.on('SIGINT', () => {
+      watcher.close();
+      console.log(`\n  Watch stopped. ${scanCount} scan(s) completed.\n`);
+      process.exit(0);
+    });
+
+    setInterval(() => {}, 1000 * 60 * 60);
+  } catch (err) {
+    output.error(`Watch failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+// =============================================================================
+// CONFIG WATCH — scanConfigFiles
+// =============================================================================
+
 async function scanConfigFiles(files, rootPath) {
   // Dynamic import to avoid circular dependency
   const { AgentConfigScanner } = await import('../agents/agent-config-scanner.js');

package/cli/providers/llm-provider.js

@@ -196,7 +196,7 @@ class GoogleProvider extends BaseLLMProvider {
 class OllamaProvider extends BaseLLMProvider {
   constructor(apiKey, options = {}) {
     super('Ollama', null, options);
-    this.model = options.model || 'llama3.2';
+    this.model = options.model || 'gemma4:e4b';
     this.baseUrl = options.baseUrl || 'http://localhost:11434/api/chat';
   }
 
@@ -223,6 +223,83 @@ class OllamaProvider extends BaseLLMProvider {
   }
 }
 
+// =============================================================================
+// GEMMA 4 PROVIDER
+// Uses Ollama's structured output (format: schema) for guaranteed JSON —
+// no regex parsing, no silent dropped findings.
+// =============================================================================
+
+const CLASSIFY_SCHEMA = {
+  type: 'object',
+  properties: {
+    results: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          id:             { type: 'string' },
+          classification: { type: 'string', enum: ['REAL', 'FALSE_POSITIVE'] },
+          reason:         { type: 'string' },
+          fix:            { type: ['string', 'null'] },
+        },
+        required: ['id', 'classification', 'reason', 'fix'],
+      },
+    },
+  },
+  required: ['results'],
+};
+
+class GemmaProvider extends OllamaProvider {
+  constructor(options = {}) {
+    super(null, {
+      model:   options.model   || 'gemma4:e4b',
+      baseUrl: options.baseUrl || 'http://localhost:11434/api/chat',
+    });
+    this.name = 'Gemma4';
+    // 256K tokens for 27b/31b, 128K for e4b — set conservatively high
+    this.contextWindow = options.model?.includes('27b') ? 131072 : 65536;
+  }
+
+  /**
+   * Classify using Ollama structured output (format: schema).
+   * Gemma 4 has trained-in function calling — the schema is enforced at the
+   * token level, so the response is always valid JSON matching CLASSIFY_SCHEMA.
+   */
+  async classify(findings, context) {
+    const prompt = this.buildClassificationPrompt(findings, context);
+
+    const response = await fetch(this.baseUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model:  this.model,
+        format: CLASSIFY_SCHEMA,
+        stream: false,
+        options: { num_ctx: this.contextWindow },
+        messages: [
+          { role: 'system', content: 'You are a security expert. Classify each finding as REAL or FALSE_POSITIVE and suggest a fix.' },
+          { role: 'user',   content: prompt },
+        ],
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Gemma4/Ollama error: HTTP ${response.status}`);
+    }
+
+    const data = await response.json();
+    const text = data.message?.content || '';
+
+    try {
+      const parsed = JSON.parse(text);
+      return parsed.results ?? [];
+    } catch {
+      // Fallback: schema enforcement failed (old Ollama version) — try regex parse
+      return this.parseJSON(text);
+    }
+  }
+}
+
 // =============================================================================
 // OPENAI-COMPATIBLE PROVIDER
 // Handles Groq, Together AI, Mistral API, LM Studio, Azure OpenAI, Bedrock
@@ -239,6 +316,10 @@ const OPENAI_COMPATIBLE_PRESETS = {
   perplexity: { baseUrl: 'https://api.perplexity.ai/chat/completions',               model: 'llama-3.1-sonar-large-128k-online', envKey: 'PERPLEXITY_API_KEY' },
   lmstudio:   { baseUrl: 'http://localhost:1234/v1/chat/completions',                model: null,                         envKey: null },
   xai:        { baseUrl: 'https://api.x.ai/v1/chat/completions',                    model: 'grok-3-mini',                envKey: 'XAI_API_KEY' },
+  // Gemma 4 via Ollama — runs fully local, no API key required
+  // e4b: MoE 4B active params, ~8GB RAM;  27b: dense, ~20GB RAM
+  gemma4:     { baseUrl: 'http://localhost:11434/v1/chat/completions',               model: 'gemma4:e4b',                 envKey: null },
+  'gemma4:27b': { baseUrl: 'http://localhost:11434/v1/chat/completions',             model: 'gemma4:27b',                 envKey: null },
 };
 
 class OpenAICompatibleProvider extends OpenAIProvider {
@@ -279,6 +360,13 @@ export function createProvider(provider, apiKey, options = {}) {
     case 'ollama':
     case 'local':
       return new OllamaProvider(apiKey, options);
+    case 'gemma4':
+    case 'gemma':
+      // Gemma 4 via Ollama — structured output, no API key needed
+      return new GemmaProvider({
+        model:   options.model,
+        baseUrl: options.baseUrl,
+      });
   }
 
   // OpenAI-compatible presets