@yegor256/jinka 0.0.8 → 0.0.9

package/src/event.js

@@ -1,105 +1,99 @@
 // SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
 // SPDX-License-Identifier: MIT
 
-export class Event {
-  constructor(line, count) {
-    this.line = line;
-    this.count = count;
-  }
-  text() {
-    try {
-      return this.#phrase(JSON.parse(this.line));
-    } catch {
-      return this.line.trim();
+export const event = (line, count) => {
+  const first = (text) => text.split('\n').map((l) => l.trim()).find((l) => l !== '') ?? '';
+  const program = (command) => `\x1b[38;2;0;204;204m${command.trim().split(/\s+/)[0].split('/').at(-1)}\x1b[39m (${count} lines)`;
+  const 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;
+  };
+  const part = (piece) => {
+    if (piece.type === 'text') {
+      return first(piece.text);
     }
-  }
-  summary() {
-    try {
-      return this.#first(this.#final(JSON.parse(this.line)));
-    } catch {
-      return '';
+    if (piece.type === 'tool_use') {
+      const input = piece.input ?? {};
+      const phrase = plain(piece.name, input);
+      if (phrase !== undefined) {
+        return first(phrase);
+      }
+      if (piece.name === 'Bash' && input.command !== undefined) {
+        return program(String(input.command));
+      }
+      return `\x1b[38;2;0;204;204m${
+        [piece.name, input.command ?? input.file_path ?? input.pattern ?? input.url ?? input.query ?? input.skill ?? input.description]
+          .filter((p) => p !== undefined)
+          .map((p) => first(String(p)))
+          .join(': ')
+      }\x1b[39m`;
     }
-  }
-  link() {
-    try {
-      return (this.#final(JSON.parse(this.line)).match(/https:\/\/github\.com\/[^/\s]+\/[^/\s]+\/(?:issues|pull)\/\d+/) ?? [''])[0];
-    } catch {
-      return '';
+    return '';
+  };
+  const final = (json) => {
+    if (json.type === 'result') {
+      return String(json.result ?? '');
     }
-  }
-  #phrase(json) {
+    if (json.type === 'item.completed' && json.item?.type === 'agent_message') {
+      return String(json.item.text ?? '');
+    }
+    return '';
+  };
+  const phrase = (json) => {
     if (json.type === 'assistant') {
-      return (json.message?.content ?? []).map((part) => this.#part(part)).filter((p) => p !== '').join(' ');
+      return (json.message?.content ?? []).map((p) => part(p)).filter((p) => p !== '').join(' ');
     }
     if (json.type === 'result') {
-      return this.#first(String(json.result ?? json.subtype ?? ''));
+      return first(String(json.result ?? json.subtype ?? ''));
     }
     if (json.type === 'item.completed' && json.item?.type === 'agent_message') {
-      return this.#first(String(json.item.text ?? ''));
+      return first(String(json.item.text ?? ''));
     }
     if (json.type === 'item.started' && json.item?.type === 'command_execution') {
-      return this.#program(String(json.item.command ?? ''));
+      return program(String(json.item.command ?? ''));
     }
     if (json.type === 'item.completed' && json.item?.type === 'file_change') {
       return `editing ${(json.item.changes ?? []).map((c) => c.path).join(', ')}`;
     }
     if (json.type === 'turn.failed') {
-      return this.#first(String(json.error?.message ?? ''));
+      return first(String(json.error?.message ?? ''));
     }
     return '';
-  }
-  #final(json) {
-    if (json.type === 'result') {
-      return String(json.result ?? '');
-    }
-    if (json.type === 'item.completed' && json.item?.type === 'agent_message') {
-      return String(json.item.text ?? '');
-    }
-    return '';
-  }
-  #part(part) {
-    if (part.type === 'text') {
-      return this.#first(part.text);
-    }
-    if (part.type === 'tool_use') {
-      const input = part.input ?? {};
-      const phrase = this.#plain(part.name, input);
-      if (phrase !== undefined) {
-        return this.#first(phrase);
+  };
+  return Object.freeze({
+    text: () => {
+      try {
+        return phrase(JSON.parse(line));
+      } catch {
+        return line.trim();
       }
-      if (part.name === 'Bash' && input.command !== undefined) {
-        return this.#program(String(input.command));
+    },
+    summary: () => {
+      try {
+        return first(final(JSON.parse(line)));
+      } catch {
+        return '';
+      }
+    },
+    link: () => {
+      try {
+        return (final(JSON.parse(line)).match(/https:\/\/github\.com\/[^/\s]+\/[^/\s]+\/(?:issues|pull)\/\d+/) ?? [''])[0];
+      } catch {
+        return '';
       }
-      return `\x1b[38;2;0;204;204m${
-        [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(': ')
-      }\x1b[39m`;
     }
-    return '';
-  }
-  #program(command) {
-    return `\x1b[38;2;0;204;204m${command.trim().split(/\s+/)[0].split('/').at(-1)}\x1b[39m (${this.count} lines)`;
-  }
-  #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

@@ -1,46 +1,41 @@
 // SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
 // SPDX-License-Identifier: MIT
 
-export class Freeze {
-  constructor(crew, notice, quit) {
-    this.crew = crew;
-    this.notice = notice;
-    this.quit = quit;
-    this.state = { frozen: false, idle: 0 };
-    this.waiters = [];
-  }
-  on() {
-    this.state.frozen = true;
-    this.notice.warn('finishing, now we wait for all jobs to finish and then quit');
-    this.#check();
-  }
-  off() {
-    this.state.frozen = false;
-    this.notice.warn('continuing, new jobs will start again');
-    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 });
-      });
+export const freeze = (crew, notice, quit) => {
+  const state = { frozen: false, idle: 0 };
+  const waiters = [];
+  const check = () => {
+    if (state.frozen && state.idle === crew.size()) {
+      quit();
     }
-  }
-  #check() {
-    if (this.state.frozen && this.state.idle === this.crew.size()) {
-      this.quit();
+  };
+  return Object.freeze({
+    on: () => {
+      state.frozen = true;
+      notice.warn('finishing, now we wait for all jobs to finish and then quit');
+      check();
+    },
+    off: () => {
+      state.frozen = false;
+      notice.warn('continuing, new jobs will start again');
+      waiters.splice(0).forEach((w) => w());
+    },
+    active: () => state.frozen,
+    enter: () => {
+      state.idle += 1;
+      check();
+    },
+    leave: () => {
+      state.idle -= 1;
+    },
+    thaw: async (signal) => {
+      signal.throwIfAborted();
+      if (state.frozen) {
+        await new Promise((resolve, reject) => {
+          waiters.push(resolve);
+          signal.addEventListener('abort', () => reject(signal.reason), { once: true });
+        });
+      }
     }
-  }
-}
+  });
+};

package/src/frozen.js

@@ -1,26 +1,24 @@
 // 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();
+export const frozen = (origin, freeze) => {
+  const wish = async (signal) => {
+    await freeze.thaw(signal);
+    const found = await origin.next(signal);
+    if (freeze.active()) {
+      found.free();
+      return wish(signal);
     }
-  }
-  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 found;
+  };
+  return Object.freeze({
+    next: async (signal) => {
+      freeze.enter();
+      try {
+        return await wish(signal);
+      } finally {
+        freeze.leave();
+      }
     }
-    return wish;
-  }
-}
+  });
+};

