gitspace 0.2.0-rc.20 → 0.2.0-rc.21

package/src/commands/switch.ts

@@ -1,361 +0,0 @@
-/**
- * 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 { syncBundleWorkspaceState } from '../core/bundle-refresh.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 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);
-
-  // Keep workspace bundle metadata in sync even for --no-shell usage.
-  const bundleSync = syncBundleWorkspaceState(currentProject, workspacePath);
-  if (bundleSync.parseError) {
-    logger.warning(`Bundle parse error: ${bundleSync.parseError}`);
-  }
-
-  const projectConfig = readProjectConfig(currentProject);
-
-  // 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

@@ -1,317 +0,0 @@
-/**
- * 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})`);
-}