blun-king-cli 9.0.0 → 9.0.1

package/mnemo/write_gate_risk.js

@@ -1,80 +0,0 @@
-"use strict";
-
-const PRODUCTION_RE = /\b(production|prod|live|deploy|pm2|nginx|dns|ssl|cert|rollback)\b/;
-const BILLING_RE = /\b(stripe|billing|invoice|pricing|checkout|refund|vat|vies|oss|subscription|plan)\b/;
-const AUTH_RE = /\b(auth|login|signup|signin|sign-in|sso|session|cookie|oauth|password|reset|forgot|verify|onboarding|account)\b/;
-const WRITE_RE = /\b(edit|change|fix|implement|update|deploy|restart|migrate|patch|write|remove|delete|rename|refactor|create|build|rollout)\b/;
-
-const RISK_TERMS =
-  "(?:production|prod|live|deploy|deployment|pm2|nginx|dns|ssl|cert|rollback|" +
-  "auth|login|signup|signin|sign-in|sso|session|cookie|oauth|password|reset|forgot|verify|onboarding|account|" +
-  "stripe|billing|invoice|pricing|checkout|refund|vat|vies|oss|subscription|plan|" +
-  "server|servers|env|secret|secrets|source|app|apps)";
-
-const NEGATED_LIST_RE = new RegExp(
-  "\\b(?:no|without|never|keine|kein|keinen|ohne)\\s+" +
-  "(?:" + RISK_TERMS + "(?:\\s*(?:/|,|;|\\+|&|\\band\\b|\\bor\\b|\\bund\\b|\\boder\\b|\\s)\\s*)?){1,16}" +
-  "(?:\\s+(?:work|edits?|writes?|changes?|scope|paths?|files?|activity|actions?))?",
-  "gi"
-);
-
-const DO_NOT_TOUCH_RE = new RegExp(
-  "\\b(?:do\\s+not|don't|dont|never|nicht)\\s+" +
-  "(?:touch|edit|change|write|deploy|modify|manage|alter)\\s+" +
-  "[^.;\\n]{0,100}\\b" + RISK_TERMS + "\\b[^.;\\n]{0,80}",
-  "gi"
-);
-
-const ORPHAN_NEGATED_TAIL_RE = new RegExp(
-  "\\b(?:or|and|oder|und)\\s+" + RISK_TERMS +
-  "(?:\\s+(?:work|edits?|writes?|changes?|scope|paths?|files?|activity|actions?))?",
-  "gi"
-);
-
-function riskScanText(text) {
-  let removedNegatedRisk = false;
-  let out = String(text || "")
-    .replace(NEGATED_LIST_RE, () => {
-      removedNegatedRisk = true;
-      return " ";
-    })
-    .replace(DO_NOT_TOUCH_RE, () => {
-      removedNegatedRisk = true;
-      return " ";
-    });
-  if (removedNegatedRisk) out = out.replace(ORPHAN_NEGATED_TAIL_RE, " ");
-  return out;
-}
-
-function classifyActionRisk(input = {}) {
-  const text = [
-    input.project,
-    input.task,
-    input.summary,
-    input.action_type,
-    Array.isArray(input.topics) ? input.topics.join(" ") : "",
-    Array.isArray(input.files) ? input.files.join(" ") : "",
-    Array.isArray(input.system_names) ? input.system_names.join(" ") : ""
-  ].filter(Boolean).join(" ");
-  const normalized = riskScanText(text).toLowerCase();
-  const rawActionType = String(input.action_type || "").toLowerCase();
-  const touchesProduction = PRODUCTION_RE.test(normalized) || /\bdeploy\b/.test(rawActionType);
-  const touchesBilling = BILLING_RE.test(normalized);
-  const touchesAuth = AUTH_RE.test(normalized);
-  const writeIntent = WRITE_RE.test(normalized) || WRITE_RE.test(rawActionType);
-  const environment = input.environment || (touchesProduction ? "production" : "staging");
-  return {
-    text,
-    scan_text: normalized,
-    write_intent: writeIntent,
-    touches_production: touchesProduction,
-    touches_billing: touchesBilling,
-    touches_auth: touchesAuth,
-    environment,
-  };
-}
-
-module.exports = {
-  classifyActionRisk,
-  riskScanText,
-};

