kiriya 0.1.0

package/dist/src/modules/files/presentation/compare.view.js

@@ -0,0 +1,50 @@
+import { message } from "../../../core/domain/message.js";
+import { previewLines } from "../../../core/presentation/list-preview.js";
+const FOLDER_PREVIEW = 50;
+export const compareView = (output, format) => {
+    const lines = [`${format.red("a")}  ${output.a}`, `${format.green("b")}  ${output.b}`, ""];
+    if (output.kind === "files") {
+        const text = output.text;
+        if (output.identical) {
+            lines.push(format.green(format.text(message("files.compare.identical", { size: format.bytes(output.sizeA) }))));
+        }
+        else if (text === null) {
+            const sizes = { sizeA: format.bytes(output.sizeA), sizeB: format.bytes(output.sizeB) };
+            lines.push(format.text(message("files.compare.files-differ", sizes)));
+        }
+        else if (text.sameText) {
+            const encodings = { encodingA: text.encodingA, encodingB: text.encodingB };
+            lines.push(format.text(message("files.compare.same-text", encodings)));
+        }
+        else {
+            const end = format.dim(format.text(message("files.compare.end-of-file")));
+            const counts = { line: text.line, linesA: text.linesA, linesB: text.linesB };
+            lines.push(format.text(message("files.compare.first-difference", counts)), `  ${format.red("a")}  ${text.lineA ?? end}`, `  ${format.green("b")}  ${text.lineB ?? end}`);
+        }
+        return lines;
+    }
+    const sections = [
+        ["files.compare.only-in-a", output.onlyInA],
+        ["files.compare.only-in-b", output.onlyInB],
+        [
+            "files.compare.changed",
+            output.different.map((item) => item.reason === "kind" ? format.text(message("files.compare.kind-differs", { path: item.path })) : item.path),
+        ],
+    ];
+    for (const [key, items] of sections) {
+        if (items.length === 0)
+            continue;
+        lines.push(format.bold(format.text(message(key, { count: items.length }))));
+        lines.push(...previewLines(items, FOLDER_PREVIEW, (item) => `  ${item}`, format), "");
+    }
+    const differences = output.onlyInA.length + output.onlyInB.length + output.different.length;
+    lines.push(differences === 0
+        ? format.green(format.text(message("files.compare.identical-folders", { count: output.entries })))
+        : format.text(message("files.compare.folder-total", {
+            onlyA: output.onlyInA.length,
+            onlyB: output.onlyInB.length,
+            different: output.different.length,
+        })));
+    return lines;
+};
+//# sourceMappingURL=compare.view.js.map

package/dist/src/modules/files/presentation/copy.view.js

@@ -0,0 +1,17 @@
+import { message } from "../../../core/domain/message.js";
+export const copyView = (output, format) => {
+    const exists = format.yellow(format.text(message("files.transfer.exists-note")));
+    const lines = output.items.map((item) => {
+        const note = item.conflict ? `  ${exists}` : "";
+        return `  ${format.path(item.source)} -> ${format.path(item.destination)}  ${format.dim(format.bytes(item.bytes))}${note}`;
+    });
+    const conflicts = output.conflicts > 0
+        ? `, ${format.text(message("files.transfer.conflicts-note", { count: output.conflicts }))}`
+        : "";
+    lines.push("", `${format.text(message("files.copy.total", { count: output.items.length, size: format.bytes(output.bytes) }))}${conflicts}`);
+    const copied = output.items.filter((item) => item.outcome === "copied").length;
+    if (copied > 0)
+        lines.push(format.green(format.text(message("files.copy.done", { count: copied }))));
+    return lines;
+};
+//# sourceMappingURL=copy.view.js.map

package/dist/src/modules/files/presentation/delete.view.js

@@ -0,0 +1,16 @@
+import { message } from "../../../core/domain/message.js";
+export const deleteView = (output, format) => {
+    const lines = [];
+    for (const item of output.items) {
+        const shown = format.path(item.path) + (item.kind === "directory" ? "/" : "");
+        if (item.outcome === "planned")
+            lines.push(`  ${shown}  ${format.dim(format.bytes(item.bytes))}`);
+        if (item.outcome === "trashed")
+            lines.push(format.green(format.text(message("files.delete.trashed", { path: shown }))));
+        if (item.outcome === "deleted")
+            lines.push(format.green(format.text(message("files.delete.deleted", { path: shown }))));
+    }
+    lines.push("", format.text(message("files.delete.total", { count: output.items.length, size: format.bytes(output.bytes) })));
+    return lines;
+};
+//# sourceMappingURL=delete.view.js.map

