@manthank/mgit 1.0.0

package/dist/components/Header.js

@@ -0,0 +1,46 @@
+// Animated header: gradient "mgit" wordmark with a shimmering tagline.
+import React from 'react';
+import { Box, Text } from 'ink';
+import Gradient from 'ink-gradient';
+import BigText from 'ink-big-text';
+import { useFrame } from '../hooks.js';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const taglines = ['git & GitHub, minus the fear', 'your friendly terminal guide', 'learn by doing, safely', 'every command, explained'];
+export default function Header({
+  theme,
+  animations,
+  subtitle
+}) {
+  const frame = useFrame(animations, 3);
+  // Rotate the gradient colours to create a flowing shimmer on the wordmark.
+  const g = theme.gradient;
+  const rotated = animations ? g.map((_, i) => g[(i + frame) % g.length]) : g;
+  const tagline = taglines[Math.floor(frame / 4) % taglines.length];
+
+  // A little animated spark that travels along the underline.
+  const width = 34;
+  const pos = animations ? frame % width : 0;
+  const underline = Array.from({
+    length: width
+  }, (_, i) => i === pos ? '◆' : i === (pos + width - 2) % width ? '◇' : '─').join('');
+  return /*#__PURE__*/_jsxs(Box, {
+    flexDirection: "column",
+    alignItems: "center",
+    marginBottom: 1,
+    children: [/*#__PURE__*/_jsx(Gradient, {
+      colors: rotated,
+      children: /*#__PURE__*/_jsx(BigText, {
+        text: "mgit",
+        font: "tiny"
+      })
+    }), /*#__PURE__*/_jsx(Gradient, {
+      colors: theme.gradient,
+      children: /*#__PURE__*/_jsx(Text, {
+        children: underline
+      })
+    }), /*#__PURE__*/_jsxs(Text, {
+      color: theme.secondary,
+      children: [theme.emoji, " ", subtitle || tagline]
+    })]
+  });
+}

package/dist/components/Menu.js

@@ -0,0 +1,56 @@
+// A themed wrapper around ink-select-input with an animated pointer and
+// two-line items (label + dim hint).
+import React from 'react';
+import { Box, Text } from 'ink';
+import SelectInput from 'ink-select-input';
+import { useFrame } from '../hooks.js';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+function makeIndicator(theme, animations) {
+  const spinners = ['›', '»', '›', '·'];
+  return function Indicator({
+    isSelected
+  }) {
+    const frame = useFrame(animations && isSelected, 6);
+    if (!isSelected) return /*#__PURE__*/_jsx(Text, {
+      children: " "
+    });
+    const ch = animations ? spinners[frame % spinners.length] : theme.pointer;
+    return /*#__PURE__*/_jsxs(Text, {
+      color: theme.accent,
+      bold: true,
+      children: [ch, ' ']
+    });
+  };
+}
+function makeItem(theme) {
+  return function Item({
+    isSelected,
+    label
+  }) {
+    return /*#__PURE__*/_jsx(Text, {
+      color: isSelected ? theme.accent : 'white',
+      bold: isSelected,
+      children: label
+    });
+  };
+}
+export default function Menu({
+  items,
+  onSelect,
+  onHighlight,
+  theme,
+  animations,
+  limit
+}) {
+  return /*#__PURE__*/_jsx(Box, {
+    flexDirection: "column",
+    children: /*#__PURE__*/_jsx(SelectInput, {
+      items: items,
+      onSelect: onSelect,
+      onHighlight: onHighlight,
+      limit: limit,
+      indicatorComponent: makeIndicator(theme, animations),
+      itemComponent: makeItem(theme)
+    })
+  });
+}

package/dist/config.js

