incremnt 0.7.0 → 0.7.2

package/src/sync-service.js

@@ -22,6 +22,9 @@ const DEFAULT_RATE_LIMIT_RULES = {
   'weekly-checkin-ack': 30,
   'weekly-checkin-start': 10,
   'weekly-digest-current': 30,
+  'coach-observations-current': 30,
+  'coach-observations-seen': 30,
+  'coach-observations-dismiss': 30,
   'dev-login': 10,
   'device-start': 20,
   'device-poll': 300,
@@ -682,6 +685,47 @@ function createRateLimiter({
   };
 }
 
+function parseLimit(value, { defaultValue, max }) {
+  const parsed = value ? Number.parseInt(value, 10) : defaultValue;
+  return Number.isFinite(parsed) && parsed > 0 ? Math.min(parsed, max) : defaultValue;
+}
+
+function coachObservationSourceTriggerForScoreSnapshots(snapshots) {
+  if (!Array.isArray(snapshots)) return undefined;
+  const reasons = snapshots.map((snapshot) => snapshot?.triggerReason);
+  if (reasons.length === 0 || reasons.some((reason) => !reason)) return undefined;
+  if (reasons.includes('sessionSave')) return 'session_completed';
+  if (reasons.every((reason) => reason === 'historicalBackfill')) {
+    return 'manual_backfill';
+  }
+  if (reasons.every((reason) => reason === 'dailyRefresh')) {
+    return 'daily_refresh';
+  }
+  return undefined;
+}
+
+function coachObservationGenerationMetadata(result, sourceTrigger) {
+  return {
+    attempted: true,
+    generated: Number(result?.generated ?? 0),
+    persisted: Number(result?.persisted ?? 0),
+    skippedReason: result?.skippedReason ?? null,
+    sourceTrigger: sourceTrigger ?? null
+  };
+}
+
+function normalizeAskCoachObservationFollowUp(value) {
+  if (!value || typeof value !== 'object') return null;
+  const id = String(value.id ?? '').trim();
+  return id ? { id: id.slice(0, 128) } : null;
+}
+
+function selectAskCoachObservationFollowUp(requested, observations) {
+  if (!requested) return null;
+  return (Array.isArray(observations) ? observations : [])
+    .find((observation) => String(observation?.id ?? '') === requested.id);
+}
+
 function routeRequest(url, method) {
   const pathname = url.pathname;
 
@@ -1055,6 +1099,28 @@ function routeRequest(url, method) {
     return { command: 'weekly-digest-current', options: {} };
   }
 
+  if (pathname === '/cli/coach-observations/current') {
+    return {
+      command: 'coach-observations-current',
+      options: {
+        limit: url.searchParams.get('limit') ?? undefined,
+        refresh: url.searchParams.get('refresh') ?? undefined
+      }
+    };
+  }
+
+  {
+    const coachObservationActionMatch = pathname.match(/^\/cli\/coach-observations\/([^/]+)\/(seen|dismiss)$/);
+    if (coachObservationActionMatch) {
+      return {
+        command: `coach-observations-${coachObservationActionMatch[2]}`,
+        options: {
+          id: decodeURIComponent(coachObservationActionMatch[1])
+        }
+      };
+    }
+  }
+
   if (pathname === '/cli/health/ai') {
     return {
       command: 'health-ai',
@@ -1512,6 +1578,27 @@ async function readJsonBody(request) {
   }
 }
 
+async function readOptionalJsonBody(request) {
+  const chunks = [];
+  let totalSize = 0;
+  for await (const chunk of request) {
+    totalSize += chunk.length;
+    if (totalSize > MAX_BODY_BYTES) {
+      throw new Error('Request body too large.');
+    }
+    chunks.push(chunk);
+  }
+
+  const raw = Buffer.concat(chunks).toString('utf8');
+  if (!raw.trim()) return {};
+
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new Error('Invalid JSON in request body.');
+  }
+}
+
 async function readUrlEncodedBody(request) {
   const chunks = [];
   let totalSize = 0;
@@ -1992,6 +2079,10 @@ export function createSyncServiceRequestHandler({
   insertScoreSnapshotsForAccount = null,
   listScoreSnapshotsForAccount = null,
   getCurrentWeeklyScoreDigestForAccount = null,
+  generateCoachObservationsForAccount = null,
+  listCurrentCoachObservationsForAccount = null,
+  markCoachObservationSeenForAccount = null,
+  dismissCoachObservationForAccount = null,
   // Social
   social = null,
   onError = null
@@ -2858,6 +2949,22 @@ export function createSyncServiceRequestHandler({
               return;
             }
             const result = await insertScoreSnapshotsForAccount(account, body.snapshots);
+            if (generateCoachObservationsForAccount) {
+              const sourceTrigger = coachObservationSourceTriggerForScoreSnapshots(body.snapshots);
+              try {
+                const generationResult = await generateCoachObservationsForAccount(account, { sourceTrigger });
+                result.coachObservations = coachObservationGenerationMetadata(generationResult, sourceTrigger);
+              } catch (error) {
+                console.error('Coach observation generation after score upload failed:', error.message);
+                result.coachObservations = {
+                  attempted: true,
+                  generated: 0,
+                  persisted: 0,
+                  skippedReason: 'generation_failed',
+                  sourceTrigger
+                };
+              }
+            }
             json(response, 200, result);
             return;
           } catch (error) {
@@ -3496,6 +3603,138 @@ export function createSyncServiceRequestHandler({
         return;
       }
 
+      if (route.command === 'coach-observations-current') {
+        if (request.method !== 'GET') {
+          methodNotAllowed(response, 'Use GET for /cli/coach-observations/current.');
+          return;
+        }
+        if (route.options.refresh && route.options.refresh !== 'morning_open') {
+          badRequest(response, 'Unsupported coach observations refresh value.');
+          return;
+        }
+        if (!listCurrentCoachObservationsForAccount) {
+          json(response, 503, { error: 'Coach observations not available' });
+          return;
+        }
+        try {
+          const limit = parseLimit(route.options.limit, { defaultValue: 5, max: 20 });
+          let refresh = null;
+          if (route.options.refresh === 'morning_open') {
+            const writeAccount = writeAuthenticator
+              ? await writeAuthenticator(requestToken)
+              : requestToken === token
+                ? account
+                : null;
+            if (!writeAccount) {
+              unauthorized(response, request);
+              return;
+            }
+            const sourceTrigger = 'daily_refresh';
+            if (generateCoachObservationsForAccount) {
+              try {
+                const generationResult = await generateCoachObservationsForAccount(writeAccount, {
+                  sourceTrigger,
+                  refresh: route.options.refresh
+                });
+                refresh = coachObservationGenerationMetadata(generationResult, sourceTrigger);
+              } catch (error) {
+                console.error('Coach observation generation on morning open failed:', error.message);
+                refresh = {
+                  attempted: true,
+                  generated: 0,
+                  persisted: 0,
+                  skippedReason: 'generation_failed',
+                  sourceTrigger
+                };
+              }
+            } else {
+              refresh = {
+                attempted: false,
+                generated: 0,
+                persisted: 0,
+                skippedReason: 'generation_unavailable',
+                sourceTrigger
+              };
+            }
+          }
+          const observations = await listCurrentCoachObservationsForAccount(account, {
+            limit
+          });
+          json(response, 200, {
+            observations: observations ?? [],
+            ...(refresh ? { refresh } : {})
+          });
+        } catch (err) {
+          console.error('Coach observations read error:', err.message);
+          json(response, 500, { error: 'Failed to read coach observations' });
+        }
+        return;
+      }
+
+      if (route.command === 'coach-observations-seen') {
+        if (request.method !== 'POST') {
+          methodNotAllowed(response, 'Use POST for /cli/coach-observations/:id/seen.');
+          return;
+        }
+        if (!markCoachObservationSeenForAccount) {
+          json(response, 503, { error: 'Coach observations not available' });
+          return;
+        }
+        let body = {};
+        try {
+          body = await readOptionalJsonBody(request);
+        } catch {
+          badRequest(response, 'Invalid request body.');
+          return;
+        }
+        const seenAt = body?.seenAt ? new Date(body.seenAt) : null;
+        if (seenAt && Number.isNaN(seenAt.getTime())) {
+          badRequest(response, 'Invalid seenAt.');
+          return;
+        }
+        try {
+          const observation = await markCoachObservationSeenForAccount(account, route.options.id, { seenAt });
+          if (!observation) {
+            notFound(response, 'Observation not found');
+            return;
+          }
+          json(response, 200, { observation });
+        } catch (err) {
+          console.error('Coach observation seen error:', err.message);
+          json(response, 500, { error: 'Failed to mark observation seen' });
+        }
+        return;
+      }
+
+      if (route.command === 'coach-observations-dismiss') {
+        if (request.method !== 'POST') {
+          methodNotAllowed(response, 'Use POST for /cli/coach-observations/:id/dismiss.');
+          return;
+        }
+        if (!dismissCoachObservationForAccount) {
+          json(response, 503, { error: 'Coach observations not available' });
+          return;
+        }
+        try {
+          await readOptionalJsonBody(request);
+        } catch {
+          badRequest(response, 'Invalid request body.');
+          return;
+        }
+        try {
+          const observation = await dismissCoachObservationForAccount(account, route.options.id, {});
+          if (!observation) {
+            notFound(response, 'Observation not found');
+            return;
+          }
+          json(response, 200, { observation });
+        } catch (err) {
+          console.error('Coach observation dismiss error:', err.message);
+          json(response, 500, { error: 'Failed to dismiss observation' });
+        }
+        return;
+      }
+
       let snapshot;
       try {
         snapshot = loadSnapshotForAccount
@@ -4140,6 +4379,7 @@ export function createSyncServiceRequestHandler({
 
         const queries = await import('./queries.js');
         const exclude = parseExclude(body?.exclude);
+        const requestedCoachObservation = normalizeAskCoachObservationFollowUp(body?.coachObservation);
         let coachFacts = [];
         if (listCoachFactsForAccount) {
           try {
@@ -4166,10 +4406,21 @@ export function createSyncServiceRequestHandler({
             history: enrichedSnapshots
           };
         }
+        let coachObservations = [];
+        if (listCurrentCoachObservationsForAccount) {
+          try {
+            coachObservations = await listCurrentCoachObservationsForAccount(account, { limit: requestedCoachObservation ? 10 : 3 }) ?? [];
+          } catch (observationErr) {
+            console.error('Coach observations read error (ask):', observationErr.message);
+          }
+        }
+        const coachObservationFollowUp = selectAskCoachObservationFollowUp(requestedCoachObservation, coachObservations);
 
-        const routedContext = queries.askRoutedContext
-          ? queries.askRoutedContext(snapshot, question, { exclude, coachFacts })
-          : { context: queries.askContext(snapshot, { exclude }), metadata: { route: 'legacy' } };
+        const routedContext = coachObservationFollowUp && queries.askObservationFollowUpContext
+          ? queries.askObservationFollowUpContext(snapshot, question, coachObservationFollowUp, { exclude, coachFacts })
+          : queries.askRoutedContext
+            ? queries.askRoutedContext(snapshot, question, { exclude, coachFacts, coachObservations })
+            : { context: queries.askContext(snapshot, { exclude }), metadata: { route: 'legacy' } };
         const persistedKind = persistedConversation?.kind ?? (conversationId?.startsWith('weekly-checkin:') ? 'weekly-checkin' : 'ask');
         const incrementScorePrelude = formatIncrementScorePrelude(scoreSnapshots);
 
@@ -4198,7 +4449,8 @@ export function createSyncServiceRequestHandler({
               historyTurnCount: canonicalHistory.filter((m) => m.role === 'user').length,
               coachFactsIncluded: (routedContext.metadata?.includedCoachFactIds ?? []).length > 0,
               coachFactIds: routedContext.metadata?.includedCoachFactIds ?? [],
-              coachFactKinds: routedContext.metadata?.coachFactKinds ?? []
+              coachFactKinds: routedContext.metadata?.coachFactKinds ?? [],
+              coachObservationIds: routedContext.metadata?.includedCoachObservationIds ?? []
             }
           });
 
@@ -4255,6 +4507,15 @@ export function createSyncServiceRequestHandler({
               });
             });
           }
+          if (markCoachObservationSeenForAccount) {
+            for (const observationId of routedContext.metadata?.includedCoachObservationIds ?? []) {
+              try {
+                await markCoachObservationSeenForAccount(account, observationId, {});
+              } catch (seenErr) {
+                console.error('Failed to mark coach observation seen:', seenErr.message);
+              }
+            }
+          }
           const updatedUserTurns = updatedMessages.filter((m) => m.role === 'user').length;
           if (
             persistedKind === 'weekly-checkin' &&