gitspace 0.2.0-rc.2 → 0.2.0-rc.21

package/src/commands/add.ts

@@ -1,452 +0,0 @@
-/**
- * Add command implementation
- * Handles both 'gssh add project' and 'gssh add [workspace-name]'
- */
-
-import { existsSync, mkdirSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import {
-  readProjectConfig,
-  createProject,
-  setCurrentProject,
-  getProjectBaseDir,
-  getProjectWorkspacesDir,
-  getCurrentProject,
-  getAllProjectNames,
-  projectExists,
-  getScriptsPhaseDir,
-  updateProjectConfig,
-} from '../core/config.js';
-import { checkGitHubAuth, ensureDependencies } from '../utils/deps.js';
-import { selectItem, promptConfirm, promptPassword, promptInput } from '../utils/prompts.js';
-import { logger } from '../utils/logger.js';
-import { listAllRepos, cloneRepository } from '../core/github.js';
-import {
-  getDefaultBranch,
-  createWorktree,
-  checkRemoteBranch,
-  listRemoteBranches,
-} from '../core/git.js';
-import { openWorkspaceShell } from '../core/shell.js';
-import { fetchUnstartedIssues } from '../core/linear.js';
-import {
-  sanitizeForFileSystem,
-  generateWorkspaceName,
-  isValidWorkspaceName,
-  extractRepoName,
-} from '../utils/sanitize.js';
-import {
-  SpacesError,
-  NoProjectError,
-  ProjectExistsError,
-  WorkspaceExistsError,
-} from '../types/errors.js';
-import type { CreateWorkspaceOptions } from '../types/workspace.js';
-import { runScriptsInTerminal } from '../utils/run-scripts.js';
-import { hasSetupBeenRun } from '../utils/workspace-state.js';
-import { generateMarkdown } from '../utils/markdown.js';
-import {
-  detectBundleInRepo,
-  loadBundleFromPath,
-  loadBundleFromUrl,
-  copyBundleScripts,
-  cleanupBundleDir,
-} from '../core/bundle.js';
-import { runOnboarding } from '../utils/onboarding.js';
-import type { LoadedBundle, OnboardingResult } from '../types/bundle.js';
-
-/**
- * Add a new project
- */
-export async function addProject(options: {
-  noClone?: boolean;
-  org?: string;
-  linearKey?: string;
-  bundleUrl?: string;
-  bundlePath?: string;
-  skipBundle?: boolean;
-}): Promise<void> {
-  // Check dependencies
-  await ensureDependencies();
-  await checkGitHubAuth();
-
-  // List all GitHub repositories
-  logger.info('Fetching repositories...');
-  const repos = await listAllRepos(options.org);
-
-  if (repos.length === 0) {
-    throw new SpacesError(
-      'No repositories found',
-      'USER_ERROR',
-      1
-    );
-  }
-
-  // Select repository
-  const selectedRepo = await selectItem(repos, 'Select a repository:');
-
-  if (!selectedRepo) {
-    logger.info('Cancelled');
-    return;
-  }
-
-  logger.success(`Selected: ${selectedRepo}`);
-
-  // Extract repo name for project directory
-  const projectName = extractRepoName(selectedRepo);
-
-  // Check if project already exists
-  if (projectExists(projectName)) {
-    throw new ProjectExistsError(
-      projectName,
-      getProjectBaseDir(projectName)
-    );
-  }
-
-  // Check for duplicate repositories
-  const existingProjects = getAllProjectNames();
-  for (const existingProject of existingProjects) {
-    const existingConfig = readProjectConfig(existingProject);
-    if (existingConfig.repository === selectedRepo) {
-      throw new SpacesError(
-        `Repository ${selectedRepo} is already tracked by project "${existingProject}"\n\nTo use that project:\n  gssh switch project ${existingProject}`,
-        'USER_ERROR',
-        1
-      );
-    }
-  }
-
-  // Clone the repository unless --no-clone
-  const baseDir = getProjectBaseDir(projectName);
-
-  if (!options.noClone) {
-    logger.info(`Cloning to ${baseDir}...`);
-    await cloneRepository(selectedRepo, baseDir);
-    logger.success(`Cloned to ${baseDir}`);
-  }
-
-  // Detect default branch
-  const baseBranch = await getDefaultBranch(baseDir);
-  logger.debug(`Detected default branch: ${baseBranch}`);
-
-  // Handle bundle detection and loading
-  let loadedBundle: LoadedBundle | null = null;
-  let onboardingResult: OnboardingResult | null = null;
-
-  if (!options.skipBundle) {
-    if (options.bundleUrl) {
-      // Load from explicit URL
-      loadedBundle = await loadBundleFromUrl(options.bundleUrl);
-    } else if (options.bundlePath) {
-      // Load from explicit local path
-      loadedBundle = loadBundleFromPath(options.bundlePath);
-    } else if (!options.noClone) {
-      // Detect bundle in cloned repo
-      const bundleDir = detectBundleInRepo(baseDir);
-      if (bundleDir) {
-        loadedBundle = loadBundleFromPath(bundleDir);
-        logger.info(`Detected spaces bundle: ${loadedBundle.bundle.name}`);
-      }
-    }
-
-    // Run onboarding if bundle has steps
-    if (loadedBundle?.bundle.onboarding && loadedBundle.bundle.onboarding.length > 0) {
-      const proceed = await promptConfirm(
-        `This repository has ${loadedBundle.bundle.onboarding.length} onboarding step(s). Run them now?`,
-        true
-      );
-
-      if (proceed) {
-        onboardingResult = await runOnboarding(loadedBundle.bundle.onboarding);
-
-        if (!onboardingResult.completed) {
-          const continueAnyway = await promptConfirm(
-            'Continue creating project without completing onboarding?',
-            false
-          );
-          if (!continueAnyway) {
-            // Clean up bundle temp dir if from URL
-            if (loadedBundle) {
-              cleanupBundleDir(loadedBundle.bundleDir);
-            }
-            logger.info('Cancelled');
-            return;
-          }
-        }
-      }
-    }
-  }
-
-  // Ask about Linear integration
-  const useLinear = await promptConfirm('Does this project use Linear?', false);
-
-  let linearApiKey: string | undefined;
-  let linearTeamKey: string | undefined;
-
-  if (useLinear) {
-    if (!options.linearKey) {
-      linearApiKey = await promptPassword('Enter Linear API key:') || undefined;
-    } else {
-      linearApiKey = options.linearKey;
-    }
-
-    linearTeamKey = await promptInput('Enter Linear team key (optional, e.g., ENG):') || undefined;
-  }
-
-  // Create project configuration
-  createProject(
-    projectName,
-    selectedRepo,
-    baseBranch,
-    linearApiKey,
-    linearTeamKey
-  );
-
-  // Copy bundle scripts if bundle was loaded
-  if (loadedBundle) {
-    copyBundleScripts(loadedBundle.bundleDir, projectName);
-
-    // Store bundle values and info in project config
-    const configUpdates: Record<string, unknown> = {};
-
-    if (onboardingResult?.completed && Object.keys(onboardingResult.configValues).length > 0) {
-      configUpdates.bundleValues = onboardingResult.configValues;
-    }
-
-    configUpdates.appliedBundle = {
-      name: loadedBundle.bundle.name,
-      version: loadedBundle.bundle.version,
-      source: loadedBundle.source,
-      appliedAt: new Date().toISOString(),
-    };
-
-    updateProjectConfig(projectName, configUpdates);
-
-    // Clean up temp directory if bundle was from URL
-    cleanupBundleDir(loadedBundle.bundleDir);
-  }
-
-  logger.success(`Project '${projectName}' created`);
-
-  // Set as current project
-  setCurrentProject(projectName);
-  logger.success('Set as current project');
-}
-
-/**
- * Add a new workspace
- */
-export async function addWorkspace(
-  workspaceNameArg?: string,
-  options: Partial<CreateWorkspaceOptions> = {}
-): Promise<void> {
-  // Get current project
-  const currentProject = getCurrentProject();
-  if (!currentProject) {
-    throw new NoProjectError();
-  }
-
-  const projectConfig = readProjectConfig(currentProject);
-  const baseDir = getProjectBaseDir(currentProject);
-  const workspacesDir = getProjectWorkspacesDir(currentProject);
-
-  let workspaceName: string;
-  let branchName: string;
-
-  let existsRemotely = false;
-  let selectedLinearIssue: Awaited<ReturnType<typeof fetchUnstartedIssues>>[0] | undefined;
-
-  if (workspaceNameArg) {
-    // Workspace name provided as argument
-    if (!isValidWorkspaceName(workspaceNameArg)) {
-      throw new SpacesError(
-        `Invalid workspace name: ${workspaceNameArg}\nWorkspace names must contain only alphanumeric characters, hyphens, and underscores (no spaces).`,
-        'USER_ERROR',
-        1
-      );
-    }
-
-    workspaceName = workspaceNameArg;
-    branchName = options.branchName || workspaceName;
-  } else {
-    // No workspace name provided, prompt for source
-    const sourceOptions = ['Create from GitHub branch', 'Create with manual name'];
-
-    // Add Linear option if configured
-    if (projectConfig.linearApiKey) {
-      sourceOptions.splice(1, 0, 'Create from Linear issue');
-    }
-
-    const source = await selectItem(sourceOptions, 'How would you like to create the workspace?');
-
-    if (!source) {
-      logger.info('Cancelled');
-      return;
-    }
-
-    if (source === 'Create from GitHub branch') {
-      // List remote branches
-      logger.info('Fetching remote branches...');
-      const allBranches = await listRemoteBranches(baseDir);
-
-      // Filter out the base branch
-      const branches = allBranches.filter((branch) => branch !== projectConfig.baseBranch);
-
-      if (branches.length === 0) {
-        throw new SpacesError(
-          `No remote branches found (excluding base branch ${projectConfig.baseBranch})`,
-          'USER_ERROR',
-          1
-        );
-      }
-
-      const selectedBranch = await selectItem(branches, 'Select a branch:');
-
-      if (!selectedBranch) {
-        logger.info('Cancelled');
-        return;
-      }
-
-      // Use branch name as workspace name (sanitize for filesystem safety)
-      workspaceName = sanitizeForFileSystem(selectedBranch);
-      branchName = selectedBranch;
-      existsRemotely = true; // We know it exists remotely
-    } else if (source === 'Create from Linear issue') {
-      // Fetch unstarted issues from Linear
-      logger.info('Fetching Linear issues...');
-
-      const issues = await fetchUnstartedIssues(
-        projectConfig.linearApiKey!,
-        projectConfig.linearTeamKey
-      );
-
-      if (issues.length === 0) {
-        throw new SpacesError(
-          'No unstarted Linear issues found',
-          'USER_ERROR',
-          1
-        );
-      }
-
-      // Format for selection
-      const issueOptions = issues.map(
-        (issue) => `${issue.identifier} - ${issue.title}`
-      );
-
-      const selectedIssueString = await selectItem(issueOptions, 'Select an issue:');
-
-      if (!selectedIssueString) {
-        logger.info('Cancelled');
-        return;
-      }
-
-      // Find the corresponding LinearIssue object
-      const [identifier] = selectedIssueString.split(' - ');
-      selectedLinearIssue = issues.find(issue => issue.identifier === identifier);
-
-      if (!selectedLinearIssue) {
-        throw new SpacesError(
-          `Failed to find Linear issue with identifier ${identifier}`,
-          'SYSTEM_ERROR',
-          2
-        );
-      }
-
-      // Generate workspace name
-      workspaceName = generateWorkspaceName(selectedLinearIssue.identifier, selectedLinearIssue.title);
-      branchName = options.branchName || workspaceName;
-    } else {
-      // Manual entry
-      const name = await promptInput('Enter workspace name:', {
-        validate: (input) => {
-          if (!input || input.trim().length === 0) {
-            return 'Workspace name is required';
-          }
-          if (!isValidWorkspaceName(input)) {
-            return 'Workspace name must contain only alphanumeric characters, hyphens, and underscores (no spaces)';
-          }
-          return true;
-        },
-      });
-
-      if (!name) {
-        logger.info('Cancelled');
-        return;
-      }
-
-      workspaceName = name;
-      branchName = options.branchName || workspaceName;
-    }
-  }
-
-  const workspacePath = join(workspacesDir, workspaceName);
-
-  // Check if workspace already exists
-  if (existsSync(workspacePath)) {
-    throw new WorkspaceExistsError(workspaceName);
-  }
-
-  logger.info(`Creating workspace: ${workspaceName}`);
-
-  // Check if branch exists remotely (if we don't already know)
-  if (!existsRemotely) {
-    existsRemotely = await checkRemoteBranch(baseDir, branchName);
-
-    if (existsRemotely) {
-      // Prompt user
-      const pullRemote = await promptConfirm(`Branch '${branchName}' exists on remote. Pull it down?`, true);
-
-      if (!pullRemote) {
-        logger.info('Cancelled');
-        return;
-      }
-    }
-  }
-
-  // Create worktree
-  const baseBranch = options.fromBranch || projectConfig.baseBranch;
-  await createWorktree(
-    baseDir,
-    workspacePath,
-    branchName,
-    baseBranch,
-    existsRemotely
-  );
-
-  logger.success(`Created worktree from ${baseBranch}`);
-
-  // If workspace was created from a Linear issue, save issue details as markdown
-  if (selectedLinearIssue) {
-    const promptDir = join(workspacePath, '.prompt');
-    mkdirSync(promptDir, { recursive: true });
-
-    const markdown = await generateMarkdown(selectedLinearIssue, promptDir, projectConfig.linearApiKey);
-    const issueMarkdownPath = join(promptDir, 'issue.md');
-    writeFileSync(issueMarkdownPath, markdown, 'utf-8');
-
-    logger.debug('Saved Linear issue details to .prompt/issue.md');
-  }
-
-  // Check if this is first-time setup (no marker exists)
-  const isFirstTime = !hasSetupBeenRun(workspacePath);
-
-  // Run pre scripts if this is the first time (before tmux/setup)
-  if (isFirstTime && !options.noSetup) {
-    const preScriptsDir = getScriptsPhaseDir(currentProject, 'pre');
-    await runScriptsInTerminal(preScriptsDir, workspacePath, workspaceName, projectConfig.repository);
-  }
-
-  // Open workspace shell unless --no-shell
-  if (!options.noShell) {
-    logger.success(`Opening workspace: ${workspaceName}`);
-    await openWorkspaceShell(
-      workspacePath,
-      currentProject,
-      projectConfig.repository,
-      options.noSetup || false
-    );
-  } else {
-    logger.success(`Workspace created at: ${workspacePath}`);
-    logger.log(`\nTo navigate:\n  cd ${workspacePath}`);
-  }
-}