From 9016f43220dcee9d93a7fc3c25d9d38ed6c0e8cd Mon Sep 17 00:00:00 2001
From: lete114 <me@imlete.cn>
Date: Tue, 9 Jun 2026 20:59:18 +0800
Subject: [PATCH] feat: add non-interactive support for init command

Add CLI options for all init prompts (author, desc, lang, mc-version, pm,
packs, no-scripts, add-bp, add-rp) to allow fully non-interactive usage.

- New options: -a/-d/-l/-v/-p/-k/--no-scripts/--add-bp/--add-rp
- parsePacks() utility converts 'bp,rp' string to PackType[]
- Each prompt checks for CLI-provided value before showing
- reinitProject also respects new options
- Unit tests for parsePacks (7) + integration tests for non-interactive (7)
---
 README.md                                     |  21 +-
 .../__tests__/init.integration.test.ts        | 159 ++++++++++
 src/commands/__tests__/init.test.ts           |  34 +++
 src/commands/init.ts                          | 275 +++++++++++-------
 src/index.ts                                  |  24 +-
 5 files changed, 412 insertions(+), 101 deletions(-)
 create mode 100644 src/commands/__tests__/init.integration.test.ts
 create mode 100644 src/commands/__tests__/init.test.ts

diff --git a/README.md b/README.md
index 7447e14..1fa29c8 100644
--- a/README.md
+++ b/README.md
@@ -26,12 +26,19 @@ Interactive prompts guide you through:
 - Template choice (when Script API is enabled)
 - Package manager (npm, pnpm, yarn)
 
-Use `--yes` to skip prompts and create with defaults (explosive-bow + BP + RP + TS):
+Use `--yes` to skip all prompts and create with defaults:
 
 ```bash
 mcbe-create init my-addon --yes
 ```
 
+Use short flags to customize non-interactively:
+
+```bash
+mcbe-create init my-addon -a "Author" -d "My addon" -l js --no-scripts -k bp -y
+mcbe-create init my-addon -v 1.20.0 -p pnpm --no-install
+```
+
 Run `init` inside an existing project to add missing packs.
 
 ### Development
@@ -70,7 +77,17 @@ mcbe-create info      # Show project information
 |-------------------|------|---------|-------------|
 | `[project-name]` | `string` | — | Project name (prompted if omitted) |
 | `-t, --template <template>` | `string` | `'default'` | Template to use (`default`, `explosive-bow`) |
-| `-y, --yes` | `boolean` | `false` | Skip prompts, use defaults |
+| `-y, --yes` | `boolean` | `false` | Skip all prompts, use defaults for unspecified fields |
+| `-a, --author <author>` | `string` | `''` | Author name |
+| `-d, --desc <desc>` | `string` | `''` | Project description |
+| `-l, --lang <lang>` | `string` | `'typescript'` | Script language (`typescript`, `javascript`) |
+| `-v, --mc-version <version>` | `string` | `'1.18.0'` | `@minecraft/server` version |
+| `-p, --pm <pm>` | `string` | auto-detected | Package manager (`npm`, `pnpm`, `yarn`) |
+| `-k, --packs <packs>` | `string` | `'bp,rp'` | Packs to include (`bp`, `rp`, comma-separated) |
+| `--no-scripts` | `boolean` | — | Disable Minecraft Script API |
+| `--no-install` | `boolean` | — | Skip dependency installation |
+| `--add-bp` | `boolean` | — | Add behavior pack to existing project |
+| `--add-rp` | `boolean` | — | Add resource pack to existing project |
 
 ### `dev`
 
