@compilr-dev/cli 0.5.0 → 0.5.1

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

@@ -21,7 +21,7 @@ interface BacklogReadInput {
     /** Maximum items to return (default: 20) */
     limit?: number;
 }
-export declare const backlogReadTool: import("@compilr-dev/agents").Tool<BacklogReadInput>;
+export declare const backlogReadTool: import("@compilr-dev/sdk").Tool<BacklogReadInput>;
 interface BacklogWriteInput {
     /** Action to perform */
     action: 'add' | 'update' | 'delete' | 'replace';
@@ -33,6 +33,8 @@ interface BacklogWriteInput {
         description?: string;
         status?: 'backlog' | 'in-progress' | 'done' | 'blocked';
         priority?: 'critical' | 'high' | 'medium' | 'low';
+        owner?: string;
+        commit_hash?: string;
     };
     /** Item ID to delete (required for delete) */
     deleteId?: string;
@@ -46,9 +48,9 @@ interface BacklogWriteInput {
         priority?: 'critical' | 'high' | 'medium' | 'low';
     }>;
 }
-export declare const backlogWriteTool: import("@compilr-dev/agents").Tool<BacklogWriteInput>;
+export declare const backlogWriteTool: import("@compilr-dev/sdk").Tool<BacklogWriteInput>;
 /**
  * All backlog wrapper tools
  */
-export declare const backlogWrapperTools: (import("@compilr-dev/agents").Tool<BacklogReadInput> | import("@compilr-dev/agents").Tool<BacklogWriteInput>)[];
+export declare const backlogWrapperTools: (import("@compilr-dev/sdk").Tool<BacklogReadInput> | import("@compilr-dev/sdk").Tool<BacklogWriteInput>)[];
 export {};

package/dist/tools/backlog-wrappers.js

