@yegor256/jinka 0.0.7 → 0.0.9

package/bin/jinka.js

@@ -7,31 +7,34 @@ import { readFile } from 'node:fs/promises';
 import { resolve, join, dirname, parse } from 'node:path';
 import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
-import { Jinka } from '../src/jinka.js';
-import { Wishes } from '../src/wishes.js';
-import { Agent } from '../src/agent.js';
-import { Claude } from '../src/claude.js';
-import { Codex } from '../src/codex.js';
-import { Genie } from '../src/genie.js';
-import { Disk } from '../src/disk.js';
-import { Tty } from '../src/tty.js';
-import { Log } from '../src/log.js';
-import { Status } from '../src/status.js';
-import { Quota } from '../src/quota.js';
-import { Rollouts } from '../src/rollouts.js';
-import { Meters } from '../src/meters.js';
-import { Freeze } from '../src/freeze.js';
-import { Frozen } from '../src/frozen.js';
-import { Limited } from '../src/limited.js';
-import { Throttled } from '../src/throttled.js';
-import { Keys } from '../src/keys.js';
-import { Wheel } from '../src/wheel.js';
-import { Legend } from '../src/legend.js';
-import { Tokens } from '../src/tokens.js';
-import { Crew } from '../src/crew.js';
-import { Jobs } from '../src/jobs.js';
-import { Summary } from '../src/summary.js';
-import { Summarized } from '../src/summarized.js';
+import { jinka } from '../src/jinka.js';
+import { wishes } from '../src/wishes.js';
+import { agent } from '../src/agent.js';
+import { claude } from '../src/claude.js';
+import { codex } from '../src/codex.js';
+import { genie } from '../src/genie.js';
+import { disk } from '../src/disk.js';
+import { tty } from '../src/tty.js';
+import { colorless } from '../src/colorless.js';
+import { log } from '../src/log.js';
+import { status } from '../src/status.js';
+import { quota } from '../src/quota.js';
+import { rollouts } from '../src/rollouts.js';
+import { meters } from '../src/meters.js';
+import { freeze } from '../src/freeze.js';
+import { frozen } from '../src/frozen.js';
+import { limited } from '../src/limited.js';
+import { throttled } from '../src/throttled.js';
+import { keys } from '../src/keys.js';
+import { wheel } from '../src/wheel.js';
+import { legend } from '../src/legend.js';
+import { release } from '../src/release.js';
+import { tokens } from '../src/tokens.js';
+import { crew } from '../src/crew.js';
+import { jobs } from '../src/jobs.js';
+import { summary } from '../src/summary.js';
+import { summarized } from '../src/summarized.js';
+import { semaphore } from '../src/semaphore.js';
 
 const root = join(dirname(fileURLToPath(import.meta.url)), '..');
 const pkg = JSON.parse(await readFile(join(root, 'package.json'), 'utf8'));
@@ -61,9 +64,10 @@ const program = new Command()
   .name('jinka')
   .description(`${pkg.description} (${pkg.version})`)
   .version(pkg.version)
+  .configureHelp({ sortOptions: true })
   .showHelpAfterError('(add --help for additional information)')
   .addOption(new Option('--wishes <dir>', 'directory with wishes, one per Markdown file').default(join(homedir(), '.jinka', 'wishes'), '~/.jinka/wishes'))
-  .option('--threads <n>', `how many wishes run at once, up to ${limit}, which the + and - keys change while running`, bounded, 8)
+  .option('--threads <n>', `how many wishes run at once, up to ${limit}, which the + and - keys change while running`, bounded, 6)
   .addOption(new Option('--archive <dir>', 'directory where finished wishes are moved instead of being deleted').default(join(homedir(), '.jinka', 'archive'), '~/.jinka/archive'))
   .addOption(new Option('--logs <dir>', 'directory where the output of every agent run is saved').default(join(homedir(), '.jinka', 'logs'), '~/.jinka/logs'))
   .addOption(new Option('--memory <dir>', 'directory where agents keep what they learn about repositories between runs').default(join(homedir(), '.jinka', 'memory'), '~/.jinka/memory'))
@@ -75,31 +79,45 @@ const program = new Command()
   .addOption(new Option('--model <name>', 'model passed to the agent').default('', 'agent default'))
   .addOption(new Option('--effort <level>', 'reasoning effort passed to the agent, such as low, medium, high, xhigh, or max').default('', 'agent default'))
   .option('--throttle <percent>', 'how much of the agent quota, in percent, must be left in every window before a new job starts', percent, 15)
