skillpkg-core 0.2.0 → 0.3.0

package/dist/state/types.d.ts

@@ -0,0 +1,86 @@
+/**
+ * State types (state.json)
+ *
+ * Tracks installation state, dependencies, and sync history
+ */
+import type { SyncTarget } from '../config/types.js';
+/**
+ * Schema version for state.json
+ */
+export declare const STATE_SCHEMA_VERSION = "skillpkg-state-v1";
+/**
+ * Who installed a skill
+ */
+export type InstalledBy = 'user' | string;
+/**
+ * Skill installation state
+ */
+export interface SkillState {
+    /** Installed version */
+    version: string;
+    /** Source (github:user/repo, URL, or local path) */
+    source: string;
+    /** Who installed this skill ('user' or skill name that depends on it) */
+    installed_by: InstalledBy;
+    /** Installation timestamp (ISO 8601) */
+    installed_at: string;
+    /** Skills that depend on this skill */
+    depended_by: string[];
+}
+/**
+ * MCP installation state
+ */
+export interface McpState {
+    /** npm package name */
+    package: string;
+    /** Skill that required this MCP (null if manually installed) */
+    installed_by_skill: string | null;
+    /** Installation timestamp (ISO 8601) */
+    installed_at: string;
+}
+/**
+ * Sync history for each target
+ */
+export type SyncHistory = Partial<Record<SyncTarget, string>>;
+/**
+ * Complete state (state.json)
+ */
+export interface State {
+    /** Schema version */
+    $schema: string;
+    /** Installed skills */
+    skills: Record<string, SkillState>;
+    /** Installed MCP servers */
+    mcp: Record<string, McpState>;
+    /** Last sync timestamp for each target */
+    sync_history: SyncHistory;
+}
+/**
+ * Skill install info (for recording)
+ */
+export interface SkillInstallInfo {
+    version: string;
+    source: string;
+    installed_by: InstalledBy;
+}
+/**
+ * MCP install info (for recording)
+ */
+export interface McpInstallInfo {
+    package: string;
+    installed_by_skill: string | null;
+}
+/**
+ * Uninstall check result
+ */
+export interface UninstallCheck {
+    /** Can the skill be safely uninstalled */
+    canUninstall: boolean;
+    /** Skills that depend on this skill */
+    dependents: string[];
+}
+/**
+ * Create an empty state
+ */
+export declare function createEmptyState(): State;
+//# sourceMappingURL=types.d.ts.map

package/dist/state/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/state/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD;;GAEG;AACH,eAAO,MAAM,oBAAoB,sBAAsB,CAAC;AAExD;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,MAAM,CAAC;AAE1C;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,wBAAwB;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,oDAAoD;IACpD,MAAM,EAAE,MAAM,CAAC;IACf,yEAAyE;IACzE,YAAY,EAAE,WAAW,CAAC;IAC1B,wCAAwC;IACxC,YAAY,EAAE,MAAM,CAAC;IACrB,uCAAuC;IACvC,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,uBAAuB;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,gEAAgE;IAChE,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,wCAAwC;IACxC,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,CAAC;AAE9D;;GAEG;AACH,MAAM,WAAW,KAAK;IACpB,qBAAqB;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,uBAAuB;IACvB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACnC,4BAA4B;IAC5B,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAC9B,0CAA0C;IAC1C,YAAY,EAAE,WAAW,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,WAAW,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,0CAA0C;IAC1C,YAAY,EAAE,OAAO,CAAC;IACtB,uCAAuC;IACvC,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,KAAK,CAOxC"}

package/dist/state/types.js

@@ -0,0 +1,21 @@
+/**
+ * State types (state.json)
+ *
+ * Tracks installation state, dependencies, and sync history
+ */
+/**
+ * Schema version for state.json
+ */
+export const STATE_SCHEMA_VERSION = 'skillpkg-state-v1';
+/**
+ * Create an empty state
+ */
+export function createEmptyState() {
+    return {
+        $schema: STATE_SCHEMA_VERSION,
+        skills: {},
+        mcp: {},
+        sync_history: {},
+    };
+}
+//# sourceMappingURL=types.js.map

