exponential-mcp 0.5.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;
@@ -106,6 +107,49 @@ function parseDateArg(raw) {
     }
     return parsed;
 }
+const SUMMARY_PREVIEW_CHARS = 400;
+const DEFAULT_MEETING_LIMIT = 30;
+/**
+ * A meeting row as it comes off the list read is ~3k characters of metadata
+ * plus the full transcript, summary and notes bodies — a single hour-long
+ * transcript is easily 50k+ characters, and the server offers no limit or
+ * projection. The list tool sends a compact row with a summary preview; the
+ * detail tool sends everything except the transcript unless asked.
+ */
+function meetingListRow(m) {
+    const summary = m.summary ?? null;
+    const truncated = summary !== null && summary.length > SUMMARY_PREVIEW_CHARS;
+    return {
+        id: m.id,
+        title: m.title,
+        description: m.description,
+        meetingDate: m.meetingDate,
+        createdAt: m.createdAt,
+        durationSeconds: m.durationSeconds ?? null,
+        participantCount: m.participantCount ?? null,
+        projectId: m.projectId,
+        project: m.project ?? null,
+        workspaceId: m.workspaceId,
+        archivedAt: m.archivedAt,
+        source: m.sourceIntegration?.provider ?? null,
+        participants: (m.participants ?? []).map((p) => ({ id: p.id, name: p.name, email: p.email })),
+        actions: m.actions ?? [],
+        summaryPreview: truncated ? summary.slice(0, SUMMARY_PREVIEW_CHARS) + '…' : summary,
+        summaryTruncated: truncated,
+        hasNotes: Boolean(m.notes),
+        hasTranscript: Boolean(m.transcription),
+    };
+}
+function meetingDetail(m, includeTranscript) {
+    // sentencesJson / analyticsJson are the server's internal processing
+    // artefacts; they are not part of the SDK type and never useful to a model.
+    const { transcription, sentencesJson, analyticsJson, ...rest } = m;
+    return {
+        ...rest,
+        hasTranscript: Boolean(transcription),
+        ...(includeTranscript ? { transcription } : {}),
+    };
+}
 // Tool definitions
 const TOOLS = [
     {
@@ -121,6 +165,64 @@ const TOOLS = [
             }
         }
     },
+    {
+        name: 'get_project',
+        description: 'Fetch one project with its relations: the objectives and key results it is linked to, DRI, team, dates, description, and linked meetings. get_projects returns none of the OKR links, so this is the tool for "what is this project driving?". It does NOT include the project\'s tasks — use get_actions with projectId for those. Accepts a project ID, a slug, or the slug-id form from app URLs.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: {
+                    type: 'string',
+                    description: 'Project ID, slug, or the compound slug-id from an app URL'
+                }
+            },
+            required: ['id']
+        }
+    },
+    {
+        name: 'update_project',
+        description: 'Update a project: rename, change status or priority, edit the description, set dates, or re-link it to objectives / key results. Only the fields you pass are changed. goalIds and keyResultIds REPLACE the existing links wholesale — read get_project first and pass the full set you want to keep. An empty keyResultIds clears the key-result links; an empty goalIds is ignored by the server.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Project ID' },
+                name: { type: 'string', description: 'New name' },
+                description: {
+                    type: 'string',
+                    description: 'New description. Pass an empty string to blank it.'
+                },
+                status: {
+                    type: 'string',
+                    enum: ['ACTIVE', 'ON_HOLD', 'COMPLETED', 'CANCELLED'],
+                    description: 'New lifecycle status'
+                },
+                priority: {
+                    type: 'string',
+                    enum: ['HIGH', 'MEDIUM', 'LOW', 'NONE'],
+                    description: 'New priority'
+                },
+                driId: {
+                    type: 'string',
+                    description: 'User ID of the directly responsible individual, or null to clear'
+                },
+                goalIds: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Objective IDs (integers, passed as strings) to link — replaces the current set'
+                },
+                keyResultIds: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Key result IDs to link — replaces the current set; [] clears'
+                },
+                startDate: { type: 'string', description: 'ISO datetime, or null to clear' },
+                endDate: { type: 'string', description: 'ISO datetime, or null to clear' },
+                reviewDate: { type: 'string', description: 'ISO datetime, or null to clear' },
+                nextActionDate: { type: 'string', description: 'ISO datetime, or null to clear' }
+            },
+            required: ['id']
+        }
+    },
     {
         name: 'get_actions',
         description: 'List actions/tasks, optionally filtered by project or status. This is a flat list with no date filtering — to answer "what should I work on today" or "what am I behind on", use get_todays_actions instead.',
@@ -312,6 +414,114 @@ const TOOLS = [
             }
         }
     },
