feat(jq): Add dedicated tokenizer, parser, and evaluator (#26)

* fix: add tokenizer and parser

* fix: split tests

* fix: add maxJqIterations limits

Author: mangersmiovision

src/commands/jq/evaluator.ts

@@ -0,0 +1,176 @@
+import { describe, expect, it } from "vitest";
+import { Bash } from "../../Bash.js";
+
+describe("jq basic", () => {
+  describe("identity filter", () => {
+    it("should pass through JSON with .", async () => {
+      const env = new Bash();
+      const result = await env.exec("echo '{\"a\":1}' | jq '.'");
+      expect(result.stdout).toBe('{\n  "a": 1\n}\n');
+      expect(result.stderr).toBe("");
+      expect(result.exitCode).toBe(0);
+    });
+
+    it("should pretty print arrays", async () => {
+      const env = new Bash();
+      const result = await env.exec("echo '[1,2,3]' | jq '.'");
+      expect(result.stdout).toBe("[\n  1,\n  2,\n  3\n]\n");
+      expect(result.exitCode).toBe(0);
+    });
+  });
+
+  describe("object access", () => {
+    it("should access object key with .key", async () => {
+      const env = new Bash();
+      const result = await env.exec("echo '{\"name\":\"test\"}' | jq '.name'");
+      expect(result.stdout).toBe('"test"\n');
+      expect(result.exitCode).toBe(0);
+    });
+
+    it("should access nested key with .a.b", async () => {
+      const env = new Bash();
+      const result = await env.exec(
+        'echo \'{"a":{"b":"nested"}}\' | jq \'.a.b\'',
+      );
+      expect(result.stdout).toBe('"nested"\n');
+      expect(result.exitCode).toBe(0);
+    });
+
+    it("should return null for missing key", async () => {
+      const env = new Bash();
+      const result = await env.exec("echo '{\"a\":1}' | jq '.missing'");
+      expect(result.stdout).toBe("null\n");
+      expect(result.exitCode).toBe(0);
+    });
+
+    it("should access numeric values", async () => {
+      const env = new Bash();
+      const result = await env.exec("echo '{\"count\":42}' | jq '.count'");
+      expect(result.stdout).toBe("42\n");
+      expect(result.exitCode).toBe(0);
+    });
+
+    it("should access boolean values", async () => {
+      const env = new Bash();
+      const result = await env.exec("echo '{\"active\":true}' | jq '.active'");
+      expect(result.stdout).toBe("true\n");
+      expect(result.exitCode).toBe(0);
+    });
+  });
+
+  describe("array access", () => {
+    it("should access array element with .[0]", async () => {
+      const env = new Bash();
+      const result = await env.exec('echo \'["a","b","c"]\' | jq \'.[0]\'');
+      expect(result.stdout).toBe('"a"\n');
+      expect(result.exitCode).toBe(0);
+    });
+
+    it("should access last element with .[-1]", async () => {
+      const env = new Bash();
+      const result = await env.exec('echo \'["a","b","c"]\' | jq \'.[-1]\'');
+      expect(result.stdout).toBe('"c"\n');
+      expect(result.exitCode).toBe(0);
+    });
+
+    it("should return null for out of bounds index", async () => {
+      const env = new Bash();
+      const result = await env.exec("echo '[1,2]' | jq '.[99]'");
+      expect(result.stdout).toBe("null\n");
+      expect(result.exitCode).toBe(0);
+    });
+  });
+
+  describe("array iteration", () => {
+    it("should iterate array with .[]", async () => {
+      const env = new Bash();
+      const result = await env.exec("echo '[1,2,3]' | jq '.[]'");
+      expect(result.stdout).toBe("1\n2\n3\n");
+      expect(result.exitCode).toBe(0);
+    });
+
+    it("should iterate object values with .[]", async () => {
+      const env = new Bash();
+      const result = await env.exec("echo '{\"a\":1,\"b\":2}' | jq '.[]'");
+      expect(result.stdout).toBe("1\n2\n");
+      expect(result.exitCode).toBe(0);
+    });
+
+    it("should iterate nested array with .items[]", async () => {
+      const env = new Bash();
+      const result = await env.exec(
+        "echo '{\"items\":[1,2,3]}' | jq '.items[]'",
+      );
+      expect(result.stdout).toBe("1\n2\n3\n");
+      expect(result.exitCode).toBe(0);
+    });
+  });
+
+  describe("pipes", () => {
+    it("should pipe filters with |", async () => {
+      const env = new Bash();
+      const result = await env.exec(
+        "echo '{\"data\":{\"value\":42}}' | jq '.data | .value'",
+      );
+      expect(result.stdout).toBe("42\n");
+      expect(result.exitCode).toBe(0);
+    });
+
+    it("should chain multiple pipes", async () => {
+      const env = new Bash();
+      const result = await env.exec(
+        'echo \'{"a":{"b":{"c":"deep"}}}\' | jq \'.a | .b | .c\'',
+      );
+      expect(result.stdout).toBe('"deep"\n');
+      expect(result.exitCode).toBe(0);
+    });
+  });
+
+  describe("array slicing", () => {
+    it("should slice with start and end", async () => {
+      const env = new Bash();
+      const result = await env.exec("echo '[0,1,2,3,4,5]' | jq '.[2:4]'");
+      expect(result.stdout).toBe("[\n  2,\n  3\n]\n");
+    });
+
+    it("should slice from start", async () => {
+      const env = new Bash();
+      const result = await env.exec("echo '[0,1,2,3,4]' | jq '.[:3]'");
+      expect(result.stdout).toBe("[\n  0,\n  1,\n  2\n]\n");
+    });
+
+    it("should slice to end", async () => {
+      const env = new Bash();
+      const result = await env.exec("echo '[0,1,2,3,4]' | jq '.[3:]'");
+      expect(result.stdout).toBe("[\n  3,\n  4\n]\n");
+    });
+
+    it("should slice strings", async () => {
+      const env = new Bash();
+      const result = await env.exec("echo '\"hello\"' | jq '.[1:4]'");
+      expect(result.stdout).toBe('"ell"\n');
+    });
+
+    it("should access with negative index in slice", async () => {
+      const env = new Bash();
+      const result = await env.exec("echo '[0,1,2,3,4]' | jq '.[-2:]'");
+      expect(result.stdout).toBe("[\n  3,\n  4\n]\n");
+    });
+  });
+
+  describe("comma operator", () => {
+    it("should output multiple values", async () => {
+      const env = new Bash();
+      const result = await env.exec("echo '{\"a\":1,\"b\":2}' | jq '.a, .b'");
+      expect(result.stdout).toBe("1\n2\n");
+    });
+
+    it("should work with three values", async () => {
+      const env = new Bash();
+      const result = await env.exec(
+        'echo \'{"x":1,"y":2,"z":3}\' | jq \'.x, .y, .z\'',
+      );
+      expect(result.stdout).toBe("1\n2\n3\n");
+    });
+  });
+});

src/commands/jq/jq.basic.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import { Bash } from "../../Bash.js";
+
+describe("jq construction", () => {
+  describe("object construction", () => {
+    it("should construct object with static keys", async () => {
+      const env = new Bash();
+      const result = await env.exec(
+        'echo \'{"name":"test","value":42}\' | jq -c \'{n: .name, v: .value}\'',
+      );
+      expect(result.stdout).toBe('{"n":"test","v":42}\n');
+    });
+
+    it("should construct object with shorthand", async () => {
+      const env = new Bash();
+      const result = await env.exec(
+        'echo \'{"name":"test","value":42}\' | jq -c \'{name, value}\'',
+      );
+      expect(result.stdout).toBe('{"name":"test","value":42}\n');
+    });
+
+    it("should construct object with dynamic keys", async () => {
+      const env = new Bash();
+      const result = await env.exec(
+        'echo \'{"key":"foo","val":42}\' | jq -c \'{(.key): .val}\'',
+      );
+      expect(result.stdout).toBe('{"foo":42}\n');
+    });
+
+    it("should allow pipes in object values", async () => {
+      const env = new Bash();
+      const result = await env.exec(
+        "echo '[[1,2],[3,4]]' | jq -c '{a: .[0] | add, b: .[1] | add}'",
+      );
+      expect(result.stdout).toBe('{"a":3,"b":7}\n');
+    });
+  });
+
+  describe("array construction", () => {
+    it("should construct array from iterator", async () => {
+      const env = new Bash();
+      const result = await env.exec("echo '{\"a\":1,\"b\":2}' | jq '[.a, .b]'");
+      expect(result.stdout).toBe("[\n  1,\n  2\n]\n");
+    });
+
+    it("should construct array from object values", async () => {
+      const env = new Bash();
+      const result = await env.exec(
+        'echo \'{"a":1,"b":2,"c":3}\' | jq \'[.[]]\'',
+      );
+      expect(result.stdout).toBe("[\n  1,\n  2,\n  3\n]\n");
+    });
+  });
+});

src/commands/jq/jq.construction.test.ts

@@ -0,0 +1,152 @@
+import { describe, expect, it } from "vitest";
+import { Bash } from "../../Bash.js";
+
+describe("jq filters", () => {
+  describe("select and map", () => {
+    it("should filter with select", async () => {
+      const env = new Bash();
+      const result = await env.exec(
+        "echo '[1,2,3,4,5]' | jq '[.[] | select(. > 3)]'",
+      );
+      expect(result.stdout).toBe("[\n  4,\n  5\n]\n");
+    });
+
+    it("should transform with map", async () => {
+      const env = new Bash();
+      const result = await env.exec("echo '[1,2,3]' | jq 'map(. * 2)'");
+      expect(result.stdout).toBe("[\n  2,\n  4,\n  6\n]\n");
+    });
+
+    it("should chain select and map", async () => {
+      const env = new Bash();
+      const result = await env.exec(
+        "echo '[1,2,3,4,5]' | jq '[.[] | select(. > 2) | . * 10]'",
+      );
+      expect(result.stdout).toBe("[\n  30,\n  40,\n  50\n]\n");
+    });
+
+    it("should select objects by field", async () => {
+      const env = new Bash();
+      const result = await env.exec(
+        'echo \'[{"n":1},{"n":5},{"n":2}]\' | jq -c \'[.[] | select(.n > 2)]\'',
+      );
+      expect(result.stdout).toBe('[{"n":5}]\n');
+    });
+  });
+
+  describe("has and in", () => {
+    it("should check has for object", async () => {
+      const env = new Bash();
+      const result = await env.exec("echo '{\"foo\":42}' | jq 'has(\"foo\")'");
+      expect(result.stdout).toBe("true\n");
+    });
+
+    it("should check has for missing key", async () => {
+      const env = new Bash();
+      const result = await env.exec("echo '{\"foo\":42}' | jq 'has(\"bar\")'");
+      expect(result.stdout).toBe("false\n");
+    });
+
+    it("should check has for array", async () => {
+      const env = new Bash();
+      const result = await env.exec("echo '[1,2,3]' | jq 'has(1)'");
+      expect(result.stdout).toBe("true\n");
+    });
+  });
+
+  describe("contains", () => {
+    it("should check array contains", async () => {
+      const env = new Bash();
+      const result = await env.exec("echo '[1,2,3]' | jq 'contains([2])'");
+      expect(result.stdout).toBe("true\n");
+    });
+
+    it("should check object contains", async () => {
+      const env = new Bash();
+      const result = await env.exec(
+        'echo \'{"a":1,"b":2}\' | jq \'contains({"a":1})\'',
+      );
+      expect(result.stdout).toBe("true\n");
+    });
+  });
+
+  describe("any and all", () => {
+    it("should check any with expression", async () => {
+      const env = new Bash();
+      const result = await env.exec("echo '[1,2,3,4,5]' | jq 'any(. > 3)'");
+      expect(result.stdout).toBe("true\n");
+    });
+
+    it("should check all with expression", async () => {
+      const env = new Bash();
+      const result = await env.exec("echo '[1,2,3]' | jq 'all(. > 0)'");
+      expect(result.stdout).toBe("true\n");
+    });
+  });
+
+  describe("conditionals", () => {
+    it("should evaluate if-then-else", async () => {
+      const env = new Bash();
+      const result = await env.exec(
+        "echo '5' | jq 'if . > 3 then \"big\" else \"small\" end'",
+      );
+      expect(result.stdout).toBe('"big"\n');
+    });
+
+    it("should evaluate else branch", async () => {
+      const env = new Bash();
+      const result = await env.exec(
+        "echo '2' | jq 'if . > 3 then \"big\" else \"small\" end'",
+      );
+      expect(result.stdout).toBe('"small"\n');
+    });
+
+    it("should evaluate elif", async () => {
+      const env = new Bash();
+      const result = await env.exec(
+        'echo \'5\' | jq \'if . > 10 then "big" elif . > 3 then "medium" else "small" end\'',
+      );
+      expect(result.stdout).toBe('"medium"\n');
+    });
+  });
+
+  describe("optional operator", () => {
+    it("should return null for missing key with ?", async () => {
+      const env = new Bash();
+      const result = await env.exec("echo 'null' | jq '.foo?'");
+      expect(result.stdout).toBe("null\n");
+    });
+
+    it("should return value if present with ?", async () => {
+      const env = new Bash();
+      const result = await env.exec("echo '{\"foo\":42}' | jq '.foo?'");
+      expect(result.stdout).toBe("42\n");
+    });
+  });
+
+  describe("try-catch", () => {
+    it("should catch errors", async () => {
+      const env = new Bash();
+      const result = await env.exec(
+        "echo '1' | jq 'try error(\"oops\") catch \"caught\"'",
+      );
+      expect(result.stdout).toBe('"caught"\n');
+    });
+  });
+
+  describe("variables", () => {
+    it("should bind and use variable", async () => {
+      const env = new Bash();
+      const result = await env.exec("echo '5' | jq '. as $x | $x * $x'");
+      expect(result.stdout).toBe("25\n");
+    });
+
+    it("should use variable in object construction", async () => {
+      const env = new Bash();
+      const result = await env.exec(
+        "echo '3' | jq -c '. as $n | {value: $n, doubled: ($n * 2)}'",
+      );
+      expect(result.stdout).toBe('{"value":3,"doubled":6}\n');
+    });
+  });
+});