blun-king-cli 4.1.0 → 5.0.0

package/installer.js

@@ -0,0 +1,160 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { execFile } = require("child_process");
+const { hasApproxWord, hasApproxPhrase } = require("./fuzzy-match");
+
+const BLUN_HOME = process.env.BLUN_HOME || path.join(os.homedir(), ".blun");
+const EXTENSIONS_DIR = path.join(BLUN_HOME, "extensions");
+if (!fs.existsSync(EXTENSIONS_DIR)) fs.mkdirSync(EXTENSIONS_DIR, { recursive: true });
+
+function execFileAsync(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    execFile(command, args, { ...options, maxBuffer: 20 * 1024 * 1024 }, (error, stdout, stderr) => {
+      if (error) reject(new Error(stderr || error.message));
+      else resolve({ stdout, stderr });
+    });
+  });
+}
+
+function classifySource(source) {
+  if (/^https?:\/\/.+\.git$/i.test(source) || /github\.com[:/].+\/.+/i.test(source)) {
+    return "git";
+  }
+  if (/^https?:\/\//i.test(source)) {
+    return "url";
+  }
+  return "npm";
+}
+
+function resolveInstallRequest(text) {
+  const raw = String(text || "").trim();
+  const urlMatch = raw.match(/https?:\/\/[^\s]+/i);
+  if (urlMatch) {
+    return {
+      source: urlMatch[0],
+      kind: classifySource(urlMatch[0]),
+      label: urlMatch[0]
+    };
+  }
+
+  const normalized = raw.toLowerCase();
+  const aliases = [
+    {
+      match: (value) => /\btelegramm?\s+bot\b|\btelegramm?-bot\b/.test(value) || hasApproxPhrase(value, "telegram bot"),
+      source: "node-telegram-bot-api",
+      label: "Telegram Bot API"
+    },
+    {
+      match: (value) => /\bplaywright\b/.test(value) || hasApproxWord(value, ["playwright"]) || hasApproxPhrase(value, "playwright"),
+      source: "playwright",
+      label: "Playwright"
+    },
+    {
+      match: (value) => /\bdiscord bot\b|\bdiscord\.js\b/.test(value) || hasApproxPhrase(value, "discord bot"),
+      source: "discord.js",
+      label: "Discord.js"
+    }
+  ];
+
+  for (const alias of aliases) {
+    if (alias.match(normalized)) {
+      return {
+        source: alias.source,
+        kind: classifySource(alias.source),
+        label: alias.label
+      };
+    }
+  }
+
+  const packageMatch = normalized.match(/\b(?:installier(?:e)?|install|installiere|hol dir|lade|besorg dir)\b[\s:,-]*([@a-z0-9._/-]+)\b/i);
+  const fuzzyInstallVerb = hasApproxWord(normalized, ["installieren", "installier", "install", "insallieren", "instaliier"]);
+  if (packageMatch) {
+    return {
+      source: packageMatch[1],
+      kind: classifySource(packageMatch[1]),
+      label: packageMatch[1]
+    };
+  }
+
+  if (fuzzyInstallVerb) {
+    const pkgCandidate = normalized
+      .split(/\s+/)
+      .find((token) => /^[@a-z0-9._/-]+$/.test(token) && !hasApproxWord(token, ["installieren", "installier", "install", "den", "die", "das", "dir", "bot"]));
+    if (pkgCandidate) {
+      return {
+        source: pkgCandidate,
+        kind: classifySource(pkgCandidate),
+        label: pkgCandidate
+      };
+    }
+  }
+
+  return null;
+}
+
+function npmTargetPath(source) {
+  return path.join(EXTENSIONS_DIR, "node_modules", source);
+}
+
+function isInstalled(source) {
+  const kind = classifySource(source);
+  if (kind === "npm") {
+    return fs.existsSync(npmTargetPath(source));
+  }
+  if (kind === "git") {
+    const repoName = source.split("/").pop().replace(/\.git$/i, "") || "";
+    return repoName ? fs.existsSync(path.join(EXTENSIONS_DIR, repoName)) : false;
+  }
+  if (kind === "url") {
+    const safeName = source.replace(/[^\w.-]+/g, "_").slice(0, 80);
+    return fs.existsSync(path.join(EXTENSIONS_DIR, safeName));
+  }
+  return false;
+}
+
+async function installSource(source) {
+  const kind = classifySource(source);
+  const gitBinary = process.platform === "win32" ? "git.exe" : "git";
+  const npmBinary = process.platform === "win32" ? "npm.cmd" : "npm";
+
+  if (kind === "git") {
+    const repoName = source.split("/").pop().replace(/\.git$/i, "") || `repo-${Date.now()}`;
+    const target = path.join(EXTENSIONS_DIR, repoName);
+    if (!fs.existsSync(target)) {
+      await execFileAsync(gitBinary, ["clone", source, target], { cwd: EXTENSIONS_DIR });
+    }
+    return { kind, source, target };
+  }
+
+  if (kind === "url") {
+    const safeName = source.replace(/[^\w.-]+/g, "_").slice(0, 80);
+    const target = path.join(EXTENSIONS_DIR, safeName);
+    const script = [
+      `$ProgressPreference='SilentlyContinue'`,
+      `Invoke-WebRequest -UseBasicParsing -Uri '${source}' -OutFile '${target}'`
+    ].join("; ");
+    await execFileAsync("powershell.exe", ["-NoProfile", "-Command", script], { cwd: EXTENSIONS_DIR });
+    return { kind, source, target };
+  }
+
+  if (kind === "npm" && isInstalled(source)) {
+    return { kind, source, target: npmTargetPath(source), alreadyInstalled: true };
+  }
+
+  if (process.platform === "win32") {
+    const command = `${npmBinary} install ${source}`;
+    await execFileAsync("cmd.exe", ["/d", "/s", "/c", command], { cwd: EXTENSIONS_DIR });
+  } else {
+    await execFileAsync(npmBinary, ["install", source], { cwd: EXTENSIONS_DIR });
+  }
+  return { kind, source, target: path.join(EXTENSIONS_DIR, "node_modules", source) };
+}
+
+module.exports = {
+  EXTENSIONS_DIR,
+  classifySource,
+  resolveInstallRequest,
+  isInstalled,
+  installSource
+};

