@gutenye/script.js 1.1.0 → 2.0.0

package/src/ake/ake.ts

@@ -0,0 +1,40 @@
+#!/usr/bin/env bun
+
+import { exitWithError, findAkeFiles } from './shared'
+
+async function main() {
+  const akeFile = await findAkeFile()
+  runCommand(akeFile)
+}
+
+async function findAkeFile() {
+  const akeFiles = await findAkeFiles()
+
+  if (akeFiles.length >= 2) {
+    exitWithError(
+      'you have duplicated ake files, merge them first',
+      akeFiles.join('\n'),
+    )
+  }
+
+  const akeFile = akeFiles[0]
+
+  if (!akeFile) {
+    exitWithError(
+      'ake file not found',
+      'Use below commands to create one:\nakectl init local\nakectl init remote',
+    )
+  }
+
+  return akeFile
+}
+
+function runCommand(akeFile: string) {
+  const { exitCode } = Bun.spawnSync([akeFile, ...Bun.argv.slice(2)], {
+    stdio: ['inherit', 'inherit', 'inherit'],
+  })
+
+  process.exit(exitCode)
+}
+
+await main()

package/src/ake/akectl.ts

@@ -0,0 +1,60 @@
+#!/usr/bin/env script.js
+
+import { castArray } from 'lodash-es'
+import fs from '../utils/fs'
+import {
+  exitWithError,
+  findAkeFiles,
+  getRemoteDir,
+  STORAGE_DIR,
+  TEMPLATE_NAME,
+} from './shared'
+
+const NAME = 'akectl'
+const ENV = process.env
+
+app.meta(NAME)
+
+app
+  .cmd('init', 'Create ake file')
+  .a('<place>', 'Place', ['local', 'remote'])
+  .a(async (place: string) => {
+    const akeFiles = await findAkeFiles()
+    if (akeFiles.length > 0) {
+      exitWithError('Already have an ake file, cannot create a new one')
+    }
+    let target = 'ake'
+    if (place === 'remote') {
+      const remoteDir = getRemoteDir()
+      await fs.mkdirp(remoteDir)
+      target = `${remoteDir}/ake`
+    }
+    const templateFile = `${STORAGE_DIR}/${TEMPLATE_NAME}`
+    if (await fs.pathExists(templateFile)) {
+      await fs.copy(templateFile, target)
+    } else {
+      await fs.writeFile(target, '')
+      await fs.chmod(target, 0o755)
+    }
+    await openEditor(target)
+  })
+
+app.cmd('edit', 'Edit ake file').a(async () => {
+  const akeFiles = await findAkeFiles()
+  const akeFile = akeFiles[0]
+  if (!akeFile) {
+    exitWithError('No ake file found')
+  }
+  await openEditor(akeFile)
+})
+
+async function openEditor(inputPaths: string | string[]) {
+  const paths = castArray(inputPaths)
+  const editor =
+    ENV.TERM_PROGRAM === 'vscode'
+      ? ENV.CURSOR_TRACE_ID
+        ? 'cursor'
+        : 'code'
+      : ENV.EDITOR
+  return $`${editor} ${paths}`
+}

package/src/ake/completions/ake.fish

@@ -0,0 +1,8 @@
+complete --erase a
+complete --command a --no-files --arguments '(_ake_complete)'
+
+function _ake_complete
+	set unique_name (string replace --all '/' '_' (realpath $PWD))
+	set name "ake.$unique_name"
+	_carapace_completer $name
+end

package/src/ake/shared.ts

@@ -0,0 +1,45 @@
+import nodeFs from 'node:fs'
+import os from 'node:os'
+import fs from '../utils/fs'
+
+const HOME = os.homedir()
+const CWD = process.cwd()
+
+export const STORAGE_DIR = `${HOME}/bin.src/ake`
+export const TEMPLATE_NAME = 'template'
+
+export async function findAkeFiles(): Promise<string[]> {
+  const localDir = CWD
+  const remoteDir = getRemoteDir()
+  const dirsToCheck = [localDir, remoteDir]
+
+  const akeFiles = await Promise.all(
+    dirsToCheck.map(async (dir) => {
+      const akeFile = `${dir}/ake`
+      return (await fs.pathExists(akeFile)) ? akeFile : null
+    }),
+  )
+
+  return akeFiles.filter(Boolean) as string[]
+}
+
+export function getRemoteDir() {
+  return `${STORAGE_DIR}/${getUniqueName()}`
+}
+
+export function getCompletionName() {
+  return `ake.${getUniqueName()}`
+}
+
+export function getUniqueName() {
+  // use sync method to avoid using await in app.enableAkeCompletion()
+  return nodeFs.realpathSync(CWD).replaceAll('/', '_')
+}
+
+export function exitWithError(message: string, help?: string): never {
+  console.error(`Error: ${message}`)
+  if (help) {
+    console.log(`\n${help}`)
+  }
+  process.exit(1)
+}

