opencode-swarm-plugin 0.22.0 → 0.23.0

package/dist/schemas/task.d.ts

@@ -0,0 +1,188 @@
+/**
+ * Task decomposition schemas
+ *
+ * These schemas define the structure for breaking down tasks
+ * into parallelizable subtasks for swarm execution.
+ */
+import { z } from "zod";
+/**
+ * Effort estimation for subtasks.
+ *
+ * Time ranges:
+ * - `trivial`: < 5 minutes (simple rename, typo fix)
+ * - `small`: 5-30 minutes (single function, simple feature)
+ * - `medium`: 30 min - 2 hours (multi-file change, moderate complexity)
+ * - `large`: 2+ hours (significant feature, refactoring)
+ */
+export declare const EffortLevelSchema: z.ZodEnum<{
+    small: "small";
+    trivial: "trivial";
+    medium: "medium";
+    large: "large";
+}>;
+export type EffortLevel = z.infer<typeof EffortLevelSchema>;
+/**
+ * Dependency type between subtasks
+ */
+export declare const DependencyTypeSchema: z.ZodEnum<{
+    blocks: "blocks";
+    related: "related";
+    requires: "requires";
+}>;
+export type DependencyType = z.infer<typeof DependencyTypeSchema>;
+/**
+ * Subtask in a decomposition
+ */
+export declare const DecomposedSubtaskSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodString;
+    files: z.ZodArray<z.ZodString>;
+    estimated_effort: z.ZodEnum<{
+        small: "small";
+        trivial: "trivial";
+        medium: "medium";
+        large: "large";
+    }>;
+    risks: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+export type DecomposedSubtask = z.infer<typeof DecomposedSubtaskSchema>;
+/**
+ * Dependency between subtasks
+ */
+export declare const SubtaskDependencySchema: z.ZodObject<{
+    from: z.ZodNumber;
+    to: z.ZodNumber;
+    type: z.ZodEnum<{
+        blocks: "blocks";
+        related: "related";
+        requires: "requires";
+    }>;
+}, z.core.$strip>;
+export type SubtaskDependency = z.infer<typeof SubtaskDependencySchema>;
+/**
+ * Full task decomposition result
+ *
+ * Returned by the decomposition agent, validated before spawning.
+ */
+export declare const TaskDecompositionSchema: z.ZodObject<{
+    task: z.ZodString;
+    reasoning: z.ZodOptional<z.ZodString>;
+    subtasks: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        description: z.ZodString;
+        files: z.ZodArray<z.ZodString>;
+        estimated_effort: z.ZodEnum<{
+            small: "small";
+            trivial: "trivial";
+            medium: "medium";
+            large: "large";
+        }>;
+        risks: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>>;
+    dependencies: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        from: z.ZodNumber;
+        to: z.ZodNumber;
+        type: z.ZodEnum<{
+            blocks: "blocks";
+            related: "related";
+            requires: "requires";
+        }>;
+    }, z.core.$strip>>>>;
+    shared_context: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type TaskDecomposition = z.infer<typeof TaskDecompositionSchema>;
+/**
+ * Arguments for task decomposition
+ */
+export declare const DecomposeArgsSchema: z.ZodObject<{
+    task: z.ZodString;
+    max_subtasks: z.ZodDefault<z.ZodNumber>;
+    context: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DecomposeArgs = z.infer<typeof DecomposeArgsSchema>;
+/**
+ * Spawn result for a single agent
+ */
+export declare const SpawnedAgentSchema: z.ZodObject<{
+    bead_id: z.ZodString;
+    agent_name: z.ZodString;
+    task_id: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        failed: "failed";
+        pending: "pending";
+        running: "running";
+        completed: "completed";
+    }>;
+    files: z.ZodArray<z.ZodString>;
+    reservation_ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>;
+export type SpawnedAgent = z.infer<typeof SpawnedAgentSchema>;
+/**
+ * Result of spawning a swarm
+ */
+export declare const SwarmSpawnResultSchema: z.ZodObject<{
+    epic_id: z.ZodString;
+    coordinator_name: z.ZodString;
+    thread_id: z.ZodString;
+    agents: z.ZodArray<z.ZodObject<{
+        bead_id: z.ZodString;
+        agent_name: z.ZodString;
+        task_id: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            failed: "failed";
+            pending: "pending";
+            running: "running";
+            completed: "completed";
+        }>;
+        files: z.ZodArray<z.ZodString>;
+        reservation_ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    }, z.core.$strip>>;
+    started_at: z.ZodString;
+}, z.core.$strip>;
+export type SwarmSpawnResult = z.infer<typeof SwarmSpawnResultSchema>;
+/**
+ * Progress update from an agent
+ */
+export declare const AgentProgressSchema: z.ZodObject<{
+    bead_id: z.ZodString;
+    agent_name: z.ZodString;
+    status: z.ZodEnum<{
+        in_progress: "in_progress";
+        blocked: "blocked";
+        failed: "failed";
+        completed: "completed";
+    }>;
+    progress_percent: z.ZodOptional<z.ZodNumber>;
+    message: z.ZodOptional<z.ZodString>;
+    files_touched: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    blockers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export type AgentProgress = z.infer<typeof AgentProgressSchema>;
+/**
+ * Swarm status summary
+ */
+export declare const SwarmStatusSchema: z.ZodObject<{
+    epic_id: z.ZodString;
+    total_agents: z.ZodNumber;
+    running: z.ZodNumber;
+    completed: z.ZodNumber;
+    failed: z.ZodNumber;
+    blocked: z.ZodNumber;
+    agents: z.ZodArray<z.ZodObject<{
+        bead_id: z.ZodString;
+        agent_name: z.ZodString;
+        task_id: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            failed: "failed";
+            pending: "pending";
+            running: "running";
+            completed: "completed";
+        }>;
+        files: z.ZodArray<z.ZodString>;
+        reservation_ids: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    }, z.core.$strip>>;
+    last_update: z.ZodString;
+}, z.core.$strip>;
+export type SwarmStatus = z.infer<typeof SwarmStatusSchema>;
+//# sourceMappingURL=task.d.ts.map

