kiriya 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,58 @@
+# Changelog
+
+Notable changes to kiriya, newest first. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and versions follow
+[semantic versioning](https://semver.org/). Command ids, flags, exit codes and JSON
+output shapes are kiriya's public API.
+
+## [Unreleased]
+
+## [0.1.0] - 2026-09-23
+
+The first release.
+
+### Added
+
+- Core: `--json` on every command, message keys for every string, typed errors
+  mapped to exit codes (2 for usage, 130 for an interruption, 1 otherwise), a typed
+  confirmation for work that cannot be undone, protected paths, and plugins named in
+  the configuration file.
+- `files`: new, list, tree, info, read, find, grep, hash, dupes, compare, copy, move,
+  rename, replace, delete (to the trash unless `--permanent`), clean, sync and size.
+- `archive`: zip and unzip; tar and untar for `.tar.gz`, `.tgz` and `.tar`. Extraction
+  refuses any archive with an entry that would land outside the target folder.
+- `git`: status, fetch, pull and switch across every repository under a folder.
+- `docker`: ps, up, down, logs, rebuild and clean for the compose project in a folder.
+- `config`: path, keys, list, get, set and unset. The file never holds a secret.
+- `doctor`: what the machine gives kiriya: runtime, configuration, trash, clipboard,
+  git, docker and plugins.
+- `gen`: uuid (version 4 or 7), ulid, password and token.
+- `convert`: base64, hex, url, json, jwt (decoded only, never verified or sent),
+  time and case.
+- `env`: show, with secret-looking values hidden; path; and check of `.env` against
+  `.env.example`.
+- `sys`: info, tools and report.
+- `net`: ip, check and dns.
+- `port`: who, kill and free.
+- `proc`: list, find, kill and tree.
+- `clip`: copy and paste, with Unicode intact.
+- `open`: a file, folder or web address, never running a program.
+- `completion`: tab completion for bash, zsh, fish and PowerShell.
+- `wait`: port, url and file. Wait until a TCP port accepts connections, or stops with `--gone`;
+  until a web address answers with a 2xx status, or one `--status` names; or until a file
+  appears, or goes with `--gone`. It tries every half second until `--timeout`, 60 seconds by
+  default, and exits with 1 when the time runs out.
+- `mcp`: `kiriya mcp` serves every command that changes nothing to AI agents as MCP
+  tools over stdio, for the 2026-07-28 protocol and for clients that still open with
+  `initialize`. Paths must stay inside the `--root` folders, symlinks included. With
+  `kiriya config set mcp.allowWrite true`, commands that change files in ways that can be
+  undone are offered too, and with `mcp.allowDestroy true`, commands whose work cannot be
+  undone, to clients that support elicitation: each asks the user before it changes
+  anything. `config set`, `config unset`, `docker up` and `docker rebuild` are never offered.
+  `open`, `clip paste`, `proc list --full` and `wait url` need `mcp.allowWrite`, and no tool that
+  changes something may reach inside a `.git` folder. `kiriya mcp` also takes its folders
+  as arguments, and each release carries an MCP bundle for Claude's desktop app.
+- Help and docs: `kiriya help <module>` explains what a module is for, shows examples and
+  points to its guide. Every module has a guide in `docs/modules/` with a command reference
+  written from the commands themselves, and CI fails when the docs and the CLI disagree.
+  Plugins may add `about`, `examples` and `guide` to their own help.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sat Paing Oo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,87 @@
+# kiriya
+
+**One command-line toolbox for everyday developer work that behaves the same on Windows,
+Linux and macOS.**
+
+kiriya (ကိရိယာ, Burmese for "tool") saves remembering `del` and `rm`, `netstat -ano` and
+`lsof -i`, `clip` and `pbcopy`, or writing a one-off script for each. It is one Node.js
+program with no runtime dependencies. Every command answers `--json`, changes to many files
+show a plan first, deletions go to the trash, and nothing that cannot be undone happens
+until you type a confirmation. AI agents can use the same commands over MCP, under the same
+rules.
+
+> **Status:** in development and not yet published to npm. Every module below is built and
+> tested in CI on Windows, Linux and macOS, with Node.js 22, 24 and the current release.
+
+## Install
+
+kiriya needs [Node.js](https://nodejs.org/) 22.13 or later. Until its first release, build
+it from source:
+
+```bash
+git clone https://github.com/SatPaingOo/kiriya.git
+cd kiriya
+npm ci
+npm run build
+npm link
+```
+
+[Getting started](docs/getting-started.md) takes it from there.
+
+## Quick start
+
+```bash
+kiriya doctor                                   # what this machine offers kiriya
+kiriya --help                                   # every module
+kiriya help port                                # one module, with examples
+kiriya port who 3000                            # which process holds port 3000
+kiriya files find --name "*.log" --older 30d    # the same search in every shell
+kiriya files delete dist --dry-run              # the plan, before anything changes
+kiriya git status ~/code --json                 # every repository under a folder, as JSON
+```
+
+## Modules
+
+<!-- kiriya:modules -->
+<!-- Written by `npm run docs` from the command specs. Change the specs, not this part. -->
+
+| Module | What it does |
+|---|---|
+| [`archive`](docs/modules/archive.md) | ZIP and tar.gz archives, made and opened the same way on every OS with no zip, tar or 7-Zip installed. |
+| [`clip`](docs/modules/clip.md) | Copy text to the clipboard and paste it back, with Unicode intact on every OS. |
+| [`completion`](docs/modules/completion.md) | Tab completion for kiriya's modules, commands, options and values in bash, zsh, fish and PowerShell. |
+| [`config`](docs/modules/config.md) | kiriya's own settings, such as the plugins to load, in one file per user. |
+| [`convert`](docs/modules/convert.md) | Convert text between base64, hex, URL encoding, JSON, JWT, times and cases, entirely on this machine. |
+| [`docker`](docs/modules/docker.md) | docker compose for the project in the current folder, and a previewed clean-up of the engine. |
+| [`doctor`](docs/modules/doctor.md) | Check what this machine gives kiriya: runtime, configuration, trash, clipboard, git, docker and plugins. |
+| [`env`](docs/modules/env.md) | Environment variables, PATH and .env files, read the same way on every OS. |
+| [`files`](docs/modules/files.md) | Files and folders: create, find, read, search, compare, copy, move, rename and delete, the same on every OS. |
+| [`gen`](docs/modules/gen.md) | Random identifiers, passwords and tokens from the operating system's secure random source. |
+| [`git`](docs/modules/git.md) | Git across every repository under a folder: status, fetch, pull and switch. |
+| [`net`](docs/modules/net.md) | Local addresses, TCP reachability and DNS lookups, the same on every OS. |
+| [`open`](docs/modules/open.md) | Open a file or folder in its default application, or a web address in the browser. |
+| [`port`](docs/modules/port.md) | See which process listens on a TCP port, end it, or find a free port, the same on every OS. |
+| [`proc`](docs/modules/proc.md) | List, find and end processes, and show them as a tree, the same on every OS. |
+| [`sys`](docs/modules/sys.md) | This machine and the developer tools on it, described the same way on every OS. |
+| [`wait`](docs/modules/wait.md) | Wait until a port listens, a web address answers or a file appears, the same way on every OS. |
+<!-- /kiriya:modules -->
+
+## AI agents
+
+`kiriya mcp` serves these commands to AI agents over the Model Context Protocol. It offers
+only commands that change nothing until you allow more, and asks you before any work that
+cannot be undone. [MCP server](docs/guides/mcp.md) shows how to add it to a client.
+
+## Documentation
+
+| For | Read |
+|---|---|
+| Using kiriya | [Getting started](docs/getting-started.md) · [Usage](docs/usage.md) · [Modules](docs/modules/README.md) |
+| Guides | [MCP server](docs/guides/mcp.md) · [Tab completion](docs/guides/completion.md) · [Plugins](docs/guides/plugins.md) |
+| Contributing | [CONTRIBUTING.md](CONTRIBUTING.md) · [Architecture](docs/development/architecture.md) · [Design](docs/development/design.md) |
+| Everything | [Documentation index](docs/README.md) |
+
+## Project
+
+[Changelog](CHANGELOG.md) · [Security policy](SECURITY.md) · [Code of conduct](CODE_OF_CONDUCT.md) ·
+[MIT licence](LICENSE)

package/dist/src/config/clean-rules.js

@@ -0,0 +1,39 @@
+/**
+ * Rebuildable folders, removed only next to the project file that recreates them,
+ * so a hand-written `bin` or `build` folder elsewhere is never touched.
+ */
+export const CLEAN_RULES = [
+    {
+        directories: [
+            "node_modules",
+            ".next",
+            ".nuxt",
+            ".turbo",
+            ".svelte-kit",
+            ".parcel-cache",
+            "dist",
+            "build",
+            "coverage",
+        ],
+        sibling: /^package\.json$/,
+        reason: "files.clean.reason.node",
+    },
+    { directories: ["bin", "obj"], sibling: /\.(cs|fs|vb)proj$/i, reason: "files.clean.reason.dotnet" },
+    {
+        directories: [".venv", "venv"],
+        sibling: /^(pyproject\.toml|requirements\.txt|setup\.py)$/,
+        reason: "files.clean.reason.python",
+    },
+    { directories: ["target"], sibling: /^(Cargo\.toml|pom\.xml)$/, reason: "files.clean.reason.cargo-maven" },
+    {
+        directories: [".gradle", "build"],
+        sibling: /^(build\.gradle|build\.gradle\.kts|settings\.gradle)$/,
+        reason: "files.clean.reason.gradle",
+    },
+    {
+        directories: ["__pycache__", ".pytest_cache", ".ruff_cache", ".mypy_cache"],
+        sibling: null,
+        reason: "files.clean.reason.python-cache",
+    },
+];
+//# sourceMappingURL=clean-rules.js.map

package/dist/src/config/config-keys.js

@@ -0,0 +1,24 @@
+/** Every setting kiriya reads. Adding a setting means adding an entry here. */
+export const CONFIG_KEYS = [
+    {
+        key: "mcp.allowDestroy",
+        type: "string",
+        description: "config.key.mcp-allow-destroy",
+        example: "true",
+        choices: ["true", "false"],
+    },
+    {
+        key: "mcp.allowWrite",
+        type: "string",
+        description: "config.key.mcp-allow-write",
+        example: "true",
+        choices: ["true", "false"],
+    },
+    {
+        key: "plugins",
+        type: "list",
+        description: "config.key.plugins",
+        example: "kiriya-plugin-example ./team/kiriya-plugin",
+    },
+];
+//# sourceMappingURL=config-keys.js.map

package/dist/src/config/dependency-directories.js

@@ -0,0 +1,16 @@
+/** Dependency, build and cache folders. Globs and walks skip them unless --all is given. */
+export const DEPENDENCY_DIRECTORIES = new Set([
+    "node_modules",
+    ".git",
+    ".venv",
+    "venv",
+    "site-packages",
+    "dist",
+    "build",
+    ".next",
+    "obj",
+    "bin",
+    "__pycache__",
+    ".pytest_cache",
+]);
+//# sourceMappingURL=dependency-directories.js.map

package/dist/src/config/modules.js

@@ -0,0 +1,38 @@
+import { archiveModule } from "../modules/archive/archive.module.js";
+import { clipModule } from "../modules/clip/clip.module.js";
+import { completionModule } from "../modules/completion/completion.module.js";
+import { configModule } from "../modules/config/config.module.js";
+import { convertModule } from "../modules/convert/convert.module.js";
+import { dockerModule } from "../modules/docker/docker.module.js";
+import { doctorModule } from "../modules/doctor/doctor.module.js";
+import { envModule } from "../modules/env/env.module.js";
+import { filesModule } from "../modules/files/files.module.js";
+import { genModule } from "../modules/gen/gen.module.js";
+import { gitModule } from "../modules/git/git.module.js";
+import { netModule } from "../modules/net/net.module.js";
+import { openModule } from "../modules/open/open.module.js";
+import { portModule } from "../modules/port/port.module.js";
+import { procModule } from "../modules/proc/proc.module.js";
+import { sysModule } from "../modules/sys/sys.module.js";
+import { waitModule } from "../modules/wait/wait.module.js";
+/** Built-in modules, in no particular order; help lists them sorted. Adding a module is one line here. */
+export const BUILT_IN_MODULES = [
+    filesModule,
+    archiveModule,
+    gitModule,
+    dockerModule,
+    configModule,
+    doctorModule,
+    genModule,
+    convertModule,
+    envModule,
+    sysModule,
+    netModule,
+    portModule,
+    procModule,
+    clipModule,
+    openModule,
+    completionModule,
+    waitModule,
+];
+//# sourceMappingURL=modules.js.map

package/dist/src/config/protected-paths.js

@@ -0,0 +1,32 @@
+/**
+ * Folders no command may delete, move or overwrite, per OS. Windows folders are
+ * named by the environment variable that holds them, since their drive varies.
+ */
+export const PROTECTED_PATHS = {
+    windows: {
+        /** Nothing inside these. */
+        insideVariables: ["SystemRoot", "ProgramFiles", "ProgramFiles(x86)"],
+        /** These folders themselves. */
+        exactVariables: ["ProgramData", "USERPROFILE"],
+        /** Relative to the drive root of the path being checked. */
+        exactOnDrive: ["Users"],
+    },
+    posix: {
+        inside: [
+            "/bin",
+            "/boot",
+            "/dev",
+            "/etc",
+            "/lib",
+            "/lib64",
+            "/proc",
+            "/sbin",
+            "/sys",
+            "/usr",
+            "/System",
+            "/Library",
+        ],
+        exact: ["/home", "/Users", "/opt", "/root", "/tmp", "/var"],
+    },
+};
+//# sourceMappingURL=protected-paths.js.map

package/dist/src/config/rebuildable-directories.js

@@ -0,0 +1,20 @@
+/** Folders `files size` reports as rebuildable: dependencies, build output, caches and downloaded models. */
+export const REBUILDABLE_DIRECTORIES = new Set([
+    "node_modules",
+    ".venv",
+    "venv",
+    "bin",
+    "obj",
+    "dist",
+    "build",
+    ".next",
+    ".turbo",
+    "__pycache__",
+    ".pytest_cache",
+    ".ruff_cache",
+    ".hf_cache",
+    "models",
+    "storage",
+    ".gradle",
+]);
+//# sourceMappingURL=rebuildable-directories.js.map

package/dist/src/core/application/command-registry.js

@@ -0,0 +1,57 @@
+/** The verb of a command id in a module: `files.list` gives `list`, `doctor` in doctor gives "", anything else null. */
+function verbOf(commandId, moduleId) {
+    if (commandId === moduleId)
+        return "";
+    if (!commandId.startsWith(`${moduleId}.`))
+        return null;
+    const verb = commandId.slice(moduleId.length + 1);
+    return verb === "" || verb.includes(".") ? null : verb;
+}
+/** Built-in modules and plugins register here; presentation looks commands up by module and verb. */
+export class CommandRegistry {
+    modules = new Map();
+    /** Registers every command of a module, or none of them when one is rejected. */
+    register(module, ports) {
+        if (this.modules.has(module.id))
+            throw new Error(`module ${module.id} is registered twice`);
+        const entry = {
+            id: module.id,
+            summary: module.summary,
+            about: module.about ?? null,
+            examples: module.examples ?? [],
+            guide: module.guide ?? null,
+            commands: new Map(),
+        };
+        const registrar = {
+            add(command, view) {
+                const verb = verbOf(command.spec.id, module.id);
+                if (verb === null)
+                    throw new Error(`command ${command.spec.id} does not belong to module ${module.id}`);
+                if (entry.commands.has(verb))
+                    throw new Error(`command ${command.spec.id} is registered twice`);
+                entry.commands.set(verb, {
+                    command: command,
+                    view: view,
+                    verb,
+                });
+            },
+        };
+        module.register(registrar, ports);
+        this.modules.set(module.id, entry);
+    }
+    module(id) {
+        return this.modules.get(id);
+    }
+    /** Modules in code-point order, which is the same on every OS. */
+    list() {
+        return [...this.modules.values()].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    }
+    catalog() {
+        return this.list().map((module) => ({
+            id: module.id,
+            summary: module.summary,
+            commands: [...module.commands.values()].map((entry) => ({ verb: entry.verb, spec: entry.command.spec })),
+        }));
+    }
+}
+//# sourceMappingURL=command-registry.js.map

package/dist/src/core/application/config-values.js

@@ -0,0 +1,33 @@
+import { CONFIG_KEYS } from "../../config/config-keys.js";
+import { OperationFailedError } from "../domain/errors.js";
+import { message } from "../domain/message.js";
+export function configKey(key) {
+    return CONFIG_KEYS.find((entry) => entry.key === key);
+}
+/** A setting kiriya knows must hold the type its key declares; settings it does not know are left alone. */
+export function checkConfigTypes(values, file) {
+    for (const [key, value] of Object.entries(values)) {
+        const known = configKey(key);
+        if (known === undefined)
+            continue;
+        const isList = typeof value !== "string";
+        if ((known.type === "list") !== isList) {
+            const expected = message(known.type === "list" ? "core.config.type.list" : "core.config.type.string");
+            throw new OperationFailedError("core.config.wrong-type", { path: file, field: key, expected });
+        }
+    }
+}
+/** Whether the MCP server may offer tools that change files. Only the exact value `true` allows it. */
+export function mcpAllowsWrite(values) {
+    return values["mcp.allowWrite"] === "true";
+}
+/** Whether the MCP server may offer tools whose work cannot be undone. Only the exact value `true` allows it. */
+export function mcpAllowsDestroy(values) {
+    return values["mcp.allowDestroy"] === "true";
+}
+/** The plugins the configuration lists, in order; none when the setting is missing or malformed. */
+export function pluginEntries(values) {
+    const value = values["plugins"];
+    return value === undefined || typeof value === "string" ? [] : value;
+}
+//# sourceMappingURL=config-values.js.map

package/dist/src/core/application/path-guard.js

@@ -0,0 +1,69 @@
+import path from "node:path";
+import { PROTECTED_PATHS } from "../../config/protected-paths.js";
+import { message } from "../domain/message.js";
+/**
+ * Drive roots, the home folder, the working folder and its parents, and
+ * operating-system folders. Uses the path rules of the environment's OS, so
+ * Windows rules can be tested anywhere.
+ */
+export class PathGuard {
+    environment;
+    paths;
+    caseInsensitive;
+    constructor(environment) {
+        this.environment = environment;
+        this.paths = environment.os === "windows" ? path.win32 : path.posix;
+        this.caseInsensitive = environment.os !== "linux";
+    }
+    reasonFor(target, cwd) {
+        const resolved = this.paths.resolve(target);
+        if (resolved === this.paths.parse(resolved).root)
+            return message("core.guard.drive-root", { path: resolved });
+        if (this.same(resolved, this.paths.resolve(this.environment.homeDirectory))) {
+            return message("core.guard.home", { path: resolved });
+        }
+        if (this.isInside(this.paths.resolve(cwd), resolved))
+            return message("core.guard.working-folder", { path: resolved });
+        for (const folder of this.insideFolders()) {
+            if (this.isInside(resolved, folder))
+                return message("core.guard.system-folder", { path: resolved, folder });
+        }
+        for (const folder of this.exactFolders(resolved)) {
+            if (this.same(resolved, folder))
+                return message("core.guard.system-location", { path: resolved, folder });
+        }
+        return null;
+    }
+    insideFolders() {
+        if (this.environment.os !== "windows")
+            return PROTECTED_PATHS.posix.inside;
+        return this.fromVariables(PROTECTED_PATHS.windows.insideVariables);
+    }
+    exactFolders(target) {
+        if (this.environment.os !== "windows")
+            return PROTECTED_PATHS.posix.exact;
+        const root = this.paths.parse(target).root;
+        return [
+            ...this.fromVariables(PROTECTED_PATHS.windows.exactVariables),
+            ...PROTECTED_PATHS.windows.exactOnDrive.map((name) => this.paths.join(root, name)),
+        ];
+    }
+    fromVariables(names) {
+        return names
+            .map((name) => this.environment.variable(name))
+            .filter((value) => value !== undefined && value !== "")
+            .map((value) => this.paths.resolve(value));
+    }
+    normalize(value) {
+        return this.caseInsensitive ? value.toLowerCase() : value;
+    }
+    same(a, b) {
+        return this.normalize(a) === this.normalize(b);
+    }
+    /** True when `child` is `parent` or anywhere below it. */
+    isInside(child, parent) {
+        const relative = this.paths.relative(this.normalize(parent), this.normalize(child));
+        return relative === "" || (!relative.startsWith("..") && !this.paths.isAbsolute(relative));
+    }
+}
+//# sourceMappingURL=path-guard.js.map

package/dist/src/core/application/paths.js

@@ -0,0 +1,77 @@
+import path from "node:path";
+import { DEPENDENCY_DIRECTORIES } from "../../config/dependency-directories.js";
+import { NotFoundError, UsageError } from "../domain/errors.js";
+import { globToRegExp, hasGlob } from "../domain/glob.js";
+import { byCodePoint, isHiddenName } from "../domain/names.js";
+import { walk } from "./walk.js";
+/** True when `child` is `parent` or anywhere below it. */
+export function isInside(child, parent) {
+    const relative = path.relative(path.resolve(parent), path.resolve(child));
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+/**
+ * Paths from command arguments. An argument that exists is taken literally;
+ * otherwise kiriya expands the glob itself, so a quoted `"src/**\/*.ts"` means
+ * the same in PowerShell, cmd and bash. Globs skip hidden and dependency folders
+ * unless `all` is set or the pattern names one.
+ */
+export async function expandPaths(fileSystem, args, cwd, all) {
+    const found = new Set();
+    for (const arg of args) {
+        const literal = path.resolve(cwd, arg);
+        if ((await fileSystem.lstat(literal)) !== null) {
+            found.add(literal);
+            continue;
+        }
+        if (!hasGlob(arg))
+            throw new NotFoundError("core.fs.not-found", { path: literal });
+        const normalized = path.sep === "\\" ? arg.split("\\").join("/") : arg;
+        const segments = normalized.split("/");
+        const firstGlob = segments.findIndex((segment) => hasGlob(segment));
+        const base = path.resolve(cwd, segments.slice(0, firstGlob).join("/") || ".");
+        const rest = segments.slice(firstGlob).join("/");
+        const namesHidden = rest.split("/").some((segment) => isHiddenName(segment) || DEPENDENCY_DIRECTORIES.has(segment));
+        const pattern = globToRegExp(rest);
+        let matched = 0;
+        for await (const entry of walk(fileSystem, base, { all: all || namesHidden })) {
+            if (pattern.test(entry.rel)) {
+                found.add(entry.path);
+                matched += 1;
+            }
+        }
+        if (matched === 0)
+            throw new UsageError("core.glob.no-match", { pattern: arg });
+    }
+    return [...found].sort(byCodePoint);
+}
+/** Drops paths inside another selected folder, so nothing is handled twice. */
+export function outermost(paths) {
+    const kept = [];
+    for (const candidate of [...paths].sort((a, b) => a.length - b.length)) {
+        if (!kept.some((parent) => parent !== candidate && isInside(candidate, parent)))
+            kept.push(candidate);
+    }
+    return kept.sort(byCodePoint);
+}
+/** Total size of a file or folder, counting everything inside; symlinks count as entries, never followed. */
+export async function measure(fileSystem, target) {
+    const stat = await fileSystem.lstat(target);
+    if (stat === null)
+        return { bytes: 0, files: 0, directories: 0 };
+    if (stat.kind !== "directory")
+        return { bytes: stat.size, files: 1, directories: 0 };
+    let bytes = 0;
+    let files = 0;
+    let directories = 0;
+    for await (const entry of walk(fileSystem, target, { all: true })) {
+        if (entry.kind === "directory") {
+            directories += 1;
+        }
+        else {
+            files += 1;
+            bytes += (await fileSystem.lstat(entry.path))?.size ?? 0;
+        }
+    }
+    return { bytes, files, directories };
+}
+//# sourceMappingURL=paths.js.map