incremnt 0.6.1 → 0.7.1

package/src/lib.js

@@ -16,6 +16,21 @@ import { createTransport } from './transport.js';
 import { formatPretty, formatHelp } from './format.js';
 import { printLogo } from './logo.js';
 import { runBrowseCli } from './browse.js';
+import { ValidationError, validateOptions } from './validate.js';
+import { projectFields } from './fields.js';
+import { buildWriteRequest } from './remote.js';
+
+const schemaById = new Map([
+  ...commandSchema.map((c) => [c.id, c]),
+  ...writeCommandSchema.map((c) => [c.id, c])
+]);
+
+function pageAllRecords(payload, commandEntry) {
+  if (Array.isArray(payload)) return payload;
+  const key = commandEntry?.pageAllKey;
+  if (key && Array.isArray(payload?.[key])) return payload[key];
+  return [payload];
+}
 
 function parseArgs(argv) {
   const commandTokens = [];
@@ -73,15 +88,7 @@ export async function runCli(argv, stdout, stderr) {
   })[command] ?? command;
 
   const sessionState = await readSessionState();
-  const hasTransport = Boolean(
-    sessionState?.session?.transport?.baseUrl
-    || sessionState?.session?.transport?.fixturePath
-  );
-  const isAuthenticated = Boolean(
-    sessionState?.session
-    && !isSessionExpired(sessionState.session)
-    && hasTransport
-  );
+  const isAuthenticated = Boolean(sessionState?.session && !isSessionExpired(sessionState.session));
 
   if (!command || options.help) {
     await printLogo(stdout);
@@ -353,9 +360,59 @@ export async function runCli(argv, stdout, stderr) {
   const wantJson = options.json || !(stdout.isTTY ?? false);
   const explicitJson = Boolean(options.json);
 
+  // Reject --dry-run on any command that doesn't declare dryRun support
+  // (reads, unknown commands, and writes without dryRun: true). Without this
+  // guard, --dry-run is silently dropped and the underlying command runs.
+  if (options['dry-run'] && !schemaById.get(normalizedCommand)?.dryRun) {
+    const cmdLabel = schemaById.get(normalizedCommand)?.command ?? command ?? normalizedCommand;
+    const message = `--dry-run is not supported for ${cmdLabel}.`;
+    if (explicitJson) {
+      stdout.write(`${JSON.stringify({ error: message, code: 'UNSUPPORTED_DRY_RUN' }, null, 2)}\n`);
+    } else {
+      stderr.write(`${message}\n`);
+    }
+    return 1;
+  }
+
   if (writeCommands.has(normalizedCommand)) {
+    let validated;
+    try {
+      validated = validateOptions(schemaById.get(normalizedCommand), options);
+    } catch (error) {
+      if (error instanceof ValidationError) {
+        if (explicitJson) {
+          stdout.write(`${JSON.stringify({ error: error.message, code: error.code, option: error.option }, null, 2)}\n`);
+        } else {
+          stderr.write(`${error.message}\n`);
+        }
+        return 1;
+      }
+      throw error;
+    }
+
+    const cmdEntry = schemaById.get(normalizedCommand);
+    if (options['dry-run']) {
+      // Outer guard already verified cmdEntry.dryRun is true here.
+      try {
+        const request = await buildWriteRequest(normalizedCommand, validated, sessionState);
+        stdout.write(`${JSON.stringify({
+          dryRun: true,
+          command: cmdEntry.command,
+          request
+        }, null, 2)}\n`);
+        return 0;
+      } catch (error) {
+        if (explicitJson) {
+          stdout.write(`${JSON.stringify({ error: error.message, code: error.code ?? null }, null, 2)}\n`);
+        } else {
+          stderr.write(`${error.message}\n`);
+        }
+        return 1;
+      }
+    }
+
     try {
-      const payload = await transport.executeWriteCommand(normalizedCommand, options);
+      const payload = await transport.executeWriteCommand(normalizedCommand, validated);
       if (wantJson) {
         stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
       } else {
@@ -386,13 +443,59 @@ export async function runCli(argv, stdout, stderr) {
     return 1;
   }
 
+  let validatedRead;
   try {
-    const payload = await transport.executeReadCommand(normalizedCommand, options);
+    validatedRead = validateOptions(schemaById.get(normalizedCommand), options);
+  } catch (error) {
+    if (error instanceof ValidationError) {
+      if (explicitJson) {
+        stdout.write(`${JSON.stringify({ error: error.message, code: error.code, option: error.option }, null, 2)}\n`);
+      } else {
+        stderr.write(`${error.message}\n`);
+      }
+      return 1;
+    }
+    throw error;
+  }
+
+  const readCmdEntry = schemaById.get(normalizedCommand);
+
+  if (options.fields !== undefined && !readCmdEntry?.supportsFields) {
+    const message = `--fields is not supported for ${readCmdEntry?.command ?? normalizedCommand}.`;
+    if (explicitJson) {
+      stdout.write(`${JSON.stringify({ error: message, code: 'UNSUPPORTED_FIELDS' }, null, 2)}\n`);
+    } else {
+      stderr.write(`${message}\n`);
+    }
+    return 1;
+  }
+
+  if (options['page-all'] && !readCmdEntry?.supportsPageAll) {
+    const message = `--page-all is not supported for ${readCmdEntry?.command ?? normalizedCommand}.`;
+    if (explicitJson) {
+      stdout.write(`${JSON.stringify({ error: message, code: 'UNSUPPORTED_PAGE_ALL' }, null, 2)}\n`);
+    } else {
+      stderr.write(`${message}\n`);
+    }
+    return 1;
+  }
+
+  try {
+    const payload = await transport.executeReadCommand(normalizedCommand, validatedRead);
+    const projected = options.fields !== undefined ? projectFields(payload, options.fields) : payload;
+
+    if (options['page-all'] && readCmdEntry?.supportsPageAll) {
+      for (const record of pageAllRecords(projected, readCmdEntry)) {
+        stdout.write(`${JSON.stringify(record)}\n`);
+      }
+      return 0;
+    }
+
     if (wantJson) {
-      stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+      stdout.write(`${JSON.stringify(projected, null, 2)}\n`);
     } else {
-      const pretty = formatPretty(normalizedCommand, payload);
-      stdout.write(`${pretty ?? JSON.stringify(payload, null, 2)}\n`);
+      const pretty = formatPretty(normalizedCommand, projected);
+      stdout.write(`${pretty ?? JSON.stringify(projected, null, 2)}\n`);
     }
 
     return 0;

package/src/mcp.js

@@ -11,6 +11,9 @@ import { commandSchema, writeCommands, writeCommandSchema } from './contract.js'
 import { listCoachReadTools } from './queries.js';
 import { readSessionState } from './state.js';
 import { createTransport } from './transport.js';
+import { ValidationError, validateOptions } from './validate.js';
+import { projectFields } from './fields.js';
+import { buildWriteRequest } from './remote.js';
 
 const globalScope = Function('return this')();
 
@@ -24,6 +27,14 @@ function commandShape(cmd) {
     shape[opt.name] = field;
   }
 
+  if (cmd.supportsFields) {
+    shape.fields = z.string().optional().describe('Comma-separated top-level keys to keep in the response. Cuts payload size for context-bound agents.');
+  }
+
+  if (cmd.dryRun) {
+    shape['dry-run'] = z.boolean().optional().describe('Preview the request without sending. Returns { dryRun: true, command, request }.');
+  }
+
   return shape;
 }
 
@@ -57,9 +68,43 @@ export function registerMcpTools(server, {
   readSessionStateFn = readSessionState,
   createTransportFn = createTransport
 } = {}) {
-  for (const cmd of [...commandSchema, ...writeCommandSchema]) {
-    server.tool(cmd.id, cmd.description, commandShape(cmd), async (args) => {
+  for (const cmd of [...commandSchema, ...writeCommandSchema].filter((entry) => entry.mcp !== false)) {
+    const description = cmd.agentNotes
+      ? `${cmd.description}\n\nNotes for agents:\n${cmd.agentNotes}`
+      : cmd.description;
+    server.tool(cmd.id, description, commandShape(cmd), async (args, extra) => {
       try {
+        // Reject --dry-run on tools that don't support it. Zod strips unknown
+        // fields silently, so without this guard a caller passing dry-run on
+        // an unsupported tool would execute the real mutation. Check the raw
+        // request when available; fall back to args.
+        const rawDryRun = extra?.request?.params?.arguments?.['dry-run'] ?? args?.['dry-run'];
+        if (rawDryRun && !cmd.dryRun) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({ error: `--dry-run is not supported for ${cmd.command}.`, code: 'UNSUPPORTED_DRY_RUN' }, null, 2)
+            }],
+            isError: true
+          };
+        }
+
+        let validated;
+        try {
+          validated = validateOptions(cmd, args);
+        } catch (error) {
+          if (error instanceof ValidationError) {
+            return {
+              content: [{
+                type: 'text',
+                text: JSON.stringify({ error: error.message, code: error.code, option: error.option }, null, 2)
+              }],
+              isError: true
+            };
+          }
+          throw error;
+        }
+
         const sessionState = await readSessionStateFn();
         const transport = await createTransportFn({}, sessionState);
 
@@ -70,12 +115,23 @@ export function registerMcpTools(server, {
           };
         }
 
+        if (cmd.dryRun && validated['dry-run']) {
+          const request = await buildWriteRequest(cmd.id, validated, sessionState);
+          return {
+            content: [{ type: 'text', text: JSON.stringify({ dryRun: true, command: cmd.command, request }, null, 2) }]
+          };
+        }
+
         const result = writeCommands.has(cmd.id)
-          ? await transport.executeWriteCommand(cmd.id, args)
-          : await transport.executeReadCommand(cmd.id, args);
+          ? await transport.executeWriteCommand(cmd.id, validated)
+          : await transport.executeReadCommand(cmd.id, validated);
+
+        const projected = cmd.supportsFields && validated.fields !== undefined
+          ? projectFields(result, validated.fields)
+          : result;
 
         return {
-          content: [{ type: 'text', text: JSON.stringify(result, null, 2) }]
+          content: [{ type: 'text', text: JSON.stringify(projected, null, 2) }]
         };
       } catch (error) {
         const message = error && error.message ? error.message : String(error);

package/src/queries.js

@@ -3610,7 +3610,42 @@ function askToolMetadata(tools = [], provenance = []) {
   };
 }
 
-export function askRoutedContext(snapshot, question, { exclude = new Set(), coachFacts = null } = {}) {
+function appendCoachObservationsContextBeforeExcludeNote(lines, observations, exclude = new Set()) {
+  if (exclude.has('coach_observations')) return [];
+  const usable = (Array.isArray(observations) ? observations : [])
+    .filter((observation) => observation?.id && observation?.summary)
+    .slice(0, 3);
+  if (usable.length === 0) return [];
+
+  const note = buildExcludeNote(exclude);
+  const noteAtEnd = note && lines.at(-1) === note;
+  if (noteAtEnd) {
+    lines.pop();
+    if (lines.at(-1) === '') lines.pop();
+  }
+  const section = [
+    '',
+    'Coach observations (derived from training data, not user-stated facts):'
+  ];
+  for (const observation of usable) {
+    const parts = [
+      `[${observation.kind ?? 'observation'}] ${observation.summary}`,
+      observation.actionText ? `Action: ${observation.actionText}` : null,
+      observation.sourceComponent ? `component=${observation.sourceComponent}` : null,
+      `confidence=${Number(observation.confidence ?? 0).toFixed(2)}`,
+      `observation-id=${observation.id}`
+    ].filter(Boolean);
+    section.push(`  ${parts.join(' ')}`);
+  }
+  lines.push(...section);
+  if (noteAtEnd) {
+    lines.push('');
+    lines.push(note);
+  }
+  return usable.map((observation) => observation.id);
+}
+
+export function askRoutedContext(snapshot, question, { exclude = new Set(), coachFacts = null, coachObservations = null } = {}) {
   const { route, namedExercises } = routeAskQuestion(snapshot, question);
   let effectiveRoute = route;
   let fallbackRoute = null;
@@ -3657,6 +3692,7 @@ export function askRoutedContext(snapshot, question, { exclude = new Set(), coac
   const factLines = built.context.split('\n');
   const includedFacts = rankedCoachFactsForAsk(snapshot, question, effectiveRoute, { facts: coachFacts });
   const includedCoachFactIds = appendCoachFactsContextBeforeExcludeNote(factLines, includedFacts, exclude);
+  const includedCoachObservationIds = appendCoachObservationsContextBeforeExcludeNote(factLines, coachObservations, exclude);
   const includedCoachFactKinds = uniqueArray(includedFacts.map((fact) => fact.kind));
   const includedCoachFactSources = uniqueArray(includedFacts.map((fact) => {
     const sourceSessionId = String(fact.sourceSessionId ?? '');
@@ -3666,7 +3702,11 @@ export function askRoutedContext(snapshot, question, { exclude = new Set(), coac
   }).filter(Boolean));
   built = {
     context: factLines.join('\n'),
-    sections: includedFacts.length > 0 ? [...built.sections, 'coach_facts'] : built.sections
+    sections: [
+      ...built.sections,
+      ...(includedFacts.length > 0 ? ['coach_facts'] : []),
+      ...(includedCoachObservationIds.length > 0 ? ['coach_observations'] : [])
+    ]
   };
 
   return {
@@ -3683,6 +3723,8 @@ export function askRoutedContext(snapshot, question, { exclude = new Set(), coac
       coachFactIds: includedCoachFactIds,
       coachFactKinds: includedCoachFactKinds,
       coachFactSources: includedCoachFactSources,
+      includedCoachObservationIds,
+      coachObservationIds: includedCoachObservationIds,
       contextCharCount: built.context.length,
       ...toolMetadata
     }
@@ -4071,12 +4113,51 @@ export function healthSummary(snapshot, days = 14) {
       nights: recentSleep.length
     },
     bodyWeight: (() => {
-      const recent = (metrics.bodyWeight ?? []).filter((m) => m.date >= cutoff);
-      if (recent.length === 0) return { latest: null, readings: 0 };
+      const profileWeightKg = Number(snapshot.user?.weightKg);
+      const resolvedProfileWeightKg = Number.isFinite(profileWeightKg) && profileWeightKg > 0
+        ? Math.round(profileWeightKg * 10) / 10
+        : null;
+      const rows = (metrics.bodyWeight ?? [])
+        .filter((m) => m?.date && Number.isFinite(Number(m.value ?? m.weight)))
+        .map((m) => ({
+          date: String(m.date).slice(0, 10),
+          value: Number(m.value ?? m.weight)
+        }))
+        .sort((a, b) => a.date.localeCompare(b.date));
+      const recent = rows.filter((m) => m.date >= cutoff);
+      if (recent.length === 0 && resolvedProfileWeightKg != null) {
+        return {
+          latest: { value: resolvedProfileWeightKg, date: null, source: 'profile', stale: false },
+          trend: null,
+          readings: 0,
+          totalReadings: rows.length
+        };
+      }
+      if (recent.length === 0) {
+        const latestKnown = rows.at(-1);
+        if (!latestKnown) return { latest: null, readings: 0, totalReadings: 0 };
+        return {
+          latest: {
+            value: Math.round(latestKnown.value * 10) / 10,
+            date: latestKnown.date,
+            source: 'healthkit',
+            stale: true
+          },
+          trend: null,
+          readings: 0,
+          totalReadings: rows.length
+        };
+      }
       return {
-        latest: { value: Math.round(recent.at(-1).value * 10) / 10, date: recent.at(-1).date },
+        latest: {
+          value: Math.round(recent.at(-1).value * 10) / 10,
+          date: recent.at(-1).date,
+          source: 'healthkit',
+          stale: false
+        },
         trend: Math.round((recent.at(-1).value - recent[0].value) * 10) / 10,
-        readings: recent.length
+        readings: recent.length,
+        totalReadings: rows.length
       };
     })(),
     respiratoryRate: (() => {