kiriya 0.1.0

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

@@ -0,0 +1,80 @@
+import path from "node:path";
+import { expandPaths, measure } from "../../../core/application/paths.js";
+import { done } from "../../../core/domain/command.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { isHiddenName } from "../../../core/domain/names.js";
+import { HASH_ALGORITHMS } from "../../../core/domain/ports/hasher.js";
+function symbolic(mode) {
+    let text = "";
+    for (const shift of [6, 3, 0]) {
+        ["r", "w", "x"].forEach((bit, index) => {
+            text += mode & (1 << (shift + 2 - index)) ? bit : "-";
+        });
+    }
+    return text;
+}
+export const infoSpec = {
+    id: "files.info",
+    summary: "files.info.summary",
+    examples: [
+        "kiriya files info package.json",
+        "kiriya files info src --json",
+        'kiriya files info "dist/*.zip" --hash sha256',
+    ],
+    safety: "read",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [{ name: "paths", description: "files.info.arg.paths", required: true, variadic: true, path: true }],
+        options: {
+            hash: { type: "string", description: "files.info.option.hash", valueName: `<${HASH_ALGORITHMS.join("|")}>` },
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            const hash = reader.string("hash") === undefined ? undefined : reader.choice("hash", HASH_ALGORITHMS, "sha256");
+            return { paths: reader.positionalsFrom(0), hash };
+        },
+    },
+};
+export class ShowInfo {
+    fileSystem;
+    hasher;
+    environment;
+    spec = infoSpec;
+    constructor(fileSystem, hasher, environment) {
+        this.fileSystem = fileSystem;
+        this.hasher = hasher;
+        this.environment = environment;
+    }
+    async execute(input, context) {
+        const items = [];
+        for (const target of await expandPaths(this.fileSystem, input.paths, context.cwd, false)) {
+            const stat = await this.fileSystem.lstat(target);
+            if (stat === null)
+                continue;
+            const size = stat.kind === "directory" ? await measure(this.fileSystem, target) : null;
+            const hash = input.hash !== undefined && stat.kind === "file"
+                ? { algorithm: input.hash, value: await this.hasher.hashFile(target, input.hash) }
+                : null;
+            items.push({
+                path: target,
+                kind: stat.kind,
+                target: stat.kind === "symlink" ? await this.fileSystem.readLink(target) : null,
+                bytes: size === null ? stat.size : size.bytes,
+                contents: size === null ? null : { files: size.files, directories: size.directories },
+                createdMs: stat.createdMs,
+                modifiedMs: stat.modifiedMs,
+                accessedMs: stat.accessedMs,
+                writable: (stat.mode & 0o200) !== 0,
+                permissions: this.environment.os === "windows"
+                    ? null
+                    : { symbolic: symbolic(stat.mode), octal: (stat.mode & 0o777).toString(8).padStart(3, "0") },
+                hidden: isHiddenName(path.basename(target)),
+                hash,
+            });
+        }
+        return done({ items });
+    }
+}
+//# sourceMappingURL=show-info.use-case.js.map

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

