kiriya 0.1.0

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

@@ -0,0 +1,23 @@
+import { CleanEngine } from "./application/clean-engine.use-case.js";
+import { ListContainers } from "./application/list-containers.use-case.js";
+import { createRebuild, createUp } from "./application/run-compose.use-case.js";
+import { ShowLogs } from "./application/show-logs.use-case.js";
+import { StopProject } from "./application/stop-project.use-case.js";
+import { cleanView, downView, logsView, psView, rebuildView, upView } from "./presentation/docker.views.js";
+export const dockerModule = {
+    id: "docker",
+    summary: "docker.summary",
+    about: "docker.about",
+    examples: ["kiriya docker ps", "kiriya docker up --build", "kiriya docker logs api -f", "kiriya docker clean"],
+    guide: "https://github.com/SatPaingOo/kiriya/blob/main/docs/modules/docker.md",
+    register(registrar, ports) {
+        const { fileSystem, fileContent, processRunner } = ports;
+        registrar.add(new ListContainers(fileSystem, fileContent, processRunner), psView);
+        registrar.add(createUp(fileSystem, fileContent, processRunner), upView);
+        registrar.add(new StopProject(fileSystem, fileContent, processRunner), downView);
+        registrar.add(new ShowLogs(fileSystem, fileContent, processRunner), logsView);
+        registrar.add(createRebuild(fileSystem, fileContent, processRunner), rebuildView);
+        registrar.add(new CleanEngine(processRunner), cleanView);
+    },
+};
+//# sourceMappingURL=docker.module.js.map

package/dist/src/modules/docker/domain/compose-file.js

@@ -0,0 +1,105 @@
+/** The file names docker compose looks for in a folder, in the order it prefers them. */
+export const COMPOSE_FILE_NAMES = ["compose.yaml", "compose.yml", "docker-compose.yaml", "docker-compose.yml"];
+/** The project name docker compose derives from a folder name: lower case, letters, digits, `-` and `_`. */
+export function projectNameFromFolder(folderName) {
+    return folderName.toLowerCase().replace(/[^a-z0-9_-]/g, "");
+}
+function unquote(value) {
+    const trimmed = value.trim();
+    const first = trimmed[0];
+    if ((first === '"' || first === "'") && trimmed.length >= 2 && trimmed.endsWith(first))
+        return trimmed.slice(1, -1);
+    return trimmed;
+}
+/**
+ * Just enough YAML to show a project: the top-level name, the services, and each
+ * service's container_name, ports and build context. It is not a YAML parser, and
+ * docker compose itself stays the authority on the file.
+ */
+export function parseCompose(text, fallbackProject) {
+    let project = fallbackProject;
+    const services = [];
+    let inServices = false;
+    let serviceIndent = -1;
+    let current;
+    let portsIndent = -1;
+    let buildIndent = -1;
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.replace(/\s+#.*$/, "");
+        const trimmed = line.trim();
+        if (trimmed === "" || trimmed.startsWith("#"))
+            continue;
+        const indent = line.length - line.trimStart().length;
+        if (indent === 0) {
+            inServices = trimmed === "services:";
+            current = undefined;
+            portsIndent = -1;
+            buildIndent = -1;
+            const name = /^name:\s*(.+)$/.exec(trimmed);
+            if (name?.[1] !== undefined)
+                project = unquote(name[1]);
+            continue;
+        }
+        if (!inServices)
+            continue;
+        if (serviceIndent < 0)
+            serviceIndent = indent;
+        if (indent === serviceIndent) {
+            const key = /^([A-Za-z0-9_.-]+):\s*$/.exec(trimmed);
+            if (key?.[1] !== undefined) {
+                current = { name: key[1], container: null, ports: [], buildContext: null };
+                services.push(current);
+            }
+            portsIndent = -1;
+            buildIndent = -1;
+            continue;
+        }
+        if (current === undefined)
+            continue;
+        if (portsIndent >= 0 && indent > portsIndent && trimmed.startsWith("-")) {
+            current.ports.push(unquote(trimmed.slice(1)));
+            continue;
+        }
+        portsIndent = -1;
+        if (buildIndent >= 0 && indent > buildIndent) {
+            const context = /^context:\s*(.+)$/.exec(trimmed);
+            if (context?.[1] !== undefined)
+                current.buildContext = unquote(context[1]);
+            continue;
+        }
+        buildIndent = -1;
+        const pair = /^([A-Za-z0-9_.-]+):\s*(.*)$/.exec(trimmed);
+        if (pair === null)
+            continue;
+        const key = pair[1];
+        const value = pair[2] ?? "";
+        if (key === "container_name" && value !== "")
+            current.container = unquote(value);
+        else if (key === "ports" && value === "")
+            portsIndent = indent;
+        else if (key === "build" && value === "")
+            buildIndent = indent;
+        else if (key === "build")
+            current.buildContext = unquote(value);
+    }
+    return { project, services };
+}
+/**
+ * Published ports as host and container port: "8080:80" and "127.0.0.1:8080:80/tcp" both
+ * give 8080 and 80. A port with no host side is published at a random port and left out.
+ */
+export function portMappings(services) {
+    const mappings = [];
+    for (const service of services) {
+        for (const port of service.ports) {
+            const parts = port.replace(/\/(tcp|udp|sctp)$/i, "").split(":");
+            const target = parts[parts.length - 1];
+            const host = parts[parts.length - 2];
+            if (host === undefined || target === undefined || host === "")
+                continue;
+            mappings.push({ host, service: service.name, target });
+        }
+    }
+    return mappings;
+}
+//# sourceMappingURL=compose-file.js.map

