monday-cli 0.4.0 → 0.6.0

package/dist/commands/doc/delete.d.ts

@@ -0,0 +1,68 @@
+/**
+ * `monday doc delete <doc-id> --yes [--dry-run]` — delete an
+ * existing workdoc (`cli-design.md` §4.3 DOC section + §13 v0.5
+ * entry; `v0.5-plan.md` §3 M35 + §8 D7-D9).
+ *
+ * **Confirmation gate** (cli-design §3.1 #7 + §10.2 + M10 round-1
+ * P2 invariant). `--yes` is mandatory for the live path; without
+ * `--yes` (and without `--dry-run`) the command fails fast with
+ * `confirmation_required` (exit 1) carrying `details.doc_id`. The
+ * gate fires BEFORE `resolveClient()` so a missing token doesn't
+ * mask `confirmation_required` as `config_error` (same shape — and
+ * same gate-before-resolve ordering — as M14 `workspace delete` /
+ * M10 `item delete` / `update delete` / `team delete`).
+ *
+ * **Wire shape.** Single round-trip via `delete_doc(docId)` against
+ * `mutation DeleteDoc` with `operationName: 'DeleteDoc'`
+ * (R-NEW-37 W2 audit-point). Returns Monday's opaque `JSON` scalar
+ * — the fetcher projects to the flat `{ doc_id: <echoed>,
+ * success: true }` envelope per D9. A null `delete_doc` payload
+ * surfaces `not_found` — same cadence as M14 `workspace delete`
+ * + M34 `team delete` (id bogus or doc already deleted by a
+ * concurrent caller).
+ *
+ * **camelCase wire-arg note.** `delete_doc` takes camelCase
+ * `docId` on the wire (Finding 7) — see the canonical
+ * asymmetry note at `src/api/documents.ts` module header (4th
+ * supporting site for R-NEW-41).
+ *
+ * **Argv shape.**
+ *
+ *   - `<doc-id>` — required positional (Monday's
+ *     `delete_doc.docId` is `ID!`). Brand-validated via
+ *     {@link DocIdSchema}.
+ *
+ * **Output envelope.** Projected from Monday's opaque JSON return
+ * per D9 — `data: { doc_id: <echoed>, success: true }`. Envelope
+ * shape is intentionally narrower than M34 `team-delete`'s "full
+ * deleted Team" projection: Monday's `delete_doc` doesn't return
+ * the deleted Document (the wire return is opaque JSON), and the
+ * agent contract doesn't gain from speculatively rehydrating the
+ * doc on the way out.
+ *
+ * **Dry-run shape** per cli-design §6.4 mutation-dry-run variant:
+ * minimal `{operation: "delete_doc", doc_id}`. No preflight read
+ * fires; the dry-run is purely argv-derived. `meta.source: 'none'`.
+ * Mirrors `workspace delete` / `team delete` — destructive-no-read
+ * pattern is uniform across destructive verbs.
+ *
+ * **Idempotent: false.** Re-running surfaces `not_found` past the
+ * first call. Same rationale as `workspace delete` / `team delete`
+ * — agents can't safely retry without verifying the id still
+ * names the same record.
+ *
+ * **Runtime body landed at v0.5-M35 IMPL.** Destructive gate fires
+ * BEFORE `resolveClient` (M10 round-1 P2 invariant); dry-run path
+ * emits minimal `{operation: "delete_doc", doc_id}` (no wire call);
+ * live path dispatches {@link deleteDoc} + projects via
+ * `emitMutation`.
+ */
+import { z } from 'zod';
+import { type CommandModule } from '../types.js';
+import { type DocDeleteOutput } from '../../api/documents.js';
+declare const inputSchema: z.ZodObject<{
+    docId: z.core.$ZodBranded<z.ZodString, "DocId", "out">;
+}, z.core.$strict>;
+export declare const docDeleteCommand: CommandModule<z.infer<typeof inputSchema>, DocDeleteOutput>;
+export {};
+//# sourceMappingURL=delete.d.ts.map

package/dist/commands/doc/delete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["../../../src/commands/doc/delete.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAoB,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAOnE,OAAO,EAGL,KAAK,eAAe,EACrB,MAAM,wBAAwB,CAAC;AAEhC,QAAA,MAAM,WAAW;;kBAA4C,CAAC;AAE9D,eAAO,MAAM,gBAAgB,EAAE,aAAa,CAC1C,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,EAC3B,eAAe,CAmFhB,CAAC"}

package/dist/commands/doc/delete.js

