kiriya 0.1.0

package/dist/src/modules/files/application/delete-paths.use-case.js

@@ -0,0 +1,127 @@
+import path from "node:path";
+import { refuseProtected, requireApproval, requireTypedConfirmation } from "../../../core/application/safety.js";
+import { done, preview } from "../../../core/domain/command.js";
+import { KiriyaError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { message } from "../../../core/domain/message.js";
+import { formatBytes } from "../../../core/domain/values/bytes.js";
+import { expandPaths, measure, outermost } from "../../../core/application/paths.js";
+export const deleteSpec = {
+    id: "files.delete",
+    summary: "files.delete.summary",
+    examples: [
+        'kiriya files delete "logs/*.log"',
+        "kiriya files delete build --dry-run",
+        "kiriya files delete old-backups --permanent",
+    ],
+    safety: "destroy",
+    idempotent: false,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [{ name: "paths", description: "files.delete.arg.paths", required: true, variadic: true, path: true }],
+        options: {
+            permanent: { type: "boolean", description: "files.delete.option.permanent" },
+            "dry-run": { type: "boolean", description: "files.delete.option.dry-run" },
+            yes: { type: "boolean", description: "files.delete.option.yes", short: "y", terminalOnly: true },
+            confirm: { type: "string", description: "files.delete.option.confirm", valueName: "<count>", terminalOnly: true },
+            all: { type: "boolean", description: "files.option.all", reachesHidden: true },
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return {
+                paths: reader.positionalsFrom(0),
+                permanent: reader.flag("permanent"),
+                dryRun: reader.flag("dry-run"),
+                yes: reader.flag("yes"),
+                confirm: reader.string("confirm"),
+                all: reader.flag("all"),
+            };
+        },
+    },
+};
+export class DeletePaths {
+    fileSystem;
+    trash;
+    protectedPaths;
+    spec = deleteSpec;
+    constructor(fileSystem, trash, protectedPaths) {
+        this.fileSystem = fileSystem;
+        this.trash = trash;
+        this.protectedPaths = protectedPaths;
+    }
+    async execute(input, context) {
+        const paths = outermost(await expandPaths(this.fileSystem, input.paths, context.cwd, input.all));
+        refuseProtected(this.protectedPaths, paths, context.cwd);
+        const planned = [];
+        const warnings = [];
+        for (const target of paths) {
+            const stat = await this.fileSystem.lstat(target);
+            const size = await measure(this.fileSystem, target);
+            const isRepository = stat?.kind === "directory" && (await this.fileSystem.lstat(path.join(target, ".git"))) !== null;
+            if (isRepository)
+                warnings.push(message("files.delete.repository", { path: target }));
+            planned.push({
+                path: target,
+                kind: stat?.kind ?? "other",
+                bytes: size.bytes,
+                files: size.files,
+                isRepository,
+                outcome: "planned",
+                reason: null,
+            });
+        }
+        const bytes = planned.reduce((sum, item) => sum + item.bytes, 0);
+        const mode = input.permanent ? "permanent" : "trash";
+        if (input.dryRun)
+            return preview({ mode, items: planned, bytes }, "", warnings);
+        if (input.permanent) {
+            const warning = message("files.delete.warn-permanent", { count: planned.length, size: formatBytes(bytes) });
+            await requireTypedConfirmation(context, warning, String(planned.length), input.confirm);
+            return this.finish(mode, await this.removeAll(planned), bytes, warnings);
+        }
+        const question = message("files.delete.ask-trash", {
+            count: planned.length,
+            location: message(this.trash.location),
+        });
+        await requireApproval(context, question, input.yes);
+        const outcomes = await this.trash.send(planned.map((item) => item.path));
+        const items = planned.map((item, index) => {
+            const outcome = outcomes[index];
+            if (outcome?.ok === true)
+                return { ...item, outcome: "trashed" };
+            return {
+                ...item,
+                outcome: "failed",
+                reason: outcome?.ok === false ? outcome.reason : message("core.trash.failed", { detail: "no result" }),
+            };
+        });
+        return this.finish(mode, items, bytes, warnings);
+    }
+    async removeAll(planned) {
+        const items = [];
+        for (const item of planned) {
+            try {
+                await this.fileSystem.remove(item.path);
+                items.push({ ...item, outcome: "deleted" });
+            }
+            catch (error) {
+                if (!(error instanceof KiriyaError))
+                    throw error;
+                items.push({ ...item, outcome: "failed", reason: error.detail });
+            }
+        }
+        return items;
+    }
+    finish(mode, items, bytes, warnings) {
+        // A reason from the file system already names its path; a trash reason does not.
+        const failures = items
+            .filter((item) => item.outcome === "failed")
+            .map((item) => {
+            const reason = item.reason ?? message("core.trash.failed", { detail: "" });
+            return "path" in reason.params ? reason : message("files.delete.failed", { path: item.path, reason });
+        });
+        return done({ mode, items, bytes }, { warnings, failures });
+    }
+}
+//# sourceMappingURL=delete-paths.use-case.js.map