@@ -0,0 +1,40 @@
+// Tiny JSON config store persisted at ~/.mgit/config.json.
+// Keeps the user's chosen theme and small UI preferences between runs.
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from 'node:fs';
+const dir = join(homedir(), '.mgit');
+const file = join(dir, 'config.json');
+const defaults = {
+  theme: 'neon',
+  animations: true,
+  confirmDanger: true,
+  showHints: true
+};
+export function loadConfig() {
+  try {
+    if (existsSync(file)) {
+      const raw = JSON.parse(readFileSync(file, 'utf8'));
+      return {
+        ...defaults,
+        ...raw
+      };
+    }
+  } catch {
+    // corrupt/unreadable config → fall back to defaults
+  }
+  return {
+    ...defaults
+  };
+}
+export function saveConfig(config) {
+  try {
+    if (!existsSync(dir)) mkdirSync(dir, {
+      recursive: true
+    });
+    writeFileSync(file, JSON.stringify(config, null, 2), 'utf8');
+  } catch {
+    // non-fatal: settings just won't persist this session
+  }
+  return config;
+}

package/dist/git.js

@@ -0,0 +1,263 @@
+// Git engine: thin async wrappers around the `git` binary using execa.
+// Parsers turn raw output into structured data the visual components consume.
+import { execa } from 'execa';
+
+// Run an arbitrary git command. Returns {ok, stdout, stderr, code, command}.
+// Never throws — callers inspect `ok` so the UI can render failures gracefully.
+export async function git(args, options = {}) {
+  const command = 'git ' + args.map(quoteIfNeeded).join(' ');
+  try {
+    const res = await execa('git', args, {
+      cwd: options.cwd || process.cwd(),
+      reject: false,
+      all: false,
+      ...options
+    });
+    return {
+      ok: res.exitCode === 0,
+      stdout: (res.stdout || '').trimEnd(),
+      stderr: (res.stderr || '').trimEnd(),
+      code: res.exitCode,
+      command
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      stdout: '',
+      stderr: error.shortMessage || error.message || String(error),
+      code: error.exitCode ?? 1,
+      command
+    };
+  }
+}
+function quoteIfNeeded(arg) {
+  return /\s/.test(arg) ? `"${arg}"` : arg;
+}
+export async function isGitRepo(cwd = process.cwd()) {
+  const res = await git(['rev-parse', '--is-inside-work-tree'], {
+    cwd
+  });
+  return res.ok && res.stdout.trim() === 'true';
+}
+export async function getCurrentBranch() {
+  const res = await git(['branch', '--show-current']);
+  return res.ok ? res.stdout.trim() : '';
+}
+
+// Parse `git status --porcelain=v1 -b` into a friendly summary.
+export async function getStatus() {
+  const res = await git(['status', '--porcelain=v1', '-b']);
+  if (!res.ok) return {
+    ok: false,
+    error: res.stderr,
+    files: []
+  };
+  const lines = res.stdout.split('\n').filter(Boolean);
+  let branchLine = '';
+  const files = [];
+  for (const line of lines) {
+    if (line.startsWith('##')) {
+      branchLine = line.slice(2).trim();
+      continue;
+    }
+    const x = line[0]; // staged column
+    const y = line[1]; // worktree column
+    const name = line.slice(3);
+    files.push({
+      x,
+      y,
+      name,
+      ...classify(x, y)
+    });
+  }
+
+  // Parse ahead/behind from a line like: main...origin/main [ahead 1, behind 2]
+  let ahead = 0;
+  let behind = 0;
+  const am = branchLine.match(/ahead (\d+)/);
+  const bm = branchLine.match(/behind (\d+)/);
+  if (am) ahead = Number(am[1]);
+  if (bm) behind = Number(bm[1]);
+  return {
+    ok: true,
+    branchLine,
+    ahead,
+    behind,
+    files,
+    staged: files.filter(f => f.staged),
+    unstaged: files.filter(f => f.unstaged),
+    untracked: files.filter(f => f.untracked)
+  };
+}
+function classify(x, y) {
+  const untracked = x === '?' && y === '?';
+  const staged = !untracked && x !== ' ' && x !== '?';
+  const unstaged = !untracked && y !== ' ';
+  let label = 'Modified';
+  const code = untracked ? '?' : x !== ' ' ? x : y;
+  switch (code) {
+    case 'A':
+      label = 'Added';
+      break;
+    case 'M':
+      label = 'Modified';
+      break;
+    case 'D':
+      label = 'Deleted';
+      break;
+    case 'R':
+      label = 'Renamed';
+      break;
+    case 'C':
+      label = 'Copied';
+      break;
+    case 'U':
+      label = 'Conflict';
+      break;
+    case '?':
+      label = 'Untracked';
+      break;
+    default:
+      label = 'Changed';
+  }
+  return {
+    untracked,
+    staged,
+    unstaged,
+    label
+  };
+}
+
+// List local branches with current marker and last-commit subject.
+export async function getBranches() {
+  const res = await git(['branch', '--format=%(HEAD)\t%(refname:short)\t%(objectname:short)\t%(contents:subject)']);
+  if (!res.ok) return {
+    ok: false,
+    error: res.stderr,
+    branches: []
+  };
+  const branches = res.stdout.split('\n').filter(Boolean).map(line => {
+    const [head, name, sha, ...rest] = line.split('\t');
+    return {
+      current: head.trim() === '*',
+      name,
+      sha,
+      subject: rest.join('\t') || ''
+    };
+  });
+  return {
+    ok: true,
+    branches
+  };
+}
+
+// Structured commit log for the graph view.
+export async function getLog(limit = 25, all = true) {
+  const args = ['log', `--max-count=${limit}`, '--date=short',
+  // Field separator \x1f between fields, record separator \x1e between commits.
+  '--pretty=format:%h\x1f%an\x1f%ad\x1f%d\x1f%s\x1e'];
+  if (all) args.push('--all');
+  const res = await git(args);
+  if (!res.ok) return {
+    ok: false,
+    error: res.stderr,
+    commits: []
+  };
+  const commits = res.stdout.split('\x1e').map(s => s.replace(/^\n/, '')).filter(Boolean).map(rec => {
+    const [hash, author, date, refs, subject] = rec.split('\x1f');
+    return {
+      hash,
+      author,
+      date,
+      refs: (refs || '').replace(/[()]/g, '').trim(),
+      subject: subject || ''
+    };
+  });
+  return {
+    ok: true,
+    commits
+  };
+}
+export async function getRemotes() {
+  const res = await git(['remote', '-v']);
+  if (!res.ok) return {
+    ok: false,
+    error: res.stderr,
+    remotes: []
+  };
+  const map = new Map();
+  for (const line of res.stdout.split('\n').filter(Boolean)) {
+    const [name, rest] = line.split('\t');
+    if (!rest) continue;
+    const url = rest.split(' ')[0];
+    if (!map.has(name)) map.set(name, url);
+  }
+  return {
+    ok: true,
+    remotes: [...map.entries()].map(([name, url]) => ({
+      name,
+      url
+    }))
+  };
+}
+export async function getStashes() {
+  const res = await git(['stash', 'list']);
+  if (!res.ok) return {
+    ok: false,
+    error: res.stderr,
+    stashes: []
+  };
+  const stashes = res.stdout.split('\n').filter(Boolean);
+  return {
+    ok: true,
+    stashes
+  };
+}
+export async function getConfigList() {
+  const res = await git(['config', '--list']);
+  if (!res.ok) return {
+    ok: false,
+    error: res.stderr,
+    entries: []
+  };
+  const entries = res.stdout.split('\n').filter(Boolean).map(l => {
+    const idx = l.indexOf('=');
+    return {
+      key: l.slice(0, idx),
+      value: l.slice(idx + 1)
+    };
+  });
+  return {
+    ok: true,
+    entries
+  };
+}
+export async function getGlobalIdentity() {
+  const name = await git(['config', '--global', 'user.name']);
+  const email = await git(['config', '--global', 'user.email']);
+  return {
+    name: name.ok ? name.stdout.trim() : '',
+    email: email.ok ? email.stdout.trim() : ''
+  };
+}
+
+// Contribution-style counts per author for the "chart" feature.
+export async function getShortstat() {
+  const res = await git(['shortlog', '-sn', '--all', '--no-merges']);
+  if (!res.ok) return {
+    ok: false,
+    error: res.stderr,
+    authors: []
+  };
+  const authors = res.stdout.split('\n').filter(Boolean).map(line => {
+    const m = line.trim().match(/^(\d+)\s+(.*)$/);
+    return m ? {
+      count: Number(m[1]),
+      name: m[2]
+    } : null;
+  }).filter(Boolean);
+  return {
+    ok: true,
+    authors
+  };
+}

