create-universal-ai-context 2.1.3 → 2.2.1

package/lib/cross-tool-sync/sync-service.js

@@ -0,0 +1,297 @@
+/**
+ * Cross-Tool Sync Service
+ *
+ * Background service that monitors context files and auto-syncs changes.
+ */
+
+const path = require('path');
+const { createToolContextWatcher } = require('./file-watcher');
+const { propagateContextChange, checkSyncStatus, formatSyncStatus, CONFLICT_STRATEGY } = require('./sync-manager');
+
+/**
+ * Sync service configuration
+ */
+const DEFAULT_CONFIG = {
+  // Polling interval for file changes (ms)
+  pollInterval: 1000,
+
+  // Debounce delay before triggering sync (ms)
+  debounceDelay: 2000,
+
+  // Auto-sync strategy
+  strategy: CONFLICT_STRATEGY.SOURCE_WINS,
+
+  // Enable/disable auto-sync
+  enabled: true,
+
+  // Log verbosity
+  verbose: false,
+
+  // Callbacks
+  onSyncStart: null,
+  onSyncComplete: null,
+  onError: null
+};
+
+/**
+ * Cross-tool sync service
+ */
+class SyncService {
+  constructor(projectRoot, config = {}) {
+    this.projectRoot = projectRoot;
+    this.config = { ...DEFAULT_CONFIG, ...config };
+
+    this.watcher = null;
+    this.syncTimeouts = new Map();
+    this.isRunning = false;
+    this.syncInProgress = false;
+  }
+
+  /**
+   * Start the sync service
+   */
+  start() {
+    if (this.isRunning) {
+      this.log('Sync service already running');
+      return;
+    }
+
+    this.log('Starting cross-tool sync service...');
+
+    // Create file watcher
+    this.watcher = createToolContextWatcher(this.projectRoot, {
+      pollInterval: this.config.pollInterval
+    });
+
+    // Set up event listeners
+    this.watcher.on('changed', (event) => this.handleFileChanged(event));
+    this.watcher.on('created', (event) => this.handleFileCreated(event));
+    this.watcher.on('deleted', (event) => this.handleFileDeleted(event));
+
+    // Start watching
+    this.watcher.start();
+    this.isRunning = true;
+
+    this.log('Sync service started');
+    this.log(`Watching: ${this.watcher.getWatchedPaths().join(', ')}`);
+  }
+
+  /**
+   * Stop the sync service
+   */
+  stop() {
+    if (!this.isRunning) {
+      return;
+    }
+
+    this.log('Stopping sync service...');
+
+    if (this.watcher) {
+      this.watcher.stop();
+      this.watcher.unwatchAll();
+      this.watcher = null;
+    }
+
+    // Clear any pending syncs
+    for (const timeout of this.syncTimeouts.values()) {
+      clearTimeout(timeout);
+    }
+    this.syncTimeouts.clear();
+
+    this.isRunning = false;
+    this.log('Sync service stopped');
+  }
+
+  /**
+   * Handle file changed event
+   */
+  handleFileChanged(event) {
+    const toolName = this.detectToolFromPath(event.path);
+
+    if (!toolName) {
+      return;
+    }
+
+    this.log(`Detected change in ${toolName}: ${event.path}`);
+
+    // Debounce sync
+    this.scheduleSync(toolName, event.path);
+  }
+
+  /**
+   * Handle file created event
+   */
+  handleFileCreated(event) {
+    const toolName = this.detectToolFromPath(event.path);
+
+    if (!toolName) {
+      return;
+    }
+
+    this.log(`Detected creation in ${toolName}: ${event.path}`);
+    this.scheduleSync(toolName, event.path);
+  }
+
+  /**
+   * Handle file deleted event
+   */
+  handleFileDeleted(event) {
+    const toolName = this.detectToolFromPath(event.path);
+
+    if (!toolName) {
+      return;
+    }
+
+    this.log(`Detected deletion in ${toolName}: ${event.path}`);
+    // Don't auto-sync on delete - let user handle it
+  }
+
+  /**
+   * Detect which tool a path belongs to
+   */
+  detectToolFromPath(filePath) {
+    const { TOOL_CONTEXT_FILES } = require('./sync-manager');
+
+    for (const [toolName, files] of Object.entries(TOOL_CONTEXT_FILES)) {
+      for (const file of files) {
+        const fullPath = path.join(this.projectRoot, file);
+
+        if (filePath.startsWith(fullPath) || filePath === fullPath) {
+          return toolName;
+        }
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Schedule a debounced sync
+   */
+  scheduleSync(toolName, changedPath) {
+    // Clear existing timeout for this tool
+    const existingTimeout = this.syncTimeouts.get(toolName);
+    if (existingTimeout) {
+      clearTimeout(existingTimeout);
+    }
+
+    // Schedule new sync
+    const timeout = setTimeout(async () => {
+      await this.performSync(toolName, changedPath);
+      this.syncTimeouts.delete(toolName);
+    }, this.config.debounceDelay);
+
+    this.syncTimeouts.set(toolName, timeout);
+  }
+
+  /**
+   * Perform the actual sync
+   */
+  async performSync(sourceTool, changedPath) {
+    if (this.syncInProgress) {
+      this.log('Sync already in progress, skipping');
+      return;
+    }
+
+    this.syncInProgress = true;
+
+    try {
+      this.log(`Starting sync from ${sourceTool}...`);
+
+      if (this.config.onSyncStart) {
+        this.config.onSyncStart(sourceTool, changedPath);
+      }
+
+      // Get config for project
+      const config = this.getProjectConfig();
+
+      // Propagate changes
+      const results = await propagateContextChange(
+        sourceTool,
+        this.projectRoot,
+        config,
+        this.config.strategy
+      );
+
+      if (results.errors.length > 0) {
+        this.log(`Sync completed with ${results.errors.length} errors`);
+
+        if (this.config.onError) {
+          this.config.onError(results.errors);
+        }
+      } else {
+        this.log(`Sync completed successfully`);
+        this.log(`Propagated to: ${results.propagated.map(p => p.displayName).join(', ')}`);
+      }
+
+      if (this.config.onSyncComplete) {
+        this.config.onSyncComplete(results);
+      }
+
+    } catch (error) {
+      this.log(`Sync failed: ${error.message}`);
+
+      if (this.config.onError) {
+        this.config.onError([error]);
+      }
+    } finally {
+      this.syncInProgress = false;
+    }
+  }
+
+  /**
+   * Get project configuration
+   */
+  getProjectConfig() {
+    const configPath = path.join(this.projectRoot, 'ai-context.config.json');
+
+    if (require('fs').existsSync(configPath)) {
+      try {
+        return JSON.parse(require('fs').readFileSync(configPath, 'utf-8'));
+      } catch {
+        // Fall through to defaults
+      }
+    }
+
+    return {
+      // Default config
+      includePatterns: ['**/*.{js,ts,jsx,tsx,py,go,rs,java}'],
+      excludePatterns: ['node_modules/**', '**/node_modules/**']
+    };
+  }
+
+  /**
+   * Get current sync status
+   */
+  getStatus() {
+    return checkSyncStatus(this.projectRoot);
+  }
+
+  /**
+   * Log message if verbose
+   */
+  log(message) {
+    if (this.config.verbose) {
+      console.log(`[SyncService] ${message}`);
+    }
+  }
+}
+
+/**
+ * Create and start a sync service
+ */
+function createSyncService(projectRoot, config = {}) {
+  const service = new SyncService(projectRoot, config);
+
+  if (config.autoStart !== false) {
+    service.start();
+  }
+
+  return service;
+}
+
+module.exports = {
+  SyncService,
+  createSyncService,
+  DEFAULT_CONFIG
+};

package/lib/install-hooks.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+/**
+ * Install Git Hooks for AI Context Sync
+ *
+ * Usage: Called via `npx create-ai-context hooks:install`
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function installHooks(projectRoot = process.cwd()) {
+  const hooksDir = path.join(__dirname, '..', 'templates', 'hooks');
+  const gitHooksDir = path.join(projectRoot, '.git', 'hooks');
+
+  // Hooks to install
+  const hooks = [
+    { source: 'pre-commit.hbs', target: 'pre-commit' },
+    { source: 'post-commit.hbs', target: 'post-commit' }
+  ];
+
+  function ensureDirectory(dir) {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  }
+
+  function copyHook(sourceFile, targetFile) {
+    const sourcePath = path.join(hooksDir, sourceFile);
+    const targetPath = path.join(gitHooksDir, targetFile);
+
+    if (!fs.existsSync(sourcePath)) {
+      console.warn(`Warning: ${sourceFile} not found, skipping`);
+      return false;
+    }
+
+    const content = fs.readFileSync(sourcePath, 'utf-8');
+
+    fs.writeFileSync(targetPath, content, { mode: 0o755 });
+    console.log(`✓ Installed ${targetFile}`);
+    return true;
+  }
+
+  console.log('\nInstalling AI context sync git hooks...\n');
+
+  // Check if we're in a git repository
+  if (!fs.existsSync(gitHooksDir)) {
+    console.error('Error: .git/hooks directory not found');
+    console.error('Please run this command from the root of a git repository\n');
+    throw new Error('Not a git repository');
+  }
+
+  // Ensure hooks directory exists
+  ensureDirectory(gitHooksDir);
+
+  // Copy hooks
+  let installed = 0;
+  for (const hook of hooks) {
+    if (copyHook(hook.source, hook.target)) {
+      installed++;
+    }
+  }
+
+  console.log(`\nSuccessfully installed ${installed} git hooks\n`);
+  console.log('The hooks will:');
+  console.log('  • Check sync status before commits (pre-commit)');
+  console.log('  • Auto-sync after successful commits (post-commit)\n');
+  console.log('To skip sync checks, use: git commit --no-verify\n');
+
+  return { installed, total: hooks.length };
+}
+
+module.exports = { installHooks };
+
+// If run directly
+if (require.main === module) {
+  try {
+    installHooks();
+  } catch (error) {
+    console.error('\n✖ Installation failed:', error.message);
+    process.exit(1);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-universal-ai-context",
-  "version": "2.1.3",
+  "version": "2.2.1",
   "description": "Universal AI Context Engineering - Set up context for Claude, Copilot, Cline, Antigravity, and more",
   "main": "lib/index.js",
   "bin": {

package/templates/hooks/post-commit.hbs

@@ -0,0 +1,29 @@
+#!/bin/bash
+# Post-commit hook for AI context sync
+# This hook triggers sync after successful commits
+
+# Don't block commit if this fails
+set +e
+
+# Check if ai-context binary is available
+if ! command -v create-ai-context &> /dev/null; then
+    # Try npx
+    if command -v npx &> /dev/null; then
+        AI_CONTEXT_CMD="npx create-universal-ai-context"
+    else
+        exit 0
+    fi
+else
+    AI_CONTEXT_CMD="create-ai-context"
+fi
+
+# Run background sync (async)
+echo "Syncing AI contexts in background..."
+
+# Use subshell to run in background
+(
+    sleep 2  # Wait a bit to not interfere with commit
+    $AI_CONTEXT_CMD sync:all --quiet > /dev/null 2>&1
+) &
+
+exit 0

package/templates/hooks/pre-commit.hbs

@@ -0,0 +1,46 @@
+#!/bin/bash
+# Pre-commit hook for AI context sync
+# This hook checks if AI tool contexts are out of sync
+
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+YELLOW='\033[1;33m'
+GREEN='\033[0;32m'
+NC='\033[0m' # No Color
+
+# Check if ai-context binary is available
+if ! command -v create-ai-context &> /dev/null; then
+    # Try npx
+    if command -v npx &> /dev/null; then
+        AI_CONTEXT_CMD="npx create-universal-ai-context"
+    else
+        echo -e "${YELLOW}Warning: create-ai-context not found. Skipping sync check.${NC}"
+        exit 0
+    fi
+else
+    AI_CONTEXT_CMD="create-ai-context"
+fi
+
+# Run sync check
+echo -e "${GREEN}Checking AI context sync status...${NC}"
+
+# Check for out-of-sync contexts
+CHECK_OUTPUT=$($AI_CONTEXT_CMD sync:check 2>&1)
+CHECK_EXIT_CODE=$?
+
+if [ $CHECK_EXIT_CODE -ne 0 ]; then
+    echo -e "${RED}AI contexts are out of sync!${NC}"
+    echo ""
+    echo "$CHECK_OUTPUT"
+    echo ""
+    echo -e "${YELLOW}To sync all contexts, run:${NC}"
+    echo "  $AI_CONTEXT_CMD sync:all"
+    echo ""
+    echo -e "${YELLOW}To skip this check, use: git commit --no-verify${NC}"
+    exit 1
+fi
+
+echo -e "${GREEN}AI contexts are in sync${NC}"
+exit 0