@yun-zero/claw-memory 0.1.0

package/src/config/llm.ts

@@ -0,0 +1,129 @@
+/**
+ * LLM Configuration Module
+ * Supports OpenAI and Anthropic API keys via environment variables
+ */
+
+export interface LLMConfig {
+  format: 'openai' | 'anthropic' | 'openai-compatible';
+  baseUrl: string;
+  apiKey: string;
+  model: string;
+}
+
+// Default configuration map for LLM providers
+const LLM_DEFAULTS: Record<string, { baseUrl: string; model: string }> = {
+  anthropic: { baseUrl: 'https://api.anthropic.com', model: 'claude-3-haiku-20240307' },
+  openai: { baseUrl: 'https://api.openai.com/v1', model: 'gpt-4o-mini' },
+  'openai-compatible': { baseUrl: 'https://api.openai.com/v1', model: 'gpt-4o-mini' }
+};
+
+export function getLLMConfig(): LLMConfig {
+  const format = (process.env.LLM_FORMAT as LLMConfig['format']) || 'openai';
+  const baseUrl = process.env.LLM_BASE_URL || getDefaultBaseUrl(format);
+  const apiKey = process.env.LLM_API_KEY || process.env.OPENAI_API_KEY || '';
+  const model = process.env.LLM_MODEL || getDefaultModel(format);
+
+  if (!apiKey) {
+    throw new Error('No LLM API key configured. Set LLM_API_KEY environment variable.');
+  }
+
+  return { format, baseUrl, apiKey, model };
+}
+
+function getDefaultBaseUrl(format: LLMConfig['format']): string {
+  return LLM_DEFAULTS[format]?.baseUrl ?? LLM_DEFAULTS.openai.baseUrl;
+}
+
+function getDefaultModel(format: LLMConfig['format']): string {
+  return LLM_DEFAULTS[format]?.model ?? LLM_DEFAULTS.openai.model;
+}
+
+export async function generateSummaryWithLLM(
+  report: string,
+  config?: LLMConfig
+): Promise<string> {
+  const llmConfig = config || getLLMConfig();
+
+  const systemPrompt = `你是一个智能助手，负责根据用户记忆数据生成周报总结。
+请根据提供的统计数据，从多个维度分析用户的记忆内容，并生成一段简洁、有价值的自然语言总结。
+总结应该：
+1. 概括本周的记忆活动概况
+2. 指出用户最关注的话题和标签
+3. 识别重要的记忆内容
+4. 给出有洞察力的观察
+
+请用中文输出总结，保持简洁但有信息量。`;
+
+  if (llmConfig.format === 'anthropic') {
+    return generateWithAnthropic(systemPrompt, report, llmConfig);
+  } else {
+    // openai 或 openai-compatible 都使用 generateWithOpenAI
+    const prefix = llmConfig.format === 'openai-compatible' ? 'OpenAI Compatible' : 'OpenAI';
+    return generateWithOpenAI(systemPrompt, report, llmConfig, prefix);
+  }
+}
+
+async function generateWithAnthropic(
+  systemPrompt: string,
+  userPrompt: string,
+  config: LLMConfig
+): Promise<string> {
+  // Ensure v1 path for Anthropic API
+  const baseUrl = config.baseUrl.includes('/anthropic') && !config.baseUrl.includes('/v1')
+    ? `${config.baseUrl}/v1`
+    : config.baseUrl;
+  const response = await fetch(`${baseUrl}/messages`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'x-api-key': config.apiKey,
+      'anthropic-version': '2023-06-01'
+    },
+    body: JSON.stringify({
+      model: config.model,
+      max_tokens: 1024,
+      system: systemPrompt,
+      messages: [{ role: 'user', content: userPrompt }]
+    })
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Anthropic API error: ${error}`);
+  }
+
+  const data = await response.json() as { content: { text: string }[] };
+  return data.content[0]?.text || '总结生成失败';
+}
+
+async function generateWithOpenAI(
+  systemPrompt: string,
+  userPrompt: string,
+  config: LLMConfig,
+  errorPrefix: string = 'OpenAI'
+): Promise<string> {
+  const response = await fetch(`${config.baseUrl}/chat/completions`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${config.apiKey}`
+    },
+    body: JSON.stringify({
+      model: config.model,
+      max_tokens: 1024,
+      messages: [
+        { role: 'system', content: systemPrompt },
+        { role: 'user', content: userPrompt }
+      ]
+    })
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`${errorPrefix} API error: ${error}`);
+  }
+
+  const data = await response.json() as { choices: { message: { content: string } }[] };
+  return data.choices[0]?.message?.content || '总结生成失败';
+}
+

