@bldg-7/cc-plugin-loader 0.1.0

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@bldg-7/cc-plugin-loader",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "src/index.ts",
+  "files": ["src"],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "changeset": "changeset",
+    "version": "changeset version",
+    "release": "npm publish"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "latest",
+    "js-yaml": "^4.1.0"
+  },
+  "devDependencies": {
+    "@changesets/changelog-github": "^0.6.0",
+    "@changesets/cli": "^2.30.0",
+    "@types/js-yaml": "^4.0.9",
+    "bun-types": "latest",
+    "typescript": "^5.7.0"
+  }
+}

package/src/constants.ts

@@ -0,0 +1,30 @@
+import { join } from "path";
+import { homedir } from "os";
+
+/** Claude Code tool name → OpenCode tool name */
+export const TOOL_NAME_MAP: Record<string, string> = {
+  Bash: "bash",
+  Read: "read",
+  Write: "write",
+  Edit: "edit",
+  Glob: "glob",
+  Grep: "grep",
+  WebFetch: "webfetch",
+  WebSearch: "websearch",
+  Agent: "agent",
+  NotebookEdit: "notebookedit",
+};
+
+/** Claude Code model alias → OpenCode model ID */
+export const MODEL_MAP: Record<string, string> = {
+  sonnet: "anthropic/claude-sonnet-4-6",
+  opus: "anthropic/claude-opus-4-6",
+  haiku: "anthropic/claude-haiku-4-5-20251001",
+};
+
+export const INSTALLED_PLUGINS_PATH = join(
+  homedir(),
+  ".claude",
+  "plugins",
+  "installed_plugins.json",
+);

package/src/hooks/command.ts

@@ -0,0 +1,49 @@
+import { readFile } from "fs/promises";
+import { parseFrontmatter } from "../parser.js";
+import type { ParsedPlugin, ParsedSkill, ParsedCommand } from "../types.js";
+
+type Loadable = ParsedSkill | ParsedCommand;
+
+export function createCommandHook(plugins: ParsedPlugin[]) {
+  // Build lookup map: qualifiedName → Loadable
+  const lookup = new Map<string, Loadable>();
+
+  for (const plugin of plugins) {
+    for (const skill of plugin.skills) {
+      lookup.set(skill.qualifiedName, skill);
+    }
+    for (const cmd of plugin.commands) {
+      lookup.set(cmd.qualifiedName, cmd);
+    }
+  }
+
+  return async (
+    input: { command: string; sessionID: string; arguments: string },
+    output: { parts: Array<{ type: string; [key: string]: unknown }> },
+  ): Promise<void> => {
+    const item = lookup.get(input.command);
+    if (!item) return; // Not our command, leave parts untouched
+
+    // Lazy-load content
+    let content: string;
+    if (item._content) {
+      content = item._content;
+    } else {
+      try {
+        const raw = await readFile(item.contentPath, "utf-8");
+        const { body } = parseFrontmatter<unknown>(raw);
+        item._content = body;
+        content = body;
+      } catch (e) {
+        content = `[cc-plugin-loader] Failed to load ${item.contentPath}: ${e}`;
+      }
+    }
+
+    // Append ARGUMENTS (Claude Code pattern)
+    const fullContent = input.arguments
+      ? `${content}\n\nARGUMENTS: ${input.arguments}`
+      : content;
+
+    output.parts = [{ type: "text", text: fullContent }];
+  };
+}

package/src/hooks/config.ts

