agent-prose 1.0.0__py3-none-any.whl

agent_prose/__init__.py

@@ -0,0 +1,13 @@
+"""
+agent-prose: Deterministic Anti-RLHF Stylometric Gate for Autonomous Agents.
+Created and maintained by Nitivra.
+"""
+from __future__ import annotations
+
+__version__ = "1.0.0"
+__author__ = "Nitivra"
+
+from agent_prose.engine import ProseEngine
+from agent_prose.profiles import get_profile, resolve_locale
+
+__all__ = ["ProseEngine", "get_profile", "resolve_locale", "__version__"]

agent_prose/__main__.py

@@ -0,0 +1,6 @@
+"""CLI entry point when invoked via python -m agent_prose."""
+import sys
+from agent_prose.cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

agent_prose/adapters/__init__.py

@@ -0,0 +1,73 @@
+"""
+Model-specific prompt priming adapters for agent-prose.
+Created and maintained by Nitivra.
+
+Provides calibration prompts to eliminate vendor-specific RLHF stylometric tells.
+Supported model families:
+  - Anthropic Claude
+  - Google Gemini
+  - xAI Grok
+  - Meta Muse / Llama
+  - Microsoft Copilot
+"""
+from __future__ import annotations
+
+from typing import Dict
+from agent_prose.profiles.base import DialectProfile
+from agent_prose.profiles import resolve_locale
+
+ADAPTER_TEMPLATES: Dict[str, str] = {
+    "claude": (
+        "[WRITING INVARIANT] Ban prestige filler words: crucial, nuance, bedrock, "
+        "linchpin, cornerstone, bespoke, imperative. Do not use 'not only X, but also Y' "
+        "synthetic balance. Do not hedge using 'that being said' or 'to be sure'. "
+        "State technical trade-offs with numbers and precise dependencies."
+    ),
+    "gemini": (
+        "[WRITING INVARIANT] Vary sentence lengths deliberately (mix 6-word statements "
+        "with 24-word complex sentences). Avoid uniform bullet lists. Do not use "
+        "trailing participial clauses (', ...ing'). Limit sentences to at most two commas."
+    ),
+    "grok": (
+        "[WRITING INVARIANT] Eliminate informal conversational swagger ('Here is the kicker', "
+        "'Let us get into it'). Do not use raw flow arrows (->) in prose; write complete "
+        "sentences with active verbs. Maintain rigorous engineering delivery."
+    ),
+    "muse": (
+        "[WRITING INVARIANT] Use straight ASCII characters only (no em dashes or curly quotes). "
+        "Contractions are prohibited (write 'do not', 'cannot', 'it is'). "
+        "Ban conversational fillers and deliver factual analysis directly."
+    ),
+    "copilot": (
+        "[WRITING INVARIANT] Contractions are prohibited (write 'do not', 'cannot', 'it is'). "
+        "Ban corporate marketing fluff (empower, seamless, streamline, leverage). "
+        "Do not include customer-service greetings or conversational sign-offs ('Certainly!', 'Happy to help!'). "
+        "Use straight ASCII characters only (no em dashes, no curly quotes). State facts directly using 'is' or 'are'."
+    ),
+}
+
+
+def get_adapter_prompt(model: str, profile: DialectProfile | None = None) -> str:
+    """Generate system prompt priming block for a specified model and dialect."""
+    target_profile = profile or resolve_locale()
+    key = model.strip().lower()
+
+    base_instruction = ADAPTER_TEMPLATES.get(key)
+    if not base_instruction:
+        base_instruction = (
+            "[WRITING INVARIANT] Use straight ASCII characters only. Contractions are prohibited. "
+            "Deliver factual analysis directly without conversational filler or synthetic balance."
+        )
+
+    dialect_rule = (
+        f"You must write in {target_profile.name}."
+    )
+    if not target_profile.allow_ize_spelling:
+        dialect_rule += " Use -ise spellings (organise, analyse, prioritise) and British/Commonwealth orthography (colour, centre)."
+    if not target_profile.allow_serial_comma:
+        dialect_rule += " Do not use the Oxford comma before conjunctions in lists."
+
+    return f"{dialect_rule} {base_instruction}"
+
+
+__all__ = ["get_adapter_prompt", "ADAPTER_TEMPLATES"]

