gittable 1.0.0

package/lib/git/exec.js

@@ -0,0 +1,222 @@
+const { execSync } = require('node:child_process');
+
+/**
+ * Execute a git command and return the output
+ */
+const execGit = (command, options = {}) => {
+  const { silent = false, encoding = 'utf8' } = options;
+
+  try {
+    const result = execSync(`git ${command}`, {
+      encoding,
+      stdio: silent ? ['pipe', 'pipe', 'pipe'] : 'inherit',
+      ...options,
+    });
+    return { success: true, output: result, error: null };
+  } catch (error) {
+    const stdout = error.stdout?.toString() || '';
+    const stderr = error.stderr?.toString() || '';
+    return {
+      success: false,
+      output: stdout,
+      error: stderr || error.message,
+    };
+  }
+};
+
+/**
+ * Check if we're in a git repository
+ */
+const isGitRepo = () => {
+  const result = execGit('rev-parse --git-dir', { silent: true });
+  return result.success;
+};
+
+/**
+ * Get current branch name
+ */
+const getCurrentBranch = () => {
+  const result = execGit('rev-parse --abbrev-ref HEAD', { silent: true });
+  return result.success ? result.output.trim() : null;
+};
+
+/**
+ * Get repository status
+ */
+const getStatus = () => {
+  const result = execGit('status --porcelain', { silent: true });
+  if (!result.success) return null;
+
+  const lines = result.output.trim().split('\n').filter(Boolean);
+  const status = {
+    staged: [],
+    unstaged: [],
+    untracked: [],
+    ahead: 0,
+    behind: 0,
+    diverged: false,
+  };
+
+  for (const line of lines) {
+    const staged = line[0];
+    const unstaged = line[1];
+    const file = line.slice(3);
+
+    if (staged !== ' ' && staged !== '?') {
+      status.staged.push({ status: staged, file });
+    }
+    if (unstaged !== ' ' && unstaged !== '?') {
+      if (unstaged === '?') {
+        status.untracked.push(file);
+      } else {
+        status.unstaged.push({ status: unstaged, file });
+      }
+    }
+  }
+
+  // Check ahead/behind
+  const branchResult = execGit('rev-list --left-right --count HEAD...@{u}', { silent: true });
+  if (branchResult.success) {
+    const [behind, ahead] = branchResult.output.trim().split('\t').map(Number);
+    status.ahead = ahead || 0;
+    status.behind = behind || 0;
+    status.diverged = ahead > 0 && behind > 0;
+  }
+
+  return status;
+};
+
+/**
+ * Get list of branches
+ */
+const getBranches = () => {
+  const localResult = execGit('branch -vv', { silent: true });
+  const remoteResult = execGit('branch -r', { silent: true });
+
+  const branches = {
+    local: [],
+    remote: [],
+    current: null,
+  };
+
+  if (localResult.success) {
+    const localLines = localResult.output.trim().split('\n').filter(Boolean);
+    for (const line of localLines) {
+      const isCurrent = line.startsWith('*');
+      const trimmed = line.replace(/^\*\s*/, '').trim();
+
+      // Parse: branch-name [upstream: ahead/behind] or branch-name
+      const match = trimmed.match(/^(\S+)(?:\s+\[([^\]]+)\])?/);
+      if (match) {
+        const name = match[1];
+        const upstreamInfo = match[2] || '';
+
+        // Extract upstream branch name (before colon or space)
+        const upstreamMatch = upstreamInfo.match(/^([^:]+)/);
+        const upstream = upstreamMatch ? upstreamMatch[1].trim() : null;
+
+        if (isCurrent) {
+          branches.current = name;
+        }
+
+        branches.local.push({
+          name,
+          current: isCurrent,
+          upstream: upstream,
+        });
+      }
+    }
+  }
+
+  if (remoteResult.success) {
+    const remoteLines = remoteResult.output.trim().split('\n').filter(Boolean);
+    for (const line of remoteLines) {
+      const trimmed = line.trim();
+      // Remove remote prefix (e.g., "origin/")
+      const match = trimmed.match(/^(\S+?)\/(.+)$/);
+      if (match) {
+        branches.remote.push({
+          name: match[2],
+          remote: match[1],
+        });
+      }
+    }
+  }
+
+  return branches;
+};
+
+/**
+ * Get commit log
+ */
+const getLog = (limit = 20, format = '%h|%an|%ar|%s') => {
+  const result = execGit(`log --format="${format}" -n ${limit}`, { silent: true });
+  if (!result.success) return [];
+
+  return result.output
+    .trim()
+    .split('\n')
+    .filter(Boolean)
+    .map((line) => {
+      const [hash, author, date, ...messageParts] = line.split('|');
+      return {
+        hash,
+        author,
+        date,
+        message: messageParts.join('|'),
+      };
+    });
+};
+
+/**
+ * Get stash list
+ */
+const getStashList = () => {
+  const result = execGit('stash list --format="%gd|%ar|%gs"', { silent: true });
+  if (!result.success) return [];
+
+  return result.output
+    .trim()
+    .split('\n')
+    .filter(Boolean)
+    .map((line) => {
+      const parts = line.split('|');
+      const ref = parts[0] || '';
+      const date = parts[1] || '';
+      const message = parts.slice(2).join('|') || '';
+      return {
+        ref,
+        date,
+        message,
+      };
+    });
+};
+
+/**
+ * Check if a remote exists
+ */
+const remoteExists = (remoteName = 'origin') => {
+  const result = execGit(`remote get-url ${remoteName}`, { silent: true });
+  return result.success;
+};
+
+/**
+ * Get list of remotes
+ */
+const getRemotes = () => {
+  const result = execGit('remote', { silent: true });
+  if (!result.success) return [];
+  return result.output.trim().split('\n').filter(Boolean);
+};
+
+module.exports = {
+  execGit,
+  isGitRepo,
+  getCurrentBranch,
+  getStatus,
+  getBranches,
+  getLog,
+  getStashList,
+  remoteExists,
+  getRemotes,
+};

