@moneysiren/cli 0.1.0-alpha.0

package/dist/apps/cli/src/commands/init.d.ts

@@ -0,0 +1,3 @@
+import type { CliExecutionContext } from "../cli.js";
+export declare function runInitCommand(args: readonly string[], context: CliExecutionContext): Promise<number>;
+//# sourceMappingURL=init.d.ts.map

package/dist/apps/cli/src/commands/init.js

@@ -0,0 +1,18 @@
+import { initializeLocalStore } from "../../../../packages/db/src/index.js";
+import { loadCliConfig, resolveDbPath } from "./shared.js";
+export async function runInitCommand(args, context) {
+    if (args.length > 0) {
+        context.stderr("Usage: moneysiren init");
+        return 1;
+    }
+    const config = loadCliConfig(context.env);
+    const dbPath = resolveDbPath(context.cwd, config.dbPath);
+    const result = await initializeLocalStore({ dbPath });
+    const migrationSummary = result.appliedMigrationIds.length > 0
+        ? `applied migrations: ${result.appliedMigrationIds.join(", ")}`
+        : `migrations already applied: ${result.skippedMigrationIds.join(", ")}`;
+    context.stdout(`Initialized MoneySiren local storage at ${config.dbPath}`);
+    context.stdout(migrationSummary);
+    return 0;
+}
+//# sourceMappingURL=init.js.map

package/dist/apps/cli/src/commands/install.d.ts

@@ -0,0 +1,3 @@
+import type { CliExecutionContext } from "../cli.js";
+export declare function runInstallCommand(args: readonly string[], context: CliExecutionContext): Promise<number>;
+//# sourceMappingURL=install.d.ts.map

package/dist/apps/cli/src/commands/install.js

