@felkot/think-mcp 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 GofMan3
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,165 @@
+<div align="center">
+
+# Think MCP
+
+**Structured reasoning MCP server for difficult engineering tasks**
+
+[![npm version](https://img.shields.io/npm/v/@felkot/think-mcp?style=flat-square&color=cb3837)](https://www.npmjs.com/package/@felkot/think-mcp)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT)
+[![MCP](https://img.shields.io/badge/MCP-Compatible-2D77FF?style=flat-square)](https://modelcontextprotocol.io/)
+
+**Think deeper. Branch safely. Finish with verified reasoning.**
+
+</div>
+
+---
+
+## Why this project exists
+
+Most assistants are good at speed but weak at deep reliability.
+
+**Think MCP** gives a strict thinking workflow for cases where mistakes are expensive:
+- architecture and refactors,
+- finance/payment flows,
+- security-sensitive logic,
+- long multi-step implementation plans.
+
+It helps the model reason in a controlled loop: map assumptions, explore alternatives, verify constraints, and only then conclude.
+
+---
+
+## Stable Release 1.0.0
+
+This release is focused on production-ready behavior:
+
+- Stronger heavy-task gates for `think` and `think_done`
+- Better anti-leak protection for context capture and export
+- Sensitive file blocking (for example `.env`, key/cert-like files)
+- Sanitized reports and insights persistence
+- Improved release quality checks and package hygiene
+
+---
+
+## Quick Start
+
+### Run directly
+
+```bash
+npx @felkot/think-mcp@latest
+```
+
+### MCP config example
+
+```json
+{
+  "mcpServers": {
+    "think": {
+      "command": "npx",
+      "args": ["-y", "@felkot/think-mcp@latest"]
+    }
+  }
+}
+```
+
+---
+
+## Mini Prompt (copy/paste)
+
+Use this in your system/custom instructions:
+
+```text
+You are a careful engineering assistant.
+For non-trivial tasks, use Think MCP before final output.
+
+Rules:
+1) Start with think_logic for architecture/flow analysis.
+2) Use think for stepwise reasoning with subSteps.
+3) If confidence < 5 or trade-offs are unclear, use think_diverge.
+4) Before final answer, call think_done with:
+   - winningPath
+   - summary
+   - constraintCheck
+   - potentialFlaws
+5) If think_done is blocked, continue reasoning; do not force a conclusion.
+```
+
+---
+
+## Toolset
+
+| Tool | Purpose |
+| :--- | :--- |
+| `think` | Add one thought with validation, confidence, substeps, and optional context snapshots |
+| `think_batch` | Submit a full chain in one request (1-30 thoughts) |
+| `think_done` | Final synthesis/verification gate before final answer |
+| `think_recall` | Search session memory or stored insights |
+| `think_reset` | Reset session state |
+| `think_logic` | Generate a practical analysis methodology |
+| `think_diverge` | Create 2-3 alternative branches from one thought |
+| `get_model_instructions` | Return built-in deep-thinking system prompt |
+
+---
+
+## Security and Privacy Defaults
+
+- Context access is restricted to current workspace.
+- Symlink escapes outside workspace are blocked.
+- Sensitive file names are blocked from context capture.
+- Secret-like values are redacted in captured content.
+- Full context content is opt-in (`includeContextContent: true`).
+- Returned context content is safety-truncated.
+- Exported reports and saved insights are sanitized.
+
+Storage behavior:
+- Sessions: `.think/sessions/latest_session.json`
+- Insights: `.think/insights.json`
+- Optional override: `THINK_MCP_STORAGE_DIR`
+
+---
+
+## Recommended Usage Pattern
+
+For heavy tasks, this pattern is the most reliable:
+
+1. `think_logic` (map the analysis method)
+2. `think` loop (decompose, validate, branch if needed)
+3. `think_recall` (check prior dead ends/insights)
+4. `think_done` (constraint and risk check)
+5. only then final user answer
+
+---
+
+## Local Development
+
+```bash
+npm ci
+npm run typecheck
+npm test
+npm run build
+npm run audit:prod
+```
+
+Optional package check:
+
+```bash
+npm pack --dry-run
+```
+
+---
+
+## Notes for model choice
+
+- **Opus-like models**: excellent for architecture and rigorous critique with `think_logic` + `think_done`.
+- **Codex-like models**: strong implementation speed; combine with `think`/`think_done` gates to reduce regressions.
+
+---
+
+## License
+
+MIT
+
+---
+
+<div align="center">
+  <sub>Created by FelKot</sub>
+</div>

package/dist/constants/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Constants barrel export
+ */
+export * from './thresholds.js';
+export * from './patterns.js';

package/dist/constants/index.js

@@ -0,0 +1,5 @@
+/**
+ * Constants barrel export
+ */
+export * from './thresholds.js';
+export * from './patterns.js';

package/dist/constants/patterns.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Pattern constants for content analysis
+ * Used by CoachingService and StagnationService
+ */
+export declare const OPTIMIZATION_TRIGGERS: string[];
+export declare const UNCERTAINTY_TRIGGERS: string[];
+export declare const FILLER_PHRASES: string[];
+export declare const LAZY_THINKING_PATTERNS: string[];

package/dist/constants/patterns.js

@@ -0,0 +1,34 @@
+/**
+ * Pattern constants for content analysis
+ * Used by CoachingService and StagnationService
+ */
+// Proactive Coach patterns for lens recommendations (v2.9.1)
+export const OPTIMIZATION_TRIGGERS = [
+    'todo', 'fixme', 'hack', 'потом', 'позже', 'оптимизировать', 'рефакторинг',
+    'медленно', 'память', 'performance', 'slow', 'memory', 'refactor', 'cleanup',
+    'технический долг', 'tech debt', 'временное решение', 'workaround',
+];
+export const UNCERTAINTY_TRIGGERS = [
+    'возможно', 'наверное', 'думаю что', 'скорее всего', 'предполагаю',
+    'может быть', 'вероятно', 'не уверен', 'perhaps', 'maybe', 'probably',
+    'i think', 'i assume', 'might be', 'could be', 'not sure', 'uncertain',
+];
+// Common filler phrases and stop words to normalize out for stagnation/entropy detection
+export const FILLER_PHRASES = [
+    // English filler phrases
+    'in this step', 'i will', 'let me', 'now i', 'first', 'next', 'then',
+    'carefully', 'analyze', 'consider', 'looking at', 'examining', 'reviewing',
+    'based on', 'according to', 'as we can see', 'it appears that',
+    // English stop words
+    'the', 'a', 'an', 'of', 'is', 'to', 'and', 'or', 'but', 'in', 'on', 'at',
+    'for', 'with', 'this', 'that', 'it', 'be', 'are', 'was', 'were', 'been',
+    // Russian stop words
+    'и', 'в', 'на', 'с', 'по', 'к', 'у', 'о', 'из', 'за', 'от', 'до',
+    'то', 'что', 'это', 'как', 'для', 'не', 'но', 'да', 'же', 'ли', 'бы',
+];
+// Patterns indicating lazy/shallow thinking (v5.5.0)
+export const LAZY_THINKING_PATTERNS = [
+    'просто', 'легко', 'очевидно', 'банально', 'просто добавлю', 'ничего сложного',
+    'simply', 'just', 'obviously', 'trivial', 'basically', 'easy fix', 'straightforward',
+    'i will just', 'simple change', 'nothing complex'
+];

package/dist/constants/prompts.d.ts

@@ -0,0 +1 @@
+export declare const DEEP_THINKING_PROMPT = "You are a Deep Thinking AI. Your goal is to solve problems by thinking deeply, sequentially, and recursively.\n\nCORE MANDATE:\n1. QUALITY OVER SPEED: Take as much time/steps as needed. Never rush.\n2. FIRST ATTEMPT PERFECTION: You must verify your solution until you are 100% certain it is error-free.\n3. MANDATORY SELF-CORRECTION: You cannot finish without a dedicated \"Pre-Mortem\" phase where you try to break your own solution.\n4. RADICAL SKEPTICISM: Assume your first intuition is wrong. Prove it right.\n\nPROCESS:\n1. INITIALIZATION:\n   - State the goal clearly.\n   - List ALL constraints and edge cases.\n   - \"Does this require external tools?\" -> Plan tool usage.\n\n2. STRATEGY (Divergent Thinking):\n   - Brainstorm 3 distinct approaches.\n   - Critique each approach (Pros/Cons).\n   - Select the best one and justify why.\n\n3. EXECUTION (Iterative Refinement):\n   - Break the chosen strategy into atomic steps.\n   - Execute step-by-step.\n   - AFTER EACH STEP: Verify the result. \"Did this work as expected?\"\n   - IF ERROR: Stop. Analyze. Fix. Do not patch blindly.\n\n4. VERIFICATION (The \"Pre-Mortem\"):\n   - Before saying \"Done\", switch roles to \"The Critic\".\n   - Attack your solution: \"Where will this fail?\", \"What edge case did I miss?\", \"Is this the simplest way?\"\n   - If flaws are found, return to Execution.\n\n5. CONCLUSION:\n   - Summarize the solution.\n   - Confirm all constraints are met.\n   - Provide the final artifact (code, text, etc.).\n\nTOOLS USAGE:\n- Use 'think' for EVERY step of reasoning.\n- Use 'think_diverge' if you are stuck or need alternatives (required if confidence < 5).\n- Use 'think_logic' to deep-dive into complex logical structures.\n\nWARNINGS:\n- Do not use phrases like \"I hope\", \"I think maybe\". Be precise.\n- Do not skip steps.\n- Do not conclude prematurely. If you have 5 steps, do all 5.";

package/dist/constants/prompts.js

@@ -0,0 +1,44 @@
+export const DEEP_THINKING_PROMPT = `You are a Deep Thinking AI. Your goal is to solve problems by thinking deeply, sequentially, and recursively.
+
+CORE MANDATE:
+1. QUALITY OVER SPEED: Take as much time/steps as needed. Never rush.
+2. FIRST ATTEMPT PERFECTION: You must verify your solution until you are 100% certain it is error-free.
+3. MANDATORY SELF-CORRECTION: You cannot finish without a dedicated "Pre-Mortem" phase where you try to break your own solution.
+4. RADICAL SKEPTICISM: Assume your first intuition is wrong. Prove it right.
+
+PROCESS:
+1. INITIALIZATION:
+   - State the goal clearly.
+   - List ALL constraints and edge cases.
+   - "Does this require external tools?" -> Plan tool usage.
+
+2. STRATEGY (Divergent Thinking):
+   - Brainstorm 3 distinct approaches.
+   - Critique each approach (Pros/Cons).
+   - Select the best one and justify why.
+
+3. EXECUTION (Iterative Refinement):
+   - Break the chosen strategy into atomic steps.
+   - Execute step-by-step.
+   - AFTER EACH STEP: Verify the result. "Did this work as expected?"
+   - IF ERROR: Stop. Analyze. Fix. Do not patch blindly.
+
+4. VERIFICATION (The "Pre-Mortem"):
+   - Before saying "Done", switch roles to "The Critic".
+   - Attack your solution: "Where will this fail?", "What edge case did I miss?", "Is this the simplest way?"
+   - If flaws are found, return to Execution.
+
+5. CONCLUSION:
+   - Summarize the solution.
+   - Confirm all constraints are met.
+   - Provide the final artifact (code, text, etc.).
+
+TOOLS USAGE:
+- Use 'think' for EVERY step of reasoning.
+- Use 'think_diverge' if you are stuck or need alternatives (required if confidence < 5).
+- Use 'think_logic' to deep-dive into complex logical structures.
+
+WARNINGS:
+- Do not use phrases like "I hope", "I think maybe". Be precise.
+- Do not skip steps.
+- Do not conclude prematurely. If you have 5 steps, do all 5.`;

package/dist/constants/thresholds.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Configuration constants for ThinkingService
+ * Extracted from thinking.service.ts for modularity
+ */
+export declare const RETAIN_FULL_THOUGHTS = 5;
+export declare const RECENT_THOUGHTS_COUNT = 3;
+export declare const RECENT_WEIGHT_MULTIPLIER = 2;
+export declare const STAGNATION_CHECK_COUNT = 3;
+export declare const MIN_ENTROPY_THRESHOLD = 0.25;
+export declare const JACCARD_STAGNATION_BASE = 0.6;
+export declare const JACCARD_STAGNATION_MAX = 0.85;
+export declare const JACCARD_DEPTH_FACTOR = 0.015;
+/**
+ * Calculate adaptive stagnation threshold based on session depth
+ * Early thoughts: more lenient (0.6), later thoughts: stricter (up to 0.85)
+ * Formula: threshold = BASE + min(MAX - BASE, thoughtCount * FACTOR)
+ * @param thoughtCount - Number of thoughts in current session
+ */
+export declare function getStagnationThreshold(thoughtCount: number): number;
+export declare const LINEAR_THINKING_THRESHOLD = 6;
+export declare const ESCALATING_PRESSURE_INTERVAL = 3;
+export declare const MAX_THOUGHTS_BUDGET = 12;
+export declare const POLISH_THRESHOLD_CONFIDENCE = 11;
+export declare const INNOVATION_THRESHOLD_THOUGHTS = 20;
+export declare const MIN_THOUGHT_LENGTH = 10;
+export declare const LOW_CONFIDENCE_THRESHOLD = 3;
+export declare const NO_CRITIQUE_THRESHOLD = 20;
+export declare const DEPTH_METRIC_SIMPLE = 10;
+export declare const DEPTH_METRIC_MEDIUM = 50;
+export declare const DEPTH_METRIC_COMPLEX = 100;
+export declare const SESSION_TTL_HOURS = 24;
+export declare const COACH_COOLDOWN_COUNT = 3;
+export declare const SMART_PRUNING_THRESHOLD = 10;
+export declare const MAX_DEAD_ENDS = 20;
+export declare const NEAR_LIMIT_CONFIDENCE_THRESHOLD = 6;
+export declare const RECALL_DEFAULT_LIMIT = 3;
+export declare const RECALL_DEFAULT_THRESHOLD = 0.4;
+export declare const RECALL_SNIPPET_CONTEXT = 100;
+export declare const TECHNICAL_SHORT_TERMS: Set<string>;

package/dist/constants/thresholds.js

@@ -0,0 +1,54 @@
+/**
+ * Configuration constants for ThinkingService
+ * Extracted from thinking.service.ts for modularity
+ */
+// Context retention
+export const RETAIN_FULL_THOUGHTS = 5; // Keep last N thoughts in full detail
+export const RECENT_THOUGHTS_COUNT = 3; // Number of recent thoughts to weight higher
+export const RECENT_WEIGHT_MULTIPLIER = 2; // Weight multiplier for last 3 thoughts in confidence calc
+// Stagnation detection
+export const STAGNATION_CHECK_COUNT = 3; // Check last N thoughts for similarity
+export const MIN_ENTROPY_THRESHOLD = 0.25; // Minimum word entropy before warning
+export const JACCARD_STAGNATION_BASE = 0.6; // Base Jaccard threshold (lenient at start)
+export const JACCARD_STAGNATION_MAX = 0.85; // Maximum threshold (strict at end)
+export const JACCARD_DEPTH_FACTOR = 0.015; // Increase threshold by this per thought
+/**
+ * Calculate adaptive stagnation threshold based on session depth
+ * Early thoughts: more lenient (0.6), later thoughts: stricter (up to 0.85)
+ * Formula: threshold = BASE + min(MAX - BASE, thoughtCount * FACTOR)
+ * @param thoughtCount - Number of thoughts in current session
+ */
+export function getStagnationThreshold(thoughtCount) {
+    const increase = Math.min(JACCARD_STAGNATION_MAX - JACCARD_STAGNATION_BASE, thoughtCount * JACCARD_DEPTH_FACTOR);
+    return JACCARD_STAGNATION_BASE + increase;
+}
+// Lateral thinking triggers
+export const LINEAR_THINKING_THRESHOLD = 6; // Thoughts before lateral thinking warning
+export const ESCALATING_PRESSURE_INTERVAL = 3; // Every N thoughts, increase pressure
+export const MAX_THOUGHTS_BUDGET = 12; // Complexity budget - warn to consolidate after this many thoughts
+// Proactive Coach thresholds
+export const POLISH_THRESHOLD_CONFIDENCE = 11; // Disabled (was 8) - Don't nag if confident
+export const INNOVATION_THRESHOLD_THOUGHTS = 20; // Disabled (was 8) - Don't force innovation
+export const MIN_THOUGHT_LENGTH = 10; // Allow short thoughts (was 50)
+export const LOW_CONFIDENCE_THRESHOLD = 3; // Lower threshold (was 5)
+export const NO_CRITIQUE_THRESHOLD = 20; // Disabled (was 5)
+// Pre-Consolidation Audit thresholds
+export const DEPTH_METRIC_SIMPLE = 10; // Allow quick fixes (was 100)
+export const DEPTH_METRIC_MEDIUM = 50; // (was 150)
+export const DEPTH_METRIC_COMPLEX = 100; // (was 200)
+// Session management
+export const SESSION_TTL_HOURS = 24; // Auto-reset session after this many hours
+export const COACH_COOLDOWN_COUNT = 3; // Don't repeat same advice within N thoughts
+export const SMART_PRUNING_THRESHOLD = 10; // Start pruning context after N thoughts
+// Dead ends tracking
+export const MAX_DEAD_ENDS = 20; // Limit dead ends to prevent memory bloat
+export const NEAR_LIMIT_CONFIDENCE_THRESHOLD = 6; // Warn if near limit with low confidence
+// Recall defaults
+export const RECALL_DEFAULT_LIMIT = 3;
+export const RECALL_DEFAULT_THRESHOLD = 0.4;
+export const RECALL_SNIPPET_CONTEXT = 100; // Characters before/after match for snippet
+// Technical short terms whitelist for entropy calculation (not filtered by length)
+export const TECHNICAL_SHORT_TERMS = new Set([
+    'api', 'ui', 'db', 'id', 'io', 'os', 'ip', 'url', 'css', 'sql', 'xml', 'jwt', 'mcp',
+    'cli', 'sdk', 'cdn', 'dns', 'ssh', 'ssl', 'tls', 'http', 'json', 'yaml', 'toml',
+]);

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+/**
+ * Think Module MCP Server v1.0.0
+ * Streamlined thinking tools: 8 tools
+ *
+ * v1.0.0: Stable public release
+ * v4.7.0: Added think_logic for deep logical analysis
+ * v4.6.0: Added NudgeService for proactive micro-prompts
+ *
+ * Tools:
+ * - think: Add a thought (with quickExtension for inline critique)
+ * - think_batch: Submit multiple thoughts at once
+ * - think_done: Finish session, verify, optionally export
+ * - think_recall: Search session or past insights
+ * - think_reset: Clear session
+ * - think_logic: Deep logical analysis of any task/feature/system
+ * - think_diverge: Create 2-3 branching alternatives
+ * - get_model_instructions: Return deep-thinking system prompt
+ */
+export {};