@nbiish/cognitive-tools-mcp 0.9.19 → 0.9.21

package/README.md

@@ -115,7 +115,7 @@ Or:
 ### `chain_of_thought`
 - **Purpose**: Guides *internal generation* and logging of detailed, step-by-step reasoning draft (CoT).
 - **Workflow**: Internally generate CoT -> Call tool.
-- **Input**:
+- **Input**: 
     - `generated_cot_text` (string) - The full CoT draft you generated internally.
     - `problem_statement` (string) - The original problem this CoT addresses.
 - **Follow-up**: Mandatory `think` or `quick_think`.

package/build/index.js

@@ -38,10 +38,23 @@ import { z } from "zod";
 // --- Server Definition ---
 const serverInfo = {
     name: "gikendaasowin-aabajichiganan-mcp",
-    version: "0.9.16",
+    version: "0.9.18",
     description: `ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Core Cognitive Tools Suite (Simplified, Relaxed Validation): Enables structured reasoning (CoT/CoD) and analysis for AI agents. Returns results as Markdown.`
 };
 const server = new McpServer(serverInfo);
+// --- Tool Prefix Compatibility Layer ---
+// Add prefixed versions of each tool to ensure backward compatibility
+const TOOL_PREFIX = "mcp_gikendaasowin-aabajichiganan_";
+// This mapping will be used to redirect legacy prefixed tool calls to the simplified names
+const prefixedToolMappings = {
+    [`${TOOL_PREFIX}think`]: "think",
+    [`${TOOL_PREFIX}assess_cuc_n_mode`]: "assess_cuc_n_mode",
+    [`${TOOL_PREFIX}quick_think`]: "quick_think",
+    [`${TOOL_PREFIX}chain_of_thought`]: "chain_of_thought",
+    [`${TOOL_PREFIX}chain_of_draft`]: "chain_of_draft",
+    [`${TOOL_PREFIX}reflection`]: "reflection",
+    [`${TOOL_PREFIX}plan_and_solve`]: "plan_and_solve"
+};
 // --- Logging Helpers ---
 /**
  * Logs an incoming tool call to stderr.
@@ -280,6 +293,146 @@ async function main() {
     try {
         const transport = new StdioServerTransport();
         await server.connect(transport);
+        // Register prefixed tool redirects using the original tool definitions
+        // Manually register each prefixed version of the tools
+        // think
+        server.tool(`${TOOL_PREFIX}think`, "**MANDATORY Central Hub for Comprehensive Analysis and Planning.** Called after assessment (`assess_cuc_n_mode`), after `chain_of_thought` or `chain_of_draft` results, or after external action results/errors. Incorporates OODReAct principles (Observe-Orient-Decide-Reason-Act) for enhanced problem-solving. This is where you perform ALL detailed analysis, planning (including multi-step strategies), reflection, synthesis, and confidence assessment. Structure your thought clearly using headings. For simpler follow-up steps, consider using `quick_think` instead.", {
+            thought: z.string().describe("Your **detailed** internal monologue covering Analysis/Observation, Plan/Decision, Verification, Risk & Contingency, and Learning & Adaptation. Use clear headings. OODReAct-style headers are recommended.")
+        }, async ({ thought }) => {
+            // Redirect to the original tool's logic
+            const toolName = 'think';
+            logToolCall(`${TOOL_PREFIX}${toolName} → ${toolName}`);
+            try {
+                // Basic Zod validation ensures it's a non-empty string. Content validation removed.
+                if (thought.trim().length === 0) {
+                    throw new Error('Invalid thought: Must be a non-empty string containing substantive reasoning.');
+                }
+                logToolResult(toolName, true, `Thought logged (length: ${thought.length})`);
+                // Log full input for traceability
+                console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Input:\n${thought}`);
+                // Returns the same thought text received, formatted as Markdown.
+                return {
+                    content: [{
+                            type: "text",
+                            text: "```markdown\n" + thought + "\n```"
+                        }]
+                };
+            }
+            catch (error) {
+                // Use logToolError to format the error for the LLM
+                return logToolError(toolName, error);
+            }
+        });
+        // assess_cuc_n_mode
+        server.tool(`${TOOL_PREFIX}assess_cuc_n_mode`, "**Mandatory Pre-Deliberation 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. Based on assessment, use either `think` (for structured analysis) or `quick_think` (for streamlined processing) in the next step.", {
+            assessment_and_choice: z.string().describe("Your structured assessment including: 1) Situation Description, 2) CUC-N Ratings (Low/Medium/High for each), 3) Rationale for ratings, 4) Recommended Initial Cognitive Strategy (e.g., 'Start with chain_of_thought then think'), 5) Explicit Mode Selection ('Selected Mode: think' or 'Selected Mode: quick_think').")
+        }, async ({ assessment_and_choice }) => {
+            // Redirect to the original tool logic
+            const toolName = 'assess_cuc_n_mode';
+            logToolCall(`${TOOL_PREFIX}${toolName} → ${toolName}`);
+            try {
+                // Basic Zod validation ensures it's a string. Content validation removed.
+                const modeRegex = /Selected Mode: (think|quick_think)/i;
+                const modeMatch = assessment_and_choice.match(modeRegex);
+                const selectedMode = modeMatch ? modeMatch[1].toLowerCase() : "unknown"; // Extract mode for logging
+                logToolResult(toolName, true, `Selected mode (extracted): ${selectedMode}`);
+                // Log full input for traceability
+                console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Input:\n${assessment_and_choice}`);
+                // Return the full assessment text formatted as Markdown
+                return {
+                    content: [{
+                            type: "text",
+                            text: "```markdown\n" + assessment_and_choice + "\n```"
+                        }]
+                };
+            }
+            catch (error) {
+                return logToolError(toolName, error);
+            }
+        });
+        // quick_think
+        server.tool(`${TOOL_PREFIX}quick_think`, "Cognitive Checkpoint for streamlined processing and simple confirmations where detailed analysis via `think` is unnecessary. Use when full structured deliberation would be excessive for the current step.", {
+            brief_thought: z.string().describe("Your **concise** thought or confirmation for this step. Briefly state the observation/action and explain why detailed analysis isn't needed.")
+        }, async ({ brief_thought }) => {
+            const toolName = 'quick_think';
+            logToolCall(`${TOOL_PREFIX}${toolName} → ${toolName}`);
+            try {
+                // Basic Zod validation ensures it's a non-empty string. Content validation removed.
+                if (brief_thought.trim().length === 0) {
+                    throw new Error('Invalid brief_thought: Must be a non-empty string.');
+                }
+                logToolResult(toolName, true, `Logged: ${brief_thought.substring(0, 80)}...`);
+                // Log full input for traceability
+                console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Input:\n${brief_thought}`);
+                // Return the brief thought text, formatted as Markdown
+                return {
+                    content: [{
+                            type: "text",
+                            text: "```markdown\n" + brief_thought + "\n```"
+                        }]
+                };
+            }
+            catch (error) {
+                return logToolError(toolName, error);
+            }
+        });
+        // chain_of_thought
+        server.tool(`${TOOL_PREFIX}chain_of_thought`, "Guides *internal generation* and logging of **detailed, step-by-step reasoning draft (CoT)**. Call this tool *with* the generated CoT text you created internally. Returns the CoT text formatted as Markdown. Follow with either `think` (for complex reasoning chains requiring detailed analysis) or `quick_think` (for straightforward reasoning steps) to process the CoT and plan next actions.", {
+            generated_cot_text: z.string().describe("The **full, step-by-step Chain of Thought draft** you generated internally to solve or analyze the problem."),
+            problem_statement: z.string().describe("The original problem statement or question this CoT addresses.")
+        }, async ({ generated_cot_text, problem_statement }) => {
+            const toolName = 'chain_of_thought';
+            logToolCall(`${TOOL_PREFIX}${toolName} → ${toolName}`);
+            try {
+                // Basic Zod validation ensures non-empty strings. Content validation removed.
+                if (generated_cot_text.trim().length === 0) {
+                    throw new Error('Invalid generated_cot_text: Must be a non-empty string containing the CoT.');
+                }
+                if (problem_statement.trim().length === 0) {
+                    throw new Error('Invalid problem_statement: Must provide the original problem.');
+                }
+                logToolResult(toolName, true, `Problem: ${problem_statement.substring(0, 50)}...`);
+                // Log full input for traceability
+                console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Input:\nProblem: ${problem_statement}\nReasoning:\n${generated_cot_text}`);
+                // Return the CoT text, formatted as Markdown
+                return {
+                    content: [{
+                            type: "text",
+                            text: "```markdown\n" + generated_cot_text + "\n```"
+                        }]
+                };
+            }
+            catch (error) {
+                return logToolError(toolName, error);
+            }
+        });
+        // chain_of_draft
+        server.tool(`${TOOL_PREFIX}chain_of_draft`, "Signals that one or more **internal drafts** have been generated/refined using **Chain of Draft (CoD)** principles. CoD aims for **maximum efficiency** by mimicking human note-taking, focusing on minimal token usage while preserving reasoning quality. Use this *instead of* detailed Chain of Thought when speed and token economy are important, or when the reasoning involves calculations or symbolic manipulation.\n\n**How to Construct SOTA CoD Internally:**\n1.  **Extreme Conciseness:** Each reasoning step or draft element should be extremely brief (e.g., often just 1-5 words, like a quick note). AVOID full sentences.\n2.  **Symbols & Equations:** Prioritize mathematical notation (e.g., `x = 5*y`, `area = l*w`), code snippets (e.g., `user.id`, `config['key']`), or recognized symbols over descriptive text.\n3.  **Essential Information Only:** Capture only the absolute minimum information needed to proceed. Omit explanations, justifications, or restatements of the problem unless strictly necessary for the next step.\n4.  **Structure:** Can be a sequence of short phrases, key values, equations, or code elements, often line-by-line. Think 'scratchpad' not 'essay'.\n5.  **Contrast with CoT:** Unlike CoT's verbose explanations, CoD focuses purely on the *result* or *key element* of each reasoning step.\n6.  **Final Answer (Optional but Recommended):** If the CoD sequence leads directly to a final answer, clearly mark it at the end, often using `#### Final Answer: [answer]`.\n\nCall this tool *after* generating/refining draft(s) internally following these guidelines. Provide a brief description of the draft's purpose. Returns the description formatted as Markdown. Follow with either `think` (for complex drafts requiring detailed analysis) or `quick_think` (for straightforward drafts) to evaluate and plan next steps.", {
+            draft_description: z.string().describe("Brief but specific description of the CoD draft(s) generated/refined internally (e.g., 'Calculated intermediate values x, y', 'API call structure draft', 'Error handling logic sketch', 'Key parameters extracted').")
+        }, async ({ draft_description }) => {
+            const toolName = 'chain_of_draft';
+            logToolCall(`${TOOL_PREFIX}${toolName} → ${toolName}`);
+            try {
+                // Basic Zod validation ensures non-empty string. Content validation removed.
+                if (draft_description.trim().length === 0) {
+                    throw new Error('Invalid draft_description: Must provide a description.');
+                }
+                logToolResult(toolName, true);
+                // Log full input for traceability
+                console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Input:\nDescription: ${draft_description}`);
+                // Return the draft description, formatted as Markdown
+                return {
+                    content: [{
+                            type: "text",
+                            text: "```markdown\n" + draft_description + "\n```"
+                        }]
+                };
+            }
+            catch (error) {
+                return logToolError(toolName, error);
+            }
+        });
+        console.error(`[MCP Server] Registered compatibility aliases for prefixed tool names`);
         const border = '-----------------------------------------------------';
         console.error(border);
         console.error(` ${serverInfo.description}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nbiish/cognitive-tools-mcp",
-  "version": "0.9.19",
+  "version": "0.9.21",
   "description": "Cognitive Tools MCP: SOTA reasoning suite focused on iterative refinement and tool integration for AI Pair Programming. Enables structured, iterative problem-solving through Chain of Draft methodology, with tools for draft generation, analysis, and refinement. Features advanced deliberation (`think`), rapid checks (`quick_think`), mandatory complexity assessment & thought mode selection (`assess_cuc_n_mode`), context synthesis, confidence gauging, proactive planning, explicit reasoning (CoT), and reflection with content return. Alternative package name for gikendaasowin-aabajichiganan-mcp.",
   "private": false,
   "type": "module",