package/dist/src/modules/files/application/find-duplicates.use-case.js

@@ -0,0 +1,105 @@
+import path from "node:path";
+import { walk } from "../../../core/application/walk.js";
+import { done } from "../../../core/domain/command.js";
+import { KiriyaError, NotFoundError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { byCodePoint } from "../../../core/domain/names.js";
+import { parseSize } from "../domain/values.js";
+/** Files are grouped by size, then by a hash of this many first bytes, then by a full hash. */
+const PREFIX_BYTES = 64 * 1024;
+async function groupBy(items, key) {
+    const groups = new Map();
+    for (const item of items) {
+        const value = await key(item);
+        const group = groups.get(value);
+        if (group === undefined)
+            groups.set(value, [item]);
+        else
+            group.push(item);
+    }
+    return [...groups.values()].filter((group) => group.length > 1);
+}
+const extraBytes = (group) => (group[0]?.size ?? 0) * (group.length - 1);
+export const dupesSpec = {
+    id: "files.dupes",
+    summary: "files.dupes.summary",
+    examples: ["kiriya files dupes ~/Downloads", "kiriya files dupes photos --min-size 1MB", "kiriya files dupes --json"],
+    safety: "read",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [
+            { name: "folder", description: "files.dupes.arg.folder", required: false, variadic: false, path: true },
+        ],
+        options: {
+            "min-size": { type: "string", description: "files.dupes.option.min-size", valueName: "<size>" },
+            all: { type: "boolean", description: "files.option.all" },
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            const minSize = reader.string("min-size");
+            return {
+                folder: reader.positional(0) ?? ".",
+                minSize: Math.max(1, minSize === undefined ? 1 : parseSize(minSize)),
+                all: reader.flag("all"),
+            };
+        },
+    },
+};
+export class FindDuplicates {
+    fileSystem;
+    hasher;
+    spec = dupesSpec;
+    constructor(fileSystem, hasher) {
+        this.fileSystem = fileSystem;
+        this.hasher = hasher;
+    }
+    async execute(input, context) {
+        const folder = path.resolve(context.cwd, input.folder);
+        const stat = await this.fileSystem.stat(folder);
+        if (stat === null)
+            throw new NotFoundError("core.fs.not-found", { path: folder });
+        if (stat.kind !== "directory")
+            throw new NotFoundError("core.path.not-a-folder", { path: folder });
+        const files = [];
+        for await (const entry of walk(this.fileSystem, folder, { all: input.all })) {
+            if (context.signal.aborted)
+                break;
+            if (entry.kind !== "file")
+                continue;
+            const size = (await this.fileSystem.lstat(entry.path))?.size ?? 0;
+            if (size >= input.minSize)
+                files.push({ path: entry.path, size });
+        }
+        // An unreadable file gets a key of its own, so it never joins a group.
+        const digest = async (file, limitBytes) => {
+            try {
+                return await this.hasher.hashFile(file.path, "sha256", limitBytes);
+            }
+            catch (error) {
+                if (error instanceof KiriyaError)
+                    return `unreadable:${file.path}`;
+                throw error;
+            }
+        };
+        const groups = [];
+        for (const sameSize of await groupBy(files, (file) => Promise.resolve(String(file.size)))) {
+            for (const sameStart of await groupBy(sameSize, (file) => digest(file, PREFIX_BYTES))) {
+                const small = (sameStart[0]?.size ?? 0) <= PREFIX_BYTES;
+                groups.push(...(small ? [sameStart] : await groupBy(sameStart, (file) => digest(file))));
+            }
+        }
+        groups.sort((a, b) => extraBytes(b) - extraBytes(a));
+        return done({
+            folder,
+            checked: files.length,
+            groups: groups.map((group) => ({
+                size: group[0]?.size ?? 0,
+                paths: group.map((file) => file.path).sort(byCodePoint),
+            })),
+            extraBytes: groups.reduce((sum, group) => sum + extraBytes(group), 0),
+        });
+    }
+}
+//# sourceMappingURL=find-duplicates.use-case.js.map

