readystack-jdk25-upgrade-blocker-lint 1.0.3__tar.gz

readystack_jdk25_upgrade_blocker_lint-1.0.3/LICENSE.txt

@@ -0,0 +1,16 @@
+JDK 25 Upgrade Blocker Lint — Licence
+
+Free scope
+  Scans every .java file you open or the whole workspace and names each JDK 21/25 blocker on its line with the JEP that removed it and the replacement call. is free for any use, personal or commercial, for as long as you keep the
+  extension installed, and the online check at the product page is free without registration.
+
+Paid scope
+  Exports the whole repository as one dated migration report — every file, blocker, JEP and replacement in Markdown and CSV — to hand to the team or attach to the upgrade ticket, and covers commercial and team-seat use. is the paid part. It asks for a licence key issued at purchase (one seat, one key;
+  7-day full refund, no questions). The key is checked against the payment provider and
+  cached locally for 30 days so it keeps working offline.
+
+Redistribution
+  You may not resell, re-host or bundle this extension or its rule set. The rule set and the
+  engine are provided as-is; check results are advisory and do not constitute legal advice.
+
+(c) ReadyStack — https://getreadystack.com

readystack_jdk25_upgrade_blocker_lint-1.0.3/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: readystack-jdk25-upgrade-blocker-lint
+Version: 1.0.3
+Summary: Finds the Java lines the new LTS removed — 18 rules; 23 findings in one 64-line fixture
+Author-email: ReadyStack <support@getreadystack.com>
+License: Proprietary - see LICENSE.txt
+Project-URL: Homepage, https://getreadystack.com/tools/jdk25-upgrade-blocker-lint?ref=pypi
+Project-URL: Documentation, https://getreadystack.com/tools/jdk25-upgrade-blocker-lint?ref=pypi
+Project-URL: Support, https://getreadystack.com/support
+Keywords: java,jdk,migration,jakarta,linter,upgrade
+Classifier: Programming Language :: Python :: 3
+Classifier: Environment :: Console
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Dynamic: license-file
+
+# JDK 25 Upgrade Blocker Lint
+
+Finds the Java lines the new LTS removed — 18 rules; 23 findings in one 64-line fixture
+
+## Install
+
+```
+jdk25-upgrade-blocker-lint file
+```
+
+Node 18+. The same 18 rules as the VS Code extension, from a terminal or CI.
+
+## Free
+
+- Lints the .java file you have open with all 18 rules, no key and no cap — the bundled 64-line fixture returns 23 findings, 15 errors and 8 warnings; the fixed copy returns 0.
+- `--rules` lists every rule
+
+## With a licence ($29 once)
+
+- Sweeps the whole workspace and writes the dated migration report file — every file, blocker, JEP and replacement — for the upgrade ticket; free for the first 7 days, then one key, commercial and CI-seat use included.
+
+```
+@readystack/jdk25-upgrade-blocker-lint --dir ./templates --report html --out report.html
+```
+
+A Java migration consultant bills $120-$200 an hour; a two-day audit of one repo is over $2,000.
+
+## Use from an AI agent (MCP)
+
+Claude Code · Cursor · Windsurf · any MCP client - add to your MCP config:
+
+```json
+{ "mcpServers": { "jdk25-upgrade-blocker-lint": { "command": "npx", "args": ["-y", "@readystack/jdk25-upgrade-blocker-lint", "--mcp"] } } }
+```
+
+Tools: `check_text` and `check_file` (free) · `check_dir` (licence; the full sweep is free for 7 days). The agent gets every finding with the line number.
+
+## Use in CI
+
+```yaml
+- name: JDK 25 Upgrade Blocker Lint
+  run: npx -y @readystack/jdk25-upgrade-blocker-lint --dir . --ci
+```
+
+(container: `docker run --rm -v "$PWD:/work" getreadystack/jdk25-upgrade-blocker-lint --dir /work --ci`)
+
+Try the full run free for 7 days — no key needed. Then one licence, 7-day refund, no questions. Set `READYSTACK_LICENSE=<key>` or run `--license <key>` once.
+
+[Get a licence](https://buy.polar.sh/polar_cl_YK2CXL7Hd4TEoxQ76oOVQpVAsrLK9zUpcK7oV2MKwJs)
+
+
+<!-- jdk25 upgrade blocker lint -->
+
+
+## Install (PyPI)
+
+```
+pip install readystack-jdk25-upgrade-blocker-lint
+jdk25-upgrade-blocker-lint --help
+```

readystack_jdk25_upgrade_blocker_lint-1.0.3/README.md

@@ -0,0 +1,60 @@
+# JDK 25 Upgrade Blocker Lint
+
+Finds the Java lines the new LTS removed — 18 rules; 23 findings in one 64-line fixture
+
+## Install
+
+```
+jdk25-upgrade-blocker-lint file
+```
+
+Node 18+. The same 18 rules as the VS Code extension, from a terminal or CI.
+
+## Free
+
+- Lints the .java file you have open with all 18 rules, no key and no cap — the bundled 64-line fixture returns 23 findings, 15 errors and 8 warnings; the fixed copy returns 0.
+- `--rules` lists every rule
+
+## With a licence ($29 once)
+
+- Sweeps the whole workspace and writes the dated migration report file — every file, blocker, JEP and replacement — for the upgrade ticket; free for the first 7 days, then one key, commercial and CI-seat use included.
+
+```
+@readystack/jdk25-upgrade-blocker-lint --dir ./templates --report html --out report.html
+```
+
+A Java migration consultant bills $120-$200 an hour; a two-day audit of one repo is over $2,000.
+
+## Use from an AI agent (MCP)
+
+Claude Code · Cursor · Windsurf · any MCP client - add to your MCP config:
+
+```json
+{ "mcpServers": { "jdk25-upgrade-blocker-lint": { "command": "npx", "args": ["-y", "@readystack/jdk25-upgrade-blocker-lint", "--mcp"] } } }
+```
+
+Tools: `check_text` and `check_file` (free) · `check_dir` (licence; the full sweep is free for 7 days). The agent gets every finding with the line number.
+
+## Use in CI
+
+```yaml
+- name: JDK 25 Upgrade Blocker Lint
+  run: npx -y @readystack/jdk25-upgrade-blocker-lint --dir . --ci
+```
+
+(container: `docker run --rm -v "$PWD:/work" getreadystack/jdk25-upgrade-blocker-lint --dir /work --ci`)
+
+Try the full run free for 7 days — no key needed. Then one licence, 7-day refund, no questions. Set `READYSTACK_LICENSE=<key>` or run `--license <key>` once.
+
+[Get a licence](https://buy.polar.sh/polar_cl_YK2CXL7Hd4TEoxQ76oOVQpVAsrLK9zUpcK7oV2MKwJs)
+
+
+<!-- jdk25 upgrade blocker lint -->
+
+
+## Install (PyPI)
+
+```
+pip install readystack-jdk25-upgrade-blocker-lint
+jdk25-upgrade-blocker-lint --help
+```

readystack_jdk25_upgrade_blocker_lint-1.0.3/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "readystack-jdk25-upgrade-blocker-lint"
+version = "1.0.3"
+description = "Finds the Java lines the new LTS removed \u2014 18 rules; 23 findings in one 64-line fixture"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "Proprietary - see LICENSE.txt"}
+keywords = ["java", "jdk", "migration", "jakarta", "linter", "upgrade"]
+authors = [{name = "ReadyStack", email = "support@getreadystack.com"}]
+classifiers = ["Programming Language :: Python :: 3", "Environment :: Console", "Topic :: Software Development :: Quality Assurance", "Operating System :: OS Independent"]
+
+[project.urls]
+Homepage = "https://getreadystack.com/tools/jdk25-upgrade-blocker-lint?ref=pypi"
+Documentation = "https://getreadystack.com/tools/jdk25-upgrade-blocker-lint?ref=pypi"
+Support = "https://getreadystack.com/support"
+
+[project.scripts]
+"jdk25-upgrade-blocker-lint" = "readystack_jdk25_upgrade_blocker_lint.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"readystack_jdk25_upgrade_blocker_lint" = ["rules.json", "strings.json"]

readystack_jdk25_upgrade_blocker_lint-1.0.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

readystack_jdk25_upgrade_blocker_lint-1.0.3/src/readystack_jdk25_upgrade_blocker_lint/__init__.py

@@ -0,0 +1 @@
+__version__ = '1.0.3'

readystack_jdk25_upgrade_blocker_lint-1.0.3/src/readystack_jdk25_upgrade_blocker_lint/cli.py

@@ -0,0 +1,135 @@
+# cli.py — the same rules as the VS Code extension, from a terminal, a container or an MCP client. Generated by pypi_build.py.
+import json, os, sys, time, datetime
+from . import engine as ENGINE, license as lic
+_HERE = os.path.dirname(os.path.abspath(__file__))
+S = json.load(open(os.path.join(_HERE, 'strings.json'), encoding='utf-8'))
+def scan(text, file=''):
+    r = ENGINE.check(str(text), {'today': datetime.date.today().isoformat(), 'path': file})
+    return [{'line': int(f.get('line') or 1), 'msg': str(f.get('msg') or f.get('check') or ''), 'fix': f.get('fix'), 'sev': 'error' if str(f.get('sev', 'error')).lower().startswith('err') else 'warn'} for f in r.get('findings', [])]
+def is_text(p):
+    try:
+        with open(p, 'rb') as h: b = h.read(4096)
+        return os.path.getsize(p) <= 2 * 1024 * 1024 and b'\x00' not in b
+    except Exception: return False
+def walk(d, exts, out):
+    try: ents = list(os.scandir(d))
+    except Exception: return out
+    for e in ents:
+        if e.name in ('node_modules', '.git') or e.name.startswith('.'): continue
+        if e.is_dir(): walk(e.path, exts, out)
+        elif (not exts or os.path.splitext(e.name)[1].lower() in exts) and is_text(e.path): out.append(e.path)
+    return out
+def esc(s): return str(s).replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;')
+def csvq(s): return '"' + str('' if s is None else s).replace('"', '""') + '"'
+RULE_N = len(ENGINE.RULES)
+def render(rows, fmt):
+    if fmt == 'json': return json.dumps({'tool': S['name'], 'rules': RULE_N, 'files': rows}, indent=1)
+    if fmt == 'csv':
+        o = ['file,line,severity,message,fix']
+        for r in rows:
+            for h in r['hits']: o.append(','.join([csvq(r['file']), str(h['line']), h['sev'], csvq(h['msg']), csvq(h['fix'])]))
+        return '\n'.join(o)
+    if fmt == 'html':
+        n = sum(len(r['hits']) for r in rows)
+        o = '<!doctype html><meta charset="utf-8"><title>' + esc(S['name']) + ' report</title><style>body{font:14px system-ui;margin:24px}table{border-collapse:collapse}td,th{border:1px solid #ddd;padding:4px 8px}</style>'
+        o += '<h1>' + esc(S['name']) + '</h1><p>' + str(len(rows)) + ' files · ' + str(n) + ' findings · ' + str(RULE_N) + ' rules</p><table><tr><th>file</th><th>line</th><th>sev</th><th>message</th><th>fix</th></tr>'
+        for r in rows:
+            for h in r['hits']: o += '<tr><td><code>' + esc(r['file']) + '</code></td><td>' + str(h['line']) + '</td><td>' + esc(h['sev']) + '</td><td>' + esc(h['msg']) + '</td><td>' + esc(h['fix'] or '') + '</td></tr>'
+        return o + '</table>'
+    o = ''
+    for r in rows:
+        o += r['file'] + '\n'
+        for h in r['hits']: o += '  ' + str(h['line']).rjust(5) + '  ' + h['sev'].ljust(5) + ' ' + h['msg'] + ('\n         -> ' + h['fix'] if h['fix'] else '') + '\n'
+    return o
+def trial_state():
+    if os.environ.get('READYSTACK_NO_TRIAL'): return {'active': False}
+    try:
+        p = os.path.join(os.path.dirname(lic.store_path()), S['bin'] + '.trial.json'); t = None
+        try: t = json.load(open(p, encoding='utf-8'))
+        except Exception: pass
+        if not t or not t.get('until'):
+            t = {'until': (datetime.date.today() + datetime.timedelta(days=7)).isoformat()}; os.makedirs(os.path.dirname(p), exist_ok=True); json.dump(t, open(p, 'w', encoding='utf-8'))
+        return {'active': datetime.date.fromisoformat(t['until']) >= datetime.date.today(), 'until': t['until']}
+    except Exception: return {'active': False}
+def mcp_serve():
+    os.environ['READYSTACK_MCP'] = '1'
+    def send(o): sys.stdout.write(json.dumps(o) + '\n'); sys.stdout.flush()
+    tools = [
+        {'name': 'check_text', 'description': S['name'] + ' - run all ' + str(RULE_N) + ' checks on a text (free)', 'inputSchema': {'type': 'object', 'properties': {'text': {'type': 'string', 'description': 'file contents'}, 'path': {'type': 'string'}}, 'required': ['text']}},
+        {'name': 'check_file', 'description': S['name'] + ' - run all checks on one file by path (free)', 'inputSchema': {'type': 'object', 'properties': {'path': {'type': 'string'}}, 'required': ['path']}},
+        {'name': 'check_dir', 'description': S['name'] + ' - sweep a folder and return every finding (licence; the full run is free for 7 days)', 'inputSchema': {'type': 'object', 'properties': {'dir': {'type': 'string'}, 'ext': {'type': 'string'}}, 'required': ['dir']}},
+    ]
+    def result(i, rows): send({'jsonrpc': '2.0', 'id': i, 'result': {'content': [{'type': 'text', 'text': render(rows, 'text')}], 'structuredContent': {'tool': S['name'], 'rules': RULE_N, 'files': rows}}})
+    def fail(i, text): send({'jsonrpc': '2.0', 'id': i, 'result': {'content': [{'type': 'text', 'text': text}], 'isError': True}})
+    for line in sys.stdin:
+        try: m = json.loads(line)
+        except Exception: continue
+        i, method = m.get('id'), m.get('method')
+        if method == 'initialize': send({'jsonrpc': '2.0', 'id': i, 'result': {'protocolVersion': '2025-06-18', 'capabilities': {'tools': {}}, 'serverInfo': {'name': 'readystack-' + S['bin'], 'version': '1.0.3'}}}); continue
+        if method in ('notifications/initialized', 'ping'):
+            if i is not None: send({'jsonrpc': '2.0', 'id': i, 'result': {}})
+            continue
+        if method == 'tools/list': send({'jsonrpc': '2.0', 'id': i, 'result': {'tools': tools}}); continue
+        if method == 'tools/call':
+            name = (m.get('params') or {}).get('name'); args = (m.get('params') or {}).get('arguments') or {}
+            try:
+                if name == 'check_text': result(i, [{'file': args.get('path') or '(text)', 'hits': scan(str(args.get('text') or ''), args.get('path') or '')}]); continue
+                if name == 'check_file': result(i, [{'file': args['path'], 'hits': scan(open(args['path'], encoding='utf-8', errors='replace').read(), args['path'])}]); continue
+                if name == 'check_dir':
+                    r = lic.ensure()
+                    if not r['ok'] and not trial_state()['active']: fail(i, S['need_key'] + ' Get a licence ($' + str(S['price']) + ', once, 7-day refund): ' + lic.BUY_URL); continue
+                    files = walk(args['dir'], [args['ext']] if args.get('ext') else (S.get('exts') or []), [])
+                    rows = []
+                    for f in files:
+                        try: rows.append({'file': f, 'hits': scan(open(f, encoding='utf-8', errors='replace').read(), f)})
+                        except Exception as e: rows.append({'file': f, 'hits': [], 'error': str(e)})
+                    result(i, rows); continue
+                send({'jsonrpc': '2.0', 'id': i, 'error': {'code': -32601, 'message': 'unknown tool ' + str(name)}})
+            except Exception as e: fail(i, str(e))
+            continue
+        if i is not None: send({'jsonrpc': '2.0', 'id': i, 'error': {'code': -32601, 'message': 'method not found: ' + str(method)}})
+def help_text():
+    b = S['bin']
+    return '\n'.join([S['name'] + ' - ' + S['subtitle'], '', 'Usage: ' + b + ' <file> [more files]           check the files you name (free, every rule)',
+        '       ' + b + ' --dir <folder> [--ext .py]    scan a whole folder            (licence)',
+        '       ' + b + ' ... --report csv|json|html [--out file]   export a report   (licence)',
+        '       ' + b + ' ... --ci                      exit 1 when an error-level finding exists (licence)',
+        '       ' + b + ' --license <key>               store your licence key (or set READYSTACK_LICENSE)',
+        '       ' + b + ' --rules                       list the ' + str(RULE_N) + ' rules',
+        '       ' + b + ' --mcp                         run as an MCP server (stdio) for Claude Code / Cursor / Windsurf - free checks, folder sweep needs a licence', '',
+        'Free: ' + S['free'], 'Licence ($' + str(S['price']) + ', once, 7-day refund): ' + S['paid'], 'Get a licence: ' + lic.BUY_URL, ''])
+def main(argv=None):
+    a = list(sys.argv[1:] if argv is None else argv)
+    try:
+        feed = lic.pull_feed()
+        if feed and isinstance(feed.get('rules'), list): ENGINE.RULES.extend(feed['rules'])
+    except Exception: pass
+    def get(k):
+        return a[a.index(k) + 1] if k in a and a.index(k) + 1 < len(a) else None
+    if '--mcp' in a: mcp_serve(); return 0
+    if not a or '--help' in a or '-h' in a: sys.stdout.write(help_text()); return 0
+    if '--rules' in a:
+        sys.stdout.write('\n'.join(str(i + 1).rjust(3) + '  [' + str(r.get('sev', 'warn')) + '] ' + str(r.get('msg') or r.get('id') or '') for i, r in enumerate(ENGINE.RULES)) + '\n'); return 0
+    if '--license' in a:
+        r = lic.ensure(get('--license')); sys.stdout.write(('Licence stored: ' + lic.store_path() if r['ok'] else 'Licence not accepted (' + str(r.get('why')) + ')') + '\n'); return 0 if r['ok'] else 1
+    d, fmt, out, ci = get('--dir'), get('--report'), get('--out'), '--ci' in a
+    exts = [get('--ext')] if '--ext' in a else (S.get('exts') or [])
+    if d or fmt or ci:
+        r = lic.ensure()
+        if not r['ok']:
+            t = trial_state()
+            if t['active']: sys.stderr.write('Trial: the full run is free until ' + t['until'] + ' - after that $' + str(S['price']) + ' once (7-day refund). Get a licence: ' + lic.BUY_URL + '\n')
+            else: sys.stderr.write(S['need_key'] + '\n  set READYSTACK_LICENSE=<key>  or  ' + S['bin'] + ' --license <key>\n  Get a licence ($' + str(S['price']) + ', once): ' + lic.BUY_URL + '\n'); return 2
+    flags = {'--dir', '--report', '--out', '--ext', '--license'}
+    files = walk(d, exts, []) if d else [x for i, x in enumerate(a) if not x.startswith('--') and (i == 0 or a[i - 1] not in flags)]
+    if not files: sys.stderr.write('No files. ' + S['bin'] + ' --help\n'); return 2
+    rows = []
+    for f in files:
+        try: rows.append({'file': f, 'hits': scan(open(f, encoding='utf-8', errors='replace').read(), f)})
+        except Exception as e: rows.append({'file': f, 'hits': [], 'error': str(e)})
+    text = render(rows, fmt or 'text')
+    if out: open(out, 'w', encoding='utf-8').write(text)
+    else: sys.stdout.write(text if text.endswith('\n') else text + '\n')
+    errors = sum(1 for r in rows for h in r['hits'] if h['sev'] == 'error')
+    return 1 if (ci and errors) else 0
+if __name__ == '__main__': sys.exit(main())

readystack_jdk25_upgrade_blocker_lint-1.0.3/src/readystack_jdk25_upgrade_blocker_lint/engine.py

@@ -0,0 +1,30 @@
+# engine.py — same rules as the VS Code extension and the npm CLI (rules.json), pure Python. Generated by pypi_build.py.
+import json, os, re
+_HERE = os.path.dirname(os.path.abspath(__file__))
+RULES = json.load(open(os.path.join(_HERE, 'rules.json'), encoding='utf-8'))
+def _py(p): return re.sub(r'\(\?<(?![=!])', '(?P<', p)
+def _c(r):
+    if '_re' not in r:
+        r['_re'] = re.compile(_py(r['re'])); r['_ctx'] = re.compile(_py(r['ctx']), re.M) if r.get('ctx') else None
+        r['_prev'] = re.compile(_py(r['prev_not'])) if r.get('prev_not') else None; r['_next'] = re.compile(_py(r['next_re'])) if r.get('next_re') else None
+    return r
+def _code(s): t = s.strip(); return t != '' and not t.startswith('#')
+def check(text, opts=None):
+    opts = opts or {}; src = '' if text is None else str(text); lines = src.split('\n'); lines = [l.rstrip('\r') for l in lines]; out = []
+    for r in RULES:
+        r = _c(r)
+        if r['_ctx'] and not r['_ctx'].search(src): continue
+        for n, line in enumerate(lines):
+            if not _code(line) or not r['_re'].search(line): continue
+            if r['_prev']:
+                p = n - 1
+                while p >= 0 and lines[p].strip() == '': p -= 1
+                if p >= 0 and r['_prev'].search(lines[p]): continue
+            if r['_next']:
+                q = n + 1
+                while q < len(lines) and lines[q].strip() == '': q += 1
+                if q >= len(lines) or not r['_next'].search(lines[q]): continue
+            out.append({'check': r['id'], 'sev': r.get('sev', 'warn'), 'line': n + 1, 'msg': r.get('msg', ''), 'fix': r.get('fix'), 'text': line.strip()[:160]})
+    out.sort(key=lambda f: f['line'])
+    return {'findings': out, 'scanned_lines': len(lines), 'rule_count': len(RULES),
+            'errors': sum(1 for f in out if f['sev'] == 'error'), 'warnings': sum(1 for f in out if f['sev'] == 'warn'), 'today': opts.get('today', '')}

readystack_jdk25_upgrade_blocker_lint-1.0.3/src/readystack_jdk25_upgrade_blocker_lint/license.py

@@ -0,0 +1,61 @@
+# license.py — Polar licence check (same contract as license.js). Generated by pypi_build.py.
+import json, os, sys, time, urllib.request
+ORG_ID = 'a5cdf664-d8e7-4f87-8895-056717aaba17'; BENEFIT_ID = 'ecc7be06-5c7b-418a-abf2-9204bdc20568'; BUY_URL = 'https://buy.polar.sh/polar_cl_YK2CXL7Hd4TEoxQ76oOVQpVAsrLK9zUpcK7oV2MKwJs'; ALL_BENEFIT_ID = '22692551-5203-4467-b1a3-e33cdba6589d'; SLUG = 'jdk25-upgrade-blocker-lint'
+GRACE = 30 * 86400; RECHECK = 7 * 86400
+def store_path():
+    return os.path.join(os.environ.get('READYSTACK_HOME') or os.path.join(os.path.expanduser('~'), '.config', 'readystack'), SLUG + '.json')
+def load():
+    try: return json.load(open(store_path(), encoding='utf-8'))
+    except Exception: return {}
+def save(o):
+    try:
+        os.makedirs(os.path.dirname(store_path()), exist_ok=True); json.dump(o, open(store_path(), 'w', encoding='utf-8'))
+    except Exception: pass
+def _post(url, body, headers, timeout):
+    req = urllib.request.Request(url, data=json.dumps(body).encode(), headers=dict({'content-type': 'application/json'}, **headers), method='POST')
+    return urllib.request.urlopen(req, timeout=timeout)
+def _validate1(key, ben):
+    if not ORG_ID: return {'ok': False, 'offline': False}
+    body = {'key': key, 'organization_id': ORG_ID}
+    if len(ben) == 36: body['benefit_id'] = ben
+    try:
+        r = _post('https://api.polar.sh/v1/customer-portal/license-keys/validate', body, {'polar-version': '2026-04', 'user-agent': 'readystack-py/' + SLUG}, 8)
+        if r.status != 200: return {'ok': False, 'offline': False}
+        j = json.loads(r.read().decode() or '{}'); return {'ok': bool(j and (j.get('status') == 'granted' or j.get('valid') is True or j.get('id'))), 'offline': False}
+    except urllib.error.HTTPError: return {'ok': False, 'offline': False}
+    except Exception: return {'ok': False, 'offline': True}
+def validate(key):
+    r = _validate1(key, BENEFIT_ID)
+    if r['ok'] or r['offline'] or len(ALL_BENEFIT_ID) != 36: return r
+    return _validate1(key, ALL_BENEFIT_ID)
+_pinged = [False]
+def ping_paywall(why):
+    try:
+        if _pinged[0]: return
+        _pinged[0] = True
+        if os.environ.get('DO_NOT_TRACK') == '1' or os.environ.get('READYSTACK_NO_TELEMETRY') or os.environ.get('CI'): return
+        if not (sys.stdout.isatty() or sys.stdin.isatty() or os.environ.get('READYSTACK_MCP') == '1'): return
+        _post('https://getreadystack.com/api/ev', {'t': 'paywall', 'slug': SLUG, 'src': 'mcp' if os.environ.get('READYSTACK_MCP') == '1' else 'cli', 'why': why or 'no_key'}, {'user-agent': 'readystack-py/' + SLUG}, 3).read()
+    except Exception: pass
+def ensure(explicit=None):
+    st = load(); key = explicit or os.environ.get('READYSTACK_LICENSE') or st.get('key')
+    if not key: ping_paywall('no_key'); return {'ok': False, 'why': 'no_key'}
+    age = time.time() - (st.get('okAt') or 0)
+    if not explicit and st.get('key') == key and age < RECHECK: return {'ok': True, 'cached': True}
+    r = validate(str(key).strip())
+    if r['ok']: save({'key': str(key).strip(), 'okAt': time.time()}); return {'ok': True}
+    if r['offline'] and st.get('key') == key and age < GRACE: return {'ok': True, 'offline': True}
+    if not r['offline']: ping_paywall('invalid')
+    return {'ok': False, 'why': 'offline' if r['offline'] else 'invalid'}
+def pull_feed():
+    st = load(); key = os.environ.get('READYSTACK_LICENSE') or st.get('key'); cached = st.get('feed')
+    if not key: return cached
+    if cached and time.time() - (st.get('feedAt') or 0) < RECHECK: return cached
+    try:
+        import urllib.parse
+        r = urllib.request.urlopen(urllib.request.Request('https://getreadystack.com/api/rules/' + urllib.parse.quote(SLUG) + '?key=' + urllib.parse.quote(key), headers={'user-agent': 'readystack-py'}), timeout=8)
+        if r.status != 200: return cached
+        j = json.loads(r.read().decode() or '{}')
+        if not isinstance(j, dict) or not isinstance(j.get('rules'), list): return cached
+        s2 = load(); s2['feed'] = j; s2['feedAt'] = time.time(); save(s2); return j
+    except Exception: return cached

readystack_jdk25_upgrade_blocker_lint-1.0.3/src/readystack_jdk25_upgrade_blocker_lint/rules.json

@@ -0,0 +1,110 @@
+[
+ {
+  "id": "security_manager_set",
+  "re": "System\\s*\\.\\s*setSecurityManager\\s*\\(",
+  "sev": "error",
+  "msg": "System.setSecurityManager() throws UnsupportedOperationException on JDK 24 and later — JEP 486 permanently disabled the Security Manager. Delete the call and move the check into your own authorization layer."
+ },
+ {
+  "id": "access_controller",
+  "re": "AccessController\\s*\\.\\s*doPrivileged|import\\s+java\\.security\\.AccessController",
+  "sev": "error",
+  "msg": "AccessController.doPrivileged is terminally deprecated and grants nothing (JEP 486, JDK 24). The privileged block now runs with the caller's own access. Inline the body and drop the wrapper."
+ },
+ {
+  "id": "security_policy",
+  "re": "java\\.security\\.Policy|Policy\\s*\\.\\s*setPolicy\\s*\\(|SecurityManager\\s+[A-Za-z_]",
+  "sev": "error",
+  "msg": "java.security.Policy and SecurityManager are terminally deprecated with JEP 486 (JDK 24). Your .policy file grants nothing at run time — the permissions in it are no longer enforced."
+ },
+ {
+  "id": "unsafe_memory",
+  "re": "sun\\.misc\\.Unsafe|Unsafe\\s*\\.\\s*getUnsafe\\s*\\(",
+  "sev": "error",
+  "msg": "sun.misc.Unsafe memory-access methods are deprecated for removal (JEP 471, JDK 23) and warn at run time by default since JDK 24 (JEP 498). Replace with java.lang.invoke.VarHandle, or the FFM API in java.lang.foreign for off-heap memory."
+ },
+ {
+  "id": "javax_to_jakarta",
+  "re": "import\\s+javax\\.(persistence|servlet|ws\\.rs|enterprise|inject|validation|transaction|ejb|jms|mail|annotation\\.(Resource|PostConstruct|PreDestroy))",
+  "sev": "error",
+  "msg": "Jakarta EE 9 renamed this package to jakarta.*. A Jakarta EE 10/11 runtime (Spring Boot 3, Quarkus 3, Payara 6, WildFly 27+) never scans javax.* here, so the bean or endpoint silently disappears. Rename the import to jakarta.*"
+ },
+ {
+  "id": "jaxb_removed",
+  "re": "javax\\.xml\\.bind|com\\.sun\\.xml\\.bind",
+  "sev": "error",
+  "msg": "javax.xml.bind (JAXB) was removed from the JDK in Java 11 (JEP 320). On JDK 21/25 this compiles only if you add the jakarta.xml.bind-api and a runtime yourself — and the package is jakarta.xml.bind now."
+ },
+ {
+  "id": "applet_api",
+  "re": "java\\.applet|\\bextends\\s+(J?Applet)\\b",
+  "sev": "error",
+  "msg": "The Applet API was removed outright in JDK 25 (JEP 504). There is no replacement class — this file cannot compile on the new LTS."
+ },
+ {
+  "id": "thread_stop",
+  "re": "(?:[Tt]hread[A-Za-z0-9_]*|[a-z][A-Za-z0-9_]*Thread)\\s*\\.\\s*(?:stop|suspend|resume)\\s*\\(\\s*\\)",
+  "sev": "error",
+  "msg": "Thread.stop() throws UnsupportedOperationException since JDK 20, and suspend()/resume() are terminally deprecated and throw on current JDKs. Use interrupt() plus a volatile flag the worker loop reads."
+ },
+ {
+  "id": "finalize_override",
+  "re": "(?:protected|public)\\s+void\\s+finalize\\s*\\(\\s*\\)",
+  "sev": "error",
+  "msg": "Overriding finalize() is deprecated for removal (JEP 421) and finalization is already disabled by default in some runs via --finalization=disabled — your cleanup may never execute. Move it to try-with-resources or java.lang.ref.Cleaner."
+ },
+ {
+  "id": "jdk_internal_import",
+  "re": "import\\s+(?:sun\\.(?!misc\\.Unsafe)|com\\.sun\\.(?!xml\\.bind)|jdk\\.internal\\.)",
+  "sev": "error",
+  "msg": "JDK-internal packages are strongly encapsulated since JDK 17 (JEP 403). This import throws IllegalAccessError at run time unless every launch carries a matching --add-exports flag."
+ },
+ {
+  "id": "run_finalization",
+  "re": "(?:System|Runtime\\s*\\.\\s*getRuntime\\s*\\(\\s*\\))\\s*\\.\\s*runFinalization\\s*\\(",
+  "sev": "error",
+  "msg": "System.runFinalization() and Runtime.runFinalization() are deprecated for removal (JEP 421). They are no-ops once finalization is disabled — the resource you expect to be released is not released."
+ },
+ {
+  "id": "subject_do_as",
+  "re": "Subject\\s*\\.\\s*doAs(?:Privileged)?\\s*\\(",
+  "sev": "warn",
+  "msg": "Subject.doAs is deprecated for removal together with the Security Manager. Use Subject.callAs, added in JDK 18, which takes a Callable and keeps the Subject on the current thread."
+ },
+ {
+  "id": "native_access",
+  "re": "System\\s*\\.\\s*(?:loadLibrary|load)\\s*\\(|\\bnative\\s+(?:[A-Za-z_$][\\w$<>\\[\\]\\.]*)\\s+[A-Za-z_$]",
+  "sev": "warn",
+  "msg": "Loading native code prints a warning on JDK 24+ unless the module is named in --enable-native-access (JEP 472), and that warning is planned to become an error. Add the flag or an Enable-Native-Access manifest entry now."
+ },
+ {
+  "id": "set_accessible",
+  "re": "setAccessible\\s*\\(\\s*true\\s*\\)",
+  "sev": "warn",
+  "msg": "setAccessible(true) against a java.* class throws InaccessibleObjectException under the strong encapsulation of JDK 17+ (JEP 403). Check the target is your own class, or add an explicit --add-opens for the exact package."
+ },
+ {
+  "id": "url_constructor",
+  "re": "new\\s+URL\\s*\\(",
+  "sev": "warn",
+  "msg": "The java.net.URL constructors are deprecated since JDK 20 because they accept malformed input without validating it. Use URI.create(s).toURL(), which rejects the bad string instead of carrying it."
+ },
+ {
+  "id": "wrapper_constructor",
+  "re": "new\\s+(?:Integer|Long|Double|Float|Short|Byte|Character|Boolean)\\s*\\(",
+  "sev": "warn",
+  "msg": "Primitive wrapper constructors are deprecated for removal since JDK 9. Use Integer.valueOf(x) or Integer.parseInt(s) — valueOf caches small values, the constructor allocates every time."
+ },
+ {
+  "id": "class_new_instance",
+  "re": "(?:\\.class|getClass\\(\\s*\\)|Class\\.forName\\([^)]*\\))\\s*\\.\\s*newInstance\\s*\\(\\s*\\)",
+  "sev": "warn",
+  "msg": "Class.newInstance() is deprecated since JDK 9 because it rethrows checked exceptions the compiler cannot see. Use getDeclaredConstructor().newInstance()."
+ },
+ {
+  "id": "locale_constructor",
+  "re": "new\\s+Locale\\s*\\(",
+  "sev": "warn",
+  "msg": "The java.util.Locale constructors are deprecated since JDK 19. Use Locale.of(language, country), which validates and interns the tag."
+ }
+]

readystack_jdk25_upgrade_blocker_lint-1.0.3/src/readystack_jdk25_upgrade_blocker_lint/strings.json

@@ -0,0 +1,10 @@
+{
+ "name": "JDK 25 Upgrade Blocker Lint",
+ "subtitle": "Finds the Java lines the new LTS removed — 18 rules; 23 findings in one 64-line fixture",
+ "bin": "jdk25-upgrade-blocker-lint",
+ "price": 29,
+ "free": "Lints the .java file you have open with all 18 rules, no key and no cap — the bundled 64-line fixture returns 23 findings, 15 errors and 8 warnings; the fixed copy returns 0.",
+ "paid": "Sweeps the whole workspace and writes the dated migration report file — every file, blocker, JEP and replacement — for the upgrade ticket; free for the first 7 days, then one key, commercial and CI-seat use included.",
+ "need_key": "This option needs a licence (JDK 25 Upgrade Blocker Lint).",
+ "exts": []
+}

readystack_jdk25_upgrade_blocker_lint-1.0.3/src/readystack_jdk25_upgrade_blocker_lint.egg-info/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: readystack-jdk25-upgrade-blocker-lint
+Version: 1.0.3
+Summary: Finds the Java lines the new LTS removed — 18 rules; 23 findings in one 64-line fixture
+Author-email: ReadyStack <support@getreadystack.com>
+License: Proprietary - see LICENSE.txt
+Project-URL: Homepage, https://getreadystack.com/tools/jdk25-upgrade-blocker-lint?ref=pypi
+Project-URL: Documentation, https://getreadystack.com/tools/jdk25-upgrade-blocker-lint?ref=pypi
+Project-URL: Support, https://getreadystack.com/support
+Keywords: java,jdk,migration,jakarta,linter,upgrade
+Classifier: Programming Language :: Python :: 3
+Classifier: Environment :: Console
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Dynamic: license-file
+
+# JDK 25 Upgrade Blocker Lint
+
+Finds the Java lines the new LTS removed — 18 rules; 23 findings in one 64-line fixture
+
+## Install
+
+```
+jdk25-upgrade-blocker-lint file
+```
+
+Node 18+. The same 18 rules as the VS Code extension, from a terminal or CI.
+
+## Free
+
+- Lints the .java file you have open with all 18 rules, no key and no cap — the bundled 64-line fixture returns 23 findings, 15 errors and 8 warnings; the fixed copy returns 0.
+- `--rules` lists every rule
+
+## With a licence ($29 once)
+
+- Sweeps the whole workspace and writes the dated migration report file — every file, blocker, JEP and replacement — for the upgrade ticket; free for the first 7 days, then one key, commercial and CI-seat use included.
+
+```
+@readystack/jdk25-upgrade-blocker-lint --dir ./templates --report html --out report.html
+```
+
+A Java migration consultant bills $120-$200 an hour; a two-day audit of one repo is over $2,000.
+
+## Use from an AI agent (MCP)
+
+Claude Code · Cursor · Windsurf · any MCP client - add to your MCP config:
+
+```json
+{ "mcpServers": { "jdk25-upgrade-blocker-lint": { "command": "npx", "args": ["-y", "@readystack/jdk25-upgrade-blocker-lint", "--mcp"] } } }
+```
+
+Tools: `check_text` and `check_file` (free) · `check_dir` (licence; the full sweep is free for 7 days). The agent gets every finding with the line number.
+
+## Use in CI
+
+```yaml
+- name: JDK 25 Upgrade Blocker Lint
+  run: npx -y @readystack/jdk25-upgrade-blocker-lint --dir . --ci
+```
+
+(container: `docker run --rm -v "$PWD:/work" getreadystack/jdk25-upgrade-blocker-lint --dir /work --ci`)
+
+Try the full run free for 7 days — no key needed. Then one licence, 7-day refund, no questions. Set `READYSTACK_LICENSE=<key>` or run `--license <key>` once.
+
+[Get a licence](https://buy.polar.sh/polar_cl_YK2CXL7Hd4TEoxQ76oOVQpVAsrLK9zUpcK7oV2MKwJs)
+
+
+<!-- jdk25 upgrade blocker lint -->
+
+
+## Install (PyPI)
+
+```
+pip install readystack-jdk25-upgrade-blocker-lint
+jdk25-upgrade-blocker-lint --help
+```

readystack_jdk25_upgrade_blocker_lint-1.0.3/src/readystack_jdk25_upgrade_blocker_lint.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE.txt
+README.md
+pyproject.toml
+src/readystack_jdk25_upgrade_blocker_lint/__init__.py
+src/readystack_jdk25_upgrade_blocker_lint/cli.py
+src/readystack_jdk25_upgrade_blocker_lint/engine.py
+src/readystack_jdk25_upgrade_blocker_lint/license.py
+src/readystack_jdk25_upgrade_blocker_lint/rules.json
+src/readystack_jdk25_upgrade_blocker_lint/strings.json
+src/readystack_jdk25_upgrade_blocker_lint.egg-info/PKG-INFO
+src/readystack_jdk25_upgrade_blocker_lint.egg-info/SOURCES.txt
+src/readystack_jdk25_upgrade_blocker_lint.egg-info/dependency_links.txt
+src/readystack_jdk25_upgrade_blocker_lint.egg-info/entry_points.txt
+src/readystack_jdk25_upgrade_blocker_lint.egg-info/top_level.txt

readystack_jdk25_upgrade_blocker_lint-1.0.3/src/readystack_jdk25_upgrade_blocker_lint.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

readystack_jdk25_upgrade_blocker_lint-1.0.3/src/readystack_jdk25_upgrade_blocker_lint.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+jdk25-upgrade-blocker-lint = readystack_jdk25_upgrade_blocker_lint.cli:main

readystack_jdk25_upgrade_blocker_lint-1.0.3/src/readystack_jdk25_upgrade_blocker_lint.egg-info/top_level.txt

@@ -0,0 +1 @@
+readystack_jdk25_upgrade_blocker_lint