tiger-agent 0.2.0

package/scripts/sqlite_vec_setup.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+import argparse
+import glob
+import json
+import os
+import sqlite3
+import subprocess
+import sys
+from pathlib import Path
+
+
+def run(cmd):
+    return subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+
+
+def discover_extension_path() -> str:
+    try:
+        import sqlite_vec  # type: ignore
+    except Exception:
+        return ""
+
+    # Preferred API if present.
+    loadable_fn = getattr(sqlite_vec, "loadable_path", None)
+    if callable(loadable_fn):
+        try:
+            path = str(loadable_fn() or "").strip()
+            if path and os.path.exists(path):
+                return path
+        except Exception:
+            pass
+
+    module_file = Path(getattr(sqlite_vec, "__file__", "")).resolve()
+    if not module_file.exists():
+        return ""
+    base = module_file.parent
+    patterns = ["*vec*.so", "*vec*.dylib", "*vec*.dll", "*.so", "*.dylib", "*.dll"]
+    for pat in patterns:
+        for candidate in glob.glob(str(base / pat)):
+            if os.path.isfile(candidate):
+                return candidate
+    return ""
+
+
+def test_load(path: str):
+    if not path:
+        return False, "extension path is empty"
+    conn = sqlite3.connect(":memory:")
+    try:
+        conn.enable_load_extension(True)
+        conn.load_extension(path)
+        return True, ""
+    except Exception as err:
+        return False, str(err)
+    finally:
+        try:
+            conn.enable_load_extension(False)
+        except Exception:
+            pass
+        conn.close()
+
+
+def set_env_sqlite_vec(env_path: str, extension_path: str):
+    p = Path(env_path)
+    text = p.read_text(encoding="utf-8") if p.exists() else ""
+    lines = text.splitlines()
+    replaced = False
+    out = []
+    for line in lines:
+        if line.startswith("SQLITE_VEC_EXTENSION="):
+            out.append(f"SQLITE_VEC_EXTENSION={extension_path}")
+            replaced = True
+        else:
+            out.append(line)
+    if not replaced:
+        out.append(f"SQLITE_VEC_EXTENSION={extension_path}")
+    p.write_text("\n".join(out).rstrip() + "\n", encoding="utf-8")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--install", action="store_true", help="Attempt pip install sqlite-vec first")
+    parser.add_argument("--write-env", action="store_true", help="Write SQLITE_VEC_EXTENSION to .env")
+    parser.add_argument("--env-path", default=".env")
+    parser.add_argument("--extension-path", default="")
+    args = parser.parse_args()
+
+    install_error = ""
+    if args.install:
+        res = run([sys.executable, "-m", "pip", "install", "sqlite-vec"])
+        if res.returncode != 0:
+            install_error = (res.stderr or res.stdout or "").strip()
+
+    extension_path = args.extension_path.strip() or discover_extension_path()
+    ok, load_error = test_load(extension_path)
+
+    if ok and args.write_env:
+        set_env_sqlite_vec(args.env_path, extension_path)
+
+    out = {
+        "ok": ok,
+        "sqlite_version": sqlite3.sqlite_version,
+        "extension_path": extension_path,
+        "loaded": ok,
+        "load_error": load_error,
+        "install_error": install_error,
+    }
+    sys.stdout.write(json.dumps(out))
+    return 0 if ok else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/src/agent/contextFiles.js

@@ -0,0 +1,30 @@
+const fs = require('fs');
+const path = require('path');
+const { dataDir } = require('../config');
+const { ensureDir } = require('../utils');
+
+const files = ['soul.md', 'human.md', 'human2.md', 'ownskill.md'];
+
+function ensureContextFiles() {
+  ensureDir(dataDir);
+  for (const name of files) {
+    const full = path.join(dataDir, name);
+    if (!fs.existsSync(full)) {
+      fs.writeFileSync(full, `# ${name.replace('.md', '')}\n\n`, 'utf8');
+    }
+  }
+}
+
+function loadContextFiles() {
+  ensureContextFiles();
+  return files.map((name) => {
+    const full = path.join(dataDir, name);
+    const content = fs.readFileSync(full, 'utf8');
+    return { name, full, content };
+  });
+}
+
+module.exports = {
+  ensureContextFiles,
+  loadContextFiles
+};

package/src/agent/db.js

