limatus 0.2.0__tar.gz

limatus-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anthus AI Solutions
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

limatus-0.2.0/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: limatus
+Version: 0.2.0
+Summary: A diagnose-and-steer quality loop for AI-generated content.
+Author: Anthus AI Solutions
+License: MIT
+Project-URL: Homepage, https://github.com/AnthusAI/Limatus
+Project-URL: Repository, https://github.com/AnthusAI/Limatus
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyYAML<7.0.0,>=6.0.2
+Provides-Extra: dev
+Requires-Dist: behave>=1.2.6; extra == "dev"
+Dynamic: license-file
+
+# Limatus
+
+Limatus is a diagnose-and-steer quality loop for AI-generated content — prose today, web pages soon — built to catch generic AI slop and enforce a specific publication or product's own style rules, not just generic patterns.
+
+## Press Release
+
+**Anthus AI Solutions introduces Limatus, an open-source tool that tells writers exactly where AI-generated prose sounds generic — without rewriting it for them**
+
+Teams publishing AI-assisted content face a recurring problem: drafts that are technically correct but sound like every other AI-generated draft — hedge words, empty lead-ins, uniform sentence cadence, unsupported certainty, and a voice that matches no one's actual house style. Fixing this by hand doesn't scale, and letting a model "just rewrite it" trades one set of generic patterns for another.
+
+Limatus is a command-line tool that closes this gap in two separate steps. `limatus diagnose` reads a draft against a publication's own style profile — its voice, its lexicon, its banned phrases and patterns — and returns a structured list of findings: vague claims, empty lead-ins, uniform cadence, list-shaped prose, unsupported certainty, redundancy, and voice mismatches. It never rewrites anything; findings are signal, not verdicts. A human or agent then marks each finding skip, rewrite, delete, or keep, and only for the findings marked "rewrite" does `limatus options` generate a small set of constrained rewrite candidates — never a single mandated replacement, and never a fabricated fact, statistic, or anecdote.
+
+"We built this because we were publishing AI-assisted content ourselves and got tired of the same tells showing up in every draft," said the Limatus team at Anthus AI Solutions. "The insight wasn't that AI writing is bad — it's that treating every publication's voice as the same generic 'professional tone' is what makes it read as AI-generated. Limatus makes house style an explicit, versioned, machine-checkable artifact instead of something an editor has to remember and enforce by hand every time."
+
+Limatus is extracted from the editorial engine Anthus AI Solutions built and ran across dozens of real articles on its own Anth.us and Pilobolus publications, and is available today as an MIT-licensed, publication-agnostic Python package at [github.com/AnthusAI/Limatus](https://github.com/AnthusAI/Limatus).
+
+## FAQ
+
+**Is Limatus an AI-content detector?**
+No. Limatus doesn't try to guess whether text was written by a model — it checks text against a style profile you define, regardless of who or what wrote it. It deliberately refuses to accept "detector scores" as part of a style profile; the goal is to enforce your voice, not to pass someone else's AI-detection heuristic.
+
+**Does Limatus rewrite my content for me?**
+Not automatically, and not without a human or agent explicitly opting each finding in. `limatus diagnose` only reports findings — it never touches the draft file. `limatus options` only generates rewrite *candidates* for findings you've separately marked "rewrite," and always offers more than one option so the choice of which to accept stays with an editor.
+
+**What does a "style profile" look like?**
+A YAML file naming a publication's voice, audience, tone, sentence style, structure, a preferred/avoided lexicon, evidence rules, and five to ten reference samples of real approved prose. It's the same profile used to catch drift, so it's meant to be version-controlled alongside the content it governs.
+
+**Why is this a separate package from Papyrus?**
+Papyrus is Anthus AI Solutions' own content and newsroom system, tightly coupled to Anth.us's publishing pipeline. Limatus is the general-purpose diagnose engine underneath it, extracted so any publication or product — not just Anthus's own — can adopt it without adopting the rest of Papyrus.
+
+**What's next?**
+A second capability is planned: a usability and accessibility diagnose loop for AI-generated web pages, built on Playwright and axe-core, checking WCAG 2.2 A/AA compliance across themes, viewports, and interactive states — the same diagnose-first, never-auto-fix philosophy applied to markup instead of prose.
+
+**Is it on PyPI yet?**
+Not yet — see Status below.
+
+## Status
+
+This package was newly extracted from Anth.us's Papyrus content system and is under active development. It is not yet on PyPI.
+
+## Installation
+
+```bash
+pip install -e ".[dev]"
+```
+
+(PyPI installation via `pip install limatus` will be available once the package is published — see Status above.)
+
+## Usage
+
+```bash
+limatus diagnose --draft path/to/draft.md --profile path/to/style-profile.yml
+limatus options --draft path/to/draft.md --profile path/to/style-profile.yml \
+  --diagnosis path/to/diagnosis.json --decisions path/to/decisions.json \
+  --skill path/to/rewrite-skill.yml
+```
+
+Run `limatus --help` for the full command reference.
+
+## Testing
+
+Limatus's test suite is written in Gherkin and run with [Behave](https://behave.readthedocs.io/):
+
+```bash
+behave
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

limatus-0.2.0/README.md

@@ -0,0 +1,70 @@
+# Limatus
+
+Limatus is a diagnose-and-steer quality loop for AI-generated content — prose today, web pages soon — built to catch generic AI slop and enforce a specific publication or product's own style rules, not just generic patterns.
+
+## Press Release
+
+**Anthus AI Solutions introduces Limatus, an open-source tool that tells writers exactly where AI-generated prose sounds generic — without rewriting it for them**
+
+Teams publishing AI-assisted content face a recurring problem: drafts that are technically correct but sound like every other AI-generated draft — hedge words, empty lead-ins, uniform sentence cadence, unsupported certainty, and a voice that matches no one's actual house style. Fixing this by hand doesn't scale, and letting a model "just rewrite it" trades one set of generic patterns for another.
+
+Limatus is a command-line tool that closes this gap in two separate steps. `limatus diagnose` reads a draft against a publication's own style profile — its voice, its lexicon, its banned phrases and patterns — and returns a structured list of findings: vague claims, empty lead-ins, uniform cadence, list-shaped prose, unsupported certainty, redundancy, and voice mismatches. It never rewrites anything; findings are signal, not verdicts. A human or agent then marks each finding skip, rewrite, delete, or keep, and only for the findings marked "rewrite" does `limatus options` generate a small set of constrained rewrite candidates — never a single mandated replacement, and never a fabricated fact, statistic, or anecdote.
+
+"We built this because we were publishing AI-assisted content ourselves and got tired of the same tells showing up in every draft," said the Limatus team at Anthus AI Solutions. "The insight wasn't that AI writing is bad — it's that treating every publication's voice as the same generic 'professional tone' is what makes it read as AI-generated. Limatus makes house style an explicit, versioned, machine-checkable artifact instead of something an editor has to remember and enforce by hand every time."
+
+Limatus is extracted from the editorial engine Anthus AI Solutions built and ran across dozens of real articles on its own Anth.us and Pilobolus publications, and is available today as an MIT-licensed, publication-agnostic Python package at [github.com/AnthusAI/Limatus](https://github.com/AnthusAI/Limatus).
+
+## FAQ
+
+**Is Limatus an AI-content detector?**
+No. Limatus doesn't try to guess whether text was written by a model — it checks text against a style profile you define, regardless of who or what wrote it. It deliberately refuses to accept "detector scores" as part of a style profile; the goal is to enforce your voice, not to pass someone else's AI-detection heuristic.
+
+**Does Limatus rewrite my content for me?**
+Not automatically, and not without a human or agent explicitly opting each finding in. `limatus diagnose` only reports findings — it never touches the draft file. `limatus options` only generates rewrite *candidates* for findings you've separately marked "rewrite," and always offers more than one option so the choice of which to accept stays with an editor.
+
+**What does a "style profile" look like?**
+A YAML file naming a publication's voice, audience, tone, sentence style, structure, a preferred/avoided lexicon, evidence rules, and five to ten reference samples of real approved prose. It's the same profile used to catch drift, so it's meant to be version-controlled alongside the content it governs.
+
+**Why is this a separate package from Papyrus?**
+Papyrus is Anthus AI Solutions' own content and newsroom system, tightly coupled to Anth.us's publishing pipeline. Limatus is the general-purpose diagnose engine underneath it, extracted so any publication or product — not just Anthus's own — can adopt it without adopting the rest of Papyrus.
+
+**What's next?**
+A second capability is planned: a usability and accessibility diagnose loop for AI-generated web pages, built on Playwright and axe-core, checking WCAG 2.2 A/AA compliance across themes, viewports, and interactive states — the same diagnose-first, never-auto-fix philosophy applied to markup instead of prose.
+
+**Is it on PyPI yet?**
+Not yet — see Status below.
+
+## Status
+
+This package was newly extracted from Anth.us's Papyrus content system and is under active development. It is not yet on PyPI.
+
+## Installation
+
+```bash
+pip install -e ".[dev]"
+```
+
+(PyPI installation via `pip install limatus` will be available once the package is published — see Status above.)
+
+## Usage
+
+```bash
+limatus diagnose --draft path/to/draft.md --profile path/to/style-profile.yml
+limatus options --draft path/to/draft.md --profile path/to/style-profile.yml \
+  --diagnosis path/to/diagnosis.json --decisions path/to/decisions.json \
+  --skill path/to/rewrite-skill.yml
+```
+
+Run `limatus --help` for the full command reference.
+
+## Testing
+
+Limatus's test suite is written in Gherkin and run with [Behave](https://behave.readthedocs.io/):
+
+```bash
+behave
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

limatus-0.2.0/pyproject.toml

@@ -0,0 +1,48 @@
+[project]
+name = "limatus"
+version = "0.2.0"
+description = "A diagnose-and-steer quality loop for AI-generated content."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+authors = [
+  { name = "Anthus AI Solutions" }
+]
+dependencies = [
+    "PyYAML>=6.0.2,<7.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "behave>=1.2.6",
+]
+
+[project.urls]
+Homepage = "https://github.com/AnthusAI/Limatus"
+Repository = "https://github.com/AnthusAI/Limatus"
+
+[project.scripts]
+limatus = "limatus.cli:main"
+
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.semantic_release]
+version_toml = ["pyproject.toml:project.version"]
+version_variables = ["src/limatus/__init__.py:__version__"]
+build_command = "python -m pip install build && python -m build"
+commit_parser = "conventional"
+major_on_zero = false
+
+[tool.semantic_release.branches.main]
+match = "main"
+
+[tool.semantic_release.changelog]
+exclude_commit_patterns = []
+
+[tool.semantic_release.remote]
+type = "github"

