@compilr-dev/sdk 0.2.2 → 0.2.4

package/dist/platform/sqlite/schema.js

@@ -0,0 +1,159 @@
+/**
+ * Database Schema for compilr-dev workflow system
+ *
+ * Shared between CLI and Desktop — both access ~/.compilr-dev/projects.db
+ * Schema version must be kept in sync across all consumers.
+ */
+export const SCHEMA_VERSION = 6;
+export const SCHEMA_SQL = `
+-- Schema version tracking
+CREATE TABLE IF NOT EXISTS schema_version (
+  version INTEGER PRIMARY KEY,
+  applied_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Projects table
+CREATE TABLE IF NOT EXISTS projects (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT UNIQUE NOT NULL,
+  display_name TEXT NOT NULL,
+  description TEXT,
+  type TEXT DEFAULT 'general',
+  status TEXT DEFAULT 'active',
+  path TEXT NOT NULL,
+  docs_path TEXT,
+  repo_pattern TEXT DEFAULT 'single',
+  language TEXT,
+  framework TEXT,
+  package_manager TEXT,
+  runtime_version TEXT,
+  commands TEXT,
+  git_remote TEXT,
+  git_branch TEXT DEFAULT 'main',
+  workflow_mode TEXT DEFAULT 'flexible',
+  lifecycle_state TEXT DEFAULT 'setup',
+  current_item_id TEXT,
+  last_context TEXT,
+  metadata TEXT,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  last_activity_at DATETIME
+);
+
+-- Work items (backlog items, tasks, bugs)
+CREATE TABLE IF NOT EXISTS work_items (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  project_id INTEGER NOT NULL,
+  item_number INTEGER NOT NULL,
+  item_id TEXT NOT NULL,
+  type TEXT NOT NULL,
+  status TEXT DEFAULT 'backlog',
+  priority TEXT DEFAULT 'medium',
+  guided_step TEXT,
+  owner TEXT,
+  title TEXT NOT NULL,
+  description TEXT,
+  estimated_effort TEXT,
+  actual_minutes INTEGER,
+  completed_at DATETIME,
+  completed_by TEXT,
+  commit_hash TEXT,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,
+  UNIQUE (project_id, item_id)
+);
+
+-- Project documents (PRD, architecture, plans, etc.)
+CREATE TABLE IF NOT EXISTS project_documents (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  project_id INTEGER NOT NULL,
+  doc_type TEXT NOT NULL,
+  title TEXT NOT NULL,
+  content TEXT NOT NULL,
+  status TEXT,
+  work_item_id INTEGER,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,
+  FOREIGN KEY (work_item_id) REFERENCES work_items(id) ON DELETE SET NULL
+);
+
+-- Work item history (audit trail)
+CREATE TABLE IF NOT EXISTS work_item_history (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  work_item_id INTEGER NOT NULL,
+  project_id INTEGER NOT NULL,
+  action TEXT NOT NULL,
+  old_value TEXT,
+  new_value TEXT,
+  notes TEXT,
+  changed_by TEXT,
+  changed_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  FOREIGN KEY (work_item_id) REFERENCES work_items(id) ON DELETE CASCADE,
+  FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+);
+
+-- Indexes
+CREATE INDEX IF NOT EXISTS idx_projects_path ON projects(path);
+CREATE INDEX IF NOT EXISTS idx_projects_docs_path ON projects(docs_path);
+CREATE INDEX IF NOT EXISTS idx_projects_status ON projects(status);
+CREATE INDEX IF NOT EXISTS idx_work_items_project ON work_items(project_id);
+CREATE INDEX IF NOT EXISTS idx_work_items_status ON work_items(status);
+CREATE INDEX IF NOT EXISTS idx_work_items_priority ON work_items(priority);
+CREATE INDEX IF NOT EXISTS idx_work_items_owner ON work_items(owner);
+CREATE INDEX IF NOT EXISTS idx_project_documents_project ON project_documents(project_id);
+CREATE INDEX IF NOT EXISTS idx_project_documents_type ON project_documents(doc_type);
+CREATE INDEX IF NOT EXISTS idx_project_documents_status ON project_documents(status);
+CREATE INDEX IF NOT EXISTS idx_project_documents_work_item ON project_documents(work_item_id);
+CREATE INDEX IF NOT EXISTS idx_work_item_history_item ON work_item_history(work_item_id);
+
+-- Terminal sessions (multi-terminal awareness)
+CREATE TABLE IF NOT EXISTS terminal_sessions (
+  id TEXT PRIMARY KEY,
+  project_id INTEGER,
+  pid INTEGER NOT NULL,
+  tty_path TEXT,
+  label TEXT,
+  started_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  last_heartbeat DATETIME DEFAULT CURRENT_TIMESTAMP,
+  active_agent TEXT DEFAULT 'default',
+  agents_json TEXT DEFAULT '[]',
+  status TEXT DEFAULT 'active',
+  FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE SET NULL
+);
+CREATE INDEX IF NOT EXISTS idx_terminal_sessions_project ON terminal_sessions(project_id);
+CREATE INDEX IF NOT EXISTS idx_terminal_sessions_status ON terminal_sessions(status);
+
+-- File locks (multi-terminal file lock awareness)
+CREATE TABLE IF NOT EXISTS file_locks (
+  path TEXT NOT NULL,
+  project_id INTEGER NOT NULL,
+  session_id TEXT NOT NULL,
+  agent_id TEXT NOT NULL,
+  locked_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  PRIMARY KEY (path, project_id),
+  FOREIGN KEY (session_id) REFERENCES terminal_sessions(id) ON DELETE CASCADE,
+  FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+);
+CREATE INDEX IF NOT EXISTS idx_file_locks_session ON file_locks(session_id);
+
+-- Session notifications (cross-session notifications)
+CREATE TABLE IF NOT EXISTS session_notifications (
+  id TEXT PRIMARY KEY,
+  project_id INTEGER NOT NULL,
+  from_session_id TEXT NOT NULL,
+  to_session_id TEXT,
+  type TEXT NOT NULL,
+  title TEXT NOT NULL,
+  message TEXT,
+  payload_json TEXT,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  read_at DATETIME,
+  FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,
+  FOREIGN KEY (from_session_id) REFERENCES terminal_sessions(id) ON DELETE CASCADE
+);
+CREATE INDEX IF NOT EXISTS idx_session_notifications_project ON session_notifications(project_id);
+CREATE INDEX IF NOT EXISTS idx_session_notifications_to_session ON session_notifications(to_session_id);
+CREATE INDEX IF NOT EXISTS idx_session_notifications_unread ON session_notifications(read_at);
+`;

