@wentorai/research-plugins 1.0.0

package/skills/writing/polish/ai-writing-humanizer/SKILL.md

@@ -0,0 +1,178 @@
+---
+name: ai-writing-humanizer
+description: "Remove AI-generated patterns to produce natural, authentic academic writing"
+metadata:
+  openclaw:
+    emoji: "pencil2"
+    category: "writing"
+    subcategory: "polish"
+    keywords: ["humanize", "AI pattern removal", "natural writing", "AI-assisted writing", "writing style"]
+    source: "wentor"
+---
+
+# AI Writing Humanizer
+
+A skill for identifying and removing characteristic patterns of AI-generated text to produce natural, authentic academic writing. Designed for researchers who use AI tools for drafting and want to ensure the final output reads as genuine scholarly prose.
+
+## Common AI Writing Patterns
+
+### Lexical Patterns to Identify and Replace
+
+AI-generated text frequently overuses certain words and phrases:
+
+```python
+def identify_ai_patterns(text: str) -> dict:
+    """
+    Scan text for common AI-generated writing patterns.
+
+    Returns a report of detected patterns with suggested replacements.
+    """
+    overused_phrases = {
+        # Hedging/filler phrases AI overuses
+        'it is important to note that': 'Note that',
+        'it is worth mentioning that': '[delete or rephrase]',
+        'it should be noted that': '[delete or rephrase]',
+        'in the realm of': 'in',
+        'in the context of': 'in / for / regarding',
+        'a testament to': '[rephrase with specific evidence]',
+        'the landscape of': '[delete -- be specific]',
+        'a nuanced understanding': '[delete or specify what nuance]',
+        'shed light on': 'clarified / revealed / explained',
+        'delve into': 'examined / analyzed / investigated',
+        'furthermore': '[vary: also, additionally, moreover, or restructure]',
+        'moreover': '[vary: in addition, also, or restructure]',
+        'utilizing': 'using',
+        'leverage': 'use / apply / employ',
+        'facilitate': 'enable / support / help',
+        'a myriad of': 'many / numerous / various',
+        'plays a crucial role': 'is important for / contributes to',
+        'in conclusion': '[often unnecessary -- just conclude]',
+        'overall': '[often unnecessary filler]',
+        'comprehensive': '[usually vague -- be specific about scope]',
+        'robust': '[overused -- specify what makes it strong]',
+        'multifaceted': '[specify the actual facets]',
+        'notably': '[usually filler -- delete or restructure]'
+    }
+
+    results = {'detected': [], 'total_flags': 0}
+
+    text_lower = text.lower()
+    for phrase, suggestion in overused_phrases.items():
+        count = text_lower.count(phrase.lower())
+        if count > 0:
+            results['detected'].append({
+                'phrase': phrase,
+                'count': count,
+                'suggestion': suggestion
+            })
+            results['total_flags'] += count
+
+    return results
+```
+
+### Structural Patterns
+
+AI text tends to exhibit predictable structural patterns:
+
+```
+AI Pattern: Formulaic paragraph structure
+  - Topic sentence (broad claim)
+  - Supporting point 1
+  - Supporting point 2
+  - Concluding/transition sentence
+  Every paragraph follows this exact template.
+
+Human Fix: Vary paragraph structure
+  - Sometimes lead with evidence, then interpret
+  - Sometimes pose a question, then answer it
+  - Sometimes use a single punchy sentence as a paragraph
+  - Let paragraph length vary naturally (2-8 sentences)
+```
+
+```
+AI Pattern: Excessive parallel construction
+  "The study examined X, analyzed Y, and evaluated Z."
+  "This approach enhances accuracy, improves efficiency, and reduces cost."
+
+Human Fix: Break parallelism occasionally
+  "The study examined X. For Y, a different analytical lens was required,
+   so we turned to Z for comparison."
+```
+
+## Revision Strategies
+
+### Sentence-Level Humanization
+
+```python
+def humanize_sentence_variety(sentences: list[str]) -> dict:
+    """
+    Analyze sentence variety -- AI text often has uniform sentence lengths
+    and structures.
+    """
+    lengths = [len(s.split()) for s in sentences]
+    avg_length = sum(lengths) / len(lengths)
+    std_length = (sum((l - avg_length)**2 for l in lengths) / len(lengths)) ** 0.5
+
+    # Check first word variety
+    first_words = [s.split()[0].lower() if s.split() else '' for s in sentences]
+    unique_first_words = len(set(first_words)) / len(first_words)
+
+    issues = []
+
+    if std_length < 3:
+        issues.append(
+            f"Sentence lengths are too uniform (avg={avg_length:.0f}, "
+            f"std={std_length:.1f}). Mix short (5-10 words) and long "
+            f"(20-30 words) sentences."
+        )
+
+    if unique_first_words < 0.5:
+        repeated = [w for w in set(first_words) if first_words.count(w) > 2]
+        issues.append(
+            f"Too many sentences start with the same word: {repeated}. "
+            f"Vary sentence openings."
+        )
+
+    # Check for consecutive similar-length sentences
+    uniform_runs = 0
+    for i in range(1, len(lengths)):
+        if abs(lengths[i] - lengths[i-1]) < 3:
+            uniform_runs += 1
+
+    if uniform_runs > len(lengths) * 0.6:
+        issues.append("Too many consecutive sentences with similar lengths.")
+
+    return {
+        'avg_sentence_length': round(avg_length, 1),
+        'length_std': round(std_length, 1),
+        'first_word_variety': round(unique_first_words, 2),
+        'issues': issues,
+        'assessment': 'natural' if not issues else 'needs_revision'
+    }
+```
+
+### Voice and Perspective
+
+AI text often defaults to an impersonal, overly balanced voice. Academic writing benefits from:
+
+1. **Authorial voice**: Use "we" in multi-author papers. Take clear positions.
+2. **Disciplinary conventions**: Match the register of your target journal (some are more formal, others more conversational).
+3. **Specific over general**: Replace "many researchers have studied X" with "Smith (2020), Jones (2021), and Lee (2023) each approached X differently."
+4. **Genuine hedging**: Use hedging when genuinely uncertain, not as a default.
+
+## Workflow for AI-Assisted Writing
+
+```
+Step 1: Draft with AI assistance (outline, first draft)
+Step 2: Print the draft and read aloud -- mark anything that sounds generic
+Step 3: Replace flagged phrases with your natural voice
+Step 4: Add personal scholarly judgment (interpretations, critiques)
+Step 5: Insert discipline-specific terminology and citations
+Step 6: Vary sentence structure and paragraph length
+Step 7: Run the pattern detector to catch remaining AI fingerprints
+Step 8: Final read-aloud check
+```
+
+## Ethical Considerations
+
+Using AI for writing assistance is increasingly accepted in academia, but transparency is essential. Many journals now require disclosure of AI tool usage. The key ethical principle: you must deeply understand and stand behind every claim in the final text. AI is a drafting tool; scholarly judgment and intellectual ownership remain yours.

