@fairspec/agent 0.9.0

package/build/tools/table/query.js

@@ -0,0 +1,24 @@
+import { loadTable, queryTable, Resource } from "@fairspec/library";
+import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+export const queryTableTool = createTool({
+    id: "query-table",
+    description: "Query a table using SQL. Loads the table, executes the SQL query, and returns the results as an array of records.",
+    inputSchema: z.object({
+        resource: Resource.describe("The table resource to query"),
+        query: z
+            .string()
+            .describe("SQL query to execute (use 'self' as table name)"),
+    }),
+    outputSchema: z.array(z.record(z.string(), z.unknown())),
+    execute: async (input) => {
+        const table = await loadTable(input.resource, {});
+        if (!table) {
+            throw new Error("Could not load table");
+        }
+        const lazyFrame = queryTable(table, input.query);
+        const frame = await lazyFrame.collect();
+        return frame.toRecords();
+    },
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/tools/table/query.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/tools/table/query.spec.js

@@ -0,0 +1,138 @@
+import { writeTempFile } from "@fairspec/library";
+import { describe, expect, it } from "vitest";
+import { queryTableTool } from "./query.js";
+describe("queryTableTool", () => {
+    it("validates tool structure", () => {
+        expect(queryTableTool.id).toBe("query-table");
+        expect(queryTableTool.description).toBeTruthy();
+        expect(queryTableTool.inputSchema).toBeTruthy();
+        expect(queryTableTool.outputSchema).toBeTruthy();
+        expect(queryTableTool.execute).toBeTypeOf("function");
+    });
+    it("queries table with SELECT statement", async () => {
+        const csvContent = "id,name,age\n1,alice,25\n2,bob,30\n3,carol,28";
+        const csvPath = await writeTempFile(csvContent, { format: "csv" });
+        const resource = { data: csvPath, dialect: { format: "csv" } };
+        const result = await queryTableTool.execute?.({
+            resource,
+            query: "SELECT * FROM self WHERE age > 25",
+        }, {});
+        expect.assert(result);
+        expect.assert(!("error" in result));
+        expect(Array.isArray(result)).toBe(true);
+        expect(result.length).toBe(2);
+        expect(result).toContainEqual({ id: 2, name: "bob", age: 30 });
+        expect(result).toContainEqual({ id: 3, name: "carol", age: 28 });
+    });
+    it("queries table with column selection", async () => {
+        const csvContent = "id,name,age,city\n1,alice,25,NYC\n2,bob,30,LA\n3,carol,28,SF";
+        const csvPath = await writeTempFile(csvContent, { format: "csv" });
+        const resource = { data: csvPath, dialect: { format: "csv" } };
+        const result = await queryTableTool.execute?.({
+            resource,
+            query: "SELECT name, city FROM self",
+        }, {});
+        expect.assert(result);
+        expect.assert(!("error" in result));
+        expect(Array.isArray(result)).toBe(true);
+        expect(result.length).toBe(3);
+        expect(result[0]).toHaveProperty("name");
+        expect(result[0]).toHaveProperty("city");
+        expect(result[0]).not.toHaveProperty("id");
+        expect(result[0]).not.toHaveProperty("age");
+    });
+    it("queries table with ORDER BY clause", async () => {
+        const csvContent = "id,name,score\n1,alice,85\n2,bob,90\n3,carol,88";
+        const csvPath = await writeTempFile(csvContent, { format: "csv" });
+        const resource = { data: csvPath, dialect: { format: "csv" } };
+        const result = await queryTableTool.execute?.({
+            resource,
+            query: "SELECT * FROM self ORDER BY score DESC",
+        }, {});
+        expect.assert(result);
+        expect.assert(!("error" in result));
+        expect(Array.isArray(result)).toBe(true);
+        expect(result.length).toBe(3);
+        expect(result[0]).toMatchObject({ name: "bob", score: 90 });
+        expect(result[1]).toMatchObject({ name: "carol", score: 88 });
+        expect(result[2]).toMatchObject({ name: "alice", score: 85 });
+    });
+    it("queries table with aggregation", async () => {
+        const csvContent = "id,name,score\n1,alice,85\n2,bob,90\n3,carol,88";
+        const csvPath = await writeTempFile(csvContent, { format: "csv" });
+        const resource = { data: csvPath, dialect: { format: "csv" } };
+        const result = await queryTableTool.execute?.({
+            resource,
+            query: "SELECT COUNT(*) as count, AVG(score) as avg_score FROM self",
+        }, {});
+        expect.assert(result);
+        expect.assert(!("error" in result));
+        expect(Array.isArray(result)).toBe(true);
+        expect(result.length).toBe(1);
+        expect(result[0]).toHaveProperty("count");
+        expect(result[0]).toHaveProperty("avg_score");
+    });
+    it("queries table with WHERE and LIMIT", async () => {
+        const csvContent = "id,name,age\n1,alice,25\n2,bob,30\n3,carol,28\n4,dave,35\n5,eve,22";
+        const csvPath = await writeTempFile(csvContent, { format: "csv" });
+        const resource = { data: csvPath, dialect: { format: "csv" } };
+        const result = await queryTableTool.execute?.({
+            resource,
+            query: "SELECT * FROM self WHERE age >= 25 ORDER BY age LIMIT 2",
+        }, {});
+        expect.assert(result);
+        expect.assert(!("error" in result));
+        expect(Array.isArray(result)).toBe(true);
+        expect(result.length).toBe(2);
+    });
+    it("queries inline data", async () => {
+        const resource = {
+            data: [
+                { id: 1, name: "alice", score: 85 },
+                { id: 2, name: "bob", score: 90 },
+                { id: 3, name: "carol", score: 88 },
+            ],
+        };
+        const result = await queryTableTool.execute?.({
+            resource,
+            query: "SELECT name, score FROM self WHERE score > 85",
+        }, {});
+        expect.assert(result);
+        expect.assert(!("error" in result));
+        expect(Array.isArray(result)).toBe(true);
+        expect(result.length).toBe(2);
+        expect(result).toContainEqual({ name: "bob", score: 90 });
+        expect(result).toContainEqual({ name: "carol", score: 88 });
+    });
+    it("queries with JOIN operations", async () => {
+        const resource = {
+            data: [
+                { id: 1, name: "alice", dept_id: 10 },
+                { id: 2, name: "bob", dept_id: 20 },
+            ],
+        };
+        const result = await queryTableTool.execute?.({
+            resource,
+            query: "SELECT * FROM self WHERE dept_id = 10",
+        }, {});
+        expect.assert(result);
+        expect.assert(!("error" in result));
+        expect(Array.isArray(result)).toBe(true);
+        expect(result.length).toBe(1);
+        expect(result[0]).toMatchObject({ name: "alice", dept_id: 10 });
+    });
+    it("returns all records when querying without filters", async () => {
+        const csvContent = "id,name\n1,alice\n2,bob\n3,carol";
+        const csvPath = await writeTempFile(csvContent, { format: "csv" });
+        const resource = { data: csvPath, dialect: { format: "csv" } };
+        const result = await queryTableTool.execute?.({
+            resource,
+            query: "SELECT * FROM self",
+        }, {});
+        expect.assert(result);
+        expect.assert(!("error" in result));
+        expect(Array.isArray(result)).toBe(true);
+        expect(result.length).toBe(3);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query.spec.js","sourceRoot":"","sources":["../../../tools/table/query.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Resource } from \"@fairspec/library\"\nimport { writeTempFile } from \"@fairspec/library\"\nimport { describe, expect, it } from \"vitest\"\nimport { queryTableTool } from \"./query.ts\"\n\ndescribe(\"queryTableTool\", () => {\n  it(\"validates tool structure\", () => {\n    expect(queryTableTool.id).toBe(\"query-table\")\n    expect(queryTableTool.description).toBeTruthy()\n    expect(queryTableTool.inputSchema).toBeTruthy()\n    expect(queryTableTool.outputSchema).toBeTruthy()\n    expect(queryTableTool.execute).toBeTypeOf(\"function\")\n  })\n\n  it(\"queries table with SELECT statement\", async () => {\n    const csvContent = \"id,name,age\\n1,alice,25\\n2,bob,30\\n3,carol,28\"\n    const csvPath = await writeTempFile(csvContent, { format: \"csv\" })\n    const resource: Resource = { data: csvPath, dialect: { format: \"csv\" } }\n\n    const result = await queryTableTool.execute?.(\n      {\n        resource,\n        query: \"SELECT * FROM self WHERE age > 25\",\n      },\n      {},\n    )\n\n    expect.assert(result)\n    expect.assert(!(\"error\" in result))\n\n    expect(Array.isArray(result)).toBe(true)\n    expect(result.length).toBe(2)\n    expect(result).toContainEqual({ id: 2, name: \"bob\", age: 30 })\n    expect(result).toContainEqual({ id: 3, name: \"carol\", age: 28 })\n  })\n\n  it(\"queries table with column selection\", async () => {\n    const csvContent =\n      \"id,name,age,city\\n1,alice,25,NYC\\n2,bob,30,LA\\n3,carol,28,SF\"\n    const csvPath = await writeTempFile(csvContent, { format: \"csv\" })\n    const resource: Resource = { data: csvPath, dialect: { format: \"csv\" } }\n\n    const result = await queryTableTool.execute?.(\n      {\n        resource,\n        query: \"SELECT name, city FROM self\",\n      },\n      {},\n    )\n\n    expect.assert(result)\n    expect.assert(!(\"error\" in result))\n\n    expect(Array.isArray(result)).toBe(true)\n    expect(result.length).toBe(3)\n    expect(result[0]).toHaveProperty(\"name\")\n    expect(result[0]).toHaveProperty(\"city\")\n    expect(result[0]).not.toHaveProperty(\"id\")\n    expect(result[0]).not.toHaveProperty(\"age\")\n  })\n\n  it(\"queries table with ORDER BY clause\", async () => {\n    const csvContent = \"id,name,score\\n1,alice,85\\n2,bob,90\\n3,carol,88\"\n    const csvPath = await writeTempFile(csvContent, { format: \"csv\" })\n    const resource: Resource = { data: csvPath, dialect: { format: \"csv\" } }\n\n    const result = await queryTableTool.execute?.(\n      {\n        resource,\n        query: \"SELECT * FROM self ORDER BY score DESC\",\n      },\n      {},\n    )\n\n    expect.assert(result)\n    expect.assert(!(\"error\" in result))\n\n    expect(Array.isArray(result)).toBe(true)\n    expect(result.length).toBe(3)\n    expect(result[0]).toMatchObject({ name: \"bob\", score: 90 })\n    expect(result[1]).toMatchObject({ name: \"carol\", score: 88 })\n    expect(result[2]).toMatchObject({ name: \"alice\", score: 85 })\n  })\n\n  it(\"queries table with aggregation\", async () => {\n    const csvContent = \"id,name,score\\n1,alice,85\\n2,bob,90\\n3,carol,88\"\n    const csvPath = await writeTempFile(csvContent, { format: \"csv\" })\n    const resource: Resource = { data: csvPath, dialect: { format: \"csv\" } }\n\n    const result = await queryTableTool.execute?.(\n      {\n        resource,\n        query: \"SELECT COUNT(*) as count, AVG(score) as avg_score FROM self\",\n      },\n      {},\n    )\n\n    expect.assert(result)\n    expect.assert(!(\"error\" in result))\n\n    expect(Array.isArray(result)).toBe(true)\n    expect(result.length).toBe(1)\n    expect(result[0]).toHaveProperty(\"count\")\n    expect(result[0]).toHaveProperty(\"avg_score\")\n  })\n\n  it(\"queries table with WHERE and LIMIT\", async () => {\n    const csvContent =\n      \"id,name,age\\n1,alice,25\\n2,bob,30\\n3,carol,28\\n4,dave,35\\n5,eve,22\"\n    const csvPath = await writeTempFile(csvContent, { format: \"csv\" })\n    const resource: Resource = { data: csvPath, dialect: { format: \"csv\" } }\n\n    const result = await queryTableTool.execute?.(\n      {\n        resource,\n        query: \"SELECT * FROM self WHERE age >= 25 ORDER BY age LIMIT 2\",\n      },\n      {},\n    )\n\n    expect.assert(result)\n    expect.assert(!(\"error\" in result))\n\n    expect(Array.isArray(result)).toBe(true)\n    expect(result.length).toBe(2)\n  })\n\n  it(\"queries inline data\", async () => {\n    const resource: Resource = {\n      data: [\n        { id: 1, name: \"alice\", score: 85 },\n        { id: 2, name: \"bob\", score: 90 },\n        { id: 3, name: \"carol\", score: 88 },\n      ],\n    }\n\n    const result = await queryTableTool.execute?.(\n      {\n        resource,\n        query: \"SELECT name, score FROM self WHERE score > 85\",\n      },\n      {},\n    )\n\n    expect.assert(result)\n    expect.assert(!(\"error\" in result))\n\n    expect(Array.isArray(result)).toBe(true)\n    expect(result.length).toBe(2)\n    expect(result).toContainEqual({ name: \"bob\", score: 90 })\n    expect(result).toContainEqual({ name: \"carol\", score: 88 })\n  })\n\n  it(\"queries with JOIN operations\", async () => {\n    const resource: Resource = {\n      data: [\n        { id: 1, name: \"alice\", dept_id: 10 },\n        { id: 2, name: \"bob\", dept_id: 20 },\n      ],\n    }\n\n    const result = await queryTableTool.execute?.(\n      {\n        resource,\n        query: \"SELECT * FROM self WHERE dept_id = 10\",\n      },\n      {},\n    )\n\n    expect.assert(result)\n    expect.assert(!(\"error\" in result))\n\n    expect(Array.isArray(result)).toBe(true)\n    expect(result.length).toBe(1)\n    expect(result[0]).toMatchObject({ name: \"alice\", dept_id: 10 })\n  })\n\n  it(\"returns all records when querying without filters\", async () => {\n    const csvContent = \"id,name\\n1,alice\\n2,bob\\n3,carol\"\n    const csvPath = await writeTempFile(csvContent, { format: \"csv\" })\n    const resource: Resource = { data: csvPath, dialect: { format: \"csv\" } }\n\n    const result = await queryTableTool.execute?.(\n      {\n        resource,\n        query: \"SELECT * FROM self\",\n      },\n      {},\n    )\n\n    expect.assert(result)\n    expect.assert(!(\"error\" in result))\n\n    expect(Array.isArray(result)).toBe(true)\n    expect(result.length).toBe(3)\n  })\n})\n"]}