@ezmodo/mcp-server 0.13.0

package/handlers/projects.js

@@ -0,0 +1,122 @@
+/**
+ * Project Handlers
+ * Handler functions for project-related MCP tools
+ */
+
+import { callZephlyAPI } from '../lib/http-client.js';
+
+/**
+ * Dispatch manage_project actions
+ */
+export async function manageProject(args) {
+  const { action, ...params } = args;
+  switch (action) {
+  case 'create': return createProject(params);
+  case 'update': return updateProject(params);
+  case 'generate_how_it_works': return generateProjectHowItWorks(params);
+  case 'apply_how_it_works': return applyProjectHowItWorks(params);
+  default: throw new Error(`Unknown action: ${action}`);
+  }
+}
+
+/**
+ * Unified get_project handler — by ID (context), search, or list all
+ */
+export async function getProject(args) {
+  const { projectId, query } = args;
+
+  // Mode 1: get project context by ID
+  if (projectId) {
+    return callZephlyAPI('mcpGetProjectContext', { projectId });
+  }
+
+  // Mode 2: search by query text, or list all
+  if (query || args.type || args.organizationId) {
+    return searchProjects(args);
+  }
+
+  // Mode 3: list all
+  return callZephlyAPI('mcpListProjects', {});
+}
+
+async function createProject(args) {
+  return callZephlyAPI('mcpCreateProject', args);
+}
+
+// Update an existing project. Only the fields present in `args` are changed —
+// the server leaves anything unmentioned alone. This is the path that lets an
+// agent set gitUrl/gitProvider after creation, which is what commit-to-task
+// linking and component link resolution key off.
+async function updateProject(args) {
+  return callZephlyAPI('mcpUpdateProject', args);
+}
+
+// Generate (and persist) the project's grounded "how it works" living description
+// via the model. AI-quota gated server-side (mirrors entities.generateGoalHowItWorks).
+async function generateProjectHowItWorks({ projectId }) {
+  return callZephlyAPI('mcpGenerateProjectHowItWorks', { projectId });
+}
+
+// Apply (persist) a LOCAL-agent-authored "how it works" for a project (BYO-AI,
+// E-190). Cited sources are validated server-side before saving; no model call.
+async function applyProjectHowItWorks({ projectId, markdown, sources }) {
+  return callZephlyAPI('mcpApplyProjectHowItWorks', { projectId, markdown, sources });
+}
+
+// Project Story (E-208): a grounded, source-attributed narrative of what has
+// happened to a project since it began. Returns a fresh cached story when
+// available, otherwise generates one (AI-quota gated server-side).
+export async function getProjectStory({ projectId, window, from, to }) {
+  return callZephlyAPI('mcpGetProjectStory', { projectId, window, from, to });
+}
+
+async function searchProjects(args) {
+  const {
+    query: searchText,
+    type,
+    organizationId,
+    limit = 50,
+  } = args;
+
+  try {
+    const allProjects = await callZephlyAPI('mcpListProjects', {});
+
+    // callZephlyAPI already unwrapped the {success, data} envelope, so what
+    // arrives is `{projects: [...]}` with no `success` flag. Testing for one
+    // sent every search down this branch and returned the whole unfiltered
+    // list -- a `query` that matched nothing was indistinguishable from one
+    // that matched everything.
+    if (!Array.isArray(allProjects?.projects)) {
+      return allProjects;
+    }
+
+    let filtered = allProjects.projects;
+
+    if (searchText) {
+      const searchLower = searchText.toLowerCase();
+      filtered = filtered.filter((project) =>
+        project.name.toLowerCase().includes(searchLower) ||
+        (project.description && project.description.toLowerCase().includes(searchLower))
+      );
+    }
+
+    if (type) {
+      filtered = filtered.filter((project) => project.type === type);
+    }
+
+    if (organizationId) {
+      filtered = filtered.filter((project) => project.organizationId === organizationId);
+    }
+
+    filtered = filtered.slice(0, limit);
+
+    return {
+      success: true,
+      projects: filtered,
+      count: filtered.length,
+      totalBeforeLimit: allProjects.projects.length,
+    };
+  } catch (error) {
+    throw new Error(`Failed to search projects: ${error.message}`);
+  }
+}

package/handlers/recurring-tasks.js

