investing 0.1.0 → 0.1.2

package/dist/correlate/predict-statistics.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @file predict-statistics.ts
+ * @description Statistical analysis and prediction library - main export file.
+ *
+ * This file serves as a barrel export for all statistical prediction functionality,
+ * providing a single import point for all modules.
+ */
+export type { XGBoostParams, TrainModelOptions, PredictOptions, TrainTestSplit, } from './types';
+export { trainModels, splitTrainTest } from './xgboost-trainer';
+export { predictFuture } from './xgboost-predictor';
+export { calculateRMSE, calculateR2 } from './metrics';
+export { saveModel, loadModel } from './model-persistence';
+export { calculateRollingStats } from './rolling-stats';
+//# sourceMappingURL=predict-statistics.d.ts.map

package/dist/correlate/predict-statistics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predict-statistics.d.ts","sourceRoot":"","sources":["../../src/correlate/predict-statistics.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,YAAY,EACV,aAAa,EACb,iBAAiB,EACjB,cAAc,EACd,cAAc,GACf,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGhE,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGpD,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAGvD,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAG3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/correlate/rolling-stats.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @file rolling-stats.ts
+ * @description Rolling window statistical calculations for time series data.
+ */
+/**
+ * Calculate rolling statistics for a given array of values
+ *
+ * Computes rolling mean and standard deviation over a sliding window.
+ * Rolling statistics help identify trends and volatility in time series data.
+ *
+ * @param data - Array of data objects
+ * @param field - Field name to calculate rolling stats for
+ * @param window - Rolling window size (default: 7)
+ * @returns Array with added rolling statistics fields:
+ *   - `${field}_rolling_mean_${window}d`: Rolling mean
+ *   - `${field}_rolling_std_${window}d`: Rolling standard deviation
+ * @example
+ *  let data = [
+ *    { date: '2024-01-01', price: 100 },
+ *    { date: '2024-01-02', price: 105 },
+ *    { date: '2024-01-03', price: 110 },
+ *  ];
+ *  let result = calculateRollingStats(data, 'price', 3);
+ *  // result[2] will have price_rolling_mean_3d and price_rolling_std_3d
+ */
+export declare function calculateRollingStats(data: any[], field: string, window?: number): any[];
+//# sourceMappingURL=rolling-stats.d.ts.map

package/dist/correlate/rolling-stats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rolling-stats.d.ts","sourceRoot":"","sources":["../../src/correlate/rolling-stats.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,GAAG,EAAE,EACX,KAAK,EAAE,MAAM,EACb,MAAM,GAAE,MAAU,GACjB,GAAG,EAAE,CAyCP"}

package/dist/correlate/types.d.ts

