@weavetab/skills 1.0.1 → 2.5.0-beta.4

package/dist/granular/desktop_electron-discovery.md

@@ -0,0 +1,115 @@
+---
+id: electron-discovery
+domain: desktop
+triggers:
+  - "discover electron apps"
+  - "detect desktop apps"
+  - "connect to slack"
+  - "connect to discord"
+  - "connect to vscode"
+  - "electron automation"
+tools:
+  - "browser_detect"
+weavetab: ">=2.5.0-beta.4"
+---
+
+# Electron Discovery & Environment Handshake
+
+Modern desktop applications (Discord, Slack, VS Code, Notion, Obsidian, Figma) are built on Chromium and Electron. Weavetab can inspect and drive these native applications through standard CDP interfaces without third-party drivers or OS-level accessibility hacks.
+
+`browser_detect` is the **critical initialization handshake** tool. Every agent should call `browser_detect` before interacting with the user's desktop environment to gain immediate situational awareness.
+
+---
+
+## 1. Running Discovery via `browser_detect`
+
+Call `browser_detect` with empty parameters `{}`:
+
+```json
+{}
+```
+
+### Response Schema:
+```json
+{
+  "available": [
+    {
+      "engine": "chromium",
+      "name": "Google Chrome",
+      "path": "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe"
+    }
+  ],
+  "current": "chromium",
+  "configuredApps": [
+    {
+      "name": "discord",
+      "status": "running_no_debug",
+      "configuredPath": "C:\\Users\\username\\AppData\\Local\\Discord\\app-1.0.9256\\Discord.exe"
+    },
+    {
+      "name": "slack",
+      "status": "connected",
+      "port": 9222,
+      "configuredPath": "C:\\Users\\username\\AppData\\Local\\slack\\app-4.38.125\\slack.exe",
+      "activeTabs": [
+        {
+          "id": "PAGE_1",
+          "title": "general - Weavetab Slack",
+          "url": "https://app.slack.com/client/..."
+        }
+      ]
+    },
+    {
+      "name": "vscode",
+      "status": "offline",
+      "configuredPath": "C:\\Users\\username\\AppData\\Local\\Programs\\Microsoft VS Code\\Code.exe"
+    }
+  ],
+  "toolCoverage": {
+    "chromium": 100,
+    "firefox": 78,
+    "webkit": 55
+  }
+}
+```
+
+---
+
+## 2. Understanding Application Status
+
+Each configured desktop app reports one of three distinct lifecycle statuses:
+
+| Status | Meaning | Agent Action |
+| :--- | :--- | :--- |
+| **`connected`** | App is running with CDP remote debugging active. Weavetab has an active session. | Immediately interact using any tool with `"app": "<name>"`. Tabs and port are available. |
+| **`running_no_debug`** | The app process is currently open on the user's OS, but was launched normally by the user without `--remote-debugging-port`. | Do NOT send click/type commands. To attach, inform the user or close and launch via `browser_navigate(app: "<name>")` so Weavetab supplies the debugging port. |
+| **`offline`** | The application is not currently running on the OS. | Launch and attach in one step by calling `browser_navigate(app: "<name>")`. |
+
+---
+
+## 3. Dynamic Squirrel Updates on Windows
+
+On Windows, Squirrel-managed applications (Discord, Slack, Teams) update dynamically into versioned sibling directories (e.g. `Discord\app-1.0.9256\Discord.exe`). 
+
+Weavetab automatically handles this:
+- If a configured path points to an outdated version or the parent folder, Weavetab scans the directory, resolves the highest semantic version folder (`app-1.0.xxxx`), and launches the valid executable.
+- The dynamically resolved path is reported in `browser_detect` under `configuredPath`.
+
+---
+
+## 4. Launching Desktop Apps Manually with Debugging
+
+If the user prefers to launch apps manually from a terminal or shortcut with remote debugging enabled:
+
+```bash
+# Discord
+Discord.exe --remote-debugging-port=9222
+
+# Slack
+slack.exe --remote-debugging-port=9223
+
+# VS Code
+code.exe --remote-debugging-port=9225
+```
+
+Once launched with `--remote-debugging-port`, `browser_detect` immediately reflects the application as connectable.

package/dist/granular/developer_github-forensics.md

