gitspace 0.2.0-rc.1

package/src/commands/switch.ts

@@ -0,0 +1,353 @@
+/**
+ * Switch command implementation
+ * Handles both 'gssh switch project' and 'gssh switch [workspace-name]'
+ */
+
+import { existsSync, readdirSync } from 'fs';
+import {
+  readGlobalConfig,
+  readProjectConfig,
+  setCurrentProject,
+  getAllProjectNames,
+  getCurrentProject,
+  getProjectWorkspacesDir,
+} from '../core/config.js';
+import { selectItem } from '../utils/prompts.js';
+import { logger } from '../utils/logger.js';
+import { openWorkspaceShell } from '../core/shell.js';
+import { getWorktreeInfo } from '../core/git.js';
+import { SpacesError, NoProjectError } from '../types/errors.js';
+import { join } from 'path';
+import { runCommandsInTerminal } from '../utils/run-commands.js';
+import { fuzzyMatch } from '../utils/fuzzy-match.js';
+import type {
+  WorkspaceCandidate,
+  RankedWorkspace,
+} from '../types/workspace-fuzzy.js';
+
+/**
+ * Switch to a different project
+ */
+export async function switchProject(projectNameArg?: string): Promise<void> {
+  const allProjects = getAllProjectNames();
+
+  if (allProjects.length === 0) {
+    throw new SpacesError(
+      'No projects found\n\nCreate a project first:\n  gssh add project',
+      'USER_ERROR',
+      1
+    );
+  }
+
+  let projectName: string;
+
+  if (projectNameArg) {
+    // Project name provided as argument
+    if (!allProjects.includes(projectNameArg)) {
+      throw new SpacesError(
+        `Project "${projectNameArg}" not found`,
+        'USER_ERROR',
+        1
+      );
+    }
+    projectName = projectNameArg;
+  } else {
+    // Select project using fzf
+    const currentProject = getCurrentProject();
+    const projectOptions = allProjects.map((name) => {
+      const config = readProjectConfig(name);
+      const indicator = name === currentProject ? ' (current)' : '';
+      return `${name} - ${config.repository}${indicator}`;
+    });
+
+    const selected = await selectItem(projectOptions, 'Select project:');
+
+    if (!selected) {
+      logger.info('Cancelled');
+      return;
+    }
+
+    // Extract project name from selection
+    projectName = selected.split(' - ')[0];
+  }
+
+  // Set as current project
+  setCurrentProject(projectName);
+  logger.success(`Switched to project: ${projectName}`);
+}
+
+/**
+ * Switch to a workspace in the current project
+ */
+export async function switchWorkspace(
+  workspaceNameArg?: string,
+  options: {
+    noShell?: boolean;
+    force?: boolean;
+  } = {}
+): Promise<void> {
+  // Get current project
+  const currentProject = getCurrentProject();
+  if (!currentProject) {
+    throw new NoProjectError();
+  }
+
+  const projectConfig = readProjectConfig(currentProject);
+  const workspacesDir = getProjectWorkspacesDir(currentProject);
+
+  // Check if workspaces directory exists
+  if (!existsSync(workspacesDir)) {
+    throw new SpacesError(
+      `No workspaces found in project "${currentProject}"\n\nCreate a workspace first:\n  gssh add`,
+      'USER_ERROR',
+      1
+    );
+  }
+
+  // Get all workspace directories
+  const workspaces = readdirSync(workspacesDir).filter((entry) => {
+    const path = join(workspacesDir, entry);
+    return existsSync(path) && readdirSync(path).length > 0; // Not empty
+  });
+
+  if (workspaces.length === 0) {
+    throw new SpacesError(
+      `No workspaces found in project "${currentProject}"\n\nCreate a workspace first:\n  gssh add`,
+      'USER_ERROR',
+      1
+    );
+  }
+
+  let workspaceName: string;
+
+  if (workspaceNameArg) {
+    // Try exact match first (backward compatible)
+    if (workspaces.includes(workspaceNameArg)) {
+      workspaceName = workspaceNameArg;
+    } else {
+      // No exact match - try fuzzy matching
+      logger.debug(`No exact match for "${workspaceNameArg}", trying fuzzy match...`);
+
+      const candidates = await gatherWorkspaceCandidates(
+        workspacesDir,
+        workspaces
+      );
+
+      const matches = fuzzyMatch(workspaceNameArg, candidates);
+
+      if (matches.length === 0) {
+        throw new SpacesError(
+          `No workspaces match "${workspaceNameArg}"\n\nAvailable workspaces:\n${workspaces.map(w => '  - ' + w).join('\n')}`,
+          'USER_ERROR',
+          1
+        );
+      }
+
+      // Rank matches
+      const ranked = rankMatches(matches);
+
+      // If only one match or force flag, use directly
+      if (ranked.length === 1 || options.force) {
+        workspaceName = ranked[0].workspace.name;
+        logger.info(`Fuzzy matched "${workspaceNameArg}" → ${workspaceName}`);
+      } else {
+        // Multiple matches - show interactive selection
+        const selected = await selectFromRanked(ranked, workspaceNameArg);
+
+        if (!selected) {
+          logger.info('Cancelled');
+          return;
+        }
+
+        workspaceName = selected.name;
+      }
+    }
+  } else {
+    // Get workspace info for display
+    const workspaceOptions: string[] = [];
+
+    for (const workspace of workspaces) {
+      const workspacePath = join(workspacesDir, workspace);
+      const info = await getWorktreeInfo(workspacePath);
+
+      if (info) {
+        const statusParts: string[] = [];
+
+        // Add ahead/behind info
+        if (info.ahead > 0 || info.behind > 0) {
+          statusParts.push(`[${info.branch} +${info.ahead} -${info.behind}]`);
+        } else {
+          statusParts.push(`[${info.branch}]`);
+        }
+
+        // Add uncommitted changes
+        if (info.uncommittedChanges > 0) {
+          statusParts.push(`${info.uncommittedChanges} uncommitted`);
+        } else {
+          statusParts.push('clean');
+        }
+
+        const display = `${workspace.padEnd(30)} ${statusParts.join(' ')}`;
+        workspaceOptions.push(display);
+      } else {
+        workspaceOptions.push(workspace);
+      }
+    }
+
+    const selected = await selectItem(workspaceOptions, 'Select workspace:');
+
+    if (!selected) {
+      logger.info('Cancelled');
+      return;
+    }
+
+    // Extract workspace name (first part before padding)
+    workspaceName = selected.split(/\s+/)[0];
+  }
+
+  const workspacePath = join(workspacesDir, workspaceName);
+
+  // Switch to workspace
+  if (options.noShell) {
+    logger.success(`Workspace: ${workspacePath}`);
+    logger.log(`\nTo navigate:\n  cd ${workspacePath}`);
+  } else {
+    // Open workspace shell
+    await openWorkspaceShell(
+      workspacePath,
+      currentProject,
+      projectConfig.repository,
+      false // never skip setup on switch
+    );
+  }
+}
+
+/**
+ * Gather workspace candidates with metadata for fuzzy matching
+ *
+ * @param workspacesDir Path to workspaces directory
+ * @param workspaceNames Array of workspace names
+ * @returns Array of workspace candidates with metadata
+ */
+async function gatherWorkspaceCandidates(
+  workspacesDir: string,
+  workspaceNames: string[]
+): Promise<WorkspaceCandidate[]> {
+  const candidates: WorkspaceCandidate[] = [];
+
+  for (const name of workspaceNames) {
+    const path = join(workspacesDir, name);
+    const info = await getWorktreeInfo(path);
+
+    if (info) {
+      candidates.push({
+        name: info.name,
+        path: info.path,
+        branch: info.branch,
+        ahead: info.ahead,
+        behind: info.behind,
+        uncommittedChanges: info.uncommittedChanges,
+        lastCommit: info.lastCommit,
+      });
+    }
+  }
+
+  return candidates;
+}
+
+/**
+ * Rank fuzzy matches with additional scoring
+ *
+ * Additional ranking factors:
+ * - Shorter workspace names get +5 bonus (easier to type)
+ *
+ * @param matches Fuzzy match results
+ * @returns Ranked workspace results
+ */
+function rankMatches(
+  matches: Array<{ item: WorkspaceCandidate; score: number; matchedIndices: number[] }>
+): RankedWorkspace[] {
+  const ranked: RankedWorkspace[] = matches.map((match) => {
+    let finalScore = match.score;
+
+    // Bonus for shorter names (easier to remember/type)
+    if (match.item.name.length <= 15) {
+      finalScore += 5;
+    }
+
+    return {
+      workspace: match.item,
+      matchScore: match.score,
+      finalScore,
+      matchedIndices: match.matchedIndices,
+    };
+  });
+
+  // Sort by final score
+  ranked.sort((a, b) => b.finalScore - a.finalScore);
+
+  return ranked;
+}
+
+/**
+ * Display ranked workspaces and prompt for selection
+ *
+ * @param ranked Ranked workspace results
+ * @param query Original query (for display)
+ * @returns Selected workspace or null if cancelled
+ */
+async function selectFromRanked(
+  ranked: RankedWorkspace[],
+  query: string
+): Promise<WorkspaceCandidate | null> {
+  // Format each workspace for display
+  const choices = ranked.map((r) => formatWorkspaceChoice(r));
+
+  const selected = await selectItem(
+    choices,
+    `Multiple matches for "${query}":`
+  );
+
+  if (!selected) {
+    return null;
+  }
+
+  // Parse workspace name from selection (first part before padding)
+  const workspaceName = selected.split(/\s+/)[0];
+  const workspace = ranked.find((r) => r.workspace.name === workspaceName);
+
+  return workspace ? workspace.workspace : null;
+}
+
+/**
+ * Format a ranked workspace for display in selection list
+ *
+ * Format: "name    [branch +A -B] status"
+ * Example: "my-feature    [main +2 -0] clean"
+ *
+ * @param ranked Ranked workspace
+ * @returns Formatted string for display
+ */
+function formatWorkspaceChoice(ranked: RankedWorkspace): string {
+  const ws = ranked.workspace;
+  const parts: string[] = [];
+
+  // Workspace name (padded to 30 chars for alignment)
+  parts.push(ws.name.padEnd(30));
+
+  // Branch info with ahead/behind
+  if (ws.ahead > 0 || ws.behind > 0) {
+    parts.push(`[${ws.branch} +${ws.ahead} -${ws.behind}]`);
+  } else {
+    parts.push(`[${ws.branch}]`);
+  }
+
+  // Uncommitted changes or clean status
+  if (ws.uncommittedChanges > 0) {
+    parts.push(`${ws.uncommittedChanges} uncommitted`);
+  } else {
+    parts.push('clean');
+  }
+
+  return parts.join(' ');
+}