package/dist/src/modules/files/application/find-files.use-case.js

@@ -0,0 +1,131 @@
+import path from "node:path";
+import { done } from "../../../core/domain/command.js";
+import { NotFoundError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { globToRegExp } from "../../../core/domain/glob.js";
+import { parseExtensions } from "../domain/filters.js";
+import { parseSize, parseTime } from "../domain/values.js";
+import { walk } from "../../../core/application/walk.js";
+export const FIND_TYPES = ["file", "dir"];
+export const findSpec = {
+    id: "files.find",
+    summary: "files.find.summary",
+    examples: [
+        'kiriya files find --name "*.test.ts"',
+        "kiriya files find src --ext .ts,.tsx --newer 7d",
+        "kiriya files find --type dir --empty",
+    ],
+    safety: "read",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [
+            { name: "folder", description: "files.find.arg.folder", required: false, variadic: false, path: true },
+        ],
+        options: {
+            name: { type: "string", description: "files.find.option.name", valueName: "<glob>" },
+            ext: { type: "string", description: "files.find.option.ext", valueName: "<extensions>", multiple: true },
+            type: { type: "string", description: "files.find.option.type", valueName: "<file|dir>" },
+            larger: { type: "string", description: "files.find.option.larger", valueName: "<size>" },
+            smaller: { type: "string", description: "files.find.option.smaller", valueName: "<size>" },
+            newer: { type: "string", description: "files.find.option.newer", valueName: "<time>" },
+            older: { type: "string", description: "files.find.option.older", valueName: "<time>" },
+            empty: { type: "boolean", description: "files.find.option.empty" },
+            all: { type: "boolean", description: "files.option.all" },
+            limit: { type: "string", description: "files.find.option.limit", valueName: "<n>" },
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            const type = reader.string("type") === undefined ? undefined : reader.choice("type", FIND_TYPES, "file");
+            const larger = reader.string("larger");
+            const smaller = reader.string("smaller");
+            return {
+                folder: reader.positional(0) ?? ".",
+                name: reader.string("name"),
+                extensions: parseExtensions(reader.strings("ext")),
+                type,
+                larger: larger === undefined ? undefined : parseSize(larger),
+                smaller: smaller === undefined ? undefined : parseSize(smaller),
+                newer: reader.string("newer"),
+                older: reader.string("older"),
+                empty: reader.flag("empty"),
+                all: reader.flag("all"),
+                limit: reader.positiveInteger("limit", 200),
+            };
+        },
+    },
+};
+export class FindFiles {
+    fileSystem;
+    clock;
+    spec = findSpec;
+    constructor(fileSystem, clock) {
+        this.fileSystem = fileSystem;
+        this.clock = clock;
+    }
+    async execute(input, context) {
+        const folder = path.resolve(context.cwd, input.folder);
+        const stat = await this.fileSystem.stat(folder);
+        if (stat === null)
+            throw new NotFoundError("core.fs.not-found", { path: folder });
+        if (stat.kind !== "directory")
+            throw new NotFoundError("core.path.not-a-folder", { path: folder });
+        const now = this.clock.now();
+        const newer = input.newer === undefined ? undefined : parseTime(input.newer, now);
+        const older = input.older === undefined ? undefined : parseTime(input.older, now);
+        const pattern = input.name === undefined ? undefined : globToRegExp(input.name);
+        const patternHasSlash = input.name?.includes("/") === true;
+        const extensions = new Set(input.extensions);
+        const sizeFilter = input.larger !== undefined || input.smaller !== undefined;
+        const matches = [];
+        let total = 0;
+        let totalBytes = 0;
+        for await (const entry of walk(this.fileSystem, folder, { all: input.all })) {
+            if (context.signal.aborted)
+                break;
+            const isDirectory = entry.kind === "directory";
+            if (input.type === "file" && isDirectory)
+                continue;
+            if (input.type === "dir" && !isDirectory)
+                continue;
+            if (pattern !== undefined && !pattern.test(patternHasSlash ? entry.rel : entry.name))
+                continue;
+            if (extensions.size > 0 && (isDirectory || !extensions.has(path.extname(entry.name).toLowerCase())))
+                continue;
+            if (sizeFilter && isDirectory)
+                continue;
+            const entryStat = await this.fileSystem.lstat(entry.path);
+            if (entryStat === null)
+                continue;
+            if (input.larger !== undefined && entryStat.size <= input.larger)
+                continue;
+            if (input.smaller !== undefined && entryStat.size >= input.smaller)
+                continue;
+            if (newer !== undefined && entryStat.modifiedMs < newer)
+                continue;
+            if (older !== undefined && entryStat.modifiedMs > older)
+                continue;
+            if (input.empty) {
+                const empty = isDirectory
+                    ? (await this.fileSystem.readDirectory(entry.path)).length === 0
+                    : entryStat.size === 0;
+                if (!empty)
+                    continue;
+            }
+            total += 1;
+            if (!isDirectory)
+                totalBytes += entryStat.size;
+            if (matches.length < input.limit) {
+                matches.push({
+                    path: entry.path,
+                    kind: entry.kind,
+                    size: isDirectory ? 0 : entryStat.size,
+                    modifiedMs: entryStat.modifiedMs,
+                });
+            }
+        }
+        return done({ folder, matches, total, totalBytes });
+    }
+}
+//# sourceMappingURL=find-files.use-case.js.map