agent_prose/adapters/claude.md

@@ -0,0 +1,21 @@
+<!-- writing-quality: off -->
+<!-- agent-prose: off -->
+# Anthropic Claude System Prompt Adapter
+
+> Created and maintained by Nitivra.
+> Dialect: Enforces chosen regional profile (default: en-AU).
+
+## Prompt Priming Block
+
+Copy the following block into your Claude system prompt, `CLAUDE.md`, or agent configuration:
+
+```text
+[WRITING INVARIANT]
+You must adhere strictly to clear, direct technical prose:
+1. Ban prestige filler stems: crucial, nuance, bedrock, linchpin, cornerstone, bespoke, imperative, paramount.
+2. Avoid synthetic balance constructions such as "not only X, but also Y".
+3. Avoid concessive hedging phrases like "that being said" or "to be sure".
+4. State technical trade-offs directly with precise numbers, concrete metrics, and architectural dependencies.
+5. Use straight ASCII punctuation only: replace Unicode em dashes with double hyphens (--) and use straight quotes.
+6. Do not use contractions. Write full words: "do not", "cannot", "it is".
+```

agent_prose/adapters/copilot.md

@@ -0,0 +1,21 @@
+<!-- writing-quality: off -->
+<!-- agent-prose: off -->
+# Microsoft Copilot System Prompt Adapter
+
+> Created and maintained by Nitivra.
+> Dialect: Enforces chosen regional profile (default: en-AU).
+
+## Prompt Priming Block
+
+Copy the following block into your Copilot instructions, workspace instructions (`.github/copilot-instructions.md`) or agent configuration:
+
+```text
+[WRITING INVARIANT]
+You must adhere strictly to clear, direct technical prose:
+1. Enforce target dialect orthography (when using en-AU: -ise spellings, colour, centre).
+2. Ban corporate marketing fluff (empower, seamless, streamline, leverage, comprehensive).
+3. Do not include customer-service greetings or conversational sign-offs ("Certainly!", "Happy to help!", "I hope this assists you!").
+4. State facts directly using direct copulas ("is", "are"). Prohibit evasive copulas ("serves as", "stands as", "marks a").
+5. Use straight ASCII characters only: replace Unicode em dashes with double hyphens (--) and use straight quotes.
+6. Do not use contractions. Write full words: "do not", "cannot", "it is".
+```

agent_prose/adapters/gemini.md

@@ -0,0 +1,21 @@
+<!-- writing-quality: off -->
+<!-- agent-prose: off -->
+# Google Gemini System Prompt Adapter
+
+> Created and maintained by Nitivra.
+> Dialect: Enforces chosen regional profile (default: en-AU).
+
+## Prompt Priming Block
+
+Copy the following block into your Gemini system instructions, `GEMINI.md`, or agent configuration:
+
+```text
+[WRITING INVARIANT]
+You must adhere strictly to clear, direct technical prose:
+1. Vary sentence lengths deliberately: alternate short punchy statements (6 words) with compound sentences (20 to 28 words).
+2. Avoid monotone bullet lists and formulaic paragraph openers.
+3. Prohibit trailing participial clauses (", ensuring...", ", enabling...", ", providing..."). State outcomes as direct full sentences.
+4. Limit sentences to at most two commas.
+5. Use straight ASCII punctuation only: replace Unicode em dashes with double hyphens (--) and use straight quotes.
+6. Do not use contractions. Write full words: "do not", "cannot", "it is".
+```

agent_prose/adapters/grok.md

@@ -0,0 +1,20 @@
+<!-- writing-quality: off -->
+<!-- agent-prose: off -->
+# xAI Grok System Prompt Adapter
+
+> Created and maintained by Nitivra.
+> Dialect: Enforces chosen regional profile (default: en-AU).
+
+## Prompt Priming Block
+
+Copy the following block into your Grok system prompt, `.grok/rules`, or agent configuration:
+
+```text
+[WRITING INVARIANT]
+You must adhere strictly to clear, direct technical prose:
+1. Eliminate informal conversational swagger ("Here is the kicker", "Let us dive in", "Buckle up").
+2. Prohibit raw flow arrows (->) in narrative prose. Express sequences using plain prose verbs: "then", "feeds into", "maps to".
+3. Maintain rigorous engineering delivery and avoid throat-clearing rhetorical questions.
+4. Use straight ASCII punctuation only: replace Unicode em dashes with double hyphens (--) and use straight quotes.
+5. Do not use contractions. Write full words: "do not", "cannot", "it is".
+```