package/job-manager.js

@@ -0,0 +1,146 @@
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const crypto = require("crypto");
+
+const BLUN_HOME = process.env.BLUN_HOME || path.join(os.homedir(), ".blun");
+const DATA_DIR = path.join(BLUN_HOME, "data");
+const JOBS_FILE = path.join(DATA_DIR, "jobs.json");
+
+function ensureDataDir() {
+  if (!fs.existsSync(DATA_DIR)) fs.mkdirSync(DATA_DIR, { recursive: true });
+}
+
+function readJobs() {
+  ensureDataDir();
+  if (!fs.existsSync(JOBS_FILE)) return [];
+  try {
+    return JSON.parse(fs.readFileSync(JOBS_FILE, "utf8"));
+  } catch {
+    return [];
+  }
+}
+
+function writeJobs(jobs) {
+  ensureDataDir();
+  fs.writeFileSync(JOBS_FILE, JSON.stringify(jobs, null, 2), "utf8");
+}
+
+function makeId() {
+  return `job_${Date.now()}_${crypto.randomBytes(4).toString("hex")}`;
+}
+
+function createJob({ endpoint, sessionId, payload, mode = "agent", resumedFrom = null }) {
+  const jobs = readJobs();
+  const job = {
+    id: makeId(),
+    endpoint,
+    mode,
+    sessionId: String(sessionId || "default"),
+    payload: payload || {},
+    status: "queued",
+    resumedFrom,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    startedAt: null,
+    finishedAt: null,
+    error: null,
+    result: null,
+    logs: []
+  };
+  jobs.unshift(job);
+  writeJobs(jobs.slice(0, 200));
+  return job;
+}
+
+function summarizeJob(job) {
+  const result = job?.result || {};
+  return {
+    id: job?.id || "",
+    status: job?.status || "unknown",
+    endpoint: job?.endpoint || "",
+    taskType: result.task_type || "",
+    durationMs: job?.startedAt && job?.finishedAt ? Math.max(0, job.finishedAt - job.startedAt) : null,
+    fileCount: Array.isArray(result.files) ? result.files.length : 0,
+    referenceCount: Array.isArray(result.references) ? result.references.length : 0,
+    artifact: result.artifact?.filename || null,
+    error: job?.error || null
+  };
+}
+
+function updateJob(jobId, patch = {}) {
+  const jobs = readJobs();
+  const index = jobs.findIndex((job) => job.id === jobId);
+  if (index === -1) return null;
+  jobs[index] = {
+    ...jobs[index],
+    ...patch,
+    updatedAt: Date.now()
+  };
+  writeJobs(jobs);
+  return jobs[index];
+}
+
+function getJob(jobId) {
+  return readJobs().find((job) => job.id === jobId) || null;
+}
+
+function listJobs({ sessionId, limit = 20 } = {}) {
+  return readJobs()
+    .filter((job) => !sessionId || job.sessionId === sessionId)
+    .slice(0, limit);
+}
+
+function cloneJobForResume(jobId) {
+  const original = getJob(jobId);
+  if (!original) return null;
+  return createJob({
+    endpoint: original.endpoint,
+    sessionId: original.sessionId,
+    payload: {
+      ...original.payload,
+      resume_context: {
+        resumedFrom: original.id,
+        previousStatus: original.status,
+        previousError: original.error || "",
+        previousAnswer: String(original.result?.answer || "").slice(0, 500),
+        previousLogs: getJobLogs(original.id).slice(-10)
+      }
+    },
+    mode: original.mode,
+    resumedFrom: original.id
+  });
+}
+
+function appendJobLog(jobId, event, payload = {}) {
+  const jobs = readJobs();
+  const index = jobs.findIndex((job) => job.id === jobId);
+  if (index === -1) return null;
+
+  jobs[index].logs = Array.isArray(jobs[index].logs) ? jobs[index].logs : [];
+  jobs[index].logs.push({
+    ts: Date.now(),
+    event,
+    payload
+  });
+  jobs[index].logs = jobs[index].logs.slice(-100);
+  jobs[index].updatedAt = Date.now();
+  writeJobs(jobs);
+  return jobs[index].logs;
+}
+
+function getJobLogs(jobId) {
+  return getJob(jobId)?.logs || [];
+}
+
+module.exports = {
+  JOBS_FILE,
+  createJob,
+  summarizeJob,
+  updateJob,
+  getJob,
+  listJobs,
+  cloneJobForResume,
+  appendJobLog,
+  getJobLogs
+};

