avil13-co 2.4.0 → 2.5.0

package/README.md

@@ -1,6 +1,6 @@
 # avil13/co
 
-Interactive Git branch checkout, merge, deletion and synchronization.
+Interactive Git branch checkout, merge, deletion, synchronization and stash management.
 
 ![demo](assets/cli-demo.gif)
 
@@ -20,6 +20,7 @@ co un               # Show unmerged branches (also: -un, --no-merged)
 co -M               # Merge a selected branch (also: merge)
 co -D               # Delete multiple local branches (also: rm)
 co -p               # Fetch and safely sync all local branches (like hub sync)
+co -s               # List and manage stashes (also: --stash)
 co -h               # Show help
 ```
 
@@ -42,6 +43,22 @@ with **Yes** as the default (`[Y/n]`). This uses safe deletion (`git branch -d`)
 not forced deletion. Remote-only branches are not offered for deletion.
 A failed merge never triggers the deletion question.
 
+### Stash
+
+`co -s` or `co --stash` lists stash entries, newest first, with their dates and
+messages. Select an entry to see its creation date, author, commit hash and
+change statistics (including untracked files saved in the stash).
+
+Choose **Apply** to restore changes and keep the stash, **Pop** to restore and
+remove it on success, or **Delete** to remove it without applying. Deletion asks
+for confirmation `[n/Y]`: Enter confirms, `n` cancels. A failed pop keeps the
+stash, including when Git reports conflicts. Git errors end the command with
+exit code 1; resolve any conflicts before trying again.
+
+Use **Back to stash list** to select another entry, or **Exit** to leave without
+changes. The list refreshes after deletion. Optional filtering is supported:
+`co -s - search text` matches the reference, date or message.
+
 ### Synchronize branches
 
 `co -p` works like `hub sync`, without requiring `hub`:

package/dist/cli-commands/index.d.ts

@@ -5,7 +5,8 @@ export declare enum Commands {
     MergeBranch = 4,
     ShowMerged = 8,
     ShowUnMerged = 16,
-    Sync = 32
+    Sync = 32,
+    Stash = 64
 }
 export declare const getWishOfUser: (firstArg?: string) => Commands;
 export declare function parseArgs(args?: string[]): {

package/dist/cli-commands/index.js

@@ -10,6 +10,7 @@ var Commands;
     Commands[Commands["ShowMerged"] = 8] = "ShowMerged";
     Commands[Commands["ShowUnMerged"] = 16] = "ShowUnMerged";
     Commands[Commands["Sync"] = 32] = "Sync";
+    Commands[Commands["Stash"] = 64] = "Stash";
 })(Commands = exports.Commands || (exports.Commands = {}));
 const getWishOfUser = (firstArg = process.argv[2]) => {
     if (['help', '-h', '--h', '--help'].includes(firstArg))
@@ -20,6 +21,8 @@ const getWishOfUser = (firstArg = process.argv[2]) => {
         return Commands.DeleteBranch;
     if (firstArg === '-p')
         return Commands.Sync;
+    if (['-s', '--stash'].includes(firstArg))
+        return Commands.Stash;
     if (['m', '-sm', '--show-merged'].includes(firstArg))
         return Commands.ShowMerged;
     if (['un', '-un', '--no-merged'].includes(firstArg))
@@ -45,7 +48,7 @@ function parseArgs(args = process.argv.slice(2)) {
 exports.parseArgs = parseArgs;
 const getHelp = () => `
 DESCRIPTION:
-  Quickly switch, merge, delete and synchronize Git branches.
+  Quickly switch, merge, delete and synchronize Git branches, and manage stashes.
 
 USAGE:
   co                         Select a branch to check out
@@ -53,6 +56,7 @@ USAGE:
   co -M [- filter]           Merge, then offer to delete the source branch [Y/n]
   co -D [- filter]           Delete multiple local branches (Space to select)
   co -p                     Fetch and safely sync all local branches (like hub sync)
+  co -s, --stash [- filter] List stashes, view details, apply, pop or delete [n/Y]
   co m, -sm, --show-merged   Show merged branches
   co un, -un, --no-merged    Show unmerged branches
   co help, -h, --h, --help   Show this message

package/dist/commands/stash.d.ts

