profclaw 2.0.0 → 2.3.0

package/dist/cron/scheduler.js

@@ -523,6 +523,9 @@ export class JobScheduler {
                 case 'message':
                     result = await this.executeMessageJob(job.payload);
                     break;
+                case 'agent_session':
+                    result = await this.executeAgentSessionJob(job.payload);
+                    break;
                 default:
                     result = { success: false, error: `Unknown job type: ${job.jobType}`, durationMs: 0 };
             }
@@ -646,6 +649,7 @@ export class JobScheduler {
         const delivery = job.delivery;
         if (!delivery?.channels?.length)
             return;
+        const deliveryResults = [];
         for (const channel of delivery.channels) {
             // Check if we should deliver based on result
             const shouldDeliver = (result.success && channel.onSuccess !== false) ||
@@ -655,7 +659,13 @@ export class JobScheduler {
             try {
                 switch (channel.type) {
                     case 'slack':
-                        await this.deliverToSlack(channel.target, job, result);
+                        await this.deliverToChatProvider('slack', channel.target, job, result);
+                        break;
+                    case 'telegram':
+                        await this.deliverToChatProvider('telegram', channel.target, job, result);
+                        break;
+                    case 'discord':
+                        await this.deliverToChatProvider('discord', channel.target, job, result);
                         break;
                     case 'webhook':
                         await this.deliverToWebhook(channel.target, job, result);
@@ -664,21 +674,80 @@ export class JobScheduler {
                         await this.deliverToEmail(channel.target, job, result);
                         break;
                 }
+                deliveryResults.push({ channel: `${channel.type}:${channel.target}`, success: true });
             }
             catch (error) {
-                log.error(`Failed to deliver to ${channel.type}:${channel.target}:`, error instanceof Error ? error : new Error(String(error)));
+                const errMsg = error instanceof Error ? error.message : String(error);
+                log.error(`Failed to deliver to ${channel.type}:${channel.target}:`, error instanceof Error ? error : new Error(errMsg));
+                deliveryResults.push({ channel: `${channel.type}:${channel.target}`, success: false, error: errMsg });
             }
         }
+        if (deliveryResults.length > 0) {
+            const succeeded = deliveryResults.filter((d) => d.success).length;
+            const failed = deliveryResults.filter((d) => !d.success).length;
+            log.info(`Delivery complete: ${succeeded} succeeded, ${failed} failed`, {
+                jobId: job.id,
+                results: deliveryResults,
+            });
+        }
     }
     /**
-     * Deliver output to Slack channel
+     * Deliver output via a chat provider (Telegram, Slack, Discord, etc.)
+     * Uses the chat provider registry for real message delivery.
+     *
+     * Target format:
+     *   - Telegram: "<chat_id>" or "<chat_id>:topic:<topic_id>"
+     *   - Slack: "#channel-name" or "C01234ABCDE"
+     *   - Discord: "<channel_id>"
      */
-    async deliverToSlack(target, job, result) {
-        // TODO: Implement Slack webhook integration
-        // For now, log the delivery attempt
-        log.info(`[Slack Delivery] Job: ${job.name}, Channel: ${target}, Success: ${result.success}`);
-        // This will be implemented when Slack OAuth is integrated
-        // Will use the Slack API to post to the channel
+    async deliverToChatProvider(providerName, target, job, result) {
+        const { getChatRegistry } = await import('../chat/providers/registry.js');
+        const registry = getChatRegistry();
+        const provider = registry.get(providerName);
+        if (!provider) {
+            log.warn(`[Delivery] Chat provider "${providerName}" not registered, skipping`);
+            return;
+        }
+        // Parse target for topic support (Telegram: "chatId:topic:topicId")
+        let chatId = target;
+        let threadId;
+        if (providerName === 'telegram' && target.includes(':topic:')) {
+            const parts = target.split(':topic:');
+            chatId = parts[0];
+            threadId = parts[1];
+        }
+        // Convert markdown to channel-appropriate format
+        const { convertMarkdown } = await import('../chat/format/markdown-convert.js');
+        const formatTarget = providerName === 'telegram' ? 'telegram'
+            : providerName === 'slack' ? 'slack'
+                : 'plain';
+        const statusIcon = result.success ? '\u2705' : '\u274c';
+        const rawBody = result.output
+            ? result.output.slice(0, 3800)
+            : result.error
+                ? `Error: ${result.error}`
+                : 'No output';
+        // Convert agent markdown output to channel format
+        const formattedBody = convertMarkdown(rawBody, formatTarget);
+        const header = providerName === 'telegram'
+            ? `${statusIcon} <b>${job.name}</b>`
+            : `${statusIcon} *${job.name}*`;
+        const footer = result.durationMs
+            ? providerName === 'telegram'
+                ? `\n\n<i>${(result.durationMs / 1000).toFixed(1)}s</i>`
+                : `\n\n_${(result.durationMs / 1000).toFixed(1)}s_`
+            : '';
+        const text = `${header}\n\n${formattedBody}${footer}`;
+        const sendResult = await provider.outbound.send({
+            provider: providerName,
+            to: chatId,
+            text,
+            threadId,
+        });
+        if (!sendResult.success) {
+            throw new Error(`${providerName} delivery failed: ${sendResult.error}`);
+        }
+        log.info(`[${providerName}] Delivered to ${target}: ${result.success ? 'success' : 'failure'}`);
     }
     /**
      * Deliver output to a webhook URL
@@ -858,6 +927,69 @@ export class JobScheduler {
             };
         }
     }
+    /**
+     * Execute an agent session job.
+     * Spawns an isolated agent with tool access, runs the prompt, returns the output.
+     * This is the core of the automation pipeline - enables "run this prompt every morning".
+     */
+    async executeAgentSessionJob(payload) {
+        const startTime = Date.now();
+        const timeout = 300000; // 5 min max per agent session
+        try {
+            const { executeAgenticChat } = await import('../chat/agentic-executor.js');
+            const { createChatToolHandler } = await import('../chat/tool-handler.js');
+            const conversationId = `cron-agent-${crypto.randomUUID()}`;
+            // Create tool handler with full access (security mode = full for automated jobs)
+            const toolHandler = await createChatToolHandler({
+                conversationId,
+                securityMode: 'full',
+                workdir: payload.workdir || process.cwd(),
+            });
+            // Filter tools if allowedTools specified
+            const allTools = toolHandler.getTools();
+            const tools = payload.allowedTools?.length
+                ? allTools.filter((t) => payload.allowedTools.includes(t.name))
+                : allTools;
+            const systemPrompt = payload.systemPrompt ||
+                'You are profClaw, an automated AI assistant running a scheduled task. ' +
+                    'Execute the user\'s request thoroughly. Use available tools (web_search, web_fetch, etc.) as needed. ' +
+                    'Be concise and deliver actionable results. Format output as clean text suitable for messaging.';
+            const response = await Promise.race([
+                executeAgenticChat({
+                    conversationId,
+                    messages: [{
+                            id: crypto.randomUUID(),
+                            role: 'user',
+                            content: payload.prompt,
+                            timestamp: new Date().toISOString(),
+                        }],
+                    systemPrompt,
+                    model: payload.model,
+                    provider: payload.provider,
+                    effort: payload.effort || 'medium',
+                    toolHandler,
+                    tools: tools.map((t) => ({
+                        name: t.name,
+                        description: t.description,
+                        parameters: t.parameters,
+                    })),
+                }),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('Agent session timed out after 5 minutes')), timeout)),
+            ]);
+            return {
+                success: true,
+                output: response.content,
+                durationMs: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                durationMs: Date.now() - startTime,
+            };
+        }
+    }
     /**
      * Calculate next run time from cron or interval
      */

