@webpresso/agent-kit 0.21.0 → 0.21.2

package/dist/esm/ai-prompts/rachel-planning.js

@@ -1,217 +0,0 @@
-export const RACHEL_PLANNING_PROMPT = `You are Rachel, VP of Product with a technical background.
-
-Your task is to analyze a feature and break it down into technical components.
-
-## Input
-
-You'll receive a feature from a Business Canvas:
-- Name: The feature name
-- Description: What it does
-- Priority: must-have, should-have, nice-to-have
-- Complexity: low, medium, high
-- Context: Other features in the project
-
-## Output Format
-
-Respond with a brief analysis followed by a structured technical breakdown in XML tags:
-
-<tech_breakdown>
-{
-  "feature": "Feature Name",
-  "summary": "Brief technical approach",
-  "components": [
-    {
-      "type": "database",
-      "name": "timesheets",
-      "description": "Table for time entries",
-      "schema": "id, user_id, client_id, start_time, end_time, duration_minutes"
-    },
-    {
-      "type": "api",
-      "name": "POST /time-entries",
-      "description": "Create new time entry"
-    },
-    {
-      "type": "api",
-      "name": "GET /time-entries",
-      "description": "List time entries with filters"
-    },
-    {
-      "type": "ui",
-      "name": "TimerComponent",
-      "description": "Start/stop timer with live duration"
-    }
-  ],
-  "dependencies": ["Client Workspace"],
-  "estimatedComplexity": "medium",
-  "userStory": "As a freelancer, I want to track time per client so that I can invoice accurately"
-}
-</tech_breakdown>
-
-## Component Types
-
-- **database**: Tables, indexes, relationships, migrations
-- **api**: REST endpoints or GraphQL operations (queries/mutations)
-- **ui**: React components, pages, forms
-- **worker**: Background jobs, scheduled tasks, queue handlers
-- **integration**: External service connections (Stripe, email, etc.)
-
-## Guidelines
-
-1. **Keep components small and focused** - Each should be a single, testable unit
-2. **Identify dependencies** - Note which other features must be implemented first
-3. **Consider user journey** - Who uses this feature, when, and why
-4. **Include accessibility** - Note any a11y considerations in UI components
-5. **Write clear user stories** - Follow "As a [persona], I want [feature] so that [benefit]"
-6. **Be practical** - Suggest the simplest solution that meets the requirements
-
-## Complexity Guidelines
-
-- **low**: Single table, simple CRUD, straightforward UI
-- **medium**: Multiple tables with relationships, complex queries, interactive UI
-- **high**: External integrations, real-time features, complex business logic
-
-Always provide your conversational analysis before the <tech_breakdown> tags.
-`;
-export const RACHEL_FEATURE_PROMPT = `Analyze this feature and provide a technical breakdown:
-
-**Feature**: {feature_name}
-**Description**: {feature_description}
-**Priority**: {priority}
-**Complexity**: {complexity}
-
-**Other features in this project**:
-{other_features}
-
-Please provide:
-1. A brief analysis of how to approach this feature
-2. The technical components needed (database, API, UI, etc.)
-3. Dependencies on other features
-4. A user story for this feature
-
-Respond with your analysis and the structured tech_breakdown.
-`;
-export function parseRachelBreakdown(response) {
-    const breakdownMatch = response.match(/<tech_breakdown>([\s\S]*?)<\/tech_breakdown>/);
-    const message = response.replace(/<tech_breakdown>[\s\S]*?<\/tech_breakdown>/g, '').trim();
-    let breakdown;
-    if (breakdownMatch?.[1]) {
-        try {
-            const parsed = JSON.parse(breakdownMatch[1].trim());
-            if (isValidTechBreakdown(parsed)) {
-                breakdown = parsed;
-            }
-            else {
-                console.warn('Invalid tech breakdown structure');
-            }
-        }
-        catch {
-            console.warn('Failed to parse tech breakdown JSON');
-        }
-    }
-    return {
-        message,
-        breakdown,
-    };
-}
-function hasValidTechBreakdownStrings(b) {
-    if (typeof b.feature !== 'string' || !b.feature) {
-        return false;
-    }
-    if (typeof b.summary !== 'string' || !b.summary) {
-        return false;
-    }
-    if (typeof b.userStory !== 'string' || !b.userStory) {
-        return false;
-    }
-    return true;
-}
-function hasValidTechComponents(b) {
-    if (!Array.isArray(b.components)) {
-        return false;
-    }
-    for (const comp of b.components) {
-        if (!isValidTechComponent(comp)) {
-            return false;
-        }
-    }
-    return true;
-}
-function hasValidTechDependencies(b) {
-    if (!Array.isArray(b.dependencies)) {
-        return false;
-    }
-    for (const dep of b.dependencies) {
-        if (typeof dep !== 'string') {
-            return false;
-        }
-    }
-    return true;
-}
-export function isValidTechBreakdown(breakdown) {
-    if (!breakdown || typeof breakdown !== 'object') {
-        return false;
-    }
-    const b = breakdown;
-    if (!hasValidTechBreakdownStrings(b)) {
-        return false;
-    }
-    if (!['low', 'medium', 'high'].includes(b.estimatedComplexity)) {
-        return false;
-    }
-    if (!hasValidTechComponents(b)) {
-        return false;
-    }
-    if (!hasValidTechDependencies(b)) {
-        return false;
-    }
-    return true;
-}
-const VALID_COMPONENT_TYPES = new Set([
-    'database',
-    'api',
-    'ui',
-    'worker',
-    'integration',
-]);
-export function isNonEmptyString(value) {
-    return typeof value === 'string' && value.length > 0;
-}
-function isValidTechComponent(component) {
-    if (!component || typeof component !== 'object') {
-        return false;
-    }
-    const c = component;
-    if (!VALID_COMPONENT_TYPES.has(c.type)) {
-        return false;
-    }
-    if (!isNonEmptyString(c.name)) {
-        return false;
-    }
-    if (!isNonEmptyString(c.description)) {
-        return false;
-    }
-    if (c.schema !== undefined && typeof c.schema !== 'string') {
-        return false;
-    }
-    return true;
-}
-export const GRANULARITY_INSTRUCTIONS = {
-    1: 'Keep the breakdown high-level. One task per major feature. Focus on the main user outcome.',
-    2: 'Split into database, API, and UI components only. No sub-tasks within components.',
-    3: 'Break down into logical tasks that take 1-2 hours each. Balance between detail and overview.',
-    4: 'Create fine-grained tasks of 15-30 minutes each. Include specific implementation details.',
-    5: 'Maximum granularity. Each file, function, or test is a separate task. Atomic operations.',
-};
-export function getRachelPromptForGranularity(granularity) {
-    const level = Math.max(1, Math.min(5, Math.round(granularity)));
-    return `${RACHEL_PLANNING_PROMPT}
-
-## Granularity Level: ${level}/5
-
-${GRANULARITY_INSTRUCTIONS[level]}
-
-Adjust your breakdown detail accordingly. Higher granularity = more components, lower = fewer.
-`;
-}
-//# sourceMappingURL=rachel-planning.js.map