+    {
+        name: 'get_meetings',
+        description: 'List meetings the user can see — ones they own or attended, plus those on their projects and workspaces — newest first. Each row has metadata, participants, linked actions and a short preview of the AI summary; the full summary, notes and transcript are only in get_meeting. Use this to answer "when did I last meet Y" or to find a meeting ID, then get_meeting for what was actually said.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workspaceId: {
+                    type: 'string',
+                    description: 'Optional workspace ID to restrict to one workspace'
+                },
+                meetingType: {
+                    type: 'string',
+                    enum: ['all', 'mine', 'one_on_one'],
+                    description: 'all (default) — everything visible; mine — meetings the user owns or attended; one_on_one — exactly two participants'
+                },
+                includeArchived: {
+                    type: 'boolean',
+                    description: 'Include archived meetings (default false)'
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Max meetings to return, newest first (default 30)'
+                }
+            }
+        }
+    },
+    {
+        name: 'get_meeting',
+        description: 'Fetch one meeting in full: participants with speaker labels, linked actions, the AI summary, and the meeting notes. The raw transcript is omitted unless includeTranscript is true — it can be tens of thousands of characters, so only pull it when the summary and notes are not enough.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Meeting ID' },
+                includeTranscript: {
+                    type: 'boolean',
+                    description: 'Also return the raw transcript text (default false)'
+                }
+            },
+            required: ['id']
+        }
+    },
+    {
+        name: 'create_meeting',
+        description: 'Record a meeting in Exponential from a transcript or notes the user gives you. transcription is required by the server — if the user only has notes, put the notes text there too. A project-linked meeting inherits its project\'s workspace.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                title: { type: 'string', description: 'Meeting title' },
+                transcription: {
+                    type: 'string',
+                    description: 'Raw transcript text (required, at least one character)'
+                },
+                notes: { type: 'string', description: 'Meeting notes (Markdown)' },
+                description: { type: 'string', description: 'Short description' },
+                meetingDate: {
+                    type: 'string',
+                    description: 'When the meeting happened, as an ISO datetime (defaults to now)'
+                },
+                projectId: { type: 'string', description: 'Link to this project' },
+                workspaceId: { type: 'string', description: 'Workspace ID (ignored when projectId is set)' },
+                participants: {
+                    type: 'array',
+                    description: 'Who attended. Each entry needs at least one of userId, contactId, or email.',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            userId: { type: 'string' },
+                            contactId: { type: 'string' },
+                            email: { type: 'string' },
+                            name: { type: 'string' }
+                        }
+                    }
+                }
+            },
+            required: ['title', 'transcription']
+        }
+    },
+    {
+        name: 'update_meeting',
+        description: 'Edit a meeting\'s title, description, summary, date, or REPLACE its notes wholesale. To add to existing notes without rewriting them, use append_meeting_notes instead. Only the fields you pass are changed.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Meeting ID' },
+                title: { type: 'string', description: 'New title' },
+                description: { type: 'string', description: 'New description' },
+                summary: { type: 'string', description: 'New summary' },
+                notes: { type: 'string', description: 'Replacement notes body (Markdown)' },
+                meetingDate: {
+                    type: 'string',
+                    description: 'When the meeting happened, as an ISO datetime, or null to clear'
+                }
+            },
+            required: ['id']
+        }
+    },
+    {
+        name: 'append_meeting_notes',
+        description: 'Append a block of text to a meeting\'s notes, separated by a blank line, creating the notes if there are none yet. This is the safe way to add a follow-up, decision, or action list to a meeting without clobbering what is already there.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Meeting ID' },
+                text: { type: 'string', description: 'Text to append (Markdown)' }
+            },
+            required: ['id', 'text']
+        }
+    },
     {
         name: 'search',
         description: "Global text search across everything the user can access — projects, actions/tasks, goals, workspaces (and more entity types as the API grows). Same coverage as the app's Cmd+K palette. Returns typed results with ids, workspace, and app URL.",
@@ -360,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({
@@ -380,6 +602,45 @@ async function main() {
                         ],
                     };
                 }
+                case 'get_project': {
+                    const project = await client.projects.get(args?.id);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(project, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case 'update_project': {
+                    // `null` clears driId; the string "null" is the JSON-as-text form the
+                    // model sometimes emits, same as parseDateArg handles for dates.
+                    const rawDri = args?.driId;
+                    const driId = rawDri === undefined ? undefined : rawDri === null || rawDri === 'null' ? null : rawDri;
+                    const project = await client.projects.update({
+                        id: args?.id,
+                        name: args?.name,
+                        description: args?.description,
+                        status: args?.status,
+                        priority: args?.priority,
+                        driId,
+                        goalIds: args?.goalIds,
+                        keyResultIds: args?.keyResultIds,
+                        startDate: parseDateArg(args?.startDate),
+                        endDate: parseDateArg(args?.endDate),
+                        reviewDate: parseDateArg(args?.reviewDate),
+                        nextActionDate: parseDateArg(args?.nextActionDate),
+                    });
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `Updated project: ${project.name} (ID: ${project.id})`,
+                            },
+                        ],
+                    };
+                }
                 case 'get_actions': {
                     const status = args?.status;
                     const projectId = args?.projectId;
@@ -546,8 +807,90 @@ async function main() {
                         ],
                     };
                 }
