blun-king-cli 4.1.0 → 5.0.0

package/blunking-api.js

@@ -0,0 +1,7 @@
+const api = require("./api");
+
+if (require.main === module) {
+  api.startServer();
+}
+
+module.exports = api;

package/bot.js

@@ -0,0 +1,188 @@
+const TelegramBot = require("node-telegram-bot-api");
+const os = require("os");
+const path = require("path");
+const runtime = require("./runtime");
+const memory = require("./chat-memory");
+const palace = require("./palace-memory");
+const taskExecutor = require("./task-executor");
+const { buildConversationMessages } = require("./message-builder");
+
+const BOT_TOKEN = process.env.BLUN_TELEGRAM_TOKEN || process.env.BLUN_TELEGRAM_BOT_TOKEN || "";
+const OLLAMA_URL = process.env.OLLAMA_URL || "http://127.0.0.1:11434/api/chat";
+const MODEL = process.env.BLUN_MODEL || "blun-king-v500";
+
+function stripThinking(text) {
+  return String(text || "").replace(/<think>[\s\S]*?<\/think>/gi, "").trim();
+}
+
+function resolveSessionId(msg = {}) {
+  const chatId = String(msg.chat?.id || "default");
+  const chatType = String(msg.chat?.type || "private");
+  const userId = msg.from?.id ? String(msg.from.id) : "anonymous";
+  return chatType === "private" ? chatId : `${chatId}::${userId}`;
+}
+
+function parsePalaceCommand(text = "") {
+  const trimmed = String(text || "").trim();
+  if (!trimmed.startsWith("/palace")) return null;
+
+  const rest = trimmed.slice("/palace".length).trim();
+  if (!rest || rest === "status") return { action: "status", value: "" };
+  if (rest === "recall") return { action: "recall", value: "" };
+  if (rest.startsWith("search ")) return { action: "search", value: rest.slice(7).trim() };
+  if (rest.startsWith("store ")) return { action: "store", value: rest.slice(6).trim() };
+  if (rest.startsWith("learn ")) return { action: "learn", value: rest.slice(6).trim() };
+  return { action: "unknown", value: rest };
+}
+
+async function ollamaChat(messages) {
+  const resp = await fetch(OLLAMA_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ model: MODEL, messages, stream: false })
+  });
+  if (!resp.ok) throw new Error(`Ollama error ${resp.status}`);
+  const data = await resp.json();
+  return stripThinking(data.message?.content || "");
+}
+
+async function sendLongMessage(bot, chatId, text) {
+  const chunks = String(text || "").match(/[\s\S]{1,3900}/g) || [""];
+  for (const chunk of chunks) {
+    if (chunk.trim()) {
+      await bot.sendMessage(chatId, chunk);
+    }
+  }
+}
+
+async function handlePalaceCommand(bot, msg, command) {
+  const sessionId = resolveSessionId(msg);
+  const chatId = msg.chat.id;
+
+  switch (command.action) {
+    case "status": {
+      const wake = palace.palaceWakeUp(sessionId);
+      const stats = palace.palaceStats(sessionId);
+      return bot.sendMessage(chatId, `BLUN KING MEMORY PALACE\n\n${stats}\n\nWake-Up:\n${wake || "leer"}`);
+    }
+    case "search":
+      return sendLongMessage(bot, chatId, palace.palaceSearch(command.value, 5, sessionId));
+    case "store": {
+      const ok = palace.palaceStore(command.value, "telegram-user", sessionId);
+      return bot.sendMessage(chatId, ok ? "Gespeichert." : "Speichern fehlgeschlagen.");
+    }
+    case "learn": {
+      const ok = palace.palaceLearn(command.value, "telegram-user", sessionId);
+      return bot.sendMessage(chatId, ok ? "Gelernt und gespeichert." : "Lernen fehlgeschlagen.");
+    }
+    case "recall":
+      return sendLongMessage(bot, chatId, palace.palaceWakeUp(sessionId) || "Kein Kontext vorhanden.");
+    default:
+      return bot.sendMessage(chatId, "Unbekannter Palace-Befehl. Nutze /palace, /palace search <query>, /palace store <text>, /palace recall oder /palace learn <text>.");
+  }
+}
+
+async function handleMessage(bot, msg) {
+  const text = String(msg.text || "").trim();
+  if (!text) return;
+
+  if (text === "/start") {
+    await bot.sendMessage(msg.chat.id, "BLUN KING ist aktiv.");
+    return;
+  }
+
+  if (text === "/tools") {
+    await bot.sendMessage(msg.chat.id, "Verfuegbar: Chat, Identitaeten, Memory Palace mit /palace, Browser- und Build-Faehigkeiten ueber die API/CLI.");
+    return;
+  }
+
+  const palaceCommand = parsePalaceCommand(text);
+  if (palaceCommand) {
+    await handlePalaceCommand(bot, msg, palaceCommand);
+    return;
+  }
+
+  const sessionId = resolveSessionId(msg);
+  const session = memory.loadSession(sessionId);
+  const task = runtime.classifyTask(text, session);
+  if (taskExecutor.isDirectActionTask(task)) {
+    const direct = await taskExecutor.executeDirectTask({
+      task,
+      message: text,
+      session,
+      workdir: path.join(process.env.BLUN_HOME || path.join(os.homedir(), ".blun"), "telegram-artifacts")
+    });
+    memory.appendHistory(sessionId, "user", text);
+    memory.appendHistory(sessionId, "assistant", direct.answer);
+    palace.palaceLogChat(sessionId, "user", text);
+    palace.palaceLogChat(sessionId, "assistant", direct.answer);
+    memory.setActiveTask(sessionId, {
+      type: task.type,
+      role: task.role,
+      output: task.output,
+      lastUserIntent: text
+    });
+    await bot.sendMessage(msg.chat.id, direct.answer);
+    if (task.type === "browser_capture" && Array.isArray(direct.references) && direct.references[0]?.screenshotPath) {
+      await bot.sendDocument(msg.chat.id, direct.references[0].screenshotPath).catch(() => {});
+    }
+    return;
+  }
+  const identity = runtime.resolveIdentity(text, task, session);
+  const palaceContext = palace.palaceWakeUp(sessionId);
+  const prompt = runtime.composeSystemPrompt(task, session, text, identity.id) +
+    (palaceContext ? `\n\n[Langzeitgedaechtnis]\n${palaceContext.slice(0, 2000)}` : "");
+
+  palace.palaceLogChat(sessionId, "user", text);
+
+  const answer = await ollamaChat(buildConversationMessages({ prompt, session, message: text }));
+
+  memory.appendHistory(sessionId, "user", text);
+  memory.appendHistory(sessionId, "assistant", answer);
+  palace.palaceLogChat(sessionId, "assistant", answer);
+
+  if ((task.type === "website_builder" || task.type === "file_generation" || task.type === "browser_capture" || task.type === "installation") && !task.followup) {
+    memory.setActiveTask(sessionId, {
+      type: task.type,
+      role: task.role,
+      output: task.output,
+      lastUserIntent: text,
+      identityId: identity.id
+    });
+  } else if (!task.followup && task.type === "chat") {
+    memory.clearActiveTask(sessionId);
+  }
+
+  await sendLongMessage(bot, msg.chat.id, answer);
+}
+
+function startBot(token = BOT_TOKEN) {
+  if (!token) {
+    console.log("Telegram bot disabled (BLUN_TELEGRAM_TOKEN missing).");
+    return null;
+  }
+
+  const bot = new TelegramBot(token, { polling: true });
+  bot.on("message", async (msg) => {
+    try {
+      await handleMessage(bot, msg);
+    } catch (error) {
+      console.error("[telegram]", error);
+      await bot.sendMessage(msg.chat.id, `Fehler bei der Verarbeitung: ${error.message}`);
+    }
+  });
+  return bot;
+}
+
+if (require.main === module) {
+  startBot();
+}
+
+module.exports = {
+  stripThinking,
+  resolveSessionId,
+  parsePalaceCommand,
+  handlePalaceCommand,
+  handleMessage,
+  startBot
+};