package/dist/src/modules/files/presentation/dupes.view.js

@@ -0,0 +1,20 @@
+import { message } from "../../../core/domain/message.js";
+export const dupesView = (output, format) => {
+    const lines = [];
+    for (const group of output.groups) {
+        const extra = message("files.dupes.extra", { size: format.bytes(group.size * (group.paths.length - 1)) });
+        lines.push(`${format.bold(`${format.bytes(group.size)} × ${group.paths.length}`)}  ${format.dim(format.text(extra))}`);
+        for (const item of group.paths)
+            lines.push(`  ${format.path(item)}`);
+        lines.push("");
+    }
+    lines.push(format.text(output.groups.length === 0
+        ? message("files.dupes.none", { checked: output.checked })
+        : message("files.dupes.total", {
+            groups: output.groups.length,
+            size: format.bytes(output.extraBytes),
+            checked: output.checked,
+        })));
+    return lines;
+};
+//# sourceMappingURL=dupes.view.js.map

package/dist/src/modules/files/presentation/find.view.js

@@ -0,0 +1,16 @@
+import { message } from "../../../core/domain/message.js";
+export const findView = (output, format) => {
+    const lines = output.matches.map((match) => {
+        const size = match.kind === "directory" ? "" : format.bytes(match.size);
+        const shown = format.path(match.path) + (match.kind === "directory" ? "/" : "");
+        return `  ${format.time(match.modifiedMs)}  ${size.padStart(9)}  ${shown}`;
+    });
+    if (output.total > output.matches.length) {
+        lines.push(format.dim(format.text(message("files.find.more", { count: output.total - output.matches.length }))));
+    }
+    lines.push("", output.total === 0
+        ? format.text(message("files.find.none"))
+        : format.text(message("files.find.total", { count: output.total, size: format.bytes(output.totalBytes) })));
+    return lines;
+};
+//# sourceMappingURL=find.view.js.map

package/dist/src/modules/files/presentation/grep.view.js

@@ -0,0 +1,27 @@
+import { message } from "../../../core/domain/message.js";
+export const grepView = (output, format) => {
+    const lines = [];
+    if (output.mode === "lines") {
+        for (const match of output.lines) {
+            lines.push(`${format.bold(format.path(match.path))}:${match.line}: ${match.text}`);
+        }
+        if (output.matches > output.lines.length) {
+            const more = output.matches - output.lines.length;
+            lines.push(format.dim(format.text(message("files.grep.more", { count: more }))));
+        }
+    }
+    else {
+        for (const file of output.files) {
+            lines.push(output.mode === "files" ? format.path(file.path) : `${format.path(file.path)}: ${file.count}`);
+        }
+    }
+    const skipped = output.skipped > 0 ? format.dim(` · ${format.text(message("files.grep.skipped", { count: output.skipped }))}`) : "";
+    const total = message("files.grep.total", {
+        matches: output.matches,
+        matched: output.files.length,
+        checked: output.checked,
+    });
+    lines.push("", `${format.text(total)}${skipped}`);
+    return lines;
+};
+//# sourceMappingURL=grep.view.js.map

package/dist/src/modules/files/presentation/hash.view.js

@@ -0,0 +1,15 @@
+import { message } from "../../../core/domain/message.js";
+/** `<hash>  <path>`, as sha256sum prints it; a failed check is reported on stderr. */
+export const hashView = (output, format) => {
+    if (output.check !== null) {
+        if (!output.check.matches)
+            return [];
+        const matches = message("files.hash.matches", {
+            algorithm: output.algorithm,
+            path: format.path(output.check.path),
+        });
+        return [format.green(format.text(matches))];
+    }
+    return output.files.map((file) => `${file.hash}  ${format.path(file.path)}`);
+};
+//# sourceMappingURL=hash.view.js.map

package/dist/src/modules/files/presentation/info.view.js

