@maiaos/cli 0.1.0-canary.2

package/dist/project-workspace/tree/tree.js

@@ -0,0 +1,197 @@
+const project = () => import("../index.js");
+const guard = () => import("../../project-guard/index.js");
+const container = () => import("../../container/index.js");
+export const PROJECT_TREE = {
+    groups: [
+        ["project", "Projects: registered repositories."],
+        ["project guard", "A Project's guards."],
+        ["project context", "A Project's context notes."],
+        ["workspace", "Workspaces of a Project."],
+        ["workspace context", "The active Workspace context."],
+        ["workspace membership", "Repositories attached to a Workspace."],
+        ["workspace execution", "A Workspace's execution settings."],
+        ["workspace repository", "A Workspace's repositories."],
+        ["container", "Workspace containers."],
+        ["container index", "Every container with its Projects."],
+    ],
+    leaves: [
+        [
+            "project register <path> [--name <name>] [--command-id <id>]",
+            0,
+            "project.register",
+            "Register a Git repository as a Project.",
+            {
+                example: "maia --json project register . --name app --command-id project-1",
+                run: [project, "runProjectRegister"],
+            },
+        ],
+        [
+            "project list [--limit <1..100>] [--after <cursor>]",
+            0,
+            "project.list",
+            "List Projects.",
+            {
+                example: "maia --json project list --limit 20",
+                run: [project, "runProjectList"],
+            },
+        ],
+        [
+            "project show <project-id>",
+            0,
+            "project.show",
+            "Show one Project.",
+            { run: [project, "runProjectShow"] },
+        ],
+        [
+            "project create (--input-stdin --dry-run | --confirm-stdin)",
+            1,
+            ["project.create.preview", "project.create.confirm"],
+            "Create a Project after a preview.",
+            { kind: "two-phase", run: [project, "runProjectCreate"] },
+        ],
+        [
+            "project rename (--input-stdin --dry-run | --confirm-stdin)",
+            1,
+            ["project.rename.preview", "project.rename.confirm"],
+            "Rename a Project after a preview.",
+            { kind: "two-phase", run: [project, "runProjectRename"] },
+        ],
+        [
+            "project guard show <project-id>",
+            1,
+            "project.guard.show",
+            "Show a Project's guards.",
+            { run: [guard, "runProjectGuardShow"] },
+        ],
+        [
+            "project guard set (<project-id> --expected-revision <revision> --max-depth <1..4> --max-live-children <1..64> --max-messages-per-minute <1..600> --max-leases-per-session <1..64> [--command-id <id>] [--dry-run] | --confirm-stdin)",
+            1,
+            ["project.guard.preview", "project.guard.confirm"],
+            "Set a Project's guards after a preview.",
+            { kind: "two-phase", run: [guard, "runProjectGuardSet"] },
+        ],
+        [
+            "project context record --project <project-id> --body-stdin [--command-id <id>]",
+            0,
+            "project.context.record",
+            "Record a context note for a Project.",
+            { run: [project, "runProjectContextRecord"] },
+        ],
+        [
+            "project context list --project <project-id> [--limit <1..100>] [--after <cursor>]",
+            0,
+            "project.context.list",
+            "List a Project's context notes.",
+            { run: [project, "runProjectContextList"] },
+        ],
+        [
+            "project context show <note-id>",
+            0,
+            "project.context.show",
+            "Show one context note.",
+            { run: [project, "runProjectContextShow"] },
+        ],
+        [
+            "workspace list --project <project-id> [--limit <1..100>] [--after <cursor>]",
+            0,
+            "workspace.list",
+            "List a Project's Workspaces.",
+            { run: [project, "runWorkspaceList"] },
+        ],
+        [
+            "workspace show <workspace-id>",
+            0,
+            "workspace.show",
+            "Show one Workspace.",
+            { run: [project, "runWorkspaceShow"] },
+        ],
+        [
+            "workspace select <workspace-id> --project <project-id> --repository <repository-id> --expected-active-workspace-id <workspace-id> --expected-active-context-revision <revision> --expected-workspace-revision <revision> --expected-context-revision <revision> [--command-id <id>]",
+            1,
+            "workspace.select",
+            "Select the active Workspace.",
+            { run: [project, "runWorkspaceSelect"] },
+        ],
+        [
+            "workspace context show",
+            1,
+            "workspace.context.show",
+            "Show the active Workspace context.",
+            { run: [project, "runWorkspaceContextShow"] },
+        ],
+        [
+            "workspace execution show <workspace-id>",
+            1,
+            "workspace.execution.show",
+            "Show a Workspace's execution settings.",
+            { run: [project, "runWorkspaceExecutionShow"] },
+        ],
+        [
+            "workspace execution set <workspace-id> (--execution-profile <profile-id> | --policy <policy-id>) --expected-revision <revision> [--command-id <id>]",
+            1,
+            "workspace.execution.configure",
+            "Set a Workspace's execution profile or policy.",
+            { kind: "discriminant", run: [project, "runWorkspaceExecutionSet"] },
+        ],
+        [
+            "workspace execution clear <workspace-id> --expected-revision <revision> [--command-id <id>]",
+            1,
+            "workspace.execution.configure",
+            "Clear a Workspace's execution settings.",
+            { kind: "discriminant", run: [project, "runWorkspaceExecutionClear"] },
+        ],
+        [
+            "workspace membership attach <workspace-id> --project <project-id> --repository <repository-id> --expected-workspace-revision <revision> --expected-context-revision <revision> [--command-id <id>]",
+            1,
+            "workspace.membership.attach",
+            "Attach a Project repository to a Workspace.",
+            { run: [project, "runWorkspaceMembershipAttach"] },
+        ],
+        [
+            "workspace repository attach <path> --workspace <workspace-id> --expected-revision <revision> [--name <name>] [--command-id <id>]",
+            0,
+            "workspace.repository.attach",
+            "Attach a repository to a Workspace.",
+            { run: [project, "runWorkspaceRepositoryAttach"] },
+        ],
+        [
+            "container list [--limit <1..100>] [--after <cursor>]",
+            1,
+            "container.list",
+            "List containers.",
+            { run: [container, "runContainerList"] },
+        ],
+        [
+            "container show <container-id> [--limit <1..100>] [--after <cursor>]",
+            1,
+            "container.show",
+            "Show one container and its Projects.",
+            { run: [container, "runContainerShow"] },
+        ],
+        [
+            "container index list [--limit <1..500>] [--after <cursor>]",
+            1,
+            "container.index.list",
+            "List every container with its Projects and their paths.",
+            {
+                example: "maia --json container index list --limit 500",
+                run: [container, "runContainerIndexList"],
+            },
+        ],
+        [
+            "container create (--input-stdin --dry-run | --confirm-stdin)",
+            1,
+            ["container.create.preview", "container.create.confirm"],
+            "Create a container after a preview.",
+            { kind: "two-phase", run: [container, "runContainerCreate"] },
+        ],
+        [
+            "container rename (--input-stdin --dry-run | --confirm-stdin)",
+            1,
+            ["container.rename.preview", "container.rename.confirm"],
+            "Rename a container after a preview.",
+            { kind: "two-phase", run: [container, "runContainerRename"] },
+        ],
+    ],
+};
+//# sourceMappingURL=tree.js.map

