discoclaw 0.1.0

package/dist/discord/actions-memory.js

@@ -0,0 +1,106 @@
+import { loadDurableMemory, saveDurableMemory, addItem, deprecateItems, selectItemsForInjection, formatDurableSection, } from './durable-memory.js';
+import { durableWriteQueue } from './durable-write-queue.js';
+const MEMORY_TYPE_MAP = {
+    memoryRemember: true,
+    memoryForget: true,
+    memoryShow: true,
+};
+export const MEMORY_ACTION_TYPES = new Set(Object.keys(MEMORY_TYPE_MAP));
+// ---------------------------------------------------------------------------
+// Executor
+// ---------------------------------------------------------------------------
+const VALID_KINDS = new Set([
+    'fact', 'preference', 'project', 'constraint', 'person', 'tool', 'workflow',
+]);
+export async function executeMemoryAction(action, _ctx, memCtx) {
+    switch (action.type) {
+        case 'memoryRemember': {
+            if (!action.text) {
+                return { ok: false, error: 'memoryRemember requires text' };
+            }
+            const kind = action.kind ?? 'fact';
+            if (!VALID_KINDS.has(kind)) {
+                return { ok: false, error: `Invalid memory kind: "${kind}". Must be one of: ${[...VALID_KINDS].join(', ')}` };
+            }
+            return durableWriteQueue.run(memCtx.userId, async () => {
+                const store = await loadOrCreate(memCtx.durableDataDir, memCtx.userId);
+                const source = { type: 'discord' };
+                if (memCtx.channelId)
+                    source.channelId = memCtx.channelId;
+                if (memCtx.messageId)
+                    source.messageId = memCtx.messageId;
+                if (memCtx.guildId)
+                    source.guildId = memCtx.guildId;
+                if (memCtx.channelName)
+                    source.channelName = memCtx.channelName;
+                addItem(store, action.text, source, memCtx.durableMaxItems, kind);
+                await saveDurableMemory(memCtx.durableDataDir, memCtx.userId, store);
+                memCtx.log?.info({ action: 'memoryRemember', userId: memCtx.userId, textLength: action.text.length }, 'memory:action:remember');
+                return { ok: true, summary: `Remembered: "${action.text}"` };
+            });
+        }
+        case 'memoryForget': {
+            if (!action.substring) {
+                return { ok: false, error: 'memoryForget requires a substring' };
+            }
+            return durableWriteQueue.run(memCtx.userId, async () => {
+                const store = await loadOrCreate(memCtx.durableDataDir, memCtx.userId);
+                const { deprecatedCount } = deprecateItems(store, action.substring);
+                if (deprecatedCount > 0) {
+                    await saveDurableMemory(memCtx.durableDataDir, memCtx.userId, store);
+                    memCtx.log?.info({ action: 'memoryForget', userId: memCtx.userId, textLength: action.substring.length, deprecatedCount }, 'memory:action:forget');
+                    return { ok: true, summary: `Forgot ${deprecatedCount} item(s) matching "${action.substring}"` };
+                }
+                return { ok: true, summary: `No matching items found for "${action.substring}"` };
+            });
+        }
+        case 'memoryShow': {
+            const store = await loadDurableMemory(memCtx.durableDataDir, memCtx.userId);
+            const items = store
+                ? selectItemsForInjection(store, memCtx.durableInjectMaxChars)
+                : [];
+            if (items.length === 0) {
+                return { ok: true, summary: 'No durable memory items.' };
+            }
+            return { ok: true, summary: formatDurableSection(items) };
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+async function loadOrCreate(dir, userId) {
+    const store = await loadDurableMemory(dir, userId);
+    return store ?? { version: 1, updatedAt: 0, items: [] };
+}
+// ---------------------------------------------------------------------------
+// Prompt section
+// ---------------------------------------------------------------------------
+export function memoryActionsPromptSection() {
+    return `### Memory (Durable User Memory)
+
+**memoryRemember** — Store a fact, preference, or note in the user's durable memory:
+\`\`\`
+<discord-action>{"type":"memoryRemember","text":"Prefers Rust over Go for systems work"}</discord-action>
+<discord-action>{"type":"memoryRemember","text":"Working on API migration","kind":"project"}</discord-action>
+\`\`\`
+- \`text\` (required): The fact or note to remember.
+- \`kind\` (optional): One of \`fact\`, \`preference\`, \`project\`, \`constraint\`, \`person\`, \`tool\`, \`workflow\`. Defaults to \`fact\`.
+
+**memoryForget** — Deprecate matching items from the user's durable memory:
+\`\`\`
+<discord-action>{"type":"memoryForget","substring":"Prefers Rust over Go"}</discord-action>
+\`\`\`
+- \`substring\` (required): Text to match against. Items where this covers >= 60% of the item's text length are deprecated.
+
+**memoryShow** — Show the user's current durable memory items:
+\`\`\`
+<discord-action>{"type":"memoryShow"}</discord-action>
+\`\`\`
+
+#### Memory Guidelines
+- Use memoryRemember to proactively store important facts the user mentions (preferences, projects, tools, constraints).
+- Pick the most specific \`kind\` that fits — it helps with organization and retrieval.
+- Use memoryForget to clean up outdated or incorrect items.
+- Memory items persist across sessions, channels, and restarts.`;
+}

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

@@ -0,0 +1,248 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { MEMORY_ACTION_TYPES, executeMemoryAction, memoryActionsPromptSection } from './actions-memory.js';
+// ---------------------------------------------------------------------------
+// Mocks
+// ---------------------------------------------------------------------------
+const mockStore = {
+    version: 1,
+    updatedAt: 1700000000000,
+    items: [
+        {
+            id: 'durable-abc12345',
+            kind: 'fact',
+            text: 'Works at Acme Corp',
+            tags: [],
+            status: 'active',
+            source: { type: 'manual', channelId: 'ch1', channelName: 'general' },
+            createdAt: 1700000000000,
+            updatedAt: 1700000000000,
+        },
+        {
+            id: 'durable-def67890',
+            kind: 'preference',
+            text: 'Prefers Rust over Go',
+            tags: [],
+            status: 'active',
+            source: { type: 'summary' },
+            createdAt: 1700000000000,
+            updatedAt: 1700000000000,
+        },
+    ],
+};
+vi.mock('./durable-memory.js', () => ({
+    loadDurableMemory: vi.fn(async (_dir, _userId) => {
+        return JSON.parse(JSON.stringify(mockStore));
+    }),
+    saveDurableMemory: vi.fn(async () => { }),
+    addItem: vi.fn((store, text, source, maxItems, kind) => {
+        store.items.push({
+            id: `durable-new`,
+            kind: kind ?? 'fact',
+            text,
+            tags: [],
+            status: 'active',
+            source,
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+        });
+        return store;
+    }),
+    deprecateItems: vi.fn((store, substring) => {
+        const needle = substring.toLowerCase();
+        let deprecatedCount = 0;
+        for (const item of store.items) {
+            if (item.status !== 'active')
+                continue;
+            if (item.text.toLowerCase().includes(needle) && needle.length >= item.text.length * 0.6) {
+                item.status = 'deprecated';
+                deprecatedCount++;
+            }
+        }
+        return { store, deprecatedCount };
+    }),
+    selectItemsForInjection: vi.fn((store, _maxChars) => {
+        return store.items.filter((i) => i.status === 'active');
+    }),
+    formatDurableSection: vi.fn((items) => {
+        return items.map((i) => `- [${i.kind}] ${i.text}`).join('\n');
+    }),
+}));
+vi.mock('./durable-write-queue.js', () => ({
+    durableWriteQueue: {
+        run: vi.fn(async (_key, fn) => fn()),
+    },
+}));
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeCtx() {
+    return {
+        guild: {},
+        client: {},
+        channelId: 'test-channel',
+        messageId: 'test-message',
+    };
+}
+function makeMemCtx(overrides) {
+    return {
+        userId: 'user-123',
+        durableDataDir: '/tmp/durable',
+        durableMaxItems: 200,
+        durableInjectMaxChars: 2000,
+        channelId: 'ch-456',
+        messageId: 'msg-789',
+        guildId: 'guild-001',
+        channelName: 'dev',
+        log: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+        ...overrides,
+    };
+}
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+beforeEach(() => {
+    vi.clearAllMocks();
+});
+describe('MEMORY_ACTION_TYPES', () => {
+    it('contains all memory action types', () => {
+        expect(MEMORY_ACTION_TYPES.has('memoryRemember')).toBe(true);
+        expect(MEMORY_ACTION_TYPES.has('memoryForget')).toBe(true);
+        expect(MEMORY_ACTION_TYPES.has('memoryShow')).toBe(true);
+    });
+    it('does not contain non-memory types', () => {
+        expect(MEMORY_ACTION_TYPES.has('forgeCreate')).toBe(false);
+        expect(MEMORY_ACTION_TYPES.has('planList')).toBe(false);
+        expect(MEMORY_ACTION_TYPES.has('beadCreate')).toBe(false);
+    });
+});
+describe('executeMemoryAction', () => {
+    describe('memoryRemember', () => {
+        it('stores a fact in durable memory', async () => {
+            const { addItem } = await import('./durable-memory.js');
+            const { saveDurableMemory } = await import('./durable-memory.js');
+            const result = await executeMemoryAction({ type: 'memoryRemember', text: 'Uses TypeScript daily' }, makeCtx(), makeMemCtx());
+            expect(result.ok).toBe(true);
+            if (result.ok) {
+                expect(result.summary).toContain('Remembered');
+                expect(result.summary).toContain('Uses TypeScript daily');
+            }
+            expect(addItem).toHaveBeenCalled();
+            expect(saveDurableMemory).toHaveBeenCalled();
+        });
+        it('passes kind to addItem when specified', async () => {
+            const { addItem } = await import('./durable-memory.js');
+            await executeMemoryAction({ type: 'memoryRemember', text: 'Working on DiscoClaw', kind: 'project' }, makeCtx(), makeMemCtx());
+            expect(addItem).toHaveBeenCalledWith(expect.any(Object), 'Working on DiscoClaw', expect.objectContaining({ type: 'discord' }), 200, 'project');
+        });
+        it('defaults kind to fact', async () => {
+            const { addItem } = await import('./durable-memory.js');
+            await executeMemoryAction({ type: 'memoryRemember', text: 'Some fact' }, makeCtx(), makeMemCtx());
+            expect(addItem).toHaveBeenCalledWith(expect.any(Object), 'Some fact', expect.any(Object), 200, 'fact');
+        });
+        it('sets source type to discord with Discord metadata', async () => {
+            const { addItem } = await import('./durable-memory.js');
+            await executeMemoryAction({ type: 'memoryRemember', text: 'A fact' }, makeCtx(), makeMemCtx());
+            expect(addItem).toHaveBeenCalledWith(expect.any(Object), 'A fact', expect.objectContaining({
+                type: 'discord',
+                channelId: 'ch-456',
+                messageId: 'msg-789',
+                guildId: 'guild-001',
+                channelName: 'dev',
+            }), 200, 'fact');
+        });
+        it('fails without text', async () => {
+            const result = await executeMemoryAction({ type: 'memoryRemember', text: '' }, makeCtx(), makeMemCtx());
+            expect(result.ok).toBe(false);
+            if (!result.ok)
+                expect(result.error).toContain('requires text');
+        });
+        it('serializes writes through durableWriteQueue', async () => {
+            const { durableWriteQueue } = await import('./durable-write-queue.js');
+            await executeMemoryAction({ type: 'memoryRemember', text: 'Queued fact' }, makeCtx(), makeMemCtx());
+            expect(durableWriteQueue.run).toHaveBeenCalledWith('user-123', expect.any(Function));
+        });
+    });
+    describe('memoryForget', () => {
+        it('deprecates matching items', async () => {
+            const { deprecateItems, saveDurableMemory } = await import('./durable-memory.js');
+            const result = await executeMemoryAction({ type: 'memoryForget', substring: 'Prefers Rust over Go' }, makeCtx(), makeMemCtx());
+            expect(result.ok).toBe(true);
+            if (result.ok) {
+                expect(result.summary).toContain('Forgot');
+                expect(result.summary).toContain('1 item(s)');
+            }
+            expect(deprecateItems).toHaveBeenCalled();
+            expect(saveDurableMemory).toHaveBeenCalled();
+        });
+        it('reports when no items match', async () => {
+            const result = await executeMemoryAction({ type: 'memoryForget', substring: 'x' }, makeCtx(), makeMemCtx());
+            expect(result.ok).toBe(true);
+            if (result.ok) {
+                expect(result.summary).toContain('No matching items');
+            }
+        });
+        it('fails without substring', async () => {
+            const result = await executeMemoryAction({ type: 'memoryForget', substring: '' }, makeCtx(), makeMemCtx());
+            expect(result.ok).toBe(false);
+            if (!result.ok)
+                expect(result.error).toContain('requires a substring');
+        });
+        it('does not save when nothing was deprecated', async () => {
+            const { saveDurableMemory } = await import('./durable-memory.js');
+            await executeMemoryAction({ type: 'memoryForget', substring: 'x' }, makeCtx(), makeMemCtx());
+            expect(saveDurableMemory).not.toHaveBeenCalled();
+        });
+    });
+    describe('memoryShow', () => {
+        it('shows durable memory items', async () => {
+            const result = await executeMemoryAction({ type: 'memoryShow' }, makeCtx(), makeMemCtx());
+            expect(result.ok).toBe(true);
+            if (result.ok) {
+                expect(result.summary).toContain('[fact]');
+                expect(result.summary).toContain('Works at Acme Corp');
+                expect(result.summary).toContain('[preference]');
+                expect(result.summary).toContain('Prefers Rust over Go');
+            }
+        });
+        it('returns message when no items exist', async () => {
+            const { loadDurableMemory } = await import('./durable-memory.js');
+            loadDurableMemory.mockResolvedValueOnce(null);
+            const result = await executeMemoryAction({ type: 'memoryShow' }, makeCtx(), makeMemCtx());
+            expect(result.ok).toBe(true);
+            if (result.ok) {
+                expect(result.summary).toContain('No durable memory items');
+            }
+        });
+        it('returns message when all items are deprecated', async () => {
+            const { selectItemsForInjection } = await import('./durable-memory.js');
+            selectItemsForInjection.mockReturnValueOnce([]);
+            const result = await executeMemoryAction({ type: 'memoryShow' }, makeCtx(), makeMemCtx());
+            expect(result.ok).toBe(true);
+            if (result.ok) {
+                expect(result.summary).toContain('No durable memory items');
+            }
+        });
+    });
+});
+describe('memoryActionsPromptSection', () => {
+    it('returns non-empty prompt section', () => {
+        const section = memoryActionsPromptSection();
+        expect(section).toContain('memoryRemember');
+        expect(section).toContain('memoryForget');
+        expect(section).toContain('memoryShow');
+    });
+    it('includes memory guidelines', () => {
+        const section = memoryActionsPromptSection();
+        expect(section).toContain('proactively');
+        expect(section).toContain('persist');
+        expect(section).toContain('kind');
+    });
+    it('documents available kinds', () => {
+        const section = memoryActionsPromptSection();
+        expect(section).toContain('fact');
+        expect(section).toContain('preference');
+        expect(section).toContain('project');
+        expect(section).toContain('constraint');
+        expect(section).toContain('workflow');
+    });
+});