package/src/completion.ts

@@ -0,0 +1,152 @@
+import nodeFs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import * as yaml from 'yaml'
+import { getCompletionName } from './ake/shared'
+import type { Command } from './Command'
+
+export type CompletionValue = string[] | (() => string[])
+
+export type CarapaceSpec = {
+  name: string
+  aliases?: string[]
+  description?: string
+  flags?: Record<string, string>
+  completion?: CarapaceCompletion
+  commands?: CarapaceSpec[]
+}
+
+export type CarapaceCompletion = {
+  positional?: string[][]
+  positionalany?: string[]
+  flag?: Record<string, string[]>
+}
+
+function resolveCompletion(completion: CompletionValue): string[] {
+  if (typeof completion === 'function') {
+    try {
+      return completion()
+    } catch {
+      return []
+    }
+  }
+  return completion
+}
+
+export function buildSpec(command: Command): CarapaceSpec {
+  const spec: CarapaceSpec = { name: command.name as string }
+
+  if (command.description) {
+    spec.description = command.description
+  }
+  if (command.aliases.length > 0) {
+    spec.aliases = command.aliases
+  }
+
+  const completion: CarapaceCompletion = {}
+
+  for (const arg of command.arguments) {
+    const values = resolveCompletion(arg.completion)
+    if (arg.variadic) {
+      if (values.length > 0) {
+        completion.positionalany = values
+      }
+    } else {
+      completion.positional = completion.positional || []
+      completion.positional.push(values)
+    }
+  }
+
+  for (const opt of command.options) {
+    spec.flags = spec.flags || {}
+    let flag = [opt.short, opt.long].filter(Boolean).join(', ')
+    if (opt.required) flag += '='
+    else if (opt.optional) flag += '=?'
+    spec.flags[flag] = opt.description
+
+    const values = resolveCompletion(opt.completion)
+    if (values.length > 0) {
+      completion.flag = completion.flag || {}
+      const key = opt.long?.replace(/^--/, '') || opt.attributeName
+      completion.flag[key] = values
+    }
+  }
+
+  if (Object.keys(completion).length > 0) {
+    spec.completion = completion
+  }
+
+  for (const sub of command.commands) {
+    spec.commands = spec.commands || []
+    spec.commands.push(buildSpec(sub))
+  }
+
+  return spec
+}
+
+export function buildSpecText(
+  command: Command,
+): { spec: CarapaceSpec; text: string } | undefined {
+  if (!command.name) return undefined
+
+  const spec = buildSpec(command)
+  if (!(spec.commands || spec.flags || spec.completion)) return undefined
+
+  const text = yaml.stringify(spec)
+  return { spec, text }
+}
+
+function getCarapaceSpecsDir(): string {
+  const homeDir = os.homedir()
+  switch (os.platform()) {
+    case 'darwin':
+      return path.join(homeDir, 'Library/Application Support/carapace/specs')
+    case 'win32': {
+      const localAppData =
+        process.env.LOCALAPPDATA || path.join(homeDir, 'AppData/Local')
+      return path.join(localAppData, 'carapace/specs')
+    }
+    default: {
+      const configHome =
+        process.env.XDG_CONFIG_HOME || path.join(homeDir, '.config')
+      return path.join(configHome, 'carapace/specs')
+    }
+  }
+}
+
+type InstallOptions = {
+  scriptPath?: string
+  specsDir?: string
+}
+
+export async function installCompletion(
+  command: Command,
+  options: InstallOptions = {},
+) {
+  try {
+    if (!command.name && options.scriptPath) {
+      const basename = path.basename(options.scriptPath)
+      if (basename === 'ake') {
+        command.name = getCompletionName()
+      }
+    }
+
+    const result = buildSpecText(command)
+    if (!result) return
+
+    const specsDir = options.specsDir || getCarapaceSpecsDir()
+    const filePath = path.join(specsDir, `${result.spec.name}.yaml`)
+
+    let existing: string | undefined
+    try {
+      existing = nodeFs.readFileSync(filePath, 'utf8')
+    } catch {}
+
+    if (existing === result.text) return
+
+    nodeFs.mkdirSync(specsDir, { recursive: true })
+    nodeFs.writeFileSync(filePath, result.text)
+  } catch {
+    // completion is supplementary — silently ignore errors
+  }
+}

package/src/globals.d.ts

