@greeana/jira-dev-workflow 0.1.0

package/src/image-dimensions.ts

@@ -0,0 +1,137 @@
+import fs from "node:fs/promises";
+
+export type ImageDimensions = {
+  height: number;
+  width: number;
+};
+
+export async function getImageDimensions(filePath: string): Promise<ImageDimensions> {
+  const buffer = await fs.readFile(filePath);
+  return getImageDimensionsFromBuffer(buffer);
+}
+
+export function getImageDimensionsFromBuffer(buffer: Buffer): ImageDimensions {
+  return parsePng(buffer) ?? parseGif(buffer) ?? parseJpeg(buffer) ?? parseWebp(buffer) ?? unsupported();
+}
+
+function parsePng(buffer: Buffer): ImageDimensions | null {
+  const pngSignature = "89504e470d0a1a0a";
+
+  if (buffer.length < 24 || buffer.subarray(0, 8).toString("hex") !== pngSignature) {
+    return null;
+  }
+
+  return {
+    width: buffer.readUInt32BE(16),
+    height: buffer.readUInt32BE(20),
+  };
+}
+
+function parseGif(buffer: Buffer): ImageDimensions | null {
+  const header = buffer.subarray(0, 6).toString("ascii");
+
+  if (buffer.length < 10 || (header !== "GIF87a" && header !== "GIF89a")) {
+    return null;
+  }
+
+  return {
+    width: buffer.readUInt16LE(6),
+    height: buffer.readUInt16LE(8),
+  };
+}
+
+function parseJpeg(buffer: Buffer): ImageDimensions | null {
+  if (buffer.length < 4 || buffer[0] !== 0xff || buffer[1] !== 0xd8) {
+    return null;
+  }
+
+  let offset = 2;
+
+  while (offset + 9 < buffer.length) {
+    if (buffer[offset] !== 0xff) {
+      offset += 1;
+      continue;
+    }
+
+    const marker = buffer[offset + 1];
+    offset += 2;
+
+    if (marker === 0xd8 || marker === 0xd9) {
+      continue;
+    }
+
+    if (offset + 1 >= buffer.length) {
+      break;
+    }
+
+    const segmentLength = buffer.readUInt16BE(offset);
+
+    if (segmentLength < 2 || offset + segmentLength > buffer.length) {
+      break;
+    }
+
+    if (isSofMarker(marker)) {
+      return {
+        height: buffer.readUInt16BE(offset + 3),
+        width: buffer.readUInt16BE(offset + 5),
+      };
+    }
+
+    offset += segmentLength;
+  }
+
+  return null;
+}
+
+function parseWebp(buffer: Buffer): ImageDimensions | null {
+  if (
+    buffer.length < 30 ||
+    buffer.subarray(0, 4).toString("ascii") !== "RIFF" ||
+    buffer.subarray(8, 12).toString("ascii") !== "WEBP"
+  ) {
+    return null;
+  }
+
+  const chunkType = buffer.subarray(12, 16).toString("ascii");
+
+  if (chunkType === "VP8X" && buffer.length >= 30) {
+    return {
+      width: 1 + readUInt24LE(buffer, 24),
+      height: 1 + readUInt24LE(buffer, 27),
+    };
+  }
+
+  if (chunkType === "VP8 " && buffer.length >= 30) {
+    return {
+      width: buffer.readUInt16LE(26) & 0x3fff,
+      height: buffer.readUInt16LE(28) & 0x3fff,
+    };
+  }
+
+  if (chunkType === "VP8L" && buffer.length >= 25) {
+    const bits = buffer.readUInt32LE(21);
+    return {
+      width: (bits & 0x3fff) + 1,
+      height: ((bits >> 14) & 0x3fff) + 1,
+    };
+  }
+
+  return null;
+}
+
+function readUInt24LE(buffer: Buffer, offset: number): number {
+  return buffer[offset]! | (buffer[offset + 1]! << 8) | (buffer[offset + 2]! << 16);
+}
+
+function isSofMarker(marker: number): boolean {
+  return (
+    (marker >= 0xc0 && marker <= 0xc3) ||
+    (marker >= 0xc5 && marker <= 0xc7) ||
+    (marker >= 0xc9 && marker <= 0xcb) ||
+    (marker >= 0xcd && marker <= 0xcf)
+  );
+}
+
+function unsupported(): never {
+  throw new Error("Unsupported image format for inline Jira media. Use PNG, JPEG, GIF, or WebP.");
+}

package/src/import-issues.ts

