@phreshos/cli 0.1.47 → 0.1.49

package/dist/control/program.js

@@ -1,68 +0,0 @@
-import { Option } from "commander";
-import { commandContract } from "../command-contract.js";
-import { outputOptions } from "./options.js";
-import { bounded, connected, integer, output, page, programView, requireProgram, wait } from "./shared.js";
-export default function programCommands(root, connect) {
-    const program = commandContract(root.command("program")
-        .description("discover PhreshOS Programs and their agent documentation"));
-    outputOptions(program.command("list")
-        .description("list Programs with bounded filtering")
-        .option("--installed-only", "return only installed Programs")
-        .option("--search <text>", "case-insensitive identity, name, or description search")
-        .option("--limit <count>", "maximum returned Programs", integer, 30)
-        .option("--offset <count>", "number of matching Programs to skip", integer, 0))
-        .action(async (options) => connected(connect, async (system) => {
-        const programs = await system.program.list(options.installedOnly === true);
-        const selected = page(programs, options.search, bounded(options.offset, "--offset", 0), bounded(options.limit, "--limit", 1, 100), value => `${value.identity}\n${value.name}\n${value.description ?? ""}`);
-        output({ ...selected, data: await Promise.all(selected.data.map(programView)) }, options.compact);
-    }));
-    outputOptions(program.command("inspect")
-        .description("read one Program declaration and installed state")
-        .requiredOption("--program <identity>", "Program identity"))
-        .action(async (options) => connected(connect, async (system) => {
-        output(await programView(await requireProgram(system, options.program)), options.compact);
-    }));
-    outputOptions(program.command("agent")
-        .description("read a Program's own agent operating policy")
-        .requiredOption("--program <identity>", "Program identity"))
-        .action(async (options) => connected(connect, async (system) => {
-        const program = await requireProgram(system, options.program);
-        const content = await program.agent();
-        if (content === null)
-            throw new Error(`Program "${program.identity}" has no agent documentation`);
-        output({ program: program.identity, content }, options.compact);
-    }));
-    outputOptions(program.command("wait")
-        .description("wait for one Program registry event")
-        .addOption(new Option("--event <event>", "Program lifecycle event")
-        .choices(["create", "forget", "install", "uninstall"])
-        .makeOptionMandatory())
-        .option("--program <identity>", "scope forget or uninstall to one Program")
-        .option("--timeout <milliseconds>", "maximum wait in milliseconds", integer))
-        .action(async (options) => connected(connect, async (system) => {
-        if (options.program && options.event !== "forget" && options.event !== "uninstall") {
-            throw new Error("An individual Program emits only forget and uninstall");
-        }
-        const target = options.program ? await requireProgram(system, options.program) : system.program;
-        const message = await wait(target, options.event, timeout(options.timeout));
-        output({
-            scope: options.program ? `program:${options.program}` : "program",
-            event: options.event,
-            payload: await eventView(options.event, message, options.program ? target : undefined)
-        }, options.compact);
-    }));
-}
-async function eventView(event, message, scoped) {
-    if (event === "uninstall") {
-        if (scoped)
-            return { program: await programView(scoped), everything: message === true };
-        const value = message;
-        return { program: await programView(value.program), everything: value.everything };
-    }
-    if (scoped)
-        return programView(scoped);
-    return programView(message);
-}
-function timeout(value) {
-    return value === undefined ? undefined : bounded(value, "--timeout", 1);
-}

package/dist/control/window.js

