gittable 1.0.0

package/commands/branch.js

@@ -0,0 +1,234 @@
+const clack = require('@clack/prompts');
+const chalk = require('chalk');
+const { execGit, getBranches, getCurrentBranch } = require('../lib/git/exec');
+const { createTable } = require('../lib/ui/table');
+const { showBanner } = require('../lib/ui/banner');
+
+const listBranches = async () => {
+  const branches = getBranches();
+  const _current = getCurrentBranch();
+
+  const rows = branches.local.map((branch) => [
+    branch.current ? chalk.green('*') : ' ',
+    branch.current ? chalk.green.bold(branch.name) : branch.name,
+    branch.upstream ? chalk.gray(`[${branch.upstream}]`) : chalk.dim('(no upstream)'),
+  ]);
+
+  console.log(createTable(['', 'Branch', 'Upstream'], rows));
+
+  if (branches.remote.length > 0) {
+    console.log(chalk.gray('\nRemote branches:'));
+    for (const branch of branches.remote) {
+      console.log(chalk.gray(`  ${branch.name}`));
+    }
+  }
+};
+
+const createBranch = async (name) => {
+  if (!name) {
+    name = await clack.text({
+      message: chalk.cyan('Branch name:'),
+      placeholder: 'feature/new-feature',
+    });
+
+    if (clack.isCancel(name)) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+  }
+
+  const spinner = clack.spinner();
+  spinner.start(`Creating branch ${name}`);
+
+  const result = execGit(`checkout -b ${name}`, { silent: true });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold(`Branch ${name} created and checked out`));
+  } else {
+    clack.cancel(chalk.red('Failed to create branch'));
+    console.error(result.error);
+    process.exit(1);
+  }
+};
+
+const checkoutBranch = async (name) => {
+  const branches = getBranches();
+
+  if (!name) {
+    const options = branches.local.map((branch) => ({
+      value: branch.name,
+      label: branch.current ? chalk.green(`* ${branch.name}`) : branch.name,
+    }));
+
+    name = await clack.select({
+      message: chalk.cyan('Select branch to checkout:'),
+      options,
+    });
+
+    if (clack.isCancel(name)) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+  }
+
+  const spinner = clack.spinner();
+  spinner.start(`Checking out ${name}`);
+
+  const result = execGit(`checkout ${name}`, { silent: true });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold(`Switched to branch ${name}`));
+  } else {
+    clack.cancel(chalk.red('Failed to checkout branch'));
+    console.error(result.error);
+    process.exit(1);
+  }
+};
+
+const deleteBranch = async (name) => {
+  const branches = getBranches();
+  const current = getCurrentBranch();
+
+  if (!name) {
+    const options = branches.local
+      .filter((branch) => !branch.current)
+      .map((branch) => ({
+        value: branch.name,
+        label: branch.name,
+      }));
+
+    if (options.length === 0) {
+      clack.cancel(chalk.yellow('No branches to delete'));
+      return;
+    }
+
+    name = await clack.select({
+      message: chalk.cyan('Select branch to delete:'),
+      options,
+    });
+
+    if (clack.isCancel(name)) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+  }
+
+  if (name === current) {
+    clack.cancel(chalk.red('Cannot delete current branch'));
+    process.exit(1);
+  }
+
+  const confirm = await clack.confirm({
+    message: chalk.yellow(`Delete branch ${name}?`),
+    initialValue: false,
+  });
+
+  if (clack.isCancel(confirm) || !confirm) {
+    clack.cancel(chalk.yellow('Cancelled'));
+    return;
+  }
+
+  const spinner = clack.spinner();
+  spinner.start(`Deleting branch ${name}`);
+
+  const result = execGit(`branch -d ${name}`, { silent: true });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold(`Branch ${name} deleted`));
+  } else {
+    // Try force delete
+    const forceConfirm = await clack.confirm({
+      message: chalk.yellow('Branch not fully merged. Force delete?'),
+      initialValue: false,
+    });
+
+    if (forceConfirm) {
+      const forceResult = execGit(`branch -D ${name}`, { silent: true });
+      if (forceResult.success) {
+        clack.outro(chalk.green.bold(`Branch ${name} force deleted`));
+      } else {
+        clack.cancel(chalk.red('Failed to delete branch'));
+        console.error(forceResult.error);
+        process.exit(1);
+      }
+    } else {
+      clack.cancel(chalk.yellow('Cancelled'));
+    }
+  }
+};
+
+module.exports = async (args) => {
+  const action = args[0];
+
+  // If no action provided, show interactive menu
+  if (!action) {
+    showBanner('BRANCH');
+
+    // 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 branch list'));
+      console.log(chalk.gray('  - gittable branch create <name>'));
+      console.log(chalk.gray('  - gittable branch checkout <name>'));
+      console.log(chalk.gray('  - gittable branch delete <name>'));
+      process.exit(1);
+    }
+
+    const selectedAction = await clack.select({
+      message: chalk.cyan('What would you like to do?'),
+      options: [
+        { value: 'list', label: chalk.cyan('List branches') },
+        { value: 'create', label: chalk.green('Create new branch') },
+        { value: 'checkout', label: chalk.yellow('Checkout branch') },
+        { value: 'delete', label: chalk.red('Delete branch') },
+      ],
+    });
+
+    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('BRANCH');
+    console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Branch List')}`);
+    await listBranches();
+    clack.outro(chalk.green.bold('Done'));
+    return;
+  }
+
+  if (action === 'create' || action === 'new') {
+    showBanner('BRANCH');
+    console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Create Branch')}`);
+    await createBranch(args[1]);
+    return;
+  }
+
+  if (action === 'checkout' || action === 'co') {
+    showBanner('BRANCH');
+    console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Checkout Branch')}`);
+    await checkoutBranch(args[1]);
+    return;
+  }
+
+  if (action === 'delete' || action === 'del' || action === 'rm') {
+    showBanner('BRANCH');
+    console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Delete Branch')}`);
+    await deleteBranch(args[1]);
+    return;
+  }
+
+  // Default: try to checkout
+  showBanner('BRANCH');
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Checkout Branch')}`);
+  await checkoutBranch(action);
+};

