gittable 1.0.0

package/commands/stash.js

@@ -0,0 +1,201 @@
+const clack = require('@clack/prompts');
+const chalk = require('chalk');
+const { execGit, getStashList } = require('../lib/git/exec');
+const { createTable } = require('../lib/ui/table');
+const { showBanner } = require('../lib/ui/banner');
+
+const listStashes = () => {
+  const stashes = getStashList();
+
+  if (stashes.length === 0) {
+    console.log(chalk.dim('No stashes found'));
+    return;
+  }
+
+  const rows = stashes.map((stash, _index) => [stash.ref, stash.date, stash.message]);
+
+  console.log(`\n${createTable(['Ref', 'Date', 'Message'], rows)}`);
+};
+
+const createStash = async (message, includeUntracked = false) => {
+  const spinner = clack.spinner();
+  spinner.start('Creating stash');
+
+  const command = includeUntracked
+    ? `stash push -u -m "${message || 'Stash'}"`
+    : `stash push -m "${message || 'Stash'}"`;
+
+  const result = execGit(command, { silent: true });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold('Stash created'));
+  } else {
+    clack.cancel(chalk.red('Failed to create stash'));
+    console.error(result.error);
+    process.exit(1);
+  }
+};
+
+const applyStash = async (stashRef) => {
+  const stashes = getStashList();
+
+  if (!stashRef) {
+    if (stashes.length === 0) {
+      clack.cancel(chalk.yellow('No stashes available'));
+      return;
+    }
+
+    const options = stashes.map((stash) => ({
+      value: stash.ref,
+      label: `${stash.ref} - ${stash.message}`,
+    }));
+
+    stashRef = await clack.select({
+      message: chalk.cyan('Select stash to apply:'),
+      options,
+    });
+
+    if (clack.isCancel(stashRef)) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+  }
+
+  const spinner = clack.spinner();
+  spinner.start(`Applying stash ${stashRef}`);
+
+  const result = execGit(`stash apply ${stashRef}`, { silent: false });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold('Stash applied'));
+  } else {
+    clack.cancel(chalk.red('Failed to apply stash'));
+    console.error(result.error);
+    process.exit(1);
+  }
+};
+
+const popStash = async (stashRef) => {
+  const stashes = getStashList();
+
+  if (!stashRef) {
+    if (stashes.length === 0) {
+      clack.cancel(chalk.yellow('No stashes available'));
+      return;
+    }
+
+    stashRef = stashes[0].ref; // Default to most recent
+  }
+
+  const spinner = clack.spinner();
+  spinner.start(`Popping stash ${stashRef}`);
+
+  const result = execGit(`stash pop ${stashRef}`, { silent: false });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold('Stash popped'));
+  } else {
+    clack.cancel(chalk.red('Failed to pop stash'));
+    console.error(result.error);
+    process.exit(1);
+  }
+};
+
+const dropStash = async (stashRef) => {
+  const stashes = getStashList();
+
+  if (!stashRef) {
+    if (stashes.length === 0) {
+      clack.cancel(chalk.yellow('No stashes available'));
+      return;
+    }
+
+    const options = stashes.map((stash) => ({
+      value: stash.ref,
+      label: `${stash.ref} - ${stash.message}`,
+    }));
+
+    stashRef = await clack.select({
+      message: chalk.cyan('Select stash to drop:'),
+      options,
+    });
+
+    if (clack.isCancel(stashRef)) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+  }
+
+  const confirm = await clack.confirm({
+    message: chalk.yellow(`Delete stash ${stashRef}?`),
+    initialValue: false,
+  });
+
+  if (clack.isCancel(confirm) || !confirm) {
+    clack.cancel(chalk.yellow('Cancelled'));
+    return;
+  }
+
+  const spinner = clack.spinner();
+  spinner.start(`Dropping stash ${stashRef}`);
+
+  const result = execGit(`stash drop ${stashRef}`, { silent: true });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold('Stash dropped'));
+  } else {
+    clack.cancel(chalk.red('Failed to drop stash'));
+    console.error(result.error);
+    process.exit(1);
+  }
+};
+
+module.exports = async (args) => {
+  const action = args[0] || 'list';
+
+  showBanner('STASH');
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Stash Management')}`);
+
+  if (action === 'list' || action === 'ls') {
+    listStashes();
+    clack.outro(chalk.green.bold('Done'));
+    return;
+  }
+
+  if (action === 'create' || action === 'save' || action === 'push') {
+    const message =
+      args[1] ||
+      (await clack.text({
+        message: chalk.cyan('Stash message (optional):'),
+        placeholder: 'WIP: working on feature',
+      }));
+
+    if (!clack.isCancel(message)) {
+      const includeUntracked = args.includes('--include-untracked') || args.includes('-u');
+      await createStash(message, includeUntracked);
+    }
+    return;
+  }
+
+  if (action === 'apply') {
+    await applyStash(args[1]);
+    return;
+  }
+
+  if (action === 'pop') {
+    await popStash(args[1]);
+    return;
+  }
+
+  if (action === 'drop' || action === 'delete') {
+    await dropStash(args[1]);
+    return;
+  }
+
+  // Default: create stash
+  await createStash(action);
+};

