oh-my-opencode-kikokikok 2.13.0

package/dist/features/knowledge-repo/cache.d.ts

@@ -0,0 +1,28 @@
+import type { KnowledgeCommit, KnowledgeManifest } from "./types";
+interface CacheConfig {
+    memoryEnabled: boolean;
+    diskEnabled: boolean;
+    ttlMs: number;
+    diskCacheDir: string;
+}
+export declare class KnowledgeCache {
+    private config;
+    private memoryCache;
+    private initialized;
+    constructor(config: Partial<CacheConfig> & {
+        diskCacheDir: string;
+    });
+    initialize(): Promise<void>;
+    getCommit(id: string): Promise<KnowledgeCommit | null>;
+    setCommit(commit: KnowledgeCommit): Promise<void>;
+    getManifest(): Promise<KnowledgeManifest | null>;
+    setManifest(manifest: KnowledgeManifest): Promise<void>;
+    invalidateCommit(id: string): Promise<void>;
+    invalidateManifest(): Promise<void>;
+    clear(): Promise<void>;
+    private get;
+    private set;
+    private invalidate;
+    private getDiskPath;
+}
+export {};

package/dist/features/knowledge-repo/client.d.ts

@@ -0,0 +1,39 @@
+import type { KnowledgeCommit, KnowledgeLayer, KnowledgeType, KnowledgeAuthor, KnowledgeManifest, KnowledgeQueryFilter, KnowledgeQueryResult, PromotionRequest, PromotionRecord, KnowledgeRepositoryConfig, RepositoryStats, Constraint, Severity, KnowledgeMetadata } from "./types";
+export declare class KnowledgeRepository {
+    private config;
+    private commitsDir;
+    private manifestPath;
+    private promotionsDir;
+    constructor(config: KnowledgeRepositoryConfig);
+    initialize(): Promise<void>;
+    createCommit(params: {
+        type: KnowledgeType;
+        title: string;
+        content: string;
+        layer: KnowledgeLayer;
+        severity: Severity;
+        constraints?: Constraint[];
+        metadata?: KnowledgeMetadata;
+        author: KnowledgeAuthor;
+        tags?: string[];
+        triggerKeywords?: string[];
+        parentId?: string;
+    }): Promise<KnowledgeCommit>;
+    getCommit(layer: KnowledgeLayer, id: string): Promise<KnowledgeCommit | null>;
+    getCommitById(id: string): Promise<KnowledgeCommit | null>;
+    query(filter: KnowledgeQueryFilter): Promise<KnowledgeQueryResult>;
+    getManifest(): Promise<KnowledgeManifest>;
+    rebuildManifest(): Promise<KnowledgeManifest>;
+    promote(request: PromotionRequest): Promise<PromotionRecord>;
+    getHistory(id: string): Promise<KnowledgeCommit[]>;
+    getStats(): Promise<RepositoryStats>;
+    findByKeyword(keyword: string): Promise<KnowledgeCommit[]>;
+    getMergedKnowledge(layer: KnowledgeLayer): Promise<KnowledgeCommit[]>;
+    private getCommitPath;
+    private generateCommitId;
+    private generateSummary;
+    private commitToManifestEntry;
+    private createEmptyManifest;
+    private updateManifest;
+    private normalizeFilter;
+}

package/dist/features/knowledge-repo/client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/features/knowledge-repo/conflict-detector.d.ts

@@ -0,0 +1,28 @@
+import type { ConstraintViolation, KnowledgeCommit, Severity } from "./types";
+interface DetectionContext {
+    projectRoot: string;
+    targetFiles?: string[];
+}
+interface DetectionResult {
+    violations: ConstraintViolation[];
+    filesScanned: number;
+    constraintsChecked: number;
+}
+export declare class ConflictDetector {
+    detect(commits: KnowledgeCommit[], context: DetectionContext): Promise<DetectionResult>;
+    checkFile(commits: KnowledgeCommit[], filePath: string, context: DetectionContext): Promise<ConstraintViolation[]>;
+    private shouldApplyConstraint;
+    private checkConstraint;
+    private checkMustNotUse;
+    private checkMustUse;
+    private checkMustMatch;
+    private checkMustNotMatch;
+    private checkMustExist;
+    private checkMustNotExist;
+    private createViolation;
+    private generateRemediation;
+    private collectFiles;
+}
+export declare function groupViolationsBySeverity(violations: ConstraintViolation[]): Record<Severity, ConstraintViolation[]>;
+export declare function hasBlockingViolations(violations: ConstraintViolation[]): boolean;
+export {};

