@webpresso/agent-kit 0.21.0

package/dist/esm/ai-prompts/persona-context.js

@@ -0,0 +1,158 @@
+import { match } from 'ts-pattern';
+function addBusinessGrowthMetrics(lines, growth) {
+    if (!growth)
+        return;
+    lines.push('Growth:');
+    if (growth.mrrGrowth !== undefined)
+        lines.push(`  - MRR Growth: ${growth.mrrGrowth}%`);
+    if (growth.userGrowth !== undefined)
+        lines.push(`  - User Growth: ${growth.userGrowth}%`);
+    if (growth.period)
+        lines.push(`  - Period: ${growth.period}`);
+}
+function addBusinessMetrics(lines, ctx) {
+    if (ctx.mrr !== undefined)
+        lines.push(`MRR: $${ctx.mrr.toLocaleString()}`);
+    if (ctx.arr !== undefined)
+        lines.push(`ARR: $${ctx.arr.toLocaleString()}`);
+    if (ctx.mau !== undefined)
+        lines.push(`MAU: ${ctx.mau.toLocaleString()}`);
+    if (ctx.dau !== undefined)
+        lines.push(`DAU: ${ctx.dau.toLocaleString()}`);
+    if (ctx.cac !== undefined)
+        lines.push(`CAC: $${ctx.cac}`);
+    if (ctx.ltv !== undefined)
+        lines.push(`LTV: $${ctx.ltv}`);
+    if (ctx.churnRate !== undefined)
+        lines.push(`Churn Rate: ${ctx.churnRate}%`);
+    if (ctx.conversionRate !== undefined)
+        lines.push(`Conversion Rate: ${ctx.conversionRate}%`);
+}
+function addBusinessPriorities(lines, priorities) {
+    if (!priorities?.length)
+        return;
+    lines.push('Strategic Priorities:');
+    for (const priority of priorities) {
+        lines.push(`  - ${priority}`);
+    }
+}
+function formatBusinessContext(ctx) {
+    const lines = ['<business_context>'];
+    addBusinessMetrics(lines, ctx);
+    addBusinessGrowthMetrics(lines, ctx.growth);
+    if (ctx.competitors?.length) {
+        lines.push(`Competitors: ${ctx.competitors.join(', ')}`);
+    }
+    addBusinessPriorities(lines, ctx.priorities);
+    lines.push('</business_context>');
+    return lines.join('\n');
+}
+function addFeedbackThemes(lines, feedbackThemes) {
+    if (!feedbackThemes?.length)
+        return;
+    lines.push('User Feedback Themes:');
+    for (const theme of feedbackThemes) {
+        lines.push(`  - ${theme.theme} (${theme.count} mentions, ${theme.sentiment})`);
+    }
+}
+function addFeatureRequests(lines, featureRequests) {
+    if (!featureRequests?.length)
+        return;
+    lines.push('Top Feature Requests:');
+    for (const req of featureRequests.slice(0, 5)) {
+        lines.push(`  - ${req.title} (${req.votes} votes, ${req.status})`);
+    }
+}
+function addFunnelMetrics(lines, funnelMetrics) {
+    if (!funnelMetrics?.length)
+        return;
+    lines.push('Funnel Drop-off Rates:');
+    for (const step of funnelMetrics) {
+        lines.push(`  - ${step.step}: ${step.dropOffRate}%`);
+    }
+}
+function formatProductContext(ctx) {
+    const lines = ['<product_context>'];
+    if (ctx.nps !== undefined)
+        lines.push(`NPS Score: ${ctx.nps}`);
+    if (ctx.csat !== undefined)
+        lines.push(`CSAT Score: ${ctx.csat}`);
+    if (ctx.accessibilityScore !== undefined)
+        lines.push(`Accessibility Score: ${ctx.accessibilityScore}/100`);
+    addFeedbackThemes(lines, ctx.feedbackThemes);
+    addFeatureRequests(lines, ctx.featureRequests);
+    addFunnelMetrics(lines, ctx.funnelMetrics);
+    if (ctx.supportThemes?.length) {
+        lines.push(`Support Ticket Themes: ${ctx.supportThemes.join(', ')}`);
+    }
+    if (ctx.userPersonas?.length) {
+        lines.push(`User Personas: ${ctx.userPersonas.join(', ')}`);
+    }
+    lines.push('</product_context>');
+    return lines.join('\n');
+}
+function addPerformanceMetrics(lines, performance) {
+    if (!performance)
+        return;
+    lines.push('Performance:');
+    if (performance.p50Latency !== undefined)
+        lines.push(`  - P50 Latency: ${performance.p50Latency}ms`);
+    if (performance.p95Latency !== undefined)
+        lines.push(`  - P95 Latency: ${performance.p95Latency}ms`);
+    if (performance.p99Latency !== undefined)
+        lines.push(`  - P99 Latency: ${performance.p99Latency}ms`);
+}
+function addTechDebtItems(lines, techDebt) {
+    if (!techDebt?.length)
+        return;
+    lines.push('Tech Debt:');
+    for (const item of techDebt.slice(0, 5)) {
+        lines.push(`  - [${item.severity}] ${item.description}${item.file ? ` (${item.file})` : ''}`);
+    }
+}
+function addVulnerabilityItems(lines, vulnerabilities) {
+    if (!vulnerabilities?.length)
+        return;
+    lines.push('Vulnerabilities:');
+    for (const vuln of vulnerabilities.slice(0, 5)) {
+        lines.push(`  - [${vuln.severity}] ${vuln.package} (fix ${vuln.fixAvailable ? 'available' : 'not available'})`);
+    }
+}
+function formatEngineeringContext(ctx) {
+    const lines = ['<engineering_context>'];
+    if (ctx.testCoverage !== undefined)
+        lines.push(`Test Coverage: ${ctx.testCoverage}%`);
+    if (ctx.lintErrors !== undefined)
+        lines.push(`Lint Errors: ${ctx.lintErrors}`);
+    if (ctx.typeErrors !== undefined)
+        lines.push(`Type Errors: ${ctx.typeErrors}`);
+    if (ctx.errorRate !== undefined)
+        lines.push(`Error Rate: ${ctx.errorRate}%`);
+    if (ctx.buildStatus)
+        lines.push(`Build Status: ${ctx.buildStatus}`);
+    if (ctx.openPRs !== undefined)
+        lines.push(`Open PRs: ${ctx.openPRs}`);
+    addPerformanceMetrics(lines, ctx.performance);
+    addTechDebtItems(lines, ctx.techDebt);
+    addVulnerabilityItems(lines, ctx.vulnerabilities);
+    lines.push('</engineering_context>');
+    return lines.join('\n');
+}
+export function formatPersonaContext(persona, context) {
+    return match(persona)
+        .with('steve', () => (context.business ? formatBusinessContext(context.business) : undefined))
+        .with('rachel', () => (context.product ? formatProductContext(context.product) : undefined))
+        .with('ozby', () => context.engineering ? formatEngineeringContext(context.engineering) : undefined)
+        .with('volker', 'jeramy', 'rodrigo', () => {
+        return;
+    })
+        .exhaustive();
+}
+export function getPersonaContextHeader(persona) {
+    return match(persona)
+        .with('steve', () => '# Business Intelligence')
+        .with('rachel', () => '# Product & User Insights')
+        .with('ozby', () => '# Engineering Metrics')
+        .otherwise(() => '# Context');
+}
+//# sourceMappingURL=persona-context.js.map

