@compilr-dev/sdk 0.2.3 → 0.2.4

package/dist/platform/sqlite/work-item-repository.js

@@ -0,0 +1,350 @@
+/**
+ * SQLite Work Item Repository — Concrete implementation of IWorkItemRepository.
+ */
+function recordToWorkItem(record) {
+    return {
+        id: record.id,
+        projectId: record.project_id,
+        itemNumber: record.item_number,
+        itemId: record.item_id,
+        type: record.type,
+        status: record.status,
+        priority: record.priority,
+        guidedStep: record.guided_step,
+        owner: record.owner,
+        title: record.title,
+        description: record.description,
+        estimatedEffort: record.estimated_effort,
+        actualMinutes: record.actual_minutes,
+        completedAt: record.completed_at ? new Date(record.completed_at) : null,
+        completedBy: record.completed_by,
+        commitHash: record.commit_hash,
+        createdAt: new Date(record.created_at),
+        updatedAt: new Date(record.updated_at),
+    };
+}
+function getTypePrefix(type) {
+    const prefixes = {
+        feature: 'REQ',
+        bug: 'BUG',
+        'tech-debt': 'TEC',
+        chore: 'CHR',
+    };
+    return prefixes[type];
+}
+const PRIORITY_ORDER = `
+  CASE priority
+    WHEN 'critical' THEN 1
+    WHEN 'high' THEN 2
+    WHEN 'medium' THEN 3
+    WHEN 'low' THEN 4
+    ELSE 5
+  END
+`;
+export class SQLiteWorkItemRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    create(input) {
+        const now = new Date().toISOString();
+        const maxResult = this.db
+            .prepare('SELECT MAX(item_number) as max_num FROM work_items WHERE project_id = ?')
+            .get(input.project_id);
+        const itemNumber = (maxResult.max_num ?? 0) + 1;
+        const itemId = `${getTypePrefix(input.type)}-${String(itemNumber).padStart(3, '0')}`;
+        const result = this.db
+            .prepare(`INSERT INTO work_items (
+        project_id, item_number, item_id, type, status, priority,
+        owner, title, description, estimated_effort,
+        created_at, updated_at
+      ) VALUES (
+        @project_id, @item_number, @item_id, @type, @status, @priority,
+        @owner, @title, @description, @estimated_effort,
+        @created_at, @updated_at
+      )`)
+            .run({
+            project_id: input.project_id,
+            item_number: itemNumber,
+            item_id: itemId,
+            type: input.type,
+            status: 'backlog',
+            priority: input.priority ?? 'medium',
+            owner: input.owner ?? null,
+            title: input.title,
+            description: input.description ?? null,
+            estimated_effort: input.estimated_effort ?? null,
+            created_at: now,
+            updated_at: now,
+        });
+        const record = this.db
+            .prepare('SELECT * FROM work_items WHERE id = ?')
+            .get(Number(result.lastInsertRowid));
+        if (!record)
+            throw new Error('Failed to create work item');
+        return Promise.resolve(recordToWorkItem(record));
+    }
+    getById(id) {
+        const record = this.db.prepare('SELECT * FROM work_items WHERE id = ?').get(id);
+        return Promise.resolve(record ? recordToWorkItem(record) : null);
+    }
+    getByItemId(projectId, itemId) {
+        const record = this.db
+            .prepare('SELECT * FROM work_items WHERE project_id = ? AND item_id = ?')
+            .get(projectId, itemId);
+        return Promise.resolve(record ? recordToWorkItem(record) : null);
+    }
+    query(input) {
+        const conditions = [];
+        const params = {};
+        if (input.project_id) {
+            conditions.push('project_id = @project_id');
+            params.project_id = input.project_id;
+        }
+        if (input.status && input.status !== 'all') {
+            conditions.push('status = @status');
+            params.status = input.status;
+        }
+        if (input.type && input.type !== 'all') {
+            conditions.push('type = @type');
+            params.type = input.type;
+        }
+        if (input.priority && input.priority !== 'all') {
+            conditions.push('priority = @priority');
+            params.priority = input.priority;
+        }
+        if (input.owner && input.owner !== 'all') {
+            if (input.owner === 'unassigned') {
+                conditions.push('owner IS NULL');
+            }
+            else {
+                conditions.push('owner = @owner');
+                params.owner = input.owner;
+            }
+        }
+        if (input.search) {
+            conditions.push('(title LIKE @search OR description LIKE @search)');
+            params.search = `%${input.search}%`;
+        }
+        const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+        const countResult = this.db
+            .prepare(`SELECT COUNT(*) as count FROM work_items ${whereClause}`)
+            .get(params);
+        const limit = input.limit ?? 50;
+        const offset = input.offset ?? 0;
+        const query = `
+      SELECT * FROM work_items ${whereClause}
+      ORDER BY
+        CASE status WHEN 'in_progress' THEN 0 ELSE 1 END,
+        ${PRIORITY_ORDER},
+        created_at ASC
+      LIMIT @limit OFFSET @offset
+    `;
+        params.limit = limit;
+        params.offset = offset;
+        const records = this.db.prepare(query).all(params);
+        return Promise.resolve({
+            items: records.map(recordToWorkItem),
+            total: countResult.count,
+            hasMore: offset + records.length < countResult.count,
+        });
+    }
+    getNext(projectId, type) {
+        let query = `SELECT * FROM work_items WHERE project_id = ? AND status = 'backlog'`;
+        const params = [projectId];
+        if (type) {
+            query += ' AND type = ?';
+            params.push(type);
+        }
+        query += ` ORDER BY ${PRIORITY_ORDER}, created_at ASC LIMIT 1`;
+        const record = this.db.prepare(query).get(...params);
+        return Promise.resolve(record ? recordToWorkItem(record) : null);
+    }
+    update(id, input) {
+        const oldRecord = this.db.prepare('SELECT * FROM work_items WHERE id = ?').get(id);
+        if (!oldRecord)
+            return Promise.resolve(null);
+        const oldItem = recordToWorkItem(oldRecord);
+        const updates = [];
+        const params = { id };
+        if (input.type !== undefined) {
+            updates.push('type = @type');
+            params.type = input.type;
+        }
+        if (input.status !== undefined) {
+            updates.push('status = @status');
+            params.status = input.status;
+            if (input.status === 'completed' && oldItem.status !== 'completed') {
+                updates.push('completed_at = @completed_at');
+                params.completed_at = new Date().toISOString();
+            }
+        }
+        if (input.priority !== undefined) {
+            updates.push('priority = @priority');
+            params.priority = input.priority;
+        }
+        if (input.guided_step !== undefined) {
+            updates.push('guided_step = @guided_step');
+            params.guided_step = input.guided_step;
+        }
+        if (input.owner !== undefined) {
+            updates.push('owner = @owner');
+            params.owner = input.owner;
+        }
+        if (input.title !== undefined) {
+            updates.push('title = @title');
+            params.title = input.title;
+        }
+        if (input.description !== undefined) {
+            updates.push('description = @description');
+            params.description = input.description;
+        }
+        if (input.estimated_effort !== undefined) {
+            updates.push('estimated_effort = @estimated_effort');
+            params.estimated_effort = input.estimated_effort;
+        }
+        if (input.actual_minutes !== undefined) {
+            updates.push('actual_minutes = @actual_minutes');
+            params.actual_minutes = input.actual_minutes;
+        }
+        if (input.commit_hash !== undefined) {
+            updates.push('commit_hash = @commit_hash');
+            params.commit_hash = input.commit_hash;
+        }
+        if (updates.length === 0)
+            return Promise.resolve(oldItem);
+        updates.push('updated_at = @updated_at');
+        params.updated_at = new Date().toISOString();
+        this.db.prepare(`UPDATE work_items SET ${updates.join(', ')} WHERE id = @id`).run(params);
+        // Record history
+        this.recordHistory(id, oldItem.projectId, input, oldItem);
+        const record = this.db.prepare('SELECT * FROM work_items WHERE id = ?').get(id);
+        return Promise.resolve(record ? recordToWorkItem(record) : null);
+    }
+    delete(id) {
+        const result = this.db.prepare('DELETE FROM work_items WHERE id = ?').run(id);
+        return Promise.resolve(result.changes > 0);
+    }
+    getByOwner(projectId, owner, status) {
+        let query = 'SELECT * FROM work_items WHERE project_id = ?';
+        const params = [projectId];
+        if (owner === 'unassigned') {
+            query += ' AND owner IS NULL';
+        }
+        else {
+            query += ' AND owner = ?';
+            params.push(owner);
+        }
+        if (status) {
+            query += ' AND status = ?';
+            params.push(status);
+        }
+        query += ' ORDER BY priority, created_at ASC';
+        const records = this.db.prepare(query).all(...params);
+        return Promise.resolve(records.map(recordToWorkItem));
+    }
+    getOwnerCounts(projectId) {
+        const results = this.db
+            .prepare(`SELECT COALESCE(owner, 'unassigned') as owner, COUNT(*) as count
+       FROM work_items
+       WHERE project_id = ? AND status != 'completed' AND status != 'skipped'
+       GROUP BY owner`)
+            .all(projectId);
+        const counts = {};
+        for (const row of results) {
+            counts[row.owner] = row.count;
+        }
+        return Promise.resolve(counts);
+    }
+    getStatusCounts(projectId) {
+        const results = this.db
+            .prepare('SELECT status, COUNT(*) as count FROM work_items WHERE project_id = ? GROUP BY status')
+            .all(projectId);
+        const counts = {
+            backlog: 0,
+            in_progress: 0,
+            completed: 0,
+            skipped: 0,
+        };
+        for (const row of results) {
+            counts[row.status] = row.count;
+        }
+        return Promise.resolve(counts);
+    }
+    getHistory(workItemId) {
+        const records = this.db
+            .prepare('SELECT * FROM work_item_history WHERE work_item_id = ? ORDER BY changed_at DESC')
+            .all(workItemId);
+        return Promise.resolve(records.map((r) => ({
+            action: r.action,
+            oldValue: r.old_value,
+            newValue: r.new_value,
+            notes: r.notes,
+            changedBy: r.changed_by,
+            changedAt: new Date(r.changed_at),
+        })));
+    }
+    bulkCreate(projectId, items) {
+        const now = new Date().toISOString();
+        const maxResult = this.db
+            .prepare('SELECT MAX(item_number) as max_num FROM work_items WHERE project_id = ?')
+            .get(projectId);
+        let itemNumber = (maxResult.max_num ?? 0) + 1;
+        const createdIds = [];
+        const insertStmt = this.db.prepare(`
+      INSERT INTO work_items (
+        project_id, item_number, item_id, type, status, priority,
+        owner, title, description, created_at, updated_at
+      ) VALUES (
+        @project_id, @item_number, @item_id, @type, @status, @priority,
+        @owner, @title, @description, @created_at, @updated_at
+      )
+    `);
+        const insertAll = this.db.transaction(() => {
+            for (const item of items) {
+                const itemId = `${getTypePrefix(item.type)}-${String(itemNumber).padStart(3, '0')}`;
+                const result = insertStmt.run({
+                    project_id: projectId,
+                    item_number: itemNumber,
+                    item_id: itemId,
+                    type: item.type,
+                    status: 'backlog',
+                    priority: item.priority ?? 'medium',
+                    owner: item.owner ?? null,
+                    title: item.title,
+                    description: item.description ?? null,
+                    created_at: now,
+                    updated_at: now,
+                });
+                createdIds.push(Number(result.lastInsertRowid));
+                itemNumber++;
+            }
+        });
+        insertAll();
+        const results = createdIds
+            .map((rowId) => {
+            const record = this.db.prepare('SELECT * FROM work_items WHERE id = ?').get(rowId);
+            return record ? recordToWorkItem(record) : null;
+        })
+            .filter((item) => item !== null);
+        return Promise.resolve(results);
+    }
+    // Internal: record history entries
+    recordHistory(workItemId, projectId, changes, oldItem) {
+        const now = new Date().toISOString();
+        const stmt = this.db.prepare(`INSERT INTO work_item_history (work_item_id, project_id, action, old_value, new_value, changed_by, changed_at)
+       VALUES (?, ?, ?, ?, ?, 'agent', ?)`);
+        if (changes.status && changes.status !== oldItem.status) {
+            stmt.run(workItemId, projectId, 'status_change', oldItem.status, changes.status, now);
+        }
+        if (changes.priority && changes.priority !== oldItem.priority) {
+            stmt.run(workItemId, projectId, 'priority_change', oldItem.priority, changes.priority, now);
+        }
+        if (changes.guided_step !== undefined && changes.guided_step !== oldItem.guidedStep) {
+            stmt.run(workItemId, projectId, 'step_advance', oldItem.guidedStep ?? 'none', changes.guided_step ?? 'none', now);
+        }
+        if (changes.owner !== undefined && changes.owner !== oldItem.owner) {
+            stmt.run(workItemId, projectId, 'owner_change', oldItem.owner ?? 'unassigned', changes.owner ?? 'unassigned', now);
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@compilr-dev/sdk",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "Universal agent runtime for building AI-powered applications",
   "type": "module",
   "main": "dist/index.js",
@@ -56,15 +56,22 @@
     "ajv": "^6.14.0"
   },
   "peerDependencies": {
-    "@compilr-dev/agents": "^0.3.16",
-    "@compilr-dev/agents-coding": "^1.0.2"
+    "@compilr-dev/agents": "^0.3.25",
+    "@compilr-dev/agents-coding": "^1.0.2",
+    "better-sqlite3": "^11.0.0 || ^12.0.0"
+  },
+  "peerDependenciesMeta": {
+    "better-sqlite3": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@anthropic-ai/sdk": "^0.78.0",
-    "@compilr-dev/agents": "^0.3.16",
+    "@compilr-dev/agents": "^0.3.25",
     "@compilr-dev/agents-coding": "^1.0.2",
     "@eslint/js": "^9.39.1",
     "@opentelemetry/api": "^1.9.0",
+    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^25.2.3",
     "@vitest/coverage-v8": "^4.0.18",
     "eslint": "^9.39.1",