@misterscan/sesi 1.2.3 → 1.3.2

package/docs/SPECIFICATION.md

@@ -1,33 +1,33 @@
-# Sesi Systems Language Specification (v1.2)
+# Sesi Language Specification (v1.3)
 
 ## 1. Philosophy & Design Principles
 
 Sesi is built on these core principles:
 
-1. **High-Performance Systems Orchestration**: Designed for building resilient, stateful applications with first-class primitives for process management and filesystem orchestration.
-2. **Reasoning as a First-Class Citizen**: Model calls, schema definitions, and tool orchestration are treated as language primitives rather than external SDK dependencies.
-3. **Transparency Over Magic**: Explicit model calls with clear costs and latency, not hidden inference.
-4. **Distributed State Management**: Optimized for coordination and state integrity using filesystem locking and concurrent `spawn()` patterns.
-5. **Practical Over Perfect**: Focus on reducing boilerplate code for complex reasoning logic, emphasizing what developers actually need over complete generality.
+1. **Conciseness and Legibility**: The syntax is minimal. If a concept can be expressed simply, the language gets out of the way to let you express it.
+2. **Buildable from Scratch**: Sesi is a complete, functioning language with its own lexer, parser, and interpreter.
+3. **Simplicity Enables Power**: Because the core language is simple, complex operations (like hitting APIs or orchestrating processes) become trivial extensions of the language, rather than tangled SDK implementations.
+4. **Transparency Over Magic**: Sesi executes exactly what you write.
+5. **Practicality**: Focus on reducing boilerplate code, emphasizing what developers actually need over academic completeness.
 
 ## 2. Target Users
 
-**Primary**: Developers building resilient, stateful applications that require systems-level orchestration alongside integrated reasoning.
+**Primary**: Developers who want a clean, fast, and legible language where writing code, whether purely logic-based or calling out to a Reasoning model, is completely frictionless.
 
 **Secondary**:
 
 - Engineers transitioning from traditional languages (TypeScript, Python, Go)
-- Developers building agentic swarms and distributed systems
+- Developers looking for minimal boilerplate.
 - Teams requiring complex logic with a fraction of the boilerplate
 
 **Use Cases**:
 
-- Stateful multi-agent swarm orchestration
-- High-performance data pipelines with structured extraction
-- Concurrent process management and distributed locking
-- Multi-stage reasoning workflows with stateful memory
+- Writing clean CLI tools and scripts
+- Interacting with APIs without SDK boilerplate
+- Quickly orchestrating shell commands
+- Rapid prototyping and scripting
 
-## 3. V1.2 Feature Set (Current)
+## 3. V1.3 Feature Set (Current)
 
 ### Core Language Features
 
@@ -37,20 +37,20 @@ Sesi is built on these core principles:
 - ✅ Loops (`while`, `for`)
 - ✅ Error Handling (`try/catch` blocks)
 - ✅ Data types (number, string, bool, array, object)
-- ✅ Systems Orchestration (`spawn`, `exec`, `time`, `random`)
+- ✅ Process Execution (`spawn`, `exec`, `time`, `random`)
 - ✅ Comments (`//`, `/* */`)
 - ✅ Operators (arithmetic, logical, comparison)
 - ✅ Standard library (print, len, range, etc.)
+- ✅ `prompt` blocks (composable templates for concise formatting)
+- ✅ `structured_output()` (schema-guided structured output with JSON recovery and empty-object fallback on failure)
+- ✅ `tool_call()` (Fully functional function calling for tool use)
+- ✅ `memory` (simple multi-turn script memory and retrieval context management)
 
 ### Reasoning-Native Features
 
-- ✅ `prompt` blocks (composable message templates)
 - ✅ `model()` calls (native model with configuration)
 - ✅ `image()` calls (native image generation with configuration)
 - ✅ `images` config key (multimodal vision input for `model()` and `image()`)
-- ✅ `structured_output()` (schema-guided structured output with JSON recovery and empty-object fallback on failure)
-- ✅ `tool_call()` (Fully functional function calling via models)
-- ✅ Simple memory (conversation context)
 
 ### Type System
 