+  .addOption(new Option('--pid <file>', 'file that exists while jinka runs, so that a second jinka refuses to start').default(join(homedir(), '.jinka', 'pid.txt'), '~/.jinka/pid.txt'))
+  .option('--no-color', 'paint nothing in the terminal, which a non-empty NO_COLOR environment variable also does')
+  .option('--no-tui', 'print only the protocol, without the status bars and the list of threads')
   .addOption(new Option('--limit <n>', 'how many jobs start before jinka waits for them to finish and quits').argParser(positive).default(Infinity, 'unlimited'))
   .parse();
 const values = program.opts();
+const s = semaphore(resolve(values.pid));
+await s.acquire().catch((e) => {
+  console.error(e.message);
+  process.exit(1);
+});
+process.on('exit', () => s.release());
 const dir = resolve(values.wishes);
 const engine = values.engine ?? (parse(values.agent).name === 'codex' ? 'codex' : 'claude');
-const agent = values.agent === '' ? engine : values.agent;
-const tokens = new Tokens();
-const quota = new Quota();
-const crew = new Crew(values.threads, limit, { warn: (text) => screen.notice().warn(text) });
-const jobs = new Jobs(new Genie(new (engine === 'codex' ? Codex : Claude)(new Agent(agent), values.model, values.effort, resolve(values.skill)), new Disk(dir, resolve(values.logs), resolve(values.memory), crew), new Meters([tokens, engine === 'codex' ? new Rollouts(quota, join(process.env.CODEX_HOME ?? join(homedir(), '.codex'), 'sessions')) : quota])));
-const freeze = new Freeze(crew, { warn: (text) => screen.notice().warn(text) }, () => quit(0));
+const a = values.agent === '' ? engine : values.agent;
+const t = tokens();
+const q = quota();
+const c = crew(values.threads, limit, { warn: (text) => screen.notice().warn(text) });
+const j = jobs(genie((engine === 'codex' ? codex : claude)(agent(a), values.model, values.effort, resolve(values.skill)), disk(dir, resolve(values.logs), resolve(values.memory), c), meters([t, engine === 'codex' ? rollouts(q, join(process.env.CODEX_HOME ?? join(homedir(), '.codex'), 'sessions')) : q])));
+const f = freeze(c, { warn: (text) => screen.notice().warn(text) }, () => quit(0));
+const r = release(pkg.version, 'https://registry.npmjs.org/@yegor256/jinka/latest');
 const start = Date.now();
