sandbox cleanup development

    1

    Build and integrate Java AST transformations, multi-file cleanups, and JDT quick fixes for the Sandbox repository.

    $20

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    sandbox cleanup development

    Example session with this skill installed

    I need to create a multi-file cleanup that renames a specific internal annotation and updates all its call sites across the project. How should I structure this in Sandbox?

    • Read your context and instructions
    • Compiled the sandbox cleanup development

    I have designed the structure for a coordinated multi-file cleanup to rename the annotation and update all call sites. This implementation uses the AbstractPlannedMultiFileCleanUp path to ensure semantic consistency across compilation units.

    Coordinated Cleanup Design

    ComponentImplementation Detail
    Targetcarstenartur/sandbox (Current Revision)
    ApproachAbstractPlannedMultiFileCleanUp<AnnotationRenamePlan>
    DiscoverySearch for ITypeBinding of the target annotation within project scope
    PlanningMap all ICompilationUnit occurrences to a single AnnotationRenamePlan
    RewriteUse ASTRewrite to modify AnnotationTypeDeclaration and Annotation nodes
    SafetyReject if annotation is part of a binary dependency or read-only file
    public class RenameInternalAnnotationCleanUp extends AbstractPlannedMultiFileCleanUp<AnnotationRenamePlan> {
        @Override
        protected AnnotationRenamePlan createPlan(ICompilationUnit[] units) {
            // Discovery phase: Identify annotation and all reference sites
            return new AnnotationRenamePlan(units);
        }
    
        @Override
        protected ICleanUpFix createFix(ICompilationUnit unit, AnnotationRenamePlan plan) {
            // Per-file rewrite phase: Apply the name change to the AST
            return new AnnotationRenameFix(unit, plan);
        }
    }
    

    Next steps

    1. Register the new cleanup class in MYCleanUpConstants and the corresponding extension point.
    2. Add a test case to the existing JUnit suite using a mock project with two dependent source files.
    3. Verify that the UI wizard correctly shows a preview of changes in both the declaration and usage files.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Developing Java AST transformations within the Eclipse JDT ecosystem is fragile. Manual implementations often break source compatibility, lose comments, or fail to handle complex multi-file dependencies. This skill provides a structured framework for building cleanups, quick fixes, and TriggerPattern rules specifically for the carstenartur/sandbox repository and its host environment.

    What it does

    • AST transformations designs Java cleanup rules using fluent visitors and JDT rewrite infrastructure.
    • Multi-file coordination manages semantically coupled edits across different compilation units using a planned lifecycle.
    • Pattern matching implements TriggerPattern rules with specific DSL guards and applicability contracts.
    • Upstream assessment evaluates the effort required to port Sandbox implementations to standard Eclipse JDT.
    • Integration testing extends existing Maven and JUnit fixtures to verify UI behavior, headless execution, and save actions.

    How it works

    1. Define the contract by identifying the entry point, target Java level, and whether the change is local or multi-file.
    2. Select the API from TriggerPattern, Sandbox fluent visitors, or raw JDT rewrite based on the complexity of analysis required.
    3. Plan the edits using AbstractPlannedMultiFileCleanUp to separate discovery, planning, and per-file rewrites.
    4. Execute verification by running repository-specific gates to test stale sources, partial selections, and undo/redo behavior.

    Frameworks & tools

    This skill works with Java, Eclipse JDT (Java Development Tools), LTK (Language Toolkit), Maven, and the Sandbox repository infrastructure.

    Why this beats prompting it yourself

    Writing JDT cleanups requires strict adherence to binding resolutions and AST lifecycles that generic models often hallucinate. This skill enforces the specific multi-file contracts and registration patterns required by the Sandbox repository, preventing broken project structures.

    Use cases

    • Add a new code cleanup rule to remove redundant logic across a workspace.
    • Implement a quick fix that coordinates changes between a class and its interface.
    • Port a custom Sandbox transformation to an upstream Eclipse JDT plugin.
    • Create a TriggerPattern to enforce team-specific coding standards.

    Known limitations

    This is an authoring skill only. It requires an existing checkout of the Sandbox repository and does not include a live Eclipse instance or compiler.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Agents & Orchestration.

    Requires a local checkout of the Sandbox repository. Does not provide an Eclipse execution environment or compiler. Coordination limited to supported host capabilities.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 14 days ago

    Accounts
    GitHub
    Software
    Eclipse

    Permissions

    Read Files
    Write Files

    Allowed Hosts

    api.github.com
    Listed14 days ago

    What's inside

    Frequently Asked Questions

    This skill automates the complex process of writing Java AST transformations specifically for the Sandbox repository, ensuring that new cleanups preserve source compatibility, comments, and multi-file dependencies that manual coding often breaks.

    You receive a specialized configuration for your AI agent that includes the framework for designing TriggerPattern rules, multi-file cleanup lifecycle templates, and integration testing fixtures tailored for the JDT ecosystem.

    The skill is designed for AI agents capable of processing technical documentation and code structures, provided they have access to a local environment containing a checkout of the 'carstenartur/sandbox' repository.

    Yes, it includes an 'upstream assessment' feature that evaluates your Sandbox-specific implementations and provides the necessary logic adjustments to port them to standard Eclipse JDT or LTK plugins.

    This skill supports Java development within the Eclipse JDT and LTK frameworks, specifically optimized for the Maven-based project structure and registration patterns used in the Sandbox repository.

    The skill covers the logic, pattern matching, and rewrite planning for cleanups, but it does not provide a live compiler or Eclipse GUI; you must execute the generated code within your own IDE or CI pipeline.

    New in Agents & Orchestration