kiriya 0.1.0

package/dist/src/modules/env/application/path-entries.js

@@ -0,0 +1,28 @@
+import path from "node:path";
+/** `;` on Windows and `:` elsewhere, whichever OS kiriya runs on. */
+export function listSeparator(os) {
+    return os === "windows" ? ";" : ":";
+}
+function flavour(os) {
+    return os === "windows" ? path.win32 : path.posix;
+}
+/** The folder an entry names: on Windows without surrounding quotes and with `%NAME%` expanded; unknown names stay. */
+export function entryFolder(entry, os, variable) {
+    const trimmed = entry.trim();
+    if (os !== "windows")
+        return trimmed;
+    return trimmed.replace(/^"(.*)"$/, "$1").replace(/%([^%]+)%/g, (whole, name) => variable(name) ?? whole);
+}
+export function isAbsoluteFolder(folder, os) {
+    return flavour(os).isAbsolute(folder);
+}
+/** The form two folders share when they are the same: normalised, without a trailing separator, and on Windows in lower case. */
+export function comparableFolder(folder, os) {
+    const paths = flavour(os);
+    let normal = paths.normalize(folder);
+    const root = paths.parse(normal).root;
+    while (normal.length > root.length && normal.endsWith(paths.sep))
+        normal = normal.slice(0, -1);
+    return os === "windows" ? normal.toLowerCase() : normal;
+}
+//# sourceMappingURL=path-entries.js.map

package/dist/src/modules/env/application/show-variables.use-case.js

@@ -0,0 +1,47 @@
+import { done } from "../../../core/domain/command.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { message } from "../../../core/domain/message.js";
+import { byCodePoint } from "../../../core/domain/names.js";
+import { isSecretName, looksSecret } from "../../../core/domain/secrets.js";
+export const showSpec = {
+    id: "env.show",
+    summary: "env.show.summary",
+    examples: ["kiriya env show", "kiriya env show java", "kiriya env show token --reveal"],
+    safety: "read",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [{ name: "filter", description: "env.show.arg.filter", required: false, variadic: false }],
+        options: { reveal: { type: "boolean", description: "env.show.option.reveal", terminalOnly: true } },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return { filter: reader.positional(0), reveal: reader.flag("reveal") };
+        },
+    },
+};
+/** Values hide when a name or value looks secret, in text and in JSON alike, because both end up in logs. */
+export class ShowVariables {
+    environment;
+    spec = showSpec;
+    constructor(environment) {
+        this.environment = environment;
+    }
+    execute(input) {
+        const filter = input.filter?.toLowerCase();
+        const variables = Object.entries(this.environment.variables())
+            .filter(([name]) => filter === undefined || name.toLowerCase().includes(filter))
+            .sort(([first], [second]) => byCodePoint(first.toLowerCase(), second.toLowerCase()) || byCodePoint(first, second))
+            .map(([name, value]) => {
+            const secret = isSecretName(name) || looksSecret(value);
+            return { name, value: secret && !input.reveal ? null : value, secret };
+        });
+        const hidden = variables.filter((variable) => variable.value === null).length;
+        const warnings = input.reveal && variables.some((variable) => variable.secret) ? [message("env.show.revealed")] : [];
+        const failures = input.filter !== undefined && variables.length === 0
+            ? [message("env.show.no-match", { filter: input.filter })]
+            : [];
+        return Promise.resolve(done({ variables, hidden }, { warnings, failures }));
+    }
+}
+//# sourceMappingURL=show-variables.use-case.js.map

package/dist/src/modules/env/domain/dotenv.js

