gittable 1.0.0

package/commands/rebase.js

@@ -0,0 +1,134 @@
+const clack = require('@clack/prompts');
+const chalk = require('chalk');
+const { execGit, getBranches, getCurrentBranch } = require('../lib/git/exec');
+const { showBanner } = require('../lib/ui/banner');
+
+module.exports = async (args) => {
+  showBanner('REBASE');
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Rebase')}`);
+
+  const currentBranch = getCurrentBranch();
+  const branches = getBranches();
+
+  let targetBranch = args[0];
+
+  if (!targetBranch) {
+    // Check if TTY is available for interactive prompts
+    if (!process.stdin.isTTY) {
+      clack.cancel(chalk.red('Interactive mode required'));
+      console.log(chalk.yellow('This command requires interactive input.'));
+      console.log(chalk.gray('Please provide a branch name: gittable rebase <branch>'));
+      process.exit(1);
+    }
+
+    const options = branches.local
+      .filter((branch) => !branch.current)
+      .map((branch) => ({
+        value: branch.name,
+        label: branch.name,
+      }));
+
+    // Add remote branches option
+    options.push({
+      value: '__remote__',
+      label: chalk.dim('Remote branch...'),
+    });
+
+    if (options.length === 0) {
+      clack.cancel(chalk.yellow('No branches to rebase onto'));
+      return;
+    }
+
+    targetBranch = await clack.select({
+      message: chalk.cyan('Select branch to rebase onto:'),
+      options,
+    });
+
+    if (clack.isCancel(targetBranch)) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+
+    if (targetBranch === '__remote__') {
+      targetBranch = await clack.text({
+        message: chalk.cyan('Remote branch (e.g., origin/main):'),
+        placeholder: 'origin/main',
+      });
+
+      if (clack.isCancel(targetBranch)) {
+        clack.cancel(chalk.yellow('Cancelled'));
+        return;
+      }
+    }
+  }
+
+  const interactive = args.includes('--interactive') || args.includes('-i');
+  const continueRebase = args.includes('--continue');
+  const abortRebase = args.includes('--abort');
+
+  if (continueRebase) {
+    const spinner = clack.spinner();
+    spinner.start('Continuing rebase');
+    const result = execGit('rebase --continue', { silent: false });
+    spinner.stop();
+
+    if (result.success) {
+      clack.outro(chalk.green.bold('Rebase continued'));
+    } else {
+      clack.cancel(chalk.red('Rebase continue failed'));
+      console.error(result.error);
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (abortRebase) {
+    if (!process.stdin.isTTY) {
+      clack.cancel(chalk.red('Interactive mode required'));
+      console.log(chalk.yellow('This command requires interactive confirmation.'));
+      process.exit(1);
+    }
+
+    const confirm = await clack.confirm({
+      message: chalk.yellow('Abort rebase? This will lose any rebase progress.'),
+      initialValue: false,
+    });
+
+    if (clack.isCancel(confirm) || !confirm) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+
+    const spinner = clack.spinner();
+    spinner.start('Aborting rebase');
+    const result = execGit('rebase --abort', { silent: true });
+    spinner.stop();
+
+    if (result.success) {
+      clack.outro(chalk.green.bold('Rebase aborted'));
+    } else {
+      clack.cancel(chalk.red('Failed to abort rebase'));
+      console.error(result.error);
+      process.exit(1);
+    }
+    return;
+  }
+
+  const spinner = clack.spinner();
+  spinner.start(`Rebasing ${currentBranch} onto ${targetBranch}`);
+
+  const command = interactive ? `rebase --interactive ${targetBranch}` : `rebase ${targetBranch}`;
+  const result = execGit(command, { silent: false });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold('Rebase completed'));
+  } else {
+    clack.cancel(chalk.red('Rebase failed'));
+    console.error(result.error);
+    console.log(chalk.yellow('\nYou may need to resolve conflicts manually'));
+    console.log(chalk.gray('Use "gittable rebase --continue" to continue after resolving'));
+    console.log(chalk.gray('Use "gittable rebase --abort" to abort the rebase'));
+    process.exit(1);
+  }
+};

package/commands/remote.js

