postgresai 0.14.0-dev.55 → 0.14.0-dev.57

package/lib/issues.ts

@@ -1,5 +1,16 @@
 import { formatHttpError, maskSecret, normalizeBaseUrl } from "./util";
 
+/**
+ * Issue status constants.
+ * Used in updateIssue to change issue state.
+ */
+export const IssueStatus = {
+  /** Issue is open and active */
+  OPEN: 0,
+  /** Issue is closed/resolved */
+  CLOSED: 1,
+} as const;
+
 export interface IssueActionItem {
   id: string;
   issue_id: string;
@@ -69,6 +80,7 @@ export async function fetchIssues(params: FetchIssuesParams): Promise<IssueListI
     "access-token": apiKey,
     "Prefer": "return=representation",
     "Content-Type": "application/json",
+    "Connection": "close",
   };
 
   if (debug) {
@@ -126,6 +138,7 @@ export async function fetchIssueComments(params: FetchIssueCommentsParams): Prom
     "access-token": apiKey,
     "Prefer": "return=representation",
     "Content-Type": "application/json",
+    "Connection": "close",
   };
 
   if (debug) {
@@ -185,6 +198,7 @@ export async function fetchIssue(params: FetchIssueParams): Promise<IssueDetail
     "access-token": apiKey,
     "Prefer": "return=representation",
     "Content-Type": "application/json",
+    "Connection": "close",
   };
 
   if (debug) {
@@ -223,6 +237,112 @@ export async function fetchIssue(params: FetchIssueParams): Promise<IssueDetail
   }
 }
 
+export interface CreateIssueParams {
+  apiKey: string;
+  apiBaseUrl: string;
+  title: string;
+  orgId: number;
+  description?: string;
+  projectId?: number;
+  labels?: string[];
+  debug?: boolean;
+}
+
+export interface CreatedIssue {
+  id: string;
+  title: string;
+  description: string | null;
+  created_at: string;
+  status: number;
+  project_id: number | null;
+  labels: string[] | null;
+}
+
+/**
+ * Create a new issue in the PostgresAI platform.
+ *
+ * @param params - The parameters for creating an issue
+ * @param params.apiKey - API key for authentication
+ * @param params.apiBaseUrl - Base URL for the API
+ * @param params.title - Issue title (required)
+ * @param params.orgId - Organization ID (required)
+ * @param params.description - Optional issue description
+ * @param params.projectId - Optional project ID to associate with
+ * @param params.labels - Optional array of label strings
+ * @param params.debug - Enable debug logging
+ * @returns The created issue object
+ * @throws Error if API key, title, or orgId is missing, or if the API call fails
+ */
+export async function createIssue(params: CreateIssueParams): Promise<CreatedIssue> {
+  const { apiKey, apiBaseUrl, title, orgId, description, projectId, labels, debug } = params;
+  if (!apiKey) {
+    throw new Error("API key is required");
+  }
+  if (!title) {
+    throw new Error("title is required");
+  }
+  if (typeof orgId !== "number") {
+    throw new Error("orgId is required");
+  }
+
+  const base = normalizeBaseUrl(apiBaseUrl);
+  const url = new URL(`${base}/rpc/issue_create`);
+
+  const bodyObj: Record<string, unknown> = {
+    title: title,
+    org_id: orgId,
+  };
+  if (description !== undefined) {
+    bodyObj.description = description;
+  }
+  if (projectId !== undefined) {
+    bodyObj.project_id = projectId;
+  }
+  if (labels && labels.length > 0) {
+    bodyObj.labels = labels;
+  }
+  const body = JSON.stringify(bodyObj);
+
+  const headers: Record<string, string> = {
+    "access-token": apiKey,
+    "Prefer": "return=representation",
+    "Content-Type": "application/json",
+    "Connection": "close",
+  };
+
+  if (debug) {
+    const debugHeaders: Record<string, string> = { ...headers, "access-token": maskSecret(apiKey) };
+    console.log(`Debug: Resolved API base URL: ${base}`);
+    console.log(`Debug: POST URL: ${url.toString()}`);
+    console.log(`Debug: Auth scheme: access-token`);
+    console.log(`Debug: Request headers: ${JSON.stringify(debugHeaders)}`);
+    console.log(`Debug: Request body: ${body}`);
+  }
+
+  const response = await fetch(url.toString(), {
+    method: "POST",
+    headers,
+    body,
+  });
+
+  if (debug) {
+    console.log(`Debug: Response status: ${response.status}`);
+    console.log(`Debug: Response headers: ${JSON.stringify(Object.fromEntries(response.headers.entries()))}`);
+  }
+
+  const data = await response.text();
+
+  if (response.ok) {
+    try {
+      return JSON.parse(data) as CreatedIssue;
+    } catch {
+      throw new Error(`Failed to parse create issue response: ${data}`);
+    }
+  } else {
+    throw new Error(formatHttpError("Failed to create issue", response.status, data));
+  }
+}
+
 export interface CreateIssueCommentParams {
   apiKey: string;
   apiBaseUrl: string;
@@ -260,6 +380,7 @@ export async function createIssueComment(params: CreateIssueCommentParams): Prom
     "access-token": apiKey,
     "Prefer": "return=representation",
     "Content-Type": "application/json",
+    "Connection": "close",
   };
 
   if (debug) {
@@ -294,3 +415,200 @@ export async function createIssueComment(params: CreateIssueCommentParams): Prom
     throw new Error(formatHttpError("Failed to create issue comment", response.status, data));
   }
 }
