veryfront 0.0.48 → 0.0.50

package/dist/integrations/jira/files/ai/tools/update-issue.ts

@@ -0,0 +1,81 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import {
+  getIssue,
+  getIssueTransitions,
+  transitionIssue,
+  updateIssue,
+} from "../../lib/jira-client.ts";
+
+export default tool({
+  id: "update-issue",
+  description:
+    'Update an existing Jira issue. Can update fields like summary, description, priority, assignee, labels, or transition the status (e.g., move to "In Progress", "Done").',
+  inputSchema: z.object({
+    issueKey: z.string().describe('The issue key (e.g., "PROJ-123") to update'),
+    summary: z.string().optional().describe("New summary/title for the issue"),
+    description: z.string().optional().describe("New description for the issue"),
+    priority: z.string().optional().describe(
+      'New priority: "Highest", "High", "Medium", "Low", "Lowest"',
+    ),
+    assigneeId: z.string().optional().describe("Atlassian account ID of the new assignee"),
+    labels: z.array(z.string()).optional().describe(
+      "New array of labels (replaces existing labels)",
+    ),
+    status: z.string().optional().describe(
+      'New status to transition to (e.g., "In Progress", "Done", "To Do")',
+    ),
+  }),
+  async execute({ issueKey, summary, description, priority, assigneeId, labels, status }) {
+    // Update fields if provided
+    if (summary || description || priority || assigneeId || labels) {
+      await updateIssue(issueKey, {
+        summary,
+        description,
+        priority,
+        assigneeId,
+        labels,
+      });
+    }
+
+    // Transition status if provided
+    if (status) {
+      const transitions = await getIssueTransitions(issueKey);
+      const targetTransition = transitions.find(
+        (t) =>
+          t.name.toLowerCase() === status.toLowerCase() ||
+          t.to.name.toLowerCase() === status.toLowerCase(),
+      );
+
+      if (!targetTransition) {
+        throw new Error(
+          `Status "${status}" not found. Available transitions: ${
+            transitions.map((t) => t.to.name).join(", ")
+          }`,
+        );
+      }
+
+      await transitionIssue(issueKey, targetTransition.id);
+    }
+
+    // Fetch and return updated issue
+    const updatedIssue = await getIssue(issueKey);
+
+    return {
+      key: updatedIssue.key,
+      id: updatedIssue.id,
+      summary: updatedIssue.fields.summary,
+      status: updatedIssue.fields.status.name,
+      type: updatedIssue.fields.issuetype.name,
+      priority: updatedIssue.fields.priority?.name,
+      assignee: updatedIssue.fields.assignee?.displayName,
+      project: {
+        key: updatedIssue.fields.project.key,
+        name: updatedIssue.fields.project.name,
+      },
+      updated: updatedIssue.fields.updated,
+      labels: updatedIssue.fields.labels || [],
+      message: `Issue ${issueKey} updated successfully`,
+    };
+  },
+});

package/dist/integrations/jira/files/app/api/auth/jira/callback/route.ts

@@ -0,0 +1,11 @@
+/**
+ * Jira OAuth Callback
+ */
+
+import { createOAuthCallbackHandler, jiraConfig, memoryTokenStore } from "veryfront/oauth";
+
+export const GET = createOAuthCallbackHandler(jiraConfig, {
+  tokenStore: memoryTokenStore,
+  onSuccess: () => "/",
+  onError: () => "/",
+});

package/dist/integrations/jira/files/app/api/auth/jira/route.ts

@@ -0,0 +1,9 @@
+/**
+ * Jira OAuth Initiation
+ */
+
+import { createOAuthInitHandler, jiraConfig, memoryTokenStore } from "veryfront/oauth";
+
+export const GET = createOAuthInitHandler(jiraConfig, {
+  tokenStore: memoryTokenStore,
+});

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