package/skills/writing/polish/grammar-checker-guide/SKILL.md

@@ -0,0 +1,184 @@
+---
+name: grammar-checker-guide
+description: "Use grammar and style checking tools to polish academic manuscripts"
+metadata:
+  openclaw:
+    emoji: "pencil2"
+    category: "writing"
+    subcategory: "polish"
+    keywords: ["grammar checker", "academic style", "proofreading", "writing tools", "language editing"]
+    source: "wentor-research-plugins"
+---
+
+# Grammar Checker Guide
+
+A skill for using grammar and style checking tools to polish academic manuscripts. Covers tool comparison, configuration for scholarly writing, common academic English pitfalls, and workflows for integrating automated checking into the writing process.
+
+## Tool Comparison
+
+### Overview
+
+| Tool | Best For | Academic Mode? | Privacy | Cost |
+|------|----------|---------------|---------|------|
+| Grammarly | General grammar, clarity | Yes (tone settings) | Cloud-based | Free / Premium |
+| LanguageTool | Open-source, privacy | Yes (formal style) | Self-hostable | Free / Premium |
+| ProWritingAid | Style depth, reports | Yes (academic style) | Cloud-based | Subscription |
+| Writefull | Academic-specific | Designed for academic | Cloud-based | Free / Premium |
+| Vale | CLI/CI linting for docs | Configurable rules | Local only | Free (open-source) |
+
+### Privacy Considerations
+
+```
+For unpublished research:
+  - Check the tool's data retention policy before pasting manuscript text
+  - LanguageTool can be self-hosted (no data leaves your machine)
+  - Vale runs entirely locally
+  - Grammarly Enterprise offers data processing agreements
+
+For sensitive or embargoed work:
+  - Use local-only tools (Vale, local LanguageTool server)
+  - Avoid pasting full manuscripts into cloud-based free tiers
+  - Review the tool's terms regarding data use for model training
+```
+
+## Configuring Tools for Academic Writing
+
+### LanguageTool Setup
+
+```python
+import os
+import json
+import urllib.request
+
+
+def check_text_with_languagetool(text: str, language: str = "en-US") -> list:
+    """
+    Check text using the LanguageTool API.
+
+    Args:
+        text: The text to check
+        language: Language code (en-US, en-GB, de-DE, etc.)
+    """
+    api_url = os.environ.get(
+        "LANGUAGETOOL_URL",
+        "https://api.languagetool.org/v2/check"
+    )
+
+    data = urllib.parse.urlencode({
+        "text": text,
+        "language": language,
+        "enabledCategories": "GRAMMAR,TYPOS,PUNCTUATION,STYLE",
+        "level": "picky"
+    }).encode("utf-8")
+
+    req = urllib.request.Request(api_url, data=data)
+    response = urllib.request.urlopen(req)
+    result = json.loads(response.read())
+
+    issues = []
+    for match in result.get("matches", []):
+        issues.append({
+            "message": match["message"],
+            "context": match["context"]["text"],
+            "offset": match["offset"],
+            "length": match["length"],
+            "suggestions": [r["value"] for r in match.get("replacements", [])[:3]],
+            "rule_id": match["rule"]["id"]
+        })
+
+    return issues
+```
+
+### Vale Configuration for Academic Prose
+
+```yaml
+# .vale.ini -- place in your project root
+StylesPath = styles
+MinAlertLevel = suggestion
+
+[*.md]
+BasedOnStyles = Vale, academic
+
+[*.tex]
+BasedOnStyles = Vale, academic
+
+# Custom academic rules (styles/academic/):
+# - Flag passive voice overuse
+# - Warn about hedging ("it is believed that")
+# - Flag jargon and nominalization
+# - Check for consistent spelling (US vs. UK English)
+```
+
+## Common Academic English Issues
+
+### Grammar Pitfalls
+
+```
+1. Subject-verb agreement with collective nouns:
+   Wrong:  "The data shows a clear trend."
+   Right:  "The data show a clear trend." (data is plural in academic English)
+   Note:   "The dataset shows..." is acceptable (dataset is singular)
+
+2. Tense consistency:
+   Methods:     Past tense ("We collected samples...")
+   Results:     Past tense ("The analysis revealed...")
+   Discussion:  Present tense for established knowledge
+                ("These results suggest that X plays a role...")
+
+3. Article usage:
+   Wrong:  "In the Section 3, we describe method."
+   Right:  "In Section 3, we describe the method."
+
+4. Dangling modifiers:
+   Wrong:  "Using regression analysis, the results showed..."
+   Right:  "Using regression analysis, we found that..."
+```
+
+### Style Improvements
+
+```
+Wordiness -> Concise:
+  "due to the fact that"    -> "because"
+  "in order to"             -> "to"
+  "a large number of"       -> "many"
+  "it is worth noting that" -> (delete, just state the point)
+  "at the present time"     -> "currently" or "now"
+
+Nominalization -> Verbal form:
+  "made an examination of"  -> "examined"
+  "conducted an analysis"   -> "analyzed"
+  "reached a conclusion"    -> "concluded"
+
+Passive -> Active (when appropriate):
+  "The samples were analyzed by us" -> "We analyzed the samples"
+  Note: Passive voice is acceptable in Methods for focus on procedure
+```
+
+## Workflow Integration
+
+### Recommended Editing Stages
+
+```
+Stage 1 - Content editing (you or co-authors):
+  Focus on argument structure, logic, completeness
+  Do NOT worry about grammar yet
+
+Stage 2 - Automated grammar check:
+  Run LanguageTool or Grammarly on the full manuscript
+  Review each suggestion -- reject false positives
+  Accept clear grammar and spelling fixes
+
+Stage 3 - Style pass:
+  Run ProWritingAid or Vale for style analysis
+  Address wordiness, passive voice overuse, readability
+  Check for consistent terminology throughout
+
+Stage 4 - Human proofreading:
+  Read aloud or have a colleague read
+  Catch issues that automated tools miss
+  Final check on formatting, references, figure labels
+```
+
+## Discipline-Specific Conventions
+
+Different fields have different style expectations. Medical journals expect CONSORT/STROBE language. Legal writing has distinct citation formats. Engineering papers tolerate more passive voice. Always check your target journal's author guidelines and recent publications to calibrate your style to audience expectations.