@@ -0,0 +1,62 @@
+const BYTE_ORDER_MARK = String.fromCharCode(0xfeff);
+const ENTRY = /^(?:export\s+)?([A-Za-z_][A-Za-z0-9_.-]*)\s*=\s*(.*)$/;
+const QUOTES = ['"', "'", "`"];
+/** Where the closing quote is from `start`, skipping escaped ones inside double quotes; -1 when there is none. */
+function closingQuote(text, quote, start) {
+    for (let index = start; index < text.length; index += 1) {
+        const char = text.charAt(index);
+        if (char === "\\" && quote === '"') {
+            index += 1;
+        }
+        else if (char === quote) {
+            return index;
+        }
+    }
+    return -1;
+}
+/**
+ * The keys of a .env file as dotenv reads it: `KEY=value`, an optional `export`,
+ * `#` comments, and values in single, double or backtick quotes that may span lines.
+ * A value is only checked for being empty; it never leaves this function.
+ */
+export function parseDotenv(content) {
+    const text = content.startsWith(BYTE_ORDER_MARK) ? content.slice(1) : content;
+    const lines = text.split(/\r?\n/);
+    const entries = [];
+    const malformed = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const trimmed = (lines[index] ?? "").trim();
+        if (trimmed === "" || trimmed.startsWith("#"))
+            continue;
+        const match = ENTRY.exec(trimmed);
+        if (match === null) {
+            malformed.push(index + 1);
+            continue;
+        }
+        const key = match[1] ?? "";
+        const rest = match[2] ?? "";
+        const quote = rest.charAt(0);
+        if (!QUOTES.includes(quote)) {
+            // Unquoted, a # starts a comment.
+            entries.push({ key, line: index + 1, empty: (rest.split("#")[0] ?? "").trim() === "" });
+            continue;
+        }
+        const close = closingQuote(rest, quote, 1);
+        if (close >= 0) {
+            entries.push({ key, line: index + 1, empty: close === 1 });
+            continue;
+        }
+        // The value goes on to the line with the closing quote.
+        let end = index + 1;
+        while (end < lines.length && closingQuote(lines[end] ?? "", quote, 0) < 0)
+            end += 1;
+        if (end === lines.length) {
+            malformed.push(index + 1);
+            continue;
+        }
+        entries.push({ key, line: index + 1, empty: false });
+        index = end;
+    }
+    return { entries, malformed };
+}
+//# sourceMappingURL=dotenv.js.map

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

@@ -0,0 +1,17 @@
+import { CheckDotenv } from "./application/check-dotenv.use-case.js";
+import { InspectPath } from "./application/inspect-path.use-case.js";
+import { ShowVariables } from "./application/show-variables.use-case.js";
+import { checkView, pathView, showView } from "./presentation/env.views.js";
+export const envModule = {
+    id: "env",
+    summary: "env.summary",
+    about: "env.about",
+    examples: ["kiriya env show node", "kiriya env path", "kiriya env check"],
+    guide: "https://github.com/SatPaingOo/kiriya/blob/main/docs/modules/env.md",
+    register(registrar, ports) {
+        registrar.add(new ShowVariables(ports.environment), showView);
+        registrar.add(new InspectPath(ports.environment, ports.fileSystem), pathView);
+        registrar.add(new CheckDotenv(ports.fileSystem, ports.fileContent), checkView);
+    },
+};
+//# sourceMappingURL=env.module.js.map

package/dist/src/modules/env/presentation/env.views.js

@@ -0,0 +1,43 @@
+import { message } from "../../../core/domain/message.js";
+/** NAME=value, one per line, as shells print them. */
+export const showView = (output, format) => {
+    const lines = output.variables.map((variable) => variable.value === null
+        ? `${variable.name}=${format.dim(format.text(message("env.show.hidden-value")))}`
+        : `${variable.name}=${variable.value}`);
+    if (output.hidden > 0)
+        lines.push(format.dim(format.text(message("env.show.hidden", { count: output.hidden }))));
+    return lines;
+};
+const STATUS_KEYS = {
+    ok: "env.path.status.ok",
+    missing: "env.path.status.missing",
+    "not-a-folder": "env.path.status.not-a-folder",
+    duplicate: "env.path.status.duplicate",
+    empty: "env.path.status.empty",
+    relative: "env.path.status.relative",
+};
+function paintStatus(status, text, format) {
+    if (status === "ok")
+        return format.green(text);
+    return status === "missing" || status === "not-a-folder" ? format.red(text) : format.yellow(text);
+}
+export const pathView = (output, format) => {
+    const labels = output.entries.map((entry) => format.text(message(STATUS_KEYS[entry.status])));
+    const statusWidth = Math.max(0, ...labels.map((label) => label.length));
+    const indexWidth = String(output.entries.length).length;
+    return output.entries.map((entry, position) => {
+        const status = paintStatus(entry.status, (labels[position] ?? "").padEnd(statusWidth), format);
+        const expanded = entry.folder !== entry.entry.trim() ? format.dim(` → ${entry.folder}`) : "";
+        const repeat = entry.duplicateOf === null
+            ? ""
+            : format.dim(`  ${format.text(message("env.path.same-as", { index: entry.duplicateOf }))}`);
+        return `  ${String(entry.index).padStart(indexWidth)}  ${status}  ${entry.entry}${expanded}${repeat}`;
+    });
+};
+/** Problems arrive as failures and warnings; a file with every variable set gets one line. */
+export const checkView = (output, format) => output.fileExists && output.missing.length === 0
+    ? [
+        format.green(format.text(message("env.check.ok", { count: output.expected, example: output.example, file: output.file }))),
+    ]
+    : [];
+//# sourceMappingURL=env.views.js.map

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

