exponential-mcp 0.1.1

package/README.md

@@ -0,0 +1,132 @@
+# Exponential MCP
+
+Connect Claude to your [Exponential](https://exponential.im) workspace. Manage projects, actions, and OKRs directly from Claude.
+
+## Quick Start
+
+### 1. Create an API Key
+
+Go to [exponential.im/settings/api-keys](https://www.exponential.im/settings/api-keys) and create a new key:
+- Click **Create API Key**
+- Select **JWT Token** as the token type
+- Copy the generated key
+
+### 2. Set Up the MCP Server
+
+```bash
+npx exponential-mcp init
+```
+
+Paste your API key when prompted.
+
+### 3. Configure for Your Claude Client
+
+**For Claude Desktop:**
+- `exponential-mcp init` will automatically configure Claude Desktop
+- Restart Claude Desktop
+
+**For Claude Code (VSCode Extension):**
+- The server uses `.mcp.json` in your project directory
+- Reload your VSCode window (`Cmd+Shift+P` → "Developer: Reload Window")
+- The server will be available in your current project
+
+### 4. Ask Claude to manage your tasks!
+
+## What Claude Can Do
+
+Once connected, Claude can:
+
+- **List projects** – "What projects am I working on?"
+- **View actions** – "Show my active tasks"
+- **Create actions** – "Add a task to call John tomorrow"
+- **Complete actions** – "Mark the report task as done"
+- **View OKRs** – "What are my Q1 goals?"
+- **Search** – "Find anything related to Kenya"
+
+## Manual Setup
+
+### For Claude Desktop
+
+**macOS (recommended path):** `~/Library/Application Support/Claude/claude_desktop_config.json`  
+**Legacy path:** `~/.claude/claude_desktop_config.json`
+
+Add this to the appropriate file:
+
+```json
+{
+  "mcpServers": {
+    "exponential": {
+      "command": "/absolute/path/to/node",
+      "args": ["/absolute/path/to/exponential-mcp/dist/index.js"]
+    }
+  }
+}
+```
+
+### For Claude Code (VSCode Extension)
+
+Create a `.mcp.json` file in your project directory:
+
+```json
+{
+  "mcpServers": {
+    "exponential": {
+      "command": "npx",
+      "args": ["-y", "exponential-mcp", "serve"]
+    }
+  }
+}
+```
+
+Then reload your VSCode window.
+
+**Note:** The API key is stored in the Exponential SDK config store (created by `npx exponential-mcp init`), so you don't need to specify it in the MCP configuration. Run `exponential-mcp config` to see the current storage path and values. Run `exponential-mcp doctor` to print a recommended MCP config snippet for your machine.
+
+## Commands
+
+```bash
+# Initialize with your API key
+exponential-mcp init
+
+# Show current config
+exponential-mcp config
+
+# Diagnose local setup
+exponential-mcp doctor
+
+# Start server manually (usually not needed)
+exponential-mcp serve
+```
+
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `get_workspaces` | List all workspaces |
+| `get_projects` | List projects (optionally by workspace) |
+| `get_actions` | List actions/tasks (filter by project or status) |
+| `create_action` | Create a new task (supports natural language) |
+| `complete_action` | Mark an action as done |
+| `get_goals` | List OKRs with progress |
+| `search` | Search across everything |
+
+## Development
+
+```bash
+# Clone the repo
+git clone https://github.com/your-org/exponential-mcp
+cd exponential-mcp
+
+# Install dependencies
+npm install
+
+# Build
+npm run build
+
+# Run locally
+npm start
+```
+
+## License
+
+MIT

package/dist/api.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Exponential API Client
+ * Handles authenticated requests to the Exponential API
+ */
+export interface ExponentialConfig {
+    apiKey: string;
+    baseUrl?: string;
+}
+export interface Project {
+    id: string;
+    name: string;
+    description?: string;
+    status: string;
+    priority: string;
+    progress: number;
+}
+export interface Action {
+    id: string;
+    name: string;
+    description?: string;
+    status: string;
+    priority: string;
+    dueDate?: string;
+    projectId?: string;
+    project?: {
+        name: string;
+    };
+}
+export interface Goal {
+    id: number;
+    title: string;
+    description?: string;
+    period?: string;
+    keyResults: KeyResult[];
+}
+export interface KeyResult {
+    id: string;
+    title: string;
+    targetValue?: number;
+    currentValue?: number;
+    status: string;
+}
+export interface Workspace {
+    id: string;
+    name: string;
+    slug: string;
+}
+export declare class ExponentialAPI {
+    private apiKey;
+    private baseUrl;
+    constructor(config: ExponentialConfig);
+    private request;
+    private trpcQuery;
+    private trpcMutation;
+    getWorkspaces(): Promise<Workspace[]>;
+    getProjects(workspaceId?: string): Promise<Project[]>;
+    getProject(id: string): Promise<Project>;
+    getActions(params?: {
+        projectId?: string;
+        status?: string;
+    }): Promise<Action[]>;
+    createAction(data: {
+        name: string;
+        description?: string;
+        projectId?: string;
+        priority?: string;
+        dueDate?: string;
+    }): Promise<Action>;
+    updateAction(id: string, data: {
+        name?: string;
+        status?: string;
+        priority?: string;
+        dueDate?: string;
+    }): Promise<Action>;
+    completeAction(id: string): Promise<Action>;
+    getGoals(workspaceId?: string): Promise<Goal[]>;
+    getGoal(id: number): Promise<Goal>;
+    quickCreateAction(text: string): Promise<Action>;
+    search(query: string): Promise<{
+        projects: Project[];
+        actions: Action[];
+        goals: Goal[];
+    }>;
+}

package/dist/api.js

@@ -0,0 +1,82 @@
+/**
+ * Exponential API Client
+ * Handles authenticated requests to the Exponential API
+ */
+const DEFAULT_BASE_URL = 'https://www.exponential.im';
+export class ExponentialAPI {
+    apiKey;
+    baseUrl;
+    constructor(config) {
+        this.apiKey = config.apiKey;
+        this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+    }
+    async request(endpoint, options = {}) {
+        const url = `${this.baseUrl}${endpoint}`;
+        const response = await fetch(url, {
+            ...options,
+            headers: {
+                'Authorization': `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json',
+                ...options.headers,
+            },
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Exponential API error (${response.status}): ${error}`);
+        }
+        return response.json();
+    }
+    // tRPC-style calls
+    async trpcQuery(procedure, input) {
+        const inputStr = input ? encodeURIComponent(JSON.stringify(input)) : '';
+        const url = `/api/trpc/${procedure}${inputStr ? `?input=${inputStr}` : ''}`;
+        return this.request(url).then(r => r.result.data);
+    }
+    async trpcMutation(procedure, input) {
+        const url = `/api/trpc/${procedure}`;
+        return this.request(url, {
+            method: 'POST',
+            body: JSON.stringify(input),
+        }).then(r => r.result.data);
+    }
+    // === Workspace ===
+    async getWorkspaces() {
+        return this.trpcQuery('workspace.list');
+    }
+    // === Projects ===
+    async getProjects(workspaceId) {
+        return this.trpcQuery('project.list', { workspaceId });
+    }
+    async getProject(id) {
+        return this.trpcQuery('project.get', { id });
+    }
+    // === Actions ===
+    async getActions(params) {
+        return this.trpcQuery('action.list', params);
+    }
+    async createAction(data) {
+        return this.trpcMutation('action.create', data);
+    }
+    async updateAction(id, data) {
+        return this.trpcMutation('action.update', { id, ...data });
+    }
+    async completeAction(id) {
+        return this.updateAction(id, { status: 'COMPLETED' });
+    }
+    // === Goals (OKRs) ===
+    async getGoals(workspaceId) {
+        return this.trpcQuery('goal.list', { workspaceId });
+    }
+    async getGoal(id) {
+        return this.trpcQuery('goal.get', { id });
+    }
+    // === Quick Actions ===
+    async quickCreateAction(text) {
+        // Uses natural language parsing (dates, project names, etc.)
+        return this.trpcMutation('action.quickCreate', { text });
+    }
+    // === Search ===
+    async search(query) {
+        return this.trpcQuery('search.global', { query });
+    }
+}

package/dist/cli.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * Exponential MCP CLI
+ * Setup and configuration for the MCP server
+ */
+export {};

package/dist/cli.js

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+/**
+ * Exponential MCP CLI
+ * Setup and configuration for the MCP server
+ */
+import { program } from 'commander';
+import { createConfigStore } from 'exponential-sdk';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { dirname, join } from 'path';
+import * as readline from 'readline';
+import { fileURLToPath } from 'url';
+const CONFIG_DIR = join(homedir(), '.config', 'exponential-mcp');
+const LEGACY_CONFIG_PATH = join(CONFIG_DIR, 'config.json');
+const configStore = createConfigStore({ projectName: 'exponential-mcp' });
+const LEGACY_CLAUDE_CONFIG_PATH = join(homedir(), '.claude', 'claude_desktop_config.json');
+const MACOS_CLAUDE_CONFIG_PATH = join(homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+function prompt(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+function migrateLegacyConfig() {
+    if (configStore.isAuthenticated() || !existsSync(LEGACY_CONFIG_PATH)) {
+        return;
+    }
+    try {
+        const legacy = JSON.parse(readFileSync(LEGACY_CONFIG_PATH, 'utf-8'));
+        if (legacy?.apiKey) {
+            configStore.saveConfig({
+                token: legacy.apiKey,
+                apiUrl: legacy.baseUrl || 'https://www.exponential.im',
+            });
+        }
+    }
+    catch {
+        // Ignore legacy config parsing errors.
+    }
+}
+function getClaudeConfigPath() {
+    if (process.platform === 'darwin') {
+        if (existsSync(MACOS_CLAUDE_CONFIG_PATH)) {
+            return MACOS_CLAUDE_CONFIG_PATH;
+        }
+        if (existsSync(LEGACY_CLAUDE_CONFIG_PATH)) {
+            return LEGACY_CLAUDE_CONFIG_PATH;
+        }
+        return MACOS_CLAUDE_CONFIG_PATH;
+    }
+    return LEGACY_CLAUDE_CONFIG_PATH;
+}
+function getServerEntry() {
+    const serverPath = fileURLToPath(new URL('./index.js', import.meta.url));
+    return {
+        command: process.execPath,
+        args: [serverPath],
+    };
+}
+function ensureParentDir(filePath) {
+    const dir = dirname(filePath);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+}
+program
+    .name('exponential-mcp')
+    .description('MCP server for Exponential - connect Claude to your productivity data')
+    .version('0.1.0');
+program
+    .command('init')
+    .description('Set up Exponential MCP with your API key')
+    .option('-k, --key <key>', 'API key (or will prompt)')
+    .option('--base-url <url>', 'Custom Exponential URL (default: https://www.exponential.im)')
+    .action(async (options) => {
+    console.log('🚀 Setting up Exponential MCP...\n');
+    // Get API key
+    let apiKey = options.key;
+    if (!apiKey) {
+        console.log('Create an API key at: https://www.exponential.im/settings/api-keys');
+        console.log('  → Select "JWT Token" as the token type\n');
+        apiKey = await prompt('Paste your API key: ');
+    }
+    if (!apiKey) {
+        console.error('❌ API key is required');
+        process.exit(1);
+    }
+    // Create config directory for legacy migrations.
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    configStore.saveConfig({
+        token: apiKey,
+        apiUrl: options.baseUrl || 'https://www.exponential.im',
+    });
+    console.log(`✅ Config saved to ${configStore.getConfigPath()}\n`);
+    // Update Claude Desktop config
+    await updateClaudeConfig();
+    console.log('\n🎉 Setup complete!\n');
+    console.log('Next steps:');
+    console.log('  1. Restart Claude Desktop');
+    console.log('  2. Ask Claude to "list my projects" or "create a task"\n');
+});
+program
+    .command('config')
+    .description('Show current configuration')
+    .action(() => {
+    migrateLegacyConfig();
+    if (!configStore.isAuthenticated()) {
+        console.log('No config found. Run "exponential-mcp init" first.');
+        return;
+    }
+    const config = configStore.loadConfig();
+    console.log('Current config:');
+    console.log(`  Base URL: ${config.apiUrl}`);
+    console.log(`  API Key: ${config.token.substring(0, 10)}...`);
+});
+program
+    .command('serve')
+    .description('Start the MCP server (usually called by Claude Desktop)')
+    .action(async () => {
+    // Import and run the server
+    await import('./index.js');
+});
+program
+    .command('doctor')
+    .description('Diagnose local MCP setup for Claude Desktop')
+    .action(() => {
+    migrateLegacyConfig();
+    const issues = [];
+    const configPath = getClaudeConfigPath();
+    const recommended = getServerEntry();
+    console.log('🩺 Exponential MCP Doctor\n');
+    if (!configStore.isAuthenticated()) {
+        issues.push('No API key found. Run "exponential-mcp init" first.');
+    }
+    if (!existsSync(configPath)) {
+        issues.push(`Claude Desktop config not found at ${configPath}`);
+    }
+    let config = null;
+    if (existsSync(configPath)) {
+        try {
+            config = JSON.parse(readFileSync(configPath, 'utf-8'));
+        }
+        catch {
+            issues.push(`Claude Desktop config is not valid JSON: ${configPath}`);
+        }
+    }
+    const serverConfig = config?.mcpServers?.exponential;
+    if (!serverConfig) {
+        issues.push('No "exponential" entry found in Claude Desktop config.');
+    }
+    else {
+        if (!serverConfig.command) {
+            issues.push('MCP config is missing "command" for Exponential.');
+        }
+        else if (!existsSync(serverConfig.command)) {
+            issues.push(`MCP command not found: ${serverConfig.command}`);
+        }
+        const serverArg = Array.isArray(serverConfig.args) ? serverConfig.args[0] : null;
+        if (!serverArg) {
+            issues.push('MCP config args missing server entry point.');
+        }
+        else if (!existsSync(serverArg)) {
+            issues.push(`MCP server entry not found: ${serverArg}`);
+        }
+    }
+    if (issues.length === 0) {
+        console.log('✅ No issues found. Claude Desktop should load the Exponential MCP server.');
+    }
+    else {
+        console.log('⚠️  Issues found:\n');
+        for (const issue of issues) {
+            console.log(`- ${issue}`);
+        }
+    }
+    console.log('\nRecommended MCP config:\n');
+    console.log(JSON.stringify({
+        mcpServers: {
+            exponential: recommended,
+        },
+    }, null, 2));
+});
+async function updateClaudeConfig() {
+    const configPath = getClaudeConfigPath();
+    ensureParentDir(configPath);
+    let claudeConfig = { mcpServers: {} };
+    // Read existing config if present
+    if (existsSync(configPath)) {
+        try {
+            claudeConfig = JSON.parse(readFileSync(configPath, 'utf-8'));
+            if (!claudeConfig.mcpServers) {
+                claudeConfig.mcpServers = {};
+            }
+        }
+        catch (e) {
+            console.log('⚠️  Could not parse existing Claude config, creating new one');
+        }
+    }
+    // Add exponential server
+    claudeConfig.mcpServers.exponential = getServerEntry();
+    writeFileSync(configPath, JSON.stringify(claudeConfig, null, 2));
+    console.log(`✅ Claude Desktop config updated: ${configPath}`);
+}
+program.parse();

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * Exponential MCP Server
+ * Connects Claude to your Exponential workspace
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,299 @@
+#!/usr/bin/env node
+/**
+ * Exponential MCP Server
+ * Connects Claude to your Exponential workspace
+ */
+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 { ExponentialClient, createConfigStore } from 'exponential-sdk';
+import { readFileSync, existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+const LEGACY_CONFIG_PATH = join(homedir(), '.config', 'exponential-mcp', 'config.json');
+const configStore = createConfigStore({ projectName: 'exponential-mcp' });
+function migrateLegacyConfig() {
+    if (configStore.isAuthenticated() || !existsSync(LEGACY_CONFIG_PATH)) {
+        return;
+    }
+    try {
+        const legacy = JSON.parse(readFileSync(LEGACY_CONFIG_PATH, 'utf-8'));
+        if (legacy?.apiKey) {
+            configStore.saveConfig({
+                token: legacy.apiKey,
+                apiUrl: legacy.baseUrl || 'https://www.exponential.im',
+            });
+        }
+    }
+    catch {
+        // Ignore legacy config parsing errors.
+    }
+}
+function loadClientConfig() {
+    migrateLegacyConfig();
+    if (configStore.isAuthenticated()) {
+        const config = configStore.loadConfig();
+        return { token: config.token, apiUrl: config.apiUrl };
+    }
+    const token = process.env.EXPONENTIAL_API_KEY || process.env.EXPONENTIAL_API_TOKEN;
+    const apiUrl = process.env.EXPONENTIAL_API_URL ||
+        process.env.EXPONENTIAL_BASE_URL ||
+        'https://www.exponential.im';
+    if (!token) {
+        console.error('Error: No API key found.');
+        console.error('Run "npx exponential-mcp init" to set up, or set EXPONENTIAL_API_KEY env var.');
+        process.exit(1);
+    }
+    return { token, apiUrl };
+}
+// Tool definitions
+const TOOLS = [
+    {
+        name: 'get_projects',
+        description: 'List all projects in Exponential. Returns project names, status, and progress.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workspaceId: {
+                    type: 'string',
+                    description: 'Optional workspace ID to filter projects'
+                }
+            }
+        }
+    },
+    {
+        name: 'get_actions',
+        description: 'List actions/tasks. Can filter by project or status.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectId: {
+                    type: 'string',
+                    description: 'Filter by project ID'
+                },
+                status: {
+                    type: 'string',
+                    enum: ['ACTIVE', 'COMPLETED', 'CANCELLED'],
+                    description: 'Filter by status (default: ACTIVE)'
+                }
+            }
+        }
+    },
+    {
+        name: 'create_action',
+        description: 'Create a new action/task. Supports natural language with dates and project names.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                text: {
+                    type: 'string',
+                    description: 'Action description (can include "tomorrow", "next week", project names, etc.)'
+                }
+            },
+            required: ['text']
+        }
+    },
+    {
+        name: 'complete_action',
+        description: 'Mark an action as completed',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: {
+                    type: 'string',
+                    description: 'Action ID to complete'
+                }
+            },
+            required: ['id']
+        }
+    },
+    {
+        name: 'get_goals',
+        description: 'List OKRs (Objectives and Key Results) with their progress',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workspaceId: {
+                    type: 'string',
+                    description: 'Optional workspace ID'
+                }
+            }
+        }
+    },
+    {
+        name: 'search',
+        description: 'Search across projects, actions, and goals',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'Search query'
+                }
+            },
+            required: ['query']
+        }
+    },
+    {
+        name: 'get_workspaces',
+        description: 'List all workspaces the user has access to',
+        inputSchema: {
+            type: 'object',
+            properties: {}
+        }
+    }
+];
+async function main() {
+    const config = loadClientConfig();
+    const client = new ExponentialClient({
+        token: config.token,
+        apiUrl: config.apiUrl,
+    });
+    const trpcClient = client.client;
+    const server = new Server({
+        name: 'exponential-mcp',
+        version: '0.1.0',
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    // List available tools
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: TOOLS,
+    }));
+    // Handle tool calls
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        try {
+            switch (name) {
+                case 'get_projects': {
+                    const projects = await client.projects.list({
+                        workspaceId: args?.workspaceId,
+                    });
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(projects, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case 'get_actions': {
+                    const status = args?.status;
+                    const projectId = args?.projectId;
+                    let actions;
+                    if (status === 'COMPLETED') {
+                        actions = await client.actions.getKanban({
+                            projectId,
+                            status: 'DONE',
+                        });
+                    }
+                    else if (status === 'CANCELLED') {
+                        actions = await client.actions.getKanban({
+                            projectId,
+                            status: 'CANCELLED',
+                        });
+                    }
+                    else {
+                        actions = await client.actions.list({ projectId });
+                    }
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(actions, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case 'create_action': {
+                    // SDK does not yet expose quickCreate, so we use the underlying tRPC client.
+                    const action = await trpcClient.action.quickCreate.mutate({
+                        text: args?.text,
+                    });
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `Created action: ${action.name} (ID: ${action.id})`,
+                            },
+                        ],
+                    };
+                }
+                case 'complete_action': {
+                    // SDK does not yet expose action updates, so we use the underlying tRPC client.
+                    const action = await trpcClient.action.update.mutate({
+                        id: args?.id,
+                        status: 'COMPLETED',
+                    });
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `Completed: ${action.name}`,
+                            },
+                        ],
+                    };
+                }
+                case 'get_goals': {
+                    const goals = await trpcClient.goal.list.query({
+                        workspaceId: args?.workspaceId,
+                    });
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(goals, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case 'search': {
+                    const results = await trpcClient.search.global.query({
+                        query: args?.query,
+                    });
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(results, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case 'get_workspaces': {
+                    const workspaces = await client.workspaces.list();
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(workspaces, null, 2),
+                            },
+                        ],
+                    };
+                }
+                default:
+                    throw new Error(`Unknown tool: ${name}`);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Start server
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('Exponential MCP server running');
+}
+main().catch(console.error);

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "exponential-mcp",
+  "version": "0.1.1",
+  "description": "MCP server for Exponential - connect Claude to your projects, actions, and goals",
+  "main": "dist/index.js",
+  "bin": {
+    "exponential-mcp": "./dist/cli.js"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "cli": "node dist/cli.js"
+  },
+  "keywords": [
+    "mcp",
+    "claude",
+    "exponential",
+    "productivity",
+    "anthropic"
+  ],
+  "author": "Exponential",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "commander": "^12.0.0",
+    "exponential-sdk": "^1.0.0",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist"
+  ]
+}