@@ -0,0 +1,74 @@
+---
+id: github-forensics
+domain: developer
+triggers:
+  - "analyze github"
+  - "read repository"
+  - "check pull request"
+  - "github issues"
+  - "inspect repo"
+tools:
+  - "browser_github"
+weavetab: ">=2.5.0-beta.4"
+---
+
+# GitHub Forensics & Repository Architecture Inspection
+
+Navigating GitHub repositories via web browsing burns massive token budgets loading HTML chrome, comment threads, and diff trees. Weavetab includes a dedicated `browser_github` tool that interacts directly with git metadata and raw endpoints.
+
+---
+
+## 1. High-Level Repository Analysis (action: "analyze")
+
+Quickly summarize repo structure, languages, dependency graphs, and recent commit frequency:
+
+```json
+{
+  "action": "analyze",
+  "repo": "Weavetab/MCP"
+}
+```
+
+---
+
+## 2. Reading Repository Source Files (action: "read")
+
+Directly stream files and directories from any public or authenticated GitHub repo without cloning or burning API rate limits:
+
+```json
+{
+  "action": "read",
+  "repo": "Weavetab/MCP",
+  "paths": ["src/server.ts"],
+  "line_range": [1, 200]
+}
+```
+
+---
+
+## 3. Pull Request Forensics (action: "pr")
+
+Retrieve PR diffs, changed files, review comments, CI checks, and mergeability status:
+
+```json
+{
+  "action": "pr",
+  "repo": "Weavetab/MCP",
+  "number": 42
+}
+```
+
+---
+
+## 4. Issue Triage & Search (action: "issues")
+
+Query repository issue trackers with state, label, and keyword filters:
+
+```json
+{
+  "action": "issues",
+  "repo": "Weavetab/MCP",
+  "state": "open",
+  "labels": ["bug", "priority"]
+}
+```

package/dist/granular/documents_canvas-and-visual-capture.md

@@ -0,0 +1,103 @@
+---
+id: canvas-and-visual-capture
+domain: documents
+triggers:
+  - "take screenshot"
+  - "capture viewport"
+  - "export pdf"
+  - "canvas inspection"
+  - "extract design tokens"
+tools:
+  - "browser_screenshot"
+  - "browser_viewport"
+  - "browser_canvas"
+  - "browser_pdf"
+  - "browser_extract_design"
+  - "browser_map"
+  - "browser_click"
+weavetab: ">=2.5.0-beta.4"
+---
+
+# Visual Capture, Canvas Forensics & Design Extraction
+
+Beyond textual DOM manipulation, modern web applications contain dynamic HTML5 canvas renderings (charts, maps, WebGL games), and agents often need high-fidelity visual artifacts.
+
+---
+
+## 1. Targeted Screenshots (`browser_screenshot`)
+
+Capture full page layouts, the visible viewport, or specific element bounding boxes:
+
+```json
+{
+  "fullPage": true,
+  "format": "png"
+}
+```
+
+Or target a specific element ref:
+```json
+{
+  "ref": "w:55",
+  "format": "jpeg",
+  "quality": 80
+}
+```
+
+---
+
+## 2. PDF Document Generation (`browser_pdf`)
+
+Render the current page into a print-ready PDF document with print CSS styles applied:
+
+```json
+{
+  "landscape": false,
+  "printBackground": true,
+  "paperWidth": 8.5,
+  "paperHeight": 11
+}
+```
+
+---
+
+## 3. HTML5 Canvas Pixel Inspection & Visual Grounding (`browser_canvas` & `browser_map`)
+
+When a chart or graphic is rendered via `<canvas>`, standard DOM reading tools cannot see individual buttons or nodes. You have two strategies:
+
+### A. Set-of-Marks Visual Grounding (Recommended for Canvas UIs & WebGL)
+Run `browser_map({ visual: "auto" })`. It detects canvas elements and high-contrast regions, attaches numbered badges `[1]…[N]`, and returns an annotated image:
+```json
+{
+  "visual": "auto"
+}
+```
+Then interact directly by mark number without guessing pixel coordinates:
+```json
+{
+  "mark": 3
+}
+```
+
+### B. Direct Canvas Pixel Export (`browser_canvas`)
+To extract the raw image data or draw programmatic gesture paths:
+```json
+{
+  "ref": "w:19",
+  "action": "toDataURL"
+}
+```
+
+---
+
+## 4. Design System Extraction (`browser_extract_design`)
+
+Reverse-engineer UI stylesheets, active CSS custom properties (variables), typography scales, and color palettes:
+
+```json
+{
+  "selector": ".antigravity-hud-panel"
+}
+```
+
+Returns structured JSON representing colors, font families, shadows, and spacing tokens.

package/dist/granular/documents_office-document-ingestion.md

