tjs-lang 0.2.0

package/src/cli/commands/types.ts

@@ -0,0 +1,20 @@
+/**
+ * tjs types - Output type metadata as JSON
+ */
+
+import { readFileSync } from 'fs'
+import { tjs } from '../../lang'
+
+export async function types(file: string): Promise<void> {
+  const source = readFileSync(file, 'utf-8')
+
+  const result = tjs(source)
+
+  // Output the type information as JSON
+  const typeInfo = {
+    file,
+    ...result.types,
+  }
+
+  console.log(JSON.stringify(typeInfo, null, 2))
+}

package/src/cli/create-app.ts

@@ -0,0 +1,236 @@
+#!/usr/bin/env bun
+/**
+ * create-tjs-app - Scaffold a new TJS project
+ *
+ * Usage:
+ *   bun create tjs-app my-app
+ *   bunx create-tjs-app my-app
+ */
+
+import { existsSync, mkdirSync, writeFileSync } from 'fs'
+import { join, resolve } from 'path'
+
+const HELP = `
+create-tjs-app - Scaffold a new TJS project
+
+Usage:
+  bun create tjs-app <project-name>
+  bunx create-tjs-app <project-name>
+
+Options:
+  -h, --help      Show this help message
+  --minimal       Create minimal project (no examples)
+
+Examples:
+  bun create tjs-app my-app
+  bun create tjs-app ./projects/new-app
+  bun create tjs-app my-app --minimal
+`
+
+const PACKAGE_JSON = (name: string) => `{
+  "name": "${name}",
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "dev": "tjs-playground",
+    "check": "tjs check src/",
+    "build": "tjs emit src/ -o dist/",
+    "test": "tjs test"
+  },
+  "dependencies": {
+    "tjs-lang": "^0.1.0"
+  }
+}
+`
+
+const MAIN_TJS = `/**
+ * Main entry point
+ */
+
+// A simple function with type validation
+function greet(name: 'World') -> '' {
+  return \`Hello, \${name}!\`
+}
+
+// Run it
+console.log(greet())
+console.log(greet('TJS'))
+`
+
+const UTILS_TJS = `/**
+ * Utility functions with runtime type checking
+ */
+
+// Math utilities
+function add(a: 0, b: 0) -> 0 {
+  return a + b
+}
+
+function multiply(a: 0, b: 0) -> 0 {
+  return a * b
+}
+
+// String utilities
+function capitalize(str: '') -> '' {
+  if (str.length === 0) return ''
+  return str[0].toUpperCase() + str.slice(1)
+}
+
+// Array utilities
+function sum(numbers: [0]) -> 0 {
+  return numbers.reduce((acc, n) => acc + n, 0)
+}
+
+export { add, multiply, capitalize, sum }
+`
+
+const UTILS_TEST_TJS = `/**
+ * Tests for utility functions
+ */
+
+import { add, multiply, capitalize, sum } from './utils.tjs'
+
+test('add works with numbers', () => {
+  expect(add(1, 2)).toBe(3)
+  expect(add(-1, 1)).toBe(0)
+  expect(add(0.1, 0.2)).toBeCloseTo(0.3)
+})
+
+test('multiply works with numbers', () => {
+  expect(multiply(2, 3)).toBe(6)
+  expect(multiply(-2, 3)).toBe(-6)
+})
+
+test('capitalize handles strings', () => {
+  expect(capitalize('hello')).toBe('Hello')
+  expect(capitalize('')).toBe('')
+  expect(capitalize('a')).toBe('A')
+})
+
+test('sum adds array elements', () => {
+  expect(sum([1, 2, 3])).toBe(6)
+  expect(sum([])).toBe(0)
+  expect(sum([5])).toBe(5)
+})
+
+test('type validation rejects bad inputs', () => {
+  // These should return monadic errors, not throw
+  const result = add('not', 'numbers')
+  expect(result.error).toBeDefined()
+})
+`
+
+const README = (name: string) => `# ${name}
+
+A TJS (Typed JavaScript) project.
+
+## Getting Started
+
+\`\`\`bash
+# Install dependencies
+bun install
+
+# Run the playground
+bun run dev
+
+# Type check all files
+bun run check
+
+# Run tests
+bun run test
+
+# Build for production
+bun run build
+\`\`\`
+
+## Project Structure
+
+\`\`\`
+${name}/
+├── src/
+│   ├── main.tjs       # Entry point
+│   ├── utils.tjs      # Utility functions
+│   └── utils.test.tjs # Tests
+├── dist/              # Built output (after build)
+└── package.json
+\`\`\`
+
+## TJS Features
+
+TJS adds runtime type validation to JavaScript:
+
+\`\`\`javascript
+// Required parameter with type inference from example
+function greet(name: 'Alice') -> '' {
+  return \`Hello, \${name}!\`
+}
+
+greet('Bob')      // Returns "Hello, Bob!"
+greet(123)        // Returns { error: 'type mismatch', ... }
+\`\`\`
+
+Learn more at the [TJS documentation](https://github.com/tonioloewald/tjs-lang).
+`
+
+const GITIGNORE = `node_modules/
+dist/
+.DS_Store
+*.log
+`
+
+async function main() {
+  const args = process.argv.slice(2)
+
+  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+    console.log(HELP)
+    process.exit(0)
+  }
+
+  const minimal = args.includes('--minimal')
+  const projectArg = args.find((a) => !a.startsWith('-'))
+
+  if (!projectArg) {
+    console.error('Error: Please specify a project name')
+    console.error('Usage: bun create tjs-app <project-name>')
+    process.exit(1)
+  }
+
+  const projectDir = resolve(projectArg)
+  const projectName = projectArg.split('/').pop() || 'tjs-app'
+
+  // Check if directory exists
+  if (existsSync(projectDir)) {
+    console.error(`Error: Directory '${projectDir}' already exists`)
+    process.exit(1)
+  }
+
+  console.log(`Creating TJS project in ${projectDir}...`)
+
+  // Create directories
+  mkdirSync(projectDir, { recursive: true })
+  mkdirSync(join(projectDir, 'src'), { recursive: true })
+
+  // Write files
+  writeFileSync(join(projectDir, 'package.json'), PACKAGE_JSON(projectName))
+  writeFileSync(join(projectDir, 'README.md'), README(projectName))
+  writeFileSync(join(projectDir, '.gitignore'), GITIGNORE)
+  writeFileSync(join(projectDir, 'src', 'main.tjs'), MAIN_TJS)
+
+  if (!minimal) {
+    writeFileSync(join(projectDir, 'src', 'utils.tjs'), UTILS_TJS)
+    writeFileSync(join(projectDir, 'src', 'utils.test.tjs'), UTILS_TEST_TJS)
+  }
+
+  console.log(`
+Created ${projectName}!
+
+Next steps:
+  cd ${projectArg}
+  bun install
+  bun run dev
+
+Happy coding!
+`)
+}
+
+main()

