ai-custom-skills 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ravi Patel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,47 @@
+# AI Skill Collection
+
+A professional collection of AI skills for enhanced agentic capabilities. Each skill is designed to be easily discoverable and usable by any AI assistant or agent that supports the skill format.
+
+## Installation
+
+```bash
+npm install ai-custom-skills
+```
+
+## CLI Usage
+
+After installation, you can use the `custom-skills` command to interact with your collection:
+
+### List all skills
+
+```bash
+npx custom-skills --list
+```
+
+### Get detailed information for a skill
+
+```bash
+npx custom-skills --info=default-skill
+```
+
+## Project Structure
+
+This project follows the manifest-driven architecture used by professional AI skill stores:
+
+- **`skills.json`**: The central manifest file for skill discovery.
+- **`index.js`**: Lightweight CLI for skill management.
+- **`skills/`**: Root directory for all individual skill folders.
+  - **`<skill-name>/`**:
+    - **`SKILL.md`**: Core instructions for the AI agent for this specific skill.
+    - **`scripts/`**: Executable scripts specific to this skill.
+    - **`examples/`**: Usage guides and reference implementations.
+
+## Adding a New Skill
+
+1. Create a new folder under `skills/` with a unique name.
+2. Add a `SKILL.md` file following the standard template.
+3. Update `skills.json` with your new skill's details.
+
+## License
+
+MIT

package/index.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const pkgPath = path.join(__dirname, 'package.json');
+const manifestPath = path.join(__dirname, 'skills.json');
+
+const c = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  cyan: "\x1b[36m",
+  green: "\x1b[32m",
+  dim: "\x1b[2m",
+};
+
+const col = (color, text) => `${c[color]}${text}${c.reset}`;
+
+function showHelp() {
+  console.log(`
+${col("bold", col("cyan", "🤖  custom-skills"))} — Manage your AI skill collection
+
+${col("bold", "USAGE")}
+  npx custom-skills [options]
+
+${col("bold", "OPTIONS")}
+  ${col("green", "--list")}          List all available skills
+  ${col("green", "--info=<name>")}   Show details and path for a specific skill
+  ${col("green", "--help")}          Show this help message
+`);
+}
+
+function listSkills() {
+  if (!fs.existsSync(manifestPath)) {
+    console.error("Error: skills.json manifest not found.");
+    process.exit(1);
+  }
+
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+  console.log(`\n${col("bold", "Available Skills:")}\n`);
+  
+  manifest.skills.forEach(skill => {
+    console.log(`  ${col("cyan", "◆")} ${col("bold", skill.name.padEnd(20))} ${col("dim", skill.description)}`);
+  });
+  console.log("");
+}
+
+function showSkillInfo(name) {
+  if (!fs.existsSync(manifestPath)) {
+    console.error("Error: skills.json manifest not found.");
+    process.exit(1);
+  }
+
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+  const skill = manifest.skills.find(s => s.name === name);
+
+  if (!skill) {
+    console.error(`Error: Skill "${name}" not found.`);
+    process.exit(1);
+  }
+
+  const skillDir = path.join(__dirname, 'skills', skill.name);
+  const skillFile = path.join(skillDir, 'SKILL.md');
+
+  console.log(`\n${col("bold", "Skill Information:")}`);
+  console.log(`  ${col("cyan", "Name:")}        ${skill.name}`);
+  console.log(`  ${col("cyan", "Description:")} ${skill.description}`);
+  console.log(`  ${col("cyan", "Category:")}    ${skill.category}`);
+  console.log(`  ${col("cyan", "Path:")}        ${skillFile}`);
+  console.log("");
+}
+
+const args = process.argv.slice(2);
+const listArg = args.includes('--list');
+const helpArg = args.includes('--help');
+const infoArg = args.find(a => a.startsWith('--info='));
+
+if (helpArg || args.length === 0) {
+  showHelp();
+} else if (listArg) {
+  listSkills();
+} else if (infoArg) {
+  const name = infoArg.split('=')[1];
+  showSkillInfo(name);
+} else {
+  showHelp();
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "ai-custom-skills",
+  "version": "1.0.0",
+  "description": "A collection of AI skills for enhanced agentic capabilities.",
+  "main": "index.js",
+  "bin": {
+    "custom-skills": "./index.js"
+  },
+  "keywords": [
+    "ai",
+    "skills",
+    "prompt-collection",
+    "agentic-coding"
+  ],
+  "author": "Ravi Patel",
+  "license": "MIT",
+  "files": [
+    "index.js",
+    "skills.json",
+    "skills/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ravipatel10/ai-custom-skills.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ravipatel10/ai-custom-skills/issues"
+  },
+  "homepage": "https://github.com/ravipatel10/ai-custom-skills#readme"
+}