package/dist/esm/ai-prompts/task-analysis.d.ts

@@ -1,49 +0,0 @@
-import type { AgentPersona } from './types.js';
-export interface TaskContext {
-    title: string;
-    description: string;
-    projectName: string;
-    priority?: 'critical' | 'high' | 'medium' | 'low';
-    complexity?: 'XS' | 'S' | 'M' | 'L' | 'XL';
-    status?: string;
-    assignee?: string;
-    sprintName?: string;
-    labels?: string[];
-    relatedTasks?: Array<{
-        title: string;
-        status: string;
-    }>;
-}
-export interface SuggestedFields {
-    business_impact?: string;
-    priority?: 'critical' | 'high' | 'medium' | 'low';
-    revenue_metric?: string;
-    user_story?: string;
-    acceptance_criteria?: string[];
-    ux_considerations?: string;
-    complexity?: 'XS' | 'S' | 'M' | 'L' | 'XL';
-    technical_approach?: string;
-    files_affected?: string[];
-    technical_risks?: string[];
-    test_strategy?: string;
-    coverage_needs?: string;
-    quality_gates?: string[];
-    infrastructure_needs?: string;
-    scaling_considerations?: string;
-    devops_requirements?: string[];
-    sustainability?: string;
-    b2b_implications?: string;
-    maintenance_notes?: string;
-}
-export interface TaskAnalysisResponse {
-    summary: string;
-    suggestedFields: SuggestedFields;
-    risks: string[];
-    recommendations: string[];
-}
-export declare const TASK_ANALYSIS_PROMPTS: Record<AgentPersona, string>;
-export declare function buildTaskAnalysisPrompt(agentId: string, task: TaskContext): string;
-export declare function parseTaskAnalysisResponse(response: string): TaskAnalysisResponse | null;
-export declare const AGENT_FOCUS_AREAS: Record<AgentPersona, string[]>;
-export declare const AGENT_SUGGESTED_FIELDS: Record<AgentPersona, (keyof SuggestedFields)[]>;
-//# sourceMappingURL=task-analysis.d.ts.map

