@meetopenbot/linear 0.0.3 → 0.0.4

package/src/linear-agent.ts

@@ -1,107 +0,0 @@
-import { createOpenAI } from "@ai-sdk/openai";
-import { generateText, stepCountIs } from "ai";
-import type { LinearIssue } from "./linear-issues.js";
-import { extractIssuesFromToolResults } from "./linear-issues.js";
-import { createLinearMcpClient } from "./linear-mcp.js";
-
-export type RunLinearAgentArgs = {
-  prompt: string;
-  openaiApiKey: string;
-  accessToken: string;
-  model?: string;
-};
-
-export type LinearAgentResult = {
-  text: string;
-  issues: LinearIssue[];
-  usedTools: boolean;
-  toolErrors: string[];
-};
-
-const SYSTEM_PROMPT = `You are the OpenBot Linear specialist agent.
-You MUST use the provided Linear MCP tools for every request about issues, projects, teams, or comments.
-Never guess or invent Linear data. If a tool returns no results, say so explicitly.
-For listing or searching issues, call linear_get_user first when the user asks for issues assigned to them, then call linear_search_issues with the correct filters.
-Summarize tool results clearly in plain text. Be concise and friendly.`;
-
-function extractToolErrors(
-  toolResults: Array<{ toolName: string; output: unknown }>,
-): string[] {
-  const errors: string[] = [];
-
-  for (const toolResult of toolResults) {
-    const output = toolResult.output;
-    if (!output || typeof output !== "object") continue;
-
-    const record = output as Record<string, unknown>;
-    if (typeof record.error === "string") {
-      errors.push(`${toolResult.toolName}: ${record.error}`);
-      continue;
-    }
-
-    if (typeof record.isError === "boolean" && record.isError) {
-      const text =
-        typeof record.text === "string"
-          ? record.text
-          : JSON.stringify(record).slice(0, 300);
-      errors.push(`${toolResult.toolName}: ${text}`);
-    }
-  }
-
-  return errors;
-}
-
-export async function runLinearAgent(
-  args: RunLinearAgentArgs,
-): Promise<LinearAgentResult> {
-  const openai = createOpenAI({ apiKey: args.openaiApiKey });
-  const mcpClient = await createLinearMcpClient({
-    accessToken: args.accessToken,
-  });
-
-  try {
-    const tools = await mcpClient.tools();
-    if (Object.keys(tools).length === 0) {
-      throw new Error(
-        "Linear MCP server returned no tools. Check that mcp-server-linear is installed and reachable.",
-      );
-    }
-
-    const result = await generateText({
-      model: openai(args.model ?? "gpt-4o-mini"),
-      system: SYSTEM_PROMPT,
-      prompt: args.prompt,
-      tools,
-      stopWhen: stepCountIs(10),
-    });
-
-    const toolResults = result.steps.flatMap((step) =>
-      step.toolResults.map((toolResult) => ({
-        toolName: toolResult.toolName,
-        output: toolResult.output,
-      })),
-    );
-
-    const issues = extractIssuesFromToolResults(toolResults);
-    const toolErrors = extractToolErrors(toolResults);
-    const text = result.text.trim();
-
-    if (!text && toolErrors.length > 0) {
-      return {
-        text: `Linear tool error: ${toolErrors[0]}`,
-        issues,
-        usedTools: toolResults.length > 0,
-        toolErrors,
-      };
-    }
-
-    return {
-      text: text || (issues.length > 0 ? `Found ${issues.length} issue(s).` : "Done."),
-      issues,
-      usedTools: toolResults.length > 0,
-      toolErrors,
-    };
-  } finally {
-    await mcpClient.close();
-  }
-}

package/src/linear-issues.ts

