@tightknitai/cli 0.1.0-alpha.0

package/src/core/types.ts

@@ -0,0 +1,79 @@
+import { z } from "zod";
+
+/** Schema for a calendar event returned by the Tightknit API */
+export const CalendarEventSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  description: z.unknown().nullable().optional(),
+  start_date: z.string(),
+  end_date: z.string(),
+  location: z.string().nullable().optional(),
+  link: z.string().nullable().optional(),
+  slug: z.string().nullable().optional(),
+  status: z.string().optional(),
+  publish_to_site: z.boolean().optional(),
+  is_unlisted: z.boolean().optional(),
+  attendees_count: z.number().optional(),
+  created_at: z.string().optional(),
+  updated_at: z.string().optional(),
+});
+
+export type CalendarEvent = z.infer<typeof CalendarEventSchema>;
+
+/** Schema for a paginated list response */
+export const PaginatedResponseSchema = <T extends z.ZodTypeAny>(itemSchema: T) =>
+  z.object({
+    data: z.array(itemSchema),
+    page: z.number().optional(),
+    per_page: z.number().optional(),
+  });
+
+/** Schema for a feed */
+export const FeedSchema = z.object({
+  id: z.string(),
+  name: z.string().optional(),
+  slug: z.string().optional(),
+  is_unlisted: z.boolean().optional(),
+  is_archived: z.boolean().optional(),
+});
+
+export type Feed = z.infer<typeof FeedSchema>;
+
+/** Schema for a post */
+export const PostSchema = z.object({
+  id: z.string(),
+  title: z.string().nullable().optional(),
+  body: z.unknown().nullable().optional(),
+  author: z.unknown().nullable().optional(),
+  created_at: z.string().optional(),
+  updated_at: z.string().optional(),
+});
+
+export type Post = z.infer<typeof PostSchema>;
+
+/** Schema for a community member */
+export const MemberSchema = z.object({
+  id: z.string(),
+  full_name: z.string().nullable().optional(),
+  email: z.string().nullable().optional(),
+  avatar_url_original: z.string().nullable().optional(),
+  created_at: z.string().optional(),
+});
+
+export type Member = z.infer<typeof MemberSchema>;
+
+/** User identifier — one of slack_user_id, email, or profile_id */
+export const UserIdentifierSchema = z.union([
+  z.object({ slack_user_id: z.string() }),
+  z.object({ email: z.string() }),
+  z.object({ profile_id: z.string() }),
+]);
+
+export type UserIdentifier = z.infer<typeof UserIdentifierSchema>;
+
+/** Structured API error */
+export interface ApiError {
+  error: true;
+  code: number;
+  message: string;
+}

package/src/mcp/server.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env tsx
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerTools } from "./tools";
+
+const server = new McpServer({
+  name: "tightknit",
+  version: "0.1.0-alpha.0",
+});
+
+registerTools(server);
+
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/src/mcp/tools.ts

