@greeana/jira-dev-workflow 0.1.0

package/src/create-issue.ts

@@ -0,0 +1,191 @@
+import fs from "node:fs/promises";
+
+import { textToAdf } from "./csv";
+import { loadToolEnv, loadWorkflowConfig, readEnv } from "./config";
+import { createJiraClient } from "./jira-client";
+import { saveCurrentIssueState } from "./state";
+
+type CliOptions = {
+  configPath?: string;
+  description?: string;
+  descriptionFilePath?: string;
+  envFilePath?: string;
+  issueTypeOverride?: string;
+  json: boolean;
+  labels: string[];
+  projectKeyOverride?: string;
+  relatedIssues: string[];
+  save: boolean;
+  summary?: string;
+};
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  await loadToolEnv(options.envFilePath);
+  const config = await loadWorkflowConfig(options.configPath);
+  const jira = createJiraClient();
+
+  const projectKey = options.projectKeyOverride ?? config.projectKey ?? readEnv("JIRA_PROJECT_KEY");
+  const issueType = options.issueTypeOverride ?? config.defaultIssueType;
+  const summary = options.summary?.trim();
+  const descriptionText = await resolveDescription(options);
+
+  if (!projectKey) {
+    throw new Error("Set projectKey in .jira-dev-workflow/config.json or pass --project-key.");
+  }
+
+  if (!summary) {
+    throw new Error("Provide --summary.");
+  }
+
+  const createdIssue = await jira.createIssue({
+    description: textToAdf(descriptionText),
+    issueType,
+    labels: options.labels,
+    projectKey,
+    summary,
+  });
+
+  for (const relatedIssue of options.relatedIssues) {
+    await jira.addIssueLink(createdIssue.key, relatedIssue, config.issueLinkType);
+  }
+
+  const browseUrl = jira.getIssueBrowseUrl(createdIssue.key);
+
+  if (options.save) {
+    await saveCurrentIssueState(config, {
+      issueKey: createdIssue.key,
+      summary,
+      url: browseUrl,
+    });
+  }
+
+  const response = {
+    issueKey: createdIssue.key,
+    projectKey,
+    relatedIssues: options.relatedIssues,
+    summary,
+    url: browseUrl,
+  };
+
+  if (options.json) {
+    console.log(JSON.stringify(response, null, 2));
+    return;
+  }
+
+  console.log(`Created ${createdIssue.key}: ${summary}`);
+  console.log(browseUrl);
+
+  if (options.relatedIssues.length > 0) {
+    console.log(`Linked related issues: ${options.relatedIssues.join(", ")}`);
+  }
+}
+
+async function resolveDescription(options: CliOptions): Promise<string> {
+  if (options.descriptionFilePath) {
+    return fs.readFile(options.descriptionFilePath, "utf8");
+  }
+
+  return options.description ?? "";
+}
+
+function parseArgs(args: string[]): CliOptions {
+  const options: CliOptions = {
+    json: false,
+    labels: [],
+    relatedIssues: [],
+    save: true,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (!arg) {
+      continue;
+    }
+
+    if (arg === "--config") {
+      options.configPath = requireNextValue(args, ++index, "--config");
+      continue;
+    }
+
+    if (arg === "--description") {
+      options.description = requireNextValue(args, ++index, "--description");
+      continue;
+    }
+
+    if (arg === "--description-file") {
+      options.descriptionFilePath = requireNextValue(args, ++index, "--description-file");
+      continue;
+    }
+
+    if (arg === "--env-file") {
+      options.envFilePath = requireNextValue(args, ++index, "--env-file");
+      continue;
+    }
+
+    if (arg === "--issue-type") {
+      options.issueTypeOverride = requireNextValue(args, ++index, "--issue-type");
+      continue;
+    }
+
+    if (arg === "--json") {
+      options.json = true;
+      continue;
+    }
+
+    if (arg === "--label") {
+      options.labels.push(requireNextValue(args, ++index, "--label"));
+      continue;
+    }
+
+    if (arg === "--no-save") {
+      options.save = false;
+      continue;
+    }
+
+    if (arg === "--project-key") {
+      options.projectKeyOverride = requireNextValue(args, ++index, "--project-key");
+      continue;
+    }
+
+    if (arg === "--related-issue") {
+      options.relatedIssues.push(requireNextValue(args, ++index, "--related-issue"));
+      continue;
+    }
+
+    if (arg === "--summary") {
+      options.summary = requireNextValue(args, ++index, "--summary");
+      continue;
+    }
+
+    if (arg.startsWith("--")) {
+      throw new Error(`Unknown argument: ${arg}`);
+    }
+
+    if (!options.summary) {
+      options.summary = arg;
+      continue;
+    }
+
+    throw new Error(`Unexpected positional argument: ${arg}`);
+  }
+
+  return options;
+}
+
+function requireNextValue(args: string[], index: number, flagName: string): string {
+  const value = args[index];
+
+  if (!value) {
+    throw new Error(`Missing value for ${flagName}.`);
+  }
+
+  return value;
+}
+
+void main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(message);
+  process.exitCode = 1;
+});

