@emmertarmin/redmine-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1920 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/commands/config.ts
+import { stdin as input, stderr as output } from "process";
+import { createInterface } from "readline/promises";
+
+// src/config/load-config.ts
+import { constants as fsConstants } from "fs";
+import { access, mkdir, readFile, writeFile } from "fs/promises";
+import { dirname } from "path";
+
+// src/config/xdg.ts
+import { homedir } from "os";
+import { join } from "path";
+function getConfigPath() {
+  const baseDir = process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config");
+  return join(baseDir, "redmine", "config.json");
+}
+function getDataDir() {
+  const baseDir = process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");
+  return join(baseDir, "redmine");
+}
+function getDefaultIssueMirrorDir() {
+  return join(getDataDir(), "issues");
+}
+function expandHomePath(path) {
+  if (path === "~") {
+    return homedir();
+  }
+  if (path.startsWith("~/")) {
+    return join(homedir(), path.slice(2));
+  }
+  return path;
+}
+
+// src/config/load-config.ts
+async function ensureConfigDir() {
+  await mkdir(dirname(getConfigPath()), { recursive: true });
+}
+var requiredConfigKeys = ["url", "key"];
+function getMissingRequiredConfig(config) {
+  return requiredConfigKeys.filter((key) => !config[key]);
+}
+function formatMissingConfigWarning(missing) {
+  const names = missing.map((key) => `--${key}`).join(", ");
+  return `Missing required Redmine configuration: ${names}. Run \`redmine config setup\`.`;
+}
+async function loadConfig() {
+  const configPath = getConfigPath();
+  try {
+    await access(configPath, fsConstants.R_OK);
+  } catch {
+    return {};
+  }
+  const raw = await readFile(configPath, "utf8");
+  const config = JSON.parse(raw);
+  if (config.url !== undefined && typeof config.url !== "string") {
+    throw new Error(`Invalid config in ${configPath}: url must be a string`);
+  }
+  if (config.key !== undefined && typeof config.key !== "string") {
+    throw new Error(`Invalid config in ${configPath}: key must be a string`);
+  }
+  if (config.issueMirrorDir !== undefined && typeof config.issueMirrorDir !== "string") {
+    throw new Error(`Invalid config in ${configPath}: issueMirrorDir must be a string`);
+  }
+  return config;
+}
+function getIssueMirrorDir(config) {
+  return config.issueMirrorDir ? expandHomePath(config.issueMirrorDir) : getDefaultIssueMirrorDir();
+}
+async function saveConfig(config) {
+  await ensureConfigDir();
+  await writeFile(getConfigPath(), `${JSON.stringify(config, null, 2)}
+`, "utf8");
+}
+
+// src/commands/config.ts
+function optionalString(value) {
+  return typeof value === "string" ? value : undefined;
+}
+function maskApiKey(key) {
+  if (key.length <= 8) {
+    return "*****";
+  }
+  return `*****${key.slice(-4)}`;
+}
+function maskConfig(config) {
+  return {
+    ...config,
+    key: config.key === undefined ? undefined : maskApiKey(config.key)
+  };
+}
+var configGetCommand = {
+  name: "get",
+  summary: "Get Redmine configuration values",
+  description: "Print a single Redmine setting from the XDG config file.",
+  flags: [
+    {
+      name: "url",
+      type: "boolean",
+      description: "Print the configured Redmine server URL"
+    },
+    {
+      name: "key",
+      type: "boolean",
+      description: "Print the configured Redmine API key, obfuscated for identification"
+    },
+    {
+      name: "issue-mirror-dir",
+      type: "boolean",
+      description: "Print the configured issue mirror directory, or the default if unset"
+    }
+  ],
+  examples: ["redmine config get --url", "redmine config get --key", "redmine config get --issue-mirror-dir"],
+  execute: async ({ values, positionals }) => {
+    if (positionals.length > 0) {
+      throw new Error(`Unexpected argument: ${positionals[0]}`);
+    }
+    const wantsUrl = values.url === true;
+    const wantsKey = values.key === true;
+    const wantsIssueMirrorDir = values["issue-mirror-dir"] === true;
+    if ([wantsUrl, wantsKey, wantsIssueMirrorDir].filter(Boolean).length !== 1) {
+      throw new Error("Specify exactly one setting to get: --url, --key, or --issue-mirror-dir.");
+    }
+    const config = await loadConfig();
+    if (wantsIssueMirrorDir) {
+      console.log(getIssueMirrorDir(config));
+      return;
+    }
+    const name = wantsUrl ? "url" : "key";
+    const value = config[name];
+    if (value === undefined) {
+      throw new Error(`Config value is not set: ${name}`);
+    }
+    console.log(name === "key" ? maskApiKey(value) : value);
+  }
+};
+var configListCommand = {
+  name: "list",
+  aliases: ["ls"],
+  summary: "List Redmine configuration",
+  description: "Print all configured Redmine settings from the XDG config file.",
+  examples: ["redmine config list"],
+  execute: async ({ positionals }) => {
+    if (positionals.length > 0) {
+      throw new Error(`Unexpected argument: ${positionals[0]}`);
+    }
+    const config = await loadConfig();
+    console.log(JSON.stringify(maskConfig(config), null, 2));
+  }
+};
+async function createPromptReader() {
+  if (input.isTTY) {
+    return createInterface({ input, output });
+  }
+  const chunks = [];
+  for await (const chunk of input) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  const answers = Buffer.concat(chunks).toString("utf8").split(/\r?\n/);
+  let index = 0;
+  return {
+    question: async (message) => {
+      output.write(message);
+      return answers[index++] ?? "";
+    },
+    close: () => {}
+  };
+}
+async function prompt(readline, message, currentValue, options = {}) {
+  const suffix = currentValue ? ` [current: ${options.mask ? options.mask(currentValue) : currentValue}]` : "";
+  const answer = await readline.question(`${message}${suffix}: `);
+  const value = answer.trim();
+  return value === "" ? currentValue : value;
+}
+var configSetupCommand = {
+  name: "setup",
+  aliases: ["init"],
+  summary: "Interactively set up Redmine configuration",
+  description: "Prompt for the required Redmine URL and API key, then write them to the XDG config file.",
+  examples: ["redmine config setup"],
+  execute: async ({ positionals }) => {
+    if (positionals.length > 0) {
+      throw new Error(`Unexpected argument: ${positionals[0]}`);
+    }
+    const currentConfig = await loadConfig();
+    const readline = await createPromptReader();
+    try {
+      output.write(`Redmine configuration setup (${getConfigPath()})
+`);
+      const url = await prompt(readline, "Redmine URL", currentConfig.url);
+      const key = await prompt(readline, "Redmine API key", currentConfig.key, { mask: maskApiKey });
+      const nextConfig = {
+        ...currentConfig,
+        ...url ? { url } : {},
+        ...key ? { key } : {}
+      };
+      const missing = getMissingRequiredConfig(nextConfig);
+      if (missing.length > 0) {
+        throw new Error(formatMissingConfigWarning(missing));
+      }
+      await saveConfig(nextConfig);
+      console.log(`Wrote ${getConfigPath()}`);
+    } finally {
+      readline.close();
+    }
+  }
+};
+var configSetCommand = {
+  name: "set",
+  summary: "Set Redmine configuration",
+  description: "Write Redmine connection settings to the XDG config file.",
+  flags: [
+    {
+      name: "url",
+      type: "string",
+      description: "Redmine server URL"
+    },
+    {
+      name: "key",
+      type: "string",
+      description: "Redmine API key"
+    },
+    {
+      name: "issue-mirror-dir",
+      type: "string",
+      description: "Directory for the local Markdown issue mirror"
+    }
+  ],
+  examples: ["redmine config set --url https://redmine.example.com --key YOUR_API_KEY", "redmine config set --issue-mirror-dir ~/Documents/Redmine"],
+  execute: async ({ values, positionals }) => {
+    if (positionals.length > 0) {
+      throw new Error(`Unexpected argument: ${positionals[0]}`);
+    }
+    const url = optionalString(values.url);
+    const key = optionalString(values.key);
+    const issueMirrorDir = optionalString(values["issue-mirror-dir"]);
+    if (url === undefined && key === undefined && issueMirrorDir === undefined) {
+      throw new Error("Nothing to set. Provide --url, --key, --issue-mirror-dir, or any combination.");
+    }
+    const nextConfig = {
+      ...await loadConfig()
+    };
+    if (url !== undefined) {
+      nextConfig.url = url;
+    }
+    if (key !== undefined) {
+      nextConfig.key = key;
+    }
+    if (issueMirrorDir !== undefined) {
+      nextConfig.issueMirrorDir = issueMirrorDir;
+    }
+    await saveConfig(nextConfig);
+    console.log(`Wrote ${getConfigPath()}`);
+  }
+};
+var configCommand = {
+  name: "config",
+  summary: "Manage configuration",
+  description: "Commands for Redmine settings stored in the XDG config file.",
+  subcommands: [configGetCommand, configSetCommand, configSetupCommand, configListCommand]
+};
+
+// src/commands/issues.ts
+import { createInterface as createInterface2 } from "readline/promises";
+import { stdin as input2, stderr as output2 } from "process";
+
+// src/redmine/cache.ts
+import { createHash } from "crypto";
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+function getCacheDir() {
+  const baseDir = process.env.XDG_CACHE_HOME ?? join2(homedir2(), ".cache");
+  return join2(baseDir, "redmine", "api-cache-v1");
+}
+function cachePathForKey(key) {
+  const hash = createHash("sha256").update(key).digest("hex");
+  return join2(getCacheDir(), `${hash}.json`);
+}
+async function readCachedRedmineJson(key, ttlMs) {
+  try {
+    const raw = await readFile2(cachePathForKey(key), "utf8");
+    const entry = JSON.parse(raw);
+    if (typeof entry.createdAt !== "string" || !("data" in entry)) {
+      return;
+    }
+    const createdAt = Date.parse(entry.createdAt);
+    if (!Number.isFinite(createdAt)) {
+      return;
+    }
+    const ageMs = Date.now() - createdAt;
+    if (ageMs < 0 || ageMs > ttlMs) {
+      return;
+    }
+    return { data: entry.data, ageMs };
+  } catch {
+    return;
+  }
+}
+async function writeCachedRedmineJson(key, ttlMs, data) {
+  try {
+    await mkdir2(getCacheDir(), { recursive: true });
+    const entry = {
+      createdAt: new Date().toISOString(),
+      ttlMs,
+      data
+    };
+    await writeFile2(cachePathForKey(key), `${JSON.stringify(entry)}
+`, "utf8");
+  } catch {}
+}
+
+// src/redmine/trace.ts
+import { appendFile, mkdir as mkdir3 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname2, join as join3 } from "path";
+function getDefaultTraceFilePath() {
+  const baseDir = process.env.XDG_CACHE_HOME ?? join3(homedir3(), ".cache");
+  return join3(baseDir, "redmine", "requests.jsonl");
+}
+function getTraceFilePath() {
+  return process.env.REDMINE_TRACE_FILE === "1" ? getDefaultTraceFilePath() : undefined;
+}
+async function traceRedmineRequest(event) {
+  const traceFilePath = getTraceFilePath();
+  if (!traceFilePath) {
+    return;
+  }
+  try {
+    await mkdir3(dirname2(traceFilePath), { recursive: true });
+    await appendFile(traceFilePath, `${JSON.stringify(event)}
+`, "utf8");
+  } catch {}
+}
+
+// src/redmine/client.ts
+function requireString(value, name) {
+  if (!value) {
+    throw new Error(`Missing Redmine ${name}. Run \`redmine config setup\` or \`redmine config set --${name} <value>\`.`);
+  }
+  return value;
+}
+function buildUrl(baseUrl, path, query = {}) {
+  const url = new URL(path.replace(/^\/+/, ""), baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`);
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== undefined) {
+      url.searchParams.set(key, String(value));
+    }
+  }
+  return url;
+}
+async function fetchRedmineJson(config, url, path) {
+  const key = requireString(config.key, "key");
+  const startedAt = performance.now();
+  try {
+    const response = await fetch(url, {
+      headers: {
+        Accept: "application/json",
+        "X-Redmine-API-Key": key
+      }
+    });
+    const durationMs = Math.round(performance.now() - startedAt);
+    await traceRedmineRequest({
+      ts: new Date().toISOString(),
+      method: "GET",
+      path,
+      source: "network",
+      status: response.status,
+      duration_ms: durationMs,
+      ok: response.ok
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`Redmine API request failed (${response.status} ${response.statusText}): ${body}`);
+    }
+    return response.json();
+  } catch (error) {
+    if (!(error instanceof Error && error.message.startsWith("Redmine API request failed"))) {
+      await traceRedmineRequest({
+        ts: new Date().toISOString(),
+        method: "GET",
+        path,
+        source: "network",
+        duration_ms: Math.round(performance.now() - startedAt),
+        ok: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+    throw error;
+  }
+}
+async function redmineGetJson(config, options) {
+  const url = buildUrl(requireString(config.url, "url"), options.path, options.query);
+  const path = `${url.pathname}${url.search}`;
+  return fetchRedmineJson(config, url, path);
+}
+async function redmineGetJsonCached(config, options, ttlMs) {
+  const url = buildUrl(requireString(config.url, "url"), options.path, options.query);
+  const path = `${url.pathname}${url.search}`;
+  const startedAt = performance.now();
+  const cached = await readCachedRedmineJson(url.toString(), ttlMs);
+  if (cached) {
+    await traceRedmineRequest({
+      ts: new Date().toISOString(),
+      method: "GET",
+      path,
+      source: "cache",
+      status: 200,
+      duration_ms: Math.round(performance.now() - startedAt),
+      ok: true,
+      cache_age_ms: Math.round(cached.ageMs)
+    });
+    return cached.data;
+  }
+  const data = await fetchRedmineJson(config, url, path);
+  await writeCachedRedmineJson(url.toString(), ttlMs, data);
+  return data;
+}
+
+// src/output/markdown.ts
+function splitFrontmatter(markdown) {
+  if (!markdown.startsWith(`---
+`)) {
+    return { body: markdown };
+  }
+  const end = markdown.indexOf(`
+---
+`, 4);
+  if (end === -1) {
+    return { body: markdown };
+  }
+  return {
+    frontmatter: markdown.slice(4, end).trim(),
+    body: markdown.slice(end + `
+---
+`.length)
+  };
+}
+function renderFrontmatter(frontmatter) {
+  const dim = "\x1B[2m";
+  const reset = "\x1B[0m";
+  return `${dim}---
+${frontmatter}
+---${reset}
+
+`;
+}
+function renderMarkdownForTerminal(markdown, options = {}) {
+  const { frontmatter, body } = splitFrontmatter(markdown);
+  const renderedBody = Bun.markdown.ansi(body, {
+    colors: options.colors ?? true,
+    columns: options.columns ?? process.stdout.columns ?? 100,
+    hyperlinks: options.hyperlinks ?? true,
+    kittyGraphics: options.kittyGraphics
+  });
+  return `${frontmatter ? renderFrontmatter(frontmatter) : ""}${renderedBody}`;
+}
+
+// src/commands/issues.ts
+var SPRINT_CUSTOM_FIELD_ID = 10;
+var SPRINT_ANCHOR_START = "2026-06-08";
+var SPRINT_ANCHOR_NUMBER = 12;
+var DAY_MS = 24 * 60 * 60 * 1000;
+var SPRINT_DAYS = 14;
+var SPRINT_WORK_DAYS = 12;
+var DESCRIPTION_PREVIEW_LENGTH = 180;
+var DESCRIPTION_PREVIEW_HYSTERESIS_LENGTH = 220;
+var DEFAULT_ISSUE_GET_INCLUDE = "journals,attachments,relations,changesets,watchers";
+function optionalString2(value) {
+  return typeof value === "string" ? value : undefined;
+}
+function optionalNumber(value, fallback) {
+  if (value === undefined) {
+    return fallback;
+  }
+  if (typeof value !== "string") {
+    throw new Error("Expected a numeric value");
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    throw new Error(`Expected a non-negative integer, got: ${value}`);
+  }
+  return parsed;
+}
+function requirePositiveInteger(value, name) {
+  if (!value) {
+    throw new Error(`Expected ${name}`);
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || String(parsed) !== value || parsed < 1) {
+    throw new Error(`Expected ${name} to be a positive integer, got: ${value}`);
+  }
+  return parsed;
+}
+function isIssueListResponse(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const response = value;
+  return Array.isArray(response.issues) && typeof response.total_count === "number" && typeof response.offset === "number" && typeof response.limit === "number";
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function namedReferenceName(value) {
+  if (!isRecord(value)) {
+    return;
+  }
+  const name = value.name;
+  if (typeof name === "string") {
+    return name;
+  }
+  const firstName = value.firstname;
+  const lastName = value.lastname;
+  if (typeof firstName === "string" && typeof lastName === "string") {
+    return `${lastName}, ${firstName}`;
+  }
+  const login = value.login;
+  return typeof login === "string" ? login : undefined;
+}
+function namedReferenceId(value) {
+  if (!isRecord(value)) {
+    return;
+  }
+  const id = value.id;
+  return typeof id === "string" || typeof id === "number" ? String(id) : undefined;
+}
+function createLookupMaps() {
+  return {
+    statuses: new Map,
+    trackers: new Map,
+    priorities: new Map,
+    customFields: new Map,
+    versions: new Map,
+    categories: new Map,
+    users: new Map
+  };
+}
+function addNamedReferencesToMap(map, values) {
+  if (!Array.isArray(values)) {
+    return;
+  }
+  for (const value of values) {
+    const id = namedReferenceId(value);
+    const name = namedReferenceName(value);
+    if (id && name) {
+      map.set(id, name);
+    }
+  }
+}
+function lookupArray(response, key) {
+  return isRecord(response) ? response[key] : undefined;
+}
+function mergeLookupMaps(target, source) {
+  for (const [key, map] of Object.entries(source)) {
+    for (const [id, name] of map) {
+      target[key].set(id, name);
+    }
+  }
+}
+function truncateDescription(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const normalized = value.replace(/\s+/g, " ").trim();
+  if (!normalized) {
+    return;
+  }
+  if (normalized.length <= DESCRIPTION_PREVIEW_HYSTERESIS_LENGTH) {
+    return normalized;
+  }
+  return `${normalized.slice(0, DESCRIPTION_PREVIEW_LENGTH - 1).trimEnd()}\u2026`;
+}
+function summarizeIssue(issue) {
+  if (!issue || typeof issue !== "object") {
+    return {};
+  }
+  const record = issue;
+  return {
+    id: record.id,
+    subject: record.subject,
+    project: namedReferenceName(record.project),
+    tracker: namedReferenceName(record.tracker),
+    status: namedReferenceName(record.status),
+    priority: namedReferenceName(record.priority),
+    assignee: namedReferenceName(record.assigned_to),
+    author: namedReferenceName(record.author),
+    sprint: getIssueSprintValue(issue) || undefined,
+    description_preview: truncateDescription(record.description),
+    updated_on: record.updated_on,
+    created_on: record.created_on,
+    spent_hours: record.spent_hours,
+    estimated_hours: record.estimated_hours,
+    done_ratio: record.done_ratio
+  };
+}
+function summarizeIssueListResponse(response, issues = response.issues) {
+  return {
+    ...response,
+    issues: issues.map((issue) => summarizeIssue(issue))
+  };
+}
+function outputFormat(values) {
+  const value = optionalString2(values.output) ?? "json";
+  if (value !== "json" && value !== "md") {
+    throw new Error(`Invalid value for --output: ${value}`);
+  }
+  return value;
+}
+function mdEscape(value) {
+  return String(value ?? "").replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\|/g, "\\|").replace(/\*/g, "\\*").replace(/_/g, "\\_").replace(/\[/g, "\\[").replace(/\]/g, "\\]");
+}
+function scalarValue(value) {
+  if (value === undefined || value === null || value === "") {
+    return;
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  const name = namedReferenceName(value);
+  if (name) {
+    return name;
+  }
+  return;
+}
+function formatDateTime(value) {
+  if (typeof value !== "string" || !value) {
+    return;
+  }
+  if (/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+    return value;
+  }
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? value : date.toISOString();
+}
+function formatHours(value) {
+  if (typeof value !== "number") {
+    return scalarValue(value);
+  }
+  return `${value}h`;
+}
+function normalizeRedmineTextileToMarkdown(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const codeBlocks = [];
+  const protectCodeBlock = (_match, language, body) => {
+    const index = codeBlocks.push(`
+
+\`\`\`${language ? language.trim() : ""}
+${body.replace(/^\n|\n$/g, "")}
+\`\`\`
+
+`) - 1;
+    return `
+
+@@REDMINE_CODE_BLOCK_${index}@@
+
+`;
+  };
+  let text = value.replace(/\r\n/g, `
+`).replace(/<pre><code(?:\s+class=["']?([^"'>\s]+)["']?)?>([\s\S]*?)<\/code><\/pre>/gi, protectCodeBlock).replace(/<pre>([\s\S]*?)<\/pre>/gi, (_match, body) => protectCodeBlock("", undefined, body)).replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/^h([1-6])\.\s+/gm, (_, level) => `${"#".repeat(Number.parseInt(level, 10))} `).replace(/^bq\.\s+/gm, "> ").replace(/^p[<>=(){}[\]#.\w-]*\.\s+/gm, "").replace(/(^|[\s([{])\*([^*\n]+)\*(?=[\s).,!?:;\]}]|$)/g, "$1**$2**").replace(/\+([^+\n]+)\+/g, "$1").replace(/"([^"\n]+)":(https?:\/\/\S+)/g, "[$1]($2)").replace(/@([^@\n]+)@/g, "`$1`").replace(/\{\{(?:toc|>toc)\}\}/gi, "").trim();
+  text = text.replace(/@@REDMINE_CODE_BLOCK_(\d+)@@/g, (_match, index) => codeBlocks[Number.parseInt(index, 10)] ?? "");
+  return text || undefined;
+}
+function markdownTable(rows) {
+  const presentRows = rows.filter(([, value]) => value !== undefined && value !== "");
+  if (presentRows.length === 0) {
+    return "";
+  }
+  return ["| Field | Value |", "| --- | --- |", ...presentRows.map(([label, value]) => `| ${mdEscape(label)} | ${mdEscape(value)} |`)].join(`
+`);
+}
+function customFieldsMarkdown(issue) {
+  if (!Array.isArray(issue.custom_fields)) {
+    return "";
+  }
+  const rows = issue.custom_fields.filter((field) => isRecord(field)).map((field) => [scalarValue(field.name) ?? `Custom field ${scalarValue(field.id) ?? ""}`.trim(), scalarValue(field.value)]);
+  return markdownTable(rows);
+}
+function yamlString(value) {
+  return JSON.stringify(String(value ?? ""));
+}
+function joinNameAndId(value) {
+  const name = namedReferenceName(value);
+  const id = namedReferenceId(value);
+  if (name && id)
+    return `${name} (#${id})`;
+  return name ?? id;
+}
+function bulletList(items) {
+  return items.length > 0 ? items.map((item) => `- ${item}`).join(`
+`) : "";
+}
+function compactJson(value) {
+  if (value === undefined || value === null || value === "") {
+    return;
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  return JSON.stringify(value);
+}
+function summarizeChangedText(value) {
+  if (typeof value !== "string") {
+    return compactJson(value);
+  }
+  const normalized = value.replace(/\s+/g, " ").trim();
+  if (!normalized) {
+    return;
+  }
+  return `${normalized.length} chars${normalized.length <= 80 ? `: ${normalized}` : ""}`;
+}
+function journalDetailMarkdown(detail) {
+  const label = scalarValue(detail.label) ?? scalarValue(detail.name) ?? "Change";
+  const oldValue = scalarValue(detail.old_label) ?? compactJson(detail.old_value);
+  const newValue = scalarValue(detail.new_label) ?? compactJson(detail.new_value);
+  const property = scalarValue(detail.property);
+  const suffix = property && property !== "attr" ? ` (${mdEscape(property)})` : "";
+  if (detail.name === "description" || detail.name === "notes") {
+    const oldSummary = summarizeChangedText(detail.old_value);
+    const newSummary = summarizeChangedText(detail.new_value);
+    const summary = [oldSummary ? `previous ${oldSummary}` : undefined, newSummary ? `updated ${newSummary}` : undefined].filter(Boolean).join("; ");
+    return `- **${mdEscape(label)}${suffix}:** changed${summary ? ` (${mdEscape(summary)})` : ""}`;
+  }
+  const maxInlineLength = 160;
+  const oldInline = oldValue && oldValue.length > maxInlineLength ? `${oldValue.slice(0, maxInlineLength - 1).trimEnd()}\u2026` : oldValue;
+  const newInline = newValue && newValue.length > maxInlineLength ? `${newValue.slice(0, maxInlineLength - 1).trimEnd()}\u2026` : newValue;
+  if (oldInline !== undefined && newInline !== undefined) {
+    return `- **${mdEscape(label)}${suffix}:** \`${mdEscape(oldInline)}\` \u2192 \`${mdEscape(newInline)}\``;
+  }
+  if (newInline !== undefined) {
+    return `- **${mdEscape(label)}${suffix}:** set to \`${mdEscape(newInline)}\``;
+  }
+  if (oldInline !== undefined) {
+    return `- **${mdEscape(label)}${suffix}:** removed \`${mdEscape(oldInline)}\``;
+  }
+  return `- **${mdEscape(label)}${suffix}** changed`;
+}
+function issueResponseToMarkdown(response) {
+  const issue = isRecord(response) && isRecord(response.issue) ? response.issue : undefined;
+  if (!issue) {
+    return `---
+resource: redmine_issue
+generated_at: ${new Date().toISOString()}
+---
+
+# Redmine issue
+
+\`\`\`json
+${JSON.stringify(response, null, 2)}
+\`\`\`
+`;
+  }
+  const id = scalarValue(issue.id) ?? "?";
+  const subject = scalarValue(issue.subject) ?? "Untitled issue";
+  const frontmatter = [
+    "resource: redmine_issue",
+    `id: ${yamlString(id)}`,
+    `subject: ${yamlString(subject)}`,
+    `project: ${yamlString(namedReferenceName(issue.project) ?? "")}`,
+    `status: ${yamlString(namedReferenceName(issue.status) ?? "")}`,
+    `generated_at: ${new Date().toISOString()}`
+  ];
+  const parts = [`---
+${frontmatter.join(`
+`)}
+---`, `# #${mdEscape(id)} ${mdEscape(subject)}`];
+  const sprint = getIssueSprintValue(issue);
+  const overview = markdownTable([
+    ["Project", joinNameAndId(issue.project)],
+    ["Tracker", joinNameAndId(issue.tracker)],
+    ["Status", joinNameAndId(issue.status)],
+    ["Priority", joinNameAndId(issue.priority)],
+    ["Category", joinNameAndId(issue.category)],
+    ["Target version", joinNameAndId(issue.fixed_version)],
+    ["Parent", joinNameAndId(issue.parent)],
+    ["Assignee", joinNameAndId(issue.assigned_to)],
+    ["Author", joinNameAndId(issue.author)],
+    ["Sprint", sprint],
+    ["Done", scalarValue(issue.done_ratio) ? `${scalarValue(issue.done_ratio)}%` : undefined],
+    ["Estimated", formatHours(issue.estimated_hours)],
+    ["Spent", formatHours(issue.spent_hours)],
+    ["Total spent", formatHours(issue.total_spent_hours)],
+    ["Start", scalarValue(issue.start_date)],
+    ["Due", scalarValue(issue.due_date)],
+    ["Created", formatDateTime(issue.created_on)],
+    ["Updated", formatDateTime(issue.updated_on)],
+    ["Closed", formatDateTime(issue.closed_on)],
+    ["Private", issue.is_private === true ? "yes" : undefined]
+  ]);
+  if (overview)
+    parts.push("## Overview", overview);
+  const description = normalizeRedmineTextileToMarkdown(issue.description);
+  if (description)
+    parts.push("## Description", description);
+  const customFields = customFieldsMarkdown(issue);
+  if (customFields)
+    parts.push("## Custom fields", customFields);
+  if (Array.isArray(issue.attachments) && issue.attachments.length > 0) {
+    const items = issue.attachments.filter(isRecord).map((attachment) => {
+      const filename = scalarValue(attachment.filename) ?? scalarValue(attachment.id) ?? "attachment";
+      const url = scalarValue(attachment.content_url);
+      const author = namedReferenceName(attachment.author);
+      const size = scalarValue(attachment.filesize);
+      const meta = [size ? `${size} bytes` : undefined, author ? `by ${author}` : undefined, formatDateTime(attachment.created_on)].filter(Boolean).join(", ");
+      return `${url ? `[${mdEscape(filename)}](${url})` : mdEscape(filename)}${meta ? ` \u2014 ${mdEscape(meta)}` : ""}`;
+    });
+    parts.push("## Attachments", bulletList(items));
+  }
+  if (Array.isArray(issue.relations) && issue.relations.length > 0) {
+    const rows = issue.relations.filter(isRecord).map((relation) => [
+      scalarValue(relation.relation_type) ?? "relation",
+      `#${scalarValue(relation.issue_id) ?? "?"} \u2194 #${scalarValue(relation.issue_to_id) ?? "?"}${scalarValue(relation.delay) ? ` (${scalarValue(relation.delay)}d)` : ""}`
+    ]);
+    parts.push("## Relations", markdownTable(rows));
+  }
+  if (Array.isArray(issue.children) && issue.children.length > 0) {
+    const items = issue.children.filter(isRecord).map((child) => `#${scalarValue(child.id) ?? "?"} ${mdEscape(scalarValue(child.subject) ?? "Untitled")} \u2014 ${mdEscape(namedReferenceName(child.status) ?? "")}`.trim());
+    parts.push("## Children", bulletList(items));
+  }
+  if (Array.isArray(issue.changesets) && issue.changesets.length > 0) {
+    const items = issue.changesets.filter(isRecord).map((changeset) => {
+      const revision = scalarValue(changeset.revision) ?? scalarValue(changeset.id) ?? "changeset";
+      const comments = scalarValue(changeset.comments);
+      const author = scalarValue(changeset.user) ?? scalarValue(changeset.author);
+      const committed = formatDateTime(changeset.committed_on);
+      return [`\`${mdEscape(revision)}\``, author, committed, comments].filter(Boolean).join(" \u2014 ");
+    });
+    parts.push("## Changesets", bulletList(items));
+  }
+  if (Array.isArray(issue.watchers) && issue.watchers.length > 0) {
+    parts.push("## Watchers", bulletList(issue.watchers.map((watcher) => mdEscape(joinNameAndId(watcher) ?? compactJson(watcher) ?? "watcher"))));
+  }
+  if (Array.isArray(issue.time_entries) && issue.time_entries.length > 0) {
+    const rows = issue.time_entries.filter(isRecord).map((entry) => [
+      scalarValue(entry.spent_on) ?? formatDateTime(entry.created_on) ?? "time entry",
+      [formatHours(entry.hours), namedReferenceName(entry.user), namedReferenceName(entry.activity), scalarValue(entry.comments)].filter(Boolean).join(" \u2014 ")
+    ]);
+    parts.push("## Time entries", markdownTable(rows));
+  }
+  if (Array.isArray(issue.journals) && issue.journals.length > 0) {
+    parts.push("## Journal");
+    for (const journal of issue.journals.filter(isRecord)) {
+      const journalId = scalarValue(journal.id) ?? "?";
+      const author = namedReferenceName(journal.user) ?? "Unknown user";
+      const created = formatDateTime(journal.created_on) ?? scalarValue(journal.created_on) ?? "unknown date";
+      parts.push(`### Note ${mdEscape(journalId)} \u2014 ${mdEscape(author)} \u2014 ${mdEscape(created)}`);
+      const notes = normalizeRedmineTextileToMarkdown(journal.notes);
+      if (notes)
+        parts.push(notes);
+      if (Array.isArray(journal.details) && journal.details.length > 0) {
+        const detailBlocks = journal.details.filter(isRecord).map(journalDetailMarkdown);
+        parts.push(detailBlocks.join(`
+`));
+      }
+    }
+  }
+  if (isRecord(issue._enrichment) && Array.isArray(issue._enrichment.warnings) && issue._enrichment.warnings.length > 0) {
+    parts.push("## Enrichment warnings", bulletList(issue._enrichment.warnings.map((warning) => mdEscape(compactJson(warning) ?? "warning"))));
+  }
+  const renderedKeys = new Set([
+    "id",
+    "subject",
+    "project",
+    "tracker",
+    "status",
+    "priority",
+    "category",
+    "fixed_version",
+    "parent",
+    "assigned_to",
+    "author",
+    "custom_fields",
+    "custom_fields_by_name",
+    "done_ratio",
+    "estimated_hours",
+    "spent_hours",
+    "total_spent_hours",
+    "start_date",
+    "due_date",
+    "created_on",
+    "updated_on",
+    "closed_on",
+    "is_private",
+    "description",
+    "attachments",
+    "relations",
+    "children",
+    "changesets",
+    "watchers",
+    "time_entries",
+    "journals",
+    "_enrichment"
+  ]);
+  const additionalData = Object.fromEntries(Object.entries(issue).filter(([key]) => !renderedKeys.has(key)));
+  if (Object.keys(additionalData).length > 0) {
+    parts.push("## Additional data", `\`\`\`json
+${JSON.stringify(additionalData, null, 2)}
+\`\`\``);
+  }
+  return `${parts.filter(Boolean).join(`
+
+`)}
+`;
+}
+function issueListResponseToMarkdown(response, filters) {
+  const fetchedCount = response.issues.length;
+  const complete = response.offset + fetchedCount >= response.total_count;
+  const frontmatter = [
+    "resource: redmine_issue_list",
+    `total_count: ${response.total_count}`,
+    `fetched_count: ${fetchedCount}`,
+    `offset: ${response.offset}`,
+    `limit: ${response.limit}`,
+    `complete: ${complete}`,
+    `generated_at: ${new Date().toISOString()}`
+  ];
+  const activeFilters = [
+    filters.project ? `project=${filters.project}` : undefined,
+    filters.assignee ? `assignee=${filters.assignee}` : undefined,
+    filters.status ? `status=${filters.status}` : undefined,
+    filters.sprint ? `sprint=${filters.sprint.kind === "exact" ? filters.sprint.value : filters.sprint.kind}` : undefined
+  ].filter(Boolean);
+  const parts = [`---
+${frontmatter.join(`
+`)}
+---`, "# Redmine issues", `Fetched **${fetchedCount}** of **${response.total_count}** issues${complete ? "." : " (partial result)."}`];
+  if (activeFilters.length > 0) {
+    parts.push(`Filters: ${activeFilters.map((filter) => `\`${filter}\``).join(", ")}`);
+  }
+  for (const issue of response.issues) {
+    if (!isRecord(issue)) {
+      continue;
+    }
+    const id = scalarValue(issue.id) ?? "?";
+    const subject = scalarValue(issue.subject) ?? "Untitled issue";
+    const sprint = getIssueSprintValue(issue);
+    const fields = markdownTable([
+      ["Project", scalarValue(issue.project)],
+      ["Tracker", scalarValue(issue.tracker)],
+      ["Status", scalarValue(issue.status)],
+      ["Priority", scalarValue(issue.priority)],
+      ["Assignee", scalarValue(issue.assigned_to)],
+      ["Author", scalarValue(issue.author)],
+      ["Sprint", sprint],
+      ["Done", scalarValue(issue.done_ratio) ? `${scalarValue(issue.done_ratio)}%` : undefined],
+      ["Estimated", formatHours(issue.estimated_hours)],
+      ["Spent", formatHours(issue.spent_hours)],
+      ["Total spent", formatHours(issue.total_spent_hours)],
+      ["Start", scalarValue(issue.start_date)],
+      ["Due", scalarValue(issue.due_date)],
+      ["Created", formatDateTime(issue.created_on)],
+      ["Updated", formatDateTime(issue.updated_on)],
+      ["Closed", formatDateTime(issue.closed_on)],
+      ["Private", issue.is_private === true ? "yes" : undefined]
+    ]);
+    parts.push(`## #${mdEscape(id)} ${mdEscape(subject)}`);
+    if (fields) {
+      parts.push(fields);
+    }
+    const description = normalizeRedmineTextileToMarkdown(issue.description);
+    if (description) {
+      parts.push("### Description", description);
+    }
+    const customFields = customFieldsMarkdown(issue);
+    if (customFields) {
+      parts.push("### Custom fields", customFields);
+    }
+  }
+  return `${parts.join(`
+
+`)}
+`;
+}
+function printIssueListResponse(response, values, filters) {
+  if (outputFormat(values) === "md") {
+    process.stdout.write(renderMarkdownForTerminal(issueListResponseToMarkdown(response, filters)));
+    return;
+  }
+  console.log(JSON.stringify(values.raw === true ? response : summarizeIssueListResponse(response), null, 2));
+}
+async function redmineGetJsonOptional(config, path, query, cacheTtlMs) {
+  try {
+    return { data: cacheTtlMs === undefined ? await redmineGetJson(config, { path, query }) : await redmineGetJsonCached(config, { path, query }, cacheTtlMs) };
+  } catch (error) {
+    return { warning: `${path}: ${error instanceof Error ? error.message : String(error)}` };
+  }
+}
+function customFieldsByName(issue) {
+  const customFields = issue.custom_fields;
+  if (!Array.isArray(customFields)) {
+    return;
+  }
+  const byName = {};
+  for (const field of customFields) {
+    if (!isRecord(field) || typeof field.name !== "string") {
+      continue;
+    }
+    byName[field.name] = field.value;
+  }
+  return byName;
+}
+function detailLabel(name, lookups) {
+  if (lookups.customFields.has(name.replace(/^cf_/, ""))) {
+    return lookups.customFields.get(name.replace(/^cf_/, ""));
+  }
+  const labels = {
+    assigned_to_id: "Assignee",
+    category_id: "Category",
+    done_ratio: "Done ratio",
+    due_date: "Due date",
+    estimated_hours: "Estimated hours",
+    fixed_version_id: "Target version",
+    is_private: "Private",
+    priority_id: "Priority",
+    project_id: "Project",
+    start_date: "Start date",
+    status_id: "Status",
+    subject: "Subject",
+    tracker_id: "Tracker"
+  };
+  return labels[name];
+}
+function valueLabel(name, value, lookups) {
+  if (value === undefined || value === null || value === "") {
+    return;
+  }
+  const key = String(value);
+  if (name === "status_id")
+    return lookups.statuses.get(key);
+  if (name === "tracker_id")
+    return lookups.trackers.get(key);
+  if (name === "priority_id")
+    return lookups.priorities.get(key);
+  if (name === "fixed_version_id")
+    return lookups.versions.get(key);
+  if (name === "category_id")
+    return lookups.categories.get(key);
+  if (name === "assigned_to_id" || name === "user_id" || name === "author_id")
+    return lookups.users.get(key);
+  if (name.startsWith("cf_"))
+    return lookups.customFields.get(name.slice(3));
+  return;
+}
+function enrichJournalDetail(detail, lookups) {
+  if (!isRecord(detail) || typeof detail.name !== "string") {
+    return detail;
+  }
+  const label = detailLabel(detail.name, lookups);
+  const oldLabel = valueLabel(detail.name, detail.old_value, lookups);
+  const newLabel = valueLabel(detail.name, detail.new_value, lookups);
+  return {
+    ...detail,
+    ...label ? { label } : {},
+    ...oldLabel ? { old_label: oldLabel } : {},
+    ...newLabel ? { new_label: newLabel } : {}
+  };
+}
+function enrichIssueResponse(response, enrichment) {
+  if (!isRecord(response) || !isRecord(response.issue)) {
+    return response;
+  }
+  const issue = response.issue;
+  const customFields = customFieldsByName(issue);
+  const journals = Array.isArray(issue.journals) ? issue.journals.map((journal) => {
+    if (!isRecord(journal)) {
+      return journal;
+    }
+    return {
+      ...journal,
+      details: Array.isArray(journal.details) ? journal.details.map((detail) => enrichJournalDetail(detail, enrichment.lookups)) : journal.details
+    };
+  }) : issue.journals;
+  return {
+    ...response,
+    issue: {
+      ...issue,
+      ...customFields ? { custom_fields_by_name: customFields } : {},
+      ...journals ? { journals } : {},
+      ...enrichment.timeEntries ? { time_entries: enrichment.timeEntries } : {},
+      _enrichment: {
+        includes: DEFAULT_ISSUE_GET_INCLUDE.split(","),
+        secondary_resources: ["time_entries", "issue_statuses", "trackers", "issue_priorities", "custom_fields", "versions", "issue_categories", "users"],
+        warnings: enrichment.warnings
+      }
+    }
+  };
+}
+function collectJournalUserIds(issue) {
+  if (!isRecord(issue) || !Array.isArray(issue.journals)) {
+    return [];
+  }
+  const ids = new Set;
+  for (const journal of issue.journals) {
+    if (!isRecord(journal)) {
+      continue;
+    }
+    const userId = namedReferenceId(journal.user);
+    if (userId)
+      ids.add(userId);
+    if (!Array.isArray(journal.details)) {
+      continue;
+    }
+    for (const detail of journal.details) {
+      if (!isRecord(detail) || typeof detail.name !== "string") {
+        continue;
+      }
+      if (detail.name === "assigned_to_id" || detail.name === "user_id" || detail.name === "author_id") {
+        for (const value of [detail.old_value, detail.new_value]) {
+          if (typeof value === "string" || typeof value === "number") {
+            ids.add(String(value));
+          }
+        }
+      }
+    }
+  }
+  return [...ids];
+}
+async function fetchIssueEnrichment(config, issueId, issue) {
+  const lookups = createLookupMaps();
+  const warnings = [];
+  if (isRecord(issue)) {
+    addNamedReferencesToMap(lookups.users, [issue.author, issue.assigned_to]);
+  }
+  const projectId = isRecord(issue) ? namedReferenceId(issue.project) : undefined;
+  const requests = await Promise.all([
+    redmineGetJsonOptional(config, "/time_entries.json", { issue_id: issueId, limit: 100 }),
+    redmineGetJsonOptional(config, "/issue_statuses.json", undefined, DAY_MS),
+    redmineGetJsonOptional(config, "/trackers.json", undefined, DAY_MS),
+    redmineGetJsonOptional(config, "/enumerations/issue_priorities.json", undefined, DAY_MS),
+    redmineGetJsonOptional(config, "/custom_fields.json", undefined, DAY_MS),
+    projectId ? redmineGetJsonOptional(config, `/projects/${projectId}/versions.json`, undefined, DAY_MS) : Promise.resolve({ data: undefined, warning: undefined }),
+    projectId ? redmineGetJsonOptional(config, `/projects/${projectId}/issue_categories.json`, undefined, DAY_MS) : Promise.resolve({ data: undefined, warning: undefined })
+  ]);
+  for (const request of requests) {
+    if (request.warning)
+      warnings.push(request.warning);
+  }
+  const [timeEntries, statuses, trackers, priorities, customFields, versions, categories] = requests.map((request) => request.data);
+  addNamedReferencesToMap(lookups.statuses, lookupArray(statuses, "issue_statuses"));
+  addNamedReferencesToMap(lookups.trackers, lookupArray(trackers, "trackers"));
+  addNamedReferencesToMap(lookups.priorities, lookupArray(priorities, "issue_priorities"));
+  addNamedReferencesToMap(lookups.customFields, lookupArray(customFields, "custom_fields"));
+  addNamedReferencesToMap(lookups.versions, lookupArray(versions, "versions"));
+  addNamedReferencesToMap(lookups.categories, lookupArray(categories, "issue_categories"));
+  const userIds = collectJournalUserIds(issue).filter((id) => !lookups.users.has(id)).slice(0, 25);
+  const userRequests = await Promise.all(userIds.map((id) => redmineGetJsonOptional(config, `/users/${id}.json`, undefined, DAY_MS)));
+  const userLookups = createLookupMaps();
+  for (const userRequest of userRequests) {
+    if (userRequest.warning) {
+      warnings.push(userRequest.warning);
+      continue;
+    }
+    if (isRecord(userRequest.data) && isRecord(userRequest.data.user)) {
+      const id = namedReferenceId(userRequest.data.user);
+      const name = namedReferenceName(userRequest.data.user);
+      if (id && name) {
+        userLookups.users.set(id, name);
+      }
+    }
+  }
+  mergeLookupMaps(lookups, userLookups);
+  return {
+    lookups,
+    timeEntries: Array.isArray(lookupArray(timeEntries, "time_entries")) ? lookupArray(timeEntries, "time_entries") : undefined,
+    warnings
+  };
+}
+async function confirmAll(totalRequests) {
+  const readline = createInterface2({ input: input2, output: output2 });
+  try {
+    const answer = await readline.question(`Fetch all? ${totalRequests} requests. Continue? [y/N] `);
+    return answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
+  } finally {
+    readline.close();
+  }
+}
+function utcDateOnly(value) {
+  return new Date(Date.UTC(value.getUTCFullYear(), value.getUTCMonth(), value.getUTCDate()));
+}
+function addDays(value, days) {
+  return new Date(value.getTime() + days * DAY_MS);
+}
+function formatSprintDate(value, includeYear) {
+  const day = String(value.getUTCDate()).padStart(2, "0");
+  const month = String(value.getUTCMonth() + 1).padStart(2, "0");
+  if (!includeYear) {
+    return `${day}.${month}.`;
+  }
+  const year = String(value.getUTCFullYear()).slice(-2);
+  return `${day}.${month}.${year}`;
+}
+function currentSprintIndex() {
+  const anchor = new Date(`${SPRINT_ANCHOR_START}T00:00:00Z`);
+  const today = utcDateOnly(new Date);
+  return Math.floor((today.getTime() - anchor.getTime()) / (SPRINT_DAYS * DAY_MS));
+}
+function currentSprintNumber() {
+  return SPRINT_ANCHOR_NUMBER + currentSprintIndex();
+}
+function sprintLabel(offset) {
+  const anchor = new Date(`${SPRINT_ANCHOR_START}T00:00:00Z`);
+  const sprintIndex = currentSprintIndex() + offset;
+  const sprintNumber = SPRINT_ANCHOR_NUMBER + sprintIndex;
+  const start = addDays(anchor, sprintIndex * SPRINT_DAYS);
+  const end = addDays(start, SPRINT_WORK_DAYS - 1);
+  return `Sprint ${String(sprintNumber).padStart(2, "0")} (${formatSprintDate(start, false)} - ${formatSprintDate(end, true)})`;
+}
+function resolveSprint(value) {
+  if (!value) {
+    return;
+  }
+  switch (value.toLowerCase()) {
+    case "backlog":
+      return { kind: "exact", value: "Backlog" };
+    case "current":
+      return { kind: "exact", value: sprintLabel(0) };
+    case "last":
+      return { kind: "exact", value: sprintLabel(-1) };
+    case "next":
+      return { kind: "exact", value: sprintLabel(1) };
+    case "past":
+      return { kind: "past" };
+    case "future":
+      return { kind: "future" };
+    default:
+      return { kind: "exact", value };
+  }
+}
+function resolveStatus(value) {
+  if (!value || value === "open") {
+    return "open";
+  }
+  if (value === "all") {
+    return "*";
+  }
+  return value;
+}
+function buildIssueQuery(filters, limit, offset) {
+  return {
+    project_id: filters.project,
+    assigned_to_id: filters.assignee,
+    status_id: filters.status,
+    [`cf_${SPRINT_CUSTOM_FIELD_ID}`]: filters.sprint?.kind === "exact" ? filters.sprint.value : undefined,
+    sort: "updated_on:desc",
+    limit,
+    offset
+  };
+}
+function filtersFromValues(values, overrides = {}) {
+  return {
+    project: optionalString2(values.project),
+    assignee: overrides.assignee ?? optionalString2(values.assignee),
+    status: overrides.status ?? resolveStatus(optionalString2(values.status)),
+    sprint: overrides.sprint ?? resolveSprint(optionalString2(values.sprint))
+  };
+}
+function getIssueSprintValue(issue) {
+  if (!issue || typeof issue !== "object") {
+    return;
+  }
+  const customFields = issue.custom_fields;
+  if (!Array.isArray(customFields)) {
+    return;
+  }
+  const sprintField = customFields.find((field) => {
+    return Boolean(field && typeof field === "object" && field.id === SPRINT_CUSTOM_FIELD_ID);
+  });
+  return sprintField && typeof sprintField === "object" && typeof sprintField.value === "string" ? sprintField.value : undefined;
+}
+function sprintNumberFromValue(value) {
+  const match = value?.match(/^Sprint\s+(\d+)\b/);
+  if (!match) {
+    return;
+  }
+  const parsed = Number.parseInt(match[1], 10);
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+function issueMatchesRelativeSprint(issue, sprint) {
+  const sprintNumber = sprintNumberFromValue(getIssueSprintValue(issue));
+  if (sprintNumber === undefined) {
+    return false;
+  }
+  const current = currentSprintNumber();
+  return sprint.kind === "past" ? sprintNumber < current : sprintNumber > current;
+}
+async function fetchRemainingPages(config, firstPage, filters, pageLimit, confirm) {
+  const totalPages = Math.ceil(firstPage.total_count / pageLimit);
+  if (confirm && totalPages > 10 && !await confirmAll(totalPages)) {
+    return;
+  }
+  const issues = [...firstPage.issues];
+  for (let pageIndex = 1;pageIndex < totalPages; pageIndex += 1) {
+    const page = await redmineGetJson(config, {
+      path: "/issues.json",
+      query: buildIssueQuery(filters, pageLimit, pageIndex * pageLimit)
+    });
+    if (!isIssueListResponse(page)) {
+      throw new Error("Unexpected Redmine issue list response");
+    }
+    issues.push(...page.issues);
+  }
+  return issues;
+}
+async function executeIssueList(values, filters) {
+  const limit = optionalNumber(values.limit, 25);
+  if (limit < 1) {
+    throw new Error("Expected --limit to be at least 1");
+  }
+  const offset = optionalNumber(values.offset, 0);
+  const config = await loadConfig();
+  if (filters.sprint?.kind === "past" || filters.sprint?.kind === "future") {
+    const pageLimit = 100;
+    const serverFilters = { ...filters, sprint: undefined };
+    const firstPage2 = await redmineGetJson(config, {
+      path: "/issues.json",
+      query: buildIssueQuery(serverFilters, pageLimit, 0)
+    });
+    if (!isIssueListResponse(firstPage2)) {
+      throw new Error("Unexpected Redmine issue list response");
+    }
+    const allIssues = await fetchRemainingPages(config, firstPage2, serverFilters, pageLimit, values.yes !== true);
+    if (!allIssues) {
+      return;
+    }
+    const filteredIssues = allIssues.filter((issue) => issueMatchesRelativeSprint(issue, filters.sprint));
+    const issues2 = values.all === true ? filteredIssues.slice(offset) : filteredIssues.slice(offset, offset + limit);
+    const response2 = { ...firstPage2, issues: issues2, total_count: filteredIssues.length, offset, limit: values.all === true ? issues2.length : limit };
+    printIssueListResponse(response2, values, filters);
+    return;
+  }
+  const firstPage = await redmineGetJson(config, {
+    path: "/issues.json",
+    query: buildIssueQuery(filters, limit, offset)
+  });
+  if (values.all !== true) {
+    if (!isIssueListResponse(firstPage)) {
+      throw new Error("Unexpected Redmine issue list response");
+    }
+    printIssueListResponse(firstPage, values, filters);
+    return;
+  }
+  if (!isIssueListResponse(firstPage)) {
+    throw new Error("Unexpected Redmine issue list response");
+  }
+  const totalRemaining = Math.max(firstPage.total_count - offset, 0);
+  const totalPages = Math.ceil(totalRemaining / limit);
+  if (totalPages > 10 && values.yes !== true && !await confirmAll(totalPages)) {
+    return;
+  }
+  const issues = [...firstPage.issues];
+  for (let pageIndex = 1;pageIndex < totalPages; pageIndex += 1) {
+    const pageOffset = offset + pageIndex * limit;
+    const page = await redmineGetJson(config, {
+      path: "/issues.json",
+      query: buildIssueQuery(filters, limit, pageOffset)
+    });
+    if (!isIssueListResponse(page)) {
+      throw new Error("Unexpected Redmine issue list response");
+    }
+    issues.push(...page.issues);
+  }
+  const response = { ...firstPage, issues, offset, limit: issues.length };
+  printIssueListResponse(response, values, filters);
+}
+var issueListFlags = [
+  {
+    name: "project",
+    aliases: ["p"],
+    type: "string",
+    description: "Project identifier or ID to filter by"
+  },
+  {
+    name: "assignee",
+    type: "string",
+    description: "Assignee user ID, or 'me'"
+  },
+  {
+    name: "status",
+    type: "string",
+    description: "Issue status filter: open, closed, all, or a status ID",
+    defaultValue: "open"
+  },
+  {
+    name: "sprint",
+    type: "string",
+    description: "Sprint filter: backlog, current, last, next, past, future, or an exact Sprint custom-field value"
+  },
+  {
+    name: "limit",
+    type: "string",
+    description: "Maximum number of issues to return",
+    defaultValue: "25"
+  },
+  {
+    name: "offset",
+    type: "string",
+    description: "Number of issues to skip",
+    defaultValue: "0"
+  },
+  {
+    name: "all",
+    aliases: ["a"],
+    type: "boolean",
+    description: "Fetch all pages"
+  },
+  {
+    name: "raw",
+    type: "boolean",
+    description: "Output unmodified Redmine issue list JSON"
+  },
+  {
+    name: "output",
+    aliases: ["o"],
+    type: "string",
+    choices: ["json", "md"],
+    description: "Output format: json or md",
+    defaultValue: "json"
+  },
+  {
+    name: "yes",
+    aliases: ["y"],
+    type: "boolean",
+    description: "Skip confirmation prompts"
+  }
+];
+var issueGetCommand = {
+  name: "get",
+  requiresConfig: true,
+  aliases: ["show"],
+  summary: "Get an issue",
+  description: "Get a single Redmine issue as JSON. Journals, attachments, relations, changesets, and watchers are included by default.",
+  arguments: [
+    {
+      name: "id",
+      description: "Issue ID",
+      required: true
+    }
+  ],
+  flags: [
+    {
+      name: "include",
+      aliases: ["i"],
+      type: "string",
+      description: "Comma-separated Redmine issue includes, or 'none'",
+      defaultValue: DEFAULT_ISSUE_GET_INCLUDE
+    },
+    {
+      name: "raw",
+      type: "boolean",
+      description: "Output only the primary Redmine issue response, without secondary detail enrichment"
+    },
+    {
+      name: "output",
+      aliases: ["o"],
+      type: "string",
+      choices: ["json", "md"],
+      description: "Output format: json or md",
+      defaultValue: "json"
+    },
+    {
+      name: "no-secondary",
+      type: "boolean",
+      description: "Skip secondary requests for time entries and lookup metadata"
+    }
+  ],
+  examples: ["redmine issue get 43135", "redmine issue get 43135 -o md", "redmine issue get 43135 --include journals,attachments,relations", "redmine issue get 43135 --include none", "redmine issue get 43135 --raw"],
+  execute: async ({ values, positionals }) => {
+    if (positionals.length !== 1) {
+      throw new Error("Expected exactly one issue ID argument");
+    }
+    const issueId = requirePositiveInteger(positionals[0], "issue ID");
+    const include = optionalString2(values.include);
+    const config = await loadConfig();
+    const response = await redmineGetJson(config, {
+      path: `/issues/${issueId}.json`,
+      query: { include: include && include !== "none" ? include : undefined }
+    });
+    const format = outputFormat(values);
+    if (values.raw === true || values["no-secondary"] === true || !isRecord(response) || !isRecord(response.issue)) {
+      if (format === "md") {
+        process.stdout.write(renderMarkdownForTerminal(issueResponseToMarkdown(response)));
+        return;
+      }
+      console.log(JSON.stringify(response, null, 2));
+      return;
+    }
+    const enrichment = await fetchIssueEnrichment(config, issueId, response.issue);
+    const enriched = enrichIssueResponse(response, enrichment);
+    if (format === "md") {
+      process.stdout.write(renderMarkdownForTerminal(issueResponseToMarkdown(enriched)));
+      return;
+    }
+    console.log(JSON.stringify(enriched, null, 2));
+  }
+};
+var issueListCommand = {
+  name: "list",
+  requiresConfig: true,
+  summary: "List issues",
+  description: "List Redmine issues. Results are filtered to semantically open issues by default.",
+  flags: issueListFlags,
+  examples: [
+    "redmine issue list",
+    "redmine issue list -p ai",
+    "redmine issue list -p ai -o md",
+    "redmine issue list --assignee me --sprint current",
+    "redmine issue list --assignee 585 --status all",
+    "redmine issue list --sprint backlog -a -y",
+    "redmine issue list --assignee me --sprint past"
+  ],
+  execute: async ({ values, positionals }) => {
+    if (positionals.length > 0) {
+      throw new Error(`Unexpected argument: ${positionals[0]}`);
+    }
+    await executeIssueList(values, filtersFromValues(values));
+  }
+};
+var issueMineCommand = {
+  name: "mine",
+  requiresConfig: true,
+  summary: "List my open issues",
+  description: "List issues assigned to the configured Redmine user. Results are filtered to semantically open issues by default.",
+  flags: issueListFlags.filter((flag) => flag.name !== "assignee"),
+  examples: ["redmine issue mine", "redmine issue mine --sprint current", "redmine issue mine -p ai --sprint backlog"],
+  execute: async ({ values, positionals }) => {
+    if (positionals.length > 0) {
+      throw new Error(`Unexpected argument: ${positionals[0]}`);
+    }
+    await executeIssueList(values, filtersFromValues(values, { assignee: "me" }));
+  }
+};
+var issueAssignedCommand = {
+  name: "assigned",
+  requiresConfig: true,
+  summary: "List issues assigned to a user",
+  description: "List issues assigned to a Redmine user ID, or to 'me'. Results are filtered to semantically open issues by default.",
+  arguments: [
+    {
+      name: "assignee",
+      description: "Assignee user ID, or 'me'",
+      required: true
+    }
+  ],
+  flags: issueListFlags.filter((flag) => flag.name !== "assignee"),
+  examples: ["redmine issue assigned me", "redmine issue assigned 585 --sprint current", "redmine issue assigned 585 -p ai"],
+  execute: async ({ values, positionals }) => {
+    if (positionals.length !== 1) {
+      throw new Error("Expected exactly one assignee argument: user ID or 'me'");
+    }
+    await executeIssueList(values, filtersFromValues(values, { assignee: positionals[0] }));
+  }
+};
+var issueCommand = {
+  name: "issue",
+  aliases: ["issues"],
+  summary: "Work with issues",
+  description: "Commands for Redmine issues.",
+  subcommands: [issueGetCommand, issueListCommand, issueMineCommand, issueAssignedCommand]
+};
+
+// src/cli/registry.ts
+var globalFlags = [
+  {
+    name: "help",
+    aliases: ["h"],
+    type: "boolean",
+    description: "Show help"
+  },
+  {
+    name: "version",
+    aliases: ["v"],
+    type: "boolean",
+    description: "Show version"
+  }
+];
+var rootCommand = {
+  name: "redmine",
+  summary: "Redmine CLI",
+  description: "Inspect and manage Redmine resources from the command line.",
+  subcommands: [configCommand, issueCommand]
+};
+function getVisibleSubcommands(command) {
+  return (command.subcommands ?? []).filter((entry) => entry.hidden !== true);
+}
+function findSubcommand(command, name) {
+  return (command.subcommands ?? []).find((entry) => entry.name === name || (entry.aliases ?? []).includes(name));
+}
+function resolveCommandPath(args) {
+  const path = [];
+  let current = rootCommand;
+  let index = 0;
+  while (index < args.length) {
+    const token = args[index];
+    if (!token || token.startsWith("-")) {
+      break;
+    }
+    const next = findSubcommand(current, token);
+    if (!next) {
+      break;
+    }
+    path.push(next);
+    current = next;
+    index += 1;
+  }
+  const nextToken = args[index];
+  const unknownCommand = Boolean(path.length > 0 && nextToken && !nextToken.startsWith("-") && (current.subcommands ?? []).length > 0);
+  const unknownTopLevelCommand = path.length === 0 && args[0] !== undefined && !args[0].startsWith("-");
+  return {
+    command: path.at(-1),
+    path,
+    consumed: index,
+    unknownCommand,
+    unknownTopLevelCommand
+  };
+}
+function collectCommandFlags(command) {
+  return [...globalFlags, ...command?.flags ?? []];
+}
+
+// src/cli/help.ts
+function formatArgument(argument) {
+  const base = argument.variadic ? `${argument.name}...` : argument.name;
+  return argument.required ? `<${base}>` : `[${base}]`;
+}
+function formatFlag(flag) {
+  const aliases = (flag.aliases ?? []).map((alias) => alias.length === 1 ? `-${alias}` : `--${alias}`);
+  const label = ["--" + flag.name, ...aliases].join(", ");
+  return `${label}${flag.type === "string" ? " <value>" : ""}`;
+}
+function formatFlagDetails(flag) {
+  const details = [];
+  if (flag.required) {
+    details.push("required");
+  }
+  if (flag.defaultValue !== undefined) {
+    details.push(`default: ${String(flag.defaultValue)}`);
+  }
+  if (flag.choices && flag.choices.length > 0) {
+    details.push(`choices: ${flag.choices.join(", ")}`);
+  }
+  return details.length > 0 ? ` (${details.join("; ")})` : "";
+}
+function printUsage(command, path) {
+  const names = path.map((entry) => entry.name);
+  const commandPath = names.length > 0 ? ` ${names.join(" ")}` : "";
+  const executable = typeof command.execute === "function";
+  const subcommands = getVisibleSubcommands(command);
+  const hasOptions = collectCommandFlags(command).length > 0;
+  const argumentList = (command.arguments ?? []).map(formatArgument).join(" ");
+  console.log("Usage:");
+  if (subcommands.length > 0) {
+    console.log(`  redmine${commandPath} <subcommand>`);
+  }
+  if (executable) {
+    const parts = [`redmine${commandPath}`];
+    if (hasOptions) {
+      parts.push("[options]");
+    }
+    if (argumentList) {
+      parts.push(argumentList);
+    }
+    console.log(`  ${parts.join(" ")}`);
+  }
+}
+function printArguments(command) {
+  const argumentsList = command.arguments ?? [];
+  if (argumentsList.length === 0) {
+    return;
+  }
+  console.log();
+  console.log("Arguments:");
+  for (const argument of argumentsList) {
+    console.log(`  ${formatArgument(argument)}`);
+    console.log(`      ${argument.description}`);
+  }
+}
+function printFlags(command) {
+  const flags = collectCommandFlags(command).filter((flag) => flag.hidden !== true);
+  if (flags.length === 0) {
+    return;
+  }
+  console.log();
+  console.log("Options:");
+  for (const flag of flags) {
+    console.log(`  ${formatFlag(flag)}`);
+    console.log(`      ${flag.description}${formatFlagDetails(flag)}`);
+  }
+}
+function printSubcommands(command, path) {
+  const subcommands = getVisibleSubcommands(command);
+  if (subcommands.length === 0) {
+    return;
+  }
+  const prefix = path.map((entry) => entry.name).join(" ");
+  console.log();
+  console.log("Subcommands:");
+  for (const subcommand of subcommands) {
+    const label = prefix ? `${prefix} ${subcommand.name}` : subcommand.name;
+    console.log(`  ${label} - ${subcommand.summary}`);
+  }
+}
+function printExamples(command) {
+  if (!command.examples || command.examples.length === 0) {
+    return;
+  }
+  console.log();
+  console.log("Examples:");
+  for (const example of command.examples) {
+    console.log(`  ${example}`);
+  }
+}
+function printCommandHelp(command, path) {
+  const title = path.length === 0 ? rootCommand.name : `${rootCommand.name} ${path.map((entry) => entry.name).join(" ")}`;
+  console.log(title);
+  console.log();
+  console.log(command.description ?? command.summary);
+  console.log();
+  printUsage(command, path);
+  printArguments(command);
+  printFlags(command);
+  printSubcommands(command, path);
+  printExamples(command);
+}
+function printRootHelp() {
+  printCommandHelp(rootCommand, []);
+  console.log();
+  console.log("Run `redmine <command> --help` for command-specific help.");
+}
+
+// src/cli/parse.ts
+function buildFlagMaps(flags) {
+  const byLongName = new Map;
+  const byAlias = new Map;
+  for (const flag of flags) {
+    byLongName.set(flag.name, flag);
+    for (const alias of flag.aliases ?? []) {
+      byAlias.set(alias, flag);
+    }
+  }
+  return { byLongName, byAlias };
+}
+function parseFlagToken(arg, maps) {
+  if (arg.startsWith("--")) {
+    const body = arg.slice(2);
+    const [name, inlineValue] = body.split("=", 2);
+    return {
+      flag: maps.byLongName.get(name),
+      inlineValue,
+      displayName: `--${name}`
+    };
+  }
+  if (arg.startsWith("-") && arg.length > 1) {
+    const alias = arg.slice(1);
+    return {
+      flag: maps.byAlias.get(alias),
+      inlineValue: undefined,
+      displayName: `-${alias}`
+    };
+  }
+  return {
+    flag: undefined,
+    inlineValue: undefined,
+    displayName: arg
+  };
+}
+function parseValues(args, flags) {
+  const maps = buildFlagMaps(flags);
+  const values = {};
+  const positionals = [];
+  for (let index = 0;index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--") {
+      positionals.push(...args.slice(index + 1));
+      break;
+    }
+    if (!arg.startsWith("-")) {
+      positionals.push(arg);
+      continue;
+    }
+    const { flag, inlineValue, displayName } = parseFlagToken(arg, maps);
+    if (!flag) {
+      throw new Error(`Unknown option: ${displayName}`);
+    }
+    if (flag.type === "boolean") {
+      if (inlineValue !== undefined) {
+        throw new Error(`Option ${displayName} does not take a value`);
+      }
+      values[flag.name] = true;
+      continue;
+    }
+    const value = inlineValue ?? args[index + 1];
+    if (value === undefined || value.startsWith("-")) {
+      throw new Error(`Missing value for option ${displayName}`);
+    }
+    values[flag.name] = value;
+    index += inlineValue === undefined ? 1 : 0;
+  }
+  const wantsHelp = values.help === true;
+  for (const flag of flags) {
+    if (values[flag.name] === undefined && flag.defaultValue !== undefined) {
+      values[flag.name] = flag.defaultValue;
+    }
+    if (!wantsHelp && flag.required && values[flag.name] === undefined) {
+      throw new Error(`Missing required option: --${flag.name}`);
+    }
+    const value = values[flag.name];
+    if (flag.choices && typeof value === "string" && !flag.choices.includes(value)) {
+      throw new Error(`Invalid value for --${flag.name}: ${value}`);
+    }
+  }
+  return { values, positionals };
+}
+function parseCli(args) {
+  const resolved = resolveCommandPath(args);
+  if (resolved.unknownTopLevelCommand) {
+    throw new Error(`Unknown command: ${args[0]}`);
+  }
+  if (resolved.unknownCommand) {
+    const unknownToken = args[resolved.consumed];
+    const commandPath = resolved.path.map((entry) => entry.name).join(" ");
+    throw new Error(`Unknown subcommand for ${commandPath}: ${unknownToken}`);
+  }
+  const command = resolved.command;
+  const flags = collectCommandFlags(command);
+  const parsed = parseValues(args.slice(resolved.consumed), flags);
+  return {
+    command,
+    path: resolved.path,
+    values: parsed.values,
+    positionals: parsed.positionals
+  };
+}
+// package.json
+var package_default = {
+  name: "@emmertarmin/redmine-cli",
+  version: "0.1.0",
+  description: "A personal Redmine CLI.",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/emmertarmin/redmine-cli.git"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  type: "module",
+  bin: {
+    redmine: "dist/index.js"
+  },
+  files: [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  engines: {
+    bun: ">=1.0.0"
+  },
+  scripts: {
+    dev: "bun --watch run index.ts",
+    build: "bun build ./index.ts --outdir dist --target bun",
+    tsc: "tsc --noEmit",
+    prepublishOnly: "bun run build"
+  },
+  devDependencies: {
+    "@types/bun": "latest",
+    "@types/node": "^22.15.21",
+    typescript: "^5.8.3"
+  }
+};
+
+// src/version.ts
+var VERSION = package_default.version;
+function printVersion() {
+  console.log(`redmine v${VERSION}`);
+}
+
+// src/index.ts
+async function main() {
+  await ensureConfigDir();
+  const parsed = parseCli(process.argv.slice(2));
+  const wantsHelp = parsed.values.help === true;
+  const wantsVersion = parsed.values.version === true;
+  if (wantsVersion) {
+    printVersion();
+    return;
+  }
+  if (!parsed.command) {
+    if (wantsHelp || parsed.positionals.length === 0) {
+      printRootHelp();
+      return;
+    }
+    throw new Error("Missing command. Run `redmine --help` to see available commands.");
+  }
+  if (wantsHelp || typeof parsed.command.execute !== "function") {
+    printCommandHelp(parsed.command, parsed.path);
+    return;
+  }
+  if (parsed.command.requiresConfig === true) {
+    const missing = getMissingRequiredConfig(await loadConfig());
+    if (missing.length > 0) {
+      console.error(`Warning: ${formatMissingConfigWarning(missing)}`);
+      process.exit(1);
+    }
+  }
+  await parsed.command.execute({
+    values: parsed.values,
+    positionals: parsed.positionals
+  });
+}
+main().then(() => {
+  process.exit(0);
+}).catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`Error: ${message}`);
+  process.exit(1);
+});