@haystackeditor/cli 0.11.0 → 0.12.1

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

@@ -0,0 +1,416 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import type {
+  AgentContext,
+  AgentParser,
+  DetectionResult,
+  InteractionTurn,
+  ModifiedFile,
+  TokenUsage,
+  ToolUseInfo,
+} from '../types.js';
+import { detectAgent } from '../detect.js';
+
+const PATCH_FILE_LINE_RE = /^\*\*\* (?:Update|Add|Delete) File: (.+)$/;
+const PATCH_MOVE_LINE_RE = /^\*\*\* Move to: (.+)$/;
+const EDITING_TOOLS = new Set([
+  'apply_patch',
+  'write_file',
+  'edit_file',
+  'create_file',
+  'replace_file',
+]);
+const FILE_PATH_KEYS = [
+  'path',
+  'file_path',
+  'filePath',
+  'filename',
+  'target_path',
+  'targetPath',
+  'new_path',
+  'newPath',
+  'old_path',
+  'oldPath',
+  'notebook_path',
+];
+const TASK_PROMPT_SKIP_PREFIXES = [
+  '# AGENTS.md instructions for ',
+  '<permissions instructions>',
+  '<app-context>',
+  '<collaboration_mode>',
+  '<skills_instructions>',
+  '<environment_context>',
+];
+
+interface CodexRecord {
+  type?: string;
+  payload?: Record<string, unknown>;
+}
+
+interface CodexSessionMetaPayload {
+  id?: string;
+  timestamp?: string;
+  cwd?: string;
+  cli_version?: string;
+  git?: {
+    branch?: string;
+  };
+}
+
+interface CodexTurnContextPayload {
+  model?: string;
+  cwd?: string;
+}
+
+interface CodexTokenUsagePayload {
+  input_tokens?: number;
+  cached_input_tokens?: number;
+  output_tokens?: number;
+}
+
+function parseLines(raw: string): CodexRecord[] {
+  const records: CodexRecord[] = [];
+  for (const line of raw.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      records.push(JSON.parse(trimmed));
+    } catch {
+      // Skip partial lines while a session file is still being written.
+    }
+  }
+  return records;
+}
+
+function extractTextContent(content: unknown): string {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+
+  return content
+    .map((part) => {
+      if (typeof part === 'string') return part;
+      if (
+        part &&
+        typeof part === 'object' &&
+        'text' in part &&
+        typeof part.text === 'string'
+      ) {
+        return part.text;
+      }
+      return '';
+    })
+    .filter(Boolean)
+    .join('\n');
+}
+
+function truncateString(value: string): string {
+  if (value.length <= 200) return value;
+  return value.slice(0, 200) + '... (truncated)';
+}
+
+function sanitizeInput(input: Record<string, unknown>): Record<string, unknown> {
+  const sanitized: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (typeof value === 'string') {
+      sanitized[key] = truncateString(value);
+    } else if (Array.isArray(value)) {
+      sanitized[key] = value.map((item) =>
+        typeof item === 'string' ? truncateString(item) : item,
+      );
+    } else {
+      sanitized[key] = value;
+    }
+  }
+  return sanitized;
+}
+
+function parseJsonObject(raw: unknown): Record<string, unknown> {
+  if (typeof raw !== 'string' || !raw.trim()) return {};
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+      return parsed as Record<string, unknown>;
+    }
+  } catch {
+    // Ignore malformed arguments payloads.
+  }
+  return {};
+}
+
+function extractPatchFilePaths(inputText: string): string[] {
+  const filePaths = new Set<string>();
+
+  for (const line of inputText.split('\n')) {
+    const fileMatch = line.match(PATCH_FILE_LINE_RE);
+    if (fileMatch) {
+      filePaths.add(fileMatch[1]);
+      continue;
+    }
+
+    const moveMatch = line.match(PATCH_MOVE_LINE_RE);
+    if (moveMatch) {
+      filePaths.add(moveMatch[1]);
+    }
+  }
+
+  return Array.from(filePaths);
+}
+
+function extractKnownFilePaths(input: Record<string, unknown>): string[] {
+  const filePaths = new Set<string>();
+
+  for (const key of FILE_PATH_KEYS) {
+    const value = input[key];
+    if (typeof value === 'string' && value.trim()) {
+      filePaths.add(value);
+    } else if (Array.isArray(value)) {
+      for (const item of value) {
+        if (typeof item === 'string' && item.trim()) {
+          filePaths.add(item);
+        }
+      }
+    }
+  }
+
+  return Array.from(filePaths);
+}
+
+function extractPatchInputText(
+  input: Record<string, unknown>,
+  rawInputText?: string,
+): string {
+  const parsedInputText = input.input;
+  if (typeof parsedInputText === 'string' && parsedInputText.trim()) {
+    return parsedInputText;
+  }
+
+  const parsedPatchText = input.patch;
+  if (typeof parsedPatchText === 'string' && parsedPatchText.trim()) {
+    return parsedPatchText;
+  }
+
+  const rawInputObject = parseJsonObject(rawInputText);
+  const rawObjectInputText = rawInputObject.input;
+  if (typeof rawObjectInputText === 'string' && rawObjectInputText.trim()) {
+    return rawObjectInputText;
+  }
+
+  const rawObjectPatchText = rawInputObject.patch;
+  if (typeof rawObjectPatchText === 'string' && rawObjectPatchText.trim()) {
+    return rawObjectPatchText;
+  }
+
+  return typeof rawInputText === 'string' ? rawInputText : '';
+}
+
+function extractModifiedFiles(
+  toolName: string,
+  toolUseId: string,
+  input: Record<string, unknown>,
+  rawInputText?: string,
+): ModifiedFile[] {
+  let filePaths: string[] = [];
+
+  if (toolName === 'apply_patch') {
+    const patchInputText = extractPatchInputText(input, rawInputText);
+    if (patchInputText) {
+      filePaths = extractPatchFilePaths(patchInputText);
+    }
+  } else if (EDITING_TOOLS.has(toolName)) {
+    filePaths = extractKnownFilePaths(input);
+  }
+
+  return filePaths.map((filePath) => ({
+    filePath,
+    toolName,
+    toolUseId,
+  }));
+}
+
+function getOrCreateAssistantTurn(transcript: InteractionTurn[]): InteractionTurn {
+  const lastTurn = transcript[transcript.length - 1];
+  if (lastTurn && lastTurn.role === 'assistant') {
+    return lastTurn;
+  }
+
+  const turn: InteractionTurn = {
+    turnIndex: transcript.length,
+    role: 'assistant',
+    content: '',
+    modifiedFiles: [],
+    toolUses: [],
+  };
+  transcript.push(turn);
+  return turn;
+}
+
+function isMeaningfulTaskPrompt(content: string): boolean {
+  const trimmed = content.trim();
+  if (!trimmed) return false;
+  return !TASK_PROMPT_SKIP_PREFIXES.some((prefix) => trimmed.startsWith(prefix));
+}
+
+function extractSessionId(sessionFilePath: string, sessionMeta?: CodexSessionMetaPayload): string {
+  if (sessionMeta?.id) return sessionMeta.id;
+
+  const basename = path.basename(sessionFilePath);
+  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] : basename.replace(/\.jsonl$/, '');
+}
+
+export class CodexParser implements AgentParser {
+  async detect(repoPath: string): Promise<DetectionResult> {
+    return detectAgent(repoPath);
+  }
+
+  async parse(
+    sessionFilePath: string,
+    _repoPath: string,
+  ): Promise<AgentContext> {
+    const raw = fs.readFileSync(sessionFilePath, 'utf-8');
+    const records = parseLines(raw);
+    const transcript: InteractionTurn[] = [];
+    const fallbackUserPrompts: string[] = [];
+    let taskPrompt = '';
+    let sessionMeta: CodexSessionMetaPayload | undefined;
+    let latestTurnContext: CodexTurnContextPayload | undefined;
+    let totalUsage: TokenUsage = {
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheCreationTokens: 0,
+    };
+
+    for (const record of records) {
+      if (!record.type || !record.payload) continue;
+
+      if (record.type === 'session_meta') {
+        sessionMeta = record.payload as unknown as CodexSessionMetaPayload;
+        continue;
+      }
+
+      if (record.type === 'turn_context') {
+        latestTurnContext = record.payload as unknown as CodexTurnContextPayload;
+        continue;
+      }
+
+      if (record.type === 'event_msg') {
+        const payloadType = record.payload.type;
+        if (payloadType === 'token_count') {
+          const usage = (
+            record.payload.info as { total_token_usage?: CodexTokenUsagePayload } | undefined
+          )?.total_token_usage;
+          if (usage) {
+            totalUsage = {
+              inputTokens: usage.input_tokens || 0,
+              outputTokens: usage.output_tokens || 0,
+              cacheReadTokens: usage.cached_input_tokens || 0,
+              cacheCreationTokens: 0,
+            };
+          }
+        }
+        continue;
+      }
+
+      if (record.type !== 'response_item') continue;
+
+      const payloadType = record.payload.type;
+      if (payloadType === 'message') {
+        const role = record.payload.role;
+        if (role !== 'user' && role !== 'assistant') continue;
+
+        const content = extractTextContent(record.payload.content);
+        if (role === 'user') {
+          if (content) {
+            fallbackUserPrompts.push(content);
+            if (!taskPrompt && isMeaningfulTaskPrompt(content)) {
+              taskPrompt = content;
+            }
+          }
+        }
+
+        transcript.push({
+          turnIndex: transcript.length,
+          role,
+          content,
+          modifiedFiles: [],
+          toolUses: [],
+        });
+        continue;
+      }
+
+      if (payloadType === 'function_call') {
+        const toolName =
+          typeof record.payload.name === 'string' ? record.payload.name : 'unknown';
+        const toolUseId =
+          typeof record.payload.call_id === 'string' ? record.payload.call_id : '';
+        const rawArguments =
+          typeof record.payload.arguments === 'string' ? record.payload.arguments : undefined;
+        const input = parseJsonObject(record.payload.arguments);
+        const assistantTurn = getOrCreateAssistantTurn(transcript);
+
+        assistantTurn.toolUses.push({
+          toolName,
+          toolUseId,
+          input: sanitizeInput(input),
+        });
+        assistantTurn.modifiedFiles.push(
+          ...extractModifiedFiles(toolName, toolUseId, input, rawArguments),
+        );
+        continue;
+      }
+
+      if (payloadType === 'custom_tool_call') {
+        const toolName =
+          typeof record.payload.name === 'string' ? record.payload.name : 'unknown';
+        const toolUseId =
+          typeof record.payload.call_id === 'string' ? record.payload.call_id : '';
+        const rawInput =
+          typeof record.payload.input === 'string' ? record.payload.input : '';
+        const input = rawInput ? { input: rawInput } : {};
+        const assistantTurn = getOrCreateAssistantTurn(transcript);
+
+        assistantTurn.toolUses.push({
+          toolName,
+          toolUseId,
+          input: sanitizeInput(input),
+        });
+        assistantTurn.modifiedFiles.push(
+          ...extractModifiedFiles(toolName, toolUseId, input, rawInput),
+        );
+      }
+    }
+
+    if (!taskPrompt) {
+      taskPrompt = fallbackUserPrompts.find((prompt) => prompt.trim()) || '';
+    }
+
+    const allModifiedFiles = new Set<string>();
+    for (const turn of transcript) {
+      for (const modifiedFile of turn.modifiedFiles) {
+        allModifiedFiles.add(modifiedFile.filePath);
+      }
+    }
+
+    const stat = fs.statSync(sessionFilePath);
+
+    return {
+      agent: 'codex',
+      sessionId: extractSessionId(sessionFilePath, sessionMeta),
+      sessionFilePath,
+      taskPrompt,
+      modifiedFiles: Array.from(allModifiedFiles),
+      tokenUsage: totalUsage,
+      transcript,
+      metadata: {
+        model: latestTurnContext?.model,
+        version: sessionMeta?.cli_version,
+        gitBranch: sessionMeta?.git?.branch,
+        startedAt: sessionMeta?.timestamp,
+        sessionFileModifiedAt: stat.mtime.toISOString(),
+      },
+    };
+  }
+}