@@ -0,0 +1,116 @@
+import { DEFAULT_INSTALL_SURFACES, INSTALL_SURFACES, isInstallSurface, readInstallProfileFile, resolveInstallProfilePath, writeInstallProfileFile, } from "../install-profile.js";
+import { formatInstallSelectionLine, installSelectionHelp, parseInstallSurfaceSelection, promptForInstallSurfaces, } from "../install-selector.js";
+const INSTALL_USAGE = [
+    "Usage: moneysiren install [--status|--all|--cli|--web|--hud|--no-cli|--no-web|--no-hud]",
+    "",
+    "Components:",
+    installSelectionHelp(),
+    "",
+    "Default: all components selected (recommended).",
+].join("\n");
+export async function runInstallCommand(args, context) {
+    if (args.includes("--help") || args.includes("-h")) {
+        context.stdout(INSTALL_USAGE);
+        return 0;
+    }
+    if (args.length === 1 && args[0] === "--status") {
+        return writeInstallStatus(context);
+    }
+    const parsed = parseInstallArgs(args);
+    if (parsed === null) {
+        context.stderr(INSTALL_USAGE);
+        return 1;
+    }
+    const selectedSurfaces = parsed ?? await selectedSurfacesFromPromptOrDefault(context);
+    const profile = await writeInstallProfileFile({
+        selectedSurfaces,
+        source: "cli",
+        recommendedDefault: isDefaultSelection(selectedSurfaces),
+    }, {
+        env: context.env,
+        now: context.now,
+    });
+    context.stdout("MoneySiren install profile updated.");
+    context.stdout(formatInstallSelectionLine(profile.selectedSurfaces));
+    context.stdout("Secrets returned: false");
+    return 0;
+}
+async function writeInstallStatus(context) {
+    const profile = await readInstallProfileFile({
+        env: context.env,
+    });
+    const selectedSurfaces = profile?.selectedSurfaces ?? DEFAULT_INSTALL_SURFACES;
+    context.stdout("MoneySiren install profile");
+    context.stdout(`Status: ${profile === null ? "not configured; using recommended default" : "configured"}`);
+    context.stdout(formatInstallSelectionLine(selectedSurfaces));
+    context.stdout(`Recommended default: ${isDefaultSelection(selectedSurfaces) ? "yes" : "no"}`);
+    context.stdout(`Profile path: ${resolveInstallProfilePath({ env: context.env })}`);
+    context.stdout("Secrets returned: false");
+    return 0;
+}
+async function selectedSurfacesFromPromptOrDefault(context) {
+    if (!context.interactive || context.stdin === undefined || context.output === undefined) {
+        return DEFAULT_INSTALL_SURFACES;
+    }
+    return promptForInstallSurfaces({
+        stdin: context.stdin,
+        output: context.output,
+    });
+}
+function parseInstallArgs(args) {
+    if (args.length === 0) {
+        return undefined;
+    }
+    if (args.length === 1) {
+        const selected = parseInstallSurfaceSelection(args[0] ?? "");
+        if (selected !== null) {
+            return selected;
+        }
+    }
+    let explicitIncludes = false;
+    const selected = new Set();
+    for (const arg of args) {
+        if (arg === "--all") {
+            for (const surface of DEFAULT_INSTALL_SURFACES) {
+                selected.add(surface);
+            }
+            explicitIncludes = true;
+            continue;
+        }
+        if (arg.startsWith("--no-")) {
+            const surface = arg.slice("--no-".length);
+            if (!isInstallSurface(surface)) {
+                return null;
+            }
+            if (!explicitIncludes) {
+                for (const defaultSurface of DEFAULT_INSTALL_SURFACES) {
+                    selected.add(defaultSurface);
+                }
+                explicitIncludes = true;
+            }
+            selected.delete(surface);
+            continue;
+        }
+        if (arg.startsWith("--")) {
+            const surface = arg.slice("--".length);
+            if (!isInstallSurface(surface)) {
+                return null;
+            }
+            selected.add(surface);
+            explicitIncludes = true;
+            continue;
+        }
+        if (!isInstallSurface(arg)) {
+            return null;
+        }
+        selected.add(arg);
+        explicitIncludes = true;
+    }
+    const normalized = INSTALL_SURFACES.filter((surface) => selected.has(surface));
+    return normalized.length === 0 ? null : normalized;
+}
+function isDefaultSelection(selectedSurfaces) {
+    return selectedSurfaces.length === INSTALL_SURFACES.length &&
+        INSTALL_SURFACES.every((surface, index) => selectedSurfaces[index] === surface);
+}
+//# sourceMappingURL=install.js.map

package/dist/apps/cli/src/commands/modes.d.ts

@@ -0,0 +1,3 @@
+import type { CliExecutionContext } from "../cli.js";
+export declare function runModesCommand(args: readonly string[], context: CliExecutionContext): Promise<number>;
+//# sourceMappingURL=modes.d.ts.map

package/dist/apps/cli/src/commands/modes.js

