gitspace 0.2.0-rc.4 → 0.2.0-rc.6

package/src/index.ts

@@ -128,7 +128,13 @@ addCommand
 	.action(async (workspaceName, options) => {
 		await checkFirstTimeSetup()
 		try {
-			await addWorkspace(workspaceName, options)
+			// Map commander option names to CreateWorkspaceOptions property names
+			await addWorkspace(workspaceName, {
+				branchName: options.branch,
+				fromBranch: options.from,
+				noShell: options.shell === false,
+				noSetup: options.setup === false,
+			})
 		} catch (error) {
 			handleError(error)
 		}

package/src/lib/remote-session/session-handler.ts

@@ -31,9 +31,12 @@ import {
 // Import project loading
 import { loadProjects } from "../../tui/state";
 
-// Import workspace removal
-import { removeWorktree, deleteLocalBranch, getWorktreeInfo } from "../../core/git";
-import { getProjectWorkspacesDir, getProjectBaseDir } from "../../core/config";
+// Import workspace operations
+import { deleteWorkspaceCore } from "../../core/workspace";
+import { readProjectConfig } from "../../core/config";
+
+// Import script execution
+import { runWorkspaceScripts } from "../../utils/run-workspace-scripts";
 
 /**
  * Session state for a connected client
@@ -326,6 +329,24 @@ export class RemoteSessionHandler {
           return;
         }
 
+        // Run setup or select scripts for the workspace
+        const config = readProjectConfig(workspace.projectName);
+
+        console.log(`[remote-session] Running workspace scripts for: ${workspace.id}`);
+        const scriptResult = await runWorkspaceScripts({
+          projectName: workspace.projectName,
+          workspacePath: workspace.path,
+          workspaceName: workspace.id,
+          repository: config.repository,
+          interactive: false, // Remote context - scripts can't prompt for input
+        });
+
+        if (!scriptResult.success) {
+          console.error(`[remote-session] ${scriptResult.phase} scripts failed:`, scriptResult.error);
+          await this.sendError(session, sendResponse, "SCRIPT_FAILED", `Workspace scripts failed during ${scriptResult.phase} phase: ${scriptResult.error}`);
+          return;
+        }
+
         // Create session name: use provided name or auto-generate
         let sessionName: string;
         if (msg.sessionName) {
@@ -449,25 +470,14 @@ export class RemoteSessionHandler {
     sendResponse: (data: Uint8Array) => void
   ): Promise<void> {
     try {
-      const workspacesDir = getProjectWorkspacesDir(projectName);
-      const baseDir = getProjectBaseDir(projectName);
-      const workspacePath = `${workspacesDir}/${workspaceId}`;
-
-      // Get workspace info for branch name
-      const info = await getWorktreeInfo(workspacePath);
-      if (!info) {
-        await this.sendError(session, sendResponse, "NOT_FOUND", "Workspace not found");
-        return;
-      }
-
-      // Remove worktree
-      await removeWorktree(baseDir, workspacePath, true);
+      const result = await deleteWorkspaceCore(projectName, workspaceId, {
+        nonInteractive: true, // Remote context - scripts can't prompt for input
+      });
 
-      // Try to delete the local branch
-      try {
-        await deleteLocalBranch(baseDir, info.branch, true);
-      } catch {
-        // Branch deletion is best-effort
+      if (!result.success) {
+        const errorCode = result.error?.includes("not found") ? "NOT_FOUND" : "DELETE_FAILED";
+        await this.sendError(session, sendResponse, errorCode, result.error || "Failed to delete workspace");
+        return;
       }
 
       await this.sendMessage(session, sendResponse, {

package/src/tui/app.tsx

@@ -57,15 +57,18 @@ import {
   projectExists,
   updateProjectConfig,
 } from '../core/config.js';
-import { removeWorkspace, removeProject } from '../commands/remove.js';
 
-// Git and workspace creation
-import { listRemoteBranches, createWorktree, checkRemoteBranch, getDefaultBranch } from '../core/git.js';
+// Git and workspace operations
+import { listRemoteBranches, createWorktree, getDefaultBranch } from '../core/git.js';
+import { deleteWorkspaceCore, deleteProjectCore } from '../core/workspace.js';
 import { fetchUnstartedIssues } from '../core/linear.js';
 import { generateMarkdown } from '../utils/markdown.js';
-import { sanitizeForFileSystem, generateWorkspaceName, isValidWorkspaceName, extractRepoName } from '../utils/sanitize.js';
+import { sanitizeForFileSystem, generateWorkspaceName, isValidWorkspaceName, isValidBranchName, extractRepoName } from '../utils/sanitize.js';
 import { existsSync, mkdirSync, writeFileSync } from 'fs';
 import { join } from 'path';
+
+// Script execution
+import { runWorkspaceScripts } from '../utils/run-workspace-scripts.js';
 import type { LinearIssue } from '../types/workspace.js';
 
 // Project creation
@@ -98,7 +101,8 @@ type WorkspaceFlowState =
   | { type: 'loading'; title: string; message: string }
   | { type: 'branch-select'; branches: string[]; selectedIndex: number }
   | { type: 'linear-select'; issues: LinearIssue[]; selectedIndex: number }
-  | { type: 'manual-input'; inputValue: string; error: string | null }
+  | { type: 'manual-name-input'; inputValue: string; error: string | null }
+  | { type: 'manual-branch-input'; workspaceName: string; inputValue: string }
   | { type: 'creating'; workspaceName: string };
 
 /** Project flow states - explicit state machine for project creation */
@@ -371,7 +375,33 @@ function App({ relayConfig, onQuit }: AppProps) {
       warning: 'This will delete all workspaces in this project!',
       onConfirm: async () => {
         flow.showLoading({ title: 'Deleting', message: 'Removing project...' });
-        await removeProject(project.name, { force: false });
+
+        try {
+          const result = await deleteProjectCore(project.name, {
+            nonInteractive: true, // TUI is non-interactive for scripts
+          });
+
+          if (!result.success && result.errors.length > 0) {
+            console.error('[tui] Project deletion errors:', result.errors);
+            flow.close();
+            flow.showMessage({
+              title: 'Delete Failed',
+              message: `Failed to delete project "${project.name}". Check logs for details.`,
+              variant: 'error',
+            });
+            return;
+          }
+        } catch (error) {
+          console.error('[tui] Failed to delete project:', error);
+          flow.close();
+          flow.showMessage({
+            title: 'Delete Failed',
+            message: `An unexpected error occurred while deleting project "${project.name}".`,
+            variant: 'error',
+          });
+          return;
+        }
+
         flow.close();
         await refreshProjects();
       },
@@ -419,7 +449,7 @@ function App({ relayConfig, onQuit }: AppProps) {
     } else if (params.workspaceId) {
       // Create new session
       const workspace = state.workspaces.find(w => w.name === params.workspaceId);
-      if (workspace) {
+      if (workspace && state.currentProject) {
         flow.showInput({
           title: 'New Session',
           label: 'Session name (optional):',
@@ -427,12 +457,36 @@ function App({ relayConfig, onQuit }: AppProps) {
           onSubmit: async (name) => {
             const sessionName = name || `${state.currentProject}:${workspace.name}:${Date.now()}`;
             try {
+              const config = readProjectConfig(state.currentProject!);
+
+              // Run workspace scripts (pre+setup for first time, select for existing)
+              const scriptResult = await runWorkspaceScripts({
+                projectName: state.currentProject!,
+                workspacePath: workspace.path,
+                workspaceName: workspace.name,
+                repository: config.repository,
+                interactive: false, // TUI context - scripts can't prompt for input
+              });
+
+              if (!scriptResult.success) {
+                flow.showMessage({
+                  title: 'Script Failed',
+                  message: `Workspace scripts failed during ${scriptResult.phase} phase: ${scriptResult.error}`,
+                  variant: 'error',
+                });
+                return;
+              }
+
               const session = await createSession(sessionName, workspace.path);
               // Attach to newly created session
               dispatch({ type: 'SET_ATTACHED_SESSION', session });
               dispatch({ type: 'SET_VIEW', view: 'terminal' });
             } catch (err) {
-              dispatch({ type: 'SET_ERROR', error: err instanceof Error ? err.message : 'Failed to create session' });
+              flow.showMessage({
+                title: 'Session Failed',
+                message: err instanceof Error ? err.message : 'Failed to create session',
+                variant: 'error',
+              });
             }
           },
         });
@@ -492,7 +546,33 @@ function App({ relayConfig, onQuit }: AppProps) {
       onConfirm: async () => {
         if (!state.currentProject) return;
         flow.showLoading({ title: 'Deleting', message: 'Removing workspace...' });
-        await removeWorkspace(workspace.name, { force: false });
+
+        try {
+          const result = await deleteWorkspaceCore(state.currentProject, workspace.name, {
+            nonInteractive: true, // TUI is non-interactive for scripts
+          });
+
+          if (!result.success) {
+            console.error('[tui] Failed to delete workspace:', result.error);
+            flow.close();
+            flow.showMessage({
+              title: 'Delete Failed',
+              message: result.error ?? `Failed to delete workspace "${workspace.name}".`,
+              variant: 'error',
+            });
+            return;
+          }
+        } catch (error) {
+          console.error('[tui] Failed to delete workspace:', error);
+          flow.close();
+          flow.showMessage({
+            title: 'Delete Failed',
+            message: error instanceof Error ? error.message : `Failed to delete workspace "${workspace.name}".`,
+            variant: 'error',
+          });
+          return;
+        }
+
         flow.close();
         await refreshWorkspaces();
       },
@@ -556,6 +636,25 @@ function App({ relayConfig, onQuit }: AppProps) {
         writeFileSync(join(promptDir, 'issue.md'), markdown, 'utf-8');
       }
 
+      // Run workspace scripts (pre+setup for new workspace)
+      const scriptResult = await runWorkspaceScripts({
+        projectName: state.currentProject,
+        workspacePath,
+        workspaceName,
+        repository: config.repository,
+        interactive: false, // TUI context - scripts can't prompt for input
+      });
+
+      if (!scriptResult.success) {
+        setWorkspaceFlow({ type: 'closed' });
+        flow.showMessage({
+          title: 'Script Failed',
+          message: `Workspace scripts failed during ${scriptResult.phase} phase: ${scriptResult.error}`,
+          variant: 'error',
+        });
+        return;
+      }
+
       setWorkspaceFlow({ type: 'closed' });
       await refreshWorkspaces();
 
@@ -566,7 +665,11 @@ function App({ relayConfig, onQuit }: AppProps) {
       dispatch({ type: 'SET_VIEW', view: 'terminal' });
     } catch (err) {
       setWorkspaceFlow({ type: 'closed' });
-      dispatch({ type: 'SET_ERROR', error: err instanceof Error ? err.message : 'Failed to create workspace' });
+      flow.showMessage({
+        title: 'Workspace Failed',
+        message: err instanceof Error ? err.message : 'Failed to create workspace',
+        variant: 'error',
+      });
     }
   }, [state.currentProject, refreshWorkspaces]);
 
@@ -639,7 +742,7 @@ function App({ relayConfig, onQuit }: AppProps) {
         setWorkspaceFlow({ type: 'closed' });
       }
     } else if (source === 'manual') {
-      setWorkspaceFlow({ type: 'manual-input', inputValue: '', error: null });
+      setWorkspaceFlow({ type: 'manual-name-input', inputValue: '', error: null });
     }
   }, [state.currentProject, flow]);
 
@@ -655,17 +758,29 @@ function App({ relayConfig, onQuit }: AppProps) {
     await createWorkspaceAndOpenSession(workspaceName, workspaceName, false, issue);
   }, [createWorkspaceAndOpenSession]);
 
-  // Handle manual name submission
-  const handleManualSubmit = useCallback(async (name: string) => {
-    if (!name || name.trim().length === 0) {
-      setWorkspaceFlow(prev => prev.type === 'manual-input' ? { ...prev, error: 'Workspace name is required' } : prev);
+  // Handle manual workspace name submission (advances to branch input)
+  const handleManualNameSubmit = useCallback((name: string) => {
+    const trimmedName = name.trim();
+    if (!trimmedName) {
+      setWorkspaceFlow(prev => prev.type === 'manual-name-input' ? { ...prev, error: 'Workspace name is required' } : prev);
       return;
     }
-    if (!isValidWorkspaceName(name)) {
-      setWorkspaceFlow(prev => prev.type === 'manual-input' ? { ...prev, error: 'Use only letters, numbers, hyphens, underscores' } : prev);
+    if (!isValidWorkspaceName(trimmedName)) {
+      setWorkspaceFlow(prev => prev.type === 'manual-name-input' ? { ...prev, error: 'Use only letters, numbers, hyphens, underscores' } : prev);
       return;
     }
-    await createWorkspaceAndOpenSession(name, name, false);
+    // Advance to branch input step, pre-fill with workspace name
+    setWorkspaceFlow({ type: 'manual-branch-input', workspaceName: trimmedName, inputValue: trimmedName });
+  }, []);
+
+  // Handle manual branch name submission (creates the workspace)
+  const handleManualBranchSubmit = useCallback(async (workspaceName: string, branchName: string) => {
+    const finalBranch = branchName.trim() || workspaceName;
+    if (!isValidBranchName(finalBranch)) {
+      setWorkspaceFlow(prev => prev.type === 'manual-branch-input' ? { ...prev, error: 'Invalid branch name (no spaces, .., or special chars like : ? * [ \\ ~)' } : prev);
+      return;
+    }
+    await createWorkspaceAndOpenSession(workspaceName, finalBranch, false);
   }, [createWorkspaceAndOpenSession]);
 
   // Main handler to start new workspace flow
@@ -1155,9 +1270,9 @@ function App({ relayConfig, onQuit }: AppProps) {
         return;
       }
 
-      if (workspaceFlow.type === 'manual-input') {
+      if (workspaceFlow.type === 'manual-name-input') {
         if (key.name === 'return') {
-          await handleManualSubmit(workspaceFlow.inputValue);
+          handleManualNameSubmit(workspaceFlow.inputValue);
         } else if (key.name === 'backspace') {
           setWorkspaceFlow({
             ...workspaceFlow,
@@ -1174,6 +1289,23 @@ function App({ relayConfig, onQuit }: AppProps) {
         return;
       }
 
+      if (workspaceFlow.type === 'manual-branch-input') {
+        if (key.name === 'return') {
+          await handleManualBranchSubmit(workspaceFlow.workspaceName, workspaceFlow.inputValue);
+        } else if (key.name === 'backspace') {
+          setWorkspaceFlow({
+            ...workspaceFlow,
+            inputValue: workspaceFlow.inputValue.slice(0, -1),
+          });
+        } else if (key.raw && key.raw.length === 1 && !key.ctrl && !key.meta) {
+          setWorkspaceFlow({
+            ...workspaceFlow,
+            inputValue: workspaceFlow.inputValue + key.raw,
+          });
+        }
+        return;
+      }
+
       // For loading/creating states, just wait (escape to cancel handled above)
       return;
     }
@@ -1484,8 +1616,10 @@ function WorkspaceFlowModal({ flow }: { flow: WorkspaceFlowState }) {
   // Calculate modal height based on content:
   // - source-select: title + spacer + (options * 2 lines each) + (spacers between) + spacer + hint + border/padding
   // - branch/linear-select: title + items (scrollable) + hint + border/padding
-  // - manual-input: title + label + input box + error? + hint + border/padding
-  const modalHeight = flow.type === 'manual-input' ? 10 :
+  // - manual-name-input: title + label + input box + error? + hint + border/padding
+  // - manual-branch-input: title + label + input box + workspace display + hint + border/padding
+  const modalHeight = flow.type === 'manual-name-input' ? 10 :
+                      flow.type === 'manual-branch-input' ? 12 :
                       flow.type === 'loading' || flow.type === 'creating' ? 6 :
                       flow.type === 'source-select' ? 6 + flow.options.length * 3 :
                       flow.type === 'branch-select' ? Math.min(16, 6 + flow.branches.length) :
@@ -1584,10 +1718,10 @@ function WorkspaceFlowModal({ flow }: { flow: WorkspaceFlowState }) {
           </>
         )}
 
-        {/* Manual input */}
-        {flow.type === 'manual-input' && (
+        {/* Manual workspace name input */}
+        {flow.type === 'manual-name-input' && (
           <>
-            <text fg={COLORS.title} height={1}>New Workspace</text>
+            <text fg={COLORS.title} height={1}>New Workspace (1/2)</text>
             <text fg={COLORS.text} height={1} marginTop={1}>Enter workspace name:</text>
             <box
               marginTop={1}
@@ -1599,6 +1733,25 @@ function WorkspaceFlowModal({ flow }: { flow: WorkspaceFlowState }) {
               <text fg={COLORS.text} height={1}>{flow.inputValue || ' '}_</text>
             </box>
             {flow.error && <text fg={COLORS.error} height={1} marginTop={1}>{flow.error}</text>}
+            <text fg={COLORS.textDim} height={1} marginTop={1}>[Enter] Next  [Esc] Cancel</text>
+          </>
+        )}
+
+        {/* Manual branch name input */}
+        {flow.type === 'manual-branch-input' && (
+          <>
+            <text fg={COLORS.title} height={1}>New Workspace (2/2)</text>
+            <text fg={COLORS.text} height={1} marginTop={1}>Enter branch name (slashes allowed):</text>
+            <box
+              marginTop={1}
+              borderStyle="rounded"
+              borderColor={COLORS.border}
+              padding={0}
+              width="100%"
+            >
+              <text fg={COLORS.text} height={1}>{flow.inputValue || ' '}_</text>
+            </box>
+            <text fg={COLORS.textDim} height={1} marginTop={1}>Workspace: {flow.workspaceName}</text>
             <text fg={COLORS.textDim} height={1} marginTop={1}>[Enter] Create  [Esc] Cancel</text>
           </>
         )}