@wentorai/research-plugins 1.0.0

package/skills/writing/templates/thesis-writing-guide/SKILL.md

@@ -0,0 +1,220 @@
+---
+name: thesis-writing-guide
+description: "Templates, formatting rules, and strategies for thesis and dissertation writing"
+metadata:
+  openclaw:
+    emoji: "📑"
+    category: "writing"
+    subcategory: "templates"
+    keywords: ["thesis template", "dissertation formatting", "journal formatting requirements", "page limit"]
+    source: "https://github.com/awesome-thesis/awesome-thesis"
+---
+
+# Thesis Writing Guide
+
+## Overview
+
+Writing a thesis or dissertation is the culminating challenge of graduate education. Unlike journal papers, a thesis demands sustained coherence across hundreds of pages, covering background, methodology, multiple studies, and synthesis. The formatting requirements are often institution-specific and unforgiving -- a misplaced margin or incorrect heading style can delay your defense.
+
+This guide draws from the awesome-thesis repository (626+ stars), which curates practical tips and tricks for computer science theses, and extends the advice to cover all disciplines. It covers thesis structure, LaTeX and Word templates, formatting checklists, writing strategies for long documents, and common pitfalls that delay graduation.
+
+Whether you are writing a master's thesis (50-100 pages) or a PhD dissertation (150-300 pages), the planning and execution patterns here will help you finish on time and produce a document you are proud of.
+
+## Thesis Structure
+
+### Standard Structure (Monograph Style)
+
+| Chapter | Content | Typical Pages |
+|---------|---------|---------------|
+| 1. Introduction | Problem, motivation, contributions, outline | 10-20 |
+| 2. Background | Core concepts, definitions, prerequisites | 15-25 |
+| 3. Related Work | Comprehensive literature review | 15-30 |
+| 4. Methodology | Your approach, design, algorithms | 20-40 |
+| 5. Experiments | Setup, results, analysis | 20-40 |
+| 6. Discussion | Interpretation, limitations, broader impact | 10-20 |
+| 7. Conclusion | Summary, contributions, future work | 5-10 |
+
+### Paper-Based (Compilation) Style
+
+Many institutions now accept theses composed of published papers:
+
+```
+Chapter 1: Introduction and Overview (new content, 15-20 pages)
+Chapter 2: Paper A (published, reformatted)
+Chapter 3: Paper B (published, reformatted)
+Chapter 4: Paper C (under review, reformatted)
+Chapter 5: Synthesis and Conclusion (new content, 10-15 pages)
+Appendix: Supplementary materials for each paper
+```
+
+The key challenge with compilation theses is the "red thread" -- the narrative that connects your papers into a coherent whole. The introduction and conclusion chapters carry this responsibility.
+
+## LaTeX Templates
+
+### University Template Setup
+
+Most universities provide official LaTeX templates. Here is a generic setup:
+
+```latex
+\documentclass[12pt, a4paper, twoside]{report}
+
+% Essential packages
+\usepackage[margin=1in, bindingoffset=0.5in]{geometry}
+\usepackage{setspace}
+\doublespacing
+\usepackage[hidelinks]{hyperref}
+\usepackage{cleveref}
+\usepackage[backend=biber, style=numeric]{biblatex}
+\addbibresource{thesis.bib}
+
+% Front matter
+\begin{document}
+\frontmatter
+\include{chapters/titlepage}
+\include{chapters/abstract}
+\include{chapters/acknowledgments}
+\tableofcontents
+\listoffigures
+\listoftables
+
+% Main content
+\mainmatter
+\include{chapters/introduction}
+\include{chapters/background}
+\include{chapters/related_work}
+\include{chapters/methodology}
+\include{chapters/experiments}
+\include{chapters/discussion}
+\include{chapters/conclusion}
+
+% Back matter
+\backmatter
+\printbibliography
+\appendix
+\include{chapters/appendix_a}
+\end{document}
+```
+
+### Popular Thesis Templates
+
+| Template | Institution/Style | Link |
+|----------|-------------------|------|
+| `thuthesis` | Tsinghua University | github.com/tuna/thuthesis |
+| `SJTUThesis` | Shanghai Jiao Tong | github.com/sjtug/SJTUThesis |
+| `Dissertate` | Harvard (multi-school) | github.com/suchow/Dissertate |
+| `novathesis` | Universidade Nova de Lisboa | github.com/joaomlourenco/novathesis |
+| `cleanthesis` | Generic clean style | github.com/derric/cleanthesis |
+
+### Project Organization
+
+```
+thesis/
+  main.tex                # Master file
+  thesis.bib              # Bibliography
+  chapters/
+    titlepage.tex
+    abstract.tex
+    introduction.tex
+    ...
+  figures/
+    ch1/
+    ch2/
+    ...
+  tables/
+  code/                   # Code listings
+  Makefile                # Build automation
+  .gitignore
+```
+
+## Writing Strategies for Long Documents
+
+### The Modular Writing Approach
+
+1. **Write chapters independently.** Each chapter should be understandable on its own before integration.
+2. **Start with the easiest chapter.** Often this is the Methods or a chapter based on a published paper.
+3. **Write the Introduction last.** You need to know all your contributions before you can introduce them.
+4. **Set daily word count targets.** 500 words/day produces a 100-page thesis in roughly 4 months of writing.
+
+### Timeline Planning
+
+For a 6-month writing period:
+
+| Month | Task | Deliverable |
+|-------|------|------------|
+| 1 | Outline all chapters; write Methods | Methods draft |
+| 2 | Write Experiments chapter | Experiments draft |
+| 3 | Write Background and Related Work | Literature review draft |
+| 4 | Write Discussion and Conclusion | Full rough draft |
+| 5 | Write Introduction; revise all chapters | Complete first draft |
+| 6 | Advisor review; final revisions; formatting | Submission-ready thesis |
+
+### Managing Advisor Feedback
+
+- Send one chapter at a time for review, not the entire thesis.
+- Include a cover note explaining what feedback you need (structure? content? prose?).
+- Allow 2 weeks per chapter for advisor review.
+- Track revisions using `latexdiff` or track changes in Word.
+
+```bash
+# Generate a visual diff between thesis versions
+latexdiff old_version.tex new_version.tex > diff.tex
+pdflatex diff.tex
+```
+
+## Formatting Checklist
+
+Before submission, verify every item:
+
+### Document-Level
+
+- [ ] Title page matches university template exactly.
+- [ ] Page numbers: roman for front matter, arabic for main text.
+- [ ] Margins meet requirements (typically 1-1.5 inch, larger on binding side).
+- [ ] Line spacing is correct (usually double-spaced; some allow 1.5).
+- [ ] Font and size comply (usually 12pt Times New Roman or Computer Modern).
+
+### Figures and Tables
+
+- [ ] All figures are referenced in the text.
+- [ ] Figure captions are below figures; table captions are above tables.
+- [ ] Resolution is at least 300 DPI for raster images.
+- [ ] All figures are readable in grayscale (accessibility).
+
+### References
+
+- [ ] All cited works appear in the bibliography.
+- [ ] All bibliography entries are cited in the text.
+- [ ] Citation style matches university requirements.
+- [ ] DOIs are included where available.
+
+### Front and Back Matter
+
+- [ ] Abstract is within the word limit.
+- [ ] Acknowledgments are complete (funding, advisor, committee, family).
+- [ ] Table of contents, list of figures, list of tables are up to date.
+- [ ] Appendices are properly numbered and referenced.
+
+## Common Pitfalls
+
+1. **Starting too late.** Begin writing during your research, not after.
+2. **Perfectionism on first drafts.** "Done is better than perfect" for draft 1.
+3. **Inconsistent notation.** Define a notation table and stick to it across all chapters.
+4. **Ignoring the formatting guide.** Read your university's thesis manual before writing, not the week before submission.
+5. **Not backing up.** Use Git + cloud storage. Losing a thesis to hardware failure is devastating and preventable.
+
+## Best Practices
+
+- **Use version control.** Git with a private GitHub/GitLab repository provides backup and history.
+- **Compile frequently.** Catch LaTeX errors early rather than debugging 200 pages of broken code.
+- **Create a glossary.** Define all domain-specific terms in one place for consistency.
+- **Write the abstract in three versions:** 50-word (elevator pitch), 150-word (standard), and 300-word (extended).
+- **Schedule your defense date early.** Having a deadline makes the writing timeline concrete.
+- **Read other theses from your lab.** They set expectations for scope, depth, and style.
+
+## References
+
+- [awesome-thesis](https://github.com/awesome-thesis/awesome-thesis) -- Practical thesis tips (626+ stars)
+- [How to Write a Thesis](https://www.ldeo.columbia.edu/~martins/sen_res/how_to_thesis.html) -- Columbia University guide
+- [Dissertate Template](https://github.com/suchow/Dissertate) -- Harvard multi-school LaTeX template
+- [latexdiff](https://ctan.org/pkg/latexdiff) -- Visual diff tool for LaTeX documents
+- [Overleaf Thesis Templates](https://www.overleaf.com/latex/templates/tagged/thesis) -- Gallery of institutional templates

package/src/tools/arxiv.ts

@@ -0,0 +1,131 @@
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
+
+const BASE = "https://export.arxiv.org/api/query";
+
+function parseArxivXml(xml: string) {
+  const entries: Record<string, unknown>[] = [];
+  const entryBlocks = xml.split("<entry>").slice(1);
+
+  for (const block of entryBlocks) {
+    const getText = (tag: string) => {
+      const m = block.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`));
+      return m ? m[1].trim() : "";
+    };
+
+    const getAll = (tag: string) => {
+      const results: string[] = [];
+      const re = new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`, "g");
+      let m;
+      while ((m = re.exec(block)) !== null) results.push(m[1].trim());
+      return results;
+    };
+
+    const getAttr = (tag: string, attr: string) => {
+      const m = block.match(new RegExp(`<${tag}[^>]*${attr}="([^"]*)"[^>]*/?>`, "g"));
+      return m
+        ? m.map((s) => {
+            const am = s.match(new RegExp(`${attr}="([^"]*)"`));
+            return am ? am[1] : "";
+          })
+        : [];
+    };
+
+    const id = getText("id");
+    const arxivId = id.replace("http://arxiv.org/abs/", "").replace(/v\d+$/, "");
+
+    entries.push({
+      arxiv_id: arxivId,
+      title: getText("title").replace(/\s+/g, " "),
+      summary: getText("summary").replace(/\s+/g, " "),
+      authors: getAll("name"),
+      published: getText("published"),
+      updated: getText("updated"),
+      categories: getAttr("category", "term"),
+      pdf_url: `https://arxiv.org/pdf/${arxivId}`,
+      abs_url: `https://arxiv.org/abs/${arxivId}`,
+      doi: getText("arxiv:doi"),
+      comment: getText("arxiv:comment"),
+    });
+  }
+
+  return entries;
+}
+
+export function createArxivTools(
+  _ctx: OpenClawPluginToolContext,
+  _api: OpenClawPluginApi,
+) {
+  return [
+    {
+      name: "search_arxiv",
+      description:
+        "Search arXiv preprint repository. Covers physics, math, CS, biology, quantitative finance, statistics, and more.",
+      inputSchema: Type.Object({
+        query: Type.String({
+          description:
+            "Search query. Supports field prefixes: ti: (title), au: (author), abs: (abstract), cat: (category). E.g. 'ti:transformer AND cat:cs.CL'",
+        }),
+        max_results: Type.Optional(
+          Type.Number({ description: "Max results (default 10, max 50)" }),
+        ),
+        sort_by: Type.Optional(
+          Type.String({
+            description:
+              "Sort by: 'relevance', 'lastUpdatedDate', 'submittedDate'",
+          }),
+        ),
+        sort_order: Type.Optional(
+          Type.String({ description: "Sort order: 'ascending' or 'descending'" }),
+        ),
+      }),
+      handler: async (input: {
+        query: string;
+        max_results?: number;
+        sort_by?: string;
+        sort_order?: string;
+      }) => {
+        const params = new URLSearchParams({
+          search_query: input.query,
+          max_results: String(Math.min(input.max_results ?? 10, 50)),
+          sortBy: input.sort_by ?? "relevance",
+          sortOrder: input.sort_order ?? "descending",
+        });
+
+        const res = await fetch(`${BASE}?${params}`);
+        if (!res.ok) return { error: `API error: ${res.status} ${res.statusText}` };
+        const xml = await res.text();
+
+        const totalMatch = xml.match(
+          /<opensearch:totalResults[^>]*>(\d+)<\/opensearch:totalResults>/,
+        );
+        const total = totalMatch ? parseInt(totalMatch[1], 10) : 0;
+
+        return {
+          total_results: total,
+          papers: parseArxivXml(xml),
+        };
+      },
+    },
+    {
+      name: "get_arxiv_paper",
+      description:
+        "Get detailed information about a specific arXiv paper by its ID.",
+      inputSchema: Type.Object({
+        arxiv_id: Type.String({
+          description: "arXiv paper ID, e.g. '2301.00001' or '2301.00001v2'",
+        }),
+      }),
+      handler: async (input: { arxiv_id: string }) => {
+        const id = input.arxiv_id.replace("arXiv:", "");
+        const params = new URLSearchParams({ id_list: id });
+        const res = await fetch(`${BASE}?${params}`);
+        if (!res.ok) return { error: `API error: ${res.status} ${res.statusText}` };
+        const xml = await res.text();
+        const papers = parseArxivXml(xml);
+        if (papers.length === 0) return { error: "Paper not found" };
+        return papers[0];
+      },
+    },
+  ];
+}

package/src/tools/crossref.ts

@@ -0,0 +1,112 @@
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
+
+const BASE = "https://api.crossref.org";
+
+export function createCrossRefTools(
+  _ctx: OpenClawPluginToolContext,
+  _api: OpenClawPluginApi,
+) {
+  const headers: Record<string, string> = {
+    "User-Agent": "ResearchPlugins/1.0 (https://wentor.ai; mailto:dev@wentor.ai)",
+  };
+
+  return [
+    {
+      name: "resolve_doi",
+      description:
+        "Resolve a DOI to get full bibliographic metadata from CrossRef (title, authors, journal, dates, references).",
+      inputSchema: Type.Object({
+        doi: Type.String({
+          description: "DOI to resolve, e.g. '10.1038/nature12373'",
+        }),
+      }),
+      handler: async (input: { doi: string }) => {
+        const doi = input.doi.replace(/^https?:\/\/doi\.org\//, "");
+        const res = await fetch(`${BASE}/works/${encodeURIComponent(doi)}`, {
+          headers,
+        });
+        if (!res.ok) return { error: `API error: ${res.status} ${res.statusText}` };
+        const data = await res.json();
+        const w = data.message;
+        return {
+          doi: w.DOI,
+          title: w.title?.[0],
+          authors: w.author?.map(
+            (a: Record<string, string>) => `${a.given ?? ""} ${a.family ?? ""}`.trim(),
+          ),
+          container_title: w["container-title"]?.[0],
+          published_date: w.published?.["date-parts"]?.[0]?.join("-"),
+          type: w.type,
+          is_referenced_by_count: w["is-referenced-by-count"],
+          references_count: w["references-count"],
+          issn: w.ISSN,
+          url: w.URL,
+          abstract: w.abstract,
+          license: w.license?.[0]?.URL,
+        };
+      },
+    },
+    {
+      name: "search_crossref",
+      description:
+        "Search CrossRef for scholarly works by query. Covers 150M+ DOIs across all publishers.",
+      inputSchema: Type.Object({
+        query: Type.String({ description: "Search query" }),
+        limit: Type.Optional(
+          Type.Number({ description: "Max results (default 10, max 100)" }),
+        ),
+        from_year: Type.Optional(
+          Type.Number({ description: "Published from this year onward" }),
+        ),
+        type: Type.Optional(
+          Type.String({
+            description:
+              "Work type filter: 'journal-article', 'book-chapter', 'proceedings-article', etc.",
+          }),
+        ),
+        sort: Type.Optional(
+          Type.String({
+            description: "Sort by: 'relevance', 'published', 'is-referenced-by-count'",
+          }),
+        ),
+      }),
+      handler: async (input: {
+        query: string;
+        limit?: number;
+        from_year?: number;
+        type?: string;
+        sort?: string;
+      }) => {
+        const params = new URLSearchParams({
+          query: input.query,
+          rows: String(Math.min(input.limit ?? 10, 100)),
+        });
+        if (input.from_year)
+          params.set("filter", `from-pub-date:${input.from_year}`);
+        if (input.type)
+          params.append("filter", `type:${input.type}`);
+        if (input.sort) params.set("sort", input.sort);
+
+        const res = await fetch(`${BASE}/works?${params}`, { headers });
+        if (!res.ok) return { error: `API error: ${res.status} ${res.statusText}` };
+        const data = await res.json();
+        return {
+          total_results: data.message?.["total-results"],
+          items: data.message?.items?.map((w: Record<string, unknown>) => ({
+            doi: w.DOI,
+            title: (w.title as string[])?.[0],
+            authors: (w.author as Record<string, string>[])
+              ?.slice(0, 5)
+              .map((a) => `${a.given ?? ""} ${a.family ?? ""}`.trim()),
+            container_title: (w["container-title"] as string[])?.[0],
+            published:
+              (w.published as Record<string, unknown>)?.["date-parts"],
+            type: w.type,
+            cited_by: w["is-referenced-by-count"],
+          })),
+        };
+      },
+    },
+  ];
+}

package/src/tools/openalex.ts

@@ -0,0 +1,174 @@
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
+
+const BASE = "https://api.openalex.org";
+
+export function createOpenAlexTools(
+  _ctx: OpenClawPluginToolContext,
+  _api: OpenClawPluginApi,
+) {
+  const headers: Record<string, string> = {
+    "User-Agent": "ResearchPlugins/1.0 (https://wentor.ai)",
+  };
+
+  return [
+    {
+      name: "search_openalex",
+      description:
+        "Search academic works via OpenAlex (free, no key required). Covers 250M+ works across all disciplines.",
+      inputSchema: Type.Object({
+        query: Type.String({ description: "Search query for works" }),
+        limit: Type.Optional(
+          Type.Number({ description: "Max results (default 10, max 200)" }),
+        ),
+        from_year: Type.Optional(
+          Type.Number({ description: "Filter works from this year onward" }),
+        ),
+        to_year: Type.Optional(
+          Type.Number({ description: "Filter works up to this year" }),
+        ),
+        open_access: Type.Optional(
+          Type.Boolean({ description: "Only open access works" }),
+        ),
+        sort_by: Type.Optional(
+          Type.String({
+            description: "Sort by: 'cited_by_count', 'publication_date', 'relevance_score'",
+          }),
+        ),
+      }),
+      handler: async (input: {
+        query: string;
+        limit?: number;
+        from_year?: number;
+        to_year?: number;
+        open_access?: boolean;
+        sort_by?: string;
+      }) => {
+        const filters: string[] = [];
+        if (input.from_year) filters.push(`from_publication_date:${input.from_year}-01-01`);
+        if (input.to_year) filters.push(`to_publication_date:${input.to_year}-12-31`);
+        if (input.open_access) filters.push("is_oa:true");
+
+        const params = new URLSearchParams({
+          search: input.query,
+          per_page: String(Math.min(input.limit ?? 10, 200)),
+        });
+        if (filters.length > 0) params.set("filter", filters.join(","));
+        if (input.sort_by) params.set("sort", input.sort_by);
+
+        const res = await fetch(`${BASE}/works?${params}`, { headers });
+        if (!res.ok) return { error: `API error: ${res.status} ${res.statusText}` };
+        const data = await res.json();
+        return {
+          total_count: data.meta?.count,
+          results: data.results?.map((w: Record<string, unknown>) => ({
+            id: w.id,
+            doi: w.doi,
+            title: w.title,
+            publication_date: w.publication_date,
+            cited_by_count: w.cited_by_count,
+            is_oa: w.open_access && (w.open_access as Record<string, unknown>).is_oa,
+            oa_url:
+              w.open_access && (w.open_access as Record<string, unknown>).oa_url,
+            authors: Array.isArray(w.authorships)
+              ? (w.authorships as Record<string, unknown>[]).slice(0, 5).map(
+                  (a) => (a.author as Record<string, unknown>)?.display_name,
+                )
+              : [],
+          })),
+        };
+      },
+    },
+    {
+      name: "get_work",
+      description:
+        "Get full details of a work by its OpenAlex ID, DOI, or other identifier.",
+      inputSchema: Type.Object({
+        work_id: Type.String({
+          description:
+            "Work identifier: OpenAlex ID (e.g. 'W2741809807'), DOI URL, or PMID",
+        }),
+      }),
+      handler: async (input: { work_id: string }) => {
+        const id = input.work_id.startsWith("10.")
+          ? `https://doi.org/${input.work_id}`
+          : input.work_id;
+        const res = await fetch(`${BASE}/works/${encodeURIComponent(id)}`, {
+          headers,
+        });
+        if (!res.ok) return { error: `API error: ${res.status} ${res.statusText}` };
+        const w = await res.json();
+        return {
+          id: w.id,
+          doi: w.doi,
+          title: w.title,
+          abstract: w.abstract,
+          publication_date: w.publication_date,
+          type: w.type,
+          cited_by_count: w.cited_by_count,
+          is_oa: w.open_access?.is_oa,
+          oa_url: w.open_access?.oa_url,
+          venue: w.primary_location?.source?.display_name,
+          authors: w.authorships?.map(
+            (a: Record<string, unknown>) =>
+              (a.author as Record<string, unknown>)?.display_name,
+          ),
+          concepts: w.concepts
+            ?.slice(0, 10)
+            .map((c: Record<string, unknown>) => c.display_name),
+          referenced_works_count: w.referenced_works?.length,
+        };
+      },
+    },
+    {
+      name: "get_author_openalex",
+      description:
+        "Get author information from OpenAlex including publications, h-index, and affiliations.",
+      inputSchema: Type.Object({
+        author_id: Type.String({
+          description:
+            "Author identifier: OpenAlex ID (e.g. 'A5023888391'), ORCID, or name search",
+        }),
+      }),
+      handler: async (input: { author_id: string }) => {
+        let url: string;
+        if (
+          input.author_id.startsWith("A") ||
+          input.author_id.startsWith("https://")
+        ) {
+          url = `${BASE}/authors/${encodeURIComponent(input.author_id)}`;
+        } else if (input.author_id.includes("-")) {
+          url = `${BASE}/authors/orcid:${input.author_id}`;
+        } else {
+          const params = new URLSearchParams({
+            search: input.author_id,
+            per_page: "5",
+          });
+          const res = await fetch(`${BASE}/authors?${params}`, { headers });
+          if (!res.ok) return { error: `API error: ${res.status} ${res.statusText}` };
+          return res.json();
+        }
+
+        const res = await fetch(url, { headers });
+        if (!res.ok) return { error: `API error: ${res.status} ${res.statusText}` };
+        const a = await res.json();
+        return {
+          id: a.id,
+          display_name: a.display_name,
+          orcid: a.orcid,
+          works_count: a.works_count,
+          cited_by_count: a.cited_by_count,
+          h_index: a.summary_stats?.h_index,
+          i10_index: a.summary_stats?.i10_index,
+          affiliations: a.affiliations?.map(
+            (af: Record<string, unknown>) =>
+              (af.institution as Record<string, unknown>)?.display_name,
+          ),
+          top_concepts: a.x_concepts
+            ?.slice(0, 5)
+            .map((c: Record<string, unknown>) => c.display_name),
+        };
+      },
+    },
+  ];
+}