kiriya 0.1.0

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

@@ -0,0 +1,82 @@
+import path from "node:path";
+import { refuseProtected, requireTypedConfirmation } from "../../../core/application/safety.js";
+import { done, preview } from "../../../core/domain/command.js";
+import { KiriyaError } from "../../../core/domain/errors.js";
+import { message } from "../../../core/domain/message.js";
+import { transferInput } from "./copy-paths.use-case.js";
+import { moveEntry } from "./move-entry.js";
+import { planTransfers } from "./transfers.js";
+export const moveSpec = {
+    id: "files.move",
+    summary: "files.move.summary",
+    examples: [
+        "kiriya files move draft.md docs/",
+        "kiriya files move readme.md README.md",
+        'kiriya files move "*.log" D:/archive/logs/ --dry-run',
+    ],
+    // Replaced destinations go to the trash, so even --overwrite can be undone.
+    safety: "write",
+    idempotent: false,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: transferInput,
+};
+export class MovePaths {
+    fileSystem;
+    trash;
+    protectedPaths;
+    environment;
+    spec = moveSpec;
+    constructor(fileSystem, trash, protectedPaths, environment) {
+        this.fileSystem = fileSystem;
+        this.trash = trash;
+        this.protectedPaths = protectedPaths;
+        this.environment = environment;
+    }
+    async execute(input, context) {
+        const windows = this.environment.os === "windows";
+        const transfers = await planTransfers(this.fileSystem, input.sources, input.target, context.cwd, windows);
+        refuseProtected(this.protectedPaths, transfers.map((transfer) => transfer.source), context.cwd);
+        const planned = transfers.map((transfer) => ({ ...transfer, outcome: "planned", reason: null }));
+        const conflicts = planned.filter((item) => item.conflict);
+        const data = { items: planned, conflicts: conflicts.length };
+        if (input.dryRun)
+            return preview(data, "");
+        if (conflicts.length > 0) {
+            if (!input.overwrite) {
+                return done(data, {
+                    failures: conflicts.map((item) => message("core.fs.exists", { path: item.destination })),
+                    warnings: [message("files.transfer.nothing-changed")],
+                });
+            }
+            const destinations = conflicts.map((item) => item.destination);
+            refuseProtected(this.protectedPaths, destinations, context.cwd);
+            const warning = message("files.move.warn-overwrite", {
+                count: conflicts.length,
+                location: message(this.trash.location),
+            });
+            await requireTypedConfirmation(context, warning, String(conflicts.length), input.confirm);
+            const outcomes = await this.trash.send(destinations);
+            const refused = outcomes.flatMap((outcome) => outcome.ok ? [] : [message("files.move.trash-failed", { path: outcome.path, reason: outcome.reason })]);
+            if (refused.length > 0)
+                return done(data, { failures: refused, warnings: [message("files.move.nothing-moved")] });
+        }
+        const items = [];
+        const failures = [];
+        for (const item of planned) {
+            try {
+                await this.fileSystem.createDirectory(path.dirname(item.destination));
+                await moveEntry(this.fileSystem, item.source, item.destination);
+                items.push({ ...item, outcome: "moved" });
+            }
+            catch (error) {
+                if (!(error instanceof KiriyaError))
+                    throw error;
+                items.push({ ...item, outcome: "failed", reason: error.detail });
+                failures.push(error.detail);
+            }
+        }
+        return done({ ...data, items }, { failures });
+    }
+}
+//# sourceMappingURL=move-paths.use-case.js.map

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

