gitforest 1.1.2 → 1.2.0

package/src/components/AddDirectoryDialog.tsx

@@ -0,0 +1,151 @@
+import { Box, Text, useInput } from "ink";
+import { homedir } from "os";
+import {
+  HybridDirectoryBrowser,
+  formatDisplayPath,
+} from "./onboarding/DirectoriesStep.tsx";
+import type { AddDirectoryDialogState } from "../types/index.ts";
+
+export interface AddDirectoryDialogProps {
+  state: AddDirectoryDialogState;
+  onUpdate: (updates: Partial<AddDirectoryDialogState>) => void;
+  onConfirm: (path: string, maxDepth: number, label: string) => void;
+  onCancel: () => void;
+}
+
+export function AddDirectoryDialog({
+  state,
+  onUpdate,
+  onConfirm,
+  onCancel,
+}: AddDirectoryDialogProps) {
+  const { step, selectedPath, maxDepthInput, labelInput, error } = state;
+
+  // Handle maxDepth and label input
+  useInput((input, key) => {
+    // Browse mode is handled entirely by HybridDirectoryBrowser
+    if (step === "browse") return;
+
+    if (key.escape) {
+      if (step === "maxDepth") {
+        // Go back to browser
+        onUpdate({ step: "browse", selectedPath: null, error: null });
+      } else if (step === "label") {
+        // Go back to maxDepth
+        onUpdate({ step: "maxDepth", error: null });
+      }
+      return;
+    }
+
+    if (key.return) {
+      if (step === "maxDepth") {
+        const depth = parseInt(maxDepthInput, 10);
+        if (isNaN(depth) || depth < 0 || depth > 10) {
+          onUpdate({ error: "Max depth must be between 0 and 10" });
+          return;
+        }
+        onUpdate({ step: "label", error: null });
+      } else if (step === "label") {
+        if (!selectedPath) return;
+        const depth = parseInt(maxDepthInput, 10);
+        onConfirm(selectedPath, isNaN(depth) ? 2 : depth, labelInput.trim());
+      }
+      return;
+    }
+
+    if (step === "maxDepth") {
+      if ((key as any).backspace || (key as any).delete) {
+        onUpdate({ maxDepthInput: maxDepthInput.slice(0, -1) });
+      } else if (/^[0-9]$/.test(input)) {
+        onUpdate({ maxDepthInput: maxDepthInput + input });
+      }
+    } else if (step === "label") {
+      if ((key as any).backspace || (key as any).delete) {
+        onUpdate({ labelInput: labelInput.slice(0, -1) });
+      } else if (input.length === 1) {
+        onUpdate({ labelInput: labelInput + input });
+      }
+    }
+  });
+
+  const handleBrowserSelect = (path: string) => {
+    onUpdate({
+      selectedPath: path,
+      step: "maxDepth",
+      maxDepthInput: "2",
+      labelInput: "",
+      error: null,
+    });
+  };
+
+  const handleBrowserCancel = () => {
+    onCancel();
+  };
+
+  return (
+    <Box
+      flexDirection="column"
+      borderStyle="round"
+      borderColor="cyan"
+      paddingX={2}
+      paddingY={1}
+      width={80}
+    >
+      <Box marginBottom={1}>
+        <Text bold color="cyan">
+          Add Directory
+        </Text>
+      </Box>
+
+      {/* Step 1: Browse for directory */}
+      {step === "browse" && (
+        <HybridDirectoryBrowser
+          startingPath={homedir()}
+          onSelect={handleBrowserSelect}
+          onCancel={handleBrowserCancel}
+        />
+      )}
+
+      {/* Step 2: Max depth input */}
+      {step === "maxDepth" && (
+        <Box flexDirection="column" marginBottom={1}>
+          <Text>Max scan depth (0-10, default 2):</Text>
+          <Box gap={1}>
+            <Text color="yellow">{"> "}</Text>
+            <Text color="yellow">{maxDepthInput}</Text>
+            <Text color="yellow" inverse>_</Text>
+          </Box>
+          <Text dimColor>Path: {formatDisplayPath(selectedPath || "")}</Text>
+          {error && <Text color="red">{error}</Text>}
+          <Box marginTop={1} gap={2}>
+            <Text dimColor>Enter:</Text>
+            <Text dimColor>continue</Text>
+            <Text dimColor>Esc:</Text>
+            <Text dimColor>back to browser</Text>
+          </Box>
+        </Box>
+      )}
+
+      {/* Step 3: Label input */}
+      {step === "label" && (
+        <Box flexDirection="column" marginBottom={1}>
+          <Text>Label (optional, press Enter to skip):</Text>
+          <Box gap={1}>
+            <Text color="yellow">{"> "}</Text>
+            <Text color="yellow">{labelInput}</Text>
+            <Text color="yellow" inverse>_</Text>
+          </Box>
+          <Text dimColor>Path: {formatDisplayPath(selectedPath || "")}</Text>
+          <Text dimColor>Depth: {maxDepthInput}</Text>
+          {error && <Text color="red">{error}</Text>}
+          <Box marginTop={1} gap={2}>
+            <Text dimColor>Enter:</Text>
+            <Text dimColor>confirm</Text>
+            <Text dimColor>Esc:</Text>
+            <Text dimColor>back to depth</Text>
+          </Box>
+        </Box>
+      )}
+    </Box>
+  );
+}

