gittable 1.0.0

package/commands/config.js

@@ -0,0 +1,171 @@
+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 listConfig = (scope = 'local') => {
+  const scopeFlag = scope === 'global' ? '--global' : scope === 'system' ? '--system' : '--local';
+  const result = execGit(`config ${scopeFlag} --list`, { silent: true });
+
+  if (!result.success || !result.output.trim()) {
+    console.log(chalk.dim('No configuration found'));
+    return;
+  }
+
+  const lines = result.output.trim().split('\n').filter(Boolean);
+  const configs = lines.map((line) => {
+    const [key, ...valueParts] = line.split('=');
+    return {
+      key,
+      value: valueParts.join('='),
+    };
+  });
+
+  const rows = configs.map((config) => [chalk.cyan(config.key), config.value]);
+
+  console.log(`\n${createTable(['Key', 'Value'], rows)}`);
+};
+
+const getConfig = async (key, scope = 'local') => {
+  const scopeFlag = scope === 'global' ? '--global' : scope === 'system' ? '--system' : '--local';
+  const result = execGit(`config ${scopeFlag} --get ${key}`, { silent: true });
+
+  if (result.success) {
+    console.log(chalk.green(result.output.trim()));
+  } else {
+    clack.cancel(chalk.yellow(`Config key "${key}" not found`));
+  }
+};
+
+const setConfig = async (key, value, scope = 'local') => {
+  if (!key) {
+    key = await clack.text({
+      message: chalk.cyan('Config key:'),
+      placeholder: 'user.name',
+    });
+
+    if (clack.isCancel(key)) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+  }
+
+  if (!value) {
+    value = await clack.text({
+      message: chalk.cyan('Config value:'),
+      placeholder: 'John Doe',
+    });
+
+    if (clack.isCancel(value)) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+  }
+
+  const spinner = clack.spinner();
+  spinner.start(`Setting config ${key}`);
+
+  const scopeFlag = scope === 'global' ? '--global' : scope === 'system' ? '--system' : '--local';
+  const result = execGit(`config ${scopeFlag} ${key} "${value}"`, { silent: true });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold(`Config ${key} set to ${value}`));
+  } else {
+    clack.cancel(chalk.red('Failed to set config'));
+    console.error(result.error);
+    process.exit(1);
+  }
+};
+
+const unsetConfig = async (key, scope = 'local') => {
+  if (!key) {
+    key = await clack.text({
+      message: chalk.cyan('Config key to unset:'),
+      placeholder: 'user.name',
+    });
+
+    if (clack.isCancel(key)) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+  }
+
+  const confirm = await clack.confirm({
+    message: chalk.yellow(`Unset config ${key}?`),
+    initialValue: false,
+  });
+
+  if (clack.isCancel(confirm) || !confirm) {
+    clack.cancel(chalk.yellow('Cancelled'));
+    return;
+  }
+
+  const spinner = clack.spinner();
+  spinner.start(`Unsetting config ${key}`);
+
+  const scopeFlag = scope === 'global' ? '--global' : scope === 'system' ? '--system' : '--local';
+  const result = execGit(`config ${scopeFlag} --unset ${key}`, { silent: true });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold(`Config ${key} unset`));
+  } else {
+    clack.cancel(chalk.red('Failed to unset config'));
+    console.error(result.error);
+    process.exit(1);
+  }
+};
+
+module.exports = async (args) => {
+  const action = args[0];
+  const global = args.includes('--global') || args.includes('-g');
+  const system = args.includes('--system') || args.includes('-s');
+  const scope = global ? 'global' : system ? 'system' : 'local';
+
+  if (!action || action === 'list' || action === 'ls') {
+    showBanner('CONFIG');
+    console.log(`${chalk.gray('├')}  ${chalk.cyan.bold(`Config List (${scope})`)}`);
+    listConfig(scope);
+    clack.outro(chalk.green.bold('Done'));
+    return;
+  }
+
+  if (action === 'get') {
+    showBanner('CONFIG');
+    console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Get Config')}`);
+    await getConfig(args[1], scope);
+    clack.outro(chalk.green.bold('Done'));
+    return;
+  }
+
+  if (action === 'set') {
+    showBanner('CONFIG');
+    console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Set Config')}`);
+    await setConfig(args[1], args[2], scope);
+    return;
+  }
+
+  if (action === 'unset' || action === 'remove' || action === 'rm') {
+    showBanner('CONFIG');
+    console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Unset Config')}`);
+    await unsetConfig(args[1], scope);
+    return;
+  }
+
+  // If action looks like a key=value, treat as set
+  if (action.includes('=')) {
+    const [key, ...valueParts] = action.split('=');
+    showBanner('CONFIG');
+    console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Set Config')}`);
+    await setConfig(key, valueParts.join('='), scope);
+    return;
+  }
+
+  // Default: get config
+  showBanner('CONFIG');
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Get Config')}`);
+  await getConfig(action, scope);
+  clack.outro(chalk.green.bold('Done'));
+};