package/dist/provider/client.d.ts

@@ -0,0 +1,6 @@
+import type { ProviderPoolListResult } from "@maiaos/sdk";
+import type { CliNodeEffect, CliNodeOperations } from "../local-node/index.js";
+export declare const makeProviderClient: (node: CliNodeOperations) => {
+    listProviderPools: () => CliNodeEffect<ProviderPoolListResult>;
+};
+//# sourceMappingURL=client.d.ts.map

package/dist/provider/client.js

@@ -0,0 +1,5 @@
+import { providerPoolListParametersSchema } from "@maiaos/sdk";
+export const makeProviderClient = (node) => ({
+    listProviderPools: () => node.runValidatedNodeOperation({}, providerPoolListParametersSchema, (client, parameters, options) => client.listProviderPools(parameters, options)),
+});
+//# sourceMappingURL=client.js.map

package/dist/provider/commands.d.ts

@@ -0,0 +1,3 @@
+import { type CommandContext, type CommandEffect } from "../command-line/index.js";
+export declare const runProviderPoolList: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+//# sourceMappingURL=commands.d.ts.map

package/dist/provider/commands.js

@@ -0,0 +1,38 @@
+import * as Effect from "effect/Effect";
+import { cell, formatRows, parseOptions, requirePositionals, tab, writeNodeResult, } from "../command-line/index.js";
+const formatPools = ({ result }) => formatRows(result.pools, (pool) => tab([
+    cell(pool.poolId),
+    cell(pool.providerId),
+    cell(pool.model),
+    `${String(pool.availableCredentialCount)}/${String(pool.credentialCount)}`,
+    pool.default ? "default" : "-",
+]), {
+    empty: "No model-provider pools.",
+    headers: ["POOL", "PROVIDER", "MODEL", "CREDENTIALS", "DEFAULT"],
+});
+export const runProviderPoolList = (tokens, context) => Effect.gen(function* () {
+    const parsed = parseOptions(tokens, new Set());
+    requirePositionals(parsed.positionals, 0);
+    const operation = context.dependencies.listProviderPools;
+    if (operation === undefined)
+        return yield* Effect.die(new Error("Missing provider client."));
+    const result = yield* operation();
+    return writeNodeResult(result, context, {
+        toResult: (value) => ({
+            command: "provider.pool.list",
+            result: {
+                pools: value.pools.map((pool) => ({
+                    availableCredentialCount: pool.availableCredentialCount,
+                    credentialCount: pool.credentialCount,
+                    default: pool.default,
+                    model: pool.model,
+                    poolId: pool.poolId,
+                    providerId: pool.providerId,
+                })),
+                releaseQualified: value.releaseQualified,
+            },
+        }),
+        toText: formatPools,
+    });
+});
+//# sourceMappingURL=commands.js.map

