@johpaz/hive-skills 0.1.1

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@johpaz/hive-skills",
+  "version": "0.1.1",
+  "description": "Hive Skills — Official bundled skills for Hive",
+  "main": "./src/index.ts",
+  "license": "MIT",
+  "files": [
+    "src/"
+  ],
+  "scripts": {
+    "test": "bun test"
+  },
+  "dependencies": {
+    "@johpaz/hive-core": "workspace:*",
+    "zod": "latest"
+  },
+  "devDependencies": {
+    "typescript": "latest",
+    "@types/bun": "latest"
+  }
+}

package/src/bundled/browser_automation/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: browser_automation
+description: "Control a web browser for automation tasks"
+metadata:
+  hive:
+    emoji: "🌐"
+    bins: ["chromium", "chrome"]
+    userInvocable: true
+    requires:
+      config: []
+---
+
+# Browser Automation Skill
+
+This skill enables the agent to control a web browser for automation tasks.
+
+## Capabilities
+
+- Navigate to URLs
+- Click elements
+- Fill forms
+- Extract content
+- Take screenshots
+- Handle multiple tabs
+
+## Configuration
+
+Enable in CONFIG.yaml:
+
+```yaml
+tools:
+  browser:
+    enabled: true
+    headless: true
+    timeoutSeconds: 30
+```
+
+## Usage Examples
+
+### Navigate and Extract
+
+```
+browser_navigate(url: "https://example.com")
+browser_extract(selector: ".content")
+```
+
+### Fill Form
+
+```
+browser_fill(selector: "#email", value: "user@example.com")
+browser_click(selector: "#submit")
+```
+
+## Best Practices
+
+- Use headless mode for background tasks
+- Set appropriate timeouts
+- Close browser when done
+- Handle dynamic content with waits
+
+## Limitations
+
+- Requires Chromium/Chrome installed
+- Some sites may block automation
+- Captchas cannot be bypassed

package/src/bundled/context_compact/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: context_compact
+description: "Manually trigger context compaction when conversation gets long"
+metadata:
+  hive:
+    emoji: "📦"
+    bins: []
+    userInvocable: true
+---
+
+# Context Compact Skill
+
+This skill allows manual triggering of context compaction.
+
+## Usage
+
+### Via Slash Command
+
+```
+/compact
+```
+
+### When to Use
+
+- When you notice the agent is forgetting earlier context
+- When responses become slower
+- Before starting a new major topic
+
+## How It Works
+
+1. The agent summarizes the conversation history
+2. Recent messages are preserved
+3. A summary replaces older messages
+4. Important information from memory is retained
+
+## What Gets Preserved
+
+- Last N messages (configurable)
+- Pending tool calls
+- Important facts saved to memory
+
+## Automatic Compaction
+
+The system automatically compacts when:
+- Context reaches 80% of model's limit (configurable)
+- Before critical operations
+
+Use `/compact` for manual control when needed.

package/src/bundled/cron_manager/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: cron_manager
+description: "Schedule and manage automated tasks"
+metadata:
+  hive:
+    emoji: "⏰"
+    bins: []
+    userInvocable: true
+---
+
+# Cron Manager Skill
+
+This skill enables the agent to schedule and manage automated tasks.
+
+## Available Tools
+
+- `cron_add`: Add a new scheduled task
+- `cron_list`: List all scheduled tasks
+- `cron_edit`: Edit an existing task
+- `cron_remove`: Remove a scheduled task
+
+## Usage
+
+### Add a Daily Task
+
+```
+cron_add(expression: "0 9 * * *", task: "Send daily report")
+```
+
+### List All Tasks
+
+```
+cron_list()
+```
+
+### Remove a Task
+
+```
+cron_remove(jobId: "cron-1")
+```
+
+## Cron Expression Format
+
+```
+┌───────────── minute (0 - 59)
+│ ┌───────────── hour (0 - 23)
+│ │ ┌───────────── day of month (1 - 31)
+│ │ │ ┌───────────── month (1 - 12)
+│ │ │ │ ┌───────────── day of week (0 - 6) (Sunday = 0)
+│ │ │ │ │
+* * * * *
+```
+
+### Examples
+
+- `0 9 * * *` - Every day at 9:00 AM
+- `*/15 * * * *` - Every 15 minutes
+- `0 9 * * 1` - Every Monday at 9:00 AM
+- `0 0 1 * *` - First day of every month at midnight

