git-thing 1.0.2 → 1.0.6

package/dist/app.d.ts

@@ -1,6 +1,2 @@
 import React from 'react';
-type Props = {
-    name: string | undefined;
-};
-export default function App({ name }: Props): React.JSX.Element;
-export {};
+export default function App(): React.JSX.Element;

package/dist/app.js

@@ -1,15 +1,48 @@
-import React from 'react';
-import { Text, useApp, useInput } from 'ink';
-export default function App({ name = 'Stranger' }) {
+import React, { useState, useEffect } from 'react';
+import { Box, Text, useApp, useInput } from 'ink';
+import { BranchList } from './components/BranchList.js';
+import { Settings } from './components/Settings.js';
+import { useSettings } from './hooks/useSettings.js';
+import { theme } from './constants/theme.js';
+export default function App() {
     const { exit } = useApp();
+    const { settings, updateSetting } = useSettings();
+    const [activeTab, setActiveTab] = useState('branches');
+    const [statusMessage, setStatusMessage] = useState(null);
+    // Auto-clear status message after 3s
+    useEffect(() => {
+        if (!statusMessage) {
+            return;
+        }
+        const timer = setTimeout(() => {
+            setStatusMessage(null);
+        }, 3000);
+        return () => clearTimeout(timer);
+    }, [statusMessage]);
     useInput((input, key) => {
-        if (key.escape || (key.ctrl && input === 'c')) {
+        if (input === 'q' || (key.ctrl && input === 'c')) {
             exit();
         }
+        // Tab key switches tabs (but not Shift+Tab which is used for mode switching)
+        if (key.tab && !key.shift) {
+            setActiveTab((t) => (t === 'branches' ? 'settings' : 'branches'));
+        }
     });
-    return (React.createElement(Text, null,
-        "Hello, ",
-        React.createElement(Text, { color: "green" }, name),
-        '\n',
-        React.createElement(Text, { dimColor: true }, "Press ESC or Ctrl+C to exit")));
+    const handleStatusChange = (message, type) => {
+        if (message) {
+            setStatusMessage({ text: message, type });
+        }
+        else {
+            setStatusMessage(null);
+        }
+    };
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: activeTab === 'branches', color: activeTab === 'branches' ? theme.tabs.activeColor : theme.tabs.inactiveColor }, "[Branches]"),
+            React.createElement(Text, null, " "),
+            React.createElement(Text, { bold: activeTab === 'settings', color: activeTab === 'settings' ? theme.tabs.activeColor : theme.tabs.inactiveColor }, "[Settings]")),
+        React.createElement(Box, { flexDirection: "column", flexGrow: 1 }, activeTab === 'branches' ? (React.createElement(BranchList, { baseBranch: settings.baseBranch, autoStash: settings.autoStash, isActive: activeTab === 'branches', onStatusChange: handleStatusChange })) : (React.createElement(Settings, { baseBranch: settings.baseBranch, autoStash: settings.autoStash, onBaseBranchChange: (value) => updateSetting('baseBranch', value), onAutoStashChange: (value) => updateSetting('autoStash', value), isActive: activeTab === 'settings' }))),
+        React.createElement(Box, { marginTop: 1, height: 1 }, statusMessage ? (React.createElement(Text, { color: statusMessage.type === 'success'
+                ? theme.status.successColor
+                : theme.status.errorColor }, statusMessage.text)) : (React.createElement(Text, { dimColor: true }, "Press q to exit")))));
 }

package/dist/cli.js

@@ -1,24 +1,5 @@
 #!/usr/bin/env node
 import React from 'react';
 import { render } from 'ink';
-import meow from 'meow';
 import App from './app.js';
-const cli = meow(`
-	Usage
-	  $ Git-thing
-
-	Options
-		--name  Your name
-
-	Examples
-	  $ Git-thing --name=Jane
-	  Hello, Jane
-`, {
-    importMeta: import.meta,
-    flags: {
-        name: {
-            type: 'string',
-        },
-    },
-});
-render(React.createElement(App, { name: cli.flags.name }));
+render(React.createElement(App, null));

package/dist/components/BranchList.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+type BranchListProps = {
+    baseBranch: string;
+    autoStash: boolean;
+    isActive: boolean;
+    onStatusChange: (message: string | null, type: 'success' | 'error') => void;
+};
+export declare function BranchList({ baseBranch, autoStash, isActive, onStatusChange, }: BranchListProps): React.JSX.Element;
+export {};

package/dist/components/BranchList.js