package/lib/ui/ascii.js

@@ -0,0 +1,154 @@
+const chalk = require('chalk');
+
+// ASCII art letter definitions from ASCII ART Reference.md
+const ASCII_LETTERS = {
+  A: [
+    ' ______      ',
+    '/\\  __ \\     ',
+    '\\ \\  __ \\    ',
+    ' \\ \\_\\ \\_\\   ',
+    '  \\/_/\\/_/   ',
+  ],
+  B: [' ______      ', '/\\  == \\     ', '\\ \\  __<     ', ' \\ \\_____\\   ', '  \\/_____/   '],
+  C: [' ______     ', '/\\  ___\\    ', '\\ \\ \\____   ', ' \\ \\_____\\  ', '  \\/_____/  '],
+  D: [' _____       ', '/\\  __-.     ', '\\ \\ \\/\\ \\    ', ' \\ \\____-    ', '  \\/____/    '],
+  E: [' ______      ', '/\\  ___\\     ', '\\ \\  __\\     ', ' \\ \\_____\\   ', '  \\/_____/   '],
+  F: [' ______     ', '/\\  ___\\    ', '\\ \\  __\\    ', ' \\ \\_\\      ', '  \\/_/      '],
+  G: [
+    ' ______      ',
+    '/\\  ___\\     ',
+    '\\ \\ \\__ \\    ',
+    ' \\ \\_____\\   ',
+    '  \\/_____/   ',
+  ],
+  H: [
+    ' __  __      ',
+    '/\\ \\_\\ \\     ',
+    '\\ \\  __ \\    ',
+    ' \\ \\_\\ \\_\\   ',
+    '  \\/_/\\/_/   ',
+  ],
+  I: [' __    ', '/\\ \\   ', '\\ \\ \\  ', ' \\ \\_\\ ', '  \\/_/ '],
+  J: ['   __        ', '  /\\ \\       ', ' _\\_\\ \\      ', '/\\_____\\     ', '\\/_____/     '],
+  K: [
+    ' __  __      ',
+    '/\\ \\/ /      ',
+    '\\ \\  _"-.    ',
+    ' \\ \\_\\ \\_\\   ',
+    '  \\/_/\\/_/   ',
+  ],
+  L: [' __          ', '/\\ \\         ', '\\ \\ \\____    ', ' \\ \\_____\\   ', '  \\/_____/   '],
+  M: [
+    ' __    __    ',
+    '/\\ "-./  \\   ',
+    '\\ \\ \\-./\\ \\  ',
+    ' \\ \\_\\ \\ \\_\\ ',
+    '  \\/_/  \\/_/ ',
+  ],
+  N: [
+    ' __   __     ',
+    '/\\ "-.\\ \\    ',
+    '\\ \\ \\-.  \\   ',
+    ' \\ \\_\\\\"\\_\\  ',
+    '  \\/_/ \\/_/  ',
+  ],
+  O: [' ______     ', '/\\  __ \\    ', '\\ \\ \\/\\ \\   ', ' \\ \\_____\\  ', '  \\/_____/  '],
+  P: [' ______      ', '/\\  == \\     ', '\\ \\  _-/     ', ' \\ \\_\\       ', '  \\/_/       '],
+  Q: [
+    ' ______      ',
+    '/\\  __ \\     ',
+    '\\ \\ \\/\\_\\    ',
+    ' \\ \\___\\_\\   ',
+    '  \\/___/_/   ',
+  ],
+  R: [
+    ' ______      ',
+    '/\\  == \\     ',
+    '\\ \\  __<     ',
+    ' \\ \\_\\ \\_\\   ',
+    '  \\/_/ /_/   ',
+  ],
+  S: [' ______      ', '/\\  ___\\     ', '\\ \\___  \\    ', ' \\/\\_____\\   ', '  \\/_____/   '],
+  T: [' ______      ', '/\\__  _\\     ', '\\/_/\\ \\/     ', '   \\ \\_\\     ', '    \\/_/     '],
+  U: [
+    ' __  __      ',
+    '/\\ \\/\\ \\     ',
+    '\\ \\ \\_\\ \\    ',
+    ' \\ \\_____\\   ',
+    '  \\/_____/   ',
+  ],
+  V: [' __   __     ', '/\\ \\ / /     ', "\\ \\ \\'/      ", ' \\ \\__|      ', '  \\/_/       '],
+  W: [
+    ' __     __   ',
+    '/\\ \\  _ \\ \\  ',
+    '\\ \\ \\/ ".\\ \\ ',
+    ' \\ \\__/".~\\_\\',
+    '  \\/_/   \\/_/',
+  ],
+  X: [
+    ' __  __      ',
+    '/\\_\\_\\_\\     ',
+    '\\/_/\\_\\/_    ',
+    '  /\\_\\/\\_\\   ',
+    '  \\/_/\\/_/   ',
+  ],
+  Y: [
+    ' __  __      ',
+    '/\\ \\_\\ \\     ',
+    '\\ \\____ \\    ',
+    ' \\/\\_____\\   ',
+    '  \\/_____/   ',
+  ],
+  Z: [' ______      ', '/\\___  \\     ', '\\/_/  /__    ', '  /\\_____\\   ', '  \\/_____/   '],
+};
+
+/**
+ * Generate ASCII art for a word
+ * @param {string} word - The word to convert to ASCII art
+ * @param {object} options - Options for formatting
+ * @param {string} options.color - Chalk color to apply (default: 'cyan')
+ * @returns {string} - Formatted ASCII art
+ */
+function generateASCII(word, options = {}) {
+  const { color = 'cyan' } = options;
+  const upperWord = word.toUpperCase();
+  const letters = upperWord.split('');
+
+  // Filter out non-letter characters (spaces, numbers, etc.)
+  const validLetters = letters.filter((char) => ASCII_LETTERS[char]);
+
+  if (validLetters.length === 0) {
+    return '';
+  }
+
+  // Get the height of ASCII art (all letters have the same height)
+  const height = ASCII_LETTERS[validLetters[0]].length;
+
+  // Combine letters horizontally
+  const lines = [];
+  for (let i = 0; i < height; i++) {
+    const line = validLetters.map((letter) => ASCII_LETTERS[letter][i]).join('');
+    lines.push(line);
+  }
+
+  // Apply color if specified
+  const coloredLines = color ? lines.map((line) => chalk[color](line)) : lines;
+
+  return coloredLines.join('\n');
+}
+
+/**
+ * Get ASCII art for a command name
+ * @param {string} commandName - The command name
+ * @param {object} options - Options for formatting
+ * @returns {string} - Formatted ASCII art
+ */
+function getCommandASCII(commandName, options = {}) {
+  return generateASCII(commandName, options);
+}
+
+module.exports = {
+  generateASCII,
+  getCommandASCII,
+  ASCII_LETTERS,
+};

