cmx-core 0.2.0

package/dist/platform.js

@@ -0,0 +1,137 @@
+export const PLATFORM_VALUES = [
+    "claude",
+    "copilot",
+    "cursor",
+    "windsurf",
+    "gemini",
+    "opencode",
+    "codex",
+    "pi",
+    "crush",
+    "amp",
+    "zed",
+    "openhands",
+    "hermes",
+    "devin",
+];
+const sharedAgentsSkills = ".agents/skills";
+const PLATFORM_SPECS = {
+    claude: {
+        slug: "",
+        skillSubpath: { global: ".claude/skills", local: ".claude/skills" },
+        supportsAgent: true,
+        agentExtension: "md",
+    },
+    copilot: {
+        slug: "copilot",
+        skillSubpath: { global: ".copilot/skills", local: ".github/skills" },
+        supportsAgent: true,
+        agentExtension: "md",
+    },
+    cursor: {
+        slug: "cursor",
+        skillSubpath: { global: ".cursor/skills", local: ".cursor/skills" },
+        supportsAgent: true,
+        agentExtension: "md",
+    },
+    windsurf: {
+        slug: "windsurf",
+        skillSubpath: {
+            global: ".codeium/windsurf/skills",
+            local: ".windsurf/skills",
+        },
+        supportsAgent: true,
+        agentExtension: "md",
+    },
+    gemini: {
+        slug: "gemini",
+        skillSubpath: { global: ".gemini/skills", local: ".gemini/skills" },
+        supportsAgent: true,
+        agentExtension: "md",
+    },
+    opencode: {
+        slug: "opencode",
+        skillSubpath: { global: sharedAgentsSkills, local: sharedAgentsSkills },
+        supportsAgent: true,
+        agentExtension: "md",
+    },
+    codex: {
+        slug: "codex",
+        skillSubpath: { global: sharedAgentsSkills, local: sharedAgentsSkills },
+        supportsAgent: true,
+        agentExtension: "toml",
+    },
+    pi: {
+        slug: "pi",
+        skillSubpath: { global: sharedAgentsSkills, local: sharedAgentsSkills },
+        supportsAgent: false,
+        agentExtension: "md",
+    },
+    crush: {
+        slug: "crush",
+        skillSubpath: { global: sharedAgentsSkills, local: sharedAgentsSkills },
+        supportsAgent: false,
+        agentExtension: "md",
+    },
+    amp: {
+        slug: "amp",
+        skillSubpath: { global: ".config/agents/skills", local: sharedAgentsSkills },
+        supportsAgent: false,
+        agentExtension: "md",
+    },
+    zed: {
+        slug: "zed",
+        skillSubpath: { global: sharedAgentsSkills, local: sharedAgentsSkills },
+        supportsAgent: false,
+        agentExtension: "md",
+    },
+    openhands: {
+        slug: "openhands",
+        skillSubpath: { global: sharedAgentsSkills, local: sharedAgentsSkills },
+        supportsAgent: false,
+        agentExtension: "md",
+    },
+    hermes: {
+        slug: "hermes",
+        skillSubpath: { global: ".hermes/skills", local: sharedAgentsSkills },
+        supportsAgent: false,
+        agentExtension: "md",
+    },
+    devin: {
+        slug: "devin",
+        skillSubpath: { global: sharedAgentsSkills, local: sharedAgentsSkills },
+        supportsAgent: false,
+        agentExtension: "md",
+    },
+};
+export const isPlatform = (value) => PLATFORM_VALUES.includes(value);
+export const platformSlug = (platform) => PLATFORM_SPECS[platform].slug;
+export const platformInstallSubpath = (platform, kind, scope) => {
+    if (kind === "skill") {
+        return PLATFORM_SPECS[platform].skillSubpath[scope];
+    }
+    if (!PLATFORM_SPECS[platform].supportsAgent) {
+        return null;
+    }
+    if (platform === "copilot") {
+        const base = scope === "local" ? ".github" : ".copilot";
+        return `${base}/agents`;
+    }
+    if (platform === "windsurf") {
+        return scope === "local" ? ".windsurf/agents" : ".codeium/windsurf/agents";
+    }
+    if (platform === "opencode") {
+        return scope === "local" ? ".opencode/agent" : ".config/opencode/agent";
+    }
+    if (platform === "codex") {
+        return ".codex/agents";
+    }
+    return `.${platform}/agents`;
+};
+export const supportsArtifact = (platform, kind) => kind === "skill" || PLATFORM_SPECS[platform].supportsAgent;
+export const agentExtension = (platform) => PLATFORM_SPECS[platform].agentExtension;
+export const lockFileName = (platform) => {
+    const slug = platformSlug(platform);
+    return slug === "" ? "cmx-lock.json" : `cmx-lock-${slug}.json`;
+};
+export const platformsLabel = (platforms) => platforms.join(", ");

