kiriya 0.1.0

package/dist/src/modules/archive/domain/zip-format.js

@@ -0,0 +1,158 @@
+/**
+ * The ZIP format as pure functions over bytes: stored and deflated entries with
+ * UTF-8 names. ZIP64, which archives of 4 GB or 65,535 entries need, is detected
+ * and refused by the caller rather than guessed.
+ */
+export const STORED = 0;
+export const DEFLATED = 8;
+export const ZIP32_LIMIT = 0xffffffff;
+export const MAX_ENTRIES = 0xffff;
+export const LOCAL_HEADER_LENGTH = 30;
+export const END_RECORD_LENGTH = 22;
+/** The end record sits within this many bytes of the end: its own length plus the longest comment. */
+export const END_SEARCH_LENGTH = END_RECORD_LENGTH + 0xffff;
+const LOCAL_SIGNATURE = 0x04034b50;
+const CENTRAL_SIGNATURE = 0x02014b50;
+const END_SIGNATURE = 0x06054b50;
+const CENTRAL_HEADER_LENGTH = 46;
+const UTF8_NAMES = 0x0800;
+const ENCRYPTED = 0x0001;
+const DIRECTORY_ATTRIBUTE = 0x10;
+const ARCHIVE_ATTRIBUTE = 0x20;
+const encoder = new TextEncoder();
+function view(bytes) {
+    return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+/** ZIP stores local time in two-second steps from 1980. */
+function toDos(epochMs) {
+    const d = new Date(Math.max(epochMs, new Date(1980, 0, 1).getTime()));
+    return {
+        time: (d.getHours() << 11) | (d.getMinutes() << 5) | Math.floor(d.getSeconds() / 2),
+        date: ((d.getFullYear() - 1980) << 9) | ((d.getMonth() + 1) << 5) | d.getDate(),
+    };
+}
+function fromDos(time, date) {
+    return new Date(((date >> 9) & 0x7f) + 1980, ((date >> 5) & 0x0f) - 1, date & 0x1f, (time >> 11) & 0x1f, (time >> 5) & 0x3f, (time & 0x1f) * 2).getTime();
+}
+export function localHeader(entry) {
+    const name = encoder.encode(entry.name);
+    const bytes = new Uint8Array(LOCAL_HEADER_LENGTH + name.length);
+    const fields = view(bytes);
+    const { time, date } = toDos(entry.modifiedMs);
+    fields.setUint32(0, LOCAL_SIGNATURE, true);
+    fields.setUint16(4, 20, true);
+    fields.setUint16(6, UTF8_NAMES, true);
+    fields.setUint16(8, entry.method, true);
+    fields.setUint16(10, time, true);
+    fields.setUint16(12, date, true);
+    fields.setUint32(14, entry.crc, true);
+    fields.setUint32(18, entry.compressedSize, true);
+    fields.setUint32(22, entry.size, true);
+    fields.setUint16(26, name.length, true);
+    bytes.set(name, LOCAL_HEADER_LENGTH);
+    return bytes;
+}
+export function centralHeader(entry, localOffset) {
+    const name = encoder.encode(entry.name);
+    const bytes = new Uint8Array(CENTRAL_HEADER_LENGTH + name.length);
+    const fields = view(bytes);
+    const { time, date } = toDos(entry.modifiedMs);
+    fields.setUint32(0, CENTRAL_SIGNATURE, true);
+    fields.setUint16(4, 20, true);
+    fields.setUint16(6, 20, true);
+    fields.setUint16(8, UTF8_NAMES, true);
+    fields.setUint16(10, entry.method, true);
+    fields.setUint16(12, time, true);
+    fields.setUint16(14, date, true);
+    fields.setUint32(16, entry.crc, true);
+    fields.setUint32(20, entry.compressedSize, true);
+    fields.setUint32(24, entry.size, true);
+    fields.setUint16(28, name.length, true);
+    fields.setUint32(38, entry.isDirectory ? DIRECTORY_ATTRIBUTE : ARCHIVE_ATTRIBUTE, true);
+    fields.setUint32(42, localOffset, true);
+    bytes.set(name, CENTRAL_HEADER_LENGTH);
+    return bytes;
+}
+export function endRecord(location) {
+    const bytes = new Uint8Array(END_RECORD_LENGTH);
+    const fields = view(bytes);
+    fields.setUint32(0, END_SIGNATURE, true);
+    fields.setUint16(8, location.count, true);
+    fields.setUint16(10, location.count, true);
+    fields.setUint32(12, location.size, true);
+    fields.setUint32(16, location.offset, true);
+    return bytes;
+}
+/** The central directory's place, from the last bytes of an archive; null when they hold no end record. */
+export function findDirectory(tail) {
+    const fields = view(tail);
+    for (let index = tail.length - END_RECORD_LENGTH; index >= 0; index -= 1) {
+        if (fields.getUint32(index, true) === END_SIGNATURE) {
+            return {
+                count: fields.getUint16(index + 10, true),
+                size: fields.getUint32(index + 12, true),
+                offset: fields.getUint32(index + 16, true),
+            };
+        }
+    }
+    return null;
+}
+export function usesZip64(location) {
+    return location.count === MAX_ENTRIES || location.offset === ZIP32_LIMIT || location.size === ZIP32_LIMIT;
+}
+/** Every entry in central directory bytes; null when the directory is damaged. */
+export function parseDirectory(bytes, count) {
+    const fields = view(bytes);
+    const entries = [];
+    let position = 0;
+    for (let index = 0; index < count; index += 1) {
+        if (position + CENTRAL_HEADER_LENGTH > bytes.length)
+            return null;
+        if (fields.getUint32(position, true) !== CENTRAL_SIGNATURE)
+            return null;
+        const flags = fields.getUint16(position + 8, true);
+        const nameLength = fields.getUint16(position + 28, true);
+        const extraLength = fields.getUint16(position + 30, true);
+        const commentLength = fields.getUint16(position + 32, true);
+        const nameStart = position + CENTRAL_HEADER_LENGTH;
+        if (nameStart + nameLength > bytes.length)
+            return null;
+        const name = new TextDecoder(flags & UTF8_NAMES ? "utf-8" : "latin1").decode(bytes.subarray(nameStart, nameStart + nameLength));
+        entries.push({
+            name,
+            isDirectory: name.endsWith("/") || (fields.getUint32(position + 38, true) & DIRECTORY_ATTRIBUTE) !== 0,
+            method: fields.getUint16(position + 10, true),
+            encrypted: (flags & ENCRYPTED) !== 0,
+            crc: fields.getUint32(position + 16, true),
+            compressedSize: fields.getUint32(position + 20, true),
+            size: fields.getUint32(position + 24, true),
+            modifiedMs: fromDos(fields.getUint16(position + 12, true), fields.getUint16(position + 14, true)),
+            localOffset: fields.getUint32(position + 42, true),
+        });
+        position = nameStart + nameLength + extraLength + commentLength;
+    }
+    return entries;
+}
+/** Where an entry's data starts, from its local header; null when the header is damaged. */
+export function dataOffset(localOffset, header) {
+    if (header.length < LOCAL_HEADER_LENGTH)
+        return null;
+    const fields = view(header);
+    if (fields.getUint32(0, true) !== LOCAL_SIGNATURE)
+        return null;
+    return localOffset + LOCAL_HEADER_LENGTH + fields.getUint16(26, true) + fields.getUint16(28, true);
+}
+/**
+ * The folder names an entry may be written under, or null for a name that would
+ * escape the target folder: absolute, with a drive letter, or with a `..` segment.
+ */
+export function safeEntrySegments(name) {
+    const normalized = name.split(String.fromCharCode(92)).join("/");
+    if (normalized.startsWith("/") || /^[A-Za-z]:/.test(normalized))
+        return null;
+    const segments = normalized.split("/").filter((segment) => segment !== "" && segment !== ".");
+    if (segments.some((segment) => segment === ".."))
+        return null;
+    return segments;
+}
+//# sourceMappingURL=zip-format.js.map

package/dist/src/modules/archive/presentation/tar.view.js

@@ -0,0 +1,17 @@
+import { message } from "../../../core/domain/message.js";
+export const tarView = (output, format) => {
+    const ratio = output.bytesIn === 0 ? 100 : Math.round((output.bytesOut / output.bytesIn) * 100);
+    const summary = message("archive.tar.done", {
+        path: format.path(output.archive),
+        entries: output.entries,
+        bytesIn: format.bytes(output.bytesIn),
+        bytesOut: format.bytes(output.bytesOut),
+        ratio,
+    });
+    const lines = [format.green(format.text(summary))];
+    if (output.skippedLinks > 0) {
+        lines.push(format.dim(format.text(message("archive.tar.skipped-links", { count: output.skippedLinks }))));
+    }
+    return lines;
+};
+//# sourceMappingURL=tar.view.js.map

package/dist/src/modules/archive/presentation/untar.view.js

@@ -0,0 +1,30 @@
+import { message } from "../../../core/domain/message.js";
+export const untarView = (output, format) => {
+    if (output.mode === "list") {
+        const lines = output.entries.map((entry) => {
+            const size = entry.type === "file" ? format.bytes(entry.size) : "";
+            // Links and special files are listed, but never extracted.
+            const name = entry.type === "link" || entry.type === "other" ? format.dim(entry.name) : entry.name;
+            return `  ${format.time(entry.modifiedMs)}  ${size.padStart(9)}  ${name}`;
+        });
+        const total = message("archive.unzip.list-total", {
+            count: output.entries.length,
+            size: format.bytes(output.bytes),
+        });
+        lines.push("", format.text(total));
+        return lines;
+    }
+    if (!output.extracted)
+        return [];
+    const summary = message("archive.unzip.done", {
+        files: output.files,
+        size: format.bytes(output.bytes),
+        target: format.path(output.target),
+    });
+    const lines = [format.green(format.text(summary))];
+    if (output.skippedLinks > 0) {
+        lines.push(format.dim(format.text(message("archive.untar.skipped-links", { count: output.skippedLinks }))));
+    }
+    return lines;
+};
+//# sourceMappingURL=untar.view.js.map

package/dist/src/modules/archive/presentation/unzip.view.js

@@ -0,0 +1,24 @@
+import { message } from "../../../core/domain/message.js";
+export const unzipView = (output, format) => {
+    if (output.mode === "list") {
+        const lines = output.entries.map((entry) => {
+            const size = entry.isDirectory ? "" : format.bytes(entry.size);
+            return `  ${format.time(entry.modifiedMs)}  ${size.padStart(9)}  ${entry.name}`;
+        });
+        const total = message("archive.unzip.list-total", {
+            count: output.entries.length,
+            size: format.bytes(output.bytes),
+        });
+        lines.push("", format.text(total));
+        return lines;
+    }
+    if (!output.extracted)
+        return [];
+    const summary = message("archive.unzip.done", {
+        files: output.files,
+        size: format.bytes(output.bytes),
+        target: format.path(output.target),
+    });
+    return [format.green(format.text(summary))];
+};
+//# sourceMappingURL=unzip.view.js.map

package/dist/src/modules/archive/presentation/zip.view.js

@@ -0,0 +1,17 @@
+import { message } from "../../../core/domain/message.js";
+export const zipView = (output, format) => {
+    const ratio = output.bytesIn === 0 ? 100 : Math.round((output.bytesOut / output.bytesIn) * 100);
+    const summary = message("archive.zip.done", {
+        path: format.path(output.archive),
+        entries: output.entries,
+        bytesIn: format.bytes(output.bytesIn),
+        bytesOut: format.bytes(output.bytesOut),
+        ratio,
+    });
+    const lines = [format.green(format.text(summary))];
+    if (output.skippedLinks > 0) {
+        lines.push(format.dim(format.text(message("archive.zip.skipped-links", { count: output.skippedLinks }))));
+    }
+    return lines;
+};
+//# sourceMappingURL=zip.view.js.map

package/dist/src/modules/clip/application/copy-text.use-case.js

@@ -0,0 +1,43 @@
+import { inputText, readInput } from "../../../core/application/text-input.js";
+import { done } from "../../../core/domain/command.js";
+import { UsageError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { message } from "../../../core/domain/message.js";
+import { looksSecret } from "../../../core/domain/secrets.js";
+export const copySpec = {
+    id: "clip.copy",
+    summary: "clip.copy.summary",
+    examples: ['kiriya clip copy "hello"', "git log -1 | kiriya clip copy", "kiriya clip copy --file notes.md"],
+    // It replaces what is on the clipboard, which is why it is there.
+    safety: "write",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [{ name: "text", description: "clip.copy.arg.text", required: false, variadic: false }],
+        options: { file: { type: "string", description: "clip.copy.option.file", valueName: "<path>", path: true } },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return { value: reader.positional(0), file: reader.string("file") };
+        },
+    },
+};
+export class CopyText {
+    clipboard;
+    sources;
+    spec = copySpec;
+    constructor(clipboard, sources) {
+        this.clipboard = clipboard;
+        this.sources = sources;
+    }
+    async execute(input, context) {
+        const text = inputText(await readInput(this.sources, context.cwd, input.value, input.file));
+        if (text === "")
+            throw new UsageError("clip.copy.empty");
+        await this.clipboard.write(text, context.signal);
+        // Clipboard history and other programs can read it long after.
+        const warnings = looksSecret(text) ? [message("clip.copy.secret")] : [];
+        return done({ characters: [...text].length }, { warnings });
+    }
+}
+//# sourceMappingURL=copy-text.use-case.js.map