package/dist/src/modules/files/application/hash-files.use-case.js

@@ -0,0 +1,73 @@
+import { expandPaths } from "../../../core/application/paths.js";
+import { done } from "../../../core/domain/command.js";
+import { UsageError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { message } from "../../../core/domain/message.js";
+import { HASH_ALGORITHMS } from "../../../core/domain/ports/hasher.js";
+export const hashSpec = {
+    id: "files.hash",
+    summary: "files.hash.summary",
+    examples: [
+        "kiriya files hash setup.exe",
+        'kiriya files hash "dist/*" --algo sha512',
+        "kiriya files hash node.tar.gz --check <expected-sha256>",
+    ],
+    safety: "read",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [{ name: "paths", description: "files.hash.arg.paths", required: true, variadic: true, path: true }],
+        options: {
+            algo: { type: "string", description: "files.hash.option.algo", valueName: `<${HASH_ALGORITHMS.join("|")}>` },
+            check: { type: "string", description: "files.hash.option.check", valueName: "<hex>" },
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return {
+                paths: reader.positionalsFrom(0),
+                algorithm: reader.choice("algo", HASH_ALGORITHMS, "sha256"),
+                check: reader.string("check")?.trim().toLowerCase(),
+            };
+        },
+    },
+};
+export class HashFiles {
+    fileSystem;
+    hasher;
+    spec = hashSpec;
+    constructor(fileSystem, hasher) {
+        this.fileSystem = fileSystem;
+        this.hasher = hasher;
+    }
+    async execute(input, context) {
+        const warnings = [];
+        const files = [];
+        for (const target of await expandPaths(this.fileSystem, input.paths, context.cwd, false)) {
+            if ((await this.fileSystem.lstat(target))?.kind === "file")
+                files.push(target);
+            else
+                warnings.push(message("files.hash.not-a-file", { path: target }));
+        }
+        if (input.check !== undefined) {
+            const [file, ...rest] = files;
+            if (file === undefined || rest.length > 0)
+                throw new UsageError("files.hash.check-one");
+            const actual = await this.hasher.hashFile(file, input.algorithm);
+            const matches = actual === input.check;
+            const failures = matches
+                ? []
+                : [message("files.hash.mismatch", { algorithm: input.algorithm, expected: input.check, actual })];
+            const check = { path: file, expected: input.check, actual, matches };
+            return done({ algorithm: input.algorithm, files: [{ path: file, hash: actual }], check }, { warnings, failures });
+        }
+        const hashed = [];
+        for (const file of files) {
+            if (context.signal.aborted)
+                break;
+            hashed.push({ path: file, hash: await this.hasher.hashFile(file, input.algorithm) });
+        }
+        return done({ algorithm: input.algorithm, files: hashed, check: null }, { warnings });
+    }
+}
+//# sourceMappingURL=hash-files.use-case.js.map

