@greeana/jira-dev-workflow 0.1.0

package/src/add-comment.ts

@@ -0,0 +1,177 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+import { loadToolEnv, loadWorkflowConfig } from "./config";
+import { createJiraClient } from "./jira-client";
+import { loadCurrentIssueState } from "./state";
+import { buildCommentAdf, type InlineMediaItem } from "./comment-adf";
+import { getImageDimensions } from "./image-dimensions";
+
+type CliOptions = {
+  configPath?: string;
+  envFilePath?: string;
+  filePaths: string[];
+  inlineFilePaths: string[];
+  issueKey?: string;
+  json: boolean;
+  text?: string;
+  textFilePath?: 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 currentIssue = await loadCurrentIssueState(config);
+  const issueKey = options.issueKey ?? currentIssue?.issueKey;
+
+  if (!issueKey) {
+    throw new Error("Pass --issue or set the current issue first with jira-dev-workflow use.");
+  }
+
+  const baseText = await resolveCommentText(options);
+  const inlineMedia = await uploadInlineMedia(jira, issueKey, options.inlineFilePaths);
+  const comment = buildCommentAdf({
+    attachmentFileNames: options.filePaths,
+    inlineMedia,
+    text: baseText,
+  });
+
+  if (!comment) {
+    throw new Error("Pass --text, --text-file, --file, or --inline-file.");
+  }
+
+  for (const filePath of options.filePaths) {
+    await jira.attachFile(issueKey, filePath);
+  }
+
+  await jira.addComment(issueKey, comment);
+
+  const response = {
+    attachedFiles: options.filePaths,
+    inlineFiles: options.inlineFilePaths,
+    issueKey,
+    text: baseText,
+  };
+
+  if (options.json) {
+    console.log(JSON.stringify(response, null, 2));
+    return;
+  }
+
+  console.log(`Added comment to ${issueKey}`);
+}
+
+async function resolveCommentText(options: CliOptions): Promise<string> {
+  if (options.textFilePath) {
+    return fs.readFile(options.textFilePath, "utf8");
+  }
+
+  return options.text ?? "";
+}
+
+function parseArgs(args: string[]): CliOptions {
+  const options: CliOptions = {
+    filePaths: [],
+    inlineFilePaths: [],
+    json: false,
+  };
+
+  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 === "--issue") {
+      options.issueKey = requireNextValue(args, ++index, "--issue");
+      continue;
+    }
+
+    if (arg === "--file") {
+      options.filePaths.push(requireNextValue(args, ++index, "--file"));
+      continue;
+    }
+
+    if (arg === "--inline-file") {
+      options.inlineFilePaths.push(requireNextValue(args, ++index, "--inline-file"));
+      continue;
+    }
+
+    if (arg === "--json") {
+      options.json = true;
+      continue;
+    }
+
+    if (arg === "--text") {
+      options.text = requireNextValue(args, ++index, "--text");
+      continue;
+    }
+
+    if (arg === "--text-file") {
+      options.textFilePath = requireNextValue(args, ++index, "--text-file");
+      continue;
+    }
+
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  return options;
+}
+
+async function uploadInlineMedia(
+  jira: ReturnType<typeof createJiraClient>,
+  issueKey: string,
+  inlineFilePaths: string[],
+): Promise<InlineMediaItem[]> {
+  const inlineMedia: InlineMediaItem[] = [];
+
+  for (const filePath of inlineFilePaths) {
+    const uploaded = await jira.attachFile(issueKey, filePath);
+    const attachment = uploaded[0];
+
+    if (!attachment?.content) {
+      throw new Error(`Jira did not return an attachment content URL for inline file ${filePath}.`);
+    }
+
+    const mediaId = await jira.resolveMediaIdFromAttachmentContentUrl(attachment.content);
+    const dimensions = await getImageDimensions(filePath);
+
+    inlineMedia.push({
+      collection: "",
+      dimensions,
+      fileName: attachment.filename ?? path.basename(filePath),
+      mediaId,
+    });
+  }
+
+  return inlineMedia;
+}
+
+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/attach-file.ts

