@adecore/agents 0.39.0 → 0.40.0

package/src/chat/chat-log.ts

@@ -22,20 +22,25 @@ const LineSchema = z.object({ seq: z.number().int().positive(), at: z.number(),
  */
 export function parseLog(raw: string): ChatLogLine[] {
     const lines: ChatLogLine[] = [];
+
     for (const text of raw.split('\n')) {
         if (text === '') {
             continue;
         }
+
         let parsed: ReturnType<typeof LineSchema.safeParse>;
+
         try {
             parsed = LineSchema.safeParse(JSON.parse(text));
         } catch {
             continue;
         }
+
         if (parsed.success && parsed.data.seq > (lines.at(-1)?.seq ?? 0)) {
             lines.push(parsed.data);
         }
     }
+
     return lines;
 }
 
@@ -72,6 +77,7 @@ export class ChatLog {
         const first = state.lines[0];
         // A log with a hole in front of it only answers from after the hole.
         this.base = first === undefined ? this.seqValue : first.seq - 1;
+
         for (let i = 1; i < state.lines.length; i++) {
             if (state.lines[i]!.seq !== state.lines[i - 1]!.seq + 1) {
                 this.base = state.lines[i - 1]!.seq;
@@ -102,12 +108,15 @@ export class ChatLog {
     append(event: ChatEvent, at: number): number {
         this.seqValue += 1;
         const line: ChatLogLine = { seq: this.seqValue, at, event };
+
         if (event.type === 'reset') {
             this.resetSeqValue = line.seq;
         }
+
         const text = `${JSON.stringify(line)}\n`;
         this.lines.push(line);
         this.bytes += Buffer.byteLength(text);
+
         if (this.path !== null) {
             try {
                 this.fd ??= this.open(this.path);
@@ -118,6 +127,7 @@ export class ChatLog {
                 console.error(`Appending to ${this.path} failed:`, errorText(e));
             }
         }
+
         return line.seq;
     }
 
@@ -130,6 +140,7 @@ export class ChatLog {
         if (since < this.resetSeqValue || since < this.base || since > this.seqValue) {
             return null;
         }
+
         return this.lines.filter((line) => line.seq > since).map((line) => line.event);
     }
 
@@ -143,20 +154,25 @@ export class ChatLog {
         if (seq <= this.base) {
             return;
         }
+
         this.lines = this.lines.filter((line) => line.seq > seq);
         this.base = seq;
         const text = this.lines.map((line) => `${JSON.stringify(line)}\n`).join('');
         this.bytes = Buffer.byteLength(text);
+
         if (this.path === null) {
             return;
         }
+
         this.close();
+
         try {
             if (text === '') {
                 rmSync(this.path, { force: true });
             } else {
                 writeAtomicSync(this.path, text);
             }
+
             this.written = true;
         } catch (e) {
             console.error(`Compacting ${this.path} failed:`, errorText(e));
@@ -175,13 +191,16 @@ export class ChatLog {
         mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
         const fd = openSync(path, 'a+', 0o600);
         const { size } = fstatSync(fd);
+
         if (size > 0) {
             const last = Buffer.alloc(1);
             readSync(fd, last, 0, 1, size - 1);
+
             if (last[0] !== 0x0a) {
                 writeSync(fd, '\n');
             }
         }
+
         return fd;
     }
 }

package/src/chat/chat-process.ts

@@ -35,10 +35,13 @@ const STDOUT_DRAIN_MS = 250;
 
 export function spawnChatProcess(options: ChatSpawnOptions): ChatProcess {
     const [command, ...args] = options.command;
+
     if (command === undefined) {
         throw new Error('No command to start');
     }
+
     const target = spawnTarget(command, args, { env: options.env });
+
     const child = spawn(target.file, target.args, {
         cwd: options.cwd,
         env: options.env,
@@ -49,13 +52,17 @@ export function spawnChatProcess(options: ChatSpawnOptions): ChatProcess {
         detached: process.platform !== 'win32',
         windowsHide: true
     });
+
     // Node reports a missing executable as an event after the call; a start that failed says so on the spot.
     child.on('error', () => undefined);
     const pid = child.pid;
+
     if (pid === undefined) {
         throw new Error(`Could not start ${command}: no such executable`);
     }
+
     child.stdin.on('error', (error) => options.onError?.(error));
+
     child.on('exit', (exitCode, signal) => {
         // The last lines may still be on their way through the pipe; they belong before the exit.
         const report = (): void => {
@@ -63,13 +70,18 @@ export function spawnChatProcess(options: ChatSpawnOptions): ChatProcess {
             child.stdout.off('end', report);
             setImmediate(() => options.onExit(exitCode, signal));
         };
+
         const timer = setTimeout(report, STDOUT_DRAIN_MS);
+
         if (child.stdout.readableEnded) {
             report();
+
             return;
         }
+
         child.stdout.once('end', report);
     });
+
     return {
         pid,
         stdin: {
@@ -92,10 +104,13 @@ export interface ProcessTreeKillOptions {
 /* Signals a process and everything it started. Windows has no process groups and no SIGTERM, so there the tree is ended at once. */
 export function killProcessTree(pid: number, signal: 'SIGTERM' | 'SIGKILL', options: ProcessTreeKillOptions = {}): void {
     const { platform = process.platform, kill = process.kill, run = runQuietly } = options;
+
     if (platform === 'win32') {
         run(['taskkill', '/pid', String(pid), '/t', '/f']);
+
         return;
     }
+
     try {
         kill(-pid, signal);
     } catch {
@@ -107,6 +122,7 @@ function runQuietly([command, ...args]: string[]): void {
     if (command === undefined) {
         return;
     }
+
     const child = spawn(command, args, { stdio: 'ignore', windowsHide: true });
     // A tree that already ended makes taskkill fail, which is what the caller wanted anyway.
     child.on('error', () => undefined);
@@ -115,7 +131,7 @@ function runQuietly([command, ...args]: string[]): void {
 // After stdin closed, a CLI that is still around is not going to say more.
 const EXIT_GRACE_MS = 3000;
 // What a CLI and everything it started get between the SIGTERM and the SIGKILL.
-const KILL_GRACE_MS = 2000;
+export const KILL_GRACE_MS = 2000;
 // How long a crash note waits for the last of stderr; a process the CLI started may hold the pipe open.
 const STDERR_DRAIN_MS = 250;
 // A pipe nobody reads is buffered in memory for as long as the CLI lives, so stderr is read into this much and no more.
@@ -140,19 +156,24 @@ export class StreamTail {
             .map((line) => line.trimEnd())
             .filter((line) => line.trim() !== '')
             .slice(-NOTE_TAIL_LINES);
+
         const tail = lines.join('\n').slice(-NOTE_TAIL_CHARS);
+
         return tail === '' ? null : tail;
     }
 
     private async read(stream: ReadableStream<Uint8Array>): Promise<void> {
         const reader = stream.getReader();
         const decoder = new TextDecoder();
+
         try {
             while (true) {
                 const { value, done } = await reader.read();
+
                 if (done) {
                     break;
                 }
+
                 this.text = (this.text + decoder.decode(value, { stream: true })).slice(-STDERR_TAIL_CHARS);
             }
         } catch {
@@ -186,21 +207,26 @@ export class LineSplitter {
     push(text: string): void {
         let start = 0;
         let newline = text.indexOf('\n');
+
         while (newline >= 0) {
             this.add(text.slice(start, newline));
             const line = this.take();
+
             if (line !== null) {
                 this.onLine(line);
             }
+
             start = newline + 1;
             newline = text.indexOf('\n', start);
         }
+
         this.add(text.slice(start));
     }
 
     /* Hands on what came after the last line break, for a stream that ended without one. */
     end(): void {
         const line = this.take();
+
         if (line !== null && line !== '') {
             this.onLine(line);
         }
@@ -210,13 +236,17 @@ export class LineSplitter {
         if (this.dropping || piece === '') {
             return;
         }
+
         this.length += piece.length;
+
         if (this.length > this.max) {
             this.parts = [];
             this.dropping = true;
             this.onOverflow();
+
             return;
         }
+
         this.parts.push(piece);
     }
 
@@ -225,6 +255,7 @@ export class LineSplitter {
         this.parts = [];
         this.length = 0;
         this.dropping = false;
+
         return line;
     }
 }
@@ -242,14 +273,18 @@ export async function readStreamLines(
     const reader = stream.getReader();
     const decoder = new TextDecoder();
     const lines = new LineSplitter(onLine, onOverflow, max);
+
     try {
         while (true) {
             const { value, done } = await reader.read();
+
             if (done) {
                 break;
             }
+
             lines.push(decoder.decode(value, { stream: true }));
         }
+
         lines.end();
     } finally {
         reader.releaseLock();
@@ -278,10 +313,13 @@ export class ChatChild {
 
     constructor(options: ChatChildOptions) {
         let settle: () => void = () => undefined;
+
         this.exited = new Promise((resolve) => {
             settle = resolve;
         });
+
         const spawn = options.spawn ?? spawnChatProcess;
+
         this.process = spawn({
             command: options.command,
             cwd: options.cwd,
@@ -294,6 +332,7 @@ export class ChatChild {
                 void this.report(exitCode, signal, options.onExit);
             }
         });
+
         this.tail = this.process.stderr ? new StreamTail(this.process.stderr) : null;
     }
 
@@ -306,31 +345,38 @@ export class ChatChild {
         if (this.hasExited || this.graceTimer !== null || this.ending !== null) {
             return;
         }
+
         this.graceTimer = setTimeout(() => {
             this.graceTimer = null;
             void this.end();
         }, EXIT_GRACE_MS);
+
         this.graceTimer.unref?.();
     }
 
     /* SIGTERM to the group now and SIGKILL after the grace; settles once the CLI exited or was sent the SIGKILL. */
     end(): Promise<void> {
         this.clearGrace();
+
         if (this.hasExited) {
             return Promise.resolve();
         }
+
         if (this.ending === null) {
             this.process.kill('SIGTERM');
+
             this.ending = new Promise((resolve) => {
                 // Sent even when the CLI left in time: what it started may still be shutting down, or ignoring the SIGTERM.
                 const timer = setTimeout(() => {
                     this.process.kill('SIGKILL');
                     resolve();
                 }, KILL_GRACE_MS);
+
                 timer.unref?.();
                 void this.exited.then(resolve);
             });
         }
+
         return this.ending;
     }
 
@@ -344,16 +390,21 @@ export class ChatChild {
     private async report(exitCode: number | null, signal: string | null, onExit: ChatChildOptions['onExit']): Promise<void> {
         if (exitCode === null || exitCode === 0 || this.tail === null) {
             onExit(exitCode, null, signal);
+
             return;
         }
+
         let release: () => void = () => undefined;
+
         const timer = setTimeout(() => release(), STDERR_DRAIN_MS);
+
         await Promise.race([
             this.tail.done,
             new Promise<void>((resolve) => {
                 release = resolve;
             })
         ]);
+
         clearTimeout(timer);
         onExit(exitCode, this.tail.lines(), signal);
     }