@@ -0,0 +1,149 @@
+import path from "node:path";
+import { CLEAN_RULES } from "../../../config/clean-rules.js";
+import { measure } from "../../../core/application/paths.js";
+import { refuseProtected, requireTypedConfirmation } from "../../../core/application/safety.js";
+import { done, preview } from "../../../core/domain/command.js";
+import { KiriyaError, NotFoundError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { message } from "../../../core/domain/message.js";
+import { byCodePoint } from "../../../core/domain/names.js";
+import { formatBytes } from "../../../core/domain/values/bytes.js";
+function ruleFor(name, siblings) {
+    return CLEAN_RULES.find((rule) => {
+        const sibling = rule.sibling;
+        return rule.directories.includes(name) && (sibling === null || siblings.some((item) => sibling.test(item)));
+    });
+}
+export const cleanSpec = {
+    id: "files.clean",
+    summary: "files.clean.summary",
+    examples: ["kiriya files clean ~/projects", "kiriya files clean --apply", "kiriya files clean . --depth 3 --json"],
+    safety: "destroy",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [
+            { name: "folder", description: "files.clean.arg.folder", required: false, variadic: false, path: true },
+        ],
+        options: {
+            depth: { type: "string", description: "files.clean.option.depth", valueName: "<n>" },
+            apply: { type: "boolean", description: "files.clean.option.apply" },
+            confirm: { type: "string", description: "files.clean.option.confirm", valueName: "<count>", terminalOnly: true },
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return {
+                folder: reader.positional(0) ?? ".",
+                depth: reader.positiveInteger("depth", 8),
+                apply: reader.flag("apply"),
+                confirm: reader.string("confirm"),
+            };
+        },
+    },
+};
+export class CleanBuilds {
+    fileSystem;
+    processRunner;
+    protectedPaths;
+    spec = cleanSpec;
+    constructor(fileSystem, processRunner, protectedPaths) {
+        this.fileSystem = fileSystem;
+        this.processRunner = processRunner;
+        this.protectedPaths = protectedPaths;
+    }
+    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 git = await this.processRunner.find("git");
+        const candidates = [];
+        let tracked = 0;
+        const visit = async (dir, depth) => {
+            let entries;
+            try {
+                entries = await this.fileSystem.readDirectory(dir);
+            }
+            catch (error) {
+                if (error instanceof KiriyaError)
+                    return;
+                throw error;
+            }
+            const siblings = entries.map((entry) => entry.name);
+            for (const entry of entries) {
+                if (context.signal.aborted)
+                    return;
+                if (entry.kind !== "directory" || entry.name === ".git")
+                    continue;
+                const entryPath = path.join(dir, entry.name);
+                const rule = ruleFor(entry.name, siblings);
+                if (rule === undefined) {
+                    // An unrecognised node_modules is still not worth walking into.
+                    if (entry.name !== "node_modules" && depth < input.depth)
+                        await visit(entryPath, depth + 1);
+                    continue;
+                }
+                if (git !== null && (await this.insideRepository(dir))) {
+                    const listed = await this.processRunner.run(git, ["-C", dir, "ls-files", "--", entry.name], {
+                        timeoutMs: 60_000,
+                        signal: context.signal,
+                    });
+                    if (listed.code === 0 && listed.stdout.trim() !== "") {
+                        tracked += 1;
+                        continue;
+                    }
+                }
+                const { bytes } = await measure(this.fileSystem, entryPath);
+                candidates.push({ path: entryPath, reason: message(rule.reason), bytes });
+            }
+        };
+        await visit(folder, 1);
+        candidates.sort((a, b) => b.bytes - a.bytes || byCodePoint(a.path, b.path));
+        const bytes = candidates.reduce((sum, candidate) => sum + candidate.bytes, 0);
+        const warnings = git === null ? [message("files.clean.no-git")] : [];
+        const data = { folder, candidates, bytes, tracked, removed: 0 };
+        if (candidates.length === 0)
+            return done(data, { warnings });
+        if (!input.apply)
+            return preview(data, "--apply", warnings);
+        refuseProtected(this.protectedPaths, candidates.map((candidate) => candidate.path), context.cwd);
+        // Everything here is rebuildable, so it is removed for good rather than filling the trash.
+        const warning = message("files.clean.warn", { count: candidates.length, size: formatBytes(bytes) });
+        await requireTypedConfirmation(context, warning, String(candidates.length), input.confirm);
+        const failures = [];
+        let removed = 0;
+        for (const candidate of candidates) {
+            try {
+                await this.fileSystem.remove(candidate.path);
+                removed += 1;
+            }
+            catch (error) {
+                if (!(error instanceof KiriyaError))
+                    throw error;
+                failures.push(error.detail);
+            }
+        }
+        return done({ ...data, removed }, { warnings, failures });
+    }
+    async insideRepository(folder) {
+        for (let current = folder;;) {
+            try {
+                if ((await this.fileSystem.lstat(path.join(current, ".git"))) !== null)
+                    return true;
+            }
+            catch (error) {
+                if (error instanceof KiriyaError)
+                    return false;
+                throw error;
+            }
+            const parent = path.dirname(current);
+            if (parent === current)
+                return false;
+            current = parent;
+        }
+    }
+}
+//# sourceMappingURL=clean-builds.use-case.js.map

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