package/dist/src/modules/clip/application/paste-text.use-case.js

@@ -0,0 +1,25 @@
+import { done } from "../../../core/domain/command.js";
+export const pasteSpec = {
+    id: "clip.paste",
+    summary: "clip.paste.summary",
+    examples: ["kiriya clip paste", "kiriya clip paste > notes.txt", "kiriya clip paste --json"],
+    safety: "read",
+    // The clipboard can change between runs.
+    idempotent: false,
+    usesNetwork: false,
+    runsUserCommands: false,
+    // The clipboard often holds a password on its way to a form.
+    sensitive: true,
+    input: { positionals: [], options: {}, parse: () => ({}) },
+};
+export class PasteText {
+    clipboard;
+    spec = pasteSpec;
+    constructor(clipboard) {
+        this.clipboard = clipboard;
+    }
+    async execute(_input, context) {
+        return done({ text: await this.clipboard.read(context.signal) });
+    }
+}
+//# sourceMappingURL=paste-text.use-case.js.map

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

@@ -0,0 +1,16 @@
+import { CopyText } from "./application/copy-text.use-case.js";
+import { PasteText } from "./application/paste-text.use-case.js";
+import { copyView, pasteView } from "./presentation/clip.views.js";
+export const clipModule = {
+    id: "clip",
+    summary: "clip.summary",
+    about: "clip.about",
+    examples: ['kiriya clip copy "hello"', "kiriya clip copy --file notes.md", "kiriya clip paste"],
+    guide: "https://github.com/SatPaingOo/kiriya/blob/main/docs/modules/clip.md",
+    register(registrar, ports) {
+        const sources = { stdin: ports.stdin, fileSystem: ports.fileSystem, content: ports.fileContent };
+        registrar.add(new CopyText(ports.clipboard, sources), copyView);
+        registrar.add(new PasteText(ports.clipboard), pasteView);
+    },
+};
+//# sourceMappingURL=clip.module.js.map

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

