@gutenye/script.js 2.3.0 → 2.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gutenye/script.js",
-  "version": "2.3.0",
+  "version": "2.5.0",
   "description": "Write shell scripts in JavaScript",
   "keywords": [
     "shell",
@@ -26,7 +26,6 @@
   ],
   "bin": {
     "script.js": "src/script.ts",
-    "a": "src/ake.ts",
     "ake": "src/ake.ts",
     "akectl": "src/akectl.ts"
   },
@@ -39,6 +38,7 @@
     "access": "public"
   },
   "dependencies": {
+    "@gutenye/script.js": "^2.3.0",
     "yaml": "^2.6.0"
   },
   "peerDependencies": {

package/src/ake/README.md

@@ -45,7 +45,80 @@ ake <Tab> # uses ake file's completion
 Create `~/bin.src/ake/template`
 
 ```sh
-akectl init local  # create a ake file from template in currenct directory
-akectl init remote  # create in ~/bin.src/ake/<dir>, doesn't touch original project files
-akectl edit # Opens a editor to edit the ake file
+akectl init local         # create an ake file from template in current directory
+akectl init local foo     # create an akefoo file
+akectl init remote        # create in ~/bin.src/ake/<dir>, doesn't touch original project files
+akectl init remote foo    # create akefoo in remote location
+akectl edit               # opens an editor to edit the ake file
+akectl edit foo           # opens an editor to edit the akefoo file
+```
+
+## Organize Multiple Files
+
+For larger projects, split commands into separate files and import them.
+
+```
+project/
+├── ake              # entry point (executable)
+├── src/
+│   ├── index.ts     # imports all command files
+│   ├── cmd1.ts
+│   └── cmd2.ts
+```
+
+`src/cmd1.ts`
+
+```ts
+import { app } from "@gutenye/script.js";
+
+app.cmd("greetings").add(() => {
+  $`echo greetings`;
+});
+```
+
+`src/index.ts`
+
+```ts
+import "./cmd1";
+import "./cmd2";
+```
+
+`ake`
+
+```ts
+#!/usr/bin/env bun
+
+import { app } from "@gutenye/script.js";
+import "./src";
+
+await app.run();
+```
+
+## Multiple Ake Files
+
+Any file named `ake<suffix>` or `ake<suffix>.ts` is supported.
+
+1. Create a variant ake file
+
+```sh
+akectl init local foo   # creates ./akefoo
+```
+
+2. Create a wrapper script so you can invoke it by name
+
+```sh
+akectl install-bin ~/bin/ake foo
+```
+
+3. Enable shell completion in `ake.fish`
+
+```fish
+_setup_ake_complete ake foo
+```
+
+4. Run it
+
+```sh
+akefoo greetings
+akefoo <Tab>   # with autocompletion
 ```

package/src/ake/ake.ts

@@ -1,6 +1,8 @@
 #!/usr/bin/env bun
 
-import { exitWithError, findAkeFiles } from './shared'
+import { exitWithError, findAkeFiles, getSuffix } from './shared'
+
+const suffix = process.env.SUFFIX ?? getSuffix()
 
 async function main() {
   const akeFile = await findAkeFile()
@@ -8,7 +10,7 @@ async function main() {
 }
 
 async function findAkeFile() {
-  const akeFiles = await findAkeFiles()
+  const akeFiles = await findAkeFiles(suffix)
 
   if (akeFiles.length >= 2) {
     exitWithError(
@@ -20,9 +22,10 @@ async function findAkeFile() {
   const akeFile = akeFiles[0]
 
   if (!akeFile) {
+    const name = `ake${suffix}`
     exitWithError(
-      'ake file not found',
-      'Use below commands to create one:\nakectl init local\nakectl init remote',
+      `${name} file not found`,
+      `Use below commands to create one:\nakectl init local${suffix ? ` ${suffix}` : ''}\nakectl init remote${suffix ? ` ${suffix}` : ''}`,
     )
   }
 

package/src/ake/akectl.ts

@@ -3,12 +3,12 @@
 import { castArray } from 'lodash-es'
 import fs from '../utils/fs'
 import {
-  AKE_FILENAMES,
-  STORAGE_DIR,
-  TEMPLATE_NAME,
   exitWithError,
   findAkeFiles,
+  getAkeFilenames,
   getRemoteDir,
+  STORAGE_DIR,
+  TEMPLATE_NAME,
 } from './shared'
 
 const NAME = 'akectl'
@@ -19,16 +19,19 @@ app.meta(NAME)
 app
   .cmd('init', 'Create ake file')
   .add('<place>', 'Place', ['local', 'remote'])
-  .add(async (place: string) => {
-    const akeFiles = await findAkeFiles()
+  .add('[suffix]', 'Ake file suffix (e.g. "foo" for akefoo)')
+  .add(async (place: string, suffix: string) => {
+    suffix = suffix ?? ''
+    const akeFiles = await findAkeFiles(suffix)
     if (akeFiles.length > 0) {
       exitWithError('Already have an ake file, cannot create a new one')
     }
-    let target = AKE_FILENAMES[0]
+    const filenames = getAkeFilenames(suffix)
+    let target = filenames[0]
     if (place === 'remote') {
       const remoteDir = getRemoteDir()
       await fs.mkdirp(remoteDir)
-      target = `${remoteDir}/${AKE_FILENAMES[0]}`
+      target = `${remoteDir}/${filenames[0]}`
     }
     const templateFile = `${STORAGE_DIR}/${TEMPLATE_NAME}`
     if (await fs.pathExists(templateFile)) {
@@ -40,14 +43,35 @@ app
     await openEditor(target)
   })
 
-app.cmd('edit', 'Edit ake file').add(async () => {
-  const akeFiles = await findAkeFiles()
-  const akeFile = akeFiles[0]
-  if (!akeFile) {
-    exitWithError('No ake file found')
-  }
-  await openEditor(akeFile)
-})
+app
+  .cmd('install-bin', 'Create a wrapper script for ake with a suffix')
+  .add('<prefix>', 'Path prefix (e.g. ~/bin/ake, ~/bin/a)')
+  .add('<suffix>', 'Suffix to append (e.g. "foo" → ~/bin/akefoo)')
+  .add(async (prefix: string, suffix: string) => {
+    const target = `${prefix}${suffix}`
+    const content = `
+#!/usr/bin/env bash
+
+SUFFIX=${suffix} exec ${prefix} "$@"
+`.trim()
+    await fs.writeFile(target, content)
+    await fs.chmod(target, 0o755)
+    console.log(`created ${target}`)
+  })
+
+app
+  .cmd('edit', 'Edit ake file')
+  .add('[suffix]', 'Ake file suffix (e.g. "foo" for akefoo)')
+  .add(async (suffix: string) => {
+    suffix = suffix ?? ''
+    const akeFiles = await findAkeFiles(suffix)
+    const akeFile = akeFiles[0]
+    if (!akeFile) {
+      const name = `ake${suffix}`
+      exitWithError(`${name} file not found`)
+    }
+    await openEditor(akeFile)
+  })
 
 async function openEditor(inputPaths: string | string[]) {
   const paths = castArray(inputPaths)

package/src/ake/completions/ake.fish

@@ -1,8 +1,17 @@
-complete --erase a
-complete --command a --no-files --arguments '(_ake_complete)'
+function _setup_ake_complete
+	set cmd $argv[1]
+	set suffix $argv[2]
+	complete --erase $cmd$suffix
+	complete --command $cmd$suffix --no-files --arguments "(_ake_complete $suffix)"
+end
 
 function _ake_complete
-	set unique_name (string replace --all '/' '_' (realpath $PWD))
-	set name "ake.$unique_name"
+	set suffix $argv[1]
+	set unique_name (string replace --all '/' '_' $PWD)
+	set name "ake$suffix.$unique_name"
 	_carapace_completer $name
 end
+
+_setup_ake_complete ake
+# _setup_ake_complete ake <suffix>
+

package/src/ake/shared.ts

@@ -1,22 +1,38 @@
-import nodeFs from 'node:fs'
+import fsSync from 'node:fs'
+import path from 'node:path'
 import os from 'node:os'
 import fs from '../utils/fs'
 
 const HOME = os.homedir()
 const CWD = process.cwd()
 
-export const AKE_FILENAMES = ['ake', 'ake.ts']
 export const STORAGE_DIR = `${HOME}/bin.src/ake`
 export const TEMPLATE_NAME = 'template'
 
-export async function findAkeFiles(): Promise<string[]> {
+export function getAkeFilenames(suffix = ''): string[] {
+  const name = `ake${suffix}`
+  return [name, `${name}.ts`]
+}
+
+export function getAkeSuffix(name: string): string | null {
+  const base = name.replace(/\.ts$/, '')
+  if (!base.startsWith('ake') || base === 'akectl') return null
+  return base.slice(3)
+}
+
+export function getSuffix(): string {
+  return getAkeSuffix(path.basename(process.argv[1])) ?? ''
+}
+
+export async function findAkeFiles(suffix = ''): Promise<string[]> {
+  const filenames = getAkeFilenames(suffix)
   const localDir = CWD
   const remoteDir = getRemoteDir()
   const dirsToCheck = [localDir, remoteDir]
 
   const akeFiles = await Promise.all(
     dirsToCheck.flatMap((dir) =>
-      AKE_FILENAMES.map(async (name) => {
+      filenames.map(async (name) => {
         const akeFile = `${dir}/${name}`
         return (await fs.pathExists(akeFile)) ? akeFile : null
       }),
@@ -30,13 +46,13 @@ export function getRemoteDir() {
   return `${STORAGE_DIR}/${getUniqueName()}`
 }
 
-export function getCompletionName() {
-  return `ake.${getUniqueName()}`
+export function getCompletionName(suffix = '') {
+  return `ake${suffix}.${getUniqueName()}`
 }
 
 export function getUniqueName() {
   // use sync method to avoid using await in app.enableAkeCompletion()
-  return nodeFs.realpathSync(CWD).replaceAll('/', '_')
+  return fsSync.realpathSync(CWD).replaceAll('/', '_')
 }
 
 export function exitWithError(message: string, help?: string): never {

package/src/completion.ts

@@ -1,9 +1,9 @@
-import nodeFs from 'node:fs'
+import fsSync from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 import * as yaml from 'yaml'
 import type { Command } from './Command'
-import { AKE_FILENAMES, getCompletionName } from './ake/shared'
+import { getAkeSuffix, getCompletionName } from './ake/shared'
 
 export type CompletionValue = string[] | (() => string[])
 
@@ -125,9 +125,9 @@ export async function installCompletion(
 ) {
   try {
     if (!command.name && options.scriptPath) {
-      const basename = path.basename(options.scriptPath)
-      if (AKE_FILENAMES.includes(basename)) {
-        command.name = getCompletionName()
+      const suffix = getAkeSuffix(path.basename(options.scriptPath))
+      if (suffix !== null) {
+        command.name = getCompletionName(suffix)
       }
     }
 
@@ -139,13 +139,13 @@ export async function installCompletion(
 
     let existing: string | undefined
     try {
-      existing = nodeFs.readFileSync(filePath, 'utf8')
+      existing = fsSync.readFileSync(filePath, 'utf8')
     } catch {}
 
     if (existing === result.text) return
 
-    nodeFs.mkdirSync(specsDir, { recursive: true })
-    nodeFs.writeFileSync(filePath, result.text)
+    fsSync.mkdirSync(specsDir, { recursive: true })
+    fsSync.writeFileSync(filePath, result.text)
   } catch {
     // completion is supplementary — silently ignore errors
   }