package/dist/schemas/task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../../src/schemas/task.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB;;;;;EAK5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;EAI/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;iBAOlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;iBAMlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;;;GAIG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;iBAWlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;iBAI9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;iBAe7B,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;iBAMjC,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;iBAe7B,CAAC;AACJ,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;iBAS5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/skills.d.ts

@@ -0,0 +1,471 @@
+/**
+ * Skills Module for OpenCode
+ *
+ * Implements Anthropic's Agent Skills specification for OpenCode.
+ * Skills are markdown files with YAML frontmatter that provide
+ * domain-specific instructions the model can activate when relevant.
+ *
+ * Discovery locations (in priority order):
+ * 1. {projectDir}/.opencode/skills/
+ * 2. {projectDir}/.claude/skills/ (compatibility)
+ * 3. {projectDir}/skills/ (simple projects)
+ *
+ * Skill format:
+ * ```markdown
+ * ---
+ * name: my-skill
+ * description: What it does. Use when X.
+ * ---
+ *
+ * # Skill Instructions
+ * ...
+ * ```
+ *
+ * @module skills
+ */
+/**
+ * Skill metadata from YAML frontmatter
+ */
+export interface SkillMetadata {
+    /** Unique skill identifier (lowercase, hyphens) */
+    name: string;
+    /** Description of what the skill does and when to use it */
+    description: string;
+    /** Optional list of tools this skill works with */
+    tools?: string[];
+    /** Optional tags for categorization */
+    tags?: string[];
+}
+/**
+ * Full skill definition including content
+ */
+export interface Skill {
+    /** Parsed frontmatter metadata */
+    metadata: SkillMetadata;
+    /** Raw markdown body (instructions) */
+    body: string;
+    /** Absolute path to the SKILL.md file */
+    path: string;
+    /** Directory containing the skill */
+    directory: string;
+    /** Whether this skill has executable scripts */
+    hasScripts: boolean;
+    /** List of script files in the skill directory */
+    scripts: string[];
+}
+/**
+ * Lightweight skill reference for listing
+ */
+export interface SkillRef {
+    name: string;
+    description: string;
+    path: string;
+    hasScripts: boolean;
+}
+/**
+ * Set the project directory for skill discovery
+ */
+export declare function setSkillsProjectDirectory(dir: string): void;
+/**
+ * Parse YAML frontmatter from markdown content using gray-matter
+ *
+ * Handles the common frontmatter format:
+ * ```
+ * ---
+ * key: value
+ * ---
+ * body content
+ * ```
+ */
+export declare function parseFrontmatter(content: string): {
+    metadata: Record<string, unknown>;
+    body: string;
+};
+/**
+ * Discover all skills in the project and global directories
+ *
+ * Priority order (first match wins):
+ * 1. Project: .opencode/skills/
+ * 2. Project: .claude/skills/
+ * 3. Project: skills/
+ * 4. Global: ~/.config/opencode/skills/
+ * 5. Global: ~/.claude/skills/
+ */
+export declare function discoverSkills(projectDir?: string): Promise<Map<string, Skill>>;
+/**
+ * Get a single skill by name
+ */
+export declare function getSkill(name: string): Promise<Skill | null>;
+/**
+ * List all available skills (lightweight refs only)
+ */
+export declare function listSkills(): Promise<SkillRef[]>;
+/**
+ * Invalidate the skills cache (call when skills may have changed)
+ */
+export declare function invalidateSkillsCache(): void;
+/**
+ * List available skills with metadata
+ *
+ * Returns lightweight skill references for the model to evaluate
+ * which skills are relevant to the current task.
+ */
+export declare const skills_list: {
+    description: string;
+    args: {
+        tag: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        tag?: string | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Load and activate a skill by name
+ *
+ * Loads the full skill content for injection into context.
+ * The skill's instructions become available for the model to follow.
+ */
+export declare const skills_use: {
+    description: string;
+    args: {
+        name: import("zod").ZodString;
+        include_scripts: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    };
+    execute(args: {
+        name: string;
+        include_scripts?: boolean | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Execute a script from a skill
+ *
+ * Skills can include helper scripts in their scripts/ directory.
+ * This tool runs them with appropriate context.
+ */
+export declare const skills_execute: {
+    description: string;
+    args: {
+        skill: import("zod").ZodString;
+        script: import("zod").ZodString;
+        args: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    };
+    execute(args: {
+        skill: string;
+        script: string;
+        args?: string[] | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Read a resource file from a skill directory
+ *
+ * Skills can include additional resources like examples, templates, or reference docs.
+ */
+export declare const skills_read: {
+    description: string;
+    args: {
+        skill: import("zod").ZodString;
+        file: import("zod").ZodString;
+    };
+    execute(args: {
+        skill: string;
+        file: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * CSO validation warnings for skill metadata
+ */
+export interface CSOValidationWarnings {
+    /** Critical warnings (strong indicators of poor discoverability) */
+    critical: string[];
+    /** Suggestions for improvement */
+    suggestions: string[];
+}
+/**
+ * Validate skill metadata against Claude Search Optimization best practices
+ *
+ * Checks:
+ * - 'Use when...' format in description
+ * - Description length (warn > 500, max 1024)
+ * - Third-person voice (no 'I', 'you')
+ * - Name conventions (verb-first, gerunds, hyphens)
+ *
+ * @returns Warnings object with critical issues and suggestions
+ */
+export declare function validateCSOCompliance(name: string, description: string): CSOValidationWarnings;
+/**
+ * Create a new skill in the project
+ *
+ * Agents can use this to codify learned patterns, best practices,
+ * or domain-specific knowledge into reusable skills.
+ */
+export declare const skills_create: {
+    description: string;
+    args: {
+        name: import("zod").ZodString;
+        description: import("zod").ZodString;
+        body: import("zod").ZodString;
+        tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        tools: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        directory: import("zod").ZodOptional<import("zod").ZodEnum<{
+            ".opencode/skills": ".opencode/skills";
+            ".claude/skills": ".claude/skills";
+            skills: "skills";
+            global: "global";
+            "global-claude": "global-claude";
+        }>>;
+    };
+    execute(args: {
+        name: string;
+        description: string;
+        body: string;
+        tags?: string[] | undefined;
+        tools?: string[] | undefined;
+        directory?: ".opencode/skills" | ".claude/skills" | "skills" | "global" | "global-claude" | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Update an existing skill
+ *
+ * Modify a skill's metadata or content based on learned improvements.
+ */
+export declare const skills_update: {
+    description: string;
+    args: {
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        body: import("zod").ZodOptional<import("zod").ZodString>;
+        append_body: import("zod").ZodOptional<import("zod").ZodString>;
+        tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        add_tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        tools: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    };
+    execute(args: {
+        name: string;
+        description?: string | undefined;
+        body?: string | undefined;
+        append_body?: string | undefined;
+        tags?: string[] | undefined;
+        add_tags?: string[] | undefined;
+        tools?: string[] | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Delete a skill from the project
+ */
+export declare const skills_delete: {
+    description: string;
+    args: {
+        name: import("zod").ZodString;
+        confirm: import("zod").ZodBoolean;
+    };
+    execute(args: {
+        name: string;
+        confirm: boolean;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Add a script to a skill
+ *
+ * Skills can include helper scripts for automation.
+ */
+export declare const skills_add_script: {
+    description: string;
+    args: {
+        skill: import("zod").ZodString;
+        script_name: import("zod").ZodString;
+        content: import("zod").ZodString;
+        executable: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    };
+    execute(args: {
+        skill: string;
+        script_name: string;
+        content: string;
+        executable: boolean;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * Initialize a new skill with full directory structure
+ *
+ * Creates a skill template following best practices from the
+ * Anthropic Agent Skills specification and community patterns.
+ */
+export declare const skills_init: {
+    description: string;
+    args: {
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        directory: import("zod").ZodOptional<import("zod").ZodEnum<{
+            ".opencode/skills": ".opencode/skills";
+            ".claude/skills": ".claude/skills";
+            skills: "skills";
+            global: "global";
+        }>>;
+        include_example_script: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        include_reference: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    };
+    execute(args: {
+        name: string;
+        include_example_script: boolean;
+        include_reference: boolean;
+        description?: string | undefined;
+        directory?: ".opencode/skills" | ".claude/skills" | "skills" | "global" | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+/**
+ * All skills tools for plugin registration
+ */
+export declare const skillsTools: {
+    skills_list: {
+        description: string;
+        args: {
+            tag: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            tag?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    skills_use: {
+        description: string;
+        args: {
+            name: import("zod").ZodString;
+            include_scripts: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            name: string;
+            include_scripts?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    skills_execute: {
+        description: string;
+        args: {
+            skill: import("zod").ZodString;
+            script: import("zod").ZodString;
+            args: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        };
+        execute(args: {
+            skill: string;
+            script: string;
+            args?: string[] | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    skills_read: {
+        description: string;
+        args: {
+            skill: import("zod").ZodString;
+            file: import("zod").ZodString;
+        };
+        execute(args: {
+            skill: string;
+            file: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    skills_create: {
+        description: string;
+        args: {
+            name: import("zod").ZodString;
+            description: import("zod").ZodString;
+            body: import("zod").ZodString;
+            tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            tools: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            directory: import("zod").ZodOptional<import("zod").ZodEnum<{
+                ".opencode/skills": ".opencode/skills";
+                ".claude/skills": ".claude/skills";
+                skills: "skills";
+                global: "global";
+                "global-claude": "global-claude";
+            }>>;
+        };
+        execute(args: {
+            name: string;
+            description: string;
+            body: string;
+            tags?: string[] | undefined;
+            tools?: string[] | undefined;
+            directory?: ".opencode/skills" | ".claude/skills" | "skills" | "global" | "global-claude" | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    skills_update: {
+        description: string;
+        args: {
+            name: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            body: import("zod").ZodOptional<import("zod").ZodString>;
+            append_body: import("zod").ZodOptional<import("zod").ZodString>;
+            tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            add_tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            tools: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        };
+        execute(args: {
+            name: string;
+            description?: string | undefined;
+            body?: string | undefined;
+            append_body?: string | undefined;
+            tags?: string[] | undefined;
+            add_tags?: string[] | undefined;
+            tools?: string[] | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    skills_delete: {
+        description: string;
+        args: {
+            name: import("zod").ZodString;
+            confirm: import("zod").ZodBoolean;
+        };
+        execute(args: {
+            name: string;
+            confirm: boolean;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    skills_add_script: {
+        description: string;
+        args: {
+            skill: import("zod").ZodString;
+            script_name: import("zod").ZodString;
+            content: import("zod").ZodString;
+            executable: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            skill: string;
+            script_name: string;
+            content: string;
+            executable: boolean;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    skills_init: {
+        description: string;
+        args: {
+            name: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            directory: import("zod").ZodOptional<import("zod").ZodEnum<{
+                ".opencode/skills": ".opencode/skills";
+                ".claude/skills": ".claude/skills";
+                skills: "skills";
+                global: "global";
+            }>>;
+            include_example_script: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            include_reference: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            name: string;
+            include_example_script: boolean;
+            include_reference: boolean;
+            description?: string | undefined;
+            directory?: ".opencode/skills" | ".claude/skills" | "skills" | "global" | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+};
+/**
+ * Get skill context for swarm task decomposition
+ *
+ * Returns a summary of available skills that can be referenced
+ * in subtask prompts for specialized handling.
+ */
+export declare function getSkillsContextForSwarm(): Promise<string>;
+/**
+ * Find skills relevant to a task description
+ *
+ * Simple keyword matching to suggest skills for a task.
+ * Returns skill names that may be relevant.
+ */
+export declare function findRelevantSkills(taskDescription: string): Promise<string[]>;
+//# sourceMappingURL=skills.d.ts.map

package/dist/skills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills.d.ts","sourceRoot":"","sources":["../src/skills.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAmBH;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,mDAAmD;IACnD,IAAI,EAAE,MAAM,CAAC;IACb,4DAA4D;IAC5D,WAAW,EAAE,MAAM,CAAC;IACpB,mDAAmD;IACnD,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,uCAAuC;IACvC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,KAAK;IACpB,kCAAkC;IAClC,QAAQ,EAAE,aAAa,CAAC;IACxB,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,qCAAqC;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,gDAAgD;IAChD,UAAU,EAAE,OAAO,CAAC;IACpB,kDAAkD;IAClD,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,OAAO,CAAC;CACrB;AAYD;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAG3D;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG;IACjD,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,IAAI,EAAE,MAAM,CAAC;CACd,CAQA;AA6JD;;;;;;;;;GASG;AACH,wBAAsB,cAAc,CAClC,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAuD7B;AAED;;GAEG;AACH,wBAAsB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,CAGlE;AAED;;GAEG;AACH,wBAAsB,UAAU,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC,CAQtD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAE5C;AAMD;;;;;GAKG;AACH,eAAO,MAAM,WAAW;;;;;;;;CAyCtB,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;CAoCrB,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;CAwEzB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;CAsDtB,CAAC;AAeH;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,oEAAoE;IACpE,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,kCAAkC;IAClC,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,GAClB,qBAAqB,CA2FvB;AAwGD;;;;;GAKG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;CA6GxB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;CAoGxB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;CA4CxB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;CAqE5B,CAAC;AAiGH;;;;;GAKG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;CA6ItB,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAUvB,CAAC;AAMF;;;;;GAKG;AACH,wBAAsB,wBAAwB,IAAI,OAAO,CAAC,MAAM,CAAC,CAoBhE;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACtC,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,MAAM,EAAE,CAAC,CA2BnB"}