@openhands/extensions 0.1.0 → 0.2.0

package/plugins/issue-duplicate-checker/scripts/post_duplicate_notice.js

@@ -0,0 +1,220 @@
+module.exports = async ({ github, context, core }) => {
+  const issueNumber = Number(process.env.ISSUE_NUMBER);
+  const summary = (process.env.SUMMARY || "").trim();
+  const classification = process.env.CLASSIFICATION || "no-match";
+  const autoClose = process.env.AUTO_CLOSE_CANDIDATE === "true";
+  const closeAfterDays = process.env.CLOSE_AFTER_DAYS || "3";
+  let candidates = [];
+  try {
+    candidates = JSON.parse(process.env.CANDIDATE_ISSUES_JSON || "[]");
+  } catch (error) {
+    core.setFailed(`Invalid candidate JSON: ${error.message}`);
+    return;
+  }
+  if (!Array.isArray(candidates)) {
+    core.setFailed("CANDIDATE_ISSUES_JSON is not an array");
+    return;
+  }
+  if (candidates.length === 0) {
+    core.warning(`No candidate issues were returned for issue #${issueNumber}; skipping.`);
+    return;
+  }
+
+  const canonicalIssueRaw = process.env.CANONICAL_ISSUE_NUMBER || candidates[0].number;
+  const canonicalIssueNumber = canonicalIssueRaw ? Number(canonicalIssueRaw) : Number.NaN;
+  const candidateLabel = "duplicate-candidate";
+
+  function parseDuplicateCheckMarker(body) {
+    if (!body) return null;
+    const match = body.match(/<!-- openhands-duplicate-check canonical=(\d+) auto-close=(true|false) -->/);
+    if (!match) return null;
+    return {
+      canonicalIssueNumber: Number(match[1]),
+      autoClose: match[2] === "true",
+    };
+  }
+
+  async function ensureCanonicalIssueIsOpenIssue() {
+    let canonicalIssue;
+    try {
+      ({ data: canonicalIssue } = await github.rest.issues.get({
+        owner: context.repo.owner,
+        repo: context.repo.repo,
+        issue_number: canonicalIssueNumber,
+      }));
+    } catch (error) {
+      if (error.status === 404) {
+        core.setFailed(`Canonical issue #${canonicalIssueNumber} does not exist.`);
+        return false;
+      }
+      throw error;
+    }
+    if (canonicalIssue.pull_request) {
+      core.setFailed(`Canonical issue #${canonicalIssueNumber} is a pull request, not an issue.`);
+      return false;
+    }
+    if (canonicalIssue.state !== "open" || canonicalIssue.locked) {
+      core.setFailed(`Canonical issue #${canonicalIssueNumber} must be an open, unlocked issue.`);
+      return false;
+    }
+    return true;
+  }
+
+  async function ensureCandidateLabelOnIssue() {
+    try {
+      await github.rest.issues.getLabel({
+        owner: context.repo.owner,
+        repo: context.repo.repo,
+        name: candidateLabel,
+      });
+    } catch (error) {
+      if (error.status !== 404) throw error;
+      await github.rest.issues.createLabel({
+        owner: context.repo.owner,
+        repo: context.repo.repo,
+        name: candidateLabel,
+        color: "f97316",
+        description: "Potential duplicate awaiting auto-close or maintainer review",
+      });
+    }
+
+    const { data: issue } = await github.rest.issues.get({
+      owner: context.repo.owner,
+      repo: context.repo.repo,
+      issue_number: issueNumber,
+    });
+    const labelNames = (issue.labels || []).map((label) =>
+      typeof label === "string" ? label : label.name,
+    );
+    if (!labelNames.includes(candidateLabel)) {
+      await github.rest.issues.addLabels({
+        owner: context.repo.owner,
+        repo: context.repo.repo,
+        issue_number: issueNumber,
+        labels: [candidateLabel],
+      });
+    }
+  }
+
+  async function removeCandidateLabelFromIssue() {
+    try {
+      await github.rest.issues.removeLabel({
+        owner: context.repo.owner,
+        repo: context.repo.repo,
+        issue_number: issueNumber,
+        name: candidateLabel,
+      });
+    } catch (error) {
+      if (error.status !== 404) throw error;
+    }
+  }
+
+  if (!Number.isInteger(canonicalIssueNumber) || canonicalIssueNumber <= 0) {
+    core.setFailed(`No canonical issue number was returned for issue #${issueNumber}.`);
+    return;
+  }
+  if (canonicalIssueNumber === issueNumber) {
+    core.setFailed(`Duplicate check cannot mark issue #${issueNumber} as a duplicate of itself.`);
+    return;
+  }
+
+  if (!(await ensureCanonicalIssueIsOpenIssue())) return;
+
+  const marker = `<!-- openhands-duplicate-check canonical=${canonicalIssueNumber} auto-close=${autoClose ? "true" : "false"} -->`;
+  const header = candidates.length === 1
+    ? "Found 1 possible duplicate issue:"
+    : `Found ${candidates.length} possible duplicate issues:`;
+  const candidateLines = candidates.map((candidate, index) =>
+    `${index + 1}. [#${candidate.number}](${candidate.url}) — ${candidate.title}`,
+  );
+
+  const sections = [];
+  if (summary) sections.push(summary, "");
+  sections.push(header, "", ...candidateLines);
+
+  if (classification === "overlapping-scope") {
+    sections.push(
+      "",
+      "These may not be exact duplicates, but the scope appears to overlap enough that keeping discussion in one place may be more useful.",
+    );
+  }
+
+  if (autoClose) {
+    sections.push(
+      "",
+      `This issue will be automatically closed as a duplicate in ${closeAfterDays} days.`,
+      "",
+      "- If your issue is a duplicate, please close it and 👍 the existing issue instead",
+      "- To prevent auto-closure, add a comment or 👎 this comment",
+    );
+  }
+
+  sections.push(
+    "",
+    marker,
+    "_This comment was created by an AI assistant (OpenHands) on behalf of the repository maintainer._",
+  );
+  const body = sections.join("\n").trim();
+
+  const maxCommentPages = 50;
+  let allComments = [];
+  let page = 1;
+  while (page <= maxCommentPages) {
+    const { data: comments } = await github.rest.issues.listComments({
+      owner: context.repo.owner,
+      repo: context.repo.repo,
+      issue_number: issueNumber,
+      per_page: 100,
+      page,
+    });
+    if (!comments || comments.length === 0) break;
+    allComments = allComments.concat(comments);
+    if (comments.length < 100) break;
+    page += 1;
+  }
+  if (page > maxCommentPages) {
+    core.setFailed(`Stopped loading comments for issue #${issueNumber} after ${maxCommentPages} pages.`);
+    return;
+  }
+
+  const existing = allComments.find((comment) =>
+    comment.body && comment.body.includes("<!-- openhands-duplicate-check "),
+  );
+  if (existing) {
+    const existingMarker = parseDuplicateCheckMarker(existing.body);
+    if (existingMarker) {
+      if (
+        existingMarker.canonicalIssueNumber !== canonicalIssueNumber ||
+        existingMarker.autoClose !== autoClose
+      ) {
+        await github.rest.issues.updateComment({
+          owner: context.repo.owner,
+          repo: context.repo.repo,
+          comment_id: existing.id,
+          body,
+        });
+        if (autoClose) await ensureCandidateLabelOnIssue();
+        else await removeCandidateLabelFromIssue();
+        core.info(`Updated existing duplicate check comment ${existing.id} on issue #${issueNumber}.`);
+        return;
+      }
+      if (autoClose) await ensureCandidateLabelOnIssue();
+      else await removeCandidateLabelFromIssue();
+    } else {
+      core.warning(
+        `Duplicate check comment already exists on issue #${issueNumber} but its marker could not be parsed; leaving label state unchanged.`,
+      );
+    }
+    core.info(`Duplicate check comment already exists on issue #${issueNumber}; skipping.`);
+    return;
+  }
+
+  await github.rest.issues.createComment({
+    owner: context.repo.owner,
+    repo: context.repo.repo,
+    issue_number: issueNumber,
+    body,
+  });
+
+  if (autoClose) await ensureCandidateLabelOnIssue();
+};