package/dist/features/knowledge-repo/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types";
+export { KnowledgeRepository } from "./client";
+export { KnowledgeCache } from "./cache";
+export { ConflictDetector, groupViolationsBySeverity, hasBlockingViolations, } from "./conflict-detector";

package/dist/features/knowledge-repo/types.d.ts

@@ -0,0 +1,338 @@
+/**
+ * Knowledge Repository Types
+ *
+ * Git-like immutable knowledge storage with hierarchical layers.
+ * Supports ADRs, Policies, Patterns, and Specs with constraint-based conflict detection.
+ */
+/**
+ * Hierarchical layers for knowledge organization.
+ * Lower layers inherit from and can override higher layers.
+ */
+export type KnowledgeLayer = "company" | "org" | "project";
+/**
+ * Severity levels for policy enforcement.
+ * - info: Informational, no action required
+ * - warn: Warning, agent should acknowledge
+ * - block: Blocking, agent must stop and report violation
+ */
+export type Severity = "info" | "warn" | "block";
+/**
+ * Types of knowledge artifacts.
+ * - adr: Architectural Decision Record
+ * - policy: Organizational policy with enforcement rules
+ * - pattern: Reusable code/design pattern
+ * - spec: Technical specification
+ */
+export type KnowledgeType = "adr" | "policy" | "pattern" | "spec";
+/**
+ * Status of an ADR (Architectural Decision Record).
+ */
+export type ADRStatus = "proposed" | "accepted" | "deprecated" | "superseded";
+/**
+ * Constraint operators for the DSL.
+ */
+export type ConstraintOperator = "must_not_use" | "must_use" | "must_match" | "must_not_match" | "must_exist" | "must_not_exist";
+/**
+ * Constraint target types.
+ */
+export type ConstraintTarget = "file" | "code" | "dependency" | "import" | "config";
+/**
+ * A single constraint rule in the DSL.
+ */
+export interface Constraint {
+    id: string;
+    operator: ConstraintOperator;
+    target: ConstraintTarget;
+    /** Glob pattern, regex, or exact string depending on target */
+    pattern: string;
+    /** Optional message to show on violation */
+    message?: string;
+    /** Severity when this constraint is violated */
+    severity: Severity;
+    /** Glob patterns for files this constraint applies to */
+    appliesTo?: string[];
+    /** Glob patterns for files this constraint does NOT apply to */
+    excludes?: string[];
+}
+/**
+ * Result of a constraint check.
+ */
+export interface ConstraintViolation {
+    constraintId: string;
+    knowledgeId: string;
+    severity: Severity;
+    message: string;
+    /** File path where violation occurred */
+    file?: string;
+    /** Line number where violation occurred */
+    line?: number;
+    /** The matching content that violated the constraint */
+    match?: string;
+    /** Suggested remediation */
+    remediation?: string;
+}
+/**
+ * Author information for a knowledge commit.
+ */
+export interface KnowledgeAuthor {
+    id: string;
+    name: string;
+    email?: string;
+}
+/**
+ * Metadata for ADR-type knowledge.
+ */
+export interface ADRMetadata {
+    status: ADRStatus;
+    /** ID of the ADR that supersedes this one */
+    supersededBy?: string;
+    /** IDs of related ADRs */
+    relatedTo?: string[];
+    /** Context/background for the decision */
+    context?: string;
+    /** Available options that were considered */
+    options?: Array<{
+        title: string;
+        description: string;
+        pros?: string[];
+        cons?: string[];
+    }>;
+    /** Final decision made */
+    decision?: string;
+    /** Expected consequences of the decision */
+    consequences?: string[];
+}
+/**
+ * Metadata for Policy-type knowledge.
+ */
+export interface PolicyMetadata {
+    /** Whether this policy is currently active */
+    active: boolean;
+    /** Date when this policy takes effect */
+    effectiveDate?: string;
+    /** Date when this policy expires */
+    expiresAt?: string;
+    /** IDs of exceptions to this policy */
+    exceptions?: string[];
+    /** Owner responsible for this policy */
+    owner?: string;
+}
+/**
+ * Metadata for Pattern-type knowledge.
+ */
+export interface PatternMetadata {
+    /** Programming languages this pattern applies to */
+    languages?: string[];
+    /** Frameworks this pattern applies to */
+    frameworks?: string[];
+    /** Difficulty level */
+    difficulty?: "beginner" | "intermediate" | "advanced";
+    /** Example code snippets */
+    examples?: Array<{
+        language: string;
+        code: string;
+        description?: string;
+    }>;
+}
+/**
+ * Metadata for Spec-type knowledge.
+ */
+export interface SpecMetadata {
+    /** Version of the specification */
+    version?: string;
+    /** Specification status */
+    status?: "draft" | "review" | "approved" | "deprecated";
+    /** API endpoints or interfaces defined */
+    endpoints?: string[];
+    /** Data schemas defined */
+    schemas?: string[];
+}
+/**
+ * Union type for type-specific metadata.
+ */
+export type KnowledgeMetadata = {
+    type: "adr";
+    data: ADRMetadata;
+} | {
+    type: "policy";
+    data: PolicyMetadata;
+} | {
+    type: "pattern";
+    data: PatternMetadata;
+} | {
+    type: "spec";
+    data: SpecMetadata;
+};
+/**
+ * An immutable knowledge commit.
+ * Once created, commits cannot be modified - only new commits can be added.
+ */
+export interface KnowledgeCommit {
+    /** Unique identifier (SHA-like hash) */
+    id: string;
+    /** Type of knowledge artifact */
+    type: KnowledgeType;
+    /** Human-readable title */
+    title: string;
+    /** One-line summary for manifest (max 100 chars) */
+    summary: string;
+    /** Full content in markdown format */
+    content: string;
+    /** Hierarchical layer */
+    layer: KnowledgeLayer;
+    /** Default severity for violations */
+    severity: Severity;
+    /** Constraint rules for this knowledge */
+    constraints: Constraint[];
+    /** Type-specific metadata */
+    metadata?: KnowledgeMetadata;
+    /** Author of this commit */
+    author: KnowledgeAuthor;
+    /** ISO 8601 timestamp */
+    createdAt: string;
+    /** ID of the parent commit (for versioning) */
+    parentId?: string;
+    /** Tags for categorization */
+    tags: string[];
+    /** Keywords that trigger loading this knowledge */
+    triggerKeywords: string[];
+}
+/**
+ * A single entry in the knowledge manifest.
+ * Designed to be extremely compact for initial context loading.
+ */
+export interface ManifestEntry {
+    /** Knowledge ID */
+    id: string;
+    /** Type abbreviation */
+    type: KnowledgeType;
+    /** Layer abbreviation */
+    layer: KnowledgeLayer;
+    /** One-line summary (max 100 chars) */
+    summary: string;
+    /** Severity indicator */
+    severity: Severity;
+    /** Keywords that trigger full loading */
+    keywords: string[];
+}
+/**
+ * The knowledge manifest for a session.
+ * Must be under 2K tokens for efficient context usage.
+ */
+export interface KnowledgeManifest {
+    /** Version of the manifest format */
+    version: string;
+    /** When this manifest was generated */
+    generatedAt: string;
+    /** Total number of knowledge items */
+    totalCount: number;
+    /** Entries by layer */
+    entries: {
+        company: ManifestEntry[];
+        org: ManifestEntry[];
+        project: ManifestEntry[];
+    };
+    /** Aggregate statistics */
+    stats: {
+        byType: Record<KnowledgeType, number>;
+        bySeverity: Record<Severity, number>;
+    };
+}
+/**
+ * Filter options for querying knowledge.
+ */
+export interface KnowledgeQueryFilter {
+    /** Filter by type */
+    type?: KnowledgeType | KnowledgeType[];
+    /** Filter by layer */
+    layer?: KnowledgeLayer | KnowledgeLayer[];
+    /** Filter by severity */
+    severity?: Severity | Severity[];
+    /** Filter by tags */
+    tags?: string[];
+    /** Filter by keywords */
+    keywords?: string[];
+    /** Full-text search in title and content */
+    search?: string;
+    /** Filter by author ID */
+    authorId?: string;
+    /** Filter by date range */
+    createdAfter?: string;
+    /** Filter by date range */
+    createdBefore?: string;
+    /** Maximum results */
+    limit?: number;
+    /** Pagination offset */
+    offset?: number;
+}
+/**
+ * Result of a knowledge query.
+ */
+export interface KnowledgeQueryResult {
+    items: KnowledgeCommit[];
+    total: number;
+    hasMore: boolean;
+}
+/**
+ * A request to promote knowledge from one layer to another.
+ */
+export interface PromotionRequest {
+    /** ID of the knowledge to promote */
+    knowledgeId: string;
+    /** Target layer */
+    targetLayer: KnowledgeLayer;
+    /** Justification for the promotion */
+    justification: string;
+    /** Promoter information */
+    promoter: KnowledgeAuthor;
+}
+/**
+ * Record of a promotion event.
+ */
+export interface PromotionRecord {
+    id: string;
+    knowledgeId: string;
+    fromLayer: KnowledgeLayer;
+    toLayer: KnowledgeLayer;
+    promoter: KnowledgeAuthor;
+    justification: string;
+    promotedAt: string;
+    /** New knowledge ID after promotion (may change) */
+    newKnowledgeId: string;
+}
+/**
+ * Configuration for a knowledge repository.
+ */
+export interface KnowledgeRepositoryConfig {
+    /** Root directory for knowledge storage */
+    rootDir: string;
+    /** Organization identifier */
+    orgId?: string;
+    /** Project identifier */
+    projectId?: string;
+    /** Cache configuration */
+    cache?: {
+        /** Enable memory caching */
+        memory?: boolean;
+        /** Enable disk caching */
+        disk?: boolean;
+        /** TTL for cache entries in seconds */
+        ttlSeconds?: number;
+    };
+    /** Mem0 integration configuration */
+    mem0?: {
+        enabled: boolean;
+        apiKey?: string;
+        endpoint?: string;
+    };
+}
+/**
+ * Statistics about the knowledge repository.
+ */
+export interface RepositoryStats {
+    totalCommits: number;
+    byLayer: Record<KnowledgeLayer, number>;
+    byType: Record<KnowledgeType, number>;
+    bySeverity: Record<Severity, number>;
+    lastUpdated: string;
+}