package/dist/provider/index.d.ts

@@ -0,0 +1,3 @@
+export { makeProviderClient } from "./client.js";
+export { runProviderPoolList } from "./commands.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/provider/index.js

@@ -0,0 +1,3 @@
+export { makeProviderClient } from "./client.js";
+export { runProviderPoolList } from "./commands.js";
+//# sourceMappingURL=index.js.map

package/dist/reference/commands.d.ts

@@ -0,0 +1,3 @@
+import { type CommandContext, type CommandEffect } from "../command-line/index.js";
+export declare const runReferenceResolve: (tokens: readonly string[], context: CommandContext) => CommandEffect;
+//# sourceMappingURL=commands.d.ts.map

package/dist/reference/commands.js

@@ -0,0 +1,39 @@
+import * as Effect from "effect/Effect";
+import { cell, CliArgumentError, parseOptions, writeNodeResult, } from "../command-line/index.js";
+import { workingFolder } from "./resolve.js";
+const KINDS = new Set([
+    "connection",
+    "container",
+    "project",
+    "session",
+    "workspace",
+]);
+const isKind = (value) => KINDS.has(value ?? "");
+const readParameters = (tokens, context) => {
+    const parsed = parseOptions(tokens, new Set(["--project"]));
+    const [kind, reference, ...extra] = parsed.positionals;
+    if (!isKind(kind) || extra.length > 0)
+        throw new CliArgumentError("Name one kind (connection, container, project, session or workspace) and at most one reference.");
+    const projectId = parsed.options.get("--project");
+    const path = context.node === undefined ? workingFolder(context.io.cwd) : undefined;
+    if (reference === undefined)
+        return { kind, ...(path === undefined ? {} : { path }) };
+    return { kind, reference, ...(projectId === undefined ? {} : { projectId }) };
+};
+const line = (id, label) => `${id}${label === undefined ? "" : `\t${cell(label)}`}\n`;
+const formatResolution = (value) => value.outcome === "resolved"
+    ? line(value.id, value.label)
+    : value.candidates
+        .map((candidate) => line(candidate.id, candidate.label))
+        .join("");
+export const runReferenceResolve = (tokens, context) => {
+    const parameters = readParameters(tokens, context);
+    const { call } = context.dependencies;
+    if (call === undefined)
+        return Effect.die(new Error("Missing the typed Node call."));
+    return Effect.map(call("reference.resolve", parameters), (result) => writeNodeResult(result, context, {
+        toResult: (value) => ({ command: "reference.resolve", result: value }),
+        toText: ({ result: value }) => formatResolution(value),
+    }));
+};
+//# sourceMappingURL=commands.js.map

