@haystackeditor/cli 0.25.1 → 0.26.0

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

@@ -1,316 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import * as crypto from 'crypto';
-import type { DetectionResult, AgentType } from './types.js';
-
-const STALENESS_MINUTES = parseInt(
-  process.env.AGENT_CONTEXT_STALENESS_MINUTES ?? '5',
-  10,
-);
-
-export function sanitizePath(absPath: string): string {
-  return absPath.replace(/[^a-zA-Z0-9]/g, '-');
-}
-
-function sha256(input: string): string {
-  return crypto.createHash('sha256').update(input).digest('hex');
-}
-
-function isRecent(filePath: string): boolean {
-  try {
-    const stat = fs.statSync(filePath);
-    const ageMs = Date.now() - stat.mtimeMs;
-    return ageMs < STALENESS_MINUTES * 60 * 1000;
-  } catch {
-    return false;
-  }
-}
-
-function findMostRecentFile(dir: string, pattern: RegExp): string | null {
-  if (!fs.existsSync(dir)) return null;
-
-  let entries: fs.Dirent[];
-  try {
-    entries = fs.readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return null;
-  }
-
-  let bestPath: string | null = null;
-  let bestMtime = 0;
-
-  for (const entry of entries) {
-    if (!entry.isFile() || !pattern.test(entry.name)) continue;
-    const fullPath = path.join(dir, entry.name);
-    try {
-      const stat = fs.statSync(fullPath);
-      if (stat.mtimeMs > bestMtime) {
-        bestMtime = stat.mtimeMs;
-        bestPath = fullPath;
-      }
-    } catch {
-      continue;
-    }
-  }
-
-  return bestPath;
-}
-
-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.HAYSTACK_TEST_CODEX_SESSION_DIR;
-  if (overrideDir) return [overrideDir];
-
-  const codexHome =
-    process.env.HAYSTACK_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.HAYSTACK_TEST_CLAUDE_PROJECT_DIR;
-  const sessionDir =
-    overrideDir ||
-    path.join(os.homedir(), '.claude', 'projects', sanitizePath(repoPath));
-
-  const sessionFile = findMostRecentFile(sessionDir, /\.jsonl$/);
-  if (!sessionFile || !isRecent(sessionFile)) {
-    return { detected: false };
-  }
-
-  return {
-    detected: true,
-    agent: 'claude-code',
-    sessionFilePath: sessionFile,
-    sessionId: extractSessionId(sessionFile, '.jsonl'),
-  };
-}
-
-function detectGemini(repoPath: string): DetectionResult {
-  const overrideDir = process.env.HAYSTACK_TEST_GEMINI_PROJECT_DIR;
-  const projectHash = sha256(repoPath);
-  const sessionDir =
-    overrideDir ||
-    path.join(os.homedir(), '.gemini', 'tmp', projectHash, 'chats');
-
-  const sessionFile = findMostRecentFile(sessionDir, /^session-.*\.json$/);
-  if (!sessionFile || !isRecent(sessionFile)) {
-    return { detected: false };
-  }
-
-  return {
-    detected: true,
-    agent: 'gemini-cli',
-    sessionFilePath: sessionFile,
-    sessionId: extractSessionId(sessionFile, '.json'),
-  };
-}
-
-function detectOpenCode(repoPath: string): DetectionResult {
-  const overrideDir = process.env.HAYSTACK_TEST_OPENCODE_PROJECT_DIR;
-  const sessionDir =
-    overrideDir ||
-    path.join(os.tmpdir(), 'haystack-opencode', sanitizePath(repoPath));
-
-  const sessionFile = findMostRecentFile(sessionDir, /\.json$/);
-  if (!sessionFile || !isRecent(sessionFile)) {
-    return { detected: false };
-  }
-
-  return {
-    detected: true,
-    agent: 'opencode',
-    sessionFilePath: sessionFile,
-    sessionId: extractSessionId(sessionFile, '.json'),
-  };
-}
-
-function detectCodex(repoPath: string): DetectionResult {
-  const overrideFile = process.env.HAYSTACK_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,
-];
-
-export async function detectAgent(
-  repoPath: string,
-): Promise<DetectionResult> {
-  for (const detect of detectors) {
-    const result = detect(repoPath);
-    if (result.detected) return result;
-  }
-  return { detected: false };
-}

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

