@aperdomoll90/ledger-ai 1.0.0

package/dist/lib/generators.js

@@ -0,0 +1,115 @@
+// --- CLAUDE.md Section Mapping ---
+const SECTION_MAP = {
+    'Security': ['feedback-no-read-env'],
+    'Coding Conventions': ['feedback-coding-conventions'],
+    'Architecture': [
+        'feedback-mcp-registration',
+        'feedback-prefer-cli-and-skills',
+        'feedback-repo-docs-structure',
+        'feedback-project-logs',
+    ],
+    'Communication': ['feedback-communication-style'],
+};
+// --- Helpers ---
+function extractBulletPoints(content) {
+    const lines = content.split('\n');
+    const bullets = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('---') || trimmed.startsWith('#') || trimmed === '')
+            continue;
+        if (trimmed.startsWith('Why:') || trimmed.startsWith('**Why:**'))
+            continue;
+        if (trimmed.startsWith('How to apply:') || trimmed.startsWith('**How to apply:**'))
+            continue;
+        if (trimmed.startsWith('Follow these') ||
+            trimmed.startsWith('Never') ||
+            trimmed.startsWith('Always') ||
+            trimmed.startsWith('When') ||
+            trimmed.startsWith('Before')) {
+            bullets.push(`- ${trimmed}`);
+        }
+        else if (trimmed.startsWith('- ') || trimmed.startsWith('* ')) {
+            bullets.push(trimmed);
+        }
+    }
+    return bullets.join('\n');
+}
+// --- Generators ---
+export function generateClaudeMd(notes) {
+    const notesByKey = new Map();
+    for (const note of notes) {
+        const key = note.metadata.upsert_key;
+        if (key)
+            notesByKey.set(key, note);
+    }
+    const sections = ['# Global Rules'];
+    const usedKeys = new Set();
+    for (const [sectionName, keys] of Object.entries(SECTION_MAP)) {
+        const sectionBullets = [];
+        for (const key of keys) {
+            const note = notesByKey.get(key);
+            if (note) {
+                sectionBullets.push(extractBulletPoints(note.content));
+                usedKeys.add(key);
+            }
+        }
+        if (sectionBullets.length > 0) {
+            sections.push(`\n## ${sectionName}\n${sectionBullets.join('\n')}`);
+        }
+    }
+    const unmapped = [];
+    for (const note of notes) {
+        const key = note.metadata.upsert_key;
+        const type = note.metadata.type;
+        if (key && !usedKeys.has(key) && type === 'feedback') {
+            unmapped.push(extractBulletPoints(note.content));
+            usedKeys.add(key);
+        }
+    }
+    if (unmapped.length > 0) {
+        sections.push(`\n## General\n${unmapped.join('\n')}`);
+    }
+    return sections.join('\n') + '\n';
+}
+export function generateMemoryMd(files) {
+    const userFiles = [];
+    const feedbackFiles = [];
+    const projectFiles = [];
+    for (const file of files) {
+        if (file.startsWith('user_'))
+            userFiles.push(file);
+        else if (file.startsWith('feedback_'))
+            feedbackFiles.push(file);
+        else if (file.startsWith('project_'))
+            projectFiles.push(file);
+    }
+    const lines = [
+        '# Memory Index',
+        '',
+        'Local cache files auto-loaded into Claude Code context. Source of truth is Ledger.',
+        '',
+    ];
+    if (userFiles.length > 0) {
+        lines.push('## User Profile');
+        for (const f of userFiles)
+            lines.push(`- [${f}](${f})`);
+        lines.push('');
+    }
+    if (feedbackFiles.length > 0) {
+        lines.push('## Feedback (Behavioral Rules)');
+        for (const f of feedbackFiles)
+            lines.push(`- [${f}](${f})`);
+        lines.push('');
+    }
+    if (projectFiles.length > 0) {
+        lines.push('## Project Status');
+        for (const f of projectFiles)
+            lines.push(`- [${f}](${f})`);
+        lines.push('');
+    }
+    lines.push('## Not Auto-Loaded (Search Ledger)');
+    lines.push('Architecture, references, project details, events, errors — all in Ledger, search on demand.');
+    lines.push('');
+    return lines.join('\n');
+}

package/dist/lib/hash.js