@@ -87,6 +87,13 @@ string: "..." | '...'
 comment: // ... | /* ... */
 ```
 
+#### String Escapes & Multiline Rules
+
+- Supported escape sequences: `\\n`, `\\t`, `\\r`, `\\\\`, `\\"`, `\\'`
+- Unknown escape sequences are runtime errors during lexing with line and column context
+- Strings can span multiple lines when a literal newline appears before the closing quote
+- Unterminated strings report the starting line and column of the string literal
+
 ### 4.2 Program Structure
 
 ```
@@ -171,7 +178,7 @@ Example:
 ```sesi
 for i = 0 to 10 {print i}
 try
-{let result = model("Hello")
+{let result = "Hello"
 } catch (e) {
 print e}
 ```
@@ -235,10 +242,10 @@ config_entry := (STRING | identifier) ':' expression
 | Key             | Applies to       | Type                      | Description                                                                |
 | --------------- | ---------------- | ------------------------- | -------------------------------------------------------------------------- |
 | `thinkingLevel` | `model`          | `string \| object`        | **Recommended**: Effort level (`"minimal"`, `"low"`, `"medium"`, `"high"`) |
-| `temperature`   | `model`, `image` | `number`                  | *Will be deprecated in Gemini 3.x+_ (Sampling temperature)                 |
+| `temperature`   | `model`, `image` | `number`                  | \*Will be deprecated in Gemini 3.x+\_ (Sampling temperature)               |
 | `max_tokens`    | `model`          | `number`                  | Max output token count                                                     |
-| `top_k`         | `model`          | `number`                  | *Will be deprecated in Gemini 3.x+_                                        |
-| `top_p`         | `model`          | `number`                  | *Will be deprecated in Gemini 3.x+_                                        |
+| `top_k`         | `model`          | `number`                  | \*Will be deprecated in Gemini 3.x+\_                                      |
+| `top_p`         | `model`          | `number`                  | \*Will be deprecated in Gemini 3.x+\_                                      |
 | `ratio`         | `image`          | `string`                  | Aspect ratio e.g. `"16:9"`                                                 |
 | `size`          | `image`          | `string`                  | `"512"`, `"1K"`, `"2K"`, `"4K"`                                            |
 | `images`        | `model`, `image` | `string \| array<string>` | Local file path(s) passed as visual input                                  |
@@ -260,13 +267,21 @@ schema := '{' (identifier ':' type (',' identifier ':' type)*)? '}'
 Example:
 
 ```sesi
-let analysis = structured_output({sentiment: string, score: number, keywords: array<string>})(model("gemini-3.1-flash-lite") { analyzeText })
+let rawJson = "{\"projectName\": \"Sesi\", \"version\": \"1.3.0\", \"status\": \"active\"}"
+let parsedRegistry = structured_output({projectName: string, version: string, status: string})(rawJson)
 ```
 
 #### Tool Call
 
 ```
-tool_call := 'tool_call' '('function_name')' '('model_call')'
+tool_call := 'tool_call' '('function_name')' '('(model_call | expressions)?')'
+```
+
+Example (Native Sandboxed Dispatch):
+
+```sesi
+fn add(a: number, b: number) -> number { return a + b }
+let sum = tool_call(add)(10, 20)
 ```
 
 #### Memory (State Management)
@@ -297,7 +312,7 @@ optional_type := type '?'
 
 1. **Short-circuit evaluation**: `&&` and `||` short-circuit
 2. **Type coercion**: Automatic for numeric operations; explicit for string/number
-3. **Null propagation**: Operations on `null` return `null` (no exceptions in v1.2)
+3. **Null propagation**: Operations on `null` return `null` (no exceptions in v1.3)
 4. **Model responses**: Always returned as strings initially; structured_output provides type safety
 
 ## 6. Scope and Binding
@@ -357,9 +372,13 @@ time() -> number                  // Current Unix timestamp
 random() -> number                // Random float (0.0 to 1.0)
 ```
 
+### Built-in Global Variables
+
+- `args` - `array<string>`: Contains the command-line arguments passed to the script, excluding Sesi runtime options and the script path.
+
 ## 9. Module System
 
-Runtime module execution and standard namespace modules are fully implemented and natively supported in v1.2+.
+Runtime module execution and standard namespace modules are fully implemented and natively supported in v1.3+.
 
 ### Defining Modules
 
@@ -385,16 +404,16 @@ import math from "std/math"    // Math operations
 import json from "std/json"    // JSON parsing
 ```
 
-### Module Resolution Order (v1.2.2+)
+### Module Resolution Order (v1.3+)
 
 When you write `import {x} from "mymodule"`, Sesi searches for `mymodule.sesi` in the following order, stopping at the first match:
 
-| Priority | Location | Description |
-| -------- | -------- | ----------- |
-| 1 | **Script's own directory** | Same folder as the currently running `.sesi` file |
-| 2 | **Current working directory** | The directory you ran `sesi` from |
-| 3 | **`SESI_PATH`** | Semicolon-separated (Windows) or colon-separated (Unix) list of additional directories |
-| 4 | **`~/.sesi/lib`** | Global shared library directory — available system-wide |
+| Priority | Location                      | Description                                                                            |
+| -------- | ----------------------------- | -------------------------------------------------------------------------------------- |
+| 1        | **Script's own directory**    | Same folder as the currently running `.sesi` file                                      |
+| 2        | **Current working directory** | The directory you ran `sesi` from                                                      |
+| 3        | **`SESI_PATH`**               | Semicolon-separated (Windows) or colon-separated (Unix) list of additional directories |
+| 4        | **`~/.sesi/lib`**             | Global shared library directory — available system-wide                                |
 
 This means imports always resolve correctly regardless of where you run `sesi` from.
 
@@ -470,10 +489,10 @@ print "Image written to logo.png"
 - **`max_tokens`**: `number` (maximum response tokens)
 - **`images`**: `string` or `array<string>` (paths to multimodal vision input files)
 - **`cache`**: `bool` (set to `false` to explicitly bypass Sesi Logic Caching)
-- **`temperature`**: *  Will be deprecated in Gemini 3.x+, use thinkingLevel instead.* — reasoning is pre-optimized for defaults.
-- **`top_k` / `top_p`**: *Will be deprecated in Gemini 3.x+, use thinkingLevel instead.* — reasoning is pre-optimized for defaults.
+- **`temperature`**: _ Will be deprecated in Gemini 3.x+, use thinkingLevel instead._ — reasoning is pre-optimized for defaults.
+- **`top_k` / `top_p`**: _ Will be deprecated in Gemini 3.x+, use thinkingLevel instead._ — reasoning is pre-optimized for defaults.
 
-### Structured Output
+### Reasoning with Structured Output
 
 ```sesi
 let result = structured_output({title: string, category: string, confidence: number})(model("gemini-3.1-flash-lite") {"Extract metadata from this text:" text})
@@ -481,7 +500,7 @@ print result.title       // Access fields
 print result.confidence  // Type-safe access
 ```
 
-### Tool Calling
+### Reasoning with Tool Calling
 
 ```sesi
 fn calculateTax(amount: number, rate: number) {print amount * rate}
@@ -489,7 +508,7 @@ let taxAmount = tool_call(calculateTax)(model("gemini-3.1-flash-lite") {"Calcula
 taxAmount
 ```
 
-### Memory
+### Reasoning with Memory
 
 ```sesi
 memory chat {"System: You are a helpful assistant."}
@@ -515,7 +534,7 @@ fn analyzeText(text: string) -> string {return model("gemini-3.5-flash") {thinki
 print analyzeText("Reasoning is transforming industries")
 ```
 
-### Example 3: Structured Output
+### Example 3: Reasoning with Structured Output
 
 ```sesi
 let sentiment = structured_output({label: string, score: number})(model("gemini-3-flash-preview") {"Analyze sentiment of:" userInput})
@@ -523,7 +542,7 @@ print sentiment.label
 print sentiment.score
 ```
 
-## 12. Undefined Behavior & Limitations (V1.2)
+## 12. Undefined Behavior & Limitations (V1.3)
 
 - **No async/await**: All operations within a script are blocking (including model calls). Concurrency must be achieved via `spawn()`.
 - **No custom types**: Only built-in types are supported natively.

package/examples/03_functions.sesi

@@ -1,6 +1,35 @@
 // Functions
 fn add(a: number, b: number) {print a + b}
 fn greet(name: string = "World") {print "Hello" name "!"}
+
 add(5, 3)
 greet()
-greet("Alice")
+greet("Alice")
+
+// Advanced Functions
+fn calculate(operation: string, a: number, b: number) {
+    if operation == "add" {
+        print a + b
+    } else if operation == "subtract" {
+        print a - b
+    } else if operation == "multiply" {
+        print a * b
+    } else if operation == "divide" {
+        print a / b
+    } else {
+        print "Invalid operation"
+    }
+}
+
+calculate("add", 5, 3)
+
+// Define your functions and call it using a custom tool
+
+fn getSesiVersion() {
+    return "1.3.2"
+}
+
+define_tool("sesi", getSesiVersion, "Get the current Sesi version")
+let v = tool_call(sesi)()
+
+print "Current version:" v

package/examples/07_prompts.sesi

@@ -1,10 +1,34 @@
-// Prompt blocks - composable message templates
+// Prompt blocks - composable text templates
 prompt greetingTemplate {"Hello! " "How are you today?"}
-prompt responseTemplate {greetingTemplate " " "I hope you're having a great day!"}
+prompt responseTemplate {greetingTemplate " I hope you're having a great day!"}
 // Prompts evaluate to strings
 let greeting = responseTemplate
 print greeting
 // Prompts can use variables
 let userName = "Alice"
 prompt personalGreeting {"Hello, " userName "! Welcome back!"}
-print personalGreeting
+print personalGreeting
+
+// You can really explore the power of prompt blocks by using it to structure your outputs
+
+prompt htmlHead {"<!DOCTYPE html>
+<html lang='en'>
+<head>
+    <meta charset='UTF-8'>
+    <meta name='viewport' content='width=device-width, initial-scale=1.0'>
+    <title>Document</title>
+</head>
+"}
+prompt htmlBody {"<body>
+    <h1>Hello World!</h1>
+    <p>This is a paragraph</p>
+</body>
+"}
+prompt htmlFooter {"</html>"}
+prompt htmlLayout {htmlHead htmlBody htmlFooter}
+try {
+    write_file("index.html", htmlLayout)
+    print "HTML file created successfully!"
+} catch(error) {
+    print "Error creating HTML file: " error
+}

package/examples/08_model_call.sesi

@@ -1,5 +1,7 @@
 // Reasoning-powered text analysis using model calls
-// Requires GEMINI_API_KEY environment variable
-let text = "Artificial intelligence is transforming how we work and live"
-let analysis = model("gemini-3.1-flash-lite") {"temperature": 0.5, "max_tokens": 400} {"Analyze the following text and provide 3 concise key insights. Keep the total response under 120 words. " text}
-print "Analysis:" analysis
+// USING IT FOR AI IS OPTIONAL AND NOT REQUIRED TO USE IN YOUR SCRIPTS.
+// COMMENTED OUT BECAUSE AI WILL FORCE THEMSELVES TO RUN IT
+
+// let text = "Sesi is transforming how we work and live"
+// let analysis = model("gemini-3.1-flash-lite") {temperature: 0.5, max_tokens: 400} {"Analyze the following text and provide 3 concise key insights. Keep the total response under 120 words. " text}
+// print "Analysis:" analysis

package/examples/09_structured_output.sesi

@@ -1,7 +1,23 @@
 // Sentiment analysis with structured output
-// Requires GEMINI_API_KEY environment variable
+// THIS IS OPTIONAL AND NOT REQUIRED TO USE IN YOUR SCRIPTS.
+
 let review = "This product is amazing! I love how it works. Highly recommended!"
-let sentiment = structured_output({sentiment: string, confidence: number, keywords: string})(model("gemini-3.1-flash-lite") {"Analyze the sentiment of this review and extract key information. " "Return JSON with: sentiment (positive/negative/neutral), confidence (0-1), keywords (comma-separated) " review})
+let sentiment = structured_output({sentiment: string, confidence: number, keywords: string})(model("gemini-3.1-flash-lite") {"Analyze the sentiment of this review and extract key information. Return JSON with: sentiment (positive/negative/neutral), confidence (0-1), keywords (comma-separated) " review})
 print "Sentiment:" sentiment["sentiment"]
 print "Confidence:" sentiment["confidence"]
-print "Keywords:" sentiment["keywords"]
+print "Keywords:" sentiment["keywords"]
+
+// Structured output can be used without model() function as well
+// For example, if you have an API endpoint that returns JSON data, you can use structured_output to parse it.
+
+let json_data = web_get("https://jsonplaceholder.typicode.com/todos/1")
+let structured_data = structured_output({title: string, completed: boolean})(json_data)
+print "Title:" structured_data["title"]
+print "Completed:" structured_data["completed"]
+
+// You can even pass raw text to structured_output if you want, it just needs to be in JSON format. For example:
+
+let raw_text = "{\"title\": \"Buy milk\", \"completed\": false}"
+let structured_data = structured_output({title: string, completed: boolean})(raw_text)
+print "Title:" structured_data["title"]
+print "Completed:" structured_data["completed"]

package/examples/10_code_generation.sesi

@@ -1,5 +1,7 @@
 // Code generation with Reasoning
-// Requires GEMINI_API_KEY environment variable
-let requirement = "A function that checks if a number is prime"
-let generatedCode = model("gemini-3.1-flash-lite") {"temperature": 0.2, "max_tokens": 500} {"Generate JavaScript code for the following requirement: " requirement " Provide only the code, no explanation."}
-print "Generated Code:" generatedCode
+// USING IT FOR AI IS OPTIONAL AND NOT REQUIRED TO USE IN YOUR SCRIPTS.
+// COMMENTED OUT BECAUSE AI WILL FORCE THEMSELVES TO RUN IT
+
+// let requirement = "A function that checks if a number is prime"
+// let generatedCode = model("gemini-3.1-flash-lite") {temperature: 0.2, max_tokens: 500} {"Generate JavaScript code for the following requirement: " requirement " Provide only the code, no explanation."}
+// print "Generated Code:" generatedCode

package/examples/11_memory_conversation.sesi

@@ -1,16 +1,48 @@
-// Multi-turn conversation with memory
-// Requires GEMINI_API_KEY environment variable
-memory conversation {"You are a helpful programming assistant. Respond concisely."}
-fn askBot(question: string) -> string {
-  let message = conversation + "User:" + question
-  let response = model("gemini-3.1-flash-lite") {message}
-  conversation = message + "Assistant:" + response
-  return response
+// You can use memory to store variables throughout your script without redeclaring it
+
+memory store_database {"name: string, age: number, role: string"}
+
+store_database = {"name": "John", "age": 30, "role": "developer"}
+print "Name:" store_database["name"]
+print "Age:" store_database["age"]
+print "Role:" store_database["role"]
+try {
+  write_file("data.txt", to_json(store_database))
+  print "Database saved!"
+} catch(error) {
+  print "Error:" error
 }
-print "Starting conversation..."
-let answer1 = askBot("What is a closure in JavaScript?")
-print "Q1 Answer:" answer1
-let answer2 = askBot("Can you give me an example?")
-print "Q2 Answer:" answer2
-let answer3 = askBot("How do I use it in practice?")
-print "Q3 Answer:" answer3
+
+let new_info = {"name": "Jane", "age": 25, "role": "designer"}
+let merged = store_database
+for key in keys(new_info) {
+  merged[key] = new_info[key]
+}
+store_database = merged
+print "Name:" store_database["name"]
+print "Age:" store_database["age"]
+print "Role:" store_database["role"]
+try {
+  write_file("data.txt", to_json(store_database))
+  print "Database updated!"
+} catch(error) {
+  print "Error:" error
+}
+
+// USING IT FOR AI IS OPTIONAL AND NOT REQUIRED TO USE IN YOUR SCRIPTS.
+// COMMENTED OUT BECAUSE AI WILL FORCE THEMSELVES TO RUN IT
+
+// memory conversation {"You are a helpful programming assistant. Respond concisely."}
+// memory conversationfn askBot(question: string) -> string {
+//  let message = conversation + "User:" + question
+//  let response = model("gemini-3.1-flash-lite") {message}
+//  conversation = message + "Assistant:" + response
+//  return response
+//}
+// print "Starting conversation..."
+// let answer1 = askBot("What is a closure in JavaScript?")
+// print "Q1 Answer:" answer1
+// let answer2 = askBot("Can you give me an example?")
+// print "Q2 Answer:" answer2
+// let answer3 = askBot("How do I use it in practice?")
+// print "Q3 Answer:" answer3

package/examples/12_classification.sesi

@@ -1,8 +1,63 @@
-// Data classification using Reasoning
-// Requires GEMINI_API_KEY environment variable
+// Data classification 
+
 let items = ["A quick brown fox", "123 Main Street", "user@example.com", "New York City"]
-fn classifyItem(item: string) -> string {return model("gemini-3.1-flash-lite") {"Classify this item into one of: TEXT, ADDRESS, EMAIL, LOCATION " "Item: " item}}
-print "Classifying items..."
-for item in items 
-{let classification = classifyItem(item)
-print item "->" classification}
+
+fn isEmail(item: string) -> bool {
+  let parts = split(item, "@")
+  if len(parts) != 2 {
+    return false
+  }
+  let localPart = parts[0]
+  let domainPart = parts[1]
+  if len(localPart) == 0 || len(domainPart) == 0 {
+    return false
+  }
+  let domainParts = split(domainPart, ".")
+  if len(domainParts) < 2 {
+    return false
+  }
+  for part in domainParts {
+    if len(part) == 0 {
+      return false
+    }
+  }
+  return true
+}
+
+fn isAddress(item: string) -> bool {
+  // Simplified check for address-like strings
+  let parts = split(item, " ")
+  // Must contain numbers and words
+  let hasNumber = false
+  let hasWord = false
+  for part in parts {
+    if num(part) != null {
+      hasNumber = true
+    } else if len(part) > 1 {
+      hasWord = true
+    }
+  }
+  return hasNumber && hasWord && len(parts) >= 2
+}
+
+print "Classifying items natively:"
+for item in items {
+  if isEmail(item) {
+    print item "-> EMAIL"
+  } else if isAddress(item) {
+    print item "-> ADDRESS"
+  } else {
+    print item "-> TEXT/LOCATION"
+  }
+}
+
+// USING AI IS OPTIONAL AND NOT REQUIRED TO USE IN YOUR SCRIPTS.
+// COMMENTED OUT BECAUSE AI WILL FORCE THEMSELVES TO RUN IT
+
+
+// let items = ["A quick brown fox", "123 Main Street", "user@example.com", "New York City"]
+// fn classifyItem(item: string) -> string {return model("gemini-3.1-flash-lite") {"Classify this item into one of: TEXT, ADDRESS, EMAIL, LOCATION " "Item: " item}}
+// print "Classifying items..."
+// for item in items 
+// {let classification = classifyItem(item)
+// print item "->" classification}

package/examples/13_data_pipeline.sesi

@@ -1,35 +1,62 @@
-// Comprehensive example: Reasoning-powered data pipeline
 // This example demonstrates: Functions and control flow, Loops and arrays, Model calls with configuration, Structured output parsing, Memory for multi-step processing
 // Data to process
-let reviews = ["This product is amazing! Highly recommended.", "Terrible quality. Waste of money.", "It's okay. Nothing special.", "Love it! Best purchase ever.", "Disappointed. Poor customer service."]
-// Function to analyze single review
-fn analyzeReview(review: string) -> object {
-  return structured_output({sentiment: string, confidence: number})(model("gemini-3.1-flash-lite") {"temperature": 0.3} {"Analyze sentiment. Return JSON with sentiment (positive/negative/neutral) and confidence (0-1). Review:" review})
+
+let numbers = [10, 25, 30, 45, 50]
+let threshold = 30
+fn filterNumbers(list: array, limit: number) -> array {
+  let filtered = []
+  for n in list {
+    if n >= limit {
+      push(filtered, n)
+    }
+  }
+  return filtered
+}
+let highNumbers = filterNumbers(numbers, threshold)
+print "Numbers above " + threshold + ":"
+for val in highNumbers {
+  print "- " + val
 }
+try {
+  write_file("results.txt", "Processed " + len(highNumbers) + " items.")
+  print "Log file created."
+} catch(e) {
+  print "File error: " + e
+}
+
+// USING AI IS OPTIONAL AND NOT REQUIRED TO USE IN YOUR SCRIPTS.
+// COMMENTED OUT BECAUSE AI WILL FORCE THEMSELVES TO RUN IT
+
+// let reviews = ["This product is amazing! Highly recommended.", "Terrible quality. Waste of money.", "It's okay. Nothing special.", "Love it! Best purchase ever.", "Disappointed. Poor customer service."]
+// Function to analyze single review
+// fn analyzeReview(review: string) -> object {
+//   return structured_output({sentiment: string, confidence: number})(model("gemini-3.1-flash-lite") {temperature: 0.3} {"Analyze sentiment. Return JSON with sentiment (positive/negative/neutral) and confidence (0-1). Review:" review})
+// }
 // Process all reviews
-print ("Processing " + len(reviews) + " reviews...")
-let results = []
-let positiveCount = 0
-let negativeCount = 0
-let neutralCount = 0
-for review in reviews 
-{print "Review:" review
-let analysis = analyzeReview(review)
-let sentiment = analysis["sentiment"]
-let confidence = analysis["confidence"]
-print "Sentiment:" sentiment "Confidence:" confidence
-push(results, analysis)
-if sentiment == "positive" {positiveCount = positiveCount + 1} else if sentiment == "negative" {negativeCount = negativeCount + 1} else {neutralCount = neutralCount + 1}}
+
+// print ("Processing " + len(reviews) + " reviews...")
+// let results = []
+// let positiveCount = 0
+// let negativeCount = 0
+// let neutralCount = 0
+// for review in reviews 
+// {print "Review:" review
+// let analysis = analyzeReview(review)
+// let sentiment = analysis["sentiment"]
+// let confidence = analysis["confidence"]
+// print "Sentiment:" sentiment "Confidence:" confidence
+// push(results, analysis)
+// if sentiment == "positive" {positiveCount = positiveCount + 1} else if sentiment == "negative" {negativeCount = negativeCount + 1} else {neutralCount = neutralCount + 1}}
 // Summary
-print "=== Summary ==="
-print "Total reviews:" len(reviews)
-print "Positive:" positiveCount
-print "Negative:" negativeCount
-print "Neutral:" neutralCount
+// print "=== Summary ==="
+// print "Total reviews:" len(reviews)
+// print "Positive:" positiveCount
+// print "Negative:" negativeCount
+// print "Neutral:" neutralCount
 // Calculate average sentiment score
-let totalConfidence = 0
-for result in results {totalConfidence = totalConfidence + result["confidence"]}
-let avgConfidence = totalConfidence / len(results)
-print "Average confidence:" avgConfidence
+// let totalConfidence = 0
+// for result in results {totalConfidence = totalConfidence + result["confidence"]}
+// let avgConfidence = totalConfidence / len(results)
+// print "Average confidence:" avgConfidence
 // Overall recommendation
-if positiveCount > negativeCount {print "Overall: RECOMMENDED (more positive reviews)"} else if negativeCount > positiveCount {print "Overall: NOT RECOMMENDED (more negative reviews)"} else {print "Overall: MIXED (balanced reviews)"}
+// if positiveCount > negativeCount {print "Overall: RECOMMENDED (more positive reviews)"} else if negativeCount > positiveCount {print "Overall: NOT RECOMMENDED (more negative reviews)"} else {print "Overall: MIXED (balanced reviews)"}