package/src/genie.js

@@ -2,49 +2,44 @@
 // SPDX-License-Identifier: MIT
 
 import { createInterface } from 'node:readline';
-import { Event } from './event.js';
-import { Tokens } from './tokens.js';
-import { Model } from './model.js';
+import { event } from './event.js';
+import { tokens } from './tokens.js';
+import { model } from './model.js';
 
-export class Genie {
-  constructor(engine, disk, meter) {
-    this.engine = engine;
-    this.disk = disk;
-    this.meter = meter;
-  }
-  async run(wish, row, signal) {
+export const genie = (engine, disk, meter) => Object.freeze({
+  run: async (wish, row, signal) => {
     const prompt = [
       'Make this wish come true, working on your own without asking any questions:',
       '',
       await wish.text(),
       '',
-      ...this.disk.lines(wish),
-      ...this.engine.lines(),
+      ...disk.lines(wish),
+      ...engine.lines(),
       '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 log = await this.disk.log(wish);
-    const child = this.engine.start(this.disk.args(), signal);
+    const log = await disk.log(wish);
+    const child = engine.start(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();
+    const usage = tokens();
+    const m = model();
     let count = 0;
     createInterface({ input: child.stderr }).on('line', () => {
       count += 1;
     });
     createInterface({ input: child.stdout }).on('line', (line) => {
       count += 1;
-      this.meter.add(line);
+      meter.add(line);
       usage.add(line);
-      model.add(line);
-      summary = new Event(line, count).summary() || summary;
-      link = new Event(line, count).link() || link;
-      const text = new Event(line, count).text();
+      m.add(line);
+      summary = event(line, count).summary() || summary;
+      link = event(line, count).link() || link;
+      const text = event(line, count).text();
       if (text !== '') {
         row.show(text);
       }
@@ -55,7 +50,7 @@ export class Genie {
           reject(new Error(`Cannot start the agent "${child.spawnfile}": ${e.message}`));
         }
       });
-      child.on('close', (code) => log.end(() => resolve({ code: code ?? 1, summary, link, tokens: usage.text(), model: model.text() })));
+      child.on('close', (code) => log.end(() => resolve({ code: code ?? 1, summary, link, tokens: usage.text(), model: m.text() })));
     });
   }
-}
+});

package/src/jinka.js

@@ -1,20 +1,14 @@
 // SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
 // SPDX-License-Identifier: MIT
 
-import { Wand } from './wand.js';
+import { wand } from './wand.js';
 
-export class Jinka {
-  constructor(wishes, agent, screen, crew) {
-    this.wishes = wishes;
-    this.agent = agent;
-    this.screen = screen;
-    this.crew = crew;
-  }
-  async 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),
+export const jinka = (wishes, agent, screen, crew) => Object.freeze({
+  run: async (signal) => {
+    await crew.run(
+      wishes,
+      (i, w, s) => wand(w, agent, screen.row(i), screen.notice()).run(s),
       signal
     );
   }
-}
+});