package/dist/state/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/state/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH;;GAEG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,mBAAmB,CAAC;AAiFxD;;GAEG;AACH,MAAM,UAAU,gBAAgB;IAC9B,OAAO;QACL,OAAO,EAAE,oBAAoB;QAC7B,MAAM,EAAE,EAAE;QACV,GAAG,EAAE,EAAE;QACP,YAAY,EAAE,EAAE;KACjB,CAAC;AACJ,CAAC"}

package/dist/syncer/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Syncer module - Sync skills to AI tool directories
+ *
+ * @example
+ * ```typescript
+ * import { createSyncer, loadSkillsFromDirectory } from '@skillpkg/core';
+ *
+ * // Load skills
+ * const skills = await loadSkillsFromDirectory('.skillpkg/skills');
+ *
+ * // Create syncer
+ * const syncer = createSyncer();
+ *
+ * // Sync to all enabled targets
+ * const result = await syncer.syncAll(projectPath, skills, config);
+ *
+ * // Or sync to a specific target
+ * const targetResult = await syncer.syncToTarget(
+ *   projectPath,
+ *   skills,
+ *   getTargetConfig('claude-code')
+ * );
+ * ```
+ */
+export type { SyncFormat, FrontmatterHandling, TargetConfig, SkillContent, SyncerOptions, FileSyncResult, TargetSyncResult, SyncerResult, McpJsonConfig, } from './types.js';
+export { TARGET_CONFIGS, getTargetConfig, getImplementedTargets, getAllTargets, } from './types.js';
+export { Syncer, createSyncer, loadSkillContent, loadSkillsFromDirectory, } from './syncer.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/syncer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/syncer/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,YAAY,EACV,UAAU,EACV,mBAAmB,EACnB,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,cAAc,EACd,gBAAgB,EAChB,YAAY,EACZ,aAAa,GACd,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,cAAc,EACd,eAAe,EACf,qBAAqB,EACrB,aAAa,GACd,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,MAAM,EACN,YAAY,EACZ,gBAAgB,EAChB,uBAAuB,GACxB,MAAM,aAAa,CAAC"}

package/dist/syncer/index.js

@@ -0,0 +1,28 @@
+/**
+ * Syncer module - Sync skills to AI tool directories
+ *
+ * @example
+ * ```typescript
+ * import { createSyncer, loadSkillsFromDirectory } from '@skillpkg/core';
+ *
+ * // Load skills
+ * const skills = await loadSkillsFromDirectory('.skillpkg/skills');
+ *
+ * // Create syncer
+ * const syncer = createSyncer();
+ *
+ * // Sync to all enabled targets
+ * const result = await syncer.syncAll(projectPath, skills, config);
+ *
+ * // Or sync to a specific target
+ * const targetResult = await syncer.syncToTarget(
+ *   projectPath,
+ *   skills,
+ *   getTargetConfig('claude-code')
+ * );
+ * ```
+ */
+export { TARGET_CONFIGS, getTargetConfig, getImplementedTargets, getAllTargets, } from './types.js';
+// Syncer
+export { Syncer, createSyncer, loadSkillContent, loadSkillsFromDirectory, } from './syncer.js';
+//# sourceMappingURL=index.js.map

package/dist/syncer/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/syncer/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAeH,OAAO,EACL,cAAc,EACd,eAAe,EACf,qBAAqB,EACrB,aAAa,GACd,MAAM,YAAY,CAAC;AAEpB,SAAS;AACT,OAAO,EACL,MAAM,EACN,YAAY,EACZ,gBAAgB,EAChB,uBAAuB,GACxB,MAAM,aAAa,CAAC"}

package/dist/syncer/syncer.d.ts

