Time Series Trend Detector (javascript, written by Gemini Code Assist)

Gemini Code Assist wrote this javascript project from the task below. It installed and ran on a clean Ubuntu 22.04 machine as written.

Task given to the agent:

TASK: Time Series Trend Detector

Write a program that analyzes time series data to detect trends, seasonal patterns, and anomalies using statistical methods, and produces a visual summary report.

FUNCTIONAL REQUIREMENTS:
- Accept a CSV file path as a command-line argument with columns for timestamp and one or more numeric value columns
- Parse timestamps in multiple formats (ISO 8601, Unix epoch, and common date formats like MM/DD/YYYY, YYYY-MM-DD HH:MM:SS)
- Compute a moving average with a configurable window size via --window flag (default: 7 data points)
- Detect overall trend direction (increasing, decreasing, stable) using linear regression and report the slope and R-squared value
- Detect seasonality by computing autocorrelation at various lags and reporting the dominant period if one exists
- Identify anomalies: data points that deviate more than a configurable number of standard deviations from the moving average (--threshold flag, default: 2.0)
- Support multiple value columns: analyze each independently and report results for all
- Generate a summary report with: trend direction and strength, seasonal period (if any), count and list of anomalies with their timestamps and values, basic statistics (min, max, mean, variance)
- Save the report as a JSON file with --output flag (default: trend_report.json)
- Export the processed data (original values, moving average, anomaly flags) as a CSV file via --export flag
- If no input file is given, generate a sample time series dataset with 365 daily data points containing a linear trend, weekly seasonality, and injected anomalies, then analyze it
- Handle missing timestamps and gaps in the series by interpolating or flagging them

Create a complete JavaScript project for a clean Ubuntu 22.04 machine with only Node.js 20+ (LTS) installed. Include:
- Source code
- package.json with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[]

{
  "name": "time-series-trend-detector",
  "version": "1.0.0",
  "description": "Detect trends and anomalies in time series",
  "main": "trend_detector.js",
  "engines": {
    "node": ">=20.0.0"
  },
  "dependencies": {
    "simple-statistics": "7.8.3",
    "fast-csv": "5.0.0",
    "date-fns": "3.3.1",
    "yargs": "17.7.2"
  },
  "scripts": {
    "start": "node trend_detector.js"
  }
}

# Time Series Trend Detector (JavaScript)

A tool for detecting trends and anomalies in time series data.

## Setup Instructions

1. Ensure Node.js 20+ (LTS) is installed.
2. Install dependencies:
   ```bash
   npm install
   ```

## Run Commands

- Analyze a specific CSV:
  ```bash
  node trend_detector.js data.csv
  ```
- Run with generated sample data:
  ```bash
  node trend_detector.js
  ```

const fs = require('fs');
const csv = require('fast-csv');
const ss = require('simple-statistics');
const { parseISO, addDays, format } = require('date-fns');
const yargs = require('yargs/yargs');
const { hideBin } = require('yargs/helpers');

const argv = yargs(hideBin(process.argv))
    .option('window', { default: 7 })
    .option('threshold', { default: 2.0 })
    .argv;

const inputPath = argv._[0] || 'sample_ts.csv';

function generateSample(path) {
    console.log(`Generating sample TS: ${path}`);
    const ws = fs.createWriteStream(path);
    const stream = csv.format({ headers: true });
    stream.pipe(ws);
    let date = new Date(2025, 0, 1);
    for (let i = 0; i < 365; i++) {
        let val = 0.1 * i + 5 * Math.sin(2 * Math.PI * i / 7) + (Math.random() - 0.5) * 2;
        if (i === 150) val += 20;
        stream.write({ timestamp: format(date, 'yyyy-MM-dd'), value: val.toFixed(4) });
        date = addDays(date, 1);
    }
    stream.end();
}

async function analyze(path) {
    const rows = [];
    fs.createReadStream(path)
        .pipe(csv.parse({ headers: true }))
        .on('data', r => rows.push({ ts: r.timestamp, val: parseFloat(r.value) }))
        .on('end', () => {
            const vals = rows.map(r => r.val);
            const x = rows.map((_, i) => i);
            const regression = ss.linearRegression(x.map((v, i) => [v, vals[i]]));
            const line = ss.linearRegressionLine(regression);
            
            const mean = ss.mean(vals);
            const std = ss.standardDeviation(vals);
            
            const anomalies = rows.filter((r, i) => Math.abs(r.val - line(i)) > argv.threshold * std);

            const report = {
                trend: regression.m > 0.01 ? 'increasing' : regression.m < -0.01 ? 'decreasing' : 'stable',
                slope: regression.m,
                anomaly_count: anomalies.length,
                anomalies
            };

            console.log(`Trend: ${report.trend} (Slope: ${report.slope.toFixed(4)})`);
            console.log(`Anomalies: ${report.anomaly_count}`);

            fs.writeFileSync('trend_report.json', JSON.stringify(report, null, 4));
            console.log('Report saved to trend_report.json');
        });
}

if (!fs.existsSync(inputPath)) {
    generateSample('sample_ts.csv');
}
analyze(inputPath);