@bretwardjames/tw-bridge 0.1.0

package/dist/cli.js

@@ -0,0 +1,592 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import fs2 from "fs";
+import path3 from "path";
+import os2 from "os";
+
+// src/config.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+var CONFIG_PATHS = [
+  path.join(os.homedir(), ".config", "tw-bridge", "config.json"),
+  path.join(os.homedir(), ".tw-bridge.json")
+];
+function findConfigPath() {
+  for (const p of CONFIG_PATHS) {
+    if (fs.existsSync(p)) return p;
+  }
+  return null;
+}
+function loadConfig() {
+  const configPath = findConfigPath();
+  if (!configPath) {
+    return { backends: {} };
+  }
+  const raw = fs.readFileSync(configPath, "utf-8");
+  return JSON.parse(raw);
+}
+function saveConfig(config) {
+  const configPath = findConfigPath() ?? CONFIG_PATHS[0];
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  return configPath;
+}
+
+// src/adapters/ghp.ts
+import { spawnSync } from "child_process";
+import path2 from "path";
+function statusToTag(status) {
+  if (!status) return null;
+  return status.toLowerCase().replace(/\s+/g, "_");
+}
+function mapPriority(fields) {
+  const priority = fields["Priority"]?.toLowerCase();
+  if (!priority) return void 0;
+  if (priority.startsWith("high") || priority === "urgent" || priority === "p0" || priority === "p1") return "H";
+  if (priority.startsWith("med") || priority === "p2") return "M";
+  if (priority.startsWith("low") || priority === "p3" || priority === "p4") return "L";
+  return void 0;
+}
+function extractErrorMessage(raw) {
+  const lines = raw.split("\n");
+  const meaningful = lines.find(
+    (l) => /^(fatal|error|Error):/i.test(l.trim())
+  );
+  if (meaningful) return meaningful.trim();
+  const first = lines.find(
+    (l) => l.trim() && !l.trim().startsWith("at ") && !l.includes("node:internal")
+  );
+  return first?.trim() ?? raw.split("\n")[0].trim();
+}
+var GhpAdapter = class {
+  name = "ghp";
+  config;
+  defaultConfig(cwd) {
+    return {
+      cwd,
+      project: path2.basename(cwd)
+    };
+  }
+  async init(config) {
+    this.config = config;
+    if (!this.config.cwd) {
+      throw new Error('ghp adapter requires "cwd" in config (path to git repo)');
+    }
+  }
+  async pull() {
+    const result = spawnSync("ghp", ["work", "--json"], {
+      cwd: this.config.cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      encoding: "utf-8"
+    });
+    if (result.status !== 0 || !result.stdout?.trim()) {
+      const raw = result.stderr?.trim() || result.stdout?.trim() || "unknown error";
+      console.error(`  Warning: ${extractErrorMessage(raw)}`);
+      return [];
+    }
+    let items;
+    try {
+      items = JSON.parse(result.stdout);
+    } catch {
+      console.error(`  Warning: ${extractErrorMessage(result.stdout.trim())}`);
+      return [];
+    }
+    const tasks = [];
+    for (const item of items) {
+      const statusTag = statusToTag(item.status);
+      const tags = [];
+      if (statusTag) tags.push(statusTag);
+      for (const label of item.labels) {
+        tags.push(label.name.toLowerCase().replace(/\s+/g, "_"));
+      }
+      const project = this.config.project ?? item.repository?.split("/")[1] ?? void 0;
+      const task = {
+        uuid: "",
+        description: item.title,
+        status: "pending",
+        entry: (/* @__PURE__ */ new Date()).toISOString(),
+        project,
+        tags,
+        priority: mapPriority(item.fields),
+        // backend and backend_id are set by the sync layer
+        backend: "",
+        backend_id: String(item.number),
+        annotations: item.url ? [{ entry: (/* @__PURE__ */ new Date()).toISOString(), description: item.url }] : void 0
+      };
+      tasks.push(task);
+    }
+    return tasks;
+  }
+  async onStart(task, ttyFd) {
+    const issueNumber = task.backend_id;
+    if (!issueNumber) {
+      process.stderr.write("tw-bridge [ghp]: task has no backend_id, skipping ghp start\n");
+      return;
+    }
+    process.stderr.write(`tw-bridge [ghp]: starting issue #${issueNumber}
+`);
+    const result = spawnSync("ghp", ["start", issueNumber], {
+      cwd: this.config.cwd,
+      stdio: [ttyFd, ttyFd, ttyFd]
+    });
+    if (result.status !== 0) {
+      throw new Error(`ghp start exited with code ${result.status}`);
+    }
+  }
+  async onDone(task) {
+    const issueNumber = task.backend_id;
+    if (!issueNumber) return;
+    process.stderr.write(`tw-bridge [ghp]: completing issue #${issueNumber}
+`);
+    const result = spawnSync("ghp", ["done", issueNumber], {
+      cwd: this.config.cwd,
+      stdio: "pipe"
+    });
+    if (result.status !== 0) {
+      throw new Error(`ghp done exited with code ${result.status}`);
+    }
+  }
+};
+
+// src/registry.ts
+var BUILTIN_ADAPTERS = {
+  ghp: () => new GhpAdapter()
+};
+function matchBackend(task, config) {
+  if (task.backend && config.backends[task.backend]) {
+    return { name: task.backend, backend: config.backends[task.backend] };
+  }
+  for (const [name, backend] of Object.entries(config.backends)) {
+    const { match } = backend;
+    if (match.tags?.length && task.tags?.some((t) => match.tags.includes(t))) {
+      return { name, backend };
+    }
+    if (match.project && task.project === match.project) {
+      return { name, backend };
+    }
+  }
+  return null;
+}
+function createAdapter(adapterType) {
+  const factory = BUILTIN_ADAPTERS[adapterType];
+  if (!factory) return null;
+  return factory();
+}
+function listAdapterTypes() {
+  return Object.keys(BUILTIN_ADAPTERS);
+}
+async function resolveAdapter(task, config) {
+  const matched = matchBackend(task, config);
+  if (!matched) return null;
+  const factory = BUILTIN_ADAPTERS[matched.backend.adapter];
+  if (!factory) {
+    process.stderr.write(`tw-bridge: unknown adapter "${matched.backend.adapter}"
+`);
+    return null;
+  }
+  const adapter = factory();
+  await adapter.init(matched.backend.config ?? {});
+  return adapter;
+}
+
+// src/taskwarrior.ts
+import { spawnSync as spawnSync2 } from "child_process";
+function getExistingTasks(backend) {
+  const result = spawnSync2(
+    "task",
+    ["backend:" + backend, "status:pending", "export"],
+    { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+  );
+  if (result.status !== 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  const tasks = JSON.parse(result.stdout || "[]");
+  const map = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    if (task.backend_id) {
+      map.set(task.backend_id, task);
+    }
+  }
+  return map;
+}
+function importTask(task) {
+  const { uuid: _, ...taskData } = task;
+  const result = spawnSync2("task", ["import"], {
+    input: JSON.stringify(taskData),
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  if (result.status !== 0) {
+    throw new Error(`task import failed: ${result.stderr?.trim()}`);
+  }
+  const match = result.stdout?.match(/([0-9a-f-]{36})/);
+  return { uuid: match?.[1] ?? "unknown" };
+}
+function updateTaskTags(existing, newTags) {
+  const existingTags = new Set(existing.tags ?? []);
+  const targetTags = new Set(newTags);
+  if (existingTags.size === targetTags.size && [...existingTags].every((t) => targetTags.has(t))) {
+    return false;
+  }
+  const args = ["task", existing.uuid, "modify"];
+  for (const tag of existingTags) {
+    if (!targetTags.has(tag)) args.push(`-${tag}`);
+  }
+  for (const tag of targetTags) {
+    if (!existingTags.has(tag)) args.push(`+${tag}`);
+  }
+  const result = spawnSync2(args[0], args.slice(1), {
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  return result.status === 0;
+}
+function ensureContext(name, tags) {
+  const check = spawnSync2("task", ["context", "show"], {
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  const existing = check.stdout ?? "";
+  const filter = tags.map((t) => `+${t}`).join(" or ");
+  const result = spawnSync2(
+    "task",
+    ["rc.confirmation=off", "context", "define", name, filter],
+    { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+  );
+  return result.status === 0;
+}
+function completeTask(existing, keepTags) {
+  const keep = new Set(keepTags);
+  const removals = (existing.tags ?? []).filter((t) => !keep.has(t)).map((t) => `-${t}`);
+  const args = ["rc.confirmation=off", existing.uuid, "modify", ...removals];
+  if (removals.length > 0) {
+    spawnSync2("task", args, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  }
+  const result = spawnSync2(
+    "task",
+    ["rc.confirmation=off", existing.uuid, "done"],
+    { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+  );
+  return result.status === 0;
+}
+function updateTaskDescription(existing, newDescription) {
+  if (existing.description === newDescription) return false;
+  const result = spawnSync2(
+    "task",
+    [existing.uuid, "modify", `description:${newDescription}`],
+    { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+  );
+  return result.status === 0;
+}
+
+// src/cli.ts
+var HOOKS_DIR = path3.join(os2.homedir(), ".task", "hooks");
+var commands = {
+  add: addBackend,
+  install,
+  sync,
+  which,
+  config: showConfig
+};
+async function main() {
+  const command = process.argv[2];
+  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("  sync      Pull tasks from all backends");
+    console.log("  which     Print the context for the current directory");
+    console.log("  config    Show current configuration");
+    return;
+  }
+  const handler = commands[command];
+  if (!handler) {
+    console.error(`Unknown command: ${command}`);
+    process.exit(1);
+  }
+  await handler();
+}
+function parseFlag(flag) {
+  const idx = process.argv.indexOf(flag);
+  return idx !== -1 ? process.argv[idx + 1] : void 0;
+}
+async function addBackend() {
+  const name = process.argv[3];
+  const adapterType = parseFlag("--adapter");
+  const tagOverride = parseFlag("--tag");
+  if (!name || name.startsWith("--")) {
+    console.error("Usage: tw-bridge add <name> --adapter <type> [--tag <context-tag>]");
+    console.error(`
+Available adapters: ${listAdapterTypes().join(", ")}`);
+    process.exit(1);
+  }
+  if (!adapterType) {
+    console.error("Missing --adapter flag.");
+    console.error(`Available adapters: ${listAdapterTypes().join(", ")}`);
+    process.exit(1);
+  }
+  const adapter = createAdapter(adapterType);
+  if (!adapter) {
+    console.error(`Unknown adapter: ${adapterType}`);
+    console.error(`Available adapters: ${listAdapterTypes().join(", ")}`);
+    process.exit(1);
+  }
+  const config = loadConfig();
+  if (config.backends[name]) {
+    console.error(`Backend "${name}" already exists. Remove it first or choose a different name.`);
+    process.exit(1);
+  }
+  const matchTag = tagOverride ?? name;
+  const cwd = process.cwd();
+  const adapterConfig = adapter.defaultConfig(cwd);
+  config.backends[name] = {
+    adapter: adapterType,
+    match: { tags: [matchTag] },
+    config: adapterConfig
+  };
+  const configPath = saveConfig(config);
+  console.log(`Added backend "${name}" (adapter: ${adapterType})`);
+  console.log(`Config: ${configPath}`);
+  console.log(`Match tag: +${matchTag}`);
+  if (adapterConfig.cwd) {
+    console.log(`Working directory: ${adapterConfig.cwd}`);
+  }
+  if (adapterConfig.project) {
+    console.log(`Project: ${adapterConfig.project}`);
+  }
+  console.log("");
+  await syncBackend(name, config.backends[name], config);
+  console.log(`
+Use 'task context ${matchTag}' to switch to this project.`);
+}
+async function install() {
+  fs2.mkdirSync(HOOKS_DIR, { recursive: true });
+  const hookSource = path3.resolve(
+    path3.dirname(new URL(import.meta.url).pathname),
+    "hooks",
+    "on-modify.js"
+  );
+  const hookTarget = path3.join(HOOKS_DIR, "on-modify.tw-bridge");
+  if (fs2.existsSync(hookTarget)) {
+    fs2.unlinkSync(hookTarget);
+  }
+  fs2.symlinkSync(hookSource, hookTarget);
+  fs2.chmodSync(hookSource, 493);
+  console.log(`Installed hook: ${hookTarget} -> ${hookSource}`);
+  console.log("\nAdd these to your .taskrc:\n");
+  console.log("# --- tw-bridge UDAs ---");
+  console.log("uda.backend.type=string");
+  console.log("uda.backend.label=Backend");
+  console.log("uda.backend_id.type=string");
+  console.log("uda.backend_id.label=Backend ID");
+  console.log("");
+  console.log("# --- Urgency coefficients (adjust to taste) ---");
+  console.log("urgency.user.tag.backlog.coefficient=0.0");
+  console.log("urgency.user.tag.todo.coefficient=1.0");
+  console.log("urgency.user.tag.in_progress.coefficient=4.0");
+  console.log("urgency.user.tag.in_review.coefficient=-2.0");
+  console.log("urgency.user.tag.ready_for_beta.coefficient=-4.0");
+  console.log("urgency.user.tag.in_beta.coefficient=-6.0");
+  installShellFunction();
+}
+var SHELL_FUNCTION = `
+# tw-bridge: auto-context task wrapper
+task() {
+  local ctx
+  ctx=$(tw-bridge which 2>/dev/null)
+  if [ -n "$ctx" ]; then
+    command task "rc.context=$ctx" "$@"
+  else
+    command task "$@"
+  fi
+}
+`.trim();
+var SHELL_MARKER = "# tw-bridge: auto-context task wrapper";
+function installShellFunction() {
+  const shell = process.env.SHELL ?? "/bin/bash";
+  const home = os2.homedir();
+  let rcFile;
+  if (shell.endsWith("zsh")) {
+    rcFile = path3.join(home, ".zshrc");
+  } else {
+    rcFile = path3.join(home, ".bashrc");
+  }
+  const existing = fs2.existsSync(rcFile) ? fs2.readFileSync(rcFile, "utf-8") : "";
+  if (existing.includes(SHELL_MARKER)) {
+    console.log(`
+Shell integration already installed in ${rcFile}`);
+    return;
+  }
+  fs2.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 = path3.join(os2.homedir(), ".config", "tw-bridge", ".seen-dirs");
+function loadSeenDirs() {
+  try {
+    const raw = fs2.readFileSync(SEEN_FILE, "utf-8");
+    return new Set(raw.split("\n").filter(Boolean));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function markDirSeen(dir) {
+  const seen = loadSeenDirs();
+  if (seen.has(dir)) return;
+  seen.add(dir);
+  fs2.mkdirSync(path3.dirname(SEEN_FILE), { recursive: true });
+  fs2.writeFileSync(SEEN_FILE, [...seen].join("\n") + "\n");
+}
+function isGitRepo(dir) {
+  try {
+    let current = dir;
+    while (current !== path3.dirname(current)) {
+      if (fs2.existsSync(path3.join(current, ".git"))) return true;
+      current = path3.dirname(current);
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+async function which() {
+  const cwd = process.cwd();
+  const config = loadConfig();
+  for (const [_name, backend] of Object.entries(config.backends)) {
+    const backendCwd = backend.config?.cwd;
+    if (!backendCwd) continue;
+    const resolved = path3.resolve(backendCwd);
+    if (cwd === resolved || cwd.startsWith(resolved + path3.sep)) {
+      const contextTag = backend.match.tags?.[0];
+      if (contextTag) {
+        process.stdout.write(contextTag);
+        return;
+      }
+    }
+  }
+  if (config.default_context) {
+    process.stdout.write(config.default_context);
+    return;
+  }
+  if (isGitRepo(cwd)) {
+    const seen = loadSeenDirs();
+    let gitRoot = cwd;
+    let current = cwd;
+    while (current !== path3.dirname(current)) {
+      if (fs2.existsSync(path3.join(current, ".git"))) {
+        gitRoot = current;
+        break;
+      }
+      current = path3.dirname(current);
+    }
+    if (!seen.has(gitRoot)) {
+      const dirName = path3.basename(gitRoot);
+      process.stderr.write(
+        `tw-bridge: unconfigured project "${dirName}". Run: tw-bridge add ${dirName} --adapter ghp
+`
+      );
+      markDirSeen(gitRoot);
+    }
+  }
+}
+async function sync() {
+  const config = loadConfig();
+  const backendNames = Object.keys(config.backends);
+  if (backendNames.length === 0) {
+    console.log("No backends configured. Use `tw-bridge add` to get started.");
+    return;
+  }
+  for (const name of backendNames) {
+    await syncBackend(name, config.backends[name], config);
+  }
+}
+async function syncBackend(name, backend, config) {
+  const adapter = await resolveAdapter(
+    { backend: name },
+    config
+  );
+  if (!adapter) {
+    console.error(`Skipping ${name}: adapter "${backend.adapter}" not found`);
+    return;
+  }
+  console.log(`Syncing ${name}...`);
+  const matchTags = backend.match.tags ?? [];
+  if (matchTags.length > 0) {
+    const contextName = matchTags[0];
+    if (ensureContext(contextName, matchTags)) {
+      console.log(`  Context "${contextName}" configured (${matchTags.map((t) => "+" + t).join(" ")})`);
+    }
+  }
+  const remoteTasks = await adapter.pull();
+  const existing = getExistingTasks(name);
+  const doneStatuses = new Set(
+    (backend.done_statuses ?? ["done"]).map((s) => s.toLowerCase())
+  );
+  for (const task of remoteTasks) {
+    task.backend = name;
+    task.tags = [...matchTags, ...task.tags ?? []];
+  }
+  let created = 0;
+  let updated = 0;
+  let completed = 0;
+  let unchanged = 0;
+  for (const task of remoteTasks) {
+    const backendId = task.backend_id;
+    const existingTask = existing.get(backendId);
+    const statusTag = task.tags?.find((t) => !matchTags.includes(t) && doneStatuses.has(t));
+    const isDone = !!statusTag;
+    if (!existingTask) {
+      if (isDone) {
+      } else {
+        const { uuid } = importTask(task);
+        console.log(`  + [#${backendId}] ${task.description} (${uuid.slice(0, 8)})`);
+        created++;
+      }
+    } else if (isDone) {
+      if (completeTask(existingTask, matchTags)) {
+        console.log(`  \u2713 [#${backendId}] ${task.description}`);
+        completed++;
+      }
+    } else {
+      let changed = false;
+      if (updateTaskDescription(existingTask, task.description)) {
+        changed = true;
+      }
+      if (updateTaskTags(existingTask, task.tags ?? [])) {
+        changed = true;
+      }
+      if (changed) {
+        console.log(`  ~ [#${backendId}] ${task.description}`);
+        updated++;
+      } else {
+        unchanged++;
+      }
+    }
+    existing.delete(backendId);
+  }
+  if (existing.size > 0) {
+    console.log(`  ${existing.size} task(s) no longer in ${name} (not modified)`);
+  }
+  console.log(`  Synced: ${created} created, ${updated} updated, ${completed} completed, ${unchanged} unchanged`);
+}
+async function showConfig() {
+  const configPath = findConfigPath();
+  if (!configPath) {
+    console.log("No config file found. Searched:");
+    console.log("  ~/.config/tw-bridge/config.json");
+    console.log("  ~/.tw-bridge.json");
+    return;
+  }
+  console.log(`Config: ${configPath}
+`);
+  const config = loadConfig();
+  console.log(JSON.stringify(config, null, 2));
+}
+main();

package/dist/hooks/on-modify.js

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+
+// src/hooks/on-modify.ts
+import fs2 from "fs";
+
+// src/config.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+var CONFIG_PATHS = [
+  path.join(os.homedir(), ".config", "tw-bridge", "config.json"),
+  path.join(os.homedir(), ".tw-bridge.json")
+];
+function findConfigPath() {
+  for (const p of CONFIG_PATHS) {
+    if (fs.existsSync(p)) return p;
+  }
+  return null;
+}
+function loadConfig() {
+  const configPath = findConfigPath();
+  if (!configPath) {
+    return { backends: {} };
+  }
+  const raw = fs.readFileSync(configPath, "utf-8");
+  return JSON.parse(raw);
+}
+
+// src/adapters/ghp.ts
+import { spawnSync } from "child_process";
+import path2 from "path";
+function statusToTag(status) {
+  if (!status) return null;
+  return status.toLowerCase().replace(/\s+/g, "_");
+}
+function mapPriority(fields) {
+  const priority = fields["Priority"]?.toLowerCase();
+  if (!priority) return void 0;
+  if (priority.startsWith("high") || priority === "urgent" || priority === "p0" || priority === "p1") return "H";
+  if (priority.startsWith("med") || priority === "p2") return "M";
+  if (priority.startsWith("low") || priority === "p3" || priority === "p4") return "L";
+  return void 0;
+}
+function extractErrorMessage(raw) {
+  const lines = raw.split("\n");
+  const meaningful = lines.find(
+    (l) => /^(fatal|error|Error):/i.test(l.trim())
+  );
+  if (meaningful) return meaningful.trim();
+  const first = lines.find(
+    (l) => l.trim() && !l.trim().startsWith("at ") && !l.includes("node:internal")
+  );
+  return first?.trim() ?? raw.split("\n")[0].trim();
+}
+var GhpAdapter = class {
+  name = "ghp";
+  config;
+  defaultConfig(cwd) {
+    return {
+      cwd,
+      project: path2.basename(cwd)
+    };
+  }
+  async init(config) {
+    this.config = config;
+    if (!this.config.cwd) {
+      throw new Error('ghp adapter requires "cwd" in config (path to git repo)');
+    }
+  }
+  async pull() {
+    const result = spawnSync("ghp", ["work", "--json"], {
+      cwd: this.config.cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      encoding: "utf-8"
+    });
+    if (result.status !== 0 || !result.stdout?.trim()) {
+      const raw = result.stderr?.trim() || result.stdout?.trim() || "unknown error";
+      console.error(`  Warning: ${extractErrorMessage(raw)}`);
+      return [];
+    }
+    let items;
+    try {
+      items = JSON.parse(result.stdout);
+    } catch {
+      console.error(`  Warning: ${extractErrorMessage(result.stdout.trim())}`);
+      return [];
+    }
+    const tasks = [];
+    for (const item of items) {
+      const statusTag = statusToTag(item.status);
+      const tags = [];
+      if (statusTag) tags.push(statusTag);
+      for (const label of item.labels) {
+        tags.push(label.name.toLowerCase().replace(/\s+/g, "_"));
+      }
+      const project = this.config.project ?? item.repository?.split("/")[1] ?? void 0;
+      const task = {
+        uuid: "",
+        description: item.title,
+        status: "pending",
+        entry: (/* @__PURE__ */ new Date()).toISOString(),
+        project,
+        tags,
+        priority: mapPriority(item.fields),
+        // backend and backend_id are set by the sync layer
+        backend: "",
+        backend_id: String(item.number),
+        annotations: item.url ? [{ entry: (/* @__PURE__ */ new Date()).toISOString(), description: item.url }] : void 0
+      };
+      tasks.push(task);
+    }
+    return tasks;
+  }
+  async onStart(task, ttyFd) {
+    const issueNumber = task.backend_id;
+    if (!issueNumber) {
+      process.stderr.write("tw-bridge [ghp]: task has no backend_id, skipping ghp start\n");
+      return;
+    }
+    process.stderr.write(`tw-bridge [ghp]: starting issue #${issueNumber}
+`);
+    const result = spawnSync("ghp", ["start", issueNumber], {
+      cwd: this.config.cwd,
+      stdio: [ttyFd, ttyFd, ttyFd]
+    });
+    if (result.status !== 0) {
+      throw new Error(`ghp start exited with code ${result.status}`);
+    }
+  }
+  async onDone(task) {
+    const issueNumber = task.backend_id;
+    if (!issueNumber) return;
+    process.stderr.write(`tw-bridge [ghp]: completing issue #${issueNumber}
+`);
+    const result = spawnSync("ghp", ["done", issueNumber], {
+      cwd: this.config.cwd,
+      stdio: "pipe"
+    });
+    if (result.status !== 0) {
+      throw new Error(`ghp done exited with code ${result.status}`);
+    }
+  }
+};
+
+// src/registry.ts
+var BUILTIN_ADAPTERS = {
+  ghp: () => new GhpAdapter()
+};
+function matchBackend(task, config) {
+  if (task.backend && config.backends[task.backend]) {
+    return { name: task.backend, backend: config.backends[task.backend] };
+  }
+  for (const [name, backend] of Object.entries(config.backends)) {
+    const { match } = backend;
+    if (match.tags?.length && task.tags?.some((t) => match.tags.includes(t))) {
+      return { name, backend };
+    }
+    if (match.project && task.project === match.project) {
+      return { name, backend };
+    }
+  }
+  return null;
+}
+async function resolveAdapter(task, config) {
+  const matched = matchBackend(task, config);
+  if (!matched) return null;
+  const factory = BUILTIN_ADAPTERS[matched.backend.adapter];
+  if (!factory) {
+    process.stderr.write(`tw-bridge: unknown adapter "${matched.backend.adapter}"
+`);
+    return null;
+  }
+  const adapter = factory();
+  await adapter.init(matched.backend.config ?? {});
+  return adapter;
+}
+
+// src/hooks/on-modify.ts
+async function main() {
+  const input = fs2.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");
+  const config = loadConfig();
+  const adapter = await resolveAdapter(newTask, config);
+  if (!adapter) return;
+  const wasStarted = !oldTask.start && !!newTask.start;
+  const wasStopped = !!oldTask.start && !newTask.start && newTask.status === "pending";
+  const wasCompleted = oldTask.status !== "completed" && newTask.status === "completed";
+  let ttyFd = null;
+  try {
+    if (wasStarted && adapter.onStart) {
+      ttyFd = fs2.openSync("/dev/tty", "r+");
+      await adapter.onStart(newTask, ttyFd);
+    } else if (wasStopped && adapter.onStop) {
+      await adapter.onStop(newTask);
+    } else if (wasCompleted && adapter.onDone) {
+      await adapter.onDone(newTask);
+    } else if (adapter.onModify) {
+      await adapter.onModify(oldTask, newTask);
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`tw-bridge [${adapter.name}]: ${msg}
+`);
+  } finally {
+    if (ttyFd !== null) fs2.closeSync(ttyFd);
+  }
+}
+main();

package/examples/config.json

@@ -0,0 +1,14 @@
+{
+  "backends": {
+    "ghp": {
+      "adapter": "ghp",
+      "match": {
+        "tags": ["ghp"]
+      },
+      "config": {
+        "cwd": "/home/bretwardjames/IdeaProjects/ghp",
+        "project": "ghp"
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@bretwardjames/tw-bridge",
+  "version": "0.1.0",
+  "description": "Taskwarrior backend bridge — unified sync and hooks for multiple task management platforms",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bretwardjames/tw-bridge.git"
+  },
+  "keywords": [
+    "taskwarrior",
+    "timewarrior",
+    "task-management",
+    "github-projects",
+    "sync"
+  ],
+  "bin": {
+    "tw-bridge": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "examples"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0"
+  }
+}