blun-king-cli 4.1.1 → 5.0.0

package/user-profile.js

@@ -0,0 +1,395 @@
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { hasApproxPhrase } = require("./fuzzy-match");
+
+const BLUN_HOME = process.env.BLUN_HOME || path.join(os.homedir(), ".blun");
+const DATA_DIR = path.join(BLUN_HOME, "data");
+const PROFILE_FILE = path.join(DATA_DIR, "user-profiles.json");
+
+function ensureDataDir() {
+  if (!fs.existsSync(DATA_DIR)) fs.mkdirSync(DATA_DIR, { recursive: true });
+}
+
+function readProfiles() {
+  ensureDataDir();
+  if (!fs.existsSync(PROFILE_FILE)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(PROFILE_FILE, "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+function writeProfiles(profiles) {
+  ensureDataDir();
+  fs.writeFileSync(PROFILE_FILE, JSON.stringify(profiles, null, 2), "utf8");
+}
+
+function normalizePhrase(text) {
+  return String(text || "")
+    .toLowerCase()
+    .replace(/https?:\/\/[^\s]+/g, " ")
+    .replace(/[^a-z0-9\s-]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim()
+    .slice(0, 120);
+}
+
+function compactText(text, maxLength = 240) {
+  return String(text || "")
+    .replace(/\s+/g, " ")
+    .trim()
+    .slice(0, maxLength);
+}
+
+function ensureProfileShape(profile = {}) {
+  return {
+    installAliases: Array.isArray(profile.installAliases) ? profile.installAliases : [],
+    termAliases: Array.isArray(profile.termAliases) ? profile.termAliases : [],
+    knowledgeSnippets: Array.isArray(profile.knowledgeSnippets) ? profile.knowledgeSnippets : [],
+    typedKnowledge: {
+      preferences: Array.isArray(profile.typedKnowledge?.preferences) ? profile.typedKnowledge.preferences : [],
+      facts: Array.isArray(profile.typedKnowledge?.facts) ? profile.typedKnowledge.facts : [],
+      workflows: Array.isArray(profile.typedKnowledge?.workflows) ? profile.typedKnowledge.workflows : [],
+      guardrails: Array.isArray(profile.typedKnowledge?.guardrails) ? profile.typedKnowledge.guardrails : []
+    }
+  };
+}
+
+function looksLikePackageName(value) {
+  return /^(@[a-z0-9._-]+\/)?[a-z0-9._-]+$/i.test(String(value || "").trim());
+}
+
+function loadUserProfile(userId) {
+  const profiles = readProfiles();
+  return ensureProfileShape(profiles[String(userId)]);
+}
+
+function saveUserProfile(userId, profile) {
+  const profiles = readProfiles();
+  profiles[String(userId)] = ensureProfileShape(profile);
+  writeProfiles(profiles);
+}
+
+function learnInstallAlias(userId, phrase, source) {
+  if (!userId || !phrase || !source) return;
+  const profile = ensureProfileShape(loadUserProfile(userId));
+  const normalized = normalizePhrase(phrase);
+  if (!normalized) return;
+
+  const existing = profile.installAliases.find((entry) => entry.phrase === normalized && entry.source === source);
+  if (existing) {
+    existing.count = (existing.count || 1) + 1;
+    existing.updatedAt = Date.now();
+  } else {
+    profile.installAliases.push({
+      phrase: normalized,
+      source,
+      count: 1,
+      updatedAt: Date.now()
+    });
+  }
+
+  profile.installAliases = profile.installAliases
+    .sort((a, b) => (b.count || 0) - (a.count || 0) || (b.updatedAt || 0) - (a.updatedAt || 0))
+    .slice(0, 30);
+
+  saveUserProfile(userId, profile);
+}
+
+function learnTermAlias(userId, phrase, target) {
+  if (!userId || !phrase || !target) return;
+  const profile = ensureProfileShape(loadUserProfile(userId));
+  const normalized = normalizePhrase(phrase);
+  const normalizedTarget = compactText(target, 160);
+  if (!normalized || !normalizedTarget) return;
+
+  const existing = profile.termAliases.find((entry) => entry.phrase === normalized && entry.target === normalizedTarget);
+  if (existing) {
+    existing.count = (existing.count || 1) + 1;
+    existing.updatedAt = Date.now();
+  } else {
+    profile.termAliases.push({
+      phrase: normalized,
+      target: normalizedTarget,
+      count: 1,
+      updatedAt: Date.now()
+    });
+  }
+
+  profile.termAliases = profile.termAliases
+    .sort((a, b) => (b.count || 0) - (a.count || 0) || (b.updatedAt || 0) - (a.updatedAt || 0))
+    .slice(0, 40);
+
+  if (looksLikePackageName(normalizedTarget)) {
+    learnInstallAlias(userId, normalized, normalizedTarget);
+    return;
+  }
+
+  saveUserProfile(userId, profile);
+}
+
+function learnKnowledgeSnippet(userId, text, meta = {}) {
+  if (!userId || !text) return false;
+  const profile = ensureProfileShape(loadUserProfile(userId));
+  const stored = storeKnowledgeSnippet(profile, text, meta);
+  saveUserProfile(userId, profile);
+  return stored;
+}
+
+function storeKnowledgeSnippet(profile, text, meta = {}) {
+  const snippet = compactText(text, 280);
+  if (!snippet) return false;
+  const existing = profile.knowledgeSnippets.find((entry) => entry.text === snippet);
+  if (existing) {
+    existing.count = (existing.count || 1) + 1;
+    existing.updatedAt = Date.now();
+    if (meta.category) existing.category = meta.category;
+    if (meta.title) existing.title = compactText(meta.title, 80);
+  } else {
+    profile.knowledgeSnippets.push({
+      text: snippet,
+      category: meta.category ? compactText(meta.category, 40) : "general",
+      title: meta.title ? compactText(meta.title, 80) : "",
+      count: 1,
+      updatedAt: Date.now()
+    });
+  }
+
+  profile.knowledgeSnippets = profile.knowledgeSnippets
+    .sort((a, b) => (b.count || 0) - (a.count || 0) || (b.updatedAt || 0) - (a.updatedAt || 0))
+    .slice(0, 60);
+  return true;
+}
+
+function storeTypedEntry(profile, type, text, meta = {}) {
+  const snippet = compactText(text, 240);
+  if (!snippet) return false;
+
+  const bucket = profile.typedKnowledge[type];
+  const existing = bucket.find((entry) => entry.text === snippet);
+  if (existing) {
+    existing.count = (existing.count || 1) + 1;
+    existing.updatedAt = Date.now();
+    if (meta.category) existing.category = compactText(meta.category, 40);
+    if (meta.title) existing.title = compactText(meta.title, 80);
+  } else {
+    bucket.push({
+      text: snippet,
+      category: meta.category ? compactText(meta.category, 40) : "general",
+      title: meta.title ? compactText(meta.title, 80) : "",
+      count: 1,
+      updatedAt: Date.now()
+    });
+  }
+
+  profile.typedKnowledge[type] = bucket
+    .sort((a, b) => (b.count || 0) - (a.count || 0) || (b.updatedAt || 0) - (a.updatedAt || 0))
+    .slice(0, 30);
+
+  return true;
+}
+
+function detectKnowledgeType(text) {
+  const normalized = normalizePhrase(text);
+  if (!normalized) return "facts";
+  if (/\b(modell|domain|projekt|server|api|stack|version)\b/.test(normalized) && /\b(ist|sind|nutze|verwende|als)\b/.test(normalized)) return "facts";
+  if (/\b(niemals|nie|darfst nicht|verboten|kein html|keine landingpages?)\b/.test(normalized)) return "guardrails";
+  if (/^wenn ich\b/.test(normalized) || /\b(dann|erst .* dann|deploy|workflow|ablauf)\b/.test(normalized)) return "workflows";
+  if (/\b(immer|standard|bevorzuge|nutze|ich will|bitte immer|am liebsten)\b/.test(normalized)) return "preferences";
+  return "facts";
+}
+
+function resolveInstallAlias(userId, phrase) {
+  if (!userId || !phrase) return null;
+  const profile = ensureProfileShape(loadUserProfile(userId));
+  const normalized = normalizePhrase(phrase);
+  if (!normalized) return null;
+
+  for (const entry of profile.installAliases || []) {
+    if (normalized.includes(entry.phrase) || hasApproxPhrase(normalized, entry.phrase)) {
+      return entry.source;
+    }
+  }
+
+  return null;
+}
+
+function resolveTermAlias(userId, phrase) {
+  if (!userId || !phrase) return null;
+  const profile = ensureProfileShape(loadUserProfile(userId));
+  const normalized = normalizePhrase(phrase);
+  if (!normalized) return null;
+
+  for (const entry of profile.termAliases || []) {
+    if (normalized.includes(entry.phrase) || hasApproxPhrase(normalized, entry.phrase)) {
+      return entry.target;
+    }
+  }
+
+  return null;
+}
+
+function scoreSnippet(snippet, query) {
+  const haystack = normalizePhrase(`${snippet.title || ""} ${snippet.category || ""} ${snippet.text || ""}`);
+  const needle = normalizePhrase(query);
+  if (!needle) return 0;
+  const tokens = needle.split(/\s+/).filter(Boolean);
+  const tokenScore = tokens.reduce((score, token) => score + (haystack.includes(token) ? 1 : 0), 0);
+  const exactBonus = haystack.includes(needle) ? 2 : 0;
+  return tokenScore + exactBonus + Math.min(2, (snippet.count || 0) * 0.25);
+}
+
+function recallTypedKnowledge(userId, query, limit = 4) {
+  if (!userId) return [];
+  const profile = ensureProfileShape(loadUserProfile(userId));
+  const all = [];
+
+  for (const [type, entries] of Object.entries(profile.typedKnowledge || {})) {
+    for (const entry of entries || []) {
+      all.push({
+        type,
+        ...entry,
+        score: scoreSnippet(entry, query)
+      });
+    }
+  }
+
+  return all
+    .filter((entry) => entry.score > 0)
+    .sort((a, b) => b.score - a.score || (b.updatedAt || 0) - (a.updatedAt || 0))
+    .slice(0, limit);
+}
+
+function recallKnowledge(userId, query, limit = 4) {
+  if (!userId) return [];
+  const profile = ensureProfileShape(loadUserProfile(userId));
+
+  return (profile.knowledgeSnippets || [])
+    .map((entry) => ({
+      ...entry,
+      score: scoreSnippet(entry, query)
+    }))
+    .filter((entry) => entry.score > 0)
+    .sort((a, b) => b.score - a.score || (b.updatedAt || 0) - (a.updatedAt || 0))
+    .slice(0, limit);
+}
+
+function buildPromptContext(userId, query, limit = 4) {
+  if (!userId) return "";
+  const termAlias = resolveTermAlias(userId, query);
+  const snippets = recallKnowledge(userId, query, limit);
+  const typedEntries = recallTypedKnowledge(userId, query, limit);
+  const lines = [];
+
+  if (termAlias) {
+    lines.push(`- Nutzerbegriff erkannt: "${compactText(query, 60)}" meint hier wahrscheinlich "${termAlias}".`);
+  }
+
+  const typeLabels = {
+    preferences: "Praeferenz",
+    facts: "Fakt",
+    workflows: "Workflow",
+    guardrails: "Guardrail"
+  };
+
+  for (const entry of typedEntries) {
+    lines.push(`- ${typeLabels[entry.type] || entry.type}: ${entry.text}`);
+  }
+
+  for (const snippet of snippets) {
+    const prefix = snippet.title ? `${snippet.title}: ` : "";
+    if (!typedEntries.some((entry) => entry.text === snippet.text)) {
+      lines.push(`- ${prefix}${snippet.text}`);
+    }
+  }
+
+  return lines.length ? lines.join("\n") : "";
+}
+
+function extractAliasPairs(text) {
+  const pairs = [];
+  const lines = String(text || "")
+    .split(/\r?\n/)
+    .map((line) => compactText(line, 220))
+    .filter(Boolean);
+
+  for (const line of lines) {
+    let match = line.match(/^(.+?)\s*(?:=|->|=>|bedeutet|meint)\s*(.+)$/i);
+    if (match) {
+      pairs.push({ phrase: match[1], target: match[2] });
+      continue;
+    }
+
+    match = line.match(/^wenn ich\s+(.+?)\s+sage,\s*(?:meine ich|dann meine ich)\s+(.+)$/i);
+    if (match) {
+      pairs.push({ phrase: match[1], target: match[2] });
+    }
+  }
+
+  return pairs
+    .map((pair) => ({
+      phrase: normalizePhrase(pair.phrase),
+      target: compactText(pair.target, 160)
+    }))
+    .filter((pair) => pair.phrase && pair.target);
+}
+
+function extractKnowledgeSnippets(text) {
+  const blocks = String(text || "")
+    .split(/\n\s*\n/)
+    .map((block) => compactText(block, 280))
+    .filter((block) => block.length >= 20);
+
+  return [...new Set(blocks)].slice(0, 6);
+}
+
+function learnFromText(userId, text, options = {}) {
+  const aliases = extractAliasPairs(text);
+  for (const alias of aliases) {
+    learnTermAlias(userId, alias.phrase, alias.target);
+  }
+
+  const snippets = extractKnowledgeSnippets(text);
+  const profile = ensureProfileShape(loadUserProfile(userId));
+  const typeCounts = {
+    preferences: 0,
+    facts: 0,
+    workflows: 0,
+    guardrails: 0
+  };
+
+  for (const snippet of snippets) {
+    storeKnowledgeSnippet(profile, snippet, options);
+    const type = detectKnowledgeType(snippet);
+    if (storeTypedEntry(profile, type, snippet, options)) {
+      typeCounts[type] += 1;
+    }
+  }
+
+  saveUserProfile(userId, profile);
+
+  return {
+    aliasesLearned: aliases.length,
+    snippetsLearned: snippets.length,
+    types: typeCounts,
+    aliases,
+    snippets
+  };
+}
+
+module.exports = {
+  PROFILE_FILE,
+  loadUserProfile,
+  saveUserProfile,
+  learnInstallAlias,
+  learnTermAlias,
+  learnKnowledgeSnippet,
+  learnFromText,
+  resolveInstallAlias,
+  resolveTermAlias,
+  recallKnowledge,
+  recallTypedKnowledge,
+  buildPromptContext
+};