incremnt 0.1.0

package/README.md

@@ -0,0 +1,66 @@
+# incremnt
+
+Command-line tool for querying your [incremnt](https://incremnt.app) strength training data.
+
+## Install
+
+```bash
+npm install -g incremnt
+```
+
+## Usage
+
+### Hosted sync (recommended)
+
+After connecting with Apple in the iOS app (Settings > Workout Sync), your workouts sync automatically. To access them from the CLI:
+
+```bash
+incremnt login
+incremnt sessions list --limit 5
+incremnt records
+incremnt records --pretty
+incremnt programs current
+incremnt exercises history --name "Bench Press"
+```
+
+### Local snapshot
+
+If you prefer to work offline, export a snapshot from the app and point the CLI at it:
+
+```bash
+incremnt sessions list --input ~/Downloads/export.onemore.json --limit 5
+incremnt records --input ~/Downloads/export.onemore.json --pretty
+```
+
+If `--input` is omitted, the CLI checks `INCREMNT_SNAPSHOT`, then `ONEMORE_SNAPSHOT`, then common local paths, then the most recent `.onemore.json` in `~/Downloads`.
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `sessions list` | Recent sessions with duration and exercise count |
+| `sessions show --id <id>` | Details for a single session |
+| `programs current` | Active program state |
+| `programs list` | All programs |
+| `exercises history --name <name>` | Set-by-set history for an exercise |
+| `records` | Personal records (best e1RM per exercise) |
+| `login` | Authenticate with the hosted sync service |
+| `logout` | Clear stored session |
+| `status` | Show current mode, auth state, and config paths |
+| `contract` | Machine-readable command surface for scripts |
+
+## Flags
+
+| Flag | Description |
+|------|-------------|
+| `--pretty` | Human-readable formatted output (default is JSON) |
+| `--input <path>` | Path to a local `.onemore.json` snapshot |
+| `--limit <n>` | Limit number of results (for `sessions list`) |
+
+## Exercise matching
+
+`exercises history --name "Bench Press"` uses canonical synonym matching, so it finds `Barbell Bench Press` without pulling in incline, machine, or dumbbell variants.
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "incremnt",
+  "version": "0.1.0",
+  "description": "Command-line tool for querying your incremnt strength training data",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "incremnt": "./src/index.js"
+  },
+  "files": [
+    "src/"
+  ],
+  "scripts": {
+    "test": "node --test",
+    "dev:sync-fixture": "node ./scripts/dev-sync-fixture-server.js"
+  }
+}

package/src/auth.js

