abelworkflow 1.2.4 → 1.3.0

package/skills/dev-browser/package.json

@@ -1,35 +0,0 @@
-{
-  "name": "dev-browser",
-  "version": "0.0.1",
-  "type": "module",
-  "engines": {
-    "node": ">=22"
-  },
-  "packageManager": "npm@10.9.2",
-  "exports": {
-    "./client": {
-      "types": "./dist/src/client.d.ts",
-      "import": "./dist/src/client.js"
-    }
-  },
-  "scripts": {
-    "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "start": "node dist/scripts/start.js standalone",
-    "start-server": "node dist/scripts/start.js standalone",
-    "start-extension": "node dist/scripts/start.js extension",
-    "test": "vitest run",
-    "test:watch": "vitest"
-  },
-  "dependencies": {
-    "@hono/node-server": "^1.19.13",
-    "@hono/node-ws": "^1.3.1",
-    "hono": "^4.12.30",
-    "playwright": "^1.56.0"
-  },
-  "devDependencies": {
-    "@types/node": "^22.0.0",
-    "typescript": "^5.0.0",
-    "vitest": "^2.1.0"
-  }
-}

package/skills/dev-browser/references/scraping.md

@@ -1,144 +0,0 @@
-# Data Scraping Guide
-
-For large datasets (followers, posts, search results), **intercept and replay network requests** rather than scrolling and parsing the DOM. This is faster, more reliable, and handles pagination automatically.
-
-## Why Not Scroll?
-
-Scrolling is slow, unreliable, and wastes time. APIs return structured data with pagination built in. Always prefer API replay.
-
-## Start Small, Then Scale
-
-**Don't try to automate everything at once.** Work incrementally:
-
-1. **Capture one request** - verify you're intercepting the right endpoint
-2. **Inspect one response** - understand the schema before writing extraction code
-3. **Extract a few items** - make sure your parsing logic works
-4. **Then scale up** - add pagination loop only after the basics work
-
-This prevents wasting time debugging a complex script when the issue is a simple path like `data.user.timeline` vs `data.user.result.timeline`.
-
-## External Script Setup
-
-Keep the installed skill directory read-only. Put scripts and temporary artifacts in the OS temporary directory or the task workspace, and remove them when the task finishes. External scripts receive the installed skill directory as their first argument and dynamically import the compiled client by file URL.
-
-Never persist complete authentication headers. Keep captured headers in memory, and write only redacted metadata or final non-sensitive results.
-
-```javascript
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { pathToFileURL } from "node:url";
-
-const skillDir = process.argv[2];
-if (!skillDir) throw new Error("Pass the installed dev-browser skill directory");
-const { connect, waitForPageLoad } = await import(
-  pathToFileURL(join(skillDir, "dist", "src", "client.js")).href
-);
-
-const workDir = await mkdtemp(join(tmpdir(), "dev-browser-scrape-"));
-let client;
-try {
-  client = await connect();
-  const page = await client.page("site");
-  let capturedRequest;
-
-  page.on("request", (request) => {
-    const url = request.url();
-    if (url.includes("/api/") || url.includes("/graphql/")) {
-      capturedRequest = {
-        url,
-        method: request.method(),
-        headers: request.headers(),
-      };
-    }
-  });
-
-  await page.goto("https://example.com/profile");
-  await waitForPageLoad(page);
-  await page.waitForTimeout(3000);
-
-  if (!capturedRequest) throw new Error("No matching API request captured");
-  const capturedUrl = new URL(capturedRequest.url);
-  console.log({
-    url: `${capturedUrl.origin}${capturedUrl.pathname}`,
-    method: capturedRequest.method,
-    headerNames: Object.keys(capturedRequest.headers),
-  });
-
-  const results = new Map();
-  let cursor;
-  do {
-    const params = { count: 20, ...(cursor ? { cursor } : {}) };
-    const url = new URL(capturedRequest.url);
-    url.searchParams.set("params", JSON.stringify(params));
-    const response = await page.evaluate(
-      async ({ url, headers }) => {
-        const result = await fetch(url, { headers });
-        return result.json();
-      },
-      { url: url.href, headers: capturedRequest.headers }
-    );
-
-    const entries = response?.data?.entries ?? [];
-    cursor = undefined;
-    for (const entry of entries) {
-      if (entry.type === "cursor-bottom") cursor = entry.value;
-      else if (entry.id) results.set(entry.id, entry);
-    }
-    await new Promise((resolve) => setTimeout(resolve, 500));
-  } while (cursor);
-
-  const resultPath = join(workDir, "results.json");
-  await writeFile(resultPath, JSON.stringify([...results.values()], null, 2));
-  console.log({ count: results.size, resultPath });
-} finally {
-  try {
-    await client?.disconnect();
-  } finally {
-    await rm(workDir, { recursive: true, force: true });
-  }
-}
-```
-
-Run it with quoted paths on Linux, PowerShell, or Command Prompt:
-
-```text
-node "PATH_TO_SCRIPT.mjs" "PATH_TO_INSTALLED_DEV_BROWSER"
-```
-
-If a result must survive the script, write the sanitized deliverable to the task workspace instead of `workDir`, then delete it at task completion unless the user asks to retain it.
-
-## Step-by-Step Workflow
-
-### 1. Capture One Request
-
-Match a narrow API or GraphQL URL pattern. Keep the request URL and headers in memory. Log only the URL origin/path, method, and header names while confirming the endpoint; query parameters can contain credentials.
-
-### 2. Inspect One Response
-
-Inspect the response in memory before building pagination. Find:
-
-- Where the data array lives (e.g., `data.user.result.timeline.instructions[].entries`)
-- Where pagination cursors are (e.g., `cursor-bottom` entries)
-- What fields you need to extract
-
-### 3. Replay API with Pagination
-
-Replay through `page.evaluate(fetch)` so the browser supplies its session cookies. Pass only the in-memory headers required by the endpoint, deduplicate with a `Map`, stop when the cursor or results end, and rate-limit requests.
-
-## Key Patterns
-
-| Pattern                 | Description                                            |
-| ----------------------- | ------------------------------------------------------ |
-| `page.on('request')`    | Capture outgoing request URL + headers                 |
-| `page.on('response')`   | Capture response data to understand schema             |
-| `page.evaluate(fetch)`  | Replay requests in browser context (inherits auth)     |
-| `Map` for deduplication | APIs often return overlapping data across pages        |
-| Cursor-based pagination | Look for `cursor`, `next_token`, `offset` in responses |
-
-## Tips
-
-- **Extension mode**: `page.context().cookies()` doesn't work - keep intercepted auth headers in memory instead
-- **Rate limiting**: Add 500ms+ delays between requests to avoid blocks
-- **Stop conditions**: Check for empty results, missing cursor, or reaching a date/ID threshold
-- **GraphQL APIs**: URL params often include `variables` and `features` JSON objects - capture and reuse them