+
+export interface UpdateIssueParams {
+  apiKey: string;
+  apiBaseUrl: string;
+  issueId: string;
+  title?: string;
+  description?: string;
+  status?: number;
+  labels?: string[];
+  debug?: boolean;
+}
+
+export interface UpdatedIssue {
+  id: string;
+  title: string;
+  description: string | null;
+  status: number;
+  updated_at: string;
+  labels: string[] | null;
+}
+
+/**
+ * Update an existing issue in the PostgresAI platform.
+ *
+ * @param params - The parameters for updating an issue
+ * @param params.apiKey - API key for authentication
+ * @param params.apiBaseUrl - Base URL for the API
+ * @param params.issueId - ID of the issue to update (required)
+ * @param params.title - New title (optional)
+ * @param params.description - New description (optional)
+ * @param params.status - New status: 0 = open, 1 = closed (optional)
+ * @param params.labels - New labels array (optional, replaces existing)
+ * @param params.debug - Enable debug logging
+ * @returns The updated issue object
+ * @throws Error if API key or issueId is missing, if no fields to update are provided, or if the API call fails
+ */
+export async function updateIssue(params: UpdateIssueParams): Promise<UpdatedIssue> {
+  const { apiKey, apiBaseUrl, issueId, title, description, status, labels, debug } = params;
+  if (!apiKey) {
+    throw new Error("API key is required");
+  }
+  if (!issueId) {
+    throw new Error("issueId is required");
+  }
+  if (title === undefined && description === undefined && status === undefined && labels === undefined) {
+    throw new Error("At least one field to update is required (title, description, status, or labels)");
+  }
+
+  const base = normalizeBaseUrl(apiBaseUrl);
+  const url = new URL(`${base}/rpc/issue_update`);
+
+  // Prod RPC expects p_* argument names (see OpenAPI at /api/general/).
+  const bodyObj: Record<string, unknown> = {
+    p_id: issueId,
+  };
+  if (title !== undefined) {
+    bodyObj.p_title = title;
+  }
+  if (description !== undefined) {
+    bodyObj.p_description = description;
+  }
+  if (status !== undefined) {
+    bodyObj.p_status = status;
+  }
+  if (labels !== undefined) {
+    bodyObj.p_labels = labels;
+  }
+  const body = JSON.stringify(bodyObj);
+
+  const headers: Record<string, string> = {
+    "access-token": apiKey,
+    "Prefer": "return=representation",
+    "Content-Type": "application/json",
+    "Connection": "close",
+  };
+
+  if (debug) {
+    const debugHeaders: Record<string, string> = { ...headers, "access-token": maskSecret(apiKey) };
+    console.log(`Debug: Resolved API base URL: ${base}`);
+    console.log(`Debug: POST URL: ${url.toString()}`);
+    console.log(`Debug: Auth scheme: access-token`);
+    console.log(`Debug: Request headers: ${JSON.stringify(debugHeaders)}`);
+    console.log(`Debug: Request body: ${body}`);
+  }
+
+  const response = await fetch(url.toString(), {
+    method: "POST",
+    headers,
+    body,
+  });
+
+  if (debug) {
+    console.log(`Debug: Response status: ${response.status}`);
+    console.log(`Debug: Response headers: ${JSON.stringify(Object.fromEntries(response.headers.entries()))}`);
+  }
+
+  const data = await response.text();
+
+  if (response.ok) {
+    try {
+      return JSON.parse(data) as UpdatedIssue;
+    } catch {
+      throw new Error(`Failed to parse update issue response: ${data}`);
+    }
+  } else {
+    throw new Error(formatHttpError("Failed to update issue", response.status, data));
+  }
+}
+
+export interface UpdateIssueCommentParams {
+  apiKey: string;
+  apiBaseUrl: string;
+  commentId: string;
+  content: string;
+  debug?: boolean;
+}
+
+export interface UpdatedIssueComment {
+  id: string;
+  issue_id: string;
+  content: string;
+  updated_at: string;
+}
+
+/**
+ * Update an existing issue comment in the PostgresAI platform.
+ *
+ * @param params - The parameters for updating a comment
+ * @param params.apiKey - API key for authentication
+ * @param params.apiBaseUrl - Base URL for the API
+ * @param params.commentId - ID of the comment to update (required)
+ * @param params.content - New comment content (required)
+ * @param params.debug - Enable debug logging
+ * @returns The updated comment object
+ * @throws Error if API key, commentId, or content is missing, or if the API call fails
+ */
+export async function updateIssueComment(params: UpdateIssueCommentParams): Promise<UpdatedIssueComment> {
+  const { apiKey, apiBaseUrl, commentId, content, debug } = params;
+  if (!apiKey) {
+    throw new Error("API key is required");
+  }
+  if (!commentId) {
+    throw new Error("commentId is required");
+  }
+  if (!content) {
+    throw new Error("content is required");
+  }
+
+  const base = normalizeBaseUrl(apiBaseUrl);
+  const url = new URL(`${base}/rpc/issue_comment_update`);
+
+  const bodyObj: Record<string, unknown> = {
+    // Prod RPC expects p_* argument names (see OpenAPI at /api/general/).
+    p_id: commentId,
+    p_content: content,
+  };
+  const body = JSON.stringify(bodyObj);
+
+  const headers: Record<string, string> = {
+    "access-token": apiKey,
+    "Prefer": "return=representation",
+    "Content-Type": "application/json",
+    "Connection": "close",
+  };
+
+  if (debug) {
+    const debugHeaders: Record<string, string> = { ...headers, "access-token": maskSecret(apiKey) };
+    console.log(`Debug: Resolved API base URL: ${base}`);
+    console.log(`Debug: POST URL: ${url.toString()}`);
+    console.log(`Debug: Auth scheme: access-token`);
+    console.log(`Debug: Request headers: ${JSON.stringify(debugHeaders)}`);
+    console.log(`Debug: Request body: ${body}`);
+  }
+
+  const response = await fetch(url.toString(), {
+    method: "POST",
+    headers,
+    body,
+  });
+
+  if (debug) {
+    console.log(`Debug: Response status: ${response.status}`);
+    console.log(`Debug: Response headers: ${JSON.stringify(Object.fromEntries(response.headers.entries()))}`);
+  }
+
+  const data = await response.text();
+
+  if (response.ok) {
+    try {
+      return JSON.parse(data) as UpdatedIssueComment;
+    } catch {
+      throw new Error(`Failed to parse update comment response: ${data}`);
+    }
+  } else {
+    throw new Error(formatHttpError("Failed to update issue comment", response.status, data));
+  }
+}