@@ -0,0 +1,63 @@
+---
+id: office-document-ingestion
+domain: documents
+triggers:
+  - "read excel"
+  - "read docx"
+  - "parse csv"
+  - "spreadsheet"
+  - "word document"
+  - "parse table"
+tools:
+  - "browser_office"
+weavetab: ">=2.5.0-beta.4"
+---
+
+# Office Document Ingestion: Word, Excel & CSV Parsing
+
+Agents frequently need to parse structured spreadsheets or corporate documents downloaded during automation runs. `browser_office` parses `.docx`, `.xlsx`, `.xls`, and `.csv` files directly into clean JSON structures.
+
+---
+
+## 1. Parsing Spreadsheets (`.xlsx`, `.csv`)
+
+Stream structured sheet data, headers, and cell values:
+
+```json
+{
+  "filePath": "C:/Users/fy2ne/Downloads/quarterly_revenue.xlsx",
+  "sheet": "Q3_Summary",
+  "headerRow": 1,
+  "maxRows": 100
+}
+```
+
+### Response Example:
+```json
+{
+  "fileType": "xlsx",
+  "sheets": ["Q1", "Q2", "Q3_Summary"],
+  "rowCount": 45,
+  "data": [
+    { "Department": "Engineering", "Budget": 1250000, "Actual": 1180000 },
+    { "Department": "Marketing", "Budget": 600000, "Actual": 620000 }
+  ]
+}
+```
+
+---
+
+## 2. Ingesting Word Documents (`.docx`)
+
+Extract semantic paragraphs, document headings, tables, and lists:
+
+```json
+{
+  "filePath": "C:/Users/fy2ne/Documents/service_agreement.docx",
+  "extractTables": true
+}
+```
+
+### Operational Advantages:
+- Eliminates the need for heavy external Python libraries or microservices.
+- Safely sanitizes binary formats before passing content into LLM context.

package/dist/granular/memory_selector-memory-system.md

@@ -0,0 +1,127 @@
+---
+id: selector-memory-system
+domain: memory
+triggers:
+  - "adaptive selector"
+  - "selector memory"
+  - "cached selector"
+  - "selector decay"
+  - "cross session learning"
+  - "site profile"
+  - "known workflow"
+  - "fast path"
+tools:
+  - "browser_find"
+  - "browser_click"
+  - "browser_fill"
+  - "browser_pattern_learn"
+weavetab: ">=2.5.0-beta.4"
+---
+
+# Two-Tier Memory System
+
+Weavetab operates a two-tier persistent memory system. Understanding both layers prevents wasted DOM traversals and makes agents dramatically faster across sessions.
+
+---
+
+## Tier 1 — Selector Confidence Cache (`~/.weavetab-system/memory/`)
+
+Per-domain JSON files (one per hostname) track individual element selectors and their interaction history.
+
+Every time an element is located and interacted with, Weavetab calculates a confidence score based on:
+1. **Attribute Stability**: Prefers `data-testid`, `id`, `aria-label`, and semantic roles over dynamic Tailwind/CSS-module class strings.
+2. **Success Count**: Selectors that successfully trigger navigation or state changes gain reinforcement.
+3. **Origin Isolation**: Learned selectors are strictly namespaced to the origin to prevent cross-site contamination.
+
+### Strike Degradation
+- **Strike 1**: Marked as degraded — falls back to secondary candidates or fuzzy label match.
+- **Strike 2**: Deprecated — immediate fallback to full DOM inspection via `browser_find` or `browser_map`.
+- **Strike 3**: Purged from memory cache to prevent stale lookups.
+
+### Agent Discipline for Tier 1
+1. **Rely on Native Tool Resolution**: When you pass a `ref`, Weavetab queries both the active volatile registry and the Tier 1 memory cache automatically.
+2. **Don't Hardcode Fragile Selectors**: Never pass brittle absolute CSS paths like `div:nth-child(3) > ul > li:nth-child(2) > button`.
+3. **Trust Heuristic Recovery**: If a button moves slightly on the page, the underlying engine re-anchors before reporting failure.
+
+---
+
+## Tier 2 — Site Profiles & Workflow Patterns (`~/.weavetab-system/memory/sites/`)
+
+One JSON file per origin stores named multi-step workflow patterns, site quirks, and reliability scores. This is the **Intelligent Memory** layer — agents learn entire flows, not just individual selectors.
+
+### Checking a Site Profile at Session Start
+Always call `browser_pattern_learn` with `action: "get"` when starting an automation session on a site you may have visited before:
+
+```json
+{ "origin": "https://github.com" }
+```
+
+Response tells you:
+- `known_patterns`: named flows with reliability scores and step counts
+- `quirks`: known cookie banners, rate limits, modal popups to handle automatically
+- `framework`: detected frontend stack
+- `_hint`: compact hint string summarizing everything
+
+### Fast-Path Decision Rule
+| Reliability | Action |
+|---|---|
+| **≥ 0.8** | Use pattern steps directly via `browser_burst` — skip exploratory navigation |
+| **0.5 – 0.79** | Attempt pattern but verify success indicator before moving on |
+| **< 0.5 or strikes ≥ 3** | Ignore pattern, re-explore from scratch, then teach via `browser_pattern_learn` |
+
+### Teaching a New Pattern After Completing a Workflow
+After successfully completing a multi-step flow:
+
+```json
+{
+  "origin": "https://github.com",
+  "action": "learn",
+  "name": "login_flow",
+  "steps": [
+    { "tool": "browser_click", "target": ".btn-login" },
+    { "tool": "browser_fill", "target": "#login_field", "value": "{{username}}" },
+    { "tool": "browser_fill", "target": "#password", "value": "{{password}}" },
+    { "tool": "browser_click", "target": "[type=submit]" }
+  ],
+  "success_indicator": "a[aria-label='Homepage']"
+}
+```
+
+### Recording Execution Outcomes (Reliability Upkeep)
+After replaying a pattern, always report the outcome:
+
+```json
+{
+  "origin": "https://github.com",
+  "action": "record_execution",
+  "name": "login_flow",
+  "success": true,
+  "duration_ms": 3200
+}
+```
+
+### Recording Site Quirks
+When you discover a cookie banner or rate limit:
+
+```json
+{
+  "origin": "https://github.com",
+  "action": "record_quirk",
+  "quirk_key": "cookie_banner",
+  "quirk_data": { "selector": "#cookie-consent", "action": "click .accept-all", "appears": "first_visit" }
+}
+```
+
+On future visits, the quirk is present in the profile so you can dismiss banners before starting your main workflow — zero wasted agent turns.
+
+---
+
+## File Locations (Never Write to ~/.weavetab/)
+
+| Tier | Path | Owner |
+|---|---|---|
+| Tier 1 selectors | `~/.weavetab-system/memory/<hostname>.json` | Engine (auto) |
+| Tier 2 site profiles | `~/.weavetab-system/memory/sites/<origin>.json` | Engine via `browser_pattern_learn` |
+| Knowledge hints | `~/.weavetab-system/knowledge/<hostname>.md` | Engine (auto, 20-token notes) |
+| User config | `~/.weavetab/config.json` | Human — never written by agents |
+

