gittable 1.0.0

package/cli.js

@@ -0,0 +1,342 @@
+#!/usr/bin/env node
+
+const clack = require('@clack/prompts');
+const chalk = require('chalk');
+const { isGitRepo } = require('./lib/git/exec');
+
+// Command aliases mapping
+const COMMANDS = {
+  status: require('./commands/status'),
+  st: require('./commands/status'),
+
+  branch: require('./commands/branch'),
+  br: require('./commands/branch'),
+  co: require('./commands/branch'),
+
+  commit: require('./commands/commit'),
+  ci: require('./commands/commit'),
+
+  pull: require('./commands/pull'),
+  pl: require('./commands/pull'),
+
+  push: require('./commands/push'),
+  ps: require('./commands/push'),
+
+  sync: require('./commands/sync'),
+
+  merge: require('./commands/merge'),
+
+  rebase: require('./commands/rebase'),
+
+  stash: require('./commands/stash'),
+
+  log: require('./commands/log'),
+
+  undo: require('./commands/undo'),
+  reset: require('./commands/undo'),
+
+  // New commands
+  add: require('./commands/add'),
+  diff: require('./commands/diff'),
+  init: require('./commands/init'),
+  uninit: require('./commands/uninit'),
+  deinit: require('./commands/uninit'),
+  clone: require('./commands/clone'),
+  fetch: require('./commands/fetch'),
+  remote: require('./commands/remote'),
+  tag: require('./commands/tag'),
+  show: require('./commands/show'),
+  checkout: require('./commands/checkout'),
+  revert: require('./commands/revert'),
+  'cherry-pick': require('./commands/cherry-pick'),
+  clean: require('./commands/clean'),
+  config: require('./commands/config'),
+  blame: require('./commands/blame'),
+  grep: require('./commands/grep'),
+  rm: require('./commands/rm'),
+  mv: require('./commands/mv'),
+  restore: require('./commands/restore'),
+};
+
+const VERSION = require('./package.json').version;
+const { showBanner } = require('./lib/ui/banner');
+const { createLink } = require('./lib/utils/terminal-link');
+
+// Command categories
+const COMMAND_CATEGORIES = {
+  core: {
+    name: 'Core Commands',
+    commands: [
+      { name: 'status', aliases: ['st'], description: 'Show repository status' },
+      {
+        name: 'branch',
+        aliases: ['br', 'co'],
+        description: 'Branch management (list, create, checkout, delete)',
+      },
+      { name: 'commit', aliases: ['ci'], description: 'Create commits with conventional format' },
+      { name: 'pull', aliases: ['pl'], description: 'Fetch and merge from remote' },
+      { name: 'push', aliases: ['ps'], description: 'Push to remote' },
+      { name: 'sync', aliases: [], description: 'Synchronize (pull + rebase + push)' },
+      { name: 'merge', aliases: [], description: 'Merge branches' },
+      { name: 'rebase', aliases: [], description: 'Rebase operations' },
+      { name: 'stash', aliases: [], description: 'Stash management' },
+      { name: 'log', aliases: [], description: 'View commit history' },
+      { name: 'undo', aliases: ['reset'], description: 'Undo operations and reflog browser' },
+    ],
+  },
+  file: {
+    name: 'File Operations',
+    commands: [
+      { name: 'add', aliases: [], description: 'Stage files for commit' },
+      { name: 'diff', aliases: [], description: 'Show changes' },
+      { name: 'checkout', aliases: [], description: 'Checkout files' },
+      { name: 'restore', aliases: [], description: 'Restore files from index or commit' },
+      { name: 'rm', aliases: [], description: 'Remove files from git' },
+      { name: 'mv', aliases: [], description: 'Move/rename files' },
+      { name: 'clean', aliases: [], description: 'Remove untracked files' },
+    ],
+  },
+  repo: {
+    name: 'Repository Management',
+    commands: [
+      { name: 'init', aliases: [], description: 'Initialize a new repository' },
+      { name: 'uninit', aliases: ['deinit'], description: 'Remove git repository (clear history)' },
+      { name: 'clone', aliases: [], description: 'Clone a repository' },
+      { name: 'remote', aliases: [], description: 'Manage remote repositories' },
+      { name: 'fetch', aliases: [], description: 'Fetch from remote' },
+      { name: 'tag', aliases: [], description: 'Tag management' },
+      { name: 'config', aliases: [], description: 'Git configuration management' },
+    ],
+  },
+  history: {
+    name: 'History & Inspection',
+    commands: [
+      { name: 'show', aliases: [], description: 'Show commit details' },
+      { name: 'revert', aliases: [], description: 'Revert commits' },
+      { name: 'cherry-pick', aliases: [], description: 'Apply commits from another branch' },
+      { name: 'blame', aliases: [], description: 'Show who last modified each line' },
+      { name: 'grep', aliases: [], description: 'Search in repository' },
+    ],
+  },
+};
+
+const showHelp = () => {
+  // Show banner
+  showBanner('GITTABLE', { version: VERSION });
+
+  // GitHub link at the top
+  const repoLink = createLink('GitHub', 'https://github.com/GG-Santos/Gittable');
+  console.log(`${chalk.gray('├')}  ${chalk.dim(repoLink)}`);
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Modern Git CLI with Interactive Prompts')}`);
+  console.log(
+    chalk.gray('├') +
+      '  ' +
+      chalk.yellow('Usage:') +
+      ' ' +
+      chalk.white('gittable <command> [options]')
+  );
+  console.log(chalk.gray('│'));
+
+  // Core Commands
+  console.log(chalk.bold.cyan('  Core Commands:'));
+  console.log();
+  for (const cmd of COMMAND_CATEGORIES.core.commands) {
+    const cmdList = [cmd.name, ...cmd.aliases].join(', ');
+    console.log(`    ${chalk.cyan(cmdList.padEnd(20))} ${chalk.gray(cmd.description)}`);
+  }
+  console.log();
+
+  // File Operations
+  console.log(chalk.bold.cyan('  File Operations:'));
+  console.log();
+  for (const cmd of COMMAND_CATEGORIES.file.commands) {
+    const cmdList = [cmd.name, ...cmd.aliases].join(', ');
+    console.log(`    ${chalk.cyan(cmdList.padEnd(20))} ${chalk.gray(cmd.description)}`);
+  }
+  console.log();
+
+  // Repository Management
+  console.log(chalk.bold.cyan('  Repository Management:'));
+  console.log();
+  for (const cmd of COMMAND_CATEGORIES.repo.commands) {
+    const cmdList = [cmd.name, ...cmd.aliases].join(', ');
+    console.log(`    ${chalk.cyan(cmdList.padEnd(20))} ${chalk.gray(cmd.description)}`);
+  }
+  console.log();
+
+  // History & Inspection
+  console.log(chalk.bold.cyan('  History & Inspection:'));
+  console.log();
+  for (const cmd of COMMAND_CATEGORIES.history.commands) {
+    const cmdList = [cmd.name, ...cmd.aliases].join(', ');
+    console.log(`    ${chalk.cyan(cmdList.padEnd(20))} ${chalk.gray(cmd.description)}`);
+  }
+  console.log();
+};
+
+const showInteractiveMenu = async () => {
+  showBanner('GITTABLE', { version: VERSION });
+
+  const category = await clack.select({
+    message: chalk.cyan('Select a category:'),
+    options: [
+      { value: 'core', label: chalk.cyan('Core Commands') },
+      { value: 'file', label: chalk.cyan('File Operations') },
+      { value: 'repo', label: chalk.cyan('Repository Management') },
+      { value: 'history', label: chalk.cyan('History & Inspection') },
+      { value: 'help', label: chalk.yellow('List Commands') },
+      { value: 'exit', label: chalk.red('Exit') },
+    ],
+  });
+
+  if (clack.isCancel(category) || category === 'exit') {
+    clack.cancel(chalk.yellow('Cancelled'));
+    return;
+  }
+
+  if (category === 'help') {
+    showHelp();
+    return;
+  }
+
+  // Show commands in selected category
+  const categoryData = COMMAND_CATEGORIES[category];
+  const commandOptions = categoryData.commands.map((cmd) => ({
+    value: cmd.name,
+    label: `${chalk.cyan(cmd.name)} ${chalk.gray(`- ${cmd.description}`)}`,
+  }));
+
+  // Add back option
+  commandOptions.push({
+    value: '__back__',
+    label: chalk.dim('← Back to categories'),
+  });
+
+  const selectedCommand = await clack.select({
+    message: chalk.cyan(`Select a command from ${categoryData.name}:`),
+    options: commandOptions,
+  });
+
+  if (clack.isCancel(selectedCommand) || selectedCommand === '__back__') {
+    // Recursively show menu again
+    return showInteractiveMenu();
+  }
+
+  // Execute the selected command
+  if (COMMANDS[selectedCommand]) {
+    // Check if we're in a git repo (except for init, uninit, and clone)
+    if (
+      !isGitRepo() &&
+      selectedCommand !== 'init' &&
+      selectedCommand !== 'uninit' &&
+      selectedCommand !== 'clone'
+    ) {
+      clack.cancel(chalk.red('Not a git repository'));
+      console.log();
+      console.log(`${chalk.gray('├')}  ${chalk.yellow('Tip:')}`);
+      console.log(`${chalk.gray('│')}  ${chalk.gray('Initialize a new repository with:')}`);
+      console.log(`${chalk.gray('│')}  ${chalk.cyan('  gittable init')}`);
+      console.log(chalk.gray('│'));
+      console.log(`${chalk.gray('└')}  ${chalk.gray('Or clone an existing repository with:')}`);
+      console.log(chalk.gray('    ') + chalk.cyan('  gittable clone <url>'));
+      console.log();
+      return;
+    }
+
+    try {
+      await COMMANDS[selectedCommand]([]);
+    } catch (error) {
+      clack.cancel(chalk.red('Command failed'));
+      console.error(error);
+      process.exit(1);
+    }
+  } else {
+    clack.cancel(chalk.red(`Command '${selectedCommand}' not found`));
+    process.exit(1);
+  }
+};
+
+const main = async () => {
+  const args = process.argv.slice(2);
+
+  if (args[0] === '--help' || args[0] === '-h') {
+    showHelp();
+    process.exit(0);
+  }
+
+  if (args[0] === '--version' || args[0] === '-v') {
+    showBanner('GITTABLE', { version: VERSION });
+    console.log();
+    clack.outro(chalk.green(`Version ${VERSION}`));
+    process.exit(0);
+  }
+
+  // If no arguments provided and TTY is available, show interactive menu
+  if (args.length === 0 && process.stdin.isTTY) {
+    try {
+      await showInteractiveMenu();
+      process.exit(0);
+    } catch (error) {
+      clack.cancel(chalk.red('Menu failed'));
+      console.error(error);
+      process.exit(1);
+    }
+  }
+
+  // If no arguments and not TTY, show help
+  if (args.length === 0) {
+    showHelp();
+    process.exit(0);
+  }
+
+  const command = args[0].toLowerCase();
+  const commandArgs = args.slice(1);
+
+  if (!COMMANDS[command]) {
+    showBanner('GITTABLE', { version: VERSION });
+    console.log();
+    clack.cancel(chalk.red(`Unknown command: ${chalk.bold(command)}`));
+    console.log();
+    console.log(`${chalk.gray('├')}  ${chalk.yellow('Available commands:')}`);
+    console.log(chalk.gray('│'));
+
+    // Show some common commands as suggestions
+    const suggestions = Object.keys(COMMANDS).slice(0, 10);
+    for (const cmd of suggestions) {
+      console.log(`${chalk.gray('│')}  ${chalk.cyan(`  ${cmd}`)}`);
+    }
+
+    console.log(chalk.gray('│'));
+    console.log(
+      `${chalk.gray('└')}  ${chalk.gray('Run "gittable --help" for full usage information')}`
+    );
+    console.log();
+    process.exit(1);
+  }
+
+  // Check if we're in a git repo (except for help/version, init, uninit, and clone)
+  if (!isGitRepo() && command !== 'init' && command !== 'uninit' && command !== 'clone') {
+    showBanner('GITTABLE', { version: VERSION });
+    console.log();
+    clack.cancel(chalk.red('Not a git repository'));
+    console.log();
+    console.log(`${chalk.gray('├')}  ${chalk.yellow('Tip:')}`);
+    console.log(`${chalk.gray('│')}  ${chalk.gray('Initialize a new repository with:')}`);
+    console.log(`${chalk.gray('│')}  ${chalk.cyan('  gittable init')}`);
+    console.log(chalk.gray('│'));
+    console.log(`${chalk.gray('└')}  ${chalk.gray('Or clone an existing repository with:')}`);
+    console.log(chalk.gray('    ') + chalk.cyan('  gittable clone <url>'));
+    console.log();
+    process.exit(1);
+  }
+
+  try {
+    await COMMANDS[command](commandArgs);
+  } catch (error) {
+    clack.cancel(chalk.red('Command failed'));
+    console.error(error);
+    process.exit(1);
+  }
+};
+
+main();

