Claude Skills by TheRealSeber

Performs deep static analysis of a codebase to generate a comprehensive, hierarchical, cross-referenced documentation ecosystem. Use this skill whenever the user wants to analyze, document, understand, or audit a codebase — even if they phrase it as "document my project", "analyze the repo", "generate docs", "audit technical debt", "understand this codebase", or "create documentation for this code". This skill covers: program structure extraction, architectural documentation, behavioral anal...

Stages and commits all files touched by a single migration rule, using a strict conventional-commit message format. Logs the commit SHA to artifacts/09-rule-commit-log.json so the orchestrator can verify the rule was committed before moving to the next rule.

Enforces Rule-by-Rule Sequential Batching — processes exactly ONE rule_id batch at a time. For the selected rule_id, prepares all per-file tasks from the flag index, tracks per-file completion, and persists batch artifact + status. No cross-rule parallel execution.

Build prerequisite gate for JADE migration pipeline. Analyzes build files (build.xml/pom.xml/gradle), checks dependency/plugin compatibility for the target Java version, applies safe minimal build/dependency updates, and verifies the build. This is a GATE — no source-code migration may proceed until the build passes at the target version.

Collects Java version breaking-change rules from user-supplied sources. Uses LLM reading comprehension to extract rules from fetched text — never regex. A schema-validating write_manifest.py enforces evidence, confidence, and format. If all sources fail, halts with AWAITING_SOURCE_INPUT.

Classifies JADE migration skills as experimental/candidate/official using reproducible evidence from pipeline run artifacts. Use after a complete migration run to assess skill quality.

Core skill that builds a Java Knowledge Graph from `.java` sources using tree-sitter-java, enabling impact analysis, rule ordering, and consumer test selection in the JADE migration pipeline.

Orchestrates JADE migration runs using strict file-based handoff and deterministic state transitions. Use whenever running a version migration pipeline that must process rules sequentially (rule-by-rule), persist artifacts to disk, and enforce phase gates before continuing.

Routes failed JADE migration rule tasks back into the same rule batch with bounded retries. Use when the orchestrator encounters VERIFICATION_FAILED or RULE_GATE_FAILED and the user wants automatic requeue with back-off before escalation. Reads verification outputs and fix results to decide requeue vs escalate per failed rule.

Routes rule tasks to registry recipes via recipe-registry.json. Handles LOAD/MATCH/RECORD workflow but delegates all transform logic to recipe subprocesses. Contains ZERO version-specific or rule-specific transform code. Accepts one task at a time from the rule batch.

Production-grade scanner that reads a breaking-changes manifest, scans workspace sources against rule patterns using regex, injects deterministic inline // JADE-FLAG:<rule_id> markers into matched source lines, and writes flag index and scan summary artifacts. Fully idempotent — re-running never duplicates tags. Use after manifest is ready and before build gate verification.

Detects what can be auto-assisted by OpenRewrite, PMD, and Checkstyle before manual scanner work. Probes tool availability, runs each tool against the legacy workspace using a modern JDK, collects findings, and merges results into the breaking-changes manifest with provenance. Never rewrites code — discovery and reporting only.

Verifies JADE migration correctness by semantic outcome matching instead of raw textual log diffing. Normalizes traces (strips timestamps, thread IDs, nonces), extracts agent lifecycle / ACL protocol / DF-AMS state events, and compares state outcomes under configurable tolerance. Produces diff and metrics artifacts. Run this as the final verification gate after all migration rules have been applied.

Onboards external JADE projects into the consumer playground. Extracts a ZIP archive of a JADE project, copies Java sources into consumer-playground/<name>/, and generates a test-config.json for runtime verification.

Replaces the full-array copy idiom System.arraycopy(a, 0, b, 0, a.length) with Java 6 Arrays.copyOf. Agent-mode recipe: the shard contract names the files to edit; this document defines the transform and its invariants.

