@compilr-dev/cli 0.8.7 → 0.8.9

package/dist/episodes/work-summary-anchor.js

@@ -1,73 +0,0 @@
-/**
- * Work Summary Anchor
- *
- * Manages an auto-generated anchor that summarizes work done in the current session.
- * Updated automatically after each episode batch is flushed.
- */
-const ANCHOR_TAG = 'episode-work-summary';
-/**
- * Build the anchor content string from the store's work summary.
- * Returns null when there are no episodes to summarize.
- */
-export function buildWorkSummaryContent(summary) {
-    if (summary.episodeCount === 0)
-        return null;
-    const lines = ['[Session Work Summary]'];
-    lines.push(`Episodes: ${String(summary.episodeCount)}, Effort: ${summary.totalEffort}, Time: ${formatMs(summary.timeSpentMs)}`);
-    if (summary.agentBreakdown.length > 0) {
-        const agents = summary.agentBreakdown
-            .map(a => `${a.agentId}(${String(a.episodeCount)})`)
-            .join(', ');
-        lines.push(`Agents: ${agents}`);
-    }
-    if (summary.topFiles.length > 0) {
-        const files = summary.topFiles.slice(0, 5)
-            .map(f => f.path.split('/').pop() ?? f.path)
-            .join(', ');
-        lines.push(`Top files: ${files}`);
-    }
-    if (summary.uncommittedWork.length > 0) {
-        lines.push(`Uncommitted: ${String(summary.uncommittedWork.length)} episode(s)`);
-    }
-    return lines.join('\n');
-}
-/**
- * Update the work summary anchor for a project.
- * Removes existing anchor (if any) and adds updated one.
- */
-export function updateWorkSummaryAnchor(config) {
-    const { store, projectId, getAnchorManager: getManager } = config;
-    const manager = getManager(projectId);
-    const summary = store.getWorkSummary();
-    const content = buildWorkSummaryContent(summary);
-    // Remove existing work summary anchor
-    const existing = manager.getAll().find((a) => a.tags?.includes(ANCHOR_TAG));
-    if (existing)
-        manager.remove(existing.id);
-    // Add new anchor if there's content
-    if (content) {
-        manager.add({
-            content,
-            priority: 'info',
-            scope: 'persistent',
-            tags: [ANCHOR_TAG],
-            projectId,
-        });
-    }
-}
-/**
- * Format milliseconds to a human-readable string (e.g., "2h 15m", "45s").
- */
-function formatMs(ms) {
-    if (ms < 1000)
-        return `${String(ms)}ms`;
-    const totalSeconds = Math.floor(ms / 1000);
-    if (totalSeconds < 60)
-        return `${String(totalSeconds)}s`;
-    const minutes = Math.floor(totalSeconds / 60);
-    if (minutes < 60)
-        return `${String(minutes)}m`;
-    const hours = Math.floor(minutes / 60);
-    const remainingMinutes = minutes % 60;
-    return remainingMinutes > 0 ? `${String(hours)}h ${String(remainingMinutes)}m` : `${String(hours)}h`;
-}

package/dist/tools/consult.d.ts

@@ -1,14 +0,0 @@
-/**
- * Consult Tool — Specialist-to-Specialist Sync Borrow
- *
- * The CLI surfaces the SDK's `consult` semantic via a thin wrapper around
- * the registered consult handler (same pattern as handoff). The actual
- * sub-run of the target agent lives in `handlers/delegation-handlers.ts`.
- *
- * Spec: project-docs/00-requirements/compilr-dev-sdk/consult-tool-spec.md
- */
-export declare const consultTool: import("@compilr-dev/sdk").Tool<{
-    agentId: string;
-    question: string;
-    context?: string;
-}>;

package/dist/tools/consult.js