package/src/commands/tmux.ts

@@ -0,0 +1,317 @@
+/**
+ * tmux-lite daemon management commands
+ *
+ * Commands:
+ *   gssh tmux start       - Start the tmux-lite server daemon
+ *   gssh tmux stop        - Stop the tmux-lite server daemon
+ *   gssh tmux status      - Show server status
+ *   gssh tmux list        - List sessions
+ *   gssh tmux new [name]  - Create and attach to a new session
+ *   gssh tmux attach <id> - Attach to a session
+ *   gssh tmux kill <id>   - Kill a session
+ */
+
+import { logger } from "../utils/logger.js";
+import {
+  ensureServer,
+  isServerRunning,
+  getServerPid,
+  isProcessRunning,
+  cleanupStalePidFile,
+  getStatus,
+  killServer,
+  listSessions,
+  createSession,
+  killSession,
+  attach,
+  isNested,
+  getRouterSocket,
+  getPidFile,
+  PACKAGE_VERSION,
+  type Session,
+} from "../lib/tmux-lite/cli.js";
+
+/**
+ * Format uptime in human-readable format
+ */
+function formatUptime(seconds: number): string {
+  if (seconds < 60) return `${seconds}s`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+  const hours = Math.floor(seconds / 3600);
+  const mins = Math.floor((seconds % 3600) / 60);
+  return `${hours}h ${mins}m`;
+}
+
+/**
+ * Start the tmux-lite server daemon
+ */
+export async function startTmux(): Promise<void> {
+  // Clean up any stale PID file first
+  cleanupStalePidFile();
+
+  if (await isServerRunning()) {
+    const pid = getServerPid();
+    logger.info(`tmux-lite server already running${pid ? ` (pid ${pid})` : ""}`);
+    return;
+  }
+
+  logger.log("Starting tmux-lite server...");
+  await ensureServer();
+
+  const pid = getServerPid();
+  logger.success(`tmux-lite server started${pid ? ` (pid ${pid})` : ""}`);
+
+  // Force exit since child process reference may keep event loop alive
+  process.exit(0);
+}
+
+/**
+ * Stop the tmux-lite server daemon
+ */
+export async function stopTmux(options: { force?: boolean } = {}): Promise<void> {
+  // Clean up any stale PID file first
+  cleanupStalePidFile();
+
+  if (!(await isServerRunning())) {
+    logger.info("tmux-lite server not running");
+    return;
+  }
+
+  // Check for active sessions
+  try {
+    const sessions = await listSessions();
+    const activeSessions = sessions.filter((s) => !s.exitCode);
+
+    if (activeSessions.length > 0 && !options.force) {
+      logger.warning(
+        `Warning: ${activeSessions.length} active session(s) will be terminated`
+      );
+      logger.log("Sessions:");
+      for (const s of activeSessions) {
+        const status = s.attached ? "\x1b[32m●\x1b[0m" : "\x1b[90m○\x1b[0m";
+        logger.log(`  ${status} ${s.id}: ${s.name}`);
+      }
+      logger.log("");
+      logger.log("Use --force to stop anyway");
+      return;
+    }
+  } catch {
+    // Ignore errors listing sessions
+  }
+
+  logger.log("Stopping tmux-lite server...");
+  await killServer();
+  logger.success("tmux-lite server stopped");
+}
+
+/**
+ * Show tmux-lite server status
+ */
+export async function statusTmux(): Promise<void> {
+  // Clean up any stale PID file first
+  const wasStale = cleanupStalePidFile();
+  if (wasStale) {
+    logger.dim("(cleaned up stale PID file)");
+  }
+
+  const pid = getServerPid();
+  const pidAlive = pid !== null && isProcessRunning(pid);
+  const socketResponds = await isServerRunning();
+
+  // Build status output
+  const box = (lines: string[]) => {
+    const width = 44;
+    const top = "┌─ tmux-lite " + "─".repeat(width - 13) + "┐";
+    const bottom = "└" + "─".repeat(width) + "┘";
+    const padded = lines.map((l) => {
+      const visible = l.replace(/\x1b\[[0-9;]*m/g, ""); // Strip ANSI for length calc
+      const padding = width - visible.length;
+      return "│ " + l + " ".repeat(Math.max(0, padding - 1)) + "│";
+    });
+    return [top, ...padded, bottom].join("\n");
+  };
+
+  if (!socketResponds) {
+    // Server not running
+    const lines = [
+      `Status:   \x1b[90m○ not running\x1b[0m`,
+      "",
+      `Run: \x1b[36mgssh tmux start\x1b[0m`,
+    ];
+    logger.log(box(lines));
+    return;
+  }
+
+  // Server is running - get detailed status
+  try {
+    const status = await getStatus();
+    const statusIcon = "\x1b[32m●\x1b[0m"; // Green dot
+    const attachedStr =
+      status.attached > 0
+        ? `(${status.attached} attached)`
+        : "";
+
+    const lines = [
+      `Status:   ${statusIcon} running (pid ${status.pid})`,
+      `Version:  ${status.version}`,
+      `Socket:   ${getRouterSocket()}`,
+      `Sessions: ${status.sessions} total ${attachedStr}`,
+      `Uptime:   ${formatUptime(status.uptime)}`,
+    ];
+    logger.log(box(lines));
+  } catch (err) {
+    // Fallback if status query fails
+    const lines = [
+      `Status:   \x1b[32m●\x1b[0m running${pid ? ` (pid ${pid})` : ""}`,
+      `Version:  ${PACKAGE_VERSION}`,
+      `Socket:   ${getRouterSocket()}`,
+    ];
+    logger.log(box(lines));
+  }
+}
+
+/**
+ * List tmux-lite sessions
+ */
+export async function listTmux(): Promise<void> {
+  // Clean up any stale PID file first
+  cleanupStalePidFile();
+
+  if (!(await isServerRunning())) {
+    logger.info("tmux-lite server not running");
+    logger.dim("Run: gssh tmux start");
+    return;
+  }
+
+  const sessions = await listSessions();
+
+  if (sessions.length === 0) {
+    logger.log("No sessions");
+    return;
+  }
+
+  logger.log("Sessions:");
+  for (const s of sessions) {
+    const age = Math.floor((Date.now() - s.createdAt) / 1000);
+    const ageStr =
+      age < 60
+        ? `${age}s`
+        : age < 3600
+          ? `${Math.floor(age / 60)}m`
+          : `${Math.floor(age / 3600)}h`;
+    const status = s.attached ? "\x1b[32m●\x1b[0m" : "\x1b[90m○\x1b[0m";
+    const exited = s.exitCode !== undefined ? ` \x1b[31m(exited ${s.exitCode})\x1b[0m` : "";
+    const title = s.processTitle ? ` \x1b[33m[${s.processTitle}]\x1b[0m` : "";
+    logger.log(`  ${status} ${s.id}: ${s.name} (${ageStr})${title}${exited}`);
+    logger.dim(`      ${s.cwd}`);
+  }
+}
+
+/**
+ * Create and attach to a new tmux-lite session
+ */
+export async function newTmux(name?: string): Promise<void> {
+  // Check for nested session
+  if (isNested()) {
+    logger.error("Already inside a tmux-lite session");
+    logger.dim("Detach first with Ctrl+Esc");
+    return;
+  }
+
+  // Clean up any stale PID file first
+  cleanupStalePidFile();
+
+  // Ensure server is running
+  if (!(await isServerRunning())) {
+    logger.log("Starting tmux-lite server...");
+    await ensureServer();
+  }
+
+  const cwd = process.cwd();
+  const session = await createSession(name || "session", cwd);
+
+  logger.log(`Created session: ${session.name} (id: ${session.id})`);
+  logger.dim("Ctrl+Esc to detach\n");
+
+  const result = await attach(session, true);
+
+  if (result.type === "exited") {
+    process.exit(result.code);
+  } else if (result.type === "error") {
+    logger.error(result.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Attach to an existing tmux-lite session
+ */
+export async function attachTmux(id: string, options: { force?: boolean } = {}): Promise<void> {
+  // Check for nested session
+  if (isNested()) {
+    logger.error("Already inside a tmux-lite session");
+    logger.dim("Detach first with Ctrl+Esc");
+    return;
+  }
+
+  // Clean up any stale PID file first
+  cleanupStalePidFile();
+
+  if (!(await isServerRunning())) {
+    logger.error("tmux-lite server not running");
+    logger.dim("Run: gssh tmux start");
+    return;
+  }
+
+  const sessions = await listSessions();
+  const session = sessions.find((s) => s.id === id || s.name === id);
+
+  if (!session) {
+    logger.error(`Session not found: ${id}`);
+    logger.dim("Run: gssh tmux list");
+    return;
+  }
+
+  if (session.attached && !options.force) {
+    logger.warning(`Session ${session.name} is attached elsewhere`);
+    logger.dim("Use --force to take over");
+    return;
+  }
+
+  logger.log(`Attaching to: ${session.name} (id: ${session.id})`);
+  logger.dim("Ctrl+Esc to detach\n");
+
+  const result = await attach(session, true);
+
+  if (result.type === "exited") {
+    process.exit(result.code);
+  } else if (result.type === "error") {
+    logger.error(result.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Kill a tmux-lite session
+ */
+export async function killTmux(id: string): Promise<void> {
+  // Clean up any stale PID file first
+  cleanupStalePidFile();
+
+  if (!(await isServerRunning())) {
+    logger.error("tmux-lite server not running");
+    return;
+  }
+
+  const sessions = await listSessions();
+  const session = sessions.find((s) => s.id === id || s.name === id);
+
+  if (!session) {
+    logger.error(`Session not found: ${id}`);
+    logger.dim("Run: gssh tmux list");
+    return;
+  }
+
+  await killSession(session.id);
+  logger.success(`Killed session: ${session.name} (id: ${session.id})`);
+}