-const screen = new Summarized(
-  process.stdout.isTTY
-    ? new Tty(
-      process.stdout,
-      crew,
-      new Status(start, jobs, agent, values.model, tokens, quota),
-      new Legend(freeze, pkg.version)
+const tui = process.stdout.isTTY && values.tui;
+const screen = summarized(
+  tui
+    ? tty(
+      values.color && !process.env.NO_COLOR ? process.stdout : colorless(process.stdout),
+      c,
+      status(start, j, a, values.model, t, q),
+      legend(f, r)
     )
-    : new Log(process.stdout),
-  new Summary(start, pkg.version, jobs, { agent, model: values.model, effort: values.effort, wishes: dir }),
+    : log(process.stdout),
+  summary(start, pkg.version, j, { agent: a, model: values.model, effort: values.effort, wishes: dir }),
   process.stdout
 );
 process.on('exit', () => screen.close());
+if (tui) {
+  r.check();
+}
 const quit = (code) => {
   screen.close();
   process.stdout.write('', () => process.stderr.write('', () => process.exit(code)));
@@ -112,18 +130,18 @@ const interrupt = () => {
   controller.abort();
 };
 process.on('SIGINT', interrupt);
-new Keys(process.stdin, freeze, crew, interrupt).listen();
-new Wheel(process.stdin, screen).listen();
+keys(process.stdin, f, c, interrupt).listen();
+wheel(process.stdin, screen).listen();
 try {
-  await new Jinka(
-    new Limited(new Frozen(new Throttled(new Wishes(dir, values.interval, values.archive === '' ? '' : resolve(values.archive), values.pause, { warn: (text) => screen.notice().warn(text) }), quota, values.throttle, 15 * 60 * 1000, { warn: (text) => screen.notice().warn(text) }), freeze), values.limit, freeze),
-    jobs,
+  await jinka(
+    limited(frozen(throttled(wishes(dir, values.interval, values.archive === '' ? '' : resolve(values.archive), values.pause, { warn: (text) => screen.notice().warn(text) }), q, values.throttle, 15 * 60 * 1000, { warn: (text) => screen.notice().warn(text) }), f), values.limit, f),
+    j,
     screen,
-    crew
+    c
   ).run(controller.signal);
   quit(130);
 } catch (e) {
   screen.close();
-  console.error(e.message);
+  console.error(e);
   quit(1);
 }

package/package.json

@@ -35,5 +35,5 @@
     "test": "c8 --check-coverage --lines 80 mocha"
   },
   "type": "module",
-  "version": "0.0.7"
+  "version": "0.0.9"
 }

package/src/agent.js

@@ -3,13 +3,10 @@
 
 import spawn from 'cross-spawn';
 
-export class Agent {
-  constructor(command) {
-    this.command = command;
-  }
-  start(args, signal) {
+export const agent = (command) => Object.freeze({
+  start: (args, signal) => {
     const windows = process.platform === 'win32';
-    const child = spawn(this.command, args, windows ? { stdio: 'pipe' } : { signal, stdio: 'pipe' });
+    const child = spawn(command, args, windows ? { stdio: 'pipe' } : { signal, stdio: 'pipe' });
     if (windows) {
       signal.addEventListener(
         'abort',
@@ -19,4 +16,4 @@ export class Agent {
     }
     return child;
   }
-}
+});

package/src/archived.js

@@ -4,34 +4,26 @@
 import { copyFile, mkdir, access } from 'node:fs/promises';
 import { join, dirname, extname } from 'node:path';
 
-export class Archived {
-  constructor(origin, dir, archive) {
-    this.origin = origin;
-    this.dir = dir;
-    this.archive = archive;
-  }
-  name() {
-    return this.origin.name();
-  }
-  async text() {
-    return this.origin.text();
-  }
-  fate() {
-    return this.origin.fate();
-  }
-  async close() {
-    await copyFile(join(this.dir, this.origin.name()), await this.#target());
-    await this.origin.close();
-  }
-  free() {
-    this.origin.free();
-  }
-  async #target() {
-    const target = join(this.archive, this.origin.name());
-    await mkdir(dirname(target), { recursive: true });
-    return access(target).then(
-      () => `${target.slice(0, target.length - extname(target).length)}-${Date.now()}${extname(target)}`,
-      () => target
+export const archived = (origin, dir, archive) => {
+  const target = async () => {
+    const path = join(archive, origin.name());
+    await mkdir(dirname(path), { recursive: true });
+    return access(path).then(
+      () => `${path.slice(0, path.length - extname(path).length)}-${Date.now()}${extname(path)}`,
+      () => path
     );
-  }
-}
+  };
+  return Object.freeze({
+    name: () => origin.name(),
+    text: async () => origin.text(),
+    fate: () => origin.fate(),
+    close: async () => {
+      await access(join(dir, origin.name())).then(
+        async () => copyFile(join(dir, origin.name()), await target()),
+        () => {}
+      );
+      await origin.close();
+    },
+    free: () => origin.free()
+  });
+};

package/src/claude.js

@@ -1,27 +1,17 @@
 // SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
 // SPDX-License-Identifier: MIT
 
-export class Claude {
-  constructor(agent, model, effort, plugin) {
-    this.agent = agent;
-    this.model = model;
-    this.effort = effort;
-    this.plugin = plugin;
-  }
-  start(args, signal) {
-    return this.agent.start(
-      [
-        '-p', '--output-format', 'stream-json', '--verbose',
-        '--plugin-dir', this.plugin,
-        ...args,
-        '--dangerously-skip-permissions',
-        ...(this.model === '' ? [] : ['--model', this.model]),
-        ...(this.effort === '' ? [] : ['--effort', this.effort])
-      ],
-      signal
-    );
-  }
-  lines() {
-    return [];
-  }
-}
+export const claude = (agent, model, effort, plugin) => Object.freeze({
+  start: (args, signal) => agent.start(
+    [
+      '-p', '--output-format', 'stream-json', '--verbose',
+      '--plugin-dir', plugin,
+      ...args,
+      '--dangerously-skip-permissions',
+      ...(model === '' ? [] : ['--model', model]),
+      ...(effort === '' ? [] : ['--effort', effort])
+    ],
+    signal
+  ),
+  lines: () => []
+});

package/src/codex.js

@@ -3,30 +3,20 @@
 
 import { join } from 'node:path';
 
-export class Codex {
-  constructor(agent, model, effort, plugin) {
-    this.agent = agent;
-    this.model = model;
-    this.effort = effort;
-    this.plugin = plugin;
-  }
-  start(args, signal) {
-    return this.agent.start(
-      [
-        'exec', '--json',
-        '--dangerously-bypass-approvals-and-sandbox', '--skip-git-repo-check',
-        ...args,
-        ...(this.model === '' ? [] : ['--model', this.model]),
-        ...(this.effort === '' ? [] : ['--config', `model_reasoning_effort=${this.effort}`]),
-        '-'
-      ],
-      signal
-    );
-  }
-  lines() {
-    return [
-      `Your skills live in the directory ${join(this.plugin, 'skills')}, one skill per subdirectory, each described in its SKILL.md file.`,
-      'Before you start, read the descriptions of these skills, and whenever a skill fits your work, read its SKILL.md file and follow it.'
-    ];
-  }
-}
+export const codex = (agent, model, effort, plugin) => Object.freeze({
+  start: (args, signal) => agent.start(
+    [
+      'exec', '--json',
+      '--dangerously-bypass-approvals-and-sandbox', '--skip-git-repo-check',
+      ...args,
+      ...(model === '' ? [] : ['--model', model]),
+      ...(effort === '' ? [] : ['--config', `model_reasoning_effort=${effort}`]),
+      '-'
+    ],
+    signal
+  ),
+  lines: () => [
+    `Your skills live in the directory ${join(plugin, 'skills')}, one skill per subdirectory, each described in its SKILL.md file.`,
+    'Before you start, read the descriptions of these skills, and whenever a skill fits your work, read its SKILL.md file and follow it.'
+  ]
+});

package/src/colorless.js

@@ -0,0 +1,13 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
+// SPDX-License-Identifier: MIT
+
+export const colorless = (stream) => Object.freeze({
+  get columns() {
+    return stream.columns;
+  },
+  get rows() {
+    return stream.rows;
+  },
+  on: (event, listener) => stream.on(event, listener),
+  write: (text, done) => stream.write(text.replace(new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, 'g'), ''), done)
+});

package/src/crew.js

@@ -1,67 +1,62 @@
 // 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.warn(`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.warn('the last thread cannot be removed');
-    } else if (index === undefined) {
-      this.notice.warn('no idle thread can be removed right now');
-    } else {
-      this.seats.get(index).controller.abort();
-      this.seats.delete(index);
+export const crew = (size, limit, notice) => {
+  const seats = new Map(Array.from({ length: size }, (_, i) => [i, { idle: false, controller: new AbortController() }]));
+  const state = { launch: () => {}, runs: [] };
+  const indexes = () => [...seats.keys()].sort((a, b) => a - b);
+  const join = async (from) => {
+    const to = state.runs.length;
+    if (from < to) {
+      await Promise.all(state.runs.slice(from, to));
+      await join(to);
     }
-  }
-  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;
+  };
+  return Object.freeze({
+    size: () => seats.size,
+    indexes,
+    more: () => {
+      if (seats.size >= limit) {
+        notice.warn(`more than ${limit} threads are not allowed`);
+        return;
+      }
+      const index = Array.from({ length: limit }, (_, i) => i).find((i) => !seats.has(i));
+      seats.set(index, { idle: false, controller: new AbortController() });
+      state.launch(index);
+    },
+    less: () => {
+      const index = indexes().findLast((i) => seats.get(i).idle);
+      if (seats.size === 1) {
+        notice.warn('the last thread cannot be removed');
+      } else if (index === undefined) {
+        notice.warn('no idle thread can be removed right now');
+      } else {
+        seats.get(index).controller.abort();
+        seats.delete(index);
+      }
+    },
+    run: async (wishes, wand, signal) => {
+      state.launch = (index) => {
+        const seat = seats.get(index);
+        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);
+            },
+            AbortSignal.any([signal, seat.controller.signal])
+          )
+        );
+      };
+      indexes().forEach((i) => state.launch(i));
+      await join(0);
     }
-  }
-}
+  });
+};