@@ -0,0 +1,36 @@
+import { message } from "../../../core/domain/message.js";
+const KIND_KEYS = {
+    file: "core.kind.file",
+    directory: "core.kind.directory",
+    symlink: "core.kind.symlink",
+    other: "core.kind.other",
+};
+export const infoView = (output, format) => {
+    const label = (key) => format.text(message(key));
+    const lines = [];
+    for (const item of output.items) {
+        const rows = [[label("files.info.label.type"), label(KIND_KEYS[item.kind])]];
+        if (item.target !== null)
+            rows.push([label("files.info.label.target"), item.target]);
+        const size = item.contents === null
+            ? message("files.info.size-file", { size: format.bytes(item.bytes), bytes: item.bytes })
+            : message("files.info.size-folder", {
+                size: format.bytes(item.bytes),
+                files: item.contents.files,
+                folders: item.contents.directories,
+            });
+        const access = item.permissions === null
+            ? label(item.writable ? "files.info.read-write" : "files.info.read-only")
+            : `${item.permissions.symbolic} (${item.permissions.octal})`;
+        rows.push([label("files.info.label.size"), format.text(size)], [label("files.info.label.created"), format.time(item.createdMs)], [label("files.info.label.modified"), format.time(item.modifiedMs)], [label("files.info.label.accessed"), format.time(item.accessedMs)], [label("files.info.label.access"), access], [label("files.info.label.hidden"), label(item.hidden ? "files.info.hidden-yes" : "files.info.hidden-no")]);
+        if (item.hash !== null)
+            rows.push([item.hash.algorithm, item.hash.value]);
+        const width = Math.max(...rows.map(([name]) => name.length));
+        lines.push(format.bold(format.path(item.path)));
+        for (const [name, value] of rows)
+            lines.push(`  ${name.padEnd(width)}  ${value}`);
+        lines.push("");
+    }
+    return lines;
+};
+//# sourceMappingURL=info.view.js.map

package/dist/src/modules/files/presentation/list.view.js

@@ -0,0 +1,17 @@
+import { message } from "../../../core/domain/message.js";
+export const listView = (output, format) => {
+    const lines = [format.bold(format.path(output.path)), ""];
+    for (const entry of output.entries) {
+        const size = entry.kind === "file" ? format.bytes(entry.size) : "";
+        const name = entry.kind === "directory" ? format.bold(`${entry.name}/`) : entry.name;
+        const target = entry.target === null ? "" : format.dim(` -> ${entry.target}`);
+        lines.push(`  ${entry.kind.padEnd(9)} ${size.padStart(9)}  ${format.time(entry.modifiedMs)}  ${name}${target}`);
+    }
+    const folders = output.entries.filter((entry) => entry.kind === "directory").length;
+    const bytes = output.entries.reduce((sum, entry) => sum + entry.size, 0);
+    lines.push("", format.text(message("files.list.total", { folders, files: output.entries.length - folders, size: format.bytes(bytes) })));
+    if (output.hidden > 0)
+        lines.push(format.dim(format.text(message("files.list.hidden", { count: output.hidden }))));
+    return lines;
+};
+//# sourceMappingURL=list.view.js.map

package/dist/src/modules/files/presentation/move.view.js

@@ -0,0 +1,14 @@
+import { message } from "../../../core/domain/message.js";
+export const moveView = (output, format) => {
+    const exists = format.yellow(format.text(message("files.transfer.exists-note")));
+    const lines = output.items.map((item) => `  ${format.path(item.source)} -> ${format.path(item.destination)}${item.conflict ? `  ${exists}` : ""}`);
+    const conflicts = output.conflicts > 0
+        ? `, ${format.text(message("files.transfer.conflicts-note", { count: output.conflicts }))}`
+        : "";
+    lines.push("", `${format.text(message("files.move.total", { count: output.items.length }))}${conflicts}`);
+    const moved = output.items.filter((item) => item.outcome === "moved").length;
+    if (moved > 0)
+        lines.push(format.green(format.text(message("files.move.done", { count: moved }))));
+    return lines;
+};
+//# sourceMappingURL=move.view.js.map

package/dist/src/modules/files/presentation/new.view.js

