oh-my-codex 0.14.4 → 0.15.1

package/src/scripts/postinstall.ts

@@ -1,5 +1,5 @@
 import { readFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
+import { join } from "node:path";
 import { pathToFileURL } from "node:url";
 import {
   isInstallVersionBump,
@@ -7,16 +7,13 @@ import {
   type UserInstallStamp,
   writeUserInstallStamp,
 } from "../cli/update.js";
-import { setup } from "../cli/setup.js";
 import { getPackageRoot } from "../utils/package.js";
 
 type PostinstallStatus =
   | "noop-local"
   | "noop-same-version"
   | "noop-missing-version"
-  | "hinted"
-  | "setup-ran"
-  | "setup-failed";
+  | "hinted";
 
 export interface PostinstallResult {
   status: PostinstallStatus;
@@ -26,11 +23,8 @@ export interface PostinstallResult {
 interface PostinstallDependencies {
   env: NodeJS.ProcessEnv;
   getCurrentVersion: () => Promise<string | null>;
-  isInteractive: () => boolean;
   log: (message: string) => void;
   readStamp: () => Promise<UserInstallStamp | null>;
-  runSetup: typeof setup;
-  warn: (message: string) => void;
   writeStamp: (stamp: UserInstallStamp) => Promise<void>;
 }
 
@@ -46,29 +40,6 @@ export function isGlobalInstallLifecycle(env: NodeJS.ProcessEnv = process.env):
   return isTruthyEnv(env.npm_config_global) || env.npm_config_location === "global";
 }
 
-function resolveInstallRoot(env: NodeJS.ProcessEnv): string {
-  const installPrefix = env.npm_config_prefix?.trim() || env.npm_config_local_prefix?.trim();
-  return installPrefix ? resolve(installPrefix) : process.cwd();
-}
-
-async function runSetupFromInstallRoot(
-  runSetup: typeof setup,
-  installRoot: string,
-): Promise<void> {
-  const previousCwd = process.cwd();
-  if (previousCwd === installRoot) {
-    await runSetup();
-    return;
-  }
-
-  process.chdir(installRoot);
-  try {
-    await runSetup();
-  } finally {
-    process.chdir(previousCwd);
-  }
-}
-
 async function getCurrentVersion(): Promise<string | null> {
   try {
     const packageJsonPath = join(getPackageRoot(), "package.json");
@@ -83,11 +54,8 @@ async function getCurrentVersion(): Promise<string | null> {
 const defaultDependencies: PostinstallDependencies = {
   env: process.env,
   getCurrentVersion,
-  isInteractive: () => Boolean(process.stdin.isTTY && process.stdout.isTTY),
   log: (message) => console.log(message),
   readStamp: () => readUserInstallStamp(),
-  runSetup: setup,
-  warn: (message) => console.warn(message),
   writeStamp: (stamp) => writeUserInstallStamp(stamp),
 };
 
@@ -120,32 +88,10 @@ export async function runPostinstall(
     updated_at: new Date().toISOString(),
   });
 
-  if (!resolved.isInteractive()) {
-    resolved.log(
-      `[omx] Installed oh-my-codex v${currentStampVersion}. Run \`omx setup\` (interactive) or \`omx update\` when you're ready.`,
-    );
-    return { status: "hinted", version: currentStampVersion };
-  }
-
   resolved.log(
-    `[omx] Detected oh-my-codex v${currentStampVersion} install/update. Launching interactive setup...`,
+    `[omx] Installed oh-my-codex v${currentStampVersion}. OMX setup is explicit opt-in; run \`omx setup\` or \`omx update\` when you're ready.`,
   );
-
-  try {
-    await runSetupFromInstallRoot(resolved.runSetup, resolveInstallRoot(env));
-    await resolved.writeStamp({
-      installed_version: currentStampVersion,
-      setup_completed_version: currentStampVersion,
-      updated_at: new Date().toISOString(),
-    });
-    resolved.log(`[omx] Setup refresh completed for v${currentStampVersion}.`);
-    return { status: "setup-ran", version: currentStampVersion };
-  } catch (error) {
-    resolved.warn(
-      `[omx] Postinstall setup skipped after a non-fatal error: ${error instanceof Error ? error.message : String(error)}`,
-    );
-    return { status: "setup-failed", version: currentStampVersion };
-  }
+  return { status: "hinted", version: currentStampVersion };
 }
 
 export async function main(): Promise<void> {

package/src/scripts/prompt-inventory.ts

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+
+export interface PromptSurfaceInventory {
+  path: string;
+  lines: number;
+  approximateTokens: number;
+  absoluteDirectiveCount: number;
+  markers: Record<string, number>;
+}
+
+export interface DuplicateFragmentFamily {
+  text: string;
+  count: number;
+  paths: string[];
+}
+
+export interface PromptInventoryReport {
+  generatedAt: string;
+  root: string;
+  totals: {
+    files: number;
+    lines: number;
+    approximateTokens: number;
+    absoluteDirectiveCount: number;
+  };
+  surfaces: PromptSurfaceInventory[];
+  duplicateFragmentFamilies: DuplicateFragmentFamily[];
+}
+
+const PROMPT_SURFACE_FILES = [
+  'AGENTS.md',
+  'templates/AGENTS.md',
+  'docs/prompt-guidance-contract.md',
+  'docs/guidance-schema.md',
+  'src/hooks/prompt-guidance-contract.ts',
+  'src/config/generator.ts',
+  'src/cli/setup.ts',
+];
+
+const PROMPT_SURFACE_DIRS = [
+  'prompts',
+  'skills',
+  'templates/model-instructions',
+  'docs/prompt-guidance-fragments',
+];
+
+const MARKERS = [
+  '<!-- OMX:RUNTIME:START -->',
+  '<!-- OMX:RUNTIME:END -->',
+  '<!-- OMX:TEAM:WORKER:START -->',
+  '<!-- OMX:TEAM:WORKER:END -->',
+  '<!-- OMX:MODELS:START -->',
+  '<!-- OMX:MODELS:END -->',
+  '<!-- omx:generated:agents-md -->',
+];
+
+const ABSOLUTE_DIRECTIVE_PATTERN = /\b(MUST(?:\s+NOT)?|DO NOT|DON'T|NEVER|ALWAYS|REQUIRED|REQUIRE|ONLY|STOP|ASK only|AUTO-CONTINUE|KEEP GOING)\b/i;
+
+function walkFiles(root: string, dir: string, out: string[]): void {
+  const absoluteDir = join(root, dir);
+  if (!existsSync(absoluteDir)) return;
+  for (const entry of readdirSync(absoluteDir)) {
+    const rel = join(dir, entry);
+    const absolute = join(root, rel);
+    const stats = statSync(absolute);
+    if (stats.isDirectory()) {
+      walkFiles(root, rel, out);
+      continue;
+    }
+    if (stats.isFile() && /\.(md|ts)$/.test(entry)) {
+      out.push(rel);
+    }
+  }
+}
+
+export function listPromptSurfacePaths(root = process.cwd()): string[] {
+  const paths = new Set<string>();
+  for (const file of PROMPT_SURFACE_FILES) {
+    if (existsSync(join(root, file))) paths.add(file);
+  }
+
+  const walked: string[] = [];
+  for (const dir of PROMPT_SURFACE_DIRS) walkFiles(root, dir, walked);
+  for (const path of walked) paths.add(path);
+
+  return [...paths].sort();
+}
+
+function countOccurrences(text: string, needle: string): number {
+  let count = 0;
+  let index = text.indexOf(needle);
+  while (index !== -1) {
+    count += 1;
+    index = text.indexOf(needle, index + needle.length);
+  }
+  return count;
+}
+
+function approximateTokenCount(text: string): number {
+  return text.match(/[\p{L}\p{N}_'-]+|[^\s]/gu)?.length ?? 0;
+}
+
+function countAbsoluteDirectives(text: string): number {
+  return text
+    .split(/\r?\n/)
+    .filter((line) => ABSOLUTE_DIRECTIVE_PATTERN.test(line))
+    .length;
+}
+
+function inventorySurface(root: string, path: string): PromptSurfaceInventory {
+  const text = readFileSync(join(root, path), 'utf-8');
+  const markers = Object.fromEntries(MARKERS.map((marker) => [marker, countOccurrences(text, marker)]));
+  return {
+    path,
+    lines: text.length === 0 ? 0 : text.split(/\r?\n/).length,
+    approximateTokens: approximateTokenCount(text),
+    absoluteDirectiveCount: countAbsoluteDirectives(text),
+    markers,
+  };
+}
+
+function normalizeFragmentLine(line: string): string | null {
+  const normalized = line.replace(/\s+/g, ' ').trim();
+  if (normalized.length < 60) return null;
+  if (/^[-*#>|`]+$/.test(normalized)) return null;
+  return normalized;
+}
+
+function duplicateFragmentFamilies(root: string, paths: string[]): DuplicateFragmentFamily[] {
+  const occurrences = new Map<string, Set<string>>();
+  for (const path of paths) {
+    const text = readFileSync(join(root, path), 'utf-8');
+    for (const line of text.split(/\r?\n/)) {
+      const normalized = normalizeFragmentLine(line);
+      if (!normalized) continue;
+      const pathsWithLine = occurrences.get(normalized) ?? new Set<string>();
+      pathsWithLine.add(path);
+      occurrences.set(normalized, pathsWithLine);
+    }
+  }
+
+  return [...occurrences.entries()]
+    .map(([text, pathSet]) => ({ text, count: pathSet.size, paths: [...pathSet].sort() }))
+    .filter((family) => family.count > 1)
+    .sort((a, b) => b.count - a.count || a.text.localeCompare(b.text))
+    .slice(0, 50);
+}
+
+export function buildPromptInventory(root = process.cwd(), generatedAt = new Date().toISOString()): PromptInventoryReport {
+  const resolvedRoot = root;
+  const paths = listPromptSurfacePaths(resolvedRoot);
+  const surfaces = paths.map((path) => inventorySurface(resolvedRoot, path));
+  return {
+    generatedAt,
+    root: resolvedRoot,
+    totals: {
+      files: surfaces.length,
+      lines: surfaces.reduce((sum, surface) => sum + surface.lines, 0),
+      approximateTokens: surfaces.reduce((sum, surface) => sum + surface.approximateTokens, 0),
+      absoluteDirectiveCount: surfaces.reduce((sum, surface) => sum + surface.absoluteDirectiveCount, 0),
+    },
+    surfaces,
+    duplicateFragmentFamilies: duplicateFragmentFamilies(resolvedRoot, paths),
+  };
+}
+
+export function renderPromptInventoryMarkdown(report: PromptInventoryReport): string {
+  const rows = report.surfaces.map((surface) => {
+    const markerHits = Object.entries(surface.markers)
+      .filter(([, count]) => count > 0)
+      .map(([marker, count]) => `${marker} (${count})`)
+      .join('<br>');
+    return `| ${surface.path} | ${surface.lines} | ${surface.approximateTokens} | ${surface.absoluteDirectiveCount} | ${markerHits || '—'} |`;
+  });
+
+  const duplicates = report.duplicateFragmentFamilies.length === 0
+    ? ['- None detected.']
+    : report.duplicateFragmentFamilies.map(
+        (family) => `- ${family.count} files: ${family.text}\n  - ${family.paths.join(', ')}`,
+      );
+
+  return [
+    '# Prompt Inventory',
+    '',
+    `Generated: ${report.generatedAt}`,
+    `Root: ${relative(process.cwd(), report.root) || '.'}`,
+    '',
+    '## Totals',
+    '',
+    `- Files: ${report.totals.files}`,
+    `- Lines: ${report.totals.lines}`,
+    `- Approximate tokens: ${report.totals.approximateTokens}`,
+    `- Absolute directive lines: ${report.totals.absoluteDirectiveCount}`,
+    '',
+    '## Surfaces',
+    '',
+    '| Path | Lines | Approx. tokens | Absolute directive lines | Markers |',
+    '| --- | ---: | ---: | ---: | --- |',
+    ...rows,
+    '',
+    '## Duplicated fragment families',
+    '',
+    ...duplicates,
+    '',
+  ].join('\n');
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const root = process.argv.includes('--root') ? process.argv[process.argv.indexOf('--root') + 1] : process.cwd();
+  const report = buildPromptInventory(root);
+  if (process.argv.includes('--json')) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    console.log(renderPromptInventoryMarkdown(report));
+  }
+}

package/src/scripts/run-test-files.ts

@@ -2,6 +2,9 @@ import { spawnSync } from 'node:child_process';
 import { readdirSync, statSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 
+const DEFAULT_TEST_TIMEOUT_MS = 0;
+const DEFAULT_RUNNER_TIMEOUT_MS = 30 * 60 * 1_000;
+
 function collectTests(path: string, out: string[]): void {
   let stats;
   try {
@@ -22,6 +25,13 @@ function collectTests(path: string, out: string[]): void {
   }
 }
 
+function parseTimeoutMs(value: string | undefined, defaultTimeoutMs: number): number {
+  if (!value) return defaultTimeoutMs;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) return defaultTimeoutMs;
+  return Math.floor(parsed);
+}
+
 const roots = process.argv.slice(2);
 const targets = roots.length > 0 ? roots : ['dist'];
 const files: string[] = [];
@@ -36,13 +46,42 @@ if (files.length === 0) {
   process.exit(1);
 }
 
-const result = spawnSync(process.execPath, ['--test', ...files], {
+const testTimeoutMs = parseTimeoutMs(process.env.OMX_NODE_TEST_TIMEOUT_MS, DEFAULT_TEST_TIMEOUT_MS);
+const runnerTimeoutMs = parseTimeoutMs(process.env.OMX_NODE_TEST_RUNNER_TIMEOUT_MS, DEFAULT_RUNNER_TIMEOUT_MS);
+const testArgs = ['--test'];
+if (testTimeoutMs > 0) {
+  testArgs.push(`--test-timeout=${testTimeoutMs}`);
+}
+testArgs.push(...files);
+
+console.error(
+  `[run-test-files] running ${files.length} test file(s) from ${targets.join(', ')}${
+    testTimeoutMs > 0 ? ` with per-test timeout ${testTimeoutMs}ms` : ' with per-test timeout disabled'
+  }${runnerTimeoutMs > 0 ? ` and runner timeout ${runnerTimeoutMs}ms` : ' and runner timeout disabled'}`,
+);
+
+const childEnv = { ...process.env };
+delete childEnv.NODE_TEST_CONTEXT;
+childEnv.OMX_TEST_RELAX_TMUX_TIMEOUT = '1';
+
+const result = spawnSync(process.execPath, testArgs, {
   stdio: 'inherit',
-  env: process.env,
+  env: childEnv,
+  timeout: runnerTimeoutMs > 0 ? runnerTimeoutMs : undefined,
+  killSignal: 'SIGTERM',
 });
 
 if (typeof result.status === 'number') {
   process.exit(result.status);
 }
 
+if (result.error) {
+  console.error(`[run-test-files] node --test error: ${result.error.message}`);
+}
+console.error(
+  `[run-test-files] node --test did not exit normally${result.signal ? ` (signal: ${result.signal})` : ''}. `
+    + `Roots: ${targets.join(', ')}. Test files: ${files.length}. `
+    + `Per-test timeout: ${testTimeoutMs > 0 ? `${testTimeoutMs}ms` : 'disabled'}. `
+    + `Runner timeout: ${runnerTimeoutMs > 0 ? `${runnerTimeoutMs}ms` : 'disabled'}.`,
+);
 process.exit(1);

package/src/scripts/smoke-packed-install.ts

@@ -110,6 +110,15 @@ function npmBinName(name: string): string {
   return process.platform === 'win32' ? `${name}.cmd` : name;
 }
 
+export function parseNpmPackJsonOutput(stdout: string): Array<{ filename: string }> {
+  const start = stdout.lastIndexOf('\n[');
+  const jsonText = (start >= 0 ? stdout.slice(start + 1) : stdout).trim();
+  if (!jsonText.startsWith('[')) {
+    throw new Error(`npm pack did not return JSON output: ${stdout.trim()}`);
+  }
+  return JSON.parse(jsonText) as Array<{ filename: string }>;
+}
+
 async function main(): Promise<void> {
   parseArgs(process.argv.slice(2));
 
@@ -125,7 +134,7 @@ async function main(): Promise<void> {
     });
 
     const pack = run('npm', ['pack', '--json'], { cwd: repoRoot });
-    const packOutput = JSON.parse((pack.stdout as string).slice((pack.stdout as string).indexOf('['))) as Array<{ filename: string }>;
+    const packOutput = parseNpmPackJsonOutput(pack.stdout as string);
     const tarballName = packOutput[0]?.filename;
     if (!tarballName) throw new Error('npm pack did not return a tarball filename');
     tarballPath = join(repoRoot, tarballName);