OpenScript

A Modern AI-Powered Scripting Language for Automation and Development

OpenScript is a modern scripting language that seamlessly integrates artificial intelligence capabilities with traditional automation tools. Built in Rust for performance and safety, OpenScript combines the simplicity of shell scripting with the power of AI-driven development.

Features

Core Language Features

• Intuitive Syntax: JavaScript-like syntax that's easy to learn and write
• Dynamic Typing: Flexible type system with automatic type coercion
• First-class Functions: Support for closures, higher-order functions, and functional programming patterns
• Rich Data Types: Objects, arrays, strings, numbers, and booleans with comprehensive operations
• Control Flow: Full support for conditionals, loops, and error handling

AI Integration

• OpenAI Integration: Direct integration with OpenAI's GPT models for text generation, code completion, and analysis
• Smart Completion: AI-powered code suggestions and auto-completion
• Natural Language Processing: Built-in functions for text analysis and processing
• Code Generation: Generate code snippets and entire functions using AI prompts

System Integration

• HTTP Client: Built-in HTTP/HTTPS support with JSON handling
• File System: Comprehensive file and directory operations
• System Commands: Execute system commands and capture output
• Environment Variables: Full access to system environment
• Cross-Platform: Works on Windows, macOS, and Linux

Development Tools

• REPL: Interactive development environment
• Syntax Checking: Built-in syntax validation and error reporting
• Package Manager: Dependency management and library distribution
• Language Server: IDE integration with syntax highlighting and IntelliSense
• Debugging: Comprehensive debugging and profiling tools

Quick Start

Installation

From Crates.io

cargo install openscript_cli

From Source

git clone https://github.com/openscript-lang/openscript-rs.git
cd openscript-rs
cargo build --release

Your First Script

Create a file hello.os:

#!/usr/bin/env openscript

echo "Hello, OpenScript!"

# Variables and operations
let name = "Developer"
let greeting = "Welcome to OpenScript, " + name + "!"
echo greeting

# Functions
fn fibonacci(n) {
    if n <= 1 {
        return n
    } else {
        return fibonacci(n - 1) + fibonacci(n - 2)
    }
}

echo "Fibonacci(10): " + fibonacci(10)

# HTTP requests
let response = http_get("https://api.github.com/users/octocat")
if response.status == 200 {
    let user = json_parse(response.body)
    echo "GitHub user: " + user.name
}

# AI integration (requires OPENAI_API_KEY)
if env_get("OPENAI_API_KEY") != null {
    let ai_response = ai_complete("Explain the benefits of automation in software development")
    echo "AI says: " + ai_response
}

Run the script:

openscript run hello.os

Language Guide

Variables and Types

# Numbers
let age = 25
let pi = 3.14159

# Strings
let name = "OpenScript"
let multiline = """
This is a
multiline string
"""

# Booleans
let is_awesome = true
let is_ready = false

# Arrays
let numbers = [1, 2, 3, 4, 5]
let mixed = ["hello", 42, true, null]

# Objects
let user = {
    "name": "Alice",
    "age": 30,
    "skills": ["Rust", "JavaScript", "Python"]
}

Control Flow

# Conditionals
if age >= 18 {
    echo "Adult"
} else if age >= 13 {
    echo "Teenager"
} else {
    echo "Child"
}

# Loops
for i in 1..10 {
    echo "Number: " + i
}

for item in ["apple", "banana", "cherry"] {
    echo "Fruit: " + item
}

# While loops
let count = 0
while count < 5 {
    echo "Count: " + count
    count = count + 1
}

Functions

# Basic function
fn greet(name) {
    return "Hello, " + name + "!"
}

# Function with multiple parameters
fn calculate_area(width, height) {
    return width * height
}

# Higher-order functions
fn apply_operation(x, y, operation) {
    return operation(x, y)
}

let add = fn(a, b) { return a + b }
let result = apply_operation(5, 3, add)  # Returns 8

AI Integration

# Set your OpenAI API key
# export OPENAI_API_KEY="your-api-key-here"

# Simple completion
let response = ai_complete("Write a function to sort an array")
echo response

# Code generation
let code = ai_complete("Generate a Python function that reads a CSV file and returns a list of dictionaries")
write_file("generated_code.py", code)

# Text analysis
let text = "OpenScript is an innovative scripting language with AI capabilities."
let analysis = ai_complete("Analyze the sentiment and key themes in this text: " + text)
echo analysis

HTTP and API Integration

# GET request
let response = http_get("https://api.github.com/users/octocat")
if response.status == 200 {
    let data = json_parse(response.body)
    echo "User: " + data.name
    echo "Repos: " + data.public_repos
}

# POST request
let post_data = {
    "title": "Hello World",
    "body": "This is a test post",
    "userId": 1
}

let post_response = http_post(
    "https://jsonplaceholder.typicode.com/posts",
    json_stringify(post_data),
    {"Content-Type": "application/json"}
)

echo "Post created with ID: " + json_parse(post_response.body).id

File Operations

# Write to file
let data = {"name": "OpenScript", "version": "1.0.0"}
write_file("config.json", json_stringify(data))

# Read from file
let content = read_file("config.json")
let config = json_parse(content)
echo "App: " + config.name

# Directory operations
mkdir("temp")
let files = list_dir(".")
for file in files {
    echo "File: " + file + " (" + file_size(file) + " bytes)"
}

