@gutenye/script.js 1.0.0

package/README.md

@@ -0,0 +1,35 @@
+# 🌟 Script.js 🌟
+
+[![Stars](https://img.shields.io/github/stars/gutenye/script.js?style=social)](https://github.com/gutenye/script.js) [![NPM Version](https://img.shields.io/npm/v/@gutenye/script.js)](https://www.npmjs.com/package/@gutenye/script.js) [![License](https://img.shields.io/github/license/gutenye/script.js?color=blue)](https://github.com/gutenye/script.js/blob/main/LICENSE) [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-blue)](https://github.com/gutenye/script.js#-contribute)
+
+Write shell scripts in JavaScript
+
+**Show your ❤️ and support by starring this project and following the author, [Guten Ye](https://github.com/gutenye)!**
+
+## 🌟 Features
+
+- **Javascript**: ..
+- **Autocomplete**: .. 
+- **Fast**: ..
+
+## 📖 Documentation
+
+- [Getting Started](./docs/Getting%20Started.md)
+- [Completion](./docs/Completion.md)
+
+## 🤝 Contribute
+
+We welcome contributions from the community! Whether it’s reporting bugs, suggesting features, or submitting pull requests, your help is appreciated.
+
+1. Fork the Repository
+2. Open a Pull Request on Github
+
+---
+
+Thank you for using Script.js! 🔐 ✨ If you found it helpful, please ⭐️ star the project ️️⭐ on GitHub. If you have any questions or encounter issues, please refer to the documentation or report an issue on GitHub.
+
+**Thanks to all the people who contribute:**
+
+[![](https://contrib.rocks/image?repo=gutenye/script.js)](https://github.com/gutenye/script.js/graphs/contributors)
+
+[⬆ Back to top ⬆](#readme)

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@gutenye/script.js",
+  "version": "1.0.0",
+  "description": "Write shell scripts in JavaScript",
+  "keywords": [
+    "shell",
+    "script",
+    "bash",
+    "bin",
+    "binary",
+    "child",
+    "process",
+    "exec",
+    "execute",
+    "invoke",
+    "call",
+    "spawn",
+    "zx",
+    "bunshell"
+  ],
+  "license": "MIT",
+  "repository": "github:gutenye/script.js",
+  "type": "module",
+  "files": [
+    "src",
+    "tsconfig.json",
+    "build",
+    "!**/__tests__"
+  ],
+  "bin": {
+    "gutenye-script.js": "src/script.ts"
+  },
+  "scripts": {
+    "test": "bun test",
+    "lint": "biome check --fix",
+    "lint:ci": "biome ci --reporter=github",
+    "build": "rm -rf build; tsc --project tsconfig.build.json; tsc-alias --project tsconfig.build.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@gutenye/commander-completion-carapace": "^1.0.3",
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "csv-parse": "^5.5.6",
+    "lodash-es": "^4.17.21",
+    "table": "^6.8.2",
+    "tiny-invariant": "^1.3.3",
+    "yaml": "^2.6.0",
+    "zx": "^8.2.1"
+  },
+  "peerDependencies": {
+    "typescript": "^5.7.2"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "1.9.4",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@types/bun": "latest",
+    "@types/lodash-es": "^4.17.12",
+    "conventional-changelog-conventionalcommits": "^8.0.0",
+    "tsc-alias": "^1.8.10"
+  }
+}

package/src/app.ts

@@ -0,0 +1,25 @@
+import { Argument, Option, program } from './command'
+
+const [bunPath, scriptJsPath, scriptPath, ...args] = process.argv
+
+export const app = program
+
+app.Argument = Argument
+app.Option = Option
+
+export async function start() {
+  if (!scriptPath) {
+    echo('Error: missing script path, usage: gutenye-script.js <script>')
+    process.exit(1)
+  }
+
+  await import(scriptPath)
+
+  const promise = program.installCompletion()
+  if (args.length === 0) {
+    // wait for file write operation completed before app print hellp and exit in parse()
+    await promise
+  }
+
+  program.parse(args, { from: 'user' })
+}

package/src/command.ts

@@ -0,0 +1,51 @@
+import { Command as BaseCommand } from '@gutenye/commander-completion-carapace'
+
+export * from '@gutenye/commander-completion-carapace'
+
+export class Command extends BaseCommand {
+  createCommand(name) {
+    return new Command(name)
+  }
+
+  async invoke(text, ...args) {
+    if (args.length === 0) {
+      const args = text.split(/ +/)
+      return program.parseAsync(args, { from: 'user' })
+    } else {
+      return program._findCommand(text)._actionHandler(...args)
+    }
+  }
+
+  actionLinux(fn) {
+    this._actionLinux = fn
+    this._actionOS()
+    return this
+  }
+
+  actionMac(fn) {
+    this._actionMac = fn
+    this._actionOS()
+    return this
+  }
+
+  actionWin(fn) {
+    this._actionWin = fn
+    this._actionOS()
+    return this
+  }
+
+  _actionOS(fn) {
+    this.action((...args) => {
+      switch (process.platform) {
+        case 'linux':
+          return this._actionLinux?.(...args)
+        case 'darwin':
+          return this._actionMac?.(...args)
+        case 'win32':
+          return this._actionWin?.(...args)
+      }
+    })
+  }
+}
+
+export const program = new Command()

package/src/csv.ts

@@ -0,0 +1,12 @@
+import * as csv from 'csv-parse/sync'
+
+// csv.parse(text, { delimiter: ','*, columns: true* })
+//   columns: true -> [{column: value}]
+//   columns: false -> [[column], [value]]
+export function parse(text, options = {}) {
+  const newOptions = {
+    columns: true,
+    ...options,
+  }
+  return csv.parse(text, newOptions)
+}

package/src/exit.ts

@@ -0,0 +1,10 @@
+// exitWithError(message, [more])
+export function exitWithError(message, more) {
+  // for comletion <Tab> display error message: 1) no prefix: '\n, it uses first line 2) use console.error
+  let text = colors.red.bold(`Error: ${message}`)
+  if (more) {
+    text += `\n${more}`
+  }
+  console.error(text)
+  process.exit(1)
+}

package/src/fileSystem.ts

@@ -0,0 +1,17 @@
+import { fs } from '#/utils'
+
+export { fs }
+
+export const cp = fs.copy
+
+export const mv = fs.move
+
+export const rm = fs.remove
+
+export const mkdir = fs.mkdirp
+
+export const ls = glob
+
+export const ln = fs.ln
+
+export const lns = fs.symlink

package/src/mixins.ts

@@ -0,0 +1,19 @@
+export async function mixins(...names) {
+  const errorNames = []
+  for (const name of names) {
+    try {
+      // TODO: use env to config
+      await import(`${process.env.HOME}/bin.src/mixins/${name}`)
+    } catch (error) {
+      if (error.message.match(/Cannot find module/)) {
+        errorNames.push(name)
+      } else {
+        throw error
+      }
+    }
+  }
+  if (errorNames.length > 0) {
+    console.error(`Error: [mixins] not found: ${errorNames.join(', ')}`)
+    process.exit(1)
+  }
+}

package/src/script.ts

@@ -0,0 +1,53 @@
+#!/usr/bin/env bun
+
+import 'zx/globals'
+
+// Variables
+globalThis.HOME = os.homedir()
+globalThis.PWD = process.cwd()
+globalThis.ENV = process.env
+
+// App
+import { app, start } from './app'
+globalThis.app = app
+
+// Mixins
+import { mixins } from './mixins'
+globalThis.mixins = mixins
+
+// Spawn
+import { $, $l, $t } from './spawn'
+globalThis.$ = $
+globalThis.$t = $t
+globalThis.$l = $l
+
+// Error
+import { exitWithError } from './exit'
+globalThis.exitWithError = exitWithError
+
+globalThis.mixins = mixins
+
+// Filesystem
+import { fs, cp, ls, mkdir, mv, rm } from './fileSystem'
+globalThis.fs = fs
+globalThis.cp = cp
+globalThis.mv = mv
+globalThis.rm = rm
+globalThis.mkdir = mkdir
+globalThis.ls = ls
+
+// Lodash
+import _ from 'lodash-es'
+globalThis._ = _
+
+// UI
+import * as ui from './ui'
+globalThis.ui = ui
+import colors from 'chalk'
+globalThis.colors = colors
+
+// Csv
+import * as csv from './csv'
+globalThis.csv = csv
+
+start()

package/src/spawn.ts

@@ -0,0 +1,23 @@
+import * as zx from 'zx'
+
+// wait for release fix: handle nullable stdout/stderr https://github.com/google/zx/commits/main/
+// export const $ = zx.$.sync({ stdio: 'inherit' })
+export const $ = zx.$({ stdio: 'inherit' })
+
+// Returns text
+export function $t(...args) {
+  const result = zx.$.sync(...args).text()
+  return result.trim()
+}
+
+// Returns lines
+export function $l(...args) {
+  const lines = zx.$.sync(...args).lines()
+  // fix [''] issue
+  if (lines.length === 1 && lines[0] === '') {
+    return []
+  } else {
+    // fix '  a\n  b\n' with space issue
+    return lines.map((v) => v.trim())
+  }
+}

package/src/types/global.d.ts

@@ -0,0 +1,8 @@
+import 'zx/globals'
+import type { Command } from '@gutenye/commander-completion-carapace'
+
+declare global {
+  interface GlobalThis {
+    app: Command
+  }
+}

package/src/ui/index.ts

@@ -0,0 +1 @@
+export * from './table'

package/src/ui/table.ts

@@ -0,0 +1,35 @@
+import { getBorderCharacters, table as rawTable } from 'table'
+import invariant from 'tiny-invariant'
+
+// Display table
+// data: [{a: '1'}] | [['a'], ['1'], ..]
+export function table(data) {
+  invariant(_.isArray(data), 'data should be array')
+  let columns = []
+  let rows = []
+  if (_.isPlainObject(data[0])) {
+    columns = Object.keys(data[0])
+    rows = data.map((v) => Object.values(v))
+  } else if (_.isArray(data[0])) {
+    columns = data[0]
+    rows = data.slice(1)
+  } else {
+    throw new Error('data should be array of object or array')
+  }
+  const newData = [data[0], ...data.slice(1)]
+  const tableText = rawTable(
+    [columns.map((v) => colors.green.bold(v)), ...rows],
+    {
+      drawHorizontalLine: (lineIndex, rowCount) =>
+        [0, 1, rowCount].includes(lineIndex),
+      border: {
+        ...getBorderCharacters('norc'),
+        topLeft: '╭',
+        topRight: '╮',
+        bottomLeft: '╰',
+        bottomRight: '╯',
+      },
+    },
+  )
+  echo(tableText)
+}

package/src/utils/fs.ts

@@ -0,0 +1,226 @@
+import fs from 'node:fs/promises'
+import os from 'node:os'
+import nodePath from 'node:path'
+
+/**
+ * Check path exists
+ */
+async function pathExists(path: string) {
+  try {
+    await fs.access(cleanPath(path))
+    return true
+  } catch (error) {
+    if (isNodeError(error) && error.code === 'ENOENT') {
+      return false
+    }
+    throw error
+  }
+}
+
+/**
+ * - file not exists: returns undefined
+ */
+export async function inputFile(
+  path: ReadFileArgs[0],
+  options?: ReadFileArgs[1],
+) {
+  try {
+    return await fs.readFile(cleanPath(path), options)
+  } catch (error) {
+    if (isNodeError(error) && error.code === 'ENOENT') {
+      return
+    }
+    throw error
+  }
+}
+
+/**
+ * - Auto create missing dirs
+ */
+async function outputFile(
+  rawPath: WriteFileArgs[0],
+  data: WriteFileArgs[1],
+  options?: WriteFileArgs[2],
+) {
+  const path = cleanPath(rawPath)
+  if (typeof path === 'string') {
+    const dir = nodePath.dirname(path)
+    await fs.mkdir(dir, { recursive: true })
+  }
+  return fs.writeFile(path, data, options)
+}
+
+// TODO
+// emptyDir: readdirSync(dir).forEach(v => fs.rmSync(`${dir}/${v}`, { recursive: true })
+
+/**
+ * Walk dir
+ */
+
+async function* walk(rawDir: string): AsyncGenerator<string> {
+  const dir = cleanPath(rawDir)
+  for await (const d of await fs.opendir(dir)) {
+    const entry = nodePath.join(dir, d.name)
+    if (d.isDirectory()) yield* walk(entry)
+    else if (d.isFile()) yield entry
+  }
+}
+
+/**
+ * - uses inputFile
+ */
+async function inputJson(input: ReadFileArgs[0], options?: ReadFileArgs[1]) {
+  const text = await inputFile(cleanPath(input), options)
+  if (!text) {
+    return
+  }
+  try {
+    return JSON.parse(text)
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`[inputJson] ${error.message} from '${input}'`)
+    }
+    throw error
+  }
+}
+
+/*
+ * - uses readFile
+ */
+async function readJson(input: ReadFileArgs[0], options?: ReadFileArgs[1]) {
+  const text = await fs.readFile(cleanPath(input), options)
+  try {
+    return JSON.parse(text)
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`[readJson] ${error.message} from '${input}'`)
+    }
+    throw error
+  }
+}
+
+/**
+ * isSymlink
+ */
+async function isSymlink(input: PathLike) {
+  const stat = await lstatSafe(input)
+  return stat ? stat.isSymbolicLink() : false
+}
+
+/**
+ * isFile
+ */
+async function isFile(input: PathLike) {
+  const stat = await lstatSafe(input)
+  return stat ? stat.isFile() : false
+}
+
+/**
+ * isDir
+ */
+async function isDir(input: PathLike) {
+  const stat = await lstatSafe(input)
+  return stat ? stat.isDirectory() : false
+}
+
+/**
+ * TS check if error is a Node Error
+ */
+function isNodeError(error: unknown): error is NodeJS.ErrnoException {
+  return error instanceof Error && 'code' in error
+}
+
+// ignore ENOENT
+async function lstatSafe(input: PathLike) {
+  try {
+    return await fs.lstat(cleanPath(input))
+  } catch (error) {
+    if (isNodeError(error) && error.code === 'ENOENT') {
+      return
+    }
+    throw error
+  }
+}
+
+/**
+ * Expands a file path that starts with '~' to the absolute path of the home directory.
+ * @param {string} path - The file path to expand.
+ * @returns {string} - The expanded absolute file path.
+ */
+export function expand(path: any) {
+  if (!path || typeof path !== 'string') {
+    return path
+  }
+  const home = os.homedir()
+  if (path === '~') {
+    return home
+  }
+  if (path.startsWith('~/') || path.startsWith('~\\')) {
+    return nodePath.join(os.homedir(), path.slice(2))
+  }
+  return path
+}
+
+export function removeTrailingSlash(path: any) {
+  if (!path || typeof path !== 'string') {
+    return path
+  }
+  return path.replace(/[\\/]+$/, '')
+}
+
+export function cleanPath(path: any) {
+  return removeTrailingSlash(expand(path))
+}
+
+async function remove(path: PathLike) {
+  return fs.rm(cleanPath(path), { recursive: true, force: true })
+}
+
+async function copy(source: CpArgs[0], destination: CpArgs[1]) {
+  return fs.cp(source, destination, { recursive: true })
+}
+
+async function move(rawSrc: PathLike, rawDest: PathLike) {
+  const src = cleanPath(rawSrc)
+  const dest = cleanPath(rawDest)
+  await makeMissingDirs(dest)
+  return fs.rename(src, dest)
+}
+
+async function makeMissingDirs(rawPath: PathLike) {
+  if (typeof rawPath !== 'string') {
+    return
+  }
+  const path = cleanPath(rawPath)
+  const parent = nodePath.dirname(path)
+  return mkdirp(parent)
+}
+
+async function mkdirp(path: PathLike) {
+  return fs.mkdir(path, { recursive: true })
+}
+
+type WriteFileArgs = Parameters<typeof fs.writeFile>
+type ReadFileArgs = Parameters<typeof fs.readFile>
+type PathLike = Parameters<typeof fs.lstat>[0]
+type CpArgs = Parameters<typeof fs.cp>
+
+export default {
+  ...fs,
+  pathExists,
+  expand,
+  cleanPath,
+  inputFile,
+  outputFile,
+  isNodeError,
+  readJson,
+  inputJson,
+  walk,
+  isFile,
+  isDir,
+  isSymlink,
+  remove,
+  copy,
+  move,
+  mkdirp,
+}

package/src/utils/index.ts

@@ -0,0 +1 @@
+export { default as fs } from './fs'

package/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    // Import path alias
+    "baseUrl": ".",
+    "paths": {
+      "#/*": ["src/*"],
+      "#root/*": ["./*"]
+    },
+
+    // Enable latest features
+    "lib": ["ESNext", "DOM"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}