package/src/cli/playground.ts

@@ -0,0 +1,250 @@
+#!/usr/bin/env bun
+/**
+ * tjs-playground - Serve the TJS playground locally
+ *
+ * Usage:
+ *   tjs-playground [--port 8699]
+ *   bunx tjs-playground
+ */
+
+import { watch } from 'fs'
+import { join } from 'path'
+import { $ } from 'bun'
+
+const DEFAULT_PORT = 8699 // Homage to Agent-99
+
+const HELP = `
+tjs-playground - Serve the TJS playground locally
+
+Usage:
+  tjs-playground [options]
+
+Options:
+  -p, --port <port>   Port to serve on (default: ${DEFAULT_PORT})
+  -h, --help          Show this help message
+  --no-watch          Don't watch for file changes
+
+Examples:
+  tjs-playground
+  tjs-playground --port 3000
+`
+
+async function main() {
+  const args = process.argv.slice(2)
+
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(HELP)
+    process.exit(0)
+  }
+
+  // Parse port
+  const portIdx = args.findIndex((a) => a === '-p' || a === '--port')
+  const port = portIdx !== -1 ? parseInt(args[portIdx + 1], 10) : DEFAULT_PORT
+
+  const noWatch = args.includes('--no-watch')
+
+  // Find the package root (where docs/ lives)
+  // When installed via npm, this will be in node_modules/tjs-lang
+  // When running locally, it's the repo root
+  let rootDir: string
+
+  // Check if we're in node_modules
+  const scriptPath = import.meta.path
+  if (scriptPath.includes('node_modules')) {
+    // Installed as a package - go up to find package root
+    rootDir = join(import.meta.dir, '..', '..')
+  } else {
+    // Running from repo
+    rootDir = join(import.meta.dir, '..', '..')
+  }
+
+  const docsDir = join(rootDir, 'docs')
+  const srcDir = join(rootDir, 'src')
+  const demoDir = join(rootDir, 'demo')
+  const editorsDir = join(rootDir, 'editors')
+
+  // Check if docs directory exists
+  const docsExists = await Bun.file(join(docsDir, 'index.html')).exists()
+
+  if (!docsExists) {
+    console.log('Docs not built yet. Building...')
+    await buildDocs(rootDir)
+  }
+
+  // Kill any existing process on our port
+  try {
+    const result = await $`lsof -ti:${port}`.quiet()
+    const pids = result.text().trim().split('\n').filter(Boolean)
+    for (const pid of pids) {
+      console.log(`Killing existing process on port ${port} (PID: ${pid})`)
+      await $`kill -9 ${pid}`.quiet()
+    }
+  } catch {
+    // No process on port
+  }
+
+  // Build function
+  async function buildDocs(root: string) {
+    console.log('Building playground...')
+    try {
+      // Generate docs.json
+      const docsScript = join(root, 'bin', 'docs.js')
+      if (await Bun.file(docsScript).exists()) {
+        await $`node ${docsScript}`.cwd(root)
+      }
+
+      // Build the demo app
+      const result = await Bun.build({
+        entrypoints: [join(root, 'demo', 'src', 'index.ts')],
+        outdir: join(root, 'docs'),
+        minify: false,
+        sourcemap: 'external',
+        target: 'browser',
+      })
+
+      if (!result.success) {
+        console.error('Build failed:')
+        for (const log of result.logs) {
+          console.error(log)
+        }
+        return false
+      }
+
+      // Copy static files
+      const demoStatic = join(root, 'demo', 'static')
+      const demoIndex = join(root, 'demo', 'index.html')
+      const logoSvg = join(root, 'tjs-lang.svg')
+      const targetDocs = join(root, 'docs')
+
+      await $`cp ${demoIndex} ${logoSvg} ${targetDocs}/`.quiet()
+      await $`cp ${join(demoStatic, 'favicon.svg')} ${targetDocs}/`.quiet()
+      await $`cp ${join(demoStatic, 'photo-*.jpg')} ${targetDocs}/`.quiet()
+      await $`cp -r ${join(demoStatic, 'texts')} ${targetDocs}/`.quiet()
+
+      console.log('Build complete!')
+      return true
+    } catch (error) {
+      console.error(
+        'Build error:',
+        error instanceof Error ? error.message : error
+      )
+      return false
+    }
+  }
+
+  // Debounced rebuild
+  let rebuildTimeout: ReturnType<typeof setTimeout> | null = null
+  let isBuilding = false
+
+  async function debouncedBuild(source: string) {
+    if (rebuildTimeout) clearTimeout(rebuildTimeout)
+    rebuildTimeout = setTimeout(async () => {
+      if (isBuilding) {
+        debouncedBuild(source)
+        return
+      }
+      isBuilding = true
+      console.log(`\n${source}`)
+      await buildDocs(rootDir)
+      isBuilding = false
+    }, 100)
+  }
+
+  // Watch for changes if not disabled
+  const watchers: ReturnType<typeof watch>[] = []
+
+  if (!noWatch) {
+    try {
+      watchers.push(
+        watch(srcDir, { recursive: true }, (event, filename) => {
+          debouncedBuild(`File changed: ${filename}`)
+        })
+      )
+      watchers.push(
+        watch(join(demoDir, 'src'), { recursive: true }, (event, filename) => {
+          debouncedBuild(`Demo file changed: ${filename}`)
+        })
+      )
+      watchers.push(
+        watch(editorsDir, { recursive: true }, (event, filename) => {
+          debouncedBuild(`Editor file changed: ${filename}`)
+        })
+      )
+    } catch {
+      // Watching may fail if directories don't exist (installed package)
+    }
+  }
+
+  // Serve the docs directory
+  const server = Bun.serve({
+    port,
+    async fetch(req) {
+      const url = new URL(req.url)
+      let pathname = url.pathname
+
+      if (pathname === '/') {
+        pathname = '/index.html'
+      }
+
+      const filePath = join(docsDir, pathname)
+      const file = Bun.file(filePath)
+
+      if (await file.exists()) {
+        const ext = pathname.split('.').pop()
+        const contentTypes: Record<string, string> = {
+          html: 'text/html',
+          js: 'application/javascript',
+          css: 'text/css',
+          json: 'application/json',
+          svg: 'image/svg+xml',
+          png: 'image/png',
+          jpg: 'image/jpeg',
+          jpeg: 'image/jpeg',
+          webp: 'image/webp',
+          gif: 'image/gif',
+          ico: 'image/x-icon',
+          map: 'application/json',
+        }
+
+        return new Response(file, {
+          headers: {
+            'Content-Type': contentTypes[ext || 'html'] || 'text/plain',
+            'Access-Control-Allow-Origin': '*',
+          },
+        })
+      }
+
+      // SPA fallback
+      const indexFile = Bun.file(join(docsDir, 'index.html'))
+      if (await indexFile.exists()) {
+        return new Response(indexFile, {
+          headers: { 'Content-Type': 'text/html' },
+        })
+      }
+
+      return new Response('Not Found', { status: 404 })
+    },
+  })
+
+  console.log(`
+  TJS Playground running at http://localhost:${port}
+${
+  !noWatch
+    ? `
+  Watching for changes...`
+    : ''
+}
+
+  Press Ctrl+C to stop
+`)
+
+  // Graceful shutdown
+  process.on('SIGINT', () => {
+    console.log('\nShutting down...')
+    watchers.forEach((w) => w.close())
+    server.stop()
+    process.exit(0)
+  })
+}
+
+main()

