@praveencs/agent 0.9.30 → 0.10.0

package/agent-skills/plugins/github/tools/github.js

@@ -0,0 +1,133 @@
+/**
+ * The GitHub automation tool.
+ * Provides a universal interface to the GitHub API using native Node.js fetch.
+ */
+export async function execute(params) {
+    const { action, ...args } = params;
+    const token = process.env.GITHUB_TOKEN;
+
+    if (!token) {
+        throw new Error('GITHUB_TOKEN environment variable is not set. Please export it to use the github tool.');
+    }
+
+    const headers = {
+        'Accept': 'application/vnd.github+json',
+        'Authorization': `Bearer ${token}`,
+        'X-GitHub-Api-Version': '2022-11-28',
+        'User-Agent': 'praveencs-agent-runtime'
+    };
+
+    /** Utility to make fetch requests */
+    async function ghFetch(method, endpoint, body = null) {
+        const url = endpoint.startsWith('http') ? endpoint : `https://api.github.com${endpoint}`;
+        const options = { method, headers };
+        if (body) {
+            options.body = JSON.stringify(body);
+        }
+
+        const res = await fetch(url, options);
+        if (res.status === 204) return { success: true };
+
+        let data;
+        try {
+            data = await res.json();
+        } catch {
+            data = await res.text();
+        }
+
+        if (!res.ok) {
+            throw new Error(`GitHub API Error (${res.status}): ${JSON.stringify(data)}`);
+        }
+        return data;
+    }
+
+    try {
+        switch (action) {
+            // --- REPOSITORY MANAGEMENT ---
+            case 'create_repo':
+                return await ghFetch('POST', '/user/repos', args);
+            case 'fork_repo':
+                return await ghFetch('POST', `/repos/${args.owner}/${args.repo}/forks`, args);
+            case 'delete_repo':
+                return await ghFetch('DELETE', `/repos/${args.owner}/${args.repo}`);
+            case 'list_repos':
+                return await ghFetch('GET', `/user/repos?sort=updated&per_page=${args.per_page || 30}`);
+
+            // --- ISSUES & PULL REQUESTS ---
+            case 'create_issue':
+                return await ghFetch('POST', `/repos/${args.owner}/${args.repo}/issues`, {
+                    title: args.title,
+                    body: args.body,
+                    labels: args.labels || [],
+                    assignees: args.assignees || []
+                });
+            case 'create_pr':
+                return await ghFetch('POST', `/repos/${args.owner}/${args.repo}/pulls`, {
+                    title: args.title,
+                    head: args.head, // The branch where changes are implemented
+                    base: args.base, // The branch you want your changes pulled into
+                    body: args.body
+                });
+
+            // --- ADVANCED SEARCH ---
+            case 'search_code':
+                // args.query should be a fully formed GitHub code search string e.g. "addClass repo:jquery/jquery"
+                return await ghFetch('GET', `/search/code?q=${encodeURIComponent(args.query)}`);
+            case 'search_repos':
+                return await ghFetch('GET', `/search/repositories?q=${encodeURIComponent(args.query)}&sort=stars&order=desc`);
+
+            // --- CI/CD WORKFLOWS & ACTIONS ---
+            case 'list_workflows':
+                return await ghFetch('GET', `/repos/${args.owner}/${args.repo}/actions/workflows`);
+            case 'dispatch_workflow':
+                // args.workflow_id can be the ID or the filename (e.g., 'main.yml')
+                return await ghFetch('POST', `/repos/${args.owner}/${args.repo}/actions/workflows/${args.workflow_id}/dispatches`, {
+                    ref: args.ref || 'main', // Branch or tag
+                    inputs: args.inputs || {}
+                });
+            case 'list_workflow_runs':
+                return await ghFetch('GET', `/repos/${args.owner}/${args.repo}/actions/runs?per_page=${args.per_page || 10}`);
+
+            default:
+                throw new Error(`Unknown action: ${action}`);
+        }
+    } catch (err) {
+        return {
+            error: err.message,
+            stack: err.stack
+        };
+    }
+}
+
+export const definition = {
+    name: 'github',
+    description: 'Interact with the GitHub API to manage repositories, search code, trigger workflows, and manage issues/PRs. Requires GITHUB_TOKEN environment variable.',
+    parameters: {
+        type: 'object',
+        required: ['action'],
+        properties: {
+            action: {
+                type: 'string',
+                description: 'The GitHub operation to perform',
+                enum: [
+                    'create_repo', 'fork_repo', 'delete_repo', 'list_repos',
+                    'create_issue', 'create_pr',
+                    'search_code', 'search_repos',
+                    'list_workflows', 'dispatch_workflow', 'list_workflow_runs'
+                ]
+            },
+            owner: { type: 'string', description: 'Repository owner (username or org)' },
+            repo: { type: 'string', description: 'Repository name' },
+            title: { type: 'string', description: 'Title for issue or PR or repository name' },
+            body: { type: 'string', description: 'Description body for issue or PR' },
+            head: { type: 'string', description: 'Branch containing your changes (for PRs)' },
+            base: { type: 'string', description: 'Target branch to pull into (for PRs)' },
+            query: { type: 'string', description: 'Advanced search query string (e.g., "my-func repo:org/repo in:file")' },
+            workflow_id: { type: 'string', description: 'The ID or filename of the workflow (e.g., "build.yml")' },
+            ref: { type: 'string', description: 'Git branch or tag to run the workflow against' },
+            inputs: { type: 'object', description: 'Inputs to pass to the workflow dispatch' },
+            labels: { type: 'array', items: { type: 'string' }, description: 'Labels for issues' },
+            assignees: { type: 'array', items: { type: 'string' }, description: 'Assignees for issues' }
+        }
+    }
+};