package/dist/src/modules/docker/domain/engine-output.js

@@ -0,0 +1,65 @@
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function parseLine(line) {
+    try {
+        const parsed = JSON.parse(line);
+        return isRecord(parsed) ? [parsed] : [];
+    }
+    catch {
+        return [];
+    }
+}
+/** Docker prints JSON as one array or as one object per line, depending on the command and version. */
+export function parseJsonRecords(text) {
+    const trimmed = text.trim();
+    if (trimmed === "")
+        return [];
+    if (trimmed.startsWith("[")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            return Array.isArray(parsed) ? parsed.filter(isRecord) : [];
+        }
+        catch {
+            return [];
+        }
+    }
+    return trimmed.split(/\r?\n/).flatMap(parseLine);
+}
+function field(record, name) {
+    const value = record[name];
+    if (typeof value === "string")
+        return value;
+    return typeof value === "number" ? String(value) : "";
+}
+/** `docker compose ps --all --format json`. */
+export function parseContainers(text) {
+    return parseJsonRecords(text).map((record) => ({
+        name: field(record, "Name"),
+        service: field(record, "Service"),
+        state: field(record, "State"),
+        status: field(record, "Status"),
+        ports: field(record, "Ports"),
+    }));
+}
+/** `docker compose ls --all --format json`. */
+export function parseProjects(text) {
+    return parseJsonRecords(text).map((record) => ({
+        name: field(record, "Name"),
+        status: field(record, "Status"),
+        configFiles: field(record, "ConfigFiles"),
+    }));
+}
+/** `docker system df --format "{{json .}}"`. */
+export function parseDiskUsage(text) {
+    return parseJsonRecords(text).map((record) => ({
+        type: field(record, "Type"),
+        total: field(record, "TotalCount"),
+        active: field(record, "Active"),
+        size: field(record, "Size"),
+        reclaimable: field(record, "Reclaimable"),
+    }));
+}
+/** "Total reclaimed space: 1.2GB" in a prune command's output, as "1.2GB"; null when absent. */
+export function reclaimedSpace(text) {
+    return /Total reclaimed space:\s*(\S+)/i.exec(text)?.[1] ?? null;
+}
+//# sourceMappingURL=engine-output.js.map

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