@@ -1,84 +0,0 @@
-import { Option } from "commander";
-import { commandContract } from "../command-contract.js";
-import { outputOptions, processOptions } from "./options.js";
-import { bounded, connected, integer, output, position, requireProcess, size, wait, windowOf, windowView } from "./shared.js";
-export default function windowCommands(root, connect) {
-    const windows = commandContract(root.command("window")
-        .description("inspect and control authoritative Client Windows"));
-    outputOptions(processOptions(windows.command("inspect")
-        .description("read the complete current Window state")))
-        .action(async (options) => withWindow(connect, options, async (process) => {
-        output(await windowView(process), options.compact);
-    }));
-    outputOptions(processOptions(windows.command("move")
-        .description("change Window position")
-        .requiredOption("--x <value>", "horizontal pixels or workspace-relative expression")
-        .requiredOption("--y <value>", "vertical pixels or workspace-relative expression")))
-        .action(async (options) => withWindow(connect, options, async (process) => {
-        await windowOf(process).move(position(options.x, options.y));
-        output(await windowView(process), options.compact);
-    }));
-    outputOptions(processOptions(windows.command("resize")
-        .description("change Window size")
-        .requiredOption("--width <value>", "width in pixels or a workspace-relative expression")
-        .requiredOption("--height <value>", "height in pixels or a workspace-relative expression")))
-        .action(async (options) => withWindow(connect, options, async (process) => {
-        await windowOf(process).resize(size(options.width, options.height));
-        output(await windowView(process), options.compact);
-    }));
-    outputOptions(processOptions(windows.command("setGeometry")
-        .alias("set-geometry")
-        .description("change Window position and size atomically")
-        .requiredOption("--x <value>", "horizontal pixels or workspace-relative expression")
-        .requiredOption("--y <value>", "vertical pixels or workspace-relative expression")
-        .requiredOption("--width <value>", "width in pixels or a workspace-relative expression")
-        .requiredOption("--height <value>", "height in pixels or a workspace-relative expression")))
-        .action(async (options) => withWindow(connect, options, async (process) => {
-        await windowOf(process).setGeometry({
-            position: position(options.x, options.y),
-            size: size(options.width, options.height)
-        });
-        output(await windowView(process), options.compact);
-    }));
-    outputOptions(processOptions(windows.command("minimize")
-        .description("set Window visibility without changing its order")
-        .option("--restore", "restore rather than minimize the Window")))
-        .action(async (options) => withWindow(connect, options, async (process) => {
-        await windowOf(process).minimize(options.restore !== true);
-        output(await windowView(process), options.compact);
-    }));
-    outputOptions(processOptions(windows.command("changeTitle")
-        .alias("change-title")
-        .description("change the human-readable Window title")
-        .requiredOption("--title <title>", "new Window title")))
-        .action(async (options) => withWindow(connect, options, async (process) => {
-        await windowOf(process).changeTitle(options.title);
-        output(await windowView(process), options.compact);
-    }));
-    outputOptions(processOptions(windows.command("raise")
-        .description("raise the Window within its own layer")))
-        .action(async (options) => withWindow(connect, options, async (process) => {
-        await windowOf(process).raise();
-        output(await windowView(process), options.compact);
-    }));
-    outputOptions(processOptions(windows.command("wait")
-        .description("wait for one authoritative Window change")
-        .addOption(new Option("--event <event>", "Window event")
-        .choices(["move", "resize", "geometry", "minimize", "changeTitle", "front"])
-        .makeOptionMandatory())
-        .option("--timeout <milliseconds>", "maximum wait in milliseconds", integer)))
-        .action(async (options) => withWindow(connect, options, async (process) => {
-        output({
-            scope: `window:${process.identity}`,
-            event: options.event,
-            payload: await wait(windowOf(process), options.event, options.timeout === undefined
-                ? undefined
-                : bounded(options.timeout, "--timeout", 1))
-        }, options.compact);
-    }));
-}
-async function withWindow(connect, options, action) {
-    await connected(connect, async (system) => {
-        await action(await requireProcess(system, options.process, options.program));
-    });
-}

package/dist/describe-command.js

@@ -1,56 +0,0 @@
-import { commandContract, readCommandContract } from "./command-contract.js";
-import { blank } from "./style.js";
-/** Add one machine-readable description entry point for the complete CLI tree. */
-export default function describeCommands(program) {
-    commandContract(program.command("describe")
-        .description("describe any Phresh capability as machine-readable data")
-        .argument("[path...]", "command path to describe")
-        .option("--compact", "write JSON on one line")
-        .action(function (path, options) {
-        const command = resolveCommand(program, path);
-        const description = describe(command, path);
-        console.log(JSON.stringify(description, null, options.compact ? undefined : 2));
-        blank();
-    }), { guidance: ["Omit the path to discover all top-level commands, then describe progressively deeper paths."] });
-}
-function resolveCommand(root, path) {
-    let command = root;
-    for (const name of path) {
-        const child = command.commands.find(candidate => candidate.name() === name);
-        if (!child)
-            throw new Error(`Unknown command path "${path.join(" ")}"`);
-        command = child;
-    }
-    return command;
-}
-function describe(command, path) {
-    const registered = readCommandContract(command);
-    return {
-        path,
-        name: command.name(),
-        description: command.description(),
-        arguments: command.registeredArguments.map(argumentDescription),
-        options: command.options.map(optionDescription),
-        commands: command.commands.map(child => ({ name: child.name(), description: child.description() })),
-        ...(registered?.guidance ? { guidance: registered.guidance } : {})
-    };
-}
-function argumentDescription(argument) {
-    return {
-        name: argument.name(),
-        description: argument.description,
-        required: argument.required,
-        variadic: argument.variadic,
-        ...(argument.defaultValue === undefined ? {} : { default: argument.defaultValue })
-    };
-}
-function optionDescription(option) {
-    return {
-        flags: option.flags,
-        description: option.description,
-        value: option.required ? "required" : option.optional ? "optional" : "none",
-        variadic: option.variadic,
-        ...(option.defaultValue === undefined ? {} : { default: option.defaultValue }),
-        ...(option.argChoices === undefined ? {} : { choices: option.argChoices })
-    };
-}