package/agent-skills/plugins/huggingface/plugin.json

@@ -0,0 +1,22 @@
+{
+    "name": "huggingface",
+    "version": "1.0.0",
+    "description": "Run inference on any Hugging Face model and search the model hub.",
+    "author": "Praveen",
+    "category": "AI & Specialized",
+    "tags": [
+        "huggingface",
+        "ml",
+        "ai",
+        "inference",
+        "models"
+    ],
+    "exports": {
+        "tools": [
+            "tools/huggingface.js"
+        ],
+        "skills": [
+            "skills/huggingface-manager.md"
+        ]
+    }
+}

package/agent-skills/plugins/huggingface/skills/huggingface-manager.md

@@ -0,0 +1,16 @@
+# Hugging Face Manager
+
+## Description
+This skill enables you to run ML inference on any Hugging Face model and search the model hub.
+
+## Instructions
+1. For text generation, use `action: "text_generation"` with `prompt` and an optional `model` (defaults to Mistral-7B).
+2. For summarization, use `action: "summarization"` with `text` (defaults to BART-large-CNN).
+3. For sentiment analysis, use `action: "sentiment"` with `text`. Returns labels (POSITIVE/NEGATIVE) and scores.
+4. For translation, use `action: "translation"` with `text`. Default model is EN→FR. Change `model` for other language pairs (e.g., `Helsinki-NLP/opus-mt-en-de` for EN→DE).
+5. Use `action: "search_models"` with `query` to find models on the hub. Results are sorted by downloads.
+6. The Inference API may return a "model loading" status for cold models. Retry after a few seconds.
+7. Requires `HF_TOKEN` from https://huggingface.co/settings/tokens.
+
+## Input Variables
+{{input}}

package/agent-skills/plugins/huggingface/tools/huggingface.js

