refactor(sync): Replace direct GitHubSyncService with SyncRegistry

- Add SyncRegistry class to manage multiple sync services
- Update TaskService to use syncRegistry instead of syncService
- Rename syncToGitHub() to syncToIntegrations() with parallel sync support
- Add integrations container to TaskMetadataSchema for multi-provider support
- Add id/displayName properties to GitHubSyncService for registry compatibility
- Update bootstrap.ts with createSyncRegistry() factory function
- Update CLI, MCP server, and index.ts to use new registry pattern
- Update tests to use SyncRegistry with mock services

This enables parallel sync to multiple integrations (GitHub, GitLab, Linear,
etc.) while maintaining backward compatibility with existing GitHub sync.

Refs #96

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: dcramer

src/bootstrap.ts

@@ -1,11 +1,9 @@
-import type { GitHubSyncConfig } from "./core/config.js";
+import type { SyncConfig } from "./core/config.js";
 import { loadConfig } from "./core/config.js";
 import type { StorageEngine } from "./core/storage/index.js";
 import { JsonlStorage } from "./core/storage/index.js";
-import {
-  createGitHubSyncService,
-  GitHubSyncService,
-} from "./core/github/index.js";
+import { SyncRegistry } from "./core/sync/index.js";
+import { createGitHubSyncService } from "./core/github/index.js";
 
 export interface ParsedGlobalOptions {
   storagePath?: string;
@@ -99,23 +97,40 @@ export function createStorageEngine(
   });
 }
 