package/src/config/plugin.ts

@@ -0,0 +1,47 @@
+export interface PluginConfig {
+  enabled: boolean;
+  autoSave: boolean;
+  saveMode: 'qa' | 'full';
+  dataDir: string;
+  scheduler: {
+    enabled: boolean;
+    deduplicateTime: string;
+    dailyTime: string;
+    weeklyTime: string;
+    monthlyTime: string;
+  };
+}
+
+export function getConfig(config?: any): PluginConfig {
+  const defaultConfig: PluginConfig = {
+    enabled: true,
+    autoSave: true,
+    saveMode: 'qa',
+    dataDir: '~/.openclaw/claw-memory',
+    scheduler: {
+      enabled: true,
+      deduplicateTime: '01:00',
+      dailyTime: '02:00',
+      weeklyTime: '03:00',
+      monthlyTime: '04:00'
+    }
+  };
+
+  if (!config) {
+    return defaultConfig;
+  }
+
+  return {
+    enabled: config.enabled ?? defaultConfig.enabled,
+    autoSave: config.autoSave ?? defaultConfig.autoSave,
+    saveMode: config.saveMode ?? defaultConfig.saveMode,
+    dataDir: config.dataDir ?? defaultConfig.dataDir,
+    scheduler: {
+      enabled: config.scheduler?.enabled ?? defaultConfig.scheduler.enabled,
+      deduplicateTime: config.scheduler?.deduplicateTime ?? defaultConfig.scheduler.deduplicateTime,
+      dailyTime: config.scheduler?.dailyTime ?? defaultConfig.scheduler.dailyTime,
+      weeklyTime: config.scheduler?.weeklyTime ?? defaultConfig.scheduler.weeklyTime,
+      monthlyTime: config.scheduler?.monthlyTime ?? defaultConfig.scheduler.monthlyTime
+    }
+  };
+}

package/src/db/entityRepository.ts