@@ -0,0 +1,7 @@
+import { message } from "../../../core/domain/message.js";
+export const copyView = (output, format) => [
+    format.dim(format.text(message("clip.copy.done", { count: output.characters }))),
+];
+/** The text itself, one final line ending aside, which the terminal adds back. */
+export const pasteView = (output) => output.text === "" ? [] : output.text.replace(/\r?\n$/, "").split(/\r?\n/);
+//# sourceMappingURL=clip.views.js.map

package/dist/src/modules/completion/application/print-script.use-case.js

@@ -0,0 +1,38 @@
+import { done } from "../../../core/domain/command.js";
+import { UsageError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { completionScript, SHELLS } from "../domain/scripts.js";
+export const scriptSpec = {
+    id: "completion",
+    summary: "completion.script.summary",
+    examples: [
+        'eval "$(kiriya completion bash)"',
+        "kiriya completion fish > ~/.config/fish/completions/kiriya.fish",
+        "kiriya completion powershell | Out-String | Invoke-Expression",
+    ],
+    safety: "read",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [
+            { name: "shell", description: "completion.arg.shell", required: true, variadic: false, choices: SHELLS },
+        ],
+        options: {},
+        parse(raw) {
+            const text = new RawReader(raw).positional(0) ?? "";
+            const shell = SHELLS.find((candidate) => candidate === text);
+            if (shell === undefined)
+                throw new UsageError("completion.shell-invalid", { shell: text });
+            return { shell };
+        },
+    },
+};
+/** Prints the script and installs nothing, so it can be read before it is loaded. */
+export class PrintScript {
+    spec = scriptSpec;
+    execute(input) {
+        return Promise.resolve(done({ shell: input.shell, script: completionScript(input.shell) }));
+    }
+}
+//# sourceMappingURL=print-script.use-case.js.map