package/src/csv.ts

@@ -0,0 +1,273 @@
+export type CsvRow = Record<string, string>;
+
+type AdfMark = {
+  type: "link";
+  attrs: {
+    href: string;
+  };
+};
+
+type AdfTextNode = {
+  type: "text";
+  text: string;
+  marks?: AdfMark[];
+};
+
+type AdfHardBreakNode = {
+  type: "hardBreak";
+};
+
+type AdfParagraphNode = {
+  type: "paragraph";
+  content: Array<AdfTextNode | AdfHardBreakNode>;
+};
+
+type AdfMediaNode = {
+  type: "media";
+  attrs: {
+    alt?: string;
+    collection: string;
+    height?: number;
+    id: string;
+    type: "file";
+    width?: number;
+  };
+};
+
+type AdfMediaSingleNode = {
+  type: "mediaSingle";
+  attrs: {
+    layout: "align-start" | "align-end" | "center" | "full-width" | "wide" | "wrap-left" | "wrap-right";
+    width?: number;
+    widthType?: "percentage" | "pixel";
+  };
+  content: [AdfMediaNode];
+};
+
+export type AdfDocument = {
+  version: 1;
+  type: "doc";
+  content: Array<AdfParagraphNode | AdfMediaSingleNode>;
+};
+
+const urlPattern = /https?:\/\/[^\s]+/g;
+
+export function parseCsvRows(text: string): CsvRow[] {
+  const rows = parseCsv(text);
+
+  if (rows.length === 0) {
+    return [];
+  }
+
+  const [headerRow, ...dataRows] = rows;
+  const headers = headerRow.map((header) => header.trim());
+
+  return dataRows.map((dataRow, rowIndex) => {
+    if (dataRow.length > headers.length) {
+      throw new Error(
+        `CSV parsing failed: row ${rowIndex + 2} has ${dataRow.length} fields but only ${headers.length} headers.`,
+      );
+    }
+
+    const record: CsvRow = {};
+
+    headers.forEach((header, columnIndex) => {
+      record[header] = dataRow[columnIndex] ?? "";
+    });
+
+    return record;
+  });
+}
+
+export function textToAdf(text: string): AdfDocument | null {
+  const normalized = text.replace(/\r\n/g, "\n").trim();
+
+  if (normalized.length === 0) {
+    return null;
+  }
+
+  const paragraphs = normalized
+    .split(/\n{2,}/)
+    .map((paragraph) => paragraph.trim())
+    .filter((paragraph) => paragraph.length > 0)
+    .map((paragraph) => ({
+      type: "paragraph" as const,
+      content: linesToParagraphContent(paragraph.split("\n")),
+    }));
+
+  if (paragraphs.length === 0) {
+    return null;
+  }
+
+  return {
+    version: 1,
+    type: "doc",
+    content: paragraphs,
+  };
+}
+
+export function adfToPlainText(value: unknown): string {
+  if (!value || typeof value !== "object") {
+    return "";
+  }
+
+  const document = value as { content?: unknown[] };
+  return extractAdfText(document.content ?? []).trim();
+}
+
+function parseCsv(text: string): string[][] {
+  const rows: string[][] = [];
+  const normalized = text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+
+  let row: string[] = [];
+  let field = "";
+  let inQuotes = false;
+
+  for (let index = 0; index < normalized.length; index += 1) {
+    const char = normalized[index];
+
+    if (inQuotes) {
+      if (char === "\"") {
+        if (normalized[index + 1] === "\"") {
+          field += "\"";
+          index += 1;
+          continue;
+        }
+
+        inQuotes = false;
+        continue;
+      }
+
+      field += char;
+      continue;
+    }
+
+    if (char === "\"") {
+      inQuotes = true;
+      continue;
+    }
+
+    if (char === ",") {
+      row.push(field);
+      field = "";
+      continue;
+    }
+
+    if (char === "\r" || char === "\n") {
+      if (char === "\r" && normalized[index + 1] === "\n") {
+        index += 1;
+      }
+
+      row.push(field);
+      rows.push(row);
+      row = [];
+      field = "";
+      continue;
+    }
+
+    field += char;
+  }
+
+  if (inQuotes) {
+    throw new Error("CSV parsing failed: unterminated quoted field.");
+  }
+
+  if (field.length > 0 || row.length > 0) {
+    row.push(field);
+    rows.push(row);
+  }
+
+  while (rows.length > 0 && rows[rows.length - 1]!.every((cell) => cell.trim() === "")) {
+    rows.pop();
+  }
+
+  return rows;
+}
+
+function linesToParagraphContent(lines: string[]): Array<AdfTextNode | AdfHardBreakNode> {
+  const content: Array<AdfTextNode | AdfHardBreakNode> = [];
+
+  lines.forEach((line, lineIndex) => {
+    if (lineIndex > 0) {
+      content.push({ type: "hardBreak" });
+    }
+
+    const nodes = lineToTextNodes(line);
+
+    if (nodes.length === 0) {
+      content.push({ type: "text", text: "" });
+      return;
+    }
+
+    content.push(...nodes);
+  });
+
+  return content;
+}
+
+function lineToTextNodes(line: string): AdfTextNode[] {
+  const nodes: AdfTextNode[] = [];
+  let lastIndex = 0;
+
+  for (const match of line.matchAll(urlPattern)) {
+    const startIndex = match.index ?? 0;
+    const url = match[0];
+
+    if (startIndex > lastIndex) {
+      nodes.push({
+        type: "text",
+        text: line.slice(lastIndex, startIndex),
+      });
+    }
+
+    nodes.push({
+      type: "text",
+      text: url,
+      marks: [
+        {
+          type: "link",
+          attrs: {
+            href: url,
+          },
+        },
+      ],
+    });
+
+    lastIndex = startIndex + url.length;
+  }
+
+  if (lastIndex < line.length) {
+    nodes.push({
+      type: "text",
+      text: line.slice(lastIndex),
+    });
+  }
+
+  return nodes;
+}
+
+function extractAdfText(nodes: unknown[]): string {
+  return nodes
+    .map((node) => {
+      if (!node || typeof node !== "object") {
+        return "";
+      }
+
+      const typedNode = node as { type?: string; text?: string; content?: unknown[] };
+
+      if (typedNode.type === "text") {
+        return typedNode.text ?? "";
+      }
+
+      if (typedNode.type === "hardBreak") {
+        return "\n";
+      }
+
+      if (Array.isArray(typedNode.content)) {
+        return extractAdfText(typedNode.content);
+      }
+
+      return "";
+    })
+    .join("");
+}