@@ -0,0 +1,80 @@
+import Database from 'better-sqlite3';
+import { v4 as uuidv4 } from 'uuid';
+import type { Entity } from '../types.js';
+
+export interface CreateEntityInput {
+  name: string;
+  type: Entity['type'];
+  parentId?: string | null;
+  level?: number;
+  metadata?: Record<string, unknown>;
+}
+
+export class EntityRepository {
+  private db: Database.Database;
+
+  constructor(db: Database.Database) {
+    this.db = db;
+  }
+
+  create(input: CreateEntityInput): Entity {
+    const id = uuidv4();
+    const now = new Date();
+
+    this.db.prepare(`
+      INSERT INTO entities (id, name, type, parent_id, level, metadata, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      id,
+      input.name,
+      input.type,
+      input.parentId || null,
+      input.level ?? 0,
+      input.metadata ? JSON.stringify(input.metadata) : null,
+      now.toISOString()
+    );
+
+    return this.findById(id)!;
+  }
+
+  findById(id: string): Entity | null {
+    const row = this.db.prepare('SELECT * FROM entities WHERE id = ?').get(id) as any;
+    if (!row) return null;
+    return this.mapRowToEntity(row);
+  }
+
+  findByName(name: string): Entity | null {
+    const row = this.db.prepare('SELECT * FROM entities WHERE name = ?').get(name) as any;
+    if (!row) return null;
+    return this.mapRowToEntity(row);
+  }
+
+  findByType(type: Entity['type']): Entity[] {
+    const rows = this.db.prepare('SELECT * FROM entities WHERE type = ?').all(type) as any[];
+    return rows.map(row => this.mapRowToEntity(row));
+  }
+
+  findChildren(parentId: string): Entity[] {
+    const rows = this.db.prepare('SELECT * FROM entities WHERE parent_id = ?').all(parentId) as any[];
+    return rows.map(row => this.mapRowToEntity(row));
+  }
+
+  findOrCreate(input: CreateEntityInput): Entity {
+    const existing = this.findByName(input.name);
+    if (existing) return existing;
+    return this.create(input);
+  }
+
+  private mapRowToEntity(row: any): Entity {
+    return {
+      id: row.id,
+      name: row.name,
+      type: row.type as Entity['type'],
+      parentId: row.parent_id,
+      level: row.level,
+      embedding: row.embedding,
+      metadata: row.metadata ? JSON.parse(row.metadata) : null,
+      createdAt: new Date(row.created_at)
+    };
+  }
+}

package/src/db/repository.ts

@@ -0,0 +1,106 @@
+import Database from 'better-sqlite3';
+import { v4 as uuidv4 } from 'uuid';
+import type { Memory, IntegratedSummary } from '../types.js';
+
+export interface CreateMemoryInput {
+  contentPath: string;
+  summary?: string;
+  integratedSummary?: IntegratedSummary;
+  importance?: number;
+  tokenCount?: number;
+}
+
+export class MemoryRepository {
+  private db: Database.Database;
+
+  constructor(db: Database.Database) {
+    this.db = db;
+  }
+
+  create(input: CreateMemoryInput): Memory {
+    const id = uuidv4();
+    const now = new Date();
+
+    this.db.prepare(`
+      INSERT INTO memories (id, content_path, summary, integrated_summary, importance, token_count, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      id,
+      input.contentPath,
+      input.summary || null,
+      input.integratedSummary ? JSON.stringify(input.integratedSummary) : null,
+      input.importance ?? 0.5,
+      input.tokenCount ?? 0,
+      now.toISOString(),
+      now.toISOString()
+    );
+
+    return this.findById(id)!;
+  }
+
+  findById(id: string): Memory | null {
+    const row = this.db.prepare(`
+      SELECT * FROM memories WHERE id = ?
+    `).get(id) as any;
+
+    if (!row) return null;
+    return this.mapRowToMemory(row);
+  }
+
+  findAll(limit?: number, offset?: number): Memory[] {
+    let query = 'SELECT * FROM memories ORDER BY created_at DESC';
+    if (limit) {
+      query += ` LIMIT ${limit}`;
+      if (offset) query += ` OFFSET ${offset}`;
+    }
+
+    const rows = this.db.prepare(query).all() as any[];
+    return rows.map(row => this.mapRowToMemory(row));
+  }
+
+  delete(id: string): boolean {
+    const result = this.db.prepare('DELETE FROM memories WHERE id = ?').run(id);
+    return result.changes > 0;
+  }
+
+  updateLastAccessed(id: string): void {
+    this.db.prepare(`
+      UPDATE memories SET last_accessed_at = ?, access_count = access_count + 1 WHERE id = ?
+    `).run(new Date().toISOString(), id);
+  }
+
+  private mapRowToMemory(row: any): Memory {
+    return {
+      id: row.id,
+      contentPath: row.content_path,
+      summary: row.summary,
+      integratedSummary: row.integrated_summary ? this.safeParseJSON(row.integrated_summary) : null,
+      createdAt: new Date(row.created_at),
+      updatedAt: new Date(row.updated_at),
+      tokenCount: row.token_count,
+      importance: row.importance,
+      accessCount: row.access_count,
+      lastAccessedAt: row.last_accessed_at ? new Date(row.last_accessed_at) : null,
+      isArchived: Boolean(row.is_archived),
+      isDuplicate: Boolean(row.is_duplicate),
+      duplicateOf: row.duplicate_of
+    };
+  }
+
+  private safeParseJSON(json: string): IntegratedSummary | null {
+    try {
+      return JSON.parse(json);
+    } catch {
+      return null;
+    }
+  }
+
+  getLatestIntegratedSummary(): IntegratedSummary | null {
+    const row = this.db.prepare(`
+      SELECT integrated_summary FROM memories ORDER BY created_at DESC LIMIT 1
+    `).get() as { integrated_summary: string } | undefined;
+
+    if (!row || !row.integrated_summary) return null;
+    return this.safeParseJSON(row.integrated_summary);
+  }
+}

package/src/db/schema.ts

@@ -0,0 +1,121 @@
+import Database from 'better-sqlite3';
+
+export function initializeDatabase(db: Database.Database): void {
+  // 1. 记忆表
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS memories (
+      id TEXT PRIMARY KEY,
+      content_path TEXT NOT NULL,
+      summary TEXT,
+      integrated_summary JSON,
+      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+      updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+      token_count INTEGER DEFAULT 0,
+      importance REAL DEFAULT 0.5,
+      access_count INTEGER DEFAULT 0,
+      last_accessed_at TIMESTAMP,
+      is_archived BOOLEAN DEFAULT FALSE,
+      is_duplicate BOOLEAN DEFAULT FALSE,
+      duplicate_of TEXT
+    )
+  `);
+
+  // 2. 实体表
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS entities (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      type TEXT NOT NULL,
+      parent_id TEXT,
+      level INTEGER DEFAULT 0,
+      embedding BLOB,
+      metadata JSON,
+      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+      FOREIGN KEY (parent_id) REFERENCES entities(id)
+    )
+  `);
+
+  // 3. 记忆-实体关联表
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS memory_entities (
+      memory_id TEXT NOT NULL,
+      entity_id TEXT NOT NULL,
+      relevance REAL DEFAULT 1.0,
+      source TEXT DEFAULT 'auto',
+      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+      PRIMARY KEY (memory_id, entity_id),
+      FOREIGN KEY (memory_id) REFERENCES memories(id),
+      FOREIGN KEY (entity_id) REFERENCES entities(id)
+    )
+  `);
+
+  // 4. 实体关系图
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS entity_relations (
+      id TEXT PRIMARY KEY,
+      source_id TEXT NOT NULL,
+      target_id TEXT NOT NULL,
+      relation_type TEXT NOT NULL,
+      weight REAL DEFAULT 1.0,
+      evidence_count INTEGER DEFAULT 1,
+      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+      FOREIGN KEY (source_id) REFERENCES entities(id),
+      FOREIGN KEY (target_id) REFERENCES entities(id),
+      UNIQUE(source_id, target_id, relation_type)
+    )
+  `);
+
+  // 5. 时间桶
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS time_buckets (
+      date TEXT PRIMARY KEY,
+      memory_count INTEGER DEFAULT 0,
+      summary TEXT,
+      summary_generated_at TIMESTAMP,
+      key_topics JSON,
+      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+
+  // 6. 待办事项
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS todos (
+      id TEXT PRIMARY KEY,
+      content TEXT NOT NULL,
+      period TEXT NOT NULL,
+      period_date TEXT,
+      created_at TEXT NOT NULL,
+      completed_at TEXT,
+      memory_id TEXT
+    )
+  `);
+
+  // 创建索引
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_memories_created ON memories(created_at);
+    CREATE INDEX IF NOT EXISTS idx_memories_importance ON memories(importance);
+    CREATE INDEX IF NOT EXISTS idx_entities_name ON entities(name);
+    CREATE INDEX IF NOT EXISTS idx_entities_type ON entities(type);
+    CREATE INDEX IF NOT EXISTS idx_entities_parent ON entities(parent_id);
+    CREATE INDEX IF NOT EXISTS idx_memory_entities_entity ON memory_entities(entity_id);
+    CREATE INDEX IF NOT EXISTS idx_entity_relations_source ON entity_relations(source_id);
+    CREATE INDEX IF NOT EXISTS idx_entity_relations_target ON entity_relations(target_id);
+  `);
+}
+
+let dbInstance: Database.Database | null = null;
+
+export function resetDbInstance(): void {
+  if (dbInstance) {
+    dbInstance.close();
+    dbInstance = null;
+  }
+}
+
+export function getDatabase(dbPath: string = './memories/memory.db'): Database.Database {
+  if (!dbInstance) {
+    dbInstance = new Database(dbPath);
+    initializeDatabase(dbInstance);
+  }
+  return dbInstance;
+}