@@ -0,0 +1,146 @@
+/**
+ * `monday doc delete <doc-id> --yes [--dry-run]` — delete an
+ * existing workdoc (`cli-design.md` §4.3 DOC section + §13 v0.5
+ * entry; `v0.5-plan.md` §3 M35 + §8 D7-D9).
+ *
+ * **Confirmation gate** (cli-design §3.1 #7 + §10.2 + M10 round-1
+ * P2 invariant). `--yes` is mandatory for the live path; without
+ * `--yes` (and without `--dry-run`) the command fails fast with
+ * `confirmation_required` (exit 1) carrying `details.doc_id`. The
+ * gate fires BEFORE `resolveClient()` so a missing token doesn't
+ * mask `confirmation_required` as `config_error` (same shape — and
+ * same gate-before-resolve ordering — as M14 `workspace delete` /
+ * M10 `item delete` / `update delete` / `team delete`).
+ *
+ * **Wire shape.** Single round-trip via `delete_doc(docId)` against
+ * `mutation DeleteDoc` with `operationName: 'DeleteDoc'`
+ * (R-NEW-37 W2 audit-point). Returns Monday's opaque `JSON` scalar
+ * — the fetcher projects to the flat `{ doc_id: <echoed>,
+ * success: true }` envelope per D9. A null `delete_doc` payload
+ * surfaces `not_found` — same cadence as M14 `workspace delete`
+ * + M34 `team delete` (id bogus or doc already deleted by a
+ * concurrent caller).
+ *
+ * **camelCase wire-arg note.** `delete_doc` takes camelCase
+ * `docId` on the wire (Finding 7) — see the canonical
+ * asymmetry note at `src/api/documents.ts` module header (4th
+ * supporting site for R-NEW-41).
+ *
+ * **Argv shape.**
+ *
+ *   - `<doc-id>` — required positional (Monday's
+ *     `delete_doc.docId` is `ID!`). Brand-validated via
+ *     {@link DocIdSchema}.
+ *
+ * **Output envelope.** Projected from Monday's opaque JSON return
+ * per D9 — `data: { doc_id: <echoed>, success: true }`. Envelope
+ * shape is intentionally narrower than M34 `team-delete`'s "full
+ * deleted Team" projection: Monday's `delete_doc` doesn't return
+ * the deleted Document (the wire return is opaque JSON), and the
+ * agent contract doesn't gain from speculatively rehydrating the
+ * doc on the way out.
+ *
+ * **Dry-run shape** per cli-design §6.4 mutation-dry-run variant:
+ * minimal `{operation: "delete_doc", doc_id}`. No preflight read
+ * fires; the dry-run is purely argv-derived. `meta.source: 'none'`.
+ * Mirrors `workspace delete` / `team delete` — destructive-no-read
+ * pattern is uniform across destructive verbs.
+ *
+ * **Idempotent: false.** Re-running surfaces `not_found` past the
+ * first call. Same rationale as `workspace delete` / `team delete`
+ * — agents can't safely retry without verifying the id still
+ * names the same record.
+ *
+ * **Runtime body landed at v0.5-M35 IMPL.** Destructive gate fires
+ * BEFORE `resolveClient` (M10 round-1 P2 invariant); dry-run path
+ * emits minimal `{operation: "delete_doc", doc_id}` (no wire call);
+ * live path dispatches {@link deleteDoc} + projects via
+ * `emitMutation`.
+ */
+import { z } from 'zod';
+import { ensureSubcommand } from '../types.js';
+import { parseArgv } from '../parse-argv.js';
+import { parseGlobalFlags } from '../../types/global-flags.js';
+import { enforceDestructiveGate } from '../../api/destructive-gate.js';
+import { emitDryRun, emitMutation } from '../emit.js';
+import { resolveClient } from '../../api/resolve-client.js';
+import { DocIdSchema } from '../../types/ids.js';
+import { deleteDoc, docDeleteOutputSchema, } from '../../api/documents.js';
+const inputSchema = z.object({ docId: DocIdSchema }).strict();
+export const docDeleteCommand = {
+    name: 'doc.delete',
+    summary: 'Delete a workdoc — --yes required',
+    examples: [
+        'monday doc delete 12345678 --yes',
+        'monday doc delete 12345678 --dry-run',
+        'monday doc delete 12345678 --yes --json',
+    ],
+    // Re-deleting an already-deleted doc surfaces `not_found`;
+    // re-running with the same `<doc-id>` after an interim
+    // `doc create-in-workspace` would target a different record
+    // (Monday mints new DocIds on create). Mark non-idempotent.
+    idempotent: false,
+    inputSchema,
+    outputSchema: docDeleteOutputSchema,
+    attach: (program, ctx) => {
+        const noun = ensureSubcommand(program, 'doc', 'Workdoc commands');
+        noun
+            .command('delete <docId>')
+            .description(docDeleteCommand.summary)
+            .addHelpText('after', ['', 'Examples:', ...docDeleteCommand.examples.map((e) => `  ${e}`), ''].join('\n'))
+            .action(async (docId) => {
+            const parsed = parseArgv(docDeleteCommand.inputSchema, { docId });
+            // Gate BEFORE `resolveClient()` — M10 round-1 P2 invariant.
+            // A missing `--yes` must surface as `confirmation_required`
+            // per cli-design §3.1 #7's unconditional contract, never
+            // masked by `config_error` when no token is configured.
+            const preGateGlobalFlags = parseGlobalFlags(program.opts(), ctx.env);
+            enforceDestructiveGate({
+                globalFlags: preGateGlobalFlags,
+                verb: 'doc delete',
+                target: parsed.docId,
+                detailKey: 'doc_id',
+                action: 'delete the workdoc',
+                hint: 'delete is destructive — Monday\'s wire surface offers no ' +
+                    'restore mutation for workdocs; agents needing reversal must ' +
+                    'recreate via `monday doc create-in-workspace` / `create-on-' +
+                    'column` (lossy: new id, content must be re-imported).',
+            });
+            if (preGateGlobalFlags.dryRun) {
+                // Minimal dry-run shape — no preflight read fires. Per
+                // cli-design §6.4 mutation-dry-run variant: `operation:
+                // "delete_doc"`, `doc_id`, nothing else. `meta.source:
+                // 'none'` because no API call fires; live surfaces
+                // `not_found` for missing ids on its own. Mirrors
+                // workspace-delete + team-delete cadence.
+                const { apiVersion } = resolveClient(ctx, program.opts());
+                emitDryRun({
+                    ctx,
+                    programOpts: program.opts(),
+                    plannedChanges: [
+                        { operation: 'delete_doc', doc_id: parsed.docId },
+                    ],
+                    source: 'none',
+                    cacheAgeSeconds: null,
+                    warnings: [],
+                    apiVersion,
+                });
+                return;
+            }
+            const { client, apiVersion } = resolveClient(ctx, program.opts());
+            const result = await deleteDoc({ client, docId: parsed.docId });
+            emitMutation({
+                ctx,
+                data: result.result,
+                schema: docDeleteCommand.outputSchema,
+                programOpts: program.opts(),
+                warnings: [],
+                source: result.source,
+                cacheAgeSeconds: result.cacheAgeSeconds,
+                complexity: result.complexity,
+                apiVersion,
+            });
+        });
+    },
+};
+//# sourceMappingURL=delete.js.map

