oh-my-codex 0.10.2 → 0.10.3

package/scripts/__tests__/smoke-packed-install.test.mjs

@@ -4,29 +4,42 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { test } from 'node:test';
 import {
+  ensureRepoDependencies,
+  hasSparkShellFallbackBanner,
+  hasUsableNodeModules,
   prepareLocalHydrationAssetDirectory,
+  resolveGitCommonDir,
+  resolveReusableNodeModulesSource,
   rewriteManifestDownloadUrls,
 } from '../smoke-packed-install.mjs';
 
+test('detects the sparkshell GLIBC fallback banner', () => {
+  assert.equal(
+    hasSparkShellFallbackBanner('[sparkshell] GLIBC-incompatible native sidecar detected; falling back to raw command execution without summary support.\n'),
+    true,
+  );
+  assert.equal(hasSparkShellFallbackBanner('node v20.0.0\n'), false);
+});
+
 test('rewrites copied native manifest download urls to the local smoke server', async () => {
   const root = await mkdtemp(join(tmpdir(), 'omx-smoke-packed-install-'));
   try {
     const sourceDir = join(root, 'source-release-assets');
     await mkdir(sourceDir, { recursive: true });
-    await writeFile(join(sourceDir, 'omx-explore-harness-x86_64-unknown-linux-gnu.tar.xz'), 'explore');
-    await writeFile(join(sourceDir, 'omx-sparkshell-x86_64-unknown-linux-gnu.tar.xz'), 'sparkshell');
+    await writeFile(join(sourceDir, 'omx-explore-harness-x86_64-unknown-linux-musl.tar.xz'), 'explore');
+    await writeFile(join(sourceDir, 'omx-sparkshell-x86_64-unknown-linux-musl.tar.xz'), 'sparkshell');
     await writeFile(join(sourceDir, 'native-release-manifest.json'), JSON.stringify({
       version: '0.9.0',
       assets: [
         {
           product: 'omx-explore-harness',
-          archive: 'omx-explore-harness-x86_64-unknown-linux-gnu.tar.xz',
-          download_url: 'https://github.com/example/omx-explore-harness-x86_64-unknown-linux-gnu.tar.xz',
+          archive: 'omx-explore-harness-x86_64-unknown-linux-musl.tar.xz',
+          download_url: 'https://github.com/example/omx-explore-harness-x86_64-unknown-linux-musl.tar.xz',
         },
         {
           product: 'omx-sparkshell',
-          archive: 'omx-sparkshell-x86_64-unknown-linux-gnu.tar.xz',
-          download_url: 'https://github.com/example/omx-sparkshell-x86_64-unknown-linux-gnu.tar.xz',
+          archive: 'omx-sparkshell-x86_64-unknown-linux-musl.tar.xz',
+          download_url: 'https://github.com/example/omx-sparkshell-x86_64-unknown-linux-musl.tar.xz',
         },
       ],
     }, null, 2));
@@ -41,11 +54,127 @@ test('rewrites copied native manifest download urls to the local smoke server',
     assert.deepEqual(
       copiedManifest.assets.map((asset) => asset.download_url),
       [
-        'http://127.0.0.1:43123/omx-explore-harness-x86_64-unknown-linux-gnu.tar.xz',
-        'http://127.0.0.1:43123/omx-sparkshell-x86_64-unknown-linux-gnu.tar.xz',
+        'http://127.0.0.1:43123/omx-explore-harness-x86_64-unknown-linux-musl.tar.xz',
+        'http://127.0.0.1:43123/omx-sparkshell-x86_64-unknown-linux-musl.tar.xz',
       ],
     );
   } finally {
     await rm(root, { recursive: true, force: true });
   }
 });
+
+test('resolveGitCommonDir resolves relative git common dir output against the repo root', () => {
+  const commonDir = resolveGitCommonDir('/tmp/worktree', () => ({
+    status: 0,
+    stdout: '../primary/.git\n',
+    stderr: '',
+  }));
+  assert.equal(commonDir, '/tmp/primary/.git');
+});
+
+test('hasUsableNodeModules requires the packaged build dependencies', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'omx-smoke-node-modules-'));
+  try {
+    const nodeModules = join(root, 'node_modules');
+    await mkdir(join(nodeModules, 'typescript'), { recursive: true });
+    await mkdir(join(nodeModules, '@iarna', 'toml'), { recursive: true });
+    await mkdir(join(nodeModules, '@modelcontextprotocol', 'sdk'), { recursive: true });
+    await mkdir(join(nodeModules, 'zod'), { recursive: true });
+    await writeFile(join(nodeModules, 'typescript', 'package.json'), '{}');
+    await writeFile(join(nodeModules, '@iarna', 'toml', 'package.json'), '{}');
+    await writeFile(join(nodeModules, '@modelcontextprotocol', 'sdk', 'package.json'), '{}');
+    await writeFile(join(nodeModules, 'zod', 'package.json'), '{}');
+
+    assert.equal(hasUsableNodeModules(root), true);
+
+    await rm(join(nodeModules, 'zod', 'package.json'));
+    assert.equal(hasUsableNodeModules(root), false);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('resolveReusableNodeModulesSource reuses primary worktree node_modules when available', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'omx-smoke-reuse-node-modules-'));
+  try {
+    const primaryRepo = join(root, 'primary');
+    const worktreeRepo = join(root, 'worktree');
+    await mkdir(join(primaryRepo, 'node_modules', 'typescript'), { recursive: true });
+    await mkdir(join(primaryRepo, 'node_modules', '@iarna', 'toml'), { recursive: true });
+    await mkdir(join(primaryRepo, 'node_modules', '@modelcontextprotocol', 'sdk'), { recursive: true });
+    await mkdir(join(primaryRepo, 'node_modules', 'zod'), { recursive: true });
+    await writeFile(join(primaryRepo, 'node_modules', 'typescript', 'package.json'), '{}');
+    await writeFile(join(primaryRepo, 'node_modules', '@iarna', 'toml', 'package.json'), '{}');
+    await writeFile(join(primaryRepo, 'node_modules', '@modelcontextprotocol', 'sdk', 'package.json'), '{}');
+    await writeFile(join(primaryRepo, 'node_modules', 'zod', 'package.json'), '{}');
+    await mkdir(worktreeRepo, { recursive: true });
+
+    const reusable = resolveReusableNodeModulesSource(worktreeRepo, () => ({
+      status: 0,
+      stdout: `${join(primaryRepo, '.git')}\n`,
+      stderr: '',
+    }));
+
+    assert.equal(reusable, join(primaryRepo, 'node_modules'));
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('ensureRepoDependencies symlinks a reusable primary worktree node_modules', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'omx-smoke-symlink-node-modules-'));
+  try {
+    const primaryRepo = join(root, 'primary');
+    const worktreeRepo = join(root, 'worktree');
+    await mkdir(join(primaryRepo, 'node_modules', 'typescript'), { recursive: true });
+    await mkdir(join(primaryRepo, 'node_modules', '@iarna', 'toml'), { recursive: true });
+    await mkdir(join(primaryRepo, 'node_modules', '@modelcontextprotocol', 'sdk'), { recursive: true });
+    await mkdir(join(primaryRepo, 'node_modules', 'zod'), { recursive: true });
+    await writeFile(join(primaryRepo, 'node_modules', 'typescript', 'package.json'), '{}');
+    await writeFile(join(primaryRepo, 'node_modules', '@iarna', 'toml', 'package.json'), '{}');
+    await writeFile(join(primaryRepo, 'node_modules', '@modelcontextprotocol', 'sdk', 'package.json'), '{}');
+    await writeFile(join(primaryRepo, 'node_modules', 'zod', 'package.json'), '{}');
+    await mkdir(worktreeRepo, { recursive: true });
+
+    const events = [];
+    const result = ensureRepoDependencies(worktreeRepo, {
+      gitRunner: () => ({
+        status: 0,
+        stdout: `${join(primaryRepo, '.git')}\n`,
+        stderr: '',
+      }),
+      install: () => {
+        throw new Error('install should not be called when a reusable node_modules source exists');
+      },
+      log: (message) => events.push(message),
+    });
+
+    assert.equal(result.strategy, 'symlink');
+    assert.equal(result.sourceNodeModulesPath, join(primaryRepo, 'node_modules'));
+    assert.equal(events[0], `[smoke:packed-install] Reusing node_modules from ${join(primaryRepo, 'node_modules')}`);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('ensureRepoDependencies falls back to npm ci when no reusable node_modules source exists', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'omx-smoke-install-node-modules-'));
+  try {
+    const installs = [];
+    const result = ensureRepoDependencies(root, {
+      gitRunner: () => ({
+        status: 1,
+        stdout: '',
+        stderr: 'not a worktree',
+      }),
+      install: (cwd) => {
+        installs.push(cwd);
+      },
+    });
+
+    assert.equal(result.strategy, 'installed');
+    assert.deepEqual(installs, [root]);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});

