@mndrk/agx 2.3.3 → 2.4.2

package/cloud-runtime/standalone/apps/local/lib/tracker/adapters/jira/issues.ts

@@ -0,0 +1,268 @@
+import "server-only";
+
+import {
+  getJiraClient,
+  getJiraToken,
+  type JiraRawIssue,
+  adfToPlainText,
+} from "./client";
+import type {
+  TrackerItem,
+  TrackerItemDetail,
+  TrackerComment,
+  TrackerActivity,
+  TrackerStatusCategory,
+} from "../../types";
+import {
+  replaceCachedTrackerItems,
+  listCachedTrackerItems,
+  getCachedTrackerItemContexts,
+  type CachedTrackerItemInput,
+} from "../../tracker-item-store";
+
+// ── Jira statusCategory → canonical statusCategory ──────────────────
+
+export function jiraStatusCategoryToCanonical(key: string): TrackerStatusCategory {
+  switch (key) {
+    case "new":
+      return "todo";
+    case "indeterminate":
+      return "in_progress";
+    case "done":
+      return "done";
+    default:
+      return "todo";
+  }
+}
+
+// ── Jira priority → canonical priority ──────────────────────────────
+
+function jiraPriorityToCanonical(name: string | null | undefined): TrackerItem["priority"] {
+  if (!name) return undefined;
+  const lower = name.toLowerCase();
+  if (lower.includes("highest") || lower.includes("critical")) return "urgent";
+  if (lower.includes("high")) return "high";
+  if (lower.includes("medium") || lower.includes("major")) return "medium";
+  if (lower.includes("low") || lower.includes("minor")) return "low";
+  if (lower.includes("lowest") || lower.includes("trivial")) return "low";
+  return "none";
+}
+
+// ── Map a raw Jira issue to a canonical TrackerItem ─────────────────
+
+export function mapJiraIssue(
+  issue: JiraRawIssue,
+  siteUrl: string,
+  accountId?: string,
+): TrackerItem {
+  const fields = issue.fields;
+  const statusCategoryKey = fields.status?.statusCategory?.key ?? "new";
+
+  return {
+    id: issue.id,
+    trackerId: `jira:${fields.project?.key ?? "unknown"}`,
+    trackerType: "jira",
+    identifier: issue.key,
+    title: fields.summary,
+    description: adfToPlainText(fields.description) ?? undefined,
+    status: fields.status?.name ?? "Unknown",
+    statusCategory: jiraStatusCategoryToCanonical(statusCategoryKey),
+    assignee: fields.assignee
+      ? {
+          id: fields.assignee.accountId,
+          name: fields.assignee.displayName,
+          avatarUrl: fields.assignee.avatarUrls?.["48x48"],
+        }
+      : undefined,
+    priority: jiraPriorityToCanonical(fields.priority?.name),
+    labels: fields.labels ?? [],
+    createdAt: fields.created,
+    updatedAt: fields.updated,
+    url: `${siteUrl}/browse/${issue.key}`,
+  };
+}
+
+// ── Map a raw Jira issue to a cache input ────────────────────────────
+
+function mapJiraIssueToCacheInput(
+  issue: JiraRawIssue,
+  siteUrl: string,
+): CachedTrackerItemInput {
+  const fields = issue.fields;
+  const statusCategoryKey = fields.status?.statusCategory?.key ?? "new";
+
+  return {
+    id: issue.id,
+    trackerType: "jira",
+    trackerId: `jira:${fields.project?.key ?? "unknown"}`,
+    identifier: issue.key,
+    title: fields.summary,
+    description: adfToPlainText(fields.description),
+    status: fields.status?.name ?? "Unknown",
+    statusCategory: jiraStatusCategoryToCanonical(statusCategoryKey),
+    assigneeId: fields.assignee?.accountId ?? null,
+    assignee: fields.assignee?.displayName ?? null,
+    assigneeEmail: null,
+    isAssignedToMe: false, // Set later when we know the viewer
+    teamId: fields.project?.id ?? null,
+    teamName: fields.project?.name ?? null,
+    teamKey: fields.project?.key ?? null,
+    cycleId: fields.customfield_10020 ? String(fields.customfield_10020.id) : null,
+    cycleName: fields.customfield_10020?.name ?? null,
+    cycleNumber: fields.customfield_10020 ? fields.customfield_10020.id : null,
+    priority: fields.priority?.name ?? null,
+    labels: fields.labels ?? [],
+    url: `${siteUrl}/browse/${issue.key}`,
+    updatedAt: fields.updated,
+  };
+}
+
+// ── Pull Jira issues and cache them ─────────────────────────────────
+
+export async function pullJiraIssues(input: {
+  projectId: string;
+  projectKey?: string;
+  jql?: string;
+  limit?: number;
+}): Promise<{ pulled: number }> {
+  const client = await getJiraClient(input.projectId);
+  if (!client) throw new Error("Not connected to Jira");
+
+  const token = getJiraToken(input.projectId);
+  if (!token?.siteUrl) throw new Error("Missing Jira site URL");
+
+  const jql = input.jql ?? (input.projectKey
+    ? `project = ${input.projectKey} ORDER BY updated DESC`
+    : "assignee = currentUser() OR reporter = currentUser() ORDER BY updated DESC");
+  const limit = input.limit ?? 100;
+  const allIssues: CachedTrackerItemInput[] = [];
+  let nextPageToken: string | undefined;
+  let isLast = false;
+
+  while (!isLast && allIssues.length < limit) {
+    const result = await client.searchIssues(jql, {
+      nextPageToken,
+      maxResults: Math.min(50, limit - allIssues.length),
+    });
+
+    for (const issue of result.issues) {
+      allIssues.push(mapJiraIssueToCacheInput(issue, token.siteUrl));
+    }
+
+    isLast = result.isLast || result.issues.length === 0;
+    nextPageToken = result.nextPageToken;
+  }
+
+  await replaceCachedTrackerItems({
+    trackerType: "jira",
+    issues: allIssues,
+    complete: isLast,
+    pulledAtMs: Date.now(),
+  });
+
+  return { pulled: allIssues.length };
+}
+
+// ── Ensure cache is populated, refresh if needed ────────────────────
+
+export async function ensureJiraIssueCache(input: {
+  projectId: string;
+  refresh?: boolean;
+  projectKey?: string;
+}): Promise<{ pulledAt: string | null }> {
+  const { getTrackerItemSyncState, setTrackerItemSyncState } = await import("../../tracker-item-store");
+
+  const syncState = await getTrackerItemSyncState("jira");
+  const shouldRefresh = input.refresh || !syncState?.lastPulledAt;
+
+  if (shouldRefresh) {
+    await pullJiraIssues({
+      projectId: input.projectId,
+      projectKey: input.projectKey,
+    });
+    await setTrackerItemSyncState("jira", 0, Date.now());
+  }
+
+  return { pulledAt: syncState?.lastPulledAt ?? null };
+}
+
+// ── List cached Jira issue summaries ────────────────────────────────
+
+export async function listJiraIssueSummaries(input?: {
+  limit?: number;
+}): Promise<{ issues: TrackerItem[] }> {
+  const result = await listCachedTrackerItems({
+    trackerType: "jira",
+    limit: input?.limit ?? 500,
+  });
+
+  return {
+    issues: result.issues.map((issue) => ({
+      id: issue.id,
+      trackerId: issue.trackerId || "jira:default",
+      trackerType: "jira",
+      identifier: issue.identifier,
+      title: issue.title,
+      description: issue.description ?? undefined,
+      status: issue.status,
+      statusCategory: issue.statusCategory,
+      assignee: issue.assignee
+        ? { id: issue.assigneeId ?? issue.assignee, name: issue.assignee }
+        : undefined,
+      priority: undefined,
+      labels: issue.labels ?? [],
+      createdAt: issue.pulledAt,
+      updatedAt: issue.updatedAt,
+      url: issue.url ?? "#",
+    })),
+  };
+}
+
+// ── Get detail for a single Jira issue ──────────────────────────────
+
+export async function getJiraIssueDetail(
+  projectId: string,
+  issueIdOrKey: string,
+): Promise<TrackerItemDetail> {
+  const client = await getJiraClient(projectId);
+  if (!client) throw new Error("Not connected to Jira");
+
+  const token = getJiraToken(projectId);
+  const siteUrl = token?.siteUrl ?? "https://example.atlassian.net";
+
+  const rawIssue = await client.getIssue(issueIdOrKey);
+  const item = mapJiraIssue(rawIssue, siteUrl);
+
+  // Get comments
+  const rawComments = rawIssue.fields.comment?.comments ?? [];
+  const comments: TrackerComment[] = rawComments.map((c) => ({
+    id: c.id,
+    body: typeof c.body === "string" ? c.body : adfToPlainText(c.body) ?? "",
+    author: { id: c.author.accountId, name: c.author.displayName },
+    createdAt: c.created,
+  }));
+
+  // Get activity
+  const rawActivity = await client.getActivity(issueIdOrKey);
+  const activity: TrackerActivity[] = rawActivity.map((a) => ({
+    id: a.id,
+    type: "update",
+    description: a.items.map((i) => `${i.field}: ${i.fromString ?? ""} → ${i.toString ?? ""}`).join(", "),
+    actor: { id: a.author.accountId, name: a.author.displayName },
+    createdAt: a.created,
+  }));
+
+  return {
+    ...item,
+    comments,
+    activity,
+    metadata: {
+      projectId: rawIssue.fields.project?.id,
+      projectKey: rawIssue.fields.project?.key,
+      projectName: rawIssue.fields.project?.name,
+      issueType: rawIssue.fields.issuetype?.name,
+      sprintId: rawIssue.fields.customfield_10020?.id,
+      sprintName: rawIssue.fields.customfield_10020?.name,
+    },
+  };
+}