@@ -0,0 +1,8 @@
+import { message } from "../../../core/domain/message.js";
+/** Created paths go to stdout; the ones left alone are reported as failures on stderr. */
+export const newView = (output, format) => output.items
+    .filter((item) => item.created)
+    .map((item) => format.green(format.text(message(item.kind === "directory" ? "files.new.created-folder" : "files.new.created-file", {
+    path: format.path(item.path),
+}))));
+//# sourceMappingURL=new.view.js.map

package/dist/src/modules/files/presentation/read.view.js

@@ -0,0 +1,6 @@
+/** Only the text, so the output can be piped. */
+export const readView = (output) => {
+    const width = String(output.last).length;
+    return output.lines.map((line, index) => output.numbered ? `${String(output.first + index).padStart(width)}  ${line}` : line);
+};
+//# sourceMappingURL=read.view.js.map

package/dist/src/modules/files/presentation/rename.view.js

@@ -0,0 +1,16 @@
+import path from "node:path";
+import { message } from "../../../core/domain/message.js";
+export const renameView = (output, format) => {
+    if (output.mode === "one") {
+        return output.renames.map((rename) => format.green(format.text(message("files.rename.renamed-one", { from: format.path(rename.from), name: path.basename(rename.to) }))));
+    }
+    const lines = output.renames.map((rename) => `  ${format.path(rename.from)} -> ${format.bold(path.basename(rename.to))}`);
+    lines.push("", format.text(message("files.rename.count", { count: output.renames.length })));
+    if (output.renames.length === 0 && output.problems.length === 0) {
+        lines.push(format.green(format.text(message("files.rename.all-fit"))));
+    }
+    if (output.renamed > 0)
+        lines.push(format.green(format.text(message("files.rename.renamed", { count: output.renamed }))));
+    return lines;
+};
+//# sourceMappingURL=rename.view.js.map

package/dist/src/modules/files/presentation/replace.view.js

@@ -0,0 +1,26 @@
+import { message } from "../../../core/domain/message.js";
+export const replaceView = (output, format) => {
+    const lines = [];
+    for (const file of output.files) {
+        const count = format.dim(format.text(message("files.replace.matches", { count: file.count })));
+        lines.push(`${format.bold(format.path(file.path))}  ${count}`);
+        if (file.lineCountChanges)
+            lines.push(format.dim(`  ${format.text(message("files.replace.lines-change"))}`));
+        for (const sample of file.samples) {
+            lines.push(`  ${String(sample.line).padStart(5)}  ${format.red("-")} ${sample.before}`);
+            lines.push(`  ${"".padStart(5)}  ${format.green("+")} ${sample.after}`);
+        }
+    }
+    const skipped = output.skipped > 0 ? format.dim(` · ${format.text(message("files.grep.skipped", { count: output.skipped }))}`) : "";
+    const total = message("files.replace.total", {
+        total: output.replacements,
+        files: output.files.length,
+        checked: output.checked,
+    });
+    lines.push("", `${format.text(total)}${skipped}`);
+    if (output.written > 0) {
+        lines.push(format.green(format.text(message("files.replace.written", { count: output.written }))));
+    }
+    return lines;
+};
+//# sourceMappingURL=replace.view.js.map

package/dist/src/modules/files/presentation/size.view.js

@@ -0,0 +1,24 @@
+import { message } from "../../../core/domain/message.js";
+export const sizeView = (output, format) => {
+    const rebuildable = output.rebuildableBytes > 0
+        ? format.dim(`  ${format.text(message("files.size.rebuildable-total", { size: format.bytes(output.rebuildableBytes) }))}`)
+        : "";
+    const lines = [`${format.bold(format.path(output.folder))}  ${format.bytes(output.bytes)}${rebuildable}`, ""];
+    const shown = output.rows.slice(0, output.top);
+    const loose = format.text(message("files.size.loose-files"));
+    const width = Math.max(8, loose.length, ...shown.map((row) => row.name.length + 1));
+    for (const row of shown) {
+        const extra = row.rebuildableBytes > 0
+            ? format.dim(`  ${format.text(message("files.size.rebuildable", { size: format.bytes(row.rebuildableBytes) }))}`)
+            : "";
+        lines.push(`  ${`${row.name}/`.padEnd(width)}  ${format.bytes(row.bytes).padStart(9)}${extra}`);
+    }
+    if (output.rows.length > shown.length) {
+        lines.push(format.dim(`  ${format.text(message("files.size.more", { count: output.rows.length - shown.length }))}`));
+    }
+    if (output.looseBytes > 0) {
+        lines.push(format.dim(`  ${loose.padEnd(width)}  ${format.bytes(output.looseBytes).padStart(9)}`));
+    }
+    return lines;
+};
+//# sourceMappingURL=size.view.js.map

