postgresai 0.12.0-beta.6 → 0.14.0-dev.7

package/lib/issues.ts

@@ -2,13 +2,62 @@ import * as https from "https";
 import { URL } from "url";
 import { maskSecret, normalizeBaseUrl } from "./util";
 
+export interface IssueActionItem {
+  id: string;
+  issue_id: string;
+  title: string;
+  description: string | null;
+  severity: number;
+  is_done: boolean;
+  done_by: number | null;
+  done_at: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface Issue {
+  id: string;
+  title: string;
+  description: string | null;
+  created_at: string;
+  updated_at: string;
+  status: number;
+  url_main: string | null;
+  urls_extra: string[] | null;
+  data: unknown | null;
+  author_id: number;
+  org_id: number;
+  project_id: number | null;
+  is_ai_generated: boolean;
+  assigned_to: number[] | null;
+  labels: string[] | null;
+  is_edited: boolean;
+  author_display_name: string;
+  comment_count: number;
+  action_items: IssueActionItem[];
+}
+
+export interface IssueComment {
+  id: string;
+  issue_id: string;
+  author_id: number;
+  parent_comment_id: string | null;
+  content: string;
+  created_at: string;
+  updated_at: string;
+  data: unknown | null;
+}
+
+export type IssueListItem = Pick<Issue, "id" | "title" | "status" | "created_at">;
+
+export type IssueDetail = Pick<Issue, "id" | "title" | "description" | "status" | "created_at" | "author_display_name">;
 export interface FetchIssuesParams {
   apiKey: string;
   apiBaseUrl: string;
   debug?: boolean;
 }
 
-export async function fetchIssues(params: FetchIssuesParams): Promise<unknown> {
+export async function fetchIssues(params: FetchIssuesParams): Promise<IssueListItem[]> {
   const { apiKey, apiBaseUrl, debug } = params;
   if (!apiKey) {
     throw new Error("API key is required");
@@ -16,6 +65,7 @@ export async function fetchIssues(params: FetchIssuesParams): Promise<unknown> {
 
   const base = normalizeBaseUrl(apiBaseUrl);
   const url = new URL(`${base}/issues`);
+  url.searchParams.set("select", "id,title,status,created_at");
 
   const headers: Record<string, string> = {
     "access-token": apiKey,
@@ -54,10 +104,10 @@ export async function fetchIssues(params: FetchIssuesParams): Promise<unknown> {
           }
           if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
             try {
-              const parsed = JSON.parse(data);
+              const parsed = JSON.parse(data) as IssueListItem[];
               resolve(parsed);
             } catch {
-              resolve(data);
+              reject(new Error(`Failed to parse issues response: ${data}`));
             }
           } else {
             let errMsg = `Failed to fetch issues: HTTP ${res.statusCode}`;
@@ -81,3 +131,275 @@ export async function fetchIssues(params: FetchIssuesParams): Promise<unknown> {
 }
 
 
+export interface FetchIssueCommentsParams {
+  apiKey: string;
+  apiBaseUrl: string;
+  issueId: string;
+  debug?: boolean;
+}
+
+export async function fetchIssueComments(params: FetchIssueCommentsParams): Promise<IssueComment[]> {
+  const { apiKey, apiBaseUrl, issueId, debug } = params;
+  if (!apiKey) {
+    throw new Error("API key is required");
+  }
+  if (!issueId) {
+    throw new Error("issueId is required");
+  }
+
+  const base = normalizeBaseUrl(apiBaseUrl);
+  const url = new URL(`${base}/issue_comments?issue_id=eq.${encodeURIComponent(issueId)}`);
+
+  const headers: Record<string, string> = {
+    "access-token": apiKey,
+    "Prefer": "return=representation",
+    "Content-Type": "application/json",
+  };
+
+  if (debug) {
+    const debugHeaders: Record<string, string> = { ...headers, "access-token": maskSecret(apiKey) };
+    // eslint-disable-next-line no-console
+    console.log(`Debug: Resolved API base URL: ${base}`);
+    // eslint-disable-next-line no-console
+    console.log(`Debug: GET URL: ${url.toString()}`);
+    // eslint-disable-next-line no-console
+    console.log(`Debug: Auth scheme: access-token`);
+    // eslint-disable-next-line no-console
+    console.log(`Debug: Request headers: ${JSON.stringify(debugHeaders)}`);
+  }
+
+  return new Promise((resolve, reject) => {
+    const req = https.request(
+      url,
+      {
+        method: "GET",
+        headers,
+      },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          if (debug) {
+            // eslint-disable-next-line no-console
+            console.log(`Debug: Response status: ${res.statusCode}`);
+            // eslint-disable-next-line no-console
+            console.log(`Debug: Response headers: ${JSON.stringify(res.headers)}`);
+          }
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            try {
+              const parsed = JSON.parse(data) as IssueComment[];
+              resolve(parsed);
+            } catch {
+              reject(new Error(`Failed to parse issue comments response: ${data}`));
+            }
+          } else {
+            let errMsg = `Failed to fetch issue comments: HTTP ${res.statusCode}`;
+            if (data) {
+              try {
+                const errObj = JSON.parse(data);
+                errMsg += `\n${JSON.stringify(errObj, null, 2)}`;
+              } catch {
+                errMsg += `\n${data}`;
+              }
+            }
+            reject(new Error(errMsg));
+          }
+        });
+      }
+    );
+
+    req.on("error", (err: Error) => reject(err));
+    req.end();
+  });
+}
+
+export interface FetchIssueParams {
+  apiKey: string;
+  apiBaseUrl: string;
+  issueId: string;
+  debug?: boolean;
+}
+
+export async function fetchIssue(params: FetchIssueParams): Promise<IssueDetail | null> {
+  const { apiKey, apiBaseUrl, issueId, debug } = params;
+  if (!apiKey) {
+    throw new Error("API key is required");
+  }
+  if (!issueId) {
+    throw new Error("issueId is required");
+  }
+
+  const base = normalizeBaseUrl(apiBaseUrl);
+  const url = new URL(`${base}/issues`);
+  url.searchParams.set("select", "id,title,description,status,created_at,author_display_name");
+  url.searchParams.set("id", `eq.${issueId}`);
+  url.searchParams.set("limit", "1");
+
+  const headers: Record<string, string> = {
+    "access-token": apiKey,
+    "Prefer": "return=representation",
+    "Content-Type": "application/json",
+  };
+
+  if (debug) {
+    const debugHeaders: Record<string, string> = { ...headers, "access-token": maskSecret(apiKey) };
+    // eslint-disable-next-line no-console
+    console.log(`Debug: Resolved API base URL: ${base}`);
+    // eslint-disable-next-line no-console
+    console.log(`Debug: GET URL: ${url.toString()}`);
+    // eslint-disable-next-line no-console
+    console.log(`Debug: Auth scheme: access-token`);
+    // eslint-disable-next-line no-console
+    console.log(`Debug: Request headers: ${JSON.stringify(debugHeaders)}`);
+  }
+
+  return new Promise((resolve, reject) => {
+    const req = https.request(
+      url,
+      {
+        method: "GET",
+        headers,
+      },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          if (debug) {
+            // eslint-disable-next-line no-console
+            console.log(`Debug: Response status: ${res.statusCode}`);
+            // eslint-disable-next-line no-console
+            console.log(`Debug: Response headers: ${JSON.stringify(res.headers)}`);
+          }
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            try {
+              const parsed = JSON.parse(data);
+              if (Array.isArray(parsed)) {
+                resolve((parsed[0] as IssueDetail) ?? null);
+              } else {
+                resolve(parsed as IssueDetail);
+              }
+            } catch {
+              reject(new Error(`Failed to parse issue response: ${data}`));
+            }
+          } else {
+            let errMsg = `Failed to fetch issue: HTTP ${res.statusCode}`;
+            if (data) {
+              try {
+                const errObj = JSON.parse(data);
+                errMsg += `\n${JSON.stringify(errObj, null, 2)}`;
+              } catch {
+                errMsg += `\n${data}`;
+              }
+            }
+            reject(new Error(errMsg));
+          }
+        });
+      }
+    );
+
+    req.on("error", (err: Error) => reject(err));
+    req.end();
+  });
+}
+
+export interface CreateIssueCommentParams {
+  apiKey: string;
+  apiBaseUrl: string;
+  issueId: string;
+  content: string;
+  parentCommentId?: string;
+  debug?: boolean;
+}
+
+export async function createIssueComment(params: CreateIssueCommentParams): Promise<IssueComment> {
+  const { apiKey, apiBaseUrl, issueId, content, parentCommentId, debug } = params;
+  if (!apiKey) {
+    throw new Error("API key is required");
+  }
+  if (!issueId) {
+    throw new Error("issueId is required");
+  }
+  if (!content) {
+    throw new Error("content is required");
+  }
+
+  const base = normalizeBaseUrl(apiBaseUrl);
+  const url = new URL(`${base}/rpc/issue_comment_create`);
+
+  const bodyObj: Record<string, unknown> = {
+    issue_id: issueId,
+    content: content,
+  };
+  if (parentCommentId) {
+    bodyObj.parent_comment_id = parentCommentId;
+  }
+  const body = JSON.stringify(bodyObj);
+
+  const headers: Record<string, string> = {
+    "access-token": apiKey,
+    "Prefer": "return=representation",
+    "Content-Type": "application/json",
+    "Content-Length": Buffer.byteLength(body).toString(),
+  };
+
+  if (debug) {
+    const debugHeaders: Record<string, string> = { ...headers, "access-token": maskSecret(apiKey) };
+    // eslint-disable-next-line no-console
+    console.log(`Debug: Resolved API base URL: ${base}`);
+    // eslint-disable-next-line no-console
+    console.log(`Debug: POST URL: ${url.toString()}`);
+    // eslint-disable-next-line no-console
+    console.log(`Debug: Auth scheme: access-token`);
+    // eslint-disable-next-line no-console
+    console.log(`Debug: Request headers: ${JSON.stringify(debugHeaders)}`);
+    // eslint-disable-next-line no-console
+    console.log(`Debug: Request body: ${body}`);
+  }
+
+  return new Promise((resolve, reject) => {
+    const req = https.request(
+      url,
+      {
+        method: "POST",
+        headers,
+      },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          if (debug) {
+            // eslint-disable-next-line no-console
+            console.log(`Debug: Response status: ${res.statusCode}`);
+            // eslint-disable-next-line no-console
+            console.log(`Debug: Response headers: ${JSON.stringify(res.headers)}`);
+          }
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            try {
+              const parsed = JSON.parse(data) as IssueComment;
+              resolve(parsed);
+            } catch {
+              reject(new Error(`Failed to parse create comment response: ${data}`));
+            }
+          } else {
+            let errMsg = `Failed to create issue comment: HTTP ${res.statusCode}`;
+            if (data) {
+              try {
+                const errObj = JSON.parse(data);
+                errMsg += `\n${JSON.stringify(errObj, null, 2)}`;
+              } catch {
+                errMsg += `\n${data}`;
+              }
+            }
+            reject(new Error(errMsg));
+          }
+        });
+      }
+    );
+
+    req.on("error", (err: Error) => reject(err));
+    req.write(body);
+    req.end();
+  });
+}
+
+

