code-the-jewels 0.1.0

package/src/ast.ts

@@ -0,0 +1,189 @@
+export interface Location {
+  line: number;
+  column: number;
+}
+
+export type Statement =
+  | VarDecl
+  | FunctionDecl
+  | ReturnStmt
+  | TalkStmt
+  | IfStmt
+  | LoopStmt
+  | ImportStmt
+  | ThrowStmt
+  | ExpressionStmt
+  | BlockStmt;
+
+export type Expression =
+  | Identifier
+  | StringLiteral
+  | NumberLiteral
+  | BooleanLiteral
+  | NullLiteral
+  | ArrayLiteral
+  | ObjectLiteral
+  | BinaryExpr
+  | UnaryExpr
+  | CallExpr
+  | MemberExpr
+  | PipeExpr
+  | DuoExpr;
+
+export interface Program {
+  type: 'Program';
+  body: Statement[];
+}
+
+export interface VarDecl {
+  type: 'VarDecl';
+  name: string;
+  init: Expression;
+  loc: Location;
+}
+
+export interface FunctionDecl {
+  type: 'FunctionDecl';
+  name: string;
+  params: string[];
+  body: BlockStmt;
+  loc: Location;
+}
+
+export interface ReturnStmt {
+  type: 'ReturnStmt';
+  value?: Expression;
+  loc: Location;
+}
+
+export interface TalkStmt {
+  type: 'TalkStmt';
+  value: Expression;
+  loc: Location;
+}
+
+export interface IfStmt {
+  type: 'IfStmt';
+  condition: Expression;
+  consequent: BlockStmt;
+  alternate?: BlockStmt;
+  loc: Location;
+}
+
+export interface LoopStmt {
+  type: 'LoopStmt';
+  variable: string;
+  iterable: Expression;
+  body: BlockStmt;
+  loc: Location;
+}
+
+export interface ImportStmt {
+  type: 'ImportStmt';
+  names: string[];
+  source: string;
+  loc: Location;
+}
+
+export interface ThrowStmt {
+  type: 'ThrowStmt';
+  value: Expression;
+  loc: Location;
+}
+
+export interface ExpressionStmt {
+  type: 'ExpressionStmt';
+  expr: Expression;
+  loc: Location;
+}
+
+export interface BlockStmt {
+  type: 'BlockStmt';
+  body: Statement[];
+  loc: Location;
+}
+
+export interface Identifier {
+  type: 'Identifier';
+  name: string;
+  loc: Location;
+}
+
+export interface StringLiteral {
+  type: 'StringLiteral';
+  value: string;
+  loc: Location;
+}
+
+export interface NumberLiteral {
+  type: 'NumberLiteral';
+  value: number;
+  loc: Location;
+}
+
+export interface BooleanLiteral {
+  type: 'BooleanLiteral';
+  value: boolean;
+  loc: Location;
+}
+
+export interface NullLiteral {
+  type: 'NullLiteral';
+  loc: Location;
+}
+
+export interface ArrayLiteral {
+  type: 'ArrayLiteral';
+  elements: Expression[];
+  loc: Location;
+}
+
+export interface ObjectLiteral {
+  type: 'ObjectLiteral';
+  pairs: { key: string; value: Expression }[];
+  loc: Location;
+}
+
+export interface BinaryExpr {
+  type: 'BinaryExpr';
+  op: string;
+  left: Expression;
+  right: Expression;
+  loc: Location;
+}
+
+export interface UnaryExpr {
+  type: 'UnaryExpr';
+  op: string;
+  operand: Expression;
+  loc: Location;
+}
+
+export interface CallExpr {
+  type: 'CallExpr';
+  callee: Expression;
+  args: Expression[];
+  loc: Location;
+}
+
+export interface MemberExpr {
+  type: 'MemberExpr';
+  object: Expression;
+  property: Expression;
+  computed: boolean;
+  loc: Location;
+}
+
+export interface PipeExpr {
+  type: 'PipeExpr';
+  steps: Expression[];
+  loc: Location;
+}
+
+export interface DuoExpr {
+  type: 'DuoExpr';
+  input: Expression;
+  mikePipeline: Expression[];
+  elPipeline: Expression[];
+  loc: Location;
+}

