profclaw 0.0.1-beta.1

package/dist/chat/providers/zalo-personal/index.js

@@ -0,0 +1,212 @@
+/**
+ * Zalo Personal Provider - Zalo Social API personal messaging
+ * Separate from Zalo OA (Official Account).
+ * API base: https://graph.zalo.me/v2.0/me
+ */
+import { createHmac } from 'node:crypto';
+import { z } from 'zod';
+import { logger } from '../../../utils/logger.js';
+// --- Schema ---
+export const ZaloPersonalAccountConfigSchema = z.object({
+    id: z.string(),
+    name: z.string().optional(),
+    enabled: z.boolean().default(true),
+    isDefault: z.boolean().optional(),
+    provider: z.literal('zalo-personal'),
+    accessToken: z.string().optional(),
+    secretKey: z.string().optional(),
+    userId: z.string().optional(),
+});
+// --- State ---
+let currentConfig = null;
+const ZALO_SOCIAL_API = 'https://graph.zalo.me/v2.0/me';
+// --- HTTP helper ---
+async function callZaloSocialApi(endpoint, method = 'GET', body, config) {
+    const token = (config ?? currentConfig)?.accessToken;
+    if (!token)
+        return { ok: false, error: 'Access token not configured' };
+    try {
+        const url = `${ZALO_SOCIAL_API}${endpoint}`;
+        const res = await fetch(url, {
+            method,
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'Content-Type': 'application/json',
+            },
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        });
+        const data = await res.json();
+        if (!res.ok) {
+            const errMsg = typeof data.error === 'object' ? data.error?.message : data.message;
+            return { ok: false, error: errMsg ?? `HTTP ${res.status}` };
+        }
+        if (typeof data.error === 'number' && data.error !== 0) {
+            return { ok: false, error: data.message ?? `Zalo error ${data.error}` };
+        }
+        return { ok: true, data };
+    }
+    catch (error) {
+        logger.error('[ZaloPersonal] API call failed:', error instanceof Error ? error : undefined);
+        return { ok: false, error: error instanceof Error ? error.message : 'Unknown error' };
+    }
+}
+// --- Adapters ---
+const authAdapter = {
+    getAuthUrl(state, _scopes) {
+        const appId = process.env['ZALO_PERSONAL_APP_ID'] ?? '';
+        const redirectUri = encodeURIComponent(process.env['ZALO_PERSONAL_REDIRECT_URI'] ?? '');
+        return `https://oauth.zaloapp.com/v4/permission?app_id=${appId}&redirect_uri=${redirectUri}&state=${state}`;
+    },
+    async exchangeCode(code) {
+        const appId = process.env['ZALO_PERSONAL_APP_ID'];
+        const appSecret = process.env['ZALO_PERSONAL_APP_SECRET'];
+        if (!appId || !appSecret) {
+            throw new Error('ZALO_PERSONAL_APP_ID and ZALO_PERSONAL_APP_SECRET required');
+        }
+        const res = await fetch('https://oauth.zaloapp.com/v4/access_token', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'secret_key': appSecret,
+            },
+            body: `code=${code}&app_id=${appId}&grant_type=authorization_code`,
+        });
+        const data = await res.json();
+        if (data.error || !data.access_token) {
+            throw new Error(data.error_name ?? 'Token exchange failed');
+        }
+        return {
+            accessToken: data.access_token,
+            refreshToken: data.refresh_token,
+            expiresIn: data.expires_in,
+        };
+    },
+    verifyWebhook(signature, _timestamp, body) {
+        const secret = currentConfig?.secretKey;
+        if (!secret) {
+            logger.warn('[ZaloPersonal] verifyWebhook: secretKey not configured');
+            return false;
+        }
+        try {
+            const expected = createHmac('sha256', secret).update(body, 'utf8').digest('hex');
+            return signature === expected;
+        }
+        catch (error) {
+            logger.error('[ZaloPersonal] verifyWebhook failed:', error instanceof Error ? error : undefined);
+            return false;
+        }
+    },
+};
+const outboundAdapter = {
+    async send(message) {
+        if (!currentConfig?.accessToken)
+            return { success: false, error: 'Access token not configured' };
+        if (!message.to)
+            return { success: false, error: 'Recipient user ID (to) is required' };
+        const result = await callZaloSocialApi('/message', 'POST', {
+            recipient: { user_id: message.to },
+            message: { text: message.text ?? '' },
+        });
+        return result.ok
+            ? { success: true, messageId: result.data?.data?.message_id }
+            : { success: false, error: result.error ?? 'Failed to send message' };
+    },
+};
+const inboundAdapter = {
+    parseMessage(payload) {
+        const event = payload;
+        if (!event?.from?.id || !event?.message?.text)
+            return null;
+        if (event.event_name && event.event_name !== 'user_send_text')
+            return null;
+        return {
+            id: event.message.msg_id ?? `zp-${Date.now()}`,
+            provider: 'zalo-personal',
+            accountId: currentConfig?.id ?? 'default',
+            senderId: event.from.id,
+            senderName: event.from.name ?? event.from.id,
+            senderUsername: event.from.id,
+            chatType: 'direct',
+            chatId: event.from.id,
+            chatName: undefined,
+            threadId: undefined,
+            replyToId: undefined,
+            text: event.message.text,
+            rawContent: event,
+            timestamp: event.timestamp ? new Date(event.timestamp) : new Date(),
+            attachments: undefined,
+        };
+    },
+    parseCommand(_payload) { return null; },
+    parseAction(_payload) { return null; },
+    buildCommandResponse(response) { return { text: response.text ?? '' }; },
+    buildActionResponse(response) { return { text: response.text ?? '' }; },
+};
+const statusAdapter = {
+    isConfigured(config) {
+        return !!config.accessToken;
+    },
+    async checkHealth(config) {
+        if (!config.accessToken)
+            return { connected: false, error: 'accessToken is required' };
+        const personalConfig = {
+            ...config,
+            provider: 'zalo-personal',
+            enabled: config.enabled ?? true,
+        };
+        const start = Date.now();
+        const result = await callZaloSocialApi('/info', 'GET', undefined, personalConfig);
+        const latencyMs = Date.now() - start;
+        if (result.ok && result.data) {
+            const profile = result.data;
+            return {
+                connected: true,
+                latencyMs,
+                details: { userId: profile.id, name: profile.name },
+            };
+        }
+        return { connected: false, latencyMs, error: result.error ?? 'Failed to connect' };
+    },
+};
+// --- Config ---
+export function setZaloPersonalConfig(config) {
+    currentConfig = config;
+}
+export function clearZaloPersonalConfig() {
+    currentConfig = null;
+}
+// --- Provider export ---
+export const zaloPersonalProvider = {
+    meta: {
+        id: 'zalo-personal',
+        name: 'Zalo Personal',
+        description: 'Zalo Social API for personal messaging in Vietnam',
+        icon: 'Zalo icon',
+        docsUrl: 'https://developers.zalo.me/docs/social-api/',
+        order: 24,
+        color: '#0068FF',
+    },
+    capabilities: {
+        chatTypes: ['direct'],
+        send: true,
+        receive: true,
+        slashCommands: false,
+        interactiveComponents: false,
+        reactions: false,
+        edit: false,
+        delete: false,
+        threads: false,
+        media: true,
+        richBlocks: false,
+        oauth: true,
+        webhooks: true,
+        realtime: false,
+    },
+    defaultConfig: { provider: 'zalo-personal', enabled: true },
+    configSchema: ZaloPersonalAccountConfigSchema,
+    auth: authAdapter,
+    outbound: outboundAdapter,
+    inbound: inboundAdapter,
+    status: statusAdapter,
+};
+//# sourceMappingURL=index.js.map