diff --git a/src/commands/__tests__/init.integration.test.ts b/src/commands/__tests__/init.integration.test.ts
new file mode 100644
index 0000000..c2a57d8
--- /dev/null
+++ b/src/commands/__tests__/init.integration.test.ts
@@ -0,0 +1,159 @@
+import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import process from 'node:process'
+import { describe, expect, it } from 'vitest'
+import { initCommand } from '../init.js'
+
+function readJson(file: string) {
+  return JSON.parse(readFileSync(file, 'utf-8'))
+}
+
+function createTempDir() {
+  return mkdtempSync(join(tmpdir(), 'mcbe-test-'))
+}
+
+describe('init command integration', () => {
+  it('should create a project with default packs and scripts', async () => {
+    const tmp = createTempDir()
+    const cwd = process.cwd()
+    process.chdir(tmp)
+    try {
+      await initCommand('test-addon', { yes: true, install: false })
+
+      expect(existsSync(join(tmp, 'test-addon', 'package.json'))).toBe(true)
+      expect(existsSync(join(tmp, 'test-addon', 'tsconfig.json'))).toBe(true)
+      expect(existsSync(join(tmp, 'test-addon', 'src', 'behavior_pack', 'manifest.json'))).toBe(true)
+      expect(existsSync(join(tmp, 'test-addon', 'src', 'resource_pack', 'manifest.json'))).toBe(true)
+
+      const pkg = readJson(join(tmp, 'test-addon', 'package.json'))
+      expect(pkg.name).toBe('test-addon')
+      expect(pkg.mcbe.uuids.behaviorPack).toBeTruthy()
+      expect(pkg.mcbe.uuids.resourcePack).toBeTruthy()
+      expect(pkg.mcbe.uuids.module).toBeTruthy()
+    }
+    finally {
+      process.chdir(cwd)
+      rmSync(tmp, { recursive: true })
+    }
+  })
+
+  it('should respect --no-scripts and -k bp', async () => {
+    const tmp = createTempDir()
+    const cwd = process.cwd()
+    process.chdir(tmp)
+    try {
+      await initCommand('no-scripts-test', { yes: true, install: false, scripts: false, packs: 'bp' })
+
+      expect(existsSync(join(tmp, 'no-scripts-test', 'tsconfig.json'))).toBe(false)
+      expect(existsSync(join(tmp, 'no-scripts-test', 'src', 'behavior_pack', 'manifest.json'))).toBe(true)
+      expect(existsSync(join(tmp, 'no-scripts-test', 'src', 'resource_pack', 'manifest.json'))).toBe(false)
+
+      const pkg = readJson(join(tmp, 'no-scripts-test', 'package.json'))
+      expect(pkg.mcbe.uuids.behaviorPack).toBeTruthy()
+      expect(pkg.mcbe.uuids.module).toBeFalsy()
+      expect(pkg.mcbe.uuids.resourcePack).toBeFalsy()
+      expect(pkg.dependencies).toEqual({})
+    }
+    finally {
+      process.chdir(cwd)
+      rmSync(tmp, { recursive: true })
+    }
+  })
+
+  it('should respect -l js', async () => {
+    const tmp = createTempDir()
+    const cwd = process.cwd()
+    process.chdir(tmp)
+    try {
+      await initCommand('js-test', { yes: true, install: false, lang: 'javascript' })
+
+      expect(existsSync(join(tmp, 'js-test', 'tsconfig.json'))).toBe(false)
+      expect(existsSync(join(tmp, 'js-test', 'src', 'behavior_pack', 'scripts', 'main.js'))).toBe(true)
+    }
+    finally {
+      process.chdir(cwd)
+      rmSync(tmp, { recursive: true })
+    }
+  })
+
+  it('should respect -a and -d', async () => {
+    const tmp = createTempDir()
+    const cwd = process.cwd()
+    process.chdir(tmp)
+    try {
+      await initCommand('author-test', { yes: true, install: false, author: 'Test Author', desc: 'Test Description' })
+
+      const pkg = readJson(join(tmp, 'author-test', 'package.json'))
+      expect(pkg.author).toBe('Test Author')
+      expect(pkg.description).toBe('Test Description')
+    }
+    finally {
+      process.chdir(cwd)
+      rmSync(tmp, { recursive: true })
+    }
+  })
+
+  it('should respect -v for mc-version', async () => {
+    const tmp = createTempDir()
+    const cwd = process.cwd()
+    process.chdir(tmp)
+    try {
+      await initCommand('version-test', { yes: true, install: false, mcVersion: '1.20.0' })
+
+      const pkg = readJson(join(tmp, 'version-test', 'package.json'))
+      expect(pkg.dependencies['@minecraft/server']).toBe('1.20.0')
+    }
+    finally {
+      process.chdir(cwd)
+      rmSync(tmp, { recursive: true })
+    }
+  })
+
+  it('should respect -p pm override', async () => {
+    const tmp = createTempDir()
+    const cwd = process.cwd()
+    process.chdir(tmp)
+    try {
+      await initCommand('pm-test', { yes: true, install: false, pm: 'npm' })
+
+      const pkg = readJson(join(tmp, 'pm-test', 'package.json'))
+      expect(existsSync(join(tmp, 'pm-test', 'pnpm-lock.yaml'))).toBe(false)
+      expect(pkg.name).toBe('pm-test')
+    }
+    finally {
+      process.chdir(cwd)
+      rmSync(tmp, { recursive: true })
+    }
+  })
+
+  it('should support full non-interactive creation with all flags', async () => {
+    const tmp = createTempDir()
+    const cwd = process.cwd()
+    process.chdir(tmp)
+    try {
+      await initCommand('full-flags', {
+        yes: true,
+        install: false,
+        author: 'Dev',
+        desc: 'Full test',
+        lang: 'typescript',
+        mcVersion: '1.21.0',
+        pm: 'pnpm',
+        packs: 'bp,rp',
+        template: 'default',
+      })
+      expect(existsSync(join(tmp, 'full-flags', 'src', 'behavior_pack', 'manifest.json'))).toBe(true)
+      expect(existsSync(join(tmp, 'full-flags', 'src', 'resource_pack', 'manifest.json'))).toBe(true)
+
+      const pkg = readJson(join(tmp, 'full-flags', 'package.json'))
+      expect(pkg.author).toBe('Dev')
+      expect(pkg.description).toBe('Full test')
+      expect(pkg.dependencies['@minecraft/server']).toBe('1.21.0')
+    }
+    finally {
+      process.chdir(cwd)
+      rmSync(tmp, { recursive: true })
+    }
+  })
+})
diff --git a/src/commands/__tests__/init.test.ts b/src/commands/__tests__/init.test.ts
new file mode 100644
index 0000000..38f48d8
--- /dev/null
+++ b/src/commands/__tests__/init.test.ts
@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest'
+import { parsePacks } from '../init.js'
+
+describe('parsePacks', () => {
+  it('should default to both packs when no argument given', () => {
+    expect(parsePacks()).toEqual(['behavior_pack', 'resource_pack'])
+    expect(parsePacks(undefined)).toEqual(['behavior_pack', 'resource_pack'])
+  })
+
+  it('should parse "bp" as behavior_pack', () => {
+    expect(parsePacks('bp')).toEqual(['behavior_pack'])
+  })
+
+  it('should parse "rp" as resource_pack', () => {
+    expect(parsePacks('rp')).toEqual(['resource_pack'])
+  })
+
+  it('should parse comma-separated packs', () => {
+    expect(parsePacks('bp,rp')).toEqual(['behavior_pack', 'resource_pack'])
+  })
+
+  it('should parse full names', () => {
+    expect(parsePacks('behavior_pack,resource_pack')).toEqual(['behavior_pack', 'resource_pack'])
+    expect(parsePacks('behavior_pack')).toEqual(['behavior_pack'])
+  })
+
+  it('should trim whitespace', () => {
+    expect(parsePacks(' bp , rp ')).toEqual(['behavior_pack', 'resource_pack'])
+  })
+
+  it('should pass through unknown values', () => {
+    expect(parsePacks('bp,custom_pack')).toEqual(['behavior_pack', 'custom_pack'] as any)
+  })
+})
diff --git a/src/commands/init.ts b/src/commands/init.ts
index db0b583..71bfee7 100644
--- a/src/commands/init.ts
+++ b/src/commands/init.ts
@@ -20,6 +20,15 @@ interface InitOptions {
   template?: string
   yes?: boolean
   install?: boolean
+  author?: string
+  desc?: string
+  lang?: string
+  mcVersion?: string
+  pm?: string
+  packs?: string
+  scripts?: boolean
+  addBp?: boolean
+  addRp?: boolean
 }
 
 function detectPackageManager(): PackageManager {
@@ -64,97 +73,120 @@ function writeLang(dir: string, name: string, description: string) {
   writeFileSync(join(textsDir, 'languages.json'), JSON.stringify(['en_US'], null, 2))
 }
 
+export function parsePacks(packs?: string): PackType[] {
+  if (!packs) { return ['behavior_pack', 'resource_pack'] }
+  return packs.split(',').map((s) => {
+    const t = s.trim()
+    if (t === 'bp') { return 'behavior_pack' }
+    if (t === 'rp') { return 'resource_pack' }
+    return t as PackType
+  })
+}
+
 async function createNewProject(name: string, options: InitOptions) {
   const projectDir = join(process.cwd(), name)
 
-  let template = options.template as TemplateName | undefined
-  let author = ''
-  let description = ''
-  let packs: PackType[] = ['behavior_pack', 'resource_pack']
-  let hasScripts = true
-  let language: ScriptLanguage = 'typescript'
-  let mcVersion = '1.18.0'
-  let pm: PackageManager = detectPackageManager()
+  let packs: PackType[] = parsePacks(options.packs)
+  let hasScripts = options.scripts !== false
+  let language: ScriptLanguage = (options.lang as ScriptLanguage) || 'typescript'
+  let template: TemplateName = (options.template as TemplateName) || 'default'
+  let mcVersion = options.mcVersion || '1.18.0'
+  let pm: PackageManager = (options.pm as PackageManager) || detectPackageManager()
+  let author = options.author ?? ''
+  let description = options.desc ?? ''
+
+  const noScriptsArg = process.argv.includes('--no-scripts')
 
   if (!options.yes) {
     p.intro(pc.bold(pc.blue('Create a new Minecraft BE addon')))
 
-    packs = await p.multiselect({
-      message: 'Which packs do you need?',
-      required: true,
-      options: [
-        { value: 'behavior_pack', label: 'Behavior Pack', hint: 'Addon logic and scripts' },
-        { value: 'resource_pack', label: 'Resource Pack', hint: 'Textures, sounds, models' },
-      ],
-    }) as PackType[]
-    if (isCancel(packs)) { onCancel() }
+    if (!options.packs) {
+      packs = await p.multiselect({
+        message: 'Which packs do you need?',
+        required: true,
+        options: [
+          { value: 'behavior_pack', label: 'Behavior Pack', hint: 'Addon logic and scripts' },
+          { value: 'resource_pack', label: 'Resource Pack', hint: 'Textures, sounds, models' },
+        ],
+      }) as PackType[]
+      if (isCancel(packs)) { onCancel() }
+    }
 
     if (packs.includes('behavior_pack')) {
-      hasScripts = await p.confirm({
-        message: 'Use Minecraft Script API?',
-        initialValue: true,
-      }) as boolean
-      if (isCancel(hasScripts)) { onCancel() }
+      if (!noScriptsArg && options.scripts === undefined) {
+        hasScripts = await p.confirm({
+          message: 'Use Minecraft Script API?',
+          initialValue: true,
+        }) as boolean
+        if (isCancel(hasScripts)) { onCancel() }
+      }
 
       if (hasScripts) {
-        language = await p.select({
-          message: 'Script language:',
-          options: [
-            { value: 'typescript', label: 'TypeScript', hint: 'Requires compilation' },
-            { value: 'javascript', label: 'JavaScript', hint: 'No compilation needed' },
-          ],
-        }) as ScriptLanguage
-        if (isCancel(language)) { onCancel() }
-
-        template = await p.select({
-          message: 'Select a template:',
-          initialValue: template || 'default',
-          options: [
-            { value: 'default', label: 'Default', hint: 'Simple event listener starter' },
-            { value: 'explosive-bow', label: 'Explosive Bow', hint: 'Bow that spawns exploding crystals' },
-          ],
-        }) as TemplateName
-        if (isCancel(template)) { onCancel() }
-
-        mcVersion = await p.text({
-          message: '@minecraft/server version:',
-          placeholder: mcVersion,
-          initialValue: mcVersion,
-        }) as string
-        if (isCancel(mcVersion)) { onCancel() }
+        if (!options.lang) {
+          language = await p.select({
+            message: 'Script language:',
+            options: [
+              { value: 'typescript', label: 'TypeScript', hint: 'Requires compilation' },
+              { value: 'javascript', label: 'JavaScript', hint: 'No compilation needed' },
+            ],
+          }) as ScriptLanguage
+          if (isCancel(language)) { onCancel() }
+        }
+
+        if (!options.template) {
+          template = await p.select({
+            message: 'Select a template:',
+            initialValue: template,
+            options: [
+              { value: 'default', label: 'Default', hint: 'Simple event listener starter' },
+              { value: 'explosive-bow', label: 'Explosive Bow', hint: 'Bow that spawns exploding crystals' },
+            ],
+          }) as TemplateName
+          if (isCancel(template)) { onCancel() }
+        }
+
+        if (!options.mcVersion) {
+          mcVersion = await p.text({
+            message: '@minecraft/server version:',
+            placeholder: mcVersion,
+            initialValue: mcVersion,
+          }) as string
+          if (isCancel(mcVersion)) { onCancel() }
+        }
       }
     }
 
-    pm = await p.select({
-      message: 'Package manager:',
-      initialValue: pm,
-      options: [
-        { value: 'npm', label: 'npm' },
-        { value: 'pnpm', label: 'pnpm' },
-        { value: 'yarn', label: 'yarn' },
-      ],
-    }) as PackageManager
-    if (isCancel(pm)) { onCancel() }
-
-    author = await p.text({
-      message: 'Author:',
-      placeholder: 'Your name',
-    }) as string
-    if (isCancel(author)) { onCancel() }
+    if (!options.pm) {
+      pm = await p.select({
+        message: 'Package manager:',
+        initialValue: pm,
+        options: [
+          { value: 'npm', label: 'npm' },
+          { value: 'pnpm', label: 'pnpm' },
+          { value: 'yarn', label: 'yarn' },
+        ],
+      }) as PackageManager
+      if (isCancel(pm)) { onCancel() }
+    }
 
-    description = await p.text({
-      message: 'Description:',
-      placeholder: 'My Minecraft BE addon',
-    }) as string
-    if (isCancel(description)) { onCancel() }
+    if (!options.author) {
+      author = await p.text({
+        message: 'Author:',
+        placeholder: 'Your name',
+      }) as string
+      if (isCancel(author)) { onCancel() }
+    }
+
+    if (!options.desc) {
+      description = await p.text({
+        message: 'Description:',
+        placeholder: 'My Minecraft BE addon',
+      }) as string
+      if (isCancel(description)) { onCancel() }
+    }
 
     p.outro('Creating project...')
   }
-  else {
-    template = template || 'explosive-bow'
-  }
-
-  template = template || 'default'
 
   const newUuids = generateUUIDs()
   const mcbeConfig: McbeConfig = {
@@ -253,7 +285,7 @@ async function createNewProject(name: string, options: InitOptions) {
   console.log()
 }
 
-async function reinitProject(projectDir: string) {
+async function reinitProject(projectDir: string, options: InitOptions) {
   const config = getProjectConfig(projectDir)
   const hasBp = existsSync(join(projectDir, 'src', 'behavior_pack'))
   const hasRp = existsSync(join(projectDir, 'src', 'resource_pack'))
@@ -269,13 +301,26 @@ async function reinitProject(projectDir: string) {
 
   const additions: string[] = []
   const uuids = config.uuids
+  const noScriptsArg = process.argv.includes('--no-scripts')
 
   if (!hasBp) {
-    const addBp = await p.confirm({
-      message: 'Add Behavior Pack?',
-      initialValue: true,
-    })
-    if (isCancel(addBp)) { onCancel() }
+    let addBp: boolean
+
+    if (options.addBp !== undefined) {
+      addBp = options.addBp
+    }
+    else if (options.yes) {
+      addBp = false
+    }
+    else {
+      const confirmAddBp = await p.confirm({
+        message: 'Add Behavior Pack?',
+        initialValue: true,
+      })
+      if (isCancel(confirmAddBp)) { onCancel() }
+      addBp = confirmAddBp as boolean
+    }
+
     if (addBp) {
       additions.push('behavior_pack')
       const newUuids = generateUUIDs()
@@ -283,20 +328,42 @@ async function reinitProject(projectDir: string) {
         uuids: { behaviorPack: newUuids.behaviorPack, module: newUuids.module },
       })
 
-      const addScripts = await p.confirm({
-        message: 'Use Minecraft Script API?',
-        initialValue: true,
-      })
-      if (isCancel(addScripts)) { onCancel() }
+      let addScripts: boolean
+
+      if (options.scripts !== undefined || noScriptsArg) {
+        addScripts = options.scripts !== false
+      }
+      else if (options.yes) {
+        addScripts = true
+      }
+      else {
+        const confirmScripts = await p.confirm({
+          message: 'Use Minecraft Script API?',
+          initialValue: true,
+        })
+        if (isCancel(confirmScripts)) { onCancel() }
+        addScripts = confirmScripts as boolean
+      }
+
       if (addScripts) {
-        const lang = await p.select({
-          message: 'Script language:',
-          options: [
-            { value: 'typescript', label: 'TypeScript' },
-            { value: 'javascript', label: 'JavaScript' },
-          ],
-        }) as ScriptLanguage
-        if (isCancel(lang)) { onCancel() }
+        let lang: ScriptLanguage
+
+        if (options.lang) {
+          lang = options.lang as ScriptLanguage
+        }
+        else if (options.yes) {
+          lang = 'typescript'
+        }
+        else {
+          lang = await p.select({
+            message: 'Script language:',
+            options: [
+              { value: 'typescript', label: 'TypeScript' },
+              { value: 'javascript', label: 'JavaScript' },
+            ],
+          }) as ScriptLanguage
+          if (isCancel(lang)) { onCancel() }
+        }
 
         const bpDir = join(projectDir, 'src', 'behavior_pack')
         mkdirSync(bpDir, { recursive: true })
@@ -328,11 +395,23 @@ async function reinitProject(projectDir: string) {
   }
 
   if (!hasRp) {
-    const addRp = await p.confirm({
-      message: 'Add Resource Pack?',
-      initialValue: true,
-    })
-    if (isCancel(addRp)) { onCancel() }
+    let addRp: boolean
+
+    if (options.addRp !== undefined) {
+      addRp = options.addRp
+    }
+    else if (options.yes) {
+      addRp = false
+    }
+    else {
+      const confirmAddRp = await p.confirm({
+        message: 'Add Resource Pack?',
+        initialValue: true,
+      })
+      if (isCancel(confirmAddRp)) { onCancel() }
+      addRp = confirmAddRp as boolean
+    }
+
     if (addRp) {
       additions.push('resource_pack')
       if (!uuids.resourcePack) {
@@ -360,7 +439,7 @@ export async function initCommand(name: string | undefined, options: InitOptions
     const existingProjectDir = getProjectDir()
 
     if (existingProjectDir) {
-      await reinitProject(existingProjectDir)
+      await reinitProject(existingProjectDir, options)
       return
     }
   }
diff --git a/src/index.ts b/src/index.ts
index 923954a..62f0e83 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -19,7 +19,29 @@ program
   .option('-t, --template <template>', 'Template to use (default, explosive-bow)')
   .option('-y, --yes', 'Skip prompts, use defaults')
   .option('--no-install', 'Skip dependency installation')
-  .action(async (name: string, options: { template?: string, yes?: boolean, install?: boolean }) => {
+  .option('-a, --author <author>', 'Author name')
+  .option('-d, --desc <desc>', 'Project description')
+  .option('-l, --lang <lang>', 'Script language (typescript | javascript)')
+  .option('-v, --mc-version <version>', '@minecraft/server version')
+  .option('-p, --pm <pm>', 'Package manager (npm | pnpm | yarn)')
+  .option('-k, --packs <packs>', 'Packs to include (bp,rp)')
+  .option('--no-scripts', 'Disable Minecraft Script API')
+  .option('--add-bp', 'Add behavior pack to existing project')
+  .option('--add-rp', 'Add resource pack to existing project')
+  .action(async (name: string, options: {
+    template?: string
+    yes?: boolean
+    install?: boolean
+    author?: string
+    desc?: string
+    lang?: string
+    mcVersion?: string
+    pm?: string
+    packs?: string
+    scripts?: boolean
+    addBp?: boolean
+    addRp?: boolean
+  }) => {
     const { initCommand } = await import('./commands/init.js')
     await initCommand(name, options)
   })