veryfront 0.0.49 → 0.0.51

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

@@ -0,0 +1,439 @@
+import { getAccessToken } from "./token-store.ts";
+
+const CLICKUP_BASE_URL = "https://api.clickup.com/api/v2";
+
+interface ClickUpResponse<T> {
+  data?: T;
+}
+
+interface ClickUpTask {
+  id: string;
+  name: string;
+  description: string;
+  status: {
+    status: string;
+    color: string;
+    type: string;
+  };
+  date_created: string;
+  date_updated: string;
+  date_closed: string | null;
+  creator: {
+    id: number;
+    username: string;
+    email: string;
+  };
+  assignees: Array<{
+    id: number;
+    username: string;
+    email: string;
+  }>;
+  tags: Array<{
+    name: string;
+    tag_fg: string;
+    tag_bg: string;
+  }>;
+  due_date: string | null;
+  start_date: string | null;
+  priority: {
+    id: string;
+    priority: string;
+    color: string;
+  } | null;
+  list: {
+    id: string;
+    name: string;
+  };
+  folder: {
+    id: string;
+    name: string;
+  };
+  space: {
+    id: string;
+    name: string;
+  };
+}
+
+interface ClickUpList {
+  id: string;
+  name: string;
+  orderindex: number;
+  content: string;
+  status: {
+    status: string;
+    color: string;
+  };
+  priority: {
+    priority: string;
+    color: string;
+  } | null;
+  assignee: {
+    id: number;
+    username: string;
+    email: string;
+  } | null;
+  task_count: number;
+  due_date: string | null;
+  start_date: string | null;
+  folder: {
+    id: string;
+    name: string;
+    hidden: boolean;
+    access: boolean;
+  };
+  space: {
+    id: string;
+    name: string;
+    access: boolean;
+  };
+  archived: boolean;
+}
+
+interface ClickUpFolder {
+  id: string;
+  name: string;
+  orderindex: number;
+  override_statuses: boolean;
+  hidden: boolean;
+  space: {
+    id: string;
+    name: string;
+  };
+  task_count: string;
+  lists: ClickUpList[];
+}
+
+interface ClickUpSpace {
+  id: string;
+  name: string;
+  private: boolean;
+  statuses: Array<{
+    status: string;
+    type: string;
+    orderindex: number;
+    color: string;
+  }>;
+  multiple_assignees: boolean;
+  features: {
+    due_dates: {
+      enabled: boolean;
+      start_date: boolean;
+      remap_due_dates: boolean;
+      remap_closed_due_date: boolean;
+    };
+    time_tracking: {
+      enabled: boolean;
+    };
+    tags: {
+      enabled: boolean;
+    };
+    time_estimates: {
+      enabled: boolean;
+    };
+    checklists: {
+      enabled: boolean;
+    };
+    custom_fields: {
+      enabled: boolean;
+    };
+    remap_dependencies: {
+      enabled: boolean;
+    };
+    dependency_warning: {
+      enabled: boolean;
+    };
+    portfolios: {
+      enabled: boolean;
+    };
+  };
+}
+
+async function clickupFetch<T>(
+  endpoint: string,
+  options: RequestInit = {},
+): Promise<T> {
+  const token = await getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated with ClickUp. Please connect your account.");
+  }
+
+  const response = await fetch(`${CLICKUP_BASE_URL}${endpoint}`, {
+    ...options,
+    headers: {
+      "Authorization": token,
+      "Content-Type": "application/json",
+      ...options.headers,
+    },
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new Error(
+      `ClickUp API error: ${response.status} ${error.err || error.error || response.statusText}`,
+    );
+  }
+
+  return response.json();
+}
+
+export async function listSpaces(teamId: string): Promise<ClickUpSpace[]> {
+  const response = await clickupFetch<{ spaces: ClickUpSpace[] }>(`/team/${teamId}/space`);
+  return response.spaces;
+}
+
+export async function listFolders(spaceId: string): Promise<ClickUpFolder[]> {
+  const response = await clickupFetch<{ folders: ClickUpFolder[] }>(`/space/${spaceId}/folder`);
+  return response.folders;
+}
+
+export async function listLists(folderId: string): Promise<ClickUpList[]> {
+  const response = await clickupFetch<{ lists: ClickUpList[] }>(`/folder/${folderId}/list`);
+  return response.lists;
+}
+
+export async function listFolderlessLists(spaceId: string): Promise<ClickUpList[]> {
+  const response = await clickupFetch<{ lists: ClickUpList[] }>(`/space/${spaceId}/list`);
+  return response.lists;
+}
+
+export async function listTasks(options: {
+  listId?: string;
+  spaceId?: string;
+  folderId?: string;
+  assignees?: number[];
+  statuses?: string[];
+  includeClosed?: boolean;
+  orderBy?: string;
+  subtasks?: boolean;
+}): Promise<ClickUpTask[]> {
+  const params = new URLSearchParams();
+
+  if (options.assignees && options.assignees.length > 0) {
+    options.assignees.forEach(assignee => params.append("assignees[]", assignee.toString()));
+  }
+
+  if (options.statuses && options.statuses.length > 0) {
+    options.statuses.forEach(status => params.append("statuses[]", status));
+  }
+
+  if (options.includeClosed !== undefined) {
+    params.set("include_closed", options.includeClosed.toString());
+  }
+
+  if (options.orderBy) {
+    params.set("order_by", options.orderBy);
+  }
+
+  if (options.subtasks !== undefined) {
+    params.set("subtasks", options.subtasks.toString());
+  }
+
+  let endpoint = "/task";
+  if (options.listId) {
+    endpoint = `/list/${options.listId}/task`;
+  } else if (options.folderId) {
+    endpoint = `/folder/${options.folderId}/task`;
+  } else if (options.spaceId) {
+    endpoint = `/space/${options.spaceId}/task`;
+  }
+
+  const queryString = params.toString();
+  const url = queryString ? `${endpoint}?${queryString}` : endpoint;
+
+  const response = await clickupFetch<{ tasks: ClickUpTask[] }>(url);
+  return response.tasks;
+}
+
+export async function getTask(taskId: string, options?: {
+  customTaskIds?: boolean;
+  teamId?: string;
+  includeSubtasks?: boolean;
+}): Promise<ClickUpTask> {
+  const params = new URLSearchParams();
+
+  if (options?.customTaskIds) {
+    params.set("custom_task_ids", "true");
+    if (options.teamId) {
+      params.set("team_id", options.teamId);
+    }
+  }
+
+  if (options?.includeSubtasks) {
+    params.set("include_subtasks", "true");
+  }
+
+  const queryString = params.toString();
+  const url = queryString ? `/task/${taskId}?${queryString}` : `/task/${taskId}`;
+
+  return await clickupFetch<ClickUpTask>(url);
+}
+
+export async function createTask(options: {
+  listId: string;
+  name: string;
+  description?: string;
+  assignees?: number[];
+  tags?: string[];
+  status?: string;
+  priority?: number;
+  dueDate?: number;
+  dueDateTime?: boolean;
+  timeEstimate?: number;
+  startDate?: number;
+  startDateTime?: boolean;
+  notifyAll?: boolean;
+  parent?: string;
+  linksTo?: string;
+  checkRequired?: boolean;
+  customTaskIds?: boolean;
+  teamId?: string;
+}): Promise<ClickUpTask> {
+  const body: Record<string, unknown> = {
+    name: options.name,
+  };
+
+  if (options.description) body.description = options.description;
+  if (options.assignees) body.assignees = options.assignees;
+  if (options.tags) body.tags = options.tags;
+  if (options.status) body.status = options.status;
+  if (options.priority !== undefined) body.priority = options.priority;
+  if (options.dueDate) {
+    body.due_date = options.dueDate;
+    if (options.dueDateTime !== undefined) body.due_date_time = options.dueDateTime;
+  }
+  if (options.timeEstimate) body.time_estimate = options.timeEstimate;
+  if (options.startDate) {
+    body.start_date = options.startDate;
+    if (options.startDateTime !== undefined) body.start_date_time = options.startDateTime;
+  }
+  if (options.notifyAll !== undefined) body.notify_all = options.notifyAll;
+  if (options.parent) body.parent = options.parent;
+  if (options.linksTo) body.links_to = options.linksTo;
+
+  const params = new URLSearchParams();
+  if (options.customTaskIds) {
+    params.set("custom_task_ids", "true");
+    if (options.teamId) {
+      params.set("team_id", options.teamId);
+    }
+  }
+
+  const queryString = params.toString();
+  const url = queryString
+    ? `/list/${options.listId}/task?${queryString}`
+    : `/list/${options.listId}/task`;
+
+  return await clickupFetch<ClickUpTask>(url, {
+    method: "POST",
+    body: JSON.stringify(body),
+  });
+}
+
+export async function updateTask(
+  taskId: string,
+  updates: {
+    name?: string;
+    description?: string;
+    status?: string;
+    priority?: number | null;
+    dueDate?: number | null;
+    dueDateTime?: boolean;
+    timeEstimate?: number | null;
+    startDate?: number | null;
+    startDateTime?: boolean;
+    assignees?: {
+      add?: number[];
+      rem?: number[];
+    };
+    archived?: boolean;
+  },
+  options?: {
+    customTaskIds?: boolean;
+    teamId?: string;
+  },
+): Promise<ClickUpTask> {
+  const body: Record<string, unknown> = {};
+
+  if (updates.name !== undefined) body.name = updates.name;
+  if (updates.description !== undefined) body.description = updates.description;
+  if (updates.status !== undefined) body.status = updates.status;
+  if (updates.priority !== undefined) body.priority = updates.priority;
+  if (updates.dueDate !== undefined) {
+    body.due_date = updates.dueDate;
+    if (updates.dueDateTime !== undefined) body.due_date_time = updates.dueDateTime;
+  }
+  if (updates.timeEstimate !== undefined) body.time_estimate = updates.timeEstimate;
+  if (updates.startDate !== undefined) {
+    body.start_date = updates.startDate;
+    if (updates.startDateTime !== undefined) body.start_date_time = updates.startDateTime;
+  }
+  if (updates.assignees) body.assignees = updates.assignees;
+  if (updates.archived !== undefined) body.archived = updates.archived;
+
+  const params = new URLSearchParams();
+  if (options?.customTaskIds) {
+    params.set("custom_task_ids", "true");
+    if (options.teamId) {
+      params.set("team_id", options.teamId);
+    }
+  }
+
+  const queryString = params.toString();
+  const url = queryString ? `/task/${taskId}?${queryString}` : `/task/${taskId}`;
+
+  return await clickupFetch<ClickUpTask>(url, {
+    method: "PUT",
+    body: JSON.stringify(body),
+  });
+}
+
+export async function getAuthorizedUser(): Promise<{
+  user: {
+    id: number;
+    username: string;
+    email: string;
+    color: string;
+    profilePicture: string;
+  };
+}> {
+  return await clickupFetch<{
+    user: {
+      id: number;
+      username: string;
+      email: string;
+      color: string;
+      profilePicture: string;
+    };
+  }>("/user");
+}
+
+export async function getTeams(): Promise<Array<{
+  id: string;
+  name: string;
+  color: string;
+  avatar: string | null;
+  members: Array<{
+    user: {
+      id: number;
+      username: string;
+      email: string;
+    };
+  }>;
+}>> {
+  const response = await clickupFetch<{
+    teams: Array<{
+      id: string;
+      name: string;
+      color: string;
+      avatar: string | null;
+      members: Array<{
+        user: {
+          id: number;
+          username: string;
+          email: string;
+        };
+      }>;
+    }>;
+  }>("/team");
+  return response.teams;
+}

