@mkacki98/chestnut-mcp 0.1.0

package/README.md

@@ -0,0 +1,74 @@
+# Chestnut MCP Server
+
+MCP server for integrating Claude Code with the Chestnut learning platform. Allows Claude Code to suggest relevant courses based on coding patterns.
+
+## Installation
+
+```bash
+npx @mkacki98/chestnut-mcp auth
+```
+
+## Setup
+
+### 1. Authenticate
+
+```bash
+npx @mkacki98/chestnut-mcp auth
+```
+
+This will:
+- Open your browser to Chestnut
+- Prompt you to log in (if not already logged in)
+- Generate an access token
+- Save the token locally
+
+### 2. Configure Claude Code
+
+Add to your Claude Code MCP settings:
+
+```json
+{
+  "mcpServers": {
+    "chestnut": {
+      "command": "npx",
+      "args": ["@mkacki98/chestnut-mcp"]
+    }
+  }
+}
+```
+
+### 3. Use Claude Code
+
+Claude Code will now automatically suggest courses when it detects learning opportunities. Suggestions appear in your Chestnut dashboard.
+
+## Commands
+
+- `npx chestnut-mcp auth` - Authenticate with Chestnut
+- `npx chestnut-mcp status` - Check authentication status
+- `npx chestnut-mcp logout` - Clear saved credentials
+- `npx chestnut-mcp config` - View/set configuration
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Build
+npm run build
+
+# Test locally
+npm run dev
+```
+
+## How It Works
+
+1. Claude Code detects you're using a suboptimal pattern
+2. On session end, it calls the `create_pending_course` tool
+3. Tool sends suggestion to your Chestnut account
+4. You see the suggestion in your dashboard
+5. Click "Start Course" to begin learning
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+import { initiateOAuth } from "./oauth.js";
+import { loadAccessToken, clearAccessToken, getChestnutUrl, setChestnutUrl } from "./config.js";
+const args = process.argv.slice(2);
+const command = args[0];
+async function main() {
+    switch (command) {
+        case "auth":
+            await initiateOAuth();
+            break;
+        case "status":
+            const token = loadAccessToken();
+            if (token) {
+                console.log("✓ Authenticated with Chestnut");
+                console.log(`  Chestnut URL: ${getChestnutUrl()}`);
+                console.log(`  Token: ${token.substring(0, 8)}...`);
+            }
+            else {
+                console.log("✗ Not authenticated");
+                console.log("  Run: npx chestnut-mcp auth");
+            }
+            break;
+        case "logout":
+            clearAccessToken();
+            console.log("✓ Logged out successfully");
+            break;
+        case "config":
+            if (args[1] === "set-url" && args[2]) {
+                setChestnutUrl(args[2]);
+                console.log(`✓ Chestnut URL set to: ${args[2]}`);
+            }
+            else {
+                console.log(`Current Chestnut URL: ${getChestnutUrl()}`);
+                console.log("\nTo change URL:");
+                console.log("  npx chestnut-mcp config set-url https://your-url.com");
+            }
+            break;
+        default:
+            console.log("Chestnut MCP Server");
+            console.log("\nCommands:");
+            console.log("  auth           Authenticate with Chestnut");
+            console.log("  status         Check authentication status");
+            console.log("  logout         Clear saved token");
+            console.log("  config         View/set configuration");
+            console.log("\nFor Claude Code integration, add to your config:");
+            console.log(JSON.stringify({
+                mcpServers: {
+                    chestnut: {
+                        command: "npx",
+                        args: ["@mkacki98/chestnut-mcp"],
+                    },
+                },
+            }, null, 2));
+    }
+}
+main().catch((error) => {
+    console.error("Error:", error);
+    process.exit(1);
+});

package/dist/config.d.ts

@@ -0,0 +1,12 @@
+interface Config {
+    accessToken?: string;
+    chestnutUrl?: string;
+}
+export declare function loadConfig(): Config;
+export declare function saveConfig(config: Config): void;
+export declare function loadAccessToken(): string | null;
+export declare function saveAccessToken(token: string): void;
+export declare function clearAccessToken(): void;
+export declare function getChestnutUrl(): string;
+export declare function setChestnutUrl(url: string): void;
+export {};

package/dist/config.js

@@ -0,0 +1,46 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+const CONFIG_DIR = path.join(os.homedir(), ".chestnut-mcp");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+export function loadConfig() {
+    if (!fs.existsSync(CONFIG_FILE)) {
+        return {};
+    }
+    try {
+        const content = fs.readFileSync(CONFIG_FILE, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return {};
+    }
+}
+export function saveConfig(config) {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+export function loadAccessToken() {
+    const config = loadConfig();
+    return config.accessToken || null;
+}
+export function saveAccessToken(token) {
+    const config = loadConfig();
+    config.accessToken = token;
+    saveConfig(config);
+}
+export function clearAccessToken() {
+    const config = loadConfig();
+    delete config.accessToken;
+    saveConfig(config);
+}
+export function getChestnutUrl() {
+    const config = loadConfig();
+    return config.chestnutUrl || "https://chestnut.com"; // Replace with actual production URL
+}
+export function setChestnutUrl(url) {
+    const config = loadConfig();
+    config.chestnutUrl = url;
+    saveConfig(config);
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { createPendingCourseTool, executeCreatePendingCourse, } from "./tools/create-pending-course.js";
+const server = new Server({
+    name: "chestnut-mcp",
+    version: "0.1.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// List available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [createPendingCourseTool],
+    };
+});
+// Handle tool execution
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    if (request.params.name === "create_pending_course") {
+        const args = request.params.arguments;
+        return await executeCreatePendingCourse(args);
+    }
+    throw new Error(`Unknown tool: ${request.params.name}`);
+});
+// Start server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Chestnut MCP server running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error in main():", error);
+    process.exit(1);
+});

package/dist/oauth.d.ts

@@ -0,0 +1 @@
+export declare function initiateOAuth(): Promise<void>;

package/dist/oauth.js

@@ -0,0 +1,60 @@
+import open from "open";
+import { saveAccessToken, getChestnutUrl } from "./config.js";
+import readline from "readline";
+export async function initiateOAuth() {
+    const chestnutUrl = getChestnutUrl();
+    const authUrl = `${chestnutUrl}/api/claude-code/oauth/authorize`;
+    console.log("\nOpening browser for authorization...");
+    console.log(`If browser doesn't open, visit: ${authUrl}\n`);
+    try {
+        await open(authUrl);
+    }
+    catch (error) {
+        console.log("Could not open browser automatically.");
+    }
+    console.log("After authorizing, you'll be redirected to the dashboard with a token in the URL.");
+    console.log("Copy the token from the URL (the part after 'token=').\n");
+    const token = await promptForToken();
+    if (!token) {
+        console.log("❌ No token provided. Authentication cancelled.");
+        return;
+    }
+    // Validate token by making a test request
+    try {
+        const response = await fetch(`${chestnutUrl}/api/claude-code/pending-courses`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                query: "_test_connection",
+                reason: "Testing MCP connection",
+            }),
+        });
+        if (response.ok || response.status === 400) {
+            // 400 is ok - it means token is valid but request validation failed (expected for test)
+            saveAccessToken(token);
+            console.log("✓ Authenticated successfully with Chestnut!");
+            console.log(`Token saved to: ${process.env.HOME}/.chestnut-mcp/config.json\n`);
+        }
+        else {
+            console.log("❌ Invalid token. Please try again.");
+        }
+    }
+    catch (error) {
+        console.log("❌ Failed to validate token:", error);
+    }
+}
+async function promptForToken() {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question("Paste your token here: ", (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}

package/dist/tools/create-pending-course.d.ts

@@ -0,0 +1,27 @@
+export declare const createPendingCourseTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            query: {
+                type: string;
+                description: string;
+            };
+            reason: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function executeCreatePendingCourse(args: {
+    query: string;
+    reason: string;
+}): Promise<{
+    content: Array<{
+        type: string;
+        text: string;
+    }>;
+}>;

package/dist/tools/create-pending-course.js

@@ -0,0 +1,63 @@
+import { loadAccessToken, getChestnutUrl } from "../config.js";
+export const createPendingCourseTool = {
+    name: "create_pending_course",
+    description: "Suggest a learning course to the user based on patterns observed in their code. Use this when you notice the user could benefit from learning a specific topic or pattern.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            query: {
+                type: "string",
+                description: "The course topic to suggest (e.g., 'server actions in nextjs', 'react hooks best practices'). Keep it concise and searchable.",
+            },
+            reason: {
+                type: "string",
+                description: "Why you're suggesting this course. Explain what pattern or issue you noticed that prompted this suggestion (e.g., 'user is using API route pattern instead of Next.js native server actions').",
+            },
+        },
+        required: ["query", "reason"],
+    },
+};
+export async function executeCreatePendingCourse(args) {
+    const token = loadAccessToken();
+    const chestnutUrl = getChestnutUrl();
+    if (!token) {
+        throw new Error("Not authenticated with Chestnut. Please run: npx chestnut-mcp auth");
+    }
+    try {
+        const response = await fetch(`${chestnutUrl}/api/claude-code/pending-courses`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                query: args.query,
+                reason: args.reason,
+            }),
+        });
+        if (!response.ok) {
+            if (response.status === 401) {
+                throw new Error("Authentication failed. Please re-authenticate: npx chestnut-mcp auth");
+            }
+            if (response.status === 429) {
+                throw new Error("Too many suggestions. Please try again later.");
+            }
+            throw new Error(`Failed to create course suggestion: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `✓ Course suggestion sent to Chestnut: "${args.query}"\n\nThe user will see this suggestion in their dashboard and can start the course when ready.`,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw error;
+        }
+        throw new Error("Failed to create course suggestion");
+    }
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@mkacki98/chestnut-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for Chestnut learning platform integration",
+  "type": "module",
+  "main": "./dist/index.js",
+  "bin": {
+    "chestnut-mcp": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc && node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "claude-code",
+    "learning",
+    "chestnut"
+  ],
+  "author": "Mikolaj Kacki",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^0.5.0",
+    "open": "^10.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.0"
+  }
+}