package/skills/agent-workflow-creator/README.md

@@ -0,0 +1,103 @@
+# agent-workflow-creator
+
+A comprehensive skill for designing, generating, and documenting complete agent workflows for any task or domain.
+
+## What This Skill Does
+
+Given any task description, this skill produces:
+
+- **Plain-English Workflow Summary** — what it does, inputs, outputs
+- **Step-by-Step Table** — every step with tool, input, output, and failure path
+- **Mermaid Flowchart** — visual diagram of the workflow
+- **Agent Roles Card** — who does what in multi-agent systems
+- **Tool Manifest** — every tool and credential required
+- **Error Handling Plan** — every failure class with recovery strategy
+- **YAML Workflow Definition** — machine-readable spec for any agent framework
+- **Execution Checklist** — pre-flight checks before running
+
+## Directory Structure
+
+```
+agent-workflow-creator/
+├── SKILL.md                          # Main skill instructions
+├── evals/
+│   └── evals.json                    # Test cases for the skill
+├── references/
+│   ├── step-schema.md                # Full step schema reference
+│   ├── yaml-schema.md                # Full YAML workflow schema
+│   ├── patterns.md                   # 9 workflow patterns with diagrams + YAML
+│   ├── domains/
+│   │   ├── research.md               # Research & knowledge domain guidance
+│   │   ├── data-pipeline.md          # Data processing & ETL guidance
+│   │   └── content.md                # Content creation domain guidance
+│   └── examples/
+│       ├── research-report-workflow.yaml
+│       └── customer-support-triage.yaml
+└── scripts/
+    ├── generate_workflow.py          # Scaffold a YAML workflow from task description
+    ├── validate_workflow.py          # Validate a YAML workflow against the schema
+    ├── render_mermaid.py             # Convert YAML workflow to Mermaid diagram
+    └── export_workflow.py            # Export workflow to multiple formats
+```
+
+## Scripts Quick Reference
+
+### Generate a workflow
+
+```bash
+python scripts/generate_workflow.py \
+  --task "monitor social media and alert on negative mentions" \
+  --type single-agent \
+  --pattern react \
+  --domain research \
+  --output my_workflow.yaml \
+  --verbose
+```
+
+### Validate a workflow
+
+```bash
+python scripts/validate_workflow.py --file my_workflow.yaml --report
+```
+
+### Render a Mermaid diagram
+
+```bash
+# Output to Markdown (paste into any Mermaid viewer)
+python scripts/render_mermaid.py --file my_workflow.yaml
+
+# Output to standalone HTML
+python scripts/render_mermaid.py --file my_workflow.yaml --html --output diagram.html
+```
+
+### Export to all formats
+
+```bash
+python scripts/export_workflow.py \
+  --file my_workflow.yaml \
+  --formats yaml,json,markdown,html,mermaid \
+  --output-dir ./exports
+```
+
+## Supported Workflow Patterns
+
+| Pattern           | Best For                             |
+| ----------------- | ------------------------------------ |
+| Sequential Chain  | Linear step-by-step tasks            |
+| Map-Reduce        | Batch processing many items          |
+| Fan-Out / Fan-In  | Parallel independent branches        |
+| ReAct Loop        | Open-ended autonomous research       |
+| Critic-Refine     | Quality-sensitive content generation |
+| Human-in-the-Loop | Approval workflows                   |
+| RAG               | Knowledge-base powered responses     |
+| Supervisor-Worker | Complex multi-specialist tasks       |
+| Event-Driven      | Webhook/trigger-based automation     |
+
+## Requirements
+
+- Python 3.8+
+- `pyyaml` (for JSON export and YAML loading): `pip install pyyaml`
+
+## Installation as Skill
+
+Place this directory in your ai's skills folder. The ai will automatically detect and use it when you ask for workflow design, agent architecture, or automation planning help.