package/dist/reference/index.d.ts

@@ -0,0 +1,3 @@
+export { runReferenceResolve } from "./commands.js";
+export { describeResolution, type LeafArguments, type PreparedLeaf, prepareLeaf, type ResolvedArguments, resolveLeafArguments, workingFolder, } from "./resolve.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/reference/index.js

@@ -0,0 +1,3 @@
+export { runReferenceResolve } from "./commands.js";
+export { describeResolution, prepareLeaf, resolveLeafArguments, workingFolder, } from "./resolve.js";
+//# sourceMappingURL=index.js.map

package/dist/reference/resolve.d.ts

@@ -0,0 +1,29 @@
+import * as Effect from "effect/Effect";
+import { CliArgumentError, type CliResolution, type CliServices, type CommandContext } from "../command-line/index.js";
+export type ResolvedArguments = {
+    readonly exitCode: number;
+    readonly ok: false;
+} | {
+    readonly ok: true;
+    readonly resolutions: readonly CliResolution[];
+    readonly tokens: readonly string[];
+};
+export declare const describeResolution: (item: CliResolution) => string;
+export type LeafArguments = {
+    readonly context: CommandContext;
+    readonly cwd?: string;
+    readonly tokens: readonly string[];
+    readonly usage: string;
+};
+export declare const resolveLeafArguments: ({ context, cwd, tokens, usage, }: LeafArguments) => Effect.Effect<ResolvedArguments, CliArgumentError, CliServices>;
+export type PreparedLeaf = {
+    readonly context: CommandContext;
+    readonly ok: true;
+    readonly tokens: readonly string[];
+} | {
+    readonly exitCode: number;
+    readonly ok: false;
+};
+export declare const prepareLeaf: (input: LeafArguments) => Effect.Effect<PreparedLeaf, CliArgumentError, CliServices>;
+export declare const workingFolder: (cwd?: string) => string | undefined;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/reference/resolve.js