package/plugins/issue-duplicate-checker/scripts/remove_duplicate_candidate_label.js

@@ -0,0 +1,27 @@
+module.exports = async ({ github, context, core }) => {
+  const issueNumber = context.issue.number;
+  const commenter = context.payload.comment?.user?.login ?? "";
+  const normalizedCommenter = commenter.toLowerCase();
+
+  if (normalizedCommenter.endsWith("[bot]") || normalizedCommenter === "all-hands-bot") {
+    core.info(`Skipping duplicate-candidate label removal for bot comment from ${commenter || "unknown"}`);
+    return;
+  }
+
+  core.info(`Removing duplicate-candidate label from issue #${issueNumber} after comment from ${commenter}`);
+
+  try {
+    await github.rest.issues.removeLabel({
+      owner: context.repo.owner,
+      repo: context.repo.repo,
+      issue_number: issueNumber,
+      name: "duplicate-candidate",
+    });
+  } catch (error) {
+    if (error.status === 404) {
+      core.info(`duplicate-candidate label was already removed from issue #${issueNumber}`);
+      return;
+    }
+    throw error;
+  }
+};

package/plugins/magic-test/.plugin/plugin.json

@@ -0,0 +1,13 @@
+{
+  "name": "magic-test",
+  "version": "1.0.0",
+  "description": "A simple test plugin with a magic word skill for verifying plugin loading",
+  "author": {
+    "name": "OpenHands Test",
+    "email": "test@openhands.dev"
+  },
+  "homepage": "https://github.com/jpshackelford/openhands-sample-plugins",
+  "repository": "https://github.com/jpshackelford/openhands-sample-plugins",
+  "license": "MIT",
+  "keywords": ["test", "magic", "plugin", "verification"]
+}

