flowquery 1.0.0

package/flowquery-vscode/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "flowquery-vscode",
+  "displayName": "FlowQuery-VSCode",
+  "icon": "images/FlowQueryLogoIcon.png",
+  "description": "FlowQuery - A declarative query language for data processing pipelines.",
+  "version": "0.0.1",
+  "publisher": "FlowQuery",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/microsoft/FlowQuery"
+  },
+  "engines": {
+    "vscode": "^1.104.0"
+  },
+  "categories": [
+    "Other"
+  ],
+  "activationEvents": [
+    "onCommand:extension.runFlowQueryStatement"
+  ],
+  "main": "./extension.js",
+  "contributes": {
+    "commands": [
+      {
+        "command": "extension.runFlowQueryStatement",
+        "title": "Run FlowQuery statement"
+      }
+    ],
+    "keybindings": [
+      {
+        "command": "extension.runFlowQueryStatement",
+        "key": "shift+enter",
+        "when": "editorTextFocus && resourceExtname == .cql"
+      }
+    ]
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "pretest": "npm run lint",
+    "test": "vscode-test"
+  },
+  "devDependencies": {
+    "@types/vscode": "^1.104.0",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "22.x",
+    "eslint": "^9.34.0",
+    "@vscode/test-cli": "^0.0.11",
+    "@vscode/test-electron": "^2.5.2"
+  }
+}

package/flowquery-vscode/test/extension.test.js

