beast-agent 0.15.0

package/src/agent/kb.js

@@ -0,0 +1,123 @@
+'use strict';
+
+/* Beast knowledge store (#3 derin öğrenme katmanı)
+   sqlite-vec yerine sıfır bağımlılık: JSON deposu + TF-IDF benzerlik.
+   Kayıtlar kaynak taşır → kb_search sonucu citation'lı döner.
+
+   Depo: %APPDATA%\beast\knowledge.json
+   { items: [{ id, title, source, tags[], text, createdAt }] }  */
+
+const fs = require('fs');
+const path = require('path');
+const { beastRoot } = require('./memory');
+
+function file() {
+  return path.join(beastRoot(), 'knowledge.json');
+}
+
+let items = null;
+
+function load() {
+  if (items) return;
+  try {
+    const raw = JSON.parse(fs.readFileSync(file(), 'utf8'));
+    items = Array.isArray(raw.items) ? raw.items : [];
+  } catch {
+    items = [];
+  }
+}
+
+function save() {
+  try {
+    fs.mkdirSync(beastRoot(), { recursive: true });
+    const tmp = file() + '.tmp';
+    fs.writeFileSync(tmp, JSON.stringify({ items }, null, 2));
+    fs.renameSync(tmp, file());
+  } catch {}
+}
+
+const KB_CAP = 2000;
+
+function uid() {
+  return Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
+}
+
+/* memory.js ile aynı Türkçe duyarsız tokenleştirme */
+const TR_FOLD = { ç: 'c', ğ: 'g', ı: 'i', ö: 'o', ş: 's', ü: 'u', â: 'a', î: 'i', û: 'u' };
+function fold(s) {
+  return String(s || '').toLowerCase().replace(/[çğıöşüâîû]/g, (ch) => TR_FOLD[ch] || ch);
+}
+function tokenize(q) {
+  return (fold(q).match(/[a-z0-9_+#.]+/g) || []).filter((w) => w.length >= 3);
+}
+
+/** add(title, text, {source, tags}) → { ok, id } */
+function add(title, text, meta = {}) {
+  load();
+  const t = String(text || '').trim();
+  if (!t) return { ok: false, error: 'metin boş' };
+  if (items.length >= KB_CAP) items.splice(0, items.length - KB_CAP + 1); // en eskiyi düşür
+  const it = {
+    id: uid(),
+    title: String(title || '').trim().slice(0, 120) || t.slice(0, 60),
+    source: String(meta.source || '').trim().slice(0, 300) || 'agent',
+    tags: Array.isArray(meta.tags) ? meta.tags.map((x) => String(x).slice(0, 40)).slice(0, 8) : [],
+    text: t.slice(0, 20000),
+    createdAt: new Date().toISOString(),
+  };
+  items.push(it);
+  save();
+  return { ok: true, id: it.id };
+}
+
+function get(id) {
+  load();
+  return items.find((x) => x.id === id) ? { ...items.find((x) => x.id === id) } : null;
+}
+
+function count() {
+  load();
+  return items.length;
+}
+
+/** TF-IDF benzerlik araması; sonuçlar citation alanıyla döner */
+function search(query, limit = 5) {
+  load();
+  const qTokens = tokenize(query);
+  if (!qTokens.length || !items.length) return [];
+  const N = items.length;
+  const docs = items.map((it) => tokenize(it.title + ' ' + it.text));
+  /* df */
+  const df = new Map();
+  for (const toks of docs) {
+    for (const t of new Set(toks)) df.set(t, (df.get(t) || 0) + 1);
+  }
+  const scored = [];
+  for (let i = 0; i < N; i++) {
+    const toks = docs[i];
+    if (!toks.length) continue;
+    const tf = new Map();
+    for (const t of toks) tf.set(t, (tf.get(t) || 0) + 1);
+    let score = 0;
+    for (const q of qTokens) {
+      const f = tf.get(q) || 0;
+      if (!f) continue;
+      const idf = Math.log(1 + N / (1 + (df.get(q) || 0)));
+      score += (f / toks.length) * idf;
+    }
+    /* tag/başlık eşleşmesine bonus */
+    const hayT = fold(items[i].title + ' ' + (items[i].tags || []).join(' '));
+    for (const q of qTokens) if (hayT.includes(q)) score += 0.35;
+    if (score > 0) scored.push({ i, score });
+  }
+  scored.sort((a, b) => b.score - a.score);
+  return scored.slice(0, Math.max(1, Math.min(limit, 10))).map(({ i, score }) => ({
+    id: items[i].id,
+    title: items[i].title,
+    snippet: items[i].text.slice(0, 400),
+    score: Number(score.toFixed(3)),
+    citation: `[${items[i].title}] (${items[i].source}, ${String(items[i].createdAt).slice(0, 10)})`,
+  }));
+}
+
+module.exports = { add, get, search, count, tokenize };

package/src/agent/llm.js

@@ -0,0 +1,219 @@
+'use strict';
+
+/* OpenAI-compatible streaming chat client with SSE parsing.
+   Geçici sağlayıcı hatalarında (5xx/429/ağ) üstel beklemeyle otomatik retry. */
+
+const RETRYABLE_STATUS = new Set([408, 409, 425, 429, 500, 502, 503, 504]);
+const MAX_RETRIES = 3;
+
+const HINTS = {
+  401: 'API anahtarı geçersiz',
+  402: 'kredi/bakiye bitti',
+  403: 'erişim reddedildi (anahtar yetkisi)',
+  404: 'model adı ya da endpoint yanlış',
+  429: 'hız limitine takıldın',
+  500: 'sağlayıcı iç hatası',
+  502: 'sağlayıcı upstream bağlantısı koptu',
+  503: 'sağlayıcı şu an kullanılamıyor (aşırı yük veya kapalı)',
+  504: 'sağlayıcı zaman aşımı',
+};
+
+function friendlyError(status, statusText, detail) {
+  const hint = HINTS[status];
+  let msg = `HTTP ${status} ${statusText}`;
+  if (hint) msg += ` — ${hint}`;
+  if (detail) msg += `\n${detail}`;
+  if ([500, 502, 503, 504].includes(status)) {
+    msg += '\n(geçici olabilir: birkaç saniye sonra tekrar dene ya da model seçiciyi açıp başka bir model dene)';
+  }
+  return msg;
+}
+
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const t = setTimeout(resolve, ms);
+    if (signal) {
+      signal.addEventListener(
+        'abort',
+        () => {
+          clearTimeout(t);
+          const e = new Error('iptal');
+          e.name = 'AbortError';
+          reject(e);
+        },
+        { once: true }
+      );
+    }
+  });
+}
+
+/* fn: denenecek istek. Ağ hataları ve RETRYABLE_STATUS durumlarında
+   0.8s → 1.6s → 3.2s bekleyip tekrar dener. */
+async function withRetries(fn, { signal, onRetry } = {}) {
+  let attempt = 0;
+  for (;;) {
+    try {
+      return await fn();
+    } catch (e) {
+      const aborted = e && (e.name === 'AbortError' || (signal && signal.aborted));
+      const status = e && e.status;
+      const retriable =
+        !aborted && (status === undefined || RETRYABLE_STATUS.has(status));
+      if (!retriable || attempt >= MAX_RETRIES) throw e;
+      attempt++;
+      try {
+        onRetry && onRetry(attempt, status);
+      } catch {}
+      await sleep(800 * Math.pow(2, attempt - 1), signal);
+    }
+  }
+}
+
+async function openChat(sel, body, { stream, signal, omitReasoning } = {}) {
+  const payload = {
+    model: sel.model,
+    messages: body.messages,
+    stream,
+    ...(body.tools && body.tools.length ? { tools: body.tools } : {}),
+    temperature: body.temperature ?? 0.6,
+  };
+  /* Düşünme (reasoning) seviyesi: OpenAI-style reasoning_effort —
+     OpenRouter ve GPT-5 ailesi dahil uyumlu sağlayıcılar kabul eder. */
+  if (body.reasoningEffort && !omitReasoning) {
+    payload.reasoning_effort = String(body.reasoningEffort);
+  }
+  return fetch(sel.url, {
+    method: 'POST',
+    signal,
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${sel.key}`,
+      'HTTP-Referer': 'https://localhost/beast',
+      'X-Title': 'Beast Agent',
+    },
+    body: JSON.stringify(payload),
+  });
+}
+
+async function chatStream(sel, body, { signal, onDelta, onRetry } = {}) {
+  try {
+    return await streamOnce(sel, body, { signal, onDelta });
+  } catch (e) {
+    /* Model reasoning_effort'u desteklemiyorsa (400) parametreyi atlayıp
+       TEK seferlik sessiz retry — kullanıcı hatayı görmez. */
+    if (
+      body.reasoningEffort &&
+      e && e.status === 400 &&
+      /reason|effort|thinking/i.test(String(e.message || ''))
+    ) {
+      return await streamOnce(sel, body, { signal, onDelta }, true);
+    }
+    throw e;
+  }
+}
+
+async function streamOnce(sel, body, { signal, onDelta, onRetry } = {}, omitReasoning = false) {
+  const res = await withRetries(
+    async () => {
+      const r = await openChat(sel, body, { stream: true, signal, omitReasoning });
+      if (!r.ok) {
+        let detail = '';
+        try {
+          detail = (await r.text()).slice(0, 300);
+        } catch {}
+        const err = new Error(friendlyError(r.status, r.statusText, detail));
+        err.status = r.status;
+        throw err;
+      }
+      return r;
+    },
+    { signal, onRetry }
+  );
+
+  let content = '';
+  let reasoning = '';
+  const toolCalls = [];
+  let usage = null;
+  let finishReason = null;
+
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buf = '';
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buf += decoder.decode(value, { stream: true });
+
+    let idx;
+    while ((idx = buf.indexOf('\n')) !== -1) {
+      const line = buf.slice(0, idx).trim();
+      buf = buf.slice(idx + 1);
+      if (!line.startsWith('data:')) continue;
+      const data = line.slice(5).trim();
+      if (!data || data === '[DONE]') continue;
+
+      let json;
+      try {
+        json = JSON.parse(data);
+      } catch {
+        continue;
+      }
+
+      if (json.usage) usage = json.usage;
+      const ch = json.choices && json.choices[0];
+      if (!ch) continue;
+      if (ch.finish_reason) finishReason = ch.finish_reason;
+      const d = ch.delta || {};
+      if (d.content) {
+        content += d.content;
+        onDelta && onDelta(d.content, content);
+      }
+      if (d.reasoning_content) reasoning += d.reasoning_content;
+      if (d.reasoning) reasoning += d.reasoning;
+      for (const tc of d.tool_calls || []) {
+        const i = typeof tc.index === 'number' ? tc.index : toolCalls.length;
+        while (toolCalls.length <= i) {
+          toolCalls.push({ id: '', type: 'function', function: { name: '', arguments: '' } });
+        }
+        if (tc.id) toolCalls[i].id = tc.id;
+        if (tc.function) {
+          if (tc.function.name) toolCalls[i].function.name += tc.function.name;
+          if (tc.function.arguments) toolCalls[i].function.arguments += tc.function.arguments;
+        }
+      }
+    }
+  }
+
+  return { content, reasoning, toolCalls, usage, finishReason };
+}
+
+async function chatOnce(sel, body, { signal, onRetry } = {}) {
+  const res = await withRetries(
+    async () => {
+      const r = await openChat(sel, body, { stream: false, signal });
+      if (!r.ok) {
+        let detail = '';
+        try {
+          detail = (await r.text()).slice(0, 300);
+        } catch {}
+        const err = new Error(friendlyError(r.status, r.statusText, detail));
+        err.status = r.status;
+        throw err;
+      }
+      return r;
+    },
+    { signal, onRetry }
+  );
+  const json = await res.json();
+  const msg = json.choices?.[0]?.message || {};
+  return {
+    content: msg.content || '',
+    reasoning: msg.reasoning_content || msg.reasoning || '',
+    toolCalls: msg.tool_calls || [],
+    usage: json.usage || null,
+    finishReason: json.choices?.[0]?.finish_reason,
+  };
+}
+
+module.exports = { chatStream, chatOnce, withRetries, friendlyError };

package/src/agent/logger.js

@@ -0,0 +1,90 @@
+'use strict';
+
+/* Merkezî log sistemi:
+   - Günlük dosyalar: %APPDATA%\beast\logs\beast-YYYY-MM-DD.log
+   - Bellekte ring buffer (UI'da hızlı gösterim için)
+   - 14 günden eski günlük dosyaları saatlik temizlikle silinir
+   Kullanım: const log = require('./logger'); log.info('wa', 'bağlandı'); */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const ROOT = process.env.APPDATA
+  ? path.join(process.env.APPDATA, 'beast')
+  : path.join(os.homedir(), 'AppData', 'Roaming', 'beast');
+const LOG_DIR = path.join(ROOT, 'logs');
+const KEEP_DAYS = 14;
+const RING_MAX = 1000;
+
+const ring = [];
+let lastCleanup = 0;
+
+function fileFor(d) {
+  const t = d || new Date();
+  const p = (n) => String(n).padStart(2, '0');
+  return path.join(LOG_DIR, `beast-${t.getFullYear()}-${p(t.getMonth() + 1)}-${p(t.getDate())}.log`);
+}
+
+function cleanup() {
+  const now = Date.now();
+  if (now - lastCleanup < 60 * 60 * 1000) return;
+  lastCleanup = now;
+  try {
+    for (const f of fs.readdirSync(LOG_DIR)) {
+      const m = /^beast-(\d{4})-(\d{2})-(\d{2})\.log$/.exec(f);
+      if (!m) continue;
+      const age = (now - Date.UTC(Number(m[1]), Number(m[2]) - 1, Number(m[3]))) / 86400000;
+      if (age > KEEP_DAYS) { try { fs.unlinkSync(path.join(LOG_DIR, f)); } catch {} }
+    }
+  } catch {}
+}
+
+function write(level, tag, msg) {
+  const line =
+    `[${new Date().toISOString()}] [${String(level).toUpperCase()}] [${tag}] ` +
+    String(msg == null ? '' : msg).replace(/\r?\n/g, ' | ').slice(0, 4000);
+  ring.push(line);
+  if (ring.length > RING_MAX) ring.splice(0, ring.length - RING_MAX);
+  try {
+    fs.mkdirSync(LOG_DIR, { recursive: true });
+    cleanup();
+    fs.appendFileSync(fileFor(), line + '\n');
+  } catch {}
+  return line;
+}
+
+const info = (tag, msg) => write('info', tag, msg);
+const warn = (tag, msg) => write('warn', tag, msg);
+const error = (tag, msg) => write('error', tag, msg);
+
+/* Bugün + dünün son n satırı (UI ve hata raporları için) */
+function tail(n = 300) {
+  const lines = [];
+  try { lines.push(...fs.readFileSync(fileFor(new Date(Date.now() - 86400000)), 'utf8').split('\n')); } catch {}
+  try { lines.push(...fs.readFileSync(fileFor(), 'utf8').split('\n')); } catch {}
+  return lines.filter((l) => l.trim()).slice(-Math.max(1, Number(n) || 300));
+}
+
+function dir() {
+  try { fs.mkdirSync(LOG_DIR, { recursive: true }); } catch {}
+  return LOG_DIR;
+}
+
+function recent() {
+  return ring.slice(-200);
+}
+
+function clear() {
+  try { ring.length = 0; } catch {}
+  /* tail() bugün + dünün dosyasını okur; ikisini de boşalt ki
+     UI'daki "Logları Temizle" gerçekten temizlesin */
+  try {
+    for (const d of [new Date(), new Date(Date.now() - 86400000)]) {
+      try { fs.writeFileSync(fileFor(d), ''); } catch {}
+    }
+  } catch {}
+  return true;
+}
+
+module.exports = { info, warn, error, tail, dir, recent, clear, LOG_DIR };