limatus-0.2.0/setup.cfg

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

limatus-0.2.0/src/limatus/__init__.py

@@ -0,0 +1,3 @@
+"""Limatus: a diagnose-and-steer quality loop for AI-generated content."""
+
+__version__ = "0.2.0"

limatus-0.2.0/src/limatus/_util.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from typing import Any
+
+
+def hash_stable(value: Any) -> str:
+    if isinstance(value, str):
+        payload = value
+    else:
+        payload = json.dumps(value, sort_keys=True, separators=(",", ":"), default=str)
+    return hashlib.sha256(payload.encode("utf-8")).hexdigest()
+
+
+def hash_short(value: Any) -> str:
+    return hash_stable(value)[:16]
+
+
+# Default model for constrained rewrite-option generation.
+DEFAULT_EDITORIAL_REWRITE_MODEL = "gpt-5.4-mini"

limatus-0.2.0/src/limatus/cli.py

@@ -0,0 +1,43 @@
+"""Limatus CLI entry point.
+
+    limatus diagnose --draft <file> --profile <style-profile.yml> [...]
+    limatus options  --draft <file> --profile <style-profile.yml> \\
+                      --diagnosis <diagnosis.json> --decisions <decisions.json> \\
+                      --skill <editorial-rewrite-skill.yml> [...]
+
+See editorial_commands.py for each subcommand's full flag set.
+"""
+from __future__ import annotations
+
+import sys
+
+from . import __version__
+from .editorial_commands import editorial_diagnose, editorial_options
+
+COMMANDS = {
+    "diagnose": editorial_diagnose,
+    "options": editorial_options,
+}
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = list(sys.argv[1:] if argv is None else argv)
+    if not args or args[0] in {"-h", "--help"}:
+        print(__doc__)
+        return 0
+    if args[0] in {"-V", "--version"}:
+        print(f"limatus {__version__}")
+        return 0
+
+    command, flags = args[0], args[1:]
+    handler = COMMANDS.get(command)
+    if handler is None:
+        print(f"limatus: unknown command '{command}'. Try one of: {', '.join(sorted(COMMANDS))}")
+        return 1
+
+    handler(flags)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