package/dist/features/mem0-memory/adapter.d.ts

@@ -0,0 +1,19 @@
+import type { Memory, MemorySearchResult, AddMemoryInput, SearchMemoryInput, UpdateMemoryInput, Mem0Config, MemoryStats, MemoryLayer } from "./types";
+export declare class Mem0Adapter {
+    private config;
+    private endpoint;
+    constructor(config: Mem0Config);
+    add(input: AddMemoryInput): Promise<Memory>;
+    search(input: SearchMemoryInput): Promise<MemorySearchResult[]>;
+    get(id: string): Promise<Memory | null>;
+    update(input: UpdateMemoryInput): Promise<Memory>;
+    delete(id: string): Promise<void>;
+    getAll(layer?: MemoryLayer): Promise<Memory[]>;
+    getStats(): Promise<MemoryStats>;
+    private request;
+    private getUserId;
+    private normalizeLayers;
+    private getAllLayers;
+    private parseMemory;
+    private parseSearchResults;
+}

package/dist/features/mem0-memory/adapter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/features/mem0-memory/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./types";
+export { Mem0Adapter } from "./adapter";
+export { MemoryLayerManager } from "./layers";

package/dist/features/mem0-memory/layers.d.ts

@@ -0,0 +1,29 @@
+import type { MemoryLayer, Memory, MemorySearchResult } from "./types";
+import { Mem0Adapter } from "./adapter";
+interface LayerManagerConfig {
+    adapter: Mem0Adapter;
+    defaultLayer: MemoryLayer;
+}
+export declare class MemoryLayerManager {
+    private adapter;
+    private defaultLayer;
+    private layerPriority;
+    constructor(config: LayerManagerConfig);
+    addToLayer(content: string, layer?: MemoryLayer, metadata?: Record<string, unknown>): Promise<Memory>;
+    searchAcrossLayers(query: string, options?: {
+        layers?: MemoryLayer[];
+        limit?: number;
+        threshold?: number;
+    }): Promise<MemorySearchResult[]>;
+    searchLayer(query: string, layer: MemoryLayer, limit?: number): Promise<MemorySearchResult[]>;
+    getLayerMemories(layer: MemoryLayer): Promise<Memory[]>;
+    getMergedContext(query: string, options?: {
+        maxTokens?: number;
+        limit?: number;
+    }): Promise<string>;
+    promoteMemory(id: string, targetLayer: MemoryLayer): Promise<Memory>;
+    clearLayer(layer: MemoryLayer): Promise<number>;
+    clearSession(): Promise<number>;
+    private formatLayerName;
+}
+export {};

