@jannael/glinter 1.1.0 → 1.2.0

package/README.md

@@ -1,23 +1,106 @@
-# Glinter
-
-Glinter is a high-performance, transparent Git wrapper built with **Bun**. It enhances the standard `git add` workflow with a beautiful, interactive CLI interface while acting as a seamless pass-through for all other Git commands.
+<p align="center">
+  <br>
+  <br>
+  <a href="https://glinter.jannael.com" target="_blank" rel="noopener noreferrer">
+    <picture>
+      <img alt="Glinter" src="https://github.com/Jannael/glinter/raw/main/apps/web/public/og.png">
+    </picture>
+  </a>
+  <br>
+  <br>
+  <br>
+</p>
+
+Glinter is a high-performance, transparent Git wrapper built with **Bun**.
 
 ## Preview
 
-<video src="https://github.com/user-attachments/assets/f488ac07-f36a-4a56-a533-9598c46596ed" controls="false" autoplay="true" loop="true" muted="true" style="max-width: 100%;">
+<video src="https://github.com/user-attachments/assets/63b401a0-e1e1-453c-9e38-c36cd14e200f" controls="false" autoplay="true" loop="true" muted="true" style="max-width: 100%;">
 Your browser does not support the video tag.
 </video>
 
-
 ## Features
 
-- **Interactive `add`**: When you run `g add`, it presents a color-coded list of your modified, new, and deleted files. You can multi-select exactly what you want to stage using a GUI-like interface in your terminal.
+- **Abbreviation**: You can use `g` instead of `git`.
+
+- **Safe by Default**: Automatically filters and prevents accidental staging of sensitive files: `.env` and `node_modules`.
 
 - **Transparent Wrapper**: For every other command (like `commit`, `push`, `log`, or `status`), Glinter acts as a direct tunnel to Git. It preserves all original colors, formatting, and interactive features of the native Git CLI.
 
-- **Safe by Default**: Automatically filters and prevents accidental staging of sensitive files: `.env` and `node_modules`.
 
-- **Abbreviation**: You can use `g` instead of `git`.
+### Commands
+
+| Command | Description |
+|---|---|
+| `g add` | Opens an interactive file selector to stage changes, filtering out sensitive files like `.env` and `node_modules` |
+| `g commit` | Opens an interactive prompt to select a commit type and write a commit message |
+| `g switch` | Opens an interactive prompt to switch branches |
+| `g setup` | sets up alias for git and glinter |
+| `g alias` | shows all the aliases |
+
+### Aliases
+
+| Alias | Command | Description |
+|---|---|---|
+| gs | git status -sb | Status with short format and branch info |
+| gl | git log --oneline --decorate --graph --all -n 20 | Recent commits graph |
+| gll | git log --stat | Log with file change statistics |
+| gd | git diff --word-diff=color | Word-level diff with colors |
+| gds | git diff --staged --word-diff=color | Staged diff with colors |
+| ga | glinter add | Interactive staging |
+| gaa | git add -A | Add all changes |
+| gc | glinter commit | Interactive commit |
+| gcm | git commit -m | Direct commit message |
+| gca | git commit --amend | Amend last commit |
+| gcan | git commit --amend --no-edit | Amend without editing |
+| gb | git branch | List branches |
+| gba | git branch -a | List all branches |
+| gco | glinter switch | Interactive branch switch |
+| gcb | git checkout -b | Create and switch branch |
+| gpl | git pull | Pull from remote |
+| gplr | git pull --rebase | Pull with rebase |
+| gp | git push | Push to remote |
+| ggpush | git push origin HEAD | Push current branch |
+| gpf | git push --force-with-lease | Force push with lease |
+| gst | git stash | Stash changes |
+| gstp | git stash pop | Pop stash |
+| gstl | git stash list | List stashes |
+| gcl | git clean -fd | Clean untracked files |
+| grh | git reset --hard | Hard reset |
+
+## Quick Start
+
+1. **Install Glinter**:
+
+   ```bash
+   npm install -g @jannael/glinter
+   ```
+
+2. **Set up aliases** (optional, recommended):
+
+   ```bash
+   g setup
+   ```
+
+3. **Start using Glinter**:
+
+   ```bash
+   g add        # Interactive file staging
+   g commit     # Interactive commit
+   g status     # Standard git status
+   g push       # Standard git push
+   ```
+
+   
+
+
+### Screenshots
+
+| `g add` | `g commit` |
+|---|---|
+| ![glinter add](./screenshots/ga.png) | ![glinter commit](./screenshots/gc.png) |
+
+
 
 ## How it works
 
@@ -52,7 +135,9 @@ npm install -g @jannael/glinter
 now you can simply run:
 ```bash
 g add           # Opens the interactive selector
+g commit        # Opens commit type + message prompt
 g add <file>    # Runs standard git add <file>
+g commit -m ""  # Runs standard git commit -m ""
 g status        # Runs standard git status
 g push          # Runs standard git push
 ```

package/dist/index.js

@@ -90,22 +90,64 @@ var require_src = __commonJS((exports, module) => {
   module.exports = { cursor, scroll, erase, beep };
 });
 
-// src/utils/colors.ts
-var GREEN = "\x1B[32m";
-var YELLOW = "\x1B[33m";
-var RED = "\x1B[31m";
-var MAGENTA = "\x1B[35m";
-var BLUE = "\x1B[34m";
-var BLACK = "\x1B[30m";
-var BG_YELLOW = "\x1B[43m";
+// apps/cli/error/error-constructor.ts
+function CreateError(name) {
+  const capitalize = (text) => text.charAt(0).toUpperCase() + text.slice(1);
+  return class extends Error {
+    description;
+    constructor(message, description) {
+      super(capitalize(message));
+      this.name = name;
+      this.description = description !== undefined ? capitalize(description) : undefined;
+    }
+  };
+}
+
+// apps/cli/error/error-instance.ts
+var NotFound = CreateError("NotFound");
+var Forbidden = CreateError("Forbidden");
+var Conflict = CreateError("Conflict");
+var ServerError = CreateError("ServerError");
+var BadRequest = CreateError("BadRequest");
+
+// apps/cli/utils/colors.ts
 var RESET = "\x1B[0m";