@@ -0,0 +1,149 @@
+/**
+ * Hugging Face automation tool.
+ * Provides model inference and hub search via the Hugging Face API.
+ */
+export async function execute(params) {
+    const { action, ...args } = params;
+    const token = process.env.HF_TOKEN;
+
+    if (!token) {
+        throw new Error('HF_TOKEN environment variable is not set. Get one at https://huggingface.co/settings/tokens');
+    }
+
+    const headers = {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${token}`
+    };
+
+    try {
+        switch (action) {
+            case 'inference': {
+                const model = args.model || 'meta-llama/Llama-2-7b-chat-hf';
+                const res = await fetch(`https://api-inference.huggingface.co/models/${model}`, {
+                    method: 'POST',
+                    headers,
+                    body: JSON.stringify({ inputs: args.inputs, parameters: args.parameters || {} })
+                });
+                if (!res.ok) {
+                    const err = await res.json();
+                    throw new Error(`HF Inference Error: ${err.error || JSON.stringify(err)}`);
+                }
+                const contentType = res.headers.get('content-type') || '';
+                if (contentType.includes('json')) return await res.json();
+                return { output: 'Binary response (image/audio)', bytes: (await res.arrayBuffer()).byteLength };
+            }
+
+            case 'text_generation': {
+                const model = args.model || 'mistralai/Mistral-7B-Instruct-v0.2';
+                const res = await fetch(`https://api-inference.huggingface.co/models/${model}`, {
+                    method: 'POST',
+                    headers,
+                    body: JSON.stringify({
+                        inputs: args.prompt,
+                        parameters: {
+                            max_new_tokens: args.max_tokens || 256,
+                            temperature: args.temperature ?? 0.7,
+                            return_full_text: false
+                        }
+                    })
+                });
+                return await res.json();
+            }
+
+            case 'summarization': {
+                const model = args.model || 'facebook/bart-large-cnn';
+                const res = await fetch(`https://api-inference.huggingface.co/models/${model}`, {
+                    method: 'POST',
+                    headers,
+                    body: JSON.stringify({ inputs: args.text })
+                });
+                return await res.json();
+            }
+
+            case 'sentiment': {
+                const model = args.model || 'distilbert-base-uncased-finetuned-sst-2-english';
+                const res = await fetch(`https://api-inference.huggingface.co/models/${model}`, {
+                    method: 'POST',
+                    headers,
+                    body: JSON.stringify({ inputs: args.text })
+                });
+                return await res.json();
+            }
+
+            case 'translation': {
+                const model = args.model || 'Helsinki-NLP/opus-mt-en-fr';
+                const res = await fetch(`https://api-inference.huggingface.co/models/${model}`, {
+                    method: 'POST',
+                    headers,
+                    body: JSON.stringify({ inputs: args.text })
+                });
+                return await res.json();
+            }
+
+            case 'image_classification': {
+                const model = args.model || 'google/vit-base-patch16-224';
+                const res = await fetch(`https://api-inference.huggingface.co/models/${model}`, {
+                    method: 'POST',
+                    headers: { 'Authorization': `Bearer ${token}` },
+                    body: args.image_url
+                        ? JSON.stringify({ inputs: args.image_url })
+                        : args.image_data
+                });
+                return await res.json();
+            }
+
+            case 'search_models': {
+                const query = args.query || '';
+                const res = await fetch(
+                    `https://huggingface.co/api/models?search=${encodeURIComponent(query)}&limit=${args.limit || 10}&sort=downloads&direction=-1`,
+                    { headers: { 'Authorization': `Bearer ${token}` } }
+                );
+                const models = await res.json();
+                return models.map(m => ({
+                    id: m.modelId || m.id,
+                    pipeline: m.pipeline_tag,
+                    downloads: m.downloads,
+                    likes: m.likes,
+                    lastModified: m.lastModified
+                }));
+            }
+
+            case 'model_info': {
+                const res = await fetch(`https://huggingface.co/api/models/${args.model}`, {
+                    headers: { 'Authorization': `Bearer ${token}` }
+                });
+                return await res.json();
+            }
+
+            default:
+                throw new Error(`Unknown action: ${action}`);
+        }
+    } catch (err) {
+        return { error: err.message, stack: err.stack };
+    }
+}
+
+export const definition = {
+    name: 'huggingface',
+    description: 'Run ML inference (text gen, summarization, sentiment, translation, image classification) and search Hugging Face models. Requires HF_TOKEN.',
+    parameters: {
+        type: 'object',
+        required: ['action'],
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['inference', 'text_generation', 'summarization', 'sentiment', 'translation', 'image_classification', 'search_models', 'model_info']
+            },
+            model: { type: 'string', description: 'Hugging Face model ID (e.g., meta-llama/Llama-2-7b-chat-hf)' },
+            inputs: { type: 'string', description: 'Raw input for generic inference' },
+            prompt: { type: 'string', description: 'Text prompt for generation' },
+            text: { type: 'string', description: 'Text input for summarization/sentiment/translation' },
+            image_url: { type: 'string', description: 'Image URL for classification' },
+            parameters: { type: 'object', description: 'Model parameters' },
+            max_tokens: { type: 'number', description: 'Max tokens for text generation' },
+            temperature: { type: 'number', description: 'Temperature for generation' },
+            query: { type: 'string', description: 'Search query for model hub' },
+            limit: { type: 'number', description: 'Max results' }
+        }
+    }
+};

package/agent-skills/plugins/linear/plugin.json

@@ -0,0 +1,22 @@
+{
+    "name": "linear",
+    "version": "1.0.0",
+    "description": "Manage issues, projects, and cycles on Linear for modern project management.",
+    "author": "Praveen",
+    "category": "Productivity",
+    "tags": [
+        "linear",
+        "issues",
+        "projects",
+        "agile",
+        "tracking"
+    ],
+    "exports": {
+        "tools": [
+            "tools/linear.js"
+        ],
+        "skills": [
+            "skills/linear-manager.md"
+        ]
+    }
+}

