oh-my-codex 0.13.1 → 0.13.2

package/src/scripts/codex-native-hook.ts

@@ -44,7 +44,6 @@ import type { HookEventEnvelope } from "../hooks/extensibility/types.js";
 import { dispatchHookEvent } from "../hooks/extensibility/dispatcher.js";
 import { reconcileHudForPromptSubmit } from "../hud/reconcile.js";
 import { onSessionStart as buildWikiSessionStartContext } from "../wiki/lifecycle.js";
-import { sessionModelInstructionsPath } from "../hooks/agents-overlay.js";
 
 type CodexHookEventName =
   | "SessionStart"
@@ -977,29 +976,6 @@ function readNativeStopSessionKey(
   return resolveRepeatableStopSessionId(payload, canonicalSessionId) || readPayloadThreadId(payload) || "global";
 }
 
-function hasManagedStopSessionEnv(sessionIds: string[]): boolean {
-  const envSessionId = safeString(process.env.OMX_SESSION_ID).trim();
-  if (!envSessionId) return false;
-  return sessionIds.length === 0 || sessionIds.includes(envSessionId);
-}
-
-async function hasManagedStopContext(
-  cwd: string,
-  payload: CodexHookPayload,
-  canonicalSessionId: string,
-): Promise<boolean> {
-  if (hasTeamWorkerContext()) return true;
-
-  const sessionIds = [...new Set([
-    canonicalSessionId,
-    readPayloadSessionId(payload),
-  ].map((value) => safeString(value).trim()).filter(Boolean))];
-
-  if (hasManagedStopSessionEnv(sessionIds)) return true;
-
-  return sessionIds.some((sessionId) => existsSync(sessionModelInstructionsPath(cwd, sessionId)));
-}
-
 function readPreviousNativeStopSignature(
   state: Record<string, unknown>,
   sessionKey: string,
@@ -1038,10 +1014,11 @@ async function maybeReturnRepeatableStopOutput(
   signature: string,
   output: Record<string, unknown> | null,
   canonicalSessionId?: string,
+  options: { allowRepeatDuringStopHook?: boolean } = {},
 ): Promise<Record<string, unknown> | null> {
   if (!output) return null;
   const stopHookActive = payload.stop_hook_active === true || payload.stopHookActive === true;
-  if (stopHookActive) {
+  if (stopHookActive && options.allowRepeatDuringStopHook !== true) {
     const state = await readJsonIfExists(join(stateDir, NATIVE_STOP_STATE_FILE)) ?? {};
     const previousSignature = readPreviousNativeStopSignature(
       state,
@@ -1055,6 +1032,24 @@ async function maybeReturnRepeatableStopOutput(
   return output;
 }
 
+async function returnPersistentStopBlock(
+  payload: CodexHookPayload,
+  stateDir: string,
+  signatureKind: string,
+  signatureValue: string,
+  output: Record<string, unknown> | null,
+  canonicalSessionId?: string,
+): Promise<Record<string, unknown> | null> {
+  return await maybeReturnRepeatableStopOutput(
+    payload,
+    stateDir,
+    buildRepeatableStopSignature(payload, signatureKind, signatureValue, canonicalSessionId),
+    output,
+    canonicalSessionId,
+    { allowRepeatDuringStopHook: true },
+  );
+}
+
 async function findCanonicalActiveTeamForSession(
   cwd: string,
   sessionId: string,
@@ -1287,20 +1282,45 @@ async function buildStopHookOutput(
   const canonicalSessionId = await resolveInternalSessionIdForPayload(cwd, sessionId);
   const threadId = readPayloadThreadId(payload);
   const ralphState = await readActiveRalphState(stateDir, canonicalSessionId);
-  const stopHookActive = payload.stop_hook_active === true || payload.stopHookActive === true;
-  const managedStopContext = await hasManagedStopContext(cwd, payload, canonicalSessionId);
   if (!ralphState) {
     const teamWorkerOutput = await buildTeamWorkerStopOutput(cwd);
-    if (!stopHookActive && hasTeamWorkerContext()) return teamWorkerOutput;
+    if (hasTeamWorkerContext() && teamWorkerOutput) return teamWorkerOutput;
 
     const autopilotOutput = await buildModeBasedStopOutput("autopilot", cwd, canonicalSessionId);
-    if (!stopHookActive && autopilotOutput) return autopilotOutput;
+    if (autopilotOutput) {
+      return await returnPersistentStopBlock(
+        payload,
+        stateDir,
+        "autopilot-stop",
+        safeString(autopilotOutput.stopReason),
+        autopilotOutput,
+        canonicalSessionId,
+      );
+    }
 
     const ultraworkOutput = await buildModeBasedStopOutput("ultrawork", cwd, canonicalSessionId);
-    if (!stopHookActive && ultraworkOutput) return ultraworkOutput;
+    if (ultraworkOutput) {
+      return await returnPersistentStopBlock(
+        payload,
+        stateDir,
+        "ultrawork-stop",
+        safeString(ultraworkOutput.stopReason),
+        ultraworkOutput,
+        canonicalSessionId,
+      );
+    }
 
     const ultraqaOutput = await buildModeBasedStopOutput("ultraqa", cwd, canonicalSessionId);
-    if (!stopHookActive && ultraqaOutput) return ultraqaOutput;
+    if (ultraqaOutput) {
+      return await returnPersistentStopBlock(
+        payload,
+        stateDir,
+        "ultraqa-stop",
+        safeString(ultraqaOutput.stopReason),
+        ultraqaOutput,
+        canonicalSessionId,
+      );
+    }
 
     const releaseReadinessFinalizeResult = await maybeBuildReleaseReadinessFinalizeStopOutput(
       payload,
@@ -1312,16 +1332,11 @@ async function buildStopHookOutput(
 
     const teamOutput = await buildTeamStopOutput(cwd, canonicalSessionId);
     if (teamOutput) {
-      const teamSignature = buildRepeatableStopSignature(
+      return await returnPersistentStopBlock(
         payload,
+        stateDir,
         "team-stop",
         safeString(teamOutput.stopReason),
-        canonicalSessionId,
-      );
-      return await maybeReturnRepeatableStopOutput(
-        payload,
-        stateDir,
-        teamSignature,
         teamOutput,
         canonicalSessionId,
       );
@@ -1334,16 +1349,11 @@ async function buildStopHookOutput(
           canonicalTeam.teamName,
           canonicalTeam.phase,
         );
-        const canonicalTeamSignature = buildRepeatableStopSignature(
+        const repeatedCanonicalTeamOutput = await returnPersistentStopBlock(
           payload,
+          stateDir,
           "team-stop",
           `${canonicalTeam.teamName}|${canonicalTeam.phase}`,
-          canonicalSessionId,
-        );
-        const repeatedCanonicalTeamOutput = await maybeReturnRepeatableStopOutput(
-          payload,
-          stateDir,
-          canonicalTeamSignature,
           canonicalTeamOutput,
           canonicalSessionId,
         );
@@ -1351,12 +1361,18 @@ async function buildStopHookOutput(
       }
 
       const skillOutput = await buildSkillStopOutput(cwd, canonicalSessionId, threadId);
-      if (!stopHookActive && skillOutput) return skillOutput;
+      if (skillOutput) {
+        return await returnPersistentStopBlock(
+          payload,
+          stateDir,
+          "skill-stop",
+          safeString(skillOutput.stopReason),
+          skillOutput,
+          canonicalSessionId,
+        );
+      }
     }
 
-    if (!managedStopContext) {
-      return null;
-    }
 
     const lastAssistantMessage = safeString(
       payload.last_assistant_message ?? payload.lastAssistantMessage,
@@ -1369,10 +1385,11 @@ async function buildStopHookOutput(
       && detectNativeStopStallPattern(lastAssistantMessage, autoNudgeConfig.patterns, autoNudgePhase)
     ) {
       const effectiveResponse = resolveEffectiveAutoNudgeResponse(autoNudgeConfig.response);
-      return await maybeReturnRepeatableStopOutput(
+      return await returnPersistentStopBlock(
         payload,
         stateDir,
-        buildRepeatableStopSignature(payload, "auto-nudge", lastAssistantMessage, canonicalSessionId),
+        "auto-nudge",
+        lastAssistantMessage,
         {
           decision: "block",
           reason: effectiveResponse,
@@ -1387,21 +1404,24 @@ async function buildStopHookOutput(
     return null;
   }
 
-  if (stopHookActive) {
-    return null;
-  }
-
   const currentPhase = safeString(ralphState?.current_phase).trim() || "executing";
   const stopReason = `ralph_${currentPhase}`;
   const systemMessage =
     `OMX Ralph is still active (phase: ${currentPhase}); continue the task and gather fresh verification evidence before stopping.`;
 
-  return {
-    decision: "block",
-    reason: systemMessage,
-    stopReason,
-    systemMessage,
-  };
+  return await returnPersistentStopBlock(
+    payload,
+    stateDir,
+    "ralph-stop",
+    currentPhase,
+    {
+      decision: "block",
+      reason: systemMessage,
+      stopReason,
+      systemMessage,
+    },
+    canonicalSessionId,
+  );
 }
 
 export async function dispatchCodexNativeHook(

package/src/scripts/generate-release-body.ts

@@ -0,0 +1,295 @@
+#!/usr/bin/env node
+import { readFileSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { pathToFileURL } from 'node:url';
+
+export interface Contributor {
+  displayName: string;
+  login?: string;
+  url?: string;
+}
+
+interface CompareCommit {
+  author?: {
+    login?: string;
+    html_url?: string;
+  } | null;
+  commit?: {
+    author?: {
+      name?: string;
+    } | null;
+  } | null;
+}
+
+interface CompareResponse {
+  commits?: CompareCommit[];
+}
+
+interface GenerateReleaseBodyOptions {
+  templatePath: string;
+  outPath: string;
+  currentTag?: string;
+  previousTag?: string;
+  repo?: string;
+  githubToken?: string;
+  cwd?: string;
+}
+
+function usage(): never {
+  console.error('Usage: node scripts/generate-release-body.mjs --template <path> --out <path> [--current-tag <tag>] [--previous-tag <tag>] [--repo <owner/name>]');
+  process.exit(1);
+}
+
+function arg(name: string): string | undefined {
+  const index = process.argv.indexOf(name);
+  if (index === -1) return undefined;
+  return process.argv[index + 1];
+}
+
+function runGit(args: string[], cwd: string, allowFailure = false): string {
+  const result = spawnSync('git', args, {
+    cwd,
+    encoding: 'utf-8',
+    stdio: 'pipe',
+  });
+  if (result.status !== 0) {
+    if (allowFailure) return '';
+    throw new Error(`git ${args.join(' ')} failed: ${(result.stderr || result.stdout || '').trim()}`.trim());
+  }
+  return String(result.stdout || '').trim();
+}
+
+function resolveRepositoryFromRemote(cwd: string): string | undefined {
+  const remote = runGit(['config', '--get', 'remote.origin.url'], cwd, true);
+  if (!remote) return undefined;
+  const httpsMatch = remote.match(/github\.com[:/](.+?)(?:\.git)?$/);
+  return httpsMatch?.[1];
+}
+
+export function resolveCurrentTag(cwd: string, explicit?: string): string {
+  if (explicit) return explicit;
+  if (process.env.GITHUB_REF_NAME) return process.env.GITHUB_REF_NAME;
+  const described = runGit(['describe', '--tags', '--exact-match'], cwd, true);
+  if (described) return described;
+  throw new Error('unable to determine current release tag; pass --current-tag or set GITHUB_REF_NAME');
+}
+
+export function resolvePreviousTag(cwd: string, currentTag: string, explicit?: string): string | undefined {
+  if (explicit) return explicit;
+  const tags = runGit(['tag', '--list', 'v*', '--sort=-v:refname'], cwd, true)
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+  if (tags.length === 0) return undefined;
+  const currentIndex = tags.indexOf(currentTag);
+  if (currentIndex >= 0) return tags.slice(currentIndex + 1).find(Boolean);
+  return tags.find((tag) => tag !== currentTag);
+}
+
+function normalizeContributors(contributors: Contributor[]): Contributor[] {
+  const deduped = new Map<string, Contributor>();
+  for (const contributor of contributors) {
+    const login = contributor.login?.trim();
+    const displayName = contributor.displayName.trim();
+    if (!displayName && !login) continue;
+    const key = (login || displayName).toLowerCase();
+    if (!deduped.has(key)) {
+      deduped.set(key, {
+        displayName: displayName || `@${login}`,
+        ...(login ? { login } : {}),
+        ...(contributor.url ? { url: contributor.url } : {}),
+      });
+    }
+  }
+  return [...deduped.values()].sort((left, right) => {
+    const leftKey = (left.login || left.displayName).toLowerCase();
+    const rightKey = (right.login || right.displayName).toLowerCase();
+    return leftKey.localeCompare(rightKey);
+  });
+}
+
+export function formatContributor(contributor: Contributor): string {
+  if (contributor.login && contributor.url) {
+    return `[@${contributor.login}](${contributor.url})`;
+  }
+  if (contributor.login) {
+    return `@${contributor.login}`;
+  }
+  if (contributor.url) {
+    return `[${contributor.displayName}](${contributor.url})`;
+  }
+  return contributor.displayName;
+}
+
+function joinHumanList(values: string[]): string {
+  if (values.length === 0) return 'the contributors';
+  if (values.length === 1) return values[0]!;
+  if (values.length === 2) return `${values[0]} and ${values[1]}`;
+  return `${values.slice(0, -1).join(', ')}, and ${values.at(-1)}`;
+}
+
+export function renderContributorsSection(contributors: Contributor[]): string {
+  const normalized = normalizeContributors(contributors);
+  if (normalized.length === 0) {
+    return 'Thanks to the contributors who made this release possible.';
+  }
+  return `Thanks to ${joinHumanList(normalized.map((contributor) => formatContributor(contributor)))} for contributing to this release.`;
+}
+
+export function buildFullChangelogLine(repo: string, currentTag: string, previousTag?: string): string {
+  if (!repo) {
+    throw new Error('unable to determine GitHub repository; pass --repo or set GITHUB_REPOSITORY');
+  }
+  if (previousTag) {
+    return `**Full Changelog**: [\`${previousTag}...${currentTag}\`](https://github.com/${repo}/compare/${previousTag}...${currentTag})`;
+  }
+  return `**Full Changelog**: [\`${currentTag}\`](https://github.com/${repo}/releases/tag/${currentTag})`;
+}
+
+function replaceTitle(markdown: string, currentTag: string): string {
+  if (!/^#\s+/m.test(markdown)) {
+    throw new Error('release body template is missing a top-level title');
+  }
+  return markdown.replace(/^#\s+.*$/m, `# oh-my-codex ${currentTag}`);
+}
+
+function findSectionEnd(lines: string[], startIndex: number): number {
+  for (let index = startIndex + 1; index < lines.length; index += 1) {
+    if (/^##\s+/.test(lines[index] ?? '')) return index;
+    if (/^\*\*Full Changelog\*\*:/.test(lines[index] ?? '')) return index;
+  }
+  return lines.length;
+}
+
+export function replaceSectionBody(markdown: string, heading: string, body: string): string {
+  const lines = markdown.split(/\r?\n/);
+  const headingLine = `## ${heading}`;
+  const startIndex = lines.findIndex((line) => line.trim() === headingLine);
+  if (startIndex === -1) {
+    throw new Error(`release body template is missing section: ${headingLine}`);
+  }
+  const endIndex = findSectionEnd(lines, startIndex);
+  lines.splice(startIndex + 1, endIndex - startIndex - 1, '', ...body.split('\n'), '');
+  return `${lines.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd()}\n`;
+}
+
+export function replaceFullChangelogLine(markdown: string, fullChangelogLine: string): string {
+  const lines = markdown.split(/\r?\n/);
+  const lineIndex = lines.findIndex((line) => /^\*\*Full Changelog\*\*:/.test(line));
+  if (lineIndex === -1) {
+    throw new Error('release body template is missing the Full Changelog line');
+  }
+  lines[lineIndex] = fullChangelogLine;
+  return `${lines.join('\n').trimEnd()}\n`;
+}
+
+function parseShortlogLine(line: string): Contributor | undefined {
+  const match = line.match(/^\s*\d+\s+(.+?)(?:\s+<[^>]+>)?$/);
+  if (!match) return undefined;
+  const displayName = match[1]?.trim();
+  if (!displayName) return undefined;
+  return { displayName };
+}
+
+export function getGitContributors(cwd: string, currentTag: string, previousTag?: string): Contributor[] {
+  const range = previousTag ? `${previousTag}..${currentTag}` : currentTag;
+  const shortlog = runGit(['shortlog', '-sne', range], cwd, true);
+  if (!shortlog) return [];
+  return normalizeContributors(shortlog.split(/\r?\n/).map((line) => parseShortlogLine(line)).filter((value): value is Contributor => Boolean(value)));
+}
+
+export async function getGitHubCompareContributors(
+  repo: string,
+  currentTag: string,
+  previousTag: string,
+  githubToken: string,
+  fetchImpl: typeof fetch = fetch,
+): Promise<Contributor[]> {
+  const response = await fetchImpl(`https://api.github.com/repos/${repo}/compare/${previousTag}...${currentTag}`, {
+    headers: {
+      Accept: 'application/vnd.github+json',
+      Authorization: `Bearer ${githubToken}`,
+      'User-Agent': 'oh-my-codex-release-body-generator',
+      'X-GitHub-Api-Version': '2022-11-28',
+    },
+  });
+  if (!response.ok) {
+    throw new Error(`GitHub compare API failed (${response.status})`);
+  }
+  const payload = await response.json() as CompareResponse;
+  const contributors = (payload.commits ?? []).map((commit) => {
+    if (commit.author?.login) {
+      return {
+        displayName: `@${commit.author.login}`,
+        login: commit.author.login,
+        ...(commit.author.html_url ? { url: commit.author.html_url } : {}),
+      } satisfies Contributor;
+    }
+    const name = commit.commit?.author?.name?.trim();
+    return name ? { displayName: name } satisfies Contributor : undefined;
+  }).filter((value): value is Contributor => Boolean(value));
+  return normalizeContributors(contributors);
+}
+
+export async function resolveContributors(options: {
+  cwd: string;
+  repo?: string;
+  currentTag: string;
+  previousTag?: string;
+  githubToken?: string;
+}): Promise<Contributor[]> {
+  const { cwd, repo, currentTag, previousTag, githubToken } = options;
+  if (repo && previousTag && githubToken) {
+    try {
+      return await getGitHubCompareContributors(repo, currentTag, previousTag, githubToken);
+    } catch (error) {
+      console.error(`[generate-release-body] falling back to git shortlog: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return getGitContributors(cwd, currentTag, previousTag);
+}
+
+export async function generateReleaseBody(options: GenerateReleaseBodyOptions): Promise<string> {
+  const cwd = resolve(options.cwd ?? process.cwd());
+  const templatePath = resolve(cwd, options.templatePath);
+  const outPath = resolve(cwd, options.outPath);
+  const currentTag = resolveCurrentTag(cwd, options.currentTag);
+  const previousTag = resolvePreviousTag(cwd, currentTag, options.previousTag);
+  const repo = options.repo || process.env.GITHUB_REPOSITORY || resolveRepositoryFromRemote(cwd);
+  const contributors = await resolveContributors({
+    cwd,
+    repo,
+    currentTag,
+    previousTag,
+    githubToken: options.githubToken || process.env.GITHUB_TOKEN,
+  });
+
+  let markdown = readFileSync(templatePath, 'utf-8');
+  markdown = replaceTitle(markdown, currentTag);
+  markdown = replaceSectionBody(markdown, 'Contributors', renderContributorsSection(contributors));
+  markdown = replaceFullChangelogLine(markdown, buildFullChangelogLine(repo || '', currentTag, previousTag));
+  writeFileSync(outPath, markdown);
+  return markdown;
+}
+
+async function main(): Promise<void> {
+  const templatePath = arg('--template');
+  const outPath = arg('--out');
+  if (!templatePath || !outPath) usage();
+  await generateReleaseBody({
+    templatePath,
+    outPath,
+    currentTag: arg('--current-tag'),
+    previousTag: arg('--previous-tag'),
+    repo: arg('--repo'),
+  });
+  console.log(resolve(process.cwd(), outPath));
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  });
+}