@@ -0,0 +1,294 @@
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import { cell, CliArgumentError, parseOptions, reportError, tokenizeArguments, } from "../command-line/index.js";
+import { parseUsage, REFERENCE_PLACEHOLDER, } from "../command-tree/index.js";
+class ReferenceRefused extends Data.TaggedError("ReferenceRefused") {
+}
+const NOUNS = {
+    connection: "Connection",
+    container: "Container",
+    project: "Project",
+    session: "Session",
+    workspace: "Workspace",
+};
+const MAX_REFERENCES = 32;
+const SCOPE_NAMES = new Set([
+    "--all",
+    "--project",
+    "--workspace",
+]);
+const isKind = (value) => Object.hasOwn(NOUNS, value);
+const kindOf = (placeholder) => {
+    const word = REFERENCE_PLACEHOLDER.exec(placeholder ?? "")?.[1] ?? "";
+    return isKind(word) ? word : undefined;
+};
+const isExactId = (kind, value) => new RegExp(`^${kind}_[0-9a-f]{32}$`, "u").test(value);
+const grammarOf = (arguments_) => ({
+    options: new Map(arguments_.flatMap((argument) => argument.name.startsWith("--") && argument.value !== undefined
+        ? [
+            [
+                argument.name,
+                argument.name.startsWith("--expected-")
+                    ? undefined
+                    : kindOf(argument.value),
+            ],
+        ]
+        : [])),
+    positionals: arguments_.filter((argument) => argument.name.startsWith("<")),
+});
+const slotOf = (grammar, position) => {
+    const { positionals } = grammar;
+    const last = positionals.at(-1);
+    return positionals[position] ?? (last?.repeated === true ? last : undefined);
+};
+const valueOf = (token, inline) => inline ? token.slice(token.indexOf("=") + 1) : token;
+const placeOf = (grammar, role, position) => {
+    if (role.kind === "value") {
+        const kind = grammar.options.get(role.name);
+        return {
+            argument: role.name,
+            index: role.index,
+            inline: role.inline,
+            ...(kind === undefined ? {} : { kind }),
+        };
+    }
+    const slot = slotOf(grammar, position);
+    const kind = kindOf(slot?.name);
+    return {
+        argument: slot?.name ?? "",
+        index: role.index,
+        inline: false,
+        ...(kind === undefined ? {} : { kind }),
+    };
+};
+const targetsOf = (grammar, tokens, roles) => {
+    const kept = roles.filter((role) => role.kind !== "flag");
+    const positionals = kept.filter((role) => role.kind === "positional");
+    return kept.flatMap((role) => {
+        const place = placeOf(grammar, role, positionals.indexOf(role));
+        const { inline, kind } = place;
+        return kind === undefined
+            ? []
+            : [
+                {
+                    ...place,
+                    kind,
+                    reference: valueOf(tokens[role.index] ?? "", inline),
+                },
+            ];
+    });
+};
+const flagsOf = (arguments_) => new Set(arguments_.flatMap((argument) => argument.name.startsWith("--") && argument.value === undefined
+    ? [argument.name]
+    : []));
+const locate = (arguments_, tokens) => Effect.try({
+    catch: (error) => error instanceof CliArgumentError
+        ? error
+        : new CliArgumentError("The command arguments are invalid."),
+    try: () => {
+        const grammar = grammarOf(arguments_);
+        const valueOptions = new Set(grammar.options.keys());
+        const end = tokens.indexOf("--");
+        parseOptions(end === -1 ? tokens : tokens.slice(0, end), valueOptions, flagsOf(arguments_));
+        const roles = tokenizeArguments(tokens, valueOptions);
+        return {
+            given: new Set(roles.flatMap((role) => ("name" in role ? [role.name] : []))),
+            targets: targetsOf(grammar, tokens, roles),
+        };
+    },
+});
+const missingScope = (arguments_, given) => {
+    const scope = arguments_.find((argument) => argument.required === true &&
+        (argument.name === "--workspace" || argument.name === "--project"));
+    if (scope === undefined)
+        return undefined;
+    const group = scope.oneOf === undefined
+        ? [scope]
+        : arguments_.filter((argument) => argument.oneOf === scope.oneOf && argument.required === true);
+    return group.some((argument) => given.has(argument.name)) ? undefined : group;
+};
+const labelled = (id, label) => label === undefined ? id : `${id} (${cell(label)})`;
+const ambiguous = (argument, reference, result) => new CliArgumentError(`${reference === undefined ? `The default ${argument}` : `'${cell(reference)}'`} matches ${String(result.candidates.length)} ${NOUNS[result.kind]}s: ${result.candidates
+    .map((candidate) => labelled(candidate.id, candidate.label))
+    .join(", ")}. Pass ${argument} with a full ID.`);
+const foreignAnswer = () => new ReferenceRefused({
+    error: {
+        code: "internal_error",
+        message: "The Node resolved a reference to another kind of resource.",
+        retryable: false,
+    },
+});
+const ask = (call, parameters) => Effect.flatMap(call("reference.resolve", parameters), (result) => {
+    if (!result.ok)
+        return Effect.fail(new ReferenceRefused({ error: result.error }));
+    const answer = result.value;
+    const matches = answer.kind === parameters.kind &&
+        (answer.outcome === "ambiguous" ||
+            answer.id.startsWith(`${parameters.kind}_`));
+    return matches ? Effect.succeed(answer) : Effect.fail(foreignAnswer());
+});
+const resolution = (argument, result, reference) => ({
+    argument,
+    id: result.id,
+    kind: result.kind,
+    ...(result.label === undefined ? {} : { label: result.label }),
+    match: result.match,
+    ...(reference === undefined ? {} : { reference }),
+});
+const scoped = (kind, scope) => scope === undefined || (kind !== "session" && kind !== "workspace")
+    ? {}
+    : { projectId: scope };
+const answerFor = (call, state, parameters) => {
+    const key = JSON.stringify(parameters);
+    const known = state.answers.get(key);
+    if (known !== undefined)
+        return Effect.succeed({ answer: known, key });
+    if (state.answers.size >= MAX_REFERENCES)
+        return Effect.fail(new CliArgumentError(`A command resolves at most ${String(MAX_REFERENCES)} references.`));
+    return Effect.map(ask(call, parameters), (answer) => ({ answer, key }));
+};
+const rewrite = (state, target, id) => state.tokens.with(target.index, target.inline ? `${target.argument}=${id}` : id);
+const exact = (state, target) => ({
+    ...state,
+    resolutions: [
+        ...state.resolutions,
+        {
+            argument: target.argument,
+            id: target.reference,
+            kind: target.kind,
+            match: "id",
+        },
+    ],
+    ...(target.kind === "project" ? { scope: target.reference } : {}),
+});
+const accept = (state, target, found) => ({
+    ...state,
+    answers: new Map(state.answers).set(found.key, found.answer),
+    resolutions: [
+        ...state.resolutions,
+        resolution(target.argument, found.answer, target.reference),
+    ],
+    ...(target.kind === "project" ? { scope: found.answer.id } : {}),
+    tokens: rewrite(state, target, found.answer.id),
+});
+const resolveTarget = (call, state, target) => {
+    if (isExactId(target.kind, target.reference))
+        return Effect.succeed(exact(state, target));
+    const parameters = {
+        kind: target.kind,
+        reference: target.reference,
+        ...scoped(target.kind, state.scope),
+    };
+    return Effect.flatMap(answerFor(call, state, parameters), ({ answer, key }) => answer.outcome === "ambiguous"
+        ? Effect.fail(ambiguous(target.argument, target.reference, answer))
+        : Effect.succeed(accept(state, target, { answer, key })));
+};
+const resolveEach = (call, initial, targets) => Effect.reduce(targets, () => initial, (state, target) => resolveTarget(call, state, target));
+const noDefault = (group) => ({ error, }) => error.code === "resource_not_found"
+    ? Effect.fail(new CliArgumentError(`Pass ${group
+        .map((argument) => argument.name)
+        .filter((name) => SCOPE_NAMES.has(name))
+        .join(" or ")}: ${error.message}`))
+    : Effect.fail(new ReferenceRefused({ error }));
+const orElse = (first, second) => Effect.catchTag(first, "CliArgumentError", (missing) => Effect.catchTag(second, "CliArgumentError", () => Effect.fail(missing)));
+const resolveDefault = (call, group, path) => {
+    const names = new Set(group.map((argument) => argument.name));
+    const askDefault = (kind) => ask(call, { kind, ...(path === undefined ? {} : { path }) }).pipe(Effect.catchTag("ReferenceRefused", noDefault(group)));
+    const settle = (kind, result) => result.outcome === "resolved"
+        ? Effect.succeed(result)
+        : Effect.fail(ambiguous(`--${kind}`, undefined, result));
+    const project = Effect.flatMap(askDefault("project"), (result) => settle("project", result));
+    if (!names.has("--workspace"))
+        return project;
+    const workspace = Effect.flatMap(askDefault("workspace"), (result) => result.outcome === "ambiguous" && names.has("--project")
+        ? project
+        : settle("workspace", result));
+    return names.has("--project") ? orElse(workspace, project) : workspace;
+};
+const withDefault = (call, group, path) => {
+    return (state) => {
+        if (group === undefined)
+            return Effect.succeed(state);
+        return Effect.map(resolveDefault(call, group, path), (fallback) => {
+            const argument = `--${fallback.kind}`;
+            const end = state.tokens.indexOf("--");
+            const at = end === -1 ? state.tokens.length : end;
+            return {
+                ...state,
+                resolutions: [...state.resolutions, resolution(argument, fallback)],
+                scope: fallback.kind === "project" ? fallback.id : fallback.projectId,
+                tokens: state.tokens.toSpliced(at, 0, argument, fallback.id),
+            };
+        });
+    };
+};
+const SOURCES = {
+    id: "its ID",
+    name: "its name",
+    path: "the current folder",
+    prefix: "its ID prefix",
+    selection: "the selected Workspace",
+};
+export const describeResolution = (item) => `${item.argument}: ${labelled(item.id, item.label)} from ${SOURCES[item.match]}\n`;
+const plan = (group, path, targets) => ({
+    ...(group === undefined ? {} : { group }),
+    ...(path === undefined ? {} : { path }),
+    targets,
+});
+const resolveAll = (call, tokens, plan) => {
+    const initial = { answers: new Map(), resolutions: [], tokens };
+    const isProject = (target) => target.kind === "project";
+    return resolveEach(call, initial, plan.targets.filter(isProject)).pipe(Effect.flatMap(withDefault(call, plan.group, plan.path)), Effect.flatMap((state) => resolveEach(call, state, plan.targets.filter((target) => !isProject(target)))));
+};
+const unresolved = (tokens) => ({
+    answers: new Map(),
+    resolutions: [],
+    tokens,
+});
+const reported = (context) => ({ error }) => Effect.succeed({
+    exitCode: reportError(error, context),
+    ok: false,
+});
+const settled = ({ resolutions, tokens }) => ({
+    ok: true,
+    resolutions,
+    tokens,
+});
+export const resolveLeafArguments = ({ context, cwd, tokens, usage, }) => {
+    const { call } = context.dependencies;
+    if (call === undefined)
+        return Effect.succeed(settled(unresolved(tokens)));
+    const { args } = parseUsage(usage);
+    const path = context.node === undefined ? cwd : undefined;
+    return locate(args, tokens).pipe(Effect.flatMap(({ given, targets }) => given.has("--attached")
+        ? Effect.succeed(unresolved(tokens))
+        : resolveAll(call, tokens, plan(missingScope(args, given), path, targets))), Effect.map(settled), Effect.catchTag("ReferenceRefused", reported(context)));
+};
+export const prepareLeaf = (input) => Effect.map(resolveLeafArguments(input), (outcome) => {
+    if (!outcome.ok)
+        return outcome;
+    const changed = outcome.resolutions.filter((item) => item.match !== "id");
+    const { context } = input;
+    if (!context.json)
+        changed.forEach((item) => {
+            context.io.stderr(describeResolution(item));
+        });
+    return {
+        context: changed.length === 0 ? context : { ...context, resolved: changed },
+        ok: true,
+        tokens: outcome.tokens,
+    };
+});
+const currentFolder = () => {
+    try {
+        return process.cwd();
+    }
+    catch {
+        return undefined;
+    }
+};
+export const workingFolder = (cwd) => {
+    const folder = cwd ?? currentFolder();
+    return folder?.startsWith("/") === true ? folder : undefined;
+};
+//# sourceMappingURL=resolve.js.map

package/dist/reference/tree/index.d.ts

@@ -0,0 +1,2 @@
+export { REFERENCE_TREE } from "./tree.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/reference/tree/index.js

@@ -0,0 +1,2 @@
+export { REFERENCE_TREE } from "./tree.js";
+//# sourceMappingURL=index.js.map

package/dist/reference/tree/tree.d.ts

@@ -0,0 +1,3 @@
+import type { TreeFragment } from "../../command-tree/index.js";
+export declare const REFERENCE_TREE: TreeFragment;
+//# sourceMappingURL=tree.d.ts.map