package/src/bundled/file_manager/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: file_manager
+description: "Read, write, and manage files in the workspace"
+metadata:
+  hive:
+    emoji: "📁"
+    bins: []
+    userInvocable: true
+---
+
+# File Manager Skill
+
+This skill enables the agent to manage files in the workspace.
+
+## Available Tools
+
+- `read`: Read file contents
+- `write`: Create or overwrite files
+- `edit`: Make targeted edits to existing files
+- `apply_patch`: Apply diff/patch format changes
+
+## Usage
+
+### Reading Files
+
+```
+read(path: "/path/to/file.txt")
+read(path: "/path/to/file.txt", offset: 10, limit: 50)
+```
+
+### Writing Files
+
+```
+write(path: "/path/to/file.txt", content: "Hello, World!")
+```
+
+### Editing Files
+
+```
+edit(path: "/path/to/file.txt", oldString: "old text", newString: "new text")
+```
+
+## Best Practices
+
+- Always read a file before editing to understand its structure
+- Use `offset` and `limit` for large files
+- Create backups before major changes

package/src/bundled/http_client/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: http_client
+description: "Make HTTP requests with custom headers and authentication"
+metadata:
+  hive:
+    emoji: "🌐"
+    bins: []
+    userInvocable: true
+---
+
+# HTTP Client Skill
+
+This skill enables the agent to make HTTP requests to external APIs and services.
+
+## Available Tools
+
+- `web_fetch`: Fetch content from URLs
+
+## Usage
+
+### Basic GET Request
+
+```
+web_fetch(url: "https://api.example.com/data")
+```
+
+### With Custom Parameters
+
+```
+web_fetch(url: "https://api.example.com/data", maxLength: 5000)
+```
+
+## Best Practices
+
+- Always handle potential errors
+- Respect rate limits
+- Use appropriate timeouts
+- Validate response data before processing

package/src/bundled/memory/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: memory
+description: "Store and retrieve persistent notes across sessions"
+metadata:
+  hive:
+    emoji: "🧠"
+    bins: []
+    userInvocable: true
+---
+
+# Memory Skill
+
+This skill enables the agent to maintain persistent memory across sessions.
+
+## Usage
+
+Use memory to store important information that should persist between conversations.
+
+## Available Operations
+
+- `memory_write`: Save a note to memory
+- `memory_read`: Retrieve a note from memory
+- `memory_list`: List all saved notes
+
+## Examples
+
+1. Save a note:
+   ```
+   memory_write(title: "User preferences", content: "Prefers brief responses, TypeScript developer")
+   ```
+
+2. Read a note:
+   ```
+   memory_read(title: "User preferences")
+   ```
+
+3. List all notes:
+   ```
+   memory_list()
+   ```
+
+## Best Practices
+
+- Use descriptive titles for easy retrieval
+- Update notes when information changes
+- Don't store sensitive information in memory

package/src/bundled/shell/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: shell
+description: "Execute shell commands safely with allowlist control"
+metadata:
+  hive:
+    emoji: "💻"
+    bins: [bash, sh]
+    userInvocable: true
+    requires:
+      config: []
+---
+
+# Shell Skill
+
+This skill enables the agent to execute shell commands.
+
+## Usage
+
+Use the `exec` tool to run shell commands. Commands are subject to allowlist/denylist restrictions.
+
+## Safety
+
+- Only commands in the allowlist can be executed
+- Commands matching denylist patterns are always blocked
+- Commands run with a configurable timeout
+
+## Parameters
+
+- `command` (required): The command to execute
+- `timeout` (optional): Timeout in seconds (default: 30)
+
+## Examples
+
+1. List files:
+   ```
+   exec(command: "ls -la")
+   ```
+
+2. Check git status:
+   ```
+   exec(command: "git status")
+   ```
+
+## Best Practices
+
+- Prefer read-only commands when possible
+- Always check command output for errors
+- Use absolute paths for reliability

package/src/bundled/system_notify/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: system_notify
+description: "Send system desktop notifications"
+metadata:
+  hive:
+    emoji: "🔔"
+    bins: []
+    userInvocable: true
+---
+
+# System Notify Skill
+
+This skill enables the agent to send desktop notifications.
+
+## Available Tools
+
+- `notify`: Send a system notification
+
+## Usage
+
+### Basic Notification
+
+```
+notify(title: "Task Complete", message: "Your file has been processed")
+```
+
+### With Urgency Level
+
+```
+notify(title: "Important", message: "Server is down", urgency: "critical")
+```
+
+## Urgency Levels
+
+- `low`: Low priority notification
+- `normal`: Standard notification (default)
+- `critical`: High priority, may stay on screen
+
+## Platform Support
+
+- **Linux**: Uses `notify-send` (libnotify)
+- **macOS**: Uses AppleScript
+- **Windows**: Not currently supported
+
+## Best Practices
+
+- Use appropriate urgency levels
+- Keep messages concise
+- Don't send too many notifications