+                case 'get_meetings': {
+                    const meetings = await client.meetings.list({
+                        workspaceId: args?.workspaceId,
+                        meetingType: args?.meetingType,
+                        includeArchived: args?.includeArchived,
+                    });
+                    const limit = Math.max(1, Number(args?.limit) || DEFAULT_MEETING_LIMIT);
+                    const when = (m) => new Date(m.meetingDate ?? m.createdAt).getTime();
+                    const rows = [...meetings]
+                        .sort((a, b) => when(b) - when(a))
+                        .slice(0, limit)
+                        .map(meetingListRow);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({ total: meetings.length, returned: rows.length, meetings: rows }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                case 'get_meeting': {
+                    const meeting = await client.meetings.get(args?.id);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(meetingDetail(meeting, Boolean(args?.includeTranscript)), null, 2),
+                            },
+                        ],
+                    };
+                }
+                case 'create_meeting': {
+                    const meetingDate = parseDateArg(args?.meetingDate);
+                    const meeting = await client.meetings.create({
+                        title: args?.title,
+                        transcription: args?.transcription,
+                        notes: args?.notes,
+                        description: args?.description,
+                        meetingDate: meetingDate ?? undefined,
+                        projectId: args?.projectId,
+                        workspaceId: args?.workspaceId,
+                        participants: args?.participants,
+                    });
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `Created meeting: ${meeting.title ?? '(untitled)'} (ID: ${meeting.id})`,
+                            },
+                        ],
+                    };
+                }
+                case 'update_meeting': {
+                    const meeting = await client.meetings.update({
+                        id: args?.id,
+                        title: args?.title,
+                        description: args?.description,
+                        summary: args?.summary,
+                        notes: args?.notes,
+                        meetingDate: parseDateArg(args?.meetingDate),
+                    });
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `Updated meeting: ${meeting.title ?? '(untitled)'} (ID: ${meeting.id})`,
+                            },
+                        ],
+                    };
+                }
+                case 'append_meeting_notes': {
+                    const meeting = await client.meetings.appendNotes(args?.id, args?.text);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `Appended to notes of: ${meeting.title ?? '(untitled)'} (ID: ${meeting.id})`,
+                            },
+                        ],
+                    };
+                }
                 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.5.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.12.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",