@@ -0,0 +1,196 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+import { parseCsvRows, textToAdf } from "./csv";
+import { loadToolEnv, loadWorkflowConfig, localToolDirName, readEnv } from "./config";
+import { createJiraClient } from "./jira-client";
+
+type CliOptions = {
+  configPath?: string;
+  continueOnError: boolean;
+  dryRun: boolean;
+  envFilePath?: string;
+  filePath: string;
+  issueTypeOverride?: string;
+  limit?: number;
+  projectKeyOverride?: string;
+};
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  await loadToolEnv(options.envFilePath);
+  const config = await loadWorkflowConfig(options.configPath);
+  const absoluteCsvPath = path.resolve(options.filePath);
+  const csv = await fs.readFile(absoluteCsvPath, "utf8");
+  const rows = parseCsvRows(csv);
+  const selectedRows = typeof options.limit === "number" ? rows.slice(0, options.limit) : rows;
+
+  if (selectedRows.length === 0) {
+    console.log(`No rows found in ${absoluteCsvPath}.`);
+    return;
+  }
+
+  if (options.dryRun) {
+    for (const [index, row] of selectedRows.entries()) {
+      const projectKey = resolveProjectKey(row, options, config.projectKey);
+      const issueType = resolveIssueType(row, options, config.defaultIssueType);
+      const summary = requireValue(row, "Summary", index);
+      const comment = row.Comment?.trim();
+
+      console.log(`[dry-run] Row ${index + 2}: would create ${projectKey} ${issueType} "${summary}"`);
+
+      if (comment) {
+        console.log(`[dry-run] Row ${index + 2}: would add comment with ${comment.split("\n").length} line(s)`);
+      }
+    }
+
+    return;
+  }
+
+  const jira = createJiraClient();
+
+  for (const [index, row] of selectedRows.entries()) {
+    try {
+      const projectKey = resolveProjectKey(row, options, config.projectKey);
+      const issueType = resolveIssueType(row, options, config.defaultIssueType);
+      const summary = requireValue(row, "Summary", index);
+      const description = row.Description?.trim() ?? "";
+      const comment = row.Comment?.trim() ?? "";
+
+      const issue = await jira.createIssue({
+        description: textToAdf(description),
+        issueType,
+        projectKey,
+        summary,
+      });
+
+      console.log(`Created ${issue.key}: ${summary}`);
+
+      if (comment) {
+        const adfComment = textToAdf(comment);
+        if (adfComment) {
+          await jira.addComment(issue.key, adfComment);
+          console.log(`Added comment to ${issue.key}`);
+        }
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`Failed to import row ${index + 2}: ${message}`);
+
+      if (!options.continueOnError) {
+        process.exitCode = 1;
+        return;
+      }
+
+      process.exitCode = 1;
+    }
+  }
+}
+
+function parseArgs(args: string[]): CliOptions {
+  const options: CliOptions = {
+    continueOnError: false,
+    dryRun: false,
+    filePath: path.resolve(process.cwd(), localToolDirName, "import.csv"),
+  };
+
+  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 === "--continue-on-error") {
+      options.continueOnError = true;
+      continue;
+    }
+
+    if (arg === "--dry-run") {
+      options.dryRun = true;
+      continue;
+    }
+
+    if (arg === "--env-file") {
+      options.envFilePath = requireNextValue(args, ++index, "--env-file");
+      continue;
+    }
+
+    if (arg === "--file") {
+      options.filePath = requireNextValue(args, ++index, "--file");
+      continue;
+    }
+
+    if (arg === "--issue-type") {
+      options.issueTypeOverride = requireNextValue(args, ++index, "--issue-type");
+      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.startsWith("--")) {
+      throw new Error(`Unknown argument: ${arg}`);
+    }
+
+    options.filePath = arg;
+  }
+
+  return options;
+}
+
+function resolveProjectKey(row: Record<string, string>, options: CliOptions, configProjectKey?: string): string {
+  return (
+    options.projectKeyOverride ??
+    row["Project Key"]?.trim() ??
+    configProjectKey ??
+    readEnv("JIRA_PROJECT_KEY") ??
+    missingField("Project Key")
+  );
+}
+
+function resolveIssueType(row: Record<string, string>, options: CliOptions, configDefaultIssueType: string): string {
+  return options.issueTypeOverride ?? row["Issue Type"]?.trim() ?? configDefaultIssueType;
+}
+
+function requireValue(row: Record<string, string>, fieldName: string, rowIndex: number): string {
+  const value = row[fieldName]?.trim();
+
+  if (!value) {
+    throw new Error(`Row ${rowIndex + 2} is missing required field "${fieldName}".`);
+  }
+
+  return value;
+}
+
+function missingField(fieldName: string): never {
+  throw new Error(`Missing required value for "${fieldName}". Provide it in the CSV or via config.`);
+}
+
+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/install.ts