@@ -1,188 +0,0 @@
-import type { RenderUIWidgetData } from "@meetopenbot/plugin-sdk";
-
-export type LinearIssue = {
-  id: string;
-  identifier: string;
-  title: string;
-  url: string;
-  state?: { name: string; type: string };
-  assignee?: { name: string };
-  team?: { name: string; key: string };
-  project?: { name: string };
-};
-
-const OPEN_URL_ACTION_ID = "open_url";
-export const ISSUES_LIST_WIDGET_ID = "linear-issues-list";
-
-type LinearStateType =
-  | "backlog"
-  | "unstarted"
-  | "started"
-  | "completed"
-  | "canceled"
-  | string;
-
-function mapStateStatus(
-  stateType?: LinearStateType,
-): "pending" | "in_progress" | "done" | "cancelled" | undefined {
-  switch (stateType) {
-    case "started":
-      return "in_progress";
-    case "completed":
-      return "done";
-    case "canceled":
-      return "cancelled";
-    case "backlog":
-    case "unstarted":
-      return "pending";
-    default:
-      return undefined;
-  }
-}
-
-export function buildIssuesListWidget(
-  issues: LinearIssue[],
-  options?: { title?: string; description?: string },
-): RenderUIWidgetData {
-  return {
-    kind: "list",
-    widgetId: ISSUES_LIST_WIDGET_ID,
-    title: options?.title ?? "Linear issues",
-    description:
-      options?.description ??
-      (issues.length === 0
-        ? "No issues matched this query."
-        : `${issues.length} issue${issues.length === 1 ? "" : "s"}`),
-    items: issues.map((issue) => {
-      const details = [
-        issue.state?.name,
-        issue.assignee?.name ? `Assignee: ${issue.assignee.name}` : undefined,
-        issue.team?.name,
-        issue.project?.name,
-      ]
-        .filter(Boolean)
-        .join(" · ");
-
-      return {
-        id: issue.id,
-        label: `${issue.identifier}: ${issue.title}`,
-        description: details || undefined,
-        badge: issue.state?.name,
-        status: mapStateStatus(issue.state?.type),
-        actions: issue.url
-          ? [
-              {
-                id: OPEN_URL_ACTION_ID,
-                label: "Open",
-                variant: "secondary" as const,
-                value: { url: issue.url, target: "_blank" },
-              },
-            ]
-          : undefined,
-        metadata: {
-          identifier: issue.identifier,
-          url: issue.url,
-        },
-      };
-    }),
-  };
-}
-
-function extractTextPayload(value: unknown): string | undefined {
-  if (typeof value === "string") return value;
-  if (!value || typeof value !== "object") return undefined;
-
-  const record = value as Record<string, unknown>;
-  if (typeof record.text === "string") return record.text;
-
-  if (Array.isArray(record.content)) {
-    for (const part of record.content) {
-      if (
-        part &&
-        typeof part === "object" &&
-        (part as { type?: string }).type === "text" &&
-        typeof (part as { text?: string }).text === "string"
-      ) {
-        return (part as { text: string }).text;
-      }
-    }
-  }
-
-  return undefined;
-}
-
-function parseIssuesPayload(payload: unknown): LinearIssue[] {
-  if (!payload || typeof payload !== "object") return [];
-
-  const root = payload as Record<string, unknown>;
-  const issuesNode =
-    (root.issues as { nodes?: unknown[] } | undefined) ??
-    ((root.data as Record<string, unknown> | undefined)?.issues as
-      | { nodes?: unknown[] }
-      | undefined);
-
-  if (!issuesNode?.nodes || !Array.isArray(issuesNode.nodes)) return [];
-
-  return issuesNode.nodes
-    .filter((node): node is LinearIssue => {
-      if (!node || typeof node !== "object") return false;
-      const issue = node as LinearIssue;
-      return (
-        typeof issue.id === "string" &&
-        typeof issue.identifier === "string" &&
-        typeof issue.title === "string"
-      );
-    })
-    .map((issue) => ({
-      ...issue,
-      url: typeof issue.url === "string" ? issue.url : "",
-    }));
-}
-
-export function extractIssuesFromToolResults(
-  toolResults: Array<{ toolName: string; output: unknown }>,
-): LinearIssue[] {
-  const byId = new Map<string, LinearIssue>();
-
-  for (const toolResult of toolResults) {
-    if (!toolResult.toolName.includes("search_issues")) continue;
-
-    const text = extractTextPayload(toolResult.output);
-    if (!text) continue;
-
-    try {
-      for (const issue of parseIssuesPayload(JSON.parse(text))) {
-        byId.set(issue.id, issue);
-      }
-    } catch {
-      // Ignore malformed tool payloads.
-    }
-  }
-
-  return [...byId.values()];
-}
-
-export function isListIssuesPrompt(message: string): boolean {
-  const normalized = message.trim().toLowerCase();
-  if (!normalized) return false;
-
-  return (
-    /\b(list|show|get|fetch|what are|available)\b/.test(normalized) &&
-    /\bissues?\b/.test(normalized)
-  );
-}
-
-export function isAssignedIssuesPrompt(message: string): boolean {
-  const normalized = message.trim().toLowerCase();
-  return (
-    /\b(assigned to me|my issues|issues for me|issues assigned)\b/.test(
-      normalized,
-    ) || /\bissues?\s+assigned\b/.test(normalized)
-  );
-}
-
-export function issuesListTitle(prompt: string): string {
-  return isAssignedIssuesPrompt(prompt)
-    ? "Issues assigned to you"
-    : "Linear issues";
-}

