baton-issue-tracker 1.5.0 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "baton-issue-tracker",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "A CLI issue tracker for AI agents",
   "type": "module",
   "bin": {
@@ -37,6 +37,7 @@
     "node": ">=22.0.0"
   },
   "dependencies": {
+    "@inquirer/prompts": "^8.5.1",
     "better-sqlite3": "^12.10.0",
     "drizzle-orm": "^0.45.2"
   }

package/source/cli.js

@@ -23,7 +23,9 @@ import { run as runView} from './commands/view.js';
 import { run as runSearch } from './commands/search.js';
 import { run as runList } from './commands/list.js';
 import { run as runCreate } from './commands/create.js'
-import { run as runUpdate } from './commands/update.js'
+import { run as runUpdate } from './commands/update.js';
+import { run as runPriority } from './commands/priority.js';
+import { run as runLog } from './commands/log.js';
 
 const HELP = `baton — AI agent issue tracker CLI
 
@@ -40,7 +42,9 @@ Commands:
   list     Lists issues filtered by status and priority
   create   Creates an issue with specified fields
   approve  Move an issue from in-review to closed
-  update   Updates an issue's specified fields 
+  priority Set an issue's priority level
+  update   Updates an issue's specified fields
+  log      Show activity history for an issue
 
 Options:
   init --force                    Re-initialize an existing tracker database
@@ -66,13 +70,14 @@ Options:
   create --token-limit <n>        Optional token budget for this issue
   create --json                   Output as JSON (for AI agents)
   approve <id> [--json]
+  priority <id> <level> [--json]  low | medium | high
   update --title <text>           New title
   update --description <text>     New description
   update --token-limit <n>        New token budget
   update --status <s>             open | in-progress | closed
   update --priority <level>       low | medium | high
   update --json                   Output as JSON (for AI agents)
- 
+  log <id> [--json]
 
 Examples:
   baton init
@@ -90,8 +95,11 @@ Examples:
   baton create --title "Fix login bug" --priority high
   baton create --title "Refactor auth" --description "Clean up JWT logic" --token-limit 4000
   baton approve 5
+  baton priority 5 high
+  baton priority 3 low
   baton update 3 --title "Revised title"
   baton update 7 --status closed --priority medium
+  baton log 5
 `;
 
 /**
@@ -101,12 +109,6 @@ Examples:
 async function main() {
   const [, , command, ...args] = process.argv;
 
-  if (!command || command === 'help' || wantsHelp(args) || command === '--help') {
-    console.log(HELP);
-    process.exit(command ? 0 : 1);
-    return;
-  }
-
   const handlers = {
     init: () => runInit(args),
     next: () => runNext(args),
@@ -116,12 +118,25 @@ async function main() {
     search: () => runSearch(args),
     list: () => runList(args),
     approve: () => runApprove(args),
+    priority: () => runPriority(args),
     create: () => runCreate(args),
-    update: () => runUpdate(args)
+    update: () => runUpdate(args),
+    log: () => runLog(args),
   };
-  
+
+  if (!command || command === 'help' || command === '--help') {
+    console.log(HELP);
+    process.exit(command ? 0 : 1);
+    return;
+  }
+
   const handler = handlers[command];
   if (!handler) {
+    if (wantsHelp(args)) {
+      console.log(HELP);
+      process.exit(0);
+      return;
+    }
     console.error(`Error: Unknown command "${command}".`);
     console.error('Run `baton --help` for usage.');
     process.exit(1);

package/source/commands/create.js

@@ -1,52 +1,237 @@
 // create.js
 // AI was consulted for some portions of this file.
-// create command allows the user to create an issue 
+// create command allows the user to create an issue
 // Usage: baton create --title <text> --description <text> --priority <level> --token-limit <n>
-// 
+//        baton create                  (launches interactive prompt mode)
+//
 // Examples:
-// baton create --title "Fix login bug" --priority high
-//  baton create --title "Refactor auth" --description "Clean up JWT logic" --token-limit 4000
+//   baton create --title "Fix login bug" --priority high
+//   baton create --title "Refactor auth" --description "Clean up JWT logic" --token-limit 4000
+//   baton create                         # interactive mode
+//
 // Options:
-//  --title <text>         Issue title (defaults to "Issue #<id>" if omitted)
-//  --description <text>   Issue description
-//  --priority <level>     low | medium | high  (default: low)
-//  --token-limit <n>      Optional token budget for this issue
-//  -h, --help             Show this help
+//   --title <text>         Issue title (defaults to "Issue #<id>" if omitted)
+//   --description <text>   Issue description
+//   --priority <level>     low | medium | high  (default: low)
+//   --token-limit <n>      Optional token budget for this issue
+//   -h, --help             Show this help
 
 import { createIssue } from "../services/issuesService.js";
-import { getFlagValue, getNumericFlag } from "../util.js";
-import { hasFlag, parseArgs, renderOutput, serializeIssue } from '../util.js';
+import { hasFlag, parseArgs, renderOutput, serializeIssue } from "../util.js";
+import { issueSchema } from "../models/schema.js";
+import { input, select, confirm, editor } from "@inquirer/prompts";
+import { spawnSync } from "child_process";
+import { writeFileSync, readFileSync, unlinkSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+
+const ALLOWED_CREATE_FIELDS = ['title', 'priority', 'tokenLimit', 'description'];
+
+const VALID_FLAGS = new Set([
+  ...ALLOWED_CREATE_FIELDS.map(key => issueSchema[key].flag),
+  "--json",
+]);
+
+// Build select choices from issueSchema.priority.values so the list stays in
+// sync with the Priority enum without any duplication.
+const PRIORITY_HINTS = {
+  Low: "routine work, no urgency",
+  Medium: "should be resolved this week",
+  High: "blocking or time-sensitive",
+};
+const PRIORITY_CHOICES = issueSchema.priority.values.map((v) => ({
+  name: `${v.padEnd(6)} -- ${PRIORITY_HINTS[v] ?? v}`,
+  value: v,
+}));
+const DEFAULT_PRIORITY = issueSchema.priority.values[0];
+
+const DESCRIPTION_PLACEHOLDER = [
+  "## What is the issue?",
+  "",
+  "## Steps to reproduce (if applicable)",
+  "",
+  "## Expected vs actual behaviour",
+  "",
+  "## Additional context",
+  "",
+].join("\n");
+
+/**
+ * Opens the user's $EDITOR with an optional seed template and returns the
+ * saved contents, or null if the user left it unchanged / empty.
+ *
+ * Falls back gracefully: if no $EDITOR is set the inquirer `editor` prompt is
+ * used instead (which has its own built-in text area).
+ *
+ * @param {string} template   Initial file content shown to the user.
+ * @returns {Promise<string|null>}
+ */
+async function openEditorForDescription(template = DESCRIPTION_PLACEHOLDER) {
+  const editorBin = process.env.EDITOR || process.env.VISUAL;
+
+  if (!editorBin) {
+    // If no $EDITOR set, then fall back to @inquirer/prompts built-in editor widget
+    const result = await editor({
+      message:
+        "Description (opens in-terminal editor -- save & quit when done):",
+      default: template,
+      waitForUseInput: false,
+    });
+    const cleaned = result.trim();
+    return cleaned && cleaned !== template.trim() ? cleaned : null;
+  }
+
+  // Write template to a temp file, open $EDITOR, read back the result
+  const tmpPath = join(tmpdir(), `baton-issue-${Date.now()}.md`);
+  writeFileSync(tmpPath, template, "utf8");
+
+  const result = spawnSync(editorBin, [tmpPath], { stdio: "inherit" });
+
+  if (result.error) {
+    unlinkSync(tmpPath);
+    throw new Error(
+      `Could not open $EDITOR (${editorBin}): ${result.error.message}`,
+    );
+  }
+
+  const saved = readFileSync(tmpPath, "utf8");
+  unlinkSync(tmpPath);
+
+  const cleaned = saved.trim();
+  // Return null if the user saved without changing anything
+  return cleaned && cleaned !== template.trim() ? cleaned : null;
+}
+
+/**
+ * Guides the user through issue creation with interactive prompts.
+ * @returns {Promise<object>} Options object ready to pass to createIssue()
+ */
+async function runInteractiveMode() {
+  console.log("\n  Baton -- interactive issue creation\n");
+
+  // Title
+  const title = await input({
+    message: "Title:",
+    required: true,
+    validate: (val) => val.trim().length > 0 || "Title cannot be empty.",
+  });
+
+  // Priority
+  const priority = await select({
+    message: "Priority:",
+    choices: PRIORITY_CHOICES,
+    default: DEFAULT_PRIORITY,
+  });
+
+  // Token limit
+  const wantsTokenLimit = await confirm({
+    message: "Set a token limit for this issue?",
+    default: false,
+  });
+
+  let tokenLimit = null;
+  if (wantsTokenLimit) {
+    const raw = await input({
+      message: "Token limit (positive integer):",
+      validate: (val) => {
+        const n = Number(val);
+        return (Number.isInteger(n) && n > 0) || "Must be a positive integer.";
+      },
+    });
+    tokenLimit = Number(raw);
+  }
+
+  // Description
+  const wantsDescription = await confirm({
+    message: "Add a description?",
+    default: true,
+  });
+
+  let description = null;
+  if (wantsDescription) {
+    const editorBin = process.env.EDITOR || process.env.VISUAL;
+    const hint = editorBin ? `opens ${editorBin}` : "in-terminal editor";
+    console.log(
+      `  ->  ${hint} -- fill in what's relevant, save and quit when done.\n`,
+    );
+    description = await openEditorForDescription();
+  }
+
+  // Preview & confirm
+  console.log("\n" + "-".repeat(48));
+  console.log(`  Title      : ${title}`);
+  console.log(`  Priority   : ${priority}`);
+  console.log(`  Token limit: ${tokenLimit ?? "(none)"}`);
+  if (description) {
+    const preview = description.split("\n").slice(0, 3).join(" ").slice(0, 72);
+    console.log(
+      `  Description: ${preview}${description.length > 72 ? "..." : ""}`,
+    );
+  } else {
+    console.log(`  Description: (none)`);
+  }
+  console.log("-".repeat(48) + "\n");
+
+  const confirmed = await confirm({
+    message: "Create this issue?",
+    default: true,
+  });
+  if (!confirmed) {
+    console.log("Aborted -- no issue created.");
+    process.exit(0);
+  }
+
+  return { title, priority, tokenLimit, description };
+}
 
 /**
  * Initializes a new issue in the database with the specified fields
+ * Drops into interactive mode when no flags are provided
+ *
  * @param {string[]} args - The command line arguments
- * @returns {Promise<number>} The exit code: 0 is success, 1 is error.
+ * @returns {Promise<number>} The exit code: 0 is success, 1 is error
  */
 export async function run(args) {
-    const isJson = hasFlag(args, '--json');
-    const validFlags = ['--title', '--description', '--priority', '--token-limit', '--json'];
-    // Check if user misspelled a flag
-    for (const arg of args) {
-        if (arg.startsWith('--')) {
-            if (!validFlags.includes(arg)) {
-                throw new Error(`Unknown flag provided: ${arg}. \nFlags: --title <text>, --description <text>, --priority <level>, --token-limit <n>`);
-            }
-        }
+  const isJson = hasFlag(args, "--json");
+
+  // Flag validation -- VALID_FLAGS is derived from issueSchema, so this stays
+  // current automatically when fields are added or renamed there
+  const providedFlags = args.filter((a) => a.startsWith("--"));
+  for (const flag of providedFlags) {
+    if (!VALID_FLAGS.has(flag)) {
+      const knownFlags = [...VALID_FLAGS].join(", ");
+      throw new Error(
+        `Unknown flag: ${flag}\nValid flags: ${knownFlags}\n` +
+          `Tip: run \`baton create\` with no flags to use interactive mode.`,
+      );
     }
+  }
+
+  try {
+    // Interactive mode: no flags provided (human at a keyboard)
+    // Flag mode:        at least one flag present (scripts, CI, power users)
+    const nonJsonFlags = providedFlags.filter((f) => f !== "--json");
+    const isInteractive = nonJsonFlags.length === 0;
 
-    try {
-        const options = parseArgs(args);
+    const options = isInteractive
+      ? await runInteractiveMode()
+      : parseArgs(args);
 
-        const issue = await createIssue(options);
-        const envelope = { status: 'success', issue: serializeIssue(issue) };
+    const issue = await createIssue(options);
+    const envelope = { status: "success", issue: serializeIssue(issue) };
 
-        renderOutput(isJson, envelope, () => {
-            console.log(`Successfully created issue #${issue.id}: "${issue.title}"`);
-        });
+    renderOutput(isJson, envelope, () => {
+      console.log(`\nCreated issue #${issue.id}: "${issue.title}"`);
+    });
 
-        return 0;
-    } catch (error) {
-        console.error(`Failed to create issue: ${error.message}`);
-        return 1;
+    return 0;
+  } catch (error) {
+    // when user hits Ctrl+C
+    if (error.name === "ExitPromptError") {
+      console.log("\nAborted.");
+      return 0;
     }
+    console.error(`Failed to create issue: ${error.message}`);
+    return 1;
+  }
 }

package/source/commands/log.js

@@ -0,0 +1,85 @@
+// AI was consulted for some portions of this file.
+// log.js
+// log command which displays the full activity history for an issue
+// Usage: baton log <id>
+//
+// Options:
+//   -h, --help    Show this help
+//   --json        Output as JSON (for AI agents)
+//
+// Examples:
+//   baton log 5
+
+import { getActivityLog } from '../services/issuesService.js';
+import { formatTimestamp, hasFlag } from '../util.js';
+
+/**
+ * Serializes an activity log entry for JSON output.
+ * @param {object} entry
+ * @returns {object}
+ */
+function serializeLogEntry(entry) {
+  return {
+    log_id: entry.logId,
+    issue_id: entry.issueId,
+    action: entry.action,
+    details: entry.details ?? null,
+    created_at: entry.createdAt,
+  };
+}
+
+/**
+ * Displays the full activity history for a given issue ID.
+ * @param {string[]} args - The issue ID
+ * @returns {Promise<number>} The exit code: 0 is success, 1 is error.
+ */
+export async function run(args) {
+  const isJson = hasFlag(args, '--json');
+  const idArgs = args.filter((arg) => arg !== '--json');
+
+  if (idArgs.length === 0) {
+    throw new Error('Invalid input: Missing Issue ID.\nUsage: baton log <id>');
+  }
+
+  const id = idArgs.join(' ');
+
+  if (isNaN(id)) {
+    throw new Error('Invalid input: ID must be a number.\nUsage: baton log <id>');
+  }
+
+  try {
+    const logs = getActivityLog(Number(id));
+    const entries = logs.map(serializeLogEntry);
+    const envelope = {
+      status: 'success',
+      issue_id: Number(id),
+      count: entries.length,
+      entries,
+    };
+
+    if (isJson) {
+      console.log(JSON.stringify(envelope, null, 2));
+      return 0;
+    }
+
+    if (entries.length === 0) {
+      console.log(`No activity history for issue #${id}.`);
+      return 0;
+    }
+
+    console.log(`Activity log for issue #${id}`);
+    console.log('──────────────────────────────────────────');
+    for (const entry of entries) {
+      const timestamp = formatTimestamp(entry.created_at);
+      const details = entry.details ?? '';
+      console.log(`${timestamp}  ${entry.action}  ${details}`);
+    }
+    console.log('');
+
+    return 0;
+  } catch (error) {
+    console.error('Error: Failed to retrieve activity log.');
+    console.error(error.message);
+    return 1;
+  }
+}

package/source/commands/priority.js

@@ -0,0 +1,102 @@
+// AI was consulted for some portions of this file.
+// priority.js
+// Sets the priority of an issue.
+// Usage: baton priority <id> <priority>
+//
+// Options:
+//  -h, --help             Show this help
+//  --json                 Output as JSON (for AI agents)
+//
+// Examples:
+//  baton priority 5 high
+//  baton priority 3 low
+
+import { Priority } from '../models/issue.js';
+import { setPriority } from '../services/issuesService.js';
+import { hasFlag, renderOutput, serializeIssue, wantsHelp } from '../util.js';
+
+const HELP = `Usage:
+  baton priority <id> <priority>
+
+Options:
+  -h, --help             Show this help
+  --json                 Output as JSON (for AI agents)
+
+Examples:
+  baton priority 5 high
+  baton priority 3 low
+`;
+
+/**
+ * Normalize CLI priority input to a canonical Priority enum value.
+ * @param {string} input
+ * @returns {string | null}
+ */
+function normalizePriority(input) {
+  const values = Object.values(Priority);
+  return values.find((v) => v.toLowerCase() === input.trim().toLowerCase()) ?? null;
+}
+
+/**
+ * Sets the priority of an issue.
+ * @param {string[]} args - The command line arguments.
+ * @returns {Promise<number>} The exit code: 0 is success, 1 is error.
+ */
+export async function run(args) {
+  if (wantsHelp(args)) {
+    console.log(HELP);
+    return 0;
+  }
+
+  const isJson = hasFlag(args, '--json');
+  const cmdArgs = args.filter((arg) => arg !== '--json');
+
+  if (cmdArgs.length < 2) {
+    throw new Error(
+      'Invalid input: Missing issue ID or priority.\nUsage: baton priority <id> <priority>'
+    );
+  }
+
+  if (cmdArgs.length > 2) {
+    throw new Error(
+      'Invalid input: Too many arguments.\nUsage: baton priority <id> <priority>'
+    );
+  }
+
+  for (const arg of cmdArgs) {
+    if (arg.startsWith('--')) {
+      throw new Error(
+        'Unknown flag provided.\nUsage: baton priority <id> <priority>\nPriority: low | medium | high'
+      );
+    }
+  }
+
+  const id = parseInt(cmdArgs[0], 10);
+  if (Number.isNaN(id)) {
+    throw new Error(
+      'Invalid input: ID must be a number.\nUsage: baton priority <id> <priority>'
+    );
+  }
+
+  const priority = normalizePriority(cmdArgs[1]);
+  if (!priority) {
+    throw new Error(
+      `Invalid priority "${cmdArgs[1]}". Must be one of: low, medium, high.\nUsage: baton priority <id> <priority>`
+    );
+  }
+
+  try {
+    const issue = setPriority(id, priority);
+    const envelope = { status: 'success', issue: serializeIssue(issue) };
+
+    renderOutput(isJson, envelope, () => {
+      console.log(`Issue #${issue.id} priority set to ${issue.priority}.`);
+    });
+
+    return 0;
+  } catch (error) {
+    console.error('Error: Failed to set issue priority.');
+    console.error(error.message);
+    return 1;
+  }
+}

package/source/commands/update.js

@@ -1,7 +1,8 @@
 // update.js
 // AI was consulted for some portions of this file.
-// update command allows the user to update data fields for an issue 
+// update command allows the user to update data fields for an issue
 // Usage: baton update <id> [options]
+//        baton update <id>              (launches interactive mode pre-filled with current values)
 //
 // Options:
 //  --title <text>         New title
@@ -12,70 +13,252 @@
 //  -h, --help             Show this help
 //
 // Examples:
-// baton update 3 --title "Revised title"
-// baton update 7 --status closed --priority medium
+//  baton update 3                        # interactive mode
+//  baton update 3 --title "Revised title"
+//  baton update 7 --status closed --priority medium
 
 import { updateIssue, getIssue } from "../services/issuesService.js";
-import { hasFlag, parseArgs, renderOutput, serializeIssue } from '../util.js';
+import { hasFlag, parseArgs, renderOutput, serializeIssue } from "../util.js";
+import { issueSchema } from "../models/schema.js";
+import { input, select, confirm, editor } from "@inquirer/prompts";
+import { spawnSync } from "child_process";
+import { writeFileSync, readFileSync, unlinkSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
 
+const ALLOWED_UPDATE_FIELDS = ['title', 'status', 'priority', 'tokenLimit', 'description'];
+
+const VALID_FLAGS = new Set([
+  ...ALLOWED_UPDATE_FIELDS.map(key => issueSchema[key].flag),
+  "--json",
+]);
+const FLAGS_HINT = [...VALID_FLAGS].join(", ");
+const USAGE = "Usage: baton update <id> [options]";
+
+// Build select choices from issueSchema enums so they stay in sync automatically.
+const PRIORITY_HINTS = {
+  Low: "routine work, no urgency",
+  Medium: "should be resolved this week",
+  High: "blocking or time-sensitive",
+};
+
+const PRIORITY_CHOICES = issueSchema.priority.values.map((v) => ({
+  name: `${v.padEnd(6)} -- ${PRIORITY_HINTS[v] ?? v}`,
+  value: v,
+}));
+
+const STATUS_CHOICES = issueSchema.status.values.map((v) => ({
+  name: v,
+  value: v,
+}));
+
+/**
+ * Opens the user's $EDITOR pre-filled with existing content.
+ * Falls back to the inquirer built-in editor widget if $EDITOR is not set.
+ * Returns null if the user saves without making any changes.
+ *
+ * @param {string} existing  Current description to pre-fill.
+ * @returns {Promise<string|null>}
+ */
+async function openEditorForDescription(existing = "") {
+  const editorBin = process.env.EDITOR || process.env.VISUAL;
+
+  if (!editorBin) {
+    const result = await editor({
+      message: "Description (save & quit when done):",
+      default: existing,
+      waitForUseInput: false,
+    });
+    const cleaned = result.trim();
+    return cleaned !== existing.trim() ? cleaned : null;
+  }
+
+  const tmpPath = join(tmpdir(), `baton-issue-${Date.now()}.md`);
+  writeFileSync(tmpPath, existing, "utf8");
+
+  const result = spawnSync(editorBin, [tmpPath], { stdio: "inherit" });
+  if (result.error) {
+    unlinkSync(tmpPath);
+    throw new Error(
+      `Could not open $EDITOR (${editorBin}): ${result.error.message}`,
+    );
+  }
+
+  const saved = readFileSync(tmpPath, "utf8");
+  unlinkSync(tmpPath);
+
+  const cleaned = saved.trim();
+  return cleaned !== existing.trim() ? cleaned : null;
+}
+
+/**
+ * Prompts the user to edit each field of an existing issue.
+ * Every prompt is pre-filled with the issue's current value so the user
+ * only needs to change what they care about.
+ *
+ * @param {object} issue  The current issue object from the database.
+ * @returns {Promise<object>} Partial options object containing only changed fields.
+ */
+async function runInteractiveMode(issue) {
+  console.log(`\n  Baton -- editing issue #${issue.id}: "${issue.title}"\n`);
+
+  // Collect all prompt results into one object keyed by schema field name.
+  // The diff at the end loops over this -- no field names hardcoded there.
+  const results = {};
+
+  // Title
+  results.title = await input({
+    message: "Title:",
+    default: issue.title,
+    validate: (val) => val.trim().length > 0 || "Title cannot be empty.",
+  });
+
+  // Status
+  results.status = await select({
+    message: "Status:",
+    choices: STATUS_CHOICES,
+    default: issue.status,
+  });
+
+  // Priority
+  results.priority = await select({
+    message: "Priority:",
+    choices: PRIORITY_CHOICES,
+    default: issue.priority,
+  });
+
+  // Token limit -- confirm-gated since it is optional
+  const currentLimit = issue.tokenLimit ?? null;
+  const wantsTokenLimit = await confirm({
+    message: `Set a token limit?${currentLimit ? ` (currently ${currentLimit})` : ""}`,
+    default: currentLimit !== null,
+  });
+  if (wantsTokenLimit) {
+    const raw = await input({
+      message: "Token limit (positive integer):",
+      default: currentLimit ? String(currentLimit) : undefined,
+      validate: (val) => {
+        const n = Number(val);
+        return (Number.isInteger(n) && n > 0) || "Must be a positive integer.";
+      },
+    });
+    results.tokenLimit = Number(raw);
+  }
+
+  // Description - $EDITOR flow, keep original if the user makes no changes
+  const wantsDescription = await confirm({
+    message: "Edit description?",
+    default: true,
+  });
+  if (wantsDescription) {
+    const editorBin = process.env.EDITOR || process.env.VISUAL;
+    const hint = editorBin ? `opens ${editorBin}` : "in-terminal editor";
+    console.log(
+      `  ->  ${hint} -- edit the description, save and quit when done.\n`,
+    );
+    const edited = await openEditorForDescription(issue.description ?? "");
+    // Only write to results if the user actually changed something
+    if (edited !== null) results.description = edited;
+  }
+
+  // Diff: loop over results and collect only what changed.
+  // Adding a new prompt above is all that is needed -- nothing to update here.
+  const pending = Object.fromEntries(
+    Object.entries(results).filter(([key, val]) => val !== issue[key]),
+  );
+
+  if (Object.keys(pending).length === 0) {
+    console.log("\nNo changes made.");
+    process.exit(0);
+  }
+
+  console.log("\n" + "-".repeat(48));
+  for (const [key, val] of Object.entries(pending)) {
+    const old = issue[key] ?? "(none)";
+    const preview = String(val).split("\n").slice(0, 2).join(" ").slice(0, 60);
+    console.log(
+      `  ${key}: "${old}" -> "${preview}${String(val).length > 60 ? "..." : ""}"`,
+    );
+  }
+  console.log("-".repeat(48) + "\n");
+
+  const confirmed = await confirm({ message: "Save changes?", default: true });
+  if (!confirmed) {
+    console.log("Aborted -- no changes saved.");
+    process.exit(0);
+  }
+
+  return pending;
+}
 
 /**
- * Updates the specified fields for a given issue ID 
+ * Updates the specified fields for a given issue ID.
+ * Drops into interactive mode when only an ID is provided and no field flags follow.
+ *
  * @param {string[]} args - The command line arguments
  * @returns {Promise<number>} The exit code: 0 is success, 1 is error.
  */
 export async function run(args) {
-    const isJson = hasFlag(args, '--json');
-    const cmdArgs = args.filter((arg) => arg !== '--json');
+  const isJson = hasFlag(args, "--json");
+  const cmdArgs = args.filter((arg) => arg !== "--json");
 
-    if (cmdArgs.length === 0 || cmdArgs === '') {
-        throw new Error("Invalid input: No arguments entered.\nUsage: baton update <id> [options] \nOptions: --title <text>, --description <text>, --token-limit <n>, --status <s>, --priority <level>");
-    } 
+  if (cmdArgs.length === 0 || cmdArgs === "") {
+    throw new Error(
+      `Invalid input: No arguments entered.\n${USAGE}\nOptions: ${FLAGS_HINT}`,
+    );
+  }
 
-    // Convert id argument from string to base-10 integer
-    const id = parseInt(cmdArgs[0], 10);
+  // Convert id argument from string to base-10 integer
+  const id = parseInt(cmdArgs[0], 10);
 
-    if (isNaN(id)) {
-        throw new Error ("Invalid input: No ID entered. \nUsage: baton update <id> [options]\nOptions: --title <text>, --description <text>, --token-limit <n>, --status <s>, --priority <level>");
+  if (isNaN(id)) {
+    throw new Error(
+      `Invalid input: No ID entered.\n${USAGE}\nOptions: ${FLAGS_HINT}`,
+    );
+  }
+
+  // Check if user misspelled a flag
+  for (const arg of cmdArgs) {
+    if (arg.startsWith("--") && !VALID_FLAGS.has(arg)) {
+      throw new Error(`Unknown flag: ${arg}\nValid flags: ${FLAGS_HINT}`);
     }
+  }
+
+  try {
+    const oldIssue = await getIssue(id);
 
-    const validFlags = ['--title', '--description', '--token-limit', '--status', '--priority', '--json'];
-    // Check if user misspelled a flag
-    for (const arg of cmdArgs) {
-        if (arg.startsWith('--')) {
-            if (!validFlags.includes(arg)) {
-                throw new Error(`Unknown flag provided: ${arg}. \nFlags: --title <text>, --description <text>, --token-limit <n>, --status <s>, --priority <level>`);
-            }
+    // Interactive mode: only the ID was passed, no field flags.
+    // Flag mode:        at least one flag follows the ID.
+    const providedFlags = cmdArgs.slice(1).filter((a) => a.startsWith("--"));
+    const isInteractive = providedFlags.length === 0;
+
+    const options = isInteractive
+      ? await runInteractiveMode(oldIssue)
+      : parseArgs(cmdArgs.slice(1));
+
+    const newIssue = await updateIssue(id, oldIssue, options);
+    const envelope = { status: "success", issue: serializeIssue(newIssue) };
+
+    renderOutput(isJson, envelope, () => {
+      console.log("");
+      console.log(`Successfully updated issue #${id}:`);
+      for (const key in options) {
+        if (oldIssue[key] !== newIssue[key]) {
+          console.log(`  ${key}: "${oldIssue[key]}" -> "${newIssue[key]}"`);
+        } else {
+          console.log(`  ${key}: No change (already set to "${newIssue[key]}")`);
         }
-    }
+      }
+      console.log("");
+    });
 
-    try {
-        const options = parseArgs(cmdArgs.slice(1));
-
-        // Store the old issue fields for displaying purposes:
-        const oldIssue = getIssue(id);
-
-        const newIssue = await updateIssue(id, oldIssue, options);
-        const envelope = { status: 'success', issue: serializeIssue(newIssue) };
-
-        renderOutput(isJson, envelope, () => {
-            console.log('');
-            // Compare and print the changes:
-            console.log(`Successfully updated issue #${id}:`);
-            for (const key in options) {
-                if (oldIssue[key] !== newIssue[key]) {
-                    console.log(`  ${key}: "${oldIssue[key]}" -> "${newIssue[key]}"`);
-                } else {
-                    // If the entered argument matches the old data
-                    console.log(`  ${key}: No change (already set to "${newIssue[key]}")`);
-                }
-            }
-            console.log('');
-        });
-
-        return 0;
-    } catch (error) {
-        console.error(`Failed to update issue: ${error.message}`);
-        return 1;
+    return 0;
+  } catch (error) {
+    if (error.name === "ExitPromptError") {
+      console.log("\nAborted.");
+      return 0;
     }
+    console.error(`Failed to update issue: ${error.message}`);
+    return 1;
+  }
 }