Skip to content
Back to search

iris-legacy-kit

MarketplaceWorks with Claude CodeGitHub

Claude Code kit for legacy InterSystems IRIS projects

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/intersystems-ib--iris-legacy-kit/badge.svg)](/listings/intersystems-ib--iris-legacy-kit)

HTML

<a href="/listings/intersystems-ib--iris-legacy-kit"><img src="/api/listings/intersystems-ib--iris-legacy-kit/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

claude plugin marketplace add intersystems-ib/iris-legacy-kit
claude plugin install iris-legacy@iris-legacy-kit --scope project

`--scope project` records both in the project's `.claude/settings.json`, so teammates who open the repo get the same plugin. At the first session start, a hook installs the pinned tools into the plugin's data directory (`~/.claude/plugins/data/<plugin id>/`), each checked against the sha256 in `plugins/iris-legacy/versions.json`. `/iris-legacy:setup` checks or repeats that.

Requirements: `jq`, `curl`, `unzip`; [`uv`](https://docs.astral.sh/uv/) for the global map; network access to GitHub, PyPI and the npm registry for the first install.

Then, in the project, ask Claude to bootstrap it (`/iris-legacy:bootstrap`): it finds the code, converts headerless or exported routines, asks whether IRIS runs in Docker (it generates the stack) or on an existing development instance, writes the files below plus `CLAUDE.md` and the project settings, proves the compile-on-edit loop and records a baseline. It commits nothing.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 15 lines
  1. {
  2. "name": "iris-legacy-kit",
  3. "description": "Claude Code kit for legacy InterSystems IRIS projects",
  4. "owner": {
  5. "name": "Pierre-Yves Duquesnoy",
  6. "url": "https://github.com/intersystems-ib"
  7. },
  8. "plugins": [
  9. {
  10. "name": "iris-legacy",
  11. "source": "./plugins/iris-legacy",
  12. "description": "Pinned tools, legacy-routine skills and the edit loop for routine-and-global IRIS code"
  13. }
  14. ]
  15. }
README.md · README · 156 lines
  1. # iris-legacy-kit
  2. A Claude Code plugin, and its marketplace, for legacy InterSystems IRIS code: routines, globals
  3. and the class layers built on them. It packages what a demo on a synthetic 1998-style
  4. order-management system (OMS) proved: pinned tools, legacy-routine skills, a compile-and-lint edit
  5. loop, and a way to report tool defects upstream.
  6. What it gives a Claude Code session in an IRIS code repository:
  7. - **An edit loop.** Every edit of a `.mac`, `.int`, `.inc` or `.cls` file in the source dirs is
  8. uploaded and compiled in a development namespace, and compile errors come straight back to
  9. Claude. A second hook runs [ascot](https://github.com/intersystems-community/ascot) over the
  10. source dirs (callers broken anywhere by the edit, missing labels and routines, wrong argument
  11. counts) and reports the legacy smells the edit added (naked global references, `LOCK` without
  12. a timeout, `GOTO LABEL+n`, `QUIT` inside an open transaction, `$ZU`).
  13. - **An MCP server**, [iris-interop-dev](https://github.com/intersystems-ib/iris-interop-dev) with
  14. its `routines` profile: run ObjectScript, read documents and globals, run unit tests.
  15. - **Skills** for routine and global idioms, a bootstrap that sets a repository up, a global map
  16. (which labels read, set, kill or lock each global), characterization tests before a change,
  17. on-demand lint, and reporting tool defects upstream.
  18. - **Pinned tools**, installed into the plugin's data directory on the first session and checked
  19. against the checksums in `versions.json`, with a weekly release watch that proposes pin bumps.
  20. See [DESIGN.md](DESIGN.md) for how it is put together.
  21. ## Install
  22. ```bash
  23. claude plugin marketplace add intersystems-ib/iris-legacy-kit
  24. claude plugin install iris-legacy@iris-legacy-kit --scope project
  25. ```
  26. `--scope project` records both in the project's `.claude/settings.json`, so teammates who open
  27. the repo get the same plugin. At the first session start, a hook installs the pinned tools into
  28. the plugin's data directory (`~/.claude/plugins/data/<plugin id>/`), each checked against the
  29. sha256 in `plugins/iris-legacy/versions.json`. `/iris-legacy:setup` checks or repeats that.
  30. Requirements: `jq`, `curl`, `unzip`; [`uv`](https://docs.astral.sh/uv/) for the global map;
  31. network access to GitHub, PyPI and the npm registry for the first install.
  32. Then, in the project, ask Claude to bootstrap it (`/iris-legacy:bootstrap`): it finds the code,
  33. converts headerless or exported routines, asks whether IRIS runs in Docker (it generates the
  34. stack) or on an existing development instance, writes the files below plus `CLAUDE.md` and the
  35. project settings, proves the compile-on-edit loop and records a baseline. It commits nothing.
  36. ## Project files
  37. The hooks and the MCP server act only in a project that has both of these (the bootstrap writes
  38. them):
  39. `.iris-agentic-dev.toml`, the IRIS the MCP server and the compile hook use:
  40. ```toml
  41. host = "localhost"
  42. web_port = 46080 # the Web Gateway's port: Atelier REST, not the superserver
  43. namespace = "APP" # a development namespace, never production
  44. username = "_SYSTEM"
  45. password = "SYS" # Docker dev stack only. For an existing instance the bootstrap writes no
  46. # credentials: each developer sets IRIS_USERNAME and IRIS_PASSWORD in
  47. # .claude/settings.local.json (gitignored)
  48. ```
  49. `.claude/iris-legacy.json`, the kit config:
  50. ```json
  51. {
  52. "sourceDirs": ["src"],
  53. "environment": "docker",
  54. "tests": { "package": "App.Test" },
  55. "errors": { "trap": "ERR^APPUTL", "log": "^ERRORS" },
  56. "publish": [{ "dir": "ui", "command": "scripts/ui.sh" }],
  57. "lint": { "ascot": true, "smells": true }
  58. }
  59. ```
  60. - `sourceDirs`: ObjectScript under these is uploaded, compiled and linted after each edit.
  61. Anything elsewhere is never sent to IRIS.
  62. - `publish` (optional): a command run from the project root after an edit under `dir`.
  63. - `lint` (optional): switch either check off, replace the ascot code list with `ascotCodes`, or
  64. list declarations files for ascot to ask before the kit's with `ascotIris` (for classes IRIS
  65. Community's `%SYS` lacks, such as `Ens.*` and `HS.*`; make one with `ascot declare`).
  66. - `report` (optional): `denyTerms` the sanitizer always refuses (the customer's name), `maxPerDay`
  67. (default 3). Findings go to this repo's issues, sanitized and checked for duplicates first,
  68. unless `IRIS_LEGACY_REPORT_TO=upstream` is set (the kit owner's environment only, where
  69. `IRIS_LEGACY_FINDINGS` points at the owner's findings ledger).
  70. ## What it contains
  71. | Path | What |
  72. | --- | --- |
  73. | `.claude-plugin/marketplace.json` | The marketplace: one plugin, `iris-legacy` |
  74. | `plugins/iris-legacy/.claude-plugin/plugin.json` | Plugin manifest |
  75. | `plugins/iris-legacy/versions.json` | The only place versions and checksums are pinned: iris-interop-dev, ascot (with the IRIS declarations from its npm package), ast-grep, tree-sitter-objectscript |
  76. | `plugins/iris-legacy/hooks/hooks.json` | SessionStart: install the tools. PostToolUse on edits: compile hook, then lint hook |
  77. | `plugins/iris-legacy/.mcp.json` | MCP server `iris`: the pinned iris-interop-dev, `routines` profile, started in the project root |
  78. | `plugins/iris-legacy/scripts/setup.sh` | Installs and checks the pinned tools (`--check`, `--hook`) |
  79. | `plugins/iris-legacy/scripts/post-edit.sh` | Compile hook: upload and compile edits in the source dirs; compile errors back to Claude |
  80. | `plugins/iris-legacy/scripts/lint.sh` | Lint hook and on-demand checks: filtered ascot, plus legacy smells an edit adds; `--sarif` for CI |
  81. | `plugins/iris-legacy/scripts/report.sh` | The auto-improve loop: findings ledger, dedupe, sanitizer, filing with gh |
  82. | `plugins/iris-legacy/scripts/bootstrap.sh` | The bootstrap's steps: `detect`, `convert`, `write`, `prove`, `baseline` |
  83. | `plugins/iris-legacy/scripts/globalmap.sh`, `tools/globalmap/` | The global map (tree-sitter), with the pinned grammar and a hash-locked `tree-sitter` |
  84. | `plugins/iris-legacy/scripts/mcp.sh`, `common.sh` | MCP entry point; shared project and config lookup |
  85. | `plugins/iris-legacy/templates/` | What the bootstrap writes: the `CLAUDE.md` block, permissions, `.gitignore` lines, the Docker stack and its scripts |
  86. | `plugins/iris-legacy/lint/ast-grep/` | The legacy-smell rules and their tests |
  87. | `plugins/iris-legacy/skills/` | `bootstrap`, `legacy-routines-globals` (idioms), `map-globals`, `characterize` (with `Template.cls`), `report-upstream`, `lint`, `setup` |
  88. | `tools/release-watch.sh`, `.github/workflows/release-watch.yml` | The release watch (below) |
  89. | `tests/` | The test suites below; the OMS fixture `hooks.sh` edits; captured GitHub, PyPI and npm answers |
  90. ## Tests
  91. The tests never download anything. Fetch the pinned tools once into `.test-data/` (gitignored)
  92. and keep them:
  93. ```bash
  94. CLAUDE_PLUGIN_DATA="$PWD/.test-data" plugins/iris-legacy/scripts/setup.sh # once, needs network
  95. ```
  96. ```bash
  97. tests/smoke.sh # manifests validate; a fresh install from the kept downloads; a re-run changes
  98. # nothing; a wrong checksum is refused. A curl stand-in blocks any network fetch
  99. tests/install.sh # marketplace add and install at project scope in a throwaway project; user settings untouched
  100. tests/hooks.sh # 42 checks: the scripted agent mistakes from the OMS evaluation, SARIF output,
  101. # ascot never downloading, hook routing, the MCP server's tool list, the smell
  102. # rules; the 2 live compile checks run only when the OMS stack answers
  103. tests/bootstrap.sh # 58 checks: detect, convert, write in both modes, refusals, idempotence,
  104. # baseline; prove against the OMS stack when it answers
  105. tests/skills.sh # the global map against golden output; the characterize template in IRIS
  106. tests/report.sh # 57 checks, offline: this month's real findings replay as duplicates; new ones
  107. # file once, to the right repo per mode; customer names are blocked
  108. tests/release-watch.sh # offline: the release watch against captured GitHub, PyPI and npm
  109. # answers; no download, kit pins untouched
  110. ```
  111. The live checks need a development IRIS with the OMS fixture loaded in namespace `OMS`, its Web
  112. Gateway on `localhost:46080`; they create throwaway `ZZ*` probes and delete them, and are skipped
  113. when nothing answers there.
  114. `hooks.sh` checks that ascot reads only the pinned declarations: it runs with an empty `HOME` and
  115. fails if ascot created `~/.ascot`.
  116. ## Release watch
  117. `tools/release-watch.sh` compares each pin with the tool's latest release (GitHub releases API;
  118. PyPI for the grammar) and never downloads a tool: new checksums are the sha256 digests the
  119. release publishes, and for ascot's declarations the sha512 integrity of its npm package of the
  120. same version, which moves with the ascot pin. `--updates` lists them, `--write [TOOL...]` rewrites the pins (all or nothing;
  121. never a guessed or empty checksum), and `--pr [TOOL...]` makes `pin/<tool>-<version>` or
  122. `pin/<date>` with one commit and prints the PR title and body; only `--push` pushes and opens it.
  123. The weekly workflow `.github/workflows/release-watch.yml` does that per tool, with the new pin
  124. installed and tested on the runner. It needs Actions enabled on the repo and, under Settings >
  125. Actions > General > Workflow permissions, "Allow GitHub Actions to create and approve pull
  126. requests".
  127. ## Licence
  128. MIT, see [LICENSE](LICENSE). The tools the kit installs keep their own licences.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.