@@ -0,0 +1,92 @@
+import path from "node:path";
+import { done } from "../../../core/domain/command.js";
+import { NotFoundError, OperationFailedError, UsageError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { formatBytes } from "../../../core/domain/values/bytes.js";
+import { MAX_TEXT_BYTES, splitLines } from "../domain/text-encoding.js";
+import { readTextFile } from "./text-files.js";
+export const readSpec = {
+    id: "files.read",
+    summary: "files.read.summary",
+    examples: [
+        "kiriya files read README.md",
+        "kiriya files read app.log --tail 50",
+        "kiriya files read query.sql --lines 10-20 --number",
+    ],
+    safety: "read",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [{ name: "file", description: "files.read.arg.file", required: true, variadic: false, path: true }],
+        options: {
+            head: { type: "string", description: "files.read.option.head", valueName: "<n>" },
+            tail: { type: "string", description: "files.read.option.tail", valueName: "<n>" },
+            lines: { type: "string", description: "files.read.option.lines", valueName: "<from>-<to>" },
+            number: { type: "boolean", description: "files.read.option.number" },
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            const head = reader.string("head") === undefined ? undefined : reader.positiveInteger("head", 1);
+            const tail = reader.string("tail") === undefined ? undefined : reader.positiveInteger("tail", 1);
+            const lines = reader.string("lines");
+            if ([head, tail, lines].filter((value) => value !== undefined).length > 1) {
+                throw new UsageError("files.read.one-selection");
+            }
+            let range;
+            if (lines !== undefined) {
+                const match = /^(\d+)-(\d+)$/.exec(lines.trim());
+                const from = Number(match?.[1]);
+                const to = Number(match?.[2]);
+                if (match === null || from < 1 || to < 1)
+                    throw new UsageError("files.read.lines-format");
+                if (to < from)
+                    throw new UsageError("files.read.lines-order");
+                range = { from, to };
+            }
+            return { path: reader.positional(0) ?? "", head, tail, range, number: reader.flag("number") };
+        },
+    },
+};
+export class ReadText {
+    fileSystem;
+    content;
+    spec = readSpec;
+    constructor(fileSystem, content) {
+        this.fileSystem = fileSystem;
+        this.content = content;
+    }
+    async execute(input, context) {
+        const target = path.resolve(context.cwd, input.path);
+        const stat = await this.fileSystem.stat(target);
+        if (stat === null)
+            throw new NotFoundError("core.fs.not-found", { path: target });
+        if (stat.kind === "directory")
+            throw new UsageError("files.read.is-folder", { path: target });
+        const text = await readTextFile(this.fileSystem, this.content, target);
+        if (text === null) {
+            throw new OperationFailedError("files.read.not-text", { path: target, limit: formatBytes(MAX_TEXT_BYTES) });
+        }
+        const lines = splitLines(text.text);
+        let first = 1;
+        let last = lines.length;
+        if (input.head !== undefined)
+            last = Math.min(lines.length, input.head);
+        if (input.tail !== undefined)
+            first = Math.max(1, lines.length - input.tail + 1);
+        if (input.range !== undefined) {
+            first = input.range.from;
+            last = Math.min(lines.length, input.range.to);
+        }
+        return done({
+            path: target,
+            encoding: text.encoding,
+            first,
+            last,
+            totalLines: lines.length,
+            lines: lines.slice(first - 1, Math.max(first - 1, last)),
+            numbered: input.number,
+        });
+    }
+}
+//# sourceMappingURL=read-text.use-case.js.map

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