package/src/linear-mcp.ts

@@ -1,33 +0,0 @@
-import { createRequire } from "node:module";
-import { createMCPClient } from "@ai-sdk/mcp";
-import { Experimental_StdioMCPTransport } from "@ai-sdk/mcp/mcp-stdio";
-
-export type LinearMcpClientArgs = {
-  accessToken: string;
-};
-
-const require = createRequire(import.meta.url);
-
-function resolveMcpServerLinearLaunch(): { command: string; args: string[] } {
-  try {
-    const entry = require.resolve("mcp-server-linear");
-    return { command: process.execPath, args: [entry] };
-  } catch {
-    return { command: "npx", args: ["-y", "mcp-server-linear"] };
-  }
-}
-
-export async function createLinearMcpClient(args: LinearMcpClientArgs) {
-  const launch = resolveMcpServerLinearLaunch();
-
-  return createMCPClient({
-    transport: new Experimental_StdioMCPTransport({
-      command: launch.command,
-      args: launch.args,
-      env: {
-        ...process.env,
-        LINEAR_ACCESS_TOKEN: args.accessToken,
-      },
-    }),
-  });
-}

package/src/oauth-pending.ts

@@ -1,68 +0,0 @@
-import type { Storage } from "@meetopenbot/plugin-sdk";
-
-export const VAR_OAUTH_PENDING = "LINEAR_OAUTH_PENDING";
-
-export interface PendingOAuthSession {
-  state: string;
-  codeVerifier: string;
-  clientId: string;
-  clientSecret?: string;
-  redirectUri: string;
-  expiresAt: number;
-}
-
-type VariableValue = string | { value: string; secret: boolean } | undefined;
-
-function variableValue(
-  variables: Record<string, VariableValue>,
-  key: string,
-): string | undefined {
-  const entry = variables[key];
-  if (typeof entry === "string") return entry || undefined;
-  return entry?.value || undefined;
-}
-
-export async function savePendingOAuthSession(
-  storage: Storage,
-  session: PendingOAuthSession,
-): Promise<void> {
-  await storage.createVariable({
-    key: VAR_OAUTH_PENDING,
-    value: JSON.stringify(session),
-    secret: true,
-  });
-}
-
-export async function loadPendingOAuthSession(
-  storage: Storage,
-): Promise<PendingOAuthSession | null> {
-  const variables = (await storage.getVariables().catch(() => ({}))) as Record<
-    string,
-    VariableValue
-  >;
-  const raw =
-    variableValue(variables, VAR_OAUTH_PENDING) ??
-    process.env[VAR_OAUTH_PENDING];
-  if (!raw) return null;
-
-  try {
-    const session = JSON.parse(raw) as PendingOAuthSession;
-    if (
-      typeof session.state !== "string" ||
-      typeof session.codeVerifier !== "string" ||
-      typeof session.clientId !== "string" ||
-      typeof session.redirectUri !== "string" ||
-      typeof session.expiresAt !== "number"
-    ) {
-      return null;
-    }
-    if (Date.now() > session.expiresAt) return null;
-    return session;
-  } catch {
-    return null;
-  }
-}
-
-export async function clearPendingOAuthSession(storage: Storage): Promise<void> {
-  await storage.deleteVariable({ key: VAR_OAUTH_PENDING }).catch(() => {});
-}