@pcircle/footprint 1.0.0

package/dist/index.js

@@ -0,0 +1,690 @@
+#!/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 evidence
+ * 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-evidence', {
+            title: 'Capture Evidence',
+            description: 'Capture and encrypt LLM conversation as evidence',
+            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-evidence] ${getErrorMessage(error)}. Suggested action: Check content is not empty and messageCount is positive.`);
+            }
+        });
+        this.server.registerTool('list-evidences', {
+            title: 'List Evidences',
+            description: 'List all captured evidence 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: `✅ Evidence list retrieved successfully\n- Count: ${evidences.length} evidence(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-evidences] ${getErrorMessage(error)}. Suggested action: Ensure limit is positive and offset is non-negative.`);
+            }
+        });
+        this.server.registerTool('export-evidences', {
+            title: 'Export Evidences',
+            description: 'Export evidences 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- Evidence 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-evidences] ${getErrorMessage(error)}. Suggested action: Check evidenceIds exist and filesystem has write permissions.`);
+            }
+        });
+        this.server.registerTool('get-evidence', {
+            title: 'Get Evidence',
+            description: 'Retrieve and decrypt specific evidence by ID',
+            inputSchema: {
+                id: z.string().describe('Evidence 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-evidence] ${getErrorMessage(error)}. Suggested action: Verify the evidence ID exists and password is correct.`);
+            }
+        });
+        this.server.registerTool('search-evidences', {
+            title: 'Search Evidences',
+            description: 'Search and filter evidences 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} evidence(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-evidences] ${getErrorMessage(error)}. Suggested action: Check date format (ISO 8601), limit > 0, and offset >= 0.`);
+            }
+        });
+        this.server.registerTool('verify-evidence', {
+            title: 'Verify Evidence',
+            description: 'Verify the integrity and authenticity of captured evidence',
+            inputSchema: {
+                id: z.string().describe('Evidence 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 evidence 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-evidence] ${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-evidences', {
+            title: 'Delete Evidences',
+            description: 'Permanently delete one or more evidence records',
+            inputSchema: {
+                evidenceIds: z.array(z.string()).min(1).describe('Array of evidence 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} evidence record${deletedCount > 1 ? 's' : ''}`
+                    : `⚠️ No evidence records found with the provided IDs`;
+                return {
+                    content: [{ type: 'text', text: resultText }],
+                    structuredContent: { deletedCount, success }
+                };
+            }
+            catch (error) {
+                throw new Error(`[Tool: delete-evidences] ${getErrorMessage(error)}. Suggested action: Verify the evidence IDs exist.`);
+            }
+        });
+        // Rename tag tool
+        this.server.registerTool('rename-tag', {
+            title: 'Rename Tag',
+            description: 'Rename a tag across all evidence 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} evidence record${updatedCount > 1 ? 's' : ''}`
+                    : `⚠️ No evidence 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 evidence 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} evidence record${updatedCount > 1 ? 's' : ''}`
+                    : `⚠️ No evidence 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 evidence 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 evidence 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();
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main().catch((error) => {
+        console.error('Server error:', error);
+        process.exit(1);
+    });
+}
+export { EvidenceMCPTestHelpers } from './test-helpers.js';
+//# sourceMappingURL=index.js.map