limatus-0.2.0/src/limatus/editorial_commands.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from .editorial_diagnosis import diagnose_draft
+from .editorial_diagnosis_schema import validate_diagnosis
+from .editorial_markup import render_annotated_markus, render_annotated_xml
+from .editorial_options_schema import validate_decisions
+from .editorial_rewrite_options import generate_rewrite_options
+from .editorial_style import load_style_profile
+from ._util import DEFAULT_EDITORIAL_REWRITE_MODEL
+
+
+def editorial_diagnose(flags: list[str]) -> None:
+    parser = argparse.ArgumentParser(prog="limatus diagnose")
+    input_group = parser.add_mutually_exclusive_group(required=True)
+    input_group.add_argument("--draft", help="Path to the draft file (read-only).")
+    input_group.add_argument("--text", help="Draft text to diagnose without reading a file.")
+    parser.add_argument("--profile", required=True, help="Path to the style profile YAML.")
+    parser.add_argument("--output", default="", help="Optional path to write diagnostic JSON.")
+    parser.add_argument(
+        "--markup-out",
+        default="",
+        help="Optional path to write Markus-annotated Markdown (editorial-finding directives).",
+    )
+    parser.add_argument(
+        "--xml-out",
+        default="",
+        help="Optional path to write editorial annotation XML.",
+    )
+    args = parser.parse_args(flags)
+
+    profile_path = Path(args.profile).resolve()
+    if args.draft:
+        draft_path = Path(args.draft).resolve()
+        if not draft_path.is_file():
+            raise ValueError(f"Draft file not found: {draft_path}")
+        draft_text = draft_path.read_text(encoding="utf-8")
+    else:
+        draft_text = args.text
+
+    style_profile = load_style_profile(profile_path)
+    diagnosis = diagnose_draft(draft_text, style_profile=style_profile)
+    rendered = json.dumps(diagnosis, indent=2) + "\n"
+
+    if args.markup_out:
+        markup_path = Path(args.markup_out).resolve()
+        markup_path.write_text(render_annotated_markus(draft_text, diagnosis), encoding="utf-8")
+
+    if args.xml_out:
+        xml_path = Path(args.xml_out).resolve()
+        xml_path.write_text(render_annotated_xml(draft_text, diagnosis), encoding="utf-8")
+
+    if args.output:
+        output_path = Path(args.output).resolve()
+        output_path.write_text(rendered, encoding="utf-8")
+        return
+
+    sys.stdout.write(rendered)
+
+
+def editorial_options(flags: list[str]) -> None:
+    parser = argparse.ArgumentParser(prog="limatus options")
+    parser.add_argument("--draft", required=True, help="Path to the draft file (read-only).")
+    parser.add_argument("--profile", required=True, help="Path to the style profile YAML.")
+    parser.add_argument("--diagnosis", required=True, help="Path to validated diagnostic JSON.")
+    parser.add_argument("--decisions", required=True, help="Path to steering decisions JSON.")
+    parser.add_argument("--output", default="", help="Optional path to write options JSON.")
+    parser.add_argument("--model", default=DEFAULT_EDITORIAL_REWRITE_MODEL, help="OpenAI model id.")
+    parser.add_argument(
+        "--skill",
+        required=True,
+        help="Path to editorial rewrite skill YAML.",
+    )
+    args = parser.parse_args(flags)
+
+    draft_path = Path(args.draft).resolve()
+    if not draft_path.is_file():
+        raise ValueError(f"Draft file not found: {draft_path}")
+    draft_text = draft_path.read_text(encoding="utf-8")
+
+    diagnosis_path = Path(args.diagnosis).resolve()
+    decisions_path = Path(args.decisions).resolve()
+    diagnosis_payload = json.loads(diagnosis_path.read_text(encoding="utf-8"))
+    decisions_payload = json.loads(decisions_path.read_text(encoding="utf-8"))
+    if not isinstance(decisions_payload, list):
+        raise ValueError("Decisions JSON must be a list.")
+
+    style_profile = load_style_profile(Path(args.profile).resolve())
+    validate_diagnosis(diagnosis_payload)
+    validate_decisions(decisions_payload)
+
+    options = generate_rewrite_options(
+        draft_text,
+        style_profile=style_profile,
+        diagnosis=diagnosis_payload,
+        decisions=decisions_payload,
+        model=args.model,
+        skill_path=args.skill,
+    )
+    rendered = json.dumps(options, indent=2) + "\n"
+
+    if args.output:
+        output_path = Path(args.output).resolve()
+        output_path.write_text(rendered, encoding="utf-8")
+        return
+
+    sys.stdout.write(rendered)