Replaces System.arraycopy() calls with Java 6 Arrays.copyOf()/copyOfRange(). Handles three cases: same-source copy, destPos=0 copy, and non-zero destPos (leaves a NOTE comment). Invoked by jade-core-rule-dispatcher.

Informational rule. LinkedList already implements Deque in Java 6. No code change required. Invoked by jade-core-rule-dispatcher.

Informational rule. TreeSet/TreeMap already implement NavigableSet/ NavigableMap in Java 6. No code change required. Invoked by jade-core-rule-dispatcher.

Replaces the pre-Java-6 emptiness idiom s.length() == 0 with s.isEmpty() on String receivers only. Agent-mode recipe: the shard contract names the files to edit; this document defines the transform and its invariants.

Adds -Xdoclint:none to Ant <javadoc> elements so the JDK 8 javadoc tool's default-on DocLint checker does not turn pre-existing malformed Javadoc comments into build failures. Agent-mode recipe: verifying the fix means actually running `ant doc` under the JDK 8 Docker image.

Documents (does not remove) the two <rmic> Ant task uses that are deprecated for removal starting with JDK 8 and removed outright in JDK 9+. Agent-mode recipe: the correct action on a 1.7->1.8 jump is a deferral marker plus a real build check, not deletion of a still-working task.

Reviews a default sun.jdbc.odbc.JdbcOdbcDriver reference removed from the JDK in Java 8. Agent-mode recipe: there is no mechanical replacement, so this document defines the judgment call (fail fast vs. defer to config) and the invariant that only the literal default value may change.

Converts anonymous single-abstract-method (SAM) inner classes to Java 8 lambda expressions. Agent-mode recipe: the shard contract names the files and flagged sites; this document defines the transform, the non-convertible categories that must be SKIPPED, and the invariants.

Inspects .stop() calls flagged by THREAD_STOP_DISABLED for actual Thread.stop() usage. Most calls are custom .stop() methods in JADE's own classes (Timer.stop(), client.stop(), HTTPServer.stop()), not java.lang.Thread.stop(Throwable). Marks false positives as SKIPPED. If actual Thread.stop() is found, defers for manual review via JADE-MODERNIZATION-DEFERRED marker. Invoked by jade-core-rule-dispatcher.

Replaces explicit generic type arguments with Java 7 diamond operator (<>). Scans +/-2 lines for the pattern, skips already-converted lines. Removes JADE-FLAG:DIAMOND_OPERATOR comments. Atomic write. Invoked by jade-core-rule-dispatcher.

Converts .equals() if-chains to Java 7 switch statements. Handles sequential if-return and if-else-if-else patterns. Defers unconvertible single branches via JADE-MODERNIZATION-DEFERRED. Removes JADE-FLAG:STRINGS_IN_SWITCH comments on success. Invoked by jade-core-rule-dispatcher.

Converts manual open/close resource management to Java 7 try-with-resources where — and only where — the resource genuinely implements Closeable/AutoCloseable, is closed unconditionally on every path, and is never touched again after the try. Agent-mode recipe: scripts/scan.py narrows the manifest's broad TRY_WITH_RESOURCES flags (0.6% precision) to a shortlist (~70% precision); this document defines the judgment calls the shortlist cannot make on its own.

Handles JADE's dependency on java.applet.Applet, which JEP 398 deprecated for removal in JDK 17. Agent-mode recipe: the shard contract names the files; this document defines what may be changed mechanically and why the removal decision itself belongs to the user.

Moves JADE's multicast main-container discovery off the deprecated MulticastSocket.joinGroup(InetAddress)/leaveGroup(InetAddress) overloads that JDK 17 superseded. Agent-mode recipe: the shard contract names the file; this document defines the transform and the one argument the agent must not invent.

Removes the two Ant <rmic> pregeneration steps from build.xml. The rmic tool they drive was removed in JDK 15, and Ant refuses the task on JDK 15+, which is the only thing stopping the JADE build on JDK 17. Agent-mode recipe: the shard contract names the file; this document defines the transform and the one condition under which the agent must stop instead.