package/dist/esm/ai-prompts/persona-debate.d.ts

@@ -0,0 +1,67 @@
+import type { AgentPersona } from './types.js';
+export interface AgentContribution {
+    persona: AgentPersona;
+    content: string;
+    position?: 'approve' | 'reject' | 'abstain' | 'needs_clarification';
+    confidence?: number;
+    keyPoints?: string[];
+    timestamp: Date;
+}
+export interface DebateRound {
+    roundNumber: number;
+    topic: string;
+    contributions: AgentContribution[];
+    summary?: string;
+}
+export interface DebateOutcome {
+    consensusReached: boolean;
+    decision: 'approved' | 'rejected' | 'needs_more_info' | 'escalate_to_human';
+    confidence: number;
+    summary: string;
+    agreements: string[];
+    disagreements: string[];
+    actionItems?: string[];
+    votes: Record<AgentPersona, 'approve' | 'reject' | 'abstain' | 'needs_clarification'>;
+}
+export type DebateType = 'feature_review' | 'bug_priority' | 'technical_decision' | 'sprint_planning' | 'user_story_refinement';
+export interface DebateConfig {
+    type: DebateType;
+    topic: string;
+    context?: string;
+    maxRounds?: number;
+    consensusThreshold?: number;
+    participants?: AgentPersona[];
+    useModerator?: boolean;
+    moderator?: AgentPersona;
+    verbose?: boolean;
+}
+export declare const DEFAULT_DEBATE_CONFIG: Required<Omit<DebateConfig, 'type' | 'topic' | 'context'>>;
+export interface DebateState {
+    id: string;
+    config: DebateConfig;
+    rounds: DebateRound[];
+    status: 'in_progress' | 'consensus_reached' | 'max_rounds_exceeded' | 'escalated';
+    outcome?: DebateOutcome;
+    startedAt: Date;
+    completedAt?: Date;
+}
+export declare const DEBATE_PROMPTS: {
+    readonly initialPrompt: (config: DebateConfig, persona: AgentPersona) => string;
+    readonly followUpPrompt: (config: DebateConfig, persona: AgentPersona, previousRound: DebateRound) => string;
+    readonly moderatorPrompt: (config: DebateConfig, state: DebateState) => string;
+};
+export declare function parsePosition(text: string): 'approve' | 'reject' | 'abstain' | 'needs_clarification';
+export declare function parseConfidence(text: string): number;
+export declare function calculateConsensus(contributions: AgentContribution[]): {
+    hasConsensus: boolean;
+    majorityPosition: 'approve' | 'reject' | 'abstain' | 'needs_clarification';
+    percentAgreement: number;
+    averageConfidence: number;
+};
+export declare function generateDebateId(): string;
+export declare function createDebateState(config: DebateConfig): DebateState;
+export declare function addContribution(state: DebateState, contribution: AgentContribution): DebateState;
+export declare function startNewRound(state: DebateState, topic?: string): DebateState;
+export declare function finalizeDebate(state: DebateState, outcome: DebateOutcome): DebateState;
+export declare function shouldContinueDebate(state: DebateState): boolean;
+//# sourceMappingURL=persona-debate.d.ts.map