package/dist/src/modules/files/application/list-entries.use-case.js

@@ -0,0 +1,87 @@
+import path from "node:path";
+import { done } from "../../../core/domain/command.js";
+import { NotFoundError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { byCodePoint, isHiddenName } from "../../../core/domain/names.js";
+export const LIST_SORTS = ["name", "size", "time"];
+export const listSpec = {
+    id: "files.list",
+    summary: "files.list.summary",
+    examples: ["kiriya files list", "kiriya files list src --sort size", "kiriya files list --all --json"],
+    safety: "read",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [{ name: "path", description: "files.list.arg.path", required: false, variadic: false, path: true }],
+        options: {
+            all: { type: "boolean", description: "files.option.all" },
+            sort: { type: "string", description: "files.list.option.sort", valueName: "<name|size|time>" },
+            reverse: { type: "boolean", description: "files.list.option.reverse" },
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return {
+                path: reader.positional(0) ?? ".",
+                all: reader.flag("all"),
+                sort: reader.choice("sort", LIST_SORTS, "name"),
+                reverse: reader.flag("reverse"),
+            };
+        },
+    },
+};
+export class ListEntries {
+    fileSystem;
+    spec = listSpec;
+    constructor(fileSystem) {
+        this.fileSystem = fileSystem;
+    }
+    async execute(input, context) {
+        const target = path.resolve(context.cwd, input.path);
+        const stat = await this.fileSystem.lstat(target);
+        if (stat === null)
+            throw new NotFoundError("core.fs.not-found", { path: target });
+        const entries = [];
+        let hidden = 0;
+        if (stat.kind === "directory") {
+            for (const entry of await this.fileSystem.readDirectory(target)) {
+                if (!input.all && isHiddenName(entry.name)) {
+                    hidden += 1;
+                    continue;
+                }
+                const listed = await this.describe(path.join(target, entry.name), entry.name);
+                if (listed !== null)
+                    entries.push(listed);
+            }
+        }
+        else {
+            const listed = await this.describe(target, path.basename(target));
+            if (listed !== null)
+                entries.push(listed);
+        }
+        const byName = (a, b) => Number(b.kind === "directory") - Number(a.kind === "directory") || byCodePoint(a.name, b.name);
+        const order = input.sort === "size"
+            ? (a, b) => b.size - a.size || byName(a, b)
+            : input.sort === "time"
+                ? (a, b) => b.modifiedMs - a.modifiedMs || byName(a, b)
+                : byName;
+        entries.sort(order);
+        if (input.reverse)
+            entries.reverse();
+        return done({ path: target, entries, hidden });
+    }
+    async describe(entryPath, name) {
+        const stat = await this.fileSystem.lstat(entryPath);
+        if (stat === null)
+            return null;
+        return {
+            name,
+            path: entryPath,
+            kind: stat.kind,
+            size: stat.kind === "file" ? stat.size : 0,
+            modifiedMs: stat.modifiedMs,
+            target: stat.kind === "symlink" ? await this.fileSystem.readLink(entryPath) : null,
+        };
+    }
+}
+//# sourceMappingURL=list-entries.use-case.js.map

package/dist/src/modules/files/application/measure-folders.use-case.js