package/browser-controller.js

@@ -0,0 +1,76 @@
+const { chromium } = require("playwright");
+
+let browserInstance = null;
+let pageInstance = null;
+
+async function ensurePage() {
+  if (!browserInstance) {
+    browserInstance = await chromium.launch({ headless: true });
+  }
+  if (!pageInstance) {
+    pageInstance = await browserInstance.newPage({ viewport: { width: 1440, height: 960 } });
+  }
+  return pageInstance;
+}
+
+async function open(url) {
+  const page = await ensurePage();
+  await page.goto(String(url), { waitUntil: "domcontentloaded", timeout: 30000 });
+  return snapshot();
+}
+
+async function click(selector) {
+  const page = await ensurePage();
+  await page.locator(String(selector)).first().click();
+  return snapshot();
+}
+
+async function type(selector, text) {
+  const page = await ensurePage();
+  await page.locator(String(selector)).first().fill(String(text));
+  return snapshot();
+}
+
+async function press(key) {
+  const page = await ensurePage();
+  await page.keyboard.press(String(key));
+  return snapshot();
+}
+
+async function snapshot() {
+  const page = await ensurePage();
+  const text = await page.locator("body").innerText().catch(() => "");
+  return {
+    url: page.url(),
+    title: await page.title(),
+    text: String(text || "").trim().slice(0, 4000)
+  };
+}
+
+async function screenshot(targetPath) {
+  const page = await ensurePage();
+  await page.screenshot({ path: String(targetPath), fullPage: true });
+  return { path: String(targetPath) };
+}
+
+async function close() {
+  if (pageInstance) {
+    await pageInstance.close().catch(() => {});
+    pageInstance = null;
+  }
+  if (browserInstance) {
+    await browserInstance.close().catch(() => {});
+    browserInstance = null;
+  }
+  return { closed: true };
+}
+
+module.exports = {
+  open,
+  click,
+  type,
+  press,
+  snapshot,
+  screenshot,
+  close
+};

