veryfront 0.0.49 → 0.0.51

package/dist/integrations/mixpanel/files/ai/tools/get-retention.ts

@@ -0,0 +1,64 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getRetention } from "../../lib/mixpanel-client.ts";
+
+export default tool({
+  id: "get-retention",
+  description:
+    "Analyze user retention cohorts in Mixpanel. Understand how many users return after performing an initial event.",
+  inputSchema: z.object({
+    from: z.string().describe(
+      "Start date in YYYY-MM-DD format (e.g., '2024-01-01')",
+    ),
+    to: z.string().describe(
+      "End date in YYYY-MM-DD format (e.g., '2024-01-31')",
+    ),
+    event: z.string().describe(
+      "The event to analyze retention for (e.g., 'App Opened', 'Sign Up')",
+    ),
+    retentionType: z.enum(["birth", "compounded"]).optional().default("birth")
+      .describe(
+        "Retention type: 'birth' (first time users) or 'compounded' (all users who did the event)",
+      ),
+  }),
+  async execute({ from, to, event, retentionType }) {
+    const retention = await getRetention(from, to, event, retentionType);
+
+    return {
+      event,
+      retentionType,
+      dateRange: {
+        from,
+        to,
+      },
+      cohorts: retention.map((cohort) => ({
+        date: cohort.date,
+        initialCount: cohort.count,
+        retention: cohort.retention.map((r) => ({
+          day: r.day,
+          count: r.count,
+          rate: `${(r.rate * 100).toFixed(2)}%`,
+        })),
+      })),
+      summary: {
+        totalCohorts: retention.length,
+        averageDay1Retention: retention.length > 0
+          ? `${(
+            retention.reduce((sum, c) => {
+              const day1 = c.retention.find((r) => r.day === 1);
+              return sum + (day1 ? day1.rate : 0);
+            }, 0) / retention.length * 100
+          ).toFixed(2)}%`
+          : "N/A",
+        averageDay7Retention: retention.length > 0
+          ? `${(
+            retention.reduce((sum, c) => {
+              const day7 = c.retention.find((r) => r.day === 7);
+              return sum + (day7 ? day7.rate : 0);
+            }, 0) / retention.length * 100
+          ).toFixed(2)}%`
+          : "N/A",
+      },
+    };
+  },
+});

package/dist/integrations/mixpanel/files/ai/tools/list-cohorts.ts

@@ -0,0 +1,46 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listCohorts } from "../../lib/mixpanel-client.ts";
+
+export default tool({
+  id: "list-cohorts",
+  description:
+    "List all user cohorts defined in your Mixpanel project. Cohorts are saved user segments based on properties or behaviors.",
+  inputSchema: z.object({
+    includeHidden: z.boolean().optional().default(false).describe(
+      "Include hidden cohorts in the results (defaults to false)",
+    ),
+  }),
+  async execute({ includeHidden }) {
+    const allCohorts = await listCohorts();
+
+    // Filter by visibility if needed
+    const cohorts = includeHidden
+      ? allCohorts
+      : allCohorts.filter((c) => c.is_visible);
+
+    return {
+      total: cohorts.length,
+      cohorts: cohorts.map((cohort) => ({
+        id: cohort.id,
+        name: cohort.name,
+        description: cohort.description,
+        count: cohort.count,
+        created: cohort.created,
+        isVisible: cohort.is_visible,
+        projectId: cohort.project_id,
+      })),
+      summary: {
+        totalUsers: cohorts.reduce((sum, c) => sum + c.count, 0),
+        largestCohort: cohorts.length > 0
+          ? cohorts.reduce((max, c) => (c.count > max.count ? c : max))
+            .name
+          : "N/A",
+        smallestCohort: cohorts.length > 0
+          ? cohorts.reduce((min, c) => (c.count < min.count ? c : min))
+            .name
+          : "N/A",
+      },
+    };
+  },
+});

package/dist/integrations/mixpanel/files/ai/tools/query-events.ts

