tiger-agent 0.2.0

package/scripts/setup.js

@@ -0,0 +1,302 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const { execFileSync } = require('child_process');
+const { encryptString } = require('./cryptoEnv');
+
+function exists(p) {
+  try {
+    fs.accessSync(p, fs.constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function writeFile600(filePath, content) {
+  fs.writeFileSync(filePath, content, { mode: 0o600 });
+}
+
+function normalizeYesNo(s, defBool) {
+  const t = String(s || '').trim().toLowerCase();
+  if (!t) return defBool;
+  if (['y', 'yes', 'true', '1', 'on'].includes(t)) return true;
+  if (['n', 'no', 'false', '0', 'off'].includes(t)) return false;
+  return defBool;
+}
+
+function createRl() {
+  return readline.createInterface({ input: process.stdin, output: process.stdout });
+}
+
+function question(rl, prompt) {
+  return new Promise((resolve) => rl.question(prompt, (ans) => resolve(ans)));
+}
+
+async function questionHidden(prompt) {
+  // Minimal hidden input prompt that works in a normal TTY.
+  // Prints '*' for each char.
+  return await new Promise((resolve, reject) => {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+
+    if (!stdin.isTTY) {
+      reject(new Error('Hidden prompt requires a TTY'));
+      return;
+    }
+
+    stdout.write(prompt);
+    stdin.setRawMode(true);
+    stdin.resume();
+
+    let buf = '';
+    function onData(chunk) {
+      const s = chunk.toString('utf8');
+      for (const ch of s) {
+        if (ch === '\r' || ch === '\n') {
+          stdout.write('\n');
+          cleanup();
+          resolve(buf);
+          return;
+        }
+        if (ch === '\u0003') {
+          // Ctrl-C
+          cleanup();
+          reject(new Error('Aborted'));
+          return;
+        }
+        if (ch === '\u007f') {
+          // backspace
+          if (buf.length) {
+            buf = buf.slice(0, -1);
+            stdout.write('\b \b');
+          }
+          continue;
+        }
+        buf += ch;
+        stdout.write('*');
+      }
+    }
+
+    function cleanup() {
+      stdin.off('data', onData);
+      stdin.setRawMode(false);
+      stdin.pause();
+    }
+
+    stdin.on('data', onData);
+  });
+}
+
+function envLine(k, v) {
+  if (v == null) v = '';
+  const s = String(v);
+  // Quote if contains spaces or # to avoid comment truncation.
+  const needsQuotes = /\s|#|"|'/g.test(s);
+  if (!s) return `${k}=`;
+  if (!needsQuotes) return `${k}=${s}`;
+  // Use double quotes, escape backslashes and quotes.
+  const escaped = s.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+  return `${k}="${escaped}"`;
+}
+
+(async function main() {
+  const cwd = process.cwd();
+  const envPath = path.join(cwd, '.env');
+  const secretsPath = path.join(cwd, '.env.secrets');
+  const secretsEncPath = path.join(cwd, '.env.secrets.enc');
+
+  const rl = createRl();
+  try {
+    console.log('Tiger setup (creates .env and .env.secrets; optionally .env.secrets.enc)');
+
+    if (exists(envPath) || exists(secretsPath) || exists(secretsEncPath)) {
+      const ans = await question(
+        rl,
+        'Existing config found (.env/.env.secrets/.env.secrets.enc). Overwrite? (y/N): '
+      );
+      const ok = normalizeYesNo(ans, false);
+      if (!ok) {
+        console.log('Canceled. No files changed.');
+        process.exit(0);
+      }
+    }
+
+    const providerAns = (await question(rl, 'Choose provider [moonshot/code] (moonshot): ')).trim();
+    const provider = (providerAns || 'moonshot').toLowerCase();
+    if (!['moonshot', 'code'].includes(provider)) {
+      throw new Error('Invalid provider. Use moonshot or code.');
+    }
+
+    const useTelegram = normalizeYesNo(await question(rl, 'Enable Telegram bot? (y/N): '), false);
+
+    // Non-secret config
+    const baseUrlDefault = provider === 'code' ? 'https://api.kimi.com/coding/v1' : 'https://api.moonshot.cn/v1';
+    const chatModelDefault = provider === 'code' ? 'k2p5' : 'kimi-k1';
+    const embedModelDefault = provider === 'code' ? '' : 'kimi-embedding-v1';
+    const userAgentDefault = provider === 'code' ? 'KimiCLI/0.77' : '';
+
+    const baseUrl = (await question(rl, `KIMI_BASE_URL (${baseUrlDefault}): `)).trim() || baseUrlDefault;
+    const chatModel = (await question(rl, `KIMI_CHAT_MODEL (${chatModelDefault}): `)).trim() || chatModelDefault;
+    const enableEmbeddings = normalizeYesNo(
+      await question(rl, `Enable embeddings? (${provider === 'code' ? 'N' : 'Y'}/n): `),
+      provider !== 'code'
+    );
+    const embedModel = enableEmbeddings
+      ? (await question(rl, `KIMI_EMBED_MODEL (${embedModelDefault || 'empty'}): `)).trim() || embedModelDefault
+      : '';
+    const userAgent = (await question(rl, `KIMI_USER_AGENT (${userAgentDefault || 'empty'}): `)).trim() || userAgentDefault;
+
+    const timeoutMsRaw = (await question(rl, 'KIMI_TIMEOUT_MS (30000): ')).trim();
+    const timeoutMs = timeoutMsRaw ? String(Number(timeoutMsRaw) || 30000) : '30000';
+
+    const ownHoursRaw = (await question(rl, 'OWN_SKILL_UPDATE_HOURS (24): ')).trim();
+    const soulHoursRaw = (await question(rl, 'SOUL_UPDATE_HOURS (24): ')).trim();
+    const reflectionHoursRaw = (await question(rl, 'REFLECTION_UPDATE_HOURS (12): ')).trim();
+    const ingestTurnsRaw = (await question(rl, 'MEMORY_INGEST_EVERY_TURNS (2): ')).trim();
+    const ingestMinCharsRaw = (await question(rl, 'MEMORY_INGEST_MIN_CHARS (140): ')).trim();
+    const ownHours = String(Math.max(1, Number(ownHoursRaw || 24)));
+    const soulHours = String(Math.max(1, Number(soulHoursRaw || 24)));
+    const reflectionHours = String(Math.max(1, Number(reflectionHoursRaw || 12)));
+    const ingestTurns = String(Math.max(1, Number(ingestTurnsRaw || 2)));
+    const ingestMinChars = String(Math.max(20, Number(ingestMinCharsRaw || 140)));
+
+    const allowShell = normalizeYesNo(await question(rl, 'ALLOW_SHELL (false): '), false);
+    const allowSkillInstall = normalizeYesNo(await question(rl, 'ALLOW_SKILL_INSTALL (false): '), false);
+
+    const dataDir = (await question(rl, 'DATA_DIR (./data): ')).trim() || './data';
+    const dbPath = (await question(rl, 'DB_PATH (./db/agent.json): ')).trim() || './db/agent.json';
+    const usePersistentVectorDb = normalizeYesNo(
+      await question(rl, 'Use persistent SQLite vector DB path? (Y/n): '),
+      true
+    );
+    const defaultVectorDbPath = usePersistentVectorDb ? './db/memory.sqlite' : '/tmp/tiger_memory.db';
+    const vectorDbPath =
+      (await question(rl, `VECTOR_DB_PATH (${defaultVectorDbPath}): `)).trim() || defaultVectorDbPath;
+    const sqliteVecExtension = (await question(rl, 'SQLITE_VEC_EXTENSION (optional path): ')).trim();
+    const runSqliteVecSetup = normalizeYesNo(
+      await question(rl, 'Run sqlite-vec auto-setup now? (pip install + detect path) (y/N): '),
+      false
+    );
+
+    const maxMessagesRaw = (await question(rl, 'MAX_MESSAGES (200): ')).trim();
+    const recentMessagesRaw = (await question(rl, 'RECENT_MESSAGES (40): ')).trim();
+    const maxMessages = String(Number(maxMessagesRaw || 200) || 200);
+    const recentMessages = String(Number(recentMessagesRaw || 40) || 40);
+
+    // Secrets
+    let moonshotKey = '';
+    let kimiCodeKey = '';
+    let kimiAliasKey = '';
+    if (provider === 'moonshot') {
+      moonshotKey = (await questionHidden('MOONSHOT_API_KEY (hidden): ')).trim();
+    } else {
+      kimiCodeKey = (await questionHidden('KIMI_CODE_API_KEY (hidden): ')).trim();
+    }
+    const useAlias = normalizeYesNo(await question(rl, 'Also set KIMI_API_KEY alias? (y/N): '), false);
+    if (useAlias) {
+      kimiAliasKey = (await questionHidden('KIMI_API_KEY (hidden): ')).trim();
+    }
+
+    let telegramToken = '';
+    if (useTelegram) {
+      telegramToken = (await questionHidden('TELEGRAM_BOT_TOKEN (hidden): ')).trim();
+    }
+
+    const wantEncrypt = normalizeYesNo(
+      await question(rl, 'Encrypt .env.secrets to .env.secrets.enc and delete plaintext? (y/N): '),
+      false
+    );
+
+    let secretsPass = '';
+    if (wantEncrypt) {
+      secretsPass = await questionHidden('SECRETS_PASSPHRASE (hidden): ');
+      const secretsPass2 = await questionHidden('Confirm SECRETS_PASSPHRASE (hidden): ');
+      if (secretsPass !== secretsPass2) throw new Error('Passphrases do not match');
+      secretsPass = secretsPass.trim();
+      if (!secretsPass) throw new Error('Empty passphrase not allowed');
+    }
+
+    // Write files
+    const envLines = [
+      '# Non-secret config',
+      envLine('KIMI_PROVIDER', provider),
+      envLine('KIMI_BASE_URL', baseUrl),
+      envLine('KIMI_CHAT_MODEL', chatModel),
+      envLine('KIMI_EMBED_MODEL', embedModel),
+      envLine('KIMI_USER_AGENT', userAgent),
+      envLine('KIMI_ENABLE_EMBEDDINGS', enableEmbeddings ? 'true' : 'false'),
+      envLine('KIMI_TIMEOUT_MS', timeoutMs),
+      envLine('OWN_SKILL_UPDATE_HOURS', ownHours),
+      envLine('SOUL_UPDATE_HOURS', soulHours),
+      envLine('REFLECTION_UPDATE_HOURS', reflectionHours),
+      envLine('MEMORY_INGEST_EVERY_TURNS', ingestTurns),
+      envLine('MEMORY_INGEST_MIN_CHARS', ingestMinChars),
+      '',
+      '# Encrypted secrets support (optional)',
+      envLine('SECRETS_FILE', '.env.secrets.enc'),
+      // If encrypting, user must export SECRETS_PASSPHRASE when running the bot.
+      envLine('SECRETS_PASSPHRASE', ''),
+      '',
+      envLine('ALLOW_SHELL', allowShell ? 'true' : 'false'),
+      envLine('ALLOW_SKILL_INSTALL', allowSkillInstall ? 'true' : 'false'),
+      envLine('DATA_DIR', dataDir),
+      envLine('DB_PATH', dbPath),
+      envLine('VECTOR_DB_PATH', vectorDbPath),
+      envLine('SQLITE_VEC_EXTENSION', sqliteVecExtension),
+      envLine('MAX_MESSAGES', maxMessages),
+      envLine('RECENT_MESSAGES', recentMessages),
+      ''
+    ];
+
+    const secretLines = [
+      '# Secrets only (do not commit)',
+      envLine('MOONSHOT_API_KEY', moonshotKey),
+      envLine('KIMI_CODE_API_KEY', kimiCodeKey),
+      envLine('KIMI_API_KEY', kimiAliasKey),
+      envLine('TELEGRAM_BOT_TOKEN', telegramToken),
+      ''
+    ];
+
+    writeFile600(envPath, envLines.join('\n') + '\n');
+    writeFile600(secretsPath, secretLines.join('\n') + '\n');
+
+    if (wantEncrypt) {
+      const plaintext = fs.readFileSync(secretsPath, 'utf8');
+      const payload = encryptString(plaintext, secretsPass);
+      fs.writeFileSync(secretsEncPath, JSON.stringify(payload, null, 2) + '\n', { mode: 0o600 });
+      fs.unlinkSync(secretsPath);
+      console.log('Wrote .env.secrets.enc and removed plaintext .env.secrets');
+      console.log('When running the bot, you must export SECRETS_PASSPHRASE in your shell or service env.');
+    } else {
+      console.log('Wrote .env and .env.secrets');
+    }
+
+    if (runSqliteVecSetup) {
+      try {
+        const out = execFileSync(
+          'python3',
+          ['scripts/sqlite_vec_setup.py', '--install', '--write-env'],
+          { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }
+        );
+        console.log(`sqlite-vec setup result: ${String(out || '').trim()}`);
+      } catch (err) {
+        const msg =
+          (err && err.stderr && String(err.stderr).trim()) ||
+          (err && err.stdout && String(err.stdout).trim()) ||
+          (err && err.message) ||
+          'unknown sqlite-vec setup error';
+        console.log(`sqlite-vec setup skipped/failed: ${msg}`);
+      }
+    }
+
+    console.log('Setup complete. Restart the bot to load the new config.');
+  } finally {
+    rl.close();
+  }
+})().catch((err) => {
+  console.error(`Setup failed: ${err.message}`);
+  process.exit(1);
+});

package/scripts/sqlite_memory.py

@@ -0,0 +1,297 @@
+#!/usr/bin/env python3
+import argparse
+import json
+import math
+import os
+import sqlite3
+import sys
+from typing import Any, Dict, List
+
+
+def connect(db_path: str) -> sqlite3.Connection:
+    os.makedirs(os.path.dirname(db_path), exist_ok=True)
+    conn = sqlite3.connect(db_path)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def set_meta(conn: sqlite3.Connection, key: str, value: str) -> None:
+    conn.execute(
+        "INSERT INTO meta(key, value) VALUES(?, ?) ON CONFLICT(key) DO UPDATE SET value=excluded.value",
+        (key, value),
+    )
+
+
+def init_db(db_path: str, vec_ext_path: str) -> Dict[str, Any]:
+    conn = connect(db_path)
+    try:
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS conversations (
+              id INTEGER PRIMARY KEY AUTOINCREMENT,
+              conversation_id TEXT NOT NULL UNIQUE,
+              platform TEXT DEFAULT '',
+              user_id TEXT DEFAULT '',
+              created_at INTEGER NOT NULL,
+              updated_at INTEGER NOT NULL
+            )
+            """
+        )
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS messages (
+              id INTEGER PRIMARY KEY AUTOINCREMENT,
+              conversation_id TEXT NOT NULL,
+              role TEXT NOT NULL,
+              content TEXT NOT NULL,
+              created_at INTEGER NOT NULL
+            )
+            """
+        )
+        conn.execute("CREATE INDEX IF NOT EXISTS idx_messages_conv_time ON messages(conversation_id, created_at)")
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS skills (
+              id INTEGER PRIMARY KEY AUTOINCREMENT,
+              name TEXT NOT NULL UNIQUE,
+              provider TEXT DEFAULT '',
+              enabled INTEGER DEFAULT 1,
+              updated_at INTEGER NOT NULL
+            )
+            """
+        )
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS memories (
+              id INTEGER PRIMARY KEY AUTOINCREMENT,
+              conversation_id TEXT NOT NULL,
+              source TEXT NOT NULL,
+              content TEXT NOT NULL,
+              embedding_json TEXT NOT NULL,
+              created_at INTEGER NOT NULL
+            )
+            """
+        )
+        conn.execute("CREATE INDEX IF NOT EXISTS idx_memories_conv_time ON memories(conversation_id, created_at)")
+        conn.execute("CREATE INDEX IF NOT EXISTS idx_memories_source_time ON memories(source, created_at)")
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS meta (
+              key TEXT PRIMARY KEY,
+              value TEXT NOT NULL
+            )
+            """
+        )
+
+        vec_loaded = False
+        vec_error = ""
+        if vec_ext_path:
+            try:
+                conn.enable_load_extension(True)
+                conn.load_extension(vec_ext_path)
+                vec_loaded = True
+            except Exception as err:  # pragma: no cover
+                vec_loaded = False
+                vec_error = str(err)
+            finally:
+                try:
+                    conn.enable_load_extension(False)
+                except Exception:
+                    pass
+
+        set_meta(conn, "sqlite_vec_extension_path", vec_ext_path or "")
+        set_meta(conn, "sqlite_vec_loaded", "1" if vec_loaded else "0")
+        set_meta(conn, "sqlite_vec_error", vec_error)
+        conn.commit()
+        return {"ok": True, "vec_loaded": vec_loaded, "vec_error": vec_error}
+    finally:
+        conn.close()
+
+
+def stats(db_path: str) -> Dict[str, Any]:
+    conn = connect(db_path)
+    try:
+        out = {}
+        for table in ["memories", "conversations", "messages", "skills"]:
+            row = conn.execute(f"SELECT COUNT(*) AS c FROM {table}").fetchone()
+            out[table] = int(row["c"] if row else 0)
+        return {"ok": True, "counts": out}
+    finally:
+        conn.close()
+
+
+def upsert_skill(db_path: str, name: str, provider: str, enabled: int, updated_at: int) -> Dict[str, Any]:
+    conn = connect(db_path)
+    try:
+        conn.execute(
+            """
+            INSERT INTO skills(name, provider, enabled, updated_at)
+            VALUES(?, ?, ?, ?)
+            ON CONFLICT(name) DO UPDATE SET
+              provider=excluded.provider,
+              enabled=excluded.enabled,
+              updated_at=excluded.updated_at
+            """,
+            (name, provider, int(enabled), int(updated_at)),
+        )
+        conn.commit()
+        return {"ok": True}
+    finally:
+        conn.close()
+
+
+def parse_embedding(text: str) -> List[float]:
+    try:
+        data = json.loads(text or "[]")
+        if not isinstance(data, list):
+            return []
+        out = []
+        for v in data:
+            try:
+                out.append(float(v))
+            except Exception:
+                pass
+        return out
+    except Exception:
+        return []
+
+
+def cosine_similarity(a: List[float], b: List[float]) -> float:
+    if not a or not b or len(a) != len(b):
+        return -1.0
+    dot = 0.0
+    aa = 0.0
+    bb = 0.0
+    for i in range(len(a)):
+        av = float(a[i])
+        bv = float(b[i])
+        dot += av * bv
+        aa += av * av
+        bb += bv * bv
+    if aa <= 0.0 or bb <= 0.0:
+        return -1.0
+    return dot / (math.sqrt(aa) * math.sqrt(bb))
+
+
+def add_memory(
+    db_path: str, conversation_id: str, source: str, content: str, embedding_json: str, created_at: int
+) -> Dict[str, Any]:
+    conn = connect(db_path)
+    try:
+        conn.execute(
+            "INSERT INTO memories(conversation_id, source, content, embedding_json, created_at) VALUES(?, ?, ?, ?, ?)",
+            (conversation_id, source, content, embedding_json or "[]", int(created_at)),
+        )
+        row_id = conn.execute("SELECT last_insert_rowid() AS id").fetchone()["id"]
+        conn.commit()
+        return {"ok": True, "id": row_id}
+    finally:
+        conn.close()
+
+
+def search_memories(
+    db_path: str,
+    conversation_id: str,
+    query_embedding_json: str,
+    limit: int,
+    min_score: float,
+    window: int,
+) -> Dict[str, Any]:
+    conn = connect(db_path)
+    try:
+        q_emb = parse_embedding(query_embedding_json)
+        if not q_emb:
+            return {"ok": True, "rows": []}
+
+        rows = conn.execute(
+            """
+            SELECT id, conversation_id, source, content, embedding_json, created_at
+            FROM memories
+            WHERE (conversation_id = ? OR conversation_id = 'global' OR source = 'self_reflection')
+            ORDER BY created_at DESC
+            LIMIT ?
+            """,
+            (conversation_id, int(window)),
+        ).fetchall()
+
+        ranked = []
+        for row in rows:
+            emb = parse_embedding(row["embedding_json"])
+            score = cosine_similarity(q_emb, emb)
+            if score > float(min_score):
+                ranked.append(
+                    {
+                        "id": row["id"],
+                        "source": row["source"],
+                        "content": row["content"],
+                        "created_at": row["created_at"],
+                        "score": score,
+                    }
+                )
+
+        ranked.sort(key=lambda r: r["score"], reverse=True)
+        return {"ok": True, "rows": ranked[: int(limit)]}
+    finally:
+        conn.close()
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("command", choices=["init", "add", "search", "stats", "upsert-skill"])
+    parser.add_argument("--db", required=True)
+    parser.add_argument("--vec-ext", default="")
+    parser.add_argument("--conversation-id", default="")
+    parser.add_argument("--source", default="")
+    parser.add_argument("--content", default="")
+    parser.add_argument("--embedding-json", default="[]")
+    parser.add_argument("--query-embedding-json", default="[]")
+    parser.add_argument("--created-at", default="0")
+    parser.add_argument("--limit", default="6")
+    parser.add_argument("--min-score", default="0.1")
+    parser.add_argument("--window", default="600")
+    parser.add_argument("--name", default="")
+    parser.add_argument("--provider", default="")
+    parser.add_argument("--enabled", default="1")
+    parser.add_argument("--updated-at", default="0")
+    args = parser.parse_args()
+
+    try:
+        if args.command == "init":
+            result = init_db(args.db, args.vec_ext)
+        elif args.command == "add":
+            result = add_memory(
+                args.db,
+                args.conversation_id,
+                args.source,
+                args.content,
+                args.embedding_json,
+                int(args.created_at or "0"),
+            )
+        elif args.command == "stats":
+            result = stats(args.db)
+        elif args.command == "upsert-skill":
+            result = upsert_skill(
+                args.db,
+                args.name,
+                args.provider or "tool",
+                int(args.enabled or "1"),
+                int(args.updated_at or "0"),
+            )
+        else:
+            result = search_memories(
+                args.db,
+                args.conversation_id,
+                args.query_embedding_json,
+                int(args.limit or "6"),
+                float(args.min_score or "0.1"),
+                int(args.window or "600"),
+            )
+        sys.stdout.write(json.dumps(result))
+        return 0
+    except Exception as err:
+        sys.stdout.write(json.dumps({"ok": False, "error": str(err)}))
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())