@@ -0,0 +1,60 @@
+import type { Config } from "@opencode-ai/sdk";
+import { TOOL_NAME_MAP, MODEL_MAP } from "../constants.js";
+import type { ParsedPlugin } from "../types.js";
+
+function mapTools(tools: string[]): Record<string, boolean> {
+  const result: Record<string, boolean> = {};
+  for (const tool of tools) {
+    const mapped = TOOL_NAME_MAP[tool] || tool.toLowerCase();
+    result[mapped] = true;
+  }
+  return result;
+}
+
+export function createConfigHook(plugins: ParsedPlugin[]) {
+  return async (config: Config): Promise<void> => {
+    if (!config.agent) config.agent = {};
+    if (!config.mcp) config.mcp = {};
+    if (!config.command) config.command = {};
+
+    for (const plugin of plugins) {
+      // Register agents
+      for (const agent of plugin.agents) {
+        const key = `${plugin.name}-${agent.name}`;
+        config.agent[key] = {
+          description: agent.description,
+          mode: "subagent",
+          prompt: agent.prompt,
+          tools: mapTools(agent.tools),
+          ...(agent.model && { model: MODEL_MAP[agent.model] || agent.model }),
+          ...(agent.maxTurns && { maxSteps: agent.maxTurns }),
+        };
+      }
+
+      // Register MCP servers
+      for (const mcp of plugin.mcpServers) {
+        config.mcp[mcp.qualifiedName] = {
+          type: "local" as const,
+          command: [mcp.command, ...mcp.args],
+          environment: mcp.env,
+        };
+      }
+
+      // Register skills as commands
+      for (const skill of plugin.skills) {
+        config.command[skill.qualifiedName] = {
+          template: "$ARGUMENTS",
+          description: skill.description,
+        };
+      }
+
+      // Register commands
+      for (const cmd of plugin.commands) {
+        config.command[cmd.qualifiedName] = {
+          template: "$ARGUMENTS",
+          description: cmd.description,
+        };
+      }
+    }
+  };
+}

package/src/hooks/env.ts

@@ -0,0 +1,20 @@
+import type { ParsedPlugin } from "../types.js";
+
+export function createEnvHook(plugins: ParsedPlugin[]) {
+  // Pre-build env map
+  const envVars: Record<string, string> = {};
+
+  for (const plugin of plugins) {
+    const safeName = plugin.name.replace(/-/g, "_").toUpperCase();
+    envVars[`CLAUDE_PLUGIN_ROOT_${safeName}`] = plugin.installPath;
+    // Last plugin wins for backwards compat
+    envVars["CLAUDE_PLUGIN_ROOT"] = plugin.installPath;
+  }
+
+  return async (
+    _input: { cwd: string; sessionID?: string; callID?: string },
+    output: { env: Record<string, string> },
+  ): Promise<void> => {
+    Object.assign(output.env, envVars);
+  };
+}

package/src/hooks/system.ts

@@ -0,0 +1,40 @@
+import type { ParsedPlugin } from "../types.js";
+
+export function createSystemHook(plugins: ParsedPlugin[]) {
+  // Pre-build static strings at init time
+  const systemParts: string[] = [];
+
+  for (const plugin of plugins) {
+    // Inject CLAUDE.md
+    if (plugin.claudeMd) {
+      systemParts.push(
+        `# ${plugin.name} Plugin Instructions\n\n${plugin.claudeMd}`,
+      );
+    }
+
+    // Build skill/command summary
+    const entries: string[] = [];
+
+    for (const skill of plugin.skills) {
+      entries.push(`- ${plugin.name}:${skill.name}: ${skill.description}`);
+    }
+    for (const cmd of plugin.commands) {
+      entries.push(`- ${plugin.name}:${cmd.name}: ${cmd.description}`);
+    }
+
+    if (entries.length > 0) {
+      systemParts.push(
+        `# Available commands from ${plugin.name} plugin\n\nThe following skills are available for use with the Skill tool:\n\n${entries.join("\n")}`,
+      );
+    }
+  }
+
+  return async (
+    _input: { sessionID?: string; model: unknown },
+    output: { system: string[] },
+  ): Promise<void> => {
+    for (const part of systemParts) {
+      output.system.push(part);
+    }
+  };
+}

package/src/index.ts