@@ -0,0 +1,236 @@
+const clack = require('@clack/prompts');
+const chalk = require('chalk');
+const { execGit } = require('../lib/git/exec');
+const { createTable } = require('../lib/ui/table');
+const { showBanner } = require('../lib/ui/banner');
+
+const listRemotes = () => {
+  const result = execGit('remote -v', { silent: true });
+  if (!result.success) {
+    console.log(chalk.dim('No remotes found'));
+    return;
+  }
+
+  const lines = result.output.trim().split('\n').filter(Boolean);
+  const remotes = {};
+
+  for (const line of lines) {
+    const [name, url, type] = line.split(/\s+/);
+    if (!remotes[name]) {
+      remotes[name] = { name, url, fetch: '', push: '' };
+    }
+    if (type === '(fetch)') {
+      remotes[name].fetch = url;
+    } else if (type === '(push)') {
+      remotes[name].push = url;
+    }
+  }
+
+  const rows = Object.values(remotes).map((remote) => [
+    remote.name,
+    remote.fetch || remote.push,
+    remote.fetch && remote.push && remote.fetch !== remote.push ? chalk.yellow('different') : '',
+  ]);
+
+  console.log(`\n${createTable(['Remote', 'URL', 'Note'], rows)}`);
+};
+
+const addRemote = async (name, url) => {
+  if (!name) {
+    name = await clack.text({
+      message: chalk.cyan('Remote name:'),
+      placeholder: 'origin',
+    });
+
+    if (clack.isCancel(name)) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return false;
+    }
+  }
+
+  if (!url) {
+    url = await clack.text({
+      message: chalk.cyan('Remote URL:'),
+      placeholder: 'https://github.com/user/repo.git',
+    });
+
+    if (clack.isCancel(url)) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return false;
+    }
+  }
+
+  const spinner = clack.spinner();
+  spinner.start(`Adding remote ${name}`);
+
+  const result = execGit(`remote add ${name} ${url}`, { silent: true });
+  spinner.stop();
+
+  if (result.success) {
+    console.log(chalk.green(`✓ Remote ${name} added`));
+    return true;
+  } else {
+    clack.cancel(chalk.red('Failed to add remote'));
+    console.error(result.error);
+    return false;
+  }
+};
+
+const removeRemote = async (name) => {
+  if (!name) {
+    name = await clack.text({
+      message: chalk.cyan('Remote name to remove:'),
+      placeholder: 'origin',
+    });
+
+    if (clack.isCancel(name)) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+  }
+
+  const confirm = await clack.confirm({
+    message: chalk.yellow(`Remove remote ${name}?`),
+    initialValue: false,
+  });
+
+  if (clack.isCancel(confirm) || !confirm) {
+    clack.cancel(chalk.yellow('Cancelled'));
+    return;
+  }
+
+  const spinner = clack.spinner();
+  spinner.start(`Removing remote ${name}`);
+
+  const result = execGit(`remote remove ${name}`, { silent: true });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold(`Remote ${name} removed`));
+  } else {
+    clack.cancel(chalk.red('Failed to remove remote'));
+    console.error(result.error);
+    process.exit(1);
+  }
+};
+
+const renameRemote = async (oldName, newName) => {
+  if (!oldName) {
+    oldName = await clack.text({
+      message: chalk.cyan('Current remote name:'),
+      placeholder: 'origin',
+    });
+
+    if (clack.isCancel(oldName)) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+  }
+
+  if (!newName) {
+    newName = await clack.text({
+      message: chalk.cyan('New remote name:'),
+      placeholder: 'upstream',
+    });
+
+    if (clack.isCancel(newName)) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+  }
+
+  const spinner = clack.spinner();
+  spinner.start(`Renaming remote ${oldName} to ${newName}`);
+
+  const result = execGit(`remote rename ${oldName} ${newName}`, { silent: true });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold(`Remote renamed to ${newName}`));
+  } else {
+    clack.cancel(chalk.red('Failed to rename remote'));
+    console.error(result.error);
+    process.exit(1);
+  }
+};
+
+module.exports = async (args) => {
+  const action = args[0];
+
+  // If no action provided, show interactive menu
+  if (!action) {
+    showBanner('REMOTE');
+    
+    // Check if TTY is available for interactive prompts
+    if (!process.stdin.isTTY) {
+      clack.cancel(chalk.red('Interactive mode required'));
+      console.log(chalk.yellow('This command requires interactive input.'));
+      console.log(chalk.gray('Available actions:'));
+      console.log(chalk.gray('  - gittable remote list (or ls)'));
+      console.log(chalk.gray('  - gittable remote add <name> <url>'));
+      console.log(chalk.gray('  - gittable remote remove <name> (or rm)'));
+      console.log(chalk.gray('  - gittable remote rename <old> <new> (or mv)'));
+      process.exit(1);
+    }
+    
+    const selectedAction = await clack.select({
+      message: chalk.cyan('What would you like to do?'),
+      options: [
+        { value: 'list', label: chalk.cyan('List remotes') },
+        { value: 'add', label: chalk.green('Add remote') },
+        { value: 'remove', label: chalk.red('Remove remote') },
+        { value: 'rename', label: chalk.yellow('Rename remote') },
+      ],
+    });
+
+    if (clack.isCancel(selectedAction)) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+
+    // Recursively call with the selected action
+    return module.exports([selectedAction, ...args.slice(1)]);
+  }
+
+  if (action === 'list' || action === 'ls') {
+    showBanner('REMOTE');
+    console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Remote List')}`);
+    listRemotes();
+    clack.outro(chalk.green.bold('Done'));
+    return;
+  }
+
+  if (action === 'add') {
+    showBanner('REMOTE');
+    console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Add Remote')}`);
+    await addRemote(args[1], args[2]);
+    return;
+  }
+
+  if (action === 'remove' || action === 'rm') {
+    showBanner('REMOTE');
+    console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Remove Remote')}`);
+    await removeRemote(args[1]);
+    return;
+  }
+
+  if (action === 'rename' || action === 'mv') {
+    showBanner('REMOTE');
+    console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Rename Remote')}`);
+    await renameRemote(args[1], args[2]);
+    return;
+  }
+
+  // Unknown action - show help
+  showBanner('REMOTE');
+  clack.cancel(chalk.red(`Unknown action: ${action}`));
+  console.log(chalk.yellow('\nAvailable actions:'));
+  console.log(chalk.cyan('  list, ls    - List all remotes'));
+  console.log(chalk.cyan('  add         - Add a new remote'));
+  console.log(chalk.cyan('  remove, rm   - Remove a remote'));
+  console.log(chalk.cyan('  rename, mv   - Rename a remote'));
+  process.exit(1);
+};
+
+// Export addRemote for use in other commands
+module.exports.addRemote = addRemote;

