@b-apm/integration-claude 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sdju
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,49 @@
+# @b-apm/integration-claude
+
+> **UNSTABLE:** Early public release. APIs and on-disk layouts may change without a major bump. Not production-ready.
+
+Claude Code **runtime** host for bapm, plus Anthropic **marketplace pack** mapper in the same package.
+
+## Dual surface
+
+| Capability                | Export                                                  | When                                 |
+| ------------------------- | ------------------------------------------------------- | ------------------------------------ |
+| Runtime install / compile | `createClaudeIntegration` / `createIntegration`         | `targets.claude` / `--target claude` |
+| Marketplace pack          | `claudeMarketplaceIntegration` / `mapClaudeMarketplace` | `bapm pack --marketplace claude`     |
+
+Marketplace mapping stays available without activating the runtime factory.
+
+## Detection vs forced target
+
+| Mode                           | When active                                              | Creates roots?                                                    |
+| ------------------------------ | -------------------------------------------------------- | ----------------------------------------------------------------- |
+| **Auto-detect**                | `.claude/` **directory** **or** project-root `CLAUDE.md` | Only when materialize / configureMcp runs after a positive detect |
+| **Forced** (`--target claude`) | Explicit forced target id, even if detect is false       | MAY `mkdir` `.claude/` as needed                                  |
+
+Auto-detect without force MUST NOT create `.claude/` solely for MCP opt-in.
+
+## Deploy roots
+
+- `.claude` — skills, rules, agents, commands, hooks settings/scripts, ownership sidecar
+- `.` — project `.mcp.json` and compile `CLAUDE.md` only (basename allowlist in writers)
+
+## Materialize routing
+
+| Primitive type | Destination                                                                                |
+| -------------- | ------------------------------------------------------------------------------------------ |
+| skill          | `.claude/skills/<name>/SKILL.md` (never `.agents/skills/`)                                 |
+| instruction    | `.claude/rules/<name>.md` (`applyTo` → `paths:`)                                           |
+| agent          | `.claude/agents/<name>.md`                                                                 |
+| command        | `.claude/commands/<name>.md` (shared frontmatter subset)                                   |
+| hook           | merge `.claude/settings.json` + scripts under `.claude/hooks/` + `.claude/bapm-hooks.json` |
+
+MCP is **not** written by materialize — only via `configureMcp` → project `.mcp.json` when `.claude/` exists.
+
+## Compile
+
+`compile` defaults to `CLAUDE.md`, omits instruction primitives (they live under `.claude/rules/`), and honors `write` for preview vs durable emit.
+
+## Dependencies
+
+Depends only on `@b-apm/integration-api` among bapm packages — not `@b-apm/core`.
+Register via `createIntegrationRegistry().register(createClaudeIntegration())` or object-map `targets.claude: "@b-apm/integration-claude"`.

package/dist/index.d.mts

@@ -0,0 +1,28 @@
+import { BapmIntegration, MarketplaceOutputIntegration } from "@b-apm/integration-api";
+//#region src/createClaudeIntegration.d.ts
+/**
+ * Create the Claude Code target.
+ * Detect: `.claude/` directory **or** project-root `CLAUDE.md`.
+ * Materialize: skills → `.claude/skills/<name>/SKILL.md` (never `.agents/skills/`),
+ * instructions → `.claude/rules/<name>.md` (`applyTo` → `paths`),
+ * agents → `.claude/agents/<name>.md`,
+ * commands → `.claude/commands/<name>.md`,
+ * hooks → merge `.claude/settings.json` (+ scripts under `.claude/hooks/`, ownership sidecar).
+ * MCP: optional `configureMcp` writes project `.mcp.json` when `.claude/` exists.
+ * Compile: default `CLAUDE.md`, omitting instruction primitives.
+ */
+declare function createClaudeIntegration(options?: {
+  id?: string;
+  deployRoots?: string[];
+}): BapmIntegration;
+/**
+ * Convert portable `applyTo` frontmatter to Claude `paths:` (omit when unconditional).
+ */
+declare function transformClaudeRulesMarkdown(source: string): string;
+//#endregion
+//#region src/index.d.ts
+/** Maps resolved packages into Anthropic's marketplace document. */
+declare function mapClaudeMarketplace(config: unknown, resolved: unknown[]): Record<string, unknown>;
+declare const claudeMarketplaceIntegration: MarketplaceOutputIntegration;
+//#endregion
+export { claudeMarketplaceIntegration, createClaudeIntegration, createClaudeIntegration as createIntegration, mapClaudeMarketplace, transformClaudeRulesMarkdown };

