@compilr-dev/cli 0.4.0 → 0.5.0

package/dist/tools/backlog-wrappers.js

@@ -0,0 +1,338 @@
+/**
+ * Backlog Tool Wrappers
+ *
+ * These wrappers provide `backlog_read` and `backlog_write` tools that skills expect,
+ * but internally delegate to the `workitem_*` database tools.
+ *
+ * This allows library skills (which reference backlog_*) to work seamlessly
+ * with the CLI's database-backed workitem system.
+ */
+import { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/agents';
+import { workItemRepository } from '../db/repositories/index.js';
+import { getActiveProject } from './project-db.js';
+// =============================================================================
+// Type Mappings (Library ↔ CLI)
+// =============================================================================
+// Library status → CLI status
+const STATUS_TO_CLI = {
+    'backlog': 'backlog',
+    'in-progress': 'in_progress',
+    'done': 'completed',
+    'blocked': 'skipped', // closest match
+};
+// CLI status → Library status
+const STATUS_TO_LIBRARY = {
+    'backlog': 'backlog',
+    'in_progress': 'in-progress',
+    'completed': 'done',
+    'skipped': 'blocked',
+};
+// Library type → CLI type
+const TYPE_TO_CLI = {
+    'feature': 'feature',
+    'bug': 'bug',
+    'chore': 'chore',
+    'spike': 'tech-debt', // closest match
+};
+// CLI type → Library type
+const TYPE_TO_LIBRARY = {
+    'feature': 'feature',
+    'bug': 'bug',
+    'chore': 'chore',
+    'tech-debt': 'spike',
+};
+export const backlogReadTool = defineTool({
+    name: 'backlog_read',
+    description: 'Read backlog items from the project. ' +
+        'Use filters to narrow results. Use id parameter to get a specific item. ' +
+        'Returns items sorted by priority (critical first) then by creation date.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            id: {
+                type: 'string',
+                description: 'Get a specific item by ID (e.g., "FEAT-001")',
+            },
+            status: {
+                type: 'string',
+                enum: ['backlog', 'in-progress', 'done', 'blocked'],
+                description: 'Filter by status',
+            },
+            type: {
+                type: 'string',
+                enum: ['feature', 'bug', 'chore', 'spike'],
+                description: 'Filter by item type',
+            },
+            search: {
+                type: 'string',
+                description: 'Search in title and description',
+            },
+            priority: {
+                type: 'string',
+                enum: ['critical', 'high', 'medium', 'low'],
+                description: 'Filter by priority',
+            },
+            limit: {
+                type: 'number',
+                description: 'Maximum items to return (default: 20)',
+            },
+        },
+    },
+    execute: async (input) => {
+        try {
+            // Note: workItemRepository methods are synchronous, but we keep async for interface consistency
+            await Promise.resolve();
+            const projectId = getActiveProject()?.id;
+            if (!projectId) {
+                return createSuccessResult({
+                    items: [],
+                    total: 0,
+                    filtered: 0,
+                    message: 'No active project. Use /projects to select a project first.',
+                });
+            }
+            // If specific ID requested, look it up directly
+            if (input.id) {
+                const item = workItemRepository.getByItemId(projectId, input.id);
+                if (!item) {
+                    return createErrorResult(`Item not found: ${input.id}`);
+                }
+                return createSuccessResult({
+                    items: [{
+                            id: item.itemId,
+                            type: TYPE_TO_LIBRARY[item.type],
+                            title: item.title,
+                            description: item.description || '',
+                            status: STATUS_TO_LIBRARY[item.status],
+                            priority: item.priority,
+                        }],
+                    total: 1,
+                    filtered: 1,
+                });
+            }
+            // Build query
+            const queryInput = {
+                project_id: projectId,
+                status: input.status ? STATUS_TO_CLI[input.status] : 'all',
+                type: input.type ? TYPE_TO_CLI[input.type] : 'all',
+                priority: input.priority || 'all',
+                search: input.search,
+                limit: input.limit || 20,
+                offset: 0,
+            };
+            const result = workItemRepository.query(queryInput);
+            // Map items to library format
+            const items = result.items.map((item) => ({
+                id: item.itemId,
+                type: TYPE_TO_LIBRARY[item.type],
+                title: item.title,
+                description: item.description || '',
+                status: STATUS_TO_LIBRARY[item.status],
+                priority: item.priority,
+                createdAt: item.createdAt.toISOString(),
+                updatedAt: item.createdAt.toISOString(), // DB doesn't track updatedAt separately
+            }));
+            return createSuccessResult({
+                items,
+                total: result.total,
+                filtered: items.length,
+            });
+        }
+        catch (error) {
+            return createErrorResult(error instanceof Error ? error.message : String(error));
+        }
+    },
+});
+export const backlogWriteTool = defineTool({
+    name: 'backlog_write',
+    description: 'Create, update, or delete backlog items. ' +
+        'Actions: add (new item), update (modify existing), delete (remove), replace (full list). ' +
+        'IDs are auto-generated for new items based on type (e.g., FEAT-001, BUG-002).',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['add', 'update', 'delete', 'replace'],
+                description: 'Action to perform',
+            },
+            item: {
+                type: 'object',
+                description: 'Item to add or update (for add/update actions)',
+                properties: {
+                    id: { type: 'string', description: 'Item ID (required for update)' },
+                    type: {
+                        type: 'string',
+                        enum: ['feature', 'bug', 'chore', 'spike'],
+                        description: 'Item type (required for add)',
+                    },
+                    title: { type: 'string', description: 'Item title' },
+                    description: { type: 'string', description: 'Detailed description' },
+                    status: {
+                        type: 'string',
+                        enum: ['backlog', 'in-progress', 'done', 'blocked'],
+                        description: 'Item status',
+                    },
+                    priority: {
+                        type: 'string',
+                        enum: ['critical', 'high', 'medium', 'low'],
+                        description: 'Priority level',
+                    },
+                },
+            },
+            deleteId: {
+                type: 'string',
+                description: 'Item ID to delete (for delete action)',
+            },
+            items: {
+                type: 'array',
+                description: 'Full list of items (for replace action)',
+                items: {
+                    type: 'object',
+                },
+            },
+        },
+        required: ['action'],
+    },
+    execute: async (input) => {
+        try {
+            // Note: workItemRepository methods are synchronous, but we keep async for interface consistency
+            await Promise.resolve();
+            const projectId = getActiveProject()?.id;
+            if (!projectId) {
+                return createErrorResult('No active project. Use /projects to select a project first.');
+            }
+            switch (input.action) {
+                case 'add': {
+                    if (!input.item) {
+                        return createErrorResult('Item is required for add action');
+                    }
+                    if (!input.item.type) {
+                        return createErrorResult('Item type is required for add action');
+                    }
+                    if (!input.item.title) {
+                        return createErrorResult('Item title is required for add action');
+                    }
+                    const createInput = {
+                        project_id: projectId,
+                        type: TYPE_TO_CLI[input.item.type],
+                        title: input.item.title,
+                        description: input.item.description,
+                        priority: input.item.priority,
+                    };
+                    const item = workItemRepository.create(createInput);
+                    return createSuccessResult({
+                        success: true,
+                        action: 'add',
+                        itemId: item.itemId,
+                        message: `Created ${item.itemId}: "${item.title}"`,
+                    });
+                }
+                case 'update': {
+                    if (!input.item?.id) {
+                        return createErrorResult('Item ID is required for update action');
+                    }
+                    const existingItem = workItemRepository.getByItemId(projectId, input.item.id);
+                    if (!existingItem) {
+                        return createErrorResult(`Item not found: ${input.item.id}`);
+                    }
+                    const updateInput = {};
+                    if (input.item.status) {
+                        updateInput.status = STATUS_TO_CLI[input.item.status];
+                    }
+                    if (input.item.priority) {
+                        updateInput.priority = input.item.priority;
+                    }
+                    if (input.item.title) {
+                        updateInput.title = input.item.title;
+                    }
+                    if (input.item.description !== undefined) {
+                        updateInput.description = input.item.description;
+                    }
+                    const updated = workItemRepository.update(existingItem.id, updateInput);
+                    if (!updated) {
+                        return createErrorResult(`Failed to update item: ${input.item.id}`);
+                    }
+                    return createSuccessResult({
+                        success: true,
+                        action: 'update',
+                        itemId: input.item.id,
+                        message: `Updated ${input.item.id}`,
+                    });
+                }
+                case 'delete': {
+                    const deleteId = input.deleteId || input.item?.id;
+                    if (!deleteId) {
+                        return createErrorResult('deleteId or item.id is required for delete action');
+                    }
+                    const existingItem = workItemRepository.getByItemId(projectId, deleteId);
+                    if (!existingItem) {
+                        return createErrorResult(`Item not found: ${deleteId}`);
+                    }
+                    const deleted = workItemRepository.delete(existingItem.id);
+                    if (!deleted) {
+                        return createErrorResult(`Failed to delete item: ${deleteId}`);
+                    }
+                    return createSuccessResult({
+                        success: true,
+                        action: 'delete',
+                        itemId: deleteId,
+                        message: `Deleted ${deleteId}`,
+                    });
+                }
+                case 'replace': {
+                    if (!input.items) {
+                        return createErrorResult('Items array is required for replace action');
+                    }
+                    // Delete all existing items
+                    const existing = workItemRepository.query({
+                        project_id: projectId,
+                        limit: 1000,
+                        offset: 0,
+                    });
+                    for (const item of existing.items) {
+                        workItemRepository.delete(item.id);
+                    }
+                    // Add all new items
+                    const newIds = [];
+                    for (const newItem of input.items) {
+                        const createInput = {
+                            project_id: projectId,
+                            type: TYPE_TO_CLI[newItem.type],
+                            title: newItem.title,
+                            description: newItem.description,
+                            priority: newItem.priority,
+                        };
+                        const created = workItemRepository.create(createInput);
+                        newIds.push(created.itemId);
+                        // Update status if not backlog
+                        if (newItem.status && newItem.status !== 'backlog') {
+                            workItemRepository.update(created.id, {
+                                status: STATUS_TO_CLI[newItem.status],
+                            });
+                        }
+                    }
+                    return createSuccessResult({
+                        success: true,
+                        action: 'replace',
+                        itemCount: input.items.length,
+                        newIds,
+                        message: `Replaced backlog with ${String(input.items.length)} items`,
+                    });
+                }
+                default:
+                    return createErrorResult(`Unknown action: ${input.action}`);
+            }
+        }
+        catch (error) {
+            return createErrorResult(error instanceof Error ? error.message : String(error));
+        }
+    },
+});
+/**
+ * All backlog wrapper tools
+ */
+export const backlogWrapperTools = [
+    backlogReadTool,
+    backlogWriteTool,
+];