@@ -0,0 +1,12 @@
+export interface StashEntry {
+    ref: string;
+    hash: string;
+    date: string;
+    author: string;
+    message: string;
+}
+export declare function getStashes(): Promise<StashEntry[]>;
+export declare function showStash(entry: StashEntry): Promise<void>;
+export declare function applyStash(entry: StashEntry, pop?: boolean): Promise<void>;
+export declare function dropStash(entry: StashEntry): Promise<boolean>;
+export declare function manageStashes(filter?: string): Promise<void>;

package/dist/commands/stash.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manageStashes = exports.dropStash = exports.applyStash = exports.showStash = exports.getStashes = void 0;
+const ask_1 = require("../ask");
+const color_1 = require("../color");
+const prompt_1 = require("../prompt");
+const terminal_1 = require("../terminal");
+const exec_1 = require("./exec");
+async function getStashes() {
+    const output = await (0, exec_1.exec)(['stash', 'list', '--format=%gd%x00%H%x00%cI%x00%an%x00%gs']);
+    if (!output)
+        return [];
+    return output.split('\n').map(line => {
+        const [ref, hash, date, author, message] = line.split('\0');
+        return { ref, hash, date, author, message };
+    });
+}
+exports.getStashes = getStashes;
+async function assertStash(entry) {
+    // Reflog indices can shift if another process changes the stash list.
+    const hash = await (0, exec_1.exec)(['rev-parse', '--verify', entry.ref]);
+    if (hash !== entry.hash)
+        throw new Error('Stash list changed. Run co --stash again.');
+}
+async function showStash(entry) {
+    await assertStash(entry);
+    const details = `${entry.ref}: ${entry.message}\nDate: ${entry.date}\nAuthor: ${entry.author}\nCommit: ${entry.hash}`;
+    const stats = await (0, exec_1.exec)(['stash', 'show', '--stat', '--include-untracked', '--no-color', entry.hash]);
+    const output = [details, stats].filter(Boolean).join('\n');
+    (0, terminal_1.print)(process.stdout.isTTY ? color_1.clc.gray(output) : output);
+}
+exports.showStash = showStash;
+async function applyStash(entry, pop = false) {
+    await assertStash(entry);
+    // Let Git perform pop: on conflicts it preserves the stash automatically.
+    (0, terminal_1.print)(await (0, exec_1.exec)(['stash', pop ? 'pop' : 'apply', entry.ref]));
+    (0, terminal_1.print)(`${entry.ref}: ${pop ? 'popped' : 'applied (stash kept)'}.`);
+}
+exports.applyStash = applyStash;
+async function dropStash(entry) {
+    const { answer } = await (0, prompt_1.prompt)({
+        type: 'input',
+        name: 'answer',
+        message: `Delete ${entry.ref}: ${entry.message}? [n/Y]`,
+        default: 'Y',
+        filter: (value) => value.trim().toLowerCase(),
+        validate: (value) => ['n', 'y'].includes(value) || 'Enter n or Y.',
+    });
+    if (answer.toLowerCase() !== 'y') {
+        (0, terminal_1.print)('Stash was not deleted.');
+        return false;
+    }
+    await assertStash(entry);
+    (0, terminal_1.print)(await (0, exec_1.exec)(['stash', 'drop', entry.ref]));
+    return true;
+}
+exports.dropStash = dropStash;
+async function manageStashes(filter = '') {
+    while (true) {
+        const entries = await getStashes();
+        if (!entries.length) {
+            (0, terminal_1.print)('No stash entries.');
+            return;
+        }
+        const filtered = entries.filter(entry => (0, ask_1.checkItem)(`${entry.ref} ${entry.date} ${entry.message}`, filter));
+        if (!filtered.length) {
+            (0, terminal_1.print)('No stash entries match the filter.');
+            return;
+        }
+        const { entry } = await (0, prompt_1.prompt)({
+            type: 'list',
+            name: 'entry',
+            message: 'Select stash',
+            choices: [
+                ...filtered.map(value => ({ name: `📦 ${value.ref} | ${value.date} | ${value.message}`, value })),
+                { name: '🚪 Exit', value: null },
+            ],
+        });
+        if (!entry)
+            return;
+        await showStash(entry);
+        const { action } = await (0, prompt_1.prompt)({
+            type: 'list',
+            name: 'action',
+            message: `Action for ${entry.ref}`,
+            choices: [
+                { name: '⬅️ Back to stash list', value: 'back' },
+                { name: '📥 Apply (keep stash)', value: 'apply' },
+                { name: '📤 Pop (apply and remove on success)', value: 'pop' },
+                { name: '🗑️ Delete stash', value: 'drop' },
+                { name: '🚪 Exit', value: 'exit' },
+            ],
+        });
+        if (action === 'exit')
+            return;
+        if (action === 'apply' || action === 'pop') {
+            await applyStash(entry, action === 'pop');
+            return;
+        }
+        if (action === 'drop')
+            await dropStash(entry);
+    }
+}
+exports.manageStashes = manageStashes;