@@ -0,0 +1,43 @@
+import type { Plugin } from "@opencode-ai/plugin";
+import { loadInstalledPlugins } from "./registry.js";
+import { loadPlugin } from "./loader.js";
+import { createConfigHook } from "./hooks/config.js";
+import { createSystemHook } from "./hooks/system.js";
+import { createCommandHook } from "./hooks/command.js";
+import { createEnvHook } from "./hooks/env.js";
+import type { ParsedPlugin } from "./types.js";
+
+const plugin: Plugin = async (input) => {
+  const installations = await loadInstalledPlugins({
+    directory: input.directory,
+    worktree: input.worktree,
+  });
+
+  if (!installations.length) {
+    console.warn("[cc-plugin-loader] No matching plugins found");
+    return {};
+  }
+
+  const loaded = await Promise.all(installations.map(loadPlugin));
+  const plugins: ParsedPlugin[] = loaded.filter(
+    (p): p is ParsedPlugin => p !== null,
+  );
+
+  if (!plugins.length) {
+    console.warn("[cc-plugin-loader] All plugins failed to load");
+    return {};
+  }
+
+  console.log(
+    `[cc-plugin-loader] Loaded ${plugins.length} plugin(s): ${plugins.map((p) => p.name).join(", ")}`,
+  );
+
+  return {
+    config: createConfigHook(plugins),
+    "experimental.chat.system.transform": createSystemHook(plugins),
+    "command.execute.before": createCommandHook(plugins),
+    "shell.env": createEnvHook(plugins),
+  };
+};
+
+export default plugin;

package/src/loader.ts

