@wentorai/research-plugins 1.0.0

package/skills/domains/cs/algorithms-complexity-guide/SKILL.md

@@ -0,0 +1,194 @@
+---
+name: algorithms-complexity-guide
+description: "Analyze algorithm complexity and computational efficiency for research"
+metadata:
+  openclaw:
+    emoji: "gear"
+    category: "domains"
+    subcategory: "cs"
+    keywords: ["algorithms", "computational complexity", "Big-O", "NP-hard", "optimization", "data structures"]
+    source: "wentor-research-plugins"
+---
+
+# Algorithms and Complexity Guide
+
+A skill for analyzing algorithm complexity and computational efficiency in research contexts. Covers asymptotic notation, common complexity classes, NP-completeness, amortized analysis, and strategies for presenting algorithmic contributions in papers.
+
+## Asymptotic Notation
+
+### Big-O, Omega, and Theta
+
+```
+O(f(n))   -- Upper bound (worst case, "at most")
+            T(n) is O(f(n)) if T(n) <= c * f(n) for large n
+
+Omega(f(n)) -- Lower bound (best case, "at least")
+               T(n) is Omega(f(n)) if T(n) >= c * f(n) for large n
+
+Theta(f(n)) -- Tight bound (exact asymptotic growth)
+               Both O(f(n)) and Omega(f(n))
+
+Common growth rates (slowest to fastest):
+  O(1) < O(log n) < O(sqrt(n)) < O(n) < O(n log n) < O(n^2) < O(n^3) < O(2^n) < O(n!)
+```
+
+### Practical Interpretation
+
+```python
+def estimate_runtime(n: int, complexity: str) -> dict:
+    """
+    Estimate practical runtime for common complexities.
+
+    Args:
+        n: Input size
+        complexity: Complexity class string
+    """
+    import math
+
+    complexities = {
+        "O(1)": 1,
+        "O(log n)": math.log2(max(n, 1)),
+        "O(n)": n,
+        "O(n log n)": n * math.log2(max(n, 1)),
+        "O(n^2)": n ** 2,
+        "O(n^3)": n ** 3,
+        "O(2^n)": 2 ** min(n, 40),  # Cap to avoid overflow
+    }
+
+    operations = complexities.get(complexity, n)
+
+    # Assuming ~10^9 operations per second
+    seconds = operations / 1e9
+
+    return {
+        "input_size": n,
+        "complexity": complexity,
+        "estimated_operations": operations,
+        "estimated_time": (
+            f"{seconds:.2e} seconds"
+            if seconds < 60
+            else f"{seconds / 60:.1f} minutes"
+            if seconds < 3600
+            else f"{seconds / 3600:.1f} hours"
+        ),
+        "feasible": operations < 1e12  # Roughly 1000 seconds
+    }
+```
+
+## Complexity Classes
+
+### P, NP, and Beyond
+
+```
+P:     Problems solvable in polynomial time
+       Examples: Sorting, shortest path, MST, linear programming
+
+NP:    Problems verifiable in polynomial time
+       (Given a solution, can check it quickly)
+       Examples: SAT, TSP, graph coloring, subset sum
+
+NP-Complete: The "hardest" problems in NP
+             If any one is in P, then P = NP
+             Proven via reduction from a known NP-complete problem
+
+NP-Hard:   At least as hard as NP-complete
+           Not necessarily in NP (may not even be decision problems)
+           Examples: Optimization versions of NP-complete problems
+
+PSPACE:    Solvable with polynomial space (possibly exponential time)
+           Examples: QBF, certain game-theoretic problems
+```
+
+### Proving NP-Completeness
+
+```
+To prove problem X is NP-complete:
+  1. Show X is in NP:
+     - Given a certificate (proposed solution), verify it in poly time
+
+  2. Reduce a known NP-complete problem Y to X:
+     - Construct a polynomial-time transformation f
+       such that Y has solution iff f(Y) has solution in X
+     - Common starting problems: SAT, 3-SAT, Vertex Cover,
+       Hamiltonian Path, Subset Sum
+```
+
+## Algorithm Analysis Techniques
+
+### Recurrence Relations
+
+```
+For divide-and-conquer algorithms, solve recurrences:
+
+Master Theorem: T(n) = a * T(n/b) + O(n^d)
+
+  Case 1: d < log_b(a)  ->  T(n) = O(n^(log_b(a)))
+  Case 2: d = log_b(a)  ->  T(n) = O(n^d * log n)
+  Case 3: d > log_b(a)  ->  T(n) = O(n^d)
+
+Examples:
+  Merge Sort:    T(n) = 2T(n/2) + O(n)     -> O(n log n)  [Case 2]
+  Binary Search: T(n) = T(n/2) + O(1)       -> O(log n)    [Case 2]
+  Strassen:      T(n) = 7T(n/2) + O(n^2)   -> O(n^2.81)   [Case 1]
+```
+
+### Amortized Analysis
+
+```
+Amortized analysis provides the average cost per operation over
+a worst-case sequence of operations.
+
+Methods:
+  - Aggregate method: Total cost / number of operations
+  - Accounting method: Assign "credits" to cheap operations
+  - Potential method: Define a potential function
+
+Example: Dynamic array (ArrayList)
+  Most insertions: O(1)
+  Occasional resize: O(n)
+  Amortized cost per insertion: O(1)
+  (The expensive resizes are rare enough that the average stays constant)
+```
+
+## Presenting Algorithms in Papers
+
+### Algorithm Pseudocode Standards
+
+```latex
+% Use the algorithm2e or algorithmicx package in LaTeX
+
+\begin{algorithm}[H]
+\caption{Description of Algorithm}
+\label{alg:myalgorithm}
+\KwIn{Input description}
+\KwOut{Output description}
+
+initialization\;
+\While{condition}{
+    compute something\;
+    \If{condition}{
+        action\;
+    }
+}
+\Return result\;
+\end{algorithm}
+```
+
+### What to Include in an Algorithms Paper
+
+```
+1. Problem definition (formal, with input/output specification)
+2. Related work and existing approaches with their complexities
+3. Algorithm description (pseudocode + English explanation)
+4. Correctness proof (invariants, termination argument)
+5. Complexity analysis (time and space, worst/average/amortized)
+6. Experimental evaluation:
+   - Comparison with baselines on standard benchmarks
+   - Runtime scaling with input size (empirical vs. theoretical)
+   - Real-world datasets in addition to synthetic ones
+7. Discussion of practical considerations (constants, cache behavior)
+```
+
+## Dealing with Intractability
+
+When you encounter NP-hard problems in your research, consider: polynomial-time approximation algorithms (with provable approximation ratios), heuristics (greedy, local search, simulated annealing), fixed-parameter tractable (FPT) algorithms if a relevant parameter is small, integer linear programming (ILP) solvers for moderate-size instances, or restricting to special cases where the problem becomes tractable (e.g., trees, planar graphs).

