@nbiish/cognitive-tools-mcp 2.0.12 → 2.0.16

package/README.md

@@ -43,6 +43,7 @@ Known as:
 Both packages are maintained in parallel and receive the same updates. You can use either package name in your projects - they provide identical functionality.
 
 **Recent Updates:**
+- v2.0.15: Updated Zod schema usage in `server.tool` to fix type error and rebuilt.
 - v2.0.6: Added `mental_sandbox` tool for logging internal cognitive simulations.
 - v2.0.6: Removed prefixing from cognitive tool outputs to ensure verbatim logging.
 - Resolved TypeScript compilation errors related to MCP SDK types and server configuration.

package/build/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 /**
  * -----------------------------------------------------------------------------
- * Gikendaasowin Aabajichiganan - Agentic Cognitive Tools MCP Server (v3.2)
+ * Gikendaasowin Aabajichiganan - Agentic Cognitive Tools MCP Server (v3.4)
  *
  * Description: Provides cognitive tools implementing the Gikendaasowin v7
  * Agentic Operational Guidelines. Enforces a mandatory structured
@@ -12,10 +12,14 @@
  * Chain-of-Thought (SCoT)**. Aligns with dynamic tool environments,
  * including CodeAct preference. Returns Markdown.
  *
- * v3.2 Enhancements:
- * - Expanded cognitive technique acronyms (OOReDAct, CoT, CoD/CR, SCoT)
- *   with brief explanations on first use in descriptions.
- * - Maintained internal system prompt framing.
+ * v3.4 Enhancements:
+ * - Enhanced the description of the `deliberate` tool to be expertly verbose,
+ *   explaining the prompting techniques (CoT, CoD/CR, SCoT) before using acronyms,
+ *   drawing from the provided research context for professional precision.
+ * - Maintained tooling compression, internal system prompt framing, and
+ *   expanded cognitive technique acronyms (with explanations on first use in
+ *   the main server description).
+ * - Simplified error reporting.
  * -----------------------------------------------------------------------------
  */
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -24,9 +28,9 @@ import { z } from "zod";
 // --- Server Definition ---
 const serverInfo = {
     name: "gikendaasowin-agentic-cognitive-tools-mcp",
-    version: "3.2.0", // Version reflects acronym expansion
-    // Updated description with expanded acronyms
-    description: `ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Agentic Cognitive Tools (v3.2): Implements Gikendaasowin v7 Guidelines. Enforces MANDATORY internal **Observe-Orient-Reason-Decide-Act (OOReDAct)** cycle: Starts with 'assess_and_orient', continues with 'think' deliberation before actions. Guides adaptive reasoning (**Chain-of-Thought (CoT)**, **Chain-of-Draft/Condensed Reasoning (CoD/CR)**, **Structured Chain-of-Thought (SCoT)**) & CodeAct preference. Returns Markdown.`
+    version: "3.4.0", // Version reflects enhanced tool description verbosity
+    // Updated description with consolidated tooling and expanded acronyms
+    description: `ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Agentic Cognitive Tools (v3.4): Implements Gikendaasowin v7 Guidelines. Enforces MANDATORY internal **Observe-Orient-Reason-Decide-Act (OOReDAct)** cycle using the unified 'deliberate' tool. Starts with initial assessment/orientation, continues with structured deliberation and mandatory mental sandbox logging before actions. Guides adaptive reasoning (**Chain-of-Thought (CoT)**: step-by-step natural language reasoning; **Chain-of-Draft/Condensed Reasoning (CoD/CR)**: iterative refinement/concise steps; **Structured Chain-of-Thought (SCoT)**: reasoning incorporating program structures/plans) & CodeAct preference. Returns Markdown.`
 };
 const server = new McpServer(serverInfo);
 // --- Logging Helpers (Internal - No changes needed) ---