@@ -0,0 +1,74 @@
+import type { SkillpkgConfig, McpConfig } from '../config/types.js';
+import type { StateManager } from '../state/index.js';
+import type { TargetConfig, SkillContent, SyncerOptions, SyncerResult, TargetSyncResult } from './types.js';
+/**
+ * Syncer class - syncs skills to AI tool directories
+ */
+export declare class Syncer {
+    private stateManager?;
+    constructor(stateManager?: StateManager);
+    /**
+     * Sync all skills to all enabled targets
+     */
+    syncAll(projectPath: string, skills: Map<string, SkillContent>, config: SkillpkgConfig, options?: SyncerOptions): Promise<SyncerResult>;
+    /**
+     * Sync skills to a single target
+     */
+    syncToTarget(projectPath: string, skills: Map<string, SkillContent>, targetConfig: TargetConfig, options?: SyncerOptions): Promise<TargetSyncResult>;
+    /**
+     * Sync in directory format (each skill in its own directory)
+     */
+    private syncDirectoryFormat;
+    /**
+     * Sync in single-file format (all skills merged)
+     */
+    private syncSingleFileFormat;
+    /**
+     * Transform skill content for a specific target
+     */
+    transformForTarget(skill: SkillContent, targetConfig: TargetConfig): string;
+    /**
+     * Merge multiple skills into a single file
+     */
+    private mergeSkillsForTarget;
+    /**
+     * Cleanup orphaned skill directories
+     */
+    private cleanupOrphans;
+    /**
+     * Sync MCP configuration to .mcp.json
+     */
+    syncMcpConfig(projectPath: string, mcpConfigs: Record<string, McpConfig>, options?: SyncerOptions): Promise<{
+        path: string;
+        action: 'created' | 'updated' | 'unchanged';
+    }>;
+    /**
+     * Determine what action is needed for a file
+     */
+    private getFileAction;
+    /**
+     * Hash content for comparison
+     */
+    private hashContent;
+    /**
+     * Get list of enabled targets from config
+     */
+    private getEnabledTargets;
+}
+/**
+ * Create a Syncer instance
+ */
+export declare function createSyncer(stateManager?: StateManager): Syncer;
+/**
+ * Load skill content from a SKILL.md file
+ *
+ * Supports two formats:
+ * 1. YAML files (skill.yaml)
+ * 2. Markdown with YAML frontmatter (SKILL.md)
+ */
+export declare function loadSkillContent(filePath: string): Promise<SkillContent>;
+/**
+ * Load all skills from a directory
+ */
+export declare function loadSkillsFromDirectory(skillsDir: string): Promise<Map<string, SkillContent>>;
+//# sourceMappingURL=syncer.d.ts.map

package/dist/syncer/syncer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"syncer.d.ts","sourceRoot":"","sources":["../../src/syncer/syncer.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAA2B,cAAc,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC7F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EACV,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,gBAAgB,EAEjB,MAAM,YAAY,CAAC;AAIpB;;GAEG;AACH,qBAAa,MAAM;IACjB,OAAO,CAAC,YAAY,CAAC,CAAe;gBAExB,YAAY,CAAC,EAAE,YAAY;IAIvC;;OAEG;IACG,OAAO,CACX,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,EACjC,MAAM,EAAE,cAAc,EACtB,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,YAAY,CAAC;IAoFxB;;OAEG;IACG,YAAY,CAChB,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,EACjC,YAAY,EAAE,YAAY,EAC1B,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,gBAAgB,CAAC;IAmD5B;;OAEG;YACW,mBAAmB;IAiCjC;;OAEG;YACW,oBAAoB;IA8BlC;;OAEG;IACH,kBAAkB,CAAC,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,GAAG,MAAM;IAc3E;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAyB5B;;OAEG;YACW,cAAc;IAgD5B;;OAEG;IACG,aAAa,CACjB,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,EACrC,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,WAAW,CAAA;KAAE,CAAC;IA2BzE;;OAEG;YACW,aAAa;IAyB3B;;OAEG;IACH,OAAO,CAAC,WAAW;IAInB;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAe1B;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,YAAY,CAAC,EAAE,YAAY,GAAG,MAAM,CAEhE;AAED;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CA2B9E;AAkCD;;GAEG;AACH,wBAAsB,uBAAuB,CAC3C,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CA0BpC"}

package/dist/syncer/syncer.js