package/src/jobs.js

@@ -1,19 +1,16 @@
 // SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
 // SPDX-License-Identifier: MIT
 
-export class Jobs {
-  constructor(agent) {
-    this.agent = agent;
-    this.count = { done: 0 };
-  }
-  async run(wish, row, signal) {
-    const result = await this.agent.run(wish, row, signal);
-    if (result.code === 0) {
-      this.count.done += 1;
-    }
-    return result;
-  }
-  text() {
-    return `${this.count.done}`;
-  }
-}
+export const jobs = (agent) => {
+  const count = { done: 0 };
+  return Object.freeze({
+    run: async (wish, row, signal) => {
+      const result = await agent.run(wish, row, signal);
+      if (result.code === 0) {
+        count.done += 1;
+      }
+      return result;
+    },
+    text: () => `${count.done}`
+  });
+};

package/src/keys.js

@@ -1,28 +1,24 @@
 // 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) {
+export const keys = (stream, freeze, crew, interrupt) => {
+  const 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()
+      f: () => freeze.on(),
+      F: () => freeze.on(),
+      c: () => freeze.off(),
+      C: () => freeze.off(),
+      '+': () => crew.more(),
+      '-': () => crew.less(),
+      '\x03': () => interrupt()
     })[key]?.();
-  }
-}
+  };
+  return Object.freeze({
+    listen: () => {
+      if (stream.isTTY) {
+        stream.setRawMode(true);
+      }
+      stream.on('data', (chunk) => [...chunk.toString()].forEach((k) => press(k)));
+    }
+  });
+};

package/src/legend.js

@@ -3,17 +3,13 @@
 
 import { styleText } from 'node:util';
 
