incremnt 0.1.13 → 0.1.16

package/src/sync-service.js

@@ -4,9 +4,11 @@ import { executeReadCommand } from './queries.js';
 
 const MAX_BODY_BYTES = 10 * 1024 * 1024; // 10 MB
 const DEFAULT_RATE_LIMIT_WINDOW_MS = 60_000;
+const MAX_ASK_USER_TURNS = 3;
 const DEFAULT_RATE_LIMIT_RULES = {
   'workout-summary-ai': 3,
   'cycle-summary-ai': 3,
+  'ask-ai': 5,
   'dev-login': 10,
   'device-start': 20,
   'device-poll': 300,
@@ -29,6 +31,14 @@ function json(response, statusCode, payload) {
   response.end(JSON.stringify(payload));
 }
 
+function jsonWithHeaders(response, statusCode, payload, headers = {}) {
+  response.writeHead(statusCode, {
+    'content-type': 'application/json',
+    ...headers
+  });
+  response.end(JSON.stringify(payload));
+}
+
 function logRequest(request, statusCode, extra = '') {
   const method = request.method ?? '?';
   const rawUrl = request.url ?? '/';
@@ -54,8 +64,9 @@ function methodNotAllowed(response, message = 'Method not allowed') {
   json(response, 405, { error: message });
 }
 
-function internalError(response, error) {
+function internalError(response, error, onError) {
   console.error('Internal error:', error.message);
+  if (onError) onError(error);
   json(response, 500, { error: 'Internal server error' });
 }
 
@@ -119,16 +130,22 @@ function createRateLimiter({
 
       if (!bucket || bucket.resetAt <= now) {
         buckets.set(key, { count: 1, resetAt: now + windowMs });
-        return { allowed: true };
+        return { allowed: true, retryAfterSec: Math.ceil(windowMs / 1000) };
       }
 
       if (bucket.count >= limit) {
-        return { allowed: false };
+        return {
+          allowed: false,
+          retryAfterSec: Math.max(1, Math.ceil((bucket.resetAt - now) / 1000))
+        };
       }
 
       bucket.count += 1;
       buckets.set(key, bucket);
-      return { allowed: true };
+      return {
+        allowed: true,
+        retryAfterSec: Math.max(1, Math.ceil((bucket.resetAt - now) / 1000))
+      };
     }
   };
 }
@@ -261,6 +278,20 @@ function routeRequest(url) {
     return { command: 'goals-show', options: { id: decodeURIComponent(goalsShowMatch[1]) } };
   }
 
+  if (pathname === '/cli/cycles') {
+    return {
+      command: 'cycle-summary-list',
+      options: {
+        'program-id': url.searchParams.get('program-id') ?? undefined
+      }
+    };
+  }
+
+  const cyclesShowMatch = pathname.match(/^\/cli\/cycles\/([^/]+)$/);
+  if (cyclesShowMatch) {
+    return { command: 'cycle-summary-show', options: { id: decodeURIComponent(cyclesShowMatch[1]) } };
+  }
+
   const compareMatch = pathname.match(/^\/cli\/sessions\/([^/]+)\/compare$/);
   if (compareMatch) {
     return {
@@ -309,6 +340,30 @@ function routeRequest(url) {
     };
   }
 
+  if (pathname === '/cli/ask') {
+    return { command: 'ask-ai', options: {} };
+  }
+
+  if (pathname === '/cli/ask/history') {
+    return { command: 'ask-history', options: { limit: url.searchParams.get('limit') ?? undefined } };
+  }
+
+  {
+    const askShowMatch = pathname.match(/^\/cli\/ask\/history\/(.+)$/);
+    if (askShowMatch) {
+      return { command: 'ask-show', options: { id: askShowMatch[1] } };
+    }
+  }
+
+  if (pathname === '/cli/health/summary') {
+    return {
+      command: 'health-summary',
+      options: {
+        days: url.searchParams.get('days') ?? undefined
+      }
+    };
+  }
+
   return null;
 }
 
@@ -779,7 +834,10 @@ export function createSyncServiceRequestHandler({
   createProposalForAccount = null,
   listProposalsForAccount = null,
   updateProposalForAccount = null,
-  updateAnalysisConsentForAccount = null
+  updateAnalysisConsentForAccount = null,
+  saveAskConversationForAccount = null,
+  listAskConversationsForAccount = null,
+  onError = null
 }) {
   const rateLimiter = createRateLimiter(rateLimitConfig ?? {});
 
@@ -816,8 +874,14 @@ export function createSyncServiceRequestHandler({
         return;
       }
 
-      if (!rateLimiter.check(request, route.command).allowed) {
-        json(response, 429, { error: 'Too many requests' });
+      const rateLimitResult = rateLimiter.check(request, route.command);
+      if (!rateLimitResult.allowed) {
+        jsonWithHeaders(
+          response,
+          429,
+          { error: 'Too many requests', code: 'rate_limited' },
+          { 'Retry-After': String(rateLimitResult.retryAfterSec ?? 60) }
+        );
         return;
       }
 
@@ -1668,18 +1732,32 @@ export function createSyncServiceRequestHandler({
 
         const openrouterKey = process.env.OPENROUTER_API_KEY;
         if (!openrouterKey) {
-          json(response, 503, { error: 'AI summaries not configured' });
+          json(response, 503, { error: 'AI summaries not configured', code: 'not_configured' });
           return;
         }
 
         try {
           const { generateWorkoutCoachingSummary } = await import('./openrouter.js');
-          const model = process.env.OPENROUTER_MODEL || undefined;
-          const summary = await generateWorkoutCoachingSummary(ctx, { apiKey: openrouterKey, model });
-          json(response, 200, { summary });
+          const result = await generateWorkoutCoachingSummary(ctx, { apiKey: openrouterKey });
+          if (result.fallback && onError) {
+            const warning = new Error(`AI workout-summary used fallback model ${result.model}`);
+            warning.level = 'warning';
+            onError(warning, {
+              feature: 'workout-summary',
+              modelErrors: result.errors,
+              durationMs: result.durationMs,
+              fallbackModel: result.model
+            });
+          }
+          json(response, 200, { summary: result.text, model: result.model });
         } catch (err) {
           console.error('AI workout summary error:', err.message);
-          json(response, 502, { error: 'Failed to generate AI summary' });
+          onError?.(err, {
+            feature: 'workout-summary',
+            modelErrors: err.modelErrors,
+            durationMs: err.durationMs
+          });
+          json(response, 502, { error: 'Failed to generate AI summary', code: 'ai_unavailable' });
         }
         return;
       }
@@ -1700,18 +1778,181 @@ export function createSyncServiceRequestHandler({
 
         const openrouterKey = process.env.OPENROUTER_API_KEY;
         if (!openrouterKey) {
-          json(response, 503, { error: 'AI summaries not configured' });
+          json(response, 503, { error: 'AI summaries not configured', code: 'not_configured' });
           return;
         }
 
         try {
           const { generateCoachingSummary } = await import('./openrouter.js');
-          const model = process.env.OPENROUTER_MODEL || undefined;
-          const summary = await generateCoachingSummary(ctx, { apiKey: openrouterKey, model });
-          json(response, 200, { summary });
+          const result = await generateCoachingSummary(ctx, { apiKey: openrouterKey });
+          if (result.fallback && onError) {
+            const warning = new Error(`AI cycle-summary used fallback model ${result.model}`);
+            warning.level = 'warning';
+            onError(warning, {
+              feature: 'cycle-summary',
+              modelErrors: result.errors,
+              durationMs: result.durationMs,
+              fallbackModel: result.model
+            });
+          }
+          json(response, 200, { summary: result.text, model: result.model });
         } catch (err) {
           console.error('AI cycle summary error:', err.message);
-          json(response, 502, { error: 'Failed to generate AI summary' });
+          onError?.(err, {
+            feature: 'cycle-summary',
+            modelErrors: err.modelErrors,
+            durationMs: err.durationMs
+          });
+          json(response, 502, { error: 'Failed to generate AI summary', code: 'ai_unavailable' });
+        }
+        return;
+      }
+
+      if (route.command === 'ask-ai') {
+        if (request.method !== 'POST') {
+          methodNotAllowed(response, 'Use POST for /cli/ask.');
+          return;
+        }
+
+        let body;
+        try {
+          body = await readJsonBody(request);
+        } catch {
+          badRequest(response, 'Invalid JSON body.');
+          return;
+        }
+
+        const question = body?.question;
+        if (!question || typeof question !== 'string' || question.trim().length === 0) {
+          badRequest(response, 'question is required');
+          return;
+        }
+        if (question.length > 500) {
+          badRequest(response, 'question must be 500 characters or fewer');
+          return;
+        }
+
+        const conversationId = body?.conversationId;
+        if (!conversationId || typeof conversationId !== 'string') {
+          badRequest(response, 'conversationId is required');
+          return;
+        }
+
+        const history = Array.isArray(body?.history) ? body.history : [];
+        const validHistory = history.every(
+          (m) => m && typeof m.role === 'string' && typeof m.content === 'string'
+        );
+        if (!validHistory) {
+          badRequest(response, 'history must be an array of {role, content} objects');
+          return;
+        }
+        const priorUserTurns = history.filter((m) => m.role === 'user').length;
+        if (priorUserTurns >= MAX_ASK_USER_TURNS) {
+          json(response, 400, { error: `Ask Coach supports up to ${MAX_ASK_USER_TURNS} questions per conversation. Start a new conversation.`, code: 'conversation_limit' });
+          return;
+        }
+
+        const openrouterKey = process.env.OPENROUTER_API_KEY;
+        if (!openrouterKey) {
+          json(response, 503, { error: 'AI not configured', code: 'not_configured' });
+          return;
+        }
+
+        const { askContext } = await import('./queries.js');
+        const ctx = askContext(snapshot);
+
+        try {
+          const { generateAskAnswer } = await import('./openrouter.js');
+          const askResult = await generateAskAnswer(ctx, question, { apiKey: openrouterKey, history });
+          const updatedMessages = [
+            ...history,
+            { role: 'user', content: question },
+            { role: 'assistant', content: askResult.text }
+          ];
+          if (saveAskConversationForAccount) {
+            try {
+              await saveAskConversationForAccount(account, {
+                id: conversationId,
+                messages: updatedMessages,
+                model: askResult.model
+              });
+            } catch (saveErr) {
+              console.error('Failed to save ask conversation:', saveErr.message);
+            }
+          }
+          if (askResult.fallback && onError) {
+            const warning = new Error(`AI ask-coach used fallback model ${askResult.model}`);
+            warning.level = 'warning';
+            onError(warning, {
+              feature: 'ask-coach',
+              modelErrors: askResult.errors,
+              durationMs: askResult.durationMs,
+              fallbackModel: askResult.model
+            });
+          }
+          json(response, 200, { answer: askResult.text, model: askResult.model });
+        } catch (err) {
+          console.error('AI ask error:', err.message);
+          onError?.(err, {
+            feature: 'ask-coach',
+            modelErrors: err.modelErrors,
+            durationMs: err.durationMs
+          });
+          json(response, 502, { error: 'Failed to generate AI answer', code: 'ai_unavailable' });
+        }
+        return;
+      }
+
+      if (route.command === 'ask-history') {
+        if (request.method !== 'GET') {
+          methodNotAllowed(response, 'Use GET for /cli/ask/history.');
+          return;
+        }
+
+        if (!listAskConversationsForAccount) {
+          json(response, 503, { error: 'Ask history not available' });
+          return;
+        }
+
+        try {
+          const limit = route.options.limit ? parseInt(route.options.limit, 10) : 20;
+          const conversations = await listAskConversationsForAccount(account, { limit });
+          const summaries = conversations.map((c) => ({
+            id: c.id,
+            preview: (c.messages?.[0]?.content ?? '').slice(0, 120),
+            messageCount: c.messages?.length ?? 0,
+            createdAt: c.createdAt
+          }));
+          json(response, 200, { conversations: summaries });
+        } catch (err) {
+          console.error('Ask history error:', err.message);
+          json(response, 500, { error: 'Failed to load ask history' });
+        }
+        return;
+      }
+
+      if (route.command === 'ask-show') {
+        if (request.method !== 'GET') {
+          methodNotAllowed(response, 'Use GET for /cli/ask/history/:id.');
+          return;
+        }
+
+        if (!listAskConversationsForAccount) {
+          json(response, 503, { error: 'Ask history not available' });
+          return;
+        }
+
+        try {
+          const conversations = await listAskConversationsForAccount(account);
+          const conversation = conversations.find((c) => c.id === route.options.id);
+          if (!conversation) {
+            notFound(response, `Conversation not found: ${route.options.id}`);
+            return;
+          }
+          json(response, 200, conversation);
+        } catch (err) {
+          console.error('Ask show error:', err.message);
+          json(response, 500, { error: 'Failed to load conversation' });
         }
         return;
       }
@@ -1729,7 +1970,7 @@ export function createSyncServiceRequestHandler({
 
       json(response, 200, result.payload);
     } catch (error) {
-      internalError(response, error);
+      internalError(response, error, onError);
     }
   };
 }