agency-lang 0.0.91 → 0.0.92

package/dist/lib/backends/agencyGenerator.js

@@ -793,13 +793,16 @@ export class AgencyGenerator {
         return assigned ? multiLine : this.indentStr(multiLine);
     }
     processAccessChainElement(node) {
+        const dot = node.optional ? "?." : ".";
         switch (node.kind) {
             case "property":
-                return `.${node.name}`;
-            case "index":
-                return `[${this.processNode(node.index).trim()}]`;
+                return `${dot}${node.name}`;
+            case "index": {
+                const inner = this.processNode(node.index).trim();
+                return node.optional ? `?.[${inner}]` : `[${inner}]`;
+            }
             case "methodCall":
-                return `.${this.generateFunctionCallExpression(node.functionCall, "valueAccess")}`;
+                return `${dot}${this.generateFunctionCallExpression(node.functionCall, "valueAccess")}`;
             default:
                 throw new Error(`Unknown access chain element kind: ${node.kind}`);
         }

package/dist/lib/backends/typescriptBuilder.js

@@ -661,10 +661,10 @@ export class TypeScriptBuilder {
         for (const element of node.chain) {
             switch (element.kind) {
                 case "property":
-                    result = ts.prop(result, element.name);
+                    result = ts.prop(result, element.name, { optional: element.optional });
                     break;
                 case "index":
-                    result = ts.index(result, this.processNode(element.index));
+                    result = ts.index(result, this.processNode(element.index), { optional: element.optional });
                     break;
                 case "methodCall": {
                     const callNode = this.generateFunctionCallExpression(element.functionCall, "valueAccess");
@@ -675,15 +675,14 @@ export class TypeScriptBuilder {
                         const args = isClassMethod
                             ? [...callNode.arguments, this.buildMethodCallConfig()]
                             : callNode.arguments;
-                        const callExpr = $(result)
-                            .prop(callNode.callee.name)
-                            .call(args)
-                            .done();
+                        const propNode = ts.prop(result, callNode.callee.name, { optional: element.optional });
+                        const callExpr = ts.call(propNode, args);
                         result = isClassMethod ? ts.await(callExpr) : callExpr;
                     }
                     else {
                         // Fallback for complex cases (e.g. await-wrapped)
-                        result = ts.raw(`${this.str(result)}.${this.str(callNode)}`);
+                        const dot = element.optional ? "?." : ".";
+                        result = ts.raw(`${this.str(result)}${dot}${this.str(callNode)}`);
                     }
                     break;
                 }

package/dist/lib/ir/builders.d.ts

@@ -51,8 +51,12 @@ export declare const ts: {
         parenLeft?: boolean;
         parenRight?: boolean;
     }): TsBinOp;
-    prop(object: TsNode, property: string): TsPropertyAccess;
-    index(object: TsNode, property: TsNode): TsPropertyAccess;
+    prop(object: TsNode, property: string, opts?: {
+        optional?: boolean;
+    }): TsPropertyAccess;
+    index(object: TsNode, property: TsNode, opts?: {
+        optional?: boolean;
+    }): TsPropertyAccess;
     spread(expr: TsNode): TsSpread;
     id(name: string): TsIdentifier;
     str(value: string): TsStringLiteral;

package/dist/lib/ir/builders.js

@@ -166,11 +166,11 @@ export const ts = {
             parenRight: opts?.parenRight,
         };
     },
-    prop(object, property) {
-        return { kind: "propertyAccess", object, property, computed: false };
+    prop(object, property, opts) {
+        return { kind: "propertyAccess", object, property, computed: false, ...(opts?.optional && { optional: true }) };
     },
-    index(object, property) {
-        return { kind: "propertyAccess", object, property, computed: true };
+    index(object, property, opts) {
+        return { kind: "propertyAccess", object, property, computed: true, ...(opts?.optional && { optional: true }) };
     },
     spread(expr) {
         return { kind: "spread", expr };

package/dist/lib/ir/fluent.d.ts

@@ -9,7 +9,9 @@ export declare class TsChain {
     readonly node: TsNode;
     constructor(node: TsNode);
     /** Property access: .prop("foo") → ts.prop(this, "foo") */
-    prop(name: string): TsChain;
+    prop(name: string, opts?: {
+        optional?: boolean;
+    }): TsChain;
     map(fn: TsNode): TsChain;
     /** Computed index: .index(expr) → ts.index(this, expr) */
     index(expr: TsNode): TsChain;

package/dist/lib/ir/fluent.js

@@ -11,8 +11,8 @@ export class TsChain {
         this.node = node;
     }
     /** Property access: .prop("foo") → ts.prop(this, "foo") */
-    prop(name) {
-        return new TsChain(ts.prop(this.node, name));
+    prop(name, opts) {
+        return new TsChain(ts.prop(this.node, name, opts));
     }
     map(fn) {
         return new TsChain(ts.call(ts.prop(this.node, "map"), [fn]));

package/dist/lib/ir/prettyPrint.js

@@ -189,9 +189,11 @@ export function printTs(node, indent = 0) {
         case "propertyAccess": {
             const obj = printTs(node.object, indent);
             if (node.computed) {
-                return `${obj}[${printTs(node.property, indent)}]`;
+                const prefix = node.optional ? "?." : "";
+                return `${obj}${prefix}[${printTs(node.property, indent)}]`;
             }
-            return `${obj}.${node.property}`;
+            const dot = node.optional ? "?." : ".";
+            return `${obj}${dot}${node.property}`;
         }
         case "spread":
             return `...${printTs(node.expr, indent)}`;

package/dist/lib/ir/tsIR.d.ts

@@ -153,6 +153,7 @@ export interface TsPropertyAccess {
     object: TsNode;
     property: string | TsNode;
     computed: boolean;
+    optional?: boolean;
 }
 export interface TsSpread {
     kind: "spread";

package/dist/lib/parsers/access.test.js

@@ -340,6 +340,73 @@ describe("valueAccessParser", () => {
             }
         });
     });
+    describe("optional chaining", () => {
+        it('should parse "foo?.bar" with optional property access', () => {
+            const result = valueAccessParser("foo?.bar");
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.result).toEqualWithoutLoc({
+                    type: "valueAccess",
+                    base: { type: "variableName", value: "foo" },
+                    chain: [{ kind: "property", name: "bar", optional: true }],
+                });
+            }
+        });
+        it('should parse "foo?.bar?.baz" with chained optional access', () => {
+            const result = valueAccessParser("foo?.bar?.baz");
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.result).toEqualWithoutLoc({
+                    type: "valueAccess",
+                    base: { type: "variableName", value: "foo" },
+                    chain: [
+                        { kind: "property", name: "bar", optional: true },
+                        { kind: "property", name: "baz", optional: true },
+                    ],
+                });
+            }
+        });
+        it('should parse "foo?.bar.baz" mixing optional and regular access', () => {
+            const result = valueAccessParser("foo?.bar.baz");
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.result).toEqualWithoutLoc({
+                    type: "valueAccess",
+                    base: { type: "variableName", value: "foo" },
+                    chain: [
+                        { kind: "property", name: "bar", optional: true },
+                        { kind: "property", name: "baz" },
+                    ],
+                });
+            }
+        });
+        it('should parse "arr?.[0]" with optional index access', () => {
+            const result = valueAccessParser("arr?.[0]");
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.result).toEqualWithoutLoc({
+                    type: "valueAccess",
+                    base: { type: "variableName", value: "arr" },
+                    chain: [{ kind: "index", index: { type: "number", value: "0" }, optional: true }],
+                });
+            }
+        });
+        it('should parse "obj?.method()" with optional method call', () => {
+            const result = valueAccessParser("obj?.method()");
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.result).toEqualWithoutLoc({
+                    type: "valueAccess",
+                    base: { type: "variableName", value: "obj" },
+                    chain: [{
+                            kind: "methodCall",
+                            functionCall: { type: "functionCall", functionName: "method", arguments: [] },
+                            optional: true,
+                        }],
+                });
+            }
+        });
+    });
     describe("failure cases", () => {
         it('should fail to parse ""', () => {
             expect(valueAccessParser("").success).toBe(false);

package/dist/lib/parsers/binop.test.js

@@ -524,6 +524,68 @@ describe("binOpParser", () => {
             }
         });
     });
+    // Nullish coalescing operator
+    describe("nullish coalescing operator", () => {
+        it('should parse "a ?? b"', () => {
+            const result = binOpParser("a ?? b");
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.result).toEqualWithoutLoc({
+                    type: "binOpExpression",
+                    operator: "??",
+                    left: { type: "variableName", value: "a" },
+                    right: { type: "variableName", value: "b" },
+                });
+            }
+        });
+        it('should parse "a ?? b ?? c" as left-associative', () => {
+            const result = binOpParser("a ?? b ?? c");
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.result).toEqualWithoutLoc({
+                    type: "binOpExpression",
+                    operator: "??",
+                    left: {
+                        type: "binOpExpression",
+                        operator: "??",
+                        left: { type: "variableName", value: "a" },
+                        right: { type: "variableName", value: "b" },
+                    },
+                    right: { type: "variableName", value: "c" },
+                });
+            }
+        });
+        it('should parse "a ?? 42"', () => {
+            const result = binOpParser("a ?? 42");
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.result).toEqualWithoutLoc({
+                    type: "binOpExpression",
+                    operator: "??",
+                    left: { type: "variableName", value: "a" },
+                    right: { type: "number", value: "42" },
+                });
+            }
+        });
+        it('should parse ?? with lower precedence than comparison', () => {
+            const result = binOpParser("a == b ?? c");
+            expect(result.success).toBe(true);
+            if (result.success) {
+                // Should parse as (a == b) ?? c
+                expect(result.result).toEqualWithoutLoc({
+                    type: "binOpExpression",
+                    operator: "??",
+                    left: {
+                        type: "binOpExpression",
+                        operator: "==",
+                        left: { type: "variableName", value: "a" },
+                        right: { type: "variableName", value: "b" },
+                    },
+                    right: { type: "variableName", value: "c" },
+                });
+            }
+        });
+    });
     // Failure cases
     describe("regex match operators", () => {
         const testCases = [

package/dist/lib/parsers/parsers.js

@@ -409,27 +409,35 @@ export const functionCallParser = label("a function call", _functionCallParser);
 // =============================================================================
 // access.ts
 // =============================================================================
-// Parse a single chain element: .method(), .property, or [index]
+// Parse "?." or "." — returns true for optional, false for regular
+const dotParser = or(map(str("?."), () => true), map(char("."), () => false));
+// Parse a single chain element: .method(), ?.method(), .property, ?.property, [index], ?.[index]
 const dotMethodCallParser = (input) => {
-    // First try: . followed by functionCall (name + parens)
-    const dotResult = char(".")(input);
+    const dotResult = dotParser(input);
     if (!dotResult.success)
         return failure("expected dot", input);
-    const fcResult = _functionCallParser(dotResult.rest);
+    const optional = dotResult.result;
+    const afterDot = dotResult.rest;
+    // First try: functionCall (name + parens)
+    const fcResult = _functionCallParser(afterDot);
     if (fcResult.success) {
-        return success({ kind: "methodCall", functionCall: fcResult.result }, fcResult.rest);
+        return success({ kind: "methodCall", functionCall: fcResult.result, ...(optional && { optional: true }) }, fcResult.rest);
     }
-    // Second try: . followed by just a property name
-    const nameResult = variableNameParser(dotResult.rest);
+    // Second try: just a property name
+    const nameResult = variableNameParser(afterDot);
     if (nameResult.success) {
-        return success({ kind: "property", name: nameResult.result.value }, nameResult.rest);
+        return success({ kind: "property", name: nameResult.result.value, ...(optional && { optional: true }) }, nameResult.rest);
     }
     return failure("expected property name or method call after dot", input);
 };
+// Parse "?.[" or "[" — returns true for optional, false for regular
+const bracketParser = or(map(str("?.["), () => true), map(char("["), () => false));
 const indexChainParser = (input) => {
-    const parser = seqC(set("kind", "index"), char("["), optionalSpaces, capture(lazy(() => exprParser), "index"), optionalSpaces, char("]"));
+    const parser = seqC(capture(bracketParser, "optional"), optionalSpaces, capture(lazy(() => exprParser), "index"), optionalSpaces, char("]"));
     const result = parser(input);
-    return result;
+    if (!result.success)
+        return result;
+    return success({ kind: "index", index: result.result.index, ...(result.result.optional && { optional: true }) }, result.rest);
 };
 const chainElementParser = or(dotMethodCallParser, indexChainParser);
 export const _valueAccessParser = (input) => {
@@ -607,8 +615,9 @@ export const exprParser = label("an expression", buildExpressionParser(atom, [
     [
         { op: wsOp("&&"), assoc: "left", apply: makeBinOp("&&") },
     ],
-    // Precedence 1: logical OR
+    // Precedence 1: logical OR, nullish coalescing
     [
+        { op: wsOp("??"), assoc: "left", apply: makeBinOp("??") },
         { op: wsOp("||"), assoc: "left", apply: makeBinOp("||") },
     ],
     // Precedence 0: catch (unwrap Result with fallback)

package/dist/lib/types/access.d.ts

@@ -3,12 +3,15 @@ import { BaseNode } from "./base.js";
 export type AccessChainElement = {
     kind: "property";
     name: string;
+    optional?: boolean;
 } | {
     kind: "index";
     index: Expression;
+    optional?: boolean;
 } | {
     kind: "methodCall";
     functionCall: FunctionCall;
+    optional?: boolean;
 };
 export type ValueAccess = BaseNode & {
     type: "valueAccess";

package/dist/lib/types/binop.d.ts

@@ -1,7 +1,7 @@
 import { BaseNode } from "./base.js";
 import { Expression } from "../types.js";
 export type BinOpArgument = Expression;
-export type Operator = "+" | "-" | "*" | "/" | "%" | "==" | "===" | "!=" | "+=" | "-=" | "*=" | "/=" | "<" | ">" | "<=" | ">=" | "&&" | "||" | "!" | "=~" | "!~" | "|>" | "catch";
+export type Operator = "+" | "-" | "*" | "/" | "%" | "==" | "===" | "!=" | "+=" | "-=" | "*=" | "/=" | "<" | ">" | "<=" | ">=" | "&&" | "||" | "!" | "=~" | "!~" | "??" | "|>" | "catch";
 export declare const PRECEDENCE: Record<string, number>;
 export type BinOpExpression = BaseNode & {
     type: "binOpExpression";

package/dist/lib/types/binop.js

@@ -1,6 +1,7 @@
 export const PRECEDENCE = {
     "|>": -1,
     "catch": 0,
+    "??": 1,
     "||": 1,
     "&&": 2,
     "==": 3,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agency-lang",
-  "version": "0.0.91",
+  "version": "0.0.92",
   "description": "The Agency language",
   "main": "lib/index.js",
   "scripts": {

package/stdlib/array.js

@@ -33,6 +33,9 @@ const __globalCtx = new RuntimeContext({
     dirname: __dirname
 });
 const graph = __globalCtx.graph;
+import { TraceWriter } from "agency-lang/runtime";
+const __traceWriter = new TraceWriter("/Users/adityabhargava/agency-lang/tests/debugger/trace-test.agencytrace", "stdlib/array.agency");
+__globalCtx.traceWriter = __traceWriter;
 // Path-dependent builtin wrappers
 export function readSkill({ filepath }) {
     return _readSkillRaw({ filepath, dirname: __dirname });

package/stdlib/index.js

@@ -32,6 +32,9 @@ const __globalCtx = new RuntimeContext({
     dirname: __dirname
 });
 const graph = __globalCtx.graph;
+import { TraceWriter } from "agency-lang/runtime";
+const __traceWriter = new TraceWriter("/Users/adityabhargava/agency-lang/tests/debugger/trace-test.agencytrace", "stdlib/index.agency");
+__globalCtx.traceWriter = __traceWriter;
 // Path-dependent builtin wrappers
 export function readSkill({ filepath }) {
     return _readSkillRaw({ filepath, dirname: __dirname });