@openhands/extensions 0.1.0 → 0.2.0

package/plugins/cobol-modernization/skills/cobol-modernization-overview/SKILL.md

@@ -0,0 +1,113 @@
+---
+name: cobol-modernization
+description: End-to-end COBOL to Java migration workflow. Handles build setup, mainframe dependency removal, and code migration with test validation.
+license: MIT
+compatibility: Requires GnuCOBOL, Java 11+, Maven/Gradle, Python 3.13 with uv
+triggers:
+  - cobol modernization
+  - cobol to java
+  - cobol migration
+  - mainframe migration
+---
+
+End-to-end workflow for migrating COBOL codebases to Java.
+
+## Overview
+
+This plugin orchestrates a multi-phase COBOL modernization project:
+
+1. **Build Setup** — Configure compilation for both COBOL and Java, create test fixtures
+2. **Mainframe Planning** — Document transformations needed to remove mainframe dependencies
+3. **Mainframe Removal** — Convert CICS/VSAM code to standard COBOL
+4. **Java Migration** — Translate standardized COBOL to idiomatic Java
+
+## Prerequisites
+
+- GnuCOBOL compiler (`cobc`)
+- Java 11+ with Maven or Gradle
+- Python 3.13 with `uv`
+- LLM API key (Anthropic or OpenAI)
+
+## 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.cobol_modernization --src-path /path/to/cobol/project
+```
+
+## Workflow Phases
+
+### Phase 1: Build Setup
+
+See [../build-setup/SKILL.md](../build-setup/SKILL.md)
+
+Creates the foundation for the migration:
+- COBOL compilation environment (GnuCOBOL)
+- Java project structure (Maven/Gradle + JUnit 5)
+- Test fixtures with golden outputs from COBOL execution
+
+**Outputs:**
+- `build_notes.md` — Build instructions
+- `test-fixtures/` — Input/output test data
+- `test_manifest.json` — Test case mapping
+
+### Phase 2: Mainframe Planning
+
+See [../mainframe-planning/SKILL.md](../mainframe-planning/SKILL.md)
+
+Creates a transformation guide without modifying code:
+- Maps CICS/VSAM constructs to standard COBOL equivalents
+- Documents error handling replacements
+- Identifies UI operations to stub
+
+**Output:**
+- `mainframe_dependency_removal_plan.md`
+
+### Phase 3: Mainframe Removal
+
+See [../mainfraime-removal/SKILL.md](../mainfraime-removal/SKILL.md)
+
+Applies the transformation guide:
+- Replaces EXEC CICS commands with file I/O
+- Adds FILE STATUS checking
+- Stubs BMS/screen operations
+
+**Verification:**
+- Code compiles with GnuCOBOL
+- Runs with test fixtures
+
+### Phase 4: Java Migration
+
+See [../to-java-migration/SKILL.md](../to-java-migration/SKILL.md)
+
+Translates to idiomatic Java:
+- Proper Java conventions (not literal translations)
+- JUnit tests using golden outputs
+- COBOL references in comments
+
+**Done when:**
+- All code compiles
+- All JUnit tests pass
+- No TODOs or stubs remain
+
+## Output Structure
+
+```
+your-project/
+├── .lc-sdk/
+│   ├── initial_batch_graph.json
+│   ├── fixed_batch_graph.json
+│   └── mainframe_dependency_removal_plan.md
+├── test-fixtures/
+│   ├── inputs/
+│   └── expected_outputs/
+├── test_manifest.json
+├── src/main/java/
+└── src/test/java/
+```
+
+## Troubleshooting
+
+See [../../references/troubleshooting.md](../../references/troubleshooting.md) for common issues and solutions.

package/plugins/cobol-modernization/skills/mainfraime-removal/SKILL.md

@@ -0,0 +1,62 @@
+---
+name: mainframe-removal
+description: Apply mainframe dependency transformations to COBOL code using a pre-generated transformation guide. Converts CICS/VSAM constructs to standard COBOL.
+license: MIT
+compatibility: Requires GnuCOBOL (cobc) for verification
+triggers:
+  - remove mainframe
+  - cobol transformation
+  - cics removal
+  - standard cobol
+---
+
+Apply the transformations from a transformation guide to convert mainframe-specific COBOL to standard COBOL.
+
+**Prerequisite**: A transformation guide must exist (see `cobol-mainframe-planning` skill).
+
+## Transformation Requirements
+
+### Data Operations
+
+- Replace each CICS/VSAM construct with its standard COBOL equivalent per the plan
+- Add FILE STATUS checks after EVERY file operation:
+  - Check for success (00) before proceeding
+  - Handle "not found" (23) distinctly from I/O errors (3x)
+  - Handle "file not exists" (35) at OPEN time
+- Add explicit CLOSE statements in all code paths (including error paths)
+
+### UI/Terminal Operations (BMS maps, SEND/RECEIVE)
+
+- Replace with simple stubs or ACCEPT/DISPLAY statements
+- Do NOT spend time replicating screen layouts
+- Focus on preserving data flow, not UI fidelity
+
+### Error Handling
+
+- Replace CICS RESP/RESP2 checks with equivalent FILE STATUS logic
+- Replace HANDLE CONDITION with explicit status checking after operations
+- Ensure error paths don't leave files open
+
+See [references/cics-transformation-examples.md](references/cics-transformation-examples.md) for before/after code examples.
+
+## Verification
+
+After transformation:
+- Code MUST compile without errors
+- Test with valid input → should execute core business logic
+- Test with missing/invalid files → should fail gracefully, not crash
+
+## Preserve
+
+- All original business logic
+- Data transformations and calculations
+- Validation rules
+
+## Checklist
+
+- [ ] All EXEC CICS commands replaced
+- [ ] FILE STATUS declared for all files
+- [ ] FILE STATUS checked after every I/O operation
+- [ ] CLOSE statements in all code paths
+- [ ] Code compiles successfully
+- [ ] Basic test execution passes

package/plugins/cobol-modernization/skills/mainfraime-removal/references/cics-transformation-examples.md

@@ -0,0 +1,45 @@
+# CICS Transformation Examples
+
+## UI/Terminal Operations
+
+### Before (CICS)
+```cobol
+EXEC CICS SEND MAP('CUSTMAP') MAPSET('CUSTSET') END-EXEC
+```
+
+### After (Standard COBOL)
+```cobol
+DISPLAY "Customer Screen Output"
+DISPLAY WS-CUSTOMER-NAME
+DISPLAY WS-CUSTOMER-ADDRESS
+```
+
+---
+
+## Error Handling
+
+### Before (CICS with RESP/RESP2)
+```cobol
+EXEC CICS READ FILE('CUSTFILE')
+    INTO(WS-CUSTOMER-REC)
+    RIDFLD(WS-CUST-KEY)
+    RESP(WS-RESP)
+    RESP2(WS-RESP2)
+END-EXEC
+IF WS-RESP = DFHRESP(NOTFND)
+    PERFORM CUSTOMER-NOT-FOUND
+END-IF
+```
+
+### After (Standard COBOL with FILE STATUS)
+```cobol
+READ CUSTFILE INTO WS-CUSTOMER-REC
+    KEY IS WS-CUST-KEY
+IF FILE-STATUS NOT = '00'
+    IF FILE-STATUS = '23'
+        PERFORM CUSTOMER-NOT-FOUND
+    ELSE
+        PERFORM FILE-ERROR-HANDLER
+    END-IF
+END-IF
+```

package/plugins/cobol-modernization/skills/mainframe-planning/SKILL.md

@@ -0,0 +1,78 @@
+---
+name: mainframe-planning
+description: Create a transformation guide for replacing mainframe-specific COBOL constructs with standard COBOL equivalents. Use when preparing COBOL code for local execution or migration.
+license: MIT
+compatibility: Requires knowledge of CICS/VSAM mainframe constructs
+triggers:
+  - mainframe planning
+  - cics replacement
+  - cobol transformation guide
+  - mainframe dependency
+---
+
+Create a comprehensive transformation guide that maps each mainframe dependency to its standard COBOL replacement.
+
+This guide is a prerequisite for the actual transformation — DO NOT modify any code, only create the guide.
+
+## Output Format
+
+Document each mainframe-specific construct with:
+
+1. **Pattern**: The mainframe construct (e.g., `EXEC CICS READ FILE(...)`)
+2. **Replacement**: The standard COBOL equivalent
+3. **Error Handling**: How to replicate the mainframe's error behavior
+   - Map CICS RESP/RESP2 codes to FILE STATUS equivalents
+   - Specify which FILE STATUS values to check (e.g., 00=success, 23=not found, 35=file not exists)
+4. **Resource Cleanup**: Any cleanup the replacement requires (CICS auto-manages resources; file I/O does not)
+5. **Edge Cases**: Behavior differences between mainframe and standard COBOL
+
+## Constructs to Address
+
+### Data Operations (CICS/IMS/VSAM)
+
+- READ, WRITE, REWRITE, DELETE operations
+- STARTBR, READNEXT, READPREV (browse operations)
+- CICS error handling: HANDLE CONDITION, RESP/RESP2 options
+- VSAM → sequential or indexed file I/O
+
+### UI/Terminal Operations (BMS maps, screens)
+
+- SEND MAP, RECEIVE MAP → these can be MOCKED or stubbed
+- Screen I/O is not needed for business logic validation
+- Document how to replace with simple ACCEPT/DISPLAY or test harness stubs
+- Focus on preserving the data flow, not the UI interaction
+
+### Other Mainframe Constructs
+
+- Mainframe data types (COMP-3 packed decimal, etc.)
+- JCL-embedded constructs
+- IMS calls (if present)
+
+## Critical Requirements
+
+- Every CICS command that can fail MUST have an error handling replacement documented
+- UI operations should be clearly marked as "mock/stub" so the agent doesn't get stuck on them
+- Prefer: file-based I/O over mainframe I/O, standard data types over mainframe types
+
+## Common Mappings Reference
+
+### FILE STATUS Codes
+
+| Code | Meaning | CICS Equivalent |
+|------|---------|-----------------|
+| 00 | Success | Normal completion |
+| 23 | Record not found | NOTFND condition |
+| 35 | File does not exist | NOTOPEN condition |
+| 22 | Duplicate key | DUPREC condition |
+| 3x | I/O errors | Various IOERR conditions |
+
+### CICS to Standard COBOL
+
+| CICS Command | Standard COBOL |
+|--------------|----------------|
+| `EXEC CICS READ FILE(...)` | `READ filename INTO...` |
+| `EXEC CICS WRITE FILE(...)` | `WRITE record-name FROM...` |
+| `EXEC CICS REWRITE FILE(...)` | `REWRITE record-name FROM...` |
+| `EXEC CICS DELETE FILE(...)` | `DELETE filename RECORD` |
+| `EXEC CICS STARTBR FILE(...)` | `START filename KEY...` |
+| `EXEC CICS READNEXT FILE(...)` | `READ filename NEXT INTO...` |

package/plugins/cobol-modernization/skills/to-java-migration/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: to-java-migration
+description: Migrate COBOL code to idiomatic Java, preserving business logic while following Java best practices. Use for COBOL modernization projects.
+license: MIT
+compatibility: Requires Java 11+, Maven or Gradle
+triggers:
+  - cobol to java
+  - cobol migration
+  - cobol modernization
+  - migrate cobol
+---
+
+Migrate COBOL code to idiomatic Java, preserving all business logic.
+
+## Code Style Requirements
+
+Write idiomatic Java, NOT literal COBOL translations:
+- Use Java conventions: camelCase names, standard collections (List, Map)
+- Use Java standard library instead of rolling your own
+- No god classes — split into cohesive, single-responsibility classes
+- No TODO comments or stub implementations — fully implement everything
+
+## Robustness Requirements
+
+- Validate inputs at method entry (null checks, range validation)
+- Use try-catch for all I/O and external operations
+- Use try-with-resources for files, streams, connections
+- Handle errors gracefully with meaningful messages
+
+## Configuration Requirements
+
+- No hardcoded file paths or credentials — use environment variables
+- No magic numbers — use named constants
+- Make limits and timeouts configurable
+
+## Documentation Requirements
+
+- Add COBOL references: `// COBOL equivalent: BNK1CRA.cbl 145-167`
+- Document assumptions made during conversion
+- Add Javadoc to public methods
+
+## Testing Requirements
+
+If test fixtures exist (see `cobol-build-setup` skill):
+- Create a JUnit test class for each migrated program
+- Load inputs from fixtures, assert output matches expected (golden) output
+- All tests must pass before migration is complete
+
+## References
+
+- See [references/cobol-to-java-example.md](references/cobol-to-java-example.md) for a complete transformation example
+- See [references/datatype-mappings.md](references/datatype-mappings.md) for COBOL→Java type mappings
+
+## Done When
+
+✓ Code compiles without errors
+✓ All JUnit tests pass (Java output matches COBOL golden output)
+✓ No TODO or stub implementations remain
+✓ COBOL references documented in comments

