@dypai-ai/mcp 1.6.16 → 1.6.17

package/src/tools/sync/source-diff.js

@@ -0,0 +1,217 @@
+import { createHash } from "node:crypto"
+import { mkdir, readFile, readdir, stat, writeFile } from "fs/promises"
+import { dirname, join } from "path"
+
+const BACKEND_SOURCE_DIRS = ["flows", "automations", "endpoints", "migrations", "types", "lib"]
+const BACKEND_SOURCE_EXACT = [
+  "schema.sql",
+  "realtime.yaml",
+  "credentials.yaml",
+  "node-catalog.json",
+  "capability-catalog.json",
+  "capability-brief.md",
+  "dypai.config.yaml",
+]
+const BACKEND_SOURCE_EXTS = new Set([
+  ".ts", ".tsx", ".js", ".jsx", ".mjs", ".mts", ".cjs", ".cts",
+  ".json", ".yaml", ".yml", ".sql", ".md", ".txt",
+])
+
+function extOfPath(path) {
+  const filename = path.split("/").pop() || path
+  return filename.includes(".") ? `.${filename.split(".").pop().toLowerCase()}` : ""
+}
+
+function isTextBackendPath(path) {
+  return BACKEND_SOURCE_EXTS.has(extOfPath(path))
+}
+
+function normalizePath(path) {
+  return String(path || "").replace(/\\/g, "/").replace(/^\/+/, "")
+}
+
+export function isTrackedBackendSourcePath(path) {
+  const normalized = normalizePath(path)
+  if (!normalized.startsWith("dypai/")) return false
+  if (normalized.startsWith("dypai/.dypai/")) return false
+  const rel = normalized.slice("dypai/".length)
+  if (BACKEND_SOURCE_EXACT.includes(rel)) return true
+  return BACKEND_SOURCE_DIRS.some((dir) => rel.startsWith(`${dir}/`)) && isTextBackendPath(rel)
+}
+
+function hashContent(content) {
+  return createHash("sha256").update(content).digest("hex")
+}
+
+async function addFile(files, absPath, relPath) {
+  if (!isTextBackendPath(relPath)) return
+  const content = await readFile(absPath, "utf8")
+  files.push({
+    path: `dypai/${relPath}`,
+    content,
+    sha256: hashContent(content),
+  })
+}
+
+async function walkDir(files, absDir, relBase) {
+  let entries = []
+  try {
+    entries = await readdir(absDir, { withFileTypes: true })
+  } catch {
+    return
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith(".")) continue
+    const relPath = `${relBase}/${entry.name}`.replace(/^\/+/, "")
+    const absPath = join(absDir, entry.name)
+    if (entry.isDirectory()) {
+      await walkDir(files, absPath, relPath)
+    } else if (entry.isFile()) {
+      await addFile(files, absPath, relPath)
+    }
+  }
+}
+
+export async function collectBackendSourceFiles(rootDir) {
+  const files = []
+
+  for (const relPath of BACKEND_SOURCE_EXACT) {
+    const absPath = join(rootDir, relPath)
+    try {
+      const s = await stat(absPath)
+      if (s.isFile()) await addFile(files, absPath, relPath)
+    } catch {
+      // optional
+    }
+  }
+
+  for (const dir of BACKEND_SOURCE_DIRS) {
+    await walkDir(files, join(rootDir, dir), dir)
+  }
+
+  files.sort((a, b) => a.path.localeCompare(b.path))
+  return files
+}
+
+function normalizeBaseline(raw) {
+  const parsed = JSON.parse(raw)
+  const files = parsed?.files
+  const result = new Map()
+  if (Array.isArray(files)) {
+    for (const file of files) {
+      if (typeof file?.path === "string" && typeof file?.sha256 === "string" && isTrackedBackendSourcePath(file.path)) {
+        result.set(file.path, file.sha256)
+      }
+    }
+  } else if (files && typeof files === "object") {
+    for (const [path, value] of Object.entries(files)) {
+      if (!isTrackedBackendSourcePath(path)) continue
+      if (typeof value === "string") result.set(path, value)
+      else if (value && typeof value === "object" && typeof value.sha256 === "string") result.set(path, value.sha256)
+    }
+  }
+  return result
+}
+
+export async function readBackendSourceBaseline(rootDir) {
+  try {
+    const raw = await readFile(join(rootDir, ".dypai", "backend-baseline.json"), "utf8")
+    return {
+      ok: true,
+      baseline: normalizeBaseline(raw),
+    }
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return {
+        ok: false,
+        missing: true,
+        baseline: new Map(),
+      }
+    }
+    return {
+      ok: false,
+      error: error?.message || String(error),
+      baseline: new Map(),
+    }
+  }
+}
+
+export async function diffBackendSource(rootDir) {
+  const currentFiles = await collectBackendSourceFiles(rootDir)
+  const current = new Map(currentFiles.map((file) => [file.path, file.sha256]))
+  const baselineResult = await readBackendSourceBaseline(rootDir)
+
+  if (!baselineResult.ok && !baselineResult.missing) {
+    return {
+      ok: false,
+      reason: "baseline_parse_error",
+      error: baselineResult.error,
+    }
+  }
+
+  if (baselineResult.missing) {
+    return {
+      ok: true,
+      baseline: false,
+      files: {
+        created: currentFiles.map((file) => file.path),
+        updated: [],
+        deleted: [],
+      },
+      summary: {
+        create: currentFiles.length,
+        update: 0,
+        delete: 0,
+        unchanged: 0,
+      },
+    }
+  }
+
+  const baseline = baselineResult.baseline
+  const created = []
+  const updated = []
+  const deleted = []
+  const unchanged = []
+
+  for (const [path, hash] of current) {
+    if (!baseline.has(path)) created.push(path)
+    else if (baseline.get(path) !== hash) updated.push(path)
+    else unchanged.push(path)
+  }
+  for (const path of baseline.keys()) {
+    if (!current.has(path)) deleted.push(path)
+  }
+
+  return {
+    ok: true,
+    baseline: true,
+    files: {
+      created,
+      updated,
+      deleted,
+    },
+    summary: {
+      create: created.length,
+      update: updated.length,
+      delete: deleted.length,
+      unchanged: unchanged.length,
+    },
+  }
+}
+
+export async function writeBackendSourceBaseline(rootDir, projectId = null) {
+  const files = await collectBackendSourceFiles(rootDir)
+  const payload = {
+    synced_at: new Date().toISOString(),
+    ...(projectId ? { project_id: projectId } : {}),
+    files: files.map((file) => ({
+      path: file.path,
+      sha256: file.sha256,
+    })),
+  }
+  const target = join(rootDir, ".dypai", "backend-baseline.json")
+  await mkdir(dirname(target), { recursive: true })
+  await writeFile(target, JSON.stringify(payload, null, 2) + "\n", "utf8")
+  return payload
+}
+