@h-rig/linear-plugin 0.0.6-alpha.100

package/dist/src/linear-issues-source.js

@@ -0,0 +1,361 @@
+// @bun
+// packages/linear-plugin/src/linear-issues-source.ts
+var ISSUE_FIELDS = `
+      id
+      identifier
+      title
+      description
+      priority
+      priorityLabel
+      url
+      state { id name type }
+      labels { nodes { name } }
+      assignee { name email }`;
+var LIST_ISSUES_QUERY = `query RigListIssues($filter: IssueFilter, $first: Int!, $after: String) {
+  issues(filter: $filter, first: $first, after: $after) {
+    pageInfo { hasNextPage endCursor }
+    nodes {${ISSUE_FIELDS}
+    }
+  }
+}`;
+var GET_ISSUE_QUERY = `query RigGetIssue($id: String!) {
+  issue(id: $id) {${ISSUE_FIELDS}
+  }
+}`;
+var RESOLVE_ISSUE_QUERY = `query RigResolveIssue($id: String!) {
+  issue(id: $id) { id }
+}`;
+var ISSUE_DESCRIPTION_QUERY = `query RigIssueDescription($id: String!) {
+  issue(id: $id) { description }
+}`;
+var TEAM_STATES_QUERY = `query RigTeamStates($teamKey: String!) {
+  teams(filter: { key: { eq: $teamKey } }, first: 1) {
+    nodes {
+      id
+      key
+      states { nodes { id name type position } }
+    }
+  }
+}`;
+var ISSUE_UPDATE_MUTATION = `mutation RigIssueUpdate($id: String!, $input: IssueUpdateInput!) {
+  issueUpdate(id: $id, input: $input) { success }
+}`;
+var COMMENT_CREATE_MUTATION = `mutation RigCommentCreate($input: CommentCreateInput!) {
+  commentCreate(input: $input) { success }
+}`;
+function rigStatusForLinearStateType(stateType) {
+  switch (stateType) {
+    case "triage":
+    case "backlog":
+    case "unstarted":
+      return "ready";
+    case "started":
+      return "in_progress";
+    case "completed":
+      return "completed";
+    case "canceled":
+      return "cancelled";
+    default:
+      return "open";
+  }
+}
+function linearStateTypeForRigStatus(status) {
+  switch (status) {
+    case "ready":
+      return "unstarted";
+    case "in_progress":
+    case "under_review":
+    case "ci_fixing":
+    case "merging":
+      return "started";
+    case "closed":
+    case "completed":
+      return "completed";
+    case "cancelled":
+      return "canceled";
+    case "blocked":
+    case "failed":
+    case "needs_attention":
+    case "open":
+      return null;
+    default:
+      return null;
+  }
+}
+var RIG_METADATA_START = "<!-- rig:metadata:start -->";
+var RIG_METADATA_END = "<!-- rig:metadata:end -->";
+function yamlScalar(value) {
+  if (Array.isArray(value)) {
+    return value.length === 0 ? "[]" : `
+${value.map((entry) => `  - ${String(entry)}`).join(`
+`)}`;
+  }
+  if (value && typeof value === "object")
+    return JSON.stringify(value);
+  return String(value);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function updateRigOwnedMetadataBlock(body, metadata) {
+  const rendered = [
+    RIG_METADATA_START,
+    ...Object.entries(metadata).map(([key, value]) => Array.isArray(value) ? `${key}:${yamlScalar(value)}` : `${key}: ${yamlScalar(value)}`),
+    RIG_METADATA_END
+  ].join(`
+`);
+  const pattern = new RegExp(`${escapeRegExp(RIG_METADATA_START)}\\s*[\\s\\S]*?\\s*${escapeRegExp(RIG_METADATA_END)}`);
+  if (pattern.test(body))
+    return body.replace(pattern, rendered);
+  return body.trim().length > 0 ? `${body.trimEnd()}
+
+${rendered}
+` : `${rendered}
+`;
+}
+function labelNamesFor(issue) {
+  return (issue.labels?.nodes ?? []).map((label) => label.name);
+}
+function issueToTask(issue) {
+  const labelNames = labelNamesFor(issue);
+  const scope = labelNames.filter((l) => l.startsWith("scope:")).map((l) => l.slice("scope:".length));
+  const roleLabel = labelNames.find((l) => l.startsWith("role:"));
+  const validators = labelNames.filter((l) => l.startsWith("validator:")).map((l) => l.slice("validator:".length));
+  const description = issue.description ?? "";
+  return {
+    id: issue.identifier,
+    deps: [],
+    status: rigStatusForLinearStateType(issue.state?.type),
+    title: issue.title,
+    body: description,
+    description,
+    ...scope.length > 0 ? { scope } : {},
+    ...roleLabel ? { role: roleLabel.slice("role:".length) } : {},
+    ...validators.length > 0 ? { validators } : {},
+    ...issue.priority !== null && issue.priority !== undefined ? { priority: issue.priority } : {},
+    ...issue.priorityLabel ? { priorityLabel: issue.priorityLabel } : {},
+    ...issue.url ? { url: issue.url } : {},
+    labels: labelNames,
+    externalRef: `linear:${issue.identifier}`,
+    sourceIssueId: issue.identifier,
+    linearIssueId: issue.id,
+    ...issue.state ? { stateName: issue.state.name, stateType: issue.state.type } : {},
+    raw: issue
+  };
+}
+function buildIssueFilter(opts) {
+  const filter = { team: { key: { eq: opts.teamKey } } };
+  if (opts.states && opts.states.length > 0) {
+    filter.state = { name: { in: [...opts.states] } };
+  }
+  const assignee = opts.assignee?.trim();
+  if (assignee) {
+    filter.assignee = assignee.includes("@") ? { email: { eq: assignee } } : { displayName: { eq: assignee } };
+  }
+  if (opts.labels && opts.labels.length > 0) {
+    filter.and = opts.labels.map((name) => ({ labels: { some: { name: { eq: name } } } }));
+  }
+  return filter;
+}
+var DEFAULT_ENDPOINT = "https://api.linear.app/graphql";
+var DEFAULT_PAGE_SIZE = 50;
+var DEFAULT_LIST_LIMIT = 1000;
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function truncateForError(text) {
+  const clean = text.replace(/\s+/g, " ").trim();
+  return clean.length > 300 ? `${clean.slice(0, 300)}\u2026` : clean;
+}
+function isAuthErrorPayload(status, errors) {
+  if (status === 401)
+    return "HTTP 401";
+  for (const error of errors ?? []) {
+    const code = error.extensions?.code ?? "";
+    if (code === "AUTHENTICATION_ERROR" || /authentication/i.test(error.message ?? "")) {
+      return error.message ?? code;
+    }
+  }
+  return null;
+}
+function createGraphQLClient(opts) {
+  const endpoint = opts.endpoint ?? DEFAULT_ENDPOINT;
+  const transport = opts.transport ?? fetch;
+  return {
+    async request(query, variables) {
+      const apiKey = (opts.apiKey ?? process.env.LINEAR_API_KEY)?.trim();
+      if (!apiKey) {
+        throw new Error("Linear task source: no API key configured. Pass apiKey in plugin options or set the LINEAR_API_KEY environment variable.");
+      }
+      const authorization = apiKey.startsWith("lin_oauth_") ? `Bearer ${apiKey}` : apiKey;
+      let response;
+      try {
+        response = await transport(endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: authorization
+          },
+          body: JSON.stringify({ query, variables })
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Linear API request failed (network error): ${message}`, { cause: error });
+      }
+      const text = await response.text();
+      let parsed;
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        parsed = undefined;
+      }
+      const authError = isAuthErrorPayload(response.status, parsed?.errors);
+      if (authError) {
+        throw new Error(`Linear API authentication failed (${authError}). Check that the configured API key (options.apiKey / LINEAR_API_KEY) is a valid Linear key with access to team "${opts.teamKey}".`);
+      }
+      if (!response.ok) {
+        throw new Error(`Linear API request failed (HTTP ${response.status}): ${truncateForError(text)}`);
+      }
+      if (parsed?.errors && parsed.errors.length > 0) {
+        const messages = parsed.errors.map((e) => e.message ?? "unknown error").join("; ");
+        throw new Error(`Linear GraphQL error: ${messages}`);
+      }
+      if (!parsed || parsed.data === undefined || parsed.data === null) {
+        throw new Error(`Linear API returned no data: ${truncateForError(text)}`);
+      }
+      return parsed.data;
+    }
+  };
+}
+function createLinearIssuesTaskSource(opts) {
+  if (!opts.teamKey?.trim()) {
+    throw new Error("createLinearIssuesTaskSource: teamKey is required");
+  }
+  const teamKey = opts.teamKey.trim();
+  const client = createGraphQLClient(opts);
+  const pageSize = Math.min(250, Math.max(1, Math.trunc(opts.pageSize ?? DEFAULT_PAGE_SIZE)));
+  const listLimit = Math.max(1, Math.trunc(opts.listLimit ?? DEFAULT_LIST_LIMIT));
+  let cachedStates = null;
+  const fetchTeamStates = async () => {
+    if (cachedStates)
+      return cachedStates;
+    const data = await client.request(TEAM_STATES_QUERY, { teamKey });
+    const team = data.teams.nodes[0];
+    if (!team) {
+      throw new Error(`Linear team not found for key "${teamKey}" \u2014 check taskSource.options.teamKey.`);
+    }
+    cachedStates = team.states.nodes;
+    return cachedStates;
+  };
+  const resolveStateId = async (stateType) => {
+    const states = await fetchTeamStates();
+    const candidates = states.filter((s) => s.type === stateType).toSorted((a, b) => (a.position ?? 0) - (b.position ?? 0));
+    const target = candidates[0];
+    if (!target) {
+      throw new Error(`Linear team "${teamKey}" has no workflow state of type "${stateType}" \u2014 cannot map this Rig status to a Linear state.`);
+    }
+    return target.id;
+  };
+  const resolveIssueUuid = async (taskId) => {
+    if (UUID_PATTERN.test(taskId))
+      return taskId;
+    const data = await client.request(RESOLVE_ISSUE_QUERY, { id: taskId });
+    if (!data.issue) {
+      throw new Error(`Linear issue not found: ${taskId}`);
+    }
+    return data.issue.id;
+  };
+  const fetchDescription = async (issueUuid) => {
+    const data = await client.request(ISSUE_DESCRIPTION_QUERY, { id: issueUuid });
+    return data.issue?.description ?? "";
+  };
+  const applyIssueUpdate = async (taskId, update) => {
+    const issueUuid = await resolveIssueUuid(taskId);
+    const input = {};
+    if (update.status) {
+      const stateType = linearStateTypeForRigStatus(update.status);
+      if (stateType)
+        input.stateId = await resolveStateId(stateType);
+    }
+    if (update.title?.trim())
+      input.title = update.title.trim();
+    const nextBody = update.metadata ? updateRigOwnedMetadataBlock(update.body ?? await fetchDescription(issueUuid), update.metadata) : update.body;
+    if (nextBody !== undefined)
+      input.description = nextBody;
+    if (Object.keys(input).length > 0) {
+      await client.request(ISSUE_UPDATE_MUTATION, {
+        id: issueUuid,
+        input
+      });
+    }
+    if (update.comment?.trim()) {
+      await client.request(COMMENT_CREATE_MUTATION, {
+        input: { issueId: issueUuid, body: update.comment }
+      });
+    }
+  };
+  const notifyTaskChanged = (id, status) => {
+    opts.onTaskChanged?.({ teamKey, id, ...status ? { status } : {}, reason: "linear-issue-updated" });
+  };
+  return {
+    id: "linear:issues",
+    kind: "linear",
+    async list() {
+      const filter = buildIssueFilter({ ...opts, teamKey });
+      const out = [];
+      let after = null;
+      for (;; ) {
+        const data = await client.request(LIST_ISSUES_QUERY, {
+          filter,
+          first: pageSize,
+          after
+        });
+        out.push(...data.issues.nodes.map(issueToTask));
+        if (out.length > listLimit) {
+          throw new Error(`Linear issue list for team ${teamKey} exceeded the configured limit (${listLimit}); refusing to silently truncate matching issues. Increase taskSource.options.listLimit or narrow states/labels/assignee.`);
+        }
+        if (!data.issues.pageInfo.hasNextPage)
+          break;
+        after = data.issues.pageInfo.endCursor ?? null;
+        if (!after)
+          break;
+      }
+      return out;
+    },
+    async get(id) {
+      try {
+        const data = await client.request(GET_ISSUE_QUERY, { id });
+        return data.issue ? issueToTask(data.issue) : undefined;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (/authentication|API key/i.test(message))
+          throw error;
+        if (/not found|entity not found/i.test(message))
+          return;
+        throw error;
+      }
+    },
+    async updateStatus(id, status) {
+      const stateType = linearStateTypeForRigStatus(status);
+      if (stateType) {
+        const issueUuid = await resolveIssueUuid(id);
+        const stateId = await resolveStateId(stateType);
+        await client.request(ISSUE_UPDATE_MUTATION, {
+          id: issueUuid,
+          input: { stateId }
+        });
+      }
+      notifyTaskChanged(id, status);
+    },
+    async updateTask(id, update) {
+      await applyIssueUpdate(id, update);
+      notifyTaskChanged(id, update.status);
+    }
+  };
+}
+export {
+  updateRigOwnedMetadataBlock,
+  rigStatusForLinearStateType,
+  linearStateTypeForRigStatus,
+  createLinearIssuesTaskSource,
+  RIG_METADATA_START,
+  RIG_METADATA_END
+};

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@h-rig/linear-plugin",
+  "version": "0.0.6-alpha.100",
+  "type": "module",
+  "description": "Rig package",
+  "license": "UNLICENSED",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    }
+  },
+  "engines": {
+    "bun": ">=1.3.11"
+  },
+  "main": "./dist/src/index.js",
+  "module": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "dependencies": {
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.100",
+    "@rig/core": "npm:@h-rig/core@0.0.6-alpha.100",
+    "effect": "4.0.0-beta.78"
+  }
+}