profclaw 0.0.1-beta.3 → 2.3.0

package/dist/routes/chat.js

@@ -9,8 +9,18 @@ import { streamText } from "hono/streaming";
 import { zValidator } from "@hono/zod-validator";
 import { z } from "zod";
 import { randomUUID } from "node:crypto";
+import { routeQuery, recordRoutingDecision, isSmartRouterEnabled, getCostComparison, } from "../providers/smart-router.js";
 import { logger } from "../utils/logger.js";
+import { rateLimit } from "../middleware/rate-limit.js";
+import { contentFilter } from "../middleware/content-filter.js";
 const chatRoutes = new Hono();
+// Per-IP sliding-window rate limiter for chat send endpoints
+const chatMaxRequests = parseInt(process.env['CHAT_RATE_LIMIT'] ?? '20', 10);
+const chatRateLimiter = rateLimit({
+    maxRequests: chatMaxRequests,
+    windowMs: 60_000,
+    message: `Chat rate limit exceeded. Maximum ${chatMaxRequests} messages per minute.`,
+});
 let chatRuntimePromise = null;
 let ProviderTypeSchema;
 let aiProvider;
@@ -26,6 +36,7 @@ let listConversations;
 let deleteConversation;
 let addMessage;
 let getConversationMessages;
+let deleteMessage;
 let getRecentConversationsWithPreview;
 let compactMessages;
 let getMemoryStats;