package/dist/granular/memory_session-trail.md

@@ -0,0 +1,95 @@
+---
+id: session-trail
+domain: memory
+triggers:
+  - "compile macro"
+  - "export automation"
+  - "replay actions"
+  - "session trail"
+  - "record workflow"
+tools:
+  - "browser_burst"
+  - "browser_recording"
+  - "browser_automation"
+  - "browser_thoughts"
+weavetab: ">=2.5.0-beta.4"
+---
+
+# Session Trails & Deterministic Macro Compilation
+
+When an agent executes an exploratory workflow (e.g. logging into a dashboard, navigating to analytics, setting date filters, and downloading a CSV), re-running that flow autonomously in the future should not require 15 reasoning steps.
+
+`browser_burst` with `compile_from_history: true` automatically converts recent successful session actions into a high-performance, deterministic execution script.
+
+---
+
+## 1. Compiling and Replaying Recent Actions (`browser_burst`)
+
+Replay recent successful actions directly in a single turn:
+
+```json
+{
+  "compile_from_history": true
+}
+```
+
+Or pass `dry_run: true` to inspect the compiled macro steps before running them:
+
+```json
+{
+  "compile_from_history": true,
+  "dry_run": true,
+  "history_limit": 15
+}
+```
+
+### Response Example:
+```json
+{
+  "success": true,
+  "steps_completed": 0,
+  "compiled_steps": [
+    { "tool": "browser_go", "args": { "url": "https://analytics.example.com" } },
+    { "tool": "browser_fill", "args": { "ref": "w:12", "value": "metrics" } },
+    { "tool": "click_and_wait", "args": { "ref": "w:15" } }
+  ],
+  "message": "compiled 3 macro steps from history"
+}
+```
+
+---
+
+## 2. Parameterizing Variable Inputs
+
+When `"parameterizeInputs": true` is passed:
+- Text inputs and dates entered during the exploratory session are replaced with named parameters.
+- Secrets entered via `browser_type_secret` are never hardcoded; they are replaced with environment variable or secret lookups.
+
+---
+
+## 3. Replaying Compiled Automations
+
+Compiled macros can be executed in sub-second time without LLM inference overhead using `browser_automation`:
+
+```json
+{
+  "macroId": "macro_8f7b2c",
+  "parameters": {
+    "startDate": "2026-09-01",
+    "endDate": "2026-09-03"
+  }
+}
+```
+
+---
+
+## 4. Emitting Operational Thoughts (`browser_thoughts`)
+
+Log agent rationale and internal reasoning directly to the Weavetab HUD and telemetry stream without bloating user chat responses:
+
+```json
+{
+  "thought": "Detected dynamic React hydration delay. Holding interaction until DOM mutation settles."
+}
+```
+