package/skills/git-commit/SKILL.md

@@ -1,124 +0,0 @@
----
-name: git-commit
-description: 'Execute git commit with conventional commit message analysis, intelligent staging, and message generation. Use when user asks to commit changes, create a git commit, or mentions "/commit". Supports: (1) Auto-detecting type and scope from changes, (2) Generating conventional commit messages from diff, (3) Interactive commit with optional type/scope/description overrides, (4) Intelligent file staging for logical grouping'
-license: MIT
-allowed-tools: Bash
----
-
-# Git Commit with Conventional Commits
-
-## Overview
-
-Create standardized, semantic git commits using the Conventional Commits specification. Analyze the actual diff to determine appropriate type, scope, and message.
-
-## Conventional Commit Format
-
-```
-<type>[optional scope]: <description>
-
-[optional body]
-
-[optional footer(s)]
-```
-
-## Commit Types
-
-| Type       | Purpose                        |
-| ---------- | ------------------------------ |
-| `feat`     | New feature                    |
-| `fix`      | Bug fix                        |
-| `docs`     | Documentation only             |
-| `style`    | Formatting/style (no logic)    |
-| `refactor` | Code refactor (no feature/fix) |
-| `perf`     | Performance improvement        |
-| `test`     | Add/update tests               |
-| `build`    | Build system/dependencies      |
-| `ci`       | CI/config changes              |
-| `chore`    | Maintenance/misc               |
-| `revert`   | Revert commit                  |
-
-## Breaking Changes
-
-```
-# Exclamation mark after type/scope
-feat!: remove deprecated endpoint
-
-# BREAKING CHANGE footer
-feat: allow config to extend other configs
-
-BREAKING CHANGE: `extends` key behavior changed
-```
-
-## Workflow
-
-### 1. Analyze Diff
-
-```bash
-# If files are staged, use staged diff
-git diff --staged
-
-# If nothing staged, use working tree diff
-git diff
-
-# Also check status
-git status --porcelain
-```
-
-### 2. Stage Files (if needed)
-
-If nothing is staged or you want to group changes differently:
-
-```bash
-# Stage specific files
-git add path/to/file1 path/to/file2
-
-# Stage by pattern
-git add *.test.*
-git add src/components/*
-
-# Interactive staging
-git add -p
-```
-
-**Never commit secrets** (.env, credentials.json, private keys).
-
-### 3. Generate Commit Message
-
-Analyze the diff to determine:
-
-- **Type**: What kind of change is this?
-- **Scope**: What area/module is affected?
-- **Description**: One-line summary of what changed (present tense, imperative mood, <72 chars)
-
-### 4. Execute Commit
-
-```bash
-# Single line
-git commit -m "<type>[scope]: <description>"
-
-# Multi-line with body/footer
-git commit -m "$(cat <<'EOF'
-<type>[scope]: <description>
-
-<optional body>
-
-<optional footer>
-EOF
-)"
-```
-
-## Best Practices
-
-- One logical change per commit
-- Present tense: "add" not "added"
-- Imperative mood: "fix bug" not "fixes bug"
-- Reference issues: `Closes #123`, `Refs #456`
-- Keep description under 72 characters
-
-## Git Safety Protocol
-
-- NEVER update git config
-- NEVER run destructive commands (--force, hard reset) without explicit request
-- NEVER skip hooks (--no-verify) unless user asks
-- NEVER force push to main/master
-- If commit fails due to hooks, fix and create NEW commit (don't amend)

package/skills/time/SKILL.md

@@ -1,119 +0,0 @@
----
-name: time
-description: |
-  Time and timezone utilities for getting current time and converting between timezones. Use when: (1) Getting current time in any timezone, (2) Converting time between different timezones, (3) Working with IANA timezone names, (4) Scheduling across timezones, (5) Time-sensitive operations. Triggers: "what time is it", "current time", "convert time", "timezone", "time in [city]". Supports both MCP server and standalone CLI.
----
-
-# Time
-
-Time and timezone conversion utilities. Supports both MCP server and standalone CLI.
-
-## Execution Methods
-
-### Method 1: MCP Tools (if available)
-Use `mcp__time__*` tools directly:
-- `mcp__time__get_current_time` - Get current time in a timezone
-- `mcp__time__convert_time` - Convert time between timezones
-
-### Method 2: CLI Script (no MCP dependency)
-Run `scripts/time_cli.py` via Bash:
-
-```bash
-# Prerequisite: Python 3.9+
-# Windows also requires IANA data: python -m pip install tzdata
-
-# Get current time in a timezone
-python scripts/time_cli.py get --timezone "Asia/Shanghai"
-python scripts/time_cli.py get --timezone "America/New_York"
-python scripts/time_cli.py get  # Uses UTC
-
-# Convert time between timezones
-python scripts/time_cli.py convert \
-  --time "16:30" \
-  --from "America/New_York" \
-  --to "Asia/Tokyo"
-
-# List available timezones
-python scripts/time_cli.py list [--filter "Asia"]
-```
-
-## Tool Capability Matrix
-
-| Tool | Parameters | Output |
-|------|------------|--------|
-| `get_current_time` | `timezone` (required, IANA name) | `{timezone, datetime, is_dst}` |
-| `convert_time` | `source_timezone`, `time` (HH:MM), `target_timezone` | `{source, target, time_difference}` |
-
-## Common IANA Timezone Names
-
-| Region | Timezone |
-|--------|----------|
-| China | `Asia/Shanghai` |
-| Japan | `Asia/Tokyo` |
-| Korea | `Asia/Seoul` |
-| US East | `America/New_York` |
-| US West | `America/Los_Angeles` |
-| UK | `Europe/London` |
-| Germany | `Europe/Berlin` |
-| France | `Europe/Paris` |
-| Australia | `Australia/Sydney` |
-| UTC | `UTC` |
-
-## Workflow
-
-### Getting Current Time
-1. Identify target timezone (use IANA name)
-2. Call `get_current_time` with timezone parameter
-3. Response includes ISO 8601 datetime and DST status
-
-### Converting Time
-1. Identify source timezone and time (24-hour format HH:MM)
-2. Identify target timezone
-3. Call `convert_time` with all parameters
-4. Response includes both times and time difference
-
-## Output Format
-
-### get_current_time Response
-```json
-{
-  "timezone": "Asia/Shanghai",
-  "datetime": "2024-01-01T21:00:00+08:00",
-  "is_dst": false
-}
-```
-
-### convert_time Response
-```json
-{
-  "source": {
-    "timezone": "America/New_York",
-    "datetime": "2024-01-01T16:30:00-05:00",
-    "is_dst": false
-  },
-  "target": {
-    "timezone": "Asia/Tokyo",
-    "datetime": "2024-01-02T06:30:00+09:00",
-    "is_dst": false
-  },
-  "time_difference": "+14.0h"
-}
-```
-
-## Error Handling
-
-| Error | Recovery |
-|-------|----------|
-| Invalid timezone | Check IANA timezone name spelling |
-| Invalid time format | Use 24-hour format HH:MM |
-| Nonexistent or ambiguous DST time | Choose an unambiguous local time |
-| Missing timezone data on Windows | Run `python -m pip install tzdata` |
-| MCP unavailable | Fall back to CLI script |
-
-## Anti-Patterns
-
-| Prohibited | Correct |
-|------------|---------|
-| Use city names directly | Use IANA timezone names (e.g., `Asia/Tokyo` not `Tokyo`) |
-| Use 12-hour format | Use 24-hour format (e.g., `16:30` not `4:30 PM`) |
-| Assume timezone | Always specify timezone explicitly |

package/skills/time/scripts/time_cli.py

@@ -1,143 +0,0 @@
-#!/usr/bin/env python3
-"""Time CLI - Standalone time and timezone utilities."""
-
-import argparse
-import json
-import re
-import sys
-from datetime import datetime, timezone
-from zoneinfo import ZoneInfo, ZoneInfoNotFoundError, available_timezones
-
-
-def load_timezone(tz_name: str) -> ZoneInfo:
-    try:
-        return ZoneInfo(tz_name)
-    except ZoneInfoNotFoundError as error:
-        try:
-            ZoneInfo("UTC")
-        except ZoneInfoNotFoundError:
-            raise ValueError(
-                "IANA timezone data is unavailable; on Windows install it with: "
-                "python -m pip install tzdata"
-            ) from error
-        raise ValueError(f"Unknown IANA timezone: {tz_name}") from error
-
-
-def localize_time(source: ZoneInfo, year: int, month: int, day: int, hour: int, minute: int) -> datetime:
-    naive = datetime(year, month, day, hour, minute)
-    candidates = []
-    for fold in (0, 1):
-        candidate = naive.replace(tzinfo=source, fold=fold)
-        round_trip = candidate.astimezone(timezone.utc).astimezone(source)
-        if round_trip.replace(tzinfo=None) == naive:
-            candidates.append(candidate)
-
-    if not candidates:
-        raise ValueError("local time is nonexistent because of a DST transition")
-    if len({candidate.utcoffset() for candidate in candidates}) > 1:
-        raise ValueError("local time is ambiguous because of a DST transition")
-    return candidates[0]
-
-
-def get_current_time(tz_name: str) -> dict:
-    """Get current time in specified timezone."""
-    try:
-        tz = load_timezone(tz_name)
-        now = datetime.now(tz)
-        return {
-            "timezone": tz_name,
-            "datetime": now.isoformat(),
-            "is_dst": bool(now.dst()) if hasattr(now, 'dst') and now.dst() else False
-        }
-    except Exception as e:
-        return {"error": str(e)}
-
-
-def convert_time(source_tz: str, time_str: str, target_tz: str) -> dict:
-    """Convert time between timezones."""
-    try:
-        if not re.fullmatch(r"(?:[01]\d|2[0-3]):[0-5]\d", time_str):
-            raise ValueError("time must use 24-hour HH:MM format")
-        hour, minute = map(int, time_str.split(':'))
-        source = load_timezone(source_tz)
-        target = load_timezone(target_tz)
-
-        today = datetime.now(source).date()
-        source_dt = localize_time(source, today.year, today.month, today.day, hour, minute)
-        target_dt = source_dt.astimezone(target)
-
-        source_offset = source_dt.utcoffset().total_seconds() / 3600
-        target_offset = target_dt.utcoffset().total_seconds() / 3600
-        diff = target_offset - source_offset
-
-        return {
-            "source": {
-                "timezone": source_tz,
-                "datetime": source_dt.isoformat(),
-                "is_dst": bool(source_dt.dst()) if hasattr(source_dt, 'dst') and source_dt.dst() else False
-            },
-            "target": {
-                "timezone": target_tz,
-                "datetime": target_dt.isoformat(),
-                "is_dst": bool(target_dt.dst()) if hasattr(target_dt, 'dst') and target_dt.dst() else False
-            },
-            "time_difference": f"{diff:+.1f}h"
-        }
-    except Exception as e:
-        return {"error": str(e)}
-
-
-def list_timezones(filter_str: str = None) -> list:
-    """List available timezones."""
-    zones = sorted(available_timezones())
-    if not zones:
-        load_timezone("UTC")
-    if filter_str:
-        zones = [z for z in zones if filter_str.lower() in z.lower()]
-    return zones
-
-
-def print_result(result: dict) -> int:
-    if "error" in result:
-        print(json.dumps(result, indent=2), file=sys.stderr)
-        return 1
-    print(json.dumps(result, indent=2))
-    return 0
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description="Time and timezone utilities")
-    subparsers = parser.add_subparsers(dest="command", required=True)
-
-    # get command
-    get_parser = subparsers.add_parser("get", help="Get current time")
-    get_parser.add_argument("--timezone", "-tz", default="UTC", help="IANA timezone name")
-
-    # convert command
-    convert_parser = subparsers.add_parser("convert", help="Convert time between timezones")
-    convert_parser.add_argument("--time", "-t", required=True, help="Time in HH:MM format")
-    convert_parser.add_argument("--from", "-f", dest="source", required=True, help="Source timezone")
-    convert_parser.add_argument("--to", "-o", dest="target", required=True, help="Target timezone")
-
-    # list command
-    list_parser = subparsers.add_parser("list", help="List available timezones")
-    list_parser.add_argument("--filter", "-f", help="Filter timezones by substring")
-
-    args = parser.parse_args()
-
-    if args.command == "get":
-        return print_result(get_current_time(args.timezone))
-    if args.command == "convert":
-        return print_result(convert_time(args.source, args.time, args.target))
-    if args.command == "list":
-        try:
-            for z in list_timezones(args.filter):
-                print(z)
-            return 0
-        except Exception as error:
-            return print_result({"error": str(error)})
-    return 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())