package/dist/src/modules/files/presentation/sync.view.js

@@ -0,0 +1,37 @@
+import { message } from "../../../core/domain/message.js";
+import { previewLines } from "../../../core/presentation/list-preview.js";
+const PREVIEW = 15;
+export const syncView = (output, format) => {
+    const label = (key) => format.bold(format.text(message(key)));
+    const plan = message("files.sync.plan", {
+        copy: output.copy.length,
+        update: output.update.length,
+        remove: output.remove.length,
+        size: format.bytes(output.bytes),
+    });
+    const lines = [
+        `${label("files.sync.label.source")}  ${output.source}`,
+        `${label("files.sync.label.target")}  ${output.target}`,
+        "",
+        format.text(plan),
+    ];
+    const sections = [
+        ["files.sync.section.copy", output.copy],
+        ["files.sync.section.update", output.update],
+        ["files.sync.section.delete", output.remove],
+    ];
+    for (const [key, items] of sections) {
+        if (items.length === 0)
+            continue;
+        lines.push("", label(key), ...previewLines(items, PREVIEW, (item) => `  ${item}`, format));
+    }
+    if (output.copy.length + output.update.length + output.remove.length === 0) {
+        lines.push("", format.green(format.text(message("files.sync.in-sync"))));
+    }
+    if (output.applied) {
+        const counts = { copy: output.copy.length, update: output.update.length, remove: output.remove.length };
+        lines.push("", format.green(format.text(message("files.sync.done", counts))));
+    }
+    return lines;
+};
+//# sourceMappingURL=sync.view.js.map

package/dist/src/modules/files/presentation/tree.view.js

@@ -0,0 +1,22 @@
+import { message } from "../../../core/domain/message.js";
+export const treeView = (output, format) => {
+    const lines = [format.bold(format.path(output.root))];
+    const draw = (nodes, prefix) => {
+        nodes.forEach((node, index) => {
+            const last = index === nodes.length - 1;
+            const name = node.kind === "directory" ? format.bold(`${node.name}/`) : node.name;
+            const target = node.target === null ? "" : format.dim(` -> ${node.target}`);
+            const note = node.closed
+                ? format.dim(`  ${format.text(message("files.tree.not-opened"))}`)
+                : node.unreadable
+                    ? format.dim(`  ${format.text(message("files.tree.unreadable"))}`)
+                    : "";
+            lines.push(`${prefix}${last ? "└── " : "├── "}${name}${target}${note}`);
+            draw(node.children, `${prefix}${last ? "    " : "│   "}`);
+        });
+    };
+    draw(output.nodes, "");
+    lines.push("", format.text(message("files.tree.total", { folders: output.directories, files: output.files, depth: output.depth })));
+    return lines;
+};
+//# sourceMappingURL=tree.view.js.map

package/dist/src/modules/gen/application/gen-options.js

@@ -0,0 +1,18 @@
+import { UsageError } from "../../../core/domain/errors.js";
+export const MAX_COUNT = 1000;
+/** Every run gives new values, and nothing leaves the machine. */
+export const GENERATOR = { safety: "read", idempotent: false, usesNetwork: false, runsUserCommands: false };
+export const countOption = { type: "string", description: "gen.option.count", valueName: "<n>" };
+export function readCount(reader) {
+    const count = reader.positiveInteger("count", 1);
+    if (count > MAX_COUNT)
+        throw new UsageError("gen.count-too-large", { max: MAX_COUNT });
+    return count;
+}
+export function readRange(reader, option, fallback, min, max) {
+    const value = reader.positiveInteger(option, fallback);
+    if (value < min || value > max)
+        throw new UsageError("gen.out-of-range", { option, min, max });
+    return value;
+}
+//# sourceMappingURL=gen-options.js.map

package/dist/src/modules/gen/application/generate-passwords.use-case.js