package/plugins/cobol-modernization/skills/to-java-migration/references/cobol-to-java-example.md

@@ -0,0 +1,58 @@
+# COBOL to Java Transformation Example
+
+## COBOL (Before)
+
+```cobol
+       IDENTIFICATION DIVISION.
+       PROGRAM-ID. CALC-TAX.
+       DATA DIVISION.
+       WORKING-STORAGE SECTION.
+       01 WS-SUBTOTAL    PIC 9(7)V99.
+       01 WS-TAX-RATE    PIC V999 VALUE 0.085.
+       01 WS-TAX-AMOUNT  PIC 9(7)V99.
+
+       PROCEDURE DIVISION.
+           MULTIPLY WS-SUBTOTAL BY WS-TAX-RATE
+               GIVING WS-TAX-AMOUNT.
+           STOP RUN.
+```
+
+## Java (After)
+
+```java
+/**
+ * Tax calculation service.
+ * COBOL equivalent: CALC-TAX.cbl
+ */
+public class TaxCalculator {
+    private static final BigDecimal DEFAULT_TAX_RATE = new BigDecimal("0.085");
+
+    private final BigDecimal taxRate;
+
+    public TaxCalculator() {
+        this(DEFAULT_TAX_RATE);
+    }
+
+    public TaxCalculator(BigDecimal taxRate) {
+        this.taxRate = Objects.requireNonNull(taxRate, "Tax rate cannot be null");
+    }
+
+    /**
+     * Calculate tax for a given subtotal.
+     * COBOL equivalent: CALC-TAX.cbl lines 10-12
+     *
+     * @param subtotal The pre-tax amount
+     * @return The calculated tax amount
+     * @throws IllegalArgumentException if subtotal is null or negative
+     */
+    public BigDecimal calculateTax(BigDecimal subtotal) {
+        if (subtotal == null) {
+            throw new IllegalArgumentException("Subtotal cannot be null");
+        }
+        if (subtotal.compareTo(BigDecimal.ZERO) < 0) {
+            throw new IllegalArgumentException("Subtotal cannot be negative");
+        }
+        return subtotal.multiply(taxRate).setScale(2, RoundingMode.HALF_UP);
+    }
+}
+```

