@drazenbebic/wdid 0.1.3 → 0.3.0

package/dist/index.js

@@ -1,14 +1,26 @@
 #!/usr/bin/env node
 
 // src/index.ts
+import chalk3 from "chalk";
 import { Command } from "commander";
 
 // src/git.ts
-import { execFile } from "child_process";
+import { execFile, spawn } from "child_process";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 var FIELD_SEP = "";
 var RECORD_SEP = "";
+var TRUNK_BRANCHES = /* @__PURE__ */ new Set(["main", "master"]);
+var pad2 = (n) => String(n).padStart(2, "0");
+function formatLocalDateTime(iso) {
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) {
+    return { date: "", time: "" };
+  }
+  const date = `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())}`;
+  const time = `${pad2(d.getHours())}:${pad2(d.getMinutes())}`;
+  return { date, time };
+}
 function extractTicket(message, pattern) {
   const match = message.match(pattern);
   if (!match) {
@@ -16,34 +28,110 @@ function extractTicket(message, pattern) {
   }
   return match[1] ?? match[0];
 }
-async function getGitUserName(cwd) {
+function normalizeBranchName(rawName) {
+  const clean = rawName.replace(/[~^].*$/, "").trim();
+  if (!clean || clean === "undefined" || TRUNK_BRANCHES.has(clean)) {
+    return null;
+  }
+  return clean;
+}
+async function runGitWithStdin(cwd, args, input) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn("git", args, { cwd });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    proc.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    proc.on("error", reject);
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(`git ${args.join(" ")} failed: ${stderr.trim()}`));
+        return;
+      }
+      resolve(stdout);
+    });
+    proc.stdin.write(input);
+    proc.stdin.end();
+  });
+}
+async function getBranchMap(cwd, shas) {
+  const map = /* @__PURE__ */ new Map();
+  if (shas.length === 0) {
+    return map;
+  }
+  let stdout;
+  try {
+    stdout = await runGitWithStdin(
+      cwd,
+      ["name-rev", "--stdin", "--refs=refs/heads/*"],
+      shas.join("\n") + "\n"
+    );
+  } catch {
+    return map;
+  }
+  for (const line of stdout.split("\n")) {
+    const m = line.match(/^([0-9a-fA-F]+)\s+\((.+)\)\s*$/);
+    if (!m) {
+      continue;
+    }
+    const sha = m[1];
+    const rawName = m[2];
+    if (!sha || !rawName) {
+      continue;
+    }
+    map.set(sha, normalizeBranchName(rawName));
+  }
+  return map;
+}
+async function assertGitRepo(cwd) {
   try {
-    const { stdout } = await execFileAsync("git", ["config", "user.name"], {
+    await execFileAsync("git", ["rev-parse", "--is-inside-work-tree"], {
       cwd
     });
-    const name = stdout.trim();
-    if (!name) {
-      throw new Error("empty");
-    }
-    return name;
   } 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',
+      `not inside a git repository: ${cwd} \u2014 cd into a repo or pass --repo <path>`,
       { cause: err }
     );
   }
 }
