tjs-lang 0.2.0

package/src/cli/commands/check.ts

@@ -0,0 +1,41 @@
+/**
+ * tjs check - Parse and type check a TJS file
+ */
+
+import { readFileSync } from 'fs'
+import { tjs } from '../../lang'
+
+export async function check(file: string): Promise<void> {
+  const source = readFileSync(file, 'utf-8')
+
+  try {
+    const result = tjs(source)
+
+    // Report function info from types
+    if (result.types) {
+      const fn = result.types
+      const params = Object.entries(fn.params || {})
+        .map(([name, info]: [string, any]) => {
+          const opt = info.required ? '' : '?'
+          const type = info.type?.kind || 'any'
+          return `${name}${opt}: ${type}`
+        })
+        .join(', ')
+      const ret = fn.returns?.kind || 'void'
+      console.log(`✓ ${file}`)
+      console.log(`  ${fn.name}(${params}) -> ${ret}`)
+    } else {
+      console.log(`✓ ${file} - Parsed successfully`)
+    }
+  } catch (error: any) {
+    console.error(`✗ ${file}`)
+    if (error.name === 'SyntaxError' && error.formatWithContext) {
+      console.error()
+      console.error(error.formatWithContext(2))
+      console.error()
+    } else {
+      console.error(`  ${error.message}`)
+    }
+    process.exit(1)
+  }
+}

package/src/cli/commands/convert.ts

@@ -0,0 +1,133 @@
+/**
+ * tjs convert - Convert TypeScript files to TJS
+ *
+ * Usage:
+ *   tjs convert <file.ts>              Convert single file, output to stdout
+ *   tjs convert <file.ts> -o <out.tjs> Convert single file to output file
+ *   tjs convert <dir> -o <outdir>      Convert all .ts files in directory
+ */
+
+import {
+  readFileSync,
+  writeFileSync,
+  readdirSync,
+  statSync,
+  mkdirSync,
+  existsSync,
+} from 'fs'
+import { join, basename, dirname, extname } from 'path'
+import { fromTS } from '../../lang/emitters/from-ts'
+
+export interface ConvertOptions {
+  output?: string
+  recursive?: boolean
+  verbose?: boolean
+}
+
+export async function convert(
+  input: string,
+  options: ConvertOptions = {}
+): Promise<void> {
+  const { output, recursive = true, verbose = false } = options
+  const stats = statSync(input)
+
+  if (stats.isFile()) {
+    // Single file conversion
+    await convertFile(input, output, verbose)
+  } else if (stats.isDirectory()) {
+    // Directory conversion
+    if (!output) {
+      console.error('Error: Output directory required for directory conversion')
+      console.error('Usage: tjs convert <dir> -o <outdir>')
+      process.exit(1)
+    }
+    await convertDirectory(input, output, recursive, verbose)
+  } else {
+    console.error(`Error: ${input} is not a file or directory`)
+    process.exit(1)
+  }
+}
+
+async function convertFile(
+  inputPath: string,
+  outputPath?: string,
+  verbose = false
+): Promise<void> {
+  const source = readFileSync(inputPath, 'utf-8')
+  const filename = basename(inputPath)
+
+  try {
+    const result = fromTS(source, { emitTJS: true, filename })
+
+    if (result.warnings && result.warnings.length > 0 && verbose) {
+      console.error(`Warnings for ${inputPath}:`)
+      for (const warning of result.warnings) {
+        console.error(`  - ${warning}`)
+      }
+    }
+
+    if (outputPath) {
+      // Ensure output directory exists
+      const outDir = dirname(outputPath)
+      if (!existsSync(outDir)) {
+        mkdirSync(outDir, { recursive: true })
+      }
+      writeFileSync(outputPath, result.code)
+      console.log(`✓ ${inputPath} -> ${outputPath}`)
+    } else {
+      // Output to stdout
+      console.log(result.code)
+    }
+  } catch (error: any) {
+    console.error(`✗ ${inputPath}: ${error.message}`)
+    if (!outputPath) {
+      process.exit(1)
+    }
+  }
+}
+
+async function convertDirectory(
+  inputDir: string,
+  outputDir: string,
+  recursive: boolean,
+  verbose: boolean
+): Promise<void> {
+  const entries = readdirSync(inputDir)
+  let converted = 0
+  let failed = 0
+  let skipped = 0
+
+  for (const entry of entries) {
+    const inputPath = join(inputDir, entry)
+    const stats = statSync(inputPath)
+
+    if (stats.isDirectory() && recursive) {
+      // Recurse into subdirectory
+      const subOutputDir = join(outputDir, entry)
+      await convertDirectory(inputPath, subOutputDir, recursive, verbose)
+    } else if (stats.isFile() && extname(entry) === '.ts') {
+      // Skip test files and declaration files
+      if (entry.endsWith('.test.ts') || entry.endsWith('.d.ts')) {
+        skipped++
+        if (verbose) {
+          console.log(`- Skipping ${inputPath}`)
+        }
+        continue
+      }
+
+      const outputPath = join(outputDir, entry.replace(/\.ts$/, '.tjs'))
+      try {
+        await convertFile(inputPath, outputPath, verbose)
+        converted++
+      } catch {
+        failed++
+      }
+    }
+  }
+
+  if (verbose || converted > 0 || failed > 0) {
+    console.log(
+      `\nDirectory ${inputDir}: ${converted} converted, ${failed} failed, ${skipped} skipped`
+    )
+  }
+}