package/skills/domains/cs/dblp-api/SKILL.md

@@ -0,0 +1,129 @@
+---
+name: dblp-api
+description: "Search computer science publications, authors, and venues via DBLP"
+metadata:
+  openclaw:
+    emoji: "🔍"
+    category: "domains"
+    subcategory: "cs"
+    keywords: ["algorithms", "data structures", "software engineering", "database", "academic database search"]
+    source: "https://dblp.org/faq/1474707.html"
+---
+
+# DBLP API Guide
+
+## Overview
+
+DBLP (Digital Bibliography and Library Project) is the most comprehensive open bibliographic database for computer science. Maintained by Schloss Dagstuhl - Leibniz Center for Informatics, DBLP indexes over 6.5 million publications from thousands of journals, conference proceedings, and informal publication venues in computer science and related fields.
+
+DBLP is widely regarded as the authoritative source for computer science bibliographic data. It is used by researchers for tracking publication records, by hiring committees for evaluating academic productivity, and by bibliometric tools for analyzing the computer science research landscape. Each author in DBLP has a unique profile page with a complete, disambiguated publication list.
+
+The API is entirely free and open, requiring no authentication. There are no published rate limits, though users are expected to be respectful and avoid excessive load on the servers. All data is available under the ODC-BY license.
+
+## Authentication
+
+No authentication required. The DBLP API is fully open and free to use. No API key, registration, or email is needed. Users should include a descriptive User-Agent header and avoid sending excessive concurrent requests.
+
+## Core Endpoints
+
+### Publication Search: Find Computer Science Papers
+
+- **URL**: `GET https://dblp.org/search/publ/api`
+- **Parameters**:
+  | Param | Type | Required | Description |
+  |-------|------|----------|-------------|
+  | q | string | Yes | Search query (supports author:, venue:, year: prefixes) |
+  | format | string | No | Response format: json, xml (default: xml) |
+  | h | integer | No | Number of results (default: 30, max: 1000) |
+  | f | integer | No | Starting offset for pagination (default: 0) |
+  | c | integer | No | Maximum completions in auto-suggest mode |
+- **Example**:
+  ```bash
+  curl "https://dblp.org/search/publ/api?q=graph+neural+networks&format=json&h=10&f=0"
+  ```
+- **Response**: JSON with `result.hits` containing `@total` count and `hit` array. Each hit has `info` with `title`, `authors.author`, `venue`, `year`, `type`, `doi`, `url`, and `ee` (electronic edition link).
+
+### Author Search: Find Researchers
+
+- **URL**: `GET https://dblp.org/search/author/api`
+- **Parameters**:
+  | Param | Type | Required | Description |
+  |-------|------|----------|-------------|
+  | q | string | Yes | Author name query |
+  | format | string | No | Response format: json, xml |
+  | h | integer | No | Number of results (default: 30) |
+  | f | integer | No | Starting offset |
+- **Example**:
+  ```bash
+  curl "https://dblp.org/search/author/api?q=Yann+LeCun&format=json&h=5"
+  ```
+- **Response**: JSON with matched author profiles including `author` name, `url` (DBLP profile URL), and optional `notes` with affiliation information.
+
+### Venue Search: Find Journals and Conferences
+
+- **URL**: `GET https://dblp.org/search/venue/api`
+- **Parameters**:
+  | Param | Type | Required | Description |
+  |-------|------|----------|-------------|
+  | q | string | Yes | Venue name query |
+  | format | string | No | Response format: json, xml |
+  | h | integer | No | Number of results |
+  | f | integer | No | Starting offset |
+- **Example**:
+  ```bash
+  curl "https://dblp.org/search/venue/api?q=NeurIPS&format=json&h=5"
+  ```
+- **Response**: JSON with matched venue names, acronyms, and DBLP venue URLs.
+
+### Author Profile: Full Publication List
+
+- **URL**: `GET https://dblp.org/pid/{pid}.json`
+- **Parameters**:
+  | Param | Type | Required | Description |
+  |-------|------|----------|-------------|
+  | pid | string | Yes | DBLP person ID (e.g., h/GeoffreyEHinton) from author search results |
+- **Example**:
+  ```bash
+  curl "https://dblp.org/pid/h/GeoffreyEHinton.json"
+  ```
+- **Response**: JSON with full author profile including name variants, affiliation, and complete publication list with metadata.
+
+## Rate Limits
+
+No published rate limits. DBLP does not enforce strict API quotas. However, the service is provided by a non-profit institution with limited resources. Best practices include limiting requests to a reasonable rate (1-2 per second), using caching for repeated queries, and downloading the DBLP XML dump for large-scale analyses instead of querying the API repeatedly.
+
+## Common Patterns
+
+### Track an Author's Publication Record
+
+Get a complete, chronological list of publications for a researcher:
+
+```bash
+# Step 1: Find the author's DBLP PID
+curl "https://dblp.org/search/author/api?q=Jure+Leskovec&format=json&h=1"
+
+# Step 2: Fetch their full profile
+curl "https://dblp.org/pid/l/JureLeskovec.json"
+```
+
+### Find Top Papers at a Conference
+
+Search for publications at a specific venue in a given year:
+
+```bash
+curl "https://dblp.org/search/publ/api?q=venue:ICML+year:2024&format=json&h=50"
+```
+
+### Cross-Reference with DOI
+
+Use DBLP records to find DOIs and link to other metadata sources:
+
+```bash
+curl "https://dblp.org/search/publ/api?q=attention+is+all+you+need&format=json&h=1" | jq '.result.hits.hit[0].info.doi'
+```
+
+## References
+
+- Official documentation: https://dblp.org/faq/1474707.html
+- DBLP XML dump: https://dblp.org/xml/
+- DBLP statistics: https://dblp.org/statistics/