package/commands/checkout.js

@@ -0,0 +1,43 @@
+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('CHECKOUT');
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Checkout Files')}`);
+
+  const files = args.filter((arg) => !arg.startsWith('--'));
+  const from =
+    args.find((arg) => arg.startsWith('--source='))?.split('=')[1] ||
+    args.find((arg) => arg.startsWith('--ours'))
+      ? '--ours'
+      : args.find((arg) => arg.startsWith('--theirs'))
+        ? '--theirs'
+        : null;
+
+  if (files.length === 0) {
+    clack.cancel(chalk.yellow('No files specified'));
+    return;
+  }
+
+  const spinner = clack.spinner();
+  spinner.start(`Checking out ${files.length} file(s)`);
+
+  let command = 'checkout';
+  if (from) {
+    command += ` ${from}`;
+  }
+  command += ` -- ${files.join(' ')}`;
+
+  const result = execGit(command, { silent: false });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold(`Checked out ${files.length} file(s)`));
+  } else {
+    clack.cancel(chalk.red('Failed to checkout files'));
+    console.error(result.error);
+    process.exit(1);
+  }
+};

package/commands/cherry-pick.js

@@ -0,0 +1,104 @@
+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('CHERRY-PICK');
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Cherry-pick Commit')}`);
+
+  let commit = args[0];
+  const noCommit = args.includes('--no-commit') || args.includes('-n');
+  const continuePick = args.includes('--continue');
+  const abortPick = args.includes('--abort');
+
+  if (continuePick) {
+    const spinner = clack.spinner();
+    spinner.start('Continuing cherry-pick');
+    const result = execGit('cherry-pick --continue', { silent: false });
+    spinner.stop();
+
+    if (result.success) {
+      clack.outro(chalk.green.bold('Cherry-pick continued'));
+    } else {
+      clack.cancel(chalk.red('Cherry-pick continue failed'));
+      console.error(result.error);
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (abortPick) {
+    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 cherry-pick? This will lose any progress.'),
+      initialValue: false,
+    });
+
+    if (clack.isCancel(confirm) || !confirm) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+
+    const spinner = clack.spinner();
+    spinner.start('Aborting cherry-pick');
+    const result = execGit('cherry-pick --abort', { silent: true });
+    spinner.stop();
+
+    if (result.success) {
+      clack.outro(chalk.green.bold('Cherry-pick aborted'));
+    } else {
+      clack.cancel(chalk.red('Failed to abort cherry-pick'));
+      console.error(result.error);
+      process.exit(1);
+    }
+    return;
+  }
+
+  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 cherry-pick <commit>'));
+      process.exit(1);
+    }
+
+    commit = await clack.text({
+      message: chalk.cyan('Commit hash to cherry-pick:'),
+      placeholder: 'abc1234',
+    });
+
+    if (clack.isCancel(commit)) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+  }
+
+  const spinner = clack.spinner();
+  spinner.start(`Cherry-picking commit ${commit}`);
+
+  let command = 'cherry-pick';
+  if (noCommit) {
+    command += ' --no-commit';
+  }
+  command += ` ${commit}`;
+
+  const result = execGit(command, { silent: false });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold(`Cherry-picked commit ${commit}`));
+  } else {
+    clack.cancel(chalk.red('Cherry-pick failed'));
+    console.error(result.error);
+    console.log(chalk.yellow('\nYou may need to resolve conflicts manually'));
+    console.log(chalk.gray('Use "gittable cherry-pick --continue" to continue after resolving'));
+    console.log(chalk.gray('Use "gittable cherry-pick --abort" to abort'));
+    process.exit(1);
+  }
+};

