@skillkit/core 1.3.0

package/dist/index.d.ts

@@ -0,0 +1,2234 @@
+import { z } from 'zod';
+
+declare const AgentType: z.ZodEnum<["claude-code", "codex", "cursor", "antigravity", "opencode", "gemini-cli", "amp", "clawdbot", "droid", "github-copilot", "goose", "kilo", "kiro-cli", "roo", "trae", "windsurf", "universal"]>;
+type AgentType = z.infer<typeof AgentType>;
+declare const GitProvider: z.ZodEnum<["github", "gitlab", "bitbucket", "local"]>;
+type GitProvider = z.infer<typeof GitProvider>;
+declare const SkillFrontmatter: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    license: z.ZodOptional<z.ZodString>;
+    compatibility: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    'allowed-tools': z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    agents: z.ZodOptional<z.ZodArray<z.ZodEnum<["claude-code", "codex", "cursor", "antigravity", "opencode", "gemini-cli", "amp", "clawdbot", "droid", "github-copilot", "goose", "kilo", "kiro-cli", "roo", "trae", "windsurf", "universal"]>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    license?: string | undefined;
+    compatibility?: string | undefined;
+    metadata?: Record<string, string> | undefined;
+    'allowed-tools'?: string | undefined;
+    version?: string | undefined;
+    author?: string | undefined;
+    tags?: string[] | undefined;
+    agents?: ("claude-code" | "codex" | "cursor" | "antigravity" | "opencode" | "gemini-cli" | "amp" | "clawdbot" | "droid" | "github-copilot" | "goose" | "kilo" | "kiro-cli" | "roo" | "trae" | "windsurf" | "universal")[] | undefined;
+}, {
+    name: string;
+    description: string;
+    license?: string | undefined;
+    compatibility?: string | undefined;
+    metadata?: Record<string, string> | undefined;
+    'allowed-tools'?: string | undefined;
+    version?: string | undefined;
+    author?: string | undefined;
+    tags?: string[] | undefined;
+    agents?: ("claude-code" | "codex" | "cursor" | "antigravity" | "opencode" | "gemini-cli" | "amp" | "clawdbot" | "droid" | "github-copilot" | "goose" | "kilo" | "kiro-cli" | "roo" | "trae" | "windsurf" | "universal")[] | undefined;
+}>;
+type SkillFrontmatter = z.infer<typeof SkillFrontmatter>;
+declare const SkillMetadata: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    source: z.ZodString;
+    sourceType: z.ZodEnum<["github", "gitlab", "bitbucket", "local"]>;
+    subpath: z.ZodOptional<z.ZodString>;
+    installedAt: z.ZodString;
+    updatedAt: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    version: z.ZodOptional<z.ZodString>;
+    checksum: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    source: string;
+    sourceType: "github" | "gitlab" | "bitbucket" | "local";
+    installedAt: string;
+    enabled: boolean;
+    version?: string | undefined;
+    subpath?: string | undefined;
+    updatedAt?: string | undefined;
+    checksum?: string | undefined;
+}, {
+    name: string;
+    description: string;
+    source: string;
+    sourceType: "github" | "gitlab" | "bitbucket" | "local";
+    installedAt: string;
+    version?: string | undefined;
+    subpath?: string | undefined;
+    updatedAt?: string | undefined;
+    enabled?: boolean | undefined;
+    checksum?: string | undefined;
+}>;
+type SkillMetadata = z.infer<typeof SkillMetadata>;
+declare const SkillLocation: z.ZodEnum<["project", "global"]>;
+type SkillLocation = z.infer<typeof SkillLocation>;
+declare const Skill: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    path: z.ZodString;
+    location: z.ZodEnum<["project", "global"]>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        source: z.ZodString;
+        sourceType: z.ZodEnum<["github", "gitlab", "bitbucket", "local"]>;
+        subpath: z.ZodOptional<z.ZodString>;
+        installedAt: z.ZodString;
+        updatedAt: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        version: z.ZodOptional<z.ZodString>;
+        checksum: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description: string;
+        source: string;
+        sourceType: "github" | "gitlab" | "bitbucket" | "local";
+        installedAt: string;
+        enabled: boolean;
+        version?: string | undefined;
+        subpath?: string | undefined;
+        updatedAt?: string | undefined;
+        checksum?: string | undefined;
+    }, {
+        name: string;
+        description: string;
+        source: string;
+        sourceType: "github" | "gitlab" | "bitbucket" | "local";
+        installedAt: string;
+        version?: string | undefined;
+        subpath?: string | undefined;
+        updatedAt?: string | undefined;
+        enabled?: boolean | undefined;
+        checksum?: string | undefined;
+    }>>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    name: string;
+    description: string;
+    enabled: boolean;
+    location: "project" | "global";
+    metadata?: {
+        name: string;
+        description: string;
+        source: string;
+        sourceType: "github" | "gitlab" | "bitbucket" | "local";
+        installedAt: string;
+        enabled: boolean;
+        version?: string | undefined;
+        subpath?: string | undefined;
+        updatedAt?: string | undefined;
+        checksum?: string | undefined;
+    } | undefined;
+}, {
+    path: string;
+    name: string;
+    description: string;
+    location: "project" | "global";
+    metadata?: {
+        name: string;
+        description: string;
+        source: string;
+        sourceType: "github" | "gitlab" | "bitbucket" | "local";
+        installedAt: string;
+        version?: string | undefined;
+        subpath?: string | undefined;
+        updatedAt?: string | undefined;
+        enabled?: boolean | undefined;
+        checksum?: string | undefined;
+    } | undefined;
+    enabled?: boolean | undefined;
+}>;
+type Skill = z.infer<typeof Skill>;
+declare const SkillkitConfig: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    agent: z.ZodDefault<z.ZodEnum<["claude-code", "codex", "cursor", "antigravity", "opencode", "gemini-cli", "amp", "clawdbot", "droid", "github-copilot", "goose", "kilo", "kiro-cli", "roo", "trae", "windsurf", "universal"]>>;
+    skillsDir: z.ZodOptional<z.ZodString>;
+    enabledSkills: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    disabledSkills: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    autoSync: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    version: 1;
+    agent: "claude-code" | "codex" | "cursor" | "antigravity" | "opencode" | "gemini-cli" | "amp" | "clawdbot" | "droid" | "github-copilot" | "goose" | "kilo" | "kiro-cli" | "roo" | "trae" | "windsurf" | "universal";
+    autoSync: boolean;
+    skillsDir?: string | undefined;
+    enabledSkills?: string[] | undefined;
+    disabledSkills?: string[] | undefined;
+}, {
+    version: 1;
+    agent?: "claude-code" | "codex" | "cursor" | "antigravity" | "opencode" | "gemini-cli" | "amp" | "clawdbot" | "droid" | "github-copilot" | "goose" | "kilo" | "kiro-cli" | "roo" | "trae" | "windsurf" | "universal" | undefined;
+    skillsDir?: string | undefined;
+    enabledSkills?: string[] | undefined;
+    disabledSkills?: string[] | undefined;
+    autoSync?: boolean | undefined;
+}>;
+type SkillkitConfig = z.infer<typeof SkillkitConfig>;
+interface InstallOptions {
+    global?: boolean;
+    skills?: string[];
+    provider?: GitProvider;
+    yes?: boolean;
+    force?: boolean;
+}
+interface SyncOptions {
+    output?: string;
+    agent?: AgentType;
+    yes?: boolean;
+    enabledOnly?: boolean;
+}
+interface UpdateOptions {
+    skills?: string[];
+    all?: boolean;
+    force?: boolean;
+}
+interface RegistrySkill {
+    name: string;
+    description: string;
+    source: string;
+    provider: GitProvider;
+    downloads?: number;
+    stars?: number;
+    tags?: string[];
+}
+interface DiscoveredSkill {
+    name: string;
+    dirName: string;
+    path: string;
+}
+interface CloneResult {
+    success: boolean;
+    path?: string;
+    tempRoot?: string;
+    error?: string;
+    skills?: string[];
+    discoveredSkills?: DiscoveredSkill[];
+}
+interface CommandResult {
+    success: boolean;
+    message: string;
+    data?: unknown;
+}
+interface AgentAdapterInfo {
+    type: AgentType;
+    name: string;
+    skillsDir: string;
+    configFile: string;
+}
+
+declare const SKILL_DISCOVERY_PATHS: string[];
+declare function discoverSkills(rootDir: string): Skill[];
+declare function parseSkill(skillPath: string, location?: SkillLocation): Skill | null;
+declare function extractFrontmatter(content: string): Record<string, unknown> | null;
+declare function extractField(content: string, field: string): string | null;
+declare function loadMetadata(skillPath: string): SkillMetadata | null;
+declare function readSkillContent(skillPath: string): string | null;
+declare function findSkill(name: string, searchDirs: string[]): Skill | null;
+declare function findAllSkills(searchDirs: string[]): Skill[];
+declare function validateSkill(skillPath: string): {
+    valid: boolean;
+    errors: string[];
+    warnings?: string[];
+};
+declare function isPathInside(child: string, parent: string): boolean;
+
+declare function getProjectConfigPath(): string;
+declare function getGlobalConfigPath(): string;
+declare function loadConfig(): SkillkitConfig;
+declare function saveConfig(config: SkillkitConfig, global?: boolean): void;
+declare function getSearchDirs(adapter: AgentAdapterInfo): string[];
+declare function getInstallDir(adapter: AgentAdapterInfo, global?: boolean): string;
+declare function getAgentConfigPath(adapter: AgentAdapterInfo): string;
+declare function saveSkillMetadata(skillPath: string, metadata: SkillMetadata): void;
+declare function loadSkillMetadata(skillPath: string): SkillMetadata | null;
+declare function setSkillEnabled(skillPath: string, enabled: boolean): boolean;
+declare function initProject(type: AgentType, adapter: AgentAdapterInfo): Promise<void>;
+
+interface GitProviderAdapter {
+    readonly type: GitProvider;
+    readonly name: string;
+    readonly baseUrl: string;
+    parseSource(source: string): {
+        owner: string;
+        repo: string;
+        subpath?: string;
+    } | null;
+    matches(source: string): boolean;
+    getCloneUrl(owner: string, repo: string): string;
+    getSshUrl(owner: string, repo: string): string;
+    clone(source: string, targetDir: string, options?: CloneOptions): Promise<CloneResult>;
+}
+interface CloneOptions {
+    depth?: number;
+    branch?: string;
+    ssh?: boolean;
+}
+declare function parseShorthand(source: string): {
+    owner: string;
+    repo: string;
+    subpath?: string;
+} | null;
+declare function isLocalPath(source: string): boolean;
+declare function isGitUrl(source: string): boolean;
+
+declare class GitHubProvider implements GitProviderAdapter {
+    readonly type: GitProvider;
+    readonly name = "GitHub";
+    readonly baseUrl = "https://github.com";
+    parseSource(source: string): {
+        owner: string;
+        repo: string;
+        subpath?: string;
+    } | null;
+    matches(source: string): boolean;
+    getCloneUrl(owner: string, repo: string): string;
+    getSshUrl(owner: string, repo: string): string;
+    clone(source: string, _targetDir: string, options?: CloneOptions): Promise<CloneResult>;
+}
+
+declare class GitLabProvider implements GitProviderAdapter {
+    readonly type: GitProvider;
+    readonly name = "GitLab";
+    readonly baseUrl = "https://gitlab.com";
+    parseSource(source: string): {
+        owner: string;
+        repo: string;
+        subpath?: string;
+    } | null;
+    matches(source: string): boolean;
+    getCloneUrl(owner: string, repo: string): string;
+    getSshUrl(owner: string, repo: string): string;
+    clone(source: string, _targetDir: string, options?: CloneOptions): Promise<CloneResult>;
+}
+
+declare class BitbucketProvider implements GitProviderAdapter {
+    readonly type: GitProvider;
+    readonly name = "Bitbucket";
+    readonly baseUrl = "https://bitbucket.org";
+    parseSource(source: string): {
+        owner: string;
+        repo: string;
+        subpath?: string;
+    } | null;
+    matches(source: string): boolean;
+    getCloneUrl(owner: string, repo: string): string;
+    getSshUrl(owner: string, repo: string): string;
+    clone(source: string, _targetDir: string, options?: CloneOptions): Promise<CloneResult>;
+}
+
+declare class LocalProvider implements GitProviderAdapter {
+    readonly type: GitProvider;
+    readonly name = "Local Filesystem";
+    readonly baseUrl = "";
+    parseSource(source: string): {
+        owner: string;
+        repo: string;
+        subpath?: string;
+    } | null;
+    matches(source: string): boolean;
+    getCloneUrl(_owner: string, _repo: string): string;
+    getSshUrl(_owner: string, _repo: string): string;
+    clone(source: string, _targetDir: string, _options?: CloneOptions): Promise<CloneResult>;
+}
+
+declare function getProvider(type: GitProvider): GitProviderAdapter | undefined;
+declare function getAllProviders(): GitProviderAdapter[];
+declare function detectProvider(source: string): GitProviderAdapter | undefined;
+declare function parseSource(source: string): {
+    provider: GitProviderAdapter;
+    owner: string;
+    repo: string;
+    subpath?: string;
+} | null;
+
+/**
+ * Format categories for skill translation
+ */
+type FormatCategory = 'skill-md' | 'cursor-mdc' | 'markdown-rules' | 'external';
+/**
+ * Mapping of agents to their format categories
+ */
+declare const AGENT_FORMAT_MAP: Record<AgentType, FormatCategory>;
+/**
+ * Extended skill frontmatter for translation
+ */
+declare const TranslatableSkillFrontmatter: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    license: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    compatibility: z.ZodOptional<z.ZodString>;
+    'allowed-tools': z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    globs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    alwaysApply: z.ZodOptional<z.ZodBoolean>;
+    agents: z.ZodOptional<z.ZodObject<{
+        optimized: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        compatible: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        optimized?: string[] | undefined;
+        compatible?: string[] | undefined;
+    }, {
+        optimized?: string[] | undefined;
+        compatible?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    license?: string | undefined;
+    compatibility?: string | undefined;
+    metadata?: Record<string, string> | undefined;
+    'allowed-tools'?: string | undefined;
+    version?: string | undefined;
+    author?: string | undefined;
+    tags?: string[] | undefined;
+    agents?: {
+        optimized?: string[] | undefined;
+        compatible?: string[] | undefined;
+    } | undefined;
+    globs?: string[] | undefined;
+    alwaysApply?: boolean | undefined;
+}, {
+    name: string;
+    description: string;
+    license?: string | undefined;
+    compatibility?: string | undefined;
+    metadata?: Record<string, string> | undefined;
+    'allowed-tools'?: string | undefined;
+    version?: string | undefined;
+    author?: string | undefined;
+    tags?: string[] | undefined;
+    agents?: {
+        optimized?: string[] | undefined;
+        compatible?: string[] | undefined;
+    } | undefined;
+    globs?: string[] | undefined;
+    alwaysApply?: boolean | undefined;
+}>;
+type TranslatableSkillFrontmatter = z.infer<typeof TranslatableSkillFrontmatter>;
+/**
+ * Canonical skill representation for translation
+ */
+interface CanonicalSkill {
+    /** Skill name (kebab-case) */
+    name: string;
+    /** Human-readable description */
+    description: string;
+    /** Version string */
+    version?: string;
+    /** Author name or handle */
+    author?: string;
+    /** License identifier */
+    license?: string;
+    /** Categorization tags */
+    tags?: string[];
+    /** Compatibility description */
+    compatibility?: string;
+    /** Allowed tools list */
+    allowedTools?: string;
+    /** Additional metadata */
+    metadata?: Record<string, string>;
+    /** Main content (markdown) */
+    content: string;
+    /** Original format this was parsed from */
+    sourceFormat: FormatCategory;
+    /** Source agent type */
+    sourceAgent?: AgentType;
+    /** Cursor-specific: glob patterns */
+    globs?: string[];
+    /** Cursor-specific: always apply flag */
+    alwaysApply?: boolean;
+    /** Agent optimization hints */
+    agentHints?: {
+        optimized?: string[];
+        compatible?: string[];
+    };
+}
+/**
+ * Result of a translation operation
+ */
+interface TranslationResult {
+    /** Whether translation succeeded */
+    success: boolean;
+    /** Translated content */
+    content: string;
+    /** Output filename */
+    filename: string;
+    /** Warnings during translation */
+    warnings: string[];
+    /** Features that couldn't be translated */
+    incompatible: string[];
+    /** Target format */
+    targetFormat: FormatCategory;
+    /** Target agent */
+    targetAgent: AgentType;
+}
+/**
+ * Options for translation
+ */
+interface TranslationOptions {
+    /** Preserve original comments */
+    preserveComments?: boolean;
+    /** Add translation metadata */
+    addMetadata?: boolean;
+    /** Custom output filename */
+    outputFilename?: string;
+    /** For Cursor: glob patterns to include */
+    globs?: string[];
+    /** For Cursor: always apply setting */
+    alwaysApply?: boolean;
+}
+/**
+ * Interface for format-specific translators
+ */
+interface FormatTranslator {
+    /** Format this translator handles */
+    readonly format: FormatCategory;
+    /** Agents this translator is optimized for */
+    readonly agents: AgentType[];
+    /**
+     * Parse content into canonical format
+     */
+    parse(content: string, filename?: string): CanonicalSkill | null;
+    /**
+     * Check if content matches this format
+     */
+    detect(content: string, filename?: string): boolean;
+    /**
+     * Generate content for target agent
+     */
+    generate(skill: CanonicalSkill, targetAgent: AgentType, options?: TranslationOptions): TranslationResult;
+    /**
+     * Get the expected filename for this format
+     */
+    getFilename(skillName: string, targetAgent: AgentType): string;
+}
+/**
+ * Translation path between formats
+ */
+interface TranslationPath {
+    from: FormatCategory;
+    to: FormatCategory;
+    steps: FormatCategory[];
+}
+
+/**
+ * SKILL.md Format Translator
+ *
+ * This is the canonical format used by most AI coding agents.
+ * Format:
+ * ```
+ * ---
+ * name: skill-name
+ * description: What it does
+ * version: 1.0.0
+ * tags: [tag1, tag2]
+ * ---
+ * # Instructions
+ * Markdown content here...
+ * ```
+ */
+declare class SkillMdTranslator implements FormatTranslator {
+    readonly format: FormatCategory;
+    readonly agents: AgentType[];
+    /**
+     * Parse SKILL.md content into canonical format
+     */
+    parse(content: string, filename?: string): CanonicalSkill | null;
+    /**
+     * Check if content is SKILL.md format
+     */
+    detect(content: string, filename?: string): boolean;
+    /**
+     * Generate SKILL.md content for target agent
+     */
+    generate(skill: CanonicalSkill, targetAgent: AgentType, options?: TranslationOptions): TranslationResult;
+    /**
+     * Get the expected filename for SKILL.md format
+     */
+    getFilename(_skillName: string, _targetAgent: AgentType): string;
+}
+/**
+ * Singleton instance
+ */
+declare const skillMdTranslator: SkillMdTranslator;
+
+/**
+ * Cursor MDC Format Translator
+ *
+ * Cursor uses two formats:
+ * 1. .cursorrules - Global rules file in project root
+ * 2. .cursor/rules/*.mdc - Individual rule files with frontmatter
+ *
+ * MDC Format:
+ * ```
+ * ---
+ * description: What this rule does
+ * globs: ["**\/*.tsx", "**\/*.jsx"]
+ * alwaysApply: false
+ * ---
+ * Instructions here...
+ * ```
+ */
+declare class CursorTranslator implements FormatTranslator {
+    readonly format: FormatCategory;
+    readonly agents: AgentType[];
+    /**
+     * Parse Cursor MDC content into canonical format
+     */
+    parse(content: string, filename?: string): CanonicalSkill | null;
+    /**
+     * Check if content is Cursor MDC format
+     */
+    detect(content: string, filename?: string): boolean;
+    /**
+     * Generate Cursor MDC content
+     */
+    generate(skill: CanonicalSkill, targetAgent: AgentType, options?: TranslationOptions): TranslationResult;
+    /**
+     * Generate .cursorrules content (alternative format)
+     */
+    generateCursorrules(skill: CanonicalSkill): string;
+    /**
+     * Get the expected filename for Cursor format
+     */
+    getFilename(skillName: string, _targetAgent: AgentType): string;
+}
+/**
+ * Singleton instance
+ */
+declare const cursorTranslator: CursorTranslator;
+
+/**
+ * Windsurf Rules Format Translator
+ *
+ * Windsurf uses plain markdown files (.windsurfrules) without YAML frontmatter.
+ * Metadata can be embedded in HTML comments at the top.
+ *
+ * Format:
+ * ```
+ * <!-- name: skill-name -->
+ * <!-- description: What it does -->
+ *
+ * # Guidelines
+ *
+ * Instructions here...
+ * ```
+ */
+declare class WindsurfTranslator implements FormatTranslator {
+    readonly format: FormatCategory;
+    readonly agents: AgentType[];
+    /**
+     * Parse Windsurf rules content into canonical format
+     */
+    parse(content: string, filename?: string): CanonicalSkill | null;
+    /**
+     * Check if content is Windsurf format
+     */
+    detect(content: string, filename?: string): boolean;
+    /**
+     * Generate Windsurf rules content
+     */
+    generate(skill: CanonicalSkill, targetAgent: AgentType, options?: TranslationOptions): TranslationResult;
+    /**
+     * Get the expected filename for Windsurf format
+     */
+    getFilename(_skillName: string, _targetAgent: AgentType): string;
+}
+/**
+ * Singleton instance
+ */
+declare const windsurfTranslator: WindsurfTranslator;
+
+/**
+ * GitHub Copilot Instructions Format Translator
+ *
+ * GitHub Copilot uses a markdown file at `.github/copilot-instructions.md`
+ * for custom instructions. It's plain markdown with optional metadata comments.
+ *
+ * Format:
+ * ```
+ * <!-- This file provides custom instructions for GitHub Copilot -->
+ *
+ * # Coding Guidelines
+ *
+ * ## React Components
+ * - Use functional components with hooks
+ * - Prefer TypeScript
+ * ```
+ */
+declare class CopilotTranslator implements FormatTranslator {
+    readonly format: FormatCategory;
+    readonly agents: AgentType[];
+    /**
+     * Parse Copilot instructions into canonical format
+     */
+    parse(content: string, filename?: string): CanonicalSkill | null;
+    /**
+     * Check if content is GitHub Copilot format
+     */
+    detect(content: string, filename?: string): boolean;
+    /**
+     * Generate GitHub Copilot instructions content
+     */
+    generate(skill: CanonicalSkill, targetAgent: AgentType, options?: TranslationOptions): TranslationResult;
+    /**
+     * Get the expected filename for GitHub Copilot format
+     */
+    getFilename(_skillName: string, _targetAgent: AgentType): string;
+    /**
+     * Get the expected path for the instructions file
+     */
+    getPath(_skillName: string): string;
+}
+/**
+ * Singleton instance
+ */
+declare const copilotTranslator: CopilotTranslator;
+
+/**
+ * Translator Registry
+ *
+ * Central registry for all format translators. Handles:
+ * - Format detection
+ * - Translation between any supported formats
+ * - Finding the optimal translation path
+ */
+declare class TranslatorRegistry {
+    private translators;
+    private agentTranslators;
+    constructor();
+    /**
+     * Register a format translator
+     */
+    register(translator: FormatTranslator): void;
+    /**
+     * Get translator for a specific format
+     */
+    getTranslator(format: FormatCategory): FormatTranslator | undefined;
+    /**
+     * Get translator for a specific agent
+     */
+    getTranslatorForAgent(agent: AgentType): FormatTranslator;
+    /**
+     * Get the format category for an agent
+     */
+    getFormatForAgent(agent: AgentType): FormatCategory;
+    /**
+     * Detect the format of content
+     */
+    detectFormat(content: string, filename?: string): FormatCategory | null;
+    /**
+     * Detect the source agent from content
+     */
+    detectSourceAgent(content: string, filename?: string): AgentType | null;
+    /**
+     * Parse content into canonical format
+     */
+    parse(content: string, filename?: string): CanonicalSkill | null;
+    /**
+     * Translate skill to target agent format
+     */
+    translate(skill: CanonicalSkill, targetAgent: AgentType, options?: TranslationOptions): TranslationResult;
+    /**
+     * Translate content directly from one agent to another
+     */
+    translateContent(content: string, targetAgent: AgentType, options?: TranslationOptions & {
+        sourceFilename?: string;
+    }): TranslationResult;
+    /**
+     * Translate a skill file to target agent format
+     */
+    translateFile(sourcePath: string, targetAgent: AgentType, options?: TranslationOptions): TranslationResult;
+    /**
+     * Translate and write to target path
+     */
+    translateAndWrite(sourcePath: string, targetPath: string, targetAgent: AgentType, options?: TranslationOptions): TranslationResult;
+    /**
+     * Get all supported agents
+     */
+    getSupportedAgents(): AgentType[];
+    /**
+     * Get all registered formats
+     */
+    getRegisteredFormats(): FormatCategory[];
+    /**
+     * Check if translation is supported between two agents
+     */
+    canTranslate(from: AgentType, to: AgentType): boolean;
+    /**
+     * Get translation compatibility info
+     */
+    getCompatibilityInfo(from: AgentType, to: AgentType): {
+        supported: boolean;
+        warnings: string[];
+        lossyFields: string[];
+    };
+}
+/**
+ * Default registry instance
+ */
+declare const translatorRegistry: TranslatorRegistry;
+
+/**
+ * Translate skill content from one agent format to another
+ *
+ * @example
+ * ```ts
+ * import { translateSkill } from '@skillkit/core';
+ *
+ * const result = translateSkill(skillMdContent, 'cursor');
+ * console.log(result.content); // Cursor MDC format
+ * ```
+ */
+declare function translateSkill(content: string, targetAgent: AgentType, options?: TranslationOptions & {
+    sourceFilename?: string;
+}): TranslationResult;
+/**
+ * Translate a skill file to target agent format
+ *
+ * @example
+ * ```ts
+ * import { translateSkillFile } from '@skillkit/core';
+ *
+ * const result = translateSkillFile('./skills/my-skill/SKILL.md', 'cursor');
+ * console.log(result.filename); // 'my-skill.mdc'
+ * ```
+ */
+declare function translateSkillFile(sourcePath: string, targetAgent: AgentType, options?: TranslationOptions): TranslationResult;
+/**
+ * Parse skill content into canonical format
+ *
+ * @example
+ * ```ts
+ * import { parseSkillContent } from '@skillkit/core';
+ *
+ * const skill = parseSkillContent(cursorMdcContent, 'my-rule.mdc');
+ * console.log(skill.name); // 'my-rule'
+ * ```
+ */
+declare function parseSkillContent(content: string, filename?: string): CanonicalSkill | null;
+/**
+ * Detect the format of skill content
+ *
+ * @example
+ * ```ts
+ * import { detectSkillFormat } from '@skillkit/core';
+ *
+ * const format = detectSkillFormat(content, 'SKILL.md');
+ * console.log(format); // 'skill-md'
+ * ```
+ */
+declare function detectSkillFormat(content: string, filename?: string): string | null;
+/**
+ * Get all supported agent types for translation
+ */
+declare function getSupportedTranslationAgents(): AgentType[];
+/**
+ * Check if translation is possible between two agents
+ */
+declare function canTranslate(from: AgentType, to: AgentType): boolean;
+
+/**
+ * Detected dependency with version
+ */
+declare const DependencyInfo: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    dev: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    dev: boolean;
+    version?: string | undefined;
+}, {
+    name: string;
+    version?: string | undefined;
+    dev?: boolean | undefined;
+}>;
+type DependencyInfo = z.infer<typeof DependencyInfo>;
+/**
+ * Detection result with confidence
+ */
+declare const Detection: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodDefault<z.ZodNumber>;
+    source: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    confidence: number;
+    version?: string | undefined;
+    source?: string | undefined;
+}, {
+    name: string;
+    version?: string | undefined;
+    source?: string | undefined;
+    confidence?: number | undefined;
+}>;
+type Detection = z.infer<typeof Detection>;
+/**
+ * Project stack detection results
+ */
+declare const ProjectStack: z.ZodObject<{
+    languages: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+        confidence: z.ZodDefault<z.ZodNumber>;
+        source: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        confidence: number;
+        version?: string | undefined;
+        source?: string | undefined;
+    }, {
+        name: string;
+        version?: string | undefined;
+        source?: string | undefined;
+        confidence?: number | undefined;
+    }>, "many">>;
+    frameworks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+        confidence: z.ZodDefault<z.ZodNumber>;
+        source: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        confidence: number;
+        version?: string | undefined;
+        source?: string | undefined;
+    }, {
+        name: string;
+        version?: string | undefined;
+        source?: string | undefined;
+        confidence?: number | undefined;
+    }>, "many">>;
+    libraries: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+        confidence: z.ZodDefault<z.ZodNumber>;
+        source: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        confidence: number;
+        version?: string | undefined;
+        source?: string | undefined;
+    }, {
+        name: string;
+        version?: string | undefined;
+        source?: string | undefined;
+        confidence?: number | undefined;
+    }>, "many">>;
+    styling: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+        confidence: z.ZodDefault<z.ZodNumber>;
+        source: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        confidence: number;
+        version?: string | undefined;
+        source?: string | undefined;
+    }, {
+        name: string;
+        version?: string | undefined;
+        source?: string | undefined;
+        confidence?: number | undefined;
+    }>, "many">>;
+    testing: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+        confidence: z.ZodDefault<z.ZodNumber>;
+        source: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        confidence: number;
+        version?: string | undefined;
+        source?: string | undefined;
+    }, {
+        name: string;
+        version?: string | undefined;
+        source?: string | undefined;
+        confidence?: number | undefined;
+    }>, "many">>;
+    databases: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+        confidence: z.ZodDefault<z.ZodNumber>;
+        source: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        confidence: number;
+        version?: string | undefined;
+        source?: string | undefined;
+    }, {
+        name: string;
+        version?: string | undefined;
+        source?: string | undefined;
+        confidence?: number | undefined;
+    }>, "many">>;
+    tools: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+        confidence: z.ZodDefault<z.ZodNumber>;
+        source: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        confidence: number;
+        version?: string | undefined;
+        source?: string | undefined;
+    }, {
+        name: string;
+        version?: string | undefined;
+        source?: string | undefined;
+        confidence?: number | undefined;
+    }>, "many">>;
+    runtime: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+        confidence: z.ZodDefault<z.ZodNumber>;
+        source: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        confidence: number;
+        version?: string | undefined;
+        source?: string | undefined;
+    }, {
+        name: string;
+        version?: string | undefined;
+        source?: string | undefined;
+        confidence?: number | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    testing: {
+        name: string;
+        confidence: number;
+        version?: string | undefined;
+        source?: string | undefined;
+    }[];
+    languages: {
+        name: string;
+        confidence: number;
+        version?: string | undefined;
+        source?: string | undefined;
+    }[];
+    frameworks: {
+        name: string;
+        confidence: number;
+        version?: string | undefined;
+        source?: string | undefined;
+    }[];
+    libraries: {
+        name: string;
+        confidence: number;
+        version?: string | undefined;
+        source?: string | undefined;
+    }[];
+    styling: {
+        name: string;
+        confidence: number;
+        version?: string | undefined;
+        source?: string | undefined;
+    }[];
+    databases: {
+        name: string;
+        confidence: number;
+        version?: string | undefined;
+        source?: string | undefined;
+    }[];
+    tools: {
+        name: string;
+        confidence: number;
+        version?: string | undefined;
+        source?: string | undefined;
+    }[];
+    runtime: {
+        name: string;
+        confidence: number;
+        version?: string | undefined;
+        source?: string | undefined;
+    }[];
+}, {
+    testing?: {
+        name: string;
+        version?: string | undefined;
+        source?: string | undefined;
+        confidence?: number | undefined;
+    }[] | undefined;
+    languages?: {
+        name: string;
+        version?: string | undefined;
+        source?: string | undefined;
+        confidence?: number | undefined;
+    }[] | undefined;
+    frameworks?: {
+        name: string;
+        version?: string | undefined;
+        source?: string | undefined;
+        confidence?: number | undefined;
+    }[] | undefined;
+    libraries?: {
+        name: string;
+        version?: string | undefined;
+        source?: string | undefined;
+        confidence?: number | undefined;
+    }[] | undefined;
+    styling?: {
+        name: string;
+        version?: string | undefined;
+        source?: string | undefined;
+        confidence?: number | undefined;
+    }[] | undefined;
+    databases?: {
+        name: string;
+        version?: string | undefined;
+        source?: string | undefined;
+        confidence?: number | undefined;
+    }[] | undefined;
+    tools?: {
+        name: string;
+        version?: string | undefined;
+        source?: string | undefined;
+        confidence?: number | undefined;
+    }[] | undefined;
+    runtime?: {
+        name: string;
+        version?: string | undefined;
+        source?: string | undefined;
+        confidence?: number | undefined;
+    }[] | undefined;
+}>;
+type ProjectStack = z.infer<typeof ProjectStack>;
+/**
+ * Project patterns and conventions
+ */
+declare const ProjectPatterns: z.ZodObject<{
+    components: z.ZodOptional<z.ZodString>;
+    stateManagement: z.ZodOptional<z.ZodString>;
+    apiStyle: z.ZodOptional<z.ZodString>;
+    styling: z.ZodOptional<z.ZodString>;
+    testing: z.ZodOptional<z.ZodString>;
+    linting: z.ZodOptional<z.ZodString>;
+    formatting: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    testing?: string | undefined;
+    styling?: string | undefined;
+    components?: string | undefined;
+    stateManagement?: string | undefined;
+    apiStyle?: string | undefined;
+    linting?: string | undefined;
+    formatting?: string | undefined;
+}, {
+    testing?: string | undefined;
+    styling?: string | undefined;
+    components?: string | undefined;
+    stateManagement?: string | undefined;
+    apiStyle?: string | undefined;
+    linting?: string | undefined;
+    formatting?: string | undefined;
+}>;
+type ProjectPatterns = z.infer<typeof ProjectPatterns>;
+/**
+ * Skill preferences for the project
+ */
+declare const SkillPreferences: z.ZodObject<{
+    installed: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    recommended: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    excluded: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    autoSync: z.ZodDefault<z.ZodBoolean>;
+    securityLevel: z.ZodDefault<z.ZodEnum<["low", "medium", "high"]>>;
+    testingRequired: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    autoSync: boolean;
+    installed: string[];
+    recommended: string[];
+    excluded: string[];
+    securityLevel: "low" | "medium" | "high";
+    testingRequired: boolean;
+}, {
+    autoSync?: boolean | undefined;
+    installed?: string[] | undefined;
+    recommended?: string[] | undefined;
+    excluded?: string[] | undefined;
+    securityLevel?: "low" | "medium" | "high" | undefined;
+    testingRequired?: boolean | undefined;
+}>;
+type SkillPreferences = z.infer<typeof SkillPreferences>;
+/**
+ * Agent configuration for the project
+ */
+declare const AgentConfig: z.ZodObject<{
+    primary: z.ZodOptional<z.ZodString>;
+    detected: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    synced: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    disabled: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    detected: string[];
+    synced: string[];
+    disabled: string[];
+    primary?: string | undefined;
+}, {
+    primary?: string | undefined;
+    detected?: string[] | undefined;
+    synced?: string[] | undefined;
+    disabled?: string[] | undefined;
+}>;
+type AgentConfig = z.infer<typeof AgentConfig>;
+/**
+ * Full project context
+ */
+declare const ProjectContext: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    project: z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        path?: string | undefined;
+        type?: string | undefined;
+        description?: string | undefined;
+    }, {
+        name: string;
+        path?: string | undefined;
+        type?: string | undefined;
+        description?: string | undefined;
+    }>;
+    stack: z.ZodObject<{
+        languages: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+            confidence: z.ZodDefault<z.ZodNumber>;
+            source: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            confidence: number;
+            version?: string | undefined;
+            source?: string | undefined;
+        }, {
+            name: string;
+            version?: string | undefined;
+            source?: string | undefined;
+            confidence?: number | undefined;
+        }>, "many">>;
+        frameworks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+            confidence: z.ZodDefault<z.ZodNumber>;
+            source: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            confidence: number;
+            version?: string | undefined;
+            source?: string | undefined;
+        }, {
+            name: string;
+            version?: string | undefined;
+            source?: string | undefined;
+            confidence?: number | undefined;
+        }>, "many">>;
+        libraries: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+            confidence: z.ZodDefault<z.ZodNumber>;
+            source: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            confidence: number;
+            version?: string | undefined;
+            source?: string | undefined;
+        }, {
+            name: string;
+            version?: string | undefined;
+            source?: string | undefined;
+            confidence?: number | undefined;
+        }>, "many">>;
+        styling: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+            confidence: z.ZodDefault<z.ZodNumber>;
+            source: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            confidence: number;
+            version?: string | undefined;
+            source?: string | undefined;
+        }, {
+            name: string;
+            version?: string | undefined;
+            source?: string | undefined;
+            confidence?: number | undefined;
+        }>, "many">>;
+        testing: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+            confidence: z.ZodDefault<z.ZodNumber>;
+            source: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            confidence: number;
+            version?: string | undefined;
+            source?: string | undefined;
+        }, {
+            name: string;
+            version?: string | undefined;
+            source?: string | undefined;
+            confidence?: number | undefined;
+        }>, "many">>;
+        databases: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+            confidence: z.ZodDefault<z.ZodNumber>;
+            source: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            confidence: number;
+            version?: string | undefined;
+            source?: string | undefined;
+        }, {
+            name: string;
+            version?: string | undefined;
+            source?: string | undefined;
+            confidence?: number | undefined;
+        }>, "many">>;
+        tools: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+            confidence: z.ZodDefault<z.ZodNumber>;
+            source: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            confidence: number;
+            version?: string | undefined;
+            source?: string | undefined;
+        }, {
+            name: string;
+            version?: string | undefined;
+            source?: string | undefined;
+            confidence?: number | undefined;
+        }>, "many">>;
+        runtime: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+            confidence: z.ZodDefault<z.ZodNumber>;
+            source: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            confidence: number;
+            version?: string | undefined;
+            source?: string | undefined;
+        }, {
+            name: string;
+            version?: string | undefined;
+            source?: string | undefined;
+            confidence?: number | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        testing: {
+            name: string;
+            confidence: number;
+            version?: string | undefined;
+            source?: string | undefined;
+        }[];
+        languages: {
+            name: string;
+            confidence: number;
+            version?: string | undefined;
+            source?: string | undefined;
+        }[];
+        frameworks: {
+            name: string;
+            confidence: number;
+            version?: string | undefined;
+            source?: string | undefined;
+        }[];
+        libraries: {
+            name: string;
+            confidence: number;
+            version?: string | undefined;
+            source?: string | undefined;
+        }[];
+        styling: {
+            name: string;
+            confidence: number;
+            version?: string | undefined;
+            source?: string | undefined;
+        }[];
+        databases: {
+            name: string;
+            confidence: number;
+            version?: string | undefined;
+            source?: string | undefined;
+        }[];
+        tools: {
+            name: string;
+            confidence: number;
+            version?: string | undefined;
+            source?: string | undefined;
+        }[];
+        runtime: {
+            name: string;
+            confidence: number;
+            version?: string | undefined;
+            source?: string | undefined;
+        }[];
+    }, {
+        testing?: {
+            name: string;
+            version?: string | undefined;
+            source?: string | undefined;
+            confidence?: number | undefined;
+        }[] | undefined;
+        languages?: {
+            name: string;
+            version?: string | undefined;
+            source?: string | undefined;
+            confidence?: number | undefined;
+        }[] | undefined;
+        frameworks?: {
+            name: string;
+            version?: string | undefined;
+            source?: string | undefined;
+            confidence?: number | undefined;
+        }[] | undefined;
+        libraries?: {
+            name: string;
+            version?: string | undefined;
+            source?: string | undefined;
+            confidence?: number | undefined;
+        }[] | undefined;
+        styling?: {
+            name: string;
+            version?: string | undefined;
+            source?: string | undefined;
+            confidence?: number | undefined;
+        }[] | undefined;
+        databases?: {
+            name: string;
+            version?: string | undefined;
+            source?: string | undefined;
+            confidence?: number | undefined;
+        }[] | undefined;
+        tools?: {
+            name: string;
+            version?: string | undefined;
+            source?: string | undefined;
+            confidence?: number | undefined;
+        }[] | undefined;
+        runtime?: {
+            name: string;
+            version?: string | undefined;
+            source?: string | undefined;
+            confidence?: number | undefined;
+        }[] | undefined;
+    }>;
+    patterns: z.ZodOptional<z.ZodObject<{
+        components: z.ZodOptional<z.ZodString>;
+        stateManagement: z.ZodOptional<z.ZodString>;
+        apiStyle: z.ZodOptional<z.ZodString>;
+        styling: z.ZodOptional<z.ZodString>;
+        testing: z.ZodOptional<z.ZodString>;
+        linting: z.ZodOptional<z.ZodString>;
+        formatting: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        testing?: string | undefined;
+        styling?: string | undefined;
+        components?: string | undefined;
+        stateManagement?: string | undefined;
+        apiStyle?: string | undefined;
+        linting?: string | undefined;
+        formatting?: string | undefined;
+    }, {
+        testing?: string | undefined;
+        styling?: string | undefined;
+        components?: string | undefined;
+        stateManagement?: string | undefined;
+        apiStyle?: string | undefined;
+        linting?: string | undefined;
+        formatting?: string | undefined;
+    }>>;
+    skills: z.ZodOptional<z.ZodObject<{
+        installed: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        recommended: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        excluded: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        autoSync: z.ZodDefault<z.ZodBoolean>;
+        securityLevel: z.ZodDefault<z.ZodEnum<["low", "medium", "high"]>>;
+        testingRequired: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        autoSync: boolean;
+        installed: string[];
+        recommended: string[];
+        excluded: string[];
+        securityLevel: "low" | "medium" | "high";
+        testingRequired: boolean;
+    }, {
+        autoSync?: boolean | undefined;
+        installed?: string[] | undefined;
+        recommended?: string[] | undefined;
+        excluded?: string[] | undefined;
+        securityLevel?: "low" | "medium" | "high" | undefined;
+        testingRequired?: boolean | undefined;
+    }>>;
+    agents: z.ZodOptional<z.ZodObject<{
+        primary: z.ZodOptional<z.ZodString>;
+        detected: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        synced: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        disabled: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        detected: string[];
+        synced: string[];
+        disabled: string[];
+        primary?: string | undefined;
+    }, {
+        primary?: string | undefined;
+        detected?: string[] | undefined;
+        synced?: string[] | undefined;
+        disabled?: string[] | undefined;
+    }>>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    version: 1;
+    project: {
+        name: string;
+        path?: string | undefined;
+        type?: string | undefined;
+        description?: string | undefined;
+    };
+    stack: {
+        testing: {
+            name: string;
+            confidence: number;
+            version?: string | undefined;
+            source?: string | undefined;
+        }[];
+        languages: {
+            name: string;
+            confidence: number;
+            version?: string | undefined;
+            source?: string | undefined;
+        }[];
+        frameworks: {
+            name: string;
+            confidence: number;
+            version?: string | undefined;
+            source?: string | undefined;
+        }[];
+        libraries: {
+            name: string;
+            confidence: number;
+            version?: string | undefined;
+            source?: string | undefined;
+        }[];
+        styling: {
+            name: string;
+            confidence: number;
+            version?: string | undefined;
+            source?: string | undefined;
+        }[];
+        databases: {
+            name: string;
+            confidence: number;
+            version?: string | undefined;
+            source?: string | undefined;
+        }[];
+        tools: {
+            name: string;
+            confidence: number;
+            version?: string | undefined;
+            source?: string | undefined;
+        }[];
+        runtime: {
+            name: string;
+            confidence: number;
+            version?: string | undefined;
+            source?: string | undefined;
+        }[];
+    };
+    agents?: {
+        detected: string[];
+        synced: string[];
+        disabled: string[];
+        primary?: string | undefined;
+    } | undefined;
+    updatedAt?: string | undefined;
+    skills?: {
+        autoSync: boolean;
+        installed: string[];
+        recommended: string[];
+        excluded: string[];
+        securityLevel: "low" | "medium" | "high";
+        testingRequired: boolean;
+    } | undefined;
+    patterns?: {
+        testing?: string | undefined;
+        styling?: string | undefined;
+        components?: string | undefined;
+        stateManagement?: string | undefined;
+        apiStyle?: string | undefined;
+        linting?: string | undefined;
+        formatting?: string | undefined;
+    } | undefined;
+    createdAt?: string | undefined;
+}, {
+    version: 1;
+    project: {
+        name: string;
+        path?: string | undefined;
+        type?: string | undefined;
+        description?: string | undefined;
+    };
+    stack: {
+        testing?: {
+            name: string;
+            version?: string | undefined;
+            source?: string | undefined;
+            confidence?: number | undefined;
+        }[] | undefined;
+        languages?: {
+            name: string;
+            version?: string | undefined;
+            source?: string | undefined;
+            confidence?: number | undefined;
+        }[] | undefined;
+        frameworks?: {
+            name: string;
+            version?: string | undefined;
+            source?: string | undefined;
+            confidence?: number | undefined;
+        }[] | undefined;
+        libraries?: {
+            name: string;
+            version?: string | undefined;
+            source?: string | undefined;
+            confidence?: number | undefined;
+        }[] | undefined;
+        styling?: {
+            name: string;
+            version?: string | undefined;
+            source?: string | undefined;
+            confidence?: number | undefined;
+        }[] | undefined;
+        databases?: {
+            name: string;
+            version?: string | undefined;
+            source?: string | undefined;
+            confidence?: number | undefined;
+        }[] | undefined;
+        tools?: {
+            name: string;
+            version?: string | undefined;
+            source?: string | undefined;
+            confidence?: number | undefined;
+        }[] | undefined;
+        runtime?: {
+            name: string;
+            version?: string | undefined;
+            source?: string | undefined;
+            confidence?: number | undefined;
+        }[] | undefined;
+    };
+    agents?: {
+        primary?: string | undefined;
+        detected?: string[] | undefined;
+        synced?: string[] | undefined;
+        disabled?: string[] | undefined;
+    } | undefined;
+    updatedAt?: string | undefined;
+    skills?: {
+        autoSync?: boolean | undefined;
+        installed?: string[] | undefined;
+        recommended?: string[] | undefined;
+        excluded?: string[] | undefined;
+        securityLevel?: "low" | "medium" | "high" | undefined;
+        testingRequired?: boolean | undefined;
+    } | undefined;
+    patterns?: {
+        testing?: string | undefined;
+        styling?: string | undefined;
+        components?: string | undefined;
+        stateManagement?: string | undefined;
+        apiStyle?: string | undefined;
+        linting?: string | undefined;
+        formatting?: string | undefined;
+    } | undefined;
+    createdAt?: string | undefined;
+}>;
+type ProjectContext = z.infer<typeof ProjectContext>;
+/**
+ * Context file location
+ */
+declare const CONTEXT_FILE = ".skillkit/context.yaml";
+declare const CONTEXT_DIR = ".skillkit";
+/**
+ * Detection source types
+ */
+type DetectionSource = 'package.json' | 'tsconfig.json' | 'pyproject.toml' | 'Cargo.toml' | 'go.mod' | 'pubspec.yaml' | 'folder-structure' | 'config-file' | 'manual';
+/**
+ * Project type hints based on detection
+ */
+declare const PROJECT_TYPE_HINTS: Record<string, string[]>;
+/**
+ * Context sync options
+ */
+interface ContextSyncOptions {
+    agents?: AgentType[];
+    force?: boolean;
+    dryRun?: boolean;
+    skillsOnly?: boolean;
+}
+/**
+ * Context export options
+ */
+interface ContextExportOptions {
+    output?: string;
+    format?: 'yaml' | 'json';
+    includeSkills?: boolean;
+    includeAgents?: boolean;
+}
+/**
+ * Context import options
+ */
+interface ContextImportOptions {
+    merge?: boolean;
+    overwrite?: boolean;
+    skipDetection?: boolean;
+}
+
+/**
+ * Project Detector
+ *
+ * Analyzes a project directory to detect the technology stack,
+ * frameworks, libraries, and patterns used.
+ */
+declare class ProjectDetector {
+    private projectPath;
+    private packageJson;
+    private files;
+    constructor(projectPath: string);
+    /**
+     * Analyze the project and return detected stack
+     */
+    analyze(): ProjectStack;
+    /**
+     * Detect project patterns and conventions
+     */
+    detectPatterns(): ProjectPatterns;
+    /**
+     * Detect project type
+     */
+    detectProjectType(): string;
+    /**
+     * Get project name
+     */
+    getProjectName(): string;
+    /**
+     * Get project description
+     */
+    getProjectDescription(): string | undefined;
+    private loadPackageJson;
+    private scanFiles;
+    private getDependencies;
+    private getVersion;
+    private hasFile;
+    private detectLanguages;
+    private detectRuntime;
+    private detectFromPatterns;
+}
+/**
+ * Analyze a project and return the detected stack
+ */
+declare function analyzeProject(projectPath: string): ProjectStack;
+/**
+ * Get all relevant tags from a project stack
+ */
+declare function getStackTags(stack: ProjectStack): string[];
+
+/**
+ * Context Manager
+ *
+ * Handles loading, saving, and managing project contexts.
+ * The context is stored in .skillkit/context.yaml
+ */
+declare class ContextManager {
+    private projectPath;
+    private context;
+    constructor(projectPath?: string);
+    /**
+     * Get the context file path
+     */
+    getContextPath(): string;
+    /**
+     * Check if context exists
+     */
+    exists(): boolean;
+    /**
+     * Load context from file
+     */
+    load(): ProjectContext | null;
+    /**
+     * Save context to file
+     */
+    save(context: ProjectContext): void;
+    /**
+     * Initialize a new context from project detection
+     */
+    init(options?: {
+        force?: boolean;
+        skipDetection?: boolean;
+    }): ProjectContext;
+    /**
+     * Update context with new detection
+     */
+    refresh(): ProjectContext;
+    /**
+     * Get current context (load if not loaded)
+     */
+    get(): ProjectContext | null;
+    /**
+     * Update skills in context
+     */
+    updateSkills(skills: Partial<SkillPreferences>): void;
+    /**
+     * Update agents in context
+     */
+    updateAgents(agents: Partial<AgentConfig>): void;
+    /**
+     * Set primary agent
+     */
+    setPrimaryAgent(agent: AgentType): void;
+    /**
+     * Add agent to synced list
+     */
+    addSyncedAgent(agent: AgentType): void;
+    /**
+     * Remove agent from synced list
+     */
+    removeSyncedAgent(agent: AgentType): void;
+    /**
+     * Add installed skill
+     */
+    addInstalledSkill(skillName: string): void;
+    /**
+     * Remove installed skill
+     */
+    removeInstalledSkill(skillName: string): void;
+    /**
+     * Export context to file
+     */
+    export(options?: ContextExportOptions): string;
+    /**
+     * Import context from content
+     */
+    import(content: string, options?: ContextImportOptions): ProjectContext;
+    /**
+     * Merge two contexts
+     */
+    private mergeContexts;
+    /**
+     * Merge two stacks
+     */
+    private mergeStacks;
+    /**
+     * Get empty stack
+     */
+    private getEmptyStack;
+    /**
+     * Get recommended skill tags based on stack
+     */
+    getRecommendedTags(): string[];
+}
+/**
+ * Create a context manager for the current directory
+ */
+declare function createContextManager(projectPath?: string): ContextManager;
+/**
+ * Load context from the current directory
+ */
+declare function loadContext(projectPath?: string): ProjectContext | null;
+/**
+ * Initialize context in the current directory
+ */
+declare function initContext(projectPath?: string, options?: {
+    force?: boolean;
+}): ProjectContext;
+
+/**
+ * Result of a sync operation
+ */
+interface SyncResult {
+    success: boolean;
+    agent: AgentType;
+    skillsSynced: number;
+    skillsSkipped: number;
+    errors: string[];
+    warnings: string[];
+    files: string[];
+}
+/**
+ * Overall sync report
+ */
+interface SyncReport {
+    totalAgents: number;
+    successfulAgents: number;
+    totalSkills: number;
+    results: SyncResult[];
+}
+/**
+ * Context Sync
+ *
+ * Handles syncing skills across multiple AI agents.
+ * Skills are translated to the appropriate format for each agent.
+ */
+declare class ContextSync {
+    private projectPath;
+    private contextManager;
+    constructor(projectPath?: string);
+    /**
+     * Detect which agents are installed/configured on the system
+     */
+    detectAgents(): AgentType[];
+    /**
+     * Get agents to sync to based on context
+     */
+    getTargetAgents(options?: ContextSyncOptions): AgentType[];
+    /**
+     * Sync all skills to all target agents
+     */
+    syncAll(options?: ContextSyncOptions): Promise<SyncReport>;
+    /**
+     * Sync skills to a specific agent
+     */
+    syncToAgent(agent: AgentType, skills?: Array<{
+        name: string;
+        path: string;
+    }>, options?: ContextSyncOptions): Promise<SyncResult>;
+    /**
+     * Sync a single skill to an agent
+     */
+    private syncSkill;
+    /**
+     * Copy additional skill assets (references, scripts, etc.)
+     */
+    private copySkillAssets;
+    /**
+     * Get source skills to sync
+     */
+    private getSourceSkills;
+    /**
+     * Check sync status - which agents have which skills
+     */
+    checkStatus(): Record<AgentType, {
+        hasSkills: boolean;
+        skillCount: number;
+        skills: string[];
+    }>;
+}
+/**
+ * Create a context sync instance
+ */
+declare function createContextSync(projectPath?: string): ContextSync;
+/**
+ * Sync skills to all detected agents
+ */
+declare function syncToAllAgents(projectPath?: string, options?: ContextSyncOptions): Promise<SyncReport>;
+/**
+ * Sync skills to a specific agent
+ */
+declare function syncToAgent(agent: AgentType, projectPath?: string, options?: ContextSyncOptions): Promise<SyncResult>;
+
+/**
+ * Skill summary for recommendation matching
+ */
+declare const SkillSummary: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    compatibility: z.ZodOptional<z.ZodObject<{
+        frameworks: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        languages: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        libraries: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        minVersion: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        languages: string[];
+        frameworks: string[];
+        libraries: string[];
+        minVersion?: Record<string, string> | undefined;
+    }, {
+        languages?: string[] | undefined;
+        frameworks?: string[] | undefined;
+        libraries?: string[] | undefined;
+        minVersion?: Record<string, string> | undefined;
+    }>>;
+    popularity: z.ZodDefault<z.ZodNumber>;
+    quality: z.ZodDefault<z.ZodNumber>;
+    lastUpdated: z.ZodOptional<z.ZodString>;
+    verified: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    tags: string[];
+    popularity: number;
+    quality: number;
+    verified: boolean;
+    description?: string | undefined;
+    compatibility?: {
+        languages: string[];
+        frameworks: string[];
+        libraries: string[];
+        minVersion?: Record<string, string> | undefined;
+    } | undefined;
+    source?: string | undefined;
+    lastUpdated?: string | undefined;
+}, {
+    name: string;
+    description?: string | undefined;
+    compatibility?: {
+        languages?: string[] | undefined;
+        frameworks?: string[] | undefined;
+        libraries?: string[] | undefined;
+        minVersion?: Record<string, string> | undefined;
+    } | undefined;
+    tags?: string[] | undefined;
+    source?: string | undefined;
+    popularity?: number | undefined;
+    quality?: number | undefined;
+    lastUpdated?: string | undefined;
+    verified?: boolean | undefined;
+}>;
+type SkillSummary = z.infer<typeof SkillSummary>;
+/**
+ * Scored skill with match explanation
+ */
+interface ScoredSkill {
+    skill: SkillSummary;
+    score: number;
+    reasons: MatchReason[];
+    warnings: string[];
+}
+/**
+ * Match reason with category and weight
+ */
+interface MatchReason {
+    category: MatchCategory;
+    description: string;
+    weight: number;
+    matched: string[];
+}
+/**
+ * Categories of matching
+ */
+type MatchCategory = 'framework' | 'language' | 'library' | 'tag' | 'pattern' | 'popularity' | 'quality' | 'freshness';
+/**
+ * Weight configuration for scoring
+ */
+interface ScoringWeights {
+    framework: number;
+    language: number;
+    library: number;
+    tag: number;
+    popularity: number;
+    quality: number;
+    freshness: number;
+}
+declare const DEFAULT_SCORING_WEIGHTS: ScoringWeights;
+/**
+ * Project profile for matching (derived from ProjectContext)
+ */
+interface ProjectProfile {
+    name: string;
+    type?: string;
+    stack: ProjectStack;
+    patterns?: {
+        components?: string;
+        stateManagement?: string;
+        apiStyle?: string;
+        styling?: string;
+        testing?: string;
+    };
+    installedSkills: string[];
+    excludedSkills: string[];
+}
+/**
+ * Skill index for efficient lookup
+ */
+interface SkillIndex {
+    version: number;
+    lastUpdated: string;
+    skills: SkillSummary[];
+    sources: IndexSource[];
+}
+/**
+ * Source repository in the index
+ */
+interface IndexSource {
+    name: string;
+    url: string;
+    lastFetched: string;
+    skillCount: number;
+}
+/**
+ * Recommendation options
+ */
+interface RecommendOptions {
+    limit?: number;
+    minScore?: number;
+    categories?: string[];
+    excludeInstalled?: boolean;
+    weights?: Partial<ScoringWeights>;
+    includeReasons?: boolean;
+}
+/**
+ * Recommendation result
+ */
+interface RecommendationResult {
+    recommendations: ScoredSkill[];
+    profile: ProjectProfile;
+    totalSkillsScanned: number;
+    timestamp: string;
+}
+/**
+ * Search options for task-based search
+ */
+interface SearchOptions {
+    query: string;
+    limit?: number;
+    semantic?: boolean;
+    filters?: {
+        tags?: string[];
+        minScore?: number;
+        verified?: boolean;
+    };
+}
+/**
+ * Search result
+ */
+interface SearchResult {
+    skill: SkillSummary;
+    relevance: number;
+    matchedTerms: string[];
+    snippet?: string;
+}
+/**
+ * Freshness check result
+ */
+interface FreshnessResult {
+    skill: string;
+    status: 'current' | 'outdated' | 'unknown';
+    details?: {
+        skillVersion?: string;
+        projectVersion?: string;
+        message: string;
+    };
+}
+/**
+ * Tag to technology mapping for smart inference
+ */
+declare const TAG_TO_TECH: Record<string, string[]>;
+/**
+ * Reverse mapping: tech to tags
+ */
+declare function getTechTags(techName: string): string[];
+
+/**
+ * Recommendation engine for matching skills to project profiles
+ */
+declare class RecommendationEngine {
+    private weights;
+    private index;
+    constructor(weights?: Partial<ScoringWeights>);
+    /**
+     * Load skill index from cache or generate from local skills
+     */
+    loadIndex(index: SkillIndex): void;
+    /**
+     * Get loaded index
+     */
+    getIndex(): SkillIndex | null;
+    /**
+     * Score a single skill against a project profile
+     */
+    scoreSkill(profile: ProjectProfile, skill: SkillSummary): ScoredSkill;
+    /**
+     * Match frameworks in project stack against skill
+     */
+    private matchFrameworks;
+    /**
+     * Match languages in project stack against skill
+     */
+    private matchLanguages;
+    /**
+     * Match libraries in project stack against skill
+     */
+    private matchLibraries;
+    /**
+     * Match tags based on project patterns and type
+     */
+    private matchTags;
+    /**
+     * Extract relevant tags from project profile
+     */
+    private extractProjectTags;
+    /**
+     * Score based on popularity (downloads/stars)
+     */
+    private scorePopularity;
+    /**
+     * Score based on quality metrics
+     */
+    private scoreQuality;
+    /**
+     * Score based on freshness (last update)
+     */
+    private scoreFreshness;
+    /**
+     * Find detected version for a technology
+     */
+    private findDetectedVersion;
+    /**
+     * Compare semantic versions (basic implementation)
+     */
+    private isVersionLower;
+    /**
+     * Get top recommendations for a project profile
+     */
+    recommend(profile: ProjectProfile, options?: RecommendOptions): RecommendationResult;
+    /**
+     * Search skills by query (task-based search)
+     */
+    search(options: SearchOptions): SearchResult[];
+    /**
+     * Calculate search relevance for a skill
+     */
+    private calculateRelevance;
+    /**
+     * Check freshness of installed skills against project dependencies
+     *
+     * A skill is considered:
+     * - 'current': skill's minVersion is <= project version (compatible and up to date)
+     * - 'outdated': skill targets a significantly older major version
+     * - 'unknown': no version requirements specified
+     */
+    checkFreshness(profile: ProjectProfile, installedSkills: SkillSummary[]): FreshnessResult[];
+}
+/**
+ * Create a recommendation engine with default settings
+ */
+declare function createRecommendationEngine(weights?: Partial<ScoringWeights>): RecommendationEngine;
+
+export { AGENT_FORMAT_MAP, type AgentAdapterInfo, AgentConfig, AgentType, BitbucketProvider, CONTEXT_DIR, CONTEXT_FILE, type CanonicalSkill, type CloneOptions, type CloneResult, type CommandResult, type ContextExportOptions, type ContextImportOptions, ContextManager, ContextSync, type ContextSyncOptions, CopilotTranslator, CursorTranslator, DEFAULT_SCORING_WEIGHTS, DependencyInfo, Detection, type DetectionSource, type DiscoveredSkill, type FormatCategory, type FormatTranslator, type FreshnessResult, GitHubProvider, GitLabProvider, GitProvider, type GitProviderAdapter, type IndexSource, type InstallOptions, LocalProvider, type MatchCategory, type MatchReason, PROJECT_TYPE_HINTS, ProjectContext, ProjectDetector, ProjectPatterns, type ProjectProfile, ProjectStack, type RecommendOptions, RecommendationEngine, type RecommendationResult, type RegistrySkill, SKILL_DISCOVERY_PATHS, type ScoredSkill, type ScoringWeights, type SearchOptions, type SearchResult, Skill, SkillFrontmatter, type SkillIndex, SkillLocation, SkillMdTranslator, SkillMetadata, SkillPreferences, SkillSummary, SkillkitConfig, type SyncOptions, type SyncReport, type SyncResult, TAG_TO_TECH, TranslatableSkillFrontmatter, type TranslationOptions, type TranslationPath, type TranslationResult, TranslatorRegistry, type UpdateOptions, WindsurfTranslator, analyzeProject, canTranslate, copilotTranslator, createContextManager, createContextSync, createRecommendationEngine, cursorTranslator, detectProvider, detectSkillFormat, discoverSkills, extractField, extractFrontmatter, findAllSkills, findSkill, getAgentConfigPath, getAllProviders, getGlobalConfigPath, getInstallDir, getProjectConfigPath, getProvider, getSearchDirs, getStackTags, getSupportedTranslationAgents, getTechTags, initContext, initProject, isGitUrl, isLocalPath, isPathInside, loadConfig, loadContext, loadMetadata, loadSkillMetadata, parseShorthand, parseSkill, parseSkillContent, parseSource, readSkillContent, saveConfig, saveSkillMetadata, setSkillEnabled, skillMdTranslator, syncToAgent, syncToAllAgents, translateSkill, translateSkillFile, translatorRegistry, validateSkill, windsurfTranslator };