sharp-converter 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 frndvrgs (github.com/frndvrgs)
+
+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,64 @@
+# sharp-converter
+
+Batch image conversion and compression CLI powered by [Sharp](https://sharp.pixelplumbing.com/).
+
+## Install
+
+```bash
+npm install -g sharp-converter
+```
+
+## Usage
+
+```bash
+sharpc                         # convert images using .sharpc.json or defaults
+sharpc -c                      # interactive configuration wizard
+sharpc -i photos/ -o dist/     # custom input/output directories
+sharpc --clean                 # clear output before converting
+```
+
+## Configuration
+
+Run `sharpc -c` to create a `.sharpc.json` in the current directory:
+
+```json
+{
+  "format": "webp",
+  "quality": 80,
+  "resize": {
+    "width": 1920,
+    "height": null,
+    "fit": "inside",
+    "withoutEnlargement": true
+  }
+}
+```
+
+Without a config file, defaults to webp at quality 80 with no resize.
+
+## Output
+
+```
+  Processing 4 images → webp (q80)
+  hero-1.png → hero-1.webp  62kb  (96% smaller)
+  hero-2.png → hero-2.webp  162kb  (92% smaller)
+  Done!
+```
+
+## Formats
+
+webp, jpg, png, avif
+
+## Fit strategies
+
+| Strategy | Behavior |
+|----------|----------|
+| `inside` | fit within dimensions, preserve aspect ratio |
+| `cover` | fill dimensions, crop excess |
+| `contain` | fit within, letterbox if needed |
+| `outside` | cover minimum dimension |
+| `fill` | exact dimensions, may distort |
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "sharp-converter",
+  "version": "0.1.0",
+  "description": "Batch image conversion and compression CLI powered by Sharp",
+  "license": "MIT",
+  "author": "frndvrgs (https://github.com/frndvrgs)",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/frndvrgs/sharp-converter.git"
+  },
+  "type": "module",
+  "bin": {
+    "sharpc": "src/cli.js"
+  },
+  "files": [
+    "src"
+  ],
+  "dependencies": {
+    "sharp": "^0.34.5"
+  }
+}

package/src/cli.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+
+import { parseArgs } from "node:util"
+import { configure } from "./configure.js"
+import { convert } from "./convert.js"
+
+const { values } = parseArgs({
+  options: {
+    config: { type: "boolean", short: "c", default: false },
+    upgrade: { type: "boolean", short: "u", default: false },
+    input: { type: "string", short: "i", default: "./input" },
+    output: { type: "string", short: "o", default: "./output" },
+    clean: { type: "boolean", default: false },
+    help: { type: "boolean", short: "h", default: false },
+  },
+  strict: true,
+})
+
+if (values.help) {
+  console.log(`
+  sharpc — batch image conversion powered by Sharp
+
+  Usage:
+    sharpc                     convert images using .sharpc.json or defaults
+    sharpc -c                  interactive configuration wizard
+    sharpc -i <dir> -o <dir>   specify input/output directories
+    sharpc --clean             clear output directory before converting
+
+  Options:
+    -c, --config    run interactive configuration
+    -i, --input     input directory (default: ./input)
+    -o, --output    output directory (default: ./output)
+    --clean         clear output directory first
+    -h, --help      show this help
+`)
+  process.exit(0)
+}
+
+if (values.config) {
+  await configure()
+} else {
+  await convert({ input: values.input, output: values.output, clean: values.clean })
+}

package/src/config.js

@@ -0,0 +1,27 @@
+import fs from "node:fs/promises"
+import path from "node:path"
+
+const CONFIG_FILE = ".sharpc.json"
+
+const DEFAULTS = {
+  format: "webp",
+  quality: 80,
+  resize: null,
+}
+
+export async function loadConfig(cwd = process.cwd()) {
+  const configPath = path.join(cwd, CONFIG_FILE)
+  try {
+    const data = await fs.readFile(configPath, "utf8")
+    return { ...DEFAULTS, ...JSON.parse(data) }
+  } catch {
+    return { ...DEFAULTS }
+  }
+}
+
+export async function saveConfig(config, cwd = process.cwd()) {
+  const configPath = path.join(cwd, CONFIG_FILE)
+  await fs.writeFile(configPath, JSON.stringify(config, null, 2) + "\n")
+}
+
+export { DEFAULTS, CONFIG_FILE }

package/src/configure.js

@@ -0,0 +1,42 @@
+import { loadConfig, saveConfig, CONFIG_FILE } from "./config.js"
+import { ask, close, confirm, heading, info, select, success } from "./prompt.js"
+
+export async function configure() {
+  const config = await loadConfig()
+
+  heading("Sharp Converter — Configuration")
+  info(`Settings will be saved to ${CONFIG_FILE}\n`)
+
+  config.format = await select("Output format", ["webp", "jpg", "png", "avif"], config.format)
+  config.quality = parseInt(await ask("Quality (1-100)", config.quality), 10)
+
+  const wantResize = await confirm("Configure resize?", config.resize != null)
+
+  if (wantResize) {
+    heading("Resize")
+
+    const width = await ask("Width (blank for auto)", config.resize?.width ?? "")
+    const height = await ask("Height (blank for auto)", config.resize?.height ?? "")
+
+    config.resize = {
+      width: width ? parseInt(width, 10) : null,
+      height: height ? parseInt(height, 10) : null,
+      fit: await select(
+        "Fit strategy",
+        ["inside", "outside", "cover", "contain", "fill"],
+        config.resize?.fit ?? "inside",
+      ),
+      withoutEnlargement: await confirm("Prevent upscaling?", config.resize?.withoutEnlargement ?? true),
+    }
+  } else {
+    config.resize = null
+  }
+
+  await saveConfig(config)
+  console.log()
+  success(`Saved to ${CONFIG_FILE}`)
+  info(JSON.stringify(config, null, 2))
+  console.log()
+
+  close()
+}