package/commands/diff.js

@@ -0,0 +1,30 @@
+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('DIFF');
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Show Changes')}`);
+
+  const staged = args.includes('--staged') || args.includes('--cached');
+  const file = args.find((arg) => !arg.startsWith('--'));
+
+  let command = 'diff';
+  if (staged) {
+    command += ' --staged';
+  }
+  if (file) {
+    command += ` ${file}`;
+  }
+
+  const result = execGit(command, { silent: false });
+
+  if (!result.success) {
+    clack.cancel(chalk.red('Failed to show diff'));
+    console.error(result.error);
+    process.exit(1);
+  }
+
+  clack.outro(chalk.green.bold('Done'));
+};

package/commands/fetch.js

@@ -0,0 +1,76 @@
+const clack = require('@clack/prompts');
+const chalk = require('chalk');
+const { execGit, remoteExists, getRemotes } = require('../lib/git/exec');
+const { showBanner } = require('../lib/ui/banner');
+const { addRemote } = require('./remote');
+
+module.exports = async (args) => {
+  showBanner('FETCH');
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Fetch from Remote')}`);
+
+  let remote = args[0] || 'origin';
+  const all = args.includes('--all') || args.includes('-a');
+  const prune = args.includes('--prune') || args.includes('-p');
+
+  if (!all && !remoteExists(remote)) {
+    const remotes = getRemotes();
+    if (remotes.length === 0) {
+      console.log(chalk.yellow(`Remote '${remote}' does not exist.`));
+      const shouldAdd = await clack.confirm({
+        message: chalk.cyan(`Would you like to add remote '${remote}'?`),
+        initialValue: true,
+      });
+
+      if (clack.isCancel(shouldAdd) || !shouldAdd) {
+        clack.cancel(chalk.yellow('Cancelled'));
+        process.exit(1);
+      }
+
+      const added = await addRemote(remote, null);
+      if (!added) {
+        process.exit(1);
+      }
+    } else {
+      console.log(chalk.yellow(`Remote '${remote}' not found`));
+      console.log(chalk.dim(`Available remotes: ${remotes.join(', ')}`));
+      const shouldAdd = await clack.confirm({
+        message: chalk.cyan(`Would you like to add remote '${remote}'?`),
+        initialValue: true,
+      });
+
+      if (clack.isCancel(shouldAdd) || !shouldAdd) {
+        clack.cancel(chalk.yellow('Cancelled'));
+        process.exit(1);
+      }
+
+      const added = await addRemote(remote, null);
+      if (!added) {
+        process.exit(1);
+      }
+    }
+  }
+
+  const spinner = clack.spinner();
+  spinner.start(`Fetching from ${all ? 'all remotes' : remote}`);
+
+  let command = 'fetch';
+  if (all) {
+    command += ' --all';
+  } else {
+    command += ` ${remote}`;
+  }
+  if (prune) {
+    command += ' --prune';
+  }
+
+  const result = execGit(command, { silent: false });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold('Fetch completed'));
+  } else {
+    clack.cancel(chalk.red('Fetch failed'));
+    console.error(result.error);
+    process.exit(1);
+  }
+};