+var GREEN = ({ text }) => `\x1B[32m${text}${RESET}`;
+var YELLOW = ({ text }) => `\x1B[33m${text}${RESET}`;
+var RED = ({ text }) => `\x1B[31m${text}${RESET}`;
+var MAGENTA = ({ text }) => `\x1B[35m${text}${RESET}`;
+var BLUE = ({ text }) => `\x1B[34m${text}${RESET}`;
+var BLACK = ({ text }) => `\x1B[30m${text}${RESET}`;
+var BG_YELLOW = ({ text }) => `\x1B[43m${text}${RESET}`;
+
+// apps/cli/utils/icons-terminal.ts
+var X = ({ text }) => RED({ text: `\u2716 ${text}` });
+var CHECK = ({ text }) => `${GREEN({ text: "\u2714" })}  ${text}`;
+var WARNING = ({ text }) => BG_YELLOW({ text: BLACK({ text: ` \u26A0 ${text}` }) });
 
-// src/utils/check.ts
-var CHECK = `${GREEN}\u2714${RESET}`;
+// apps/cli/error/error-handler.ts
+function errorHandler(error) {
+  if (error instanceof ServerError) {
+    console.error(X({ text: error.message }));
+    if (error.description) {
+      console.error(`  ${error.description}`);
+    }
+    return;
+  }
+  if (error instanceof NotFound) {
+    console.error(WARNING({ text: error.message }));
+    return;
+  }
+  console.error(X({ text: "An unexpected error occurred" }));
+  if (error instanceof Error) {
+    console.error(`  ${error.message}`);
+  }
+}
 
 // node_modules/@clack/core/dist/index.mjs
 import { styleText as y } from "util";
 import { stdout as S, stdin as $ } from "process";
+import * as _ from "readline";
 import P from "readline";
 
 // node_modules/fast-string-truncated-width/dist/utils.js
@@ -494,6 +536,7 @@ function wrapAnsi(string, columns, options) {
 
 // node_modules/@clack/core/dist/index.mjs
 var import_sisteransi = __toESM(require_src(), 1);
+import { ReadStream as D } from "tty";
 function d(r, t, e) {
   if (!e.some((o) => !o.disabled))
     return r;
@@ -530,6 +573,28 @@ function w(r, t) {
   const e = r;
   e.isTTY && e.setRawMode(t);
 }
+function z({ input: r = $, output: t = S, overwrite: e = true, hideCursor: s = true } = {}) {
+  const i = _.createInterface({ input: r, output: t, prompt: "", tabSize: 1 });
+  _.emitKeypressEvents(r, i), r instanceof D && r.isTTY && r.setRawMode(true);
+  const n = (o, { name: a, sequence: h }) => {
+    const l = String(o);
+    if (V([l, a, h], "cancel")) {
+      s && t.write(import_sisteransi.cursor.show), process.exit(0);
+      return;
+    }
+    if (!e)
+      return;
+    const f = a === "return" ? 0 : -1, v = a === "return" ? -1 : 0;
+    _.moveCursor(t, f, v, () => {
+      _.clearLine(t, 1, () => {
+        r.once("keypress", n);
+      });
+    });
+  };
+  return s && t.write(import_sisteransi.cursor.hide), r.once("keypress", n), () => {
+    r.off("keypress", n), s && t.write(import_sisteransi.cursor.show), r instanceof D && r.isTTY && !Y && r.setRawMode(false), i.terminal = false, i.close();
+  };
+}
 var O = (r) => ("columns" in r) && typeof r.columns == "number" ? r.columns : 80;
 var A = (r) => ("rows" in r) && typeof r.rows == "number" ? r.rows : 20;
 function R(r, t, e, s = e) {
@@ -744,9 +809,27 @@ var H = class extends p {
     }
   }
 };
-var X = { Y: { type: "year", len: 4 }, M: { type: "month", len: 2 }, D: { type: "day", len: 2 } };
+
+class Q extends p {
+  get cursor() {
+    return this.value ? 0 : 1;
+  }
+  get _value() {
+    return this.cursor === 0;
+  }
+  constructor(t) {
+    super(t, false), this.value = !!t.initialValue, this.on("userInput", () => {
+      this.value = this._value;
+    }), this.on("confirm", (e) => {
+      this.output.write(import_sisteransi.cursor.move(0, -1)), this.value = e, this.state = "submit", this.close();
+    }), this.on("cursor", () => {
+      this.value = !this.value;
+    });
+  }
+}
+var X2 = { Y: { type: "year", len: 4 }, M: { type: "month", len: 2 }, D: { type: "day", len: 2 } };
 function L(r) {
-  return [...r].map((t) => X[t]);
+  return [...r].map((t) => X2[t]);
 }
 function Z(r) {
   const t = new Intl.DateTimeFormat(r, { year: "numeric", month: "2-digit", day: "2-digit" }).formatToParts(new Date(2000, 0, 15)), e = [];
@@ -1048,6 +1131,27 @@ class nt extends p {
     });
   }
 }
+class at extends p {
+  get userInputWithCursor() {
+    if (this.state === "submit")
+      return this.userInput;
+    const t = this.userInput;
+    if (this.cursor >= t.length)
+      return `${this.userInput}\u2588`;
+    const e = t.slice(0, this.cursor), [s, ...i] = t.slice(this.cursor);
+    return `${e}${y("inverse", s)}${i.join("")}`;
+  }
+  get cursor() {
+    return this._cursor;
+  }
+  constructor(t) {
+    super({ ...t, initialUserInput: t.initialUserInput ?? t.initialValue }), this.on("userInput", (e) => {
+      this._setValue(e);
+    }), this.on("finalize", () => {
+      this.value || (this.value = t.defaultValue), this.value === undefined && (this.value = "");
+    });
+  }
+}
 
 // node_modules/@clack/prompts/dist/index.mjs
 import { styleText as t, stripVTControlCharacters as ne } from "util";
@@ -1057,6 +1161,7 @@ function Ze() {
   return P2.platform !== "win32" ? P2.env.TERM !== "linux" : !!P2.env.CI || !!P2.env.WT_SESSION || !!P2.env.TERMINUS_SUBLIME || P2.env.ConEmuTask === "{cmd::Cmder}" || P2.env.TERM_PROGRAM === "Terminus-Sublime" || P2.env.TERM_PROGRAM === "vscode" || P2.env.TERM === "xterm-256color" || P2.env.TERM === "alacritty" || P2.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
 }
 var ee = Ze();
