@compilr-dev/cli 0.6.1 → 0.6.3

package/dist/multi-agent/context-resolver.js

@@ -1,316 +0,0 @@
-/**
- * ContextResolver - Resolve $agent mentions to actual content
- *
- * Resolution strategy:
- * 1. Check for explicit artifact reference in context hint
- * 2. Search artifacts by name/content matching context hint
- * 3. Fall back to recent conversation history
- *
- * Token budgets:
- * - Single mention: 2000 tokens max
- * - Multiple mentions: 3000 tokens total, split among mentions
- */
-// =============================================================================
-// Constants
-// =============================================================================
-const DEFAULT_MAX_TOKENS_PER_MENTION = 2000;
-const DEFAULT_MAX_TOTAL_TOKENS = 3000;
-const DEFAULT_MAX_HISTORY_MESSAGES = 10;
-// Token counting via tiktoken
-import { estimateTokens } from '../utils/token-tracker.js';
-// =============================================================================
-// ContextResolver
-// =============================================================================
-/**
- * Resolve mentions to actual content
- */
-export class ContextResolver {
-    team;
-    artifactStore;
-    constructor(team, artifactStore) {
-        this.team = team;
-        this.artifactStore = artifactStore;
-    }
-    /**
-     * Resolve multiple mentions
-     */
-    resolveAll(mentions, options = {}) {
-        const maxTotal = options.maxTotalTokens ?? DEFAULT_MAX_TOTAL_TOKENS;
-        const perMention = options.maxTokensPerMention ?? DEFAULT_MAX_TOKENS_PER_MENTION;
-        // Calculate budget per mention
-        const budgetPerMention = Math.min(perMention, Math.floor(maxTotal / mentions.length));
-        const results = new Map();
-        let totalTokens = 0;
-        for (const mention of mentions) {
-            // Skip if we're out of budget
-            if (totalTokens >= maxTotal) {
-                results.set(mention.agentId, {
-                    mention,
-                    resolved: false,
-                    source: 'not_found',
-                    sourceName: 'budget exceeded',
-                    content: '',
-                    tokenCount: 0,
-                });
-                continue;
-            }
-            const remainingBudget = Math.min(budgetPerMention, maxTotal - totalTokens);
-            const resolved = this.resolveMention(mention, {
-                ...options,
-                maxTokensPerMention: remainingBudget,
-            });
-            results.set(mention.agentId, resolved);
-            totalTokens += resolved.tokenCount;
-        }
-        return results;
-    }
-    /**
-     * Resolve a single mention
-     */
-    resolveMention(mention, options = {}) {
-        const maxTokens = options.maxTokensPerMention ?? DEFAULT_MAX_TOKENS_PER_MENTION;
-        // 1. Try to find matching artifact
-        const artifactResult = this.resolveFromArtifacts(mention, maxTokens, options);
-        if (artifactResult) {
-            return artifactResult;
-        }
-        // 2. Try to extract from conversation history
-        const historyResult = this.resolveFromHistory(mention, maxTokens, options);
-        if (historyResult) {
-            return historyResult;
-        }
-        // 3. Not found
-        return {
-            mention,
-            resolved: false,
-            source: 'not_found',
-            sourceName: 'no relevant content found',
-            content: '',
-            tokenCount: 0,
-        };
-    }
-    /**
-     * Resolve from artifacts
-     */
-    resolveFromArtifacts(mention, maxTokens, options) {
-        const { agentId, context } = mention;
-        // Get artifacts by this agent
-        const agentArtifacts = this.artifactStore.listByAgent(agentId);
-        if (agentArtifacts.length === 0) {
-            return null;
-        }
-        // Sort artifacts by most recent first
-        const sortedArtifacts = agentArtifacts
-            .sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
-        // Find matching artifact based on context hint
-        let matchedArtifact;
-        if (context) {
-            // Search by name or content
-            const searchResults = this.artifactStore.search(context);
-            const searchMatch = searchResults.find(a => a.agent === agentId);
-            // Use search match if found, otherwise fall back to most recent
-            matchedArtifact = searchMatch ?? sortedArtifacts[0];
-        }
-        else {
-            // No context hint - use most recent artifact
-            matchedArtifact = sortedArtifacts[0];
-        }
-        // Format artifact content
-        let content;
-        let tokenCount;
-        if (options.includeFullArtifact) {
-            content = this.formatArtifactFull(matchedArtifact);
-            tokenCount = estimateTokens(content);
-            // If over budget, fall back to summary
-            if (tokenCount > maxTokens) {
-                content = this.formatArtifactSummary(matchedArtifact);
-                tokenCount = estimateTokens(content);
-            }
-        }
-        else {
-            // Start with summary, include full if within budget
-            const summary = this.formatArtifactSummary(matchedArtifact);
-            const full = this.formatArtifactFull(matchedArtifact);
-            if (estimateTokens(full) <= maxTokens) {
-                content = full;
-            }
-            else {
-                content = summary;
-            }
-            tokenCount = estimateTokens(content);
-        }
-        return {
-            mention,
-            resolved: true,
-            source: 'artifact',
-            sourceName: matchedArtifact.name,
-            content,
-            tokenCount,
-        };
-    }
-    /**
-     * Resolve from conversation history
-     */
-    resolveFromHistory(mention, maxTokens, options) {
-        const { agentId, context } = mention;
-        const maxMessages = options.maxHistoryMessages ?? DEFAULT_MAX_HISTORY_MESSAGES;
-        // Get the team agent
-        const teamAgent = this.team.get(agentId);
-        if (!teamAgent) {
-            return null;
-        }
-        // Get the underlying agent
-        const agent = teamAgent.agent;
-        if (!agent) {
-            return null;
-        }
-        // Get recent messages from the agent's history
-        const state = agent.serialize();
-        const messages = state.messages;
-        if (messages.length === 0) {
-            return null;
-        }
-        // Get assistant messages (agent's responses)
-        const assistantMessages = messages
-            .filter((m) => m.role === 'assistant')
-            .slice(-maxMessages);
-        if (assistantMessages.length === 0) {
-            return null;
-        }
-        // Extract relevant content
-        let relevantContent;
-        if (context) {
-            // Search for context in messages
-            relevantContent = this.extractRelevantContent(assistantMessages, context, maxTokens);
-        }
-        else {
-            // Use most recent message
-            const lastMessage = assistantMessages[assistantMessages.length - 1];
-            relevantContent = this.formatMessage(lastMessage);
-        }
-        if (!relevantContent) {
-            return null;
-        }
-        // Truncate if needed
-        const tokenCount = estimateTokens(relevantContent);
-        if (tokenCount > maxTokens) {
-            relevantContent = this.truncateToTokens(relevantContent, maxTokens);
-        }
-        return {
-            mention,
-            resolved: true,
-            source: 'history',
-            sourceName: 'recent conversation',
-            content: relevantContent,
-            tokenCount: estimateTokens(relevantContent),
-        };
-    }
-    /**
-     * Extract relevant content from messages based on context hint
-     */
-    extractRelevantContent(messages, context, maxTokens) {
-        const keywords = context.toLowerCase().split(/\s+/).filter(w => w.length > 2);
-        // Score messages by relevance
-        const scored = messages.map(msg => {
-            const content = this.formatMessage(msg);
-            const contentLower = content.toLowerCase();
-            let score = 0;
-            for (const keyword of keywords) {
-                if (contentLower.includes(keyword)) {
-                    score += 1;
-                }
-            }
-            return { content, score };
-        });
-        // Sort by score (highest first)
-        scored.sort((a, b) => b.score - a.score);
-        // Take best matches within token budget
-        const results = [];
-        let totalTokens = 0;
-        for (const { content, score } of scored) {
-            if (score === 0)
-                continue;
-            const tokens = estimateTokens(content);
-            if (totalTokens + tokens > maxTokens) {
-                // Try to include truncated version
-                const remaining = maxTokens - totalTokens;
-                if (remaining > 100) {
-                    results.push(this.truncateToTokens(content, remaining));
-                }
-                break;
-            }
-            results.push(content);
-            totalTokens += tokens;
-        }
-        return results.join('\n\n---\n\n');
-    }
-    /**
-     * Format a message for injection
-     */
-    formatMessage(message) {
-        if (typeof message.content === 'string') {
-            return message.content;
-        }
-        // Handle array content (Claude format)
-        if (Array.isArray(message.content)) {
-            const blocks = message.content;
-            return blocks
-                .filter((block) => block.type === 'text' && typeof block.text === 'string')
-                .map(block => block.text)
-                .join('\n');
-        }
-        return String(message.content);
-    }
-    /**
-     * Format artifact with full content
-     */
-    formatArtifactFull(artifact) {
-        return [
-            `**${artifact.name}** (${artifact.type})`,
-            `By: $${artifact.agent} | Updated: ${artifact.updatedAt.toLocaleDateString()}`,
-            '',
-            artifact.content,
-        ].join('\n');
-    }
-    /**
-     * Format artifact with summary only
-     */
-    formatArtifactSummary(artifact) {
-        return [
-            `**${artifact.name}** (${artifact.type})`,
-            `By: $${artifact.agent} | Updated: ${artifact.updatedAt.toLocaleDateString()}`,
-            '',
-            `Summary: ${artifact.summary}`,
-            '',
-            `[Full content available via: /artifact view "${artifact.name}"]`,
-        ].join('\n');
-    }
-    /**
-     * Truncate content to approximate token count
-     */
-    truncateToTokens(content, maxTokens) {
-        const maxChars = maxTokens * 4;
-        if (content.length <= maxChars) {
-            return content;
-        }
-        // Truncate at word boundary
-        const truncated = content.slice(0, maxChars);
-        const lastSpace = truncated.lastIndexOf(' ');
-        if (lastSpace > maxChars * 0.8) {
-            return truncated.slice(0, lastSpace) + '...';
-        }
-        return truncated + '...';
-    }
-}
-/**
- * Build a context map from resolved mentions
- */
-export function buildContextMap(resolved) {
-    const contextMap = new Map();
-    for (const [agentId, resolution] of resolved) {
-        if (resolution.resolved && resolution.content) {
-            contextMap.set(agentId, resolution.content);
-        }
-    }
-    return contextMap;
-}

