dryai 0.2.1

package/dest/lib/context.js

@@ -0,0 +1,104 @@
+import os from 'node:os';
+import path from 'node:path';
+export const DEFAULT_INPUT_ROOT_SEGMENTS = ['.config', 'agents'];
+export const DEFAULT_TEST_OUTPUT_DIR_NAME = 'output-test';
+export const DEFAULT_SOURCE_ROOT_NAMES = {
+    commands: 'commands',
+    rules: 'rules',
+    skills: 'skills',
+};
+export const DEFAULT_TARGET_ROOT_SEGMENTS = {
+    copilotPrompts: ['.copilot', 'prompts'],
+    copilotInstructions: ['.copilot', 'instructions'],
+    copilotSkills: ['.copilot', 'skills'],
+    cursorRules: ['.cursor', 'rules'],
+    cursorSkills: ['.cursor', 'skills'],
+};
+/**
+ * Creates the Copilot and Cursor output root paths under one base directory.
+ */
+export function createTargetRoots(baseDir) {
+    return {
+        copilotPrompts: path.join(baseDir, ...DEFAULT_TARGET_ROOT_SEGMENTS.copilotPrompts),
+        copilotInstructions: path.join(baseDir, ...DEFAULT_TARGET_ROOT_SEGMENTS.copilotInstructions),
+        copilotSkills: path.join(baseDir, ...DEFAULT_TARGET_ROOT_SEGMENTS.copilotSkills),
+        cursorRules: path.join(baseDir, ...DEFAULT_TARGET_ROOT_SEGMENTS.cursorRules),
+        cursorSkills: path.join(baseDir, ...DEFAULT_TARGET_ROOT_SEGMENTS.cursorSkills),
+    };
+}
+/**
+ * Creates the commands, rules, and skills input roots under one base directory.
+ */
+export function createSourceRoots(baseDir) {
+    return {
+        commands: path.join(baseDir, DEFAULT_SOURCE_ROOT_NAMES.commands),
+        rules: path.join(baseDir, DEFAULT_SOURCE_ROOT_NAMES.rules),
+        skills: path.join(baseDir, DEFAULT_SOURCE_ROOT_NAMES.skills),
+    };
+}
+/**
+ * Expands a leading `~` in a path to the current user's home directory.
+ */
+export function expandHomePath(inputPath, homeDir) {
+    if (inputPath === '~') {
+        return homeDir;
+    }
+    if (inputPath.startsWith('~/') || inputPath.startsWith('~\\')) {
+        return path.join(homeDir, inputPath.slice(2));
+    }
+    return inputPath;
+}
+/**
+ * Returns the requested output-root override derived from CLI-style options.
+ */
+export function resolveRequestedOutputRoot(input) {
+    if (input.outputRoot) {
+        return input.outputRoot;
+    }
+    return input.test ? `./${DEFAULT_TEST_OUTPUT_DIR_NAME}` : undefined;
+}
+/**
+ * Returns the filesystem path to use for generated output.
+ */
+export function resolveOutputRoot(input) {
+    if (input.outputRoot) {
+        return path.resolve(expandHomePath(input.outputRoot, input.homeDir));
+    }
+    return input.homeDir;
+}
+/**
+ * Returns a copy of the context with generated output redirected under one
+ * explicit output root.
+ */
+export function resolveOutputContext(context, outputRoot) {
+    return {
+        ...context,
+        outputRoot,
+        targetRoots: createTargetRoots(outputRoot),
+    };
+}
+/**
+ * Creates the base CLI context with repository, input, and output paths
+ * resolved.
+ */
+export function createAgentsContext(options) {
+    const homeDir = os.homedir();
+    const inputRoot = options?.inputRoot
+        ? path.resolve(expandHomePath(options.inputRoot, homeDir))
+        : path.join(homeDir, ...DEFAULT_INPUT_ROOT_SEGMENTS);
+    const outputRoot = resolveOutputRoot(options?.outputRoot
+        ? {
+            homeDir,
+            outputRoot: options.outputRoot,
+        }
+        : {
+            homeDir,
+        });
+    return {
+        inputRoot,
+        outputRoot,
+        skillsLockfilePath: path.join(inputRoot, 'skills.lock.json'),
+        sourceRoots: createSourceRoots(inputRoot),
+        targetRoots: createTargetRoots(outputRoot),
+    };
+}

package/dest/lib/frontmatter.d.ts

