Skip to content
Skills Library
Programming · Building & coding

objectscript-repair

/objectscript-repair

Perform coordinated fixes across multiple ObjectScript files. Use when a change in one class requires updates in dependent classes (e.g., method signature changes, renames).

Licence
MIT
Last repository change
25.10.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 25.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Perform coordinated fixes across multiple ObjectScript files. Use when a change in one class requires updates in dependent classes (e.g., method signature changes, renames).

Original author description

Perform coordinated fixes across multiple ObjectScript files. Use when a change in one class requires updates in dependent classes (e.g., method signature changes, renames).

How it works

  1. When to use
  2. Procedure
  3. Common Scenarios
  4. Common Pitfalls
  5. Related skills
Original SKILL.md headings · 99 lines, 672 words
SKILL.md preview
---
name: objectscript-repair
tier: extra
description: Perform coordinated fixes across multiple ObjectScript files. Use when a change in one class requires updates in dependent classes (e.g., method signature changes, renames).
---

# Multi-File Repair Skill

This skill provides a procedure for handling ObjectScript repairs that span multiple files.

## When to use

- Compilation errors in files other than the one being edited.
- Method signature updates where callers need to be updated.
- Renaming properties or classes that are referenced elsewhere.
- Implementing an interface that requires updates to several implementations.

## Procedure

### 1. Dependency Discovery

When a change is made to a class member, identify all call sites before touching any file.

- **Tool**: `docs_introspect(class_name)` — confirms the current method signature and shows the full class definition from `%Dictionary`
- **Tool**: `docs_introspect(class_name="Package.Class")` — lists the methods and properties of the class, inherited ones included. (`iris_symbols` matches class names only.)
- **Tool**: `Grep` (regex search across `.cls` files) — finds every reference to the old symbol name
- **Requirement**: You MUST perform this check for every public `ClassMethod`, `Method`, or `Property` change before writing any edits.

### 2. Multi-File Planning

Update the repair plan to include all affected files.

- The `target_files` list should contain the root cause file first, followed by all dependent files.
- **Strategy**: Map the change from "Definition" → "Reference" → "Integration".
- Document the full list of files to touch before editing any of them.

### 3. Coordinated Patching

Apply edits to all target files in a single pass.

- Use the `Edit` tool for each file in dependency order (definitions before callers).
- **Validation**: After all edits are written, compile the root file first, then each dependent file.

### 4. Atomic Verification

Always verify the workspace as a whole after the full patch is applied.

- **Compile**: push each changed file with `iris_doc(mode="put", name="Package.SubPackage.ClassName.cls", content=..., compile=true)`; fix any errors before proceeding to the next file
- **Test**: Run the full test suite related to the change via `iris_test`
- **Revert**: If any file fails to compile or tests regress, revert ALL changes in the iteration using `git checkout -- <file>` (via Bash) before starting the next attempt

## Common Scenarios

### 1. Method Signature Update

**Context**: A method signature is modified (parameters added, removed, or types changed).
**Discovery**:

1. Call `docs_introspect` on the class to capture the current signature.
2. Use `Grep` to find all callers of the method across `.cls` files.
3. List all call sites in the repair plan.
   **Transformation**:

- Update all identified call sites to match the new signature.
- Provide default values for newly added parameters if possible.

### 2. Class/Member Rename

**Context**: A class name or a public property/method is renamed.
**Discovery**:

1. Use `Grep` to find all occurrences of the old symbol name across the workspace.
2. After renaming, run `iris_search` over the affected packages for the old name and confirm it is gone from the server's code. Compiling does not check a rename: a call to a method that no longer exists compiles, and fails only when it runs, with `<METHOD DOES NOT EXIST>`.
   **Transformation**:

- Rename the definition.
- Rename all occurrences in referencing files.
- Update `##class(OldName)` to `##class(NewName)` everywhere.

### 3. Interface Implementation Sync

**Context**: An abstract class or interface is updated, requiring all subclasses to be updated.
**Discovery**:

1. Use `Grep` to find all classes that `Extends` the modified class.
2. Call `docs_introspect` on each subclass to see which methods they currently implement.
   **Transformation**:

- Implement or update the required methods in all subclasses to maintain contract compliance.

## Common Pitfalls

- Forgetting to update a caller in a different package.
- Mismatching parameter counts after a signature change.
- Circular dependencies causing compilation loops — compile in dependency order (base class first).
- Compiling before pushing — `iris_compile` compiles the source IRIS holds, so push local edits with `iris_doc(mode="put", compile=true)` first.

## Related skills

- **objectscript-navigation** — to map the full dependency graph before planning repairs
- **objectscript-debugging** — to trace runtime errors to their source before repairing
- **objectscript-review** — to review the repaired code before compiling
- **objectscript-tdd** — to write a failing test first, then repair until it passes

Versions

The database has no other skills named objectscript-repair.

Database snapshot: 13.11.2026 · package version be6e7ad14861 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100objectscript-tdd
    Compile-test-fix loop for ObjectScript development. Use when writing or modifying ObjectScript classes.
  • 95objectscript-list-patterns
    ObjectScript %List, %ListOfDataTypes, $LISTBUILD, $LISTTOSTRING, $LISTNEXT patterns. Use when building, iterating, merging, or converting lists in ObjectScript.
  • 95function-class-generator
    Generate complete, production-ready functions and classes from formal specifications, design descriptions, type signatures, or natural language requirements. Use this skill when implementing APIs from specifications, creating data structures from schemas, building classes from…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.