package/dist/multi-agent/mention-parser.d.ts

@@ -1,64 +0,0 @@
-/**
- * MentionParser - Parse $agent references in user input
- *
- * Two types of $agent usage:
- * 1. Switch: "$arch message" at start of input → switch to arch, send message
- * 2. Reference: "what did $arch propose" mid-sentence → inject arch's context
- *
- * Detection rule: $name at START of trimmed input = switch. Otherwise = reference.
- */
-/**
- * A parsed mention in the input
- */
-export interface ParsedMention {
-    /** Agent ID without $ prefix */
-    agentId: string;
-    /** Position in original input */
-    startIndex: number;
-    endIndex: number;
-    /** The full match including $ prefix */
-    raw: string;
-    /** Optional query/context after the agent name */
-    context?: string;
-}
-/**
- * Result of parsing user input for mentions
- */
-export interface ParsedInput {
-    /** Original input text */
-    original: string;
-    /** Whether the input starts with a switch ($agent at beginning) */
-    hasSwitch: boolean;
-    /** The switch target agent (if hasSwitch is true) */
-    switchTarget?: string;
-    /** Message to send after switching (if hasSwitch is true) */
-    messageAfterSwitch?: string;
-    /** All reference mentions (mid-sentence $agent) */
-    references: ParsedMention[];
-    /** Input with mentions replaced by placeholders for context injection */
-    normalizedInput: string;
-}
-/**
- * Parse user input for $agent mentions
- *
- * @param input - User input string
- * @param validAgents - Set of valid agent IDs (for validation)
- * @returns Parsed input with mentions identified
- */
-export declare function parseInputForMentions(input: string, validAgents?: Set<string>): ParsedInput;
-/**
- * Get unique agent IDs from references
- */
-export declare function getReferencedAgents(parsed: ParsedInput): string[];
-/**
- * Check if input contains any references (not just switch)
- */
-export declare function hasReferences(parsed: ParsedInput): boolean;
-/**
- * Build a message with context injected for mentions
- *
- * @param parsed - Parsed input
- * @param contextMap - Map of agentId → resolved context string
- * @returns Message with context prepended or injected
- */
-export declare function buildMessageWithContext(parsed: ParsedInput, contextMap: Map<string, string>): string;