@@ -0,0 +1,4 @@
+import { createHash } from 'crypto';
+export function contentHash(content) {
+    return createHash('sha256').update(content, 'utf-8').digest('hex');
+}

package/dist/lib/migrate.js

@@ -0,0 +1,23 @@
+import { readFileSync, readdirSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const MIGRATIONS_DIR = resolve(__dirname, '../migrations');
+export function getMigrationFiles() {
+    return readdirSync(MIGRATIONS_DIR)
+        .filter(f => f.endsWith('.sql'))
+        .sort();
+}
+export function readMigration(filename) {
+    return readFileSync(resolve(MIGRATIONS_DIR, filename), 'utf-8');
+}
+export async function getAppliedMigrations(supabase) {
+    const { data, error } = await supabase
+        .from('schema_migrations')
+        .select('version');
+    if (error) {
+        // Table doesn't exist yet — no migrations applied
+        return new Set();
+    }
+    return new Set((data || []).map(r => r.version));
+}

package/dist/lib/notes.js

@@ -0,0 +1,105 @@
+import { fatal, ExitCode } from './errors.js';
+import { contentHash } from './hash.js';
+// --- Queries ---
+export async function fetchCachedNotes(supabase) {
+    const { data: cachedNotes, error: cacheError } = await supabase
+        .from('notes')
+        .select('id, content, metadata, created_at, updated_at')
+        .eq('metadata->>local_cache', 'true');
+    if (cacheError) {
+        fatal(`Error querying Ledger: ${cacheError.message}`, ExitCode.SUPABASE_ERROR);
+    }
+    const { data: ruleNotes, error: ruleError } = await supabase
+        .from('notes')
+        .select('id, content, metadata, created_at, updated_at')
+        .in('metadata->>type', ['feedback', 'user-preference']);
+    if (ruleError) {
+        fatal(`Error querying rule notes: ${ruleError.message}`, ExitCode.SUPABASE_ERROR);
+    }
+    const allNotes = new Map();
+    for (const note of [...(cachedNotes || []), ...(ruleNotes || [])]) {
+        allNotes.set(note.id, note);
+    }
+    return Array.from(allNotes.values());
+}
+export async function findNoteByFile(supabase, filename) {
+    const { data: byFile } = await supabase
+        .from('notes')
+        .select('id, metadata')
+        .eq('metadata->>local_file', filename)
+        .limit(1)
+        .single();
+    if (byFile)
+        return byFile;
+    const upsertKey = filename.replace(/\.md$/, '');
+    const { data: byKey } = await supabase
+        .from('notes')
+        .select('id, metadata')
+        .eq('metadata->>upsert_key', upsertKey)
+        .limit(1)
+        .single();
+    return byKey || null;
+}
+export async function updateNoteContent(supabase, openai, noteId, content) {
+    const embeddingResponse = await openai.embeddings.create({
+        model: 'text-embedding-3-small',
+        input: content,
+    });
+    const embedding = embeddingResponse.data[0].embedding;
+    const { error } = await supabase
+        .from('notes')
+        .update({
+        content,
+        embedding,
+        updated_at: new Date().toISOString(),
+    })
+        .eq('id', noteId);
+    if (error) {
+        fatal(`Error updating note: ${error.message}`, ExitCode.SUPABASE_ERROR);
+    }
+}
+export async function searchNotes(supabase, openai, query, threshold = 0.3, maxResults = 1) {
+    const embeddingResponse = await openai.embeddings.create({
+        model: 'text-embedding-3-small',
+        input: query,
+    });
+    const embedding = embeddingResponse.data[0].embedding;
+    const { data, error } = await supabase.rpc('match_notes', {
+        q_emb: JSON.stringify(embedding),
+        threshold,
+        max_results: maxResults,
+    });
+    if (error) {
+        fatal(`Error searching Ledger: ${error.message}`, ExitCode.SUPABASE_ERROR);
+    }
+    return (data || []);
+}
+export async function fetchNoteHashes(supabase) {
+    const notes = await fetchCachedNotes(supabase);
+    return notes
+        .filter(n => n.metadata.local_file)
+        .map(n => ({
+        id: n.id,
+        localFile: n.metadata.local_file,
+        contentHash: n.metadata.content_hash || contentHash(n.content),
+        content: n.content,
+    }));
+}
+export async function updateNoteHash(supabase, noteId, hash) {
+    const { data: note, error: fetchError } = await supabase
+        .from('notes')
+        .select('metadata')
+        .eq('id', noteId)
+        .single();
+    if (fetchError) {
+        fatal(`Error fetching note metadata: ${fetchError.message}`, ExitCode.SUPABASE_ERROR);
+    }
+    const metadata = { ...note.metadata, content_hash: hash };
+    const { error } = await supabase
+        .from('notes')
+        .update({ metadata })
+        .eq('id', noteId);
+    if (error) {
+        fatal(`Error updating note hash: ${error.message}`, ExitCode.SUPABASE_ERROR);
+    }
+}

package/dist/lib/prompt.js

@@ -0,0 +1,65 @@
+import { createInterface } from 'readline';
+export async function ask(question) {
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stderr,
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+export async function askMasked(question) {
+    return new Promise((resolve) => {
+        process.stderr.write(question);
+        let input = '';
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.resume();
+        const onData = (buf) => {
+            const c = buf.toString();
+            if (c === '\n' || c === '\r') {
+                process.stdin.removeListener('data', onData);
+                if (process.stdin.isTTY) {
+                    process.stdin.setRawMode(false);
+                }
+                process.stdin.pause();
+                process.stderr.write('\n');
+                resolve(input.trim());
+            }
+            else if (c === '\u007f' || c === '\b') {
+                if (input.length > 0) {
+                    input = input.slice(0, -1);
+                    process.stderr.write('\b \b');
+                }
+            }
+            else if (c === '\u0003') {
+                // Ctrl+C
+                process.exit(1);
+            }
+            else {
+                input += c;
+                process.stderr.write('*');
+            }
+        };
+        process.stdin.on('data', onData);
+    });
+}
+export async function confirm(question) {
+    const answer = await ask(`${question} [y/N] `);
+    return answer === 'y' || answer === 'yes';
+}
+export async function choose(question, options) {
+    const optionList = options.map((o, i) => `  ${i + 1}. ${o}`).join('\n');
+    const answer = await ask(`${question}\n${optionList}\n> `);
+    const index = parseInt(answer, 10) - 1;
+    if (index >= 0 && index < options.length) {
+        return options[index];
+    }
+    // Try matching by name
+    const match = options.find(o => o.toLowerCase().startsWith(answer));
+    return match || options[0];
+}

package/dist/mcp-server.js

@@ -0,0 +1,348 @@
+import 'dotenv/config';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createClient } from '@supabase/supabase-js';
+import OpenAI from 'openai';
+import { z } from 'zod';
+import { randomUUID, createHash } from 'crypto';
+// --- Constants ---
+const MAX_CHARS_PER_CHUNK = 25_000;
+const CHUNK_OVERLAP = 2_000;
+// --- Clients ---
+const supabaseUrl = process.env.SUPABASE_URL;
+const supabaseKey = process.env.SUPABASE_SERVICE_ROLE_KEY;
+const openaiKey = process.env.OPENAI_API_KEY;
+if (!supabaseUrl || !supabaseKey) {
+    console.error('Missing SUPABASE_URL or SUPABASE_SERVICE_ROLE_KEY. Run `ledger init` to configure.');
+    process.exit(1);
+}
+if (!openaiKey) {
+    console.error('Missing OPENAI_API_KEY. Run `ledger init` to configure.');
+    process.exit(1);
+}
+const supabase = createClient(supabaseUrl, supabaseKey);
+const openai = new OpenAI({ apiKey: openaiKey });
+// --- Helpers ---
+function contentHash(text) {
+    return createHash('sha256').update(text, 'utf-8').digest('hex');
+}
+async function getEmbedding(text) {
+    const response = await openai.embeddings.create({
+        model: 'text-embedding-3-small',
+        input: text,
+    });
+    return response.data[0].embedding;
+}
+function chunkText(text, maxChars, overlap) {
+    if (text.length <= maxChars)
+        return [text];
+    const paragraphs = text.split(/\n\n+/);
+    const chunks = [];
+    let current = '';
+    for (const paragraph of paragraphs) {
+        if (current.length + paragraph.length + 2 > maxChars && current.length > 0) {
+            chunks.push(current.trim());
+            // Start next chunk with overlap from end of current
+            const overlapText = current.slice(-overlap);
+            current = overlapText + '\n\n' + paragraph;
+        }
+        else {
+            current = current ? current + '\n\n' + paragraph : paragraph;
+        }
+    }
+    if (current.trim()) {
+        chunks.push(current.trim());
+    }
+    // Edge case: a single paragraph exceeds maxChars — force split by character
+    return chunks.flatMap((chunk) => {
+        if (chunk.length <= maxChars)
+            return [chunk];
+        const forced = [];
+        for (let i = 0; i < chunk.length; i += maxChars - overlap) {
+            forced.push(chunk.slice(i, i + maxChars));
+        }
+        return forced;
+    });
+}
+// --- MCP Server ---
+const server = new McpServer({
+    name: 'ledger',
+    version: '1.0.0',
+});
+// Tool: Search notes by semantic similarity
+server.tool('search_notes', 'Search memories by meaning using semantic similarity. If a result is chunked, all sibling chunks are returned reassembled.', {
+    query: z.string().describe('What to search for'),
+    threshold: z.coerce.number().min(0).max(1).default(0.5).describe('Minimum similarity score (0-1)'),
+    limit: z.coerce.number().min(1).max(50).default(10).describe('Max results to return'),
+    type: z.string().optional().describe('Filter by note type (e.g. feedback, reference, event)'),
+    project: z.string().optional().describe('Filter by project name'),
+}, async ({ query, threshold, limit, type, project }) => {
+    const embedding = await getEmbedding(query);
+    // Fetch more results than needed so we can filter and still meet limit
+    const fetchLimit = (type || project) ? limit * 3 : limit;
+    const { data, error } = await supabase.rpc('match_notes', {
+        q_emb: JSON.stringify(embedding),
+        threshold,
+        max_results: fetchLimit,
+    });
+    if (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+    }
+    let results = data;
+    // Apply filters
+    if (type) {
+        results = results.filter(n => n.metadata.type === type);
+    }
+    if (project) {
+        results = results.filter(n => n.metadata.project === project);
+    }
+    results = results.slice(0, limit);
+    if (!results || results.length === 0) {
+        return { content: [{ type: 'text', text: 'No matching notes found.' }] };
+    }
+    // Reassemble chunked notes: fetch all sibling chunks for any chunked result
+    const seenGroups = new Set();
+    const output = [];
+    for (const note of results) {
+        const meta = note.metadata;
+        const groupId = meta.chunk_group;
+        if (groupId) {
+            if (seenGroups.has(groupId))
+                continue;
+            seenGroups.add(groupId);
+            // Fetch all chunks in this group, ordered by index
+            const { data: siblings, error: sibError } = await supabase
+                .from('notes')
+                .select('id, content, metadata, created_at')
+                .eq('metadata->>chunk_group', groupId)
+                .order('metadata->>chunk_index', { ascending: true });
+            if (sibError || !siblings || siblings.length === 0) {
+                output.push(`[${note.id}] (similarity: ${note.similarity.toFixed(3)}) [chunked, sibling fetch failed]\n${note.content}\nMetadata: ${JSON.stringify(note.metadata)}`);
+            }
+            else {
+                const reassembled = siblings.map((s) => s.content).join('\n\n');
+                const firstId = siblings[0].id;
+                const chunkCount = siblings.length;
+                output.push(`[${firstId}] (similarity: ${note.similarity.toFixed(3)}) [${chunkCount} chunks reassembled]\n${reassembled}\nMetadata: ${JSON.stringify({ ...meta, chunk_group: groupId, chunks: chunkCount })}`);
+            }
+        }
+        else {
+            output.push(`[${note.id}] (similarity: ${note.similarity.toFixed(3)})\n${note.content}\nMetadata: ${JSON.stringify(note.metadata)}`);
+        }
+    }
+    return { content: [{ type: 'text', text: output.join('\n\n---\n\n') }] };
+});
+// Tool: Add a new note (with automatic chunking for large content)
+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', 'general']).describe('Note type for consistent categorization'),
+    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.)'),
+}, async ({ content, type, agent, metadata }) => {
+    // Merge type and agent into metadata, include content hash
+    const fullMetadata = { ...metadata, type, agent, content_hash: contentHash(content) };
+    const upsertKey = metadata.upsert_key;
+    // If upsert_key provided, check for existing note and update it instead
+    if (upsertKey) {
+        const { data: existing } = await supabase
+            .from('notes')
+            .select('id, metadata')
+            .eq('metadata->>upsert_key', upsertKey)
+            .limit(1)
+            .single();
+        if (existing) {
+            // Delete old note (and its chunks if any)
+            const oldMeta = existing.metadata;
+            const oldGroup = oldMeta.chunk_group;
+            if (oldGroup) {
+                await supabase.from('notes').delete().eq('metadata->>chunk_group', oldGroup);
+            }
+            else {
+                await supabase.from('notes').delete().eq('id', existing.id);
+            }
+        }
+    }
+    const chunks = chunkText(content, MAX_CHARS_PER_CHUNK, CHUNK_OVERLAP);
+    if (chunks.length === 1) {
+        // Single note — no chunking needed
+        const embedding = await getEmbedding(content);
+        const { data, error } = await supabase
+            .from('notes')
+            .insert({ content, metadata: fullMetadata, embedding })
+            .select('id, created_at')
+            .single();
+        if (error) {
+            return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+        }
+        const uKey = fullMetadata.upsert_key;
+        const label = uKey || `id ${data.id}`;
+        const preview = content.length > 100 ? content.slice(0, 100) + '...' : content;
+        return {
+            content: [{ type: 'text', text: `Saved "${label}" (id: ${data.id}, type: ${type}, ${content.length} chars)\nPreview: ${preview}` }],
+        };
+    }
+    // Multiple chunks — embed and store each with shared group ID
+    const groupId = randomUUID();
+    const ids = [];
+    for (let i = 0; i < chunks.length; i++) {
+        const chunkMeta = {
+            ...fullMetadata,
+            chunk_group: groupId,
+            chunk_index: i,
+            total_chunks: chunks.length,
+        };
+        const embedding = await getEmbedding(chunks[i]);
+        const { data, error } = await supabase
+            .from('notes')
+            .insert({ content: chunks[i], metadata: chunkMeta, embedding })
+            .select('id')
+            .single();
+        if (error) {
+            return { content: [{ type: 'text', text: `Error saving chunk ${i + 1}/${chunks.length}: ${error.message}` }] };
+        }
+        ids.push(data.id);
+    }
+    return {
+        content: [{ type: 'text', text: `Saved "${fullMetadata.upsert_key || 'chunked'}" as ${chunks.length} chunks (ids: ${ids.join(', ')}, ${content.length} chars total)` }],
+    };
+});
+// Tool: Update an existing note by ID
+server.tool('update_note', 'Update an existing note by ID. Replaces content and re-generates embedding. If the note was chunked, all chunks are replaced.', {
+    id: z.coerce.number().describe('The note ID to update'),
+    content: z.string().describe('The new content'),
+    metadata: z.record(z.string(), z.unknown()).optional().describe('Optional: replace metadata (keeps existing if omitted)'),
+}, async ({ id, content, metadata }) => {
+    // Check if this note is part of a chunk group
+    const { data: existing, error: fetchError } = await supabase
+        .from('notes')
+        .select('id, metadata')
+        .eq('id', id)
+        .single();
+    if (fetchError || !existing) {
+        return { content: [{ type: 'text', text: `Error: note ${id} not found.` }] };
+    }
+    const existingMeta = existing.metadata;
+    const groupId = existingMeta.chunk_group;
+    const baseMeta = metadata ?? existingMeta;
+    // Delete old chunks if this was a chunked note
+    if (groupId) {
+        await supabase.from('notes').delete().eq('metadata->>chunk_group', groupId);
+    }
+    else {
+        await supabase.from('notes').delete().eq('id', id);
+    }
+    // Re-insert with chunking support
+    const chunks = chunkText(content, MAX_CHARS_PER_CHUNK, CHUNK_OVERLAP);
+    if (chunks.length === 1) {
+        const embedding = await getEmbedding(content);
+        // Remove old chunk metadata, add content hash
+        const { chunk_group, chunk_index, total_chunks, ...cleanMeta } = baseMeta;
+        const updatedMeta = { ...cleanMeta, content_hash: contentHash(content) };
+        const { data, error } = await supabase
+            .from('notes')
+            .insert({ content, metadata: updatedMeta, embedding })
+            .select('id, created_at')
+            .single();
+        if (error) {
+            return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+        }
+        const uKey = baseMeta.upsert_key;
+        const label = uKey || `id ${data.id}`;
+        const preview = content.length > 100 ? content.slice(0, 100) + '...' : content;
+        return {
+            content: [{ type: 'text', text: `Updated "${label}" (id: ${data.id}, ${content.length} chars)\nPreview: ${preview}` }],
+        };
+    }
+    const newGroupId = randomUUID();
+    const ids = [];
+    for (let i = 0; i < chunks.length; i++) {
+        const { chunk_group, chunk_index, total_chunks, ...cleanMeta } = baseMeta;
+        const chunkMeta = {
+            ...cleanMeta,
+            chunk_group: newGroupId,
+            chunk_index: i,
+            total_chunks: chunks.length,
+        };
+        const embedding = await getEmbedding(chunks[i]);
+        const { data, error } = await supabase
+            .from('notes')
+            .insert({ content: chunks[i], metadata: chunkMeta, embedding })
+            .select('id')
+            .single();
+        if (error) {
+            return { content: [{ type: 'text', text: `Error updating chunk ${i + 1}/${chunks.length}: ${error.message}` }] };
+        }
+        ids.push(data.id);
+    }
+    return {
+        content: [{ type: 'text', text: `Note updated as ${chunks.length} chunks (ids: ${ids.join(', ')}, group: ${newGroupId})` }],
+    };
+});
+// Tool: List recent notes
+server.tool('list_notes', 'List recent notes from the knowledge base', {
+    limit: z.coerce.number().min(1).max(100).default(20).describe('Number of notes to return'),
+    type: z.string().optional().describe('Filter by note type (e.g. feedback, reference, event)'),
+    project: z.string().optional().describe('Filter by project name'),
+}, async ({ limit, type, project }) => {
+    let query = supabase
+        .from('notes')
+        .select('id, content, metadata, created_at')
+        .order('created_at', { ascending: false })
+        .limit(limit);
+    if (type) {
+        query = query.eq('metadata->>type', type);
+    }
+    if (project) {
+        query = query.eq('metadata->>project', project);
+    }
+    const { data, error } = await query;
+    if (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+    }
+    const notes = data;
+    if (!notes || notes.length === 0) {
+        return { content: [{ type: 'text', text: 'No notes found.' }] };
+    }
+    const formatted = notes.map((note) => {
+        const meta = note.metadata;
+        const chunkInfo = meta.chunk_group ? ` [chunk ${meta.chunk_index + 1}/${meta.total_chunks}]` : '';
+        return `[${note.id}]${chunkInfo} ${note.created_at}\n${note.content.slice(0, 200)}${note.content.length > 200 ? '...' : ''}\nMetadata: ${JSON.stringify(note.metadata)}`;
+    }).join('\n\n---\n\n');
+    return { content: [{ type: 'text', text: formatted }] };
+});
+// Tool: Delete a note
+server.tool('delete_note', 'Delete a note from the knowledge base by ID. If the note is chunked, all chunks in the group are deleted.', {
+    id: z.coerce.number().describe('The note ID to delete'),
+}, async ({ id }) => {
+    // Check if this note is part of a chunk group
+    const { data: existing } = await supabase
+        .from('notes')
+        .select('metadata')
+        .eq('id', id)
+        .single();
+    if (existing) {
+        const meta = existing.metadata;
+        const groupId = meta.chunk_group;
+        if (groupId) {
+            const { error } = await supabase
+                .from('notes')
+                .delete()
+                .eq('metadata->>chunk_group', groupId);
+            if (error) {
+                return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+            }
+            return { content: [{ type: 'text', text: `Deleted all chunks in group ${groupId}.` }] };
+        }
+    }
+    const { error } = await supabase
+        .from('notes')
+        .delete()
+        .eq('id', id);
+    if (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+    }
+    return { content: [{ type: 'text', text: `Note ${id} deleted.` }] };
+});
+// --- Start ---
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/migrations/000-tracking.sql

@@ -0,0 +1,4 @@
+CREATE TABLE IF NOT EXISTS schema_migrations (
+  version text PRIMARY KEY,
+  applied_at timestamptz DEFAULT now()
+);