package/skills/agent-workflow-creator/SKILL.md

@@ -0,0 +1,271 @@
+---
+name: agent-workflow-creator
+description: >
+  Use this skill to design, generate, document, and validate complete agent workflows for any task or domain.
+  Trigger this skill whenever a user asks to: build an agent, design a workflow, automate a process, create
+  a pipeline, map out task steps for AI execution, design an LLM-powered automation, define agent roles or
+  tool sequences, create a multi-step AI process, or plan any system where AI agents coordinate to complete
+  a goal. Also trigger for: "how should my agent handle X", "what steps does an AI need for Y", "create a
+  workflow for Z", "design an automation pipeline", "agent architecture for...", or any request to structure
+  tasks so an AI can execute them reliably and efficiently. Use even if the user mentions 'flow', 'pipeline',
+  'automation', 'task plan', 'agent design', or 'AI process' — this skill covers all of those.
+---
+
+# Agent Workflow Creator
+
+A comprehensive skill for generating complete, production-ready agent workflows. Given any task, goal, or domain, this skill produces structured workflows that AI agents can execute reliably — with clear steps, decision logic, tool assignments, error handling, and output definitions.
+
+---
+
+## Core Philosophy
+
+A great agent workflow is more than a list of steps. It is:
+- **Decomposed** — every ambiguous task broken into atomic, executable actions
+- **Deterministic at the edges** — clear entry and exit conditions at every node
+- **Tool-aware** — each step names the exact tool, API, or capability needed
+- **Failure-safe** — every step has a fallback or error path defined
+- **Observable** — outputs at each step are named, typed, and passed forward explicitly
+- **Role-assigned** — in multi-agent systems, every step says WHO does it
+
+Think of yourself as both a systems architect and an AI director: you're building a machine that runs reliably without human intervention, but also a script that any capable agent can follow.
+
+---
+
+## Workflow Generation Process
+
+When the user gives you a task to turn into an agent workflow, follow this process:
+
+### Step 1 — Understand the Goal
+Before designing anything, extract:
+- **Objective**: What is the final deliverable or outcome?
+- **Inputs**: What data, files, or context does the workflow receive?
+- **Constraints**: Speed, cost, tool availability, privacy, etc.
+- **Failure tolerance**: Is this best-effort or mission-critical?
+- **Agent type**: Single agent, multi-agent, human-in-the-loop, or fully autonomous?
+
+If the user hasn't provided enough information, ask targeted questions before proceeding. Don't guess on objectives.
+
+### Step 2 — Decompose the Task
+Break the goal into a directed graph of steps:
+- Each step = one atomic action (fetch, parse, decide, transform, call API, write file, etc.)
+- Identify sequential dependencies and parallel opportunities
+- Mark decision points (branching logic) explicitly
+- Identify loops (retry, poll, iterate) vs. one-shot steps
+
+Use the **Step Schema** (see `references/step-schema.md`) for structuring each node.
+
+### Step 3 — Assign Tools and Agents
+For every step, specify:
+- **Tool**: The exact capability needed (web_search, code_execution, file_read, API call, LLM completion, etc.)
+- **Agent role** (if multi-agent): Orchestrator, Researcher, Writer, Validator, etc.
+- **Input contract**: What does this step receive?
+- **Output contract**: What does it produce and pass forward?
+
+### Step 4 — Add Control Flow
+Define:
+- **Entry condition**: When does this step start?
+- **Exit condition**: When is it done?
+- **On success**: Where does the flow go next?
+- **On failure**: Retry? Fallback step? Alert human? Abort?
+- **On ambiguity**: Does this step need a human checkpoint?
+
+### Step 5 — Generate Outputs
+Produce all of the following (see individual sections below):
+1. **Workflow Summary** — plain-English description
+2. **Step-by-Step Table** — structured table of all steps
+3. **Mermaid Flowchart** — visual diagram of the workflow
+4. **Agent Roles Card** — who does what
+5. **Tool Manifest** — all tools and capabilities required
+6. **Error Handling Plan** — what can go wrong and how it's handled
+7. **YAML Workflow Definition** — machine-readable workflow spec
+8. **Execution Checklist** — pre-flight checks before running
+
+---
+
+## Output Formats
+
+### 1. Workflow Summary
+A 3–5 sentence plain-English description:
+- What the workflow does
+- What it takes as input
+- What it produces as output
+- How long it typically takes / how many steps
+
+### 2. Step-by-Step Table
+Always output a table with these columns:
+
+| Step # | Step Name | Description | Tool / Capability | Input | Output | On Failure |
+|--------|-----------|-------------|-------------------|-------|--------|------------|
+
+Every row must be filled completely. "TBD" is not acceptable.
+
+### 3. Mermaid Flowchart
+Always generate a Mermaid diagram. Use this format:
+
+```mermaid
+flowchart TD
+    A([Start: <input>]) --> B[Step: <name>]
+    B --> C{Decision: <condition>}
+    C -->|Yes| D[Step: <name>]
+    C -->|No| E[Step: <name>]
+    D --> F([End: <output>])
+    E --> F
+```
+
+Node shape guide:
+- `([text])` — Start / End (stadium)
+- `[text]` — Action step (rectangle)
+- `{text}` — Decision point (diamond)
+- `[(text)]` — Data store / file (cylinder)
+- `((text))` — Sub-workflow / agent call (circle)
+
+Color-code by agent role when multi-agent (use `style` or `classDef`).
+
+### 4. Agent Roles Card
+For multi-agent workflows:
+
+| Role | Responsibility | Steps Owned | Tools Available |
+|------|----------------|-------------|-----------------|
+
+For single-agent workflows, describe the agent's persona, capability profile, and any sub-roles it plays.
+
+### 5. Tool Manifest
+List every tool the workflow requires:
+
+| Tool Name | Type | Steps Used In | Required Credentials / Config |
+|-----------|------|---------------|-------------------------------|
+
+Types: `web_search`, `code_execution`, `file_io`, `api_call`, `llm_completion`, `database`, `human_input`, `memory`, `vector_search`, `notification`
+
+### 6. Error Handling Plan
+For each major failure class, define:
+
+| Failure Type | Affected Steps | Detection Method | Recovery Strategy | Escalation |
+|--------------|----------------|------------------|-------------------|------------|
+
+Standard failure classes to always consider:
+- Tool unavailable / rate limited
+- Malformed / unexpected input
+- LLM hallucination or low-confidence output
+- Step timeout
+- Downstream dependency failure
+- Data quality / validation failure
+
+### 7. YAML Workflow Definition
+Always produce a machine-readable YAML spec. Read `references/yaml-schema.md` for the full schema. Abbreviated example:
+
+```yaml
+workflow:
+  name: my-workflow
+  version: "1.0"
+  description: "What this workflow does"
+  inputs:
+    - name: query
+      type: string
+      required: true
+  outputs:
+    - name: report
+      type: file
+  steps:
+    - id: step_01
+      name: Fetch Data
+      tool: web_search
+      input: "{{inputs.query}}"
+      output: raw_results
+      on_failure:
+        strategy: retry
+        max_attempts: 3
+      next: step_02
+```
+
+### 8. Execution Checklist
+Pre-flight items to verify before running the workflow:
+
+- [ ] All required tools are available and authenticated
+- [ ] Input data format matches the workflow's input schema
+- [ ] Output destinations are writable
+- [ ] Rate limits and quotas checked for all APIs used
+- [ ] Error notification channels configured
+- [ ] Logging / observability enabled
+- [ ] Test run on sample input completed
+
+---
+
+## Workflow Patterns Library
+
+When designing, identify which pattern(s) apply and apply them correctly. Read `references/patterns.md` for full pattern details with examples.
+
+**Quick Reference:**
+| Pattern | When to Use |
+|---------|-------------|
+| Sequential Chain | Steps must happen in strict order |
+| Map-Reduce | Apply same operation to many items, then aggregate |
+| Fan-Out / Fan-In | Parallel execution, then merge results |
+| ReAct Loop | Agent reasons and acts iteratively until goal met |
+| Critic-Refine | One agent produces, another critiques, repeat |
+| Human-in-the-Loop | Insert approval or input checkpoint |
+| Retrieval-Augmented | Fetch context before generating |
+| Event-Driven | Workflow triggered by external event or signal |
+| Recursive Decomposer | Break task into subtasks recursively |
+| Supervisor-Worker | Orchestrator delegates to specialist agents |
+
+---
+
+## Quality Checklist (Self-Review Before Presenting)
+
+Before outputting the workflow, verify:
+
+- [ ] Every step has a named input and named output
+- [ ] No step is ambiguous ("do research" → specify what kind, how, with what tool)
+- [ ] Every decision point has all branches labeled
+- [ ] All failure paths lead somewhere (retry, fallback, or human escalation)
+- [ ] The Mermaid diagram matches the step table exactly
+- [ ] The YAML is valid and complete
+- [ ] Tools in the manifest match tools referenced in steps
+- [ ] The workflow solves the stated objective end-to-end
+
+---
+
+## Domain-Specific Guidance
+
+For specialized domains, read the relevant reference file before designing:
+
+- **Research / knowledge workflows** → `references/domains/research.md`
+- **Data processing / ETL workflows** → `references/domains/data-pipeline.md`
+- **Content creation workflows** → `references/domains/content.md`
+- **Customer support / triage workflows** → `references/domains/support.md`
+- **Code generation / review workflows** → `references/domains/coding.md`
+- **Document processing workflows** → `references/domains/documents.md`
+
+---
+
+## Scripts
+
+Use these scripts to accelerate workflow generation:
+
+- `scripts/generate_workflow.py` — CLI tool to scaffold a YAML workflow from a task description
+- `scripts/validate_workflow.py` — Validates a YAML workflow file against the schema
+- `scripts/render_mermaid.py` — Converts a YAML workflow to a Mermaid diagram string
+- `scripts/export_workflow.py` — Exports a workflow to multiple formats (JSON, YAML, Markdown)
+
+Run any script with `--help` for full usage.
+
+---
+
+## Example Workflows
+
+For inspiration and templates, see:
+- `references/examples/research-report-workflow.yaml`
+- `references/examples/customer-support-triage.yaml`
+- `references/examples/data-etl-pipeline.yaml`
+- `references/examples/content-creation-workflow.yaml`
+
+---
+
+## Reminders
+
+- **Be specific.** "Search the web" is not a step. "Use web_search tool with query `{{user_query}}` and return top 5 results as `raw_results`" is a step.
+- **Name everything.** Every input variable, output variable, and intermediate state should have a name. Anonymous data is a bug waiting to happen.
+- **Parallel when possible.** If steps are independent, flag them as parallelizable — it matters for performance.
+- **Don't skip error handling.** A workflow without error handling is a proof of concept, not a production system.
+- **Match the user's level.** If they said "I'm new to agents", explain concepts as you go. If they said "give me the YAML", skip the hand-holding.

