creek 0.2.2 → 0.3.0-alpha.2

package/dist/commands/deploy.d.ts

@@ -0,0 +1,8 @@
+export declare const deployCommand: import("citty").CommandDef<{
+    "skip-build": {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;
+//# sourceMappingURL=deploy.d.ts.map

package/dist/commands/deploy.js

@@ -0,0 +1,146 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { execSync } from "node:child_process";
+import { parseConfig, CreekClient, isSSRFramework, getSSRServerEntry, getClientAssetsDir, } from "@solcreek/sdk";
+import { getToken, getApiUrl } from "../utils/config.js";
+import { collectAssets } from "../utils/bundle.js";
+import { bundleSSRServer } from "../utils/ssr-bundle.js";
+export const deployCommand = defineCommand({
+    meta: {
+        name: "deploy",
+        description: "Deploy the current project to Creek",
+    },
+    args: {
+        "skip-build": {
+            type: "boolean",
+            description: "Skip the build step",
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const cwd = process.cwd();
+        const configPath = join(cwd, "creek.toml");
+        if (!existsSync(configPath)) {
+            consola.error("No creek.toml found. Run `creek init` first.");
+            process.exit(1);
+        }
+        const config = parseConfig(readFileSync(configPath, "utf-8"));
+        consola.info(`Project: ${config.project.name}`);
+        const token = getToken();
+        if (!token) {
+            consola.error("Not authenticated. Run `creek login` first.");
+            process.exit(1);
+        }
+        const client = new CreekClient(getApiUrl(), token);
+        // Ensure project exists
+        let project;
+        try {
+            project = await client.getProject(config.project.name);
+        }
+        catch {
+            consola.info("Project not found, creating...");
+            const res = await client.createProject({
+                slug: config.project.name,
+                framework: config.project.framework,
+            });
+            project = res.project;
+            consola.success(`Created project: ${project.slug}`);
+        }
+        // Build
+        if (!args["skip-build"]) {
+            consola.start(`Building with: ${config.build.command}`);
+            try {
+                execSync(config.build.command, { cwd, stdio: "inherit" });
+            }
+            catch {
+                consola.error("Build failed");
+                process.exit(1);
+            }
+            consola.success("Build complete");
+        }
+        const outputDir = resolve(cwd, config.build.output);
+        if (!existsSync(outputDir)) {
+            consola.error(`Build output directory not found: ${config.build.output}`);
+            process.exit(1);
+        }
+        const framework = config.project.framework ?? null;
+        const isSSR = isSSRFramework(framework);
+        const renderMode = isSSR ? "ssr" : "spa";
+        // Collect client assets
+        let clientAssetsDir = outputDir;
+        if (isSSR && framework) {
+            const clientSubdir = getClientAssetsDir(framework);
+            if (clientSubdir) {
+                clientAssetsDir = resolve(outputDir, clientSubdir);
+            }
+        }
+        consola.start("Collecting assets...");
+        const { assets: clientAssets, fileList } = collectAssets(clientAssetsDir);
+        consola.info(`Found ${fileList.length} client assets`);
+        // Bundle server files for SSR
+        let serverFiles;
+        if (isSSR && framework) {
+            const serverEntry = getSSRServerEntry(framework);
+            if (serverEntry) {
+                const serverEntryPath = resolve(outputDir, serverEntry);
+                if (existsSync(serverEntryPath)) {
+                    consola.start("Bundling SSR server...");
+                    const bundled = await bundleSSRServer(serverEntryPath);
+                    // Send as base64-encoded single file
+                    serverFiles = {
+                        "server.js": Buffer.from(bundled).toString("base64"),
+                    };
+                    consola.success(`SSR server bundled (${Math.round(bundled.length / 1024)}KB)`);
+                }
+            }
+        }
+        // Create deployment
+        consola.start("Creating deployment...");
+        const { deployment } = await client.createDeployment(project.id);
+        // Upload bundle
+        consola.start("Uploading...");
+        const bundle = {
+            manifest: {
+                assets: fileList,
+                hasWorker: isSSR,
+                entrypoint: null,
+                renderMode,
+            },
+            workerScript: null,
+            assets: clientAssets,
+            serverFiles,
+        };
+        const result = await client.uploadDeploymentBundle(project.id, deployment.id, bundle);
+        if (result.url) {
+            consola.success(`Deployed! ${result.url}`);
+            if (result.previewUrl) {
+                consola.info(`Preview:  ${result.previewUrl}`);
+            }
+        }
+        else {
+            let status = deployment.status;
+            let url = null;
+            for (let i = 0; i < 30; i++) {
+                const res = await client.getDeploymentStatus(project.id, deployment.id);
+                status = res.deployment.status;
+                url = res.url;
+                if (status === "active" || status === "failed")
+                    break;
+                await new Promise((r) => setTimeout(r, 1000));
+            }
+            if (status === "active" && url) {
+                consola.success(`Deployed! ${url}`);
+            }
+            else if (status === "failed") {
+                consola.error("Deployment failed");
+                process.exit(1);
+            }
+            else {
+                consola.warn(`Deployment status: ${status}`);
+            }
+        }
+    },
+});
+//# sourceMappingURL=deploy.js.map

package/dist/commands/init.d.ts

@@ -0,0 +1,8 @@
+export declare const initCommand: import("citty").CommandDef<{
+    name: {
+        type: "string";
+        description: string;
+        required: false;
+    };
+}>;
+//# sourceMappingURL=init.d.ts.map

package/dist/commands/init.js

@@ -0,0 +1,60 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join, basename } from "node:path";
+import { stringify } from "smol-toml";
+import { detectFramework } from "@solcreek/sdk";
+export const initCommand = defineCommand({
+    meta: {
+        name: "init",
+        description: "Initialize a new Creek project",
+    },
+    args: {
+        name: {
+            type: "string",
+            description: "Project name",
+            required: false,
+        },
+    },
+    async run({ args }) {
+        const cwd = process.cwd();
+        const configPath = join(cwd, "creek.toml");
+        if (existsSync(configPath)) {
+            consola.warn("creek.toml already exists");
+            const overwrite = await consola.prompt("Overwrite?", { type: "confirm" });
+            if (!overwrite)
+                return;
+        }
+        // Detect framework
+        const pkgPath = join(cwd, "package.json");
+        let framework;
+        if (existsSync(pkgPath)) {
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+            const detected = detectFramework(pkg);
+            if (detected) {
+                framework = detected;
+                consola.info(`Detected framework: ${framework}`);
+            }
+        }
+        const defaultName = basename(cwd).toLowerCase().replace(/[^a-z0-9-]/g, "-");
+        const name = args.name ?? defaultName;
+        const config = {
+            project: {
+                name,
+                ...(framework ? { framework } : {}),
+            },
+            build: {
+                command: "npm run build",
+                output: "dist",
+            },
+            resources: {
+                d1: false,
+                kv: false,
+                r2: false,
+            },
+        };
+        writeFileSync(configPath, stringify(config));
+        consola.success(`Created creek.toml for "${name}"`);
+    },
+});
+//# sourceMappingURL=init.js.map

package/dist/commands/login.d.ts

@@ -0,0 +1,8 @@
+export declare const loginCommand: import("citty").CommandDef<{
+    token: {
+        type: "string";
+        description: string;
+        required: false;
+    };
+}>;
+//# sourceMappingURL=login.d.ts.map

package/dist/commands/login.js

@@ -0,0 +1,32 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+import { writeCliConfig, readCliConfig } from "../utils/config.js";
+export const loginCommand = defineCommand({
+    meta: {
+        name: "login",
+        description: "Authenticate with Creek using an API token",
+    },
+    args: {
+        token: {
+            type: "string",
+            description: "API token",
+            required: false,
+        },
+    },
+    async run({ args }) {
+        let token = args.token;
+        if (!token) {
+            token = await consola.prompt("Enter your API token:", {
+                type: "text",
+            });
+        }
+        if (!token || typeof token !== "string") {
+            consola.error("No token provided");
+            process.exit(1);
+        }
+        const config = readCliConfig();
+        writeCliConfig({ ...config, token });
+        consola.success("Token saved successfully");
+    },
+});
+//# sourceMappingURL=login.js.map

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import { defineCommand, runMain } from "citty";
+import { loginCommand } from "./commands/login.js";
+import { initCommand } from "./commands/init.js";
+import { deployCommand } from "./commands/deploy.js";
+const main = defineCommand({
+    meta: {
+        name: "creek",
+        version: "0.1.0",
+        description: "Deploy full-stack apps to the edge",
+    },
+    subCommands: {
+        login: loginCommand,
+        init: initCommand,
+        deploy: deployCommand,
+    },
+});
+runMain(main);
+//# sourceMappingURL=index.js.map

package/dist/utils/bundle.d.ts

@@ -0,0 +1,6 @@
+export interface BundleAssets {
+    assets: Record<string, string>;
+    fileList: string[];
+}
+export declare function collectAssets(dir: string, baseDir?: string): BundleAssets;
+//# sourceMappingURL=bundle.d.ts.map

package/dist/utils/bundle.js

@@ -0,0 +1,24 @@
+import { readFileSync, readdirSync } from "node:fs";
+import { join, relative } from "node:path";
+export function collectAssets(dir, baseDir) {
+    const base = baseDir ?? dir;
+    const assets = {};
+    const fileList = [];
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            const sub = collectAssets(fullPath, base);
+            Object.assign(assets, sub.assets);
+            fileList.push(...sub.fileList);
+        }
+        else if (entry.isFile()) {
+            const relPath = relative(base, fullPath);
+            const content = readFileSync(fullPath);
+            assets[relPath] = content.toString("base64");
+            fileList.push(relPath);
+        }
+    }
+    return { assets, fileList };
+}
+//# sourceMappingURL=bundle.js.map

