@pyyupsk/nit 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 pyyupsk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,90 @@
+# @pyyupsk/nit
+
+Lightweight, zero-dependency Git hooks manager for JavaScript/Node.js projects.
+
+Configure hooks in `package.json` — no extra config files, no dependencies.
+
+## Features
+
+- Zero runtime dependencies
+- Config lives in `package.json` under a `"nit"` key
+- Auto-installs hooks via the `prepare` lifecycle script
+- CI-safe `check` command — exits 1 when hooks are out of sync
+- Works with any package manager (bun, npm, pnpm, yarn)
+
+## Installation
+
+```sh
+bun add -D @pyyupsk/nit
+```
+
+Then add a `prepare` script so hooks are installed automatically on `bun install`:
+
+```json
+{
+  "scripts": {
+    "prepare": "nit install"
+  }
+}
+```
+
+## Configuration
+
+Add a `"nit"` key to your `package.json`:
+
+```json
+{
+  "nit": {
+    "hooks": {
+      "pre-commit": "bun run lint && bun run typecheck",
+      "commit-msg": "bun run test"
+    }
+  }
+}
+```
+
+Any valid [Git hook name](https://git-scm.com/docs/githooks) is supported as a key. The value is the shell command to run.
+
+## CLI
+
+```sh
+nit install   # write hooks to .git/hooks/ (default when run bare)
+nit sync      # alias for install
+nit check     # exit 1 if installed hooks differ from config (CI-safe)
+```
+
+### `nit install` / `nit sync`
+
+Reads `nit.hooks` from `package.json` and writes a shell script for each entry into `.git/hooks/`. Each hook file is made executable automatically.
+
+```sh
+$ nit install
+nit: installed pre-commit, commit-msg
+```
+
+### `nit check`
+
+Compares the installed hook files against the current config without writing anything. Exits with code `1` if any hook is missing or has a different command — useful in CI to enforce that hooks are committed.
+
+```sh
+$ nit check
+nit: hooks are up to date
+```
+
+## Self-hosting Example
+
+`nit` manages its own hooks:
+
+```json
+{
+  "nit": {
+    "hooks": {
+      "pre-commit": "bun format && bun check && bun typecheck && bun test && bun run build"
+    }
+  }
+}
+```
+
+## License
+
+MIT

package/dist/cli.cjs

@@ -0,0 +1,257 @@
+#!/usr/bin/env node
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  run: () => run
+});
+module.exports = __toCommonJS(cli_exports);
+var import_node_path6 = require("path");
+
+// src/core/check.ts
+var import_node_fs = require("fs");
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+async function checkHooks(hooks, hooksDir) {
+  try {
+    await (0, import_promises.stat)(hooksDir);
+  } catch {
+    return [new Error(`Hooks directory does not exist: ${hooksDir}`), null];
+  }
+  for (const [name, cmd] of Object.entries(hooks)) {
+    const hookPath = (0, import_node_path.join)(hooksDir, name);
+    if (!(0, import_node_fs.existsSync)(hookPath)) {
+      return [null, false];
+    }
+    let content;
+    try {
+      content = await (0, import_promises.readFile)(hookPath, "utf8");
+    } catch (e) {
+      return [
+        e instanceof Error ? e : new Error(`Failed to read hook "${name}"`),
+        null
+      ];
+    }
+    const lines = content.split("\n");
+    const hasCmd = lines.some((line) => line.trim() === cmd.trim());
+    if (!hasCmd) {
+      return [null, false];
+    }
+  }
+  return [null, true];
+}
+
+// src/core/install.ts
+var import_promises2 = require("fs/promises");
+var import_node_path2 = require("path");
+function hookScript(cmd) {
+  return `#!/bin/sh
+${cmd}
+`;
+}
+async function installHooks(hooks, hooksDir) {
+  try {
+    await (0, import_promises2.stat)(hooksDir);
+  } catch {
+    return [new Error(`Hooks directory does not exist: ${hooksDir}`), null];
+  }
+  const written = [];
+  for (const [name, cmd] of Object.entries(hooks)) {
+    const hookPath = (0, import_node_path2.join)(hooksDir, name);
+    try {
+      await (0, import_promises2.writeFile)(hookPath, hookScript(cmd), "utf8");
+      written.push(hookPath);
+      await (0, import_promises2.chmod)(hookPath, 493);
+    } catch (e) {
+      await Promise.all(written.map((p) => (0, import_promises2.unlink)(p).catch(() => {
+      })));
+      return [
+        e instanceof Error ? e : new Error(`Failed to write hook "${name}"`),
+        null
+      ];
+    }
+  }
+  return [null, true];
+}
+
+// src/core/validate.ts
+var import_node_fs2 = require("fs");
+var import_node_path3 = require("path");
+function commandExists(bin) {
+  const sep = process.platform === "win32" ? ";" : ":";
+  const exts = process.platform === "win32" ? [".exe", ".cmd", ".bat", ""] : [""];
+  const dirs = (process.env.PATH ?? "").split(sep);
+  return dirs.some(
+    (dir) => exts.some((ext) => (0, import_node_fs2.existsSync)((0, import_node_path3.join)(dir, bin + ext)))
+  );
+}
+function validateHooks(hooks) {
+  for (const [hookName, cmd] of Object.entries(hooks)) {
+    const bin = cmd.trim().split(/\s+/).at(0);
+    if (bin === void 0 || bin === "") {
+      return new Error(`Hook "${hookName}" has an empty command`);
+    }
+    if (!commandExists(bin)) {
+      return new Error(`Hook "${hookName}": command "${bin}" not found in PATH`);
+    }
+  }
+  return null;
+}
+
+// src/utils/config.ts
+var import_promises3 = require("fs/promises");
+var import_node_path4 = require("path");
+async function readConfig(cwd) {
+  const pkgPath = (0, import_node_path4.join)(cwd, "package.json");
+  let raw;
+  try {
+    raw = await (0, import_promises3.readFile)(pkgPath, "utf8");
+  } catch {
+    return [new Error(`Cannot find package.json at ${pkgPath}`), null];
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(raw);
+  } catch {
+    return [new Error(`package.json contains invalid JSON at ${pkgPath}`), null];
+  }
+  if (typeof pkg !== "object" || pkg === null) {
+    return [new Error("package.json must be a JSON object"), null];
+  }
+  const nit = pkg.nit;
+  if (nit === void 0) {
+    return [null, { hooks: {} }];
+  }
+  if (typeof nit !== "object" || nit === null) {
+    return [new Error('"nit" in package.json must be an object'), null];
+  }
+  const nitObj = nit;
+  const hooks = nitObj.hooks;
+  if (hooks === void 0) {
+    return [null, { hooks: {} }];
+  }
+  if (typeof hooks !== "object" || hooks === null || Array.isArray(hooks)) {
+    return [new Error("hooks must be an object in nit config"), null];
+  }
+  const hooksObj = hooks;
+  for (const [name, cmd] of Object.entries(hooksObj)) {
+    if (typeof cmd !== "string") {
+      return [
+        new Error(
+          `Hook "${name}" must have a string command, got ${typeof cmd}`
+        ),
+        null
+      ];
+    }
+  }
+  return [null, { hooks: hooksObj }];
+}
+
+// src/utils/git.ts
+var import_node_fs3 = require("fs");
+var import_promises4 = require("fs/promises");
+var import_node_path5 = require("path");
+async function findGitDir(startPath, stopAt) {
+  try {
+    await (0, import_promises4.stat)(startPath);
+  } catch {
+    return [new Error(`Path does not exist: ${startPath}`), null];
+  }
+  let current = startPath;
+  const { root } = (0, import_node_path5.parse)(current);
+  while (current !== root) {
+    const candidate = (0, import_node_path5.join)(current, ".git");
+    if ((0, import_node_fs3.existsSync)(candidate)) {
+      return [null, candidate];
+    }
+    if (stopAt !== void 0 && current === stopAt) break;
+    const parent = (0, import_node_path5.dirname)(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return [new Error(`Not a git repository (searched from ${startPath})`), null];
+}
+
+// src/cli.ts
+var silent = { log: () => {
+}, error: () => {
+} };
+async function run(args, cwd, logger = silent) {
+  const command = args.at(0) ?? "install";
+  if (!["install", "sync", "check"].includes(command)) {
+    logger.error(`nit: unknown command "${command}"`);
+    logger.error("Usage: nit [install|sync|check]");
+    return 1;
+  }
+  const [cfgErr, config] = await readConfig(cwd);
+  if (cfgErr !== null) {
+    logger.error(`nit: ${cfgErr.message}`);
+    return 1;
+  }
+  const [gitErr, gitDir] = await findGitDir(cwd);
+  if (gitErr !== null) {
+    if (command !== "check") return 0;
+    logger.error(`nit: ${gitErr.message}`);
+    return 1;
+  }
+  const hooksDir = (0, import_node_path6.join)(gitDir, "hooks");
+  if (command === "check") {
+    const [err, inSync] = await checkHooks(config.hooks, hooksDir);
+    if (err !== null) {
+      logger.error(`nit: ${err.message}`);
+      return 1;
+    }
+    if (!inSync) {
+      logger.error("nit: hooks are out of sync \u2014 run `nit install` to fix");
+      return 1;
+    }
+    logger.log("nit: hooks are up to date");
+    return 0;
+  }
+  const validErr = validateHooks(config.hooks);
+  if (validErr !== null) {
+    logger.error(`nit: ${validErr.message}`);
+    return 1;
+  }
+  const [installErr] = await installHooks(config.hooks, hooksDir);
+  if (installErr !== null) {
+    logger.error(`nit: ${installErr.message}`);
+    return 1;
+  }
+  const hookNames = Object.keys(config.hooks);
+  if (hookNames.length === 0) {
+    logger.log("nit: no hooks configured");
+  } else {
+    logger.log(`nit: installed ${hookNames.join(", ")}`);
+  }
+  return 0;
+}
+var isMain = typeof process !== "undefined" && /[/\\](?:cli\.[jt]s|nit)$/.test(process.argv[1] ?? "");
+if (isMain) {
+  const args = process.argv.slice(2);
+  run(args, process.cwd(), console).then((code) => {
+    process.exit(code);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  run
+});

package/dist/cli.js

@@ -0,0 +1,233 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { join as join6 } from "path";
+
+// src/core/check.ts
+import { existsSync } from "fs";
+import { readFile, stat } from "fs/promises";
+import { join } from "path";
+async function checkHooks(hooks, hooksDir) {
+  try {
+    await stat(hooksDir);
+  } catch {
+    return [new Error(`Hooks directory does not exist: ${hooksDir}`), null];
+  }
+  for (const [name, cmd] of Object.entries(hooks)) {
+    const hookPath = join(hooksDir, name);
+    if (!existsSync(hookPath)) {
+      return [null, false];
+    }
+    let content;
+    try {
+      content = await readFile(hookPath, "utf8");
+    } catch (e) {
+      return [
+        e instanceof Error ? e : new Error(`Failed to read hook "${name}"`),
+        null
+      ];
+    }
+    const lines = content.split("\n");
+    const hasCmd = lines.some((line) => line.trim() === cmd.trim());
+    if (!hasCmd) {
+      return [null, false];
+    }
+  }
+  return [null, true];
+}
+
+// src/core/install.ts
+import { chmod, stat as stat2, unlink, writeFile } from "fs/promises";
+import { join as join2 } from "path";
+function hookScript(cmd) {
+  return `#!/bin/sh
+${cmd}
+`;
+}
+async function installHooks(hooks, hooksDir) {
+  try {
+    await stat2(hooksDir);
+  } catch {
+    return [new Error(`Hooks directory does not exist: ${hooksDir}`), null];
+  }
+  const written = [];
+  for (const [name, cmd] of Object.entries(hooks)) {
+    const hookPath = join2(hooksDir, name);
+    try {
+      await writeFile(hookPath, hookScript(cmd), "utf8");
+      written.push(hookPath);
+      await chmod(hookPath, 493);
+    } catch (e) {
+      await Promise.all(written.map((p) => unlink(p).catch(() => {
+      })));
+      return [
+        e instanceof Error ? e : new Error(`Failed to write hook "${name}"`),
+        null
+      ];
+    }
+  }
+  return [null, true];
+}
+
+// src/core/validate.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join3 } from "path";
+function commandExists(bin) {
+  const sep = process.platform === "win32" ? ";" : ":";
+  const exts = process.platform === "win32" ? [".exe", ".cmd", ".bat", ""] : [""];
+  const dirs = (process.env.PATH ?? "").split(sep);
+  return dirs.some(
+    (dir) => exts.some((ext) => existsSync2(join3(dir, bin + ext)))
+  );
+}
+function validateHooks(hooks) {
+  for (const [hookName, cmd] of Object.entries(hooks)) {
+    const bin = cmd.trim().split(/\s+/).at(0);
+    if (bin === void 0 || bin === "") {
+      return new Error(`Hook "${hookName}" has an empty command`);
+    }
+    if (!commandExists(bin)) {
+      return new Error(`Hook "${hookName}": command "${bin}" not found in PATH`);
+    }
+  }
+  return null;
+}
+
+// src/utils/config.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join4 } from "path";
+async function readConfig(cwd) {
+  const pkgPath = join4(cwd, "package.json");
+  let raw;
+  try {
+    raw = await readFile2(pkgPath, "utf8");
+  } catch {
+    return [new Error(`Cannot find package.json at ${pkgPath}`), null];
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(raw);
+  } catch {
+    return [new Error(`package.json contains invalid JSON at ${pkgPath}`), null];
+  }
+  if (typeof pkg !== "object" || pkg === null) {
+    return [new Error("package.json must be a JSON object"), null];
+  }
+  const nit = pkg.nit;
+  if (nit === void 0) {
+    return [null, { hooks: {} }];
+  }
+  if (typeof nit !== "object" || nit === null) {
+    return [new Error('"nit" in package.json must be an object'), null];
+  }
+  const nitObj = nit;
+  const hooks = nitObj.hooks;
+  if (hooks === void 0) {
+    return [null, { hooks: {} }];
+  }
+  if (typeof hooks !== "object" || hooks === null || Array.isArray(hooks)) {
+    return [new Error("hooks must be an object in nit config"), null];
+  }
+  const hooksObj = hooks;
+  for (const [name, cmd] of Object.entries(hooksObj)) {
+    if (typeof cmd !== "string") {
+      return [
+        new Error(
+          `Hook "${name}" must have a string command, got ${typeof cmd}`
+        ),
+        null
+      ];
+    }
+  }
+  return [null, { hooks: hooksObj }];
+}
+
+// src/utils/git.ts
+import { existsSync as existsSync3 } from "fs";
+import { stat as stat3 } from "fs/promises";
+import { dirname, join as join5, parse } from "path";
+async function findGitDir(startPath, stopAt) {
+  try {
+    await stat3(startPath);
+  } catch {
+    return [new Error(`Path does not exist: ${startPath}`), null];
+  }
+  let current = startPath;
+  const { root } = parse(current);
+  while (current !== root) {
+    const candidate = join5(current, ".git");
+    if (existsSync3(candidate)) {
+      return [null, candidate];
+    }
+    if (stopAt !== void 0 && current === stopAt) break;
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return [new Error(`Not a git repository (searched from ${startPath})`), null];
+}
+
+// src/cli.ts
+var silent = { log: () => {
+}, error: () => {
+} };
+async function run(args, cwd, logger = silent) {
+  const command = args.at(0) ?? "install";
+  if (!["install", "sync", "check"].includes(command)) {
+    logger.error(`nit: unknown command "${command}"`);
+    logger.error("Usage: nit [install|sync|check]");
+    return 1;
+  }
+  const [cfgErr, config] = await readConfig(cwd);
+  if (cfgErr !== null) {
+    logger.error(`nit: ${cfgErr.message}`);
+    return 1;
+  }
+  const [gitErr, gitDir] = await findGitDir(cwd);
+  if (gitErr !== null) {
+    if (command !== "check") return 0;
+    logger.error(`nit: ${gitErr.message}`);
+    return 1;
+  }
+  const hooksDir = join6(gitDir, "hooks");
+  if (command === "check") {
+    const [err, inSync] = await checkHooks(config.hooks, hooksDir);
+    if (err !== null) {
+      logger.error(`nit: ${err.message}`);
+      return 1;
+    }
+    if (!inSync) {
+      logger.error("nit: hooks are out of sync \u2014 run `nit install` to fix");
+      return 1;
+    }
+    logger.log("nit: hooks are up to date");
+    return 0;
+  }
+  const validErr = validateHooks(config.hooks);
+  if (validErr !== null) {
+    logger.error(`nit: ${validErr.message}`);
+    return 1;
+  }
+  const [installErr] = await installHooks(config.hooks, hooksDir);
+  if (installErr !== null) {
+    logger.error(`nit: ${installErr.message}`);
+    return 1;
+  }
+  const hookNames = Object.keys(config.hooks);
+  if (hookNames.length === 0) {
+    logger.log("nit: no hooks configured");
+  } else {
+    logger.log(`nit: installed ${hookNames.join(", ")}`);
+  }
+  return 0;
+}
+var isMain = typeof process !== "undefined" && /[/\\](?:cli\.[jt]s|nit)$/.test(process.argv[1] ?? "");
+if (isMain) {
+  const args = process.argv.slice(2);
+  run(args, process.cwd(), console).then((code) => {
+    process.exit(code);
+  });
+}
+export {
+  run
+};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@pyyupsk/nit",
+  "version": "0.1.0",
+  "description": "Lightweight zero-dependency Git hooks manager for JavaScript/Node.js projects",
+  "license": "MIT",
+  "packageManager": "bun@1.3.11",
+  "type": "module",
+  "main": "dist/cli.js",
+  "module": "dist/cli.js",
+  "bin": {
+    "nit": "dist/cli.js"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "check": "biome check .",
+    "dev": "tsup --watch",
+    "format": "biome format --write .",
+    "prepare": "bun run ./src/cli.ts install",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.11",
+    "@types/bun": "^1.3.12",
+    "@vitest/coverage-v8": "^4.1.4",
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.4"
+  },
+  "nit": {
+    "hooks": {
+      "pre-commit": "bun format && bun check && bun typecheck && bun test && bun run build"
+    }
+  }
+}