monday-cli 0.2.0

package/dist/api/filters.js

@@ -0,0 +1,328 @@
+/**
+ * Filter DSL parser (`cli-design.md` §5.5, `v0.1-plan.md` §3 M4).
+ *
+ * Two surfaces, one for each `monday item list` knob:
+ *
+ *   - `--where <token><op><val>` (repeatable) → parsed against §5.5's
+ *     allowlist (`=`, `!=`, `~=`, `<`, `<=`, `>`, `>=`, `:is_empty`,
+ *     `:is_not_empty`) and emitted as a Monday `query_params.rules`
+ *     object. Multiple `--where` flags are AND'd. Token resolution
+ *     reuses the M3 column read-resolver (`api/columns.ts`) so the
+ *     same NFC + case-fold rules apply across read and write surfaces.
+ *
+ *   - `--filter-json <json>` is the literal Monday `query_params`
+ *     object — never re-parsed. Power users / agents needing OR /
+ *     nested groups / `within_last(7d)` use this. v0.1's `--where`
+ *     surface is intentionally narrow; `--filter-json` is the escape
+ *     hatch.
+ *
+ * `--where` and `--filter-json` are **mutually exclusive**. Combining
+ * them would either force a merge rule (extra contract surface) or
+ * silently let one win — both are worse than failing fast with a
+ * `usage_error` and asking the agent to pick.
+ *
+ * **Operator-in-title trap.** When a column title contains an
+ * operator (`Plan A=B`), the implicit-resolution path can't
+ * disambiguate — `--where Plan A=B=approved` splits on the *first*
+ * `=` per §5.3 step 2.b, so the token resolves as `Plan A` and the
+ * value is `B=approved`. This is documented behaviour, not a bug.
+ * The `title:`/`id:` prefix doesn't help here either — `parseWhereSyntax`
+ * splits on the first operator before `parseColumnTokenPrefix`
+ * sees the token, so `title:Plan A=B=approved` still cleaves at
+ * the first `=`. The supported escape hatch for operator-in-title
+ * columns is `--filter-json`, where the agent passes the literal
+ * Monday `query_params` JSON; the rule's `column_id` is unambiguous
+ * and the value carries through verbatim. Codex M4 pass-2 §4
+ * surfaced this as a documentation backfill item — logged in
+ * v0.1-plan.md §3 M4 spec-gaps. The unit suite asserts the
+ * documented split verbatim so a future "be clever about it"
+ * patch fails loudly.
+ *
+ * **`me` sugar.** Per §5.5 + §5.3, `--where owner=me` against a
+ * `people` column resolves through the directory cache to the
+ * current user's ID. The resolution is a separate `whoami` query
+ * the parser issues on demand; tests inject a stub via the
+ * `resolveMe` callback so the pure-syntax layer stays
+ * unit-testable.
+ *
+ * **Result-type meta surface (§14 M3 prophylactic).** Even though
+ * filter parsing produces no network-derived data of its own
+ * (resolution is delegated to columns.ts + a `me`-resolver
+ * callback), the result type carries `warnings` from day one. The
+ * meta-source / cache-age / complexity slots travel through the
+ * board-metadata loader the caller has already opened — surfacing
+ * them again here would be redundant.
+ */
+import { z } from 'zod';
+import { ApiError, UsageError } from '../utils/errors.js';
+import { resolveColumnsAcrossClauses } from './columns.js';
+import { isMeToken } from './me-token.js';
+const OPERATORS_BINARY = [
+    // Two-character operators must come before their one-character
+    // prefixes so the position-by-position scan picks the longest
+    // match at any given index.
+    { kind: 'lower_than_or_equals', literal: '<=', arity: 'binary' },
+    { kind: 'greater_than_or_equals', literal: '>=', arity: 'binary' },
+    { kind: 'not_equals', literal: '!=', arity: 'binary' },
+    { kind: 'contains_text', literal: '~=', arity: 'binary' },
+    { kind: 'lower_than', literal: '<', arity: 'binary' },
+    { kind: 'greater_than', literal: '>', arity: 'binary' },
+    { kind: 'equals', literal: '=', arity: 'binary' },
+];
+/**
+ * Maps the AST kind to the Monday `query_params` operator name.
+ * Frozen so a future import can't mutate the table mid-process.
+ */
+const MONDAY_OPERATOR_NAME = Object.freeze({
+    equals: 'any_of',
+    not_equals: 'not_any_of',
+    contains_text: 'contains_text',
+    lower_than: 'lower_than',
+    lower_than_or_equals: 'lower_than_or_equals',
+    greater_than: 'greater_than',
+    greater_than_or_equals: 'greater_than_or_equals',
+    is_empty: 'is_empty',
+    is_not_empty: 'is_not_empty',
+});
+/**
+ * Splits one raw `--where` argument into a {@link WhereClause}.
+ *
+ * Algorithm (left-to-right, longest-match-at-position):
+ *
+ *  1. Match `:is_not_empty` / `:is_empty` suffix on the right (with
+ *     `:is_not_empty` checked first so it doesn't get truncated to
+ *     the shorter form).
+ *  2. Otherwise scan position-by-position from index 1 (token must
+ *     be non-empty), trying each binary operator at that position.
+ *     The first match wins — earliest-leftmost-with-longest-tie-break.
+ *  3. If no operator is found, raise `UsageError`.
+ *
+ * Per §5.3 step 2.b, the split happens on the *first* operator
+ * occurrence — a column title containing an operator (`Plan A=B`)
+ * needs the explicit `title:` prefix or `--filter-json` to round-trip.
+ */
+export const parseWhereSyntax = (raw) => {
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) {
+        throw new UsageError(`--where: empty filter clause`, { details: { clause: raw } });
+    }
+    // Step 1: unary `:is_empty` / `:is_not_empty` suffix. Order matters
+    // so the longer literal binds first.
+    const unarySuffixes = [
+        { suffix: ':is_not_empty', kind: 'is_not_empty' },
+        { suffix: ':is_empty', kind: 'is_empty' },
+    ];
+    for (const u of unarySuffixes) {
+        if (trimmed.endsWith(u.suffix)) {
+            const tokenPart = trimmed.slice(0, trimmed.length - u.suffix.length);
+            if (tokenPart.length === 0) {
+                throw new UsageError(`--where: missing column token before ${u.suffix}`, { details: { clause: raw } });
+            }
+            return {
+                token: tokenPart,
+                operator: { kind: u.kind, literal: u.suffix.slice(1), arity: 'unary' },
+                value: undefined,
+                raw,
+            };
+        }
+    }
+    // Step 2: scan left-to-right from index 1 (a leading operator
+    // would mean an empty token, rejected). At each index, prefer the
+    // longest matching operator literal.
+    for (let i = 1; i < trimmed.length; i++) {
+        for (const op of OPERATORS_BINARY) {
+            if (trimmed.startsWith(op.literal, i)) {
+                const token = trimmed.slice(0, i);
+                const value = trimmed.slice(i + op.literal.length);
+                // Token mustn't end with whitespace + operator-only — but a
+                // non-empty token + non-empty value is always valid. Empty
+                // value (`status=`) is technically allowed by §5.5 but
+                // pragmatically meaningless; reject so agents notice.
+                if (value.length === 0) {
+                    throw new UsageError(`--where: missing value after ${op.literal} (use ${op.literal}'<value>')`, { details: { clause: raw, operator: op.literal } });
+                }
+                return { token, operator: op, value, raw };
+            }
+        }
+    }
+    throw new UsageError(`--where: no recognised operator in ${JSON.stringify(raw)}; ` +
+        `expected one of =, !=, ~=, <, <=, >, >=, :is_empty, :is_not_empty`, { details: { clause: raw } });
+};
+/**
+ * Resolves each parsed `WhereClause` against the board metadata and
+ * emits the Monday `query_params` payload. Empty `clauses` →
+ * `queryParams: undefined` (caller omits the variable from the
+ * GraphQL request). Multiple clauses are AND'd by Monday's default
+ * rule-array semantics — no nested groups in v0.1.
+ *
+ * Throws `ApiError` (`column_not_found` / `ambiguous_column`) when
+ * column resolution fails — same shape `--set` will surface in M5b
+ * so agents key off the same code regardless of the read vs write
+ * channel.
+ */
+export const buildFilterRules = async (inputs) => {
+    if (inputs.clauses.length === 0) {
+        return { queryParams: undefined, warnings: [], refreshed: false };
+    }
+    let cachedMe;
+    const me = async () => {
+        cachedMe ??= await inputs.resolveMe();
+        return cachedMe;
+    };
+    // R12 lift: cache-miss-refresh + collision-warning collection are
+    // shared with `commands/item/search.ts buildColumnQueries`. The
+    // helper resolves every clause's column token; per-clause value
+    // resolution (`me` for people, etc.) stays here.
+    const resolved = await resolveColumnsAcrossClauses({
+        metadata: inputs.metadata,
+        tokens: inputs.clauses.map((c) => c.token),
+        ...(inputs.onColumnNotFound === undefined
+            ? {}
+            : { onColumnNotFound: inputs.onColumnNotFound }),
+    });
+    const rules = [];
+    for (let i = 0; i < inputs.clauses.length; i++) {
+        const clause = inputs.clauses[i];
+        const match = resolved.matches[i];
+        /* c8 ignore next 6 — defensive: matches.length === clauses.length
+           by helper contract; the index guard exists for
+           noUncheckedIndexedAccess narrowing only. */
+        if (clause === undefined || match === undefined) {
+            throw new ApiError('internal_error', `buildFilterRules: lost clause/match alignment at index ${String(i)}`);
+        }
+        const rule = await buildRuleForClause(clause, match.column, me);
+        rules.push(rule);
+    }
+    // ResolverWarning is structurally compatible with envelope.Warning
+    // (narrower `code` literal, required `details`), so the assignment
+    // widens cleanly without a cast. Same shape `commands/item/search.ts`
+    // uses post-R12 for the same reason.
+    return {
+        queryParams: { rules },
+        warnings: resolved.warnings,
+        refreshed: resolved.refreshed,
+    };
+};
+const buildRuleForClause = async (clause, column, resolveMe) => {
+    const operator = clause.operator;
+    if (operator.arity === 'unary') {
+        return {
+            column_id: column.id,
+            operator: MONDAY_OPERATOR_NAME[operator.kind],
+        };
+    }
+    // Binary operator — extract value, resolve `me` if applicable.
+    /* c8 ignore next 7 — defensive guard. The parser's output shape
+       guarantees `value` is defined whenever `arity: 'binary'`; the
+       check exists for type narrowing under
+       `noUncheckedIndexedAccess` / `exactOptionalPropertyTypes`. */
+    if (clause.value === undefined) {
+        throw new ApiError('internal_error', `binary operator ${operator.literal} produced no value during build`);
+    }
+    const compareValue = await resolveCompareValue(clause.value, column, operator, resolveMe);
+    return {
+        column_id: column.id,
+        operator: MONDAY_OPERATOR_NAME[operator.kind],
+        compare_value: compareValue,
+    };
+};
+const resolveCompareValue = async (rawValue, column, operator, resolveMe) => {
+    // `me` sugar resolves only on people-style columns. Other types
+    // pass through verbatim so a stray `me` against a text column
+    // surfaces as Monday's validation_failed rather than a silent
+    // identity swap.
+    //
+    // `isMeToken` is the shared (`api/me-token.ts`, R15) recogniser
+    // used by all three `me`-aware surfaces — `--where Owner=me`
+    // here, `item search --where Owner=me` in commands/item/search.ts,
+    // and `--set Owner=me` in api/people.ts. One rule across read
+    // filters and `--set` writes per cli-design §5.3 step 3 line
+    // 704-707. cli-design doesn't pin case-sensitivity explicitly;
+    // the people-session Codex passes settled on case-insensitive
+    // (logged as a v0.1-plan §3 M5a spec gap for backfill).
+    if (column.type === 'people' && isMeToken(rawValue)) {
+        const id = await resolveMe();
+        return wrapForOperator([id], operator);
+    }
+    // contains_text takes a bare string. Everything else takes an
+    // array (any_of / not_any_of) or a scalar (lt/gt/le/ge — number
+    // or date string). For v0.1 we pass strings as-is and let Monday
+    // coerce; Monday accepts both string and number for numeric
+    // columns when the value parses as a number.
+    return wrapForOperator(rawValue, operator);
+};
+const wrapForOperator = (value, operator) => {
+    switch (operator.kind) {
+        case 'equals':
+        case 'not_equals':
+            return Array.isArray(value) ? value : [value];
+        case 'contains_text':
+            return Array.isArray(value) ? value[0] : value;
+        case 'lower_than':
+        case 'lower_than_or_equals':
+        case 'greater_than':
+        case 'greater_than_or_equals':
+            return Array.isArray(value) ? value[0] : value;
+        /* c8 ignore start — unary kinds never reach this helper; the
+           caller only invokes wrapForOperator for binary operators. */
+        case 'is_empty':
+        case 'is_not_empty':
+            return undefined;
+        /* c8 ignore stop */
+    }
+};
+const filterJsonSchema = z.object({}).loose();
+/**
+ * Validates a raw `--filter-json` string into a `query_params`-shaped
+ * object. Per §5.5, the payload is "never parsed; passed through as
+ * the GraphQL var" — the JSON.parse here is just a syntax check so a
+ * malformed input produces `usage_error` instead of a server-side
+ * parse error. Field-level shape validation stays on Monday's side.
+ */
+export const parseFilterJson = (raw) => {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        throw new UsageError(`--filter-json: input is not valid JSON`, { details: { input: raw }, cause: err });
+    }
+    const result = filterJsonSchema.safeParse(parsed);
+    if (!result.success) {
+        throw new UsageError(`--filter-json: expected a JSON object`, { details: { input: raw } });
+    }
+    return result.data;
+};
+export const buildQueryParams = async (inputs) => {
+    const hasWhere = inputs.whereClauses.length > 0;
+    const filterJson = inputs.filterJson;
+    const hasFilterJson = filterJson !== undefined && filterJson.length > 0;
+    if (hasWhere && hasFilterJson) {
+        throw new UsageError('--where and --filter-json are mutually exclusive; pick one');
+    }
+    if (hasFilterJson) {
+        return {
+            queryParams: parseFilterJson(filterJson),
+            warnings: [],
+            refreshed: false,
+        };
+    }
+    if (!hasWhere) {
+        return { queryParams: undefined, warnings: [], refreshed: false };
+    }
+    const clauses = inputs.whereClauses.map(parseWhereSyntax);
+    const result = await buildFilterRules({
+        metadata: inputs.metadata,
+        resolveMe: inputs.resolveMe,
+        clauses,
+        ...(inputs.onColumnNotFound === undefined
+            ? {}
+            : { onColumnNotFound: inputs.onColumnNotFound }),
+    });
+    return {
+        queryParams: result.queryParams,
+        warnings: result.warnings,
+        refreshed: result.refreshed,
+    };
+};
+//# sourceMappingURL=filters.js.map

