incremnt 0.1.13 → 0.1.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incremnt",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "Command-line tool for querying your incremnt strength training data",
   "license": "MIT",
   "type": "module",
@@ -13,7 +13,8 @@
   ],
   "scripts": {
     "test": "node --test",
-    "dev:sync-fixture": "node ./scripts/dev-sync-fixture-server.js"
+    "dev:sync-fixture": "node ./scripts/dev-sync-fixture-server.js",
+    "postinstall": "node -e \"process.stdout.write('\\n  incremnt MCP server installed.\\n  Run: incremnt mcp install\\n  to register it with Claude.\\n\\n')\""
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.1",

package/src/lib.js

@@ -1,5 +1,7 @@
 import fs from 'node:fs/promises';
-import { spawn } from 'node:child_process';
+import path from 'node:path';
+import os from 'node:os';
+import { spawn, execFileSync } from 'node:child_process';
 import { capabilities, commandSchema, contractVersion, officialCommands, proposalSchema, readCommands, writeCommands, writeCommandSchema } from './contract.js';
 import {
   bootstrapSessionFromRemoteBaseUrl,
@@ -139,6 +141,40 @@ export async function runCli(argv, stdout, stderr) {
     }
   }
 
+  if (normalizedCommand === 'mcp install') {
+    try {
+      const mcpBin = resolveMcpBin();
+      const installed = [];
+
+      // Claude Desktop
+      const desktopPath = claudeDesktopConfigPath();
+      let desktopConfig = {};
+      try {
+        desktopConfig = JSON.parse(await fs.readFile(desktopPath, 'utf8'));
+      } catch { /* file doesn't exist yet */ }
+      desktopConfig.mcpServers = { ...desktopConfig.mcpServers, incremnt: { command: mcpBin } };
+      await fs.mkdir(path.dirname(desktopPath), { recursive: true });
+      await fs.writeFile(desktopPath, JSON.stringify(desktopConfig, null, 2) + '\n');
+      installed.push(`  Claude Desktop: ${desktopPath}`);
+
+      // Claude Code CLI
+      const cliPath = path.join(os.homedir(), '.claude.json');
+      let cliConfig = {};
+      try {
+        cliConfig = JSON.parse(await fs.readFile(cliPath, 'utf8'));
+      } catch { /* file doesn't exist yet */ }
+      cliConfig.mcpServers = { ...cliConfig.mcpServers, incremnt: { type: 'stdio', command: mcpBin } };
+      await fs.writeFile(cliPath, JSON.stringify(cliConfig, null, 2) + '\n');
+      installed.push(`  Claude Code:    ${cliPath}`);
+
+      stdout.write(`Registered incremnt MCP server in:\n${installed.join('\n')}\n\nRestart Claude for the changes to take effect.\n`);
+      return 0;
+    } catch (error) {
+      stderr.write(`${error.message}\n`);
+      return 1;
+    }
+  }
+
   if (normalizedCommand === 'login') {
     if (options.snapshot) {
       try {
@@ -380,6 +416,26 @@ function browserCommandForPlatform() {
   return null;
 }
 
+function claudeDesktopConfigPath() {
+  if (process.platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+  }
+  if (process.platform === 'win32') {
+    return path.join(process.env.APPDATA ?? path.join(os.homedir(), 'AppData', 'Roaming'), 'Claude', 'claude_desktop_config.json');
+  }
+  return path.join(os.homedir(), '.config', 'Claude', 'claude_desktop_config.json');
+}
+
+function resolveMcpBin() {
+  try {
+    return execFileSync('which', ['incremnt-mcp'], { encoding: 'utf8' }).trim();
+  } catch {
+    // fall back to sibling binary next to the current incremnt binary
+    const dir = path.dirname(process.argv[1]);
+    return path.join(dir, 'incremnt-mcp');
+  }
+}
+
 function configuredAuthProviders(auth) {
   const providers = auth?.providers ?? {};
   const labels = [];

package/src/openrouter.js

@@ -1,3 +1,5 @@
+// Default model used only for local dev. In production the sync service
+// sets OPENROUTER_MODEL via env vars (currently Claude 3.5 Haiku).
 const DEFAULT_MODEL = 'meta-llama/llama-3.1-8b-instruct:free';
 const DEFAULT_TIMEOUT_MS = 15_000;
 const DEFAULT_MAX_TOKENS = 500;
@@ -172,16 +174,19 @@ Focus on:
 - Plan deviations: exercises swapped, skipped, or added vs the plan. Ask why if something looks unusual.
 - Set completion: if they did fewer sets than planned on an exercise, note it and ask about it.
 - Cross-session patterns: trends across recent sessions (volume direction on specific lifts, consistent cutoffs, same weight for weeks).
+- If exercises are marked "first session" they have zero prior history. State this plainly — don't frame it as "exploring" or "a new loading strategy."
+- If this is an adhoc session (no program), note any overlap with programmed exercises.
 - Ask 1-2 genuine questions about choices that look interesting or unusual.
 
-Rules:
-- Only state what the data shows. Never claim how something "felt" — you have numbers, not feelings.
-- Never use words like: impressive, crushed, solid, demonstrating, significant, incredible, fantastic, smooth, controlled.
-- Never use -ing clauses that add fake depth ("indicating progressive overload", "demonstrating strength gains").
-- Never say things "felt smooth", "felt controlled", "feels about average" — you cannot know this.
-- Never restate PRs, total volume, or effort score — the user already sees these in the app.
-- Write like a training partner looking at a logbook, not a motivational coach.
-- Short sentences, no filler, no cheerleading. Questions are good.
+Voice rules — follow these exactly:
+- Only state what the data shows. Never claim how something "felt."
+- Be specific. Use numbers and exercise names, not vague descriptions.
+- No hedging: don't soften with "suggests", "appears to", "looks like", "seems", "might", "could potentially", "may want to." State it.
+- No filler preambles: don't start sentences with "The session shows", "Your performance indicates", "It's worth noting." Just say it.
+- No -ing clauses that add fake depth ("indicating progressive overload", "demonstrating strength gains", "suggesting increased capacity").
+- Never use: impressive, crushed, solid, demonstrating, significant, incredible, fantastic, smooth, controlled, highlighting, journey, empower.
+- Never restate PRs, total volume, or effort score — the user already sees these.
+- Write like a training partner reading a logbook. Short sentences, no filler, no cheerleading.
 - No bullet points or lists.`;
 
 export async function generateWorkoutCoachingSummary(workoutContext, { apiKey, model, timeoutMs } = {}) {
@@ -232,9 +237,10 @@ export async function generateWorkoutCoachingSummary(workoutContext, { apiKey, m
 }
 
 export function formatWorkoutContext(ctx) {
-  const lines = [
-    `Session: ${ctx.dayName}, ${ctx.sessionDate}, ${ctx.totalVolume} kg total volume.`
-  ];
+  const sessionLabel = ctx.isAdhoc
+    ? `Session: ${ctx.dayName}, ${ctx.sessionDate}, adhoc (no program), ${ctx.totalVolume} kg total volume.`
+    : `Session: ${ctx.dayName}, ${ctx.sessionDate}, program "${ctx.programName}", ${ctx.totalVolume} kg total volume.`;
+  const lines = [sessionLabel];
 
   if (ctx.effortScore) {
     lines.push(`Effort rating: ${ctx.effortScore}/10.`);
@@ -243,11 +249,14 @@ export function formatWorkoutContext(ctx) {
   lines.push('Exercises:');
   for (const ex of ctx.exercises) {
     const topPart = ex.topSet ? ` (top: ${ex.topSet.weight}×${ex.topSet.reps})` : '';
-    lines.push(`  ${ex.exerciseName}: ${ex.completedSets} sets${topPart}`);
+    const historyPart = ex.priorSessions === 0
+      ? ' [first session]'
+      : ` [${ex.priorSessions} prior sessions]`;
+    lines.push(`  ${ex.exerciseName}: ${ex.completedSets} sets${topPart}${historyPart}`);
   }
 
   if (ctx.prs.length > 0) {
-    lines.push('PRs this session:');
+    lines.push('PRs this session (only exercises with prior history):');
     for (const pr of ctx.prs) {
       lines.push(`  ${pr.exerciseName}: ${pr.weight}×${pr.reps} (e1RM ${pr.estimatedOneRM})`);
     }
@@ -257,7 +266,8 @@ export function formatWorkoutContext(ctx) {
     lines.push('Recent same-day sessions for comparison:');
     for (const comp of ctx.recentComparisons) {
       const effort = comp.effortScore ? `, effort ${comp.effortScore}/10` : '';
-      lines.push(`  ${comp.date}: ${comp.totalVolume} kg volume${effort}`);
+      const prog = comp.programName ? ` (${comp.programName})` : '';
+      lines.push(`  ${comp.date}: ${comp.totalVolume} kg volume${effort}${prog}`);
     }
   }
 
@@ -282,3 +292,52 @@ export function formatWorkoutContext(ctx) {
 
   return lines.join('\n');
 }
+
+const ASK_PROMPT = `You are a knowledgeable strength training assistant. Answer questions about the user's workout history concisely. Reference specific numbers, dates, and exercises from their data. If the data doesn't contain information to answer the question, say so briefly. Keep answers to 2-4 sentences.`;
+
+export async function generateAskAnswer(context, question, { apiKey, model, timeoutMs } = {}) {
+  const resolvedModel = model || DEFAULT_MODEL;
+  const resolvedTimeout = timeoutMs || DEFAULT_TIMEOUT_MS;
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), resolvedTimeout);
+
+  try {
+    const userContent = `${context}\n\nQuestion: ${question}`;
+
+    const response = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+        'HTTP-Referer': 'https://incremnt.app',
+        'X-Title': 'incremnt'
+      },
+      body: JSON.stringify({
+        model: resolvedModel,
+        messages: [
+          { role: 'system', content: ASK_PROMPT },
+          { role: 'user', content: userContent }
+        ],
+        max_tokens: 300,
+        temperature: 0.3
+      }),
+      signal: controller.signal
+    });
+
+    if (!response.ok) {
+      const text = await response.text().catch(() => '');
+      throw new Error(`OpenRouter API error ${response.status}: ${text}`);
+    }
+
+    const data = await response.json();
+    const content = data.choices?.[0]?.message?.content;
+    if (!content) {
+      throw new Error('No content in OpenRouter response');
+    }
+
+    return content.trim();
+  } finally {
+    clearTimeout(timer);
+  }
+}

package/src/queries.js

@@ -58,7 +58,7 @@ function sessionSummary(session) {
     recommendations: session.recommendations ?? {},
     historicalContext: session.historicalContext ?? null,
     prescriptionSnapshot: session.prescriptionSnapshot ?? null,
-    aiCoachNotes: session.aiCoachNotes ?? null
+    aiCoachNotes: session.summary?.aiCoachNotes ?? null
   };
 }
 
@@ -692,24 +692,26 @@ export function workoutSummaryContext(snapshot, sessionId) {
     };
   });
 
-  // Find recent sessions with same dayName for comparison (up to 3, excluding current)
+  // Find recent sessions with same dayName for comparison (up to 3, excluding current).
+  // Match across programs so context survives program switches.
   const recentComparisons = sessions
     .filter(
       (s) =>
         s.id !== sessionId &&
-        s.dayName === dayName &&
-        s.programId === session.programId
+        s.dayName === dayName
     )
     .sort((a, b) => String(completionDateForSession(b)).localeCompare(String(completionDateForSession(a))))
     .slice(0, 3)
     .map((s) => ({
       date: completionDateForSession(s),
       totalVolume: s.summary?.totalVolume ?? s.volume ?? 0,
-      effortScore: s.summary?.effortScore ?? null
+      effortScore: s.summary?.effortScore ?? null,
+      programName: s.programName ?? null
     }));
 
-  // Detect PRs — compare each exercise's best e1RM against all prior sessions
+  // Count prior sessions per exercise and track best e1RM scores
   const priorBests = new Map();
+  const exerciseSessionCounts = new Map();
   for (const s of sessions) {
     if (s.id === sessionId) continue;
     const sDate = String(completionDateForSession(s));
@@ -717,9 +719,10 @@ export function workoutSummaryContext(snapshot, sessionId) {
     if (sDate >= currentDate) continue;
 
     for (const exercise of s.exercises ?? []) {
+      const key = normalizeExerciseName(exercise.name);
+      exerciseSessionCounts.set(key, (exerciseSessionCounts.get(key) ?? 0) + 1);
       for (const set of exercise.sets ?? []) {
         if (!set.isComplete) continue;
-        const key = normalizeExerciseName(exercise.name);
         const score = Number(set.weight) * (1 + Number(set.reps) / 30);
         const current = priorBests.get(key);
         if (!current || score > current) priorBests.set(key, score);
@@ -727,14 +730,22 @@ export function workoutSummaryContext(snapshot, sessionId) {
     }
   }
 
+  // Attach prior session count to each exercise
+  for (const ex of exercises) {
+    const key = normalizeExerciseName(ex.exerciseName);
+    ex.priorSessions = exerciseSessionCounts.get(key) ?? 0;
+  }
+
+  // Detect PRs — skip first-time exercises (every set is trivially a "PR")
   const prs = [];
   for (const exercise of session.exercises ?? []) {
     const key = normalizeExerciseName(exercise.name);
+    if (!priorBests.has(key)) continue;
     for (const set of exercise.sets ?? []) {
       if (!set.isComplete) continue;
       const score = Number(set.weight) * (1 + Number(set.reps) / 30);
       const prior = priorBests.get(key);
-      if (!prior || score > prior) {
+      if (score > prior) {
         prs.push({
           exerciseName: exercise.name,
           weight: set.weight,
@@ -760,9 +771,12 @@ export function workoutSummaryContext(snapshot, sessionId) {
     }
   }
 
+  const isAdhoc = !session.programId;
   const result = {
     sessionDate,
     dayName,
+    programName: session.programName ?? null,
+    isAdhoc,
     totalVolume: session.summary?.totalVolume ?? session.volume ?? 0,
     effortScore: session.summary?.effortScore ?? null,
     exercises,
@@ -773,6 +787,85 @@ export function workoutSummaryContext(snapshot, sessionId) {
   return result;
 }
 
+export function askContext(snapshot) {
+  const sessions = snapshot.sessions ?? [];
+  const lines = [];
+
+  lines.push(`Training overview: ${sessions.length} total workouts logged.`);
+
+  // Training frequency (last 4 weeks)
+  const fourWeeksAgo = new Date(Date.now() - 28 * 24 * 60 * 60 * 1000).toISOString();
+  const recentCount = sessions.filter((s) => String(completionDateForSession(s)) >= fourWeeksAgo).length;
+  if (recentCount > 0) {
+    const perWeek = (recentCount / 4).toFixed(1);
+    lines.push(`Recent frequency: ${perWeek} sessions/week (last 4 weeks).`);
+  }
+
+  // Current program
+  const program = activeProgram(snapshot);
+  if (program) {
+    lines.push(`Current program: ${program.name}, ${program.daysPerWeek} days/week, equipment: ${program.equipmentTier ?? 'unknown'}.`);
+  }
+
+  // Best e1RM records (top 15)
+  const bestByExercise = new Map();
+  for (const session of sessions) {
+    for (const exercise of session.exercises ?? []) {
+      const key = normalizeExerciseName(exercise.name);
+      for (const set of exercise.sets ?? []) {
+        if (!set.isComplete) continue;
+        const e1rm = Number(set.weight) * (1 + Number(set.reps) / 30);
+        const current = bestByExercise.get(key);
+        if (!current || e1rm > current.e1rm) {
+          bestByExercise.set(key, { name: exercise.name, e1rm });
+        }
+      }
+    }
+  }
+
+  const records = [...bestByExercise.values()]
+    .filter((r) => r.e1rm > 0)
+    .sort((a, b) => b.e1rm - a.e1rm)
+    .slice(0, 15);
+
+  if (records.length > 0) {
+    lines.push('');
+    lines.push('Best estimated 1RM records:');
+    for (const r of records) {
+      lines.push(`  ${r.name}: ${r.e1rm.toFixed(1)} kg`);
+    }
+  }
+
+  // Recent sessions (last 10)
+  const recentSessions = sessions.slice(-10);
+  if (recentSessions.length > 0) {
+    lines.push('');
+    lines.push('Recent sessions (newest last):');
+    for (const session of recentSessions) {
+      const dateStr = completionDateForSession(session);
+      const dayLabel = session.dayName ?? session.programName ?? 'Workout';
+      const exerciseNames = (session.exercises ?? []).map((e) => e.name).join(', ');
+      const volume = session.summary?.totalVolume ?? session.volume ?? 0;
+      let line = `  ${dateStr} - ${dayLabel}: ${exerciseNames}`;
+      if (volume > 0) line += ` (${volume} kg volume)`;
+      lines.push(line);
+
+      for (const exercise of session.exercises ?? []) {
+        const completedSets = (exercise.sets ?? []).filter((s) => s.isComplete);
+        if (completedSets.length === 0) continue;
+        const topSet = completedSets.reduce((best, s) => {
+          const score = Number(s.weight) * Number(s.reps);
+          const bestScore = Number(best.weight) * Number(best.reps);
+          return score > bestScore ? s : best;
+        });
+        lines.push(`    ${exercise.name}: ${completedSets.length} sets, top ${Number(topSet.weight).toFixed(1)}x${topSet.reps}`);
+      }
+    }
+  }
+
+  return lines.join('\n');
+}
+
 function requiredOption(options, primaryKey, legacyKey = null) {
   return options[primaryKey] ?? (legacyKey ? options[legacyKey] : undefined);
 }

package/src/sync-service.js

@@ -7,6 +7,7 @@ const DEFAULT_RATE_LIMIT_WINDOW_MS = 60_000;
 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,
@@ -261,6 +262,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 +324,14 @@ function routeRequest(url) {
     };
   }
 
+  if (pathname === '/cli/ask') {
+    return { command: 'ask-ai', options: {} };
+  }
+
+  if (pathname === '/cli/ask/history') {
+    return { command: 'ask-history', options: {} };
+  }
+
   return null;
 }
 
@@ -779,7 +802,9 @@ export function createSyncServiceRequestHandler({
   createProposalForAccount = null,
   listProposalsForAccount = null,
   updateProposalForAccount = null,
-  updateAnalysisConsentForAccount = null
+  updateAnalysisConsentForAccount = null,
+  saveAskConversationForAccount = null,
+  listAskConversationsForAccount = null
 }) {
   const rateLimiter = createRateLimiter(rateLimitConfig ?? {});
 
@@ -1716,6 +1741,79 @@ export function createSyncServiceRequestHandler({
         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 openrouterKey = process.env.OPENROUTER_API_KEY;
+        if (!openrouterKey) {
+          json(response, 503, { error: 'AI not configured' });
+          return;
+        }
+
+        const { askContext } = await import('./queries.js');
+        const ctx = askContext(snapshot);
+
+        try {
+          const { generateAskAnswer } = await import('./openrouter.js');
+          const model = process.env.OPENROUTER_MODEL || undefined;
+          const answer = await generateAskAnswer(ctx, question, { apiKey: openrouterKey, model });
+          if (saveAskConversationForAccount) {
+            try {
+              await saveAskConversationForAccount(account, { question, answer });
+            } catch (saveErr) {
+              console.error('Failed to save ask conversation:', saveErr.message);
+            }
+          }
+          json(response, 200, { answer });
+        } catch (err) {
+          console.error('AI ask error:', err.message);
+          json(response, 502, { error: 'Failed to generate AI answer' });
+        }
+        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 conversations = await listAskConversationsForAccount(account);
+          json(response, 200, { conversations });
+        } catch (err) {
+          console.error('Ask history error:', err.message);
+          json(response, 500, { error: 'Failed to load ask history' });
+        }
+        return;
+      }
+
       const result = executeReadCommand(snapshot, route.command, route.options);
       if (!result.ok) {
         if (result.error.startsWith('Session not found')) {