@@ -0,0 +1,349 @@
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const { ensureDir, cosineSimilarity } = require('../utils');
+const { dbPath, maxMessages, recentMessages, vectorDbPath, sqliteVecExtension } = require('../config');
+
+ensureDir(path.dirname(dbPath));
+ensureDir(path.dirname(vectorDbPath));
+
+const sqliteMemoryScript = path.resolve(process.cwd(), 'scripts', 'sqlite_memory.py');
+let sqliteMemoryReady = false;
+let sqliteVecLoaded = false;
+let sqliteInitError = '';
+
+function runSqliteMemory(args) {
+  if (!fs.existsSync(sqliteMemoryScript)) {
+    throw new Error('sqlite memory helper script is missing');
+  }
+  const out = execFileSync('python3', [sqliteMemoryScript, ...args], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+  const parsed = JSON.parse(String(out || '{}'));
+  if (parsed && parsed.ok === false) {
+    throw new Error(String(parsed.error || 'sqlite memory helper failed'));
+  }
+  return parsed;
+}
+
+function ensureSqliteMemoryReady() {
+  if (sqliteMemoryReady) return;
+  try {
+    const args = ['init', '--db', vectorDbPath];
+    if (sqliteVecExtension) {
+      args.push('--vec-ext', sqliteVecExtension);
+    }
+    const initResult = runSqliteMemory(args);
+    sqliteVecLoaded = Boolean(initResult.vec_loaded);
+    sqliteInitError = String(initResult.vec_error || '');
+    sqliteMemoryReady = true;
+  } catch (err) {
+    sqliteMemoryReady = false;
+    sqliteVecLoaded = false;
+    sqliteInitError = String(err.message || err);
+  }
+}
+
+function initVectorMemory() {
+  ensureSqliteMemoryReady();
+  if (sqliteMemoryReady) {
+    let counts = null;
+    try {
+      const statsResult = runSqliteMemory(['stats', '--db', vectorDbPath]);
+      counts = statsResult && statsResult.counts ? statsResult.counts : null;
+    } catch (err) {
+      counts = null;
+    }
+    return {
+      ok: true,
+      backend: 'sqlite',
+      dbPath: vectorDbPath,
+      sqliteVecLoaded,
+      sqliteVecExtension,
+      sqliteInitError,
+      counts
+    };
+  }
+  return {
+    ok: false,
+    backend: 'json-fallback',
+    dbPath: dbPath,
+    sqliteVecLoaded: false,
+    sqliteVecExtension,
+    sqliteInitError,
+    counts: null
+  };
+}
+
+function defaultState() {
+  return {
+    conversations: {},
+    messages: [],
+    memories: [],
+    meta: {}
+  };
+}
+
+function loadState() {
+  if (!fs.existsSync(dbPath)) {
+    return defaultState();
+  }
+  try {
+    const parsed = JSON.parse(fs.readFileSync(dbPath, 'utf8'));
+    if (!parsed || typeof parsed !== 'object') return defaultState();
+    return {
+      conversations: parsed.conversations || {},
+      messages: Array.isArray(parsed.messages) ? parsed.messages : [],
+      memories: Array.isArray(parsed.memories) ? parsed.memories : [],
+      meta: parsed.meta && typeof parsed.meta === 'object' ? parsed.meta : {}
+    };
+  } catch (err) {
+    return defaultState();
+  }
+}
+
+const state = loadState();
+
+function saveState() {
+  fs.writeFileSync(dbPath, JSON.stringify(state, null, 2), 'utf8');
+}
+
+function now() {
+  return Date.now();
+}
+
+function conversationId(platform, userId) {
+  return `${platform}:${userId}`;
+}
+
+function nextId(rows) {
+  if (!rows.length) return 1;
+  return rows[rows.length - 1].id + 1;
+}
+
+function ensureConversation(platform, userId) {
+  const id = conversationId(platform, userId);
+  const ts = now();
+  const existing = state.conversations[id];
+  if (existing) {
+    existing.updated_at = ts;
+  } else {
+    state.conversations[id] = {
+      id,
+      platform,
+      user_id: userId,
+      created_at: ts,
+      updated_at: ts
+    };
+  }
+  saveState();
+  return id;
+}
+
+function addMessage(conversationIdValue, role, content) {
+  state.messages.push({
+    id: nextId(state.messages),
+    conversation_id: conversationIdValue,
+    role,
+    content,
+    created_at: now()
+  });
+
+  if (state.conversations[conversationIdValue]) {
+    state.conversations[conversationIdValue].updated_at = now();
+  }
+  saveState();
+}
+
+function getRecentMessages(conversationIdValue, limit = recentMessages) {
+  return state.messages
+    .filter((m) => m.conversation_id === conversationIdValue)
+    .slice(-limit)
+    .map((m) => ({ role: m.role, content: m.content, created_at: m.created_at }));
+}
+
+function getMessageCount(conversationIdValue) {
+  return state.messages.filter((m) => m.conversation_id === conversationIdValue).length;
+}
+
+function getMessagesForCompaction(conversationIdValue) {
+  const count = getMessageCount(conversationIdValue);
+  if (count <= maxMessages) return [];
+  const toCompact = Math.max(0, count - recentMessages);
+  if (!toCompact) return [];
+  return state.messages
+    .filter((m) => m.conversation_id === conversationIdValue)
+    .slice(0, toCompact)
+    .map((m) => ({ id: m.id, role: m.role, content: m.content }));
+}
+
+function deleteMessagesUpTo(conversationIdValue, maxId) {
+  state.messages = state.messages.filter((m) => {
+    if (m.conversation_id !== conversationIdValue) return true;
+    return m.id > maxId;
+  });
+  saveState();
+}
+
+function addMemory(conversationIdValue, source, content, embedding) {
+  const createdAt = now();
+  ensureSqliteMemoryReady();
+
+  if (sqliteMemoryReady) {
+    try {
+      runSqliteMemory([
+        'add',
+        '--db',
+        vectorDbPath,
+        '--conversation-id',
+        String(conversationIdValue || ''),
+        '--source',
+        String(source || ''),
+        '--content',
+        String(content || ''),
+        '--embedding-json',
+        JSON.stringify(Array.isArray(embedding) ? embedding : []),
+        '--created-at',
+        String(createdAt)
+      ]);
+      return;
+    } catch (err) {
+      // Fall back to legacy JSON memory if sqlite path is unavailable.
+    }
+  }
+
+  state.memories.push({
+    id: nextId(state.memories),
+    conversation_id: conversationIdValue,
+    source,
+    content,
+    embedding,
+    created_at: createdAt
+  });
+  saveState();
+}
+
+function getMeta(key, fallback = null) {
+  if (!key) return fallback;
+  if (!Object.prototype.hasOwnProperty.call(state.meta, key)) return fallback;
+  return state.meta[key];
+}
+
+function setMeta(key, value) {
+  if (!key) return;
+  state.meta[key] = value;
+  saveState();
+}
+
+function getRecentMessagesAll(limit = 200) {
+  return state.messages.slice(-limit).map((m) => ({
+    conversation_id: m.conversation_id,
+    role: m.role,
+    content: m.content,
+    created_at: m.created_at
+  }));
+}
+
+function getMessagesSince(sinceTs, limit = 500) {
+  const threshold = Number(sinceTs || 0);
+  return state.messages
+    .filter((m) => Number(m.created_at || 0) > threshold)
+    .slice(-limit)
+    .map((m) => ({
+      conversation_id: m.conversation_id,
+      role: m.role,
+      content: m.content,
+      created_at: m.created_at
+    }));
+}
+
+function getRelevantMemories(conversationIdValue, queryEmbedding, limit = 6) {
+  ensureSqliteMemoryReady();
+  if (sqliteMemoryReady) {
+    try {
+      const result = runSqliteMemory([
+        'search',
+        '--db',
+        vectorDbPath,
+        '--conversation-id',
+        String(conversationIdValue || ''),
+        '--query-embedding-json',
+        JSON.stringify(Array.isArray(queryEmbedding) ? queryEmbedding : []),
+        '--limit',
+        String(limit),
+        '--min-score',
+        '0.1',
+        '--window',
+        '600'
+      ]);
+      const rows = Array.isArray(result.rows) ? result.rows : [];
+      if (rows.length) {
+        return rows;
+      }
+    } catch (err) {
+      // Fall through to JSON fallback.
+    }
+  }
+
+  return state.memories
+    .filter(
+      (m) =>
+        m.conversation_id === conversationIdValue ||
+        m.conversation_id === 'global' ||
+        m.source === 'self_reflection'
+    )
+    .slice(-300)
+    .map((m) => ({
+      id: m.id,
+      source: m.source,
+      content: m.content,
+      created_at: m.created_at,
+      score: cosineSimilarity(queryEmbedding, m.embedding || [])
+    }))
+    .filter((m) => m.score > 0.1)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, limit);
+}
+
+function recordSkillUsage(name, provider = 'tool') {
+  const skillName = String(name || '').trim();
+  if (!skillName) return;
+  ensureSqliteMemoryReady();
+  if (!sqliteMemoryReady) return;
+  try {
+    runSqliteMemory([
+      'upsert-skill',
+      '--db',
+      vectorDbPath,
+      '--name',
+      skillName,
+      '--provider',
+      String(provider || 'tool'),
+      '--enabled',
+      '1',
+      '--updated-at',
+      String(now())
+    ]);
+  } catch (err) {
+    // Non-blocking telemetry.
+  }
+}
+
+module.exports = {
+  db: state,
+  ensureConversation,
+  addMessage,
+  getRecentMessages,
+  getMessageCount,
+  getMessagesForCompaction,
+  deleteMessagesUpTo,
+  addMemory,
+  getRelevantMemories,
+  getMeta,
+  setMeta,
+  getRecentMessagesAll,
+  getMessagesSince,
+  initVectorMemory,
+  recordSkillUsage
+};