@compilr-dev/cli 0.5.0 → 0.5.2

package/dist/tools/anchor-tools.js

@@ -1,255 +0,0 @@
-/**
- * Anchor Tools - Agent tools for managing anchors
- *
- * Provides anchor_add and anchor_remove tools that allow
- * the agent to add critical context that survives compaction.
- */
-import { defineTool } from '@compilr-dev/agents';
-import { getGlobalAnchorManager, getAnchorManager, } from '../anchors/index.js';
-import { getActiveProject } from './project-db.js';
-// =============================================================================
-// anchor_add Tool
-// =============================================================================
-export const anchorAddTool = defineTool({
-    name: 'anchor_add',
-    description: 'Add critical information that must survive context compaction. ' +
-        'Use this for: project context, important decisions, user preferences, ' +
-        'architectural constraints, or any information that should persist across the entire conversation. ' +
-        'Anchors are always included at the top of the context window.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            content: {
-                type: 'string',
-                description: 'The critical information to preserve. Keep it concise but complete.',
-            },
-            priority: {
-                type: 'string',
-                enum: ['critical', 'safety', 'info'],
-                description: 'Priority level. "critical" for must-never-forget info (user preferences, key constraints), ' +
-                    '"safety" for safety-related context, "info" for general helpful context.',
-            },
-            scope: {
-                type: 'string',
-                enum: ['global', 'project'],
-                description: 'Scope for the anchor. "global" persists across all projects, ' +
-                    '"project" is specific to the current project (requires active project).',
-            },
-            tags: {
-                type: 'array',
-                items: { type: 'string' },
-                description: 'Optional tags for categorization (e.g., ["architecture", "decision"])',
-            },
-        },
-        required: ['content'],
-    },
-    execute: (input) => {
-        try {
-            // Validate content
-            if (!input.content || input.content.trim().length === 0) {
-                return Promise.resolve({
-                    success: false,
-                    error: 'Anchor content is required and cannot be empty',
-                });
-            }
-            const content = input.content.trim();
-            const priority = input.priority ?? 'info';
-            const activeProject = getActiveProject();
-            // Determine scope
-            let scope = input.scope;
-            if (!scope) {
-                scope = activeProject ? 'project' : 'global';
-            }
-            // Validate project scope
-            if (scope === 'project' && !activeProject) {
-                return Promise.resolve({
-                    success: false,
-                    error: 'Cannot add project-scoped anchor: no active project. Use scope: "global" instead.',
-                });
-            }
-            // Get project ID for project-scoped anchors (validated above that activeProject exists)
-            const projectId = scope === 'project' && activeProject
-                ? String(activeProject.id)
-                : undefined;
-            // Get the appropriate manager
-            const manager = scope === 'global'
-                ? getGlobalAnchorManager()
-                : getAnchorManager(projectId ?? '');
-            // Add the anchor
-            const anchor = manager.add({
-                content,
-                priority,
-                scope: 'persistent', // Anchors persist across sessions
-                tags: input.tags,
-                projectId,
-            });
-            return Promise.resolve({
-                success: true,
-                result: {
-                    id: anchor.id,
-                    content: anchor.content,
-                    priority: anchor.priority,
-                    scope: scope,
-                    tags: anchor.tags,
-                    message: `Anchor added successfully (${scope} scope, ${priority} priority)`,
-                },
-            });
-        }
-        catch (err) {
-            return Promise.resolve({
-                success: false,
-                error: `Failed to add anchor: ${err instanceof Error ? err.message : String(err)}`,
-            });
-        }
-    },
-});
-// =============================================================================
-// anchor_remove Tool
-// =============================================================================
-export const anchorRemoveTool = defineTool({
-    name: 'anchor_remove',
-    description: 'Remove an anchor by its ID. Use this to clean up outdated or no longer relevant anchors. ' +
-        'Use anchor_list first to see available anchors and their IDs.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            id: {
-                type: 'string',
-                description: 'The ID of the anchor to remove',
-            },
-        },
-        required: ['id'],
-    },
-    execute: (input) => {
-        try {
-            if (!input.id || input.id.trim().length === 0) {
-                return Promise.resolve({
-                    success: false,
-                    error: 'Anchor ID is required',
-                });
-            }
-            const id = input.id.trim();
-            const activeProject = getActiveProject();
-            // Try to remove from project anchors first, then global
-            let removed = false;
-            let scope = 'unknown';
-            if (activeProject) {
-                const projectManager = getAnchorManager(String(activeProject.id));
-                if (projectManager.has(id)) {
-                    removed = projectManager.remove(id);
-                    scope = 'project';
-                }
-            }
-            if (!removed) {
-                const globalManager = getGlobalAnchorManager();
-                if (globalManager.has(id)) {
-                    removed = globalManager.remove(id);
-                    scope = 'global';
-                }
-            }
-            if (!removed) {
-                return Promise.resolve({
-                    success: false,
-                    error: `Anchor with ID "${id}" not found`,
-                });
-            }
-            return Promise.resolve({
-                success: true,
-                result: {
-                    id,
-                    scope,
-                    message: `Anchor removed successfully (was ${scope} scope)`,
-                },
-            });
-        }
-        catch (err) {
-            return Promise.resolve({
-                success: false,
-                error: `Failed to remove anchor: ${err instanceof Error ? err.message : String(err)}`,
-            });
-        }
-    },
-});
-// =============================================================================
-// anchor_list Tool
-// =============================================================================
-export const anchorListTool = defineTool({
-    name: 'anchor_list',
-    description: 'List all anchors. Returns anchor IDs, content, priority, and scope. ' +
-        'Use this to see what persistent context is available before adding or removing anchors.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            scope: {
-                type: 'string',
-                enum: ['global', 'project', 'all'],
-                description: 'Filter by scope: "global", "project", or "all" (default: "all")',
-            },
-            priority: {
-                type: 'string',
-                enum: ['critical', 'safety', 'info'],
-                description: 'Filter by priority level',
-            },
-        },
-    },
-    execute: (input) => {
-        try {
-            const activeProject = getActiveProject();
-            const scope = input.scope ?? 'all';
-            const anchors = [];
-            // Collect global anchors
-            if (scope === 'global' || scope === 'all') {
-                const globalManager = getGlobalAnchorManager();
-                const globalAnchors = globalManager.getAll({ priority: input.priority });
-                for (const anchor of globalAnchors) {
-                    anchors.push({
-                        id: anchor.id,
-                        content: anchor.content,
-                        priority: anchor.priority,
-                        scope: 'global',
-                        tags: anchor.tags,
-                    });
-                }
-            }
-            // Collect project anchors
-            if ((scope === 'project' || scope === 'all') && activeProject) {
-                const projectManager = getAnchorManager(String(activeProject.id));
-                const projectAnchors = projectManager.getAll({ priority: input.priority });
-                for (const anchor of projectAnchors) {
-                    anchors.push({
-                        id: anchor.id,
-                        content: anchor.content,
-                        priority: anchor.priority,
-                        scope: 'project',
-                        tags: anchor.tags,
-                    });
-                }
-            }
-            // Sort by priority (critical first)
-            const priorityOrder = { critical: 0, safety: 1, info: 2 };
-            anchors.sort((a, b) => {
-                const pa = priorityOrder[a.priority] ?? 2;
-                const pb = priorityOrder[b.priority] ?? 2;
-                return pa - pb;
-            });
-            return Promise.resolve({
-                success: true,
-                result: {
-                    count: anchors.length,
-                    activeProject: activeProject?.displayName ?? null,
-                    anchors,
-                },
-            });
-        }
-        catch (err) {
-            return Promise.resolve({
-                success: false,
-                error: `Failed to list anchors: ${err instanceof Error ? err.message : String(err)}`,
-            });
-        }
-    },
-});
-// =============================================================================
-// Export all anchor tools
-// =============================================================================
-export const allAnchorTools = [anchorAddTool, anchorRemoveTool, anchorListTool];

