hyacinth-ai 0.9.6

package/dist/memory/conversation.js

@@ -0,0 +1,107 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export class ConversationStore {
+    maxMessages;
+    conversationFile;
+    constructor(maxMessages = 10000, conversationFile = 'conversation.jsonl') {
+        this.maxMessages = maxMessages;
+        this.conversationFile = conversationFile;
+    }
+    getFilePath(sessionDir) {
+        return path.join(sessionDir, this.conversationFile);
+    }
+    async ensureFile(filePath) {
+        try {
+            await fs.access(filePath);
+        }
+        catch {
+            await fs.writeFile(filePath, '', 'utf-8');
+        }
+    }
+    /**
+     * 追加消息到 conversation.jsonl
+     */
+    async append(sessionDir, message) {
+        const filePath = this.getFilePath(sessionDir);
+        await ensureDir(sessionDir);
+        const line = JSON.stringify(message) + '\n';
+        await fs.appendFile(filePath, line, 'utf-8');
+        // 检查是否需要截断旧消息
+        const count = await this.count(sessionDir);
+        if (count > this.maxMessages) {
+            await this.truncate(sessionDir, count - this.maxMessages);
+        }
+    }
+    /**
+     * 读取全部消息
+     */
+    async readAll(sessionDir) {
+        const filePath = this.getFilePath(sessionDir);
+        return readJsonlFile(filePath);
+    }
+    /**
+     * 读取最后 n 条消息
+     */
+    async readLast(sessionDir, n) {
+        const all = await this.readAll(sessionDir);
+        return all.slice(-n);
+    }
+    /**
+     * 统计消息数量
+     */
+    async count(sessionDir) {
+        const all = await this.readAll(sessionDir);
+        return all.length;
+    }
+    /**
+     * 截断旧消息，保留最新的消息
+     */
+    async truncate(sessionDir, removeCount) {
+        const filePath = this.getFilePath(sessionDir);
+        const lines = await this.readAll(sessionDir);
+        // 保留最新的消息，移除最旧的
+        const kept = lines.slice(removeCount);
+        const content = kept.map((m) => JSON.stringify(m)).join('\n') + '\n';
+        await fs.writeFile(filePath, content, 'utf-8');
+    }
+    /**
+     * 替换全部消息（用于压缩后写回）
+     * 使用 write-to-temp + rename 原子写入模式，防止写入过程中崩溃导致文件损坏
+     */
+    async replace(sessionDir, messages) {
+        const filePath = this.getFilePath(sessionDir);
+        await ensureDir(sessionDir);
+        const content = messages.map((m) => JSON.stringify(m)).join('\n') + '\n';
+        const tmpPath = filePath + '.tmp';
+        await fs.writeFile(tmpPath, content, 'utf-8');
+        // 原子替换：先写临时文件，再 rename
+        // Windows 上 rename 在目标文件存在时会失败，需先 unlink
+        try {
+            await fs.unlink(filePath);
+        }
+        catch {
+            // 原文件不存在，忽略
+        }
+        await fs.rename(tmpPath, filePath);
+    }
+}
+/**
+ * 通用 JSONL 文件读取
+ */
+async function readJsonlFile(filePath) {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const lines = content.split('\n').filter((line) => line.trim().length > 0);
+        return lines.map((line) => JSON.parse(line));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * 确保目录存在
+ */
+async function ensureDir(dir) {
+    await fs.mkdir(dir, { recursive: true });
+}
+//# sourceMappingURL=conversation.js.map

package/dist/memory/events.d.ts

@@ -0,0 +1,42 @@
+export declare class EventStore {
+    private readonly eventsFile;
+    constructor(eventsFile?: string);
+    private getFilePath;
+    private ensureFile;
+    /**
+     * 追加事件到 events.jsonl
+     */
+    append(sessionDir: string, event: Record<string, unknown>): Promise<void>;
+    /**
+     * 读取全部事件
+     */
+    readAll(sessionDir: string): Promise<Record<string, unknown>[]>;
+    /**
+     * 读取最后 n 条事件
+     */
+    readLast(sessionDir: string, n: number): Promise<Record<string, unknown>[]>;
+}
+export interface SessionStartEvent {
+    type: 'session_start';
+    session_id: string;
+    timestamp: string;
+}
+export interface UsageEvent {
+    type: 'usage';
+    input_tokens: number;
+    output_tokens: number;
+    timestamp: string;
+}
+export interface ToolCallEvent {
+    type: 'tool_call';
+    tool_name: string;
+    tool_use_id: string;
+    timestamp: string;
+}
+export interface UserInputEvent {
+    type: 'user_input';
+    content: string;
+    timestamp: string;
+}
+export type SessionEvent = SessionStartEvent | UsageEvent | ToolCallEvent | UserInputEvent;
+//# sourceMappingURL=events.d.ts.map

package/dist/memory/events.js

@@ -0,0 +1,56 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export class EventStore {
+    eventsFile;
+    constructor(eventsFile = 'events.jsonl') {
+        this.eventsFile = eventsFile;
+    }
+    getFilePath(sessionDir) {
+        return path.join(sessionDir, this.eventsFile);
+    }
+    async ensureFile(filePath) {
+        try {
+            await fs.access(filePath);
+        }
+        catch {
+            await fs.writeFile(filePath, '', 'utf-8');
+        }
+    }
+    /**
+     * 追加事件到 events.jsonl
+     */
+    async append(sessionDir, event) {
+        const filePath = this.getFilePath(sessionDir);
+        await this.ensureFile(filePath);
+        const line = JSON.stringify(event) + '\n';
+        await fs.appendFile(filePath, line, 'utf-8');
+    }
+    /**
+     * 读取全部事件
+     */
+    async readAll(sessionDir) {
+        const filePath = this.getFilePath(sessionDir);
+        return readJsonlFile(filePath);
+    }
+    /**
+     * 读取最后 n 条事件
+     */
+    async readLast(sessionDir, n) {
+        const all = await this.readAll(sessionDir);
+        return all.slice(-n);
+    }
+}
+/**
+ * 通用 JSONL 文件读取
+ */
+async function readJsonlFile(filePath) {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const lines = content.split('\n').filter((line) => line.trim().length > 0);
+        return lines.map((line) => JSON.parse(line));
+    }
+    catch {
+        return [];
+    }
+}
+//# sourceMappingURL=events.js.map

