@dypai-ai/mcp 1.5.18 → 1.5.22

package/src/tools/capability-kits.js

@@ -1,830 +0,0 @@
-import crypto from "crypto"
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, copyFileSync } from "fs"
-import { tmpdir } from "os"
-import { basename, delimiter, dirname, isAbsolute, join, relative, resolve, sep } from "path"
-import { fileURLToPath } from "url"
-import { proxyToolCall } from "./proxy.js"
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-const DEFAULT_LIMIT = 5
-const DEFAULT_R2_BUCKET = "organizations-storage"
-const DEFAULT_R2_PREFIX = "capability-kits"
-
-function readJson(path) {
-  return JSON.parse(readFileSync(path, "utf8"))
-}
-
-function isObject(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value)
-}
-
-function normalizeList(value) {
-  return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.trim()) : []
-}
-
-function walkUp(start, predicate) {
-  let cursor = resolve(start)
-  for (let i = 0; i < 10; i++) {
-    if (predicate(cursor)) return cursor
-    const parent = dirname(cursor)
-    if (parent === cursor) break
-    cursor = parent
-  }
-  return null
-}
-
-function resolveKitsRoot(inputRoot) {
-  const candidates = [
-    inputRoot,
-    process.env.DYPAI_CAPABILITY_KITS_ROOT,
-  ].filter(Boolean)
-
-  for (const candidate of candidates) {
-    const root = resolve(candidate)
-    if (existsSync(join(root, "kits"))) return root
-  }
-
-  const fromCwd = walkUp(process.cwd(), (dir) => existsSync(join(dir, "dypai-capability-kits", "kits")))
-  if (fromCwd) return join(fromCwd, "dypai-capability-kits")
-
-  const fromThisFile = walkUp(__dirname, (dir) => existsSync(join(dir, "dypai-capability-kits", "kits")))
-  if (fromThisFile) return join(fromThisFile, "dypai-capability-kits")
-
-  throw new Error(
-    "Capability kit repo not found locally. Set DYPAI_CAPABILITY_KITS_ROOT for local authoring or configure R2 credentials for remote kit install.",
-  )
-}
-
-function tryResolveKitsRoot(inputRoot) {
-  try {
-    return resolveKitsRoot(inputRoot)
-  } catch {
-    return null
-  }
-}
-
-function hasLocalKit(root, slug, version) {
-  return Boolean(root) && existsSync(join(root, "kits", slug, version, "kit.json"))
-}
-
-function sha256Buffer(buffer) {
-  return crypto.createHash("sha256").update(buffer).digest("hex")
-}
-
-function safeLogicalPath(path) {
-  if (typeof path !== "string" || !path.trim()) throw new Error("Remote kit file path is invalid")
-  const normalized = path.replace(/\\/g, "/").replace(/^\/+/, "")
-  if (!normalized || normalized.includes("..") || isAbsolute(normalized)) {
-    throw new Error(`Unsafe remote kit file path: ${path}`)
-  }
-  return normalized
-}
-
-function parseR2SourceUri(sourceUri, slug) {
-  if (typeof sourceUri !== "string" || !sourceUri.startsWith("r2://")) return null
-  const withoutScheme = sourceUri.slice("r2://".length)
-  const slash = withoutScheme.indexOf("/")
-  if (slash <= 0) throw new Error(`Invalid capability kit source_uri: ${sourceUri}`)
-  const bucket = withoutScheme.slice(0, slash)
-  const rootKey = withoutScheme.slice(slash + 1).replace(/^\/+|\/+$/g, "")
-  if (!rootKey || !rootKey.split("/").includes(slug)) {
-    throw new Error(`Capability kit source_uri does not look like a kit root for ${slug}: ${sourceUri}`)
-  }
-  return { bucket, rootKey }
-}
-
-function resolveRemoteKitLocation(slug, sourceUri) {
-  const parsed = parseR2SourceUri(sourceUri, slug)
-  if (parsed) return parsed
-  const bucket = process.env.CAPABILITY_KITS_R2_BUCKET
-    || process.env.DYPAI_CAPABILITY_KITS_R2_BUCKET
-    || process.env.CLOUDFLARE_R2_CAPABILITY_KITS_BUCKET
-    || DEFAULT_R2_BUCKET
-  const prefix = (process.env.CAPABILITY_KITS_R2_PREFIX || DEFAULT_R2_PREFIX).replace(/^\/+|\/+$/g, "")
-  return {
-    bucket,
-    rootKey: `${prefix}/${slug}`.replace(/^\/+|\/+$/g, "").replace(/\/+/g, "/"),
-  }
-}
-
-function resolveR2Config(slug, sourceUri) {
-  const endpoint = (process.env.CLOUDFLARE_R2_ENDPOINT_URL || "").replace(/\/$/, "")
-  const accessKeyId = process.env.CLOUDFLARE_R2_ACCESS_KEY_ID || ""
-  const secretAccessKey = process.env.CLOUDFLARE_R2_SECRET_ACCESS_KEY || ""
-  if (!endpoint || !accessKeyId || !secretAccessKey) {
-    throw new Error("Capability kit R2 storage is not configured. Set CLOUDFLARE_R2_ENDPOINT_URL, CLOUDFLARE_R2_ACCESS_KEY_ID, and CLOUDFLARE_R2_SECRET_ACCESS_KEY.")
-  }
-  return { endpoint, accessKeyId, secretAccessKey, ...resolveRemoteKitLocation(slug, sourceUri) }
-}
-
-function hmac(key, value, encoding) {
-  return crypto.createHmac("sha256", key).update(value).digest(encoding)
-}
-
-function sha256Hex(value) {
-  return crypto.createHash("sha256").update(value).digest("hex")
-}
-
-function encodeRfc3986(value) {
-  return encodeURIComponent(value).replace(/[!'()*]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`)
-}
-
-function r2Url(config, key) {
-  const encodedKey = key.split("/").map(encodeRfc3986).join("/")
-  return new URL(`${config.endpoint}/${encodeRfc3986(config.bucket)}/${encodedKey}`)
-}
-
-function signingKey(secretAccessKey, dateStamp) {
-  const dateKey = hmac(`AWS4${secretAccessKey}`, dateStamp)
-  const dateRegionKey = hmac(dateKey, "auto")
-  const dateRegionServiceKey = hmac(dateRegionKey, "s3")
-  return hmac(dateRegionServiceKey, "aws4_request")
-}
-
-function signedR2Headers(config, method, url, payloadHash) {
-  const now = new Date()
-  const amzDate = now.toISOString().replace(/[:-]|\.\d{3}/g, "")
-  const dateStamp = amzDate.slice(0, 8)
-  const canonicalHeaders = [
-    `host:${url.host}`,
-    `x-amz-content-sha256:${payloadHash}`,
-    `x-amz-date:${amzDate}`,
-    "",
-  ].join("\n")
-  const signedHeaders = "host;x-amz-content-sha256;x-amz-date"
-  const canonicalRequest = [
-    method,
-    url.pathname,
-    url.searchParams.toString(),
-    canonicalHeaders,
-    signedHeaders,
-    payloadHash,
-  ].join("\n")
-  const credentialScope = `${dateStamp}/auto/s3/aws4_request`
-  const stringToSign = [
-    "AWS4-HMAC-SHA256",
-    amzDate,
-    credentialScope,
-    sha256Hex(canonicalRequest),
-  ].join("\n")
-  const signature = hmac(signingKey(config.secretAccessKey, dateStamp), stringToSign, "hex")
-
-  return {
-    Authorization: `AWS4-HMAC-SHA256 Credential=${config.accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`,
-    "x-amz-content-sha256": payloadHash,
-    "x-amz-date": amzDate,
-  }
-}
-
-async function r2Get(config, key) {
-  const url = r2Url(config, key)
-  const response = await fetch(url, {
-    method: "GET",
-    headers: signedR2Headers(config, "GET", url, sha256Hex(Buffer.alloc(0))),
-  })
-  if (!response.ok) {
-    throw new Error(`R2 GET failed for ${key}: ${response.status} ${await response.text()}`)
-  }
-  return Buffer.from(await response.arrayBuffer())
-}
-
-function parseRemoteFilesManifest(value, slug, requestedVersion) {
-  const parsed = JSON.parse(value)
-  if (!isObject(parsed)) throw new Error("Remote kit manifest must be a JSON object")
-  if (parsed.slug && parsed.slug !== slug) throw new Error(`Remote kit manifest slug mismatch: expected ${slug}, got ${parsed.slug}`)
-  if (parsed.version && parsed.version !== requestedVersion) {
-    throw new Error(`Remote kit manifest version mismatch: expected ${requestedVersion}, got ${parsed.version}`)
-  }
-  if (!Array.isArray(parsed.files) || !parsed.files.length) {
-    throw new Error(`Remote kit manifest for ${slug} has no files`)
-  }
-  return parsed
-}
-
-function cachedRemoteKitComplete(kitDirPath, manifest) {
-  return (manifest.files || []).every((file) => {
-    try {
-      const rel = safeLogicalPath(file.path)
-      const path = join(kitDirPath, rel)
-      if (!existsSync(path)) return false
-      return file.sha256 ? sha256Buffer(readFileSync(path)) === file.sha256 : true
-    } catch {
-      return false
-    }
-  })
-}
-
-function remoteKitKey(config, logicalPath) {
-  return `${config.rootKey}/${logicalPath}`.replace(/\/+/g, "/").replace(/^\/+/, "")
-}
-
-async function downloadRemoteCapabilityKit(slug, version, sourceUri) {
-  const config = resolveR2Config(slug, sourceUri)
-  const manifestKey = remoteKitKey(config, "manifest.files.json")
-  const manifestText = (await r2Get(config, manifestKey)).toString("utf8")
-  const manifest = parseRemoteFilesManifest(manifestText, slug, version)
-  const contentHash = typeof manifest.contentHash === "string" && manifest.contentHash.trim()
-    ? manifest.contentHash.trim()
-    : sha256Buffer(Buffer.from(manifestText))
-  const cacheRoot = join(tmpdir(), "dypai-capability-kits", slug, contentHash)
-  const kitDirPath = join(cacheRoot, "kits", slug, version)
-  const localManifestPath = join(kitDirPath, "manifest.files.json")
-
-  if (existsSync(localManifestPath) && cachedRemoteKitComplete(kitDirPath, manifest)) {
-    return cacheRoot
-  }
-
-  mkdirSync(kitDirPath, { recursive: true })
-  for (const file of manifest.files || []) {
-    const rel = safeLogicalPath(file.path)
-    const buffer = await r2Get(config, remoteKitKey(config, rel))
-    if (file.sha256 && sha256Buffer(buffer) !== file.sha256) {
-      throw new Error(`Capability kit file hash mismatch for ${slug}/${rel}`)
-    }
-    const target = join(kitDirPath, rel)
-    mkdirSync(dirname(target), { recursive: true })
-    writeFileSync(target, buffer)
-  }
-  writeFileSync(localManifestPath, manifestText)
-  return cacheRoot
-}
-
-async function resolveKitsRootForKit({ kits_root, slug, version, source_uri }) {
-  const sourceMode = (process.env.DYPAI_CAPABILITY_KITS_SOURCE || "").toLowerCase()
-  const localRoot = sourceMode === "remote" ? null : tryResolveKitsRoot(kits_root)
-  if (hasLocalKit(localRoot, slug, version)) return { root: localRoot, source: "local_repo" }
-  const remoteRoot = await downloadRemoteCapabilityKit(slug, version, source_uri)
-  return { root: remoteRoot, source: "r2" }
-}
-
-function shouldSearchRemote(kitsRoot) {
-  const source = (process.env.DYPAI_CAPABILITY_KITS_SOURCE || "").toLowerCase()
-  if (source === "local") return false
-  if (source === "remote") return true
-  if (kitsRoot || process.env.DYPAI_CAPABILITY_KITS_ROOT) return false
-  return Boolean(process.env.DYPAI_TOKEN)
-}
-
-function resolveWorkspaceRoot(inputRoot) {
-  if (inputRoot) {
-    const root = resolve(inputRoot)
-    mkdirSync(root, { recursive: true })
-    return root
-  }
-
-  const envCandidates = [
-    process.env.CLAUDE_PROJECT_DIR,
-    process.env.DYPAI_WORKSPACE_ROOT,
-    process.env.PROJECT_ROOT,
-    process.env.WORKSPACE_FOLDER_PATHS?.split(delimiter)[0],
-  ].filter(Boolean)
-
-  for (const candidate of envCandidates) {
-    const root = resolve(candidate)
-    if (existsSync(root)) return root
-  }
-
-  const fromCwd = walkUp(process.cwd(), (dir) =>
-    existsSync(join(dir, ".git")) ||
-    existsSync(join(dir, "package.json")) ||
-    existsSync(join(dir, "dypai")) ||
-    existsSync(join(dir, "src")),
-  )
-  if (fromCwd) return fromCwd
-
-  throw new Error("Could not determine workspace root. Pass workspace_root as an absolute project path.")
-}
-
-function safeTarget(workspaceRoot, targetPath) {
-  if (!targetPath || typeof targetPath !== "string") throw new Error("Invalid target path")
-  if (isAbsolute(targetPath)) throw new Error(`Target must be workspace-relative, got absolute path: ${targetPath}`)
-  const normalized = targetPath.replace(/\\/g, "/").replace(/^\/+/, "")
-  if (normalized.includes("..")) throw new Error(`Target path cannot contain '..': ${targetPath}`)
-  const full = resolve(workspaceRoot, normalized)
-  const rel = relative(workspaceRoot, full)
-  if (rel.startsWith("..") || rel === "" || isAbsolute(rel)) {
-    throw new Error(`Target escapes workspace root: ${targetPath}`)
-  }
-  return full
-}
-
-function kitDir(kitsRoot, slug, version) {
-  if (!slug || !version) throw new Error("slug and version are required")
-  return join(kitsRoot, "kits", slug, version)
-}
-
-function loadKit(kitsRoot, slug, version) {
-  const dir = kitDir(kitsRoot, slug, version)
-  const manifestPath = join(dir, "kit.json")
-  if (!existsSync(manifestPath)) throw new Error(`Kit not found: ${slug}@${version}`)
-  const manifest = readJson(manifestPath)
-  return { dir, manifest }
-}
-
-function listKits(kitsRoot) {
-  const kitsDir = join(kitsRoot, "kits")
-  const kits = []
-  for (const slug of readdirSync(kitsDir)) {
-    const slugDir = join(kitsDir, slug)
-    if (!existsSync(slugDir) || slug === "index.json") continue
-    for (const version of readdirSync(slugDir)) {
-      const manifestPath = join(slugDir, version, "kit.json")
-      if (!existsSync(manifestPath)) continue
-      kits.push({ dir: join(slugDir, version), manifest: readJson(manifestPath) })
-    }
-  }
-  return kits
-}
-
-function searchText(kit) {
-  const parts = [
-    kit.slug,
-    kit.name,
-    kit.kitType,
-    kit.category,
-    kit.description,
-    kit.useWhen,
-    kit.avoidWhen,
-    kit.userFacingSummary,
-    kit.agentInstructions,
-    ...normalizeList(kit.appTypes),
-    ...normalizeList(kit.screenTypes),
-    ...normalizeList(kit.featureTags),
-    ...normalizeList(kit.visualStyles),
-    ...normalizeList(kit.provides),
-    ...normalizeList(kit.requires),
-    ...normalizeList(kit.dependencies),
-  ]
-  return parts.filter(Boolean).join(" ").toLowerCase()
-}
-
-function matchesFilter(kit, filters = {}) {
-  if (!isObject(filters)) return true
-  if (filters.category && kit.category !== filters.category) return false
-  if (filters.maturity) {
-    const allowed = Array.isArray(filters.maturity) ? filters.maturity : [filters.maturity]
-    if (!allowed.includes(kit.maturity)) return false
-  }
-  const listChecks = [
-    ["app_type", "appTypes"],
-    ["screen_type", "screenTypes"],
-    ["feature_tag", "featureTags"],
-  ]
-  for (const [filterKey, kitKey] of listChecks) {
-    if (filters[filterKey] && !normalizeList(kit[kitKey]).includes(filters[filterKey])) return false
-  }
-  if (Array.isArray(filters.requires)) {
-    const requires = normalizeList(kit.requires)
-    for (const required of filters.requires) {
-      if (!requires.includes(required)) return false
-    }
-  }
-  return true
-}
-
-function scoreKit(query, kit) {
-  const text = searchText(kit)
-  const terms = String(query || "")
-    .toLowerCase()
-    .split(/[^a-z0-9áéíóúñ]+/i)
-    .map((term) => term.trim())
-    .filter((term) => term.length >= 3)
-  if (!terms.length) return 0
-  let score = 0
-  for (const term of terms) {
-    if (kit.slug?.includes(term)) score += 5
-    if (kit.category?.toLowerCase() === term) score += 4
-    if (text.includes(term)) score += 1
-  }
-  return score
-}
-
-function assetIndex(dir) {
-  const out = []
-  function visit(abs, rel = "") {
-    for (const name of readdirSync(abs, { withFileTypes: true })) {
-      const childAbs = join(abs, name.name)
-      const childRel = rel ? `${rel}/${name.name}` : name.name
-      if (name.isDirectory()) visit(childAbs, childRel)
-      else out.push({ logicalPath: childRel, sizeBytes: readFileSync(childAbs).length })
-    }
-  }
-  visit(dir)
-  return out.sort((a, b) => a.logicalPath.localeCompare(b.logicalPath))
-}
-
-function stripFrontendPrefix(source) {
-  return source.replace(/^frontend\/src\//, "")
-}
-
-function defaultTargetForSource(manifest, source, kind) {
-  if (kind === "frontend") return `src/dypai-kits/${manifest.slug}/${stripFrontendPrefix(source)}`
-  if (kind === "backend") return `dypai/endpoints/${manifest.slug}/${source.split("/").pop()}`
-  if (kind === "database") return `dypai/kit-installations/${manifest.slug}/${manifest.version}/${source.split("/").pop()}`
-  return `.dypai/kits/${manifest.slug}/${source.split("/").pop()}`
-}
-
-function pluralize(word) {
-  if (!word) return word
-  if (word.endsWith("s")) return word
-  if (word.endsWith("y")) return `${word.slice(0, -1)}ies`
-  return `${word}s`
-}
-
-function namingContext(manifest, naming = {}) {
-  const adaptation = isObject(manifest.adaptation) ? manifest.adaptation : {}
-  const sourceEntity = adaptation.defaultEntity || normalizeList(adaptation.entityAliases)[0] || ""
-  const sourcePlural = adaptation.defaultEndpointPrefix || pluralize(sourceEntity)
-  const sourceTable = adaptation.defaultTableName || sourcePlural
-  const targetEntity = naming.entity || sourceEntity
-  const targetPlural = naming.endpointPrefix || pluralize(targetEntity)
-  const targetTable = naming.tableName || targetPlural
-  return { sourceEntity, sourcePlural, sourceTable, targetEntity, targetPlural, targetTable }
-}
-
-function replaceWholeWords(text, replacements) {
-  let out = text
-  for (const [from, to] of replacements) {
-    if (!from || !to || from === to) continue
-    out = out.replace(new RegExp(`\\b${from.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "g"), to)
-  }
-  return out
-}
-
-function adaptText(content, manifest, naming, kind) {
-  const n = namingContext(manifest, naming)
-  if (!n.sourceEntity && !n.sourcePlural && !n.sourceTable) return content
-  if (kind === "frontend") return content
-
-  if (kind === "backend") {
-    const withEndpointName = content.replace(/^name:\s*([a-z0-9-]+)\s*$/m, (_line, endpointName) => {
-      return `name: ${adaptTarget(endpointName, manifest, naming)}`
-    })
-    return replaceWholeWords(withEndpointName, [
-      [n.sourceTable, n.targetTable],
-      [n.sourceEntity, n.targetEntity],
-    ])
-  }
-
-  return replaceWholeWords(content, [
-    [n.sourceTable, n.targetTable],
-    [n.sourcePlural, n.targetTable],
-    [n.sourceEntity, n.targetEntity],
-  ])
-}
-
-function adaptTarget(target, manifest, naming) {
-  const n = namingContext(manifest, naming)
-  return replaceWholeWords(target, [
-    [n.sourcePlural, n.targetPlural],
-    [n.sourceEntity, n.targetEntity],
-    [n.sourceTable, n.targetTable],
-  ])
-}
-
-function installRecordPath(workspaceRoot) {
-  return join(workspaceRoot, ".dypai", "kits", "installed.json")
-}
-
-function readInstallRecord(workspaceRoot) {
-  const path = installRecordPath(workspaceRoot)
-  if (!existsSync(path)) return { schemaVersion: 1, kits: [] }
-  try {
-    const parsed = readJson(path)
-    if (isObject(parsed) && Array.isArray(parsed.kits)) return parsed
-  } catch {}
-  return { schemaVersion: 1, kits: [] }
-}
-
-function writeInstallRecord(workspaceRoot, record) {
-  const path = installRecordPath(workspaceRoot)
-  mkdirSync(dirname(path), { recursive: true })
-  writeFileSync(path, `${JSON.stringify(record, null, 2)}\n`)
-}
-
-function ownedTargets(record, slug, version) {
-  const targets = new Set()
-  for (const item of record.kits || []) {
-    if (item.slug === slug && item.version === version) {
-      for (const file of item.files || []) {
-        if (file.target) targets.add(file.target)
-      }
-    }
-  }
-  return targets
-}
-
-function writeTemplateFile({ sourceAbs, targetRel, workspaceRoot, manifest, naming, kind, overwrite, record, copied, skipped }) {
-  const targetAbs = safeTarget(workspaceRoot, targetRel)
-  const targetExists = existsSync(targetAbs)
-  if (targetExists) {
-    if (overwrite === "fail") throw new Error(`Target already exists: ${targetRel}`)
-    if (overwrite !== "replace" || !ownedTargets(record, manifest.slug, manifest.version).has(targetRel)) {
-      skipped.push(targetRel)
-      return false
-    }
-  }
-
-  mkdirSync(dirname(targetAbs), { recursive: true })
-  const isText = /\.(tsx?|jsx?|ya?ml|json|md|sql|css|scss|html)$/i.test(sourceAbs)
-  if (isText) {
-    const content = adaptText(readFileSync(sourceAbs, "utf8"), manifest, naming, kind)
-    writeFileSync(targetAbs, content)
-  } else {
-    copyFileSync(sourceAbs, targetAbs)
-  }
-  copied.push(targetRel)
-  return true
-}
-
-export const searchCapabilityKitsTool = {
-  name: "search_capability_kits",
-  description: "Search local DYPAI capability kits before building complex UI like calendars, maps, Kanban, upload flows, CRUD tables, dashboards, or editors.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      query: { type: "string", description: "Feature need and app domain, e.g. booking calendar for hotel reservations." },
-      limit: { type: "integer", default: DEFAULT_LIMIT, minimum: 1, maximum: 10 },
-      filters: { type: "object", description: "Optional filters: category, maturity, app_type, screen_type, feature_tag, requires." },
-      kits_root: { type: "string", description: "Optional local path to dypai-capability-kits. When omitted, the tool may use the remote MCP registry so local behavior matches production." },
-    },
-    required: ["query"],
-  },
-  async execute({ query, limit = DEFAULT_LIMIT, filters = {}, kits_root }) {
-    if (shouldSearchRemote(kits_root)) {
-      try {
-        const remote = await proxyToolCall("search_capability_kits", { query, limit, filters })
-        if (isObject(remote)) {
-          return { ...remote, source: remote.source || "mcp_cloud" }
-        }
-        return remote
-      } catch (error) {
-        if (!tryResolveKitsRoot(kits_root)) throw error
-        process.stderr.write(`Capability kit remote search failed, falling back to local repo: ${error.message}\n`)
-      }
-    }
-
-    const root = resolveKitsRoot(kits_root)
-    const kits = listKits(root)
-      .filter(({ manifest }) => matchesFilter(manifest, filters))
-      .map(({ manifest }) => ({ manifest, score: scoreKit(query, manifest) }))
-      .filter((item) => item.score > 0 || !query)
-      .sort((a, b) => b.score - a.score)
-      .slice(0, Math.max(1, Math.min(Number(limit) || DEFAULT_LIMIT, 10)))
-
-    return {
-      ok: true,
-      source: "local_repo",
-      kitsRoot: root,
-      count: kits.length,
-      kits: kits.map(({ manifest, score }) => ({
-        slug: manifest.slug,
-        version: manifest.version,
-        name: manifest.name,
-        category: manifest.category,
-        maturity: manifest.maturity,
-        description: manifest.description,
-        useWhen: manifest.useWhen,
-        provides: manifest.provides,
-        requires: manifest.requires,
-        dependencies: manifest.dependencies,
-        frontendManifest: manifest.frontendManifest,
-        backendManifest: manifest.backendManifest,
-        databaseManifest: manifest.databaseManifest,
-        score,
-      })),
-    }
-  },
-}
-
-async function inspectCapabilityKit({ slug, version = "1.0.0", kits_root, source_uri }) {
-  const { root, source } = await resolveKitsRootForKit({ kits_root, slug, version, source_uri })
-  const { dir, manifest } = loadKit(root, slug, version)
-  return {
-    ok: true,
-    operation: "inspect",
-    source,
-    kitsRoot: root,
-    kit: manifest,
-    assets: assetIndex(dir),
-    agentNotes: existsSync(join(dir, "agent.md")) ? readFileSync(join(dir, "agent.md"), "utf8") : undefined,
-    checklist: existsSync(join(dir, "verification", "checklist.md"))
-      ? readFileSync(join(dir, "verification", "checklist.md"), "utf8")
-      : undefined,
-  }
-}
-
-async function applyCapabilityKit({
-  slug,
-  version = "1.0.0",
-  targetFeature = "",
-  install = {},
-  naming = {},
-  target = {},
-  overwrite = "skip",
-  workspace_root,
-  kits_root,
-  source_uri,
-}) {
-  const { root, source } = await resolveKitsRootForKit({ kits_root, slug, version, source_uri })
-  const workspaceRoot = resolveWorkspaceRoot(workspace_root)
-  const { dir, manifest } = loadKit(root, slug, version)
-  const record = readInstallRecord(workspaceRoot)
-  const previousEntries = (record.kits || []).filter((item) => item.slug === manifest.slug && item.version === manifest.version)
-  const copied = []
-  const copiedByKind = {
-    frontend: [],
-    backend: [],
-    database: [],
-  }
-  const databaseTargetsBySource = new Map()
-  const skipped = []
-
-  const installFrontend = install.frontend !== false
-  const installBackend = install.backend !== false
-  const installDatabase = install.database !== false
-
-  if (installFrontend) {
-    for (const asset of manifest.frontendManifest || []) {
-      const sourceAbs = join(dir, asset.source)
-      if (!existsSync(sourceAbs)) throw new Error(`Missing kit asset: ${asset.source}`)
-      let targetRel = asset.suggestedTarget || defaultTargetForSource(manifest, asset.source, "frontend")
-      if (target.frontendDir) {
-        targetRel = join(target.frontendDir, stripFrontendPrefix(asset.source)).split(sep).join("/")
-      }
-      if (writeTemplateFile({ sourceAbs, targetRel, workspaceRoot, manifest, naming, kind: "frontend", overwrite, record, copied, skipped })) {
-        copiedByKind.frontend.push(targetRel)
-      }
-    }
-  }
-
-  if (installBackend) {
-    for (const asset of manifest.backendManifest || []) {
-      const sourceAbs = join(dir, asset.source)
-      if (!existsSync(sourceAbs)) throw new Error(`Missing kit asset: ${asset.source}`)
-      let targetRel = asset.suggestedTarget || defaultTargetForSource(manifest, asset.source, "backend")
-      targetRel = join(dirname(targetRel), adaptTarget(basename(targetRel), manifest, naming)).split(sep).join("/")
-      if (target.endpointDir) {
-        targetRel = join(target.endpointDir, adaptTarget(asset.source.split("/").pop(), manifest, naming)).split(sep).join("/")
-      }
-      if (writeTemplateFile({ sourceAbs, targetRel, workspaceRoot, manifest, naming, kind: "backend", overwrite, record, copied, skipped })) {
-        copiedByKind.backend.push(targetRel)
-      }
-    }
-  }
-
-  if (installDatabase && isObject(manifest.databaseManifest)) {
-    for (const key of ["schema", "seed"]) {
-      const source = manifest.databaseManifest[key]
-      if (!source) continue
-      const sourceAbs = join(dir, source)
-      if (!existsSync(sourceAbs)) throw new Error(`Missing kit asset: ${source}`)
-      let targetRel = defaultTargetForSource(manifest, source, "database")
-      if (target.databaseDir) {
-        targetRel = join(target.databaseDir, source.split("/").pop()).split(sep).join("/")
-      }
-      if (writeTemplateFile({ sourceAbs, targetRel, workspaceRoot, manifest, naming, kind: "database", overwrite, record, copied, skipped })) {
-        copiedByKind.database.push(targetRel)
-        databaseTargetsBySource.set(source, targetRel)
-      }
-    }
-  }
-
-  const imported = (manifest.frontendManifest || []).map((asset) => ({
-    name: asset.exportName,
-    from: target.frontendDir
-      ? `@/${join(target.frontendDir, stripFrontendPrefix(asset.source)).replace(/^src\//, "").replace(/\\/g, "/").replace(/\.(tsx?|jsx?)$/, "")}`
-      : asset.importPath,
-  })).filter((item) => item.name && item.from)
-
-  const backendEndpoints = (manifest.backendManifest || []).map((asset) =>
-    adaptTarget(asset.endpointName || asset.source.split("/").pop().replace(/\.ya?ml$/, ""), manifest, naming),
-  )
-  const databaseTables = normalizeList(manifest.databaseManifest?.tables).map((table) =>
-    adaptTarget(table, manifest, naming),
-  )
-  const schemaSource = installDatabase && isObject(manifest.databaseManifest) && typeof manifest.databaseManifest.schema === "string"
-    ? manifest.databaseManifest.schema
-    : ""
-  const seedSource = installDatabase && isObject(manifest.databaseManifest) && typeof manifest.databaseManifest.seed === "string"
-    ? manifest.databaseManifest.seed
-    : ""
-  const schemaFile = schemaSource ? databaseTargetsBySource.get(schemaSource) : undefined
-  const seedFile = seedSource ? databaseTargetsBySource.get(seedSource) : undefined
-
-  const previousFiles = previousEntries.flatMap((item) => Array.isArray(item.files) ? item.files : [])
-  const fileMap = new Map()
-  for (const file of previousFiles) {
-    if (file?.target) fileMap.set(file.target, file)
-  }
-  for (const targetPath of copied) {
-    fileMap.set(targetPath, { target: targetPath })
-  }
-
-  const entry = {
-    slug: manifest.slug,
-    version: manifest.version,
-    installedAt: new Date().toISOString(),
-    targetFeature,
-    files: [...fileMap.values()],
-    skippedFiles: skipped,
-    naming,
-  }
-  record.kits = (record.kits || []).filter((item) => !(item.slug === manifest.slug && item.version === manifest.version))
-  record.kits.push(entry)
-  writeInstallRecord(workspaceRoot, record)
-
-  const dependencies = manifest.dependencies || []
-
-  return {
-    ok: true,
-    operation: "apply",
-    source,
-    slug: manifest.slug,
-    version: manifest.version,
-    workspaceRoot,
-    installed: {
-      files: copied,
-      frontendFiles: copiedByKind.frontend,
-      backendFiles: copiedByKind.backend,
-      databaseFiles: copiedByKind.database,
-      skipped,
-      recordFile: ".dypai/kits/installed.json",
-    },
-    imports: imported,
-    backend: {
-      endpoints: backendEndpoints,
-      requiresPublish: Boolean(manifest.install?.requiresBackendPublish || backendEndpoints.length),
-    },
-    database: {
-      tables: databaseTables,
-      sqlFiles: copiedByKind.database,
-      schemaFile,
-      seedFile,
-      requiresExecuteSql: Boolean(manifest.install?.requiresExecuteSql || databaseTables.length),
-      applyWith: "execute_sql",
-      schemaRefresh: "automatic_after_successful_ddl",
-    },
-    dependencies,
-    nextSteps: [
-      ...(dependencies.length
-        ? [`Add any missing package dependencies to the target workspace package.json, then install them locally before building: ${dependencies.join(", ")}.`]
-        : []),
-      "Wire installed frontend components into the selected app page or route.",
-      ...(databaseTables.length ? [
-        `Before backend tests, ensure tables exist (${databaseTables.join(", ")}): read ${schemaFile || "the installed schema SQL"} and execute its safe CREATE/ALTER statements with execute_sql. Do not edit dypai/schema.sql; it refreshes automatically.`,
-      ] : []),
-      ...(backendEndpoints.length ? ["Run backend validation and endpoint tests for installed/renamed endpoints."] : []),
-      "Run frontend verification after wiring imports and data callbacks.",
-    ],
-  }
-}
-
-export const manageCapabilityKitTool = {
-  name: "manage_capability_kit",
-  description: "Inspect or install a local DYPAI capability kit. Use operation='inspect' after search when you need full manifest details, then operation='apply' to copy editable source into the workspace. Apply never executes SQL, publishes backend, deploys frontend, or installs npm packages.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      operation: { type: "string", enum: ["inspect", "apply"], description: "inspect returns manifest/assets. apply copies kit files into the workspace." },
-      slug: { type: "string" },
-      version: { type: "string", default: "1.0.0" },
-      source_uri: { type: "string", description: "Optional r2://... kit root from search results. Used when the kit is not available locally." },
-      targetFeature: { type: "string", description: "Domain/feature being built, e.g. hotel reservations." },
-      install: {
-        type: "object",
-        properties: {
-          frontend: { type: "boolean", default: true },
-          backend: { type: "boolean", default: true },
-          database: { type: "boolean", default: true },
-          examples: { type: "boolean", default: false },
-        },
-      },
-      naming: {
-        type: "object",
-        properties: {
-          entity: { type: "string", description: "Singular domain entity, e.g. reservation." },
-          endpointPrefix: { type: "string", description: "Plural endpoint/table-friendly domain name, e.g. reservations." },
-          tableName: { type: "string", description: "Database table name, e.g. reservations." },
-        },
-      },
-      target: {
-        type: "object",
-        properties: {
-          frontendDir: { type: "string" },
-          endpointDir: { type: "string" },
-          databaseDir: { type: "string" },
-        },
-      },
-      overwrite: { type: "string", enum: ["skip", "fail", "replace"], default: "skip" },
-      workspace_root: { type: "string", description: "Optional absolute path to the target app workspace." },
-      kits_root: { type: "string", description: "Optional local path to dypai-capability-kits. Pass this to force local authoring source; omit it to allow R2 fallback." },
-    },
-    required: ["operation", "slug"],
-  },
-  async execute(args) {
-    if (args?.operation === "inspect") return inspectCapabilityKit(args)
-    if (args?.operation === "apply") return applyCapabilityKit(args)
-    throw new Error("manage_capability_kit requires operation 'inspect' or 'apply'.")
-  },
-}