baton-issue-tracker 1.4.0 → 1.6.0

package/source/commands/loop.js

@@ -11,7 +11,7 @@
 //  baton loop -n 5
 
 import { isTrackerReady } from '../services/issuesService.js';
-import { getNumericFlag, reportTrackerNotReady } from '../util.js';
+import { getNumericFlag, hasFlag, renderOutput, reportTrackerNotReady } from '../util.js';
 import { run as runNext } from './next.js';
 
 /**
@@ -30,7 +30,9 @@ function parseLoopFlags(args) {
  * @returns {Promise<number>}
  */
 export async function run(args = []) {
-  const { steps } = parseLoopFlags(args);
+  const isJson = hasFlag(args, '--json');
+  const loopArgs = args.filter((arg) => arg !== '--json');
+  const { steps } = parseLoopFlags(loopArgs);
 
   if (!isTrackerReady()) {
     reportTrackerNotReady();
@@ -58,6 +60,8 @@ export async function run(args = []) {
     }
   }
 
-  console.log(`\nCompleted ${completed} autonomous step(s).`);
+  renderOutput(isJson, { status: 'success', steps, completed }, () => {
+    console.log(`\nCompleted ${completed} autonomous step(s).`);
+  });
   return 0;
 }

package/source/commands/next.js

@@ -8,7 +8,7 @@ import {
   selectNextIssue,
   workOnIssue,
 } from '../services/issuesService.js';
-import { formatTimestamp, reportTrackerNotReady } from '../util.js';
+import { formatTimestamp, hasFlag, renderOutput, reportTrackerNotReady, serializeIssue } from '../util.js';
 
 /**
  * Moves the AI agent to work on the next issue. 
@@ -17,7 +17,9 @@ import { formatTimestamp, reportTrackerNotReady } from '../util.js';
  * Stats are updated on the issue through workOnIssue function from init.js.
  * @returns {Promise<number>} The exit code: 0 is success, 1 is error.
  */