package/dist/assets/hooks/agent-context/tsconfig.json

@@ -5,6 +5,7 @@
     "moduleResolution": "Node16",
     "strict": true,
     "esModuleInterop": true,
+    "types": ["node"],
     "resolveJsonModule": true,
     "noEmit": true,
     "skipLibCheck": true

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

@@ -1,4 +1,4 @@
-export type AgentType = 'claude-code' | 'gemini-cli' | 'opencode';
+export type AgentType = 'claude-code' | 'gemini-cli' | 'opencode' | 'codex';
 
 export interface ModifiedFile {
   filePath: string;

package/dist/assets/hooks/package.json

@@ -5,7 +5,8 @@
   "type": "module",
   "description": "Git hooks for AI agent quality checks (installed by @haystackeditor/cli)",
   "dependencies": {
-    "tree-sitter": "0.22.4",
+    "tsx": "4.21.0",
+    "tree-sitter": "0.21.1",
     "tree-sitter-typescript": "0.23.2"
   }
 }

package/dist/assets/hooks/scripts/pre-commit.sh

@@ -1,10 +1,88 @@
 #!/usr/bin/env bash
 HOOKS_DIR="$(cd "$(dirname "$0")" && pwd)"
 REPO_ROOT="$(cd "$HOOKS_DIR/.." && pwd)"
