@offerpilot/axiomruntime 0.0.1

package/dist/telegram/memory/memory-service.js

@@ -0,0 +1,413 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { getMemoryBackupDir } from "../../core/config/paths.js";
+import { escapeHtml, truncateText } from "../interaction/formatter.js";
+import { MemoryStore } from "./memory-store.js";
+const DEFAULT_INJECTION_CHAR_BUDGET = 3000;
+const DEFAULT_SHORT_TERM_TTL_MS = 72 * 60 * 60 * 1000;
+const PROFILE_TITLE = "用户画像";
+const PERSONA_TITLE = "Bot 人设";
+const RAW_DESCRIPTION_TITLE = "用户原始自我描述";
+export class MemoryService {
+    botId;
+    store;
+    ownsStore;
+    injectionCharBudget;
+    shortTermTtlMs;
+    constructor(options) {
+        this.botId = options.botId || "default";
+        this.store = options.store ?? new MemoryStore();
+        this.ownsStore = !options.store;
+        this.injectionCharBudget = options.injectionCharBudget ?? DEFAULT_INJECTION_CHAR_BUDGET;
+        this.shortTermTtlMs = options.shortTermTtlMs ?? DEFAULT_SHORT_TERM_TTL_MS;
+    }
+    close() {
+        if (this.ownsStore)
+            this.store.close();
+    }
+    getStorePath() {
+        return this.store.getPath();
+    }
+    save(chatId, input) {
+        const normalized = this.normalizeSaveInput(chatId, input);
+        return this.store.save(normalized);
+    }
+    remember(chatId, input) {
+        const category = input.category ?? classifyCategory(input.content);
+        if (category === "credential") {
+            throw new Error("加密记忆尚未启用，凭证类内容不会明文保存。");
+        }
+        const scope = input.scope ?? defaultScopeForCategory(category);
+        const duration = input.duration ?? "permanent";
+        const expiresAt = duration === "short_term"
+            ? Date.now() + (input.ttlMs ?? this.shortTermTtlMs)
+            : null;
+        return this.save(chatId, {
+            scope,
+            category,
+            title: input.title ?? inferTitle(input.content, category),
+            content: input.content,
+            tags: input.tags ?? inferTags(input.content, category),
+            duration,
+            expiresAt,
+            priority: category === "profile" || category === "persona" ? 1 : 0
+        });
+    }
+    saveProfile(chatId, content) {
+        return this.store.upsertSingleton(this.normalizeSaveInput(chatId, {
+            scope: "global",
+            category: "profile",
+            title: PROFILE_TITLE,
+            content,
+            tags: ["profile"],
+            priority: 1,
+            duration: "permanent"
+        }));
+    }
+    savePersona(chatId, content) {
+        return this.store.upsertSingleton(this.normalizeSaveInput(chatId, {
+            scope: "bot",
+            category: "persona",
+            title: PERSONA_TITLE,
+            content,
+            tags: ["persona", this.botId],
+            priority: 1,
+            duration: "permanent"
+        }));
+    }
+    saveRawDescription(chatId, content) {
+        return this.store.upsertSingleton(this.normalizeSaveInput(chatId, {
+            scope: "bot",
+            category: "fact",
+            title: RAW_DESCRIPTION_TITLE,
+            content,
+            tags: ["profile", "raw"],
+            priority: 0,
+            duration: "permanent"
+        }));
+    }
+    getProfile(chatId) {
+        return this.store.getProfile(normalizeChatId(chatId));
+    }
+    getPersona(chatId) {
+        return this.store.getPersona(normalizeChatId(chatId), this.botId);
+    }
+    listVisible(chatId, query, limit = 50) {
+        return this.store.listVisible({
+            chatId: normalizeChatId(chatId),
+            botId: this.botId,
+            query,
+            limit
+        });
+    }
+    retrieveForPrompt(chatId, prompt) {
+        const visible = this.store.listVisible({
+            chatId: normalizeChatId(chatId),
+            botId: this.botId,
+            limit: 200
+        });
+        if (!visible.length)
+            return [];
+        const required = visible.filter((entry) => entry.priority > 0);
+        const keywords = extractKeywords(prompt);
+        const scored = visible
+            .filter((entry) => entry.priority <= 0)
+            .map((entry) => ({ entry, score: scoreMemory(entry, keywords) }))
+            .filter((item) => item.score > 0)
+            .sort((a, b) => b.score - a.score || b.entry.updatedAt - a.entry.updatedAt)
+            .slice(0, 8)
+            .map((item) => item.entry);
+        return trimEntriesToBudget(dedupeEntries([
+            ...sortRequiredEntries(required),
+            ...scored
+        ]), this.injectionCharBudget);
+    }
+    delete(chatId, selector) {
+        const value = selector.trim();
+        if (!value)
+            return 0;
+        if (/^\d+$/.test(value)) {
+            return this.store.deleteVisibleById(normalizeChatId(chatId), this.botId, Number(value));
+        }
+        if (value === "profile") {
+            const profile = this.getProfile(chatId);
+            return profile ? this.store.deleteVisibleById(normalizeChatId(chatId), this.botId, profile.id) : 0;
+        }
+        if (value === "persona") {
+            const persona = this.getPersona(chatId);
+            return persona ? this.store.deleteVisibleById(normalizeChatId(chatId), this.botId, persona.id) : 0;
+        }
+        return this.store.deleteVisibleByKeyword(normalizeChatId(chatId), this.botId, value);
+    }
+    promote(chatId, id) {
+        return this.store.promote(normalizeChatId(chatId), this.botId, id);
+    }
+    clearScope(chatId, scope) {
+        return this.store.clearScope(normalizeChatId(chatId), this.botId, scope);
+    }
+    cleanupExpired(now = Date.now()) {
+        return this.store.deleteExpired(now);
+    }
+    async backup(retain = 7) {
+        const dbPath = this.store.getPath();
+        try {
+            await fs.access(dbPath);
+        }
+        catch {
+            return null;
+        }
+        const backupDir = getMemoryBackupDir();
+        await fs.mkdir(backupDir, { recursive: true });
+        const stamp = new Date().toISOString().slice(0, 10);
+        const backupPath = path.join(backupDir, `memory-${stamp}.sqlite`);
+        try {
+            await fs.copyFile(dbPath, backupPath);
+            await pruneBackups(backupDir, retain);
+            return backupPath;
+        }
+        catch {
+            return null;
+        }
+    }
+    formatList(chatId, query) {
+        const entries = this.listVisible(chatId, query, 30);
+        if (!entries.length)
+            return "🤖 还没有记忆。";
+        return [
+            "🤖 当前记忆",
+            "",
+            ...entries.map(formatMemorySummary)
+        ].join("\n\n");
+    }
+    normalizeSaveInput(chatId, input) {
+        if (!input.content.trim()) {
+            throw new Error("记忆内容不能为空。");
+        }
+        const category = input.category ?? "fact";
+        if (category === "credential" && !input.encrypted) {
+            throw new Error("加密记忆尚未启用，凭证类内容不会明文保存。");
+        }
+        const scope = normalizeScope(input.scope ?? defaultScopeForCategory(category), category);
+        const duration = input.duration ?? "permanent";
+        const expiresAt = duration === "short_term"
+            ? input.expiresAt ?? Date.now() + this.shortTermTtlMs
+            : null;
+        return {
+            chatId: normalizeChatId(chatId),
+            scope,
+            botId: scope === "bot" ? this.botId : null,
+            category,
+            title: (input.title ?? inferTitle(input.content, category)).trim(),
+            content: input.content.trim(),
+            tags: normalizeTags(input.tags ?? []),
+            priority: input.priority ?? 0,
+            duration,
+            encrypted: input.encrypted ?? false,
+            expiresAt
+        };
+    }
+}
+export function getBotIdFromToken(token) {
+    const value = String(token ?? "").trim();
+    if (!value)
+        return "default";
+    return value.split(":", 1)[0] || "default";
+}
+export function buildFullProfilePrompt(rawDescription) {
+    return [
+        "根据以下用户的自我描述，生成两份内容，用分隔符 '=====PERSONA=====' 分开。",
+        "",
+        "<user_description>",
+        rawDescription,
+        "</user_description>",
+        "",
+        "第一部分【用户画像】（跨所有助手共享，只描述用户本人）：",
+        "- 用户身份、技术背景、通用偏好、通用工作方式",
+        "- 不要包含任何特定助手的角色定位",
+        "- 500 字符以内",
+        "",
+        "建议结构：",
+        "## 用户背景",
+        "## 通用偏好",
+        "",
+        "第二部分【Bot 人设】（仅本助手使用）：",
+        "- 本助手的职责域、专业风格、风险边界",
+        "- 400 字符以内",
+        "",
+        "建议结构：",
+        "## 角色与职责",
+        "## 工作风格",
+        "## 风险边界",
+        "",
+        "通用要求：输出纯文本；中文输入就使用中文；只输出内容本身，不要多余说明。"
+    ].join("\n");
+}
+export function buildPersonaPrompt(rawDescription, existingProfile) {
+    return [
+        "已知用户画像如下（勿修改、勿重复其中内容）：",
+        "<existing_profile>",
+        existingProfile,
+        "</existing_profile>",
+        "",
+        "用户希望本助手承担的职责描述：",
+        "<bot_description>",
+        rawDescription,
+        "</bot_description>",
+        "",
+        "生成本助手的 Bot 人设，要求：",
+        "- 只描述本助手的职责域、专业风格、风险边界",
+        "- 400 字符以内；中文输入就使用中文",
+        "",
+        "建议结构：",
+        "## 角色与职责",
+        "## 工作风格",
+        "## 风险边界",
+        "",
+        "只输出人设内容，不要多余说明。"
+    ].join("\n");
+}
+export function splitProfileAndPersona(value) {
+    const [profile, ...rest] = value.split("=====PERSONA=====");
+    return {
+        profile: profile?.trim() || value.trim(),
+        persona: rest.join("=====PERSONA=====").trim()
+    };
+}
+function normalizeChatId(chatId) {
+    return String(chatId);
+}
+function normalizeScope(scope, category) {
+    if (category === "profile")
+        return "global";
+    if (category === "persona" || category === "credential")
+        return "bot";
+    return scope;
+}
+function defaultScopeForCategory(category) {
+    if (category === "profile")
+        return "global";
+    if (category === "persona" || category === "credential" || category === "note" || category === "skill")
+        return "bot";
+    return "global";
+}
+function classifyCategory(content) {
+    const text = content.toLowerCase();
+    if (/密码|账号|token|api[_ -]?key|secret|credential|password/.test(text))
+        return "credential";
+    if (/偏好|喜欢|习惯|prefer|preference/.test(text))
+        return "preference";
+    if (/明天|今天|本周|临时|提醒|todo|计划/.test(text))
+        return "note";
+    return "fact";
+}
+function inferTitle(content, category) {
+    const firstLine = content.trim().split(/\r?\n/, 1)[0] ?? "";
+    const title = firstLine.replace(/^#+\s*/, "").trim();
+    if (title)
+        return truncateText(title, 40);
+    if (category === "preference")
+        return "偏好";
+    if (category === "note")
+        return "临时笔记";
+    return "记忆";
+}
+function inferTags(content, category) {
+    const tags = new Set([category]);
+    for (const match of content.matchAll(/#([\p{L}\p{N}_-]+)/gu)) {
+        tags.add(match[1]);
+    }
+    return [...tags].slice(0, 8);
+}
+function normalizeTags(tags) {
+    const seen = new Set();
+    const result = [];
+    for (const tag of tags) {
+        const value = String(tag).trim();
+        if (!value || seen.has(value))
+            continue;
+        seen.add(value);
+        result.push(value);
+        if (result.length >= 12)
+            break;
+    }
+    return result;
+}
+function extractKeywords(prompt) {
+    const words = prompt
+        .toLowerCase()
+        .replace(/[^\p{L}\p{N}_-]+/gu, " ")
+        .split(/\s+/)
+        .filter((word) => word.length >= 2);
+    return [...new Set(words)].slice(0, 20);
+}
+function scoreMemory(entry, keywords) {
+    if (!keywords.length)
+        return 0;
+    const haystack = `${entry.title}\n${entry.content}\n${entry.tags.join(" ")}`.toLowerCase();
+    let score = 0;
+    for (const keyword of keywords) {
+        if (haystack.includes(keyword))
+            score += entry.title.toLowerCase().includes(keyword) ? 3 : 1;
+    }
+    if (entry.category === "preference")
+        score += 1;
+    if (entry.category === "note")
+        score += 0.5;
+    return score;
+}
+function sortRequiredEntries(entries) {
+    const order = {
+        persona: 0,
+        profile: 1,
+        preference: 2,
+        fact: 3,
+        note: 4,
+        skill: 5,
+        credential: 6
+    };
+    return [...entries].sort((a, b) => order[a.category] - order[b.category] || b.updatedAt - a.updatedAt);
+}
+function dedupeEntries(entries) {
+    const seen = new Set();
+    const result = [];
+    for (const entry of entries) {
+        if (seen.has(entry.id))
+            continue;
+        seen.add(entry.id);
+        result.push(entry);
+    }
+    return result;
+}
+function trimEntriesToBudget(entries, budget) {
+    const required = entries.filter((entry) => entry.priority > 0);
+    const optional = entries.filter((entry) => entry.priority <= 0);
+    const result = [...required];
+    let used = required.reduce((sum, entry) => sum + entry.content.length + entry.title.length, 0);
+    for (const entry of optional) {
+        const cost = entry.content.length + entry.title.length;
+        if (used + cost > budget && result.length)
+            continue;
+        result.push(entry);
+        used += cost;
+        if (used >= budget)
+            break;
+    }
+    return result;
+}
+function formatMemorySummary(entry) {
+    const scope = entry.scope === "global" ? "global" : "bot";
+    const expiry = entry.expiresAt ? `\nExpires：<code>${escapeHtml(new Date(entry.expiresAt).toISOString())}</code>` : "";
+    return [
+        `<b>#${entry.id} ${escapeHtml(entry.title)}</b>`,
+        `Scope：<code>${scope}</code> · Category：<code>${entry.category}</code>`,
+        `Content：${escapeHtml(truncateText(entry.encrypted ? "(encrypted)" : entry.content, 220))}${expiry}`
+    ].join("\n");
+}
+async function pruneBackups(backupDir, retain) {
+    const entries = await fs.readdir(backupDir).catch(() => []);
+    const files = entries
+        .filter((name) => /^memory-\d{4}-\d{2}-\d{2}\.sqlite$/.test(name))
+        .sort()
+        .reverse();
+    await Promise.all(files.slice(retain).map((name) => fs.rm(path.join(backupDir, name), { force: true })));
+}

package/dist/telegram/memory/memory-store.js

@@ -0,0 +1,216 @@
+import fs from "node:fs";
+import path from "node:path";
+import Database from "better-sqlite3";
+import { getMemoryDbPath } from "../../core/config/paths.js";
+export class MemoryStore {
+    dbPath;
+    db;
+    constructor(dbPath = getMemoryDbPath()) {
+        this.dbPath = dbPath;
+        fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+        this.db = new Database(dbPath);
+        this.db.pragma("journal_mode = WAL");
+        this.db.pragma("busy_timeout = 5000");
+        this.migrate();
+    }
+    close() {
+        this.db.close();
+    }
+    getPath() {
+        return this.dbPath;
+    }
+    save(input) {
+        const now = Date.now();
+        const result = this.db.prepare(`insert into memories (
+        chatId, scope, botId, category, title, content, tags, priority, duration,
+        encrypted, expiresAt, createdAt, updatedAt
+      ) values (
+        @chatId, @scope, @botId, @category, @title, @content, @tagsJson, @priority, @duration,
+        @encryptedValue, @expiresAt, @now, @now
+      )`).run({
+            ...input,
+            tagsJson: JSON.stringify(input.tags),
+            encryptedValue: input.encrypted ? 1 : 0,
+            now
+        });
+        return this.getById(Number(result.lastInsertRowid));
+    }
+    upsertSingleton(input) {
+        const current = this.getSingleton(input.chatId, input.scope, input.botId, input.category, input.title);
+        if (current) {
+            const now = Date.now();
+            this.db.prepare(`update memories set
+          content = @content,
+          tags = @tagsJson,
+          priority = @priority,
+          duration = @duration,
+          encrypted = @encryptedValue,
+          expiresAt = @expiresAt,
+          updatedAt = @now
+         where id = @id`).run({
+                id: current.id,
+                content: input.content,
+                tagsJson: JSON.stringify(input.tags),
+                priority: input.priority,
+                duration: input.duration,
+                encryptedValue: input.encrypted ? 1 : 0,
+                expiresAt: input.expiresAt,
+                now
+            });
+            return this.getById(current.id);
+        }
+        const now = Date.now();
+        this.db.prepare(`insert into memories (
+        chatId, scope, botId, category, title, content, tags, priority, duration,
+        encrypted, expiresAt, createdAt, updatedAt
+      ) values (
+        @chatId, @scope, @botId, @category, @title, @content, @tagsJson, @priority, @duration,
+        @encryptedValue, @expiresAt, @now, @now
+      )`).run({
+            ...input,
+            tagsJson: JSON.stringify(input.tags),
+            encryptedValue: input.encrypted ? 1 : 0,
+            now
+        });
+        return this.getSingleton(input.chatId, input.scope, input.botId, input.category, input.title);
+    }
+    getById(id) {
+        const row = this.db.prepare("select * from memories where id = ?").get(id);
+        return row ? rowToEntry(row) : null;
+    }
+    getSingleton(chatId, scope, botId, category, title) {
+        const row = this.db.prepare(`select * from memories
+       where chatId = ? and scope = ? and botId is ? and category = ? and title = ?
+       limit 1`).get(chatId, scope, botId, category, title);
+        return row ? rowToEntry(row) : null;
+    }
+    getProfile(chatId) {
+        const row = this.db.prepare("select * from memories where chatId = ? and scope = 'global' and category = 'profile' order by updatedAt desc limit 1").get(chatId);
+        return row ? rowToEntry(row) : null;
+    }
+    getPersona(chatId, botId) {
+        const row = this.db.prepare("select * from memories where chatId = ? and scope = 'bot' and botId = ? and category = 'persona' order by updatedAt desc limit 1").get(chatId, botId);
+        return row ? rowToEntry(row) : null;
+    }
+    listVisible(input) {
+        const now = Date.now();
+        const params = {
+            chatId: input.chatId,
+            botId: input.botId,
+            now,
+            limit: input.limit ?? 100
+        };
+        const query = input.query?.trim().toLowerCase();
+        const searchClause = query
+            ? "and (lower(title) like @query or lower(content) like @query or lower(tags) like @query)"
+            : "";
+        if (query)
+            params.query = `%${query}%`;
+        const rows = this.db.prepare(`select * from memories
+       where ${visibilityClause()} and (expiresAt is null or expiresAt > @now)
+       ${searchClause}
+       order by priority desc, updatedAt desc, id desc
+       limit @limit`).all(params);
+        return rows.map(rowToEntry);
+    }
+    deleteVisibleById(chatId, botId, id) {
+        const result = this.db.prepare(`delete from memories
+       where id = @id and ${visibilityClause()}`).run({ chatId, botId, id });
+        return result.changes;
+    }
+    deleteVisibleByKeyword(chatId, botId, keyword) {
+        if (keyword.trim().length < 2)
+            return 0;
+        const query = `%${keyword.trim().toLowerCase()}%`;
+        const result = this.db.prepare(`delete from memories
+       where ${visibilityClause()}
+       and (lower(title) like @query or lower(content) like @query or lower(tags) like @query)`).run({ chatId, botId, query });
+        return result.changes;
+    }
+    clearScope(chatId, botId, scope) {
+        const result = scope === "global"
+            ? this.db.prepare("delete from memories where chatId = ? and scope = 'global'").run(chatId)
+            : this.db.prepare("delete from memories where chatId = ? and scope = 'bot' and botId = ?").run(chatId, botId);
+        return result.changes;
+    }
+    promote(chatId, botId, id) {
+        const entry = this.getById(id);
+        if (!entry || entry.chatId !== chatId || entry.scope !== "bot" || entry.botId !== botId)
+            return null;
+        if (entry.category === "persona") {
+            throw new Error("Bot 人设不能升级为 global。");
+        }
+        this.db.prepare("update memories set scope = 'global', botId = null, updatedAt = ? where id = ?").run(Date.now(), id);
+        return this.getById(id);
+    }
+    deleteExpired(now = Date.now()) {
+        const result = this.db.prepare("delete from memories where expiresAt is not null and expiresAt <= ?").run(now);
+        return result.changes;
+    }
+    migrate() {
+        this.db.exec(`
+      create table if not exists memories (
+        id integer primary key autoincrement,
+        chatId text not null,
+        scope text not null default 'bot' check (scope in ('global', 'bot')),
+        botId text,
+        category text not null check (category in ('profile', 'persona', 'credential', 'fact', 'preference', 'note', 'skill')),
+        title text not null,
+        content text not null,
+        tags text not null default '[]',
+        priority integer not null default 0,
+        duration text not null default 'permanent' check (duration in ('permanent', 'short_term')),
+        encrypted integer not null default 0,
+        expiresAt integer,
+        createdAt integer not null,
+        updatedAt integer not null,
+        check (scope = 'global' or botId is not null),
+        unique (chatId, scope, botId, category, title)
+      );
+      create index if not exists idx_memories_owner on memories (chatId, scope, botId);
+      create index if not exists idx_memories_expiry on memories (expiresAt) where expiresAt is not null;
+
+      create table if not exists memory_keys (
+        chatId text primary key,
+        salt text not null,
+        verifier text not null,
+        failCount integer not null default 0,
+        lockedUntil integer,
+        createdAt integer not null,
+        updatedAt integer not null
+      );
+    `);
+    }
+}
+function visibilityClause() {
+    return "chatId = @chatId and (scope = 'global' or (scope = 'bot' and botId = @botId))";
+}
+function rowToEntry(row) {
+    return {
+        id: row.id,
+        chatId: row.chatId,
+        scope: row.scope,
+        botId: row.botId,
+        category: row.category,
+        title: row.title,
+        content: row.content,
+        tags: parseTags(row.tags),
+        priority: row.priority,
+        duration: row.duration,
+        encrypted: row.encrypted === 1,
+        expiresAt: row.expiresAt,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt
+    };
+}
+function parseTags(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed)
+            ? parsed.filter((item) => typeof item === "string")
+            : [];
+    }
+    catch {
+        return [];
+    }
+}

package/dist/telegram/memory/types.js

@@ -0,0 +1 @@
+export {};

package/dist/telegram/network-retry.js

@@ -0,0 +1,22 @@
+const DEFAULT_RETRY_DELAYS_MS = [250, 750];
+export async function withTelegramNetworkRetry(operation, options = {}) {
+    const delays = options.delaysMs ?? DEFAULT_RETRY_DELAYS_MS;
+    for (let attempt = 0;; attempt += 1) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            if (attempt >= delays.length || !isRetryableTelegramNetworkError(error)) {
+                throw error;
+            }
+            await delay(delays[attempt]);
+        }
+    }
+}
+export function isRetryableTelegramNetworkError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /Network request|fetch failed|ECONNRESET|ECONNREFUSED|ETIMEDOUT|EAI_AGAIN|socket hang up|\b5\d\d\b/i.test(message);
+}
+function delay(ms) {
+    return ms > 0 ? new Promise((resolve) => setTimeout(resolve, ms)) : Promise.resolve();
+}