-export class Legend {
-  constructor(freeze, version) {
-    this.freeze = freeze;
-    this.version = version;
-  }
-  text() {
-    return `${this.#keys()}\t${this.version}`;
-  }
-  #keys() {
-    return this.freeze.active()
+export const legend = (freeze, release) => {
+  const keys = () => (
+    freeze.active()
       ? `keys: ${styleText('bgGray', 'C', { validateStream: false })} - to continue`
-      : `keys: ${styleText('bgGray', 'F', { validateStream: false })} - to finish and quit, ${styleText('bgGray', '+/-', { validateStream: false })} to add threads`;
-  }
-}
+      : `keys: ${styleText('bgGray', 'F', { validateStream: false })} - to finish and quit, ${styleText('bgGray', '+/-', { validateStream: false })} to add threads`
+  );
+  return Object.freeze({
+    text: () => `${keys()}\t${release.text()}`
+  });
+};

package/src/limited.js

@@ -1,19 +1,16 @@
 // SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
 // SPDX-License-Identifier: MIT
 
-export class Limited {
-  constructor(origin, limit, freeze) {
-    this.origin = origin;
-    this.limit = limit;
-    this.freeze = freeze;
-    this.state = { given: 0 };
-  }
-  async next(signal) {
-    const wish = await this.origin.next(signal);
-    this.state.given += 1;
-    if (this.state.given >= this.limit) {
-      this.freeze.on();
+export const limited = (origin, limit, freeze) => {
+  const state = { given: 0 };
+  return Object.freeze({
+    next: async (signal) => {
+      const wish = await origin.next(signal);
+      state.given += 1;
+      if (state.given >= limit) {
+        freeze.on();
+      }
+      return wish;
     }
-    return wish;
-  }
-}
+  });
+};

package/src/log.js

@@ -1,21 +1,12 @@
 // SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
 // SPDX-License-Identifier: MIT
 
-import { stripVTControlCharacters } from 'node:util';
-import { Row } from './row.js';
-import { Protocol } from './protocol.js';
+import { protocol } from './protocol.js';
 
-export class Log {
-  constructor(stream) {
-    this.stream = stream;
-  }
-  row(index) {
-    return new Row({ push: ([i, text]) => this.stream.write(`[${i + 1}] ${stripVTControlCharacters(text).replace('\t', '  ')}\n`) }, index);
-  }
-  notice() {
-    return new Protocol({ push: ([, text]) => this.stream.write(`${new Date().toTimeString().slice(0, 8)} ${text}\n`) });
-  }
-  up() {}
-  down() {}
-  close() {}
-}
+export const log = (stream) => Object.freeze({
+  row: () => Object.freeze({ show: () => {} }),
+  notice: () => protocol({ push: ([, text]) => stream.write(`${new Date().toTimeString().slice(0, 8)} ${text}\n`) }),
+  up: () => {},
+  down: () => {},
+  close: () => {}
+});

package/src/logo.js

@@ -1,8 +1,6 @@
 // SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
 // SPDX-License-Identifier: MIT
 
-export class Logo {
-  lines() {
-    return ['▚▄▄▙▄▄▄▄▗▄▖ ', '▞▀▀▛▀▀▀▛▀▀▀▀'].map((l) => `\x1b[38;2;215;119;87m${l}\x1b[39m`);
-  }
-}
+export const logo = () => Object.freeze({
+  lines: () => ['▚▄▄▙▄▄▄▄▗▄▖ ', '▞▀▀▛▀▀▀▛▀▀▀▀'].map((l) => `\x1b[38;2;215;119;87m${l}\x1b[39m`)
+});

package/src/meters.js

@@ -1,11 +1,6 @@
 // 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));
-  }
-}
+export const meters = (m) => Object.freeze({
+  add: (line) => m.forEach((meter) => meter.add(line))
+});

package/src/model.js

@@ -1,25 +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);
+export const model = () => {
+  const names = [];
+  return Object.freeze({
+    add: (line) => {
+      try {
+        const json = JSON.parse(line);
+        if (json.type === 'system' && json.subtype === 'init' && typeof json.model === 'string') {
+          names.push(json.model);
+        }
+      } catch {
+        return;
       }
-    } catch {
-      return;
+    },
+    text: () => {
+      const parts = (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('');
     }
-  }
-  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('');
-  }
-}
+  });
+};