Removes the single ThreadGroup.destroy() call in jade.core.Runtime's shutdown path. JDK 16 terminally deprecated it and calls the destruction mechanism inherently flawed. Agent-mode recipe: the shard contract names the file; this document defines the transform and the diagnostic it must not silently drop.

Replaces primitive wrapper constructor calls with the corresponding valueOf factory. JEP 390 (JDK 16) deprecated those constructors for removal. Agent-mode recipe: the shard contract names the files; this document defines the transform and the identity-sensitive sites it must refuse to touch.

Pins an explicit UTF-8 charset on the file reader, writer and print stream constructors that JADE uses to write files it later reads back itself. JEP 400 (JDK 18) changed those constructors from the platform default charset to UTF-8. Agent-mode recipe: the shard contract names the files; this document defines the transform and the sites it must refuse to touch.

Removes Object.finalize() overrides in favour of the close or shutdown method each of them already delegates to. JEP 421 (JDK 18) deprecated finalization for removal. Agent-mode recipe: the shard contract names the files; this document defines the transform and the condition that forces NEEDS_REVIEW.

Removes the catch of java.lang.ThreadDeath, which JDK 20 deprecated for removal after making Thread.stop() throw UnsupportedOperationException. Agent-mode recipe: the shard contract names the file; this document defines the transform and what must be preserved.

Makes date/time formatting independent of the default locale data provider, which switched from JRE/COMPAT to CLDR in JDK 9. Agent-mode recipe: the shard contract names the files; this document defines the two accepted fixes and which one the agent may apply.

Deletes JADE's CORBA dependency instead of retrofitting it: the generated FIPA IDL stubs, the IIOP message transport protocol, and their build.xml wiring. Agent-mode recipe: the shard contract names the files; this document defines what is deleted, what is left alone, and how the leftover references are resolved.

Java 11 removed the java.corba module (JEP 320): org.omg.* classes no longer exist in the JDK. This recipe retrofits a standalone GlassFish CORBA implementation (omgapi + orb + transitive jars) into lib/corba/ and wires it into the Ant compile classpath so FIPA/* and jade.mtp.iiop/* compile and run on JDK 11. Idempotent. Removes JADE-FLAG:CORBA_REMOVAL markers. Invoked by jade-core-rule-dispatcher.

Resolves hard-coded anonymous TLS cipher suites (DH_anon / ECDH_anon), which JDK 11 disables by default through jdk.tls.disabledAlgorithms. Agent-mode recipe: the shard contract names the files; this document defines the transform, its limit, and when the fix stops being the agent's call.

Registry of version-scoped migration recipes (jade-recipe-*) and auto-generated migration skills produced by the Skill-Creator agent. Each subdirectory holds versioned skills/recipes for a specific version jump. Recipes here are transform scripts + docs, NOT first-class agent skills — they are nested below the skills/*/SKILL.md discovery depth and are invoked only by jade-core-rule-dispatcher via recipe-registry.json. Not a command — background knowledge only.

E2E test recipe. Appends // E2E TEST comment to matched line. Returns success immediately. Invoked by jade-core-rule-dispatcher.

Fallback recipe for rules with no specific transform. Marks flagged lines as SKIPPED — no source change needed. Used when the fix is informational (e.g., "LinkedList already implements Deque in Java 6"). Invoked by jade-core-rule-dispatcher.

Modernizes Java applications by upgrading the Java version and updating dependencies to compatible versions — improving security, performance, and maintainability while keeping the project buildable at every step. Use this skill whenever the user wants to upgrade Java versions, migrate from javax to Jakarta EE, update Spring Boot, modernize dependencies, or do any kind of Java version migration — even if they phrase it as "upgrade to Java 21", "migrate to Spring Boot 3", "update dependencies...