@@ -1,100 +0,0 @@
-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',
-};
-
-// intentional: truncation for display formatting in hook output, not LLM context
-function truncate(text: string, maxLen: number): string {
-  if (text.length <= maxLen) return text;
-  return text.slice(0, maxLen) + '...';
-}
-
-function formatNumber(n: number): string {
-  return n.toLocaleString('en-US');
-}
-
-function formatTurnSummary(turn: InteractionTurn): string {
-  const role = turn.role.toUpperCase();
-  const content = truncate(turn.content.replace(/\n/g, ' '), 200);
-  const toolNames = turn.toolUses.map((t) => t.toolName);
-  const toolSuffix = toolNames.length > 0 ? ` [tools: ${toolNames.join(', ')}]` : '';
-  return `  [${turn.turnIndex + 1}] ${role}: ${content}${toolSuffix}`;
-}
-
-function formatHuman(ctx: AgentContext): string {
-  const lines: string[] = [];
-
-  lines.push('========================================');
-  lines.push('  AGENT CONTEXT DETECTED');
-  lines.push('========================================');
-  lines.push(`Agent:       ${AGENT_DISPLAY_NAMES[ctx.agent] || ctx.agent}`);
-  lines.push(`Session ID:  ${ctx.sessionId}`);
-
-  if (ctx.metadata.model) {
-    lines.push(`Model:       ${ctx.metadata.model}`);
-  }
-  if (ctx.metadata.version) {
-    lines.push(`Version:     ${ctx.metadata.version}`);
-  }
-  if (ctx.metadata.gitBranch) {
-    lines.push(`Git Branch:  ${ctx.metadata.gitBranch}`);
-  }
-  if (ctx.metadata.startedAt) {
-    lines.push(`Started At:  ${ctx.metadata.startedAt}`);
-  }
-
-  lines.push('');
-  lines.push('Task Prompt:');
-  lines.push(`  ${truncate(ctx.taskPrompt.replace(/\n/g, ' '), 500)}`);
-
-  lines.push('');
-  lines.push(`Modified Files (${ctx.modifiedFiles.length}):`);
-  if (ctx.modifiedFiles.length === 0) {
-    lines.push('  (none)');
-  } else {
-    for (const f of ctx.modifiedFiles) {
-      // Find which tools modified this file
-      const tools = new Set<string>();
-      for (const turn of ctx.transcript) {
-        for (const mf of turn.modifiedFiles) {
-          if (mf.filePath === f) tools.add(mf.toolName);
-        }
-      }
-      lines.push(`  - ${f} (${Array.from(tools).join(', ')})`);
-    }
-  }
-
-  lines.push('');
-  lines.push('Token Usage:');
-  lines.push(
-    `  Input:  ${formatNumber(ctx.tokenUsage.inputTokens)}  Output: ${formatNumber(ctx.tokenUsage.outputTokens)}`,
-  );
-  if (ctx.tokenUsage.cacheCreationTokens || ctx.tokenUsage.cacheReadTokens) {
-    lines.push(
-      `  Cache Creation: ${formatNumber(ctx.tokenUsage.cacheCreationTokens || 0)}  Cache Read: ${formatNumber(ctx.tokenUsage.cacheReadTokens || 0)}`,
-    );
-  }
-
-  lines.push('');
-  lines.push(`Transcript (${ctx.transcript.length} turns):`);
-  for (const turn of ctx.transcript) {
-    lines.push(formatTurnSummary(turn));
-  }
-
-  lines.push('========================================');
-  return lines.join('\n');
-}
-
-function formatJson(ctx: AgentContext): string {
-  return JSON.stringify(ctx, null, 2);
-}
-
-export function formatContext(ctx: AgentContext): string {
-  const mode = process.env.AGENT_CONTEXT_FORMAT || 'human';
-  if (mode === 'json') return formatJson(ctx);
-  return formatHuman(ctx);
-}

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