package/src/components/HelpOverlay.tsx

@@ -58,6 +58,7 @@ const HELP_SECTIONS = [
       { key: "/", desc: "Filter projects" },
       { key: "s", desc: "Cycle sort field" },
       { key: "x", desc: "Command palette" },
+      { key: "+", desc: "Add directory" },
       { key: "r", desc: "Refresh" },
       { key: "?", desc: "Toggle help" },
       { key: "Esc", desc: "Cancel / exit mode" },

package/src/components/Layout.tsx

@@ -7,21 +7,24 @@ import { ConfirmDialog } from "./ConfirmDialog.tsx";
 import { CloneDialog } from "./CloneDialog.tsx";
 import { RepoDetailModal } from "./RepoDetailModal.tsx";
 import { CommandPalette } from "./CommandPalette.tsx";
+import { AddDirectoryDialog } from "./AddDirectoryDialog.tsx";
 import { useStore, useFilteredUnifiedRepos, useSelectedUnifiedRepos } from "../state/store.tsx";
 import { useConfirmDialogActions } from "../hooks/useConfirmDialogActions.ts";
-import { startAction, endAction, setMessage } from "../state/actions.ts";
+import { startAction, endAction, setMessage, updateAddDirectoryDialog, hideAddDirectoryDialog } from "../state/actions.ts";
 import { executeCommand } from "../operations/commands.ts";
 import { errorToString } from "../utils/errors.ts";
+import { openInEditor, openInBrowser } from "../services/editor.ts";
 import { UI } from "../constants.ts";
-import type { GitforestConfig, CommandConfig } from "../types/index.ts";
+import type { GitforestConfig, CommandConfig, UnifiedRepo } from "../types/index.ts";
 
 interface LayoutProps {
   config: GitforestConfig;
-  onRefresh: () => Promise<void>;
-  onClone?: (repos: any[], targetDir: string, useSSH: boolean) => Promise<void>;
+  onRefresh: (options?: { forceRefresh?: boolean }) => Promise<void>;
+  onClone?: (repos: UnifiedRepo[], targetDir: string, useSSH: boolean) => Promise<void>;
+  onAddDirectory?: (path: string, maxDepth: number, label: string) => Promise<{ success: boolean; error?: string }>;
 }
 
-export function Layout({ config, onRefresh, onClone }: LayoutProps) {
+export function Layout({ config, onRefresh, onClone, onAddDirectory }: LayoutProps) {
   const { state, dispatch } = useStore();
   const { mode, confirmDialog, cloneDialog } = state;
   const filteredRepos = useFilteredUnifiedRepos();
@@ -178,13 +181,9 @@ export function Layout({ config, onRefresh, onClone }: LayoutProps) {
           break;
         case "browser":
           if (repo.github?.htmlUrl) {
-            try {
-              Bun.spawn(["open", repo.github.htmlUrl], {
-                stdout: "ignore",
-                stderr: "ignore",
-              });
-            } catch (error) {
-              dispatch(setMessage(`Failed to open browser: ${errorToString(error)}`));
+            const browserResult = await openInBrowser(repo.github.htmlUrl);
+            if (!browserResult.success) {
+              dispatch(setMessage(`Failed to open browser: ${browserResult.error}`));
             }
           } else {
             dispatch(setMessage("No GitHub URL available for this repository"));
@@ -192,90 +191,9 @@ export function Layout({ config, onRefresh, onClone }: LayoutProps) {
           break;
         case "editor":
           if (repo.localPath) {
-            // Resolve editor: Project > Global > Env > Default
-            let editor = config.editor;
-
-            // Check for project-specific editor
-            if (repo.localPath) {
-              const matchedDir = config.directories.find(d =>
-                repo.localPath!.startsWith(d.path.replace(/^~/, process.env.HOME || ""))
-              );
-              if (matchedDir?.editor) {
-                editor = matchedDir.editor;
-              }
-            }
-
-            if (!editor) {
-              editor = process.env.EDITOR || "code";
-            }
-
-            // Split command and args once
-            const parts = editor.split(" ");
-            const cmd = parts[0]!;
-            const args = parts.slice(1);
-
-            // Check if it's a known terminal editor
-            const terminalEditors = ["vim", "nvim", "nano", "vi", "emacs", "hx", "helix"];
-            const isTerminal = terminalEditors.includes(cmd);
-
-            try {
-              if (isTerminal) {
-                // Suspends Ink's raw mode to allow the editor to take over
-                if (process.stdin.setRawMode) {
-                  process.stdin.setRawMode(false);
-                }
-
-                // Spawn with inherit to take over terminal
-                // IMPORTANT: Use split cmd and args
-                const proc = Bun.spawn([cmd, ...args, repo.localPath], {
-                  stdin: "inherit",
-                  stdout: "inherit",
-                  stderr: "inherit",
-                });
-
-                await proc.exited;
-
-                // Resume raw mode
-                if (process.stdin.setRawMode) {
-                  process.stdin.setRawMode(true);
-                }
-              } else {
-                // GUI Editor
-
-                // Use 'open' command for macOS GUI editors (VS Code, Cursor) specific optimization
-                if (process.platform === "darwin" && (cmd === "code" || cmd === "cursor")) {
-                  const appName = cmd === "code" ? "Visual Studio Code" : "Cursor";
-
-                  const openArgs = ["open", "-a", appName, repo.localPath];
-                  openArgs.push("--args", "-n"); // Force new window
-
-                  const subprocess = Bun.spawn(openArgs, {
-                    stdin: "ignore",
-                    stdout: "ignore",
-                    stderr: "ignore",
-                  });
-                  subprocess.unref();
-
-                } else {
-                  // Fallback for other GUI editors
-
-                  // Auto-inject -n for code/cursor if not using 'open' strategy or on other platforms
-                  if ((cmd === "code" || cmd === "cursor") && !args.includes("-n") && !args.includes("--new-window")) {
-                    args.push("-n");
-                  }
-
-                  const subprocess = Bun.spawn([cmd, ...args, repo.localPath], {
-                    stdin: "ignore",
-                    stdout: "ignore",
-                    stderr: "ignore",
-                  });
-                  subprocess.unref();
-                }
-              }
-            } catch (error) {
-              dispatch(setMessage(`Failed to open editor: ${errorToString(error)}`));
-              // Ensure raw mode is back if we failed mid-flight
-              if (process.stdin.setRawMode) process.stdin.setRawMode(true);
+            const editorResult = await openInEditor(repo.localPath, config);
+            if (!editorResult.success) {
+              dispatch(setMessage(`Failed to open editor: ${editorResult.error}`));
             }
           } else {
             dispatch(setMessage("No local path available for this repository"));
@@ -303,8 +221,8 @@ export function Layout({ config, onRefresh, onClone }: LayoutProps) {
         const result = await executeCommand(command, projectPath);
         dispatch(endAction());
         if (result.success) {
-          const shortOutput = result.output && result.output.length > 50
-            ? result.output.slice(0, 50) + "..."
+          const shortOutput = result.output && result.output.length > UI.OUTPUT_TRUNCATION_LENGTH
+            ? result.output.slice(0, UI.OUTPUT_TRUNCATION_LENGTH) + "..."
             : result.output || "Done";
           dispatch(setMessage(`${command.name}: ${shortOutput}`));
         } else {
@@ -312,7 +230,7 @@ export function Layout({ config, onRefresh, onClone }: LayoutProps) {
         }
       } catch (error) {
         dispatch(endAction());
-        dispatch(setMessage(`${command.name} failed: ${error instanceof Error ? error.message : String(error)}`));
+        dispatch(setMessage(`${command.name} failed: ${errorToString(error)}`));
       }
     };
 
@@ -334,6 +252,33 @@ export function Layout({ config, onRefresh, onClone }: LayoutProps) {
     );
   }
 
+  // Show add directory dialog
+  if (mode === "add-directory" && state.addDirectoryDialog) {
+    const handleAddDirConfirm = async (path: string, maxDepth: number, label: string) => {
+      if (onAddDirectory) {
+        const result = await onAddDirectory(path, maxDepth, label);
+        if (result.success) {
+          dispatch(hideAddDirectoryDialog());
+          dispatch(setMessage(`Added directory: ${path}`));
+          await onRefresh({ forceRefresh: true });
+        } else {
+          dispatch(updateAddDirectoryDialog({ error: result.error ?? "Failed to add directory" }));
+        }
+      }
+    };
+
+    return (
+      <Box flexDirection="column" height={terminalHeight} justifyContent="center" alignItems="center">
+        <AddDirectoryDialog
+          state={state.addDirectoryDialog}
+          onUpdate={(updates) => dispatch(updateAddDirectoryDialog(updates))}
+          onConfirm={handleAddDirConfirm}
+          onCancel={() => dispatch(hideAddDirectoryDialog())}
+        />
+      </Box>
+    );
+  }
+
   // Show filter options overlay
   if (mode === "filter-options") {
     return (

package/src/components/UnifiedProjectItem.tsx

@@ -388,7 +388,7 @@ export function UnifiedProjectItem({ repo, isSelected, isCursor }: UnifiedProjec
       <Text backgroundColor={bg}>{'  '}</Text>
       
       {/* Sync status */}
-      <Text color={isCursor ? fg : sync.color} backgroundColor={sync.bgColor || bg} bold={!!sync.bgColor}>
+      <Text color={isCursor ? fg : sync.color} backgroundColor={bg}>
         {sync.text}
       </Text>
       

package/src/components/onboarding/DirectoriesStep.unit.test.ts

@@ -255,66 +255,66 @@ describe("Directory Browser Utility Functions", () => {
 
     // These tests require specific platform or permission setups
     // Mark them as todo since they're environment-dependent
-    test.todo("should handle very long paths gracefully");
-    test.todo("should handle paths with special characters");
-    test.todo("should handle permission denied errors gracefully");
+    test.todo("should handle very long paths gracefully", () => {});
+    test.todo("should handle paths with special characters", () => {});
+    test.todo("should handle permission denied errors gracefully", () => {});
   });
 });
 
 describe("Browser State Management", () => {
   describe("input buffer changes", () => {
-    test.todo("should reset selection when input changes");
-    test.todo("should reset scroll offset when input changes");
-    test.todo("should not reset when typing same character");
+    test.todo("should reset selection when input changes", () => {});
+    test.todo("should reset scroll offset when input changes", () => {});
+    test.todo("should not reset when typing same character", () => {});
   });
 
   describe("currentPath changes", () => {
-    test.todo("should reset scroll offset when navigating to new directory");
-    test.todo("should reset selection when navigating to new directory");
-    test.todo("should reload directory entries for new path");
+    test.todo("should reset scroll offset when navigating to new directory", () => {});
+    test.todo("should reset selection when navigating to new directory", () => {});
+    test.todo("should reload directory entries for new path", () => {});
   });
 
   describe("tab completion", () => {
-    test.todo("should cycle through completions when pressing Tab repeatedly");
-    test.todo("should add trailing slash after completing directory");
-    test.todo("should update currentPath to completed directory");
-    test.todo("should update folder list to show completed directory's contents");
+    test.todo("should cycle through completions when pressing Tab repeatedly", () => {});
+    test.todo("should add trailing slash after completing directory", () => {});
+    test.todo("should update currentPath to completed directory", () => {});
+    test.todo("should update folder list to show completed directory's contents", () => {});
   });
 
   describe("backspace handling", () => {
-    test.todo("should allow backspacing initial tilde");
-    test.todo("should allow backspacing to empty input");
-    test.todo("should reset selection when backspacing");
-    test.todo("should reset scroll offset when backspacing");
+    test.todo("should allow backspacing initial tilde", () => {});
+    test.todo("should allow backspacing to empty input", () => {});
+    test.todo("should reset selection when backspacing", () => {});
+    test.todo("should reset scroll offset when backspacing", () => {});
   });
 
   describe("escape key handling", () => {
-    test.todo("should go to parent directory when input ends with /");
-    test.todo("should clear input when input has text beyond ~");
-    test.todo("should cancel when input is just ~");
-    test.todo("should reset all state when going back");
+    test.todo("should go to parent directory when input ends with /", () => {});
+    test.todo("should clear input when input has text beyond ~", () => {});
+    test.todo("should cancel when input is just ~", () => {});
+    test.todo("should reset all state when going back", () => {});
   });
 
   describe("Ctrl+U handling", () => {
-    test.todo("should reset input to ~");
-    test.todo("should reset selection");
-    test.todo("should reset scroll offset");
-    test.todo("should clear errors");
+    test.todo("should reset input to ~", () => {});
+    test.todo("should reset selection", () => {});
+    test.todo("should reset scroll offset", () => {});
+    test.todo("should clear errors", () => {});
   });
 
   describe("folder filtering logic", () => {
-    test.todo("should filter by name when input has no slashes");
-    test.todo("should NOT filter when input starts with /");
-    test.todo("should NOT filter when input contains /");
-    test.todo("should show all folders when typing /Volumes");
-    test.todo("should show all folders when typing ~/code/proj");
+    test.todo("should filter by name when input has no slashes", () => {});
+    test.todo("should NOT filter when input starts with /", () => {});
+    test.todo("should NOT filter when input contains /", () => {});
+    test.todo("should show all folders when typing /Volumes", () => {});
+    test.todo("should show all folders when typing ~/code/proj", () => {});
   });
 
   describe("dynamic currentPath updates", () => {
-    test.todo("should update currentPath when input is valid directory");
-    test.todo("should expand ~ before validating");
-    test.todo("should reload entries when currentPath changes");
-    test.todo("should default to startingPath when input is empty");
+    test.todo("should update currentPath when input is valid directory", () => {});
+    test.todo("should expand ~ before validating", () => {});
+    test.todo("should reload entries when currentPath changes", () => {});
+    test.todo("should default to startingPath when input is empty", () => {});
   });
 });
 

package/src/constants.ts

@@ -14,6 +14,8 @@ export const UI = {
   MIN_TERMINAL_HEIGHT: 24,
   /** Default terminal height if detection fails */
   DEFAULT_TERMINAL_HEIGHT: 24,
+  /** Maximum length for command output before truncation */
+  OUTPUT_TRUNCATION_LENGTH: 50,
 } as const;
 
 // ============================================================================

package/src/git/index.ts

@@ -1,2 +1 @@
-export * from "./types.js";
-export * from "./service.js";
+export * from "./types.js";

package/src/github/unified.ts

@@ -369,10 +369,9 @@ export async function cloneGitHubRepo(
   }
 
   // Check if target directory exists
-  // TODO: Re-enable after fixing test environment
-  // if (!existsSync(targetDir)) {
-  //   return { success: false, error: `Target directory does not exist: ${targetDir}` };
-  // }
+  if (!existsSync(targetDir)) {
+    return { success: false, error: `Target directory does not exist: ${targetDir}` };
+  }
 
   const repoPath = `${targetDir}/${repo.name}`;
   const url = useSSH ? repo.github.sshUrl : repo.github.cloneUrl;

package/src/hooks/useBackgroundFetch.ts

@@ -15,7 +15,7 @@ export interface BackgroundFetchDeps {
 
 export function useBackgroundFetch(
   config: GitforestConfig,
-  onRefresh: () => Promise<void>,
+  onRefresh: (options?: { forceRefresh?: boolean }) => Promise<void>,
   deps?: Partial<BackgroundFetchDeps>,
 ) {
   const { state, dispatch } = useStore();

package/src/hooks/useConfirmDialogActions.ts

@@ -7,7 +7,7 @@ import type { GitforestConfig, Project } from "../types/index.ts";
 
 interface UseConfirmDialogActionsOptions {
   config: GitforestConfig;
-  onRefresh: () => Promise<void>;
+  onRefresh: (options?: { forceRefresh?: boolean }) => Promise<void>;
 }
 
 export function useConfirmDialogActions({