package/cloud-runtime/standalone/apps/local/lib/tracker/adapters/jira/jira-icon.tsx

@@ -0,0 +1,22 @@
+// Client-safe JiraIcon component — no server-only imports.
+// Official Jira logomark.
+export function JiraIcon({ className }: { className?: string }) {
+  return (
+    <svg
+      className={className}
+      viewBox="12 12 104 104"
+      fill="currentColor"
+      xmlns="http://www.w3.org/2000/svg"
+    >
+      <path
+        d="M108.023 16H61.805c0 11.52 9.324 20.848 20.847 20.848h8.5v8.226c0 11.52 9.328 20.848 20.848 20.848V19.977A3.98 3.98 0 00108.023 16zm0 0"
+      />
+      <path
+        d="M85.121 39.04H38.902c0 11.519 9.325 20.847 20.844 20.847h8.504v8.226c0 11.52 9.328 20.848 20.848 20.848V43.016a3.983 3.983 0 00-3.977-3.977zm0 0"
+      />
+      <path
+        d="M62.219 62.078H16c0 11.524 9.324 20.848 20.848 20.848h8.5v8.23c0 11.52 9.328 20.844 20.847 20.844V66.059a3.984 3.984 0 00-3.976-3.98zm0 0"
+      />
+    </svg>
+  );
+}

