From 0e4afd6273e92426b907728c11eb30f387ab7021 Mon Sep 17 00:00:00 2001 From: Zhongwei Li Date: Sun, 30 Nov 2025 08:20:11 +0800 Subject: [PATCH] Initial commit --- .claude-plugin/plugin.json | 12 + README.md | 3 + plugin.lock.json | 69 ++++++ skills/pi-pathfinder/SKILL.md | 221 ++++++++++++++++++ skills/pi-pathfinder/assets/README.md | 7 + .../assets/example_plugin_analysis.json | 82 +++++++ .../assets/plugin_selection_rules.yaml | 90 +++++++ .../assets/skill_adaptation_template.py | 141 +++++++++++ skills/pi-pathfinder/references/README.md | 7 + skills/pi-pathfinder/scripts/README.md | 7 + 10 files changed, 639 insertions(+) create mode 100644 .claude-plugin/plugin.json create mode 100644 README.md create mode 100644 plugin.lock.json create mode 100644 skills/pi-pathfinder/SKILL.md create mode 100644 skills/pi-pathfinder/assets/README.md create mode 100644 skills/pi-pathfinder/assets/example_plugin_analysis.json create mode 100644 skills/pi-pathfinder/assets/plugin_selection_rules.yaml create mode 100644 skills/pi-pathfinder/assets/skill_adaptation_template.py create mode 100644 skills/pi-pathfinder/references/README.md create mode 100644 skills/pi-pathfinder/scripts/README.md diff --git a/.claude-plugin/plugin.json b/.claude-plugin/plugin.json new file mode 100644 index 0000000..3304ed6 --- /dev/null +++ b/.claude-plugin/plugin.json @@ -0,0 +1,12 @@ +{ + "name": "pi-pathfinder", + "description": "PI Pathfinder - Finds the path through 229 plugins. Automatically picks the best plugin for your task, extracts its skills, and applies them. You don't pick plugins, PI does.", + "version": "1.0.0", + "author": { + "name": "Jeremy Longshore", + "email": "[email protected]" + }, + "skills": [ + "./skills" + ] +} \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..7753ded --- /dev/null +++ b/README.md @@ -0,0 +1,3 @@ +# pi-pathfinder + +PI Pathfinder - Finds the path through 229 plugins. Automatically picks the best plugin for your task, extracts its skills, and applies them. You don't pick plugins, PI does. diff --git a/plugin.lock.json b/plugin.lock.json new file mode 100644 index 0000000..8e012b0 --- /dev/null +++ b/plugin.lock.json @@ -0,0 +1,69 @@ +{ + "$schema": "internal://schemas/plugin.lock.v1.json", + "pluginId": "gh:jeremylongshore/claude-code-plugins-plus:plugins/examples/pi-pathfinder", + "normalized": { + "repo": null, + "ref": "refs/tags/v20251128.0", + "commit": "602ec546a189d794162fbb93a997d1e5589a5a0c", + "treeHash": "b9d8ee19223b50eb71c8ad04285d8cd245aa9aac47ecd752be63f01e1197396c", + "generatedAt": "2025-11-28T10:18:40.380621Z", + "toolVersion": "publish_plugins.py@0.2.0" + }, + "origin": { + "remote": "git@github.com:zhongweili/42plugin-data.git", + "branch": "master", + "commit": "aa1497ed0949fd50e99e70d6324a29c5b34f9390", + "repoRoot": "/Users/zhongweili/projects/openmind/42plugin-data" + }, + "manifest": { + "name": "pi-pathfinder", + "description": "PI Pathfinder - Finds the path through 229 plugins. Automatically picks the best plugin for your task, extracts its skills, and applies them. You don't pick plugins, PI does.", + "version": "1.0.0" + }, + "content": { + "files": [ + { + "path": "README.md", + "sha256": "d5f1e0b5681f8c3f02a393ffa737b26e48dd188113e41373563e6081a34b31e2" + }, + { + "path": ".claude-plugin/plugin.json", + "sha256": "6b33d524f7060d38ca1f0bc1b620ad107e7ffc58c212636b789ffd405e78b7ec" + }, + { + "path": "skills/pi-pathfinder/SKILL.md", + "sha256": "00678c41b7dab77a627705c4598f8a8f6926eba5f67fca980d3649cd9ed6b8af" + }, + { + "path": "skills/pi-pathfinder/references/README.md", + "sha256": "ef4063163f9a93e5e2d5de78077343b50f8d0973ab4edb1dc95054d5e208b4b9" + }, + { + "path": "skills/pi-pathfinder/scripts/README.md", + "sha256": "32922e3c9a25a8727d19215b62600defcdadca3715e6ea4ad7a40067589c0898" + }, + { + "path": "skills/pi-pathfinder/assets/plugin_selection_rules.yaml", + "sha256": "a961aefb71b7791b30dc1ca4c8f505e00df7877d2e3f4a83a22173430df927b0" + }, + { + "path": "skills/pi-pathfinder/assets/example_plugin_analysis.json", + "sha256": "4f66090a1e8bc627bdb38c52e0181d958e03edd85e9cd469fba2d03e0d72d782" + }, + { + "path": "skills/pi-pathfinder/assets/skill_adaptation_template.py", + "sha256": "d610c447442017398ad03f3cb52a597b41de96084c29a9260d8d94944c27dc1d" + }, + { + "path": "skills/pi-pathfinder/assets/README.md", + "sha256": "28fb584a15b3a6703e4aaf0175307316ca2e74036f38823109657ec76ae01643" + } + ], + "dirSha256": "b9d8ee19223b50eb71c8ad04285d8cd245aa9aac47ecd752be63f01e1197396c" + }, + "security": { + "scannedAt": null, + "scannerVersion": null, + "flags": [] + } +} \ No newline at end of file diff --git a/skills/pi-pathfinder/SKILL.md b/skills/pi-pathfinder/SKILL.md new file mode 100644 index 0000000..60008e8 --- /dev/null +++ b/skills/pi-pathfinder/SKILL.md @@ -0,0 +1,221 @@ +--- +name: skill-adapter +description: | + Analyzes existing plugins to extract their capabilities, then adapts and applies those skills to the current task. Acts as a universal skill chameleon that learns from other plugins. Activates when you request "skill adapter" functionality. +allowed-tools: Read, Grep, Glob, Bash +version: 1.0.0 +--- + +# Skill Adapter - Universal Plugin Capability Extractor + +## Purpose +Analyzes plugins in the claude-code-plugins marketplace to understand their capabilities, extracts the core patterns and approaches, then adapts those skills to solve the current user's task. Acts as a "skill chameleon" that can adopt any plugin's capabilities. + +## How It Works + +### 1. Task Analysis +When user presents a task: +- Identify the core capability needed (e.g., "analyze code quality", "generate documentation", "automate deployment") +- Determine the domain (security, devops, testing, etc.) +- Extract key requirements and constraints + +### 2. Plugin Discovery +Search existing plugins for relevant capabilities: + +```bash +# Find plugins in relevant category +ls plugins/community/ plugins/packages/ plugins/examples/ + +# Search for keywords in plugin descriptions +grep -r "keyword" --include="plugin.json" plugins/ + +# Find similar commands/agents +grep -r "capability-name" --include="*.md" plugins/ +``` + +### 3. Capability Extraction + +For each relevant plugin found, analyze: + +**Commands (commands/*.md):** +- Read the markdown content +- Extract the approach/methodology +- Identify input/output patterns +- Note any scripts or tools used + +**Agents (agents/*.md):** +- Understand the agent's role +- Extract problem-solving approach +- Note decision-making patterns +- Identify expertise areas + +**Skills (skills/*/SKILL.md):** +- Read the skill instructions +- Extract core capability +- Note trigger conditions +- Understand tool usage patterns + +**Scripts (scripts/*.sh, *.py):** +- Analyze script logic +- Extract reusable patterns +- Identify best practices +- Note error handling approaches + +### 4. Pattern Synthesis + +Combine learned patterns: +- Merge multiple approaches if beneficial +- Adapt to current context and constraints +- Simplify or enhance based on user needs +- Ensure compatibility with current environment + +### 5. Skill Application + +Apply the adapted skill: +- Use the learned approach +- Follow the extracted patterns +- Apply best practices discovered +- Adapt syntax/tools to current context + +## Example Workflows + +### Example 1: Learning Code Analysis from Security Plugins + +**User task:** "Analyze this codebase for issues" + +**Process:** +1. Search for security and code-analysis plugins +2. Find: `owasp-top-10-scanner`, `code-quality-enforcer`, `security-audit-agent` +3. Extract patterns: + - OWASP scanner checks for: SQL injection, XSS, CSRF, auth issues + - Quality enforcer looks at: complexity, duplication, standards + - Audit agent examines: dependencies, secrets, permissions +4. Synthesize approach: + - Run multi-layer analysis + - Check security patterns first + - Then code quality metrics + - Then dependency issues +5. Apply to user's codebase with adapted checks + +### Example 2: Adopting Documentation Skills + +**User task:** "Generate API documentation" + +**Process:** +1. Find documentation plugins +2. Discover: `api-documenter`, `openapi-generator`, `readme-builder` +3. Extract approaches: + - API documenter: parses code, generates OpenAPI spec + - OpenAPI generator: creates interactive docs + - README builder: structures documentation hierarchically +4. Synthesize: + - Parse code for endpoints + - Generate OpenAPI/Swagger spec + - Create interactive documentation + - Build comprehensive README +5. Apply combined approach to user's API + +### Example 3: Learning Automation from DevOps Plugins + +**User task:** "Automate deployment process" + +**Process:** +1. Search DevOps category +2. Find: `deployment-automation`, `ci-cd-pipeline`, `docker-compose-generator` +3. Extract patterns: + - Deployment automation: build → test → deploy → verify + - CI/CD pipeline: trigger conditions, parallel jobs, rollback + - Docker compose: service orchestration, environment management +4. Synthesize deployment workflow +5. Apply to user's specific tech stack + +## Reasoning Process + +### When to Use Skill Adapter + +Trigger when: +- User needs capability that might exist in marketplace +- Task could benefit from existing plugin patterns +- User asks: "Is there a plugin for this?" +- Similar problems have been solved before +- Multiple approaches could be combined + +### Plugin Selection Criteria + +Choose plugins based on: +1. **Relevance**: Matches task domain/requirements +2. **Quality**: Well-documented, clear approach +3. **Simplicity**: Not overly complex for the task +4. **Recency**: Updated plugins preferred +5. **Popularity**: Featured or well-maintained plugins + +### Adaptation Strategy + +When adapting skills: +- **Keep**: Core logic and proven patterns +- **Adapt**: Syntax, tool names, specific commands +- **Enhance**: Add error handling, user feedback +- **Simplify**: Remove unnecessary complexity +- **Contextualize**: Adjust to user's environment + +## Limitations and Boundaries + +### What Skill Adapter CAN Do: +✅ Read and analyze plugin source code +✅ Extract patterns and approaches +✅ Adapt methodologies to new contexts +✅ Combine multiple plugin capabilities +✅ Apply learned skills with reasoning + +### What Skill Adapter CANNOT Do: +❌ Execute compiled code (MCP servers) +❌ Access external APIs without credentials +❌ Modify original plugins +❌ Guarantee exact plugin behavior replication +❌ Use plugins that require specific environment setup + +## Success Criteria + +Skill adaptation is successful when: +1. User's task is completed effectively +2. Approach borrowed makes logical sense +3. Adapted skill is properly contextualized +4. User understands where the approach came from +5. Result quality matches or exceeds original plugin + +## Transparency + +Always inform user: +- Which plugins were analyzed +- What patterns were extracted +- How the skill was adapted +- Why this approach was chosen +- Any limitations of the adaptation + +## Example Usage + +``` +User: "I need to validate JSON schemas in my project" + +Skill Adapter Process: +1. Searches plugins for JSON validation +2. Finds: schema-validator, json-lint-enforcer +3. Extracts: ajv library usage, error formatting patterns +4. Adapts: Uses available tools (jq, node, python) +5. Applies: Validates user's schemas with detailed errors +6. Reports: "I adapted the schema-validator approach using jq + for validation and added custom error formatting" +``` + +## Meta-Learning + +Skill Adapter improves by: +- Tracking which plugins solve which tasks best +- Learning which patterns are most reusable +- Noting which adaptations work well +- Building a mental model of the marketplace +- Understanding plugin ecosystem relationships + +--- + +**In essence:** Skill Adapter is a meta-skill that makes the entire plugin marketplace available as a learning resource, extracting and applying capabilities on-demand to solve user tasks efficiently. diff --git a/skills/pi-pathfinder/assets/README.md b/skills/pi-pathfinder/assets/README.md new file mode 100644 index 0000000..7dd3bb1 --- /dev/null +++ b/skills/pi-pathfinder/assets/README.md @@ -0,0 +1,7 @@ +# Assets + +Bundled resources for pi-pathfinder skill + +- [ ] example_plugin_analysis.json: Example JSON output from the plugin_analyzer.py script, showcasing the structure and content of the plugin analysis. +- [ ] skill_adaptation_template.py: Template for adapting skills from one plugin to another, including placeholders for input parameters, output variables, and adaptation logic. +- [ ] plugin_selection_rules.yaml: YAML file containing rules for selecting the best plugin for a given task, based on keywords, capabilities, and user preferences. diff --git a/skills/pi-pathfinder/assets/example_plugin_analysis.json b/skills/pi-pathfinder/assets/example_plugin_analysis.json new file mode 100644 index 0000000..89caf1e --- /dev/null +++ b/skills/pi-pathfinder/assets/example_plugin_analysis.json @@ -0,0 +1,82 @@ +{ + "_comment": "Example JSON output for plugin analysis by PI Pathfinder", + "query": "Summarize the key findings from the latest IPCC report on climate change and suggest potential mitigation strategies.", + "selected_plugin": { + "name": "Research Assistant", + "description": "A powerful research tool for accessing and summarizing information from various online sources.", + "capabilities": [ + "Web scraping", + "Document summarization", + "Academic paper retrieval", + "Fact checking", + "Trend analysis" + ], + "reasoning": "This plugin is best suited for the task because it can access the IPCC report online, summarize its findings, and identify relevant mitigation strategies from reputable sources.", + "confidence_score": 0.95 + }, + "extracted_skills": [ + { + "skill_name": "Document Summarization", + "skill_description": "Condenses large documents into concise summaries highlighting key information.", + "parameters": { + "document_url": "URL of the IPCC report", + "summary_length": "medium", + "focus_areas": ["key findings", "mitigation strategies"] + }, + "implementation_details": "Utilizes advanced NLP techniques to identify and extract the most important information, including sentence scoring and topic modeling.", + "success_probability": 0.9 + }, + { + "skill_name": "Web Scraping", + "skill_description": "Extracts data from web pages, including text, tables, and images.", + "parameters": { + "url": "URL of the IPCC report website", + "elements_to_extract": ["text", "tables"] + }, + "implementation_details": "Uses a robust web scraping library to handle various website structures and anti-scraping measures.", + "success_probability": 0.98 + } + ], + "execution_plan": [ + { + "step": 1, + "action": "Use Web Scraping to extract the text content from the IPCC report webpage.", + "plugin_skill": "Web Scraping", + "expected_outcome": "Successful extraction of the IPCC report text." + }, + { + "step": 2, + "action": "Use Document Summarization to generate a summary of the extracted text, focusing on key findings and mitigation strategies.", + "plugin_skill": "Document Summarization", + "expected_outcome": "A concise summary of the IPCC report's key findings and mitigation strategies." + }, + { + "step": 3, + "action": "Return the generated summary to the user.", + "plugin_skill": null, + "expected_outcome": "User receives a helpful summary of the IPCC report." + } + ], + "alternative_plugins": [ + { + "name": "Web Search", + "description": "Performs web searches and retrieves relevant snippets.", + "suitability_score": 0.7, + "reason": "Useful for finding general information, but less effective for in-depth document analysis." + }, + { + "name": "Document Reader", + "description": "Reads and analyzes local documents.", + "suitability_score": 0.3, + "reason": "Not applicable as the IPCC report is likely online." + } + ], + "overall_assessment": { + "success_likelihood": 0.9, + "potential_issues": [ + "Website may have anti-scraping measures.", + "Summarization may miss subtle nuances in the report." + ], + "recommendations": "Review the generated summary for accuracy and consult the original report for a complete understanding." + } +} \ No newline at end of file diff --git a/skills/pi-pathfinder/assets/plugin_selection_rules.yaml b/skills/pi-pathfinder/assets/plugin_selection_rules.yaml new file mode 100644 index 0000000..def34cd --- /dev/null +++ b/skills/pi-pathfinder/assets/plugin_selection_rules.yaml @@ -0,0 +1,90 @@ +# plugin_selection_rules.yaml +# Configuration file for PI Pathfinder plugin selection logic. + +# Global settings for plugin selection behavior. +global: + # Default preference for prioritizing plugins: "speed", "accuracy", "cost" + default_priority: "accuracy" + # Maximum number of plugins to consider for a given task. + max_plugins_considered: 10 + # Minimum relevance score for a plugin to be considered. (0.0 - 1.0) + minimum_relevance_score: 0.2 + # Enable/Disable verbose logging for debugging. + verbose_logging: false + +# Rules for selecting plugins based on keywords and task descriptions. +keyword_rules: + # Define keywords and their associated plugin preferences. + # The higher the weight, the more preferred the plugin is for that keyword. + - keywords: ["image", "generate", "picture", "visual"] + plugin_preferences: + "DALL-E": 0.9 # Example: Prefer DALL-E for image generation + "Stable Diffusion": 0.8 + "REPLACE_ME_IMAGE_PLUGIN": 0.5 + - keywords: ["translate", "language", "multilingual"] + plugin_preferences: + "Google Translate": 0.95 + "DeepL Translator": 0.9 + "REPLACE_ME_TRANSLATION_PLUGIN": 0.6 + - keywords: ["code", "programming", "algorithm", "debug"] + plugin_preferences: + "Code Interpreter": 0.9 + "GitHub Copilot": 0.85 + "REPLACE_ME_CODE_PLUGIN": 0.7 + - keywords: ["data analysis", "statistics", "spreadsheet"] + plugin_preferences: + "Wolfram Alpha": 0.9 + "Excel Online": 0.8 + "REPLACE_ME_DATA_PLUGIN": 0.6 + +# Rules for selecting plugins based on their stated capabilities. +capability_rules: + # Define capability patterns and their associated plugin preferences. + # These rules are based on the plugin's description and advertised skills. + - capability_pattern: "Generates realistic images from text prompts." + plugin_preferences: + "DALL-E": 1.0 + "Stable Diffusion": 0.9 + - capability_pattern: "Translates text between multiple languages." + plugin_preferences: + "Google Translate": 1.0 + "DeepL Translator": 0.95 + - capability_pattern: "Executes code and analyzes data." + plugin_preferences: + "Code Interpreter": 1.0 + "Wolfram Alpha": 0.8 + +# Rules for handling user preferences. +user_preferences: + # Default user preferences (can be overridden by user-specific settings). + defaults: + priority: "accuracy" # Default priority: "speed", "accuracy", "cost" + preferred_plugins: [] # List of plugins the user prefers (e.g., ["DALL-E", "Google Translate"]) + excluded_plugins: [] # List of plugins the user wants to avoid (e.g., ["Expensive Plugin"]) + + # Example: User-specific preferences (loaded from a user profile, for example). + user_id_123: + priority: "speed" + preferred_plugins: ["Google Translate"] + excluded_plugins: ["REPLACE_ME_EXPENSIVE_PLUGIN"] + +# Fallback plugin to use if no other plugin matches the criteria. +fallback_plugin: "Web Search" + +# Advanced configuration (for expert users only). +advanced: + # Weighting factors for combining different rule types. + keyword_weight: 0.6 + capability_weight: 0.4 + user_preference_weight: 0.2 + + # Threshold for considering a plugin "suitable" after applying all rules. + suitability_threshold: 0.7 + + # Plugin specific configurations (example). + plugin_configurations: + "DALL-E": + api_key: "REPLACE_ME_DALL_E_API_KEY" + image_size: "1024x1024" + "Google Translate": + target_language: "en" # Default target language \ No newline at end of file diff --git a/skills/pi-pathfinder/assets/skill_adaptation_template.py b/skills/pi-pathfinder/assets/skill_adaptation_template.py new file mode 100644 index 0000000..235daa5 --- /dev/null +++ b/skills/pi-pathfinder/assets/skill_adaptation_template.py @@ -0,0 +1,141 @@ +#!/usr/bin/env python3 + +""" +Template for adapting skills from one plugin to another. + +This module provides a template for adapting skills from a source plugin +to a target plugin. It includes placeholders for input parameters, +output variables, and adaptation logic. + +""" + +import logging + +# Configure logging +logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') + + +def adapt_skill(source_plugin_skills, target_plugin_requirements, user_query): + """ + Adapt skills from the source plugin to meet the target plugin's requirements. + + Args: + source_plugin_skills (dict): A dictionary representing the skills + provided by the source plugin. + target_plugin_requirements (dict): A dictionary representing the + requirements of the target plugin. + user_query (str): The original user query. + + Returns: + dict: A dictionary containing the adapted input parameters for the + target plugin. Returns None if adaptation is not possible. + + Raises: + TypeError: If input types are incorrect. + ValueError: If input values are invalid. + Exception: For any other unexpected error during adaptation. + """ + + try: + if not isinstance(source_plugin_skills, dict): + raise TypeError("source_plugin_skills must be a dictionary.") + if not isinstance(target_plugin_requirements, dict): + raise TypeError("target_plugin_requirements must be a dictionary.") + if not isinstance(user_query, str): + raise TypeError("user_query must be a string.") + + # Example adaptation logic (replace with your actual adaptation) + adapted_input = {} + + # Check if the target plugin requires a 'text' input and adapt from user query + if "text" in target_plugin_requirements: + adapted_input["text"] = user_query + + # Check if the source plugin can provide a 'summary' and the target plugin requires it + if "summary" in target_plugin_requirements and "summarize" in source_plugin_skills: + # Assuming source_plugin_skills["summarize"] is a function that returns a summary + # This is a placeholder, replace with actual logic using the source plugin's skills + try: + # Placeholder: Replace with actual call to source plugin's skill + # summary = source_plugin_skills["summarize"](user_query) + summary = "This is a placeholder summary." # Simulate a summary + adapted_input["summary"] = summary + except Exception as e: + logging.error(f"Error summarizing using source plugin: {e}") + return None # Adaptation failed + + # Check if adaptation logic was successful + if not adapted_input: + logging.warning("No adaptation logic applied. Adaptation may not be effective.") + + return adapted_input + + except TypeError as e: + logging.error(f"Type error during skill adaptation: {e}") + raise + except ValueError as e: + logging.error(f"Value error during skill adaptation: {e}") + raise + except Exception as e: + logging.exception("Unexpected error during skill adaptation.") + raise + + +def post_process_output(target_plugin_output): + """ + Post-processes the output from the target plugin. + + Args: + target_plugin_output (any): The raw output from the target plugin. + + Returns: + str: A human-readable string representing the processed output. + + Raises: + TypeError: If input type is incorrect. + Exception: For any other error during post-processing. + """ + try: + if target_plugin_output is None: + return "No output from target plugin." + + # Simple example: Convert to string + processed_output = str(target_plugin_output) + + return processed_output + + except TypeError as e: + logging.error(f"Type error during output post-processing: {e}") + raise + except Exception as e: + logging.exception("Unexpected error during output post-processing.") + raise + + +if __name__ == "__main__": + # Example Usage + source_plugin_skills = { + "summarize": lambda x: f"Summary of: {x}" # Placeholder summarize function + } + target_plugin_requirements = { + "text": "string", + "summary": "string" + } + user_query = "This is a long document that needs to be summarized." + + try: + adapted_input = adapt_skill(source_plugin_skills, target_plugin_requirements, user_query) + + if adapted_input: + print("Adapted Input:", adapted_input) + + # Simulate target plugin output + target_plugin_output = f"Target plugin processed: {adapted_input}" + + processed_output = post_process_output(target_plugin_output) + print("Processed Output:", processed_output) + else: + print("Skill adaptation failed.") + + except Exception as e: + print(f"An error occurred: {e}") \ No newline at end of file diff --git a/skills/pi-pathfinder/references/README.md b/skills/pi-pathfinder/references/README.md new file mode 100644 index 0000000..a245ca4 --- /dev/null +++ b/skills/pi-pathfinder/references/README.md @@ -0,0 +1,7 @@ +# References + +Bundled resources for pi-pathfinder skill + +- [ ] plugin_analysis_schema.md: Defines the schema for the plugin analysis output, including fields for name, description, capabilities, and examples. +- [ ] skill_adaptation_strategies.md: Details various strategies for adapting skills from one plugin to another, such as parameter mapping, input transformation, and output aggregation. +- [ ] plugin_selection_criteria.md: Outlines the criteria used to select the best plugin for a given task, including relevance, reliability, and performance. diff --git a/skills/pi-pathfinder/scripts/README.md b/skills/pi-pathfinder/scripts/README.md new file mode 100644 index 0000000..bf04143 --- /dev/null +++ b/skills/pi-pathfinder/scripts/README.md @@ -0,0 +1,7 @@ +# Scripts + +Bundled resources for pi-pathfinder skill + +- [ ] plugin_analyzer.py: Analyzes a given plugin directory, extracts skill descriptions, and returns a structured summary. +- [ ] skill_adapter.py: Adapts the extracted skills from other plugins to the current task based on the user's request. +- [ ] plugin_search.py: Searches the installed plugins for relevant keywords and returns a list of potential plugins to use.