package/src/cli/commands/emit.ts

@@ -0,0 +1,260 @@
+/**
+ * tjs emit - Output transpiled JavaScript
+ *
+ * Usage:
+ *   tjs emit <file.tjs>                 Emit single file to stdout
+ *   tjs emit <file.tjs> -o <out.js>     Emit single file to output
+ *   tjs emit <dir> -o <outdir>          Emit all .tjs files in directory
+ *   tjs emit --unsafe <file.tjs>        Emit without __tjs metadata (production)
+ *   tjs emit --no-docs <file.tjs>       Suppress documentation generation
+ *   tjs emit --docs-dir <dir>           Output docs to separate directory
+ *   tjs emit --jfdi <file.tjs>          Emit even if tests fail (just fucking do it)
+ */
+
+import {
+  readFileSync,
+  writeFileSync,
+  readdirSync,
+  statSync,
+  mkdirSync,
+  existsSync,
+} from 'fs'
+import { join, basename, dirname, extname } from 'path'
+import { tjs } from '../../lang'
+import { generateDocs } from '../../lang/docs'
+
+export interface EmitOptions {
+  /** Include source locations in __tjs metadata */
+  debug?: boolean
+  /** Output path (file or directory) */
+  output?: string
+  /** Strip __tjs metadata for production builds */
+  unsafe?: boolean
+  /** Recursive directory processing */
+  recursive?: boolean
+  /** Verbose output */
+  verbose?: boolean
+  /** Suppress documentation generation */
+  noDocs?: boolean
+  /** Output docs to separate directory (default: alongside JS) */
+  docsDir?: string
+  /** Emit even if tests fail (just fucking do it) */
+  jfdi?: boolean
+}
+
+export async function emit(
+  input: string,
+  options: EmitOptions = {}
+): Promise<void> {
+  const { output, recursive = true } = options
+
+  // Check if input exists
+  if (!existsSync(input)) {
+    console.error(`Error: ${input} does not exist`)
+    process.exit(1)
+  }
+
+  const stats = statSync(input)
+
+  if (stats.isFile()) {
+    await emitFile(input, output, options)
+  } else if (stats.isDirectory()) {
+    if (!output) {
+      console.error('Error: Output directory required for directory emit')
+      console.error('Usage: tjs emit <dir> -o <outdir>')
+      process.exit(1)
+    }
+    await emitDirectory(input, output, recursive, options)
+  } else {
+    console.error(`Error: ${input} is not a file or directory`)
+    process.exit(1)
+  }
+}
+
+async function emitFile(
+  inputPath: string,
+  outputPath: string | undefined,
+  options: EmitOptions
+): Promise<void> {
+  const source = readFileSync(inputPath, 'utf-8')
+  const filename = basename(inputPath)
+
+  try {
+    // Use 'report' mode to get test results without throwing
+    const result = tjs(source, {
+      filename,
+      debug: options.debug,
+      runTests: 'report',
+    })
+
+    // Check test results
+    const testResults = result.testResults || []
+    const failures = testResults.filter((r) => !r.passed)
+    const hasFailures = failures.length > 0
+
+    // Report test results
+    if (testResults.length > 0) {
+      const passed = testResults.filter((r) => r.passed).length
+      const failed = failures.length
+
+      if (options.verbose || hasFailures) {
+        if (hasFailures) {
+          console.log(`\n${inputPath}: ${passed} passed, ${failed} failed`)
+          for (const f of failures) {
+            if (f.isSignatureTest) {
+              console.log(`  ✗ Signature: ${f.error}`)
+            } else {
+              console.log(`  ✗ ${f.description}: ${f.error}`)
+            }
+          }
+        } else if (options.verbose) {
+          console.log(`  ✓ ${testResults.length} tests passed`)
+        }
+      }
+    }
+
+    // Don't emit if tests failed (unless --jfdi)
+    if (hasFailures && !options.jfdi) {
+      if (!options.verbose) {
+        // Show failures even in non-verbose mode
+        console.error(`✗ ${inputPath}: ${failures.length} test(s) failed`)
+        for (const f of failures) {
+          if (f.isSignatureTest) {
+            console.error(`  Signature: ${f.error}`)
+          } else {
+            console.error(`  ${f.description}: ${f.error}`)
+          }
+        }
+      }
+      console.error(`  (use --jfdi to emit anyway)`)
+      return
+    }
+
+    let code = result.code
+
+    // Strip __tjs metadata if unsafe mode
+    if (options.unsafe) {
+      code = stripTJSMetadata(code)
+    }
+
+    if (outputPath) {
+      // Ensure output directory exists
+      const outDir = dirname(outputPath)
+      if (outDir && !existsSync(outDir)) {
+        mkdirSync(outDir, { recursive: true })
+      }
+      writeFileSync(outputPath, code)
+      if (options.verbose) {
+        const suffix = hasFailures ? ' (tests failed, --jfdi)' : ''
+        console.log(`✓ ${inputPath} -> ${outputPath}${suffix}`)
+      }
+
+      // Generate docs unless suppressed
+      if (!options.noDocs) {
+        try {
+          const docs = generateDocs(source)
+          const docsPath = options.docsDir
+            ? join(
+                options.docsDir,
+                basename(outputPath).replace(/\.js$/, '.md')
+              )
+            : outputPath.replace(/\.js$/, '.md')
+
+          // Ensure docs directory exists
+          const docsDir = dirname(docsPath)
+          if (docsDir && !existsSync(docsDir)) {
+            mkdirSync(docsDir, { recursive: true })
+          }
+
+          writeFileSync(docsPath, docs.markdown)
+          if (options.verbose) {
+            console.log(`  📄 ${docsPath}`)
+          }
+        } catch (docsError: any) {
+          // Don't fail emit if docs generation fails
+          if (options.verbose) {
+            console.log(`  ⚠ docs skipped: ${docsError.message}`)
+          }
+        }
+      }
+    } else {
+      // Output to stdout
+      console.log(code)
+    }
+  } catch (error: any) {
+    // This is a real transpilation error (syntax, parse, etc.)
+    console.error(`✗ ${inputPath}: ${error.message}`)
+    if (!outputPath) {
+      process.exit(1)
+    }
+  }
+}
+
+async function emitDirectory(
+  inputDir: string,
+  outputDir: string,
+  recursive: boolean,
+  options: EmitOptions
+): Promise<void> {
+  const entries = readdirSync(inputDir)
+  let emitted = 0
+  let failed = 0
+  let skipped = 0
+
+  for (const entry of entries) {
+    const inputPath = join(inputDir, entry)
+    const stats = statSync(inputPath)
+
+    if (stats.isDirectory()) {
+      if (recursive && !entry.startsWith('.') && entry !== 'node_modules') {
+        const subOutputDir = join(outputDir, entry)
+        await emitDirectory(inputPath, subOutputDir, recursive, options)
+      }
+    } else if (stats.isFile() && extname(entry) === '.tjs') {
+      // Skip test files for production emit
+      if (entry.endsWith('.test.tjs')) {
+        skipped++
+        if (options.verbose) {
+          console.log(`- Skipping test: ${inputPath}`)
+        }
+        continue
+      }
+
+      const outputPath = join(outputDir, entry.replace(/\.tjs$/, '.js'))
+      try {
+        await emitFile(inputPath, outputPath, { ...options, verbose: true })
+        emitted++
+      } catch {
+        failed++
+      }
+    }
+  }
+
+  if (options.verbose || emitted > 0 || failed > 0) {
+    console.log(
+      `\n${inputDir}: ${emitted} emitted, ${failed} failed, ${skipped} skipped`
+    )
+  }
+}
+
+/**
+ * Strip __tjs metadata from transpiled code for production builds.
+ * This removes runtime validation, giving pure JS performance.
+ */
+function stripTJSMetadata(code: string): string {
+  // Remove __tjs property assignments from function declarations
+  // Pattern: function foo(x) { ... }\nfoo.__tjs = { ... };
+  code = code.replace(/\n\w+\.__tjs\s*=\s*\{[^}]*\};?/g, '')
+
+  // Remove __tjs from object method shorthand and arrow functions
+  // Pattern: const foo = (x) => { ... };\nfoo.__tjs = { ... };
+  code = code.replace(/;\s*\w+\.__tjs\s*=\s*\{[^}]*\};?/g, ';')
+
+  // Remove standalone __tjs assignments that might remain
+  code = code.replace(/^\w+\.__tjs\s*=\s*\{[^}]*\};?\n?/gm, '')
+
+  // Clean up any double newlines left behind
+  code = code.replace(/\n{3,}/g, '\n\n')
+
+  return code
+}

