@yegor256/jinka 0.0.2 → 0.0.4

package/src/tty.js

@@ -1,49 +1,44 @@
 // SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
 // SPDX-License-Identifier: MIT
 
+import { stripVTControlCharacters } from 'node:util';
+import sliceAnsi from 'slice-ansi';
 import { Row } from './row.js';
 import { Duration } from './duration.js';
 
-/**
- * The screen for terminals, which takes over the whole terminal like top.
- * It switches to the alternate buffer and draws a fixed layout from the
- * top left corner: the status line, one line per wand with the time it
- * has been busy with its current wish, a separator, and the newest
- * protocol lines that fit below it. The layout is redrawn on every change,
- * every second, and on every resize, until the screen is closed and the
- * normal buffer comes back.
- */
 export class Tty {
-  constructor(stream, threads, status) {
+  constructor(stream, crew, status, legend) {
     this.stream = stream;
+    this.crew = crew;
     this.status = status;
-    this.lines = Array.from({ length: threads }, () => ({ head: '', tail: '', start: Date.now() }));
+    this.legend = legend;
+    this.lines = new Map();
     this.notes = [];
     this.clock = [];
   }
   row(index) {
     return new Row({ push: ([i, text]) => this.#update(i, text) }, index);
   }
-  protocol(index) {
-    return new Row({ push: ([i, text]) => this.#note(i, text) }, index);
+  notice() {
+    return new Row({ push: ([, text]) => this.#note(text) }, 0);
   }
   close() {
     this.clock.splice(0).forEach((c) => {
       clearInterval(c);
       this.stream.write('\x1b[?25h\x1b[?1049l');
+      this.stream.write(this.notes.map((n) => `${n}\n`).join(''));
     });
   }
   #update(index, text) {
     const [head, tail = ''] = text.split('\t');
-    this.lines[index] = {
-      head,
-      tail,
-      start: head === this.lines[index].head ? this.lines[index].start : Date.now()
-    };
+    const line = this.lines.get(index) ?? { head: '', start: Date.now() };
+    this.lines.set(index, { head, tail, start: head === line.head ? line.start : Date.now() });
     this.#paint();
   }
-  #note(index, text) {
-    this.notes.push(`${new Date().toTimeString().slice(0, 8)} [${index + 1}] ${text.replace('\t', '  ')}`);
+  #note(text) {
+    this.notes.push(
+      `${new Date().toTimeString().slice(0, 8)} ${text.replace(/https:\/\/github\.com\/([^/\s]+\/[^/\s]+)\/(?:issues|pull)\/(\d+)/g, (url, repo, number) => `\x1b]8;;${url}\x07\x1b[34m${repo}#${number}\x1b[39m\x1b]8;;\x07`)}`
+    );
     this.#paint();
   }
   #paint() {
@@ -59,17 +54,27 @@ export class Tty {
     this.#draw();
   }
   #draw() {
-    this.notes.splice(0, Math.max(0, this.notes.length - Math.max(0, (this.stream.rows || 24) - this.lines.length - 2)));
-    const width = Math.max(...this.lines.map((l) => l.head.length));
+    const rows = this.stream.rows || 24;
+    const lines = this.crew.indexes().map((i) => [i, this.lines.get(i) ?? { head: '', tail: '', start: Date.now() }]);
+    const width = Math.max(...lines.map(([, l]) => stripVTControlCharacters(l.head).length));
+    const columns = this.stream.columns || 80;
+    const notes = this.notes.flatMap((n) => this.#wrap(n, columns));
+    const top = [
+      this.status.text(),
+      '',
+      ...lines.map(([, l]) => `${l.head}${' '.repeat(width - stripVTControlCharacters(l.head).length)}  ${new Duration(Date.now() - l.start).minutes()}  ${l.tail}`),
+      '-'.repeat(10),
+      ...notes.slice(Math.max(0, notes.length - Math.max(0, rows - lines.length - 5)))
+    ];
     this.stream.write(
       `\x1b[H${
-        [
-          this.status.text(),
-          ...this.lines.map((l, i) => `[${i + 1}] ${l.head.padEnd(width)}  ${new Duration(Date.now() - l.start).minutes()}  ${l.tail}`),
-          '-'.repeat(10),
-          ...this.notes
-        ].map((l) => `\x1b[2K${l.slice(0, this.stream.columns || 80)}`).join('\n')
+        [...top, ...Array(Math.max(1, rows - top.length - 1)).fill(''), this.legend.text()]
+          .map((l) => `\x1b[2K${sliceAnsi(l, 0, columns)}\x1b[0m`)
+          .join('\n')
       }\x1b[J`
     );
   }
+  #wrap(text, width) {
+    return stripVTControlCharacters(text).length <= width || width < 3 ? [text] : [sliceAnsi(text, 0, width), ...this.#wrap(`  ${sliceAnsi(text, width)}`, width)];
+  }
 }

package/src/wand.js

@@ -1,15 +1,9 @@
 // SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
 // SPDX-License-Identifier: MIT
 
+import { styleText } from 'node:util';
 import { Duration } from './duration.js';
 
-/**
- * One loop that keeps making wishes come true until the signal aborts.
- * It takes the next free wish, shows it on its own screen row, runs the
- * agent on it, and closes the wish when the agent succeeds or frees it
- * for a later retry when the agent fails. Either way, it reports the
- * outcome and the time it took to the protocol of the screen.
- */
 export class Wand {
   constructor(wishes, agent, row, protocol) {
     this.wishes = wishes;
@@ -29,17 +23,18 @@ export class Wand {
     }
   }
   async #once(signal) {
-    this.row.show('idle\twaiting for wishes');
+    this.row.show(`${styleText('gray', 'idle', { validateStream: false })}\t${styleText('gray', 'waiting for wishes', { validateStream: false })}`);
     const wish = await this.wishes.next(signal);
     this.row.show(`${wish.name()}\tstarting the agent`);
     const start = Date.now();
-    const code = await this.agent.run(wish, { show: (text) => this.row.show(`${wish.name()}\t${text}`) }, signal);
+    const { code, summary, link = '', tokens, model } = await this.agent.run(wish, { show: (text) => this.row.show(`${wish.name()}\t${text}`) }, signal);
+    const suffix = [`(${[wish.name(), new Duration(Date.now() - start).minutes(), tokens, model].filter((p) => p !== '').join(' ')})`, link].filter((p) => p !== '').join(' ');
     if (code === 0) {
       await wish.close();
-      this.protocol.show(`${wish.name()}\tdone in ${new Duration(Date.now() - start).minutes()}`);
+      this.protocol.show(`${summary === '' ? 'done' : summary} ${suffix}`);
     } else {
       wish.free();
-      this.protocol.show(`${wish.name()}\tfailed with exit code ${code} after ${new Duration(Date.now() - start).minutes()}`);
+      this.protocol.show(`failed with exit code ${code}${summary === '' ? '' : `: ${summary}`} ${suffix}`);
     }
   }
 }

package/src/wish.js

@@ -4,11 +4,6 @@
 import { readFile, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 
-/**
- * One wish, a Markdown file inside the wishes directory.
- * The wish shares the map of claims with the wishes directory,
- * so it can give its claim back when a wand is done with it.
- */
 export class Wish {
   constructor(dir, path, claims) {
     this.dir = dir;

package/src/wishes.js

@@ -2,26 +2,18 @@
 // SPDX-License-Identifier: MIT
 
 import { readdir } from 'node:fs/promises';
-import { join, relative } from 'node:path';
+import { basename, join, relative } from 'node:path';
 import { setTimeout } from 'node:timers/promises';
 import { Wish } from './wish.js';
 import { Archived } from './archived.js';
 import { Permanent } from './permanent.js';
 
-/**
- * The directory with wishes, shared by all wands.
- * It is the only object with mutable state: a map of claims, where the
- * order of entries tells how recently each wish was tried and the value
- * tells whether a wand holds it now. A wish is claimed synchronously
- * right after the scan, so two wands never get the same file.
- * The wishes found by the first scan are permanent and stay in the
- * directory forever, while the ones that appear later are one-time.
- */
 export class Wishes {
-  constructor(dir, interval, archive = '') {
+  constructor(dir, interval, archive = '', pause = 0) {
     this.dir = dir;
     this.interval = interval;
     this.archive = archive;
+    this.pause = pause;
     this.claims = new Map();
     this.startup = [];
   }
@@ -31,6 +23,7 @@ export class Wishes {
       .filter((f) => f.isFile() && f.name.endsWith('.md'))
       .map((f) => join(relative(this.dir, f.parentPath), f.name))
       .sort();
+    signal.throwIfAborted();
     if (this.startup.length === 0) {
       this.startup.push(new Set(files));
     }
@@ -43,8 +36,8 @@ export class Wishes {
     this.claims.delete(path);
     this.claims.set(path, true);
     const wish = new Wish(this.dir, path, this.claims);
-    if (this.startup[0].has(path)) {
-      return new Permanent(wish);
+    if (this.startup[0].has(path) && /^[A-Z]/.test(basename(path))) {
+      return new Permanent(wish, this.pause);
     }
     return this.archive === '' ? wish : new Archived(wish, this.dir, this.archive);
   }