@jannael/glinter 1.0.3 → 1.0.4

package/dist/index.js

@@ -90,6 +90,19 @@ var require_src = __commonJS((exports, module) => {
   module.exports = { cursor, scroll, erase, beep };
 });
 
+// src/packages/colors.ts
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var RED = "\x1B[31m";
+var MAGENTA = "\x1B[35m";
+var BOLD = "\x1B[1m";
+var BLACK = "\x1B[30m";
+var BG_YELLOW = "\x1B[43m";
+var RESET = "\x1B[0m";
+
+// src/packages/check.ts
+var CHECK = `${GREEN}\u2714${RESET}`;
+
 // node_modules/@clack/core/dist/index.mjs
 import { styleText as y } from "util";
 import { stdout as S, stdin as $ } from "process";
@@ -1008,6 +1021,33 @@ var it = class extends p {
     });
   }
 };
+class nt extends p {
+  options;
+  cursor = 0;
+  get _selectedValue() {
+    return this.options[this.cursor];
+  }
+  changeValue() {
+    this.value = this._selectedValue.value;
+  }
+  constructor(t) {
+    super(t, false), this.options = t.options;
+    const e = this.options.findIndex(({ value: i }) => i === t.initialValue), s = e === -1 ? 0 : e;
+    this.cursor = this.options[s].disabled ? d(s, 1, this.options) : s, this.changeValue(), this.on("cursor", (i) => {
+      switch (i) {
+        case "left":
+        case "up":
+          this.cursor = d(this.cursor, -1, this.options);
+          break;
+        case "down":
+        case "right":
+          this.cursor = d(this.cursor, 1, this.options);
+          break;
+      }
+      this.changeValue();
+    });
+  }
+}
 
 // node_modules/@clack/prompts/dist/index.mjs
 import { styleText as t, stripVTControlCharacters as ne } from "util";
@@ -1167,100 +1207,402 @@ ${r ? t("cyan", E2) : ""}
   } }).prompt();
 };
 var Ve = { light: w2("\u2500", "-"), heavy: w2("\u2501", "="), block: w2("\u2588", "#") };
+var re = (e, i) => e.includes(`
+`) ? e.split(`
+`).map((s) => i(s)).join(`
+`) : i(e);
+var _t = (e) => {
+  const i = (s, r) => {
+    const u2 = s.label ?? String(s.value);
+    switch (r) {
+      case "disabled":
+        return `${t("gray", H2)} ${re(u2, (n) => t("gray", n))}${s.hint ? ` ${t("dim", `(${s.hint ?? "disabled"})`)}` : ""}`;
+      case "selected":
+        return `${re(u2, (n) => t("dim", n))}`;
+      case "active":
+        return `${t("green", z2)} ${u2}${s.hint ? ` ${t("dim", `(${s.hint})`)}` : ""}`;
+      case "cancelled":
+        return `${re(u2, (n) => t(["strikethrough", "dim"], n))}`;
+      default:
+        return `${t("dim", H2)} ${re(u2, (n) => t("dim", n))}`;
+    }
+  };
+  return new nt({ options: e.options, signal: e.signal, input: e.input, output: e.output, initialValue: e.initialValue, render() {
+    const s = e.withGuide ?? u.withGuide, r = `${V2(this.state)}  `, u2 = `${ye(this.state)}  `, n = R(e.output, e.message, u2, r), o = `${s ? `${t("gray", d2)}
+` : ""}${n}
+`;
+    switch (this.state) {
+      case "submit": {
+        const c2 = s ? `${t("gray", d2)}  ` : "", a = R(e.output, i(this.options[this.cursor], "selected"), c2);
+        return `${o}${a}`;
+      }
+      case "cancel": {
+        const c2 = s ? `${t("gray", d2)}  ` : "", a = R(e.output, i(this.options[this.cursor], "cancelled"), c2);
+        return `${o}${a}${s ? `
+${t("gray", d2)}` : ""}`;
+      }
+      default: {
+        const c2 = s ? `${t("cyan", d2)}  ` : "", a = s ? t("cyan", E2) : "", l = o.split(`
+`).length, $2 = s ? 2 : 1;
+        return `${o}${c2}${Y2({ output: e.output, cursor: this.cursor, options: this.options, maxItems: e.maxItems, columnPadding: c2.length, rowPadding: l + $2, style: (y2, p2) => i(y2, y2.disabled ? "disabled" : p2 ? "active" : "inactive") }).join(`
+${c2}`)}
+${a}
+`;
+      }
+    }
+  } }).prompt();
+};
 var je = `${t("gray", d2)}  `;
 