+var ae = () => process.env.CI === "true";
 var w2 = (e, i) => ee ? e : i;
 var _e = w2("\u25C6", "*");
 var oe = w2("\u25A0", "x");
@@ -1134,7 +1239,7 @@ var Y2 = ({ cursor: e, options: i, style: s, output: r = process.stdout, maxItem
   }
   if (f > $2) {
     let b = 0, x = 0, G2 = f;
-    const M2 = e - v, R2 = (j2, D) => et2(h, G2, j2, D, $2);
+    const M2 = e - v, R2 = (j2, D2) => et2(h, G2, j2, D2, $2);
     m ? ({ lineCount: G2, removals: b } = R2(0, M2), G2 > $2 && ({ lineCount: G2, removals: x } = R2(M2 + 1, h.length))) : ({ lineCount: G2, removals: x } = R2(M2 + 1, h.length), G2 > $2 && ({ lineCount: G2, removals: b } = R2(0, M2))), b > 0 && (m = true, h.splice(0, b)), x > 0 && (g = true, h.splice(h.length - x, x));
   }
   const C2 = [];
@@ -1144,10 +1249,49 @@ var Y2 = ({ cursor: e, options: i, style: s, output: r = process.stdout, maxItem
       C2.push(x);
   return g && C2.push(l), C2;
 };
+var ot2 = (e) => {
+  const i = e.active ?? "Yes", s = e.inactive ?? "No";
+  return new Q({ active: i, inactive: s, signal: e.signal, input: e.input, output: e.output, initialValue: e.initialValue ?? true, render() {
+    const r = e.withGuide ?? u.withGuide, u2 = `${V2(this.state)}  `, n = r ? `${t("gray", d2)}  ` : "", o = R(e.output, e.message, n, u2), c2 = `${r ? `${t("gray", d2)}
+` : ""}${o}
+`, a = this.value ? i : s;
+    switch (this.state) {
+      case "submit": {
+        const l = r ? `${t("gray", d2)}  ` : "";
+        return `${c2}${l}${t("dim", a)}`;
+      }
+      case "cancel": {
+        const l = r ? `${t("gray", d2)}  ` : "";
+        return `${c2}${l}${t(["strikethrough", "dim"], a)}${r ? `
+${t("gray", d2)}` : ""}`;
+      }
+      default: {
+        const l = r ? `${t("cyan", d2)}  ` : "", $2 = r ? t("cyan", E2) : "";
+        return `${c2}${l}${this.value ? `${t("green", z2)} ${i}` : `${t("dim", H2)} ${t("dim", i)}`}${e.vertical ? r ? `
+${t("cyan", d2)}  ` : `
+` : ` ${t("dim", "/")} `}${this.value ? `${t("dim", H2)} ${t("dim", s)}` : `${t("green", z2)} ${s}`}
+${$2}
+`;
+      }
+    }
+  } }).prompt();
+};
 var pt = (e = "", i) => {
   const s = i?.output ?? process.stdout, r = i?.withGuide ?? u.withGuide ? `${t("gray", E2)}  ` : "";
   s.write(`${r}${t("red", e)}
 
+`);
+};
+var mt = (e = "", i) => {
+  const s = i?.output ?? process.stdout, r = i?.withGuide ?? u.withGuide ? `${t("gray", le)}  ` : "";
+  s.write(`${r}${e}
+`);
+};
+var gt = (e = "", i) => {
+  const s = i?.output ?? process.stdout, r = i?.withGuide ?? u.withGuide ? `${t("gray", d2)}
+${t("gray", E2)}  ` : "";
+  s.write(`${r}${e}
+
 `);
 };
 var Q2 = (e, i) => e.split(`
@@ -1206,6 +1350,64 @@ ${r ? t("cyan", E2) : ""}
     }
   } }).prompt();
 };
+var Ct = (e) => t("magenta", e);
+var fe = ({ indicator: e = "dots", onCancel: i, output: s = process.stdout, cancelMessage: r, errorMessage: u2, frames: n = ee ? ["\u25D2", "\u25D0", "\u25D3", "\u25D1"] : ["\u2022", "o", "O", "0"], delay: o = ee ? 80 : 120, signal: c2, ...a } = {}) => {
+  const l = ae();
+  let $2, y2, p2 = false, m = false, g = "", S2, h = performance.now();
+  const f = O(s), v = a?.styleFrame ?? Ct, T2 = (_2) => {
+    const A2 = _2 > 1 ? u2 ?? u.messages.error : r ?? u.messages.cancel;
+    m = _2 === 1, p2 && (W2(A2, _2), m && typeof i == "function" && i());
+  }, C2 = () => T2(2), b = () => T2(1), x = () => {
+    process.on("uncaughtExceptionMonitor", C2), process.on("unhandledRejection", C2), process.on("SIGINT", b), process.on("SIGTERM", b), process.on("exit", T2), c2 && c2.addEventListener("abort", b);
+  }, G2 = () => {
+    process.removeListener("uncaughtExceptionMonitor", C2), process.removeListener("unhandledRejection", C2), process.removeListener("SIGINT", b), process.removeListener("SIGTERM", b), process.removeListener("exit", T2), c2 && c2.removeEventListener("abort", b);
+  }, M2 = () => {
+    if (S2 === undefined)
+      return;
+    l && s.write(`
+`);
+    const _2 = wrapAnsi(S2, f, { hard: true, trim: false }).split(`
+`);
+    _2.length > 1 && s.write(import_sisteransi2.cursor.up(_2.length - 1)), s.write(import_sisteransi2.cursor.to(0)), s.write(import_sisteransi2.erase.down());
+  }, R2 = (_2) => _2.replace(/\.+$/, ""), j2 = (_2) => {
+    const A2 = (performance.now() - _2) / 1000, k2 = Math.floor(A2 / 60), L2 = Math.floor(A2 % 60);
+    return k2 > 0 ? `[${k2}m ${L2}s]` : `[${L2}s]`;
+  }, D2 = a.withGuide ?? u.withGuide, ie = (_2 = "") => {
+    p2 = true, $2 = z({ output: s }), g = R2(_2), h = performance.now(), D2 && s.write(`${t("gray", d2)}
+`);
+    let A2 = 0, k2 = 0;
+    x(), y2 = setInterval(() => {
+      if (l && g === S2)
+        return;
+      M2(), S2 = g;
+      const L2 = v(n[A2]);
+      let Z2;
+      if (l)
+        Z2 = `${L2}  ${g}...`;
+      else if (e === "timer")
+        Z2 = `${L2}  ${g} ${j2(h)}`;
+      else {
+        const Be = ".".repeat(Math.floor(k2)).slice(0, 3);
+        Z2 = `${L2}  ${g}${Be}`;
+      }
+      const Ne = wrapAnsi(Z2, f, { hard: true, trim: false });
+      s.write(Ne), A2 = A2 + 1 < n.length ? A2 + 1 : 0, k2 = k2 < 4 ? k2 + 0.125 : 0;
+    }, o);
+  }, W2 = (_2 = "", A2 = 0, k2 = false) => {
+    if (!p2)
+      return;
+    p2 = false, clearInterval(y2), M2();
+    const L2 = A2 === 0 ? t("green", F2) : A2 === 1 ? t("red", oe) : t("red", ue);
+    g = _2 ?? g, k2 || (e === "timer" ? s.write(`${L2}  ${g} ${j2(h)}
+`) : s.write(`${L2}  ${g}
+`)), G2(), $2();
+  };
+  return { start: ie, stop: (_2 = "") => W2(_2, 0), message: (_2 = "") => {
+    g = R2(_2 ?? g);
+  }, cancel: (_2 = "") => W2(_2, 1), error: (_2 = "") => W2(_2, 2), clear: () => W2("", 0, true), get isCancelled() {
+    return m;
+  } };
+};
 var Ve = { light: w2("\u2500", "-"), heavy: w2("\u2501", "="), block: w2("\u2588", "#") };
 var re = (e, i) => e.includes(`
 `) ? e.split(`
@@ -1253,8 +1455,37 @@ ${a}
   } }).prompt();
 };
 var je = `${t("gray", d2)}  `;