package/dist/cron/templates.d.ts

@@ -23,7 +23,7 @@ export interface JobTemplate {
     createdAt: Date;
     updatedAt: Date;
 }
-export type TemplateCategory = 'sync' | 'report' | 'cleanup' | 'notification' | 'monitoring' | 'custom';
+export type TemplateCategory = 'sync' | 'report' | 'cleanup' | 'notification' | 'monitoring' | 'automation' | 'custom';
 export interface CreateTemplateParams {
     name: string;
     description?: string;

package/dist/cron/templates.js

@@ -218,6 +218,225 @@ export const BUILT_IN_TEMPLATES = [
         suggestedCron: '0 2 * * *', // Daily at 2 AM
         isBuiltIn: true,
     },
+    // --- Feed Polling ---
+    {
+        name: 'Feed Poller',
+        description: 'Poll all enabled RSS/Atom feeds for new articles. Runs hourly by default.',
+        icon: '📡',
+        category: 'sync',
+        jobType: 'tool',
+        payloadTemplate: {
+            tool: 'poll_all_feeds',
+            params: {},
+        },
+        suggestedCron: '0 * * * *', // Every hour
+        isBuiltIn: true,
+    },
+    // --- Automation Templates (agent_session) ---
+    {
+        name: 'Morning AI News Digest',
+        description: 'Search for the latest AI and tech news, summarize the top stories, and deliver to your preferred channel',
+        icon: '📰',
+        category: 'automation',
+        jobType: 'agent_session',
+        payloadTemplate: {
+            prompt: 'Search for the latest AI and technology news from today. Find the top 5 most important stories. For each story provide: 1) A one-line headline, 2) A 2-3 sentence summary, 3) Why it matters. Format the output cleanly for a messaging app. No markdown headers, use plain text with line breaks.',
+            effort: 'medium',
+        },
+        suggestedCron: '0 7 * * 1-5', // 7 AM weekdays
+        defaultDelivery: {
+            channels: [
+                { type: 'telegram', target: '{{telegramChatId}}', onSuccess: true, onFailure: true },
+            ],
+        },
+        defaultRetryPolicy: {
+            enabled: true,
+            initialDelayMs: 300000,
+            backoffMultiplier: 2,
+            maxDelayMs: 1800000,
+            maxRetries: 2,
+        },
+        isBuiltIn: true,
+    },
+    {
+        name: 'Daily Standup Prep',
+        description: 'Scan GitHub activity and Linear/Jira tickets to generate a standup-ready summary of what happened yesterday',
+        icon: '🧑‍💻',
+        category: 'automation',
+        jobType: 'agent_session',
+        payloadTemplate: {
+            prompt: 'Prepare a daily standup summary. Check recent GitHub commits, pull requests, and issue activity. Summarize: 1) What was completed yesterday, 2) What is in progress, 3) Any blockers or items needing attention. Keep it brief and actionable.',
+            effort: 'medium',
+        },
+        suggestedCron: '30 8 * * 1-5', // 8:30 AM weekdays
+        defaultDelivery: {
+            channels: [
+                { type: 'slack', target: '#standup', onSuccess: true },
+            ],
+        },
+        isBuiltIn: true,
+    },
+    {
+        name: 'Weekly Repo Digest',
+        description: 'Generate a weekly summary of repository activity including PRs merged, issues closed, and key changes',
+        icon: '📊',
+        category: 'automation',
+        jobType: 'agent_session',
+        payloadTemplate: {
+            prompt: 'Generate a weekly repository digest. Summarize: 1) Pull requests merged this week, 2) Issues opened and closed, 3) Notable code changes or patterns, 4) Contributors active this week. Format as a clean summary suitable for a team channel.',
+            effort: 'medium',
+        },
+        suggestedCron: '0 17 * * 5', // Friday 5 PM
+        defaultDelivery: {
+            channels: [
+                { type: 'slack', target: '#engineering', onSuccess: true },
+            ],
+        },
+        isBuiltIn: true,
+    },
+    {
+        name: 'Security Advisory Check',
+        description: 'Scan for new security advisories and CVEs relevant to your project dependencies',
+        icon: '🔒',
+        category: 'automation',
+        jobType: 'agent_session',
+        payloadTemplate: {
+            prompt: 'Search for the latest security advisories and CVEs published in the last 24 hours that are relevant to Node.js, TypeScript, and common web dependencies. Focus on critical and high severity issues. For each finding: 1) CVE ID and severity, 2) Affected package/version, 3) One-line description, 4) Recommended action. If nothing critical found, say so briefly.',
+            effort: 'medium',
+        },
+        suggestedCron: '0 9 * * *', // Daily 9 AM
+        defaultDelivery: {
+            channels: [
+                { type: 'slack', target: '#security', onSuccess: true, onFailure: true },
+            ],
+        },
+        isBuiltIn: true,
+    },
+    {
+        name: 'Feed-Powered News Digest',
+        description: 'Poll RSS feeds and summarize new articles. Cheaper and more reliable than web search for recurring news digests.',
+        icon: '📡',
+        category: 'automation',
+        jobType: 'agent_session',
+        payloadTemplate: {
+            prompt: 'Check the RSS feed engine for new articles from the last 24 hours. Summarize the top {{count}} most interesting stories. For each: a one-line headline and a 2-sentence summary. Focus on {{category}} feeds. Format for a messaging app - plain text, no markdown headers.',
+            effort: 'low',
+        },
+        suggestedCron: '0 7 * * *', // Daily 7 AM
+        defaultDelivery: {
+            channels: [
+                { type: 'telegram', target: '{{telegramChatId}}', onSuccess: true },
+            ],
+        },
+        isBuiltIn: true,
+    },
+    {
+        name: 'Custom AI Agent Task',
+        description: 'Run any prompt on a schedule with full tool access. The agent can search the web, read files, run commands, and more.',
+        icon: '🤖',
+        category: 'automation',
+        jobType: 'agent_session',
+        payloadTemplate: {
+            prompt: '{{prompt}}',
+            systemPrompt: '{{systemPrompt}}',
+            effort: 'medium',
+        },
+        suggestedCron: '0 9 * * *', // Daily 9 AM
+        isBuiltIn: true,
+    },
+    {
+        name: 'Competitor Watch',
+        description: 'Monitor competitor activity by searching for recent news, product launches, and announcements',
+        icon: '👁️',
+        category: 'automation',
+        jobType: 'agent_session',
+        payloadTemplate: {
+            prompt: 'Search for the latest news and announcements from {{competitors}}. Focus on: product launches, pricing changes, major partnerships, and funding rounds from the past week. Summarize the top 3-5 developments with links where possible.',
+            effort: 'medium',
+        },
+        suggestedCron: '0 8 * * 1', // Monday 8 AM
+        defaultDelivery: {
+            channels: [
+                { type: 'telegram', target: '{{telegramChatId}}', onSuccess: true },
+            ],
+        },
+        isBuiltIn: true,
+    },
+    // --- Feed Digest Templates ---
+    {
+        name: 'Morning AI News Digest',
+        description: 'Poll AI/tech RSS feeds and send a curated digest with summaries',
+        icon: '📰',
+        category: 'automation',
+        jobType: 'tool',
+        payloadTemplate: {
+            tool: 'feed_digest',
+            params: {
+                category: 'ai',
+                hours: 24,
+                limit: 15,
+            },
+        },
+        suggestedCron: '0 7 * * 1-5', // Weekdays 7 AM
+        defaultDelivery: {
+            channels: [
+                { type: 'telegram', target: '{{channel}}', onSuccess: true },
+            ],
+        },
+        isBuiltIn: true,
+    },
+    {
+        name: 'Dev News Digest',
+        description: 'Daily developer news from RSS feeds - frameworks, tools, releases',
+        icon: '💻',
+        category: 'automation',
+        jobType: 'tool',
+        payloadTemplate: {
+            tool: 'feed_digest',
+            params: {
+                category: 'dev',
+                hours: 24,
+                limit: 20,
+            },
+        },
+        suggestedCron: '0 8 * * 1-5', // Weekdays 8 AM
+        isBuiltIn: true,
+    },
+    {
+        name: 'Security Alert Digest',
+        description: 'Security news and vulnerability alerts from RSS feeds',
+        icon: '🔒',
+        category: 'automation',
+        jobType: 'tool',
+        payloadTemplate: {
+            tool: 'feed_digest',
+            params: {
+                category: 'security',
+                hours: 12,
+                limit: 10,
+            },
+        },
+        suggestedCron: '0 9,17 * * *', // Twice daily 9 AM and 5 PM
+        isBuiltIn: true,
+    },
+    {
+        name: 'Feed Poll + Digest Pipeline',
+        description: 'Poll all feeds for new articles, then generate and deliver a digest',
+        icon: '🔄📰',
+        category: 'automation',
+        jobType: 'agent_session',
+        payloadTemplate: {
+            prompt: 'First, poll all RSS feeds for new articles using the feed_poll tool. Then use feed_digest to get the latest articles from the last {{hours}} hours. Summarize the top {{limit}} articles into a brief, scannable digest with titles, one-line summaries, and links. Group by category if multiple categories exist.',
+            effort: 'low',
+        },
+        suggestedCron: '0 7 * * *', // Daily 7 AM
+        defaultDelivery: {
+            channels: [
+                { type: 'slack', target: '#news', onSuccess: true },
+            ],
+        },
+        isBuiltIn: true,
+    },
 ];
 // Template Service
 export class TemplateService {

package/dist/feeds/feed-engine.d.ts

@@ -0,0 +1,149 @@
+/**
+ * RSS/Atom Feed Engine
+ *
+ * Fetches, parses, and stores articles from RSS/Atom feeds.
+ * Provides deduplication, categorization, and AI summarization integration.
+ *
+ * Fully dynamic - categories, sources, and bundles can be extended at runtime.
+ * No hardcoded limitations on feed types, categories, or article counts.
+ *
+ * Used by cron jobs to power "morning AI news digest" and similar automations.
+ */
+export interface FeedSource {
+    id: string;
+    name: string;
+    url: string;
+    /** Free-form category - any string is valid */
+    category: string;
+    /** Optional tags for fine-grained filtering */
+    tags: string[];
+    enabled: boolean;
+    /** How often to poll (ms). Defaults to 1 hour */
+    pollIntervalMs: number;
+    lastPolledAt?: Date;
+    lastError?: string;
+    articleCount: number;
+    /** Custom metadata - extensible per feed */
+    metadata: Record<string, unknown>;
+    userId?: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface FeedArticle {
+    id: string;
+    feedId: string;
+    title: string;
+    url: string;
+    summary?: string;
+    content?: string;
+    author?: string;
+    publishedAt?: Date;
+    fetchedAt: Date;
+    /** AI-generated summary (populated by digest job) */
+    aiSummary?: string;
+    /** Whether this article has been included in a digest */
+    digestedAt?: Date;
+    /** Content hash for deduplication */
+    contentHash: string;
+}
+export interface CreateFeedParams {
+    name: string;
+    url: string;
+    category?: string;
+    tags?: string[];
+    pollIntervalMs?: number;
+    metadata?: Record<string, unknown>;
+    userId?: string;
+}
+export interface FeedDigest {
+    category?: string;
+    articles: FeedArticle[];
+    fetchedAt: Date;
+}
+export interface FeedBundleEntry {
+    name: string;
+    url: string;
+    category?: string;
+    tags?: string[];
+}
+export declare const FEED_BUNDLES: Record<string, FeedBundleEntry[]>;
+/**
+ * Register a custom feed bundle at runtime.
+ * Agents and users can call this to extend the available bundles.
+ */
+export declare function registerFeedBundle(name: string, feeds: FeedBundleEntry[]): void;
+export declare function addFeed(params: CreateFeedParams): Promise<FeedSource>;
+export declare function addFeedBundle(bundleName: string, userId?: string): Promise<FeedSource[]>;
+export declare function listFeeds(filters?: {
+    category?: string;
+    tag?: string;
+    enabled?: boolean;
+    userId?: string;
+}): Promise<FeedSource[]>;
+export declare function getFeed(id: string): Promise<FeedSource | null>;
+export declare function updateFeed(id: string, updates: Partial<Pick<CreateFeedParams, 'name' | 'category' | 'tags' | 'pollIntervalMs' | 'metadata'>>): Promise<void>;
+export declare function removeFeed(id: string): Promise<boolean>;
+export declare function toggleFeed(id: string, enabled: boolean): Promise<void>;
+/**
+ * Parse an RSS/Atom XML feed into articles.
+ * Lightweight regex-based parser - no external dependencies needed.
+ */
+export declare function parseFeedXml(xml: string): Array<{
+    title: string;
+    url: string;
+    summary?: string;
+    content?: string;
+    author?: string;
+    publishedAt?: string;
+}>;
+/**
+ * Poll a single feed source and store new articles.
+ */
+export declare function pollFeed(feedId: string): Promise<{
+    newArticles: number;
+    errors?: string;
+}>;
+/**
+ * Poll all enabled feeds that are due for polling.
+ */
+export declare function pollAllFeeds(): Promise<{
+    total: number;
+    newArticles: number;
+    errors: number;
+}>;
+/**
+ * Get recent articles for a digest.
+ * All filters are optional - the engine imposes no limits by default.
+ */
+export declare function getDigestArticles(options?: {
+    since?: Date;
+    category?: string;
+    tag?: string;
+    feedId?: string;
+    limit?: number;
+    undigestedOnly?: boolean;
+}): Promise<FeedArticle[]>;
+/**
+ * Mark articles as digested (included in a delivered digest).
+ */
+export declare function markAsDigested(articleIds: string[]): Promise<void>;
+/**
+ * Get feed statistics.
+ */
+export declare function getFeedStats(): Promise<{
+    totalFeeds: number;
+    enabledFeeds: number;
+    totalArticles: number;
+    articlesToday: number;
+    byCategory: Record<string, number>;
+}>;
+/**
+ * List all distinct categories currently in use.
+ */
+export declare function listCategories(): Promise<string[]>;
+/**
+ * Auto-discover feed URL from a website.
+ * Fetches the page and looks for RSS/Atom link tags.
+ */
+export declare function discoverFeedUrl(websiteUrl: string): Promise<string | null>;
+//# sourceMappingURL=feed-engine.d.ts.map