@gloablehive/celphone-wechat-plugin 1.0.0

package/dist/src/cache/index.js

@@ -0,0 +1,16 @@
+/**
+ * Cache Module Exports
+ *
+ * All cache-related modules for WeChat Channel Plugin
+ */
+export * from './types.js';
+export * from './writer.js';
+export * from './indexer.js';
+export * from './extractor.js';
+export * from './compactor.js';
+export * from './syncer.js';
+export * from './saas-connector.js';
+export * from './message-queue.js';
+export * from './manager.js';
+// Main export
+export { createCacheManager, CacheManager } from './manager.js';

package/dist/src/cache/indexer.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Cache Indexer - MEMORY.md index management
+ *
+ * Aligned with Claude Code:
+ * - MEMORY.md is index, not memory itself
+ * - Max 200 lines, 25KB
+ * - Multi-level: global → account → session
+ */
+import { IndexEntry, WeChatAccount } from './types.js';
+/**
+ * Build global index (across all accounts)
+ */
+export declare function buildGlobalIndex(basePath: string, accounts: WeChatAccount[]): Promise<string>;
+/**
+ * Write global index
+ */
+export declare function writeGlobalIndex(basePath: string, content: string): Promise<void>;
+/**
+ * Build account-level index
+ */
+export declare function buildAccountIndex(basePath: string, account: WeChatAccount, friends: IndexEntry[], chatrooms: IndexEntry[], profiles: IndexEntry[]): Promise<string>;
+/**
+ * Write account index
+ */
+export declare function writeAccountIndex(basePath: string, accountId: string, content: string): Promise<void>;
+/**
+ * Scan account directory for entries
+ */
+export declare function scanAccountEntries(basePath: string, accountId: string): Promise<{
+    friends: IndexEntry[];
+    chatrooms: IndexEntry[];
+    profiles: IndexEntry[];
+}>;
+/**
+ * Rebuild all indexes for an account
+ */
+export declare function rebuildAccountIndex(basePath: string, account: WeChatAccount): Promise<void>;
+/**
+ * Rebuild all indexes for all accounts
+ */
+export declare function rebuildAllIndexes(basePath: string, accounts: WeChatAccount[]): Promise<void>;

package/dist/src/cache/indexer.js

