@nuvlore/extension-bds 0.1.1

package/tools/bds_oncall_followup_payload_draft.mjs

@@ -0,0 +1,285 @@
+export const description = "Create a atomic-helper BDS on-call report row and BDS Jira follow-up draft for BDS-owned on-call issues.";
+
+import { z } from "zod";
+import { defineReadOnlyTool, fail, ok } from "@nuvlore/extension-read-only-toolkit/devops-diagnostics";
+
+const DEFAULT_ANCHOR_START = "2026/05/26";
+const DEFAULT_PERIOD_DAYS = 14;
+const DEFAULT_SPACE_KEY = "BD";
+const DEFAULT_PARENT_PAGE_ID = "4259305001";
+const DEFAULT_REPORT_PAGE_ID = "4432574596";
+
+const issueSchema = z.object({
+  issue: z.string().trim().min(1).max(512),
+  issueDescription: z.string().trim().min(1).max(5000),
+  slackOrJira: z.array(z.string().trim().min(1).max(2048)).max(12).default([]),
+  rca: z.string().trim().max(8000).default(""),
+  impact: z.string().trim().max(5000).default(""),
+  followUpNeeded: z.boolean().default(false),
+  followUpJira: z.string().trim().max(128).default(""),
+  codePointer: z.string().trim().max(8000).default("")
+});
+
+const inputSchema = {
+  currentDate: z.string().trim().regex(/^\d{4}-\d{2}-\d{2}$/u).optional(),
+  anchorStartDate: z.string().trim().regex(/^\d{4}\/\d{2}\/\d{2}$/u).default(DEFAULT_ANCHOR_START),
+  periodDays: z.number().int().positive().max(31).default(DEFAULT_PERIOD_DAYS),
+  spaceKey: z.string().trim().min(1).max(128).default(DEFAULT_SPACE_KEY),
+  parentPageId: z.string().trim().min(1).max(128).default(DEFAULT_PARENT_PAGE_ID),
+  reportPageId: z.string().trim().min(1).max(128).default(DEFAULT_REPORT_PAGE_ID),
+  issue: issueSchema,
+  format: z.enum(["json", "markdown"]).default("json")
+};
+
+function parseSlashDate(value) {
+  const [year, month, day] = String(value).split("/").map(Number);
+  return new Date(Date.UTC(year, month - 1, day));
+}
+
+function parseDashDate(value) {
+  const [year, month, day] = String(value).split("-").map(Number);
+  return new Date(Date.UTC(year, month - 1, day));
+}
+
+function addDays(date, days) {
+  const next = new Date(date.getTime());
+  next.setUTCDate(next.getUTCDate() + days);
+  return next;
+}
+
+function slashDate(date) {
+  const year = date.getUTCFullYear();
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(date.getUTCDate()).padStart(2, "0");
+  return `${year}/${month}/${day}`;
+}
+
+function daysBetween(left, right) {
+  return Math.floor((right.getTime() - left.getTime()) / 86_400_000);
+}
+
+function resolveOncallRange({ currentDate, anchorStartDate, periodDays } = {}) {
+  const normalizedAnchorStartDate = anchorStartDate || DEFAULT_ANCHOR_START;
+  const normalizedPeriodDays = periodDays || DEFAULT_PERIOD_DAYS;
+  const anchor = parseSlashDate(normalizedAnchorStartDate);
+  const current = currentDate ? parseDashDate(currentDate) : new Date();
+  const periodsSinceAnchor = Math.floor(daysBetween(anchor, current) / normalizedPeriodDays);
+  const start = addDays(anchor, periodsSinceAnchor * normalizedPeriodDays);
+  const end = addDays(start, normalizedPeriodDays);
+  return {
+    startDate: slashDate(start),
+    endDate: slashDate(end),
+    title: `BDS On Call Handoff ${slashDate(start)}-${slashDate(end)}`
+  };
+}
+
+function normalizeText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function normalizeIssue(input = {}) {
+  return {
+    issue: normalizeText(input.issue),
+    issueDescription: normalizeText(input.issueDescription),
+    slackOrJira: Array.isArray(input.slackOrJira) ? input.slackOrJira.filter((item) => normalizeText(item)) : [],
+    rca: normalizeText(input.rca),
+    impact: normalizeText(input.impact),
+    followUpNeeded: Boolean(input.followUpNeeded),
+    followUpJira: normalizeText(input.followUpJira),
+    codePointer: normalizeText(input.codePointer)
+  };
+}
+
+function paragraphDraft(value) {
+  return normalizeText(value)
+    .split(/\n+/u)
+    .map((line) => line.trim())
+    .filter(Boolean);
+}
+
+function jiraUrl(keyOrUrl) {
+  const text = normalizeText(keyOrUrl);
+  if (!text) return "";
+  if (/^https?:\/\//iu.test(text)) return text;
+  if (/^[A-Z][A-Z0-9]+-\d+$/u.test(text)) return `https://jira2.workday.com/browse/${text}`;
+  return text;
+}
+
+function jiraKey(keyOrUrl) {
+  const text = normalizeText(keyOrUrl);
+  const match = text.match(/[A-Z][A-Z0-9]+-\d+/u);
+  return match?.[0] || text;
+}
+
+function buildJiraDraft(issue) {
+  if (!issue.followUpNeeded) return null;
+  const summary = `Follow up: ${issue.issue}`;
+  const codePointer = normalizeText(issue.codePointer);
+  return {
+    project: "BDS",
+    issueType: "Story",
+    component: "Devops",
+    labels: ["oncall-followup"],
+    summary,
+    description: [
+      "Context:",
+      issue.issueDescription,
+      "",
+      "Current code/problem to investigate:",
+      normalizeText(issue.rca) || "TBD from BDS-owned evidence.",
+      "",
+      ...(codePointer ? [
+        "Code pointer:",
+        "{code}",
+        codePointer,
+        "{code}",
+        ""
+      ] : []),
+      "What needs correction:",
+      "- Identify the BDS-owned code or workflow gap that allowed this on-call issue.",
+      "- Keep the fix focused on the BDS-owned failure mode. Do not broaden to unrelated TAR/MTP/DB issues.",
+      "- Leave implementation details to the assignee after code inspection.",
+      "",
+      "Acceptance criteria:",
+      "- Add or update a regression test for the BDS-owned failure mode.",
+      "- Error handling or diagnostics are clear enough for on-call to distinguish BDS state from upstream/non-BDS issues.",
+      "",
+      "References:",
+      ...issue.slackOrJira.map((item) => `- ${item}`)
+    ].join("\n")
+  };
+}
+
+function buildOncallRowDraft(issue) {
+  const followUp = normalizeText(issue.followUpJira);
+  const row = {
+    issue: issue.issue,
+    issueDescription: issue.issueDescription,
+    slackChannelOrJira: issue.slackOrJira,
+    rca: normalizeText(issue.rca),
+    impact: normalizeText(issue.impact),
+    followUpJira: followUp ? {
+      key: jiraKey(followUp),
+      url: jiraUrl(followUp)
+    } : null
+  };
+  return {
+    ...row,
+    paragraphDraft: {
+      issue: paragraphDraft(row.issue),
+      issueDescription: paragraphDraft(row.issueDescription),
+      slackChannelOrJira: row.slackChannelOrJira,
+      rca: paragraphDraft(row.rca),
+      impact: paragraphDraft(row.impact),
+      followUpJira: row.followUpJira
+    }
+  };
+}
+
+export class BdsOncallFollowupPayloadDraftService {
+  invoke(input = {}) {
+    const range = resolveOncallRange(input);
+    const issue = normalizeIssue(input.issue);
+    const jiraDraft = buildJiraDraft(issue);
+    const followUpJira = normalizeText(issue.followUpJira);
+    const payloadDraft = {
+      mode: "atomic-helper",
+      remoteWrite: "not_executed",
+      range,
+      confluence: {
+        spaceKey: input.spaceKey || DEFAULT_SPACE_KEY,
+        parentPageId: input.parentPageId || DEFAULT_PARENT_PAGE_ID,
+        reportPageId: input.reportPageId || DEFAULT_REPORT_PAGE_ID,
+        reportTitle: range.title,
+        reportUrl: `https://confluence.workday.com/pages/viewpage.action?pageId=${input.reportPageId || DEFAULT_REPORT_PAGE_ID}`,
+        rowDraft: buildOncallRowDraft(issue)
+      },
+      jira: {
+        shouldCreateFollowUp: Boolean(issue.followUpNeeded && !followUpJira),
+        existingFollowUp: followUpJira ? {
+          key: jiraKey(followUpJira),
+          url: jiraUrl(followUpJira)
+        } : null,
+        draft: jiraDraft
+      },
+      reviewNotes: [
+        "Verify the issue is BDS-owned before creating a BDS Jira.",
+        "If the issue source is a Slack incident thread, use that Slack thread as the report Issue source and keep any main Jira as tracking context.",
+        "When a main Jira exists, read its issuelinks and use a linked monitoring/product follow-up ticket as the Follow-up Jira when present.",
+        "Search Jira for existing follow-ups using tenant, cluster, alert, and issue keywords before creating a new ticket.",
+        "Create a BDS Jira only when followUpNeeded=true and no followUpJira is already present.",
+        "Keep the Jira focused on concrete BDS code/workflow gaps; avoid over-specifying implementation.",
+        "Add or update the current on-call Confluence row, including the follow-up Jira link when present.",
+        "When updating an existing Confluence table, preserve unrelated issue rows; if a row contains multiple issues, split or append the new issue instead of replacing the whole row.",
+        "Render every issue row in paragraph format: split issue description, RCA/evidence, impact, and links into separate paragraphs instead of one dense cell.",
+        "Do not mention Codex or internal assistant/thread provenance in requester-facing Confluence or Jira content.",
+        "Read back Jira and Confluence after writes to confirm both systems were updated, the Confluence version advanced, and the target row contains the Slack thread, main Jira, and follow-up Jira when relevant."
+      ]
+    };
+    return input.format === "markdown" ? renderMarkdown(payloadDraft) : JSON.stringify(payloadDraft, null, 2);
+  }
+}
+
+function bdsOncallFollowupPayloadDraft(input = {}) {
+  return new BdsOncallFollowupPayloadDraftService().invoke(input);
+}
+
+const defaultService = new BdsOncallFollowupPayloadDraftService();
+
+function renderMarkdown(payloadDraft) {
+  const lines = [
+    "# BDS On-call Follow-up Payload Draft",
+    "",
+    `Mode: ${payloadDraft.mode}`,
+    `Remote write: ${payloadDraft.remoteWrite}`,
+    `Report: ${payloadDraft.confluence.reportTitle}`,
+    `Report URL: ${payloadDraft.confluence.reportUrl}`,
+    "",
+    "## On-call Row",
+    `- Issue: ${payloadDraft.confluence.rowDraft.issue}`,
+    `- Issue Description: ${payloadDraft.confluence.rowDraft.issueDescription}`,
+    `- Slack/Jira: ${payloadDraft.confluence.rowDraft.slackChannelOrJira.join(", ") || "TBD"}`,
+    `- RCA: ${payloadDraft.confluence.rowDraft.rca || "TBD"}`,
+    `- Impact: ${payloadDraft.confluence.rowDraft.impact || "TBD"}`,
+    `- Follow up Jira: ${payloadDraft.confluence.rowDraft.followUpJira?.url || "TBD"}`,
+    "",
+    "## Paragraph Draft",
+    `- Issue paragraphs: ${payloadDraft.confluence.rowDraft.paragraphDraft.issue.join(" | ") || "TBD"}`,
+    `- Description paragraphs: ${payloadDraft.confluence.rowDraft.paragraphDraft.issueDescription.join(" | ") || "TBD"}`,
+    `- RCA paragraphs: ${payloadDraft.confluence.rowDraft.paragraphDraft.rca.join(" | ") || "TBD"}`,
+    `- Impact paragraphs: ${payloadDraft.confluence.rowDraft.paragraphDraft.impact.join(" | ") || "TBD"}`,
+    "",
+    "## Jira",
+    payloadDraft.jira.shouldCreateFollowUp ? `Create draft: ${payloadDraft.jira.draft.summary}` : `Existing follow-up: ${payloadDraft.jira.existingFollowUp?.url || "none"}`,
+    "",
+    "## Review Notes",
+    ...payloadDraft.reviewNotes.map((item) => `- ${item}`)
+  ];
+  return lines.join("\n");
+}
+
+export default defineReadOnlyTool({
+  name: "bds_oncall_followup_payload_draft",
+  description: "Create a atomic-helper BDS on-call report row and BDS Jira follow-up draft for BDS-owned on-call issues.",
+  inputSchema,
+  annotations: { openWorldHint: false },
+  async handler(input) {
+    try {
+      return ok(defaultService.invoke(input));
+    } catch (error) {
+      return fail(error);
+    }
+  }
+});
+
+export const __test = {
+  DEFAULT_ANCHOR_START,
+  DEFAULT_PERIOD_DAYS,
+  buildJiraDraft,
+  buildOncallRowDraft,
+  bdsOncallFollowupPayloadDraft,
+  BdsOncallFollowupPayloadDraftService,
+  normalizeIssue,
+  paragraphDraft,
+  resolveOncallRange
+};

package/tools/bds_pharos_query_pack.mjs

@@ -0,0 +1,218 @@
+export const description = "Create a atomic-helper translation from BDS Pharos investigation fields to read-only Pharos alert, silence, Prometheus, and dashboard tool calls; does not call Pharos.";
+
+import { z } from "zod";
+import { defineReadOnlyTool, fail, ok } from "@nuvlore/extension-read-only-toolkit/devops-diagnostics";
+
+const domainQueries = [
+  {
+    domain: "disk",
+    dashboards: ["single_server", "datanode", "hdfs", "cluster"],
+    queries: [
+      "topk(10, bds_disk_kernel_daily_io_error_total{wd_owner=\"bds\", bds_cluster=\"$cluster\"})",
+      "topk(10, rate(datanode_failed_volumes{bds_cluster=\"$cluster\"}[5m]))"
+    ]
+  },
+  {
+    domain: "yarn",
+    dashboards: ["yarn", "resourcemanager", "nodemanager", "cluster"],
+    queries: [
+      "bds_yarn_overall_status{bds_cluster=\"$cluster\"}",
+      "topk(10, yarn_queue_apps_running{bds_cluster=\"$cluster\"})"
+    ]
+  },
+  {
+    domain: "namenode",
+    dashboards: ["namenode", "hdfs", "cluster"],
+    queries: [
+      "bds_namenode_ha_state{bds_cluster=\"$cluster\"}",
+      "topk(10, namenode_rpc_queue_time_avg_time{bds_cluster=\"$cluster\"})"
+    ]
+  },
+  {
+    domain: "kubernetes",
+    dashboards: ["k8s", "cluster"],
+    queries: [
+      "up{wd_owner=\"bds\", bds_cluster=\"$cluster\", job=~\".*kube.*\"}",
+      "sum by (pod) (kube_pod_container_status_restarts_total{bds_cluster=\"$cluster\"})"
+    ]
+  },
+  {
+    domain: "airflow",
+    dashboards: ["airflow", "cluster"],
+    queries: [
+      "airflow_dag_status{bds_cluster=\"$cluster\"}",
+      "topk(10, airflow_task_status{bds_cluster=\"$cluster\"})"
+    ]
+  },
+  {
+    domain: "kms",
+    dashboards: ["kms", "cluster"],
+    queries: [
+      "up{wd_owner=\"bds\", bds_cluster=\"$cluster\", job=~\".*kms.*\"}",
+      "topk(10, rate(kms_requests_total{bds_cluster=\"$cluster\"}[5m]))"
+    ]
+  }
+];
+
+const domainQueryByName = new Map(domainQueries.map((entry) => [entry.domain, entry]));
+
+export class BdsTimeWindowResolver {
+  resolve(input) {
+    if (input.start || input.end) {
+      return { start: input.start, end: input.end ?? "now" };
+    }
+    return { start: "now-6h", end: "now" };
+  }
+}
+
+const timeWindowResolver = new BdsTimeWindowResolver();
+
+function renderQuery(query, cluster, source) {
+  let rendered = query;
+  if (cluster) rendered = rendered.replaceAll("$cluster", cluster);
+  else rendered = rendered.replaceAll('bds_cluster="$cluster"', 'wd_owner="bds"');
+  if (source && !rendered.includes("source=")) {
+    rendered = rendered.replace(/\{([^}]*)\}/, (_match, labels) => `{${labels}, source="${source}"}`);
+  }
+  return rendered;
+}
+
+function bdsPharosQueryPlan(input, dependencies = {}) {
+  const {
+    timeWindowResolver: activeTimeWindowResolver = timeWindowResolver
+  } = dependencies;
+  const text = input.request.trim();
+  const cluster = input.cluster || "";
+  const source = input.source || "";
+  const alertName = input.alertName || "";
+  const intent = input.intent || "metric_query";
+  const domain = input.domain ? domainQueryByName.get(input.domain) : null;
+  const timeWindow = activeTimeWindowResolver.resolve(input);
+  const filters = [
+    alertName ? { key: "alertname", value: alertName } : null,
+    source ? { key: "source", value: source } : null,
+    cluster ? { key: "bds_cluster", value: cluster } : null
+  ].filter(Boolean);
+
+  const steps = [];
+  if (intent === "firing_alerts" || intent === "health_check" || alertName) {
+    steps.push({
+      tool: "mcp__devops-tool__pharos_alert_read",
+      action: "firing_alerts",
+      args: { action: "firing_alerts", environment: input.environment, namespace: "bds", alertName: alertName || undefined, filters }
+    });
+  }
+  if (intent === "silence_status" || intent === "health_check" || alertName || source || cluster) {
+    steps.push({
+      tool: "mcp__devops-tool__pharos_alert_read",
+      action: "active_silences",
+      args: { action: "active_silences", environment: input.environment, namespace: "bds", filters }
+    });
+  }
+  if (intent === "rule_details" && alertName) {
+    steps.push({
+      tool: "mcp__devops-tool__pharos_alert_read",
+      action: "alert_rules",
+      args: { action: "alert_rules", environment: input.environment, namespace: "bds", alertName, filters: [] }
+    });
+  }
+  if (intent === "discover_metrics") {
+    steps.push({
+      tool: "mcp__devops-tool__pharos_prometheus_read",
+      action: "label_values",
+      args: { action: "label_values", environment: input.environment, labelName: "bds_cluster", matchers: ['{wd_owner="bds"}'] }
+    });
+  }
+  for (const query of (domain?.queries ?? ['up{wd_owner="bds"}']).slice(0, 3)) {
+    steps.push({
+      tool: "mcp__devops-tool__pharos_prometheus_read",
+      action: intent === "metric_range" || intent === "health_check" ? "query_range" : "query",
+      args: {
+        action: intent === "metric_range" || intent === "health_check" ? "query_range" : "query",
+        environment: input.environment,
+        query: renderQuery(query, cluster, source),
+        start: intent === "metric_range" || intent === "health_check" ? timeWindow.start : undefined,
+        end: intent === "metric_range" || intent === "health_check" ? timeWindow.end : undefined,
+        step: input.step ?? "5m"
+      }
+    });
+  }
+  steps.push({
+    tool: "mcp__devops-tool__bds_dashboard_links",
+    action: "links",
+    args: {
+      environment: input.environment,
+      alertName: alertName || undefined,
+      source: source || undefined,
+      cluster: cluster || undefined,
+      from: timeWindow.start,
+      to: timeWindow.end,
+      domain: domain?.domain,
+      dashboards: domain?.dashboards
+    }
+  });
+
+  return JSON.stringify({
+    mode: "natural-language-query-pack",
+    provider: "bds-pharos",
+    request: text,
+    parsed: {
+      environment: input.environment,
+      intent,
+      domain: domain?.domain ?? "general",
+      cluster,
+      source,
+      alertName,
+      timeWindow
+    },
+    steps,
+    guidance: [
+      "Execute steps in order until the answer has enough direct evidence.",
+      "Use pharos_prometheus_read for arbitrary BDS PromQL when the planner cannot infer a domain metric.",
+      "Never mutate Pharos from this workflow."
+    ]
+  }, null, 2);
+}
+
+export class BdsPharosQueryPackService {
+  constructor(dependencies = {}) {
+    this.dependencies = dependencies;
+  }
+
+  invoke(input) {
+    return bdsPharosQueryPlan(input, this.dependencies);
+  }
+}
+
+const defaultService = new BdsPharosQueryPackService();
+
+export default defineReadOnlyTool({
+  name: "bds_pharos_query_pack",
+  description: "Create a atomic-helper translation from BDS Pharos investigation fields to read-only Pharos alert, silence, Prometheus, and dashboard tool calls; does not call Pharos.",
+  inputSchema: {
+    request: z.string().trim().min(1).max(2_000),
+    intent: z.enum(["metric_query", "metric_range", "health_check", "firing_alerts", "silence_status", "rule_details", "discover_metrics"]).default("metric_query"),
+    domain: z.enum(domainQueries.map((entry) => entry.domain)).optional(),
+    environment: z.enum(["dev", "prod", "il4"]).default("prod"),
+    cluster: z.string().trim().min(1).max(128).regex(/^[A-Za-z0-9_.:-]+$/).optional(),
+    source: z.string().trim().min(1).max(255).regex(/^[A-Za-z0-9_.:@/-]+$/).optional(),
+    alertName: z.string().trim().min(1).max(200).regex(/^[A-Za-z0-9_.:-]+$/).optional(),
+    start: z.string().trim().min(1).max(80).optional(),
+    end: z.string().trim().min(1).max(80).optional(),
+    step: z.string().trim().min(1).max(40).default("5m")
+  },
+  async handler(input) {
+    try {
+      return ok(defaultService.invoke(input));
+    } catch (error) {
+      return fail(error);
+    }
+  }
+});
+
+export const __test = {
+  BdsPharosQueryPackService,
+  BdsTimeWindowResolver,
+  bdsPharosQueryPlan,
+  domainQueries
+};