@@ -1,73 +0,0 @@
-/**
- * Consult Tool — Specialist-to-Specialist Sync Borrow
- *
- * The CLI surfaces the SDK's `consult` semantic via a thin wrapper around
- * the registered consult handler (same pattern as handoff). The actual
- * sub-run of the target agent lives in `handlers/delegation-handlers.ts`.
- *
- * Spec: project-docs/00-requirements/compilr-dev-sdk/consult-tool-spec.md
- */
-import { defineTool } from '@compilr-dev/sdk';
-import { getConsultHandler } from '../shared-handlers.js';
-export const consultTool = defineTool({
-    name: 'consult',
-    description: 'Ask another specialist a focused question and continue the conversation yourself. ' +
-        'Use this when you need a quick opinion or expertise input from a teammate without giving up the conversation. ' +
-        'Unlike handoff, you keep ownership — the target answers and control returns to you. ' +
-        'Example: $arch can consult $pm on scope, get an answer, and continue designing.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            agentId: {
-                type: 'string',
-                description: 'Target specialist agent ID to consult (e.g., "pm", "qa", "dev"). ' +
-                    'Cannot be yourself or "default" (use handoff to escalate to the coordinator).',
-            },
-            question: {
-                type: 'string',
-                description: 'The focused question you want answered — be specific.',
-            },
-            context: {
-                type: 'string',
-                description: 'Optional supporting material the target needs to answer well ' +
-                    '(code snippet, design constraint, current state, etc.).',
-            },
-        },
-        required: ['agentId', 'question'],
-    },
-    execute: async (input) => {
-        if (!input.agentId || input.agentId.trim().length === 0) {
-            return { success: false, error: 'agentId is required' };
-        }
-        if (!input.question || input.question.trim().length === 0) {
-            return { success: false, error: 'question is required and cannot be empty' };
-        }
-        const handler = getConsultHandler();
-        if (!handler) {
-            return {
-                success: false,
-                error: 'Consult handler not initialized. This tool requires multi-agent mode with a team.',
-            };
-        }
-        try {
-            const result = await handler({
-                agentId: input.agentId.trim(),
-                question: input.question.trim(),
-                context: input.context?.trim() || undefined,
-            });
-            if (result.error) {
-                return { success: false, error: result.error };
-            }
-            return {
-                success: true,
-                result: { answer: result.answer, agentId: result.agentId },
-            };
-        }
-        catch (err) {
-            return {
-                success: false,
-                error: `Consult failed: ${err instanceof Error ? err.message : String(err)}`,
-            };
-        }
-    },
-});

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

@@ -1,27 +0,0 @@
-/**
- * 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

@@ -1,115 +0,0 @@
-/**
- * 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

@@ -1,28 +0,0 @@
-/**
- * Delegate Tool - Multi-Agent Task Delegation (sync, persistent)
- *
- * Allows the coordinator to delegate tasks to specialist agents.
- * Only available to the coordinator (default agent).
- *
- * Behavior (per multi-agent-tools-taxonomy-spec.md §2):
- *   1. Coordinator calls delegate(agentId, task, reason?)
- *   2. CLI shows approval prompt
- *   3. If approved: specialist runs the task INLINE in their persistent
- *      context; response is captured and returned to the coordinator
- *   4. Coordinator stays in charge of the conversation — no permanent
- *      speaker switch
- *   5. If declined: return "User declined" to coordinator (continues working)
- *
- * For sync-without-persistence use `consult`. For async + tracking use
- * `delegate_background`. For permanent baton-pass use `handoff`.
- */
-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

@@ -1,113 +0,0 @@
-/**
- * Delegate Tool - Multi-Agent Task Delegation (sync, persistent)
- *
- * Allows the coordinator to delegate tasks to specialist agents.
- * Only available to the coordinator (default agent).
- *
- * Behavior (per multi-agent-tools-taxonomy-spec.md §2):
- *   1. Coordinator calls delegate(agentId, task, reason?)
- *   2. CLI shows approval prompt
- *   3. If approved: specialist runs the task INLINE in their persistent
- *      context; response is captured and returned to the coordinator
- *   4. Coordinator stays in charge of the conversation — no permanent
- *      speaker switch
- *   5. If declined: return "User declined" to coordinator (continues working)
- *
- * For sync-without-persistence use `consult`. For async + tracking use
- * `delegate_background`. For permanent baton-pass use `handoff`.
- */
-import { defineTool } from '@compilr-dev/sdk';
-import { getDelegateHandler } from '../shared-handlers.js';
-// =============================================================================
-// Tool Definition
-// =============================================================================
-export const delegateTool = defineTool({
-    name: 'delegate',
-    description: 'Delegate a task to a specialist and get their response back. ' +
-        'The specialist runs the task in their persistent context (they remember the work). ' +
-        "You stay in charge — control returns to you with the specialist's response. " +
-        'Use consult if you just want a quick answer without persistence. ' +
-        'Use delegate_background if you want the specialist to work in parallel while you continue. ' +
-        'Use handoff to permanently pass the baton (you stop working). ' +
-        '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: show approval prompt, run specialist inline,
-            // capture response.
-            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,
-                };
-            }
-            // User declined the approval prompt
-            if (result.declined) {
-                const output = {
-                    delegated: false,
-                    agent: input.agentId,
-                    message: 'User declined the delegation. Continue handling the task yourself.',
-                };
-                return { success: true, result: output };
-            }
-            // Approved and specialist ran — surface the response so the coordinator's
-            // LLM sees it as the tool result body.
-            const output = {
-                delegated: true,
-                agent: result.agentId ?? input.agentId,
-                response: result.response,
-            };
-            return { success: true, result: output };
-        }
-        catch (err) {
-            return {
-                success: false,
-                error: `Delegation failed: ${err instanceof Error ? err.message : String(err)}`,
-            };
-        }
-    },
-});