@@ -0,0 +1,319 @@
+import fs from 'node:fs/promises';
+import { contractVersion } from './contract.js';
+import { writeSessionState } from './state.js';
+import { readSnapshot } from './local.js';
+import { resolveServiceUrl } from './service-url.js';
+
+export async function importSessionFile(sessionFilePath) {
+  const raw = await fs.readFile(sessionFilePath, 'utf8');
+  const session = JSON.parse(raw);
+  return writeSessionState(session);
+}
+
+export async function bootstrapSessionFromSnapshot(snapshotPath) {
+  await readSnapshot(snapshotPath);
+
+  return writeSessionState({
+    version: 1,
+    mode: 'remote',
+    account: {
+      id: 'bootstrap-user',
+      email: null
+    },
+    auth: {
+      accessToken: 'bootstrap-token',
+      refreshToken: null,
+      expiresAt: '2999-01-01T00:00:00Z'
+    },
+    transport: {
+      fixturePath: snapshotPath
+    }
+  });
+}
+
+export async function bootstrapSessionFromRemoteBaseUrl(baseUrl, token, account = null) {
+  const issuedSession = await issueRemoteSession(baseUrl, token);
+  const remoteContract = await fetchRemoteContract(baseUrl, issuedSession.session.accessToken);
+
+  return writeSessionState({
+    version: 1,
+    mode: 'remote',
+    account: account ?? issuedSession.account ?? {
+      id: 'remote-user',
+      email: null
+    },
+    auth: {
+      accessToken: issuedSession.session.accessToken,
+      refreshToken: null,
+      expiresAt: issuedSession.session.expiresAt
+    },
+    sync: {
+      verifiedAt: new Date().toISOString()
+    },
+    transport: {
+      baseUrl,
+      contractVersion: remoteContract.contractVersion,
+      capabilities: remoteContract.capabilities ?? null
+    }
+  });
+}
+
+export async function bootstrapSessionFromRemoteBaseUrlWithDeviceFlow(baseUrl, {
+  authConfig = null,
+  onChallenge = null,
+  timeoutMs = 60 * 1000
+} = {}) {
+  const challenge = await startDeviceLogin(baseUrl);
+  if (onChallenge) {
+    await onChallenge(challenge, authConfig);
+  }
+
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const result = await pollDeviceLogin(baseUrl, challenge.deviceCode);
+    if (result.status === 'approved') {
+      const remoteContract = await fetchRemoteContract(baseUrl, result.session.accessToken);
+      return writeSessionState({
+        version: 1,
+        mode: 'remote',
+        account: result.account ?? {
+          id: 'remote-user',
+          email: null
+        },
+        auth: {
+          accessToken: result.session.accessToken,
+          refreshToken: null,
+          expiresAt: result.session.expiresAt
+        },
+        sync: {
+          verifiedAt: new Date().toISOString()
+        },
+        transport: {
+          baseUrl,
+          contractVersion: remoteContract.contractVersion,
+          capabilities: remoteContract.capabilities ?? null
+        }
+      });
+    }
+
+    if (result.status !== 'pending') {
+      const error = new Error(result.message ?? 'Unable to complete device login.');
+      error.code = result.code ?? 'REMOTE_AUTH_ERROR';
+      throw error;
+    }
+
+    await delay((result.intervalSeconds ?? challenge.intervalSeconds ?? 1) * 1000);
+  }
+
+  throw new Error('Timed out waiting for device login approval.');
+}
+
+export async function bootstrapSessionFromRemoteBaseUrlWithEmail(baseUrl, email, userId = null) {
+  const devLogin = await issueDevLogin(baseUrl, email, userId);
+  return bootstrapSessionFromRemoteBaseUrl(baseUrl, devLogin.token, devLogin.account);
+}
+
+export async function fetchRemoteAuthConfig(baseUrl) {
+  let response;
+
+  try {
+    const url = resolveServiceUrl(baseUrl, '/auth/config');
+    response = await fetch(url);
+  } catch {
+    return null;
+  }
+
+  if (response.status === 404) {
+    return null;
+  }
+
+  if (!response.ok) {
+    const payload = await response.json().catch(() => ({ error: null }));
+    const error = new Error(payload.error ?? 'Unable to fetch incremnt sync auth config.');
+    error.code = 'REMOTE_AUTH_ERROR';
+    throw error;
+  }
+
+  return response.json();
+}
+
+async function startDeviceLogin(baseUrl) {
+  let response;
+
+  try {
+    const url = resolveServiceUrl(baseUrl, '/auth/device/start');
+    response = await fetch(url, {
+      method: 'POST'
+    });
+  } catch {
+    const error = new Error('Unable to reach incremnt sync service.');
+    error.code = 'REMOTE_HTTP_ERROR';
+    throw error;
+  }
+
+  if (!response.ok) {
+    const payload = await response.json().catch(() => ({ error: null }));
+    const error = new Error(payload.error ?? 'Unable to start device login.');
+    error.code = 'REMOTE_AUTH_ERROR';
+    throw error;
+  }
+
+  return response.json();
+}
+
+async function pollDeviceLogin(baseUrl, deviceCode) {
+  let response;
+
+  try {
+    const url = resolveServiceUrl(baseUrl, '/auth/device/poll');
+    response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json'
+      },
+      body: JSON.stringify({ deviceCode })
+    });
+  } catch {
+    const error = new Error('Unable to reach incremnt sync service.');
+    error.code = 'REMOTE_HTTP_ERROR';
+    throw error;
+  }
+
+  if (response.status === 202) {
+    const payload = await response.json();
+    return {
+      status: 'pending',
+      intervalSeconds: payload.intervalSeconds ?? 1
+    };
+  }
+
+  if (response.status === 410) {
+    return {
+      status: 'failed',
+      code: 'REMOTE_AUTH_EXPIRED',
+      message: 'Device login expired. Run incremnt login again.'
+    };
+  }
+
+  if (!response.ok) {
+    const payload = await response.json().catch(() => ({ error: null }));
+    return {
+      status: 'failed',
+      code: 'REMOTE_AUTH_ERROR',
+      message: payload.error ?? 'Unable to complete device login.'
+    };
+  }
+
+  const payload = await response.json();
+  return {
+    status: 'approved',
+    session: payload.session,
+    account: payload.account
+  };
+}
+
+async function issueRemoteSession(baseUrl, token) {
+  let response;
+
+  try {
+    const url = resolveServiceUrl(baseUrl, '/auth/session');
+    response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${token}`
+      }
+    });
+  } catch {
+    const error = new Error('Unable to reach incremnt sync service.');
+    error.code = 'REMOTE_HTTP_ERROR';
+    throw error;
+  }
+
+  if (response.status === 401 || response.status === 403) {
+    const error = new Error('Authentication failed. Check your token and run incremnt login again.');
+    error.code = 'REMOTE_AUTH_ERROR';
+    throw error;
+  }
+
+  if (!response.ok) {
+    const payload = await response.json().catch(() => ({ error: null }));
+    const error = new Error(payload.error ?? 'Unable to issue a remote session.');
+    error.code = 'REMOTE_AUTH_ERROR';
+    throw error;
+  }
+
+  return response.json();
+}
+
+async function fetchRemoteContract(baseUrl, token) {
+  let response;
+
+  try {
+    const url = resolveServiceUrl(baseUrl, '/cli/contract');
+    response = await fetch(url, {
+      headers: {
+        Authorization: `Bearer ${token}`
+      }
+    });
+  } catch {
+    const error = new Error('Unable to reach incremnt sync service.');
+    error.code = 'REMOTE_HTTP_ERROR';
+    throw error;
+  }
+
+  if (response.status === 401 || response.status === 403) {
+    const error = new Error('Authentication failed. Check your token and run incremnt login again.');
+    error.code = 'REMOTE_AUTH_ERROR';
+    throw error;
+  }
+
+  if (!response.ok) {
+    const error = new Error('Unable to reach incremnt sync service.');
+    error.code = 'REMOTE_HTTP_ERROR';
+    throw error;
+  }
+
+  const payload = await response.json();
+  if (payload.contractVersion !== contractVersion) {
+    const error = new Error(`Remote incremnt sync service is incompatible with this CLI. Expected contract v${contractVersion}, got v${payload.contractVersion}.`);
+    error.code = 'REMOTE_CONTRACT_MISMATCH';
+    throw error;
+  }
+
+  return payload;
+}
+
+async function issueDevLogin(baseUrl, email, userId) {
+  let response;
+
+  try {
+    const url = resolveServiceUrl(baseUrl, '/auth/dev-login');
+    response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json'
+      },
+      body: JSON.stringify({
+        email,
+        userId
+      })
+    });
+  } catch {
+    const error = new Error('Unable to reach incremnt sync service.');
+    error.code = 'REMOTE_HTTP_ERROR';
+    throw error;
+  }
+
+  if (!response.ok) {
+    const payload = await response.json().catch(() => ({ error: null }));
+    const error = new Error(payload.error ?? 'Unable to issue a dev login token.');
+    error.code = 'REMOTE_AUTH_ERROR';
+    throw error;
+  }
+
+  return response.json();
+}
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/contract.js

@@ -0,0 +1,40 @@
+export const contractVersion = 1;
+
+export const capabilities = {
+  readOnly: true,
+  localSnapshots: true,
+  remoteReads: true,
+  remoteAuthShell: true,
+  remoteBootstrap: true
+};
+
+export const officialCommands = [
+  'sessions list',
+  'sessions show --id <session-id>',
+  'sessions compare --session-id <session-id>',
+  'sessions explain --session-id <session-id>',
+  'programs list',
+  'programs current',
+  'exercises history --name <exercise-name>',
+  'records',
+  'status',
+  'contract',
+  'login',
+  'login --base-url <base-url>',
+  'login --snapshot <snapshot-file>',
+  'login --base-url <base-url> --token <token>',
+  'login --base-url <base-url> --email <email>',
+  'login --session-file <session-file>',
+  'logout'
+];
+
+export const readCommands = new Set([
+  'session-insights',
+  'session-show',
+  'exercise-history',
+  'records',
+  'program-list',
+  'program-summary',
+  'planned-vs-actual',
+  'why-did-this-change'
+]);

package/src/format.js

@@ -0,0 +1,72 @@
+const shortMonths = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+const shortDays = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+
+function formatShortDate(dateString) {
+  const date = new Date(dateString);
+  if (Number.isNaN(date.getTime())) {
+    return dateString;
+  }
+
+  return `${date.getDate()} ${shortMonths[date.getMonth()]}`;
+}
+
+function formatDayAndDate(dateString) {
+  const date = new Date(dateString);
+  if (Number.isNaN(date.getTime())) {
+    return dateString;
+  }
+
+  return `${shortDays[date.getDay()]} ${date.getDate()} ${shortMonths[date.getMonth()]}`;
+}
+
+function formatRecords(payload) {
+  if (!Array.isArray(payload) || payload.length === 0) {
+    return 'No records found.';
+  }
+
+  const maxNameLength = Math.max(...payload.map((record) => record.exerciseName.length));
+
+  return payload.map((record) => {
+    const name = record.exerciseName.padEnd(maxNameLength);
+    const date = formatShortDate(record.sessionDate);
+    const isBodyweight = Number(record.weight) === 0;
+
+    if (isBodyweight) {
+      const reps = `${record.reps} reps`.padStart(12);
+      return `${name}  ${reps}  BW \u00b7 ${date}`;
+    }
+
+    const weight = `${Number(record.weight).toFixed(1)} kg`.padStart(12);
+    return `${name}  ${weight}  e1RM \u00b7 ${date}`;
+  }).join('\n');
+}
+
+function formatSessionInsights(payload) {
+  if (!Array.isArray(payload) || payload.length === 0) {
+    return 'No sessions found.';
+  }
+
+  return payload.map((session) => {
+    const date = formatDayAndDate(session.sessionDate);
+    const dayName = session.dayName ?? 'Workout';
+    const exercises = `${session.exerciseCount ?? '?'} exercises`;
+    const duration = session.durationSeconds
+      ? `${Math.round(session.durationSeconds / 60)} min`
+      : '';
+    const suffix = duration ? ` \u00b7 ${exercises} \u00b7 ${duration}` : ` \u00b7 ${exercises}`;
+
+    return `${date}  ${dayName}${suffix}`;
+  }).join('\n');
+}
+
+export function formatPretty(command, payload) {
+  if (command === 'records') {
+    return formatRecords(payload);
+  }
+
+  if (command === 'session-insights') {
+    return formatSessionInsights(payload);
+  }
+
+  return null;
+}

package/src/index.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+
+import { runCli } from './lib.js';
+
+const exitCode = await runCli(process.argv.slice(2), process.stdout, process.stderr);
+process.exit(exitCode);