@emmertarmin/redmine-cli 0.1.1 → 0.1.3

package/README.md

@@ -40,10 +40,27 @@ Options:
 Subcommands:
   config - Manage configuration
   issue - Work with issues
+  activity - Watch Redmine activity
 
 Run `redmine <command> --help` for command-specific help.
 ```
 
+### Watch activity
+
+```bash
+redmine activity
+redmine activity -n 60
+redmine activity -o jsonl
+redmine activity watch
+redmine activity watch -n 5
+redmine activity watch -o jsonl
+redmine activity watch --verbose
+```
+
+`activity` prints recent issue updates and time entries once. Use `-n` / `--minutes` to choose the lookback window, defaulting to 15 minutes.
+
+`activity watch` polls recent activity, prints recent activity on startup, then continues printing new events. Minimal human-readable text is the default output. Use `--verbose` / `-v` for full markdown details. With `-o jsonl`, default output is `{ "text": "..." }`; verbose JSONL emits the full event object.
+
 ## License
 
 MIT

package/dist/index.js

@@ -1,10 +1,6 @@
 #!/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";
@@ -75,10 +71,525 @@ async function saveConfig(config) {
 `, "utf8");
 }
 
-// src/commands/config.ts
+// 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/commands/activity.ts
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
 function optionalString(value) {
   return typeof value === "string" ? value : undefined;
 }