@@ -0,0 +1,338 @@
+import { getAccessToken, getCloudId } from "./token-store.ts";
+
+const JIRA_API_VERSION = "3";
+
+interface JiraResponse<T> {
+  expand?: string;
+  startAt?: number;
+  maxResults?: number;
+  total?: number;
+  issues?: T[];
+  values?: T[];
+}
+
+export interface JiraIssue {
+  id: string;
+  key: string;
+  self: string;
+  fields: {
+    summary: string;
+    description?: {
+      type: string;
+      content: unknown[];
+    } | string;
+    status: {
+      name: string;
+      statusCategory: {
+        key: string;
+        name: string;
+      };
+    };
+    issuetype: {
+      id: string;
+      name: string;
+      iconUrl: string;
+    };
+    priority?: {
+      name: string;
+      iconUrl: string;
+    };
+    assignee?: {
+      displayName: string;
+      emailAddress: string;
+      accountId: string;
+    };
+    reporter?: {
+      displayName: string;
+      emailAddress: string;
+      accountId: string;
+    };
+    created: string;
+    updated: string;
+    project: {
+      id: string;
+      key: string;
+      name: string;
+    };
+    labels?: string[];
+    [key: string]: unknown;
+  };
+}
+
+export interface JiraProject {
+  id: string;
+  key: string;
+  name: string;
+  projectTypeKey: string;
+  self: string;
+  avatarUrls?: Record<string, string>;
+  lead?: {
+    displayName: string;
+    accountId: string;
+  };
+}
+
+export interface JiraIssueType {
+  id: string;
+  name: string;
+  description: string;
+  iconUrl: string;
+  subtask: boolean;
+}
+
+export interface JiraTransition {
+  id: string;
+  name: string;
+  to: {
+    id: string;
+    name: string;
+  };
+}
+
+async function jiraFetch<T>(
+  endpoint: string,
+  options: RequestInit = {},
+): Promise<T> {
+  const token = await getAccessToken();
+  const cloudId = await getCloudId();
+
+  if (!token) {
+    throw new Error("Not authenticated with Jira. Please connect your account.");
+  }
+
+  if (!cloudId) {
+    throw new Error("Jira cloud ID not found. Please reconnect your account.");
+  }
+
+  const baseUrl = `https://api.atlassian.com/ex/jira/${cloudId}/rest/api/${JIRA_API_VERSION}`;
+  const url = endpoint.startsWith("http") ? endpoint : `${baseUrl}${endpoint}`;
+
+  const response = await fetch(url, {
+    ...options,
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "Accept": "application/json",
+      "Content-Type": "application/json",
+      ...options.headers,
+    },
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new Error(
+      `Jira API error: ${response.status} ${
+        error.errorMessages?.join(", ") || error.message || response.statusText
+      }`,
+    );
+  }
+
+  // Handle 204 No Content
+  if (response.status === 204) {
+    return {} as T;
+  }
+
+  return response.json();
+}
+
+export async function searchIssues(
+  jql: string,
+  options?: {
+    fields?: string[];
+    maxResults?: number;
+    startAt?: number;
+  },
+): Promise<{ issues: JiraIssue[]; total: number }> {
+  const params = new URLSearchParams({
+    jql,
+    maxResults: String(options?.maxResults || 50),
+    startAt: String(options?.startAt || 0),
+  });
+
+  if (options?.fields && options.fields.length > 0) {
+    params.set("fields", options.fields.join(","));
+  }
+
+  const response = await jiraFetch<JiraResponse<JiraIssue>>(
+    `/search?${params.toString()}`,
+  );
+
+  return {
+    issues: response.issues || [],
+    total: response.total || 0,
+  };
+}
+
+export function getIssue(issueIdOrKey: string): Promise<JiraIssue> {
+  return jiraFetch<JiraIssue>(`/issue/${issueIdOrKey}`);
+}
+
+export async function createIssue(options: {
+  projectKey: string;
+  summary: string;
+  description?: string;
+  issueType: string;
+  priority?: string;
+  assigneeId?: string;
+  labels?: string[];
+}): Promise<JiraIssue> {
+  const fields: Record<string, unknown> = {
+    project: { key: options.projectKey },
+    summary: options.summary,
+    issuetype: { name: options.issueType },
+  };
+
+  if (options.description) {
+    // Use ADF (Atlassian Document Format) for description
+    fields.description = {
+      type: "doc",
+      version: 1,
+      content: [
+        {
+          type: "paragraph",
+          content: [
+            {
+              type: "text",
+              text: options.description,
+            },
+          ],
+        },
+      ],
+    };
+  }
+
+  if (options.priority) {
+    fields.priority = { name: options.priority };
+  }
+
+  if (options.assigneeId) {
+    fields.assignee = { id: options.assigneeId };
+  }
+
+  if (options.labels && options.labels.length > 0) {
+    fields.labels = options.labels;
+  }
+
+  const response = await jiraFetch<{ id: string; key: string; self: string }>(
+    "/issue",
+    {
+      method: "POST",
+      body: JSON.stringify({ fields }),
+    },
+  );
+
+  // Fetch the full issue details
+  return getIssue(response.key);
+}
+
+export function updateIssue(
+  issueIdOrKey: string,
+  updates: {
+    summary?: string;
+    description?: string;
+    priority?: string;
+    assigneeId?: string;
+    labels?: string[];
+  },
+): Promise<void> {
+  const fields: Record<string, unknown> = {};
+
+  if (updates.summary) {
+    fields.summary = updates.summary;
+  }
+
+  if (updates.description) {
+    fields.description = {
+      type: "doc",
+      version: 1,
+      content: [
+        {
+          type: "paragraph",
+          content: [
+            {
+              type: "text",
+              text: updates.description,
+            },
+          ],
+        },
+      ],
+    };
+  }
+
+  if (updates.priority) {
+    fields.priority = { name: updates.priority };
+  }
+
+  if (updates.assigneeId) {
+    fields.assignee = { id: updates.assigneeId };
+  }
+
+  if (updates.labels) {
+    fields.labels = updates.labels;
+  }
+
+  return jiraFetch<void>(`/issue/${issueIdOrKey}`, {
+    method: "PUT",
+    body: JSON.stringify({ fields }),
+  });
+}
+
+export async function transitionIssue(
+  issueIdOrKey: string,
+  transitionId: string,
+): Promise<void> {
+  await jiraFetch<void>(`/issue/${issueIdOrKey}/transitions`, {
+    method: "POST",
+    body: JSON.stringify({
+      transition: { id: transitionId },
+    }),
+  });
+}
+
+export async function getIssueTransitions(issueIdOrKey: string): Promise<JiraTransition[]> {
+  const response = await jiraFetch<{ transitions: JiraTransition[] }>(
+    `/issue/${issueIdOrKey}/transitions`,
+  );
+  return response.transitions || [];
+}
+
+export async function listProjects(): Promise<JiraProject[]> {
+  const response = await jiraFetch<JiraProject[]>("/project");
+  return response;
+}
+
+export function getProject(projectIdOrKey: string): Promise<JiraProject> {
+  return jiraFetch<JiraProject>(`/project/${projectIdOrKey}`);
+}
+
+export async function getProjectIssueTypes(projectIdOrKey: string): Promise<JiraIssueType[]> {
+  const response = await jiraFetch<JiraIssueType[]>(
+    `/project/${projectIdOrKey}/statuses`,
+  );
+  return response;
+}
+
+// Helper to extract plain text from ADF description
+export function extractDescriptionText(description: unknown): string {
+  if (typeof description === "string") {
+    return description;
+  }
+
+  if (description && typeof description === "object" && "content" in description) {
+    const content = (description as { content: unknown[] }).content;
+    const texts: string[] = [];
+
+    const extractText = (node: any): void => {
+      if (node.type === "text" && node.text) {
+        texts.push(node.text);
+      }
+      if (node.content && Array.isArray(node.content)) {
+        node.content.forEach(extractText);
+      }
+    };
+
+    content.forEach(extractText);
+    return texts.join(" ");
+  }
+
+  return "";
+}

