Files
ECC/tests/scripts/instinct-cli-python-compat.test.js
T
montjeffrey e41a4a0492 feat(clv2): tell instinct-cli users on an end-of-life Python to upgrade
instinct-cli keeps running on old interpreters, but people on one should
know they no longer get security fixes. On a Python older than 3.11 (3.10
reached end of life in October 2026) the CLI now prints one line to
stderr after parsing its arguments:

  [instinct-cli] Python 3.8 is past end of life. instinct-cli still runs
  on it; upgrade to Python 3.11 or newer for security fixes.

The command itself runs as before. The notice stays out of automated
output: `prune --quiet`, which observer-loop.sh runs, skips it, and
CLV2_SKIP_PYTHON_EOL_NOTICE=1 turns it off for anyone who keeps an old
Python on purpose. The threshold is one constant, _SUPPORTED_PYTHON, to
raise as versions age out. Importing the module prints nothing.
2026-11-04 11:30:07 -05:00

267 lines
8.8 KiB
JavaScript

/**
* Tests that instinct-cli.py keeps running on old and new Pythons.
*
* The CLI supports Python 3.6 and newer, but CI runs a current Python, so a
* newer-only construct would not fail anywhere until a user on an old
* interpreter hit it. The static check below parses the script with the 3.6
* grammar and rejects the runtime constructs a grammar check cannot see:
* unquoted builtin generics in evaluated annotations and newer-only APIs.
* The other cases run the CLI under the strictest warning settings of the
* current Python and cover the end-of-life notice.
*
* Run with: node tests/scripts/instinct-cli-python-compat.test.js
*/
const assert = require('assert');
const fs = require('fs');
const os = require('os');
const path = require('path');
const { spawnSync } = require('child_process');
let passed = 0;
let failed = 0;
const repoRoot = path.resolve(__dirname, '..', '..');
const cliPath = path.join(
repoRoot,
'skills',
'continuous-learning-v2',
'scripts',
'instinct-cli.py'
);
function detectPython3() {
for (const bin of ['python3', 'python']) {
const r = spawnSync(bin, ['--version'], { encoding: 'utf8' });
if (r.status === 0 && /Python 3\.(\d+)/.test(r.stdout + r.stderr)) return bin;
}
return null;
}
const PYTHON3 = detectPython3();
if (!PYTHON3) {
console.log('\n=== Testing instinct-cli.py Python compatibility ===\n');
console.log(' - skipped: Python 3 not found in PATH');
console.log('\nPassed: 0');
console.log('Failed: 0');
process.exit(0);
}
function test(name, fn) {
try {
fn();
console.log(` ✓ ${name}`);
passed += 1;
} catch (error) {
console.log(` ✗ ${name}`);
console.log(` Error: ${error.message}`);
failed += 1;
}
}
function createTempDir() {
return fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-instinct-cli-compat-'));
}
function cleanupDir(dir) {
fs.rmSync(dir, { recursive: true, force: true });
}
function runPython(args, options = {}) {
return spawnSync(PYTHON3, args, {
encoding: 'utf8',
timeout: 60000,
...options,
env: { ...process.env, ...(options.env || {}) },
});
}
// Prints one line per construct that would break on Python 3.6.
const COMPAT_CHECK = String.raw`
import ast, sys
path = sys.argv[1]
src = open(path, encoding="utf-8").read()
problems = []
try:
tree = ast.parse(src, filename=path, feature_version=(3, 6))
except SyntaxError as exc:
print("syntax newer than 3.6 at line %s: %s" % (exc.lineno, exc.msg))
sys.exit(0)
BUILTIN_GENERICS = {"list", "dict", "set", "tuple", "type", "frozenset"}
NEWER_METHODS = {"removeprefix", "removesuffix", "is_relative_to", "with_stem"}
# Keywords newer than 3.6, keyed by the callable they belong to.
NEWER_KEYWORDS = {
"run": {"capture_output", "text"},
"Popen": {"text"},
"check_output": {"text"},
"copytree": {"dirs_exist_ok"},
"unlink": {"missing_ok"},
"zip": {"strict"},
}
def call_name(func):
if isinstance(func, ast.Attribute):
return func.attr
if isinstance(func, ast.Name):
return func.id
return ""
def check_annotation(node, where):
if node is None:
return
for sub in ast.walk(node):
if (isinstance(sub, ast.Subscript) and isinstance(sub.value, ast.Name)
and sub.value.id in BUILTIN_GENERICS):
problems.append("line %d: unquoted %s[...] annotation in %s" % (sub.lineno, sub.value.id, where))
for node in ast.walk(tree):
if isinstance(node, ast.ImportFrom) and node.module == "__future__":
for alias in node.names:
if alias.name == "annotations":
problems.append("line %d: from __future__ import annotations needs 3.7" % node.lineno)
if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
all_args = getattr(node.args, "posonlyargs", []) + node.args.args + node.args.kwonlyargs
for extra in (node.args.vararg, node.args.kwarg):
if extra is not None:
all_args.append(extra)
for arg in all_args:
check_annotation(arg.annotation, node.name)
check_annotation(node.returns, node.name)
if isinstance(node, ast.AnnAssign):
check_annotation(node.annotation, "a variable annotation")
if isinstance(node, ast.Attribute) and node.attr in NEWER_METHODS:
problems.append("line %d: .%s() is newer than 3.6" % (node.lineno, node.attr))
if isinstance(node, ast.Call):
newer = NEWER_KEYWORDS.get(call_name(node.func), set())
for kw in node.keywords:
if kw.arg in newer:
problems.append("line %d: keyword %s= is newer than 3.6" % (node.lineno, kw.arg))
for problem in problems:
print(problem)
`;
function loadAndCall(body, env = {}) {
const code = [
'import argparse, importlib.util, sys',
`spec = importlib.util.spec_from_file_location('icli', ${JSON.stringify(cliPath)})`,
'm = importlib.util.module_from_spec(spec)',
'spec.loader.exec_module(m)',
body,
].join('\n');
const tmp = createTempDir();
try {
const r = runPython(['-c', code], {
env: { CLV2_HOMUNCULUS_DIR: path.join(tmp, 'homunculus'), ...env },
});
if (r.status !== 0) {
throw new Error(`python exited ${r.status}: ${r.stderr || r.error}`);
}
return r;
} finally {
cleanupDir(tmp);
}
}
console.log('\n=== Testing instinct-cli.py Python compatibility ===\n');
test('the script uses nothing newer than Python 3.6', () => {
const r = runPython(['-c', COMPAT_CHECK, cliPath]);
assert.strictEqual(r.status, 0, r.stderr);
assert.strictEqual(r.stdout.trim(), '', `3.6-incompatible constructs:\n${r.stdout}`);
});
test('the compatibility check catches what it is meant to catch', () => {
const tmp = createTempDir();
try {
const sample = path.join(tmp, 'sample.py');
fs.writeFileSync(
sample,
[
'import subprocess',
'def f(x: list[str]) -> dict[str, int]:',
' subprocess.run(["git"], capture_output=True, text=True)',
' return x[0].removeprefix("a")',
'',
].join('\n')
);
const r = runPython(['-c', COMPAT_CHECK, sample]);
assert.strictEqual(r.status, 0, r.stderr);
for (const expected of ['list[...]', 'dict[...]', 'capture_output=', 'text=', '.removeprefix()']) {
assert.ok(r.stdout.includes(expected), `missing ${expected} in:\n${r.stdout}`);
}
} finally {
cleanupDir(tmp);
}
});
test('commands run with every warning turned into an error', () => {
const tmp = createTempDir();
try {
const projectDir = path.join(tmp, 'repo');
fs.mkdirSync(projectDir, { recursive: true });
const init = spawnSync('git', ['init', '-q'], { cwd: projectDir, encoding: 'utf8' });
assert.strictEqual(init.status, 0, init.stderr);
const env = {
CLV2_HOMUNCULUS_DIR: path.join(tmp, 'homunculus'),
CLAUDE_PROJECT_DIR: projectDir,
CLV2_SKIP_PYTHON_EOL_NOTICE: '1',
};
const sample = path.join(repoRoot, '.claude', 'homunculus', 'instincts', 'inherited', 'ecc-instincts.yaml');
const strict = ['-X', 'dev', '-X', 'warn_default_encoding', '-W', 'error', cliPath];
const commands = [
['import', sample, '--force', '--scope', 'global'],
['status'],
['export', '--output', path.join(tmp, 'export.yaml')],
['evolve'],
['projects'],
['prune', '--dry-run'],
];
for (const command of commands) {
const r = runPython([...strict, ...command], { cwd: projectDir, env });
assert.strictEqual(r.status, 0, `${command.join(' ')} exited ${r.status}:\n${r.stderr}`);
}
} finally {
cleanupDir(tmp);
}
});
test('an end-of-life Python gets a one-line notice on stderr', () => {
const r = loadAndCall(
"m._SUPPORTED_PYTHON = (99, 0)\nm._warn_if_python_eol(argparse.Namespace(command='status'))",
{ CLV2_SKIP_PYTHON_EOL_NOTICE: '' }
);
assert.strictEqual(r.stdout, '');
const lines = r.stderr.trim().split(/\r?\n/);
assert.strictEqual(lines.length, 1, r.stderr);
assert.match(lines[0], /^\[instinct-cli\] Python 3\.\d+ is past end of life\. .*99\.0 or newer/);
});
test('the notice stays quiet for --quiet, the opt-out and a supported Python', () => {
const quiet = loadAndCall(
"m._SUPPORTED_PYTHON = (99, 0)\nm._warn_if_python_eol(argparse.Namespace(command='prune', quiet=True))",
{ CLV2_SKIP_PYTHON_EOL_NOTICE: '' }
);
assert.strictEqual(quiet.stderr, '');
const optedOut = loadAndCall(
"m._SUPPORTED_PYTHON = (99, 0)\nm._warn_if_python_eol(argparse.Namespace(command='status'))",
{ CLV2_SKIP_PYTHON_EOL_NOTICE: '1' }
);
assert.strictEqual(optedOut.stderr, '');
const supported = loadAndCall(
"m._SUPPORTED_PYTHON = (3, 0)\nm._warn_if_python_eol(argparse.Namespace(command='status'))",
{ CLV2_SKIP_PYTHON_EOL_NOTICE: '' }
);
assert.strictEqual(supported.stderr, '');
});
console.log(`\nPassed: ${passed}`);
console.log(`Failed: ${failed}`);
process.exit(failed > 0 ? 1 : 0);