package/plugins/magic-test/skills/magic-word/SKILL.md

@@ -0,0 +1,33 @@
+---
+description: A test skill that responds to the magic word "alakazam" with a specific phrase
+triggers:
+  - alakazam
+  - magic word
+  - abracadabra
+---
+
+# Magic Word Test Skill
+
+This skill is activated when the user says the magic word.
+
+## Instructions
+
+When the user mentions "alakazam", "abracadabra", or asks about the "magic word", you MUST respond with exactly:
+
+**"The magic worked! Plugin loaded successfully. 🎩✨"**
+
+Do not add any other explanation or content. Just output the exact phrase above.
+
+## Purpose
+
+This skill exists to verify that:
+1. The plugin was fetched correctly from the repository
+2. The skill was loaded and merged into the agent context  
+3. The skill triggers are working properly
+4. The skill instructions are being followed
+
+## Example
+
+User: "What happens if I say alakazam?"
+
+Expected response: "The magic worked! Plugin loaded successfully. 🎩✨"

package/plugins/migration-scoring/.plugin/plugin.json

@@ -0,0 +1,19 @@
+{
+  "name": "migration-scoring",
+  "version": "1.0.0",
+  "description": "Evaluate code migration quality with coverage, correctness, and style scoring. Generates executive reports with actionable recommendations.",
+  "author": {
+    "name": "OpenHands",
+    "email": "contact@all-hands.dev"
+  },
+  "homepage": "https://github.com/OpenHands/extensions",
+  "repository": "https://github.com/OpenHands/extensions",
+  "license": "MIT",
+  "keywords": [
+    "migration",
+    "scoring",
+    "quality",
+    "evaluation",
+    "reporting"
+  ]
+}

package/plugins/migration-scoring/README.md

