alchemy-writing 0.1.0__tar.gz

alchemy_writing-0.1.0/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: alchemy-writing
+Version: 0.1.0
+Summary: Turn AI prose into human-quality writing. A drop-in ruleset that stops your coding agent from writing like an LLM.
+Author-email: fernforge <fernforgehq@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/fernforge/alchemy
+Project-URL: Repository, https://github.com/fernforge/alchemy
+Project-URL: Bug Tracker, https://github.com/fernforge/alchemy/issues
+Keywords: ai,llm,writing,prose,humanize,claude,cursor,agents,style-guide,rules
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Text Processing
+Classifier: Topic :: Software Development :: Documentation
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# alchemy-writing
+
+Turn AI prose into writing that reads like a person wrote it. This is the Python
+distribution of [Alchemy](https://github.com/fernforge/alchemy) — a small ruleset you hand
+your coding agent so the docs, READMEs, and replies it writes stop carrying the tell-tale
+LLM patterns.
+
+## Install
+
+```bash
+pip install alchemy-writing
+alchemy init
+```
+
+`alchemy init` writes `ALCHEMY.md` into your project and links it from your `CLAUDE.md`,
+`AGENTS.md`, or `.cursorrules` if one exists. Your agent reads the rules whenever it writes
+after that.
+
+Print the rules instead of writing them:
+
+```bash
+alchemy print
+```
+
+Or pull them into your own code:
+
+```python
+import alchemy_writing
+print(alchemy_writing.rules())
+```
+
+## What's in it
+
+The rules are grounded in documented AI-writing tells: Wikipedia's "Signs of AI writing,"
+the Kobak et al. study on words that spiked in research papers after ChatGPT, and Pangram's
+phrase-frequency data. They cover the banned constructions, the fingerprint vocabulary, the
+punctuation tells led by em-dash overuse, and a self-check the agent runs over its own prose.
+
+Full project, including the npm package and MCP server: https://github.com/fernforge/alchemy
+
+## License
+
+MIT

alchemy_writing-0.1.0/README.md

@@ -0,0 +1,43 @@
+# alchemy-writing
+
+Turn AI prose into writing that reads like a person wrote it. This is the Python
+distribution of [Alchemy](https://github.com/fernforge/alchemy) — a small ruleset you hand
+your coding agent so the docs, READMEs, and replies it writes stop carrying the tell-tale
+LLM patterns.
+
+## Install
+
+```bash
+pip install alchemy-writing
+alchemy init
+```
+
+`alchemy init` writes `ALCHEMY.md` into your project and links it from your `CLAUDE.md`,
+`AGENTS.md`, or `.cursorrules` if one exists. Your agent reads the rules whenever it writes
+after that.
+
+Print the rules instead of writing them:
+
+```bash
+alchemy print
+```
+
+Or pull them into your own code:
+
+```python
+import alchemy_writing
+print(alchemy_writing.rules())
+```
+
+## What's in it
+
+The rules are grounded in documented AI-writing tells: Wikipedia's "Signs of AI writing,"
+the Kobak et al. study on words that spiked in research papers after ChatGPT, and Pangram's
+phrase-frequency data. They cover the banned constructions, the fingerprint vocabulary, the
+punctuation tells led by em-dash overuse, and a self-check the agent runs over its own prose.
+
+Full project, including the npm package and MCP server: https://github.com/fernforge/alchemy
+
+## License
+
+MIT

alchemy_writing-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "alchemy-writing"
+version = "0.1.0"
+description = "Turn AI prose into human-quality writing. A drop-in ruleset that stops your coding agent from writing like an LLM."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [{ name = "fernforge", email = "fernforgehq@gmail.com" }]
+keywords = ["ai", "llm", "writing", "prose", "humanize", "claude", "cursor", "agents", "style-guide", "rules"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Topic :: Text Processing",
+  "Topic :: Software Development :: Documentation",
+]
+
+[project.urls]
+Homepage = "https://github.com/fernforge/alchemy"
+Repository = "https://github.com/fernforge/alchemy"
+"Bug Tracker" = "https://github.com/fernforge/alchemy/issues"
+
+[project.scripts]
+alchemy = "alchemy_writing.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+alchemy_writing = ["ALCHEMY.md"]

alchemy_writing-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

alchemy_writing-0.1.0/src/alchemy_writing/ALCHEMY.md

@@ -0,0 +1,58 @@
+# Alchemy — write like a human, not an LLM
+
+Rules for an AI writing prose for people: docs, READMEs, comments, commits, emails,
+replies. Goal: text a sharp person would write — specific, uneven, unpadded. Not text that
+performs sounding human. Applies to prose, not code.
+
+**The meta-rule:** no single word or dash proves AI. The tell is *density* — many of these
+clustered, plus flat, evenly-weighted texture. Weight co-occurrence over any one hit, and
+never strip a word that's genuinely the right one.
+
+## Banned constructions
+- **"Not just X, it's Y"** / "It's not about A — it's about B." Empty contrast. Say what it is.
+- **"No X. No Y. Just Z."** staccato trios. And rule-of-three flourishes: "fast, reliable, scalable."
+- **Hollow elevation:** "game changer," "next level," "unlock the potential," "transform how you," "take it to the next level."
+- **Throat-clearing openers:** "In today's fast-paced world," "In the ever-evolving landscape of," "In the realm of," "At its core," "Now more than ever."
+- **Significance inflation:** "stands as a testament to," "plays a crucial role," "serves as a powerful reminder," "a rich tapestry of," "navigating the complexities of," "harness the power of."
+- **Hedge stems:** "It's important to note," "It's worth mentioning," "When it comes to," "That being said."
+- **Recap closers:** "In conclusion," "Ultimately," "All in all," "At the end of the day," "There you have it."
+- **Assistant outro:** "Hope this helps!" "Feel free to reach out," "Let me know if you have questions!"
+- **Leaked-AI artifacts (dead giveaways):** "As an AI language model," "Certainly!" "I cannot," "As of my last update," "Great question!"
+- **Restating the prompt** before answering it.
+
+## Banned words
+delve, underscore, showcase, tapestry, testament, intricate, meticulous, pivotal, realm,
+landscape (abstract), boasts, garner, groundbreaking, multifaceted, seamless, robust,
+leverage, harness, unleash, unlock, elevate, embark, foster, navigate (figurative), vibrant,
+beacon, cornerstone, burgeoning.
+
+**Ration hard** (tell when stacked): comprehensive, powerful, cutting-edge, innovative,
+transformative, holistic, nuanced, streamline, empower, facilitate, resonate, ensure,
+utilize ("use"), "in order to" ("to"). Transitions (Moreover, Furthermore, Additionally,
+Notably) — one or two per piece, max.
+
+The fix is never a synonym — it's a concrete fact. Not "robust" but "handles 10k req/sec."
+
+## Punctuation and formatting
+- **Em-dashes — the loudest tell.** Most-cited but least reliable, so the giveaway is high *density* of pristine, correctly-spaced dashes. Use rarely; prefer a period, comma, or parentheses. More than one in a few paragraphs is too many.
+- **Smart/curly quotes** read as machine-set in casual or plain-text contexts. Use straight quotes (`'` `"`) unless the medium is typeset prose.
+- **Emoji:** at most one, and only in genuinely casual writing. None in docs, READMEs, commits, or headers. Never as bullets (✅ 🚀 ✨).
+- **Bold:** real labels and warnings only. No **bolded-lead-in bullets** ("**Speed:** it's fast").
+- Sentence case headers, not Title Case. No header on every short answer.
+
+## Substance
+- Name the specific. No vague attribution — "studies show," "experts say," "research suggests" — you can't source. Numbers, versions, commands.
+- Don't dodge "is/are" with "serves as," "stands as," "represents."
+- Cut sentences true of almost anything ("good docs matter"). Cut the weakest 20%. Take a stance instead of listing both sides.
+
+## Voice
+- Vary sentence length — uniform medium-length cadence is a tell. A short one lands. Then a longer one carrying the qualification. Then short.
+- Contractions are normal. "You" is fine; "one might consider" is not.
+- Don't perform enthusiasm — no "exciting/amazing" on ordinary things. A little dry opinion reads human.
+
+## Before returning, check
+Throat-clearing opener? Recap closer? Banned words/constructions clustered? Em-dash density?
+Suspicious symmetry (equal paragraphs, every section three bullets)? Could someone who knows
+the topic tell a person wrote it? Lead with the one specific, slightly opinionated thing only
+someone who did the work would say. The point isn't beating a detector — it's writing
+something worth reading.

alchemy_writing-0.1.0/src/alchemy_writing/__init__.py

@@ -0,0 +1,16 @@
+"""Alchemy — human-quality writing rules for AI agents.
+
+The rules themselves live in ALCHEMY.md next to this module. `rules()` returns
+their text; the `alchemy` command-line tool writes them into a project.
+"""
+from importlib import resources
+
+__version__ = "0.1.0"
+
+
+def rules() -> str:
+    """Return the full text of the Alchemy ruleset."""
+    return resources.files(__package__).joinpath("ALCHEMY.md").read_text(encoding="utf-8")
+
+
+__all__ = ["rules", "__version__"]

alchemy_writing-0.1.0/src/alchemy_writing/cli.py

@@ -0,0 +1,89 @@
+"""Command-line tool: install the Alchemy ruleset into the current project."""
+import sys
+from pathlib import Path
+
+from . import rules
+
+POINTER = (
+    "\n## Writing style\n\n"
+    "When writing prose (docs, READMEs, comments, commits, replies), follow the rules in "
+    "`ALCHEMY.md` in this repo: write human-quality text, avoid the tell-tale LLM patterns.\n"
+)
+
+# Agent config files that take a natural-language pointer. First existing one wins.
+AGENT_FILES = ["CLAUDE.md", "AGENTS.md", ".cursorrules", ".github/copilot-instructions.md"]
+
+HELP = """alchemy - human-quality writing rules for AI agents
+
+Usage:
+  alchemy init     Write ALCHEMY.md into this project and link it from your agent
+                   config (CLAUDE.md / AGENTS.md / etc).
+  alchemy print    Print the ruleset to stdout.
+  alchemy --help   Show this.
+
+Flags:
+  --force    Overwrite an existing ALCHEMY.md.
+  --no-link  Don't touch agent config files; just write ALCHEMY.md.
+"""
+
+
+def _init(argv):
+    text = rules()
+    dest = Path.cwd() / "ALCHEMY.md"
+
+    if dest.exists() and "--force" not in argv:
+        print("* ALCHEMY.md already exists - left it alone (use --force to overwrite).")
+    else:
+        dest.write_text(text, encoding="utf-8")
+        print("[ok] wrote ALCHEMY.md")
+
+    if "--no-link" in argv:
+        return _done()
+
+    for rel in AGENT_FILES:
+        p = Path.cwd() / rel
+        if not p.exists():
+            continue
+        cur = p.read_text(encoding="utf-8")
+        if "ALCHEMY.md" in cur:
+            print(f"* {rel} already references ALCHEMY.md")
+        else:
+            p.write_text(cur.rstrip() + "\n" + POINTER, encoding="utf-8")
+            print(f"[ok] linked ALCHEMY.md from {rel}")
+        return _done()
+
+    print(
+        "* no agent config found. Add this line to your CLAUDE.md / AGENTS.md / .cursorrules:\n"
+        "    See ALCHEMY.md for writing style."
+    )
+    _done()
+
+
+def _done():
+    print("\nDone. Your agent now has the rules. Review ALCHEMY.md and tune to taste.")
+
+
+def main(argv=None):
+    argv = list(sys.argv[1:] if argv is None else argv)
+    cmd = argv[0] if argv else None
+    if cmd in (None, "--help", "-h", "help"):
+        print(HELP)
+    elif cmd == "init":
+        _init(argv[1:])
+    elif cmd == "print":
+        # Write UTF-8 bytes directly: the ruleset has characters (em-dash, emoji it
+        # cites as examples) that a Windows cp1252 console can't encode via stdout.write.
+        data = rules()
+        try:
+            sys.stdout.buffer.write(data.encode("utf-8"))
+        except AttributeError:
+            sys.stdout.write(data)
+    else:
+        sys.stderr.write(f'alchemy: unknown command "{cmd}"\n\n')
+        print(HELP)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

alchemy_writing-0.1.0/src/alchemy_writing.egg-info/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: alchemy-writing
+Version: 0.1.0
+Summary: Turn AI prose into human-quality writing. A drop-in ruleset that stops your coding agent from writing like an LLM.
+Author-email: fernforge <fernforgehq@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/fernforge/alchemy
+Project-URL: Repository, https://github.com/fernforge/alchemy
+Project-URL: Bug Tracker, https://github.com/fernforge/alchemy/issues
+Keywords: ai,llm,writing,prose,humanize,claude,cursor,agents,style-guide,rules
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Text Processing
+Classifier: Topic :: Software Development :: Documentation
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# alchemy-writing
+
+Turn AI prose into writing that reads like a person wrote it. This is the Python
+distribution of [Alchemy](https://github.com/fernforge/alchemy) — a small ruleset you hand
+your coding agent so the docs, READMEs, and replies it writes stop carrying the tell-tale
+LLM patterns.
+
+## Install
+
+```bash
+pip install alchemy-writing
+alchemy init
+```
+
+`alchemy init` writes `ALCHEMY.md` into your project and links it from your `CLAUDE.md`,
+`AGENTS.md`, or `.cursorrules` if one exists. Your agent reads the rules whenever it writes
+after that.
+
+Print the rules instead of writing them:
+
+```bash
+alchemy print
+```
+
+Or pull them into your own code:
+
+```python
+import alchemy_writing
+print(alchemy_writing.rules())
+```
+
+## What's in it
+
+The rules are grounded in documented AI-writing tells: Wikipedia's "Signs of AI writing,"
+the Kobak et al. study on words that spiked in research papers after ChatGPT, and Pangram's
+phrase-frequency data. They cover the banned constructions, the fingerprint vocabulary, the
+punctuation tells led by em-dash overuse, and a self-check the agent runs over its own prose.
+
+Full project, including the npm package and MCP server: https://github.com/fernforge/alchemy
+
+## License
+
+MIT

alchemy_writing-0.1.0/src/alchemy_writing.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+src/alchemy_writing/ALCHEMY.md
+src/alchemy_writing/__init__.py
+src/alchemy_writing/cli.py
+src/alchemy_writing.egg-info/PKG-INFO
+src/alchemy_writing.egg-info/SOURCES.txt
+src/alchemy_writing.egg-info/dependency_links.txt
+src/alchemy_writing.egg-info/entry_points.txt
+src/alchemy_writing.egg-info/top_level.txt

alchemy_writing-0.1.0/src/alchemy_writing.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

alchemy_writing-0.1.0/src/alchemy_writing.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+alchemy = alchemy_writing.cli:main

alchemy_writing-0.1.0/src/alchemy_writing.egg-info/top_level.txt

@@ -0,0 +1 @@
+alchemy_writing