postgresai 0.14.0-dev.43 → 0.14.0-dev.45

package/lib/config.ts

@@ -9,6 +9,7 @@ export interface Config {
   apiKey: string | null;
   baseUrl: string | null;
   orgId: number | null;
+  defaultProject: string | null;
 }
 
 /**
@@ -46,6 +47,7 @@ export function readConfig(): Config {
     apiKey: null,
     baseUrl: null,
     orgId: null,
+    defaultProject: null,
   };
 
   // Try user-level config first
@@ -57,6 +59,7 @@ export function readConfig(): Config {
       config.apiKey = parsed.apiKey || null;
       config.baseUrl = parsed.baseUrl || null;
       config.orgId = parsed.orgId || null;
+      config.defaultProject = parsed.defaultProject || null;
       return config;
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);

package/lib/init.ts

@@ -159,13 +159,21 @@ export type InitPlan = {
   steps: InitStep[];
 };
 
-function packageRootDirFromCompiled(): string {
-  // dist/lib/init.js -> <pkg>/dist/lib ; package root is ../..
-  return path.resolve(__dirname, "..", "..");
-}
-
 function sqlDir(): string {
-  return path.join(packageRootDirFromCompiled(), "sql");
+  // Handle both development and production paths
+  // Development: lib/init.ts -> ../sql
+  // Production (bundled): dist/bin/postgres-ai.js -> ../sql (copied during build)
+  const candidates = [
+    path.resolve(__dirname, "..", "sql"),       // bundled: dist/bin -> dist/sql
+    path.resolve(__dirname, "..", "..", "sql"), // dev from lib: lib -> ../sql
+  ];
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(`SQL directory not found. Searched: ${candidates.join(", ")}`);
 }
 
 function loadSqlTemplate(filename: string): string {
@@ -485,6 +493,12 @@ end $$;`;
     sql: applyTemplate(loadSqlTemplate("02.permissions.sql"), vars),
   });
 
+  // Helper functions (SECURITY DEFINER) for plan analysis and table info
+  steps.push({
+    name: "05.helpers",
+    sql: applyTemplate(loadSqlTemplate("05.helpers.sql"), vars),
+  });
+
   if (params.includeOptionalPermissions) {
     steps.push(
       {
@@ -511,78 +525,70 @@ export async function applyInitPlan(params: {
   const applied: string[] = [];
   const skippedOptional: string[] = [];
 
-  // Apply non-optional steps in a single transaction.
-  await params.client.query("begin;");
-  try {
-    for (const step of params.plan.steps.filter((s) => !s.optional)) {
+  // Helper to wrap a step execution in begin/commit
+  const executeStep = async (step: InitStep): Promise<void> => {
+    await params.client.query("begin;");
+    try {
+      await params.client.query(step.sql, step.params as any);
+      await params.client.query("commit;");
+    } catch (e) {
+      // Rollback errors should never mask the original failure.
       try {
-        await params.client.query(step.sql, step.params as any);
-        applied.push(step.name);
-      } catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
-        const errAny = e as any;
-        const wrapped: any = new Error(`Failed at step "${step.name}": ${msg}`);
-        // Preserve useful Postgres error fields so callers can provide better hints / diagnostics.
-        const pgErrorFields = [
-          "code",
-          "detail",
-          "hint",
-          "position",
-          "internalPosition",
-          "internalQuery",
-          "where",
-          "schema",
-          "table",
-          "column",
-          "dataType",
-          "constraint",
-          "file",
-          "line",
-          "routine",
-        ] as const;
-        if (errAny && typeof errAny === "object") {
-          for (const field of pgErrorFields) {
-            if (errAny[field] !== undefined) wrapped[field] = errAny[field];
-          }
-        }
-        if (e instanceof Error && e.stack) {
-          wrapped.stack = e.stack;
-        }
-        throw wrapped;
+        await params.client.query("rollback;");
+      } catch {
+        // ignore
       }
+      throw e;
     }
-    await params.client.query("commit;");
-  } catch (e) {
-    // Rollback errors should never mask the original failure.
+  };
+
+  // Apply non-optional steps, each in its own transaction
+  for (const step of params.plan.steps.filter((s) => !s.optional)) {
     try {
-      await params.client.query("rollback;");
-    } catch {
-      // ignore
+      await executeStep(step);
+      applied.push(step.name);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      const errAny = e as any;
+      const wrapped: any = new Error(`Failed at step "${step.name}": ${msg}`);
+      // Preserve useful Postgres error fields so callers can provide better hints / diagnostics.
+      const pgErrorFields = [
+        "code",
+        "detail",
+        "hint",
+        "position",
+        "internalPosition",
+        "internalQuery",
+        "where",
+        "schema",
+        "table",
+        "column",
+        "dataType",
+        "constraint",
+        "file",
+        "line",
+        "routine",
+      ] as const;
+      if (errAny && typeof errAny === "object") {
+        for (const field of pgErrorFields) {
+          if (errAny[field] !== undefined) wrapped[field] = errAny[field];
+        }
+      }
+      if (e instanceof Error && e.stack) {
+        wrapped.stack = e.stack;
+      }
+      throw wrapped;
     }
-    throw e;
   }
 
-  // Apply optional steps outside of the transaction so a failure doesn't abort everything.
+  // Apply optional steps, each in its own transaction (failure doesn't abort)
   for (const step of params.plan.steps.filter((s) => s.optional)) {
     try {
-      // Run each optional step in its own mini-transaction to avoid partial application.
-      await params.client.query("begin;");
-      try {
-        await params.client.query(step.sql, step.params as any);
-        await params.client.query("commit;");
-        applied.push(step.name);
-      } catch {
-        try {
-          await params.client.query("rollback;");
-        } catch {
-          // ignore rollback errors
-        }
-        skippedOptional.push(step.name);
-        // best-effort: ignore
-      }
+      await executeStep(step);
+      applied.push(step.name);
     } catch {
-      // If we can't even begin/commit, treat as skipped.
       skippedOptional.push(step.name);
+      // best-effort: ignore
     }
   }
 
@@ -642,16 +648,25 @@ export async function verifyInitSetup(params: {
       missingRequired.push("SELECT on pg_catalog.pg_index");
     }
 
-    const viewExistsRes = await params.client.query("select to_regclass('public.pg_statistic') is not null as ok");
+    // Check postgres_ai schema exists and is usable
+    const schemaExistsRes = await params.client.query(
+      "select has_schema_privilege($1, 'postgres_ai', 'USAGE') as ok",
+      [role]
+    );
+    if (!schemaExistsRes.rows?.[0]?.ok) {
+      missingRequired.push("USAGE on schema postgres_ai");
+    }
+
+    const viewExistsRes = await params.client.query("select to_regclass('postgres_ai.pg_statistic') is not null as ok");
     if (!viewExistsRes.rows?.[0]?.ok) {
-      missingRequired.push("view public.pg_statistic exists");
+      missingRequired.push("view postgres_ai.pg_statistic exists");
     } else {
       const viewPrivRes = await params.client.query(
-        "select has_table_privilege($1, 'public.pg_statistic', 'SELECT') as ok",
+        "select has_table_privilege($1, 'postgres_ai.pg_statistic', 'SELECT') as ok",
         [role]
       );
       if (!viewPrivRes.rows?.[0]?.ok) {
-        missingRequired.push("SELECT on view public.pg_statistic");
+        missingRequired.push("SELECT on view postgres_ai.pg_statistic");
       }
     }
 
@@ -669,13 +684,30 @@ export async function verifyInitSetup(params: {
     if (typeof spLine !== "string" || !spLine) {
       missingRequired.push("role search_path is set");
     } else {
-      // We accept any ordering as long as public and pg_catalog are included.
+      // We accept any ordering as long as postgres_ai, public, and pg_catalog are included.
       const sp = spLine.toLowerCase();
-      if (!sp.includes("public") || !sp.includes("pg_catalog")) {
-        missingRequired.push("role search_path includes public and pg_catalog");
+      if (!sp.includes("postgres_ai") || !sp.includes("public") || !sp.includes("pg_catalog")) {
+        missingRequired.push("role search_path includes postgres_ai, public and pg_catalog");
       }
     }
 
+    // Check for helper functions
+    const explainFnRes = await params.client.query(
+      "select has_function_privilege($1, 'postgres_ai.explain_generic(text, text, text)', 'EXECUTE') as ok",
+      [role]
+    );
+    if (!explainFnRes.rows?.[0]?.ok) {
+      missingRequired.push("EXECUTE on postgres_ai.explain_generic(text, text, text)");
+    }
+
+    const tableDescribeFnRes = await params.client.query(
+      "select has_function_privilege($1, 'postgres_ai.table_describe(text)', 'EXECUTE') as ok",
+      [role]
+    );
+    if (!tableDescribeFnRes.rows?.[0]?.ok) {
+      missingRequired.push("EXECUTE on postgres_ai.table_describe(text)");
+    }
+
     if (params.includeOptionalPermissions) {
       // Optional RDS/Aurora extras
       {

package/lib/issues.ts

@@ -1,5 +1,3 @@
-import * as https from "https";
-import { URL } from "url";
 import { maskSecret, normalizeBaseUrl } from "./util";
 
 export interface IssueActionItem {
@@ -75,59 +73,42 @@ export async function fetchIssues(params: FetchIssuesParams): Promise<IssueListI
 
   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 IssueListItem[];
-              resolve(parsed);
-            } catch {
-              reject(new Error(`Failed to parse issues response: ${data}`));
-            }
-          } else {
-            let errMsg = `Failed to fetch issues: 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();
+  const response = await fetch(url.toString(), {
+    method: "GET",
+    headers,
   });
+
+  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 IssueListItem[];
+    } catch {
+      throw new Error(`Failed to parse issues response: ${data}`);
+    }
+  } else {
+    let errMsg = `Failed to fetch issues: HTTP ${response.status}`;
+    if (data) {
+      try {
+        const errObj = JSON.parse(data);
+        errMsg += `\n${JSON.stringify(errObj, null, 2)}`;
+      } catch {
+        errMsg += `\n${data}`;
+      }
+    }
+    throw new Error(errMsg);
+  }
 }
 
 
@@ -158,59 +139,42 @@ export async function fetchIssueComments(params: FetchIssueCommentsParams): Prom
 
   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();
+  const response = await fetch(url.toString(), {
+    method: "GET",
+    headers,
   });
+
+  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 IssueComment[];
+    } catch {
+      throw new Error(`Failed to parse issue comments response: ${data}`);
+    }
+  } else {
+    let errMsg = `Failed to fetch issue comments: HTTP ${response.status}`;
+    if (data) {
+      try {
+        const errObj = JSON.parse(data);
+        errMsg += `\n${JSON.stringify(errObj, null, 2)}`;
+      } catch {
+        errMsg += `\n${data}`;
+      }
+    }
+    throw new Error(errMsg);
+  }
 }
 
 export interface FetchIssueParams {
@@ -243,63 +207,47 @@ export async function fetchIssue(params: FetchIssueParams): Promise<IssueDetail
 
   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();
+  const response = await fetch(url.toString(), {
+    method: "GET",
+    headers,
   });
+
+  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 {
+      const parsed = JSON.parse(data);
+      if (Array.isArray(parsed)) {
+        return (parsed[0] as IssueDetail) ?? null;
+      } else {
+        return parsed as IssueDetail;
+      }
+    } catch {
+      throw new Error(`Failed to parse issue response: ${data}`);
+    }
+  } else {
+    let errMsg = `Failed to fetch issue: HTTP ${response.status}`;
+    if (data) {
+      try {
+        const errObj = JSON.parse(data);
+        errMsg += `\n${JSON.stringify(errObj, null, 2)}`;
+      } catch {
+        errMsg += `\n${data}`;
+      }
+    }
+    throw new Error(errMsg);
+  }
 }
 
 export interface CreateIssueCommentParams {
@@ -339,67 +287,46 @@ export async function createIssueComment(params: CreateIssueCommentParams): Prom
     "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();
+  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 IssueComment;
+    } catch {
+      throw new Error(`Failed to parse create comment response: ${data}`);
+    }
+  } else {
+    let errMsg = `Failed to create issue comment: HTTP ${response.status}`;
+    if (data) {
+      try {
+        const errObj = JSON.parse(data);
+        errMsg += `\n${JSON.stringify(errObj, null, 2)}`;
+      } catch {
+        errMsg += `\n${data}`;
+      }
+    }
+    throw new Error(errMsg);
+  }
+}

package/lib/mcp-server.ts

@@ -1,12 +1,12 @@
-import * as pkg from "../package.json";
+import pkg from "../package.json";
 import * as config from "./config";
 import { fetchIssues, fetchIssueComments, createIssueComment, fetchIssue } from "./issues";
 import { resolveBaseUrls } from "./util";
 
-// MCP SDK imports
-import { Server } from "@modelcontextprotocol/sdk/server";
-import * as path from "path";
-// Types schemas will be loaded dynamically from the SDK's CJS bundle
+// MCP SDK imports - Bun handles these directly
+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 {
   apiKey?: string;
@@ -14,16 +14,6 @@ interface RootOptsLike {
 }
 
 export async function startMcpServer(rootOpts?: RootOptsLike, extra?: { debug?: boolean }): Promise<void> {
-  // Resolve stdio transport at runtime to avoid subpath export resolution issues
-  const serverEntry = require.resolve("@modelcontextprotocol/sdk/server");
-  const stdioPath = path.join(path.dirname(serverEntry), "stdio.js");
-  // eslint-disable-next-line @typescript-eslint/no-var-requires
-  const { StdioServerTransport } = require(stdioPath);
-  // Load schemas dynamically to avoid subpath export resolution issues
-  const typesPath = path.resolve(path.dirname(serverEntry), "../types.js");
-  // eslint-disable-next-line @typescript-eslint/no-var-requires
-  const { CallToolRequestSchema, ListToolsRequestSchema } = require(typesPath);
-
   const server = new Server(
     { name: "postgresai-mcp", version: pkg.version },
     { capabilities: { tools: {} } }
@@ -85,6 +75,7 @@ export async function startMcpServer(rootOpts?: RootOptsLike, extra?: { debug?:
     };
   });
 
+  // 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>) || {};
@@ -152,5 +143,3 @@ export async function startMcpServer(rootOpts?: RootOptsLike, extra?: { debug?:
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }
-
-