package/lib/mcp-server.ts

@@ -1,6 +1,6 @@
 import * as pkg from "../package.json";
 import * as config from "./config";
-import { fetchIssues } from "./issues";
+import { fetchIssues, fetchIssueComments, createIssueComment, fetchIssue } from "./issues";
 import { resolveBaseUrls } from "./util";
 
 // MCP SDK imports
@@ -29,6 +29,16 @@ export async function startMcpServer(rootOpts?: RootOptsLike, extra?: { debug?:
     { 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: [
@@ -43,6 +53,34 @@ export async function startMcpServer(rootOpts?: RootOptsLike, extra?: { debug?:
             additionalProperties: false,
           },
         },
+        {
+          name: "view_issue",
+          description: "View a specific issue with its comments",
+          inputSchema: {
+            type: "object",
+            properties: {
+              issue_id: { type: "string", description: "Issue ID (UUID)" },
+              debug: { type: "boolean", description: "Enable verbose debug logs" },
+            },
+            required: ["issue_id"],
+            additionalProperties: false,
+          },
+        },
+        {
+          name: "post_issue_comment",
+          description: "Post a new comment to an issue (optionally as a reply)",
+          inputSchema: {
+            type: "object",
+            properties: {
+              issue_id: { type: "string", description: "Issue ID (UUID)" },
+              content: { type: "string", description: "Comment text (supports \\n as newline)" },
+              parent_comment_id: { type: "string", description: "Parent comment ID (UUID) for replies" },
+              debug: { type: "boolean", description: "Enable verbose debug logs" },
+            },
+            required: ["issue_id", "content"],
+            additionalProperties: false,
+          },
+        },
       ],
     };
   });
