delimit-cli 4.5.4 → 4.5.6

package/bin/delimit-cli.js

@@ -4629,18 +4629,33 @@ program
         const prePushPath = path.join(hooksDir, 'pre-push');
         const marker = '# delimit-governance-hook';
 
+        // Resolution order: local node_modules → global PATH → npx fallback.
+        // npx is last because it can fail with Arborist 'extraneous' errors
+        // when a project's node_modules / lockfile drift (LED-1248).
         const preCommitHook = `#!/bin/sh
 ${marker}
 # Delimit API governance gate
 # Blocks commits with breaking API changes
-npx delimit-cli check --staged
+if [ -x ./node_modules/.bin/delimit-cli ]; then
+  ./node_modules/.bin/delimit-cli check --staged
+elif command -v delimit-cli >/dev/null 2>&1; then
+  delimit-cli check --staged
+else
+  npx delimit-cli check --staged
+fi
 `;
 
         const prePushHook = `#!/bin/sh
 ${marker}
 # Delimit API governance gate
 # Blocks pushes with breaking API changes
-npx delimit-cli check --base origin/main
+if [ -x ./node_modules/.bin/delimit-cli ]; then
+  ./node_modules/.bin/delimit-cli check --base origin/main
+elif command -v delimit-cli >/dev/null 2>&1; then
+  delimit-cli check --base origin/main
+else
+  npx delimit-cli check --base origin/main
+fi
 `;
 
         if (action === 'install') {

package/gateway/ai/license.py

@@ -26,10 +26,14 @@ try:
         # Autonomous build loop
         "delimit_next_task", "delimit_task_complete",
         "delimit_loop_status", "delimit_loop_config",
+        # LED-1253: vendor-news riff MCP wrappers
+        "delimit_vendor_news_scan", "delimit_vendor_news_health",
+        "delimit_vendor_news_draft",
     })
 except ImportError:
     # license_core not available (development mode or missing binary)
     import json
+    import os
     import time
     from pathlib import Path
 
@@ -78,6 +82,9 @@ except ImportError:
         # Autonomous build loop
         "delimit_next_task", "delimit_task_complete",
         "delimit_loop_status", "delimit_loop_config",
+        # LED-1253: vendor-news riff MCP wrappers
+        "delimit_vendor_news_scan", "delimit_vendor_news_health",
+        "delimit_vendor_news_draft",
     })
     FREE_TRIAL_LIMITS = {"delimit_deliberate": 3}
 

package/gateway/ai/server.py

@@ -51,7 +51,7 @@ import subprocess
 import threading
 import traceback
 import uuid
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
 