@@ -0,0 +1,196 @@
+const assert = require('assert');
+const vscode = require('vscode');
+
+suite('Extension Test Suite', () => {
+	vscode.window.showInformationMessage('Start all tests.');
+
+	test('command is registered', async () => {
+		// Explicitly activate the extension under test before checking registered commands.
+		let ext = vscode.extensions.getExtension('Microsoft.flowquery-vscode');
+		if (!ext) {
+			ext = vscode.extensions.all.find(e => e.packageJSON && e.packageJSON.name === 'flowquery-vscode');
+		}
+		if (!ext) {
+			assert.fail('Extension under test not found in extension host');
+		}
+		await ext.activate();
+
+		const commands = await vscode.commands.getCommands(true);
+		assert.ok(commands.includes('extension.runFlowQueryStatement'), 'extension.runFlowQueryStatement should be registered');
+	});
+
+	test('runFlowQueryStatement produces expected output', async function() {
+		this.timeout(5000);
+
+		// Activate the extension and arrange multiple capture strategies (appendLine + information messages)
+		const outputs = [];
+		const messages = [];
+		const origShowInformationMessage = vscode.window.showInformationMessage;
+		vscode.window.showInformationMessage = function(msg) { messages.push(msg); return origShowInformationMessage.call(vscode.window, msg); };
+
+		// Stub createWebviewPanel so we can capture webview.html being set by the extension
+		const origCreateWebviewPanel = vscode.window.createWebviewPanel;
+		let capturedHtml = null;
+		vscode.window.createWebviewPanel = /** @type {any} */ (function() {
+			const webview = {};
+			Object.defineProperty(webview, 'html', {
+				set: function(html) { capturedHtml = html; },
+				get: function() { return capturedHtml; }
+			});
+			webview.onDidReceiveMessage = function() { return { dispose: function() {} }; };
+			return /** @type {any} */ ({ webview });
+		});
+
+		let ext = vscode.extensions.getExtension('Microsoft.flowquery-vscode');
+		if (!ext) {
+			ext = vscode.extensions.all.find(e => e.packageJSON && e.packageJSON.name === 'flowquery-vscode');
+		}
+		if (!ext) {
+			assert.fail('Extension under test not found in extension host');
+		}
+		await ext.activate();
+
+		let channel, origAppendLine;
+		if (ext.exports && ext.exports._outputChannel) {
+			channel = ext.exports._outputChannel;
+			origAppendLine = channel.appendLine.bind(channel);
+			channel.appendLine = (text) => { outputs.push(text); return origAppendLine(text); };
+		}
+
+		try {
+			const doc = await vscode.workspace.openTextDocument({ content: 'return "hello from test"' });
+			await vscode.window.showTextDocument(doc);
+			await vscode.commands.executeCommand('extension.runFlowQueryStatement');
+
+			// The command should execute without throwing. Ensure the extension exposes the output channel
+			// so callers/tests can instrument or observe output if desired.
+			// assert.ok(ext.exports && ext.exports._outputChannel, 'Expected extension to expose _outputChannel for instrumentation');
+
+			// Ensure the command executed without throwing
+			assert.ok(true, 'Command executed without throwing');
+		} finally {
+			// Restore original appendLine implementation on the wrapped output channel, if used
+			if (typeof channel !== 'undefined' && typeof origAppendLine !== 'undefined') {
+				channel.appendLine = origAppendLine;
+			}
+			// Restore original showInformationMessage implementation
+			vscode.window.showInformationMessage = origShowInformationMessage;
+			// Restore original createWebviewPanel implementation
+			vscode.window.createWebviewPanel = origCreateWebviewPanel;
+		}
+	});
+
+	test('cancellation terminates worker and logs cancellation', async function() {
+		this.timeout(8000);
+
+		// Activate extension
+		let ext = vscode.extensions.getExtension('Microsoft.flowquery-vscode');
+		if (!ext) {
+			ext = vscode.extensions.all.find(e => e.packageJSON && e.packageJSON.name === 'flowquery-vscode');
+		}
+		if (!ext) {
+			assert.fail('Extension under test not found in extension host');
+		}
+		await ext.activate();
+
+		const outputs = [];
+		let channel, origAppendLine;
+		if (ext.exports && ext.exports._outputChannel) {
+			channel = ext.exports._outputChannel;
+			origAppendLine = channel.appendLine.bind(channel);
+			channel.appendLine = (text) => { outputs.push(text); return origAppendLine(text); };
+		}
+
+		try {
+			const doc = await vscode.workspace.openTextDocument({ content: '__TEST_SLEEP__:3000' });
+			await vscode.window.showTextDocument(doc);
+
+			// Start the query but don't await its completion so we can cancel it
+			const execPromise = vscode.commands.executeCommand('extension.runFlowQueryStatement');
+
+			// Wait for the extension to expose the running worker/process so we can reliably cancel it
+			const start2 = Date.now();
+			while (Date.now() - start2 < 2000) {
+				if (ext.exports && ext.exports._lastWorker) break;
+				await new Promise(r => setTimeout(r, 50));
+			}
+
+			// Programmatically cancel the running worker via exported test helper
+			if (ext.exports && typeof ext.exports._cancelCurrentlyRunningQuery === 'function') {
+				ext.exports._cancelCurrentlyRunningQuery();
+			} else {
+				// If helper isn't available, try an alternate test command (no-op if not present)
+				try { await vscode.commands.executeCommand('extension._testCancelQuery'); } catch {}
+			}
+
+			// Wait up to 4s for the extension to append a cancellation message
+			const start = Date.now();
+			while (Date.now() - start < 4000) {
+				if (outputs.some(s => /cancel/i.test(s))) break;
+				await new Promise(r => setTimeout(r, 100));
+			}
+
+			// Wait for the extension to clear the lastWorker reference after cancellation
+			const waitClearStart = Date.now();
+			while (Date.now() - waitClearStart < 4000) {
+				if (!(ext.exports && ext.exports._lastWorker)) break;
+				await new Promise(r => setTimeout(r, 50));
+			}
+			assert.ok(!(ext.exports && ext.exports._lastWorker), `Expected lastWorker to be cleared after cancellation. lastWorker: ${ext.exports && ext.exports._lastWorker}`);
+			// If outputs were captured, ensure the extension did not append a JSON result after cancellation
+			if (outputs.length > 0) {
+				const jsonCandidate = outputs.find(s => s.trim().startsWith('[') || s.trim().startsWith('{'));
+				assert.ok(!jsonCandidate, `Expected no JSON result after cancellation but found: ${jsonCandidate}`);
+			}
+
+			// Ensure the command finishes before exiting the test
+			try { await execPromise; } catch { /* ignore errors from cancelled execution */ }
+		} finally {
+			if (typeof channel !== 'undefined' && typeof origAppendLine !== 'undefined') {
+				channel.appendLine = origAppendLine;
+			}
+		}
+	});
+
+	test('env file substitutions are applied', async function() {
+		this.timeout(2000);
+
+		const os = require('os');
+		const fs = require('fs');
+		const path = require('path');
+
+		const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'flowquery-env-'));
+		try {
+			fs.writeFileSync(path.join(tmpDir, '.env'), 'GREETING=world\nFOO="bar baz"\n', 'utf8');
+			const docPath = path.join(tmpDir, 'query.fq');
+			const docText = 'return $GREETING; return "$FOO"';
+			fs.writeFileSync(docPath, docText, 'utf8');
+
+			let ext = vscode.extensions.getExtension('Microsoft.flowquery-vscode');
+			if (!ext) {
+				ext = vscode.extensions.all.find(e => e.packageJSON && e.packageJSON.name === 'flowquery-vscode');
+			}
+			if (!ext) {
+				assert.fail('Extension under test not found in extension host');
+			}
+			await ext.activate();
+
+			// Require the extension module directly so we can call the helper synchronously
+			const extModule = require(path.join(__dirname, '..', 'extension.js'));
+			const substituted = typeof extModule._applyEnvSubstitutions === 'function'
+				? extModule._applyEnvSubstitutions(docText, docPath)
+				: docText;
+
+			// For debugging in CI logs, show the substituted value briefly
+			console.log('SUBSTITUTED:', substituted);
+
+			// Validate substitutions were applied
+			assert.ok(substituted.includes('world'), `Expected substituted string to include 'world' but got: ${substituted}`);
+			assert.ok(substituted.includes('bar baz'), `Expected substituted string to include 'bar baz' but got: ${substituted}`);
+		} finally {
+			try { fs.unlinkSync(path.join(tmpDir, '.env')); } catch {}
+			try { fs.unlinkSync(path.join(tmpDir, 'query.fq')); } catch {}
+			try { fs.rmdirSync(tmpDir); } catch {}
+		}
+	});
+});

