@proletariat/cli 0.2.0 → 0.3.1

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

@@ -0,0 +1,61 @@
+/**
+ * Dependency operations for tickets, specs, and epics.
+ */
+import { EpicDependency, EpicDependencyType, SpecDependency, SpecDependencyType, Ticket, TicketDependency, TicketDependencyType } from '../types.js';
+import { StorageContext } from './types.js';
+export declare class DependencyStorage {
+    private ctx;
+    constructor(ctx: StorageContext);
+    /**
+     * Create a dependency between two tickets.
+     */
+    createTicketDependency(ticketId: string, dependsOnTicketId: string, dependencyType?: TicketDependencyType): Promise<TicketDependency>;
+    /**
+     * Delete a ticket dependency.
+     */
+    deleteTicketDependency(ticketId: string, dependsOnTicketId: string, dependencyType?: TicketDependencyType): Promise<void>;
+    /**
+     * List dependencies for a ticket.
+     */
+    listTicketDependencies(ticketId: string): Promise<TicketDependency[]>;
+    /**
+     * Get tickets that this ticket depends on (blockers).
+     */
+    getTicketBlockers(ticketId: string): Promise<Ticket[]>;
+    /**
+     * Get tickets that depend on this ticket (blocking).
+     */
+    getTicketsBlockedBy(ticketId: string): Promise<Ticket[]>;
+    /**
+     * Check if a ticket is blocked by incomplete dependencies.
+     */
+    isTicketBlocked(ticketId: string): Promise<boolean>;
+    /**
+     * Create a dependency between two specs.
+     */
+    createSpecDependency(specId: string, dependsOnSpecId: string, dependencyType?: SpecDependencyType): Promise<SpecDependency>;
+    /**
+     * Delete a spec dependency.
+     */
+    deleteSpecDependency(specId: string, dependsOnSpecId: string, dependencyType?: SpecDependencyType): Promise<void>;
+    /**
+     * List dependencies for a spec.
+     */
+    listSpecDependencies(specId: string): Promise<SpecDependency[]>;
+    /**
+     * Create a dependency between two epics.
+     */
+    createEpicDependency(epicId: string, dependsOnEpicId: string, dependencyType?: EpicDependencyType): Promise<EpicDependency>;
+    /**
+     * Delete an epic dependency.
+     */
+    deleteEpicDependency(epicId: string, dependsOnEpicId: string, dependencyType?: EpicDependencyType): Promise<void>;
+    /**
+     * List dependencies for an epic.
+     */
+    listEpicDependencies(epicId: string): Promise<EpicDependency[]>;
+    /**
+     * Check if an epic is blocked by incomplete dependencies.
+     */
+    isEpicBlocked(epicId: string): Promise<boolean>;
+}

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