package/dist/hooks.js

@@ -0,0 +1,23 @@
+// Small reusable hooks for animation and timers.
+import { useEffect, useRef, useState } from 'react';
+
+// Fire a callback on a fixed interval. Pass delay=null to pause.
+export function useInterval(callback, delay) {
+  const saved = useRef(callback);
+  useEffect(() => {
+    saved.current = callback;
+  }, [callback]);
+  useEffect(() => {
+    if (delay === null || delay === undefined) return undefined;
+    const id = setInterval(() => saved.current(), delay);
+    return () => clearInterval(id);
+  }, [delay]);
+}
+
+// A monotonically increasing frame counter, handy for cycling colours/positions.
+// Disabled (stays at 0) when `enabled` is false so animations can be turned off.
+export function useFrame(enabled = true, fps = 12) {
+  const [frame, setFrame] = useState(0);
+  useInterval(() => setFrame(f => f + 1), enabled ? Math.round(1000 / fps) : null);
+  return enabled ? frame : 0;
+}

package/dist/recipes.js

@@ -0,0 +1,96 @@
+// Guided multi-step workflows. Each step has a title, explanation, the git args
+// to run, and optional inputs collected up front. The RecipeView walks the user
+// through them one at a time, running each on confirmation.
+
+export const recipes = {
+  'github-first': {
+    title: 'Publish to GitHub (first time)',
+    emoji: '🚀',
+    intro: 'Take a plain folder and push it to a brand-new GitHub repository.',
+    inputs: [{
+      name: 'msg',
+      label: 'First commit message',
+      placeholder: 'Initial commit',
+      default: 'Initial commit'
+    }, {
+      name: 'url',
+      label: 'GitHub repo URL',
+      placeholder: 'https://github.com/you/repo.git'
+    }],
+    steps: v => [{
+      title: 'Initialize repo',
+      why: 'Start tracking this folder with git.',
+      args: ['init']
+    }, {
+      title: 'Stage everything',
+      why: 'Mark all files to be included in the first commit.',
+      args: ['add', '.']
+    }, {
+      title: 'First commit',
+      why: 'Save the initial snapshot.',
+      args: ['commit', '-m', v.msg || 'Initial commit']
+    }, {
+      title: 'Name branch main',
+      why: 'GitHub expects a "main" branch by default.',
+      args: ['branch', '-M', 'main']
+    }, {
+      title: 'Link to GitHub',
+      why: 'Connect your local repo to the remote URL.',
+      args: ['remote', 'add', 'origin', v.url]
+    }, {
+      title: 'Push',
+      why: 'Upload your commits and remember the link.',
+      args: ['push', '-u', 'origin', 'main']
+    }]
+  },
+  feature: {
+    title: 'Feature branch workflow',
+    emoji: '🌿',
+    intro: 'The everyday team flow: get latest, branch off, then push your work.',
+    inputs: [{
+      name: 'branch',
+      label: 'New feature branch name',
+      placeholder: 'feature/login'
+    }, {
+      name: 'msg',
+      label: 'Commit message',
+      placeholder: 'Add login screen'
+    }],
+    steps: v => [{
+      title: 'Pull latest',
+      why: 'Start from the most recent code.',
+      args: ['pull']
+    }, {
+      title: 'Create feature branch',
+      why: 'Isolate your work from main.',
+      args: ['switch', '-c', v.branch]
+    }, {
+      title: 'Stage your changes',
+      why: 'Mark your edits for commit. (Make your edits before this step!)',
+      args: ['add', '.']
+    }, {
+      title: 'Commit',
+      why: 'Save a snapshot of your work.',
+      args: ['commit', '-m', v.msg || 'Update']
+    }, {
+      title: 'Push branch',
+      why: 'Publish your branch so you can open a Pull Request.',
+      args: ['push', '-u', 'origin', v.branch]
+    }]
+  },
+  'sync-main': {
+    title: 'Sync main branch',
+    emoji: '🔄',
+    intro: 'Switch to main and pull the newest changes.',
+    inputs: [],
+    steps: () => [{
+      title: 'Switch to main',
+      why: 'Move onto the main branch.',
+      args: ['switch', 'main']
+    }, {
+      title: 'Pull origin main',
+      why: 'Download and merge the latest main.',
+      args: ['pull', 'origin', 'main']
+    }]
+  }
+};