@@ -0,0 +1,93 @@
+import React, { useState, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { useGitBranches } from '../hooks/useGitBranches.js';
+import { theme } from '../constants/theme.js';
+export function BranchList({ baseBranch, autoStash, isActive, onStatusChange, }) {
+    const { branches, loading, error, checkout, rebaseMaster } = useGitBranches();
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [mode, setMode] = useState('selection');
+    const [rebasedBranch, setRebasedBranch] = useState(null);
+    // Clear rebased indicator after 3 seconds
+    useEffect(() => {
+        if (!rebasedBranch) {
+            return;
+        }
+        const timer = setTimeout(() => {
+            setRebasedBranch(null);
+        }, 3000);
+        return () => clearTimeout(timer);
+    }, [rebasedBranch]);
+    const cycleMode = () => {
+        setMode((m) => (m === 'selection' ? 'rebase' : 'selection'));
+    };
+    useInput((_input, key) => {
+        // SHIFT+TAB to switch modes within branch list
+        if (key.shift && key.tab) {
+            cycleMode();
+            return;
+        }
+        if (key.upArrow) {
+            setSelectedIndex((i) => (i > 0 ? i - 1 : branches.length - 1));
+        }
+        else if (key.downArrow) {
+            setSelectedIndex((i) => (i < branches.length - 1 ? i + 1 : 0));
+        }
+        else if (key.return) {
+            const branch = branches[selectedIndex];
+            if (branch && !branch.isCurrent) {
+                if (mode === 'selection') {
+                    checkout(branch.name).catch((err) => {
+                        onStatusChange(err.message, 'error');
+                    });
+                }
+                else if (mode === 'rebase') {
+                    const branchName = branch.name;
+                    rebaseMaster({ baseBranch, autoStash })
+                        .then(() => {
+                        setRebasedBranch(branchName);
+                    })
+                        .catch((err) => {
+                        onStatusChange(err.message, 'error');
+                    });
+                }
+            }
+        }
+    }, { isActive });
+    if (loading) {
+        return React.createElement(Text, { dimColor: true }, "Loading branches...");
+    }
+    if (error) {
+        return React.createElement(Text, { color: theme.error.color },
+            "Error: ",
+            error);
+    }
+    if (branches.length === 0) {
+        return React.createElement(Text, { dimColor: true }, "No branches found");
+    }
+    const modeConfig = theme.modes[mode];
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { alignSelf: "flex-start", borderStyle: theme.heading.borderStyle, borderColor: theme.heading.borderColor, paddingX: theme.heading.paddingX, paddingY: theme.heading.paddingY, marginBottom: theme.heading.marginBottom },
+            React.createElement(Text, { bold: theme.heading.bold, color: theme.heading.color }, theme.heading.text)),
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, null, "MODE: "),
+            React.createElement(Text, { bold: true, color: modeConfig.color }, modeConfig.label),
+            mode === 'rebase' && React.createElement(Text, { dimColor: true },
+                " (base: ",
+                baseBranch,
+                ")")),
+        branches.map((branch, index) => {
+            const isSelected = index === selectedIndex;
+            const wasRebased = branch.name === rebasedBranch;
+            return (React.createElement(Box, { key: branch.name },
+                React.createElement(Text, { color: branch.isCurrent ? theme.branch.currentColor : undefined }, branch.isCurrent ? '* ' : '  '),
+                React.createElement(Text, { color: isSelected ? modeConfig.color : undefined, bold: isSelected && theme.branch.selectedBold }, branch.name),
+                wasRebased && (React.createElement(Text, { bold: true, color: theme.modes.rebase.color },
+                    ' ',
+                    "REBASED"))));
+        }),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: theme.help.dimmed },
+                "\u2191\u2193 navigate  Enter ",
+                mode === 'selection' ? 'checkout' : 'rebase',
+                "  Shift+Tab switch mode  Tab switch tab  q quit"))));
+}

package/dist/components/Settings.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+type SettingsProps = {
+    baseBranch: string;
+    autoStash: boolean;
+    onBaseBranchChange: (value: string) => void;
+    onAutoStashChange: (value: boolean) => void;
+    isActive: boolean;
+};
+export declare function Settings({ baseBranch, autoStash, onBaseBranchChange, onAutoStashChange, isActive, }: SettingsProps): React.JSX.Element;
+export {};

package/dist/components/Settings.js