package/src/bundled/web_search/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: web_search
+description: "Search the web for current information using search engines"
+metadata:
+  hive:
+    emoji: "🔍"
+    bins: []
+    userInvocable: true
+---
+
+# Web Search Skill
+
+This skill enables the agent to search the web for current information.
+
+## Usage
+
+Use the `web_search` tool to search for information on the internet. The search will return relevant results with titles, URLs, and snippets.
+
+## Parameters
+
+- `query` (required): The search query string
+- `numResults` (optional): Number of results to return (default: 5)
+
+## Examples
+
+1. Search for recent news:
+   ```
+   web_search(query: "latest AI developments 2024")
+   ```
+
+2. Search for documentation:
+   ```
+   web_search(query: "TypeScript generic constraints examples")
+   ```
+
+## Best Practices
+
+- Be specific with your search queries
+- Use quotes for exact phrases
+- Combine with `web_fetch` to get full content from results

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./loader.ts";

package/src/loader.ts

@@ -0,0 +1,143 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as yaml from "js-yaml";
+import type { Config } from "../config/loader.ts";
+import { logger } from "../utils/logger.ts";
+
+export interface SkillMetadata {
+  name: string;
+  description: string;
+  metadata?: {
+    hive?: {
+      emoji?: string;
+      bins?: string[];
+      userInvocable?: boolean;
+      requires?: {
+        config?: string[];
+        env?: string[];
+      };
+      install?: {
+        brew?: string;
+        apt?: string;
+        npm?: string;
+      };
+      os?: string[];
+    };
+  };
+}
+
+export interface Skill {
+  name: string;
+  description: string;
+  content: string;
+  metadata: SkillMetadata["metadata"];
+  source: "bundled" | "managed" | "workspace";
+  path: string;
+}
+
+function parseFrontmatter(content: string): { frontmatter: Record<string, unknown>; body: string } {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  
+  if (!match) {
+    return { frontmatter: {}, body: content };
+  }
+
+  try {
+    const frontmatter = yaml.load(match[1]!) as Record<string, unknown>;
+    const body = match[2]!;
+    return { frontmatter, body };
+  } catch {
+    return { frontmatter: {}, body: content };
+  }
+}
+
+export class SkillLoader {
+  private config: Config;
+  private log = logger.child("skills");
+  private cache: Map<string, Skill> = new Map();
+
+  constructor(config: Config) {
+    this.config = config;
+  }
+
+  private expandPath(p: string): string {
+    if (p.startsWith("~")) {
+      return path.join(process.env.HOME ?? "", p.slice(1));
+    }
+    return p;
+  }
+
+  loadSkill(skillPath: string, source: Skill["source"]): Skill | null {
+    try {
+      const skillMdPath = path.join(skillPath, "SKILL.md");
+      
+      if (!fs.existsSync(skillMdPath)) {
+        return null;
+      }
+
+      const content = fs.readFileSync(skillMdPath, "utf-8");
+      const { frontmatter, body } = parseFrontmatter(content);
+
+      const metadata = frontmatter.metadata as SkillMetadata["metadata"];
+      const name = (frontmatter.name as string) ?? path.basename(skillPath);
+      const description = (frontmatter.description as string) ?? "";
+
+      const skill: Skill = {
+        name,
+        description,
+        content: body,
+        metadata,
+        source,
+        path: skillPath,
+      };
+
+      this.cache.set(name, skill);
+      return skill;
+    } catch (error) {
+      this.log.error(`Failed to load skill: ${skillPath}`, { error: (error as Error).message });
+      return null;
+    }
+  }
+
+  loadAllSkills(): Skill[] {
+    const skills: Map<string, Skill> = new Map();
+
+    const managedDir = this.expandPath(this.config.skills?.managedDir ?? "~/.hive/skills");
+    if (fs.existsSync(managedDir)) {
+      for (const entry of fs.readdirSync(managedDir, { withFileTypes: true })) {
+        if (entry.isDirectory()) {
+          const skill = this.loadSkill(path.join(managedDir, entry.name), "managed");
+          if (skill) {
+            skills.set(skill.name, skill);
+          }
+        }
+      }
+    }
+
+    const workspaceDir = "workspace/skills";
+    if (fs.existsSync(workspaceDir)) {
+      for (const entry of fs.readdirSync(workspaceDir, { withFileTypes: true })) {
+        if (entry.isDirectory()) {
+          const skill = this.loadSkill(path.join(workspaceDir, entry.name), "workspace");
+          if (skill) {
+            skills.set(skill.name, skill);
+          }
+        }
+      }
+    }
+
+    return Array.from(skills.values());
+  }
+
+  getSkill(name: string): Skill | undefined {
+    return this.cache.get(name);
+  }
+
+  clearCache(): void {
+    this.cache.clear();
+  }
+}
+
+export function createSkillLoader(config: Config): SkillLoader {
+  return new SkillLoader(config);
+}