package/dist/tools/handoff.d.ts

@@ -1,17 +0,0 @@
-/**
- * Handoff Tool - Multi-Agent Task Handoff
- *
- * Uses SDK's createHandoffTool factory with CLI-specific handler.
- * Exported as a static tool that lazily resolves dependencies.
- */
-/**
- * Handoff tool — delegates to the CLI's handoff handler.
- *
- * The handler (registered by delegation-handlers.ts) manages team validation,
- * one-hop enforcement, user approval, and agent switching.
- */
-export declare const handoffTool: import("@compilr-dev/sdk").Tool<{
-    agentId: string;
-    task: string;
-    reason?: string;
-}>;

package/dist/tools/handoff.js

@@ -1,79 +0,0 @@
-/**
- * Handoff Tool - Multi-Agent Task Handoff
- *
- * Uses SDK's createHandoffTool factory with CLI-specific handler.
- * Exported as a static tool that lazily resolves dependencies.
- */
-import { defineTool } from '@compilr-dev/sdk';
-import { getHandoffHandler } from '../shared-handlers.js';
-/**
- * Handoff tool — delegates to the CLI's handoff handler.
- *
- * The handler (registered by delegation-handlers.ts) manages team validation,
- * one-hop enforcement, user approval, and agent switching.
- */
-export const handoffTool = defineTool({
-    name: 'handoff',
-    description: 'Hand off the current task to another team agent. ' +
-        'Use this when a task is outside your expertise or would benefit from another specialist. ' +
-        'The user will be asked to approve the handoff before switching. ' +
-        'Example: hand off architecture questions to $arch, implementation to $dev, testing to $qa.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            agentId: {
-                type: 'string',
-                description: 'Target agent ID (e.g., "arch", "dev", "qa", "default")',
-            },
-            task: {
-                type: 'string',
-                description: 'Task description for the target agent - be specific and clear',
-            },
-            reason: {
-                type: 'string',
-                description: 'Why this agent is better suited for the task (shown to user)',
-            },
-        },
-        required: ['agentId', 'task'],
-    },
-    execute: async (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' };
-        }
-        const handoffHandler = getHandoffHandler();
-        if (!handoffHandler) {
-            return {
-                success: false,
-                error: 'Handoff handler not initialized. This tool requires multi-agent mode with a team.',
-            };
-        }
-        try {
-            const result = await handoffHandler({
-                agentId: input.agentId.trim(),
-                task: input.task.trim(),
-                reason: input.reason?.trim(),
-            });
-            if (result.error) {
-                return { success: false, error: result.error };
-            }
-            return {
-                success: true,
-                result: {
-                    handedOff: !result.declined,
-                    message: result.declined
-                        ? 'User declined the handoff. Continue handling the task yourself.'
-                        : `Task handed off to $${input.agentId}. They will handle it from here.`,
-                },
-            };
-        }
-        catch (err) {
-            return {
-                success: false,
-                error: `Handoff failed: ${err instanceof Error ? err.message : String(err)}`,
-            };
-        }
-    },
-});

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

@@ -1,31 +0,0 @@
-/**
- * Meta-Tools for Dynamic Tool Loading
- *
- * Thin singleton wrapper over @compilr-dev/sdk's MetaToolsRegistry.
- * Provides the same module-level API used by the CLI while delegating
- * all logic to the SDK's class-based implementation.
- *
- * Instead of declaring all 49 tools (~15K tokens), we declare:
- * 1. A small set of "direct" tools (always available)
- * 2. A get_tool_info meta-tool (always available)
- * 3. A tool index in the system prompt
- * 4. A transparent fallback handler that routes calls to the registry
- */
-import { type Tool, type ToolExecutionResult } from '@compilr-dev/sdk';
-export declare function setMetaToolFilter(filter: string[] | null | undefined): void;
-export declare function getMetaToolFilter(): Set<string> | null;
-export declare function initializeMetaToolRegistry(tools: Tool[]): void;
-export declare function getRegisteredMetaTools(): Tool[];
-export declare function getMetaToolCount(): number;
-export declare function generateToolIndex(): string;
-export declare const listToolsTool: Tool<object>;
-export declare const getToolInfoTool: Tool<object>;
-export declare const useToolTool: Tool<object>;
-export declare const metaTools: Tool<object>[];
-export declare function createMetaToolFallback(): (name: string, input: Record<string, unknown>) => Promise<ToolExecutionResult | null>;
-/**
- * Generate a filtered tool index showing only tools in the given set.
- * Sets the registry filter, generates the index, then restores the previous filter.
- */
-export declare function generateFilteredToolIndex(activeToolNames: string[]): string;
-export declare const META_TOOLS_SYSTEM_PROMPT_PREFIX = "\n## Tool Index (Specialized Tools)\n\nThese tools are called **exactly like direct tools** \u2014 just use the tool name with parameters. No special syntax or wrapper needed. The system routes them automatically.\n\n**IMPORTANT \u2014 These are CLI system tools, NOT your project's backend. Never use localhost/curl to access them.**\n\n**Parameter Rules:**\n- For **zero-parameter calls**: call the tool directly (e.g., `workitem_query()`, `git_status()`).\n- For **calls WITH parameters**: you MUST call `get_tool_info(\"tool_name\")` first to get parameter details. The signatures below are summaries only \u2014 do NOT guess parameter structure from them.\n- After a failed tool call, always call `get_tool_info()` before retrying.\n\n";