@@ -0,0 +1,65 @@
+import { DEFAULT_INSTALL_SURFACES, formatInstallSurfaces, readInstallProfileFile, } from "../install-profile.js";
+const MODES_USAGE = "Usage: moneysiren modes";
+export async function runModesCommand(args, context) {
+    if (args.includes("--help") || args.includes("-h")) {
+        context.stdout(MODES_USAGE);
+        return 0;
+    }
+    if (args.length > 0) {
+        context.stderr(MODES_USAGE);
+        return 1;
+    }
+    const profile = await readInstallProfileFile({
+        env: context.env,
+    });
+    const selectedSurfaces = profile?.selectedSurfaces ?? DEFAULT_INSTALL_SURFACES;
+    context.stdout("MoneySiren modes");
+    context.stdout(`Platform: ${platformLabel()}`);
+    context.stdout(`Install profile: ${formatInstallSurfaces(selectedSurfaces)}${profile === null ? " (recommended default)" : ""}`);
+    context.stdout("npm install: npm install -g @moneysiren/cli@alpha");
+    context.stdout(`Runtime lock: ${runtimeLockHint()}`);
+    context.stdout("");
+    context.stdout("1. CLI automation");
+    context.stdout(`   Status: ${surfaceStatus("cli", selectedSurfaces)} from the npm CLI package`);
+    context.stdout("   Try: moneysiren doctor");
+    context.stdout("   Try: moneysiren sync --provider mock");
+    context.stdout("");
+    context.stdout("2. Local web dashboard/runtime");
+    context.stdout(`   Status: ${surfaceStatus("web", selectedSurfaces)} local API runtime is available from the npm CLI package`);
+    context.stdout("   Try: moneysiren serve [--port <port>]");
+    context.stdout("   Try: moneysiren dashboard check");
+    context.stdout("   Note: the full Next.js dashboard is run from the repo or a future bundled desktop app.");
+    context.stdout("");
+    context.stdout("3. Desktop tray/notifier");
+    context.stdout(`   Status: ${surfaceStatus("hud", selectedSurfaces)} Windows/macOS target is the thin Tauri tray shell; the native tray binary is not bundled in moneysiren`);
+    context.stdout("   Try: moneysiren desktop status");
+    context.stdout("   Try: moneysiren notify once --dry-run");
+    context.stdout("");
+    context.stdout("Change selection: moneysiren install");
+    return 0;
+}
+function surfaceStatus(surface, selectedSurfaces) {
+    return selectedSurfaces.includes(surface) ? "selected;" : "not selected;";
+}
+function platformLabel() {
+    if (process.platform === "darwin") {
+        return `macOS (${process.platform} ${process.arch})`;
+    }
+    if (process.platform === "win32") {
+        return `Windows (${process.platform} ${process.arch})`;
+    }
+    if (process.platform === "linux") {
+        return `Linux (${process.platform} ${process.arch})`;
+    }
+    return `${process.platform} ${process.arch}`;
+}
+function runtimeLockHint() {
+    if (process.platform === "darwin") {
+        return "~/Library/Application Support/MoneySiren/runtime.json";
+    }
+    if (process.platform === "win32") {
+        return "%APPDATA%\\MoneySiren\\runtime.json";
+    }
+    return "${XDG_CONFIG_HOME:-~/.config}/moneysiren/runtime.json";
+}
+//# sourceMappingURL=modes.js.map

package/dist/apps/cli/src/commands/notify.d.ts

@@ -0,0 +1,3 @@
+import type { CliExecutionContext } from "../cli.js";
+export declare function runNotifyCommand(args: readonly string[], context: CliExecutionContext): Promise<number>;
+//# sourceMappingURL=notify.d.ts.map

package/dist/apps/cli/src/commands/notify.js

