@dypai-ai/mcp 1.5.12 → 1.5.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dypai-ai/mcp",
-  "version": "1.5.12",
+  "version": "1.5.13",
   "description": "DYPAI MCP Server — AI agent toolkit for building and deploying full-stack apps",
   "type": "module",
   "main": "src/index.js",

package/src/index.js

@@ -1121,7 +1121,7 @@ async function handleRequest(msg) {
     return makeResponse(id, {
       protocolVersion: "2024-11-05",
       capabilities: { tools: {} },
-      serverInfo: { name: "dypai", version: "1.5.12" },
+      serverInfo: { name: "dypai", version: "1.5.13" },
       instructions: SERVER_INSTRUCTIONS,
     })
   }

package/src/tools/sync/validate.js

@@ -397,6 +397,46 @@ function isWordAt(sql, index, word) {
   return !/[A-Za-z0-9_]/.test(before) && !/[A-Za-z0-9_]/.test(after)
 }
 
+function skipDoubleQuotedIdentifier(sql, index) {
+  if (sql[index] !== "\"") return index
+  for (let i = index + 1; i < sql.length; i++) {
+    if (sql[i] !== "\"") continue
+    if (sql[i + 1] === "\"") {
+      i++
+      continue
+    }
+    return i
+  }
+  return sql.length - 1
+}
+
+function skipSqlSpaces(sql, index) {
+  let i = index
+  while (i < sql.length && /\s/.test(sql[i])) i++
+  return i
+}
+
+function findMatchingParen(sql, openIndex) {
+  if (sql[openIndex] !== "(") return -1
+  let depth = 0
+  for (let i = openIndex; i < sql.length; i++) {
+    const ch = sql[i]
+    if (ch === "\"") {
+      i = skipDoubleQuotedIdentifier(sql, i)
+      continue
+    }
+    if (ch === "(") {
+      depth++
+      continue
+    }
+    if (ch === ")") {
+      depth--
+      if (depth === 0) return i
+    }
+  }
+  return -1
+}
+
 function findOuterSelectList(sqlText) {
   const sql = stripSqlForInference(sqlText)
   if (!sql) return null
@@ -404,6 +444,10 @@ function findOuterSelectList(sqlText) {
   let selectStart = -1
   for (let i = 0; i < sql.length; i++) {
     const ch = sql[i]
+    if (ch === "\"") {
+      i = skipDoubleQuotedIdentifier(sql, i)
+      continue
+    }
     if (ch === "(") depth++
     else if (ch === ")") depth = Math.max(0, depth - 1)
 
@@ -417,15 +461,183 @@ function findOuterSelectList(sqlText) {
       return sql.slice(selectStart, i).trim()
     }
   }
+  if (selectStart >= 0) return sql.slice(selectStart).trim()
   return null
 }
 
+function hasTopLevelLimitOne(sqlText) {
+  const sql = stripSqlForInference(sqlText)
+  let depth = 0
+  for (let i = 0; i < sql.length; i++) {
+    const ch = sql[i]
+    if (ch === "\"") {
+      i = skipDoubleQuotedIdentifier(sql, i)
+      continue
+    }
+    if (ch === "(") {
+      depth++
+      continue
+    }
+    if (ch === ")") {
+      depth = Math.max(0, depth - 1)
+      continue
+    }
+    if (depth !== 0 || !isWordAt(sql, i, "limit")) continue
+
+    const tail = sql.slice(skipSqlSpaces(sql, i + "limit".length))
+    return /^1(?:\D|$)/.test(tail)
+  }
+  return false
+}
+
+function hasTopLevelFetchOne(sqlText) {
+  const sql = stripSqlForInference(sqlText)
+  let depth = 0
+  for (let i = 0; i < sql.length; i++) {
+    const ch = sql[i]
+    if (ch === "\"") {
+      i = skipDoubleQuotedIdentifier(sql, i)
+      continue
+    }
+    if (ch === "(") {
+      depth++
+      continue
+    }
+    if (ch === ")") {
+      depth = Math.max(0, depth - 1)
+      continue
+    }
+    if (depth !== 0 || !isWordAt(sql, i, "fetch")) continue
+
+    let cursor = skipSqlSpaces(sql, i + "fetch".length)
+    if (isWordAt(sql, cursor, "first")) cursor += "first".length
+    else if (isWordAt(sql, cursor, "next")) cursor += "next".length
+    else continue
+    cursor = skipSqlSpaces(sql, cursor)
+    return /^1(?:\D|$)/.test(sql.slice(cursor))
+  }
+  return false
+}
+
+function hasTopLevelGroupBy(sqlText) {
+  const sql = stripSqlForInference(sqlText)
+  let depth = 0
+  for (let i = 0; i < sql.length; i++) {
+    const ch = sql[i]
+    if (ch === "\"") {
+      i = skipDoubleQuotedIdentifier(sql, i)
+      continue
+    }
+    if (ch === "(") {
+      depth++
+      continue
+    }
+    if (ch === ")") {
+      depth = Math.max(0, depth - 1)
+      continue
+    }
+    if (depth !== 0 || !isWordAt(sql, i, "group")) continue
+
+    const restStart = i + "group".length
+    const rest = sql.slice(restStart)
+    const byOffset = rest.search(/\S/)
+    if (byOffset >= 0 && isWordAt(sql, restStart + byOffset, "by")) return true
+  }
+  return false
+}
+
+function hasTopLevelSetOperation(sqlText) {
+  const sql = stripSqlForInference(sqlText)
+  let depth = 0
+  for (let i = 0; i < sql.length; i++) {
+    const ch = sql[i]
+    if (ch === "\"") {
+      i = skipDoubleQuotedIdentifier(sql, i)
+      continue
+    }
+    if (ch === "(") {
+      depth++
+      continue
+    }
+    if (ch === ")") {
+      depth = Math.max(0, depth - 1)
+      continue
+    }
+    if (depth !== 0) continue
+    if (isWordAt(sql, i, "union") || isWordAt(sql, i, "intersect") || isWordAt(sql, i, "except")) {
+      return true
+    }
+  }
+  return false
+}
+
+const AGGREGATE_FUNCTIONS = ["count", "sum", "avg", "min", "max", "json_agg", "jsonb_agg", "array_agg", "string_agg"]
+
+function isWindowAggregateCall(sql, openIndex) {
+  const closeIndex = findMatchingParen(sql, openIndex)
+  if (closeIndex < 0) return false
+
+  let cursor = skipSqlSpaces(sql, closeIndex + 1)
+  if (isWordAt(sql, cursor, "filter")) {
+    cursor = skipSqlSpaces(sql, cursor + "filter".length)
+    if (sql[cursor] === "(") {
+      const filterClose = findMatchingParen(sql, cursor)
+      if (filterClose >= 0) cursor = skipSqlSpaces(sql, filterClose + 1)
+    }
+  }
+
+  return isWordAt(sql, cursor, "over")
+}
+
+function hasOuterAggregateFunction(selectList) {
+  const sql = String(selectList || "")
+  let depth = 0
+  const activeSubqueryDepths = []
+
+  const insideSubquery = () => activeSubqueryDepths.some(d => d <= depth)
+
+  for (let i = 0; i < sql.length; i++) {
+    const ch = sql[i]
+    if (ch === "\"") {
+      i = skipDoubleQuotedIdentifier(sql, i)
+      continue
+    }
+    if (ch === "(") {
+      depth++
+      continue
+    }
+    if (ch === ")") {
+      activeSubqueryDepths.splice(0, activeSubqueryDepths.length, ...activeSubqueryDepths.filter(d => d < depth))
+      depth = Math.max(0, depth - 1)
+      continue
+    }
+
+    if (depth > 0 && isWordAt(sql, i, "select")) {
+      activeSubqueryDepths.push(depth)
+      i += "select".length - 1
+      continue
+    }
+
+    for (const fn of AGGREGATE_FUNCTIONS) {
+      if (!isWordAt(sql, i, fn)) continue
+      const openIndex = skipSqlSpaces(sql, i + fn.length)
+      if (sql[openIndex] === "(" && !insideSubquery() && !isWindowAggregateCall(sql, openIndex)) return true
+    }
+  }
+
+  return false
+}
+
 function splitTopLevelComma(list) {
   const parts = []
   let depth = 0
   let start = 0
   for (let i = 0; i < list.length; i++) {
     const ch = list[i]
+    if (ch === "\"") {
+      i = skipDoubleQuotedIdentifier(list, i)
+      continue
+    }
     if (ch === "(") depth++
     else if (ch === ")") depth = Math.max(0, depth - 1)
     else if (ch === "," && depth === 0) {
@@ -478,10 +690,12 @@ function inferSelectOutputColumns(sqlText) {
 function inferSqlCardinality(sqlText) {
   const sql = stripSqlForInference(sqlText)
   if (!sql) return null
-  if (/\blimit\s+1(?:\D|$)/i.test(sql)) return "single"
+  if (hasTopLevelLimitOne(sql) || hasTopLevelFetchOne(sql)) return "single"
   const startsLikeRead = /^(select|with)\b/i.test(sql)
-  const hasAggregate = /\b(count|sum|avg|min|max|json_agg|jsonb_agg|array_agg|string_agg)\s*\(/i.test(sql)
-  const hasGroupBy = /\bgroup\s+by\b/i.test(sql)
+  if (startsLikeRead && hasTopLevelSetOperation(sql)) return "many"
+  const outerSelectList = findOuterSelectList(sql)
+  const hasAggregate = outerSelectList ? hasOuterAggregateFunction(outerSelectList) : false
+  const hasGroupBy = hasTopLevelGroupBy(sql)
   if (startsLikeRead && hasAggregate && !hasGroupBy) return "single"
   return "many"
 }