teleportation-cli 1.1.5 → 1.2.0

package/lib/teleport/git-committer.js

@@ -0,0 +1,337 @@
+/**
+ * Git Committer
+ *
+ * Manages automatic periodic commits for teleported sessions.
+ * Ensures work is preserved even if cloud sessions crash.
+ *
+ * Commit Strategy:
+ * - WIP commits every 30 minutes: "WIP: {activity} (teleport auto-save)"
+ * - Final commit on success: "Complete: {taskDescription}"
+ * - Partial commit on failure: "Partial: {accomplished} (stopped: {reason})"
+ *
+ * @module lib/teleport/git-committer
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+/**
+ * Default auto-commit interval (30 minutes)
+ * @type {number}
+ */
+export const DEFAULT_COMMIT_INTERVAL = 30 * 60 * 1000;
+
+/**
+ * GitCommitter manages automatic commits for teleported sessions.
+ */
+export class GitCommitter {
+  /**
+   * Initialize GitCommitter
+   *
+   * @param {Object} config - Configuration
+   * @param {string} config.repoPath - Path to git repository
+   * @param {string} config.branch - Branch name for commits
+   * @param {number} [config.interval] - Auto-commit interval in ms (default: 30 min)
+   * @param {string} [config.teleportId] - Teleport session ID for commit messages
+   */
+  constructor(config) {
+    if (!config) {
+      throw new Error('GitCommitter config is required');
+    }
+    if (!config.repoPath) {
+      throw new Error('repoPath is required');
+    }
+    if (!config.branch) {
+      throw new Error('branch is required');
+    }
+
+    this.repoPath = config.repoPath;
+    this.branch = config.branch;
+    this.interval = config.interval || DEFAULT_COMMIT_INTERVAL;
+    this.teleportId = config.teleportId || 'unknown';
+
+    // State
+    this.isRunning = false;
+    this.intervalId = null;
+    this.currentActivity = 'Working on task';
+    this.commitCount = 0;
+    this.lastCommitAt = null;
+    this.errors = [];
+  }
+
+  /**
+   * Start automatic commits at the configured interval.
+   *
+   * @returns {void}
+   */
+  startAutoCommit() {
+    if (this.isRunning) {
+      return; // Already running
+    }
+
+    this.isRunning = true;
+    this.intervalId = setInterval(async () => {
+      try {
+        await this.createWIPCommit(this.currentActivity);
+      } catch (error) {
+        this.errors.push({
+          type: 'wip_commit',
+          message: error.message,
+          timestamp: new Date().toISOString(),
+        });
+        // Don't stop on errors - just log and continue
+        console.error(`[git-committer] WIP commit failed: ${error.message}`);
+      }
+    }, this.interval);
+  }
+
+  /**
+   * Stop automatic commits.
+   *
+   * @returns {void}
+   */
+  stopAutoCommit() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    this.isRunning = false;
+  }
+
+  /**
+   * Update the current activity description.
+   * Used for WIP commit messages.
+   *
+   * @param {string} activity - Current activity description
+   */
+  updateActivity(activity) {
+    if (activity && typeof activity === 'string') {
+      this.currentActivity = activity.slice(0, 100); // Limit length
+    }
+  }
+
+  /**
+   * Create a WIP (Work In Progress) commit.
+   *
+   * @param {string} [activity] - Activity description for commit message
+   * @returns {Promise<Object>} Commit result
+   */
+  async createWIPCommit(activity = this.currentActivity) {
+    const message = `WIP: ${activity} (teleport auto-save)`;
+    return this._createCommit(message, 'wip');
+  }
+
+  /**
+   * Create a final commit for successful task completion.
+   *
+   * @param {string} taskDescription - Description of completed task
+   * @returns {Promise<Object>} Commit result
+   */
+  async createFinalCommit(taskDescription) {
+    const message = `Complete: ${taskDescription}`;
+    return this._createCommit(message, 'final');
+  }
+
+  /**
+   * Create a partial commit for incomplete work.
+   *
+   * @param {string} accomplished - What was accomplished
+   * @param {string} reason - Why the session stopped
+   * @returns {Promise<Object>} Commit result
+   */
+  async createPartialCommit(accomplished, reason) {
+    const message = `Partial: ${accomplished} (stopped: ${reason})`;
+    return this._createCommit(message, 'partial');
+  }
+
+  /**
+   * Create a commit with the given message.
+   *
+   * @private
+   * @param {string} message - Commit message
+   * @param {string} type - Commit type (wip, final, partial)
+   * @returns {Promise<Object>} Commit result
+   */
+  async _createCommit(message, type) {
+    const cwd = this.repoPath;
+
+    try {
+      // Check if there are changes to commit
+      const hasChanges = await this._hasChanges();
+      if (!hasChanges) {
+        return {
+          success: true,
+          skipped: true,
+          reason: 'No changes to commit',
+          type,
+        };
+      }
+
+      // Stage all changes
+      await execAsync('git add -A', { cwd });
+
+      // Create commit with teleport attribution
+      const fullMessage = `${message}\n\nTeleport-ID: ${this.teleportId}\nCommit-Type: ${type}`;
+      await execAsync(`git commit -m ${this._escapeMessage(fullMessage)}`, { cwd });
+
+      // Get commit SHA
+      const { stdout: sha } = await execAsync('git rev-parse HEAD', { cwd });
+
+      this.commitCount++;
+      this.lastCommitAt = new Date().toISOString();
+
+      return {
+        success: true,
+        skipped: false,
+        sha: sha.trim(),
+        message,
+        type,
+        timestamp: this.lastCommitAt,
+      };
+    } catch (error) {
+      // Handle "nothing to commit" gracefully
+      if (error.message.includes('nothing to commit')) {
+        return {
+          success: true,
+          skipped: true,
+          reason: 'Nothing to commit',
+          type,
+        };
+      }
+
+      throw new Error(`Commit failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Check if there are uncommitted changes.
+   *
+   * @private
+   * @returns {Promise<boolean>} True if there are changes
+   */
+  async _hasChanges() {
+    try {
+      const { stdout } = await execAsync('git status --porcelain', { cwd: this.repoPath });
+      return stdout.trim().length > 0;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Escape commit message for shell.
+   *
+   * @private
+   * @param {string} message - Message to escape
+   * @returns {string} Escaped message
+   */
+  _escapeMessage(message) {
+    // Use $'...' syntax for proper escaping
+    return `$'${message.replace(/'/g, "\\'").replace(/\n/g, "\\n")}'`;
+  }
+
+  /**
+   * Push commits to remote.
+   *
+   * @param {boolean} [force=false] - Force push (for WIP branches)
+   * @returns {Promise<Object>} Push result
+   */
+  async push(force = false) {
+    const cwd = this.repoPath;
+    const forceFlag = force ? '--force' : '';
+
+    try {
+      await execAsync(`git push origin ${this.branch} ${forceFlag}`, { cwd });
+      return { success: true };
+    } catch (error) {
+      throw new Error(`Push failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Create and checkout teleport branch.
+   *
+   * @param {string|null} baseBranch - Branch to base off of (null = current HEAD)
+   * @returns {Promise<Object>} Branch creation result
+   */
+  async createTeleportBranch(baseBranch = 'main') {
+    const cwd = this.repoPath;
+
+    try {
+      // Fetch latest (ignore errors if no remote)
+      await execAsync('git fetch origin', { cwd }).catch(() => {});
+
+      // Create branch - from origin/baseBranch if specified, otherwise from HEAD
+      if (baseBranch) {
+        try {
+          await execAsync(`git checkout -b ${this.branch} origin/${baseBranch}`, { cwd });
+        } catch {
+          // If origin/baseBranch doesn't exist, try local baseBranch
+          await execAsync(`git checkout -b ${this.branch} ${baseBranch}`, { cwd });
+        }
+      } else {
+        // Create from current HEAD
+        await execAsync(`git checkout -b ${this.branch}`, { cwd });
+      }
+
+      return { success: true, branch: this.branch };
+    } catch (error) {
+      // Branch might already exist
+      if (error.message.includes('already exists')) {
+        await execAsync(`git checkout ${this.branch}`, { cwd });
+        return { success: true, branch: this.branch, existed: true };
+      }
+      throw new Error(`Branch creation failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get commit history for this teleport session.
+   *
+   * @param {number} [limit=50] - Maximum commits to return
+   * @returns {Promise<Object[]>} Array of commit objects
+   */
+  async getCommitHistory(limit = 50) {
+    const cwd = this.repoPath;
+
+    try {
+      const { stdout } = await execAsync(
+        `git log --format="%H|%s|%ci" -n ${limit}`,
+        { cwd }
+      );
+
+      const commits = stdout
+        .trim()
+        .split('\n')
+        .filter(Boolean)
+        .map(line => {
+          const [sha, message, date] = line.split('|');
+          return { sha, message, date };
+        });
+
+      return commits;
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Get statistics about commits made.
+   *
+   * @returns {Object} Commit statistics
+   */
+  getStats() {
+    return {
+      commitCount: this.commitCount,
+      lastCommitAt: this.lastCommitAt,
+      isRunning: this.isRunning,
+      interval: this.interval,
+      branch: this.branch,
+      errors: this.errors,
+    };
+  }
+}
+
+export default GitCommitter;

package/lib/teleport/index.js

@@ -0,0 +1,48 @@
+/**
+ * Teleport Module
+ *
+ * Core module for session teleportation functionality.
+ * Enables developers to "teleport" active coding sessions to cloud dev environments.
+ *
+ * @module lib/teleport
+ */
+
+// Transcript Exporters
+export {
+  TranscriptExporter,
+  ClaudeTranscriptExporter,
+  GeminiTranscriptExporter,
+  getExporterForCoder,
+  getSupportedCoders,
+  isCoderSupported,
+  CODER_NAMES,
+} from './exporters/index.js';
+
+// Session Capture
+export {
+  captureSessionState,
+  isGitRepository,
+  captureGitState,
+  captureUncommittedChanges,
+  findClaudeTranscript,
+  getProjectSlug,
+} from './session-capture.js';
+
+// Teleport Manager
+export {
+  TeleportManager,
+  TeleportMode,
+  TeleportStatus,
+} from './manager.js';
+
+// Git Auto-Commit
+export {
+  GitCommitter,
+  DEFAULT_COMMIT_INTERVAL,
+} from './git-committer.js';
+
+// Fork Mode Tracking
+export {
+  ForkTracker,
+  ForkSessionState,
+} from './fork-tracker.js';