package/dist/integrations/jira/files/lib/token-store.ts

@@ -0,0 +1,5 @@
+/**
+ * Jira Token Store
+ */
+
+export { memoryTokenStore as tokenStore, type OAuthTokens, type TokenStore } from "veryfront/oauth";

package/dist/integrations/linear/connector.json

@@ -0,0 +1,100 @@
+{
+  "name": "linear",
+  "displayName": "Linear",
+  "icon": "linear.svg",
+  "description": "Search, create, and manage Linear issues and projects",
+  "auth": {
+    "type": "oauth2",
+    "provider": "linear",
+    "authorizationUrl": "https://linear.app/oauth/authorize",
+    "tokenUrl": "https://api.linear.app/oauth/token",
+    "scopes": ["read", "write"],
+    "callbackPath": "/api/auth/linear/callback",
+    "tokenAuthMethod": "basic",
+    "requiredApis": [
+      {
+        "name": "Linear OAuth Application",
+        "enableUrl": "https://linear.app/settings/api"
+      }
+    ]
+  },
+  "envVars": [
+    {
+      "name": "LINEAR_CLIENT_ID",
+      "description": "Linear OAuth Client ID (from your OAuth application)",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://linear.app/settings/api"
+    },
+    {
+      "name": "LINEAR_CLIENT_SECRET",
+      "description": "Linear OAuth Client Secret",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://linear.app/settings/api"
+    }
+  ],
+  "tools": [
+    {
+      "id": "search-issues",
+      "name": "Search Issues",
+      "description": "Search for Linear issues by title or description",
+      "requiresWrite": false
+    },
+    {
+      "id": "get-issue",
+      "name": "Get Issue",
+      "description": "Get detailed information about a specific Linear issue",
+      "requiresWrite": false
+    },
+    {
+      "id": "create-issue",
+      "name": "Create Issue",
+      "description": "Create a new Linear issue in a team",
+      "requiresWrite": true
+    },
+    {
+      "id": "update-issue",
+      "name": "Update Issue",
+      "description": "Update the status, assignee, or other properties of an issue",
+      "requiresWrite": true
+    },
+    {
+      "id": "list-projects",
+      "name": "List Projects",
+      "description": "List all projects in the workspace",
+      "requiresWrite": false
+    }
+  ],
+  "prompts": [
+    {
+      "id": "find-issues",
+      "title": "Find my issues",
+      "prompt": "Search for Linear issues assigned to me or related to a specific topic.",
+      "category": "productivity",
+      "icon": "search"
+    },
+    {
+      "id": "create-bug-report",
+      "title": "Create bug report",
+      "prompt": "Create a new bug report in Linear with title, description, and relevant labels.",
+      "category": "productivity",
+      "icon": "plus"
+    },
+    {
+      "id": "update-issue-status",
+      "title": "Update issue status",
+      "prompt": "Update the status of a Linear issue (e.g., mark as done, in progress, blocked).",
+      "category": "productivity",
+      "icon": "check"
+    },
+    {
+      "id": "project-overview",
+      "title": "Project overview",
+      "prompt": "Get an overview of all projects in Linear, including their status and key issues.",
+      "category": "productivity",
+      "icon": "list"
+    }
+  ],
+  "suggestedWith": ["github", "slack", "figma"]
+}

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