@@ -0,0 +1,63 @@
+import { message } from "../../../core/domain/message.js";
+/** Rows of cells as columns padded to their widest cell. */
+function columns(rows) {
+    const widths = [];
+    for (const row of rows)
+        row.forEach((cell, index) => (widths[index] = Math.max(widths[index] ?? 0, cell.length)));
+    return rows.map((row) => `  ${row
+        .map((cell, index) => cell.padEnd(widths[index] ?? 0))
+        .join("  ")
+        .trimEnd()}`);
+}
+function portLines(ports, format) {
+    return ports.map((port) => `  ${format.text(message("docker.port", { ...port }))}`);
+}
+export const psView = (output, format) => {
+    if (output.mode === "projects") {
+        if (output.projects.length === 0)
+            return [format.dim(format.text(message("docker.ps.no-projects")))];
+        return columns(output.projects.map((project) => [project.name, project.status, project.configFiles]));
+    }
+    const header = `${format.bold(output.project)}  ${format.dim(format.path(output.file))}`;
+    if (output.containers.length === 0)
+        return [header, format.dim(format.text(message("docker.ps.no-containers")))];
+    return [
+        header,
+        ...columns(output.containers.map((item) => [item.name, item.service, item.state, item.status, item.ports])),
+    ];
+};
+function startView(done) {
+    return (output, format) => output.succeeded
+        ? [format.green(format.text(message(done, { project: output.project }))), ...portLines(output.ports, format)]
+        : [];
+}
+export const upView = startView("docker.up.done");
+export const rebuildView = startView("docker.rebuild.done");
+export const downView = (output, format) => {
+    if (!output.succeeded)
+        return [];
+    const key = output.volumes ? "docker.down.done-volumes" : "docker.down.done";
+    return [format.green(format.text(message(key, { project: output.project })))];
+};
+/** The logs themselves already went to the terminal as docker printed them. */
+export const logsView = () => [];
+export const cleanView = (output, format) => {
+    const label = (key) => format.text(message(key));
+    const lines = columns([
+        [
+            label("docker.clean.column.type"),
+            label("docker.clean.column.total"),
+            label("docker.clean.column.active"),
+            label("docker.clean.column.size"),
+            label("docker.clean.column.reclaimable"),
+        ],
+        ...output.usage.map((row) => [row.type, row.total, row.active, row.size, row.reclaimable]),
+    ]);
+    lines[0] = format.bold(lines[0] ?? "");
+    for (const result of output.results.filter((item) => item.succeeded)) {
+        const space = result.reclaimed ?? "0B";
+        lines.push(format.green(format.text(message("docker.clean.reclaimed", { target: result.target, space }))));
+    }
+    return lines;
+};
+//# sourceMappingURL=docker.views.js.map

package/dist/src/modules/doctor/application/run-checks.use-case.js

