@drazenbebic/wdid 0.2.0 → 0.3.0

package/README.md

@@ -1,4 +1,17 @@
-# wdid
+<div align="center">
+    <picture>
+        <source
+            srcset="./logos/wdid_logo_white_transparent.png"
+            media="(prefers-color-scheme: dark)"
+            width="820" height="332"
+        />
+        <img
+            src="./logos/wdid_logo_black_transparent.png"
+            alt="What did I do Logo"
+            width="820" height="332"
+        />
+    </picture>
+</div>
 
 > What did I do? — a small CLI that summarizes your git activity as a tidy table, so you can fill in your timesheet without trying to remember Tuesday.
 
@@ -113,6 +126,80 @@ CLI flags always win. The first match in this list is used in full (configs do n
 
 The column header is picked automatically based on the active format. To override it for a specific preset (e.g. call them "Tasks" instead of "Ticket"), set `ticketColumnLabel` in your config.
 
+## Toggl integration
+
+`wdid toggl sync [date]` pushes the day's commits to Toggl as time entries. By default, commits with the same ticket are **collapsed into a single entry** (duration scales with commit count) and commits whose subject matches `\bmerge\b` are skipped. Entries stack from a configurable day-start hour — you adjust the exact times in Toggl yourself. The sync is **idempotent**: each entry's description carries one `(wdid <short-sha>)` marker per included commit, and re-running skips commits already pushed.
+
+Descriptions are condensed for Toggl: the conventional-commit prefix (`feat:`, `chore(ABC-123):`, `fix!:`, etc.) is stripped, and the ticket — if any — is prepended once. So `chore(EN-4435): remove requestBody` becomes `EN-4435: remove requestBody`. Aggregated entries look like `EN-4435: subject A; subject B; subject C`.
+
+```sh
+wdid toggl sync                                      # push today
+wdid toggl sync 2026-05-27                           # push a specific day
+wdid toggl sync today --dry-run                      # preview without pushing
+wdid toggl sync --workspace 12345 today              # override the configured workspace
+wdid toggl sync --from 2026-05-25 --to 2026-05-27    # push a multi-day range (inclusive)
+```
+
+`--from` and `--to` are inclusive and mutually exclusive with the positional `[date]`. Each day is planned independently (its own 09:00 start, its own dedup fetch). On a per-day failure (Toggl 500, missing project, etc.), the sync continues through the remaining days and exits non-zero with a summary so one bad day doesn't strand the rest. The range is capped at 366 days as a guardrail.
+
+### Toggl config
+
+Add these alongside the other config fields:
+
+```json
+{
+  "togglApiToken": "your-api-token",
+  "togglWorkspaceId": 12345,
+  "togglProjects": {
+    "ABC-": 67890,
+    "DEF-": 67891
+  },
+  "togglDefaultProjectId": 99999,
+  "togglDefaultDurationMinutes": 30,
+  "togglDayStartHour": 9,
+  "togglOneEntryPerTicket": true,
+  "togglIgnoreSubjectPattern": "\\bmerge\\b"
+}
+```
+
+| Field                         | Type                     | Description                                                                                                 |
+| ----------------------------- | ------------------------ | ----------------------------------------------------------------------------------------------------------- |
+| `togglApiToken`               | `string`                 | Toggl API token (find it in Toggl → Profile → API Token). Prefer the `TOGGL_API_TOKEN` env var.             |
+| `togglWorkspaceId`            | `number`                 | Numeric Toggl workspace ID. Required to push.                                                               |
+| `togglProjects`               | `Record<string, number>` | Map of ticket-prefix → project ID. Longest matching prefix wins.                                            |
+| `togglDefaultProjectId`       | `number`                 | Project ID for commits that don't match any prefix (or have no ticket).                                     |
+| `togglDefaultDurationMinutes` | `number`                 | Per-commit duration. Default `30`. In per-ticket mode, an entry's total duration is `count × this`.         |
+| `togglDayStartHour`           | `number` (0–23)          | Hour to start stacking entries at. Default `9` (09:00).                                                     |
+| `togglOneEntryPerTicket`      | `boolean`                | When `true` (default), commits sharing a ticket collapse into one entry. Commits without a ticket stay 1:1. |
+| `togglIgnoreSubjectPattern`   | `string` (regex)         | Subjects matching this pattern (case-insensitive) are skipped. Default `\bmerge\b`. Set to `""` to disable. |
+
+### Auth
+
+The API token is resolved in this order: `TOGGL_API_TOKEN` env var > `togglApiToken` in config. The env var path is preferred so you don't have to commit (or remember not to commit) the token.
+
+## Managing config
+
+`wdid config` provides four subcommands for the **global** config (`~/.config/wdid/config.json` — honors `XDG_CONFIG_HOME`). Repo-level configs are read but not written by these commands; edit them by hand.
+
+```sh
+wdid config set togglApiToken tok_…                # set a scalar field
+wdid config set togglWorkspaceId 12345             # numbers are parsed
+wdid config set togglOneEntryPerTicket false       # booleans take "true"/"false"
+wdid config set togglProjects.ABC- 67890           # set a nested record entry
+wdid config get togglApiToken                      # secrets are masked
+wdid config get togglApiToken --show-secrets       # …unless --show-secrets
+wdid config list                                   # all set fields, aligned, secrets masked
+wdid config list --show-secrets                    # reveal secrets
+wdid config path                                   # absolute path to the config file
+```
+
+Notes:
+
+- **Validation runs at `set` time** — `wdid config set togglDayStartHour 99` fails immediately with the schema error, the file is never touched.
+- **Secrets are masked** in `list` / `get` output (`tok_…wa9e0d` style) unless `--show-secrets` is set.
+- **`defaultRepos` is not settable from the CLI** (it's an array). Same for any future array-shaped field. Use `vim $(wdid config path)` to edit those.
+- **To remove a key**, edit the file directly — `unset` isn't included in this slice.
+
 ## Development
 
 This project uses [pnpm](https://pnpm.io) (see the `packageManager` field in `package.json`).

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 import { Command } from "commander";
 
 // src/git.ts
@@ -102,30 +102,31 @@ async function assertGitRepo(cwd) {
     );
   }
 }
+var GIT_USER_NAME_HINT = 'could not read git user.name \u2014 set it with `git config user.name "Your Name"` or pass --author';
 async function getGitUserName(cwd) {
+  let stdout;
   try {
-    const { stdout } = await execFileAsync("git", ["config", "user.name"], {
+    const result = await execFileAsync("git", ["config", "user.name"], {
       cwd
     });
-    const name = stdout.trim();
-    if (!name) {
-      throw new Error("empty");
-    }
-    return name;
+    stdout = result.stdout;
   } catch (err) {
     if (err.code === "ENOENT") {
       throw new Error("git is not installed or not on PATH", { cause: err });
     }
-    throw new Error(
-      'could not read git user.name \u2014 set it with `git config user.name "Your Name"` or pass --author',
-      { cause: err }
-    );
+    throw new Error(GIT_USER_NAME_HINT, { cause: err });
+  }
+  const name = stdout.trim();
+  if (!name) {
+    throw new Error(GIT_USER_NAME_HINT);
   }
+  return name;
 }
 async function getCommits(opts) {
   await assertGitRepo(opts.cwd);
   const args = [
     "log",
+    "--exclude=refs/stash",
     "--all",
     "--author-date-order",
     "--regexp-ignore-case",
@@ -171,6 +172,7 @@ async function getCommits(opts) {
     parsed.map((p) => p.sha).filter((s) => s.length > 0)
   );
   return parsed.map((p) => ({
+    sha: p.sha,
     date: p.date,
     time: p.time,
     ticket: p.ticket,
@@ -251,6 +253,7 @@ function toJsonKey(label) {
 function renderJson(entries, ticketColumnLabel = "Ticket") {
   const key = toJsonKey(ticketColumnLabel);
   const transformed = entries.map((e) => ({
+    sha: e.sha,
     date: e.date,
     time: e.time,
     [key]: e.ticket,
@@ -271,6 +274,12 @@ import { homedir } from "os";
 import { readFile } from "fs/promises";
 import { join } from "path";
 import { cosmiconfig } from "cosmiconfig";
+var TOGGL_DEFAULTS = {
+  durationMinutes: 30,
+  dayStartHour: 9,
+  oneEntryPerTicket: true,
+  ignoreSubjectPattern: "\\bmerge\\b"
+};
 var DEFAULT_COLUMN_LABELS = {
   jira: "Ticket",
   github: "Issue",
@@ -371,6 +380,71 @@ function validateConfig(raw) {
     }
     cfg.ticketColumnLabel = obj.ticketColumnLabel;
   }
+  if ("togglApiToken" in obj) {
+    if (typeof obj.togglApiToken !== "string") {
+      throw new Error("togglApiToken must be a string");
+    }
+    cfg.togglApiToken = obj.togglApiToken;
+  }
+  if ("togglWorkspaceId" in obj) {
+    if (typeof obj.togglWorkspaceId !== "number" || !Number.isInteger(obj.togglWorkspaceId) || obj.togglWorkspaceId < 1) {
+      throw new Error("togglWorkspaceId must be a positive integer");
+    }
+    cfg.togglWorkspaceId = obj.togglWorkspaceId;
+  }
+  if ("togglProjects" in obj) {
+    const raw2 = obj.togglProjects;
+    if (typeof raw2 !== "object" || raw2 === null || Array.isArray(raw2)) {
+      throw new Error(
+        "togglProjects must be an object mapping ticket prefix \u2192 project ID"
+      );
+    }
+    const map = {};
+    for (const [prefix, projectId] of Object.entries(raw2)) {
+      if (typeof projectId !== "number" || !Number.isInteger(projectId) || projectId < 1) {
+        throw new Error(
+          `togglProjects["${prefix}"] must be a positive integer`
+        );
+      }
+      map[prefix] = projectId;
+    }
+    cfg.togglProjects = map;
+  }
+  if ("togglDefaultProjectId" in obj) {
+    if (typeof obj.togglDefaultProjectId !== "number" || !Number.isInteger(obj.togglDefaultProjectId) || obj.togglDefaultProjectId < 1) {
+      throw new Error("togglDefaultProjectId must be a positive integer");
+    }
+    cfg.togglDefaultProjectId = obj.togglDefaultProjectId;
+  }
+  if ("togglDefaultDurationMinutes" in obj) {
+    if (typeof obj.togglDefaultDurationMinutes !== "number" || !Number.isInteger(obj.togglDefaultDurationMinutes) || obj.togglDefaultDurationMinutes < 1) {
+      throw new Error("togglDefaultDurationMinutes must be a positive integer");
+    }
+    cfg.togglDefaultDurationMinutes = obj.togglDefaultDurationMinutes;
+  }
+  if ("togglDayStartHour" in obj) {
+    if (typeof obj.togglDayStartHour !== "number" || !Number.isInteger(obj.togglDayStartHour) || obj.togglDayStartHour < 0 || obj.togglDayStartHour > 23) {
+      throw new Error("togglDayStartHour must be an integer between 0 and 23");
+    }
+    cfg.togglDayStartHour = obj.togglDayStartHour;
+  }
+  if ("togglOneEntryPerTicket" in obj) {
+    if (typeof obj.togglOneEntryPerTicket !== "boolean") {
+      throw new Error("togglOneEntryPerTicket must be a boolean");
+    }
+    cfg.togglOneEntryPerTicket = obj.togglOneEntryPerTicket;
+  }
+  if ("togglIgnoreSubjectPattern" in obj) {
+    if (typeof obj.togglIgnoreSubjectPattern !== "string") {
+      throw new Error("togglIgnoreSubjectPattern must be a string");
+    }
+    if (obj.togglIgnoreSubjectPattern.length > MAX_CUSTOM_PATTERN_LENGTH) {
+      throw new Error(
+        `togglIgnoreSubjectPattern is ${obj.togglIgnoreSubjectPattern.length} characters; limit is ${MAX_CUSTOM_PATTERN_LENGTH}`
+      );
+    }
+    cfg.togglIgnoreSubjectPattern = obj.togglIgnoreSubjectPattern;
+  }
   return cfg;
 }
 function globalConfigPath() {
@@ -401,6 +475,477 @@ async function loadConfig(cwd) {
   return {};
 }
 
+// src/integrations/toggl.ts
+var TOGGL_API_BASE = "https://api.track.toggl.com/api/v9";
+function shortenSha(sha) {
+  return sha.slice(0, 7);
+}
+function findProjectId(ticket, projects, defaultProjectId) {
+  if (!ticket) {
+    return { projectId: defaultProjectId ?? null, matchedPrefix: null };
+  }
+  const prefixes = Object.keys(projects).sort((a, b) => b.length - a.length);
+  for (const prefix of prefixes) {
+    if (ticket.startsWith(prefix)) {
+      return { projectId: projects[prefix] ?? null, matchedPrefix: prefix };
+    }
+  }
+  return { projectId: defaultProjectId ?? null, matchedPrefix: null };
+}
+var SHA_MARKER_GLOBAL = /\(wdid ([0-9a-f]{7})\)/g;
+function extractSyncedShasFromDescription(description) {
+  const shas = [];
+  for (const match of description.matchAll(SHA_MARKER_GLOBAL)) {
+    if (match[1]) {
+      shas.push(match[1]);
+    }
+  }
+  return shas;
+}
+function groupKey(commit, oneEntryPerTicket) {
+  if (oneEntryPerTicket && commit.ticket) {
+    return `ticket:${commit.ticket}`;
+  }
+  return `sha:${commit.sha}`;
+}
+function buildMarker(shortShas) {
+  return shortShas.map((s) => `(wdid ${s})`).join(" ");
+}
+var CONVENTIONAL_PREFIX = /^\w+(\([^)]+\))?!?:\s*/;
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function cleanSubjectForToggl(rawSubject, ticket) {
+  let cleaned = rawSubject.replace(CONVENTIONAL_PREFIX, "");
+  if (ticket) {
+    const leadingTicket = new RegExp(`^${escapeRegExp(ticket)}[:\\s]+`);
+    cleaned = cleaned.replace(leadingTicket, "");
+  }
+  return cleaned.trim();
+}
+function planEntries(commits, options) {
+  const filtered = options.ignoreSubjectPattern ? commits.filter((c) => !options.ignoreSubjectPattern.test(c.description)) : commits;
+  const sorted = [...filtered].sort(
+    (a, b) => `${a.date} ${a.time}`.localeCompare(`${b.date} ${b.time}`)
+  );
+  const groups = /* @__PURE__ */ new Map();
+  for (const commit of sorted) {
+    const key = groupKey(commit, options.oneEntryPerTicket);
+    const existing = groups.get(key);
+    if (existing) {
+      existing.push(commit);
+    } else {
+      groups.set(key, [commit]);
+    }
+  }
+  const defaultDurationSeconds = options.defaultDurationMinutes * 60;
+  const dayStart = /* @__PURE__ */ new Date(
+    `${options.date}T${String(options.dayStartHour).padStart(2, "0")}:00:00`
+  );
+  let cursor = dayStart.getTime();
+  const plans = [];
+  for (const groupCommits of groups.values()) {
+    const first = groupCommits[0];
+    const ticket = first.ticket;
+    const shas = groupCommits.map((c) => c.sha);
+    const shortShas = shas.map(shortenSha);
+    const cleanedSubjects = groupCommits.map((c) => cleanSubjectForToggl(c.description, ticket)).filter((s) => s.length > 0);
+    const joined = cleanedSubjects.join("; ");
+    const marker = buildMarker(shortShas);
+    const body = ticket ? joined.length > 0 ? `${ticket}: ${joined}` : ticket : joined;
+    const description = `${body} ${marker}`.trim();
+    const durationSeconds = defaultDurationSeconds * groupCommits.length;
+    const { projectId, matchedPrefix } = findProjectId(
+      ticket,
+      options.projects,
+      options.defaultProjectId
+    );
+    const alreadySynced = shortShas.every(
+      (s) => options.existingSyncedShas.has(s)
+    );
+    plans.push({
+      shas,
+      shortShas,
+      description,
+      start: new Date(cursor).toISOString(),
+      durationSeconds,
+      projectId,
+      matchedTicketPrefix: matchedPrefix,
+      ticket,
+      commitCount: groupCommits.length,
+      alreadySynced
+    });
+    cursor += durationSeconds * 1e3;
+  }
+  return plans;
+}
+function basicAuth(token) {
+  return `Basic ${Buffer.from(`${token}:api_token`).toString("base64")}`;
+}
+function nextDay(date) {
+  const d = /* @__PURE__ */ new Date(`${date}T00:00:00Z`);
+  d.setUTCDate(d.getUTCDate() + 1);
+  return d.toISOString().slice(0, 10);
+}
+var MAX_SYNC_RANGE_DAYS = 366;
+function enumerateDates(from, to) {
+  const start = /* @__PURE__ */ new Date(`${from}T00:00:00Z`);
+  const end = /* @__PURE__ */ new Date(`${to}T00:00:00Z`);
+  if (Number.isNaN(start.getTime()) || Number.isNaN(end.getTime())) {
+    throw new Error(`invalid date range "${from}" \u2192 "${to}"`);
+  }
+  if (end < start) {
+    throw new Error(`--to (${to}) must be on or after --from (${from})`);
+  }
+  const days = Math.round((end.getTime() - start.getTime()) / 864e5) + 1;
+  if (days > MAX_SYNC_RANGE_DAYS) {
+    throw new Error(
+      `date range is ${days} days; limit is ${MAX_SYNC_RANGE_DAYS}`
+    );
+  }
+  const result = [];
+  for (const d = new Date(start); d <= end; d.setUTCDate(d.getUTCDate() + 1)) {
+    result.push(d.toISOString().slice(0, 10));
+  }
+  return result;
+}
+async function fetchSyncedShas(auth, date) {
+  const url = `${TOGGL_API_BASE}/me/time_entries?start_date=${date}&end_date=${nextDay(date)}`;
+  const response = await fetch(url, {
+    headers: { Authorization: basicAuth(auth.apiToken) }
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Toggl fetch failed: ${response.status} ${response.statusText}`
+    );
+  }
+  const entries = await response.json();
+  const shas = /* @__PURE__ */ new Set();
+  for (const e of entries) {
+    for (const sha of extractSyncedShasFromDescription(e.description ?? "")) {
+      shas.add(sha);
+    }
+  }
+  return shas;
+}
+async function pushEntries(auth, workspaceId, plan) {
+  const result = { pushed: 0, skipped: 0, failures: [] };
+  for (const entry of plan) {
+    if (entry.alreadySynced) {
+      result.skipped++;
+      continue;
+    }
+    const response = await fetch(
+      `${TOGGL_API_BASE}/workspaces/${workspaceId}/time_entries`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: basicAuth(auth.apiToken)
+        },
+        body: JSON.stringify({
+          description: entry.description,
+          start: entry.start,
+          duration: entry.durationSeconds,
+          workspace_id: workspaceId,
+          project_id: entry.projectId,
+          created_with: "wdid"
+        })
+      }
+    );
+    if (!response.ok) {
+      const body = await response.text();
+      result.failures.push({
+        plan: entry,
+        reason: `${response.status} ${response.statusText} \u2014 ${body.slice(0, 200)}`
+      });
+      continue;
+    }
+    result.pushed++;
+  }
+  return result;
+}
+
+// src/config-cli.ts
+import { mkdir, readFile as readFile2, writeFile } from "fs/promises";
+import { dirname } from "path";
+import Table2 from "cli-table3";
+import chalk2 from "chalk";
+var FIELDS = {
+  format: {
+    type: "enum",
+    values: ["jira", "github", "conventional", "custom"],
+    default: "jira",
+    description: "Ticket extraction preset."
+  },
+  customPattern: {
+    type: "string",
+    description: 'Regex for ticket extraction when format is "custom".'
+  },
+  defaultAuthor: {
+    type: "string",
+    description: "Default author for git log; falls back to git config user.name."
+  },
+  defaultRepos: {
+    type: "string-array",
+    settable: false,
+    description: "Repo paths to query when --repo is not given. (~) is expanded."
+  },
+  ticketColumnLabel: {
+    type: "string",
+    description: "Override the auto-picked Ticket column header."
+  },
+  togglApiToken: {
+    type: "string",
+    secret: true,
+    description: "Toggl API token. Prefer the TOGGL_API_TOKEN env var."
+  },
+  togglWorkspaceId: {
+    type: "number",
+    description: "Numeric Toggl workspace ID. Required to push."
+  },
+  togglProjects: {
+    type: "number-record",
+    nested: true,
+    description: "Map of ticket-prefix \u2192 Toggl project ID. Longest prefix wins."
+  },
+  togglDefaultProjectId: {
+    type: "number",
+    description: "Project ID for commits without a prefix match."
+  },
+  togglDefaultDurationMinutes: {
+    type: "number",
+    default: 30,
+    description: "Per-commit duration. Total = count \xD7 this in per-ticket mode."
+  },
+  togglDayStartHour: {
+    type: "number",
+    default: 9,
+    description: "Hour (0\u201323) to start stacking entries at."
+  },
+  togglOneEntryPerTicket: {
+    type: "boolean",
+    default: true,
+    description: "Collapse same-ticket commits into one entry. No-ticket commits stay 1:1."
+  },
+  togglIgnoreSubjectPattern: {
+    type: "string",
+    default: "\\bmerge\\b",
+    description: 'Subjects matching this regex (case-insensitive) are skipped. "" to disable.'
+  }
+};
+function parseKey(rawKey) {
+  const dotIndex = rawKey.indexOf(".");
+  const field = dotIndex === -1 ? rawKey : rawKey.slice(0, dotIndex);
+  const subKey = dotIndex === -1 ? void 0 : rawKey.slice(dotIndex + 1);
+  const spec = FIELDS[field];
+  if (!spec) {
+    throw new Error(
+      `unknown config key "${field}". Known keys: ${Object.keys(FIELDS).join(", ")}`
+    );
+  }
+  if (subKey !== void 0 && !spec.nested) {
+    throw new Error(
+      `config key "${field}" does not support dotted access (it is a ${spec.type})`
+    );
+  }
+  if (subKey === "") {
+    throw new Error(`empty sub-key in "${rawKey}"`);
+  }
+  return { field, subKey };
+}
+function parseValue(field, rawValue) {
+  const spec = FIELDS[field];
+  if (!spec) {
+    throw new Error(`unknown config key "${field}"`);
+  }
+  if (spec.settable === false) {
+    throw new Error(
+      `"${field}" cannot be set from the CLI \u2014 edit the config file directly`
+    );
+  }
+  switch (spec.type) {
+    case "string":
+      return rawValue;
+    case "enum":
+      if (!spec.values?.includes(rawValue)) {
+        throw new Error(
+          `"${rawValue}" is not a valid value for "${field}" \u2014 must be one of ${spec.values?.join(", ")}`
+        );
+      }
+      return rawValue;
+    case "number":
+    case "number-record": {
+      const n = Number(rawValue);
+      if (!Number.isFinite(n)) {
+        throw new Error(`"${rawValue}" is not a valid number for "${field}"`);
+      }
+      return n;
+    }
+    case "boolean":
+      if (rawValue === "true") {
+        return true;
+      }
+      if (rawValue === "false") {
+        return false;
+      }
+      throw new Error(
+        `"${rawValue}" is not a valid boolean for "${field}" \u2014 use "true" or "false"`
+      );
+    case "string-array":
+      throw new Error(`"${field}" is an array \u2014 edit the config file directly`);
+    default:
+      throw new Error(`internal: unhandled field type for "${field}"`);
+  }
+}
+function setConfigValue(cfg, rawKey, rawValue) {
+  const { field, subKey } = parseKey(rawKey);
+  const next = { ...cfg };
+  if (subKey !== void 0) {
+    const spec = FIELDS[field];
+    if (spec.type !== "number-record") {
+      throw new Error(
+        `internal: nested set requested for non-record field "${field}"`
+      );
+    }
+    const parsed = parseValue(field, rawValue);
+    const current = cfg[field] ?? {};
+    next[field] = {
+      ...current,
+      [subKey]: parsed
+    };
+  } else {
+    next[field] = parseValue(field, rawValue);
+  }
+  return validateConfig(next);
+}
+function getConfigValue(cfg, rawKey) {
+  const { field, subKey } = parseKey(rawKey);
+  const value = cfg[field];
+  if (subKey === void 0) {
+    return value;
+  }
+  if (typeof value !== "object" || value === null) {
+    return void 0;
+  }
+  return value[subKey];
+}
+function maskSecret(value) {
+  if (value.length <= 10) {
+    return "***";
+  }
+  return `${value.slice(0, 4)}\u2026${value.slice(-6)}`;
+}
+function formatValue(value, secret, reveal) {
+  if (value === void 0) {
+    return "(not set)";
+  }
+  if (secret && !reveal && typeof value === "string") {
+    return maskSecret(value);
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  return JSON.stringify(value);
+}
+function renderConfigList(cfg, options = {}) {
+  const reveal = options.showSecrets ?? false;
+  const keys = Object.keys(cfg);
+  const presentKeys = keys.filter((k) => cfg[k] !== void 0);
+  if (presentKeys.length === 0) {
+    return chalk2.gray("(no values set)");
+  }
+  const table = new Table2({
+    head: [chalk2.bold.cyan("Key"), chalk2.bold.cyan("Value")],
+    style: { head: [], border: [] },
+    wordWrap: true,
+    colWidths: [32, 60]
+  });
+  for (const k of presentKeys) {
+    const spec = FIELDS[k];
+    const secret = spec?.secret ?? false;
+    const formatted = formatValue(cfg[k], secret, reveal);
+    const valueCell = secret && !reveal ? chalk2.dim(formatted) : formatted;
+    table.push([chalk2.cyan(k), valueCell]);
+  }
+  return table.toString();
+}
+function formatFieldType(spec) {
+  switch (spec.type) {
+    case "enum":
+      return `enum (${(spec.values ?? []).join(" | ")})`;
+    case "string-array":
+      return "string[]";
+    case "number-record":
+      return "Record<string, number>";
+    default:
+      return spec.type;
+  }
+}
+function formatFieldNotes(spec) {
+  const tags = [];
+  if (spec.secret) {
+    tags.push("secret");
+  }
+  if (spec.nested) {
+    tags.push("nested");
+  }
+  if (spec.settable === false) {
+    tags.push("edit file directly");
+  }
+  return tags.length > 0 ? tags.join(", ") : "";
+}
+function formatFieldDefault(spec) {
+  if (spec.default === void 0) {
+    return "";
+  }
+  return typeof spec.default === "string" ? spec.default : JSON.stringify(spec.default);
+}
+function renderConfigKeys() {
+  const table = new Table2({
+    head: [
+      chalk2.bold.cyan("Key"),
+      chalk2.bold.cyan("Type"),
+      chalk2.bold.cyan("Default"),
+      chalk2.bold.cyan("Notes"),
+      chalk2.bold.cyan("Description")
+    ],
+    style: { head: [], border: [] },
+    wordWrap: true,
+    colWidths: [30, 26, 16, 22, 48]
+  });
+  for (const [key, spec] of Object.entries(FIELDS)) {
+    table.push([
+      chalk2.cyan(key),
+      formatFieldType(spec),
+      chalk2.dim(formatFieldDefault(spec)),
+      chalk2.yellow(formatFieldNotes(spec)),
+      chalk2.dim(spec.description ?? "")
+    ]);
+  }
+  return table.toString();
+}
+function renderSingleValue(value, field, reveal) {
+  const spec = FIELDS[field];
+  return formatValue(value, spec?.secret ?? false, reveal);
+}
+async function readGlobalConfig() {
+  try {
+    const content = await readFile2(globalConfigPath(), "utf-8");
+    return validateConfig(JSON.parse(content));
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return {};
+    }
+    throw err;
+  }
+}
+async function writeGlobalConfig(cfg) {
+  const path = globalConfigPath();
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
+}
+
 // src/index.ts
 function parseLimit(raw) {
   if (raw === void 0) {
@@ -490,8 +1035,195 @@ async function run(dateArg, options) {
   const rendered = options.groupByDay ? renderTableGroupedByDay(display, ticketColumnLabel) : renderTable(display, ticketColumnLabel);
   process.stdout.write(rendered + "\n");
 }
+function resolveTogglSyncDates(dateArg, options) {
+  if (dateArg && (options.from || options.to)) {
+    throw new Error(
+      "cannot combine the positional [date] with --from / --to \u2014 use one or the other"
+    );
+  }
+  if (options.from || options.to) {
+    if (!options.from || !options.to) {
+      throw new Error("--from and --to must both be provided");
+    }
+    return enumerateDates(resolveDate(options.from), resolveDate(options.to));
+  }
+  return [resolveDate(dateArg ?? "today")];
+}
+function resolveTogglAuth(config) {
+  const token = process.env.TOGGL_API_TOKEN ?? config.togglApiToken;
+  if (!token) {
+    return null;
+  }
+  return { apiToken: token };
+}
+function formatHHMM(iso) {
+  const d = new Date(iso);
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+function renderTogglPlan(plan, date) {
+  const newCount = plan.filter((p) => !p.alreadySynced).length;
+  const skipCount = plan.length - newCount;
+  const lines = [];
+  lines.push(
+    chalk3.bold(`Toggl sync \u2014 ${date}`) + chalk3.dim(
+      `  (${newCount} new, ${skipCount} already synced, ${plan.length} total)`
+    )
+  );
+  lines.push("");
+  for (const entry of plan) {
+    const start = formatHHMM(entry.start);
+    const endIso = new Date(
+      new Date(entry.start).getTime() + entry.durationSeconds * 1e3
+    ).toISOString();
+    const end = formatHHMM(endIso);
+    const status = entry.alreadySynced ? chalk3.gray("skip") : chalk3.green("new ");
+    const project = entry.projectId === null ? chalk3.yellow("(no project)") : chalk3.cyan(
+      `[project ${entry.projectId}${entry.matchedTicketPrefix ? ` \u2190 ${entry.matchedTicketPrefix}` : " (default)"}]`
+    );
+    const commitNote = entry.commitCount > 1 ? chalk3.dim(` (${entry.commitCount} commits)`) : "";
+    lines.push(
+      `  ${status}  ${chalk3.dim(`${start}\u2013${end}`)}  ${entry.description}  ${project}${commitNote}`
+    );
+  }
+  return lines.join("\n");
+}
+async function syncOneDay(date, ctx) {
+  const result = {
+    date,
+    planned: 0,
+    pushed: 0,
+    skipped: 0,
+    failures: 0
+  };
+  try {
+    const perRepoCommits = await Promise.all(
+      ctx.repos.map(async (cwd) => {
+        const author = ctx.cliAuthor ?? ctx.configAuthor ?? await getGitUserName(cwd);
+        return getCommits({
+          author,
+          from: date,
+          to: date,
+          cwd,
+          pattern: ctx.pattern
+        });
+      })
+    );
+    const commits = perRepoCommits.flat();
+    const existingSyncedShas = ctx.auth ? await fetchSyncedShas(ctx.auth, date) : /* @__PURE__ */ new Set();
+    const plan = planEntries(commits, {
+      date,
+      defaultDurationMinutes: ctx.defaultDurationMinutes,
+      dayStartHour: ctx.dayStartHour,
+      projects: ctx.projects,
+      defaultProjectId: ctx.defaultProjectId,
+      existingSyncedShas,
+      oneEntryPerTicket: ctx.oneEntryPerTicket,
+      ignoreSubjectPattern: ctx.ignoreSubjectPattern
+    });
+    result.planned = plan.length;
+    if (plan.length === 0) {
+      process.stdout.write(
+        chalk3.gray(`No commits to sync for ${date}.`) + "\n"
+      );
+      return result;
+    }
+    process.stdout.write(renderTogglPlan(plan, date) + "\n");
+    if (ctx.dryRun) {
+      return result;
+    }
+    if (!ctx.auth || ctx.workspaceId === null) {
+      throw new Error("internal: auth/workspaceId resolved to null");
+    }
+    const pushResult = await pushEntries(ctx.auth, ctx.workspaceId, plan);
+    result.pushed = pushResult.pushed;
+    result.skipped = pushResult.skipped;
+    result.failures = pushResult.failures.length;
+    process.stdout.write(
+      "\n" + chalk3.bold(
+        `  ${date}: pushed ${pushResult.pushed}, skipped ${pushResult.skipped}`
+      ) + (pushResult.failures.length > 0 ? chalk3.red(`, ${pushResult.failures.length} failed`) : "") + "\n"
+    );
+    for (const failure of pushResult.failures) {
+      process.stderr.write(
+        chalk3.red(
+          `  ${date} failed: ${failure.plan.shortShas.join(",")} \u2014 ${failure.reason}`
+        ) + "\n"
+      );
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    result.error = message;
+    process.stderr.write(chalk3.red(`  ${date}: ${message}`) + "\n");
+  }
+  return result;
+}
+async function runTogglSync(dateArg, options) {
+  const config = await loadConfig(process.cwd());
+  const dates = resolveTogglSyncDates(dateArg, options);
+  const workspaceId = (options.workspace ? Number.parseInt(options.workspace, 10) : config.togglWorkspaceId) ?? null;
+  if (!options.dryRun && workspaceId === null) {
+    throw new Error(
+      "togglWorkspaceId is not set \u2014 add it to your config or pass --workspace <id>"
+    );
+  }
+  const auth = resolveTogglAuth(config);
+  if (!options.dryRun && !auth) {
+    throw new Error(
+      "no Toggl API token \u2014 set TOGGL_API_TOKEN or `togglApiToken` in your config"
+    );
+  }
+  const format = config.format ?? "jira";
+  const pattern = getTicketPattern(format, config.customPattern);
+  const configRepos = config.defaultRepos?.map(expandPath) ?? [];
+  const repos = options.repo && options.repo.length > 0 ? options.repo : configRepos.length > 0 ? configRepos : [process.cwd()];
+  const defaultDurationMinutes = config.togglDefaultDurationMinutes ?? TOGGL_DEFAULTS.durationMinutes;
+  const dayStartHour = config.togglDayStartHour ?? TOGGL_DEFAULTS.dayStartHour;
+  const oneEntryPerTicket = config.togglOneEntryPerTicket ?? TOGGL_DEFAULTS.oneEntryPerTicket;
+  const ignoreSubjectSource = config.togglIgnoreSubjectPattern ?? TOGGL_DEFAULTS.ignoreSubjectPattern;
+  const ignoreSubjectPattern = ignoreSubjectSource ? new RegExp(ignoreSubjectSource, "i") : void 0;
+  const ctx = {
+    auth,
+    workspaceId,
+    dryRun: options.dryRun ?? false,
+    repos,
+    cliAuthor: options.author,
+    configAuthor: config.defaultAuthor,
+    pattern,
+    defaultDurationMinutes,
+    dayStartHour,
+    oneEntryPerTicket,
+    ignoreSubjectPattern,
+    projects: config.togglProjects ?? {},
+    defaultProjectId: config.togglDefaultProjectId
+  };
+  const results = [];
+  for (const date of dates) {
+    results.push(await syncOneDay(date, ctx));
+  }
+  if (options.dryRun) {
+    process.stdout.write("\n" + chalk3.dim("(dry-run \u2014 nothing pushed)") + "\n");
+    return;
+  }
+  if (dates.length > 1) {
+    const totalPushed = results.reduce((n, r) => n + r.pushed, 0);
+    const totalSkipped = results.reduce((n, r) => n + r.skipped, 0);
+    const totalFailures = results.reduce((n, r) => n + r.failures, 0);
+    const erroredDays = results.filter((r) => r.error !== void 0).length;
+    process.stdout.write(
+      "\n" + chalk3.bold(
+        `Total across ${dates.length} days: pushed ${totalPushed}, skipped ${totalSkipped}`
+      ) + (totalFailures > 0 ? chalk3.red(`, ${totalFailures} failed`) : "") + (erroredDays > 0 ? chalk3.red(`, ${erroredDays} day(s) errored`) : "") + "\n"
+    );
+  }
+  const anyFailed = results.some((r) => r.error !== void 0 || r.failures > 0);
+  if (anyFailed) {
+    process.exitCode = 1;
+  }
+}
 var program = new Command();
-program.name("wdid").description("What did I do? \u2014 summarize your git commits as a table").version("0.2.0", "-V, --version", "output the version number").argument("[date]", 'a YYYY-MM-DD date or "today"; omit to show all history').option("--from <date>", 'start date (YYYY-MM-DD or "today")').option("--to <date>", 'end date (YYYY-MM-DD or "today")').option(
+program.enablePositionalOptions();
+program.name("wdid").description("What did I do? \u2014 summarize your git commits as a table").version("0.3.0", "-V, --version", "output the version number").argument("[date]", 'a YYYY-MM-DD date or "today"; omit to show all history').option("--from <date>", 'start date (YYYY-MM-DD or "today")').option("--to <date>", 'end date (YYYY-MM-DD or "today")').option(
   "--author <name>",
   "override the git author (defaults to git config user.name, then defaultAuthor in config)"
 ).option(
@@ -514,7 +1246,7 @@ program.name("wdid").description("What did I do? \u2014 summarize your git commi
   "group rows under a bold date heading per day (time-only in row)"
 ).option("--json", "emit a JSON array of commit entries instead of the table").action(async (dateArg, options) => {
   if (shouldDisableColor(options)) {
-    chalk2.level = 0;
+    chalk3.level = 0;
   }
   try {
     await run(dateArg, options);
@@ -524,4 +1256,103 @@ program.name("wdid").description("What did I do? \u2014 summarize your git commi
     process.exitCode = 1;
   }
 });
+var togglCmd = program.command("toggl").description("Toggl integration commands");
+togglCmd.command("sync [date]").description(
+  "push the day's commits as Toggl time entries. Default: today. Pass --from/--to for a range."
+).option("--dry-run", "preview the plan without pushing").option(
+  "--workspace <id>",
+  "override the configured togglWorkspaceId for this run"
+).option(
+  "--repo <path...>",
+  "one or more repo paths to query (overrides defaultRepos in config)"
+).option(
+  "--author <name>",
+  "override the git author (defaults to git config user.name, then defaultAuthor in config)"
+).option(
+  "--from <date>",
+  "start of a multi-day range (inclusive). Use with --to. Mutually exclusive with [date]."
+).option(
+  "--to <date>",
+  "end of a multi-day range (inclusive). Use with --from. Mutually exclusive with [date]."
+).action(async (dateArg, options) => {
+  try {
+    await runTogglSync(dateArg, options);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(renderError(message) + "\n");
+    process.exitCode = 1;
+  }
+});
+async function runConfigSet(key, value) {
+  const current = await readGlobalConfig();
+  const next = setConfigValue(current, key, value);
+  await writeGlobalConfig(next);
+  const { field } = parseKey(key);
+  const isSecret = FIELDS[field]?.secret ?? false;
+  process.stdout.write(
+    chalk3.green(`set ${key}`) + (isSecret ? chalk3.dim(" (secret \u2014 value hidden)") : "") + "\n"
+  );
+}
+async function runConfigGet(key, options) {
+  const cfg = await readGlobalConfig();
+  const value = getConfigValue(cfg, key);
+  const { field } = parseKey(key);
+  process.stdout.write(
+    renderSingleValue(value, field, options.showSecrets ?? false) + "\n"
+  );
+  if (value === void 0) {
+    process.exitCode = 1;
+  }
+}
+async function runConfigList(options) {
+  const cfg = await readGlobalConfig();
+  process.stdout.write(
+    renderConfigList(cfg, { showSecrets: options.showSecrets }) + "\n"
+  );
+}
+function runConfigPath() {
+  process.stdout.write(globalConfigPath() + "\n");
+}
+var configCmd = program.command("config").description("Read and write the global wdid config file");
+configCmd.command("set <key> <value>").description(
+  "Set a value in the global config (~/.config/wdid/config.json). Use dotted access for nested fields (togglProjects.ABC-)."
+).action(async (key, value) => {
+  try {
+    await runConfigSet(key, value);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(renderError(message) + "\n");
+    process.exitCode = 1;
+  }
+});
+configCmd.command("get <key>").description(
+  "Print a single config value. Secrets are masked unless --show-secrets is set."
+).option("--show-secrets", "reveal secret values in full").action(async (key, options) => {
+  try {
+    await runConfigGet(key, options);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(renderError(message) + "\n");
+    process.exitCode = 1;
+  }
+});
+configCmd.command("list").description(
+  "Print all configured values. Secrets are masked unless --show-secrets is set."
+).option("--show-secrets", "reveal secret values in full").action(async (options) => {
+  try {
+    await runConfigList(options);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(renderError(message) + "\n");
+    process.exitCode = 1;
+  }
+});
+configCmd.command("path").description(
+  "Print the absolute path to the global config file (honors XDG_CONFIG_HOME)."
+).action(() => {
+  runConfigPath();
+});
+configCmd.command("keys").description("List every config key with its type, default, and description.").action(() => {
+  process.stdout.write(renderConfigKeys() + "\n");
+});
 program.parseAsync(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drazenbebic/wdid",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "What did I do? — summarize your git activity per day as a tidy table, grouped by JIRA ticket.",
   "keywords": [
     "git",