@yegor256/jinka 0.0.2 → 0.0.4

package/src/archived.js

@@ -4,11 +4,6 @@
 import { copyFile, mkdir, access } from 'node:fs/promises';
 import { join, dirname, extname } from 'node:path';
 
-/**
- * A wish that goes into the archive directory instead of disappearing.
- * The archived copy keeps the subdirectory of the wish, and gets a
- * timestamp in its name when a file with the same name is already there.
- */
 export class Archived {
   constructor(origin, dir, archive) {
     this.origin = origin;

package/src/claude.js

@@ -1,25 +1,17 @@
 // SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
 // SPDX-License-Identifier: MIT
 
-import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
-import { join } from 'node:path';
 import { Event } from './event.js';
+import { Tokens } from './tokens.js';
+import { Model } from './model.js';
 
-/**
- * The coding agent that makes one wish come true.
- * It starts the agent process in headless mode, writes the prompt
- * to its standard input, and reports every event of its stream-json
- * output to a screen row. The model, when not empty, is passed
- * to the agent verbatim. The process gets SIGTERM when the signal
- * aborts.
- */
 export class Claude {
-  constructor(command, plugin, dir, model) {
-    this.command = command;
+  constructor(agent, plugin, disk, meter) {
+    this.agent = agent;
     this.plugin = plugin;
-    this.dir = dir;
-    this.model = model;
+    this.disk = disk;
+    this.meter = meter;
   }
   async run(wish, row, signal) {
     const prompt = [
@@ -27,34 +19,38 @@ export class Claude {
       '',
       await wish.text(),
       '',
-      `The wish is written in the file ${join(this.dir, wish.name())}, ${wish.fate()}.`,
-      `All wishes live in the directory ${this.dir}, and you may add new wishes there as Markdown files.`
+      ...this.disk.lines(wish),
+      'When you finish, end with a single plain sentence that says what you did.',
+      'On the next line, write the full URL of the GitHub issue or pull request you worked on, if there was one.'
     ].join('\n');
-    const agent = spawn(
-      this.command,
-      [
-        '-p', '--output-format', 'stream-json', '--verbose',
-        '--plugin-dir', this.plugin, '--add-dir', this.dir,
-        '--dangerously-skip-permissions',
-        ...(this.model === '' ? [] : ['--model', this.model])
-      ],
-      { signal, stdio: ['pipe', 'pipe', 'ignore'] }
-    );
-    agent.stdin.on('error', () => {});
-    agent.stdin.end(prompt);
-    createInterface({ input: agent.stdout }).on('line', (line) => {
+    const log = await this.disk.log(wish);
+    const child = this.agent.start(['--plugin-dir', this.plugin, ...this.disk.args()], signal);
+    child.stdin.on('error', () => {});
+    child.stdin.end(prompt);
+    child.stdout.pipe(log, { end: false });
+    child.stderr.pipe(log, { end: false });
+    let summary = '';
+    let link = '';
+    const usage = new Tokens();
+    const model = new Model();
+    createInterface({ input: child.stdout }).on('line', (line) => {
+      this.meter.add(line);
+      usage.add(line);
+      model.add(line);
+      summary = new Event(line).summary() || summary;
+      link = new Event(line).link() || link;
       const text = new Event(line).text();
       if (text !== '') {
         row.show(text);
       }
     });
     return new Promise((resolve, reject) => {
-      agent.on('error', (e) => {
+      child.on('error', (e) => {
         if (!signal.aborted) {
-          reject(new Error(`Cannot start the agent "${this.command}": ${e.message}`));
+          reject(new Error(`Cannot start the agent "${child.spawnfile}": ${e.message}`));
         }
       });
-      agent.on('close', (code) => resolve(code ?? 1));
+      child.on('close', (code) => log.end(() => resolve({ code: code ?? 1, summary, link, tokens: usage.text(), model: model.text() })));
     });
   }
 }

package/src/crew.js

@@ -0,0 +1,67 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
+// SPDX-License-Identifier: MIT
+
+export class Crew {
+  constructor(size, limit, notice) {
+    this.limit = limit;
+    this.notice = notice;
+    this.seats = new Map(Array.from({ length: size }, (_, i) => [i, { idle: false, controller: new AbortController() }]));
+    this.state = { launch: () => {}, runs: [] };
+  }
+  size() {
+    return this.seats.size;
+  }
+  indexes() {
+    return [...this.seats.keys()].sort((a, b) => a - b);
+  }
+  more() {
+    if (this.seats.size >= this.limit) {
+      this.notice.show(`more than ${this.limit} threads are not allowed`);
+      return;
+    }
+    const index = Array.from({ length: this.limit }, (_, i) => i).find((i) => !this.seats.has(i));
+    this.seats.set(index, { idle: false, controller: new AbortController() });
+    this.state.launch(index);
+  }
+  less() {
+    const index = this.indexes().findLast((i) => this.seats.get(i).idle);
+    if (this.seats.size === 1) {
+      this.notice.show('the last thread cannot be removed');
+    } else if (index === undefined) {
+      this.notice.show('no idle thread can be removed right now');
+    } else {
+      this.seats.get(index).controller.abort();
+      this.seats.delete(index);
+    }
+  }
+  async run(wishes, wand, signal) {
+    this.state.launch = (index) => {
+      const seat = this.seats.get(index);
+      this.state.runs.push(
+        wand(
+          index,
+          {
+            next: async (s) => {
+              seat.idle = true;
+              try {
+                return await wishes.next(s);
+              } finally {
+                seat.idle = false;
+              }
+            }
+          },
+          AbortSignal.any([signal, seat.controller.signal])
+        )
+      );
+    };
+    this.indexes().forEach((i) => this.state.launch(i));
+    await this.#join(0);
+  }
+  async #join(from) {
+    const to = this.state.runs.length;
+    if (from < to) {
+      await Promise.all(this.state.runs.slice(from, to));
+      await this.#join(to);
+    }
+  }
+}

package/src/disk.js

@@ -0,0 +1,35 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
+// SPDX-License-Identifier: MIT
+
+import { createWriteStream } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { join, dirname, extname } from 'node:path';
+
+export class Disk {
+  constructor(wishes, logs, memory, crew) {
+    this.wishes = wishes;
+    this.logs = logs;
+    this.memory = memory;
+    this.crew = crew;
+  }
+  lines(wish) {
+    return [
+      `The wish is written in the file ${join(this.wishes, wish.name())}, ${wish.fate()}.`,
+      `All wishes live in the directory ${this.wishes}, and you may add new wishes there as Markdown files.`,
+      `Your memory lives in the directory ${this.memory}, keep there what the skills tell you to keep.`,
+      `Jinka runs ${this.crew.size()} threads right now, so up to ${this.crew.size()} wishes run at once.`
+    ];
+  }
+  args() {
+    return ['--add-dir', this.wishes, '--add-dir', this.memory];
+  }
+  async log(wish) {
+    const file = join(
+      this.logs,
+      `${wish.name().slice(0, wish.name().length - extname(wish.name()).length)}-${new Date().toISOString().replace(/[-:]/g, '').replace('T', '-').slice(0, 15)}.jsonl`
+    );
+    await mkdir(dirname(file), { recursive: true });
+    await mkdir(this.memory, { recursive: true });
+    return createWriteStream(file);
+  }
+}

package/src/duration.js

@@ -1,11 +1,6 @@
 // SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
 // SPDX-License-Identifier: MIT
 
-/**
- * A span of time, printed the way a clock prints it.
- * It drops the milliseconds and pads every part with zeros, either as
- * minutes and seconds, or as hours, minutes and seconds.
- */
 export class Duration {
   constructor(millis) {
     this.millis = millis;

package/src/event.js

@@ -1,13 +1,8 @@
 // SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
 // SPDX-License-Identifier: MIT
 
-/**
- * One line of the stream-json output of the agent.
- * It turns the line into a short phrase that fits into one screen line,
- * such as the name of a tool with its main argument, or the first line
- * of what the agent said. Lines that carry nothing worth showing
- * become an empty phrase.
- */
+import { styleText } from 'node:util';
+
 export class Event {
   constructor(line) {
     this.line = line;
@@ -19,6 +14,22 @@ export class Event {
       return this.line.trim();
     }
   }
+  summary() {
+    try {
+      const json = JSON.parse(this.line);
+      return json.type === 'result' ? this.#first(String(json.result ?? '')) : '';
+    } catch {
+      return '';
+    }
+  }
+  link() {
+    try {
+      const json = JSON.parse(this.line);
+      return json.type === 'result' ? (String(json.result ?? '').match(/https:\/\/github\.com\/[^/\s]+\/[^/\s]+\/(?:issues|pull)\/\d+/) ?? [''])[0] : '';
+    } catch {
+      return '';
+    }
+  }
   #phrase(json) {
     if (json.type === 'assistant') {
       return (json.message?.content ?? []).map((part) => this.#part(part)).filter((p) => p !== '').join(' ');
@@ -34,13 +45,38 @@ export class Event {
     }
     if (part.type === 'tool_use') {
       const input = part.input ?? {};
-      return [part.name, input.command ?? input.file_path ?? input.pattern ?? input.url ?? input.query ?? input.skill ?? input.description]
-        .filter((p) => p !== undefined)
-        .map((p) => this.#first(String(p)))
-        .join(': ');
+      const phrase = this.#plain(part.name, input);
+      if (phrase !== undefined) {
+        return this.#first(phrase);
+      }
+      return styleText(
+        'gray',
+        [part.name, input.command ?? input.file_path ?? input.pattern ?? input.url ?? input.query ?? input.skill ?? input.description]
+          .filter((p) => p !== undefined)
+          .map((p) => this.#first(String(p)))
+          .join(': '),
+        { validateStream: false }
+      );
     }
     return '';
   }
+  #plain(name, input) {
+    const phrases = {
+      Bash: () => input.description,
+      Agent: () => input.description,
+      Task: () => input.description,
+      Read: () => input.file_path && `reading ${input.file_path}`,
+      Edit: () => input.file_path && `editing ${input.file_path}`,
+      MultiEdit: () => input.file_path && `editing ${input.file_path}`,
+      Write: () => input.file_path && `writing ${input.file_path}`,
+      Grep: () => input.pattern && `searching for "${input.pattern}"`,
+      Glob: () => input.pattern && `looking for files "${input.pattern}"`,
+      WebFetch: () => input.url && `fetching ${input.url}`,
+      WebSearch: () => input.query && `searching the web for "${input.query}"`,
+      Skill: () => input.skill && `using the skill ${input.skill}`
+    };
+    return Object.hasOwn(phrases, name) ? phrases[name]() || undefined : undefined;
+  }
   #first(text) {
     return text.split('\n').map((l) => l.trim()).find((l) => l !== '') ?? '';
   }

package/src/freeze.js

@@ -0,0 +1,43 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
+// SPDX-License-Identifier: MIT
+
+export class Freeze {
+  constructor(crew, quit) {
+    this.crew = crew;
+    this.quit = quit;
+    this.state = { frozen: false, idle: 0 };
+    this.waiters = [];
+  }
+  on() {
+    this.state.frozen = true;
+    this.#check();
+  }
+  off() {
+    this.state.frozen = false;
+    this.waiters.splice(0).forEach((w) => w());
+  }
+  active() {
+    return this.state.frozen;
+  }
+  enter() {
+    this.state.idle += 1;
+    this.#check();
+  }
+  leave() {
+    this.state.idle -= 1;
+  }
+  async thaw(signal) {
+    signal.throwIfAborted();
+    if (this.state.frozen) {
+      await new Promise((resolve, reject) => {
+        this.waiters.push(resolve);
+        signal.addEventListener('abort', () => reject(signal.reason), { once: true });
+      });
+    }
+  }
+  #check() {
+    if (this.state.frozen && this.state.idle === this.crew.size()) {
+      this.quit();
+    }
+  }
+}

package/src/frozen.js

@@ -0,0 +1,26 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
+// SPDX-License-Identifier: MIT
+
+export class Frozen {
+  constructor(origin, freeze) {
+    this.origin = origin;
+    this.freeze = freeze;
+  }
+  async next(signal) {
+    this.freeze.enter();
+    try {
+      return await this.#wish(signal);
+    } finally {
+      this.freeze.leave();
+    }
+  }
+  async #wish(signal) {
+    await this.freeze.thaw(signal);
+    const wish = await this.origin.next(signal);
+    if (this.freeze.active()) {
+      wish.free();
+      return this.#wish(signal);
+    }
+    return wish;
+  }
+}

package/src/jinka.js

@@ -3,21 +3,18 @@
 
 import { Wand } from './wand.js';
 
-/**
- * The application, which keeps several wands busy with wishes.
- * Each wand gets its own screen row and protocol, and all of them share one
- * directory of wishes and one agent, until the signal aborts.
- */
 export class Jinka {
-  constructor(wishes, agent, screen, threads) {
+  constructor(wishes, agent, screen, crew) {
     this.wishes = wishes;
     this.agent = agent;
     this.screen = screen;
-    this.threads = threads;
+    this.crew = crew;
   }
   async run(signal) {
-    await Promise.all(
-      Array.from({ length: this.threads }, (_, i) => new Wand(this.wishes, this.agent, this.screen.row(i), this.screen.protocol(i)).run(signal))
+    await this.crew.run(
+      this.wishes,
+      (i, wishes, s) => new Wand(wishes, this.agent, this.screen.row(i), this.screen.notice()).run(s),
+      signal
     );
   }
 }

package/src/keys.js

@@ -0,0 +1,28 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
+// SPDX-License-Identifier: MIT
+
+export class Keys {
+  constructor(stream, freeze, crew, interrupt) {
+    this.stream = stream;
+    this.freeze = freeze;
+    this.crew = crew;
+    this.interrupt = interrupt;
+  }
+  listen() {
+    if (this.stream.isTTY) {
+      this.stream.setRawMode(true);
+    }
+    this.stream.on('data', (chunk) => [...chunk.toString()].forEach((k) => this.#press(k)));
+  }
+  #press(key) {
+    ({
+      f: () => this.freeze.on(),
+      F: () => this.freeze.on(),
+      c: () => this.freeze.off(),
+      C: () => this.freeze.off(),
+      '+': () => this.crew.more(),
+      '-': () => this.crew.less(),
+      '\x03': () => this.interrupt()
+    })[key]?.();
+  }
+}

package/src/legend.js

@@ -0,0 +1,15 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
+// SPDX-License-Identifier: MIT
+
+import { styleText } from 'node:util';
+
+export class Legend {
+  constructor(freeze) {
+    this.freeze = freeze;
+  }
+  text() {
+    return this.freeze.active()
+      ? `${styleText('bgGray', 'C', { validateStream: false })} - to continue`
+      : `${styleText('bgGray', 'F', { validateStream: false })} - to finish and quit, ${styleText('bgGray', '+/-', { validateStream: false })} to add threads`;
+  }
+}

package/src/log.js

@@ -1,25 +1,18 @@
 // SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
 // SPDX-License-Identifier: MIT
 
+import { stripVTControlCharacters } from 'node:util';
 import { Row } from './row.js';
 
-/**
- * The screen for anything that is not a terminal, such as CI or a pipe.
- * It prints every change of every row and every protocol line
- * as a new plain line, without any cursor movement.
- */
 export class Log {
   constructor(stream) {
     this.stream = stream;
   }
   row(index) {
-    return new Row({ push: ([i, text]) => this.stream.write(`[${i + 1}] ${text.replace('\t', '  ')}\n`) }, index);
+    return new Row({ push: ([i, text]) => this.stream.write(`[${i + 1}] ${stripVTControlCharacters(text).replace('\t', '  ')}\n`) }, index);
   }
-  protocol(index) {
-    return new Row(
-      { push: ([i, text]) => this.stream.write(`${new Date().toTimeString().slice(0, 8)} [${i + 1}] ${text.replace('\t', '  ')}\n`) },
-      index
-    );
+  notice() {
+    return new Row({ push: ([, text]) => this.stream.write(`${new Date().toTimeString().slice(0, 8)} ${text}\n`) }, 0);
   }
   close() {}
 }

package/src/meters.js

@@ -0,0 +1,11 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
+// SPDX-License-Identifier: MIT
+
+export class Meters {
+  constructor(meters) {
+    this.meters = meters;
+  }
+  add(line) {
+    this.meters.forEach((meter) => meter.add(line));
+  }
+}

package/src/model.js

@@ -0,0 +1,25 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
+// SPDX-License-Identifier: MIT
+
+export class Model {
+  constructor() {
+    this.names = [];
+  }
+  add(line) {
+    try {
+      const json = JSON.parse(line);
+      if (json.type === 'system' && json.subtype === 'init' && typeof json.model === 'string') {
+        this.names.push(json.model);
+      }
+    } catch {
+      return;
+    }
+  }
+  text() {
+    const parts = (this.names.at(-1) ?? '').replace(/^claude-/, '').replace(/-\d{8}$/, '').split('-').filter((p) => p !== '');
+    return [
+      ...parts.filter((p) => !/^\d+$/.test(p)).map((p) => `${p[0].toUpperCase()}${p.slice(1)}`),
+      parts.filter((p) => /^\d+$/.test(p)).join('.')
+    ].join('');
+  }
+}

package/src/permanent.js

@@ -1,19 +1,10 @@
 // SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
 // SPDX-License-Identifier: MIT
 
-/**
- * A wish that was already in the directory when jinka started.
- * It describes ongoing work, so its file is never deleted: closing it
- * only gives its claim back, sending it to the end of the queue.
- * @todo #10:45min A permanent wish goes back to the queue right after
- *  a successful run, so a directory with a single permanent wish makes
- *  the agent work on it without any pause, burning the subscription.
- *  Let us decide whether a permanent wish must wait some time after
- *  a success before it is tried again, and implement that delay.
- */
 export class Permanent {
-  constructor(origin) {
+  constructor(origin, pause) {
     this.origin = origin;
+    this.pause = pause;
   }
   name() {
     return this.origin.name();
@@ -25,7 +16,7 @@ export class Permanent {
     return 'which stays there after you exit, so you must not delete it';
   }
   async close() {
-    this.origin.free();
+    setTimeout(() => this.origin.free(), this.pause).unref();
   }
   free() {
     this.origin.free();

package/src/quota.js

@@ -0,0 +1,21 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
+// SPDX-License-Identifier: MIT
+
+export class Quota {
+  constructor() {
+    this.shares = [];
+  }
+  add(line) {
+    try {
+      const json = JSON.parse(line);
+      if (json.type === 'rate_limit_event' && typeof json.rate_limit_info?.unifiedWindows?.five_hour?.utilization === 'number') {
+        this.shares.push(json.rate_limit_info.unifiedWindows.five_hour.utilization);
+      }
+    } catch {
+      return;
+    }
+  }
+  text() {
+    return this.shares.length === 0 ? '-' : `${Math.round((1 - this.shares.at(-1)) * 100)}%`;
+  }
+}

package/src/row.js

@@ -1,11 +1,6 @@
 // SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
 // SPDX-License-Identifier: MIT
 
-/**
- * One line of the screen, owned by one wand.
- * Every text it receives goes to the screen together with the index
- * of the line, so the screen knows which line to change.
- */
 export class Row {
   constructor(lines, index) {
     this.lines = lines;

package/src/status.js

@@ -1,19 +1,26 @@
 // SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
 // SPDX-License-Identifier: MIT
 
+import { styleText } from 'node:util';
 import { Duration } from './duration.js';
 
-/**
- * The top line of the terminal screen.
- * It tells which version of jinka is running and how long it has been
- * alive since the moment it started.
- */
 export class Status {
-  constructor(version, start) {
+  constructor(version, start, agent, model, tokens, quota) {
     this.version = version;
     this.start = start;
+    this.agent = agent;
+    this.model = model;
+    this.tokens = tokens;
+    this.quota = quota;
   }
   text() {
-    return `jinka ${this.version}, up ${new Duration(Date.now() - this.start).hours()}`;
+    return [
+      `jinka ${styleText('bgGray', this.version, { validateStream: false })}`,
+      `up ${styleText('bgGray', new Duration(Date.now() - this.start).hours(), { validateStream: false })}`,
+      `agent ${styleText('bgGray', this.agent, { validateStream: false })}`,
+      `model ${styleText('bgGray', this.model === '' ? 'default' : this.model, { validateStream: false })}`,
+      `tokens ${styleText('bgGray', this.tokens.text(), { validateStream: false })}`,
+      `5h-quota [${styleText('bgGray', this.quota.text(), { validateStream: false })}]`
+    ].join(', ');
   }
 }

package/src/tokens.js

@@ -0,0 +1,26 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
+// SPDX-License-Identifier: MIT
+
+export class Tokens {
+  constructor() {
+    this.messages = new Map();
+  }
+  add(line) {
+    try {
+      const json = JSON.parse(line);
+      if (json.type === 'assistant' && json.message?.id !== undefined && json.message?.usage !== undefined) {
+        this.messages.set(
+          json.message.id,
+          ['input_tokens', 'output_tokens', 'cache_read_input_tokens', 'cache_creation_input_tokens']
+            .reduce((sum, key) => sum + (json.message.usage[key] ?? 0), 0)
+        );
+      }
+    } catch {
+      return;
+    }
+  }
+  text() {
+    return new Intl.NumberFormat('en', { notation: 'compact', maximumFractionDigits: 1 })
+      .format([...this.messages.values()].reduce((sum, count) => sum + count, 0));
+  }
+}