package/commands/add.js

@@ -0,0 +1,159 @@
+const clack = require('@clack/prompts');
+const chalk = require('chalk');
+const { execGit, getStatus } = require('../lib/git/exec');
+const { showBanner } = require('../lib/ui/banner');
+
+const stageFiles = async (files) => {
+  if (!files || 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 add <file1> <file2> ...'));
+      console.log(chalk.gray('  - gittable add --all (or -A)'));
+      process.exit(1);
+    }
+
+    // Interactive mode: show unstaged files
+    const status = getStatus();
+    if (!status) {
+      clack.cancel(chalk.red('Failed to get repository status'));
+      process.exit(1);
+    }
+
+    const allFiles = [
+      ...status.unstaged.map((f) => ({
+        value: f.file,
+        label: chalk.yellow(`M ${f.file}`),
+        hint: 'modified',
+      })),
+      ...status.untracked.map((f) => ({
+        value: f,
+        label: chalk.green(`? ${f}`),
+        hint: 'untracked',
+      })),
+    ];
+
+    if (allFiles.length === 0) {
+      clack.cancel(chalk.yellow('No files to stage'));
+      return;
+    }
+
+    const selected = await clack.multiselect({
+      message: chalk.cyan('Select files to stage:'),
+      options: allFiles,
+    });
+
+    if (clack.isCancel(selected)) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+
+    files = selected;
+  }
+
+  const spinner = clack.spinner();
+  spinner.start(`Staging ${files.length} file(s)`);
+
+  const result = execGit(`add ${files.join(' ')}`, { silent: false });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold(`Staged ${files.length} file(s)`));
+  } else {
+    clack.cancel(chalk.red('Failed to stage files'));
+    console.error(result.error);
+    process.exit(1);
+  }
+};
+
+const stageAll = async () => {
+  const confirm = await clack.confirm({
+    message: chalk.cyan('Stage all changes?'),
+    initialValue: false,
+  });
+
+  if (clack.isCancel(confirm) || !confirm) {
+    clack.cancel(chalk.yellow('Cancelled'));
+    return;
+  }
+
+  const spinner = clack.spinner();
+  spinner.start('Staging all changes');
+
+  const result = execGit('add -A', { silent: false });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold('Staged all changes'));
+  } else {
+    clack.cancel(chalk.red('Failed to stage files'));
+    console.error(result.error);
+    process.exit(1);
+  }
+};
+
+const unstageFiles = async (files) => {
+  if (!files || files.length === 0) {
+    const status = getStatus();
+    if (!status || status.staged.length === 0) {
+      clack.cancel(chalk.yellow('No staged files to unstage'));
+      return;
+    }
+
+    const options = status.staged.map((f) => ({
+      value: f.file,
+      label: `${f.status} ${f.file}`,
+    }));
+
+    const selected = await clack.multiselect({
+      message: chalk.cyan('Select files to unstage:'),
+      options,
+    });
+
+    if (clack.isCancel(selected)) {
+      clack.cancel(chalk.yellow('Cancelled'));
+      return;
+    }
+
+    files = selected;
+  }
+
+  const spinner = clack.spinner();
+  spinner.start(`Unstaging ${files.length} file(s)`);
+
+  const result = execGit(`reset HEAD -- ${files.join(' ')}`, { silent: false });
+  spinner.stop();
+
+  if (result.success) {
+    clack.outro(chalk.green.bold(`Unstaged ${files.length} file(s)`));
+  } else {
+    clack.cancel(chalk.red('Failed to unstage files'));
+    console.error(result.error);
+    process.exit(1);
+  }
+};
+
+module.exports = async (args) => {
+  const action = args[0];
+
+  if (action === '--all' || action === '-A') {
+    showBanner('ADD');
+    console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Stage All Changes')}`);
+    await stageAll();
+    return;
+  }
+
+  if (action === '--unstage' || action === 'unstage') {
+    showBanner('ADD');
+    console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Unstage Files')}`);
+    await unstageFiles(args.slice(1));
+    return;
+  }
+
+  // Default: stage files
+  showBanner('ADD');
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Stage Files')}`);
+  await stageFiles(args);
+};

package/commands/blame.js

@@ -0,0 +1,33 @@
+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('BLAME');
+  console.log(`${chalk.gray('├')}  ${chalk.cyan.bold('Blame File')}`);
+
+  const file = args[0];
+  const revision = args.find((arg) => !arg.startsWith('--'));
+
+  if (!file) {
+    clack.cancel(chalk.yellow('No file specified'));
+    return;
+  }
+
+  let command = 'blame';
+  if (revision && revision !== file) {
+    command += ` ${revision}`;
+  }
+  command += ` ${file}`;
+
+  const result = execGit(command, { silent: false });
+
+  if (!result.success) {
+    clack.cancel(chalk.red('Failed to show blame'));
+    console.error(result.error);
+    process.exit(1);
+  }
+
+  clack.outro(chalk.green.bold('Done'));
+};