exponential-mcp 0.6.0 → 0.7.0

package/dist/domains/tickets.js

@@ -0,0 +1,135 @@
+import { z } from 'zod';
+import { id, op } from './framework.js';
+const TICKET_STATUSES = [
+    'BACKLOG',
+    'NEEDS_REFINEMENT',
+    'READY_TO_PLAN',
+    'COMMITTED',
+    'IN_PROGRESS',
+    'BLOCKED',
+    'QA',
+    'DONE',
+    'DEPLOYED',
+    'ARCHIVED',
+];
+const TICKET_TYPES = ['BUG', 'FEATURE', 'CHORE', 'IMPROVEMENT', 'SPIKE', 'RESEARCH'];
+const ticketId = z.string().describe('Ticket ID (the CUID, not the shortId or number — find it with `search`)');
+const url = (what) => z.string().url().max(500).describe(`${what} URL`);
+const clearable = (schema, what) => schema.nullable().optional().describe(`${what} (null to clear)`);
+export const tickets = {
+    name: 'tickets',
+    description: 'Tickets: the unit of work in a product backlog, with blocking dependencies and linked actions. Always product-scoped (see `products`); they can point at a feature (`features`), scope (`scopes`), epic (`epics`) and cycle. Ticket comments are in the `comments` tool and labels in `labels`.',
+    operations: {
+        list: op({
+            summary: 'List every ticket in one product with full fields (body included), optionally filtered. No workspace-wide query — call once per product. prUrl/branchName are exact-match filters applied after the fetch.',
+            params: z.object({
+                productId: id('Product'),
+                status: z.enum(TICKET_STATUSES).optional(),
+                type: z.enum(TICKET_TYPES).optional(),
+                featureId: id('Feature').optional(),
+                epicId: id('Epic').optional(),
+                cycleId: id('Cycle').optional(),
+                assigneeId: id('User').optional(),
+                prUrl: z.string().optional().describe('Exact match on the ticket’s PR URL'),
+                branchName: z.string().optional().describe('Exact match on the ticket’s branch name'),
+            }),
+            run: (client, params) => client.tickets.list(params),
+        }),
+        get: op({
+            summary: 'Get one ticket in full: body, product, dependencies (dependsOn / requiredFor), linked actions and comments (newest first).',
+            params: z.object({ id: ticketId }),
+            run: (client, { id }) => client.tickets.get(id),
+        }),
+        create: op({
+            summary: 'Create a ticket in a product. Number and shortId are assigned server-side.',
+            params: z.object({
+                productId: id('Product'),
+                title: z.string().min(1).max(300),
+                body: z.string().optional().describe('Markdown body. Omit with templateId to start from the template’s body'),
+                type: z.enum(TICKET_TYPES).optional(),
+                status: z.enum(TICKET_STATUSES).optional(),
+                priority: z.number().int().min(0).max(4).optional().describe('0–4; lower is higher priority'),
+                points: z.number().optional(),
+                branchName: z.string().optional(),
+                prUrl: url('Pull request').optional(),
+                designUrl: url('Design').optional(),
+                specUrl: url('Spec').optional(),
+                links: z.record(z.string()).optional().describe('Extra named links, label → URL'),
+                epicId: id('Epic').optional(),
+                featureId: id('Feature').optional(),
+                cycleId: id('Cycle').optional(),
+                scopeId: id('Feature scope').optional(),
+                assigneeId: id('User').optional().describe('User ID; must be a member of the product’s workspace'),
+                templateId: id('Ticket template').optional(),
+            }),
+            run: (client, params) => client.tickets.create(params),
+        }),
+        update: op({
+            summary: 'Update a ticket. Only the fields you pass change.',
+            params: z.object({
+                id: ticketId,
+                title: z.string().min(1).max(300).optional(),
+                body: z.string().optional().describe('Markdown body; replaces the whole body'),
+                type: z.enum(TICKET_TYPES).optional(),
+                status: z.enum(TICKET_STATUSES).optional(),
+                priority: clearable(z.number().int().min(0).max(4), 'Priority 0–4, lower is higher'),
+                points: clearable(z.number(), 'Story points'),
+                branchName: clearable(z.string(), 'Branch name'),
+                prUrl: clearable(z.string().url().max(500), 'Pull request URL'),
+                designUrl: clearable(z.string().url().max(500), 'Design URL'),
+                specUrl: clearable(z.string().url().max(500), 'Spec URL'),
+                links: clearable(z.record(z.string()), 'Named links, label → URL; replaces the whole map'),
+                epicId: clearable(z.string(), 'Epic ID'),
+                featureId: clearable(z.string(), 'Feature ID'),
+                cycleId: clearable(z.string(), 'Cycle ID'),
+                scopeId: clearable(z.string(), 'Feature scope ID'),
+                assigneeId: clearable(z.string(), 'Assignee user ID'),
+            }),
+            run: (client, params) => client.tickets.update(params),
+        }),
+        delete: op({
+            summary: 'Delete a ticket permanently, with its comments and dependency edges. Linked actions are kept but unlinked.',
+            params: z.object({ id: ticketId }),
+            run: (client, { id }) => client.tickets.delete(id),
+        }),
+        search: op({
+            summary: 'Quick picker search within one product: matches title, shortId or ticket number and returns slim rows (id, number, shortId, title, status, priority, assignee), most recently updated first. Use `list` for full tickets or field filters.',
+            params: z.object({
+                productId: id('Product'),
+                query: z.string().max(200).optional().describe('Title substring, shortId, or a bare ticket number'),
+                excludeTicketId: id('Ticket to leave out of the results').optional(),
+                limit: z.number().int().min(1).max(50).optional().describe('Default 20'),
+            }),
+            run: (client, params) => client.tickets.search(params),
+        }),
+        add_dependency: op({
+            summary: 'Mark ticketId as blocked by dependsOnId. Both must be in the same product; rejects self-dependencies and cycles. Idempotent.',
+            params: z.object({
+                ticketId: id('Blocked ticket'),
+                dependsOnId: id('Blocking ticket'),
+            }),
+            run: (client, { ticketId, dependsOnId }) => client.tickets.addDependency(ticketId, dependsOnId),
+        }),
+        remove_dependency: op({
+            summary: 'Remove a "ticketId is blocked by dependsOnId" edge. Succeeds even if no such edge exists.',
+            params: z.object({
+                ticketId: id('Blocked ticket'),
+                dependsOnId: id('Blocking ticket'),
+            }),
+            run: (client, { ticketId, dependsOnId }) => client.tickets.removeDependency(ticketId, dependsOnId),
+        }),
+        link_action: op({
+            summary: 'Attach one of your own actions to a ticket (an action belongs to at most one ticket, so this moves it if already linked).',
+            params: z.object({
+                ticketId: id('Ticket'),
+                actionId: id('Action'),
+            }),
+            run: (client, { ticketId, actionId }) => client.tickets.linkAction(ticketId, actionId),
+        }),
+        unlink_action: op({
+            summary: 'Detach one of your own actions from whatever ticket it is linked to.',
+            params: z.object({ actionId: id('Action') }),
+            run: (client, { actionId }) => client.tickets.unlinkAction(actionId),
+        }),
+    },
+};