@@ -0,0 +1,128 @@
+import { checkConfigTypes } from "../../../core/application/config-values.js";
+import { done } from "../../../core/domain/command.js";
+import { KiriyaError } from "../../../core/domain/errors.js";
+import { message } from "../../../core/domain/message.js";
+import { isAtLeast } from "../domain/versions.js";
+/** The oldest Node.js release kiriya supports, as package.json's engines field says. */
+const MINIMUM_NODE = "22.13.0";
+const PROBE_TIMEOUT_MS = 20_000;
+export const doctorSpec = {
+    id: "doctor",
+    summary: "doctor.summary",
+    examples: ["kiriya doctor", "kiriya doctor --json"],
+    safety: "read",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: { positionals: [], options: {}, parse: () => ({}) },
+};
+export class RunChecks {
+    processRunner;
+    environment;
+    config;
+    trash;
+    clipboard;
+    plugins;
+    runtime;
+    spec = doctorSpec;
+    constructor(processRunner, environment, config, trash, clipboard, plugins, runtime) {
+        this.processRunner = processRunner;
+        this.environment = environment;
+        this.config = config;
+        this.trash = trash;
+        this.clipboard = clipboard;
+        this.plugins = plugins;
+        this.runtime = runtime;
+    }
+    async execute(_input, context) {
+        const loaded = this.plugins.loaded();
+        const problems = this.plugins.problems();
+        const node = this.runtime.nodeVersion;
+        const checks = [
+            { name: "kiriya", status: "ok", detail: message("doctor.check.kiriya", { version: this.runtime.kiriyaVersion }) },
+            isAtLeast(node, MINIMUM_NODE)
+                ? { name: "node", status: "ok", detail: message("doctor.check.node", { version: node }) }
+                : {
+                    name: "node",
+                    status: "warn",
+                    detail: message("doctor.check.node-old", { version: node, minimum: MINIMUM_NODE }),
+                },
+            { name: "os", status: "ok", detail: message("doctor.check.os", { os: this.environment.os }) },
+            await this.configCheck(),
+            {
+                name: "trash",
+                status: "ok",
+                detail: message("doctor.check.trash", { location: message(this.trash.location) }),
+            },
+            await this.clipboardCheck(),
+            await this.gitCheck(context.signal),
+            await this.dockerCheck(context.signal),
+            {
+                name: "plugins",
+                status: problems.length > 0 ? "fail" : "ok",
+                detail: message("doctor.check.plugins", { loaded: loaded.length, failed: problems.length }),
+            },
+        ];
+        const failures = [
+            ...checks.filter((check) => check.status === "fail" && check.name !== "plugins").map((check) => check.detail),
+            ...problems.map((problem) => message("doctor.plugin-failed", { entry: problem.entry, reason: problem.reason })),
+        ];
+        return done({ checks, plugins: loaded, pluginProblems: problems }, { failures });
+    }
+    async configCheck() {
+        const path = this.config.path;
+        try {
+            if (!(await this.config.exists())) {
+                return { name: "config", status: "ok", detail: message("doctor.check.config-missing", { path }) };
+            }
+            checkConfigTypes(await this.config.read(), path);
+            return { name: "config", status: "ok", detail: message("doctor.check.config", { path }) };
+        }
+        catch (error) {
+            if (!(error instanceof KiriyaError))
+                throw error;
+            return { name: "config", status: "fail", detail: error.detail };
+        }
+    }
+    async clipboardCheck() {
+        try {
+            const backend = await this.clipboard.backend();
+            return { name: "clipboard", status: "ok", detail: message("doctor.check.clipboard", { backend }) };
+        }
+        catch (error) {
+            if (!(error instanceof KiriyaError) || error.kind === "interrupted")
+                throw error;
+            return { name: "clipboard", status: "warn", detail: error.detail };
+        }
+    }
+    /** The first line a program prints for `args`, or null when it is missing or fails. */
+    async probe(program, args, signal) {
+        try {
+            const result = await this.processRunner.run(program, args, { timeoutMs: PROBE_TIMEOUT_MS, signal });
+            const line = result.stdout.trim().split(/\r?\n/)[0] ?? "";
+            return result.code === 0 && line !== "" ? line : null;
+        }
+        catch (error) {
+            if (error instanceof KiriyaError && error.kind !== "interrupted")
+                return null;
+            throw error;
+        }
+    }
+    async gitCheck(signal) {
+        const git = await this.processRunner.find("git");
+        const version = git === null ? null : await this.probe(git, ["--version"], signal);
+        return version === null
+            ? { name: "git", status: "warn", detail: message("doctor.check.git-missing") }
+            : { name: "git", status: "ok", detail: message("doctor.check.git", { version }) };
+    }
+    async dockerCheck(signal) {
+        const docker = await this.processRunner.find("docker");
+        if (docker === null)
+            return { name: "docker", status: "warn", detail: message("doctor.check.docker-missing") };
+        const server = await this.probe(docker, ["version", "--format", "{{.Server.Version}}"], signal);
+        return server === null
+            ? { name: "docker", status: "warn", detail: message("doctor.check.docker-stopped") }
+            : { name: "docker", status: "ok", detail: message("doctor.check.docker", { version: server }) };
+    }
+}
+//# sourceMappingURL=run-checks.use-case.js.map

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