+TSX_IMPORT="$HOOKS_DIR/node_modules/tsx/dist/loader.mjs"
+TSX_BIN="$HOOKS_DIR/node_modules/.bin/tsx"
+
+if [ ! -f "$TSX_IMPORT" ]; then
+  TSX_IMPORT="tsx"
+fi
+
+node_version() {
+  node -v 2>/dev/null | sed 's/^v//'
+}
+
+node_version_major() {
+  node_version | cut -d. -f1
+}
+
+node_version_minor() {
+  node_version | cut -d. -f2
+}
+
+node_supports_import() {
+  major=$(node_version_major)
+  minor=$(node_version_minor)
+
+  if [ -z "$major" ] || [ -z "$minor" ]; then
+    return 1
+  fi
+
+  if [ "$major" -gt 20 ]; then
+    return 0
+  fi
+
+  if [ "$major" -eq 20 ] && [ "$minor" -ge 6 ]; then
+    return 0
+  fi
+
+  if [ "$major" -eq 19 ]; then
+    return 0
+  fi
+
+  if [ "$major" -eq 18 ] && [ "$minor" -ge 19 ]; then
+    return 0
+  fi
+
+  return 1
+}
+
+node_supports_loader() {
+  major=$(node_version_major)
+
+  if [ -z "$major" ]; then
+    return 1
+  fi
+
+  if [ "$major" -lt 18 ]; then
+    return 1
+  fi
+
+  ! node_supports_import
+}
+
+run_tsx() {
+  if node_supports_import; then
+    node --import "$TSX_IMPORT" "$@"
+    return
+  fi
+
+  if node_supports_loader; then
+    node --loader "$TSX_IMPORT" "$@"
+    return
+  fi
+
+  if [ -x "$TSX_BIN" ]; then
+    "$TSX_BIN" "$@"
+    return
+  fi
+
+  npx tsx "$@"
+}
 
 # Extract agent context if running under an AI agent
 # Capture stderr to detect whether an AI agent is present