package/dist/index.js

@@ -7,6 +7,7 @@ const commands_1 = require("./commands");
 const delete_barnch_1 = require("./commands/delete-barnch");
 const merge_branch_1 = require("./commands/merge-branch");
 const sync_branches_1 = require("./commands/sync-branches");
+const stash_1 = require("./commands/stash");
 const terminal_1 = require("./terminal");
 const run = async () => {
     const { command, filter } = (0, cli_commands_1.parseArgs)();
@@ -14,6 +15,11 @@ const run = async () => {
         console.log((0, cli_commands_1.getHelp)());
         return;
     }
+    if (command === cli_commands_1.Commands.Stash) {
+        (0, terminal_1.startTerminal)();
+        await (0, stash_1.manageStashes)(filter);
+        return;
+    }
     if (command === cli_commands_1.Commands.Sync) {
         (0, terminal_1.startTerminal)();
         await (0, sync_branches_1.syncBranches)();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "avil13-co",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "description": "",
   "main": "dist/index.js",
   "public": true,

package/src/__tests__/cli-commands.spec.ts

@@ -19,6 +19,10 @@ describe('arguments', () => {
   it.each(['un', '-un', '--no-merged'])('accepts unmerged alias %s', alias => {
     expect(parseArgs([alias]).command).toBe(Commands.ShowUnMerged);
   });
+  it.each(['-s', '--stash'])('accepts stash alias %s and optional filter', alias => {
+    expect(parseArgs([alias])).toEqual({ command: Commands.Stash, filter: '' });
+    expect(parseArgs([alias, '-', 'work'])).toEqual({ command: Commands.Stash, filter: 'work' });
+  });
   it('accepts sync without a filter', () => {
     expect(parseArgs(['-p'])).toEqual({ command: Commands.Sync, filter: '' });
   });

package/src/__tests__/stash.spec.ts

@@ -0,0 +1,171 @@
+import { afterEach, beforeEach, expect, it, vi } from 'vitest';
+import { execFileSync } from 'child_process';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import inquirer from 'inquirer';
+import { applyStash, dropStash, getStashes, manageStashes, showStash } from '../commands/stash';
+
+const context = vi.hoisted(() => ({ cwd: '' }));
+vi.mock('child_process', async importOriginal => {
+  const actual = await importOriginal<typeof import('child_process')>();
+  return {
+    ...actual,
+    execFile: (file, args, callback) => actual.execFile(file, args, { cwd: context.cwd }, callback),
+  };
+});
+
+function git(...args: string[]) {
+  return execFileSync('git', args, { cwd: context.cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+}
+function stash(message = 'saved work') {
+  writeFileSync(join(context.cwd, 'file.txt'), message);
+  git('stash', 'push', '-qm', message);
+}
+
+beforeEach(() => {
+  context.cwd = mkdtempSync(join(tmpdir(), 'co-stash-'));
+  git('init', '-q', '-b', 'main');
+  git('config', 'user.name', 'Test');
+  git('config', 'user.email', 'test@example.test');
+  writeFileSync(join(context.cwd, 'file.txt'), 'initial');
+  git('add', '.');
+  git('commit', '-qm', 'initial');
+  vi.spyOn(console, 'log').mockImplementation(() => {});
+});
+afterEach(() => {
+  vi.restoreAllMocks();
+  rmSync(context.cwd, { recursive: true, force: true });
+});
+
+it('handles an empty stash list without prompting', async () => {
+  const prompt = vi.spyOn(inquirer, 'prompt');
+  expect(await getStashes()).toEqual([]);
+  await manageStashes();
+  expect(prompt).not.toHaveBeenCalled();
+  expect(console.log).toHaveBeenCalledWith('No stash entries.');
+});
+
+it('lists newest first with references, dates, author and literal messages', async () => {
+  stash('older');
+  stash('new; $(echo nope) | message');
+  const entries = await getStashes();
+  expect(entries).toHaveLength(2);
+  expect(entries[0]).toMatchObject({ ref: 'stash@{0}', author: 'Test', message: 'On main: new; $(echo nope) | message' });
+  expect(entries[0].hash).toBe(git('rev-parse', 'stash@{0}'));
+  expect(Number.isNaN(Date.parse(entries[0].date))).toBe(false);
+  expect(entries[1].ref).toBe('stash@{1}');
+});
+
+it('shows metadata and tracked and untracked file statistics', async () => {
+  writeFileSync(join(context.cwd, 'file.txt'), 'changed');
+  writeFileSync(join(context.cwd, 'extra.txt'), 'untracked');
+  git('stash', 'push', '-qu', '-m', 'details');
+  const [entry] = await getStashes();
+  await showStash(entry);
+  expect(console.log).toHaveBeenCalledWith(expect.stringContaining(`Commit: ${entry.hash}`));
+  expect(console.log).toHaveBeenCalledWith(expect.stringMatching(/extra.txt[\s\S]*file.txt/));
+});
+
+it('renders stash details and statistics in gray in a terminal', async () => {
+  stash();
+  const descriptor = Object.getOwnPropertyDescriptor(process.stdout, 'isTTY');
+  Object.defineProperty(process.stdout, 'isTTY', { value: true, configurable: true });
+  try {
+    await showStash((await getStashes())[0]);
+    expect(console.log).toHaveBeenCalledWith(expect.stringMatching(/^\x1b\[0;90m[\s\S]*file.txt[\s\S]*\x1b\[0m$/));
+  } finally {
+    if (descriptor) Object.defineProperty(process.stdout, 'isTTY', descriptor);
+    else delete (process.stdout as any).isTTY;
+  }
+});
+
+it.each([false, true])('applies changes with pop=%s and keeps/removes the stash', async pop => {
+  stash();
+  await applyStash((await getStashes())[0], pop);
+  expect(readFileSync(join(context.cwd, 'file.txt'), 'utf8')).toBe('saved work');
+  expect(await getStashes()).toHaveLength(pop ? 0 : 1);
+});
+
+it('keeps the stash when pop has conflicts', async () => {
+  stash();
+  writeFileSync(join(context.cwd, 'file.txt'), 'conflicting commit');
+  git('add', '.');
+  git('commit', '-qm', 'conflict');
+  await expect(applyStash((await getStashes())[0], true)).rejects.toThrow();
+  expect(await getStashes()).toHaveLength(1);
+  expect(git('status', '--porcelain')).toContain('UU file.txt');
+});
+
+it('does not drop a stash if confirmation is declined', async () => {
+  stash();
+  const prompt = vi.spyOn(inquirer, 'prompt').mockResolvedValue({ answer: 'n' });
+  expect(await dropStash((await getStashes())[0])).toBe(false);
+  expect(await getStashes()).toHaveLength(1);
+  expect(prompt).toHaveBeenCalledWith(expect.objectContaining({ default: 'Y', message: expect.stringContaining('[n/Y]') }));
+});
+
+it('drops only the selected stash after confirmation', async () => {
+  stash('older');
+  stash('newer');
+  vi.spyOn(inquirer, 'prompt').mockResolvedValue({ answer: 'Y' });
+  expect(await dropStash((await getStashes())[1])).toBe(true);
+  expect((await getStashes()).map(entry => entry.message)).toEqual(['On main: newer']);
+});
+
+it('refuses to act on an entry whose index has changed', async () => {
+  stash('older');
+  const [entry] = await getStashes();
+  stash('newer');
+  vi.spyOn(inquirer, 'prompt').mockResolvedValue({ answer: 'y' });
+  await expect(dropStash(entry)).rejects.toThrow('Stash list changed');
+  await expect(applyStash(entry)).rejects.toThrow('Stash list changed');
+  expect(await getStashes()).toHaveLength(2);
+});
+
+it('refreshes the list after deletion and permits exiting', async () => {
+  stash('older');
+  stash('newer');
+  const [entry] = await getStashes();
+  const prompt = vi.spyOn(inquirer, 'prompt')
+    .mockResolvedValueOnce({ entry })
+    .mockResolvedValueOnce({ action: 'drop' })
+    .mockResolvedValueOnce({ answer: 'y' })
+    .mockResolvedValueOnce({ entry: null });
+  await manageStashes();
+  const choices = (prompt.mock.calls[3][0] as any).choices;
+  expect(choices).toHaveLength(2);
+  expect(choices[0].value).toMatchObject({ ref: 'stash@{0}', message: 'On main: older' });
+});
+
+it('filters the selection and allows backing out without changes', async () => {
+  stash('older');
+  stash('newer');
+  const entry = (await getStashes())[1];
+  const prompt = vi.spyOn(inquirer, 'prompt')
+    .mockResolvedValueOnce({ entry })
+    .mockResolvedValueOnce({ action: 'back' })
+    .mockResolvedValueOnce({ entry: null });
+  await manageStashes('older');
+  expect((prompt.mock.calls[0][0] as any).choices).toHaveLength(2);
+  expect(await getStashes()).toHaveLength(2);
+});
+
+it('reports a filter with no matches without prompting', async () => {
+  stash();
+  const prompt = vi.spyOn(inquirer, 'prompt');
+  await manageStashes('missing');
+  expect(prompt).not.toHaveBeenCalled();
+  expect(console.log).toHaveBeenCalledWith('No stash entries match the filter.');
+});
+
+it.each(['apply', 'pop'])('runs the selected %s action', async action => {
+  stash();
+  const [entry] = await getStashes();
+  vi.spyOn(inquirer, 'prompt')
+    .mockResolvedValueOnce({ entry })
+    .mockResolvedValueOnce({ action });
+  await manageStashes();
+  expect(readFileSync(join(context.cwd, 'file.txt'), 'utf8')).toBe('saved work');
+  expect(await getStashes()).toHaveLength(action === 'pop' ? 0 : 1);
+});

package/src/cli-commands/index.ts

@@ -6,6 +6,7 @@ export enum Commands {
   ShowMerged = 8,
   ShowUnMerged = 16,
   Sync = 32,
+  Stash = 64,
 }
 
 export const getWishOfUser = (firstArg = process.argv[2]): Commands => {
@@ -13,6 +14,7 @@ export const getWishOfUser = (firstArg = process.argv[2]): Commands => {
   if (['-M', 'merge'].includes(firstArg)) return Commands.MergeBranch;
   if (['-D', 'rm'].includes(firstArg)) return Commands.DeleteBranch;
   if (firstArg === '-p') return Commands.Sync;
+  if (['-s', '--stash'].includes(firstArg)) return Commands.Stash;
   if (['m', '-sm', '--show-merged'].includes(firstArg)) return Commands.ShowMerged;
   if (['un', '-un', '--no-merged'].includes(firstArg)) return Commands.ShowUnMerged;
   return Commands.Unknown;
@@ -34,7 +36,7 @@ export function parseArgs(args = process.argv.slice(2)) {
 
 export const getHelp = (): string => `
 DESCRIPTION:
-  Quickly switch, merge, delete and synchronize Git branches.
+  Quickly switch, merge, delete and synchronize Git branches, and manage stashes.
 
 USAGE:
   co                         Select a branch to check out
@@ -42,6 +44,7 @@ USAGE:
   co -M [- filter]           Merge, then offer to delete the source branch [Y/n]
   co -D [- filter]           Delete multiple local branches (Space to select)
   co -p                     Fetch and safely sync all local branches (like hub sync)
+  co -s, --stash [- filter] List stashes, view details, apply, pop or delete [n/Y]
   co m, -sm, --show-merged   Show merged branches
   co un, -un, --no-merged    Show unmerged branches
   co help, -h, --h, --help   Show this message

package/src/commands/stash.ts

@@ -0,0 +1,105 @@
+import { checkItem } from '../ask';
+import { clc } from '../color';
+import { prompt } from '../prompt';
+import { print } from '../terminal';
+import { exec } from './exec';
+
+export interface StashEntry {
+  ref: string;
+  hash: string;
+  date: string;
+  author: string;
+  message: string;
+}
+
+export async function getStashes(): Promise<StashEntry[]> {
+  const output = await exec(['stash', 'list', '--format=%gd%x00%H%x00%cI%x00%an%x00%gs']);
+  if (!output) return [];
+  return output.split('\n').map(line => {
+    const [ref, hash, date, author, message] = line.split('\0');
+    return { ref, hash, date, author, message };
+  });
+}
+
+async function assertStash(entry: StashEntry) {
+  // Reflog indices can shift if another process changes the stash list.
+  const hash = await exec(['rev-parse', '--verify', entry.ref]);
+  if (hash !== entry.hash) throw new Error('Stash list changed. Run co --stash again.');
+}
+
+export async function showStash(entry: StashEntry) {
+  await assertStash(entry);
+  const details = `${entry.ref}: ${entry.message}\nDate: ${entry.date}\nAuthor: ${entry.author}\nCommit: ${entry.hash}`;
+  const stats = await exec(['stash', 'show', '--stat', '--include-untracked', '--no-color', entry.hash]);
+  const output = [details, stats].filter(Boolean).join('\n');
+  print(process.stdout.isTTY ? clc.gray(output) : output);
+}
+
+export async function applyStash(entry: StashEntry, pop = false) {
+  await assertStash(entry);
+  // Let Git perform pop: on conflicts it preserves the stash automatically.
+  print(await exec(['stash', pop ? 'pop' : 'apply', entry.ref]));
+  print(`${entry.ref}: ${pop ? 'popped' : 'applied (stash kept)'}.`);
+}
+
+export async function dropStash(entry: StashEntry): Promise<boolean> {
+  const { answer } = await prompt<{ answer: string }>({
+    type: 'input',
+    name: 'answer',
+    message: `Delete ${entry.ref}: ${entry.message}? [n/Y]`,
+    default: 'Y',
+    filter: (value: string) => value.trim().toLowerCase(),
+    validate: (value: string) => ['n', 'y'].includes(value) || 'Enter n or Y.',
+  });
+  if (answer.toLowerCase() !== 'y') {
+    print('Stash was not deleted.');
+    return false;
+  }
+  await assertStash(entry);
+  print(await exec(['stash', 'drop', entry.ref]));
+  return true;
+}
+
+export async function manageStashes(filter = '') {
+  while (true) {
+    const entries = await getStashes();
+    if (!entries.length) {
+      print('No stash entries.');
+      return;
+    }
+    const filtered = entries.filter(entry => checkItem(`${entry.ref} ${entry.date} ${entry.message}`, filter));
+    if (!filtered.length) {
+      print('No stash entries match the filter.');
+      return;
+    }
+    const { entry } = await prompt<{ entry: StashEntry | null }>({
+      type: 'list',
+      name: 'entry',
+      message: 'Select stash',
+      choices: [
+        ...filtered.map(value => ({ name: `📦 ${value.ref} | ${value.date} | ${value.message}`, value })),
+        { name: '🚪 Exit', value: null },
+      ],
+    });
+    if (!entry) return;
+    await showStash(entry);
+    const { action } = await prompt<{ action: string }>({
+      type: 'list',
+      name: 'action',
+      message: `Action for ${entry.ref}`,
+      choices: [
+        { name: '⬅️ Back to stash list', value: 'back' },
+        { name: '📥 Apply (keep stash)', value: 'apply' },
+        { name: '📤 Pop (apply and remove on success)', value: 'pop' },
+        { name: '🗑️ Delete stash', value: 'drop' },
+        { name: '🚪 Exit', value: 'exit' },
+      ],
+    });
+    if (action === 'exit') return;
+    if (action === 'apply' || action === 'pop') {
+      await applyStash(entry, action === 'pop');
+      return;
+    }
+    if (action === 'drop') await dropStash(entry);
+  }
+}

package/src/index.ts

@@ -4,6 +4,7 @@ import { BranchesType, checkoutBranch, getBranches, getCurrentBranchName } from
 import { deleteBranches } from './commands/delete-barnch';
 import { mergeBranch } from './commands/merge-branch';
 import { syncBranches } from './commands/sync-branches';
+import { manageStashes } from './commands/stash';
 import { finishTerminal, installInterruptHandler, print, startTerminal } from './terminal';
 
 export const run = async () => {
@@ -13,6 +14,12 @@ export const run = async () => {
     return;
   }
 
+  if (command === Commands.Stash) {
+    startTerminal();
+    await manageStashes(filter);
+    return;
+  }
+
   if (command === Commands.Sync) {
     startTerminal();
     await syncBranches();