package/src/cli.ts

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { Lexer } from './lexer';
+import { Parser } from './parser';
+import { Semantic } from './semantic';
+import { Generator } from './generator';
+import { RTJError } from './diagnostics';
+import { startRepl } from './repl';
+
+function compile(source: string): string {
+  const lexer = new Lexer(source);
+  const tokens = lexer.tokenize();
+  const parser = new Parser(tokens);
+  const ast = parser.parse();
+  const semantic = new Semantic();
+  semantic.analyze(ast);
+  const gen = new Generator();
+  return gen.generate(ast);
+}
+
+function resolveRuntimePath(): string {
+  // When running from dist/, runtime is at dist/runtime/rtj-core.js
+  // When running via ts-node, runtime is at src/runtime/rtj-core.ts
+  const distRuntime = path.join(__dirname, 'runtime', 'rtj-core');
+  return distRuntime;
+}
+
+function run(filePath: string): void {
+  const absPath = path.resolve(filePath);
+  if (!fs.existsSync(absPath)) {
+    console.error(`File not found: ${absPath}`);
+    process.exit(1);
+  }
+  const source = fs.readFileSync(absPath, 'utf-8');
+  let js = compile(source);
+
+  // Replace the generic runtime require with the actual path
+  const runtimePath = resolveRuntimePath().replace(/\\/g, '/');
+  js = js.replace(
+    'const __rtj = require("./runtime/rtj-core");',
+    `const __rtj = require("${runtimePath}");`
+  );
+
+  // Write to temp file and execute
+  const tmpFile = path.join(os.tmpdir(), `rtj_${Date.now()}_${Math.random().toString(36).slice(2)}.js`);
+  fs.writeFileSync(tmpFile, js, 'utf-8');
+  try {
+    require(tmpFile);
+  } finally {
+    fs.unlinkSync(tmpFile);
+  }
+}
+
+function compileToFile(filePath: string): void {
+  const absPath = path.resolve(filePath);
+  if (!fs.existsSync(absPath)) {
+    console.error(`File not found: ${absPath}`);
+    process.exit(1);
+  }
+  const source = fs.readFileSync(absPath, 'utf-8');
+  const js = compile(source);
+  const outPath = absPath.replace(/\.rtj$/, '.js');
+  fs.writeFileSync(outPath, js, 'utf-8');
+}
+
+function check(filePath: string): void {
+  const absPath = path.resolve(filePath);
+  if (!fs.existsSync(absPath)) {
+    console.error(`File not found: ${absPath}`);
+    process.exit(1);
+  }
+  const source = fs.readFileSync(absPath, 'utf-8');
+  compile(source); // throws on error
+}
+
+const [,, command, ...args] = process.argv;
+
+try {
+  switch (command) {
+    case 'run': {
+      if (!args[0]) {
+        console.error('Usage: rtj run <file.rtj>');
+        process.exit(1);
+      }
+      run(args[0]);
+      break;
+    }
+    case 'compile': {
+      if (!args[0]) {
+        console.error('Usage: rtj compile <file.rtj>');
+        process.exit(1);
+      }
+      compileToFile(args[0]);
+      break;
+    }
+    case 'check': {
+      if (!args[0]) {
+        console.error('Usage: rtj check <file.rtj>');
+        process.exit(1);
+      }
+      check(args[0]);
+      break;
+    }
+    case 'repl': {
+      startRepl();
+      break;
+    }
+    default: {
+      console.log('Usage: rtj <run|compile|check|repl> [file]');
+    }
+  }
+} catch (err) {
+  if (err instanceof RTJError) {
+    console.error(err.format());
+    process.exit(1);
+  }
+  throw err;
+}

package/src/diagnostics.ts

@@ -0,0 +1,15 @@
+export class RTJError extends Error {
+  constructor(
+    public kind: 'SyntaxError' | 'NameError' | 'ImportError' | 'DuoError' | 'RuntimeError',
+    message: string,
+    public line?: number,
+    public column?: number
+  ) {
+    super(message);
+  }
+
+  format(): string {
+    const loc = this.line ? ` near line ${this.line}` : '';
+    return `${this.kind}: ${this.message}${loc}`;
+  }
+}

