redscript-mc 2.6.2 → 3.0.0

package/src/__tests__/cli-docs.test.ts

@@ -0,0 +1,77 @@
+import { spawnSync } from 'child_process'
+import * as path from 'path'
+import { buildDocsUrl, STDLIB_MODULES, docsCommand, DOCS_BASE_URL } from '../docs'
+
+const cliPath = path.resolve(__dirname, '..', 'cli.ts')
+const cliRunner = [require.resolve('ts-node/register/transpile-only')]
+
+function runCli(...args: string[]) {
+  return spawnSync(
+    process.execPath,
+    ['-r', ...cliRunner, cliPath, ...args],
+    {
+      encoding: 'utf-8',
+      env: { ...process.env, REDSCRIPT_NO_UPDATE_CHECK: '1' },
+    }
+  )
+}
+
+describe('redscript docs command', () => {
+  // 1. Basic command parsing — exits 0, prints URL
+  it('opens the stdlib index when no module is given', () => {
+    const opened: string[] = []
+    docsCommand(undefined, false, url => opened.push(url))
+    expect(opened).toHaveLength(1)
+    expect(opened[0]).toBe(`${DOCS_BASE_URL}/en/stdlib/`)
+  })
+
+  // 2. Module argument generates correct URL
+  it('builds the correct URL for a named module', () => {
+    const url = buildDocsUrl('math')
+    expect(url).toBe(`${DOCS_BASE_URL}/en/stdlib/math`)
+  })
+
+  it('opens the correct URL when a module argument is provided', () => {
+    const opened: string[] = []
+    docsCommand('random', false, url => opened.push(url))
+    expect(opened).toHaveLength(1)
+    expect(opened[0]).toBe(`${DOCS_BASE_URL}/en/stdlib/random`)
+  })
+
+  // 3. --list outputs stdlib module names (via CLI)
+  it('--list prints all available module names without opening browser', () => {
+    const result = runCli('docs', '--list')
+    expect(result.status).toBe(0)
+    // Should mention at least the known modules
+    for (const mod of ['math', 'list', 'random', 'physics', 'player']) {
+      expect(result.stdout).toContain(mod)
+    }
+    // Should NOT attempt to open a URL (no stdout URL)
+    expect(result.stdout).not.toContain('http')
+  })
+
+  // 4. STDLIB_MODULES contains expected entries
+  it('STDLIB_MODULES contains the expected stdlib modules', () => {
+    const expected = [
+      'math', 'math_hp', 'bits', 'bigint', 'calculus',
+      'list', 'sets', 'matrix', 'vec', 'quaternion',
+      'random', 'noise', 'signal', 'expr',
+      'geometry', 'physics',
+      'player', 'mobs', 'combat', 'effects',
+    ]
+    for (const mod of expected) {
+      expect(STDLIB_MODULES).toContain(mod)
+    }
+  })
+
+  // 5. Unknown module still opens a URL (with a warning to stderr)
+  it('opens a URL even for an unknown module name (with warning)', () => {
+    const opened: string[] = []
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
+    docsCommand('nonexistent_module', false, url => opened.push(url))
+    expect(opened).toHaveLength(1)
+    expect(opened[0]).toContain('nonexistent_module')
+    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('not a known stdlib module'))
+    warnSpy.mockRestore()
+  })
+})

package/src/__tests__/cli-init.test.ts