@@ -0,0 +1,323 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+import { workflowPackageDir } from "./config";
+
+const publishedPackageName = "@greeana/jira-dev-workflow";
+const localSkillDir = path.join(".codex", "skills", "jira-dev-workflow");
+const localSkillFile = path.join(localSkillDir, "SKILL.md");
+const localWorkflowDir = ".jira-dev-workflow";
+const localConfigFile = path.join(localWorkflowDir, "config.json");
+const localEnvFile = path.join(localWorkflowDir, ".env.local");
+const localStateDir = path.join(localWorkflowDir, "state");
+const gitignoreEntries = [".jira-dev-workflow/.env.local", ".jira-dev-workflow/state/"];
+
+export type InstallOptions = {
+  force: boolean;
+  json: boolean;
+  local: boolean;
+  preview: boolean;
+  projectKey?: string;
+  version?: string;
+};
+
+export type InstallResult = {
+  created: string[];
+  overwritten: string[];
+  skipped: string[];
+  updated: string[];
+  warnings: string[];
+};
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  const result = await installWorkflowRepo(process.cwd(), options);
+  const commandPrefix = resolveCommandPrefix(options);
+
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  console.log(`Installed jira-dev-workflow in ${process.cwd()}`);
+  console.log(`Skill command reference: ${commandPrefix}`);
+
+  printSection("Created", result.created);
+  printSection("Overwritten", result.overwritten);
+  printSection("Updated", result.updated);
+  printSection("Skipped existing", result.skipped);
+  printSection("Warnings", result.warnings);
+
+  console.log("");
+  console.log("Edit these files before first use:");
+  console.log(`- ${localConfigFile} : set projectKey if JDW is not your Jira project key, and review workflow defaults.`);
+  console.log(`- ${localEnvFile} : set JIRA_BASE_URL, JIRA_EMAIL, and JIRA_API_TOKEN.`);
+  console.log("");
+  console.log("Then run:");
+  console.log(`- \`${commandPrefix} test\``);
+}
+
+export async function installWorkflowRepo(
+  targetDir: string,
+  options: Pick<InstallOptions, "force" | "local" | "preview" | "projectKey" | "version">,
+): Promise<InstallResult> {
+  const result: InstallResult = {
+    created: [],
+    overwritten: [],
+    skipped: [],
+    updated: [],
+    warnings: [],
+  };
+  const skillTemplate = await loadSkillTemplate({
+    local: false,
+    preview: false,
+    version: undefined,
+    ...options,
+  });
+
+  await fs.mkdir(path.join(targetDir, localWorkflowDir), { recursive: true });
+  await fs.mkdir(path.join(targetDir, localStateDir), { recursive: true });
+  await fs.mkdir(path.join(targetDir, localSkillDir), { recursive: true });
+
+  await writeManagedFile(path.join(targetDir, localConfigFile), buildInitialConfig(options.projectKey), options.force, targetDir, result);
+  await writeManagedFile(path.join(targetDir, localEnvFile), buildEnvTemplate(), options.force, targetDir, result);
+  await writeManagedFile(path.join(targetDir, localSkillFile), skillTemplate, options.force, targetDir, result);
+  await ensureGitignoreEntries(targetDir, result);
+
+  if (!options.projectKey) {
+    result.warnings.push(`Using example project key JDW in ${localConfigFile}. Change it if your Jira project uses a different key.`);
+  }
+
+  return result;
+}
+
+export function buildInitialConfig(projectKey?: string): string {
+  const config = {
+    projectKey: projectKey?.trim() || "JDW",
+    defaultIssueType: "Task",
+    issueLinkType: "Relates",
+    commitMessageFormat: "{issueKey} {message}",
+    searchLimit: 5,
+    reuseClosedAsRelatedLink: true,
+    stateFile: "state/current-issue.json",
+  };
+
+  return `${JSON.stringify(config, null, 2)}\n`;
+}
+
+export function buildEnvTemplate(): string {
+  return [
+    "JIRA_BASE_URL=https://your-company.atlassian.net",
+    "JIRA_EMAIL=your.name@company.com",
+    "JIRA_API_TOKEN=your_jira_api_token",
+    "",
+  ].join("\n");
+}
+
+export function resolvePackageSpecifier(options: Pick<InstallOptions, "preview" | "version">): string {
+  if (options.version) {
+    return `${publishedPackageName}@${options.version.trim()}`;
+  }
+
+  if (options.preview) {
+    return `${publishedPackageName}@preview`;
+  }
+
+  return publishedPackageName;
+}
+
+export function resolveCommandPrefix(options: Pick<InstallOptions, "local" | "preview" | "version">): string {
+  validateSourceSelection(options);
+
+  if (options.local) {
+    return `node ${shellQuote(path.join(workflowPackageDir, "bin", "jira-dev-workflow.mjs"))}`;
+  }
+
+  return `npx -y ${resolvePackageSpecifier(options)}`;
+}
+
+export async function loadSkillTemplate(options: Pick<InstallOptions, "local" | "preview" | "version">): Promise<string> {
+  const skillTemplatePath = path.join(workflowPackageDir, "skill", "jira-dev-workflow", "SKILL.md");
+  const skillTemplate = await fs.readFile(skillTemplatePath, "utf8");
+  return skillTemplate.replaceAll(`npx -y ${publishedPackageName}`, resolveCommandPrefix(options));
+}
+
+export function mergeGitignore(existingContent: string): { addedEntries: string[]; content: string } {
+  const trimmed = existingContent.trimEnd();
+  const lines = trimmed ? trimmed.split(/\r?\n/) : [];
+  const seen = new Set(lines);
+  const addedEntries: string[] = [];
+
+  for (const entry of gitignoreEntries) {
+    if (seen.has(entry)) {
+      continue;
+    }
+
+    lines.push(entry);
+    seen.add(entry);
+    addedEntries.push(entry);
+  }
+
+  return {
+    addedEntries,
+    content: lines.length > 0 ? `${lines.join("\n")}\n` : "",
+  };
+}
+
+async function ensureGitignoreEntries(targetDir: string, result: InstallResult) {
+  const gitignorePath = path.join(targetDir, ".gitignore");
+  let existingContent = "";
+  let existed = true;
+
+  try {
+    existingContent = await fs.readFile(gitignorePath, "utf8");
+  } catch (error) {
+    if (!isFileMissingError(error)) {
+      throw error;
+    }
+
+    existed = false;
+  }
+
+  const merged = mergeGitignore(existingContent);
+
+  if (merged.addedEntries.length === 0 && existed) {
+    return;
+  }
+
+  await fs.writeFile(gitignorePath, merged.content, "utf8");
+
+  if (existed) {
+    result.updated.push(relativeDisplayPath(targetDir, gitignorePath));
+    return;
+  }
+
+  result.created.push(relativeDisplayPath(targetDir, gitignorePath));
+}
+
+async function writeManagedFile(filePath: string, content: string, force: boolean, targetDir: string, result: InstallResult) {
+  try {
+    await fs.readFile(filePath, "utf8");
+
+    if (!force) {
+      result.skipped.push(relativeDisplayPath(targetDir, filePath));
+      return;
+    }
+
+    await fs.writeFile(filePath, content, "utf8");
+    result.overwritten.push(relativeDisplayPath(targetDir, filePath));
+  } catch (error) {
+    if (!isFileMissingError(error)) {
+      throw error;
+    }
+
+    await fs.writeFile(filePath, content, "utf8");
+    result.created.push(relativeDisplayPath(targetDir, filePath));
+  }
+}
+
+function parseArgs(args: string[]): InstallOptions {
+  const options: InstallOptions = {
+    force: false,
+    json: false,
+    local: false,
+    preview: false,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (!arg) {
+      continue;
+    }
+
+    if (arg === "--force") {
+      options.force = true;
+      continue;
+    }
+
+    if (arg === "--json") {
+      options.json = true;
+      continue;
+    }
+
+    if (arg === "--project-key") {
+      options.projectKey = requireNextValue(args, ++index, "--project-key");
+      continue;
+    }
+
+    if (arg === "--local") {
+      options.local = true;
+      continue;
+    }
+
+    if (arg === "--preview") {
+      options.preview = true;
+      continue;
+    }
+
+    if (arg === "--version") {
+      options.version = requireNextValue(args, ++index, "--version");
+      continue;
+    }
+
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  validateSourceSelection(options);
+
+  return options;
+}
+
+function printSection(title: string, values: string[]) {
+  if (values.length === 0) {
+    return;
+  }
+
+  console.log("");
+  console.log(`${title}:`);
+
+  for (const value of values) {
+    console.log(`- ${value}`);
+  }
+}
+
+function relativeDisplayPath(targetDir: string, filePath: string): string {
+  const relativePath = path.relative(targetDir, filePath) || ".";
+  return relativePath.split(path.sep).join("/");
+}
+
+function validateSourceSelection(options: Pick<InstallOptions, "local" | "preview" | "version">) {
+  const selectedModes = [options.local, options.preview, Boolean(options.version)].filter(Boolean).length;
+
+  if (selectedModes > 1) {
+    throw new Error("Pass at most one of --local, --preview, or --version.");
+  }
+}
+
+function requireNextValue(args: string[], index: number, flagName: string): string {
+  const value = args[index];
+
+  if (!value) {
+    throw new Error(`Missing value for ${flagName}.`);
+  }
+
+  return value;
+}
+
+function isFileMissingError(error: unknown): error is NodeJS.ErrnoException {
+  return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
+}
+
+function shellQuote(value: string): string {
+  return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  void main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    process.exitCode = 1;
+  });
+}