@@ -0,0 +1,13 @@
+import { RunChecks } from "./application/run-checks.use-case.js";
+import { doctorView } from "./presentation/doctor.view.js";
+export const doctorModule = {
+    id: "doctor",
+    summary: "doctor.summary",
+    about: "doctor.about",
+    guide: "https://github.com/SatPaingOo/kiriya/blob/main/docs/modules/doctor.md",
+    register(registrar, ports) {
+        const { processRunner, environment, config, trash, clipboard, plugins, runtime } = ports;
+        registrar.add(new RunChecks(processRunner, environment, config, trash, clipboard, plugins, runtime), doctorView);
+    },
+};
+//# sourceMappingURL=doctor.module.js.map

package/dist/src/modules/doctor/domain/versions.js

@@ -0,0 +1,22 @@
+/** "v24.14.0" or "22.13" -> [24, 14, 0] or [22, 13]; a part that is not a number counts as 0. */
+export function versionParts(version) {
+    return version
+        .trim()
+        .replace(/^v/i, "")
+        .split(".")
+        .map((part) => Number.parseInt(part, 10))
+        .map((part) => (Number.isNaN(part) ? 0 : part));
+}
+/** Compares part by part; a missing part counts as 0, so 22.13 equals 22.13.0. */
+export function isAtLeast(version, minimum) {
+    const actual = versionParts(version);
+    const required = versionParts(minimum);
+    for (let index = 0; index < Math.max(actual.length, required.length); index += 1) {
+        const a = actual[index] ?? 0;
+        const b = required[index] ?? 0;
+        if (a !== b)
+            return a > b;
+    }
+    return true;
+}
+//# sourceMappingURL=versions.js.map

package/dist/src/modules/doctor/presentation/doctor.view.js

@@ -0,0 +1,30 @@
+import { message } from "../../../core/domain/message.js";
+const STATUS_KEYS = {
+    ok: "doctor.status.ok",
+    warn: "doctor.status.warn",
+    fail: "doctor.status.fail",
+};
+function paint(status, text, format) {
+    if (status === "ok")
+        return format.green(text);
+    return status === "warn" ? format.yellow(text) : format.red(text);
+}
+export const doctorView = (output, format) => {
+    const statusWidth = Math.max(...output.checks.map((check) => format.text(message(STATUS_KEYS[check.status])).length));
+    const nameWidth = Math.max(...output.checks.map((check) => check.name.length));
+    const lines = output.checks.map((check) => {
+        const status = format.text(message(STATUS_KEYS[check.status])).padEnd(statusWidth);
+        return `  ${paint(check.status, status, format)}  ${check.name.padEnd(nameWidth)}  ${format.text(check.detail)}`;
+    });
+    if (output.plugins.length > 0) {
+        lines.push("", format.bold(format.text(message("doctor.plugins"))));
+        const idWidth = Math.max(...output.plugins.map((plugin) => plugin.id.length));
+        for (const plugin of output.plugins) {
+            const label = [plugin.name ?? plugin.entry, plugin.version].filter((part) => part !== null).join(" ");
+            const detail = message("doctor.plugin", { commands: plugin.commands, location: format.path(plugin.location) });
+            lines.push(`  ${plugin.id.padEnd(idWidth)}  ${label}  ${format.dim(format.text(detail))}`);
+        }
+    }
+    return lines;
+};
+//# sourceMappingURL=doctor.view.js.map