package/dist/api/filters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filters.js","sourceRoot":"","sources":["../../src/api/filters.ts"],"names":[],"mappings":"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"}

package/dist/api/group-color.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Monday-supported group colour palette (M17 implementation-owned
+ * field set per cli-design §4.3 group-create + group-update).
+ *
+ * Monday's `create_group(group_color)` and `update_group(group_
+ * attribute: color, new_value)` accept plain `String` on the wire
+ * (the SDK 14.0.0 `MutationCreate_GroupArgs.group_color: String?`
+ * type is unstructured); the accepted-values list lives in Monday's
+ * public API help center, not in the SDK's typed surface, and
+ * evolves over time.
+ *
+ * This module owns the v0.2 field set. The cli-design contract
+ * pins the SHAPE (argv-parse validation against the M17
+ * implementation-owned set); pinning specific values inline in the
+ * contract would force docs revisions every time Monday tweaks
+ * the palette. Same rationale as M16 column-create's per-type
+ * `--settings` field-set ownership in `column-types.ts`.
+ *
+ * **What's here**: the union of Monday's documented group colours
+ * across both the API help center and the working `update_group`
+ * payloads observed in the SDK 14.0.0 test fixtures. When Monday
+ * adds a colour, agents either patch this list (SemVer-minor) or
+ * fall back to `dev mutate` until the next release.
+ *
+ * **Why two consumers** (group-create + group-update): both verbs
+ * share the argv-parse validation layer. Sharing the constant
+ * means an agent that successfully sets a colour via group-create
+ * can rely on it round-tripping through group-update without
+ * surprise rejections, and vice versa.
+ */
+export declare const GROUP_COLOR_VALUES: readonly ["dark-red", "red", "stuck-red", "sofia-pink", "lipstick", "berry", "dark-orange", "orange", "working-orange", "peachy", "sunset", "sun-yellow", "yellow", "dark-yellow", "gold", "lime-green", "grass-green", "done-green", "dark-green", "sea-foam", "teal", "turqouise", "sky", "light-blue", "bright-blue", "blue", "dark-blue", "royal", "indigo", "dark-indigo", "navy", "purple", "dark-purple", "lavender", "dark-pink", "pink", "brown", "pecan", "tan", "american-gray", "gray-gray", "blackish"];
+export type GroupColor = (typeof GROUP_COLOR_VALUES)[number];
+//# sourceMappingURL=group-color.d.ts.map

package/dist/api/group-color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"group-color.d.ts","sourceRoot":"","sources":["../../src/api/group-color.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,eAAO,MAAM,kBAAkB,sfAgDrB,CAAC;AAEX,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAC"}

package/dist/api/group-color.js

@@ -0,0 +1,80 @@
+/**
+ * Monday-supported group colour palette (M17 implementation-owned
+ * field set per cli-design §4.3 group-create + group-update).
+ *
+ * Monday's `create_group(group_color)` and `update_group(group_
+ * attribute: color, new_value)` accept plain `String` on the wire
+ * (the SDK 14.0.0 `MutationCreate_GroupArgs.group_color: String?`
+ * type is unstructured); the accepted-values list lives in Monday's
+ * public API help center, not in the SDK's typed surface, and
+ * evolves over time.
+ *
+ * This module owns the v0.2 field set. The cli-design contract
+ * pins the SHAPE (argv-parse validation against the M17
+ * implementation-owned set); pinning specific values inline in the
+ * contract would force docs revisions every time Monday tweaks
+ * the palette. Same rationale as M16 column-create's per-type
+ * `--settings` field-set ownership in `column-types.ts`.
+ *
+ * **What's here**: the union of Monday's documented group colours
+ * across both the API help center and the working `update_group`
+ * payloads observed in the SDK 14.0.0 test fixtures. When Monday
+ * adds a colour, agents either patch this list (SemVer-minor) or
+ * fall back to `dev mutate` until the next release.
+ *
+ * **Why two consumers** (group-create + group-update): both verbs
+ * share the argv-parse validation layer. Sharing the constant
+ * means an agent that successfully sets a colour via group-create
+ * can rely on it round-tripping through group-update without
+ * surprise rejections, and vice versa.
+ */
+export const GROUP_COLOR_VALUES = [
+    // Reds + warm
+    'dark-red',
+    'red',
+    'stuck-red',
+    'sofia-pink',
+    'lipstick',
+    'berry',
+    'dark-orange',
+    'orange',
+    'working-orange',
+    'peachy',
+    'sunset',
+    'sun-yellow',
+    'yellow',
+    'dark-yellow',
+    'gold',
+    // Greens
+    'lime-green',
+    'grass-green',
+    'done-green',
+    'dark-green',
+    'sea-foam',
+    'teal',
+    // Blues + indigos
+    'turqouise',
+    'sky',
+    'light-blue',
+    'bright-blue',
+    'blue',
+    'dark-blue',
+    'royal',
+    'indigo',
+    'dark-indigo',
+    'navy',
+    // Purples + pinks
+    'purple',
+    'dark-purple',
+    'lavender',
+    'dark-pink',
+    'pink',
+    // Earth + neutrals
+    'brown',
+    'pecan',
+    'tan',
+    'american-gray',
+    'gray-gray',
+    'blackish',
+];
+//# sourceMappingURL=group-color.js.map

package/dist/api/group-color.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"group-color.js","sourceRoot":"","sources":["../../src/api/group-color.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,cAAc;IACd,UAAU;IACV,KAAK;IACL,WAAW;IACX,YAAY;IACZ,UAAU;IACV,OAAO;IACP,aAAa;IACb,QAAQ;IACR,gBAAgB;IAChB,QAAQ;IACR,QAAQ;IACR,YAAY;IACZ,QAAQ;IACR,aAAa;IACb,MAAM;IACN,SAAS;IACT,YAAY;IACZ,aAAa;IACb,YAAY;IACZ,YAAY;IACZ,UAAU;IACV,MAAM;IACN,kBAAkB;IAClB,WAAW;IACX,KAAK;IACL,YAAY;IACZ,aAAa;IACb,MAAM;IACN,WAAW;IACX,OAAO;IACP,QAAQ;IACR,aAAa;IACb,MAAM;IACN,kBAAkB;IAClB,QAAQ;IACR,aAAa;IACb,UAAU;IACV,WAAW;IACX,MAAM;IACN,mBAAmB;IACnB,OAAO;IACP,OAAO;IACP,KAAK;IACL,eAAe;IACf,WAAW;IACX,UAAU;CACF,CAAC"}

package/dist/api/group-mutation-result.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Live-mutation null-result projection for the M17 group lifecycle
+ * cluster (`v0.2-plan.md` §22 R48 lift).
+ *
+ * Five M17 verbs share a near-verbatim shape: null-check the wire
+ * payload, throw a typed ApiError on null carrying both
+ * `details.board_id` and `details.group_id` (the group-mutation
+ * wire signature is two-tuple — `create_group` carries `board_id`
+ * only pre-id, but the read-side projection always pairs the two),
+ * then parse through `groupProjectionSchema` to surface the §6.4
+ * mutation envelope's `data: <projected snapshot>`.
+ *
+ * Lifted alongside the first M17 group verb commit (mirroring R45's
+ * "ship the projection helper alongside the first new mutation
+ * rather than as a follow-up R-class" precedent — same precedent
+ * R39 originally established). The five M17 verbs land in the same
+ * milestone, so adopting the helper from day one avoids five
+ * parallel inline implementations of the same shape. cf. R28
+ * (`projectMutationItem`), R37 (`projectMutationUpdate`), R43
+ * (`projectMutationBoard`), R45 (`projectMutationColumn`); R48
+ * ships the fifth per-noun helper at the firmest 5-consumer trigger
+ * any projection-helper lift has had to date (R39 fired at 3, R45
+ * at 3, R48 at 5).
+ *
+ * **Why parameterised on `errorCode` + `errorMessage`.** Like
+ * R28 / R37 / R43 / R45, the M17 verbs diverge in error semantics:
+ *   - `group-create` chose `internal_error` (every successful call
+ *     returns a Group — a null payload means Monday glitched
+ *     server-side, abnormal); the `details` carry `board_id` +
+ *     `name` (no group_id yet).
+ *   - `group-update`, `group-archive`, `group-duplicate`,
+ *     `group-delete` chose `not_found` (Monday's idiomatic null-
+ *     for-missing-or-no-access response — a typed agent-recovery
+ *     story); all four carry `board_id` + `group_id`.
+ * The helper owns the boilerplate (null check, `details: {board_id,
+ * [idKey]: idValue}` envelope, the `unwrapOrThrow` schema parse);
+ * each call site supplies its own typed error parts.
+ *
+ * **`GROUP_FIELDS_FRAGMENT` + `groupProjectionSchema` co-ship.**
+ * Mirrors R39's `WORKSPACE_FIELDS_FRAGMENT` + `workspaceProjection
+ * Schema`, R43's `BOARD_FIELDS_FRAGMENT` + `boardProjectionSchema`,
+ * and R45's `COLUMN_FIELDS_FRAGMENT` + `columnProjectionSchema`
+ * patterns. The schema mirrors the `groupSchema` already in
+ * `src/api/board-metadata.ts` (the read-side cache projection) but
+ * exists as an exported strict projection schema so M17's five
+ * mutation verbs share one source of truth for the on-the-wire
+ * Group shape. The field set covers the full Group metadata —
+ * every Group field except `items_page`, which is the group's
+ * items rather than group metadata and is out of scope for the
+ * mutation envelope's `data` slot (M17 pre-flight load-bearing
+ * finding).
+ *
+ * **What stays at the call site.** The wire-shape parse of the full
+ * mutation response (`responseSchema.safeParse(response.data)`)
+ * stays inline because each verb's response root key (`create_
+ * group` / `update_group` / `archive_group` / `duplicate_group` /
+ * `delete_group`) is per-verb. The missing-root-key check (schema-
+ * drift → `internal_error` with a `hint`) stays inline too —
+ * that's Codex M15 implementation round-2 F1's distinction between
+ * schema-drift and null-payload, deliberately preserved at each
+ * site. R42 would unify the missing-root-key check across all
+ * pre-M14 mutation verbs once scheduled.
+ */
+import { z } from 'zod';
+import { type ErrorCode } from '../utils/errors.js';
+/**
+ * Shared GraphQL selection set for the M17 group projection. 6-space
+ * continuation indent matches the column every consumer interpolates
+ * `${GROUP_FIELDS_FRAGMENT}` at, so rendered query bytes stay stable
+ * across consumers. Mirrors `BOARD_FIELDS_FRAGMENT` (R43),
+ * `WORKSPACE_FIELDS_FRAGMENT` (R39), and `COLUMN_FIELDS_FRAGMENT`
+ * (R45).
+ *
+ * Field set tracks `boardMetadataSchema.groups[*]` (the read-side
+ * cache projection) so a `board describe` after a successful group
+ * mutation returns the same JSON shape the mutation envelope did.
+ * `items_page` is deliberately excluded — that's the group's items,
+ * not group metadata, and is out of scope for the mutation
+ * envelope's `data` slot.
+ */
+export declare const GROUP_FIELDS_FRAGMENT = "id\n      title\n      color\n      position\n      archived\n      deleted";
+/**
+ * Strict zod schema for the group projection — the exact shape
+ * `GROUP_FIELDS_FRAGMENT` selects from the wire. Shared by all
+ * five M17 group verbs; each verb's `CommandModule.outputSchema`
+ * aliases this so the schema-export pipeline emits one canonical
+ * shape.
+ *
+ * Mirrors `boardMetadataSchema.groups[*]` in `board-metadata.ts`
+ * verbatim — same fields, same nullability — so a `board describe`
+ * after a successful group mutation reads the same JSON shape the
+ * mutation envelope wrote.
+ */
+export declare const groupProjectionSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    color: z.ZodNullable<z.ZodString>;
+    position: z.ZodNullable<z.ZodString>;
+    archived: z.ZodNullable<z.ZodBoolean>;
+    deleted: z.ZodNullable<z.ZodBoolean>;
+}, z.core.$strict>;
+export type GroupProjection = z.infer<typeof groupProjectionSchema>;
+/**
+ * Group-mutation detail key — varies between create (`name` echo,
+ * since the new group id doesn't exist pre-call) and update /
+ * archive / duplicate / delete (`group_id`, since all four operate
+ * on an existing group). All M17 verbs additionally echo `board_id`
+ * because the group-mutation wire signature is two-tuple.
+ */
+export type GroupMutationDetailKey = 'group_id' | 'name';
+export interface ProjectMutationGroupInputs {
+    readonly raw: unknown;
+    readonly errorCode: ErrorCode;
+    /**
+     * Full caller-formatted message for the null-payload throw —
+     * e.g. `"Monday returned no group payload from delete_group for
+     * board 12345 group topics"`. Per-verb phrasing is preserved
+     * verbatim because agents key off the message text in error
+     * logs.
+     */
+    readonly errorMessage: string;
+    readonly boardId: string;
+    /**
+     * Whether the call site identifies the group by its already-
+     * known id (`group_id`, used by update / archive / duplicate /
+     * delete) or by the agent-supplied name (`name`, used by create
+     * — no id exists pre-call). The helper keys `details.<idKey>`
+     * accordingly so agents key off the right field without having
+     * to switch on the verb.
+     */
+    readonly idKey: GroupMutationDetailKey;
+    readonly idValue: string;
+}
+/**
+ * Parses + projects a live-mutation `Group` payload, throwing the
+ * supplied typed error on null/undefined. Caller owns the error
+ * code + message so create's `internal_error` / "no group payload
+ * from create_group for board <X> name <Y>" and update's /
+ * archive's / duplicate's / delete's `not_found` / "no group
+ * payload from <op> for board <X> group <Y>" all survive the lift
+ * byte-for-byte.
+ *
+ * `details: { board_id, [idKey]: idValue }` is supplied by the
+ * helper so every consumer carries the same envelope shape —
+ * agents key off `details.board_id` + `details.group_id` (or
+ * `details.name` on create's pre-id path) regardless of which verb
+ * threw (cli-design §6.5).
+ */
+export declare const projectMutationGroup: ({ raw, errorCode, errorMessage, boardId, idKey, idValue, }: ProjectMutationGroupInputs) => GroupProjection;
+//# sourceMappingURL=group-mutation-result.d.ts.map

package/dist/api/group-mutation-result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"group-mutation-result.d.ts","sourceRoot":"","sources":["../../src/api/group-mutation-result.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAY,KAAK,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAG9D;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,qBAAqB,gFAKpB,CAAC;AAEf;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qBAAqB;;;;;;;kBASvB,CAAC;AAEZ,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE;;;;;;GAMG;AACH,MAAM,MAAM,sBAAsB,GAAG,UAAU,GAAG,MAAM,CAAC;AAEzD,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B;;;;;;OAMG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;;;;;;;OAOG;IACH,QAAQ,CAAC,KAAK,EAAE,sBAAsB,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,oBAAoB,GAAI,4DAOlC,0BAA0B,KAAG,eAgB/B,CAAC"}