package/dist/tools/backlog-wrappers.d.ts

@@ -1,54 +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.
- */
-interface BacklogReadInput {
-    /** Get a specific item by ID */
-    id?: string;
-    /** Filter by status */
-    status?: 'backlog' | 'in-progress' | 'done' | 'blocked';
-    /** Filter by type */
-    type?: 'feature' | 'bug' | 'chore' | 'spike';
-    /** Filter by priority */
-    priority?: 'critical' | 'high' | 'medium' | 'low';
-    /** Search in title and description */
-    search?: string;
-    /** Maximum items to return (default: 20) */
-    limit?: number;
-}
-export declare const backlogReadTool: import("@compilr-dev/agents").Tool<BacklogReadInput>;
-interface BacklogWriteInput {
-    /** Action to perform */
-    action: 'add' | 'update' | 'delete' | 'replace';
-    /** Item to add or update (required for add/update) */
-    item?: {
-        id?: string;
-        type?: 'feature' | 'bug' | 'chore' | 'spike';
-        title?: string;
-        description?: string;
-        status?: 'backlog' | 'in-progress' | 'done' | 'blocked';
-        priority?: 'critical' | 'high' | 'medium' | 'low';
-    };
-    /** Item ID to delete (required for delete) */
-    deleteId?: string;
-    /** Full list of items (required for replace action) */
-    items?: Array<{
-        id?: string;
-        type: 'feature' | 'bug' | 'chore' | 'spike';
-        title: string;
-        description?: string;
-        status?: 'backlog' | 'in-progress' | 'done' | 'blocked';
-        priority?: 'critical' | 'high' | 'medium' | 'low';
-    }>;
-}
-export declare const backlogWriteTool: import("@compilr-dev/agents").Tool<BacklogWriteInput>;
-/**
- * All backlog wrapper tools
- */
-export declare const backlogWrapperTools: (import("@compilr-dev/agents").Tool<BacklogReadInput> | import("@compilr-dev/agents").Tool<BacklogWriteInput>)[];
-export {};

package/dist/tools/backlog-wrappers.js

@@ -1,338 +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/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/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/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;
-}>[];