package/commands/clean.js

@@ -0,0 +1,71 @@
+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('CLEAN');
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Clean Untracked Files')}`);
+
+  const dryRun = args.includes('--dry-run') || args.includes('-n');
+  const force = args.includes('--force') || args.includes('-f');
+  const directories = args.includes('--dir') || args.includes('-d');
+  const interactive = args.includes('--interactive') || args.includes('-i');
+
+  const status = getStatus();
+  if (!status) {
+    clack.cancel(chalk.red('Failed to get repository status'));
+    process.exit(1);
+  }
+
+  if (status.untracked.length === 0) {
+    clack.cancel(chalk.yellow('No untracked files to clean'));
+    return;
+  }
+
+  if (dryRun) {
+    console.log(chalk.yellow('\nFiles that would be removed:'));
+    for (const file of status.untracked) {
+      console.log(chalk.gray(`  ${file}`));
+    }
+    clack.outro(chalk.green.bold('Dry run complete'));
+    return;
+  }
+
+  if (!force && !interactive) {
+    const confirm = await clack.confirm({
+      message: chalk.yellow(`Remove ${status.untracked.length} untracked file(s)?`),
+      initialValue: false,
+    });
+
+    if (clack.isCancel(confirm) || !confirm) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+  }
+
+  const spinner = clack.spinner();
+  spinner.start('Cleaning untracked files');
+
+  let command = 'clean';
+  if (force) {
+    command += ' -f';
+  }
+  if (directories) {
+    command += ' -d';
+  }
+  if (interactive) {
+    command += ' -i';
+  }
+
+  const result = execGit(command, { silent: false });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold('Clean completed'));
+  } else {
+    clack.cancel(chalk.red('Clean failed'));
+    console.error(result.error);
+    process.exit(1);
+  }
+};

package/commands/clone.js