@@ -0,0 +1,6 @@
+# Linear Integration
+# Create an OAuth application at https://linear.app/settings/api
+# Set the callback URL to: http://localhost:3000/api/auth/linear/callback (or your production URL)
+
+LINEAR_CLIENT_ID=your_client_id_here
+LINEAR_CLIENT_SECRET=your_client_secret_here

package/dist/integrations/linear/files/ai/tools/create-issue.ts

@@ -0,0 +1,71 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { createIssue } from "../../lib/linear-client.ts";
+
+export default tool({
+  id: "create-issue",
+  description:
+    "Create a new Linear issue in a specified team. You can optionally set priority, assign to someone, add to a project, and attach labels.",
+  inputSchema: z.object({
+    teamId: z.string().describe(
+      "The ID of the team to create the issue in. Use list-projects tool first if you need to find team IDs.",
+    ),
+    title: z.string().describe("Title of the issue"),
+    description: z.string().optional().describe(
+      "Detailed description of the issue (supports markdown)",
+    ),
+    priority: z.number().min(0).max(4).optional().describe(
+      "Priority level: 0=No priority, 1=Urgent, 2=High, 3=Medium, 4=Low",
+    ),
+    stateId: z.string().optional().describe(
+      'Workflow state ID (e.g., "Todo", "In Progress", "Done")',
+    ),
+    assigneeId: z.string().optional().describe("User ID to assign the issue to"),
+    projectId: z.string().optional().describe("Project ID to add the issue to"),
+    labelIds: z.array(z.string()).optional().describe("Array of label IDs to attach to the issue"),
+  }),
+  async execute(
+    { teamId, title, description, priority, stateId, assigneeId, projectId, labelIds },
+  ) {
+    const issue = await createIssue({
+      teamId,
+      title,
+      description,
+      priority,
+      stateId,
+      assigneeId,
+      projectId,
+      labelIds,
+    });
+
+    return {
+      id: issue.id,
+      identifier: issue.identifier,
+      title: issue.title,
+      description: issue.description,
+      priority: issue.priorityLabel,
+      status: issue.state.name,
+      assignee: issue.assignee
+        ? {
+          name: issue.assignee.name,
+          email: issue.assignee.email,
+        }
+        : null,
+      team: {
+        name: issue.team.name,
+        key: issue.team.key,
+      },
+      project: issue.project
+        ? {
+          name: issue.project.name,
+        }
+        : null,
+      labels: issue.labels.nodes.map((label) => ({
+        name: label.name,
+        color: label.color,
+      })),
+      url: issue.url,
+      createdAt: issue.createdAt,
+    };
+  },
+});

