teleportation-cli 1.0.0

package/lib/cli/session-commands.js

@@ -0,0 +1,294 @@
+#!/usr/bin/env node
+/**
+ * CLI Commands for Session Registry Management
+ */
+
+import {
+  listSessions,
+  getSession,
+  getActiveSessionsInRepo,
+  detectConflicts,
+  cleanupStaleSessions,
+  getSessionStats,
+  completeSession,
+  pauseSession,
+  resumeSession
+} from '../session-registry/manager.js';
+import { getCurrentSessionId } from '../worktree/manager.js';
+
+/**
+ * List all sessions
+ */
+export async function commandSessionList(args) {
+  const { status, repoOnly = false } = args;
+
+  try {
+    let sessions;
+
+    if (repoOnly) {
+      sessions = await getActiveSessionsInRepo();
+    } else {
+      sessions = await listSessions(status);
+    }
+
+    if (sessions.length === 0) {
+      console.log('No sessions found.');
+      return;
+    }
+
+    console.log('\nRegistered Sessions:\n');
+    console.log(
+      'SESSION ID'.padEnd(25),
+      'AGENT'.padEnd(15),
+      'BRANCH'.padEnd(25),
+      'STATUS'.padEnd(12),
+      'LAST ACTIVE'
+    );
+    console.log('-'.repeat(100));
+
+    for (const session of sessions) {
+      const lastActive = new Date(session.lastActiveAt).toLocaleString();
+      console.log(
+        session.id.padEnd(25),
+        session.agent.padEnd(15),
+        session.branch.padEnd(25),
+        session.status.padEnd(12),
+        lastActive
+      );
+    }
+
+    // Show current session if we're in one
+    const currentSessionId = getCurrentSessionId();
+    if (currentSessionId) {
+      console.log(`\n→ Current session: ${currentSessionId}`);
+    }
+
+    return sessions;
+  } catch (error) {
+    console.error(`Failed to list sessions: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * Show session details
+ */
+export async function commandSessionInfo(args) {
+  const { sessionId } = args;
+
+  try {
+    let targetSessionId = sessionId;
+
+    // If no session ID, try to get current
+    if (!targetSessionId) {
+      targetSessionId = getCurrentSessionId();
+      if (!targetSessionId) {
+        throw new Error('Not in a worktree. Specify --session-id to get info for a specific session.');
+      }
+    }
+
+    const session = await getSession(targetSessionId);
+
+    if (!session) {
+      throw new Error(`Session not found: ${targetSessionId}`);
+    }
+
+    console.log('\nSession Information:\n');
+    console.log(`Session ID:    ${session.id}`);
+    console.log(`Agent:         ${session.agent}`);
+    console.log(`Branch:        ${session.branch}`);
+    console.log(`Worktree:      ${session.worktreePath}`);
+    console.log(`Repository:    ${session.repoRoot}`);
+    console.log(`Status:        ${session.status}`);
+    console.log(`Started:       ${new Date(session.startedAt).toLocaleString()}`);
+    console.log(`Last Active:   ${new Date(session.lastActiveAt).toLocaleString()}`);
+
+    if (session.modifiedFiles.length > 0) {
+      console.log(`\nModified Files (${session.modifiedFiles.length}):`);
+      session.modifiedFiles.slice(0, 15).forEach(file => {
+        console.log(`  - ${file}`);
+      });
+      if (session.modifiedFiles.length > 15) {
+        console.log(`  ... and ${session.modifiedFiles.length - 15} more`);
+      }
+    } else {
+      console.log('\nNo modified files tracked.');
+    }
+
+    return session;
+  } catch (error) {
+    console.error(`Failed to get session info: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * Check for conflicts between sessions
+ */
+export async function commandCheckConflicts(args) {
+  const { sessionId } = args;
+
+  try {
+    let targetSessionId = sessionId;
+
+    // If no session ID, try to get current
+    if (!targetSessionId) {
+      targetSessionId = getCurrentSessionId();
+      if (!targetSessionId) {
+        throw new Error('Not in a worktree. Specify --session-id to check conflicts for a specific session.');
+      }
+    }
+
+    console.log(`Checking for conflicts with session: ${targetSessionId}\n`);
+
+    const conflicts = await detectConflicts(targetSessionId);
+
+    if (conflicts.length === 0) {
+      console.log('✓ No conflicts detected with other active sessions.');
+      return [];
+    }
+
+    console.log(`⚠ Found conflicts with ${conflicts.length} other session(s):\n`);
+
+    for (const conflict of conflicts) {
+      console.log(`Session: ${conflict.sessionId}`);
+      console.log(`  Agent: ${conflict.agent}`);
+      console.log(`  Branch: ${conflict.branch}`);
+      console.log(`  Conflicting files:`);
+      conflict.conflictingFiles.forEach(file => {
+        console.log(`    - ${file}`);
+      });
+      console.log();
+    }
+
+    console.log('Recommendation: Coordinate with other sessions before merging.');
+    console.log('Consider creating a snapshot before proceeding with any merges.');
+
+    return conflicts;
+  } catch (error) {
+    console.error(`Failed to check conflicts: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * Show session statistics
+ */
+export async function commandSessionStats() {
+  try {
+    const stats = await getSessionStats();
+
+    console.log('\nSession Statistics:\n');
+    console.log(`Total Sessions:     ${stats.total}`);
+    console.log(`Active:             ${stats.active}`);
+    console.log(`Paused:             ${stats.paused}`);
+    console.log(`Completed:          ${stats.completed}`);
+
+    return stats;
+  } catch (error) {
+    console.error(`Failed to get session stats: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * Pause a session
+ */
+export async function commandSessionPause(args) {
+  const { sessionId } = args;
+
+  try {
+    let targetSessionId = sessionId;
+
+    // If no session ID, try to get current
+    if (!targetSessionId) {
+      targetSessionId = getCurrentSessionId();
+      if (!targetSessionId) {
+        throw new Error('Not in a worktree. Specify --session-id to pause a specific session.');
+      }
+    }
+
+    await pauseSession(targetSessionId);
+    console.log(`✓ Session paused: ${targetSessionId}`);
+
+    return true;
+  } catch (error) {
+    console.error(`Failed to pause session: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * Resume a session
+ */
+export async function commandSessionResume(args) {
+  const { sessionId } = args;
+
+  try {
+    let targetSessionId = sessionId;
+
+    // If no session ID, try to get current
+    if (!targetSessionId) {
+      targetSessionId = getCurrentSessionId();
+      if (!targetSessionId) {
+        throw new Error('Not in a worktree. Specify --session-id to resume a specific session.');
+      }
+    }
+
+    await resumeSession(targetSessionId);
+    console.log(`✓ Session resumed: ${targetSessionId}`);
+
+    return true;
+  } catch (error) {
+    console.error(`Failed to resume session: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * Complete a session
+ */
+export async function commandSessionComplete(args) {
+  const { sessionId } = args;
+
+  try {
+    let targetSessionId = sessionId;
+
+    // If no session ID, try to get current
+    if (!targetSessionId) {
+      targetSessionId = getCurrentSessionId();
+      if (!targetSessionId) {
+        throw new Error('Not in a worktree. Specify --session-id to complete a specific session.');
+      }
+    }
+
+    await completeSession(targetSessionId);
+    console.log(`✓ Session marked as completed: ${targetSessionId}`);
+
+    return true;
+  } catch (error) {
+    console.error(`Failed to complete session: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * Clean up stale sessions
+ */
+export async function commandSessionCleanup() {
+  try {
+    console.log('Cleaning up stale sessions...');
+    const count = await cleanupStaleSessions();
+
+    if (count === 0) {
+      console.log('No stale sessions found.');
+    } else {
+      console.log(`✓ Cleaned up ${count} stale session(s)`);
+    }
+
+    return count;
+  } catch (error) {
+    console.error(`Failed to cleanup sessions: ${error.message}`);
+    throw error;
+  }
+}

package/lib/cli/snapshot-commands.js

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+/**
+ * CLI Commands for Snapshot Management
+ */
+
+import {
+  createSnapshot,
+  restoreSnapshot,
+  listSnapshots,
+  deleteSnapshot,
+  deleteAllSnapshots,
+  getSnapshotDiff,
+  SnapshotType
+} from '../snapshot/manager.js';
+import { getCurrentSessionId } from '../worktree/manager.js';
+
+/**
+ * Create a snapshot
+ */
+export async function commandSnapshotCreate(args) {
+  const {
+    sessionId,
+    type = SnapshotType.CHECKPOINT,
+    message = ''
+  } = args;
+
+  try {
+    let targetSessionId = sessionId;
+
+    // If no session ID, try to get current
+    if (!targetSessionId) {
+      targetSessionId = getCurrentSessionId();
+      if (!targetSessionId) {
+        throw new Error('Not in a worktree. Specify --session-id to create snapshot for a specific session.');
+      }
+    }
+
+    console.log(`Creating ${type} snapshot for session: ${targetSessionId}`);
+    if (message) {
+      console.log(`Message: ${message}`);
+    }
+
+    const snapshot = await createSnapshot(targetSessionId, type, message);
+
+    console.log(`✓ Snapshot created: ${snapshot.id}`);
+    console.log(`  Type: ${snapshot.type}`);
+    console.log(`  Branch: ${snapshot.branch}`);
+    console.log(`  Commit: ${snapshot.commitHash.substring(0, 8)}`);
+    console.log(`  Timestamp: ${new Date(snapshot.timestamp).toLocaleString()}`);
+
+    if (snapshot.stashRef) {
+      console.log(`  Stash: ${snapshot.stashRef}`);
+    }
+
+    return snapshot;
+  } catch (error) {
+    console.error(`Failed to create snapshot: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * List snapshots
+ */
+export async function commandSnapshotList(args) {
+  const { sessionId } = args;
+
+  try {
+    let targetSessionId = sessionId;
+
+    // If no session ID, try to get current
+    if (!targetSessionId) {
+      targetSessionId = getCurrentSessionId();
+      if (!targetSessionId) {
+        throw new Error('Not in a worktree. Specify --session-id to list snapshots for a specific session.');
+      }
+    }
+
+    const snapshots = await listSnapshots(targetSessionId);
+
+    if (snapshots.length === 0) {
+      console.log(`No snapshots found for session: ${targetSessionId}`);
+      return;
+    }
+
+    console.log(`\nSnapshots for session: ${targetSessionId}\n`);
+    console.log('ID'.padEnd(50), 'TYPE'.padEnd(15), 'DATE'.padEnd(25), 'MESSAGE');
+    console.log('-'.repeat(120));
+
+    for (const snapshot of snapshots) {
+      const date = new Date(snapshot.timestamp).toLocaleString();
+      const msg = snapshot.message || '(no message)';
+      console.log(
+        snapshot.id.padEnd(50),
+        snapshot.type.padEnd(15),
+        date.padEnd(25),
+        msg.substring(0, 30)
+      );
+    }
+
+    return snapshots;
+  } catch (error) {
+    console.error(`Failed to list snapshots: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * Restore a snapshot
+ */
+export async function commandSnapshotRestore(args) {
+  const { snapshotId, force = false } = args;
+
+  if (!snapshotId) {
+    throw new Error('Snapshot ID is required (--snapshot-id or -s)');
+  }
+
+  try {
+    console.log(`Restoring snapshot: ${snapshotId}`);
+
+    if (!force) {
+      console.log('WARNING: This will overwrite your current working directory.');
+      console.log('Use --force to confirm.');
+      return false;
+    }
+
+    await restoreSnapshot(snapshotId, force);
+
+    console.log(`✓ Snapshot restored: ${snapshotId}`);
+    console.log('Your working directory has been restored to the snapshot state.');
+
+    return true;
+  } catch (error) {
+    console.error(`Failed to restore snapshot: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * Show diff between current state and snapshot
+ */
+export async function commandSnapshotDiff(args) {
+  const { snapshotId } = args;
+
+  if (!snapshotId) {
+    throw new Error('Snapshot ID is required (--snapshot-id or -s)');
+  }
+
+  try {
+    const diff = await getSnapshotDiff(snapshotId);
+
+    if (!diff || diff.trim().length === 0) {
+      console.log('No differences found.');
+      return '';
+    }
+
+    console.log(diff);
+    return diff;
+  } catch (error) {
+    console.error(`Failed to get snapshot diff: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * Delete a snapshot
+ */
+export async function commandSnapshotDelete(args) {
+  const { snapshotId, force = false } = args;
+
+  if (!snapshotId) {
+    throw new Error('Snapshot ID is required (--snapshot-id or -s)');
+  }
+
+  try {
+    if (!force) {
+      console.log(`This will permanently delete snapshot: ${snapshotId}`);
+      console.log('Use --force to confirm.');
+      return false;
+    }
+
+    await deleteSnapshot(snapshotId);
+    console.log(`✓ Snapshot deleted: ${snapshotId}`);
+
+    return true;
+  } catch (error) {
+    console.error(`Failed to delete snapshot: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * Delete all snapshots for a session
+ */
+export async function commandSnapshotDeleteAll(args) {
+  const { sessionId, force = false } = args;
+
+  try {
+    let targetSessionId = sessionId;
+
+    // If no session ID, try to get current
+    if (!targetSessionId) {
+      targetSessionId = getCurrentSessionId();
+      if (!targetSessionId) {
+        throw new Error('Not in a worktree. Specify --session-id to delete snapshots for a specific session.');
+      }
+    }
+
+    if (!force) {
+      console.log(`This will permanently delete ALL snapshots for session: ${targetSessionId}`);
+      console.log('Use --force to confirm.');
+      return false;
+    }
+
+    const count = await deleteAllSnapshots(targetSessionId);
+    console.log(`✓ Deleted ${count} snapshot(s)`);
+
+    return count;
+  } catch (error) {
+    console.error(`Failed to delete snapshots: ${error.message}`);
+    throw error;
+  }
+}