@@ -0,0 +1,244 @@
+# Migration Scoring Plugin
+
+Quality evaluation for code migration projects using OpenHands agents. This plugin scores completed migrations across multiple dimensions including coverage, correctness, and code style, generating executive reports with actionable recommendations.
+
+## Quick Start
+
+```bash
+export LLM_API_KEY="your-api-key"
+export LLM_MODEL="anthropic/claude-3-5-sonnet-20241022"
+
+uv run python -m lc_sdk_examples.migration_scoring \
+  --src-path /path/to/migration/project \
+  --rubric-path /path/to/style_rubric.txt
+```
+
+## Features
+
+- **Multi-Dimensional Scoring** — Evaluates coverage, correctness, and style separately
+- **Source-to-Target Mapping** — Documents relationships between source and migrated files
+- **Executive Reporting** — Generates summary reports with risk categorization
+- **Custom Style Rubrics** — Supports project-specific style guidelines
+- **Actionable Recommendations** — Prioritized list of improvements
+
+## Prerequisites
+
+- Completed migration with both source and target code present
+- Python 3.13 with `uv`
+- LLM API key (Anthropic or OpenAI)
+- Optional: Custom style rubric file
+
+## Plugin Contents
+
+```
+plugins/migration-scoring/
+├── README.md                              # This file
+└── skills/                                # Workflow phase skills
+    ├── migration-scoring-overview/        # Plugin overview
+    │   └── SKILL.md
+    ├── migration-mapping/                 # Phase 1: Source-to-target mapping
+    │   └── SKILL.md
+    ├── score-quality/                     # Phase 2: Coverage and correctness
+    │   ├── SKILL.md
+    │   └── references/
+    │       └── scoring-criteria.md
+    ├── score-style/                       # Phase 3: Code style evaluation
+    │   └── SKILL.md
+    └── migration-report/                  # Phase 4: Executive report
+        └── SKILL.md
+```
+
+## Workflow Phases
+
+### Phase 1: Migration Mapping
+
+Creates a source→target file mapping:
+
+- Identifies which target files implement each source file
+- Supports many-to-many relationships
+- Flags unmigrated source files
+
+**Output:** `migration_mapping.json`
+
+```json
+{
+  "CALC001.cbl": ["InvoiceCalculator.java", "TaxCalculator.java"],
+  "CUST002.cbl": ["CustomerService.java"]
+}
+```
+
+### Phase 2: Quality Scoring
+
+Scores each source file on:
+
+- **Coverage (1-5)**: How much functionality was migrated
+- **Correctness (1-5)**: How accurately behavior was preserved
+
+**Output:** `migration_score.json`
+
+```json
+{
+  "CALC001.cbl": {
+    "coverage": 4,
+    "correctness": 5,
+    "justification": "All calculation logic migrated..."
+  }
+}
+```
+
+### Phase 3: Style Scoring
+
+Evaluates target code against style guidelines:
+
+- Naming conventions
+- Code organization
+- Error handling
+- Documentation
+- Idiomaticity
+
+**Output:** `style_score.json`
+
+### Phase 4: Executive Report
+
+Generates a detailed report:
+
+- Overall health assessment
+- Score statistics and distribution
+- Risk categorization (Green/Yellow/Red)
+- Prioritized recommendations
+
+**Output:** `final_report.md`
+
+## Output Structure
+
+```
+your-project/
+├── .lc-sdk/
+│   ├── migration_mapping.json
+│   ├── migration_score.json
+│   ├── style_score.json
+│   └── final_report.md
+```
+
+## Usage
+
+### Running the Evaluation
+
+1. **Ensure migration is complete**: Both source and target code should be present
+2. **Set environment variables**:
+   ```bash
+   export LLM_API_KEY="your-api-key"
+   export LLM_MODEL="anthropic/claude-3-5-sonnet-20241022"
+   ```
+3. **Run the scoring**:
+   ```bash
+   uv run python -m lc_sdk_examples.migration_scoring \
+     --src-path /path/to/migration/project \
+     --rubric-path /path/to/style_rubric.txt
+   ```
+4. **Review the report**: Check `final_report.md` for results and recommendations
+
+### Using a Custom Style Rubric
+
+Create a text file with your style guidelines:
+
+```text
+# Style Rubric for Java Migration
+
+## Naming Conventions
+- Use camelCase for methods and variables
+- Use PascalCase for classes
+- Avoid Hungarian notation
+
+## Code Organization
+- One public class per file
+- Group related methods together
+- Maximum 500 lines per class
+
+## Error Handling
+- Use specific exception types
+- Include meaningful error messages
+- Log exceptions appropriately
+```
+
+Then pass it using `--rubric-path`:
+
+```bash
+uv run python -m lc_sdk_examples.migration_scoring \
+  --src-path /path/to/project \
+  --rubric-path ./my_style_rubric.txt
+```
+
+## Scoring Criteria
+
+### Coverage Score (1-5)
+
+| Score | Description |
+|-------|-------------|
+| 5 | 100% of source functionality migrated |
+| 4 | 90%+ migrated, minor features missing |
+| 3 | 70-90% migrated, some features missing |
+| 2 | 50-70% migrated, significant gaps |
+| 1 | Less than 50% migrated |
+
+### Correctness Score (1-5)
+
+| Score | Description |
+|-------|-------------|
+| 5 | Behavior exactly matches source |
+| 4 | Minor edge case differences |
+| 3 | Some behavioral differences |
+| 2 | Significant behavioral changes |
+| 1 | Major functionality broken |
+
+### Risk Categories
+
+- **Green**: All scores ≥ 4 — Migration is production-ready
+- **Yellow**: Any score 3-4 — Needs review before production
+- **Red**: Any score < 3 — Significant work required
+
+## Troubleshooting
+
+### Mapping Not Found
+
+1. Verify directory structure matches expected layout
+2. Check file extensions are recognized
+3. Ensure source and target directories are accessible
+
+### Low Coverage Scores
+
+1. Review unmigrated files in the mapping
+2. Check for split functionality across multiple target files
+3. Verify all helper/utility functions are included
+
+### Style Score Issues
+
+1. Check that rubric file is valid
+2. Verify target code files are readable
+3. Review specific style violations in `style_score.json`
+
+### Report Generation Fails
+
+1. Ensure all previous phases completed successfully
+2. Check that score JSON files are valid
+3. Verify sufficient disk space for output
+
+## Integration with COBOL Modernization
+
+This plugin works seamlessly with the [COBOL Modernization Plugin](../cobol-modernization/README.md):
+
+```bash
+# First, run the migration
+uv run python -m lc_sdk_examples.cobol_modernization --src-path /path/to/cobol
+
+# Then, score the results
+uv run python -m lc_sdk_examples.migration_scoring --src-path /path/to/cobol
+```
+
+## Contributing
+
+See the main [extensions repository](https://github.com/OpenHands/extensions) for contribution guidelines.
+
+## License
+
+This plugin is part of the OpenHands extensions repository. See [LICENSE](../../LICENSE) for details.

package/plugins/migration-scoring/skills/migration-mapping/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: migration-mapping
+description: Create a mapping from source language files to target language files for code migrations. Use when evaluating or documenting a migration project.
+license: MIT
+compatibility: Requires completed migration with source and target code
+triggers:
+  - migration mapping
+  - source target mapping
+  - file mapping
+---
+
+Create a mapping from source language files (e.g., COBOL) to target language files (e.g., Java) to document which target files implement the functionality of each source file.
+
+## Task
+
+Examine all source language files and identify the corresponding target language files that implement the same functionality. This mapping is essential for:
+- Migration quality evaluation
+- Traceability documentation
+- Gap analysis
+
+## Output Format
+
+Save the mapping as a JSON file with this structure:
+
+```json
+{
+  "source_file_1.cbl": ["target_file_a.java", "target_file_b.java"],
+  "source_file_2.cbl": ["target_file_c.java"],
+  "source_file_3.cbl": []
+}
+```
+
+## Rules
+
+1. **Many-to-many mapping**: A source file may map to multiple target files, and a target file may implement logic from multiple source files
+2. **Complete coverage**: EVERY source file must appear as a key in the mapping
+3. **Complete target coverage**: EVERY target file should appear as a value at least once
+4. **Empty arrays**: If a source file has no corresponding target implementation, use an empty array `[]`
+5. **Incremental**: If a mapping file already exists, update it rather than replacing it
+
+## How to Identify Mappings
+
+Look for:
+- Matching class/program names
+- Similar function/paragraph names
+- Matching business logic patterns
+- Comments referencing source files
+- Import/include statements
+- Data structure similarities
+
+## Example
+
+For a COBOL-to-Java migration:
+
+```json
+{
+  "CALC001.cbl": ["InvoiceCalculator.java", "TaxCalculator.java"],
+  "CUST002.cbl": ["CustomerService.java", "CustomerRepository.java"],
+  "UTIL003.cbl": ["StringUtils.java"],
+  "SCREEN001.cbl": []
+}
+```
+
+Note: `SCREEN001.cbl` maps to nothing because UI code was not migrated.
+
+## Verification
+
+After creating the mapping:
+- [ ] Every source file is a key
+- [ ] No duplicate keys
+- [ ] Target files are relative paths from project root
+- [ ] JSON is valid and well-formatted