package/dist/esm/ai-prompts/persona-debate.js

@@ -0,0 +1,172 @@
+export const DEFAULT_DEBATE_CONFIG = {
+    maxRounds: 3,
+    consensusThreshold: 0.75,
+    participants: ['steve', 'rachel', 'ozby', 'volker', 'jeramy', 'rodrigo'],
+    useModerator: true,
+    moderator: 'steve',
+    verbose: false,
+};
+export const DEBATE_PROMPTS = {
+    initialPrompt: (config, persona) => {
+        const roleContext = {
+            steve: 'As the Business Strategist, evaluate this from a business viability, revenue impact, and strategic alignment perspective.',
+            rachel: 'As the Product Visionary, evaluate this from a user experience, accessibility, and product-market fit perspective.',
+            ozby: 'As the Engineering Lead, evaluate this from a technical feasibility, code quality, and scalability perspective.',
+            volker: 'As the Clean Code Evangelist, evaluate this from a code quality, testability, and maintainability perspective.',
+            jeramy: 'As the Backend & Cloud Architect, evaluate this from a scalability, data flow, and infrastructure cost perspective.',
+            rodrigo: 'As the Sustainability & Supply Chain CTO, evaluate this from a supply chain complexity, enterprise scalability, and sustainability perspective.',
+        };
+        return `<debate_context>\n<type>${config.type}</type>\n<topic>${config.topic}</topic>\n${config.context ? `<additional_context>${config.context}</additional_context>` : ''}\n</debate_context>\n\n<instructions>\n${roleContext[persona]}\n\nProvide your initial assessment with:\n1. Your position: approve, reject, needs_clarification, or abstain\n2. Your confidence level (0-100%)\n3. Key points supporting your position\n4. Any concerns or questions for other team members\n\nBe concise but thorough. Remember your unique perspective and background.\n</instructions>\n\n<output_format>\nPosition: [Your position]\nConfidence: [0-100]%\nKey Points:\n- [Point 1]\n- [Point 2]\n...\n\nConcerns:\n- [Concern 1]\n...\n\nQuestions for team:\n- [Question 1]\n...\n</output_format>`;
+    },
+    followUpPrompt: (config, persona, previousRound) => {
+        const otherContributions = previousRound.contributions
+            .filter((c) => c.persona !== persona)
+            .map((c) => `<${c.persona}_perspective>\n${c.content}\n</${c.persona}_perspective>`)
+            .join('\n\n');
+        return `<debate_context>\n<type>${config.type}</type>\n<topic>${config.topic}</topic>\n<round>${previousRound.roundNumber + 1}</round>\n</debate_context>\n\n<previous_round>\n${otherContributions}\n</previous_round>\n\n<instructions>\nReview your teammates' perspectives and:\n1. Update your position if their arguments convinced you\n2. Address any concerns raised about your area of expertise\n3. Answer any questions directed at you\n4. Raise any new concerns based on what you've learned\n\nWork towards consensus while maintaining your expert perspective.\n</instructions>\n\n<output_format>\nUpdated Position: [Your position - may be unchanged]\nConfidence: [0-100]%\nResponse to concerns:\n- [Response 1]\n...\n\nUpdated assessment:\n[Your refined view considering others' perspectives]\n</output_format>`;
+    },
+    moderatorPrompt: (config, state) => {
+        const roundSummaries = state.rounds
+            .map((r) => `<round_${r.roundNumber}>\n${r.contributions.map((c) => `${c.persona}: ${c.position} (${Math.round((c.confidence ?? 0.5) * 100)}% confidence)`).join('\n')}\n${r.summary ? `Summary: ${r.summary}` : ''}\n</round_${r.roundNumber}>`)
+            .join('\n\n');
+        return `<debate_summary>\n<type>${config.type}</type>\n<topic>${config.topic}</topic>\n<rounds_completed>${state.rounds.length}</rounds_completed>\n\n${roundSummaries}\n</debate_summary>\n\n<instructions>\nAs the moderator, synthesize the debate and determine the final outcome:\n1. Did the team reach consensus? (>= ${(config.consensusThreshold ?? 0.75) * 100}% agreement)\n2. What is the final decision?\n3. What are the key agreements and disagreements?\n4. What action items should result from this discussion?\n\nIf consensus was not reached, decide whether to:\n- Make a tie-breaking decision based on the strongest arguments\n- Escalate to a human for final decision\n</instructions>\n\n<output_format>\nConsensus Reached: [yes/no]\nFinal Decision: [approved/rejected/needs_more_info/escalate_to_human]\nConfidence: [0-100]%\n\nSummary:\n[2-3 sentence summary of the debate]\n\nAgreements:\n- [Agreement 1]\n...\n\nDisagreements:\n- [Disagreement 1]\n...\n\nAction Items:\n- [Action 1]\n...\n</output_format>`;
+    },
+};
+export function parsePosition(text) {
+    const lower = text.toLowerCase().trim();
+    if (lower.includes('approve') || lower.includes('yes') || lower.includes('accept')) {
+        return 'approve';
+    }
+    if (lower.includes('reject') || lower.includes('no') || lower.includes('deny')) {
+        return 'reject';
+    }
+    if (lower.includes('clarif') || lower.includes('more info') || lower.includes('question')) {
+        return 'needs_clarification';
+    }
+    return 'abstain';
+}
+const CONFIDENCE_KEYWORDS = [
+    { keywords: ['very high', 'certain'], value: 0.95 },
+    { keywords: ['very low', 'uncertain'], value: 0.2 },
+    { keywords: ['high'], value: 0.8 },
+    { keywords: ['medium', 'moderate'], value: 0.6 },
+    { keywords: ['low'], value: 0.4 },
+];
+function parseWordBasedConfidence(text) {
+    const lower = text.toLowerCase();
+    for (const { keywords, value } of CONFIDENCE_KEYWORDS) {
+        if (keywords.some((kw) => lower.includes(kw))) {
+            return value;
+        }
+    }
+    return null;
+}
+export function parseConfidence(text) {
+    const percentMatch = text.match(/(\d+)\s*%/);
+    if (percentMatch?.[1]) {
+        return Math.min(100, Math.max(0, Number.parseInt(percentMatch[1], 10))) / 100;
+    }
+    const decimalMatch = text.match(/0?\.\d+/);
+    if (decimalMatch) {
+        return Math.min(1, Math.max(0, Number.parseFloat(decimalMatch[0])));
+    }
+    return parseWordBasedConfidence(text) ?? 0.5;
+}
+export function calculateConsensus(contributions) {
+    const votes = contributions
+        .map((c) => c.position)
+        .filter((p) => p !== undefined);
+    const voteCounts = votes.reduce((acc, vote) => {
+        acc[vote] = (acc[vote] || 0) + 1;
+        return acc;
+    }, {});
+    const totalVotes = votes.length;
+    const maxVotes = Math.max(...Object.values(voteCounts), 0);
+    const majorityPosition = (Object.entries(voteCounts).find(([_, count]) => count === maxVotes)?.[0] ?? 'abstain');
+    const confidences = contributions
+        .map((c) => c.confidence)
+        .filter((c) => c !== undefined);
+    const averageConfidence = confidences.length > 0 ? confidences.reduce((a, b) => a + b, 0) / confidences.length : 0.5;
+    return {
+        hasConsensus: maxVotes === totalVotes && totalVotes > 0,
+        majorityPosition,
+        percentAgreement: totalVotes > 0 ? maxVotes / totalVotes : 0,
+        averageConfidence,
+    };
+}
+export function generateDebateId() {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 8);
+    return `debate-${timestamp}-${random}`;
+}
+export function createDebateState(config) {
+    return {
+        id: generateDebateId(),
+        config: {
+            ...DEFAULT_DEBATE_CONFIG,
+            ...config,
+        },
+        rounds: [],
+        status: 'in_progress',
+        startedAt: new Date(),
+    };
+}
+export function addContribution(state, contribution) {
+    const currentRound = state.rounds[state.rounds.length - 1];
+    if (!currentRound) {
+        throw new Error('No active round to add contribution to');
+    }
+    return {
+        ...state,
+        rounds: [
+            ...state.rounds.slice(0, -1),
+            {
+                ...currentRound,
+                contributions: [...currentRound.contributions, contribution],
+            },
+        ],
+    };
+}
+export function startNewRound(state, topic) {
+    const roundNumber = state.rounds.length + 1;
+    return {
+        ...state,
+        rounds: [
+            ...state.rounds,
+            {
+                roundNumber,
+                topic: topic ?? state.config.topic,
+                contributions: [],
+            },
+        ],
+    };
+}
+export function finalizeDebate(state, outcome) {
+    return {
+        ...state,
+        status: outcome.consensusReached
+            ? 'consensus_reached'
+            : outcome.decision === 'escalate_to_human'
+                ? 'escalated'
+                : 'max_rounds_exceeded',
+        outcome,
+        completedAt: new Date(),
+    };
+}
+export function shouldContinueDebate(state) {
+    const { config, rounds } = state;
+    const max_rounds = config.maxRounds ?? DEFAULT_DEBATE_CONFIG.maxRounds;
+    if (rounds.length >= max_rounds) {
+        return false;
+    }
+    const lastRound = rounds[rounds.length - 1];
+    if (lastRound && lastRound.contributions.length > 0) {
+        const { hasConsensus, averageConfidence } = calculateConsensus(lastRound.contributions);
+        const threshold = config.consensusThreshold ?? DEFAULT_DEBATE_CONFIG.consensusThreshold;
+        if (hasConsensus && averageConfidence >= threshold) {
+            return false;
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=persona-debate.js.map

package/dist/esm/ai-prompts/persona-tools.d.ts

@@ -0,0 +1,26 @@
+import type { AgentPersona } from './types.js';
+export declare const TOOL_CATEGORIES: {
+    readonly file: readonly ["read_file", "write_file", "list_files", "search_files"];
+    readonly git: readonly ["git_status", "git_diff", "git_stage", "git_commit", "git_log", "git_branch", "git_pull", "git_push", "git_suggest_commit"];
+    readonly analysis: readonly ["analyze_code", "explain_code"];
+    readonly documentation: readonly ["generate_adr"];
+    readonly execution: readonly ["execute_command"];
+    readonly changes: readonly ["apply_pending_changes", "changes_list", "changes_diff", "changes_revert"];
+    readonly lsp: readonly ["lsp"];
+    readonly task: readonly ["task"];
+    readonly mcp: readonly ["mcp"];
+};
+export declare const ALL_TOOLS: readonly ["read_file", "write_file", "list_files", "search_files", "git_status", "git_diff", "git_stage", "git_commit", "git_log", "git_branch", "git_pull", "git_push", "git_suggest_commit", "analyze_code", "explain_code", "generate_adr", "execute_command", "apply_pending_changes", "changes_list", "changes_diff", "changes_revert", "lsp", "task", "mcp"];
+export type ToolName = (typeof ALL_TOOLS)[number];
+export interface PersonaToolConfig {
+    prioritized: readonly ToolName[];
+    allowed?: readonly ToolName[];
+    restricted: readonly ToolName[];
+    description: string;
+}
+export declare const PERSONA_TOOL_CONFIG: Record<AgentPersona, PersonaToolConfig>;
+export declare function filterToolsForPersona(toolNames: readonly string[], persona: AgentPersona): string[];
+export declare function isToolAllowedForPersona(toolName: string, persona: AgentPersona): boolean;
+export declare function getPersonaToolDescription(persona: AgentPersona): string;
+export declare function getRestrictedToolsForPersona(persona: AgentPersona): readonly ToolName[];
+//# sourceMappingURL=persona-tools.d.ts.map

package/dist/esm/ai-prompts/persona-tools.js

@@ -0,0 +1,172 @@
+export const TOOL_CATEGORIES = {
+    file: ['read_file', 'write_file', 'list_files', 'search_files'],
+    git: [
+        'git_status',
+        'git_diff',
+        'git_stage',
+        'git_commit',
+        'git_log',
+        'git_branch',
+        'git_pull',
+        'git_push',
+        'git_suggest_commit',
+    ],
+    analysis: ['analyze_code', 'explain_code'],
+    documentation: ['generate_adr'],
+    execution: ['execute_command'],
+    changes: ['apply_pending_changes', 'changes_list', 'changes_diff', 'changes_revert'],
+    lsp: ['lsp'],
+    task: ['task'],
+    mcp: ['mcp'],
+};
+export const ALL_TOOLS = [
+    ...TOOL_CATEGORIES.file,
+    ...TOOL_CATEGORIES.git,
+    ...TOOL_CATEGORIES.analysis,
+    ...TOOL_CATEGORIES.documentation,
+    ...TOOL_CATEGORIES.execution,
+    ...TOOL_CATEGORIES.changes,
+    ...TOOL_CATEGORIES.lsp,
+    ...TOOL_CATEGORIES.task,
+    ...TOOL_CATEGORIES.mcp,
+];
+const TOOL_NAME_SET = new Set(ALL_TOOLS);
+function resolveToolAccessName(toolName) {
+    if (toolName.startsWith('mcp_'))
+        return 'mcp';
+    if (TOOL_NAME_SET.has(toolName))
+        return toolName;
+    return toolName;
+}
+export const PERSONA_TOOL_CONFIG = {
+    steve: {
+        prioritized: ['explain_code', 'read_file', 'list_files', 'search_files', 'analyze_code'],
+        restricted: [
+            'execute_command',
+            'write_file',
+            'apply_pending_changes',
+            'changes_revert',
+            'task',
+            'mcp',
+            ...TOOL_CATEGORIES.git,
+        ],
+        description: 'Read-only access for business context. Cannot modify code or run commands.',
+    },
+    rachel: {
+        prioritized: ['explain_code', 'read_file', 'search_files', 'list_files', 'analyze_code'],
+        restricted: [
+            'execute_command',
+            'git_push',
+            'git_pull',
+            'apply_pending_changes',
+            'changes_revert',
+            'task',
+            'mcp',
+        ],
+        description: 'Read access for UX review. Limited write access for documentation and copy changes.',
+    },
+    ozby: {
+        prioritized: [
+            'analyze_code',
+            'read_file',
+            'write_file',
+            'git_status',
+            'git_diff',
+            'execute_command',
+            'search_files',
+            'generate_adr',
+        ],
+        restricted: [],
+        description: 'Full access to all technical tools for engineering tasks.',
+    },
+    volker: {
+        prioritized: [
+            'analyze_code',
+            'read_file',
+            'search_files',
+            'git_diff',
+            'git_status',
+            'execute_command',
+            'list_files',
+            'generate_adr',
+        ],
+        restricted: [],
+        description: 'Full access for code quality review. Prioritizes analysis and testing.',
+    },
+    jeramy: {
+        prioritized: [
+            'read_file',
+            'search_files',
+            'execute_command',
+            'analyze_code',
+            'git_status',
+            'git_diff',
+            'list_files',
+            'generate_adr',
+        ],
+        restricted: [],
+        description: 'Full access for backend and infrastructure. Prioritizes data flow and scalability.',
+    },
+    rodrigo: {
+        prioritized: [
+            'read_file',
+            'search_files',
+            'analyze_code',
+            'execute_command',
+            'git_status',
+            'git_diff',
+            'list_files',
+        ],
+        restricted: [],
+        description: 'Full access for engineering organization work. Prioritizes team topology, culture, and leadership.',
+    },
+};
+function getPriorityRank(entry, prioritizedSet, prioritizedList) {
+    return prioritizedSet.has(entry.accessName)
+        ? prioritizedList.indexOf(entry.accessName)
+        : Number.POSITIVE_INFINITY;
+}
+function compareToolEntries(a, b, prioritizedSet, prioritizedList) {
+    const aRank = getPriorityRank(a, prioritizedSet, prioritizedList);
+    const bRank = getPriorityRank(b, prioritizedSet, prioritizedList);
+    if (aRank !== bRank)
+        return aRank - bRank;
+    return a.name.localeCompare(b.name);
+}
+function createToolComparator(prioritizedSet, prioritizedList) {
+    return (a, b) => compareToolEntries(a, b, prioritizedSet, prioritizedList);
+}
+function resolveToolEntries(toolNames) {
+    return toolNames.map((name) => ({
+        name,
+        accessName: resolveToolAccessName(name),
+    }));
+}
+function filterRestrictedTools(entries, restrictedSet) {
+    return entries.filter((entry) => !restrictedSet.has(entry.accessName));
+}
+function sortToolsByPriority(entries, prioritizedSet, prioritizedList) {
+    return entries
+        .toSorted(createToolComparator(prioritizedSet, prioritizedList))
+        .map((entry) => entry.name);
+}
+export function filterToolsForPersona(toolNames, persona) {
+    const config = PERSONA_TOOL_CONFIG[persona];
+    const prioritizedSet = new Set(config.prioritized);
+    const restrictedSet = new Set(config.restricted);
+    const resolved = resolveToolEntries(toolNames);
+    const allowed = filterRestrictedTools(resolved, restrictedSet);
+    return sortToolsByPriority(allowed, prioritizedSet, config.prioritized);
+}
+export function isToolAllowedForPersona(toolName, persona) {
+    const config = PERSONA_TOOL_CONFIG[persona];
+    const accessName = resolveToolAccessName(toolName);
+    return !config.restricted.includes(accessName);
+}
+export function getPersonaToolDescription(persona) {
+    return PERSONA_TOOL_CONFIG[persona].description;
+}
+export function getRestrictedToolsForPersona(persona) {
+    return PERSONA_TOOL_CONFIG[persona].restricted;
+}
+//# sourceMappingURL=persona-tools.js.map