package/src/db/todoRepository.ts

@@ -0,0 +1,76 @@
+import Database from 'better-sqlite3';
+import { v4 as uuidv4 } from 'uuid';
+
+export interface Todo {
+  id: string;
+  content: string;
+  period: 'day' | 'week' | 'month';
+  periodDate: string;
+  createdAt: Date;
+  completedAt: Date | null;
+  memoryId: string | null;
+}
+
+export interface CreateTodoInput {
+  content: string;
+  period: 'day' | 'week' | 'month';
+  periodDate: string;
+  memoryId?: string;
+}
+
+export class TodoRepository {
+  constructor(private db: Database.Database) {}
+
+  create(input: CreateTodoInput): Todo {
+    const id = uuidv4();
+    const createdAt = new Date().toISOString();
+
+    this.db.prepare(`
+      INSERT INTO todos (id, content, period, period_date, created_at, memory_id)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(id, input.content, input.period, input.periodDate, createdAt, input.memoryId || null);
+
+    return {
+      id,
+      content: input.content,
+      period: input.period,
+      periodDate: input.periodDate,
+      createdAt: new Date(createdAt),
+      completedAt: null,
+      memoryId: input.memoryId || null
+    };
+  }
+
+  findByPeriod(period: string, periodDate: string, includeCompleted = false): Todo[] {
+    const sql = includeCompleted
+      ? `SELECT * FROM todos WHERE period = ? AND period_date = ? ORDER BY created_at DESC`
+      : `SELECT * FROM todos WHERE period = ? AND period_date = ? AND completed_at IS NULL ORDER BY created_at DESC`;
+
+    const rows = this.db.prepare(sql).all(period, periodDate) as any[];
+    return rows.map(this.mapRowToTodo);
+  }
+
+  findById(id: string): Todo | null {
+    const row = this.db.prepare('SELECT * FROM todos WHERE id = ?').get(id) as any;
+    if (!row) return null;
+    return this.mapRowToTodo(row);
+  }
+
+  markCompleted(id: string): void {
+    this.db.prepare(`
+      UPDATE todos SET completed_at = ? WHERE id = ?
+    `).run(new Date().toISOString(), id);
+  }
+
+  private mapRowToTodo(row: any): Todo {
+    return {
+      id: row.id,
+      content: row.content,
+      period: row.period,
+      periodDate: row.period_date,
+      createdAt: new Date(row.created_at),
+      completedAt: row.completed_at ? new Date(row.completed_at) : null,
+      memoryId: row.memory_id
+    };
+  }
+}

package/src/hooks/bootstrap.ts

@@ -0,0 +1,36 @@
+import type { Database } from 'better-sqlite3';
+
+export async function handleAgentBootstrap(
+  db: Database
+): Promise<string> {
+  // 获取本周记忆摘要
+  const today = new Date();
+  const weekStart = new Date(today);
+  weekStart.setDate(today.getDate() - today.getDay());
+  const weekStartStr = weekStart.toISOString().split('T')[0];
+
+  const weekMemories = db.prepare(`
+    SELECT summary, importance
+    FROM memories
+    WHERE date(created_at) >= date(?)
+    ORDER BY importance DESC
+    LIMIT 10
+  `).all(weekStartStr) as { summary: string; importance: number }[];
+
+  if (weekMemories.length === 0) {
+    return '';
+  }
+
+  // 构建摘要文本
+  const lines = ['## 记忆摘要\n'];
+  lines.push(`本周共有 ${weekMemories.length} 条记忆记录。\n`);
+  lines.push('### 重点内容:\n');
+
+  for (const m of weekMemories.slice(0, 5)) {
+    if (m.summary) {
+      lines.push(`- ${m.summary}`);
+    }
+  }
+
+  return lines.join('\n');
+}

package/src/hooks/message.ts

@@ -0,0 +1,84 @@
+import type { Database } from 'better-sqlite3';
+import { v4 as uuidv4 } from 'uuid';
+import * as path from 'path';
+import * as fs from 'fs';
+import { homedir } from 'os';
+
+interface MessageEvent {
+  message: {
+    role: 'user' | 'assistant';
+    content: string;
+  };
+  session: {
+    id: string;
+    key: string;
+  };
+  conversation?: Array<{
+    role: 'user' | 'assistant';
+    content: string;
+  }>;
+}
+
+export async function handleMessageSent(
+  event: MessageEvent,
+  db: Database,
+  dataDir: string
+): Promise<void> {
+  // 只处理 assistant 消息（AI 回复后保存）
+  if (event.message.role !== 'assistant') {
+    return;
+  }
+
+  // 从 conversation 中获取最后一条 user 消息
+  let userMessage = '';
+  if (event.conversation && event.conversation.length > 0) {
+    // 找到最后一个 user 消息
+    for (let i = event.conversation.length - 1; i >= 0; i--) {
+      if (event.conversation[i].role === 'user') {
+        userMessage = event.conversation[i].content;
+        break;
+      }
+    }
+  }
+
+  const assistantMessage = event.message.content;
+
+  if (!userMessage || !assistantMessage) {
+    console.log('[ClawMemory] Skipping - no valid Q&A pair');
+    return;
+  }
+
+  // 构建 Q&A
+  const qaContent = `Q: ${userMessage}\n\nA: ${assistantMessage}`;
+
+  // 解析 dataDir 中的 ~
+  const resolvedDataDir = dataDir.replace(/^~/, homedir());
+
+  // 确保目录存在
+  if (!fs.existsSync(resolvedDataDir)) {
+    fs.mkdirSync(resolvedDataDir, { recursive: true });
+  }
+
+  const memoriesDir = path.join(resolvedDataDir, 'memories');
+  if (!fs.existsSync(memoriesDir)) {
+    fs.mkdirSync(memoriesDir, { recursive: true });
+  }
+
+  // 保存记忆
+  const memoryId = uuidv4();
+  const contentPath = path.join(memoriesDir, `${memoryId}.md`);
+
+  // 写入文件
+  fs.writeFileSync(contentPath, qaContent, 'utf-8');
+
+  // 提取摘要（取前200字符）
+  const summary = assistantMessage.substring(0, 200);
+
+  // 插入数据库
+  db.prepare(`
+    INSERT INTO memories (id, content_path, summary, created_at)
+    VALUES (?, ?, ?, datetime('now'))
+  `).run(memoryId, contentPath, summary);
+
+  console.log(`[ClawMemory] Saved memory: ${memoryId}`);
+}