@@ -0,0 +1,91 @@
+import { compile } from '../index'
+import * as fs from 'fs'
+import * as os from 'os'
+import * as path from 'path'
+import { spawnSync } from 'child_process'
+
+describe('init CLI', () => {
+  const cliPath = path.resolve(__dirname, '..', 'cli.ts')
+  const cliRunner = [require.resolve('ts-node/register/transpile-only')]
+
+  it('creates the expected project structure', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-init-cli-'))
+    const projectDir = path.join(tempDir, 'demo-pack')
+
+    const result = spawnSync(
+      process.execPath,
+      ['-r', ...cliRunner, cliPath, 'init', projectDir],
+      {
+        encoding: 'utf-8',
+        env: { ...process.env, REDSCRIPT_NO_UPDATE_CHECK: '1' },
+      }
+    )
+
+    expect(result.status).toBe(0)
+    expect(fs.existsSync(path.join(projectDir, 'src', 'main.mcrs'))).toBe(true)
+    expect(fs.existsSync(path.join(projectDir, 'redscript.config.json'))).toBe(true)
+    expect(fs.existsSync(path.join(projectDir, '.gitignore'))).toBe(true)
+    expect(fs.existsSync(path.join(projectDir, 'README.md'))).toBe(true)
+  })
+
+  it('writes the expected redscript.config.json', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-init-cli-'))
+    const projectDir = path.join(tempDir, 'demo-pack')
+
+    const result = spawnSync(
+      process.execPath,
+      ['-r', ...cliRunner, cliPath, 'init', projectDir],
+      {
+        encoding: 'utf-8',
+        env: { ...process.env, REDSCRIPT_NO_UPDATE_CHECK: '1' },
+      }
+    )
+
+    expect(result.status).toBe(0)
+
+    const config = JSON.parse(
+      fs.readFileSync(path.join(projectDir, 'redscript.config.json'), 'utf-8')
+    )
+
+    expect(config).toEqual({
+      namespace: 'demo_pack',
+      entry: 'src/main.mcrs',
+      outDir: 'dist/',
+      mcVersion: '1.21.4',
+    })
+  })
+
+  it('scaffolds a main.mcrs template that compiles', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-init-cli-'))
+    const projectDir = path.join(tempDir, 'demo-pack')
+
+    const result = spawnSync(
+      process.execPath,
+      ['-r', ...cliRunner, cliPath, 'init', projectDir],
+      {
+        encoding: 'utf-8',
+        env: { ...process.env, REDSCRIPT_NO_UPDATE_CHECK: '1' },
+      }
+    )
+
+    expect(result.status).toBe(0)
+
+    const config = JSON.parse(
+      fs.readFileSync(path.join(projectDir, 'redscript.config.json'), 'utf-8')
+    )
+    const entryPath = path.join(projectDir, config.entry)
+    const source = fs.readFileSync(entryPath, 'utf-8')
+    const compiled = compile(source, {
+      namespace: config.namespace,
+      filePath: entryPath,
+    })
+    const loadTag = compiled.files.find(file => file.path.includes('load.json'))
+    const tickTag = compiled.files.find(file => file.path.includes('tick.json'))
+
+    expect(compiled.files.some(file => file.path === 'pack.mcmeta')).toBe(true)
+    expect(loadTag).toBeDefined()
+    expect(tickTag).toBeDefined()
+    expect(JSON.parse(loadTag!.content).values).toContain(`${config.namespace}:setup`)
+    expect(JSON.parse(tickTag!.content).values).toContain(`${config.namespace}:heartbeat`)
+  })
+})

package/src/__tests__/cli-publish.test.ts