package/cloud-runtime/standalone/apps/local/lib/tracker/adapters/linear/adapter.tsx

@@ -0,0 +1,307 @@
+// Linear tracker adapter — implements TrackerAdapter by wrapping the
+// existing Linear GraphQL client and issue cache.
+
+import type { TrackerAdapter, McpServerConfig } from "../../tracker-adapter";
+import { getConfiguredAppBaseUrl } from "@/lib/app-config";
+import type {
+  TrackerItem,
+  TrackerItemDetail,
+  TrackerFilters,
+  TrackerItemUpdate,
+  TrackerGroup,
+  TrackerStatusOption,
+  TrackerAssignee,
+  TrackerActivity,
+  ConnectionStatus,
+  TokenResult,
+  PaginatedResult,
+  TrackerStatusCategory,
+} from "../../types";
+import { getLinearClient, getProjectTicketToken } from "./client";
+import type { LinearCycle } from "./client";
+import { LinearIcon } from "./linear-icon";
+export { LinearIcon } from "./linear-icon";
+
+// Linear status → statusCategory mapping
+function linearStatusToCategory(status: string): TrackerStatusCategory {
+  const lower = status.trim().toLowerCase();
+  if (["done", "completed", "closed"].includes(lower)) return "done";
+  if (["cancelled", "canceled", "duplicate"].includes(lower)) return "cancelled";
+  if (["in progress", "in review", "started", "testing", "deployed", "in deployment"].includes(lower)) return "in_progress";
+  return "todo";
+}
+
+// Auth helpers
+function getLinearAuthUrl(projectId: string): string {
+  const appUrl = getConfiguredAppBaseUrl();
+  const port = new URL(appUrl).port || "41741";
+  return `https://www.runagx.com/integrations/linear/auth?port=${port}`;
+}
+
+async function handleLinearCallback(_projectId: string, _code: string): Promise<TokenResult> {
+  // Actual token exchange is handled by the route handler which has access
+  // to cookies and env vars. This method is a placeholder for the interface.
+  throw new Error("Linear OAuth callback must be handled by the route handler");
+}
+
+async function getLinearConnectionStatus(projectId: string): Promise<ConnectionStatus> {
+  const client = getLinearClient(projectId);
+  if (!client) {
+    return { connected: false };
+  }
+  try {
+    const viewer = await client.viewer;
+    return {
+      connected: true,
+      user: { id: viewer.id, name: viewer.name, avatarUrl: undefined },
+    };
+  } catch {
+    return { connected: false };
+  }
+}
+
+async function disconnectLinear(projectId: string): Promise<void> {
+  const { deleteProjectTicketToken } = await import("./client");
+  deleteProjectTicketToken(projectId, "linear");
+}
+
+// Cycle → TrackerGroup mapping
+function cycleToGroup(cycle: LinearCycle): TrackerGroup {
+  return {
+    id: cycle.id,
+    name: cycle.name ?? `Cycle ${cycle.number}`,
+    type: "cycle",
+  };
+}
+
+export class LinearAdapter implements TrackerAdapter {
+  type = "linear" as const;
+  displayName = "Linear";
+  icon = LinearIcon;
+
+  getAuthUrl(projectId: string): string {
+    return getLinearAuthUrl(projectId);
+  }
+
+  async handleCallback(projectId: string, code: string): Promise<TokenResult> {
+    return handleLinearCallback(projectId, code);
+  }
+
+  async getStatus(projectId: string): Promise<ConnectionStatus> {
+    return getLinearConnectionStatus(projectId);
+  }
+
+  async disconnect(projectId: string): Promise<void> {
+    return disconnectLinear(projectId);
+  }
+
+  async listItems(projectId: string, filters: TrackerFilters): Promise<PaginatedResult<TrackerItem>> {
+    const { ensureLinearIssueCache, listLinearIssueSummaries } = await import("./issues");
+    const { getIssueActivityMap } = await import("../../tracker-run-store");
+
+    // Ensure cache is populated
+    const shouldRefresh = !filters.cursor;
+    await ensureLinearIssueCache({ projectId, refresh: shouldRefresh });
+
+    // Build the cache query from tracker-agnostic filters
+    const activityMap = filters.hasActivity
+      ? await getIssueActivityMap(projectId)
+      : undefined;
+
+    // Map statusCategories to raw status names (we query the cache which stores raw statuses)
+    const { listCachedTrackerItems } = await import("../../tracker-item-store");
+    const result = await listCachedTrackerItems({
+      trackerType: "linear",
+      search: filters.search,
+      statuses: filters.statuses,
+      statusCategories: filters.statusCategories,
+      assigneeIds: filters.assigneeIds,
+      groupIds: filters.groupIds, // cycles for Linear
+      cursor: filters.cursor,
+      limit: filters.limit,
+      sortBy: filters.sortBy ?? "activity",
+      sortDir: filters.sortDir,
+      hasActivity: filters.hasActivity,
+      activityMap,
+    });
+
+    return {
+      items: result.issues.map((issue) => ({
+        id: issue.id,
+        trackerId: issue.trackerId || `linear:${issue.teamId ?? "default"}`,
+        trackerType: "linear",
+        identifier: issue.identifier,
+        title: issue.title,
+        description: issue.description ?? undefined,
+        status: issue.status,
+        statusCategory: issue.statusCategory,
+        assignee: issue.assignee
+          ? { id: issue.assigneeId ?? issue.assignee, name: issue.assignee, avatarUrl: undefined }
+          : undefined,
+        priority: undefined,
+        labels: issue.labels ?? [],
+        createdAt: issue.pulledAt,
+        updatedAt: issue.updatedAt,
+        url: issue.url ?? `https://linear.app/issue/${issue.identifier}`,
+      })),
+      pageInfo: result.pageInfo,
+    };
+  }
+
+  async getItem(projectId: string, itemId: string): Promise<TrackerItemDetail> {
+    const { getCachedTrackerItemContexts } = await import("../../tracker-item-store");
+    const contexts = await getCachedTrackerItemContexts([itemId]);
+    const issue = contexts[0];
+    if (!issue) {
+      throw new Error(`Item ${itemId} not found`);
+    }
+
+    return {
+      id: issue.id,
+      trackerId: issue.trackerId || `linear:${issue.teamId ?? "default"}`,
+      trackerType: "linear",
+      identifier: issue.identifier,
+      title: issue.title,
+      description: issue.description ?? undefined,
+      status: issue.status,
+      statusCategory: issue.statusCategory,
+      assignee: issue.assignee
+        ? { id: issue.assigneeId ?? issue.assignee, name: issue.assignee, avatarUrl: undefined }
+        : undefined,
+      labels: issue.labels ?? [],
+      createdAt: issue.pulledAt,
+      updatedAt: issue.updatedAt,
+      url: issue.url ?? `https://linear.app/issue/${issue.identifier}`,
+      comments: [], // Comments require Linear API call — populated on demand
+      activity: [], // Activity requires Linear API call — populated on demand
+      metadata: {
+        teamId: issue.teamId,
+        teamName: issue.teamName,
+        teamKey: issue.teamKey,
+        cycleId: issue.cycleId,
+        cycleName: issue.cycleName,
+        cycleNumber: issue.cycleNumber,
+        isAssignedToMe: issue.isAssignedToMe,
+      },
+    };
+  }
+
+  async updateItem(projectId: string, itemId: string, update: TrackerItemUpdate): Promise<TrackerItem> {
+    const client = getLinearClient(projectId);
+    if (!client) throw new Error("Not connected to Linear");
+
+    if (update.status) {
+      const result = await client.updateIssueStatus(itemId, update.status);
+      // Update the cache
+      const { updateCachedTrackerItemStatus } = await import("../../tracker-item-store");
+      await updateCachedTrackerItemStatus({
+        issueId: itemId,
+        status: result.status ?? update.status,
+        updatedAt: result.updatedAt,
+      });
+
+      return {
+        id: itemId,
+        trackerId: `linear:default`,
+        trackerType: "linear",
+        identifier: result.identifier,
+        title: result.title,
+        status: result.status ?? update.status,
+        statusCategory: linearStatusToCategory(result.status ?? update.status),
+        assignee: result.assignee ? { id: result.assignee, name: result.assignee } : undefined,
+        labels: [],
+        createdAt: result.updatedAt,
+        updatedAt: result.updatedAt,
+        url: result.url ?? `https://linear.app/issue/${result.identifier}`,
+      };
+    }
+
+    throw new Error("Only status updates are currently supported");
+  }
+
+  async addComment(projectId: string, itemId: string, body: string): Promise<void> {
+    // Linear comment API not yet in client — would need GraphQL mutation
+    throw new Error("Linear addComment not yet implemented");
+  }
+
+  async getActivity(projectId: string, itemId: string): Promise<TrackerActivity[]> {
+    // Linear activity API not yet in client — would need GraphQL query
+    return [];
+  }
+
+  async listGroups(projectId: string): Promise<TrackerGroup[]> {
+    const client = getLinearClient(projectId);
+    if (!client) return [];
+    const cycles = await client.cycles();
+    return cycles.map(cycleToGroup);
+  }
+
+  async listStatuses(projectId: string): Promise<TrackerStatusOption[]> {
+    const client = getLinearClient(projectId);
+    if (!client) return [];
+
+    try {
+      const states = await client.workflowStates();
+      const seen = new Set<string>();
+      return states
+        .map((s) => ({
+          id: s.id,
+          name: s.name,
+          category: linearStatusToCategory(s.name),
+        }))
+        .filter((s) => {
+          if (seen.has(s.name)) return false;
+          seen.add(s.name);
+          return true;
+        });
+    } catch {
+      return [
+        { id: "todo", name: "Todo", category: "todo" },
+        { id: "in_progress", name: "In Progress", category: "in_progress" },
+        { id: "done", name: "Done", category: "done" },
+        { id: "cancelled", name: "Cancelled", category: "cancelled" },
+      ];
+    }
+  }
+
+  async listAssignees(projectId: string): Promise<TrackerAssignee[]> {
+    const client = getLinearClient(projectId);
+    if (!client) return [];
+    const users = await client.users();
+    return users.map((user) => ({
+      id: user.id,
+      name: user.name,
+      avatarUrl: undefined,
+    }));
+  }
+
+  async handleApiKeyConnect(projectId: string, apiKey: string): Promise<void> {
+    const { saveProjectTicketToken } = await import("./client");
+    saveProjectTicketToken(projectId, "linear", { accessToken: apiKey });
+  }
+
+  async handleTokenDelivery(projectId: string, params: Record<string, string>): Promise<void> {
+    const accessToken = params.access_token;
+    if (!accessToken) throw new Error("Missing access_token");
+    const { saveProjectTicketToken } = await import("./client");
+    const expiresIn = params.expires_in ? Number(params.expires_in) : undefined;
+    saveProjectTicketToken(projectId, "linear", {
+      accessToken,
+      ...(expiresIn && { expiresAt: Date.now() + expiresIn * 1000 }),
+    });
+  }
+
+  getMcpConfig(projectId: string): McpServerConfig {
+    const token = getProjectTicketToken(projectId, "linear");
+    return {
+      name: "linear",
+      url: "https://mcp.linear.app/sse",
+      headers: token ? { Authorization: `Bearer ${token.accessToken}` } : {},
+    };
+  }
+
+  renderGroupLabel(group: TrackerGroup): string {
+    if (group.type === "cycle") return `Cycle: ${group.name}`;
+    return group.name;
+  }
+}