@anysiteio/agent-skills 1.4.0 → 2.0.1

package/skills/anysite-market-research/SKILL.md

@@ -26,32 +26,54 @@ Comprehensive market research using Y Combinator, SEC, social media, and web dat
 - ✅ **Twitter/X**: Market pulse, news, influencer opinions
 - ✅ **Web Scraping**: Company websites, industry reports, market data
 
+## v2 MCP Tool Interface
+
+All data fetching uses the universal `execute()` meta-tool. Always call `discover(source, category)` first if you need to verify endpoint names or parameters.
+
+**Core workflow**:
+1. `execute(source, category, endpoint, params)` -- fetch data (returns first page + `cache_key`)
+2. `get_page(cache_key, offset, limit)` -- paginate through remaining results
+3. `query_cache(cache_key, conditions, sort_by, aggregate, group_by)` -- filter/sort/aggregate cached data without new API calls
+4. `export_data(cache_key, format)` -- export to CSV, JSON, or JSONL for deliverables
+
+**Error handling**: check response for `llm_hint` field -- it contains actionable guidance when calls fail or return partial data.
+
 ## Quick Start
 
 **Step 1: Define Research Scope**
 
 Choose focus:
-- Startup ecosystem: `search_yc_companies`
-- Public companies: `sec_search_companies`
-- Industry sentiment: `search_reddit_posts`, `search_twitter_posts`
-- Company intelligence: `search_linkedin_companies`
+- Startup ecosystem: `execute("yc", "search", "search", {"query": ...})`
+- Public companies: `execute("sec", "search", "search", {"query": ...})`
+- Industry sentiment: `execute("reddit", "search", "search", {"query": ...})`, `execute("twitter", "search", "search_users", {"query": ...})`
+- Company intelligence: `execute("linkedin", "search", "search_companies", {...})`
 
 **Step 2: Gather Data**
 
 Execute searches:
 ```
 # Startup research
-search_yc_companies(industries=["fintech"], batches=["W24", "S23"])
+execute("yc", "search", "search", {"query": "fintech", "batch": "W24,S23"})
 
 # Public company research
-sec_search_companies(entity_name="tech company", forms=["10-K"])
+execute("sec", "search", "search", {"query": "tech company"})
 
 # Market sentiment
-search_reddit_posts(query="fintech trends", count=100)
+execute("reddit", "search", "search", {"query": "fintech trends"})
+→ use get_page(cache_key, offset, limit) to collect up to 100 results
 ```
 
 **Step 3: Analyze Results**
 
+Use `query_cache()` to slice data without re-fetching:
+```
+# Count startups by category
+query_cache(cache_key, aggregate={"field": "category", "function": "count"})
+
+# Filter high-engagement posts
+query_cache(cache_key, conditions=[{"field": "score", "operator": ">", "value": 50}], sort_by={"field": "score", "order": "desc"})
+```
+
 Extract insights:
 - Market size indicators
 - Competitive landscape
@@ -61,7 +83,7 @@ Extract insights:
 
 **Step 4: Synthesize Findings**
 
-Deliver:
+Use `export_data(cache_key, "csv")` or `export_data(cache_key, "json")` to deliver:
 - Market opportunity assessment
 - Competitive analysis
 - Trend identification
@@ -77,17 +99,17 @@ Deliver:
 
 1. **Find Startups**
 ```
-search_yc_companies(
-  industries=["fintech"],
-  batches=["W24", "S23", "W23", "S22"],
-  count=100
-)
+execute("yc", "search", "search", {
+  "query": "fintech",
+  "batch": "W24,S23,W23,S22"
+})
+→ use get_page(cache_key, offset, limit) to paginate through all results
 ```
 
 2. **Categorize by Focus**
 ```
 For each startup:
-  get_yc_company(company)
+  execute("yc", "company", "get", {"slug": company_slug})
 
 Group by:
 - Payments
@@ -96,6 +118,9 @@ Group by:
 - Banking
 - Insurance
 - B2B fintech tools
+
+Or use query_cache to group:
+  query_cache(cache_key, group_by="category")
 ```
 
 3. **Analyze Patterns**