@@ -50,8 +54,7 @@ function logToolResult(toolName, success, resultDetails) {
     console.error(`[${timestamp}] [MCP Server] < Tool Result: ${toolName} - ${success ? 'Success' : 'Failure'}${resultDetails ? ` - ${resultDetails}` : ''}`);
 }
 /**
- * Logs an error during tool execution and formats a standard error response for the LLM,
- * guiding towards the mandatory internal deliberation cycle with expanded acronyms on first use.
+ * Logs an error during tool execution and formats a standard error response for the LLM.
  * @param toolName The name of the tool where the error occurred.
  * @param error The error object or message.
  * @returns An object matching the required MCP tool result structure containing the error message.
@@ -61,145 +64,44 @@ function logToolError(toolName, error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     console.error(`[${timestamp}] [MCP Server] ! Tool Error: ${toolName} - ${errorMessage}`);
     logToolResult(toolName, false, errorMessage); // Log failure result as well
-    // **Simplified Error Reporting:** Return only the core error message.
+    // Simplified Error Reporting: Return only the core error message.
     return {
         content: [{
                 type: "text",
-                // Simpler error message, removing corrective action guidance.
                 text: `**TOOL EXECUTION ERROR in '${toolName}':** ${errorMessage}`
             }]
     };
 }
-// --- Core Cognitive Deliberation & Refinement Steps (v3.2 - Expanded Acronyms) ---
+// --- Consolidated Cognitive Deliberation & Refinement Step (v3.4) ---
 /**
- * Step: assess_and_orient (Mandatory Initial Assessment & Orientation)
- * Purpose: **Mandatory first step** for every new user request AND before any significant strategic pivot.
- * Establishes initial context by assessing task characteristics (Complexity, Uncertainty, Consequence, Novelty - CUC-N)
- * and performing the initial Observe/Orient steps of the **Observe-Orient-Reason-Decide-Act (OOReDAct)** cycle.
- * Workflow: **Perform this step** at the beginning of processing a user request or when changing overall approach.
- * Its output informs the *first* full OOReDAct cycle (`think` step).
- * Input: A single string provided by the LLM (treated as opaque data).
- * Output: The input string, returned verbatim.
- */
-server.tool("assess_and_orient", 
-// **Internal Framing:** Expanded OOReDAct on first mention.
-"**Mandatory Initial Assessment & Orientation:** At the start of EVERY user request AND before any major change in strategy, you MUST perform this initial assessment and orientation. Analyze the request/situation using CUC-N (Complexity, Uncertainty, Consequence, Novelty) to perform the initial 'Observe' and 'Orient' steps of the **Observe-Orient-Reason-Decide-Act (OOReDAct)** cycle. This assessment is CRITICAL for grounding your subsequent reasoning and planning within the main OOReDAct cycle.", {
-    // Input is a simple string, description reflects pass-through nature.
-    assessment_and_orientation_text: z.string().describe("Provide the assessment/orientation text. This tool acts as a passthrough and will return the input verbatim without validation or modification.")
-}, 
-// Simplified handler: No validation, just return input.
-async ({ assessment_and_orientation_text }) => {
-    const toolName = 'assess_and_orient';
-    logToolCall(toolName);
-    try {
-        // No validation or processing - treat input as opaque string
-        logToolResult(toolName, true, `Input received (length: ${assessment_and_orientation_text.length})`);
-        // Log the raw input string
-        console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Input String:\n${assessment_and_orientation_text}`);
-        // Return the input string directly
-        return { content: [{ type: "text", text: assessment_and_orientation_text }] };
-    }
-    catch (error) {
-        // Catch only unexpected runtime errors
-        return logToolError(toolName, error);
-    }
-});
-/**
- * Step: think (Mandatory OOReDAct Deliberation Cycle)
+ * Tool: deliberate (Unified Cognitive Process)
  * Purpose: The **REQUIRED & CENTRAL cognitive process** for the **MANDATORY** structured deliberation cycle
- * (**Observe-Orient-Reason-Decide-Act (OOReDAct)**).
- * Workflow: **You MUST perform this full, structured OOReDAct cycle** *after* the initial `assess_and_orient` step,
- * *after* receiving subsequent new information (tool results, CodeAct output/errors, USER input, file reads),
- * and *before* executing any non-trivial action or providing a final response. Use it to rigorously follow the OOReDAct
- * structure, document reasoning (adapting reasoning styles like **Chain-of-Thought (CoT)**, **Chain-of-Draft/Condensed Reasoning (CoD/CR)**,
- * or **Structured Chain-of-Thought (SCoT)** as needed), decide the next step, and plan actions precisely.
- * Input: A single string provided by the LLM (treated as opaque data).
- * Output: The input string, returned verbatim.
- */
-server.tool("think", 
-// **Internal Framing:** Expanded OOReDAct, CoT, CoD/CR, SCoT on first mention in this tool's description.
-"**Mandatory OOReDAct Deliberation Cycle:** You MUST perform the full, structured **Observe-Orient-Reason-Decide-Act (OOReDAct)** cycle *after* the initial `assess_and_orient` step, *after* receiving new information (tool/CodeAct results, errors, USER input), and *before* any non-trivial action or final response. Follow the complete OOReDAct structure, adapting your reasoning style within the 'Reason' step (e.g., using detailed **Chain-of-Thought (CoT)** for complexity, concise **Chain-of-Draft/Condensed Reasoning (CoD/CR)** for efficiency, or **Structured Chain-of-Thought (SCoT)** for planning/code) for reliable, verifiable, and adaptive behavior.", {
-    // Input is a simple string, description reflects pass-through nature.
-    thought: z.string().describe("Provide the OOReDAct deliberation text. This tool acts as a passthrough and will return the input verbatim without validation or modification.")
-}, 
-// Simplified handler: No validation, just return input.
-async ({ thought }) => {
-    const toolName = 'think';
-    logToolCall(toolName);
-    try {
-        // No validation or processing - treat input as opaque string
-        logToolResult(toolName, true, `Input received (length: ${thought.length})`);
-        // Log the raw input string
-        console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Input String:\n${thought}`);
-        // Return the input string directly
-        return { content: [{ type: "text", text: thought }] };
-    }
-    catch (error) {
-        // Catch only unexpected runtime errors
-        return logToolError(toolName, error);
-    }
-});
-/**
- * Step: quick_think (Minimal Cognitive Acknowledgement)
- * Purpose: For acknowledging *simple, expected, non-problematic* outcomes ONLY, where the next step is
- * *already clearly defined* by a prior **Observe-Orient-Reason-Decide-Act (OOReDAct)** cycle (`think` step)
- * and requires NO re-evaluation or adaptation.
- * Workflow: Use sparingly to maintain cognitive flow in straightforward sequences. **Does NOT replace the mandatory OOReDAct cycle**.
- * The full OOReDAct cycle (`think` step) is MANDATORY for handling new information, errors, planning changes,
- * or any step requiring analysis or decision-making.
- * Input: A single string provided by the LLM (treated as opaque data).
- * Output: The brief acknowledgement text (Markdown).
- */
-server.tool("quick_think", 
-// **Internal Framing:** Expanded OOReDAct on first mention here.
-"**Minimal Cognitive Acknowledgement:** Use ONLY for acknowledging *simple, expected, non-problematic* outcomes (e.g., 'Data fetch OK, proceeding with planned analysis') where the next step is *already determined* by a prior **Observe-Orient-Reason-Decide-Act (OOReDAct)** cycle (`think` step) and needs NO re-evaluation. Helps maintain flow in simple sequences. **This step DOES NOT satisfy the mandatory OOReDAct deliberation requirement.** Perform the full OOReDAct cycle (`think` step) for any analysis, planning, reasoning, error handling, or decision making.", {
-    // Input is a simple string, description reflects pass-through nature.
-    brief_thought: z.string().describe("Provide the brief acknowledgement text. This tool acts as a passthrough and will return the input verbatim without validation or modification.")
-}, 
-// Simplified handler: No validation, just return input.
-async ({ brief_thought }) => {
-    const toolName = 'quick_think';
-    logToolCall(toolName);
-    try {
-        // No validation or processing - treat input as opaque string
-        logToolResult(toolName, true, `Input received (length: ${brief_thought.length})`);
-        // Log the raw input string
-        console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Input String:\n${brief_thought}`);
-        // Return the input string directly
-        return { content: [{ type: "text", text: brief_thought }] };
-    }
-    catch (error) {
-        // Catch only unexpected runtime errors
-        return logToolError(toolName, error);
-    }
-});
-/**
- * Tool: mental_sandbox (Mental Sandbox Simulation Logging)
- * Purpose: **Mandatory Step** for logging the internal cognitive simulation (`<sandbox>`) BEFORE any non-trivial output,
- * plan, decision, or action, encompassing steps like Hypothesis Generation/Testing, Constraint Checks,
- * Confidence Scoring, and Pre-computational Analysis.
- * Workflow: Invoke this tool to record the detailed simulation text. The tool functions as a passthrough,
- * returning the provided text verbatim without modification.
- * Input: A single string containing the detailed sandbox simulation text.
- * Output: The input string, returned verbatim.
+ * (**Observe-Orient-Reason-Decide-Act (OOReDAct)**). This tool consolidates the functionality of
+ * `assess_and_orient`, `think`, `quick_think`, and `mental_sandbox` into a single, flexible interface.
+ * Workflow: **You MUST use this tool** for:
+ * 1. Initial assessment and orientation (`stage: "orient"`).
+ * 2. Full, structured OOReDAct deliberation after receiving new information or before non-trivial actions (`stage: "reason"`).
+ * 3. Brief cognitive acknowledgement of simple, expected outcomes (`stage: "acknowledge"`).
+ * 4. Logging the mandatory mental sandbox simulation before actions (`stage: "sandbox"`).
+ * Adapt your reasoning style within the 'Reason' stage using techniques like Chain-of-Thought, Chain-of-Draft/Condensed Reasoning, or Structured Chain-of-Thought.
+ * Input: An object containing the stage and corresponding cognitive content.
+ * Output: The provided content, returned verbatim.
  */
-server.tool("mental_sandbox", 
-// **Internal Framing:** Tool for logging the mandatory sandbox simulation.
-"**Mandatory Mental Sandbox Simulation Logging:** Use this tool BEFORE any non-trivial output/plan/decision/action to log the mandatory internal `<sandbox>` simulation (Hypothesis Testing, Constraint Checks, Confidence, Pre-computation, etc.) as per operational directives. This tool acts as a passthrough and returns the provided simulation text verbatim.", {
-    // Input is a simple string, description reflects pass-through nature.
-    sandbox_content: z.string().describe("Provide the sandbox simulation text. This tool acts as a passthrough and will return the input verbatim without validation or modification.")
-}, 
-// Simplified handler: No validation, just return input.
-async ({ sandbox_content }) => {
-    const toolName = 'mental_sandbox';
-    logToolCall(toolName);
+server.tool("deliberate", 
+// Expertly verbose description explaining techniques before acronyms
+"**Unified Cognitive Process (Mandatory):** This is your REQUIRED tool for ALL internal cognitive steps, enforcing the **Observe-Orient-Reason-Decide-Act (OOReDAct)** cycle. Use `stage: \"orient\"` for the MANDATORY initial assessment (Complexity, Uncertainty, Consequence, Novelty - CUC-N) and OOReDAct Observe/Orient steps at the start of ANY task or strategic pivot. Use `stage: \"reason\"` for the MANDATORY full OOReDAct deliberation cycle after receiving new information (tool/CodeAct results, errors, USER input) and BEFORE any non-trivial action or final response. Within the 'Reason' stage, adapt your reasoning style for optimal performance: employ **Chain-of-Thought** (step-by-step natural language reasoning for complex problems, enhancing accuracy), **Chain-of-Draft/Condensed Reasoning** (iterative refinement or concise steps for efficiency), or **Structured Chain-of-Thought** (reasoning that explicitly incorporates program structures, plans, or structured steps, particularly effective for code generation and structured tasks). Use `stage: \"acknowledge\"` ONLY for brief acknowledgements of simple, expected outcomes where the next step is already clearly defined by a prior 'reason' stage and needs NO re-evaluation. Use `stage: \"sandbox\"` to log the MANDATORY internal `<sandbox>` simulation (Hypothesis Testing, Constraint Checks, Confidence Scoring, Pre-computation, etc.) BEFORE any non-trivial output, plan, decision, or action, as per operational directives. This tool acts as a passthrough, returning the provided content verbatim.", z.object({
+    stage: z.enum(["orient", "reason", "acknowledge", "sandbox"]).describe("The current stage of the cognitive process."),
+    content: z.string().describe("The cognitive content for the specified stage (assessment, deliberation, acknowledgement, or sandbox simulation text). This tool acts as a passthrough.")
+}).shape, async ({ stage, content }) => {
+    const toolName = 'deliberate';
+    logToolCall(toolName, `Stage: ${stage}`);
     try {
-        // No validation or processing - treat input as opaque string
-        logToolResult(toolName, true, `Input received (length: ${sandbox_content.length})`);
-        // Log the raw input string
-        console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Input String:\n${sandbox_content}`);
+        // Treat input as opaque string for the specified stage
+        logToolResult(toolName, true, `Stage: ${stage}, Input received (length: ${content.length})`);
+        // Log the raw input string with stage context
+        console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} (${stage}) Input String:\n${content}`);
         // Return the input string directly
-        return { content: [{ type: "text", text: sandbox_content }] };
+        return { content: [{ type: "text", text: content }] };
     }
     catch (error) {
         // Catch only unexpected runtime errors
@@ -248,7 +150,7 @@ async function main() {
         console.error(border);
         console.error(` ${serverInfo.description}`); // Uses updated description
         console.error(` Version: ${serverInfo.version}`);
-        console.error(` Enforcing Gikendaasowin v7 Guidelines with Internal OOReDAct Cycle`);
+        console.error(` Enforcing Gikendaasowin v7 Guidelines with Unified 'deliberate' Tool`);
         console.error(' Status: Running on stdio, awaiting MCP requests...');
         console.error(border);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nbiish/cognitive-tools-mcp",
-  "version": "2.0.12",
+  "version": "2.0.16",
   "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",