@algosail/lang 0.2.9 → 0.2.10

package/README.md

@@ -2,6 +2,15 @@
 
 Sail language tooling. Re-exports parser and typecheck.
 
+## CLI
+
+```bash
+sail check <file.sail>           # Typecheck
+sail compile <file.sail> [options]  # Compile to JS
+```
+
+Options for `compile`: `--out <file.js>`, `--no-source-map`, `-` (stdout).
+
 ## Exports
 
 ```javascript

package/cli/sail.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+
+/**
+ * Sail CLI — sail check | sail compile
+ */
+
+const args = process.argv.slice(2)
+const cmd = args[0]
+
+if (!cmd || cmd === '-h' || cmd === '--help') {
+  console.log(`sail - Sail language tooling
+
+Usage:
+  sail check <file.sail>       Typecheck a Sail file
+  sail compile <file.sail>     Compile Sail to JavaScript
+
+Options for compile:
+  --out <file.js>              Output path (default: input.js)
+  --no-source-map              Disable source map generation
+  -                           Write to stdout
+
+Examples:
+  sail check main.sail
+  sail compile main.sail --out dist/main.js
+  sail compile main.sail -
+`)
+  process.exit(cmd === '-h' || cmd === '--help' ? 0 : 1)
+}
+
+const rest = args.slice(1)
+
+if (cmd === 'check') {
+  await runCheck(rest)
+} else if (cmd === 'compile') {
+  await runCompile(rest)
+} else {
+  console.error(`sail: unknown command '${cmd}'. Use 'sail check' or 'sail compile'.`)
+  process.exit(1)
+}
+
+async function runCheck(args) {
+  const filePath = args.find((a) => !a.startsWith('-'))
+  if (!filePath) {
+    console.error('Usage: sail check <path-to-file.sail>')
+    process.exit(1)
+  }
+
+  const { createParser } = await import('@algosail/parser')
+  const { typecheck } = await import('@algosail/typecheck')
+  const { readFile } = await import('node:fs/promises')
+  const { pathToFileURL } = await import('node:url')
+  const { resolve } = await import('node:path')
+  const { formatError } = await import('@algosail/compiler/lib/formatError.js')
+  const { addErrorHints } = await import('@algosail/compiler/lib/errorHints.js')
+
+  const absPath = resolve(process.cwd(), filePath)
+  const uri = pathToFileURL(absPath).href
+
+  let text
+  try {
+    text = await readFile(absPath, 'utf8')
+  } catch (err) {
+    console.error(`sail check: cannot read ${filePath}: ${err.message}`)
+    process.exit(1)
+  }
+
+  const parser = await createParser()
+  const result = await parser.parseSail(uri, text)
+  const parseErrors = (result.errors ?? []).map((e) => ({
+    message: e.type === 'error' ? `Parse error: ${e.text}` : `Parse error: missing ${e.text}`,
+    startPosition: e.startPosition,
+    uri,
+  }))
+  const typeErrors = typecheck(result).map((e) => {
+    const hint = addErrorHints(e)
+    return { ...e, uri, ...(hint && { hint }) }
+  })
+  const errors = [...parseErrors, ...typeErrors]
+
+  if (errors.length > 0) {
+    for (const err of errors) {
+      console.error(formatError({ ...err, uri }, uri))
+    }
+    process.exit(1)
+  }
+}
+
+async function runCompile(args) {
+  let inputPath = null
+  let outPath = null
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--out' && args[i + 1]) {
+      outPath = args[i + 1]
+      i++
+    } else if (!args[i].startsWith('-')) {
+      inputPath = args[i]
+    }
+  }
+
+  if (!inputPath) {
+    console.error('Usage: sail compile <input.sail> [--out <output.js>] [--no-source-map]')
+    process.exit(1)
+  }
+
+  const { compile } = await import('@algosail/compiler')
+  const { formatError } = await import('@algosail/compiler/lib/formatError.js')
+  const { readFile, writeFile } = await import('node:fs/promises')
+  const { dirname, resolve, basename } = await import('node:path')
+  const { pathToFileURL } = await import('node:url')
+
+  const absPath = resolve(process.cwd(), inputPath)
+  const uri = pathToFileURL(absPath).href
+
+  let source
+  try {
+    source = await readFile(absPath, 'utf8')
+  } catch (err) {
+    console.error(`sail compile: cannot read ${inputPath}: ${err.message}`)
+    process.exit(1)
+  }
+
+  const outputPath = outPath ?? inputPath.replace(/\.sail$/, '.js')
+  const compileOpts = {
+    outPath: outputPath !== '-' ? dirname(resolve(process.cwd(), outputPath)) : dirname(absPath),
+    sourceMap: outputPath !== '-' && !args.includes('--no-source-map'),
+    outFile: outputPath !== '-' ? resolve(process.cwd(), outputPath) : null,
+  }
+
+  const result = await compile(uri, source, compileOpts)
+
+  if (result.errors.length > 0) {
+    for (const err of result.errors) {
+      console.error(formatError({ ...err, uri }, uri))
+    }
+    process.exit(1)
+  }
+
+  if (outputPath === '-') {
+    process.stdout.write(result.js)
+  } else {
+    let js = result.js
+    if (result.sourceMap) {
+      const mapPath = outputPath + '.map'
+      await writeFile(mapPath, result.sourceMap, 'utf8')
+      js += `\n//# sourceMappingURL=${basename(mapPath)}`
+    }
+    await writeFile(outputPath, js, 'utf8')
+    console.log(`Compiled to ${outputPath}`)
+  }
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@algosail/lang",
-  "version": "0.2.9",
+  "version": "0.2.10",
   "type": "module",
   "main": "index.js",
   "bin": {
-    "sail-typecheck": "cli/typecheck.js"
+    "sail": "cli/sail.js"
   },
   "scripts": {
     "test": "brittle \"test/**/*.test.js\""
@@ -16,6 +16,6 @@
     "@algosail/builtins": "^0.0.6",
     "@algosail/compiler": "^0.0.2",
     "@algosail/parser": "^0.1.1",
-    "@algosail/typecheck": "^0.1.1"
+    "@algosail/typecheck": "^0.1.2"
   }
 }