package/commands/grep.js

@@ -0,0 +1,42 @@
+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('GREP');
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Search in Repository')}`);
+
+  const pattern = args[0];
+  const caseInsensitive = args.includes('--ignore-case') || args.includes('-i');
+  const files = args.filter((arg) => !arg.startsWith('--') && arg !== pattern);
+
+  if (!pattern) {
+    clack.cancel(chalk.yellow('No search pattern specified'));
+    return;
+  }
+
+  let command = 'grep';
+  if (caseInsensitive) {
+    command += ' --ignore-case';
+  }
+  command += ` "${pattern}"`;
+  if (files.length > 0) {
+    command += ` ${files.join(' ')}`;
+  }
+
+  const result = execGit(command, { silent: false });
+
+  if (!result.success) {
+    // Grep returns non-zero when no matches found, which is not an error
+    if (result.error && !result.error.includes('No matches found')) {
+      clack.cancel(chalk.red('Grep failed'));
+      console.error(result.error);
+      process.exit(1);
+    } else {
+      console.log(chalk.dim('No matches found'));
+    }
+  }
+
+  clack.outro(chalk.green.bold('Done'));
+};

package/commands/init.js

@@ -0,0 +1,45 @@
+const clack = require('@clack/prompts');
+const chalk = require('chalk');
+const { execGit, isGitRepo } = require('../lib/git/exec');
+const { showBanner } = require('../lib/ui/banner');
+const _path = require('node:path');
+
+module.exports = async (args) => {
+  showBanner('INIT');
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Initialize Repository')}`);
+
+  if (isGitRepo()) {
+    clack.cancel(chalk.yellow('Already a git repository'));
+    return;
+  }
+
+  const dir = args[0] || '.';
+  const bare = args.includes('--bare');
+  const initialBranch =
+    args.find((arg) => arg.startsWith('--initial-branch='))?.split('=')[1] || 'main';
+
+  const spinner = clack.spinner();
+  spinner.start(`Initializing repository${dir !== '.' ? ` in ${dir}` : ''}`);
+
+  let command = `init`;
+  if (bare) {
+    command += ' --bare';
+  }
+  if (initialBranch) {
+    command += ` --initial-branch=${initialBranch}`;
+  }
+  if (dir !== '.') {
+    command += ` ${dir}`;
+  }
+
+  const result = execGit(command, { silent: true });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold('Repository initialized'));
+  } else {
+    clack.cancel(chalk.red('Failed to initialize repository'));
+    console.error(result.error);
+    process.exit(1);
+  }
+};

package/commands/log.js

@@ -0,0 +1,38 @@
+const clack = require('@clack/prompts');
+const chalk = require('chalk');
+const { getLog } = require('../lib/git/exec');
+const { createTable } = require('../lib/ui/table');
+const { showBanner } = require('../lib/ui/banner');
+
+module.exports = async (args) => {
+  showBanner('LOG');
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Commit History')}`);
+
+  const limit = parseInt(args[0], 10) || 20;
+  const format = args.includes('--oneline') ? '%h|%s' : '%h|%an|%ar|%s';
+
+  const commits = getLog(limit, format);
+
+  if (commits.length === 0) {
+    console.log(chalk.dim('No commits found'));
+    clack.outro(chalk.green.bold('Done'));
+    return;
+  }
+
+  if (args.includes('--oneline')) {
+    for (const commit of commits) {
+      console.log(`${chalk.cyan(commit.hash)} ${commit.message}`);
+    }
+  } else {
+    const rows = commits.map((commit) => [
+      chalk.cyan(commit.hash),
+      commit.author,
+      chalk.gray(commit.date),
+      commit.message,
+    ]);
+
+    console.log(`\n${createTable(['Hash', 'Author', 'Date', 'Message'], rows)}`);
+  }
+
+  clack.outro(chalk.green.bold('Done'));
+};

package/commands/merge.js

