@kosuke-ai/kosuke 1.0.7 → 1.0.9

package/dist/runtime/variants.js

@@ -0,0 +1,205 @@
+import { UsageError } from './invoke.js';
+/** The word that reaches a personal form. */
+export const PERSONAL = 'personal';
+export function scopeOf(form) {
+    return form.variant?.scope ?? 'workspace';
+}
+/** Descriptors grouped by command, in the order the first form of each appears. */
+export function formsOf(operations) {
+    const byCommand = new Map();
+    for (const operation of operations) {
+        const key = operation.command.join(' ');
+        byCommand.set(key, [...(byCommand.get(key) ?? []), operation]);
+    }
+    return byCommand;
+}
+/** What is left of a form's path params once the workspace positional took its place. */
+function restParams(form, hasScope) {
+    if (scopeOf(form) === 'workspace' && hasScope)
+        return form.pathParams.slice(1);
+    return form.pathParams;
+}
+function commonPrefix(lists) {
+    const [first = [], ...rest] = lists;
+    const prefix = [];
+    for (let i = 0; i < first.length; i++) {
+        if (rest.every((list) => list[i] === first[i]))
+            prefix.push(first[i]);
+        else
+            break;
+    }
+    return prefix;
+}
+export function leafShape(forms) {
+    const scopes = new Set(forms.map(scopeOf));
+    const hasScope = scopes.has('personal') || scopes.has('all');
+    const workspace = forms.find((form) => scopeOf(form) === 'workspace');
+    let scope = null;
+    if (hasScope) {
+        const name = workspace?.pathParams[0] ?? 'workspaceId';
+        const optional = scopes.has('all');
+        const words = [
+            ...(scopes.has('workspace') || !scopes.has('personal') ? [name] : []),
+            ...(scopes.has('personal') ? [PERSONAL] : []),
+        ].join('|');
+        scope = { name, label: optional ? `[${words}]` : `<${words}>`, optional };
+    }
+    const positionals = commonPrefix(forms.map((form) => restParams(form, hasScope)));
+    const flags = new Map();
+    const entry = (flag) => {
+        let found = flags.get(flag);
+        if (!found) {
+            found = { flag, forms: new Map(), uniform: true, selector: new Set() };
+            flags.set(flag, found);
+        }
+        return found;
+    };
+    for (const form of forms) {
+        const own = new Set();
+        for (const field of fieldsOf(form)) {
+            entry(field.flag).forms.set(form, field);
+            own.add(field.flag);
+        }
+        for (const name of restParams(form, hasScope).slice(positionals.length)) {
+            const flag = kebab(name);
+            if (own.has(flag)) {
+                throw new Error(`kosuke ${form.command.join(' ')}: path param ${name} and a field share --${flag}.`);
+            }
+            entry(flag).forms.set(form, { name, flag, kind: 'string', required: true, pathParam: true });
+        }
+        if (form.variant?.when)
+            entry(form.variant.when.flag).selector.add(scopeOf(form));
+    }
+    for (const leafFlag of flags.values()) {
+        const shapes = new Set([...leafFlag.forms.values()].map((field) => JSON.stringify([field.kind, field.choices ?? null, field.repeated ?? false])));
+        leafFlag.uniform = shapes.size <= 1 && leafFlag.selector.size === 0;
+    }
+    return { scope, positionals, flags: [...flags.values()] };
+}
+/** Query, then JSON body, then form fields, one per flag. */
+export function fieldsOf(form) {
+    const seen = new Set();
+    return [...form.query, ...(form.body?.fields ?? []), ...(form.multipart ?? [])].filter((field) => {
+        if (seen.has(field.flag))
+            return false;
+        seen.add(field.flag);
+        return true;
+    });
+}
+/** `kosuke crons get personal`, `kosuke providers usage get <workspaceId> --provider codex`. */
+export function formUsage(form, shape) {
+    const scope = scopeOf(form);
+    const first = !shape.scope
+        ? []
+        : scope === 'personal'
+            ? [PERSONAL]
+            : scope === 'all'
+                ? []
+                : [`<${shape.scope.name}>`];
+    return [
+        'kosuke',
+        ...form.command,
+        ...first,
+        ...shape.positionals.map((name) => `<${name}>`),
+        ...(form.variant?.when ? [`--${form.variant.when.flag} ${form.variant.when.equals}`] : []),
+    ].join(' ');
+}
+/** `the personal form`, `the --provider codex form`, `the workspace form`. */
+export function formLabel(form) {
+    const words = [
+        ...(form.variant?.scope ? [form.variant.scope] : []),
+        ...(form.variant?.when ? [`--${form.variant.when.flag} ${form.variant.when.equals}`] : []),
+    ];
+    return `the ${words.length ? words.join(' ') : 'workspace'} form`;
+}
+const WORKSPACE_ID = 'workspaceId';
+/**
+ * The form a call reaches, or a UsageError saying why none does. `reachable` is what
+ * the caller's key reaches: a form it does not is refused by name rather than as a
+ * form that does not exist.
+ */
+export function selectForm(forms, { first, flags }, reachable = () => true) {
+    const command = `kosuke ${forms[0].command.join(' ')}`;
+    const shape = leafShape(forms);
+    let scope = 'workspace';
+    if (shape.scope) {
+        if (first === PERSONAL)
+            scope = 'personal';
+        else if (first === undefined)
+            scope = 'all';
+    }
+    else if (first === PERSONAL && forms[0].pathParams[0] === WORKSPACE_ID) {
+        scope = 'personal';
+    }
+    const scoped = forms.filter((form) => scopeOf(form) === scope);
+    if (!scoped.length) {
+        if (scope === 'personal') {
+            throw new UsageError(`${command} has no personal form. Pass ${idHint(shape.scope?.name ?? WORKSPACE_ID)}.`);
+        }
+        if (scope === 'workspace' && forms.some((form) => scopeOf(form) === 'personal')) {
+            throw new UsageError(`${command} works on personal only. Pass personal.`);
+        }
+        throw new UsageError(`${command} needs ${idHint(shape.scope?.name ?? WORKSPACE_ID)}.`);
+    }
+    let form = scoped[0];
+    const selector = scoped[0].variant?.when?.flag;
+    if (selector) {
+        const value = flags[selector];
+        const match = scoped.find((candidate) => candidate.variant?.when?.equals === value);
+        if (!match) {
+            const values = scoped.map((candidate) => candidate.variant.when.equals);
+            throw new UsageError(`--${selector} must be one of ${values.join(', ')} for ${scopedUsage(command, scope, shape)}.`);
+        }
+        form = match;
+    }
+    if (!reachable(form)) {
+        throw new UsageError(`This key does not reach ${formLabel(form)} of ${command}.`);
+    }
+    for (const leafFlag of shape.flags) {
+        if (flags[leafFlag.flag] === undefined)
+            continue;
+        if (leafFlag.forms.has(form) || form.variant?.when?.flag === leafFlag.flag)
+            continue;
+        // A selector of another scope is not a flag of this form either.
+        throw new UsageError(`--${leafFlag.flag} is not a flag of ${formLabel(form)} of ${command}.`);
+    }
+    for (const leafFlag of shape.flags) {
+        const field = leafFlag.forms.get(form);
+        if (field?.pathParam && flags[leafFlag.flag] === undefined) {
+            throw new UsageError(`--${leafFlag.flag} is required.`);
+        }
+    }
+    return form;
+}
+function scopedUsage(command, scope, shape) {
+    if (!shape.scope || scope === 'all')
+        return command;
+    return `${command} ${scope === 'personal' ? PERSONAL : `<${shape.scope.name}>`}`;
+}
+/** The chosen form's path params: the workspace positional, the shared ones, then V3 flags. */
+export function pathParamsFor(form, shape, first, positionals, flags) {
+    const params = {};
+    const rest = [...form.pathParams];
+    if (shape.scope && scopeOf(form) === 'workspace')
+        params[rest.shift()] = first;
+    rest.forEach((name, index) => {
+        params[name] =
+            index < shape.positionals.length ? positionals[index] : String(flags[kebab(name)]);
+    });
+    return params;
+}
+/** `connectionId` reads as `connection-id`, the generator's own spelling of a flag. */
+function kebab(name) {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/_/g, '-')
+        .toLowerCase();
+}
+/** The id a scope positional takes, in words, with the command that lists them. */
+function idHint(name) {
+    if (name === 'projectId')
+        return 'a project id (kosuke projects list)';
+    if (name === WORKSPACE_ID)
+        return 'a workspace id (kosuke workspaces list)';
+    return `a ${name}`;
+}