package/lib/ui/banner.js

@@ -0,0 +1,80 @@
+const chalk = require('chalk');
+const { getCommandASCII } = require('./ascii');
+const commandVersions = require('../versions');
+
+/**
+ * Create a banner for a command with ASCII art, borders, and version
+ * @param {string} commandName - The command name (e.g., 'COMMIT', 'STATUS')
+ * @param {object} options - Banner options
+ * @param {string} options.color - Color for ASCII art (default: 'cyan')
+ * @param {string} options.version - Version override (default: from versions.js)
+ * @param {string} options.borderColor - Border color (default: 'gray')
+ * @param {string} options.contentColor - Content color (default: 'cyan')
+ * @returns {string} - Formatted banner
+ */
+function createBanner(commandName, options = {}) {
+  const {
+    version = commandVersions[commandName.toLowerCase()] || '1.0.0',
+    borderColor = 'gray',
+    contentColor = 'cyan',
+  } = options;
+
+  // Get ASCII art for the command
+  const asciiArt = getCommandASCII(commandName, { color: contentColor });
+  const asciiLines = asciiArt.split('\n').filter(Boolean);
+
+  if (asciiLines.length === 0) {
+    return '';
+  }
+
+  // Calculate width (use the longest line)
+  const WIDTH = Math.max(...asciiLines.map((line) => line.length));
+
+  const border = chalk[borderColor];
+  const content = chalk[contentColor];
+
+  // Helper functions
+  // Each framed line is: │ + space + content (WIDTH) + space + │ = WIDTH + 4 total
+  const _TOTAL_WIDTH = WIDTH + 4;
+  const pad = (text = '') => text.padEnd(WIDTH - 7);
+  const framedLine = (text = '') => `${border('│')} ${content(pad(text))} ${border('│')}`;
+  const topBorder = (title) => {
+    // Top border: ┌ + space + title + spaces + dashes + ╮ = TOTAL_WIDTH
+    // ┌ (1) + space (1) + titleText (titleLen) + dashes (dashCount) + ╮ (1) = WIDTH + 4
+    // So: 3 + titleLen + dashCount = WIDTH + 4
+    // Therefore: dashCount = WIDTH + 1 - titleLen
+    const titleText = `${title}  `;
+    const titleLen = titleText.length;
+    const dashCount = WIDTH - 7 - titleLen;
+    return border(`${titleText}${'─'.repeat(dashCount)}╮`);
+  };
+  const bottomBorder = () => border(`├${'─'.repeat(WIDTH - 5)}╯`);
+
+  // Build banner
+  const banner = [
+    topBorder(`${commandName} v${version}`),
+    ...asciiLines.map((line) => framedLine(`   ${line}`)),
+    framedLine(),
+    bottomBorder(),
+  ].join('\n');
+
+  return banner;
+}
+
+/**
+ * Display banner using clack.intro
+ * @param {string} commandName - The command name
+ * @param {object} options - Banner options
+ */
+function showBanner(commandName, options = {}) {
+  const banner = createBanner(commandName, options);
+  if (banner) {
+    const clack = require('@clack/prompts');
+    clack.intro(banner);
+  }
+}
+
+module.exports = {
+  createBanner,
+  showBanner,
+};