@@ -0,0 +1,267 @@
+/**
+ * Dependency operations for tickets, specs, and epics.
+ */
+import { PMO_TABLES } from '../schema.js';
+import { PMOError, } from '../types.js';
+import { rowToTicket } from './helpers.js';
+const T = PMO_TABLES;
+export class DependencyStorage {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    // =========================================================================
+    // Ticket Dependencies
+    // =========================================================================
+    /**
+     * Create a dependency between two tickets.
+     */
+    async createTicketDependency(ticketId, dependsOnTicketId, dependencyType = 'blocks') {
+        // Validate tickets exist
+        const ticket = this.ctx.db.prepare(`SELECT id FROM ${T.tickets} WHERE id = ?`).get(ticketId);
+        if (!ticket)
+            throw new PMOError('NOT_FOUND', `Ticket not found: ${ticketId}`);
+        const dependsOn = this.ctx.db.prepare(`SELECT id FROM ${T.tickets} WHERE id = ?`).get(dependsOnTicketId);
+        if (!dependsOn)
+            throw new PMOError('NOT_FOUND', `Ticket not found: ${dependsOnTicketId}`);
+        try {
+            this.ctx.db.prepare(`
+        INSERT INTO ${T.ticket_dependencies} (ticket_id, depends_on_ticket_id, dependency_type)
+        VALUES (?, ?, ?)
+      `).run(ticketId, dependsOnTicketId, dependencyType);
+            return {
+                ticketId,
+                dependsOnTicketId,
+                dependencyType,
+                createdAt: new Date(),
+            };
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('UNIQUE constraint')) {
+                throw new PMOError('CONFLICT', 'Dependency already exists');
+            }
+            if (error instanceof Error && error.message.includes('CHECK constraint')) {
+                throw new PMOError('INVALID', 'Cannot create self-dependency');
+            }
+            throw error;
+        }
+    }
+    /**
+     * Delete a ticket dependency.
+     */
+    async deleteTicketDependency(ticketId, dependsOnTicketId, dependencyType) {
+        let query = `DELETE FROM ${T.ticket_dependencies} WHERE ticket_id = ? AND depends_on_ticket_id = ?`;
+        const params = [ticketId, dependsOnTicketId];
+        if (dependencyType) {
+            query += ' AND dependency_type = ?';
+            params.push(dependencyType);
+        }
+        const result = this.ctx.db.prepare(query).run(...params);
+        if (result.changes === 0) {
+            throw new PMOError('NOT_FOUND', 'Dependency not found');
+        }
+    }
+    /**
+     * List dependencies for a ticket.
+     */
+    async listTicketDependencies(ticketId) {
+        const rows = this.ctx.db.prepare(`
+      SELECT ticket_id, depends_on_ticket_id, dependency_type, created_at
+      FROM ${T.ticket_dependencies}
+      WHERE ticket_id = ?
+      ORDER BY created_at DESC
+    `).all(ticketId);
+        return rows.map((row) => ({
+            ticketId: row.ticket_id,
+            dependsOnTicketId: row.depends_on_ticket_id,
+            dependencyType: row.dependency_type,
+            createdAt: new Date(row.created_at),
+        }));
+    }
+    /**
+     * Get tickets that this ticket depends on (blockers).
+     */
+    async getTicketBlockers(ticketId) {
+        const rows = this.ctx.db.prepare(`
+      SELECT t.*,
+             ws.id as column_id,
+             ws.name as column_name,
+             ws.position as position
+      FROM ${T.tickets} t
+      JOIN ${T.ticket_dependencies} d ON t.id = d.depends_on_ticket_id
+      LEFT JOIN ${T.workflow_statuses} ws ON t.status_id = ws.id
+      WHERE d.ticket_id = ? AND d.dependency_type = 'blocks'
+    `).all(ticketId);
+        return Promise.all(rows.map((row) => rowToTicket(this.ctx.db, row)));
+    }
+    /**
+     * Get tickets that depend on this ticket (blocking).
+     */
+    async getTicketsBlockedBy(ticketId) {
+        const rows = this.ctx.db.prepare(`
+      SELECT t.*,
+             ws.id as column_id,
+             ws.name as column_name,
+             ws.position as position
+      FROM ${T.tickets} t
+      JOIN ${T.ticket_dependencies} d ON t.id = d.ticket_id
+      LEFT JOIN ${T.workflow_statuses} ws ON t.status_id = ws.id
+      WHERE d.depends_on_ticket_id = ? AND d.dependency_type = 'blocks'
+    `).all(ticketId);
+        return Promise.all(rows.map((row) => rowToTicket(this.ctx.db, row)));
+    }
+    /**
+     * Check if a ticket is blocked by incomplete dependencies.
+     */
+    async isTicketBlocked(ticketId) {
+        const blockers = await this.getTicketBlockers(ticketId);
+        return blockers.some((t) => t.status !== 'done' && t.status !== 'canceled');
+    }
+    // =========================================================================
+    // Spec Dependencies
+    // =========================================================================
+    /**
+     * Create a dependency between two specs.
+     */
+    async createSpecDependency(specId, dependsOnSpecId, dependencyType = 'depends_on') {
+        // Validate specs exist
+        const spec = this.ctx.db.prepare(`SELECT id FROM ${T.specs} WHERE id = ?`).get(specId);
+        if (!spec)
+            throw new PMOError('NOT_FOUND', `Spec not found: ${specId}`);
+        const dependsOn = this.ctx.db.prepare(`SELECT id FROM ${T.specs} WHERE id = ?`).get(dependsOnSpecId);
+        if (!dependsOn)
+            throw new PMOError('NOT_FOUND', `Spec not found: ${dependsOnSpecId}`);
+        try {
+            this.ctx.db.prepare(`
+        INSERT INTO ${T.spec_dependencies} (spec_id, depends_on_spec_id, dependency_type)
+        VALUES (?, ?, ?)
+      `).run(specId, dependsOnSpecId, dependencyType);
+            return {
+                specId,
+                dependsOnSpecId,
+                dependencyType,
+                createdAt: new Date(),
+            };
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('UNIQUE constraint')) {
+                throw new PMOError('CONFLICT', 'Dependency already exists');
+            }
+            if (error instanceof Error && error.message.includes('CHECK constraint')) {
+                throw new PMOError('INVALID', 'Cannot create self-dependency');
+            }
+            throw error;
+        }
+    }
+    /**
+     * Delete a spec dependency.
+     */
+    async deleteSpecDependency(specId, dependsOnSpecId, dependencyType) {
+        let query = `DELETE FROM ${T.spec_dependencies} WHERE spec_id = ? AND depends_on_spec_id = ?`;
+        const params = [specId, dependsOnSpecId];
+        if (dependencyType) {
+            query += ' AND dependency_type = ?';
+            params.push(dependencyType);
+        }
+        const result = this.ctx.db.prepare(query).run(...params);
+        if (result.changes === 0) {
+            throw new PMOError('NOT_FOUND', 'Dependency not found');
+        }
+    }
+    /**
+     * List dependencies for a spec.
+     */
+    async listSpecDependencies(specId) {
+        const rows = this.ctx.db.prepare(`
+      SELECT spec_id, depends_on_spec_id, dependency_type, created_at
+      FROM ${T.spec_dependencies}
+      WHERE spec_id = ?
+      ORDER BY created_at DESC
+    `).all(specId);
+        return rows.map((row) => ({
+            specId: row.spec_id,
+            dependsOnSpecId: row.depends_on_spec_id,
+            dependencyType: row.dependency_type,
+            createdAt: new Date(row.created_at),
+        }));
+    }
+    // =========================================================================
+    // Epic Dependencies
+    // =========================================================================
+    /**
+     * Create a dependency between two epics.
+     */
+    async createEpicDependency(epicId, dependsOnEpicId, dependencyType = 'blocks') {
+        // Validate epics exist
+        const epic = this.ctx.db.prepare(`SELECT id FROM ${T.epics} WHERE id = ?`).get(epicId);
+        if (!epic)
+            throw new PMOError('NOT_FOUND', `Epic not found: ${epicId}`);
+        const dependsOn = this.ctx.db.prepare(`SELECT id FROM ${T.epics} WHERE id = ?`).get(dependsOnEpicId);
+        if (!dependsOn)
+            throw new PMOError('NOT_FOUND', `Epic not found: ${dependsOnEpicId}`);
+        try {
+            this.ctx.db.prepare(`
+        INSERT INTO ${T.epic_dependencies} (epic_id, depends_on_epic_id, dependency_type)
+        VALUES (?, ?, ?)
+      `).run(epicId, dependsOnEpicId, dependencyType);
+            return {
+                epicId,
+                dependsOnEpicId,
+                dependencyType,
+                createdAt: new Date(),
+            };
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('UNIQUE constraint')) {
+                throw new PMOError('CONFLICT', 'Dependency already exists');
+            }
+            if (error instanceof Error && error.message.includes('CHECK constraint')) {
+                throw new PMOError('INVALID', 'Cannot create self-dependency');
+            }
+            throw error;
+        }
+    }
+    /**
+     * Delete an epic dependency.
+     */
+    async deleteEpicDependency(epicId, dependsOnEpicId, dependencyType) {
+        let query = `DELETE FROM ${T.epic_dependencies} WHERE epic_id = ? AND depends_on_epic_id = ?`;
+        const params = [epicId, dependsOnEpicId];
+        if (dependencyType) {
+            query += ' AND dependency_type = ?';
+            params.push(dependencyType);
+        }
+        const result = this.ctx.db.prepare(query).run(...params);
+        if (result.changes === 0) {
+            throw new PMOError('NOT_FOUND', 'Dependency not found');
+        }
+    }
+    /**
+     * List dependencies for an epic.
+     */
+    async listEpicDependencies(epicId) {
+        const rows = this.ctx.db.prepare(`
+      SELECT epic_id, depends_on_epic_id, dependency_type, created_at
+      FROM ${T.epic_dependencies}
+      WHERE epic_id = ?
+      ORDER BY created_at DESC
+    `).all(epicId);
+        return rows.map((row) => ({
+            epicId: row.epic_id,
+            dependsOnEpicId: row.depends_on_epic_id,
+            dependencyType: row.dependency_type,
+            createdAt: new Date(row.created_at),
+        }));
+    }
+    /**
+     * Check if an epic is blocked by incomplete dependencies.
+     */
+    async isEpicBlocked(epicId) {
+        const rows = this.ctx.db.prepare(`
+      SELECT e.status FROM ${T.epics} e
+      JOIN ${T.epic_dependencies} d ON e.id = d.depends_on_epic_id
+      WHERE d.epic_id = ? AND d.dependency_type = 'blocks'
+    `).all(epicId);
+        return rows.some((r) => r.status !== 'complete' && r.status !== 'dropped');
+    }
+}

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

