@cyanautomation/kaseki-agent 1.4.1

package/src/pi-progress-stream.ts

@@ -0,0 +1,287 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import readline from 'readline';
+import { sanitizeToolName } from './progress-stream-utils.js';
+import {
+  formatProgressMessage,
+  EventSampler,
+  extractFilePath,
+  detectError,
+  formatElapsed,
+  truncate,
+} from './pi-progress-summarizer.js';
+import { ANSI_COLORS, stripAnsi } from './ansi-colors.js';
+
+interface EventCountMap {
+  [key: string]: number;
+}
+
+interface PiEvent {
+  type?: string;
+  event?: string;
+  name?: string;
+  kind?: string;
+  tool_name?: string;
+  toolName?: string;
+  tool?: { name: string };
+  call?: { name: string };
+  message?: { content?: any };
+}
+
+interface ProgressPayload {
+  timestamp: string;
+  updatedAt: string;
+  stage: string;
+  message: string;
+  percentComplete?: number;
+  summary?: string;
+  [key: string]: any;
+}
+
+const progressJsonlPath = process.argv[2] || '/results/progress.jsonl';
+const progressLogPath = process.argv[3] || '/results/progress.log';
+const streamToStdout = process.env.KASEKI_STREAM_PROGRESS !== '0';
+const enableSummarization = process.env.KASEKI_PROGRESS_SUMMARIZATION !== '0';
+
+const counts: EventCountMap = {};
+let toolStartCount = 0;
+let toolEndCount = 0;
+let messageUpdateCount = 0;
+let lastHeartbeat = 0;
+let streamOpen = true;
+const startTime = Date.now();
+
+// Sample 1 in every 15 message_update events
+const messageSampler = new EventSampler(15);
+
+function append(file: string, text: string): void {
+  fs.appendFileSync(file, text);
+}
+
+function eventType(event: PiEvent | any): string {
+  return event?.type || event?.event || event?.name || event?.kind || 'unknown';
+}
+
+function toolName(event: PiEvent | any): string {
+  const candidates = [
+    event?.tool_name,
+    event?.toolName,
+    event?.tool?.name,
+    event?.name,
+    event?.call?.name,
+  ];
+
+  for (const candidate of candidates) {
+    if (typeof candidate !== 'string') {
+      continue;
+    }
+    const sanitized = sanitizeToolLabel(candidate);
+    if (sanitized !== 'tool') {
+      return sanitized;
+    }
+  }
+
+  return 'tool';
+}
+
+function sanitizeToolLabel(value: string): string {
+  return sanitizeToolName(value);
+}
+
+function emit(stage: string, message: string, extra: Record<string, any> = {}): void {
+  const now = new Date().toISOString();
+  const payload: ProgressPayload = {
+    timestamp: now,
+    updatedAt: now,
+    stage,
+    message,
+    ...extra,
+  };
+
+  // For JSONL, strip ANSI codes
+  const cleanMessage = stripAnsi(message);
+  const cleanPayload = { ...payload, message: cleanMessage };
+
+  append(progressJsonlPath, `${JSON.stringify(cleanPayload)}\n`);
+  const line = `[progress] ${stage}: ${message}\n`;
+  append(progressLogPath, line);
+  if (streamToStdout) {
+    process.stdout.write(line);
+  }
+}
+
+function eventTotal(): number {
+  return Object.values(counts).reduce((sum, count) => sum + count, 0);
+}
+
+function maybeHeartbeat(force: boolean = false, reason: string = 'events'): void {
+  const now = Date.now();
+  if (!force && now - lastHeartbeat < 15000) {
+    return;
+  }
+  lastHeartbeat = now;
+
+  const elapsed = formatElapsed(startTime);
+  const workingMsg = `working; events=${eventTotal()}, tool starts=${toolStartCount}, tool ends=${toolEndCount}`;
+  const message = `${workingMsg} | ${ANSI_COLORS.DIM}${elapsed} elapsed${ANSI_COLORS.RESET}`;
+
+  emit('pi coding agent', message, {
+    counts,
+    toolStartCount,
+    toolEndCount,
+    messageUpdateCount,
+    reason,
+  });
+}
+
+/**
+ * Emit enhanced summary for tool execution
+ */
+function emitToolSummary(event: PiEvent, tool: string, isStart: boolean): void {
+  if (!enableSummarization) {
+    return;
+  }
+
+  const elapsed = formatElapsed(startTime);
+  const action = extractFilePath(tool) || tool;
+  const { hasError } = detectError(JSON.stringify(event).substring(0, 500));
+  const level = hasError ? ('error' as const) : undefined;
+
+  const message = formatProgressMessage(
+    'pi tool',
+    `${isStart ? 'start' : 'end'} ${action}`,
+    undefined,
+    level,
+    elapsed
+  );
+
+  if (message && message.length > 0) {
+    emit('pi tool', stripAnsi(message.substring(13)), { level });
+  }
+}
+
+/**
+ * Emit enhanced summary for message updates
+ */
+function emitMessageSummary(event: PiEvent): void {
+  if (!enableSummarization || !messageSampler.shouldEmit()) {
+    return;
+  }
+
+  const elapsed = formatElapsed(startTime);
+  // Try to extract a brief insight from the message
+  let detail: string | undefined;
+
+  if (event.message?.content) {
+    const content = event.message.content;
+    const contentText = Array.isArray(content)
+      ? content.map((c: any) => (c.text || c.content || '').substring(0, 50)).join(' ')
+      : String(content).substring(0, 100);
+
+    if (contentText.length > 10) {
+      detail = truncate(contentText, 60);
+    }
+  }
+
+  if (detail) {
+    const message = formatProgressMessage(
+      'pi coding agent',
+      'processing',
+      detail,
+      undefined,
+      elapsed
+    );
+
+    if (message && message.length > 0) {
+      emit('pi coding agent', stripAnsi(message.substring(13)), { type: 'message_update' });
+    }
+  }
+}
+
+emit('pi coding agent', 'started');
+const heartbeatTimer = setInterval(() => {
+  if (streamOpen) {
+    maybeHeartbeat(true, 'timer');
+  }
+}, 30000);
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  crlfDelay: Infinity,
+});
+
+rl.on('line', (line: string) => {
+  if (line.trim().length === 0) {
+    return;
+  }
+
+  let event: any;
+  try {
+    event = JSON.parse(line);
+  } catch {
+    counts.invalid_json = (counts.invalid_json || 0) + 1;
+    maybeHeartbeat();
+    return;
+  }
+
+  const type = eventType(event);
+  counts[type] = (counts[type] || 0) + 1;
+
+  if (type === 'tool_execution_start' || type === 'toolcall_start') {
+    const tool = toolName(event);
+    toolStartCount += 1;
+
+    const startMsg = `started ${tool}`;
+    emit('pi tool', startMsg, { type, toolStartCount });
+
+    if (enableSummarization) {
+      emitToolSummary(event, tool, true);
+    }
+  } else if (type === 'tool_execution_end' || type === 'toolcall_end') {
+    const tool = toolName(event);
+    toolEndCount += 1;
+
+    const endMsg = `finished ${tool}`;
+    emit('pi tool', endMsg, { type, toolEndCount });
+
+    if (enableSummarization) {
+      emitToolSummary(event, tool, false);
+    }
+  } else if (type === 'message_update') {
+    messageUpdateCount += 1;
+
+    if (enableSummarization) {
+      emitMessageSummary(event);
+    }
+  } else if (type === 'agent_start') {
+    messageSampler.reset();
+    emit('pi coding agent', 'agent started', { type });
+  } else if (type === 'agent_end') {
+    emit('pi coding agent', 'agent finished', { type });
+  } else if (type === 'auto_retry_start') {
+    emit(
+      'pi coding agent',
+      `${ANSI_COLORS.YELLOW}auto retry started${ANSI_COLORS.RESET}`,
+      { type }
+    );
+  } else if (type === 'auto_retry_end') {
+    emit('pi coding agent', 'auto retry finished', { type });
+  }
+
+  maybeHeartbeat();
+});
+
+rl.on('close', () => {
+  streamOpen = false;
+  clearInterval(heartbeatTimer);
+  maybeHeartbeat(true, 'close');
+
+  const finalElapsed = formatElapsed(startTime);
+  emit('pi coding agent', `event stream ended | ${ANSI_COLORS.DIM}${finalElapsed} total${ANSI_COLORS.RESET}`, {
+    counts,
+    toolStartCount,
+    toolEndCount,
+    messageUpdateCount,
+  });
+});