@@ -0,0 +1,254 @@
+import { readFile, readdir, stat } from "fs/promises";
+import { join, basename } from "path";
+import { parseFrontmatter, normalizeTools } from "./parser.js";
+import type {
+  PluginManifest,
+  PluginInstallation,
+  SkillFrontmatter,
+  AgentFrontmatter,
+  CommandFrontmatter,
+  McpConfig,
+  ParsedPlugin,
+  ParsedSkill,
+  ParsedAgent,
+  ParsedCommand,
+  ParsedMcp,
+} from "./types.js";
+
+async function readFileSafe(path: string): Promise<string | null> {
+  try {
+    return await readFile(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+async function dirExists(path: string): Promise<boolean> {
+  try {
+    return (await stat(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+export async function loadPlugin(
+  inst: PluginInstallation & { pluginKey: string },
+): Promise<ParsedPlugin | null> {
+  const { installPath, pluginKey } = inst;
+
+  // Read manifest
+  const manifestRaw = await readFileSafe(
+    join(installPath, ".claude-plugin", "plugin.json"),
+  );
+  let manifest: PluginManifest;
+  if (manifestRaw) {
+    try {
+      manifest = JSON.parse(manifestRaw);
+    } catch {
+      console.warn(
+        `[cc-plugin-loader] Failed to parse plugin.json for ${pluginKey}`,
+      );
+      return null;
+    }
+  } else {
+    // Derive name from key (e.g. "my-plugin@registry" → "my-plugin")
+    manifest = { name: pluginKey.split("@")[0] };
+  }
+
+  const pluginName = manifest.name;
+
+  const [claudeMd, skills, agents, commands, mcpServers] = await Promise.all([
+    readFileSafe(join(installPath, "CLAUDE.md")),
+    loadSkills(installPath, pluginName),
+    loadAgents(installPath, pluginName),
+    loadCommands(installPath, pluginName),
+    loadMcpServers(installPath, pluginName),
+  ]);
+
+  return {
+    name: pluginName,
+    installPath,
+    claudeMd: claudeMd ?? undefined,
+    skills,
+    agents,
+    commands,
+    mcpServers,
+  };
+}
+
+async function loadSkills(
+  installPath: string,
+  pluginName: string,
+): Promise<ParsedSkill[]> {
+  const skillsDir = join(installPath, "skills");
+  if (!(await dirExists(skillsDir))) return [];
+
+  const entries = await readdir(skillsDir, { withFileTypes: true });
+  const skills: ParsedSkill[] = [];
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+
+    const skillMdPath = join(skillsDir, entry.name, "SKILL.md");
+    const raw = await readFileSafe(skillMdPath);
+    if (!raw) continue;
+
+    try {
+      const { frontmatter } = parseFrontmatter<SkillFrontmatter>(raw);
+      const name = frontmatter.name || entry.name;
+      skills.push({
+        pluginName,
+        name,
+        qualifiedName: `${pluginName}:${name}`,
+        description: frontmatter.description || "",
+        tools: normalizeTools(frontmatter),
+        contentPath: skillMdPath,
+      });
+    } catch (e) {
+      console.warn(
+        `[cc-plugin-loader] Failed to parse skill ${entry.name} in ${pluginName}:`,
+        e,
+      );
+    }
+  }
+
+  return skills;
+}
+
+async function loadAgents(
+  installPath: string,
+  pluginName: string,
+): Promise<ParsedAgent[]> {
+  const agentsDir = join(installPath, "agents");
+  if (!(await dirExists(agentsDir))) return [];
+
+  const entries = await readdir(agentsDir, { withFileTypes: true });
+  const agents: ParsedAgent[] = [];
+
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+
+    const agentPath = join(agentsDir, entry.name);
+    const raw = await readFileSafe(agentPath);
+    if (!raw) continue;
+
+    try {
+      const { frontmatter, body } = parseFrontmatter<AgentFrontmatter>(raw);
+      const name = frontmatter.name || basename(entry.name, ".md");
+
+      // Replace ${CLAUDE_PLUGIN_ROOT} with actual installPath
+      const prompt = body.replaceAll("${CLAUDE_PLUGIN_ROOT}", installPath);
+
+      agents.push({
+        pluginName,
+        name,
+        description: frontmatter.description || "",
+        model: frontmatter.model,
+        tools: normalizeTools(frontmatter),
+        maxTurns: frontmatter.maxTurns,
+        prompt,
+      });
+    } catch (e) {
+      console.warn(
+        `[cc-plugin-loader] Failed to parse agent ${entry.name} in ${pluginName}:`,
+        e,
+      );
+    }
+  }
+
+  return agents;
+}
+
+async function loadCommands(
+  installPath: string,
+  pluginName: string,
+): Promise<ParsedCommand[]> {
+  const commandsDir = join(installPath, "commands");
+  if (!(await dirExists(commandsDir))) return [];
+
+  const entries = await readdir(commandsDir, { withFileTypes: true });
+  const commands: ParsedCommand[] = [];
+
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+
+    const cmdPath = join(commandsDir, entry.name);
+    const raw = await readFileSafe(cmdPath);
+    if (!raw) continue;
+
+    try {
+      const { frontmatter } = parseFrontmatter<CommandFrontmatter>(raw);
+      const name = frontmatter.name || basename(entry.name, ".md");
+      commands.push({
+        pluginName,
+        name,
+        qualifiedName: `${pluginName}:${name}`,
+        description: frontmatter.description || "",
+        contentPath: cmdPath,
+      });
+    } catch (e) {
+      console.warn(
+        `[cc-plugin-loader] Failed to parse command ${entry.name} in ${pluginName}:`,
+        e,
+      );
+    }
+  }
+
+  return commands;
+}
+
+async function loadMcpServers(
+  installPath: string,
+  pluginName: string,
+): Promise<ParsedMcp[]> {
+  const mcpPath = join(installPath, ".mcp.json");
+  const raw = await readFileSafe(mcpPath);
+  if (!raw) return [];
+
+  let config: McpConfig;
+  try {
+    config = JSON.parse(raw);
+  } catch {
+    console.warn(
+      `[cc-plugin-loader] Failed to parse .mcp.json in ${pluginName}`,
+    );
+    return [];
+  }
+
+  if (!config.mcpServers) return [];
+
+  const servers: ParsedMcp[] = [];
+  for (const [serverName, server] of Object.entries(config.mcpServers)) {
+    // Expand env variables
+    const env: Record<string, string> = {};
+    if (server.env) {
+      for (const [k, v] of Object.entries(server.env)) {
+        env[k] = expandEnv(v);
+      }
+    }
+
+    servers.push({
+      pluginName,
+      serverName,
+      qualifiedName: `${pluginName}-${serverName}`,
+      command: server.command,
+      args: server.args || [],
+      env,
+    });
+  }
+
+  return servers;
+}
+
+function expandEnv(value: string): string {
+  return value.replace(/\$\{([^}]+)\}/g, (_match, varName) => {
+    const val = process.env[varName];
+    if (val === undefined) {
+      console.warn(
+        `[cc-plugin-loader] Environment variable ${varName} is not set`,
+      );
+      return "";
+    }
+    return val;
+  });
+}

package/src/parser.ts

@@ -0,0 +1,34 @@
+import yaml from "js-yaml";
+
+export interface Parsed<T> {
+  frontmatter: T;
+  body: string;
+}
+
+const FM_REGEX = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+
+export function parseFrontmatter<T>(content: string): Parsed<T> {
+  const match = content.match(FM_REGEX);
+  if (!match) {
+    return { frontmatter: {} as T, body: content };
+  }
+  const frontmatter = (yaml.load(match[1]) ?? {}) as T;
+  const body = match[2].trim();
+  return { frontmatter, body };
+}
+
+/**
+ * Normalize tools from either `allowed-tools` (YAML array) or `tools` (comma-separated string).
+ */
+export function normalizeTools(fm: {
+  "allowed-tools"?: string[];
+  tools?: string;
+}): string[] {
+  if (fm["allowed-tools"] && Array.isArray(fm["allowed-tools"])) {
+    return fm["allowed-tools"];
+  }
+  if (fm.tools && typeof fm.tools === "string") {
+    return fm.tools.split(",").map((t) => t.trim()).filter(Boolean);
+  }
+  return [];
+}

package/src/registry.ts

@@ -0,0 +1,118 @@
+import { readFile } from "fs/promises";
+import { join, resolve } from "path";
+import { INSTALLED_PLUGINS_PATH } from "./constants.js";
+import type {
+  InstalledPluginsFile,
+  InstalledPluginsFileV1,
+  InstalledPluginsFileV2,
+  PluginInstallation,
+} from "./types.js";
+
+interface RegistryContext {
+  directory: string;
+  worktree: string;
+}
+
+/**
+ * Convert V1 format to V2.
+ * V1 has no scope — all entries become scope:"user".
+ * V1 may or may not have installPath; if missing, derive from plugin key + version.
+ */
+function convertV1toV2(v1: InstalledPluginsFileV1): InstalledPluginsFileV2 {
+  const plugins: Record<string, PluginInstallation[]> = {};
+  for (const [key, entry] of Object.entries(v1.plugins)) {
+    const installPath =
+      entry.installPath || deriveInstallPath(key, entry.version);
+    plugins[key] = [
+      {
+        scope: "user",
+        installPath,
+        version: entry.version,
+        installedAt: entry.installedAt,
+        lastUpdated: entry.lastUpdated,
+        gitCommitSha: entry.gitCommitSha,
+      },
+    ];
+  }
+  return { version: 2, plugins };
+}
+
+/** Replicate Claude Code's cache path derivation: ~/.claude/plugins/cache/{marketplace}/{name}/{version} */
+function deriveInstallPath(key: string, version: string): string {
+  const [name, marketplace] = key.includes("@")
+    ? key.split("@")
+    : [key, "unknown"];
+  const safeMp = (marketplace || "unknown").replace(/[^a-zA-Z0-9\-_]/g, "-");
+  const safeName = (name || key).replace(/[^a-zA-Z0-9\-_]/g, "-");
+  const safeVer = version.replace(/[^a-zA-Z0-9\-_.]/g, "-");
+  return join(INSTALLED_PLUGINS_PATH, "..", "cache", safeMp, safeName, safeVer);
+}
+
+function normalizeFile(raw: unknown): InstalledPluginsFileV2 {
+  const data = raw as InstalledPluginsFile;
+  const version = typeof data?.version === "number" ? data.version : 1;
+  if (version === 1) {
+    console.log("[cc-plugin-loader] Converting V1 installed_plugins.json to V2");
+    return convertV1toV2(data as InstalledPluginsFileV1);
+  }
+  return data as InstalledPluginsFileV2;
+}
+
+export async function loadInstalledPlugins(
+  ctx: RegistryContext,
+): Promise<(PluginInstallation & { pluginKey: string })[]> {
+  let data: InstalledPluginsFileV2;
+  try {
+    const raw = await readFile(INSTALLED_PLUGINS_PATH, "utf-8");
+    data = normalizeFile(JSON.parse(raw));
+  } catch {
+    console.warn(
+      `[cc-plugin-loader] installed_plugins.json not found at ${INSTALLED_PLUGINS_PATH}`,
+    );
+    return [];
+  }
+
+  const dir = resolve(ctx.directory);
+  const wt = resolve(ctx.worktree);
+  const seen = new Set<string>();
+  const result: (PluginInstallation & { pluginKey: string })[] = [];
+
+  for (const [key, installations] of Object.entries(data.plugins)) {
+    for (const inst of installations) {
+      if (!matchesScope(inst, dir, wt)) continue;
+
+      // Deduplicate by installPath
+      const dedup = `${key}::${inst.installPath}`;
+      if (seen.has(dedup)) continue;
+      seen.add(dedup);
+
+      result.push({ ...inst, pluginKey: key });
+    }
+  }
+
+  return result;
+}
+
+function matchesScope(
+  inst: PluginInstallation,
+  dir: string,
+  worktree: string,
+): boolean {
+  switch (inst.scope) {
+    case "user":
+      return true;
+    case "project": {
+      if (!inst.projectPath) return false;
+      const pp = resolve(inst.projectPath);
+      return dir === pp || worktree === pp;
+    }
+    case "local": {
+      if (!inst.projectPath) return false;
+      const pp = resolve(inst.projectPath);
+      return dir.startsWith(pp + "/") || dir === pp ||
+        worktree.startsWith(pp + "/") || worktree === pp;
+    }
+    default:
+      return false;
+  }
+}

package/src/types.ts

@@ -0,0 +1,124 @@
+// ── Source types (Claude Code plugin format) ──
+
+/** V1: each plugin key maps to a single entry (no scope, no array) */
+export interface InstalledPluginsFileV1 {
+  version: 1;
+  plugins: Record<string, PluginInstallationV1>;
+}
+
+export interface PluginInstallationV1 {
+  version: string;
+  installedAt: string;
+  lastUpdated?: string;
+  installPath: string;
+  gitCommitSha?: string;
+}
+
+/** V2: each plugin key maps to an array of scoped entries */
+export interface InstalledPluginsFileV2 {
+  version: 2;
+  plugins: Record<string, PluginInstallation[]>;
+}
+
+export type InstalledPluginsFile = InstalledPluginsFileV1 | InstalledPluginsFileV2;
+
+export interface PluginInstallation {
+  scope: "user" | "project" | "local";
+  installPath: string;
+  projectPath?: string;
+  version: string;
+  installedAt: string;
+  lastUpdated?: string;
+  gitCommitSha?: string;
+}
+
+export interface PluginManifest {
+  name: string;
+  description?: string;
+  version?: string;
+  author?: { name: string };
+  repository?: string;
+  license?: string;
+}
+
+export interface SkillFrontmatter {
+  name?: string;
+  description?: string;
+  "allowed-tools"?: string[];
+  tools?: string;
+}
+
+export interface AgentFrontmatter {
+  name: string;
+  description: string;
+  model?: string;
+  "allowed-tools"?: string[];
+  tools?: string;
+  maxTurns?: number;
+}
+
+export interface CommandFrontmatter {
+  name?: string;
+  description?: string;
+}
+
+export interface McpServerConfig {
+  type: "stdio";
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+}
+
+export interface McpConfig {
+  mcpServers: Record<string, McpServerConfig>;
+}
+
+// ── Parsed types (intermediate representation) ──
+
+export interface ParsedSkill {
+  pluginName: string;
+  name: string;
+  qualifiedName: string;
+  description: string;
+  tools: string[];
+  contentPath: string;
+  _content?: string;
+}
+
+export interface ParsedAgent {
+  pluginName: string;
+  name: string;
+  description: string;
+  model?: string;
+  tools: string[];
+  maxTurns?: number;
+  prompt: string;
+}
+
+export interface ParsedCommand {
+  pluginName: string;
+  name: string;
+  qualifiedName: string;
+  description: string;
+  contentPath: string;
+  _content?: string;
+}
+
+export interface ParsedMcp {
+  pluginName: string;
+  serverName: string;
+  qualifiedName: string;
+  command: string;
+  args: string[];
+  env: Record<string, string>;
+}
+
+export interface ParsedPlugin {
+  name: string;
+  installPath: string;
+  claudeMd?: string;
+  skills: ParsedSkill[];
+  agents: ParsedAgent[];
+  commands: ParsedCommand[];
+  mcpServers: ParsedMcp[];
+}