discoclaw 0.1.0

package/dist/discord/memory-commands.js

@@ -0,0 +1,85 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { loadDurableMemory, saveDurableMemory, addItem, deprecateItems, selectItemsForInjection, formatDurableSection, } from './durable-memory.js';
+import { loadSummary } from './summarizer.js';
+import { durableWriteQueue } from './durable-write-queue.js';
+export function parseMemoryCommand(content) {
+    const trimmed = content.trim();
+    if (!/^!memory(?:\s|$)/.test(trimmed))
+        return null;
+    const rest = trimmed.slice('!memory'.length).trim();
+    if (!rest || rest === 'show')
+        return { action: 'show', args: '' };
+    if (rest.startsWith('remember '))
+        return { action: 'remember', args: rest.slice('remember '.length).trim() };
+    if (rest.startsWith('forget '))
+        return { action: 'forget', args: rest.slice('forget '.length).trim() };
+    if (rest === 'reset rolling')
+        return { action: 'reset-rolling', args: '' };
+    return null;
+}
+export async function handleMemoryCommand(cmd, opts) {
+    try {
+        if (cmd.action === 'show') {
+            const store = await loadDurableMemory(opts.durableDataDir, opts.userId);
+            const items = store
+                ? selectItemsForInjection(store, opts.durableInjectMaxChars)
+                : [];
+            const durableText = items.length > 0
+                ? formatDurableSection(items)
+                : '(none)';
+            let summaryText = '(none)';
+            try {
+                const summary = await loadSummary(opts.summaryDataDir, opts.sessionKey);
+                if (summary)
+                    summaryText = summary.summary;
+            }
+            catch {
+                // best-effort
+            }
+            return `**Durable memory:**\n${durableText}\n\n**Rolling summary:**\n${summaryText}`;
+        }
+        if (cmd.action === 'remember') {
+            return durableWriteQueue.run(opts.userId, async () => {
+                const store = await loadOrCreate(opts.durableDataDir, opts.userId);
+                const source = { type: 'manual' };
+                if (opts.channelId)
+                    source.channelId = opts.channelId;
+                if (opts.messageId)
+                    source.messageId = opts.messageId;
+                if (opts.guildId)
+                    source.guildId = opts.guildId;
+                if (opts.channelName)
+                    source.channelName = opts.channelName;
+                addItem(store, cmd.args, source, opts.durableMaxItems);
+                await saveDurableMemory(opts.durableDataDir, opts.userId, store);
+                return `Remembered: ${cmd.args}`;
+            });
+        }
+        if (cmd.action === 'forget') {
+            return durableWriteQueue.run(opts.userId, async () => {
+                const store = await loadOrCreate(opts.durableDataDir, opts.userId);
+                const { deprecatedCount } = deprecateItems(store, cmd.args);
+                if (deprecatedCount > 0) {
+                    await saveDurableMemory(opts.durableDataDir, opts.userId, store);
+                    return `Forgot ${deprecatedCount} item(s).`;
+                }
+                return 'No matching items found.';
+            });
+        }
+        if (cmd.action === 'reset-rolling') {
+            const safeName = opts.sessionKey.replace(/[^a-zA-Z0-9:_-]+/g, '-');
+            const filePath = path.join(opts.summaryDataDir, `${safeName}.json`);
+            await fs.rm(filePath, { force: true });
+            return 'Rolling summary cleared for this session.';
+        }
+        return 'Unknown memory command.';
+    }
+    catch (err) {
+        return `Memory command error: ${String(err)}`;
+    }
+}
+async function loadOrCreate(dir, userId) {
+    const store = await loadDurableMemory(dir, userId);
+    return store ?? { version: 1, updatedAt: 0, items: [] };
+}

package/dist/discord/memory-commands.test.js