package/commands/status.js

@@ -0,0 +1,21 @@
+const clack = require('@clack/prompts');
+const chalk = require('chalk');
+const { getStatus, getCurrentBranch } = require('../lib/git/exec');
+const { displayStatus } = require('../lib/ui/status-display');
+const { showBanner } = require('../lib/ui/banner');
+
+module.exports = async (_args) => {
+  showBanner('STATUS');
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Repository Status')}`);
+
+  const branch = getCurrentBranch();
+  const status = getStatus();
+
+  if (!status) {
+    clack.cancel(chalk.red('Failed to get repository status'));
+    process.exit(1);
+  }
+
+  console.log(displayStatus(status, branch));
+  clack.outro(chalk.green.bold('Status complete'));
+};

package/commands/sync.js

@@ -0,0 +1,98 @@
+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('SYNC');
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Synchronize Repository')}`);
+
+  const branch = getCurrentBranch();
+  let remote = args[0] || 'origin';
+
+  // Handle empty repository (no commits = no branch)
+  if (!branch || branch === 'null' || branch === '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 synchronizing.'));
+    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);
+      }
+    }
+  }
+
+  // Step 1: Fetch
+  let spinner = clack.spinner();
+  spinner.start('Fetching from remote');
+  let result = execGit(`fetch ${remote}`, { silent: true });
+  spinner.stop();
+
+  if (!result.success) {
+    clack.cancel(chalk.red('Fetch failed'));
+    console.error(result.error);
+    process.exit(1);
+  }
+
+  // Step 2: Rebase
+  spinner = clack.spinner();
+  spinner.start(`Rebasing onto ${remote}/${branch}`);
+  result = execGit(`rebase ${remote}/${branch}`, { silent: false });
+  spinner.stop();
+
+  if (!result.success) {
+    clack.cancel(chalk.red('Rebase failed'));
+    console.error(result.error);
+    console.log(chalk.yellow('\nYou may need to resolve conflicts manually'));
+    process.exit(1);
+  }
+
+  // Step 3: Push
+  spinner = clack.spinner();
+  spinner.start(`Pushing to ${remote}/${branch}`);
+  result = execGit(`push ${remote} ${branch}`, { silent: false });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold('Synchronization completed'));
+  } else {
+    clack.cancel(chalk.red('Push failed'));
+    console.error(result.error);
+    process.exit(1);
+  }
+};

package/commands/tag.js