package/scripts/eval-adaptive-sort-optimization.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+
+result = subprocess.run(
+    [sys.executable, 'playground/adaptive_sort_demo/sort_benchmark.py'],
+    check=False,
+    capture_output=True,
+    text=True,
+)
+if result.stdout:
+    sys.stderr.write(result.stdout)
+if result.stderr:
+    sys.stderr.write(result.stderr)
+if result.returncode != 0:
+    print(json.dumps({'pass': False, 'score': 0.0}))
+    raise SystemExit(result.returncode)
+
+payload = json.loads(result.stdout)
+total_cost = float(payload['total_cost'])
+score = 10000.0 / total_cost
+print(json.dumps({'pass': total_cost > 0, 'score': score}))

package/scripts/eval-in-action-cat-shellout-demo.js

@@ -0,0 +1,31 @@
+import { readFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+
+const source = readFileSync('src/cli/autoresearch.ts', 'utf-8');
+const stillUsesCatShellout = /execFileSync\('cat',\s*\[runtime\.manifestFile\]/.test(source);
+
+if (stillUsesCatShellout) {
+  process.stderr.write('Evaluator: src/cli/autoresearch.ts still shells out to cat for the manifest.\n');
+  process.stdout.write(JSON.stringify({ pass: false, score: 0 }));
+  process.exit(1);
+}
+
+const build = spawnSync('npm', ['run', 'build'], { encoding: 'utf-8' });
+if (build.stdout) process.stderr.write(build.stdout);
+if (build.stderr) process.stderr.write(build.stderr);
+if (build.status !== 0) {
+  process.stdout.write(JSON.stringify({ pass: false, score: 0 }));
+  process.exit(build.status ?? 1);
+}
+
+const test = spawnSync('node', [
+  '--test',
+  'dist/cli/__tests__/autoresearch.test.js',
+  'dist/autoresearch/__tests__/runtime.test.js',
+], { encoding: 'utf-8' });
+if (test.stdout) process.stderr.write(test.stdout);
+if (test.stderr) process.stderr.write(test.stderr);
+
+const pass = test.status === 0;
+process.stdout.write(JSON.stringify({ pass, score: pass ? 1 : 0 }));
+process.exit(test.status ?? 1);

package/scripts/eval-ml-kaggle-model-optimization.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+
+result = subprocess.run(
+    [sys.executable, "playground/ml_kaggle_demo/train.py"],
+    check=False,
+    capture_output=True,
+    text=True,
+)
+
+if result.stdout:
+    sys.stderr.write(result.stdout)
+if result.stderr:
+    sys.stderr.write(result.stderr)
+
+if result.returncode != 0:
+    print(json.dumps({"pass": False, "score": 0.0}))
+    raise SystemExit(result.returncode)
+
+metrics = json.loads(result.stdout)
+auc = float(metrics["roc_auc"])
+
+# Baseline should pass, but score_improvement should still reward better architectures.
+passed = auc >= 0.90
+print(json.dumps({"pass": passed, "score": auc}))
+raise SystemExit(0 if passed else 1)

package/scripts/eval-noisy-bayesopt-highdim.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+CONFIG_PATH = Path('playground/bayesopt_highdim_demo/config.json')
+SEEDS = (17, 29, 43)
+
+
+def run_for_seed(seed: int) -> dict:
+    config = json.loads(CONFIG_PATH.read_text())
+    config['seed'] = seed
+    tmp_path = Path('.omx') / 'tmp' / f'noisy-bayesopt-seed-{seed}.json'
+    tmp_path.parent.mkdir(parents=True, exist_ok=True)
+    tmp_path.write_text(json.dumps(config))
+
+    result = subprocess.run(
+        [sys.executable, 'playground/bayesopt_highdim_demo/run_search.py', '--config', str(tmp_path)],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if result.stdout:
+        sys.stderr.write(result.stdout)
+    if result.stderr:
+        sys.stderr.write(result.stderr)
+    if result.returncode != 0:
+        raise SystemExit(result.returncode)
+    return json.loads(result.stdout)
+
+
+def main() -> None:
+    rows = [run_for_seed(seed) for seed in SEEDS]
+    means = [float(row['best_mean']) for row in rows]
+    overall_mean = sum(means) / len(means)
+    variance_penalty = (max(means) - min(means)) * 0.15
+    score = overall_mean - variance_penalty
+    print(json.dumps({'pass': score >= 1.15, 'score': score}))
+
+
+if __name__ == '__main__':
+    main()

package/scripts/eval-noisy-latent-subspace-discovery.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+CONFIG_PATH = Path('playground/bayesopt_latent_discovery_demo/config.json')
+SEEDS = (23, 41, 59)
+
+
+def run_for_seed(seed: int) -> dict:
+    config = json.loads(CONFIG_PATH.read_text())
+    config['seed'] = seed
+    tmp_path = Path('.omx') / 'tmp' / f'latent-discovery-seed-{seed}.json'
+    tmp_path.parent.mkdir(parents=True, exist_ok=True)
+    tmp_path.write_text(json.dumps(config))
+
+    result = subprocess.run(
+        [sys.executable, 'playground/bayesopt_latent_discovery_demo/run_search.py', '--config', str(tmp_path)],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if result.stdout:
+        sys.stderr.write(result.stdout)
+    if result.stderr:
+        sys.stderr.write(result.stderr)
+    if result.returncode != 0:
+        raise SystemExit(result.returncode)
+    return json.loads(result.stdout)
+
+
+def main() -> None:
+    rows = [run_for_seed(seed) for seed in SEEDS]
+    means = [float(row['best_mean']) for row in rows]
+    overall_mean = sum(means) / len(means)
+    variance_penalty = (max(means) - min(means)) * 0.18
+    score = overall_mean - variance_penalty
+    print(json.dumps({'pass': score >= 1.4, 'score': score}))
+
+
+if __name__ == '__main__':
+    main()

package/scripts/generate-native-release-manifest.mjs

@@ -29,8 +29,10 @@ function parseChecksum(raw) {
 
 function mapTriple(triple) {
   switch (triple) {
-    case 'x86_64-unknown-linux-gnu': return { platform: 'linux', arch: 'x64' };
-    case 'aarch64-unknown-linux-gnu': return { platform: 'linux', arch: 'arm64' };
+    case 'x86_64-unknown-linux-gnu': return { platform: 'linux', arch: 'x64', libc: 'glibc' };
+    case 'aarch64-unknown-linux-gnu': return { platform: 'linux', arch: 'arm64', libc: 'glibc' };
+    case 'x86_64-unknown-linux-musl': return { platform: 'linux', arch: 'x64', libc: 'musl' };
+    case 'aarch64-unknown-linux-musl': return { platform: 'linux', arch: 'arm64', libc: 'musl' };
     case 'x86_64-apple-darwin': return { platform: 'darwin', arch: 'x64' };
     case 'aarch64-apple-darwin': return { platform: 'darwin', arch: 'arm64' };
     case 'x86_64-pc-windows-msvc': return { platform: 'win32', arch: 'x64' };
@@ -71,6 +73,8 @@ for (const artifact of Object.values(plan.artifacts)) {
     version,
     platform: mapped.platform,
     arch: mapped.arch,
+    target: triple,
+    ...(mapped.libc ? { libc: mapped.libc } : {}),
     archive: artifact.name,
     binary: executable.name,
     binary_path: executable.path,
@@ -85,7 +89,14 @@ const manifest = {
   version: plan.announcement_tag.replace(/^v/, ''),
   tag: plan.announcement_tag,
   generated_at: new Date().toISOString(),
-  assets: assets.sort((a, b) => `${a.product}-${a.platform}-${a.arch}`.localeCompare(`${b.product}-${b.platform}-${b.arch}`)),
+  assets: assets.sort((a, b) => {
+    const keyCompare = `${a.product}-${a.platform}-${a.arch}`.localeCompare(`${b.product}-${b.platform}-${b.arch}`);
+    if (keyCompare !== 0) return keyCompare;
+    const libcOrder = { musl: 0, glibc: 1 };
+    const libcCompare = (libcOrder[a.libc] ?? 2) - (libcOrder[b.libc] ?? 2);
+    if (libcCompare !== 0) return libcCompare;
+    return a.archive.localeCompare(b.archive);
+  }),
 };
 for (const product of requireProducts) {
   if (!manifest.assets.some((asset) => asset.product === product)) {