package/dist/integrations/linear/files/ai/tools/get-issue.ts

@@ -0,0 +1,55 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getIssue } from "../../lib/linear-client.ts";
+
+export default tool({
+  id: "get-issue",
+  description:
+    "Get detailed information about a specific Linear issue by its ID or identifier (e.g., ENG-123). Returns complete issue details including description, status, assignee, labels, and project.",
+  inputSchema: z.object({
+    issueId: z.string().describe(
+      'The ID or identifier of the issue (e.g., "ENG-123" or full UUID)',
+    ),
+  }),
+  async execute({ issueId }) {
+    const issue = await getIssue(issueId);
+
+    return {
+      id: issue.id,
+      identifier: issue.identifier,
+      title: issue.title,
+      description: issue.description,
+      priority: issue.priorityLabel,
+      priorityNumber: issue.priority,
+      status: issue.state.name,
+      statusType: issue.state.type,
+      stateId: issue.state.id,
+      assignee: issue.assignee
+        ? {
+          id: issue.assignee.id,
+          name: issue.assignee.name,
+          email: issue.assignee.email,
+        }
+        : null,
+      team: {
+        id: issue.team.id,
+        name: issue.team.name,
+        key: issue.team.key,
+      },
+      project: issue.project
+        ? {
+          id: issue.project.id,
+          name: issue.project.name,
+        }
+        : null,
+      labels: issue.labels.nodes.map((label) => ({
+        id: label.id,
+        name: label.name,
+        color: label.color,
+      })),
+      url: issue.url,
+      createdAt: issue.createdAt,
+      updatedAt: issue.updatedAt,
+    };
+  },
+});