@@ -0,0 +1,184 @@
+import path from "node:path";
+import { expandPaths } from "../../../core/application/paths.js";
+import { refuseProtected, requireApproval } from "../../../core/application/safety.js";
+import { walk } from "../../../core/application/walk.js";
+import { done, preview } from "../../../core/domain/command.js";
+import { KiriyaError, NotFoundError, UsageError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { message } from "../../../core/domain/message.js";
+import { invalidNameReason } from "../../../core/domain/names.js";
+import { CASE_STYLES, renameByCase } from "../domain/case-style.js";
+import { moveEntry } from "./move-entry.js";
+const ONLY = ["files", "dirs"];
+export const renameSpec = {
+    id: "files.rename",
+    summary: "files.rename.summary",
+    examples: [
+        "kiriya files rename notes.txt meeting-notes.txt",
+        "kiriya files rename src/components --case kebab --recursive",
+        'kiriya files rename "photos/*.JPG" --find " " --with "-" --apply',
+    ],
+    safety: "write",
+    idempotent: false,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [
+            { name: "paths", description: "files.rename.arg.paths", required: false, variadic: true, path: true },
+        ],
+        options: {
+            case: { type: "string", description: "files.rename.option.case", valueName: `<${CASE_STYLES.join("|")}>` },
+            find: { type: "string", description: "files.rename.option.find", valueName: "<text>" },
+            with: { type: "string", description: "files.rename.option.with", valueName: "<text>" },
+            recursive: { type: "boolean", description: "files.rename.option.recursive" },
+            only: { type: "string", description: "files.rename.option.only", valueName: "<files|dirs>" },
+            apply: { type: "boolean", description: "files.rename.option.apply" },
+            yes: { type: "boolean", description: "files.rename.option.yes", short: "y", terminalOnly: true },
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            const positionals = reader.positionalsFrom(0);
+            const find = reader.string("find");
+            const replacement = reader.string("with");
+            if (reader.string("case") === undefined && find === undefined) {
+                if (replacement !== undefined)
+                    throw new UsageError("files.rename.find-with");
+                const [from, newName, ...rest] = positionals;
+                if (from === undefined || newName === undefined || rest.length > 0)
+                    throw new UsageError("files.rename.usage");
+                return { mode: "one", path: from, newName };
+            }
+            if ((find === undefined) !== (replacement === undefined))
+                throw new UsageError("files.rename.find-with");
+            if (find === "")
+                throw new UsageError("files.rename.find-empty");
+            return {
+                mode: "many",
+                paths: positionals,
+                style: reader.string("case") === undefined ? undefined : reader.choice("case", CASE_STYLES, "kebab"),
+                find,
+                replacement: replacement ?? "",
+                recursive: reader.flag("recursive"),
+                only: reader.string("only") === undefined ? undefined : reader.choice("only", ONLY, "files"),
+                apply: reader.flag("apply"),
+                yes: reader.flag("yes"),
+            };
+        },
+    },
+};
+export class RenamePaths {
+    fileSystem;
+    protectedPaths;
+    spec = renameSpec;
+    constructor(fileSystem, protectedPaths) {
+        this.fileSystem = fileSystem;
+        this.protectedPaths = protectedPaths;
+    }
+    async execute(input, context) {
+        return input.mode === "one" ? this.renameOne(input, context) : this.renameMany(input, context);
+    }
+    async renameOne(input, context) {
+        const from = path.resolve(context.cwd, input.path);
+        if ((await this.fileSystem.lstat(from)) === null)
+            throw new NotFoundError("core.fs.not-found", { path: from });
+        const invalid = invalidNameReason(input.newName);
+        if (invalid !== null) {
+            throw new UsageError("files.rename.invalid-name", { reason: message(invalid, { name: input.newName }) });
+        }
+        refuseProtected(this.protectedPaths, [from], context.cwd);
+        const to = path.join(path.dirname(from), input.newName);
+        await moveEntry(this.fileSystem, from, to);
+        return done({ mode: "one", renames: [{ from, to }], problems: [], renamed: 1 });
+    }
+    async renameMany(input, context) {
+        const args = input.paths.length === 0 ? ["."] : input.paths;
+        const folderArgs = new Set(args.map((arg) => path.resolve(context.cwd, arg)));
+        const candidates = [];
+        for (const target of await expandPaths(this.fileSystem, args, context.cwd, false)) {
+            const isDirectory = (await this.fileSystem.lstat(target))?.kind === "directory";
+            // A folder named as an argument means its contents; a folder a glob matched means itself.
+            if (!isDirectory || !folderArgs.has(target)) {
+                candidates.push({ path: target, isDirectory });
+                continue;
+            }
+            const options = input.recursive ? { all: false } : { all: false, maxDepth: 1 };
+            for await (const entry of walk(this.fileSystem, target, options)) {
+                candidates.push({ path: entry.path, isDirectory: entry.kind === "directory" });
+            }
+        }
+        const renames = [];
+        const problems = [];
+        for (const candidate of candidates) {
+            if (input.only === "files" && candidate.isDirectory)
+                continue;
+            if (input.only === "dirs" && !candidate.isDirectory)
+                continue;
+            const name = path.basename(candidate.path);
+            let next = input.find === undefined ? name : name.split(input.find).join(input.replacement);
+            if (input.style !== undefined)
+                next = renameByCase(next, input.style);
+            if (next === name)
+                continue;
+            const invalid = invalidNameReason(next);
+            if (invalid !== null) {
+                problems.push(message("files.rename.invalid", { from: candidate.path, reason: message(invalid, { name: next }) }));
+                continue;
+            }
+            renames.push({ from: candidate.path, to: path.join(path.dirname(candidate.path), next) });
+        }
+        problems.push(...(await this.clashes(renames)));
+        const data = { mode: "many", renames, problems, renamed: 0 };
+        if (problems.length > 0) {
+            return done(data, { failures: problems, warnings: [message("files.rename.nothing-renamed")] });
+        }
+        if (renames.length === 0)
+            return done(data);
+        if (!input.apply)
+            return preview(data, "--apply");
+        refuseProtected(this.protectedPaths, renames.map((rename) => rename.from), context.cwd);
+        await requireApproval(context, message("files.rename.ask", { count: renames.length }), input.yes);
+        const failures = [];
+        let renamed = 0;
+        // Deepest first, so a folder is renamed only after everything inside it.
+        for (const rename of [...renames].sort((a, b) => b.from.length - a.from.length)) {
+            try {
+                await moveEntry(this.fileSystem, rename.from, rename.to);
+                renamed += 1;
+            }
+            catch (error) {
+                if (!(error instanceof KiriyaError))
+                    throw error;
+                failures.push(error.detail);
+            }
+        }
+        return done({ ...data, renamed }, { failures });
+    }
+    /** Two renames landing on one name, compared without case as Windows and macOS do, or an existing entry. */
+    async clashes(renames) {
+        const problems = [];
+        const landing = new Map();
+        for (const rename of renames) {
+            const key = rename.to.toLowerCase();
+            const other = landing.get(key);
+            if (other !== undefined) {
+                problems.push(message("files.rename.clash", { first: other, second: rename.from, name: path.basename(rename.to) }));
+            }
+            landing.set(key, rename.from);
+            if ((await this.fileSystem.lstat(rename.to)) === null)
+                continue;
+            if (await this.fileSystem.sameEntry(rename.from, rename.to))
+                continue;
+            let movedAway = false;
+            for (const item of renames) {
+                if (item !== rename && (await this.fileSystem.sameEntry(item.from, rename.to))) {
+                    movedAway = true;
+                    break;
+                }
+            }
+            if (!movedAway)
+                problems.push(message("core.fs.exists", { path: rename.to }));
+        }
+        return problems;
+    }
+}
+//# sourceMappingURL=rename-paths.use-case.js.map

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