@@ -0,0 +1,69 @@
+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('MERGE');
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Merge Branch')}`);
+
+  const currentBranch = getCurrentBranch();
+  const branches = getBranches();
+
+  let branchToMerge = args[0];
+
+  if (!branchToMerge) {
+    // 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:'));
+      console.log(chalk.gray('  gittable merge <branch-name>'));
+      process.exit(1);
+    }
+
+    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 merge'));
+      return;
+    }
+
+    branchToMerge = await clack.select({
+      message: chalk.cyan('Select branch to merge:'),
+      options,
+    });
+
+    if (clack.isCancel(branchToMerge)) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+  }
+
+  const strategy = args.includes('--no-ff')
+    ? '--no-ff'
+    : args.includes('--squash')
+      ? '--squash'
+      : '';
+
+  const spinner = clack.spinner();
+  spinner.start(`Merging ${branchToMerge} into ${currentBranch}`);
+
+  const command = strategy ? `merge ${strategy} ${branchToMerge}` : `merge ${branchToMerge}`;
+  const result = execGit(command, { silent: false });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold(`Merged ${branchToMerge} into ${currentBranch}`));
+  } else {
+    clack.cancel(chalk.red('Merge failed'));
+    console.error(result.error);
+    console.log(chalk.yellow('\nYou may need to resolve conflicts manually'));
+    process.exit(1);
+  }
+};

package/commands/mv.js

@@ -0,0 +1,40 @@
+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('MV');
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Move/Rename Files')}`);
+
+  const force = args.includes('--force') || args.includes('-f');
+  const files = args.filter((arg) => !arg.startsWith('--'));
+
+  if (files.length < 2) {
+    clack.cancel(chalk.yellow('Usage: mv <source> <destination>'));
+    return;
+  }
+
+  const source = files[0];
+  const destination = files[1];
+
+  const spinner = clack.spinner();
+  spinner.start(`Moving ${source} to ${destination}`);
+
+  let command = 'mv';
+  if (force) {
+    command += ' --force';
+  }
+  command += ` ${source} ${destination}`;
+
+  const result = execGit(command, { silent: false });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold(`Moved ${source} to ${destination}`));
+  } else {
+    clack.cancel(chalk.red('Failed to move file'));
+    console.error(result.error);
+    process.exit(1);
+  }
+};

package/commands/pull.js

@@ -0,0 +1,74 @@
+const clack = require('@clack/prompts');
+const chalk = require('chalk');
+const { execGit, getCurrentBranch, remoteExists, getRemotes } = require('../lib/git/exec');
+const { showBanner } = require('../lib/ui/banner');
+const { addRemote } = require('./remote');
+
+module.exports = async (args) => {
+  showBanner('PULL');
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Pull from Remote')}`);
+
+  const branch = getCurrentBranch();
+  let remote = args[0] || 'origin';
+  let branchName = args[1] || branch;
+
+  // Handle empty repository (no commits = no branch)
+  if (!branchName || branchName === 'null' || branchName === 'HEAD') {
+    clack.cancel(chalk.red('No branch found'));
+    console.log(chalk.yellow('Repository has no commits yet.'));
+    console.log(chalk.gray('Make at least one commit before pulling.'));
+    process.exit(1);
+  }
+
+  if (!remoteExists(remote)) {
+    const remotes = getRemotes();
+    if (remotes.length === 0) {
+      console.log(chalk.yellow(`Remote '${remote}' does not exist.`));
+      const shouldAdd = await clack.confirm({
+        message: chalk.cyan(`Would you like to add remote '${remote}'?`),
+        initialValue: true,
+      });
+
+      if (clack.isCancel(shouldAdd) || !shouldAdd) {
+        clack.cancel(chalk.yellow('Cancelled'));
+        process.exit(1);
+      }
+
+      const added = await addRemote(remote, null);
+      if (!added) {
+        process.exit(1);
+      }
+    } else {
+      console.log(chalk.yellow(`Remote '${remote}' not found`));
+      console.log(chalk.dim(`Available remotes: ${remotes.join(', ')}`));
+      const shouldAdd = await clack.confirm({
+        message: chalk.cyan(`Would you like to add remote '${remote}'?`),
+        initialValue: true,
+      });
+
+      if (clack.isCancel(shouldAdd) || !shouldAdd) {
+        clack.cancel(chalk.yellow('Cancelled'));
+        process.exit(1);
+      }
+
+      const added = await addRemote(remote, null);
+      if (!added) {
+        process.exit(1);
+      }
+    }
+  }
+
+  const spinner = clack.spinner();
+  spinner.start(`Pulling from ${remote}/${branchName}`);
+
+  const result = execGit(`pull ${remote} ${branchName}`, { silent: false });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold('Pull completed'));
+  } else {
+    clack.cancel(chalk.red('Pull failed'));
+    console.error(result.error);
+    process.exit(1);
+  }
+};