package/chat-memory.js

@@ -0,0 +1,103 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const BASE_DIR = process.env.BLUN_HOME || path.join(os.homedir(), ".blun");
+const MEMORY_DIR = path.join(BASE_DIR, "memory");
+if (!fs.existsSync(MEMORY_DIR)) fs.mkdirSync(MEMORY_DIR, { recursive: true });
+
+function fileFor(id) {
+  return path.join(MEMORY_DIR, `${String(id).replace(/[^a-zA-Z0-9._-]/g, "_")}.json`);
+}
+
+function defaultSession(id) {
+  return {
+    id,
+    history: [],
+    activeTask: null,
+    summary: "",
+    createdAt: Date.now(),
+    updatedAt: Date.now()
+  };
+}
+
+function loadSession(id) {
+  const file = fileFor(id);
+  if (!fs.existsSync(file)) return defaultSession(id);
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return defaultSession(id);
+  }
+}
+
+function saveSession(id, data) {
+  data.updatedAt = Date.now();
+  fs.writeFileSync(fileFor(id), JSON.stringify(data, null, 2), "utf8");
+}
+
+function appendHistory(id, role, content) {
+  const s = loadSession(id);
+  s.history.push({ role, content, ts: Date.now() });
+  s.history = s.history.slice(-30);
+  saveSession(id, s);
+  return s;
+}
+
+function setActiveTask(id, task) {
+  const s = loadSession(id);
+  s.activeTask = task || null;
+  saveSession(id, s);
+  return s.activeTask;
+}
+
+function clearActiveTask(id) {
+  return setActiveTask(id, null);
+}
+
+function getContextMessages(id) {
+  const session = loadSession(id);
+  return (session.history || []).map((item) => ({
+    role: item.role,
+    content: item.content
+  }));
+}
+
+function addMessage(id, role, content) {
+  return appendHistory(id, role, content);
+}
+
+async function autoCompact(id) {
+  const session = loadSession(id);
+  if ((session.history || []).length <= 24) return;
+  session.history = session.history.slice(-20);
+  saveSession(id, session);
+}
+
+function saveHistory(id, data = {}) {
+  const session = loadSession(id);
+  session.summary = String(data.summary || "");
+  session.history = Array.isArray(data.messages)
+    ? data.messages
+        .filter((item) => item && item.role && typeof item.content === "string")
+        .map((item) => ({
+          role: item.role,
+          content: item.content,
+          ts: Date.now()
+        }))
+        .slice(-30)
+    : [];
+  saveSession(id, session);
+}
+
+module.exports = {
+  loadSession,
+  saveSession,
+  appendHistory,
+  setActiveTask,
+  clearActiveTask,
+  getContextMessages,
+  addMessage,
+  autoCompact,
+  saveHistory
+};

