@vibecoded/work 0.0.12 → 0.0.13

package/README.md

@@ -8,6 +8,8 @@ Minimal local time-tracking CLI (Bun + TypeScript) that stores everything on dis
 ## Features
 
 - One command to start/stop tracking.
+- Pause and resume active tracking.
+- Add notes, manual entries, and undo the latest session.
 - Task picking with fuzzy search.
 - Monthly CSV storage for easy exports.
 - No servers, no accounts, no lock-in.
@@ -25,6 +27,11 @@ npm install -g @vibecoded/work
 work init
 work on "Client X" "Kickoff call"
 work status
+work pause
+work resume
+work note "Investigating issue"
+work add "Client X" "Prep" --start "2025-10-01 09" --end "2025-10-01 10" --note "offline work"
+work undo
 work off
 ```
 
@@ -66,6 +73,32 @@ Stop current tracking and write to the month CSV.
 ```typescript
 work off
 ```
+### `work pause`
+Pause the current tracking session.
+```typescript
+work pause
+```
+### `work resume`
+Resume a paused tracking session.
+```typescript
+work resume
+```
+### `work note <text>`
+Add a note to the active session.
+```typescript
+work note "Investigating issue"
+```
+### `work add <project> <task...> [--start <date>] [--end <date>] [--note <text>]`
+Add a manual entry. Date parts are optional; missing minutes/seconds/milliseconds are randomized.
+```typescript
+work add Project "Deep work" --start "2025-10-01 09" --end "2025-10-01 10"
+work add Project "Planning" --start "2025-10-01 11:2" --end "2025-10-01 12" --note "offline"
+```
+### `work undo`
+Mark the most recent session as deleted.
+```typescript
+work undo
+```
 ### `work status`
 Show current tracking (if any).
 ```typescript

package/dist/cli.js

@@ -2084,17 +2084,7 @@ async function ensureCsvHeader(path) {
   }
 }
 async function appendCsvRow(path, row) {
-  const line = [
-    row.id,
-    row.startAt,
-    row.endAt,
-    row.task,
-    row.note,
-    row.createdAt,
-    row.updatedAt,
-    row.deletedAt
-  ].map(esc).join(",") + `
-`;
+  const line = serializeCsvRows([row], false);
   await appendFile(path, line, "utf-8");
 }
 function unquoteCsvCell(s) {
@@ -2158,6 +2148,29 @@ async function readCsvRows(path) {
   }
   return rows;
 }