package/dist/utils/config.d.ts

@@ -0,0 +1,11 @@
+interface CliConfig {
+    token?: string;
+    apiUrl?: string;
+}
+export declare function getConfigDir(): string;
+export declare function readCliConfig(): CliConfig;
+export declare function writeCliConfig(config: CliConfig): void;
+export declare function getToken(): string | undefined;
+export declare function getApiUrl(): string;
+export {};
+//# sourceMappingURL=config.d.ts.map

package/dist/utils/config.js

@@ -0,0 +1,33 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+const CONFIG_DIR = join(homedir(), ".creek");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+export function getConfigDir() {
+    return CONFIG_DIR;
+}
+export function readCliConfig() {
+    if (!existsSync(CONFIG_FILE))
+        return {};
+    try {
+        return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+export function writeCliConfig(config) {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+export function getToken() {
+    return process.env.CREEK_TOKEN ?? readCliConfig().token;
+}
+export function getApiUrl() {
+    return (process.env.CREEK_API_URL ??
+        readCliConfig().apiUrl ??
+        "https://api.creek.dev");
+}
+//# sourceMappingURL=config.js.map

package/dist/utils/ssr-bundle.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Bundle an SSR server entry point into a single standalone worker script.
+ * Uses esbuild (same bundler as wrangler) with node: builtins as externals.
+ */
+export declare function bundleSSRServer(entryPoint: string): Promise<string>;
+//# sourceMappingURL=ssr-bundle.d.ts.map

package/dist/utils/ssr-bundle.js

@@ -0,0 +1,48 @@
+import { build } from "esbuild";
+/**
+ * Bundle an SSR server entry point into a single standalone worker script.
+ * Uses esbuild (same bundler as wrangler) with node: builtins as externals.
+ */
+export async function bundleSSRServer(entryPoint) {
+    const result = await build({
+        entryPoints: [entryPoint],
+        bundle: true,
+        format: "esm",
+        platform: "neutral",
+        target: "es2022",
+        write: false,
+        minify: false,
+        external: [
+            "node:async_hooks",
+            "node:stream",
+            "node:stream/web",
+            "node:buffer",
+            "node:util",
+            "node:events",
+            "node:crypto",
+            "node:path",
+            "node:url",
+            "node:string_decoder",
+            "node:diagnostics_channel",
+            "node:process",
+            "node:fs",
+            "node:os",
+            "node:child_process",
+            "node:http",
+            "node:https",
+            "node:net",
+            "node:tls",
+            "node:zlib",
+            "node:perf_hooks",
+            "node:worker_threads",
+        ],
+        conditions: ["workerd", "worker", "import"],
+        mainFields: ["module", "main"],
+        logLevel: "warning",
+    });
+    if (result.errors.length > 0) {
+        throw new Error(`esbuild: ${result.errors.map((e) => e.text).join(", ")}`);
+    }
+    return result.outputFiles[0].text;
+}
+//# sourceMappingURL=ssr-bundle.js.map

package/package.json

@@ -1,24 +1,46 @@
 {
   "name": "creek",
-  "description": "Configurable stream aggregator",
-  "version": "0.2.2",
-  "author": {
-    "name": "Andy Kent",
-    "email": "andy@forward.co.uk"
+  "version": "0.3.0-alpha.2",
+  "description": "CLI for the Creek deployment platform",
+  "type": "module",
+  "bin": {
+    "creek": "./dist/index.js"
   },
-  "directories": { 
-    "lib" : "./lib"
-  },
-  "main": "lib/bootstrap",
-  "bin": "bin/creek",
-  "dependencies": {
-    "coffee-script": "1.0.1"
-  },
-  "engines": [ 
-    "node"
+  "files": [
+    "dist",
+    "!dist/**/*.test.*",
+    "!dist/**/*.map"
+  ],
+  "keywords": [
+    "creek",
+    "cli",
+    "deployment",
+    "cloudflare",
+    "workers"
   ],
+  "author": "SolCreek",
+  "license": "Apache-2.0",
+  "homepage": "https://creek.dev",
   "repository": {
     "type": "git",
-    "url": "http://github.com/andykent/creek.git"
+    "url": "https://github.com/solcreek/creek.git",
+    "directory": "packages/cli"
+  },
+  "dependencies": {
+    "citty": "^0.1.6",
+    "consola": "^3.4.2",
+    "smol-toml": "^1.3.1",
+    "esbuild": "^0.25.0",
+    "@solcreek/sdk": "0.1.0-alpha.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.2",
+    "@types/node": "^22.13.10"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
   }
 }

package/README.md

@@ -1,105 +0,0 @@
-When you've got a hosepipe, what you need is a Creek!
-=====================================================
-Creek is a dead simple way to run performant summary analysis over time series data. Creek is written in coffee-script and has only been tested with node 0.2.5.
-
-Current Status
---------------
-It's early days for the project and there may be some warts however Creek is currently used in production at Forward to analyse over 35 million messages per day.
-
-The command line tool and configuration interface is fairly stable however the code level interfaces not so much.
-
-Hello World Example
--------------------
-
-Get the code with either `npm install creek` or clone this repo and either add creek to your path or use ./bin/creek in place.
-
-then create a file somewhere called `hello.creek` containing the following...
-
-    parser 'words'
-    interface 'rest'
-    track 'unique-words', aggregator: distinct.alltime
-    track 'count', aggregator: count.alltime
-
-Then run `echo 'hello world from creek' | creek hello.creek` 
-
-To see Creek in action run `curl "http://localhost:8080/"` from another window.
-
-Twitter Example
----------------
-
-As with the hello world example above but using this config instead...
-
-    parser 'json', seperatedBy: '\r'
-    interface 'rest'
-    
-    track 'languages-seen'
-     aggregator: distinct.alltime
-     field: (o) -> if o.user then o.user.lang else undefined
-     
-    track 'popular-words'
-      aggregator: popular.timeboxed
-      field: (o) -> if o.text then o.text.toLowerCase().split(' ') else undefined
-      period: 60
-      precision: 5
-      top: 10
-      before: (v) -> if v and v.length > 4 then v else undefined
-      
-    track 'popular-urls'
-      aggregator: popular.timeboxed
-      field: (o) -> if o.text then o.text.split(' ') else undefined
-      period: 60*30
-      precision: 60
-      top: 5
-      before: (v) -> if v and v.indexOf('http://') is 0 then v else undefined
-
-Then run `curl http://stream.twitter.com/1/statuses/sample.json -u USERNAME:PASSWORD | creek twitter.creek` and visit `http://localhost:8080/`
-
-Parsers
--------
-You must choose a parser, the currently available options are...
-
-* words - this pushes each word to the aggregator using the current timestamp
-* json - expects line separated JSON objects
-* chunked - this is a generic parser which can chunk a stream based on any string or regex
-* zeromq - allows subscription to a zeromq channel rather than input on stdin.
-
-Currently all the parsers expect utf8 or a subset thereof.
-
-Interfaces
-----------
-There is currently only one interface available...
-
-* rest - this makes a JSON rest api available running on localhost:8080 by default.
-
-Aggregators
------------
-The currently available aggregators are...
-
-* count.alltime
-* count.timeboxed
-* distinct.alltime
-* distinct.timeboxed
-* max.alltime
-* max.timeboxed
-* mean.alltime
-* mean.timeboxed
-* min.alltime
-* min.timeboxed
-* popular.timeboxed
-* recent.limited
-* sum.alltime
-* sum.timeboxed
-
-All aggregators support `field` and `before` options and timeboxed ones also support `period` and `precision` settings. 
-
-* field - defaults to the whole object, can be a string in which case it uses that key on the object, or an integer in which case it uses that as a constant value, or a function which takes an object and returns a value to be used.
-* before - a function that takes each chunks field right before it is about to be pushed to the aggregator, you should return the original value, a modified value or undefined if you would like this chunk to be skipped.
-* period - this is the period in seconds over which you would like the timeboxed aggregation to run. A value of 60 will keep track of the value over the last rolling 1 min window. The default value is 60 seconds.
-* precision - the accuracy of the rolling time window specified in seconds. I general lower the value used here the more memory will be required. The default value is 1 second. 
-
-Notes
------
-Please note that the current aggregator implementations are fairly immature and they may not be optimal in terms of RAM or CPU usage at this point. 
-What I can say though is they are efficient enough for most use cases and Creek can comfortably handle dozens of aggregators running across 1,000s of records per second.
-
-If anyone would like to contribute interfaces, parsers or aggregators they would be gladly received.

package/bin/creek

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-
-require('coffee-script')
-process.title = 'creek'
-configFile = process.argv[2]
-if(configFile===undefined) {
-  console.log('Usage: `creek myconf.creek`')
-  process.exit(1)
-}
-require('./../lib/runner').boot(configFile)

package/examples/hello.creek

@@ -1,6 +0,0 @@
-parser 'words'
-interface 'rest'
-
-track 'unique-words', aggregator: distinct.alltime
-  
-track 'count', aggregator: count.alltime

package/examples/twitter.creek

@@ -1,23 +0,0 @@
-parser 'json', seperatedBy: '\r'
-interface 'rest'
-
-track 'languages-seen',
- aggregator: distinct.alltime
- field: (o) -> if o.user then o.user.lang else undefined
-
-track 'popular-words',
-  aggregator: popular.timeboxed
-  field: (o) -> if o.text then o.text.toLowerCase().split(' ') else undefined
-  period: 60
-  precision: 5
-  top: 10
-  keep: 5
-  before: (v) -> if v and v.length > 4 then v else undefined
-
-track 'popular-urls',
-  aggregator: popular.timeboxed
-  field: (o) -> if o.text then o.text.split(' ') else undefined
-  period: 60*30
-  precision: 60
-  top: 5
-  before: (v) -> if v and v.indexOf('http://') is 0 then v else undefined

package/examples/zeromq.creek

@@ -1,16 +0,0 @@
-parser 'zeromq', 
-  url:          'tcp://example:5555', 
-  channel:      'redirect',
-  as:           'json',
-  bucketedBy:   'site',
-  timestampedBy:'timestamp'
-
-interface 'rest'
-
-track 'count', aggregator: count.alltime
-track 'popular-keywords',
-  aggregator: popular.timeboxed
-  field: (o) -> unescape(o.keyword)
-  period: 60
-  precision: 5
-  top: 10

package/lib/aggregator.coffee

@@ -1,27 +0,0 @@
-events = require('events')
-
-class Aggregator
-  constructor: (name, implementation, opts) ->
-    @name = name
-    @implementation = implementation
-    @opts = opts
-    @implementation.init.call(this, @opts)
-    @cachedValue = null
-    @events = new events.EventEmitter()
-  on: (event, callback) ->
-    @events.on(event, callback)
-  push: (time, values) ->
-    values = [values] unless Array.isArray(values)
-    for value in values
-      value = @opts.before.call(this, value) if @opts.before
-      @implementation.push.call(this, time, value) unless value is undefined
-    oldValue = @cachedValue
-    @events.emit('change', @cachedValue, oldValue) unless @compute() is oldValue
-  compute: ->
-    @cachedValue = @implementation.compute.call(this)
-    @cachedValue = @opts.after.call(this, @cachedValue) if @opts.after
-    @cachedValue
-  value: ->
-    @cachedValue
-
-exports.buildAggregator = (name, implementation)-> ((opts) -> new Aggregator(name, implementation, opts))

package/lib/aggregators/count.coffee

@@ -1,15 +0,0 @@
-aggregator = require('../aggregator')
-timeboxedAggregator = require('../timeboxed-aggregator')
-
-exports.alltime = aggregator.buildAggregator 'Alltime Count',
-  init: (opts) -> @count = 0
-  push: (time, value) -> @count++
-  compute: -> @count
-
-exports.timeboxed = timeboxedAggregator.buildTimeboxedAggregator 'Timeboxed Count',
-  recalculateBlockData: (blockData, value) ->
-    blockData + 1
-  computeFromBlocks: (blocks) ->
-    count = 0
-    count += block.data for block in blocks
-    count

package/lib/aggregators/distinct.coffee

@@ -1,20 +0,0 @@
-aggregator = require('../aggregator')
-timeboxedAggregator = require('../timeboxed-aggregator')
-
-
-exports.alltime = aggregator.buildAggregator 'Alltime Distinct',
-  init: (opts) -> @records = []
-  push: (time, value) -> @records.push(value) if @records.indexOf(value) is -1
-  compute: -> @records
-
-
-exports.timeboxed = timeboxedAggregator.buildTimeboxedAggregator 'Timeboxed Distinct',
-  recalculateBlockData: (blockData, value) ->
-    blockData += value
-    blockData.push(value) if blockData.indexOf(value) is -1
-  computeFromBlocks: (blocks) ->
-    uniques = []
-    for block in blocks
-      for value in block
-        uniques.push(value) if uniques.indexOf(value) is -1
-    uniques

package/lib/aggregators/max.coffee

@@ -1,16 +0,0 @@
-aggregator = require('../aggregator')
-timeboxedAggregator = require('../timeboxed-aggregator')
-
-exports.alltime = aggregator.buildAggregator 'Alltime Maximum',
-  init: (opts) -> @max = null
-  push: (time, value) -> @max = value if @max == null or @max < value
-  compute: -> @max
-
-exports.timeboxed = timeboxedAggregator.buildTimeboxedAggregator 'Timeboxed Maximum',
-  recalculateBlockData: (blockData, value) ->
-    if blockData is null or blockData < value then value else blockData
-  computeFromBlocks: (blocks) ->
-    max = null
-    for block in blocks
-      max = block.data if max == null or max < block.data
-    max

package/lib/aggregators/mean.coffee

@@ -1,27 +0,0 @@
-aggregator = require('../aggregator')
-timeboxedAggregator = require('../timeboxed-aggregator')
-
-exports.alltime = aggregator.buildAggregator 'Alltime Mean',
-  init: (opts) -> 
-    @count = 0
-    @total = 0
-  push: (time, value) ->
-    @count++
-    @total += value
-  compute: -> @total / @count
-
-exports.timeboxed = timeboxedAggregator.buildTimeboxedAggregator 'Timeboxed Mean',
-  recalculateBlockData: (blockData, value) ->
-    blockData.count++
-    blockData.total += value
-    blockData
-  defaultBlockValue: ->
-    {total:0, count:0}
-  computeFromBlocks: (blocks) ->
-    total = 0
-    count = 0
-    for block in blocks
-      total += block.data.total
-      count += block.data.count
-    return 0 if count is 0
-    total / count

package/lib/aggregators/min.coffee

@@ -1,16 +0,0 @@
-aggregator = require('../aggregator')
-timeboxedAggregator = require('../timeboxed-aggregator')
-
-exports.alltime = aggregator.buildAggregator 'Alltime Minimum',
-  init: (opts) -> @max = null
-  push: (time, value) -> @max = value if @max == null or @max > value
-  compute: -> @max
-
-exports.timeboxed = timeboxedAggregator.buildTimeboxedAggregator 'Timeboxed Minimum',
-  recalculateBlockData: (blockData, value) ->
-    if blockData is null or blockData > value then value else blockData
-  computeFromBlocks: (blocks) ->
-    min = null
-    for block in blocks
-      min = block.data if min == null or min > block.data
-    min

package/lib/aggregators/popular.coffee

@@ -1,27 +0,0 @@
-timeboxedAggregator = require('../timeboxed-aggregator')
-
-exports.timeboxed = timeboxedAggregator.buildTimeboxedAggregator 'Timeboxed Popular',
-  init: (opts) ->
-    @numberOfResultsToKeep = opts.top
-    @numberOfResultsToKeep = 10 if @numberOfResultsToKeep is null
-  defaultBlockValue: () -> {}
-  closeBlock: (block) ->
-    values = Object.keys(block.data)
-    topValues = values.sort((a,b) -> block.data[b] - block.data[a])
-    topValues = topValues.slice(0, @numberOfResultsToKeep) if numberOfResultsToKeep?
-    topValues.reduce ((m,v) -> m[v] = block.data[v]; m), {}
-  recalculateBlockData: (blockData, value) ->
-    blockData[value] ?= 0
-    blockData[value]++
-    blockData
-  computeFromBlocks: (blocks) ->
-    completeBlocks = blocks.slice(0,blocks.length-1)
-    foldBlocksTogether = (m,v) -> 
-      for value, count of v.data
-        m[value] = 0 unless m[value]?
-        m[value] += count
-      m
-    foldedResults = completeBlocks.reduce foldBlocksTogether, {}
-    topValues = Object.keys(foldedResults).sort((a,b) -> foldedResults[b] - foldedResults[a])
-    topValues = topValues.slice(0, @numberOfResultsToKeep) if @numberOfResultsToKeep?
-    topValues.reduce ((m,v) -> m.push(value:v, count:foldedResults[v]); m), []

package/lib/aggregators/recent.coffee

@@ -1,10 +0,0 @@
-aggregator = require('../aggregator')
-
-exports.limited = aggregator.buildAggregator 'Most Recent',
-  init: (opts) -> 
-    @count = opts.count or 10
-    @items = []
-  push: (time, value) ->
-    @items.unshift(value)
-    @items.pop() if @items.length > @count
-  compute: -> @items

package/lib/aggregators/sum.coffee

@@ -1,17 +0,0 @@
-aggregator = require('../aggregator')
-timeboxedAggregator = require('../timeboxed-aggregator')
-
-
-exports.alltime = aggregator.buildAggregator 'Alltime Sum',
-  init: (opts) -> @total = 0
-  push: (time, value) -> @total += value
-  compute: -> @total
-
-
-exports.timeboxed = timeboxedAggregator.buildTimeboxedAggregator 'Timeboxed Sum',
-  recalculateBlockData: (blockData, value) ->
-    blockData += value
-  computeFromBlocks: (blocks) ->
-    total = 0
-    total += block.data for block in blocks
-    total

package/lib/bootstrap.js

@@ -1,5 +0,0 @@
-require('coffee-script')
-var creek = require('./creek')
-for(var key in creek) {
-  exports[key] = creek[key]
-}

package/lib/compound-aggregator.coffee

@@ -1,33 +0,0 @@
-class CompoundAggregator
-  constructor: ->
-    @aggregators = {}
-  track: (name, opts) ->
-    getValue = switch typeof opts.field
-      when 'string' then ((o) -> o[opts.field])
-      when 'number' then ((o) -> opts.field)
-      when 'function' then ((o) -> opts.field(o))
-      else ((o) -> o)
-    @aggregators[name] = {getValue:getValue, aggregator:opts.aggregator(opts)}
-    console.log("Tracking '#{@aggregators[name].aggregator.name}' as '#{name}' with #{JSON.stringify(opts)}")
-  on: (name, event, callback) ->
-    if arguments.length == 3
-      @aggregators[name].aggregator.on(event, callback)
-    else
-      event = name
-      callback = event
-      agg.aggregator.on(event, callback) for name, agg of @aggregators
-  push: (time, obj) ->
-    for name, agg of @aggregators
-      val = agg.getValue(obj)
-      agg.aggregator.push(time, val)
-  value: (name) ->
-    if typeof name is 'string'
-      console.log("Aggregation '#{name}' does not exist!") unless @aggregators[name]
-      @aggregators[name].aggregator.value()
-    else
-      ret = {}
-      for name, agg of @aggregators
-        ret[name] = agg.aggregator.value()
-      ret
-
-exports.create = -> new CompoundAggregator()

package/lib/creek.coffee

@@ -1,13 +0,0 @@
-exports.aggregator = require('./aggregator')
-exports.compoundAggregator = require('./compound-aggregator')
-exports.lazyBucketedAggregator = require('./lazy-bucketed-aggregator')
-
-exports.aggregators = 
-  count:    require('./aggregators/count')
-  distinct: require('./aggregators/distinct')
-  max:      require('./aggregators/max')
-  mean:     require('./aggregators/mean')
-  min:      require('./aggregators/min')
-  popular:  require('./aggregators/popular')
-  recent:   require('./aggregators/recent')
-  sum:      require('./aggregators/sum')

package/lib/interfaces/rest.coffee

@@ -1,30 +0,0 @@
-http = require('http')
-url = require('url')
-
-exports.init = (agg, opts) ->
-  console.log("Rest Server Started")
-  server = http.createServer (req, res) ->
-    path = url.parse(req.url).pathname
-    path = path.replace(opts.path, '') if opts.path
-    pathParts = path.split('/')
-    pathParts.shift()
-    buildResponse = (obj) ->
-      callback = url.parse(req.url, true).query?.callback
-      if callback?
-        "#{callback}(#{JSON.stringify(obj)});"
-      else
-        JSON.stringify(obj)
-    try
-      result = if pathParts.length is 0
-        buildResponse(agg.value())
-      else if pathParts.length is 1
-        buildResponse(agg.value(null, pathParts[0]))
-      else
-        buildResponse(agg.value(pathParts[1], pathParts[0]))
-    catch e
-      res.writeHead(500, 'Content-Type': 'application/json; charset=utf-8')
-      res.end(buildResponse(message: "Unable to display requested data"))
-      return
-    res.writeHead(200, 'Content-Type': 'application/json')
-    res.end(result)
-  server.listen (opts.port or 8080), (opts.host or 'localhost')

package/lib/interfaces/websocket.coffee

@@ -1,15 +0,0 @@
-http = require('http')
-io = require('socket.io')
-
-exports.init = (agg, opts) ->
-  server = http.createServer (req, res) ->
-   res.writeHead(200, {'Content-Type': 'text/html'})
-   res.write('<h1>Hello world</h1>')
-   res.end()
-  
-  server.listen(8888)
-  
-  socket = io.listen(server)
-  
-  agg.on 'change', (newValue) ->
-    socket.broadcast(JSON.stringify(newValue))

package/lib/lazy-bucketed-aggregator.coffee

@@ -1,35 +0,0 @@
-compoundAggregator = require('./compound-aggregator')
-
-class LazyBucketedAggregator
-  constructor: -> 
-    @aggregatorOpts = {}
-    @aggregators = {}
-    @events = []
-  track: (name, opts) ->
-    @aggregatorOpts[name] = opts
-    console.log("Lazy Tracking '#{name}' with #{JSON.stringify(opts)}")
-  on: (name, event, callback) ->
-    if arguments.length == 2
-      event = name
-      callback = event
-      name = null
-    @events.push( name:name, event:event, callback:callback )
-  push: (bucket, time, obj) ->
-    unless @aggregators[bucket]
-      @aggregators[bucket] = compoundAggregator.create()
-      @aggregators[bucket].track(name, opts) for name, opts of @aggregatorOpts
-      for e in @events
-        @aggregators[bucket].on e.name, e.event, (newValue, oldValue) -> e.callback(bucket, newValue, oldValue)
-    @aggregators[bucket].push(time, obj)
-  value: (name, bucket) ->
-    if bucket
-      @aggregators[bucket].value(name)
-    else
-      ret = {}
-      for bucket, agg of @aggregators
-        ret[bucket] = agg.value(name)
-      ret
-  buckets: ->
-    Object.keys(@aggregators)
-
-exports.create = -> new LazyBucketedAggregator()

package/lib/parsers/chunked.coffee

@@ -1,17 +0,0 @@
-class ChunkedStream
-  constructor: (opts, recordHandler) ->
-    @seperator = opts.seperatedBy or "\n"
-    @stream = process.openStdin()
-    @stream.setEncoding('utf8')
-    @patialData = ""
-    @recordHandler = recordHandler
-    @stream.on 'data', @dataHandler
-  dataHandler: (data) =>
-    @patialData += data
-    parts = @patialData.split(@seperator)
-    @patialData = parts.pop() # last part will be an incomplete chunk or an empty string if we are lucky
-    for chunk in parts
-      @recordHandler(chunk) if chunk
-
-
-exports.init = (agg, opts, handler) -> new ChunkedStream(opts, handler)

package/lib/parsers/json.coffee

@@ -1,9 +0,0 @@
-chunkedStream = require('./chunked')
-
-exports.init = (agg, opts, handler) ->
-  chunkedStream.init agg, opts, (chunk) ->
-    try
-      parsedLine = JSON.parse(chunk)
-    catch e
-    handler(parsedLine) if parsedLine
-    

package/lib/parsers/words.coffee

@@ -1,6 +0,0 @@
-chunkedStream = require('./chunked')
-
-exports.init = (agg, opts, handler) ->
-  opts.seperatedBy = /\W/
-  chunkedStream.init agg, opts, (chunk) ->
-    handler(chunk)

package/lib/parsers/zeromq.coffee

@@ -1,16 +0,0 @@
-zeromq = require('zeromq')
-
-
-exports.init = (agg, opts, handler) ->
-  socket = zeromq.createSocket('sub')
-  socket.connect(opts.url)
-  socket.subscribe(opts.channel) if opts.channel
-  socket.on 'message', (ch, data) -> 
-    utf8Data = data.toString('utf8')
-    if opts.as is 'json'
-      try
-        handler(JSON.parse(utf8Data))
-      catch e
-        console.log("ERR: failed to JSON parse - #{utf8Data}")
-    else
-      handler(utf8Data)

package/lib/runner.coffee

@@ -1,39 +0,0 @@
-creek = require('./creek')
-
-agg = creek.lazyBucketedAggregator.create()
-
-publicInterface = {}
-
-publicInterface.track = (name, opts) -> agg.track(name, opts)
-
-for name, code of creek.aggregators
-  publicInterface[name] = code
-
-publicInterface.interface = (interfaceName, opts) ->
-  opts ?= {}
-  require("./interfaces/#{interfaceName}").init(agg, opts)
-
-publicInterface.parser = (parserName, opts) ->
-  opts ?= {}
-  require("./parsers/#{parserName}").init agg, opts, (record) -> 
-    bucket = if opts.bucketedBy?
-      if typeof opts.bucketedBy is 'string'
-        record[opts.bucketedBy]
-      else
-        opts.bucketedBy(record)
-    else
-      null
-    timestamp = if opts.timestampedBy?
-      if typeof opts.timestampedBy is 'string'
-        new Date(record[opts.timestampedBy]) 
-      else
-        opts.timestampedBy(record)
-    else 
-      new Date()
-    agg.push((bucket or 'default'), timestamp, record)
-
-exports.boot = (configFile) ->
-  Script = process.binding('evals').Script
-  code = require('fs').readFileSync(configFile, 'utf8')
-  jsCode = require('coffee-script').compile(code)
-  Script.runInNewContext(jsCode, publicInterface, configFile)

package/lib/timeboxed-aggregator.coffee

@@ -1,64 +0,0 @@
-events = require('events')
-
-class TimeboxedAggregator
-  constructor: (name, implementation, opts) ->
-    @name = name
-    @opts = opts
-    @implementation = implementation
-    @period = (opts.period or 60) * 1000
-    @precision = (opts.precision or 1) * 1000
-    @historySize = opts.keep or 1
-    @history = []
-    @cachedValue = null
-    @blocks = []
-    @implementation.init.call(this, opts) if @implementation.init
-    @events = new events.EventEmitter()
-    @staleCache =  false
-    setInterval (=> @compute(true)), @precision
-  on: (event, callback) ->
-    @events.on(event, callback)
-  push: (time, values) ->
-    currentBlock = @maybeCreateNewBlock(time)
-    values = [values] unless Array.isArray(values)
-    for value in values
-      value = @opts.before.call(this, value) if @opts.before
-      currentBlock.data = @implementation.recalculateBlockData.call(this, currentBlock.data, value, currentBlock.time, time) unless value is undefined
-    oldValue = @cachedValue
-    @compute()
-    @events.emit('change', @cachedValue, oldValue) if @cachedValue != oldValue
-  compute: (force=false) ->
-    @cleanup()
-    if force or @staleCache
-      @cachedValue = @implementation.computeFromBlocks.call(this, @blocks)
-      @cachedValue = @opts.after.call(this, @cachedValue) if @opts.after
-      @updateHistory()
-      @staleCache = false
-    @cachedValue
-  value: ->
-    @cachedValue
-  maybeCreateNewBlock: (time) ->
-    if @blocks.length == 0
-      @blocks.push( time:time, data:@defaultBlockValue() )
-      return @blocks[@blocks.length-1]
-    lastBlock = @blocks[@blocks.length-1]
-    diff = time - lastBlock.time.getTime()
-    if diff > @precision
-      @blocks.push( time:time, data:@defaultBlockValue() )
-      @blocks[@blocks.length-2].data = @implementation.closeBlock(lastBlock) if @implementation.closeBlock
-      @staleCache = true
-    @blocks[@blocks.length-1]
-  cleanup: ->
-    periodThreshold = new Date().getTime() - @period
-    loop
-      break if @blocks.length == 0 or @blocks[0].time.getTime() > periodThreshold
-      @blocks.shift()
-  defaultBlockValue: -> 
-    if @implementation.defaultBlockValue then @implementation.defaultBlockValue.call(this) else null
-  updateHistory: ->
-    @history.unshift(@cachedValue)
-    @history.pop() if @history.length > @historySize
-    @history
-
-exports.TimeboxedAggregator = TimeboxedAggregator
-
-exports.buildTimeboxedAggregator = (name, implementation)-> ((opts) -> new TimeboxedAggregator(name, implementation, opts))