@@ -0,0 +1,46 @@
+/**
+ * Epic operations for PMO.
+ */
+import { Epic, EpicFilter, Ticket } from '../types.js';
+import { StorageContext } from './types.js';
+export declare class EpicStorage {
+    private ctx;
+    constructor(ctx: StorageContext);
+    /**
+     * Create a new epic.
+     */
+    createEpic(projectId: string, epic: Partial<Epic>): Promise<Epic>;
+    /**
+     * Get an epic by ID.
+     */
+    getEpic(id: string): Promise<Epic | null>;
+    /**
+     * List epics with optional filters.
+     */
+    listEpics(projectId: string, filter?: EpicFilter): Promise<Epic[]>;
+    /**
+     * Reorder an epic to a new position.
+     */
+    reorderEpic(projectId: string, epicId: string, newPosition: number): Promise<Epic>;
+    /**
+     * Update an epic.
+     */
+    updateEpic(id: string, changes: Partial<Epic>): Promise<Epic>;
+    /**
+     * Delete an epic.
+     */
+    deleteEpic(id: string): Promise<void>;
+    /**
+     * Get tickets for an epic.
+     */
+    getTicketsForEpic(projectId: string, epicId: string): Promise<Ticket[]>;
+    /**
+     * Link a ticket to an epic.
+     */
+    linkTicketToEpic(ticketId: string, epicId: string): Promise<void>;
+    /**
+     * Unlink a ticket from its epic.
+     */
+    unlinkTicketFromEpic(ticketId: string): Promise<void>;
+    private rowToEpic;
+}

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