package/src/generator.ts

@@ -0,0 +1,129 @@
+import { Program, Statement, Expression } from './ast';
+
+export class Generator {
+  private indent: number = 0;
+
+  generate(program: Program): string {
+    const lines: string[] = [
+      '"use strict";',
+      'const __rtj = require("./runtime/rtj-core");',
+      'const __modules = __rtj.modules;',
+      '',
+    ];
+
+    for (const stmt of program.body) {
+      lines.push(this.genStatement(stmt));
+    }
+
+    return lines.join('\n') + '\n';
+  }
+
+  private pad(): string {
+    return '  '.repeat(this.indent);
+  }
+
+  private genStatement(stmt: Statement): string {
+    switch (stmt.type) {
+      case 'VarDecl':
+        return `${this.pad()}const ${stmt.name} = ${this.genExpression(stmt.init)};`;
+      case 'FunctionDecl': {
+        const params = stmt.params.join(', ');
+        const body = this.genBlock(stmt.body);
+        return `${this.pad()}function ${stmt.name}(${params}) ${body}`;
+      }
+      case 'ReturnStmt':
+        return stmt.value
+          ? `${this.pad()}return ${this.genExpression(stmt.value)};`
+          : `${this.pad()}return;`;
+      case 'TalkStmt':
+        return `${this.pad()}__rtj.talk(${this.genExpression(stmt.value)});`;
+      case 'IfStmt': {
+        let result = `${this.pad()}if (${this.genExpression(stmt.condition)}) ${this.genBlock(stmt.consequent)}`;
+        if (stmt.alternate) {
+          result += ` else ${this.genBlock(stmt.alternate)}`;
+        }
+        return result;
+      }
+      case 'LoopStmt':
+        return `${this.pad()}for (const ${stmt.variable} of ${this.genExpression(stmt.iterable)}) ${this.genBlock(stmt.body)}`;
+      case 'ImportStmt': {
+        const names = stmt.names.join(', ');
+        return `${this.pad()}const { ${names} } = __modules["${stmt.source}"];`;
+      }
+      case 'ThrowStmt':
+        return `${this.pad()}throw new Error(${this.genExpression(stmt.value)});`;
+      case 'ExpressionStmt':
+        return `${this.pad()}${this.genExpression(stmt.expr)};`;
+      case 'BlockStmt':
+        return this.genBlock(stmt);
+    }
+  }
+
+  private genBlock(block: { body: Statement[] }): string {
+    const lines: string[] = ['{'];
+    this.indent++;
+    for (const stmt of block.body) {
+      lines.push(this.genStatement(stmt));
+    }
+    this.indent--;
+    lines.push(`${this.pad()}}`);
+    return lines.join('\n');
+  }
+
+  private genExpression(expr: Expression): string {
+    switch (expr.type) {
+      case 'Identifier':
+        return expr.name;
+      case 'StringLiteral':
+        return JSON.stringify(expr.value);
+      case 'NumberLiteral':
+        return String(expr.value);
+      case 'BooleanLiteral':
+        return String(expr.value);
+      case 'NullLiteral':
+        return 'null';
+      case 'ArrayLiteral':
+        return `[${expr.elements.map(e => this.genExpression(e)).join(', ')}]`;
+      case 'ObjectLiteral': {
+        const pairs = expr.pairs.map(p => `${JSON.stringify(p.key)}: ${this.genExpression(p.value)}`);
+        return `{ ${pairs.join(', ')} }`;
+      }
+      case 'BinaryExpr':
+        return `(${this.genExpression(expr.left)} ${expr.op} ${this.genExpression(expr.right)})`;
+      case 'UnaryExpr':
+        return `(${expr.op}${this.genExpression(expr.operand)})`;
+      case 'CallExpr': {
+        const callee = this.genExpression(expr.callee);
+        const args = expr.args.map(a => this.genExpression(a)).join(', ');
+        return `${callee}(${args})`;
+      }
+      case 'MemberExpr':
+        if (expr.computed) {
+          return `${this.genExpression(expr.object)}[${this.genExpression(expr.property)}]`;
+        }
+        return `${this.genExpression(expr.object)}.${this.genExpression(expr.property)}`;
+      case 'PipeExpr':
+        return this.flattenPipe(expr.steps);
+      case 'DuoExpr': {
+        const allSteps = [...expr.mikePipeline, ...expr.elPipeline];
+        const initial = this.genExpression(expr.input);
+        return this.flattenPipeFromStrings(initial, allSteps);
+      }
+    }
+  }
+
+  private flattenPipe(steps: Expression[]): string {
+    if (steps.length === 0) return '';
+    if (steps.length === 1) return this.genExpression(steps[0]);
+    const initial = this.genExpression(steps[0]);
+    return this.flattenPipeFromStrings(initial, steps.slice(1));
+  }
+
+  private flattenPipeFromStrings(initial: string, fns: Expression[]): string {
+    let result = initial;
+    for (const fn of fns) {
+      result = `${this.genExpression(fn)}(${result})`;
+    }
+    return result;
+  }
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export { Lexer } from './lexer';
+export { Parser } from './parser';
+export { Semantic } from './semantic';
+export { Generator } from './generator';
+export { RTJError } from './diagnostics';
+export { TokenType } from './token';
+export type { Token } from './token';

package/src/lexer.ts

@@ -0,0 +1,208 @@
+import { Token, TokenType, KEYWORDS } from './token';
+import { RTJError } from './diagnostics';
+
+export class Lexer {
+  private source: string;
+  private pos: number = 0;
+  private line: number = 1;
+  private col: number = 1;
+
+  constructor(source: string) {
+    this.source = source;
+  }
+
+  tokenize(): Token[] {
+    const tokens: Token[] = [];
+
+    while (this.pos < this.source.length) {
+      const ch = this.source[this.pos];
+
+      // Skip whitespace (not newlines)
+      if (ch === ' ' || ch === '\t' || ch === '\r') {
+        this.advance();
+        continue;
+      }
+
+      // Newlines
+      if (ch === '\n') {
+        this.advance();
+        this.line++;
+        this.col = 1;
+        continue;
+      }
+
+      // Line comments
+      if (ch === '/' && this.peek(1) === '/') {
+        while (this.pos < this.source.length && this.source[this.pos] !== '\n') {
+          this.advance();
+        }
+        continue;
+      }
+
+      // Block comments
+      if (ch === '/' && this.peek(1) === '*') {
+        this.advance();
+        this.advance();
+        while (this.pos < this.source.length) {
+          if (this.source[this.pos] === '*' && this.peek(1) === '/') {
+            this.advance();
+            this.advance();
+            break;
+          }
+          if (this.source[this.pos] === '\n') {
+            this.line++;
+            this.col = 0;
+          }
+          this.advance();
+        }
+        continue;
+      }
+
+      // Strings
+      if (ch === '"' || ch === "'") {
+        tokens.push(this.readString(ch));
+        continue;
+      }
+
+      // Numbers
+      if (this.isDigit(ch)) {
+        tokens.push(this.readNumber());
+        continue;
+      }
+
+      // Identifiers / keywords
+      if (this.isAlpha(ch)) {
+        tokens.push(this.readIdentifier());
+        continue;
+      }
+
+      // Pipe operator |>
+      if (ch === '|' && this.peek(1) === '>') {
+        tokens.push(this.makeToken(TokenType.PIPE, '|>', 2));
+        continue;
+      }
+
+      // Two-char operators
+      if (ch === '=' && this.peek(1) === '=') { tokens.push(this.makeToken(TokenType.EQ_EQ, '==', 2)); continue; }
+      if (ch === '!' && this.peek(1) === '=') { tokens.push(this.makeToken(TokenType.BANG_EQ, '!=', 2)); continue; }
+      if (ch === '>' && this.peek(1) === '=') { tokens.push(this.makeToken(TokenType.GT_EQ, '>=', 2)); continue; }
+      if (ch === '<' && this.peek(1) === '=') { tokens.push(this.makeToken(TokenType.LT_EQ, '<=', 2)); continue; }
+      if (ch === '&' && this.peek(1) === '&') { tokens.push(this.makeToken(TokenType.AND_AND, '&&', 2)); continue; }
+      if (ch === '|' && this.peek(1) === '|') { tokens.push(this.makeToken(TokenType.OR_OR, '||', 2)); continue; }
+
+      // Single-char tokens
+      const singles: Record<string, TokenType> = {
+        '+': TokenType.PLUS,
+        '-': TokenType.MINUS,
+        '*': TokenType.STAR,
+        '/': TokenType.SLASH,
+        '%': TokenType.PERCENT,
+        '>': TokenType.GT,
+        '<': TokenType.LT,
+        '!': TokenType.BANG,
+        '=': TokenType.ASSIGN,
+        '{': TokenType.LBRACE,
+        '}': TokenType.RBRACE,
+        '(': TokenType.LPAREN,
+        ')': TokenType.RPAREN,
+        '[': TokenType.LBRACKET,
+        ']': TokenType.RBRACKET,
+        ',': TokenType.COMMA,
+        ':': TokenType.COLON,
+        '.': TokenType.DOT,
+        ';': TokenType.SEMICOLON,
+      };
+
+      if (singles[ch]) {
+        tokens.push(this.makeToken(singles[ch], ch, 1));
+        continue;
+      }
+
+      throw new RTJError('SyntaxError', `unexpected character '${ch}'`, this.line, this.col);
+    }
+
+    tokens.push({ type: TokenType.EOF, value: '', line: this.line, column: this.col });
+    return tokens;
+  }
+
+  private advance(): void {
+    this.pos++;
+    this.col++;
+  }
+
+  private peek(offset: number): string | undefined {
+    return this.source[this.pos + offset];
+  }
+
+  private makeToken(type: TokenType, value: string, length: number): Token {
+    const token: Token = { type, value, line: this.line, column: this.col };
+    for (let i = 0; i < length; i++) this.advance();
+    return token;
+  }
+
+  private isDigit(ch: string): boolean {
+    return ch >= '0' && ch <= '9';
+  }
+
+  private isAlpha(ch: string): boolean {
+    return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch === '_';
+  }
+
+  private isAlphaNumeric(ch: string): boolean {
+    return this.isAlpha(ch) || this.isDigit(ch);
+  }
+
+  private readString(quote: string): Token {
+    const startCol = this.col;
+    this.advance(); // skip opening quote
+    let value = '';
+    while (this.pos < this.source.length && this.source[this.pos] !== quote) {
+      if (this.source[this.pos] === '\\') {
+        this.advance();
+        const esc = this.source[this.pos];
+        if (esc === 'n') value += '\n';
+        else if (esc === 't') value += '\t';
+        else if (esc === '\\') value += '\\';
+        else if (esc === quote) value += quote;
+        else value += '\\' + esc;
+      } else {
+        value += this.source[this.pos];
+      }
+      this.advance();
+    }
+    if (this.pos >= this.source.length) {
+      throw new RTJError('SyntaxError', 'unterminated string', this.line, startCol);
+    }
+    this.advance(); // skip closing quote
+    return { type: TokenType.STRING, value, line: this.line, column: startCol };
+  }
+
+  private readNumber(): Token {
+    const startCol = this.col;
+    let value = '';
+    while (this.pos < this.source.length && this.isDigit(this.source[this.pos])) {
+      value += this.source[this.pos];
+      this.advance();
+    }
+    if (this.pos < this.source.length && this.source[this.pos] === '.' && this.peek(1) && this.isDigit(this.peek(1)!)) {
+      value += '.';
+      this.advance();
+      while (this.pos < this.source.length && this.isDigit(this.source[this.pos])) {
+        value += this.source[this.pos];
+        this.advance();
+      }
+    }
+    return { type: TokenType.NUMBER, value, line: this.line, column: startCol };
+  }
+
+  private readIdentifier(): Token {
+    const startCol = this.col;
+    let value = '';
+    while (this.pos < this.source.length && this.isAlphaNumeric(this.source[this.pos])) {
+      value += this.source[this.pos];
+      this.advance();
+    }
+    const type = KEYWORDS[value] || TokenType.IDENTIFIER;
+    return { type, value, line: this.line, column: startCol };
+  }
+}