package/dist/themes.js

@@ -0,0 +1,89 @@
+// Theme catalog for mgit.
+// Each theme controls the gradient of the logo, accent colours used across the UI,
+// and small decorative choices (icons/pointer). Colours are standard chalk/ink
+// colour names or hex strings so they render nicely in most terminals.
+
+export const themes = {
+  neon: {
+    label: 'Neon Night',
+    emoji: '🌆',
+    gradient: ['#ff00cc', '#3333ff', '#00ffcc'],
+    accent: '#ff36c9',
+    secondary: '#00e5ff',
+    success: '#4aff26',
+    danger: '#ff4d6d',
+    warn: '#ffd166',
+    muted: 'gray',
+    pointer: '›',
+    branchColors: ['#ff36c9', '#00e5ff', '#ffd166', '#7cff6b', '#b892ff', '#ff8c42']
+  },
+  ocean: {
+    label: 'Deep Ocean',
+    emoji: '🌊',
+    gradient: ['#2E3192', '#1BFFFF'],
+    accent: '#1BC7FF',
+    secondary: '#5efce8',
+    success: '#38ef7d',
+    danger: '#ff6b6b',
+    warn: '#ffe66d',
+    muted: 'gray',
+    pointer: '»',
+    branchColors: ['#1BC7FF', '#5efce8', '#38ef7d', '#8ec5ff', '#b3f0ff', '#00b4d8']
+  },
+  sunset: {
+    label: 'Sunset',
+    emoji: '🌅',
+    gradient: ['#f12711', '#f5af19'],
+    accent: '#ff7e5f',
+    secondary: '#feb47b',
+    success: '#8ee000',
+    danger: '#e63946',
+    warn: '#ffb703',
+    muted: 'gray',
+    pointer: '➜',
+    branchColors: ['#ff7e5f', '#feb47b', '#ffb703', '#f9c74f', '#f8961e', '#f3722c']
+  },
+  forest: {
+    label: 'Forest',
+    emoji: '🌲',
+    gradient: ['#134E5E', '#71B280'],
+    accent: '#71B280',
+    secondary: '#a8e063',
+    success: '#a8e063',
+    danger: '#e07a5f',
+    warn: '#f2cc8f',
+    muted: 'gray',
+    pointer: '▸',
+    branchColors: ['#71B280', '#a8e063', '#56ab2f', '#c1ffc1', '#3d8361', '#1c6758']
+  },
+  mono: {
+    label: 'Monochrome',
+    emoji: '⬛',
+    gradient: ['#ffffff', '#888888'],
+    accent: '#ffffff',
+    secondary: '#bbbbbb',
+    success: '#ffffff',
+    danger: '#ff5555',
+    warn: '#dddddd',
+    muted: 'gray',
+    pointer: '▌',
+    branchColors: ['#ffffff', '#cccccc', '#999999', '#bbbbbb', '#dddddd', '#777777']
+  },
+  candy: {
+    label: 'Candy Pop',
+    emoji: '🍬',
+    gradient: ['#ff9a9e', '#fad0c4', '#a18cd1'],
+    accent: '#ff6ec7',
+    secondary: '#a18cd1',
+    success: '#7bed9f',
+    danger: '#ff4757',
+    warn: '#ffdb4d',
+    muted: 'gray',
+    pointer: '★',
+    branchColors: ['#ff6ec7', '#a18cd1', '#7bed9f', '#ff9ff3', '#feca57', '#48dbfb']
+  }
+};
+export const themeOrder = ['neon', 'ocean', 'sunset', 'forest', 'mono', 'candy'];
+export function getTheme(name) {
+  return themes[name] || themes.neon;
+}