Tools
Deaiify
By Em-dash exterminator for AI output. Ships as OpenClaw plugin + Claude Code Stop hook. The README is a Billy Mays infomercial. Yes, on purpose.
Install
openclaw plugin install deaiifyConfiguration Example
{ "rewriteTimeoutMs": 20000 }README
<p align="center">
<img src="assets/hero.png" alt="deAIify - SMASH AI PUNCTUATION! ONE SMALL CHANGE. HUGE IMPACT!" width="900" />
</p>
### An OpenClaw Plugin
---
## HI, BILLY MAYS HERE FOR deAIify!
ARE YOU TIRED of your LLM dropping em-dashes into every single response? Are they making your automated tweets look like a 19th century periodical and TANKING your engagement?
Does your AI assistant write like it swallowed a Victorian typewriter? Do your Slack bots sound like they're narrating a Dickens novel? Is every sentence interrupted by those PRETENTIOUS little horizontal lines that SCREAM "a robot wrote this"?
**Well BILLY MAYS HERE with deAIify!**
The ONLY OpenClaw plugin that doesn't just find-and-replace your dashes like some AMATEUR HOUR regex script. No sir. deAIify intercepts the ENTIRE RESPONSE and makes the LLM RESTRUCTURE IT. Like a disappointed parent returning a C-minus essay. "Do it again. DO IT RIGHT."
---
## WHAT DOES IT DO?
- **CATCHES** em-dashes (U+2014) and en-dashes (U+2013) BEFORE they reach your users
- **INTERCEPTS** the response via `before_agent_reply`, meaning the hook fires BEFORE delivery
- **SENDS IT BACK** to the LLM with a restructuring prompt that says "REWRITE THAT WITHOUT THE DASHES, PAL"
- **VERIFIES** the rewrite is sane (word count and length checks, because we're not animals)
- **SHIPS THE CLEAN VERSION** with actual restructured sentences, not some find-and-replace hackjob
This isn't character substitution. This is a FULL ARCHITECTURAL INTERVENTION. We don't put a band-aid on the dash. We send the whole response back to the FACTORY.
---
## v3: THE FORMULA, PERFECTED
**v1 was wrong:** string replacement swaps characters but leaves broken grammar. `Things like this -- might result in` becomes `Things like this. might result in` (lowercase m after period, BROKEN).
**v2 tried harder** but kept a regex-first mode that caused the same problem.
**v3 is the one.** LLM-first, every time. No regex fallback. No character swaps. JUST PROPER SENTENCES.
```
โโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโ
โ LLM writes โโโโโ>โ before_agent_ โโโโโ>โ Dashes found? โ
โ a response โ โ reply hook โ โ โ
โ โ โ intercepts it โ โ YES: REWRITE โ
โโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโโ โ NO: SHIP IT โ
โโโโโโโโโโฌโโโโโโโโโ
โ (dashes found)
v
โโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโ
โ runEmbedded โโโโโ>โ Verification โ
โ PiAgent sends โ โ gate: word โ
โ restructuring โ โ count + length โ
โ prompt to LLM โ โ checks pass? โ
โโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโฌโโโโโโโโโ
โ
v
โโโโโโโโโโโโโโโโโโโ
โ DELIVER CLEAN โ
โ HUMAN-SOUNDING โ
โ PROSE โ
โโโโโโโโโโโโโโโโโโโ
```
### THE MIRACLE FORMULA
**`before_agent_reply`**: The QUALITY INSPECTOR on the assembly line. Every assistant response passes through before it reaches your users. It scans for those sneaky Unicode dashes. If it finds one? The response gets pulled off the line and sent to the RESTRUCTURING DEPARTMENT (the LLM, with a prompt that says "eliminate these dashes, rephrase so the sentence flows naturally"). The LLM produces a clean version. The verification gate checks it didn't balloon in size. Then the properly rewritten version ships.
If anything goes wrong (LLM timeout, empty response, verification failure), the plugin **fails open** and delivers the original reply unchanged. No crashes. No stuck sessions. No drama.
It's like having a QUALITY CONTROL DEPARTMENT for your AI output, except it runs in MILLISECONDS and doesn't take lunch breaks!
---
## BUT WAIT! THERE'S MORE!
### Smart Code Detection
Content inside fenced code blocks and inline code is COMPLETELY IGNORED. Your code samples with Unicode dashes? Untouched. Your `--verbose` flags? Safe. We only target the PROSE, where dashes are crimes against readability.
### Verification Gate
The rewrite is rejected (and the original delivered unchanged) if:
- Word count drifts more than 10% from the original
- Total length expands more than 50%
The LLM is restructuring, not writing a novel. If it bloats the response, something went wrong and we fail safe.
### Configurable Timeout
```json
{ "rewriteTimeoutMs": 20000 }
```
Give the LLM more time if your model is slow, or tighten it up if you're running local. Default is 15 seconds because we believe in FAST RESULTS.
---
## ARE YOU TIRED OF...
...running `sed -i` on every output to scrub punctuation, only to break a hyphen in a CLI flag and SHIP A BUSTED COMMAND TO PRODUCTION?
...telling your LLM "no em-dashes please" in the system prompt and watching it CHEERFULLY IGNORE YOU? Like you suggested a vacation policy?
...begging the model to rewrite, only for it to substitute ` -- ` in there like you wouldn't NOTICE THE SAME RHYTHM?
...copy-pasting every single reply into a SEPARATE "scrub" tool because your agent stack has NO POST-PROCESSING LAYER? In TWENTY TWENTY SIX?!
...writing 47 follow-up messages to your agent ("remove the dash, no the OTHER dash, NO NOT THAT dash, the LONG ONE") just to send a clean email that doesn't SCREAM "a robot wrote this"?
...building a custom regex pipeline, only to discover you ALSO broke the inline code, the markdown tables, the CLI examples, AND your own will to live?
...running a SEPARATE Haiku pass on every output, paying for ANOTHER MODEL CALL just to scrub punctuation, watching your token bill BALLOON like a hot air balloon at the county fair?
...settling for output that SCREAMS "a robot wrote this" because the alternatives are TOO COMPLICATED, TOO SLOW, or TOO EXPENSIVE to wire up?
**STOP. JUST. STOP.**
You don't need a 12-step pipeline. You don't need a separate model. You don't need to retrain anything. You don't even need to RESTART YOUR AGENT.
YOU NEED ONE PLUGIN.
---
## JUST 2 EASY STEPS!
**STEP 1:** Install it!
```bash
openclaw plugin install deaiify
```
**STEP 2:** There is no step 2! It works out of the box with zero configuration!
But if you WANT to configure it:
```json
{
"plugins": {
"entries": {
"deaiify": {
"enabled": true,
"config": {
"rewriteTimeoutMs": 15000
}
}
}
}
}
```
But you DON'T HAVE TO. Defaults are ALREADY PERFECT.
**ZERO external runtime dependencies.** Just a peer dependency on `@openclaw/plugin-sdk`. That's it. No bloat. No node_modules swamp. Just PURE, UNADULTERATED dash destruction.
---
## BUT YOU SAY YOU USE CLAUDE CODE?!
**WELL HOLD THE PHONE, SAILOR!** deAIify is ALSO AVAILABLE as a Claude Code Stop hook!
Same product philosophy. Same architectural intervention. Same em-dash extermination. Just wired into Claude Code's hook system instead of OpenClaw's. Scans the assistant's Stop event, blocks the turn from ending if it spots a long line or two short lines in prose, forces a rewrite. Loop-safe. Fails open. ZERO drama.
**[Get the Claude Code installer here](claude-code/README.md)**
ONE PRODUCT. TWO HARNESSES. ZERO DASHES.
---
## DETECTION TARGETS
Only two Unicode characters. That's it. Surgical precision.
- `\u2014`: Unicode em-dash (U+2014)
- `\u2013`: Unicode en-dash (U+2013)
Hyphen-minus (U+002D, the regular `-` character) is NEVER touched. Double-hyphens (`--`) in output are fine and expected. Your code is safe. Your CLI flags are safe. Only the PROSE DASHES get the treatment.
---
## TESTIMONIALS*
> "I used to spend 3 hours a day manually removing em-dashes from my bot's output. Now I spend that time with my family."
> - Definitely A Real Person
> "deAIify saved my marriage."
> - Also Very Real
> "My engagement went up 400% after I stopped sounding like a Victorian telegraph operator."
> - Absolutely Not Made Up
*\*These testimonials are as real as the em-dashes in your LLM output are necessary (they're not).*
---
## SECURITY AND PRIVACY
- No message content is stored to disk. Rewrite prompts are ephemeral and scoped to the current session.
- Embedded LLM rewrite uses the session-default model. No external API calls beyond what your agent already uses.
- Fail-open design: every error path delivers the original reply unchanged.
- Single hook path. No config-driven code execution. No eval. No funny business.
---
## THE FINE PRINT
- Zero external runtime deps
- Peer dep on `@openclaw/plugin-sdk`
- TypeScript all the way down
- One hook, one mission, zero dashes
- Works with any OpenClaw-compatible agent
---
```
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ โ
โ STOP LIVING IN DASH HELL. โ
โ โ
โ INSTALL deAIify TODAY AND NEVER SEE โ
โ AN EM-DASH AGAIN.* โ
โ โ
โ openclaw plugin install deaiify โ
โ โ
โ *results may vary. โ
โ not responsible for existential crises caused by โ
โ realizing how many dashes your LLM was using. โ
โ โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
```
---
*If you call in the next 15 minut
... (truncated)
tools
Comments
Sign in to leave a comment