@proletariat/cli 0.3.20 → 0.3.22

package/dist/lib/pmo/storage/subtasks.js

@@ -5,6 +5,7 @@ import { randomUUID } from 'node:crypto';
 import { PMO_TABLES } from '../schema.js';
 import { PMOError } from '../types.js';
 import { slugify } from '../utils.js';
+import { wrapSqliteError } from './helpers.js';
 const T = PMO_TABLES;
 export class SubtaskStorage {
     ctx;
@@ -42,10 +43,15 @@ export class SubtaskStorage {
             id = `${baseId}-${counter}`;
         }
         const position = maxPos.max_pos + 1;
-        this.ctx.db.prepare(`
-      INSERT INTO ${T.subtasks} (id, ticket_id, title, done, position)
-      VALUES (?, ?, ?, 0, ?)
-    `).run(id, ticketId, title, position);
+        try {
+            this.ctx.db.prepare(`
+        INSERT INTO ${T.subtasks} (id, ticket_id, title, done, position)
+        VALUES (?, ?, ?, 0, ?)
+      `).run(id, ticketId, title, position);
+        }
+        catch (err) {
+            wrapSqliteError('Subtask', 'create', err);
+        }
         // Update ticket timestamp
         this.ctx.db.prepare(`
       UPDATE ${T.tickets} SET updated_at = ? WHERE id = ?
@@ -139,10 +145,15 @@ export class AcceptanceCriteriaStorage {
         // Use UUID to guarantee uniqueness even when multiple ACs are added in the same millisecond
         const id = `ac-${randomUUID()}`;
         const position = maxPos.max_pos + 1;
-        this.ctx.db.prepare(`
-      INSERT INTO ${T.ticket_acceptance_criteria} (id, ticket_id, criterion, verifiable, verified, position)
-      VALUES (?, ?, ?, 1, 0, ?)
-    `).run(id, ticketId, criterion, position);
+        try {
+            this.ctx.db.prepare(`
+        INSERT INTO ${T.ticket_acceptance_criteria} (id, ticket_id, criterion, verifiable, verified, position)
+        VALUES (?, ?, ?, 1, 0, ?)
+      `).run(id, ticketId, criterion, position);
+        }
+        catch (err) {
+            wrapSqliteError('Acceptance criterion', 'create', err);
+        }
         this.ctx.db.prepare(`
       UPDATE ${T.tickets} SET updated_at = ? WHERE id = ?
     `).run(Date.now(), ticketId);

package/dist/lib/pmo/storage/tickets.d.ts

@@ -8,6 +8,11 @@ import { StorageContext } from './types.js';
 export declare class TicketStorage {
     private ctx;
     constructor(ctx: StorageContext);
+    /**
+     * Validate a category against the DB.
+     * Returns the valid category name if found, throws error if invalid.
+     */
+    private validateCategory;
     /**
      * Resolve a project identifier to its actual ID.
      * Tries multiple strategies:

package/dist/lib/pmo/storage/tickets.js

@@ -6,13 +6,34 @@
 import { PMO_TABLES } from '../schema.js';
 import { PMOError } from '../types.js';
 import { slugify, generateEntityId } from '../utils.js';
-import { rowToTicket } from './helpers.js';
+import { rowToTicket, wrapSqliteError } from './helpers.js';
 const T = PMO_TABLES;
 export class TicketStorage {
     ctx;
     constructor(ctx) {
         this.ctx = ctx;
     }
+    /**
+     * Validate a category against the DB.
+     * Returns the valid category name if found, throws error if invalid.
+     */
+    async validateCategory(category) {
+        if (!category)
+            return null;
+        // Check if category exists in DB for ticket type
+        const row = this.ctx.db.prepare(`
+      SELECT name FROM ${T.categories} WHERE LOWER(name) = LOWER(?) AND type = 'ticket'
+    `).get(category);
+        if (!row) {
+            // Get valid categories for error message
+            const validCategories = this.ctx.db.prepare(`
+        SELECT name FROM ${T.categories} WHERE type = 'ticket' ORDER BY position
+      `).all();
+            const validNames = validCategories.map(c => c.name).join(', ');
+            throw new PMOError('INVALID', `Invalid category "${category}". Valid categories: ${validNames}`);
+        }
+        return row.name;
+    }
     /**
      * Resolve a project identifier to its actual ID.
      * Tries multiple strategies:
@@ -71,6 +92,8 @@ export class TicketStorage {
         const title = ticket.title || 'Untitled';
         const now = Date.now();
         const specId = ticket.specId || null;
+        // Validate category against DB
+        const validatedCategory = await this.validateCategory(ticket.category);
         // Get status_id from project's workflow
         let statusId = ticket.statusId;
         // Get the project's workflow
@@ -126,14 +149,19 @@ export class TicketStorage {
         }
         // Insert ticket
         const labels = ticket.labels || [];
-        this.ctx.db.prepare(`
-      INSERT INTO ${T.tickets} (
-        id, project_id, title, description, priority, category,
-        status_id, owner, assignee, spec_id, epic_id, labels,
-        created_at, updated_at, last_synced_from_spec, last_synced_from_board
-      )
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(id, projectId, title, ticket.description || null, ticket.priority || null, ticket.category || null, statusId, ticket.owner || null, ticket.assignee || null, specId, ticket.epicId || null, JSON.stringify(labels), now, now, ticket.lastSyncedFromSpec || null, ticket.lastSyncedFromBoard || null);
+        try {
+            this.ctx.db.prepare(`
+        INSERT INTO ${T.tickets} (
+          id, project_id, title, description, priority, category,
+          status_id, owner, assignee, spec_id, epic_id, labels,
+          created_at, updated_at, last_synced_from_spec, last_synced_from_board
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(id, projectId, title, ticket.description || null, ticket.priority || null, validatedCategory, statusId, ticket.owner || null, ticket.assignee || null, specId, ticket.epicId || null, JSON.stringify(labels), now, now, ticket.lastSyncedFromSpec || null, ticket.lastSyncedFromBoard || null);
+        }
+        catch (err) {
+            wrapSqliteError('Ticket', 'create', err);
+        }
         // Insert subtasks
         if (ticket.subtasks && ticket.subtasks.length > 0) {
             const insertSubtask = this.ctx.db.prepare(`
@@ -191,6 +219,11 @@ export class TicketStorage {
         if (!existing) {
             throw new PMOError('NOT_FOUND', `Ticket not found: ${id}`, id);
         }
+        // Validate category if being updated
+        let validatedCategory;
+        if (changes.category !== undefined) {
+            validatedCategory = await this.validateCategory(changes.category);
+        }
         const updates = [];
         const params = [];
         if (changes.title !== undefined) {
@@ -205,9 +238,9 @@ export class TicketStorage {
             updates.push('priority = ?');
             params.push(changes.priority);
         }
-        if (changes.category !== undefined) {
+        if (validatedCategory !== undefined) {
             updates.push('category = ?');
-            params.push(changes.category);
+            params.push(validatedCategory);
         }
         if (changes.statusId !== undefined) {
             updates.push('status_id = ?');
@@ -335,12 +368,19 @@ export class TicketStorage {
         }
         // Delete ticket (by ID only, since IDs are globally unique)
         // Related data (subtasks, metadata) are deleted via CASCADE
-        const result = this.ctx.db.prepare(`
-      DELETE FROM ${T.tickets}
-      WHERE id = ?
-    `).run(id);
-        if (result.changes === 0) {
-            throw new PMOError('NOT_FOUND', `Ticket not found: ${id}`, id);
+        try {
+            const result = this.ctx.db.prepare(`
+        DELETE FROM ${T.tickets}
+        WHERE id = ?
+      `).run(id);
+            if (result.changes === 0) {
+                throw new PMOError('NOT_FOUND', `Ticket not found: ${id}`, id);
+            }
+        }
+        catch (err) {
+            if (err instanceof PMOError)
+                throw err;
+            wrapSqliteError('Ticket', 'delete', err);
         }
         // Update board timestamp for the ticket's project
         this.updateProjectTimestamp(ticketProjectId);

package/dist/lib/pmo/storage/types.d.ts

@@ -216,3 +216,13 @@ export interface RoadmapProjectRow {
     position: number;
     created_at: string;
 }
+export interface CategoryRow {
+    id: string;
+    name: string;
+    type: string;
+    description: string | null;
+    color: string | null;
+    position: number;
+    is_builtin: number;
+    created_at: string;
+}

package/dist/lib/pmo/types.d.ts

@@ -83,6 +83,31 @@ export declare const LEGACY_PRIORITY_MAP: Record<LegacyPriority, Priority>;
  */
 export declare const TICKET_CATEGORIES: readonly ["feature", "bug", "refactor", "docs", "test", "chore", "performance", "ci", "build", "security", "database", "release"];
 export type TicketCategory = typeof TICKET_CATEGORIES[number];
+/**
+ * Category types (ticket vs status).
+ */
+export type CategoryType = 'ticket' | 'status';
+/**
+ * Category record for ticket or status classification.
+ */
+export interface Category {
+    id: string;
+    name: string;
+    type: CategoryType;
+    description?: string;
+    color?: string;
+    position: number;
+    isBuiltin: boolean;
+    createdAt: Date;
+}
+/**
+ * Filter options for listing categories.
+ */
+export interface CategoryFilter {
+    type?: CategoryType;
+    isBuiltin?: boolean;
+    search?: string;
+}
 /**
  * Check if a string is a valid Priority value.
  */

package/dist/lib/prompt-json.d.ts

@@ -128,20 +128,17 @@ export interface ErrorJsonOutput {
  */
 export type JsonOutput = PromptJsonOutput | SuccessJsonOutput | ErrorJsonOutput;
 /**
- * Flags interface for JSON mode detection (legacy)
- * @deprecated Use MachineOutputFlags instead
+ * Flags interface for JSON mode detection
  */
 export interface JsonFlags {
     json?: boolean;
 }
 /**
  * Flags interface for machine-readable output mode detection
- * Supports both new --machine format and legacy --json boolean
+ * --json is the primary flag, -m/--machine are aliases that set json=true
  */
 export interface MachineOutputFlags {
-    /** New format: --machine (enables machine-readable JSON output for AI agents) */
-    machine?: boolean;
-    /** Legacy format: --json (deprecated, use --machine instead) */
+    /** Primary JSON output flag. -m and --machine are aliases to this flag */
     json?: boolean;
 }
 /**
@@ -154,16 +151,13 @@ export declare function isNonTTY(): boolean;
  * Determine if JSON output mode is active (for AI agents)
  *
  * Returns true if:
- * - The --machine flag is explicitly set
- * - The --json flag is explicitly set
+ * - The --json flag is set (or -m/--machine aliases)
  * - The environment is non-TTY (piped output)
  *
  * @param flags - Command flags object
  * @returns true if JSON mode should be used
  */
-export declare function shouldOutputJson(flags: JsonFlags & {
-    machine?: boolean;
-}): boolean;
+export declare function shouldOutputJson(flags: JsonFlags): boolean;
 /**
  * Alias for shouldOutputJson - clearer name for agent-focused code
  */
@@ -172,8 +166,7 @@ export declare const isAgentMode: typeof shouldOutputJson;
  * Determine if machine-readable output mode is active (for AI agents/scripts)
  *
  * Returns true if:
- * - The --machine flag is set
- * - The --json flag is explicitly set (legacy support)
+ * - The --json flag is set (or -m/--machine aliases)
  * - The environment is non-TTY (piped output)
  *
  * @param flags - Command flags object
@@ -200,15 +193,16 @@ export declare function createMetadata(command: string, flags: Record<string, un
  */
 export declare function outputPromptAsJson(config: PromptConfig, metadata: OutputMetadata): never;
 /**
- * Output success result as JSON
+ * Output success result as JSON and exit
  *
  * Use this when all required data was provided via flags
- * and no prompt is needed.
+ * and no prompt is needed. Exits with EXIT_SUCCESS (0) to signal
+ * successful command completion.
  *
  * @param result - Command-specific result data
  * @param metadata - Command metadata
  */
-export declare function outputSuccessAsJson(result: Record<string, unknown>, metadata: OutputMetadata): void;
+export declare function outputSuccessAsJson(result: Record<string, unknown>, metadata: OutputMetadata): never;
 /**
  * Output error as JSON and exit
  *

package/dist/lib/prompt-json.js

@@ -41,19 +41,14 @@ export function isNonTTY() {
  * Determine if JSON output mode is active (for AI agents)
  *
  * Returns true if:
- * - The --machine flag is explicitly set
- * - The --json flag is explicitly set
+ * - The --json flag is set (or -m/--machine aliases)
  * - The environment is non-TTY (piped output)
  *
  * @param flags - Command flags object
  * @returns true if JSON mode should be used
  */
 export function shouldOutputJson(flags) {
-    // New --machine flag
-    if (flags.machine === true) {
-        return true;
-    }
-    // Legacy --json flag
+    // --json flag (includes -m and --machine aliases)
     if (flags.json === true) {
         return true;
     }
@@ -68,19 +63,14 @@ export const isAgentMode = shouldOutputJson;
  * Determine if machine-readable output mode is active (for AI agents/scripts)
  *
  * Returns true if:
- * - The --machine flag is set
- * - The --json flag is explicitly set (legacy support)
+ * - The --json flag is set (or -m/--machine aliases)
  * - The environment is non-TTY (piped output)
  *
  * @param flags - Command flags object
  * @returns true if machine-readable output mode should be used
  */
 export function isMachineOutput(flags) {
-    // New --machine flag takes precedence
-    if (flags.machine === true) {
-        return true;
-    }
-    // Legacy --json flag support
+    // --json flag (includes -m and --machine aliases)
     if (flags.json === true) {
         return true;
     }
@@ -128,10 +118,11 @@ export function outputPromptAsJson(config, metadata) {
     process.exit(EXIT_NEEDS_INPUT);
 }
 /**
- * Output success result as JSON
+ * Output success result as JSON and exit
  *
  * Use this when all required data was provided via flags
- * and no prompt is needed.
+ * and no prompt is needed. Exits with EXIT_SUCCESS (0) to signal
+ * successful command completion.
  *
  * @param result - Command-specific result data
  * @param metadata - Command metadata
@@ -144,6 +135,7 @@ export function outputSuccessAsJson(result, metadata) {
         metadata,
     };
     console.log(JSON.stringify(output, null, 2));
+    process.exit(EXIT_SUCCESS);
 }
 /**
  * Output error as JSON and exit