package/dist/src/modules/completion/application/suggest-words.use-case.js

@@ -0,0 +1,37 @@
+import { done } from "../../../core/domain/command.js";
+import { GLOBAL_OPTIONS } from "../../../core/domain/global-options.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { suggest } from "../domain/suggest.js";
+export const suggestSpec = {
+    id: "completion.suggest",
+    summary: "completion.suggest.summary",
+    examples: ["kiriya completion suggest --word=files --current=li", "kiriya completion suggest --current= --json"],
+    safety: "read",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [],
+        options: {
+            current: { type: "string", description: "completion.suggest.option.current", valueName: "<word>" },
+            word: { type: "string", multiple: true, description: "completion.suggest.option.word", valueName: "<word>" },
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return { current: reader.string("current") ?? "", words: reader.strings("word") };
+        },
+    },
+};
+/** Never runs what is on the line: it only reads the command catalog. */
+export class SuggestWords {
+    commands;
+    spec = suggestSpec;
+    constructor(commands) {
+        this.commands = commands;
+    }
+    execute(input) {
+        const suggestions = suggest(this.commands.catalog(), GLOBAL_OPTIONS, input.words, input.current);
+        return Promise.resolve(done({ suggestions }));
+    }
+}
+//# sourceMappingURL=suggest-words.use-case.js.map

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