package/src/convert.js

@@ -0,0 +1,77 @@
+import sharp from "sharp"
+import fs from "node:fs/promises"
+import path from "node:path"
+import { loadConfig } from "./config.js"
+
+const IMAGE_EXTENSIONS = new Set([".jpg", ".jpeg", ".png", ".webp", ".gif", ".tiff", ".avif"])
+
+function normalizeFilename(filename) {
+  return filename
+    .toLowerCase()
+    .trim()
+    .replace(/[\s_]+/g, "-")
+    .replace(/[^a-z0-9-]/g, "")
+    .replace(/-+/g, "-")
+    .replace(/^-+|-+$/g, "")
+}
+
+function applyFormat(pipeline, format, quality) {
+  const opts = quality ? { quality } : {}
+  const methods = { webp: "webp", jpg: "jpeg", jpeg: "jpeg", png: "png", avif: "avif" }
+  const method = methods[format]
+  return method ? pipeline[method](opts) : pipeline
+}
+
+async function processImage(inputPath, outputPath, config) {
+  let pipeline = sharp(inputPath)
+
+  if (config.resize) {
+    pipeline = pipeline.resize({
+      width: config.resize.width || undefined,
+      height: config.resize.height || undefined,
+      fit: config.resize.fit || "inside",
+      withoutEnlargement: config.resize.withoutEnlargement ?? false,
+    })
+  }
+
+  pipeline = applyFormat(pipeline, config.format, config.quality)
+  await pipeline.toFile(outputPath)
+}
+
+export async function convert({ input, output, clean }) {
+  const config = await loadConfig()
+
+  await fs.mkdir(input, { recursive: true })
+  await fs.mkdir(output, { recursive: true })
+
+  if (clean) {
+    const existing = await fs.readdir(output)
+    await Promise.all(existing.map((f) => fs.unlink(path.join(output, f))))
+    console.log(`  Cleared ${output}/`)
+  }
+
+  const files = (await fs.readdir(input)).filter((f) => IMAGE_EXTENSIONS.has(path.extname(f).toLowerCase()))
+
+  if (files.length === 0) {
+    console.log("  No images found in", input)
+    return
+  }
+
+  console.log(`  Processing ${files.length} images → ${config.format} (q${config.quality})`)
+
+  for (const file of files) {
+    const inputPath = path.join(input, file)
+    const baseName = normalizeFilename(path.parse(file).name)
+    const outputPath = path.join(output, `${baseName}.${config.format}`)
+
+    const inputStat = await fs.stat(inputPath)
+    await processImage(inputPath, outputPath, config)
+    const outputStat = await fs.stat(outputPath)
+
+    const ratio = ((1 - outputStat.size / inputStat.size) * 100).toFixed(0)
+    const size = (outputStat.size / 1024).toFixed(0)
+    console.log(`  ${file} → ${baseName}.${config.format}  ${size}kb  (${ratio}% smaller)`)
+  }
+
+  console.log("  Done!")
+}

package/src/prompt.js

@@ -0,0 +1,54 @@
+import readline from "node:readline/promises"
+
+const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+
+const DIM = "\x1b[2m"
+const BOLD = "\x1b[1m"
+const GREEN = "\x1b[32m"
+const YELLOW = "\x1b[33m"
+const RESET = "\x1b[0m"
+
+export async function ask(label, fallback) {
+  const hint = fallback != null ? ` ${DIM}(${fallback})${RESET}` : ""
+  const answer = (await rl.question(`  ${label}${hint}: `)).trim()
+  return answer || (fallback != null ? String(fallback) : "")
+}
+
+export async function select(label, options, fallback) {
+  console.log(`\n  ${BOLD}${label}${RESET}`)
+  for (const [i, opt] of options.entries()) {
+    const marker = opt === fallback ? `${GREEN}>${RESET}` : " "
+    console.log(`  ${marker} ${i + 1}) ${opt}`)
+  }
+  const answer = (await rl.question(`  ${DIM}choice (1-${options.length})${RESET}: `)).trim()
+  const idx = parseInt(answer, 10) - 1
+  if (idx >= 0 && idx < options.length) return options[idx]
+  return fallback ?? options[0]
+}
+
+export async function confirm(label, fallback = true) {
+  const hint = fallback ? "Y/n" : "y/N"
+  const answer = (await rl.question(`  ${label} ${DIM}(${hint})${RESET}: `)).trim().toLowerCase()
+  if (!answer) return fallback
+  return answer === "y" || answer === "yes"
+}
+
+export function info(msg) {
+  console.log(`  ${DIM}${msg}${RESET}`)
+}
+
+export function success(msg) {
+  console.log(`  ${GREEN}${msg}${RESET}`)
+}
+
+export function warn(msg) {
+  console.log(`  ${YELLOW}${msg}${RESET}`)
+}
+
+export function heading(msg) {
+  console.log(`\n  ${BOLD}${msg}${RESET}`)
+}
+
+export function close() {
+  rl.close()
+}