package/skills/writing/polish/plagiarism-detection-guide/SKILL.md

@@ -0,0 +1,167 @@
+---
+name: plagiarism-detection-guide
+description: "Use plagiarism detection tools and ensure manuscript originality"
+metadata:
+  openclaw:
+    emoji: "shield"
+    category: "writing"
+    subcategory: "polish"
+    keywords: ["plagiarism detection", "originality check", "Turnitin", "iThenticate", "self-plagiarism", "text similarity"]
+    source: "wentor-research-plugins"
+---
+
+# Plagiarism Detection Guide
+
+A skill for using plagiarism detection tools to ensure manuscript originality before submission. Covers major detection platforms, understanding similarity reports, avoiding self-plagiarism, paraphrasing best practices, and institutional policies.
+
+## Detection Tools Overview
+
+### Platform Comparison
+
+| Tool | Primary Users | Database | Cost |
+|------|-------------|----------|------|
+| iThenticate | Researchers, publishers | Crossref, web, dissertations | Subscription |
+| Turnitin | Universities (student work) | Student papers, web, journals | Institutional |
+| Copyscape | Web content | Web pages | Per-search or subscription |
+| Quetext | General | Web, academic | Free tier / Premium |
+| PlagScan | Academic, corporate | Web, internal database | Per-document |
+| Grammarly Premium | Writers | Web, ProQuest | Included in Premium |
+
+### What Detection Tools Check
+
+```
+Text matching (NOT idea matching):
+  - Tools compare your text against databases of published content
+  - They flag verbatim matches and close paraphrases
+  - They do NOT detect idea plagiarism or conceptual theft
+  - They do NOT understand context (quoted text may be flagged)
+
+Common databases searched:
+  - Published journal articles (via Crossref, Scopus partnerships)
+  - Web pages and online content
+  - Previously submitted student papers (Turnitin only)
+  - Books and dissertations (varies by tool)
+  - Preprint servers (arXiv, SSRN)
+```
+
+## Understanding Similarity Reports
+
+### Reading the Report
+
+```python
+def interpret_similarity_score(total_score: float,
+                                source_breakdown: list[dict]) -> dict:
+    """
+    Interpret a plagiarism detection similarity report.
+
+    Args:
+        total_score: Overall similarity percentage
+        source_breakdown: List of dicts with 'source', 'percentage', 'type'
+    """
+    interpretation = {
+        "total_similarity": total_score,
+        "risk_level": (
+            "low" if total_score < 15
+            else "moderate" if total_score < 30
+            else "high"
+        ),
+        "guidance": {
+            "low": (
+                "Under 15% is typical for original research papers. "
+                "Review flagged sections to confirm they are properly quoted "
+                "or are common phrases."
+            ),
+            "moderate": (
+                "15-30% warrants review. Check if matches are from your own "
+                "prior work (self-citation), methods sections using standard "
+                "language, or properly attributed quotations."
+            ),
+            "high": (
+                "Over 30% requires careful review. Large blocks of matched "
+                "text must be rewritten, quoted, or properly attributed. "
+                "Note: review articles and meta-analyses may legitimately "
+                "have higher similarity scores."
+            )
+        }
+    }
+
+    # Categorize sources
+    for src in source_breakdown:
+        src["action"] = (
+            "Verify proper citation" if src["type"] == "journal_article"
+            else "Check if self-plagiarism" if src["type"] == "own_prior_work"
+            else "Rewrite or quote with attribution"
+        )
+
+    interpretation["sources"] = source_breakdown
+    return interpretation
+```
+
+### Acceptable vs. Problematic Matches
+
+```
+Typically acceptable:
+  - Reference list entries
+  - Standard methodology descriptions ("Informed consent was obtained...")
+  - Widely used definitions or established terminology
+  - Properly quoted and attributed passages
+  - Author name and affiliation blocks
+  - Common phrases ("on the other hand", "in this study")
+
+Potentially problematic:
+  - Paragraphs copied from other papers without quotation or citation
+  - Closely paraphrased passages without citation
+  - Reuse of your own prior text without disclosure (self-plagiarism)
+  - Translated text from another language without attribution
+  - Figures, tables, or data descriptions from other sources
+```
+
+## Avoiding Self-Plagiarism
+
+### What Counts as Self-Plagiarism
+
+```
+Self-plagiarism occurs when you reuse substantial portions of your
+own previously published text without disclosure. This is an issue
+because publishers hold copyright on your published work.
+
+Problematic:
+  - Copying methods paragraphs from your prior paper verbatim
+  - Reusing introduction or discussion text across papers
+  - "Salami slicing" -- publishing the same data in multiple papers
+
+Acceptable:
+  - Building on your own prior findings (with proper citation)
+  - Reusing brief, standard methodological phrases
+  - Reproducing your own figures with permission and citation
+  - Theses/dissertations reused in subsequent journal articles
+    (check journal policy -- most allow this)
+```
+
+## Paraphrasing Best Practices
+
+### Effective Rewriting Strategy
+
+```
+Step 1: Read the source passage carefully
+Step 2: Close the source -- do not look at it
+Step 3: Write the idea in your own words from memory
+Step 4: Compare with the original for accuracy
+Step 5: Add the citation
+
+Test: If you can cover the original and still write the passage,
+you have genuinely paraphrased. If you need to keep looking back
+and changing individual words, you are patch-writing (still plagiarism).
+```
+
+### Common Paraphrasing Errors
+
+| Error | Example | Fix |
+|-------|---------|-----|
+| Word swapping | "Important" becomes "significant" with same structure | Restructure the entire sentence |
+| Patchwriting | Changing a few words but keeping sentence structure | Write from understanding, not from text |
+| Missing citation | Good paraphrase but no in-text citation | Always cite the source of the idea |
+
+## Pre-Submission Checklist
+
+Before submitting your manuscript, verify: all direct quotes are in quotation marks with page numbers, all paraphrased ideas have in-text citations, methods text is rewritten rather than copied from prior papers, any reuse of your own prior text is disclosed to the editor, and your similarity report shows no large unattributed matches. Run the detection tool on your final manuscript version, not an earlier draft, to ensure all revisions are captured.