package/commands/restore.js

@@ -0,0 +1,76 @@
+const clack = require('@clack/prompts');
+const chalk = require('chalk');
+const { execGit, getStatus } = require('../lib/git/exec');
+const { showBanner } = require('../lib/ui/banner');
+
+module.exports = async (args) => {
+  showBanner('RESTORE');
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Restore Files')}`);
+
+  const staged = args.includes('--staged') || args.includes('--cached');
+  const source = args.find((arg) => arg.startsWith('--source='))?.split('=')[1];
+  const files = args.filter((arg) => !arg.startsWith('--'));
+
+  if (files.length === 0) {
+    // Check if TTY is available for interactive prompts
+    if (!process.stdin.isTTY) {
+      clack.cancel(chalk.red('Interactive mode required'));
+      console.log(chalk.yellow('This command requires interactive input.'));
+      console.log(chalk.gray('Available options:'));
+      console.log(chalk.gray('  - gittable restore <file1> <file2> ...'));
+      console.log(chalk.gray('  - gittable restore --staged <file1> <file2> ...'));
+      process.exit(1);
+    }
+
+    // Interactive mode: show files that can be restored
+    const status = getStatus();
+    if (!status) {
+      clack.cancel(chalk.red('Failed to get repository status'));
+      process.exit(1);
+    }
+
+    const availableFiles = staged
+      ? status.staged.map((f) => ({ value: f.file, label: chalk.yellow(`M ${f.file}`) }))
+      : status.unstaged.map((f) => ({ value: f.file, label: chalk.yellow(`M ${f.file}`) }));
+
+    if (availableFiles.length === 0) {
+      clack.cancel(chalk.yellow(`No ${staged ? 'staged' : 'unstaged'} files to restore`));
+      return;
+    }
+
+    const selected = await clack.multiselect({
+      message: chalk.cyan(`Select files to restore${staged ? ' (from staging)' : ''}:`),
+      options: availableFiles,
+    });
+
+    if (clack.isCancel(selected)) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+
+    files.push(...selected);
+  }
+
+  const spinner = clack.spinner();
+  spinner.start(`Restoring ${files.length} file(s)`);
+
+  let command = 'restore';
+  if (staged) {
+    command += ' --staged';
+  }
+  if (source) {
+    command += ` --source=${source}`;
+  }
+  command += ` -- ${files.join(' ')}`;
+
+  const result = execGit(command, { silent: false });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold(`Restored ${files.length} file(s)`));
+  } else {
+    clack.cancel(chalk.red('Failed to restore files'));
+    console.error(result.error);
+    process.exit(1);
+  }
+};

package/commands/revert.js