Built-in Functions

String Functions

• length(str) - Get string length
• upper(str) - Convert to uppercase
• lower(str) - Convert to lowercase
• trim(str) - Remove whitespace
• split(str, delimiter) - Split string into array
• join(array, delimiter) - Join array into string
• replace(str, old, new) - Replace text

Array Functions

• push(array, item) - Add item to array
• pop(array) - Remove last item
• sort(array) - Sort array
• reverse(array) - Reverse array
• filter(array, predicate) - Filter array
• map(array, function) - Transform array

Math Functions

• round(number) - Round to nearest integer
• floor(number) - Round down
• ceil(number) - Round up
• abs(number) - Absolute value
• min(a, b) - Minimum value
• max(a, b) - Maximum value
• random() - Random number 0-1

System Functions

• timestamp() - Current timestamp
• sleep(seconds) - Pause execution
• env_get(name) - Get environment variable
• exec(command) - Execute system command

CLI Usage

Interactive REPL

openscript repl

Run Scripts

openscript run script.os
openscript run script.os --verbose

Evaluate Expressions

openscript eval "echo 'Hello World'"
openscript eval "2 + 3 * 4"

Syntax Checking

openscript check script.os

Package Management

openscript install package-name
openscript list
openscript update

Architecture

OpenScript is built with a modular architecture designed for extensibility and performance:

┌─────────────────────────────────────────────────────────────┐
│                    OpenScript CLI                           │
├─────────────────────────────────────────────────────────────┤
│                    OpenScript SDK                           │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────────────┐    │
│  │ AI Plugin   │ │ HTTP Plugin │ │ FileSystem Plugin   │    │
│  └─────────────┘ └─────────────┘ └─────────────────────┘    │
├─────────────────────────────────────────────────────────────┤
│                  OpenScript Runtime                         │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────────────┐    │
│  │   Parser    │ │ Interpreter │ │    Type System      │    │
│  └─────────────┘ └─────────────┘ └─────────────────────┘    │
└─────────────────────────────────────────────────────────────┘

Core Components

1. Lexer & Parser: Fast, hand-written lexer and recursive descent parser
2. AST: Comprehensive abstract syntax tree representation
3. Interpreter: Tree-walking interpreter with optimizations
4. Type System: Dynamic typing with runtime type checking
5. Memory Management: Rust's ownership system ensures memory safety
6. Plugin System: Extensible architecture for adding functionality

Performance

OpenScript is designed for performance while maintaining ease of use:

• Fast Startup: Sub-100ms cold start time
• Memory Efficient: Minimal memory footprint
• Concurrent: Built-in support for async operations
• Optimized: JIT-friendly interpreter design

Benchmarks

Script Execution:     ~50,000 ops/sec
HTTP Requests:        ~1,000 req/sec
File Operations:      ~10,000 ops/sec
AI API Calls:         Limited by OpenAI rate limits

Development

Building from Source

git clone https://github.com/openscript-lang/openscript-rs.git
cd openscript-rs
cargo build --release

Running Tests

cargo test
cargo test --package openscript_sdk
cargo test --package openscript_cli

Contributing

We welcome contributions! Please see our Contributing Guide for details.

1. Fork the repository
2. Create a feature branch
3. Add tests for your changes
4. Ensure all tests pass
5. Submit a pull request

Code Structure

• openscript/ - Core language implementation
• openscript_sdk/ - Standard library and AI integration
• openscript_cli/ - Command-line interface
• examples/ - Example scripts and use cases
• tests/ - Test suites
• docs/ - Documentation

Use Cases

DevOps Automation

# Deploy application with AI-powered rollback decisions
let deployment_status = deploy_app("production")
if deployment_status.errors > 0 {
    let ai_decision = ai_complete("Should we rollback this deployment? Errors: " + deployment_status.errors)
    if contains(lower(ai_decision), "yes") {
        rollback_deployment()
    }
}

Data Processing

# Process CSV data with AI insights
let data = parse_csv("sales_data.csv")
let summary = analyze_sales_data(data)
let insights = ai_complete("Provide business insights for this sales data: " + json_stringify(summary))
write_file("sales_insights.md", insights)

API Testing

# Automated API testing with intelligent assertions
let endpoints = ["/users", "/posts", "/comments"]
for endpoint in endpoints {
    let response = http_get("https://api.example.com" + endpoint)
    let validation = ai_complete("Is this API response valid? " + response.body)
    assert(contains(lower(validation), "valid"))
}

Infrastructure Monitoring

# Monitor system health with AI-powered alerts
let metrics = get_system_metrics()
let health_check = ai_complete("Analyze these system metrics and provide health status: " + json_stringify(metrics))
if contains(lower(health_check), "critical") {
    send_alert("System health critical: " + health_check)
}

License

OpenScript is released under the MIT License. See LICENSE for details.

Support

• Documentation: https://docs.openscript.dev
• Issues: https://github.com/openscript-lang/openscript-rs/issues
• Discussions: https://github.com/openscript-lang/openscript-rs/discussions
• Discord: https://discord.gg/openscript

Roadmap

• WebAssembly compilation target
• VS Code extension
• Package registry
• JIT compilation
• GPU acceleration for AI workloads
• Distributed execution
• Visual programming interface

Built with ❤️ in Rust for the future of automation