-export async function run() {
+export async function run(args = []) {
+  const isJson = hasFlag(args, '--json');
+
   if (!isTrackerReady()) {
     reportTrackerNotReady();
     return 1;
@@ -25,22 +27,27 @@ export async function run() {
 
   const issue = selectNextIssue();
   if (!issue) {
-    console.log('No open issues available. All work is complete or the backlog is empty.');
+    renderOutput(isJson, { status: 'success', issue: null }, () => {
+      console.log('No open issues available. All work is complete or the backlog is empty.');
+    });
     return 0;
   }
 
   const updated = workOnIssue(issue.id);
+  const envelope = { status: 'success', issue: serializeIssue(updated) };
 
-  console.log('Working on next issue:');
-  console.log(`  ID:          #${updated.id}`);
-  console.log(`  Title:       ${updated.title}`);
-  console.log(`  Priority:    ${updated.priority}`);
-  console.log(`  Status:      ${updated.status}`);
-  console.log(`  Attempts:    ${updated.attemptNum}`);
-  console.log(`  Created:     ${formatTimestamp(updated.createdAt)}`);
-  if (updated.description) {
-    console.log(`  Description: ${updated.description}`);
-  }
+  renderOutput(isJson, envelope, () => {
+    console.log('Working on next issue:');
+    console.log(`  ID:          #${updated.id}`);
+    console.log(`  Title:       ${updated.title}`);
+    console.log(`  Priority:    ${updated.priority}`);
+    console.log(`  Status:      ${updated.status}`);
+    console.log(`  Attempts:    ${updated.attemptNum}`);
+    console.log(`  Created:     ${formatTimestamp(updated.createdAt)}`);
+    if (updated.description) {
+      console.log(`  Description: ${updated.description}`);
+    }
+  });
 
   return 0;
 }

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/search.js

@@ -4,7 +4,13 @@
 // Usage: baton search "login bug"
 
 import { searchIssues } from "../services/issuesService.js";
-import { printIssueTable, printTableHeader } from '../util.js';
+import {
+  hasFlag,
+  printIssueTable,
+  printTableHeader,
+  renderOutput,
+  serializeIssue,
+} from '../util.js';
 
 /**
  * Searches for a title or description matching the command line argument
@@ -12,27 +18,31 @@ import { printIssueTable, printTableHeader } from '../util.js';
  * @returns {Promise<number>} The exit code: 0 is success, 1 is error.
  */
 export async function run(args) {
-    if (args.length === 0 || args === '') {
+    const isJson = hasFlag(args, '--json');
+    const queryArgs = args.filter((arg) => arg !== '--json');
+
+    if (queryArgs.length === 0 || queryArgs === '') {
         throw new Error("Invalid input: No search term entered.\nUsage: baton search <query>");
     }
 
     try {
-        const query = args.join(' ');
+        const query = queryArgs.join(' ');
         const result = await searchIssues(query);
+        const issues = result.map(serializeIssue);
+        const envelope = { status: 'success', count: issues.length, issues };
 
-        // If no issues with matching title or desc was found
-        if (result.length == 0) {
-            console.log(`No issues containing "${query}" were found.`);
-            return 0;
-        }
-
-        console.log(`\nFound ${result.length} issue(s) containing "${query}":\n`);
+        renderOutput(isJson, envelope, (data) => {
+            if (data.count === 0) {
+                console.log(`No issues containing "${query}" were found.`);
+                return;
+            }
 
-        // Logic for table formatting 
-        printTableHeader();
-        result.forEach(issue => printIssueTable(issue));
+            console.log(`\nFound ${data.count} issue(s) containing "${query}":\n`);
+            printTableHeader();
+            result.forEach((issue) => printIssueTable(issue));
+            console.log('');
+        });
 
-        console.log("");
         return 0;
     } catch (error) {
         // Failed to query database

package/source/commands/status.js

@@ -8,13 +8,15 @@ import {
   getIssueStats,
   getAllIssues,
 } from '../services/issuesService.js';
-import { reportTrackerNotReady } from '../util.js';
+import { hasFlag, renderOutput, reportTrackerNotReady } from '../util.js';
 
 /**
  * Main function that runs the status command.
  * @returns {Promise<number>} The exit code: 0 is success, 1 is error.
  */
-export async function run() {
+export async function run(args = []) {
+  const isJson = hasFlag(args, '--json');
+
   if (!isTrackerReady()) {
     reportTrackerNotReady();
     return 1;
@@ -29,27 +31,55 @@ export async function run() {
     progress = Math.round((stats.closed / stats.total) * 100);
   }
 
-  console.log('Issue Tracker Status');
-  console.log('──────────────────────────────────────────');
-  console.log(`Total issues:     ${stats.total}`);
-  console.log(`Open:             ${stats.open}`);
-  console.log(`In progress:      ${stats.inProgress}`);
-  console.log(`In review:        ${stats.inReview}`);
-  console.log(`Closed:           ${stats.closed}`);
-  console.log(`Overall progress: ${progress}% complete`);
-
-  if (issues.length > 0) {
-    console.log('\nOpen issues by priority:');
-    const byPriority = { High: 0, Medium: 0, Low: 0 };
+  const byPriority = { High: 0, Medium: 0, Low: 0 };
+  if (isJson) {
     for (const issue of issues) {
       if (issue.status === 'Open') {
         byPriority[issue.priority] += 1;
       }
     }
-    console.log(`  High:   ${byPriority.High}`);
-    console.log(`  Medium: ${byPriority.Medium}`);
-    console.log(`  Low:    ${byPriority.Low}`);
   }
 
+  const envelope = {
+    status: 'success',
+    stats: {
+      total: stats.total,
+      open: stats.open,
+      in_progress: stats.inProgress,
+      in_review: stats.inReview,
+      closed: stats.closed,
+      progress_percent: progress,
+    },
+    open_by_priority: {
+      high: byPriority.High,
+      medium: byPriority.Medium,
+      low: byPriority.Low,
+    },
+  };
+
+  renderOutput(isJson, envelope, () => {
+    console.log('Issue Tracker Status');
+    console.log('──────────────────────────────────────────');
+    console.log(`Total issues:     ${stats.total}`);
+    console.log(`Open:             ${stats.open}`);
+    console.log(`In progress:      ${stats.inProgress}`);
+    console.log(`In review:        ${stats.inReview}`);
+    console.log(`Closed:           ${stats.closed}`);
+    console.log(`Overall progress: ${progress}% complete`);
+
+    if (issues.length > 0) {
+      console.log('\nOpen issues by priority:');
+      const byPriority = { High: 0, Medium: 0, Low: 0 };
+      for (const issue of issues) {
+        if (issue.status === 'Open') {
+          byPriority[issue.priority] += 1;
+        }
+      }
+      console.log(`  High:   ${byPriority.High}`);
+      console.log(`  Medium: ${byPriority.Medium}`);
+      console.log(`  Low:    ${byPriority.Low}`);
+    }
+  });
+
   return 0;
 }

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,63 +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 { parseArgs } 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;
+}
 
 /**
- * Updates the specified fields for a given issue ID 
+ * 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.
+ * 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) {
-    if (args.length === 0 || args === '') {
-        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>");
-    } 
+  const isJson = hasFlag(args, "--json");
+  const cmdArgs = args.filter((arg) => arg !== "--json");
 
-    // Convert id argument from string to base-10 integer
-    const id = parseInt(args[0], 10);
+  if (cmdArgs.length === 0 || cmdArgs === "") {
+    throw new Error(
+      `Invalid input: No arguments entered.\n${USAGE}\nOptions: ${FLAGS_HINT}`,
+    );
+  }
 
-    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>");
-    }
+  // Convert id argument from string to base-10 integer
+  const id = parseInt(cmdArgs[0], 10);
 
-    const validFlags = ['--title', '--description', '--token-limit', '--status', '--priority'];
-    // 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>, --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);
 
-    try {
-        const options = parseArgs(args.slice(1));
+    // 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;
 
-        // Store the old issue fields for displaying purposes:
-        const oldIssue = getIssue(id);
+    const options = isInteractive
+      ? await runInteractiveMode(oldIssue)
+      : parseArgs(cmdArgs.slice(1));
 
-        const newIssue = await updateIssue(id, oldIssue, options);
+    const newIssue = await updateIssue(id, oldIssue, options);
+    const envelope = { status: "success", issue: serializeIssue(newIssue) };
 
-        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]}")`);
-            }
+    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("");
-        return 0;
-    } catch (error) {
-        console.error(`Failed to update issue: ${error.message}`);
-        return 1;
+      }
+      console.log("");
+    });
+
+    return 0;
+  } catch (error) {
+    if (error.name === "ExitPromptError") {
+      console.log("\nAborted.");
+      return 0;
     }
+    console.error(`Failed to update issue: ${error.message}`);
+    return 1;
+  }
 }