@@ -0,0 +1,190 @@
+/**
+ * Tests for `redscript publish` command.
+ *
+ * Verifies that the generated .zip contains:
+ *  - pack.mcmeta with the correct pack_format
+ *  - All compiled .mcfunction files under data/<namespace>/function/
+ *  - Tag JSON files under data/minecraft/tags/function/
+ */
+
+import * as fs from 'fs'
+import * as os from 'os'
+import * as path from 'path'
+import { spawnSync } from 'child_process'
+import AdmZip from 'adm-zip'
+
+// We need adm-zip to inspect the zip — install as dev dependency if missing.
+// The test will skip gracefully if the zip can't be opened.
+
+const cliPath = path.resolve(__dirname, '..', 'cli.ts')
+const cliRunner = [require.resolve('ts-node/register/transpile-only')]
+
+function runCli(args: string[]): { stdout: string; stderr: string; status: number | null } {
+  const result = spawnSync(
+    process.execPath,
+    ['-r', ...cliRunner, cliPath, ...args],
+    {
+      encoding: 'utf-8',
+      env: { ...process.env, REDSCRIPT_NO_UPDATE_CHECK: '1' },
+      timeout: 30_000,
+    }
+  )
+  return {
+    stdout: result.stdout ?? '',
+    stderr: result.stderr ?? '',
+    status: result.status,
+  }
+}
+
+describe('publish CLI', () => {
+  let tempDir: string
+  let srcFile: string
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-publish-'))
+    srcFile = path.join(tempDir, 'main.mcrs')
+    fs.writeFileSync(srcFile, `
+@load
+fn setup(): void {
+  say("Loaded");
+}
+
+@tick(rate=20)
+fn heartbeat(): void {
+  say("Tick");
+}
+`)
+  })
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  })
+
+  it('exits 0 and produces a .zip file', () => {
+    const outZip = path.join(tempDir, 'my_pack.zip')
+    const result = runCli(['publish', srcFile, '--namespace', 'my_pack', '-o', outZip])
+
+    expect(result.status).toBe(0)
+    expect(fs.existsSync(outZip)).toBe(true)
+  })
+
+  it('zip contains pack.mcmeta at root', () => {
+    const outZip = path.join(tempDir, 'test.zip')
+    runCli(['publish', srcFile, '--namespace', 'test_ns', '-o', outZip])
+
+    const zip = new AdmZip(outZip)
+    const mcmeta = zip.getEntry('pack.mcmeta')
+    expect(mcmeta).not.toBeNull()
+
+    const content = JSON.parse(zip.readAsText(mcmeta!))
+    expect(content.pack).toBeDefined()
+    expect(typeof content.pack.pack_format).toBe('number')
+    expect(content.pack.pack_format).toBeGreaterThan(0)
+  })
+
+  it('pack_format is 48 for mc 1.21.4', () => {
+    const outZip = path.join(tempDir, 'mc1214.zip')
+    runCli(['publish', srcFile, '--namespace', 'ns', '--mc-version', '1.21.4', '-o', outZip])
+
+    const zip = new AdmZip(outZip)
+    const content = JSON.parse(zip.readAsText(zip.getEntry('pack.mcmeta')!))
+    expect(content.pack.pack_format).toBe(48)
+  })
+
+  it('pack_format is 45 for mc 1.21', () => {
+    const outZip = path.join(tempDir, 'mc121.zip')
+    runCli(['publish', srcFile, '--namespace', 'ns', '--mc-version', '1.21', '-o', outZip])
+
+    const zip = new AdmZip(outZip)
+    const content = JSON.parse(zip.readAsText(zip.getEntry('pack.mcmeta')!))
+    expect(content.pack.pack_format).toBe(45)
+  })
+
+  it('pack_format is 26 for mc 1.20.4', () => {
+    const outZip = path.join(tempDir, 'mc1204.zip')
+    runCli(['publish', srcFile, '--namespace', 'ns', '--mc-version', '1.20.4', '-o', outZip])
+
+    const zip = new AdmZip(outZip)
+    const content = JSON.parse(zip.readAsText(zip.getEntry('pack.mcmeta')!))
+    expect(content.pack.pack_format).toBe(26)
+  })
+
+  it('pack_format is 18 for mc 1.20.1', () => {
+    const outZip = path.join(tempDir, 'mc1201.zip')
+    runCli(['publish', srcFile, '--namespace', 'ns', '--mc-version', '1.20.1', '-o', outZip])
+
+    const zip = new AdmZip(outZip)
+    const content = JSON.parse(zip.readAsText(zip.getEntry('pack.mcmeta')!))
+    expect(content.pack.pack_format).toBe(18)
+  })
+
+  it('zip contains compiled mcfunction files', () => {
+    const outZip = path.join(tempDir, 'funcs.zip')
+    runCli(['publish', srcFile, '--namespace', 'mypkg', '-o', outZip])
+
+    const zip = new AdmZip(outZip)
+    const entries = zip.getEntries().map(e => e.entryName)
+
+    // Should contain at least one .mcfunction file under data/mypkg/function/
+    const mcfunctions = entries.filter(e => e.startsWith('data/mypkg/function/') && e.endsWith('.mcfunction'))
+    expect(mcfunctions.length).toBeGreaterThan(0)
+  })
+
+  it('zip contains tag json files for @load and @tick', () => {
+    const outZip = path.join(tempDir, 'tags.zip')
+    runCli(['publish', srcFile, '--namespace', 'tagged', '-o', outZip])
+
+    const zip = new AdmZip(outZip)
+    const entries = zip.getEntries().map(e => e.entryName)
+
+    const hasLoadTag = entries.some(e => e.includes('tags') && e.includes('load.json'))
+    const hasTickTag = entries.some(e => e.includes('tags') && e.includes('tick.json'))
+    expect(hasLoadTag).toBe(true)
+    expect(hasTickTag).toBe(true)
+  })
+
+  it('reads namespace and mcVersion from redscript.config.json', () => {
+    const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-publish-cfg-'))
+    const entrySrc = path.join(projectDir, 'main.mcrs')
+    fs.writeFileSync(entrySrc, '@load\nfn setup(): void { say("hi"); }')
+    fs.writeFileSync(path.join(projectDir, 'redscript.config.json'), JSON.stringify({
+      namespace: 'from_config',
+      entry: 'main.mcrs',
+      outDir: 'dist/',
+      mcVersion: '1.21.4',
+      description: 'Config-driven pack',
+    }))
+
+    const outZip = path.join(projectDir, 'from_config.zip')
+    const result = runCli(['publish', entrySrc, '-o', outZip])
+
+    expect(result.status).toBe(0)
+
+    const zip = new AdmZip(outZip)
+    const mcmeta = JSON.parse(zip.readAsText(zip.getEntry('pack.mcmeta')!))
+    expect(mcmeta.pack.pack_format).toBe(48)
+    expect(mcmeta.pack.description).toBe('Config-driven pack')
+
+    const entries = zip.getEntries().map((e: AdmZip.IZipEntry) => e.entryName)
+    expect(entries.some((e: string) => e.startsWith('data/from_config/function/'))).toBe(true)
+
+    fs.rmSync(projectDir, { recursive: true, force: true })
+  })
+
+  it('--description flag overrides config', () => {
+    const outZip = path.join(tempDir, 'desc.zip')
+    runCli(['publish', srcFile, '--namespace', 'ns', '--description', 'My Custom Pack', '-o', outZip])
+
+    const zip = new AdmZip(outZip)
+    const content = JSON.parse(zip.readAsText(zip.getEntry('pack.mcmeta')!))
+    expect(content.pack.description).toBe('My Custom Pack')
+  })
+
+  it('defaults output filename to <namespace>.zip in cwd', () => {
+    const outZip = path.join(tempDir, 'default_ns.zip')
+    const result = runCli(['publish', srcFile, '--namespace', 'default_ns', '-o', outZip])
+
+    expect(result.status).toBe(0)
+    expect(fs.existsSync(outZip)).toBe(true)
+  })
+})