@@ -0,0 +1,67 @@
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { theme } from '../constants/theme.js';
+export function Settings({ baseBranch, autoStash, onBaseBranchChange, onAutoStashChange, isActive, }) {
+    const [selectedItem, setSelectedItem] = useState('baseBranch');
+    const [editValue, setEditValue] = useState(baseBranch);
+    const [isEditing, setIsEditing] = useState(false);
+    const settingItems = ['baseBranch', 'autoStash'];
+    useInput((input, key) => {
+        if (isEditing) {
+            if (key.return) {
+                if (editValue.trim()) {
+                    onBaseBranchChange(editValue.trim());
+                }
+                setIsEditing(false);
+            }
+            else if (key.escape) {
+                setEditValue(baseBranch);
+                setIsEditing(false);
+            }
+            else if (key.backspace || key.delete) {
+                setEditValue((v) => v.slice(0, -1));
+            }
+            else if (input && !key.ctrl && !key.meta && !key.tab) {
+                setEditValue((v) => v + input);
+            }
+            return;
+        }
+        if (key.upArrow) {
+            const currentIndex = settingItems.indexOf(selectedItem);
+            const newIndex = currentIndex > 0 ? currentIndex - 1 : settingItems.length - 1;
+            setSelectedItem(settingItems[newIndex]);
+        }
+        else if (key.downArrow) {
+            const currentIndex = settingItems.indexOf(selectedItem);
+            const newIndex = currentIndex < settingItems.length - 1 ? currentIndex + 1 : 0;
+            setSelectedItem(settingItems[newIndex]);
+        }
+        else if (key.return || input === ' ') {
+            if (selectedItem === 'baseBranch') {
+                setIsEditing(true);
+                setEditValue(baseBranch);
+            }
+            else if (selectedItem === 'autoStash') {
+                onAutoStashChange(!autoStash);
+            }
+        }
+    }, { isActive });
+    const modeConfig = theme.modes.settings;
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { alignSelf: "flex-start", borderStyle: theme.heading.borderStyle, borderColor: modeConfig.color, paddingX: theme.heading.paddingX, paddingY: theme.heading.paddingY, marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: modeConfig.color }, "SETTINGS")),
+        React.createElement(Box, null,
+            React.createElement(Text, { color: selectedItem === 'baseBranch' ? modeConfig.color : undefined }, selectedItem === 'baseBranch' ? '▸ ' : '  '),
+            React.createElement(Text, null, "Base Branch: "),
+            isEditing ? (React.createElement(Text, { color: "yellow" },
+                editValue,
+                "\u2588")) : (React.createElement(Text, { bold: selectedItem === 'baseBranch', color: modeConfig.color }, baseBranch))),
+        React.createElement(Box, null,
+            React.createElement(Text, { color: selectedItem === 'autoStash' ? modeConfig.color : undefined }, selectedItem === 'autoStash' ? '▸ ' : '  '),
+            React.createElement(Text, null, "Auto Stash: "),
+            React.createElement(Text, { bold: selectedItem === 'autoStash', color: autoStash ? 'green' : 'red' }, autoStash ? 'ON' : 'OFF')),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: theme.help.dimmed }, isEditing
+                ? 'Enter save  Esc cancel'
+                : '↑↓ navigate  Enter/Space toggle  Tab switch tab  q quit'))));
+}

package/dist/constants/theme.d.ts

@@ -0,0 +1,45 @@
+export declare const theme: {
+    heading: {
+        text: string;
+        color: string;
+        bold: boolean;
+        borderStyle: "double";
+        borderColor: string;
+        paddingX: number;
+        paddingY: number;
+        marginBottom: number;
+    };
+    branch: {
+        currentColor: string;
+        selectedColor: string;
+        selectedBold: boolean;
+    };
+    help: {
+        dimmed: boolean;
+    };
+    error: {
+        color: string;
+    };
+    modes: {
+        selection: {
+            label: string;
+            color: string;
+        };
+        rebase: {
+            label: string;
+            color: string;
+        };
+        settings: {
+            label: string;
+            color: string;
+        };
+    };
+    status: {
+        successColor: string;
+        errorColor: string;
+    };
+    tabs: {
+        activeColor: string;
+        inactiveColor: string;
+    };
+};

package/dist/constants/theme.js