package/src/pi-progress-summarizer.test.ts

@@ -0,0 +1,302 @@
+import { describe, it, expect } from '@jest/globals';
+import { ANSI_COLORS } from '../src/ansi-colors';
+import {
+  extractFilePath,
+  extractDecision,
+  detectError,
+  summarizeEvent,
+  formatElapsed,
+  truncate,
+  formatProgressMessage,
+  EventSampler,
+} from '../src/pi-progress-summarizer';
+
+describe('pi-progress-summarizer', () => {
+  describe('extractFilePath', () => {
+    it('extracts path from read_file tool', () => {
+      const result = extractFilePath('read_file', 'reading /workspaces/kaseki-agent/src/parser.ts');
+      expect(result).toMatch(/src\/parser/);
+    });
+
+    it('extracts path from grep_search tool', () => {
+      const result = extractFilePath('grep_search', 'searching in src/handlers.ts');
+      expect(result).toMatch(/handlers/);
+    });
+
+    it('shortens absolute paths', () => {
+      const result = extractFilePath('write_file', 'write /workspaces/kaseki-agent/src/index.ts');
+      expect(result).toMatch(/src\/index/);
+      expect(result).not.toMatch(/workspaces/);
+    });
+
+    it('handles relative paths when content is provided', () => {
+      const result = extractFilePath('read_file', './lib/utils.ts');
+      expect(result).toBe('lib/utils.ts');
+    });
+
+    it('maps tool names to operations when no path in content', () => {
+      expect(extractFilePath('bash')).toBe('bash');
+      expect(extractFilePath('grep')).toBe('grep');
+      expect(extractFilePath('ls')).toBe('ls');
+    });
+
+    it('returns null for unknown tools without content', () => {
+      expect(extractFilePath('unknown_tool')).toBeNull();
+    });
+
+    it('truncates long paths with ellipsis', () => {
+      const longPath = '/workspaces/kaseki-agent/src/deeply/nested/folder/structure/index.ts';
+      const result = extractFilePath('read_file', longPath);
+      if (result) {
+        expect(result.length).toBeLessThanOrEqual(40);
+        if (result.includes('…')) {
+          expect(result).toMatch(/…\//);
+        }
+      }
+    });
+  });
+
+  describe('extractDecision', () => {
+    it('detects decision keywords in content', () => {
+      expect(extractDecision('I will create a new file')).toContain('create');
+      expect(extractDecision('Let me fix this bug')).toContain('fix');
+      expect(extractDecision('I need to modify the handler')).toContain('modify');
+    });
+
+    it('returns null for content without keywords', () => {
+      expect(extractDecision('This is just some information')).toBeNull();
+      expect(extractDecision('I am reading the file')).toBeNull();
+    });
+
+    it('returns null for empty content', () => {
+      expect(extractDecision('')).toBeNull();
+      expect(extractDecision(undefined)).toBeNull();
+    });
+
+    it('extracts context around keyword', () => {
+      const result = extractDecision('Now I will implement the parser with error handling');
+      expect(result).toBeTruthy();
+      if (result) {
+        expect(result).toContain('implement');
+      }
+    });
+
+    it('handles case-insensitive matching', () => {
+      expect(extractDecision('I WILL CREATE a new module')).toContain('CREATE');
+      expect(extractDecision('FiX the parser')).toContain('FiX');
+    });
+  });
+
+  describe('detectError', () => {
+    it('detects error patterns in content', () => {
+      const result = detectError('Error: Cannot read property');
+      expect(result.hasError).toBe(true);
+      expect(result.snippet).toContain('Error');
+    });
+
+    it('detects failure patterns', () => {
+      const result = detectError('Test FAILED: assertion failed');
+      expect(result.hasError).toBe(true);
+    });
+
+    it('detects exit code errors', () => {
+      const result = detectError('Process exited with code 1');
+      expect(result.hasError).toBe(true);
+    });
+
+    it('returns false for successful content', () => {
+      const result = detectError('Successfully created file index.ts');
+      expect(result.hasError).toBe(false);
+    });
+
+    it('returns false for empty content', () => {
+      expect(detectError('').hasError).toBe(false);
+      expect(detectError(undefined).hasError).toBe(false);
+    });
+
+    it('extracts context snippet around error', () => {
+      const result = detectError('Some output before the actual Error: something bad happened here');
+      expect(result.snippet).toBeTruthy();
+      if (result.snippet) {
+        expect(result.snippet).toContain('Error');
+      }
+    });
+  });
+
+  describe('formatElapsed', () => {
+    it('formats seconds only for times under 60s', () => {
+      const now = Date.now();
+      const elapsed = formatElapsed(now - 30000); // 30 seconds
+      expect(elapsed).toBe('30s');
+    });
+
+    it('formats minutes and seconds', () => {
+      const now = Date.now();
+      const elapsed = formatElapsed(now - 125000); // 2m 5s
+      expect(elapsed).toMatch(/\dm \ds/);
+    });
+
+    it('formats longer durations', () => {
+      const now = Date.now();
+      const elapsed = formatElapsed(now - 605000); // 10m 5s
+      expect(elapsed).toBe('10m 5s');
+    });
+  });
+
+  describe('truncate', () => {
+    it('returns text as-is if within limit', () => {
+      const text = 'short text';
+      expect(truncate(text, 20)).toBe(text);
+    });
+
+    it('truncates text exceeding limit', () => {
+      const text = 'This is a very long text that exceeds the limit';
+      const result = truncate(text, 20);
+      expect(result.length).toBeLessThanOrEqual(20);
+      expect(result).toContain('…');
+    });
+
+    it('handles undefined input', () => {
+      expect(truncate(undefined, 20)).toBe('');
+    });
+
+    it('uses default max length of 100', () => {
+      const text = 'a'.repeat(150);
+      const result = truncate(text);
+      expect(result.length).toBeLessThanOrEqual(100);
+    });
+  });
+
+  describe('formatProgressMessage', () => {
+    it('formats basic message with stage and action', () => {
+      const msg = formatProgressMessage('pi tool', 'read parser.ts');
+      expect(msg).toContain('[progress]');
+      expect(msg).toContain('pi tool');
+      expect(msg).toContain('read parser.ts');
+    });
+
+    it('includes detail when provided', () => {
+      const msg = formatProgressMessage('pi tool', 'read parser.ts', 'checking structure');
+      expect(msg).toContain('checking structure');
+    });
+
+    it('includes elapsed time when provided', () => {
+      const msg = formatProgressMessage('pi tool', 'read parser.ts', undefined, undefined, '1m 23s');
+      expect(msg).toContain('1m 23s');
+    });
+
+    it('applies color for error level if available', () => {
+      const msg = formatProgressMessage('pi tool', 'bash npm test', undefined, 'error');
+      // When not in TTY, ANSI_COLORS will be empty, so just verify message structure
+      expect(msg).toContain('[progress]');
+      expect(msg).toContain('bash npm test');
+      // If colors are available, they should be included
+      if (ANSI_COLORS.RED !== '') {
+        expect(msg).toContain('\x1b[31m');
+      }
+    });
+
+    it('applies color for warn level if available', () => {
+      const msg = formatProgressMessage('pi tool', 'auto retry', undefined, 'warn');
+      expect(msg).toContain('[progress]');
+      expect(msg).toContain('auto retry');
+      // If colors are available, they should be included
+      if (ANSI_COLORS.YELLOW !== '') {
+        expect(msg).toContain('\x1b[33m');
+      }
+    });
+
+    it('has no color for info level', () => {
+      const msg = formatProgressMessage('pi tool', 'read file', undefined, 'info');
+      // Should not have color codes for info level (colors are optional for info)
+      // Just verify it doesn't crash
+      expect(msg).toContain('[progress]');
+    });
+  });
+
+  describe('EventSampler', () => {
+    it('emits at configured rate', () => {
+      const sampler = new EventSampler(5); // Emit every 5th event
+      expect(sampler.shouldEmit()).toBe(false);
+      expect(sampler.shouldEmit()).toBe(false);
+      expect(sampler.shouldEmit()).toBe(false);
+      expect(sampler.shouldEmit()).toBe(false);
+      expect(sampler.shouldEmit()).toBe(true); // 5th event
+    });
+
+    it('resets counter on reset()', () => {
+      const sampler = new EventSampler(3);
+      sampler.shouldEmit();
+      sampler.shouldEmit();
+      sampler.shouldEmit(); // 3rd event would be true
+      sampler.reset();
+      expect(sampler.shouldEmit()).toBe(false); // Counter reset
+    });
+
+    it('defaults to rate of 10', () => {
+      const sampler = new EventSampler();
+      let emitCount = 0;
+      for (let i = 0; i < 50; i++) {
+        if (sampler.shouldEmit()) emitCount++;
+      }
+      // Should emit 5 times out of 50 (rate 10)
+      expect(emitCount).toBe(5);
+    });
+
+    it('enforces minimum rate of 1 when given 0', () => {
+      const sampler = new EventSampler(0);
+      // With rate 1, every event is emitted
+      expect(sampler.shouldEmit()).toBe(true); // 1st event
+      expect(sampler.shouldEmit()).toBe(true); // 2nd event
+      expect(sampler.shouldEmit()).toBe(true); // 3rd event
+    });
+  });
+
+  describe('summarizeEvent', () => {
+    it('extracts file path from event', () => {
+      const event = {
+        tool_name: 'read_file',
+        message: { content: [{ text: '/src/parser.ts' }] },
+      };
+      const summary = summarizeEvent(event, 'read_file', Date.now() - 5000);
+      expect(summary).toBeTruthy();
+      if (summary && summary.action) {
+        expect(summary.action).toMatch(/read|parser/);
+      }
+    });
+
+    it('includes elapsed time', () => {
+      const event = { type: 'message_update' };
+      const startTime = Date.now() - 65000; // 65 seconds ago
+      const summary = summarizeEvent(event, 'agent', startTime);
+      expect(summary?.elapsed).toMatch(/1m/);
+    });
+
+    it('marks errors with error level', () => {
+      const event = {
+        type: 'tool_execution_end',
+        message: { content: [{ text: 'Error: failed to read file' }] },
+      };
+      const summary = summarizeEvent(event, 'read_file', Date.now() - 5000);
+      expect(summary?.level).toBe('error');
+    });
+
+    it('extracts decision keywords from content', () => {
+      const event = {
+        type: 'message_update',
+        message: {
+          content: [{ text: 'I will create a new file for the parser implementation' }],
+        },
+      };
+      const summary = summarizeEvent(event, 'agent', Date.now() - 5000);
+      expect(summary?.detail).toContain('create');
+    });
+
+    it('returns null for events with no extractable data', () => {
+      const event = { type: 'unknown' };
+      const summary = summarizeEvent(event, 'unknown_tool', Date.now() - 5000);
+      // Should return an object (elapsed is always added)
+      expect(summary).toBeTruthy();
+    });
+  });
+});