Transpiler Phase 2: Input System & Built-in Variables #16

Copilot · 2025-11-30T21:37:05Z

Adds PineScript v6 input functions and built-in variables to the oakscript-engine transpiler, enabling customizable indicators with user-configurable parameters.

Input Functions

input.int(), input.float(), input.bool(), input.string(), input.color(), input.source()
Generates TypeScript IndicatorInputs interface with proper types
Union types for options arrays in input.string()
Function signature updated to accept Partial<IndicatorInputs>

length = input.int(14, "Length", minval=1)
maType = input.string("SMA", "Type", options=["SMA", "EMA", "WMA"])

export interface IndicatorInputs {
  length: number;
  maType: "SMA" | "EMA" | "WMA";
}
export function MyIndicator(bars: any[], inputs: Partial<IndicatorInputs> = {})

Built-in Variables

Price sources: hl2, hlc3, ohlc4, hlcc4 as Series calculations
Time series: year, month, dayofmonth, dayofweek, hour, minute
Bar state: barstate.isfirst → (i === 0), barstate.islast → (i === bars.length - 1)
Symbol info: syminfo.ticker, syminfo.mintick, etc. (generates interface when used)
Timeframe: timeframe.period, timeframe.isintraday, etc.

Helper Functions

na() and nz() generated as local helpers in output

Parser

Added ArrayLiteral node type for parsing [...] in options parameter

Original prompt

Transpiler Phase 2: Input System & Built-in Variables

Objective

Enhance the oakscript-engine transpiler to support PineScript v6 input functions and built-in variables, enabling customizable indicators with user-configurable parameters.

Context

Phase 1 has been merged and the transpiler now supports:

✅ Basic expressions & operators
✅ Variable declarations (var, := reassignment)
✅ if/else blocks, for/while loops, switch expressions
✅ History operator [n], tuple destructuring, break/continue

Features to Implement

1. Input Functions (Critical)

`input.int()`

length = input.int(14, "Length", minval=1, maxval=100)
period = input.int(title="Period", defval=20)

`input.float()`

multiplier = input.float(2.0, "Multiplier", minval=0.1, maxval=10.0, step=0.1)

`input.bool()`

showMA = input.bool(true, "Show Moving Average")

`input.string()`

maType = input.string("SMA", "MA Type", options=["SMA", "EMA", "WMA", "HMA"])

`input.color()`

bullColor = input.color(color.green, "Bull Color")

`input.source()`

src = input.source(close, "Source")

TypeScript output - generate interface:

export interface IndicatorInputs {
  length: number;
  multiplier: number;
  showMA: boolean;
  maType: "SMA" | "EMA" | "WMA" | "HMA";
  bullColor: string;
  src: "open" | "high" | "low" | "close" | "hl2" | "hlc3" | "ohlc4";
}

const defaultInputs: IndicatorInputs = {
  length: 14,
  multiplier: 2.0,
  showMA: true,
  maType: "SMA",
  bullColor: "#00FF00",
  src: "close",
};

export function MyIndicator(bars: Bar[], inputs: Partial<IndicatorInputs> = {}): IndicatorResult {
  const { length, multiplier, showMA, maType, bullColor, src } = { ...defaultInputs, ...inputs };
  // ...
}

2. Calculated Price Sources

hl2    // (high + low) / 2
hlc3   // (high + low + close) / 3
ohlc4  // (open + high + low + close) / 4
hlcc4  // (high + low + close + close) / 4

TypeScript output:

const hl2 = high.add(low).div(2);
const hlc3 = high.add(low).add(close).div(3);
const ohlc4 = open.add(high).add(low).add(close).div(4);
const hlcc4 = high.add(low).add(close).add(close).div(4);

3. `bar_index` and `barstate.*` Variables

if barstate.isfirst
    // First bar logic
if barstate.islast
    // Last bar logic
position = bar_index

TypeScript output:

const bar_index = i;  // current index
const last_bar_index = bars.length - 1;
const barstate = {
  isfirst: bar_index === 0,
  islast: bar_index === bars.length - 1,
  isconfirmed: true,
  islastconfirmedhistory: bar_index === bars.length - 1,
  isrealtime: false,
  isnew: true,
};

4. Time Variables

y = year
m = month
d = dayofmonth
dow = dayofweek
h = hour

TypeScript output:

const year = new Series(bars, (bar) => new Date(bar.time).getFullYear());
const month = new Series(bars, (bar) => new Date(bar.time).getMonth() + 1);
const dayofmonth = new Series(bars, (bar) => new Date(bar.time).getDate());
const dayofweek = new Series(bars, (bar) => new Date(bar.time).getDay() + 1);
const hour = new Series(bars, (bar) => new Date(bar.time).getHours());
const minute = new Series(bars, (bar) => new Date(bar.time).getMinutes());