@@ -0,0 +1,7 @@
+import type { Command } from './Command'
+import type { $ as Shell } from './spawn'
+
+declare global {
+  var app: Command
+  var $: typeof Shell
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export { app, Command } from './Command'
+export { $ } from './spawn'

package/src/parseArgv.ts

@@ -0,0 +1,88 @@
+import type { Argument } from './Argument'
+import type { Option } from './Option'
+
+export function parseArgv(
+  argv: string[],
+  registeredArgs: Argument[],
+  registeredOptions: Option[],
+): { positionals: any[]; options: Record<string, any> } {
+  const options: Record<string, any> = {}
+  const rawPositionals: string[] = []
+
+  for (const opt of registeredOptions) {
+    if (opt.negate) {
+      options[opt.attributeName] = true
+    } else if (opt.defaultValue !== undefined) {
+      options[opt.attributeName] = opt.defaultValue
+    }
+  }
+
+  let i = 0
+  let optionsParsing = true
+
+  while (i < argv.length) {
+    const token = argv[i]
+
+    if (token === '--') {
+      optionsParsing = false
+      i++
+      continue
+    }
+
+    if (optionsParsing && token.startsWith('-') && token.length > 1) {
+      let flag = token
+      let inlineValue: string | undefined
+      const eqIndex = token.indexOf('=')
+      if (eqIndex !== -1) {
+        flag = token.slice(0, eqIndex)
+        inlineValue = token.slice(eqIndex + 1)
+      }
+
+      const opt = findOption(flag, registeredOptions)
+      if (opt) {
+        if (opt.negate) {
+          options[opt.attributeName] = false
+        } else if (opt.required) {
+          const value = inlineValue ?? argv[++i]
+          options[opt.attributeName] = value
+        } else if (opt.optional) {
+          if (inlineValue !== undefined) {
+            options[opt.attributeName] = inlineValue
+          } else {
+            const next = argv[i + 1]
+            if (next !== undefined && !next.startsWith('-')) {
+              options[opt.attributeName] = next
+              i++
+            } else {
+              options[opt.attributeName] = true
+            }
+          }
+        } else {
+          options[opt.attributeName] = true
+        }
+      }
+    } else {
+      rawPositionals.push(token)
+    }
+
+    i++
+  }
+
+  const positionals: any[] = []
+  let posIdx = 0
+  for (const arg of registeredArgs) {
+    if (arg.variadic) {
+      positionals.push(rawPositionals.slice(posIdx))
+      posIdx = rawPositionals.length
+    } else {
+      positionals.push(rawPositionals[posIdx] ?? arg.defaultValue)
+      posIdx++
+    }
+  }
+
+  return { positionals, options }
+}
+
+function findOption(flag: string, options: Option[]): Option | undefined {
+  return options.find((o) => o.short === flag || o.long === flag)
+}

package/src/script.ts

@@ -1,55 +1,17 @@
-#!/usr/bin/env bun
+#!/usr/bin/env bun --env-file ''
 
-import 'zx/globals'
+import path from 'node:path'
+import { app } from './Command'
+import { $ } from './spawn'
 
-// Variables
-globalThis.HOME = os.homedir()
-globalThis.CWD = process.cwd()
-globalThis.ENV = process.env
+;(globalThis as any).$ = $
+;(globalThis as any).app = app
 
-// App
-import { app, start } from './app'
-globalThis.app = app
+const scriptPath = Bun.argv[2]
+if (!scriptPath) {
+  console.error('Usage: script.js <script>')
+  process.exit(1)
+}
 
-// 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
-
-// Filesystem
-import { fs, path, cp, ls, mkdir, mv, rm } from './fileSystem'
-globalThis.fs = fs
-globalThis.path = path
-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
-
-import * as yaml from './yaml'
-globalThis.yaml = yaml
-
-start()
+await import(path.resolve(scriptPath))
+await app.runViaScriptJs()

package/src/spawn.ts

@@ -1,23 +1,181 @@
-import * as zx from 'zx'
+const defaults: {
+  cwd: string | undefined
+  env: Record<string, string> | undefined
+} = {
+  cwd: undefined,
+  env: undefined,
+}
+
+export class ShellError extends Error {
+  exitCode: number
+  stdout: string
+  stderr: string
+
+  constructor(command: string, result: ReturnType<typeof Bun.spawnSync>) {
+    super(`Command failed with exit code ${result.exitCode}: ${command}`)
+    this.exitCode = result.exitCode
+    this.stdout = (result.stdout ?? '').toString()
+    this.stderr = (result.stderr ?? '').toString()
+  }
+}
+
+class ShellCommand {
+  #command: string
+  #result: ReturnType<typeof Bun.spawnSync> | undefined
+  #cwd: string | undefined
+  #env: Record<string, string> | undefined
+
+  constructor(command: string) {
+    this.#command = command
+  }
+
+  #pipeExec() {
+    if (!this.#result) {
+      const opts: Parameters<typeof Bun.spawnSync>[1] = {
+        stdin: 'inherit',
+        stdout: 'pipe',
+        stderr: 'inherit',
+      }
+      const cwd = this.#cwd ?? defaults.cwd
+      const env = this.#env ?? defaults.env
+      if (cwd !== undefined) opts.cwd = cwd
+      if (env !== undefined) opts.env = env
+      this.#result = Bun.spawnSync(['sh', '-c', this.#command], opts)
+    }
+    return this.#result
+  }
+
+  inheritExec() {
+    const opts: Parameters<typeof Bun.spawnSync>[1] = {
+      stdio: ['inherit', 'inherit', 'inherit'],
+    }
+    const cwd = this.#cwd ?? defaults.cwd
+    const env = this.#env ?? defaults.env
+    if (cwd !== undefined) opts.cwd = cwd
+    if (env !== undefined) opts.env = env
+    Bun.spawnSync(['sh', '-c', this.#command], opts)
+  }
+
+  cwd(path: string) {
+    this.#cwd = path
+    return this
+  }
+
+  env(vars: Record<string, string>) {
+    this.#env = vars
+    return this
+  }
+
+  get exitCode() {
+    return this.#pipeExec().exitCode
+  }
+
+  text() {
+    const result = this.#pipeExec()
+    if (result.exitCode !== 0) {
+      throw new ShellError(this.#command, result)
+    }
+    return (result.stdout ?? '').toString().trimEnd()
+  }
+
+  json() {
+    return JSON.parse(this.text())
+  }
+
+  lines() {
+    const lines = this.text().split('\n')
+    // fix '' issue
+    if (lines.length === 1 && lines[0] === '') {
+      return []
+    } else {
+      // fix '  a\n  b\n' issue, space at start
+      return lines.map((v) => v.trim())
+    }
+  }
 
-// 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' })
+  // biome-ignore lint/suspicious/noThenProperty: thenable for await $`cmd`
+  then(resolve?: (value: undefined) => void) {
+    this.inheritExec()
+    resolve?.(undefined)
+  }
 
-// Returns text
-export function $t(...args) {
-  const result = zx.$.sync(...args).text()
-  return result.trim()
+  toString() {
+    return this.text()
+  }
 }
 
-// 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())
+const CAPTURED_PROPS = [
+  'text',
+  'json',
+  'lines',
+  'exitCode',
+  'cwd',
+  'env',
+  'then',
+]
+const CHAINABLE_PROPS = ['cwd', 'env']
+
+function $tag(strings: TemplateStringsArray, ...values: any[]): ShellCommand {
+  const command = buildCommand(strings, values)
+  const output = new ShellCommand(command)
+
+  let captured = false
+  const proxy = new Proxy(output, {
+    get(target, prop, receiver) {
+      if (CAPTURED_PROPS.includes(prop as string)) {
+        captured = true
+      }
+      const value = Reflect.get(target, prop, target)
+      if (typeof value === 'function') {
+        const bound = value.bind(target)
+        if (CHAINABLE_PROPS.includes(prop as string)) {
+          return (...args: any[]) => {
+            bound(...args)
+            return receiver
+          }
+        }
+        return bound
+      }
+      return value
+    },
+  })
+
+  queueMicrotask(() => {
+    if (!captured) {
+      output.inheritExec()
+    }
+  })
+
+  return proxy
+}
+
+$tag.cwd = (path: string) => {
+  defaults.cwd = path
+}
+$tag.env = (vars: Record<string, string>) => {
+  defaults.env = vars
+}
+
+export { $tag as $ }
+
+function buildCommand(strings: TemplateStringsArray, values: any[]) {
+  let result = ''
+  for (let i = 0; i < strings.length; i++) {
+    result += strings[i]
+    if (i < values.length) {
+      const value = values[i]
+      if (Array.isArray(value)) {
+        result += value.map(escapeArg).join(' ')
+      } else {
+        result += escapeArg(String(value))
+      }
+    }
   }
+  return result
+}
+
+function escapeArg(arg: string): string {
+  if (arg === '') return "''"
+  if (/^[a-zA-Z0-9._\-/=:@]+$/.test(arg)) return arg
+  return `'${arg.replace(/'/g, "'\\''")}'`
 }

package/src/test.ts

@@ -0,0 +1,25 @@
+#!/usr/bin/env bun
+
+import { app } from './Command'
+import { $ } from './spawn'
+
+app
+  .cmd('cmd1 | c1', 'Command 1')
+  .a('<platform>', 'Platform', [
+    'ios',
+    'android',
+    'windows',
+    'macos',
+    'linux',
+    'unknown',
+  ])
+  .a('<name>', 'Name')
+  .a('-l | --long')
+  .a(async (platform: string, options: any, ctx: any) => {
+    console.log(platform, options, ctx)
+    const name = 'Mike Smith'
+    const args = ['arg 1', 'arg 2']
+    $`echo ${name} ${args}`
+  })
+
+await app.run()