@blogic-cz/agent-tools 0.11.0 → 0.12.0

package/src/grafana-tool/alerts.ts

@@ -1,159 +0,0 @@
-import { Console, Effect } from "effect";
-import { Command, Flag } from "effect/unstable/cli";
-
-import { formatOption, formatOutput } from "#shared";
-
-import {
-  envOption,
-  formatGrafanaError,
-  grafanaFetch,
-  profileOption,
-  resolveConfig,
-} from "./shared";
-
-type AlertRulesResponse = Record<
-  string,
-  Array<{
-    name: string;
-    rules: Array<{
-      name: string;
-      state: string;
-      health: string;
-      lastEvaluation?: string;
-      evaluationTime?: number;
-    }>;
-  }>
->;
-
-type AlertInstance = {
-  labels: Record<string, string>;
-  annotations: Record<string, string>;
-  state: string;
-  activeAt?: string;
-  value?: string;
-};
-
-const listCommand = Command.make(
-  "list",
-  { format: formatOption, env: envOption, profile: profileOption },
-  ({ format, env, profile }) => {
-    const start = Date.now();
-
-    return Effect.gen(function* () {
-      const config = yield* resolveConfig(env, profile);
-      const data = yield* grafanaFetch<AlertRulesResponse>(
-        config,
-        "/api/ruler/grafana/api/v1/rules",
-      );
-
-      const rules = Object.entries(data).flatMap(([namespace, groups]) =>
-        groups.flatMap((group) =>
-          group.rules.map((rule) => ({
-            name: rule.name,
-            state: rule.state,
-            health: rule.health,
-            namespace,
-            group: group.name,
-            lastEvaluation: rule.lastEvaluation,
-            evaluationTime: rule.evaluationTime,
-          })),
-        ),
-      );
-
-      const result = {
-        success: true,
-        message: `Found ${rules.length} alert rule(s)`,
-        data: { rules, count: rules.length },
-        executionTimeMs: Date.now() - start,
-      };
-
-      yield* Console.log(formatOutput(result, format));
-    }).pipe(
-      Effect.catch((error) =>
-        Effect.gen(function* () {
-          const result = {
-            success: false,
-            message: "Failed to list alert rules",
-            error: formatGrafanaError(error),
-            hint: "Check Grafana is running and accessible",
-            executionTimeMs: Date.now() - start,
-          };
-
-          yield* Console.log(formatOutput(result, format));
-        }),
-      ),
-    );
-  },
-).pipe(Command.withDescription("List all alert rules"));
-
-const statusCommand = Command.make(
-  "status",
-  {
-    format: formatOption,
-    env: envOption,
-    profile: profileOption,
-    all: Flag.boolean("all").pipe(
-      Flag.withDescription("Show all alerts including normal state"),
-      Flag.withDefault(false),
-    ),
-  },
-  ({ format, env, profile, all }) => {
-    const start = Date.now();
-
-    return Effect.gen(function* () {
-      const config = yield* resolveConfig(env, profile);
-      const alerts = yield* grafanaFetch<AlertInstance[]>(
-        config,
-        "/api/alertmanager/grafana/api/v2/alerts",
-      );
-
-      const filtered = all
-        ? alerts
-        : alerts.filter((alert) => alert.state === "firing" || alert.state === "pending");
-      const firingCount = filtered.filter((alert) => alert.state === "firing").length;
-      const pendingCount = filtered.filter((alert) => alert.state === "pending").length;
-
-      const result = {
-        success: true,
-        message:
-          firingCount === 0 && pendingCount === 0
-            ? "No active alerts"
-            : `${firingCount} firing, ${pendingCount} pending alert(s)`,
-        data: {
-          alerts: filtered.map((alert) => ({
-            state: alert.state,
-            labels: alert.labels,
-            annotations: alert.annotations,
-            activeAt: alert.activeAt,
-            value: alert.value,
-          })),
-          firingCount,
-          pendingCount,
-          totalCount: filtered.length,
-        },
-        executionTimeMs: Date.now() - start,
-      };
-
-      yield* Console.log(formatOutput(result, format));
-    }).pipe(
-      Effect.catch((error) =>
-        Effect.gen(function* () {
-          const result = {
-            success: false,
-            message: "Failed to get alert status",
-            error: formatGrafanaError(error),
-            hint: "Check Grafana is running and accessible",
-            executionTimeMs: Date.now() - start,
-          };
-
-          yield* Console.log(formatOutput(result, format));
-        }),
-      ),
-    );
-  },
-).pipe(Command.withDescription("Show firing and pending alerts"));
-
-export const alertsCommand = Command.make("alerts", {}).pipe(
-  Command.withDescription("Alert operations"),
-  Command.withSubcommands([listCommand, statusCommand]),
-);