@@ -0,0 +1,127 @@
+import path from "node:path";
+import { walk } from "../../../core/application/walk.js";
+import { done } from "../../../core/domain/command.js";
+import { NotFoundError, UsageError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { message } from "../../../core/domain/message.js";
+import { byCodePoint } from "../../../core/domain/names.js";
+import { readTextFile } from "./text-files.js";
+export const compareSpec = {
+    id: "files.compare",
+    summary: "files.compare.summary",
+    examples: [
+        "kiriya files compare appsettings.json appsettings.Production.json",
+        "kiriya files compare dist backup/dist",
+        "kiriya files compare a b --all --json",
+    ],
+    safety: "read",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [
+            { name: "a", description: "files.compare.arg.a", required: true, variadic: false, path: true },
+            { name: "b", description: "files.compare.arg.b", required: true, variadic: false, path: true },
+        ],
+        options: { all: { type: "boolean", description: "files.compare.option.all" } },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return { a: reader.positional(0) ?? "", b: reader.positional(1) ?? "", all: reader.flag("all") };
+        },
+    },
+};
+export class ComparePaths {
+    fileSystem;
+    content;
+    hasher;
+    spec = compareSpec;
+    constructor(fileSystem, content, hasher) {
+        this.fileSystem = fileSystem;
+        this.content = content;
+        this.hasher = hasher;
+    }
+    async execute(input, context) {
+        const a = path.resolve(context.cwd, input.a);
+        const b = path.resolve(context.cwd, input.b);
+        const statA = await this.fileSystem.lstat(a);
+        if (statA === null)
+            throw new NotFoundError("core.fs.not-found", { path: a });
+        const statB = await this.fileSystem.lstat(b);
+        if (statB === null)
+            throw new NotFoundError("core.fs.not-found", { path: b });
+        if ((statA.kind === "directory") !== (statB.kind === "directory"))
+            throw new UsageError("files.compare.mixed");
+        const output = statA.kind === "directory"
+            ? await this.compareFolders(a, b, input.all)
+            : await this.compareFiles(a, b, statA.size, statB.size);
+        const same = output.kind === "files"
+            ? output.identical
+            : output.onlyInA.length + output.onlyInB.length + output.different.length === 0;
+        // Like diff and cmp, a difference is exit code 1.
+        return done(output, { failures: same ? [] : [message("files.compare.different")] });
+    }
+    async sameContent(a, b, sizeA, sizeB) {
+        if (sizeA !== sizeB)
+            return false;
+        return (await this.hasher.hashFile(a, "sha256")) === (await this.hasher.hashFile(b, "sha256"));
+    }
+    async compareFiles(a, b, sizeA, sizeB) {
+        const base = { kind: "files", a, b, sizeA, sizeB };
+        if (await this.sameContent(a, b, sizeA, sizeB))
+            return { ...base, identical: true, text: null };
+        const textA = await readTextFile(this.fileSystem, this.content, a);
+        const textB = await readTextFile(this.fileSystem, this.content, b);
+        if (textA === null || textB === null)
+            return { ...base, identical: false, text: null };
+        const linesA = textA.text.split(/\r?\n/);
+        const linesB = textB.text.split(/\r?\n/);
+        const index = linesA.findIndex((line, position) => line !== linesB[position]);
+        const at = index < 0 ? linesA.length : index;
+        return {
+            ...base,
+            identical: false,
+            text: {
+                sameText: textA.text.replace(/\r\n/g, "\n") === textB.text.replace(/\r\n/g, "\n"),
+                encodingA: textA.encoding,
+                encodingB: textB.encoding,
+                line: at + 1,
+                linesA: linesA.length,
+                linesB: linesB.length,
+                lineA: linesA[at] ?? null,
+                lineB: linesB[at] ?? null,
+            },
+        };
+    }
+    async scan(root, all) {
+        const entries = new Map();
+        for await (const entry of walk(this.fileSystem, root, { all })) {
+            const isDirectory = entry.kind === "directory";
+            const stat = isDirectory ? null : await this.fileSystem.lstat(entry.path);
+            if (!isDirectory && stat === null)
+                continue;
+            entries.set(entry.rel, { path: entry.path, isDirectory, size: stat?.size ?? 0 });
+        }
+        return entries;
+    }
+    async compareFolders(a, b, all) {
+        const left = await this.scan(a, all);
+        const right = await this.scan(b, all);
+        const onlyInA = [...left.keys()].filter((rel) => !right.has(rel)).sort(byCodePoint);
+        const onlyInB = [...right.keys()].filter((rel) => !left.has(rel)).sort(byCodePoint);
+        const different = [];
+        for (const [rel, entry] of left) {
+            const other = right.get(rel);
+            if (other === undefined)
+                continue;
+            if (entry.isDirectory !== other.isDirectory) {
+                different.push({ path: rel, reason: "kind" });
+            }
+            else if (!entry.isDirectory && !(await this.sameContent(entry.path, other.path, entry.size, other.size))) {
+                different.push({ path: rel, reason: "content" });
+            }
+        }
+        different.sort((x, y) => byCodePoint(x.path, y.path));
+        return { kind: "folders", a, b, entries: left.size, onlyInA, onlyInB, different };
+    }
+}
+//# sourceMappingURL=compare-paths.use-case.js.map

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