@@ -1,41 +0,0 @@
-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';
-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(),
-};
-
-async function main() {
-  const repoRoot = process.argv[2] || process.cwd();
-
-  const detection = await detectAgent(repoRoot);
-
-  if (!detection.detected || !detection.agent || !detection.sessionFilePath) {
-    if (process.env.AGENT_CONTEXT_VERBOSE) {
-      console.error('[agent-context] No AI agent session detected.');
-    }
-    return;
-  }
-
-  const parser = PARSERS[detection.agent];
-  if (!parser) {
-    console.error(`[agent-context] No parser for agent: ${detection.agent}`);
-    return;
-  }
-
-  const context = await parser.parse(detection.sessionFilePath, repoRoot);
-  const output = formatContext(context);
-  console.error(output);
-}
-
-main().catch((err) => {
-  console.error(`[agent-context] Error: ${err.message}`);
-});

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

@@ -1,262 +0,0 @@
-import * as fs from 'fs';
-import type {
-  AgentContext,
-  AgentParser,
-  DetectionResult,
-  InteractionTurn,
-  ModifiedFile,
-  TokenUsage,
-  ToolUseInfo,
-} from '../types.js';
-import { detectAgent } from '../detect.js';
-
-const FILE_MOD_TOOLS = new Set([
-  'Write',
-  'Edit',
-  'NotebookEdit',
-  'mcp__acp__Write',
-  'mcp__acp__Edit',
-]);
-
-interface ClaudeLine {
-  type?: string;
-  sessionId?: string;
-  version?: string;
-  gitBranch?: string;
-  uuid?: string;
-  timestamp?: string;
-  // Old format: message wrapper with role/content/usage
-  message?: {
-    id?: string;
-    model?: string;
-    role?: string;
-    content?: unknown;
-    usage?: {
-      input_tokens?: number;
-      output_tokens?: number;
-      cache_creation_input_tokens?: number;
-      cache_read_input_tokens?: number;
-    };
-  };
-  // Alternate format: id/content at top level (type is the role)
-  id?: string;
-  content?: unknown;
-}
-
-interface ContentBlock {
-  type?: string;  // Optional: new format blocks may omit type
-  text?: string;
-  thinking?: string;
-  name?: string;
-  id?: string;
-  input?: Record<string, unknown>;
-}
-
-function parseLines(raw: string): ClaudeLine[] {
-  const lines: ClaudeLine[] = [];
-  for (const line of raw.split('\n')) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    try {
-      lines.push(JSON.parse(trimmed));
-    } catch {
-      // Skip unparseable lines (e.g. partial write from concurrent agent)
-    }
-  }
-  return lines;
-}
-
-function extractTextContent(content: unknown): string {
-  if (typeof content === 'string') return content;
-  if (!Array.isArray(content)) return '';
-
-  const parts: string[] = [];
-  for (const block of content as ContentBlock[]) {
-    // Support both old ({type: "text", text}) and new ({id, text}) content blocks
-    if (block.text && (block.type === 'text' || !block.type)) {
-      parts.push(block.text);
-    }
-  }
-  return parts.join('\n');
-}
-
-function extractModifiedFiles(content: unknown): ModifiedFile[] {
-  if (!Array.isArray(content)) return [];
-  const files: ModifiedFile[] = [];
-
-  for (const block of content as ContentBlock[]) {
-    if (block.type !== 'tool_use' || !block.name) continue;
-    if (!FILE_MOD_TOOLS.has(block.name)) continue;
-
-    const filePath =
-      (block.input?.file_path as string) ||
-      (block.input?.path as string) ||
-      (block.input?.notebook_path as string);
-    if (filePath) {
-      files.push({
-        filePath,
-        toolName: block.name,
-        toolUseId: block.id,
-      });
-    }
-  }
-  return files;
-}
-
-function extractToolUses(content: unknown): ToolUseInfo[] {
-  if (!Array.isArray(content)) return [];
-  const tools: ToolUseInfo[] = [];
-
-  for (const block of content as ContentBlock[]) {
-    if (block.type !== 'tool_use' || !block.name) continue;
-    tools.push({
-      toolName: block.name,
-      toolUseId: block.id || '',
-      input: sanitizeInput(block.input || {}),
-    });
-  }
-  return tools;
-}
-
-// intentional: sanitize tool input for display in hook output, not LLM context
-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' && value.length > 200) {
-      sanitized[key] = value.slice(0, 200) + '... (truncated)';
-    } else {
-      sanitized[key] = value;
-    }
-  }
-  return sanitized;
-}
-
-export class ClaudeParser 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 allLines = parseLines(raw);
-
-    // Filter to user and assistant lines only
-    const userLines = allLines.filter((l) => l.type === 'user');
-    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 || line.id;
-      if (msgId) {
-        dedupedAssistant.set(msgId, line);
-      }
-    }
-    const uniqueAssistant = Array.from(dedupedAssistant.values());
-
-    // Build transcript turns
-    const transcript: InteractionTurn[] = [];
-    let turnIndex = 0;
-
-    // Interleave user and assistant messages by position
-    // User messages appear at even indices, assistant at odd
-    const maxTurns = Math.max(userLines.length, uniqueAssistant.length);
-    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(userContent),
-          modifiedFiles: [],
-          toolUses: [],
-        });
-      }
-      if (i < uniqueAssistant.length) {
-        const asst = uniqueAssistant[i];
-        // 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++,
-          role: 'assistant',
-          content: extractTextContent(content),
-          modifiedFiles: extractModifiedFiles(content),
-          tokenUsage: usage
-            ? {
-                inputTokens: usage.input_tokens || 0,
-                outputTokens: usage.output_tokens || 0,
-                cacheCreationTokens: usage.cache_creation_input_tokens,
-                cacheReadTokens: usage.cache_read_input_tokens,
-              }
-            : undefined,
-          toolUses: extractToolUses(content),
-        });
-      }
-    }
-
-    // Task prompt: first user message where content is a plain string
-    // (not a tool_result array) and not a system instruction injected by the host
-    let taskPrompt = '';
-    for (const user of userLines) {
-      const content = user.message?.content;
-      if (typeof content !== 'string') continue;
-      if (content.startsWith('<system_instruction>') || content.startsWith('<system-')) continue;
-      taskPrompt = content;
-      break;
-    }
-
-    // Aggregate token usage
-    const totalUsage: TokenUsage = {
-      inputTokens: 0,
-      outputTokens: 0,
-      cacheCreationTokens: 0,
-      cacheReadTokens: 0,
-    };
-    for (const asst of uniqueAssistant) {
-      const usage = asst.message?.usage;
-      if (usage) {
-        totalUsage.inputTokens += usage.input_tokens || 0;
-        totalUsage.outputTokens += usage.output_tokens || 0;
-        totalUsage.cacheCreationTokens! += usage.cache_creation_input_tokens || 0;
-        totalUsage.cacheReadTokens! += usage.cache_read_input_tokens || 0;
-      }
-    }
-
-    // Collect all modified files (deduplicated)
-    const allModifiedFiles = new Set<string>();
-    for (const turn of transcript) {
-      for (const f of turn.modifiedFiles) {
-        allModifiedFiles.add(f.filePath);
-      }
-    }
-
-    // Metadata from first lines
-    const firstUser = userLines[0];
-    const firstAssistant = uniqueAssistant[0];
-    const stat = fs.statSync(sessionFilePath);
-
-    return {
-      agent: 'claude-code',
-      sessionId: firstUser?.sessionId || '',
-      sessionFilePath,
-      taskPrompt,
-      modifiedFiles: Array.from(allModifiedFiles),
-      tokenUsage: totalUsage,
-      transcript,
-      metadata: {
-        model: firstAssistant?.message?.model,
-        version: firstUser?.version,
-        gitBranch: firstUser?.gitBranch,
-        startedAt: firstUser?.timestamp,
-        sessionFileModifiedAt: stat.mtime.toISOString(),
-      },
-    };
-  }
-}