package/dist/integrations/confluence/README.md

@@ -0,0 +1,246 @@
+# Confluence Integration for Veryfront
+
+A complete Confluence integration for Veryfront that enables AI agents to search, read, create, and update documentation in Confluence spaces.
+
+## Features
+
+- **OAuth 2.0 Authentication**: Secure authentication using Atlassian's OAuth 2.0 flow
+- **Search Content**: Search for pages and blog posts across Confluence spaces
+- **Read Pages**: Retrieve full page content with metadata
+- **Create Pages**: Create new pages in any accessible space
+- **Update Pages**: Update existing pages with version control
+- **List Spaces**: Discover all accessible Confluence spaces
+
+## Structure
+
+```
+confluence/
+├── connector.json                           # Integration metadata and configuration
+├── files/
+│   ├── _env.example                        # Environment variables template
+│   ├── lib/
+│   │   ├── confluence-client.ts            # Confluence API client
+│   │   ├── oauth.ts                        # OAuth 2.0 utilities
+│   │   └── token-store.ts                  # Token management (in-memory)
+│   ├── app/api/auth/confluence/
+│   │   ├── route.ts                        # OAuth initialization endpoint
+│   │   └── callback/route.ts               # OAuth callback handler
+│   └── ai/tools/
+│       ├── search-content.ts               # Search tool
+│       ├── get-page.ts                     # Get page content tool
+│       ├── create-page.ts                  # Create page tool
+│       ├── update-page.ts                  # Update page tool
+│       └── list-spaces.ts                  # List spaces tool
+```
+
+## Setup
+
+### 1. Create an Atlassian OAuth 2.0 App
+
+1. Go to [Atlassian Developer Console](https://developer.atlassian.com/console/myapps/)
+2. Click "Create" → "OAuth 2.0 integration"
+3. Name your app (e.g., "Veryfront Confluence Integration")
+4. Add the following settings:
+   - **Callback URL**: `https://your-domain.com/api/auth/confluence/callback`
+   - **Scopes**:
+     - `read:confluence-content.all`
+     - `write:confluence-content`
+     - `offline_access` (for refresh tokens)
+
+### 2. Configure Environment Variables
+
+Add the following to your `.env` file:
+
+```bash
+ATLASSIAN_CLIENT_ID=your_client_id_here
+ATLASSIAN_CLIENT_SECRET=your_client_secret_here
+```
+
+### 3. Install the Integration
+
+Use the Veryfront CLI to install:
+
+```bash
+veryfront add integration confluence
+```
+
+## API Client Usage
+
+### Search Content
+
+```typescript
+import { searchContent } from './lib/confluence-client.ts'
+
+const results = await searchContent('API documentation', {
+  spaceKey: 'DEV',
+  limit: 10
+})
+```
+
+### Get Page Content
+
+```typescript
+import { getPageContent, extractPlainText } from './lib/confluence-client.ts'
+
+const page = await getPageContent('page-id-here')
+const plainText = extractPlainText(page.body?.storage?.value || '')
+```
+
+### Create Page
+
+```typescript
+import { createPage } from './lib/confluence-client.ts'
+
+const newPage = await createPage({
+  spaceKey: 'TEAM',
+  title: 'Meeting Notes',
+  content: '<p>Meeting notes content here</p>',
+  parentId: 'optional-parent-page-id'
+})
+```
+
+### Update Page
+
+```typescript
+import { updatePage, getPage } from './lib/confluence-client.ts'
+
+const currentPage = await getPage('page-id')
+const updated = await updatePage('page-id', {
+  content: '<p>Updated content</p>',
+  version: currentPage.version.number + 1,
+  versionMessage: 'Updated via API'
+})
+```
+
+### List Spaces
+
+```typescript
+import { listSpaces } from './lib/confluence-client.ts'
+
+const spaces = await listSpaces({
+  type: 'global',
+  limit: 25
+})
+```
+
+## AI Tools
+
+### search-content
+
+Search for pages and blog posts in Confluence.
+
+**Parameters:**
+- `query` (string): Search query
+- `spaceKey` (string, optional): Limit to specific space
+- `limit` (number, default: 10): Max results
+
+### get-page
+
+Get the full content of a Confluence page.
+
+**Parameters:**
+- `pageId` (string): The page ID to retrieve
+
+### create-page
+
+Create a new page in a Confluence space.
+
+**Parameters:**
+- `spaceKey` (string): Space key (e.g., "TEAM")
+- `title` (string): Page title
+- `content` (string): Page content (plain text or HTML)
+- `parentId` (string, optional): Parent page ID
+- `type` (enum, default: "page"): "page" or "blogpost"
+
+### update-page
+
+Update an existing Confluence page.
+
+**Parameters:**
+- `pageId` (string): Page ID to update
+- `title` (string, optional): New title
+- `content` (string, optional): New content
+- `versionMessage` (string, optional): Version change message
+
+### list-spaces
+
+List all accessible Confluence spaces.
+
+**Parameters:**
+- `type` (enum, default: "all"): "global", "personal", or "all"
+- `limit` (number, default: 25): Max spaces to return
+
+## Authentication Flow
+
+1. User navigates to `/api/auth/confluence`
+2. OAuth flow redirects to Atlassian authorization page
+3. User approves access to their Confluence site
+4. Atlassian redirects to `/api/auth/confluence/callback`
+5. Callback exchanges code for access token
+6. System retrieves accessible Confluence sites (cloud IDs)
+7. Tokens stored in token store (in-memory by default)
+8. User redirected to application home page
+
+## Token Storage
+
+The default implementation uses an in-memory token store suitable for development. For production:
+
+1. Implement a database-backed token store
+2. Store tokens per user
+3. Handle token refresh with `refresh_token`
+4. Implement proper token expiration checks
+
+## API Details
+
+- **Base URL**: `https://api.atlassian.com/ex/confluence/{cloudId}`
+- **API Version**: Confluence Cloud REST API v1
+- **Authentication**: Bearer token
+- **Rate Limits**: Respect Atlassian API rate limits
+
+## Content Format
+
+Confluence uses "storage format" (XHTML) for content:
+
+- **Plain text**: Automatically converted using `formatAsStorage()`
+- **HTML**: Use Confluence storage format directly
+- **Reading**: Use `extractPlainText()` to convert to plain text
+
+## Suggested Integrations
+
+This integration works well with:
+- **Jira**: Link documentation to issues
+- **Slack**: Share documentation in channels
+- **Notion**: Sync documentation between platforms
+
+## Notes
+
+- Shares OAuth credentials with Jira integration (`ATLASSIAN_CLIENT_ID` and `ATLASSIAN_CLIENT_SECRET`)
+- Requires OAuth app to have Confluence API access enabled
+- Supports both Confluence Cloud and multi-site access
+- Uses the first accessible site by default (can be extended for multi-site support)
+
+## TypeScript
+
+All files are strongly typed with comprehensive TypeScript interfaces:
+
+- `ConfluenceSpace`: Space metadata
+- `ConfluencePage`: Page structure and content
+- `ConfluenceSearchResult`: Search result format
+- `AtlassianTokenResponse`: OAuth token response
+- `AtlassianResource`: Accessible site information
+
+## Error Handling
+
+All API calls include proper error handling:
+- Authentication errors: "Not authenticated" message
+- API errors: Include status code and error message
+- Token exchange errors: Detailed OAuth error messages
+
+## Security Considerations
+
+1. Store credentials securely (use environment variables)
+2. Implement CSRF protection (state parameter in OAuth)
+3. Use HTTPS for all API calls
+4. Validate all user inputs
+5. Implement proper token storage in production
+6. Handle token expiration and refresh