package/lib/ui/status-display.js

@@ -0,0 +1,90 @@
+const chalk = require('chalk');
+const { createTable } = require('./table');
+
+const STATUS_COLORS = {
+  M: chalk.yellow, // Modified
+  A: chalk.green, // Added
+  D: chalk.red, // Deleted
+  R: chalk.blue, // Renamed
+  C: chalk.magenta, // Copied
+  U: chalk.red, // Unmerged
+  '?': chalk.gray, // Untracked
+};
+
+const STATUS_LABELS = {
+  M: 'Modified',
+  A: 'Added',
+  D: 'Deleted',
+  R: 'Renamed',
+  C: 'Copied',
+  U: 'Unmerged',
+  '?': 'Untracked',
+};
+
+/**
+ * Display repository status in a formatted way
+ */
+const displayStatus = (status, branch) => {
+  const sections = [];
+
+  // Branch info
+  if (branch) {
+    sections.push(chalk.cyan.bold(`\nOn branch ${branch}`));
+  }
+
+  // Ahead/Behind info
+  if (status.ahead > 0 || status.behind > 0) {
+    const info = [];
+    if (status.ahead > 0) {
+      info.push(chalk.green(`${status.ahead} ahead`));
+    }
+    if (status.behind > 0) {
+      info.push(chalk.red(`${status.behind} behind`));
+    }
+    if (status.diverged) {
+      sections.push(chalk.yellow('Your branch has diverged from the remote'));
+    }
+    sections.push(`  ${info.join(', ')} of origin/${branch}`);
+  }
+
+  // Staged changes
+  if (status.staged.length > 0) {
+    sections.push(chalk.green.bold('\nChanges to be committed:'));
+    const rows = status.staged.map(({ status: stat, file }) => [
+      chalk.green(STATUS_LABELS[stat] || stat),
+      file,
+    ]);
+    sections.push(createTable(['Status', 'File'], rows));
+  }
+
+  // Unstaged changes
+  if (status.unstaged.length > 0) {
+    sections.push(chalk.yellow.bold('\nChanges not staged for commit:'));
+    const rows = status.unstaged.map(({ status: stat, file }) => [
+      chalk.yellow(STATUS_LABELS[stat] || stat),
+      file,
+    ]);
+    sections.push(createTable(['Status', 'File'], rows));
+  }
+
+  // Untracked files
+  if (status.untracked.length > 0) {
+    sections.push(chalk.gray.bold('\nUntracked files:'));
+    for (const file of status.untracked) {
+      sections.push(chalk.gray(`  ${file}`));
+    }
+  }
+
+  // Clean working tree
+  if (status.staged.length === 0 && status.unstaged.length === 0 && status.untracked.length === 0) {
+    sections.push(chalk.green('\nWorking tree clean'));
+  }
+
+  return sections.join('\n');
+};
+
+module.exports = {
+  displayStatus,
+  STATUS_COLORS,
+  STATUS_LABELS,
+};