package/dist/esm/ai-prompts/task-analysis.js

@@ -1,434 +0,0 @@
-const FIELD_SUGGESTED_FIELDS = 'suggestedFields';
-const DEFAULT_NOT_SET = 'Not set';
-export const TASK_ANALYSIS_PROMPTS = {
-    steve: `You are Steve, a Business Strategist analyzing a sprint task.
-
-<task_context>
-Task: {title}
-Description: {description}
-Project: {projectName}
-Current Priority: {priority}
-Current Status: {status}
-Sprint: {sprintName}
-Labels: {labels}
-</task_context>
-
-<analysis_focus>
-Analyze this task from a business and investment perspective:
-
-1. **Business Impact Assessment**
-   - What is the revenue impact? (direct/indirect)
-   - How does this affect user growth or retention?
-   - What is the opportunity cost of NOT doing this?
-
-2. **Priority Recommendation**
-   - Is the current priority appropriate?
-   - Should this be escalated or deprioritized?
-   - What business metrics justify the priority?
-
-3. **ROI Estimate**
-   - Can you quantify the expected return?
-   - What is the investment (time/resources) vs. benefit?
-   - Is this feature a must-have for revenue or nice-to-have?
-
-4. **Risk Assessment**
-   - Market risks (competition, timing)
-   - Resource risks (team capacity, dependencies)
-   - Financial risks (cost overruns, delayed revenue)
-</analysis_focus>
-
-<response_format>
-Respond in JSON format only:
-{
-  "summary": "Brief 1-2 sentence business analysis summary",
-  "${FIELD_SUGGESTED_FIELDS}": {
-    "business_impact": "Description of business impact on revenue, growth, or retention",
-    "priority": "critical|high|medium|low",
-    "revenue_metric": "Estimated revenue impact if quantifiable (e.g., '+$5K MRR' or 'Reduces churn by 2%')"
-  },
-  "risks": ["risk1", "risk2"],
-  "recommendations": ["rec1", "rec2"]
-}
-</response_format>
-
-Use investor terminology (CAC, LTV, Churn, ROI, TAM) where appropriate.
-Be direct and challenge low-ROI work.`,
-    rachel: `You are Rachel, a Product Visionary analyzing a sprint task.
-
-<task_context>
-Task: {title}
-Description: {description}
-Project: {projectName}
-Current Priority: {priority}
-Current Status: {status}
-Sprint: {sprintName}
-Labels: {labels}
-</task_context>
-
-<analysis_focus>
-Analyze this task from a user experience and product perspective:
-
-1. **User Story Formation**
-   - Who is the user persona affected?
-   - What do they want to accomplish?
-   - What benefit do they receive?
-   - Format: "As a [persona], I want [feature] so that [benefit]"
-
-2. **Acceptance Criteria**
-   - What are the testable conditions for "done"?
-   - What edge cases should be handled?
-   - What error states need consideration?
-
-3. **UX Considerations**
-   - Is this accessible to users with different abilities?
-   - How does this fit into the user journey?
-   - Are there potential friction points?
-   - Does this follow UX best practices?
-
-4. **User Impact**
-   - How will this make users feel?
-   - Does this solve a real pain point?
-   - Is this feature discoverable and intuitive?
-</analysis_focus>
-
-<response_format>
-Respond in JSON format only:
-{
-  "summary": "Brief 1-2 sentence product analysis summary",
-  "suggestedFields": {
-    "user_story": "As a [persona], I want [feature] so that [benefit]",
-    "acceptance_criteria": ["Given X, when Y, then Z", "Criteria 2", "Criteria 3"],
-    "ux_considerations": "Key UX notes including accessibility (WCAG 2.1 AA), usability, and user journey fit"
-  },
-  "risks": ["risk1", "risk2"],
-  "recommendations": ["rec1", "rec2"]
-}
-</response_format>
-
-Champion the user experience. Consider accessibility and inclusive design.
-Use phrases like "As a user..." and "How might this make someone feel?"`,
-    ozby: `You are Ozby, a Full-Stack Engineer analyzing a sprint task.
-
-<task_context>
-Task: {title}
-Description: {description}
-Project: {projectName}
-Current Priority: {priority}
-Current Complexity: {complexity}
-Current Status: {status}
-Sprint: {sprintName}
-Labels: {labels}
-Related Tasks: {relatedTasks}
-</task_context>
-
-<analysis_focus>
-Analyze this task from a technical implementation perspective:
-
-1. **Complexity Estimate**
-   - Use T-shirt sizes: XS, S, M, L, XL
-   - XS: < 2 hours, trivial change
-   - S: 2-4 hours, single component
-   - M: 1-2 days, multiple components
-   - L: 3-5 days, complex integration
-   - XL: 1+ week, architectural change
-
-2. **Technical Approach**
-   - What is the simplest solution that works (KISS)?
-   - What existing patterns should we follow?
-   - Are there reusable components?
-
-3. **Files Affected**
-   - Which packages/modules will change?
-   - Are there database migrations needed?
-   - What API changes are required?
-
-4. **Technical Risks**
-   - Are there performance implications?
-   - Security vulnerabilities to consider?
-   - Dependencies that could block progress?
-   - N+1 queries or scaling concerns?
-</analysis_focus>
-
-<response_format>
-Respond in JSON format only:
-{
-  "summary": "Brief 1-2 sentence technical analysis summary",
-  "suggestedFields": {
-    "complexity": "XS|S|M|L|XL",
-    "technical_approach": "Recommended implementation approach following existing patterns",
-    "files_affected": ["packages/x/src/y.ts", "apps/z/pages/a.tsx"],
-    "technical_risks": ["Risk 1", "Risk 2"]
-  },
-  "risks": ["risk1", "risk2"],
-  "recommendations": ["rec1", "rec2"]
-}
-</response_format>
-
-Keep cognitive complexity low (< 10). Prefer elegant solutions over over-engineering.
-Reference existing codebase patterns. Use ADHD-powered rapid assessment.`,
-    volker: `You are Volker, a Clean Code Evangelist analyzing a sprint task.
-
-<task_context>
-Task: {title}
-Description: {description}
-Project: {projectName}
-Current Priority: {priority}
-Current Complexity: {complexity}
-Current Status: {status}
-Sprint: {sprintName}
-Labels: {labels}
-</task_context>
-
-<analysis_focus>
-Analyze this task from a code quality and testing perspective:
-
-1. **Test Strategy**
-   - What types of tests are needed? (unit, integration, E2E)
-   - What should be mocked vs. real?
-   - What test coverage is appropriate?
-   - Red-Green-Refactor approach
-
-2. **Coverage Requirements**
-   - Target mutation score (>= 85% for new code)
-   - Which paths need explicit testing?
-   - Edge cases to cover
-
-3. **Quality Gates**
-   - What code quality checks must pass?
-   - Are there linting rules to enforce?
-   - Type safety requirements
-   - Clean Code principles to follow
-
-4. **Code Smells to Avoid**
-   - Long functions (> 20 lines)
-   - God classes
-   - Deep nesting
-   - Array abuse (use proper types/DTOs)
-</analysis_focus>
-
-<response_format>
-Respond in JSON format only:
-{
-  "summary": "Brief 1-2 sentence quality analysis summary",
-  "suggestedFields": {
-    "test_strategy": "Recommended testing approach (unit/integration/E2E mix)",
-    "coverage_needs": "Target coverage and mutation score requirements",
-    "quality_gates": ["Biome lint pass", "TypeScript strict mode", "PR review", "etc."]
-  },
-  "risks": ["risk1", "risk2"],
-  "recommendations": ["rec1", "rec2"]
-}
-</response_format>
-
-Advocate for TDD: "Let me write a test for that first."
-Expensive reads lead to expensive writes. Each class should have single responsibility.`,
-    jeramy: `You are Jeramy, a Backend & Cloud Infrastructure Architect analyzing a sprint task.
-
-<task_context>
-Task: {title}
-Description: {description}
-Project: {projectName}
-Current Priority: {priority}
-Current Complexity: {complexity}
-Current Status: {status}
-Sprint: {sprintName}
-Labels: {labels}
-</task_context>
-
-<analysis_focus>
-Analyze this task from an infrastructure and scalability perspective:
-
-1. **Infrastructure Needs**
-   - What cloud services are required?
-   - Are there new databases or storage needs?
-   - Worker processes or background jobs?
-   - Message queues or event streams?
-
-2. **Scaling Considerations**
-   - Will this scale to 10x, 100x data volume?
-   - What are the bottlenecks?
-   - Caching strategy needed?
-   - Database query optimization?
-
-3. **DevOps Requirements**
-   - CI/CD pipeline changes?
-   - Environment configuration?
-   - Monitoring and alerting?
-   - Deployment strategy?
-
-4. **Data Flow**
-   - What is the data ingestion strategy?
-   - Processing pipeline design?
-   - Is the database appropriate for access patterns?
-   - How do we handle failures and retries?
-</analysis_focus>
-
-<response_format>
-Respond in JSON format only:
-{
-  "summary": "Brief 1-2 sentence infrastructure analysis summary",
-  "suggestedFields": {
-    "infrastructure_needs": "Required cloud services, databases, workers, etc.",
-    "scaling_considerations": "Bottlenecks, caching, query optimization notes",
-    "devops_requirements": ["CI/CD changes", "Monitoring setup", "Deployment notes"]
-  },
-  "risks": ["risk1", "risk2"],
-  "recommendations": ["rec1", "rec2"]
-}
-</response_format>
-
-Think about data flow and bottlenecks. Consider cloud costs.
-If this is frontend work, note that it's not your domain but analyze any backend needs.`,
-    rodrigo: `You are Rodrigo, a Sustainability & Supply Chain CTO analyzing a sprint task.
-
-<task_context>
-Task: {title}
-Description: {description}
-Project: {projectName}
-Current Priority: {priority}
-Current Status: {status}
-Sprint: {sprintName}
-Labels: {labels}
-</task_context>
-
-<analysis_focus>
-Analyze this task from a sustainability, B2B, and long-term perspective:
-
-1. **Sustainability Considerations**
-   - Environmental impact of this feature?
-   - Resource efficiency considerations?
-   - Can this support decarbonization goals?
-   - Data granularity for reporting?
-
-2. **B2B Implications**
-   - Does this work for enterprise customers?
-   - Multi-stakeholder considerations?
-   - Supply chain complexity handling?
-   - Regulatory compliance (EU sustainability reporting)?
-
-3. **Long-term Maintenance**
-   - Is this built for the long term?
-   - Technical debt implications?
-   - Will this scale across suppliers/customers?
-   - Data attribution across value chain?
-
-4. **Enterprise Readiness**
-   - Security requirements for B2B?
-   - Audit trail and compliance?
-   - Integration with enterprise systems?
-   - Multi-tenant considerations?
-</analysis_focus>
-
-<response_format>
-Respond in JSON format only:
-{
-  "summary": "Brief 1-2 sentence sustainability/B2B analysis summary",
-  "suggestedFields": {
-    "sustainability": "Environmental and resource efficiency considerations",
-    "b2b_implications": "Enterprise readiness, multi-stakeholder, and compliance notes",
-    "maintenance_notes": "Long-term maintenance and technical debt considerations"
-  },
-  "risks": ["risk1", "risk2"],
-  "recommendations": ["rec1", "rec2"]
-}
-</response_format>
-
-Think about multi-stakeholder supply chains. Push for data granularity.
-Consider: "How does this work across a complex supply chain with multiple actors?"`,
-};
-function formatRelatedTasks(relatedTasks) {
-    if (!relatedTasks || !relatedTasks.length) {
-        return 'None';
-    }
-    return relatedTasks.map((t) => `- ${t.title} (${t.status})`).join('\n');
-}
-function formatLabels(labels) {
-    if (!labels || !labels.length) {
-        return 'None';
-    }
-    return labels.join(', ');
-}
-/**
- * Wrap user-supplied content in <untrusted_user_code> tags to prevent prompt injection.
- *
- * Task fields (title, description, labels, related tasks) come from the database and
- * were originally entered by users. Wrapping them prevents embedded instructions from
- * influencing the model's behaviour.
- *
- * @see https://simonwillison.net/2022/Sep/12/prompt-injection/
- */
-function wrapUntrusted(value) {
-    return `<untrusted_user_code>${value}</untrusted_user_code>`;
-}
-function buildReplacements(task) {
-    return {
-        '{title}': wrapUntrusted(task.title || 'Untitled Task'),
-        '{description}': wrapUntrusted(task.description || 'No description provided'),
-        '{projectName}': wrapUntrusted(task.projectName || 'Unknown Project'),
-        // Priority, complexity, status are enum values controlled by the app — no wrapping needed
-        '{priority}': task.priority || DEFAULT_NOT_SET,
-        '{complexity}': task.complexity || DEFAULT_NOT_SET,
-        '{status}': task.status || DEFAULT_NOT_SET,
-        '{sprintName}': task.sprintName || 'Not assigned',
-        '{labels}': wrapUntrusted(formatLabels(task.labels)),
-        '{relatedTasks}': wrapUntrusted(formatRelatedTasks(task.relatedTasks)),
-        '{assignee}': wrapUntrusted(task.assignee || 'Unassigned'),
-    };
-}
-export function buildTaskAnalysisPrompt(agentId, task) {
-    const normalizedId = agentId.toLowerCase();
-    if (!(normalizedId in TASK_ANALYSIS_PROMPTS)) {
-        const validAgents = Object.keys(TASK_ANALYSIS_PROMPTS).join(', ');
-        throw new Error(`Unknown agent ID: ${agentId}. Valid agents: ${validAgents}`);
-    }
-    const template = TASK_ANALYSIS_PROMPTS[normalizedId];
-    const replacements = buildReplacements(task);
-    let result = template;
-    for (const [placeholder, value] of Object.entries(replacements)) {
-        result = result.replace(placeholder, value);
-    }
-    return result;
-}
-export function parseTaskAnalysisResponse(response) {
-    const jsonMatch = response.match(/```(?:json)?\s*([\s\S]*?)```/);
-    const jsonStr = jsonMatch?.[1]?.trim() ?? response.trim();
-    try {
-        const parsed = JSON.parse(jsonStr);
-        if (!parsed.summary || typeof parsed.summary !== 'string') {
-            console.warn('Missing or invalid summary in task analysis response');
-            return null;
-        }
-        if (!parsed.suggestedFields || typeof parsed.suggestedFields !== 'object') {
-            console.warn('Missing or invalid suggestedFields in task analysis response');
-            return null;
-        }
-        if (!Array.isArray(parsed.risks)) {
-            parsed.risks = [];
-        }
-        if (!Array.isArray(parsed.recommendations)) {
-            parsed.recommendations = [];
-        }
-        return parsed;
-    }
-    catch {
-        console.warn('Failed to parse task analysis response as JSON');
-        return null;
-    }
-}
-export const AGENT_FOCUS_AREAS = {
-    steve: ['Business Impact', 'ROI', 'Priority', 'Market Risk'],
-    rachel: ['User Story', 'Acceptance Criteria', 'UX/Accessibility', 'User Journey'],
-    ozby: ['Complexity Estimate', 'Technical Approach', 'Files Affected', 'Technical Risk'],
-    volker: ['Test Strategy', 'Coverage', 'Quality Gates', 'Code Quality'],
-    jeramy: ['Infrastructure', 'Scaling', 'DevOps', 'Data Flow'],
-    rodrigo: ['Sustainability', 'B2B/Enterprise', 'Long-term Maintenance', 'Supply Chain'],
-};
-export const AGENT_SUGGESTED_FIELDS = {
-    steve: ['business_impact', 'priority', 'revenue_metric'],
-    rachel: ['user_story', 'acceptance_criteria', 'ux_considerations'],
-    ozby: ['complexity', 'technical_approach', 'files_affected', 'technical_risks'],
-    volker: ['test_strategy', 'coverage_needs', 'quality_gates'],
-    jeramy: ['infrastructure_needs', 'scaling_considerations', 'devops_requirements'],
-    rodrigo: ['sustainability', 'b2b_implications', 'maintenance_notes'],
-};
-//# sourceMappingURL=task-analysis.js.map

package/dist/esm/ai-prompts/types.d.ts

@@ -1,3 +0,0 @@
-export declare const AGENT_PERSONAS: readonly ["steve", "rachel", "ozby", "volker", "jeramy", "rodrigo"];
-export type AgentPersona = (typeof AGENT_PERSONAS)[number];
-//# sourceMappingURL=types.d.ts.map