-AGENT_OUTPUT=$(npx tsx "$HOOKS_DIR/agent-context/index.ts" "$REPO_ROOT" 2>&1) || true
+AGENT_OUTPUT=$(run_tsx "$HOOKS_DIR/agent-context/index.ts" "$REPO_ROOT" 2>&1) || true
 
 # Print the agent context to stderr so it still appears in the commit output
 if [ -n "$AGENT_OUTPUT" ]; then
@@ -19,7 +97,7 @@ fi
 # --- AI agent detected: run automated checks ---
 
 # Check for truncation violations in staged changes
-TRUNCATION_OUTPUT=$(npx tsx "$HOOKS_DIR/truncation-checker/index.ts" 2>&1)
+TRUNCATION_OUTPUT=$(run_tsx "$HOOKS_DIR/truncation-checker/index.ts" 2>&1)
 TRUNCATION_EXIT=$?
 
 if [ -n "$TRUNCATION_OUTPUT" ]; then

package/dist/assets/hooks/scripts/pre-push.sh

@@ -12,7 +12,7 @@ if [ -n "$current_branch" ] && [ "$current_branch" != "main" ] && [ "$current_br
       ;;
     *)
       # Check if this is an AI agent session (set by agent-context detector)
-      if [ -n "$HAYSTACK_AGENT_SESSION" ] || [ -n "$CLAUDE_CODE" ] || [ -n "$CODEX_CLI" ]; then
+      if [ -n "$HAYSTACK_AGENT_SESSION" ] || [ -n "$CLAUDE_CODE" ] || [ -n "$CODEX_CLI" ] || [ -n "$CODEX_SHELL" ] || [ -n "$CODEX_THREAD_ID" ] || [ -n "$CODEX_CI" ]; then
         echo ""
         echo "💡 Tip: Use 'haystack submit' to create PRs through the auto-merge queue."
         echo "   This enables automatic analysis and merge when approved."

package/dist/assets/skills/submit.md

@@ -22,6 +22,9 @@ This is faster than waiting for human review on every change.
 # Default: Submit to auto-merge queue
 haystack submit
 
+# Optional alpha auto-fix for straightforward mechanical issues
+haystack submit --auto-fix
+
 # Request Haystack review (for complex/risky changes)
 haystack submit --review
 