agent_prose/adapters/muse.md

@@ -0,0 +1,20 @@
+<!-- writing-quality: off -->
+<!-- agent-prose: off -->
+# Meta Muse / Llama System Prompt Adapter
+
+> Created and maintained by Nitivra.
+> Dialect: Enforces chosen regional profile (default: en-AU).
+
+## Prompt Priming Block
+
+Copy the following block into your Muse or Llama system prompt or agent configuration:
+
+```text
+[WRITING INVARIANT]
+You must adhere strictly to clear, direct technical prose:
+1. Enforce target dialect orthography (when using en-AU: -ise spellings, colour, centre).
+2. Avoid informal conversational scaffolding ("Let me unpack this", "Here is why").
+3. Use straight ASCII characters only: replace Unicode em dashes with double hyphens (--) and use straight quotes.
+4. Do not use contractions. Write full words: "do not", "cannot", "it is".
+5. Deliver factual analysis directly without sycophantic praise or conversational pleasantries.
+```

agent_prose/cli.py

@@ -0,0 +1,220 @@
+"""
+Command-line interface for agent-prose.
+Created and maintained by Nitivra.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+from typing import List, Sequence
+
+from agent_prose import __version__
+from agent_prose.engine import Finding, ProseEngine, ScanResult
+from agent_prose.profiles import resolve_locale
+
+SCANNABLE_EXTENSIONS = {".md", ".txt", ".html"}
+DEFAULT_EXCLUDES = {
+    ".git", "node_modules", ".venv", "venv", "__pycache__",
+    "site-packages", "dist", "build", ".pytest_cache", "fixtures",
+}
+
+
+def should_scan_file(filepath: Path) -> bool:
+    """Determine whether a file should be scanned based on extension and path."""
+    if filepath.suffix.lower() not in SCANNABLE_EXTENSIONS:
+        return False
+    for part in filepath.parts:
+        if part in DEFAULT_EXCLUDES:
+            return False
+    return True
+
+
+def collect_files(targets: Sequence[str]) -> List[Path]:
+    """Resolve file and directory targets into a unique list of paths."""
+    collected: List[Path] = []
+    for target in targets:
+        p = Path(target).resolve()
+        if p.is_file():
+            collected.append(p)
+        elif p.is_dir():
+            for root, dirs, files in os.walk(p):
+                dirs[:] = [d for d in dirs if d not in DEFAULT_EXCLUDES]
+                for file in files:
+                    file_path = Path(root) / file
+                    if should_scan_file(file_path):
+                        collected.append(file_path)
+    return collected
+
+
+def format_text_output(result: ScanResult, filepath_display: str) -> str:
+    """Format scan results for standard terminal display."""
+    if result.is_exempt:
+        return f"{filepath_display}: [EXEMPT] Opted out of stylometric scan"
+    if not result.findings:
+        return f"{filepath_display}: [PASSED] Clean"
+
+    lines = [f"{filepath_display} (Locale: {result.profile_code}):"]
+    for finding in result.findings:
+        loc = f"L{finding.line_number}: " if finding.line_number else ""
+        lines.append(f"  [{finding.severity}] {loc}{finding.message}")
+    return "\n".join(lines)
+
+
+def run_scan(
+    paths: Sequence[str],
+    locale_override: str | None = None,
+    strict: bool = False,
+    advisory_threshold: int = 4,
+    json_mode: bool = False,
+    quiet: bool = False,
+) -> int:
+    """Execute scan across targeted paths and return the process exit code."""
+    profile = resolve_locale(locale_override)
+    engine = ProseEngine(profile=profile, strict=strict, advisory_threshold=advisory_threshold)
+
+    # Stdin handling if requested via '-'
+    if len(paths) == 1 and paths[0] == "-":
+        content = sys.stdin.read()
+        lines = content.splitlines()
+        res = engine.check(lines, filepath="stdin.md")
+        if json_mode:
+            payload = {
+                "file": "stdin",
+                "locale": res.profile_code,
+                "passed": res.passed,
+                "exit_code": res.exit_code,
+                "findings": [
+                    {
+                        "check_id": f.check_id,
+                        "severity": f.severity,
+                        "line": f.line_number,
+                        "message": f.message,
+                    }
+                    for f in res.findings
+                ],
+            }
+            print(json.dumps(payload, indent=2))
+        else:
+            print(format_text_output(res, "stdin"))
+        return res.exit_code
+
+    targets = paths if paths else ["."]
+    files = collect_files(targets)
+
+    if not files:
+        if not quiet:
+            print("No matching files found to scan.")
+        return 0
+
+    worst_exit_code = 0
+    total_findings = 0
+    results_payload = []
+
+    for file_path in files:
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                lines = f.readlines()
+        except (IOError, UnicodeDecodeError) as err:
+            if not quiet:
+                print(f"Error reading {file_path}: {err}", file=sys.stderr)
+            worst_exit_code = max(worst_exit_code, 1)
+            continue
+
+        res = engine.check(lines, filepath=str(file_path))
+        total_findings += len(res.findings)
+        worst_exit_code = max(worst_exit_code, res.exit_code)
+
+        if json_mode:
+            results_payload.append({
+                "file": str(file_path),
+                "locale": res.profile_code,
+                "passed": res.passed,
+                "exit_code": res.exit_code,
+                "findings": [
+                    {
+                        "check_id": f.check_id,
+                        "severity": f.severity,
+                        "line": f.line_number,
+                        "message": f.message,
+                    }
+                    for f in res.findings
+                ],
+            })
+        else:
+            if not res.passed or not quiet:
+                print(format_text_output(res, str(file_path)))
+
+    if json_mode:
+        summary = {
+            "version": __version__,
+            "files_scanned": len(files),
+            "worst_exit_code": worst_exit_code,
+            "results": results_payload,
+        }
+        print(json.dumps(summary, indent=2))
+    elif not quiet:
+        status = "PASSED" if worst_exit_code == 0 else f"FAILED (code {worst_exit_code})"
+        print(f"\nScan complete: {len(files)} file(s) evaluated. Status: {status}.")
+
+    return worst_exit_code
+
+
+def main(argv: Sequence[str] | None = None) -> None:
+    """CLI entry point for agent-prose."""
+    parser = argparse.ArgumentParser(
+        prog="agent-prose",
+        description="Deterministic Anti-RLHF Stylometric Gate for Autonomous Agents by Nitivra.",
+    )
+    parser.add_argument(
+        "paths",
+        nargs="*",
+        help="Paths to markdown, text, or HTML files and directories (use '-' for stdin).",
+    )
+    parser.add_argument(
+        "-l", "--locale",
+        help="Dialect profile override (e.g. en-AU, en-US, en-GB).",
+    )
+    parser.add_argument(
+        "--strict",
+        action="store_true",
+        help="Enforce strict mode: promote all advisory warnings to blocking failures (exit code 1).",
+    )
+    parser.add_argument(
+        "--advisory-threshold",
+        type=int,
+        default=4,
+        help="Number of advisory warnings required to trigger exit code 2 (default: 4).",
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output structured JSON results.",
+    )
+    parser.add_argument(
+        "-q", "--quiet",
+        action="store_true",
+        help="Suppress output for passing files.",
+    )
+    parser.add_argument(
+        "-v", "--version",
+        action="version",
+        version=f"agent-prose {__version__}",
+    )
+
+    args = parser.parse_args(argv)
+    code = run_scan(
+        paths=args.paths,
+        locale_override=args.locale,
+        strict=args.strict,
+        advisory_threshold=args.advisory_threshold,
+        json_mode=args.json,
+        quiet=args.quiet,
+    )
+    sys.exit(code)
+
+
+if __name__ == "__main__":
+    main()