@@ -0,0 +1,153 @@
+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 listTags = () => {
+  const result = execGit('tag -l --format="%(refname:short)|%(creatordate:relative)|%(subject)"', {
+    silent: true,
+  });
+  if (!result.success || !result.output.trim()) {
+    console.log(chalk.dim('No tags found'));
+    return;
+  }
+
+  const lines = result.output.trim().split('\n').filter(Boolean);
+  const tags = lines.map((line) => {
+    const [name, date, ...messageParts] = line.split('|');
+    return {
+      name,
+      date,
+      message: messageParts.join('|') || '(no message)',
+    };
+  });
+
+  const rows = tags.map((tag) => [chalk.cyan(tag.name), chalk.gray(tag.date), tag.message]);
+
+  console.log(`\n${createTable(['Tag', 'Date', 'Message'], rows)}`);
+};
+
+const createTag = async (name, message, commit, lightweight = false) => {
+  if (!name) {
+    name = await clack.text({
+      message: chalk.cyan('Tag name:'),
+      placeholder: 'v1.0.0',
+    });
+
+    if (clack.isCancel(name)) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+  }
+
+  const annotated = !lightweight;
+  if (annotated && !message) {
+    message = await clack.text({
+      message: chalk.cyan('Tag message (optional):'),
+      placeholder: 'Release version 1.0.0',
+      required: false,
+    });
+
+    if (clack.isCancel(message)) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+  }
+
+  const spinner = clack.spinner();
+  spinner.start(`Creating tag ${name}`);
+
+  let command = 'tag';
+  if (annotated && message) {
+    command += ` -a ${name} -m "${message}"`;
+  } else if (annotated) {
+    command += ` -a ${name}`;
+  } else {
+    command += ` ${name}`;
+  }
+  if (commit) {
+    command += ` ${commit}`;
+  }
+
+  const result = execGit(command, { silent: true });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold(`Tag ${name} created`));
+  } else {
+    clack.cancel(chalk.red('Failed to create tag'));
+    console.error(result.error);
+    process.exit(1);
+  }
+};
+
+const deleteTag = async (name) => {
+  if (!name) {
+    name = await clack.text({
+      message: chalk.cyan('Tag name to delete:'),
+      placeholder: 'v1.0.0',
+    });
+
+    if (clack.isCancel(name)) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+  }
+
+  const confirm = await clack.confirm({
+    message: chalk.yellow(`Delete tag ${name}?`),
+    initialValue: false,
+  });
+
+  if (clack.isCancel(confirm) || !confirm) {
+    clack.cancel(chalk.yellow('Cancelled'));
+    return;
+  }
+
+  const spinner = clack.spinner();
+  spinner.start(`Deleting tag ${name}`);
+
+  const result = execGit(`tag -d ${name}`, { silent: true });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold(`Tag ${name} deleted`));
+  } else {
+    clack.cancel(chalk.red('Failed to delete tag'));
+    console.error(result.error);
+    process.exit(1);
+  }
+};
+
+module.exports = async (args) => {
+  const action = args[0];
+
+  if (!action || action === 'list' || action === 'ls') {
+    showBanner('TAG');
+    console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Tag List')}`);
+    listTags();
+    clack.outro(chalk.green.bold('Done'));
+    return;
+  }
+
+  if (action === 'create' || action === 'add') {
+    showBanner('TAG');
+    console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Create Tag')}`);
+    const lightweight = args.includes('--lightweight');
+    await createTag(args[1], args[2], args[3], lightweight);
+    return;
+  }
+
+  if (action === 'delete' || action === 'del' || action === 'rm') {
+    showBanner('TAG');
+    console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Delete Tag')}`);
+    await deleteTag(args[1]);
+    return;
+  }
+
+  // Default: create tag
+  showBanner('TAG');
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Create Tag')}`);
+  await createTag(action);
+};

package/commands/undo.js