+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 result = await execFileAsync("git", ["config", "user.name"], {
+      cwd
+    });
+    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(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",
     `--author=${opts.author}`,
-    `--pretty=format:%cs${FIELD_SEP}%s${RECORD_SEP}`
+    `--pretty=format:%H${FIELD_SEP}%cI${FIELD_SEP}%s${RECORD_SEP}`
   ];
   if (opts.from) {
     args.push(`--after=${opts.from} 00:00`);
@@ -51,43 +139,129 @@ async function getCommits(opts) {
   if (opts.to) {
     args.push(`--before=${opts.to} 23:59`);
   }
-  const { stdout } = await execFileAsync("git", args, {
-    cwd: opts.cwd,
-    maxBuffer: 32 * 1024 * 1024
-  });
-  return stdout.split(RECORD_SEP).map((r) => r.trim()).filter((r) => r.length > 0).map((record) => {
-    const [date = "", subject = ""] = record.split(FIELD_SEP);
+  if (opts.limit !== void 0) {
+    args.push(`--max-count=${opts.limit}`);
+  }
+  let stdout;
+  try {
+    const result = await execFileAsync("git", args, {
+      cwd: opts.cwd,
+      maxBuffer: 32 * 1024 * 1024
+    });
+    stdout = result.stdout;
+  } catch (err) {
+    const stderr = String(err.stderr ?? "");
+    if (stderr.includes("does not have any commits") || stderr.includes("bad default revision") || stderr.includes("unknown revision")) {
+      return [];
+    }
+    throw err;
+  }
+  const parsed = stdout.split(RECORD_SEP).map((r) => r.trim()).filter((r) => r.length > 0).map((record) => {
+    const [sha = "", iso = "", subject = ""] = record.split(FIELD_SEP);
+    const { date, time } = formatLocalDateTime(iso);
     return {
+      sha,
       date,
+      time,
       ticket: extractTicket(subject, opts.pattern),
       description: subject
     };
   });
+  const branchMap = await getBranchMap(
+    opts.cwd,
+    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,
+    description: p.description,
+    branch: branchMap.get(p.sha) ?? null
+  }));
 }
 
 // src/format.ts
 import Table from "cli-table3";
 import chalk from "chalk";
-function renderTable(entries) {
+function renderDateCell(entry) {
+  if (!entry.time) {
+    return entry.date;
+  }
+  return `${entry.date} ${chalk.dim(entry.time)}`;
+}
+function renderDescriptionCell(entry) {
+  if (!entry.branch) {
+    return entry.description;
+  }
+  return `${entry.description} ${chalk.magenta(`[${entry.branch}]`)}`;
+}
+function renderTable(entries, ticketColumnLabel = "Ticket") {
   const table = new Table({
     head: [
       chalk.bold.cyan("Date"),
-      chalk.bold.cyan("Ticket"),
+      chalk.bold.cyan(ticketColumnLabel),
+      chalk.bold.cyan("Description")
+    ],
+    style: { head: [], border: [] },
+    wordWrap: true,
+    colWidths: [18, 14, 80]
+  });
+  for (const entry of entries) {
+    table.push([
+      renderDateCell(entry),
+      entry.ticket ? chalk.yellow(entry.ticket) : chalk.gray("\u2014"),
+      renderDescriptionCell(entry)
+    ]);
+  }
+  return table.toString();
+}
+function renderTableGroupedByDay(entries, ticketColumnLabel = "Ticket") {
+  const table = new Table({
+    head: [
+      chalk.bold.cyan("Time"),
+      chalk.bold.cyan(ticketColumnLabel),
       chalk.bold.cyan("Description")
     ],
     style: { head: [], border: [] },
     wordWrap: true,
-    colWidths: [12, 14, 80]
+    colWidths: [8, 14, 90]
   });
+  let currentDate = "";
   for (const entry of entries) {
+    if (entry.date && entry.date !== currentDate) {
+      table.push([
+        {
+          content: chalk.bold(entry.date),
+          colSpan: 3,
+          hAlign: "left"
+        }
+      ]);
+      currentDate = entry.date;
+    }
     table.push([
-      chalk.dim(entry.date),
+      entry.time ? chalk.dim(entry.time) : chalk.gray("\u2014"),
       entry.ticket ? chalk.yellow(entry.ticket) : chalk.gray("\u2014"),
-      entry.description
+      renderDescriptionCell(entry)
     ]);
   }
   return table.toString();
 }
+function toJsonKey(label) {
+  return label.toLowerCase().replace(/\s+/g, "_");
+}
+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,
+    description: e.description,
+    branch: e.branch
+  }));
+  return JSON.stringify(transformed, null, 2);
+}
 function renderEmpty() {
   return chalk.gray("No commits found for the given filters.");
 }