package/src/grafana-tool/dashboards.ts

@@ -1,151 +0,0 @@
-import { Console, Effect, Option } from "effect";
-import { Argument, Command, Flag } from "effect/unstable/cli";
-
-import { formatOption, formatOutput } from "#shared";
-
-import {
-  envOption,
-  formatGrafanaError,
-  grafanaFetch,
-  profileOption,
-  resolveConfig,
-} from "./shared";
-
-type DashboardSearchItem = {
-  id: number;
-  uid: string;
-  title: string;
-  url: string;
-  type: string;
-  tags: string[];
-  folderTitle?: string;
-};
-
-type DashboardDetail = {
-  dashboard: {
-    id: number;
-    uid: string;
-    title: string;
-    tags: string[];
-    version: number;
-    panels?: Array<{ id: number; title: string; type: string }>;
-  };
-};
-
-const listCommand = Command.make(
-  "list",
-  {
-    format: formatOption,
-    env: envOption,
-    profile: profileOption,
-    folder: Flag.optional(
-      Flag.string("folder").pipe(Flag.withDescription("Filter by folder title (case-insensitive)")),
-    ),
-  },
-  ({ format, env, profile, folder }) => {
-    const start = Date.now();
-
-    return Effect.gen(function* () {
-      const config = yield* resolveConfig(env, profile);
-
-      const items = yield* grafanaFetch<DashboardSearchItem[]>(
-        config,
-        "/api/search?type=dash-db&limit=1000",
-      );
-
-      const folderFilter = Option.getOrUndefined(folder)?.toLowerCase();
-      const dashboards = items
-        .map((item) => ({
-          uid: item.uid,
-          title: item.title,
-          url: item.url,
-          tags: item.tags,
-          folderTitle: item.folderTitle ?? "General",
-        }))
-        .filter((item) =>
-          folderFilter ? item.folderTitle.toLowerCase().includes(folderFilter) : true,
-        );
-
-      const result = {
-        success: true,
-        message: folderFilter
-          ? `Found ${dashboards.length} dashboard(s) in folder '${folderFilter}'`
-          : `Found ${dashboards.length} dashboard(s)`,
-        data: { dashboards, count: dashboards.length },
-        executionTimeMs: Date.now() - start,
-      };
-
-      yield* Console.log(formatOutput(result, format));
-    }).pipe(
-      Effect.catch((error) =>
-        Effect.gen(function* () {
-          const result = {
-            success: false,
-            message: "Failed to list dashboards",
-            error: formatGrafanaError(error),
-            hint: "Check Grafana is running and accessible",
-            executionTimeMs: Date.now() - start,
-          };
-          yield* Console.log(formatOutput(result, format));
-        }),
-      ),
-    );
-  },
-).pipe(Command.withDescription("List all dashboards"));
-
-const getCommand = Command.make(
-  "get",
-  { uid: Argument.string("uid"), format: formatOption, env: envOption, profile: profileOption },
-  ({ uid, format, env, profile }) => {
-    const start = Date.now();
-
-    return Effect.gen(function* () {
-      const config = yield* resolveConfig(env, profile);
-
-      const detail = yield* grafanaFetch<DashboardDetail>(
-        config,
-        `/api/dashboards/uid/${encodeURIComponent(uid)}`,
-      );
-
-      const panels = (detail.dashboard.panels ?? []).map((panel) => ({
-        id: panel.id,
-        title: panel.title,
-        type: panel.type,
-      }));
-
-      const result = {
-        success: true,
-        message: `Dashboard: ${detail.dashboard.title}`,
-        data: {
-          uid: detail.dashboard.uid,
-          title: detail.dashboard.title,
-          tags: detail.dashboard.tags,
-          version: detail.dashboard.version,
-          panels,
-          panelCount: panels.length,
-        },
-        executionTimeMs: Date.now() - start,
-      };
-
-      yield* Console.log(formatOutput(result, format));
-    }).pipe(
-      Effect.catch((error) =>
-        Effect.gen(function* () {
-          const result = {
-            success: false,
-            message: `Failed to get dashboard '${uid}'`,
-            error: formatGrafanaError(error),
-            hint: "Check the dashboard UID is correct",
-            executionTimeMs: Date.now() - start,
-          };
-          yield* Console.log(formatOutput(result, format));
-        }),
-      ),
-    );
-  },
-).pipe(Command.withDescription("Get dashboard details by UID"));
-
-export const dashboardsCommand = Command.make("dashboards", {}).pipe(
-  Command.withDescription("Dashboard operations"),
-  Command.withSubcommands([listCommand, getCommand]),
-);