@@ -0,0 +1,33 @@
+/**
+ * Recurring Task Schedule Handlers
+ * Handler for the E-211 recurrence-engine MCP tool.
+ *
+ * Thin wrappers over /api/mcp/v1/recurring-tasks; validation, next_run_at
+ * computation, and the schedule lifecycle happen server-side in
+ * core/recurringtasks.Service.
+ */
+
+import { callZephlyAPI } from '../lib/http-client.js';
+
+/**
+ * Dispatch manage_recurring_task actions.
+ */
+export async function manageRecurringTask(args) {
+  const { action, ...params } = args;
+  switch (action) {
+  case 'create': return callZephlyAPI('mcpCreateRecurringTask', params);
+  case 'update': return callZephlyAPI('mcpUpdateRecurringTask', params);
+  case 'pause': return callZephlyAPI('mcpPauseRecurringTask', { scheduleId: params.scheduleId });
+  case 'resume': return callZephlyAPI('mcpResumeRecurringTask', { scheduleId: params.scheduleId });
+  case 'delete': return callZephlyAPI('mcpDeleteRecurringTask', { scheduleId: params.scheduleId });
+  case 'get': return callZephlyAPI('mcpGetRecurringTask', { scheduleId: params.scheduleId });
+  case 'list': {
+    const listParams = {};
+    if (params.organizationId) listParams.organizationId = params.organizationId;
+    if (params.projectId) listParams.projectId = params.projectId;
+    return callZephlyAPI('mcpListRecurringTasks', listParams);
+  }
+  default:
+    throw new Error(`Unknown action: ${action}. Expected create, update, pause, resume, delete, list, or get.`);
+  }
+}

package/handlers/tags.js

@@ -0,0 +1,124 @@
+/**
+ * Tag Handlers
+ * Handler functions for tag operations
+ *
+ * Consolidated: manageTag dispatches create/update/delete/merge/bulk_tag.
+ * listTags unifies get/list/findEntities/suggest.
+ *
+ * list_tags uses local cache for unfiltered requests, falling back to API.
+ * Write operations (create, update, delete, merge) invalidate the cache.
+ */
+
+import { callZephlyAPI } from '../lib/http-client.js';
+import { getCachedTags, updateCacheSections, invalidateCacheSection } from '../lib/local-cache.js';
+
+/**
+ * Dispatch manage_tag actions to the appropriate handler
+ */
+export async function manageTag(args) {
+  const { action, ...params } = args;
+  switch (action) {
+  case 'create': return createTag(params);
+  case 'update': return updateTag(params);
+  case 'delete': return deleteTag(params);
+  case 'merge': return mergeTags(params);
+  case 'bulk_tag': return bulkTagEntities(params);
+  default: throw new Error(`Unknown action: ${action}`);
+  }
+}
+
+/**
+ * Unified list/get/find/suggest handler for tags
+ */
+export async function listTags(args) {
+  // Strip routing flags before passing to helpers
+  const { suggest, findEntities, ...params } = args;
+
+  // Mode 1: suggest tags
+  if (suggest) {
+    return suggestTags(params);
+  }
+
+  // Mode 2: find entities by tags
+  if (findEntities) {
+    return findEntitiesByTags(params);
+  }
+
+  // Mode 3: single tag lookup by ID or name
+  if (params.tagId || params.name) {
+    return getTag(params);
+  }
+
+  // Mode 4: list tags with optional filters
+  return listTagsFiltered(params);
+}
+
+// --- Private helpers ---
+
+async function createTag(args) {
+  const result = await callZephlyAPI('mcpCreateTag', args);
+  await invalidateCacheSection('tags');
+  return result;
+}
+
+async function updateTag(args) {
+  const result = await callZephlyAPI('mcpUpdateTag', args);
+  await invalidateCacheSection('tags');
+  return result;
+}
+
+async function deleteTag(args) {
+  const result = await callZephlyAPI('mcpDeleteTag', args);
+  await invalidateCacheSection('tags');
+  return result;
+}
+
+async function mergeTags(args) {
+  const result = await callZephlyAPI('mcpMergeTags', args);
+  await invalidateCacheSection('tags');
+  return result;
+}
+
+async function bulkTagEntities(args) {
+  return callZephlyAPI('mcpBulkTagEntities', args);
+}
+
+async function getTag(args) {
+  return callZephlyAPI('mcpGetTag', args);
+}
+
+async function listTagsFiltered(args) {
+  const hasFilters = args.category || args.searchQuery || args.pinnedOnly || args.includeHidden || args.projectId;
+
+  if (!hasFilters) {
+    const cached = await getCachedTags();
+    if (cached !== null) {
+      return { tags: cached, cached: true };
+    }
+  }
+
+  // Call API
+  const result = await callZephlyAPI('mcpListTags', args);
+
+  // Cache unfiltered results for future use
+  if (!hasFilters && result?.tags) {
+    const summaries = result.tags.map((t) => ({
+      id: t.id,
+      name: t.name,
+      color: t.color || '',
+      category: t.category || 'custom',
+      description: t.description || '',
+    }));
+    await updateCacheSections({ tags: summaries });
+  }
+
+  return result;
+}
+
+async function findEntitiesByTags(args) {
+  return callZephlyAPI('mcpFindEntitiesByTags', args);
+}
+
+async function suggestTags(args) {
+  return callZephlyAPI('mcpSuggestTags', args);
+}