+function namedReferenceName(value) {
+  if (!isRecord(value)) {
+    return;
+  }
+  const name = value.name;
+  return typeof name === "string" ? name : undefined;
+}
+function numericId(value) {
+  return typeof value === "number" && Number.isInteger(value) ? value : undefined;
+}
+function parseRedmineTimestamp(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? undefined : date;
+}
+function parseWatchIntervalMinutes(values) {
+  const raw = optionalString(values.interval) ?? "1";
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isInteger(parsed) || String(parsed) !== raw || parsed < 0) {
+    throw new Error(`Expected --interval to be a positive integer, got: ${raw}`);
+  }
+  return parsed;
+}
+function outputFormat(values) {
+  const value = optionalString(values.output) ?? "md";
+  if (value !== "md" && value !== "jsonl") {
+    throw new Error(`Invalid value for --output: ${value}`);
+  }
+  return value;
+}
+function markdownInline(value) {
+  return String(value ?? "").replace(/\s+/g, " ").trim().replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\*/g, "\\*").replace(/_/g, "\\_").replace(/\[/g, "\\[").replace(/\]/g, "\\]");
+}
+function compact(value, maxLength = 160) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const normalized = value.replace(/\s+/g, " ").trim();
+  if (!normalized) {
+    return;
+  }
+  return normalized.length > maxLength ? `${normalized.slice(0, maxLength - 1).trimEnd()}\u2026` : normalized;
+}
+function formatLocalTimestamp(iso) {
+  const date = new Date(iso);
+  const pad = (value) => String(value).padStart(2, "0");
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+function issueLabel(event) {
+  return event.issue === undefined ? "" : ` #${event.issue}`;
+}
+function subjectLabel(event) {
+  return event.subject ? ` \u201C${markdownInline(event.subject)}\u201D` : "";
+}
+function projectLabel(event) {
+  return event.project ? ` in **${markdownInline(event.project)}**` : "";
+}
+function detailsLabel(event) {
+  return event.details.length > 0 ? `: ${event.details.map(markdownInline).join("; ")}` : "";
+}
+function plainInline(value) {
+  return String(value ?? "").replace(/\s+/g, " ").trim();
+}
+function eventVerb(event) {
+  if (event.type === "issue_created") {
+    return "created";
+  }
+  if (event.type === "time_entry") {
+    return "logged time on";
+  }
+  return "updated";
+}
+function eventToMinimalText(event) {
+  const user = event.user ? plainInline(event.user) : "Someone";
+  const issue = event.issue === undefined ? "" : ` issue ${event.issue}`;
+  const subject = event.subject ? ` ${plainInline(event.subject)}` : "";
+  const project = event.project && event.issue === undefined ? ` in ${plainInline(event.project)}` : "";
+  return `${user} ${eventVerb(event)}${issue}${subject}${project}`;
+}
+function eventToMarkdownLine(event) {
+  const user = event.user ? `**${markdownInline(event.user)}**` : "someone";
+  const prefix = `- ${formatLocalTimestamp(event.ts)} \u2014 ${user}`;
+  if (event.type === "issue_created") {
+    return `${prefix} created${issueLabel(event)}${subjectLabel(event)}${projectLabel(event)}${detailsLabel(event)}
+`;
+  }
+  if (event.type === "time_entry") {
+    return `${prefix} logged time${issueLabel(event)}${subjectLabel(event)}${projectLabel(event)}${detailsLabel(event)}
+`;
+  }
+  return `${prefix} updated${issueLabel(event)}${subjectLabel(event)}${projectLabel(event)}${detailsLabel(event)}
+`;
+}
+function eventToOutputLine(event, format, minimal) {
+  if (minimal) {
+    const text = eventToMinimalText(event);
+    if (format === "jsonl") {
+      return `${JSON.stringify({ text })}
+`;
+    }
+    return `${text}
+`;
+  }
+  if (format === "jsonl") {
+    return `${JSON.stringify(event)}
+`;
+  }
+  return eventToMarkdownLine(event);
+}
+function journalDetails(journal) {
+  const details = [];
+  const note = compact(journal.notes);
+  if (note) {
+    details.push(`comment: ${note}`);
+  }
+  const rawDetails = journal.details;
+  if (Array.isArray(rawDetails)) {
+    for (const detail of rawDetails) {
+      if (!isRecord(detail)) {
+        continue;
+      }
+      const name = typeof detail.name === "string" ? detail.name : typeof detail.property === "string" ? detail.property : "field";
+      const oldValue = detail.old_value === undefined || detail.old_value === null || detail.old_value === "" ? "\u2205" : String(detail.old_value);
+      const newValue = detail.new_value === undefined || detail.new_value === null || detail.new_value === "" ? "\u2205" : String(detail.new_value);
+      details.push(`${name} ${oldValue} \u2192 ${newValue}`);
+    }
+  }
+  return details;
+}
+async function collectIssueEvents(config, since) {
+  const response = await redmineGetJson(config, {
+    path: "/issues.json",
+    query: { status_id: "*", sort: "updated_on:desc", limit: 100 }
+  });
+  const events = [];
+  const candidateIds = [];
+  for (const issue of response.issues ?? []) {
+    if (!isRecord(issue)) {
+      continue;
+    }
+    const updatedOn = parseRedmineTimestamp(issue.updated_on);
+    if (!updatedOn || updatedOn < since) {
+      continue;
+    }
+    const id = numericId(issue.id);
+    if (id === undefined) {
+      continue;
+    }
+    candidateIds.push(id);
+    const createdOn = parseRedmineTimestamp(issue.created_on);
+    if (createdOn && createdOn >= since) {
+      events.push({
+        key: `issue_created:${id}`,
+        ts: createdOn.toISOString(),
+        type: "issue_created",
+        user: namedReferenceName(issue.author),
+        issue: id,
+        project: namedReferenceName(issue.project),
+        subject: typeof issue.subject === "string" ? issue.subject : undefined,
+        details: []
+      });
+    }
+  }
+  for (const issueId of candidateIds) {
+    const response2 = await redmineGetJson(config, {
+      path: `/issues/${issueId}.json`,
+      query: { include: "journals" }
+    });
+    if (!isRecord(response2) || !isRecord(response2.issue)) {
+      continue;
+    }
+    const issue = response2.issue;
+    const journals = issue.journals;
+    if (!Array.isArray(journals)) {
+      continue;
+    }
+    for (const journal of journals) {
+      if (!isRecord(journal)) {
+        continue;
+      }
+      const createdOn = parseRedmineTimestamp(journal.created_on);
+      const journalId = numericId(journal.id);
+      if (!createdOn || createdOn < since || journalId === undefined) {
+        continue;
+      }
+      events.push({
+        key: `issue_journal:${issueId}:${journalId}`,
+        ts: createdOn.toISOString(),
+        type: "issue_update",
+        user: namedReferenceName(journal.user),
+        issue: issueId,
+        project: namedReferenceName(issue.project),
+        subject: typeof issue.subject === "string" ? issue.subject : undefined,
+        details: journalDetails(journal)
+      });
+    }
+  }
+  return events;
+}
+async function collectTimeEntryEvents(config, since) {
+  const response = await redmineGetJson(config, {
+    path: "/time_entries.json",
+    query: { sort: "created_on:desc", limit: 100 }
+  });
+  const events = [];
+  for (const entry of response.time_entries ?? []) {
+    if (!isRecord(entry)) {
+      continue;
+    }
+    const createdOn = parseRedmineTimestamp(entry.created_on);
+    const id = numericId(entry.id);
+    if (!createdOn || createdOn < since || id === undefined) {
+      continue;
+    }
+    const details = [];
+    const hours = typeof entry.hours === "number" ? `${entry.hours}h` : undefined;
+    const activity = namedReferenceName(entry.activity);
+    const spentOn = typeof entry.spent_on === "string" ? `spent on ${entry.spent_on}` : undefined;
+    const comment = compact(entry.comments, 120);
+    const summary = [hours, activity, spentOn].filter(Boolean).join(" ");
+    if (summary) {
+      details.push(summary);
+    }
+    if (comment) {
+      details.push(comment);
+    }
+    events.push({
+      key: `time_entry:${id}`,
+      ts: createdOn.toISOString(),
+      type: "time_entry",
+      user: namedReferenceName(entry.user),
+      issue: isRecord(entry.issue) ? numericId(entry.issue.id) : undefined,
+      project: namedReferenceName(entry.project),
+      subject: undefined,
+      details
+    });
+  }
+  return events;
+}
+async function collectActivityEvents(config, since) {
+  const [issueEvents, timeEntryEvents] = await Promise.all([collectIssueEvents(config, since), collectTimeEntryEvents(config, since)]);
+  return [...issueEvents, ...timeEntryEvents].sort((a, b) => new Date(a.ts).getTime() - new Date(b.ts).getTime());
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function parseLookbackMinutes(values) {
+  const raw = optionalString(values.minutes) ?? "15";
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isInteger(parsed) || String(parsed) !== raw || parsed < 1) {
+    throw new Error(`Expected --minutes to be a positive integer, got: ${raw}`);
+  }
+  return parsed;
+}
+async function printActivityOnce(values, lookbackMs) {
+  const config = await loadConfig();
+  const format = outputFormat(values);
+  const verbose = values.verbose === true;
+  const since = new Date(Date.now() - lookbackMs);
+  const events = await collectActivityEvents(config, since);
+  for (const event of events) {
+    process.stdout.write(eventToOutputLine(event, format, !verbose));
+  }
+}
+async function executeActivityWatch(values) {
+  const config = await loadConfig();
+  const intervalMinutes = parseWatchIntervalMinutes(values);
+  const intervalMs = intervalMinutes === 0 ? 1e4 : intervalMinutes * 60000;
+  const lookbackMs = (intervalMinutes + 5) * 60000;
+  const format = outputFormat(values);
+  const verbose = values.verbose === true;
+  const seen = new Set;
+  console.error(`Watching Redmine activity every ${intervalMinutes === 0 ? "10 seconds" : `${intervalMinutes} minute${intervalMinutes === 1 ? "" : "s"}`} (lookback: ${Math.round(lookbackMs / 60000)} minutes). Press Ctrl+C to stop.`);
+  while (true) {
+    const since = new Date(Date.now() - lookbackMs);
+    const events = await collectActivityEvents(config, since);
+    for (const event of events) {
+      if (seen.has(event.key)) {
+        continue;
+      }
+      seen.add(event.key);
+      process.stdout.write(eventToOutputLine(event, format, !verbose));
+    }
+    await sleep(intervalMs);
+  }
+}
+var activityOutputFlags = [
+  {
+    name: "output",
+    aliases: ["o"],
+    type: "string",
+    choices: ["md", "jsonl"],
+    description: "Output format: md or jsonl",
+    defaultValue: "md"
+  },
+  {
+    name: "verbose",
+    aliases: ["v"],
+    type: "boolean",
+    description: "Output full activity details instead of minimal text"
+  }
+];
+var activityWatchCommand = {
+  name: "watch",
+  requiresConfig: true,
+  aliases: ["tail"],
+  summary: "Watch recent Redmine activity",
+  description: "Poll Redmine for recent issue and time-entry activity and print new events as a feed.",
+  flags: [
+    {
+      name: "interval",
+      aliases: ["n"],
+      type: "string",
+      description: "Positive integer polling interval in minutes",
+      defaultValue: "1"
+    },
+    ...activityOutputFlags
+  ],
+  examples: ["redmine activity watch", "redmine activity watch -n 5", "redmine activity watch -o jsonl", "redmine activity watch --verbose"],
+  execute: async ({ values, positionals }) => {
+    if (positionals.length > 0) {
+      throw new Error(`Unexpected argument: ${positionals[0]}`);
+    }
+    await executeActivityWatch(values);
+  }
+};
+var activityCommand = {
+  name: "activity",
+  requiresConfig: true,
+  summary: "Show recent Redmine activity",
+  description: "Show recent Redmine issue and time-entry activity once, or watch it as a feed.",
+  flags: [
+    {
+      name: "minutes",
+      aliases: ["n"],
+      type: "string",
+      description: "Look back this many minutes",
+      defaultValue: "15"
+    },
+    ...activityOutputFlags
+  ],
+  examples: ["redmine activity", "redmine activity -n 60", "redmine activity -o jsonl", "redmine activity --verbose", "redmine activity watch"],
+  subcommands: [activityWatchCommand],
+  execute: async ({ values, positionals }) => {
+    if (positionals.length > 0) {
+      throw new Error(`Unexpected argument: ${positionals[0]}`);
+    }
+    await printActivityOnce(values, parseLookbackMinutes(values) * 60000);
+  }
+};
+
+// src/commands/config.ts
+import { stdin as input, stderr as output } from "process";
+import { createInterface } from "readline/promises";
+function optionalString2(value) {
+  return typeof value === "string" ? value : undefined;
+}
 function maskApiKey(key) {
   if (key.length <= 8) {
     return "*****";
@@ -233,9 +744,9 @@ var configSetCommand = {
     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"]);
+    const url = optionalString2(values.url);
+    const key = optionalString2(values.key);
+    const issueMirrorDir = optionalString2(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.");
     }
@@ -266,159 +777,6 @@ var configCommand = {
 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(`---
@@ -468,7 +826,7 @@ 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) {
+function optionalString3(value) {
   return typeof value === "string" ? value : undefined;
 }
 function optionalNumber(value, fallback) {
@@ -501,11 +859,11 @@ function isIssueListResponse(value) {
   const response = value;
   return Array.isArray(response.issues) && typeof response.total_count === "number" && typeof response.offset === "number" && typeof response.limit === "number";
 }
-function isRecord(value) {
+function isRecord2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
-function namedReferenceName(value) {
-  if (!isRecord(value)) {
+function namedReferenceName2(value) {
+  if (!isRecord2(value)) {
     return;
   }
   const name = value.name;
@@ -521,7 +879,7 @@ function namedReferenceName(value) {
   return typeof login === "string" ? login : undefined;
 }
 function namedReferenceId(value) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     return;
   }
   const id = value.id;
@@ -544,14 +902,14 @@ function addNamedReferencesToMap(map, values) {
   }
   for (const value of values) {
     const id = namedReferenceId(value);
-    const name = namedReferenceName(value);
+    const name = namedReferenceName2(value);
     if (id && name) {
       map.set(id, name);
     }
   }
 }
 function lookupArray(response, key) {
-  return isRecord(response) ? response[key] : undefined;
+  return isRecord2(response) ? response[key] : undefined;
 }
 function mergeLookupMaps(target, source) {
   for (const [key, map] of Object.entries(source)) {
@@ -581,12 +939,12 @@ function summarizeIssue(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),
+    project: namedReferenceName2(record.project),
+    tracker: namedReferenceName2(record.tracker),
+    status: namedReferenceName2(record.status),
+    priority: namedReferenceName2(record.priority),
+    assignee: namedReferenceName2(record.assigned_to),
+    author: namedReferenceName2(record.author),
     sprint: getIssueSprintValue(issue) || undefined,
     description_preview: truncateDescription(record.description),
     updated_on: record.updated_on,
@@ -602,8 +960,8 @@ function summarizeIssueListResponse(response, issues = response.issues) {
     issues: issues.map((issue) => summarizeIssue(issue))
   };
 }
-function outputFormat(values) {
-  const value = optionalString2(values.output) ?? "json";
+function outputFormat2(values) {
+  const value = optionalString3(values.output) ?? "json";
   if (value !== "json" && value !== "md") {
     throw new Error(`Invalid value for --output: ${value}`);
   }
@@ -619,7 +977,7 @@ function scalarValue(value) {
   if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
     return String(value);
   }
-  const name = namedReferenceName(value);
+  const name = namedReferenceName2(value);
   if (name) {
     return name;
   }
@@ -677,14 +1035,14 @@ 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)]);
+  const rows = issue.custom_fields.filter((field) => isRecord2(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 name = namedReferenceName2(value);
   const id = namedReferenceId(value);
   if (name && id)
     return `${name} (#${id})`;
@@ -740,7 +1098,7 @@ function journalDetailMarkdown(detail) {
   return `- **${mdEscape(label)}${suffix}** changed`;
 }
 function issueResponseToMarkdown(response) {
-  const issue = isRecord(response) && isRecord(response.issue) ? response.issue : undefined;
+  const issue = isRecord2(response) && isRecord2(response.issue) ? response.issue : undefined;
   if (!issue) {
     return `---
 resource: redmine_issue
@@ -760,8 +1118,8 @@ ${JSON.stringify(response, null, 2)}
     "resource: redmine_issue",
     `id: ${yamlString(id)}`,
     `subject: ${yamlString(subject)}`,
-    `project: ${yamlString(namedReferenceName(issue.project) ?? "")}`,
-    `status: ${yamlString(namedReferenceName(issue.status) ?? "")}`,
+    `project: ${yamlString(namedReferenceName2(issue.project) ?? "")}`,
+    `status: ${yamlString(namedReferenceName2(issue.status) ?? "")}`,
     `generated_at: ${new Date().toISOString()}`
   ];
   const parts = [`---
@@ -800,10 +1158,10 @@ ${frontmatter.join(`
   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 items = issue.attachments.filter(isRecord2).map((attachment) => {
       const filename = scalarValue(attachment.filename) ?? scalarValue(attachment.id) ?? "attachment";
       const url = scalarValue(attachment.content_url);
-      const author = namedReferenceName(attachment.author);
+      const author = namedReferenceName2(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)}` : ""}`;
@@ -811,18 +1169,18 @@ ${frontmatter.join(`
     parts.push("## Attachments", bulletList(items));
   }
   if (Array.isArray(issue.relations) && issue.relations.length > 0) {
-    const rows = issue.relations.filter(isRecord).map((relation) => [
+    const rows = issue.relations.filter(isRecord2).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());
+    const items = issue.children.filter(isRecord2).map((child) => `#${scalarValue(child.id) ?? "?"} ${mdEscape(scalarValue(child.subject) ?? "Untitled")} \u2014 ${mdEscape(namedReferenceName2(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 items = issue.changesets.filter(isRecord2).map((changeset) => {
       const revision = scalarValue(changeset.revision) ?? scalarValue(changeset.id) ?? "changeset";
       const comments = scalarValue(changeset.comments);
       const author = scalarValue(changeset.user) ?? scalarValue(changeset.author);
@@ -835,30 +1193,30 @@ ${frontmatter.join(`
     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) => [
+    const rows = issue.time_entries.filter(isRecord2).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 ")
+      [formatHours(entry.hours), namedReferenceName2(entry.user), namedReferenceName2(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)) {
+    for (const journal of issue.journals.filter(isRecord2)) {
       const journalId = scalarValue(journal.id) ?? "?";
-      const author = namedReferenceName(journal.user) ?? "Unknown user";
+      const author = namedReferenceName2(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);
+        const detailBlocks = journal.details.filter(isRecord2).map(journalDetailMarkdown);
         parts.push(detailBlocks.join(`
 `));
       }
     }
   }
-  if (isRecord(issue._enrichment) && Array.isArray(issue._enrichment.warnings) && issue._enrichment.warnings.length > 0) {
+  if (isRecord2(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([
@@ -932,42 +1290,32 @@ ${frontmatter.join(`
     parts.push(`Filters: ${activeFilters.map((filter) => `\`${filter}\``).join(", ")}`);
   }
   for (const issue of response.issues) {
-    if (!isRecord(issue)) {
+    if (!isRecord2(issue)) {
       continue;
     }
-    const id = scalarValue(issue.id) ?? "?";
-    const subject = scalarValue(issue.subject) ?? "Untitled issue";
-    const sprint = getIssueSprintValue(issue);
+    const summary = summarizeIssue(issue);
+    const id = scalarValue(summary.id) ?? "?";
+    const subject = scalarValue(summary.subject) ?? "Untitled 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]
+      ["Project", summary.project],
+      ["Tracker", summary.tracker],
+      ["Status", summary.status],
+      ["Priority", summary.priority],
+      ["Assignee", summary.assignee],
+      ["Author", summary.author],
+      ["Sprint", summary.sprint],
+      ["Done", scalarValue(summary.done_ratio) ? `${scalarValue(summary.done_ratio)}%` : undefined],
+      ["Estimated", formatHours(summary.estimated_hours)],
+      ["Spent", formatHours(summary.spent_hours)],
+      ["Created", formatDateTime(summary.created_on)],
+      ["Updated", formatDateTime(summary.updated_on)]
     ]);
     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);
+    if (summary.description_preview) {
+      parts.push("### Description preview", mdEscape(summary.description_preview));
     }
   }
   return `${parts.join(`
@@ -976,7 +1324,7 @@ ${frontmatter.join(`
 `;
 }
 function printIssueListResponse(response, values, filters) {
-  if (outputFormat(values) === "md") {
+  if (outputFormat2(values) === "md") {
     process.stdout.write(renderMarkdownForTerminal(issueListResponseToMarkdown(response, filters)));
     return;
   }
@@ -996,7 +1344,7 @@ function customFieldsByName(issue) {
   }
   const byName = {};
   for (const field of customFields) {
-    if (!isRecord(field) || typeof field.name !== "string") {
+    if (!isRecord2(field) || typeof field.name !== "string") {
       continue;
     }
     byName[field.name] = field.value;
@@ -1046,7 +1394,7 @@ function valueLabel(name, value, lookups) {
   return;
 }
 function enrichJournalDetail(detail, lookups) {
-  if (!isRecord(detail) || typeof detail.name !== "string") {
+  if (!isRecord2(detail) || typeof detail.name !== "string") {
     return detail;
   }
   const label = detailLabel(detail.name, lookups);
@@ -1060,13 +1408,13 @@ function enrichJournalDetail(detail, lookups) {
   };
 }
 function enrichIssueResponse(response, enrichment) {
-  if (!isRecord(response) || !isRecord(response.issue)) {
+  if (!isRecord2(response) || !isRecord2(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)) {
+    if (!isRecord2(journal)) {
       return journal;
     }
     return {
@@ -1090,12 +1438,12 @@ function enrichIssueResponse(response, enrichment) {
   };
 }
 function collectJournalUserIds(issue) {
-  if (!isRecord(issue) || !Array.isArray(issue.journals)) {
+  if (!isRecord2(issue) || !Array.isArray(issue.journals)) {
     return [];
   }
   const ids = new Set;
   for (const journal of issue.journals) {
-    if (!isRecord(journal)) {
+    if (!isRecord2(journal)) {
       continue;
     }
     const userId = namedReferenceId(journal.user);
@@ -1105,7 +1453,7 @@ function collectJournalUserIds(issue) {
       continue;
     }
     for (const detail of journal.details) {
-      if (!isRecord(detail) || typeof detail.name !== "string") {
+      if (!isRecord2(detail) || typeof detail.name !== "string") {
         continue;
       }
       if (detail.name === "assigned_to_id" || detail.name === "user_id" || detail.name === "author_id") {
@@ -1122,10 +1470,10 @@ function collectJournalUserIds(issue) {
 async function fetchIssueEnrichment(config, issueId, issue) {
   const lookups = createLookupMaps();
   const warnings = [];
-  if (isRecord(issue)) {
+  if (isRecord2(issue)) {
     addNamedReferencesToMap(lookups.users, [issue.author, issue.assigned_to]);
   }
-  const projectId = isRecord(issue) ? namedReferenceId(issue.project) : undefined;
+  const projectId = isRecord2(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),
@@ -1154,9 +1502,9 @@ async function fetchIssueEnrichment(config, issueId, issue) {
       warnings.push(userRequest.warning);
       continue;
     }
-    if (isRecord(userRequest.data) && isRecord(userRequest.data.user)) {
+    if (isRecord2(userRequest.data) && isRecord2(userRequest.data.user)) {
       const id = namedReferenceId(userRequest.data.user);
-      const name = namedReferenceName(userRequest.data.user);
+      const name = namedReferenceName2(userRequest.data.user);
       if (id && name) {
         userLookups.users.set(id, name);
       }
@@ -1252,10 +1600,10 @@ function buildIssueQuery(filters, 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))
+    project: optionalString3(values.project),
+    assignee: overrides.assignee ?? optionalString3(values.assignee),
+    status: overrides.status ?? resolveStatus(optionalString3(values.status)),
+    sprint: overrides.sprint ?? resolveSprint(optionalString3(values.sprint))
   };
 }
 function getIssueSprintValue(issue) {
@@ -1432,7 +1780,7 @@ var issueGetCommand = {
   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.",
+  description: "Get a single Redmine issue as Markdown. Journals, attachments, relations, changesets, and watchers are included by default.",
   arguments: [
     {
       name: "id",
@@ -1459,7 +1807,7 @@ var issueGetCommand = {
       type: "string",
       choices: ["json", "md"],
       description: "Output format: json or md",
-      defaultValue: "json"
+      defaultValue: "md"
     },
     {
       name: "no-secondary",
@@ -1467,20 +1815,20 @@ var issueGetCommand = {
       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"],
+  examples: ["redmine issue get 43135", "redmine issue get 43135 -o json", "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 include = optionalString3(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)) {
+    const format = outputFormat2(values);
+    if (values.raw === true || values["no-secondary"] === true || !isRecord2(response) || !isRecord2(response.issue)) {
       if (format === "md") {
         process.stdout.write(renderMarkdownForTerminal(issueResponseToMarkdown(response)));
         return;
@@ -1581,7 +1929,7 @@ var rootCommand = {
   name: "redmine",
   summary: "Redmine CLI",
   description: "Inspect and manage Redmine resources from the command line.",
-  subcommands: [configCommand, issueCommand]
+  subcommands: [configCommand, issueCommand, activityCommand]
 };
 function getVisibleSubcommands(command) {
   return (command.subcommands ?? []).filter((entry) => entry.hidden !== true);
@@ -1618,7 +1966,13 @@ function resolveCommandPath(args) {
   };
 }
 function collectCommandFlags(command) {
-  return [...globalFlags, ...command?.flags ?? []];
+  const commandFlags = command?.flags ?? [];
+  const commandAliases = new Set(commandFlags.flatMap((flag) => flag.aliases ?? []));
+  const globals = globalFlags.map((flag) => ({
+    ...flag,
+    aliases: flag.aliases?.filter((alias) => !commandAliases.has(alias))
+  }));
+  return [...globals, ...commandFlags];
 }
 
 // src/cli/help.ts
@@ -1837,7 +2191,7 @@ function parseCli(args) {
 // package.json
 var package_default = {
   name: "@emmertarmin/redmine-cli",
-  version: "0.1.1",
+  version: "0.1.3",
   description: "A personal Redmine CLI.",
   license: "MIT",
   repository: {
@@ -1860,6 +2214,7 @@ var package_default = {
     bun: ">=1.0.0"
   },
   scripts: {
+    cli: "bun run ./index.ts",
     dev: "bun --watch run index.ts",
     build: "bun build ./index.ts --outdir dist --target bun",
     tsc: "tsc --noEmit",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emmertarmin/redmine-cli",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "A personal Redmine CLI.",
   "license": "MIT",
   "repository": {
@@ -23,6 +23,7 @@
     "bun": ">=1.0.0"
   },
   "scripts": {
+    "cli": "bun run ./index.ts",
     "dev": "bun --watch run index.ts",
     "build": "bun build ./index.ts --outdir dist --target bun",
     "tsc": "tsc --noEmit",