package/dist/src/modules/env/application/check-dotenv.use-case.js

@@ -0,0 +1,116 @@
+import path from "node:path";
+import { done } from "../../../core/domain/command.js";
+import { utf8Text } from "../../../core/domain/encodings.js";
+import { NotFoundError, OperationFailedError } 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 { parseDotenv } from "../domain/dotenv.js";
+const LIMIT_BYTES = 1024 * 1024;
+export const checkSpec = {
+    id: "env.check",
+    summary: "env.check.summary",
+    examples: ["kiriya env check", "kiriya env check --file .env.local --example .env.example"],
+    safety: "read",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [],
+        options: {
+            file: { type: "string", description: "env.check.option.file", valueName: "<path>", path: true },
+            example: { type: "string", description: "env.check.option.example", valueName: "<path>", path: true },
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return { file: reader.string("file") ?? ".env", example: reader.string("example") ?? ".env.example" };
+        },
+    },
+};
+function names(keys) {
+    return keys.join(", ");
+}
+export class CheckDotenv {
+    fileSystem;
+    content;
+    spec = checkSpec;
+    constructor(fileSystem, content) {
+        this.fileSystem = fileSystem;
+        this.content = content;
+    }
+    async execute(input, context) {
+        const filePath = path.resolve(context.cwd, input.file);
+        const examplePath = path.resolve(context.cwd, input.example);
+        const exampleText = await this.readText(examplePath);
+        if (exampleText === null)
+            throw new NotFoundError("env.check.no-example", { path: examplePath });
+        const fileText = await this.readText(filePath);
+        const expected = parseDotenv(exampleText);
+        const actual = parseDotenv(fileText ?? "");
+        const expectedKeys = new Set(expected.entries.map((entry) => entry.key));
+        const actualKeys = new Set(actual.entries.map((entry) => entry.key));
+        // As in dotenv, a key set twice keeps its last value.
+        const lastEntries = new Map(actual.entries.map((entry) => [entry.key, entry]));
+        const counts = new Map();
+        for (const entry of actual.entries)
+            counts.set(entry.key, (counts.get(entry.key) ?? 0) + 1);
+        const output = {
+            file: input.file,
+            example: input.example,
+            fileExists: fileText !== null,
+            expected: expectedKeys.size,
+            missing: [...expectedKeys].filter((key) => !actualKeys.has(key)),
+            empty: [...lastEntries.values()]
+                .filter((entry) => entry.empty && expectedKeys.has(entry.key))
+                .map((entry) => entry.key),
+            extra: [...actualKeys].filter((key) => !expectedKeys.has(key)),
+            duplicates: [...counts].filter(([, count]) => count > 1).map(([key]) => key),
+            malformed: [
+                ...expected.malformed.map((line) => ({ path: input.example, line })),
+                ...actual.malformed.map((line) => ({ path: input.file, line })),
+            ],
+        };
+        return done(output, { failures: this.failures(output), warnings: this.warnings(output) });
+    }
+    failures(output) {
+        const failures = [];
+        if (!output.fileExists) {
+            failures.push(message("env.check.no-file", { path: output.file, example: output.example }));
+        }
+        if (output.missing.length > 0) {
+            const params = { count: output.missing.length, names: names(output.missing) };
+            failures.push(message("env.check.missing", { ...params, example: output.example, file: output.file }));
+        }
+        return failures;
+    }
+    warnings(output) {
+        const warnings = [];
+        if (output.empty.length > 0) {
+            warnings.push(message("env.check.empty", { count: output.empty.length, names: names(output.empty) }));
+        }
+        if (output.extra.length > 0) {
+            const params = { count: output.extra.length, names: names(output.extra) };
+            warnings.push(message("env.check.extra", { ...params, file: output.file, example: output.example }));
+        }
+        if (output.duplicates.length > 0) {
+            warnings.push(message("env.check.duplicates", { file: output.file, names: names(output.duplicates) }));
+        }
+        for (const line of output.malformed)
+            warnings.push(message("env.check.malformed", { ...line }));
+        return warnings;
+    }
+    /** The file's text, or null when there is no file there. */
+    async readText(target) {
+        const stat = await this.fileSystem.stat(target);
+        if (stat?.kind !== "file")
+            return null;
+        if (stat.size > LIMIT_BYTES) {
+            throw new OperationFailedError("env.check.too-large", { path: target, limit: formatBytes(LIMIT_BYTES) });
+        }
+        const text = utf8Text(await this.content.read(target));
+        if (text === null)
+            throw new OperationFailedError("env.check.not-text", { path: target });
+        return text;
+    }
+}
+//# sourceMappingURL=check-dotenv.use-case.js.map

