@compilr-dev/cli 0.5.1 → 0.5.3

package/dist/tools/backlog-wrappers.js

@@ -1,353 +0,0 @@
-/**
- * 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/sdk';
-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',
-                    },
-                    owner: {
-                        type: 'string',
-                        description: 'Owner/assignee of the item',
-                    },
-                    commit_hash: {
-                        type: 'string',
-                        description: 'Git commit hash associated with the item (for update)',
-                    },
-                },
-            },
-            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,
-                        owner: input.item.owner,
-                    };
-                    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;
-                    }
-                    if (input.item.owner !== undefined) {
-                        updateInput.owner = input.item.owner;
-                    }
-                    if (input.item.commit_hash) {
-                        updateInput.commit_hash = input.item.commit_hash;
-                    }
-                    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/document-db.d.ts

@@ -1,43 +0,0 @@
-/**
- * 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/sdk").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/sdk").Tool<{
-    project_id?: number;
-    doc_type: string;
-}>;
-/**
- * project_document_list - List all documents for a project
- */
-export declare const projectDocumentListTool: import("@compilr-dev/sdk").Tool<{
-    project_id?: number;
-}>;
-/**
- * project_document_delete - Delete a project document
- */
-export declare const projectDocumentDeleteTool: import("@compilr-dev/sdk").Tool<{
-    project_id?: number;
-    doc_type: string;
-}>;
-/**
- * All document tools
- */
-export declare const documentDbTools: import("@compilr-dev/sdk").Tool<{
-    project_id?: number;
-    doc_type: string;
-    title: string;
-    content: string;
-}>[];

package/dist/tools/document-db.js

@@ -1,220 +0,0 @@
-/**
- * Document Database Tools
- *
- * Tools for managing project documents (PRD, architecture, design notes) in the database.
- */
-import { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/sdk';
-import { documentRepository } from '../db/repositories/index.js';
-import { getActiveProject } from './project-db.js';
-/**
- * project_document_add - Add or update a project document
- */
-export const projectDocumentAddTool = defineTool({
-    name: 'project_document_add',
-    description: 'Add or update a project document (PRD, architecture, design, notes). If a document of the same type exists, it will be updated.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            project_id: {
-                type: 'number',
-                description: 'Project ID (uses active project if not provided)',
-            },
-            doc_type: {
-                type: 'string',
-                enum: ['prd', 'architecture', 'design', 'notes'],
-                description: 'Document type',
-            },
-            title: {
-                type: 'string',
-                description: 'Document title',
-            },
-            content: {
-                type: 'string',
-                description: 'Document content (markdown)',
-            },
-        },
-        required: ['doc_type', 'title', 'content'],
-    },
-    execute: async (input) => {
-        await Promise.resolve(); // Required for async type signature
-        try {
-            const projectId = input.project_id || getActiveProject()?.id;
-            if (!projectId) {
-                return createErrorResult('No project specified and no active project. Use project_get or /projects to select a project first.');
-            }
-            const createInput = {
-                project_id: projectId,
-                doc_type: input.doc_type,
-                title: input.title,
-                content: input.content,
-            };
-            const doc = documentRepository.upsert(createInput);
-            return createSuccessResult({
-                success: true,
-                message: `Document "${doc.title}" saved`,
-                document: {
-                    id: doc.id,
-                    docType: doc.docType,
-                    title: doc.title,
-                    contentLength: doc.content.length,
-                    updatedAt: doc.updatedAt.toISOString(),
-                },
-            });
-        }
-        catch (error) {
-            return createErrorResult(`Failed to save document: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    },
-});
-/**
- * project_document_get - Get a project document
- */
-export const projectDocumentGetTool = defineTool({
-    name: 'project_document_get',
-    description: 'Get a project document by type. Returns the document content.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            project_id: {
-                type: 'number',
-                description: 'Project ID (uses active project if not provided)',
-            },
-            doc_type: {
-                type: 'string',
-                enum: ['prd', 'architecture', 'design', 'notes'],
-                description: 'Document type to retrieve',
-            },
-        },
-        required: ['doc_type'],
-    },
-    execute: async (input) => {
-        await Promise.resolve(); // Required for async type signature
-        try {
-            const projectId = input.project_id || getActiveProject()?.id;
-            if (!projectId) {
-                return createErrorResult('No project specified and no active project. Use project_get or /projects to select a project first.');
-            }
-            const doc = documentRepository.getByType(projectId, input.doc_type);
-            if (!doc) {
-                return createSuccessResult({
-                    success: true,
-                    document: null,
-                    message: `No ${input.doc_type} document found for this project`,
-                });
-            }
-            return createSuccessResult({
-                success: true,
-                document: {
-                    id: doc.id,
-                    docType: doc.docType,
-                    title: doc.title,
-                    content: doc.content,
-                    createdAt: doc.createdAt.toISOString(),
-                    updatedAt: doc.updatedAt.toISOString(),
-                },
-            });
-        }
-        catch (error) {
-            return createErrorResult(`Failed to get document: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    },
-});
-/**
- * project_document_list - List all documents for a project
- */
-export const projectDocumentListTool = defineTool({
-    name: 'project_document_list',
-    description: 'List all documents for a project. Returns document metadata without full content.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            project_id: {
-                type: 'number',
-                description: 'Project ID (uses active project if not provided)',
-            },
-        },
-        required: [],
-    },
-    execute: async (input) => {
-        await Promise.resolve(); // Required for async type signature
-        try {
-            const projectId = input.project_id || getActiveProject()?.id;
-            if (!projectId) {
-                return createErrorResult('No project specified and no active project. Use project_get or /projects to select a project first.');
-            }
-            const docs = documentRepository.listByProject(projectId);
-            const documents = docs.map((doc) => ({
-                id: doc.id,
-                docType: doc.docType,
-                title: doc.title,
-                contentLength: doc.content.length,
-                createdAt: doc.createdAt.toISOString(),
-                updatedAt: doc.updatedAt.toISOString(),
-            }));
-            return createSuccessResult({
-                success: true,
-                documents,
-                count: documents.length,
-            });
-        }
-        catch (error) {
-            return createErrorResult(`Failed to list documents: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    },
-});
-/**
- * project_document_delete - Delete a project document
- */
-export const projectDocumentDeleteTool = defineTool({
-    name: 'project_document_delete',
-    description: 'Delete a project document by type.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            project_id: {
-                type: 'number',
-                description: 'Project ID (uses active project if not provided)',
-            },
-            doc_type: {
-                type: 'string',
-                enum: ['prd', 'architecture', 'design', 'notes'],
-                description: 'Document type to delete',
-            },
-        },
-        required: ['doc_type'],
-    },
-    execute: async (input) => {
-        await Promise.resolve(); // Required for async type signature
-        try {
-            const projectId = input.project_id || getActiveProject()?.id;
-            if (!projectId) {
-                return createErrorResult('No project specified and no active project. Use project_get or /projects to select a project first.');
-            }
-            // Find the document first
-            const doc = documentRepository.getByType(projectId, input.doc_type);
-            if (!doc) {
-                return createErrorResult(`No ${input.doc_type} document found for this project`);
-            }
-            const deleted = documentRepository.delete(doc.id);
-            if (!deleted) {
-                return createErrorResult(`Failed to delete ${input.doc_type} document`);
-            }
-            return createSuccessResult({
-                success: true,
-                message: `Document "${doc.title}" deleted`,
-            });
-        }
-        catch (error) {
-            return createErrorResult(`Failed to delete document: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    },
-});
-/**
- * All document tools
- */
-export const documentDbTools = [
-    projectDocumentAddTool,
-    projectDocumentGetTool,
-    projectDocumentListTool,
-    projectDocumentDeleteTool,
-];

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