package/file-helper.js

@@ -0,0 +1,63 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const crypto = require("crypto");
+
+const BLUN_HOME = process.env.BLUN_HOME || path.join(os.homedir(), ".blun");
+const ARTIFACT_DIR = path.join(BLUN_HOME, "artifacts");
+if (!fs.existsSync(ARTIFACT_DIR)) fs.mkdirSync(ARTIFACT_DIR, { recursive: true });
+
+function ensureInside(workdir, target) {
+  const root = path.resolve(workdir);
+  const dest = path.resolve(root, target);
+  const relative = path.relative(root, dest);
+
+  if (relative.startsWith("..") || path.isAbsolute(relative)) {
+    throw new Error("Path escapes workdir");
+  }
+
+  return dest;
+}
+
+function writeArtifact(filename, content, encoding = "utf8") {
+  const id = crypto.randomBytes(12).toString("hex");
+  const safeName = filename.replace(/[^\w.\-]/g, "_");
+  const filePath = path.join(ARTIFACT_DIR, `${id}__${safeName}`);
+  fs.writeFileSync(filePath, content, encoding);
+  return {
+    artifact_id: id,
+    filename: safeName,
+    path: filePath,
+    size: fs.statSync(filePath).size
+  };
+}
+
+function listArtifacts() {
+  return fs.readdirSync(ARTIFACT_DIR).map((entry) => {
+    const full = path.join(ARTIFACT_DIR, entry);
+    const stat = fs.statSync(full);
+    const [id, ...rest] = entry.split("__");
+    return {
+      artifact_id: id,
+      filename: rest.join("__"),
+      size: stat.size,
+      created: stat.mtimeMs,
+      download: `/download/${id}`
+    };
+  }).sort((a, b) => b.created - a.created);
+}
+
+function findArtifact(id) {
+  const match = fs.readdirSync(ARTIFACT_DIR).find((entry) => entry.startsWith(`${id}__`));
+  if (!match) return null;
+  const full = path.join(ARTIFACT_DIR, match);
+  return { full, filename: match.split("__").slice(1).join("__") };
+}
+
+module.exports = {
+  ARTIFACT_DIR,
+  ensureInside,
+  writeArtifact,
+  listArtifacts,
+  findArtifact
+};

package/fuzzy-match.js