@@ -0,0 +1,78 @@
+/**
+ * @file types.ts
+ * @description Type definitions for XGBoost model training and prediction.
+ */
+/**
+ * Configuration parameters for XGBoost model training.
+ * @see {@link https://xgboost.readthedocs.io/en/release_3.0.0/parameter.html XGBoost Parameters Documentation}
+ */
+export interface XGBoostParams {
+    /** Controls output verbosity: 0=silent, 1=warnings, 2=info, 3=debug. Default: 1 */
+    verbosity?: number;
+    /** Maximum depth of each tree. Higher values increase complexity and overfitting risk. Default: 6 */
+    max_depth?: number;
+    /** Learning rate (step size shrinkage). Smaller values require more rounds but improve generalization. Default: 0.3 */
+    eta?: number;
+    /** Learning task objective (e.g., 'reg:squarederror' for regression, 'binary:logistic' for classification) */
+    objective?: string;
+    /** Number of parallel threads for training. Default: maximum available */
+    nthread?: number;
+    /** Fraction of training instances sampled per tree (0-1). Values <1 reduce overfitting. Default: 1 */
+    subsample?: number;
+    /** Fraction of features sampled per tree (0-1). Adds diversity like Random Forest. Default: 1 */
+    colsample_bytree?: number;
+    /** Fraction of features sampled per tree level (0-1). Additional regularization layer. Default: 1 */
+    colsample_bylevel?: number;
+    /** Minimum sum of instance weights in a leaf. Higher values prevent overly specific splits. Default: 1 */
+    min_child_weight?: number;
+    /** Minimum loss reduction required for a split. Higher values make splitting more conservative. Default: 0 */
+    gamma?: number;
+    /** L1 regularization (lasso). Encourages sparsity/feature selection. Default: 0 */
+    alpha?: number;
+    /** L2 regularization (ridge). Penalizes large weights to prevent overfitting. Default: 1 */
+    lambda?: number;
+    /** Stop training after N rounds without validation improvement. Prevents overfitting. */
+    early_stopping_rounds?: number;
+    /** Random seed for reproducibility. Default: 0 */
+    seed?: number;
+    /** Number of boosting rounds (trees to build). More rounds needed with lower eta. */
+    nrounds?: number;
+    /** Tree construction algorithm: 'auto', 'exact', 'approx', 'hist', 'gpu_hist'. Default: 'auto' */
+    tree_method?: string;
+    /** Tree growth policy: 'depthwise' (level-by-level) or 'lossguide' (leaf-by-leaf). Default: 'depthwise' */
+    grow_policy?: string;
+    /** Index signature for additional XGBoost parameters not explicitly typed */
+    [key: string]: any;
+}
+/**
+ * Options for training an XGBoost model.
+ */
+export interface TrainModelOptions {
+    /** XGBoost parameters for model configuration */
+    xgbParams?: XGBoostParams;
+    /** Proportion of data to use for testing (default: 0.2) */
+    testSize?: number;
+    /** Specific feature columns to use for training */
+    featuresToUse: string[];
+}
+/**
+ * Options for making predictions with a trained model.
+ */
+export interface PredictOptions {
+    /** Specific feature columns to use for prediction */
+    featuresToUse: string[];
+}
+/**
+ * Result of train/test data split.
+ */
+export interface TrainTestSplit {
+    /** Training feature arrays */
+    trainFeatures: any[][];
+    /** Testing feature arrays */
+    testFeatures: any[][];
+    /** Training target values */
+    trainTarget: any[];
+    /** Testing target values */
+    testTarget: any[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/correlate/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/correlate/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,mFAAmF;IACnF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qGAAqG;IACrG,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,uHAAuH;IACvH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,8GAA8G;IAC9G,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,0EAA0E;IAC1E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sGAAsG;IACtG,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iGAAiG;IACjG,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,qGAAqG;IACrG,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,0GAA0G;IAC1G,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,8GAA8G;IAC9G,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,mFAAmF;IACnF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,4FAA4F;IAC5F,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,yFAAyF;IACzF,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,kDAAkD;IAClD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qFAAqF;IACrF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,kGAAkG;IAClG,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,2GAA2G;IAC3G,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,6EAA6E;IAC7E,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,iDAAiD;IACjD,SAAS,CAAC,EAAE,aAAa,CAAC;IAC1B,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mDAAmD;IACnD,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,qDAAqD;IACrD,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,8BAA8B;IAC9B,aAAa,EAAE,GAAG,EAAE,EAAE,CAAC;IACvB,6BAA6B;IAC7B,YAAY,EAAE,GAAG,EAAE,EAAE,CAAC;IACtB,6BAA6B;IAC7B,WAAW,EAAE,GAAG,EAAE,CAAC;IACnB,4BAA4B;IAC5B,UAAU,EAAE,GAAG,EAAE,CAAC;CACnB"}

package/dist/correlate/xgboost-predictor.d.ts

@@ -0,0 +1,19 @@
+import { PredictOptions } from './types';
+/**
+ * Predicts target variable for future data using the trained XGBoost model
+ * @param futureData - Array of data objects for future dates
+ * @param options - Prediction options including features to use
+ * @returns Promise resolving to array of data objects with predictions
+ * @example
+ *  let futureData = [
+ *    { feature1: 10, feature2: 20 },
+ *    { feature1: 15, feature2: 25 }
+ *  ];
+ *  let options = {
+ *    featuresToUse: ['feature1', 'feature2']
+ *  };
+ *  let predictions = await predictFuture(futureData, options);
+ *  console.log(predictions);
+ */
+export declare function predictFuture(futureData: any[], options: PredictOptions): Promise<any[]>;
+//# sourceMappingURL=xgboost-predictor.d.ts.map

package/dist/correlate/xgboost-predictor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xgboost-predictor.d.ts","sourceRoot":"","sources":["../../src/correlate/xgboost-predictor.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEzC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAC3B,UAAU,EAAE,GAAG,EAAE,EACjB,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,GAAG,EAAE,CAAC,CA2BhB"}

package/dist/correlate/xgboost-trainer.d.ts

@@ -0,0 +1,112 @@
+import { TrainModelOptions, TrainTestSplit } from './types';
+/**
+ * Trains an XGBoost model on preprocessed data and evaluates its performance.
+ *
+ * XGBoost (eXtreme Gradient Boosting) works by sequentially building decision trees
+ * where each new tree corrects errors made by the ensemble of previous trees.
+ * It uses gradient descent to minimize a loss function by adding trees that
+ * predict the residuals or errors of prior trees, then combining them through boosting.
+ * The algorithm employs regularization techniques to prevent overfitting and handles
+ * missing values effectively through its sparsity-aware split finding approach.
+ *
+ * @param fullData - Preprocessed training data as array of objects with numeric values only
+ * @param targetName - Name of the target variable column to predict
+ * @param options - Configuration options for model training
+ *
+ * // General Parameters
+ * @param options.xgbParams.verbosity - [default=1] Controls the verbosity of XGBoost's output
+ *   0: silent mode (no messages)
+ *   1: warnings only
+ *   2: info messages
+ *   3: debug messages
+ *
+ * // Tree Booster Parameters (Control tree structure)
+ * @param options.xgbParams.max_depth - [default=6] Maximum depth of each tree
+ *   Controls model complexity. Higher values create more complex trees that may overfit.
+ *   Reduced from 8 to 6 to limit tree complexity and prevent overfitting.
+ *
+ * @param options.xgbParams.eta - [default=0.3, alias: learning_rate] Step size shrinkage
+ *   Controls how much weight is given to new trees in each boosting round.
+ *   Smaller values (0.1) make the model more robust by shrinking feature weights.
+ *   Set to 0.1 to allow more conservative boosting, requiring more trees but improving generalization.
+ *
+ * @param options.xgbParams.objective - Specifies the learning task and objective
+ *   'reg:squarederror': Regression with squared loss (minimize MSE)
+ *   Options include classification objectives, ranking, and other regression metrics.
+ *
+ * @param options.xgbParams.nthread - Number of parallel threads used for training
+ *   Set to 4 to utilize multi-core processing without overwhelming the system.
+ *
+ * @param options.xgbParams.subsample - [default=1] Fraction of training instances used per tree
+ *   Values < 1 implement random sampling of the training data for each tree.
+ *   Set to 0.9 to reduce overfitting by introducing randomness while using most of the data.
+ *
+ * @param options.xgbParams.colsample_bytree - [default=1] Fraction of features used per tree
+ *   Controls feature sampling for each tree, similar to Random Forest.
+ *   Set to 0.9 to reduce overfitting and create diverse trees.
+ *
+ * @param options.xgbParams.min_child_weight - [default=1] Minimum sum of instance weight in a child
+ *   Controls the minimum number of instances needed in a leaf node.
+ *   Set to 3 to prevent the model from creating overly specific rules based on few samples.
+ *
+ * @param options.xgbParams.gamma - [default=0, alias: min_split_loss] Minimum loss reduction for a split
+ *   Controls the minimum reduction in the loss function required to make a split.
+ *   Set to 0.1 to make splitting more conservative and reduce overfitting.
+ *
+ * // Regularization Parameters
+ * @param options.xgbParams.alpha - [default=0, alias: reg_alpha] L1 regularization on weights
+ *   Encourages sparsity by penalizing non-zero weights (feature selection).
+ *   Set to 0 as gamma is being used for regularization.
+ *
+ * @param options.xgbParams.lambda - [default=1, alias: reg_lambda] L2 regularization on weights
+ *   Penalizes large weights to prevent overfitting (similar to Ridge regression).
+ *   Default value of 1 provides moderate regularization.
+ *
+ * // Learning Control Parameters
+ * @param options.xgbParams.early_stopping_rounds - Stop training if performance doesn't improve
+ *   Stops adding trees when the validation metric doesn't improve for specified rounds.
+ *   Set to 20 to prevent overfitting by stopping when the model stops improving.
+ *
+ * @param options.xgbParams.seed - [default=0] Random number seed for reproducibility
+ *   Set to 42 to ensure consistent results across training runs.
+ *
+ * @param options.xgbParams.nrounds - Number of boosting rounds (trees to build)
+ *   Set to 1000 to compensate for the lower learning rate (eta),
+ *   allowing the model to converge slowly but more accurately.
+ *
+ * @param options.testSize - Proportion of data to use for testing (default: 0.2)
+ * @param options.featuresToUse - Specific feature columns to use for training
+ * @see [XGBoost_parameters](https://xgboost.readthedocs.io/en/release_3.0.0/parameter.html)
+ * @author [vtempest](https://github.com/vtempest)
+ * @license MIT
+ * @returns R² value (coefficient of determination) indicating model accuracy
+ * @example
+ *  let data = [
+ *    {
+ *      "feature1": 1,
+ *      "feature2": 2,
+ *      "target": 3
+ *    }
+ *  ];
+ *  let options = {
+ *    xgbParams: {
+ *      verbosity: 0,
+ *      max_depth: 7,
+ *      eta: 0.07,
+ *      objective: 'reg:squarederror',
+ *      nthread: 4,
+ *    }
+ *  };
+ *  let accuracy = await trainModels(data, 'target', options);
+ *  console.log(accuracy);
+ */
+export declare function trainModels(fullData: any[], targetName: string, options: TrainModelOptions): Promise<number>;
+/**
+ * Splits data into training and testing sets
+ * @param features - Feature array
+ * @param target - Target array
+ * @param testSize - Proportion of data to use for testing
+ * @returns Split datasets
+ */
+export declare function splitTrainTest(features: any[][], target: any[], testSize?: number): TrainTestSplit;
+//# sourceMappingURL=xgboost-trainer.d.ts.map

package/dist/correlate/xgboost-trainer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xgboost-trainer.d.ts","sourceRoot":"","sources":["../../src/correlate/xgboost-trainer.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAG5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoGG;AACH,wBAAsB,WAAW,CAC/B,QAAQ,EAAE,GAAG,EAAE,EACf,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,MAAM,CAAC,CA4EjB;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,GAAG,EAAE,EAAE,EACjB,MAAM,EAAE,GAAG,EAAE,EACb,QAAQ,GAAE,MAAY,GACrB,cAAc,CAsBhB"}

package/dist/db/client.d.ts

@@ -0,0 +1,10 @@
+import { DetectionConfig, PriceWindow } from '../prediction/types';
+export declare function getPool(): {
+    query: (text: string, params: any[]) => Promise<{
+        rows: never[];
+    }>;
+};
+export declare function getConfig(): Promise<DetectionConfig>;
+export declare function getPriceWindowsBatch(tokenIds: string[], minutes: number): Promise<Map<string, PriceWindow>>;
+export declare function getMarketsInCooldown(marketIds: string[], minutes: number): Promise<Set<string>>;
+//# sourceMappingURL=client.d.ts.map

package/dist/db/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/db/client.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAGnE,wBAAgB,OAAO;kBAEC,MAAM,UAAU,GAAG,EAAE;;;EAK5C;AAED,wBAAsB,SAAS,IAAI,OAAO,CAAC,eAAe,CAAC,CAU1D;AAED,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,MAAM,EAAE,EAClB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAEnC;AAED,wBAAsB,oBAAoB,CACxC,SAAS,EAAE,MAAM,EAAE,EACnB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAEtB"}

package/dist/db/d1-http.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Cloudflare D1 over the HTTP (REST) API.
+ *
+ * The app runs on Cloudflare Workers, where D1 is reached through the `DB`
+ * binding. Outside of workerd — maintenance scripts, one-off jobs, CI — there
+ * is no binding, so the *same* D1 database is reached through Cloudflare's
+ * REST API instead. This keeps a single database (Cloudflare D1) for every
+ * runtime: no libsql/Turso, no Postgres, no local sqlite file.
+ *
+ * Required environment variables outside Workers:
+ *   CLOUDFLARE_ACCOUNT_ID   Cloudflare account id
+ *   CLOUDFLARE_DATABASE_ID  D1 database id (defaults to the app's database)
+ *   CLOUDFLARE_D1_TOKEN     API token with D1 edit permission
+ */
+/** Default D1 database id for this monorepo (`ai-broker-db`). */
+export declare const DEFAULT_D1_DATABASE_ID = "37dbe79c-2687-4127-ad02-2372e15ac077";
+export interface D1HttpCredentials {
+    accountId: string;
+    databaseId: string;
+    token: string;
+}
+/**
+ * Read D1 REST credentials from the environment.
+ * Returns null when the account id or API token is missing.
+ */
+export declare function getD1HttpCredentials(): D1HttpCredentials | null;
+/**
+ * Callback for `drizzle-orm/sqlite-proxy`.
+ *
+ * drizzle's proxy driver expects rows as positional value arrays, while the D1
+ * REST API returns row objects. Object key order matches the statement's
+ * column order, so `Object.values` restores the positional shape drizzle maps
+ * back onto the schema.
+ */
+export declare function createD1HttpDriver(credentials: D1HttpCredentials): (sql: string, params: unknown[], method: "run" | "all" | "values" | "get") => Promise<{
+    rows: unknown[] | unknown[][];
+}>;
+//# sourceMappingURL=d1-http.d.ts.map

package/dist/db/d1-http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"d1-http.d.ts","sourceRoot":"","sources":["../../src/db/d1-http.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,iEAAiE;AACjE,eAAO,MAAM,sBAAsB,yCAAyC,CAAC;AAE7E,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,iBAAiB,GAAG,IAAI,CAe/D;AA6CD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,iBAAiB,IAE7D,KAAK,MAAM,EACX,QAAQ,OAAO,EAAE,EACjB,QAAQ,KAAK,GAAG,KAAK,GAAG,QAAQ,GAAG,KAAK,KACvC,OAAO,CAAC;IAAE,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,EAAE,CAAA;CAAE,CAAC,CAQ9C"}