@@ -0,0 +1,146 @@
+import { expandPaths } from "../../../core/application/paths.js";
+import { requireApproval } from "../../../core/application/safety.js";
+import { done, preview } from "../../../core/domain/command.js";
+import { KiriyaError, UsageError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { message } from "../../../core/domain/message.js";
+import { parseExtensions } from "../domain/filters.js";
+import { encodeText, escapeRegExp } from "../domain/text-encoding.js";
+import { readTextFile, selectFiles } from "./text-files.js";
+/** Changed lines shown per file. */
+const SAMPLE_LINES = 3;
+export const replaceSpec = {
+    id: "files.replace",
+    summary: "files.replace.summary",
+    examples: [
+        "kiriya files replace OldName NewName src --ext .cs",
+        'kiriya files replace "v(\\d+)\\.0" "v$1.1" --regex --apply',
+        "kiriya files replace localhost:5000 localhost:8080 --name appsettings*.json --apply --yes",
+    ],
+    // Files are written in place and there is no undo, but --apply and a question come first.
+    safety: "write",
+    idempotent: false,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [
+            { name: "find", description: "files.replace.arg.find", required: true, variadic: false },
+            { name: "with", description: "files.replace.arg.with", required: true, variadic: false },
+            { name: "paths", description: "files.replace.arg.paths", required: false, variadic: true, path: true },
+        ],
+        options: {
+            regex: { type: "boolean", description: "files.replace.option.regex" },
+            "ignore-case": { type: "boolean", description: "files.replace.option.ignore-case", short: "i" },
+            ext: { type: "string", description: "files.option.ext", valueName: "<extensions>", multiple: true },
+            name: { type: "string", description: "files.option.name", valueName: "<glob>" },
+            all: { type: "boolean", description: "files.option.all", reachesHidden: true },
+            apply: { type: "boolean", description: "files.replace.option.apply" },
+            yes: { type: "boolean", description: "files.replace.option.yes", short: "y", terminalOnly: true },
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            const find = reader.positional(0) ?? "";
+            if (find === "")
+                throw new UsageError("files.replace.empty-find");
+            const regex = reader.flag("regex");
+            if (regex) {
+                try {
+                    new RegExp(find, "g");
+                }
+                catch {
+                    throw new UsageError("files.replace.bad-pattern", { pattern: find });
+                }
+            }
+            return {
+                find,
+                replacement: reader.positional(1) ?? "",
+                paths: reader.positionalsFrom(2),
+                regex,
+                ignoreCase: reader.flag("ignore-case"),
+                extensions: parseExtensions(reader.strings("ext")),
+                name: reader.string("name"),
+                all: reader.flag("all"),
+                apply: reader.flag("apply"),
+                yes: reader.flag("yes"),
+            };
+        },
+    },
+};
+function samplesOf(before, after) {
+    const oldLines = before.split(/\r?\n/);
+    const newLines = after.split(/\r?\n/);
+    if (oldLines.length !== newLines.length)
+        return { lineCountChanges: true, samples: [] };
+    const samples = [];
+    for (let index = 0; index < oldLines.length && samples.length < SAMPLE_LINES; index += 1) {
+        const old = oldLines[index] ?? "";
+        const next = newLines[index] ?? "";
+        if (old !== next)
+            samples.push({ line: index + 1, before: old.trim(), after: next.trim() });
+    }
+    return { lineCountChanges: false, samples };
+}
+export class ReplaceText {
+    fileSystem;
+    content;
+    spec = replaceSpec;
+    constructor(fileSystem, content) {
+        this.fileSystem = fileSystem;
+        this.content = content;
+    }
+    async execute(input, context) {
+        const pattern = new RegExp(input.regex ? input.find : escapeRegExp(input.find), input.ignoreCase ? "gi" : "g");
+        // Without --regex a `$` in the replacement is text, not a group reference.
+        const replaceIn = (text) => input.regex ? text.replace(pattern, input.replacement) : text.replace(pattern, () => input.replacement);
+        const targets = input.paths.length === 0 ? ["."] : input.paths;
+        const paths = await expandPaths(this.fileSystem, targets, context.cwd, input.all);
+        const files = await selectFiles(this.fileSystem, paths, {
+            all: input.all,
+            extensions: input.extensions,
+            name: input.name,
+        });
+        const changes = [];
+        const replaced = [];
+        let replacements = 0;
+        let skipped = 0;
+        for (const file of files) {
+            if (context.signal.aborted)
+                break;
+            const current = await readTextFile(this.fileSystem, this.content, file);
+            if (current === null) {
+                skipped += 1;
+                continue;
+            }
+            const count = current.text.match(pattern)?.length ?? 0;
+            if (count === 0)
+                continue;
+            const updated = replaceIn(current.text);
+            if (updated === current.text)
+                continue;
+            replacements += count;
+            changes.push({ path: file, file: { text: updated, encoding: current.encoding } });
+            replaced.push({ path: file, count, ...samplesOf(current.text, updated) });
+        }
+        const data = { files: replaced, replacements, checked: files.length, skipped, written: 0 };
+        if (changes.length === 0)
+            return done(data);
+        if (!input.apply)
+            return preview(data, "--apply");
+        await requireApproval(context, message("files.replace.ask", { count: changes.length }), input.yes);
+        const failures = [];
+        let written = 0;
+        for (const change of changes) {
+            try {
+                await this.content.write(change.path, encodeText(change.file));
+                written += 1;
+            }
+            catch (error) {
+                if (!(error instanceof KiriyaError))
+                    throw error;
+                failures.push(error.detail);
+            }
+        }
+        return done({ ...data, written }, { failures });
+    }
+}
+//# sourceMappingURL=replace-text.use-case.js.map

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