package/src/grafana-tool/datasources.ts

@@ -1,72 +0,0 @@
-import { Console, Effect } from "effect";
-import { Command } from "effect/unstable/cli";
-
-import { formatOption, formatOutput } from "#shared";
-
-import {
-  envOption,
-  formatGrafanaError,
-  grafanaFetch,
-  profileOption,
-  resolveConfig,
-} from "./shared";
-
-type Datasource = {
-  id: number;
-  uid: string;
-  name: string;
-  type: string;
-  url: string;
-  isDefault: boolean;
-};
-
-const listCommand = Command.make(
-  "list",
-  { format: formatOption, env: envOption, profile: profileOption },
-  ({ format, env, profile }) => {
-    const start = Date.now();
-
-    return Effect.gen(function* () {
-      const config = yield* resolveConfig(env, profile);
-
-      const items = yield* grafanaFetch<Datasource[]>(config, "/api/datasources");
-
-      const result = {
-        success: true,
-        message: `Found ${items.length} datasource(s)`,
-        data: {
-          datasources: items.map((item) => ({
-            uid: item.uid,
-            name: item.name,
-            type: item.type,
-            url: item.url,
-            isDefault: item.isDefault,
-          })),
-          count: items.length,
-        },
-        executionTimeMs: Date.now() - start,
-      };
-
-      yield* Console.log(formatOutput(result, format));
-    }).pipe(
-      Effect.catch((error) =>
-        Effect.gen(function* () {
-          const result = {
-            success: false,
-            message: "Failed to list datasources",
-            error: formatGrafanaError(error),
-            hint: "Check Grafana is running and accessible",
-            executionTimeMs: Date.now() - start,
-          };
-
-          yield* Console.log(formatOutput(result, format));
-        }),
-      ),
-    );
-  },
-).pipe(Command.withDescription("List configured datasources"));
-
-export const datasourcesCommand = Command.make("datasources", {}).pipe(
-  Command.withDescription("Datasource operations"),
-  Command.withSubcommands([listCommand]),
-);

package/src/grafana-tool/errors.ts

@@ -1,8 +0,0 @@
-import { Schema } from "effect";
-
-export class GrafanaToolError extends Schema.TaggedErrorClass<GrafanaToolError>()(
-  "GrafanaToolError",
-  {
-    cause: Schema.Unknown,
-  },
-) {}

package/src/grafana-tool/health.ts

@@ -1,57 +0,0 @@
-import { Console, Effect } from "effect";
-import { Command } from "effect/unstable/cli";
-
-import { formatOption, formatOutput } from "#shared";
-
-import {
-  envOption,
-  formatGrafanaError,
-  grafanaFetch,
-  profileOption,
-  resolveConfig,
-} from "./shared";
-
-export const healthCommand = Command.make(
-  "health",
-  { format: formatOption, env: envOption, profile: profileOption },
-  ({ format, env, profile }) => {
-    const start = Date.now();
-
-    return Effect.gen(function* () {
-      const config = yield* resolveConfig(env, profile);
-
-      const body = yield* grafanaFetch<{ database?: string; version?: string; commit?: string }>(
-        config,
-        "/api/health",
-      );
-
-      const result = {
-        success: true,
-        message: `Grafana is healthy (${config.url})`,
-        data: {
-          url: config.url,
-          httpStatus: 200,
-          response: body,
-          env,
-        },
-        executionTimeMs: Date.now() - start,
-      };
-
-      yield* Console.log(formatOutput(result, format));
-    }).pipe(
-      Effect.catch((error) =>
-        Effect.gen(function* () {
-          const result = {
-            success: false,
-            message: "Grafana is unreachable",
-            error: formatGrafanaError(error),
-            hint: "Check Grafana is running and accessible",
-            executionTimeMs: Date.now() - start,
-          };
-
-          yield* Console.log(formatOutput(result, format));
-        }),
-      ),
-    );
-  },
-).pipe(Command.withDescription("Check Grafana health and connectivity"));