@@ -105,18 +130,21 @@ Identify:
 - Team size distribution
 - Geographic concentration
 - Common tech stacks (from job postings)
+
+Use query_cache for aggregation:
+  query_cache(cache_key, aggregate={"field": "team_size", "function": "avg"})
 ```
 
 4. **Research Traction**
 ```
 For promising startups:
-  search_linkedin_companies(keywords=startup_name)
+  execute("linkedin", "search", "search_companies", {"keywords": startup_name})
   → Check employee growth
 
-  search_twitter_posts(query=startup_name)
+  execute("twitter", "search", "search_users", {"query": startup_name})
   → Check social presence and buzz
 
-  parse_webpage(startup_website)
+  execute("webparser", "parse", "parse", {"url": startup_website})
   → Check positioning and features
 ```
 
@@ -136,6 +164,8 @@ Compare:
 - Market gaps identified
 - Competitive intensity by segment
 
+Use `export_data(cache_key, "csv")` to deliver the startup list as a spreadsheet.
+
 ### Workflow 2: Public Company Competitive Analysis
 
 **Scenario**: Research public competitors in cloud infrastructure
@@ -144,17 +174,16 @@ Compare:
 
 1. **Find Companies**
 ```
-sec_search_companies(
-  entity_name="cloud",
-  forms=["10-K", "10-Q"],
-  count=50
-)
+execute("sec", "search", "search", {
+  "query": "cloud"
+})
+→ use get_page(cache_key, offset, limit) to collect up to 50 results
 ```
 
 2. **Get Financial Data**
 ```
 For each company:
-  sec_document(document_url)
+  execute("sec", "document", "get", {"url": document_url})
 
 Extract:
 - Revenue and growth
@@ -185,14 +214,17 @@ Compare year-over-year:
 
 5. **Supplement with Social Intel**
 ```
-search_linkedin_companies(keywords=company_name)
+execute("linkedin", "search", "search_companies", {"keywords": company_name})
 → Employee count, hiring patterns
 
-get_linkedin_company_posts(urn)
-→ Strategic messaging
+execute("linkedin", "company", "get", {"company": company_urn})
+→ Company details and strategic messaging
 
-search_reddit_posts(query=company_name)
+execute("reddit", "search", "search", {"query": company_name})
 → Customer sentiment
+
+Use query_cache to filter sentiment:
+  query_cache(cache_key, conditions=[{"field": "text", "operator": "contains", "value": "review"}])
 ```
 
 **Expected Output**:
@@ -202,6 +234,8 @@ search_reddit_posts(query=company_name)
 - Growth trajectories
 - Market opportunities
 
+Use `export_data(cache_key, "json")` for structured competitive data.
+
 ### Workflow 3: Industry Trend Analysis
 
 **Scenario**: Understand AI/ML market evolution
@@ -210,23 +244,25 @@ search_reddit_posts(query=company_name)
 
 1. **YC Startup Trends**
 ```
-search_yc_companies(
-  query="AI OR machine learning OR artificial intelligence",
-  count=200
-)
+execute("yc", "search", "search", {
+  "query": "AI OR machine learning OR artificial intelligence"
+})
+→ use get_page(cache_key, offset, limit) to collect up to 200 results
 
 Group by batch to see:
 - Trend over time
 - Focus area shifts
 - Team size changes
+
+query_cache(cache_key, group_by="batch", aggregate={"field": "id", "function": "count"})
 ```
 
 2. **Public Market Signals**
 ```
-sec_search_companies(
-  entity_name="artificial intelligence",
-  count=50
-)
+execute("sec", "search", "search", {
+  "query": "artificial intelligence"
+})
+→ use get_page(cache_key, offset, limit) to collect up to 50 results
 
 Check 10-K mentions of:
 - "AI" or "machine learning" frequency
@@ -236,24 +272,25 @@ Check 10-K mentions of:
 
 3. **Community Sentiment**
 ```
