devvami 1.4.2 → 1.5.0

package/src/services/ai-env-deployer.js

@@ -0,0 +1,444 @@
+/**
+ * @module ai-env-deployer
+ * Translates dvmi's abstract CategoryEntry objects into actual filesystem writes
+ * (JSON mutations for MCP servers, markdown/TOML files for commands, skills, and agents)
+ * for each supported AI coding environment.
+ */
+
+import {readFile, writeFile, mkdir, rm} from 'node:fs/promises'
+import {existsSync} from 'node:fs'
+import {join, dirname} from 'node:path'
+import {homedir} from 'node:os'
+
+/** @import { CategoryEntry, CategoryType, EnvironmentId, DetectedEnvironment } from '../types.js' */
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Path & key resolution tables
+// ──────────────────────────────────────────────────────────────────────────────
+
+/**
+ * For each environment, the target JSON file path (relative to cwd or absolute)
+ * and the root key that holds the MCP server map.
+ *
+ * @type {Record<EnvironmentId, { resolvePath: (cwd: string) => string, mcpKey: string }>}
+ */
+const MCP_TARGETS = {
+  'vscode-copilot': {
+    resolvePath: (cwd) => join(cwd, '.vscode', 'mcp.json'),
+    mcpKey: 'servers',
+  },
+  'claude-code': {
+    resolvePath: (cwd) => join(cwd, '.mcp.json'),
+    mcpKey: 'mcpServers',
+  },
+  opencode: {
+    resolvePath: (cwd) => join(cwd, 'opencode.json'),
+    mcpKey: 'mcpServers',
+  },
+  'gemini-cli': {
+    resolvePath: (_cwd) => join(homedir(), '.gemini', 'settings.json'),
+    mcpKey: 'mcpServers',
+  },
+  'copilot-cli': {
+    resolvePath: (_cwd) => join(homedir(), '.copilot', 'mcp-config.json'),
+    mcpKey: 'mcpServers',
+  },
+}
+
+/**
+ * Resolve the target file path for a file-based entry (command, skill, agent).
+ *
+ * @param {string} name - Entry name (used as filename base)
+ * @param {CategoryType} type - Category type
+ * @param {EnvironmentId} envId - Target environment
+ * @param {string} cwd - Project working directory
+ * @returns {string} Absolute path to write
+ */
+function resolveFilePath(name, type, envId, cwd) {
+  switch (type) {
+    case 'command':
+      return resolveCommandPath(name, envId, cwd)
+    case 'skill':
+      return resolveSkillPath(name, envId, cwd)
+    case 'agent':
+      return resolveAgentPath(name, envId, cwd)
+    default:
+      throw new Error(`Unsupported file entry type: ${type}`)
+  }
+}
+
+/**
+ * @param {string} name
+ * @param {EnvironmentId} envId
+ * @param {string} cwd
+ * @returns {string}
+ */
+function resolveCommandPath(name, envId, cwd) {
+  switch (envId) {
+    case 'vscode-copilot':
+      return join(cwd, '.github', 'prompts', `${name}.prompt.md`)
+    case 'claude-code':
+      return join(cwd, '.claude', 'commands', `${name}.md`)
+    case 'opencode':
+      return join(cwd, '.opencode', 'commands', `${name}.md`)
+    case 'gemini-cli':
+      return join(homedir(), '.gemini', 'commands', `${name}.toml`)
+    case 'copilot-cli':
+      // shared path with vscode-copilot for commands
+      return join(cwd, '.github', 'prompts', `${name}.prompt.md`)
+    default:
+      throw new Error(`Unknown environment for command: ${envId}`)
+  }
+}
+
+/**
+ * @param {string} name
+ * @param {EnvironmentId} envId
+ * @param {string} cwd
+ * @returns {string}
+ */
+function resolveSkillPath(name, envId, cwd) {
+  switch (envId) {
+    case 'vscode-copilot':
+      // vscode uses a nested directory with SKILL.md inside
+      return join(cwd, '.github', 'skills', name, 'SKILL.md')
+    case 'claude-code':
+      return join(cwd, '.claude', 'skills', `${name}.md`)
+    case 'opencode':
+      return join(cwd, '.opencode', 'skills', `${name}.md`)
+    case 'copilot-cli':
+      return join(homedir(), '.copilot', 'skills', `${name}.md`)
+    default:
+      throw new Error(`Environment "${envId}" does not support skill entries`)
+  }
+}
+
+/**
+ * @param {string} name
+ * @param {EnvironmentId} envId
+ * @param {string} cwd
+ * @returns {string}
+ */
+function resolveAgentPath(name, envId, cwd) {
+  switch (envId) {
+    case 'vscode-copilot':
+      return join(cwd, '.github', 'agents', `${name}.agent.md`)
+    case 'claude-code':
+      return join(cwd, '.claude', 'agents', `${name}.md`)
+    case 'opencode':
+      return join(cwd, '.opencode', 'agents', `${name}.md`)
+    case 'copilot-cli':
+      return join(homedir(), '.copilot', 'agents', `${name}.md`)
+    default:
+      throw new Error(`Environment "${envId}" does not support agent entries`)
+  }
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// TOML rendering
+// ──────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Render a Gemini CLI command entry as a TOML string.
+ * No external TOML library is used — we generate the string directly.
+ *
+ * @param {string} description - Short description of the command
+ * @param {string} content - Prompt text content
+ * @returns {string} TOML-formatted string
+ */
+function renderGeminiToml(description, content) {
+  // Escape triple-quotes inside the content to prevent TOML parse errors
+  const safeContent = content.replace(/"""/g, '\\"\\"\\"')
+  return `description = ${JSON.stringify(description)}
+
+[prompt]
+text = """
+${safeContent}
+"""
+`
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// JSON helpers
+// ──────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Read a JSON file from disk. Returns an empty object when the file is missing.
+ * Throws if the file exists but cannot be parsed.
+ *
+ * @param {string} filePath - Absolute path to the JSON file
+ * @returns {Promise<Record<string, unknown>>}
+ */
+async function readJsonOrEmpty(filePath) {
+  if (!existsSync(filePath)) return {}
+  const raw = await readFile(filePath, 'utf8')
+  return JSON.parse(raw)
+}
+
+/**
+ * Write a value to disk as pretty-printed JSON, creating parent directories
+ * as needed.
+ *
+ * @param {string} filePath - Absolute path
+ * @param {unknown} data - Serialisable value
+ * @returns {Promise<void>}
+ */
+async function writeJson(filePath, data) {
+  const dir = dirname(filePath)
+  if (!existsSync(dir)) {
+    await mkdir(dir, {recursive: true})
+  }
+  await writeFile(filePath, JSON.stringify(data, null, 2), 'utf8')
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Build MCP server object from entry params
+// ──────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Convert an MCP entry's params into the server descriptor object written into
+ * the target JSON file.
+ *
+ * @param {import('../types.js').MCPParams} params
+ * @returns {Record<string, unknown>}
+ */
+function buildMCPServerObject(params) {
+  /** @type {Record<string, unknown>} */
+  const server = {}
+
+  if (params.command !== undefined) server.command = params.command
+  if (params.args !== undefined) server.args = params.args
+  if (params.env !== undefined) server.env = params.env
+  if (params.url !== undefined) server.url = params.url
+  if (params.transport !== undefined) server.type = params.transport
+
+  return server
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Public API — MCP
+// ──────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Deploy an MCP entry to a specific AI environment by merging it into the
+ * appropriate JSON config file. Creates the file (and parent directories) if
+ * it does not yet exist. Existing entries under other names are preserved.
+ *
+ * Skips silently when:
+ * - `entry` is falsy
+ * - `entry.type` is not `'mcp'`
+ * - `entry.params` is absent
+ *
+ * @param {CategoryEntry} entry - The MCP entry to deploy
+ * @param {EnvironmentId} envId - Target environment identifier
+ * @param {string} cwd - Project working directory (used for project-relative paths)
+ * @returns {Promise<void>}
+ */
+export async function deployMCPEntry(entry, envId, cwd) {
+  if (!entry || entry.type !== 'mcp' || !entry.params) return
+
+  const target = MCP_TARGETS[envId]
+  if (!target) return
+
+  const filePath = target.resolvePath(cwd)
+  const json = await readJsonOrEmpty(filePath)
+
+  if (!json[target.mcpKey] || typeof json[target.mcpKey] !== 'object') {
+    json[target.mcpKey] = {}
+  }
+
+  /** @type {Record<string, unknown>} */
+  const mcpKey = /** @type {any} */ (json[target.mcpKey])
+  mcpKey[entry.name] = buildMCPServerObject(/** @type {import('../types.js').MCPParams} */ (entry.params))
+
+  await writeJson(filePath, json)
+}
+
+/**
+ * Remove an MCP entry by name from a specific AI environment's JSON config file.
+ * If the file does not exist the function is a no-op.
+ * If the MCP key becomes empty after removal, it is kept as an empty object
+ * (the structure is preserved).
+ *
+ * @param {string} entryName - Name of the MCP server to remove
+ * @param {EnvironmentId} envId - Target environment identifier
+ * @param {string} cwd - Project working directory
+ * @returns {Promise<void>}
+ */
+export async function undeployMCPEntry(entryName, envId, cwd) {
+  const target = MCP_TARGETS[envId]
+  if (!target) return
+
+  const filePath = target.resolvePath(cwd)
+  if (!existsSync(filePath)) return
+
+  const json = await readJsonOrEmpty(filePath)
+
+  if (json[target.mcpKey] && typeof json[target.mcpKey] === 'object') {
+    delete (/** @type {any} */ (json[target.mcpKey])[entryName])
+  }
+
+  await writeJson(filePath, json)
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Public API — File-based entries
+// ──────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Deploy a file-based entry (command, skill, or agent) to a specific AI
+ * environment. Creates parent directories as needed.
+ *
+ * For Gemini CLI commands the output is TOML; for everything else it is the raw
+ * markdown content stored in `entry.params.content` or `entry.params.instructions`.
+ *
+ * For VS Code Copilot skills the directory structure `{name}/SKILL.md` is
+ * created automatically.
+ *
+ * Skips silently when:
+ * - `entry` is falsy
+ * - `entry.type` is `'mcp'` (wrong function)
+ * - `entry.params` is absent
+ *
+ * @param {CategoryEntry} entry - The entry to deploy
+ * @param {EnvironmentId} envId - Target environment identifier
+ * @param {string} cwd - Project working directory
+ * @returns {Promise<void>}
+ */
+export async function deployFileEntry(entry, envId, cwd) {
+  if (!entry || entry.type === 'mcp' || !entry.params) return
+
+  const filePath = resolveFilePath(entry.name, entry.type, envId, cwd)
+  const dir = dirname(filePath)
+
+  if (!existsSync(dir)) {
+    await mkdir(dir, {recursive: true})
+  }
+
+  const params = /** @type {any} */ (entry.params)
+
+  // Gemini CLI commands use TOML format
+  if (envId === 'gemini-cli' && entry.type === 'command') {
+    const description = params.description ?? ''
+    const content = params.content ?? ''
+    await writeFile(filePath, renderGeminiToml(description, content), 'utf8')
+    return
+  }
+
+  // All other file entries use markdown
+  const content = params.content ?? params.instructions ?? ''
+  await writeFile(filePath, content, 'utf8')
+}
+
+/**
+ * Remove a deployed file-based entry from disk. This is a no-op if the file
+ * does not exist.
+ *
+ * @param {string} entryName - Name of the entry (used to derive the file path)
+ * @param {CategoryType} type - Category type of the entry
+ * @param {EnvironmentId} envId - Target environment identifier
+ * @param {string} cwd - Project working directory
+ * @returns {Promise<void>}
+ */
+export async function undeployFileEntry(entryName, type, envId, cwd) {
+  if (type === 'mcp') return
+
+  const filePath = resolveFilePath(entryName, type, envId, cwd)
+  if (!existsSync(filePath)) return
+
+  await rm(filePath, {force: true})
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Public API — Composite helpers
+// ──────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Deploy an entry to all of its target environments that are currently detected
+ * and readable.
+ *
+ * - Environments listed in `entry.environments` but absent from `detectedEnvs`
+ *   are silently skipped.
+ * - Environments that are detected but have unreadable JSON config files are
+ *   also skipped (to avoid clobbering corrupt files).
+ *
+ * @param {CategoryEntry} entry - The entry to deploy
+ * @param {DetectedEnvironment[]} detectedEnvs - Environments found on the current machine
+ * @param {string} cwd - Project working directory
+ * @returns {Promise<void>}
+ */
+export async function deployEntry(entry, detectedEnvs, cwd) {
+  if (!entry) return
+
+  const detectedIds = new Set(detectedEnvs.map((e) => e.id))
+
+  for (const envId of entry.environments) {
+    if (!detectedIds.has(envId)) continue
+
+    const detectedEnv = detectedEnvs.find((e) => e.id === envId)
+    // Skip if the environment has unreadable JSON config files that correspond
+    // to the MCP target path (we don't want to overwrite corrupt files)
+    if (detectedEnv && entry.type === 'mcp') {
+      const target = MCP_TARGETS[envId]
+      if (target) {
+        const targetPath = target.resolvePath(cwd)
+        if (detectedEnv.unreadable.includes(targetPath)) continue
+      }
+    }
+
+    if (entry.type === 'mcp') {
+      await deployMCPEntry(entry, envId, cwd)
+    } else {
+      await deployFileEntry(entry, envId, cwd)
+    }
+  }
+}
+
+/**
+ * Undeploy an entry from all of its target environments that are currently
+ * detected. This is safe to call even when `entry` is `null` or `undefined`
+ * (it becomes a no-op).
+ *
+ * @param {CategoryEntry | null | undefined} entry - The entry to undeploy
+ * @param {DetectedEnvironment[]} detectedEnvs - Environments found on the current machine
+ * @param {string} cwd - Project working directory
+ * @returns {Promise<void>}
+ */
+export async function undeployEntry(entry, detectedEnvs, cwd) {
+  if (!entry) return
+
+  const detectedIds = new Set(detectedEnvs.map((e) => e.id))
+
+  for (const envId of entry.environments) {
+    if (!detectedIds.has(envId)) continue
+
+    if (entry.type === 'mcp') {
+      await undeployMCPEntry(entry.name, envId, cwd)
+    } else {
+      await undeployFileEntry(entry.name, entry.type, envId, cwd)
+    }
+  }
+}
+
+/**
+ * Reconcile all active entries against the currently detected environments.
+ *
+ * For each active entry, every detected environment listed in
+ * `entry.environments` is deployed (idempotent write). Environments that are
+ * listed but not currently detected are left untouched — we never undeploy on
+ * scan because the files may have been managed by the user directly
+ * (FR-004d: re-activation on re-detection).
+ *
+ * Inactive entries are not touched.
+ *
+ * @param {CategoryEntry[]} entries - All managed entries from the AI config store
+ * @param {DetectedEnvironment[]} detectedEnvs - Environments found on the current machine
+ * @param {string} cwd - Project working directory
+ * @returns {Promise<void>}
+ */
+export async function reconcileOnScan(entries, detectedEnvs, cwd) {
+  for (const entry of entries) {
+    if (!entry.active) continue
+    await deployEntry(entry, detectedEnvs, cwd)
+  }
+}

package/src/services/ai-env-scanner.js

@@ -0,0 +1,242 @@
+/**
+ * @module ai-env-scanner
+ * Detects AI coding environments by scanning well-known project and global config paths.
+ */
+
+import {existsSync, readFileSync} from 'node:fs'
+import {resolve, join} from 'node:path'
+import {homedir} from 'node:os'
+
+/** @import { CategoryType, EnvironmentId, PathStatus, CategoryCounts, DetectedEnvironment, CategoryEntry } from '../types.js' */
+
+/**
+ * @typedef {Object} PathSpec
+ * @property {string} path - Relative (project) or absolute (global) path string
+ * @property {boolean} isJson - Whether to attempt JSON.parse after reading
+ */
+
+/**
+ * @typedef {Object} EnvironmentDef
+ * @property {EnvironmentId} id
+ * @property {string} name - Display name
+ * @property {PathSpec[]} projectPaths - Paths relative to cwd
+ * @property {PathSpec[]} globalPaths - Absolute paths (resolved from homedir)
+ * @property {CategoryType[]} supportedCategories
+ */
+
+/**
+ * All recognised AI coding environments with their detection paths and capabilities.
+ * @type {Readonly<EnvironmentDef[]>}
+ */
+export const ENVIRONMENTS = Object.freeze([
+  {
+    id: /** @type {EnvironmentId} */ ('vscode-copilot'),
+    name: 'VS Code Copilot',
+    projectPaths: [
+      {path: '.github/copilot-instructions.md', isJson: false},
+      {path: '.vscode/mcp.json', isJson: true},
+      {path: '.github/instructions/', isJson: false},
+      {path: '.github/prompts/', isJson: false},
+      {path: '.github/agents/', isJson: false},
+      {path: '.github/skills/', isJson: false},
+    ],
+    globalPaths: [],
+    supportedCategories: /** @type {CategoryType[]} */ (['mcp', 'command', 'skill', 'agent']),
+  },
+  {
+    id: /** @type {EnvironmentId} */ ('claude-code'),
+    name: 'Claude Code',
+    projectPaths: [
+      {path: 'CLAUDE.md', isJson: false},
+      {path: '.mcp.json', isJson: true},
+      {path: '.claude/commands/', isJson: false},
+      {path: '.claude/skills/', isJson: false},
+      {path: '.claude/agents/', isJson: false},
+      {path: '.claude/rules/', isJson: false},
+    ],
+    globalPaths: [],
+    supportedCategories: /** @type {CategoryType[]} */ (['mcp', 'command', 'skill', 'agent']),
+  },
+  {
+    id: /** @type {EnvironmentId} */ ('opencode'),
+    name: 'OpenCode',
+    projectPaths: [
+      {path: 'AGENTS.md', isJson: false},
+      {path: '.opencode/commands/', isJson: false},
+      {path: '.opencode/skills/', isJson: false},
+      {path: '.opencode/agents/', isJson: false},
+      {path: 'opencode.json', isJson: true},
+    ],
+    globalPaths: [
+      {path: '~/.config/opencode/opencode.json', isJson: true},
+      {path: '~/.config/opencode/commands/', isJson: false},
+      {path: '~/.config/opencode/agents/', isJson: false},
+      {path: '~/.config/opencode/skills/', isJson: false},
+    ],
+    supportedCategories: /** @type {CategoryType[]} */ (['mcp', 'command', 'skill', 'agent']),
+  },
+  {
+    id: /** @type {EnvironmentId} */ ('gemini-cli'),
+    name: 'Gemini CLI',
+    projectPaths: [{path: 'GEMINI.md', isJson: false}],
+    globalPaths: [
+      {path: '~/.gemini/settings.json', isJson: true},
+      {path: '~/.gemini/commands/', isJson: false},
+    ],
+    supportedCategories: /** @type {CategoryType[]} */ (['mcp', 'command']),
+  },
+  {
+    id: /** @type {EnvironmentId} */ ('copilot-cli'),
+    name: 'GitHub Copilot CLI',
+    projectPaths: [],
+    globalPaths: [
+      {path: '~/.copilot/config.json', isJson: true},
+      {path: '~/.copilot/mcp-config.json', isJson: true},
+      {path: '~/.copilot/agents/', isJson: false},
+      {path: '~/.copilot/skills/', isJson: false},
+      {path: '~/.copilot/copilot-instructions.md', isJson: false},
+    ],
+    supportedCategories: /** @type {CategoryType[]} */ (['mcp', 'command', 'skill', 'agent']),
+  },
+])
+
+/**
+ * Resolve a path spec into an absolute path.
+ * Project paths are resolved relative to `cwd`; global paths have their `~/` prefix
+ * replaced with the actual home directory.
+ *
+ * @param {PathSpec} spec
+ * @param {string} cwd
+ * @param {boolean} isGlobal
+ * @returns {string}
+ */
+function resolvePathSpec(spec, cwd, isGlobal) {
+  if (isGlobal) {
+    // Global paths are stored with a leading `~/`
+    return resolve(join(homedir(), spec.path.replace(/^~\//, '')))
+  }
+  return resolve(join(cwd, spec.path))
+}
+
+/**
+ * Build a PathStatus for one path spec.
+ * For JSON files that exist, attempt to parse them; failure marks the path as unreadable.
+ *
+ * @param {PathSpec} spec
+ * @param {string} absolutePath
+ * @param {string[]} unreadable - Mutable array; unreadable paths are pushed here
+ * @returns {PathStatus}
+ */
+function evaluatePathSpec(spec, absolutePath, unreadable) {
+  const exists = existsSync(absolutePath)
+
+  if (!exists) {
+    return {path: absolutePath, exists: false, readable: false}
+  }
+
+  if (!spec.isJson) {
+    return {path: absolutePath, exists: true, readable: true}
+  }
+
+  // JSON file — try to parse
+  try {
+    JSON.parse(readFileSync(absolutePath, 'utf8'))
+    return {path: absolutePath, exists: true, readable: true}
+  } catch {
+    unreadable.push(absolutePath)
+    return {path: absolutePath, exists: true, readable: false}
+  }
+}
+
+/**
+ * Compute the detection scope based on which path groups produced hits.
+ *
+ * @param {PathStatus[]} projectStatuses
+ * @param {PathStatus[]} globalStatuses
+ * @returns {'project'|'global'|'both'}
+ */
+function computeScope(projectStatuses, globalStatuses) {
+  const hasProject = projectStatuses.some((s) => s.exists)
+  const hasGlobal = globalStatuses.some((s) => s.exists)
+
+  if (hasProject && hasGlobal) return 'both'
+  if (hasGlobal) return 'global'
+  return 'project'
+}
+
+/**
+ * Scan the filesystem for each known AI coding environment and return only those
+ * that were detected (i.e. at least one config path exists on disk).
+ *
+ * @param {string} [cwd] - Working directory for project-relative path resolution (defaults to process.cwd())
+ * @returns {DetectedEnvironment[]} Detected environments only
+ */
+export function scanEnvironments(cwd = process.cwd()) {
+  /** @type {DetectedEnvironment[]} */
+  const detected = []
+
+  for (const env of ENVIRONMENTS) {
+    /** @type {string[]} */
+    const unreadable = []
+
+    const projectStatuses = env.projectPaths.map((spec) => {
+      const absPath = resolvePathSpec(spec, cwd, false)
+      return evaluatePathSpec(spec, absPath, unreadable)
+    })
+
+    const globalStatuses = env.globalPaths.map((spec) => {
+      const absPath = resolvePathSpec(spec, cwd, true)
+      return evaluatePathSpec(spec, absPath, unreadable)
+    })
+
+    const isDetected = [...projectStatuses, ...globalStatuses].some((s) => s.exists)
+
+    if (!isDetected) continue
+
+    detected.push({
+      id: env.id,
+      name: env.name,
+      detected: true,
+      projectPaths: projectStatuses,
+      globalPaths: globalStatuses,
+      unreadable,
+      supportedCategories: env.supportedCategories,
+      counts: {mcp: 0, command: 0, skill: 0, agent: 0},
+      scope: computeScope(projectStatuses, globalStatuses),
+    })
+  }
+
+  return detected
+}
+
+/**
+ * Filter detected environments to those that support a given category type.
+ *
+ * @param {CategoryType} type - Category type to filter by
+ * @param {DetectedEnvironment[]} detectedEnvs - Array of detected environments from {@link scanEnvironments}
+ * @returns {EnvironmentId[]} IDs of environments that support the given type
+ */
+export function getCompatibleEnvironments(type, detectedEnvs) {
+  return detectedEnvs.filter((env) => env.supportedCategories.includes(type)).map((env) => env.id)
+}
+
+/**
+ * Count active entries from the AI config store that target a given environment,
+ * grouped by category type.
+ *
+ * @param {EnvironmentId} envId - Environment to count entries for
+ * @param {CategoryEntry[]} entries - All entries from the AI config store
+ * @returns {CategoryCounts} Per-category active entry counts
+ */
+export function computeCategoryCounts(envId, entries) {
+  /** @type {CategoryCounts} */
+  const counts = {mcp: 0, command: 0, skill: 0, agent: 0}
+
+  for (const entry of entries) {
+    if (entry.active && entry.environments.includes(envId)) {
+      counts[entry.type] = (counts[entry.type] ?? 0) + 1
+    }
+  }
+
+  return counts
+}

package/src/services/audit-detector.js

@@ -1,5 +1,5 @@
-import { existsSync } from 'node:fs'
-import { resolve, join } from 'node:path'
+import {existsSync} from 'node:fs'
+import {resolve, join} from 'node:path'
 
 /** @import { PackageEcosystem } from '../types.js' */