@@ -0,0 +1,104 @@
+import { z } from 'zod';
+export declare const nonEmptyStringSchema: z.ZodString;
+export declare const commandFrontmatterSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    cursor: z.ZodOptional<z.ZodObject<{
+        'disable-model-invocation': z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        'disable-model-invocation'?: boolean | undefined;
+    }, {
+        'disable-model-invocation'?: boolean | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    cursor?: {
+        'disable-model-invocation'?: boolean | undefined;
+    } | undefined;
+}, {
+    name: string;
+    description: string;
+    cursor?: {
+        'disable-model-invocation'?: boolean | undefined;
+    } | undefined;
+}>;
+export declare const ruleFrontmatterSchema: z.ZodObject<{
+    description: z.ZodString;
+    copilot: z.ZodObject<{
+        applyTo: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        applyTo: string;
+    }, {
+        applyTo: string;
+    }>;
+    cursor: z.ZodOptional<z.ZodObject<{
+        alwaysApply: z.ZodOptional<z.ZodBoolean>;
+        globs: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        alwaysApply?: boolean | undefined;
+        globs?: string | undefined;
+    }, {
+        alwaysApply?: boolean | undefined;
+        globs?: string | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    description: string;
+    copilot: {
+        applyTo: string;
+    };
+    cursor?: {
+        alwaysApply?: boolean | undefined;
+        globs?: string | undefined;
+    } | undefined;
+}, {
+    description: string;
+    copilot: {
+        applyTo: string;
+    };
+    cursor?: {
+        alwaysApply?: boolean | undefined;
+        globs?: string | undefined;
+    } | undefined;
+}>;
+export type CommandFrontmatter = z.infer<typeof commandFrontmatterSchema>;
+export type RuleFrontmatter = z.infer<typeof ruleFrontmatterSchema>;
+/**
+ * Returns a copy of an object with all undefined-valued entries removed.
+ */
+export declare function compactObject(value: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Returns whether a value is a non-null plain object and not an array.
+ */
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Parses optional YAML frontmatter from a markdown-like file and returns its metadata and body.
+ */
+export declare function parseFrontmatter(fileContent: string): {
+    metadata: Record<string, unknown>;
+    body: string;
+};
+/**
+ * Validates parsed frontmatter against a schema and logs a skip message when validation fails.
+ */
+export declare function validateFrontmatter<T>({ filePath, metadata, schema, }: {
+    filePath: string;
+    metadata: Record<string, unknown>;
+    schema: z.ZodType<T>;
+}): T | null;
+/**
+ * Normalizes rule frontmatter into the apply settings used by downstream generators.
+ */
+export declare function normalizeRuleMetadata(metadata: RuleFrontmatter): {
+    alwaysApply: boolean;
+    globs: string | undefined;
+    applyTo: string;
+};
+/**
+ * Renders metadata and markdown body content back into a frontmatter document string.
+ */
+export declare function renderMarkdown({ metadata, body, }: {
+    metadata: Record<string, unknown>;
+    body: string;
+}): string;
+//# sourceMappingURL=frontmatter.d.ts.map

package/dest/lib/frontmatter.js

@@ -0,0 +1,96 @@
+import matter from 'gray-matter';
+import { z } from 'zod';
+export const nonEmptyStringSchema = z.string().trim().min(1);
+export const commandFrontmatterSchema = z
+    .object({
+    name: nonEmptyStringSchema,
+    description: nonEmptyStringSchema,
+    cursor: z
+        .object({
+        'disable-model-invocation': z.boolean().optional(),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+export const ruleFrontmatterSchema = z
+    .object({
+    description: nonEmptyStringSchema,
+    copilot: z
+        .object({
+        applyTo: nonEmptyStringSchema,
+    })
+        .strict(),
+    cursor: z
+        .object({
+        alwaysApply: z.boolean().optional(),
+        globs: nonEmptyStringSchema.optional(),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+/**
+ * Returns a copy of an object with all undefined-valued entries removed.
+ */
+export function compactObject(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, entryValue]) => entryValue !== undefined));
+}
+/**
+ * Returns whether a value is a non-null plain object and not an array.
+ */
+export function isPlainObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+/**
+ * Parses optional YAML frontmatter from a markdown-like file and returns its metadata and body.
+ */
+export function parseFrontmatter(fileContent) {
+    const parsed = matter(fileContent);
+    return {
+        metadata: isPlainObject(parsed.data) ? parsed.data : {},
+        body: parsed.content.trim(),
+    };
+}
+/**
+ * Validates parsed frontmatter against a schema and logs a skip message when validation fails.
+ */
+export function validateFrontmatter({ filePath, metadata, schema, }) {
+    const result = schema.safeParse(metadata);
+    if (result.success) {
+        return result.data;
+    }
+    const issues = result.error.issues
+        .map((issue) => {
+        const fieldPath = issue.path.length > 0 ? issue.path.join('.') : 'frontmatter';
+        return `${fieldPath}: ${issue.message}`;
+    })
+        .join('; ');
+    console.log(`Skipping invalid frontmatter in ${filePath}: ${issues}`);
+    return null;
+}
+/**
+ * Normalizes rule frontmatter into the apply settings used by downstream generators.
+ */
+export function normalizeRuleMetadata(metadata) {
+    const copilotApplyTo = metadata.copilot.applyTo;
+    const explicitAlwaysApply = metadata.cursor?.alwaysApply;
+    const scopedGlobs = metadata.cursor?.globs ?? copilotApplyTo;
+    const alwaysApply = explicitAlwaysApply ?? (scopedGlobs === undefined || scopedGlobs === '**');
+    const globs = alwaysApply ? undefined : scopedGlobs;
+    return {
+        alwaysApply,
+        globs,
+        applyTo: copilotApplyTo,
+    };
+}
+/**
+ * Renders metadata and markdown body content back into a frontmatter document string.
+ */
+export function renderMarkdown({ metadata, body, }) {
+    const normalizedBody = body.trim();
+    if (Object.keys(metadata).length === 0) {
+        return `${normalizedBody}\n`;
+    }
+    return matter.stringify(normalizedBody, metadata);
+}

package/dest/lib/install.d.ts

@@ -0,0 +1,8 @@
+import type { AgentsContext, TargetRoots } from './context.js';
+/**
+ * Installs all generated command, rule, and skill outputs into the requested targets.
+ */
+export declare function installToTargets(context: AgentsContext, { targetRoots }: {
+    targetRoots: TargetRoots;
+}): Promise<void>;
+//# sourceMappingURL=install.d.ts.map

package/dest/lib/install.js

@@ -0,0 +1,380 @@
+import { Chalk } from 'chalk';
+import fs from 'fs-extra';
+import { glob } from 'glob';
+import path from 'node:path';
+import { commandFrontmatterSchema, compactObject, normalizeRuleMetadata, parseFrontmatter, renderMarkdown, ruleFrontmatterSchema, validateFrontmatter, } from './frontmatter.js';
+const ALL_INSTALL_EDITORS = ['copilot', 'cursor'];
+const chalk = new Chalk({ level: 3 });
+/**
+ * Installs all generated command, rule, and skill outputs into the requested targets.
+ */
+export async function installToTargets(context, { targetRoots }) {
+    await ensureTargetDirectories(targetRoots);
+    const installItems = [
+        ...(await collectCommandInstallItems(context, { targetRoots })),
+        ...(await collectRuleInstallItems(context, { targetRoots })),
+        ...(await collectSkillInstallItems(context, { targetRoots })),
+    ];
+    const { installableItems, skippedItems } = collectConflictFilterResult(installItems);
+    const appliedItems = [];
+    for (const installItem of installableItems) {
+        appliedItems.push(await applyInstallItem(installItem));
+    }
+    console.log(renderInstallReport(appliedItems, skippedItems));
+}
+/**
+ * Ensures that all target root directories exist before generated files are written.
+ */
+async function ensureTargetDirectories(targetRoots) {
+    await Promise.all(Object.values(targetRoots).map((dirPath) => fs.ensureDir(dirPath)));
+}
+/**
+ * Returns the markdown source files found directly under a source root.
+ */
+async function collectMarkdownFiles(rootDir) {
+    await fs.ensureDir(rootDir);
+    const matches = await glob([path.join(rootDir, '*.md')]);
+    return matches.sort();
+}
+/**
+ * Writes one markdown file after rendering its frontmatter and body content.
+ */
+async function writeMarkdownFile(filePath, metadata, body) {
+    await fs.ensureDir(path.dirname(filePath));
+    await fs.writeFile(filePath, renderMarkdown({ metadata, body }), 'utf8');
+}
+/**
+ * Detects whether each editor target for one item will be installed or updated.
+ */
+async function detectInstallChanges(installItem) {
+    return Promise.all(installItem.targets.map(async (target) => ({
+        editor: target.editor,
+        changeType: (await fs.pathExists(target.outputPath))
+            ? 'update'
+            : 'install',
+    })));
+}
+/**
+ * Applies one install item and records the change type for each editor target.
+ */
+async function applyInstallItem(installItem) {
+    const changes = await detectInstallChanges(installItem);
+    await installItem.install();
+    return {
+        item: installItem,
+        changes,
+    };
+}
+/**
+ * Collects install operations for command sources after validating their frontmatter.
+ */
+async function collectCommandInstallItems(context, { targetRoots }) {
+    const commandFiles = await collectMarkdownFiles(context.sourceRoots.commands);
+    const installItems = [];
+    for (const filePath of commandFiles) {
+        const fileName = path.basename(filePath, '.md');
+        const rawContent = await fs.readFile(filePath, 'utf8');
+        const { metadata, body } = parseFrontmatter(rawContent);
+        const commandMetadata = validateFrontmatter({
+            filePath,
+            metadata,
+            schema: commandFrontmatterSchema,
+        });
+        if (!commandMetadata) {
+            continue;
+        }
+        const commandName = commandMetadata.name;
+        const description = commandMetadata.description;
+        const copilotPromptPath = path.join(targetRoots.copilotPrompts, `${fileName}.prompt.md`);
+        const cursorSkillPath = path.join(targetRoots.cursorSkills, commandName, 'SKILL.md');
+        const promptMetadata = compactObject({
+            name: commandName,
+            description,
+        });
+        const cursorMetadata = compactObject({
+            name: commandName,
+            description,
+            'disable-model-invocation': commandMetadata.cursor?.['disable-model-invocation'],
+        });
+        installItems.push({
+            kind: 'command',
+            editors: ALL_INSTALL_EDITORS,
+            name: commandName,
+            sourcePath: filePath,
+            ownershipKeys: [
+                `copilot-prompt-path:${copilotPromptPath}`,
+                `cursor-skill-name:${commandName}`,
+            ],
+            targets: [
+                { editor: 'copilot', outputPath: copilotPromptPath },
+                { editor: 'cursor', outputPath: cursorSkillPath },
+            ],
+            install: async () => {
+                await writeMarkdownFile(copilotPromptPath, promptMetadata, body);
+                await writeMarkdownFile(cursorSkillPath, cursorMetadata, body);
+            },
+        });
+    }
+    return installItems;
+}
+/**
+ * Collects install operations for rule sources after validating their frontmatter.
+ */
+async function collectRuleInstallItems(context, { targetRoots }) {
+    const ruleFiles = await collectMarkdownFiles(context.sourceRoots.rules);
+    const installItems = [];
+    for (const filePath of ruleFiles) {
+        const fileName = path.basename(filePath, '.md');
+        const rawContent = await fs.readFile(filePath, 'utf8');
+        const { metadata, body } = parseFrontmatter(rawContent);
+        const ruleMetadata = validateFrontmatter({
+            filePath,
+            metadata,
+            schema: ruleFrontmatterSchema,
+        });
+        if (!ruleMetadata) {
+            continue;
+        }
+        const normalized = normalizeRuleMetadata(ruleMetadata);
+        const copilotInstructionPath = path.join(targetRoots.copilotInstructions, `${fileName}.instructions.md`);
+        const cursorRulePath = path.join(targetRoots.cursorRules, `${fileName}.mdc`);
+        const copilotMetadata = compactObject({
+            description: ruleMetadata.description,
+            applyTo: normalized.applyTo,
+        });
+        const cursorMetadata = compactObject({
+            description: ruleMetadata.description,
+            globs: normalized.alwaysApply ? undefined : normalized.globs,
+            alwaysApply: normalized.alwaysApply,
+        });
+        installItems.push({
+            kind: 'rule',
+            editors: ALL_INSTALL_EDITORS,
+            name: fileName,
+            sourcePath: filePath,
+            ownershipKeys: [
+                `copilot-instruction-path:${copilotInstructionPath}`,
+                `cursor-rule-path:${cursorRulePath}`,
+            ],
+            targets: [
+                { editor: 'copilot', outputPath: copilotInstructionPath },
+                { editor: 'cursor', outputPath: cursorRulePath },
+            ],
+            install: async () => {
+                await writeMarkdownFile(copilotInstructionPath, copilotMetadata, body);
+                await writeMarkdownFile(cursorRulePath, cursorMetadata, body);
+            },
+        });
+    }
+    return installItems;
+}
+/**
+ * Collects install operations for local skill directories.
+ */
+async function collectSkillInstallItems(context, { targetRoots }) {
+    await fs.ensureDir(context.sourceRoots.skills);
+    const entries = await fs.readdir(context.sourceRoots.skills, {
+        withFileTypes: true,
+    });
+    const installItems = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const sourceDir = path.join(context.sourceRoots.skills, entry.name);
+        const copilotSkillPath = path.join(targetRoots.copilotSkills, entry.name);
+        const cursorSkillPath = path.join(targetRoots.cursorSkills, entry.name);
+        installItems.push({
+            kind: 'skill',
+            editors: ALL_INSTALL_EDITORS,
+            name: entry.name,
+            sourcePath: sourceDir,
+            ownershipKeys: [
+                `copilot-skill-name:${entry.name}`,
+                `cursor-skill-name:${entry.name}`,
+            ],
+            targets: [
+                { editor: 'copilot', outputPath: copilotSkillPath },
+                { editor: 'cursor', outputPath: cursorSkillPath },
+            ],
+            install: async () => {
+                await copyDirectoryContents(sourceDir, copilotSkillPath);
+                await copyDirectoryContents(sourceDir, cursorSkillPath);
+            },
+        });
+    }
+    return installItems;
+}
+/**
+ * Copies a skill directory into a target directory after clearing any previous contents.
+ */
+async function copyDirectoryContents(sourceDir, targetDir) {
+    await fs.emptyDir(targetDir);
+    const entryNames = await fs.readdir(sourceDir);
+    for (const entryName of entryNames) {
+        await fs.copy(path.join(sourceDir, entryName), path.join(targetDir, entryName));
+    }
+}
+/**
+ * Collects the installable and skipped items after analyzing output namespace conflicts.
+ */
+function collectConflictFilterResult(items) {
+    const ownershipMap = new Map();
+    for (const item of items) {
+        for (const ownershipKey of item.ownershipKeys) {
+            const existingOwners = ownershipMap.get(ownershipKey);
+            if (existingOwners) {
+                existingOwners.push(item);
+            }
+            else {
+                ownershipMap.set(ownershipKey, [item]);
+            }
+        }
+    }
+    const skippedItemsBySourcePath = new Map();
+    for (const [ownershipKey, owners] of ownershipMap) {
+        if (owners.length < 2) {
+            continue;
+        }
+        const conflictDescription = describeOwnershipKey(ownershipKey);
+        for (const owner of owners) {
+            const existingSkippedItem = skippedItemsBySourcePath.get(owner.sourcePath);
+            if (existingSkippedItem) {
+                existingSkippedItem.conflictDescriptions.push(conflictDescription);
+            }
+            else {
+                skippedItemsBySourcePath.set(owner.sourcePath, {
+                    item: owner,
+                    conflictDescriptions: [conflictDescription],
+                });
+            }
+        }
+    }
+    const skippedItems = [...skippedItemsBySourcePath.values()].map((skippedItem) => ({
+        item: skippedItem.item,
+        conflictDescriptions: [
+            ...new Set(skippedItem.conflictDescriptions),
+        ].sort(),
+    }));
+    const skippedSourcePaths = new Set(skippedItems.map((skippedItem) => skippedItem.item.sourcePath));
+    return {
+        installableItems: items.filter((item) => !skippedSourcePaths.has(item.sourcePath)),
+        skippedItems,
+    };
+}
+/**
+ * Renders an install summary grouped by editor, item kind, and skipped conflicts.
+ */
+function renderInstallReport(appliedItems, skippedItems) {
+    const sections = [chalk.bold.cyan('Applied changes:')];
+    const copilotInstalledItems = collectEditorAppliedInstallItems(appliedItems, 'copilot');
+    const cursorInstalledItems = collectEditorAppliedInstallItems(appliedItems, 'cursor');
+    sections.push(renderEditorInstallSection('Copilot', copilotInstalledItems));
+    sections.push(renderEditorInstallSection('Cursor', cursorInstalledItems));
+    if (skippedItems.length === 0) {
+        sections.push(`${chalk.bold.green('Skipped conflicts:')} ${chalk.green('None')}`);
+    }
+    else {
+        const skippedLines = skippedItems
+            .slice()
+            .sort((left, right) => formatInstallItemLabel(left.item).localeCompare(formatInstallItemLabel(right.item)))
+            .map((skippedItem) => [
+            `- ${chalk.red(formatInstallItemLabel(skippedItem.item))}`,
+            `  * ${chalk.bold.red('due to:')} ${chalk.yellow(skippedItem.conflictDescriptions.join(', '))}`,
+        ].join('\n'));
+        sections.push(`${chalk.bold.red('Skipped conflicts:')}\n${skippedLines.join('\n')}`);
+    }
+    return sections.join('\n\n');
+}
+/**
+ * Collects the applied install items relevant to one editor.
+ */
+function collectEditorAppliedInstallItems(appliedItems, editor) {
+    return appliedItems.flatMap((appliedItem) => appliedItem.changes
+        .filter((change) => change.editor === editor)
+        .map((change) => ({
+        item: appliedItem.item,
+        changeType: change.changeType,
+    })));
+}
+/**
+ * Renders the installed items for one editor grouped by item kind.
+ */
+function renderEditorInstallSection(editorLabel, installedItems) {
+    const kindSections = [
+        renderKindInstallLine('commands', 'command', installedItems),
+        renderKindInstallLine('rules', 'rule', installedItems),
+        renderKindInstallLine('skills', 'skill', installedItems),
+    ].filter((section) => section !== undefined);
+    return [`- ${colorEditorLabel(editorLabel)}`, ...kindSections].join('\n');
+}
+/**
+ * Renders one install summary section for a specific item kind.
+ */
+function renderKindInstallLine(label, kind, installedItems) {
+    const matchingItems = installedItems
+        .filter((item) => item.item.kind === kind)
+        .slice()
+        .sort((left, right) => left.item.name.localeCompare(right.item.name));
+    if (matchingItems.length === 0) {
+        return undefined;
+    }
+    return [
+        `  * ${colorKindLabel(label)}`,
+        ...matchingItems.map(renderAppliedInstallItemLine),
+    ].join('\n');
+}
+/**
+ * Returns the styled editor label used in the install summary.
+ */
+function colorEditorLabel(editorLabel) {
+    return chalk.bold.blue(editorLabel);
+}
+/**
+ * Returns the styled item-kind label used in the install summary.
+ */
+function colorKindLabel(label) {
+    return chalk.bold.yellow(label);
+}
+/**
+ * Returns the styled change-type label used in the install summary.
+ */
+function colorChangeType(changeType) {
+    if (changeType === 'install') {
+        return chalk.green(changeType);
+    }
+    return chalk.yellow(changeType);
+}
+/**
+ * Renders one styled applied-item line in the install summary.
+ */
+function renderAppliedInstallItemLine(matchingItem) {
+    return `    - ${chalk.whiteBright(matchingItem.item.name)} (${colorChangeType(matchingItem.changeType)})`;
+}
+/**
+ * Returns a readable label for one install item in conflict warnings.
+ */
+function formatInstallItemLabel(item) {
+    return `${item.kind} "${item.name}" from ${item.sourcePath}`;
+}
+/**
+ * Converts an internal ownership key into a warning message fragment.
+ */
+function describeOwnershipKey(ownershipKey) {
+    if (ownershipKey.startsWith('cursor-skill-name:')) {
+        return `Cursor skill name "${ownershipKey.slice('cursor-skill-name:'.length)}"`;
+    }
+    if (ownershipKey.startsWith('copilot-skill-name:')) {
+        return `Copilot skill name "${ownershipKey.slice('copilot-skill-name:'.length)}"`;
+    }
+    if (ownershipKey.startsWith('copilot-prompt-path:')) {
+        return `Copilot prompt output "${ownershipKey.slice('copilot-prompt-path:'.length)}"`;
+    }
+    if (ownershipKey.startsWith('copilot-instruction-path:')) {
+        return `Copilot instruction output "${ownershipKey.slice('copilot-instruction-path:'.length)}"`;
+    }
+    if (ownershipKey.startsWith('cursor-rule-path:')) {
+        return `Cursor rule output "${ownershipKey.slice('cursor-rule-path:'.length)}"`;
+    }
+    return `output namespace "${ownershipKey}"`;
+}