@@ -0,0 +1,39 @@
+import { done } from "../../../core/domain/command.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { DIGITS, LOWER, password, SYMBOLS, UPPER } from "../domain/secrets.js";
+import { countOption, GENERATOR, readCount, readRange } from "./gen-options.js";
+export const passwordSpec = {
+    id: "gen.password",
+    summary: "gen.password.summary",
+    examples: ["kiriya gen password", "kiriya gen password --length 40 --no-symbols"],
+    ...GENERATOR,
+    input: {
+        positionals: [],
+        options: {
+            length: { type: "string", description: "gen.password.option.length", valueName: "<n>" },
+            "no-symbols": { type: "boolean", description: "gen.password.option.no-symbols" },
+            count: countOption,
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return {
+                count: readCount(reader),
+                length: readRange(reader, "length", 24, 8, 256),
+                symbols: !reader.flag("no-symbols"),
+            };
+        },
+    },
+};
+export class GeneratePasswords {
+    random;
+    spec = passwordSpec;
+    constructor(random) {
+        this.random = random;
+    }
+    execute(input) {
+        const classes = input.symbols ? [LOWER, UPPER, DIGITS, SYMBOLS] : [LOWER, UPPER, DIGITS];
+        const values = Array.from({ length: input.count }, () => password(input.length, classes, (count) => this.random.bytes(count)));
+        return Promise.resolve(done({ values }));
+    }
+}
+//# sourceMappingURL=generate-passwords.use-case.js.map

package/dist/src/modules/gen/application/generate-tokens.use-case.js

@@ -0,0 +1,38 @@
+import { done } from "../../../core/domain/command.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { formatToken, TOKEN_FORMATS } from "../domain/secrets.js";
+import { countOption, GENERATOR, readCount, readRange } from "./gen-options.js";
+export const tokenSpec = {
+    id: "gen.token",
+    summary: "gen.token.summary",
+    examples: ["kiriya gen token", "kiriya gen token --bytes 64 --format hex"],
+    ...GENERATOR,
+    input: {
+        positionals: [],
+        options: {
+            bytes: { type: "string", description: "gen.token.option.bytes", valueName: "<n>" },
+            format: { type: "string", description: "gen.token.option.format", valueName: "<hex|base64|base64url>" },
+            count: countOption,
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return {
+                count: readCount(reader),
+                bytes: readRange(reader, "bytes", 32, 8, 1024),
+                format: reader.choice("format", TOKEN_FORMATS, "base64url"),
+            };
+        },
+    },
+};
+export class GenerateTokens {
+    random;
+    spec = tokenSpec;
+    constructor(random) {
+        this.random = random;
+    }
+    execute(input) {
+        const values = Array.from({ length: input.count }, () => formatToken(this.random.bytes(input.bytes), input.format));
+        return Promise.resolve(done({ values }));
+    }
+}
+//# sourceMappingURL=generate-tokens.use-case.js.map

package/dist/src/modules/gen/application/generate-ulids.use-case.js

@@ -0,0 +1,40 @@
+import { done } from "../../../core/domain/command.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { incrementRandom, ulid } from "../domain/identifiers.js";
+import { countOption, GENERATOR, readCount } from "./gen-options.js";
+export const ulidSpec = {
+    id: "gen.ulid",
+    summary: "gen.ulid.summary",
+    examples: ["kiriya gen ulid", "kiriya gen ulid --count 10"],
+    ...GENERATOR,
+    input: {
+        positionals: [],
+        options: { count: countOption },
+        parse: (raw) => ({ count: readCount(new RawReader(raw)) }),
+    },
+};
+export class GenerateUlids {
+    random;
+    clock;
+    spec = ulidSpec;
+    constructor(random, clock) {
+        this.random = random;
+        this.clock = clock;
+    }
+    execute(input) {
+        const values = [];
+        let previousTime = -1;
+        let previousRandom = null;
+        for (let index = 0; index < input.count; index += 1) {
+            const time = this.clock.now();
+            // Within one millisecond the random part counts up, so the values keep the order they were made in.
+            const next = time === previousTime && previousRandom !== null ? incrementRandom(previousRandom) : null;
+            const random = next ?? this.random.bytes(10);
+            values.push(ulid(time, random));
+            previousTime = time;
+            previousRandom = random;
+        }
+        return Promise.resolve(done({ values }));
+    }
+}
+//# sourceMappingURL=generate-ulids.use-case.js.map