@@ -0,0 +1,86 @@
+import { loadToolEnv, loadWorkflowConfig } from "./config";
+import { createJiraClient } from "./jira-client";
+import { loadCurrentIssueState } from "./state";
+
+type CliOptions = {
+  configPath?: string;
+  envFilePath?: string;
+  filePaths: string[];
+  issueKey?: 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 currentIssue = await loadCurrentIssueState(config);
+  const issueKey = options.issueKey ?? currentIssue?.issueKey;
+
+  if (!issueKey) {
+    throw new Error("Pass --issue or set the current issue first with jira-dev-workflow use.");
+  }
+
+  if (options.filePaths.length === 0) {
+    throw new Error("Pass at least one --file.");
+  }
+
+  for (const filePath of options.filePaths) {
+    await jira.attachFile(issueKey, filePath);
+    console.log(`Attached ${filePath} -> ${issueKey}`);
+  }
+}
+
+function parseArgs(args: string[]): CliOptions {
+  const options: CliOptions = {
+    filePaths: [],
+  };
+
+  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 === "--file") {
+      options.filePaths.push(requireNextValue(args, ++index, "--file"));
+      continue;
+    }
+
+    if (arg === "--issue") {
+      options.issueKey = requireNextValue(args, ++index, "--issue");
+      continue;
+    }
+
+    throw new Error(`Unknown 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/comment-adf.ts

@@ -0,0 +1,151 @@
+import path from "node:path";
+
+import { textToAdf, type AdfDocument } from "./csv";
+import type { ImageDimensions } from "./image-dimensions";
+
+export type InlineMediaItem = {
+  collection?: string;
+  dimensions: ImageDimensions;
+  fileName: string;
+  mediaId: string;
+};
+
+export function buildCommentAdf(input: {
+  attachmentFileNames?: string[];
+  inlineMedia?: InlineMediaItem[];
+  text?: string;
+}): AdfDocument | null {
+  const baseText = buildCommentBody(input.text ?? "", input.attachmentFileNames ?? []);
+  const inlineMedia = input.inlineMedia ?? [];
+
+  const content = buildCommentContent(baseText, inlineMedia);
+
+  if (content.length === 0) {
+    return null;
+  }
+
+  return {
+    version: 1,
+    type: "doc",
+    content,
+  };
+}
+
+export function buildCommentBody(text: string, filePaths: string[]): string {
+  const normalizedText = text.trim();
+  const fileNames = filePaths.map((filePath) => path.basename(filePath)).filter(Boolean);
+
+  if (fileNames.length === 0) {
+    return normalizedText;
+  }
+
+  const attachmentSection = ["Attached files:", ...fileNames.map((fileName) => `- ${fileName}`)].join("\n");
+
+  if (!normalizedText) {
+    return attachmentSection;
+  }
+
+  return `${normalizedText}\n\n${attachmentSection}`;
+}
+
+function buildCommentContent(text: string, inlineMedia: InlineMediaItem[]) {
+  if (inlineMedia.length === 0) {
+    return textToAdf(text)?.content ?? [];
+  }
+
+  const normalized = text.replace(/\r\n/g, "\n").trim();
+
+  if (!normalized) {
+    return inlineMedia.map((item) => inlineMediaToNode(item));
+  }
+
+  const usedIndexes = new Set<number>();
+  const blocks = normalized
+    .split(/\n{2,}/)
+    .map((block) => block.trim())
+    .filter((block) => block.length > 0);
+  const content: NonNullable<AdfDocument["content"]> = [];
+  let nextSequentialInlineIndex = 0;
+
+  blocks.forEach((block) => {
+    const inlineReference = parseInlineMediaPlaceholder(block);
+
+    if (!inlineReference) {
+      const blockDocument = textToAdf(block);
+
+      if (blockDocument?.content?.length) {
+        content.push(...blockDocument.content);
+      }
+
+      return;
+    }
+
+    const inlineIndex = inlineReference.sequential ? nextSequentialInlineIndex++ : inlineReference.index;
+
+    if (inlineIndex >= 0 && inlineIndex < inlineMedia.length) {
+      content.push(inlineMediaToNode(inlineMedia[inlineIndex]));
+      usedIndexes.add(inlineIndex);
+      return;
+    }
+
+    content.push(...(textToAdf(block)?.content ?? []));
+  });
+
+  if (usedIndexes.size === 0) {
+    return [...content, ...inlineMedia.map((item) => inlineMediaToNode(item))];
+  }
+
+  inlineMedia.forEach((item, index) => {
+    if (!usedIndexes.has(index)) {
+      content.push(inlineMediaToNode(item));
+    }
+  });
+
+  return content;
+}
+
+function parseInlineMediaPlaceholder(block: string): { index: number; sequential: boolean } | null {
+  const match = block.match(/^\[\[inline-file(?::(\d+))?\]\]$/);
+
+  if (!match) {
+    return null;
+  }
+
+  const rawIndex = match[1];
+
+  if (!rawIndex) {
+    return { index: 0, sequential: true };
+  }
+
+  const parsedIndex = Number.parseInt(rawIndex, 10);
+
+  if (!Number.isFinite(parsedIndex) || parsedIndex <= 0) {
+    return null;
+  }
+
+  return { index: parsedIndex - 1, sequential: false };
+}
+
+function inlineMediaToNode(item: InlineMediaItem) {
+  return {
+    type: "mediaSingle" as const,
+    attrs: {
+      layout: "center" as const,
+      width: 100,
+      widthType: "percentage" as const,
+    },
+    content: [
+      {
+        type: "media" as const,
+        attrs: {
+          alt: item.fileName,
+          collection: item.collection ?? "",
+          height: item.dimensions.height,
+          id: item.mediaId,
+          type: "file" as const,
+          width: item.dimensions.width,
+        },
+      },
+    ],
+  };
+}

package/src/commit-message.ts

@@ -0,0 +1,10 @@
+export function formatCommitMessage(template: string, issueKey: string, message: string): string {
+  if (message.startsWith(`${issueKey} `) || message === issueKey) {
+    return message;
+  }
+
+  return template
+    .replaceAll("{issueKey}", issueKey)
+    .replaceAll("{message}", message)
+    .trim();
+}

package/src/commit-with-issue.ts

@@ -0,0 +1,90 @@
+import { commitWithMessage } from "./git";
+import { loadWorkflowConfig } from "./config";
+import { loadCurrentIssueState } from "./state";
+import { formatCommitMessage } from "./commit-message";
+
+type CliOptions = {
+  configPath?: string;
+  dryRun: boolean;
+  issueKey?: string;
+  message?: string;
+};
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  const config = await loadWorkflowConfig(options.configPath);
+  const currentIssue = await loadCurrentIssueState(config);
+  const issueKey = options.issueKey ?? currentIssue?.issueKey;
+  const message = options.message?.trim();
+
+  if (!issueKey) {
+    throw new Error("Pass --issue or set the current issue first with jira-dev-workflow use.");
+  }
+
+  if (!message) {
+    throw new Error("Pass -m or --message.");
+  }
+
+  const finalMessage = formatCommitMessage(config.commitMessageFormat, issueKey, message);
+
+  if (options.dryRun) {
+    console.log(finalMessage);
+    return;
+  }
+
+  await commitWithMessage(finalMessage);
+  console.log(finalMessage);
+}
+
+function parseArgs(args: string[]): CliOptions {
+  const options: CliOptions = {
+    dryRun: false,
+  };
+
+  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 === "--dry-run") {
+      options.dryRun = true;
+      continue;
+    }
+
+    if (arg === "--issue") {
+      options.issueKey = requireNextValue(args, ++index, "--issue");
+      continue;
+    }
+
+    if (arg === "-m" || arg === "--message") {
+      options.message = requireNextValue(args, ++index, arg);
+      continue;
+    }
+
+    throw new Error(`Unknown 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/config.ts

@@ -0,0 +1,184 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+export type WorkflowConfig = {
+  commitMessageFormat: string;
+  configBaseDir: string;
+  defaultIssueType: string;
+  issueLinkType: string;
+  projectKey?: string;
+  reuseClosedAsRelatedLink: boolean;
+  searchLimit: number;
+  stateFile: string;
+};
+
+export const localToolDirName = ".jira-dev-workflow";
+export const configFileName = "config.json";
+
+const defaultConfig: WorkflowConfig = {
+  commitMessageFormat: "{issueKey} {message}",
+  configBaseDir: process.env.INIT_CWD ? path.resolve(process.env.INIT_CWD) : process.cwd(),
+  defaultIssueType: "Task",
+  issueLinkType: "Relates",
+  reuseClosedAsRelatedLink: true,
+  searchLimit: 5,
+  stateFile: "state/current-issue.json",
+};
+
+export const workflowPackageDir = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+
+export async function loadWorkflowConfig(configPath?: string): Promise<WorkflowConfig> {
+  const resolvedConfigPath = configPath ? path.resolve(configPath) : await findConfigPath();
+
+  try {
+    const content = await fs.readFile(resolvedConfigPath, "utf8");
+    const parsed = JSON.parse(content) as Partial<WorkflowConfig>;
+    const configBaseDir = path.dirname(resolvedConfigPath);
+
+    return {
+      ...defaultConfig,
+      configBaseDir,
+      ...parsed,
+    };
+  } catch (error) {
+    if (isFileMissingError(error)) {
+      return { ...defaultConfig };
+    }
+
+    throw error;
+  }
+}
+
+export function resolveStateFilePath(config: WorkflowConfig): string {
+  return path.isAbsolute(config.stateFile) ? config.stateFile : path.resolve(config.configBaseDir, config.stateFile);
+}
+
+export async function loadToolEnv(envFilePath?: string) {
+  const toolDir = envFilePath ? null : await findLocalToolDir();
+  const candidates = envFilePath
+    ? [path.resolve(envFilePath)]
+    : [
+        path.join(toolDir ?? path.resolve(process.cwd(), localToolDirName), ".env.local"),
+        path.join(toolDir ?? path.resolve(process.cwd(), localToolDirName), ".env"),
+      ];
+
+  for (const candidate of candidates) {
+    const parsed = await readEnvFile(candidate);
+
+    if (!parsed) {
+      continue;
+    }
+
+    for (const [key, value] of Object.entries(parsed)) {
+      if (process.env[key] === undefined) {
+        process.env[key] = value;
+      }
+    }
+  }
+}
+
+export function readEnv(name: string): string | undefined {
+  const value = process.env[name]?.trim();
+  return value ? value : undefined;
+}
+
+async function readEnvFile(filePath: string): Promise<Record<string, string> | null> {
+  try {
+    const content = await fs.readFile(filePath, "utf8");
+    return parseEnvFile(content);
+  } catch (error) {
+    if (isFileMissingError(error)) {
+      return null;
+    }
+
+    throw error;
+  }
+}
+
+function parseEnvFile(content: string): Record<string, string> {
+  const values: Record<string, string> = {};
+
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = rawLine.trim();
+
+    if (!line || line.startsWith("#")) {
+      continue;
+    }
+
+    const separatorIndex = line.indexOf("=");
+
+    if (separatorIndex === -1) {
+      continue;
+    }
+
+    const key = line.slice(0, separatorIndex).trim();
+    const rawValue = line.slice(separatorIndex + 1).trim();
+
+    if (!key) {
+      continue;
+    }
+
+    values[key] = stripWrappingQuotes(rawValue);
+  }
+
+  return values;
+}
+
+function stripWrappingQuotes(value: string): string {
+  if (value.length >= 2) {
+    const first = value[0];
+    const last = value[value.length - 1];
+
+    if ((first === "\"" && last === "\"") || (first === "'" && last === "'")) {
+      return value.slice(1, -1);
+    }
+  }
+
+  return value;
+}
+
+function isFileMissingError(error: unknown): error is NodeJS.ErrnoException {
+  return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
+}
+
+async function findConfigPath(): Promise<string> {
+  const toolDir = await findLocalToolDir();
+  return toolDir
+    ? path.join(toolDir, configFileName)
+    : path.resolve(process.env.INIT_CWD ? path.resolve(process.env.INIT_CWD) : process.cwd(), localToolDirName, configFileName);
+}
+
+async function findLocalToolDir(): Promise<string | null> {
+  const searchRoots = [process.cwd(), process.env.INIT_CWD ? path.resolve(process.env.INIT_CWD) : ""].filter(Boolean);
+
+  for (const startDir of searchRoots) {
+    let currentDir = path.resolve(startDir);
+
+    while (true) {
+      const candidate = path.join(currentDir, localToolDirName);
+
+      try {
+        const stat = await fs.stat(candidate);
+
+        if (stat.isDirectory()) {
+          return candidate;
+        }
+      } catch (error) {
+        if (!isFileMissingError(error)) {
+          throw error;
+        }
+      }
+
+      const parentDir = path.dirname(currentDir);
+
+      if (parentDir === currentDir) {
+        break;
+      }
+
+      currentDir = parentDir;
+    }
+  }
+
+  return null;
+}