package/mnemo/writer_health.js

@@ -1,152 +0,0 @@
-"use strict";
-
-const DEFAULT_REQUIRED_FRESH_WRITERS = [];
-const DEFAULT_STALE_MS = 2 * 60 * 60 * 1000;
-const DEFAULT_DEAD_MS = 24 * 60 * 60 * 1000;
-
-const HEALTHY_STATUSES = new Set([
-  "alive",
-  "alive_no_new",
-  "ok",
-  "healthy",
-  "success",
-  "idle",
-]);
-
-function normalizeStatus(status) {
-  return String(status || "").trim().toLowerCase();
-}
-
-function parseList(value, fallback) {
-  const raw = value == null || value === "" ? fallback : value;
-  const list = Array.isArray(raw) ? raw : String(raw || "").split(",");
-  return list.map((item) => String(item || "").trim()).filter(Boolean);
-}
-
-function requiredFreshWriterSet(options = {}) {
-  return new Set(parseList(
-    options.requiredFreshWriters ||
-      process.env.MNEMO_WRITER_HEALTH_REQUIRED ||
-      process.env.MNEMO_HOOK_WATCHDOG_CRITICAL_WRITERS,
-    DEFAULT_REQUIRED_FRESH_WRITERS
-  ));
-}
-
-function writerStatusClass(status) {
-  const s = normalizeStatus(status);
-  if (!s) return "unknown";
-  if (s === "stale") return "stale";
-  if (s === "dead") return "dead";
-  if (s.startsWith("disabled")) return "disabled";
-  if (s.startsWith("error") || s.includes("database is locked") || s.includes("sqlite_corrupt")) return "error";
-  if (s.startsWith("blocked")) return "blocked";
-  if (s.startsWith("partial")) return "degraded";
-  if (HEALTHY_STATUSES.has(s)) return "healthy";
-  return "unknown";
-}
-
-function ageMs(iso, nowMs) {
-  const t = iso ? Date.parse(iso) : 0;
-  if (!t) return null;
-  return Math.max(0, nowMs - t);
-}
-
-function freshnessFromAge(age, staleMs, deadMs, required) {
-  if (age == null) return required ? "missing" : "not_required";
-  if (age > deadMs) return required ? "critical" : "idle";
-  if (age > staleMs) return required ? "stale" : "idle";
-  return "fresh";
-}
-
-function assessWriterHealth(row = {}, options = {}) {
-  const writer = String(row.writer || "");
-  const status = normalizeStatus(row.status);
-  const statusClass = writerStatusClass(status);
-  const nowMs = options.nowMs || Date.now();
-  const staleMs = Number(options.staleMs || DEFAULT_STALE_MS);
-  const deadMs = Number(options.deadMs || DEFAULT_DEAD_MS);
-  const lastWriteAgeMs = ageMs(row.last_write_at, nowMs);
-  const lastCheckAgeMs = ageMs(row.last_check_at, nowMs);
-  const freshnessRequired = requiredFreshWriterSet(options).has(writer);
-  const freshness = freshnessFromAge(lastWriteAgeMs, staleMs, deadMs, freshnessRequired);
-
-  let healthy = true;
-  let reason = "writer is informational or event-driven";
-  let nextStatus = status || "idle";
-  let drift = false;
-  let driftSeverity = "M";
-
-  if (statusClass === "disabled") {
-    reason = `writer disabled (${status})`;
-    nextStatus = status;
-  } else if (["error", "blocked", "degraded"].includes(statusClass)) {
-    healthy = false;
-    drift = true;
-    driftSeverity = statusClass === "degraded" ? "M" : "H";
-    reason = `writer status is ${status}`;
-    nextStatus = status;
-  } else if (freshnessRequired) {
-    if (lastWriteAgeMs == null) {
-      healthy = false;
-      drift = true;
-      driftSeverity = "H";
-      reason = "required writer has never written";
-      nextStatus = "missing";
-    } else if (lastWriteAgeMs > deadMs) {
-      healthy = false;
-      drift = true;
-      driftSeverity = "H";
-      reason = "required writer has not written within dead threshold";
-      nextStatus = "dead";
-    } else if (lastWriteAgeMs > staleMs) {
-      healthy = false;
-      drift = true;
-      driftSeverity = "M";
-      reason = "required writer has not written within stale threshold";
-      nextStatus = "stale";
-    } else {
-      reason = "required writer is fresh";
-      nextStatus = "alive";
-    }
-  } else if (lastWriteAgeMs != null && lastWriteAgeMs <= staleMs && statusClass !== "unknown") {
-    reason = "writer wrote recently";
-    nextStatus = HEALTHY_STATUSES.has(status) ? status : "alive";
-  } else {
-    reason = "writer is not freshness-gated";
-    nextStatus = statusClass === "stale" || statusClass === "dead" || !status ? "idle" : status;
-  }
-
-  return {
-    writer,
-    status,
-    status_class: statusClass,
-    freshness_required: freshnessRequired,
-    freshness,
-    healthy,
-    drift,
-    drift_severity: driftSeverity,
-    health_reason: reason,
-    next_status: nextStatus,
-    last_write_age_ms: lastWriteAgeMs,
-    last_write_age_min: lastWriteAgeMs == null ? null : Math.round(lastWriteAgeMs / 60000),
-    last_check_age_ms: lastCheckAgeMs,
-    last_check_age_min: lastCheckAgeMs == null ? null : Math.round(lastCheckAgeMs / 60000),
-  };
-}
-
-function enrichWriterHealth(row, options = {}) {
-  return Object.assign({}, row, assessWriterHealth(row, options));
-}
-
-function enrichWriterHealthRows(rows, options = {}) {
-  return (rows || []).map((row) => enrichWriterHealth(row, options));
-}
-
-module.exports = {
-  DEFAULT_REQUIRED_FRESH_WRITERS,
-  assessWriterHealth,
-  enrichWriterHealth,
-  enrichWriterHealthRows,
-  requiredFreshWriterSet,
-  writerStatusClass,
-};

