deepthinking-mcp 1.0.0

package/README.md

@@ -0,0 +1,269 @@
+# DeepThinking MCP
+
+A unified Model Context Protocol (MCP) server that combines **sequential thinking**, **Shannon's systematic methodology**, and **mathematical reasoning** with specialized support for physics and tensor mathematics.
+
+## Overview
+
+DeepThinking MCP merges the best approaches from:
+- **Sequential-thinking** (Anthropic): Iterative refinement and revision
+- **Shannon-thinking**: 5-stage systematic problem-solving
+- **Mathematical reasoning**: Theorem proving and symbolic computation
+- **Physics support**: Tensor mathematics and field theory
+
+## Features
+
+### Multiple Thinking Modes
+- **Sequential**: Iterative refinement with revision capabilities
+- **Shannon**: Systematic 5-stage problem-solving (problem definition → constraints → model → proof → implementation)
+- **Mathematics**: Theorem proving, lemma derivation, symbolic computation
+- **Physics**: Tensor formulation, dimensional analysis, conservation laws
+- **Hybrid**: Intelligently combines modes based on problem characteristics
+
+### Mathematical Enhancements
+- **Symbolic computation** support with LaTeX and symbolic formats
+- **Theorem and proof** structures
+- **Lemma derivation** and corollary tracking
+- **Algebraic manipulation** and numerical analysis
+- **Logical form** with premises, conclusions, and inference rules
+
+### Physics Capabilities
+- **Tensor mathematics** with rank, symmetries, and invariants
+- **Dimensional analysis** for unit consistency
+- **Conservation law** verification
+- **Field theory** context (Lagrangian, Hamiltonian, gauge symmetries)
+- **Physical interpretation** with units and observables
+
+### Session Management
+- Persistent thinking sessions
+- Automatic metrics tracking
+- Mode switching during problem-solving
+- Export to multiple formats (Markdown, LaTeX, JSON)
+
+## Installation
+
+```bash
+npm install deepthinking-mcp
+```
+
+## Configuration
+
+Add to your Claude Desktop config (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS or `%APPDATA%\Claude\claude_desktop_config.json` on Windows):
+
+```json
+{
+  "mcpServers": {
+    "deepthinking": {
+      "command": "npx",
+      "args": ["-y", "deepthinking-mcp"]
+    }
+  }
+}
+```
+
+## Usage
+
+### Basic Sequential Thinking
+
+```
+Use the deepthinking tool to help me think through this step by step...
+```
+
+The tool will automatically create a session and track your thoughts.
+
+### Mathematical Reasoning
+
+```
+Use deepthinking in mathematics mode to prove the Pythagorean theorem...
+```
+
+### Physics Problems
+
+```
+Use deepthinking in physics mode to derive the electromagnetic tensor formulation...
+```
+
+### Hybrid Mode (Default)
+
+```
+Use deepthinking to solve this complex problem...
+```
+
+The hybrid mode automatically selects the best features from each mode.
+
+## Tool Parameters
+
+### Core Parameters
+- `thought` (string, required): The thought content
+- `thoughtNumber` (number, required): Position in sequence
+- `totalThoughts` (number, required): Estimated total thoughts needed
+- `nextThoughtNeeded` (boolean, required): Whether to continue thinking
+- `mode` (string, optional): `sequential`, `shannon`, `mathematics`, `physics`, or `hybrid` (default)
+
+### Mode-Specific Parameters
+
+#### Sequential Mode
+- `isRevision`: Whether this revises a previous thought
+- `revisesThought`: ID of thought being revised
+- `revisionReason`: Why the revision was needed
+
+#### Shannon Mode
+- `stage`: Which Shannon stage (problem_definition, constraints, model, proof, implementation)
+- `uncertainty`: Confidence level (0-1)
+- `dependencies`: IDs of dependent thoughts
+- `assumptions`: Explicit assumptions
+
+#### Mathematics Mode
+- `thoughtType`: Specific type (axiom_definition, theorem_statement, proof_construction, etc.)
+- `mathematicalModel`: LaTeX and symbolic representation
+- `proofStrategy`: Type and steps of proof
+- `logicalForm`: Premises, conclusion, inference rules
+
+#### Physics Mode
+- `thoughtType`: Specific type (tensor_formulation, symmetry_analysis, etc.)
+- `tensorProperties`: Rank, components, symmetries, invariants
+- `physicalInterpretation`: Quantity, units, conservation laws
+- `dimensionalAnalysis`: Unit consistency checking
+
+### Actions
+- `add_thought` (default): Add a new thought to session
+- `summarize`: Generate session summary
+- `export`: Export session (requires `exportFormat`)
+- `switch_mode`: Change thinking mode (requires `newMode`)
+- `get_session`: Get session metadata
+
+## Examples
+
+### Example 1: Sequential Problem Solving
+
+```
+Thought 1: "Let me break down this optimization problem..."
+- mode: sequential
+- thoughtNumber: 1
+- nextThoughtNeeded: true
+
+Thought 2: "Building on my previous thought, I realize..."
+- mode: sequential
+- thoughtNumber: 2
+- buildUpon: [thought1_id]
+- nextThoughtNeeded: true
+
+Thought 3: "Actually, let me revise my first approach..."
+- mode: sequential
+- isRevision: true
+- revisesThought: thought1_id
+- revisionReason: "Found a more efficient approach"
+```
+
+### Example 2: Mathematical Proof
+
+```
+Thought 1: "State the theorem: For all right triangles..."
+- mode: mathematics
+- thoughtType: theorem_statement
+- mathematicalModel: { latex: "a^2 + b^2 = c^2", symbolic: "a**2 + b**2 == c**2" }
+
+Thought 2: "Proof by construction..."
+- mode: mathematics
+- thoughtType: proof_construction
+- proofStrategy: { type: "construction", steps: ["Draw square on each side", ...] }
+```
+
+### Example 3: Physics Tensor Analysis
+
+```
+Thought 1: "Define the electromagnetic field tensor"
+- mode: physics
+- thoughtType: tensor_formulation
+- tensorProperties: {
+    rank: [2, 0],
+    components: "F^{μν} = ∂^μ A^ν - ∂^ν A^μ",
+    latex: "F^{\\mu\\nu}",
+    symmetries: ["antisymmetric"],
+    invariants: ["F_{μν}F^{μν}"],
+    transformation: "contravariant"
+  }
+- physicalInterpretation: {
+    quantity: "Electromagnetic field strength",
+    units: "GeV^2",
+    conservationLaws: ["Energy-momentum", "Charge"]
+  }
+```
+
+## Development
+
+### Building
+
+```bash
+npm install
+npm run build
+```
+
+### Testing
+
+```bash
+npm test
+```
+
+### Type Checking
+
+```bash
+npm run typecheck
+```
+
+## Architecture
+
+```
+deepthinking-mcp/
+├── src/
+│   ├── types/          # Type definitions
+│   │   ├── core.ts     # Core thought types
+│   │   └── session.ts  # Session management types
+│   ├── tools/          # MCP tool definitions
+│   ├── session/        # Session manager
+│   ├── modes/          # Mode implementations
+│   ├── validation/     # Validation logic
+│   └── index.ts        # Main MCP server
+├── tests/              # Test suite
+├── docs/               # Documentation
+└── examples/           # Usage examples
+```
+
+## Roadmap
+
+### Phase 1 (Current)
+- ✅ Core type system
+- ✅ Session management
+- ✅ Unified thinking tool
+- ✅ Multiple mode support
+
+### Phase 2 (Next)
+- [ ] Validation engine
+- [ ] Export to LaTeX/Jupyter
+- [ ] Visualization (Mermaid diagrams)
+- [ ] Math-MCP integration
+
+### Phase 3 (Future)
+- [ ] Persistence layer
+- [ ] Collaborative thinking
+- [ ] Pattern learning
+- [ ] Plugin system
+
+## Contributing
+
+Contributions welcome! Please read our contributing guidelines and submit PRs.
+
+## License
+
+MIT
+
+## Credits
+
+Built upon:
+- [sequential-thinking](https://github.com/modelcontextprotocol/servers/tree/main/src/sequentialthinking) by Anthropic
+- [shannon-thinking](https://github.com/olaservo/shannon-thinking) by olaservo
+- Enhanced for mathematical and physics reasoning by Daniel Simon Jr.
+
+## Support
+
+- GitHub Issues: [Report bugs or request features](https://github.com/danielsimonjr/deepthinking-mcp/issues)
+- Documentation: [Full docs](https://github.com/danielsimonjr/deepthinking-mcp/tree/main/docs)

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,629 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { randomUUID } from 'crypto';
+import { z } from 'zod';
+
+var ThinkingToolSchema = z.object({
+  sessionId: z.string().optional(),
+  mode: z.enum(["sequential", "shannon", "mathematics", "physics", "hybrid"]).default("hybrid"),
+  thought: z.string(),
+  thoughtNumber: z.number().int().positive(),
+  totalThoughts: z.number().int().positive(),
+  nextThoughtNeeded: z.boolean(),
+  isRevision: z.boolean().optional(),
+  revisesThought: z.string().optional(),
+  revisionReason: z.string().optional(),
+  branchFrom: z.string().optional(),
+  branchId: z.string().optional(),
+  stage: z.enum(["problem_definition", "constraints", "model", "proof", "implementation"]).optional(),
+  uncertainty: z.number().min(0).max(1).optional(),
+  dependencies: z.array(z.string()).optional(),
+  assumptions: z.array(z.string()).optional(),
+  thoughtType: z.string().optional(),
+  mathematicalModel: z.object({
+    latex: z.string(),
+    symbolic: z.string(),
+    ascii: z.string().optional()
+  }).optional(),
+  proofStrategy: z.object({
+    type: z.enum(["direct", "contradiction", "induction", "construction", "contrapositive"]),
+    steps: z.array(z.string())
+  }).optional(),
+  tensorProperties: z.object({
+    rank: z.tuple([z.number(), z.number()]),
+    components: z.string(),
+    latex: z.string(),
+    symmetries: z.array(z.string()),
+    invariants: z.array(z.string()),
+    transformation: z.enum(["covariant", "contravariant", "mixed"])
+  }).optional(),
+  physicalInterpretation: z.object({
+    quantity: z.string(),
+    units: z.string(),
+    conservationLaws: z.array(z.string())
+  }).optional(),
+  action: z.enum(["add_thought", "summarize", "export", "switch_mode", "get_session"]).default("add_thought"),
+  exportFormat: z.enum(["markdown", "latex", "json", "html", "jupyter"]).optional(),
+  newMode: z.enum(["sequential", "shannon", "mathematics", "physics", "hybrid"]).optional()
+});
+var thinkingTool = {
+  name: "deepthinking",
+  description: `Advanced deep thinking tool supporting multiple reasoning modes:
+- sequential: Iterative refinement and exploration
+- shannon: Systematic 5-stage problem-solving
+- mathematics: Theorem proving and symbolic reasoning
+- physics: Tensor mathematics and field theory
+- hybrid: Intelligently combines multiple approaches
+
+Choose the mode that best fits your problem type.`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      sessionId: {
+        type: "string",
+        description: "Session ID (creates new if omitted)"
+      },
+      mode: {
+        type: "string",
+        enum: ["sequential", "shannon", "mathematics", "physics", "hybrid"],
+        description: "Thinking mode to use"
+      },
+      thought: {
+        type: "string",
+        description: "The thought content"
+      },
+      thoughtNumber: {
+        type: "integer",
+        minimum: 1,
+        description: "Position in sequence"
+      },
+      totalThoughts: {
+        type: "integer",
+        minimum: 1,
+        description: "Estimated total thoughts"
+      },
+      nextThoughtNeeded: {
+        type: "boolean",
+        description: "Should thinking continue?"
+      },
+      isRevision: {
+        type: "boolean",
+        description: "Whether this revises previous thinking"
+      },
+      revisesThought: {
+        type: "string",
+        description: "Which thought is being reconsidered"
+      },
+      revisionReason: {
+        type: "string",
+        description: "Reason for revision"
+      },
+      branchFrom: {
+        type: "string",
+        description: "Branching point thought"
+      },
+      branchId: {
+        type: "string",
+        description: "Branch identifier"
+      },
+      stage: {
+        type: "string",
+        enum: ["problem_definition", "constraints", "model", "proof", "implementation"],
+        description: "Shannon methodology stage"
+      },
+      uncertainty: {
+        type: "number",
+        minimum: 0,
+        maximum: 1,
+        description: "Uncertainty level (0-1)"
+      },
+      dependencies: {
+        type: "array",
+        items: { type: "string" },
+        description: "Dependencies on other thoughts"
+      },
+      assumptions: {
+        type: "array",
+        items: { type: "string" },
+        description: "Assumptions made"
+      },
+      thoughtType: {
+        type: "string",
+        description: "Type of mathematical thought"
+      },
+      mathematicalModel: {
+        type: "object",
+        properties: {
+          latex: { type: "string", description: "LaTeX representation" },
+          symbolic: { type: "string", description: "Symbolic representation" },
+          ascii: { type: "string", description: "ASCII representation" }
+        },
+        required: ["latex", "symbolic"]
+      },
+      proofStrategy: {
+        type: "object",
+        properties: {
+          type: {
+            type: "string",
+            enum: ["direct", "contradiction", "induction", "construction", "contrapositive"]
+          },
+          steps: {
+            type: "array",
+            items: { type: "string" }
+          }
+        },
+        required: ["type", "steps"]
+      },
+      tensorProperties: {
+        type: "object",
+        properties: {
+          rank: {
+            type: "array",
+            items: { type: "number" },
+            minItems: 2,
+            maxItems: 2
+          },
+          components: { type: "string" },
+          latex: { type: "string" },
+          symmetries: {
+            type: "array",
+            items: { type: "string" }
+          },
+          invariants: {
+            type: "array",
+            items: { type: "string" }
+          },
+          transformation: {
+            type: "string",
+            enum: ["covariant", "contravariant", "mixed"]
+          }
+        },
+        required: ["rank", "components", "latex", "symmetries", "invariants", "transformation"]
+      },
+      physicalInterpretation: {
+        type: "object",
+        properties: {
+          quantity: { type: "string" },
+          units: { type: "string" },
+          conservationLaws: {
+            type: "array",
+            items: { type: "string" }
+          }
+        },
+        required: ["quantity", "units", "conservationLaws"]
+      },
+      action: {
+        type: "string",
+        enum: ["add_thought", "summarize", "export", "switch_mode", "get_session"],
+        description: "Action to perform"
+      },
+      exportFormat: {
+        type: "string",
+        enum: ["markdown", "latex", "json", "html", "jupyter"],
+        description: "Export format"
+      },
+      newMode: {
+        type: "string",
+        enum: ["sequential", "shannon", "mathematics", "physics", "hybrid"],
+        description: "New mode for switch_mode action"
+      }
+    },
+    required: ["thought", "thoughtNumber", "totalThoughts", "nextThoughtNeeded"]
+  }
+};
+var DEFAULT_CONFIG = {
+  modeConfig: {
+    mode: "hybrid" /* HYBRID */,
+    strictValidation: false,
+    allowModeSwitch: true
+  },
+  enableAutoSave: true,
+  enableValidation: true,
+  enableVisualization: true,
+  integrations: {},
+  exportFormats: ["markdown", "latex", "json"],
+  autoExportOnComplete: false,
+  maxThoughtsInMemory: 1e3,
+  compressionThreshold: 500
+};
+var SessionManager = class {
+  activeSessions;
+  config;
+  constructor(config) {
+    this.activeSessions = /* @__PURE__ */ new Map();
+    this.config = config || {};
+  }
+  /**
+   * Create a new thinking session
+   */
+  async createSession(options = {}) {
+    const sessionId = randomUUID();
+    const now = /* @__PURE__ */ new Date();
+    const session = {
+      id: sessionId,
+      title: options.title || "Untitled Session",
+      mode: options.mode || "hybrid" /* HYBRID */,
+      domain: options.domain,
+      config: this.mergeConfig(options.config),
+      thoughts: [],
+      createdAt: now,
+      updatedAt: now,
+      author: options.author,
+      currentThoughtNumber: 0,
+      isComplete: false,
+      metrics: this.initializeMetrics(),
+      tags: [],
+      collaborators: options.author ? [options.author] : []
+    };
+    this.activeSessions.set(sessionId, session);
+    return session;
+  }
+  /**
+   * Get a session by ID
+   */
+  async getSession(sessionId) {
+    return this.activeSessions.get(sessionId) || null;
+  }
+  /**
+   * Add a thought to a session
+   */
+  async addThought(sessionId, thought) {
+    const session = this.activeSessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    thought.sessionId = sessionId;
+    thought.timestamp = /* @__PURE__ */ new Date();
+    session.thoughts.push(thought);
+    session.currentThoughtNumber = thought.thoughtNumber;
+    session.updatedAt = /* @__PURE__ */ new Date();
+    this.updateMetrics(session, thought);
+    if (!thought.nextThoughtNeeded) {
+      session.isComplete = true;
+    }
+    return session;
+  }
+  /**
+   * Update session mode
+   */
+  async switchMode(sessionId, newMode, reason) {
+    const session = this.activeSessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    session.mode;
+    session.mode = newMode;
+    session.config.modeConfig.mode = newMode;
+    session.updatedAt = /* @__PURE__ */ new Date();
+    return session;
+  }
+  /**
+   * List all sessions
+   */
+  async listSessions() {
+    return Array.from(this.activeSessions.values()).map((session) => ({
+      id: session.id,
+      title: session.title,
+      createdAt: session.createdAt,
+      updatedAt: session.updatedAt,
+      thoughtCount: session.thoughts.length,
+      mode: session.mode,
+      isComplete: session.isComplete
+    }));
+  }
+  /**
+   * Delete a session
+   */
+  async deleteSession(sessionId) {
+    this.activeSessions.delete(sessionId);
+  }
+  /**
+   * Generate summary of session
+   */
+  async generateSummary(sessionId) {
+    const session = this.activeSessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    let summary = `# ${session.title}
+
+`;
+    summary += `Mode: ${session.mode}
+`;
+    summary += `Total Thoughts: ${session.thoughts.length}
+`;
+    summary += `Status: ${session.isComplete ? "Complete" : "In Progress"}
+
+`;
+    summary += `## Key Thoughts:
+
+`;
+    for (const thought of session.thoughts) {
+      summary += `${thought.thoughtNumber}. ${thought.content.substring(0, 100)}...
+`;
+    }
+    return summary;
+  }
+  /**
+   * Merge configurations
+   */
+  mergeConfig(userConfig) {
+    return {
+      ...DEFAULT_CONFIG,
+      ...this.config,
+      ...userConfig
+    };
+  }
+  /**
+   * Initialize metrics
+   */
+  initializeMetrics() {
+    return {
+      totalThoughts: 0,
+      thoughtsByType: {},
+      averageUncertainty: 0,
+      revisionCount: 0,
+      timeSpent: 0,
+      dependencyDepth: 0
+    };
+  }
+  /**
+   * Update session metrics
+   */
+  updateMetrics(session, thought) {
+    const metrics = session.metrics;
+    metrics.totalThoughts = session.thoughts.length;
+    if (thought.isRevision) {
+      metrics.revisionCount++;
+    }
+    metrics.timeSpent = session.updatedAt.getTime() - session.createdAt.getTime();
+    if ("uncertainty" in thought) {
+      const totalUncertainty = session.thoughts.filter((t) => "uncertainty" in t).reduce((sum, t) => sum + t.uncertainty, 0);
+      const thoughtsWithUncertainty = session.thoughts.filter((t) => "uncertainty" in t).length;
+      metrics.averageUncertainty = thoughtsWithUncertainty > 0 ? totalUncertainty / thoughtsWithUncertainty : 0;
+    }
+    if ("dependencies" in thought) {
+      const deps = thought.dependencies;
+      if (deps.length > metrics.dependencyDepth) {
+        metrics.dependencyDepth = deps.length;
+      }
+    }
+  }
+};
+
+// src/index.ts
+var server = new Server(
+  {
+    name: "deepthinking-mcp",
+    version: "1.0.0"
+  },
+  {
+    capabilities: {
+      tools: {}
+    }
+  }
+);
+var sessionManager = new SessionManager();
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [thinkingTool]
+  };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  if (name === "deepthinking") {
+    try {
+      const input = ThinkingToolSchema.parse(args);
+      switch (input.action) {
+        case "add_thought":
+          return await handleAddThought(input);
+        case "summarize":
+          return await handleSummarize(input);
+        case "export":
+          return await handleExport(input);
+        case "switch_mode":
+          return await handleSwitchMode(input);
+        case "get_session":
+          return await handleGetSession(input);
+        default:
+          throw new Error(`Unknown action: ${input.action}`);
+      }
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: ${error instanceof Error ? error.message : String(error)}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+  throw new Error(`Unknown tool: ${name}`);
+});
+async function handleAddThought(input) {
+  let sessionId = input.sessionId;
+  if (!sessionId) {
+    const session2 = await sessionManager.createSession({
+      mode: input.mode,
+      title: `Thinking Session ${(/* @__PURE__ */ new Date()).toISOString()}`
+    });
+    sessionId = session2.id;
+  }
+  const thought = createThought(input, sessionId);
+  const session = await sessionManager.addThought(sessionId, thought);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          sessionId: session.id,
+          thoughtId: thought.id,
+          thoughtNumber: thought.thoughtNumber,
+          mode: thought.mode,
+          nextThoughtNeeded: thought.nextThoughtNeeded,
+          sessionComplete: session.isComplete,
+          totalThoughts: session.thoughts.length
+        }, null, 2)
+      }
+    ]
+  };
+}
+async function handleSummarize(input) {
+  if (!input.sessionId) {
+    throw new Error("sessionId required for summarize action");
+  }
+  const summary = await sessionManager.generateSummary(input.sessionId);
+  return {
+    content: [
+      {
+        type: "text",
+        text: summary
+      }
+    ]
+  };
+}
+async function handleExport(input) {
+  if (!input.sessionId) {
+    throw new Error("sessionId required for export action");
+  }
+  const session = await sessionManager.getSession(input.sessionId);
+  if (!session) {
+    throw new Error(`Session ${input.sessionId} not found`);
+  }
+  const exported = JSON.stringify(session, null, 2);
+  return {
+    content: [
+      {
+        type: "text",
+        text: exported
+      }
+    ]
+  };
+}
+async function handleSwitchMode(input) {
+  if (!input.sessionId || !input.newMode) {
+    throw new Error("sessionId and newMode required for switch_mode action");
+  }
+  const session = await sessionManager.switchMode(
+    input.sessionId,
+    input.newMode,
+    "User requested mode switch"
+  );
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Switched session ${session.id} to ${session.mode} mode`
+      }
+    ]
+  };
+}
+async function handleGetSession(input) {
+  if (!input.sessionId) {
+    throw new Error("sessionId required for get_session action");
+  }
+  const session = await sessionManager.getSession(input.sessionId);
+  if (!session) {
+    throw new Error(`Session ${input.sessionId} not found`);
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          id: session.id,
+          title: session.title,
+          mode: session.mode,
+          thoughtCount: session.thoughts.length,
+          isComplete: session.isComplete,
+          metrics: session.metrics
+        }, null, 2)
+      }
+    ]
+  };
+}
+function createThought(input, sessionId) {
+  const baseThought = {
+    id: randomUUID(),
+    sessionId,
+    thoughtNumber: input.thoughtNumber,
+    totalThoughts: input.totalThoughts,
+    content: input.thought,
+    timestamp: /* @__PURE__ */ new Date(),
+    nextThoughtNeeded: input.nextThoughtNeeded,
+    isRevision: input.isRevision,
+    revisesThought: input.revisesThought
+  };
+  switch (input.mode) {
+    case "sequential":
+      return {
+        ...baseThought,
+        mode: "sequential" /* SEQUENTIAL */,
+        revisionReason: input.revisionReason,
+        branchFrom: input.branchFrom,
+        branchId: input.branchId
+      };
+    case "shannon":
+      return {
+        ...baseThought,
+        mode: "shannon" /* SHANNON */,
+        stage: input.stage || "problem_definition" /* PROBLEM_DEFINITION */,
+        uncertainty: input.uncertainty || 0.5,
+        dependencies: input.dependencies || [],
+        assumptions: input.assumptions || []
+      };
+    case "mathematics":
+      return {
+        ...baseThought,
+        mode: "mathematics" /* MATHEMATICS */,
+        thoughtType: input.thoughtType,
+        mathematicalModel: input.mathematicalModel,
+        proofStrategy: input.proofStrategy,
+        dependencies: input.dependencies || [],
+        assumptions: input.assumptions || [],
+        uncertainty: input.uncertainty || 0.5
+      };
+    case "physics":
+      return {
+        ...baseThought,
+        mode: "physics" /* PHYSICS */,
+        thoughtType: input.thoughtType,
+        tensorProperties: input.tensorProperties,
+        physicalInterpretation: input.physicalInterpretation,
+        dependencies: input.dependencies || [],
+        assumptions: input.assumptions || [],
+        uncertainty: input.uncertainty || 0.5
+      };
+    case "hybrid":
+    default:
+      return {
+        ...baseThought,
+        mode: "hybrid" /* HYBRID */,
+        thoughtType: input.thoughtType,
+        stage: input.stage,
+        uncertainty: input.uncertainty,
+        dependencies: input.dependencies,
+        assumptions: input.assumptions,
+        mathematicalModel: input.mathematicalModel,
+        tensorProperties: input.tensorProperties,
+        physicalInterpretation: input.physicalInterpretation,
+        primaryMode: input.mode,
+        secondaryFeatures: []
+      };
+  }
+}
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("DeepThinking MCP server running on stdio");
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tools/thinking.ts","../src/session/manager.ts","../src/index.ts"],"names":["session","randomUUID"],"mappings":"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","file":"index.js","sourcesContent":["/**\n * Unified thinking tool for DeepThinking MCP\n * Supports all thinking modes in one tool\n */\n\nimport { z } from 'zod';\n\n/**\n * Zod schema for runtime validation (internal use)\n */\nexport const ThinkingToolSchema = z.object({\n  sessionId: z.string().optional(),\n  mode: z.enum(['sequential', 'shannon', 'mathematics', 'physics', 'hybrid']).default('hybrid'),\n  thought: z.string(),\n  thoughtNumber: z.number().int().positive(),\n  totalThoughts: z.number().int().positive(),\n  nextThoughtNeeded: z.boolean(),\n  isRevision: z.boolean().optional(),\n  revisesThought: z.string().optional(),\n  revisionReason: z.string().optional(),\n  branchFrom: z.string().optional(),\n  branchId: z.string().optional(),\n  stage: z.enum(['problem_definition', 'constraints', 'model', 'proof', 'implementation']).optional(),\n  uncertainty: z.number().min(0).max(1).optional(),\n  dependencies: z.array(z.string()).optional(),\n  assumptions: z.array(z.string()).optional(),\n  thoughtType: z.string().optional(),\n  mathematicalModel: z.object({\n    latex: z.string(),\n    symbolic: z.string(),\n    ascii: z.string().optional(),\n  }).optional(),\n  proofStrategy: z.object({\n    type: z.enum(['direct', 'contradiction', 'induction', 'construction', 'contrapositive']),\n    steps: z.array(z.string()),\n  }).optional(),\n  tensorProperties: z.object({\n    rank: z.tuple([z.number(), z.number()]),\n    components: z.string(),\n    latex: z.string(),\n    symmetries: z.array(z.string()),\n    invariants: z.array(z.string()),\n    transformation: z.enum(['covariant', 'contravariant', 'mixed']),\n  }).optional(),\n  physicalInterpretation: z.object({\n    quantity: z.string(),\n    units: z.string(),\n    conservationLaws: z.array(z.string()),\n  }).optional(),\n  action: z.enum(['add_thought', 'summarize', 'export', 'switch_mode', 'get_session']).default('add_thought'),\n  exportFormat: z.enum(['markdown', 'latex', 'json', 'html', 'jupyter']).optional(),\n  newMode: z.enum(['sequential', 'shannon', 'mathematics', 'physics', 'hybrid']).optional(),\n});\n\nexport type ThinkingToolInput = z.infer<typeof ThinkingToolSchema>;\n\n/**\n * Tool definition using plain JSON Schema (MCP standard format)\n */\nexport const thinkingTool = {\n  name: 'deepthinking',\n  description: `Advanced deep thinking tool supporting multiple reasoning modes:\n- sequential: Iterative refinement and exploration\n- shannon: Systematic 5-stage problem-solving\n- mathematics: Theorem proving and symbolic reasoning\n- physics: Tensor mathematics and field theory\n- hybrid: Intelligently combines multiple approaches\n\nChoose the mode that best fits your problem type.`,\n  inputSchema: {\n    type: \"object\",\n    properties: {\n      sessionId: {\n        type: \"string\",\n        description: \"Session ID (creates new if omitted)\"\n      },\n      mode: {\n        type: \"string\",\n        enum: [\"sequential\", \"shannon\", \"mathematics\", \"physics\", \"hybrid\"],\n        description: \"Thinking mode to use\"\n      },\n      thought: {\n        type: \"string\",\n        description: \"The thought content\"\n      },\n      thoughtNumber: {\n        type: \"integer\",\n        minimum: 1,\n        description: \"Position in sequence\"\n      },\n      totalThoughts: {\n        type: \"integer\",\n        minimum: 1,\n        description: \"Estimated total thoughts\"\n      },\n      nextThoughtNeeded: {\n        type: \"boolean\",\n        description: \"Should thinking continue?\"\n      },\n      isRevision: {\n        type: \"boolean\",\n        description: \"Whether this revises previous thinking\"\n      },\n      revisesThought: {\n        type: \"string\",\n        description: \"Which thought is being reconsidered\"\n      },\n      revisionReason: {\n        type: \"string\",\n        description: \"Reason for revision\"\n      },\n      branchFrom: {\n        type: \"string\",\n        description: \"Branching point thought\"\n      },\n      branchId: {\n        type: \"string\",\n        description: \"Branch identifier\"\n      },\n      stage: {\n        type: \"string\",\n        enum: [\"problem_definition\", \"constraints\", \"model\", \"proof\", \"implementation\"],\n        description: \"Shannon methodology stage\"\n      },\n      uncertainty: {\n        type: \"number\",\n        minimum: 0,\n        maximum: 1,\n        description: \"Uncertainty level (0-1)\"\n      },\n      dependencies: {\n        type: \"array\",\n        items: { type: \"string\" },\n        description: \"Dependencies on other thoughts\"\n      },\n      assumptions: {\n        type: \"array\",\n        items: { type: \"string\" },\n        description: \"Assumptions made\"\n      },\n      thoughtType: {\n        type: \"string\",\n        description: \"Type of mathematical thought\"\n      },\n      mathematicalModel: {\n        type: \"object\",\n        properties: {\n          latex: { type: \"string\", description: \"LaTeX representation\" },\n          symbolic: { type: \"string\", description: \"Symbolic representation\" },\n          ascii: { type: \"string\", description: \"ASCII representation\" }\n        },\n        required: [\"latex\", \"symbolic\"]\n      },\n      proofStrategy: {\n        type: \"object\",\n        properties: {\n          type: {\n            type: \"string\",\n            enum: [\"direct\", \"contradiction\", \"induction\", \"construction\", \"contrapositive\"]\n          },\n          steps: {\n            type: \"array\",\n            items: { type: \"string\" }\n          }\n        },\n        required: [\"type\", \"steps\"]\n      },\n      tensorProperties: {\n        type: \"object\",\n        properties: {\n          rank: {\n            type: \"array\",\n            items: { type: \"number\" },\n            minItems: 2,\n            maxItems: 2\n          },\n          components: { type: \"string\" },\n          latex: { type: \"string\" },\n          symmetries: {\n            type: \"array\",\n            items: { type: \"string\" }\n          },\n          invariants: {\n            type: \"array\",\n            items: { type: \"string\" }\n          },\n          transformation: {\n            type: \"string\",\n            enum: [\"covariant\", \"contravariant\", \"mixed\"]\n          }\n        },\n        required: [\"rank\", \"components\", \"latex\", \"symmetries\", \"invariants\", \"transformation\"]\n      },\n      physicalInterpretation: {\n        type: \"object\",\n        properties: {\n          quantity: { type: \"string\" },\n          units: { type: \"string\" },\n          conservationLaws: {\n            type: \"array\",\n            items: { type: \"string\" }\n          }\n        },\n        required: [\"quantity\", \"units\", \"conservationLaws\"]\n      },\n      action: {\n        type: \"string\",\n        enum: [\"add_thought\", \"summarize\", \"export\", \"switch_mode\", \"get_session\"],\n        description: \"Action to perform\"\n      },\n      exportFormat: {\n        type: \"string\",\n        enum: [\"markdown\", \"latex\", \"json\", \"html\", \"jupyter\"],\n        description: \"Export format\"\n      },\n      newMode: {\n        type: \"string\",\n        enum: [\"sequential\", \"shannon\", \"mathematics\", \"physics\", \"hybrid\"],\n        description: \"New mode for switch_mode action\"\n      }\n    },\n    required: [\"thought\", \"thoughtNumber\", \"totalThoughts\", \"nextThoughtNeeded\"]\n  }\n};\n","/**\n * Session Manager for DeepThinking MCP\n * Manages thinking sessions, persistence, and analytics\n */\n\nimport { randomUUID } from 'crypto';\nimport {\n  ThinkingSession,\n  SessionConfig,\n  SessionMetrics,\n  SessionMetadata,\n  Thought,\n  ThinkingMode,\n  ExportFormat\n} from '../types/index.js';\n\n/**\n * Default session configuration\n */\nconst DEFAULT_CONFIG: SessionConfig = {\n  modeConfig: {\n    mode: ThinkingMode.HYBRID,\n    strictValidation: false,\n    allowModeSwitch: true\n  },\n  enableAutoSave: true,\n  enableValidation: true,\n  enableVisualization: true,\n  integrations: {},\n  exportFormats: ['markdown', 'latex', 'json'],\n  autoExportOnComplete: false,\n  maxThoughtsInMemory: 1000,\n  compressionThreshold: 500\n};\n\n/**\n * Session Manager\n */\nexport class SessionManager {\n  private activeSessions: Map<string, ThinkingSession>;\n  private config: Partial<SessionConfig>;\n\n  constructor(config?: Partial<SessionConfig>) {\n    this.activeSessions = new Map();\n    this.config = config || {};\n  }\n\n  /**\n   * Create a new thinking session\n   */\n  async createSession(options: {\n    title?: string;\n    mode?: ThinkingMode;\n    domain?: string;\n    author?: string;\n    config?: Partial<SessionConfig>;\n  } = {}): Promise<ThinkingSession> {\n    const sessionId = randomUUID();\n    const now = new Date();\n\n    const session: ThinkingSession = {\n      id: sessionId,\n      title: options.title || 'Untitled Session',\n      mode: options.mode || ThinkingMode.HYBRID,\n      domain: options.domain,\n      config: this.mergeConfig(options.config),\n      thoughts: [],\n      createdAt: now,\n      updatedAt: now,\n      author: options.author,\n      currentThoughtNumber: 0,\n      isComplete: false,\n      metrics: this.initializeMetrics(),\n      tags: [],\n      collaborators: options.author ? [options.author] : []\n    };\n\n    this.activeSessions.set(sessionId, session);\n    return session;\n  }\n\n  /**\n   * Get a session by ID\n   */\n  async getSession(sessionId: string): Promise<ThinkingSession | null> {\n    return this.activeSessions.get(sessionId) || null;\n  }\n\n  /**\n   * Add a thought to a session\n   */\n  async addThought(sessionId: string, thought: Thought): Promise<ThinkingSession> {\n    const session = this.activeSessions.get(sessionId);\n    if (!session) {\n      throw new Error(`Session ${sessionId} not found`);\n    }\n\n    // Update thought with session metadata\n    thought.sessionId = sessionId;\n    thought.timestamp = new Date();\n\n    // Add thought to session\n    session.thoughts.push(thought);\n    session.currentThoughtNumber = thought.thoughtNumber;\n    session.updatedAt = new Date();\n\n    // Update metrics\n    this.updateMetrics(session, thought);\n\n    // Check if session is complete\n    if (!thought.nextThoughtNeeded) {\n      session.isComplete = true;\n    }\n\n    return session;\n  }\n\n  /**\n   * Update session mode\n   */\n  async switchMode(\n    sessionId: string,\n    newMode: ThinkingMode,\n    reason?: string\n  ): Promise<ThinkingSession> {\n    const session = this.activeSessions.get(sessionId);\n    if (!session) {\n      throw new Error(`Session ${sessionId} not found`);\n    }\n\n    const oldMode = session.mode;\n    session.mode = newMode;\n    session.config.modeConfig.mode = newMode;\n    session.updatedAt = new Date();\n\n    return session;\n  }\n\n  /**\n   * List all sessions\n   */\n  async listSessions(): Promise<SessionMetadata[]> {\n    return Array.from(this.activeSessions.values()).map(session => ({\n      id: session.id,\n      title: session.title,\n      createdAt: session.createdAt,\n      updatedAt: session.updatedAt,\n      thoughtCount: session.thoughts.length,\n      mode: session.mode,\n      isComplete: session.isComplete\n    }));\n  }\n\n  /**\n   * Delete a session\n   */\n  async deleteSession(sessionId: string): Promise<void> {\n    this.activeSessions.delete(sessionId);\n  }\n\n  /**\n   * Generate summary of session\n   */\n  async generateSummary(sessionId: string): Promise<string> {\n    const session = this.activeSessions.get(sessionId);\n    if (!session) {\n      throw new Error(`Session ${sessionId} not found`);\n    }\n\n    let summary = `# ${session.title}\\n\\n`;\n    summary += `Mode: ${session.mode}\\n`;\n    summary += `Total Thoughts: ${session.thoughts.length}\\n`;\n    summary += `Status: ${session.isComplete ? 'Complete' : 'In Progress'}\\n\\n`;\n\n    summary += `## Key Thoughts:\\n\\n`;\n    for (const thought of session.thoughts) {\n      summary += `${thought.thoughtNumber}. ${thought.content.substring(0, 100)}...\\n`;\n    }\n\n    return summary;\n  }\n\n  /**\n   * Merge configurations\n   */\n  private mergeConfig(userConfig?: Partial<SessionConfig>): SessionConfig {\n    return {\n      ...DEFAULT_CONFIG,\n      ...this.config,\n      ...userConfig\n    } as SessionConfig;\n  }\n\n  /**\n   * Initialize metrics\n   */\n  private initializeMetrics(): SessionMetrics {\n    return {\n      totalThoughts: 0,\n      thoughtsByType: {},\n      averageUncertainty: 0,\n      revisionCount: 0,\n      timeSpent: 0,\n      dependencyDepth: 0\n    };\n  }\n\n  /**\n   * Update session metrics\n   */\n  private updateMetrics(session: ThinkingSession, thought: Thought): void {\n    const metrics = session.metrics;\n\n    // Update total thoughts\n    metrics.totalThoughts = session.thoughts.length;\n\n    // Update revision count\n    if (thought.isRevision) {\n      metrics.revisionCount++;\n    }\n\n    // Update time spent (in milliseconds)\n    metrics.timeSpent = session.updatedAt.getTime() - session.createdAt.getTime();\n\n    // Update average uncertainty (for modes that have uncertainty)\n    if ('uncertainty' in thought) {\n      const totalUncertainty = session.thoughts\n        .filter(t => 'uncertainty' in t)\n        .reduce((sum, t) => sum + (t as any).uncertainty, 0);\n      const thoughtsWithUncertainty = session.thoughts.filter(t => 'uncertainty' in t).length;\n      metrics.averageUncertainty = thoughtsWithUncertainty > 0\n        ? totalUncertainty / thoughtsWithUncertainty\n        : 0;\n    }\n\n    // Update dependency depth\n    if ('dependencies' in thought) {\n      const deps = (thought as any).dependencies as string[];\n      if (deps.length > metrics.dependencyDepth) {\n        metrics.dependencyDepth = deps.length;\n      }\n    }\n  }\n}\n","#!/usr/bin/env node\n\n/**\n * DeepThinking MCP Server\n * Unified deep thinking server combining sequential, Shannon, and mathematical reasoning\n */\n\nimport { Server } from '@modelcontextprotocol/sdk/server/index.js';\nimport { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';\nimport {\n  CallToolRequestSchema,\n  ListToolsRequestSchema,\n} from '@modelcontextprotocol/sdk/types.js';\nimport { randomUUID } from 'crypto';\n\nimport { thinkingTool, ThinkingToolInput, ThinkingToolSchema } from './tools/thinking.js';\nimport { SessionManager } from './session/index.js';\nimport {\n  ThinkingMode,\n  ShannonStage,\n  SequentialThought,\n  ShannonThought,\n  MathematicsThought,\n  PhysicsThought,\n  HybridThought,\n} from './types/index.js';\n\nconst server = new Server(\n  {\n    name: 'deepthinking-mcp',\n    version: '1.0.0',\n  },\n  {\n    capabilities: {\n      tools: {},\n    },\n  }\n);\n\nconst sessionManager = new SessionManager();\n\nserver.setRequestHandler(ListToolsRequestSchema, async () => {\n  return {\n    tools: [thinkingTool],\n  };\n});\n\nserver.setRequestHandler(CallToolRequestSchema, async (request) => {\n  const { name, arguments: args } = request.params;\n\n  if (name === 'deepthinking') {\n    try {\n      const input = ThinkingToolSchema.parse(args) as ThinkingToolInput;\n\n      switch (input.action) {\n        case 'add_thought':\n          return await handleAddThought(input);\n        case 'summarize':\n          return await handleSummarize(input);\n        case 'export':\n          return await handleExport(input);\n        case 'switch_mode':\n          return await handleSwitchMode(input);\n        case 'get_session':\n          return await handleGetSession(input);\n        default:\n          throw new Error(`Unknown action: ${input.action}`);\n      }\n    } catch (error) {\n      return {\n        content: [\n          {\n            type: 'text',\n            text: `Error: ${error instanceof Error ? error.message : String(error)}`,\n          },\n        ],\n        isError: true,\n      };\n    }\n  }\n\n  throw new Error(`Unknown tool: ${name}`);\n});\n\nasync function handleAddThought(input: ThinkingToolInput) {\n  let sessionId = input.sessionId;\n  if (!sessionId) {\n    const session = await sessionManager.createSession({\n      mode: input.mode as ThinkingMode,\n      title: `Thinking Session ${new Date().toISOString()}`,\n    });\n    sessionId = session.id;\n  }\n\n  const thought = createThought(input, sessionId);\n  const session = await sessionManager.addThought(sessionId, thought);\n\n  return {\n    content: [\n      {\n        type: 'text',\n        text: JSON.stringify({\n          sessionId: session.id,\n          thoughtId: thought.id,\n          thoughtNumber: thought.thoughtNumber,\n          mode: thought.mode,\n          nextThoughtNeeded: thought.nextThoughtNeeded,\n          sessionComplete: session.isComplete,\n          totalThoughts: session.thoughts.length,\n        }, null, 2),\n      },\n    ],\n  };\n}\n\nasync function handleSummarize(input: ThinkingToolInput) {\n  if (!input.sessionId) {\n    throw new Error('sessionId required for summarize action');\n  }\n\n  const summary = await sessionManager.generateSummary(input.sessionId);\n\n  return {\n    content: [\n      {\n        type: 'text',\n        text: summary,\n      },\n    ],\n  };\n}\n\nasync function handleExport(input: ThinkingToolInput) {\n  if (!input.sessionId) {\n    throw new Error('sessionId required for export action');\n  }\n\n  const session = await sessionManager.getSession(input.sessionId);\n  if (!session) {\n    throw new Error(`Session ${input.sessionId} not found`);\n  }\n\n  const exported = JSON.stringify(session, null, 2);\n\n  return {\n    content: [\n      {\n        type: 'text',\n        text: exported,\n      },\n    ],\n  };\n}\n\nasync function handleSwitchMode(input: ThinkingToolInput) {\n  if (!input.sessionId || !input.newMode) {\n    throw new Error('sessionId and newMode required for switch_mode action');\n  }\n\n  const session = await sessionManager.switchMode(\n    input.sessionId,\n    input.newMode as ThinkingMode,\n    'User requested mode switch'\n  );\n\n  return {\n    content: [\n      {\n        type: 'text',\n        text: `Switched session ${session.id} to ${session.mode} mode`,\n      },\n    ],\n  };\n}\n\nasync function handleGetSession(input: ThinkingToolInput) {\n  if (!input.sessionId) {\n    throw new Error('sessionId required for get_session action');\n  }\n\n  const session = await sessionManager.getSession(input.sessionId);\n  if (!session) {\n    throw new Error(`Session ${input.sessionId} not found`);\n  }\n\n  return {\n    content: [\n      {\n        type: 'text',\n        text: JSON.stringify({\n          id: session.id,\n          title: session.title,\n          mode: session.mode,\n          thoughtCount: session.thoughts.length,\n          isComplete: session.isComplete,\n          metrics: session.metrics,\n        }, null, 2),\n      },\n    ],\n  };\n}\n\nfunction createThought(input: ThinkingToolInput, sessionId: string) {\n  const baseThought = {\n    id: randomUUID(),\n    sessionId,\n    thoughtNumber: input.thoughtNumber,\n    totalThoughts: input.totalThoughts,\n    content: input.thought,\n    timestamp: new Date(),\n    nextThoughtNeeded: input.nextThoughtNeeded,\n    isRevision: input.isRevision,\n    revisesThought: input.revisesThought,\n  };\n\n  switch (input.mode) {\n    case 'sequential':\n      return {\n        ...baseThought,\n        mode: ThinkingMode.SEQUENTIAL,\n        revisionReason: input.revisionReason,\n        branchFrom: input.branchFrom,\n        branchId: input.branchId,\n      } as SequentialThought;\n\n    case 'shannon':\n      return {\n        ...baseThought,\n        mode: ThinkingMode.SHANNON,\n        stage: (input.stage as ShannonStage) || ShannonStage.PROBLEM_DEFINITION,\n        uncertainty: input.uncertainty || 0.5,\n        dependencies: input.dependencies || [],\n        assumptions: input.assumptions || [],\n      } as ShannonThought;\n\n    case 'mathematics':\n      return {\n        ...baseThought,\n        mode: ThinkingMode.MATHEMATICS,\n        thoughtType: input.thoughtType as any,\n        mathematicalModel: input.mathematicalModel,\n        proofStrategy: input.proofStrategy,\n        dependencies: input.dependencies || [],\n        assumptions: input.assumptions || [],\n        uncertainty: input.uncertainty || 0.5,\n      } as MathematicsThought;\n\n    case 'physics':\n      return {\n        ...baseThought,\n        mode: ThinkingMode.PHYSICS,\n        thoughtType: input.thoughtType as any,\n        tensorProperties: input.tensorProperties,\n        physicalInterpretation: input.physicalInterpretation,\n        dependencies: input.dependencies || [],\n        assumptions: input.assumptions || [],\n        uncertainty: input.uncertainty || 0.5,\n      } as PhysicsThought;\n\n    case 'hybrid':\n    default:\n      return {\n        ...baseThought,\n        mode: ThinkingMode.HYBRID,\n        thoughtType: input.thoughtType as any,\n        stage: input.stage as ShannonStage,\n        uncertainty: input.uncertainty,\n        dependencies: input.dependencies,\n        assumptions: input.assumptions,\n        mathematicalModel: input.mathematicalModel,\n        tensorProperties: input.tensorProperties,\n        physicalInterpretation: input.physicalInterpretation,\n        primaryMode: input.mode as any,\n        secondaryFeatures: [],\n      } as HybridThought;\n  }\n}\n\nasync function main() {\n  const transport = new StdioServerTransport();\n  await server.connect(transport);\n  console.error('DeepThinking MCP server running on stdio');\n}\n\nmain().catch((error) => {\n  console.error('Fatal error:', error);\n  process.exit(1);\n});\n"]}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "deepthinking-mcp",
+  "version": "1.0.0",
+  "description": "Unified deep thinking MCP server combining sequential, Shannon, and mathematical reasoning with physics support",
+  "author": "Daniel Simon Jr.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "deepthinking-mcp": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest",
+    "test:coverage": "vitest --coverage",
+    "lint": "eslint src/",
+    "format": "prettier --write src/",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "zod": "^3.22.4",
+    "zod-to-json-schema": "^3.24.6"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "@typescript-eslint/eslint-plugin": "^6.19.0",
+    "@typescript-eslint/parser": "^6.19.0",
+    "@vitest/coverage-v8": "^1.2.0",
+    "eslint": "^8.56.0",
+    "prettier": "^3.2.4",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3",
+    "vitest": "^1.2.0"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "thinking",
+    "reasoning",
+    "sequential-thinking",
+    "shannon-thinking",
+    "physics",
+    "mathematics",
+    "tensor",
+    "deep-thinking",
+    "mathematical-reasoning"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/danielsimonjr/deepthinking-mcp"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}