package/flowquery-vscode/test/worker.test.js

@@ -0,0 +1,25 @@
+const assert = require('assert');
+const cp = require('child_process');
+const path = require('path');
+
+suite('Worker Test Suite', () => {
+	test('worker responds to TEST_SLEEP payload', async function() {
+		this.timeout(5000);
+		const workerPath = path.join(__dirname, '..', 'flowquery-worker.js');
+		const proc = cp.fork(workerPath);
+		const result = await new Promise((resolve, reject) => {
+			proc.on('message', (msg) => {
+				const m = /** @type {any} */ (msg);
+				if (m && m.type === 'results') resolve(m.results);
+				else if (m && m.type === 'error') reject(new Error(m.message || 'unknown'));
+			});
+			proc.on('error', reject);
+			proc.on('exit', (code) => { if (code !== 0) reject(new Error('exit ' + code)); });
+			proc.send('__TEST_SLEEP__:50');
+		});
+
+		assert.ok(Array.isArray(result));
+		assert.ok(result[0] && result[0].expr0 && result[0].expr0.indexOf('slept') === 0);
+	});
+
+});

package/flowquery-vscode/vsc-extension-quickstart.md

@@ -0,0 +1,42 @@
+# Welcome to your VS Code Extension
+
+## What's in the folder
+
+* This folder contains all of the files necessary for your extension.
+* `package.json` - this is the manifest file in which you declare your extension and command.
+  * The sample plugin registers a command and defines its title and command name. With this information VS Code can show the command in the command palette. It doesn’t yet need to load the plugin.
+* `extension.js` - this is the main file where you will provide the implementation of your command.
+  * The file exports one function, `activate`, which is called the very first time your extension is activated (in this case by executing the command). Inside the `activate` function we call `registerCommand`.
+  * We pass the function containing the implementation of the command as the second parameter to `registerCommand`.
+
+## Get up and running straight away
+
+* Press `F5` to open a new window with your extension loaded.
+* Run your command from the command palette by pressing (`Ctrl+Shift+P` or `Cmd+Shift+P` on Mac) and typing `Hello World`.
+* Set breakpoints in your code inside `extension.js` to debug your extension.
+* Find output from your extension in the debug console.
+
+## Make changes
+
+* You can relaunch the extension from the debug toolbar after changing code in `extension.js`.
+* You can also reload (`Ctrl+R` or `Cmd+R` on Mac) the VS Code window with your extension to load your changes.
+
+## Explore the API
+
+* You can open the full set of our API when you open the file `node_modules/@types/vscode/index.d.ts`.
+
+## Run tests
+
+* Install the [Extension Test Runner](https://marketplace.visualstudio.com/items?itemName=ms-vscode.extension-test-runner)
+* Open the Testing view from the activity bar and click the Run Test" button, or use the hotkey `Ctrl/Cmd + ; A`
+* See the output of the test result in the Test Results view.
+* Make changes to `test/extension.test.js` or create new test files inside the `test` folder.
+  * The provided test runner will only consider files matching the name pattern `**.test.js`.
+  * You can create folders inside the `test` folder to structure your tests any way you want.
+
+## Go further
+
+ * [Follow UX guidelines](https://code.visualstudio.com/api/ux-guidelines/overview) to create extensions that seamlessly integrate with VS Code's native interface and patterns.
+ * [Publish your extension](https://code.visualstudio.com/api/working-with-extensions/publishing-extension) on the VS Code extension marketplace.
+ * Automate builds by setting up [Continuous Integration](https://code.visualstudio.com/api/working-with-extensions/continuous-integration).
+ * Integrate to the [report issue](https://code.visualstudio.com/api/get-started/wrapping-up#issue-reporting) flow to get issue and feature requests reported by users.

package/jest.config.js

@@ -0,0 +1,11 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} **/
+module.exports = {
+  testEnvironment: "node",
+  transform: {
+    "^.+.tsx?$": ["ts-jest",{}],
+  },
+  testPathIgnorePatterns: [
+    "/node_modules/",
+    "/flowquery-vscode/test/"
+  ],
+};

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "flowquery",
+  "version": "1.0.0",
+  "description": "A declarative query language for data processing pipelines.",
+  "main": "index.js",
+  "scripts": {
+    "start": "ts-node src/index.ts",
+    "test": "jest",
+    "build": "webpack && copyfiles -f dist/flowquery.min.js docs/ && copyfiles -f dist/flowquery.min.js flowquery-vscode/flowQueryEngine/",
+    "main": "tsc & node dist/index.js",
+    "docs": "typedoc --out docs/api src/index.ts"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^25.0.3",
+    "copyfiles": "^2.4.1",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "ts-loader": "^9.5.1",
+    "typedoc": "^0.28.14",
+    "typescript": "^5.7.2",
+    "webpack": "^5.97.1",
+    "webpack-cli": "^6.0.1"
+  }
+}

package/queries/analyze_catfacts.cql

@@ -0,0 +1,75 @@
+/*
+  This query demonstrates how to use the OpenAI API in FlowQuery to analyze cat facts.
+  
+  To run this query, you need to create a .env file in the same folder as this query within your VSCode project.
+  Create two variables in the .env file:
+    OPENAI_API_KEY='YOUR_OPENAI_API_KEY'
+    OPENAI_ORGANIZATION_ID='YOUR_OPENAI_ORGANIZATION_ID'
+
+  This FlowQuery script implements a chain-of-thoughts LLM pipeline which does the following steps:
+    1. Fetches 10 cat facts from the Cat Facts API and collects them into a list.
+    2. Creates a prompt to analyze the cat facts.
+    3. Calls the OpenAI API with the prompt to get an analysis of the cat facts.
+    4. Creates a second prompt to extract topics from the analysis.
+    5. Calls the OpenAI API with the second prompt to get a list of topics.
+    6. Returns the cat facts, the analysis, and the topics.
+*/
+
+// Setup OpenAI API key and organization ID (read from .env file in same directory as this query file)
+with
+    '$OPENAI_API_KEY' as OPENAI_API_KEY,
+    '$OPENAI_ORGANIZATION_ID' as OPENAI_ORGANIZATION_ID
+
+// 1. Get 10 cat facts and collect them into a list
+unwind range(0,10) as i
+load json from "https://catfact.ninja/fact" as item
+with collect(item.fact) as catfacts
+
+// 2. Create prompt to analyze cat facts
+with f"
+Analyze the following cat facts and answer with a short (1-3 sentences max) summary of the most interesting facts, and what they imply about cats as pets:
+{stringify(catfacts)}
+" as catfacts_analysis_prompt
+
+// 3. Call OpenAI API to analyze cat facts
+load json from 'https://api.openai.com/v1/chat/completions'
+headers {
+    `Content-Type`: 'application/json',
+    Authorization: f'Bearer {OPENAI_API_KEY}',
+    `OpenAI-Organization`: OPENAI_ORGANIZATION_ID
+}
+post {
+    model: 'gpt-4o-mini',
+    messages: [{role: 'user', content: catfacts_analysis_prompt}],
+    temperature: 0.7
+} as openai_response
+with openai_response.choices[0].message.content as catfacts_analysis
+
+// 4. Create a second prompt to extract topics from the analysis
+with f"
+Extract the main topics from the following analysis of cat facts, only single-word topics. Return the topics as a comma-separated list.
+Analysis:
+{catfacts_analysis}
+" as catfacts_topics_prompt
+
+// 5. Call OpenAI API to extract topics
+load json from 'https://api.openai.com/v1/chat/completions'
+headers {
+    `Content-Type`: 'application/json',
+    Authorization: f'Bearer {OPENAI_API_KEY}',
+    `OpenAI-Organization`: OPENAI_ORGANIZATION_ID
+}
+post {
+    model: 'gpt-4o-mini',
+    messages: [{role: 'user', content: catfacts_topics_prompt}],
+    temperature: 0.7
+} as openai_topics_response
+with openai_topics_response.choices[0].message.content as catfacts_topics
+
+// 6. Return the analysis
+return
+    catfacts as `Cat Facts from API`,
+    catfacts_analysis_prompt as `Cat Facts Analysis Prompt`,
+    catfacts_analysis as `Cat Facts Analysis by gpt-4o-mini`,
+    catfacts_topics_prompt as `Cat Facts Topics Prompt`,
+    catfacts_topics as `Cat Facts Topics by gpt-4o-mini`

package/queries/azure_openai_completions.cql

@@ -0,0 +1,13 @@
+// Test completion from Azure OpenAI API
+with
+    '$AZURE_OPENAI_API_KEY' as AZURE_OPENAI_API_KEY
+load json from '$AZURE_OPENAI_ENDPOINT'
+headers {
+    `Content-Type`: 'application/json',
+    `api-key`: AZURE_OPENAI_API_KEY,
+}
+post {
+    messages: [{role: 'user', content: 'Answer with this is a test!'}],
+    temperature: 0.7
+} as data
+return data

package/queries/azure_openai_models.cql

@@ -0,0 +1,9 @@
+// Return models from Azure OpenAI API
+with
+    '$AZURE_OPENAI_API_KEY' as AZURE_OPENAI_API_KEY
+load json from '$AZURE_OPENAI_MODELS_LIST_ENDPOINT'
+headers {
+    `api-key`: f'{AZURE_OPENAI_API_KEY}'
+} as l
+unwind l.data as model
+return model

package/queries/mock_pipeline.cql

@@ -0,0 +1,84 @@
+unwind [
+    {
+        situation_recap: "Once upon a time, there was a conversation. It was a good conversation. There were many objectives in the conversation.",
+        objectives: ["Objective 1", "Objective 2"],
+        feedbacks: [
+            {
+                feedbackType: "compliment",
+                reasoning: "You conversed well",
+                title: "Good job"
+            },
+            {
+                feedbackType: "suggestion",
+                reasoning: "Don't forget to remember",
+                title: "Don't forget"
+            }
+        ],
+        contacts: [
+            {email: "bob@mail.com", displayName: "Bob"},
+            {email: "jane@mail.com", displayName: "Jane"}
+        ],
+        dimension: "Coaching",
+        supporting_messages: [
+            {
+                text: "This is a supporting message",
+                sender: {
+                    email: "bob@mail.com",
+                    displayName: "Bob"
+                }
+            },
+            {
+                text: "This is another supporting message",
+                sender: {
+                    email: "jane@mail.com",
+                    displayName: "Jane"
+                }
+            }
+        ]
+    },
+    {
+        situation_recap: "The conversation was about a topic. The objectives were clear. The feedbacks were insightful.",
+        objectives: ["Objective 3", "Objective 4"],
+        feedbacks: [
+            {
+                feedbackType: "compliment",
+                reasoning: "Very funny conversation",
+                title: "Good job"
+            },
+            {
+                feedbackType: "suggestion",
+                reasoning: "Remember to not forget",
+                title: "Remember"
+            }
+        ],
+        contacts: [
+            {email: "robot@mail.com", displayName: "Robot"},
+            {email: "r2d2@mail.com", displayName: "R2D2"}
+        ],
+        dimension: "Coaching",
+        supporting_messages: [
+            {
+                text: "This is a robot supporting message",
+                sender: {
+                    email: "robot@mail.com",
+                    displayName: "Robot"
+                }
+            },
+            {
+                text: "This is a R2D2 supporting message",
+                sender: {
+                    email: "r2d2@mail.com",
+                    displayName: "R2D2"
+                }
+            }
+        ]
+    }
+] as coach_note
+return
+    coach_note.situation_recap as situation_recap,
+    coach_note.objectives as objectives,
+    coach_note.feedbacks as feedbacks,
+    coach_note.contacts as contacts,
+    coach_note.dimension as dimension,
+    'AGGREGATE_COACH_NOTE' as type,
+    coach_note.supporting_messages as supporting_messages

package/queries/openai_completions.cql

@@ -0,0 +1,15 @@
+// Test completion from OpenAI API
+with
+    '$OPENAI_API_KEY' as OPENAI_API_KEY
+load json from 'https://api.openai.com/v1/chat/completions'
+headers {
+    `Content-Type`: 'application/json',
+    Authorization: f'Bearer {OPENAI_API_KEY}',
+    `OpenAI-Organization`: '$OPENAI_ORGANIZATION_ID' // Must be set to the organization ID
+}
+post {
+    model: 'gpt-4o-mini',
+    messages: [{role: 'user', content: 'Answer with this is a test!'}],
+    temperature: 0.7
+} as data
+return data

package/queries/openai_models.cql

@@ -0,0 +1,13 @@
+// Return models from OpenAI API
+with
+    '$OPENAI_API_KEY' as OPENAI_API_KEY
+load json from 'https://api.openai.com/v1/models'
+headers {
+    Authorization: f'Bearer {OPENAI_API_KEY}'
+} as l
+unwind l.data as model
+return
+    model.id as `Model ID`,
+    model.object as `Object Type`,
+    model.created as `Created Timestamp`,
+    model.owned_by as `Owned By`

package/queries/test.cql

@@ -0,0 +1,6 @@
+// 1. Get 10 cat facts and collect them into a list
+unwind range(0,10) as i
+load json from "https://catfact.ninja/fact" as fact
+
+// Return the cat facts
+return fact.fact as `Fact about cats`, fact.length as `Fact Length`

package/queries/tool_inference.cql

@@ -0,0 +1,24 @@
+with
+    '$OPENAI_API_KEY' as OPENAI_API_KEY,
+    '$OPENAI_ORGANIZATION_ID' as OPENAI_ORG_ID
+unwind ["Where is my document?", "Who is Niclas?", "Who is my manager?"] as query
+with f`
+If query is people-related, then output:
+people_search('query')
+Otherwise, output:
+search('query')
+
+Here is the query: "{query}"
+` as instruction
+load json from 'https://api.openai.com/v1/chat/completions'
+headers {
+    `Content-Type`: 'application/json',
+    Authorization: f'Bearer {OPENAI_API_KEY}',
+    `OpenAI-Organization`: OPENAI_ORG_ID
+}
+post {
+    model: 'gpt-4o-mini',
+    messages: [{role: 'user', content: instruction}],
+    temperature: 0.7
+} as data
+return query, data.choices[0].message.content as tool

package/queries/wisdom.cql

@@ -0,0 +1,6 @@
+/*
+Collect 10 random pieces of wisdom from the Advice Slip API and return them.
+*/
+unwind range(0,10) as i
+load json from "https://api.adviceslip.com/advice" as item
+return item.slip.advice as `Wisdom`

package/queries/wisdom_letter_histogram.cql

@@ -0,0 +1,8 @@
+/*
+Collect 10 random pieces of wisdom and create a letter histogram.
+*/
+unwind range(0,10) as i
+load json from "https://api.adviceslip.com/advice" as item
+with join(collect(item.slip.advice),"") as wisdom
+unwind split(wisdom,"") as letter
+return letter, sum(1) as lettercount