@@ -0,0 +1,78 @@
+function normalizeLoose(text) {
+  return String(text || "")
+    .normalize("NFD")
+    .replace(/[\u0300-\u036f]/g, "")
+    .toLowerCase()
+    .replace(/ß/g, "ss")
+    .replace(/[^a-z0-9\s-]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function tokenize(text) {
+  return normalizeLoose(text)
+    .split(/[^a-z0-9]+/i)
+    .map((part) => part.trim())
+    .filter(Boolean);
+}
+
+function editDistance(a, b) {
+  const left = String(a || "");
+  const right = String(b || "");
+  const rows = Array.from({ length: left.length + 1 }, () => new Array(right.length + 1).fill(0));
+
+  for (let i = 0; i <= left.length; i++) rows[i][0] = i;
+  for (let j = 0; j <= right.length; j++) rows[0][j] = j;
+
+  for (let i = 1; i <= left.length; i++) {
+    for (let j = 1; j <= right.length; j++) {
+      const cost = left[i - 1] === right[j - 1] ? 0 : 1;
+      rows[i][j] = Math.min(
+        rows[i - 1][j] + 1,
+        rows[i][j - 1] + 1,
+        rows[i - 1][j - 1] + cost
+      );
+    }
+  }
+
+  return rows[left.length][right.length];
+}
+
+function approxWordMatch(token, target) {
+  const left = normalizeLoose(token);
+  const right = normalizeLoose(target);
+  if (!left || !right) return false;
+  if (left === right) return true;
+
+  const maxDistance = right.length >= 8 ? 2 : 1;
+  if (Math.abs(left.length - right.length) > maxDistance) return false;
+  return editDistance(left, right) <= maxDistance;
+}
+
+function hasApproxWord(text, candidates) {
+  const tokens = tokenize(text);
+  return candidates.some((candidate) => tokens.some((token) => approxWordMatch(token, candidate)));
+}
+
+function hasApproxPhrase(text, phrase) {
+  const tokens = tokenize(text);
+  const parts = tokenize(phrase);
+  if (parts.length === 0 || tokens.length < parts.length) return false;
+
+  for (let index = 0; index <= tokens.length - parts.length; index++) {
+    const window = tokens.slice(index, index + parts.length);
+    const matches = window.every((token, partIndex) => approxWordMatch(token, parts[partIndex]));
+    if (matches) return true;
+  }
+
+  return false;
+}
+
+module.exports = {
+  normalizeLoose,
+  tokenize,
+  editDistance,
+  approxWordMatch,
+  hasApproxWord,
+  hasApproxPhrase
+};

package/identities.js

@@ -0,0 +1,106 @@
+const IDENTITIES = {
+  default: {
+    id: "default",
+    name: "Core",
+    aliases: ["default", "core", "standard"],
+    prompt: "Arbeite direkt, klar und ohne Show. Antworte belastbar und bleibe nah an der Aufgabe."
+  },
+  architect: {
+    id: "architect",
+    name: "Architect",
+    aliases: ["architect", "architekt", "systemarchitekt"],
+    prompt: "Denke in Systemen, Verantwortlichkeiten, Schnittstellen und langfristiger Wartbarkeit."
+  },
+  analyst: {
+    id: "analyst",
+    name: "Analyst",
+    aliases: ["analyst", "analyse", "reviewer"],
+    prompt: "Bewerte Starken, Schwachen, Risiken und Muster sauber. Trenne Beobachtung von Vermutung."
+  },
+  debugger: {
+    id: "debugger",
+    name: "Debugger",
+    aliases: ["debugger", "debug", "fehlerjaeger", "fehlerjager"],
+    prompt: "Suche die Ursache statt Symptome. Arbeite reproduzierbar, technisch und testnah."
+  },
+  builder: {
+    id: "builder",
+    name: "Builder",
+    aliases: ["builder", "maker", "umsetzer"],
+    prompt: "Baue konkret, liefere nutzbare Artefakte und halte den Fokus auf funktionierenden Ergebnissen."
+  },
+  operator: {
+    id: "operator",
+    name: "Operator",
+    aliases: ["operator", "ops", "dispatcher"],
+    prompt: "Ordne Arbeit, erkenne Blocker, priorisiere sauber und halte Ablaufe knapp und eindeutig."
+  },
+  installer: {
+    id: "installer",
+    name: "Installer",
+    aliases: ["installer", "setup", "deployer"],
+    prompt: "Fuehre lokale Installationen, Setups und verifizierbare Aktionsschritte direkt aus statt darueber zu reden."
+  },
+  critic: {
+    id: "critic",
+    name: "Critic",
+    aliases: ["critic", "kritiker", "harte review"],
+    prompt: "Zeige Schwachstellen, Regressionen und naive Annahmen ohne Schonung, aber mit technischer Begrundung."
+  }
+};
+
+function getIdentity(id) {
+  if (!id) return IDENTITIES.default;
+  return IDENTITIES[id] || IDENTITIES.default;
+}
+
+function listIdentities() {
+  return Object.values(IDENTITIES).map(({ id, name, aliases, prompt }) => ({
+    id,
+    name,
+    aliases,
+    prompt
+  }));
+}
+
+function findIdentityInText(text) {
+  const normalized = String(text || "").toLowerCase();
+
+  for (const identity of Object.values(IDENTITIES)) {
+    for (const alias of identity.aliases) {
+      const escaped = alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      if (new RegExp(`\\b${escaped}\\b`, "i").test(normalized)) {
+        return identity;
+      }
+    }
+  }
+
+  return null;
+}
+
+function recommendIdentity(task) {
+  switch (task?.type) {
+    case "website_builder":
+      return IDENTITIES.builder;
+    case "debugging":
+      return IDENTITIES.debugger;
+    case "analysis":
+      return task.role === "web_ui" ? IDENTITIES.critic : IDENTITIES.analyst;
+    case "operator":
+      return IDENTITIES.operator;
+    case "coding":
+      return IDENTITIES.architect;
+    case "installation":
+      return IDENTITIES.installer;
+    default:
+      return IDENTITIES.default;
+  }
+}
+
+module.exports = {
+  IDENTITIES,
+  getIdentity,
+  listIdentities,
+  findIdentityInText,
+  recommendIdentity
+};