teleportation-cli 1.0.0 → 1.0.1

package/lib/remote/providers/provider-factory.js

@@ -0,0 +1,228 @@
+/**
+ * Provider Factory for Intelligent Provider Selection
+ *
+ * Automatically selects the best cloud provider (Fly.io or Daytona) based on:
+ * - Task description analysis
+ * - Estimated duration
+ * - Keyword detection
+ * - User preferences
+ */
+
+import { FlyProvider } from './fly-provider.js';
+import { DaytonaProvider } from './daytona-provider.js';
+
+export class ProviderFactory {
+  /**
+   * Initialize ProviderFactory
+   * @param {Object} config - Factory configuration
+   * @param {VaultClient} config.vaultClient - Mech Vault client (required)
+   * @param {LivePortClient} config.livePortClient - LivePort client (required)
+   * @param {string} [config.flyApiToken] - Fly.io API token
+   * @param {string} [config.daytonaApiKey] - Daytona API key
+   * @param {string} [config.defaultProvider] - Default provider ('fly' or 'daytona')
+   */
+  constructor(config = {}) {
+    if (!config.vaultClient) {
+      throw new Error('VaultClient is required');
+    }
+    if (!config.livePortClient) {
+      throw new Error('LivePortClient is required');
+    }
+
+    this.config = config;
+    this.vaultClient = config.vaultClient;
+    this.livePortClient = config.livePortClient;
+    this.defaultProvider = config.defaultProvider || 'daytona';
+
+    // Keywords that suggest long-running tasks (prefer Fly)
+    this.flyKeywords = [
+      'overnight', 'multi-day', 'several days', 'long-running',
+      'migration', 'migrate', 'load test', 'stress test', 'benchmark',
+      'hours', 'days', 'extended', 'persistent',
+    ];
+
+    // Keywords that suggest quick tasks (prefer Daytona)
+    this.daytonaKeywords = [
+      'quick', 'fast', 'review', 'pr', 'pull request',
+      'feature', 'branch', 'bug fix', 'hotfix',
+      'test', 'experiment', 'prototype', 'spike',
+    ];
+  }
+
+  /**
+   * Select the best provider based on task description
+   *
+   * Decision logic:
+   * 1. If provider explicitly specified in options, use it
+   * 2. Analyze task description for duration indicators
+   * 3. Match keywords to provider preferences
+   * 4. Default to Daytona for quick, ephemeral tasks
+   *
+   * @param {string} taskDescription - Description of the task to perform
+   * @param {Object} [options] - Selection options
+   * @param {string} [options.provider] - Force specific provider ('fly' or 'daytona')
+   * @returns {string} Selected provider type ('fly' or 'daytona')
+   */
+  selectProvider(taskDescription, options = {}) {
+    // 1. Explicit override takes precedence
+    if (options.provider) {
+      return options.provider;
+    }
+
+    // 2. Estimate task duration
+    const duration = this._estimateDuration(taskDescription);
+
+    // 3. Analyze keywords
+    const keywords = this._analyzeKeywords(taskDescription);
+
+    // 4. Decision logic
+    if (duration === 'long') {
+      return 'fly';
+    }
+
+    // Check for Fly-specific keywords
+    const hasFlyKeyword = this.flyKeywords.some(keyword =>
+      taskDescription.toLowerCase().includes(keyword)
+    );
+
+    if (hasFlyKeyword) {
+      return 'fly';
+    }
+
+    // Default to Daytona for quick, ephemeral tasks
+    return 'daytona';
+  }
+
+  /**
+   * Create a provider instance of the specified type
+   *
+   * @param {string} type - Provider type ('fly' or 'daytona')
+   * @param {Object} [providerConfig] - Provider-specific configuration
+   * @returns {FlyProvider|DaytonaProvider} Provider instance
+   * @throws {Error} If provider type is unknown
+   */
+  createProvider(type, providerConfig = {}) {
+    const baseConfig = {
+      vaultClient: this.vaultClient,
+      livePortClient: this.livePortClient,
+    };
+
+    switch (type) {
+      case 'fly':
+        return new FlyProvider({
+          ...baseConfig,
+          flyApiToken: this.config.flyApiToken,
+          ...providerConfig,
+        });
+
+      case 'daytona':
+        return new DaytonaProvider({
+          ...baseConfig,
+          daytonaApiKey: this.config.daytonaApiKey,
+          ...providerConfig,
+        });
+
+      default:
+        throw new Error(`Unknown provider type: ${type}`);
+    }
+  }
+
+  /**
+   * Select provider and create instance in one step
+   *
+   * Convenience method that combines selectProvider() and createProvider().
+   *
+   * @param {string} taskDescription - Description of the task to perform
+   * @param {Object} [options] - Selection and provider options
+   * @param {string} [options.provider] - Force specific provider ('fly' or 'daytona')
+   * @returns {FlyProvider|DaytonaProvider} Configured provider instance
+   */
+  selectAndCreate(taskDescription, options = {}) {
+    const providerType = this.selectProvider(taskDescription, options);
+
+    // Separate provider override from provider-specific config
+    const { provider, ...providerConfig } = options;
+
+    return this.createProvider(providerType, providerConfig);
+  }
+
+  /**
+   * Estimate task duration from description
+   *
+   * @private
+   * @param {string} taskDescription - Task description
+   * @returns {string} Duration estimate ('short' or 'long')
+   */
+  _estimateDuration(taskDescription) {
+    const lowerDesc = taskDescription.toLowerCase();
+
+    // Long duration indicators
+    const longIndicators = [
+      'overnight', 'multi-day', 'several days', 'multiple days',
+      'long-running', 'extended', 'hours', 'days',
+      'migration', 'refactor', 'refactoring',
+    ];
+
+    for (const indicator of longIndicators) {
+      if (lowerDesc.includes(indicator)) {
+        return 'long';
+      }
+    }
+
+    // Short duration by default
+    return 'short';
+  }
+
+  /**
+   * Analyze task description for provider-specific keywords
+   *
+   * @private
+   * @param {string} taskDescription - Task description
+   * @returns {string[]} Array of matched keywords
+   */
+  _analyzeKeywords(taskDescription) {
+    const lowerDesc = taskDescription.toLowerCase();
+    const matched = [];
+
+    // Check Fly keywords
+    for (const keyword of this.flyKeywords) {
+      if (lowerDesc.includes(keyword)) {
+        matched.push(keyword);
+      }
+    }
+
+    // Check Daytona keywords
+    for (const keyword of this.daytonaKeywords) {
+      if (lowerDesc.includes(keyword)) {
+        matched.push(keyword);
+      }
+    }
+
+    return matched;
+  }
+
+  /**
+   * Get default configuration for a provider type
+   *
+   * @param {string} type - Provider type ('fly' or 'daytona')
+   * @returns {Object} Default configuration for the provider
+   */
+  getDefaultProviderConfig(type) {
+    switch (type) {
+      case 'fly':
+        return {
+          region: 'iad', // Ashburn, VA
+          appName: 'teleportation-remote',
+        };
+
+      case 'daytona':
+        return {
+          profileId: 'default',
+          autoStopMinutes: 60,
+        };
+
+      default:
+        return {};
+    }
+  }
+}