package/dist/skill-fs.d.ts

@@ -0,0 +1,9 @@
+import type { Filesystem } from "./gateway.js";
+export interface SkillFile {
+    relPath: string;
+    bytes: Uint8Array;
+}
+export declare const textSkillFile: (relPath: string, content: string) => SkillFile;
+export declare const canonicalFiles: (files: readonly SkillFile[]) => SkillFile[];
+export declare const checksumBundled: (files: readonly SkillFile[]) => string;
+export declare const writeSkillFiles: (destDir: string, files: readonly SkillFile[], fs: Filesystem) => Promise<void>;

package/dist/skill-fs.js

@@ -0,0 +1,23 @@
+import path from "node:path/posix";
+import { checksumInMemory, isCanonicalRelPath, relPathKey } from "./checksum.js";
+const textEncoder = new TextEncoder();
+export const textSkillFile = (relPath, content) => ({
+    relPath,
+    bytes: textEncoder.encode(content),
+});
+export const canonicalFiles = (files) => [...files]
+    .filter((file) => isCanonicalRelPath(file.relPath))
+    .sort((left, right) => {
+    const leftKey = relPathKey(left.relPath);
+    const rightKey = relPathKey(right.relPath);
+    return leftKey < rightKey ? -1 : leftKey > rightKey ? 1 : 0;
+});
+export const checksumBundled = (files) => checksumInMemory(canonicalFiles(files));
+export const writeSkillFiles = async (destDir, files, fs) => {
+    await fs.createDirAll(destDir);
+    for (const file of files) {
+        const destPath = path.join(destDir, file.relPath);
+        await fs.createDirAll(path.dirname(destPath));
+        await fs.writeBytes(destPath, file.bytes);
+    }
+};

package/dist/skill-installer.d.ts

@@ -0,0 +1,113 @@
+import type { Clock, Filesystem } from "./gateway.js";
+import type { ConfigPaths } from "./paths.js";
+import { type Platform } from "./platform.js";
+import { type SkillFile } from "./skill-fs.js";
+import type { InstallScope } from "./types.js";
+export type Scope = InstallScope;
+export declare class ToolIdentity {
+    readonly name: string;
+    readonly version: string;
+    constructor(name: string, version: string);
+}
+export declare class BundledSkill {
+    readonly files: SkillFile[];
+    constructor(files: SkillFile[]);
+    static fromFiles(files: SkillFile[]): BundledSkill;
+    static singleMd(content: string): BundledSkill;
+    hasSkillMd(): boolean;
+}
+export type DiskState = "missing" | "matches-source" | "drifted";
+export type TargetAction = {
+    kind: "install";
+} | {
+    kind: "update";
+    from: string | null;
+} | {
+    kind: "skip";
+} | {
+    kind: "drifted-skip";
+    installed: string;
+} | {
+    kind: "refuse-newer";
+    installed: string;
+} | {
+    kind: "downgrade";
+    from: string;
+};
+export interface PlannedFile {
+    rel_path: string;
+    dest_path: string;
+}
+export interface TargetPlan {
+    platform: Platform;
+    scope: InstallScope;
+    dest_dir: string;
+    files: PlannedFile[];
+    action: TargetAction;
+    cmx_managed: boolean;
+}
+export interface InstallPlan {
+    tool: ToolIdentity;
+    scope: InstallScope;
+    source_checksum: string;
+    cmx_present: boolean;
+    force: boolean;
+    targets: TargetPlan[];
+}
+export interface TargetOutcome {
+    platform: Platform;
+    dest_dir: string;
+    action: TargetAction;
+    files_written: number;
+    installed_checksum: string | null;
+    discarded_paths: string[];
+}
+export interface Report {
+    tool: ToolIdentity;
+    scope: InstallScope;
+    targets: TargetOutcome[];
+    source_registered: boolean;
+}
+export interface TargetStatus {
+    platform: Platform;
+    installed: boolean;
+    installed_version: string | null;
+    drifted: boolean;
+    tracked: boolean;
+}
+export interface Status {
+    tool_name: string;
+    scope: InstallScope;
+    targets: TargetStatus[];
+}
+export interface RemoveReport {
+    tool_name: string;
+    scope: InstallScope;
+    removed_dirs: string[];
+    platforms_cleared: Platform[];
+    source_unregistered: boolean;
+    was_on_disk: boolean;
+    was_tracked: boolean;
+}
+export interface InstallerContext {
+    fs: Filesystem;
+    clock: Clock;
+    paths: ConfigPaths;
+}
+export interface VersionGuardDecisionInput {
+    bundledVersion: string;
+    tracked: boolean;
+    installedVersion: string | null;
+    diskState: DiskState;
+    force: boolean;
+}
+export declare const decideVersionGuardAction: (input: VersionGuardDecisionInput) => TargetAction;
+export declare class SkillInstaller {
+    readonly tool: ToolIdentity;
+    constructor(tool: ToolIdentity);
+    plan(skill: BundledSkill, scope: Scope, force: boolean, context: InstallerContext): Promise<InstallPlan>;
+    apply(skill: BundledSkill, plan: InstallPlan, context: InstallerContext): Promise<Report>;
+    status(scope: Scope, context: InstallerContext): Promise<Status>;
+    remove(scope: Scope, context: InstallerContext): Promise<RemoveReport>;
+    private registerManagedSource;
+}