+var Ot = (e) => new at({ validate: e.validate, placeholder: e.placeholder, defaultValue: e.defaultValue, initialValue: e.initialValue, output: e.output, signal: e.signal, input: e.input, render() {
+  const i = e?.withGuide ?? u.withGuide, s = `${`${i ? `${t("gray", d2)}
+` : ""}${V2(this.state)}  `}${e.message}
+`, r = e.placeholder ? t("inverse", e.placeholder[0]) + t("dim", e.placeholder.slice(1)) : t(["inverse", "hidden"], "_"), u2 = this.userInput ? this.userInputWithCursor : r, n = this.value ?? "";
+  switch (this.state) {
+    case "error": {
+      const o = this.error ? `  ${t("yellow", this.error)}` : "", c2 = i ? `${t("yellow", d2)}  ` : "", a = i ? t("yellow", E2) : "";
+      return `${s.trim()}
+${c2}${u2}
+${a}${o}
+`;
+    }
+    case "submit": {
+      const o = n ? `  ${t("dim", n)}` : "", c2 = i ? t("gray", d2) : "";
+      return `${s}${c2}${o}`;
+    }
+    case "cancel": {
+      const o = n ? `  ${t(["strikethrough", "dim"], n)}` : "", c2 = i ? t("gray", d2) : "";
+      return `${s}${c2}${o}${n.trim() ? `
+${c2}` : ""}`;
+    }
+    default: {
+      const o = i ? `${t("cyan", d2)}  ` : "", c2 = i ? t("cyan", E2) : "";
+      return `${s}${o}${u2}
+${c2}
+`;
+    }
+  }
+} }).prompt();
 