package/src/find-issue.ts

@@ -0,0 +1,172 @@
+import { getDiffSearchText } from "./git";
+import { loadToolEnv, loadWorkflowConfig, readEnv } from "./config";
+import { createJiraClient } from "./jira-client";
+import { searchIssuesForText } from "./issue-search";
+
+type CliOptions = {
+  configPath?: string;
+  envFilePath?: string;
+  fromDiff: boolean;
+  json: boolean;
+  limit?: number;
+  projectKeyOverride?: string;
+  staged: boolean;
+  text?: string;
+};
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  await loadToolEnv(options.envFilePath);
+  const config = await loadWorkflowConfig(options.configPath);
+  const projectKey = options.projectKeyOverride ?? config.projectKey ?? readEnv("JIRA_PROJECT_KEY");
+
+  if (!projectKey) {
+    throw new Error("Set projectKey in .jira-dev-workflow/config.json or pass --project-key.");
+  }
+
+  const searchText = options.text?.trim() || (options.fromDiff ? await getDiffSearchText({ fromDiff: true, staged: options.staged }) : "");
+
+  if (!searchText) {
+    throw new Error("Provide --text or use --from-diff.");
+  }
+
+  const searchLimit = options.limit ?? config.searchLimit;
+  const jira = createJiraClient();
+  const searchResult = await searchIssuesForText({
+    jira,
+    limit: searchLimit,
+    projectKey,
+    searchText,
+  });
+
+  const response = {
+    ...searchResult,
+    projectKey,
+    query: searchText,
+  };
+
+  if (options.json) {
+    console.log(JSON.stringify(response, null, 2));
+    return;
+  }
+
+  console.log(`Project: ${projectKey}`);
+  console.log(`Query: ${searchText}`);
+  console.log("");
+
+  if (response.openMatches.length > 0) {
+    console.log("Open matches:");
+    for (const match of response.openMatches) {
+      console.log(`- ${match.issueKey} [score ${match.score}] ${match.summary}`);
+    }
+  } else {
+    console.log("Open matches: none");
+  }
+
+  console.log("");
+
+  if (response.closedMatches.length > 0) {
+    console.log("Closed matches:");
+    for (const match of response.closedMatches) {
+      console.log(`- ${match.issueKey} [score ${match.score}] ${match.summary}`);
+    }
+  } else {
+    console.log("Closed matches: none");
+  }
+
+  console.log("");
+  console.log(`Recommended action: ${response.recommendedAction}`);
+
+  if (response.recommendedOpenIssueKey) {
+    console.log(`Recommended open issue: ${response.recommendedOpenIssueKey}`);
+  }
+
+  if (response.recommendedClosedIssueKey) {
+    console.log(`Recommended related closed issue: ${response.recommendedClosedIssueKey}`);
+  }
+}
+
+function parseArgs(args: string[]): CliOptions {
+  const options: CliOptions = {
+    fromDiff: false,
+    json: false,
+    staged: true,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (!arg) {
+      continue;
+    }
+
+    if (arg === "--config") {
+      options.configPath = requireNextValue(args, ++index, "--config");
+      continue;
+    }
+
+    if (arg === "--env-file") {
+      options.envFilePath = requireNextValue(args, ++index, "--env-file");
+      continue;
+    }
+
+    if (arg === "--from-diff") {
+      options.fromDiff = true;
+      continue;
+    }
+
+    if (arg === "--json") {
+      options.json = true;
+      continue;
+    }
+
+    if (arg === "--limit") {
+      options.limit = Number.parseInt(requireNextValue(args, ++index, "--limit"), 10);
+      continue;
+    }
+
+    if (arg === "--project-key") {
+      options.projectKeyOverride = requireNextValue(args, ++index, "--project-key");
+      continue;
+    }
+
+    if (arg === "--text") {
+      options.text = requireNextValue(args, ++index, "--text");
+      continue;
+    }
+
+    if (arg === "--working-tree") {
+      options.staged = false;
+      continue;
+    }
+
+    if (arg === "--staged") {
+      options.staged = true;
+      continue;
+    }
+
+    if (arg.startsWith("--")) {
+      throw new Error(`Unknown argument: ${arg}`);
+    }
+
+    options.text = arg;
+  }
+
+  return options;
+}
+
+function requireNextValue(args: string[], index: number, flagName: string): string {
+  const value = args[index];
+
+  if (!value) {
+    throw new Error(`Missing value for ${flagName}.`);
+  }
+
+  return value;
+}
+
+void main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(message);
+  process.exitCode = 1;
+});