@@ -0,0 +1,43 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { queryEvents, getDateRange } from "../../lib/mixpanel-client.ts";
+
+export default tool({
+  id: "query-events",
+  description:
+    "Query and export event data from Mixpanel. Retrieve events within a date range, optionally filtered by event name.",
+  inputSchema: z.object({
+    from: z.string().describe(
+      "Start date in YYYY-MM-DD format (e.g., '2024-01-01')",
+    ),
+    to: z.string().describe(
+      "End date in YYYY-MM-DD format (e.g., '2024-01-31')",
+    ),
+    event: z.string().optional().describe(
+      "Optional: Filter by specific event name (e.g., 'Page Viewed'). If not provided, returns all events.",
+    ),
+    limit: z.number().optional().default(100).describe(
+      "Maximum number of events to return (defaults to 100)",
+    ),
+  }),
+  async execute({ from, to, event, limit }) {
+    const events = await queryEvents(from, to, event);
+
+    // Limit results
+    const limitedEvents = events.slice(0, limit);
+
+    return {
+      total: events.length,
+      returned: limitedEvents.length,
+      dateRange: {
+        from,
+        to,
+      },
+      eventFilter: event || "all",
+      events: limitedEvents.map((e) => ({
+        event: e.event,
+        properties: e.properties,
+      })),
+    };
+  },
+});

package/dist/integrations/mixpanel/files/ai/tools/track-event.ts

@@ -0,0 +1,41 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { trackEvent } from "../../lib/mixpanel-client.ts";
+
+export default tool({
+  id: "track-event",
+  description:
+    "Track a custom event in Mixpanel. Capture user actions, page views, or any custom analytics event with properties.",
+  inputSchema: z.object({
+    event: z.string().describe(
+      "Event name (e.g., 'Button Clicked', 'Page Viewed', 'Purchase Completed')",
+    ),
+    distinctId: z.string().describe(
+      "Unique identifier for the user or session (e.g., user ID, email, or anonymous ID)",
+    ),
+    properties: z.record(z.unknown()).optional().describe(
+      "Additional properties to attach to the event (e.g., {product_id: '123', price: 29.99, category: 'electronics'})",
+    ),
+  }),
+  async execute({ event, distinctId, properties }) {
+    const result = await trackEvent(event, properties || {}, distinctId);
+
+    if (result.status === 1) {
+      return {
+        success: true,
+        event: {
+          name: event,
+          distinctId,
+          properties: properties || {},
+          timestamp: new Date().toISOString(),
+        },
+        message: "Event tracked successfully",
+      };
+    } else {
+      return {
+        success: false,
+        error: result.error || "Failed to track event",
+      };
+    }
+  },
+});

package/dist/integrations/mixpanel/files/lib/mixpanel-client.ts