@@ -64,6 +67,22 @@ Use for straightforward changes that don't need human review:
 haystack submit
 ```
 
+### Auto-Fix (Alpha, Discouraged)
+
+> **Do NOT default to `--auto-fix`.** It is an alpha feature.
+> Use it only when the user explicitly wants to opt in, or when they are
+> comfortable using the sandbox fixer for clearly straightforward mechanical issues.
+
+Use `--auto-fix` only for issues like:
+
+- Missing null checks
+- Obvious typos or lint fixes
+- Simple deterministic bugs with one clear fix
+
+```bash
+haystack submit --auto-fix
+```
+
 ### Review Mode
 
 > **Do NOT use `--review` unless the user explicitly asks for human review.**
@@ -110,6 +129,7 @@ This uses GitHub device flow - no tokens to copy/paste.
 ## Important Notes
 
 - **Always use `haystack submit`** instead of `gh pr create` when working in Haystack-enabled repos
+- Prefer plain `haystack submit` by default; use `--auto-fix` only as an explicit alpha opt-in for straightforward mechanical issues
 - The command creates a `haystack/` prefixed branch automatically
 - Labels are applied automatically based on your chosen mode
 - You don't need to push manually - the command handles it

package/dist/commands/config.d.ts

@@ -11,6 +11,10 @@ export declare function handleAgenticTool(tool?: string): Promise<void>;
 /**
  * Check if auto-merge is enabled for the current repo.
  * Returns false if .haystack.json is missing or on error.
+ *
+ * NOTE: This does NOT go through loadHaystackConfig() because that function
+ * calls process.exit(1) when .haystack.json is missing — which is uncatchable
+ * by try/catch. We read the file directly so missing config safely returns false.
  */
 export declare function isAutoMergeEnabled(): Promise<boolean>;
 export declare function getAutoMergeStatus(): Promise<void>;

package/dist/commands/config.js

@@ -166,10 +166,17 @@ export async function handleAgenticTool(tool) {
 /**
  * Check if auto-merge is enabled for the current repo.
  * Returns false if .haystack.json is missing or on error.
+ *
+ * NOTE: This does NOT go through loadHaystackConfig() because that function
+ * calls process.exit(1) when .haystack.json is missing — which is uncatchable
+ * by try/catch. We read the file directly so missing config safely returns false.
  */
 export async function isAutoMergeEnabled() {
     try {
-        return getPreference('auto_merge');
+        const root = execSync('git rev-parse --show-toplevel', { encoding: 'utf-8' }).trim();
+        const raw = readFileSync(resolve(root, '.haystack.json'), 'utf-8');
+        const config = JSON.parse(raw);
+        return config.preferences?.auto_merge ?? false;
     }
     catch {
         return false;
@@ -288,16 +295,19 @@ export async function handleWaitForReviewers(action, reviewers) {
     // Default: show status
     if (!normalizedAction || normalizedAction === 'list' || normalizedAction === 'status') {
         const { bots } = getMergeQueueConfig();
-        console.log(chalk.bold('\nMerge queue — wait for reviewers\n'));
+        console.log(chalk.bold('\nWait for AI reviewers\n'));
         if (bots.length > 0) {
-            console.log('The merge queue will wait for ALL of these bots to post before merging:');
+            console.log('Haystack will wait for ALL of these bots to post before showing PRs in the inbox:');
             for (const bot of bots) {
                 console.log(`  ${chalk.green(displayName(bot))}`);
             }
+            console.log();
+            console.log(chalk.dim('Note: AI reviewers with check runs (CodeRabbit, Greptile, Cursor BugBot, etc.)'));
+            console.log(chalk.dim('are detected automatically. Only configure review-only bots here (e.g. Copilot).'));
         }
         else {
-            console.log('No external AI reviewers configured.');
-            console.log(chalk.dim('The merge queue will not wait for any external reviewers.'));
+            console.log('No review-only AI reviewers configured.');
+            console.log(chalk.dim('AI reviewers with check runs are still detected automatically.'));
         }
         console.log();
         printAvailableReviewers(bots);

package/dist/commands/install-session-hooks.d.ts

@@ -1,8 +1,9 @@
 /**
  * install-session-hooks — Wire up session-start hooks for coding CLIs.
  *
- * When a CLI session starts, `haystack check-pending --hook` runs automatically
- * and shows the user whether their pending PRs are "Good to merge" or "Need input".
+ * When a CLI session starts, `haystack triage --hook` runs automatically
+ * and shows the user whether their last submitted PR is "Good to merge" or
+ * "Needs input", with the Haystack rating and auto-fixer status.
  *
  * Supported CLIs:
  *   - Claude Code: Native SessionStart hook in .claude/settings.json