@@ -0,0 +1,75 @@
+import path from "node:path";
+import { DEPENDENCY_DIRECTORIES } from "../../../config/dependency-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, isHiddenName } from "../../../core/domain/names.js";
+export const treeSpec = {
+    id: "files.tree",
+    summary: "files.tree.summary",
+    examples: ["kiriya files tree", "kiriya files tree src --depth 5", "kiriya files tree --all --json"],
+    safety: "read",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [{ name: "path", description: "files.tree.arg.path", required: false, variadic: false, path: true }],
+        options: {
+            depth: { type: "string", description: "files.tree.option.depth", valueName: "<n>" },
+            all: { type: "boolean", description: "files.tree.option.all" },
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return { path: reader.positional(0) ?? ".", depth: reader.positiveInteger("depth", 3), all: reader.flag("all") };
+        },
+    },
+};
+export class ShowTree {
+    fileSystem;
+    spec = treeSpec;
+    constructor(fileSystem) {
+        this.fileSystem = fileSystem;
+    }
+    async execute(input, context) {
+        const root = path.resolve(context.cwd, input.path);
+        const stat = await this.fileSystem.stat(root);
+        if (stat === null)
+            throw new NotFoundError("core.fs.not-found", { path: root });
+        if (stat.kind !== "directory")
+            throw new NotFoundError("core.path.not-a-folder", { path: root });
+        const counts = { directories: 0, files: 0 };
+        const nodes = await this.children(root, 1, input, counts);
+        return done({ root, depth: input.depth, nodes, ...counts });
+    }
+    async children(folder, depth, input, counts) {
+        const entries = [...(await this.fileSystem.readDirectory(folder))]
+            .filter((entry) => input.all || !isHiddenName(entry.name))
+            .sort((a, b) => Number(b.kind === "directory") - Number(a.kind === "directory") || byCodePoint(a.name, b.name));
+        const nodes = [];
+        for (const entry of entries) {
+            const entryPath = path.join(folder, entry.name);
+            const isFolder = entry.kind === "directory";
+            const closed = isFolder && !input.all && DEPENDENCY_DIRECTORIES.has(entry.name);
+            if (isFolder)
+                counts.directories += 1;
+            else
+                counts.files += 1;
+            let children = [];
+            let unreadable = false;
+            if (isFolder && !closed && depth < input.depth) {
+                try {
+                    children = await this.children(entryPath, depth + 1, input, counts);
+                }
+                catch (error) {
+                    if (!(error instanceof KiriyaError))
+                        throw error;
+                    unreadable = true;
+                }
+            }
+            const target = entry.kind === "symlink" ? await this.fileSystem.readLink(entryPath) : null;
+            nodes.push({ name: entry.name, kind: entry.kind, target, closed, unreadable, children });
+        }
+        return nodes;
+    }
+}
+//# sourceMappingURL=show-tree.use-case.js.map

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