package/local-data.js

@@ -0,0 +1,71 @@
+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 DATA_DIR = path.join(BLUN_HOME, "data");
+const FACTS_FILE = path.join(DATA_DIR, "facts.json");
+const REFERENCES_DIR = path.join(DATA_DIR, "references");
+
+if (!fs.existsSync(DATA_DIR)) fs.mkdirSync(DATA_DIR, { recursive: true });
+if (!fs.existsSync(REFERENCES_DIR)) fs.mkdirSync(REFERENCES_DIR, { recursive: true });
+
+function readFacts() {
+  if (!fs.existsSync(FACTS_FILE)) return [];
+  try {
+    return JSON.parse(fs.readFileSync(FACTS_FILE, "utf8"));
+  } catch {
+    return [];
+  }
+}
+
+function writeFacts(facts) {
+  fs.writeFileSync(FACTS_FILE, JSON.stringify(facts, null, 2), "utf8");
+}
+
+function storeFact({ scope = "global", key, value, tags = [] }) {
+  const facts = readFacts();
+  const record = {
+    id: crypto.randomBytes(8).toString("hex"),
+    scope,
+    key,
+    value,
+    tags,
+    updatedAt: Date.now()
+  };
+  facts.push(record);
+  writeFacts(facts);
+  return record;
+}
+
+function findFacts(query = "") {
+  const needle = String(query || "").toLowerCase();
+  return readFacts().filter((fact) => {
+    const haystack = JSON.stringify(fact).toLowerCase();
+    return !needle || haystack.includes(needle);
+  });
+}
+
+function storeReference(url, payload) {
+  const id = crypto.randomBytes(8).toString("hex");
+  const safeHost = String(url).replace(/[^a-z0-9]+/gi, "_").slice(0, 80);
+  const filePath = path.join(REFERENCES_DIR, `${Date.now()}_${safeHost}_${id}.json`);
+  const record = {
+    id,
+    url,
+    storedAt: Date.now(),
+    ...payload
+  };
+  fs.writeFileSync(filePath, JSON.stringify(record, null, 2), "utf8");
+  return { ...record, filePath };
+}
+
+module.exports = {
+  DATA_DIR,
+  REFERENCES_DIR,
+  readFacts,
+  storeFact,
+  findFacts,
+  storeReference
+};