@@ -0,0 +1,200 @@
+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 getReflog = (limit = 30) => {
+  const result = execGit(`reflog --format="%gd|%ar|%gs" -n ${limit}`, { silent: true });
+  if (!result.success) return [];
+
+  return result.output
+    .trim()
+    .split('\n')
+    .filter(Boolean)
+    .map((line) => {
+      const [ref, date, ...messageParts] = line.split('|');
+      return {
+        ref,
+        date,
+        message: messageParts.join('|'),
+      };
+    });
+};
+
+const showReflog = () => {
+  const entries = getReflog();
+
+  if (entries.length === 0) {
+    console.log(chalk.dim('No reflog entries found'));
+    return;
+  }
+
+  const rows = entries.map((entry) => [
+    chalk.cyan(entry.ref),
+    chalk.gray(entry.date),
+    entry.message,
+  ]);
+
+  console.log(`\n${createTable(['Ref', 'Date', 'Action'], rows)}`);
+};
+
+const resetToRef = async (ref) => {
+  const entries = getReflog();
+
+  if (!ref) {
+    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 ref: gittable undo reset <ref>'));
+      process.exit(1);
+    }
+
+    if (entries.length === 0) {
+      clack.cancel(chalk.yellow('No reflog entries available'));
+      return;
+    }
+
+    const options = entries.slice(0, 20).map((entry) => ({
+      value: entry.ref,
+      label: `${entry.ref} - ${entry.message}`,
+    }));
+
+    ref = await clack.select({
+      message: chalk.cyan('Select commit to reset to:'),
+      options,
+    });
+
+    if (clack.isCancel(ref)) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+  }
+
+  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: gittable undo reset <ref> --soft|--mixed|--hard'));
+    process.exit(1);
+  }
+
+  const mode = await clack.select({
+    message: chalk.cyan('Reset mode:'),
+    options: [
+      { value: '--soft', label: 'Soft (keep changes staged)' },
+      { value: '--mixed', label: 'Mixed (keep changes unstaged)', hint: 'default' },
+      { value: '--hard', label: 'Hard (discard all changes)', hint: 'dangerous' },
+    ],
+  });
+
+  if (clack.isCancel(mode)) {
+    clack.cancel(chalk.yellow('Cancelled'));
+    return;
+  }
+
+  if (mode === '--hard') {
+    const confirm = await clack.confirm({
+      message: chalk.red('Hard reset will discard all changes. Continue?'),
+      initialValue: false,
+    });
+
+    if (clack.isCancel(confirm) || !confirm) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+  }
+
+  const spinner = clack.spinner();
+  spinner.start(`Resetting to ${ref}`);
+
+  const result = execGit(`reset ${mode} ${ref}`, { silent: false });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold(`Reset to ${ref}`));
+  } else {
+    clack.cancel(chalk.red('Reset failed'));
+    console.error(result.error);
+    process.exit(1);
+  }
+};
+
+const undoLastCommit = async () => {
+  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 reset --soft|--mixed|--hard HEAD~1'));
+    process.exit(1);
+  }
+
+  const mode = await clack.select({
+    message: chalk.cyan('Undo last commit:'),
+    options: [
+      { value: '--soft', label: 'Keep changes staged' },
+      { value: '--mixed', label: 'Keep changes unstaged', hint: 'default' },
+      { value: '--hard', label: 'Discard all changes', hint: 'dangerous' },
+    ],
+  });
+
+  if (clack.isCancel(mode)) {
+    clack.cancel(chalk.yellow('Cancelled'));
+    return;
+  }
+
+  if (mode === '--hard') {
+    const confirm = await clack.confirm({
+      message: chalk.red('This will discard all changes. Continue?'),
+      initialValue: false,
+    });
+
+    if (clack.isCancel(confirm) || !confirm) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+  }
+
+  const spinner = clack.spinner();
+  spinner.start('Undoing last commit');
+
+  const result = execGit(`reset ${mode} HEAD~1`, { silent: false });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold('Last commit undone'));
+  } else {
+    clack.cancel(chalk.red('Failed to undo commit'));
+    console.error(result.error);
+    process.exit(1);
+  }
+};
+
+module.exports = async (args) => {
+  const action = args[0];
+
+  if (action === 'reflog' || action === 'log') {
+    showBanner('UNDO');
+    console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Reflog Browser')}`);
+    showReflog();
+    clack.outro(chalk.green.bold('Done'));
+    return;
+  }
+
+  if (action === 'reset') {
+    showBanner('UNDO');
+    console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Reset to Commit')}`);
+    await resetToRef(args[1]);
+    return;
+  }
+
+  if (action === 'last' || !action) {
+    showBanner('UNDO');
+    console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Undo Last Commit')}`);
+    await undoLastCommit();
+    return;
+  }
+
+  // Try to reset to the provided ref
+  showBanner('UNDO');
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Reset to Commit')}`);
+  await resetToRef(action);
+};