package/commands/push.js

@@ -0,0 +1,97 @@
+const clack = require('@clack/prompts');
+const chalk = require('chalk');
+const { execGit, getCurrentBranch, remoteExists, getRemotes } = require('../lib/git/exec');
+const { showBanner } = require('../lib/ui/banner');
+const { addRemote } = require('./remote');
+
+module.exports = async (args) => {
+  showBanner('PUSH');
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Push to Remote')}`);
+
+  const branch = getCurrentBranch();
+  let remote = args[0] || 'origin';
+  let branchName = args[1] || branch;
+  const force = args.includes('--force') || args.includes('-f');
+
+  // Handle empty repository (no commits = no branch)
+  if (!branchName || branchName === 'null' || branchName === 'HEAD') {
+    clack.cancel(chalk.red('No branch found'));
+    console.log(chalk.yellow('Repository has no commits yet.'));
+    console.log(chalk.gray('Make at least one commit before pushing.'));
+    process.exit(1);
+  }
+
+  if (!remoteExists(remote)) {
+    const remotes = getRemotes();
+    if (remotes.length === 0) {
+      console.log(chalk.yellow(`Remote '${remote}' does not exist.`));
+      const shouldAdd = await clack.confirm({
+        message: chalk.cyan(`Would you like to add remote '${remote}'?`),
+        initialValue: true,
+      });
+
+      if (clack.isCancel(shouldAdd) || !shouldAdd) {
+        clack.cancel(chalk.yellow('Cancelled'));
+        process.exit(1);
+      }
+
+      const added = await addRemote(remote, null);
+      if (!added) {
+        process.exit(1);
+      }
+    } else {
+      console.log(chalk.yellow(`Remote '${remote}' not found`));
+      console.log(chalk.dim(`Available remotes: ${remotes.join(', ')}`));
+      const shouldAdd = await clack.confirm({
+        message: chalk.cyan(`Would you like to add remote '${remote}'?`),
+        initialValue: true,
+      });
+
+      if (clack.isCancel(shouldAdd) || !shouldAdd) {
+        clack.cancel(chalk.yellow('Cancelled'));
+        process.exit(1);
+      }
+
+      const added = await addRemote(remote, null);
+      if (!added) {
+        process.exit(1);
+      }
+    }
+  }
+
+  if (force) {
+    if (!process.stdin.isTTY) {
+      clack.cancel(chalk.red('Interactive mode required for force push'));
+      console.log(chalk.yellow('Force push requires confirmation.'));
+      console.log(
+        chalk.gray('Please use: gittable push <remote> <branch> --force (with confirmation)')
+      );
+      process.exit(1);
+    }
+
+    const confirm = await clack.confirm({
+      message: chalk.red('Force push? This can overwrite remote history.'),
+      initialValue: false,
+    });
+
+    if (clack.isCancel(confirm) || !confirm) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+  }
+
+  const spinner = clack.spinner();
+  spinner.start(`Pushing to ${remote}/${branchName}`);
+
+  const command = force ? `push ${remote} ${branchName} --force` : `push ${remote} ${branchName}`;
+  const result = execGit(command, { silent: false });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold('Push completed'));
+  } else {
+    clack.cancel(chalk.red('Push failed'));
+    console.error(result.error);
+    process.exit(1);
+  }
+};