@gutenye/script.js 2.3.0 → 2.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gutenye/script.js",
-  "version": "2.3.0",
+  "version": "2.4.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

@@ -40,12 +40,35 @@ ake greetings   # find the ake file and runs it
 ake <Tab> # uses ake file's completion
 ```
 
+## Multiple Ake Files
+
+You can have multiple ake files in the same directory, each for different tasks. Any file named `ake<suffix>` or `ake<suffix>.ts` is supported.
+
+```sh
+# Create variant ake files
+akectl init local foo   # creates ./akefoo
+akectl init local bar   # creates ./akebar
+
+# Create symlinks so you can invoke them by name
+ln -sf $(which ake) ~/bin/akefoo
+ln -sf $(which ake) ~/bin/akebar
+
+# Run them
+akefoo greetings   # finds ./akefoo and runs it
+akebar deploy      # finds ./akebar and runs it
+```
+
+Each variant gets its own shell completion spec automatically.
+
 ## Use a template / another location
 
 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
 ```

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 = 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,11 +3,11 @@
 import { castArray } from 'lodash-es'
 import fs from '../utils/fs'
 import {
-  AKE_FILENAMES,
   STORAGE_DIR,
   TEMPLATE_NAME,
   exitWithError,
   findAkeFiles,
+  getAkeFilenames,
   getRemoteDir,
 } from './shared'
 
@@ -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,19 @@ 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('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/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
   }