package/dist/tools/meta-tools.js

@@ -1,78 +0,0 @@
-/**
- * Meta-Tools for Dynamic Tool Loading
- *
- * Thin singleton wrapper over @compilr-dev/sdk's MetaToolsRegistry.
- * Provides the same module-level API used by the CLI while delegating
- * all logic to the SDK's class-based implementation.
- *
- * Instead of declaring all 49 tools (~15K tokens), we declare:
- * 1. A small set of "direct" tools (always available)
- * 2. A get_tool_info meta-tool (always available)
- * 3. A tool index in the system prompt
- * 4. A transparent fallback handler that routes calls to the registry
- */
-import { MetaToolsRegistry, createMetaTools, META_TOOLS_SYSTEM_PROMPT_PREFIX as SDK_META_TOOLS_SYSTEM_PROMPT_PREFIX, } from '@compilr-dev/sdk';
-import { getCapabilityManager } from '../multi-agent/capability-loader.js';
-// Singleton registry for the CLI process
-const registry = new MetaToolsRegistry();
-/**
- * Auto-load callback shared by both use_tool and createFallback paths.
- * When a tool is blocked by the capability filter, this loads the pack
- * and updates the filter so the tool executes in the same turn.
- */
-function onFilteredTool(toolName) {
-    const manager = getCapabilityManager();
-    if (!manager)
-        return false;
-    const packId = manager.findPackForTool(toolName);
-    if (!packId || manager.isLoaded(packId))
-        return false;
-    if (manager.getTier(packId) !== 'loadable')
-        return false;
-    manager.load(packId, 'auto-load');
-    // Minimal filter rebuild — next BeforeLLM turn does the full rebuild with orphans
-    registry.setFilter(manager.getActiveToolNames());
-    return true;
-}
-const metaToolSet = createMetaTools(registry, { onFilteredTool });
-// =============================================================================
-// Module-level API (same signatures as before)
-// =============================================================================
-export function setMetaToolFilter(filter) {
-    registry.setFilter(filter);
-}
-export function getMetaToolFilter() {
-    return registry.getFilter();
-}
-export function initializeMetaToolRegistry(tools) {
-    registry.initialize(tools);
-}
-export function getRegisteredMetaTools() {
-    return registry.getRegisteredTools();
-}
-export function getMetaToolCount() {
-    return registry.getToolCount();
-}
-export function generateToolIndex() {
-    return registry.generateToolIndex();
-}
-// Re-export tool instances
-export const listToolsTool = metaToolSet.listToolsTool;
-export const getToolInfoTool = metaToolSet.getToolInfoTool;
-export const useToolTool = metaToolSet.useToolTool;
-export const metaTools = [listToolsTool, getToolInfoTool, useToolTool];
-export function createMetaToolFallback() {
-    return metaToolSet.createFallback({ onFilteredTool });
-}
-/**
- * Generate a filtered tool index showing only tools in the given set.
- * Sets the registry filter, generates the index, then restores the previous filter.
- */
-export function generateFilteredToolIndex(activeToolNames) {
-    const previousFilter = registry.getFilter();
-    registry.setFilter(activeToolNames);
-    const index = registry.generateToolIndex();
-    registry.setFilter(previousFilter ? [...previousFilter] : null);
-    return index;
-}
-export const META_TOOLS_SYSTEM_PROMPT_PREFIX = SDK_META_TOOLS_SYSTEM_PROMPT_PREFIX;