@@ -0,0 +1,55 @@
+// Terminal colors: black, red, green, yellow, blue, magenta, cyan, white, gray
+// Or hex: #ff0000, rgb: rgb(255,0,0)
+export const theme = {
+    // Heading
+    heading: {
+        text: 'BRANCHES',
+        color: 'blue',
+        bold: true,
+        // Border: 'single', 'double', 'round', 'bold', 'classic', 'singleDouble', 'doubleSingle'
+        borderStyle: 'double',
+        borderColor: 'blue',
+        paddingX: 2, // horizontal padding inside box
+        paddingY: 0, // vertical padding inside box
+        marginBottom: 0, // space below heading
+    },
+    // Branch list
+    branch: {
+        currentColor: 'green',
+        selectedColor: 'blue',
+        selectedBold: true,
+    },
+    // Help text
+    help: {
+        dimmed: true,
+    },
+    // Errors
+    error: {
+        color: 'red',
+    },
+    // Modes
+    modes: {
+        selection: {
+            label: 'Selection',
+            color: 'blue',
+        },
+        rebase: {
+            label: 'Rebase Master',
+            color: 'magenta',
+        },
+        settings: {
+            label: 'Settings',
+            color: 'cyan',
+        },
+    },
+    // Status messages
+    status: {
+        successColor: 'green',
+        errorColor: 'red',
+    },
+    // Tabs
+    tabs: {
+        activeColor: 'cyan',
+        inactiveColor: 'gray',
+    },
+};

package/dist/hooks/useGitBranches.d.ts

@@ -0,0 +1,17 @@
+export type Branch = {
+    name: string;
+    isCurrent: boolean;
+};
+export type RebaseOptions = {
+    baseBranch: string;
+    autoStash: boolean;
+};
+export type UseGitBranchesResult = {
+    branches: Branch[];
+    loading: boolean;
+    error: string | null;
+    refresh: () => void;
+    checkout: (branchName: string) => Promise<void>;
+    rebaseMaster: (options: RebaseOptions) => Promise<string>;
+};
+export declare function useGitBranches(): UseGitBranchesResult;

package/dist/hooks/useGitBranches.js

@@ -0,0 +1,84 @@
+import { useState, useEffect, useCallback } from 'react';
+import { execFile } from 'child_process';
+export function useGitBranches() {
+    const [branches, setBranches] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const loadBranches = useCallback(() => {
+        execFile('git', ['branch'], (err, stdout, stderr) => {
+            setLoading(false);
+            if (err) {
+                if (stderr.includes('not a git repository')) {
+                    setError('Not a git repository');
+                }
+                else {
+                    setError(stderr || err.message);
+                }
+                return;
+            }
+            const parsedBranches = stdout
+                .split('\n')
+                .filter((line) => line.trim())
+                .map((line) => {
+                const isCurrent = line.startsWith('*');
+                const name = line.replace(/^\*?\s+/, '');
+                return { name, isCurrent };
+            });
+            setBranches(parsedBranches);
+        });
+    }, []);
+    const checkout = useCallback((branchName) => {
+        return new Promise((resolve, reject) => {
+            execFile('git', ['checkout', branchName], (err, _stdout, stderr) => {
+                if (err) {
+                    reject(new Error(stderr || err.message));
+                    return;
+                }
+                loadBranches();
+                resolve();
+            });
+        });
+    }, [loadBranches]);
+    const rebaseMaster = useCallback(({ baseBranch, autoStash }) => {
+        return new Promise((resolve, reject) => {
+            const currentBranch = branches.find((b) => b.isCurrent)?.name;
+            if (currentBranch === 'master') {
+                // On master branch: just pull --rebase
+                execFile('git', ['pull', '--rebase', 'origin', 'master'], (err, stdout, stderr) => {
+                    if (err) {
+                        reject(new Error(stderr || err.message));
+                        return;
+                    }
+                    loadBranches();
+                    resolve(stdout || 'Successfully pulled and rebased master');
+                });
+            }
+            else {
+                // On other branch: fetch origin master:master, then rebase
+                execFile('git', ['fetch', 'origin', 'master:master'], (fetchErr, _fetchStdout, fetchStderr) => {
+                    if (fetchErr) {
+                        reject(new Error(fetchStderr || fetchErr.message));
+                        return;
+                    }
+                    const rebaseArgs = ['rebase'];
+                    if (autoStash) {
+                        rebaseArgs.push('--autostash');
+                    }
+                    rebaseArgs.push(baseBranch);
+                    execFile('git', rebaseArgs, (err, stdout, stderr) => {
+                        if (err) {
+                            reject(new Error(stderr || err.message));
+                            return;
+                        }
+                        loadBranches();
+                        resolve(stdout || `Successfully rebased onto ${baseBranch}`);
+                    });
+                });
+            }
+        });
+    }, [loadBranches, branches]);
+    useEffect(() => {
+        loadBranches();
+    }, [loadBranches]);
+    return { branches, loading, error, refresh: loadBranches, checkout, rebaseMaster };
+}