@@ -0,0 +1,162 @@
+import path from "node:path";
+import { isInside } from "../../../core/application/paths.js";
+import { requireApproval, requireTypedConfirmation } from "../../../core/application/safety.js";
+import { walk } from "../../../core/application/walk.js";
+import { done, preview } from "../../../core/domain/command.js";
+import { KiriyaError, NotFoundError, OperationFailedError, RefusedError, UsageError, } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { message } from "../../../core/domain/message.js";
+import { planSync } from "../domain/sync-plan.js";
+const osPath = (root, rel) => path.join(root, ...rel.split("/"));
+export const syncSpec = {
+    id: "files.sync",
+    summary: "files.sync.summary",
+    examples: [
+        "kiriya files sync photos E:/backup/photos",
+        "kiriya files sync site dist --apply",
+        "kiriya files sync docs ../mirror/docs --delete --apply",
+    ],
+    safety: "destroy",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [
+            { name: "source", description: "files.sync.arg.source", required: true, variadic: false, path: true },
+            { name: "target", description: "files.sync.arg.target", required: true, variadic: false, path: true },
+        ],
+        options: {
+            delete: { type: "boolean", description: "files.sync.option.delete" },
+            apply: { type: "boolean", description: "files.sync.option.apply" },
+            yes: { type: "boolean", description: "files.sync.option.yes", short: "y", terminalOnly: true },
+            confirm: { type: "string", description: "files.sync.option.confirm", valueName: "<name>", terminalOnly: true },
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return {
+                source: reader.positional(0) ?? "",
+                target: reader.positional(1) ?? "",
+                withDelete: reader.flag("delete"),
+                apply: reader.flag("apply"),
+                yes: reader.flag("yes"),
+                confirm: reader.string("confirm"),
+            };
+        },
+    },
+};
+export class SyncFolders {
+    fileSystem;
+    environment;
+    spec = syncSpec;
+    constructor(fileSystem, environment) {
+        this.fileSystem = fileSystem;
+        this.environment = environment;
+    }
+    async execute(input, context) {
+        const source = path.resolve(context.cwd, input.source);
+        const target = path.resolve(context.cwd, input.target);
+        await this.checkPair(source, target);
+        const plan = planSync(await this.snapshot(source), await this.snapshot(target), input.withDelete);
+        const data = {
+            source,
+            target,
+            copy: plan.copy,
+            update: plan.update,
+            remove: plan.remove,
+            bytes: plan.bytes,
+            applied: false,
+        };
+        if (plan.copy.length + plan.update.length + plan.remove.length === 0)
+            return done(data);
+        if (!input.apply)
+            return preview(data, "--apply");
+        if (plan.remove.length > 0) {
+            const warning = message("files.sync.warn-delete", { count: plan.remove.length, target });
+            await requireTypedConfirmation(context, warning, path.basename(target), input.confirm);
+        }
+        else {
+            const question = message("files.sync.ask", { count: plan.copy.length + plan.update.length, target });
+            await requireApproval(context, question, input.yes);
+        }
+        const failures = [];
+        for (const rel of [...plan.copy, ...plan.update]) {
+            if (context.signal.aborted)
+                break;
+            const to = osPath(target, rel);
+            try {
+                await this.fileSystem.createDirectory(path.dirname(to));
+                // Copying keeps the source's modification time, so the next sync sees the file as unchanged.
+                await this.fileSystem.copy(osPath(source, rel), to, true);
+            }
+            catch (error) {
+                if (!(error instanceof KiriyaError))
+                    throw error;
+                failures.push(error.detail);
+            }
+        }
+        for (const rel of plan.remove) {
+            const doomed = osPath(target, rel);
+            if (!isInside(doomed, target))
+                throw new OperationFailedError("files.sync.outside", { path: doomed });
+            try {
+                await this.fileSystem.remove(doomed);
+            }
+            catch (error) {
+                if (!(error instanceof KiriyaError))
+                    throw error;
+                if (!(error instanceof NotFoundError))
+                    failures.push(error.detail);
+            }
+        }
+        for (const rel of plan.removeDirectories) {
+            try {
+                await this.fileSystem.removeEmptyDirectory(osPath(target, rel));
+            }
+            catch (error) {
+                // A folder that cannot go is left in place; the files that mattered are already handled.
+                if (!(error instanceof KiriyaError))
+                    throw error;
+            }
+        }
+        return done({ ...data, applied: true }, { failures });
+    }
+    /** Refuses pairs where a sync could clobber the source, or wipe a drive or a home folder by mistake. */
+    async checkPair(source, target) {
+        if ((await this.fileSystem.stat(source))?.kind !== "directory") {
+            throw new UsageError("files.sync.source-not-folder", { path: source });
+        }
+        if (isInside(target, source) || isInside(source, target))
+            throw new UsageError("files.sync.nested");
+        if (target === path.parse(target).root) {
+            throw new RefusedError("core.guard.refused", {
+                path: target,
+                reason: message("core.guard.drive-root", { path: target }),
+            });
+        }
+        if (target.toLowerCase() === path.resolve(this.environment.homeDirectory).toLowerCase()) {
+            throw new RefusedError("core.guard.refused", {
+                path: target,
+                reason: message("core.guard.home", { path: target }),
+            });
+        }
+    }
+    /** Files and folders below root; symlinks are left out. A missing root is empty. */
+    async snapshot(root) {
+        const files = new Map();
+        const directories = new Set();
+        if ((await this.fileSystem.stat(root))?.kind !== "directory")
+            return { files, directories };
+        for await (const entry of walk(this.fileSystem, root, { all: true })) {
+            if (entry.kind === "directory") {
+                directories.add(entry.rel);
+            }
+            else if (entry.kind === "file") {
+                const stat = await this.fileSystem.lstat(entry.path);
+                if (stat !== null)
+                    files.set(entry.rel, { size: stat.size, modifiedMs: stat.modifiedMs });
+            }
+        }
+        return { files, directories };
+    }
+}
+//# sourceMappingURL=sync-folders.use-case.js.map

package/dist/src/modules/files/application/text-files.js