package/skills/domains/cs/software-engineering-research/SKILL.md

@@ -0,0 +1,218 @@
+---
+name: software-engineering-research
+description: "Guide to software engineering research topics and methodologies"
+metadata:
+  openclaw:
+    emoji: "code"
+    category: "domains"
+    subcategory: "cs"
+    keywords: ["software engineering", "distributed systems", "cybersecurity", "HCI"]
+    source: "wentor-research-plugins"
+---
+
+# Software Engineering Research Guide
+
+Navigate the landscape of software engineering research, including key subfields, methodologies, datasets, benchmarks, and top venues.
+
+## SE Research Subfields
+
+| Subfield | Key Topics | Major Venues |
+|----------|-----------|-------------|
+| **Software Testing** | Test generation, fuzzing, mutation testing, flaky tests | ISSTA, ICST, ASE |
+| **Program Analysis** | Static analysis, abstract interpretation, symbolic execution | PLDI, POPL, OOPSLA |
+| **Software Maintenance** | Code refactoring, technical debt, code smells, evolution | ICSME, MSR, SANER |
+| **SE for AI/ML** | ML pipeline testing, data quality, model debugging | ICSE-SEIP, FSE |
+| **AI for SE** | Code generation, bug detection, program repair | ICSE, FSE, ASE |
+| **Distributed Systems** | Consensus, fault tolerance, scalability, microservices | SOSP, OSDI, EuroSys |
+| **Cybersecurity** | Vulnerability detection, malware analysis, privacy | IEEE S&P, CCS, USENIX Security |
+| **HCI in SE** | Developer tools, IDE usability, code comprehension | CHI, CSCW, VL/HCC |
+| **Empirical SE** | Mining repositories, developer surveys, controlled experiments | ESEM, MSR, TOSEM |
+
+## Research Methodologies in SE
+
+### Controlled Experiments
+
+Testing a specific hypothesis with treatment and control groups:
+
+```markdown
+Example: Does AI code completion improve developer productivity?
+
+Design:
+- Participants: 60 professional developers
+- Treatment: IDE with AI code completion enabled
+- Control: IDE with AI code completion disabled
+- Task: Complete 5 programming tasks of varying difficulty
+- Metrics: Task completion time, code correctness, lines of code
+- Analysis: Mixed-effects linear model with participant as random effect
+
+Threats to validity:
+- Internal: Learning effect (counterbalance task order)
+- External: Lab setting may not reflect real development
+- Construct: "Productivity" operationalized as speed + correctness
+```
+
+### Mining Software Repositories (MSR)
+
+Analyzing data from version control, issue trackers, code review systems:
+
+```python
+# Example: Analyze commit patterns using PyDriller
+from pydriller import Repository
+
+repo_url = "https://github.com/apache/kafka"
+
+commit_data = []
+for commit in Repository(repo_url, since=datetime(2023, 1, 1),
+                          to=datetime(2023, 12, 31)).traverse_commits():
+    commit_data.append({
+        "hash": commit.hash[:8],
+        "author": commit.author.name,
+        "date": commit.committer_date,
+        "files_changed": commit.files,
+        "insertions": commit.insertions,
+        "deletions": commit.deletions,
+        "message": commit.msg[:100]
+    })
+
+df = pd.DataFrame(commit_data)
+print(f"Total commits in 2023: {len(df)}")
+print(f"Unique contributors: {df['author'].nunique()}")
+print(f"Avg files per commit: {df['files_changed'].mean():.1f}")
+```
+
+### Case Studies
+
+In-depth investigation of a phenomenon in its real-world context:
+
+```markdown
+Case Study Protocol (based on Yin, 2018):
+1. Research questions: How do teams adopt microservices?
+2. Unit of analysis: Development teams at 3 companies
+3. Data sources:
+   - Semi-structured interviews (8-12 per company)
+   - Architecture documentation review
+   - Commit history and deployment logs
+   - Meeting observations
+4. Analysis: Thematic analysis with cross-case comparison
+5. Validity: Triangulation across data sources, member checking
+```
+
+## Key Datasets and Benchmarks
+
+### Code Understanding and Generation
+
+| Benchmark | Task | Languages | Size |
+|-----------|------|-----------|------|
+| HumanEval | Code generation from docstrings | Python | 164 problems |
+| MBPP | Code generation from descriptions | Python | 974 problems |
+| SWE-bench | Real-world GitHub issue resolution | Python | 2,294 instances |
+| CodeXGLUE | Multiple code tasks | 6 languages | Varies by task |
+| BigCloneBench | Clone detection | Java | 6M clone pairs |
+| Defects4J | Bug localization and repair | Java | 835 real bugs |
+
+### Software Engineering Process
+
+| Dataset | Content | Use Cases |
+|---------|---------|-----------|
+| GHTorrent | GitHub event data (commits, issues, PRs) | MSR studies |
+| Software Heritage | Universal source code archive | Code evolution, provenance |
+| Stack Overflow Data Dump | Q&A posts, tags, votes | Developer knowledge, NLP |
+| CVE Database | Vulnerability records | Security research |
+| Chrome/Firefox Bug Trackers | Bug reports, patches | Bug triage, severity prediction |
+
+## Static Analysis Tools for Research
+
+```python
+# Example: Using tree-sitter for AST-level code analysis
+from tree_sitter import Language, Parser
+import tree_sitter_python as tspython
+
+PYTHON_LANGUAGE = Language(tspython.language())
+parser = Parser(PYTHON_LANGUAGE)
+
+source_code = b"""
+def fibonacci(n):
+    if n <= 1:
+        return n
+    return fibonacci(n-1) + fibonacci(n-2)
+"""
+
+tree = parser.parse(source_code)
+root = tree.root_node
+
+def count_nodes(node, node_type):
+    """Count AST nodes of a given type."""
+    count = 1 if node.type == node_type else 0
+    for child in node.children:
+        count += count_nodes(child, node_type)
+    return count
+
+print(f"Function definitions: {count_nodes(root, 'function_definition')}")
+print(f"If statements: {count_nodes(root, 'if_statement')}")
+print(f"Return statements: {count_nodes(root, 'return_statement')}")
+print(f"Function calls: {count_nodes(root, 'call')}")
+```
+
+## Code Metrics
+
+```python
+# Common software metrics
+metrics = {
+    "Lines of Code (LOC)": "Total lines (including blanks and comments)",
+    "Cyclomatic Complexity": "Number of independent paths (McCabe, 1976)",
+    "Halstead Volume": "Based on operators and operands count",
+    "Maintainability Index": "Composite of LOC, CC, and Halstead",
+    "Coupling Between Objects": "Number of other classes referenced",
+    "Depth of Inheritance": "Levels in class hierarchy",
+    "Code Churn": "Lines added + modified + deleted per period",
+    "Comment Density": "Ratio of comment lines to total lines"
+}
+
+# Calculate cyclomatic complexity using radon
+# pip install radon
+import subprocess
+result = subprocess.run(
+    ["radon", "cc", "my_module.py", "-s", "-j"],
+    capture_output=True, text=True
+)
+print(result.stdout)
+```
+
+## Top Venues and Impact
+
+### Tier-1 SE Venues
+
+| Venue | Type | Acceptance Rate | Focus |
+|-------|------|-----------------|-------|
+| ICSE | Conference | ~22% | Broad SE |
+| FSE/ESEC | Conference | ~24% | Broad SE |
+| ASE | Conference | ~22% | Automated SE |
+| ISSTA | Conference | ~25% | Software testing |
+| MSR | Conference | ~30% | Mining repositories |
+| TOSEM | Journal | -- | Broad SE (ACM) |
+| TSE | Journal | -- | Broad SE (IEEE) |
+| EMSE | Journal | -- | Empirical SE (Springer) |
+
+### Systems and Security Venues
+
+| Venue | Type | Focus |
+|-------|------|-------|
+| SOSP/OSDI | Conference | Operating systems, distributed systems |
+| EuroSys | Conference | Systems (Europe) |
+| NSDI | Conference | Networked systems design |
+| IEEE S&P (Oakland) | Conference | Security and privacy |
+| USENIX Security | Conference | Security |
+| CCS | Conference | Computer and communications security |
+| NDSS | Conference | Network and distributed systems security |
+
+## Research Tools Ecosystem
+
+| Tool | Purpose | URL |
+|------|---------|-----|
+| PyDriller | Git repository mining (Python) | github.com/ishepard/pydriller |
+| Radon | Python code metrics | github.com/rubik/radon |
+| SonarQube | Multi-language static analysis | sonarqube.org |
+| Understand | Code analysis and metrics | scitools.com |
+| Joern | Code analysis platform (CPG) | joern.io |
+| CodeQL | Semantic code analysis | codeql.github.com |
+| tree-sitter | Incremental parsing library | tree-sitter.github.io |