package/plugins/cobol-modernization/skills/to-java-migration/references/datatype-mappings.md

@@ -0,0 +1,19 @@
+# COBOL to Java Data Type Mappings
+
+| COBOL | Java | Notes |
+|-------|------|-------|
+| `PIC 9(n)V99` | `BigDecimal` | Decimal with implied decimal point |
+| `PIC X(n)` | `String` | Alphanumeric |
+| `PIC 9(n)` | `int` or `long` | Use `long` for n > 9 |
+| `COMP-3` (packed decimal) | `BigDecimal` | Preserve precision |
+| `OCCURS n TIMES` | `List<T>` or array | Prefer `List` for flexibility |
+
+## Control Flow Mappings
+
+| COBOL | Java |
+|-------|------|
+| `PERFORM` | method call |
+| `EVALUATE/WHEN` | `switch` |
+| `IF/ELSE` | `if/else` |
+| `PERFORM UNTIL` | `while` loop |
+| `PERFORM VARYING` | `for` loop |

package/plugins/issue-duplicate-checker/.plugin/plugin.json

@@ -0,0 +1,13 @@
+{
+  "name": "issue-duplicate-checker",
+  "version": "0.1.0",
+  "description": "Detect duplicate GitHub issues with OpenHands Cloud and manage duplicate-candidate lifecycle automation.",
+  "author": {
+    "name": "OpenHands",
+    "email": "contact@all-hands.dev"
+  },
+  "homepage": "https://github.com/OpenHands/extensions",
+  "repository": "https://github.com/OpenHands/extensions",
+  "license": "MIT",
+  "keywords": ["issues", "duplicates", "github", "automation"]
+}