package/src/cli/commands/run.ts

@@ -0,0 +1,68 @@
+/**
+ * tjs run - Transpile and execute a TJS file
+ *
+ * Executes the entire file as a script, with full TJS runtime support.
+ */
+
+import { readFileSync } from 'fs'
+import { resolve } from 'path'
+import { preprocess } from '../../lang/parser'
+import { transpileToJS } from '../../lang/emitters/js'
+import * as runtime from '../../lang/runtime'
+
+export async function run(file: string): Promise<void> {
+  const absolutePath = resolve(file)
+  const source = readFileSync(absolutePath, 'utf-8')
+
+  try {
+    // Preprocess: transforms Type, Generic, Union declarations, runs tests
+    const preprocessed = preprocess(source)
+
+    if (preprocessed.testErrors.length > 0) {
+      console.error('Test failures:')
+      for (const err of preprocessed.testErrors) {
+        console.error(`  ${err.description}: ${err.error}`)
+      }
+      process.exit(1)
+    }
+
+    // Transpile to JS
+    const result = transpileToJS(preprocessed.source)
+
+    if (result.warnings && result.warnings.length > 0) {
+      for (const warning of result.warnings) {
+        console.warn(`Warning: ${warning.message}`)
+      }
+    }
+
+    // Create a module-like execution context with TJS runtime
+    const AsyncFunction = Object.getPrototypeOf(
+      async function () {}
+    ).constructor
+
+    // Wrap code in an async IIFE to support top-level await
+    const wrappedCode = `
+      const { Type, Generic, Union, Enum, isRuntimeType, wrap, error, isError } = __runtime__;
+      ${result.code}
+    `
+
+    const fn = new AsyncFunction('__runtime__', wrappedCode)
+    await fn(runtime)
+  } catch (error: any) {
+    if (error.name === 'SyntaxError' && error.formatWithContext) {
+      // Use enhanced error formatting with source context
+      console.error(`Syntax error in ${file}:\n`)
+      console.error(error.formatWithContext(2))
+      console.error()
+    } else if (error.name === 'SyntaxError') {
+      console.error(`Syntax error in ${file}:`)
+      console.error(`  ${error.message}`)
+      if (error.line) {
+        console.error(`  at line ${error.line}, column ${error.column}`)
+      }
+    } else {
+      console.error(`Runtime error: ${error.message}`)
+    }
+    process.exit(1)
+  }
+}