@@ -7866,6 +7866,423 @@ def delimit_github_scan(
     return _with_next_steps("github_scan", result)
 
 
+# ═══════════════════════════════════════════════════════════════════════
+#  VENDOR NEWS RIFF SYSTEM - LED-1250 / LED-1253 (Pro)
+# ═══════════════════════════════════════════════════════════════════════
+#
+# Diagnostic + ad-hoc invocation surface for the vendor-news riff cron.
+# The cron at scripts/vendor_news_cron.py is the production firing path;
+# these tools expose the same backend functions (scan_vendor_news,
+# draft_vendor_riff) for in-session inspection, dry-runs, and one-off
+# drafting against a specific source tweet.
+
+
+@mcp.tool()
+def delimit_vendor_news_scan(dry_run: bool = False) -> Dict[str, Any]:
+    """Scan watchlisted vendor accounts for fresh, high-engagement posts and
+    auto-draft brand-voice Delimit POV riffs (Pro, LED-1253).
+
+    Wraps ``ai.vendor_news.sensor.scan_vendor_news`` + ``draft_vendor_riff``
+    in a single MCP-callable tool. This is the same code path the
+    ``vendor_news_cron.py`` runs every 30 minutes; surfacing it as an MCP
+    tool lets the orchestrator invoke a scan on demand (e.g. when an X
+    thread looks ride-able and the next cron tick is too far away).
+
+    When ``dry_run=True``, the sensor still polls (cache-friendly) but
+    suppresses its JSONL log write AND skips the drafter entirely so no
+    queue insertion happens and the per-vendor 24h rate cap is not
+    consumed. Useful for "what would fire if I ran the cron now?"
+    inspection without side effects.
+
+    Args:
+        dry_run: If True, run the sensor only (no drafter, no queue,
+            no rate-cap consumption). Default False.
+
+    Returns:
+        Dict with ``stats``, ``triggered``, ``queued``, ``rejected``,
+        ``rate_capped``, ``errors`` — same shape as the cron summary.
+    """
+    from ai.license import require_premium
+    gate = require_premium("vendor_news_scan")
+    if gate:
+        return gate
+
+    try:
+        from ai.vendor_news import scan_vendor_news, draft_vendor_riff
+    except Exception as exc:
+        return _with_next_steps("vendor_news_scan", {
+            "error": "vendor_news_unavailable",
+            "message": f"could not import ai.vendor_news: {exc}",
+        })
+
+    try:
+        scan = scan_vendor_news(dry_run=dry_run)
+    except Exception as exc:
+        return _with_next_steps("vendor_news_scan", {
+            "error": "scan_failed",
+            "message": str(exc),
+        })
+
+    triggered = scan.get("triggered") or []
+    stats = scan.get("stats") or {}
+
+    queued = 0
+    rejected = 0
+    rate_capped = 0
+    drafter_errors: List[Dict[str, Any]] = []
+    drafts: List[Dict[str, Any]] = []
+
+    if not dry_run:
+        for tw in triggered:
+            try:
+                res = draft_vendor_riff(tw)
+            except Exception as exc:
+                drafter_errors.append({"id": tw.get("id"), "error": str(exc)})
+                continue
+            decision = res.get("decision")
+            reason = res.get("reason", "")
+            drafts.append({
+                "source_id": tw.get("id"),
+                "vendor": tw.get("vendor"),
+                "decision": decision,
+                "reason": reason,
+            })
+            if decision == "queue":
+                queued += 1
+            elif reason == "rate_capped":
+                rate_capped += 1
+            else:
+                rejected += 1
+
+    result = {
+        "stats": stats,
+        "triggered": [
+            {
+                "id": t.get("id"),
+                "vendor": t.get("vendor"),
+                "url": t.get("url"),
+                "trigger_reason": t.get("trigger_reason"),
+                "metrics": t.get("metrics"),
+            }
+            for t in triggered
+        ],
+        "queued": queued,
+        "rejected": rejected,
+        "rate_capped": rate_capped,
+        "errors": list(scan.get("errors") or []) + drafter_errors,
+        "drafts": drafts,
+        "dry_run": bool(dry_run),
+    }
+    return _with_next_steps("vendor_news_scan", result)
+
+
+@mcp.tool()
+def delimit_vendor_news_health() -> Dict[str, Any]:
+    """Health check for the vendor-news riff system (Pro, LED-1253).
+
+    Returns a snapshot of:
+      * cron installation status (greps ``crontab -l`` for vendor_news_cron.py)
+      * last sensor run timestamp + stats (from sensor JSONL log)
+      * last 24h queued P0 vendor_news_riff entries (from tweet_queue.json)
+      * last 24h rejected entries grouped by reason (from rejected JSONL)
+      * watchlist account count
+      * estimated daily live-call budget consumption
+
+    Use this when you want to quickly answer "is the cron firing? are
+    drafts landing? what's getting rejected?" without grepping logs.
+    """
+    from ai.license import require_premium
+    gate = require_premium("vendor_news_health")
+    if gate:
+        return gate
+
+    from ai.vendor_news.sensor import SENSOR_LOG_PATH, WATCHLIST_PATH, load_watchlist
+    from ai.vendor_news.drafter import TWEET_QUEUE_PATH, REJECTED_LOG_PATH
+
+    out: Dict[str, Any] = {
+        "cron_installed": False,
+        "last_run_ts": None,
+        "last_run_stats": None,
+        "recent_queued_count_24h": 0,
+        "recent_rejected_count_24h": 0,
+        "recent_rejection_reasons_24h": {},
+        "watchlist_account_count": 0,
+        "daily_budget_used_estimate": 0,
+    }
+
+    # 1) crontab check
+    try:
+        proc = subprocess.run(
+            ["crontab", "-l"],
+            capture_output=True, text=True, timeout=5,
+        )
+        if proc.returncode == 0 and "vendor_news_cron.py" in (proc.stdout or ""):
+            out["cron_installed"] = True
+    except (FileNotFoundError, subprocess.SubprocessError, OSError):
+        # crontab binary missing (containers, CI) — cron_installed stays False
+        out["cron_installed"] = False
+
+    cutoff = datetime.now(timezone.utc) - timedelta(hours=24)
+
+    # 2) sensor log: last run + 24h budget estimate
+    try:
+        if SENSOR_LOG_PATH.exists():
+            last_line = None
+            budget_used = 0
+            with open(SENSOR_LOG_PATH, "r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        entry = json.loads(line)
+                    except (json.JSONDecodeError, ValueError):
+                        continue
+                    last_line = entry
+                    ts_raw = entry.get("ts")
+                    try:
+                        ts_norm = ts_raw[:-1] + "+00:00" if ts_raw and ts_raw.endswith("Z") else ts_raw
+                        ts = datetime.fromisoformat(ts_norm) if ts_norm else None
+                    except (ValueError, TypeError):
+                        ts = None
+                    if ts is not None:
+                        if ts.tzinfo is None:
+                            ts = ts.replace(tzinfo=timezone.utc)
+                        if ts >= cutoff:
+                            budget_used += int(entry.get("live_calls") or 0)
+            if last_line:
+                out["last_run_ts"] = last_line.get("ts")
+                out["last_run_stats"] = {
+                    k: v for k, v in last_line.items()
+                    if k not in ("triggered_ids", "error_handles")
+                }
+            out["daily_budget_used_estimate"] = budget_used
+    except OSError:
+        pass
+
+    # 3) tweet_queue.json: 24h queued vendor_news_riff entries
+    try:
+        if TWEET_QUEUE_PATH.exists():
+            data = json.loads(TWEET_QUEUE_PATH.read_text(encoding="utf-8"))
+            if isinstance(data, list):
+                count = 0
+                for entry in data:
+                    if not isinstance(entry, dict):
+                        continue
+                    if entry.get("priority") != "P0":
+                        continue
+                    if entry.get("category") != "vendor_news_riff":
+                        continue
+                    added_raw = entry.get("added_at")
+                    try:
+                        added_norm = (
+                            added_raw[:-1] + "+00:00"
+                            if added_raw and added_raw.endswith("Z")
+                            else added_raw
+                        )
+                        added = datetime.fromisoformat(added_norm) if added_norm else None
+                    except (ValueError, TypeError):
+                        added = None
+                    if added is None:
+                        continue
+                    if added.tzinfo is None:
+                        added = added.replace(tzinfo=timezone.utc)
+                    if added >= cutoff:
+                        count += 1
+                out["recent_queued_count_24h"] = count
+    except (OSError, json.JSONDecodeError, ValueError):
+        pass
+
+    # 4) rejected JSONL: 24h count + reason histogram
+    try:
+        if REJECTED_LOG_PATH.exists():
+            count = 0
+            reasons: Dict[str, int] = {}
+            with open(REJECTED_LOG_PATH, "r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        entry = json.loads(line)
+                    except (json.JSONDecodeError, ValueError):
+                        continue
+                    ts_raw = entry.get("ts")
+                    try:
+                        ts_norm = (
+                            ts_raw[:-1] + "+00:00"
+                            if ts_raw and ts_raw.endswith("Z")
+                            else ts_raw
+                        )
+                        ts = datetime.fromisoformat(ts_norm) if ts_norm else None
+                    except (ValueError, TypeError):
+                        ts = None
+                    if ts is None:
+                        continue
+                    if ts.tzinfo is None:
+                        ts = ts.replace(tzinfo=timezone.utc)
+                    if ts < cutoff:
+                        continue
+                    count += 1
+                    reason = entry.get("reason") or "unknown"
+                    reasons[reason] = reasons.get(reason, 0) + 1
+            out["recent_rejected_count_24h"] = count
+            out["recent_rejection_reasons_24h"] = reasons
+    except OSError:
+        pass
+
+    # 5) watchlist account count
+    try:
+        cfg = load_watchlist()
+        accounts = cfg.get("accounts") or []
+        out["watchlist_account_count"] = len(accounts)
+    except Exception:
+        pass
+
+    return _with_next_steps("vendor_news_health", out)
+
+
+@mcp.tool()
+def delimit_vendor_news_draft(tweet_id: str = "", dry_run: bool = False) -> Dict[str, Any]:
+    """Draft a brand-voice Delimit-POV riff for a specific X tweet (Pro, LED-1253).
+
+    Fetches the source tweet via the cached twttr241 path (same one
+    ``delimit_x_fetch`` uses), shapes it into the dict ``draft_vendor_riff``
+    expects, then runs the riff drafter end-to-end (rate cap, source-fit
+    pre-filter, generator, capability validator, fit floor, queue insert).
+
+    When ``dry_run=True``, the underlying drafter still produces text and
+    runs validators, but the queue insertion is skipped — useful for
+    inspecting what the riff would look like without committing it. The
+    24h per-vendor rate cap IS still consulted (we don't bypass it on
+    dry runs because spurious dry runs would otherwise look like riffs
+    in the rejected log).
+
+    Args:
+        tweet_id: Source X tweet id (numeric string) or full x.com URL.
+        dry_run: If True, suppress queue insertion. Default False.
+    """
+    from ai.license import require_premium
+    gate = require_premium("vendor_news_draft")
+    if gate:
+        return gate
+
+    raw = (tweet_id or "").strip()
+    if not raw:
+        return _with_next_steps("vendor_news_draft", {
+            "error": "missing_tweet_id",
+            "message": "tweet_id is required (status id or x.com URL)",
+        })
+
+    # Normalize id (accept URL or bare id)
+    try:
+        from ai.social_target import extract_status_id, fetch_tweet_by_id
+    except Exception as exc:
+        return _with_next_steps("vendor_news_draft", {
+            "error": "social_target_unavailable",
+            "message": str(exc),
+        })
+
+    sid = extract_status_id(raw)
+    if not sid:
+        return _with_next_steps("vendor_news_draft", {
+            "error": "invalid_tweet_id",
+            "message": f"could not parse status id from {raw!r}",
+        })
+
+    fetched = fetch_tweet_by_id(sid)
+    if not isinstance(fetched, dict) or fetched.get("error"):
+        return _with_next_steps("vendor_news_draft", {
+            "error": "fetch_failed",
+            "message": (fetched or {}).get("error", "unknown fetch error"),
+            "tweet_id": sid,
+        })
+
+    # Map watchlist vendor metadata onto the source author. Falls back
+    # gracefully if the tweet author isn't in the watchlist (e.g.
+    # founder is testing a one-off riff against an off-watchlist post).
+    try:
+        from ai.vendor_news.sensor import load_watchlist
+        from ai.vendor_news import draft_vendor_riff
+    except Exception as exc:
+        return _with_next_steps("vendor_news_draft", {
+            "error": "vendor_news_unavailable",
+            "message": str(exc),
+        })
+
+    author = (fetched.get("author") or "").lstrip("@")
+    vendor_name = ""
+    products: List[str] = []
+    try:
+        cfg = load_watchlist()
+        for acc in cfg.get("accounts") or []:
+            if (acc.get("handle") or "").lstrip("@").lower() == author.lower():
+                vendor_name = acc.get("vendor", "") or author
+                products = list(acc.get("products") or [])
+                break
+    except Exception:
+        pass
+    if not vendor_name:
+        vendor_name = author or "unknown"
+
+    triggered = {
+        "id": fetched.get("id") or sid,
+        "text": fetched.get("text") or "",
+        "author": author,
+        "url": fetched.get("url") or f"https://x.com/i/status/{sid}",
+        "created_at": fetched.get("created_at") or "",
+        "metrics": fetched.get("metrics") or {},
+        "vendor": vendor_name,
+        "products": products,
+        "trigger_reason": "manual_draft",
+    }
+
+    # On dry_run, route the queue write to a temp path so the real
+    # tweet queue is untouched. Drafter still runs validator + fit gates.
+    queue_path_override = None
+    if dry_run:
+        try:
+            import tempfile as _tempfile
+            tmp = _tempfile.NamedTemporaryFile(
+                mode="w", suffix=".json", prefix="vendor_news_dry_",
+                delete=False, encoding="utf-8",
+            )
+            tmp.write("[]")
+            tmp.close()
+            queue_path_override = Path(tmp.name)
+        except Exception:
+            queue_path_override = None
+
+    try:
+        if queue_path_override is not None:
+            res = draft_vendor_riff(triggered, queue_path=queue_path_override)
+        else:
+            res = draft_vendor_riff(triggered)
+    except Exception as exc:
+        return _with_next_steps("vendor_news_draft", {
+            "error": "drafter_failed",
+            "message": str(exc),
+            "tweet_id": sid,
+        })
+
+    out = {
+        "decision": res.get("decision"),
+        "text": res.get("text"),
+        "reason": res.get("reason"),
+        "queue_entry": res.get("queue_entry") if not dry_run else None,
+        "validator_result": res.get("validator_result"),
+        "fit_result": res.get("fit_result"),
+        "source": {
+            "id": triggered["id"],
+            "author": author,
+            "vendor": vendor_name,
+            "url": triggered["url"],
+        },
+        "dry_run": bool(dry_run),
+    }
+    return _with_next_steps("vendor_news_draft", out)
+
+
 # ═══════════════════════════════════════════════════════════════════════
 #  CONTENT ENGINE - Autonomous video + tweet pipeline (Pro)
 # ═══════════════════════════════════════════════════════════════════════

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "delimit-cli",
   "mcpName": "io.github.delimit-ai/delimit-mcp-server",
-  "version": "4.5.4",
+  "version": "4.5.6",
   "description": "Unify Claude Code, Codex, Cursor, and Gemini CLI with persistent context, governance, and multi-model debate.",
   "main": "index.js",
   "files": [