@@ -0,0 +1,319 @@
+import { getProjectToken, getApiSecret, getProjectId } from "./token-store.ts";
+
+const MIXPANEL_API_BASE = "https://mixpanel.com/api";
+const MIXPANEL_TRACK_BASE = "https://api.mixpanel.com";
+const MIXPANEL_DATA_BASE = "https://data.mixpanel.com/api/2.0";
+
+// Types
+export interface MixpanelEvent {
+  event: string;
+  properties: Record<string, unknown>;
+}
+
+export interface MixpanelEventQuery {
+  event?: string;
+  from_date: string;
+  to_date: string;
+  where?: string;
+  limit?: number;
+}
+
+export interface MixpanelEventResult {
+  event: string;
+  properties: Record<string, unknown>;
+}
+
+export interface MixpanelFunnel {
+  funnel_id: number;
+  name: string;
+  steps: Array<{
+    event: string;
+    count: number;
+    avg_time: number | null;
+    overall_conv_ratio: number;
+    step_conv_ratio: number;
+  }>;
+  data: {
+    series: string[];
+    values: Record<string, number[]>;
+  };
+}
+
+export interface MixpanelRetention {
+  date: string;
+  count: number;
+  retention: Array<{
+    day: number;
+    count: number;
+    rate: number;
+  }>;
+}
+
+export interface MixpanelCohort {
+  id: number;
+  name: string;
+  description: string;
+  count: number;
+  created: string;
+  is_visible: boolean;
+  project_id: number;
+}
+
+interface MixpanelError {
+  error: string;
+  request: string;
+}
+
+// Helper function to create basic auth header
+function getAuthHeader(): string {
+  const apiSecret = getApiSecret();
+  if (!apiSecret) {
+    throw new Error(
+      "Not authenticated with Mixpanel. Please set MIXPANEL_API_SECRET.",
+    );
+  }
+  // Mixpanel uses Basic auth with API secret as username and empty password
+  const credentials = btoa(`${apiSecret}:`);
+  return `Basic ${credentials}`;
+}
+
+// Helper function for Mixpanel API calls with auth
+async function mixpanelFetch<T>(
+  baseUrl: string,
+  endpoint: string,
+  options: RequestInit & { params?: Record<string, string | number | boolean> } = {},
+): Promise<T> {
+  // Build URL with query parameters
+  let url = `${baseUrl}${endpoint}`;
+  if (options.params) {
+    const params = new URLSearchParams();
+    Object.entries(options.params).forEach(([key, value]) => {
+      params.append(key, String(value));
+    });
+    url += `?${params.toString()}`;
+  }
+
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    ...options.headers as Record<string, string>,
+  };
+
+  // Add auth header for data API calls
+  if (baseUrl === MIXPANEL_DATA_BASE || baseUrl === MIXPANEL_API_BASE) {
+    headers["Authorization"] = getAuthHeader();
+  }
+
+  const response = await fetch(url, {
+    ...options,
+    headers,
+  });
+
+  if (!response.ok) {
+    let errorMessage = `Mixpanel API error: ${response.status} ${response.statusText}`;
+    try {
+      const errorData = await response.json() as MixpanelError;
+      if (errorData.error) {
+        errorMessage = `Mixpanel API error: ${errorData.error}`;
+      }
+    } catch {
+      // If parsing JSON fails, use default error message
+    }
+    throw new Error(errorMessage);
+  }
+
+  const data = await response.json();
+  return data as T;
+}
+
+// Track event - uses ingestion API with project token
+export async function trackEvent(
+  event: string,
+  properties: Record<string, unknown>,
+  distinctId: string,
+): Promise<{ status: number; error?: string }> {
+  const projectToken = getProjectToken();
+  if (!projectToken) {
+    throw new Error(
+      "Not authenticated with Mixpanel. Please set MIXPANEL_PROJECT_TOKEN.",
+    );
+  }
+
+  const payload = {
+    event,
+    properties: {
+      ...properties,
+      token: projectToken,
+      distinct_id: distinctId,
+      time: Date.now(),
+    },
+  };
+
+  const response = await fetch(`${MIXPANEL_TRACK_BASE}/track`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify([payload]),
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    return {
+      status: 0,
+      error: `Failed to track event: ${response.status} ${text}`,
+    };
+  }
+
+  const result = await response.json() as { status: number; error?: string };
+  return result;
+}
+
+// Query events - uses export API
+export async function queryEvents(
+  from: string,
+  to: string,
+  event?: string,
+): Promise<MixpanelEventResult[]> {
+  const projectId = getProjectId();
+  if (!projectId) {
+    throw new Error("Project ID not set. Please set MIXPANEL_PROJECT_ID.");
+  }
+
+  const params: Record<string, string> = {
+    from_date: from,
+    to_date: to,
+  };
+
+  if (event) {
+    params.event = JSON.stringify([event]);
+  }
+
+  const response = await mixpanelFetch<string[]>(
+    MIXPANEL_DATA_BASE,
+    "/export",
+    { params },
+  );
+
+  // Parse JSONL response (each line is a JSON object)
+  const events: MixpanelEventResult[] = [];
+  if (Array.isArray(response)) {
+    for (const line of response) {
+      if (typeof line === "string" && line.trim()) {
+        try {
+          const parsed = JSON.parse(line);
+          events.push({
+            event: parsed.event,
+            properties: parsed.properties,
+          });
+        } catch {
+          // Skip malformed lines
+        }
+      }
+    }
+  }
+
+  return events;
+}
+
+// Get funnel data
+export async function getFunnel(
+  funnelId: number,
+  from: string,
+  to: string,
+): Promise<MixpanelFunnel> {
+  const params: Record<string, string | number> = {
+    funnel_id: funnelId,
+    from_date: from,
+    to_date: to,
+    unit: "day",
+  };
+
+  return mixpanelFetch<MixpanelFunnel>(
+    MIXPANEL_DATA_BASE,
+    "/funnels",
+    { params },
+  );
+}
+
+// Get retention data
+export async function getRetention(
+  from: string,
+  to: string,
+  event: string,
+  retentionType: "birth" | "compounded" = "birth",
+): Promise<MixpanelRetention[]> {
+  const params: Record<string, string> = {
+    from_date: from,
+    to_date: to,
+    retention_type: retentionType,
+    born_event: event,
+    event,
+    unit: "day",
+  };
+
+  const response = await mixpanelFetch<Record<string, MixpanelRetention>>(
+    MIXPANEL_DATA_BASE,
+    "/retention",
+    { params },
+  );
+
+  // Convert object to array
+  return Object.entries(response).map(([date, data]) => ({
+    date,
+    ...data,
+  }));
+}
+
+// List cohorts
+export async function listCohorts(): Promise<MixpanelCohort[]> {
+  const projectId = getProjectId();
+  if (!projectId) {
+    throw new Error("Project ID not set. Please set MIXPANEL_PROJECT_ID.");
+  }
+
+  const response = await mixpanelFetch<MixpanelCohort[]>(
+    MIXPANEL_API_BASE,
+    `/2.0/cohorts/list`,
+    {
+      params: {
+        project_id: projectId,
+      },
+    },
+  );
+
+  return response;
+}
+
+// Helper functions
+export function formatDate(date: Date): string {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+
+export function getDateRange(days: number): { from: string; to: string } {
+  const to = new Date();
+  const from = new Date();
+  from.setDate(from.getDate() - days);
+
+  return {
+    from: formatDate(from),
+    to: formatDate(to),
+  };
+}
+
+export function calculateFunnelConversionRate(funnel: MixpanelFunnel): number {
+  if (!funnel.steps || funnel.steps.length < 2) {
+    return 0;
+  }
+
+  const firstStep = funnel.steps[0];
+  const lastStep = funnel.steps[funnel.steps.length - 1];
+
+  if (!firstStep || !lastStep || firstStep.count === 0) {
+    return 0;
+  }
+
+  return (lastStep.count / firstStep.count) * 100;
+}

package/dist/integrations/monday/connector.json

@@ -0,0 +1,85 @@
+{
+  "name": "monday",
+  "displayName": "Monday.com",
+  "icon": "monday.svg",
+  "description": "Manage projects, tasks, and workflows in Monday.com",
+  "auth": {
+    "type": "oauth2",
+    "provider": "monday",
+    "authorizationUrl": "https://auth.monday.com/oauth2/authorize",
+    "tokenUrl": "https://auth.monday.com/oauth2/token",
+    "scopes": ["me:read", "boards:read", "boards:write"],
+    "callbackPath": "/api/auth/monday/callback",
+    "requiredApis": [
+      {
+        "name": "Monday.com Developers",
+        "enableUrl": "https://monday.com/developers/apps"
+      }
+    ]
+  },
+  "envVars": [
+    {
+      "name": "MONDAY_CLIENT_ID",
+      "description": "Monday.com OAuth Client ID",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://developer.monday.com/apps/docs/oauth"
+    },
+    {
+      "name": "MONDAY_CLIENT_SECRET",
+      "description": "Monday.com OAuth Client Secret",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://developer.monday.com/apps/docs/oauth"
+    }
+  ],
+  "tools": [
+    {
+      "id": "list-boards",
+      "name": "List Boards",
+      "description": "List all boards in the workspace",
+      "requiresWrite": false
+    },
+    {
+      "id": "list-items",
+      "name": "List Items",
+      "description": "List items in a board",
+      "requiresWrite": false
+    },
+    {
+      "id": "get-item",
+      "name": "Get Item",
+      "description": "Get details of a specific item",
+      "requiresWrite": false
+    },
+    {
+      "id": "create-item",
+      "name": "Create Item",
+      "description": "Create a new item in a board",
+      "requiresWrite": true
+    },
+    {
+      "id": "update-item",
+      "name": "Update Item",
+      "description": "Update an existing item",
+      "requiresWrite": true
+    }
+  ],
+  "prompts": [
+    {
+      "id": "my-items",
+      "title": "Show my items",
+      "prompt": "List all items assigned to me in Monday.com with their status and due dates.",
+      "category": "productivity",
+      "icon": "list"
+    },
+    {
+      "id": "create-item",
+      "title": "Create an item",
+      "prompt": "Create a new item with a name, status, and assign it to someone.",
+      "category": "productivity",
+      "icon": "plus"
+    }
+  ],
+  "suggestedWith": ["slack", "notion", "asana"]
+}

package/dist/integrations/monday/files/_env.example

@@ -0,0 +1,4 @@
+# Monday.com OAuth Configuration
+# Get your credentials from https://monday.com/developers/apps
+MONDAY_CLIENT_ID=your-client-id
+MONDAY_CLIENT_SECRET=your-client-secret

package/dist/integrations/monday/files/ai/tools/create-item.ts

@@ -0,0 +1,36 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { createItem } from "../../lib/monday-client.ts";
+
+export default tool({
+  id: "create-item",
+  description: "Create a new item in a Monday.com board. Items are the rows in a board.",
+  inputSchema: z.object({
+    boardId: z.string().describe("The ID of the board to create the item in"),
+    itemName: z.string().describe("The name/title of the item"),
+    groupId: z.string().optional().describe("Optional group ID within the board to add the item to"),
+    columnValues: z.record(z.unknown()).optional().describe(
+      "Optional column values as a key-value object. Keys are column IDs, values depend on column type.",
+    ),
+  }),
+  async execute({ boardId, itemName, groupId, columnValues }) {
+    const item = await createItem({
+      boardId,
+      itemName,
+      groupId,
+      columnValues,
+    });
+
+    return {
+      success: true,
+      item: {
+        id: item.id,
+        name: item.name,
+        state: item.state,
+        board: item.board,
+        group: item.group,
+        createdAt: item.created_at,
+      },
+    };
+  },
+});

package/dist/integrations/monday/files/ai/tools/get-item.ts

@@ -0,0 +1,31 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getItem } from "../../lib/monday-client.ts";
+
+export default tool({
+  id: "get-item",
+  description: "Get details of a specific Monday.com item by its ID.",
+  inputSchema: z.object({
+    itemId: z.string().describe("The ID of the item to retrieve"),
+  }),
+  async execute({ itemId }) {
+    const item = await getItem(itemId);
+
+    return {
+      id: item.id,
+      name: item.name,
+      state: item.state,
+      board: item.board,
+      group: item.group,
+      columnValues: item.column_values?.map((col) => ({
+        id: col.id,
+        title: col.title,
+        text: col.text,
+        type: col.type,
+        value: col.value,
+      })),
+      createdAt: item.created_at,
+      updatedAt: item.updated_at,
+    };
+  },
+});

package/dist/integrations/monday/files/ai/tools/list-boards.ts

@@ -0,0 +1,29 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listBoards } from "../../lib/monday-client.ts";
+
+export default tool({
+  id: "list-boards",
+  description: "List all boards in Monday.com. Can optionally filter by workspace IDs.",
+  inputSchema: z.object({
+    workspaceIds: z.array(z.string()).optional().describe("Optional list of workspace IDs to filter boards"),
+    limit: z.number().min(1).max(100).default(50).describe("Maximum number of boards to return"),
+    page: z.number().min(1).default(1).describe("Page number for pagination"),
+  }),
+  async execute({ workspaceIds, limit, page }) {
+    const boards = await listBoards({
+      workspaceIds,
+      limit,
+      page,
+    });
+
+    return boards.map((board) => ({
+      id: board.id,
+      name: board.name,
+      description: board.description,
+      boardKind: board.board_kind,
+      state: board.state,
+      workspaceId: board.workspace_id,
+    }));
+  },
+});