@@ -0,0 +1,63 @@
+const clack = require('@clack/prompts');
+const chalk = require('chalk');
+const { execGit, getLog } = require('../lib/git/exec');
+const { showBanner } = require('../lib/ui/banner');
+
+module.exports = async (args) => {
+  showBanner('REVERT');
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Revert Commit')}`);
+
+  let commit = args[0];
+  const noCommit = args.includes('--no-commit') || args.includes('-n');
+
+  if (!commit) {
+    if (!process.stdin.isTTY) {
+      clack.cancel(chalk.red('Interactive mode required'));
+      console.log(chalk.yellow('This command requires interactive input.'));
+      console.log(chalk.gray('Please provide a commit hash: gittable revert <commit>'));
+      process.exit(1);
+    }
+
+    const commits = getLog(10, '%h|%s');
+    if (commits.length === 0) {
+      clack.cancel(chalk.yellow('No commits found'));
+      return;
+    }
+
+    const options = commits.map((c) => ({
+      value: c.hash,
+      label: `${c.hash} - ${c.message}`,
+    }));
+
+    commit = await clack.select({
+      message: chalk.cyan('Select commit to revert:'),
+      options,
+    });
+
+    if (clack.isCancel(commit)) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+  }
+
+  const spinner = clack.spinner();
+  spinner.start(`Reverting commit ${commit}`);
+
+  let command = 'revert';
+  if (noCommit) {
+    command += ' --no-commit';
+  }
+  command += ` ${commit}`;
+
+  const result = execGit(command, { silent: false });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold(`Reverted commit ${commit}`));
+  } else {
+    clack.cancel(chalk.red('Revert failed'));
+    console.error(result.error);
+    console.log(chalk.yellow('\nYou may need to resolve conflicts manually'));
+    process.exit(1);
+  }
+};

package/commands/rm.js

@@ -0,0 +1,57 @@
+const clack = require('@clack/prompts');
+const chalk = require('chalk');
+const { execGit } = require('../lib/git/exec');
+const { showBanner } = require('../lib/ui/banner');
+
+module.exports = async (args) => {
+  showBanner('RM');
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Remove Files')}`);
+
+  const files = args.filter((arg) => !arg.startsWith('--'));
+  const cached = args.includes('--cached') || args.includes('--staged');
+  const force = args.includes('--force') || args.includes('-f');
+  const recursive = args.includes('--recursive') || args.includes('-r');
+
+  if (files.length === 0) {
+    clack.cancel(chalk.yellow('No files specified'));
+    return;
+  }
+
+  if (!force) {
+    const confirm = await clack.confirm({
+      message: chalk.yellow(`Remove ${files.length} file(s) from git?`),
+      initialValue: false,
+    });
+
+    if (clack.isCancel(confirm) || !confirm) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+  }
+
+  const spinner = clack.spinner();
+  spinner.start(`Removing ${files.length} file(s)`);
+
+  let command = 'rm';
+  if (cached) {
+    command += ' --cached';
+  }
+  if (force) {
+    command += ' --force';
+  }
+  if (recursive) {
+    command += ' --recursive';
+  }
+  command += ` ${files.join(' ')}`;
+
+  const result = execGit(command, { silent: false });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold(`Removed ${files.length} file(s)`));
+  } else {
+    clack.cancel(chalk.red('Failed to remove files'));
+    console.error(result.error);
+    process.exit(1);
+  }
+};

package/commands/show.js

@@ -0,0 +1,47 @@
+const clack = require('@clack/prompts');
+const chalk = require('chalk');
+const { execGit } = require('../lib/git/exec');
+const { showBanner } = require('../lib/ui/banner');
+
+module.exports = async (args) => {
+  showBanner('SHOW');
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Show Commit')}`);
+
+  const commit = args[0] || 'HEAD';
+
+  // Check if commit exists (for HEAD or any commit)
+  const checkResult = execGit(`rev-parse --verify ${commit}`, { silent: true });
+  if (!checkResult.success) {
+    clack.cancel(chalk.red('Failed to show commit'));
+    if (commit === 'HEAD') {
+      console.log(chalk.yellow('No commits found in repository'));
+      console.log(chalk.gray('Make at least one commit before using show'));
+    } else {
+      console.error(chalk.red(`Commit ${commit} does not exist`));
+    }
+    process.exit(1);
+  }
+
+  const stat = args.includes('--stat') || args.includes('-s');
+  const nameOnly = args.includes('--name-only') || args.includes('--name-status');
+
+  let command = 'show';
+  if (stat) {
+    command += ' --stat';
+  } else if (nameOnly) {
+    command += ' --name-status';
+  } else {
+    command += ' --format=fuller';
+  }
+  command += ` ${commit}`;
+
+  const result = execGit(command, { silent: false });
+
+  if (!result.success) {
+    clack.cancel(chalk.red('Failed to show commit'));
+    console.error(result.error);
+    process.exit(1);
+  }
+
+  clack.outro(chalk.green.bold('Done'));
+};