@@ -0,0 +1,46 @@
+import path from "node:path";
+import { walk } from "../../../core/application/walk.js";
+import { KiriyaError } from "../../../core/domain/errors.js";
+import { globToRegExp } from "../../../core/domain/glob.js";
+import { decodeText, MAX_TEXT_BYTES } from "../domain/text-encoding.js";
+/** A text file, or null when it is binary, larger than MAX_TEXT_BYTES, or unreadable. */
+export async function readTextFile(fileSystem, content, target) {
+    try {
+        const stat = await fileSystem.stat(target);
+        if (stat?.kind !== "file" || stat.size > MAX_TEXT_BYTES)
+            return null;
+        return decodeText(await content.read(target));
+    }
+    catch (error) {
+        if (error instanceof KiriyaError)
+            return null;
+        throw error;
+    }
+}
+/**
+ * Files at or below the given paths. A file named directly is always kept; files
+ * found inside folders must pass the extension list and the name glob, which
+ * matches the name, or the path relative to the folder when the glob has a `/`.
+ */
+export async function selectFiles(fileSystem, paths, selection) {
+    const extensions = new Set(selection.extensions);
+    const pattern = selection.name === undefined ? null : globToRegExp(selection.name);
+    const patternHasSlash = selection.name?.includes("/") === true;
+    const keep = (name, rel) => (extensions.size === 0 || extensions.has(path.extname(name).toLowerCase())) &&
+        (pattern === null || pattern.test(patternHasSlash ? rel : name));
+    const files = [];
+    for (const target of paths) {
+        const stat = await fileSystem.lstat(target);
+        if (stat?.kind === "file") {
+            files.push(target);
+        }
+        else if (stat?.kind === "directory") {
+            for await (const entry of walk(fileSystem, target, { all: selection.all })) {
+                if (entry.kind === "file" && keep(entry.name, entry.rel))
+                    files.push(entry.path);
+            }
+        }
+    }
+    return files;
+}
+//# sourceMappingURL=text-files.js.map

package/dist/src/modules/files/application/transfers.js

@@ -0,0 +1,35 @@
+import path from "node:path";
+import { expandPaths, isInside, outermost } from "../../../core/application/paths.js";
+import { UsageError } from "../../../core/domain/errors.js";
+/**
+ * Where copy and move put things. Several sources, a target that is a folder, or a
+ * target ending in a separator: into that folder. One source and a new name: at that name.
+ */
+export async function planTransfers(fileSystem, sourceArgs, targetArg, cwd, windows) {
+    const target = path.resolve(cwd, targetArg);
+    const sources = outermost(await expandPaths(fileSystem, sourceArgs, cwd, false));
+    const endsWithSeparator = targetArg.endsWith("/") || (windows && targetArg.endsWith("\\"));
+    const only = sources.length === 1 ? sources[0] : undefined;
+    const renamingCase = only !== undefined && (await fileSystem.sameEntry(only, target));
+    const intoFolder = !renamingCase && (sources.length > 1 || endsWithSeparator || (await fileSystem.stat(target))?.kind === "directory");
+    const seen = new Set();
+    const transfers = [];
+    for (const source of sources) {
+        const destination = intoFolder ? path.join(target, path.basename(source)) : target;
+        if (path.resolve(source) === path.resolve(destination)) {
+            throw new UsageError("files.transfer.already-there", { path: source });
+        }
+        if (!renamingCase && isInside(destination, source)) {
+            throw new UsageError("files.transfer.into-itself", { path: source });
+        }
+        // Compared without case, because two such names are one file on Windows and macOS.
+        const key = destination.toLowerCase();
+        if (seen.has(key))
+            throw new UsageError("files.transfer.same-destination", { path: destination });
+        seen.add(key);
+        const conflict = (await fileSystem.lstat(destination)) !== null && !(await fileSystem.sameEntry(source, destination));
+        transfers.push({ source, destination, conflict });
+    }
+    return transfers;
+}
+//# sourceMappingURL=transfers.js.map

package/dist/src/modules/files/domain/case-style.js

@@ -0,0 +1,18 @@
+import { isHiddenName } from "../../../core/domain/names.js";
+import { toCase } from "../../../core/domain/text-case.js";
+/** The cases a file name can take; `constant` and `title` suit text better than names. */
+export const CASE_STYLES = ["kebab", "snake", "camel", "pascal", "lower", "upper"];
+/**
+ * A name in another case. Only the part before the first dot changes, so suffixes
+ * and extensions stay (`UserService.test.ts` -> `user-service.test.ts`) and
+ * dotfiles such as `.gitignore` keep their name.
+ */
+export function renameByCase(name, style) {
+    if (isHiddenName(name))
+        return name;
+    const dot = name.indexOf(".");
+    const stem = dot < 0 ? name : name.slice(0, dot);
+    const rest = dot < 0 ? "" : name.slice(dot);
+    return `${toCase(stem, style)}${rest}`;
+}
+//# sourceMappingURL=case-style.js.map