package/src/cli/commands/test.ts

@@ -0,0 +1,194 @@
+/**
+ * tjs test - Run TJS test files
+ *
+ * Usage:
+ *   tjs test                     Run all .test.tjs files
+ *   tjs test <file>              Run specific test file
+ *   tjs test <dir>               Run all .test.tjs files in directory
+ *   tjs test -t <pattern>        Run tests matching pattern
+ *
+ * This command wraps `bun test` with the TJS plugin preloaded,
+ * and generates temporary wrapper files for .test.tjs files since
+ * Bun's test runner only recognizes standard extensions.
+ */
+
+import {
+  readdirSync,
+  statSync,
+  writeFileSync,
+  unlinkSync,
+  existsSync,
+  mkdirSync,
+} from 'fs'
+import { join, dirname, resolve, relative } from 'path'
+import { spawn } from 'bun'
+
+export interface TestOptions {
+  pattern?: string // -t, --test-name-pattern
+  timeout?: number // --timeout
+  watch?: boolean // --watch
+  coverage?: boolean // --coverage
+  bail?: number // --bail
+}
+
+// Find all .test.tjs files recursively
+function findTestFiles(dir: string, files: string[] = []): string[] {
+  const entries = readdirSync(dir)
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry)
+    const stats = statSync(fullPath)
+
+    if (
+      stats.isDirectory() &&
+      !entry.startsWith('.') &&
+      entry !== 'node_modules'
+    ) {
+      findTestFiles(fullPath, files)
+    } else if (stats.isFile() && entry.endsWith('.test.tjs')) {
+      files.push(fullPath)
+    }
+  }
+
+  return files
+}
+
+// Get the plugin path relative to cwd
+function getPluginPath(): string {
+  // Find the tjs-plugin relative to this file
+  const pluginPath = resolve(
+    dirname(import.meta.path),
+    '../../bun-plugin/tjs-plugin.ts'
+  )
+  return pluginPath
+}
+
+// Create temporary wrapper directory
+function getTempDir(): string {
+  const tempDir = join(process.cwd(), '.tjs-test-temp')
+  if (!existsSync(tempDir)) {
+    mkdirSync(tempDir, { recursive: true })
+  }
+  return tempDir
+}
+
+// Generate wrapper .test.ts files that import .test.tjs files
+function generateWrappers(testFiles: string[], tempDir: string): string[] {
+  const wrappers: string[] = []
+
+  for (const testFile of testFiles) {
+    const relativePath = relative(tempDir, testFile)
+
+    // Handle potential name collisions by including directory info
+    const uniqueName = testFile
+      .replace(process.cwd(), '')
+      .replace(/[/\\]/g, '_')
+      .replace('.test.tjs', '.test.ts')
+      .replace(/^_/, '')
+    const uniqueWrapperPath = join(tempDir, uniqueName)
+
+    const wrapperContent = `// Auto-generated wrapper for TJS test\nimport '${relativePath}';\n`
+    writeFileSync(uniqueWrapperPath, wrapperContent)
+    wrappers.push(uniqueWrapperPath)
+  }
+
+  return wrappers
+}
+
+// Clean up wrapper files
+function cleanupWrappers(wrappers: string[], tempDir: string): void {
+  for (const wrapper of wrappers) {
+    try {
+      unlinkSync(wrapper)
+    } catch {
+      // Ignore cleanup errors
+    }
+  }
+
+  // Try to remove temp directory if empty
+  try {
+    const remaining = readdirSync(tempDir)
+    if (remaining.length === 0) {
+      unlinkSync(tempDir)
+    }
+  } catch {
+    // Ignore
+  }
+}
+
+export async function test(
+  input?: string,
+  options: TestOptions = {}
+): Promise<void> {
+  const pluginPath = getPluginPath()
+
+  // Determine what to test
+  let testFiles: string[] = []
+
+  if (!input) {
+    // Find all .test.tjs files in current directory
+    testFiles = findTestFiles(process.cwd())
+  } else if (input.endsWith('.test.tjs')) {
+    // Single test file
+    testFiles = [resolve(input)]
+  } else if (existsSync(input) && statSync(input).isDirectory()) {
+    // Directory
+    testFiles = findTestFiles(resolve(input))
+  } else {
+    // Treat as a filter pattern for bun test
+    testFiles = findTestFiles(process.cwd())
+  }
+
+  if (testFiles.length === 0) {
+    console.log('No .test.tjs files found')
+    return
+  }
+
+  console.log(`Found ${testFiles.length} TJS test file(s)`)
+
+  // Generate wrapper files
+  const tempDir = getTempDir()
+  const wrappers = generateWrappers(testFiles, tempDir)
+
+  try {
+    // Build bun test command
+    const args = ['test', '--preload', pluginPath]
+
+    if (options.pattern) {
+      args.push('--test-name-pattern', options.pattern)
+    }
+    if (options.timeout) {
+      args.push('--timeout', String(options.timeout))
+    }
+    if (options.coverage) {
+      args.push('--coverage')
+    }
+    if (options.bail !== undefined) {
+      args.push('--bail', String(options.bail))
+    }
+
+    // Add wrapper files
+    args.push(...wrappers)
+
+    // Run bun test
+    const proc = spawn({
+      cmd: ['bun', ...args],
+      cwd: process.cwd(),
+      stdout: 'inherit',
+      stderr: 'inherit',
+    })
+
+    const exitCode = await proc.exited
+
+    // Cleanup
+    cleanupWrappers(wrappers, tempDir)
+
+    if (exitCode !== 0) {
+      process.exit(exitCode)
+    }
+  } catch (error) {
+    // Cleanup on error
+    cleanupWrappers(wrappers, tempDir)
+    throw error
+  }
+}