package/dist/chat/skills.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Chat Skills System
+ *
+ * Skills are packaged capabilities that handle specific types of requests.
+ * Each skill declares what it can do, patterns to match, and how to execute.
+ *
+ * Inspired by OpenClaw's adapter pattern and HuggingFace skills.
+ */
+export interface ChatSkill {
+    id: string;
+    name: string;
+    description: string;
+    icon: string;
+    capabilities: SkillCapability[];
+    patterns: IntentPattern[];
+    preferredModel?: 'fast' | 'balanced' | 'powerful';
+    requiresContext?: ('task' | 'ticket' | 'project')[];
+    systemPromptAddition: string;
+    examples: string[];
+}
+export type SkillCapability = 'task_management' | 'code_generation' | 'code_review' | 'documentation' | 'analysis' | 'summarization' | 'search' | 'explanation' | 'planning' | 'writing' | 'debugging' | 'general_chat';
+export interface IntentPattern {
+    pattern: RegExp;
+    confidence: number;
+    extract?: string[];
+}
+export interface SkillMatch {
+    skill: ChatSkill;
+    confidence: number;
+    matchedPattern?: string;
+    extractedVars?: Record<string, string>;
+}
+export declare const CHAT_SKILLS: ChatSkill[];
+/**
+ * Detect user intent and match to the best skill
+ */
+export declare function detectIntent(message: string, context?: {
+    hasTask?: boolean;
+    hasTicket?: boolean;
+    hasCode?: boolean;
+}): SkillMatch[];
+export interface ModelTier {
+    tier: 'fast' | 'balanced' | 'powerful';
+    models: string[];
+    description: string;
+    maxTokens: number;
+    costMultiplier: number;
+}
+export declare const MODEL_TIERS: ModelTier[];
+/**
+ * Select the best model based on skill and message complexity
+ */
+export declare function selectModel(skillMatch: SkillMatch, message: string, availableModels: string[]): {
+    model: string;
+    tier: ModelTier;
+    reason: string;
+};
+/**
+ * Build a system prompt enhanced with matched skill context
+ */
+export declare function buildSkillPrompt(basePrompt: string, skillMatch: SkillMatch, context?: {
+    task?: {
+        id?: string;
+        title?: string;
+        status?: string;
+        agent?: string;
+    };
+    ticket?: {
+        id?: string;
+        title?: string;
+        status?: string;
+    };
+}): string;
+declare const _default: {
+    CHAT_SKILLS: ChatSkill[];
+    MODEL_TIERS: ModelTier[];
+    detectIntent: typeof detectIntent;
+    selectModel: typeof selectModel;
+    buildSkillPrompt: typeof buildSkillPrompt;
+};
+export default _default;
+//# sourceMappingURL=skills.d.ts.map