package/dist/index.mjs

@@ -0,0 +1,502 @@
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+import { SHARED_COMMAND_FRONTMATTER_KEYS, assertUnderDeployRoots, compileMarkdownReport, copyHookScript, filterFrontmatterKeys, materializeSkill, primitivesList, primitivesMaterialize, readHookOwnershipSidecar, readPrimitiveContent, renderPrimitivesMarkdown, sanitizeName, stripOwnedHookCommands, writeDeployedFile, writeHookOwnershipSidecar } from "@b-apm/integration-api";
+//#region src/createClaudeIntegration.ts
+const DEFAULT_DEPLOY_ROOTS = [".claude", "."];
+const MCP_JSON_REL = ".mcp.json";
+const SETTINGS_JSON_REL = ".claude/settings.json";
+const HOOKS_OWNERSHIP_REL = ".claude/bapm-hooks.json";
+/**
+* Create the Claude Code target.
+* Detect: `.claude/` directory **or** project-root `CLAUDE.md`.
+* Materialize: skills → `.claude/skills/<name>/SKILL.md` (never `.agents/skills/`),
+* instructions → `.claude/rules/<name>.md` (`applyTo` → `paths`),
+* agents → `.claude/agents/<name>.md`,
+* commands → `.claude/commands/<name>.md`,
+* hooks → merge `.claude/settings.json` (+ scripts under `.claude/hooks/`, ownership sidecar).
+* MCP: optional `configureMcp` writes project `.mcp.json` when `.claude/` exists.
+* Compile: default `CLAUDE.md`, omitting instruction primitives.
+*/
+function createClaudeIntegration(options) {
+	const id = options?.id ?? "claude";
+	const deployRoots = [...options?.deployRoots ?? DEFAULT_DEPLOY_ROOTS];
+	return {
+		id,
+		deployRoots,
+		detect: ({ cwd }) => {
+			const claudeDir = join(cwd, ".claude");
+			if (existsSync(claudeDir) && statSync(claudeDir).isDirectory()) return true;
+			const claudeMd = join(cwd, "CLAUDE.md");
+			return existsSync(claudeMd) && statSync(claudeMd).isFile();
+		},
+		getDeployRoots: () => [...deployRoots],
+		async compile(primitives, context) {
+			const content = renderPrimitivesMarkdown({
+				primitives: primitivesList(primitives),
+				title: "# CLAUDE.md",
+				filter: (p) => !/instruction/i.test(String(p.type ?? ""))
+			});
+			return compileMarkdownReport({
+				cwd: context.cwd,
+				outputFile: context.outputFile ?? "CLAUDE.md",
+				write: context.write,
+				content,
+				outsideCwdMessage: "Claude compile output must be a cwd-relative file path"
+			});
+		},
+		async materialize(primitives, ctx) {
+			const cwd = resolve(ctx?.cwd ?? process.cwd());
+			const roots = ctx?.deployRoots?.length ? [...ctx.deployRoots] : deployRoots;
+			if (!roots.some((r) => r === ".claude" || r.startsWith(".claude"))) throw new Error("claude target missing .claude deploy root");
+			const deployedFiles = [];
+			const diagnostics = [];
+			const hookPrimitives = [];
+			await primitivesMaterialize(primitives, {
+				skill(p, { name }) {
+					deployedFiles.push(...materializeSkill({
+						primitive: p,
+						cwd,
+						deployRoots: roots,
+						destDir: join(".claude", "skills", name)
+					}));
+				},
+				instruction(p, { name }) {
+					deployedFiles.push(writeDeployedFile({
+						cwd,
+						deployRoots: roots,
+						destRel: join(".claude", "rules", `${name}.md`),
+						content: transformClaudeRulesMarkdown(readPrimitiveContent(p)),
+						primitive: {
+							name: String(p.name),
+							packageName: p.packageName
+						}
+					}));
+				},
+				agent(p, { name }) {
+					deployedFiles.push(writeDeployedFile({
+						cwd,
+						deployRoots: roots,
+						destRel: join(".claude", "agents", `${name}.md`),
+						content: readPrimitiveContent(p),
+						primitive: {
+							name: String(p.name),
+							packageName: p.packageName
+						}
+					}));
+				},
+				command(p, { name }) {
+					const { content, droppedKeys } = filterFrontmatterKeys(readPrimitiveContent(p), SHARED_COMMAND_FRONTMATTER_KEYS);
+					deployedFiles.push(writeDeployedFile({
+						cwd,
+						deployRoots: roots,
+						destRel: join(".claude", "commands", `${name}.md`),
+						content,
+						primitive: {
+							name: String(p.name),
+							packageName: p.packageName
+						}
+					}));
+					if (droppedKeys.length > 0) diagnostics.push({
+						code: "CLAUDE_COMMAND_FRONTMATTER_DROPPED",
+						message: `Dropped non-preserved command frontmatter keys for "${p.name}": ${droppedKeys.join(", ")}`,
+						primitive: String(p.name),
+						droppedKeys
+					});
+				},
+				hook(p) {
+					hookPrimitives.push(p);
+				}
+			});
+			if (hookPrimitives.length > 0) {
+				const hookDeployed = materializeClaudeHooks({
+					cwd,
+					roots,
+					hooks: hookPrimitives
+				});
+				deployedFiles.push(...hookDeployed.deployedFiles);
+				diagnostics.push(...hookDeployed.diagnostics);
+			}
+			return {
+				targetId: id,
+				deployedFiles,
+				...diagnostics.length > 0 ? { diagnostics } : {}
+			};
+		},
+		async configureMcp(servers, ctx) {
+			return writeClaudeMcpConfig(servers, {
+				cwd: resolve(ctx?.cwd ?? process.cwd()),
+				deployRoots: ctx?.deployRoots?.length ? [...ctx.deployRoots] : deployRoots,
+				targetId: ctx?.targetId ?? id
+			});
+		}
+	};
+}
+function writeClaudeMcpConfig(servers, ctx) {
+	const { cwd, deployRoots } = ctx;
+	const claudeDir = join(cwd, ".claude");
+	if (!existsSync(claudeDir) || !statSync(claudeDir).isDirectory()) return {
+		targetId: ctx.targetId,
+		configPath: MCP_JSON_REL,
+		servers: [],
+		deployedFiles: [],
+		diagnostics: [{
+			code: "CLAUDE_MCP_SKIP_NO_CLAUDE_DIR",
+			message: "Skipping project MCP write: .claude/ directory is absent (Claude project-scope MCP is opt-in)"
+		}]
+	};
+	if (!deployRoots.some((r) => r === "." || r === "./")) throw new Error("claude configureMcp requires a registered '.' deploy root for .mcp.json");
+	const destFile = join(cwd, MCP_JSON_REL);
+	assertUnderDeployRoots(cwd, destFile, deployRoots);
+	if (basename(destFile) !== ".mcp.json") throw new Error("claude configureMcp refuses non-.mcp.json root writes");
+	const existingDoc = readExistingMcpDoc(destFile);
+	const existingServers = existingDoc.mcpServers && typeof existingDoc.mcpServers === "object" ? { ...existingDoc.mcpServers } : {};
+	const { entries: incoming, diagnostics } = normalizeServerEntries(servers);
+	const nextServers = { ...existingServers };
+	const writtenNames = [];
+	for (const [name, entry] of Object.entries(incoming)) {
+		const prior = existingServers[name];
+		nextServers[name] = prior && typeof prior === "object" ? {
+			...prior,
+			...entry
+		} : { ...entry };
+		delete nextServers[name].format;
+		delete nextServers[name].packageName;
+		delete nextServers[name].registry;
+		writtenNames.push(name);
+	}
+	const doc = {
+		...existingDoc,
+		mcpServers: nextServers
+	};
+	writeFileSync(destFile, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+	return {
+		targetId: ctx.targetId,
+		configPath: MCP_JSON_REL,
+		servers: writtenNames,
+		deployedFiles: [{ path: MCP_JSON_REL }],
+		diagnostics
+	};
+}
+function readExistingMcpDoc(path) {
+	if (!existsSync(path)) return {};
+	try {
+		const raw = JSON.parse(readFileSync(path, "utf8"));
+		return raw && typeof raw === "object" && !Array.isArray(raw) ? { ...raw } : {};
+	} catch {
+		return {};
+	}
+}
+function normalizeServerEntries(servers) {
+	const out = {};
+	const diagnostics = [];
+	const list = Array.isArray(servers) ? servers : Object.entries(servers).map(([name, value]) => ({
+		...value,
+		name: value.name ?? name
+	}));
+	for (const server of list) {
+		const name = String(server.name ?? "").trim();
+		if (!name) continue;
+		const entry = toClaudeServerEntry(server);
+		if (!entry) {
+			diagnostics.push({
+				code: "CLAUDE_PORTABLE_MCP_UNSUPPORTED",
+				message: `Claude cannot faithfully represent MCP server "${name}"`,
+				server: name
+			});
+			continue;
+		}
+		out[name] = entry;
+	}
+	return {
+		entries: out,
+		diagnostics
+	};
+}
+function rewriteSkillLauncherCommand(command) {
+	if (command.startsWith(".agents/skills/")) return `.claude/skills/${command.slice(15)}`;
+	if (command.startsWith("./.agents/skills/")) return `./.claude/skills/${command.slice(17)}`;
+	return command;
+}
+function toClaudeServerEntry(server) {
+	const transport = String(server.transport ?? server.type ?? "").toLowerCase();
+	const entry = {};
+	if (server.format === "agent-plugin") {
+		if (transport === "stdio") {
+			if (typeof server.command !== "string") return void 0;
+			entry.command = rewriteSkillLauncherCommand(server.command);
+			if (Array.isArray(server.args)) entry.args = server.args;
+			if (typeof server.cwd === "string") entry.cwd = server.cwd;
+			entry.type = "stdio";
+		} else if (transport === "streamable-http" || transport === "sse" || transport === "http") {
+			if (typeof server.url !== "string") return void 0;
+			entry.url = server.url;
+			entry.type = transport === "sse" ? "sse" : "http";
+		} else return;
+		if (server.env && typeof server.env === "object") entry.env = server.env;
+		return entry;
+	}
+	if (transport === "http" || transport === "sse" || typeof server.url === "string") {
+		if (server.url) entry.url = server.url;
+		if (transport) entry.type = transport === "sse" ? "sse" : "http";
+	} else {
+		if (server.command) entry.command = rewriteSkillLauncherCommand(String(server.command));
+		if (Array.isArray(server.args)) entry.args = server.args;
+		entry.type = "stdio";
+	}
+	if (server.env && typeof server.env === "object") entry.env = server.env;
+	for (const [key, value] of Object.entries(server)) {
+		if ([
+			"name",
+			"transport",
+			"type",
+			"command",
+			"args",
+			"url",
+			"env",
+			"packageName",
+			"registry",
+			"format",
+			"cwd"
+		].includes(key)) continue;
+		if (value !== void 0) entry[key] = value;
+	}
+	return entry;
+}
+/**
+* Convert portable `applyTo` frontmatter to Claude `paths:` (omit when unconditional).
+*/
+function transformClaudeRulesMarkdown(source) {
+	const match = source.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+	if (!match) return source;
+	const rawFm = match[1] ?? "";
+	const body = match[2] ?? "";
+	const lines = rawFm.split(/\r?\n/);
+	const kept = [];
+	const paths = [];
+	let i = 0;
+	while (i < lines.length) {
+		const line = lines[i];
+		const keyMatch = line.match(/^([A-Za-z0-9_-]+)\s*:(.*)$/);
+		if (!keyMatch) {
+			if (line.trim()) kept.push(line);
+			i += 1;
+			continue;
+		}
+		const key = keyMatch[1];
+		const rest = keyMatch[2] ?? "";
+		if (key === "applyTo" || key === "paths") {
+			const inline = rest.trim();
+			if (inline.startsWith("[") && inline.endsWith("]")) {
+				for (const part of inline.slice(1, -1).split(",")) {
+					const v = part.trim().replace(/^["']|["']$/g, "");
+					if (v) paths.push(v);
+				}
+				i += 1;
+				continue;
+			}
+			if (inline && inline !== "|" && inline !== ">") {
+				paths.push(inline.replace(/^["']|["']$/g, ""));
+				i += 1;
+				continue;
+			}
+			i += 1;
+			while (i < lines.length) {
+				const listMatch = lines[i].match(/^[ \t]*-[ \t]*(.+)$/);
+				if (!listMatch) break;
+				paths.push(listMatch[1].trim().replace(/^["']|["']$/g, ""));
+				i += 1;
+			}
+			continue;
+		}
+		kept.push(line);
+		i += 1;
+	}
+	const fmLines = [...kept];
+	if (paths.length > 0) {
+		fmLines.push("paths:");
+		for (const p of paths) fmLines.push(`  - ${JSON.stringify(p)}`);
+	}
+	if (fmLines.length === 0) return body.replace(/\s+$/, "\n") || body;
+	return `---\n${fmLines.join("\n")}\n---\n${body}`.replace(/\s+$/, "\n");
+}
+function materializeClaudeHooks(args) {
+	const { cwd, roots, hooks } = args;
+	const deployedFiles = [];
+	const diagnostics = [];
+	const settingsPath = join(cwd, SETTINGS_JSON_REL);
+	const ownershipPath = join(cwd, HOOKS_OWNERSHIP_REL);
+	assertUnderDeployRoots(cwd, settingsPath, roots);
+	assertUnderDeployRoots(cwd, ownershipPath, roots);
+	mkdirSync(join(cwd, ".claude"), { recursive: true });
+	const doc = readSettingsDoc(settingsPath);
+	const ownership = readHookOwnershipSidecar(ownershipPath);
+	if (doc.hooks && typeof doc.hooks === "object") stripOwnedHookCommands(doc.hooks, ownership);
+	const nextOwned = {};
+	for (const p of hooks) {
+		const name = sanitizeName(String(p.name));
+		const srcPath = p.path ? resolve(p.path) : void 0;
+		if (!srcPath || !existsSync(srcPath) || !statSync(srcPath).isFile()) {
+			diagnostics.push({
+				code: "CLAUDE_HOOK_SOURCE_MISSING",
+				message: `Hook primitive "${p.name}" has no readable source JSON`,
+				primitive: String(p.name)
+			});
+			continue;
+		}
+		let parsed;
+		try {
+			parsed = JSON.parse(readFileSync(srcPath, "utf8"));
+		} catch (cause) {
+			diagnostics.push({
+				code: "CLAUDE_HOOK_JSON_INVALID",
+				message: `Hook "${p.name}" JSON is invalid: ${cause instanceof Error ? cause.message : String(cause)}`,
+				primitive: String(p.name)
+			});
+			continue;
+		}
+		const sourceHooks = parsed.hooks && typeof parsed.hooks === "object" ? parsed.hooks : {};
+		const ownedEntries = [];
+		const scripts = [];
+		if (!doc.hooks || typeof doc.hooks !== "object") doc.hooks = {};
+		for (const [event, entries] of Object.entries(sourceHooks)) {
+			if (!Array.isArray(entries)) continue;
+			const destList = Array.isArray(doc.hooks[event]) ? [...doc.hooks[event]] : [];
+			for (const entry of entries) {
+				if (!entry || typeof entry !== "object") continue;
+				const command = typeof entry.command === "string" ? entry.command.trim() : "";
+				if (!command) {
+					const { _apm_source: _drop, ...clean } = entry;
+					destList.push({ ...clean });
+					continue;
+				}
+				const rewritten = copyHookScript({
+					cwd,
+					deployRoots: roots,
+					hookFile: srcPath,
+					command,
+					alreadyDeployedNeedle: ".claude/",
+					destRel: `.claude/hooks/${name}/${basename(command.replace(/^\.\//, ""))}`,
+					commandAsDotSlash: true
+				});
+				const { _apm_source: _drop, ...clean } = entry;
+				const nextEntry = {
+					...clean,
+					command: rewritten.commandRel
+				};
+				destList.push(nextEntry);
+				ownedEntries.push({
+					event,
+					command: rewritten.commandRel
+				});
+				if (rewritten.scriptRel) {
+					scripts.push(rewritten.scriptRel);
+					deployedFiles.push({
+						path: rewritten.scriptRel,
+						primitive: {
+							name: String(p.name),
+							packageName: p.packageName
+						}
+					});
+				}
+			}
+			doc.hooks[event] = destList;
+		}
+		nextOwned[name] = {
+			...p.packageName ? { packageName: p.packageName } : {},
+			entries: ownedEntries,
+			scripts
+		};
+	}
+	writeFileSync(settingsPath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+	writeHookOwnershipSidecar(ownershipPath, { owned: nextOwned });
+	deployedFiles.push({
+		path: SETTINGS_JSON_REL,
+		...hooks[0] ? { primitive: {
+			name: String(hooks[0].name),
+			packageName: hooks[0].packageName
+		} } : {}
+	});
+	deployedFiles.push({
+		path: HOOKS_OWNERSHIP_REL,
+		...hooks[0] ? { primitive: {
+			name: String(hooks[0].name),
+			packageName: hooks[0].packageName
+		} } : {}
+	});
+	return {
+		deployedFiles,
+		diagnostics
+	};
+}
+function readSettingsDoc(path) {
+	if (!existsSync(path)) return { hooks: {} };
+	try {
+		const raw = JSON.parse(readFileSync(path, "utf8"));
+		if (!raw || typeof raw !== "object") return { hooks: {} };
+		if (!raw.hooks || typeof raw.hooks !== "object") raw.hooks = {};
+		return raw;
+	} catch {
+		return { hooks: {} };
+	}
+}
+//#endregion
+//#region src/index.ts
+function ownerObject(config) {
+	const owner = config.owner;
+	if (!owner) return { name: "unknown" };
+	if (typeof owner === "string") return { name: owner };
+	const value = owner;
+	return {
+		name: value.name,
+		...value.email ? { email: value.email } : {},
+		...value.url ? { url: value.url } : {}
+	};
+}
+/** Maps resolved packages into Anthropic's marketplace document. */
+function mapClaudeMarketplace(config, resolved) {
+	const cfg = config;
+	const plugins = resolved.map((pkg) => {
+		const entry = pkg.entry;
+		const plugin = { name: pkg.name };
+		for (const key of [
+			"description",
+			"author",
+			"license",
+			"repository",
+			"category"
+		]) if (entry[key]) plugin[key] = entry[key];
+		if (typeof entry.version === "string" && !/[\^~><=* ]/.test(entry.version)) plugin.version = entry.version;
+		if (Array.isArray(pkg.tags) && pkg.tags.length) plugin.tags = pkg.tags;
+		if (pkg.isLocal) plugin.source = pkg.source;
+		else if (pkg.subdir) plugin.source = {
+			source: "git-subdir",
+			url: pkg.sourceUrl ?? pkg.sourceRepo,
+			path: pkg.subdir,
+			...pkg.ref ? { ref: pkg.ref } : {},
+			...pkg.sha ? { sha: pkg.sha } : {}
+		};
+		else plugin.source = {
+			source: "url",
+			url: pkg.sourceUrl ?? pkg.sourceRepo
+		};
+		return plugin;
+	});
+	return {
+		name: cfg.name ?? "marketplace",
+		...cfg.description ? { description: cfg.description } : {},
+		...cfg.version ? { version: cfg.version } : {},
+		owner: ownerObject(cfg),
+		...cfg.metadata ? { metadata: cfg.metadata } : {},
+		plugins
+	};
+}
+const claudeMarketplaceIntegration = {
+	id: "claude",
+	marketplaceOutput: {
+		format: "claude",
+		defaultOutput: ".claude-plugin/marketplace.json",
+		map: mapClaudeMarketplace
+	}
+};
+//#endregion
+export { claudeMarketplaceIntegration, createClaudeIntegration, createClaudeIntegration as createIntegration, mapClaudeMarketplace, transformClaudeRulesMarkdown };

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@b-apm/integration-claude",
+  "version": "0.1.0",
+  "description": "Claude Code runtime + marketplace-output integration for bapm",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@b-apm/integration-api": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.2",
+    "typescript": "^7.0.2",
+    "vite": "npm:@voidzero-dev/vite-plus-core@latest",
+    "vite-plus": "latest"
+  },
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Sdju/bapm.git",
+    "directory": "packages/integration-claude"
+  },
+  "homepage": "https://github.com/Sdju/bapm#readme",
+  "bugs": {
+    "url": "https://github.com/Sdju/bapm/issues"
+  },
+  "keywords": [
+    "unstable",
+    "bapm",
+    "b-apm"
+  ],
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "check": "vp check"
+  }
+}