package/lib/remote/results-delivery.js

@@ -0,0 +1,333 @@
+/**
+ * Results Delivery - Remote Session Results Handler
+ *
+ * Delivers results from remote sessions back to local repository using
+ * a fallback strategy:
+ * 1. Try to create Pull Request (preferred)
+ * 2. Fallback to pushing to a local branch
+ * 3. Handles conflict detection and resolution
+ */
+
+import { GitHandoff } from '../handoff/git-handoff.js';
+import { PRCreator } from './pr-creator.js';
+
+/**
+ * ResultsDelivery class
+ */
+export class ResultsDelivery {
+  /**
+   * @param {Object} options
+   * @param {string} options.repoPath - Path to git repository
+   * @param {string} options.sessionId - Session ID
+   * @param {string} options.remoteBranch - Remote branch with results (e.g., teleport/wip-session-123)
+   * @param {boolean} [options.verbose] - Enable verbose logging
+   */
+  constructor(options) {
+    if (!options || !options.repoPath) {
+      throw new Error('repoPath is required');
+    }
+
+    if (!options.sessionId) {
+      throw new Error('sessionId is required');
+    }
+
+    if (!options.remoteBranch) {
+      throw new Error('remoteBranch is required');
+    }
+
+    this.repoPath = options.repoPath;
+    this.sessionId = options.sessionId;
+    this.remoteBranch = options.remoteBranch;
+    this.verbose = options.verbose || false;
+
+    // Create GitHandoff for git operations
+    this.gitHandoff = options.gitHandoff || new GitHandoff({
+      repoPath: this.repoPath,
+      sessionId: this.sessionId,
+      verbose: this.verbose,
+    });
+
+    // Create PRCreator for GitHub PR operations
+    this.prCreator = options.prCreator || new PRCreator({
+      repoPath: this.repoPath,
+      verbose: this.verbose,
+    });
+  }
+
+  /**
+   * Execute git command via GitHandoff
+   * @private
+   * @param {string} command - Git command (without 'git' prefix)
+   * @returns {Promise<string>} Command output
+   */
+  async _git(command) {
+    return this.gitHandoff.git(command);
+  }
+
+  /**
+   * Detect conflicts with remote branch
+   *
+   * Performs a dry-run merge to detect if merging the remote branch
+   * would cause conflicts. Uses try-finally pattern to ensure cleanup
+   * even if process is interrupted.
+   *
+   * @returns {Promise<Object>} Conflict details
+   * @returns {boolean} return.hasConflicts - Whether conflicts exist
+   * @returns {string[]} return.conflictFiles - Array of conflicting files
+   * @throws {Error} If conflict detection fails
+   */
+  async detectConflicts() {
+    let mergeStarted = false;
+
+    try {
+      // Fetch remote branch
+      await this._git(`fetch origin ${this.remoteBranch}`);
+
+      // Try merge with --no-commit --no-ff to simulate merge without actually committing
+      try {
+        await this._git(`merge --no-commit --no-ff origin/${this.remoteBranch}`);
+        mergeStarted = true;
+
+        // No conflicts - merge succeeded
+        return {
+          hasConflicts: false,
+          conflictFiles: [],
+        };
+      } catch (mergeError) {
+        mergeStarted = true;
+
+        // Check if this is a conflict error
+        const status = await this._git('status --porcelain');
+
+        const conflictFiles = status
+          .split('\n')
+          .filter(line => {
+            // Conflict markers: UU (both modified), AA (both added), etc.
+            return line.startsWith('UU') || line.startsWith('AA') || line.startsWith('DD') ||
+                   line.startsWith('AU') || line.startsWith('UA') || line.startsWith('DU') ||
+                   line.startsWith('UD');
+          })
+          .map(line => line.slice(3).trim());
+
+        if (conflictFiles.length > 0) {
+          return {
+            hasConflicts: true,
+            conflictFiles,
+          };
+        }
+
+        // Some other merge error (not a conflict)
+        throw mergeError;
+      }
+    } catch (error) {
+      throw new Error(`Failed to detect conflicts: ${error?.message || error}`);
+    } finally {
+      // Always attempt to abort merge, even on success or error
+      // This ensures repo is never left in merge state
+      if (mergeStarted) {
+        try {
+          await this._git('merge --abort');
+          if (this.verbose) {
+            console.log('[results-delivery] Merge aborted, repo clean');
+          }
+        } catch (abortError) {
+          // Log warning but don't fail - repo might already be clean
+          if (this.verbose) {
+            console.warn(`[results-delivery] Merge abort warning: ${abortError?.message || abortError}`);
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Push remote branch to a new local branch
+   *
+   * @param {Object} [options]
+   * @param {string} [options.localBranch] - Local branch name (defaults to remote-results/{sessionId})
+   * @returns {Promise<Object>} Push result
+   * @returns {string} return.branch - Local branch name
+   * @returns {string} return.commit - Commit hash
+   * @returns {string} return.strategy - Always 'branch'
+   * @throws {Error} If branch creation fails
+   */
+  async pushToBranch(options = {}) {
+    const { localBranch = `remote-results/${this.sessionId}` } = options;
+
+    try {
+      // Fetch remote branch
+      await this._git(`fetch origin ${this.remoteBranch}`);
+
+      // Create local branch from remote branch
+      await this._git(`branch ${localBranch} origin/${this.remoteBranch}`);
+
+      // Get commit hash
+      const commit = await this._git(`rev-parse ${localBranch}`);
+
+      if (this.verbose) {
+        console.log(`[results-delivery] Created local branch: ${localBranch}`);
+      }
+
+      return {
+        branch: localBranch,
+        commit: commit.trim(),
+        strategy: 'branch',
+      };
+    } catch (error) {
+      throw new Error(`Failed to push to branch: ${error?.message || error}`);
+    }
+  }
+
+  /**
+   * Create pull request with results
+   *
+   * @param {Object} options
+   * @param {string} options.task - Task description
+   * @param {string} [options.baseBranch] - Base branch (defaults to current branch)
+   * @param {string} [options.timelineUrl] - Timeline URL
+   * @param {Object} [options.conflicts] - Conflict details
+   * @param {boolean} [options.conflicts.hasConflicts] - Whether conflicts exist
+   * @param {string[]} [options.conflicts.conflictFiles] - Conflicting files
+   * @param {Object} [options.metadata] - Session metadata
+   * @returns {Promise<Object>} PR result
+   * @returns {number} return.prNumber - PR number
+   * @returns {string} return.prUrl - PR URL
+   * @returns {string} return.strategy - Always 'pr'
+   * @throws {Error} If PR creation fails
+   */
+  async createPullRequest(options) {
+    const { task, baseBranch, timelineUrl, conflicts, metadata } = options;
+
+    try {
+      // Fetch remote branch to ensure it exists
+      await this._git(`fetch origin ${this.remoteBranch}`);
+
+      // Get current branch as base if not specified
+      const base = baseBranch || await this.gitHandoff.getCurrentBranch();
+
+      // Generate PR title and body
+      const title = this.prCreator.generatePRTitle({
+        sessionId: this.sessionId,
+        task,
+        hasConflicts: conflicts?.hasConflicts || false,
+      });
+
+      const body = this.prCreator.generatePRBody({
+        task,
+        sessionId: this.sessionId,
+        timelineUrl,
+        conflicts,
+        metadata,
+      });
+
+      // Create PR
+      const pr = await this.prCreator.createPR({
+        head: this.remoteBranch,
+        base,
+        title,
+        body,
+      });
+
+      if (this.verbose) {
+        console.log(`[results-delivery] Created PR #${pr.number}: ${pr.url}`);
+      }
+
+      return {
+        prNumber: pr.number,
+        prUrl: pr.url,
+        strategy: 'pr',
+      };
+    } catch (error) {
+      throw new Error(`Failed to create pull request: ${error?.message || error}`);
+    }
+  }
+
+  /**
+   * Deliver results using fallback strategy
+   *
+   * Strategy:
+   * 1. Detect conflicts first
+   * 2. If conflicts exist, always create PR (never auto-merge conflicts)
+   * 3. If no conflicts, try PR creation
+   * 4. If PR creation fails, fallback to branch creation
+   *
+   * @param {Object} options
+   * @param {string} options.task - Task description
+   * @param {string} [options.baseBranch] - Base branch for PR
+   * @param {string} [options.timelineUrl] - Timeline URL
+   * @param {Object} [options.metadata] - Session metadata
+   * @returns {Promise<Object>} Delivery result
+   * @returns {boolean} return.success - Whether delivery succeeded
+   * @returns {string} return.strategy - Strategy used ('pr' or 'branch')
+   * @returns {number} [return.prNumber] - PR number (if strategy='pr')
+   * @returns {string} [return.prUrl] - PR URL (if strategy='pr')
+   * @returns {string} [return.branch] - Branch name (if strategy='branch')
+   * @returns {string} [return.commit] - Commit hash (if strategy='branch')
+   * @returns {Object} [return.conflicts] - Conflict details (if conflicts detected)
+   * @returns {Object} [return.metadata] - Session metadata
+   * @throws {Error} If all strategies fail
+   */
+  async deliverResults(options) {
+    const { task, baseBranch, timelineUrl, metadata } = options;
+
+    try {
+      // Step 1: Detect conflicts
+      const conflicts = await this.detectConflicts();
+
+      if (this.verbose && conflicts.hasConflicts) {
+        console.log(`[results-delivery] Conflicts detected: ${conflicts.conflictFiles.join(', ')}`);
+      }
+
+      // Step 2: Try PR creation (preferred)
+      try {
+        const prResult = await this.createPullRequest({
+          task,
+          baseBranch,
+          timelineUrl,
+          conflicts: conflicts.hasConflicts ? conflicts : undefined,
+          metadata,
+        });
+
+        return {
+          success: true,
+          strategy: 'pr',
+          prNumber: prResult.prNumber,
+          prUrl: prResult.prUrl,
+          conflicts: conflicts.hasConflicts ? conflicts : undefined,
+          metadata,
+        };
+      } catch (prError) {
+        if (this.verbose) {
+          console.log(`[results-delivery] PR creation failed: ${prError.message}`);
+        }
+
+        // Step 3: Fallback to branch creation
+        try {
+          const branchResult = await this.pushToBranch();
+
+          if (this.verbose) {
+            console.log(`[results-delivery] Created local branch: ${branchResult.branch}`);
+          }
+
+          return {
+            success: true,
+            strategy: 'branch',
+            branch: branchResult.branch,
+            commit: branchResult.commit,
+            conflicts: conflicts.hasConflicts ? conflicts : undefined,
+            metadata,
+          };
+        } catch (branchError) {
+          // Both strategies failed
+          throw new Error(
+            `Failed to deliver results. PR creation: ${prError.message}. Branch creation: ${branchError.message}`
+          );
+        }
+      }
+    } catch (error) {
+      throw new Error(`Failed to deliver results: ${error?.message || error}`);
+    }
+  }
+}
+
+export default ResultsDelivery;