package/agent-skills/plugins/linear/skills/linear-manager.md

@@ -0,0 +1,16 @@
+# Linear Manager
+
+## Description
+This skill enables you to manage issues, projects, teams, and cycles on Linear.
+
+## Instructions
+1. Linear uses a **GraphQL API**. All queries go through a single endpoint.
+2. To create an issue, you need a `team_id`. Use `action: "list_teams"` first to discover team IDs.
+3. Issue priority is numeric: `0` = none, `1` = urgent, `2` = high, `3` = medium, `4` = low.
+4. To search across all issues, use `action: "search_issues"` with a text `query`. It searches titles and descriptions.
+5. To filter issues precisely, use `action: "list_issues"` with a `filter` object (e.g., `{ "state": { "name": { "eq": "In Progress" } } }`).
+6. Linear issue identifiers look like `ENG-42` (team key + number). The `identifier` field in responses contains this.
+7. If the tool returns an error, the user needs to export `LINEAR_API_KEY` from https://linear.app/settings/api.
+
+## Input Variables
+{{input}}

package/agent-skills/plugins/linear/tools/linear.js

@@ -0,0 +1,199 @@
+/**
+ * Linear automation tool.
+ * Provides issue, project, and cycle management via the Linear GraphQL API.
+ */
+export async function execute(params) {
+    const { action, ...args } = params;
+    const apiKey = process.env.LINEAR_API_KEY;
+
+    if (!apiKey) {
+        throw new Error('LINEAR_API_KEY environment variable is not set. Create one at https://linear.app/settings/api');
+    }
+
+    async function linearQuery(query, variables = {}) {
+        const res = await fetch('https://api.linear.app/graphql', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': apiKey
+            },
+            body: JSON.stringify({ query, variables })
+        });
+
+        const data = await res.json();
+        if (data.errors) {
+            throw new Error(`Linear API Error: ${data.errors.map(e => e.message).join(', ')}`);
+        }
+        return data.data;
+    }
+
+    try {
+        switch (action) {
+            // --- ISSUES ---
+            case 'create_issue':
+                return await linearQuery(`
+                    mutation CreateIssue($input: IssueCreateInput!) {
+                        issueCreate(input: $input) {
+                            success
+                            issue { id identifier title url state { name } }
+                        }
+                    }
+                `, {
+                    input: {
+                        title: args.title,
+                        description: args.description,
+                        teamId: args.team_id,
+                        priority: args.priority,          // 0=none, 1=urgent, 2=high, 3=medium, 4=low
+                        assigneeId: args.assignee_id,
+                        labelIds: args.label_ids
+                    }
+                });
+
+            case 'update_issue':
+                return await linearQuery(`
+                    mutation UpdateIssue($id: String!, $input: IssueUpdateInput!) {
+                        issueUpdate(id: $id, input: $input) {
+                            success
+                            issue { id identifier title state { name } }
+                        }
+                    }
+                `, {
+                    id: args.issue_id,
+                    input: args.data || {}
+                });
+
+            case 'list_issues':
+                return await linearQuery(`
+                    query Issues($filter: IssueFilter, $first: Int) {
+                        issues(filter: $filter, first: $first) {
+                            nodes {
+                                id identifier title description priority
+                                state { name }
+                                assignee { name email }
+                                labels { nodes { name } }
+                                url createdAt updatedAt
+                            }
+                        }
+                    }
+                `, {
+                    filter: args.filter || {},
+                    first: args.limit || 25
+                });
+
+            case 'search_issues':
+                return await linearQuery(`
+                    query SearchIssues($term: String!, $first: Int) {
+                        searchIssues(term: $term, first: $first) {
+                            nodes {
+                                id identifier title description
+                                state { name }
+                                assignee { name }
+                                url
+                            }
+                        }
+                    }
+                `, { term: args.query, first: args.limit || 20 });
+
+            // --- PROJECTS ---
+            case 'list_projects':
+                return await linearQuery(`
+                    query Projects($first: Int) {
+                        projects(first: $first) {
+                            nodes {
+                                id name description state progress
+                                lead { name }
+                                url startDate targetDate
+                            }
+                        }
+                    }
+                `, { first: args.limit || 20 });
+
+            case 'create_project':
+                return await linearQuery(`
+                    mutation CreateProject($input: ProjectCreateInput!) {
+                        projectCreate(input: $input) {
+                            success
+                            project { id name url }
+                        }
+                    }
+                `, {
+                    input: {
+                        name: args.name,
+                        description: args.description,
+                        teamIds: args.team_ids
+                    }
+                });
+
+            // --- TEAMS ---
+            case 'list_teams':
+                return await linearQuery(`
+                    query Teams {
+                        teams {
+                            nodes { id name key description }
+                        }
+                    }
+                `);
+
+            // --- CYCLES ---
+            case 'list_cycles':
+                return await linearQuery(`
+                    query Cycles($teamId: String!, $first: Int) {
+                        team(id: $teamId) {
+                            cycles(first: $first) {
+                                nodes {
+                                    id number name startsAt endsAt
+                                    progress completedIssueCountHistory
+                                }
+                            }
+                        }
+                    }
+                `, { teamId: args.team_id, first: args.limit || 10 });
+
+            // --- VIEWER ---
+            case 'me':
+                return await linearQuery(`
+                    query Me {
+                        viewer { id name email admin url }
+                    }
+                `);
+
+            default:
+                throw new Error(`Unknown action: ${action}`);
+        }
+    } catch (err) {
+        return { error: err.message, stack: err.stack };
+    }
+}
+
+export const definition = {
+    name: 'linear',
+    description: 'Manage Linear issues, projects, teams, and cycles for modern project tracking. Requires LINEAR_API_KEY.',
+    parameters: {
+        type: 'object',
+        required: ['action'],
+        properties: {
+            action: {
+                type: 'string',
+                description: 'The Linear operation to perform',
+                enum: [
+                    'create_issue', 'update_issue', 'list_issues', 'search_issues',
+                    'list_projects', 'create_project',
+                    'list_teams', 'list_cycles', 'me'
+                ]
+            },
+            title: { type: 'string', description: 'Issue or project title' },
+            description: { type: 'string', description: 'Issue or project description (supports markdown)' },
+            team_id: { type: 'string', description: 'Linear team ID' },
+            team_ids: { type: 'array', items: { type: 'string' }, description: 'Team IDs for project creation' },
+            issue_id: { type: 'string', description: 'Issue ID for updates' },
+            assignee_id: { type: 'string', description: 'User ID to assign the issue to' },
+            priority: { type: 'number', description: 'Priority: 0=none, 1=urgent, 2=high, 3=medium, 4=low' },
+            label_ids: { type: 'array', items: { type: 'string' }, description: 'Label IDs to apply' },
+            data: { type: 'object', description: 'Update data for issues (IssueUpdateInput)' },
+            filter: { type: 'object', description: 'Issue filter object (IssueFilter)' },
+            query: { type: 'string', description: 'Search query text' },
+            name: { type: 'string', description: 'Project name' },
+            limit: { type: 'number', description: 'Max results to return' }
+        }
+    }
+};