-search_reddit_posts(
-  query="AI trends 2026",
-  count=100
-)
+execute("reddit", "search", "search", {
+  "query": "AI trends 2026"
+})
+→ use get_page(cache_key, offset, limit) to collect up to 100 results
 
 Analyze for:
 - Excitement vs. concern
 - Adoption barriers
 - Use case validation
 - Technology maturity
+
+query_cache(cache_key, sort_by={"field": "score", "order": "desc"})
 ```
 
 4. **Professional Discussion**
 ```
-search_linkedin_posts(
-  keywords="artificial intelligence",
-  count=50
-)
+execute("linkedin", "post", "search_posts", {
+  "keywords": "artificial intelligence"
+})
 
 Check:
 - Industry adoption
@@ -265,11 +302,8 @@ Check:
 5. **Web Intelligence**
 ```
 For key AI companies:
-  parse_webpage(website + "/blog")
-→ Technology updates, product launches
-
-get_sitemap(website)
-→ Content focus areas
+  execute("webparser", "parse", "parse", {"url": website + "/blog"})
+  → Technology updates, product launches
 ```
 
 **Expected Output**:
@@ -279,42 +313,57 @@ get_sitemap(website)
 - Opportunity identification
 - Risk assessment
 
-## MCP Tools Reference
+Use `export_data(cache_key, "csv")` for trend data tables.
+
+## MCP Tools Reference (v2)
+
+### Data Fetching
+- `execute(source, category, endpoint, params)` -- Universal data fetcher; always returns `cache_key`
+
+### Pagination
+- `get_page(cache_key, offset, limit)` -- Load additional pages from a previous execute()
+
+### Analysis
+- `query_cache(cache_key, conditions, sort_by, aggregate, group_by)` -- Filter, sort, and aggregate cached data
+
+### Export
+- `export_data(cache_key, format)` -- Export to CSV, JSON, or JSONL; returns download URL
 
 ### Y Combinator Research
-- `search_yc_companies` - Find startups by industry, batch, filters
-- `get_yc_company` - Get detailed company profile
-- `search_yc_founders` - Research founders
+- `execute("yc", "search", "search", {"query": ...})` -- Find startups by industry, batch, filters
+- `execute("yc", "company", "get", {"slug": ...})` -- Get detailed company profile
 
 ### SEC Research
-- `sec_search_companies` - Find public companies and filings
-- `sec_document` - Get full document content
+- `execute("sec", "search", "search", {"query": ...})` -- Find public companies and filings
+- `execute("sec", "document", "get", {"url": ...})` -- Get full document content
 
 ### Social Intelligence
-- `search_reddit_posts` - Community insights and sentiment
-- `search_twitter_posts` - Real-time market pulse
-- `search_linkedin_posts` - Professional trends
+- `execute("reddit", "search", "search", {"query": ...})` -- Community insights and sentiment
+- `execute("twitter", "search", "search_users", {"query": ...})` -- Real-time market pulse
+- `execute("linkedin", "post", "search_posts", {"keywords": ...})` -- Professional trends
 
 ### Company Intelligence
-- `search_linkedin_companies` - Find companies
-- `get_linkedin_company` - Company details
-- `parse_webpage` - Extract website data
+- `execute("linkedin", "search", "search_companies", {"keywords": ...})` -- Find companies
+- `execute("linkedin", "company", "get", {"company": ...})` -- Company details
+- `execute("webparser", "parse", "parse", {"url": ...})` -- Extract website data
 
 ### Market Discovery