package/src/cli/tjs.ts

@@ -0,0 +1,166 @@
+#!/usr/bin/env bun
+/**
+ * TJS CLI - Command line interface for Typed JavaScript
+ *
+ * Commands:
+ *   tjs check <file>   - Parse and type check, report errors
+ *   tjs run <file>     - Transpile to JS and execute
+ *   tjs types <file>   - Output type metadata as JSON
+ *   tjs emit <file>    - Output transpiled JavaScript
+ *
+ * Options:
+ *   --help, -h         - Show help
+ *   --version, -v      - Show version
+ */
+
+import { check } from './commands/check'
+import { run } from './commands/run'
+import { types } from './commands/types'
+import { emit } from './commands/emit'
+import { convert } from './commands/convert'
+import { test } from './commands/test'
+
+const VERSION = '0.1.0'
+
+const HELP = `
+tjs - Typed JavaScript CLI
+
+Usage:
+  tjs <command> [options] <file>
+
+Commands:
+  check <file>    Parse and type check a TJS file
+  run <file>      Transpile and execute a TJS file
+  types <file>    Output type metadata as JSON
+  emit <file>     Output transpiled JavaScript (+ docs)
+  test [file]     Run .test.tjs test files
+  convert <src>   Convert TypeScript files to TJS
+
+Options:
+  -h, --help      Show this help message
+  -v, --version   Show version
+  --debug         Include source locations in __tjs metadata (emit command)
+  --unsafe        Strip __tjs metadata for production builds (emit command)
+  --no-docs       Suppress documentation generation (emit command)
+  --docs-dir <d>  Output docs to separate directory (emit command)
+  --jfdi          Emit even if tests fail (just fucking do it)
+  -o <path>       Output path (for emit, convert commands)
+  -t <pattern>    Test name pattern (for test command)
+  --verbose, -V   Verbose output
+
+Examples:
+  tjs check src/utils.tjs
+  tjs run examples/hello.tjs
+  tjs types lib/api.tjs > api-types.json
+  tjs emit src/utils.tjs > dist/utils.js
+  tjs emit --debug src/utils.tjs > dist/utils.debug.js
+  tjs emit src/ -o dist/              # Emit all .tjs files in directory
+  tjs emit --unsafe src/ -o dist/     # Emit without validation (production)
+  tjs test                            # Run all .test.tjs files
+  tjs test src/lib/                   # Run tests in directory
+  tjs test -t "validation"            # Run tests matching pattern
+  tjs convert src/ -o src-tjs/        # Convert TS files to TJS
+`
+
+async function main() {
+  const args = process.argv.slice(2)
+
+  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+    console.log(HELP)
+    process.exit(0)
+  }
+
+  if (args.includes('--version') || args.includes('-v')) {
+    console.log(`tjs v${VERSION}`)
+    process.exit(0)
+  }
+
+  // Parse flags
+  const debug = args.includes('--debug')
+  const verbose = args.includes('--verbose') || args.includes('-V')
+  const unsafe = args.includes('--unsafe')
+  const noDocs = args.includes('--no-docs')
+  const jfdi = args.includes('--jfdi')
+
+  // Parse -o <output> option
+  const outputIdx = args.findIndex((a) => a === '-o' || a === '--output')
+  const output = outputIdx !== -1 ? args[outputIdx + 1] : undefined
+
+  // Parse --docs-dir <dir> option
+  const docsDirIdx = args.findIndex((a) => a === '--docs-dir')
+  const docsDir = docsDirIdx !== -1 ? args[docsDirIdx + 1] : undefined
+
+  // Parse -t <pattern> option for test command
+  const patternIdx = args.findIndex(
+    (a) => a === '-t' || a === '--test-name-pattern'
+  )
+  const testPattern = patternIdx !== -1 ? args[patternIdx + 1] : undefined
+
+  // Filter out flag arguments
+  const filteredArgs = args.filter((a, i) => {
+    if (a.startsWith('--') || a.startsWith('-')) return false
+    // Skip values that follow -o, -t, or --docs-dir
+    if (
+      i > 0 &&
+      (args[i - 1] === '-o' ||
+        args[i - 1] === '--output' ||
+        args[i - 1] === '-t' ||
+        args[i - 1] === '--test-name-pattern' ||
+        args[i - 1] === '--docs-dir')
+    )
+      return false
+    return true
+  })
+
+  const command = filteredArgs[0]
+  const file = filteredArgs[1]
+
+  // Some commands don't require a file argument
+  const noFileRequired = ['test']
+
+  if (!file && !noFileRequired.includes(command)) {
+    console.error(`Error: No file specified for command '${command}'`)
+    console.error(`Usage: tjs ${command} <file>`)
+    process.exit(1)
+  }
+
+  try {
+    switch (command) {
+      case 'check':
+        await check(file)
+        break
+      case 'run':
+        await run(file)
+        break
+      case 'types':
+        await types(file)
+        break
+      case 'emit':
+        await emit(file, {
+          debug,
+          unsafe,
+          output,
+          verbose,
+          noDocs,
+          docsDir,
+          jfdi,
+        })
+        break
+      case 'test':
+        await test(file, { pattern: testPattern })
+        break
+      case 'convert':
+        await convert(file, { output, verbose })
+        break
+      default:
+        console.error(`Error: Unknown command '${command}'`)
+        console.error(`Run 'tjs --help' for usage`)
+        process.exit(1)
+    }
+  } catch (error: any) {
+    console.error(`Error: ${error.message}`)
+    process.exit(1)
+  }
+}
+
+main()