package/dist/skill-installer.js

@@ -0,0 +1,348 @@
+import path from "node:path/posix";
+import { coerce, compare as compareSemver } from "semver";
+import { checksumDir } from "./checksum.js";
+import { loadConfig, loadSources, managedOrAllPlatforms, managedPlatforms, mutateSources, resolveArtifactHome, } from "./config.js";
+import { reconcileSkillVersion } from "./frontmatter.js";
+import { loadLockFile, mutateLockFile } from "./lockfile.js";
+import { PLATFORM_VALUES } from "./platform.js";
+import { canonicalFiles, checksumBundled, textSkillFile, writeSkillFiles, } from "./skill-fs.js";
+import { resolveTargets } from "./targets.js";
+export class ToolIdentity {
+    name;
+    version;
+    constructor(name, version) {
+        this.name = name;
+        this.version = version;
+    }
+}
+export class BundledSkill {
+    files;
+    constructor(files) {
+        this.files = files;
+    }
+    static fromFiles(files) {
+        return new BundledSkill(files);
+    }
+    static singleMd(content) {
+        return new BundledSkill([textSkillFile("SKILL.md", content)]);
+    }
+    hasSkillMd() {
+        return this.files.some((file) => file.relPath === "SKILL.md");
+    }
+}
+const willWrite = (action) => action.kind === "install" || action.kind === "update" || action.kind === "downgrade";
+const isBlocked = (action) => action.kind === "refuse-newer";
+const formatTimestamp = (date) => {
+    const pad = (value) => `${value}`.padStart(2, "0");
+    return (`${date.getUTCFullYear()}-${pad(date.getUTCMonth() + 1)}-${pad(date.getUTCDate())}` +
+        `T${pad(date.getUTCHours())}:${pad(date.getUTCMinutes())}:${pad(date.getUTCSeconds())}+00:00`);
+};
+const compareVersions = (installedVersion, bundledVersion) => {
+    if (installedVersion === null) {
+        return -1;
+    }
+    const installedSemver = coerce(installedVersion);
+    const bundledSemver = coerce(bundledVersion);
+    if (installedSemver !== null && bundledSemver !== null) {
+        return compareSemver(installedSemver, bundledSemver);
+    }
+    return installedVersion === bundledVersion ? 0 : -1;
+};
+export const decideVersionGuardAction = (input) => {
+    if (!input.tracked) {
+        return { kind: "install" };
+    }
+    const comparison = compareVersions(input.installedVersion, input.bundledVersion);
+    if (comparison < 0) {
+        return { kind: "update", from: input.installedVersion };
+    }
+    if (comparison === 0) {
+        if (input.diskState === "missing") {
+            return { kind: "install" };
+        }
+        if (input.diskState === "matches-source") {
+            return { kind: "skip" };
+        }
+        return input.force
+            ? { kind: "update", from: input.installedVersion }
+            : {
+                kind: "drifted-skip",
+                installed: input.installedVersion ?? "unknown",
+            };
+    }
+    return input.force
+        ? { kind: "downgrade", from: input.installedVersion ?? "unknown" }
+        : { kind: "refuse-newer", installed: input.installedVersion ?? "unknown" };
+};
+const buildLockEntry = (tool, checksum, installedAt) => ({
+    type: "skill",
+    version: tool.version,
+    installed_at: installedAt,
+    source: {
+        repo: `bundled:${tool.name}`,
+        path: `skills/${tool.name}`,
+    },
+    source_checksum: checksum,
+    installed_checksum: checksum,
+});
+const computeDiskState = async (skillDest, sourceChecksum, fs) => {
+    if (!(await fs.exists(skillDest))) {
+        return "missing";
+    }
+    const diskChecksum = await checksumDir(skillDest, fs);
+    return diskChecksum === sourceChecksum ? "matches-source" : "drifted";
+};
+const unique = (values) => [...new Set(values)];
+const discardedPathsAgainstBundle = async (skillDest, bundledFiles, fs) => {
+    if (!(await fs.exists(skillDest))) {
+        return [];
+    }
+    const installedFiles = await collectFilesRecursive(skillDest, skillDest, fs);
+    const installedByRel = new Map(installedFiles.map((file) => [file.relPath, file.bytes]));
+    const bundledByRel = new Map(canonicalFiles(bundledFiles).map((file) => [file.relPath, file.bytes]));
+    const relativePaths = unique([...installedByRel.keys(), ...bundledByRel.keys()]).sort((left, right) => left.localeCompare(right));
+    return relativePaths.flatMap((relPath) => {
+        const installed = installedByRel.get(relPath);
+        const bundled = bundledByRel.get(relPath);
+        const equal = installed !== undefined &&
+            bundled !== undefined &&
+            installed.length === bundled.length &&
+            installed.every((byte, index) => byte === bundled[index]);
+        return equal ? [] : [path.join(skillDest, relPath)];
+    });
+};
+const collectFilesRecursive = async (rootDir, currentDir, fs) => {
+    if (!(await fs.exists(currentDir))) {
+        return [];
+    }
+    const entries = await fs.listDir(currentDir);
+    const files = [];
+    for (const entry of entries) {
+        const absolutePath = path.join(currentDir, entry.fileName);
+        if (entry.isDirectory) {
+            files.push(...(await collectFilesRecursive(rootDir, absolutePath, fs)));
+            continue;
+        }
+        files.push({
+            relPath: path.relative(rootDir, absolutePath),
+            bytes: await fs.read(absolutePath),
+        });
+    }
+    return files;
+};
+export class SkillInstaller {
+    tool;
+    constructor(tool) {
+        this.tool = tool;
+    }
+    async plan(skill, scope, force, context) {
+        if (!skill.hasSkillMd()) {
+            throw new Error(`BundledSkill for '${this.tool.name}' is missing SKILL.md`);
+        }
+        const files = reconcileSkillVersion(skill.files, this.tool.version);
+        const sourceChecksum = checksumBundled(files);
+        const targets = await resolveTargets(undefined, "skill", scope, context);
+        const managed = await managedPlatforms(context.fs, context.paths);
+        const cmxManaged = managed !== undefined;
+        const cmxPresent = cmxManaged ||
+            (await Promise.all(PLATFORM_VALUES.map(async (platform) => {
+                const lockFile = await loadLockFile(scope, context.fs, context.paths.withPlatform(platform));
+                return Object.keys(lockFile.packages).length > 0;
+            }))).some(Boolean);
+        const targetPlans = [];
+        for (const platform of targets) {
+            const platformPaths = context.paths.withPlatform(platform);
+            const skillDest = path.join(platformPaths.requireInstallDir("skill", scope), this.tool.name);
+            const plannedFiles = files.map((file) => ({
+                rel_path: file.relPath,
+                dest_path: path.join(skillDest, file.relPath),
+            }));
+            const lockFile = await loadLockFile(scope, context.fs, platformPaths);
+            const entry = lockFile.packages[this.tool.name];
+            const action = entry === undefined
+                ? { kind: "install" }
+                : decideVersionGuardAction({
+                    bundledVersion: this.tool.version,
+                    tracked: true,
+                    installedVersion: entry.version ?? null,
+                    diskState: await computeDiskState(skillDest, sourceChecksum, context.fs),
+                    force,
+                });
+            targetPlans.push({
+                platform,
+                scope,
+                dest_dir: skillDest,
+                files: plannedFiles,
+                action,
+                cmx_managed: cmxManaged,
+            });
+        }
+        return {
+            tool: this.tool,
+            scope,
+            source_checksum: sourceChecksum,
+            cmx_present: cmxPresent,
+            force,
+            targets: targetPlans,
+        };
+    }
+    async apply(skill, plan, context) {
+        if (plan.targets.some((target) => isBlocked(target.action))) {
+            throw new Error(`Install plan for '${this.tool.name}' is blocked. Run with force=true to override.`);
+        }
+        const files = reconcileSkillVersion(skill.files, this.tool.version);
+        const currentChecksum = checksumBundled(files);
+        if (currentChecksum !== plan.source_checksum) {
+            throw new Error(`Parity check failed for '${this.tool.name}': the BundledSkill has changed since plan() was called.`);
+        }
+        const dirsToWrite = unique(plan.targets.filter((target) => willWrite(target.action)).map((target) => target.dest_dir));
+        const replaceDirs = unique(plan.targets
+            .filter((target) => plan.force && (target.action.kind === "update" || target.action.kind === "downgrade"))
+            .map((target) => target.dest_dir));
+        const discardedByDir = new Map();
+        for (const dir of replaceDirs) {
+            discardedByDir.set(dir, await discardedPathsAgainstBundle(dir, files, context.fs));
+            if (await context.fs.exists(dir)) {
+                await context.fs.removeDirAll(dir);
+            }
+        }
+        for (const dir of dirsToWrite) {
+            await writeSkillFiles(dir, files, context.fs);
+        }
+        const installedAt = formatTimestamp(context.clock.now());
+        const installedChecksum = plan.source_checksum;
+        const targets = [];
+        for (const target of plan.targets) {
+            if (!willWrite(target.action)) {
+                targets.push({
+                    platform: target.platform,
+                    dest_dir: target.dest_dir,
+                    action: target.action,
+                    files_written: 0,
+                    installed_checksum: null,
+                    discarded_paths: [],
+                });
+                continue;
+            }
+            await mutateLockFile(scopeFromPlan(target.scope), context.fs, context.paths.withPlatform(target.platform), (lockFile) => {
+                lockFile.packages[this.tool.name] = buildLockEntry(this.tool, installedChecksum, installedAt);
+            });
+            targets.push({
+                platform: target.platform,
+                dest_dir: target.dest_dir,
+                action: target.action,
+                files_written: target.files.length,
+                installed_checksum: installedChecksum,
+                discarded_paths: discardedByDir.get(target.dest_dir) ?? [],
+            });
+        }
+        const sourceRegistered = (await managedPlatforms(context.fs, context.paths)) !== undefined
+            ? await this.registerManagedSource(files, context)
+            : false;
+        return {
+            tool: this.tool,
+            scope: plan.scope,
+            targets,
+            source_registered: sourceRegistered,
+        };
+    }
+    async status(scope, context) {
+        const targets = await resolveTargets(undefined, "skill", scope, context);
+        const statuses = [];
+        for (const platform of targets) {
+            const platformPaths = context.paths.withPlatform(platform);
+            const skillDir = path.join(platformPaths.requireInstallDir("skill", scope), this.tool.name);
+            const installed = await context.fs.exists(skillDir);
+            const lockFile = await loadLockFile(scope, context.fs, platformPaths);
+            const entry = lockFile.packages[this.tool.name];
+            const tracked = entry !== undefined;
+            const drifted = installed && tracked
+                ? (await checksumDir(skillDir, context.fs)) !== entry.installed_checksum
+                : false;
+            statuses.push({
+                platform,
+                installed,
+                installed_version: entry?.version ?? null,
+                drifted,
+                tracked,
+            });
+        }
+        return {
+            tool_name: this.tool.name,
+            scope,
+            targets: statuses,
+        };
+    }
+    async remove(scope, context) {
+        const platforms = (await managedOrAllPlatforms(context.fs, context.paths)).filter((platform) => platform !== undefined);
+        const skillPlatforms = platforms;
+        const dirsToDelete = new Set();
+        const platformsCleared = [];
+        let wasTracked = false;
+        for (const platform of skillPlatforms) {
+            const platformPaths = context.paths.withPlatform(platform);
+            const skillDir = path.join(platformPaths.requireInstallDir("skill", scope), this.tool.name);
+            if (await context.fs.exists(skillDir)) {
+                dirsToDelete.add(skillDir);
+            }
+            const lockFile = await loadLockFile(scope, context.fs, platformPaths);
+            if (lockFile.packages[this.tool.name] !== undefined) {
+                await mutateLockFile(scope, context.fs, platformPaths, (mutableLock) => {
+                    delete mutableLock.packages[this.tool.name];
+                });
+                platformsCleared.push(platform);
+                wasTracked = true;
+            }
+        }
+        const removedDirs = [...dirsToDelete];
+        for (const dir of removedDirs) {
+            await context.fs.removeDirAll(dir);
+        }
+        const sourceName = `bundled:${this.tool.name}`;
+        let sourceUnregistered = false;
+        try {
+            const sources = await loadSources(context.fs, context.paths);
+            const entry = sources.sources[sourceName];
+            if (entry !== undefined) {
+                if (entry.path !== undefined && (await context.fs.exists(entry.path))) {
+                    await context.fs.removeDirAll(entry.path);
+                }
+                await mutateSources(context.fs, context.paths, (mutableSources) => {
+                    delete mutableSources.sources[sourceName];
+                });
+                sourceUnregistered = true;
+            }
+        }
+        catch {
+            sourceUnregistered = false;
+        }
+        return {
+            tool_name: this.tool.name,
+            scope,
+            removed_dirs: removedDirs,
+            platforms_cleared: platformsCleared,
+            source_unregistered: sourceUnregistered,
+            was_on_disk: removedDirs.length > 0,
+            was_tracked: wasTracked,
+        };
+    }
+    async registerManagedSource(files, context) {
+        const config = await loadConfig(context.fs, context.paths);
+        const materializedDir = path.join(resolveArtifactHome(config, context.paths), "skills", this.tool.name);
+        await writeSkillFiles(materializedDir, files, context.fs);
+        const sourceName = `bundled:${this.tool.name}`;
+        const now = formatTimestamp(context.clock.now());
+        await mutateSources(context.fs, context.paths, (sources) => {
+            if (sources.sources[sourceName] === undefined) {
+                const entry = {
+                    type: "local",
+                    path: materializedDir,
+                    last_updated: now,
+                };
+                sources.sources[sourceName] = entry;
+            }
+        });
+        return true;
+    }
+}
+const scopeFromPlan = (scope) => scope;

