@compilr-dev/cli 0.4.0

package/dist/db/repositories/project-repository.js

@@ -0,0 +1,337 @@
+/**
+ * Project Repository
+ *
+ * Handles all database operations for projects.
+ */
+import { getDb } from '../index.js';
+/**
+ * Convert database record to Project object
+ */
+function recordToProject(record) {
+    return {
+        id: record.id,
+        name: record.name,
+        displayName: record.display_name,
+        description: record.description,
+        type: record.type,
+        status: record.status,
+        path: record.path,
+        docsPath: record.docs_path,
+        repoPattern: record.repo_pattern,
+        language: record.language,
+        framework: record.framework,
+        packageManager: record.package_manager,
+        runtimeVersion: record.runtime_version,
+        commands: record.commands ? JSON.parse(record.commands) : null,
+        gitRemote: record.git_remote,
+        gitBranch: record.git_branch,
+        workflowMode: record.workflow_mode,
+        lifecycleState: record.lifecycle_state,
+        currentItemId: record.current_item_id,
+        lastContext: record.last_context ? JSON.parse(record.last_context) : null,
+        metadata: record.metadata ? JSON.parse(record.metadata) : null,
+        createdAt: new Date(record.created_at),
+        updatedAt: new Date(record.updated_at),
+        lastActivityAt: record.last_activity_at
+            ? new Date(record.last_activity_at)
+            : null,
+    };
+}
+export const projectRepository = {
+    /**
+     * Create a new project
+     */
+    create(input) {
+        const db = getDb();
+        const now = new Date().toISOString();
+        const result = db
+            .prepare(`
+      INSERT INTO projects (
+        name, display_name, description, type, path, docs_path, repo_pattern,
+        language, framework, package_manager, runtime_version, commands,
+        git_remote, git_branch, workflow_mode, metadata,
+        created_at, updated_at, last_activity_at
+      ) VALUES (
+        @name, @display_name, @description, @type, @path, @docs_path, @repo_pattern,
+        @language, @framework, @package_manager, @runtime_version, @commands,
+        @git_remote, @git_branch, @workflow_mode, @metadata,
+        @created_at, @updated_at, @last_activity_at
+      )
+    `)
+            .run({
+            name: input.name,
+            display_name: input.display_name,
+            description: input.description ?? null,
+            type: input.type ?? 'general',
+            path: input.path,
+            docs_path: input.docs_path ?? null,
+            repo_pattern: input.repo_pattern ?? 'single',
+            language: input.language ?? null,
+            framework: input.framework ?? null,
+            package_manager: input.package_manager ?? null,
+            runtime_version: input.runtime_version ?? null,
+            commands: input.commands ? JSON.stringify(input.commands) : null,
+            git_remote: input.git_remote ?? null,
+            git_branch: input.git_branch ?? 'main',
+            workflow_mode: input.workflow_mode ?? 'flexible',
+            metadata: input.metadata ? JSON.stringify(input.metadata) : null,
+            created_at: now,
+            updated_at: now,
+            last_activity_at: now,
+        });
+        const project = this.getById(Number(result.lastInsertRowid));
+        if (!project)
+            throw new Error('Failed to create project');
+        return project;
+    },
+    /**
+     * Get project by ID
+     */
+    getById(id) {
+        const db = getDb();
+        const record = db
+            .prepare('SELECT * FROM projects WHERE id = ?')
+            .get(id);
+        return record ? recordToProject(record) : null;
+    },
+    /**
+     * Get project by name
+     */
+    getByName(name) {
+        const db = getDb();
+        const record = db
+            .prepare('SELECT * FROM projects WHERE name = ?')
+            .get(name);
+        return record ? recordToProject(record) : null;
+    },
+    /**
+     * Get project by path (code repo)
+     */
+    getByPath(projectPath) {
+        const db = getDb();
+        const record = db
+            .prepare('SELECT * FROM projects WHERE path = ?')
+            .get(projectPath);
+        return record ? recordToProject(record) : null;
+    },
+    /**
+     * Get project by docs path (for two-repo pattern)
+     */
+    getByDocsPath(docsPath) {
+        const db = getDb();
+        const record = db
+            .prepare('SELECT * FROM projects WHERE docs_path = ?')
+            .get(docsPath);
+        return record ? recordToProject(record) : null;
+    },
+    /**
+     * Find project by path (checks both path and docs_path, including parent directories)
+     */
+    findByPath(searchPath) {
+        // First try exact match on path
+        let project = this.getByPath(searchPath);
+        if (project)
+            return project;
+        // Try exact match on docs_path
+        project = this.getByDocsPath(searchPath);
+        if (project)
+            return project;
+        // Try parent directories
+        const parts = searchPath.split('/').filter(Boolean);
+        for (let i = parts.length - 1; i >= 0; i--) {
+            const parentPath = '/' + parts.slice(0, i).join('/');
+            if (!parentPath || parentPath === '/')
+                break;
+            project = this.getByPath(parentPath);
+            if (project)
+                return project;
+            project = this.getByDocsPath(parentPath);
+            if (project)
+                return project;
+        }
+        return null;
+    },
+    /**
+     * List projects with optional filters
+     */
+    list(options) {
+        const db = getDb();
+        const conditions = [];
+        const params = {};
+        if (options?.status && options.status !== 'all') {
+            conditions.push('status = @status');
+            params.status = options.status;
+        }
+        if (options?.type && options.type !== 'all') {
+            conditions.push('type = @type');
+            params.type = options.type;
+        }
+        const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+        // Get total count
+        const countResult = db
+            .prepare(`SELECT COUNT(*) as count FROM projects ${whereClause}`)
+            .get(params);
+        // Get projects with pagination
+        let query = `SELECT * FROM projects ${whereClause} ORDER BY last_activity_at DESC NULLS LAST, updated_at DESC`;
+        if (options?.limit) {
+            query += ` LIMIT @limit`;
+            params.limit = options.limit;
+        }
+        if (options?.offset) {
+            query += ` OFFSET @offset`;
+            params.offset = options.offset;
+        }
+        const records = db.prepare(query).all(params);
+        return {
+            projects: records.map(recordToProject),
+            total: countResult.count,
+        };
+    },
+    /**
+     * Update a project
+     */
+    update(id, input) {
+        const db = getDb();
+        const updates = [];
+        const params = { id };
+        // Build dynamic update query
+        if (input.display_name !== undefined) {
+            updates.push('display_name = @display_name');
+            params.display_name = input.display_name;
+        }
+        if (input.description !== undefined) {
+            updates.push('description = @description');
+            params.description = input.description;
+        }
+        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.docs_path !== undefined) {
+            updates.push('docs_path = @docs_path');
+            params.docs_path = input.docs_path;
+        }
+        if (input.repo_pattern !== undefined) {
+            updates.push('repo_pattern = @repo_pattern');
+            params.repo_pattern = input.repo_pattern;
+        }
+        if (input.language !== undefined) {
+            updates.push('language = @language');
+            params.language = input.language;
+        }
+        if (input.framework !== undefined) {
+            updates.push('framework = @framework');
+            params.framework = input.framework;
+        }
+        if (input.package_manager !== undefined) {
+            updates.push('package_manager = @package_manager');
+            params.package_manager = input.package_manager;
+        }
+        if (input.runtime_version !== undefined) {
+            updates.push('runtime_version = @runtime_version');
+            params.runtime_version = input.runtime_version;
+        }
+        if (input.commands !== undefined) {
+            updates.push('commands = @commands');
+            params.commands = JSON.stringify(input.commands);
+        }
+        if (input.git_remote !== undefined) {
+            updates.push('git_remote = @git_remote');
+            params.git_remote = input.git_remote;
+        }
+        if (input.git_branch !== undefined) {
+            updates.push('git_branch = @git_branch');
+            params.git_branch = input.git_branch;
+        }
+        if (input.workflow_mode !== undefined) {
+            updates.push('workflow_mode = @workflow_mode');
+            params.workflow_mode = input.workflow_mode;
+        }
+        if (input.lifecycle_state !== undefined) {
+            updates.push('lifecycle_state = @lifecycle_state');
+            params.lifecycle_state = input.lifecycle_state;
+        }
+        if (input.current_item_id !== undefined) {
+            updates.push('current_item_id = @current_item_id');
+            params.current_item_id = input.current_item_id;
+        }
+        if (input.last_context !== undefined) {
+            updates.push('last_context = @last_context');
+            params.last_context = JSON.stringify(input.last_context);
+        }
+        if (input.metadata !== undefined) {
+            updates.push('metadata = @metadata');
+            params.metadata = JSON.stringify(input.metadata);
+        }
+        if (updates.length === 0) {
+            return this.getById(id);
+        }
+        // Always update updated_at
+        updates.push('updated_at = @updated_at');
+        params.updated_at = new Date().toISOString();
+        const query = `UPDATE projects SET ${updates.join(', ')} WHERE id = @id`;
+        db.prepare(query).run(params);
+        return this.getById(id);
+    },
+    /**
+     * Update last activity timestamp
+     */
+    touch(id) {
+        const db = getDb();
+        const now = new Date().toISOString();
+        db.prepare('UPDATE projects SET last_activity_at = ?, updated_at = ? WHERE id = ?').run(now, now, id);
+    },
+    /**
+     * Delete a project (cascades to work_items, documents, history)
+     */
+    delete(id) {
+        const db = getDb();
+        const result = db.prepare('DELETE FROM projects WHERE id = ?').run(id);
+        return result.changes > 0;
+    },
+    /**
+     * Archive a project (set status to 'archived')
+     */
+    archive(id) {
+        return this.update(id, { status: 'archived' });
+    },
+    /**
+     * Check if a project name is available
+     */
+    isNameAvailable(name, excludeId) {
+        const db = getDb();
+        const query = excludeId
+            ? 'SELECT id FROM projects WHERE name = ? AND id != ?'
+            : 'SELECT id FROM projects WHERE name = ?';
+        const params = excludeId ? [name, excludeId] : [name];
+        const result = db.prepare(query).get(...params);
+        return !result;
+    },
+    /**
+     * Get project counts by status
+     */
+    getStatusCounts() {
+        const db = getDb();
+        const results = db
+            .prepare(`
+      SELECT status, COUNT(*) as count
+      FROM projects
+      GROUP BY status
+    `)
+            .all();
+        const counts = {
+            active: 0,
+            paused: 0,
+            completed: 0,
+            archived: 0,
+        };
+        for (const row of results) {
+            counts[row.status] = row.count;
+        }
+        return counts;
+    },
+};

