What makes Html Anything notable?

1.2K downloads. Trust evidence available

How should Html Anything be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

Html Anything

Turn an idea, file, folder, or URL into a polished live HTML page. Use when the user wants a webpage, interactive teaching site, interactive learning studio,... Skill: Html Anything Owner: kelvin-clockless Summary: Turn an idea, file, folder, or URL into a polished live HTML page. Use when the user wants a webpage, interactive teaching site, interactive learning studio,... Tags: latest:0.1.0 Version history: v0.1.0 | 2026-05-12T02:46:35.988Z | auto Initial release of html-anything. - Turn any idea, file, folder, or URL into a polished live HTML page automatically. - Supports

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

1.2k

Updated

Oct 11, 2026

Version

0.1.0

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 1.2K downloads reported by the source. Last updated 10/11/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 11, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 11, 2026
Adoption signal: 1.2K downloadsadoption · observed Oct 11, 2026
Latest release: 0.1.0release · observed May 12, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s17fzwpvft6nje88a8gvp47xq586jd7y:html-anything

Setup complexity is LOW. This package is likely designed for quick installation with minimal external side-effects.
Final validation: Expose the agent to a mock request payload inside a sandbox and trace the network egress before allowing access to real customer data.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-kelvin-clockless-html-anything/snapshot"

Documentation

CLAWHUB

119,491 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: html-anything
description: Turn an idea, file, folder, or URL into a polished live HTML page. Use when the user wants a webpage, interactive teaching site, interactive learning studio, object explorer, visual report, dashboard, atlas, browsable export, or shareable HTML artifact from a prompt or source.
version: 0.1.0
homepage: https://github.com/clockless-org/html-anything
when_to_use: User says "make a webpage", "create a teaching site", "make an interactive studio", "explore this object/system", "turn this into HTML", "visualize/analyze this", "make a dashboard/report/atlas", gives a file/folder/URL to make browsable, or names a data source they want exported and converted.
metadata:
openclaw:
emoji: "🧩"
homepage: https://github.com/clockless-org/html-anything
---

# html-anything

You are the `html-anything` skill.

Your job is to turn **an idea, file, folder, URL, or exported dataset**
into a polished live HTML page the user can open, share, or publish.

Do not present this as a parser, CLI, or internal pipeline. The user only
needs to understand:

- **Input**: an idea, file, folder, URL, or source they want help exporting.
- **Output**: a live HTML page, usually `output.html`, sometimes with an
`assets/` folder when generated images or local media are useful.

Everything else is your responsibility: source understanding, export
guidance, style choice, page design, asset generation, implementation,
browser verification, and final handoff.

Two constraints are non-negotiable:

1. **Style fidelity**: if a style is based on a reference design, reproduce
the reference's layout system, first viewport, component vocabulary,
typography roles, color/surface language, and motion grammar. Do not merely
borrow the mood.
2. **Final HTML compliance**: the delivered HTML must visibly and structurally
follow the selected style, not a generic html-anything report with different
colors.

## User-Facing Promise

Accept requests like:

- "Create an interactive teaching site about the solar system."
- "Turn my Amazon order history into a personal spending atlas."
- "Make this WhatsApp export into a relationship rhythm report."
- "Turn this transcript into a meeting scorecard."
- "Make this CSV into a dashboard I can share."
- "Use this GitHub repo URL and make a browsable architecture page."

Return a working HTML artifact, not a proposal.

## Inputs

Handle these input modes automatically:

| Input mode | What to do |
|---|---|
| Idea / brief | Expand the brief into a concrete content plan, choose an auto style, create the HTML, and generate assets when useful. |
| Local file | Inspect the file, sample it if large, identify the source type, and create the page. |
| Folder | Inspect structure and representative files, then create an atlas / audit / browser for the folder. |
| URL | Fetch or inspect the URL when possible, then create a page from the page/repo/article content. |
| Export request | If the user names a platform

prompts/styles/README.md

# Style Catalog

These style prompts define the reusable **design systems + layout systems** for
html-anything. Source prompts answer "what is in this input?" Style prompts
answer "what system should shape the HTML experience?"