package/dist/chat/skills.js

@@ -0,0 +1,410 @@
+/**
+ * Chat Skills System
+ *
+ * Skills are packaged capabilities that handle specific types of requests.
+ * Each skill declares what it can do, patterns to match, and how to execute.
+ *
+ * Inspired by OpenClaw's adapter pattern and HuggingFace skills.
+ */
+// === Pre-compiled Patterns ===
+// Defined at module scope to avoid recompilation
+const TASK_PATTERNS = {
+    create: /(?:create|add|new|make)\s+(?:a\s+)?(?:task|ticket|issue)/i,
+    list: /(?:list|show|get|what are)\s+(?:my\s+)?(?:tasks|tickets|issues)/i,
+    status: /(?:status|progress|state)\s+(?:of\s+)?(?:task|ticket|issue)/i,
+    prioritize: /(?:prioritize|order|sort|rank)\s+(?:tasks|tickets|work)/i,
+    assign: /(?:assign|delegate|give)\s+(?:task|ticket|work)/i,
+    complete: /(?:complete|finish|done|close)\s+(?:task|ticket|issue)/i,
+};
+const CODE_PATTERNS = {
+    generate: /(?:write|create|generate|build|implement)\s+(?:code|function|class|component)/i,
+    review: /(?:review|check|analyze)\s+(?:this\s+)?(?:code|implementation|function)/i,
+    explain: /(?:explain|what does|how does)\s+(?:this\s+)?(?:code|function|work)/i,
+    debug: /(?:debug|fix|why\s+(?:is|does)|error|bug|issue\s+with)/i,
+    refactor: /(?:refactor|improve|optimize|clean\s+up)\s+(?:this\s+)?(?:code|function)/i,
+    test: /(?:write|create|generate)\s+(?:tests?|unit\s+tests?|test\s+cases?)/i,
+};
+const ANALYSIS_PATTERNS = {
+    costs: /(?:analyze|show|what are)\s+(?:my\s+)?(?:costs?|spending|usage|tokens?)/i,
+    performance: /(?:analyze|show|how is)\s+(?:performance|velocity|throughput)/i,
+    patterns: /(?:find|show|what are)\s+(?:patterns?|trends?|insights?)/i,
+    summary: /(?:summarize|summary|overview|recap)\s+(?:of\s+)?(?:today|week|month|progress)/i,
+};
+const DOC_PATTERNS = {
+    write: /(?:write|create|generate|draft)\s+(?:documentation|docs|readme|pr\s+description)/i,
+    ticket: /(?:write|create|draft)\s+(?:a\s+)?(?:ticket|issue|bug\s+report)/i,
+    commit: /(?:write|create|generate)\s+(?:commit\s+message|changelog)/i,
+};
+const GENERAL_PATTERNS = {
+    greeting: /^(?:hi|hello|hey|good\s+(?:morning|afternoon|evening))/i,
+    help: /(?:help|how\s+do\s+i|what\s+can\s+you|capabilities)/i,
+    thanks: /(?:thanks|thank\s+you|thx|ty)/i,
+};
+// === Skill Definitions ===
+export const CHAT_SKILLS = [
+    {
+        id: 'task-manager',
+        name: 'Task Manager',
+        description: 'Create, manage, and organize tasks and tickets',
+        icon: 'clipboard-list',
+        capabilities: ['task_management', 'planning'],
+        patterns: [
+            { pattern: TASK_PATTERNS.create, confidence: 90, extract: ['taskType'] },
+            { pattern: TASK_PATTERNS.list, confidence: 85 },
+            { pattern: TASK_PATTERNS.status, confidence: 80 },
+            { pattern: TASK_PATTERNS.prioritize, confidence: 85 },
+            { pattern: TASK_PATTERNS.assign, confidence: 80 },
+            { pattern: TASK_PATTERNS.complete, confidence: 80 },
+        ],
+        preferredModel: 'fast',
+        systemPromptAddition: `
+You are helping with task management in profClaw.
+
+## Available Actions
+- Create tasks/tickets with: title, description, priority, labels
+- List and filter tasks by status, priority, agent
+- Update task status and assignments
+- Prioritize and organize work
+
+## Important
+- Always confirm before creating or modifying tasks
+- Ask for missing required fields (title, description)
+- Suggest appropriate priority based on context
+- You can reference the profClaw API but cannot execute actions directly`,
+        examples: [
+            'Create a task to fix the login bug',
+            'What tasks are pending?',
+            'Prioritize my work for today',
+        ],
+    },
+    {
+        id: 'code-assistant',
+        name: 'Code Assistant',
+        description: 'Write, review, debug, and explain code',
+        icon: 'code',
+        capabilities: ['code_generation', 'code_review', 'debugging', 'explanation'],
+        patterns: [
+            { pattern: CODE_PATTERNS.generate, confidence: 90 },
+            { pattern: CODE_PATTERNS.review, confidence: 90 },
+            { pattern: CODE_PATTERNS.explain, confidence: 85 },
+            { pattern: CODE_PATTERNS.debug, confidence: 90 },
+            { pattern: CODE_PATTERNS.refactor, confidence: 85 },
+            { pattern: CODE_PATTERNS.test, confidence: 85 },
+        ],
+        preferredModel: 'powerful',
+        systemPromptAddition: `
+You are helping with code in profClaw.
+
+## Capabilities
+- Write code in TypeScript, JavaScript, Python, and more
+- Review code for bugs, security issues, and improvements
+- Explain code and technical concepts
+- Help debug issues
+- Suggest refactoring and optimizations
+
+## Guidelines
+- Use proper syntax highlighting with language tags
+- Prefer TypeScript with strict types
+- Follow existing code patterns when modifying
+- Explain your reasoning for suggestions`,
+        examples: [
+            'Write a function to validate email addresses',
+            'Review this code for security issues',
+            'Why is this throwing an error?',
+        ],
+    },
+    {
+        id: 'analyst',
+        name: 'Analyst',
+        description: 'Analyze costs, performance, and patterns',
+        icon: 'bar-chart-2',
+        capabilities: ['analysis', 'summarization'],
+        patterns: [
+            { pattern: ANALYSIS_PATTERNS.costs, confidence: 90 },
+            { pattern: ANALYSIS_PATTERNS.performance, confidence: 85 },
+            { pattern: ANALYSIS_PATTERNS.patterns, confidence: 80 },
+            { pattern: ANALYSIS_PATTERNS.summary, confidence: 85 },
+        ],
+        preferredModel: 'balanced',
+        systemPromptAddition: `
+You are analyzing data in profClaw.
+
+## Available Analysis
+- Token costs and spending by model/provider
+- Task completion rates and velocity
+- Agent performance comparisons
+- Trends and patterns over time
+
+## Data Sources
+You have access to:
+- Task history (status, duration, agent)
+- Token usage and costs
+- Agent performance metrics
+
+## Guidelines
+- Present data clearly with numbers
+- Highlight actionable insights
+- Compare against benchmarks when relevant`,
+        examples: [
+            'Analyze my token costs this week',
+            'Which agent is most efficient?',
+            'Summarize progress this sprint',
+        ],
+    },
+    {
+        id: 'writer',
+        name: 'Writer',
+        description: 'Write documentation, tickets, and content',
+        icon: 'pen-tool',
+        capabilities: ['documentation', 'writing'],
+        patterns: [
+            { pattern: DOC_PATTERNS.write, confidence: 90 },
+            { pattern: DOC_PATTERNS.ticket, confidence: 90 },
+            { pattern: DOC_PATTERNS.commit, confidence: 85 },
+        ],
+        preferredModel: 'balanced',
+        systemPromptAddition: `
+You are helping write content in profClaw.
+
+## Capabilities
+- Write clear documentation
+- Draft well-structured tickets and issues
+- Create PR descriptions and commit messages
+- Generate release notes and changelogs
+
+## Guidelines
+- Be concise but complete
+- Use proper formatting (markdown)
+- Follow conventional commit style
+- Include relevant context and acceptance criteria`,
+        examples: [
+            'Write a ticket for adding dark mode',
+            'Generate a commit message for these changes',
+            'Draft documentation for the API',
+        ],
+    },
+    {
+        id: 'general',
+        name: 'General Assistant',
+        description: 'General help and conversation',
+        icon: 'bot',
+        capabilities: ['general_chat', 'explanation'],
+        patterns: [
+            { pattern: GENERAL_PATTERNS.greeting, confidence: 70 },
+            { pattern: GENERAL_PATTERNS.help, confidence: 80 },
+            { pattern: GENERAL_PATTERNS.thanks, confidence: 60 },
+        ],
+        preferredModel: 'fast',
+        systemPromptAddition: `
+You are the profClaw assistant helping users with their questions.
+
+## What You Can Help With
+- Task management and organization
+- Code assistance and reviews
+- Analysis and insights
+- Documentation and writing
+
+## What You Cannot Do
+- Execute code or run scripts
+- Directly modify files or databases
+- Access external services
+- Remember information between sessions (use conversation history)
+
+If asked to do something outside your capabilities, explain what you CAN do instead.`,
+        examples: [
+            'Hello!',
+            'What can you help me with?',
+            'Thanks for your help',
+        ],
+    },
+];
+// === Intent Detection ===
+/**
+ * Detect user intent and match to the best skill
+ */
+export function detectIntent(message, context) {
+    const matches = [];
+    for (const skill of CHAT_SKILLS) {
+        let bestMatch = {
+            confidence: 0,
+        };
+        // Check each pattern
+        for (const intentPattern of skill.patterns) {
+            const match = message.match(intentPattern.pattern);
+            if (match) {
+                let confidence = intentPattern.confidence;
+                // Boost confidence if context matches requirements
+                if (skill.requiresContext) {
+                    if (skill.requiresContext.includes('task') && context?.hasTask) {
+                        confidence += 10;
+                    }
+                    if (skill.requiresContext.includes('ticket') && context?.hasTicket) {
+                        confidence += 10;
+                    }
+                }
+                // Boost for code-related when code is present
+                if (skill.id === 'code-assistant' && context?.hasCode) {
+                    confidence += 15;
+                }
+                if (confidence > bestMatch.confidence) {
+                    bestMatch = {
+                        confidence,
+                        pattern: intentPattern.pattern.source,
+                        vars: intentPattern.extract
+                            ? extractVariables(match, intentPattern.extract)
+                            : undefined,
+                    };
+                }
+            }
+        }
+        if (bestMatch.confidence > 0) {
+            matches.push({
+                skill,
+                confidence: Math.min(bestMatch.confidence, 100),
+                matchedPattern: bestMatch.pattern,
+                extractedVars: bestMatch.vars,
+            });
+        }
+    }
+    // Sort by confidence (highest first)
+    matches.sort((a, b) => b.confidence - a.confidence);
+    // If no matches, fall back to general
+    if (matches.length === 0) {
+        const generalSkill = CHAT_SKILLS.find(s => s.id === 'general');
+        if (generalSkill) {
+            matches.push({
+                skill: generalSkill,
+                confidence: 50,
+            });
+        }
+    }
+    return matches;
+}
+/**
+ * Extract named variables from regex match
+ */
+function extractVariables(match, names) {
+    const vars = {};
+    names.forEach((name, i) => {
+        if (match[i + 1]) {
+            vars[name] = match[i + 1];
+        }
+    });
+    return vars;
+}
+export const MODEL_TIERS = [
+    {
+        tier: 'fast',
+        models: ['llama3.2', 'gpt-4o-mini', 'claude-3-haiku', 'gemini-flash'],
+        description: 'Quick responses for simple tasks',
+        maxTokens: 2000,
+        costMultiplier: 0.1,
+    },
+    {
+        tier: 'balanced',
+        models: ['gpt-4o', 'claude-3-sonnet', 'gemini-pro'],
+        description: 'Good balance of speed and quality',
+        maxTokens: 4000,
+        costMultiplier: 1,
+    },
+    {
+        tier: 'powerful',
+        models: ['gpt-4-turbo', 'claude-3-opus', 'gemini-ultra'],
+        description: 'Best quality for complex tasks',
+        maxTokens: 8000,
+        costMultiplier: 5,
+    },
+];
+/**
+ * Select the best model based on skill and message complexity
+ */
+export function selectModel(skillMatch, message, availableModels) {
+    // Determine target tier based on skill preference
+    let targetTier = skillMatch.skill.preferredModel || 'balanced';
+    // Adjust based on message complexity
+    const complexity = estimateComplexity(message);
+    if (complexity > 0.7 && targetTier !== 'powerful') {
+        targetTier = 'powerful';
+    }
+    else if (complexity < 0.3 && targetTier === 'powerful') {
+        targetTier = 'balanced';
+    }
+    // Find the tier
+    const tier = MODEL_TIERS.find(t => t.tier === targetTier) || MODEL_TIERS[1];
+    // Find an available model in this tier (or fallback to any available)
+    let selectedModel = tier.models.find(m => availableModels.some(am => am.toLowerCase().includes(m.toLowerCase())));
+    if (!selectedModel) {
+        // Fallback to first available model
+        selectedModel = availableModels[0] || 'local';
+    }
+    return {
+        model: selectedModel,
+        tier,
+        reason: `${skillMatch.skill.name} with ${complexity > 0.5 ? 'complex' : 'simple'} request`,
+    };
+}
+/**
+ * Estimate message complexity (0-1 scale)
+ */
+function estimateComplexity(message) {
+    let score = 0;
+    // Length factor
+    if (message.length > 500)
+        score += 0.2;
+    if (message.length > 1000)
+        score += 0.2;
+    // Code presence
+    if (message.includes('```'))
+        score += 0.3;
+    if (/function|class|interface|type\s+\w+/i.test(message))
+        score += 0.2;
+    // Technical terms
+    const technicalTerms = /(?:algorithm|architecture|optimize|refactor|debug|security|performance|async|concurrent)/gi;
+    const termMatches = message.match(technicalTerms);
+    if (termMatches)
+        score += Math.min(termMatches.length * 0.1, 0.3);
+    // Multiple questions
+    const questionCount = (message.match(/\?/g) || []).length;
+    if (questionCount > 1)
+        score += 0.1 * Math.min(questionCount, 3);
+    return Math.min(score, 1);
+}
+// === Skill-Enhanced System Prompt ===
+/**
+ * Build a system prompt enhanced with matched skill context
+ */
+export function buildSkillPrompt(basePrompt, skillMatch, context) {
+    let prompt = basePrompt;
+    // Add skill-specific instructions
+    prompt += `\n\n## Current Mode: ${skillMatch.skill.name}\n`;
+    prompt += skillMatch.skill.systemPromptAddition;
+    // Add grounding to prevent hallucinations
+    prompt += `\n\n## Important Constraints
+- Only claim capabilities listed above
+- If you cannot do something, say so clearly and suggest alternatives
+- Do not invent features or claim to run scripts you cannot execute
+- Stay focused on what the user is asking`;
+    // Add context if available
+    if (context?.task) {
+        prompt += `\n\n## Current Task Context
+- Task ID: ${context.task.id}
+- Title: ${context.task.title}
+- Status: ${context.task.status}
+- Agent: ${context.task.agent || 'unassigned'}`;
+    }
+    if (context?.ticket) {
+        prompt += `\n\n## Current Ticket Context
+- Ticket ID: ${context.ticket.id}
+- Title: ${context.ticket.title}
+- Status: ${context.ticket.status}`;
+    }
+    return prompt;
+}
+export default {
+    CHAT_SKILLS,
+    MODEL_TIERS,
+    detectIntent,
+    selectModel,
+    buildSkillPrompt,
+};
+//# sourceMappingURL=skills.js.map