5. Symbol Info Variables

ticker = syminfo.ticker
mintick = syminfo.mintick
currency = syminfo.currency

TypeScript output:

export interface SymbolInfo {
  ticker: string;
  tickerid: string;
  currency: string;
  mintick: number;
  pointvalue: number;
  type: string;
}

const defaultSyminfo: SymbolInfo = {
  ticker: "UNKNOWN",
  tickerid: "UNKNOWN", 
  currency: "USD",
  mintick: 0.01,
  pointvalue: 1,
  type: "stock",
};

export function MyIndicator(
  bars: Bar[], 
  inputs?: Partial<IndicatorInputs>,
  syminfo?: Partial<SymbolInfo>
): IndicatorResult {
  const symbolInfo = { ...defaultSyminfo, ...syminfo };
  // ...
}

6. Timeframe Variables

tf = timeframe.period
isIntraday = timeframe.isintraday
isDaily = timeframe.isdaily

TypeScript output:

export interface TimeframeInfo {
  period: string;
  multiplier: number;
  isintraday: boolean;
  isdaily: boolean;
  isweekly: boolean;
  ismonthly: boolean;
}

7. `na()` and `nz()` Functions (Critical)

if na(close[100])
    // Handle missing data
safeValue = nz(value)
safeValue = nz(value, -1)

TypeScript output:

function na(value: number | null | undefined): boolean {
  return value === null || value === undefined || Number.isNaN(value);
}

function nz(value: number, replacement: number = 0): number {
  return na(value) ? replacement : value;
}

Test Cases

test-inputs.pine

//@version=6
indicator("Input Test", overlay=true)