@@ -0,0 +1,275 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import {
+  listEvents,
+  getEvent,
+  createEvent,
+  deleteEvent,
+  updateAttendee,
+  assignAward,
+  listFeeds,
+  getFeed,
+  listPostsInFeed,
+  getPost,
+  addMember,
+  checkMembership,
+  sendMessage,
+  addUserToGroup,
+  search,
+} from "../core/client";
+import { getConfigValue, setConfigValue } from "../core/config";
+
+const UserIdentifierSchema = z.union([
+  z.object({ slack_user_id: z.string() }),
+  z.object({ email: z.string() }),
+  z.object({ profile_id: z.string() }),
+]);
+
+/** Register all Tightknit tools on the MCP server */
+export function registerTools(server: McpServer): void {
+  // --- Calendar Events ---
+
+  server.tool(
+    "tightknit_events_list",
+    "List calendar events with pagination and filters",
+    {
+      page: z.number().optional().describe("Page number (0-indexed)"),
+      per_page: z.number().optional().describe("Records per page"),
+      time_filter: z.enum(["upcoming", "past"]).optional().describe("Filter by upcoming or past"),
+      status: z.enum(["draft", "needs_approval", "published"]).optional().describe("Filter by status"),
+      feed_id: z.string().optional().describe("Filter by feed ID"),
+      tag_ids: z.string().optional().describe("Comma-separated tag UUIDs"),
+    },
+    async (params) => {
+      const result = await listEvents(params);
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    "tightknit_events_get",
+    "Retrieve a calendar event by ID",
+    { id: z.string().describe("Calendar event ID") },
+    async ({ id }) => {
+      const result = await getEvent(id);
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    "tightknit_events_create",
+    "Create a new calendar event",
+    {
+      title: z.string().describe("Event title (3-70 chars)"),
+      description: z.string().describe("Event description"),
+      start_date: z.string().describe("Start date/time (ISO 8601)"),
+      end_date: z.string().describe("End date/time (ISO 8601)"),
+      location: z.string().optional().describe("Event location"),
+      link: z.string().optional().describe("Event link/URL"),
+      slug: z.string().optional().describe("URL slug"),
+      status: z.enum(["needs_approval", "published"]).optional().describe("Event status"),
+      publish_to_site: z.boolean().optional().describe("Publish to companion site"),
+      enable_registration_button: z.boolean().optional().describe("Enable registration button"),
+      triggers_webhooks: z.boolean().optional().describe("Trigger webhooks"),
+    },
+    async (input) => {
+      const result = await createEvent(input);
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    "tightknit_events_delete",
+    "Delete a calendar event by ID",
+    { id: z.string().describe("Calendar event ID") },
+    async ({ id }) => {
+      await deleteEvent(id);
+      return { content: [{ type: "text" as const, text: JSON.stringify({ success: true }, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    "tightknit_events_update_attendee",
+    "Update a calendar event attendee",
+    {
+      event_id: z.string().describe("Calendar event ID"),
+      user: UserIdentifierSchema.describe("User identifier (email, slack_user_id, or profile_id)"),
+      personal_join_link: z.string().optional().describe("Personal join link for the attendee"),
+    },
+    async ({ event_id, user, personal_join_link }) => {
+      const result = await updateAttendee(event_id, { user, personal_join_link });
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+
+  // --- Awards ---
+
+  server.tool(
+    "tightknit_awards_assign",
+    "Assign an award to a user and send a Slack notification",
+    {
+      award_id: z.string().describe("Award UUID"),
+      recipient: UserIdentifierSchema.describe("Recipient user identifier"),
+      sender: UserIdentifierSchema.optional().describe("Sender user identifier"),
+      send_anonymously: z.boolean().optional().describe("Send anonymously"),
+    },
+    async ({ award_id, recipient, sender, send_anonymously }) => {
+      const result = await assignAward(award_id, { recipient, sender, send_anonymously });
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+
+  // --- Feeds ---
+
+  server.tool(
+    "tightknit_feeds_list",
+    "List feeds with pagination",
+    {
+      page: z.number().optional().describe("Page number (0-indexed)"),
+      per_page: z.number().optional().describe("Records per page"),
+      is_unlisted: z.boolean().optional().describe("Filter to unlisted feeds"),
+      is_archived: z.boolean().optional().describe("Filter to archived feeds"),
+    },
+    async (params) => {
+      const result = await listFeeds(params);
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    "tightknit_feeds_get",
+    "Retrieve a feed by ID",
+    { feed_id: z.string().describe("Feed ID") },
+    async ({ feed_id }) => {
+      const result = await getFeed(feed_id);
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    "tightknit_feeds_posts",
+    "List posts in a feed",
+    {
+      feed_id: z.string().describe('Feed ID or "home" for the Home feed'),
+      page: z.number().optional().describe("Page number (0-indexed)"),
+      per_page: z.number().optional().describe("Records per page"),
+      sort: z.enum(["oldest", "newest", "most-recent-activity"]).optional().describe("Sort method"),
+    },
+    async ({ feed_id, ...params }) => {
+      const result = await listPostsInFeed(feed_id, params);
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+
+  // --- Posts ---
+
+  server.tool(
+    "tightknit_posts_get",
+    "Retrieve a post by ID",
+    { post_id: z.string().describe("Post ID") },
+    async ({ post_id }) => {
+      const result = await getPost(post_id);
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+
+  // --- Members ---
+
+  server.tool(
+    "tightknit_members_add",
+    "Add a member to the community (Enterprise plan required)",
+    {
+      email: z.string().describe("Member email address"),
+      full_name: z.string().describe("Member full name"),
+      avatar_url_original: z.string().optional().describe("Avatar image URL"),
+    },
+    async (input) => {
+      const result = await addMember(input);
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    "tightknit_members_check",
+    "Check if an email is a community member",
+    { email: z.string().describe("Email address to check") },
+    async ({ email }) => {
+      const result = await checkMembership(email);
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+
+  // --- Messages ---
+
+  server.tool(
+    "tightknit_messages_send",
+    "Send a Slack message to a channel or user",
+    {
+      channel: z.string().describe("Slack channel ID or user ID"),
+      text: z.string().describe("Message text (plain text or Slack mrkdwn)"),
+      thread_ts: z.string().optional().describe("Thread timestamp to reply to"),
+    },
+    async (input) => {
+      const result = await sendMessage(input);
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+
+  // --- Groups ---
+
+  server.tool(
+    "tightknit_groups_add_member",
+    "Add a user to a group",
+    {
+      group_id: z.string().describe("Group ID"),
+      user: UserIdentifierSchema.describe("User identifier"),
+    },
+    async ({ group_id, user }) => {
+      const result = await addUserToGroup(group_id, { user });
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+
+  // --- Search ---
+
+  server.tool(
+    "tightknit_search",
+    "[Beta] Search documents by query",
+    {
+      q: z.string().describe("Search query string"),
+      type: z.enum(["post", "comment", "content_resource"]).describe("Entity type to search"),
+      page: z.number().optional().describe("Page number (0-indexed)"),
+      per_page: z.number().optional().describe("Records per page"),
+    },
+    async (params) => {
+      const result = await search(params);
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+
+  // --- Config ---
+
+  server.tool(
+    "tightknit_config_get",
+    "Get a CLI configuration value",
+    { key: z.string().describe("Config key (api-key, community-id, default-output)") },
+    async ({ key }) => {
+      const value = getConfigValue(key);
+      const displayValue = key === "api-key" && value ? `${value.slice(0, 8)}...` : value;
+      return { content: [{ type: "text" as const, text: JSON.stringify({ key, value: displayValue }, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    "tightknit_config_set",
+    "Set a CLI configuration value",
+    {
+      key: z.string().describe("Config key (api-key, community-id, default-output)"),
+      value: z.string().describe("Config value"),
+    },
+    async ({ key, value }) => {
+      setConfigValue(key, value);
+      return { content: [{ type: "text" as const, text: JSON.stringify({ success: true, key, value: key === "api-key" ? "***" : value }, null, 2) }] };
+    }
+  );
+}