-// src/utils/multiselect.ts
+// apps/cli/utils/multiselect.ts
 async function MultiSelect({
   message,
   options
@@ -1271,7 +1502,7 @@ async function MultiSelect({
   return selected;
 }
 
-// src/modules/add/app/add-command.ts
+// apps/cli/modules/add/app/add-command.ts
 class AddCommand {
   getChangesUseCase;
   stageChangesUseCase;
@@ -1280,37 +1511,46 @@ class AddCommand {
     this.stageChangesUseCase = stageChangesUseCase;
   }
   async execute() {
-    const { changes, warnings } = await this.getChangesUseCase.execute();
-    if (changes.length === 0) {
-      console.log(`${CHECK}  All changes are either staged or sensitive (like .env).`);
-      return;
-    }
-    const options = [
-      ...changes.map((c2) => ({ value: c2.value, label: c2.label }))
-    ];
-    const selectedChanges = await MultiSelect({
-      message: `Select the changes you want to commit. ${BLUE}[space] to select and${RESET} ${GREEN}[enter] to confirm${RESET} ${MAGENTA}[a] to select all${RESET} ${RED}[esc] to cancel${RESET}`,
-      options
-    });
-    let selected = selectedChanges.map((file) => file.trim());
-    if (selected.includes("all")) {
-      selected = changes.map((c2) => c2.value);
-    }
-    if (selected.length > 0) {
-      await this.stageChangesUseCase.execute(selected);
-      if (warnings.size > 0) {
-        console.log(`
-${BG_YELLOW}${BLACK} WARNING ${RESET}`);
-        for (const warning of warnings) {
-          console.log(warning);
+    try {
+      const { changes, warnings } = await this.getChangesUseCase.execute();
+      if (changes.length === 0) {
+        console.log(`${CHECK({ text: "All changes are either staged or sensitive (like .env)." })}`);
+        return;
+      }
+      const options = [
+        ...changes.map((c2) => ({ value: c2.value, label: c2.label }))
+      ];
+      const selectedChanges = await MultiSelect({
+        message: `Select the changes you want to commit. 
+` + BLUE({ text: "[space] to select" }) + `
+` + GREEN({ text: "[enter] to confirm" }) + `
+` + MAGENTA({ text: "[a] to select all" }) + `
+` + RED({ text: "[esc] to cancel" }) + `
+`,
+        options
+      });
+      let selected = selectedChanges.map((file) => file.trim());
+      if (selected.includes("all")) {
+        selected = changes.map((c2) => c2.value);
+      }
+      if (selected.length > 0) {
+        await this.stageChangesUseCase.execute(selected);
+        if (warnings.size > 0) {
+          console.log(`
+${WARNING({ text: " WARNING " })}`);
+          for (const warning of warnings) {
+            console.log(warning);
+          }
+          console.log("");
         }
-        console.log("");
       }
+    } catch (error) {
+      errorHandler(error);
     }
   }
 }
 
-// src/modules/add/domain/change.ts
+// apps/cli/modules/add/domain/change.ts
 class Change {
   props;
   constructor(props) {
@@ -1329,16 +1569,16 @@ class Change {
     const { status, displayPath } = this.props;
     let label = `${status}: ${displayPath}`;
     if (status.includes("M")) {
-      label = `${YELLOW}modified:${RESET} ${displayPath}`;
+      label = YELLOW({ text: `modified: ${displayPath}` });
     }
     if (status.includes("A") || status.includes("?")) {
-      label = `${GREEN}new file:${RESET} ${displayPath}`;
+      label = GREEN({ text: `new file: ${displayPath}` });
     }
     if (status.includes("D")) {
-      label = `${RED}deleted:${RESET} ${displayPath}`;
+      label = RED({ text: `deleted: ${displayPath}` });
     }
     if (status.includes("R")) {
-      label = `${MAGENTA}renamed:${RESET} ${displayPath}`;
+      label = MAGENTA({ text: `renamed: ${displayPath}` });
     }
     return label;
   }
@@ -1347,10 +1587,10 @@ class Change {
   }
   getWarning() {
     if (this.value.includes(".env")) {
-      return `${YELLOW} .env file hidden${RESET} (Add to .gitignore to avoid leaks)`;
+      return YELLOW({ text: " .env file hidden" }) + " (Add to .gitignore to avoid leaks)";
     }
     if (this.value.includes("node_modules")) {
-      return `${YELLOW} node_modules hidden${RESET} (Add to .gitignore to save space)`;
+      return YELLOW({ text: " node_modules hidden" }) + " (Add to .gitignore to save space)";
     }
     return null;
   }
@@ -1377,7 +1617,7 @@ class Change {
   }
 }
 
-// src/modules/add/app/get-changes.use-case.ts
+// apps/cli/modules/add/app/get-changes.use-case.ts
 class GetChangesUseCase {
   gitRepository;
   constructor(gitRepository) {
@@ -1404,7 +1644,7 @@ class GetChangesUseCase {
   }
 }
 
-// src/modules/add/app/stage-changes.use-case.ts
+// apps/cli/modules/add/app/stage-changes.use-case.ts
 class StageChangesUseCase {
   gitRepository;
   constructor(gitRepository) {
@@ -1417,16 +1657,19 @@ class StageChangesUseCase {
   }
 }
 
-// src/modules/add/infra/bun-git.repository.ts
+// apps/cli/modules/add/infra/bun-git.repository.ts
 var {$: $2 } = globalThis.Bun;
-
 class BunGitRepository {
   async getEntries() {
-    const output = await $2`git status --porcelain -z`.quiet().text();
-    if (!output.trim()) {
-      return [];
+    try {
+      const output = await $2`git status --porcelain -z`.quiet().text();
+      if (!output.trim()) {
+        return [];
+      }
+      return output.split("\x00").filter(Boolean);
+    } catch {
+      throw new ServerError("Git status failed", "Could not retrieve repository status");
     }
-    return output.split("\x00").filter(Boolean);
   }
   async stageFiles(files) {
     if (files.length === 0)
@@ -1436,12 +1679,12 @@ class BunGitRepository {
     });
     const exitCode = await proc.exited;
     if (exitCode !== 0) {
-      throw new Error(`Git add failed with exit code ${exitCode}`);
+      throw new ServerError("Git add failed", `Failed to stage ${files.length} file(s)`);
     }
   }
 }
 
-// src/modules/add/main.ts
+// apps/cli/modules/add/main.ts
 async function addCommand() {
   const gitRepository = new BunGitRepository;
   const getChangesUseCase = new GetChangesUseCase(gitRepository);
@@ -1450,7 +1693,405 @@ async function addCommand() {
   await addCommand2.execute();
 }
 
-// src/modules/switch/domain/branch.ts
+// apps/cli/alias.ts
+var ALIASES = [
+  { name: "gs", command: "status -sb", kind: "git" },
+  {
+    name: "gl",
+    command: "log --oneline --decorate --graph --all -n 20",
+    kind: "git"
+  },
+  { name: "gll", command: "log --stat", kind: "git" },
+  { name: "gd", command: "diff --word-diff=color", kind: "git" },
+  { name: "gds", command: "diff --staged --word-diff=color", kind: "git" },
+  { name: "ga", command: "add", kind: "glinter" },
+  { name: "gaa", command: "add -A", kind: "git" },
+  { name: "gc", command: "commit", kind: "glinter" },
+  { name: "gcm", command: "commit -m", kind: "git" },
+  { name: "gca", command: "commit --amend", kind: "git" },
+  { name: "gcan", command: "commit --amend --no-edit", kind: "git" },
+  { name: "gb", command: "branch", kind: "git" },
+  { name: "gba", command: "branch -a", kind: "git" },
+  { name: "gco", command: "switch", kind: "glinter" },
+  { name: "gcb", command: "checkout -b", kind: "git" },
+  { name: "gpl", command: "pull", kind: "git" },
+  { name: "gplr", command: "pull --rebase", kind: "git" },
+  { name: "gp", command: "push", kind: "git" },
+  { name: "ggpush", command: "push origin HEAD", kind: "git" },
+  { name: "gpf", command: "push --force-with-lease", kind: "git" },
+  { name: "gst", command: "stash", kind: "git" },
+  { name: "gstp", command: "stash pop", kind: "git" },
+  { name: "gstl", command: "stash list", kind: "git" },
+  { name: "gcl", command: "clean -fd", kind: "git" },
+  { name: "grh", command: "reset --hard", kind: "git" }
+];
+
+// apps/cli/modules/alias/main.ts
+function resolveAlias(name, command) {
+  return { name, value: command };
+}
+function printAliases({
+  title = "The following aliases are configured by setup:"
+} = {}) {
+  console.log(YELLOW({ text: `
+${title}
+` }));
+  for (const alias of ALIASES) {
+    const tag = alias.kind === "glinter" ? MAGENTA({ text: "[glinter]" }) : BLUE({ text: "[git]    " });
+    const { name, value } = resolveAlias(alias.name, alias.command);
+    console.log(`  ${tag}  ${GREEN({ text: name.padEnd(8) })} \u2192 ${value}`);
+  }
+  console.log("");
+}
+async function aliasCommand() {
+  printAliases();
+}
+
+// apps/cli/modules/commit/app/commit.use-case.ts
+class CommitUseCase {
+  commitRepository;
+  constructor(commitRepository) {
+    this.commitRepository = commitRepository;
+  }
+  async execute({ message }) {
+    await this.commitRepository.commit(message);
+  }
+}
+
+// apps/cli/commit-options.ts
+var commitTypeOptions = [
+  {
+    value: "feat",
+    label: `${GREEN({ text: "feat" })}: A new feature`
+  },
+  {
+    value: "fix",
+    label: `${GREEN({ text: "fix" })}: A bug fix`
+  },
+  {
+    value: "chore",
+    label: `${GREEN({ text: "chore" })}: Routine maintenance`
+  },
+  {
+    value: "docs",
+    label: `${GREEN({ text: "docs" })}: Documentation updates`
+  },
+  {
+    value: "refactor",
+    label: `${GREEN({ text: "refactor" })}: Code changes without behavior change`
+  },
+  {
+    value: "test",
+    label: `${GREEN({ text: "test" })}: Add or update tests`
+  },
+  {
+    value: "perf",
+    label: `${GREEN({ text: "perf" })}: Performance improvements`
+  },
+  {
+    value: "style",
+    label: `${GREEN({ text: "style" })}: Formatting or style-only changes`
+  }
+];
+
+// apps/cli/utils/input.ts
+async function Input({
+  message,
+  placeholder
+}) {
+  const value = await Ot({
+    message,
+    placeholder,
+    validate(input) {
+      if (!input?.trim()) {
+        return "Commit message is required.";
+      }
+    }
+  });
+  if (q(value)) {
+    pt("Operation cancelled.");
+    process.exit(0);
+  }
+  return value.trim();
+}
+
+// apps/cli/utils/select.ts
+async function Select({
+  message,
+  options
+}) {
+  const selected = await _t({
+    message,
+    options
+  });
+  if (q(selected)) {
+    pt("Operation cancelled.");
+    process.exit(0);
+  }
+  return selected;
+}
+
+// apps/cli/modules/commit/app/commit-command.ts
+class CommitCommand {
+  commitUseCase;
+  constructor(commitUseCase) {
+    this.commitUseCase = commitUseCase;
+  }
+  async execute() {
+    try {
+      const commitType = await Select({
+        message: "Select the commit type.",
+        options: commitTypeOptions
+      });
+      const commitDescription = await Input({
+        message: "Write your commit message.",
+        placeholder: "e.g. add interactive commit flow"
+      });
+      await this.commitUseCase.execute({
+        message: `${commitType}: ${commitDescription}`
+      });
+    } catch (error) {
+      errorHandler(error);
+    }
+  }
+}
+
+// apps/cli/modules/commit/infra/bun-commit.repository.ts
+class BunCommitRepository {
+  async commit(message) {
+    const proc = Bun.spawn(["git", "commit", "-m", message], {
+      stdio: ["inherit", "inherit", "inherit"]
+    });
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      throw new ServerError("Git commit failed", "Could not create commit from interactive prompt");
+    }
+  }
+}
+
+// apps/cli/modules/commit/main.ts
+async function commitCommand() {
+  const commitRepository = new BunCommitRepository;
+  const commitUseCase = new CommitUseCase(commitRepository);
+  const commitCommand2 = new CommitCommand(commitUseCase);
+  await commitCommand2.execute();
+}
+
+// apps/cli/modules/setup/app/setup-aliases.use-case.ts
+class SetupAliasesUseCase {
+  aliasRepository;
+  constructor(aliasRepository) {
+    this.aliasRepository = aliasRepository;
+  }
+  async execute() {
+    for (const alias of ALIASES) {
+      const { name, value } = this.resolveAlias(alias.name, alias.command, alias.kind);
+      await this.aliasRepository.setAlias(name, value);
+    }
+    return { total: ALIASES.length };
+  }
+  resolveAlias(name, command, kind) {
+    const aliasCommand2 = kind === "git" ? `git ${command}` : `g ${command}`;
+    return { name, value: aliasCommand2 };
+  }
+}
+
+// apps/cli/utils/confirm.ts
+async function Confirm({
+  message,
+  cancelMessage,
+  exitOnCancel = true
+}) {
+  const confirmed = await ot2({
+    message
+  });
+  if (q(confirmed)) {
+    if (exitOnCancel) {
+      pt(cancelMessage ?? "Operation cancelled.");
+      process.exit(0);
+    }
+    return null;
+  }
+  return confirmed;
+}
+
+// apps/cli/utils/intro.ts
+function Intro(message) {
+  mt(message);
+}
+
+// apps/cli/utils/outro.ts
+function Outro(message) {
+  gt(message);
+}
+
+// apps/cli/utils/spinner.ts
+function Spinner() {
+  return fe();
+}
+
+// apps/cli/modules/setup/app/setup-command.ts
+class SetupCommand {
+  setupAliasesUseCase;
+  constructor(setupAliasesUseCase) {
+    this.setupAliasesUseCase = setupAliasesUseCase;
+  }
+  async execute() {
+    try {
+      Intro(MAGENTA({ text: " Glinter Setup " }));
+      printAliases({ title: "The following aliases will be set globally:" });
+      const confirmed = await Confirm({
+        message: "Apply these aliases to your global git config?",
+        exitOnCancel: false
+      });
+      if (!confirmed) {
+        Outro("Setup cancelled.");
+        return;
+      }
+      const spinner = Spinner();
+      spinner.start("Writing aliases...");
+      const { total } = await this.setupAliasesUseCase.execute();
+      console.log("");
+      spinner.stop(`${CHECK({ text: `${total} aliases configured successfully.` })}`);
+      Outro(`${GREEN({ text: "GLINTER" })}, if you like the project, give a star on github: https://github.com/jannael/glinter`);
+      console.log("");
+      console.log(MAGENTA({ text: "To use the aliases, please restart your terminal." }));
+    } catch (error) {
+      errorHandler(error);
+    }
+  }
+}
+
+// apps/cli/modules/setup/infra/bun-alias-unix.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+class BunAliasUnix {
+  async setAlias(name, value) {
+    const profilePath = this.getUnixProfilePath();
+    fs.mkdirSync(path.dirname(profilePath), { recursive: true });
+    const current = fs.existsSync(profilePath) ? fs.readFileSync(profilePath, "utf8") : "";
+    const updated = this.upsertUnixProfileAlias(current, name, value);
+    fs.writeFileSync(profilePath, updated);
+  }
+  upsertUnixProfileAlias(content, name, value) {
+    const escapedName = this.escapeRegex(name);
+    const escapedValue = this.escapeSingleQuotes(value);
+    const aliasLine = `alias ${name}='${escapedValue}'`;
+    const aliasRegex = new RegExp(`^alias ${escapedName}=.*\\r?\\n?`, "gm");
+    const cleaned = content.replace(aliasRegex, "").trimEnd();
+    const prefix = cleaned.length > 0 ? `${cleaned}
+` : "";
+    return `${prefix}${aliasLine}
+`;
+  }
+  getUnixProfilePath() {
+    const home = os.homedir();
+    const shellName = path.basename(process.env.SHELL ?? "");
+    const preferredProfile = shellName === "zsh" ? ".zshrc" : shellName === "bash" ? ".bashrc" : ".profile";
+    const candidates = [preferredProfile, ".bashrc", ".zshrc", ".profile"];
+    const uniqueCandidates = [...new Set(candidates)];
+    for (const candidate of uniqueCandidates) {
+      const candidatePath = path.join(home, candidate);
+      if (fs.existsSync(candidatePath)) {
+        return candidatePath;
+      }
+    }
+    return path.join(home, preferredProfile);
+  }
+  escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  escapeSingleQuotes(value) {
+    return value.replace(/'/g, `'"'"'`);
+  }
+}
+
+// apps/cli/modules/setup/infra/bun-alias-windows.ts
+import fs2 from "fs";
+import os2 from "os";
+import path2 from "path";
+
+class BunAliasWindows {
+  async setAlias(name, value) {
+    const psProfilePath = this.getWindowsProfilePath();
+    fs2.mkdirSync(path2.dirname(psProfilePath), { recursive: true });
+    const current = fs2.existsSync(psProfilePath) ? fs2.readFileSync(psProfilePath, "utf8") : "";
+    const updated = this.upsertWindowsProfileFunction(current, name, value);
+    fs2.writeFileSync(psProfilePath, updated);
+  }
+  upsertWindowsProfileFunction(content, name, value) {
+    const escapedName = this.escapeRegex(name);
+    const removeAliasLine = `if (Get-Alias -Name ${name} -ErrorAction SilentlyContinue) { Remove-Item Alias:${name} -Force }`;
+    const functionLine = `function ${name} { ${value} @args }`;
+    const removeAliasRegex = new RegExp(`^if \\(Get-Alias -Name ${escapedName} -ErrorAction SilentlyContinue\\) \\{ Remove-Item Alias:${escapedName} -Force \\}\\r?\\n?`, "gm");
+    const functionRegex = new RegExp(`^function ${escapedName} \\{[^\\r\\n]*\\}\\r?\\n?`, "gm");
+    const cleaned = content.replace(removeAliasRegex, "").replace(functionRegex, "").trimEnd();
+    const prefix = cleaned.length > 0 ? `${cleaned}
+` : "";
+    return `${prefix}${removeAliasLine}
+${functionLine}
+`;
+  }
+  escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  getWindowsProfilePath() {
+    return path2.join(this.getWindowsDocumentsPath(), "PowerShell", "Microsoft.PowerShell_profile.ps1");
+  }
+  getWindowsDocumentsPath() {
+    const proc = Bun.spawnSync([
+      "powershell",
+      "-NoProfile",
+      "-Command",
+      "[Environment]::GetFolderPath('MyDocuments')"
+    ], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    if (proc.exitCode === 0) {
+      const docsPath = new TextDecoder().decode(proc.stdout).trim();
+      if (docsPath.length > 0) {
+        return docsPath;
+      }
+    }
+    return path2.join(os2.homedir(), "Documents");
+  }
+}
+
+// apps/cli/modules/setup/infra/bun-alias.repository.ts
+class BunAliasRepository {
+  getOS() {
+    return process.platform === "win32" ? "windows" : "unix";
+  }
+  async setAlias(name, value) {
+    try {
+      const system = this.getOS();
+      if (system === "windows") {
+        const bunAliasWindows = new BunAliasWindows;
+        await bunAliasWindows.setAlias(name, value);
+      }
+      if (system === "unix") {
+        const bunAliasUnix = new BunAliasUnix;
+        await bunAliasUnix.setAlias(name, value);
+      }
+      console.log(`  ${MAGENTA({ text: name.padEnd(8) })} set ${GREEN({ text: "successfully".padStart(10) })}`);
+    } catch {
+      throw new ServerError("Unexpected execution error", `Failed to set alias: ${name}`);
+    }
+  }
+}
+
+// apps/cli/modules/setup/main.ts
+async function setupCommand() {
+  const aliasRepository = new BunAliasRepository;
+  const setupAliasesUseCase = new SetupAliasesUseCase(aliasRepository);
+  const setupCommand2 = new SetupCommand(setupAliasesUseCase);
+  await setupCommand2.execute();
+}
+
+// apps/cli/modules/switch/domain/branch.ts
 class Branch {
   props;
   constructor(props) {
@@ -1486,7 +2127,7 @@ class Branch {
   }
 }
 
-// src/modules/switch/app/get-branches.use-case.ts
+// apps/cli/modules/switch/app/get-branches.use-case.ts
 class GetBranchesUseCase {
   branchRepository;
   constructor(branchRepository) {
@@ -1499,7 +2140,7 @@ class GetBranchesUseCase {
   }
 }
 
-// src/modules/switch/app/switch-branch.use-case.ts
+// apps/cli/modules/switch/app/switch-branch.use-case.ts
 class SwitchBranch {
   branchRepository;
   constructor(branchRepository) {
@@ -1510,23 +2151,7 @@ class SwitchBranch {
   }
 }
 
-// src/utils/select.ts
-async function Select({
-  message,
-  options
-}) {
-  const selected = await _t({
-    message,
-    options
-  });
-  if (q(selected)) {
-    pt("Operation cancelled.");
-    process.exit(0);
-  }
-  return selected;
-}
-
-// src/modules/switch/app/switch-command.ts
+// apps/cli/modules/switch/app/switch-command.ts
 class SwitchCommand {
   getBranchesUseCase;
   switchBranch;
@@ -1535,49 +2160,56 @@ class SwitchCommand {
     this.switchBranch = switchBranch;
   }
   async execute() {
-    const branches = await this.getBranchesUseCase.execute();
-    if (branches.length === 0) {
-      console.log(`${CHECK}  No branches found.`);
-      return;
-    }
-    const options = [];
-    for (const branch of branches) {
-      let label = branch.name;
-      let value = branch.name;
-      if (branch.isHeadBranch)
-        continue;
-      if (branch.isCurrentBranch) {
-        console.log(`${CHECK}  Current branch: ${branch.name}`);
-        continue;
+    try {
+      const branches = await this.getBranchesUseCase.execute();
+      if (branches.length === 0) {
+        console.log(`${CHECK({ text: "No branches found." })}`);
+        return;
       }
-      if (branch.isRemoteBranch) {
-        label = branch.name.replace("remotes/origin/", `${GREEN}remote branch:${RESET} `);
-        value = branch.name.replace("remotes/origin/", "");
+      const options = [];
+      for (const branch of branches) {
+        let label = branch.name;
+        let value = branch.name;
+        if (branch.isHeadBranch)
+          continue;
+        if (branch.isCurrentBranch) {
+          console.log(`${CHECK({ text: `Current branch: ${branch.name}` })}`);
+          continue;
+        }
+        if (branch.isRemoteBranch) {
+          label = branch.name.replace("remotes/origin/", GREEN({ text: "remote branch: " }));
+          value = branch.name.replace("remotes/origin/", "");
+        }
+        options.push({
+          value,
+          label
+        });
       }
-      options.push({
-        value,
-        label
+      const selectedBranch = await Select({
+        message: "Select the branch you want to switch to.",
+        options
       });
+      await this.switchBranch.execute({ branch: selectedBranch });
+    } catch (error) {
+      errorHandler(error);
     }
-    const selectedBranch = await Select({
-      message: "Select the branch you want to switch to.",
-      options
-    });
-    await this.switchBranch.execute({ branch: selectedBranch });
   }
 }
 
-// src/modules/switch/infra/bun-switch-repository.ts
+// apps/cli/modules/switch/infra/bun-switch-repository.ts
 var {$: $3 } = globalThis.Bun;
-
 class BunSwitchRepository {
   async getBranches() {
-    const output = await $3`git branch -a`.quiet().text();
-    if (!output.trim()) {
-      return [];
-    }
-    return output.split(`
+    try {
+      const output = await $3`git branch -a`.quiet().text();
+      if (!output.trim()) {
+        return [];
+      }
+      return output.split(`
 `).map((branch) => branch.trim());
+    } catch {
+      throw new ServerError("Git branch failed", "Could not retrieve branches");
+    }
   }
   async switchBranch({ branch }) {
     const proc = Bun.spawn(["git", "checkout", branch], {
@@ -1585,12 +2217,12 @@ class BunSwitchRepository {
     });
     const exitCode = await proc.exited;
     if (exitCode !== 0) {
-      throw new Error(`Git checkout failed with exit code ${exitCode}`);
+      throw new ServerError("Git checkout failed", `Failed to switch to branch ${branch}`);
     }
   }
 }
 
-// src/modules/switch/main.ts
+// apps/cli/modules/switch/main.ts
 async function switchCommand() {
   const switchRepo = new BunSwitchRepository;
   const switchBranchUseCase = new SwitchBranch(switchRepo);
@@ -1599,12 +2231,18 @@ async function switchCommand() {
   await switchCommand2.execute();
 }
 
-// src/index.ts
+// apps/cli/index.ts
 var args = Bun.argv.slice(2);
 if (args[0] === "add" && !args[1])
   await addCommand();
+else if (args[0] === "commit" && !args[1])
+  await commitCommand();
 else if (args[0] === "switch" && !args[1])
   await switchCommand();
+else if (args[0] === "alias" && !args[1])
+  await aliasCommand();
+else if (args[0] === "setup")
+  await setupCommand();
 else {
   const proc = Bun.spawn(["git", ...args], {
     stdio: ["inherit", "inherit", "inherit"]

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jannael/glinter",
-	"version": "1.1.0",
+	"version": "1.2.0",
 	"description": "A high-performance, transparent Git wrapper with interactive staging",
 	"type": "module",
 	"private": false,
@@ -13,7 +13,7 @@
 		"name": "Jannael",
 		"url": "https://github.com/jannael"
 	},
-	"homepage": "https://github.com/jannael/glinter#readme",
+	"homepage": "https://glinter.jannael.com",
 	"bugs": {
 		"url": "https://github.com/jannael/glinter/issues"
 	},
@@ -34,12 +34,13 @@
 		".": "./dist/index.js"
 	},
 	"scripts": {
-		"dev": "bun run src/index.ts",
-		"build": "bun build ./src/index.ts --outfile=./dist/index.js --target=bun",
-		"prepublishOnly": "bun run build",
+		"build:cli": "bun build ./apps/cli/index.ts --outfile=./dist/index.js --target=bun",
+		"prepublishOnly": "bun run build:cli",
+
 		"test": "vitest",
 		"lint": "biome check",
-		"lint:fix": "biome format --write"
+		"lint:fix": "biome format --write",
+		"type-check": "bunx tsc --noEmit"
 	},
 	"bin": {
 		"g": "./dist/index.js"
@@ -59,4 +60,4 @@
 	"dependencies": {
 		"@clack/prompts": "1.2.0"
 	}
-}
+}