tachibot-mcp 2.0.2

package/dist/src/session/session-tools.js

@@ -0,0 +1,400 @@
+/**
+ * Session-related MCP tools for Focus MCP Server
+ * Provides tools for managing, analyzing, and exporting sessions
+ */
+import { z } from "zod";
+import { sessionLogger } from "./session-logger.js";
+import { sessionManager } from "./session-manager.js";
+// Define schemas for each tool's parameters
+const ListSessionsSchema = z.object({
+    filter: z.string().optional().describe("Filter by mode, date, or query text"),
+    limit: z.number().optional().default(10).describe("Maximum number of sessions to return"),
+    sortBy: z.enum(["date", "duration", "steps", "mode"]).optional().default("date")
+        .describe("Sort criteria for results")
+});
+const ReplaySessionSchema = z.object({
+    sessionId: z.string().describe("Session ID or filename to replay"),
+    format: z.enum(["full", "summary"]).optional().default("full")
+        .describe("Output format - full shows all steps, summary shows key points")
+});
+const ExportSessionSchema = z.object({
+    sessionId: z.string().describe("Session ID to export"),
+    format: z.enum(["markdown", "json", "html", "pdf"])
+        .describe("Export format"),
+    outputPath: z.string().optional()
+        .describe("Custom output path (optional)")
+});
+const AnalyzeSessionsSchema = z.object({
+    dateRange: z.object({
+        start: z.string().describe("Start date (YYYY-MM-DD)"),
+        end: z.string().describe("End date (YYYY-MM-DD)")
+    }).optional().describe("Date range to analyze"),
+    mode: z.string().optional().describe("Filter by specific mode"),
+    metrics: z.array(z.enum([
+        "model-usage",
+        "response-time",
+        "token-usage",
+        "consensus-rate",
+        "topic-clustering"
+    ])).optional().default(["model-usage", "response-time", "consensus-rate"])
+        .describe("Metrics to calculate"),
+    exportReport: z.boolean().optional().default(false)
+        .describe("Export analytics report to file")
+});
+const FindSimilarSchema = z.object({
+    query: z.string().describe("Query to find similar sessions for"),
+    limit: z.number().optional().default(5)
+        .describe("Maximum number of similar sessions to return")
+});
+const RecommendSchema = z.object({
+    query: z.string().describe("Query to get recommendations for")
+});
+const ClearOldSessionsSchema = z.object({
+    daysToKeep: z.number().default(30)
+        .describe("Keep sessions from the last N days")
+});
+const SessionStatusSchema = z.object({});
+/**
+ * Register all session-related tools with the MCP server
+ */
+export function registerSessionTools(server) {
+    // List saved sessions
+    server.addTool({
+        name: "focus_list_sessions",
+        description: "List all saved Focus MCP brainstorming sessions with metadata",
+        parameters: ListSessionsSchema,
+        execute: async (args) => {
+            try {
+                const sessions = await sessionLogger.listSessions(args.filter, args.limit);
+                if (sessions.length === 0) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: "No sessions found matching the criteria."
+                            }]
+                    };
+                }
+                // Format sessions as a table
+                const lines = [
+                    "# Focus MCP Sessions\n",
+                    "| Date | Mode | Query | Session ID |",
+                    "|------|------|-------|------------|"
+                ];
+                for (const session of sessions) {
+                    const date = session.date.toISOString().split('T')[0];
+                    const query = session.query.length > 50
+                        ? session.query.substring(0, 47) + "..."
+                        : session.query;
+                    lines.push(`| ${date} | ${session.mode} | ${query} | ${session.id} |`);
+                }
+                lines.push(`\n**Total sessions found**: ${sessions.length}`);
+                return {
+                    content: [{
+                            type: "text",
+                            text: lines.join("\n")
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error listing sessions: ${error}`
+                        }],
+                    isError: true
+                };
+            }
+        }
+    });
+    // Replay a saved session
+    server.addTool({
+        name: "focus_replay_session",
+        description: "Replay a saved session to see all model responses and synthesis",
+        parameters: ReplaySessionSchema,
+        execute: async (args) => {
+            try {
+                const content = await sessionLogger.replaySession(args.sessionId, args.format);
+                return {
+                    content: [{
+                            type: "text",
+                            text: content
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error replaying session: ${error}`
+                        }],
+                    isError: true
+                };
+            }
+        }
+    });
+    // Export session in different format
+    server.addTool({
+        name: "focus_export_session",
+        description: "Export a session in different formats for sharing or archiving",
+        parameters: ExportSessionSchema,
+        execute: async (args) => {
+            try {
+                const filepath = await sessionLogger.exportSession(args.sessionId, args.format, args.outputPath);
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Session exported successfully to: ${filepath}`
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error exporting session: ${error}`
+                        }],
+                    isError: true
+                };
+            }
+        }
+    });
+    // Analyze sessions for patterns and insights
+    server.addTool({
+        name: "focus_analyze_sessions",
+        description: "Analyze multiple sessions for patterns, model performance, and insights",
+        parameters: AnalyzeSessionsSchema,
+        execute: async (args) => {
+            try {
+                // Parse date range if provided
+                let dateRange;
+                if (args.dateRange) {
+                    dateRange = {
+                        start: new Date(args.dateRange.start),
+                        end: new Date(args.dateRange.end)
+                    };
+                }
+                // Analyze sessions
+                const analytics = await sessionManager.analyzeSessions(dateRange, args.mode, args.metrics);
+                // Format analytics report
+                const lines = [
+                    "# Session Analytics Report\n",
+                    "## Overview",
+                    `- **Total Sessions**: ${analytics.totalSessions}`,
+                    `- **Average Duration**: ${(analytics.averageDuration / 1000).toFixed(1)}s`,
+                    `- **Average Steps**: ${analytics.averageSteps.toFixed(1)}`,
+                    `- **Consensus Rate**: ${(analytics.consensusRate * 100).toFixed(1)}%\n`
+                ];
+                if (analytics.modelUsageStats.size > 0) {
+                    lines.push("## Model Usage");
+                    for (const [model, stats] of analytics.modelUsageStats.entries()) {
+                        lines.push(`- **${model}**: ${stats.count} uses, ${(stats.averageDuration / 1000).toFixed(1)}s avg, ${stats.totalTokens} tokens`);
+                    }
+                    lines.push("");
+                }
+                if (analytics.topicClusters.length > 0) {
+                    lines.push("## Topic Clusters");
+                    for (const cluster of analytics.topicClusters) {
+                        lines.push(`- **${cluster.topic}**: ${cluster.sessions.length} sessions`);
+                        if (cluster.commonPatterns.length > 0) {
+                            lines.push(`  Patterns: ${cluster.commonPatterns.join(", ")}`);
+                        }
+                    }
+                    lines.push("");
+                }
+                // Export if requested
+                if (args.exportReport) {
+                    const filepath = await sessionManager.exportAnalyticsReport("markdown");
+                    lines.push(`\n📊 Full report exported to: ${filepath}`);
+                }
+                return {
+                    content: [{
+                            type: "text",
+                            text: lines.join("\n")
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error analyzing sessions: ${error}`
+                        }],
+                    isError: true
+                };
+            }
+        }
+    });
+    // Find similar sessions
+    server.addTool({
+        name: "focus_find_similar",
+        description: "Find sessions similar to a given query for learning from past interactions",
+        parameters: FindSimilarSchema,
+        execute: async (args) => {
+            try {
+                const similar = await sessionManager.findSimilarSessions(args.query, args.limit);
+                if (similar.length === 0) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: "No similar sessions found."
+                            }]
+                    };
+                }
+                const lines = [
+                    `# Similar Sessions for: "${args.query}"\n`
+                ];
+                for (const { session, similarity } of similar) {
+                    lines.push(`## ${session.id}`);
+                    lines.push(`- **Query**: ${session.query}`);
+                    lines.push(`- **Mode**: ${session.mode}`);
+                    lines.push(`- **Similarity**: ${(similarity * 100).toFixed(1)}%`);
+                    lines.push(`- **Date**: ${session.timestamp}`);
+                    if (session.synthesis) {
+                        lines.push(`- **Key Insight**: ${session.synthesis.substring(0, 200)}${session.synthesis.length > 200 ? "..." : ""}`);
+                    }
+                    lines.push("");
+                }
+                return {
+                    content: [{
+                            type: "text",
+                            text: lines.join("\n")
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error finding similar sessions: ${error}`
+                        }],
+                    isError: true
+                };
+            }
+        }
+    });
+    // Get recommendations based on history
+    server.addTool({
+        name: "focus_recommend",
+        description: "Get mode and model recommendations based on session history",
+        parameters: RecommendSchema,
+        execute: async (args) => {
+            try {
+                const recommendations = await sessionManager.getRecommendations(args.query);
+                const lines = [
+                    `# Recommendations for: "${args.query}"\n`,
+                    `## Suggested Mode: **${recommendations.suggestedMode}**\n`
+                ];
+                if (recommendations.suggestedModels.length > 0) {
+                    lines.push("## Suggested Models:");
+                    for (const model of recommendations.suggestedModels) {
+                        lines.push(`- ${model}`);
+                    }
+                    lines.push("");
+                }
+                if (recommendations.similarSessions.length > 0) {
+                    lines.push("## Similar Past Sessions:");
+                    for (const session of recommendations.similarSessions) {
+                        lines.push(`- **${session.id}**`);
+                        lines.push(`  Query: "${session.query}"`);
+                        lines.push(`  Similarity: ${(session.similarity * 100).toFixed(1)}%`);
+                    }
+                }
+                return {
+                    content: [{
+                            type: "text",
+                            text: lines.join("\n")
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error getting recommendations: ${error}`
+                        }],
+                    isError: true
+                };
+            }
+        }
+    });
+    // Clear old sessions
+    server.addTool({
+        name: "focus_clear_old_sessions",
+        description: "Clean up old session files to save disk space",
+        parameters: ClearOldSessionsSchema,
+        execute: async (args) => {
+            try {
+                const deletedCount = await sessionLogger.clearOldSessions(args.daysToKeep);
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Successfully deleted ${deletedCount} old session files (kept last ${args.daysToKeep} days).`
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error clearing old sessions: ${error}`
+                        }],
+                    isError: true
+                };
+            }
+        }
+    });
+    // Get session status
+    server.addTool({
+        name: "focus_session_status",
+        description: "Get the status of the current active session",
+        parameters: SessionStatusSchema,
+        execute: async (args) => {
+            try {
+                const currentSession = sessionManager.getCurrentSession();
+                if (!currentSession) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: "No active session."
+                            }]
+                    };
+                }
+                const lines = [
+                    "# Current Session Status\n",
+                    `- **ID**: ${currentSession.id}`,
+                    `- **Mode**: ${currentSession.mode}`,
+                    `- **Query**: ${currentSession.query}`,
+                    `- **Status**: ${currentSession.status}`,
+                    `- **Steps Completed**: ${currentSession.steps.length}`,
+                    `- **Started**: ${currentSession.timestamp}`
+                ];
+                if (currentSession.totalDuration) {
+                    lines.push(`- **Duration**: ${(currentSession.totalDuration / 1000).toFixed(1)}s`);
+                }
+                if (currentSession.steps.length > 0) {
+                    lines.push("\n## Recent Steps:");
+                    const recentSteps = currentSession.steps.slice(-3);
+                    for (const step of recentSteps) {
+                        lines.push(`- Step ${step.stepNumber}: ${step.mode} (${step.model})`);
+                    }
+                }
+                return {
+                    content: [{
+                            type: "text",
+                            text: lines.join("\n")
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error getting session status: ${error}`
+                        }],
+                    isError: true
+                };
+            }
+        }
+    });
+    console.error("✅ Session tools registered successfully");
+}

package/dist/src/tools/advanced-modes.js

@@ -0,0 +1,200 @@
+import { z } from "zod";
+import { Auditor } from "../modes/auditor.js";
+import { CommitGuardian } from "../modes/commit-guardian.js";
+import { Architect } from "../modes/architect.js";
+import { CodeReviewer } from "../modes/code-reviewer.js";
+import { DocumentationWriter } from "../modes/documentation-writer.js";
+import { TestArchitect } from "../modes/test-architect.js";
+// Workflow tools removed - using workflow-runner.ts instead
+const auditor = new Auditor();
+const commitGuardian = new CommitGuardian();
+const architect = new Architect();
+const codeReviewer = new CodeReviewer();
+const documentationWriter = new DocumentationWriter();
+const testArchitect = new TestArchitect();
+// Auditor Tool
+export const auditorTool = {
+    name: "auditor",
+    description: `Evidence-based audit`,
+    parameters: z.object({
+        context: z.string(),
+        evidenceRequired: z.boolean().optional()
+    }),
+    execute: async (args, { log }) => {
+        log.info("Starting audit");
+        const result = await auditor.audit(args.context, {
+            evidenceRequired: args.evidenceRequired
+        });
+        log.info("Audit complete", {
+            verified: result.verificationStatus.verified,
+            disputed: result.verificationStatus.disputed
+        });
+        return result.synthesis;
+    }
+};
+// Commit Guardian Tool
+export const commitGuardianTool = {
+    name: "commit_guardian",
+    description: `Pre-commit validation`,
+    parameters: z.object({
+        context: z.string(),
+        strict: z.boolean().optional(),
+        checkSecurity: z.boolean().optional(),
+        checkQuality: z.boolean().optional(),
+        checkTests: z.boolean().optional()
+    }),
+    execute: async (args, { log }) => {
+        log.info("Validating commit");
+        const result = await commitGuardian.validate(args.context, {
+            strict: args.strict,
+            checkSecurity: args.checkSecurity,
+            checkQuality: args.checkQuality,
+            checkTests: args.checkTests
+        });
+        log.info("Validation complete", {
+            passed: result.passed,
+            score: result.score,
+            blockers: result.blockers.length
+        });
+        return result.summary;
+    }
+};
+// Architect Tool
+export const architectTool = {
+    name: "architect",
+    description: `Full codebase analysis with Gemini 2.5 Pro (1M tokens) and specialized verification.
+
+Parameters:
+- query (required): What to analyze in the codebase
+- path (optional): Path to codebase
+- depth (optional, default: normal): shallow|normal|deep
+- focusAreas (optional): Specific areas to focus on`,
+    parameters: z.object({
+        query: z.string(),
+        path: z.string().optional(),
+        depth: z.enum(["shallow", "normal", "deep"]).optional(),
+        focusAreas: z.array(z.string()).optional()
+    }),
+    execute: async (args, { log }) => {
+        log.info("Starting architecture analysis", {
+            depth: args.depth || "normal",
+            path: args.path
+        });
+        const result = await architect.analyze(args.query, {
+            path: args.path,
+            depth: args.depth,
+            focusAreas: args.focusAreas
+        });
+        log.info("Architecture analysis complete", {
+            hotspots: result.hotspots.length,
+            recommendations: result.recommendations.length,
+            tokensUsed: result.tokensUsed,
+            cost: result.cost
+        });
+        return result.synthesis;
+    }
+};
+// Workflow tools removed - handled by workflow-runner.ts
+// Code Reviewer Tool
+export const codeReviewerTool = {
+    name: "code_reviewer",
+    description: `Code review`,
+    parameters: z.object({
+        code: z.string(),
+        language: z.string().optional(),
+        focusAreas: z.array(z.enum(['security', 'performance', 'readability', 'bugs', 'best-practices'])).optional(),
+        severity: z.enum(['low', 'medium', 'high']).optional(),
+        model: z.string().optional()
+    }),
+    execute: async (args, { log }) => {
+        log.info("Starting code review", {
+            language: args.language || 'auto-detect',
+            focusAreas: args.focusAreas || 'all'
+        });
+        const result = await codeReviewer.review(args.code, {
+            language: args.language,
+            focusAreas: args.focusAreas,
+            severity: args.severity,
+            model: args.model
+        });
+        log.info("Code review complete", {
+            issuesFound: result.issues.length,
+            suggestions: result.suggestions.length,
+            maintainabilityScore: result.metrics.maintainabilityScore
+        });
+        return result.synthesis;
+    }
+};
+// Documentation Writer Tool
+export const documentationWriterTool = {
+    name: "documentation_writer",
+    description: `Documentation generation`,
+    parameters: z.object({
+        code: z.string(),
+        style: z.enum(['narrative', 'technical', 'beginner-friendly', 'api-reference']).optional(),
+        includeExamples: z.boolean().optional(),
+        generateToc: z.boolean().optional(),
+        format: z.enum(['markdown', 'html', 'plain']).optional()
+    }),
+    execute: async (args, { log }) => {
+        log.info("Generating documentation", {
+            style: args.style || 'narrative',
+            format: args.format || 'markdown'
+        });
+        const result = await documentationWriter.generateDocs(args.code, {
+            style: args.style,
+            includeExamples: args.includeExamples,
+            generateToc: args.generateToc,
+            format: args.format
+        });
+        log.info("Documentation generation complete", {
+            readmeLength: result.readme.split('\n').length,
+            apiDocs: result.apiDocs.length,
+            inlineComments: result.inlineComments.length,
+            hasNarrativeDoc: !!result.narrativeDoc
+        });
+        return result.synthesis;
+    }
+};
+// Test Architect Tool
+export const testArchitectTool = {
+    name: "test_architect",
+    description: `Test suite design`,
+    parameters: z.object({
+        code: z.string(),
+        testFramework: z.enum(['jest', 'mocha', 'vitest', 'cypress', 'playwright']).optional(),
+        testTypes: z.array(z.enum(['unit', 'integration', 'e2e', 'performance', 'security'])).optional(),
+        coverage: z.enum(['basic', 'thorough', 'comprehensive']).optional(),
+        generateMocks: z.boolean().optional()
+    }),
+    execute: async (args, { log }) => {
+        log.info("Architecting test suite", {
+            framework: args.testFramework || 'jest',
+            testTypes: args.testTypes || ['unit', 'integration', 'e2e'],
+            coverage: args.coverage || 'thorough'
+        });
+        const result = await testArchitect.architectTests(args.code, {
+            testFramework: args.testFramework,
+            testTypes: args.testTypes,
+            coverage: args.coverage,
+            generateMocks: args.generateMocks
+        });
+        log.info("Test architecture complete", {
+            totalTests: result.testSuite.totalTests,
+            testFiles: result.testFiles.length,
+            mockFiles: result.mockFiles.length,
+            estimatedCoverage: result.testSuite.estimatedCoverage,
+            edgeCases: result.edgeCases.length
+        });
+        return result.synthesis;
+    }
+};
+export function getAllAdvancedTools() {
+    // Scout, Verifier, Challenger have been migrated to system workflows
+    // See workflows/system/ for the new YAML-based implementations
+    return [];
+}
+// Check if advanced modes are available (always true for now)
+export function areAdvancedModesAvailable() {
+    return true;
+}