profclaw 2.0.0 → 2.3.0

package/dist/chat/message-handler.js

@@ -29,11 +29,16 @@ import { buildSystemPrompt } from './system-prompts.js';
 import { createConversation, addMessage, getConversationMessages, } from './conversations.js';
 import { needsCompaction, compactMessages } from './memory.js';
 import { getSessionModel } from './execution/tools/session-status.js';
+import { routeQuery, recordRoutingDecision, isSmartRouterEnabled } from '../providers/smart-router.js';
+import { AutomationPatternDetector } from './proactive/index.js';
+import { observeWindow } from '../memory/observational.js';
 // CONSTANTS
 /** Max concurrent AI calls to prevent overload (inspired by NanoClaw GroupQueue) */
 const MAX_CONCURRENT = parseInt(process.env['POOL_MAX_CONCURRENT'] ?? '50', 10);
 /** Currently processing count */
 let activeCount = 0;
+/** Singleton automation pattern detector - learns across all conversations */
+const patternDetector = new AutomationPatternDetector({ minOccurrences: 3 });
 // CONVERSATION CACHE
 /** In-memory cache: "telegram:default:12345" -> conversationId */
 const channelConversations = new Map();
@@ -151,8 +156,22 @@ async function handleIncomingMessage(event, _context) {
             const result = await compactMessages(messages);
             messages = result.messages;
         }
-        // Resolve model - per-conversation override or system default
-        const modelOverride = getSessionModel(conversationId);
+        // Resolve model - per-conversation override, smart routing, or system default
+        const sessionModel = getSessionModel(conversationId);
+        // Smart Model Router: auto-select cheapest capable model when no explicit override
+        const { aiProvider } = await import('../providers/ai-sdk.js');
+        let resolvedModel = sessionModel;
+        let routingDecision;
+        if (!sessionModel && isSmartRouterEnabled()) {
+            const availableProviders = new Set(aiProvider.getConfiguredProviders());
+            routingDecision = routeQuery(message.text, availableProviders, {
+                conversationLength: messages.length,
+                hasToolUse: false, // simple chat path has no tools
+                hasImages: false,
+            });
+            resolvedModel = routingDecision.selectedModel.id;
+            recordRoutingDecision(routingDecision);
+        }
         // Build system prompt with channel personality
         const personality = groupManager.getPersonality(message.chatId, message.provider);
         const promptContext = {
@@ -160,7 +179,7 @@ async function handleIncomingMessage(event, _context) {
                 name: message.senderName || message.senderUsername,
             },
             runtime: {
-                model: modelOverride,
+                model: resolvedModel,
                 conversationId,
             },
         };
@@ -182,11 +201,10 @@ async function handleIncomingMessage(event, _context) {
             content: message.text,
             timestamp: message.timestamp.toISOString(),
         });
-        // Call AI (lazy import to avoid loading all AI SDKs at startup)
-        const { aiProvider } = await import('../providers/ai-sdk.js');
+        // Call AI with smart-routed or user-selected model
         const response = await aiProvider.chat({
             messages: aiMessages,
-            model: modelOverride,
+            model: resolvedModel,
             systemPrompt,
             temperature: 0.7,
         });
@@ -227,7 +245,41 @@ async function handleIncomingMessage(event, _context) {
             conversationId,
             model: response.model,
             tokens: response.usage.totalTokens,
+            ...(routingDecision && {
+                smartRouted: true,
+                complexity: routingDecision.complexity.tier,
+                savings: `${routingDecision.savingsPercent}%`,
+            }),
         });