package/lib/ui/table.js

@@ -0,0 +1,76 @@
+const chalk = require('chalk');
+const Table = require('cli-table3');
+
+/**
+ * Create a simple table display using cli-table3
+ */
+const createTable = (headers, rows, options = {}) => {
+  const { headerColor = 'cyan', align = 'left', style = {} } = options;
+
+  if (rows.length === 0) {
+    return chalk.dim('(empty)');
+  }
+
+  // Create table with cli-table3
+  const table = new Table({
+    head: headers.map((h) => chalk[headerColor].bold(h)),
+    style: {
+      border: [],
+      head: [],
+      ...style,
+    },
+    chars: {
+      top: '─',
+      'top-mid': '┬',
+      'top-left': '├',
+      'top-right': '┐',
+      bottom: '─',
+      'bottom-mid': '┴',
+      'bottom-left': '├',
+      'bottom-right': '┘',
+      left: '│',
+      'left-mid': '├',
+      mid: '─',
+      'mid-mid': '┼',
+      right: '│',
+      'right-mid': '┤',
+      middle: '│',
+    },
+    colAligns: headers.map(() => align),
+  });
+
+  // Add rows
+  for (const row of rows) {
+    table.push(row);
+  }
+
+  // Apply gray color to border characters
+  const tableString = table.toString();
+  // Match border characters (horizontal lines, vertical lines, corners, junctions)
+  // This regex matches border chars at the start/end of lines or as standalone border elements
+  const borderCharPattern = /([─┬┌┐┴└┘│├┼┤])/g;
+  const result = tableString.replace(borderCharPattern, (match) => chalk.gray(match));
+
+  return result;
+};
+
+/**
+ * Create a key-value list
+ */
+const createKeyValueList = (items, options = {}) => {
+  const { keyColor = 'cyan', valueColor = 'white' } = options;
+
+  const maxKeyLength = Math.max(...Object.keys(items).map((k) => k.length));
+
+  return Object.entries(items)
+    .map(([key, value]) => {
+      const paddedKey = key.padEnd(maxKeyLength);
+      return `${chalk[keyColor](paddedKey)} : ${chalk[valueColor](value)}`;
+    })
+    .join('\n');
+};
+
+module.exports = {
+  createTable,
+  createKeyValueList,
+};

package/lib/utils/email-prompt.js

@@ -0,0 +1,62 @@
+const emailPrompt = require('email-prompt');
+const chalk = require('chalk');
+const clack = require('@clack/prompts');
+
+/**
+ * Prompt for email address with autocompletion
+ * @param {object} options - Email prompt options
+ * @returns {Promise<string>} - Email address
+ */
+const promptEmail = async (options = {}) => {
+  const {
+    start = '> Enter your email: ',
+    forceLowerCase = true,
+    suggestionColor = 'gray',
+  } = options;
+
+  try {
+    const email = await emailPrompt({
+      start,
+      forceLowerCase,
+      suggestionColor,
+    });
+    return email;
+  } catch (err) {
+    if (err.message?.includes('Aborted')) {
+      clack.cancel(chalk.yellow('Email input cancelled'));
+      return null;
+    }
+    throw err;
+  }
+};
+
+/**
+ * Prompt for email with validation and confirmation
+ * @param {object} options - Options
+ * @returns {Promise<string|null>} - Email address or null if cancelled
+ */
+const promptEmailWithConfirmation = async (options = {}) => {
+  const email = await promptEmail(options);
+
+  if (!email) {
+    return null;
+  }
+
+  // Show confirmation
+  const confirm = await clack.confirm({
+    message: `Use email: ${chalk.cyan(email)}?`,
+    initialValue: true,
+  });
+
+  if (clack.isCancel(confirm) || !confirm) {
+    clack.cancel(chalk.yellow('Email not set'));
+    return null;
+  }
+
+  return email;
+};
+
+module.exports = {
+  promptEmail,
+  promptEmailWithConfirmation,
+};