@aperdomoll90/ledger-ai 1.1.3 → 1.3.0

package/dist/lib/op-add-note-types.test.js

@@ -0,0 +1,159 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+/**
+ * Tests for opAddNote's type registry integration:
+ * - Unknown type → confirm prompt
+ * - Unknown type + register_type → registers then saves
+ * - Unknown type + register_type + invalid name → error
+ * - Alias resolution in add flow
+ *
+ * These tests mock config (filesystem) and force interactive OFF
+ * so we only hit the type-checking code path before any DB calls.
+ */
+const mockConfigState = { current: {} };
+vi.mock('./config.js', () => ({
+    loadConfigFile: () => mockConfigState.current,
+    saveConfigFile: (config) => { mockConfigState.current = config; },
+}));
+// Mock hash module (used in opAddNote for content_hash)
+vi.mock('./hash.js', () => ({
+    contentHash: (s) => `hash-${s.length}`,
+}));
+const { opAddNote, BUILTIN_TYPES } = await import('./notes.js');
+// --- Mock Clients ---
+function createMockClients() {
+    const insertResult = { data: { id: 999, created_at: '2026-01-01' }, error: null };
+    const selectChain = {
+        select: vi.fn().mockReturnThis(),
+        eq: vi.fn().mockReturnThis(),
+        limit: vi.fn().mockReturnThis(),
+        single: vi.fn().mockResolvedValue({ data: null, error: null }),
+    };
+    const insertChain = {
+        select: vi.fn().mockReturnValue({
+            single: vi.fn().mockResolvedValue(insertResult),
+        }),
+    };
+    const supabase = {
+        from: vi.fn().mockReturnValue({
+            ...selectChain,
+            insert: vi.fn().mockReturnValue(insertChain),
+        }),
+        rpc: vi.fn().mockResolvedValue({ data: [], error: null }),
+    };
+    const openai = {
+        embeddings: {
+            create: vi.fn().mockResolvedValue({
+                data: [{ embedding: new Array(1536).fill(0) }],
+            }),
+        },
+    };
+    return { supabase, openai };
+}
+// --- Helpers ---
+function resetConfig() {
+    mockConfigState.current = { naming: { interactive: false } };
+}
+beforeEach(() => {
+    resetConfig();
+});
+// ============================================================
+// Unknown type → confirm prompt
+// ============================================================
+describe('opAddNote — unknown type handling', () => {
+    it('returns confirm when type is unknown and register_type is false', async () => {
+        const clients = createMockClients();
+        const result = await opAddNote(clients, 'Some content', 'wine-log', 'claude-code', { upsert_key: 'test', description: 'test' }, false, // force
+        false);
+        expect(result.status).toBe('confirm');
+        expect(result.message).toContain('wine-log');
+        expect(result.message).toContain('not registered');
+        expect(result.message).toContain('Options');
+    });
+    it('confirm message lists all registered types', async () => {
+        const clients = createMockClients();
+        const result = await opAddNote(clients, 'Content', 'unknown-type', 'agent', { upsert_key: 'test', description: 'test' }, false, false);
+        expect(result.status).toBe('confirm');
+        // Should list built-in types
+        expect(result.message).toContain('code-craft');
+        expect(result.message).toContain('architecture-decision');
+        expect(result.message).toContain('reference');
+    });
+});
+// ============================================================
+// Unknown type + register_type → registers then proceeds
+// ============================================================
+describe('opAddNote — type registration', () => {
+    it('registers type and saves note when register_type is true', async () => {
+        const clients = createMockClients();
+        const result = await opAddNote(clients, 'Tasting notes for 2024 Malbec', 'wine-log', 'claude-code', { upsert_key: 'wine-2024-malbec', description: 'Tasting notes', delivery: 'project' }, false, true);
+        // Should succeed (type got registered mid-call)
+        expect(result.status).toBe('ok');
+        // Type should now be in config
+        expect(mockConfigState.current.types?.['wine-log']).toBe('project');
+    });
+    it('defaults delivery to knowledge when not specified', async () => {
+        const clients = createMockClients();
+        await opAddNote(clients, 'My recipe content', 'recipe', 'claude-code', { upsert_key: 'recipe-pasta', description: 'Pasta recipe' }, false, true);
+        expect(mockConfigState.current.types?.['recipe']).toBe('knowledge');
+    });
+    it('registered type persists for subsequent calls', async () => {
+        const clients = createMockClients();
+        // First call: register
+        await opAddNote(clients, 'First wine note', 'wine-log', 'claude-code', { upsert_key: 'wine-1', description: 'First', delivery: 'project' }, false, true);
+        // Second call: should NOT need register_type anymore
+        const result = await opAddNote(clients, 'Second wine note', 'wine-log', 'claude-code', { upsert_key: 'wine-2', description: 'Second' }, false, false);
+        expect(result.status).toBe('ok');
+    });
+});
+// ============================================================
+// Invalid type name with register_type
+// ============================================================
+describe('opAddNote — invalid type name rejection', () => {
+    it('returns error for uppercase type name', async () => {
+        const clients = createMockClients();
+        const result = await opAddNote(clients, 'Content', 'Wine-Log', 'agent', { upsert_key: 'test', description: 'test' }, false, true);
+        expect(result.status).toBe('error');
+        expect(result.message).toContain('Invalid type name');
+    });
+    it('returns error for single-character type name', async () => {
+        const clients = createMockClients();
+        const result = await opAddNote(clients, 'Content', 'x', 'agent', { upsert_key: 'test', description: 'test' }, false, true);
+        expect(result.status).toBe('error');
+        expect(result.message).toContain('at least 2');
+    });
+    it('returns error for type name with underscores', async () => {
+        const clients = createMockClients();
+        const result = await opAddNote(clients, 'Content', 'wine_log', 'agent', { upsert_key: 'test', description: 'test' }, false, true);
+        expect(result.status).toBe('error');
+        expect(result.message).toContain('Invalid type name');
+    });
+});
+// ============================================================
+// Alias resolution in opAddNote
+// ============================================================
+describe('opAddNote — alias resolution', () => {
+    it('feedback alias resolves to general and saves successfully', async () => {
+        const clients = createMockClients();
+        const result = await opAddNote(clients, 'Some feedback content', 'feedback', 'claude-code', { upsert_key: 'test-feedback', description: 'Test feedback' }, false, false);
+        // 'feedback' aliases to 'general' which is a built-in — should work
+        expect(result.status).toBe('ok');
+    });
+});
+// ============================================================
+// Built-in types work without registration
+// ============================================================
+describe('opAddNote — built-in types', () => {
+    it('accepts all built-in types without register_type flag', async () => {
+        const clients = createMockClients();
+        for (const builtinType of Object.keys(BUILTIN_TYPES)) {
+            const result = await opAddNote(clients, `Content for ${builtinType}`, builtinType, 'claude-code', {
+                upsert_key: `test-${builtinType}`,
+                description: `Test ${builtinType}`,
+                ...(builtinType === 'architecture-decision' || builtinType === 'project-status' || builtinType === 'event' || builtinType === 'error'
+                    ? { status: 'active' }
+                    : {}),
+            }, false, false);
+            expect(result.status, `Built-in type "${builtinType}" should be accepted`).toBe('ok');
+        }
+    });
+});