@@ -0,0 +1,159 @@
+import { describe, expect, it } from 'vitest';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { parseMemoryCommand, handleMemoryCommand } from './memory-commands.js';
+import { saveDurableMemory, addItem } from './durable-memory.js';
+import { saveSummary } from './summarizer.js';
+async function makeTmpDir() {
+    return fs.mkdtemp(path.join(os.tmpdir(), 'memory-commands-test-'));
+}
+function baseOpts(overrides = {}) {
+    return {
+        userId: '12345',
+        sessionKey: 'discord:dm:12345',
+        durableDataDir: '/tmp/durable',
+        durableMaxItems: 200,
+        durableInjectMaxChars: 2000,
+        summaryDataDir: '/tmp/summaries',
+        ...overrides,
+    };
+}
+describe('parseMemoryCommand', () => {
+    it('returns null for non-commands', () => {
+        expect(parseMemoryCommand('hello world')).toBeNull();
+        expect(parseMemoryCommand('!other command')).toBeNull();
+        expect(parseMemoryCommand('!memoryshow')).toBeNull();
+        expect(parseMemoryCommand('')).toBeNull();
+    });
+    it('parses !memory show', () => {
+        expect(parseMemoryCommand('!memory show')).toEqual({ action: 'show', args: '' });
+    });
+    it('parses bare !memory as show', () => {
+        expect(parseMemoryCommand('!memory')).toEqual({ action: 'show', args: '' });
+    });
+    it('parses !memory remember foo', () => {
+        expect(parseMemoryCommand('!memory remember I prefer TypeScript')).toEqual({
+            action: 'remember',
+            args: 'I prefer TypeScript',
+        });
+    });
+    it('parses !memory forget bar', () => {
+        expect(parseMemoryCommand('!memory forget TypeScript')).toEqual({
+            action: 'forget',
+            args: 'TypeScript',
+        });
+    });
+    it('parses !memory reset rolling', () => {
+        expect(parseMemoryCommand('!memory reset rolling')).toEqual({
+            action: 'reset-rolling',
+            args: '',
+        });
+    });
+    it('ignores extra whitespace', () => {
+        expect(parseMemoryCommand('  !memory   show  ')).toEqual({ action: 'show', args: '' });
+        expect(parseMemoryCommand('  !memory   remember   foo bar  ')).toEqual({
+            action: 'remember',
+            args: 'foo bar',
+        });
+    });
+});
+describe('handleMemoryCommand', () => {
+    it('show — returns formatted durable + rolling', async () => {
+        const durableDir = await makeTmpDir();
+        const summaryDir = await makeTmpDir();
+        const store = { version: 1, updatedAt: 0, items: [] };
+        addItem(store, 'User prefers TypeScript', { type: 'manual' }, 200);
+        await saveDurableMemory(durableDir, '12345', store);
+        await saveSummary(summaryDir, 'discord:dm:12345', {
+            summary: 'User is working on memory system.',
+            updatedAt: Date.now(),
+        });
+        const result = await handleMemoryCommand({ action: 'show', args: '' }, baseOpts({ durableDataDir: durableDir, summaryDataDir: summaryDir }));
+        expect(result).toContain('**Durable memory:**');
+        expect(result).toContain('User prefers TypeScript');
+        expect(result).toContain('**Rolling summary:**');
+        expect(result).toContain('User is working on memory system.');
+    });
+    it('show — returns "(none)" when empty', async () => {
+        const durableDir = await makeTmpDir();
+        const summaryDir = await makeTmpDir();
+        const result = await handleMemoryCommand({ action: 'show', args: '' }, baseOpts({ durableDataDir: durableDir, summaryDataDir: summaryDir }));
+        expect(result).toContain('(none)');
+    });
+    it('remember — adds item and saves', async () => {
+        const durableDir = await makeTmpDir();
+        const result = await handleMemoryCommand({ action: 'remember', args: 'I prefer dark mode' }, baseOpts({ durableDataDir: durableDir }));
+        expect(result).toBe('Remembered: I prefer dark mode');
+        // Verify it was saved to disk.
+        const raw = await fs.readFile(path.join(durableDir, '12345.json'), 'utf8');
+        const store = JSON.parse(raw);
+        expect(store.items).toHaveLength(1);
+        expect(store.items[0].text).toBe('I prefer dark mode');
+    });
+    it('forget — deprecates matching items', async () => {
+        const durableDir = await makeTmpDir();
+        // First remember something
+        await handleMemoryCommand({ action: 'remember', args: 'TypeScript' }, baseOpts({ durableDataDir: durableDir }));
+        // Then forget it
+        const result = await handleMemoryCommand({ action: 'forget', args: 'TypeScript' }, baseOpts({ durableDataDir: durableDir }));
+        expect(result).toBe('Forgot 1 item(s).');
+    });
+    it('forget — reports when no match found', async () => {
+        const durableDir = await makeTmpDir();
+        const result = await handleMemoryCommand({ action: 'forget', args: 'something that does not exist' }, baseOpts({ durableDataDir: durableDir }));
+        expect(result).toBe('No matching items found.');
+    });
+    it('remember — persists channelId and messageId in source', async () => {
+        const durableDir = await makeTmpDir();
+        await handleMemoryCommand({ action: 'remember', args: 'test fact' }, baseOpts({ durableDataDir: durableDir, channelId: 'ch42', messageId: 'msg99' }));
+        const raw = await fs.readFile(path.join(durableDir, '12345.json'), 'utf8');
+        const store = JSON.parse(raw);
+        expect(store.items[0].source).toEqual({ type: 'manual', channelId: 'ch42', messageId: 'msg99' });
+    });
+    it('remember persists guildId and channelName in source', async () => {
+        const durableDir = await makeTmpDir();
+        await handleMemoryCommand({ action: 'remember', args: 'test fact' }, baseOpts({ durableDataDir: durableDir, channelId: 'ch42', messageId: 'msg99', guildId: 'g1', channelName: 'dev' }));
+        const raw = await fs.readFile(path.join(durableDir, '12345.json'), 'utf8');
+        const store = JSON.parse(raw);
+        expect(store.items[0].source).toEqual({
+            type: 'manual',
+            channelId: 'ch42',
+            messageId: 'msg99',
+            guildId: 'g1',
+            channelName: 'dev',
+        });
+    });
+    it('concurrent remember calls serialize correctly', async () => {
+        const durableDir = await makeTmpDir();
+        // Fire off concurrent remember commands
+        const results = await Promise.all([
+            handleMemoryCommand({ action: 'remember', args: 'fact one' }, baseOpts({ durableDataDir: durableDir })),
+            handleMemoryCommand({ action: 'remember', args: 'fact two' }, baseOpts({ durableDataDir: durableDir })),
+            handleMemoryCommand({ action: 'remember', args: 'fact three' }, baseOpts({ durableDataDir: durableDir })),
+        ]);
+        expect(results).toEqual([
+            'Remembered: fact one',
+            'Remembered: fact two',
+            'Remembered: fact three',
+        ]);
+        // Verify all three ended up on disk
+        const raw = await fs.readFile(path.join(durableDir, '12345.json'), 'utf8');
+        const store = JSON.parse(raw);
+        expect(store.items).toHaveLength(3);
+        const texts = store.items.map((it) => it.text).sort();
+        expect(texts).toEqual(['fact one', 'fact three', 'fact two']);
+    });
+    it('reset-rolling — deletes summary file', async () => {
+        const summaryDir = await makeTmpDir();
+        await saveSummary(summaryDir, 'discord:dm:12345', {
+            summary: 'some summary',
+            updatedAt: Date.now(),
+        });
+        const result = await handleMemoryCommand({ action: 'reset-rolling', args: '' }, baseOpts({ summaryDataDir: summaryDir }));
+        expect(result).toBe('Rolling summary cleared for this session.');
+        // Verify file is gone.
+        const files = await fs.readdir(summaryDir);
+        expect(files).toHaveLength(0);
+    });
+});

