@nbiish/cognitive-tools-mcp 0.9.28 → 0.9.30

package/LICENSE

@@ -68,13 +68,13 @@ WHEREAS the inherent sovereignty of tribal nations provides a constitutional and
    Any use, reproduction, distribution, modification, adaptation, display, performance, transmission, or creation of derivative works based on this Work, whether in whole or in part, must prominently and accurately include the following citation and attribution in all associated materials, displays, publications, and metadata:
 
    ```bibtex
-   @misc{gikendaasowin-aabajichiganan-mcp2025,
+   @misc{<|repo_title|><|current_year=2025|>,
      author/creator/steward = {ᓂᐲᔥ ᐙᐸᓂᒥᑮ-ᑭᓇᐙᐸᑭᓯ (Nbiish Waabanimikii-Kinawaabakizi), also known legally as JUSTIN PAUL KENWABIKISE, professionally documented as Nbiish-Justin Paul Kenwabikise, Anishinaabek Dodem (Anishinaabe Clan): Animikii (Thunder), descendant of Chief ᑭᓇᐙᐸᑭᓯ (Kinwaabakizi) of the Beaver Island Band and enrolled member of the sovereign Grand Traverse Band of Ottawa and Chippewa Indians},
-     title/description = {gikendaasowin-aabajichiganan-mcp},
+     title/description = {<|repo_title|>},
      type_of_work = {Indigenous digital creation/software incorporating traditional knowledge and cultural expressions},
-     year = {2025},
+     year = {<|current_year|>},
      publisher/source/event = {GitHub repository under tribal sovereignty protections},
-     howpublished = {\\url{https://github.com/nbiish/gikendaasowin-aabajichiganan-mcp}},
+     howpublished = {\url{https://github.com/nbiish/<|repo_title|>}},
      note = {Authored and stewarded by ᓂᐲᔥ ᐙᐸᓂᒥᑮ-ᑭᓇᐙᐸᑭᓯ (Nbiish Waabanimikii-Kinawaabakizi), also known legally as JUSTIN PAUL KENWABIKISE, professionally documented as Nbiish-Justin Paul Kenwabikise, Anishinaabek Dodem (Anishinaabe Clan): Animikii (Thunder), descendant of Chief ᑭᓇᐙᐸᑭᓯ (Kinwaabakizi) of the Beaver Island Band and enrolled member of the sovereign Grand Traverse Band of Ottawa and Chippewa Indians. This work embodies Indigenous intellectual property, traditional knowledge systems (TK), traditional cultural expressions (TCEs), and associated data protected under tribal law, federal Indian law, treaty rights, Indigenous Data Sovereignty principles, and international indigenous rights frameworks including UNDRIP. All usage, benefit-sharing, and data governance are governed by the COMPREHENSIVE RESTRICTED USE LICENSE FOR INDIGENOUS CREATIONS WITH TRIBAL SOVEREIGNTY, DATA SOVEREIGNTY, AND WEALTH RECLAMATION PROTECTIONS.}
    }
    ```

package/README.md

@@ -7,14 +7,11 @@
   type_of_work = {Indigenous digital creation/software incorporating traditional knowledge and cultural expressions},
   year = {2025},
   publisher/source/event = {GitHub repository under tribal sovereignty protections},