package/dist/multi-agent/mention-parser.js

@@ -1,146 +0,0 @@
-/**
- * MentionParser - Parse $agent references in user input
- *
- * Two types of $agent usage:
- * 1. Switch: "$arch message" at start of input → switch to arch, send message
- * 2. Reference: "what did $arch propose" mid-sentence → inject arch's context
- *
- * Detection rule: $name at START of trimmed input = switch. Otherwise = reference.
- */
-// =============================================================================
-// Constants
-// =============================================================================
-// Match $agentname pattern - alphanumeric and underscore/hyphen
-const MENTION_PATTERN = /\$([a-zA-Z][a-zA-Z0-9_-]*)/g;
-// Match $agent at start of input (for switch detection)
-const SWITCH_PATTERN = /^\$([a-zA-Z][a-zA-Z0-9_-]*)\s*/;
-// =============================================================================
-// Parser
-// =============================================================================
-/**
- * Parse user input for $agent mentions
- *
- * @param input - User input string
- * @param validAgents - Set of valid agent IDs (for validation)
- * @returns Parsed input with mentions identified
- */
-export function parseInputForMentions(input, validAgents) {
-    const trimmed = input.trim();
-    // Check for switch pattern at start
-    const switchMatch = trimmed.match(SWITCH_PATTERN);
-    let hasSwitch = false;
-    let switchTarget;
-    let messageAfterSwitch;
-    let searchStart = 0;
-    if (switchMatch) {
-        const agentId = switchMatch[1].toLowerCase();
-        // Only treat as switch if it's a valid agent
-        if (!validAgents || validAgents.has(agentId)) {
-            hasSwitch = true;
-            switchTarget = agentId;
-            messageAfterSwitch = trimmed.slice(switchMatch[0].length).trim();
-            searchStart = switchMatch[0].length; // Skip switch when looking for references
-        }
-    }
-    // Find all reference mentions (excluding the switch)
-    const references = [];
-    MENTION_PATTERN.lastIndex = searchStart;
-    let match;
-    while ((match = MENTION_PATTERN.exec(trimmed)) !== null) {
-        const agentId = match[1].toLowerCase();
-        // Skip if not a valid agent (if validation set provided)
-        if (validAgents && !validAgents.has(agentId)) {
-            continue;
-        }
-        // Skip if this is the switch mention
-        if (hasSwitch && match.index === 0) {
-            continue;
-        }
-        references.push({
-            agentId,
-            startIndex: match.index,
-            endIndex: match.index + match[0].length,
-            raw: match[0],
-        });
-    }
-    // Extract context hints for each reference
-    for (const ref of references) {
-        ref.context = extractContextHint(trimmed, ref.endIndex);
-    }
-    // Build normalized input (with mention placeholders)
-    const normalizedInput = hasSwitch ? messageAfterSwitch ?? '' : trimmed;
-    // For normalized input, we keep mentions as-is but could replace with markers
-    // This is useful for the resolver to know where to inject context
-    return {
-        original: input,
-        hasSwitch,
-        switchTarget,
-        messageAfterSwitch,
-        references,
-        normalizedInput,
-    };
-}
-/**
- * Extract a context hint following a mention
- *
- * Examples:
- * - "what did $arch propose for the API" → "propose for the API"
- * - "review $qa's feedback on the PR" → "'s feedback on the PR"
- * - "based on $arch" → undefined
- */
-function extractContextHint(text, afterIndex) {
-    const remaining = text.slice(afterIndex);
-    // Common patterns that provide context:
-    // - "'s <noun>" (possessive)
-    // - " <verb> <object>" (action)
-    // - " about <topic>"
-    // - " for <topic>"
-    // - " on <topic>"
-    // Get up to end of sentence or 50 chars
-    const endMatch = remaining.match(/^[^.!?\n]{0,50}/);
-    if (!endMatch || endMatch[0].trim().length < 3) {
-        return undefined;
-    }
-    return endMatch[0].trim();
-}
-/**
- * Get unique agent IDs from references
- */
-export function getReferencedAgents(parsed) {
-    const agents = new Set();
-    for (const ref of parsed.references) {
-        agents.add(ref.agentId);
-    }
-    return Array.from(agents);
-}
-/**
- * Check if input contains any references (not just switch)
- */
-export function hasReferences(parsed) {
-    return parsed.references.length > 0;
-}
-/**
- * Build a message with context injected for mentions
- *
- * @param parsed - Parsed input
- * @param contextMap - Map of agentId → resolved context string
- * @returns Message with context prepended or injected
- */
-export function buildMessageWithContext(parsed, contextMap) {
-    if (parsed.references.length === 0) {
-        return parsed.normalizedInput;
-    }
-    // Collect context blocks
-    const contextBlocks = [];
-    for (const ref of parsed.references) {
-        const context = contextMap.get(ref.agentId);
-        if (context) {
-            contextBlocks.push(`[Context from $${ref.agentId}:\n${context}\n]`);
-        }
-    }
-    if (contextBlocks.length === 0) {
-        return parsed.normalizedInput;
-    }
-    // Prepend context blocks to the message
-    return `${contextBlocks.join('\n\n')}\n\n${parsed.normalizedInput}`;
-}