package/skills/doku-ingestion/SKILL.md

@@ -1,48 +0,0 @@
----
-name: doku-ingestion
-description: "Eine API-/Software-Dokumentation dauerhaft ins eigene Gedaechtnis aufnehmen: crawlen, in sinnvolle Abschnitte zerlegen und in Mnemo speichern, damit Endpunkte, Parameter und Code-Beispiele spaeter zuverlaessig zitierbar sind. Mandatory triggers: 'lern die API-Doku von X', 'nimm die Doku auf', 'merk dir die Dokumentation', 'ingest docs', 'speichere die Doku dauerhaft', eine Doku-URL mit der Bitte, sie zu behalten. Fuer einmaliges Lesen ohne Speichern reicht der web-lesen-Skill."
----
-
-# Doku-Ingestion
-
-Der Unterschied zu web-lesen: hier wird die Doku nicht nur EINMAL gelesen,
-sondern DAUERHAFT ins Gedaechtnis aufgenommen — in zitierbaren Abschnitten,
-sodass du spaeter „welche Parameter hat Endpunkt X?" beantworten kannst, ohne
-die Seite erneut zu laden.
-
-## Ablauf
-
-```bash
-python ingest_docs.py "<DOKU-URL>" --source <kurzname>
-```
-
-Das Skript (liegt neben dieser Datei):
-1. Crawlt die Seite mit Crawl4AI zu sauberem Markdown.
-2. Zerlegt sie an Ueberschriften in Abschnitte (grosse weiter an Absaetzen,
-   ~1800 Zeichen pro Stueck — ein Endpunkt/Thema pro Abschnitt).
-3. Speichert jeden Abschnitt als Capture in deine Mnemo-Lane, mit URL, Quelle
-   und Abschnittsnummer in den Metadaten.
-
-Voraussetzungen (Umgebung setzt der Starter):
-`BLUN_MNEMO_MCP` (Pfad mcp.js), `BLUN_MNEMO_AGENT`, ggf. `BLUN_MNEMO_NODE`.
-Crawl4AI einmalig: `pip install crawl4ai && crawl4ai-setup`.
-
-## Spaeter abrufen
-
-Nach dem Ingest findest du Doku-Wissen ueber die normale Erinnerung:
-`mem_recall` mit der Frage (z.B. „glm chat completions parameter"). Die
-Abschnitte kommen mit Quelle+URL zurueck — zitiere sie mit Herkunft.
-
-## Mehrseitige Dokus
-
-Erst die Uebersichtsseite lesen (web-lesen), die Unterseiten-Links sammeln,
-dann pro relevanter Unterseite `ingest_docs.py` aufrufen. Nicht die ganze
-Domain blind crawlen — nur die fuer die Aufgabe noetigen Seiten.
-
-## Regeln
-
-- Nur oeffentliche/offizielle Dokus. Keine bezahlten/geschuetzten Inhalte
-  ohne Auftrag.
-- Bei bekannten Libraries zuerst den Context7-MCP versuchen (immer aktuell,
-  kein Crawlen). Crawl4AI fuer alles ohne Context7-Eintrag.
-- Immer sagen, WAS du aufgenommen hast (Quelle + wie viele Abschnitte).

package/skills/doku-ingestion/ingest_docs.py

@@ -1,133 +0,0 @@
-#!/usr/bin/env python
-"""BLUN Doku-Ingestion: eine (API-)Doku crawlen -> in Abschnitte zerlegen ->
-in die eigene Mnemo-Lane speichern, damit sie spaeter zitierbar wiederfindbar
-ist. Kein Cloud-Dienst, alles lokal.
-
-Nutzung:
-    python ingest_docs.py <URL> [--source doku-name] [--max-chunks N]
-
-Voraussetzung: crawl4ai (pip install crawl4ai) und ein laufender Mnemo-MCP
-(mcp.js) — Pfad via BLUN_MNEMO_MCP, Agent via BLUN_MNEMO_AGENT.
-"""
-import asyncio
-import json
-import os
-import re
-import subprocess
-import sys
-
-MCP = os.environ.get("BLUN_MNEMO_MCP")
-NODE = os.environ.get("BLUN_MNEMO_NODE") or "node"
-AGENT = os.environ.get("BLUN_MNEMO_AGENT", "agent")
-CHUNK_CHARS = 1800  # ~ ein sinnvoller Doku-Abschnitt
-
-
-def chunk_markdown(md: str):
-    """Zerteilt Markdown an Ueberschriften; grosse Bloecke weiter an Absaetzen."""
-    parts = re.split(r"(?=^#{1,4}\s)", md, flags=re.MULTILINE)
-    chunks = []
-    for part in parts:
-        part = part.strip()
-        if not part:
-            continue
-        if len(part) <= CHUNK_CHARS:
-            chunks.append(part)
-        else:
-            buf = ""
-            for para in part.split("\n\n"):
-                if len(buf) + len(para) + 2 > CHUNK_CHARS and buf:
-                    chunks.append(buf.strip())
-                    buf = ""
-                buf += para + "\n\n"
-            if buf.strip():
-                chunks.append(buf.strip())
-    return [c for c in chunks if len(c) > 40]
-
-
-async def crawl(url: str) -> str:
-    from crawl4ai import AsyncWebCrawler
-    async with AsyncWebCrawler() as c:
-        res = await c.arun(url=url)
-        return res.markdown or ""
-
-
-def ingest(items):
-    """Spricht mcp.js per JSON-RPC/stdio, capture-batch in Chunks."""
-    if not MCP or not os.path.exists(MCP):
-        print("WARN: BLUN_MNEMO_MCP nicht gesetzt/gefunden — speichere nicht, gebe nur aus.")
-        for it in items[:3]:
-            print("  -", it["content"][:80].replace("\n", " "))
-        print(f"  ... {len(items)} Abschnitte insgesamt (nicht gespeichert).")
-        return
-    proc = subprocess.Popen(
-        [NODE, MCP], stdin=subprocess.PIPE, stdout=subprocess.PIPE,
-        stderr=subprocess.DEVNULL, text=True, env={**os.environ, "MNEMO_AGENT": AGENT},
-    )
-    nid = 0
-
-    def rpc(method, params):
-        nonlocal nid
-        nid += 1
-        proc.stdin.write(json.dumps({"jsonrpc": "2.0", "id": nid, "method": method, "params": params}) + "\n")
-        proc.stdin.flush()
-        for line in proc.stdout:
-            line = line.strip()
-            if not line:
-                continue
-            try:
-                msg = json.loads(line)
-            except Exception:
-                continue
-            if msg.get("id") == nid:
-                return msg
-        return None
-
-    rpc("initialize", {"protocolVersion": "2024-11-05", "capabilities": {}, "clientInfo": {"name": "doku-ingest", "version": "1"}})
-    proc.stdin.write(json.dumps({"jsonrpc": "2.0", "method": "notifications/initialized"}) + "\n")
-    proc.stdin.flush()
-    captured = 0
-    for i in range(0, len(items), 20):
-        batch = items[i:i + 20]
-        res = rpc("tools/call", {"name": "mem_capture_ingest_batch", "arguments": {"items": batch}})
-        text = ((res or {}).get("result", {}).get("content") or [{}])[0].get("text", "{}")
-        try:
-            captured += json.loads(text).get("captured", 0)
-        except Exception:
-            pass
-    proc.terminate()
-    print(f"Gespeichert: {captured}/{len(items)} Doku-Abschnitte in Mnemo (Agent {AGENT}).")
-
-
-def main():
-    if len(sys.argv) < 2:
-        print("Nutzung: python ingest_docs.py <URL> [--source name] [--max-chunks N]")
-        sys.exit(1)
-    url = sys.argv[1]
-    source = "doku"
-    max_chunks = 200
-    if "--source" in sys.argv:
-        source = sys.argv[sys.argv.index("--source") + 1]
-    if "--max-chunks" in sys.argv:
-        max_chunks = int(sys.argv[sys.argv.index("--max-chunks") + 1])
-
-    md = asyncio.run(crawl(url))
-    if not md.strip():
-        print("Keine Inhalte gecrawlt — URL erreichbar?")
-        sys.exit(1)
-    chunks = chunk_markdown(md)[:max_chunks]
-    thread = f"doku-{re.sub(r'[^a-z0-9]+', '-', source.lower()).strip('-') or 'x'}"
-    items = [{
-        "source": "doku", "channel": "doku-ingest", "direction": "inbound",
-        "actor": AGENT, "event_kind": "doc_chunk",
-        "occurred_at": "1970-01-01T00:00:00Z",  # Aufrufer/Hub stempelt real
-        "ref_id": f"doku-{source}-{n}",
-        "content": f"[{source}] {url}\n\n{c}"[:4000],
-        "meta": {"for_agent": AGENT, "doc_url": url, "doc_source": source, "chunk": n},
-        "thread_id": thread,
-    } for n, c in enumerate(chunks)]
-    print(f"Gecrawlt: {len(md)} Zeichen -> {len(items)} Abschnitte aus {url}")
-    ingest(items)
-
-
-if __name__ == "__main__":
-    main()