@@ -7,7 +7,7 @@
  * 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 { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/sdk';
 import { workItemRepository } from '../db/repositories/index.js';
 import { getActiveProject } from './project-db.js';
 // =============================================================================
@@ -178,6 +178,14 @@ export const backlogWriteTool = defineTool({
                         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: {
@@ -219,6 +227,7 @@ export const backlogWriteTool = defineTool({
                         title: input.item.title,
                         description: input.item.description,
                         priority: input.item.priority,
+                        owner: input.item.owner,
                     };
                     const item = workItemRepository.create(createInput);
                     return createSuccessResult({
@@ -249,6 +258,12 @@ export const backlogWriteTool = defineTool({
                     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}`);

package/dist/tools/backlog.d.ts

@@ -34,7 +34,7 @@ interface BacklogReadInput {
     search?: string;
     id?: string;
 }
-export declare const backlogReadTool: import("@compilr-dev/agents").Tool<BacklogReadInput>;
+export declare const backlogReadTool: import("@compilr-dev/sdk").Tool<BacklogReadInput>;
 interface BacklogWriteInput {
     action: 'add' | 'update' | 'remove' | 'reorder';
     items?: Array<{
@@ -49,5 +49,5 @@ interface BacklogWriteInput {
     ids?: string[];
     order?: string[];
 }
-export declare const backlogWriteTool: import("@compilr-dev/agents").Tool<BacklogWriteInput>;
+export declare const backlogWriteTool: import("@compilr-dev/sdk").Tool<BacklogWriteInput>;
 export {};

package/dist/tools/backlog.js

@@ -6,7 +6,7 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
-import { defineTool } from '@compilr-dev/agents';
+import { defineTool } from '@compilr-dev/sdk';
 // =============================================================================
 // Backlog File Detection
 // =============================================================================

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

@@ -1,65 +1,12 @@
 /**
  * Database Tools Index
  *
- * Exports all database-related tools for project, work item, and document management.
+ * All 24 platform tools (project, workitem, document, plan, backlog) are now
+ * provided by the SDK via platform-adapter.ts. This file re-exports them
+ * along with state management functions still needed by ~15+ CLI files.
  */
-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;
-}>)[];
+export { getActiveProject, setActiveProject } from './project-db.js';
+/**
+ * All database tools combined (24 tools from SDK)
+ */
+export declare const allDbTools: import("@compilr-dev/agents").Tool<never>[];

package/dist/tools/db-tools.js

@@ -1,19 +1,14 @@
 /**
  * Database Tools Index
  *
- * Exports all database-related tools for project, work item, and document management.
+ * All 24 platform tools (project, workitem, document, plan, backlog) are now
+ * provided by the SDK via platform-adapter.ts. This file re-exports them
+ * along with state management functions still needed by ~15+ CLI files.
  */
-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';
+import { allPlatformTools } from './platform-adapter.js';
+// Re-export state management functions (still needed by many CLI files)
+export { getActiveProject, setActiveProject } from './project-db.js';
 /**
- * All database tools combined
+ * All database tools combined (24 tools from SDK)
  */
-import { projectDbTools } from './project-db.js';
-import { workitemDbTools } from './workitem-db.js';
-import { documentDbTools } from './document-db.js';
-export const allDbTools = [
-    ...projectDbTools,
-    ...workitemDbTools,
-    ...documentDbTools,
-];
+export const allDbTools = allPlatformTools;

package/dist/tools/delegate-background.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Delegate Background Tool - Coordinator Mode
+ *
+ * Allows the coordinator to delegate tasks to specialists running in background.
+ * Unlike the foreground `delegate` tool (which switches the active agent),
+ * this tool keeps the coordinator in the foreground while the specialist
+ * works independently in the background.
+ *
+ * Flow:
+ * 1. Coordinator calls delegate_background(agentId, task)
+ * 2. DelegationTracker registers the delegation
+ * 3. Specialist starts as background agent (or queued if busy)
+ * 4. Coordinator continues working
+ * 5. On completion, coordinator is notified via completion events (Phase 2)
+ */
+interface DelegateBackgroundInput {
+    /** Target specialist agent ID (e.g., 'arch', 'dev', 'qa') */
+    agentId: string;
+    /** Detailed task description for the specialist */
+    task: string;
+    /** Optional todo index to associate with this delegation */
+    todoIndex?: number;
+    /** What the specialist should produce (e.g., "architecture document") */
+    expectedOutput?: string;
+}
+export declare const delegateBackgroundTool: import("@compilr-dev/sdk").Tool<DelegateBackgroundInput>;
+export {};

package/dist/tools/delegate-background.js

@@ -0,0 +1,115 @@
+/**
+ * Delegate Background Tool - Coordinator Mode
+ *
+ * Allows the coordinator to delegate tasks to specialists running in background.
+ * Unlike the foreground `delegate` tool (which switches the active agent),
+ * this tool keeps the coordinator in the foreground while the specialist
+ * works independently in the background.
+ *
+ * Flow:
+ * 1. Coordinator calls delegate_background(agentId, task)
+ * 2. DelegationTracker registers the delegation
+ * 3. Specialist starts as background agent (or queued if busy)
+ * 4. Coordinator continues working
+ * 5. On completion, coordinator is notified via completion events (Phase 2)
+ */
+import { defineTool } from '@compilr-dev/sdk';
+import { getDelegateBackgroundHandler } from '../shared-handlers.js';
+// =============================================================================
+// Tool Definition
+// =============================================================================
+export const delegateBackgroundTool = defineTool({
+    name: 'delegate_background',
+    description: 'Delegate a task to a specialist running in background. ' +
+        'The specialist executes independently while you continue working. ' +
+        'You will be notified when the specialist completes. ' +
+        'Use delegation_status to check progress. ' +
+        'Prefer this over delegate — it keeps you in control and tracks status. ' +
+        'Only available to the coordinator.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            agentId: {
+                type: 'string',
+                description: 'Target specialist agent ID (e.g., "arch", "dev", "qa")',
+            },
+            task: {
+                type: 'string',
+                description: 'Detailed task description for the specialist',
+            },
+            todoIndex: {
+                type: 'number',
+                description: 'Optional todo index to associate with this delegation',
+            },
+            expectedOutput: {
+                type: 'string',
+                description: 'What the specialist should produce (e.g., "architecture document", "implementation")',
+            },
+        },
+        required: ['agentId', 'task'],
+    },
+    execute: async (input) => {
+        try {
+            // Validate input
+            if (!input.agentId || input.agentId.trim().length === 0) {
+                return {
+                    success: false,
+                    error: 'Agent ID is required',
+                };
+            }
+            if (!input.task || input.task.trim().length === 0) {
+                return {
+                    success: false,
+                    error: 'Task description is required',
+                };
+            }
+            // Prevent self-delegation
+            if (input.agentId.trim() === 'default') {
+                return {
+                    success: false,
+                    error: 'Cannot delegate to yourself (the coordinator). Delegate to a specialist agent.',
+                };
+            }
+            // Get the delegate background handler from shared-handlers
+            const handler = getDelegateBackgroundHandler();
+            if (!handler) {
+                return {
+                    success: false,
+                    error: 'Delegate background handler not initialized. ' +
+                        'This tool requires multi-agent mode with coordinator role.',
+                };
+            }
+            // Execute background delegation
+            const result = await handler({
+                agentId: input.agentId.trim(),
+                task: input.task.trim(),
+                todoIndex: input.todoIndex,
+                expectedOutput: input.expectedOutput?.trim(),
+            });
+            if (result.error) {
+                return {
+                    success: false,
+                    error: result.error,
+                };
+            }
+            const output = {
+                delegated: true,
+                delegationId: result.delegationId,
+                status: result.status,
+                message: result.status === 'queued'
+                    ? `Task queued for $${input.agentId} (currently busy). It will start when they're free.`
+                    : `Task delegated to $${input.agentId} running in background. You'll be notified on completion.`,
+            };
+            return {
+                success: true,
+                result: output,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: `Background delegation failed: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+    },
+});

package/dist/tools/delegate.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Delegate Tool - Multi-Agent Task Delegation
+ *
+ * Allows the coordinator to delegate tasks to specialist agents.
+ * Only available to the coordinator (default agent).
+ *
+ * Flow:
+ * 1. Coordinator calls delegate(agentId, task, reason?)
+ * 2. CLI shows approval prompt
+ * 3. If approved: auto-switch to specialist, inject task
+ * 4. If denied: return "User declined" to coordinator
+ */
+interface DelegateInput {
+    /** Target agent ID (e.g., 'arch', 'dev', 'qa') */
+    agentId: string;
+    /** Task description for the specialist */
+    task: string;
+    /** Optional reason for delegation (shown to user for context) */
+    reason?: string;
+}
+export declare const delegateTool: import("@compilr-dev/sdk").Tool<DelegateInput>;
+export {};

package/dist/tools/delegate.js

@@ -0,0 +1,97 @@
+/**
+ * Delegate Tool - Multi-Agent Task Delegation
+ *
+ * Allows the coordinator to delegate tasks to specialist agents.
+ * Only available to the coordinator (default agent).
+ *
+ * Flow:
+ * 1. Coordinator calls delegate(agentId, task, reason?)
+ * 2. CLI shows approval prompt
+ * 3. If approved: auto-switch to specialist, inject task
+ * 4. If denied: return "User declined" to coordinator
+ */
+import { defineTool } from '@compilr-dev/sdk';
+import { getDelegateHandler } from '../shared-handlers.js';
+// =============================================================================
+// Tool Definition
+// =============================================================================
+export const delegateTool = defineTool({
+    name: 'delegate',
+    description: 'Hand off the conversation to a specialist (foreground switch). ' +
+        'You stop working and the specialist takes over. No status tracking. ' +
+        'Use delegate_background instead if you want to continue working while ' +
+        'the specialist runs in the background (with delegation tracking). ' +
+        'Only available to the coordinator.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            agentId: {
+                type: 'string',
+                description: 'Target agent ID (e.g., "arch", "dev", "qa")',
+            },
+            task: {
+                type: 'string',
+                description: 'Task description for the specialist - be specific and clear',
+            },
+            reason: {
+                type: 'string',
+                description: 'Why this specialist is suited for the task (shown to user)',
+            },
+        },
+        required: ['agentId', 'task'],
+    },
+    execute: async (input) => {
+        try {
+            // Validate input
+            if (!input.agentId || input.agentId.trim().length === 0) {
+                return {
+                    success: false,
+                    error: 'Agent ID is required',
+                };
+            }
+            if (!input.task || input.task.trim().length === 0) {
+                return {
+                    success: false,
+                    error: 'Task description is required',
+                };
+            }
+            // Get the delegate handler from shared-handlers
+            const delegateHandler = getDelegateHandler();
+            if (!delegateHandler) {
+                return {
+                    success: false,
+                    error: 'Delegate handler not initialized. ' +
+                        'This tool requires multi-agent mode with coordinator role.',
+                };
+            }
+            // Execute delegation (shows approval prompt, switches if approved)
+            const result = await delegateHandler({
+                agentId: input.agentId.trim(),
+                task: input.task.trim(),
+                reason: input.reason?.trim(),
+            });
+            if (result.error) {
+                return {
+                    success: false,
+                    error: result.error,
+                };
+            }
+            const output = {
+                delegated: result.success,
+                message: result.declined
+                    ? 'User declined the delegation. Continue handling the task yourself.'
+                    : `Task delegated to $${input.agentId}. They will handle it from here.`,
+            };
+            return {
+                success: true,
+                result: output,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: `Delegation failed: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+    },
+});

package/dist/tools/delegation-status.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Delegation Status Tool - Coordinator Mode
+ *
+ * Read-only tool for the coordinator to query delegation progress.
+ * Queries the DelegationTracker singleton and returns formatted status.
+ */
+interface DelegationStatusInput {
+    /** Specific delegation ID (e.g., "del_abc12345") */
+    delegation_id?: string;
+    /** Filter by target agent (e.g., "dev") */
+    agent_id?: string;
+    /** Filter by status: active (pending+running), completed, failed, all. Default: active */
+    status?: 'active' | 'completed' | 'failed' | 'all';
+}
+export declare const delegationStatusTool: import("@compilr-dev/sdk").Tool<DelegationStatusInput>;
+export {};

package/dist/tools/delegation-status.js

@@ -0,0 +1,128 @@
+/**
+ * Delegation Status Tool - Coordinator Mode
+ *
+ * Read-only tool for the coordinator to query delegation progress.
+ * Queries the DelegationTracker singleton and returns formatted status.
+ */
+import { defineTool } from '@compilr-dev/sdk';
+import { getDelegationTracker } from '../multi-agent/delegation-tracker.js';
+// =============================================================================
+// Helpers
+// =============================================================================
+function formatDuration(from, to) {
+    const endTime = to ?? new Date();
+    const ms = endTime.getTime() - from.getTime();
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    if (hours > 0) {
+        return `${String(hours)}h ${String(minutes % 60)}m`;
+    }
+    else if (minutes > 0) {
+        return `${String(minutes)}m ${String(seconds % 60)}s`;
+    }
+    else {
+        return `${String(seconds)}s`;
+    }
+}
+function formatDelegation(d) {
+    const entry = {
+        id: d.id,
+        targetAgent: d.targetAgentId,
+        task: d.task.length > 100 ? d.task.slice(0, 100) + '...' : d.task,
+        status: d.status,
+        duration: formatDuration(d.createdAt, d.completedAt),
+    };
+    if (d.todoIndex !== undefined) {
+        entry.todoIndex = d.todoIndex;
+    }
+    if (d.result) {
+        entry.result = {
+            success: d.result.success,
+            summary: d.result.summary,
+            artifactIds: d.result.artifactIds,
+            ...(d.result.error ? { error: d.result.error } : {}),
+        };
+    }
+    return entry;
+}
+// =============================================================================
+// Tool Definition
+// =============================================================================
+export const delegationStatusTool = defineTool({
+    name: 'delegation_status',
+    description: 'Query the status of tasks delegated via delegate_background. ' +
+        'Returns active delegations by default (pending and running). ' +
+        'Use delegation_id for a specific delegation, agent_id to filter by agent, ' +
+        'or status to see completed/failed/all delegations. ' +
+        'Note: Only tracks delegate_background calls, not foreground delegate.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            delegation_id: {
+                type: 'string',
+                description: 'Specific delegation ID (e.g., "del_abc12345")',
+            },
+            agent_id: {
+                type: 'string',
+                description: 'Filter by target agent (e.g., "dev", "arch")',
+            },
+            status: {
+                type: 'string',
+                enum: ['active', 'completed', 'failed', 'all'],
+                description: 'Filter by status. Default: "active" (pending + running)',
+            },
+        },
+    },
+    execute: async (input) => {
+        const tracker = await Promise.resolve(getDelegationTracker());
+        // Single delegation lookup
+        if (input.delegation_id) {
+            const delegation = tracker.get(input.delegation_id);
+            if (!delegation) {
+                return {
+                    success: false,
+                    error: `Delegation ${input.delegation_id} not found`,
+                };
+            }
+            return {
+                success: true,
+                result: {
+                    delegations: [formatDelegation(delegation)],
+                    stats: tracker.getStats(),
+                },
+            };
+        }
+        // Get all delegations then filter
+        let delegations;
+        if (input.agent_id) {
+            delegations = tracker.getByAgent(input.agent_id);
+        }
+        else {
+            delegations = tracker.getAll();
+        }
+        // Apply status filter
+        const filter = input.status ?? 'active';
+        if (filter !== 'all') {
+            delegations = delegations.filter((d) => {
+                switch (filter) {
+                    case 'active':
+                        return d.status === 'pending' || d.status === 'running';
+                    case 'completed':
+                        return d.status === 'completed';
+                    case 'failed':
+                        return d.status === 'failed';
+                    default:
+                        return true;
+                }
+            });
+        }
+        return {
+            success: true,
+            result: {
+                delegations: delegations.map(formatDelegation),
+                stats: tracker.getStats(),
+            },
+        };
+    },
+});

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

@@ -6,7 +6,7 @@
 /**
  * project_document_add - Add or update a project document
  */
-export declare const projectDocumentAddTool: import("@compilr-dev/agents").Tool<{
+export declare const projectDocumentAddTool: import("@compilr-dev/sdk").Tool<{
     project_id?: number;
     doc_type: string;
     title: string;
@@ -15,27 +15,27 @@ export declare const projectDocumentAddTool: import("@compilr-dev/agents").Tool<
 /**
  * project_document_get - Get a project document
  */
-export declare const projectDocumentGetTool: import("@compilr-dev/agents").Tool<{
+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/agents").Tool<{
+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/agents").Tool<{
+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/agents").Tool<{
+export declare const documentDbTools: import("@compilr-dev/sdk").Tool<{
     project_id?: number;
     doc_type: string;
     title: string;

package/dist/tools/document-db.js

@@ -3,7 +3,7 @@
  *
  * Tools for managing project documents (PRD, architecture, design notes) in the database.
  */
-import { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/agents';
+import { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/sdk';
 import { documentRepository } from '../db/repositories/index.js';
 import { getActiveProject } from './project-db.js';
 /**