package/dist/commands/doc/delete.js.map

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

package/dist/commands/doc/duplicate.d.ts

@@ -0,0 +1,101 @@
+/**
+ * `monday doc duplicate <doc-id> [--with-updates] [--dry-run]` —
+ * duplicate an existing workdoc (`cli-design.md` §4.3 DOC section
+ * + §13 v0.5 entry; `v0.5-plan.md` §3 M35 + §8 D7-D9).
+ *
+ * **Wire shape.** Single `duplicate_doc(docId, duplicateType?)`
+ * round-trip via {@link duplicateDoc} against `mutation
+ * DuplicateDoc` with `operationName: 'DuplicateDoc'` (R-NEW-37 W2
+ * audit-point). Returns Monday's opaque `JSON` scalar — the
+ * fetcher projects to the flat `{ doc_id: <NEW>, success: true }`
+ * envelope per D9. The `doc_id` echoes the **NEWLY-CREATED**
+ * duplicate's id (NOT the source-doc positional id) — the
+ * fetcher's `extractDuplicateDocId` helper pulls the new id from
+ * the opaque JSON payload defensively (the v0.5 probe was
+ * read-only, so the helper accepts plausible shapes today;
+ * a future live wire response would let a follow-up commit
+ * narrow the accepted shapes).
+ *
+ * **`--with-updates` semantics.** Monday's `duplicate_doc.
+ * duplicateType` is a 2-value enum (`duplicate_doc_with_content`
+ * / `duplicate_doc_with_content_and_updates`); the wire-side
+ * default is `duplicate_doc_with_content` (content-only). The
+ * CLI surfaces a boolean opt-in `--with-updates`:
+ *
+ *   - absent → omit the wire variable (Monday's wire-side default
+ *     `duplicate_doc_with_content` applies — comments and update
+ *     history are NOT copied).
+ *   - present → wire `duplicateType:
+ *     'duplicate_doc_with_content_and_updates'` (clone body +
+ *     every comment / update thread).
+ *
+ * The 2-value enum stays internal to the fetcher; agents see a
+ * boolean opt-in, not the wire enum name.
+ *
+ * **No `--name <n>` slot per D8.** Monday's `duplicate_doc`
+ * mutation carries no rename-on-duplicate arg on the wire — the
+ * duplicate inherits Monday's auto-generated copy name (typically
+ * `"Copy of <source-name>"`). Agents needing a renamed duplicate
+ * pair this verb with a follow-up `monday doc rename <new-id>
+ * --name <n>` call. Adding the slot speculatively was the D8
+ * alternative (CLI would have wrapped a non-atomic
+ * duplicate→rename sequence); pre-flight ratified the drop
+ * because non-atomic cross-mutation flows leak partial-failure
+ * complexity into the verb's envelope shape (one operation
+ * succeeded, one failed → the verb's envelope shape doesn't fit
+ * cli-design §6.1 single-mutation success/failure dichotomy).
+ *
+ * **camelCase wire-arg note.** `duplicate_doc` takes camelCase
+ * `docId` + `duplicateType` on the wire (Finding 7) — see the
+ * canonical asymmetry note at `src/api/documents.ts` module
+ * header (4th supporting site for R-NEW-41).
+ *
+ * **Argv shape.**
+ *
+ *   - `<doc-id>` — required positional (Monday's
+ *     `duplicate_doc.docId` is `ID!`). Brand-validated via
+ *     {@link DocIdSchema}. Echoed in error envelopes; **NOT
+ *     echoed in the success envelope** (the success envelope's
+ *     `doc_id` slot carries the NEW duplicate's id per D9).
+ *   - `--with-updates` — optional boolean. Absent → wire-side
+ *     default `duplicate_doc_with_content`; present → wire
+ *     `duplicate_doc_with_content_and_updates`.
+ *
+ * **Output envelope.** Projected from Monday's opaque JSON return
+ * per D9 — `data: { doc_id: <NEW>, success: true }`. The
+ * `doc_id` slot is the new duplicate's id, NOT the source-doc
+ * positional. Source-doc id stays accessible via the argv
+ * (agents script `monday doc duplicate <source-id> | jq` and
+ * see the new id in the projection).
+ *
+ * **Dry-run shape** per cli-design §6.4 mutation-dry-run variant:
+ * minimal `{operation: "duplicate_doc", doc_id: <source>,
+ * duplicate_type?}`. The `doc_id` slot in the dry-run echoes the
+ * SOURCE id (not the new-id — Monday's wire is the only entity
+ * that can mint a new DocId at duplicate-time). No preflight
+ * read fires; `meta.source: 'none'`.
+ *
+ * **Idempotent: false.** Re-running creates a SECOND duplicate
+ * (Monday's wire does NOT dedupe by source-id). The source-doc's
+ * `id` stays addressable; the duplicates accrete.
+ *
+ * **Runtime body landed at v0.5-M35 IMPL.** `parseArgv` runs
+ * BEFORE `resolveClient` so invalid argv surfaces `usage_error`
+ * ahead of any missing-token `config_error`; `resolveClient`
+ * parses global flags internally before `loadConfig`. Dry-run
+ * path emits minimal planned changes (no wire call fires); live
+ * path dispatches {@link duplicateDoc} + projects via
+ * `emitMutation`. The `--with-updates` boolean maps to wire
+ * `duplicateType` per the M34 omit-vs-null discipline (absent →
+ * omit; present → `duplicate_doc_with_content_and_updates`).
+ */
+import { z } from 'zod';
+import { type CommandModule } from '../types.js';
+import { type DocDuplicateOutput } from '../../api/documents.js';
+declare const inputSchema: z.ZodObject<{
+    docId: z.core.$ZodBranded<z.ZodString, "DocId", "out">;
+    withUpdates: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const docDuplicateCommand: CommandModule<z.infer<typeof inputSchema>, DocDuplicateOutput>;
+export {};
+//# sourceMappingURL=duplicate.d.ts.map

package/dist/commands/doc/duplicate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplicate.d.ts","sourceRoot":"","sources":["../../../src/commands/doc/duplicate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0FG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAoB,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAKnE,OAAO,EAGL,KAAK,kBAAkB,EACxB,MAAM,wBAAwB,CAAC;AAEhC,QAAA,MAAM,WAAW;;;kBAKN,CAAC;AAEZ,eAAO,MAAM,mBAAmB,EAAE,aAAa,CAC7C,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,EAC3B,kBAAkB,CAoGnB,CAAC"}

package/dist/commands/doc/duplicate.js

@@ -0,0 +1,191 @@
+/**
+ * `monday doc duplicate <doc-id> [--with-updates] [--dry-run]` —
+ * duplicate an existing workdoc (`cli-design.md` §4.3 DOC section
+ * + §13 v0.5 entry; `v0.5-plan.md` §3 M35 + §8 D7-D9).
+ *
+ * **Wire shape.** Single `duplicate_doc(docId, duplicateType?)`
+ * round-trip via {@link duplicateDoc} against `mutation
+ * DuplicateDoc` with `operationName: 'DuplicateDoc'` (R-NEW-37 W2
+ * audit-point). Returns Monday's opaque `JSON` scalar — the
+ * fetcher projects to the flat `{ doc_id: <NEW>, success: true }`
+ * envelope per D9. The `doc_id` echoes the **NEWLY-CREATED**
+ * duplicate's id (NOT the source-doc positional id) — the
+ * fetcher's `extractDuplicateDocId` helper pulls the new id from
+ * the opaque JSON payload defensively (the v0.5 probe was
+ * read-only, so the helper accepts plausible shapes today;
+ * a future live wire response would let a follow-up commit
+ * narrow the accepted shapes).
+ *
+ * **`--with-updates` semantics.** Monday's `duplicate_doc.
+ * duplicateType` is a 2-value enum (`duplicate_doc_with_content`
+ * / `duplicate_doc_with_content_and_updates`); the wire-side
+ * default is `duplicate_doc_with_content` (content-only). The
+ * CLI surfaces a boolean opt-in `--with-updates`:
+ *
+ *   - absent → omit the wire variable (Monday's wire-side default
+ *     `duplicate_doc_with_content` applies — comments and update
+ *     history are NOT copied).
+ *   - present → wire `duplicateType:
+ *     'duplicate_doc_with_content_and_updates'` (clone body +
+ *     every comment / update thread).
+ *
+ * The 2-value enum stays internal to the fetcher; agents see a
+ * boolean opt-in, not the wire enum name.
+ *
+ * **No `--name <n>` slot per D8.** Monday's `duplicate_doc`
+ * mutation carries no rename-on-duplicate arg on the wire — the
+ * duplicate inherits Monday's auto-generated copy name (typically
+ * `"Copy of <source-name>"`). Agents needing a renamed duplicate
+ * pair this verb with a follow-up `monday doc rename <new-id>
+ * --name <n>` call. Adding the slot speculatively was the D8
+ * alternative (CLI would have wrapped a non-atomic
+ * duplicate→rename sequence); pre-flight ratified the drop
+ * because non-atomic cross-mutation flows leak partial-failure
+ * complexity into the verb's envelope shape (one operation
+ * succeeded, one failed → the verb's envelope shape doesn't fit
+ * cli-design §6.1 single-mutation success/failure dichotomy).
+ *
+ * **camelCase wire-arg note.** `duplicate_doc` takes camelCase
+ * `docId` + `duplicateType` on the wire (Finding 7) — see the
+ * canonical asymmetry note at `src/api/documents.ts` module
+ * header (4th supporting site for R-NEW-41).
+ *
+ * **Argv shape.**
+ *
+ *   - `<doc-id>` — required positional (Monday's
+ *     `duplicate_doc.docId` is `ID!`). Brand-validated via
+ *     {@link DocIdSchema}. Echoed in error envelopes; **NOT
+ *     echoed in the success envelope** (the success envelope's
+ *     `doc_id` slot carries the NEW duplicate's id per D9).
+ *   - `--with-updates` — optional boolean. Absent → wire-side
+ *     default `duplicate_doc_with_content`; present → wire
+ *     `duplicate_doc_with_content_and_updates`.
+ *
+ * **Output envelope.** Projected from Monday's opaque JSON return
+ * per D9 — `data: { doc_id: <NEW>, success: true }`. The
+ * `doc_id` slot is the new duplicate's id, NOT the source-doc
+ * positional. Source-doc id stays accessible via the argv
+ * (agents script `monday doc duplicate <source-id> | jq` and
+ * see the new id in the projection).
+ *
+ * **Dry-run shape** per cli-design §6.4 mutation-dry-run variant:
+ * minimal `{operation: "duplicate_doc", doc_id: <source>,
+ * duplicate_type?}`. The `doc_id` slot in the dry-run echoes the
+ * SOURCE id (not the new-id — Monday's wire is the only entity
+ * that can mint a new DocId at duplicate-time). No preflight
+ * read fires; `meta.source: 'none'`.
+ *
+ * **Idempotent: false.** Re-running creates a SECOND duplicate
+ * (Monday's wire does NOT dedupe by source-id). The source-doc's
+ * `id` stays addressable; the duplicates accrete.
+ *
+ * **Runtime body landed at v0.5-M35 IMPL.** `parseArgv` runs
+ * BEFORE `resolveClient` so invalid argv surfaces `usage_error`
+ * ahead of any missing-token `config_error`; `resolveClient`
+ * parses global flags internally before `loadConfig`. Dry-run
+ * path emits minimal planned changes (no wire call fires); live
+ * path dispatches {@link duplicateDoc} + projects via
+ * `emitMutation`. The `--with-updates` boolean maps to wire
+ * `duplicateType` per the M34 omit-vs-null discipline (absent →
+ * omit; present → `duplicate_doc_with_content_and_updates`).
+ */
+import { z } from 'zod';
+import { ensureSubcommand } from '../types.js';
+import { parseArgv } from '../parse-argv.js';
+import { emitDryRun, emitMutation } from '../emit.js';
+import { resolveClient } from '../../api/resolve-client.js';
+import { DocIdSchema } from '../../types/ids.js';
+import { duplicateDoc, docDuplicateOutputSchema, } from '../../api/documents.js';
+const inputSchema = z
+    .object({
+    docId: DocIdSchema,
+    withUpdates: z.boolean().optional(),
+})
+    .strict();
+export const docDuplicateCommand = {
+    name: 'doc.duplicate',
+    summary: 'Duplicate a workdoc (content-only by default; --with-updates also clones comments + update history)',
+    examples: [
+        'monday doc duplicate 12345678',
+        'monday doc duplicate 12345678 --with-updates',
+        'monday doc duplicate 12345678 --with-updates --dry-run --json',
+    ],
+    // Monday's wire allows multiple duplicates per source; verb is
+    // non-idempotent (each call mints a new DocId).
+    idempotent: false,
+    inputSchema,
+    outputSchema: docDuplicateOutputSchema,
+    attach: (program, ctx) => {
+        const noun = ensureSubcommand(program, 'doc', 'Workdoc commands');
+        noun
+            .command('duplicate <docId>')
+            .description(docDuplicateCommand.summary)
+            .option('--with-updates', 'clone comments + update history alongside the doc body (maps to wire `duplicateType: duplicate_doc_with_content_and_updates`); absent → content-only')
+            .addHelpText('after', [
+            '',
+            'Examples:',
+            ...docDuplicateCommand.examples.map((e) => `  ${e}`),
+            '',
+            'Notes:',
+            '  - Envelope `data.doc_id` is the NEW duplicate\'s id (not the source-doc positional). Source-doc id stays available via the argv (D9 closure).',
+            '  - Monday\'s wire offers no rename-on-duplicate slot; the duplicate inherits Monday\'s auto-generated copy name. Pair with `monday doc rename <new-id> --name <n>` for a renamed duplicate (D8 closure).',
+            '  - `--dry-run` emits the planned `duplicate_doc` operation + resolved input fields (no wire call fires; `meta.source: "none"`).',
+            '',
+        ].join('\n'))
+            .action(async (docIdArg, opts) => {
+            const parsed = parseArgv(docDuplicateCommand.inputSchema, {
+                docId: docIdArg,
+                ...opts,
+            });
+            const { client, globalFlags, apiVersion } = resolveClient(ctx, program.opts());
+            // Map the CLI's boolean `--with-updates` flag to Monday's
+            // 2-value `DuplicateType` enum: absent → omit the wire
+            // variable (Monday's wire-side default content-only applies);
+            // present → opt into the with-updates variant.
+            const duplicateType = parsed.withUpdates === true
+                ? 'duplicate_doc_with_content_and_updates'
+                : undefined;
+            if (globalFlags.dryRun) {
+                const planned = {
+                    operation: 'duplicate_doc',
+                    // Dry-run echoes the SOURCE id (the new-id is wire-only
+                    // — only Monday can mint it). Live envelope swaps in
+                    // the new-id; dry-run + live envelopes' `doc_id` slots
+                    // are intentionally different per D9 prose at
+                    // `src/api/documents.ts`.
+                    doc_id: parsed.docId,
+                };
+                if (duplicateType !== undefined) {
+                    planned.duplicate_type = duplicateType;
+                }
+                emitDryRun({
+                    ctx,
+                    programOpts: program.opts(),
+                    plannedChanges: [planned],
+                    source: 'none',
+                    cacheAgeSeconds: null,
+                    warnings: [],
+                    apiVersion,
+                });
+                return;
+            }
+            const result = await duplicateDoc({
+                client,
+                docId: parsed.docId,
+                ...(duplicateType === undefined ? {} : { duplicateType }),
+            });
+            emitMutation({
+                ctx,
+                data: result.result,
+                schema: docDuplicateCommand.outputSchema,
+                programOpts: program.opts(),
+                warnings: [],
+                source: result.source,
+                cacheAgeSeconds: result.cacheAgeSeconds,
+                complexity: result.complexity,
+                apiVersion,
+            });
+        });
+    },
+};
+//# sourceMappingURL=duplicate.js.map

package/dist/commands/doc/duplicate.js.map

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

package/dist/commands/doc/import-html.d.ts

@@ -0,0 +1,125 @@
+/**
+ * `monday doc import-html --workspace <wid> (--html <file|-> |
+ * --html-string <s>) [--folder <fid>] [--kind public|private|share]
+ * [--title <t>] [--dry-run]` — import an HTML payload as a new workdoc
+ * (`cli-design.md` §4.3 DOC section + §13 v0.5 entry;
+ * `v0.5-plan.md` §3 M37 + §8 D12-D13).
+ *
+ * **Wire shape.** Single `import_doc_from_html(html, workspaceId,
+ * kind?, folderId?, title?) → ImportDocFromHtmlResult` round-trip via
+ * {@link importDocFromHtml} against `mutation ImportDocFromHtml` with
+ * `operationName: 'ImportDocFromHtml'` (R-NEW-37 W2 audit-point).
+ * Custom-OBJECT return shape: `{success!, doc_id?, error?}` —
+ * distinct from M35's opaque-JSON projection and M36's typed-OBJECT
+ * direct-unwrap (third doc-mutation return shape; see
+ * `src/api/documents.ts` M37 section header for the full taxonomy).
+ *
+ * **camelCase wire-arg note.** `import_doc_from_html` uses camelCase
+ * `workspaceId` / `folderId` on the wire (Finding 7); CLI argv stays
+ * kebab-case (`--workspace <wid>` / `--folder <fid>`); error envelope
+ * `details.*` keys stay snake_case (`details.workspace_id` /
+ * `details.folder_id`) per cli-design §6.5. See the canonical
+ * asymmetry note at `src/api/documents.ts` module header (5th
+ * supporting site for R-NEW-41).
+ *
+ * **Argv shape.**
+ *
+ *   - `--workspace <wid>` — required (Monday's
+ *     `import_doc_from_html.workspaceId` is `ID!`). Numeric workspace
+ *     ID; brand-validated via {@link WorkspaceIdSchema} at the parse
+ *     boundary.
+ *   - `--html <file|->` OR `--html-string <s>` — **mutually-exclusive
+ *     content source; exactly one required.** Both forms supply the
+ *     HTML payload that Monday parses into a new doc; the source path
+ *     vs inline-string split mirrors M13's `update reply / edit`
+ *     `--body-file <path>` vs `--body <md>` shape. The file path form
+ *     supports `-` for stdin (read up to EOF; cli-design §3.1 stdin
+ *     discipline). The inline form caps at
+ *     {@link MAX_DOC_IMPORT_PAYLOAD_BYTES} bytes at the parse
+ *     boundary per D13 closure (empirical wire threshold sits
+ *     between 250KB-OK and 500KB-rejected). The file/stdin form
+ *     applies the same size guard at the runtime read boundary
+ *     (defense-in-depth via the lifted {@link readSourceContent}
+ *     helper's `maxBytes` slot).
+ *   - `--folder <fid>` — optional (maps to wire `folderId: ID`).
+ *     Numeric folder ID; brand-validated via {@link DocFolderIdSchema}.
+ *     Absent → doc lands at workspace root.
+ *   - `--kind <k>` — optional 3-value closed enum
+ *     (`public` / `private` / `share`); maps to wire `kind: DocKind`.
+ *     Absent → Monday applies the wire-side default `public` per
+ *     probe description ("Defaults to 'public' if not specified").
+ *   - `--title <t>` — optional, non-empty (maps to wire
+ *     `title: String`). Absent → Monday infers the title from the
+ *     HTML content per probe description ("If not provided, the
+ *     title will be inferred from the HTML content").
+ *
+ * **Output envelope.** Custom-OBJECT projection per D12 — `data: {
+ * doc_id, success: true }` mirroring M35's
+ * {@link docMutationResultSchema} cadence so agents read a uniform
+ * `{ doc_id, success }` shape across rename / delete / duplicate /
+ * import-html. The `doc_id` slot carries the NEWLY-CREATED doc's id
+ * (extracted from `ImportDocFromHtmlResult.doc_id`).
+ *
+ * **Failure mapping** per D12 closure:
+ *
+ *   - `success: false + populated error` → `validation_failed` with
+ *     `details: { workspace_id, error, hint }`.
+ *   - `success: false + empty/null error` → `internal_error` with
+ *     wire-regression hint.
+ *   - `success: true + missing/null doc_id` → `internal_error`
+ *     (Monday promises a non-null `doc_id` on success).
+ *   - Oversized inline `--html-string` at parse boundary →
+ *     `usage_error.details.issues[{path: 'htmlString', message:
+ *     '--html-string exceeds the 256000-byte wire-side limit ...'}]`
+ *     from `parseArgv`'s zod-issues envelope (D13 closure). The
+ *     `usage_error` rejection surfaces ahead of any wire dispatch.
+ *   - Oversized file payload at runtime →
+ *     `readSourceContent` rejects with `usage_error` carrying
+ *     `details: { source: 'file' | 'stdin', size_bytes, limit_bytes,
+ *     file_path? }`.
+ *
+ * **Dry-run shape** per cli-design §6.4 mutation-dry-run variant.
+ * Minimal envelope listing the planned `import_doc_from_html`
+ * operation + the resolved input fields (`workspace_id`, optional
+ * `folder_id`, optional `kind`, optional `title`, `html_source`
+ * descriptor — file path / `'(stdin)'` / `'(inline)'`). Does NOT
+ * include the HTML payload itself (which could be hundreds of KB);
+ * agents see WHAT would be sent, not the bytes. No preflight read
+ * fires; `meta.source: 'none'`.
+ *
+ * **Idempotent: false.** Re-running creates a duplicate doc with a
+ * fresh id (Monday's wire does not dedupe by HTML content or title).
+ * Agents that need idempotency must pair with a `monday doc list
+ * --workspace <wid>` lookup first.
+ *
+ * **Permission-sensitive.** Tokens lacking workdoc-create scope on
+ * the target workspace surface `forbidden` (mapped from Monday's
+ * PERMISSION_DENIED extension).
+ *
+ * **Runtime body landed at v0.5-M37 IMPL.** `parseArgv` runs BEFORE
+ * `resolveClient` so invalid argv surfaces `usage_error` ahead of any
+ * missing-token `config_error`; the lifted {@link readSourceContent}
+ * helper applies the same size guard at the runtime read boundary
+ * (file/stdin path) that the schema's `.refine()` applies at parse
+ * boundary (inline path). Dry-run emits minimal planned changes with
+ * the source descriptor; live path dispatches
+ * {@link importDocFromHtml} + projects via `emitMutation`.
+ */
+import { z } from 'zod';
+import { type CommandModule } from '../types.js';
+import { type DocImportHtmlOutput } from '../../api/documents.js';
+declare const inputSchema: z.ZodObject<{
+    workspace: z.core.$ZodBranded<z.ZodString, "WorkspaceId", "out">;
+    html: z.ZodOptional<z.ZodString>;
+    htmlString: z.ZodOptional<z.ZodString>;
+    folder: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "DocFolderId", "out">>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        public: "public";
+        private: "private";
+        share: "share";
+    }>>;
+    title: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const docImportHtmlCommand: CommandModule<z.infer<typeof inputSchema>, DocImportHtmlOutput>;
+export {};
+//# sourceMappingURL=import-html.d.ts.map

package/dist/commands/doc/import-html.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-html.d.ts","sourceRoot":"","sources":["../../../src/commands/doc/import-html.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0GG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAoB,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAKnE,OAAO,EAKL,KAAK,mBAAmB,EACzB,MAAM,wBAAwB,CAAC;AAGhC,QAAA,MAAM,WAAW;;;;;;;;;;;kBA6Cd,CAAC;AAoBJ,eAAO,MAAM,oBAAoB,EAAE,aAAa,CAC9C,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,EAC3B,mBAAmB,CAqHpB,CAAC"}