package/dist/memory/index.d.ts

@@ -0,0 +1,7 @@
+export { SessionManager } from './session.js';
+export { ConversationStore } from './conversation.js';
+export { EventStore } from './events.js';
+export type { SessionStartEvent, UsageEvent, ToolCallEvent, UserInputEvent, SessionEvent } from './events.js';
+export { StatsManager } from './stats.js';
+export { SummaryStore } from './summary.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/memory/index.js

@@ -0,0 +1,6 @@
+export { SessionManager } from './session.js';
+export { ConversationStore } from './conversation.js';
+export { EventStore } from './events.js';
+export { StatsManager } from './stats.js';
+export { SummaryStore } from './summary.js';
+//# sourceMappingURL=index.js.map

package/dist/memory/memory-store.d.ts

@@ -0,0 +1,11 @@
+export declare class MemoryStore {
+    private filePath;
+    constructor(filePath: string);
+    load(): string;
+    save(content: string): void;
+    append(content: string): void;
+    getFilePath(): string;
+    formatForContext(): string;
+    initializeIfNeeded(): void;
+}
+//# sourceMappingURL=memory-store.d.ts.map

package/dist/memory/memory-store.js

@@ -0,0 +1,51 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const HEADER = '<!-- Memory managed by Agent. Edit directly or use /memory command. -->';
+export class MemoryStore {
+    filePath;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    load() {
+        try {
+            const raw = fs.readFileSync(this.filePath, 'utf-8');
+            return raw.trim();
+        }
+        catch {
+            return '';
+        }
+    }
+    save(content) {
+        const dir = path.dirname(this.filePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(this.filePath, content, 'utf-8');
+    }
+    append(content) {
+        const current = this.load();
+        this.save(current ? `${current}\n\n${content}` : content);
+    }
+    getFilePath() {
+        return this.filePath;
+    }
+    formatForContext() {
+        const content = this.load();
+        if (!content)
+            return '';
+        return `${HEADER}\n\n${content}`;
+    }
+    initializeIfNeeded() {
+        try {
+            fs.accessSync(this.filePath);
+        }
+        catch {
+            const dir = path.dirname(this.filePath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(this.filePath, `${HEADER}\n\n`, 'utf-8');
+        }
+    }
+}
+//# sourceMappingURL=memory-store.js.map

package/dist/memory/session-allowlist.d.ts

@@ -0,0 +1,11 @@
+export interface SessionAllowlistData {
+    allowedTools: string[];
+    allowedCommands: string[];
+}
+export declare function load(sessionDir: string): Promise<SessionAllowlistData>;
+export declare function save(sessionDir: string, data: SessionAllowlistData): Promise<void>;
+export declare function addTool(sessionDir: string, toolName: string): Promise<void>;
+export declare function addCommand(sessionDir: string, command: string): Promise<void>;
+export declare function isToolAllowed(sessionDir: string, toolName: string): Promise<boolean>;
+export declare function isCommandAllowed(sessionDir: string, command: string): Promise<boolean>;
+//# sourceMappingURL=session-allowlist.d.ts.map

package/dist/memory/session-allowlist.js

@@ -0,0 +1,50 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { createLogger } from '../logging/logger.js';
+const logger = createLogger('session-allowlist');
+const EMPTY_DATA = { allowedTools: [], allowedCommands: [] };
+export async function load(sessionDir) {
+    try {
+        const raw = await fs.readFile(path.join(sessionDir, 'allowlist.json'), 'utf-8');
+        const parsed = JSON.parse(raw);
+        return {
+            allowedTools: Array.isArray(parsed.allowedTools) ? parsed.allowedTools : [],
+            allowedCommands: Array.isArray(parsed.allowedCommands) ? parsed.allowedCommands : [],
+        };
+    }
+    catch {
+        return { ...EMPTY_DATA };
+    }
+}
+export async function save(sessionDir, data) {
+    try {
+        await fs.mkdir(sessionDir, { recursive: true });
+        await fs.writeFile(path.join(sessionDir, 'allowlist.json'), JSON.stringify(data, null, 2), 'utf-8');
+    }
+    catch (err) {
+        logger.warn('Failed to save allowlist', { sessionDir, error: String(err) });
+    }
+}
+export async function addTool(sessionDir, toolName) {
+    const data = await load(sessionDir);
+    if (!data.allowedTools.includes(toolName)) {
+        data.allowedTools.push(toolName);
+    }
+    await save(sessionDir, data);
+}
+export async function addCommand(sessionDir, command) {
+    const data = await load(sessionDir);
+    if (!data.allowedCommands.includes(command)) {
+        data.allowedCommands.push(command);
+    }
+    await save(sessionDir, data);
+}
+export async function isToolAllowed(sessionDir, toolName) {
+    const data = await load(sessionDir);
+    return data.allowedTools.includes(toolName);
+}
+export async function isCommandAllowed(sessionDir, command) {
+    const data = await load(sessionDir);
+    return data.allowedCommands.includes(command);
+}
+//# sourceMappingURL=session-allowlist.js.map

package/dist/memory/session.d.ts

@@ -0,0 +1,48 @@
+import type { Session } from '../types.js';
+/**
+ * 生成 Session ID：{channel}_YYYYMMDD-HHMMSS-XXXX
+ */
+export declare function generateSessionId(channel?: string): string;
+export declare class SessionManager {
+    private projectKey;
+    private sessionsRoot;
+    constructor(cwd: string);
+    /**
+     * 创建新 session
+     */
+    create(type?: 'normal' | 'precise', channel?: string): Promise<Session>;
+    /**
+     * 恢复指定 session，不指定则恢复最近的。
+     *
+     * 如果指定了 sessionId 但目录不存在，自动创建（以便渠道传 feishu_group_xxx 等
+     * 可识别 ID 时，首次调用能自动建立 session 存储）。
+     */
+    resume(sessionId?: string): Promise<Session>;
+    /**
+     * 列出所有 session
+     */
+    list(): Promise<Session[]>;
+    /**
+     * 获取最近的 session
+     */
+    getLatest(): Promise<Session | null>;
+    /**
+     * 获取 session 目录路径
+     */
+    getSessionDir(sessionId: string): string;
+    /**
+     * 获取 projectKey
+     */
+    getProjectKey(): string;
+    /**
+     * 获取 sessions 根目录
+     */
+    getSessionsRoot(): string;
+    /**
+     * 清理过期 session，删除 updatedAt 超过 maxAgeDays 的 session 目录
+     * @param maxAgeDays 最大保留天数，默认从环境变量 AGENT_MAX_SESSION_AGE 读取，否则 30 天
+     * @returns 被清理的 session 数量
+     */
+    cleanup(maxAgeDays?: number): Promise<number>;
+}
+//# sourceMappingURL=session.d.ts.map

package/dist/memory/session.js

@@ -0,0 +1,275 @@
+import fs from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import crypto from 'node:crypto';
+import { createLogger } from '../logging/logger.js';
+import { toProjectKey } from '../utils/misc.js';
+const logger = createLogger('session');
+const MAX_SESSION_AGE_DAYS = parseInt(process.env.AGENT_MAX_SESSION_AGE ?? '30', 10);
+/**
+ * 生成 Session ID：{channel}_YYYYMMDD-HHMMSS-XXXX
+ */
+export function generateSessionId(channel) {
+    const now = new Date();
+    const pad = (n, width = 2) => String(n).padStart(width, '0');
+    const datePart = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}`;
+    const timePart = `${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+    const randomPart = crypto.randomBytes(2).toString('hex');
+    const baseId = `${datePart}-${timePart}-${randomPart}`;
+    if (channel && channel.length > 0)
+        return `${channel}_${baseId}`;
+    return baseId;
+}
+/**
+ * 获取 sessions 根目录：~/.agent/sessions/
+ */
+function getSessionsRoot() {
+    return path.join(os.homedir(), '.agent', 'sessions');
+}
+/**
+ * 获取 session 目录：~/.agent/sessions/<sessionId>/
+ */
+function getSessionDir(sessionId) {
+    return path.join(getSessionsRoot(), sessionId);
+}
+/**
+ * 确保目录存在，不存在则递归创建
+ */
+async function ensureDir(dir) {
+    await fs.mkdir(dir, { recursive: true });
+}
+/**
+ * 确保文件存在，不存在则创建空文件
+ */
+async function ensureFile(filePath) {
+    try {
+        await fs.access(filePath);
+    }
+    catch {
+        await fs.writeFile(filePath, '', 'utf-8');
+    }
+}
+export class SessionManager {
+    projectKey;
+    sessionsRoot;
+    constructor(cwd) {
+        this.projectKey = toProjectKey(cwd);
+        this.sessionsRoot = getSessionsRoot();
+    }
+    /**
+     * 创建新 session
+     */
+    async create(type = 'normal', channel) {
+        // 清理过期 session
+        await this.cleanup();
+        const id = generateSessionId(channel);
+        const now = new Date().toISOString();
+        const session = {
+            id,
+            projectKey: this.projectKey,
+            createdAt: now,
+            updatedAt: now,
+            type,
+            channel,
+        };
+        const sessionDir = getSessionDir(id);
+        await ensureDir(sessionDir);
+        // 创建 session 必需的文件
+        await ensureFile(path.join(sessionDir, 'conversation.jsonl'));
+        await ensureFile(path.join(sessionDir, 'events.jsonl'));
+        await ensureFile(path.join(sessionDir, 'stats.json'));
+        // 持久化 session 元信息（type、projectKey、channel 等）
+        await fs.writeFile(path.join(sessionDir, 'meta.json'), JSON.stringify({ type, createdAt: now, projectKey: this.projectKey, channel }), 'utf-8');
+        // 写入 session_start 事件
+        const { EventStore } = await import('./events.js');
+        const eventStore = new EventStore();
+        await eventStore.append(sessionDir, {
+            type: 'session_start',
+            session_id: id,
+            timestamp: now,
+        });
+        // 初始化 stats
+        const { StatsManager } = await import('./stats.js');
+        const statsManager = new StatsManager();
+        await statsManager.init(sessionDir);
+        return session;
+    }
+    /**
+     * 恢复指定 session，不指定则恢复最近的。
+     *
+     * 如果指定了 sessionId 但目录不存在，自动创建（以便渠道传 feishu_group_xxx 等
+     * 可识别 ID 时，首次调用能自动建立 session 存储）。
+     */
+    async resume(sessionId) {
+        if (sessionId) {
+            const sessionDir = getSessionDir(sessionId);
+            // 目录不存在 → 自动创建（首次调用或重启后重建）
+            try {
+                await fs.access(sessionDir);
+            }
+            catch {
+                await ensureDir(sessionDir);
+                await ensureFile(path.join(sessionDir, 'conversation.jsonl'));
+                await ensureFile(path.join(sessionDir, 'events.jsonl'));
+                await ensureFile(path.join(sessionDir, 'stats.json'));
+                const now = new Date().toISOString();
+                // 检测 sessionId 前缀判断渠道来源
+                let channel;
+                if (sessionId.startsWith('feishu_'))
+                    channel = 'feishu';
+                else if (sessionId.startsWith('webui_'))
+                    channel = 'webui';
+                else if (sessionId.startsWith('tui_'))
+                    channel = 'tui';
+                await fs.writeFile(path.join(sessionDir, 'meta.json'), JSON.stringify({ type: 'normal', createdAt: now, channel, projectKey: this.projectKey }), 'utf-8');
+                // 写入 session_start 事件
+                const { EventStore } = await import('./events.js');
+                const eventStore = new EventStore();
+                await eventStore.append(sessionDir, {
+                    type: 'session_start',
+                    session_id: sessionId,
+                    timestamp: now,
+                });
+                // 初始化 stats
+                const { StatsManager } = await import('./stats.js');
+                const statsManager = new StatsManager();
+                await statsManager.init(sessionDir);
+                const session = {
+                    id: sessionId,
+                    projectKey: this.projectKey,
+                    createdAt: now,
+                    updatedAt: now,
+                    type: 'normal',
+                };
+                logger.info('Auto-created session', { sessionId, channel });
+                return session;
+            }
+            // 目录已存在 → 读取 meta.json
+            let type;
+            let createdAt = '';
+            let projectKey = this.projectKey;
+            let channel;
+            try {
+                const metaPath = path.join(sessionDir, 'meta.json');
+                if (existsSync(metaPath)) {
+                    const meta = JSON.parse(await fs.readFile(metaPath, 'utf-8'));
+                    createdAt = meta.createdAt ?? '';
+                    if (meta.type === 'precise' || meta.type === 'normal')
+                        type = meta.type;
+                    if (meta.projectKey)
+                        projectKey = meta.projectKey;
+                    if (typeof meta.channel === 'string')
+                        channel = meta.channel;
+                }
+            }
+            catch { /* meta.json 缺失或损坏，使用默认值 */ }
+            const session = {
+                id: sessionId,
+                projectKey,
+                createdAt,
+                updatedAt: new Date().toISOString(),
+                type,
+                channel,
+            };
+            return session;
+        }
+        // 恢复最近的 session
+        const latest = await this.getLatest();
+        if (!latest) {
+            throw new Error(`No sessions found`);
+        }
+        return latest;
+    }
+    /**
+     * 列出所有 session
+     */
+    async list() {
+        await ensureDir(this.sessionsRoot);
+        const entries = await fs.readdir(this.sessionsRoot, { withFileTypes: true });
+        const sessions = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const sessionDir = path.join(this.sessionsRoot, entry.name);
+            try {
+                const stat = await fs.stat(sessionDir);
+                // 读取 session 元信息
+                let sessionType;
+                let projectKey = '';
+                let channel;
+                try {
+                    const metaRaw = await fs.readFile(path.join(sessionDir, 'meta.json'), 'utf-8');
+                    const meta = JSON.parse(metaRaw);
+                    if (meta.type === 'precise' || meta.type === 'normal')
+                        sessionType = meta.type;
+                    projectKey = meta.projectKey ?? '';
+                    channel = meta.channel;
+                }
+                catch { /* 旧 session 没有 meta.json，默认为 normal */ }
+                sessions.push({
+                    id: entry.name,
+                    projectKey,
+                    createdAt: stat.birthtime.toISOString(),
+                    updatedAt: stat.mtime.toISOString(),
+                    type: sessionType ?? 'normal',
+                    channel,
+                });
+            }
+            catch {
+                // 跳过无法访问的目录
+            }
+        }
+        // 按 createdAt 降序排列
+        sessions.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+        return sessions;
+    }
+    /**
+     * 获取最近的 session
+     */
+    async getLatest() {
+        const sessions = await this.list();
+        return sessions.length > 0 ? sessions[0] : null;
+    }
+    /**
+     * 获取 session 目录路径
+     */
+    getSessionDir(sessionId) {
+        return getSessionDir(sessionId);
+    }
+    /**
+     * 获取 projectKey
+     */
+    getProjectKey() {
+        return this.projectKey;
+    }
+    /**
+     * 获取 sessions 根目录
+     */
+    getSessionsRoot() {
+        return this.sessionsRoot;
+    }
+    /**
+     * 清理过期 session，删除 updatedAt 超过 maxAgeDays 的 session 目录
+     * @param maxAgeDays 最大保留天数，默认从环境变量 AGENT_MAX_SESSION_AGE 读取，否则 30 天
+     * @returns 被清理的 session 数量
+     */
+    async cleanup(maxAgeDays) {
+        const maxAge = maxAgeDays ?? MAX_SESSION_AGE_DAYS;
+        const sessions = await this.list();
+        const now = Date.now();
+        const maxAgeMs = maxAge * 24 * 60 * 60 * 1000;
+        let deletedCount = 0;
+        for (const session of sessions) {
+            const updatedAtTime = new Date(session.updatedAt).getTime();
+            if (now - updatedAtTime > maxAgeMs) {
+                const sessionDir = getSessionDir(session.id);
+                await fs.rm(sessionDir, { recursive: true, force: true });
+                logger.info('Cleaned up expired session', { sessionId: session.id });
+                deletedCount++;
+            }
+        }
+        return deletedCount;
+    }
+}
+//# sourceMappingURL=session.js.map