-  howpublished = {\\url{https://github.com/nbiish/gikendaasowin-aabajichiganan-mcp}},
-  note = {Authored and stewarded by ᓂᐲᔥ ᐙᐸᓂᒥᑮ-ᑭᓇᐙᐸᑭᓯ (Nbiish Waabanimikii-Kinawaabakizi), also known legally as JUSTIN PAUL KENWABIKISE, professionally documented as Nbiish-Justin Paul Kenwabikise, Anishinaabek Dodem (Anishinaabe Clan): Animikii (Thunder), descendant of Chief ᑭᓇᐙᐸᑭᓯ (Kinwaabakizi) of the Beaver Island Band and enrolled member of the sovereign Grand Traverse Band of Ottawa and Chippewa Indians. This work embodies Indigenous intellectual property, traditional knowledge systems (TK), traditional cultural expressions (TCEs), and associated data protected under tribal law, federal Indian law, treaty rights, Indigenous Data Sovereignty principles, and international indigenous rights frameworks including UNDRIP. All usage, benefit-sharing, and data governance are governed by the COMPREHENSIVE RESTRICTED USE LICENSE FOR INDIGENOUS CREATIONS WITH TRIBAL SOVEREIGNTY, DATA SOVEREIGNTY, AND WEALTH RECLAMATION PROTECTIONS.}\n}
+  howpublished = {\url{https://github.com/nbiish/gikendaasowin-aabajichiganan-mcp}},
+  note = {Authored and stewarded by ᓂᐲᔥ ᐙᐸᓂᒥᑮ-ᑭᓇᐙᐸᑭᓯ (Nbiish Waabanimikii-Kinawaabakizi), also known legally as JUSTIN PAUL KENWABIKISE, professionally documented as Nbiish-Justin Paul Kenwabikise, Anishinaabek Dodem (Anishinaabe Clan): Animikii (Thunder), descendant of Chief ᑭᓇᐙᐸᑭᓯ (Kinwaabakizi) of the Beaver Island Band and enrolled member of the sovereign Grand Traverse Band of Ottawa and Chippewa Indians. This work embodies Indigenous intellectual property, traditional knowledge systems (TK), traditional cultural expressions (TCEs), and associated data protected under tribal law, federal Indian law, treaty rights, Indigenous Data Sovereignty principles, and international indigenous rights frameworks including UNDRIP. All usage, benefit-sharing, and data governance are governed by the COMPREHENSIVE RESTRICTED USE LICENSE FOR INDIGENOUS CREATIONS WITH TRIBAL SOVEREIGNTY, DATA SOVEREIGNTY, AND WEALTH RECLAMATION PROTECTIONS.}
+}
 ```
 
-Copyright © 2025 ᓂᐲᔥ ᐙᐸᓂᒥᑮ-ᑭᓇᐙᐸᑭᓯ (Nbiish Waabanimikii-Kinawaabakizi), also known legally as JUSTIN PAUL KENWABIKISE, professionally documented as Nbiish-Justin Paul Kenwabikise, Anishinaabek Dodem (Anishinaabe Clan): Animikii (Thunder), a descendant of Chief ᑭᓇᐙᐸᑭᓯ (Kinwaabakizi) of the Beaver Island Band, and an enrolled member of the sovereign Grand Traverse Band of Ottawa and Chippewa Indians. This work embodies Traditional Knowledge and Traditional Cultural Expressions. All rights reserved.
-
-This project is licensed under the [COMPREHENSIVE RESTRICTED USE LICENSE FOR INDIGENOUS CREATIONS WITH TRIBAL SOVEREIGNTY, DATA SOVEREIGNTY, AND WEALTH RECLAMATION PROTECTIONS](LICENSE).
-
 <div align="center">
   <hr width="50%">
   
@@ -33,6 +30,10 @@ This project is licensed under the [COMPREHENSIVE RESTRICTED USE LICENSE FOR IND
   <hr width="50%">
 </div>
 
+Copyright © 2025 ᓂᐲᔥ ᐙᐸᓂᒥᑮ-ᑭᓇᐙᐸᑭᓯ (Nbiish Waabanimikii-Kinawaabakizi), also known legally as JUSTIN PAUL KENWABIKISE, professionally documented as Nbiish-Justin Paul Kenwabikise, Anishinaabek Dodem (Anishinaabe Clan): Animikii (Thunder), a descendant of Chief ᑭᓇᐙᐸᑭᓯ (Kinwaabakizi) of the Beaver Island Band, and an enrolled member of the sovereign Grand Traverse Band of Ottawa and Chippewa Indians. This work embodies Traditional Knowledge and Traditional Cultural Expressions. All rights reserved.
+
+This project is licensed under the [COMPREHENSIVE RESTRICTED USE LICENSE FOR INDIGENOUS CREATIONS WITH TRIBAL SOVEREIGNTY, DATA SOVEREIGNTY, AND WEALTH RECLAMATION PROTECTIONS](LICENSE).
+
 ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Gikendaasowin Aabajichiganan - 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 include advanced deliberation (`think`), rapid checks (`quick_think`), mandatory complexity assessment (`assess_cuc_n_mode`), context synthesis, confidence gauging, proactive planning, explicit reasoning (CoT), and reflection.
 
 Known as:

package/build/index.js

@@ -1,26 +1,25 @@
 #!/usr/bin/env node
 /**
  * -----------------------------------------------------------------------------
- * Gikendaasowin Aabajichiganan - Core Cognitive Tools MCP Server (Ultra-Simplified Core)
+ * Gikendaasowin Aabajichiganan - Core Cognitive Tools MCP Server (v1.2 - Generalized)
  *
- * Description: Provides an ultra-streamlined suite of cognitive tools for an AI agent,
- *              focusing on assessment (`assess_cuc_n_mode`) and a central
- *              deliberation hub (`think` / `quick_think`). Chain of Thought (CoT)
- *              and Chain of Draft (CoD) reasoning styles are performed *within*
- *              the `think` tool as guided by the system prompt, not via separate tools.
- *              Validation on input content structure is removed. Tool results are
- *              returned as formatted Markdown. Versioning removed.
+ * Description: Provides a streamlined suite of cognitive tools for an AI agent,
+ *              inspired by research on improving LLM reasoning (like Anthropic's 'think' tool)
+ *              applicable across domains (coding, research, planning, etc.).
+ *              Focuses on assessment (`assess_cuc_n_mode`) and a central deliberation
+ *              hub (`think`) used especially after receiving information/results.
+ *              `quick_think` is for trivial steps. CoT/CoD reasoning styles occur within `think`.
+ *              Returns Markdown.
  *
  * Key Principles:
- * 1.  **Focused Deliberation:** Tools guide assessment (`assess_cuc_n_mode`) and
+ * 1.  **Structured Deliberation:** Tools guide assessment (`assess_cuc_n_mode`) and
  *     thinking/analysis (`think`, `quick_think`).
- * 2.  **Centralized Analysis (`think`):** The `think` tool is the hub for all
- *     complex analysis, planning, reflection, synthesis, confidence assessment,
- *     and generation of detailed (CoT-style) or concise (CoD-style) reasoning.
- * 3.  **CUC-N Assessment:** `assess_cuc_n_mode` guides initial cognitive depth.
- * 4.  **Iterative Loop:** Assess -> Think/QuickThink -> Analyze results in Think/QuickThink.
- * 5.  **Traceability:** All tool inputs are logged for a complete record.
- * 6.  **Markdown Output:** Tool results are formatted as Markdown.
+ * 2.  **Centralized Analysis (`think`):** The `think` tool is the hub for analysis (results, errors),
+ *     planning, reflection, policy checks, and reasoning (CoT/CoD). **Crucially used after info/results.**
+ * 3.  **CUC-N Assessment:** `assess_cuc_n_mode` guides initial cognitive depth choice.
+ * 4.  **Iterative Loop:** Assess -> [Action/Tool] -> Analyze Result/State (`think`) -> Plan (`think`) -> [Execute].
+ * 5.  **Traceability & Reliability:** Tool inputs logged; structured thinking enhances reliability across tasks.
+ * 6.  **Markdown Output:** Tool results formatted as Markdown.
  *
  * Protocol:    Model Context Protocol (MCP) over stdio.
  * -----------------------------------------------------------------------------
@@ -31,12 +30,12 @@ import { z } from "zod";
 // --- Server Definition ---
 const serverInfo = {
     name: "gikendaasowin-aabajichiganan-mcp",
-    version: "1.0.0",
-    // Version field removed
-    description: `ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Core Cognitive Tools Suite (Ultra-Simplified): Focuses on Assess/Think loop. CoT/CoD styles are integrated into 'think'. Returns Markdown.`
+    version: "1.2.0", // Incremented version
+    description: `ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Core Cognitive Tools (Generalized v1.2): Focuses on Assess/Think loop, using 'think' for post-result/state analysis across domains (code, research, etc.) to improve reliability. CoT/CoD integrated into 'think'. Returns Markdown.`
 };
 const server = new McpServer(serverInfo);
 // --- Logging Helpers ---
+// [Keep existing logToolCall, logToolResult, logToolError functions]
 /**
  * Logs an incoming tool call to stderr.
  * @param toolName The name of the tool being called.
@@ -71,43 +70,38 @@ function logToolError(toolName, error) {
     return {
         content: [{
                 type: "text",
-                text: `Error executing tool '${toolName}': ${errorMessage}. Please analyze this error.`
+                text: `Error executing tool '${toolName}': ${errorMessage}. Use the 'think' tool to analyze this error, check context, and plan the next step.` // Enhanced suggestion
             }]
     };
 }
 // --- Core Cognitive Deliberation & Refinement Tools ---
 /**
  * Tool: assess_cuc_n_mode
- * Purpose: Initial assessment of task characteristics to determine cognitive strategy.
+ * Purpose: Initial assessment of task characteristics to guide cognitive strategy selection.
  * Workflow: Call BEFORE starting complex tasks or significantly changing strategy.
  * Output: Returns the full assessment text formatted as Markdown.
  */
-server.tool("assess_cuc_n_mode", "**Initial Assessment.** Evaluates task Complexity, Uncertainty, Consequence, Novelty (CUC-N) to determine required cognitive depth and initial strategy. Call before starting complex tasks. 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., 'Proceed with think step'), 5) Explicit Mode Selection ('Selected Mode: think' or 'Selected Mode: quick_think').")
+server.tool("assess_cuc_n_mode", "**Initial Assessment.** Evaluates task Complexity, Uncertainty, Consequence, Novelty (CUC-N) to guide cognitive strategy. Call before complex tasks (coding, research, multi-step plans). Based on assessment, explicitly select and state whether the next step requires the detailed `think` tool (for analysis, planning, complex results) or the minimal `quick_think` tool (for trivial steps only).", {
+    assessment_and_choice: z.string().describe("Your structured assessment including: 1) Situation/Task Description, 2) CUC-N Ratings (Low/Medium/High for each), 3) Rationale, 4) Recommended Cognitive Strategy (e.g., 'Requires careful step-by-step planning'), 5) Explicit Mode Selection ('Selected Mode: think' or 'Selected Mode: quick_think').")
 }, async ({ assessment_and_choice }) => {
     const toolName = 'assess_cuc_n_mode';
     logToolCall(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
-        // Ensure assessment_and_choice is a non-empty string
+        const selectedMode = modeMatch ? modeMatch[1].toLowerCase() : "unknown";
         if (assessment_and_choice.trim().length === 0) {
             throw new Error('Invalid assessment_and_choice: Must be a non-empty string.');
         }
         if (!modeMatch) {
-            // Add a check for the mode selection presence
             throw new Error('Invalid assessment: String must include explicit "Selected Mode: think" or "Selected Mode: quick_think".');
         }
         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, now without markdown wrappers
         return {
             content: [{
                     type: "text",
-                    text: assessment_and_choice // Removed wrappers
+                    text: assessment_and_choice
                 }]
         };
     }
@@ -117,60 +111,57 @@ server.tool("assess_cuc_n_mode", "**Initial Assessment.** Evaluates task Complex
 });
 /**
  * Tool: think
- * Purpose: The **CENTRAL, COMPREHENSIVE HUB** for the cognitive loop. Incorporates OODReAct principles.
- * Workflow: Handles ALL complex analysis, planning, reflection, synthesis, confidence assessment, and generation of detailed (CoT-style) or concise (CoD-style) reasoning. Structure is guided by the prompt.
+ * Purpose: The **CENTRAL HUB** for structured reasoning, analysis, and planning across all complex tasks.
+ * Workflow: Use this tool to **stop and think** *after* receiving information (tool results, calculations, user input, file content) or *before* taking a complex action (generating code, calling critical tools, formulating multi-part answers). Analyze inputs/results, check goals/policies/constraints, verify state, plan next steps, brainstorm, and perform detailed reasoning (CoT/CoD). Essential for reliability, error handling, and managing sequential tasks.
  * Output: Returns the structured thought text itself, formatted as Markdown.
  */
-server.tool("think", "**Central Hub for Comprehensive Analysis and Planning.** Use after `assess_cuc_n_mode`, after external action results/errors, or after `quick_think` if deeper analysis is needed. Incorporates OODReAct principles. Perform ALL detailed analysis, planning, reflection, synthesis, confidence assessment, and detailed (CoT-style) or concise (CoD-style) reasoning within this tool. Structure your thought clearly using headings. For simpler follow-up steps, consider using `quick_think`.", {
-    thought: z.string().describe("Your **detailed** internal monologue covering Analysis/Observation, Plan/Decision, Verification, Risk & Contingency, and Learning & Adaptation. Include CoT/CoD style reasoning in the 'Reason' section when needed. Use clear headings. OODReAct-style headers are recommended.")
+server.tool("think", "**Central Hub for Analysis, Planning & Reasoning.** Use this tool to **stop and think**, especially *after* receiving information (tool results, errors, data) or before complex actions (coding, critical decisions). Analyze inputs/results, check goals/policies, verify information, plan next steps, and perform detailed reasoning (CoT/CoD) as needed. Crucial for reliability in coding, research, planning, and error recovery. Structure thought using clear headings (see prompt examples).", {
+    thought: z.string().describe("Your **structured** internal deliberation. MUST follow prompt guidance (Observe, Orient, Decide, Reason, Act, etc.). Include analysis of information/results, context/goal/policy checks, planning, and rationale (CoT/CoD). Crucial for complex tasks.")
 }, async ({ thought }) => {
     const toolName = 'think';
     logToolCall(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.');
+            throw new Error('Invalid thought: Must be a non-empty string containing substantive reasoning, following the prompted structure.');
         }
         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, now without markdown wrappers
         return {
             content: [{
                     type: "text",
-                    text: thought // Removed wrappers
+                    text: thought
                 }]
         };
     }
     catch (error) {
-        // Use logToolError to format the error for the LLM
         return logToolError(toolName, error);
     }
 });
 /**
  * Tool: quick_think
- * Purpose: A lightweight cognitive checkpoint for streamlined processing. Suitable for simple confirmations OR **efficient Chain of Draft (CoD) reasoning**.
- * Workflow: Use ONLY when full structured analysis via `think` is genuinely unnecessary (Low CUC-N, trivial results, or targeted CoD application).
- * Output: Returns the brief thought/draft text, formatted as Markdown.
+ * Purpose: A minimal cognitive step for trivial actions or confirmations.
+ * Workflow: Use ONLY for acknowledging *trivial* successes, simple variable passing, or confirming *immediately obvious* next steps where NO analysis, planning, policy check, or complex reasoning (handled by `think`) is needed. Use sparingly; prefer `think` for analyzing any tool output, error, or planning non-trivial actions.
+ * Output: Returns the brief thought text, formatted as Markdown.
  */
-server.tool("quick_think", "**Cognitive Checkpoint & Concise Drafter.** Use for simple confirmations OR efficient **Chain of Draft (CoD)** reasoning where detailed analysis via `think` is unnecessary. CoD focuses on minimal, essential steps (~5 words, equations) for speed and token efficiency. Use ONLY when full deliberation is excessive (verified Low CUC-N or targeted CoD).", {
-    brief_thought: z.string().describe("Your **concise** input. For confirmations: State observation/action & confirm triviality. For CoD: Provide the minimal draft step (essential info, ~5 words, equation, etc.).")
+server.tool("quick_think", "**Minimal Cognitive Step (Use Sparingly!).** Use ONLY for acknowledging *trivial* successes or confirming *obvious* next steps where NO analysis, planning, or policy check is needed (e.g., 'Action X succeeded, proceeding to Y'). All substantive analysis, error handling, planning, and reasoning (CoT/CoD) belongs in the `think` tool. Prefer `think` after most tool calls or before complex actions.", {
+    brief_thought: z.string().describe("Your **extremely concise** confirmation or trivial thought (e.g., 'Tool success, continue', 'Passing ID to next step'). Must be non-empty but very short. Do NOT use for analysis or planning.")
 }, async ({ brief_thought }) => {
     const toolName = 'quick_think';
     logToolCall(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.');
         }
+        // Optional: Add a length check if you want to enforce brevity strictly
+        // if (brief_thought.length > 100) { // Example limit
+        // 	throw new Error('Invalid brief_thought: Input is too long for quick_think. Use think tool for detailed reasoning.');
+        // }
         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, now without markdown wrappers
         return {
             content: [{
                     type: "text",
-                    text: brief_thought // Removed wrappers
+                    text: brief_thought
                 }]
         };
     }
@@ -178,9 +169,8 @@ server.tool("quick_think", "**Cognitive Checkpoint & Concise Drafter.** Use for
         return logToolError(toolName, error);
     }
 });
-// --- REMOVED chain_of_thought Tool ---
-// --- REMOVED chain_of_draft Tool ---
 // --- Server Lifecycle and Error Handling ---
+// [Keep existing shutdown, process event handlers, main function]
 /**
  * Gracefully shuts down the server.
  */
@@ -221,7 +211,7 @@ async function main() {
         const border = '-----------------------------------------------------';
         console.error(border);
         console.error(` ${serverInfo.description}`);
-        // Version logging removed from startup message
+        console.error(` Version: ${serverInfo.version}`);
         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": "0.9.28",
+  "version": "0.9.30",
   "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",