mcp-astgl-knowledge 1.0.2 → 1.1.0

package/README.md

@@ -1,8 +1,8 @@
 # mcp-astgl-knowledge
 
-An MCP server that lets AI assistants search and cite articles from [As The Geek Learns](https://astgl.ai) — covering MCP servers, local AI, and AI automation.
+An MCP server that lets AI assistants search and cite content from [As The Geek Learns](https://astgl.ai) — covering MCP servers, local AI, AI automation, and ASTGL project documentation.
 
-When an AI assistant connects to this server, it gains access to authoritative answers about MCP, local LLMs, and AI workflows. Every response includes a source URL back to astgl.ai.
+When an AI assistant connects to this server, it gains access to 49 indexed entries (articles, tutorials, comparisons, guides, and project docs). Every response includes source URLs back to astgl.ai.
 
 ## Quick Start
 
@@ -36,69 +36,177 @@ Add to your project's `.mcp.json`:
 }
 ```
 
+### Cursor / Generic MCP Client
+
+```json
+{
+  "mcpServers": {
+    "astgl-knowledge": {
+      "command": "npx",
+      "args": ["-y", "mcp-astgl-knowledge"]
+    }
+  }
+}
+```
+
+### With Registration (500 queries/day)
+
+Register via the `register` tool to get an API key, then add it to your config:
+
+```json
+{
+  "mcpServers": {
+    "astgl-knowledge": {
+      "command": "npx",
+      "args": ["-y", "mcp-astgl-knowledge"],
+      "env": {
+        "ASTGL_API_KEY": "astgl_your_api_key_here"
+      }
+    }
+  }
+}
+```
+
 ## Tools
 
 ### `search_articles`
 
-Search ASTGL articles by query. Returns ranked results with relevance scores and source URLs.
+Search the knowledge base by query. Returns ranked results with relevance scores and source URLs.
 
-```
-Input:  { query: "how to build an MCP server", limit: 5 }
-Output: Ranked article sections with title, content, URL, and relevance score
-```
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `query` | string | Yes | Search query (e.g., "how to build an MCP server") |
+| `limit` | number | No | Max results, 1-20 (default: 5) |
+| `content_type` | string | No | Filter by type: article, tutorial, faq, comparison, guide, newsletter, project |
 
 ### `get_answer`
 
 Get a direct answer to a specific question. Prefers FAQ entries for concise responses.
 
-```
-Input:  { question: "What is an MCP server?" }
-Output: Direct answer with source article URL and related articles
-```
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `question` | string | Yes | A specific question (e.g., "What is an MCP server?") |
+| `content_type` | string | No | Filter by content type |
+
+### `get_tutorial`
+
+Get step-by-step instructions from tutorial and guide content.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `query` | string | Yes | What you want to learn (e.g., "setup Ollama on Mac") |
+
+### `compare_topics`
+
+Side-by-side comparison of two topics.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `topic_a` | string | Yes | First topic |
+| `topic_b` | string | Yes | Second topic |
+
+### `get_latest`
+
+Get the most recently added content.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `limit` | number | No | Max results, 1-20 (default: 5) |
 
 ### `list_topics`
 
-List all topics covered in the knowledge base.
+Browse all topics in the knowledge base with content types and section headings.
 
-```
-Input:  {}
-Output: All articles with titles, descriptions, URLs, and section headings
-```
+### `register`
+
+Register your email to unlock 500 queries/day (up from 50).
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `email` | string | Yes | Your email address |
+
+## Content Types
+
+| Type | Count | Description |
+|------|-------|-------------|
+| article | 29 | Informational content about MCP, local AI, automation |
+| project | 9 | ASTGL project documentation (KlockThingy, Revri, Cortex, etc.) |
+| tutorial | 8 | Step-by-step how-to guides |
+| comparison | 2 | Side-by-side topic analysis |
+| guide | 1 | Comprehensive reference material |
+| newsletter | — | Personal updates and announcements |
+| faq | — | Primarily Q&A content |
+
+## Rate Limits
+
+| Tier | Limit | How to Get |
+|------|-------|------------|
+| Public | 50 queries/day | Default (anonymous) |
+| Registered | 500 queries/day | Use the `register` tool with your email |
+
+Limits reset at midnight UTC. Rate limit info is included in every response.
 
 ## How It Works
 
-The knowledge base is pre-built from ASTGL articles using semantic embeddings (nomic-embed-text, 768 dimensions). Articles are chunked by section and FAQ entry, embedded, and stored in a SQLite database with sqlite-vec for vector similarity search.
+The knowledge base is pre-built from ASTGL articles using semantic embeddings (nomic-embed-text, 768 dimensions). Content is chunked by section and FAQ entry, embedded, and stored in a SQLite database with sqlite-vec for vector similarity search.
+
+**End users don't need Ollama** — all embeddings are pre-computed and shipped in the npm package. The only runtime requirement is Node.js.
+
+### Performance
 
-**End users don't need Ollama** — all embeddings are pre-computed and shipped inside the npm package. The only runtime requirement is Node.js.
+- Typical response time: 100-500ms (embedding lookup + vector search)
+- Embedding results are cached in memory (LRU, 200 entries) — repeated queries are near-instant
+- Ollama calls include 10s timeout + automatic retry
+- Query logging is async/batched to avoid blocking responses
+- Rate limit checks are cached for 5 seconds
 
 ## For Maintainers
 
-To rebuild the knowledge database after adding or updating articles:
+### Setup
 
 ```bash
-git clone https://github.com/jamescruce/mcp-astgl-knowledge.git
+git clone https://github.com/Jmeg8r/mcp-astgl-knowledge.git
 cd mcp-astgl-knowledge
 npm install
-npm run ingest   # Requires Ollama with nomic-embed-text
-npm run build
 ```
 
-Set `ASTGL_ARTICLES_DIR` to point to your articles directory if it's not at the default location.
-
-## Coverage
-
-Currently indexes 10 articles covering:
-
-- What MCP servers are and how they work
-- Building your first MCP server
-- Connecting MCP servers to Claude and ChatGPT
-- Best MCP servers available now
-- MCP servers vs traditional APIs
-- Running AI models locally
-- Hardware requirements for local LLMs
-- Cost comparison: local vs cloud AI
-- Security of local AI
-- Automating business workflows with AI
+### Scripts
+
+| Script | Description |
+|--------|-------------|
+| `npm run build` | Compile TypeScript |
+| `npm run dev` | Run MCP server in dev mode (tsx) |
+| `npm start` | Run compiled MCP server |
+| `npm run ingest` | Rebuild knowledge.db from local markdown (requires Ollama) |
+| `npm run ingest-projects` | Index project docs from astgl-site projects.json |
+| `npm run discover` | Poll RSS/sitemap for new content |
+| `npm run structure` | Process discovered content (classify, embed, index) |
+| `npm run pipeline` | Discover + structure in one step |
+| `npm run daily-report` | Generate AEO analytics report |
+| `npm run alerts` | Run content gap alert checks |
+| `npm run freshness` | Check for stale content and ecosystem version changes |
+| `npm run citation-test` | Manual AI citation testing |
+| `npm run related` | Generate internal article links via vector similarity |
+
+### Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `OLLAMA_URL` | `http://localhost:11434` | Ollama endpoint (dev/rebuild only) |
+| `EMBED_MODEL` | `nomic-embed-text` | Embedding model |
+| `DISCORD_WEBHOOK_URL` | — | Discord webhook for reports/alerts |
+| `ASTGL_API_KEY` | — | Registered tier API key |
+| `ASTGL_ARTICLES_DIR` | `~/Projects/astgl-site/src/content/answers` | Local markdown source |
+| `ASTGL_PROJECTS_JSON` | `~/Projects/astgl-site/src/data/projects.json` | Projects data source |
+
+### Automated Jobs
+
+| Job | Schedule | Purpose |
+|-----|----------|---------|
+| Content pipeline | Every 6h | Discover + structure new content |
+| Daily report | 8 AM | Query analytics + health metrics → Discord |
+| Content alerts | 9 AM | Gap detection, zero-citation, competitor scan → Discord |
+| Freshness check | 10 AM | Stale content + ecosystem version tracking → Discord |
 
 ## License
 

package/dist/alerts.d.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env tsx
+/**
+ * Content gap alert engine.
+ *
+ * WHAT: Auto-detects AEO problems and sends Discord alerts when thresholds are crossed
+ * WHY: Proactive alerting catches citation drops, content gaps, and competitor moves
+ *       before they become invisible losses
+ *
+ * Alert types:
+ *   1. Unknown topic spike — many queries with low confidence in a short window
+ *   2. Zero-citation articles — high-value articles never appearing in cited content
+ *   3. Repeated low-confidence — same query failing multiple times (content gap signal)
+ *   4. Competitor MCP servers — new servers on registries covering similar topics
+ *
+ * Usage:
+ *   npm run alerts                    Check all alerts, print to stdout (JSON)
+ *   npm run alerts -- --discord       Also send triggered alerts to Discord
+ *   npm run alerts -- --days 7        Look back 7 days (default: 1)
+ *
+ * Env: DISCORD_WEBHOOK_URL — Discord webhook for alert delivery
+ */
+export {};

package/dist/alerts.js

@@ -0,0 +1,433 @@
+#!/usr/bin/env tsx
+/**
+ * Content gap alert engine.
+ *
+ * WHAT: Auto-detects AEO problems and sends Discord alerts when thresholds are crossed
+ * WHY: Proactive alerting catches citation drops, content gaps, and competitor moves
+ *       before they become invisible losses
+ *
+ * Alert types:
+ *   1. Unknown topic spike — many queries with low confidence in a short window
+ *   2. Zero-citation articles — high-value articles never appearing in cited content
+ *   3. Repeated low-confidence — same query failing multiple times (content gap signal)
+ *   4. Competitor MCP servers — new servers on registries covering similar topics
+ *
+ * Usage:
+ *   npm run alerts                    Check all alerts, print to stdout (JSON)
+ *   npm run alerts -- --discord       Also send triggered alerts to Discord
+ *   npm run alerts -- --days 7        Look back 7 days (default: 1)
+ *
+ * Env: DISCORD_WEBHOOK_URL — Discord webhook for alert delivery
+ */
+import { join } from "path";
+import { existsSync, mkdirSync } from "fs";
+import Database from "better-sqlite3";
+const DATA_DIR = join(import.meta.dirname, "..", "data");
+const QUERY_LOG_PATH = join(DATA_DIR, "query-log.db");
+const KNOWLEDGE_PATH = join(DATA_DIR, "knowledge.db");
+const ALERT_DB_PATH = join(DATA_DIR, "alerts.db");
+const DISCORD_WEBHOOK_URL = process.env.DISCORD_WEBHOOK_URL || "";
+// --- Thresholds ---
+const LOW_CONFIDENCE_THRESHOLD = 0.5;
+const UNKNOWN_TOPIC_SPIKE_MIN = 5;
+const REPEATED_QUERY_MIN = 3;
+const ZERO_CITATION_LOOKBACK_DAYS = 14;
+const ALERT_COOLDOWN_HOURS = 24;
+// --- Alert History DB ---
+// WHAT: Track which alerts have been sent to avoid spamming Discord
+// WHY: Same alert condition can persist for days — only notify once per cooldown window
+function initAlertDb() {
+    if (!existsSync(DATA_DIR))
+        mkdirSync(DATA_DIR, { recursive: true });
+    const db = new Database(ALERT_DB_PATH);
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS alert_history (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      alert_type TEXT NOT NULL,
+      alert_key TEXT NOT NULL,
+      fired_at TEXT NOT NULL,
+      details TEXT,
+      UNIQUE(alert_type, alert_key, fired_at)
+    )
+  `);
+    db.exec("CREATE INDEX IF NOT EXISTS idx_alert_history_key ON alert_history(alert_type, alert_key)");
+    return db;
+}
+function wasRecentlyFired(alertDb, type, key) {
+    const cutoff = new Date();
+    cutoff.setHours(cutoff.getHours() - ALERT_COOLDOWN_HOURS);
+    const row = alertDb
+        .prepare(`SELECT id FROM alert_history
+       WHERE alert_type = ? AND alert_key = ? AND fired_at > ?
+       LIMIT 1`)
+        .get(type, key, cutoff.toISOString());
+    return !!row;
+}
+function recordAlert(alertDb, alert, key) {
+    alertDb
+        .prepare("INSERT OR IGNORE INTO alert_history (alert_type, alert_key, fired_at, details) VALUES (?, ?, ?, ?)")
+        .run(alert.type, key, new Date().toISOString(), alert.title);
+}
+// --- Alert Check #1: Unknown Topic Spike ---
+// WHAT: Detect when many queries have very low confidence scores
+// WHY: Indicates users are asking about topics we don't cover — content gap opportunity
+function checkUnknownTopicSpike(fromDate, alertDb) {
+    if (!existsSync(QUERY_LOG_PATH))
+        return [];
+    const db = new Database(QUERY_LOG_PATH, { readonly: true });
+    const tableCheck = db
+        .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='query_log'")
+        .get();
+    if (!tableCheck) {
+        db.close();
+        return [];
+    }
+    const lowConfQueries = db
+        .prepare(`SELECT query_params, confidence_score, tool_name, COUNT(*) as occurrences
+       FROM query_log
+       WHERE timestamp >= ? AND confidence_score IS NOT NULL AND confidence_score < ?
+       GROUP BY query_params
+       ORDER BY occurrences DESC`)
+        .all(fromDate, LOW_CONFIDENCE_THRESHOLD);
+    db.close();
+    if (lowConfQueries.length < UNKNOWN_TOPIC_SPIKE_MIN)
+        return [];
+    const key = `spike-${lowConfQueries.length}-${fromDate.split("T")[0]}`;
+    if (wasRecentlyFired(alertDb, "unknown_topic_spike", key))
+        return [];
+    const topQueries = lowConfQueries.slice(0, 5).map((q) => {
+        try {
+            const parsed = JSON.parse(q.query_params);
+            return parsed.query || parsed.question || q.query_params;
+        }
+        catch {
+            return q.query_params;
+        }
+    });
+    const alert = {
+        type: "unknown_topic_spike",
+        severity: lowConfQueries.length >= 10 ? "critical" : "warning",
+        title: `Unknown topic spike: ${lowConfQueries.length} low-confidence queries`,
+        details: [
+            `${lowConfQueries.length} unique queries scored below ${LOW_CONFIDENCE_THRESHOLD} confidence.`,
+            "Top queries:",
+            ...topQueries.map((q, i) => `  ${i + 1}. "${q}"`),
+            "",
+            "Action: Review these topics for new article opportunities.",
+        ].join("\n"),
+        data: {
+            count: lowConfQueries.length,
+            threshold: LOW_CONFIDENCE_THRESHOLD,
+            top_queries: topQueries,
+        },
+    };
+    recordAlert(alertDb, alert, key);
+    return [alert];
+}
+// --- Alert Check #2: Zero-Citation Articles ---
+// WHAT: Find articles that exist in the knowledge base but are never cited in query results
+// WHY: Content that's never surfaced is invisible — may need better embeddings or rewriting
+function checkZeroCitationArticles(fromDate, alertDb) {
+    if (!existsSync(QUERY_LOG_PATH) || !existsSync(KNOWLEDGE_PATH))
+        return [];
+    const knowledgeDb = new Database(KNOWLEDGE_PATH, { readonly: true });
+    const allArticles = knowledgeDb
+        .prepare("SELECT title, url FROM articles")
+        .all();
+    knowledgeDb.close();
+    const logDb = new Database(QUERY_LOG_PATH, { readonly: true });
+    const tableCheck = logDb
+        .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='query_log'")
+        .get();
+    if (!tableCheck) {
+        logDb.close();
+        return [];
+    }
+    // WHAT: Collect all URLs that appeared in content_cited over the lookback window
+    // WHY: If an article URL never shows up, it's either irrelevant or poorly embedded
+    const lookback = new Date();
+    lookback.setDate(lookback.getDate() - ZERO_CITATION_LOOKBACK_DAYS);
+    const citedRows = logDb
+        .prepare(`SELECT content_cited FROM query_log
+       WHERE timestamp >= ? AND content_cited IS NOT NULL`)
+        .all(lookback.toISOString());
+    logDb.close();
+    // Need at least some query activity to make this check meaningful
+    if (citedRows.length < 10)
+        return [];
+    const citedUrls = new Set();
+    for (const row of citedRows) {
+        try {
+            const urls = JSON.parse(row.content_cited);
+            for (const url of urls)
+                citedUrls.add(url);
+        }
+        catch {
+            // Skip malformed
+        }
+    }
+    // WHAT: Filter to astgl.ai articles only (these are the "high-value" ones we control)
+    // WHY: Substack mirror URLs being uncited is expected — the canonical ones matter
+    const uncitedHighValue = allArticles.filter((a) => a.url.startsWith("https://astgl.ai/") && !citedUrls.has(a.url));
+    if (uncitedHighValue.length === 0)
+        return [];
+    const key = `uncited-${uncitedHighValue.length}`;
+    if (wasRecentlyFired(alertDb, "zero_citation", key))
+        return [];
+    const alert = {
+        type: "zero_citation",
+        severity: uncitedHighValue.length >= 10 ? "warning" : "info",
+        title: `${uncitedHighValue.length} high-value articles with zero citations (${ZERO_CITATION_LOOKBACK_DAYS}d)`,
+        details: [
+            `These astgl.ai articles were never cited in the last ${ZERO_CITATION_LOOKBACK_DAYS} days:`,
+            ...uncitedHighValue.slice(0, 10).map((a) => `  - ${a.title}\n    ${a.url}`),
+            uncitedHighValue.length > 10 ? `  ... and ${uncitedHighValue.length - 10} more` : "",
+            "",
+            "Action: Check embeddings quality, consider rewriting descriptions, or verify chunking.",
+        ].join("\n"),
+        data: {
+            count: uncitedHighValue.length,
+            lookback_days: ZERO_CITATION_LOOKBACK_DAYS,
+            articles: uncitedHighValue.slice(0, 10).map((a) => ({ title: a.title, url: a.url })),
+        },
+    };
+    recordAlert(alertDb, alert, key);
+    return [alert];
+}
+// --- Alert Check #3: Repeated Low-Confidence Queries ---
+// WHAT: Same query text appearing multiple times with consistently low confidence
+// WHY: Repeated failures = a real user need we're not serving — highest-signal content gap
+function checkRepeatedLowConfidence(fromDate, alertDb) {
+    if (!existsSync(QUERY_LOG_PATH))
+        return [];
+    const db = new Database(QUERY_LOG_PATH, { readonly: true });
+    const tableCheck = db
+        .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='query_log'")
+        .get();
+    if (!tableCheck) {
+        db.close();
+        return [];
+    }
+    const repeats = db
+        .prepare(`SELECT query_params, tool_name,
+              COUNT(*) as occurrences,
+              ROUND(AVG(confidence_score), 3) as avg_confidence
+       FROM query_log
+       WHERE timestamp >= ?
+         AND confidence_score IS NOT NULL
+         AND confidence_score < ?
+       GROUP BY query_params
+       HAVING COUNT(*) >= ?
+       ORDER BY occurrences DESC`)
+        .all(fromDate, LOW_CONFIDENCE_THRESHOLD, REPEATED_QUERY_MIN);
+    db.close();
+    if (repeats.length === 0)
+        return [];
+    const alerts = [];
+    for (const r of repeats.slice(0, 5)) {
+        let queryText = r.query_params;
+        try {
+            const parsed = JSON.parse(r.query_params);
+            queryText = parsed.query || parsed.question || r.query_params;
+        }
+        catch {
+            // Use raw
+        }
+        const key = `repeat-${queryText.slice(0, 50)}`;
+        if (wasRecentlyFired(alertDb, "repeated_low_confidence", key))
+            continue;
+        const alert = {
+            type: "repeated_low_confidence",
+            severity: r.occurrences >= 5 ? "critical" : "warning",
+            title: `Repeated content gap: "${queryText}" (${r.occurrences}x, avg ${r.avg_confidence})`,
+            details: [
+                `Query "${queryText}" has been asked ${r.occurrences} times with avg confidence ${r.avg_confidence}.`,
+                `Tool: ${r.tool_name}`,
+                "",
+                "Action: Write or improve content targeting this specific question.",
+            ].join("\n"),
+            data: {
+                query: queryText,
+                occurrences: r.occurrences,
+                avg_confidence: r.avg_confidence,
+                tool: r.tool_name,
+            },
+        };
+        recordAlert(alertDb, alert, key);
+        alerts.push(alert);
+    }
+    return alerts;
+}
+// --- Alert Check #4: Competitor MCP Servers ---
+// WHAT: Scan Smithery registry for new MCP servers covering similar topics
+// WHY: Competitors publishing knowledge MCP servers dilutes ASTGL's AEO position
+async function checkCompetitorServers(alertDb) {
+    const SEARCH_TERMS = ["knowledge base", "ai articles", "local ai", "mcp guide"];
+    const OUR_SLUGS = ["astgl-knowledge", "mcp-astgl-knowledge"];
+    const alerts = [];
+    for (const term of SEARCH_TERMS) {
+        try {
+            // WHAT: Smithery registry search API
+            // WHY: Public API, no auth needed, returns server metadata
+            const resp = await fetch(`https://registry.smithery.ai/servers?q=${encodeURIComponent(term)}&pageSize=10`, {
+                headers: { Accept: "application/json" },
+                signal: AbortSignal.timeout(10_000),
+            });
+            if (!resp.ok)
+                continue;
+            const data = (await resp.json());
+            if (!data.servers)
+                continue;
+            for (const server of data.servers) {
+                // Skip our own server
+                if (OUR_SLUGS.some((slug) => server.qualifiedName.includes(slug)))
+                    continue;
+                // WHAT: Only alert on servers created in the last 30 days
+                // WHY: Old servers aren't news — we want to catch new entrants
+                const createdAt = new Date(server.createdAt);
+                const thirtyDaysAgo = new Date();
+                thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+                if (createdAt < thirtyDaysAgo)
+                    continue;
+                const key = `competitor-${server.qualifiedName}`;
+                if (wasRecentlyFired(alertDb, "competitor_detected", key))
+                    continue;
+                const alert = {
+                    type: "competitor_detected",
+                    severity: "info",
+                    title: `New competitor MCP server: ${server.displayName}`,
+                    details: [
+                        `**Server:** ${server.qualifiedName}`,
+                        `**Name:** ${server.displayName}`,
+                        `**Description:** ${server.description?.slice(0, 200) || "N/A"}`,
+                        `**Created:** ${server.createdAt}`,
+                        `**Found via:** search for "${term}"`,
+                        "",
+                        "Action: Review server to assess overlap with ASTGL content coverage.",
+                    ].join("\n"),
+                    data: {
+                        qualified_name: server.qualifiedName,
+                        display_name: server.displayName,
+                        description: server.description,
+                        search_term: term,
+                    },
+                };
+                recordAlert(alertDb, alert, key);
+                alerts.push(alert);
+            }
+        }
+        catch {
+            // Network error — skip this search term silently
+        }
+    }
+    return alerts;
+}
+// --- Discord Delivery ---
+function severityColor(severity) {
+    switch (severity) {
+        case "critical": return 0xff0000;
+        case "warning": return 0xffa500;
+        case "info": return 0x2196f3;
+    }
+}
+function severityEmoji(severity) {
+    switch (severity) {
+        case "critical": return "🔴";
+        case "warning": return "🟡";
+        case "info": return "🔵";
+    }
+}
+async function sendAlertsToDiscord(alerts) {
+    if (!DISCORD_WEBHOOK_URL) {
+        console.error("DISCORD_WEBHOOK_URL not set.");
+        return;
+    }
+    if (alerts.length === 0)
+        return;
+    // WHAT: Group alerts into a single Discord message with multiple embeds
+    // WHY: One webhook call is better than N separate messages
+    const embeds = alerts.slice(0, 10).map((alert) => ({
+        title: `${severityEmoji(alert.severity)} ${alert.title}`,
+        description: alert.details,
+        color: severityColor(alert.severity),
+        footer: { text: `Alert type: ${alert.type}` },
+    }));
+    const resp = await fetch(DISCORD_WEBHOOK_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ embeds }),
+    });
+    if (!resp.ok) {
+        const body = await resp.text();
+        console.error(`Discord webhook failed: ${resp.status} ${body}`);
+    }
+    else {
+        console.error(`${alerts.length} alert(s) sent to Discord.`);
+    }
+}
+// --- CLI ---
+function parseArgs() {
+    const args = process.argv.slice(2);
+    return {
+        sendToDiscord: args.includes("--discord"),
+        days: (() => {
+            const idx = args.indexOf("--days");
+            return idx >= 0 && args[idx + 1] ? parseInt(args[idx + 1], 10) : 1;
+        })(),
+    };
+}
+async function main() {
+    const { sendToDiscord, days } = parseArgs();
+    const from = new Date();
+    from.setDate(from.getDate() - days);
+    const fromDate = from.toISOString();
+    const alertDb = initAlertDb();
+    const checksRun = [];
+    let suppressed = 0;
+    const allAlerts = [];
+    // Run all checks
+    console.error("=== ASTGL Content Gap Alert Engine ===\n");
+    console.error("Checking: unknown topic spike...");
+    checksRun.push("unknown_topic_spike");
+    const spikeAlerts = checkUnknownTopicSpike(fromDate, alertDb);
+    allAlerts.push(...spikeAlerts);
+    console.error(`  ${spikeAlerts.length} alert(s)\n`);
+    console.error("Checking: zero-citation articles...");
+    checksRun.push("zero_citation");
+    const zeroCiteAlerts = checkZeroCitationArticles(fromDate, alertDb);
+    allAlerts.push(...zeroCiteAlerts);
+    console.error(`  ${zeroCiteAlerts.length} alert(s)\n`);
+    console.error("Checking: repeated low-confidence queries...");
+    checksRun.push("repeated_low_confidence");
+    const repeatAlerts = checkRepeatedLowConfidence(fromDate, alertDb);
+    allAlerts.push(...repeatAlerts);
+    console.error(`  ${repeatAlerts.length} alert(s)\n`);
+    console.error("Checking: competitor MCP servers...");
+    checksRun.push("competitor_detected");
+    const competitorAlerts = await checkCompetitorServers(alertDb);
+    allAlerts.push(...competitorAlerts);
+    console.error(`  ${competitorAlerts.length} alert(s)\n`);
+    alertDb.close();
+    const report = {
+        generated_at: new Date().toISOString(),
+        period_days: days,
+        alerts_fired: allAlerts,
+        alerts_suppressed: suppressed,
+        checks_run: checksRun,
+    };
+    console.log(JSON.stringify(report, null, 2));
+    if (sendToDiscord && allAlerts.length > 0) {
+        await sendAlertsToDiscord(allAlerts);
+    }
+    else if (sendToDiscord && allAlerts.length === 0) {
+        console.error("No alerts to send.");
+    }
+    console.error(`\n=== Done: ${allAlerts.length} alert(s) fired, ${suppressed} suppressed ===`);
+}
+main()
+    .then(() => process.exit(0))
+    .catch((err) => {
+    console.error("Alert engine failed:", err);
+    process.exit(1);
+});
+//# sourceMappingURL=alerts.js.map