@@ -51,10 +89,6 @@ export async function startMcpServer(rootOpts?: RootOptsLike, extra?: { debug?:
     const toolName = req.params.name;
     const args = (req.params.arguments as Record<string, unknown>) || {};
 
-    if (toolName !== "list_issues") {
-      throw new Error(`Unknown tool: ${toolName}`);
-    }
-
     const cfg = config.readConfig();
     const apiKey = (rootOpts?.apiKey || process.env.PGAI_API_KEY || cfg.apiKey || "").toString();
     const { apiBaseUrl } = resolveBaseUrls(rootOpts, cfg);
@@ -74,20 +108,44 @@ export async function startMcpServer(rootOpts?: RootOptsLike, extra?: { debug?:
     }
 
     try {
-      const result = await fetchIssues({ apiKey, apiBaseUrl, debug });
-      return {
-        content: [
-          { type: "text", text: JSON.stringify(result, null, 2) },
-        ],
-      };
+      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 { content: [{ type: "text", text: message }], isError: true };
     }
   });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postgresai",
-  "version": "0.12.0-beta.6",
+  "version": "0.14.0-dev.7",
   "description": "postgres_ai CLI (Node.js)",
   "license": "Apache-2.0",
   "private": false,
@@ -25,7 +25,8 @@
     "build": "tsc",
     "prepare": "npm run build",
     "start": "node ./dist/bin/postgres-ai.js --help",
-    "dev": "tsc --watch"
+    "dev": "tsc --watch",
+    "test": "npm run build && node --test test/*.test.cjs"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.20.2",