package/dist/db/repositories/work-item-repository.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Work Item Repository
+ *
+ * Handles all database operations for work items (backlog items, tasks, bugs).
+ */
+import type { WorkItemType, WorkItemStatus, WorkItemPriority, GuidedStep } from '../schema.js';
+export interface CreateWorkItemInput {
+    project_id: number;
+    type: WorkItemType;
+    title: string;
+    description?: string;
+    priority?: WorkItemPriority;
+    estimated_effort?: 'low' | 'medium' | 'high';
+}
+export interface UpdateWorkItemInput {
+    type?: WorkItemType;
+    status?: WorkItemStatus;
+    priority?: WorkItemPriority;
+    guided_step?: GuidedStep | null;
+    title?: string;
+    description?: string;
+    estimated_effort?: 'low' | 'medium' | 'high';
+    actual_minutes?: number;
+    commit_hash?: string;
+}
+export interface QueryWorkItemsInput {
+    project_id?: number;
+    status?: WorkItemStatus | 'all';
+    type?: WorkItemType | 'all';
+    priority?: WorkItemPriority | 'all';
+    search?: string;
+    limit?: number;
+    offset?: number;
+}
+export interface WorkItem {
+    id: number;
+    projectId: number;
+    itemNumber: number;
+    itemId: string;
+    type: WorkItemType;
+    status: WorkItemStatus;
+    priority: WorkItemPriority;
+    guidedStep: GuidedStep | null;
+    title: string;
+    description: string | null;
+    estimatedEffort: string | null;
+    actualMinutes: number | null;
+    completedAt: Date | null;
+    completedBy: string | null;
+    commitHash: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare const workItemRepository: {
+    /**
+     * Create a new work item
+     */
+    create(input: CreateWorkItemInput): WorkItem;
+    /**
+     * Get work item by database ID
+     */
+    getById(id: number): WorkItem | null;
+    /**
+     * Get work item by item_id (e.g., "REQ-001")
+     */
+    getByItemId(projectId: number, itemId: string): WorkItem | null;
+    /**
+     * Query work items with filters
+     */
+    query(input: QueryWorkItemsInput): {
+        items: WorkItem[];
+        total: number;
+        hasMore: boolean;
+    };
+    /**
+     * Get next work item (highest priority backlog item)
+     */
+    getNext(projectId: number, type?: WorkItemType): WorkItem | null;
+    /**
+     * Update a work item
+     */
+    update(id: number, input: UpdateWorkItemInput): WorkItem | null;
+    /**
+     * Record change in history
+     */
+    recordHistory(workItemId: number, projectId: number, changes: UpdateWorkItemInput, oldItem: WorkItem): void;
+    /**
+     * Delete a work item
+     */
+    delete(id: number): boolean;
+    /**
+     * Get work item counts by status for a project
+     */
+    getStatusCounts(projectId: number): Record<WorkItemStatus, number>;
+    /**
+     * Get history for a work item
+     */
+    getHistory(workItemId: number): Array<{
+        action: string;
+        oldValue: string | null;
+        newValue: string | null;
+        notes: string | null;
+        changedBy: string | null;
+        changedAt: Date;
+    }>;
+    /**
+     * Bulk import work items (for /promote command)
+     */
+    bulkCreate(projectId: number, items: Array<{
+        type: WorkItemType;
+        title: string;
+        description?: string;
+        priority?: WorkItemPriority;
+    }>): WorkItem[];
+};