@@ -0,0 +1,115 @@
+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 { parseExtensions } from "../domain/filters.js";
+import { escapeRegExp } from "../domain/text-encoding.js";
+import { readTextFile, selectFiles } from "./text-files.js";
+/** Longer matching lines are cut here, so one minified file cannot flood the terminal. */
+const LINE_LIMIT = 240;
+export const grepSpec = {
+    id: "files.grep",
+    summary: "files.grep.summary",
+    examples: [
+        'kiriya files grep "TODO|FIXME"',
+        "kiriya files grep useState src --ext .tsx",
+        'kiriya files grep "connection string" --literal -i -l',
+    ],
+    safety: "read",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [
+            { name: "pattern", description: "files.grep.arg.pattern", required: true, variadic: false },
+            { name: "paths", description: "files.grep.arg.paths", required: false, variadic: true, path: true },
+        ],
+        options: {
+            literal: { type: "boolean", description: "files.grep.option.literal" },
+            "ignore-case": { type: "boolean", description: "files.grep.option.ignore-case", short: "i" },
+            ext: { type: "string", description: "files.option.ext", valueName: "<extensions>", multiple: true },
+            name: { type: "string", description: "files.option.name", valueName: "<glob>" },
+            "files-only": { type: "boolean", description: "files.grep.option.files-only", short: "l" },
+            count: { type: "boolean", description: "files.grep.option.count", short: "c" },
+            all: { type: "boolean", description: "files.option.all" },
+            limit: { type: "string", description: "files.grep.option.limit", valueName: "<n>" },
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            const pattern = reader.positional(0) ?? "";
+            if (pattern === "")
+                throw new UsageError("files.grep.empty-pattern");
+            const literal = reader.flag("literal");
+            if (!literal) {
+                try {
+                    new RegExp(pattern);
+                }
+                catch {
+                    throw new UsageError("files.grep.bad-pattern", { pattern });
+                }
+            }
+            return {
+                pattern,
+                paths: reader.positionalsFrom(1),
+                literal,
+                ignoreCase: reader.flag("ignore-case"),
+                extensions: parseExtensions(reader.strings("ext")),
+                name: reader.string("name"),
+                filesOnly: reader.flag("files-only"),
+                count: reader.flag("count"),
+                all: reader.flag("all"),
+                limit: reader.positiveInteger("limit", 500),
+            };
+        },
+    },
+};
+export class SearchText {
+    fileSystem;
+    content;
+    spec = grepSpec;
+    constructor(fileSystem, content) {
+        this.fileSystem = fileSystem;
+        this.content = content;
+    }
+    async execute(input, context) {
+        const regex = new RegExp(input.literal ? escapeRegExp(input.pattern) : input.pattern, input.ignoreCase ? "i" : "");
+        const mode = input.filesOnly ? "files" : input.count ? "count" : "lines";
+        const targets = input.paths.length === 0 ? ["."] : input.paths;
+        const paths = await expandPaths(this.fileSystem, targets, context.cwd, input.all);
+        const files = await selectFiles(this.fileSystem, paths, {
+            all: input.all,
+            extensions: input.extensions,
+            name: input.name,
+        });
+        const lines = [];
+        const matched = [];
+        let matches = 0;
+        let skipped = 0;
+        for (const file of files) {
+            if (context.signal.aborted)
+                break;
+            const text = await readTextFile(this.fileSystem, this.content, file);
+            if (text === null) {
+                skipped += 1;
+                continue;
+            }
+            let inFile = 0;
+            text.text.split(/\r?\n/).forEach((line, index) => {
+                if (!regex.test(line))
+                    return;
+                inFile += 1;
+                if (mode !== "lines" || lines.length >= input.limit)
+                    return;
+                const trimmed = line.trim();
+                const clipped = trimmed.length > LINE_LIMIT ? `${trimmed.slice(0, LINE_LIMIT)}…` : trimmed;
+                lines.push({ path: file, line: index + 1, text: clipped });
+            });
+            if (inFile === 0)
+                continue;
+            matches += inFile;
+            matched.push({ path: file, count: inFile });
+        }
+        return done({ mode, lines, files: matched, matches, checked: files.length, skipped });
+    }
+}
+//# sourceMappingURL=search-text.use-case.js.map