package/dist/targets.d.ts

@@ -0,0 +1,9 @@
+import type { Filesystem } from "./gateway.js";
+import type { ConfigPaths } from "./paths.js";
+import { type Platform } from "./platform.js";
+import type { ArtifactKind, InstallScope } from "./types.js";
+export interface TargetResolutionContext {
+    fs: Filesystem;
+    paths: ConfigPaths;
+}
+export declare const resolveTargets: (selector: Platform | undefined, kind: ArtifactKind, scope: InstallScope, context: TargetResolutionContext) => Promise<Platform[]>;

package/dist/targets.js

@@ -0,0 +1,23 @@
+import { managedPlatforms } from "./config.js";
+import { loadLockFile } from "./lockfile.js";
+import { PLATFORM_VALUES, supportsArtifact } from "./platform.js";
+export const resolveTargets = async (selector, kind, scope, context) => {
+    if (selector !== undefined) {
+        return [selector];
+    }
+    const managed = await managedPlatforms(context.fs, context.paths);
+    if (managed !== undefined) {
+        return managed.filter((platform) => supportsArtifact(platform, kind));
+    }
+    const targets = [];
+    for (const platform of PLATFORM_VALUES) {
+        if (!supportsArtifact(platform, kind)) {
+            continue;
+        }
+        const lockFile = await loadLockFile(scope, context.fs, context.paths.withPlatform(platform));
+        if (Object.keys(lockFile.packages).length > 0) {
+            targets.push(platform);
+        }
+    }
+    return targets.length > 0 ? targets : ["claude"];
+};