package/src/__tests__/cli.test.ts

@@ -2,11 +2,14 @@ import { compile, check } from '../index'
 import * as fs from 'fs'
 import * as os from 'os'
 import * as path from 'path'
-import { execFileSync } from 'child_process'
+import { execFileSync, spawnSync } from 'child_process'
 
 // Note: watch command is tested manually as it's an interactive long-running process
 
 describe('CLI API', () => {
+  const cliPath = path.resolve(__dirname, '..', 'cli.ts')
+  const cliRunner = [require.resolve('ts-node/register/transpile-only')]
+
   describe('imports', () => {
     it('compiles a file with imported helpers', () => {
       const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-imports-'))
@@ -81,4 +84,117 @@ describe('CLI API', () => {
       expect(error).toBeInstanceOf(Error)
     })
   })
+
+  describe('check CLI', () => {
+    it('returns exit code 1 and JSON diagnostics for warnings', () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-check-cli-'))
+      const filePath = path.join(tempDir, 'warn.mcrs')
+      fs.writeFileSync(filePath, 'fn main(x: float) {\n  return;\n}\n')
+
+      const result = spawnSync(
+        process.execPath,
+        ['-r', ...cliRunner, cliPath, 'check', filePath, '--format', 'json'],
+        {
+          encoding: 'utf-8',
+          env: { ...process.env, REDSCRIPT_NO_UPDATE_CHECK: '1' },
+        }
+      )
+
+      expect(result.status).toBe(1)
+      const payload = JSON.parse(result.stdout)
+      expect(payload.summary.warnings).toBeGreaterThan(0)
+      expect(payload.summary.errors).toBe(0)
+      expect(payload.diagnostics[0].severity).toBe('warning')
+    })
+
+    it('returns exit code 2 and human-readable output for errors', () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-check-cli-'))
+      const filePath = path.join(tempDir, 'error.mcrs')
+      fs.writeFileSync(filePath, 'fn main( {\n  return;\n}\n')
+
+      const result = spawnSync(
+        process.execPath,
+        ['-r', ...cliRunner, cliPath, 'check', filePath],
+        {
+          encoding: 'utf-8',
+          env: { ...process.env, REDSCRIPT_NO_UPDATE_CHECK: '1' },
+        }
+      )
+
+      expect(result.status).toBe(2)
+      expect(result.stderr).toContain(`${filePath}:`)
+      expect(result.stderr).toContain('error:')
+    })
+  })
+
+  describe('fmt CLI', () => {
+    it('formats files in place', () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-fmt-cli-'))
+      const filePath = path.join(tempDir, 'format.mcrs')
+      fs.writeFileSync(filePath, 'fn main()\n{\nlet x: int = 1;\n}\n')
+
+      const result = spawnSync(
+        process.execPath,
+        ['-r', ...cliRunner, cliPath, 'fmt', filePath],
+        {
+          encoding: 'utf-8',
+          env: { ...process.env, REDSCRIPT_NO_UPDATE_CHECK: '1' },
+        }
+      )
+
+      expect(result.status).toBe(0)
+      expect(fs.readFileSync(filePath, 'utf-8')).toBe('fn main() {\n  let x: int = 1;\n}\n')
+    })
+
+    it('supports --check mode', () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-fmt-cli-'))
+      const filePath = path.join(tempDir, 'check.mcrs')
+      fs.writeFileSync(filePath, 'fn main()\n{\nlet x: int = 1;\n}\n')
+
+      const result = spawnSync(
+        process.execPath,
+        ['-r', ...cliRunner, cliPath, 'fmt', filePath, '--check'],
+        {
+          encoding: 'utf-8',
+          env: { ...process.env, REDSCRIPT_NO_UPDATE_CHECK: '1' },
+        }
+      )
+
+      expect(result.status).toBe(1)
+      expect(result.stdout).toContain('Would format:')
+      expect(fs.readFileSync(filePath, 'utf-8')).toBe('fn main()\n{\nlet x: int = 1;\n}\n')
+    })
+  })
+
+  describe('compile CLI', () => {
+    it('supports --incremental and reuses cached output on the second run', () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-compile-cli-'))
+      const filePath = path.join(tempDir, 'main.mcrs')
+      const outDir = path.join(tempDir, 'dist')
+      fs.writeFileSync(filePath, 'fn main() { say("hi"); }\n')
+
+      const first = spawnSync(
+        process.execPath,
+        ['-r', ...cliRunner, cliPath, 'compile', filePath, '--incremental', '-o', outDir],
+        {
+          encoding: 'utf-8',
+          env: { ...process.env, REDSCRIPT_NO_UPDATE_CHECK: '1' },
+        }
+      )
+
+      const second = spawnSync(
+        process.execPath,
+        ['-r', ...cliRunner, cliPath, 'compile', filePath, '--incremental', '-o', outDir],
+        {
+          encoding: 'utf-8',
+          env: { ...process.env, REDSCRIPT_NO_UPDATE_CHECK: '1' },
+        }
+      )
+
+      expect(first.status).toBe(0)
+      expect(second.status).toBe(0)
+      expect(second.stdout).toContain('Reused cache')
+      expect(fs.existsSync(path.join(tempDir, '.redscript-cache', 'cache.json'))).toBe(true)
+    })
+  })
 })