@proletariat/cli 0.3.36 → 0.3.40

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

@@ -1,7 +1,8 @@
 /**
  * Helper functions for converting database rows to domain types.
  */
-import { PMO_TABLES } from '../schema.js';
+import { eq, asc } from 'drizzle-orm';
+import { pmoSubtasks, pmoTicketMetadata, pmoWorkflowStatuses, pmoTicketAcceptanceCriteria, } from '../../database/drizzle-schema.js';
 import { PMOError, normalizePriority, } from '../types.js';
 /**
  * Check if an error is a SQLite UNIQUE constraint violation.
@@ -61,31 +62,37 @@ export function wrapSqliteError(entityType, operation, err) {
     // Re-throw unknown errors
     throw err;
 }
-const T = PMO_TABLES;
 /**
  * Convert a database row to a Ticket object.
- * Fetches related data (subtasks, metadata, status info).
+ * Fetches related data (subtasks, metadata, status info) using Drizzle ORM.
  */
-export async function rowToTicket(db, row) {
+export async function rowToTicket(drizzle, row) {
     // Get subtasks
-    const subtasks = db
-        .prepare(`SELECT * FROM ${T.subtasks} WHERE ticket_id = ? ORDER BY position`)
-        .all(row.id);
+    const subtaskRows = drizzle
+        .select()
+        .from(pmoSubtasks)
+        .where(eq(pmoSubtasks.ticketId, row.id))
+        .orderBy(asc(pmoSubtasks.position))
+        .all();
     // Get metadata
-    const metaRows = db
-        .prepare(`SELECT key, value FROM ${T.ticket_metadata} WHERE ticket_id = ?`)
-        .all(row.id);
+    const metaRows = drizzle
+        .select({ key: pmoTicketMetadata.key, value: pmoTicketMetadata.value })
+        .from(pmoTicketMetadata)
+        .where(eq(pmoTicketMetadata.ticketId, row.id))
+        .all();
     const metadata = {};
     for (const m of metaRows) {
-        metadata[m.key] = m.value;
+        metadata[m.key] = m.value || '';
     }
     // Get status info from workflow_statuses
     let statusName;
     let statusCategory;
     if (row.status_id) {
-        const statusRow = db
-            .prepare(`SELECT name, category FROM ${T.workflow_statuses} WHERE id = ?`)
-            .get(row.status_id);
+        const statusRow = drizzle
+            .select({ name: pmoWorkflowStatuses.name, category: pmoWorkflowStatuses.category })
+            .from(pmoWorkflowStatuses)
+            .where(eq(pmoWorkflowStatuses.id, row.status_id))
+            .get();
         if (statusRow) {
             statusName = statusRow.name;
             statusCategory = statusRow.category;
@@ -126,14 +133,14 @@ export async function rowToTicket(db, row) {
         branch: row.branch || undefined,
         specId: row.spec_id || undefined,
         epicId: row.epic_id || undefined,
-        subtasks: subtasks.map((st) => ({
+        subtasks: subtaskRows.map((st) => ({
             id: st.id,
             title: st.title,
-            done: st.done === 1,
+            done: st.done ?? false,
         })),
         labels,
         metadata,
-        acceptanceCriteria: getAcceptanceCriteriaSync(db, row.id),
+        acceptanceCriteria: getAcceptanceCriteriaSync(drizzle, row.id),
         createdAt: new Date(row.created_at),
         updatedAt: new Date(row.updated_at),
         lastSyncedFromSpec: row.last_synced_from_spec
@@ -148,18 +155,21 @@ export async function rowToTicket(db, row) {
 /**
  * Get acceptance criteria for a ticket (sync version).
  */
-export function getAcceptanceCriteriaSync(db, ticketId) {
-    const rows = db
-        .prepare(`SELECT * FROM ${T.ticket_acceptance_criteria} WHERE ticket_id = ? ORDER BY position`)
-        .all(ticketId);
+export function getAcceptanceCriteriaSync(drizzle, ticketId) {
+    const rows = drizzle
+        .select()
+        .from(pmoTicketAcceptanceCriteria)
+        .where(eq(pmoTicketAcceptanceCriteria.ticketId, ticketId))
+        .orderBy(asc(pmoTicketAcceptanceCriteria.position))
+        .all();
     return rows.map((row) => ({
         id: row.id,
-        ticketId: row.ticket_id,
+        ticketId: row.ticketId,
         criterion: row.criterion,
-        verifiable: row.verifiable === 1,
-        verified: row.verified === 1,
-        verifiedAt: row.verified_at ? new Date(row.verified_at) : undefined,
-        verifiedBy: row.verified_by || undefined,
+        verifiable: row.verifiable ?? true,
+        verified: row.verified ?? false,
+        verifiedAt: row.verifiedAt ? new Date(row.verifiedAt) : undefined,
+        verifiedBy: row.verifiedBy || undefined,
         position: row.position,
     }));
 }

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

@@ -1,6 +1,8 @@
 /**
  * Project operations.
  * Board columns are now derived from workflow statuses (single source of truth).
+ *
+ * This module uses Drizzle ORM for type-safe database queries.
  */
 import { Board, BoardConfig, Project, ProjectFilter } from '../types.js';
 import { StorageContext } from './types.js';

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

@@ -1,13 +1,15 @@
 /**
  * Project operations.
  * Board columns are now derived from workflow statuses (single source of truth).
+ *
+ * This module uses Drizzle ORM for type-safe database queries.
  */
-import { PMO_TABLES } from '../schema.js';
+import { eq, and, like, or, asc, desc, sql, count } from 'drizzle-orm';
+import { pmoProjects, pmoTickets, pmoWorkflows, pmoWorkflowStatuses, } from '../../database/drizzle-schema.js';
 import { PMOError, } from '../types.js';
 import { generateEntityId, slugify } from '../utils.js';
 import { generateBoardMarkdown } from '../markdown.js';
 import { rowToTicket, wrapSqliteError } from './helpers.js';
-const T = PMO_TABLES;
 export class ProjectStorage {
     ctx;
     constructor(ctx) {
@@ -29,34 +31,42 @@ export class ProjectStorage {
         if (!identifier)
             return null;
         // 1. Exact ID match
-        const exactMatch = this.ctx.db.prepare(`
-      SELECT id FROM ${T.projects} WHERE id = ?
-    `).get(identifier);
+        const exactMatch = this.ctx.drizzle
+            .select({ id: pmoProjects.id })
+            .from(pmoProjects)
+            .where(eq(pmoProjects.id, identifier))
+            .get();
         if (exactMatch)
             return exactMatch.id;
         // 2. Case-insensitive ID match
-        const caseInsensitiveId = this.ctx.db.prepare(`
-      SELECT id FROM ${T.projects} WHERE LOWER(id) = LOWER(?)
-    `).get(identifier);
+        const caseInsensitiveId = this.ctx.drizzle
+            .select({ id: pmoProjects.id })
+            .from(pmoProjects)
+            .where(sql `LOWER(${pmoProjects.id}) = LOWER(${identifier})`)
+            .get();
         if (caseInsensitiveId)
             return caseInsensitiveId.id;
         // 3. Exact name match
-        const nameMatch = this.ctx.db.prepare(`
-      SELECT id FROM ${T.projects} WHERE name = ?
-    `).get(identifier);
+        const nameMatch = this.ctx.drizzle
+            .select({ id: pmoProjects.id })
+            .from(pmoProjects)
+            .where(eq(pmoProjects.name, identifier))
+            .get();
         if (nameMatch)
             return nameMatch.id;
         // 4. Case-insensitive name match
-        const caseInsensitiveName = this.ctx.db.prepare(`
-      SELECT id FROM ${T.projects} WHERE LOWER(name) = LOWER(?)
-    `).get(identifier);
+        const caseInsensitiveName = this.ctx.drizzle
+            .select({ id: pmoProjects.id })
+            .from(pmoProjects)
+            .where(sql `LOWER(${pmoProjects.name}) = LOWER(${identifier})`)
+            .get();
         if (caseInsensitiveName)
             return caseInsensitiveName.id;
         // 5. Slugified name match - check if identifier is a slug of any project name
-        // Get all projects and compare slugified names
-        const allProjects = this.ctx.db.prepare(`
-      SELECT id, name FROM ${T.projects}
-    `).all();
+        const allProjects = this.ctx.drizzle
+            .select({ id: pmoProjects.id, name: pmoProjects.name })
+            .from(pmoProjects)
+            .all();
         const identifierLower = identifier.toLowerCase();
         for (const project of allProjects) {
             const projectSlug = slugify(project.name);
@@ -72,12 +82,27 @@ export class ProjectStorage {
      */
     async init(projectId, config) {
         const projectName = config.name || 'Project Board';
-        const now = Date.now();
+        const now = String(Date.now());
         // Create or update project with default workflow
-        this.ctx.db.prepare(`
-      INSERT OR REPLACE INTO ${T.projects} (id, name, template, workflow_id, updated_at)
-      VALUES (?, ?, ?, 'default', ?)
-    `).run(projectId, projectName, 'kanban', now);
+        this.ctx.drizzle
+            .insert(pmoProjects)
+            .values({
+            id: projectId,
+            name: projectName,
+            template: 'kanban',
+            workflowId: 'default',
+            updatedAt: now,
+        })
+            .onConflictDoUpdate({
+            target: pmoProjects.id,
+            set: {
+                name: projectName,
+                template: 'kanban',
+                workflowId: 'default',
+                updatedAt: now,
+            },
+        })
+            .run();
         return this.getBoard(projectId);
     }
     /**
@@ -94,19 +119,27 @@ export class ProjectStorage {
             throw new PMOError('NOT_FOUND', `Project not found: ${projectIdOrName}. Run init() first.`);
         }
         // Get project metadata with workflow using resolved ID
-        const projectRow = this.ctx.db.prepare(`
-      SELECT id, name, workflow_id, updated_at FROM ${T.projects} WHERE id = ?
-    `).get(resolvedId);
+        const projectRow = this.ctx.drizzle
+            .select({
+            id: pmoProjects.id,
+            name: pmoProjects.name,
+            workflowId: pmoProjects.workflowId,
+            updatedAt: pmoProjects.updatedAt,
+        })
+            .from(pmoProjects)
+            .where(eq(pmoProjects.id, resolvedId))
+            .get();
         if (!projectRow) {
             throw new PMOError('NOT_FOUND', `Project not found: ${projectIdOrName}. Run init() first.`);
         }
         // Get workflow statuses as columns
-        const workflowId = projectRow.workflow_id || 'default';
-        const statusRows = this.ctx.db.prepare(`
-      SELECT * FROM ${T.workflow_statuses}
-      WHERE workflow_id = ?
-      ORDER BY position
-    `).all(workflowId);
+        const workflowId = projectRow.workflowId || 'default';
+        const statusRows = this.ctx.drizzle
+            .select()
+            .from(pmoWorkflowStatuses)
+            .where(eq(pmoWorkflowStatuses.workflowId, workflowId))
+            .orderBy(asc(pmoWorkflowStatuses.position))
+            .all();
         // Build columns from statuses, with tickets sorted by priority then created_at
         const columns = await Promise.all(statusRows.map(async (status) => ({
             id: status.id,
@@ -119,7 +152,7 @@ export class ProjectStorage {
             id: projectRow.id,
             name: projectRow.name,
             columns,
-            updatedAt: new Date(projectRow.updated_at),
+            updatedAt: new Date(projectRow.updatedAt),
         };
     }
     /**
@@ -138,17 +171,38 @@ export class ProjectStorage {
         const workflowId = project.template || 'default';
         const now = Date.now();
         // Try to find a workflow with matching ID
-        const workflow = this.ctx.db.prepare(`
-      SELECT id FROM ${T.workflows} WHERE id = ?
-    `).get(workflowId);
+        const workflow = this.ctx.drizzle
+            .select({ id: pmoWorkflows.id })
+            .from(pmoWorkflows)
+            .where(eq(pmoWorkflows.id, workflowId))
+            .get();
         // Use the requested workflow if it exists, otherwise fall back to default
         const finalWorkflowId = workflow ? workflowId : 'default';
         // Insert project with workflow
         try {
-            this.ctx.db.prepare(`
-        INSERT OR REPLACE INTO ${T.projects} (id, name, template, description, workflow_id, created_at, updated_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?)
-      `).run(id, project.name, workflowId, project.description || null, finalWorkflowId, now, now);
+            this.ctx.drizzle
+                .insert(pmoProjects)
+                .values({
+                id,
+                name: project.name,
+                template: workflowId,
+                description: project.description || null,
+                workflowId: finalWorkflowId,
+                createdAt: String(now),
+                updatedAt: String(now),
+            })
+                .onConflictDoUpdate({
+                target: pmoProjects.id,
+                set: {
+                    name: project.name,
+                    template: workflowId,
+                    description: project.description || null,
+                    workflowId: finalWorkflowId,
+                    createdAt: String(now),
+                    updatedAt: String(now),
+                },
+            })
+                .run();
         }
         catch (err) {
             wrapSqliteError('Project', 'create', err);
@@ -164,19 +218,29 @@ export class ProjectStorage {
         if (!resolvedId) {
             return null;
         }
-        const projectRow = this.ctx.db.prepare(`
-      SELECT id, name, template, description, workflow_id, updated_at FROM ${T.projects} WHERE id = ?
-    `).get(resolvedId);
+        const projectRow = this.ctx.drizzle
+            .select({
+            id: pmoProjects.id,
+            name: pmoProjects.name,
+            template: pmoProjects.template,
+            description: pmoProjects.description,
+            workflowId: pmoProjects.workflowId,
+            updatedAt: pmoProjects.updatedAt,
+        })
+            .from(pmoProjects)
+            .where(eq(pmoProjects.id, resolvedId))
+            .get();
         if (!projectRow) {
             return null;
         }
         // Get workflow statuses as columns
-        const workflowId = projectRow.workflow_id || 'default';
-        const statusRows = this.ctx.db.prepare(`
-      SELECT * FROM ${T.workflow_statuses}
-      WHERE workflow_id = ?
-      ORDER BY position
-    `).all(workflowId);
+        const workflowId = projectRow.workflowId || 'default';
+        const statusRows = this.ctx.drizzle
+            .select()
+            .from(pmoWorkflowStatuses)
+            .where(eq(pmoWorkflowStatuses.workflowId, workflowId))
+            .orderBy(asc(pmoWorkflowStatuses.position))
+            .all();
         const columns = await Promise.all(statusRows.map(async (status) => ({
             id: status.id,
             name: status.name,
@@ -188,7 +252,7 @@ export class ProjectStorage {
             id: projectRow.id,
             name: projectRow.name,
             columns,
-            updatedAt: new Date(projectRow.updated_at),
+            updatedAt: new Date(projectRow.updatedAt),
         };
     }
     /**
@@ -196,34 +260,60 @@ export class ProjectStorage {
      * Tickets are sorted by position (force-ranked) then created_at as tiebreaker.
      */
     async getTicketsForStatus(statusId, projectId) {
-        const ticketRows = this.ctx.db.prepare(`
-      SELECT t.*,
-             ws.name as status_name,
-             ws.category as status_category
-      FROM ${T.tickets} t
-      LEFT JOIN ${T.workflow_statuses} ws ON t.status_id = ws.id
-      WHERE t.status_id = ? AND t.project_id = ?
-      ORDER BY t.position ASC, t.created_at ASC
-    `).all(statusId, projectId);
-        return Promise.all(ticketRows.map((row) => rowToTicket(this.ctx.db, row)));
+        const ticketRows = this.ctx.drizzle
+            .select({
+            id: pmoTickets.id,
+            project_id: pmoTickets.projectId,
+            title: pmoTickets.title,
+            description: pmoTickets.description,
+            priority: pmoTickets.priority,
+            category: pmoTickets.category,
+            status_id: pmoTickets.statusId,
+            owner: pmoTickets.owner,
+            assignee: pmoTickets.assignee,
+            branch: pmoTickets.branch,
+            spec_id: pmoTickets.specId,
+            epic_id: pmoTickets.epicId,
+            labels: pmoTickets.labels,
+            position: pmoTickets.position,
+            created_at: pmoTickets.createdAt,
+            updated_at: pmoTickets.updatedAt,
+            last_synced_from_spec: pmoTickets.lastSyncedFromSpec,
+            last_synced_from_board: pmoTickets.lastSyncedFromBoard,
+            column_id: sql `NULL`,
+            column_name: sql `NULL`,
+            project_name: sql `NULL`,
+        })
+            .from(pmoTickets)
+            .leftJoin(pmoWorkflowStatuses, eq(pmoTickets.statusId, pmoWorkflowStatuses.id))
+            .where(and(eq(pmoTickets.statusId, statusId), eq(pmoTickets.projectId, projectId)))
+            .orderBy(asc(pmoTickets.position), asc(pmoTickets.createdAt))
+            .all();
+        return Promise.all(ticketRows.map((row) => rowToTicket(this.ctx.drizzle, row)));
     }
     /**
      * List project summaries.
      */
     async listProjectSummaries() {
-        const projects = this.ctx.db.prepare(`
-      SELECT p.*, COUNT(t.id) as ticket_count
-      FROM ${T.projects} p
-      LEFT JOIN ${T.tickets} t ON p.id = t.project_id
-      GROUP BY p.id
-      ORDER BY p.created_at
-    `).all();
+        const projects = this.ctx.drizzle
+            .select({
+            id: pmoProjects.id,
+            name: pmoProjects.name,
+            template: pmoProjects.template,
+            description: pmoProjects.description,
+            ticketCount: count(pmoTickets.id),
+        })
+            .from(pmoProjects)
+            .leftJoin(pmoTickets, eq(pmoProjects.id, pmoTickets.projectId))
+            .groupBy(pmoProjects.id)
+            .orderBy(asc(pmoProjects.createdAt))
+            .all();
         return projects.map((p) => ({
             id: p.id,
             name: p.name,
             template: p.template,
             description: p.description,
-            ticketCount: p.ticket_count,
+            ticketCount: p.ticketCount,
         }));
     }
     /**
@@ -239,7 +329,10 @@ export class ProjectStorage {
             throw new PMOError('INVALID', 'Cannot delete the default project');
         }
         try {
-            const result = this.ctx.db.prepare(`DELETE FROM ${T.projects} WHERE id = ?`).run(resolvedId);
+            const result = this.ctx.drizzle
+                .delete(pmoProjects)
+                .where(eq(pmoProjects.id, resolvedId))
+                .run();
             if (result.changes === 0) {
                 throw new PMOError('NOT_FOUND', `Project not found: ${projectIdOrName}`);
             }
@@ -259,7 +352,11 @@ export class ProjectStorage {
         const resolvedId = this.resolveProjectId(idOrName);
         if (!resolvedId)
             return null;
-        const row = this.ctx.db.prepare(`SELECT * FROM ${T.projects} WHERE id = ?`).get(resolvedId);
+        const row = this.ctx.drizzle
+            .select()
+            .from(pmoProjects)
+            .where(eq(pmoProjects.id, resolvedId))
+            .get();
         if (!row)
             return null;
         return this.rowToProject(row);
@@ -274,68 +371,59 @@ export class ProjectStorage {
         }
         // Use the resolved ID for the update
         const resolvedId = existing.id;
-        const updates = ['updated_at = ?'];
-        const params = [Date.now()];
-        if (changes.name !== undefined) {
-            updates.push('name = ?');
-            params.push(changes.name);
-        }
-        if (changes.description !== undefined) {
-            updates.push('description = ?');
-            params.push(changes.description || null);
-        }
-        if (changes.status !== undefined) {
-            updates.push('status = ?');
-            params.push(changes.status);
-        }
-        if (changes.phaseId !== undefined) {
-            updates.push('phase_id = ?');
-            params.push(changes.phaseId || null);
-        }
-        if (changes.workflowId !== undefined) {
-            updates.push('workflow_id = ?');
-            params.push(changes.workflowId || null);
-        }
-        if (changes.isArchived !== undefined) {
-            updates.push('is_archived = ?');
-            params.push(changes.isArchived ? 1 : 0);
-        }
+        const updates = {
+            updatedAt: String(Date.now()),
+        };
+        if (changes.name !== undefined)
+            updates.name = changes.name;
+        if (changes.description !== undefined)
+            updates.description = changes.description || null;
+        if (changes.status !== undefined)
+            updates.status = changes.status;
+        if (changes.phaseId !== undefined)
+            updates.phaseId = changes.phaseId || null;
+        if (changes.workflowId !== undefined)
+            updates.workflowId = changes.workflowId || null;
+        if (changes.isArchived !== undefined)
+            updates.isArchived = changes.isArchived;
         if (changes.targetDate !== undefined) {
-            updates.push('target_date = ?');
-            params.push(changes.targetDate ? changes.targetDate.toISOString() : null);
+            updates.targetDate = changes.targetDate ? changes.targetDate.toISOString() : null;
         }
-        params.push(resolvedId);
-        this.ctx.db.prepare(`UPDATE ${T.projects} SET ${updates.join(', ')} WHERE id = ?`).run(...params);
+        this.ctx.drizzle
+            .update(pmoProjects)
+            .set(updates)
+            .where(eq(pmoProjects.id, resolvedId))
+            .run();
         return (await this.getProject(resolvedId));
     }
     /**
      * List projects with optional filter.
      */
     async listProjects(filter) {
-        let sql = `SELECT * FROM ${T.projects}`;
+        let query = this.ctx.drizzle
+            .select()
+            .from(pmoProjects)
+            .$dynamic();
         const conditions = [];
-        const params = [];
         // Filter by archived status if explicitly specified
         if (filter?.isArchived === true) {
-            conditions.push('is_archived = 1');
+            conditions.push(eq(pmoProjects.isArchived, true));
         }
         else if (filter?.isArchived === false) {
-            conditions.push('is_archived = 0');
+            conditions.push(eq(pmoProjects.isArchived, false));
         }
         if (filter?.phaseId) {
-            conditions.push('phase_id = ?');
-            params.push(filter.phaseId);
+            conditions.push(eq(pmoProjects.phaseId, filter.phaseId));
         }
         if (filter?.search) {
-            conditions.push('(name LIKE ? OR description LIKE ?)');
-            const searchTerm = `%${filter.search}%`;
-            params.push(searchTerm, searchTerm);
+            conditions.push(or(like(pmoProjects.name, `%${filter.search}%`), like(pmoProjects.description, `%${filter.search}%`)));
         }
         if (conditions.length > 0) {
-            sql += ' WHERE ' + conditions.join(' AND ');
+            query = query.where(and(...conditions));
         }
-        sql += ' ORDER BY updated_at DESC';
-        const rows = this.ctx.db.prepare(sql).all(...params);
+        const rows = query
+            .orderBy(desc(pmoProjects.updatedAt))
+            .all();
         return rows.map((row) => this.rowToProject(row));
     }
     /**
@@ -371,13 +459,13 @@ export class ProjectStorage {
             template: row.template || undefined,
             description: row.description || undefined,
             status: (row.status || 'active'),
-            phaseId: row.phase_id || undefined,
-            workflowId: row.workflow_id || undefined,
-            isArchived: row.is_archived === 1,
-            targetDate: row.target_date ? new Date(row.target_date) : undefined,
-            initiativeId: row.initiative_id || undefined,
-            createdAt: new Date(row.created_at),
-            updatedAt: new Date(row.updated_at),
+            phaseId: row.phaseId || undefined,
+            workflowId: row.workflowId || undefined,
+            isArchived: row.isArchived ?? false,
+            targetDate: row.targetDate ? new Date(row.targetDate) : undefined,
+            initiativeId: row.initiativeId || undefined,
+            createdAt: new Date(row.createdAt || Date.now()),
+            updatedAt: new Date(row.updatedAt || Date.now()),
         };
     }
 }

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

@@ -1,5 +1,7 @@
 /**
  * Spec operations for PMO.
+ *
+ * This module uses Drizzle ORM for type-safe database queries.
  */
 import { Project, Spec, SpecFilter, Ticket } from '../types.js';
 import { StorageContext } from './types.js';