package/message-builder.js

@@ -0,0 +1,28 @@
+function sanitizeHistory(history, limit = 12) {
+  if (!Array.isArray(history)) return [];
+
+  return history
+    .filter((item) => item && item.role && typeof item.content === "string")
+    .slice(-limit)
+    .map((item) => ({
+      role: item.role,
+      content: String(item.content)
+    }));
+}
+
+function buildConversationMessages({ prompt, session, history, message }) {
+  const messages = [{ role: "system", content: String(prompt || "") }];
+  const sourceHistory = Array.isArray(history) && history.length ? history : session?.history;
+
+  for (const item of sanitizeHistory(sourceHistory)) {
+    messages.push(item);
+  }
+
+  messages.push({ role: "user", content: String(message || "") });
+  return messages;
+}
+
+module.exports = {
+  sanitizeHistory,
+  buildConversationMessages
+};

package/noisy-evals.js

@@ -0,0 +1,38 @@
+const runtime = require("./runtime");
+
+const CORPUS = [
+  { input: "instaliier dir den telegarm bot", expected: "installation" },
+  { input: "insalieren telegramm bot", expected: "installation" },
+  { input: "kanst du playwrigth instalieren", expected: "installation" },
+  { input: "mach ein screenshoot von der websiete https://example.com", expected: "browser_capture" },
+  { input: "brauch ein screnshot von der website https://example.com", expected: "browser_capture" },
+  { input: "baue mir eine websiete fuer mein studio", expected: "website_builder" },
+  { input: "mach landingpgae fuer nicrazy style", expected: "website_builder" }
+];
+
+function evaluateNoisyIntentCorpus() {
+  const results = CORPUS.map((entry) => {
+    const actual = runtime.classifyTask(entry.input, null).type;
+    return {
+      input: entry.input,
+      expected: entry.expected,
+      actual,
+      passed: actual === entry.expected
+    };
+  });
+
+  const passed = results.filter((entry) => entry.passed).length;
+  const total = results.length;
+  return {
+    total,
+    passed,
+    failed: total - passed,
+    score: total ? Number((passed / total).toFixed(4)) : 0,
+    results
+  };
+}
+
+module.exports = {
+  CORPUS,
+  evaluateNoisyIntentCorpus
+};

package/package.json

@@ -1,10 +1,23 @@
 {
   "name": "blun-king-cli",
-  "version": "4.1.0",
-  "description": "BLUN King CLI — Premium KI Console",
+  "version": "5.0.0",
+  "description": "BLUN King CLI — Your local AI assistant powered by Gemma4",
+  "type": "commonjs",
   "bin": {
-    "blun": "./bin/blun.js"
+    "blun": "./blun-cli.js"
   },
-  "keywords": ["ai", "cli", "blun", "king"],
+  "scripts": {
+    "start": "node api.js",
+    "cli": "node blun-cli.js",
+    "bot": "node bot.js",
+    "test": "node --test tests/*.test.js"
+  },
+  "dependencies": {
+    "express": "^5.1.0",
+    "node-telegram-bot-api": "^0.66.0",
+    "playwright": "^1.53.0"
+  },
+  "keywords": ["ai", "cli", "blun", "gemma", "local-ai"],
+  "author": "BLUN AI",
   "license": "MIT"
 }