package/lib/mcp-server.ts

@@ -1,6 +1,6 @@
 import pkg from "../package.json";
 import * as config from "./config";
-import { fetchIssues, fetchIssueComments, createIssueComment, fetchIssue } from "./issues";
+import { fetchIssues, fetchIssueComments, createIssueComment, fetchIssue, createIssue, updateIssue, updateIssueComment } from "./issues";
 import { resolveBaseUrls } from "./util";
 
 // MCP SDK imports - Bun handles these directly
@@ -8,27 +8,165 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 
-interface RootOptsLike {
+export interface RootOptsLike {
   apiKey?: string;
   apiBaseUrl?: string;
 }
 
+// Interpret escape sequences (e.g., \n -> newline). Input comes from JSON, but
+// we still normalize common escapes for consistency.
+export const interpretEscapes = (str: string): string =>
+  (str || "")
+    .replace(/\\n/g, "\n")
+    .replace(/\\t/g, "\t")
+    .replace(/\\r/g, "\r")
+    .replace(/\\"/g, '"')
+    .replace(/\\'/g, "'");
+
+export interface McpToolRequest {
+  params: {
+    name: string;
+    arguments?: Record<string, unknown>;
+  };
+}
+
+export interface McpToolResponse {
+  content: Array<{ type: string; text: string }>;
+  isError?: boolean;
+}
+
+/** Handle MCP tool calls - exported for testing */
+export async function handleToolCall(
+  req: McpToolRequest,
+  rootOpts?: RootOptsLike,
+  extra?: { debug?: boolean }
+): Promise<McpToolResponse> {
+  const toolName = req.params.name;
+  const args = (req.params.arguments as Record<string, unknown>) || {};
+
+  const cfg = config.readConfig();
+  const apiKey = (rootOpts?.apiKey || process.env.PGAI_API_KEY || cfg.apiKey || "").toString();
+  const { apiBaseUrl } = resolveBaseUrls(rootOpts, cfg);
+
+  const debug = Boolean(args.debug ?? extra?.debug);
+
+  if (!apiKey) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: "API key is required. Run 'pgai auth' or set PGAI_API_KEY.",
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  try {
+    if (toolName === "list_issues") {
+      const issues = await fetchIssues({ apiKey, apiBaseUrl, debug });
+      return { content: [{ type: "text", text: JSON.stringify(issues, null, 2) }] };
+    }
+
+    if (toolName === "view_issue") {
+      const issueId = String(args.issue_id || "").trim();
+      if (!issueId) {
+        return { content: [{ type: "text", text: "issue_id is required" }], isError: true };
+      }
+      const issue = await fetchIssue({ apiKey, apiBaseUrl, issueId, debug });
+      if (!issue) {
+        return { content: [{ type: "text", text: "Issue not found" }], isError: true };
+      }
+      const comments = await fetchIssueComments({ apiKey, apiBaseUrl, issueId, debug });
+      const combined = { issue, comments };
+      return { content: [{ type: "text", text: JSON.stringify(combined, null, 2) }] };
+    }
+
+    if (toolName === "post_issue_comment") {
+      const issueId = String(args.issue_id || "").trim();
+      const rawContent = String(args.content || "");
+      const parentCommentId = args.parent_comment_id ? String(args.parent_comment_id) : undefined;
+      if (!issueId) {
+        return { content: [{ type: "text", text: "issue_id is required" }], isError: true };
+      }
+      if (!rawContent) {
+        return { content: [{ type: "text", text: "content is required" }], isError: true };
+      }
+      const content = interpretEscapes(rawContent);
+      const result = await createIssueComment({ apiKey, apiBaseUrl, issueId, content, parentCommentId, debug });
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+
+    if (toolName === "create_issue") {
+      const rawTitle = String(args.title || "").trim();
+      if (!rawTitle) {
+        return { content: [{ type: "text", text: "title is required" }], isError: true };
+      }
+      const title = interpretEscapes(rawTitle);
+      const rawDescription = args.description ? String(args.description) : undefined;
+      const description = rawDescription ? interpretEscapes(rawDescription) : undefined;
+      const projectId = args.project_id !== undefined ? Number(args.project_id) : undefined;
+      const labels = Array.isArray(args.labels) ? args.labels.map(String) : undefined;
+      // Get orgId from args or fall back to config
+      const orgId = args.org_id !== undefined ? Number(args.org_id) : cfg.orgId;
+      // Note: orgId=0 is technically valid (though unlikely), so don't use falsy check
+      if (orgId === undefined || orgId === null || Number.isNaN(orgId)) {
+        return { content: [{ type: "text", text: "org_id is required. Either provide it as a parameter or run 'pgai auth' to set it in config." }], isError: true };
+      }
+      const result = await createIssue({ apiKey, apiBaseUrl, title, orgId, description, projectId, labels, debug });
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+
+    if (toolName === "update_issue") {
+      const issueId = String(args.issue_id || "").trim();
+      if (!issueId) {
+        return { content: [{ type: "text", text: "issue_id is required" }], isError: true };
+      }
+      const rawTitle = args.title !== undefined ? String(args.title) : undefined;
+      const title = rawTitle !== undefined ? interpretEscapes(rawTitle) : undefined;
+      const rawDescription = args.description !== undefined ? String(args.description) : undefined;
+      const description = rawDescription !== undefined ? interpretEscapes(rawDescription) : undefined;
+      const status = args.status !== undefined ? Number(args.status) : undefined;
+      const labels = Array.isArray(args.labels) ? args.labels.map(String) : undefined;
+      // Validate that at least one update field is provided
+      if (title === undefined && description === undefined && status === undefined && labels === undefined) {
+        return { content: [{ type: "text", text: "At least one field to update is required (title, description, status, or labels)" }], isError: true };
+      }
+      // Validate status value if provided (check for NaN and valid values)
+      if (status !== undefined && (Number.isNaN(status) || (status !== 0 && status !== 1))) {
+        return { content: [{ type: "text", text: "status must be 0 (open) or 1 (closed)" }], isError: true };
+      }
+      const result = await updateIssue({ apiKey, apiBaseUrl, issueId, title, description, status, labels, debug });
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+
+    if (toolName === "update_issue_comment") {
+      const commentId = String(args.comment_id || "").trim();
+      const rawContent = String(args.content || "");
+      if (!commentId) {
+        return { content: [{ type: "text", text: "comment_id is required" }], isError: true };
+      }
+      if (!rawContent.trim()) {
+        return { content: [{ type: "text", text: "content is required" }], isError: true };
+      }
+      const content = interpretEscapes(rawContent);
+      const result = await updateIssueComment({ apiKey, apiBaseUrl, commentId, content, debug });
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+
+    throw new Error(`Unknown tool: ${toolName}`);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { content: [{ type: "text", text: message }], isError: true };
+  }
+}
+
 export async function startMcpServer(rootOpts?: RootOptsLike, extra?: { debug?: boolean }): Promise<void> {
   const server = new Server(
     { name: "postgresai-mcp", version: pkg.version },
     { capabilities: { tools: {} } }
   );
 
-  // Interpret escape sequences (e.g., \n -> newline). Input comes from JSON, but
-  // we still normalize common escapes for consistency.
-  const interpretEscapes = (str: string): string =>
-    (str || "")
-      .replace(/\\n/g, "\n")
-      .replace(/\\t/g, "\t")
-      .replace(/\\r/g, "\r")
-      .replace(/\\"/g, '"')
-      .replace(/\\'/g, "'");
-
   server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {
       tools: [
@@ -71,73 +209,69 @@ export async function startMcpServer(rootOpts?: RootOptsLike, extra?: { debug?:
             additionalProperties: false,
           },
         },
+        {
+          name: "create_issue",
+          description: "Create a new issue in PostgresAI",
+          inputSchema: {
+            type: "object",
+            properties: {
+              title: { type: "string", description: "Issue title (required)" },
+              description: { type: "string", description: "Issue description (supports \\n as newline)" },
+              org_id: { type: "number", description: "Organization ID (uses config value if not provided)" },
+              project_id: { type: "number", description: "Project ID to associate the issue with" },
+              labels: {
+                type: "array",
+                items: { type: "string" },
+                description: "Labels to apply to the issue",
+              },
+              debug: { type: "boolean", description: "Enable verbose debug logs" },
+            },
+            required: ["title"],
+            additionalProperties: false,
+          },
+        },
+        {
+          name: "update_issue",
+          description: "Update an existing issue (title, description, status, labels). Use status=1 to close, status=0 to reopen.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              issue_id: { type: "string", description: "Issue ID (UUID)" },
+              title: { type: "string", description: "New title (supports \\n as newline)" },
+              description: { type: "string", description: "New description (supports \\n as newline)" },
+              status: { type: "number", description: "Status: 0=open, 1=closed" },
+              labels: {
+                type: "array",
+                items: { type: "string" },
+                description: "Labels to set on the issue",
+              },
+              debug: { type: "boolean", description: "Enable verbose debug logs" },
+            },
+            required: ["issue_id"],
+            additionalProperties: false,
+          },
+        },
+        {
+          name: "update_issue_comment",
+          description: "Update an existing issue comment",
+          inputSchema: {
+            type: "object",
+            properties: {
+              comment_id: { type: "string", description: "Comment ID (UUID)" },
+              content: { type: "string", description: "New comment text (supports \\n as newline)" },
+              debug: { type: "boolean", description: "Enable verbose debug logs" },
+            },
+            required: ["comment_id", "content"],
+            additionalProperties: false,
+          },
+        },
       ],
     };
   });
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   server.setRequestHandler(CallToolRequestSchema, async (req: any) => {
-    const toolName = req.params.name;
-    const args = (req.params.arguments as Record<string, unknown>) || {};
-
-    const cfg = config.readConfig();
-    const apiKey = (rootOpts?.apiKey || process.env.PGAI_API_KEY || cfg.apiKey || "").toString();
-    const { apiBaseUrl } = resolveBaseUrls(rootOpts, cfg);
-
-    const debug = Boolean(args.debug ?? extra?.debug);
-
-    if (!apiKey) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: "API key is required. Run 'pgai auth' or set PGAI_API_KEY.",
-          },
-        ],
-        isError: true,
-      };
-    }
-
-    try {
-      if (toolName === "list_issues") {
-        const issues = await fetchIssues({ apiKey, apiBaseUrl, debug });
-        return { content: [{ type: "text", text: JSON.stringify(issues, null, 2) }] };
-      }
-
-      if (toolName === "view_issue") {
-        const issueId = String(args.issue_id || "").trim();
-        if (!issueId) {
-          return { content: [{ type: "text", text: "issue_id is required" }], isError: true };
-        }
-        const issue = await fetchIssue({ apiKey, apiBaseUrl, issueId, debug });
-        if (!issue) {
-          return { content: [{ type: "text", text: "Issue not found" }], isError: true };
-        }
-        const comments = await fetchIssueComments({ apiKey, apiBaseUrl, issueId, debug });
-        const combined = { issue, comments };
-        return { content: [{ type: "text", text: JSON.stringify(combined, null, 2) }] };
-      }
-
-      if (toolName === "post_issue_comment") {
-        const issueId = String(args.issue_id || "").trim();
-        const rawContent = String(args.content || "");
-        const parentCommentId = args.parent_comment_id ? String(args.parent_comment_id) : undefined;
-        if (!issueId) {
-          return { content: [{ type: "text", text: "issue_id is required" }], isError: true };
-        }
-        if (!rawContent) {
-          return { content: [{ type: "text", text: "content is required" }], isError: true };
-        }
-        const content = interpretEscapes(rawContent);
-        const result = await createIssueComment({ apiKey, apiBaseUrl, issueId, content, parentCommentId, debug });
-        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-      }
-
-      throw new Error(`Unknown tool: ${toolName}`);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return { content: [{ type: "text", text: message }], isError: true };
-    }
+    return handleToolCall(req, rootOpts, extra);
   });
 
   const transport = new StdioServerTransport();

package/lib/metrics-embedded.ts

@@ -1,6 +1,6 @@
 // AUTO-GENERATED FILE - DO NOT EDIT
 // Generated from config/pgwatch-prometheus/metrics.yml by scripts/embed-metrics.ts
-// Generated at: 2025-12-29T17:55:05.936Z
+// Generated at: 2025-12-29T21:47:36.417Z
 
 /**
  * Metric definition from metrics.yml
@@ -47,7 +47,7 @@ export const METRICS: Record<string, MetricDefinition> = {
   "pg_invalid_indexes": {
     description: "This metric identifies invalid indexes in the database. It provides insights into the number of invalid indexes and their details. This metric helps administrators identify and fix invalid indexes to improve database performance.",
     sqls: {
-      11: "with fk_indexes as ( /* pgwatch_generated */\n  select\n    schemaname as tag_schema_name,\n    (indexrelid::regclass)::text as tag_index_name,\n    (relid::regclass)::text as tag_table_name,\n    (confrelid::regclass)::text as tag_fk_table_ref,\n    array_to_string(indclass, ', ') as tag_opclasses\n  from\n    pg_stat_all_indexes\n  join pg_index using (indexrelid)\n  left join pg_constraint\n    on array_to_string(indkey, ',') = array_to_string(conkey, ',')\n      and schemaname = (connamespace::regnamespace)::text\n      and conrelid = relid\n      and contype = 'f'\n  where idx_scan = 0\n    and indisunique is false\n    and conkey is not null --conkey is not null then true else false end as is_fk_idx\n), data as (\n  select\n    pci.relname as tag_index_name,\n    pn.nspname as tag_schema_name,\n    pct.relname as tag_table_name,\n    quote_ident(pn.nspname) as tag_schema_name,\n    quote_ident(pci.relname) as tag_index_name,\n    quote_ident(pct.relname) as tag_table_name,\n    coalesce(nullif(quote_ident(pn.nspname), 'public') || '.', '') || quote_ident(pct.relname) as tag_relation_name,\n    pg_relation_size(pidx.indexrelid) index_size_bytes,\n    ((\n      select count(1)\n      from fk_indexes fi\n      where\n        fi.tag_fk_table_ref = pct.relname\n        and fi.tag_opclasses like (array_to_string(pidx.indclass, ', ') || '%')\n    ) > 0)::int as supports_fk\n  from pg_index pidx\n  join pg_class as pci on pci.oid = pidx.indexrelid\n  join pg_class as pct on pct.oid = pidx.indrelid\n  left join pg_namespace pn on pn.oid = pct.relnamespace\n  where pidx.indisvalid = false\n), data_total as (\n    select\n      sum(index_size_bytes) as index_size_bytes_sum\n    from data\n), num_data as (\n  select\n    row_number() over () num,\n    data.*\n  from data\n)\nselect\n  (extract(epoch from now()) * 1e9)::int8 as epoch_ns,\n  current_database() as tag_datname,\n  num_data.*\nfrom num_data\nlimit 1000;\n",
+      11: "with fk_indexes as ( /* pgwatch_generated */\n  select\n    schemaname as tag_schema_name,\n    (indexrelid::regclass)::text as tag_index_name,\n    (relid::regclass)::text as tag_table_name,\n    (confrelid::regclass)::text as tag_fk_table_ref,\n    array_to_string(indclass, ', ') as tag_opclasses\n  from\n    pg_stat_all_indexes\n  join pg_index using (indexrelid)\n  left join pg_constraint\n    on array_to_string(indkey, ',') = array_to_string(conkey, ',')\n      and schemaname = (connamespace::regnamespace)::text\n      and conrelid = relid\n      and contype = 'f'\n  where idx_scan = 0\n    and indisunique is false\n    and conkey is not null --conkey is not null then true else false end as is_fk_idx\n), data as (\n  select\n    pci.relname as tag_index_name,\n    pn.nspname as tag_schema_name,\n    pct.relname as tag_table_name,\n    quote_ident(pn.nspname) as tag_schema_name,\n    quote_ident(pci.relname) as tag_index_name,\n    quote_ident(pct.relname) as tag_table_name,\n    coalesce(nullif(quote_ident(pn.nspname), 'public') || '.', '') || quote_ident(pct.relname) as tag_relation_name,\n    pg_get_indexdef(pidx.indexrelid) as index_definition,\n    pg_relation_size(pidx.indexrelid) index_size_bytes,\n    ((\n      select count(1)\n      from fk_indexes fi\n      where\n        fi.tag_fk_table_ref = pct.relname\n        and fi.tag_opclasses like (array_to_string(pidx.indclass, ', ') || '%')\n    ) > 0)::int as supports_fk\n  from pg_index pidx\n  join pg_class as pci on pci.oid = pidx.indexrelid\n  join pg_class as pct on pct.oid = pidx.indrelid\n  left join pg_namespace pn on pn.oid = pct.relnamespace\n  where pidx.indisvalid = false\n), data_total as (\n    select\n      sum(index_size_bytes) as index_size_bytes_sum\n    from data\n), num_data as (\n  select\n    row_number() over () num,\n    data.*\n  from data\n)\nselect\n  (extract(epoch from now()) * 1e9)::int8 as epoch_ns,\n  current_database() as tag_datname,\n  num_data.*\nfrom num_data\nlimit 1000;\n",
     },
     gauges: ["*"],
     statement_timeout_seconds: 15,