@@ -0,0 +1,101 @@
+import path from "node:path";
+import { measure } from "../../../core/application/paths.js";
+import { refuseProtected, 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 { planTransfers } from "./transfers.js";
+/** The arguments and flags copy and move share. */
+export const transferInput = {
+    positionals: [
+        { name: "sources", description: "files.transfer.arg.sources", required: true, variadic: true, path: true },
+        { name: "target", description: "files.transfer.arg.target", required: true, variadic: false, path: true },
+    ],
+    options: {
+        overwrite: { type: "boolean", description: "files.transfer.option.overwrite" },
+        "dry-run": { type: "boolean", description: "files.transfer.option.dry-run" },
+        confirm: { type: "string", description: "files.transfer.option.confirm", valueName: "<count>", terminalOnly: true },
+    },
+    parse(raw) {
+        const reader = new RawReader(raw);
+        const positionals = reader.positionalsFrom(0);
+        return {
+            sources: positionals.slice(0, -1),
+            target: positionals.at(-1) ?? "",
+            overwrite: reader.flag("overwrite"),
+            dryRun: reader.flag("dry-run"),
+            confirm: reader.string("confirm"),
+        };
+    },
+};
+export const copySpec = {
+    id: "files.copy",
+    summary: "files.copy.summary",
+    examples: [
+        "kiriya files copy report.txt backup/",
+        'kiriya files copy "src/**/*.ts" snapshot/ --dry-run',
+        "kiriya files copy config.json config.old.json",
+    ],
+    safety: "destroy",
+    idempotent: false,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: transferInput,
+};
+export class CopyPaths {
+    fileSystem;
+    protectedPaths;
+    environment;
+    spec = copySpec;
+    constructor(fileSystem, protectedPaths, environment) {
+        this.fileSystem = fileSystem;
+        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);
+        const planned = [];
+        for (const transfer of transfers) {
+            const { bytes } = await measure(this.fileSystem, transfer.source);
+            planned.push({ ...transfer, bytes, outcome: "planned", reason: null });
+        }
+        const conflicts = planned.filter((item) => item.conflict);
+        const data = {
+            items: planned,
+            bytes: planned.reduce((sum, item) => sum + item.bytes, 0),
+            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")],
+                });
+            }
+            refuseProtected(this.protectedPaths, conflicts.map((item) => item.destination), context.cwd);
+            const warning = message("files.copy.warn-overwrite", { count: conflicts.length });
+            await requireTypedConfirmation(context, warning, String(conflicts.length), input.confirm);
+        }
+        const items = [];
+        const failures = [];
+        for (const item of planned) {
+            try {
+                await this.fileSystem.createDirectory(path.dirname(item.destination));
+                await this.fileSystem.copy(item.source, item.destination, input.overwrite);
+                items.push({ ...item, outcome: "copied" });
+            }
+            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=copy-paths.use-case.js.map

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

@@ -0,0 +1,85 @@
+import path from "node:path";
+import { done } 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 { invalidNameReason } from "../../../core/domain/names.js";
+export const createSpec = {
+    id: "files.new",
+    summary: "files.new.summary",
+    examples: [
+        "kiriya files new notes.md",
+        "kiriya files new src/app/ docs/",
+        'kiriya files new .env.example --content "PORT=3000"',
+    ],
+    safety: "write",
+    idempotent: false,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [{ name: "paths", description: "files.new.arg.paths", required: true, variadic: true, path: true }],
+        options: {
+            dir: { type: "boolean", description: "files.new.option.dir" },
+            content: { type: "string", description: "files.new.option.content", valueName: "<text>" },
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            const directory = reader.flag("dir");
+            const content = reader.string("content");
+            if (directory && content !== undefined)
+                throw new UsageError("files.new.content-with-dir");
+            return { paths: reader.positionalsFrom(0), directory, content };
+        },
+    },
+};
+export class CreatePaths {
+    fileSystem;
+    environment;
+    spec = createSpec;
+    constructor(fileSystem, environment) {
+        this.fileSystem = fileSystem;
+        this.environment = environment;
+    }
+    async execute(input, context) {
+        const items = [];
+        const failures = [];
+        for (const arg of input.paths) {
+            const folder = input.directory || arg.endsWith("/") || (this.environment.os === "windows" && arg.endsWith("\\"));
+            const target = path.resolve(context.cwd, arg);
+            const kind = folder ? "directory" : "file";
+            const reason = await this.problem(target);
+            if (reason !== null) {
+                items.push({ path: target, kind, created: false, reason });
+                failures.push(reason);
+                continue;
+            }
+            try {
+                if (folder) {
+                    await this.fileSystem.createDirectory(target);
+                }
+                else {
+                    await this.fileSystem.createDirectory(path.dirname(target));
+                    await this.fileSystem.createFile(target, input.content ?? "");
+                }
+                items.push({ path: target, kind, created: true, reason: null });
+            }
+            catch (error) {
+                if (!(error instanceof KiriyaError))
+                    throw error;
+                items.push({ path: target, kind, created: false, reason: error.detail });
+                failures.push(error.detail);
+            }
+        }
+        return done({ items }, { failures });
+    }
+    async problem(target) {
+        const name = path.basename(target);
+        const invalid = invalidNameReason(name);
+        if (invalid !== null)
+            return message(invalid, { name });
+        if ((await this.fileSystem.lstat(target)) !== null)
+            return message("core.fs.exists", { path: target });
+        return null;
+    }
+}
+//# sourceMappingURL=create-paths.use-case.js.map