package/dist/lib/type-registry.test.js

@@ -0,0 +1,258 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// Mock config module — isolates tests from filesystem
+const mockConfigState = { current: {} };
+vi.mock('./config.js', () => ({
+    loadConfigFile: () => mockConfigState.current,
+    saveConfigFile: (config) => { mockConfigState.current = config; },
+}));
+// Import AFTER mock setup so modules pick up the mocked config
+const { BUILTIN_TYPES, getTypeRegistry, inferDelivery, getRegisteredTypes, isRegisteredType, registerType, validateTypeName, checkMetadataCompleteness, } = await import('./notes.js');
+// --- Helpers ---
+function setUserTypes(types) {
+    mockConfigState.current = { types };
+}
+function resetConfig() {
+    mockConfigState.current = {};
+}
+// --- Tests ---
+beforeEach(() => {
+    resetConfig();
+});
+// ============================================================
+// 1. getTypeRegistry
+// ============================================================
+describe('getTypeRegistry', () => {
+    it('returns built-ins when no user config', () => {
+        const registry = getTypeRegistry();
+        expect(registry).toEqual(BUILTIN_TYPES);
+    });
+    it('merges user overrides with built-ins', () => {
+        setUserTypes({ 'wine-log': 'project' });
+        const registry = getTypeRegistry();
+        expect(registry['wine-log']).toBe('project');
+        expect(registry['code-craft']).toBe('persona'); // built-in still present
+    });
+    it('user overrides win over built-in defaults', () => {
+        setUserTypes({ 'code-craft': 'knowledge' });
+        const registry = getTypeRegistry();
+        expect(registry['code-craft']).toBe('knowledge');
+    });
+});
+// ============================================================
+// 2. inferDelivery
+// ============================================================
+describe('inferDelivery', () => {
+    it('returns correct tier for built-in types', () => {
+        expect(inferDelivery('persona-rule')).toBe('persona');
+        expect(inferDelivery('architecture-decision')).toBe('project');
+        expect(inferDelivery('reference')).toBe('knowledge');
+    });
+    it('respects user overrides', () => {
+        setUserTypes({ 'code-craft': 'project' });
+        expect(inferDelivery('code-craft')).toBe('project');
+    });
+    it('defaults unknown types to knowledge', () => {
+        expect(inferDelivery('nonexistent-type')).toBe('knowledge');
+    });
+    it('resolves aliases — feedback maps to general (knowledge)', () => {
+        expect(inferDelivery('feedback')).toBe('knowledge');
+    });
+    it('resolves aliases before checking overrides', () => {
+        // Override 'general' (which 'feedback' aliases to)
+        setUserTypes({ 'general': 'project' });
+        expect(inferDelivery('feedback')).toBe('project');
+    });
+});
+// ============================================================
+// 3. isRegisteredType
+// ============================================================
+describe('isRegisteredType', () => {
+    it('returns true for built-in types', () => {
+        expect(isRegisteredType('code-craft')).toBe(true);
+        expect(isRegisteredType('event')).toBe(true);
+    });
+    it('returns true for custom types', () => {
+        setUserTypes({ 'wine-log': 'project' });
+        expect(isRegisteredType('wine-log')).toBe(true);
+    });
+    it('returns false for unknown types', () => {
+        expect(isRegisteredType('nonexistent')).toBe(false);
+    });
+    it('returns true for aliased types (feedback → general)', () => {
+        expect(isRegisteredType('feedback')).toBe(true);
+    });
+});
+// ============================================================
+// 4. getRegisteredTypes
+// ============================================================
+describe('getRegisteredTypes', () => {
+    it('returns all built-in type names when no custom types', () => {
+        const types = getRegisteredTypes();
+        expect(types).toContain('code-craft');
+        expect(types).toContain('architecture-decision');
+        expect(types).toContain('reference');
+        expect(types.length).toBe(Object.keys(BUILTIN_TYPES).length);
+    });
+    it('includes custom types in the list', () => {
+        setUserTypes({ 'wine-log': 'project', 'recipe': 'knowledge' });
+        const types = getRegisteredTypes();
+        expect(types).toContain('wine-log');
+        expect(types).toContain('recipe');
+        expect(types.length).toBe(Object.keys(BUILTIN_TYPES).length + 2);
+    });
+    it('does not duplicate when overriding a built-in', () => {
+        setUserTypes({ 'code-craft': 'knowledge' });
+        const types = getRegisteredTypes();
+        const codeCraftCount = types.filter(t => t === 'code-craft').length;
+        expect(codeCraftCount).toBe(1);
+        expect(types.length).toBe(Object.keys(BUILTIN_TYPES).length);
+    });
+});
+// ============================================================
+// 5. registerType
+// ============================================================
+describe('registerType', () => {
+    it('writes a new custom type to config', () => {
+        registerType('wine-log', 'project');
+        expect(mockConfigState.current.types?.['wine-log']).toBe('project');
+    });
+    it('does not clobber existing config keys', () => {
+        mockConfigState.current = {
+            device: { alias: 'test-machine' },
+            types: { 'existing': 'knowledge' },
+        };
+        registerType('wine-log', 'project');
+        expect(mockConfigState.current.device?.alias).toBe('test-machine');
+        expect(mockConfigState.current.types?.['existing']).toBe('knowledge');
+        expect(mockConfigState.current.types?.['wine-log']).toBe('project');
+    });
+    it('initializes types object if missing', () => {
+        mockConfigState.current = {};
+        registerType('recipe', 'knowledge');
+        expect(mockConfigState.current.types).toBeDefined();
+        expect(mockConfigState.current.types?.['recipe']).toBe('knowledge');
+    });
+    it('registered type becomes discoverable immediately', () => {
+        expect(isRegisteredType('wine-log')).toBe(false);
+        registerType('wine-log', 'project');
+        expect(isRegisteredType('wine-log')).toBe(true);
+        expect(inferDelivery('wine-log')).toBe('project');
+    });
+});
+// ============================================================
+// 6. validateTypeName
+// ============================================================
+describe('validateTypeName', () => {
+    it('accepts valid names', () => {
+        expect(validateTypeName('wine-log')).toBeNull();
+        expect(validateTypeName('ab')).toBeNull();
+        expect(validateTypeName('my-custom-type-123')).toBeNull();
+        expect(validateTypeName('a1')).toBeNull();
+    });
+    it('rejects empty string', () => {
+        expect(validateTypeName('')).toContain('at least 2');
+    });
+    it('rejects single character', () => {
+        expect(validateTypeName('a')).toContain('at least 2');
+    });
+    it('rejects names over 50 characters', () => {
+        const longName = 'a' + '-long'.repeat(10) + '-name';
+        expect(validateTypeName(longName.length > 50 ? longName : 'a'.repeat(51))).toContain('50 characters');
+    });
+    it('rejects uppercase letters', () => {
+        expect(validateTypeName('Wine-Log')).toContain('lowercase');
+    });
+    it('rejects names starting with a number', () => {
+        expect(validateTypeName('1-bad')).toContain('lowercase');
+    });
+    it('rejects special characters', () => {
+        expect(validateTypeName('wine_log')).toContain('lowercase');
+        expect(validateTypeName('wine.log')).toContain('lowercase');
+        expect(validateTypeName('wine log')).toContain('lowercase');
+    });
+    it('rejects consecutive hyphens', () => {
+        expect(validateTypeName('wine--log')).toContain('lowercase');
+    });
+    it('rejects trailing hyphen', () => {
+        expect(validateTypeName('wine-')).toContain('lowercase');
+    });
+});
+// ============================================================
+// 7. checkMetadataCompleteness (dynamic delivery check)
+// ============================================================
+describe('checkMetadataCompleteness', () => {
+    it('returns null when all fields are present for project type', () => {
+        const result = checkMetadataCompleteness({ description: 'test', upsert_key: 'test-key', status: 'active' }, 'architecture-decision');
+        expect(result).toBeNull();
+    });
+    it('returns null when all fields are present for persona type (no status needed)', () => {
+        const result = checkMetadataCompleteness({ description: 'test', upsert_key: 'test-key' }, 'code-craft');
+        expect(result).toBeNull();
+    });
+    it('prompts for status on project-delivery types', () => {
+        const result = checkMetadataCompleteness({ description: 'test', upsert_key: 'test-key' }, 'architecture-decision');
+        expect(result).toContain('status');
+    });
+    it('does NOT prompt for status on persona-delivery types', () => {
+        const result = checkMetadataCompleteness({ description: 'test', upsert_key: 'test-key' }, 'persona-rule');
+        expect(result).toBeNull();
+    });
+    it('uses inferDelivery for custom types — project custom type requires status', () => {
+        setUserTypes({ 'wine-log': 'project' });
+        const result = checkMetadataCompleteness({ description: 'test', upsert_key: 'test-key' }, 'wine-log');
+        expect(result).toContain('status');
+    });
+    it('uses inferDelivery for custom types — knowledge custom type skips status', () => {
+        setUserTypes({ 'recipe': 'knowledge' });
+        const result = checkMetadataCompleteness({ description: 'test', upsert_key: 'test-key' }, 'recipe');
+        expect(result).toBeNull();
+    });
+    it('prompts for missing description and upsert_key', () => {
+        const result = checkMetadataCompleteness({}, 'general');
+        expect(result).toContain('description');
+        expect(result).toContain('upsert_key');
+    });
+});
+// ============================================================
+// 8. Type alias resolution (feedback → general)
+// ============================================================
+describe('type alias resolution', () => {
+    it('feedback resolves to general in inferDelivery', () => {
+        expect(inferDelivery('feedback')).toBe(inferDelivery('general'));
+    });
+    it('feedback is recognized as registered', () => {
+        expect(isRegisteredType('feedback')).toBe(true);
+    });
+    it('unknown aliases pass through unchanged', () => {
+        expect(isRegisteredType('totally-unknown')).toBe(false);
+        expect(inferDelivery('totally-unknown')).toBe('knowledge');
+    });
+});
+// ============================================================
+// 9. Edge cases
+// ============================================================
+describe('edge cases', () => {
+    it('empty config file (no types key) falls back to built-ins', () => {
+        mockConfigState.current = {};
+        const registry = getTypeRegistry();
+        expect(registry).toEqual(BUILTIN_TYPES);
+    });
+    it('config with empty types object works', () => {
+        mockConfigState.current = { types: {} };
+        const registry = getTypeRegistry();
+        expect(registry).toEqual(BUILTIN_TYPES);
+    });
+    it('overriding a built-in then unsetting reverts to default', () => {
+        setUserTypes({ 'code-craft': 'knowledge' });
+        expect(inferDelivery('code-craft')).toBe('knowledge');
+        // Simulate unsetting — remove from user types
+        mockConfigState.current = {};
+        expect(inferDelivery('code-craft')).toBe('persona'); // reverts to built-in
+    });
+    it('registering mid-session is immediately visible', () => {
+        expect(getRegisteredTypes()).not.toContain('wine-log');
+        registerType('wine-log', 'project');
+        expect(getRegisteredTypes()).toContain('wine-log');
+        expect(inferDelivery('wine-log')).toBe('project');
+    });
+});