-// src/add-command.ts
-var {$: $2 } = globalThis.Bun;
-async function main() {
-  const output = await $2`git status --porcelain -z`.quiet().text();
-  if (!output.trim()) {
-    console.log("\x1B[32m\u2714\x1B[0m No changes detected.");
-    return;
+// src/packages/multiselect.ts
+async function MultiSelect({
+  message,
+  options
+}) {
+  const selected = await yt({
+    message,
+    options,
+    required: true
+  });
+  if (q(selected)) {
+    pt("Operation cancelled.");
+    process.exit(0);
   }
-  const warnings = new Set;
-  const entries = output.split("\x00").filter(Boolean);
-  const changes = [];
-  for (let i = 0;i < entries.length; i++) {
-    const entry = entries[i];
-    if (!entry)
-      continue;
-    const status = entry.slice(0, 2);
-    const file = entry.slice(3);
-    const isStaged = status[0] !== " " && status[0] !== "?";
-    if (isStaged)
-      continue;
-    let displayPath = file;
-    const value = file;
-    if (status.startsWith("R") || status.startsWith("C")) {
-      const source = entries[++i];
-      displayPath = `${source} -> ${file}`;
+  return selected;
+}
+
+// src/add/app/add-command.ts
+class AddCommand {
+  getChangesUseCase;
+  stageChangesUseCase;
+  constructor(getChangesUseCase, stageChangesUseCase) {
+    this.getChangesUseCase = getChangesUseCase;
+    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 = [
+      { value: "all", label: `${BOLD}all changes${RESET}` },
+      ...changes.map((c2) => ({ value: c2.value, label: c2.label }))
+    ];
+    const selectedChanges = await MultiSelect({
+      message: "Select the changes you want to commit. (select with space and confirm with enter)",
+      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);
+        }
+        console.log("");
+      }
     }
-    let label = "";
+  }
+}
+
+// src/add/domain/change.ts
+class Change {
+  props;
+  constructor(props) {
+    this.props = props;
+  }
+  get value() {
+    return this.props.value;
+  }
+  get status() {
+    return this.props.status;
+  }
+  get displayPath() {
+    return this.props.displayPath;
+  }
+  get label() {
+    const { status, displayPath } = this.props;
+    let label = `${status}: ${displayPath}`;
     if (status.includes("M")) {
-      label = `\x1B[33mmodified:\x1B[0m ${displayPath}`;
-    } else if (status.includes("A") || status.includes("?")) {
-      label = `\x1B[32mnew file:\x1B[0m ${displayPath}`;
-    } else if (status.includes("D")) {
-      label = `\x1B[31mdeleted:\x1B[0m ${displayPath}`;
-    } else if (status.includes("R")) {
-      label = `\x1B[35mrenamed:\x1B[0m ${displayPath}`;
-    } else {
-      label = `${status}: ${displayPath}`;
+      label = `${YELLOW}modified:${RESET} ${displayPath}`;
     }
-    const isSensitive = value.includes(".env") || value.includes("node_modules");
-    if (value.includes(".env")) {
-      warnings.add("\x1B[33m .env file hidden\x1B[0m (Add to .gitignore to avoid leaks)");
+    if (status.includes("A") || status.includes("?")) {
+      label = `${GREEN}new file:${RESET} ${displayPath}`;
     }
-    if (value.includes("node_modules")) {
-      warnings.add("\x1B[33m node_modules hidden\x1B[0m (Add to .gitignore to save space)");
+    if (status.includes("D")) {
+      label = `${RED}deleted:${RESET} ${displayPath}`;
     }
-    if (!isSensitive) {
-      changes.push({ value, label });
+    if (status.includes("R")) {
+      label = `${MAGENTA}renamed:${RESET} ${displayPath}`;
     }
+    return label;
   }
-  if (changes.length === 0) {
-    console.log("\x1B[32m\u2714\x1B[0m All changes are either staged or sensitive (like .env).");
-    return;
+  isSensitive() {
+    return this.value.includes(".env") || this.value.includes("node_modules");
   }
-  const options = [
-    { value: "all", label: "\x1B[1mall changes\x1B[0m" },
-    ...changes
-  ];
-  const selectedChanges = await yt({
-    message: "Select the changes you want to commit. (select with space and confirm with enter)",
-    options,
-    required: true
+  getWarning() {
+    if (this.value.includes(".env")) {
+      return `${YELLOW} .env file hidden${RESET} (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 null;
+  }
+  static fromPorcelain(entries) {
+    const changes = [];
+    for (let i = 0;i < entries.length; i++) {
+      const entry = entries[i];
+      if (!entry)
+        continue;
+      const status = entry.slice(0, 2);
+      const file = entry.slice(3);
+      const isStaged = status[0] !== " " && status[0] !== "?";
+      if (isStaged)
+        continue;
+      let displayPath = file;
+      const value = file;
+      if (status.startsWith("R") || status.startsWith("C")) {
+        const source = entries[++i];
+        displayPath = `${source} -> ${file}`;
+      }
+      changes.push(new Change({ value, status, displayPath }));
+    }
+    return changes;
+  }
+}
+
+// src/add/app/get-changes.use-case.ts
+class GetChangesUseCase {
+  gitRepository;
+  constructor(gitRepository) {
+    this.gitRepository = gitRepository;
+  }
+  async execute() {
+    const entries = await this.gitRepository.getEntries();
+    if (entries.length === 0) {
+      return { changes: [], warnings: new Set };
+    }
+    const allChanges = Change.fromPorcelain(entries);
+    const warnings = new Set;
+    const changes = [];
+    for (const change of allChanges) {
+      const warning = change.getWarning();
+      if (warning) {
+        warnings.add(warning);
+      }
+      if (!change.isSensitive()) {
+        changes.push(change);
+      }
+    }
+    return { changes, warnings };
+  }
+}
+
+// src/add/app/stage-changes.use-case.ts
+class StageChangesUseCase {
+  gitRepository;
+  constructor(gitRepository) {
+    this.gitRepository = gitRepository;
+  }
+  async execute(files) {
+    if (files.length === 0)
+      return;
+    await this.gitRepository.stageFiles(files);
+  }
+}
+
+// src/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 [];
+    }
+    return output.split("\x00").filter(Boolean);
+  }
+  async stageFiles(files) {
+    if (files.length === 0)
+      return;
+    const proc = Bun.spawn(["git", "add", ...files], {
+      stdio: ["inherit", "inherit", "inherit"]
+    });
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      throw new Error(`Git add failed with exit code ${exitCode}`);
+    }
+  }
+}
+
+// src/add/main.ts
+async function addCommand() {
+  const gitRepository = new BunGitRepository;
+  const getChangesUseCase = new GetChangesUseCase(gitRepository);
+  const stageChangesUseCase = new StageChangesUseCase(gitRepository);
+  const addCommand2 = new AddCommand(getChangesUseCase, stageChangesUseCase);
+  await addCommand2.execute();
+}
+
+// src/switch/domain/branch.ts
+class Branch {
+  props;
+  constructor(props) {
+    this.props = props;
+  }
+  get name() {
+    return this.props.name;
+  }
+  get isCurrentBranch() {
+    return this.props.current;
+  }
+  get isRemoteBranch() {
+    return this.props.remote;
+  }
+  get isHeadBranch() {
+    return this.props.name.includes("HEAD");
+  }
+  static fromPorcelain(entries) {
+    const branches = [];
+    for (let i = 0;i < entries.length; i++) {
+      const entry = entries[i];
+      if (!entry)
+        continue;
+      const current = entry.includes("*");
+      const remote = entry.includes("remotes/");
+      branches.push(new Branch({ name: entry, current, remote }));
+    }
+    return branches;
+  }
+}
+
+// src/switch/app/get-branches.use-case.ts
+class GetBranchesUseCase {
+  branchRepository;
+  constructor(branchRepository) {
+    this.branchRepository = branchRepository;
+  }
+  async execute() {
+    const branches = await this.branchRepository.getBranches();
+    const allBranches = Branch.fromPorcelain(branches);
+    return allBranches;
+  }
+}
+
+// src/switch/app/switch-branch.use-case.ts
+class SwitchBranch {
+  branchRepository;
+  constructor(branchRepository) {
+    this.branchRepository = branchRepository;
+  }
+  async execute({ branch }) {
+    await this.branchRepository.switchBranch({ branch });
+  }
+}
+
+// src/packages/select.ts
+async function Select({
+  message,
+  options
+}) {
+  const selected = await _t({
+    message,
+    options
   });
-  if (q(selectedChanges)) {
+  if (q(selected)) {
     pt("Operation cancelled.");
     process.exit(0);
   }
-  let selected = selectedChanges.map((file) => file.trim());
-  if (selected.includes("all")) {
-    selected = changes.map((c2) => c2.value);
+  return selected;
+}
+
+// src/switch/app/switch-command.ts
+class SwitchCommand {
+  getBranchesUseCase;
+  switchBranch;
+  constructor(getBranchesUseCase, switchBranch) {
+    this.getBranchesUseCase = getBranchesUseCase;
+    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;
+      }
+      if (branch.isRemoteBranch) {
+        label = branch.name.replace("remotes/origin/", `${GREEN}remote branch:${RESET} `);
+        value = branch.name.replace("remotes/origin/", "");
+      }
+      options.push({
+        value,
+        label
+      });
+    }
+    const selectedBranch = await Select({
+      message: "Select the branch you want to switch to.",
+      options
+    });
+    await this.switchBranch.execute({ branch: selectedBranch });
   }
-  if (selected.length > 0) {
-    const proc = Bun.spawn(["git", "add", ...selected], {
+}
+
+// src/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(`
+`).map((branch) => branch.trim());
+  }
+  async switchBranch({ branch }) {
+    const proc = Bun.spawn(["git", "checkout", branch], {
       stdio: ["inherit", "inherit", "inherit"]
     });
     const exitCode = await proc.exited;
-    if (warnings.size > 0) {
-      console.log(`
-\x1B[43m\x1B[30m WARNING \x1B[0m`);
-      for (const warning of warnings) {
-        console.log(warning);
-      }
-      console.log("");
+    if (exitCode !== 0) {
+      throw new Error(`Git checkout failed with exit code ${exitCode}`);
     }
-    process.exit(exitCode);
   }
 }
 
+// src/switch/main.ts
+async function switchCommand() {
+  const switchRepo = new BunSwitchRepository;
+  const switchBranchUseCase = new SwitchBranch(switchRepo);
+  const getBranchesUseCase = new GetBranchesUseCase(switchRepo);
+  const switchCommand2 = new SwitchCommand(getBranchesUseCase, switchBranchUseCase);
+  await switchCommand2.execute();
+}
+
 // src/index.ts
 var args = Bun.argv.slice(2);
-if (args[0] === "add" && !args[1]) {
-  await main();
-} else {
+if (args[0] === "add" && !args[1])
+  await addCommand();
+else if (args[0] === "switch" && !args[1])
+  await switchCommand();
+else {
   const proc = Bun.spawn(["git", ...args], {
     stdio: ["inherit", "inherit", "inherit"]
   });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jannael/glinter",
-	"version": "1.0.3",
+	"version": "1.0.4",
 	"description": "A high-performance, transparent Git wrapper with interactive staging",
 	"type": "module",
 	"private": false,
@@ -31,12 +31,15 @@
 		"dist"
 	],
 	"exports": {
-		".": "./dist/index.js"
+		".": "./src/index.ts"
 	},
 	"scripts": {
 		"dev": "bun run src/index.ts",
 		"build": "bun build ./src/index.ts --outfile=./dist/index.js --target=bun",
-		"prepublishOnly": "bun run build"
+		"prepublishOnly": "bun run build",
+		"test": "vitest",
+		"lint": "biome check",
+		"lint:fix": "biome format --write"
 	},
 	"bin": {
 		"g": "./dist/index.js"
@@ -46,7 +49,8 @@
 	},
 	"devDependencies": {
 		"@biomejs/biome": "2.4.10",
-		"@types/bun": "latest"
+		"@types/bun": "latest",
+		"vitest": "4.1.4"
 	},
 	"peerDependencies": {
 		"bun": ">=1.0.0",