feat(sync): Introduce IntegrationService for synchronization with external systems and enhance ConfigurationManager with sync strategy support

Author: tikazyq

packages/core/src/configuration-manager.ts

@@ -13,9 +13,17 @@ import * as os from "os";
 import { EnterpriseIntegration } from "@devlog/types";
 import { StorageConfig } from "./storage/storage-provider.js";
 
+export interface SyncStrategy {
+  sourceOfTruth: 'local' | 'external' | 'manual';
+  conflictResolution: 'local-wins' | 'external-wins' | 'most-recent' | 'manual';
+  syncInterval?: number; // minutes
+  autoSync?: boolean;
+}
+
 export interface DevlogConfig {
   storage: StorageConfig;
   integrations?: EnterpriseIntegration;
+  syncStrategy?: SyncStrategy;
   workspaceRoot?: string;
   workspaceId?: string; // Added for workspace identification
 }
@@ -77,15 +85,6 @@ export class ConfigurationManager {
    * Detect the best storage configuration automatically
    */
   async detectBestStorage(): Promise<StorageConfig> {
-    // Check for enterprise integrations first
-    const integrations = await this.detectEnterpriseIntegrations();
-    if (integrations && this.hasEnterpriseIntegrations(integrations)) {
-      return {
-        type: "enterprise",
-        options: { integrations }
-      };
-    }
-
     // Check for database environment variables
     if (process.env.DATABASE_URL) {
       const dbUrl = process.env.DATABASE_URL;
@@ -152,27 +151,6 @@ export class ConfigurationManager {
     bestFor: string[];
   }> {
     return [
-      {
-        type: "enterprise",
-        name: "Enterprise Integration",
-        description: "Store devlogs directly in enterprise tools (Jira, ADO, GitHub)",
-        pros: [
-          "No local storage duplication",
-          "Integrated with existing workflows",
-          "Automatic synchronization",
-          "Enterprise-grade security"
-        ],
-        cons: [
-          "Requires enterprise tool access",
-          "Limited offline capability",
-          "Dependent on external services"
-        ],
-        bestFor: [
-          "Teams using Jira, Azure DevOps, or GitHub Issues",
-          "Enterprise environments",
-          "Distributed teams"
-        ]
-      },
       {
         type: "sqlite",
         name: "SQLite Database",
@@ -181,7 +159,8 @@ export class ConfigurationManager {
           "Fast performance",
           "Full-text search",
           "ACID transactions",
-          "No server required"
+          "No server required",
+          "Works offline"
         ],
         cons: [
           "Single-user access",
@@ -191,7 +170,8 @@ export class ConfigurationManager {
         bestFor: [
           "Individual developers",
           "Local development",
-          "Fast prototyping"
+          "Fast prototyping",
+          "Offline work"
         ]
       },
       {
@@ -202,7 +182,8 @@ export class ConfigurationManager {
           "Multi-user support",
           "Advanced querying",
           "Scalable",
-          "Full ACID compliance"
+          "Full ACID compliance",
+          "Concurrent access"
         ],
         cons: [
           "Requires database server",
@@ -212,7 +193,8 @@ export class ConfigurationManager {
         bestFor: [
           "Team collaboration",
           "Production deployments",
-          "Web applications"
+          "Web applications",
+          "Multi-user environments"
         ]
       },
       {
@@ -223,7 +205,8 @@ export class ConfigurationManager {
           "Wide adoption",
           "Good performance",
           "Multi-user support",
-          "Full-text search"
+          "Full-text search",
+          "Mature ecosystem"
         ],
         cons: [
           "Requires database server",
@@ -233,27 +216,82 @@ export class ConfigurationManager {
         bestFor: [
           "Web applications",
           "Existing MySQL infrastructure",
-          "Team collaboration"
+          "Team collaboration",
+          "LAMP stack projects"
         ]
       }
     ];
   }
 
+  /**
+   * Detect the best sync strategy based on environment and integrations
+   */
+  async detectSyncStrategy(integrations?: EnterpriseIntegration): Promise<SyncStrategy> {
+    // Default sync strategy
+    const defaultStrategy: SyncStrategy = {
+      sourceOfTruth: 'local',
+      conflictResolution: 'local-wins',
+      syncInterval: 15, // 15 minutes
+      autoSync: true
+    };
+
+    // If no integrations configured, return minimal strategy
+    if (!integrations || !this.hasEnterpriseIntegrations(integrations)) {
+      return {
+        sourceOfTruth: 'local',
+        conflictResolution: 'local-wins',
+        autoSync: false
+      };
+    }
+
+    // Check for environment-specific sync preferences
+    if (process.env.DEVLOG_SYNC_STRATEGY) {
+      const strategy = process.env.DEVLOG_SYNC_STRATEGY.toLowerCase();
+      switch (strategy) {
+        case 'external':
+          return {
+            ...defaultStrategy,
+            sourceOfTruth: 'external',
+            conflictResolution: 'external-wins'
+          };
+        case 'manual':
+          return {
+            ...defaultStrategy,
+            sourceOfTruth: 'manual',
+            conflictResolution: 'manual',
+            autoSync: false
+          };
+      }
+    }
+
+    // Configure sync interval from environment
+    if (process.env.DEVLOG_SYNC_INTERVAL) {
+      const interval = parseInt(process.env.DEVLOG_SYNC_INTERVAL);
+      if (!isNaN(interval) && interval > 0) {
+        defaultStrategy.syncInterval = interval;
+      }
+    }
+
+    return defaultStrategy;
+  }
+
   private async createDefaultConfig(): Promise<DevlogConfig> {
     const storage = await this.detectBestStorage();
     const integrations = await this.detectEnterpriseIntegrations();
+    const syncStrategy = await this.detectSyncStrategy(integrations);
     const detectedRoot = await this.detectProjectRoot();
     const workspace = await this.getWorkspaceStructure(detectedRoot || undefined);
 
     return {
       storage,
       integrations,
+      syncStrategy,
       workspaceRoot: detectedRoot || this.workspaceRoot,
       workspaceId: path.basename(workspace.workspaceDir)
     };
   }
 
-  private async detectEnterpriseIntegrations(): Promise<EnterpriseIntegration | undefined> {
+  async detectEnterpriseIntegrations(): Promise<EnterpriseIntegration | undefined> {
     const integrations: EnterpriseIntegration = {};
 
     // Check for Jira configuration

packages/core/src/devlog-manager.ts

@@ -39,24 +39,29 @@ export interface DiscoveryResult {
 }
 
 import { StorageProvider, StorageConfig, StorageProviderFactory } from "./storage/storage-provider.js";
-import { ConfigurationManager } from "./configuration-manager.js";
+import { ConfigurationManager, SyncStrategy } from "./configuration-manager.js";
+import { IntegrationService } from "./integration-service.js";
 
 export interface DevlogManagerOptions {
   workspaceRoot?: string;
   storage?: StorageConfig;
   integrations?: EnterpriseIntegration;
+  syncStrategy?: SyncStrategy;
 }
 
 export class DevlogManager {
   private storageProvider!: StorageProvider;
+  private integrationService!: IntegrationService;
   private readonly workspaceRoot: string;
   private readonly integrations?: EnterpriseIntegration;
+  private readonly syncStrategy?: SyncStrategy;
   private readonly configManager: ConfigurationManager;
   private initialized = false;
 
   constructor(private options: DevlogManagerOptions = {}) {
     this.workspaceRoot = options.workspaceRoot || process.cwd();
     this.integrations = options.integrations;
+    this.syncStrategy = options.syncStrategy;
     this.configManager = new ConfigurationManager(this.workspaceRoot);
   }
 
@@ -69,6 +74,17 @@ export class DevlogManager {
     const storageConfig = await this.determineStorageConfig();
     this.storageProvider = await StorageProviderFactory.create(storageConfig);
     await this.storageProvider.initialize();
+
+    // Initialize integration service if integrations are configured
+    const integrations = this.integrations || (await this.configManager.detectEnterpriseIntegrations());
+    const syncStrategy = this.syncStrategy || (await this.configManager.detectSyncStrategy(integrations));
+    
+    this.integrationService = new IntegrationService(
+      this.storageProvider,
+      integrations,
+      syncStrategy
+    );
+
     this.initialized = true;
   }
 
@@ -131,7 +147,8 @@ export class DevlogManager {
       }
     };
 
-    await this.storageProvider.save(entry);
+    // Save with integration sync
+    await this.integrationService.saveWithSync(entry);
     return entry;
   }
 
@@ -183,7 +200,7 @@ export class DevlogManager {
       updated.notes.push(note);
     }
 
-    await this.storageProvider.save(updated);
+    await this.integrationService.saveWithSync(updated);
     return updated;
   }
 
@@ -211,7 +228,7 @@ export class DevlogManager {
       updatedAt: new Date().toISOString()
     };
 
-    await this.storageProvider.save(updated);
+    await this.integrationService.saveWithSync(updated);
     return updated;
   }
 
@@ -439,6 +456,21 @@ export class DevlogManager {
     };
   }
 
+  /**
+   * Manually sync a devlog entry with external systems
+   */
+  async syncDevlog(id: string): Promise<DevlogEntry | null> {
+    await this.ensureInitialized();
+    return await this.integrationService.syncEntry(id);
+  }
+
+  /**
+   * Get sync status for a devlog entry
+   */
+  getSyncStatus(entry: DevlogEntry) {
+    return this.integrationService.getSyncStatus(entry);
+  }
+
   // Private methods
 
   private async ensureInitialized(): Promise<void> {
@@ -452,14 +484,6 @@ export class DevlogManager {
       return this.options.storage;
     }
 
-    // If we have enterprise integrations, prioritize them in the configuration manager
-    if (this.integrations && this.hasEnterpriseIntegrations()) {
-      return {
-        type: "enterprise",
-        options: { integrations: this.integrations }
-      };
-    }
-
     // Use ConfigurationManager to detect the best storage configuration
     // This will automatically handle ~/.devlog folder creation and usage
     return await this.configManager.detectBestStorage();

packages/core/src/index.ts

@@ -5,19 +5,24 @@ export {
   type DiscoveredDevlogEntry, 
   type DiscoveryResult 
 } from "./devlog-manager.js";
-export { ConfigurationManager, type DevlogConfig } from "./configuration-manager.js";
+export { ConfigurationManager, type DevlogConfig, type SyncStrategy } from "./configuration-manager.js";
 
-// Storage Providers
+// Integration Service
+export { 
+  IntegrationService, 
+  type SyncStatus, 
+  type ConflictData 
+} from "./integration-service.js";
+
+// Storage Providers  
 export { 
   StorageProviderFactory, 
   type StorageProvider, 
-  type StorageConfig, 
-  type EnterpriseStorageProvider 
+  type StorageConfig 
 } from "./storage/storage-provider.js";
 export { SQLiteStorageProvider } from "./storage/sqlite-storage.js";
 export { PostgreSQLStorageProvider } from "./storage/postgresql-storage.js";
 export { MySQLStorageProvider } from "./storage/mysql-storage.js";
-export { EnterpriseStorageAdapter } from "./storage/enterprise-storage.js";
 export { EnterpriseSync } from "./integrations/enterprise-sync.js";
 export { DevlogUtils } from "./utils/devlog-utils.js";