package/skills/agent-workflow-creator/assets/workflow-template.md

@@ -0,0 +1,135 @@
+# [Workflow Name]
+
+> **Generated by:** agent-workflow-creator  
+> **Date:** [YYYY-MM-DD]  
+> **Version:** 1.0  
+> **Pattern:** [Sequential Chain | Map-Reduce | Fan-Out/Fan-In | ReAct Loop | Critic-Refine | Human-in-the-Loop | etc.]  
+> **Agent Type:** [Single Agent | Multi-Agent | Human-in-the-Loop | Fully Autonomous]
+
+---
+
+## Workflow Summary
+
+[3–5 sentences describing what the workflow does, what it takes as input, what it produces as output, and roughly how many steps it involves.]
+
+---
+
+## Step-by-Step Table
+
+| Step # | Step Name | Description | Tool / Capability | Input | Output | On Failure |
+|--------|-----------|-------------|-------------------|-------|--------|------------|
+| 1 | | | | | | |
+| 2 | | | | | | |
+| 3 | | | | | | |
+
+---
+
+## Mermaid Flowchart
+
+```mermaid
+flowchart TD
+    A([Start: <input>]) --> B[Step 1: <name>]
+    B --> C{Decision: <condition>}
+    C -->|Yes| D[Step 2a: <name>]
+    C -->|No| E[Step 2b: <name>]
+    D --> F([End: <output>])
+    E --> F
+```
+
+---
+
+## Agent Roles
+
+| Role | Responsibility | Steps Owned | Tools Available |
+|------|----------------|-------------|-----------------|
+| | | | |
+
+*For single-agent workflows: describe the agent's persona and capability profile here.*
+
+---
+
+## Tool Manifest
+
+| Tool Name | Type | Steps Used In | Required Credentials / Config |
+|-----------|------|---------------|-------------------------------|
+| | | | |
+
+**Tool types:** `web_search`, `code_execution`, `file_io`, `api_call`, `llm_completion`, `database`, `human_input`, `memory`, `vector_search`, `notification`
+
+---
+
+## Error Handling Plan
+
+| Failure Type | Affected Steps | Detection Method | Recovery Strategy | Escalation |
+|--------------|----------------|------------------|-------------------|------------|
+| Tool unavailable / rate limited | | | | |
+| Malformed / unexpected input | | | | |
+| LLM hallucination or low-confidence output | | | | |
+| Step timeout | | | | |
+| Downstream dependency failure | | | | |
+| Data quality / validation failure | | | | |
+
+---
+
+## YAML Workflow Definition
+
+```yaml
+workflow:
+  name: my-workflow
+  version: "1.0"
+  description: ""
+  pattern: sequential-chain
+  agent_type: single-agent
+
+  inputs:
+    - name: input_name
+      type: string
+      description: ""
+      required: true
+
+  outputs:
+    - name: output_name
+      type: file
+      format: markdown
+      description: ""
+
+  steps:
+    - id: step_01
+      name: Step Name
+      description: ""
+      tool: llm_completion
+      input: {}
+      output: result_name
+      on_failure:
+        strategy: retry
+        max_attempts: 3
+      next: step_02
+
+    - id: step_02
+      name: Step Name
+      description: ""
+      tool: file_io
+      input: {}
+      output: result_name
+      on_failure:
+        strategy: abort
+      next: END
+```
+
+---
+
+## Execution Checklist
+
+- [ ] All required tools are available and authenticated
+- [ ] Input data format matches the workflow's input schema
+- [ ] Output destinations are writable
+- [ ] Rate limits and quotas checked for all APIs used
+- [ ] Error notification channels configured
+- [ ] Logging / observability enabled
+- [ ] Test run on sample input completed
+
+---
+
+## Notes & Assumptions
+
+[Any important assumptions made during design, open questions, or future enhancements to consider.]