teleportation-cli 1.0.0 → 1.0.2

package/lib/remote/pr-creator.js

@@ -0,0 +1,382 @@
+/**
+ * PRCreator - GitHub Pull Request Creation Utility
+ *
+ * Handles PR creation for remote session results using GitHub CLI (gh).
+ * Generates properly formatted PR titles, descriptions with metadata,
+ * and includes timeline links and conflict warnings.
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { writeFileSync, unlinkSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+const execAsync = promisify(exec);
+
+/**
+ * PRCreator class
+ */
+export class PRCreator {
+  /**
+   * @param {Object} options
+   * @param {string} options.repoPath - Path to git repository
+   * @param {boolean} [options.verbose] - Enable verbose logging
+   */
+  constructor(options) {
+    if (!options || !options.repoPath) {
+      throw new Error('repoPath is required');
+    }
+
+    this.repoPath = options.repoPath;
+    this.verbose = options.verbose || false;
+  }
+
+  /**
+   * Execute gh CLI command (async, non-blocking)
+   * @private
+   * @param {string} command - gh command (without 'gh' prefix)
+   * @returns {Promise<string>} Command output
+   * @throws {Error} If command fails
+   */
+  async _gh(command) {
+    const fullCommand = `gh ${command}`;
+
+    if (this.verbose) {
+      console.log(`[pr-creator] ${fullCommand}`);
+    }
+
+    try {
+      const { stdout, stderr } = await execAsync(fullCommand, {
+        cwd: this.repoPath,
+        encoding: 'utf-8',
+        timeout: 30000, // 30 second timeout
+      });
+
+      if (stderr && this.verbose) {
+        console.warn(`[pr-creator] stderr: ${stderr}`);
+      }
+
+      return stdout.trim();
+    } catch (error) {
+      // Handle specific gh CLI errors
+      if (error.code === 127 || error.message.includes('command not found')) {
+        throw new Error('GitHub CLI (gh) is not installed. Install from https://cli.github.com/');
+      }
+
+      if (error.message.includes('authentication') || error.message.includes('auth')) {
+        throw new Error('GitHub authentication required. Run: gh auth login');
+      }
+
+      if (error.message.includes('pull request not found')) {
+        const prNumber = command.match(/\d+/)?.[0];
+        throw new Error(`Pull request #${prNumber} not found`);
+      }
+
+      throw error;
+    }
+  }
+
+  /**
+   * Generate PR title
+   *
+   * @param {Object} options
+   * @param {string} options.sessionId - Session ID
+   * @param {string} [options.task] - Task description
+   * @param {boolean} [options.hasConflicts] - Whether PR has conflicts
+   * @returns {string} PR title
+   */
+  generatePRTitle(options) {
+    const { sessionId, task, hasConflicts } = options;
+
+    let title = `Remote Session Results: ${sessionId}`;
+
+    if (task) {
+      // Truncate task to keep title under 100 chars
+      const maxTaskLength = 50;
+      const truncatedTask = task.length > maxTaskLength
+        ? task.substring(0, maxTaskLength) + '...'
+        : task;
+
+      title = `${truncatedTask} (${sessionId})`;
+    }
+
+    if (hasConflicts) {
+      title = `⚠️ ${title} (Conflicts)`;
+    }
+
+    // Ensure title doesn't exceed GitHub's limit
+    return title.substring(0, 100);
+  }
+
+  /**
+   * Format duration in seconds to human-readable string
+   *
+   * @param {number} seconds - Duration in seconds
+   * @returns {string} Formatted duration (e.g., "1h 23m 45s")
+   */
+  formatDuration(seconds) {
+    if (seconds === 0) return '0s';
+
+    const hours = Math.floor(seconds / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    const secs = seconds % 60;
+
+    const parts = [];
+
+    if (hours > 0) {
+      parts.push(`${hours}h`);
+      // Always show minutes when hours are present
+      parts.push(`${minutes}m`);
+    } else if (minutes > 0) {
+      parts.push(`${minutes}m`);
+    }
+
+    // Only show seconds if non-zero OR if no other parts
+    if (secs > 0 || parts.length === 0) {
+      parts.push(`${secs}s`);
+    }
+
+    return parts.join(' ');
+  }
+
+  /**
+   * Generate PR body with metadata
+   *
+   * @param {Object} options
+   * @param {string} options.task - Task description
+   * @param {string} options.sessionId - Session ID
+   * @param {string} [options.timelineUrl] - Timeline URL
+   * @param {Object} [options.conflicts] - Conflict information
+   * @param {boolean} [options.conflicts.hasConflicts] - Whether conflicts exist
+   * @param {string[]} [options.conflicts.conflictFiles] - List of conflicting files
+   * @param {Object} [options.metadata] - Session metadata
+   * @param {string} [options.metadata.provider] - Cloud provider used
+   * @param {number} [options.metadata.duration] - Session duration in seconds
+   * @param {string} [options.metadata.machineId] - Machine ID
+   * @returns {string} PR body in markdown format
+   */
+  generatePRBody(options) {
+    const { task, sessionId, timelineUrl, conflicts, metadata = {} } = options;
+
+    const sections = [];
+
+    // Task description
+    sections.push('## Task\n');
+    sections.push(task || 'No task description provided');
+    sections.push('\n');
+
+    // Conflict warning
+    if (conflicts?.hasConflicts) {
+      sections.push('## ⚠️ Conflicts Detected\n');
+      sections.push('This PR contains merge conflicts that must be resolved manually:\n');
+      sections.push('');
+
+      if (conflicts.conflictFiles && conflicts.conflictFiles.length > 0) {
+        conflicts.conflictFiles.forEach((file) => {
+          sections.push(`- \`${file}\``);
+        });
+      }
+
+      sections.push('\n**Action Required**: Review and resolve conflicts before merging.\n');
+    }
+
+    // Timeline link
+    if (timelineUrl) {
+      sections.push('## Session Timeline\n');
+      sections.push(`View the complete session timeline: [${sessionId}](${timelineUrl})\n`);
+    }
+
+    // Metadata footer
+    sections.push('---\n');
+    sections.push('## Session Metadata\n');
+    sections.push('');
+    sections.push(`- **Session ID**: \`${sessionId}\``);
+
+    if (metadata.provider) {
+      sections.push(`- **Provider**: ${metadata.provider}`);
+    }
+
+    if (metadata.duration) {
+      const duration = this.formatDuration(metadata.duration);
+      sections.push(`- **Duration**: ${duration}`);
+    }
+
+    if (metadata.machineId) {
+      sections.push(`- **Machine ID**: \`${metadata.machineId}\``);
+    }
+
+    sections.push('');
+    sections.push('---');
+    sections.push('');
+    sections.push('🤖 *Generated by [Teleportation](https://teleportation.dev) - Remote AI Coding*');
+
+    return sections.join('\n');
+  }
+
+  /**
+   * Create a pull request
+   *
+   * @param {Object} options
+   * @param {string} options.head - Head branch (remote branch with changes)
+   * @param {string} options.base - Base branch (target branch, usually main)
+   * @param {string} options.title - PR title
+   * @param {string} options.body - PR body (description)
+   * @returns {Promise<Object>} PR details
+   * @returns {number} return.number - PR number
+   * @returns {string} return.url - PR URL
+   * @returns {string} return.title - PR title
+   * @throws {Error} If PR creation fails
+   */
+  async createPR(options) {
+    const { head, base, title, body } = options;
+
+    if (!head || !base || !title || !body) {
+      throw new Error('head, base, title, and body are required for PR creation');
+    }
+
+    // Use temp file for body to avoid shell escaping issues (prevents command injection)
+    const tempFile = join(tmpdir(), `pr-body-${Date.now()}-${Math.random().toString(36).slice(2)}.md`);
+
+    try {
+      // Write body to temp file
+      writeFileSync(tempFile, body, { mode: 0o600 });
+
+      // Escape title (simple string, less risky)
+      const escapedTitle = title.replace(/"/g, '\\"');
+
+      // Use --body-file to avoid command injection via body content
+      const command = `pr create --head "${head}" --base "${base}" --title "${escapedTitle}" --body-file "${tempFile}"`;
+
+      const output = await this._gh(command);
+
+      // Extract PR URL from output
+      // gh CLI returns URL like: https://github.com/user/repo/pull/42
+      const prUrl = output.trim();
+      const prNumberMatch = prUrl.match(/\/pull\/(\d+)$/);
+
+      if (!prNumberMatch) {
+        throw new Error(`Failed to extract PR number from URL: ${prUrl}`);
+      }
+
+      const prNumber = parseInt(prNumberMatch[1], 10);
+
+      if (this.verbose) {
+        console.log(`[pr-creator] Created PR #${prNumber}: ${prUrl}`);
+      }
+
+      return {
+        number: prNumber,
+        url: prUrl,
+        title,
+      };
+    } catch (error) {
+      if (error.message.includes('pull request already exists')) {
+        throw error; // Re-throw with original message
+      }
+
+      throw new Error(`Failed to create pull request: ${error.message}`);
+    } finally {
+      // Always clean up temp file
+      try {
+        unlinkSync(tempFile);
+      } catch {
+        // Ignore cleanup errors
+      }
+    }
+  }
+
+  /**
+   * Update an existing pull request
+   *
+   * @param {Object} options
+   * @param {number} options.prNumber - PR number
+   * @param {string} [options.title] - New PR title
+   * @param {string} [options.body] - New PR body
+   * @returns {Promise<void>}
+   * @throws {Error} If PR update fails
+   */
+  async updatePR(options) {
+    const { prNumber, title, body } = options;
+
+    if (!prNumber) {
+      throw new Error('prNumber is required for PR update');
+    }
+
+    if (!title && !body) {
+      throw new Error('At least one of title or body is required for PR update');
+    }
+
+    // Use temp file for body to avoid shell escaping issues
+    let tempFile = null;
+
+    try {
+      const args = [];
+
+      if (title) {
+        const escapedTitle = title.replace(/"/g, '\\"');
+        args.push(`--title "${escapedTitle}"`);
+      }
+
+      if (body) {
+        // Write body to temp file to avoid command injection
+        tempFile = join(tmpdir(), `pr-body-${Date.now()}-${Math.random().toString(36).slice(2)}.md`);
+        writeFileSync(tempFile, body, { mode: 0o600 });
+        args.push(`--body-file "${tempFile}"`);
+      }
+
+      const command = `pr edit ${prNumber} ${args.join(' ')}`;
+      await this._gh(command);
+
+      if (this.verbose) {
+        console.log(`[pr-creator] Updated PR #${prNumber}`);
+      }
+    } catch (error) {
+      throw new Error(`Failed to update pull request: ${error.message}`);
+    } finally {
+      // Clean up temp file if created
+      if (tempFile) {
+        try {
+          unlinkSync(tempFile);
+        } catch {
+          // Ignore cleanup errors
+        }
+      }
+    }
+  }
+
+  /**
+   * Get PR status
+   *
+   * @param {number} prNumber - PR number
+   * @returns {Promise<Object>} PR status
+   * @returns {number} return.number - PR number
+   * @returns {string} return.state - PR state (OPEN, CLOSED, MERGED)
+   * @returns {string} return.title - PR title
+   * @returns {string} return.url - PR URL
+   * @returns {string} return.mergeable - Mergeable state (MERGEABLE, CONFLICTING, UNKNOWN)
+   * @throws {Error} If PR not found or query fails
+   */
+  async getPRStatus(prNumber) {
+    if (!prNumber) {
+      throw new Error('prNumber is required');
+    }
+
+    try {
+      const command = `pr view ${prNumber} --json number,state,title,url,mergeable`;
+      const output = await this._gh(command);
+
+      const prData = JSON.parse(output);
+
+      if (this.verbose) {
+        console.log(`[pr-creator] PR #${prNumber} status: ${prData.state}`);
+      }
+
+      return prData;
+    } catch (error) {
+      throw new Error(`Failed to get PR status: ${error.message}`);
+    }
+  }
+}
+
+export default PRCreator;