@@ -0,0 +1,405 @@
+/**
+ * Syncer - Sync skills to AI tool directories
+ */
+import { readFile, writeFile, mkdir, readdir, unlink } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join, relative } from 'path';
+import { createHash } from 'crypto';
+import { getTargetConfig } from './types.js';
+import { parse } from '../parser/index.js';
+/**
+ * Syncer class - syncs skills to AI tool directories
+ */
+export class Syncer {
+    stateManager;
+    constructor(stateManager) {
+        this.stateManager = stateManager;
+    }
+    /**
+     * Sync all skills to all enabled targets
+     */
+    async syncAll(projectPath, skills, config, options = {}) {
+        const result = {
+            targets: [],
+            success: true,
+            stats: {
+                skillsSynced: 0,
+                filesCreated: 0,
+                filesUpdated: 0,
+                filesUnchanged: 0,
+                filesDeleted: 0,
+            },
+        };
+        // Get enabled targets
+        const enabledTargets = this.getEnabledTargets(config.sync_targets);
+        // Sync to each target
+        for (const target of enabledTargets) {
+            const targetConfig = getTargetConfig(target);
+            // Skip unimplemented targets
+            if (!targetConfig.implemented) {
+                result.targets.push({
+                    target,
+                    success: false,
+                    files: [],
+                    errors: [`Target '${target}' is not yet implemented`],
+                    warnings: [],
+                });
+                continue;
+            }
+            const targetResult = await this.syncToTarget(projectPath, skills, targetConfig, options);
+            result.targets.push(targetResult);
+            if (!targetResult.success) {
+                result.success = false;
+            }
+            // Aggregate stats
+            for (const file of targetResult.files) {
+                switch (file.action) {
+                    case 'created':
+                        result.stats.filesCreated++;
+                        break;
+                    case 'updated':
+                        result.stats.filesUpdated++;
+                        break;
+                    case 'unchanged':
+                        result.stats.filesUnchanged++;
+                        break;
+                    case 'deleted':
+                        result.stats.filesDeleted++;
+                        break;
+                }
+            }
+        }
+        result.stats.skillsSynced = skills.size;
+        // Sync MCP config if applicable
+        if (config.mcp && Object.keys(config.mcp).length > 0) {
+            const mcpResult = await this.syncMcpConfig(projectPath, config.mcp, options);
+            result.mcpConfig = mcpResult;
+        }
+        // Update sync history in state
+        if (this.stateManager && !options.dryRun) {
+            for (const targetResult of result.targets) {
+                if (targetResult.success) {
+                    await this.stateManager.recordSync(projectPath, targetResult.target);
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Sync skills to a single target
+     */
+    async syncToTarget(projectPath, skills, targetConfig, options = {}) {
+        const result = {
+            target: targetConfig.id,
+            success: true,
+            files: [],
+            errors: [],
+            warnings: [],
+        };
+        try {
+            const outputDir = join(projectPath, targetConfig.outputPath);
+            // Ensure output directory exists
+            if (!options.dryRun) {
+                await mkdir(outputDir, { recursive: true });
+            }
+            if (targetConfig.format === 'directory') {
+                // Directory format: each skill in its own directory
+                await this.syncDirectoryFormat(projectPath, outputDir, skills, targetConfig, result, options);
+            }
+            else {
+                // Single-file format: all skills merged into one file
+                await this.syncSingleFileFormat(projectPath, outputDir, skills, targetConfig, result, options);
+            }
+            // Clean up orphaned skill directories (only for directory format)
+            if (targetConfig.format === 'directory' && !options.dryRun) {
+                await this.cleanupOrphans(outputDir, skills, targetConfig, result);
+            }
+        }
+        catch (error) {
+            result.success = false;
+            result.errors.push(error instanceof Error ? error.message : String(error));
+        }
+        return result;
+    }
+    /**
+     * Sync in directory format (each skill in its own directory)
+     */
+    async syncDirectoryFormat(projectPath, outputDir, skills, targetConfig, result, options) {
+        for (const [name, skill] of skills) {
+            const skillDir = join(outputDir, name);
+            const skillFile = join(skillDir, targetConfig.skillFileName);
+            const relativePath = relative(projectPath, skillFile);
+            // Transform content for target
+            const content = this.transformForTarget(skill, targetConfig);
+            // Check if file needs updating
+            const action = await this.getFileAction(skillFile, content, options);
+            if (action === 'unchanged') {
+                result.files.push({ path: relativePath, action, skillName: name });
+                continue;
+            }
+            if (!options.dryRun) {
+                await mkdir(skillDir, { recursive: true });
+                await writeFile(skillFile, content, 'utf-8');
+            }
+            result.files.push({ path: relativePath, action, skillName: name });
+        }
+    }
+    /**
+     * Sync in single-file format (all skills merged)
+     */
+    async syncSingleFileFormat(projectPath, outputDir, skills, targetConfig, result, options) {
+        const outputFile = join(outputDir, targetConfig.skillFileName);
+        const relativePath = relative(projectPath, outputFile);
+        // Merge all skills into one file
+        const content = this.mergeSkillsForTarget(skills, targetConfig);
+        // Check if file needs updating
+        const action = await this.getFileAction(outputFile, content, options);
+        if (action === 'unchanged') {
+            result.files.push({ path: relativePath, action });
+            return;
+        }
+        if (!options.dryRun) {
+            await mkdir(outputDir, { recursive: true });
+            await writeFile(outputFile, content, 'utf-8');
+        }
+        result.files.push({ path: relativePath, action });
+    }
+    /**
+     * Transform skill content for a specific target
+     */
+    transformForTarget(skill, targetConfig) {
+        switch (targetConfig.frontmatter) {
+            case 'keep':
+                return skill.rawContent;
+            case 'remove':
+                return skill.bodyContent;
+            case 'convert':
+                // Future: convert frontmatter to target-specific format
+                return skill.bodyContent;
+            default:
+                return skill.rawContent;
+        }
+    }
+    /**
+     * Merge multiple skills into a single file
+     */
+    mergeSkillsForTarget(skills, targetConfig) {
+        const sections = [];
+        // Add header based on target
+        if (targetConfig.id === 'codex') {
+            sections.push('# AGENTS\n');
+            sections.push('This file contains AI agent skills for this project.\n');
+        }
+        else if (targetConfig.id === 'copilot') {
+            sections.push('# GitHub Copilot Instructions\n');
+            sections.push('These are custom instructions for GitHub Copilot.\n');
+        }
+        // Add each skill as a section
+        for (const [name, skill] of skills) {
+            sections.push(`\n---\n`);
+            sections.push(`## ${name} (v${skill.version})\n`);
+            sections.push(skill.bodyContent);
+        }
+        return sections.join('\n');
+    }
+    /**
+     * Cleanup orphaned skill directories
+     */
+    async cleanupOrphans(outputDir, skills, targetConfig, result) {
+        if (!existsSync(outputDir))
+            return;
+        try {
+            const entries = await readdir(outputDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const skillName = entry.name;
+                // Skip if skill exists in current list
+                if (skills.has(skillName))
+                    continue;
+                // This is an orphan - delete it
+                const skillDir = join(outputDir, skillName);
+                const skillFile = join(skillDir, targetConfig.skillFileName);
+                if (existsSync(skillFile)) {
+                    await unlink(skillFile);
+                    result.files.push({
+                        path: relative(outputDir, skillFile),
+                        action: 'deleted',
+                        skillName,
+                    });
+                }
+                // Try to remove empty directory
+                try {
+                    const remaining = await readdir(skillDir);
+                    if (remaining.length === 0) {
+                        const { rmdir } = await import('fs/promises');
+                        await rmdir(skillDir);
+                    }
+                }
+                catch {
+                    // Ignore errors when removing directory
+                }
+            }
+        }
+        catch {
+            // Ignore errors during cleanup
+        }
+    }
+    /**
+     * Sync MCP configuration to .mcp.json
+     */
+    async syncMcpConfig(projectPath, mcpConfigs, options = {}) {
+        const mcpJsonPath = join(projectPath, '.mcp.json');
+        const relativePath = '.mcp.json';
+        // Build MCP JSON config
+        const mcpJson = {
+            mcpServers: {},
+        };
+        for (const [name, config] of Object.entries(mcpConfigs)) {
+            mcpJson.mcpServers[name] = {
+                command: config.command || `npx ${config.package}`,
+                args: config.args,
+                env: config.env,
+            };
+        }
+        const content = JSON.stringify(mcpJson, null, 2);
+        const action = await this.getFileAction(mcpJsonPath, content, options);
+        if (action !== 'unchanged' && !options.dryRun) {
+            await writeFile(mcpJsonPath, content, 'utf-8');
+        }
+        return { path: relativePath, action };
+    }
+    /**
+     * Determine what action is needed for a file
+     */
+    async getFileAction(filePath, newContent, options) {
+        if (!existsSync(filePath)) {
+            return 'created';
+        }
+        if (options.force) {
+            return 'updated';
+        }
+        // Compare content hash
+        try {
+            const existingContent = await readFile(filePath, 'utf-8');
+            const existingHash = this.hashContent(existingContent);
+            const newHash = this.hashContent(newContent);
+            return existingHash === newHash ? 'unchanged' : 'updated';
+        }
+        catch {
+            return 'updated';
+        }
+    }
+    /**
+     * Hash content for comparison
+     */
+    hashContent(content) {
+        return createHash('md5').update(content).digest('hex');
+    }
+    /**
+     * Get list of enabled targets from config
+     */
+    getEnabledTargets(syncTargets) {
+        if (!syncTargets) {
+            // Default to claude-code only
+            return ['claude-code'];
+        }
+        const enabled = [];
+        for (const [target, isEnabled] of Object.entries(syncTargets)) {
+            if (isEnabled) {
+                enabled.push(target);
+            }
+        }
+        return enabled.length > 0 ? enabled : ['claude-code'];
+    }
+}
+/**
+ * Create a Syncer instance
+ */
+export function createSyncer(stateManager) {
+    return new Syncer(stateManager);
+}
+/**
+ * Load skill content from a SKILL.md file
+ *
+ * Supports two formats:
+ * 1. YAML files (skill.yaml)
+ * 2. Markdown with YAML frontmatter (SKILL.md)
+ */
+export async function loadSkillContent(filePath) {
+    const rawContent = await readFile(filePath, 'utf-8');
+    // Check if it's a YAML file
+    if (filePath.endsWith('.yaml') || filePath.endsWith('.yml')) {
+        const result = parse(rawContent, { validate: false });
+        if (result.success && result.data) {
+            return {
+                name: result.data.name || 'unknown',
+                version: result.data.version || '1.0.0',
+                rawContent,
+                bodyContent: result.data.instructions || rawContent,
+                frontmatter: result.data,
+            };
+        }
+    }
+    // Parse markdown with YAML frontmatter
+    const { frontmatter, body } = parseMarkdownFrontmatter(rawContent);
+    return {
+        name: frontmatter.name || 'unknown',
+        version: frontmatter.version || '1.0.0',
+        rawContent,
+        bodyContent: body || rawContent,
+        frontmatter,
+    };
+}
+/**
+ * Parse YAML frontmatter from markdown content
+ */
+function parseMarkdownFrontmatter(content) {
+    const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+    const match = content.match(frontmatterRegex);
+    if (!match) {
+        // No frontmatter, return empty frontmatter and full content as body
+        return { frontmatter: {}, body: content };
+    }
+    const [, yamlContent, body] = match;
+    try {
+        const result = parse(yamlContent, { validate: false });
+        if (result.success && result.data) {
+            return {
+                frontmatter: result.data,
+                body: body.trim(),
+            };
+        }
+    }
+    catch {
+        // Parse error, return empty frontmatter
+    }
+    return { frontmatter: {}, body: content };
+}
+/**
+ * Load all skills from a directory
+ */
+export async function loadSkillsFromDirectory(skillsDir) {
+    const skills = new Map();
+    if (!existsSync(skillsDir)) {
+        return skills;
+    }
+    const entries = await readdir(skillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const skillDir = join(skillsDir, entry.name);
+        const skillFile = join(skillDir, 'SKILL.md');
+        if (!existsSync(skillFile))
+            continue;
+        try {
+            const skill = await loadSkillContent(skillFile);
+            skills.set(entry.name, skill);
+        }
+        catch {
+            // Skip invalid skill files
+        }
+    }
+    return skills;
+}
+//# sourceMappingURL=syncer.js.map