acdev 1.0.13 → 1.0.15

package/src/github.js

@@ -5,6 +5,63 @@ const execFileAsync = promisify(execFile);
 
 const ISSUE_URL_RE = /github\.com\/([^/]+)\/([^/]+)\/issues\/(\d+)/;
 
+const REPO_FROM_REMOTE_RE =
+  /(?:github\.com[:/]|github\.com\/)([^/]+)\/([^/]+?)(?:\.git)?$/i;
+
+const PROJECT_STATUS_FIELDS_QUERY = `query($owner: String!, $name: String!) {
+  repository(owner: $owner, name: $name) {
+    projectsV2(first: 20) {
+      nodes {
+        id
+        title
+        fields(first: 30) {
+          nodes {
+            __typename
+            ... on ProjectV2SingleSelectField {
+              id
+              name
+              options { id name }
+            }
+          }
+        }
+      }
+    }
+  }
+}`;
+
+const ISSUE_PROJECT_ITEMS_QUERY = `query($owner: String!, $name: String!, $number: Int!) {
+  repository(owner: $owner, name: $name) {
+    issue(number: $number) {
+      id
+      projectItems(first: 20) {
+        nodes {
+          id
+          project { id title }
+        }
+      }
+    }
+  }
+}`;
+
+const ADD_PROJECT_ITEM_MUTATION = `mutation($projectId: ID!, $contentId: ID!) {
+  addProjectV2ItemById(input: { projectId: $projectId, contentId: $contentId }) {
+    item { id }
+  }
+}`;
+
+const SET_PROJECT_STATUS_MUTATION = `mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $optionId: String!) {
+  updateProjectV2ItemFieldValue(
+    input: {
+      projectId: $projectId
+      itemId: $itemId
+      fieldId: $fieldId
+      value: { singleSelectOptionId: $optionId }
+    }
+  ) {
+    projectV2Item { id }
+  }
+}`;
+
 /**
  * @param {string} issueUrl
  * @returns {{ owner: string, repo: string, number: number }}
@@ -18,6 +75,272 @@ export function parseIssueUrl(issueUrl) {
   return { owner, repo, number: Number(number) };
 }
 
+/**
+ * Owner/repo from an origin remote (HTTPS or SSH).
+ * @param {string | null | undefined} remoteUrl
+ * @returns {{ owner: string, repo: string } | null}
+ */
+export function parseGithubRepoFromRemote(remoteUrl) {
+  const raw = String(remoteUrl || '').trim().replace(/\/+$/, '');
+  if (!raw) return null;
+  const match = raw.match(REPO_FROM_REMOTE_RE);
+  if (!match) return null;
+  const owner = match[1];
+  const repo = match[2];
+  if (!owner || !repo) return null;
+  return { owner, repo };
+}
+
+/**
+ * @param {{
+ *   query: string,
+ *   variables?: Record<string, string | number | boolean>,
+ *   cwd: string,
+ *   runGh?: typeof execFileAsync,
+ * }} params
+ */
+async function ghGraphql({ query, variables = {}, cwd, runGh = execFileAsync }) {
+  const args = ['api', 'graphql', '-f', `query=${query}`];
+  for (const [key, value] of Object.entries(variables)) {
+    if (typeof value === 'number' || typeof value === 'boolean') {
+      args.push('-F', `${key}=${value}`);
+    } else {
+      args.push('-f', `${key}=${value}`);
+    }
+  }
+  const { stdout } = await runGh('gh', args, { cwd });
+  const payload = JSON.parse(stdout);
+  if (Array.isArray(payload.errors) && payload.errors.length > 0) {
+    throw new Error(payload.errors.map((e) => e.message || String(e)).join('; '));
+  }
+  return payload.data;
+}
+
+/**
+ * @param {unknown} data
+ * @returns {Array<{
+ *   name: string,
+ *   id?: string,
+ *   projectId?: string,
+ *   projectTitle?: string,
+ *   fieldId?: string,
+ * }>}
+ */
+export function extractProjectStatusOptions(data) {
+  const nodes = data?.repository?.projectsV2?.nodes;
+  const projects = Array.isArray(nodes) ? nodes : [];
+  /** @type {Array<{ name: string, id?: string, projectId?: string, projectTitle?: string, fieldId?: string }>} */
+  const out = [];
+  const seen = new Set();
+  for (const project of projects) {
+    if (!project || typeof project !== 'object') continue;
+    const projectId = project.id != null ? String(project.id) : '';
+    const projectTitle = String(project.title || '').trim();
+    const fields = Array.isArray(project.fields?.nodes) ? project.fields.nodes : [];
+    for (const field of fields) {
+      if (!field || typeof field !== 'object') continue;
+      const fieldName = String(field.name || '').trim();
+      if (!/status/i.test(fieldName)) continue;
+      const fieldId = field.id != null ? String(field.id) : '';
+      const options = Array.isArray(field.options) ? field.options : [];
+      for (const opt of options) {
+        const name = String(opt?.name || '').trim();
+        if (!name) continue;
+        const key = name.toLowerCase();
+        if (seen.has(key)) continue;
+        seen.add(key);
+        out.push({
+          name,
+          ...(opt?.id != null ? { id: String(opt.id) } : {}),
+          ...(projectId ? { projectId } : {}),
+          ...(projectTitle ? { projectTitle } : {}),
+          ...(fieldId ? { fieldId } : {}),
+        });
+      }
+    }
+  }
+  return out;
+}
+
+/**
+ * @param {{
+ *   cwd: string,
+ *   originUrl?: string | null,
+ *   runGh?: typeof execFileAsync,
+ * }} opts
+ * @returns {Promise<{
+ *   ok: true,
+ *   source: 'project' | 'labels',
+ *   statuses: Array<{ name: string, id?: string, projectId?: string, projectTitle?: string, fieldId?: string }>,
+ * } | {
+ *   ok: false,
+ *   error: string,
+ *   statuses: [],
+ * }>}
+ */
+export async function listGithubIssueStatuses(opts) {
+  const runGh = opts.runGh || execFileAsync;
+  const cwd = opts.cwd;
+  const parsed = parseGithubRepoFromRemote(opts.originUrl);
+  try {
+    if (parsed) {
+      try {
+        const data = await ghGraphql({
+          query: PROJECT_STATUS_FIELDS_QUERY,
+          variables: { owner: parsed.owner, name: parsed.repo },
+          cwd,
+          runGh,
+        });
+        const statuses = extractProjectStatusOptions(data);
+        if (statuses.length > 0) {
+          return { ok: true, source: 'project', statuses };
+        }
+      } catch {
+        // Projects v2 may be disabled or unauthorized — try labels.
+      }
+    }
+
+    const { stdout } = await runGh(
+      'gh',
+      ['label', 'list', '--limit', '100', '--json', 'name'],
+      { cwd }
+    );
+    const labels = JSON.parse(stdout);
+    const list = Array.isArray(labels) ? labels : [];
+    const statuses = [];
+    const seen = new Set();
+    for (const label of list) {
+      const name = String(label?.name || '').trim();
+      if (!name) continue;
+      const key = name.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      statuses.push({ name });
+    }
+    if (statuses.length > 0) {
+      return { ok: true, source: 'labels', statuses };
+    }
+    return {
+      ok: false,
+      error: parsed
+        ? 'No GitHub Project Status options or labels found for this repo.'
+        : 'Could not parse origin remote as GitHub owner/repo, and no labels were found.',
+      statuses: [],
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err instanceof Error ? err.message : String(err),
+      statuses: [],
+    };
+  }
+}
+
+/**
+ * Set a GitHub Projects v2 Status field on the issue (add to the first matching
+ * project if needed). Returns ok:false when no Status field matches.
+ * @param {{
+ *   issueNumber: number | string,
+ *   statusName: string,
+ *   cwd: string,
+ *   originUrl?: string | null,
+ *   runGh?: typeof execFileAsync,
+ * }} opts
+ * @returns {Promise<
+ *   | { ok: true, statusName: string, projectTitle?: string }
+ *   | { ok: false, reason: 'no_repo' | 'no_match' | 'error', error: string }
+ * >}
+ */
+export async function setGithubIssueProjectStatus(opts) {
+  const runGh = opts.runGh || execFileAsync;
+  const cwd = opts.cwd;
+  const want = String(opts.statusName || '').trim();
+  const n = Number(opts.issueNumber);
+  if (!want) {
+    return { ok: false, reason: 'no_match', error: 'Status name is required' };
+  }
+  if (!Number.isInteger(n) || n <= 0) {
+    return { ok: false, reason: 'error', error: `Invalid GitHub issue number: ${opts.issueNumber}` };
+  }
+  const parsed = parseGithubRepoFromRemote(opts.originUrl);
+  if (!parsed) {
+    return { ok: false, reason: 'no_repo', error: 'Could not parse GitHub owner/repo from origin remote' };
+  }
+
+  try {
+    const fieldsData = await ghGraphql({
+      query: PROJECT_STATUS_FIELDS_QUERY,
+      variables: { owner: parsed.owner, name: parsed.repo },
+      cwd,
+      runGh,
+    });
+    const options = extractProjectStatusOptions(fieldsData);
+    const match = options.find((s) => s.name.toLowerCase() === want.toLowerCase());
+    if (!match?.projectId || !match.fieldId || !match.id) {
+      return {
+        ok: false,
+        reason: 'no_match',
+        error: `No GitHub Project Status option named "${want}"`,
+      };
+    }
+
+    const issueData = await ghGraphql({
+      query: ISSUE_PROJECT_ITEMS_QUERY,
+      variables: { owner: parsed.owner, name: parsed.repo, number: n },
+      cwd,
+      runGh,
+    });
+    const issue = issueData?.repository?.issue;
+    if (!issue?.id) {
+      return { ok: false, reason: 'error', error: `GitHub issue #${n} not found` };
+    }
+
+    const items = Array.isArray(issue.projectItems?.nodes) ? issue.projectItems.nodes : [];
+    let itemId = '';
+    for (const item of items) {
+      if (item?.project?.id === match.projectId && item.id) {
+        itemId = String(item.id);
+        break;
+      }
+    }
+    if (!itemId) {
+      const added = await ghGraphql({
+        query: ADD_PROJECT_ITEM_MUTATION,
+        variables: { projectId: match.projectId, contentId: String(issue.id) },
+        cwd,
+        runGh,
+      });
+      itemId = String(added?.addProjectV2ItemById?.item?.id || '');
+    }
+    if (!itemId) {
+      return { ok: false, reason: 'error', error: `Could not add issue #${n} to GitHub Project` };
+    }
+
+    await ghGraphql({
+      query: SET_PROJECT_STATUS_MUTATION,
+      variables: {
+        projectId: match.projectId,
+        itemId,
+        fieldId: match.fieldId,
+        optionId: match.id,
+      },
+      cwd,
+      runGh,
+    });
+    return {
+      ok: true,
+      statusName: match.name,
+      projectTitle: match.projectTitle,
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      reason: 'error',
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}
+
 /**
  * Fetch issue title/body/labels via `gh` for branch naming and type detection.
  * @param {string} issueUrl
@@ -70,6 +393,122 @@ export function buildPrCreateArgs({ title, body, baseBranch, branchName, draft =
   return args;
 }
 
+/**
+ * @typedef {{
+ *   ok: true,
+ *   url: string,
+ *   title: string,
+ *   number: number,
+ *   state: string,
+ *   isDraft: boolean,
+ *   reviewDecision: string | null,
+ *   mergeStateStatus: string | null,
+ *   closedAt: string | null,
+ *   mergedAt: string | null,
+ *   author: string | null,
+ *   requestedReviewers: string[],
+ *   latestReviews: Array<{
+ *     author: string | null,
+ *     state: string,
+ *     body: string,
+ *     submittedAt: string | null,
+ *   }>,
+ * }} GithubPrStatusOk
+ *
+ * @typedef {{
+ *   ok: false,
+ *   error: string,
+ * }} GithubPrStatusError
+ *
+ * @typedef {GithubPrStatusOk | GithubPrStatusError} GithubPrStatusResult
+ */
+
+/**
+ * @param {unknown} user
+ * @returns {string | null}
+ */
+function userName(user) {
+  if (!user || typeof user !== 'object') return null;
+  const name = String(user.login || user.name || user.displayName || '').trim();
+  return name || null;
+}
+
+/**
+ * @param {unknown} review
+ * @returns {{ author: string | null, state: string, body: string, submittedAt: string | null } | null}
+ */
+function normalizeReview(review) {
+  if (!review || typeof review !== 'object') return null;
+  const state = String(review.state || '').trim().toUpperCase();
+  const body = String(review.body || '').trim();
+  const submittedAt = String(review.submittedAt || review.createdAt || review.updatedAt || '').trim();
+  return {
+    author: userName(review.author),
+    state: state || 'UNKNOWN',
+    body,
+    submittedAt: submittedAt || null,
+  };
+}
+
+/**
+ * Current GitHub PR review state + summary via `gh pr view`.
+ * @param {{
+ *   prUrl: string,
+ *   cwd: string,
+ *   runGh?: typeof execFileAsync,
+ * }} opts
+ * @returns {Promise<GithubPrStatusResult>}
+ */
+export async function fetchGithubPrStatus({ prUrl, cwd, runGh = execFileAsync }) {
+  const url = String(prUrl || '').trim();
+  if (!url) {
+    return { ok: false, error: 'PR URL is required' };
+  }
+  try {
+    const { stdout } = await runGh(
+      'gh',
+      [
+        'pr',
+        'view',
+        url,
+        '--json',
+        'url,title,number,state,isDraft,reviewDecision,mergeStateStatus,closedAt,mergedAt,author,reviewRequests,latestReviews',
+      ],
+      { cwd }
+    );
+    const raw = JSON.parse(stdout);
+    const latestReviews = Array.isArray(raw.latestReviews)
+      ? raw.latestReviews.map(normalizeReview).filter(Boolean)
+      : [];
+    const requestedReviewers = Array.isArray(raw.reviewRequests || raw.requestedReviewers)
+      ? (raw.reviewRequests || raw.requestedReviewers).map((item) => {
+          if (item && typeof item === 'object' && 'requestedReviewer' in item) {
+            return userName(item.requestedReviewer);
+          }
+          return userName(item);
+        }).filter(Boolean)
+      : [];
+    return {
+      ok: true,
+      url: String(raw.url || url),
+      title: String(raw.title || '').trim(),
+      number: Number(raw.number || 0),
+      state: String(raw.state || '').trim().toUpperCase() || 'UNKNOWN',
+      isDraft: Boolean(raw.isDraft),
+      reviewDecision: String(raw.reviewDecision || '').trim().toUpperCase() || null,
+      mergeStateStatus: String(raw.mergeStateStatus || '').trim().toUpperCase() || null,
+      closedAt: String(raw.closedAt || '').trim() || null,
+      mergedAt: String(raw.mergedAt || '').trim() || null,
+      author: userName(raw.author),
+      requestedReviewers,
+      latestReviews,
+    };
+  } catch (err) {
+    const message = err.stderr?.toString() || err.message || String(err);
+    return { ok: false, error: `Failed to fetch PR status for ${url}: ${message}` };
+  }
+}
+
 /**
  * Create a GitHub PR (draft or ready for review).
  * @param {{
@@ -119,7 +558,6 @@ export async function createPr({
     throw err;
   }
 }
-
 /**
  * Add a label to a GitHub issue via `gh`.
  * @param {number | string} issueNumber

package/src/jira.js

@@ -316,6 +316,184 @@ export async function fetchJiraIssue(key, creds) {
   };
 }
 
+/**
+ * @param {{
+ *   baseUrl: string,
+ *   email: string,
+ *   apiToken: string,
+ *   fetchFn?: typeof fetch,
+ * }} creds
+ * @param {string} path
+ */
+async function jiraGetJson(creds, path) {
+  const fetchFn = creds.fetchFn || fetch;
+  const base = normalizeJiraBaseUrl(creds.baseUrl);
+  const url = `${base}${path.startsWith('/') ? path : `/${path}`}`;
+  const res = await fetchFn(url, {
+    method: 'GET',
+    headers: {
+      Authorization: jiraAuthHeader({
+        email: creds.email,
+        apiToken: creds.apiToken,
+      }),
+      Accept: 'application/json',
+    },
+  });
+  const text = await res.text().catch(() => '');
+  if (!res.ok) {
+    const detail = text ? `: ${text.slice(0, 200)}` : '';
+    const err = new Error(`Jira GET ${path} failed (${res.status} ${res.statusText})${detail}`);
+    err.status = res.status;
+    throw err;
+  }
+  if (!text) return {};
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(`Jira GET ${path} returned invalid JSON`);
+  }
+}
+
+/**
+ * @param {unknown} raw
+ * @returns {Map<string, string>}
+ */
+export function jiraStatusIdNameMap(raw) {
+  const list = Array.isArray(raw)
+    ? raw
+    : raw && typeof raw === 'object' && Array.isArray(/** @type {{ values?: unknown }} */ (raw).values)
+      ? /** @type {{ values: unknown[] }} */ (raw).values
+      : [];
+  /** @type {Map<string, string>} */
+  const map = new Map();
+  for (const item of list) {
+    if (!item || typeof item !== 'object') continue;
+    const obj = /** @type {{ id?: unknown, name?: unknown }} */ (item);
+    const id = obj.id != null ? String(obj.id) : '';
+    const name = String(obj.name || '').trim();
+    if (id && name) map.set(id, name);
+  }
+  return map;
+}
+
+/**
+ * @param {unknown} columns
+ * @param {Map<string, string>} statusNames
+ * @param {string} [boardName]
+ * @returns {Array<{ name: string, id?: string, column?: string, board?: string }>}
+ */
+export function statusesFromBoardColumns(columns, statusNames, boardName) {
+  const cols = Array.isArray(columns) ? columns : [];
+  /** @type {Array<{ name: string, id?: string, column?: string, board?: string }>} */
+  const out = [];
+  const seen = new Set();
+  for (const col of cols) {
+    if (!col || typeof col !== 'object') continue;
+    const colObj = /** @type {{ name?: unknown, statuses?: unknown }} */ (col);
+    const column = String(colObj.name || '').trim();
+    const sts = Array.isArray(colObj.statuses) ? colObj.statuses : [];
+    for (const st of sts) {
+      if (!st || typeof st !== 'object') continue;
+      const obj = /** @type {{ id?: unknown, name?: unknown }} */ (st);
+      const id = obj.id != null ? String(obj.id) : '';
+      const name = String(obj.name || '').trim() || (id ? statusNames.get(id) || '' : '');
+      if (!name) continue;
+      const key = name.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push({
+        name,
+        ...(id ? { id } : {}),
+        ...(column ? { column } : {}),
+        ...(boardName ? { board: boardName } : {}),
+      });
+    }
+  }
+  return out;
+}
+
+/**
+ * Live Jira statuses for the Rules dropdown.
+ * Prefers Agile board column statuses (kanban/scrum); falls back to /rest/api/3/status.
+ * @param {{
+ *   baseUrl: string,
+ *   email: string,
+ *   apiToken: string,
+ *   fetchFn?: typeof fetch,
+ * }} creds
+ * @returns {Promise<{
+ *   ok: true,
+ *   source: 'board' | 'status',
+ *   statuses: Array<{ name: string, id?: string, column?: string, board?: string }>,
+ * } | {
+ *   ok: false,
+ *   error: string,
+ *   statuses: [],
+ * }>}
+ */
+export async function listJiraBoardStatuses(creds) {
+  try {
+    let statusMap = new Map();
+    try {
+      statusMap = jiraStatusIdNameMap(await jiraGetJson(creds, '/rest/api/3/status'));
+    } catch {
+      // Board config sometimes includes status names without this lookup.
+    }
+
+    try {
+      const boards = await jiraGetJson(creds, '/rest/agile/1.0/board?maxResults=50');
+      const values = Array.isArray(boards?.values) ? boards.values : [];
+      /** @type {Array<{ name: string, id?: string, column?: string, board?: string }>} */
+      const statuses = [];
+      const seen = new Set();
+      for (const board of values) {
+        if (!board || board.id == null) continue;
+        const boardName = String(board.name || '').trim();
+        try {
+          const cfg = await jiraGetJson(
+            creds,
+            `/rest/agile/1.0/board/${encodeURIComponent(String(board.id))}/configuration`
+          );
+          const fromBoard = statusesFromBoardColumns(
+            cfg?.columnConfig?.columns,
+            statusMap,
+            boardName
+          );
+          for (const st of fromBoard) {
+            const key = st.name.toLowerCase();
+            if (seen.has(key)) continue;
+            seen.add(key);
+            statuses.push(st);
+          }
+        } catch {
+          // Skip boards the token cannot read.
+        }
+      }
+      if (statuses.length > 0) {
+        return { ok: true, source: 'board', statuses };
+      }
+    } catch {
+      // Agile API missing / 403 — use global status catalog.
+    }
+
+    const statuses = [...statusMap.entries()].map(([id, name]) => ({ name, id }));
+    if (statuses.length > 0) {
+      return { ok: true, source: 'status', statuses };
+    }
+    return {
+      ok: false,
+      error: 'No Jira statuses found. Check board access or Jira Software permissions.',
+      statuses: [],
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err instanceof Error ? err.message : String(err),
+      statuses: [],
+    };
+  }
+}
+
 /**
  * Find a transition whose target status name matches (case-insensitive).
  * @param {Array<{ id?: string, name?: string, to?: { name?: string } }>} transitions