blun-king-cli 4.1.1 → 5.0.1

package/palace-memory.js

@@ -0,0 +1,246 @@
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { execFileSync } = require("child_process");
+
+const BLUN_HOME = process.env.BLUN_HOME || path.join(os.homedir(), ".blun");
+const PALACE_BASE = path.join(BLUN_HOME, "palaces");
+const GLOBAL_PALACE = path.join(PALACE_BASE, "_global");
+
+let mempalaceSupport;
+
+ensureDir(PALACE_BASE);
+ensurePalaceSkeleton(GLOBAL_PALACE);
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function ensurePalaceSkeleton(dir) {
+  ensureDir(dir);
+  ensureDir(path.join(dir, "memory"));
+}
+
+function safeId(value) {
+  return String(value || "global").replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+
+function getUserPalace(userId) {
+  const dir = userId ? path.join(PALACE_BASE, safeId(userId)) : GLOBAL_PALACE;
+  ensurePalaceSkeleton(dir);
+  maybeInitMempalace(dir);
+  return dir;
+}
+
+function getPythonBinary() {
+  if (process.env.BLUN_PYTHON) return process.env.BLUN_PYTHON;
+  return process.platform === "win32" ? "python" : "python3";
+}
+
+function detectMempalace() {
+  if (mempalaceSupport !== undefined) return mempalaceSupport;
+
+  try {
+    execFileSync(getPythonBinary(), ["-m", "mempalace", "--help"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 4000
+    });
+    mempalaceSupport = true;
+  } catch {
+    mempalaceSupport = false;
+  }
+
+  return mempalaceSupport;
+}
+
+function maybeInitMempalace(dir) {
+  if (!detectMempalace()) return false;
+
+  const marker = path.join(dir, ".mempalace-init");
+  if (fs.existsSync(marker)) return true;
+
+  try {
+    execFileSync(getPythonBinary(), ["-m", "mempalace", "init", "--yes", "."], {
+      cwd: dir,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 15000
+    });
+    fs.writeFileSync(marker, "ok", "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function runMempalace(dir, args, timeout = 10000) {
+  return execFileSync(getPythonBinary(), ["-m", "mempalace", ...args], {
+    cwd: dir,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout
+  });
+}
+
+function memoryDir(dir) {
+  const target = path.join(dir, "memory");
+  ensureDir(target);
+  return target;
+}
+
+function listMemoryFiles(dir) {
+  const target = memoryDir(dir);
+  return fs.readdirSync(target)
+    .filter((entry) => entry.endsWith(".md"))
+    .map((entry) => path.join(target, entry));
+}
+
+function scoreText(text, query) {
+  const haystack = String(text || "").toLowerCase();
+  const needles = String(query || "").toLowerCase().split(/\s+/).filter(Boolean);
+  if (needles.length === 0) return haystack.length ? 1 : 0;
+  return needles.reduce((score, needle) => score + (haystack.includes(needle) ? 1 : 0), 0);
+}
+
+function fallbackSearch(query, limit, userId) {
+  const dir = getUserPalace(userId);
+  const scored = listMemoryFiles(dir)
+    .map((file) => {
+      const content = fs.readFileSync(file, "utf8");
+      return {
+        file,
+        content,
+        score: scoreText(content, query)
+      };
+    })
+    .filter((entry) => entry.score > 0)
+    .sort((a, b) => b.score - a.score || b.file.localeCompare(a.file))
+    .slice(0, limit);
+
+  if (scored.length === 0) return "Keine Ergebnisse.";
+
+  return scored.map((entry) => {
+    const snippet = entry.content.replace(/\s+/g, " ").trim().slice(0, 300);
+    return `${path.basename(entry.file)}\n${snippet}`;
+  }).join("\n\n");
+}
+
+function fallbackWakeUp(userId) {
+  const dir = getUserPalace(userId);
+  const entries = listMemoryFiles(dir)
+    .map((file) => ({ file, stat: fs.statSync(file) }))
+    .sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs)
+    .slice(0, 5)
+    .map(({ file }) => {
+      const content = fs.readFileSync(file, "utf8").replace(/\s+/g, " ").trim();
+      return `- ${path.basename(file)}: ${content.slice(0, 220)}`;
+    });
+
+  return entries.length ? entries.join("\n") : "";
+}
+
+function fallbackStats(userId) {
+  const dir = getUserPalace(userId);
+  const files = listMemoryFiles(dir);
+  return `Palace local fallback active. Files: ${files.length}`;
+}
+
+function appendEntry(dir, filename, text) {
+  const file = path.join(memoryDir(dir), filename);
+  fs.appendFileSync(file, text, "utf8");
+  return file;
+}
+
+function palaceSearch(query, limit = 5, userId) {
+  const dir = getUserPalace(userId);
+
+  if (detectMempalace()) {
+    try {
+      const out = runMempalace(dir, ["search", String(query || ""), "--results", String(limit)], 10000);
+      return out.trim() || "Keine Ergebnisse.";
+    } catch {
+      return fallbackSearch(query, limit, userId);
+    }
+  }
+
+  return fallbackSearch(query, limit, userId);
+}
+
+function palaceStore(text, source = "misc", userId) {
+  const dir = getUserPalace(userId);
+  const stamp = new Date();
+  const filename = `${stamp.toISOString().slice(0, 10)}_${safeId(source).slice(0, 30) || "misc"}.md`;
+  const entry = `\n## ${stamp.toISOString()}\n${String(text || "").trim()}\n`;
+
+  try {
+    appendEntry(dir, filename, entry);
+
+    if (detectMempalace()) {
+      try {
+        runMempalace(dir, ["mine", "."], 30000);
+      } catch {
+        // Local markdown store already succeeded.
+      }
+    }
+
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function palaceWakeUp(userId) {
+  const dir = getUserPalace(userId);
+
+  if (detectMempalace()) {
+    try {
+      const out = runMempalace(dir, ["wake-up"], 10000);
+      return out.trim();
+    } catch {
+      return fallbackWakeUp(userId);
+    }
+  }
+
+  return fallbackWakeUp(userId);
+}
+
+function palaceLearn(knowledge, source = "learn", userId) {
+  return palaceStore(knowledge, `learn_${source}`, userId);
+}
+
+function palaceLogChat(userId, role, content) {
+  const dir = getUserPalace(userId);
+  const stamp = new Date();
+  const filename = `chat_${stamp.toISOString().slice(0, 10)}.md`;
+  const snippet = String(content || "").replace(/\s+/g, " ").trim().slice(0, 1200);
+  appendEntry(dir, filename, `\n**${stamp.toISOString().slice(11, 16)} ${role}:** ${snippet}\n`);
+  return true;
+}
+
+function palaceStats(userId) {
+  const dir = getUserPalace(userId);
+
+  if (detectMempalace()) {
+    try {
+      const out = runMempalace(dir, ["status"], 10000);
+      return out.trim();
+    } catch {
+      return fallbackStats(userId);
+    }
+  }
+
+  return fallbackStats(userId);
+}
+
+module.exports = {
+  PALACE_BASE,
+  GLOBAL_PALACE,
+  getUserPalace,
+  palaceSearch,
+  palaceStore,
+  palaceWakeUp,
+  palaceLearn,
+  palaceLogChat,
+  palaceStats
+};

package/reference-inspector.js

@@ -0,0 +1,228 @@
+const path = require("path");
+const { execFile } = require("child_process");
+const { storeReference } = require("./local-data");
+
+let chromiumLoader = null;
+
+function extractUrls(text) {
+  return Array.from(String(text || "").matchAll(/https?:\/\/[^\s)>"']+/gi)).map((match) => match[0]);
+}
+
+function summarizeHtml(source) {
+  const title = (source.match(/<title[^>]*>([\s\S]*?)<\/title>/i) || [, ""])[1].trim();
+  const h1s = [...source.matchAll(/<h1[^>]*>([\s\S]*?)<\/h1>/ig)]
+    .map((match) => match[1].replace(/<[^>]+>/g, "").trim())
+    .filter(Boolean);
+  const links = [...source.matchAll(/<a\b/ig)].length;
+  const images = [...source.matchAll(/<img\b/ig)].length;
+  const text = cleanText((source.match(/<body[^>]*>([\s\S]*?)<\/body>/i) || [, source])[1]).slice(0, 3000);
+
+  return {
+    title,
+    h1s,
+    links,
+    images,
+    text,
+    responsive: /<meta[^>]+name=["']viewport["']/i.test(source)
+  };
+}
+
+function cleanText(source) {
+  return String(source || "")
+    .replace(/<script[\s\S]*?<\/script>/gi, " ")
+    .replace(/<style[\s\S]*?<\/style>/gi, " ")
+    .replace(/<[^>]+>/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function shouldAutoReference(input, task = {}) {
+  const text = String(input || "");
+  if (!extractUrls(text).length) return false;
+  if (["installation", "browser_capture"].includes(task?.type)) return false;
+  if (task?.type === "website_builder" || task?.type === "analysis") return true;
+  return /\b(referenz|vorlage|inspiriert|angelehnt|wie diese|wie die|schau dir|analysier.*https?:\/\/|bau.*https?:\/\/)\b/i.test(text);
+}
+
+function buildReferencePromptBlock(references = []) {
+  if (!Array.isArray(references) || references.length === 0) return "";
+
+  const lines = ["[Auto Reference Chain]"];
+  references.forEach((ref, index) => {
+    const summary = ref.summary || ref;
+    lines.push(`Referenz ${index + 1}: ${ref.url || "-"}`);
+    if (summary.title) lines.push(`Titel: ${summary.title}`);
+    if (Array.isArray(summary.h1s) && summary.h1s.length) lines.push(`H1: ${summary.h1s.join(" | ")}`);
+    if (summary.text) lines.push(`Text: ${String(summary.text).slice(0, 500)}`);
+    if (typeof summary.links === "number") lines.push(`Links: ${summary.links}`);
+    if (typeof summary.images === "number") lines.push(`Bilder: ${summary.images}`);
+    if (ref.screenshotPath) lines.push(`Screenshot: ${ref.screenshotPath}`);
+    if (ref.error) lines.push(`Fehler: ${ref.error}`);
+  });
+
+  return lines.join("\n");
+}
+
+async function loadChromium() {
+  if (chromiumLoader !== null) return chromiumLoader;
+
+  try {
+    const playwright = require("playwright");
+    chromiumLoader = playwright.chromium;
+  } catch {
+    chromiumLoader = false;
+  }
+
+  return chromiumLoader;
+}
+
+function execFileAsync(command, args) {
+  return new Promise((resolve, reject) => {
+    execFile(command, args, { maxBuffer: 20 * 1024 * 1024 }, (error, stdout, stderr) => {
+      if (error) reject(new Error(stderr || error.message));
+      else resolve(stdout);
+    });
+  });
+}
+
+async function fetchHtml(url, options = {}) {
+  try {
+    const resp = await fetch(url, {
+      headers: {
+        "User-Agent": options.userAgent || "BLUN-King/5.0 (+reference-inspector)"
+      }
+    });
+    if (!resp.ok) throw new Error(`Reference fetch failed with HTTP ${resp.status}`);
+    return await resp.text();
+  } catch {
+    try {
+      const curlBinary = process.platform === "win32" ? "curl.exe" : "curl";
+      return await execFileAsync(curlBinary, [
+        "-L",
+        "-A",
+        options.userAgent || "BLUN-King/5.0 (+reference-inspector)",
+        url
+      ]);
+    } catch {
+      if (process.platform === "win32") {
+        const script = [
+          `$ProgressPreference='SilentlyContinue'`,
+          `$resp = Invoke-WebRequest -UseBasicParsing -Headers @{'User-Agent'='${options.userAgent || "BLUN-King/5.0 (+reference-inspector)"}'} -Uri '${url}'`,
+          `[Console]::Out.Write($resp.Content)`
+        ].join("; ");
+        return await execFileAsync("powershell.exe", ["-NoProfile", "-Command", script]);
+      }
+
+      throw new Error("Reference fetch failed");
+    }
+  }
+}
+
+async function inspectReference(url, options = {}) {
+  let html = "";
+  let summary = {
+    title: "",
+    h1s: [],
+    links: 0,
+    images: 0,
+    responsive: false
+  };
+  const result = {
+    url,
+    fetchedAt: Date.now(),
+    summary,
+    html,
+    screenshotPath: null,
+    screenshotAvailable: false,
+    error: null
+  };
+
+  try {
+    html = await fetchHtml(url, options);
+    summary = summarizeHtml(html);
+    result.html = html;
+    result.summary = summary;
+  } catch (error) {
+    result.error = error.message;
+  }
+
+  if (!result.error && options.screenshot !== false) {
+    const chromium = await loadChromium();
+    if (chromium) {
+      try {
+        const browser = await chromium.launch({ headless: true });
+        try {
+          const page = await browser.newPage({ viewport: { width: 1440, height: 1024 } });
+          await page.goto(url, { waitUntil: "networkidle", timeout: options.timeout || 30000 });
+          const stored = storeReference(url, {
+            type: "reference",
+            mode: "html+screenshot",
+            summary
+          });
+          const screenshotPath = path.join(path.dirname(stored.filePath), `${stored.id}.png`);
+          await page.screenshot({ path: screenshotPath, fullPage: true });
+          result.screenshotPath = screenshotPath;
+          result.screenshotAvailable = true;
+          result.storage = stored.filePath;
+        } finally {
+          await browser.close();
+        }
+      } catch {
+        result.screenshotAvailable = false;
+      }
+    }
+  }
+
+  if (!result.storage) {
+    const stored = storeReference(url, {
+      type: "reference",
+      mode: result.error ? "error" : "html",
+      summary,
+      error: result.error
+    });
+    result.storage = stored.filePath;
+  }
+
+  return result;
+}
+
+async function screenshotUrl(url, options = {}) {
+  const result = await inspectReference(url, { ...options, screenshot: true });
+  return {
+    url: result.url,
+    screenshotPath: result.screenshotPath,
+    screenshotAvailable: result.screenshotAvailable,
+    summary: result.summary,
+    storage: result.storage,
+    error: result.error
+  };
+}
+
+async function autoReferenceChain(input, options = {}) {
+  const urls = extractUrls(input).slice(0, options.limit || 2);
+  const references = [];
+
+  for (const url of urls) {
+    try {
+      references.push(await inspectReference(url, { screenshot: options.screenshot !== false }));
+    } catch (error) {
+      references.push({
+        url,
+        error: error.message,
+        summary: { title: "", h1s: [], links: 0, images: 0, text: "", responsive: false }
+      });
+    }
+  }
+
+  return references;
+}
+
+module.exports = {
+  extractUrls,
+  inspectReference,
+  summarizeHtml,
+  shouldAutoReference,
+  buildReferencePromptBlock,
+  screenshotUrl,
+  autoReferenceChain
+};