@proletariat/cli 0.3.28 → 0.3.30

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

@@ -1,7 +1,8 @@
 /**
  * Ticket operations for PMO.
  * Tickets reference workflow statuses directly via status_id.
- * Board position is derived from priority and created_at (no separate board_tickets table).
+ * Tickets have a position column for force-ranked ordering within a status.
+ * Positions use gapped integers (1000, 2000, 3000...) for stable reordering.
  */
 import { PMO_TABLES } from '../schema.js';
 import { PMOError } from '../types.js';
@@ -147,6 +148,11 @@ export class TicketStorage {
                 }
             }
         }
+        // Get next position for the target status (append to end with gapped integer)
+        const maxPos = this.ctx.db.prepare(`
+      SELECT COALESCE(MAX(position), 0) as max_pos FROM ${T.tickets} WHERE status_id = ?
+    `).get(statusId);
+        const position = maxPos.max_pos + 1000;
         // Insert ticket
         const labels = ticket.labels || [];
         try {
@@ -154,10 +160,10 @@ export class TicketStorage {
         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
+          position, 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);
+        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), position, now, now, ticket.lastSyncedFromSpec || null, ticket.lastSyncedFromBoard || null);
         }
         catch (err) {
             wrapSqliteError('Ticket', 'create', err);
@@ -200,7 +206,7 @@ export class TicketStorage {
         const row = this.ctx.db.prepare(`
       SELECT t.*,
              ws.id as column_id,
-             ws.position as position,
+             t.position as position,
              ws.name as column_name
       FROM ${T.tickets} t
       LEFT JOIN ${T.workflow_statuses} ws ON t.status_id = ws.id
@@ -321,9 +327,10 @@ export class TicketStorage {
     /**
      * Move a ticket to a different status (column).
      * In the workflow-based system, columns ARE statuses.
-     * The position parameter is ignored - tickets are sorted by priority then created_at.
+     * If position is provided, the ticket is placed at that position.
+     * Otherwise, the ticket is appended to the end of the target status.
      */
-    async moveTicket(projectId, id, column, _position) {
+    async moveTicket(projectId, id, column, position) {
         const existing = await this.getTicketById(id);
         if (!existing) {
             throw new PMOError('NOT_FOUND', `Ticket not found: ${id}`, id);
@@ -344,15 +351,124 @@ export class TicketStorage {
         if (!targetStatus) {
             throw new PMOError('NOT_FOUND', `Status not found: ${column}`);
         }
-        // Update ticket's status_id
+        // Determine position: use provided or append to end
+        let newPosition;
+        if (position !== undefined) {
+            newPosition = position;
+        }
+        else {
+            const maxPos = this.ctx.db.prepare(`
+        SELECT COALESCE(MAX(position), 0) as max_pos FROM ${T.tickets} WHERE status_id = ?
+      `).get(targetStatus.id);
+            newPosition = maxPos.max_pos + 1000;
+        }
+        // Update ticket's status_id and position
         this.ctx.db.prepare(`
       UPDATE ${T.tickets}
-      SET status_id = ?, updated_at = ?
+      SET status_id = ?, position = ?, updated_at = ?
       WHERE id = ?
-    `).run(targetStatus.id, Date.now(), id);
+    `).run(targetStatus.id, newPosition, Date.now(), id);
         this.ctx.updateBoardTimestamp(projectId);
         return (await this.getTicketById(id));
     }
+    /**
+     * Reorder a ticket within its current status.
+     * Supports two modes:
+     * 1. Direct position: set ticket to a specific position value
+     * 2. After ticket: place ticket immediately after another ticket
+     */
+    async reorderTicket(id, opts) {
+        const existing = await this.getTicketById(id);
+        if (!existing) {
+            throw new PMOError('NOT_FOUND', `Ticket not found: ${id}`, id);
+        }
+        let newPosition;
+        if (opts.afterTicketId) {
+            // Place after the specified ticket
+            const afterTicket = await this.getTicketById(opts.afterTicketId);
+            if (!afterTicket) {
+                throw new PMOError('NOT_FOUND', `Ticket not found: ${opts.afterTicketId}`, opts.afterTicketId);
+            }
+            // The after ticket must be in the same status
+            if (afterTicket.statusId !== existing.statusId) {
+                throw new PMOError('INVALID', `Cannot reorder: ${opts.afterTicketId} is in a different status`);
+            }
+            const afterPosition = afterTicket.position ?? 0;
+            // Find the next ticket after the target
+            const nextTicket = this.ctx.db.prepare(`
+        SELECT position FROM ${T.tickets}
+        WHERE status_id = ? AND position > ? AND id != ?
+        ORDER BY position ASC
+        LIMIT 1
+      `).get(existing.statusId, afterPosition, id);
+            if (nextTicket) {
+                // Place between afterTicket and nextTicket
+                const gap = nextTicket.position - afterPosition;
+                if (gap > 1) {
+                    newPosition = afterPosition + Math.floor(gap / 2);
+                }
+                else {
+                    // No gap - need to re-gap all tickets in this status
+                    this.regapPositions(existing.statusId, id);
+                    // Re-read the after ticket position after regapping
+                    const refreshedAfter = await this.getTicketById(opts.afterTicketId);
+                    const refreshedAfterPos = refreshedAfter?.position ?? 0;
+                    const refreshedNext = this.ctx.db.prepare(`
+            SELECT position FROM ${T.tickets}
+            WHERE status_id = ? AND position > ? AND id != ?
+            ORDER BY position ASC
+            LIMIT 1
+          `).get(existing.statusId, refreshedAfterPos, id);
+                    newPosition = refreshedNext
+                        ? refreshedAfterPos + Math.floor((refreshedNext.position - refreshedAfterPos) / 2)
+                        : refreshedAfterPos + 1000;
+                }
+            }
+            else {
+                // Append after the target (no tickets after it)
+                newPosition = afterPosition + 1000;
+            }
+        }
+        else if (opts.position !== undefined) {
+            newPosition = opts.position;
+        }
+        else {
+            throw new PMOError('INVALID', 'Must provide either position or after_ticket_id');
+        }
+        this.ctx.db.prepare(`
+      UPDATE ${T.tickets}
+      SET position = ?, updated_at = ?
+      WHERE id = ?
+    `).run(newPosition, Date.now(), id);
+        if (existing.projectId) {
+            this.ctx.updateBoardTimestamp(existing.projectId);
+        }
+        return (await this.getTicketById(id));
+    }
+    /**
+     * Re-gap positions for all tickets in a status using 1000-gaps.
+     * Optionally excludes a ticket (e.g., the one being moved).
+     */
+    regapPositions(statusId, excludeTicketId) {
+        let query = `
+      SELECT id FROM ${T.tickets}
+      WHERE status_id = ?
+    `;
+        const params = [statusId];
+        if (excludeTicketId) {
+            query += ' AND id != ?';
+            params.push(excludeTicketId);
+        }
+        query += ' ORDER BY position ASC, created_at ASC';
+        const tickets = this.ctx.db.prepare(query).all(...params);
+        const update = this.ctx.db.prepare(`UPDATE ${T.tickets} SET position = ? WHERE id = ?`);
+        const regap = this.ctx.db.transaction(() => {
+            tickets.forEach((ticket, idx) => {
+                update.run((idx + 1) * 1000, ticket.id);
+            });
+        });
+        regap();
+    }
     /**
      * Delete a ticket.
      * Works with ticket ID only - no project context required since ticket IDs are globally unique.
@@ -405,7 +521,7 @@ export class TicketStorage {
         let query = `
       SELECT t.*,
              ws.id as column_id,
-             ws.position as position,
+             t.position as position,
              ws.name as column_name,
              p.name as project_name
       FROM ${T.tickets} t
@@ -460,28 +576,12 @@ export class TicketStorage {
             query += ' AND ws.name = ?';
             params.push(filter.column);
         }
-        // Order by project, then status position, then priority, then created_at
+        // Order by status column position, then ticket position within status
         if (projectIdOrName === undefined) {
-            query += ` ORDER BY p.name, ws.position,
-        CASE t.priority
-          WHEN 'P0' THEN 0
-          WHEN 'P1' THEN 1
-          WHEN 'P2' THEN 2
-          WHEN 'P3' THEN 3
-          ELSE 4
-        END,
-        t.created_at ASC`;
+            query += ` ORDER BY p.name, ws.position, t.position ASC, t.created_at ASC`;
         }
         else {
-            query += ` ORDER BY ws.position,
-        CASE t.priority
-          WHEN 'P0' THEN 0
-          WHEN 'P1' THEN 1
-          WHEN 'P2' THEN 2
-          WHEN 'P3' THEN 3
-          ELSE 4
-        END,
-        t.created_at ASC`;
+            query += ` ORDER BY ws.position, t.position ASC, t.created_at ASC`;
         }
         const rows = this.ctx.db.prepare(query).all(...params);
         return Promise.all(rows.map((row) => rowToTicket(this.ctx.db, row)));
@@ -536,13 +636,19 @@ export class TicketStorage {
                 newStatusId = firstStatus.id;
             }
         }
-        // Update ticket's project_id and status_id
+        // Get next position for the target status
+        const targetStatusId = newStatusId || existing.statusId;
+        const maxPos = this.ctx.db.prepare(`
+      SELECT COALESCE(MAX(position), 0) as max_pos FROM ${T.tickets} WHERE status_id = ?
+    `).get(targetStatusId);
+        const newTicketPosition = maxPos.max_pos + 1000;
+        // Update ticket's project_id, status_id, and position
         const now = Date.now();
         this.ctx.db.prepare(`
       UPDATE ${T.tickets}
-      SET project_id = ?, status_id = ?, updated_at = ?
+      SET project_id = ?, status_id = ?, position = ?, updated_at = ?
       WHERE id = ?
-    `).run(newProjectId, newStatusId || existing.statusId, now, ticketId);
+    `).run(newProjectId, targetStatusId, newTicketPosition, now, ticketId);
         // Update timestamps for both projects
         this.updateProjectTimestamp(oldProjectId);
         this.updateProjectTimestamp(newProjectId);

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

@@ -298,16 +298,8 @@ export class ViewStorage {
             const searchTerm = `%${filters.search}%`;
             params.push(searchTerm, searchTerm);
         }
-        // Order by priority then created_at
-        sql += ` ORDER BY
-      CASE t.priority
-        WHEN 'P0' THEN 0
-        WHEN 'P1' THEN 1
-        WHEN 'P2' THEN 2
-        WHEN 'P3' THEN 3
-        ELSE 4
-      END,
-      t.created_at ASC`;
+        // Order by ticket position, then created_at as tiebreaker
+        sql += ` ORDER BY t.position ASC, t.created_at ASC`;
         const rows = this.ctx.db.prepare(sql).all(...params);
         return Promise.all(rows.map((row) => this.rowToTicketWithColumn(row)));
     }

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

@@ -664,6 +664,10 @@ export interface PMOStorage {
     getTicket(id: string): Promise<Ticket | null>;
     updateTicket(id: string, changes: Partial<Ticket>): Promise<Ticket>;
     moveTicket(projectId: string, id: string, column: string, position?: number): Promise<Ticket>;
+    reorderTicket(id: string, opts: {
+        position?: number;
+        afterTicketId?: string;
+    }): Promise<Ticket>;
     moveTicketToProject(ticketId: string, newProjectId: string): Promise<Ticket>;
     deleteTicket(id: string): Promise<void>;
     listTickets(projectId: string | undefined, filter?: TicketFilter): Promise<Ticket[]>;