package/dist/src/modules/env/application/inspect-path.use-case.js

@@ -0,0 +1,71 @@
+import { done } from "../../../core/domain/command.js";
+import { NotFoundError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { message } from "../../../core/domain/message.js";
+import { comparableFolder, entryFolder, isAbsoluteFolder, listSeparator } from "./path-entries.js";
+export const pathSpec = {
+    id: "env.path",
+    summary: "env.path.summary",
+    examples: ["kiriya env path", "kiriya env path PYTHONPATH --json"],
+    safety: "read",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [{ name: "variable", description: "env.path.arg.variable", required: false, variadic: false }],
+        options: {},
+        parse: (raw) => ({ variable: new RawReader(raw).positional(0) ?? "PATH" }),
+    },
+};
+export class InspectPath {
+    environment;
+    fileSystem;
+    spec = pathSpec;
+    constructor(environment, fileSystem) {
+        this.environment = environment;
+        this.fileSystem = fileSystem;
+    }
+    async execute(input) {
+        const os = this.environment.os;
+        const variable = this.nameOnThisOs(input.variable);
+        const value = this.environment.variable(variable);
+        if (value === undefined)
+            throw new NotFoundError("env.path.not-set", { variable: input.variable });
+        const separator = listSeparator(os);
+        const firstSeen = new Map();
+        const entries = [];
+        for (const [position, entry] of value.split(separator).entries()) {
+            const index = position + 1;
+            const folder = entryFolder(entry, os, (name) => this.environment.variable(name));
+            entries.push({ index, entry, folder, ...(await this.check(folder, index, firstSeen)) });
+        }
+        const problems = entries.filter((entry) => entry.status !== "ok").length;
+        const warnings = problems > 0 ? [message("env.path.problems", { count: problems, total: entries.length })] : [];
+        return done({ variable, separator, entries }, { warnings });
+    }
+    /** Windows spells PATH as Path; show the name the OS uses. */
+    nameOnThisOs(name) {
+        if (this.environment.os !== "windows")
+            return name;
+        const wanted = name.toLowerCase();
+        return Object.keys(this.environment.variables()).find((key) => key.toLowerCase() === wanted) ?? name;
+    }
+    async check(folder, index, firstSeen) {
+        const os = this.environment.os;
+        if (folder === "")
+            return { status: "empty", duplicateOf: null };
+        // A relative entry is searched from whatever folder a program runs in.
+        if (!isAbsoluteFolder(folder, os))
+            return { status: "relative", duplicateOf: null };
+        const key = comparableFolder(folder, os);
+        const first = firstSeen.get(key);
+        if (first !== undefined)
+            return { status: "duplicate", duplicateOf: first };
+        firstSeen.set(key, index);
+        const stat = await this.fileSystem.stat(folder);
+        if (stat === null)
+            return { status: "missing", duplicateOf: null };
+        return { status: stat.kind === "directory" ? "ok" : "not-a-folder", duplicateOf: null };
+    }
+}
+//# sourceMappingURL=inspect-path.use-case.js.map