@bretwardjames/tw-bridge 0.4.0 → 0.5.0

package/dist/cli.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import fs3 from "fs";
-import path4 from "path";
-import os3 from "os";
+import fs4 from "fs";
+import path5 from "path";
+import os4 from "os";
 
 // src/config.ts
 import fs from "fs";
@@ -241,8 +241,8 @@ async function oauthLogin(clientId, clientSecret, rl) {
   saveTokens(tokens);
   return tokens;
 }
-async function asanaFetch(path5, token, options = {}) {
-  const url = `${API_BASE}${path5}`;
+async function asanaFetch(path6, token, options = {}) {
+  const url = `${API_BASE}${path6}`;
   const res = await fetch(url, {
     ...options,
     headers: {
@@ -258,9 +258,9 @@ async function asanaFetch(path5, token, options = {}) {
   const json = await res.json();
   return json.data;
 }
-async function asanaFetchAll(path5, token) {
+async function asanaFetchAll(path6, token) {
   const results = [];
-  let nextPage = path5;
+  let nextPage = path6;
   while (nextPage) {
     const url = `${API_BASE}${nextPage}`;
     const res = await fetch(url, {
@@ -707,12 +707,65 @@ function updateTaskDescription(existing, newDescription) {
   return result.status === 0;
 }
 
+// src/tracking.ts
+import fs3 from "fs";
+import path4 from "path";
+import os3 from "os";
+import { spawnSync as spawnSync3 } from "child_process";
+var TRACKING_FILE = path4.join(os3.homedir(), ".config", "tw-bridge", "tracking.json");
+function loadTracking() {
+  try {
+    return JSON.parse(fs3.readFileSync(TRACKING_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveTracking(state) {
+  fs3.mkdirSync(path4.dirname(TRACKING_FILE), { recursive: true });
+  fs3.writeFileSync(TRACKING_FILE, JSON.stringify(state));
+}
+function mergedTags(state) {
+  const all = /* @__PURE__ */ new Set();
+  for (const tags of Object.values(state)) {
+    for (const tag of tags) all.add(tag);
+  }
+  return [...all];
+}
+function startParallel(key, tags) {
+  const tracking = loadTracking();
+  tracking[key] = tags;
+  saveTracking(tracking);
+  const merged = mergedTags(tracking);
+  spawnSync3("timew", ["stop"], { stdio: "pipe" });
+  spawnSync3("timew", ["start", ...merged], { stdio: "pipe" });
+}
+function startSwitch(key, tags) {
+  saveTracking({ [key]: tags });
+  spawnSync3("timew", ["stop"], { stdio: "pipe" });
+  spawnSync3("timew", ["start", ...tags], { stdio: "pipe" });
+}
+function stopEntry(key) {
+  const tracking = loadTracking();
+  delete tracking[key];
+  saveTracking(tracking);
+  const remaining = mergedTags(tracking);
+  spawnSync3("timew", ["stop"], { stdio: "pipe" });
+  if (remaining.length > 0) {
+    spawnSync3("timew", ["start", ...remaining], { stdio: "pipe" });
+  }
+}
+function getActiveMeetings() {
+  const tracking = loadTracking();
+  return Object.entries(tracking).filter(([key]) => key.startsWith("meeting:")).map(([key, tags]) => ({ key, tags }));
+}
+
 // src/cli.ts
-var HOOKS_DIR = path4.join(os3.homedir(), ".task", "hooks");
+var HOOKS_DIR = path5.join(os4.homedir(), ".task", "hooks");
 var commands = {
   add: addBackend,
   install,
   sync,
+  meeting: meetingCmd,
   timewarrior: timewarriorCmd,
   which,
   config: showConfig
@@ -722,9 +775,10 @@ async function main() {
   if (!command || command === "--help") {
     console.log("Usage: tw-bridge <command>\n");
     console.log("Commands:");
-    console.log("  add       Add a new backend instance");
-    console.log("  install   Install Taskwarrior hooks and shell integration");
+    console.log("  add         Add a new backend instance");
+    console.log("  install     Install Taskwarrior hooks and shell integration");
     console.log("  sync        Pull tasks from all backends");
+    console.log("  meeting     Track meetings in Timewarrior (no task created)");
     console.log("  timewarrior Manage Timewarrior integration");
     console.log("  which       Print the context for the current directory");
     console.log("  config      Show current configuration");
@@ -800,18 +854,18 @@ Added backend "${name}" (adapter: ${adapterType})`);
 Use 'task context ${matchTag}' to switch to this project.`);
 }
 async function install() {
-  fs3.mkdirSync(HOOKS_DIR, { recursive: true });
-  const hookSource = path4.resolve(
-    path4.dirname(new URL(import.meta.url).pathname),
+  fs4.mkdirSync(HOOKS_DIR, { recursive: true });
+  const hookSource = path5.resolve(
+    path5.dirname(new URL(import.meta.url).pathname),
     "hooks",
     "on-modify.js"
   );
-  const hookTarget = path4.join(HOOKS_DIR, "on-modify.tw-bridge");
-  if (fs3.existsSync(hookTarget)) {
-    fs3.unlinkSync(hookTarget);
+  const hookTarget = path5.join(HOOKS_DIR, "on-modify.tw-bridge");
+  if (fs4.existsSync(hookTarget)) {
+    fs4.unlinkSync(hookTarget);
   }
-  fs3.symlinkSync(hookSource, hookTarget);
-  fs3.chmodSync(hookSource, 493);
+  fs4.symlinkSync(hookSource, hookTarget);
+  fs4.chmodSync(hookSource, 493);
   console.log(`Installed hook: ${hookTarget} -> ${hookSource}`);
   console.log("\nAdd these to your .taskrc:\n");
   console.log("# --- tw-bridge UDAs ---");
@@ -828,31 +882,133 @@ async function install() {
   console.log("urgency.user.tag.ready_for_beta.coefficient=-4.0");
   console.log("urgency.user.tag.in_beta.coefficient=-6.0");
   installTimewExtension();
-  if (fs3.existsSync(STANDARD_TIMEW_HOOK)) {
+  if (fs4.existsSync(STANDARD_TIMEW_HOOK)) {
     console.log("\nTimewarrior hook detected. To enable tw-bridge time tracking:");
     console.log("  tw-bridge timewarrior enable");
   }
   installShellFunction();
 }
-var TIMEW_EXT_DIR = path4.join(os3.homedir(), ".timewarrior", "extensions");
+var TIMEW_EXT_DIR = path5.join(os4.homedir(), ".timewarrior", "extensions");
 function installTimewExtension() {
-  fs3.mkdirSync(TIMEW_EXT_DIR, { recursive: true });
-  const extSource = path4.resolve(
-    path4.dirname(new URL(import.meta.url).pathname),
+  fs4.mkdirSync(TIMEW_EXT_DIR, { recursive: true });
+  const extSource = path5.resolve(
+    path5.dirname(new URL(import.meta.url).pathname),
     "extensions",
     "bridge.js"
   );
-  const extTarget = path4.join(TIMEW_EXT_DIR, "bridge");
-  if (fs3.existsSync(extTarget)) {
-    fs3.unlinkSync(extTarget);
+  const extTarget = path5.join(TIMEW_EXT_DIR, "bridge");
+  if (fs4.existsSync(extTarget)) {
+    fs4.unlinkSync(extTarget);
   }
-  fs3.symlinkSync(extSource, extTarget);
-  fs3.chmodSync(extSource, 493);
+  fs4.symlinkSync(extSource, extTarget);
+  fs4.chmodSync(extSource, 493);
   console.log(`
 Installed Timewarrior extension: ${extTarget} -> ${extSource}`);
   console.log("  Usage: timew bridge [task-time|wall-time] [project-filter]");
 }
-var STANDARD_TIMEW_HOOK = path4.join(HOOKS_DIR, "on-modify.timewarrior");
+function sanitizeMeetingName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function detectProjectContext() {
+  const cwd = process.cwd();
+  const config = loadConfig();
+  for (const [, backend] of Object.entries(config.backends)) {
+    const backendCwd = backend.config?.cwd;
+    if (!backendCwd) continue;
+    const resolved = path5.resolve(backendCwd);
+    if (cwd === resolved || cwd.startsWith(resolved + path5.sep)) {
+      return backend.match.tags?.[0] ?? null;
+    }
+  }
+  return null;
+}
+async function meetingCmd() {
+  const sub = process.argv[3];
+  if (!sub || sub === "--help") {
+    console.log("Usage: tw-bridge meeting <subcommand>\n");
+    console.log("Subcommands:");
+    console.log("  start <name> [--switch]  Start tracking a meeting");
+    console.log("  stop [name]              Stop a meeting (or all if no name)");
+    console.log("  list                     Show active meetings");
+    console.log("\nMeetings are tracked in Timewarrior only \u2014 no Taskwarrior task is created.");
+    console.log("By default, meetings run in parallel with active tasks.");
+    console.log("Use --switch to pause the current task instead.");
+    return;
+  }
+  const config = loadConfig();
+  if (!config.timewarrior?.enabled) {
+    console.error("Timewarrior is not enabled. Run: tw-bridge timewarrior enable");
+    process.exit(1);
+  }
+  if (sub === "start") {
+    const nameArg = process.argv.slice(4).filter((a) => !a.startsWith("--")).join(" ");
+    if (!nameArg) {
+      console.error("Usage: tw-bridge meeting start <name>");
+      process.exit(1);
+    }
+    const switchMode = process.argv.includes("--switch") || process.argv.includes("-s");
+    const tag = sanitizeMeetingName(nameArg);
+    const key = `meeting:${tag}`;
+    const tags = ["meeting", tag];
+    const project = detectProjectContext();
+    if (project) tags.push(project);
+    if (switchMode) {
+      startSwitch(key, tags);
+    } else {
+      startParallel(key, tags);
+    }
+    console.log(`Meeting started: ${nameArg}`);
+    console.log(`  Tags: ${tags.join(" ")}`);
+    if (!switchMode) {
+      console.log("  Mode: parallel (active tasks continue tracking)");
+    } else {
+      console.log("  Mode: switch (active tasks paused)");
+    }
+    return;
+  }
+  if (sub === "stop") {
+    const nameArg = process.argv.slice(4).join(" ").trim();
+    const active = getActiveMeetings();
+    if (active.length === 0) {
+      console.log("No active meetings.");
+      return;
+    }
+    if (nameArg) {
+      const tag = sanitizeMeetingName(nameArg);
+      const key = `meeting:${tag}`;
+      const match = active.find((m) => m.key === key);
+      if (!match) {
+        console.error(`No active meeting matching "${nameArg}".`);
+        console.error(`Active meetings: ${active.map((m) => m.key.replace("meeting:", "")).join(", ")}`);
+        process.exit(1);
+      }
+      stopEntry(key);
+      console.log(`Meeting stopped: ${nameArg}`);
+    } else {
+      for (const m of active) {
+        stopEntry(m.key);
+      }
+      console.log(`Stopped ${active.length} meeting(s): ${active.map((m) => m.key.replace("meeting:", "")).join(", ")}`);
+    }
+    return;
+  }
+  if (sub === "list") {
+    const active = getActiveMeetings();
+    if (active.length === 0) {
+      console.log("No active meetings.");
+      return;
+    }
+    console.log("Active meetings:");
+    for (const m of active) {
+      const name = m.key.replace("meeting:", "");
+      console.log(`  ${name}  (${m.tags.join(" ")})`);
+    }
+    return;
+  }
+  console.error(`Unknown subcommand: ${sub}`);
+  process.exit(1);
+}
+var STANDARD_TIMEW_HOOK = path5.join(HOOKS_DIR, "on-modify.timewarrior");
 async function timewarriorCmd() {
   const sub = process.argv[3];
   if (!sub || sub === "--help") {
@@ -875,8 +1031,8 @@ async function timewarriorCmd() {
       console.log("Timewarrior: enabled");
       console.log("  Parallel tracking: use `task start <id> --parallel`");
     }
-    const hookExists = fs3.existsSync(STANDARD_TIMEW_HOOK);
-    const hookDisabled = fs3.existsSync(STANDARD_TIMEW_HOOK + ".disabled");
+    const hookExists = fs4.existsSync(STANDARD_TIMEW_HOOK);
+    const hookDisabled = fs4.existsSync(STANDARD_TIMEW_HOOK + ".disabled");
     if (hookExists) {
       console.log(`Standard hook: active (${STANDARD_TIMEW_HOOK})`);
       if (tw?.enabled) {
@@ -894,9 +1050,9 @@ async function timewarriorCmd() {
     const configPath = saveConfig(config);
     console.log("Timewarrior tracking enabled");
     console.log(`Config: ${configPath}`);
-    if (fs3.existsSync(STANDARD_TIMEW_HOOK)) {
+    if (fs4.existsSync(STANDARD_TIMEW_HOOK)) {
       const disabled = STANDARD_TIMEW_HOOK + ".disabled";
-      fs3.renameSync(STANDARD_TIMEW_HOOK, disabled);
+      fs4.renameSync(STANDARD_TIMEW_HOOK, disabled);
       console.log(`
 Disabled standard hook: ${STANDARD_TIMEW_HOOK} -> .disabled`);
       console.log("tw-bridge will handle Timewarrior tracking directly.");
@@ -909,8 +1065,8 @@ Disabled standard hook: ${STANDARD_TIMEW_HOOK} -> .disabled`);
     console.log("Timewarrior tracking disabled");
     console.log(`Config: ${configPath}`);
     const disabled = STANDARD_TIMEW_HOOK + ".disabled";
-    if (fs3.existsSync(disabled)) {
-      fs3.renameSync(disabled, STANDARD_TIMEW_HOOK);
+    if (fs4.existsSync(disabled)) {
+      fs4.renameSync(disabled, STANDARD_TIMEW_HOOK);
       console.log(`
 Restored standard hook: ${STANDARD_TIMEW_HOOK}`);
     }
@@ -940,28 +1096,28 @@ task() {
 var SHELL_MARKER = "# tw-bridge: auto-context task wrapper";
 function installShellFunction() {
   const shell = process.env.SHELL ?? "/bin/bash";
-  const home = os3.homedir();
+  const home = os4.homedir();
   let rcFile;
   if (shell.endsWith("zsh")) {
-    rcFile = path4.join(home, ".zshrc");
+    rcFile = path5.join(home, ".zshrc");
   } else {
-    rcFile = path4.join(home, ".bashrc");
+    rcFile = path5.join(home, ".bashrc");
   }
-  const existing = fs3.existsSync(rcFile) ? fs3.readFileSync(rcFile, "utf-8") : "";
+  const existing = fs4.existsSync(rcFile) ? fs4.readFileSync(rcFile, "utf-8") : "";
   if (existing.includes(SHELL_MARKER)) {
     console.log(`
 Shell integration already installed in ${rcFile}`);
     return;
   }
-  fs3.appendFileSync(rcFile, "\n" + SHELL_FUNCTION + "\n");
+  fs4.appendFileSync(rcFile, "\n" + SHELL_FUNCTION + "\n");
   console.log(`
 Shell integration installed in ${rcFile}`);
   console.log("Restart your shell or run: source " + rcFile);
 }
-var SEEN_FILE = path4.join(os3.homedir(), ".config", "tw-bridge", ".seen-dirs");
+var SEEN_FILE = path5.join(os4.homedir(), ".config", "tw-bridge", ".seen-dirs");
 function loadSeenDirs() {
   try {
-    const raw = fs3.readFileSync(SEEN_FILE, "utf-8");
+    const raw = fs4.readFileSync(SEEN_FILE, "utf-8");
     return new Set(raw.split("\n").filter(Boolean));
   } catch {
     return /* @__PURE__ */ new Set();
@@ -971,15 +1127,15 @@ function markDirSeen(dir) {
   const seen = loadSeenDirs();
   if (seen.has(dir)) return;
   seen.add(dir);
-  fs3.mkdirSync(path4.dirname(SEEN_FILE), { recursive: true });
-  fs3.writeFileSync(SEEN_FILE, [...seen].join("\n") + "\n");
+  fs4.mkdirSync(path5.dirname(SEEN_FILE), { recursive: true });
+  fs4.writeFileSync(SEEN_FILE, [...seen].join("\n") + "\n");
 }
 function isGitRepo(dir) {
   try {
     let current = dir;
-    while (current !== path4.dirname(current)) {
-      if (fs3.existsSync(path4.join(current, ".git"))) return true;
-      current = path4.dirname(current);
+    while (current !== path5.dirname(current)) {
+      if (fs4.existsSync(path5.join(current, ".git"))) return true;
+      current = path5.dirname(current);
     }
     return false;
   } catch {
@@ -992,8 +1148,8 @@ async function which() {
   for (const [_name, backend] of Object.entries(config.backends)) {
     const backendCwd = backend.config?.cwd;
     if (!backendCwd) continue;
-    const resolved = path4.resolve(backendCwd);
-    if (cwd === resolved || cwd.startsWith(resolved + path4.sep)) {
+    const resolved = path5.resolve(backendCwd);
+    if (cwd === resolved || cwd.startsWith(resolved + path5.sep)) {
       const contextTag = backend.match.tags?.[0];
       if (contextTag) {
         process.stdout.write(contextTag);
@@ -1009,15 +1165,15 @@ async function which() {
     const seen = loadSeenDirs();
     let gitRoot = cwd;
     let current = cwd;
-    while (current !== path4.dirname(current)) {
-      if (fs3.existsSync(path4.join(current, ".git"))) {
+    while (current !== path5.dirname(current)) {
+      if (fs4.existsSync(path5.join(current, ".git"))) {
         gitRoot = current;
         break;
       }
-      current = path4.dirname(current);
+      current = path5.dirname(current);
     }
     if (!seen.has(gitRoot)) {
-      const dirName = path4.basename(gitRoot);
+      const dirName = path5.basename(gitRoot);
       process.stderr.write(
         `tw-bridge: unconfigured project "${dirName}". Run: tw-bridge add ${dirName} --adapter ghp
 `

package/dist/hooks/on-modify.js

@@ -1,10 +1,8 @@
 #!/usr/bin/env node
 
 // src/hooks/on-modify.ts
-import fs3 from "fs";
-import path4 from "path";
-import os3 from "os";
-import { spawnSync as spawnSync2 } from "child_process";
+import fs4 from "fs";
+import { spawnSync as spawnSync3 } from "child_process";
 
 // src/config.ts
 import fs from "fs";
@@ -601,7 +599,11 @@ async function resolveAdapter(task, config) {
   return adapter;
 }
 
-// src/hooks/on-modify.ts
+// src/tracking.ts
+import fs3 from "fs";
+import path4 from "path";
+import os3 from "os";
+import { spawnSync as spawnSync2 } from "child_process";
 var TRACKING_FILE = path4.join(os3.homedir(), ".config", "tw-bridge", "tracking.json");
 function loadTracking() {
   try {
@@ -621,19 +623,6 @@ function mergedTags(state) {
   }
   return [...all];
 }
-function timewTags(task) {
-  const tags = [];
-  if (task.backend) tags.push(task.backend);
-  if (task.backend_id) tags.push(`#${task.backend_id}`);
-  if (task.project) tags.push(task.project);
-  for (const tag of task.tags ?? []) {
-    if (!tag.includes("_")) tags.push(tag);
-  }
-  return [...new Set(tags)];
-}
-function taskKey(task) {
-  return task.backend_id ? `#${task.backend_id}` : task.uuid;
-}
 function getCurrentInterval() {
   const result = spawnSync2("timew", ["export"], {
     encoding: "utf-8",
@@ -647,6 +636,21 @@ function getCurrentInterval() {
     return null;
   }
 }
+
+// src/hooks/on-modify.ts
+function timewTags(task) {
+  const tags = [];
+  if (task.backend) tags.push(task.backend);
+  if (task.backend_id) tags.push(`#${task.backend_id}`);
+  if (task.project) tags.push(task.project);
+  for (const tag of task.tags ?? []) {
+    if (!tag.includes("_")) tags.push(tag);
+  }
+  return [...new Set(tags)];
+}
+function taskKey(task) {
+  return task.backend_id ? `#${task.backend_id}` : task.uuid;
+}
 function formatDuration(isoStart) {
   const start = new Date(
     isoStart.replace(
@@ -685,10 +689,10 @@ tw-bridge: Currently tracking: ${tags} (${duration})`
   lines.push("  [s] Switch \u2014 stop current, start new task (default)");
   lines.push("  [p] Parallel \u2014 add new task to current tracking");
   lines.push("");
-  fs3.writeSync(ttyFd, lines.join("\n"));
-  fs3.writeSync(ttyFd, "  > ");
+  fs4.writeSync(ttyFd, lines.join("\n"));
+  fs4.writeSync(ttyFd, "  > ");
   const buf = Buffer.alloc(64);
-  const bytesRead = fs3.readSync(ttyFd, buf, 0, 64, null);
+  const bytesRead = fs4.readSync(ttyFd, buf, 0, 64, null);
   const answer = buf.toString("utf-8", 0, bytesRead).trim().toLowerCase();
   return answer.startsWith("p") ? "parallel" : "switch";
 }
@@ -713,12 +717,12 @@ function handleTimewarriorStart(config, newTask, ttyFd) {
     tracking[key] = newTags;
     saveTracking(tracking);
     const merged = mergedTags(tracking);
-    spawnSync2("timew", ["stop"], { stdio: "pipe" });
-    spawnSync2("timew", ["start", ...merged], { stdio: "pipe" });
+    spawnSync3("timew", ["stop"], { stdio: "pipe" });
+    spawnSync3("timew", ["start", ...merged], { stdio: "pipe" });
   } else {
     saveTracking({ [key]: newTags });
-    spawnSync2("timew", ["stop"], { stdio: "pipe" });
-    spawnSync2("timew", ["start", ...newTags], { stdio: "pipe" });
+    spawnSync3("timew", ["stop"], { stdio: "pipe" });
+    spawnSync3("timew", ["start", ...newTags], { stdio: "pipe" });
   }
 }
 function handleTimewarriorStop(config, task) {
@@ -728,13 +732,13 @@ function handleTimewarriorStop(config, task) {
   delete tracking[key];
   saveTracking(tracking);
   const remaining = mergedTags(tracking);
-  spawnSync2("timew", ["stop"], { stdio: "pipe" });
+  spawnSync3("timew", ["stop"], { stdio: "pipe" });
   if (remaining.length > 0) {
-    spawnSync2("timew", ["start", ...remaining], { stdio: "pipe" });
+    spawnSync3("timew", ["start", ...remaining], { stdio: "pipe" });
   }
 }
 async function main() {
-  const input = fs3.readFileSync("/dev/stdin", "utf-8").trim().split("\n");
+  const input = fs4.readFileSync("/dev/stdin", "utf-8").trim().split("\n");
   const oldTask = JSON.parse(input[0]);
   const newTask = JSON.parse(input[1]);
   process.stdout.write(JSON.stringify(newTask) + "\n");
@@ -745,7 +749,7 @@ async function main() {
   let ttyFd = null;
   if (wasStarted) {
     try {
-      ttyFd = fs3.openSync("/dev/tty", "r+");
+      ttyFd = fs4.openSync("/dev/tty", "r+");
     } catch {
     }
   }
@@ -773,7 +777,7 @@ async function main() {
     process.stderr.write(`tw-bridge: ${msg}
 `);
   } finally {
-    if (ttyFd !== null) fs3.closeSync(ttyFd);
+    if (ttyFd !== null) fs4.closeSync(ttyFd);
   }
 }
 main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bretwardjames/tw-bridge",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Taskwarrior backend bridge — unified sync and hooks for multiple task management platforms",
   "type": "module",
   "license": "MIT",