package/src/git.ts

@@ -0,0 +1,59 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+export type DiffContext = {
+  changedFiles: string[];
+  combinedText: string;
+  patchHighlights: string[];
+};
+
+export async function getDiffContext({ staged }: { staged: boolean }): Promise<DiffContext> {
+  const nameArgs = staged ? ["diff", "--staged", "--name-only"] : ["diff", "--name-only"];
+  const patchArgs = staged
+    ? ["diff", "--staged", "--unified=0", "--no-color"]
+    : ["diff", "--unified=0", "--no-color"];
+
+  const [{ stdout: fileNames }, { stdout: patch }] = await Promise.all([
+    execFileAsync("git", nameArgs, { cwd: process.cwd() }),
+    execFileAsync("git", patchArgs, { cwd: process.cwd(), maxBuffer: 1024 * 1024 * 4 }),
+  ]);
+
+  const changedFiles = fileNames
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+
+  const patchHighlights = patch
+    .split(/\r?\n/)
+    .filter((line) => line.startsWith("+") || line.startsWith("@@"))
+    .map((line) => line.replace(/^[+@ -]+/, "").trim())
+    .filter(Boolean)
+    .slice(0, 80);
+
+  const combinedText = [...changedFiles, ...patchHighlights].join("\n").trim();
+
+  if (!combinedText) {
+    throw new Error(staged ? "No staged changes found." : "No working tree changes found.");
+  }
+
+  return {
+    changedFiles,
+    combinedText,
+    patchHighlights,
+  };
+}
+
+export async function getDiffSearchText({ fromDiff, staged }: { fromDiff: boolean; staged: boolean }): Promise<string> {
+  if (!fromDiff) {
+    throw new Error("Diff extraction requires --from-diff.");
+  }
+
+  const context = await getDiffContext({ staged });
+  return context.combinedText;
+}
+
+export async function commitWithMessage(message: string) {
+  await execFileAsync("git", ["commit", "-m", message], { cwd: process.cwd(), maxBuffer: 1024 * 1024 * 4 });
+}