@@ -0,0 +1,430 @@
+import { stat } from "node:fs/promises";
+import { sendSlackReport } from "../../../../packages/report/src/index.js";
+import { NOTIFICATION_WIDGET_KEYS, readNotificationPreferencesFile, resolveNotificationPreferencesPath, writeNotificationPreferencesFile, } from "../../../../packages/view-model/src/index.js";
+import { readSanitizedNotificationDigest } from "../summary-model.js";
+import { loadCliConfig } from "./shared.js";
+const NOTIFY_USAGE = [
+    "Usage:",
+    "  moneysiren notify once --dry-run",
+    "  moneysiren notify prefs list",
+    "  moneysiren notify prefs enable <widget>",
+    "  moneysiren notify prefs disable <widget>",
+    "  moneysiren notify prefs hud-enable <widget>",
+    "  moneysiren notify prefs hud-disable <widget>",
+    "  moneysiren notify prefs threshold <widget> --gte|--lte|--eq <value> --cooldown <minutes>",
+    "  moneysiren notify prefs quiet-hours <start> <end>",
+    "  moneysiren notify test",
+].join("\n");
+const NOTIFY_PREFS_USAGE = [
+    "Usage:",
+    "  moneysiren notify prefs list",
+    "  moneysiren notify prefs enable <widget>",
+    "  moneysiren notify prefs disable <widget>",
+    "  moneysiren notify prefs hud-enable <widget>",
+    "  moneysiren notify prefs hud-disable <widget>",
+    "  moneysiren notify prefs threshold <widget> --gte|--lte|--eq <value> --cooldown <minutes>",
+    "  moneysiren notify prefs quiet-hours <start> <end>",
+].join("\n");
+export async function runNotifyCommand(args, context) {
+    const [subcommand, ...rest] = args;
+    if (subcommand === "--help" || subcommand === "-h" || subcommand === "help") {
+        context.stdout(NOTIFY_USAGE);
+        return 0;
+    }
+    if (subcommand === "once") {
+        return runNotifyOnce(rest, context);
+    }
+    if (subcommand === "prefs") {
+        return runNotifyPrefs(rest, context);
+    }
+    if (subcommand === "test") {
+        return runNotifyTest(rest, context);
+    }
+    context.stderr(NOTIFY_USAGE);
+    return 1;
+}
+async function runNotifyOnce(args, context) {
+    if (args.length !== 1 || args[0] !== "--dry-run") {
+        context.stderr("Usage: moneysiren notify once --dry-run");
+        return 1;
+    }
+    const digest = await readSanitizedNotificationDigest(context);
+    context.stdout("MoneySiren notification dry run");
+    context.stdout(`Generated at: ${digest.generatedAt}`);
+    context.stdout(`Secrets returned: ${digest.secretsReturned}`);
+    context.stdout(`Providers: ${digest.providerCount}`);
+    context.stdout(`Health: ${digest.health}`);
+    context.stdout(`Alerts: ${digest.alertCount}`);
+    context.stdout(`Critical alerts: ${digest.criticalAlertCount}`);
+    if (digest.estimatedAmountMinorByCurrency.length === 0) {
+        context.stdout("Estimated totals: none");
+        return 0;
+    }
+    for (const total of digest.estimatedAmountMinorByCurrency) {
+        context.stdout(`Estimated total ${total.currency}: ${formatMinorAmount(total.amountMinor)}`);
+    }
+    return 0;
+}
+async function runNotifyPrefs(args, context) {
+    const [subcommand, ...rest] = args;
+    if (subcommand === "list" && rest.length === 0) {
+        return listNotificationPreferences(context);
+    }
+    if (subcommand === "enable" && rest.length === 1) {
+        return enableNotificationWidget(rest[0], context);
+    }
+    if (subcommand === "disable" && rest.length === 1) {
+        return disableNotificationWidget(rest[0], context);
+    }
+    if (subcommand === "hud-enable" && rest.length === 1) {
+        return enableHudWidget(rest[0], context);
+    }
+    if (subcommand === "hud-disable" && rest.length === 1) {
+        return disableHudWidget(rest[0], context);
+    }
+    if (subcommand === "threshold") {
+        return setNotificationThreshold(rest, context);
+    }
+    if (subcommand === "quiet-hours" && rest.length === 2) {
+        return setNotificationQuietHours(rest[0], rest[1], context);
+    }
+    context.stderr(NOTIFY_PREFS_USAGE);
+    return 1;
+}
+async function listNotificationPreferences(context) {
+    const source = await notificationPreferencesSource(context);
+    const preferences = await readPreferences(context);
+    const selectedWidgets = new Set(preferences.selectedWidgets);
+    const hudWidgets = new Set(preferences.hud.selectedWidgets);
+    context.stdout("MoneySiren notification preferences");
+    context.stdout(`Source: ${source}`);
+    context.stdout("Secrets returned: false");
+    context.stdout(`Notifications: ${enabledLabel(preferences.enabled)}`);
+    context.stdout(`Digest: ${enabledLabel(preferences.digestEnabled)} (${preferences.digestInterval})`);
+    context.stdout(`Desktop notifications: ${enabledLabel(preferences.desktopEnabled)}`);
+    context.stdout(`HUD font size: ${Math.round(preferences.hud.fontScale * 100)}%`);
+    context.stdout(`HUD opacity: ${Math.round(preferences.hud.opacity * 100)}%`);
+    context.stdout(`Quiet hours: ${preferences.quietHours.start}-${preferences.quietHours.end}`);
+    context.stdout("Widgets:");
+    for (const widgetKey of NOTIFICATION_WIDGET_KEYS) {
+        context.stdout(`- ${widgetKey}: ${selectedWidgets.has(widgetKey) ? "enabled" : "disabled"}`);
+    }
+    context.stdout("HUD widgets:");
+    for (const widgetKey of NOTIFICATION_WIDGET_KEYS) {
+        context.stdout(`- ${widgetKey}: ${hudWidgets.has(widgetKey) ? "enabled" : "disabled"}`);
+    }
+    if (preferences.thresholdRules.length === 0) {
+        context.stdout("Thresholds: none configured");
+        return 0;
+    }
+    context.stdout("Thresholds:");
+    for (const rule of orderThresholdRules(preferences.thresholdRules)) {
+        context.stdout(`- ${rule.widgetKey}: ${rule.operator} ${formatRuleValue(rule.value)} cooldown ${rule.cooldownMinutes}m`);
+    }
+    return 0;
+}
+async function enableNotificationWidget(widget, context) {
+    const widgetKey = parseWidgetKey(widget);
+    if (widgetKey === undefined) {
+        context.stderr("Unknown notification widget.");
+        return 1;
+    }
+    const preferences = await readPreferences(context);
+    const selectedWidgets = new Set(preferences.selectedWidgets);
+    selectedWidgets.add(widgetKey);
+    await writePreferences({
+        ...preferences,
+        selectedWidgets: orderWidgetKeys([...selectedWidgets]),
+    }, context);
+    context.stdout(`Notification widget enabled: ${widgetKey}`);
+    context.stdout("Secrets returned: false");
+    return 0;
+}
+async function disableNotificationWidget(widget, context) {
+    const widgetKey = parseWidgetKey(widget);
+    if (widgetKey === undefined) {
+        context.stderr("Unknown notification widget.");
+        return 1;
+    }
+    const preferences = await readPreferences(context);
+    const selectedWidgets = new Set(preferences.selectedWidgets);
+    if (!selectedWidgets.has(widgetKey)) {
+        context.stdout(`Notification widget already disabled: ${widgetKey}`);
+        context.stdout("Secrets returned: false");
+        return 0;
+    }
+    selectedWidgets.delete(widgetKey);
+    if (selectedWidgets.size === 0) {
+        context.stderr("At least one notification widget must remain enabled.");
+        return 1;
+    }
+    await writePreferences({
+        ...preferences,
+        selectedWidgets: orderWidgetKeys([...selectedWidgets]),
+    }, context);
+    context.stdout(`Notification widget disabled: ${widgetKey}`);
+    context.stdout("Secrets returned: false");
+    return 0;
+}
+async function enableHudWidget(widget, context) {
+    const widgetKey = parseWidgetKey(widget);
+    if (widgetKey === undefined) {
+        context.stderr("Unknown notification widget.");
+        return 1;
+    }
+    const preferences = await readPreferences(context);
+    const selectedWidgets = new Set(preferences.hud.selectedWidgets);
+    selectedWidgets.add(widgetKey);
+    await writePreferences({
+        ...preferences,
+        hud: {
+            ...preferences.hud,
+            selectedWidgets: orderWidgetKeys([...selectedWidgets]),
+        },
+    }, context);
+    context.stdout(`HUD widget enabled: ${widgetKey}`);
+    context.stdout("Secrets returned: false");
+    return 0;
+}
+async function disableHudWidget(widget, context) {
+    const widgetKey = parseWidgetKey(widget);
+    if (widgetKey === undefined) {
+        context.stderr("Unknown notification widget.");
+        return 1;
+    }
+    const preferences = await readPreferences(context);
+    const selectedWidgets = new Set(preferences.hud.selectedWidgets);
+    if (!selectedWidgets.has(widgetKey)) {
+        context.stdout(`HUD widget already disabled: ${widgetKey}`);
+        context.stdout("Secrets returned: false");
+        return 0;
+    }
+    selectedWidgets.delete(widgetKey);
+    if (selectedWidgets.size === 0) {
+        context.stderr("At least one HUD widget must remain enabled.");
+        return 1;
+    }
+    await writePreferences({
+        ...preferences,
+        hud: {
+            ...preferences.hud,
+            selectedWidgets: orderWidgetKeys([...selectedWidgets]),
+        },
+    }, context);
+    context.stdout(`HUD widget disabled: ${widgetKey}`);
+    context.stdout("Secrets returned: false");
+    return 0;
+}
+async function setNotificationThreshold(args, context) {
+    const [widget, ...flagArgs] = args;
+    const widgetKey = parseWidgetKey(widget);
+    const parsedRule = parseThresholdRuleArgs(widgetKey, flagArgs);
+    if (widgetKey === undefined) {
+        context.stderr("Unknown notification widget.");
+        return 1;
+    }
+    if (parsedRule === undefined) {
+        context.stderr("Usage: moneysiren notify prefs threshold <widget> --gte|--lte|--eq <value> --cooldown <minutes>");
+        return 1;
+    }
+    const preferences = await readPreferences(context);
+    await writePreferences({
+        ...preferences,
+        thresholdRules: orderThresholdRules([
+            ...preferences.thresholdRules.filter((rule) => rule.widgetKey !== widgetKey),
+            parsedRule,
+        ]),
+    }, context);
+    context.stdout(`Notification threshold set: ${parsedRule.widgetKey} ${parsedRule.operator} ${formatRuleValue(parsedRule.value)} cooldown ${parsedRule.cooldownMinutes}m`);
+    context.stdout("Secrets returned: false");
+    return 0;
+}
+async function setNotificationQuietHours(start, end, context) {
+    if (!isValidClockTime(start) || !isValidClockTime(end)) {
+        context.stderr("Usage: moneysiren notify prefs quiet-hours <HH:MM> <HH:MM>");
+        return 1;
+    }
+    const preferences = await readPreferences(context);
+    await writePreferences({
+        ...preferences,
+        quietHours: {
+            start,
+            end,
+        },
+    }, context);
+    context.stdout(`Notification quiet hours set: ${start}-${end}`);
+    context.stdout("Secrets returned: false");
+    return 0;
+}
+async function runNotifyTest(args, context) {
+    if (args.length !== 0) {
+        context.stderr("Usage: moneysiren notify test");
+        return 1;
+    }
+    const config = loadCliConfig(context.env);
+    const webhookEnvKey = config.slack.requiredEnvKey;
+    const webhookUrl = context.env[webhookEnvKey]?.trim();
+    if (webhookUrl === undefined || webhookUrl.length === 0) {
+        context.stderr(`${webhookEnvKey} is required for test notification.`);
+        return 1;
+    }
+    const text = [
+        "MoneySiren test notification",
+        `Generated at: ${context.now().toISOString()}`,
+        "Secrets returned: false",
+    ].join("\n");
+    try {
+        const options = context.slackTransport === undefined
+            ? {
+                webhookUrl,
+                text,
+            }
+            : {
+                webhookUrl,
+                text,
+                transport: context.slackTransport,
+            };
+        await sendSlackReport(options);
+        context.stdout("MoneySiren test notification sent");
+        context.stdout("Secrets returned: false");
+        return 0;
+    }
+    catch (error) {
+        context.stderr(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+}
+function formatMinorAmount(amountMinor) {
+    return (amountMinor / 100).toFixed(2);
+}
+async function readPreferences(context) {
+    return readNotificationPreferencesFile({
+        cwd: context.cwd,
+        env: context.env,
+    });
+}
+async function writePreferences(preferences, context) {
+    return writeNotificationPreferencesFile(preferences, {
+        cwd: context.cwd,
+        env: context.env,
+    });
+}
+async function notificationPreferencesSource(context) {
+    const path = resolveNotificationPreferencesPath({
+        cwd: context.cwd,
+        env: context.env,
+    });
+    try {
+        await stat(path);
+        return "local preference file";
+    }
+    catch {
+        return "default preference template";
+    }
+}
+function parseWidgetKey(value) {
+    return value !== undefined && NOTIFICATION_WIDGET_KEYS.includes(value)
+        ? value
+        : undefined;
+}
+function parseThresholdRuleArgs(widgetKey, args) {
+    if (widgetKey === undefined) {
+        return undefined;
+    }
+    let operator;
+    let value;
+    let cooldownMinutes;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === undefined) {
+            return undefined;
+        }
+        const operatorName = parseOperatorFlag(arg);
+        if (operatorName !== undefined) {
+            if (operator !== undefined) {
+                return undefined;
+            }
+            const inlineValue = inlineFlagValue(arg);
+            const rawValue = inlineValue ?? args[index + 1];
+            value = parseNonNegativeNumber(rawValue);
+            operator = operatorName;
+            if (inlineValue === undefined) {
+                index += 1;
+            }
+            continue;
+        }
+        if (arg === "--cooldown" || arg.startsWith("--cooldown=")) {
+            const inlineValue = inlineFlagValue(arg);
+            const rawValue = inlineValue ?? args[index + 1];
+            cooldownMinutes = parseNonNegativeInteger(rawValue);
+            if (inlineValue === undefined) {
+                index += 1;
+            }
+            continue;
+        }
+        return undefined;
+    }
+    if (operator === undefined || value === undefined || cooldownMinutes === undefined) {
+        return undefined;
+    }
+    return {
+        widgetKey,
+        operator,
+        value,
+        cooldownMinutes,
+    };
+}
+function parseOperatorFlag(value) {
+    if (value === "--gte" || value.startsWith("--gte=")) {
+        return "gte";
+    }
+    if (value === "--lte" || value.startsWith("--lte=")) {
+        return "lte";
+    }
+    if (value === "--eq" || value.startsWith("--eq=")) {
+        return "eq";
+    }
+    return undefined;
+}
+function inlineFlagValue(value) {
+    const separatorIndex = value.indexOf("=");
+    return separatorIndex === -1 ? undefined : value.slice(separatorIndex + 1);
+}
+function parseNonNegativeNumber(value) {
+    if (value === undefined || value.trim().length === 0) {
+        return undefined;
+    }
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined;
+}
+function parseNonNegativeInteger(value) {
+    const parsed = parseNonNegativeNumber(value);
+    return parsed !== undefined && Number.isInteger(parsed) ? parsed : undefined;
+}
+function orderWidgetKeys(widgetKeys) {
+    const selected = new Set(widgetKeys);
+    return NOTIFICATION_WIDGET_KEYS.filter((widgetKey) => selected.has(widgetKey));
+}
+function orderThresholdRules(rules) {
+    const byWidgetKey = new Map(rules.map((rule) => [rule.widgetKey, rule]));
+    return NOTIFICATION_WIDGET_KEYS.flatMap((widgetKey) => {
+        const rule = byWidgetKey.get(widgetKey);
+        return rule === undefined ? [] : [rule];
+    });
+}
+function enabledLabel(value) {
+    return value ? "enabled" : "disabled";
+}
+function formatRuleValue(value) {
+    return String(value);
+}
+function isValidClockTime(value) {
+    if (value === undefined || !/^\d{2}:\d{2}$/.test(value)) {
+        return false;
+    }
+    const [hourText, minuteText] = value.split(":");
+    const hour = Number(hourText);
+    const minute = Number(minuteText);
+    return hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59;
+}
+//# sourceMappingURL=notify.js.map

package/dist/apps/cli/src/commands/report.d.ts

@@ -0,0 +1,3 @@
+import type { CliExecutionContext } from "../cli.js";
+export declare function runReportCommand(args: readonly string[], context: CliExecutionContext): Promise<number>;
+//# sourceMappingURL=report.d.ts.map