@@ -0,0 +1,76 @@
+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('CLONE');
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Clone Repository')}`);
+
+  let url = args[0];
+  let directory = args[1];
+
+  if (!url) {
+    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 repository URL: gittable clone <url> [directory]'));
+      process.exit(1);
+    }
+
+    url = await clack.text({
+      message: chalk.cyan('Repository URL:'),
+      placeholder: 'https://github.com/user/repo.git',
+    });
+
+    if (clack.isCancel(url)) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+  }
+
+  if (!directory) {
+    if (process.stdin.isTTY) {
+      directory = await clack.text({
+        message: chalk.cyan('Directory name (optional):'),
+        placeholder: 'repo-name',
+        required: false,
+      });
+
+      if (clack.isCancel(directory)) {
+        clack.cancel(chalk.yellow('Cancelled'));
+        return;
+      }
+    }
+  }
+
+  const depth = args.find((arg) => arg.startsWith('--depth='))?.split('=')[1];
+  const branch =
+    args.find((arg) => arg.startsWith('--branch='))?.split('=')[1] ||
+    args.find((arg) => arg.startsWith('-b='))?.split('=')[1];
+
+  const spinner = clack.spinner();
+  spinner.start(`Cloning ${url}${directory ? ` into ${directory}` : ''}`);
+
+  let command = `clone ${url}`;
+  if (directory) {
+    command += ` ${directory}`;
+  }
+  if (depth) {
+    command += ` --depth ${depth}`;
+  }
+  if (branch) {
+    command += ` --branch ${branch}`;
+  }
+
+  const result = execGit(command, { silent: false });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold('Repository cloned'));
+  } else {
+    clack.cancel(chalk.red('Failed to clone repository'));
+    console.error(result.error);
+    process.exit(1);
+  }
+};

package/commands/commit.js

@@ -0,0 +1,82 @@
+const clack = require('@clack/prompts');
+const chalk = require('chalk');
+const { promptQuestions } = require('../lib/commit/questions');
+const buildCommit = require('../lib/commit/build-commit');
+const readConfigFile = require('../lib/config/read-config-file');
+
+const { showBanner } = require('../lib/ui/banner');
+
+module.exports = async (_args) => {
+  showBanner('COMMIT');
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Create Commit')}`);
+
+  // 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 use: git commit -m "message" for non-interactive commits'));
+    process.exit(1);
+  }
+
+  const config = readConfigFile();
+  if (!config) {
+    clack.cancel(chalk.red('No configuration found'));
+    process.exit(1);
+  }
+
+  config.subjectLimit = config.subjectLimit || 100;
+
+  try {
+    const answers = await promptQuestions(config);
+    const message = buildCommit(answers, config);
+
+    clack.note(message, chalk.bold('Commit Preview'));
+
+    const action = await clack.select({
+      message: chalk.yellow('Proceed?'),
+      options: [
+        { value: 'yes', label: chalk.green('Commit') },
+        { value: 'no', label: chalk.red('Cancel') },
+      ],
+    });
+
+    if (clack.isCancel(action) || action === 'no') {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+
+    const { execSync } = require('node:child_process');
+
+    const spinner = clack.spinner();
+    spinner.start('Creating commit...');
+
+    let result;
+    try {
+      execSync('git commit -F -', {
+        input: message,
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+      result = { success: true };
+    } catch (error) {
+      result = {
+        success: false,
+        error: error.stderr?.toString() || error.message,
+      };
+    }
+
+    spinner.stop();
+
+    if (result.success) {
+      clack.outro(chalk.green.bold('Commit created successfully'));
+    } else {
+      clack.cancel(chalk.red('Failed to create commit'));
+      console.error(result.error);
+      process.exit(1);
+    }
+  } catch (error) {
+    clack.cancel(chalk.red('Failed to create commit'));
+    console.error(error);
+    process.exit(1);
+  }
+};