limatus-0.2.0/src/limatus/editorial_corpus.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from .editorial_style import StyleProfileValidationError
+
+
+def load_editorial_corpus_manifest(path: str | Path) -> dict[str, list[dict[str, Any]]]:
+    manifest_path = Path(path).resolve()
+    raw = yaml.safe_load(manifest_path.read_text(encoding="utf-8"))
+    if not isinstance(raw, dict):
+        raise StyleProfileValidationError(f"Editorial corpus manifest must be a mapping: {manifest_path}")
+
+    manifest: dict[str, list[dict[str, Any]]] = {"mustFail": [], "mustPass": []}
+    for section in ("mustFail", "mustPass"):
+        entries = raw.get(section)
+        if entries is None:
+            continue
+        if not isinstance(entries, list):
+            raise StyleProfileValidationError(f"{section} must be a list in {manifest_path}")
+        normalized: list[dict[str, Any]] = []
+        for index, entry in enumerate(entries):
+            if not isinstance(entry, dict):
+                raise StyleProfileValidationError(f"{section}[{index}] must be a mapping in {manifest_path}")
+            entry_id = str(entry.get("id", "")).strip()
+            rel_path = str(entry.get("path", "")).strip()
+            if not entry_id or not rel_path:
+                raise StyleProfileValidationError(
+                    f"{section}[{index}] requires id and path in {manifest_path}"
+                )
+            draft_path = (manifest_path.parent / rel_path).resolve()
+            if not draft_path.is_file():
+                raise StyleProfileValidationError(f"Corpus draft not found: {draft_path}")
+            normalized_entry = {"id": entry_id, "path": rel_path, "draftPath": str(draft_path)}
+            if section == "mustFail":
+                expect_terms = entry.get("expectTerms")
+                if not isinstance(expect_terms, list) or not expect_terms:
+                    raise StyleProfileValidationError(
+                        f"{section}[{index}].expectTerms must be a non-empty list in {manifest_path}"
+                    )
+                normalized_entry["expectTerms"] = [str(term).strip() for term in expect_terms if str(term).strip()]
+            else:
+                source_sample = entry.get("sourceSample")
+                if isinstance(source_sample, str) and source_sample.strip():
+                    normalized_entry["sourceSample"] = source_sample.strip()
+            normalized.append(normalized_entry)
+        manifest[section] = normalized
+    return manifest