@@ -1,54 +0,0 @@
-/**
- * Plan Database Tools
- *
- * Tools for managing plans in the database.
- * Plans are used in Plan Mode for structured task planning before implementation.
- */
-export declare const planCreateTool: import("@compilr-dev/sdk").Tool<{
-    name: string;
-    content: string;
-    work_item_id?: number;
-    project_id?: number;
-}>;
-export declare const planUpdateTool: import("@compilr-dev/sdk").Tool<{
-    plan_id: number;
-    content?: string;
-    status?: string;
-    work_item_id?: number | null;
-}>;
-export declare const planGetTool: import("@compilr-dev/sdk").Tool<{
-    plan_id?: number;
-    name?: string;
-    project_id?: number;
-}>;
-export declare const planListTool: import("@compilr-dev/sdk").Tool<{
-    project_id?: number;
-    status?: string;
-    work_item_id?: number;
-    limit?: number;
-    order_by?: string;
-}>;
-export declare const planDeleteTool: import("@compilr-dev/sdk").Tool<{
-    plan_id: number;
-}>;
-export declare const planDbTools: (import("@compilr-dev/sdk").Tool<{
-    name: string;
-    content: string;
-    work_item_id?: number;
-    project_id?: number;
-}> | import("@compilr-dev/sdk").Tool<{
-    plan_id: number;
-    content?: string;
-    status?: string;
-    work_item_id?: number | null;
-}> | import("@compilr-dev/sdk").Tool<{
-    plan_id?: number;
-    name?: string;
-    project_id?: number;
-}> | import("@compilr-dev/sdk").Tool<{
-    project_id?: number;
-    status?: string;
-    work_item_id?: number;
-    limit?: number;
-    order_by?: string;
-}>)[];