@nbiish/cognitive-tools-mcp 0.9.29 → 2.0.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/build/index.js +107 -100
- package/package.json +1 -1
package/build/index.js
CHANGED
|
@@ -1,21 +1,27 @@
|
|
|
1
1
|
#!/usr/bin/env node
|
|
2
2
|
/**
|
|
3
3
|
* -----------------------------------------------------------------------------
|
|
4
|
-
* Gikendaasowin Aabajichiganan -
|
|
4
|
+
* Gikendaasowin Aabajichiganan - Agentic Cognitive Tools MCP Server (v2.0)
|
|
5
5
|
*
|
|
6
|
-
* Description: Provides
|
|
7
|
-
*
|
|
8
|
-
*
|
|
9
|
-
*
|
|
6
|
+
* Description: Provides cognitive tools for an AI agent based on the
|
|
7
|
+
* Gikendaasowin Cognitive Framework (v7 Guidelines). Emphasizes
|
|
8
|
+
* a mandatory structured deliberation cycle (Observe-Orient-Decide-Act)
|
|
9
|
+
* performed *after* receiving information and *before* significant actions,
|
|
10
|
+
* ideally using the `think` tool. Supports adaptive reasoning styles
|
|
11
|
+
* (CoT, CoD/CRP, SCoT) and integrates with potentially dynamic toolsets,
|
|
12
|
+
* including a preference for Executable Code Actions (CodeAct) if available.
|
|
13
|
+
* Returns Markdown.
|
|
10
14
|
*
|
|
11
|
-
* Key Principles:
|
|
12
|
-
* 1. **
|
|
13
|
-
*
|
|
14
|
-
* 2. **
|
|
15
|
-
*
|
|
16
|
-
* 3. **
|
|
17
|
-
* 4. **
|
|
18
|
-
* 5. **
|
|
15
|
+
* Key Principles (v7 Alignment):
|
|
16
|
+
* 1. **Mandatory Deliberation:** A structured internal reasoning cycle is required
|
|
17
|
+
* before non-trivial actions.
|
|
18
|
+
* 2. **Centralized Analysis (`think`):** The `think` tool is the preferred mechanism
|
|
19
|
+
* for the mandatory deliberation cycle (analysis, planning, OODReAct structure).
|
|
20
|
+
* 3. **Adaptability:** Assumes the agent adapts to dynamically available tools.
|
|
21
|
+
* 4. **CodeAct Preference:** Aligns with agent preference for executable code actions.
|
|
22
|
+
* 5. **Adaptive Reasoning:** Supports CoT, CoD/CRP, SCoT styles within `think`.
|
|
23
|
+
* 6. **Traceability:** Logs tool usage; `think` tool provides reasoning trace.
|
|
24
|
+
* 7. **Markdown Output:** Tool results formatted as Markdown.
|
|
19
25
|
*
|
|
20
26
|
* Protocol: Model Context Protocol (MCP) over stdio.
|
|
21
27
|
* -----------------------------------------------------------------------------
|
|
@@ -25,122 +31,113 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
|
|
|
25
31
|
import { z } from "zod";
|
|
26
32
|
// --- Server Definition ---
|
|
27
33
|
const serverInfo = {
|
|
28
|
-
name: "gikendaasowin-
|
|
29
|
-
version: "
|
|
30
|
-
description: `ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ -
|
|
34
|
+
name: "gikendaasowin-agentic-cognitive-tools-mcp",
|
|
35
|
+
version: "2.0.0", // Version reflects alignment with v7 guidelines
|
|
36
|
+
description: `ᑭᑫᓐᑖᓱᐎᓐ ᐋᐸᒋᒋᑲᓇᓐ - Agentic Cognitive Tools (v2.0): Implements Gikendaasowin v7 Guidelines. Facilitates mandatory Observe-Orient-Decide-Act deliberation cycle (using 'think' tool) before actions. Supports adaptive reasoning (CoT, CoD/CRP, SCoT) and dynamic tool environments (incl. CodeAct preference). Returns Markdown.`
|
|
31
37
|
};
|
|
32
38
|
const server = new McpServer(serverInfo);
|
|
33
39
|
// --- Logging Helpers ---
|
|
34
40
|
/**
|
|
35
|
-
* Logs an incoming
|
|
36
|
-
* @param toolName The name of the
|
|
41
|
+
* Logs an incoming tool call to stderr.
|
|
42
|
+
* @param toolName The name of the tool being called.
|
|
37
43
|
* @param details Optional additional details about the call.
|
|
38
44
|
*/
|
|
39
45
|
function logToolCall(toolName, details) {
|
|
40
46
|
const timestamp = new Date().toISOString();
|
|
41
|
-
console.error(`[${timestamp}] [MCP Server
|
|
47
|
+
console.error(`[${timestamp}] [MCP Server] > Tool Call: ${toolName}${details ? ` - ${details}` : ''}`);
|
|
42
48
|
}
|
|
43
49
|
/**
|
|
44
|
-
* Logs the result (success or failure) of
|
|
45
|
-
* @param toolName The name of the
|
|
50
|
+
* Logs the result (success or failure) of a tool execution to stderr.
|
|
51
|
+
* @param toolName The name of the tool executed.
|
|
46
52
|
* @param success Whether the execution was successful.
|
|
47
53
|
* @param resultDetails Optional details about the result.
|
|
48
54
|
*/
|
|
49
55
|
function logToolResult(toolName, success, resultDetails) {
|
|
50
56
|
const timestamp = new Date().toISOString();
|
|
51
|
-
console.error(`[${timestamp}] [MCP Server
|
|
57
|
+
console.error(`[${timestamp}] [MCP Server] < Tool Result: ${toolName} - ${success ? 'Success' : 'Failure'}${resultDetails ? ` - ${resultDetails}` : ''}`);
|
|
52
58
|
}
|
|
53
59
|
/**
|
|
54
|
-
* Logs an error during
|
|
55
|
-
*
|
|
56
|
-
* @param toolName The name of the internal tool where the error occurred.
|
|
60
|
+
* Logs an error during tool execution and formats a standard error response for the LLM.
|
|
61
|
+
* @param toolName The name of the tool where the error occurred.
|
|
57
62
|
* @param error The error object or message.
|
|
58
63
|
* @returns An object matching the required MCP tool result structure containing the error message.
|
|
59
64
|
*/
|
|
60
65
|
function logToolError(toolName, error) {
|
|
61
66
|
const timestamp = new Date().toISOString();
|
|
62
67
|
const errorMessage = error instanceof Error ? error.message : String(error);
|
|
63
|
-
console.error(`[${timestamp}] [MCP Server
|
|
64
|
-
logToolResult(toolName, false, errorMessage); // Log failure result
|
|
65
|
-
// Return a structured error message guiding the
|
|
68
|
+
console.error(`[${timestamp}] [MCP Server] ! Tool Error: ${toolName} - ${errorMessage}`);
|
|
69
|
+
logToolResult(toolName, false, errorMessage); // Log failure result as well
|
|
70
|
+
// Return a structured error message suitable for the LLM, guiding towards the mandatory deliberation step
|
|
66
71
|
return {
|
|
67
72
|
content: [{
|
|
68
73
|
type: "text",
|
|
69
|
-
|
|
70
|
-
text: `INTERNAL Tool Execution Failed:\nTool: ${toolName}\nError: ${errorMessage}\n\n**Action Required: Immediately use the 'think' tool to analyze this failure (Observe, Orient, Decide, Reason...) before proceeding.**`
|
|
74
|
+
text: `Error executing tool '${toolName}': ${errorMessage}. **Action Required:** Initiate the mandatory deliberation cycle (use the 'think' tool if available) to analyze this error (Observe/Orient), review context/goals, and plan the next corrective step (Decide/Reason/Act(Plan)).`
|
|
71
75
|
}]
|
|
72
76
|
};
|
|
73
77
|
}
|
|
74
|
-
// --- Core
|
|
78
|
+
// --- Core Cognitive Deliberation & Refinement Tools (Aligned with v7 Guidelines) ---
|
|
75
79
|
/**
|
|
76
|
-
* Tool: assess_cuc_n_mode (
|
|
77
|
-
* Purpose:
|
|
78
|
-
*
|
|
79
|
-
*
|
|
80
|
+
* Tool: assess_cuc_n_mode (Optional Initial Assessment)
|
|
81
|
+
* Purpose: Optional initial assessment of task characteristics (Complexity, Uncertainty, Consequence, Novelty)
|
|
82
|
+
* to *inform* the strategy for the mandatory deliberation cycle.
|
|
83
|
+
* Workflow: Can be called *optionally* at the start of complex tasks to help frame the initial approach.
|
|
84
|
+
* The primary, mandatory deliberation happens *later* using `think` or internally.
|
|
85
|
+
* Output: Returns the assessment text formatted as Markdown.
|
|
80
86
|
*/
|
|
81
|
-
server.tool("assess_cuc_n_mode", "**
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
.describe("Your internal structured CUC-N assessment (Situation, Ratings, Rationale, Strategy) concluding with the MANDATORY 'Selected Mode: think' or 'Selected Mode: quick_think' line. This dictates the next internal tool call.")
|
|
85
|
-
}, async ({ assessment_and_choice }) => {
|
|
87
|
+
server.tool("assess_cuc_n_mode", "**(Optional) Initial Task Assessment.** Evaluates task Complexity, Uncertainty, Consequence, Novelty (CUC-N) to *inform* the initial strategy. Call optionally before complex tasks. This assessment helps frame the mandatory deliberation cycle (which uses `think` or occurs internally) but does *not* replace it. Output is your assessment.", {
|
|
88
|
+
assessment_text: z.string().describe("Your structured CUC-N assessment including: 1) Situation/Task Summary, 2) CUC-N Analysis (Low/Medium/High rationale), 3) Potential Strategy Considerations (e.g., 'Requires careful step-by-step planning via CoT', 'Efficiency via CoD/CRP seems appropriate', 'Need to prioritize CodeAct for file manipulation'). This informs, but does not dictate, the mandatory deliberation step.")
|
|
89
|
+
}, async ({ assessment_text }) => {
|
|
86
90
|
const toolName = 'assess_cuc_n_mode';
|
|
87
91
|
logToolCall(toolName);
|
|
88
92
|
try {
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
const modeMatch = assessment_and_choice.match(modeRegex);
|
|
92
|
-
// We rely on Zod to ensure modeMatch is not null due to .includes check, but double-check for robustness
|
|
93
|
-
if (!modeMatch) {
|
|
94
|
-
throw new Error("Internal validation failed: 'Selected Mode:' found but couldn't extract 'think' or 'quick_think'. Input was: " + assessment_and_choice);
|
|
93
|
+
if (assessment_text.trim().length === 0) {
|
|
94
|
+
throw new Error('Invalid assessment_text: Must be a non-empty string containing the CUC-N analysis.');
|
|
95
95
|
}
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
// Return the assessment text as a log/confirmation
|
|
96
|
+
logToolResult(toolName, true, `Assessment logged (length: ${assessment_text.length})`);
|
|
97
|
+
console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Input:\n${assessment_text}`);
|
|
98
|
+
// Return the assessment text directly
|
|
100
99
|
return {
|
|
101
100
|
content: [{
|
|
102
101
|
type: "text",
|
|
103
|
-
|
|
104
|
-
text: `Internal CUC-N Assessment Logged. Mandatory Next Step: ${selectedMode}\n---\nAssessment Details:\n${assessment_and_choice}`
|
|
102
|
+
text: assessment_text
|
|
105
103
|
}]
|
|
106
104
|
};
|
|
107
105
|
}
|
|
108
106
|
catch (error) {
|
|
109
|
-
// Catch Zod errors or other exceptions
|
|
110
107
|
return logToolError(toolName, error);
|
|
111
108
|
}
|
|
112
109
|
});
|
|
113
110
|
/**
|
|
114
|
-
* Tool: think (
|
|
115
|
-
* Purpose: The **
|
|
116
|
-
*
|
|
117
|
-
*
|
|
111
|
+
* Tool: think (Mandatory Deliberation Hub)
|
|
112
|
+
* Purpose: The **PREFERRED & CENTRAL HUB** for the **MANDATORY** structured deliberation cycle
|
|
113
|
+
* (Observe-Orient-Decide-Act).
|
|
114
|
+
* Workflow: **MUST** be called (if available) *after* receiving new information (tool results, CodeAct output/errors,
|
|
115
|
+
* USER input, file reads) and *before* executing any non-trivial action (tool call, CodeAct execution,
|
|
116
|
+
* complex response generation). Use it to analyze inputs, orient context/goals/policies, decide the next
|
|
117
|
+
* action, reason (CoT, CoD/CRP, SCoT), plan the action details (tool params, CodeAct code), define
|
|
118
|
+
* verification, and consider risks. Essential for reliability, error handling, and complex tasks.
|
|
119
|
+
* Output: Returns the structured thought process itself, formatted as Markdown, serving as an internal log.
|
|
118
120
|
*/
|
|
119
|
-
server.tool("think", "**
|
|
120
|
-
thought: z.string().
|
|
121
|
-
// Enforce presence of key OODReAct sections for structure
|
|
122
|
-
.includes("## Observe:", { message: "Thought MUST include '## Observe:' section." })
|
|
123
|
-
.includes("## Orient:", { message: "Thought MUST include '## Orient:' section." })
|
|
124
|
-
.includes("## Decide:", { message: "Thought MUST include '## Decide:' section." })
|
|
125
|
-
.includes("## Reason:", { message: "Thought MUST include '## Reason:' section where CoT/CoD happens." })
|
|
126
|
-
// Add more checks as needed (Act, Verification, etc.) if strict enforcement is desired
|
|
127
|
-
// .includes("## Act:", "Thought MUST include '## Act:' section.")
|
|
128
|
-
// .includes("## Verification:", "Thought MUST include '## Verification:' section.")
|
|
129
|
-
// .includes("## Risk & Contingency:", "Thought MUST include '## Risk & Contingency:' section.")
|
|
130
|
-
// .includes("## Learning & Adaptation:", "Thought MUST include '## Learning & Adaptation:' section.")
|
|
131
|
-
.describe("Your **detailed internal monologue** STRICTLY following the OODReAct structure. Cover analysis (Observe), context (Orient), next step (Decide), detailed rationale/CoT/CoD (Reason), execution plan (Act), success checks (Verification), risks (Risk), and learning (Learning). This is purely for internal reasoning.")
|
|
121
|
+
server.tool("think", "**Mandatory Deliberation Hub.** Use this tool (if available) for the required structured deliberation cycle *after* info and *before* action. Input MUST follow the OODReAct structure: ## Observe (analyze inputs/results/errors), ## Orient (context/goals/policy check), ## Decide (next action: tool, CodeAct, query, respond), ## Reason (justify decision; use CoT, CoD/CRP, or SCoT style), ## Act (Plan) (tool params, CodeAct code, response draft), ## Verification (success criteria), ## Risk & Contingency (briefly).", {
|
|
122
|
+
thought: z.string().describe("Your **structured OODReAct deliberation**. MUST include all sections: Observe, Orient, Decide, Reason (using appropriate CoT/CoD/CRP/SCoT style), Act(Plan) (with specific tool parameters or CodeAct code), Verification, Risk & Contingency. This is critical for documenting the mandatory reasoning process before acting.")
|
|
132
123
|
}, async ({ thought }) => {
|
|
133
124
|
const toolName = 'think';
|
|
134
125
|
logToolCall(toolName);
|
|
135
126
|
try {
|
|
136
|
-
//
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
127
|
+
// Basic validation: Check if it's non-empty and maybe contains expected markers
|
|
128
|
+
if (thought.trim().length === 0) {
|
|
129
|
+
throw new Error('Invalid thought: Must be a non-empty string.');
|
|
130
|
+
}
|
|
131
|
+
if (!thought.includes("## Observe:") || !thought.includes("## Orient:") || !thought.includes("## Decide:") || !thought.includes("## Reason:") || !thought.includes("## Act (Plan):")) {
|
|
132
|
+
throw new Error('Invalid thought structure: Must contain required OODReAct sections (Observe, Orient, Decide, Reason, Act(Plan)).');
|
|
133
|
+
}
|
|
134
|
+
logToolResult(toolName, true, `Deliberation logged (length: ${thought.length})`);
|
|
135
|
+
console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Input:\n${thought}`);
|
|
136
|
+
// Return the thought process itself as the result
|
|
140
137
|
return {
|
|
141
138
|
content: [{
|
|
142
139
|
type: "text",
|
|
143
|
-
text:
|
|
140
|
+
text: thought
|
|
144
141
|
}]
|
|
145
142
|
};
|
|
146
143
|
}
|
|
@@ -149,27 +146,34 @@ server.tool("think", "**INTERNAL Use Only. Mandatory Central Hub for Reasoning.*
|
|
|
149
146
|
}
|
|
150
147
|
});
|
|
151
148
|
/**
|
|
152
|
-
* Tool: quick_think (
|
|
153
|
-
* Purpose:
|
|
154
|
-
* Workflow:
|
|
155
|
-
*
|
|
149
|
+
* Tool: quick_think (Minimal Cognitive Step - Use With Extreme Caution)
|
|
150
|
+
* Purpose: A minimal cognitive step ONLY for acknowledging *trivial*, *immediately obvious* successes or state transitions.
|
|
151
|
+
* Workflow: **STRONGLY DISCOURAGED.** Use ONLY if the mandatory deliberation cycle (`think` or internal) is genuinely unnecessary
|
|
152
|
+
* because the situation involves absolutely no analysis, planning, policy check, error handling, or complex reasoning.
|
|
153
|
+
* Example: Confirming receipt of simple data before an already-planned trivial action.
|
|
154
|
+
* **DO NOT USE** after most tool calls, CodeAct executions, or before any complex action - use `think` instead.
|
|
155
|
+
* Output: Returns the brief thought text, formatted as Markdown.
|
|
156
156
|
*/
|
|
157
|
-
server.tool("quick_think", "**
|
|
158
|
-
brief_thought: z.string().
|
|
159
|
-
.max(200, "Brief thought should be concise (max 200 chars). Use 'think' for detail.") // Add max length
|
|
160
|
-
.describe("Your **concise internal** confirmation for a verified trivial step (e.g., 'Acknowledged trivial success: file read OK.'). Use ONLY when full deliberation via 'think' is explicitly unnecessary per assessment.")
|
|
157
|
+
server.tool("quick_think", "**(Use Sparingly/Discouraged) Minimal Cognitive Step.** Use ONLY for acknowledging *trivial successes* or confirming *obvious, pre-planned* simple steps where NO analysis/planning/policy check is needed (e.g., 'Data received, proceeding with planned step X'). **The mandatory deliberation cycle (`think` tool or internal) is required for almost all situations.** Prefer `think` after any tool/CodeAct output or error.", {
|
|
158
|
+
brief_thought: z.string().describe("Your **extremely concise** confirmation for a truly trivial step (e.g., 'Trivial action X succeeded'). Must be non-empty but very short. DO NOT use for analysis, planning, error reflection, or complex reasoning - use the `think` tool for the mandatory deliberation cycle.")
|
|
161
159
|
}, async ({ brief_thought }) => {
|
|
162
160
|
const toolName = 'quick_think';
|
|
163
161
|
logToolCall(toolName);
|
|
164
162
|
try {
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
//
|
|
163
|
+
if (brief_thought.trim().length === 0) {
|
|
164
|
+
throw new Error('Invalid brief_thought: Must be a non-empty string.');
|
|
165
|
+
}
|
|
166
|
+
// Optional stricter length check to enforce brevity
|
|
167
|
+
if (brief_thought.length > 150) { // Example limit
|
|
168
|
+
console.error(`[${new Date().toISOString()}] [MCP Server] WARNING: 'quick_think' input is long. Ensure 'think' wasn't more appropriate.`);
|
|
169
|
+
}
|
|
170
|
+
logToolResult(toolName, true, `Logged: ${brief_thought.substring(0, 80)}...`);
|
|
171
|
+
console.error(`[${new Date().toISOString()}] [MCP Server] - ${toolName} Input:\n${brief_thought}`);
|
|
172
|
+
// Return the brief thought
|
|
169
173
|
return {
|
|
170
174
|
content: [{
|
|
171
175
|
type: "text",
|
|
172
|
-
text:
|
|
176
|
+
text: brief_thought
|
|
173
177
|
}]
|
|
174
178
|
};
|
|
175
179
|
}
|
|
@@ -177,52 +181,55 @@ server.tool("quick_think", "**INTERNAL Use Only. Trivial Confirmation Checkpoint
|
|
|
177
181
|
return logToolError(toolName, error);
|
|
178
182
|
}
|
|
179
183
|
});
|
|
180
|
-
// --- Server Lifecycle and Error Handling ---
|
|
184
|
+
// --- Server Lifecycle and Error Handling ---
|
|
181
185
|
/**
|
|
182
186
|
* Gracefully shuts down the server.
|
|
183
187
|
*/
|
|
184
188
|
async function shutdown() {
|
|
185
|
-
console.error('\n[MCP Server
|
|
189
|
+
console.error('\n[MCP Server] Shutting down gracefully...');
|
|
186
190
|
try {
|
|
187
191
|
await server.close();
|
|
188
|
-
console.error('[MCP Server
|
|
192
|
+
console.error('[MCP Server] Server closed.');
|
|
189
193
|
process.exit(0);
|
|
190
194
|
}
|
|
191
195
|
catch (err) {
|
|
192
|
-
console.error('[MCP Server
|
|
196
|
+
console.error('[MCP Server] Error during shutdown:', err);
|
|
193
197
|
process.exit(1);
|
|
194
198
|
}
|
|
195
199
|
}
|
|
200
|
+
// Setup signal handlers
|
|
196
201
|
process.on('SIGINT', shutdown);
|
|
197
202
|
process.on('SIGTERM', shutdown);
|
|
203
|
+
// Setup global error handlers
|
|
198
204
|
process.on('uncaughtException', (error, origin) => {
|
|
199
205
|
const timestamp = new Date().toISOString();
|
|
200
|
-
console.error(`[${timestamp}] [MCP Server
|
|
201
|
-
shutdown().catch(() => process.exit(1));
|
|
206
|
+
console.error(`[${timestamp}] [MCP Server] FATAL: Uncaught Exception at: ${origin}`, error);
|
|
207
|
+
shutdown().catch(() => process.exit(1)); // Attempt graceful shutdown
|
|
202
208
|
});
|
|
203
209
|
process.on('unhandledRejection', (reason, promise) => {
|
|
204
210
|
const timestamp = new Date().toISOString();
|
|
205
|
-
console.error(`[${timestamp}] [MCP Server
|
|
206
|
-
shutdown().catch(() => process.exit(1));
|
|
211
|
+
console.error(`[${timestamp}] [MCP Server] FATAL: Unhandled Promise Rejection:`, reason);
|
|
212
|
+
shutdown().catch(() => process.exit(1)); // Attempt graceful shutdown
|
|
207
213
|
});
|
|
208
214
|
// --- Start the Server ---
|
|
209
215
|
/**
|
|
210
|
-
* Initializes and starts the MCP server
|
|
216
|
+
* Initializes and starts the MCP server.
|
|
211
217
|
*/
|
|
212
218
|
async function main() {
|
|
213
219
|
try {
|
|
214
220
|
const transport = new StdioServerTransport();
|
|
215
221
|
await server.connect(transport);
|
|
216
|
-
const border = '
|
|
222
|
+
const border = '=====================================================';
|
|
217
223
|
console.error(border);
|
|
218
224
|
console.error(` ${serverInfo.description}`);
|
|
219
225
|
console.error(` Version: ${serverInfo.version}`);
|
|
220
|
-
console.error(
|
|
226
|
+
console.error(` Aligned with Gikendaasowin v7 Agentic Guidelines`);
|
|
227
|
+
console.error(' Status: Running on stdio, awaiting MCP requests...');
|
|
221
228
|
console.error(border);
|
|
222
229
|
}
|
|
223
230
|
catch (error) {
|
|
224
231
|
const timestamp = new Date().toISOString();
|
|
225
|
-
console.error(`[${timestamp}] [MCP Server
|
|
232
|
+
console.error(`[${timestamp}] [MCP Server] Fatal error during startup:`, error);
|
|
226
233
|
process.exit(1);
|
|
227
234
|
}
|
|
228
235
|
}
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@nbiish/cognitive-tools-mcp",
|
|
3
|
-
"version": "0.
|
|
3
|
+
"version": "2.0.1",
|
|
4
4
|
"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.",
|
|
5
5
|
"private": false,
|
|
6
6
|
"type": "module",
|