@nbiish/cognitive-tools-mcp 0.8.5 → 0.9.0

package/build/index.js

@@ -1,196 +1,409 @@
 #!/usr/bin/env node
+/**
+ * -----------------------------------------------------------------------------
+ * Gikendaasowin Aabajichiganan - Cognitive Tools MCP Server
+ *
+ * Description: Provides a suite of cognitive tools for an AI Pair Programmer
+ *              to structure its reasoning, plan actions, analyze results,
+ *              and iteratively refine its work (Chain of Draft). Integrates
+ *              with generic external environment tools for comprehensive interaction.
+ *              Designed to be used with the corresponding integration prompt
+ *              focused on iterative refinement and tool integration.
+ * Protocol:    Model Context Protocol (MCP) over stdio.
+ * -----------------------------------------------------------------------------
+ */
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-// Create the MCP server - Version aligned with prompt
+import { exec } from 'child_process'; // For executeTerminalCommand
+import vm from 'vm'; // For safer executeCode
+import fs from 'fs/promises'; // For file operations
+// Helper function to promisify exec
+import { promisify } from 'util';
+const execPromise = promisify(exec);
+// --- Server Definition ---
 const server = new McpServer({
     name: "gikendaasowin-aabajichiganan-mcp",
-    version: "0.8.5", // Updated version to match prompt
-    description: "ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Gikendaasowin Aabajichiganan - (Cognitive Tools v0.8.5): SOTA reasoning suite aligned with AI Pair Programmer Prompt v0.8.1+. Enforces structured deliberation via `think` after explicit assessment or action results. Returns generated cognitive content (thoughts, plans, CoT, critiques, summaries) for explicit analysis and action planning, optimizing for cognitive enhancement and effective tool integration."
-});
-// --- Core Cognitive Deliberation Tools ---
-server.tool("think", 
-// Main Description: Central hub, returns thought for explicit context and action planning.
-"MANDATORY Cognitive Hub for planning, analysis (incl. prior action/tool results), verification, risk assessment, and self-correction. Called after assessment, complex cognitive tools, or external tool execution. Returns the detailed thought text for explicit grounding and to define the immediate next action.", {
-    // Parameter Description: Input IS the thought.
-    thought: z.string().describe("Your **detailed** internal monologue following the MANDATORY structure: ## Analysis (incl. results of last action/tool call), ## Plan (defining immediate next action, incl. external tools), ## Verification, ## Anticipated Challenges Analysis & Contingency, ## Risk Assessment, ## Lookahead, ## Self-Correction & Learning.")
+    version: "0.9.0", // Version required by MCP SDK
+    description: "ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Cognitive Tools Suite: Enables structured, iterative reasoning (Chain of Draft), planning, analysis, and external tool integration for AI Pair Programming."
+});
+// --- Logging Helper ---
+function logToolCall(toolName, details) {
+    console.error(`[MCP Server] > Tool Call: ${toolName}${details ? ` - ${details}` : ''}`);
+}
+function logToolResult(toolName, success, resultDetails) {
+    console.error(`[MCP Server] < Tool Result: ${toolName} - ${success ? 'Success' : 'Failure'}${resultDetails ? ` - ${resultDetails}` : ''}`);
+}
+function logToolError(toolName, error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`[MCP Server] ! Tool Error: ${toolName} - ${errorMessage}`);
+    logToolResult(toolName, false, errorMessage); // Log failure result as well
+    // Return a structured error message suitable for the LLM
+    return { content: [{ type: "text", text: `Error in ${toolName}: ${errorMessage}` }] };
+}
+// --- Core Cognitive Deliberation & Refinement Tools ---
+server.tool("assess_cuc_n_mode", "**Mandatory Pre-Deliberation/Pre-Sequence Assessment.** Evaluates task Complexity, Uncertainty, Consequence, Novelty (CUC-N) to determine required cognitive depth and initial strategy. MUST be called before starting complex tasks or changing strategy.", {
+    assessment_and_choice: z.string().describe("Structured assessment including: 1) Situation Description, 2) CUC-N Ratings (L/M/H), 3) Recommended Initial Strategy (e.g., 'Need to read relevant file for context'), 4) Explicit Mode Selection ('Selected Mode: think' or 'Selected Mode: quick_think').")
+}, async ({ assessment_and_choice }) => {
+    logToolCall('assess_cuc_n_mode');
+    try {
+        // Basic validation for required components
+        if (!assessment_and_choice.includes("Selected Mode:") || !assessment_and_choice.includes("CUC-N Ratings:") || !assessment_and_choice.includes("Recommended Initial Strategy:")) {
+            throw new Error('Invalid assessment: String must include CUC-N ratings, Recommended Initial Strategy, and explicit Selected Mode.');
+        }
+        const mode = assessment_and_choice.includes("Selected Mode: think") ? "think" : "quick_think";
+        const resultText = `Cognitive Assessment Completed. Proceeding with selected mode: ${mode}. Full Assessment:\n${assessment_and_choice}`;
+        logToolResult('assess_cuc_n_mode', true, `Selected mode: ${mode}`);
+        return { content: [{ type: "text", text: resultText }] };
+    }
+    catch (error) {
+        return logToolError('assess_cuc_n_mode', error);
+    }
+});
+server.tool("think", "**MANDATORY Central Hub for Analysis, Planning, and Refinement.** Called after assessment, complex cognitive tools, *any* external tool execution, or internal draft generation. Analyzes previous step's outcome/draft, plans immediate next action (cognitive or external), verifies, assesses risk, and self-corrects. Returns the thought text for grounding.", {
+    thought: z.string().describe("Your **detailed** internal monologue following the MANDATORY structure: ## Analysis (critically evaluate last result/draft, incl. tool errors/warnings), ## Plan (define *immediate* next action & purpose), ## Verification (how to check next step), ## Anticipated Challenges & Contingency, ## Risk Assessment, ## Lookahead, ## Self-Correction & Learning.")
 }, async ({ thought }) => {
-    if (!thought || typeof thought !== 'string' || thought.trim().length === 0) {
-        throw new Error('Invalid thought: Must be non-empty, structured reasoning.');
-    }
-    // Ensure mandatory sections are mentioned (basic check)
-    const requiredSections = ["## Analysis:", "## Plan:", "## Verification:", "## Anticipated Challenges Analysis & Contingency:", "## Risk Assessment:", "## Lookahead:", "## Self-Correction & Learning:"];
-    // Simple check for presence; more robust parsing could be added if needed
-    const hasRequiredSections = requiredSections.every(section => thought.includes(section));
-    if (!hasRequiredSections) {
-        console.warn(`[CognitiveToolsServer v0.8.5] Warning: 'think' input might be missing some mandatory sections.`);
-        // Decide whether to throw error or just warn. Warning allows flexibility.
-        // throw new Error('Invalid thought: Missing one or more mandatory sections (## Analysis:, ## Plan:, etc.).');
-    }
-    console.error(`[CognitiveToolsServer v0.8.5] Think Tool Received: ${thought.substring(0, 150)}...`);
-    // Returns the same thought text received, making it explicit in context.
-    return { content: [{ type: "text", text: thought }] };
-});
-server.tool("quick_think", 
-// Main Description: Unchanged.
-"Cognitive Checkpoint ONLY for situations explicitly assessed as strictly Low CUC-N AND simple task nature/confirmation. Use sparingly. Logs brief thought.", {
-    brief_thought: z.string().describe("Your **concise** thought for strictly simple, low CUC-N situations confirmed by prior assessment or for brief confirmations.")
+    logToolCall('think');
+    try {
+        if (!thought || typeof thought !== 'string' || thought.trim().length === 0) {
+            throw new Error('Invalid thought: Must be a non-empty string.');
+        }
+        // Basic check for mandatory sections (can be made more robust)
+        const requiredSections = ["## Analysis:", "## Plan:", "## Verification:", "## Anticipated Challenges & Contingency:", "## Risk Assessment:", "## Lookahead:", "## Self-Correction & Learning:"];
+        const missingSections = requiredSections.filter(section => !thought.includes(section));
+        if (missingSections.length > 0) {
+            console.warn(`[MCP Server] Warning: 'think' input might be missing sections: ${missingSections.join(', ')}`);
+            // Allow processing but log warning. Could throw error if strictness is desired.
+        }
+        logToolResult('think', true, `Thought logged (length: ${thought.length})`);
+        // Returns the same thought text received, making it explicit in context.
+        return { content: [{ type: "text", text: thought }] };
+    }
+    catch (error) {
+        return logToolError('think', error);
+    }
+});
+server.tool("quick_think", "Cognitive Checkpoint ONLY for situations explicitly assessed as strictly Low CUC-N (via assess_cuc_n_mode) or for trivial confirmations where detailed analysis via `think` is unnecessary. Use sparingly.", {
+    brief_thought: z.string().describe("Your **concise** thought for strictly simple, low CUC-N situations or brief confirmations.")
 }, async ({ brief_thought }) => {
-    if (!brief_thought || typeof brief_thought !== 'string' || brief_thought.trim().length === 0) {
-        throw new Error('Invalid brief_thought: Must be non-empty.');
-    }
-    console.error(`[CognitiveToolsServer v0.8.5] QuickThink Tool Logged: ${brief_thought.substring(0, 100)}...`);
-    // Simple confirmation remains appropriate for quick_think.
-    return { content: [{ type: "text", text: `Quick Thought logged successfully.` }] };
-});
-// --- Mandatory Meta-Cognitive Tools ---
-server.tool("assess_cuc_n_mode", // Shortened name to avoid length limitations
-// Main Description: Updated name, emphasizes role.
-"**Mandatory Pre-Deliberation/Pre-Sequence Assessment.** Must be called BEFORE initiating significant cognitive processes (`think`) or complex action sequences. Evaluates CUC-N, recommends strategy, commits to next thought mode.", {
-    // Parameter Description: Unchanged.
-    assessment_and_choice: z.string().describe("Input your assessment *before* calling. MUST include: 1) Situation Description, 2) CUC-N Ratings (L/M/H), 3) Recommended Initial Strategy, 4) Explicit Mode Selection ('Selected Mode: think' or 'Selected Mode: quick_think').")
-}, async ({ assessment_and_choice }) => {
-    const requiredPhrases = ["Complexity", "Uncertainty", "Consequence", "Novelty", "Recommended Initial Strategy", "Selected Mode:"];
-    const hasRequiredPhrases = requiredPhrases.every(phrase => assessment_and_choice.includes(phrase));
-    const hasModeSelection = assessment_and_choice.includes("Selected Mode: think") || assessment_and_choice.includes("Selected Mode: quick_think");
-    if (!assessment_and_choice || typeof assessment_and_choice !== 'string' || !hasRequiredPhrases || !hasModeSelection) {
-        throw new Error('Invalid assessment: String must include CUC-N ratings, Recommended Initial Strategy, and explicit Selected Mode ("think" or "quick_think").');
-    }
-    console.error(`[CognitiveToolsServer v0.8.5] AssessComplexity Tool Signaled: ${assessment_and_choice.substring(0, 150)}...`);
-    const mode = assessment_and_choice.includes("Selected Mode: think") ? "think" : "quick_think";
-    // Confirmation guides the next step.
-    return { content: [{ type: "text", text: `Cognitive Assessment Completed. Proceeding with selected mode: ${mode}. Full Assessment: ${assessment_and_choice}` }] };
-});
-server.tool("gauge_confidence", 
-// Main Description: Emphasizes mandatory analysis.
-"Meta-Cognitive Checkpoint. Guides internal stating of **confidence (High/Medium/Low) and justification**. Output MUST be analyzed in the mandatory `think` step immediately after; Low/Medium confidence requires specific action planning.", {
-    // Parameter Description: Unchanged.
+    logToolCall('quick_think');
+    try {
+        if (!brief_thought || typeof brief_thought !== 'string' || brief_thought.trim().length === 0) {
+            throw new Error('Invalid brief_thought: Must be non-empty.');
+        }
+        logToolResult('quick_think', true, `Logged: ${brief_thought.substring(0, 50)}...`);
+        return { content: [{ type: "text", text: `Quick Thought logged successfully.` }] };
+    }
+    catch (error) {
+        return logToolError('quick_think', error);
+    }
+});
+server.tool("gauge_confidence", "Meta-Cognitive Checkpoint. Guides internal stating of **confidence (High/Medium/Low) and justification** regarding a plan, analysis, or draft. Output MUST be analyzed in the mandatory `think` step immediately after.", {
     assessment_and_confidence: z.string().describe("Input item being assessed. *Internally determine and state*: 1) Confidence Level (H/M/L). 2) Justification. Call this tool *after* making the assessment.")
 }, async ({ assessment_and_confidence }) => {
-    const confidenceRegex = /Confidence Level: (High|Medium|Low)/i;
-    if (!assessment_and_confidence || typeof assessment_and_confidence !== 'string' || !confidenceRegex.test(assessment_and_confidence)) {
-        throw new Error('Invalid confidence assessment: String must include "Confidence Level: High/Medium/Low" and justification.');
-    }
-    const match = assessment_and_confidence.match(confidenceRegex);
-    const level = match ? match[1] : "Unknown";
-    console.error(`[CognitiveToolsServer v0.8.5] GaugeConfidence Tool Signaled: Level ${level}`);
-    // Confirmation includes level, prepares for mandatory analysis.
-    return { content: [{ type: "text", text: `Confidence Gauge Completed. Level: ${level}. Assessment Text: ${assessment_and_confidence}. Ready for mandatory post-assessment 'think' analysis (action required if Low/Medium).` }] };
-});
-// --- Supporting Cognitive Strategy Tools (Accept & Return Generated Text for Analysis) ---
-server.tool("plan_and_solve", 
-// Main Description: Returns plan text for analysis and action planning.
-"Guides internal generation of **structured plan text** (incl. Risks/Challenges, potential tool needs). Call this tool *with* the generated plan text. Returns the plan text for mandatory `think` analysis to confirm/refine the immediate next step.", {
-    // Parameter: Accepts the generated plan.
-    generated_plan_text: z.string().describe("The **full, structured plan text** you generated internally, including Anticipated Challenges/Risks and potential other tool needs."),
+    logToolCall('gauge_confidence');
+    try {
+        const confidenceRegex = /Confidence Level: (High|Medium|Low)/i;
+        if (!assessment_and_confidence || typeof assessment_and_confidence !== 'string' || !confidenceRegex.test(assessment_and_confidence)) {
+            throw new Error('Invalid confidence assessment: String must include "Confidence Level: High/Medium/Low" and justification.');
+        }
+        const match = assessment_and_confidence.match(confidenceRegex);
+        const level = match ? match[1] : "Unknown";
+        const resultText = `Confidence Gauge Completed. Level: ${level}. Assessment Text: ${assessment_and_confidence}. Ready for mandatory post-assessment 'think' analysis (action required if Low/Medium).`;
+        logToolResult('gauge_confidence', true, `Level: ${level}`);
+        return { content: [{ type: "text", text: resultText }] };
+    }
+    catch (error) {
+        return logToolError('gauge_confidence', error);
+    }
+});
+server.tool("plan_and_solve", "Guides internal generation of a **structured plan draft**. Call this tool *with* the generated plan text. Returns the plan text for mandatory `think` analysis to critically evaluate feasibility, refine, and confirm the first action step.", {
+    generated_plan_text: z.string().describe("The **full, structured plan draft** you generated internally, including goals, steps, potential tool needs, and risks."),
     task_objective: z.string().describe("The original high-level task objective this plan addresses.")
 }, async ({ generated_plan_text, task_objective }) => {
-    if (!generated_plan_text || typeof generated_plan_text !== 'string' || generated_plan_text.trim().length === 0) {
-        throw new Error('Invalid generated_plan_text: Must be non-empty.');
+    logToolCall('plan_and_solve', `Objective: ${task_objective.substring(0, 50)}...`);
+    try {
+        if (!generated_plan_text || typeof generated_plan_text !== 'string' || generated_plan_text.trim().length === 0) {
+            throw new Error('Invalid generated_plan_text: Must be non-empty.');
+        }
+        if (!task_objective || typeof task_objective !== 'string' || task_objective.trim().length === 0) {
+            throw new Error('Invalid task_objective.');
+        }
+        logToolResult('plan_and_solve', true, `Returned plan draft (length: ${generated_plan_text.length})`);
+        // Returns the actual plan text received for analysis.
+        return { content: [{ type: "text", text: generated_plan_text }] };
     }
-    if (!task_objective || typeof task_objective !== 'string' || task_objective.trim().length === 0) {
-        throw new Error('Invalid task_objective.');
+    catch (error) {
+        return logToolError('plan_and_solve', error);
     }
-    console.error(`[CognitiveToolsServer v0.8.5] PlanAndSolve Tool Received Plan for Objective: ${task_objective.substring(0, 100)}...`);
-    // Returns the actual plan text received for analysis.
-    return { content: [{ type: "text", text: generated_plan_text }] };
 });
-server.tool("chain_of_thought", 
-// Main Description: Returns CoT text for analysis and action planning.
-"Guides internal generation of **detailed, step-by-step reasoning text (CoT)**. Call this tool *with* the generated CoT text. Returns the CoT text for mandatory `think` analysis to extract insights and plan the next action.", {
-    // Parameter: Accepts the generated CoT.
-    generated_cot_text: z.string().describe("The **full, step-by-step Chain of Thought text** you generated internally, potentially noting needs for other tools."),
+server.tool("chain_of_thought", "Guides internal generation of **detailed, step-by-step reasoning draft (CoT)**. Call this tool *with* the generated CoT text. Returns the CoT text for mandatory `think` analysis to extract insights, identify flaws/gaps, and plan the next concrete action.", {
+    generated_cot_text: z.string().describe("The **full, step-by-step Chain of Thought draft** you generated internally."),
     problem_statement: z.string().describe("The original problem statement this CoT addresses.")
 }, async ({ generated_cot_text, problem_statement }) => {
-    if (!generated_cot_text || typeof generated_cot_text !== 'string' || generated_cot_text.trim().length === 0) {
-        throw new Error('Invalid generated_cot_text: Must be non-empty.');
-    }
-    if (!problem_statement || typeof problem_statement !== 'string' || problem_statement.trim().length === 0) {
-        throw new Error('Invalid problem_statement.');
-    }
-    console.error(`[CognitiveToolsServer v0.8.5] ChainOfThought Tool Received CoT for Problem: ${problem_statement.substring(0, 100)}...`);
-    // Returns the actual CoT text received for analysis.
-    return { content: [{ type: "text", text: generated_cot_text }] };
-});
-server.tool("chain_of_draft", 
-// Main Description: Signal only, reinforces mandatory analysis.
-"Guides internal generation of **concise, iterative reasoning draft texts**. Call this tool *after* generating drafts internally. Response confirms generation; drafts MUST be analyzed via mandatory `think`.", {
-    // Parameter: Still just the problem statement. LLM handles drafts internally.
-    problem_statement: z.string().describe("Input problem for exploration. *You* (LLM) must now *internally generate brief, iterative draft texts*. Call this tool *after* generation to signal readiness for analysis.")
-}, async ({ problem_statement }) => {
-    if (!problem_statement || typeof problem_statement !== 'string' || problem_statement.trim().length === 0) {
-        throw new Error('Invalid problem statement.');
-    }
-    console.error(`[CognitiveToolsServer v0.8.5] ChainOfDraft Tool Signaled for: ${problem_statement.substring(0, 100)}...`);
-    // Returns confirmation, strongly reminding LLM of the mandatory next step.
-    return { content: [{ type: "text", text: `Reasoning drafts generated internally for problem: ${problem_statement}. MANDATORY: Analyze these drafts now in your next 'think' step.` }] };
-});
-server.tool("reflection", 
-// Main Description: Returns critique text for analysis and action planning.
-"Guides internal critical self-evaluation on prior text. Call this tool *with* the **generated critique text**. Returns the critique text for mandatory `think` analysis to plan corrective actions.", {
-    // Parameter: Accepts the generated critique.
-    generated_critique_text: z.string().describe("The **full critique text** you generated internally, identifying flaws and suggesting improvements."),
-    input_reasoning_or_plan: z.string().describe("The original text that was critiqued.")
-}, async ({ generated_critique_text, input_reasoning_or_plan }) => {
-    if (!generated_critique_text || typeof generated_critique_text !== 'string' || generated_critique_text.trim().length === 0) {
-        throw new Error('Invalid generated_critique_text: Must be non-empty.');
-    }
-    if (!input_reasoning_or_plan || typeof input_reasoning_or_plan !== 'string' || input_reasoning_or_plan.trim().length === 0) {
-        throw new Error('Invalid input_reasoning_or_plan.');
-    }
-    console.error(`[CognitiveToolsServer v0.8.5] Reflection Tool Received Critique for: ${input_reasoning_or_plan.substring(0, 100)}...`);
-    // Returns the actual critique text received for analysis.
-    return { content: [{ type: "text", text: generated_critique_text }] };
-});
-server.tool("synthesize_prior_reasoning", 
-// Main Description: Returns summary text for analysis and action planning.
-"Context Management Tool. Guides internal generation of a **structured summary text** (incl. Key Decisions, Open Questions). Call this tool *with* the generated summary text. Returns the summary for mandatory `think` analysis to inform the next steps.", {
-    // Parameter: Accepts the generated summary.
-    generated_summary_text: z.string().describe("The **full, structured summary text** you generated internally."),
-    context_to_summarize_description: z.string().describe("Description of the reasoning span that was summarized.")
+    logToolCall('chain_of_thought', `Problem: ${problem_statement.substring(0, 50)}...`);
+    try {
+        if (!generated_cot_text || typeof generated_cot_text !== 'string' || generated_cot_text.trim().length === 0) {
+            throw new Error('Invalid generated_cot_text: Must be non-empty.');
+        }
+        if (!problem_statement || typeof problem_statement !== 'string' || problem_statement.trim().length === 0) {
+            throw new Error('Invalid problem_statement.');
+        }
+        logToolResult('chain_of_thought', true, `Returned CoT draft (length: ${generated_cot_text.length})`);
+        // Returns the actual CoT text received for analysis.
+        return { content: [{ type: "text", text: generated_cot_text }] };
+    }
+    catch (error) {
+        return logToolError('chain_of_thought', error);
+    }
+});
+server.tool("chain_of_draft", "Signals that one or more **internal drafts** (code, text, plan fragments) have been generated or refined and are ready for analysis. Call this tool *after* generating/refining draft(s) internally. Response confirms readiness; drafts MUST be analyzed via mandatory `think`.", {
+    draft_description: z.string().describe("Brief description of the draft(s) generated/refined internally (e.g., 'Initial code snippet for function X', 'Refined plan section 3').")
+}, async ({ draft_description }) => {
+    logToolCall('chain_of_draft', `Description: ${draft_description}`);
+    try {
+        if (!draft_description || typeof draft_description !== 'string' || draft_description.trim().length === 0) {
+            throw new Error('Invalid draft_description.');
+        }
+        const resultText = `Internal draft(s) ready for analysis: ${draft_description}. MANDATORY: Analyze these draft(s) now in your next 'think' step.`;
+        logToolResult('chain_of_draft', true);
+        return { content: [{ type: "text", text: resultText }] };
+    }
+    catch (error) {
+        return logToolError('chain_of_draft', error);
+    }
+});
+server.tool("reflection", "Guides internal critical self-evaluation on a prior step, draft, or outcome. Call this tool *with* the **generated critique text**. Returns the critique text for mandatory `think` analysis to plan specific corrective actions or refinements.", {
+    generated_critique_text: z.string().describe("The **full critique text** you generated internally, identifying flaws, strengths, and suggesting improvements."),
+    input_subject_description: z.string().describe("A brief description of the original reasoning, plan, code draft, or action result that was critiqued.")
+}, async ({ generated_critique_text, input_subject_description }) => {
+    logToolCall('reflection', `Subject: ${input_subject_description}`);
+    try {
+        if (!generated_critique_text || typeof generated_critique_text !== 'string' || generated_critique_text.trim().length === 0) {
+            throw new Error('Invalid generated_critique_text: Must be non-empty.');
+        }
+        if (!input_subject_description || typeof input_subject_description !== 'string' || input_subject_description.trim().length === 0) {
+            throw new Error('Invalid input_subject_description.');
+        }
+        logToolResult('reflection', true, `Returned critique (length: ${generated_critique_text.length})`);
+        // Returns the actual critique text received for analysis.
+        return { content: [{ type: "text", text: generated_critique_text }] };
+    }
+    catch (error) {
+        return logToolError('reflection', error);
+    }
+});
+server.tool("synthesize_prior_reasoning", "Context Management Tool. Guides internal generation of a **structured summary** of preceding steps, decisions, or context. Call this tool *with* the generated summary text. Returns the summary for mandatory `think` analysis to consolidate understanding and inform next steps.", {
+    generated_summary_text: z.string().describe("The **full, structured summary text** you generated internally (e.g., key decisions, open questions, current state)."),
+    context_to_summarize_description: z.string().describe("Description of the reasoning span or context that was summarized.")
 }, async ({ generated_summary_text, context_to_summarize_description }) => {
-    if (!generated_summary_text || typeof generated_summary_text !== 'string' || generated_summary_text.trim().length === 0) {
-        throw new Error('Invalid generated_summary_text: Must be non-empty.');
+    logToolCall('synthesize_prior_reasoning', `Context: ${context_to_summarize_description}`);
+    try {
+        if (!generated_summary_text || typeof generated_summary_text !== 'string' || generated_summary_text.trim().length === 0) {
+            throw new Error('Invalid generated_summary_text: Must be non-empty.');
+        }
+        if (!context_to_summarize_description || typeof context_to_summarize_description !== 'string' || context_to_summarize_description.trim().length === 0) {
+            throw new Error('Invalid context_to_summarize_description.');
+        }
+        logToolResult('synthesize_prior_reasoning', true, `Returned summary (length: ${generated_summary_text.length})`);
+        // Returns the actual summary text received for analysis.
+        return { content: [{ type: "text", text: generated_summary_text }] };
+    }
+    catch (error) {
+        return logToolError('synthesize_prior_reasoning', error);
+    }
+});
+// --- Generic External Environment Tools ---
+// ** File System Operations **
+server.tool("readFile", "Reads the content of a specified file. Essential for getting context before analysis or modification.", {
+    filePath: z.string().describe("The path to the file relative to the project root.")
+}, async ({ filePath }) => {
+    logToolCall('readFile', `Path: ${filePath}`);
+    try {
+        const fileContent = await fs.readFile(filePath, 'utf8');
+        // Consider limiting the size returned to avoid overwhelming the context window
+        const maxSize = 10000; // Example limit: 10k characters
+        const truncatedContent = fileContent.length > maxSize ? fileContent.substring(0, maxSize) + "\n... [File truncated]" : fileContent;
+        logToolResult('readFile', true, `Read ${truncatedContent.length} chars from ${filePath}`);
+        return { content: [{ type: "text", text: truncatedContent }] };
+    }
+    catch (error) {
+        return logToolError('readFile', error);
+    }
+});
+server.tool("writeFile", "Writes the provided content to a specified file, overwriting existing content. Use to apply generated code or modifications.", {
+    filePath: z.string().describe("The path to the file relative to the project root."),
+    content: z.string().describe("The full content to write to the file.")
+}, async ({ filePath, content }) => {
+    logToolCall('writeFile', `Path: ${filePath}, Content Length: ${content.length}`);
+    try {
+        // Ensure directory exists before writing? (Optional, adds robustness)
+        // await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.writeFile(filePath, content, 'utf8');
+        logToolResult('writeFile', true, `Wrote ${content.length} chars to ${filePath}`);
+        return { content: [{ type: "text", text: `Successfully wrote content to ${filePath}.` }] };
+    }
+    catch (error) {
+        return logToolError('writeFile', error);
+    }
+});
+server.tool("listFiles", "Lists files and directories within a specified directory path.", {
+    directoryPath: z.string().describe("The path to the directory relative to the project root (e.g., '.', 'src/components').")
+}, async ({ directoryPath }) => {
+    logToolCall('listFiles', `Path: ${directoryPath}`);
+    try {
+        const entries = await fs.readdir(directoryPath, { withFileTypes: true });
+        const listing = entries.map(entry => `${entry.name}${entry.isDirectory() ? '/' : ''}`).join('\n');
+        logToolResult('listFiles', true, `Found ${entries.length} entries in ${directoryPath}`);
+        return { content: [{ type: "text", text: listing || "[Directory is empty]" }] };
+    }
+    catch (error) {
+        return logToolError('listFiles', error);
+    }
+});
+server.tool("createDirectory", "Creates a new directory at the specified path. Use `recursive: true` to create parent directories if needed.", {
+    directoryPath: z.string().describe("The path for the new directory relative to the project root."),
+    recursive: z.boolean().optional().describe("If true, create parent directories as needed. Defaults to false.")
+}, async ({ directoryPath, recursive = false }) => {
+    logToolCall('createDirectory', `Path: ${directoryPath}, Recursive: ${recursive}`);
+    try {
+        await fs.mkdir(directoryPath, { recursive: recursive });
+        logToolResult('createDirectory', true, `Created directory ${directoryPath}`);
+        return { content: [{ type: "text", text: `Successfully created directory ${directoryPath}.` }] };
+    }
+    catch (error) {
+        // Handle 'EEXIST' gracefully if directory already exists? Or let it fail?
+        // if (error.code === 'EEXIST' && recursive) { /* handle existing */ }
+        return logToolError('createDirectory', error);
+    }
+});
+server.tool("deleteFile", "Deletes the specified file. Use with caution.", {
+    filePath: z.string().describe("The path to the file to delete relative to the project root.")
+}, async ({ filePath }) => {
+    logToolCall('deleteFile', `Path: ${filePath}`);
+    try {
+        await fs.unlink(filePath);
+        logToolResult('deleteFile', true, `Deleted file ${filePath}`);
+        return { content: [{ type: "text", text: `Successfully deleted file ${filePath}.` }] };
     }
-    if (!context_to_summarize_description || typeof context_to_summarize_description !== 'string' || context_to_summarize_description.trim().length === 0) {
-        throw new Error('Invalid context_to_summarize_description.');
+    catch (error) {
+        // Handle 'ENOENT' (file not found) gracefully?
+        return logToolError('deleteFile', error);
+    }
+});
+// ** Code Execution & Terminal **
+server.tool("executeCode", "Executes a provided code snippet in a sandboxed environment. Crucial for testing drafts/logic. Currently supports JavaScript.", {
+    codeSnippet: z.string().describe("The code snippet to execute (currently JavaScript)."),
+    language: z.string().optional().describe("The language of the snippet (defaults to javascript). Informational for now.")
+}, async ({ codeSnippet, language = 'javascript' }) => {
+    // Basic check for language - could expand later
+    if (language.toLowerCase() !== 'javascript') {
+        return logToolError('executeCode', new Error(`Unsupported language: ${language}. Only JavaScript is currently supported.`));
+    }
+    logToolCall('executeCode', `Lang: ${language}, Snippet: ${codeSnippet.substring(0, 50)}...`);
+    try {
+        // Use Node.js vm module for basic sandboxing (better than eval)
+        const context = vm.createContext({}); // Create an empty context
+        const script = new vm.Script(codeSnippet);
+        const result = script.runInContext(context, { timeout: 5000 }); // Add a timeout
+        const resultString = typeof result === 'undefined' ? 'undefined' : JSON.stringify(result);
+        logToolResult('executeCode', true, `Result: ${resultString.substring(0, 100)}...`);
+        return { content: [{ type: "text", text: `Execution Result: ${resultString}` }] };
+    }
+    catch (error) {
+        return logToolError('executeCode', error);
+    }
+});
+server.tool("executeTerminalCommand", "Executes a shell command in the project's root directory. Useful for build steps, git operations, running test suites, etc.", {
+    command: z.string().describe("The shell command to execute (e.g., 'npm run test', 'git status').")
+}, async ({ command }) => {
+    logToolCall('executeTerminalCommand', `Command: ${command}`);
+    try {
+        // Execute command - consider security implications carefully in production
+        // Set a timeout? Limit allowed commands?
+        const { stdout, stderr } = await execPromise(command, { timeout: 30000, encoding: 'utf8' }); // 30s timeout
+        let resultText = "";
+        if (stderr) {
+            resultText += `Standard Error:\n${stderr}\n`;
+            logToolResult('executeTerminalCommand', false, `Command finished with stderr.`); // Consider stderr as potential failure
+        }
+        resultText += `Standard Output:\n${stdout}`;
+        logToolResult('executeTerminalCommand', true, `Command finished.`);
+        // Limit output size?
+        const maxSize = 5000;
+        if (resultText.length > maxSize) {
+            resultText = resultText.substring(0, maxSize) + "\n... [Output truncated]";
+        }
+        return { content: [{ type: "text", text: resultText }] };
+    }
+    catch (error) {
+        // Error object from exec often includes stdout/stderr which might be useful
+        let errorDetails = error instanceof Error ? error.message : String(error);
+        if (error.stdout)
+            errorDetails += `\nSTDOUT:\n${error.stdout}`;
+        if (error.stderr)
+            errorDetails += `\nSTDERR:\n${error.stderr}`;
+        return logToolError('executeTerminalCommand', errorDetails);
+    }
+});
+// ** Web & Information Retrieval **
+server.tool("webSearch", "Performs a web search using an external service (stubbed). Useful for finding API documentation, error explanations, or concepts.", {
+    query: z.string().describe("The search query.")
+}, async ({ query }) => {
+    logToolCall('webSearch', `Query: ${query}`);
+    // --- STUB IMPLEMENTATION ---
+    // In a real scenario, this would call a search API (Google, Bing, DuckDuckGo, Brave Search etc.)
+    // For now, return a placeholder message.
+    const resultText = `[Web Search Stub] Would search for: "${query}". No live search configured.`;
+    logToolResult('webSearch', true, 'Stub executed');
+    return { content: [{ type: "text", text: resultText }] };
+    // --- END STUB ---
+    /* // Example using a hypothetical search API client
+    try {
+        // const searchResults = await searchApiClient.search(query);
+        // const formattedResults = formatSearchResults(searchResults); // Process results
+        // logToolResult('webSearch', true, `Found results for ${query}`);
+        // return { content: [{ type: "text", text: formattedResults }] };
+    } catch (error: any) {
+        return logToolError('webSearch', error);
     }
-    console.error(`[CognitiveToolsServer v0.8.5] SynthesizeReasoning Tool Received Summary for: ${context_to_summarize_description}...`);
-    // Returns the actual summary text received for analysis.
-    return { content: [{ type: "text", text: generated_summary_text }] };
+    */
 });
-// --- Server Lifecycle and Error Handling (Unchanged) ---
+// --- Server Lifecycle and Error Handling ---
 process.on('SIGINT', async () => {
-    console.error('\n[CognitiveToolsServer v0.8.5] Received SIGINT, shutting down gracefully.');
+    console.error('\n[MCP Server] Received SIGINT, shutting down gracefully.');
     await server.close();
     process.exit(0);
 });
 process.on('SIGTERM', async () => {
-    console.error('\n[CognitiveToolsServer v0.8.5] Received SIGTERM, shutting down gracefully.');
+    console.error('\n[MCP Server] Received SIGTERM, shutting down gracefully.');
     await server.close();
     process.exit(0);
 });
-process.on('uncaughtException', (error) => {
-    console.error('[CognitiveToolsServer v0.8.5] FATAL: Uncaught Exception:', error);
-    server.close().catch(err => console.error('[CognitiveToolsServer v0.8.5] Error during shutdown on uncaughtException:', err)).finally(() => {
+process.on('uncaughtException', (error, origin) => {
+    console.error(`[MCP Server] FATAL: Uncaught Exception at: ${origin}`, error);
+    server.close().catch(err => console.error('[MCP Server] Error during shutdown on uncaughtException:', err)).finally(() => {
         process.exit(1);
     });
 });
 process.on('unhandledRejection', (reason, promise) => {
-    console.error('[CognitiveToolsServer v0.8.5] FATAL: Unhandled Promise Rejection:', reason);
-    server.close().catch(err => console.error('[CognitiveToolsServer v0.8.5] Error during shutdown on unhandledRejection:', err)).finally(() => {
+    console.error('[MCP Server] FATAL: Unhandled Promise Rejection:', reason);
+    server.close().catch(err => console.error('[MCP Server] Error during shutdown on unhandledRejection:', err)).finally(() => {
         process.exit(1);
     });
 });
-// Start the server
+// --- Start the Server ---
 async function main() {
     try {
         const transport = new StdioServerTransport();
         await server.connect(transport);
-        console.error('ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Gikendaasowin Aabajichiganan - (Cognitive Tools v0.8.5) MCP Server running on stdio');
+        console.error('-----------------------------------------------------');
+        console.error(' ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Cognitive Tools MCP Server');
+        console.error(' Status: Running on stdio');
+        console.error('-----------------------------------------------------');
     }
     catch (error) {
-        console.error('[CognitiveToolsServer v0.8.5] Fatal error during startup:', error);
+        console.error('[MCP Server] Fatal error during startup:', error);
         process.exit(1);
     }
 }