package/plugins/issue-duplicate-checker/README.md

@@ -0,0 +1,51 @@
+# OpenHands Issue Duplicate Checker
+
+Reusable GitHub Action for detecting duplicate issues with an OpenHands Cloud conversation, posting a duplicate/overlap notice, labeling high-confidence duplicates as `duplicate-candidate`, and auto-closing aged candidates.
+
+## Usage
+
+```yaml
+- uses: OpenHands/extensions/plugins/issue-duplicate-checker@main
+  with:
+    mode: issue-check
+    repository: ${{ github.repository }}
+    issue-number: ${{ github.event.issue.number }}
+    openhands-api-key: ${{ secrets.OPENHANDS_API_KEY }}
+    github-token: ${{ secrets.OPENHANDS_BOT_GITHUB_PAT_PUBLIC || github.token }}
+    # Optional OpenHands polling controls. Each polling phase can wait up to
+    # max-wait-seconds, so total runtime can approach twice this value when a
+    # start task must be awaited before the conversation run.
+    poll-interval-seconds: '5'
+    max-wait-seconds: '900'
+```
+
+For scheduled auto-close:
+
+```yaml
+- uses: OpenHands/extensions/plugins/issue-duplicate-checker@main
+  with:
+    mode: auto-close
+    repository: ${{ github.repository }}
+    github-token: ${{ secrets.OPENHANDS_BOT_GITHUB_PAT_PUBLIC || github.token }}
+    close-after-days: '3'
+    # Optional: preview without mutating issues.
+    dry-run: 'false'
+```
+
+For removing the `duplicate-candidate` label after a human comments, run the action from an `issue_comment` event:
+
+```yaml
+on:
+  issue_comment:
+    types: [created]
+
+jobs:
+  remove-duplicate-candidate:
+    steps:
+      - uses: OpenHands/extensions/plugins/issue-duplicate-checker@main
+        with:
+          mode: remove-label
+          github-token: ${{ secrets.OPENHANDS_BOT_GITHUB_PAT_PUBLIC || github.token }}
+```
+
+The action requires `issues: write` permission. `issue-check` also requires an `OPENHANDS_API_KEY` secret.