package/dist/mcp-server.js

@@ -4,7 +4,7 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { createClient } from '@supabase/supabase-js';
 import OpenAI from 'openai';
 import { z } from 'zod';
-import { opSearchNotes, opListNotes, opAddNote, opUpdateNote, opUpdateMetadata, opDeleteNote, } from './lib/notes.js';
+import { opSearchNotes, opListNotes, opAddNote, opUpdateNote, opUpdateMetadata, opDeleteNote, getTypeRegistry, } from './lib/notes.js';
 // --- Clients ---
 const supabaseUrl = process.env.SUPABASE_URL;
 const supabaseKey = process.env.SUPABASE_SERVICE_ROLE_KEY;
@@ -21,6 +21,11 @@ const clients = {
     supabase: createClient(supabaseUrl, supabaseKey),
     openai: new OpenAI({ apiKey: openaiKey }),
 };
+// Build dynamic type description from registry
+const typeRegistry = getTypeRegistry();
+const typeList = Object.entries(typeRegistry)
+    .map(([t, d]) => `${t} (${d})`)
+    .join(', ');
 // --- MCP Server ---
 const server = new McpServer({
     name: 'ledger',
@@ -40,12 +45,13 @@ server.tool('search_notes', 'Search memories by meaning using semantic similarit
 // Tool: Add a new note
 server.tool('add_note', 'Save a new memory/note to the knowledge base. Large notes are automatically chunked for embedding. Use upsert_key in metadata to update an existing note instead of creating a duplicate.', {
     content: z.string().describe('The note content to save'),
-    type: z.enum(['user-preference', 'feedback', 'architecture-decision', 'project-status', 'reference', 'event', 'error', 'knowledge-guide', 'general']).describe('Note type for consistent categorization'),
+    type: z.string().describe(`Note type. Registered: ${typeList}. Unknown types will prompt for registration.`),
     agent: z.string().describe('Which agent is saving this note (e.g. claude-code, zhuli)'),
     metadata: z.record(z.string(), z.unknown()).default({}).describe('Optional metadata (project, local_file, upsert_key, etc.)'),
     force: z.boolean().default(false).describe('Skip duplicate check and force creation of a new note'),
-}, async ({ content, type, agent, metadata, force }) => {
-    const result = await opAddNote(clients, content, type, agent, metadata, force);
+    register_type: z.boolean().default(false).describe('Set to true to register an unknown type before saving. Pass delivery in metadata if not using default (knowledge).'),
+}, async ({ content, type, agent, metadata, force, register_type }) => {
+    const result = await opAddNote(clients, content, type, agent, metadata, force, register_type);
     return { content: [{ type: 'text', text: result.message }] };
 });
 // Tool: Update an existing note by ID
@@ -75,12 +81,13 @@ server.tool('delete_note', 'Delete a note from the knowledge base by ID. If the
     const result = await opDeleteNote(clients, id, confirmed);
     return { content: [{ type: 'text', text: result.message }] };
 });
-// Tool: Update metadata only (no content change, no confirmation needed)
-server.tool('update_metadata', 'Update metadata fields on an existing note without changing content. Useful for adding descriptions, tags, project, or scope.', {
+// Tool: Update metadata only (confirmation required for protected notes)
+server.tool('update_metadata', 'Update metadata fields on an existing note without changing content. Useful for adding descriptions, tags, project, or scope. Protected notes (delivery: protected) require confirmed: true.', {
     id: z.coerce.number().describe('The note ID to update'),
     metadata: z.record(z.string(), z.unknown()).describe('Metadata fields to merge (existing fields are preserved unless overwritten)'),
-}, async ({ id, metadata }) => {
-    const result = await opUpdateMetadata(clients, id, metadata);
+    confirmed: z.boolean().default(false).describe('Set to true to confirm update of protected notes. Required when the note has delivery: protected.'),
+}, async ({ id, metadata, confirmed }) => {
+    const result = await opUpdateMetadata(clients, id, metadata, confirmed);
     return { content: [{ type: 'text', text: result.message }] };
 });
 // --- Start ---

package/dist/migrations/migrations/004-upsert-key-unique.sql

@@ -0,0 +1,6 @@
+-- Partial unique index on upsert_key (only where not null)
+-- Using INDEX instead of CONSTRAINT because JSONB->>key expressions
+-- can't be used in ALTER TABLE ADD CONSTRAINT
+CREATE UNIQUE INDEX IF NOT EXISTS uq_upsert_key
+  ON notes ((metadata->>'upsert_key'))
+  WHERE metadata->>'upsert_key' IS NOT NULL;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aperdomoll90/ledger-ai",
-  "version": "1.1.3",
+  "version": "1.3.0",
   "description": "AI identity and memory system — portable persona, knowledge sync, semantic search across agents and devices",
   "type": "module",
   "bin": {