@@ -100,6 +274,21 @@ 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",
+  conventional: "Type",
+  custom: "Match"
+};
+function getColumnLabel(format, override) {
+  return override ?? DEFAULT_COLUMN_LABELS[format];
+}
 var PRESET_PATTERNS = {
   jira: /\b([A-Z][A-Z0-9]+-\d+)\b/,
   github: /#(\d+)/,
@@ -111,12 +300,28 @@ var VALID_FORMATS = [
   "conventional",
   "custom"
 ];
+var MAX_CUSTOM_PATTERN_LENGTH = 500;
+function compileUserRegex(pattern) {
+  if (pattern.length > MAX_CUSTOM_PATTERN_LENGTH) {
+    throw new Error(
+      `customPattern is ${pattern.length} characters; limit is ${MAX_CUSTOM_PATTERN_LENGTH}`
+    );
+  }
+  try {
+    return new RegExp(pattern);
+  } catch (err) {
+    throw new Error(
+      `customPattern is not a valid regex: ${err.message}`,
+      { cause: err }
+    );
+  }
+}
 function getTicketPattern(format, customPattern) {
   if (format === "custom") {
     if (!customPattern) {
       throw new Error('format "custom" requires customPattern to be set');
     }
-    return new RegExp(customPattern);
+    return compileUserRegex(customPattern);
   }
   return PRESET_PATTERNS[format];
 }
@@ -147,6 +352,11 @@ function validateConfig(raw) {
     if (typeof obj.customPattern !== "string") {
       throw new Error("customPattern must be a string");
     }
+    if (obj.customPattern.length > MAX_CUSTOM_PATTERN_LENGTH) {
+      throw new Error(
+        `customPattern is ${obj.customPattern.length} characters; limit is ${MAX_CUSTOM_PATTERN_LENGTH}`
+      );
+    }
     cfg.customPattern = obj.customPattern;
   }
   if (cfg.format === "custom" && !cfg.customPattern) {
@@ -164,6 +374,77 @@ function validateConfig(raw) {
     }
     cfg.defaultRepos = obj.defaultRepos;
   }
+  if ("ticketColumnLabel" in obj) {
+    if (typeof obj.ticketColumnLabel !== "string") {
+      throw new Error("ticketColumnLabel must be a string");
+    }
+    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() {
@@ -194,7 +475,495 @@ 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) {
+    return void 0;
+  }
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isInteger(n) || n < 1 || String(n) !== raw.trim()) {
+    throw new Error(`invalid --limit "${raw}" \u2014 must be a positive integer`);
+  }
+  return n;
+}
+function shouldDisableColor(options) {
+  if (options.color === false) {
+    return true;
+  }
+  const noColor = process.env.NO_COLOR ?? "";
+  return noColor.length > 0;
+}
 var VALID_PRESETS = [
   "jira",
   "github",
@@ -242,21 +1011,219 @@ async function run(dateArg, options) {
     from = day;
     to = day;
   }
-  const allEntries = [];
-  for (const cwd of repos) {
-    const author = options.author ?? config.defaultAuthor ?? await getGitUserName(cwd);
-    const entries = await getCommits({ author, from, to, cwd, pattern });
-    allEntries.push(...entries);
+  const limit = parseLimit(options.limit);
+  const perRepoEntries = await Promise.all(
+    repos.map(async (cwd) => {
+      const author = options.author ?? config.defaultAuthor ?? await getGitUserName(cwd);
+      return getCommits({ author, from, to, cwd, pattern, limit });
+    })
+  );
+  const allEntries = perRepoEntries.flat();
+  allEntries.sort(
+    (a, b) => `${b.date} ${b.time}`.localeCompare(`${a.date} ${a.time}`)
+  );
+  const display = limit !== void 0 ? allEntries.slice(0, limit) : allEntries;
+  const ticketColumnLabel = getColumnLabel(format, config.ticketColumnLabel);
+  if (options.json) {
+    process.stdout.write(renderJson(display, ticketColumnLabel) + "\n");
+    return;
   }
-  allEntries.sort((a, b) => b.date.localeCompare(a.date));
-  if (allEntries.length === 0) {
+  if (display.length === 0) {
     process.stdout.write(renderEmpty() + "\n");
     return;
   }
-  process.stdout.write(renderTable(allEntries) + "\n");
+  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.1.3", "-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(
@@ -268,7 +1235,19 @@ program.name("wdid").description("What did I do? \u2014 summarize your git commi
 ).option(
   "--ticket-pattern <regex>",
   "custom regex for ticket extraction (implies --format custom; overrides --format)"
-).action(async (dateArg, options) => {
+).option(
+  "--no-color",
+  "disable colored output (also honored via the NO_COLOR env var)"
+).option(
+  "--limit <N>",
+  "cap the table to the most recent N rows (positive integer)"
+).option(
+  "--group-by-day",
+  "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)) {
+    chalk3.level = 0;
+  }
   try {
     await run(dateArg, options);
   } catch (err) {
@@ -277,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);