length = input.int(14, "Length", minval=1, maxval=...

</details>

*This pull request was created as a result of the following prompt from Copilot chat.*
> # Transpiler Phase 2: Input System & Built-in Variables
> 
> ## Objective
> Enhance the oakscript-engine transpiler to support PineScript v6 input functions and built-in variables, enabling customizable indicators with user-configurable parameters.
> 
> ## Context
> Phase 1 has been merged and the transpiler now supports:
> - ✅ Basic expressions & operators
> - ✅ Variable declarations (`var`, `:=` reassignment)
> - ✅ `if`/`else` blocks, `for`/`while` loops, `switch` expressions
> - ✅ History operator `[n]`, tuple destructuring, `break`/`continue`
> 
> ## Features to Implement
> 
> ### 1. Input Functions (Critical)
> 
> #### `input.int()`
> ```pinescript
> length = input.int(14, "Length", minval=1, maxval=100)
> period = input.int(title="Period", defval=20)
> ```
> 
> #### `input.float()`
> ```pinescript
> multiplier = input.float(2.0, "Multiplier", minval=0.1, maxval=10.0, step=0.1)
> ```
> 
> #### `input.bool()`
> ```pinescript
> showMA = input.bool(true, "Show Moving Average")
> ```
> 
> #### `input.string()`
> ```pinescript
> maType = input.string("SMA", "MA Type", options=["SMA", "EMA", "WMA", "HMA"])
> ```
> 
> #### `input.color()`
> ```pinescript
> bullColor = input.color(color.green, "Bull Color")
> ```
> 
> #### `input.source()`
> ```pinescript
> src = input.source(close, "Source")
> ```
> 
> **TypeScript output - generate interface:**
> ```typescript
> export interface IndicatorInputs {
>   length: number;
>   multiplier: number;
>   showMA: boolean;
>   maType: "SMA" | "EMA" | "WMA" | "HMA";
>   bullColor: string;
>   src: "open" | "high" | "low" | "close" | "hl2" | "hlc3" | "ohlc4";
> }
> 
> const defaultInputs: IndicatorInputs = {
>   length: 14,
>   multiplier: 2.0,
>   showMA: true,
>   maType: "SMA",
>   bullColor: "#00FF00",
>   src: "close",
> };
> 
> export function MyIndicator(bars: Bar[], inputs: Partial<IndicatorInputs> = {}): IndicatorResult {
>   const { length, multiplier, showMA, maType, bullColor, src } = { ...defaultInputs, ...inputs };
>   // ...
> }
> ```
> 
> ### 2. Calculated Price Sources
> ```pinescript
> hl2    // (high + low) / 2
> hlc3   // (high + low + close) / 3
> ohlc4  // (open + high + low + close) / 4
> hlcc4  // (high + low + close + close) / 4
> ```
> 
> **TypeScript output:**
> ```typescript
> const hl2 = high.add(low).div(2);
> const hlc3 = high.add(low).add(close).div(3);
> const ohlc4 = open.add(high).add(low).add(close).div(4);
> const hlcc4 = high.add(low).add(close).add(close).div(4);
> ```
> 
> ### 3. `bar_index` and `barstate.*` Variables
> ```pinescript
> if barstate.isfirst
>     // First bar logic
> if barstate.islast
>     // Last bar logic
> position = bar_index
> ```
> 
> **TypeScript output:**
> ```typescript
> const bar_index = i;  // current index
> const last_bar_index = bars.length - 1;
> const barstate = {
>   isfirst: bar_index === 0,
>   islast: bar_index === bars.length - 1,
>   isconfirmed: true,
>   islastconfirmedhistory: bar_index === bars.length - 1,
>   isrealtime: false,
>   isnew: true,
> };
> ```
> 
> ### 4. Time Variables
> ```pinescript
> y = year
> m = month
> d = dayofmonth
> dow = dayofweek
> h = hour
> ```
> 
> **TypeScript output:**
> ```typescript
> const year = new Series(bars, (bar) => new Date(bar.time).getFullYear());
> const month = new Series(bars, (bar) => new Date(bar.time).getMonth() + 1);
> const dayofmonth = new Series(bars, (bar) => new Date(bar.time).getDate());
> const dayofweek = new Series(bars, (bar) => new Date(bar.time).getDay() + 1);
> const hour = new Series(bars, (bar) => new Date(bar.time).getHours());
> const minute = new Series(bars, (bar) => new Date(bar.time).getMinutes());
> ```
> 
> ### 5. Symbol Info Variables
> ```pinescript
> ticker = syminfo.ticker
> mintick = syminfo.mintick
> currency = syminfo.currency
> ```
> 
> **TypeScript output:**
> ```typescript
> export interface SymbolInfo {
>   ticker: string;
>   tickerid: string;
>   currency: string;
>   mintick: number;
>   pointvalue: number;
>   type: string;
> }
> 
> const defaultSyminfo: SymbolInfo = {
>   ticker: "UNKNOWN",
>   tickerid: "UNKNOWN", 
>   currency: "USD",
>   mintick: 0.01,
>   pointvalue: 1,
>   type: "stock",
> };
> 
> export function MyIndicator(
>   bars: Bar[], 
>   inputs?: Partial<IndicatorInputs>,
>   syminfo?: Partial<SymbolInfo>
> ): IndicatorResult {
>   const symbolInfo = { ...defaultSyminfo, ...syminfo };
>   // ...
> }
> ```
> 
> ### 6. Timeframe Variables
> ```pinescript
> tf = timeframe.period
> isIntraday = timeframe.isintraday
> isDaily = timeframe.isdaily
> ```
> 
> **TypeScript output:**
> ```typescript
> export interface TimeframeInfo {
>   period: string;
>   multiplier: number;
>   isintraday: boolean;
>   isdaily: boolean;
>   isweekly: boolean;
>   ismonthly: boolean;
> }
> ```
> 
> ### 7. `na()` and `nz()` Functions (Critical)
> ```pinescript
> if na(close[100])
>     // Handle missing data
> safeValue = nz(value)
> safeValue = nz(value, -1)
> ```
> 
> **TypeScript output:**
> ```typescript
> function na(value: number | null | undefined): boolean {
>   return value === null || value === undefined || Number.isNaN(value);
> }
> 
> function nz(value: number, replacement: number = 0): number {
>   return na(value) ? replacement : value;
> }
> ```
> 
> ## Test Cases
> 
> ### test-inputs.pine
> ```pinescript
> //@version=6
> indicator("Input Test", overlay=true)
> 
> length = input.int(14, "Length", minval=1, maxval=200)
> multiplier = input.float(2.0, "Multiplier")
> showBands = input.bool(true, "Show Bands")
> maType = input.string("EMA", "MA Type", options=["SMA", "EMA", "WMA"])
> src = input.source(close, "Source")
> 
> ma = switch maType
>     "SMA" => ta.sma(src, length)
>     "EMA" => ta.ema(src, length)
>     "WMA" => ta.wma(src, length)
> 
> plot(ma)
> ```
> 
> ### test-barstate.pine
> ```pinescript
> //@version=6
> indicator("Barstate Test")
> 
> var float firstClose = na
> if barstate.isfirst
>     firstClose := close
> 
> plot(firstClose)
> plot(bar_index)
> ```
> 
> ### test-time.pine
> ```pinescript
> //@version=6
> indicator("Time Test")
> 
> isMonday = dayofweek == 2
> isMarketOpen = hour >= 9 and hour < 16
> 
> bgcolor(isMonday ? color.new(color.blue, 90) : na)
> plot(hour)
> ```
> 
> ## Files to Modify
> 
> 1. `packages/oakscript-engine/src/transpiler/PineParser.ts` - Parse input.* functions
> 2. `packages/oakscript-engine/src/transpiler/PineToTS.ts` - Generate interfaces, handle built-ins
> 3. `packages/oakscript-engine/src/transpiler/types.ts` - Add new types
> 4. `packages/oakscript-engine/tests/` - Add test cases
> 
> ## Success Criteria
> 
> 1. All input types parse and generate correct TypeScript interfaces
> 2. Default values extracted correctly
> 3. Built-in variables (barstate, syminfo, timeframe, time) work
> 4. `na()` and `nz()` functions work correctly
> 5. Generated code compiles and runs correctly

<!-- START COPILOT CODING AGENT TIPS -->
---

💡 You can make Copilot smarter by setting up custom instructions, customizing its development environment and configuring Model Context Protocol (MCP) servers. Learn more [Copilot coding agent tips](https://gh.io/copilot-coding-agent-tips) in the docs.

Co-authored-by: deepentropy <8287111+deepentropy@users.noreply.github.com>

chatgpt-codex-connector · 2025-11-30T22:03:45Z

You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard.
To continue using code reviews, you can upgrade your account or add credits to your account and enable them for code reviews in your settings.

Copilot

Pull request overview

This PR implements Phase 2 of the PineScript transpiler, adding support for input functions and built-in variables to enable user-configurable indicator parameters. The implementation adds input system handling, calculated price sources, time series, bar state variables, and helper functions for null handling.

Key Changes:

Input function parsing (input.int, input.float, input.bool, input.string, input.color, input.source) with TypeScript interface generation
Built-in variables for bar state (bar_index, barstate.*), time series (year, month, etc.), and metadata (syminfo.*, timeframe.*)
Helper functions na() and nz() for null/undefined handling
Array literal parsing support in the parser

Reviewed changes

Copilot reviewed 4 out of 4 changed files in this pull request and generated 6 comments.

File	Description
packages/oakscript-engine/src/transpiler/types.ts	Added type definitions for InputDefinition, SymbolInfo, TimeframeInfo, and SourceType
packages/oakscript-engine/src/transpiler/PineParser.ts	Added parseArrayLiteral() method to parse array syntax for input options parameter
packages/oakscript-engine/src/transpiler/PineToTS.ts	Core implementation: input parsing, interface generation, built-in variable translation, and helper function generation
packages/oakscript-engine/tests/transpiler-phase2.test.ts	Comprehensive test suite covering all Phase 2 features including inputs, built-ins, and integration tests

Comments suppressed due to low confidence (2)

packages/oakscript-engine/src/transpiler/PineToTS.ts:728

[nitpick] The generateAssignment function returns void but can be called from generateExpression (line 1000-1006) which expects a string return value. When an Assignment expression with an input.* function returns early (line 711), the caller in generateExpression will return an empty string, which is correct. However, when called directly as a statement (lines 696-728), the void return is appropriate. This dual usage pattern is correct, but consider adding a return type annotation to make the void return explicit: private generateAssignment(node: ASTNode): void.

  private generateAssignment(node: ASTNode): void {
    if (!node.children || node.children.length < 2) return;

    const left = node.children[0]!;
    const right = node.children[1]!;

    // Skip input.* function assignments - they're handled as function parameters
    if (right.type === 'FunctionCall') {
      const funcName = String(right.value || '');
      if (funcName.startsWith('input.')) {
        // Mark this variable as defined (it's a function parameter)
        if (left.type === 'Identifier') {
          const name = String(left.value || 'unknown');
          this.variables.set(name, name);
        }
        return;
      }
    }

    if (left.type === 'Identifier') {
      const name = String(left.value || 'unknown');
      const tsName = this.sanitizeIdentifier(name);
      
      if (!this.variables.has(name)) {
        this.variables.set(name, tsName);
        const rightExpr = this.generateExpression(right);
        this.emit(`const ${tsName} = ${rightExpr};`);
      } else {
        const rightExpr = this.generateExpression(right);
        this.emit(`${tsName} = ${rightExpr};`);
      }
    }
  }

packages/oakscript-engine/src/transpiler/PineParser.ts:803

Unused variable startPos.

      const startPos = this.position;

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

You can also share your feedback on Copilot code review for a chance to win a $100 gift card. Take the survey.

Copilot · 2025-11-30T22:08:40Z