@@ -0,0 +1,262 @@
+/**
+ * Cache Indexer - MEMORY.md index management
+ *
+ * Aligned with Claude Code:
+ * - MEMORY.md is index, not memory itself
+ * - Max 200 lines, 25KB
+ * - Multi-level: global → account → session
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { getAccountCachePath, } from './types.js';
+// ========== Constants ==========
+const MAX_INDEX_LINES = 200;
+const MAX_INDEX_BYTES = 25000;
+const ENCODING = 'utf-8';
+// ========== Global Index ==========
+/**
+ * Build global index (across all accounts)
+ */
+export async function buildGlobalIndex(basePath, accounts) {
+    const lines = [
+        '# WeChat Cache Index - All Accounts',
+        '',
+        '## 账号',
+    ];
+    for (const account of accounts) {
+        const accountIndexPath = path.join(getAccountCachePath(basePath, account.accountId), 'MEMORY.md');
+        lines.push(`- [${account.nickName}](accounts/${account.accountId}/MEMORY.md) - ${account.wechatId}`);
+    }
+    lines.push('');
+    lines.push('---');
+    lines.push('');
+    lines.push('*Last updated: ' + new Date().toISOString() + '*');
+    const content = lines.join('\n');
+    return truncateIfNeeded(content);
+}
+/**
+ * Write global index
+ */
+export async function writeGlobalIndex(basePath, content) {
+    const indexPath = path.join(basePath, 'MEMORY.md');
+    await fs.writeFile(indexPath, content, ENCODING);
+}
+// ========== Account Index ==========
+/**
+ * Build account-level index
+ */
+export async function buildAccountIndex(basePath, account, friends, chatrooms, profiles) {
+    const lines = [
+        `# WeChat Cache Index - ${account.nickName}`,
+        '',
+        account.enabled ? '✅ 在线' : '❌ 离线',
+        '',
+    ];
+    // Recent conversations
+    lines.push('## 最近对话');
+    const recentFriends = friends.slice(0, 5);
+    const recentChatrooms = chatrooms.slice(0, 5);
+    for (const friend of recentFriends) {
+        lines.push(`- [${friend.name}](friends/${friend.path}) — ${friend.messageCount}条消息`);
+    }
+    for (const chatroom of recentChatrooms) {
+        lines.push(`- [${chatroom.name}](chatrooms/${chatroom.path}) — ${chatroom.messageCount}条消息`);
+    }
+    lines.push('');
+    // User profiles
+    lines.push('## 用户画像');
+    for (const profile of profiles.slice(0, 10)) {
+        const tags = profile.description.split(', ').slice(0, 3).join(', ');
+        lines.push(`- [${profile.name}](profiles/${profile.path}) — ${tags}`);
+    }
+    lines.push('');
+    lines.push('---');
+    lines.push('');
+    // All friends
+    lines.push(`## 全部好友 (${friends.length})`);
+    for (const friend of friends.slice(0, 50)) {
+        lines.push(`- [${friend.name}](friends/${friend.path})`);
+    }
+    if (friends.length > 50) {
+        lines.push(`- ... 还有 ${friends.length - 50} 个`);
+    }
+    lines.push('');
+    // All chatrooms
+    lines.push(`## 全部群聊 (${chatrooms.length})`);
+    for (const chatroom of chatrooms.slice(0, 50)) {
+        lines.push(`- [${chatroom.name}](chatrooms/${chatroom.path})`);
+    }
+    if (chatrooms.length > 50) {
+        lines.push(`- ... 还有 ${chatrooms.length - 50} 个`);
+    }
+    lines.push('');
+    lines.push('---');
+    lines.push('');
+    lines.push(`*最后更新: ${new Date().toISOString()}*`);
+    const content = lines.join('\n');
+    return truncateIfNeeded(content);
+}
+/**
+ * Write account index
+ */
+export async function writeAccountIndex(basePath, accountId, content) {
+    const indexPath = path.join(getAccountCachePath(basePath, accountId), 'MEMORY.md');
+    await fs.mkdir(path.dirname(indexPath), { recursive: true });
+    await fs.writeFile(indexPath, content, ENCODING);
+}
+// ========== Scan Functions ==========
+/**
+ * Scan account directory for entries
+ */
+export async function scanAccountEntries(basePath, accountId) {
+    const accountPath = getAccountCachePath(basePath, accountId);
+    const friends = await scanDirectory(path.join(accountPath, 'friends'), 'friend');
+    const chatrooms = await scanDirectory(path.join(accountPath, 'chatrooms'), 'chatroom');
+    const profiles = await scanDirectory(path.join(accountPath, 'profiles'), 'profile');
+    return { friends, chatrooms, profiles };
+}
+/**
+ * Scan directory for entries
+ */
+async function scanDirectory(dirPath, type) {
+    const entries = [];
+    try {
+        const items = await fs.readdir(dirPath, { withFileTypes: true });
+        for (const item of items) {
+            if (!item.isDirectory() && type !== 'profile')
+                continue;
+            if (type === 'profile' && !item.name.endsWith('.md'))
+                continue;
+            const itemPath = type === 'profile'
+                ? item.name
+                : item.name;
+            // Try to read frontmatter
+            const fullPath = path.join(dirPath, item.name, 'memory');
+            try {
+                const files = await fs.readdir(fullPath);
+                const latestFile = files
+                    .filter(f => f.endsWith('.md'))
+                    .sort()
+                    .pop();
+                if (latestFile) {
+                    const content = await fs.readFile(path.join(fullPath, latestFile), ENCODING);
+                    const fm = parseFrontmatter(content);
+                    entries.push({
+                        path: itemPath,
+                        name: fm?.name || item.name,
+                        description: fm?.description || '',
+                        type: 'conversation',
+                        lastContact: fm?.lastContact,
+                        messageCount: fm?.messageCount || 0,
+                    });
+                }
+            }
+            catch {
+                // If no memory dir, try profile file
+                if (type === 'profile') {
+                    try {
+                        const content = await fs.readFile(path.join(dirPath, item.name), ENCODING);
+                        const fm = parseFrontmatter(content);
+                        entries.push({
+                            path: item.name,
+                            name: fm?.name || item.name.replace('.md', ''),
+                            description: fm?.description || '',
+                            type: 'user',
+                            lastContact: fm?.lastContact,
+                        });
+                    }
+                    catch {
+                        // Skip
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Directory doesn't exist
+    }
+    // Sort by lastContact
+    entries.sort((a, b) => {
+        if (!a.lastContact)
+            return 1;
+        if (!b.lastContact)
+            return -1;
+        return new Date(b.lastContact).getTime() - new Date(a.lastContact).getTime();
+    });
+    return entries;
+}
+/**
+ * Parse frontmatter from markdown content
+ */
+function parseFrontmatter(content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!match)
+        return null;
+    const fm = {};
+    const lines = match[1].split('\n');
+    for (const line of lines) {
+        const colonIdx = line.indexOf(':');
+        if (colonIdx === -1)
+            continue;
+        const key = line.slice(0, colonIdx).trim();
+        let value = line.slice(colonIdx + 1).trim();
+        // Parse value type
+        if (value === 'true')
+            value = true;
+        else if (value === 'false')
+            value = false;
+        else if (/^\d+$/.test(value))
+            value = parseInt(value, 10);
+        else if (value.startsWith('"'))
+            value = value.replace(/"/g, '');
+        fm[key] = value;
+    }
+    return fm;
+}
+// ========== Utility Functions ==========
+/**
+ * Truncate content if exceeds limits (aligned with Claude Code)
+ */
+function truncateIfNeeded(content) {
+    const lines = content.split('\n');
+    if (lines.length > MAX_INDEX_LINES) {
+        const truncated = lines.slice(0, MAX_INDEX_LINES);
+        truncated.push('');
+        truncated.push('---');
+        truncated.push('');
+        truncated.push('*Index truncated. Showing first 200 entries.*');
+        return truncated.join('\n');
+    }
+    if (content.length > MAX_INDEX_BYTES) {
+        let truncated = '';
+        for (const line of lines) {
+            if ((truncated + line + '\n').length > MAX_INDEX_BYTES) {
+                break;
+            }
+            truncated += line + '\n';
+        }
+        truncated += '\n---\n\n*Index truncated. Showing first 25KB.*';
+        return truncated;
+    }
+    return content;
+}
+/**
+ * Rebuild all indexes for an account
+ */
+export async function rebuildAccountIndex(basePath, account) {
+    const { friends, chatrooms, profiles } = await scanAccountEntries(basePath, account.accountId);
+    const content = await buildAccountIndex(basePath, account, friends, chatrooms, profiles);
+    await writeAccountIndex(basePath, account.accountId, content);
+}
+/**
+ * Rebuild all indexes for all accounts
+ */
+export async function rebuildAllIndexes(basePath, accounts) {
+    // Rebuild each account index
+    for (const account of accounts) {
+        await rebuildAccountIndex(basePath, account);
+    }
+    // Rebuild global index
+    const globalContent = await buildGlobalIndex(basePath, accounts);
+    await writeGlobalIndex(basePath, globalContent);
+}

package/dist/src/cache/manager.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Cache Manager - Main cache management
+ *
+ * Ties together all cache modules:
+ * - Writer (file operations)
+ * - Indexer (MEMORY.md)
+ * - Extractor (AI summary)
+ * - Compactor (4-layer compression)
+ * - Syncer (cloud sync)
+ * - SAAS Connector (offline fallback)
+ * - Message Queue (offline retry)
+ */
+import type { WeChatAccount, WeChatMessage, UserProfile, SyncConfig, SAASConfig, ExtractorConfig, CompactConfig } from './types.js';
+import * as writer from './writer.js';
+import * as indexer from './indexer.js';
+import * as extractor from './extractor.js';
+import * as compactor from './compactor.js';
+import { CloudSyncer } from './syncer.js';
+import { SAASConnector } from './saas-connector.js';
+import { MessageQueue } from './message-queue.js';
+/**
+ * Cache Manager Options
+ */
+export interface CacheManagerOptions {
+    basePath: string;
+    accounts: WeChatAccount[];
+    syncConfig?: Partial<SyncConfig>;
+    saasConfig?: Partial<SAASConfig>;
+    extractorConfig?: Partial<ExtractorConfig>;
+    compactConfig?: Partial<CompactConfig>;
+}
+/**
+ * Cache Manager class
+ */
+export declare class CacheManager {
+    private basePath;
+    private accounts;
+    private compactConfig;
+    private extractorConfig;
+    private syncer;
+    private saasConnector;
+    private messageQueue;
+    private messageCounts;
+    private lastExtractionCounts;
+    constructor(options: CacheManagerOptions);
+    /**
+     * Initialize cache manager
+     */
+    init(): Promise<void>;
+    /**
+     * Handle incoming message
+     */
+    onMessage(message: WeChatMessage): Promise<void>;
+    /**
+     * Check if extraction should run
+     */
+    private checkExtraction;
+    /**
+     * Check if compaction should run
+     */
+    private checkCompaction;
+    /**
+     * Get user profile (with offline fallback)
+     */
+    getProfile(accountId: string, wechatId: string): Promise<UserProfile | null>;
+    /**
+     * Update user profile
+     */
+    updateProfile(accountId: string, wechatId: string, updates: Partial<UserProfile>): Promise<void>;
+    /**
+     * Write session memory
+     */
+    writeSessionMemory(accountId: string, conversationId: string, session: any): Promise<void>;
+    /**
+     * Read session memory
+     */
+    readSessionMemory(accountId: string, conversationId: string): Promise<any | null>;
+    /**
+     * Get SAAS connection status
+     */
+    getConnectionStatus(): import("./types.js").ConnectionStatus;
+    /**
+     * Check if SAAS is online
+     */
+    isSAASOnline(): boolean;
+    /**
+     * Get offline message
+     */
+    getOfflineMessage(): string;
+    /**
+     * Run sync
+     */
+    runSync(): Promise<void>;
+    /**
+     * Process message queue
+     */
+    processQueue(): Promise<void>;
+    /**
+     * Rebuild all indexes
+     */
+    rebuildIndexes(): Promise<void>;
+    /**
+     * Shutdown cache manager
+     */
+    shutdown(): Promise<void>;
+    private options?;
+}
+/**
+ * Create cache manager instance
+ */
+export declare function createCacheManager(options: CacheManagerOptions): CacheManager;
+export { writer, indexer, extractor, compactor };
+export { CloudSyncer, SAASConnector, MessageQueue };