+        // Track query for automation pattern detection (non-blocking)
+        patternDetector.recordQuery(message.text);
+        const automationHint = patternDetector.detectPatterns();
+        if (automationHint) {
+            // Send a follow-up suggestion message
+            const hint = automationHint.suggestion;
+            const suggestionText = `${hint.message}\n\nI can set this up: "${hint.templateName}" (${hint.suggestedCron}).\nJust say "automate it" or "set it up" to create this automation.`;
+            sendProviderMessage({
+                provider: message.provider,
+                accountId: message.accountId,
+                to: message.chatId,
+                text: suggestionText,
+                threadId: replyTarget.threadId,
+            }).catch(() => { }); // fire and forget
+            logger.info('[MessageHandler] Automation pattern detected', {
+                pattern: automationHint.pattern,
+                count: automationHint.count,
+                template: hint.templateName,
+            });
+        }
+        // Observational memory: extract learnings every 10 messages (async, non-blocking)
+        if (messages.length > 0 && messages.length % 10 === 0) {
+            const observationMessages = messages.map(m => ({
+                role: m.role,
+                content: m.content,
+            }));
+            observeWindow(conversationId, observationMessages, 20, message.senderUsername)
+                .catch(() => { }); // fire and forget
+        }
     }
     catch (error) {
         logger.error('[MessageHandler] Failed to process message', {

package/dist/chat/proactive/index.d.ts

@@ -163,5 +163,67 @@ export declare class BackgroundResearcher {
     inject(taskId: string, results: ResearchResult[]): void;
     private run;
 }
+export interface PatternMatch {
+    pattern: string;
+    count: number;
+    firstSeen: number;
+    lastSeen: number;
+    /** Suggested automation */
+    suggestion: AutomationSuggestion;
+}
+export interface AutomationSuggestion {
+    message: string;
+    templateName: string;
+    suggestedCron: string;
+    params: Record<string, unknown>;
+}
+/**
+ * Detects repeated patterns in user queries and suggests automations.
+ *
+ * Tracks query frequency, tool usage patterns, and timing to identify
+ * tasks that should be automated via cron jobs.
+ */
+export declare class AutomationPatternDetector {
+    private queryHistory;
+    private dismissedPatterns;
+    private maxHistory;
+    private readonly minOccurrences;
+    private readonly windowMs;
+    /** Max 1 suggestion per session */
+    private suggestedThisSession;
+    constructor(options?: {
+        /** Min occurrences before suggesting automation (default: 3) */
+        minOccurrences?: number;
+        /** Time window to look at (default: 7 days) */
+        windowMs?: number;
+    });
+    /**
+     * Record a user query for pattern analysis.
+     */
+    recordQuery(query: string, toolsUsed?: string[]): void;
+    /**
+     * Check for automation-worthy patterns.
+     * Returns a suggestion if a pattern is detected, or null.
+     * Only returns one suggestion per session to avoid fatigue.
+     */
+    detectPatterns(): PatternMatch | null;
+    /**
+     * User dismissed a suggestion - don't suggest it again.
+     */
+    dismiss(pattern: string): void;
+    /**
+     * Reset session state (call at session start).
+     */
+    resetSession(): void;
+    /**
+     * Normalize a query for pattern matching.
+     * Strips dates, numbers, and common filler to find the core intent.
+     */
+    private normalizeQuery;
+    /**
+     * Build an automation suggestion from a detected pattern.
+     */
+    private buildSuggestion;
+}
 export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/chat/proactive/index.js

@@ -720,4 +720,151 @@ export class BackgroundResearcher {
         }
     }
 }
+/**
+ * Detects repeated patterns in user queries and suggests automations.
+ *
+ * Tracks query frequency, tool usage patterns, and timing to identify
+ * tasks that should be automated via cron jobs.
+ */
+export class AutomationPatternDetector {
+    queryHistory = [];
+    dismissedPatterns = new Set();
+    maxHistory = 500;
+    minOccurrences;
+    windowMs;
+    /** Max 1 suggestion per session */
+    suggestedThisSession = false;
+    constructor(options) {
+        this.minOccurrences = options?.minOccurrences ?? 3;
+        this.windowMs = options?.windowMs ?? 7 * 24 * 60 * 60 * 1000;
+    }
+    /**
+     * Record a user query for pattern analysis.
+     */
+    recordQuery(query, toolsUsed = []) {
+        this.queryHistory.push({
+            query,
+            normalized: this.normalizeQuery(query),
+            timestamp: Date.now(),
+            toolsUsed,
+        });
+        // Trim old entries
+        if (this.queryHistory.length > this.maxHistory) {
+            this.queryHistory = this.queryHistory.slice(-this.maxHistory);
+        }
+    }
+    /**
+     * Check for automation-worthy patterns.
+     * Returns a suggestion if a pattern is detected, or null.
+     * Only returns one suggestion per session to avoid fatigue.
+     */
+    detectPatterns() {
+        if (this.suggestedThisSession)
+            return null;
+        const cutoff = Date.now() - this.windowMs;
+        const recent = this.queryHistory.filter((q) => q.timestamp >= cutoff);
+        // Group by normalized query
+        const groups = new Map();
+        for (const record of recent) {
+            const existing = groups.get(record.normalized) || [];
+            existing.push(record);
+            groups.set(record.normalized, existing);
+        }
+        // Find patterns that exceed threshold
+        for (const [normalized, records] of groups) {
+            if (records.length < this.minOccurrences)
+                continue;
+            if (this.dismissedPatterns.has(normalized))
+                continue;
+            const suggestion = this.buildSuggestion(normalized, records);
+            if (!suggestion)
+                continue;
+            this.suggestedThisSession = true;
+            return {
+                pattern: normalized,
+                count: records.length,
+                firstSeen: records[0].timestamp,
+                lastSeen: records[records.length - 1].timestamp,
+                suggestion,
+            };
+        }
+        return null;
+    }
+    /**
+     * User dismissed a suggestion - don't suggest it again.
+     */
+    dismiss(pattern) {
+        this.dismissedPatterns.add(pattern);
+    }
+    /**
+     * Reset session state (call at session start).
+     */
+    resetSession() {
+        this.suggestedThisSession = false;
+    }
+    /**
+     * Normalize a query for pattern matching.
+     * Strips dates, numbers, and common filler to find the core intent.
+     */
+    normalizeQuery(query) {
+        return query
+            .toLowerCase()
+            .replace(/\b(today|yesterday|this week|last week|this morning)\b/g, '')
+            .replace(/\b\d{4}[-/]\d{2}[-/]\d{2}\b/g, '')
+            .replace(/\b\d+\b/g, 'N')
+            .replace(/\s+/g, ' ')
+            .trim();
+    }
+    /**
+     * Build an automation suggestion from a detected pattern.
+     */
+    buildSuggestion(normalized, records) {
+        // Detect common tool patterns
+        const toolCounts = new Map();
+        for (const record of records) {
+            for (const tool of record.toolsUsed) {
+                toolCounts.set(tool, (toolCounts.get(tool) || 0) + 1);
+            }
+        }
+        const usesWebSearch = (toolCounts.get('web_search') || 0) >= 2;
+        const usesWebFetch = (toolCounts.get('web_fetch') || 0) >= 2;
+        // News/research patterns
+        if (usesWebSearch || normalized.includes('news') || normalized.includes('latest') || normalized.includes('update')) {
+            return {
+                message: `You've asked about this ${records.length} times recently. Want me to set up a daily digest?`,
+                templateName: 'Morning AI News Digest',
+                suggestedCron: '0 7 * * 1-5',
+                params: { prompt: records[records.length - 1].query },
+            };
+        }
+        // Status/report patterns
+        if (normalized.includes('status') || normalized.includes('summary') || normalized.includes('report')) {
+            return {
+                message: `You check this regularly. Want me to generate this report automatically?`,
+                templateName: 'Daily Status Report',
+                suggestedCron: '0 9 * * 1-5',
+                params: { prompt: records[records.length - 1].query },
+            };
+        }
+        // Health/monitoring patterns
+        if (normalized.includes('health') || normalized.includes('check') || normalized.includes('monitor')) {
+            return {
+                message: `You run this check often. Want me to monitor this automatically?`,
+                templateName: 'Health Check',
+                suggestedCron: '*/30 * * * *',
+                params: { prompt: records[records.length - 1].query },
+            };
+        }
+        // Generic repeated task
+        if (records.length >= 5) {
+            return {
+                message: `You've done this ${records.length} times. Want me to automate it on a schedule?`,
+                templateName: 'Custom AI Agent Task',
+                suggestedCron: '0 9 * * *',
+                params: { prompt: records[records.length - 1].query },
+            };
+        }
+        return null;
+    }
+}
 //# sourceMappingURL=index.js.map

package/dist/chat/prompt-adapter.js

@@ -71,6 +71,8 @@ function getContextWindow(modelId) {
         return 32768;
     if (/phi/i.test(modelId))
         return 16384;
+    if (/gemma-?4/i.test(modelId))
+        return 128000;
     if (/gemma/i.test(modelId))
         return 8192;
     return 32768;

package/dist/chat/providers/irc/index.d.ts

@@ -47,10 +47,10 @@ export declare const IRCAccountConfigSchema: z.ZodObject<{
     channels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     useTLS: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
+    port: number;
     id: string;
     provider: "irc";
     enabled: boolean;
-    port: number;
     useTLS: boolean;
     name?: string | undefined;
     isDefault?: boolean | undefined;
@@ -62,10 +62,10 @@ export declare const IRCAccountConfigSchema: z.ZodObject<{
     id: string;
     provider: "irc";
     name?: string | undefined;
+    port?: number | undefined;
     isDefault?: boolean | undefined;
     enabled?: boolean | undefined;
     password?: string | undefined;
-    port?: number | undefined;
     channels?: string[] | undefined;
     server?: string | undefined;
     nick?: string | undefined;

package/dist/chat/providers/telegram/index.d.ts

@@ -28,6 +28,7 @@ interface TelegramChat {
 }
 interface TelegramMessage {
     message_id: number;
+    message_thread_id?: number;
     from?: TelegramUser;
     chat: TelegramChat;
     date: number;
@@ -48,6 +49,7 @@ interface TelegramMessage {
         file_name?: string;
         mime_type?: string;
     };
+    is_topic_message?: boolean;
 }
 interface TelegramCallbackQuery {
     id: string;

package/dist/chat/providers/telegram/index.js

@@ -46,7 +46,7 @@ const capabilities = {
     reactions: true,
     edit: true,
     delete: true,
-    threads: false, // Telegram uses reply-to
+    threads: true, // Forum topics via message_thread_id
     media: true,
     richBlocks: false, // Uses HTML/Markdown
     oauth: false,
@@ -176,11 +176,26 @@ const outboundAdapter = {
         const chunks = textChunks.length > 0 ? textChunks : [undefined];
         let replyToId = message.replyToId ? parseInt(message.replyToId, 10) : undefined;
         let firstMessage;
+        // Parse topic from threadId or "chatId:topic:topicId" format in `to`
+        let targetChatId = message.to;
+        let topicId;
+        if (message.threadId) {
+            topicId = parseInt(message.threadId, 10);
+        }
+        else if (targetChatId.includes(':topic:')) {
+            const parts = targetChatId.split(':topic:');
+            targetChatId = parts[0];
+            topicId = parseInt(parts[1], 10);
+        }
         for (const [index, chunk] of chunks.entries()) {
             const params = {
-                chat_id: message.to,
+                chat_id: targetChatId,
                 parse_mode: 'HTML',
             };
+            // Forum topic support
+            if (topicId && !isNaN(topicId)) {
+                params.message_thread_id = topicId;
+            }
             if (chunk !== undefined) {
                 params.text = chunk;
             }
@@ -288,6 +303,10 @@ const inboundAdapter = {
             chatType: getChatType(message.chat.type),
             chatId: String(message.chat.id),
             chatName: message.chat.title || message.chat.first_name,
+            // Forum topic support: include topic ID as threadId
+            threadId: message.message_thread_id
+                ? String(message.message_thread_id)
+                : undefined,
             replyToId: message.reply_to_message
                 ? String(message.reply_to_message.message_id)
                 : undefined,

package/dist/chat/system-prompts.d.ts

@@ -13,10 +13,10 @@ export interface RuntimeInfo {
     conversationId?: string;
     sessionOverride?: string;
 }
-export declare const PROFCLAW_CONTEXT = "You are profClaw Assistant, an AI helper integrated into profClaw Task Manager.\n\nprofClaw is a task orchestration platform for AI-assisted development - managing tickets, routing work to AI agents, and tracking progress.\n\n## Response Style\n- Be helpful and concise\n- Use markdown for structure\n- Match effort to the request - simple questions get simple answers\n- Ask clarifying questions when needed";
+export declare const PROFCLAW_CONTEXT = "You are profClaw, a personal AI assistant running inside profClaw engine.\nYou help with coding, research, automation, and general tasks. You have access to tools - use them.\n\n## Response Style\n- Be concise and direct. No filler, no preamble.\n- Do NOT use emoji headers, LaTeX, or excessive formatting.\n- Use short paragraphs and plain markdown (headers, bold, code blocks only when needed).\n- Match the user's tone \u2014 casual question gets a casual answer.\n- Lead with the answer, then explain only if needed.";
 export declare const GROUNDING_SUFFIX = "\n\n## Important Reminder\nYou are a chat assistant, not an execution engine. You can:\n- Help draft content, analyze information, and answer questions\n- Provide guidance on how to use profClaw\n\nYou CANNOT:\n- Execute code, run scripts, or make API calls\n- Directly modify tasks, tickets, or any data\n- Access external systems or the user's files\n\nIf asked to \"run\" or \"execute\" something, explain that you can help write or draft it, but the user needs to execute it themselves through the profClaw UI or API.";
-export declare const TOOL_ENABLED_SUFFIX = "\n\n## Tool Usage\nYou have access to tools that allow you to:\n- **Read files** and search codebases\n- **Fetch web content** from URLs (web_fetch tool)\n- **Browse websites** interactively (browser_navigate, browser_screenshot)\n- **Execute system commands** (with user approval for dangerous ones)\n- **Access profClaw operations** (list tasks, tickets, etc.)\n\nWhen the user asks you to do something that requires these capabilities:\n1. Use the appropriate tool - don't say you can't do it\n2. If a tool requires approval, explain what you're trying to do and wait for approval\n3. After tool execution, continue the conversation and explain what you found/did\n4. If a tool fails, explain the error and suggest alternatives\n\n**IMPORTANT**: When a tool returns \"pending\" or \"requires approval\", tell the user you're waiting for their approval in the UI, then STOP and wait. Do not continue until approval is given.\n\n**After approval**: Once a tool is approved and executed, summarize the results and continue helping the user.";
-export declare const AGENT_MODE_SUFFIX = "\n\n## Tool Usage\nYou have access to tools. Use them when you NEED external data or actions.\n\n**DO NOT use tools for:**\n- Greetings (\"hi\", \"hello\") \u2192 Just respond naturally\n- Questions about yourself \u2192 Explain from knowledge\n- General knowledge questions \u2192 Answer directly\n- Acknowledgments, thanks, small talk \u2192 Just respond\n\n**USE tools when you need to:**\n- Read files, fetch web data, run commands\n- Create/update tickets, projects, or other profClaw resources\n- Perform any action the user explicitly requests\n\n**When using tools:**\n- Chain tools to complete multi-step requests \u2014 don't stop after one call\n- Use parallel tool calls when steps are independent\n- Do NOT ask for confirmation \u2014 just execute the requested actions\n- After all steps are done, call `complete_task` with a summary\n\n**When NOT using tools:**\n- Respond with text directly \u2014 do NOT call `complete_task` for text-only responses";
+export declare const TOOL_ENABLED_SUFFIX = "\n\n## Tools \u2014 YOU MUST USE THEM\nYou have real tools that execute actions. You are NOT limited to text responses.\n\nALWAYS call a tool when the user asks you to:\n- Search the web \u2192 call web_search\n- Read a URL or website \u2192 call web_fetch\n- Read a file \u2192 call read_file\n- Run a command \u2192 call exec\n- Write a file \u2192 call write_file\n\nDo NOT say \"I can't browse the web\" or \"I can't access files.\" You CAN. Call the tool.\nIf you're unsure, call the tool anyway \u2014 it's better to try and fail than refuse.";
+export declare const AGENT_MODE_SUFFIX = "\n\n## Tool Call Style\nDo not narrate routine tool calls - just call the tool.\nNarrate only for multi-step work, complex problems, or sensitive actions.\nWhen a tool exists for an action, use it directly. Never say \"I can't do that\" when a tool can.\n\n## Tool Usage\nYou have tools. Use them when the task requires external data or actions.\n\n**ALWAYS use tools for:**\n- Any search/lookup/research request -> web_search\n- Reading a URL/website -> web_fetch\n- File operations -> read_file, write_file, edit_file, grep\n- Running commands -> exec\n- Git/GitHub operations -> git_*, github_pr, create_pr\n- Code quality -> typecheck, lint, build, test_run\n- \"What is X?\" about anything specific -> web_search (do NOT guess)\n\n**Skip tools only for:** greetings, thanks, simple math, questions about yourself.\n\n**Rules:**\n- Chain tools for multi-step tasks. Do not stop after one call.\n- Use parallel calls when steps are independent.\n- Do NOT ask permission. Just execute.\n- If a tool fails, try an alternative approach.\n- After completing work, call complete_task with a brief summary.\n- For text-only replies, do NOT call complete_task.\n\n## Skills\nYou have access to skills (see Available Skills list). Before starting a complex task:\n1. Scan the skills list for a relevant skill\n2. If found, read the skill's SKILL.md with read_file to get detailed instructions\n3. Follow the skill's workflow\n\n## Workspace\nTreat the current directory as your workspace. Use relative paths.\nWhen modifying code: read first, then edit, then verify (typecheck/test).\n\n## Safety\nDo not pursue independent goals beyond the user's request.\nPrioritize safety and human oversight. If instructions conflict, ask.\nDo not manipulate access controls or bypass safeguards.";
 export interface ChatPreset {
     id: string;
     name: string;