-- `duckduckgo_search` - General web research
-- `get_sitemap` - Comprehensive website analysis
+- Use `discover(source, category)` to explore available endpoints for any source
+- `execute("webparser", "parse", "parse", {"url": ...})` -- Scrape any URL for market data
+
+**Note**: Crunchbase endpoints are disabled in v2. Use LinkedIn company search and Y Combinator data as alternatives for company research.
 
 ## Market Analysis Frameworks
 
 **TAM/SAM/SOM Analysis**:
 ```
 Total Addressable Market (TAM):
-- Count YC companies in category × avg market size
+- Count YC companies in category x avg market size
 - SEC filing market size mentions
-- Industry reports (web scraping)
+- Industry reports via execute("webparser", "parse", "parse", {"url": report_url})
 
 Serviceable Addressable Market (SAM):
-- Filter by geography, segment
+- Filter by geography, segment using query_cache()
 - LinkedIn company search by ICP
 - YC companies by batch/stage
 
@@ -326,7 +375,7 @@ Serviceable Obtainable Market (SOM):
 
 **Porter's Five Forces**:
 ```
-Using anysite data:
+Using anysite v2 data:
 
 1. Competitive Rivalry:
    - YC startups in space
@@ -360,12 +409,12 @@ Using anysite data:
 - Opportunity identification
 - Strategic recommendations
 
-**CSV Export**:
+**CSV Export** (via `export_data(cache_key, "csv")`):
 - Company list with metrics
 - Market segmentation data
 - Trend indicators
 
-**JSON Export**:
+**JSON Export** (via `export_data(cache_key, "json")`):
 - Complete research data
 - Time-series analysis
 - Cross-platform correlations

package/skills/anysite-mcp/SKILL.md