@@ -0,0 +1,14 @@
+import { PrintScript } from "./application/print-script.use-case.js";
+import { SuggestWords } from "./application/suggest-words.use-case.js";
+import { scriptView, suggestView } from "./presentation/completion.views.js";
+export const completionModule = {
+    id: "completion",
+    summary: "completion.summary",
+    about: "completion.about",
+    guide: "https://github.com/SatPaingOo/kiriya/blob/main/docs/modules/completion.md",
+    register(registrar, ports) {
+        registrar.add(new PrintScript(), scriptView);
+        registrar.add(new SuggestWords(ports.commands), suggestView);
+    },
+};
+//# sourceMappingURL=completion.module.js.map

package/dist/src/modules/completion/domain/scripts.js

@@ -0,0 +1,91 @@
+export const SHELLS = ["bash", "zsh", "fish", "powershell"];
+/*
+ * Each script only gathers the words on the line and asks `kiriya completion suggest`
+ * what can come next, so every shell completes the same way and plugins installed
+ * later complete too. Words travel as --word=<word> and --current=<word>: Windows
+ * PowerShell 5.1 drops empty arguments to programs, and a word such as --json must
+ * never be read as an option of suggest itself. An empty answer hands completion
+ * back to the shell, which then offers file names.
+ */
+const BASH = [
+    "# kiriya completion for bash.",
+    '# Load it from ~/.bashrc:  eval "$(kiriya completion bash)"',
+    "_kiriya_complete() {",
+    '  local args=("--current=${COMP_WORDS[COMP_CWORD]}")',
+    "  local i",
+    "  # Word by word: bash 3.2, as macOS ships it, joins a sliced array into one word.",
+    "  for ((i = 1; i < COMP_CWORD; i++)); do",
+    '    args+=("--word=${COMP_WORDS[i]}")',
+    "  done",
+    "  local lines",
+    '  lines=$(kiriya completion suggest "${args[@]}" 2>/dev/null) || return 0',
+    "  COMPREPLY=()",
+    '  [ -z "$lines" ] && return 0',
+    "  local IFS=$'\\n'",
+    "  COMPREPLY=($(printf '%s\\n' \"$lines\" | cut -f1))",
+    "}",
+    "# With no suggestion, -o default lets bash complete file names.",
+    "complete -o default -F _kiriya_complete kiriya",
+];
+const ZSH = [
+    "#compdef kiriya",
+    "# kiriya completion for zsh.",
+    '# Load it from ~/.zshrc, after compinit:  eval "$(kiriya completion zsh)"',
+    "_kiriya() {",
+    "  local -a args lines candidates",
+    "  local word line tab=$'\\t'",
+    '  args=("--current=${words[CURRENT]}")',
+    '  for word in "${(@)words[2,CURRENT-1]}"; do',
+    '    args+=("--word=$word")',
+    "  done",
+    '  lines=("${(@f)$(kiriya completion suggest "${args[@]}" 2>/dev/null)}")',
+    '  if [[ -z "${lines[1]}" ]]; then',
+    "    _files",
+    "    return",
+    "  fi",
+    '  for line in "${lines[@]}"; do',
+    '    candidates+=("${${line%%${tab}*}//:/\\\\:}:${line#*${tab}}")',
+    "  done",
+    "  _describe 'kiriya' candidates",
+    "}",
+    "compdef _kiriya kiriya",
+];
+const FISH = [
+    "# kiriya completion for fish.",
+    "# Save it once:  kiriya completion fish > ~/.config/fish/completions/kiriya.fish",
+    "function __kiriya_complete",
+    "    set -l words (commandline -opc)",
+    "    set -l lines (kiriya completion suggest --current=(commandline -ct) --word=$words[2..-1] 2>/dev/null)",
+    "    if test (count $lines) -eq 0",
+    "        __fish_complete_path (commandline -ct)",
+    "        return",
+    "    end",
+    "    printf '%s\\n' $lines",
+    "end",
+    "complete -c kiriya -f -a '(__kiriya_complete)'",
+];
+const POWERSHELL = [
+    "# kiriya completion for PowerShell.",
+    "# Load it from your profile:  kiriya completion powershell | Out-String | Invoke-Expression",
+    "Register-ArgumentCompleter -Native -CommandName kiriya -ScriptBlock {",
+    "    param($wordToComplete, $commandAst, $cursorPosition)",
+    "    $words = @($commandAst.CommandElements | Select-Object -Skip 1 | ForEach-Object { $_.ToString() })",
+    "    if ($wordToComplete -ne '' -and $words.Count -gt 0) { $words = @($words | Select-Object -SkipLast 1) }",
+    '    $arguments = @("--current=$wordToComplete") + @($words | ForEach-Object { "--word=$_" })',
+    "    kiriya completion suggest @arguments 2>$null | ForEach-Object {",
+    '        $parts = $_ -split "`t", 2',
+    "        $tip = if ($parts.Count -gt 1 -and $parts[1] -ne '') { $parts[1] } else { $parts[0] }",
+    "        [System.Management.Automation.CompletionResult]::new($parts[0], $parts[0], 'ParameterValue', $tip)",
+    "    }",
+    "}",
+];
+const SCRIPTS = {
+    bash: BASH,
+    zsh: ZSH,
+    fish: FISH,
+    powershell: POWERSHELL,
+};
+export function completionScript(shell) {
+    return `${SCRIPTS[shell].join("\n")}\n`;
+}
+//# sourceMappingURL=scripts.js.map