package/agent-skills/plugins/mongodb/plugin.json

@@ -0,0 +1,21 @@
+{
+    "name": "mongodb",
+    "version": "1.0.0",
+    "description": "Query, insert, update, and aggregate data on MongoDB Atlas or local instances.",
+    "author": "Praveen",
+    "category": "Databases & Backend",
+    "tags": [
+        "mongodb",
+        "nosql",
+        "database",
+        "atlas"
+    ],
+    "exports": {
+        "tools": [
+            "tools/mongodb.js"
+        ],
+        "skills": [
+            "skills/mongodb-manager.md"
+        ]
+    }
+}

package/agent-skills/plugins/mongodb/skills/mongodb-manager.md

@@ -0,0 +1,14 @@
+# MongoDB Manager
+
+## Description
+This skill enables you to query, insert, update, and aggregate data on MongoDB via the Atlas Data API.
+
+## Instructions
+1. Always provide `collection` for every action. `database` defaults to `MONGODB_DATABASE` env var.
+2. `filter` uses standard MongoDB query syntax: `{"age": {"$gt": 18}}`, `{"status": "active"}`.
+3. `update` uses MongoDB operators: `{"$set": {"name": "new"}}`, `{"$inc": {"count": 1}}`.
+4. For complex analytics, use `action: "aggregate"` with a `pipeline` array of stages (`$match`, `$group`, `$sort`, `$project`, etc.).
+5. Requires `MONGODB_API_KEY` and `MONGODB_APP_ID`. Enable the Data API in MongoDB Atlas under App Services.
+
+## Input Variables
+{{input}}