whstats 1.0.0

package/README.md

@@ -0,0 +1,72 @@
+# WH Stats
+
+Compare booked hours (Redmine) vs clocked hours (timelogger) for the last 7 days.
+
+## Installation
+
+```bash
+# Using bun (recommended)
+bun x whstats
+
+# Using npx
+npx whstats
+
+# Or install globally
+bun install -g whstats
+```
+
+## Usage
+
+```bash
+# First-time setup (interactive)
+whstats --setup
+
+# Show time statistics
+whstats
+
+# Show config file location and current settings
+whstats --config
+
+# Reset configuration
+whstats --reset
+
+# Show help
+whstats --help
+```
+
+## Configuration
+
+On first run, use `whstats --setup` to configure your credentials interactively.
+
+Configuration is stored in `~/.config/whstats/config.json`.
+
+## Example Output
+
+```
+Fetching time entries for John Doe...
+
+2026-02-03 Monday: 8h booked / 8.25h clocked
+  - #1234 4h Implemented feature X
+  - #1235 4h Code review and testing
+
+2026-02-04 Tuesday: 7h booked / 7.5h clocked
+  - #1236 3h Bug fixes
+  - #1237 4h Documentation updates
+```
+
+## Development
+
+```bash
+# Install dependencies
+bun install
+
+# Run locally
+bun run index.ts
+
+# Run with flags
+bun run index.ts --help
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+import { getConfigOrExit, promptForConfig, loadConfig, deleteConfig, getConfigPath, configExists, } from "./lib/config.js";
+import { fetchCurrentUser, fetchTimeEntries } from "./lib/redmine.js";
+import { fetchClockedHours } from "./lib/mssql.js";
+import { getDateRange, formatHours, truncateComment, getDayName } from "./lib/utils.js";
+const VERSION = "1.0.0";
+function showHelp() {
+    console.log(`
+  WH Stats v${VERSION}
+  
+  Compare booked hours (Redmine) vs clocked hours (timelogger) for the last 7 days.
+
+  Usage:
+    whstats              Show time statistics
+    whstats --setup      Configure credentials (interactive)
+    whstats --config     Show config file location
+    whstats --reset      Delete saved configuration
+    whstats --help       Show this help message
+    whstats --version    Show version
+
+  Configuration:
+    Run 'whstats --setup' to configure your credentials interactively.
+    Credentials are stored in: ~/.config/whstats/config.json
+`);
+}
+function showVersion() {
+    console.log(`whstats v${VERSION}`);
+}
+function showConfig() {
+    const configPath = getConfigPath();
+    const exists = configExists();
+    console.log(`\n  Config file: ${configPath}`);
+    console.log(`  Status: ${exists ? "configured" : "not configured"}\n`);
+    if (exists) {
+        const config = loadConfig();
+        if (config) {
+            console.log("  Current settings:");
+            console.log(`    Redmine URL:    ${config.redmineUrl}`);
+            console.log(`    Redmine API:    ${config.redmineApiKey.slice(0, 8)}...`);
+            console.log(`    MSSQL Server:   ${config.mssqlServer}`);
+            console.log(`    MSSQL Database: ${config.mssqlDatabase}`);
+            console.log(`    MSSQL User:     ${config.mssqlUser}`);
+            console.log(`    User ID:        ${config.slackUserId}\n`);
+        }
+    }
+}
+async function handleSetup() {
+    const existing = loadConfig();
+    await promptForConfig(existing);
+}
+function handleReset() {
+    if (deleteConfig()) {
+        console.log("\n  Configuration deleted.\n");
+    }
+    else {
+        console.log("\n  No configuration file found.\n");
+    }
+}
+function groupByDate(entries) {
+    const grouped = new Map();
+    for (const entry of entries) {
+        const date = entry.spent_on;
+        if (!grouped.has(date)) {
+            grouped.set(date, []);
+        }
+        grouped.get(date).push(entry);
+    }
+    return grouped;
+}
+function displayResults(entries, clockedHours) {
+    const grouped = groupByDate(entries);
+    // Combine all dates from both sources
+    const allDates = new Set([...grouped.keys(), ...clockedHours.keys()]);
+    const sortedDates = Array.from(allDates).sort();
+    if (sortedDates.length === 0) {
+        console.log("No time entries found for the last 7 days.");
+        return;
+    }
+    console.log("");
+    for (const date of sortedDates) {
+        const dayEntries = grouped.get(date) || [];
+        const bookedHours = dayEntries.reduce((sum, e) => sum + e.hours, 0);
+        const clocked = clockedHours.get(date) || 0;
+        const dayName = getDayName(date);
+        const clockedStr = clocked > 0 ? formatHours(clocked) : "-";
+        console.log(`${date} ${dayName}: ${formatHours(bookedHours)} booked / ${clockedStr} clocked`);
+        for (const entry of dayEntries) {
+            const issueRef = entry.issue ? `#${entry.issue.id}` : "#N/A";
+            const hours = formatHours(entry.hours);
+            const comment = truncateComment(entry.comments || "(no comment)");
+            console.log(`  - ${issueRef} ${hours} ${comment}`);
+        }
+    }
+    console.log("");
+}
+async function runStats() {
+    const config = getConfigOrExit();
+    try {
+        const user = await fetchCurrentUser(config);
+        console.log(`\nFetching time entries for ${user.firstname} ${user.lastname}...`);
+        const { from, to } = getDateRange(7);
+        const [entries, clockedHours] = await Promise.all([
+            fetchTimeEntries(config, user.id, from, to),
+            fetchClockedHours(config, from, to),
+        ]);
+        displayResults(entries, clockedHours);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error(`\n  Error: ${error.message}\n`);
+        }
+        else {
+            console.error("\n  An unexpected error occurred.\n");
+        }
+        process.exit(1);
+    }
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    switch (command) {
+        case "--help":
+        case "-h":
+            showHelp();
+            break;
+        case "--version":
+        case "-v":
+            showVersion();
+            break;
+        case "--setup":
+        case "-s":
+            await handleSetup();
+            break;
+        case "--config":
+        case "-c":
+            showConfig();
+            break;
+        case "--reset":
+        case "-r":
+            handleReset();
+            break;
+        case undefined:
+            await runStats();
+            break;
+        default:
+            console.error(`\n  Unknown command: ${command}`);
+            console.error("  Run 'whstats --help' for usage.\n");
+            process.exit(1);
+    }
+}
+main();