package/dist/src/modules/completion/domain/suggest.js

@@ -0,0 +1,134 @@
+/** The values an option lists in its value name, such as `<hex|base64|base64url>`. */
+export function optionChoices(option) {
+    const match = /^<([a-z0-9-]+(?:\|[a-z0-9-]+)+)>$/.exec(option.valueName ?? "");
+    return match?.[1]?.split("|") ?? [];
+}
+function ownCommand(module) {
+    return module.commands.find((command) => command.verb === "");
+}
+function positionalChoices(command, index) {
+    const positionals = command.spec.input.positionals;
+    const last = positionals.at(-1);
+    const positional = positionals[index] ?? (last?.variadic === true ? last : undefined);
+    return [...(positional?.choices ?? [])];
+}
+function findOption(command, word) {
+    if (command === undefined)
+        return undefined;
+    const options = command.spec.input.options;
+    if (word.startsWith("--"))
+        return options[word.slice(2).split("=")[0] ?? ""];
+    return Object.values(options).find((option) => option.short === word.slice(1));
+}
+/** Where the line stands after the words before the one being completed; null after a word kiriya does not know. */
+function locate(modules, words) {
+    let module;
+    let command;
+    let argument = 0;
+    let help = null;
+    let pending;
+    let literal = false;
+    let started = false;
+    for (const word of words) {
+        if (pending !== undefined) {
+            pending = undefined;
+            continue;
+        }
+        if (!literal && word === "--") {
+            literal = true;
+            continue;
+        }
+        if (!literal && word.length > 1 && word.startsWith("-")) {
+            const option = findOption(command ?? (module === undefined ? undefined : ownCommand(module)), word);
+            if (option?.type === "string" && !word.includes("="))
+                pending = option;
+            continue;
+        }
+        if (help !== null) {
+            help.push(word);
+            continue;
+        }
+        if (!started) {
+            started = true;
+            if (word === "help") {
+                help = [];
+                continue;
+            }
+            module = modules.find((candidate) => candidate.id === word);
+            if (module === undefined)
+                return null;
+            continue;
+        }
+        if (module !== undefined && command === undefined) {
+            const named = module.commands.find((candidate) => candidate.verb !== "" && candidate.verb === word);
+            command = named ?? ownCommand(module);
+            if (command === undefined)
+                return null;
+            // A module that is one command takes this word as its first argument.
+            if (named === undefined)
+                argument = 1;
+            continue;
+        }
+        argument += 1;
+    }
+    return { module, command, argument, help, pending, literal };
+}
+function moduleSuggestions(modules) {
+    return modules.map((module) => ({ value: module.id, description: module.summary }));
+}
+function verbSuggestions(module) {
+    return module.commands
+        .filter((command) => command.verb !== "")
+        .map((command) => ({ value: command.verb, description: command.spec.summary }));
+}
+function plain(values) {
+    return values.map((value) => ({ value, description: null }));
+}
+/**
+ * What can come next on a command line: modules, then commands, options and their
+ * values. `words` are the words after `kiriya` and before the one being completed. An
+ * empty result means a free value such as a path, which the shell completes as a file name.
+ */
+export function suggest(modules, globals, words, current) {
+    const position = locate(modules, words);
+    if (position === null)
+        return [];
+    const starting = (suggestion) => suggestion.value.startsWith(current);
+    if (position.pending !== undefined)
+        return plain(optionChoices(position.pending)).filter(starting);
+    const command = position.command ?? (position.module === undefined ? undefined : ownCommand(position.module));
+    if (!position.literal && current.startsWith("--") && current.includes("=")) {
+        const name = current.slice(2, current.indexOf("="));
+        const option = findOption(command, `--${name}`);
+        if (option === undefined)
+            return [];
+        return plain(optionChoices(option).map((choice) => `--${name}=${choice}`)).filter(starting);
+    }
+    if (!position.literal && current.startsWith("-")) {
+        const own = Object.entries(command?.spec.input.options ?? {}).map(([name, option]) => ({
+            value: `--${name}`,
+            description: option.description,
+        }));
+        const global = globals.map((option) => ({ value: `--${option.name}`, description: option.description }));
+        return [...own, ...global].filter(starting);
+    }
+    if (position.help !== null) {
+        const [moduleName, ...rest] = position.help;
+        if (moduleName === undefined)
+            return moduleSuggestions(modules).filter(starting);
+        const helpModule = modules.find((module) => module.id === moduleName);
+        return helpModule === undefined || rest.length > 0 ? [] : verbSuggestions(helpModule).filter(starting);
+    }
+    if (position.module === undefined) {
+        const help = { value: "help", description: "completion.help-word" };
+        const mcp = { value: "mcp", description: "core.mcp.summary" };
+        return [...moduleSuggestions(modules), help, mcp].filter(starting);
+    }
+    if (position.command === undefined) {
+        const own = ownCommand(position.module);
+        const choices = own === undefined ? [] : positionalChoices(own, 0);
+        return [...verbSuggestions(position.module), ...plain(choices)].filter(starting);
+    }
+    return plain(positionalChoices(position.command, position.argument)).filter(starting);
+}
+//# sourceMappingURL=suggest.js.map