@@ -65,6 +76,7 @@ async function ensureChatRuntime() {
             deleteConversation = chatModule.deleteConversation;
             addMessage = chatModule.addMessage;
             getConversationMessages = chatModule.getConversationMessages;
+            deleteMessage = chatModule.deleteMessage;
             getRecentConversationsWithPreview =
                 chatModule.getRecentConversationsWithPreview;
             compactMessages = chatModule.compactMessages;
@@ -168,6 +180,84 @@ chatRoutes.get("/model-capability", async (c) => {
     const resolved = MODEL_ALIASES[model.toLowerCase()]?.model ?? model;
     return c.json(getModelRouting(resolved));
 });
+/**
+ * POST /api/chat/send
+ * Simple one-shot chat - send a message and get a response
+ */
+chatRoutes.post("/send", chatRateLimiter, contentFilter(), zValidator("json", z.object({
+    message: z.string(),
+    model: z.string().optional(),
+    systemPrompt: z.string().optional(),
+    temperature: z.number().min(0).max(2).optional(),
+    maxTokens: z.number().positive().optional(),
+})), async (c) => {
+    const body = c.req.valid("json");
+    try {
+        const messages = [
+            {
+                id: randomUUID(),
+                role: "user",
+                content: body.message,
+                timestamp: new Date().toISOString(),
+            },
+        ];
+        // Smart routing: auto-select model if none specified
+        let routing;
+        let modelToUse = body.model;
+        if (!body.model && isSmartRouterEnabled()) {
+            const providers = new Set(aiProvider.getConfiguredProviders());
+            routing = routeQuery(body.message, providers);
+            modelToUse = routing.selectedModel.id;
+            recordRoutingDecision(routing);
+        }
+        const response = await aiProvider.chat({
+            messages,
+            model: modelToUse,
+            systemPrompt: body.systemPrompt,
+            temperature: body.temperature,
+            maxTokens: body.maxTokens,
+        });
+        // Track token usage for cost dashboard
+        if (response.usage?.totalTokens && response.model) {
+            await ensureChatRuntime();
+            trackChatUsage(response.model, response.usage.totalTokens, response.usage.promptTokens, response.usage.completionTokens);
+        }
+        return c.json({
+            id: response.id,
+            provider: response.provider,
+            model: response.model,
+            reply: response.content,
+            finishReason: response.finishReason,
+            usage: response.usage,
+            duration: response.duration,
+            ...(routing && {
+                routing: {
+                    smartRouted: true,
+                    complexity: routing.complexity.tier,
+                    confidence: Math.round(routing.complexity.confidence * 100),
+                    reasoning: routing.complexity.reasoning,
+                    savings: `${routing.savingsPercent}%`,
+                    estimatedCost: `$${routing.estimatedCost.toFixed(4)}`,
+                    summary: getCostComparison(routing),
+                    ...(routing.missingProviderHint && {
+                        tip: {
+                            addProvider: routing.missingProviderHint.provider,
+                            reason: routing.missingProviderHint.reason,
+                            savings: routing.missingProviderHint.estimatedSavings,
+                            signupUrl: routing.missingProviderHint.signupUrl,
+                        },
+                    }),
+                },
+            }),
+        });
+    }
+    catch (error) {
+        logger.error("[Chat] Send error:", error instanceof Error ? error : undefined);
+        return c.json({
+            error: error instanceof Error ? error.message : "Chat send failed",
+        }, 500);
+    }
+});
 /**
  * POST /api/chat/completions
  * Generate a chat completion
@@ -183,11 +273,37 @@ chatRoutes.post("/completions", zValidator("json", ChatCompletionSchema), async
     }));
     // Handle streaming
     if (body.stream) {
+        // Smart route for streaming too
+        let streamRouting;
+        let streamModel = body.model;
+        if (!body.model && isSmartRouterEnabled()) {
+            const lastUserMsg = [...body.messages].reverse().find((m) => m.role === "user");
+            if (lastUserMsg) {
+                const providers = new Set(aiProvider.getConfiguredProviders());
+                streamRouting = routeQuery(lastUserMsg.content, providers, {
+                    conversationLength: body.messages.length,
+                });
+                streamModel = streamRouting.selectedModel.id;
+                recordRoutingDecision(streamRouting);
+            }
+        }
         return streamText(c, async (stream) => {
             try {
+                // Send routing info as first event in stream
+                if (streamRouting) {
+                    await stream.write(`data: ${JSON.stringify({
+                        routing: {
+                            smartRouted: true,
+                            complexity: streamRouting.complexity.tier,
+                            savings: `${streamRouting.savingsPercent}%`,
+                            model: streamRouting.selectedModel.id,
+                            provider: streamRouting.selectedModel.provider,
+                        },
+                    })}\n\n`);
+                }
                 const response = await aiProvider.chatStream({
                     messages,
-                    model: body.model,
+                    model: streamModel,
                     systemPrompt: body.systemPrompt,
                     temperature: body.temperature,
                     maxTokens: body.maxTokens,
@@ -216,9 +332,23 @@ chatRoutes.post("/completions", zValidator("json", ChatCompletionSchema), async
     }
     // Non-streaming
     try {
+        // Smart routing for completions
+        let routing;
+        let modelToUse = body.model;
+        if (!body.model && isSmartRouterEnabled()) {
+            const lastUserMsg = [...body.messages].reverse().find((m) => m.role === "user");
+            if (lastUserMsg) {
+                const providers = new Set(aiProvider.getConfiguredProviders());
+                routing = routeQuery(lastUserMsg.content, providers, {
+                    conversationLength: body.messages.length,
+                });
+                modelToUse = routing.selectedModel.id;
+                recordRoutingDecision(routing);
+            }
+        }
         const response = await aiProvider.chat({
             messages,
-            model: body.model,
+            model: modelToUse,
             systemPrompt: body.systemPrompt,
             temperature: body.temperature,
             maxTokens: body.maxTokens,
@@ -234,6 +364,15 @@ chatRoutes.post("/completions", zValidator("json", ChatCompletionSchema), async
             finishReason: response.finishReason,
             usage: response.usage,
             duration: response.duration,
+            ...(routing && {
+                routing: {
+                    smartRouted: true,
+                    complexity: routing.complexity.tier,
+                    savings: `${routing.savingsPercent}%`,
+                    estimatedCost: `$${routing.estimatedCost.toFixed(4)}`,
+                    summary: getCostComparison(routing),
+                },
+            }),
         });
     }
     catch (error) {
@@ -751,14 +890,62 @@ chatRoutes.post("/conversations/:id/compact", async (c) => {
         return c.json({ error: "Failed to compact conversation" }, 500);
     }
 });
+/**
+ * DELETE /api/chat/conversations/:id/messages/:messageId
+ * Delete a single message from a conversation
+ */
+chatRoutes.delete("/conversations/:id/messages/:messageId", async (c) => {
+    const conversationId = c.req.param("id");
+    const messageId = c.req.param("messageId");
+    try {
+        const conversation = await getConversation(conversationId);
+        if (!conversation) {
+            return c.json({ error: "Conversation not found" }, 404);
+        }
+        await deleteMessage(conversationId, messageId);
+        return c.json({ success: true });
+    }
+    catch (error) {
+        logger.error("[Chat] Delete message error:", error instanceof Error ? error : undefined);
+        return c.json({ error: "Failed to delete message" }, 500);
+    }
+});
+/**
+ * GET /api/chat/conversations/:id/export
+ * Export a conversation as JSON
+ */
+chatRoutes.get("/conversations/:id/export", async (c) => {
+    const conversationId = c.req.param("id");
+    try {
+        const conversation = await getConversation(conversationId);
+        if (!conversation) {
+            return c.json({ error: "Conversation not found" }, 404);
+        }
+        const messages = await getConversationMessages(conversationId);
+        return c.json({
+            conversation: {
+                id: conversation.id,
+                title: conversation.title,
+                createdAt: conversation.createdAt,
+            },
+            messages,
+            exportedAt: new Date().toISOString(),
+        });
+    }
+    catch (error) {
+        logger.error("[Chat] Export conversation error:", error instanceof Error ? error : undefined);
+        return c.json({ error: "Failed to export conversation" }, 500);
+    }
+});
 /**
  * POST /api/chat/conversations/:id/messages
  * Send a message in a conversation (with context and history)
  */
-chatRoutes.post("/conversations/:id/messages", zValidator("json", z.object({
+chatRoutes.post("/conversations/:id/messages", chatRateLimiter, contentFilter(), zValidator("json", z.object({
     content: z.string(),
     model: z.string().optional(),
     temperature: z.number().min(0).max(2).optional(),
+    stream: z.boolean().optional(),
 })), async (c) => {
     const conversationId = c.req.param("id");
     const body = c.req.valid("json");
@@ -870,7 +1057,56 @@ chatRoutes.post("/conversations/:id/messages", zValidator("json", z.object({
             content: m.content,
             timestamp: m.createdAt,
         }));
-        // Send to AI
+        // Streaming branch
+        if (body.stream) {
+            return streamText(c, async (stream) => {
+                try {
+                    let fullContent = "";
+                    const response = await aiProvider.chatStream({
+                        messages: chatMessages,
+                        model: body.model,
+                        systemPrompt,
+                        temperature: body.temperature,
+                    }, (chunk) => {
+                        fullContent += chunk;
+                        stream
+                            .write(`data: ${JSON.stringify({ content: chunk })}\n\n`)
+                            .catch((err) => {
+                            logger.error("[Chat] Stream write error:", err instanceof Error ? err : undefined);
+                        });
+                    });
+                    // Save assistant response after streaming completes
+                    const assistantMessage = await addMessage({
+                        conversationId,
+                        role: "assistant",
+                        content: fullContent || response.content,
+                        model: response.model,
+                        provider: response.provider,
+                        tokenUsage: response.usage
+                            ? {
+                                prompt: response.usage.promptTokens,
+                                completion: response.usage.completionTokens,
+                                total: response.usage.totalTokens,
+                            }
+                            : undefined,
+                        cost: response.usage?.cost,
+                    });
+                    await stream.write(`data: ${JSON.stringify({
+                        done: true,
+                        usage: response.usage,
+                        messageId: assistantMessage.id,
+                        compaction: compactionInfo,
+                    })}\n\n`);
+                }
+                catch (error) {
+                    logger.error("[Chat] Conversation stream error:", error instanceof Error ? error : undefined);
+                    await stream.write(`data: ${JSON.stringify({
+                        error: error instanceof Error ? error.message : "Failed to send message",
+                    })}\n\n`);
+                }
+            });
+        }
+        // Send to AI (non-streaming)
         const response = await aiProvider.chat({
             messages: chatMessages,
             model: body.model,
@@ -915,7 +1151,7 @@ chatRoutes.post("/conversations/:id/messages", zValidator("json", z.object({
  * POST /api/chat/conversations/:id/messages/with-tools
  * Send a message in a conversation with native tool calling enabled
  */
-chatRoutes.post("/conversations/:id/messages/with-tools", zValidator("json", z.object({
+chatRoutes.post("/conversations/:id/messages/with-tools", chatRateLimiter, contentFilter(), zValidator("json", z.object({
     content: z.string(),
     model: z.string().optional(),
     temperature: z.number().min(0).max(2).optional(),
@@ -993,6 +1229,10 @@ chatRoutes.post("/conversations/:id/messages/with-tools", zValidator("json", z.o
         const tools = enableTools
             ? getChatToolsForModel(modelId, { conversationId })
             : [];
+        logger.info(`[Chat] Tools for ${modelId}: ${tools.length} (enableTools=${enableTools})`, {
+            component: 'Chat',
+            toolNames: tools.map(t => t.name).join(', '),
+        });
         // Build system prompt with context and tool mode
         const systemPrompt = await buildSystemPrompt(conversation.presetId, context, {
             enableTools: enableTools && tools.length > 0,
@@ -1322,7 +1562,7 @@ chatRoutes.post("/with-tools", zValidator("json", z.object({
  * - complete - Session complete
  * - error - Error occurred
  */
-chatRoutes.post("/conversations/:id/messages/agentic", zValidator("json", z.object({
+chatRoutes.post("/conversations/:id/messages/agentic", chatRateLimiter, contentFilter(), zValidator("json", z.object({
     content: z.string(),
     model: z.string().optional(),
     provider: z.string().optional(),
@@ -1385,8 +1625,6 @@ chatRoutes.post("/conversations/:id/messages/agentic", zValidator("json", z.obje
             conversationId,
             sessionOverride,
         };
-        // Get tools - agentic mode uses model-aware filtering
-        const tools = getChatToolsForModel(resolvedRef.model, { conversationId, includeAll: true });
         // Build system prompt with agent mode (uses AGENT_MODE_SUFFIX)
         const systemPrompt = await buildSystemPrompt(conversation.presetId, context, {
             agentMode: true,
@@ -1429,11 +1667,14 @@ chatRoutes.post("/conversations/:id/messages/agentic", zValidator("json", z.obje
             content: m.content,
             timestamp: m.createdAt,
         }));
-        // Create tool handler
+        // Create tool handler (triggers tool registration if first call)
         const toolHandler = await createChatToolHandler({
             conversationId,
             securityMode: "full", // Full access in agentic mode (tools are pre-approved)
         });
+        // Get tools AFTER handler init (registry is now populated)
+        const tools = getChatToolsForModel(resolvedRef.model, { conversationId });
+        logger.info(`[Chat/Agentic] Tools for model ${resolvedRef.model}: ${tools.length}`);
         // Set up SSE streaming response
         c.header("Content-Type", "text/event-stream");
         c.header("Cache-Control", "no-cache");
@@ -1491,11 +1732,15 @@ chatRoutes.post("/conversations/:id/messages/agentic", zValidator("json", z.obje
                     provider: body.provider,
                     temperature: body.temperature,
                     toolHandler,
-                    tools: tools.map((t) => ({
-                        name: t.name,
-                        description: t.description,
-                        parameters: t.parameters,
-                    })),
+                    tools: (() => {
+                        const mapped = tools.map((t) => ({
+                            name: t.name,
+                            description: t.description,
+                            parameters: t.parameters,
+                        }));
+                        logger.info(`[Chat/Agentic] Sending ${mapped.length} tools: [${mapped.map(t => t.name).join(', ')}]`);
+                        return mapped;
+                    })(),
                     showThinking: body.showThinking,
                     maxSteps: body.maxSteps,
                     maxBudget: body.maxBudget,

package/dist/routes/costs.js

@@ -2,6 +2,7 @@ import { Hono } from 'hono';
 import { getUsageSummary } from '../costs/token-tracker.js';
 import { getBudgetStatus } from '../costs/budget.js';
 import { getStorage } from '../storage/index.js';
+import { getRoutingStats, getCostOptimizationAdvice } from '../providers/smart-router.js';
 const costs = new Hono();
 // Get usage summary
 costs.get('/summary', (c) => {
@@ -19,6 +20,37 @@ costs.get('/analytics', async (c) => {
     const analytics = await storage.getCostAnalytics();
     return c.json(analytics);
 });
+// Get smart routing stats (savings from auto-routing)
+costs.get('/routing', (_c) => {
+    const stats = getRoutingStats();
+    return _c.json({
+        success: true,
+        data: {
+            ...stats,
+            totalSaved: `$${stats.totalSaved.toFixed(4)}`,
+            avgSavingsPercent: `${Math.round(stats.avgSavingsPercent)}%`,
+            message: stats.totalRouted > 0
+                ? `Smart routing saved $${stats.totalSaved.toFixed(2)} across ${stats.totalRouted} requests (avg ${Math.round(stats.avgSavingsPercent)}% savings)`
+                : 'No queries routed yet. Smart routing will show savings as you use profClaw.',
+        },
+    });
+});
+// Get cost optimization advice
+costs.get('/optimize', async (c) => {
+    // Get configured providers dynamically
+    const { aiProvider } = await import('../providers/ai-sdk.js');
+    const providers = new Set(aiProvider.getConfiguredProviders());
+    const advice = getCostOptimizationAdvice(providers);
+    return c.json({
+        success: true,
+        data: {
+            configuredProviders: [...providers],
+            providerCount: providers.size,
+            recommendations: advice,
+            optimalSetup: advice.some(a => a.action.includes('cost-optimal')),
+        },
+    });
+});
 // Export cost report as CSV
 costs.get('/export', async (c) => {
     const format = c.req.query('format') || 'csv';

package/dist/routes/cron.js

@@ -9,6 +9,7 @@ import { zValidator } from '@hono/zod-validator';
 import { z } from 'zod';
 import { createScheduledJob, getScheduledJob, listScheduledJobs, updateScheduledJob, pauseScheduledJob, resumeScheduledJob, deleteScheduledJob, archiveScheduledJob, restoreScheduledJob, triggerScheduledJob, getJobRunHistory, getScheduler, } from '../cron/scheduler.js';
 import { listJobTemplates, getJobTemplate, createJobTemplate, deleteJobTemplate, applyJobTemplate, initBuiltInTemplates, } from '../cron/templates.js';
+import { parseNaturalLanguage, cronToHuman } from '../cron/natural-language.js';
 import { createContextualLogger } from '../utils/logger.js';
 const log = createContextualLogger('CronRoutes');
 const app = new Hono();
@@ -34,7 +35,7 @@ app.use('*', async (_c, next) => {
 });
 // Schemas
 const deliveryChannelSchema = z.object({
-    type: z.enum(['slack', 'webhook', 'email']),
+    type: z.enum(['slack', 'webhook', 'email', 'telegram', 'discord']),
     target: z.string(),
     onSuccess: z.boolean().optional(),
     onFailure: z.boolean().optional(),
@@ -64,7 +65,7 @@ const createJobSchema = z.object({
     // Event trigger (alternative to schedule)
     eventTrigger: eventTriggerSchema.optional(),
     // Execution
-    jobType: z.enum(['http', 'tool', 'script', 'message']),
+    jobType: z.enum(['http', 'tool', 'script', 'message', 'agent_session']),
     payload: z.record(z.any()),
     templateId: z.string().optional(),
     // Delivery
@@ -98,7 +99,7 @@ const updateJobSchema = z.object({
 });
 const listQuerySchema = z.object({
     status: z.enum(['active', 'paused', 'completed', 'failed', 'archived']).optional(),
-    jobType: z.enum(['http', 'tool', 'script', 'message']).optional(),
+    jobType: z.enum(['http', 'tool', 'script', 'message', 'agent_session']).optional(),
     projectId: z.string().optional(),
     userId: z.string().optional(),
     limit: z.coerce.number().min(1).max(100).optional().default(50),
@@ -107,8 +108,8 @@ const createTemplateSchema = z.object({
     name: z.string().min(1).max(100),
     description: z.string().max(500).optional(),
     icon: z.string().max(10).optional(),
-    category: z.enum(['sync', 'report', 'cleanup', 'notification', 'monitoring', 'custom']).optional(),
-    jobType: z.enum(['http', 'tool', 'script', 'message']),
+    category: z.enum(['sync', 'report', 'cleanup', 'notification', 'monitoring', 'automation', 'custom']).optional(),
+    jobType: z.enum(['http', 'tool', 'script', 'message', 'agent_session']),
     payloadTemplate: z.record(z.any()),
     suggestedCron: z.string().optional(),
     suggestedIntervalMs: z.number().min(1000).optional(),
@@ -166,6 +167,79 @@ app.get('/jobs', zValidator('query', listQuerySchema), async (c) => {
         }, 500);
     }
 });
+/**
+ * POST /api/cron/automate - Create a job from natural language
+ *
+ * Example: { "input": "every morning at 8am summarize my GitHub notifications and send to telegram" }
+ *
+ * Returns the parsed schedule, intent, and delivery - then creates the job.
+ * Use ?dryRun=true to preview without creating.
+ */
+app.post('/automate', zValidator('json', z.object({
+    input: z.string().min(5).max(500),
+})), async (c) => {
+    try {
+        const { input } = c.req.valid('json');
+        const dryRun = c.req.query('dryRun') === 'true';
+        const result = parseNaturalLanguage(input);
+        if (!result.success || !result.jobParams) {
+            return c.json({
+                success: false,
+                error: result.error ?? 'Could not understand the request',
+                parsed: {
+                    schedule: result.schedule,
+                    intent: result.intent,
+                    delivery: result.delivery,
+                },
+                hint: 'Try: "every morning at 8am summarize GitHub notifications and send to telegram"',
+            }, 400);
+        }
+        // Dry run: return what would be created
+        if (dryRun) {
+            return c.json({
+                success: true,
+                dryRun: true,
+                parsed: {
+                    schedule: result.schedule,
+                    intent: result.intent,
+                    delivery: result.delivery,
+                    humanReadable: result.schedule?.humanReadable,
+                    cronExpression: result.jobParams.cronExpression,
+                    cronExplained: result.jobParams.cronExpression
+                        ? cronToHuman(result.jobParams.cronExpression)
+                        : undefined,
+                },
+                jobParams: result.jobParams,
+                message: `Would create: "${result.jobParams.name}" running ${result.schedule?.humanReadable ?? 'on schedule'}`,
+            });
+        }
+        // Create the job
+        const job = await createScheduledJob(result.jobParams);
+        log.info(`Created job from natural language: ${job.name} (${job.id})`, {
+            input: input.slice(0, 80),
+            cron: result.jobParams.cronExpression,
+            schedule: result.schedule?.humanReadable,
+        });
+        return c.json({
+            success: true,
+            job,
+            parsed: {
+                schedule: result.schedule?.humanReadable,
+                cronExpression: result.jobParams.cronExpression,
+                intent: result.intent?.action,
+                delivery: result.delivery?.channel,
+            },
+            message: `Created "${job.name}" - ${result.schedule?.humanReadable ?? 'scheduled'}`,
+        }, 201);
+    }
+    catch (error) {
+        log.error('Failed to create job from natural language:', error instanceof Error ? error : new Error(String(error)));
+        return c.json({
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to create automation',
+        }, 500);
+    }
+});
 /**
  * POST /api/cron/jobs - Create a scheduled job
  * Supports: cron, interval, one-shot (runAt), or event-triggered
@@ -534,6 +608,7 @@ app.get('/stats', async (c) => {
                 tool: activeJobs.filter((j) => j.jobType === 'tool').length,
                 script: activeJobs.filter((j) => j.jobType === 'script').length,
                 message: activeJobs.filter((j) => j.jobType === 'message').length,
+                agent_session: activeJobs.filter((j) => j.jobType === 'agent_session').length,
             },
             byScheduleType: {
                 cron: activeJobs.filter((j) => j.cronExpression).length,

package/dist/routes/feeds.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Feed Routes
+ *
+ * REST API for managing RSS/Atom feeds and article digests.
+ * All endpoints are under /api/feeds.
+ */
+import { Hono } from 'hono';
+declare const app: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default app;
+//# sourceMappingURL=feeds.d.ts.map