package/dist/features/mem0-memory/layers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/features/mem0-memory/types.d.ts

@@ -0,0 +1,45 @@
+export type MemoryLayer = "user" | "session" | "project" | "org" | "company";
+export interface Memory {
+    id: string;
+    content: string;
+    layer: MemoryLayer;
+    metadata?: Record<string, unknown>;
+    createdAt: string;
+    updatedAt?: string;
+}
+export interface MemorySearchResult {
+    memory: Memory;
+    score: number;
+}
+export interface AddMemoryInput {
+    content: string;
+    layer: MemoryLayer;
+    metadata?: Record<string, unknown>;
+}
+export interface SearchMemoryInput {
+    query: string;
+    layer?: MemoryLayer | MemoryLayer[];
+    limit?: number;
+    threshold?: number;
+}
+export interface UpdateMemoryInput {
+    id: string;
+    content?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface DeleteMemoryInput {
+    id: string;
+}
+export interface Mem0Config {
+    enabled: boolean;
+    apiKey?: string;
+    endpoint?: string;
+    userId?: string;
+    projectId?: string;
+    orgId?: string;
+    companyId?: string;
+}
+export interface MemoryStats {
+    totalMemories: number;
+    byLayer: Record<MemoryLayer, number>;
+}

package/dist/features/opencode-skill-loader/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./loader";
+export * from "./merger";

package/dist/features/opencode-skill-loader/loader.d.ts

@@ -0,0 +1,41 @@
+import type { CommandDefinition } from "../claude-code-command-loader/types";
+import type { LoadedSkill } from "./types";
+/**
+ * Load skills from Claude Code user directory (~/.claude/skills/)
+ */
+export declare function loadUserSkills(): Record<string, CommandDefinition>;
+/**
+ * Load skills from Claude Code project directory (.claude/skills/)
+ */
+export declare function loadProjectSkills(): Record<string, CommandDefinition>;
+/**
+ * Load skills from OpenCode global directory (~/.config/opencode/skill/)
+ */
+export declare function loadOpencodeGlobalSkills(): Record<string, CommandDefinition>;
+/**
+ * Load skills from OpenCode project directory (.opencode/skill/)
+ */
+export declare function loadOpencodeProjectSkills(): Record<string, CommandDefinition>;
+/**
+ * Discover all skills from all sources with priority ordering.
+ * Priority order: opencode-project > project > opencode > user
+ *
+ * @returns Array of LoadedSkill objects for use in slashcommand discovery
+ */
+export declare function discoverAllSkills(): LoadedSkill[];
+export interface DiscoverSkillsOptions {
+    includeClaudeCodePaths?: boolean;
+}
+/**
+ * Discover skills with optional filtering.
+ * When includeClaudeCodePaths is false, only loads from OpenCode paths.
+ */
+export declare function discoverSkills(options?: DiscoverSkillsOptions): LoadedSkill[];
+/**
+ * Get a skill by name from all available sources.
+ */
+export declare function getSkillByName(name: string, options?: DiscoverSkillsOptions): LoadedSkill | undefined;
+export declare function discoverUserClaudeSkills(): LoadedSkill[];
+export declare function discoverProjectClaudeSkills(): LoadedSkill[];
+export declare function discoverOpencodeGlobalSkills(): LoadedSkill[];
+export declare function discoverOpencodeProjectSkills(): LoadedSkill[];

package/dist/features/opencode-skill-loader/loader.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/features/opencode-skill-loader/merger.d.ts

@@ -0,0 +1,7 @@
+import type { LoadedSkill } from "./types";
+import type { SkillsConfig } from "../../config/schema";
+import type { BuiltinSkill } from "../builtin-skills/types";
+export interface MergeSkillsOptions {
+    configDir?: string;
+}
+export declare function mergeSkills(builtinSkills: BuiltinSkill[], config: SkillsConfig | undefined, userClaudeSkills: LoadedSkill[], userOpencodeSkills: LoadedSkill[], projectClaudeSkills: LoadedSkill[], projectOpencodeSkills: LoadedSkill[], options?: MergeSkillsOptions): LoadedSkill[];

package/dist/features/opencode-skill-loader/types.d.ts

@@ -0,0 +1,28 @@
+import type { CommandDefinition } from "../claude-code-command-loader/types";
+import type { SkillMcpConfig } from "../skill-mcp-manager/types";
+export type SkillScope = "builtin" | "config" | "user" | "project" | "opencode" | "opencode-project";
+export interface SkillMetadata {
+    name?: string;
+    description?: string;
+    model?: string;
+    "argument-hint"?: string;
+    agent?: string;
+    subtask?: boolean;
+    license?: string;
+    compatibility?: string;
+    metadata?: Record<string, string>;
+    "allowed-tools"?: string;
+    mcp?: SkillMcpConfig;
+}
+export interface LoadedSkill {
+    name: string;
+    path?: string;
+    resolvedPath?: string;
+    definition: CommandDefinition;
+    scope: SkillScope;
+    license?: string;
+    compatibility?: string;
+    metadata?: Record<string, string>;
+    allowedTools?: string[];
+    mcpConfig?: SkillMcpConfig;
+}

package/dist/features/skill-mcp-manager/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export { SkillMcpManager } from "./manager";

package/dist/features/skill-mcp-manager/manager.d.ts

@@ -0,0 +1,21 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { Tool, Resource, Prompt } from "@modelcontextprotocol/sdk/types.js";
+import type { ClaudeCodeMcpServer } from "../claude-code-mcp-loader/types";
+import type { SkillMcpClientInfo, SkillMcpServerContext } from "./types";
+export declare class SkillMcpManager {
+    private clients;
+    private getClientKey;
+    getOrCreateClient(info: SkillMcpClientInfo, config: ClaudeCodeMcpServer): Promise<Client>;
+    private createClient;
+    disconnectSession(sessionID: string): Promise<void>;
+    disconnectAll(): Promise<void>;
+    listTools(info: SkillMcpClientInfo, context: SkillMcpServerContext): Promise<Tool[]>;
+    listResources(info: SkillMcpClientInfo, context: SkillMcpServerContext): Promise<Resource[]>;
+    listPrompts(info: SkillMcpClientInfo, context: SkillMcpServerContext): Promise<Prompt[]>;
+    callTool(info: SkillMcpClientInfo, context: SkillMcpServerContext, name: string, args: Record<string, unknown>): Promise<unknown>;
+    readResource(info: SkillMcpClientInfo, context: SkillMcpServerContext, uri: string): Promise<unknown>;
+    getPrompt(info: SkillMcpClientInfo, context: SkillMcpServerContext, name: string, args: Record<string, string>): Promise<unknown>;
+    private getOrCreateClientWithRetry;
+    getConnectedServers(): string[];
+    isConnected(info: SkillMcpClientInfo): boolean;
+}

package/dist/features/skill-mcp-manager/manager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/features/skill-mcp-manager/types.d.ts

@@ -0,0 +1,11 @@
+import type { ClaudeCodeMcpServer } from "../claude-code-mcp-loader/types";
+export type SkillMcpConfig = Record<string, ClaudeCodeMcpServer>;
+export interface SkillMcpClientInfo {
+    serverName: string;
+    skillName: string;
+    sessionID: string;
+}
+export interface SkillMcpServerContext {
+    config: ClaudeCodeMcpServer;
+    skillName: string;
+}