package/dist/src/modules/gen/application/generate-uuids.use-case.js

@@ -0,0 +1,32 @@
+import { done } from "../../../core/domain/command.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { uuidV4, uuidV7 } from "../domain/identifiers.js";
+import { countOption, GENERATOR, readCount } from "./gen-options.js";
+export const uuidSpec = {
+    id: "gen.uuid",
+    summary: "gen.uuid.summary",
+    examples: ["kiriya gen uuid", "kiriya gen uuid --v7 --count 5"],
+    ...GENERATOR,
+    input: {
+        positionals: [],
+        options: { v7: { type: "boolean", description: "gen.uuid.option.v7" }, count: countOption },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return { count: readCount(reader), timeOrdered: reader.flag("v7") };
+        },
+    },
+};
+export class GenerateUuids {
+    random;
+    clock;
+    spec = uuidSpec;
+    constructor(random, clock) {
+        this.random = random;
+        this.clock = clock;
+    }
+    execute(input) {
+        const values = Array.from({ length: input.count }, () => input.timeOrdered ? uuidV7(this.clock.now(), this.random.bytes(10)) : uuidV4(this.random.bytes(16)));
+        return Promise.resolve(done({ values }));
+    }
+}
+//# sourceMappingURL=generate-uuids.use-case.js.map

package/dist/src/modules/gen/domain/identifiers.js

@@ -0,0 +1,65 @@
+import { toHex } from "../../../core/domain/encodings.js";
+const CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+function formatUuid(bytes) {
+    const hex = toHex(bytes);
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
+/** A version 4 UUID from 16 random bytes: 122 random bits. */
+export function uuidV4(random) {
+    const bytes = Uint8Array.from(random.subarray(0, 16));
+    bytes[6] = ((bytes[6] ?? 0) & 0x0f) | 0x40;
+    bytes[8] = ((bytes[8] ?? 0) & 0x3f) | 0x80;
+    return formatUuid(bytes);
+}
+/** A version 7 UUID: 48 bits of Unix milliseconds, then 10 random bytes, so values sort by creation time. */
+export function uuidV7(epochMs, random) {
+    const bytes = new Uint8Array(16);
+    let time = Math.max(0, Math.floor(epochMs));
+    for (let index = 5; index >= 0; index -= 1) {
+        bytes[index] = time % 256;
+        time = Math.floor(time / 256);
+    }
+    bytes.set(random.subarray(0, 10), 6);
+    bytes[6] = ((bytes[6] ?? 0) & 0x0f) | 0x70;
+    bytes[8] = ((bytes[8] ?? 0) & 0x3f) | 0x80;
+    return formatUuid(bytes);
+}
+/** A ULID: 10 Crockford base32 characters of Unix milliseconds, then 16 of 10 random bytes. */
+export function ulid(epochMs, random) {
+    let time = "";
+    let remaining = Math.max(0, Math.floor(epochMs));
+    for (let index = 0; index < 10; index += 1) {
+        time = CROCKFORD.charAt(remaining % 32) + time;
+        remaining = Math.floor(remaining / 32);
+    }
+    let randomPart = "";
+    let buffer = 0;
+    let bits = 0;
+    for (const byte of random.subarray(0, 10)) {
+        buffer = (buffer << 8) | byte;
+        bits += 8;
+        while (bits >= 5) {
+            bits -= 5;
+            randomPart += CROCKFORD.charAt((buffer >> bits) & 31);
+        }
+        buffer &= (1 << bits) - 1;
+    }
+    return time + randomPart;
+}
+/**
+ * The next random part for ULIDs made in the same millisecond: the previous one plus
+ * one, so they still sort in the order they were made. null when it would overflow.
+ */
+export function incrementRandom(previous) {
+    const next = Uint8Array.from(previous);
+    for (let index = next.length - 1; index >= 0; index -= 1) {
+        const value = next[index] ?? 0;
+        if (value < 255) {
+            next[index] = value + 1;
+            return next;
+        }
+        next[index] = 0;
+    }
+    return null;
+}
+//# sourceMappingURL=identifiers.js.map