package/dist/platform/sqlite/work-item-repository.d.ts

@@ -0,0 +1,23 @@
+/**
+ * SQLite Work Item Repository — Concrete implementation of IWorkItemRepository.
+ */
+import type Database from 'better-sqlite3';
+import type { IWorkItemRepository } from '../repositories.js';
+import type { WorkItem, WorkItemType, WorkItemStatus, HistoryEntry, CreateWorkItemInput, UpdateWorkItemInput, QueryWorkItemsInput, WorkItemQueryResult, BulkCreateItem } from '../types.js';
+export declare class SQLiteWorkItemRepository implements IWorkItemRepository {
+    private readonly db;
+    constructor(db: Database.Database);
+    create(input: CreateWorkItemInput): Promise<WorkItem>;
+    getById(id: number): Promise<WorkItem | null>;
+    getByItemId(projectId: number, itemId: string): Promise<WorkItem | null>;
+    query(input: QueryWorkItemsInput): Promise<WorkItemQueryResult>;
+    getNext(projectId: number, type?: WorkItemType): Promise<WorkItem | null>;
+    update(id: number, input: UpdateWorkItemInput): Promise<WorkItem | null>;
+    delete(id: number): Promise<boolean>;
+    getByOwner(projectId: number, owner: string, status?: WorkItemStatus): Promise<WorkItem[]>;
+    getOwnerCounts(projectId: number): Promise<Record<string, number>>;
+    getStatusCounts(projectId: number): Promise<Record<WorkItemStatus, number>>;
+    getHistory(workItemId: number): Promise<HistoryEntry[]>;
+    bulkCreate(projectId: number, items: BulkCreateItem[]): Promise<WorkItem[]>;
+    private recordHistory;
+}

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.2",
+  "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",