-export interface SyncServiceResult {
-  syncService: GitHubSyncService | null;
-  syncConfig: GitHubSyncConfig | null;
+export interface SyncRegistryResult {
+  syncRegistry: SyncRegistry | null;
+  syncConfig: SyncConfig | null;
 }
 
-export function createSyncService(
+/**
+ * Create a SyncRegistry from configuration.
+ * Registers all enabled sync services based on config.
+ */
+export function createSyncRegistry(
   storagePath: string,
   cliConfigPath?: string,
-): SyncServiceResult {
+): SyncRegistryResult {
   const config = loadConfig({ storagePath, configPath: cliConfigPath });
-  const githubConfig = config.sync?.github ?? null;
+  const syncConfig = config.sync ?? null;
+
+  const registry = new SyncRegistry();
+
+  // Register GitHub sync service if configured
+  const githubService = createGitHubSyncService(
+    syncConfig?.github ?? undefined,
+    storagePath,
+  );
+  if (githubService) {
+    registry.register(githubService);
+  }
+
+  // Future: Register other sync services here
+  // if (syncConfig?.gitlab) { registry.register(createGitlabSyncService(...)); }
+  // if (syncConfig?.linear) { registry.register(createLinearSyncService(...)); }
+
   return {
-    syncService: createGitHubSyncService(
-      githubConfig ?? undefined,
-      storagePath,
-    ),
-    syncConfig: githubConfig,
+    syncRegistry: registry.hasServices() ? registry : null,
+    syncConfig,
   };
 }
 

src/cli/utils.ts

@@ -1,16 +1,16 @@
 import { TaskService } from "../core/task-service.js";
 import type { StorageEngine } from "../core/storage/index.js";
-import { GitHubSyncService } from "../core/github/index.js";
-import type { GitHubSyncConfig } from "../core/config.js";
+import type { SyncRegistry } from "../core/sync/index.js";
+import type { SyncConfig } from "../core/config.js";
 import type { Task } from "../types.js";
 import { extractErrorInfo } from "../errors.js";
 import * as readline from "readline";
 import { colors } from "./colors.js";
 
 export interface CliOptions {
   storage: StorageEngine;
-  syncService?: GitHubSyncService | null;
-  syncConfig?: GitHubSyncConfig | null;
+  syncRegistry?: SyncRegistry | null;
+  syncConfig?: SyncConfig | null;
 }
 
 // ASCII art banner for CLI headers
@@ -22,7 +22,7 @@ export const ASCII_BANNER = ` ____  _____ __ __
 export function createService(options: CliOptions): TaskService {
   return new TaskService({
     storage: options.storage,
-    syncService: options.syncService,
+    syncRegistry: options.syncRegistry,
     syncConfig: options.syncConfig,
   });
 }

src/core/github/sync.ts

@@ -82,6 +82,11 @@ export interface SyncAllOptions {
  * before code changes are pushed.
  */
 export class GitHubSyncService {
+  /** Integration ID for the SyncRegistry */
+  readonly id = "github" as const;
+  /** Human-readable name for display */
+  readonly displayName = "GitHub";
+
   private octokit: Octokit;
   private owner: string;
   private repo: string;

src/core/sync/index.ts

@@ -6,3 +6,6 @@ export type {
   SyncAllOptions,
   SyncService,
 } from "./interface.js";
+
+export { SyncRegistry } from "./registry.js";
+export type { RegisterableSyncService, LegacySyncResult } from "./registry.js";

src/core/sync/registry.ts

@@ -0,0 +1,66 @@
+import type { Task, TaskStore } from "../../types.js";
+import type { IntegrationId, SyncAllOptions } from "./interface.js";
+
+/**
+ * Result from a sync operation - loose type to support both
+ * new interface format (metadata) and legacy GitHub format (github).
+ */
+export interface LegacySyncResult {
+  taskId: string;
+  created: boolean;
+  skipped?: boolean;
+  metadata?: unknown;
+  github?: unknown;
+}
+
+/**
+ * A sync service that can be registered.
+ * This is a looser type than SyncService to allow legacy services
+ * that don't fully implement the new interface yet.
+ */
+export interface RegisterableSyncService {
+  readonly id: IntegrationId;
+  readonly displayName: string;
+  syncTask(task: Task, store: TaskStore): Promise<LegacySyncResult | null>;
+  syncAll(
+    store: TaskStore,
+    options?: SyncAllOptions,
+  ): Promise<LegacySyncResult[]>;
+}
+
+/**
+ * Registry for managing multiple sync services.
+ * Allows registering and retrieving sync services by integration ID.
+ */
+export class SyncRegistry {
+  private services: Map<IntegrationId, RegisterableSyncService> = new Map();
+
+  /**
+   * Register a sync service.
+   * Replaces any existing service with the same ID.
+   */
+  register(service: RegisterableSyncService): void {
+    this.services.set(service.id, service);
+  }
+
+  /**
+   * Get a sync service by its integration ID.
+   */
+  get(id: IntegrationId): RegisterableSyncService | undefined {
+    return this.services.get(id);
+  }
+
+  /**
+   * Get all registered sync services.
+   */
+  getAll(): RegisterableSyncService[] {
+    return Array.from(this.services.values());
+  }
+
+  /**
+   * Check if any services are registered.
+   */
+  hasServices(): boolean {
+    return this.services.size > 0;
+  }
+}

src/core/task-service.test.ts

@@ -3,7 +3,8 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
 import { TaskService } from "./task-service.js";
-import { GitHubSyncService } from "./github/index.js";
+import { SyncRegistry } from "./sync/index.js";
+import type { RegisterableSyncService } from "./sync/index.js";
 import { ValidationError } from "../errors.js";
 
 describe("TaskService", () => {
@@ -886,21 +887,24 @@ describe("TaskService", () => {
   });
 
   describe("autosync", () => {
-    let mockSyncService: {
-      syncTask: ReturnType<typeof vi.fn>;
-      getRepo: ReturnType<typeof vi.fn>;
-    };
+    let mockSyncTask: ReturnType<typeof vi.fn>;
+    let mockRegistry: SyncRegistry;
 
     beforeEach(() => {
-      mockSyncService = {
-        syncTask: vi.fn(),
-        getRepo: vi.fn(() => ({ owner: "test", repo: "test" })),
-      };
+      mockSyncTask = vi.fn();
+      const mockSyncService = {
+        id: "github" as const,
+        displayName: "GitHub",
+        syncTask: mockSyncTask,
+        syncAll: vi.fn().mockResolvedValue([]),
+      } as unknown as RegisterableSyncService;
+      mockRegistry = new SyncRegistry();
+      mockRegistry.register(mockSyncService);
     });
 
     it("saves GitHub metadata when autosync creates an issue", async () => {
       // Mock syncTask to return the task ID it was called with
-      mockSyncService.syncTask.mockImplementation(async (task) => ({
+      mockSyncTask.mockImplementation(async (task) => ({
         taskId: task.id,
         github: {
           issueNumber: 42,
@@ -913,16 +917,16 @@ describe("TaskService", () => {
 
       const syncService = new TaskService({
         storage: storagePath,
-        syncService: mockSyncService as unknown as GitHubSyncService,
-        syncConfig: { enabled: true, auto: { on_change: true } },
+        syncRegistry: mockRegistry,
+        syncConfig: { github: { enabled: true, auto: { on_change: true } } },
       });
 
       const task = await syncService.create({
         name: "Test task",
         description: "Test",
       });
 
-      expect(mockSyncService.syncTask).toHaveBeenCalled();
+      expect(mockSyncTask).toHaveBeenCalled();
 
       // Fetch the task from storage to verify metadata was saved
       const savedTask = await syncService.get(task.id);
@@ -943,7 +947,7 @@ describe("TaskService", () => {
       });
 
       // Now create a service with sync enabled
-      mockSyncService.syncTask.mockResolvedValue({
+      mockSyncTask.mockResolvedValue({
         taskId: task.id,
         github: {
           issueNumber: 99,
@@ -956,8 +960,8 @@ describe("TaskService", () => {
 
       const syncService = new TaskService({
         storage: storagePath,
-        syncService: mockSyncService as unknown as GitHubSyncService,
-        syncConfig: { enabled: true, auto: { on_change: true } },
+        syncRegistry: mockRegistry,
+        syncConfig: { github: { enabled: true, auto: { on_change: true } } },
       });
 
       await syncService.update({
@@ -984,7 +988,7 @@ describe("TaskService", () => {
       });
 
       // Now update with sync enabled
-      mockSyncService.syncTask.mockResolvedValue({
+      mockSyncTask.mockResolvedValue({
         taskId: task.id,
         github: {
           issueNumber: 55,
@@ -997,8 +1001,8 @@ describe("TaskService", () => {
 
       const syncService = new TaskService({
         storage: storagePath,
-        syncService: mockSyncService as unknown as GitHubSyncService,
-        syncConfig: { enabled: true, auto: { on_change: true } },
+        syncRegistry: mockRegistry,
+        syncConfig: { github: { enabled: true, auto: { on_change: true } } },
       });
 
       await syncService.update({
@@ -1026,7 +1030,7 @@ describe("TaskService", () => {
       await new Promise((resolve) => setTimeout(resolve, 10));
 
       // Sync returns skipped: true
-      mockSyncService.syncTask.mockResolvedValue({
+      mockSyncTask.mockResolvedValue({
         taskId: task.id,
         github: {
           issueNumber: 77,
@@ -1040,8 +1044,8 @@ describe("TaskService", () => {
 
       const syncService = new TaskService({
         storage: storagePath,
-        syncService: mockSyncService as unknown as GitHubSyncService,
-        syncConfig: { enabled: true, auto: { on_change: true } },
+        syncRegistry: mockRegistry,
+        syncConfig: { github: { enabled: true, auto: { on_change: true } } },
       });
 
       await syncService.update({
@@ -1068,7 +1072,7 @@ describe("TaskService", () => {
       });
 
       // Sync service returns parent's ID (subtasks sync their parent)
-      mockSyncService.syncTask.mockResolvedValue({
+      mockSyncTask.mockResolvedValue({
         taskId: parent.id, // Parent gets the GitHub issue, not subtask
         github: {
           issueNumber: 88,
@@ -1081,8 +1085,8 @@ describe("TaskService", () => {
 
       const syncService = new TaskService({
         storage: storagePath,
-        syncService: mockSyncService as unknown as GitHubSyncService,
-        syncConfig: { enabled: true, auto: { on_change: true } },
+        syncRegistry: mockRegistry,
+        syncConfig: { github: { enabled: true, auto: { on_change: true } } },
       });
 
       // Update subtask triggers sync