package/dist/lib/config.d.ts

@@ -0,0 +1,16 @@
+export interface Config {
+    redmineApiKey: string;
+    redmineUrl: string;
+    mssqlServer: string;
+    mssqlDatabase: string;
+    mssqlUser: string;
+    mssqlPassword: string;
+    slackUserId: string;
+}
+export declare function getConfigPath(): string;
+export declare function configExists(): boolean;
+export declare function loadConfig(): Config | null;
+export declare function saveConfig(config: Config): void;
+export declare function deleteConfig(): boolean;
+export declare function promptForConfig(existingConfig?: Config | null): Promise<Config>;
+export declare function getConfigOrExit(): Config;

package/dist/lib/config.js

@@ -0,0 +1,148 @@
+import { homedir } from "os";
+import { join } from "path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from "fs";
+import * as readline from "readline";
+const CONFIG_DIR = join(homedir(), ".config", "whstats");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+export function getConfigPath() {
+    return CONFIG_FILE;
+}
+export function configExists() {
+    return existsSync(CONFIG_FILE);
+}
+export function loadConfig() {
+    if (!existsSync(CONFIG_FILE))
+        return null;
+    try {
+        const content = readFileSync(CONFIG_FILE, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+export function saveConfig(config) {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    }
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+export function deleteConfig() {
+    if (existsSync(CONFIG_FILE)) {
+        unlinkSync(CONFIG_FILE);
+        return true;
+    }
+    return false;
+}
+function prompt(rl, question, defaultValue) {
+    const displayQuestion = defaultValue
+        ? `${question} [${defaultValue}]: `
+        : `${question}: `;
+    return new Promise((resolve) => {
+        rl.question(displayQuestion, (answer) => {
+            resolve(answer.trim() || defaultValue || "");
+        });
+    });
+}
+function promptPassword(rl, question) {
+    return new Promise((resolve) => {
+        const stdin = process.stdin;
+        const stdout = process.stdout;
+        stdout.write(`${question}: `);
+        // Disable echo for password input
+        if (stdin.isTTY) {
+            stdin.setRawMode(true);
+        }
+        let password = "";
+        const onData = (char) => {
+            const c = char.toString();
+            switch (c) {
+                case "\n":
+                case "\r":
+                case "\u0004": // Ctrl+D
+                    if (stdin.isTTY) {
+                        stdin.setRawMode(false);
+                    }
+                    stdin.removeListener("data", onData);
+                    stdout.write("\n");
+                    resolve(password);
+                    break;
+                case "\u0003": // Ctrl+C
+                    if (stdin.isTTY) {
+                        stdin.setRawMode(false);
+                    }
+                    process.exit(1);
+                    break;
+                case "\u007F": // Backspace
+                    if (password.length > 0) {
+                        password = password.slice(0, -1);
+                        stdout.write("\b \b");
+                    }
+                    break;
+                default:
+                    password += c;
+                    stdout.write("*");
+            }
+        };
+        stdin.resume();
+        stdin.on("data", onData);
+    });
+}
+export async function promptForConfig(existingConfig) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    console.log("\n  WH Stats Configuration\n");
+    console.log("  Enter your credentials (press Enter to keep existing values)\n");
+    try {
+        const config = {
+            redmineUrl: await prompt(rl, "  Redmine URL", existingConfig?.redmineUrl),
+            redmineApiKey: await prompt(rl, "  Redmine API Key", existingConfig?.redmineApiKey),
+            mssqlServer: await prompt(rl, "  MSSQL Server", existingConfig?.mssqlServer),
+            mssqlDatabase: await prompt(rl, "  MSSQL Database", existingConfig?.mssqlDatabase),
+            mssqlUser: await prompt(rl, "  MSSQL User", existingConfig?.mssqlUser),
+            mssqlPassword: await prompt(rl, "  MSSQL Password", existingConfig?.mssqlPassword),
+            slackUserId: await prompt(rl, "  User ID (in timelogger)", existingConfig?.slackUserId),
+        };
+        rl.close();
+        // Validate required fields
+        const missingFields = [];
+        if (!config.redmineUrl)
+            missingFields.push("Redmine URL");
+        if (!config.redmineApiKey)
+            missingFields.push("Redmine API Key");
+        if (!config.mssqlServer)
+            missingFields.push("MSSQL Server");
+        if (!config.mssqlDatabase)
+            missingFields.push("MSSQL Database");
+        if (!config.mssqlUser)
+            missingFields.push("MSSQL User");
+        if (!config.mssqlPassword)
+            missingFields.push("MSSQL Password");
+        if (!config.slackUserId)
+            missingFields.push("User ID");
+        if (missingFields.length > 0) {
+            console.error(`\n  Error: Missing required fields: ${missingFields.join(", ")}`);
+            process.exit(1);
+        }
+        // Normalize URL
+        config.redmineUrl = config.redmineUrl.replace(/\/$/, "");
+        saveConfig(config);
+        console.log(`\n  Config saved to ${CONFIG_FILE}\n`);
+        return config;
+    }
+    catch (error) {
+        rl.close();
+        throw error;
+    }
+}
+export function getConfigOrExit() {
+    const config = loadConfig();
+    if (config) {
+        return config;
+    }
+    console.error("\n  No configuration found.\n");
+    console.error("  Run 'whstats --setup' to configure your credentials.\n");
+    process.exit(1);
+}

package/dist/lib/mssql.d.ts

@@ -0,0 +1,2 @@
+import type { Config } from "./config.js";
+export declare function fetchClockedHours(config: Config, from: string, to: string): Promise<Map<string, number>>;

package/dist/lib/mssql.js

@@ -0,0 +1,63 @@
+import sql from "mssql";
+import { formatDate } from "./utils.js";
+export async function fetchClockedHours(config, from, to) {
+    const sqlConfig = {
+        server: config.mssqlServer,
+        database: config.mssqlDatabase,
+        user: config.mssqlUser,
+        password: config.mssqlPassword,
+        options: {
+            encrypt: false,
+            trustServerCertificate: true,
+        },
+    };
+    const pool = await sql.connect(sqlConfig);
+    try {
+        // Query to calculate clocked-in time per day
+        // For each day, we pair clock-in (1) with clock-out (0) events and sum the differences
+        const result = await pool.request()
+            .input("userId", sql.Int, parseInt(config.slackUserId))
+            .input("fromDate", sql.Date, from)
+            .input("toDate", sql.Date, to)
+            .query(`
+        WITH OrderedEvents AS (
+          SELECT 
+            CAST([date] AS DATE) AS day,
+            [date] AS event_time,
+            [clock],
+            ROW_NUMBER() OVER (PARTITION BY CAST([date] AS DATE) ORDER BY [date]) AS rn
+          FROM event_logs
+          WHERE user_id = @userId
+            AND CAST([date] AS DATE) >= @fromDate
+            AND CAST([date] AS DATE) <= @toDate
+        ),
+        ClockPairs AS (
+          SELECT 
+            e1.day,
+            e1.event_time AS clock_in,
+            e2.event_time AS clock_out
+          FROM OrderedEvents e1
+          LEFT JOIN OrderedEvents e2 
+            ON e1.day = e2.day 
+            AND e1.rn + 1 = e2.rn 
+            AND e2.clock = 0
+          WHERE e1.clock = 1
+        )
+        SELECT 
+          day,
+          SUM(DATEDIFF(MINUTE, clock_in, ISNULL(clock_out, GETDATE()))) / 60.0 AS hours
+        FROM ClockPairs
+        GROUP BY day
+        ORDER BY day
+      `);
+        const clockedHours = new Map();
+        for (const row of result.recordset) {
+            const dateStr = formatDate(new Date(row.day));
+            clockedHours.set(dateStr, parseFloat(row.hours));
+        }
+        return clockedHours;
+    }
+    finally {
+        await pool.close();
+    }
+}

package/dist/lib/redmine.d.ts

@@ -0,0 +1,38 @@
+import type { Config } from "./config.js";
+export interface TimeEntry {
+    id: number;
+    project: {
+        id: number;
+        name: string;
+    };
+    issue?: {
+        id: number;
+    };
+    user: {
+        id: number;
+        name: string;
+    };
+    activity: {
+        id: number;
+        name: string;
+    };
+    hours: number;
+    comments: string;
+    spent_on: string;
+    created_on: string;
+    updated_on: string;
+}
+export interface TimeEntriesResponse {
+    time_entries: TimeEntry[];
+    total_count: number;
+    offset: number;
+    limit: number;
+}
+export interface User {
+    id: number;
+    login: string;
+    firstname: string;
+    lastname: string;
+}
+export declare function fetchCurrentUser(config: Config): Promise<User>;
+export declare function fetchTimeEntries(config: Config, userId: number, from: string, to: string): Promise<TimeEntry[]>;

package/dist/lib/redmine.js

@@ -0,0 +1,28 @@
+export async function fetchCurrentUser(config) {
+    const url = `${config.redmineUrl}/my/account.json`;
+    const response = await fetch(url, {
+        headers: {
+            "X-Redmine-API-Key": config.redmineApiKey,
+            "Content-Type": "application/json",
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Redmine API error: ${response.status} ${response.statusText}`);
+    }
+    const data = (await response.json());
+    return data.user;
+}
+export async function fetchTimeEntries(config, userId, from, to) {
+    const url = `${config.redmineUrl}/time_entries.json?user_id=${userId}&from=${from}&to=${to}&limit=100`;
+    const response = await fetch(url, {
+        headers: {
+            "X-Redmine-API-Key": config.redmineApiKey,
+            "Content-Type": "application/json",
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Redmine API error: ${response.status} ${response.statusText}`);
+    }
+    const data = (await response.json());
+    return data.time_entries;
+}

package/dist/lib/utils.d.ts

@@ -0,0 +1,8 @@
+export declare function formatDate(date: Date): string;
+export declare function getDateRange(days?: number): {
+    from: string;
+    to: string;
+};
+export declare function formatHours(hours: number): string;
+export declare function truncateComment(comment: string, maxLength?: number): string;
+export declare function getDayName(dateStr: string): string;

package/dist/lib/utils.js

@@ -0,0 +1,21 @@
+export function formatDate(date) {
+    return date.toISOString().split("T")[0];
+}
+export function getDateRange(days = 7) {
+    const today = new Date();
+    const fromDate = new Date(today);
+    fromDate.setDate(today.getDate() - days);
+    return { from: formatDate(fromDate), to: formatDate(today) };
+}
+export function formatHours(hours) {
+    return hours % 1 === 0 ? `${hours}h` : `${hours.toFixed(2)}h`;
+}
+export function truncateComment(comment, maxLength = 30) {
+    if (comment.length <= maxLength)
+        return comment;
+    return comment.substring(0, maxLength - 3) + "...";
+}
+export function getDayName(dateStr) {
+    const days = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+    return days[new Date(dateStr).getDay()];
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "whstats",
+  "version": "1.0.0",
+  "description": "WH Stats - Compare booked hours (Redmine) vs clocked hours (timelogger)",
+  "author": "Armin Emmert <emmertarmin@gmail.com>",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "whstats": "./dist/index.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "redmine",
+    "time-tracking",
+    "statistics",
+    "cli"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/emmertarmin/whstats.git"
+  },
+  "bugs": {
+    "url": "https://github.com/emmertarmin/whstats/issues"
+  },
+  "homepage": "https://github.com/emmertarmin/whstats#readme",
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/mssql": "^9.1.5",
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "mssql": "^12.2.0"
+  }
+}