@lowdep/hashsum 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rushabh Shah
+
+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,119 @@
+# hashsum
+
+![Zero dependencies](https://img.shields.io/badge/dependencies-0-brightgreen) ![Node](https://img.shields.io/badge/node-%3E%3D14-blue) ![License: MIT](https://img.shields.io/badge/license-MIT-green) ![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux-lightgrey)
+
+
+Compute and verify file checksums with one consistent interface on every OS. Supports MD5, SHA-1, SHA-256, and SHA-512. Zero dependencies.
+
+No more remembering `sha256sum` (Linux) vs `shasum -a 256` (macOS) vs `certutil -hashfile` / `Get-FileHash` (Windows) — all of which print different formats.
+
+---
+
+## Install
+
+```bash
+npm install -g hashsum
+```
+
+Or without installing:
+
+```bash
+npx hashsum file.zip
+```
+
+---
+
+## Usage
+
+```bash
+hashsum file.zip                    # SHA-256 (default)
+hashsum *.iso -a sha512             # SHA-512 of several files
+hashsum dist/* --save              # Write sha256sums.txt
+hashsum -c sha256sums.txt          # Verify files against the list
+hashsum --string "hello" -a md5    # Hash a literal string
+```
+
+---
+
+## Output Format
+
+Matches `sha256sum`, so the files are interoperable:
+
+```
+$ hashsum archive.tar.gz
+9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08  archive.tar.gz
+```
+
+---
+
+## Verify Downloads
+
+Generate a checksum list:
+
+```bash
+hashsum *.iso -a sha256 --save     # → sha256sums.txt
+```
+
+Verify later (the algorithm is auto-detected from each hash's length):
+
+```bash
+$ hashsum -c sha256sums.txt
+
+hashsum  verifying 3 file(s) from sha256sums.txt
+
+  ✓ OK  ubuntu.iso
+  ✗ FAILED  corrupted.iso
+  ? MISSING  deleted.iso
+
+  1 OK  ·  1 failed  ·  1 missing
+```
+
+Exit code is `1` if any file fails or is missing — so it works in CI and scripts.
+
+---
+
+## Supported Algorithms
+
+| Algorithm | Hash length | Notes |
+|---|---|---|
+| `md5` | 32 hex | Fast, **not** for security |
+| `sha1` | 40 hex | Legacy |
+| `sha256` | 64 hex | **Default** — the modern standard |
+| `sha512` | 128 hex | Stronger / faster on 64-bit |
+
+When verifying with `-c`, the algorithm is inferred from each hash's length, so a mixed file works.
+
+---
+
+## Options
+
+| Flag | Description |
+|---|---|
+| `-a, --algo <name>` | `md5` \| `sha1` \| `sha256` \| `sha512` |
+| `-c, --check <file>` | Verify files listed in a checksums file |
+| `--string <text>` | Hash a string instead of a file |
+| `--save` | Write `<algo>sums.txt` |
+| `--json` | JSON output |
+| `--quiet` | Print only the hash / exit code |
+
+---
+
+## License
+
+MIT
+
+---
+
+## Keywords
+
+`checksum` · `sha256` · `md5` · `file hash` · `sha256sum windows` · `verify checksum` · `sha512` · `integrity check` · `cross-platform` · `zero dependencies`
+
+---
+
+<div align="center">
+
+**Built to solve, shared to help — Rushabh Shah 🛠️✨**
+
+<sub>One of 40+ zero-dependency developer CLI tools — no <code>node_modules</code>, ever.</sub>
+
+</div>

package/bin/hashsum.js

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs     = require('fs');
+const path   = require('path');
+const crypto = require('crypto');
+
+const VERSION = '1.0.0';
+
+// ─── ANSI ─────────────────────────────────────────────────────────────────────
+const isTTY  = process.stdout.isTTY;
+const c      = (code, t) => isTTY ? `\x1b[${code}m${t}\x1b[0m` : t;
+const bold   = t => c('1',  t);
+const dim    = t => c('2',  t);
+const red    = t => c('31', t);
+const green  = t => c('32', t);
+const yellow = t => c('33', t);
+const cyan   = t => c('36', t);
+
+const ALGOS = ['md5', 'sha1', 'sha256', 'sha512'];
+
+// ─── Hash a file (streaming) ──────────────────────────────────────────────────
+function hashFile(filePath, algo) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash(algo);
+    const stream = fs.createReadStream(filePath);
+    stream.on('data', d => hash.update(d));
+    stream.on('end', () => resolve(hash.digest('hex')));
+    stream.on('error', reject);
+  });
+}
+
+function hashString(str, algo) {
+  return crypto.createHash(algo).update(str).digest('hex');
+}
+
+// ─── Parse a checksums file ───────────────────────────────────────────────────
+// Lines look like:  <hex>  <filename>   (two spaces, like sha256sum)
+//               or:  <hex> *<filename>  (binary mode marker)
+function parseChecksumFile(content) {
+  const entries = [];
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const m = trimmed.match(/^([0-9a-fA-F]{32,128})\s+\*?(.+)$/);
+    if (m) entries.push({ hash: m[1].toLowerCase(), file: m[2].trim() });
+  }
+  return entries;
+}
+
+function algoForHashLength(hex) {
+  switch (hex.length) {
+    case 32:  return 'md5';
+    case 40:  return 'sha1';
+    case 64:  return 'sha256';
+    case 128: return 'sha512';
+    default:  return null;
+  }
+}
+
+// ─── CLI ──────────────────────────────────────────────────────────────────────
+const args        = process.argv.slice(2);
+const VALUE_FLAGS  = new Set(['-a', '--algo', '-c', '--check', '--string']);
+
+function getFlag(...names) { for (const f of names) { const i = args.indexOf(f); if (i !== -1) return args[i + 1]; } return null; }
+function hasFlag(...names) { return names.some(f => args.includes(f)); }
+
+const positional = [];
+for (let i = 0; i < args.length; i++) {
+  if (args[i].startsWith('-') && args[i] !== '-') { if (VALUE_FLAGS.has(args[i])) i++; }
+  else positional.push(args[i]);
+}
+
+if (hasFlag('--version', '-v')) { console.log(`hashsum v${VERSION}`); process.exit(0); }
+
+if (hasFlag('--help', '-h') || (!positional.length && !getFlag('-c', '--check') && getFlag('--string') === null)) {
+  console.log(`
+${bold('hashsum')} — Compute and verify file checksums, cross-platform, zero deps
+
+${bold('USAGE')}
+  hashsum [file...] [options]
+  hashsum -c <checksums-file>          Verify files against a checksum list
+  hashsum --string "text" -a sha256    Hash a literal string
+
+${bold('OPTIONS')}
+  -a, --algo <name>    md5 | sha1 | sha256 (default) | sha512
+  -c, --check <file>   Verify files listed in a checksums file
+  --string <text>      Hash a string instead of a file
+  --save               Write "<hash>  <file>" lines to <algo>sums.txt
+  --json               JSON output
+  --quiet              Minimal output (just results / exit code)
+  --version            Show version
+
+${bold('EXAMPLES')}
+  hashsum file.zip                       # sha256 of one file
+  hashsum *.iso -a sha512                # sha512 of several files
+  hashsum dist/* --save                  # write sha256sums.txt
+  hashsum -c sha256sums.txt              # verify against the list
+  hashsum --string "hello" -a md5        # hash a string
+
+${bold('OUTPUT FORMAT')}  matches sha256sum:  ${dim('<hex>  <filename>')}
+`);
+  process.exit(0);
+}
+
+const algo    = (getFlag('-a', '--algo') || 'sha256').toLowerCase();
+const checkFile = getFlag('-c', '--check');
+const strInput  = getFlag('--string');
+const save      = hasFlag('--save');
+const asJson    = hasFlag('--json');
+const quiet     = hasFlag('--quiet');
+
+if (!checkFile && !ALGOS.includes(algo)) {
+  console.error(red(`\nUnknown algorithm: ${algo}.  Use: ${ALGOS.join(', ')}\n`)); process.exit(2);
+}
+
+(async () => {
+  // ── Verify mode ──
+  if (checkFile) {
+    if (!fs.existsSync(checkFile)) { console.error(red(`\nChecksums file not found: ${checkFile}\n`)); process.exit(2); }
+    const baseDir = path.dirname(path.resolve(checkFile));
+    const entries = parseChecksumFile(fs.readFileSync(checkFile, 'utf8'));
+    if (!entries.length) { console.error(yellow('\nNo checksum entries found in file.\n')); process.exit(2); }
+
+    if (!quiet && !asJson) console.log(`\n${bold('hashsum')}  ${dim('verifying ' + entries.length + ' file(s) from ' + path.basename(checkFile))}\n`);
+
+    let ok = 0, failed = 0, missing = 0;
+    const results = [];
+    for (const e of entries) {
+      const filePath = path.resolve(baseDir, e.file);
+      const useAlgo = algoForHashLength(e.hash) || algo;
+      let status;
+      if (!fs.existsSync(filePath)) { status = 'missing'; missing++; }
+      else {
+        const actual = await hashFile(filePath, useAlgo);
+        status = actual === e.hash ? 'ok' : 'failed';
+        if (status === 'ok') ok++; else failed++;
+      }
+      results.push({ file: e.file, status, algo: useAlgo });
+      if (!quiet && !asJson) {
+        const sym = status === 'ok' ? green('✓ OK') : status === 'missing' ? yellow('? MISSING') : red('✗ FAILED');
+        console.log(`  ${sym}  ${e.file}`);
+      }
+    }
+
+    if (asJson) {
+      console.log(JSON.stringify({ checked: entries.length, ok, failed, missing, results }, null, 2));
+    } else if (!quiet) {
+      console.log();
+      const parts = [green(`${ok} OK`)];
+      if (failed)  parts.push(red(`${failed} failed`));
+      if (missing) parts.push(yellow(`${missing} missing`));
+      console.log(`  ${parts.join('  ·  ')}\n`);
+    }
+    process.exit(failed > 0 || missing > 0 ? 1 : 0);
+  }
+
+  // ── String mode ──
+  if (strInput !== null) {
+    const digest = hashString(strInput, algo);
+    if (asJson) console.log(JSON.stringify({ algo, input: strInput, hash: digest }, null, 2));
+    else console.log(quiet ? digest : `${digest}  ${dim('(' + algo + ' of string)')}`);
+    process.exit(0);
+  }
+
+  // ── Compute mode ──
+  if (!positional.length) { console.error(red('\nNo files given.\n')); process.exit(1); }
+
+  const lines = [];
+  const jsonOut = [];
+  let hadError = false;
+
+  for (const p of positional) {
+    const filePath = path.resolve(p);
+    if (!fs.existsSync(filePath)) { console.error(red(`hashsum: ${p}: no such file`)); hadError = true; continue; }
+    if (fs.statSync(filePath).isDirectory()) { console.error(yellow(`hashsum: ${p}: is a directory (skipped)`)); continue; }
+    const digest = await hashFile(filePath, algo);
+    lines.push(`${digest}  ${p}`);
+    jsonOut.push({ file: p, algo, hash: digest });
+    if (!save && !asJson) {
+      console.log(quiet ? digest : `${cyan(digest)}  ${p}`);
+    }
+  }
+
+  if (asJson) { console.log(JSON.stringify(jsonOut, null, 2)); process.exit(hadError ? 1 : 0); }
+
+  if (save) {
+    const outName = `${algo}sums.txt`;
+    fs.writeFileSync(outName, lines.join('\n') + '\n');
+    console.log(`${green('✓')} Wrote ${lines.length} checksum(s) to ${cyan(outName)}`);
+  }
+
+  process.exit(hadError ? 1 : 0);
+})();

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@lowdep/hashsum",
+  "version": "1.0.0",
+  "description": "Compute and verify file checksums (md5/sha1/sha256/sha512) with a consistent cross-platform interface — zero dependencies",
+  "bin": {
+    "hashsum": "bin/hashsum.js"
+  },
+  "keywords": [
+    "checksum",
+    "hash",
+    "sha256",
+    "md5",
+    "sha512",
+    "verify",
+    "integrity",
+    "cli",
+    "cross-platform",
+    "zero-dependencies",
+    "file hash",
+    "sha256sum windows",
+    "verify checksum",
+    "integrity check",
+    "zero dependencies"
+  ],
+  "author": "Rushabh Shah",
+  "license": "MIT",
+  "engines": {
+    "node": ">=14"
+  },
+  "files": [
+    "bin/"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Rushabh5000/hashsum.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Rushabh5000/hashsum/issues"
+  },
+  "homepage": "https://github.com/Rushabh5000/hashsum#readme",
+  "publishConfig": {
+    "access": "public"
+  }
+}