baton-issue-tracker 1.13.3 → 1.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "baton-issue-tracker",
-  "version": "1.13.3",
+  "version": "1.14.0",
   "description": "A CLI issue tracker for AI agents",
   "type": "module",
   "bin": {

package/source/cli.js

@@ -28,8 +28,10 @@ import { run as runRegister } from './commands/register.js';
 import { run as runAgents } from './commands/agents.js';
 import { run as runWhoami } from './commands/whoami.js';
 import { run as runSubmit } from './commands/submit.js';
+import { run as runUnassign } from './commands/unassign.js';
 import { run as runUnclaim } from './commands/unclaim.js';
 import { run as runClaim } from './commands/claim.js';
+import { run as runAssign} from './commands/assign.js';
 
 import { authenticateContext } from './services/authService.js';
 
@@ -56,6 +58,7 @@ Commands:
   update   Updates an issue's specified fields
   delete   Deletes an issue
   log      Show activity history for an issue
+  unassign Removes all assignees from issue
 
 Options:
   init --force                    Re-initialize an existing tracker database
@@ -94,6 +97,7 @@ Options:
   update --json                   Output as JSON (for AI agents)
   delete <id> [--yes]
   log <id> [--json]
+  unassign <id> [--json]          Output as JSON (for AI agents)
 
 Examples:
   baton init
@@ -120,6 +124,8 @@ Examples:
   baton update 3 --title "Revised title"
   baton update 7 --status closed --priority medium
   baton log 5
+  baton unassign 12
+  baton unassign 11 --json
 `;
 
 /**
@@ -156,7 +162,9 @@ async function main() {
     delete: () => runDelete(args),
     log: () => runLog(args),
     submit: () => runSubmit(args),
+    unassign: () => runUnassign(args),
     unclaim: () => runUnclaim(args),
+    assign: () => runAssign(args),
   };
 
   const handler = handlers[command];

package/source/commands/assign.js

@@ -0,0 +1,66 @@
+// commands/assign.js
+// assign command for the issue tracker
+// usage: baton assign <id> <agent-name> [--json]
+// AI was consulted for a portion of this file
+
+import { getAgentByName } from '../services/agentsService.js';
+import { assignIssue } from '../services/issuesService.js';
+import { getCurrentActor } from '../services/authService.js';
+import { hasFlag, renderOutput } from '../util.js';
+
+const DECIMAL_BASE = 10;
+
+/**
+ * Runs the assign command to associate an issue with a registered agent.
+ * Usage: baton assign <id> <agent-name> [--json]
+ * @param {string[]} args - The command line arguments
+ * @returns {Promise<number>} The exit code: 0 is success, 1 is error.
+ */
+export async function run(args = []) {
+  // Check if the user requested JSON output formatting via the --json flag
+  const isJson = hasFlag(args, '--json');
+  
+  // Strip out any flags starting with '-' to isolate the raw [issueIdStr, agentName] positional arguments
+  const [issueIdStr, agentName] = args.filter(arg => !arg.startsWith('-'));
+
+  // Guard Clause: Ensure both the issue ID and the agent name were provided
+  if (!issueIdStr || !agentName) {
+    console.error('Usage Error: Missing arguments.\nUsage: baton assign <id> <agent-name> [--json]');
+    return 1;
+  }
+
+  // Convert the extracted issue ID string into a safe decimal integer
+  const issueId = parseInt(issueIdStr, DECIMAL_BASE);
+  
+  // Guard Clause: If parsing failed (e.g., the user typed letters instead of an ID), reject it
+  if (isNaN(issueId)) {
+    console.error(`Error: Invalid issue ID "${issueIdStr}". Must be an integer.`);
+    return 1;
+  }
+
+  try {
+    // Look up the current operator. If null, error
+    const actor = getCurrentActor() || Object.assign(new Error('No authenticated context found.'), { isAuthErr: true });
+    // If that identifier property exists, it means the lookup failed; error
+    if (actor.isAuthErr) throw actor;
+
+    // Look up the target assignee by name. If not found, error
+    const target = getAgentByName(agentName) || Object.assign(new Error(`Agent/User "${agentName}" is not registered.`), { isTargetErr: true });
+    // If the lookup failed, throw the target error
+    if (target.isTargetErr) throw target;
+
+    // Execute the assignment in the database layer, passing the parsed ID, assignee ID, and operator ID
+    const issue = assignIssue(issueId, target.id, actor.id);
+
+    // Render the final output payload. If --json is on, it prints raw data. Otherwise, executes callback.
+    renderOutput(isJson, { status: 'success', issueId: issue.id, assignee: { id: target.id, name: target.name, type: target.type } }, () => {
+      console.log(`Success: Issue #${issueId} assigned to "${agentName}"`);
+    });
+    
+    return 0; // Command completed successfully
+  } catch (error) {
+    // Intercepts any thrown operational error (or database crash) and outputs a clean message
+    console.error(`Error: ${error.message}`);
+    return 1; // Return error exit code
+  }
+}