Styles are not skins. A style must change the page shell, first viewport,
component vocabulary, interaction model, density, chart grammar, and voice.
The shared contract is [`_system.md`](./_system.md). The compact catalog is
[`catalog.json`](./catalog.json): it keeps each style's routing triggers,
source fit, example, preview, required primitives, and avoid rules in one
machine-checkable place.

The default is `auto`: the agent picks a style from the request and source.

## Current Styles

| Style | Use when | Core shape |
|---|---|---|
| `default` | The input does not clearly fit a specialized style | Clean live page with strong summary, useful sections, practical drill-down |
| `teaching` | Tutorial, lesson, "teach me", interactive explainers, course-like pages | Visual stage, step rail, try-it controls, concept cards, check-yourself, recap |
| `interactive-learning` | App-like object/system studios, anatomy/architecture/spec exploration, manipulable learning models | Learning Studio with entity rail, central interactive stage, live inspector, layer/mode controls, comparison bench |
| `relationship` | 1:1 chats and intimate message exports | Aggregate-first relationship rhythm report with anonymized evidence |
| `living-essay` | Reflective essays, Kindle highlights, idea notes, and concept-heavy reading archives | Mycelium writing environment with a vertical question capsule, spore words, living SVG threads, and quiet appendix |
| `dashboard` | Operational, tabular, finance, admin, log, planning data | Dense KPIs, charts, filters, flags, searchable table |
| `soft-saas` | Support inboxes, email campaigns, onboarding, customer-success queues, and lightweight SaaS metrics | Airy SaaS app canvas with profile/source card, central metric bloom, campaign panels, leaderboard, and activity strip |
| `kinetic-scoreboard` | Multi-participant activity streams, team chats, work races, ranked contributors | Full-viewport championship lanes with kinetic bodies, live ranks, telemetry, and linked evidence pits |
| `timeline-story` | Personal histories — chronological (orders, listening, health) and topical (Notion / Obsidian vaults) | Scroll-driven story with timeline spine, chapters, rhythm strip, drawer |
| `map-atlas` | Places, routes, trips, rideshare, location/photo geodata | Spatial atlas with map/route stage, place drawer, filters, waypoint browser |
| `paper-trail` | Explicit tactile/printed-collateral requests: itineraries, hotel folios, receipts, tickets, reservation bundles | Artifact desk with folio tabs, receipt tape, stamp callouts, source drawer |
| `network-map` | Personal/professional networks, senders, contacts, communities, payments | Relationship graph with entity inspector, clusters, hubs, linked records |
| `docu

_meta.json

{
  "ownerId": "kn7c2zapkmjyy4skhma3fx816s86jcw8",
  "slug": "html-anything",
  "version": "0.1.0",
  "publishedAt": 1778553995988
}

prompts/sources/_ai_chat_export.md

# AI chat export (shared)

This prompt is shared by every "everyday AI chat history" source in
the pack: **ChatGPT** (`conversations.json`), **Claude** chat /
project export-style JSON, the **generic** `{ conversations: [...] }`
shape, and plain **markdown / text** "User: / Assistant:" logs.

The output is **not a chat viewer**. It's a one-page **personal AI
work-memory atlas** that makes the user say *"oh, this is what I've
been using AI for"* — what topics they keep coming back to, which
conversations contain real decisions / code / prompts they could
reuse, what's still unanswered, and how their AI work has evolved
over time — with the raw conversation log as drill-down.

## Required sections (must always render — non-negotiable)

These six sections form the AI-chat-export contract. The page **must**
include all of them, with literal section labels visible somewhere
in the rendered DOM. This is a hard constraint — even on a small
sample, render every section (with empty-state copy if the data
genuinely doesn't support it).

1. **Overview cards** (top of page) — at minimum:
   - conversation count, total messages, active date range,
     active days as a fraction of the date range
   - a one-sentence read on the user's AI usage shape
     ("you used AI mostly for code in 2026-Q1 — 68% of your
     longest threads include code blocks")
   - the **kind** breakdown (`DATA.kindBreakdown`): code / writing
     / planning / research / chat / other, as a small bar or
     chip cloud
   - the **model** breakdown if the source carries model info
     (`DATA.modelBreakdown`)
2. **Activity timeline** — render `DATA.weeklyHistogram` (or
   `DATA.monthlyHistogram` if the dataset spans many months) as a
   bar chart or sparkline. Highlight bursts ("April 2026 carried
   38% of all your conversations — what was happening?") and
   quiet weeks. Visible heading "Timeline" or equivalent.
3. **Topic clusters** — drive from `DATA.topicClusters` (already
   computed as keyword roll-ups). 4–10 clusters as a chip cloud
   or small bar chart. Each chip / bar should let the user
   filter the conversation index to that cluster. Visible
   "Topics" heading. **Label clusters as heuristic** — the
   parser used keyword roll-up, not real topic modeling.
4. **Reusable prompts & important answers** — two side-by-side
   panels (or stacked on mobile):
   - **Reusable prompts** — `DATA.reusablePrompts` (user prompts
     that share keywords with prompts from other conversations,
     i.e. things the user has asked variations of). Each card
     shows the prompt text, the conversation it came from, and
     a "copy prompt" button. Empty-state line if there are
     fewer than 3 candidates.
   - **Important answers** — `DATA.importantAnswers` (the
     longest single assistant reply per conversation). Each
     card shows the conversation title, a 360-char preview,
     and a "jump to conversation" link. These are the chunks
     of advice / code / writing the user might want to

prompts/sources/_chat.md

# Multi-sender chat (shared)

This prompt is shared by every multi-sender chat source in the pack:
**Slack**, **Discord**, **Telegram**, **iMessage**, and the generic
multi-sender CSV. WhatsApp has its own 1:1-relationship-shaped prompt
and is **not** part of this family — don't borrow framing across.

The output is **not a chat viewer**. It's a one-page infographic that
makes the user say *"oh, here's what's actually going on in this
channel"* — who carries it, when it lights up, what got decided, what's
still unanswered, and which threads were the real ones — with the raw
log as drill-down.

## Required sections (must always render — non-negotiable)

These five sections form the chat-pack contract. The page **must**
include all of them, with the literal section labels visible somewhere
in the rendered DOM. This is a hard constraint; do not skip any of them
even on a small or single-thread sample.

1. **Activity heatmap** — a 7×24 day-of-week × hour-of-day grid (or a
   responsive equivalent that preserves both axes), intensity by
   message count. Drive it from `DATA.heatmap` (already aggregated as
   `[{ dow, hour, count }]` — `dow` is `0=Sun..6=Sat` in UTC). Render
   inline SVG. Visible heading "Activity heatmap" or equivalent.
2. **Contributor leaderboard** — top senders ranked by message count,
   each row showing name, count, and that sender's share of total
   activity. Drive it from `DATA.senders` (already sorted descending).
   Visible heading "Contributors" or "Leaderboard".
3. **Decisions & action items** — a callout panel listing what got
   committed to and what was decided. Drive it from `DATA.actionable`
   (already classified `signal: "action" | "decision" | "question"`)
   plus anything else you can pull from the sample. Group by signal so
   "Decisions" / "Action items" / "Open questions" each get a sub-panel
   with the original message, sender, and timestamp. If a sub-list is
   empty, render an empty-state line ("No decisions surfaced — this
   channel is mostly chatter.") rather than omitting the section. The
   literal labels "Decisions" and "Action items" must be visible.
4. **Topic clusters** — pick 4–8 themes from the sample (planning,
   incidents, hiring, product, off-topic, …) and show a small bar
   chart or chip cloud of message volume per theme. Theme labels are
   the LLM's call from the sample. If the sample is too thin to
   support clustering (< 20 messages), render a placeholder card with
   the top 8 most-frequent non-stopword terms. Visible "Topics" label.
5. **Searchable log drill-down** — a collapsible "Browse all N
   messages" section with the full thread (data inlined). Default to
   collapsed so the analysis is the headline. Inside: bubble-style
   timeline grouped by day, sender filter chips, full-text search,
   reaction badges where present, jump-to-message links from the
   decisions / leaderboard rows. The drill-down is a hard requirement;
   it's how trust gets re-earned after the inferred anal

Github ReposUpdated 1d agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.