@haystackeditor/cli 0.11.0 → 0.12.1

package/README.md

@@ -69,6 +69,7 @@ Create a PR from current changes. Runs pre-PR triage (code review, rules validat
 
 ```bash
 haystack submit                      # Triage -> create PR -> wait for analysis
+haystack submit --auto-fix           # Discouraged alpha auto-fix for straightforward mechanical issues
 haystack submit --title "Fix auth"   # Custom PR title
 haystack submit --draft              # Create as draft PR
 haystack submit --force              # Skip triage checks
@@ -84,30 +85,26 @@ haystack submit --review octocat     # Request review from a specific teammate
 
 When `--review` is used without a username, the PR is labeled `haystack:needs-review` and appears in your team's assignment queue. When a username is provided, that person is also requested as a reviewer on GitHub.
 
+The `--auto-fix` flag is an alpha feature and is discouraged by default. It opts into a sandbox agent that attempts straightforward mechanical fixes before surfacing issues in the Feed. For most PRs, prefer plain `haystack submit`.
+
 ### `haystack triage`
 
 View Haystack analysis results for any PR. Shows the same data as the Haystack web feed: rating, verdict, structured findings with details, verified bugs, human review reasons, and agent fix prompts.
 
 ```bash
+haystack triage                             # Last submitted PR
 haystack triage 42                          # Current repo, PR #42
 haystack triage owner/repo#99               # Fully qualified
 haystack triage https://github.com/o/r/pull/1  # From GitHub URL
 haystack triage 42 --json                   # Machine-readable JSON output
 haystack triage 42 --no-wait                # Don't wait if analysis is pending
+haystack triage --hook                      # Minimal one-liner (for session hooks)
+haystack triage --clear                     # Clear pending submit state
 ```
 
-The `--json` output includes `agentFixPrompt` fields -- ready-to-paste instructions for coding agents to fix each finding.
-
-### `haystack check-pending`
-
-Check the status of a previously submitted PR's analysis (from the current repo):
+When called without a PR identifier, checks the last PR submitted via `haystack submit`. The `--hook` flag produces a single-line summary with the Haystack rating and auto-fixer status, designed for session-start hooks.
 
-```bash
-haystack check-pending              # Rich terminal output
-haystack check-pending --hook       # Minimal output (for session-start hooks)
-haystack check-pending --json       # Machine-readable JSON
-haystack check-pending --clear      # Clear pending state
-```
+The `--json` output includes `agentFixPrompt` fields -- ready-to-paste instructions for coding agents to fix each finding.
 
 ### `haystack dismiss`
 
@@ -198,7 +195,7 @@ haystack hooks install --skip-entire # Only install Haystack hooks
 haystack hooks status                # Check installation status
 haystack hooks update                # Update Entire CLI to latest
 
-# Session hooks (check-pending on CLI start)
+# Session hooks (triage on CLI start)
 haystack hooks install-session              # Auto-detect CLIs
 haystack hooks install-session --cli claude # Claude Code only
 haystack hooks install-session --cli all    # All detected CLIs

package/dist/assets/hooks/agent-context/detect.ts

@@ -61,6 +61,120 @@ function extractSessionId(filePath: string, ext: string): string {
   return path.basename(filePath, ext);
 }
 
+function findMostRecentFileRecursive(
+  dir: string,
+  matches: (filePath: string) => boolean,
+): string | null {
+  if (!fs.existsSync(dir)) return null;
+
+  const stack = [dir];
+  let bestPath: string | null = null;
+  let bestMtime = 0;
+
+  while (stack.length > 0) {
+    const currentDir = stack.pop();
+    if (!currentDir) continue;
+
+    let entries: fs.Dirent[];
+    try {
+      entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+        continue;
+      }
+      if (!entry.isFile() || !matches(fullPath)) continue;
+
+      try {
+        const stat = fs.statSync(fullPath);
+        if (stat.mtimeMs > bestMtime) {
+          bestMtime = stat.mtimeMs;
+          bestPath = fullPath;
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+
+  return bestPath;
+}
+
+function readCodexSessionRepoPath(filePath: string): string | null {
+  let fd: number | undefined;
+
+  try {
+    fd = fs.openSync(filePath, 'r');
+    const buffer = Buffer.alloc(32 * 1024);
+    const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, 0);
+    const header = buffer.toString('utf8', 0, bytesRead);
+
+    for (const line of header.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+
+      try {
+        const parsed = JSON.parse(trimmed) as {
+          type?: string;
+          payload?: { cwd?: string };
+        };
+        if (
+          (parsed.type === 'session_meta' || parsed.type === 'turn_context') &&
+          typeof parsed.payload?.cwd === 'string'
+        ) {
+          return parsed.payload.cwd;
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return null;
+  } finally {
+    if (fd !== undefined) {
+      fs.closeSync(fd);
+    }
+  }
+
+  return null;
+}
+
+function codexSessionMatchesRepo(
+  sessionFilePath: string,
+  repoPath: string,
+): boolean {
+  const sessionRepoPath = readCodexSessionRepoPath(sessionFilePath);
+  return !sessionRepoPath || sessionRepoPath === repoPath;
+}
+
+function getCodexSessionRoots(): string[] {
+  const overrideDir = process.env.ENTIRE_TEST_CODEX_SESSION_DIR;
+  if (overrideDir) return [overrideDir];
+
+  const codexHome =
+    process.env.ENTIRE_TEST_CODEX_HOME ||
+    process.env.CODEX_HOME ||
+    path.join(os.homedir(), '.codex');
+
+  return [
+    path.join(codexHome, 'sessions'),
+    path.join(codexHome, 'archived_sessions'),
+  ];
+}
+
+function extractCodexSessionId(filePath: string): string {
+  const basename = path.basename(filePath);
+  const match = basename.match(
+    /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i,
+  );
+  return match ? match[1] : extractSessionId(filePath, '.jsonl');
+}
+
 function detectClaude(repoPath: string): DetectionResult {
   const overrideDir = process.env.ENTIRE_TEST_CLAUDE_PROJECT_DIR;
   const sessionDir =
@@ -119,8 +233,74 @@ function detectOpenCode(repoPath: string): DetectionResult {
   };
 }
 
+function detectCodex(repoPath: string): DetectionResult {
+  const overrideFile = process.env.ENTIRE_TEST_CODEX_SESSION_FILE;
+  if (
+    overrideFile &&
+    isRecent(overrideFile) &&
+    codexSessionMatchesRepo(overrideFile, repoPath)
+  ) {
+    return {
+      detected: true,
+      agent: 'codex',
+      sessionFilePath: overrideFile,
+      sessionId: extractCodexSessionId(overrideFile),
+    };
+  }
+
+  const sessionRoots = getCodexSessionRoots();
+  const threadId = process.env.CODEX_THREAD_ID;
+
+  if (threadId) {
+    for (const sessionRoot of sessionRoots) {
+      const sessionFile = findMostRecentFileRecursive(
+        sessionRoot,
+        (filePath) =>
+          filePath.endsWith(`${threadId}.jsonl`) &&
+          path.basename(filePath).startsWith('rollout-'),
+      );
+
+      if (
+        sessionFile &&
+        isRecent(sessionFile) &&
+        codexSessionMatchesRepo(sessionFile, repoPath)
+      ) {
+        return {
+          detected: true,
+          agent: 'codex',
+          sessionFilePath: sessionFile,
+          sessionId: extractCodexSessionId(sessionFile),
+        };
+      }
+    }
+  }
+
+  for (const sessionRoot of sessionRoots) {
+    const sessionFile = findMostRecentFileRecursive(
+      sessionRoot,
+      (filePath) =>
+        filePath.endsWith('.jsonl') &&
+        path.basename(filePath).startsWith('rollout-') &&
+        isRecent(filePath) &&
+        codexSessionMatchesRepo(filePath, repoPath),
+    );
+
+    if (sessionFile) {
+      return {
+        detected: true,
+        agent: 'codex',
+        sessionFilePath: sessionFile,
+        sessionId: extractCodexSessionId(sessionFile),
+      };
+    }
+  }
+
+  return { detected: false };
+}
+
 const detectors: Array<(repoPath: string) => DetectionResult> = [
   detectClaude,
+  detectCodex,
   detectGemini,
   detectOpenCode,
 ];

package/dist/assets/hooks/agent-context/format.ts

@@ -3,6 +3,7 @@ import type { AgentContext, InteractionTurn } from './types.js';
 const AGENT_DISPLAY_NAMES: Record<string, string> = {
   'claude-code': 'Claude Code',
   'gemini-cli': 'Gemini CLI',
+  codex: 'Codex',
   opencode: 'OpenCode',
 };
 

package/dist/assets/hooks/agent-context/index.ts

@@ -1,5 +1,6 @@
 import { detectAgent } from './detect.js';
 import { ClaudeParser } from './parsers/claude.js';
+import { CodexParser } from './parsers/codex.js';
 import { GeminiParser } from './parsers/gemini.js';
 import { OpenCodeParser } from './parsers/opencode.js';
 import { formatContext } from './format.js';
@@ -7,6 +8,7 @@ import type { AgentParser } from './types.js';
 
 const PARSERS: Record<string, AgentParser> = {
   'claude-code': new ClaudeParser(),
+  codex: new CodexParser(),
   'gemini-cli': new GeminiParser(),
   opencode: new OpenCodeParser(),
 };

package/dist/assets/hooks/agent-context/parsers/claude.ts

@@ -25,6 +25,7 @@ interface ClaudeLine {
   gitBranch?: string;
   uuid?: string;
   timestamp?: string;
+  // Old format: message wrapper with role/content/usage
   message?: {
     id?: string;
     model?: string;
@@ -37,10 +38,13 @@ interface ClaudeLine {
       cache_read_input_tokens?: number;
     };
   };
+  // New Entire CLI format: id/content at top level (type is the role)
+  id?: string;
+  content?: unknown;
 }
 
 interface ContentBlock {
-  type: string;
+  type?: string;  // Optional: new format blocks may omit type
   text?: string;
   thinking?: string;
   name?: string;
@@ -68,7 +72,8 @@ function extractTextContent(content: unknown): string {
 
   const parts: string[] = [];
   for (const block of content as ContentBlock[]) {
-    if (block.type === 'text' && block.text) {
+    // Support both old ({type: "text", text}) and new ({id, text}) content blocks
+    if (block.text && (block.type === 'text' || !block.type)) {
       parts.push(block.text);
     }
   }
@@ -143,9 +148,10 @@ export class ClaudeParser implements AgentParser {
     const assistantLines = allLines.filter((l) => l.type === 'assistant');
 
     // Deduplicate assistant messages by message.id (streaming produces duplicates)
+    // Support both old format (line.message.id) and new format (line.id)
     const dedupedAssistant = new Map<string, ClaudeLine>();
     for (const line of assistantLines) {
-      const msgId = line.message?.id;
+      const msgId = line.message?.id || line.id;
       if (msgId) {
         dedupedAssistant.set(msgId, line);
       }
@@ -162,17 +168,20 @@ export class ClaudeParser implements AgentParser {
     for (let i = 0; i < maxTurns; i++) {
       if (i < userLines.length) {
         const user = userLines[i];
+        // Support both old ({message: {content}}) and new ({content}) formats
+        const userContent = user.message?.content ?? user.content;
         transcript.push({
           turnIndex: turnIndex++,
           role: 'user',
-          content: extractTextContent(user.message?.content),
+          content: extractTextContent(userContent),
           modifiedFiles: [],
           toolUses: [],
         });
       }
       if (i < uniqueAssistant.length) {
         const asst = uniqueAssistant[i];
-        const content = asst.message?.content;
+        // Support both old ({message: {content, usage}}) and new ({content}) formats
+        const content = asst.message?.content ?? asst.content;
         const usage = asst.message?.usage;
         transcript.push({
           turnIndex: turnIndex++,