package/dist/discord/memory-timing.integration.test.js

@@ -0,0 +1,159 @@
+import { describe, expect, it, vi } from 'vitest';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { createMessageCreateHandler } from '../discord.js';
+function makeQueue() {
+    return {
+        run: vi.fn(async (_key, fn) => fn()),
+    };
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function makeReply(id) {
+    return {
+        id,
+        channelId: 'chan',
+        edit: vi.fn(async () => { }),
+        delete: vi.fn(async () => { }),
+        react: vi.fn(async () => { }),
+        reactions: { resolve: () => ({ remove: async () => { } }) },
+    };
+}
+function makeMsg(content, replyId) {
+    const replyObj = makeReply(replyId);
+    return {
+        id: `msg-${replyId}`,
+        type: 0,
+        author: { id: '123', bot: false, username: 'tester', displayName: 'Tester' },
+        guildId: 'guild',
+        guild: { roles: { everyone: {} } },
+        channelId: 'chan',
+        channel: { send: vi.fn(async () => { }), isThread: () => false, name: 'general', id: 'chan' },
+        content,
+        attachments: new Map(),
+        stickers: new Map(),
+        embeds: [],
+        mentions: { has: () => false },
+        client: { user: { id: 'bot-1' }, channels: { cache: new Map() } },
+        reply: vi.fn(async () => replyObj),
+    };
+}
+function makeParams(runtime, summaryDataDir, overrides = {}) {
+    return {
+        allowUserIds: new Set(['123']),
+        runtime,
+        sessionManager: { getOrCreate: vi.fn(async () => 'sess') },
+        workspaceCwd: '/tmp',
+        projectCwd: '/tmp',
+        groupsDir: '/tmp',
+        useGroupDirCwd: false,
+        runtimeModel: 'fast',
+        runtimeTools: [],
+        runtimeTimeoutMs: 1000,
+        requireChannelContext: false,
+        autoIndexChannelContext: false,
+        autoJoinThreads: false,
+        useRuntimeSessions: true,
+        discordActionsEnabled: false,
+        discordActionsChannels: false,
+        discordActionsMessaging: false,
+        discordActionsGuild: false,
+        discordActionsModeration: false,
+        discordActionsPolls: false,
+        discordActionsTasks: false,
+        discordActionsBotProfile: false,
+        messageHistoryBudget: 0,
+        summaryEnabled: true,
+        summaryModel: 'fast',
+        summaryMaxChars: 2000,
+        summaryEveryNTurns: 1,
+        summaryDataDir,
+        summaryToDurableEnabled: false,
+        shortTermMemoryEnabled: false,
+        shortTermDataDir: '/tmp/shortterm',
+        shortTermMaxEntries: 20,
+        shortTermMaxAgeMs: 21600000,
+        shortTermInjectMaxChars: 1000,
+        durableMemoryEnabled: true,
+        durableDataDir: '/tmp/durable',
+        durableInjectMaxChars: 2000,
+        durableMaxItems: 200,
+        memoryCommandsEnabled: true,
+        actionFollowupDepth: 0,
+        reactionHandlerEnabled: false,
+        reactionRemoveHandlerEnabled: false,
+        reactionMaxAgeMs: 86400000,
+        streamStallWarningMs: 0,
+        botDisplayName: 'TestBot',
+        ...overrides,
+    };
+}
+async function waitForFileSummary(filePath, expected) {
+    const deadline = Date.now() + 4000;
+    let last = '';
+    while (Date.now() < deadline) {
+        try {
+            const raw = await fs.readFile(filePath, 'utf8');
+            last = JSON.parse(raw).summary;
+            if (last === expected)
+                return;
+        }
+        catch {
+            // keep polling
+        }
+        await sleep(20);
+    }
+    throw new Error(`Timed out waiting for summary "${expected}". Last seen: "${last}"`);
+}
+describe('memory timing integration', () => {
+    it('serializes summary writes so stale async completions do not overwrite newer summary', async () => {
+        let summaryCall = 0;
+        const runtime = {
+            id: 'test-runtime',
+            capabilities: new Set(),
+            invoke: vi.fn(async function* (p) {
+                const prompt = String(p.prompt ?? '');
+                if (prompt.includes('Updated summary:')) {
+                    summaryCall += 1;
+                    if (summaryCall === 1)
+                        await sleep(80);
+                    if (summaryCall === 2)
+                        await sleep(10);
+                    yield { type: 'text_final', text: summaryCall === 1 ? 'summary:first' : 'summary:second' };
+                    return;
+                }
+                yield { type: 'text_final', text: 'ok' };
+            }),
+        };
+        const summaryDir = await fs.mkdtemp(path.join(os.tmpdir(), 'memory-timing-summary-'));
+        const handler = createMessageCreateHandler(makeParams(runtime, summaryDir, { summaryEveryNTurns: 1 }), makeQueue());
+        await handler(makeMsg('first turn', 'r1'));
+        await handler(makeMsg('second turn', 'r2'));
+        const summaryFile = path.join(summaryDir, 'discord:channel:chan.json');
+        await waitForFileSummary(summaryFile, 'summary:second');
+    });
+    it('reset rolling clears in-memory turn counter so next turn does not prematurely regenerate summary', async () => {
+        const runtime = {
+            id: 'test-runtime',
+            capabilities: new Set(),
+            invoke: vi.fn(async function* (p) {
+                const prompt = String(p.prompt ?? '');
+                if (prompt.includes('Updated summary:')) {
+                    yield { type: 'text_final', text: 'summary:generated' };
+                    return;
+                }
+                yield { type: 'text_final', text: 'ok' };
+            }),
+        };
+        const summaryDir = await fs.mkdtemp(path.join(os.tmpdir(), 'memory-reset-counter-'));
+        const handler = createMessageCreateHandler(makeParams(runtime, summaryDir, { summaryEveryNTurns: 2 }), makeQueue());
+        await handler(makeMsg('turn one', 'r1'));
+        await handler(makeMsg('!memory reset rolling', 'r2'));
+        await handler(makeMsg('turn two', 'r3'));
+        await sleep(200);
+        const summaryFile = path.join(summaryDir, 'discord:channel:chan.json');
+        await expect(fs.access(summaryFile)).rejects.toThrow();
+    });
+});