+function serializeCsvRows(rows, includeHeader = true) {
+  const lines = [];
+  if (includeHeader)
+    lines.push(HEADER.trimEnd());
+  for (const row of rows) {
+    lines.push([
+      row.id,
+      row.startAt,
+      row.endAt,
+      row.task,
+      row.note,
+      row.createdAt,
+      row.updatedAt,
+      row.deletedAt
+    ].map(esc).join(","));
+  }
+  return lines.join(`
+`) + `
+`;
+}
+async function writeCsvRows(path, rows) {
+  await writeFile2(path, serializeCsvRows(rows, true), "utf-8");
+}
 
 // src/lib/time.ts
 function fmtElapsed(ms) {
@@ -2209,6 +2222,7 @@ async function saveTaskIndex(workHome, projectId, idx) {
 }
 
 // src/cli.ts
+import { readdir } from "node:fs/promises";
 function usage() {
   console.log(`
 work - minimal time tracking (monthly CSV per project)
@@ -2217,6 +2231,11 @@ USAGE:
   work init
   work on [project] [task...]
   work off
+  work pause
+  work resume
+  work note <text>
+  work add <project> <task...> [--start <date>] [--end <date>] [--note <text>]
+  work undo
   work status
   work info [projectNameOrId] [YYYY-MM] [--export]
   work projects
@@ -2245,6 +2264,21 @@ async function main() {
     case "off":
       await cmdOff(workHome);
       return;
+    case "pause":
+      await cmdPause(workHome);
+      return;
+    case "resume":
+      await cmdResume(workHome);
+      return;
+    case "note":
+      await cmdNote(workHome, rest);
+      return;
+    case "add":
+      await cmdAdd(workHome, rest, flags);
+      return;
+    case "undo":
+      await cmdUndo(workHome);
+      return;
     case "status":
       await cmdStatus(workHome);
       return;
@@ -2362,10 +2396,118 @@ async function cmdOff(workHome) {
     console.error("No active session.");
     process.exit(1);
   }
-  await stopAndPersist(workHome, running.session, nowIso());
+  const endAt = running.session.pausedAt ?? nowIso();
+  await stopAndPersist(workHome, running.session, endAt);
   await saveRunning(workHome, { session: null });
   console.log("Stopped.");
 }
+async function cmdNote(workHome, rest) {
+  await ensureWorkHome(workHome);
+  const running = await loadRunning(workHome);
+  if (!running.session) {
+    console.error("No active session.");
+    process.exit(1);
+  }
+  const note = rest.join(" ").trim();
+  if (!note) {
+    console.error("Note text is required.");
+    process.exit(1);
+  }
+  running.session.note = note;
+  await saveRunning(workHome, running);
+  console.log("Noted.");
+}
+async function cmdAdd(workHome, rest, flags) {
+  await ensureWorkHome(workHome);
+  const projectName = rest[0]?.trim();
+  const taskName = rest.slice(1).join(" ").trim();
+  if (!projectName || !taskName) {
+    console.error("Usage: work add <project> <task...> [--start <date>] [--end <date>] [--note <text>]");
+    process.exit(1);
+  }
+  const startAt = parseDateArg(flags.start, "start");
+  const endAt = parseDateArg(flags.end, "end");
+  const startMs = Date.parse(startAt);
+  const endMs = Date.parse(endAt);
+  if (!Number.isFinite(startMs) || !Number.isFinite(endMs) || endMs <= startMs) {
+    console.error("Invalid time range. Ensure end is after start.");
+    process.exit(1);
+  }
+  const projects = await loadProjects(workHome);
+  const project = await resolveProjectByNameOrCreate(workHome, projects, projectName);
+  const task = await resolveTaskByNameOrCreate(workHome, project.id, taskName);
+  const idx = await loadTaskIndex(workHome, project.id);
+  updateTaskStats(idx, task);
+  await saveTaskIndex(workHome, project.id, idx);
+  const ym = localYearMonth(new Date(endMs));
+  const csvPath = getMonthCsvPath(workHome, project.id, ym);
+  await ensureCsvHeader(csvPath);
+  const now = nowIso();
+  const row = {
+    id: globalThis.crypto?.randomUUID ? globalThis.crypto.randomUUID() : randomUuidFallback(),
+    startAt,
+    endAt,
+    task,
+    note: typeof flags.note === "string" ? flags.note : "",
+    createdAt: now,
+    updatedAt: now,
+    deletedAt: ""
+  };
+  await appendCsvRow(csvPath, row);
+  console.log(`Added: ${formatWorkLabel(project.name, task)}`);
+}
+async function cmdPause(workHome) {
+  await ensureWorkHome(workHome);
+  const running = await loadRunning(workHome);
+  if (!running.session) {
+    console.error("No active session.");
+    process.exit(1);
+  }
+  if (running.session.pausedAt) {
+    console.log("Already paused.");
+    return;
+  }
+  running.session.pausedAt = nowIso();
+  await saveRunning(workHome, running);
+  console.log("Paused.");
+}
+async function cmdResume(workHome) {
+  await ensureWorkHome(workHome);
+  const running = await loadRunning(workHome);
+  if (!running.session) {
+    console.error("No active session.");
+    process.exit(1);
+  }
+  if (!running.session.pausedAt) {
+    console.log("Not paused.");
+    return;
+  }
+  const pausedAt = Date.parse(running.session.pausedAt);
+  if (Number.isFinite(pausedAt)) {
+    running.session.pausedMs = (running.session.pausedMs ?? 0) + (Date.now() - pausedAt);
+  }
+  running.session.pausedAt = null;
+  await saveRunning(workHome, running);
+  console.log("Resumed.");
+}
+async function cmdUndo(workHome) {
+  await ensureWorkHome(workHome);
+  const projects = await loadProjects(workHome);
+  const latest = await findLatestSession(projects, workHome);
+  if (!latest) {
+    console.log("No sessions to undo.");
+    return;
+  }
+  const { project, csvPath, rowIndex, rows } = latest;
+  const now = nowIso();
+  rows[rowIndex] = {
+    ...rows[rowIndex],
+    updatedAt: now,
+    deletedAt: now
+  };
+  await writeCsvRows(csvPath, rows);
+  console.log(`Undone: ${formatWorkLabel(project.name, rows[rowIndex]?.task ?? "")}`);
+}
 async function cmdStatus(workHome) {
   await ensureWorkHome(workHome);
   const running = await loadRunning(workHome);
@@ -2377,7 +2519,8 @@ async function cmdStatus(workHome) {
   const elapsed = fmtElapsed(sessionElapsedMs(s));
   console.log(`Running: ${formatWorkLabel(s.projectName, s.task)}
 ` + `Started: ${s.startAt}
-` + `Elapsed: ${elapsed}${s.pausedAt ? " (paused)" : ""}`);
+` + `Elapsed: ${elapsed}${s.pausedAt ? " (paused)" : ""}` + (s.note ? `
+Note: ${s.note}` : ""));
 }
 async function cmdInfo(workHome, rest, flags) {
   await ensureWorkHome(workHome);
@@ -2608,7 +2751,8 @@ function normalizeTaskLabel(task) {
   return (task ?? "").trim() || "(no task)";
 }
 function sessionElapsedMs(session) {
-  return Date.now() - Date.parse(session.startAt) - (session.pausedMs ?? 0);
+  const endAt = session.pausedAt ? Date.parse(session.pausedAt) : Date.now();
+  return endAt - Date.parse(session.startAt) - (session.pausedMs ?? 0);
 }
 function parseInfoArgs(args) {
   const a1 = args[0]?.trim();
@@ -2625,6 +2769,101 @@ function parseInfoArgs(args) {
   }
   return { projectArg, monthArg };
 }
+function parseDateArg(value, label) {
+  if (typeof value === "boolean") {
+    console.error(`--${label} requires a value`);
+    process.exit(1);
+  }
+  if (!value)
+    return nowIso();
+  const parsed = parsePartialDateTime(value);
+  if (!parsed) {
+    console.error(`Invalid ${label} date. Expected "YYYY-MM-DD" with optional time.`);
+    process.exit(1);
+  }
+  return parsed.toISOString();
+}
+function parsePartialDateTime(input) {
+  const trimmed = input.trim();
+  if (!trimmed)
+    return null;
+  const [datePart, timePartRaw] = trimmed.split(/[T ]/);
+  const dateMatch = /^(\d{4})-(\d{2})-(\d{2})$/.exec(datePart);
+  if (!dateMatch)
+    return null;
+  const year = Number(dateMatch[1]);
+  const month = Number(dateMatch[2]);
+  const day = Number(dateMatch[3]);
+  if (!Number.isFinite(year) || !Number.isFinite(month) || !Number.isFinite(day))
+    return null;
+  let hour = 0;
+  let minute = randomInt(0, 59);
+  let second = randomInt(0, 59);
+  let ms = randomInt(0, 999);
+  if (timePartRaw) {
+    const timeParts = timePartRaw.split(":");
+    if (timeParts[0])
+      hour = Number(timeParts[0]);
+    if (!Number.isFinite(hour))
+      return null;
+    if (timeParts[1] != null) {
+      minute = fillPartialNumber(timeParts[1], 0, 59);
+    }
+    if (timeParts[2] != null) {
+      const [secPart, msPart] = timeParts[2].split(".");
+      second = fillPartialNumber(secPart, 0, 59);
+      if (msPart != null) {
+        ms = fillPartialMs(msPart);
+      }
+    }
+    if (timeParts[1] == null) {
+      minute = randomInt(0, 59);
+      second = randomInt(0, 59);
+      ms = randomInt(0, 999);
+    } else if (timeParts[2] == null) {
+      second = randomInt(0, 59);
+      ms = randomInt(0, 999);
+    }
+  }
+  if (hour < 0 || hour > 23)
+    return null;
+  if (minute < 0 || minute > 59)
+    return null;
+  if (second < 0 || second > 59)
+    return null;
+  if (ms < 0 || ms > 999)
+    return null;
+  return new Date(year, month - 1, day, hour, minute, second, ms);
+}
+function fillPartialNumber(part, min, max) {
+  const trimmed = part.trim();
+  if (!trimmed)
+    return randomInt(min, max);
+  if (/^\d$/.test(trimmed)) {
+    const tens = Number(trimmed) * 10;
+    return clamp(tens + randomInt(0, 9), min, max);
+  }
+  const value = Number(trimmed);
+  if (!Number.isFinite(value))
+    return randomInt(min, max);
+  return clamp(value, min, max);
+}
+function fillPartialMs(part) {
+  const trimmed = part.trim();
+  if (!trimmed)
+    return randomInt(0, 999);
+  if (/^\d{1,3}$/.test(trimmed)) {
+    const value = Number(trimmed.padEnd(3, String(randomInt(0, 9))));
+    return clamp(value, 0, 999);
+  }
+  return randomInt(0, 999);
+}
+function randomInt(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
 function sortTasksByUsage(a, b) {
   const ca = a.count ?? 0;
   const cb = b.count ?? 0;
@@ -2660,6 +2899,33 @@ function updateTaskStats(idx, taskName) {
     createdAt: nowIso()
   });
 }
+async function findLatestSession(projects, workHome) {
+  let latest = null;
+  for (const project of projects.projects) {
+    const projectDir = getProjectDir(workHome, project.id);
+    let entries = [];
+    try {
+      entries = await readdir(projectDir);
+    } catch {
+      continue;
+    }
+    const csvFiles = entries.filter((entry) => /^\d{4}-\d{2}\.csv$/.test(entry));
+    for (const file of csvFiles) {
+      const csvPath = pathJoin(projectDir, file);
+      const rows = await readCsvRows(csvPath);
+      for (let i = 0;i < rows.length; i++) {
+        const row = rows[i];
+        if (!row || row.deletedAt)
+          continue;
+        const timeMs = Date.parse(row.endAt) || Date.parse(row.startAt) || 0;
+        if (!latest || timeMs > latest.timeMs) {
+          latest = { project, csvPath, rowIndex: i, rows, timeMs };
+        }
+      }
+    }
+  }
+  return latest;
+}
 process.on("uncaughtException", (error) => {
   if (error && typeof error === "object" && error.name === "ExitPromptError") {
     console.log("\uD83D\uDC4B until next time!");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibecoded/work",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "description": "Work: CLI Time Tracker",
   "module": "dist/cli.js",
   "scripts": {