package/dist/src/modules/files/domain/filters.js

@@ -0,0 +1,9 @@
+/** Extension flags as given, such as ".ts,tsx" twice, as a lower-case list with dots: [".ts", ".tsx"]. */
+export function parseExtensions(values) {
+    return values
+        .flatMap((value) => value.split(","))
+        .map((extension) => extension.trim())
+        .filter((extension) => extension !== "")
+        .map((extension) => `.${extension.replace(/^[.]/, "")}`.toLowerCase());
+}
+//# sourceMappingURL=filters.js.map

package/dist/src/modules/files/domain/sync-plan.js

@@ -0,0 +1,35 @@
+import { byCodePoint } from "../../../core/domain/names.js";
+/** FAT and network shares store modification times in 2-second steps. */
+export const MODIFIED_TOLERANCE_MS = 2000;
+/** Files are compared by size and modification time. */
+export function planSync(source, target, withDelete) {
+    const copy = [];
+    const update = [];
+    let bytes = 0;
+    for (const [rel, entry] of source.files) {
+        const existing = target.files.get(rel);
+        if (existing === undefined) {
+            copy.push(rel);
+            bytes += entry.size;
+        }
+        else if (existing.size !== entry.size ||
+            Math.abs(existing.modifiedMs - entry.modifiedMs) > MODIFIED_TOLERANCE_MS) {
+            update.push(rel);
+            bytes += entry.size;
+        }
+    }
+    const remove = withDelete ? [...target.files.keys()].filter((rel) => !source.files.has(rel)) : [];
+    const removeDirectories = withDelete
+        ? [...target.directories]
+            .filter((rel) => !source.directories.has(rel))
+            .sort((a, b) => b.split("/").length - a.split("/").length || byCodePoint(a, b))
+        : [];
+    return {
+        copy: copy.sort(byCodePoint),
+        update: update.sort(byCodePoint),
+        remove: remove.sort(byCodePoint),
+        removeDirectories,
+        bytes,
+    };
+}
+//# sourceMappingURL=sync-plan.js.map

package/dist/src/modules/files/domain/text-encoding.js