@@ -0,0 +1,128 @@
+---
+name: anysite-mcp
+description: How to use the anysite MCP server effectively - the universal meta-tools (discover, execute, get_page, query_cache, export_data), the source map for GTM signals (funding, hiring, tech stack, reviews, news, launches), email finding cascades, and cost-aware calling patterns. Consult this before any anysite data work. Use when unsure which source or endpoint covers a data need, how to paginate or re-filter cached results, or how to combine sources into a signal chain.
+---
+
+# Anysite MCP — usage guide
+
+The anysite MCP exposes hundreds of data sources through five universal meta-tools. This skill
+is the map: how to call them, which sources cover which GTM need, and how to not waste credits.
+
+## The five meta-tools
+
+| Tool | Purpose | Credits |
+|---|---|---|
+| `discover(source, category)` | List endpoints + exact params for a source/category | free |
+| `execute(source, category, endpoint, params)` | Run an endpoint; returns first 10 items + `cache_key` | paid |
+| `get_page(cache_key, offset, limit)` | Page through a cached result | free |
+| `query_cache(cache_key, conditions, sort_by, sort_order, aggregate, group_by, limit, offset)` | Filter/sort/aggregate cached data with SQL-like ops | free |
+| `export_data(cache_key, format)` | Export cached data (CSV/JSON) | free |
+
+### Rules that prevent 90% of failures
+
+1. **Always `discover` before `execute`.** Endpoint names and params are not guessable, and a
+   wrong source name returns the full source list — a wrong guess self-corrects for free.
+   `execute` takes the endpoint NAME exactly as discover returns it (`products_reviews`),
+   never a REST path segment (`reviews`) — resolution is an exact-match lookup.
+2. **Never guess identifiers.** LinkedIn aliases, URNs, Crunchbase aliases, Greenhouse board
+   tokens are unpredictable. Resolve them through the search endpoint of the same source first.
+3. **Re-use the cache.** `execute` returns a `cache_key`; further filtering, sorting, counting
+   and paging of that result is free. Never re-run `execute` to look at the same data twice.
+4. **Cheap-first cascade.** When several endpoints can answer, call the cached/DB one first
+   (`*/db/*`, `*sql*` endpoints, ~1 credit) and the live one only for the remainder.
+5. **Estimate volume before bulk runs.** `N targets × credits-per-call`. Say the number to the
+   user before launching anything above ~100 calls.
+6. **Avoid `gdelt`** — it has repeatedly timed out in practice. Use techmeme or google news
+   instead.
+
+## GTM source map
+
+**Company discovery (bulk):**
+- `linkedin/search/search_sql_companies` — the workhorse. Up to 1000 companies per call with
+  DSL filters (keywords, industry_name, employee_count_min/max, country_hq, founded_on_min/max,
+  has_website). Also does batch lookup by `urn` list and search by `website` — use it to
+  resolve domains from a CRM into LinkedIn company records.
+- `crunchbase/db/db_search` — filters by funding stage, last funding date, investors,
+  employee range; count ≤100, dates as Unix timestamps. 1 credit/result. Response includes
+  `funding_rounds[]`, `leadership_hires[]`, `layoffs[]`, `news[]`, `technologies[]`,
+  `employees[]`.
+- `crunchbase/search` (live, 20cr/50) — adds `hiring`, `event`, `spotlight`,
+  `shares_investors_with`, `it_spend_*`, `revenue_*`, `valuation_*` filters. Check discover
+  for its date format — it differs from db_search.
+- `yc/search/search_companies`, `betalist`, `tracxn/companies/companies_search` —
+  early-stage supplements (check discover for exact endpoint names before calling).
+
+**Company detail:** `crunchbase/company` (by alias — resolve via `crunchbase/search` first),
+`linkedin/company`. Note: `owler` endpoints need an owler alias and its search has no
+name/keyword parameter — not usable for looking up a named account.
+
+**People:** `linkedin/search/search_users` (use `job_title` + `current_company` or
+`company_keywords`; never bare `keywords` alone — returns empty), `linkedin/user` (full
+profile, needs alias/URL/URN — never guess the alias), `linkedin/user/user_posts`,
+`user_experience`, `user_comments`.
+
+**Email finding (cascade, cheap → expensive):**
+1. `linkedin/user/user_email` — batch up to 10 profiles, cheap, low yield.
+2. `linkedin/user/find_email_by_url` — by vanity URL, high yield but expensive (50cr).
+   **May be disabled on the server** — trust `discover("linkedin", "user")`: if it is not
+   listed there, it does not exist; stop at step 1 and say so honestly.
+3. No email found → keep the lead anyway; CRM contact upserts match by `linkedin_url` too
+   (but note: creating a NEW contact requires an email — no email means update-only).
+
+**Reverse lookup (email → person):** `linkedin/email/email_sql_user` (cached DB) →
+`linkedin/email/email_user` (live) for the remainder.
+
+**Hiring signals:**
+- `linkedin/search/search_jobs` — by company; works for any company. The `company` param
+  takes `[{"type": "company", "value": "<numeric id>"}]` — extract the id from the
+  `fsd_company:<id>` URN returned by `search_companies` (raw URN strings are not accepted).
+- `greenhouse/jobs/jobs_search {board_token, count}` — full descriptions via `content=true`;
+  `ashby/jobs/jobs_search {board_name, count}` — descriptions always included. Both need the
+  company slug; 412 = wrong token, fall back to linkedin jobs.
+- `glassdoor` (resolve employer id via `companies_search` first), `builtin`, `adzuna` —
+  supplements; `blind/layoffs/layoffs_search` for layoffs.
+
+**Tech stack:** `wappalyzer/technologies` — technology slug → who uses it (`top_websites`
+sample), category alternatives (`alternatives[]`), country/language breakdown. Note: it is a
+sample, not an exhaustive site list.
+
+**Software reviews:** `g2/products/products_search` (search only),
+`capterra/products/products_reviews` (includes `switched_from[]` and `switching_reason` —
+direct competitor-switch evidence), `trustradius` and `getapp` `products_reviews`,
+`gartner/products` — competitor review mining. Employer sentiment:
+`glassdoor/companies/companies_ratings` (employer id via `companies_search`), `kununu`,
+`comparably`, `blind/companies/companies_reviews`.
+
+**News & mentions:** `techmeme/stories/stories_search {keyword, count}` (archive) and
+`stories_front_page`; `google/news/news_articles_search`;
+`linkedin/search/search_posts` (keyword or `mentioned` company URN; `date_posted` accepts
+only past-24h / past-week / past-month); `reddit`, `hackernews`, `twitter`, `bluesky` for
+community chatter; `substack`/`medium` for content signals.
+
+**Launches & products:** `producthunt/launches/launches_search`,
+`producthunt/products/products_alternatives`, `products_reviews`; `indiehackers`,
+`kickstarter`/`indiegogo` for niche ICPs.
+
+**Web fallback:** `webparser/parse` (static pages) → `webparser/render` (JS-rendered).
+Covers any URL when no named source fits. Web search: `duckduckgo/search`, `brave/search`.
+
+## Combining into signal chains
+
+The standard pattern for account signals (used by the crm-signals skill):
+
+```
+company name/domain
+  → crunchbase/search (resolve alias, once; cache it)
+  → crunchbase/company → funding_rounds, leadership_hires, news, layoffs
+  → linkedin search_jobs(company urn) → what they hire for
+  → linkedin search_posts(company name, past-month) → mentions
+```
+
+Stack signals: one signal is a guess, 2–3 signals within ~30 days is a pattern worth acting on.
+
+## Working with CRM
+
+CRM read/write goes through the `crm_*` tools, NOT through execute. Before any CRM write,
+consult the `anysite-crm-profile` skill (field mapping law) and the Writing rules in
+`anysite-crm-setup`. The server enforces fill-blank policy, protected fields and write logging
+regardless of what you pass.