package/dist/domains/time.d.ts

@@ -0,0 +1,2 @@
+import { type Domain } from './framework.js';
+export declare const time: Domain;

package/dist/domains/time.js

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import { date, id, op } from './framework.js';
+const TIME_ENTRY_STATUSES = ['PROPOSED', 'CONFIRMED'];
+const WRITABLE_SOURCES = ['manual', 'claude-desktop', 'agent-run'];
+const day = z
+    .string()
+    .describe("Calendar day as YYYY-MM-DD (or an ISO timestamp); resolved to local midnight in the MCP server's timezone");
+const optionalWorkspaceId = z
+    .string()
+    .optional()
+    .describe('Workspace ID (see the `workspaces` tool); omit for all workspaces');
+const entryFields = {
+    actionId: id('Action'),
+    startedAt: date('Start'),
+    endedAt: date('End (must be after startedAt)'),
+    source: z
+        .enum(WRITABLE_SOURCES)
+        .optional()
+        .describe('Defaults to manual. claude-desktop = Daily worklog proposed time; agent-run = unattended agent time'),
+    status: z
+        .enum(TIME_ENTRY_STATUSES)
+        .optional()
+        .describe('Defaults to CONFIRMED for a human; ignored (always PROPOSED) under an agent key'),
+    sourceRef: z
+        .string()
+        .optional()
+        .describe('Idempotency key, e.g. `claude-session:<sessionId>#<segmentIndex>`; makes the write an upsert'),
+    note: z.string().max(1000).optional().describe('One line shown in the day view'),
+};
+const partialEntry = z.object(entryFields).partial();
+export const time = {
+    name: 'time',
+    description: 'Time entries logged against actions (the Daily worklog write path). An entry always belongs to the person whose time it was: under an agent key it is owned by the agent’s owner and forced to PROPOSED until they confirm the day. Actions live in the `actions` tool.',
+    operations: {
+        log: op({
+            summary: 'Log one completed entry with explicit bounds; never touches the running Timer. With sourceRef it upserts per owner (updates a PROPOSED entry, leaves a CONFIRMED one); without, every call creates a row. Outcome: created / updated / left / merged / dropped.',
+            params: z.object(entryFields),
+            run: (client, params) => client.time.log(params),
+        }),
+        log_batch: op({
+            summary: 'Log many entries in order, one call each; a failure is reported per entry ({ index, success, error }) instead of failing the batch. `defaults` fill fields an entry omits.',
+            params: z.object({
+                entries: z.array(partialEntry).describe('Entries; each needs actionId, startedAt, endedAt after defaults apply'),
+                defaults: partialEntry.optional(),
+            }),
+            run: (client, { entries, defaults }) => client.time.logBatch(entries, defaults),
+        }),
+        confirm_day: op({
+            summary: 'Flip every PROPOSED entry of yours starting on that day to CONFIRMED, moving the actions’ spent time. Human only — agent keys are FORBIDDEN. Returns { confirmed }.',
+            params: z.object({ date: day, workspaceId: optionalWorkspaceId }),
+            run: (client, { date, workspaceId }) => client.time.confirmDay(date, workspaceId),
+        }),
+        day_report: op({
+            summary: 'One day’s time as the /time Day tab shows it: entries joined to action/ticket/project/product, attention vs session vs agent-run minutes, per-product and per-action roll-ups. Under an agent key it is the owner’s day.',
+            params: z.object({ date: day, workspaceId: optionalWorkspaceId }),
+            run: (client, { date, workspaceId }) => client.time.dayReport(date, workspaceId),
+        }),
+        list: op({
+            summary: 'Your raw time entries touching one day, oldest first, each with its status.',
+            params: z.object({ date: day, workspaceId: optionalWorkspaceId }),
+            run: (client, { date, workspaceId }) => client.time.list(date, workspaceId),
+        }),
+    },
+};