@@ -0,0 +1,102 @@
+import path from "node:path";
+import { REBUILDABLE_DIRECTORIES } from "../../../config/rebuildable-directories.js";
+import { done } from "../../../core/domain/command.js";
+import { KiriyaError, NotFoundError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { byCodePoint } from "../../../core/domain/names.js";
+export const sizeSpec = {
+    id: "files.size",
+    summary: "files.size.summary",
+    examples: ["kiriya files size", "kiriya files size ~/projects --top 30", "kiriya files size --json"],
+    safety: "read",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [
+            { name: "folder", description: "files.size.arg.folder", required: false, variadic: false, path: true },
+        ],
+        options: { top: { type: "string", description: "files.size.option.top", valueName: "<n>" } },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return { folder: reader.positional(0) ?? ".", top: reader.positiveInteger("top", 15) };
+        },
+    },
+};
+export class MeasureFolders {
+    fileSystem;
+    spec = sizeSpec;
+    constructor(fileSystem) {
+        this.fileSystem = fileSystem;
+    }
+    async execute(input, context) {
+        const folder = path.resolve(context.cwd, input.folder);
+        const stat = await this.fileSystem.stat(folder);
+        if (stat === null)
+            throw new NotFoundError("core.fs.not-found", { path: folder });
+        if (stat.kind !== "directory")
+            throw new NotFoundError("core.path.not-a-folder", { path: folder });
+        const rows = [];
+        let looseBytes = 0;
+        for (const entry of await this.fileSystem.readDirectory(folder)) {
+            if (context.signal.aborted)
+                break;
+            const entryPath = path.join(folder, entry.name);
+            if (entry.kind === "directory") {
+                const size = await this.measure(entryPath, REBUILDABLE_DIRECTORIES.has(entry.name));
+                rows.push({ name: entry.name, path: entryPath, bytes: size.total, rebuildableBytes: size.rebuildable });
+            }
+            else if (entry.kind === "file") {
+                looseBytes += await this.sizeOf(entryPath);
+            }
+        }
+        rows.sort((a, b) => b.bytes - a.bytes || byCodePoint(a.name, b.name));
+        return done({
+            folder,
+            bytes: rows.reduce((sum, row) => sum + row.bytes, looseBytes),
+            rebuildableBytes: rows.reduce((sum, row) => sum + row.rebuildableBytes, 0),
+            looseBytes,
+            top: input.top,
+            rows,
+        });
+    }
+    /** Symlinks are skipped, so a link can never count a folder twice or loop. */
+    async measure(folder, rebuildable) {
+        const size = { total: 0, rebuildable: 0 };
+        let entries;
+        try {
+            entries = await this.fileSystem.readDirectory(folder);
+        }
+        catch (error) {
+            if (error instanceof KiriyaError)
+                return size;
+            throw error;
+        }
+        for (const entry of entries) {
+            const entryPath = path.join(folder, entry.name);
+            if (entry.kind === "directory") {
+                const inner = await this.measure(entryPath, rebuildable || REBUILDABLE_DIRECTORIES.has(entry.name));
+                size.total += inner.total;
+                size.rebuildable += inner.rebuildable;
+            }
+            else if (entry.kind === "file") {
+                const bytes = await this.sizeOf(entryPath);
+                size.total += bytes;
+                if (rebuildable)
+                    size.rebuildable += bytes;
+            }
+        }
+        return size;
+    }
+    async sizeOf(file) {
+        try {
+            return (await this.fileSystem.lstat(file))?.size ?? 0;
+        }
+        catch (error) {
+            if (error instanceof KiriyaError)
+                return 0;
+            throw error;
+        }
+    }
+}
+//# sourceMappingURL=measure-folders.use-case.js.map

package/dist/src/modules/files/application/move-entry.js

@@ -0,0 +1,19 @@
+/**
+ * Renames or moves without replacing anything. A change of case alone goes through a
+ * temporary name, because case-insensitive drives on Windows and macOS see one entry.
+ */
+export async function moveEntry(fileSystem, from, to) {
+    if (from === to)
+        return;
+    if (await fileSystem.sameEntry(from, to)) {
+        let temporary = `${to}.kiriya-rename`;
+        for (let attempt = 1; (await fileSystem.lstat(temporary)) !== null; attempt += 1) {
+            temporary = `${to}.kiriya-rename-${attempt}`;
+        }
+        await fileSystem.move(from, temporary);
+        await fileSystem.move(temporary, to);
+        return;
+    }
+    await fileSystem.move(from, to);
+}
+//# sourceMappingURL=move-entry.js.map