package/skills/anysite-mcp-migration/SKILL.md

@@ -117,14 +117,25 @@ Replace each old tool call using this mapping:
 
 If the input references a tool name **not in the mapping above**:
 
-1. Try to infer the source and category from the tool name
-2. Add a `discover()` call before the `execute()`:
-   ```
-   Use discover("{source}", "{category}") to find available endpoints and params.
-   Then use execute("{source}", "{category}", "{endpoint}", {params}).
-   ```
-
-**Important:** Only add `discover()` when the exact endpoint or params are unknown. If the mapping above covers it, use `execute()` directly — no discover needed.
+1. Try to infer the source and category from the tool name (e.g., `get_instagram_user_friendships` → source `"instagram"`, category `"user"` or `"friendship"`)
+2. **IMPORTANT: Actually call `discover()` yourself right now** — do NOT leave placeholder `{endpoint}` in the migrated output. Run `discover("{source}", "{category}")` via the MCP tool to get the real endpoint names and parameter schemas.
+3. If the first category guess returns "Category not found", try alternative categories (e.g., if `"friendship"` fails, try `"user"` — the endpoint may be nested under a different category)
+4. Once you get the real endpoint list from `discover()`, use the exact endpoint name and params in the migrated `execute()` call
+
+**Example — resolving an unknown tool:**
+```
+Old tool: get_instagram_user_friendships(user, type, count)
+→ Not in mapping table
+→ You call: discover("instagram", "friendship") → error "Category not found"
+→ You call: discover("instagram", "user") → returns endpoints including "user_friendships"
+→ Migrated: execute("instagram", "user", "user_friendships", {"user": "...", "count": 100, "type": "followers"})
+```
+
+**Rules:**
+- NEVER leave `discover()` as a placeholder instruction in the final migrated skill. The migrated output must contain exact `execute()` calls with real endpoint names and params.
+- Only include `discover()` in the migrated skill text if the skill's workflow genuinely needs runtime discovery (e.g., the skill works with user-specified sources where the endpoint can't be known at migration time).
+- If the mapping above covers the tool, use `execute()` directly — no discover needed.
+- Run discover for ALL sources and categories used by the skill to verify that endpoint names and params in the mapping table are still accurate.
 
 ### Step 5: Add v2 Capabilities