package/source/commands/create.js

@@ -14,6 +14,7 @@
 //   --description <text>   Issue description
 //   --priority <level>     low | medium | high  (default: low)
 //   --token-limit <n>      Optional token budget for this issue
+//   --assignee <name>      Agent assigned to this issue
 //   -h, --help             Show this help
 
 import { createIssue } from "../services/issuesService.js";
@@ -24,8 +25,9 @@ import { spawnSync } from "child_process";
 import { writeFileSync, readFileSync, unlinkSync } from "fs";
 import { tmpdir } from "os";
 import { join } from "path";
+import { listAgents, getAgentByName } from '../services/agentsService.js';
 
-const ALLOWED_CREATE_FIELDS = ['title', 'priority', 'tokenLimit', 'description'];
+const ALLOWED_CREATE_FIELDS = ['title', 'priority', 'tokenLimit', 'description', 'assigneeId'];
 
 const VALID_FLAGS = new Set([
   ...ALLOWED_CREATE_FIELDS.map(key => issueSchema[key].flag),
@@ -157,6 +159,19 @@ async function runInteractiveMode() {
     description = await openEditorForDescription();
   }
 
+  // Assignee
+  const agents = listAgents();
+  const assigneeChoices = [
+    { name: '(none)', value: null },
+    ...agents.map(a => ({ name: `${a.name} (${a.type})`, value: a.id }))
+  ];
+
+  const assigneeId = await select({
+    message: 'Assign to:',
+    choices: assigneeChoices,
+    default: null,
+  });
+
   // Preview & confirm
   console.log("\n" + "-".repeat(48));
   console.log(`  Title      : ${title}`);
@@ -181,7 +196,7 @@ async function runInteractiveMode() {
     process.exit(0);
   }
 
-  return { title, priority, tokenLimit, description };
+  return { title, priority, tokenLimit, description, assigneeId };
 }
 
 /**
@@ -217,6 +232,17 @@ export async function run(args) {
       ? await runInteractiveMode()
       : parseArgs(args);
 
+    // Getting agent name from ID
+    if (options.assigneeId) {
+      const target = getAgentByName(options.assigneeId);
+      if (!target) {
+        const agents = listAgents();
+        const names = agents.map(agent => `${agent.name} (${agent.type})`).join(', ');
+        throw new Error(`Agent/User "${options.assigneeId}" is not registered.\nRegistered agents: ${names}`);
+      }
+      options.assigneeId = target.id;
+    }
+
     const issue = await createIssue(options);
     const envelope = { status: "success", issue: serializeIssue(issue) };
 

package/source/commands/init.js

@@ -11,9 +11,11 @@
 //  baton init --specs ./path/to/my-specs.md
 //  baton init --specs C:\full\path\to\specs.md
 
-import { readFileSync, existsSync } from 'node:fs';
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { initDB } from '../db/index.js';
+import os from 'node:os';
+import { registerAgent } from '../services/agentsService.js';
 import { Priority } from '../models/issue.js';
 import {
   createIssue,
@@ -156,6 +158,37 @@ export async function run(args = []) {
     clearAllIssues();
   }
 
+  // auto-register default deployment human user
+  let autoRegisterMessage = '';
+  try {
+    const activeName = process.env.BATON_AGENT || os.userInfo().username;
+    registerAgent(activeName, 'human');
+    autoRegisterMessage = `Auto-registered default human user: "${activeName}"`;
+  } catch (error){
+    if (!error.message?.includes('UNIQUE constraint failed')) {
+      autoRegisterMessage = `Warning: Could not auto-register default user: ${error.message}`;
+    }
+  }
+
+  if (autoRegisterMessage && !isJson) {
+    console.log(autoRegisterMessage);
+  }
+
+  const templatePath = join('docs', 'BATON_AGENT_RULES.md');
+
+  let rulesContent = '';
+  if (existsSync(templatePath)) {
+    rulesContent = readFileSync(templatePath, 'utf8');
+  }
+
+  const outputPath = join(process.cwd(), 'BATON_AGENT_RULES.md');
+  if (existsSync(outputPath) && !flags.force) {
+    console.error('Error: BATON_AGENT_RULES.md already exists. Use --force to overwrite.');
+    return 1;
+  }
+
+  writeFileSync(outputPath, rulesContent, 'utf8');
+
   const resolvedSpecsPath = resolvePath(flags.specs, DEFAULT_SPECS_PATH);
   const createdIssues = generateIssuesFromSpecs(flags.specs);
   const envelope = {
@@ -180,4 +213,4 @@ export async function run(args = []) {
   });
 
   return 0;
-}
+}

package/source/commands/list.js

@@ -8,13 +8,15 @@
 //  --priority <p>    Filter by priority: low | medium | high
 //  --limit <n>       Max results (default: 50)
 //  --offset <n>      Skip first n results (default: 0)
+//  --assignee <name> Filter by assignee name
 //  --json            Output as JSON (for AI agents)
 //  -h, --help        Show this help
 
 import { listIssues } from '../services/issuesService.js';
+import { issueSchema } from '../models/schema.js';
+import { listAgents, getAgentByName } from '../services/agentsService.js';
+
 import {
-  getFlagValue,
-  getNumericFlag,
   hasFlag,
   parseArgs,
   printIssueTable,
@@ -23,6 +25,13 @@ import {
   serializeIssue,
 } from '../util.js';
 
+const ALLOWED_LIST_FIELDS = ['status', 'priority', 'limit', 'offset', 'assigneeId'];
+
+const VALID_FLAGS = new Set([
+  ...ALLOWED_LIST_FIELDS.map(key => issueSchema[key].flag),
+  '--json',
+]);
+
 /**
  * Lists issues matching the filters and pagination settings 
  * @param {string[]} args - The command line arguments
@@ -31,19 +40,26 @@ import {
 
 export async function run(args) {
     const isJson = hasFlag(args, '--json');
-    const validFlags = ['--status', '--priority', '--limit', '--offset', '--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: --status <s>, --priority <p>, --limit <n>, --offset <n>, --json`);
-            }
+        if (arg.startsWith('--') && !VALID_FLAGS.has(arg)) {
+            throw new Error(`Unknown flag provided: ${arg}.\nFlags: ${[...VALID_FLAGS].join(', ')}`);
         }
     }
 
     try {
         const options = parseArgs(args);
 
+        // Getting agent name from ID
+        if (options.assigneeId) {
+            const target = getAgentByName(options.assigneeId);
+            if (!target) {
+            const agents = listAgents();
+            const names = agents.map(agent => `${agent.name} (${agent.type})`).join(', ');
+            throw new Error(`Agent/User "${options.assigneeId}" is not registered.\nRegistered agents: ${names}`);
+            }
+            options.assigneeId = target.id;
+        }
+
         const result = await listIssues(options);
         const issues = result.map(serializeIssue);
         const envelope = { status: 'success', count: issues.length, issues };

package/source/commands/unassign.js

@@ -0,0 +1,95 @@
+// unassign.js
+// AI was consulted to generate the majority of the contents of this file.
+// However, a human has reviewed and editted the generated code.
+// Removes the current assignee from an issue.
+//
+// Usage:
+//   baton unassign <id> [--json]
+//
+// Examples:
+//   baton unassign 12
+//   baton unassign 12 --json
+
+import { getIssue, unassignIssue } from "../services/issuesService.js";
+import { getCurrentActor } from "../services/context.js";
+import { AgentType } from "../models/agents.js";
+import { hasFlag, renderOutput, renderError, serializeIssue } from "../util.js";
+
+const VALID_FLAGS = new Set(["--json"]);
+
+/**
+ * Removes the current assignee from 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) {
+  const isJson = hasFlag(args, "--json");
+
+  // Validate flags
+  const providedFlags = args.filter((a) => a.startsWith("--"));
+  for (const flag of providedFlags) {
+    if (!VALID_FLAGS.has(flag)) {
+      throw new Error(`Unknown flag: ${flag}`);
+    }
+  }
+
+  const idArg = args.find((a) => !a.startsWith("-"));
+  const issueId = Number(idArg);
+
+  if (!Number.isInteger(issueId) || issueId <= 0) {
+    renderError(
+      isJson,
+      `Invalid ID "${idArg}". ID must be a positive integer.`,
+      "INVALID_ID",
+    );
+    return 1;
+  }
+
+  const actor = getCurrentActor();
+
+  if (!actor || actor.type !== AgentType.HUMAN) {
+    renderError(isJson, "Only human users can unassign issues.", "FORBIDDEN");
+    return 1;
+  }
+  
+  let issue;
+
+  try {
+    issue = getIssue(issueId);
+  } catch (error) {
+    if (error.message.includes("not found")) {
+      renderError(isJson, error.message, "NOT_FOUND");
+    } else {
+      renderError(isJson, error.message);
+    }
+    return 1;
+  }
+
+  if (!issue.assigneeId) {
+    renderError(
+      isJson,
+      `Issue #${issueId} is not assigned.`,
+      "INVALID_STATE"
+    );
+    return 1;
+  }
+
+  try {
+    // Use unassignIssue from issuesService.js
+    const updatedIssue = unassignIssue(issueId);
+
+    const envelope = {
+      status: "success",
+      issue: serializeIssue(updatedIssue),
+    };
+
+    renderOutput(isJson, envelope, () => {
+      console.log(`Success: Issue #${issueId} is now unassigned.`);
+    });
+
+    return 0;
+  } catch (error) {
+    renderError(isJson, error.message);
+    return 1;
+  }
+}

package/source/commands/update.js

@@ -25,8 +25,9 @@ import { spawnSync } from "child_process";
 import { writeFileSync, readFileSync, unlinkSync } from "fs";
 import { tmpdir } from "os";
 import { join } from "path";
+import { listAgents, getAgentByName } from '../services/agentsService.js';
 
-const ALLOWED_UPDATE_FIELDS = ['title', 'status', 'priority', 'tokenLimit', 'description'];
+const ALLOWED_UPDATE_FIELDS = ['title', 'status', 'priority', 'tokenLimit', 'description', 'assigneeId'];
 
 const VALID_FLAGS = new Set([
   ...ALLOWED_UPDATE_FIELDS.map(key => issueSchema[key].flag),
@@ -161,6 +162,24 @@ async function runInteractiveMode(issue) {
     if (edited !== null) results.description = edited;
   }
 
+  // Assignee
+  const wantsAssignee = await confirm({
+    message: "Edit assignee?",
+    default: false,
+  });
+  if (wantsAssignee) {
+    const agents = listAgents();
+    const assigneeChoices = [
+      { name: '(none)', value: null },
+      ...agents.map(agent => ({ name: `${agent.name} (${agent.type})`, value: agent.id }))
+    ];
+    results.assigneeId = await select({
+      message: 'Assign to:',
+      choices: assigneeChoices,
+      default: issue.assigneeId ?? null
+    });
+  }
+
   // 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(
@@ -236,6 +255,17 @@ export async function run(args) {
       ? await runInteractiveMode(oldIssue)
       : parseArgs(cmdArgs.slice(1));
 
+    // Getting agent name from ID
+    if (options.assigneeId) {
+      const target = getAgentByName(options.assigneeId);
+      if (!target) {
+        const agents = listAgents();
+        const names = agents.map(agent => `${agent.name} (${agent.type})`).join(', ');
+        throw new Error(`Agent/User "${options.assigneeId}" is not registered.\nRegistered agents: ${names}`);
+      }
+      options.assigneeId = target.id;
+    }
+
     const newIssue = await updateIssue(id, oldIssue, options);
     const envelope = { status: "success", issue: serializeIssue(newIssue) };
 

package/source/models/schema.js

@@ -53,7 +53,7 @@ export const issueSchema = {
     tokenLimit: { flag: '--token-limit', type: 'number' },
     priority:   { flag: '--priority', type: 'enum', values: Object.values(Priority) },
     description:{ flag: '--description', type: 'string' },
-    assigneeId: { flag: '--assignee-id', type: 'number'},
+    assigneeId: { flag: '--assignee', type: 'string'},
     // Pagination options 
     limit:      { flag: '--limit', type: 'number' },
     offset:     { flag: '--offset', type: 'number' }

package/source/services/agentRestrictions.js

@@ -1,11 +1,12 @@
 // agentRestrictions.js 
 
 const AGENT_RESTRICTED_COMMANDS = new Set(['init', 'approve', 'reject', 'delete', 'priority']);
-const AGENT_RESTRICTED_FLAGS = new Set(['--status', '--token-limit']);
+const AGENT_RESTRICTED_FLAGS = new Set(['--status', '--token-limit', '--assignee']);
 
 /**
  * Validates whether an actor has permission to execute a given command and arguments.
  * @param {string} command - The primary CLI command name.
+ * @param {string[]} [args=[]] - The command line arguments.
  * @throws {Error} If the agent entered a restricted command or flag
  */
 export function authorizeAction(command, args = []) {
@@ -14,7 +15,6 @@ export function authorizeAction(command, args = []) {
   }
 
   if (command === 'update') {
-    const args = process.argv.slice(2); 
     const usedRestricted = args.filter(arg => AGENT_RESTRICTED_FLAGS.has(arg));
     if (usedRestricted.length > 0) {
       throw new Error(

package/source/services/authService.js

@@ -12,6 +12,7 @@ export { getCurrentActor };
  * If the agent/user is registered, it sets them as the active actor for this session.
  * If not, it terminates the process with a helpful error message.
  * @param {string} command - The command being executed
+ * @param {string[]} [args=[]] - The command line arguments.
  */
 export function authenticateContext(command, args = []) {
   const exemptCommands = ['register', 'help'];

package/source/services/issuesService.js

@@ -1,3 +1,4 @@
+// AI was consulted to guide implementation of part of the file.
 import { getDB } from '../db/index.js';
 import { eq, and, or, like, sql } from "drizzle-orm";
 import {issuesTable, activityTable} from "../models/schema.js";
@@ -231,6 +232,7 @@ export function updateIssue(id, oldIssue, { title, description, tokenLimit, stat
     updates.status = toUpdate || status;
   }
 
+
   // Normalize priority argument
   if (priority !== undefined) {
     const priorityValues = Object.values(Priority);
@@ -257,6 +259,48 @@ export function updateIssue(id, oldIssue, { title, description, tokenLimit, stat
   return getIssue(id);
 }
 
+/**
+ * 
+ * Sets assigneeId to null
+ * Logs an edit event
+ * @param {number} issueId - ID of the issue to be editted
+ * @returns {Issue}
+ */
+export function unassignIssue(issueId){
+  const db = getDB();
+
+  // Check that issue exists
+  findById(db, issueId);
+
+  db.update(issuesTable).set({ status: Status.OPEN, assigneeId: null }).where(eq(issuesTable.id, issueId)).run();
+  logActivity(db, issueId, Action.EDIT, `Success: Issue #${issueId} is now unassigned.`);
+  return getIssue(issueId);
+}
+
+/**
+ * Assigns an issue to a specific registered agent or human.
+ * Logs an edit event.
+ * @param {number} issueId 
+ * @param {number} assigneeId 
+ * @returns {Issue} - the issue that matches the ID
+ */
+export function assignIssue(issueId, assigneeId) {
+  const db = getDB();
+  
+  // Verify the issue exists first (will throw if not found)
+  findById(db, issueId);
+  
+  db.update(issuesTable)
+    .set({ assigneeId: assigneeId })
+    .where(eq(issuesTable.id, issueId))
+    .run();
+
+  // Pass actorId directly instead of hacking the global module variable
+  logActivity(db, issueId, Action.EDIT, `Issue #${issueId} was assigned.`);
+  
+  return getIssue(issueId);
+}
+
 /**
  * Change the status of an issue from in-review to closed
  * Logs a closed event.

package/source/util.js

@@ -5,6 +5,7 @@
 
 import { isAbsolute, resolve } from 'node:path';
 import { issueSchema } from '../source/models/schema.js';
+import { getAgentById } from '../source/services/agentsService.js';
 
 /**
  * Formats a timestamp as `HH:MM:SS YYYY-MM-DD`.
@@ -269,7 +270,7 @@ export const WIDTHS = {
   title: 20,
   status: 15,
   priority: 10,
-  //assignees: 10, 
+  assignee: 10, 
   description: 50
 };
 
@@ -283,7 +284,7 @@ export function printTableHeader() {
     "TITLE".padEnd(WIDTHS.title) + " │ " +
     "STATUS".padEnd(WIDTHS.status) + " │ " +
     "PRIORITY".padEnd(WIDTHS.priority) + " │ " +
-    //"ASSIGNEE".padEnd(WIDTHS.assignees) + " │ " +
+    "ASSIGNEE".padEnd(WIDTHS.assignee) + " │ " +
     "DESCRIPTION".padEnd(WIDTHS.description)
   );
   console.log(
@@ -291,7 +292,7 @@ export function printTableHeader() {
     "─".repeat(WIDTHS.title) + "─┼─" +
     "─".repeat(WIDTHS.status) + "─┼─" +
     "─".repeat(WIDTHS.priority) + "─┼─" +
-    //"─".repeat(WIDTHS.assignees) + "─┼─" +
+    "─".repeat(WIDTHS.assignee) + "─┼─" +
     "─".repeat(WIDTHS.description)
   );
 }
@@ -324,9 +325,10 @@ export function printIssueTable(issue) {
   const priorityVal = truncate(issue.priority, WIDTHS.priority).padEnd(WIDTHS.priority);
   const descVal = truncate(issue.description, WIDTHS.description).padEnd(WIDTHS.description);
 
-  // Handling the assignee array
-  //const assigneesVal = Array.isArray(issue.assignees) ? issue.assignees.join(', ') : 'None';
-  //const assigneeVal = truncate(assigneesVal, WIDTHS.assignees).padEnd(WIDTHS.assignees);
+  // Getting Agent name from id
+  const assigneeId = issue.assigneeId ?? issue.assignee_id ?? null;
+  const assignee = assigneeId ? getAgentById(assigneeId) : null;
+  const assigneeVal = truncate(assignee?.name ?? null, WIDTHS.assignee).padEnd(WIDTHS.assignee);
 
-  console.log(`${idVal} │ ${titleVal} │ ${statusVal} │ ${priorityVal} │ ${descVal}`);
+  console.log(`${idVal} │ ${titleVal} │ ${statusVal} │ ${priorityVal} │ ${assigneeVal} │ ${descVal}`);
 }