@@ -0,0 +1,243 @@
+/**
+ * Epic operations for PMO.
+ */
+import { PMO_TABLES } from '../schema.js';
+import { PMOError } from '../types.js';
+import { generateEntityId } from '../utils.js';
+import { rowToTicket } from './helpers.js';
+const T = PMO_TABLES;
+export class EpicStorage {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    /**
+     * Create a new epic.
+     */
+    async createEpic(projectId, epic) {
+        const id = epic.id || generateEntityId(this.ctx.db, 'epic');
+        const title = epic.title || 'Untitled Epic';
+        const status = epic.status || 'active';
+        const now = Date.now();
+        // Get next position if not provided
+        let position = epic.position;
+        if (position === undefined) {
+            const maxPos = this.ctx.db.prepare(`
+        SELECT COALESCE(MAX(position), -1) as max_pos FROM ${T.epics} WHERE project_id = ?
+      `).get(projectId);
+            position = maxPos.max_pos + 1;
+        }
+        this.ctx.db.prepare(`
+      INSERT INTO ${T.epics} (id, project_id, title, description, status, position, file_path, spec_id, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, projectId, title, epic.description || null, status, position, epic.filePath || null, epic.specId || null, now, now);
+        this.ctx.updateBoardTimestamp(projectId);
+        return {
+            id,
+            projectId,
+            title,
+            description: epic.description,
+            status,
+            position,
+            filePath: epic.filePath,
+            specId: epic.specId,
+            createdAt: new Date(now),
+            updatedAt: new Date(now),
+        };
+    }
+    /**
+     * Get an epic by ID.
+     */
+    async getEpic(id) {
+        const row = this.ctx.db.prepare(`
+      SELECT * FROM ${T.epics} WHERE id = ?
+    `).get(id);
+        if (!row)
+            return null;
+        return this.rowToEpic(row);
+    }
+    /**
+     * List epics with optional filters.
+     */
+    async listEpics(projectId, filter) {
+        let query = `SELECT * FROM ${T.epics} WHERE project_id = ?`;
+        const params = [projectId];
+        if (filter?.status) {
+            query += ' AND status = ?';
+            params.push(filter.status);
+        }
+        if (filter?.search) {
+            query += ' AND (title LIKE ? OR description LIKE ?)';
+            params.push(`%${filter.search}%`, `%${filter.search}%`);
+        }
+        query += ' ORDER BY position ASC, created_at ASC';
+        const rows = this.ctx.db.prepare(query).all(...params);
+        return rows.map((row) => this.rowToEpic(row));
+    }
+    /**
+     * Reorder an epic to a new position.
+     */
+    async reorderEpic(projectId, epicId, newPosition) {
+        const epic = await this.getEpic(epicId);
+        if (!epic) {
+            throw new Error(`Epic not found: ${epicId}`);
+        }
+        const oldPosition = epic.position;
+        if (oldPosition === newPosition) {
+            return epic;
+        }
+        if (newPosition < oldPosition) {
+            this.ctx.db.prepare(`
+        UPDATE ${T.epics}
+        SET position = position + 1, updated_at = ?
+        WHERE project_id = ? AND position >= ? AND position < ?
+      `).run(Date.now(), projectId, newPosition, oldPosition);
+        }
+        else {
+            this.ctx.db.prepare(`
+        UPDATE ${T.epics}
+        SET position = position - 1, updated_at = ?
+        WHERE project_id = ? AND position > ? AND position <= ?
+      `).run(Date.now(), projectId, oldPosition, newPosition);
+        }
+        this.ctx.db.prepare(`
+      UPDATE ${T.epics}
+      SET position = ?, updated_at = ?
+      WHERE id = ?
+    `).run(newPosition, Date.now(), epicId);
+        this.ctx.updateBoardTimestamp(projectId);
+        return (await this.getEpic(epicId));
+    }
+    /**
+     * Update an epic.
+     */
+    async updateEpic(id, changes) {
+        const epic = await this.getEpic(id);
+        if (!epic) {
+            throw new PMOError('NOT_FOUND', `Epic not found: ${id}`);
+        }
+        const updates = [];
+        const params = [];
+        if (changes.title !== undefined) {
+            updates.push('title = ?');
+            params.push(changes.title);
+        }
+        if (changes.description !== undefined) {
+            updates.push('description = ?');
+            params.push(changes.description);
+        }
+        if (changes.status !== undefined) {
+            updates.push('status = ?');
+            params.push(changes.status);
+        }
+        if (changes.filePath !== undefined) {
+            updates.push('file_path = ?');
+            params.push(changes.filePath);
+        }
+        if (changes.specId !== undefined) {
+            updates.push('spec_id = ?');
+            params.push(changes.specId || null);
+        }
+        if (updates.length > 0) {
+            updates.push('updated_at = ?');
+            params.push(Date.now());
+            params.push(id);
+            this.ctx.db.prepare(`UPDATE ${T.epics} SET ${updates.join(', ')} WHERE id = ?`).run(...params);
+        }
+        this.ctx.updateBoardTimestamp(epic.projectId);
+        return (await this.getEpic(id));
+    }
+    /**
+     * Delete an epic.
+     */
+    async deleteEpic(id) {
+        const epic = await this.getEpic(id);
+        if (!epic) {
+            throw new PMOError('NOT_FOUND', `Epic not found: ${id}`);
+        }
+        // Unlink tickets from this epic
+        this.ctx.db.prepare(`
+      UPDATE ${T.tickets} SET epic_id = NULL WHERE epic_id = ?
+    `).run(id);
+        this.ctx.db.prepare(`DELETE FROM ${T.epics} WHERE id = ?`).run(id);
+        this.ctx.updateBoardTimestamp(epic.projectId);
+    }
+    /**
+     * Get tickets for an epic.
+     */
+    async getTicketsForEpic(projectId, epicId) {
+        const rows = this.ctx.db.prepare(`
+      SELECT t.*,
+             ws.id as column_id,
+             ws.position as position,
+             ws.name as column_name
+      FROM ${T.tickets} t
+      LEFT JOIN ${T.workflow_statuses} ws ON t.status_id = ws.id
+      WHERE t.project_id = ? AND t.epic_id = ?
+      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
+    `).all(projectId, epicId);
+        return Promise.all(rows.map((row) => rowToTicket(this.ctx.db, row)));
+    }
+    /**
+     * Link a ticket to an epic.
+     */
+    async linkTicketToEpic(ticketId, epicId) {
+        // Verify ticket exists and get its project
+        const ticket = this.ctx.db.prepare(`
+      SELECT id, project_id FROM ${T.tickets} WHERE id = ?
+    `).get(ticketId);
+        if (!ticket) {
+            throw new PMOError('NOT_FOUND', `Ticket not found: ${ticketId}`, ticketId);
+        }
+        // Verify epic exists
+        const epic = await this.getEpic(epicId);
+        if (!epic) {
+            throw new PMOError('NOT_FOUND', `Epic not found: ${epicId}`);
+        }
+        this.ctx.db.prepare(`
+      UPDATE ${T.tickets}
+      SET epic_id = ?, updated_at = ?
+      WHERE id = ?
+    `).run(epicId, Date.now(), ticketId);
+        this.ctx.updateBoardTimestamp(ticket.project_id);
+    }
+    /**
+     * Unlink a ticket from its epic.
+     */
+    async unlinkTicketFromEpic(ticketId) {
+        // Get ticket's project for board timestamp update
+        const ticket = this.ctx.db.prepare(`
+      SELECT project_id FROM ${T.tickets} WHERE id = ?
+    `).get(ticketId);
+        this.ctx.db.prepare(`
+      UPDATE ${T.tickets}
+      SET epic_id = NULL, updated_at = ?
+      WHERE id = ?
+    `).run(Date.now(), ticketId);
+        if (ticket) {
+            this.ctx.updateBoardTimestamp(ticket.project_id);
+        }
+    }
+    rowToEpic(row) {
+        return {
+            id: row.id,
+            projectId: row.project_id,
+            title: row.title,
+            description: row.description || undefined,
+            status: row.status,
+            position: row.position,
+            filePath: row.file_path || undefined,
+            specId: row.spec_id || undefined,
+            createdAt: new Date(row.created_at),
+            updatedAt: new Date(row.updated_at),
+        };
+    }
+}

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

@@ -0,0 +1,33 @@
+/**
+ * Helper functions for converting database rows to domain types.
+ */
+import Database from 'better-sqlite3';
+import { AcceptanceCriterion, Spec, StateCategory, Ticket } from '../types.js';
+import { SpecRow, TicketRow, WorkflowStatusRow } from './types.js';
+/**
+ * Convert a database row to a Ticket object.
+ * Fetches related data (subtasks, metadata, status info).
+ */
+export declare function rowToTicket(db: Database.Database, row: TicketRow): Promise<Ticket>;
+/**
+ * Get acceptance criteria for a ticket (sync version).
+ */
+export declare function getAcceptanceCriteriaSync(db: Database.Database, ticketId: string): AcceptanceCriterion[];
+/**
+ * Convert a database row to a Spec object.
+ */
+export declare function rowToSpec(row: SpecRow): Spec;
+/**
+ * Convert a workflow status database row to WorkflowStatus.
+ */
+export declare function rowToStatus(row: WorkflowStatusRow): {
+    id: string;
+    workflowId: string;
+    name: string;
+    category: StateCategory;
+    position: number;
+    color: string | undefined;
+    description: string | undefined;
+    isDefault: boolean;
+    createdAt: Date;
+};