package/src/disk.js

@@ -5,37 +5,29 @@ 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.`,
-      `If this wish is an atomic job that involves no other jobs, make it come true yourself;`,
-      `otherwise, do not do it yourself, but split it into smaller wishes`,
-      `and write each of them as a separate Markdown file in the directory ${join(this.wishes, dirname(wish.name()))}.`,
-      `Always start the name of every new wish file with a small English letter, never with a capital one.`,
-      `In every Git repository you touch, do all your work inside a separate Git worktree, never in the main directory of the repository, so that other wishes running at the same time do not see your changes.`,
-      `Never spend time waiting while doing a wish, neither sleeping nor polling for a build, a review, a merge, or anything else;`,
-      `if something must happen first, write a new wish that waits for it and finishes the job, and then complete the current wish right away.`,      `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) {
+export const disk = (wishes, logs, memory, crew) => Object.freeze({
+  lines: (wish) => [
+    `The wish is written in the file ${join(wishes, wish.name())}, ${wish.fate()}.`,
+    'Never delete, move, or rename the file of this wish yourself, even after you split it into smaller wishes, since Jinka takes care of it.',
+    `All wishes live in the directory ${wishes}, and you may add new wishes there as Markdown files.`,
+    `If this wish is an atomic job that involves no other jobs, make it come true yourself;`,
+    `otherwise, do not do it yourself, but split it into smaller wishes`,
+    `and write each of them as a separate Markdown file in the directory ${join(wishes, dirname(wish.name()))}.`,
+    `Always start the name of every new wish file with a small English letter, never with a capital one.`,
+    `In every Git repository you touch, do all your work inside a separate Git worktree, never in the main directory of the repository, so that other wishes running at the same time do not see your changes.`,
+    `Never spend time waiting while doing a wish, neither sleeping nor polling for a build, a review, a merge, or anything else;`,
+    `if something must happen first, write a new wish that waits for it and finishes the job, and then complete the current wish right away.`,
+    `Your memory lives in the directory ${memory}, keep there what the skills tell you to keep.`,
+    `Jinka runs ${crew.size()} threads right now, so up to ${crew.size()} wishes run at once.`
+  ],
+  args: () => ['--add-dir', wishes, '--add-dir', memory],
+  log: async (wish) => {
     const file = join(
-      this.logs,
+      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 });
+    await mkdir(memory, { recursive: true });
     return createWriteStream(file);
   }
-}
+});