package/dist/hooks/useSettings.d.ts

@@ -0,0 +1,9 @@
+type Settings = {
+    baseBranch: string;
+    autoStash: boolean;
+};
+export declare function useSettings(): {
+    settings: Settings;
+    updateSetting: <K extends keyof Settings>(key: K, value: Settings[K]) => void;
+};
+export {};

package/dist/hooks/useSettings.js

@@ -0,0 +1,31 @@
+import { useState, useEffect, useCallback } from 'react';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+const SETTINGS_PATH = join(homedir(), '.git-thing-settings.json');
+const DEFAULT_SETTINGS = {
+    baseBranch: 'main',
+    autoStash: true,
+};
+export function useSettings() {
+    const [settings, setSettings] = useState(DEFAULT_SETTINGS);
+    useEffect(() => {
+        if (existsSync(SETTINGS_PATH)) {
+            try {
+                const data = JSON.parse(readFileSync(SETTINGS_PATH, 'utf-8'));
+                setSettings({ ...DEFAULT_SETTINGS, ...data });
+            }
+            catch {
+                // If file is corrupted, use defaults
+            }
+        }
+    }, []);
+    const updateSetting = useCallback((key, value) => {
+        setSettings((prev) => {
+            const next = { ...prev, [key]: value };
+            writeFileSync(SETTINGS_PATH, JSON.stringify(next, null, 2));
+            return next;
+        });
+    }, []);
+    return { settings, updateSetting };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "git-thing",
-	"version": "1.0.2",
+	"version": "1.0.6",
 	"license": "MIT",
 	"repository": {
 		"type": "git",
@@ -13,16 +13,13 @@
 	},
 	"scripts": {
 		"build": "tsc",
-		"dev": "tsc --watch",
-		"dev:watch": "tsx watch source/cli.tsx",
-		"test": "prettier --check . && xo && ava"
+		"dev": "tsc && node dist/cli.js"
 	},
 	"files": [
 		"dist"
 	],
 	"dependencies": {
 		"ink": "^4.1.0",
-		"meow": "^11.0.0",
 		"react": "^18.2.0"
 	},
 	"devDependencies": {

package/readme.md

@@ -1,25 +1,75 @@
-# Git-thing
+# git-thing
 
-> This readme is automatically generated by [create-ink-app](https://github.com/vadimdemedes/create-ink-app)
+A streamlined CLI tool to handle the heavy lifting of feature branch workflows.
+Stop typing long Git commands and let `git-thing` manage your branching, switching, and rebasing.
 
-## Install
+## Description
 
-```bash
-$ npm install --global Git-thing
-```
+`git-thing` is a simple utility designed to automate the repetitive parts of a Git-based workflow. It allows you to:
 
-## CLI
+- **Create** new feature branches instantly.
+- **Switch** between active tasks without friction.
+- **Rebase** your work against the main branch to keep your history clean.
 
-```
-$ Git-thing --help
+---
 
-  Usage
-    $ Git-thing
+## Installation
 
-  Options
-    --name  Your name
+To use `git-thing` as a permanent command on your machine without using `npx` every time, install it globally:
 
-  Examples
-    $ Git-thing --name=Jane
-    Hello, Jane
-```
+    npm install -g git-thing
+
+## How to Update
+
+When a new version is published to NPM, sync your local copy by running:
+
+    npm update -g git-thing
+
+## How to Uninstall
+
+If you no longer need the tool, remove it with:
+
+    npm uninstall -g git-thing
+
+---
+
+## Setting up an Alias (e.g., gt)
+
+If `git-thing` is too long to type, you can set up a shorter alias like `gt`.
+
+### macOS and Linux (Zsh or Bash)
+
+1. Open your configuration file (usually `~/.zshrc` or `~/.bashrc`):
+
+   nano ~/.zshrc
+
+2. Add this line at the end:
+
+   alias gt='git-thing'
+
+3. Save, exit, and reload your shell:
+
+   source ~/.zshrc
+
+### Windows (PowerShell)
+
+1. Open your PowerShell profile:
+
+   notepad $PROFILE
+
+2. Add this line:
+
+   Set-Alias -Name gt -Value git-thing
+
+3. Save and restart your PowerShell terminal.
+
+---
+
+## Usage
+
+Once installed (and optionally aliased), you can run the tool from any directory:
+
+    git-thing
+
+    # OR, if aliased:
+    gt