package/dist/domains/workspaces.d.ts

@@ -0,0 +1,2 @@
+import { type Domain } from './framework.js';
+export declare const workspaces: Domain;

package/dist/domains/workspaces.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { op, workspaceId } from './framework.js';
+export const workspaces = {
+    name: 'workspaces',
+    description: 'Workspaces the user belongs to, and their members. Most other tools take a workspaceId from here; use list_members to resolve people for mentions and assignment.',
+    operations: {
+        list: op({
+            summary: 'List the workspaces you belong to.',
+            params: z.object({}),
+            run: (client) => client.workspaces.list(),
+        }),
+        list_members: op({
+            summary: 'Everyone in a workspace — direct members plus those with access via a linked team. Each row carries `mentionSyntax` to paste into a comment body.',
+            params: z.object({ workspaceId }),
+            run: (client, { workspaceId }) => client.workspaces.listMembers(workspaceId),
+        }),
+    },
+};

package/dist/index.js

@@ -11,6 +11,7 @@ import { readFileSync, existsSync } from 'fs';
 import { homedir } from 'os';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
+import { DOMAINS, runDomainTool, toolDefinition } from './domains/index.js';
 const LEGACY_CONFIG_PATH = join(homedir(), '.config', 'exponential-mcp', 'config.json');
 // Report the real package version rather than a hand-maintained literal that drifts.
 const PKG_VERSION = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json'), 'utf-8')).version;
@@ -569,12 +570,24 @@ async function main() {
     });
     // List available tools
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
-        tools: TOOLS,
+        tools: [...TOOLS, ...[...DOMAINS.values()].map(toolDefinition)],
     }));
     // Handle tool calls
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const { name, arguments: args } = request.params;
         try {
+            const domain = DOMAINS.get(name);
+            if (domain) {
+                const result = await runDomainTool(domain, client, args);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
             switch (name) {
                 case 'get_projects': {
                     const projects = await client.projects.list({
@@ -877,7 +890,7 @@ async function main() {
                     };
                 }
                 case 'search': {
-                    const results = await trpcClient.search.global.query({
+                    const results = await client.search.global({
                         query: args?.query,
                         workspaceId: args?.workspaceId,
                         limit: args?.limit,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "exponential-mcp",
-  "version": "0.6.0",
-  "description": "MCP server for Exponential - connect Claude to your projects, actions, and goals",
+  "version": "0.7.0",
+  "description": "MCP server for Exponential - connect Claude to your projects, actions, goals, CRM, tickets and more",
   "main": "dist/index.js",
   "bin": {
     "exponential-mcp": "./dist/cli.js"
@@ -26,8 +26,9 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
     "commander": "^12.0.0",
-    "exponential-sdk": "^1.16.0",
-    "zod": "^3.22.0"
+    "exponential-sdk": "^1.20.1",
+    "zod": "^3.22.0",
+    "zod-to-json-schema": "^3.25.2"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",