package/dist/tools/backlog.js

@@ -357,7 +357,7 @@ export const backlogReadTool = defineTool({
         if (!backlogPath) {
             return Promise.resolve({
                 success: false,
-                error: 'No backlog file found. Run /init to create a project first, or /design to create the backlog.',
+                error: 'No backlog file found. Run /new to create a project first, or /design to create the backlog.',
             });
         }
         try {

package/dist/tools/db-tools.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Database Tools Index
+ *
+ * Exports all database-related tools for project, work item, and document management.
+ */
+export { projectDbTools, projectGetTool, projectCreateTool, projectUpdateTool, projectListTool, getActiveProject, setActiveProject } from './project-db.js';
+export { workitemDbTools, workitemQueryTool, workitemAddTool, workitemUpdateTool, workitemNextTool, workitemDeleteTool, workitemStatusCountsTool } from './workitem-db.js';
+export { documentDbTools, projectDocumentAddTool, projectDocumentGetTool, projectDocumentListTool, projectDocumentDeleteTool } from './document-db.js';
+export declare const allDbTools: (import("@compilr-dev/agents").Tool<{
+    project_id?: number;
+    name?: string;
+    path?: string;
+}> | import("@compilr-dev/agents").Tool<{
+    name: string;
+    display_name: string;
+    description?: string;
+    path?: string;
+    type?: string;
+    workflow_mode?: string;
+    language?: string;
+    framework?: string;
+    package_manager?: string;
+}> | import("@compilr-dev/agents").Tool<{
+    project_id?: number;
+    status?: string;
+    description?: string;
+    workflow_mode?: string;
+    lifecycle_state?: string;
+    current_item_id?: string;
+    last_context?: Record<string, unknown>;
+}> | import("@compilr-dev/agents").Tool<{
+    project_id?: number;
+    status?: string;
+    type?: string;
+    priority?: string;
+    search?: string;
+    limit?: number;
+    offset?: number;
+}> | import("@compilr-dev/agents").Tool<{
+    project_id?: number;
+    type: string;
+    title: string;
+    description?: string;
+    priority?: string;
+    estimated_effort?: string;
+}> | import("@compilr-dev/agents").Tool<{
+    item_id: string;
+    project_id?: number;
+    status?: string;
+    priority?: string;
+    guided_step?: string;
+    title?: string;
+    description?: string;
+    commit_hash?: string;
+}> | import("@compilr-dev/agents").Tool<{
+    item_id: string;
+    reason: string;
+    force?: boolean;
+    project_id?: number;
+}> | import("@compilr-dev/agents").Tool<{
+    project_id?: number;
+    doc_type: string;
+    title: string;
+    content: string;
+}>)[];

package/dist/tools/db-tools.js

@@ -0,0 +1,19 @@
+/**
+ * Database Tools Index
+ *
+ * Exports all database-related tools for project, work item, and document management.
+ */
+export { projectDbTools, projectGetTool, projectCreateTool, projectUpdateTool, projectListTool, getActiveProject, setActiveProject } from './project-db.js';
+export { workitemDbTools, workitemQueryTool, workitemAddTool, workitemUpdateTool, workitemNextTool, workitemDeleteTool, workitemStatusCountsTool } from './workitem-db.js';
+export { documentDbTools, projectDocumentAddTool, projectDocumentGetTool, projectDocumentListTool, projectDocumentDeleteTool } from './document-db.js';
+/**
+ * All database tools combined
+ */
+import { projectDbTools } from './project-db.js';
+import { workitemDbTools } from './workitem-db.js';
+import { documentDbTools } from './document-db.js';
+export const allDbTools = [
+    ...projectDbTools,
+    ...workitemDbTools,
+    ...documentDbTools,
+];

package/dist/tools/document-db.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Document Database Tools
+ *
+ * Tools for managing project documents (PRD, architecture, design notes) in the database.
+ */
+/**
+ * project_document_add - Add or update a project document
+ */
+export declare const projectDocumentAddTool: import("@compilr-dev/agents").Tool<{
+    project_id?: number;
+    doc_type: string;
+    title: string;
+    content: string;
+}>;
+/**
+ * project_document_get - Get a project document
+ */
+export declare const projectDocumentGetTool: import("@compilr-dev/agents").Tool<{
+    project_id?: number;
+    doc_type: string;
+}>;
+/**
+ * project_document_list - List all documents for a project
+ */
+export declare const projectDocumentListTool: import("@compilr-dev/agents").Tool<{
+    project_id?: number;
+}>;
+/**
+ * project_document_delete - Delete a project document
+ */
+export declare const projectDocumentDeleteTool: import("@compilr-dev/agents").Tool<{
+    project_id?: number;
+    doc_type: string;
+}>;
+/**
+ * All document tools
+ */
+export declare const documentDbTools: import("@compilr-dev/agents").Tool<{
+    project_id?: number;
+    doc_type: string;
+    title: string;
+    content: string;
+}>[];