@@ -0,0 +1,75 @@
+export const TEXT_ENCODINGS = ["utf8", "utf8-bom", "utf16le", "utf16be"];
+/** Text files larger than this are skipped by grep and replace and refused by read. */
+export const MAX_TEXT_BYTES = 50 * 1024 * 1024;
+const BOM = String.fromCharCode(0xfeff);
+const NUL = String.fromCharCode(0);
+function swapPairs(bytes) {
+    const swapped = new Uint8Array(bytes.length - (bytes.length % 2));
+    for (let index = 0; index + 1 < bytes.length; index += 2) {
+        swapped[index] = bytes[index + 1] ?? 0;
+        swapped[index + 1] = bytes[index] ?? 0;
+    }
+    return swapped;
+}
+/** A NUL anywhere, or more than 10% control characters in the first 8000, means the bytes are not text. */
+function looksBinary(text) {
+    if (text.includes(NUL))
+        return true;
+    const sample = text.slice(0, 8000);
+    let control = 0;
+    for (let index = 0; index < sample.length; index += 1) {
+        const code = sample.charCodeAt(index);
+        if (code < 32 && code !== 9 && code !== 10 && code !== 12 && code !== 13 && code !== 27)
+            control += 1;
+    }
+    return sample.length > 0 && control / sample.length > 0.1;
+}
+/** Text with the encoding it was stored in, or null when the bytes are not text. */
+export function decodeText(bytes) {
+    const checked = (text, encoding) => looksBinary(text) ? null : { text, encoding };
+    if (bytes[0] === 0xff && bytes[1] === 0xfe) {
+        return checked(new TextDecoder("utf-16le", { ignoreBOM: true }).decode(bytes.subarray(2)), "utf16le");
+    }
+    if (bytes[0] === 0xfe && bytes[1] === 0xff) {
+        return checked(new TextDecoder("utf-16le", { ignoreBOM: true }).decode(swapPairs(bytes.subarray(2))), "utf16be");
+    }
+    const bom = bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf;
+    try {
+        const text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bom ? bytes.subarray(3) : bytes);
+        return checked(text, bom ? "utf8-bom" : "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+function utf16(text, littleEndian) {
+    const bytes = new Uint8Array(text.length * 2);
+    const view = new DataView(bytes.buffer);
+    for (let index = 0; index < text.length; index += 1)
+        view.setUint16(index * 2, text.charCodeAt(index), littleEndian);
+    return bytes;
+}
+/** The bytes decodeText read: the encoding and its byte-order mark are kept. */
+export function encodeText(file) {
+    switch (file.encoding) {
+        case "utf8":
+            return new TextEncoder().encode(file.text);
+        case "utf8-bom":
+            return new TextEncoder().encode(BOM + file.text);
+        case "utf16le":
+            return utf16(BOM + file.text, true);
+        case "utf16be":
+            return utf16(BOM + file.text, false);
+    }
+}
+/** Lines without their endings; a final line ending does not start another line. */
+export function splitLines(text) {
+    const lines = text.split(/\r?\n/);
+    if (lines.length > 1 && lines[lines.length - 1] === "")
+        lines.pop();
+    return lines;
+}
+export function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//# sourceMappingURL=text-encoding.js.map

package/dist/src/modules/files/domain/values.js

@@ -0,0 +1,28 @@
+import { UsageError } from "../../../core/domain/errors.js";
+const SIZE_UNITS = { "": 1, b: 1, k: 1024, m: 1024 ** 2, g: 1024 ** 3, t: 1024 ** 4 };
+/** "500", "10KB", "1.5 MB", "2g" -> bytes, with 1 KB = 1024 bytes. */
+export function parseSize(text) {
+    const match = /^(\d+(?:[.]\d+)?)\s*([bkmgt]?)(?:i?b)?$/i.exec(text.trim());
+    const unit = SIZE_UNITS[(match?.[2] ?? "").toLowerCase()];
+    if (match === null || unit === undefined)
+        throw new UsageError("files.value.size", { value: text });
+    return Math.round(Number(match[1]) * unit);
+}
+const AGE_UNITS = {
+    m: 60_000,
+    h: 3_600_000,
+    d: 86_400_000,
+    w: 7 * 86_400_000,
+    y: 365 * 86_400_000,
+};
+/** "30m", "12h", "7d", "2w", "1y" before `now`, or a date such as 2026-01-31, as epoch milliseconds. */
+export function parseTime(text, now) {
+    const age = /^(\d+)\s*([mhdwy])$/i.exec(text.trim());
+    if (age !== null)
+        return now - Number(age[1]) * (AGE_UNITS[(age[2] ?? "").toLowerCase()] ?? 0);
+    const date = Date.parse(text);
+    if (Number.isNaN(date))
+        throw new UsageError("files.value.time", { value: text });
+    return date;
+}
+//# sourceMappingURL=values.js.map

package/dist/src/modules/files/files.module.js

@@ -0,0 +1,70 @@
+import { CleanBuilds } from "./application/clean-builds.use-case.js";
+import { ComparePaths } from "./application/compare-paths.use-case.js";
+import { CopyPaths } from "./application/copy-paths.use-case.js";
+import { CreatePaths } from "./application/create-paths.use-case.js";
+import { DeletePaths } from "./application/delete-paths.use-case.js";
+import { FindDuplicates } from "./application/find-duplicates.use-case.js";
+import { FindFiles } from "./application/find-files.use-case.js";
+import { HashFiles } from "./application/hash-files.use-case.js";
+import { ListEntries } from "./application/list-entries.use-case.js";
+import { MeasureFolders } from "./application/measure-folders.use-case.js";
+import { MovePaths } from "./application/move-paths.use-case.js";
+import { ReadText } from "./application/read-text.use-case.js";
+import { RenamePaths } from "./application/rename-paths.use-case.js";
+import { ReplaceText } from "./application/replace-text.use-case.js";
+import { SearchText } from "./application/search-text.use-case.js";
+import { ShowInfo } from "./application/show-info.use-case.js";
+import { ShowTree } from "./application/show-tree.use-case.js";
+import { SyncFolders } from "./application/sync-folders.use-case.js";
+import { cleanView } from "./presentation/clean.view.js";
+import { compareView } from "./presentation/compare.view.js";
+import { copyView } from "./presentation/copy.view.js";
+import { deleteView } from "./presentation/delete.view.js";
+import { dupesView } from "./presentation/dupes.view.js";
+import { findView } from "./presentation/find.view.js";
+import { grepView } from "./presentation/grep.view.js";
+import { hashView } from "./presentation/hash.view.js";
+import { infoView } from "./presentation/info.view.js";
+import { listView } from "./presentation/list.view.js";
+import { moveView } from "./presentation/move.view.js";
+import { newView } from "./presentation/new.view.js";
+import { readView } from "./presentation/read.view.js";
+import { renameView } from "./presentation/rename.view.js";
+import { replaceView } from "./presentation/replace.view.js";
+import { sizeView } from "./presentation/size.view.js";
+import { syncView } from "./presentation/sync.view.js";
+import { treeView } from "./presentation/tree.view.js";
+export const filesModule = {
+    id: "files",
+    summary: "files.summary",
+    about: "files.about",
+    examples: [
+        'kiriya files find --name "*.log" --older 30d',
+        "kiriya files grep TODO src --ext .ts",
+        "kiriya files delete dist --dry-run",
+        "kiriya files clean ~/projects",
+    ],
+    guide: "https://github.com/SatPaingOo/kiriya/blob/main/docs/modules/files.md",
+    register(registrar, ports) {
+        const { fileSystem, fileContent, hasher, processRunner, trash, environment, clock, protectedPaths } = ports;
+        registrar.add(new CreatePaths(fileSystem, environment), newView);
+        registrar.add(new ListEntries(fileSystem), listView);
+        registrar.add(new ShowTree(fileSystem), treeView);
+        registrar.add(new ShowInfo(fileSystem, hasher, environment), infoView);
+        registrar.add(new ReadText(fileSystem, fileContent), readView);
+        registrar.add(new FindFiles(fileSystem, clock), findView);
+        registrar.add(new SearchText(fileSystem, fileContent), grepView);
+        registrar.add(new HashFiles(fileSystem, hasher), hashView);
+        registrar.add(new FindDuplicates(fileSystem, hasher), dupesView);
+        registrar.add(new ComparePaths(fileSystem, fileContent, hasher), compareView);
+        registrar.add(new CopyPaths(fileSystem, protectedPaths, environment), copyView);
+        registrar.add(new MovePaths(fileSystem, trash, protectedPaths, environment), moveView);
+        registrar.add(new RenamePaths(fileSystem, protectedPaths), renameView);
+        registrar.add(new ReplaceText(fileSystem, fileContent), replaceView);
+        registrar.add(new DeletePaths(fileSystem, trash, protectedPaths), deleteView);
+        registrar.add(new CleanBuilds(fileSystem, processRunner, protectedPaths), cleanView);
+        registrar.add(new SyncFolders(fileSystem, environment), syncView);
+        registrar.add(new MeasureFolders(fileSystem), sizeView);
+    },
+};
+//# sourceMappingURL=files.module.js.map

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

@@ -0,0 +1,15 @@
+import { message } from "../../../core/domain/message.js";
+export const cleanView = (output, format) => {
+    const lines = output.candidates.map((candidate) => `  ${format.bytes(candidate.bytes).padStart(9)}  ${format.path(candidate.path)}  ${format.dim(format.text(candidate.reason))}`);
+    const tracked = output.tracked > 0
+        ? format.dim(` · ${format.text(message("files.clean.tracked", { count: output.tracked }))}`)
+        : "";
+    const total = message("files.clean.total", { count: output.candidates.length, size: format.bytes(output.bytes) });
+    lines.push("", `${format.text(total)}${tracked}`);
+    if (output.removed > 0) {
+        const removed = message("files.clean.done", { count: output.removed, size: format.bytes(output.bytes) });
+        lines.push(format.green(format.text(removed)));
+    }
+    return lines;
+};
+//# sourceMappingURL=clean.view.js.map