@pcircle/footprint 1.1.1 → 1.2.1

package/dist/index.js

@@ -1,694 +0,0 @@
-#!/usr/bin/env node
-import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { EvidenceDatabase, getCurrentCommit } from './lib/storage/index.js';
-import { deriveKey, encrypt, decrypt } from './lib/crypto/index.js';
-import { registerUIResources } from './ui/register.js';
-import * as z from 'zod';
-import * as crypto from 'crypto';
-function getErrorMessage(error) {
-    return error instanceof Error ? error.message : 'Unknown error';
-}
-/**
- * EvidenceMCP Server - Captures LLM conversations as encrypted footprint
- * with Git timestamps and export capabilities.
- */
-export class EvidenceMCPServer {
-    server;
-    config;
-    db;
-    derivedKey = null;
-    constructor(config) {
-        this.config = config;
-        try {
-            this.db = new EvidenceDatabase(config.dbPath);
-        }
-        catch (error) {
-            throw new Error(`Failed to initialize database: ${getErrorMessage(error)}`);
-        }
-        this.server = new McpServer({
-            name: config.name || 'traceguard-mcp',
-            version: config.version || '0.1.0'
-        });
-        // Register UI resources for MCP Apps
-        registerUIResources(this.server);
-        this.registerTools();
-        this.registerResources();
-    }
-    async getDerivedKey() {
-        if (!this.derivedKey) {
-            const result = await deriveKey(this.config.password);
-            this.derivedKey = result.key;
-        }
-        return this.derivedKey;
-    }
-    registerTools() {
-        this.server.registerTool('capture-footprint', {
-            title: 'Capture Footprint',
-            description: 'Capture and encrypt LLM conversation as footprint',
-            inputSchema: {
-                conversationId: z.string().describe('Conversation ID'),
-                llmProvider: z.string().describe('LLM provider name (e.g., Claude Sonnet 4.5)'),
-                content: z.string().describe('Conversation content (messages, prompts, responses)'),
-                messageCount: z.number().int().positive().describe('Number of messages'),
-                tags: z.string().optional().describe('Optional tags (comma-separated)')
-            },
-            outputSchema: {
-                id: z.string(),
-                timestamp: z.string(),
-                gitCommitHash: z.string().nullable(),
-                success: z.boolean()
-            }
-        }, async (params) => {
-            try {
-                if (!params.content || params.content.trim().length === 0) {
-                    throw new Error('Content cannot be empty');
-                }
-                if (params.messageCount <= 0) {
-                    throw new Error('Message count must be positive');
-                }
-                const key = await this.getDerivedKey();
-                const encrypted = await encrypt(params.content, key);
-                const gitInfo = await getCurrentCommit();
-                const contentHash = crypto.createHash('sha256').update(params.content).digest('hex');
-                const id = this.db.create({
-                    timestamp: new Date().toISOString(),
-                    conversationId: params.conversationId,
-                    llmProvider: params.llmProvider,
-                    encryptedContent: encrypted.ciphertext,
-                    nonce: encrypted.nonce,
-                    contentHash,
-                    messageCount: params.messageCount,
-                    gitCommitHash: gitInfo?.commitHash || null,
-                    gitTimestamp: gitInfo?.timestamp || null,
-                    tags: params.tags || null
-                });
-                return {
-                    content: [{ type: 'text', text: `✅ Evidence captured successfully\n- ID: ${id}\n- Timestamp: ${new Date().toISOString()}\n- Git Commit: ${gitInfo?.commitHash || 'N/A'}\n- Message Count: ${params.messageCount}` }],
-                    structuredContent: {
-                        id,
-                        timestamp: new Date().toISOString(),
-                        gitCommitHash: gitInfo?.commitHash || null,
-                        success: true
-                    }
-                };
-            }
-            catch (error) {
-                throw new Error(`[Tool: capture-footprint] ${getErrorMessage(error)}. Suggested action: Check content is not empty and messageCount is positive.`);
-            }
-        });
-        this.server.registerTool('list-footprints', {
-            title: 'List Footprints',
-            description: 'List all captured footprint with pagination',
-            inputSchema: {
-                limit: z.number().int().positive().optional().describe('Maximum results'),
-                offset: z.number().int().min(0).optional().describe('Pagination offset')
-            },
-            outputSchema: {
-                evidences: z.array(z.object({
-                    id: z.string(),
-                    timestamp: z.string(),
-                    conversationId: z.string(),
-                    llmProvider: z.string(),
-                    messageCount: z.number(),
-                    tags: z.string().nullable()
-                })),
-                total: z.number()
-            },
-            _meta: {
-                ui: {
-                    resourceUri: "ui://footprint/dashboard.html"
-                }
-            }
-        }, async (params) => {
-            try {
-                if (params.limit !== undefined && params.limit <= 0) {
-                    throw new Error('Limit must be positive');
-                }
-                if (params.offset !== undefined && params.offset < 0) {
-                    throw new Error('Offset cannot be negative');
-                }
-                const evidences = this.db.list({ limit: params.limit, offset: params.offset });
-                const mappedEvidences = evidences.map(e => ({
-                    id: e.id,
-                    timestamp: e.timestamp,
-                    conversationId: e.conversationId,
-                    llmProvider: e.llmProvider,
-                    messageCount: e.messageCount,
-                    tags: e.tags
-                }));
-                return {
-                    content: [{ type: 'text', text: `✅ Footprint list retrieved successfully\n- Count: ${evidences.length} footprint(s)\n- Limit: ${params.limit || 'No limit'}\n- Offset: ${params.offset || 0}` }],
-                    structuredContent: { evidences: mappedEvidences, total: evidences.length }
-                };
-            }
-            catch (error) {
-                throw new Error(`[Tool: list-footprints] ${getErrorMessage(error)}. Suggested action: Ensure limit is positive and offset is non-negative.`);
-            }
-        });
-        this.server.registerTool('export-footprints', {
-            title: 'Export Footprints',
-            description: 'Export footprints to encrypted ZIP archive',
-            inputSchema: {
-                evidenceIds: z.array(z.string()).optional().describe('Specific IDs (empty = all)'),
-                includeGitInfo: z.boolean().optional().describe('Include Git timestamps')
-            },
-            outputSchema: {
-                filename: z.string(),
-                checksum: z.string(),
-                evidenceCount: z.number(),
-                success: z.boolean()
-            },
-            _meta: {
-                ui: {
-                    resourceUri: "ui://footprint/export.html"
-                }
-            }
-        }, async (params) => {
-            try {
-                const { exportEvidences } = await import('./lib/storage/index.js');
-                const fs = await import('fs');
-                const result = await exportEvidences(this.db, {
-                    evidenceIds: params.evidenceIds,
-                    includeGitInfo: params.includeGitInfo ?? false
-                });
-                fs.writeFileSync(result.filename, result.zipData);
-                return {
-                    content: [{ type: 'text', text: `✅ Export completed successfully\n- Footprint Count: ${result.evidenceCount}\n- Filename: ${result.filename}\n- Checksum: ${result.checksum}\n- Git Info: ${params.includeGitInfo ? 'Included' : 'Excluded'}` }],
-                    structuredContent: {
-                        filename: result.filename,
-                        checksum: result.checksum,
-                        evidenceCount: result.evidenceCount,
-                        success: true
-                    }
-                };
-            }
-            catch (error) {
-                throw new Error(`[Tool: export-footprints] ${getErrorMessage(error)}. Suggested action: Check evidenceIds exist and filesystem has write permissions.`);
-            }
-        });
-        this.server.registerTool('get-footprint', {
-            title: 'Get Footprint',
-            description: 'Retrieve and decrypt specific footprint by ID',
-            inputSchema: {
-                id: z.string().describe('Footprint ID')
-            },
-            outputSchema: {
-                id: z.string(),
-                timestamp: z.string(),
-                conversationId: z.string(),
-                llmProvider: z.string(),
-                content: z.string(),
-                messageCount: z.number(),
-                gitInfo: z.object({
-                    commitHash: z.string(),
-                    timestamp: z.string()
-                }).nullable(),
-                tags: z.string().nullable()
-            },
-            _meta: {
-                ui: {
-                    resourceUri: "ui://footprint/detail.html"
-                }
-            }
-        }, async (params) => {
-            try {
-                const evidence = this.db.findById(params.id);
-                if (!evidence) {
-                    throw new Error(`Evidence not found: ${params.id}`);
-                }
-                const key = await this.getDerivedKey();
-                const decrypted = decrypt(evidence.encryptedContent, evidence.nonce, key);
-                const gitInfo = evidence.gitCommitHash
-                    ? { commitHash: evidence.gitCommitHash, timestamp: evidence.gitTimestamp }
-                    : null;
-                return {
-                    content: [{ type: 'text', text: `✅ Evidence retrieved successfully\n- ID: ${evidence.id}\n- Timestamp: ${evidence.timestamp}\n- Provider: ${evidence.llmProvider}\n- Message Count: ${evidence.messageCount}\n- Content Preview: ${decrypted.substring(0, 100)}...` }],
-                    structuredContent: {
-                        id: evidence.id,
-                        timestamp: evidence.timestamp,
-                        conversationId: evidence.conversationId,
-                        llmProvider: evidence.llmProvider,
-                        content: decrypted,
-                        messageCount: evidence.messageCount,
-                        gitInfo,
-                        tags: evidence.tags
-                    }
-                };
-            }
-            catch (error) {
-                throw new Error(`[Tool: get-footprint] ${getErrorMessage(error)}. Suggested action: Verify the evidence ID exists and password is correct.`);
-            }
-        });
-        this.server.registerTool('search-footprints', {
-            title: 'Search Footprints',
-            description: 'Search and filter footprints by query, tags, or date range',
-            inputSchema: {
-                query: z.string().optional().describe('Search text (matches conversationId, tags)'),
-                tags: z.array(z.string()).optional().describe('Filter by tags'),
-                dateFrom: z.string().optional().describe('Start date (ISO format)'),
-                dateTo: z.string().optional().describe('End date (ISO format)'),
-                limit: z.number().int().positive().optional().describe('Maximum results'),
-                offset: z.number().int().min(0).optional().describe('Pagination offset')
-            },
-            outputSchema: {
-                evidences: z.array(z.object({
-                    id: z.string(),
-                    timestamp: z.string(),
-                    conversationId: z.string(),
-                    llmProvider: z.string(),
-                    messageCount: z.number(),
-                    tags: z.string().nullable()
-                })),
-                total: z.number()
-            }
-        }, async (params) => {
-            try {
-                // Validate parameters
-                if (params.limit !== undefined && params.limit <= 0) {
-                    throw new Error('Limit must be positive');
-                }
-                if (params.offset !== undefined && params.offset < 0) {
-                    throw new Error('Offset cannot be negative');
-                }
-                // Validate date format if provided
-                if (params.dateFrom) {
-                    const date = new Date(params.dateFrom);
-                    if (isNaN(date.getTime())) {
-                        throw new Error('dateFrom must be a valid ISO date string');
-                    }
-                }
-                if (params.dateTo) {
-                    const date = new Date(params.dateTo);
-                    if (isNaN(date.getTime())) {
-                        throw new Error('dateTo must be a valid ISO date string');
-                    }
-                }
-                const evidences = this.db.search({
-                    query: params.query,
-                    tags: params.tags,
-                    dateFrom: params.dateFrom,
-                    dateTo: params.dateTo,
-                    limit: params.limit,
-                    offset: params.offset
-                });
-                const mappedEvidences = evidences.map(e => ({
-                    id: e.id,
-                    timestamp: e.timestamp,
-                    conversationId: e.conversationId,
-                    llmProvider: e.llmProvider,
-                    messageCount: e.messageCount,
-                    tags: e.tags
-                }));
-                return {
-                    content: [{ type: 'text', text: `✅ Search completed successfully\n- Results: ${evidences.length} footprint(s) found\n- Query: ${params.query || 'None'}\n- Tags: ${params.tags?.join(', ') || 'None'}\n- Date Range: ${params.dateFrom || 'Start'} to ${params.dateTo || 'End'}` }],
-                    structuredContent: { evidences: mappedEvidences, total: evidences.length }
-                };
-            }
-            catch (error) {
-                throw new Error(`[Tool: search-footprints] ${getErrorMessage(error)}. Suggested action: Check date format (ISO 8601), limit > 0, and offset >= 0.`);
-            }
-        });
-        this.server.registerTool('verify-footprint', {
-            title: 'Verify Footprint',
-            description: 'Verify the integrity and authenticity of captured footprint',
-            inputSchema: {
-                id: z.string().describe('Footprint ID to verify')
-            },
-            outputSchema: {
-                id: z.string(),
-                verified: z.boolean(),
-                checks: z.object({
-                    contentIntegrity: z.object({
-                        passed: z.boolean(),
-                        hash: z.string()
-                    }),
-                    gitTimestamp: z.object({
-                        passed: z.boolean(),
-                        commitHash: z.string().nullable(),
-                        timestamp: z.string().nullable()
-                    }),
-                    encryptionStatus: z.object({
-                        passed: z.boolean(),
-                        algorithm: z.string()
-                    })
-                }),
-                legalReadiness: z.boolean(),
-                verifiedAt: z.string()
-            }
-        }, async (params) => {
-            try {
-                // Find the footprint record
-                const evidence = this.db.findById(params.id);
-                if (!evidence) {
-                    throw new Error(`Evidence with ID ${params.id} not found`);
-                }
-                const key = await this.getDerivedKey();
-                // Perform verifications
-                const checks = {
-                    contentIntegrity: { passed: false, hash: '' },
-                    gitTimestamp: { passed: false, commitHash: null, timestamp: null },
-                    encryptionStatus: { passed: false, algorithm: 'XChaCha20-Poly1305' }
-                };
-                // 1. Content Integrity: Decrypt content, compute SHA-256 hash, verify it matches stored contentHash
-                try {
-                    const decryptedContent = decrypt(evidence.encryptedContent, evidence.nonce, key);
-                    const computedHash = crypto.createHash('sha256').update(decryptedContent).digest('hex');
-                    checks.contentIntegrity.passed = computedHash === evidence.contentHash;
-                    checks.contentIntegrity.hash = computedHash;
-                }
-                catch (error) {
-                    checks.contentIntegrity.passed = false;
-                    checks.contentIntegrity.hash = '';
-                }
-                // 2. Git Timestamp: Check if gitCommitHash exists and gitTimestamp is valid
-                checks.gitTimestamp.commitHash = evidence.gitCommitHash;
-                checks.gitTimestamp.timestamp = evidence.gitTimestamp;
-                checks.gitTimestamp.passed = !!(evidence.gitCommitHash && evidence.gitTimestamp);
-                // 3. Encryption Status: Verify decryption works (XChaCha20-Poly1305)
-                try {
-                    decrypt(evidence.encryptedContent, evidence.nonce, key);
-                    checks.encryptionStatus.passed = true;
-                }
-                catch (error) {
-                    checks.encryptionStatus.passed = false;
-                }
-                const verified = checks.contentIntegrity.passed && checks.gitTimestamp.passed && checks.encryptionStatus.passed;
-                const legalReadiness = verified;
-                const statusSymbols = {
-                    content: checks.contentIntegrity.passed ? '✓' : '✗',
-                    git: checks.gitTimestamp.passed ? '✓' : '✗',
-                    encryption: checks.encryptionStatus.passed ? '✓' : '✗'
-                };
-                const statusText = verified
-                    ? `✅ Evidence ${params.id} verified successfully\n- Content: ${statusSymbols.content} Integrity preserved\n- Git: ${statusSymbols.git} Timestamp verified\n- Encryption: ${statusSymbols.encryption} XChaCha20-Poly1305`
-                    : `❌ Evidence ${params.id} verification failed\n- Content: ${statusSymbols.content} Integrity check\n- Git: ${statusSymbols.git} Timestamp check\n- Encryption: ${statusSymbols.encryption} Decryption check`;
-                return {
-                    content: [{ type: 'text', text: statusText }],
-                    structuredContent: {
-                        id: params.id,
-                        verified,
-                        checks,
-                        legalReadiness,
-                        verifiedAt: new Date().toISOString()
-                    }
-                };
-            }
-            catch (error) {
-                throw new Error(`[Tool: verify-footprint] ${getErrorMessage(error)}. Suggested action: Verify the evidence ID exists and encryption password is correct.`);
-            }
-        });
-        this.server.registerTool('suggest-capture', {
-            title: 'Suggest Capture',
-            description: 'Analyze conversation content and suggest whether to capture it as evidence',
-            inputSchema: {
-                summary: z.string().describe('Conversation summary or key content to analyze')
-            },
-            outputSchema: {
-                shouldCapture: z.boolean(),
-                reason: z.string(),
-                suggestedTags: z.array(z.string()),
-                suggestedConversationId: z.string(),
-                confidence: z.number()
-            }
-        }, async (params) => {
-            try {
-                if (!params.summary || params.summary.trim().length === 0) {
-                    throw new Error('Summary cannot be empty');
-                }
-                const summary = params.summary.toLowerCase();
-                // Define keyword categories for detection
-                const keywordCategories = {
-                    ip: ['patent', 'intellectual property', 'invention', 'algorithm', 'proprietary', 'innovation', 'design'],
-                    legal: ['contract', 'agreement', 'legal', 'copyright', 'license', 'terms', 'clause', 'liability'],
-                    business: ['decision', 'milestone', 'deliverable', 'approval', 'strategy', 'roadmap', 'budget', 'timeline'],
-                    research: ['hypothesis', 'findings', 'proof', 'research', 'study', 'experiment', 'analysis', 'data'],
-                    compliance: ['audit', 'compliance', 'evidence', 'documentation', 'regulation', 'policy', 'requirement']
-                };
-                // Helper: match whole words only (avoid false positives like "logarithm" matching "algorithm")
-                const matchesWord = (text, word) => {
-                    const regex = new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'i');
-                    return regex.test(text);
-                };
-                // Detect matching categories and keywords
-                const matches = [];
-                let totalKeywords = 0;
-                for (const [category, keywords] of Object.entries(keywordCategories)) {
-                    const foundKeywords = keywords.filter(keyword => matchesWord(summary, keyword));
-                    if (foundKeywords.length > 0) {
-                        const weight = foundKeywords.length / keywords.length;
-                        matches.push({ category, keywords: foundKeywords, weight });
-                        totalKeywords += foundKeywords.length;
-                    }
-                }
-                // Determine if should capture
-                const shouldCapture = matches.length > 0;
-                // Calculate confidence: represents likelihood content is worth capturing
-                // High confidence (>0.7) = definitely important
-                // Low confidence (<0.5) = probably not important
-                let confidence;
-                if (shouldCapture) {
-                    // More keywords and categories = higher importance confidence
-                    const keywordDensity = totalKeywords / Math.max(summary.split(/\s+/).length, 1);
-                    const categoryBonus = matches.length * 0.15;
-                    const keywordBonus = Math.min(totalKeywords * 0.1, 0.4);
-                    confidence = Math.min(0.95, 0.3 + categoryBonus + keywordBonus + keywordDensity);
-                }
-                else {
-                    // No keywords found = low importance confidence
-                    // Longer text without keywords = slightly higher (might have missed something)
-                    const wordCount = summary.split(/\s+/).length;
-                    const lengthFactor = Math.min(wordCount / 200, 0.3); // Max 0.3 for very long text
-                    confidence = 0.1 + lengthFactor; // Range: 0.1 to 0.4
-                }
-                // Generate reason
-                let reason;
-                if (shouldCapture) {
-                    const categories = matches.map(m => m.category === 'ip' ? 'IP' : m.category);
-                    if (categories.length === 1) {
-                        reason = `Contains ${categories[0]} keywords: ${matches[0].keywords.join(', ')}`;
-                    }
-                    else {
-                        reason = `Contains multiple important categories: ${categories.join(', ')}`;
-                    }
-                }
-                else {
-                    reason = 'Appears to be casual conversation with no critical business, legal, or IP content';
-                }
-                // Generate suggested tags
-                const suggestedTags = shouldCapture
-                    ? [...new Set(matches.flatMap(m => [m.category, ...m.keywords.slice(0, 2)]))]
-                    : [];
-                // Generate conversation ID
-                const currentDate = new Date().toISOString().slice(0, 10);
-                let conversationId;
-                if (shouldCapture && matches.length > 0) {
-                    // Extract key terms for ID generation
-                    const primaryKeywords = matches[0].keywords.slice(0, 2);
-                    const cleanKeywords = primaryKeywords
-                        .map(k => k.replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, ''))
-                        .filter(k => k.length > 0);
-                    if (cleanKeywords.length > 0) {
-                        conversationId = `${cleanKeywords.join('-')}-${currentDate}`;
-                    }
-                    else {
-                        conversationId = `${matches[0].category}-discussion-${currentDate}`;
-                    }
-                }
-                else {
-                    conversationId = `conversation-${currentDate}`;
-                }
-                const resultText = shouldCapture
-                    ? `💡 Capture suggested (${Math.round(confidence * 100)}% confidence)\n🔍 Reason: ${reason}\n🏷️  Tags: ${suggestedTags.join(', ')}\n📝 ID: ${conversationId}`
-                    : `🤷 Capture not recommended (${Math.round(confidence * 100)}% confidence)\n💬 ${reason}`;
-                return {
-                    content: [{ type: 'text', text: resultText }],
-                    structuredContent: {
-                        shouldCapture,
-                        reason,
-                        suggestedTags,
-                        suggestedConversationId: conversationId,
-                        confidence: Math.round(confidence * 100) / 100
-                    }
-                };
-            }
-            catch (error) {
-                throw new Error(`[Tool: suggest-capture] ${getErrorMessage(error)}`);
-            }
-        });
-        // Delete evidences tool
-        this.server.registerTool('delete-footprints', {
-            title: 'Delete Footprints',
-            description: 'Permanently delete one or more footprint records',
-            inputSchema: {
-                evidenceIds: z.array(z.string()).min(1).describe('Array of footprint IDs to delete')
-            },
-            outputSchema: {
-                deletedCount: z.number(),
-                success: z.boolean()
-            }
-        }, async (params) => {
-            try {
-                if (!params.evidenceIds || params.evidenceIds.length === 0) {
-                    throw new Error('At least one evidence ID is required');
-                }
-                const deletedCount = this.db.deleteMany(params.evidenceIds);
-                const success = deletedCount > 0;
-                const resultText = success
-                    ? `🗑️ Successfully deleted ${deletedCount} footprint record${deletedCount > 1 ? 's' : ''}`
-                    : `⚠️ No footprint records found with the provided IDs`;
-                return {
-                    content: [{ type: 'text', text: resultText }],
-                    structuredContent: { deletedCount, success }
-                };
-            }
-            catch (error) {
-                throw new Error(`[Tool: delete-footprints] ${getErrorMessage(error)}. Suggested action: Verify the footprint IDs exist.`);
-            }
-        });
-        // Rename tag tool
-        this.server.registerTool('rename-tag', {
-            title: 'Rename Tag',
-            description: 'Rename a tag across all footprint records',
-            inputSchema: {
-                oldTag: z.string().min(1).describe('Current tag name to rename'),
-                newTag: z.string().min(1).describe('New tag name')
-            },
-            outputSchema: {
-                updatedCount: z.number(),
-                success: z.boolean()
-            }
-        }, async (params) => {
-            try {
-                if (!params.oldTag || !params.newTag) {
-                    throw new Error('Both old and new tag names are required');
-                }
-                if (params.oldTag.trim() === params.newTag.trim()) {
-                    throw new Error('New tag must be different from old tag');
-                }
-                const updatedCount = this.db.renameTag(params.oldTag.trim(), params.newTag.trim());
-                const success = updatedCount > 0;
-                const resultText = success
-                    ? `🏷️ Renamed tag "${params.oldTag}" to "${params.newTag}" in ${updatedCount} footprint record${updatedCount > 1 ? 's' : ''}`
-                    : `⚠️ No footprint records found with tag "${params.oldTag}"`;
-                return {
-                    content: [{ type: 'text', text: resultText }],
-                    structuredContent: { updatedCount, success }
-                };
-            }
-            catch (error) {
-                throw new Error(`[Tool: rename-tag] ${getErrorMessage(error)}`);
-            }
-        });
-        // Remove tag tool
-        this.server.registerTool('remove-tag', {
-            title: 'Remove Tag',
-            description: 'Remove a tag from all footprint records',
-            inputSchema: {
-                tag: z.string().min(1).describe('Tag name to remove')
-            },
-            outputSchema: {
-                updatedCount: z.number(),
-                success: z.boolean()
-            }
-        }, async (params) => {
-            try {
-                if (!params.tag) {
-                    throw new Error('Tag name is required');
-                }
-                const updatedCount = this.db.removeTag(params.tag.trim());
-                const success = updatedCount > 0;
-                const resultText = success
-                    ? `🗑️ Removed tag "${params.tag}" from ${updatedCount} footprint record${updatedCount > 1 ? 's' : ''}`
-                    : `⚠️ No footprint records found with tag "${params.tag}"`;
-                return {
-                    content: [{ type: 'text', text: resultText }],
-                    structuredContent: { updatedCount, success }
-                };
-            }
-            catch (error) {
-                throw new Error(`[Tool: remove-tag] ${getErrorMessage(error)}`);
-            }
-        });
-        // Get tag statistics tool
-        this.server.registerTool('get-tag-stats', {
-            title: 'Get Tag Statistics',
-            description: 'Get all unique tags with their usage counts',
-            inputSchema: {},
-            outputSchema: {
-                tags: z.array(z.object({
-                    tag: z.string(),
-                    count: z.number()
-                })),
-                totalTags: z.number()
-            }
-        }, async () => {
-            try {
-                const tagCounts = this.db.getTagCounts();
-                const tags = Array.from(tagCounts.entries())
-                    .map(([tag, count]) => ({ tag, count }))
-                    .sort((a, b) => b.count - a.count);
-                const resultText = tags.length > 0
-                    ? `📊 Tag Statistics:\n${tags.map(t => `  • ${t.tag}: ${t.count}`).join('\n')}`
-                    : `📊 No tags found in any footprint records`;
-                return {
-                    content: [{ type: 'text', text: resultText }],
-                    structuredContent: { tags, totalTags: tags.length }
-                };
-            }
-            catch (error) {
-                throw new Error(`[Tool: get-tag-stats] ${getErrorMessage(error)}`);
-            }
-        });
-    }
-    registerResources() {
-        this.server.registerResource('evidence', new ResourceTemplate('evidence://{id}', { list: undefined }), {
-            title: 'Evidence Content',
-            description: 'Access encrypted footprint record by ID',
-            mimeType: 'text/plain'
-        }, async (uri, { id }) => {
-            try {
-                const evidence = this.db.findById(id);
-                if (!evidence) {
-                    throw new Error(`Evidence with ID ${id} not found`);
-                }
-                const key = await this.getDerivedKey();
-                const decrypted = decrypt(evidence.encryptedContent, evidence.nonce, key);
-                return {
-                    contents: [{ uri: uri.href, mimeType: 'text/plain', text: decrypted }]
-                };
-            }
-            catch (error) {
-                throw new Error(`Failed to access evidence resource: ${getErrorMessage(error)}`);
-            }
-        });
-    }
-    async start() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-    }
-}
-async function main() {
-    const config = {
-        dbPath: process.env.EVIDENCEMCP_DB_PATH || './evidence.db',
-        password: process.env.EVIDENCEMCP_PASSWORD || ''
-    };
-    if (!config.password) {
-        console.error('Error: EVIDENCEMCP_PASSWORD environment variable required');
-        process.exit(1);
-    }
-    const server = new EvidenceMCPServer(config);
-    await server.start();
-}
-// Handle both direct execution and symlink execution
-const isMainModule = import.meta.url === `file://${process.argv[1]}` ||
-    process.argv[1]?.endsWith('/footprint') ||
-    process.argv[1]?.endsWith('/dist/index.js');
-if (isMainModule) {
-    main().catch((error) => {
-        console.error('Server error:', error);
-        process.exit(1);
-    });
-}
-export { EvidenceMCPTestHelpers } from './test-helpers.js';
-//# sourceMappingURL=index.js.map