package/src/grafana-tool/logs.ts

@@ -1,124 +0,0 @@
-import { Console, Effect } from "effect";
-import { Argument, Command, Flag } from "effect/unstable/cli";
-
-import { formatOption, formatOutput } from "#shared";
-
-import { GrafanaToolError } from "./errors";
-import {
-  envOption,
-  formatGrafanaError,
-  grafanaDsQuery,
-  profileOption,
-  resolveConfig,
-} from "./shared";
-
-function parseLabel(value: string | Record<string, string>): Record<string, string> {
-  if (typeof value === "object" && value !== null) {
-    return value;
-  }
-
-  try {
-    return JSON.parse(value) as Record<string, string>;
-  } catch {
-    return {};
-  }
-}
-
-const queryCommand = Command.make(
-  "query",
-  {
-    logql: Argument.string("logql"),
-    format: formatOption,
-    env: envOption,
-    profile: profileOption,
-    limit: Flag.integer("limit").pipe(
-      Flag.withDescription("Max log lines (default: 100)"),
-      Flag.withDefault(100),
-    ),
-    start: Flag.string("start").pipe(
-      Flag.withDescription("Start time (default: now-1h)"),
-      Flag.withDefault("now-1h"),
-    ),
-    end: Flag.string("end").pipe(
-      Flag.withDescription("End time (default: now)"),
-      Flag.withDefault("now"),
-    ),
-  },
-  ({ logql, format, env, profile, limit, start, end }) => {
-    const startedAt = Date.now();
-
-    return Effect.gen(function* () {
-      const config = yield* resolveConfig(env, profile);
-      const response = yield* grafanaDsQuery(config, config.lokiUid, "loki", logql, {
-        from: start,
-        to: end,
-        maxLines: limit,
-      });
-
-      if (response.results.A.error) {
-        return yield* new GrafanaToolError({
-          cause: new Error(response.results.A.error),
-        });
-      }
-
-      const logs: Array<{ timestamp: string; line: string; labels: Record<string, string> }> = [];
-      for (const frame of response.results.A.frames ?? []) {
-        const fields = frame.schema.fields;
-        const values = frame.data.values;
-        const timeIndex = fields.findIndex(
-          (field) => field.name === "timestamp" || field.type === "time",
-        );
-        const lineIndex = fields.findIndex(
-          (field) => field.name === "body" || field.name === "Line" || field.name === "line",
-        );
-        const labelsIndex = fields.findIndex(
-          (field) => field.name === "labels" || field.name === "labelTypes",
-        );
-
-        const timestamps = (timeIndex >= 0 ? values[timeIndex] : []) as Array<string | number>;
-        const lines = (lineIndex >= 0 ? values[lineIndex] : []) as string[];
-        const labelValues = (labelsIndex >= 0 ? values[labelsIndex] : []) as Array<
-          string | Record<string, string>
-        >;
-
-        for (const [index, line] of lines.entries()) {
-          logs.push({
-            timestamp: String(timestamps[index] ?? ""),
-            line,
-            labels: labelValues[index] ? parseLabel(labelValues[index]) : {},
-          });
-        }
-      }
-
-      logs.sort((left, right) => (left.timestamp > right.timestamp ? -1 : 1));
-
-      const result = {
-        success: true,
-        message: `LogQL query returned ${logs.length} log line(s)`,
-        data: { logs, query: logql, logCount: logs.length },
-        executionTimeMs: Date.now() - startedAt,
-      };
-
-      yield* Console.log(formatOutput(result, format));
-    }).pipe(
-      Effect.catch((error) =>
-        Effect.gen(function* () {
-          const result = {
-            success: false,
-            message: "Failed to execute LogQL query",
-            error: formatGrafanaError(error),
-            hint: "Check LogQL syntax and Grafana/Loki connectivity",
-            executionTimeMs: Date.now() - startedAt,
-          };
-
-          yield* Console.log(formatOutput(result, format));
-        }),
-      ),
-    );
-  },
-).pipe(Command.withDescription("Query logs via Grafana/Loki"));
-
-export const logsCommand = Command.make("logs", {}).pipe(
-  Command.withDescription("Loki log operations"),
-  Command.withSubcommands([queryCommand]),
-);