package/src/duration.js

@@ -1,31 +1,31 @@
 // SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
 // SPDX-License-Identifier: MIT
 
-export class Duration {
-  constructor(millis) {
-    this.millis = millis;
-  }
-  minutes() {
-    const seconds = Math.floor(this.millis / 1000);
+export const duration = (millis) => {
+  const minutes = () => {
+    const seconds = Math.floor(millis / 1000);
     return [Math.floor(seconds / 60), seconds % 60].map((p) => String(p).padStart(2, '0')).join(':');
-  }
-  clock() {
-    const minutes = Math.floor(this.millis / 60_000);
-    if (minutes < 1000) {
-      return this.minutes().padStart(6);
+  };
+  return Object.freeze({
+    minutes,
+    clock: () => {
+      const total = Math.floor(millis / 60_000);
+      if (total < 1000) {
+        return minutes().padStart(6);
+      }
+      if (total < 6000) {
+        return `${String(Math.floor(total / 60)).padStart(2, '0')}:${String(total % 60).padStart(2, '0')}m`;
+      }
+      return `${Math.floor(total / 60)}h`.padStart(6);
+    },
+    phrase: () => {
+      const seconds = Math.floor(millis / 1000);
+      const [count, unit] = seconds < 60 ? [seconds, 'second'] : [Math.floor(seconds / 60), 'minute'];
+      return `${count} ${unit}${count === 1 ? '' : 's'}`;
+    },
+    hours: () => {
+      const seconds = Math.floor(millis / 1000);
+      return [Math.floor(seconds / 3600), Math.floor(seconds / 60) % 60, seconds % 60].map((p) => String(p).padStart(2, '0')).join(':');
     }
-    if (minutes < 6000) {
-      return `${String(Math.floor(minutes / 60)).padStart(2, '0')}:${String(minutes % 60).padStart(2, '0')}m`;
-    }
-    return `${Math.floor(minutes / 60)}h`.padStart(6);
-  }
-  phrase() {
-    const seconds = Math.floor(this.millis / 1000);
-    const [count, unit] = seconds < 60 ? [seconds, 'second'] : [Math.floor(seconds / 60), 'minute'];
-    return `${count} ${unit}${count === 1 ? '' : 's'}`;
-  }
-  hours() {
-    const seconds = Math.floor(this.millis / 1000);
-    return [Math.floor(seconds / 3600), Math.floor(seconds / 60) % 60, seconds % 60].map((p) => String(p).padStart(2, '0')).join(':');
-  }
-}
+  });
+};

package/src/ellipsized.js

@@ -0,0 +1,10 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 Yegor Bugayenko
+// SPDX-License-Identifier: MIT
+
+export const ellipsized = (origin, limit) => Object.freeze({
+  text: () => (
+    origin.length < limit
+      ? origin
+      : `${origin.slice(0, Math.floor((limit - 2) / 2))}…${origin.slice(-Math.ceil((limit - 2) / 2))}`
+  )
+});