monday-cli 0.3.0 → 0.5.0

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/get.d.ts

@@ -0,0 +1,46 @@
+/**
+ * `monday doc get <did>` — read a single workdoc by ID, including
+ * its rich-text block body (cli-design.md §4.3 DOC section + §13
+ * v0.4 entry; v0.4-plan.md §3 M32).
+ *
+ * **Wire shape.** Single `Query.docs(ids: [<did>])` round-trip via
+ * {@link getDocument} against `query GetDoc` with `operationName:
+ * 'GetDoc'` (R-NEW-37 W2 audit-point). Monday returns `[Document]`
+ * (an array even for a single-id query); the fetcher extracts
+ * index 0. Empty array → `not_found` with `details.doc_id` (D8 —
+ * Monday's wire surface collapses "doesn't exist" + "exists but
+ * inaccessible to token" into the same shape; the CLI can't
+ * distinguish them).
+ *
+ * **Output envelope (D9).** Direct unwrap of the Document — `data:
+ * <Document with blocks>`. Mirrors the read-one-verb convention
+ * (`monday board get <bid>` returns `data: <Board>`, `monday user
+ * get <uid>` returns `data: <User>`). The Document's own `id`
+ * field is the echoed input; no separate `doc_id` slot is needed.
+ * `data.blocks: [DocumentBlock]` is the rich-text body hydrated
+ * from `Document.blocks` (always present on success — never null
+ * for a doc that resolved).
+ *
+ * **Docs are live-only at v0.4-M32** per cli-design §8 cache
+ * scope. Output `meta.source: "live"`, `meta.cache_age_seconds:
+ * null`. Per-doc body content is content-heavy + frequently
+ * human-edited; the stale-cache risk outweighs the cache-hit
+ * value.
+ *
+ * **Idempotent: yes** (pure read).
+ *
+ * **Runtime body landed at v0.4-M32 IMPL.** Argv parsing + schema +
+ * commander wiring all ship as the real shipped surface; the action
+ * body's wire-call dispatch + envelope emit are below. The verb is
+ * a thin wrapper around {@link getDocument} — branded `<docId>` →
+ * fetcher → direct-unwrap envelope.
+ */
+import { z } from 'zod';
+import { type CommandModule } from '../types.js';
+import { type DocGetOutput } from '../../api/documents.js';
+declare const inputSchema: z.ZodObject<{
+    docId: z.core.$ZodBranded<z.ZodString, "DocId", "out">;
+}, z.core.$strict>;
+export declare const docGetCommand: CommandModule<z.infer<typeof inputSchema>, DocGetOutput>;
+export {};
+//# sourceMappingURL=get.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get.d.ts","sourceRoot":"","sources":["../../../src/commands/doc/get.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAoB,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAKnE,OAAO,EAGL,KAAK,YAAY,EAClB,MAAM,wBAAwB,CAAC;AAEhC,QAAA,MAAM,WAAW;;kBAA4C,CAAC;AAE9D,eAAO,MAAM,aAAa,EAAE,aAAa,CACvC,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,EAC3B,YAAY,CAyDb,CAAC"}

package/dist/commands/doc/get.js

@@ -0,0 +1,95 @@
+/**
+ * `monday doc get <did>` — read a single workdoc by ID, including
+ * its rich-text block body (cli-design.md §4.3 DOC section + §13
+ * v0.4 entry; v0.4-plan.md §3 M32).
+ *
+ * **Wire shape.** Single `Query.docs(ids: [<did>])` round-trip via
+ * {@link getDocument} against `query GetDoc` with `operationName:
+ * 'GetDoc'` (R-NEW-37 W2 audit-point). Monday returns `[Document]`
+ * (an array even for a single-id query); the fetcher extracts
+ * index 0. Empty array → `not_found` with `details.doc_id` (D8 —
+ * Monday's wire surface collapses "doesn't exist" + "exists but
+ * inaccessible to token" into the same shape; the CLI can't
+ * distinguish them).
+ *
+ * **Output envelope (D9).** Direct unwrap of the Document — `data:
+ * <Document with blocks>`. Mirrors the read-one-verb convention
+ * (`monday board get <bid>` returns `data: <Board>`, `monday user
+ * get <uid>` returns `data: <User>`). The Document's own `id`
+ * field is the echoed input; no separate `doc_id` slot is needed.
+ * `data.blocks: [DocumentBlock]` is the rich-text body hydrated
+ * from `Document.blocks` (always present on success — never null
+ * for a doc that resolved).
+ *
+ * **Docs are live-only at v0.4-M32** per cli-design §8 cache
+ * scope. Output `meta.source: "live"`, `meta.cache_age_seconds:
+ * null`. Per-doc body content is content-heavy + frequently
+ * human-edited; the stale-cache risk outweighs the cache-hit
+ * value.
+ *
+ * **Idempotent: yes** (pure read).
+ *
+ * **Runtime body landed at v0.4-M32 IMPL.** Argv parsing + schema +
+ * commander wiring all ship as the real shipped surface; the action
+ * body's wire-call dispatch + envelope emit are below. The verb is
+ * a thin wrapper around {@link getDocument} — branded `<docId>` →
+ * fetcher → direct-unwrap envelope.
+ */
+import { z } from 'zod';
+import { ensureSubcommand } from '../types.js';
+import { parseArgv } from '../parse-argv.js';
+import { emitSuccess } from '../emit.js';
+import { resolveClient } from '../../api/resolve-client.js';
+import { DocIdSchema } from '../../types/ids.js';
+import { docGetOutputSchema, getDocument, } from '../../api/documents.js';
+const inputSchema = z.object({ docId: DocIdSchema }).strict();
+export const docGetCommand = {
+    name: 'doc.get',
+    summary: 'Read a single workdoc by ID (includes block body)',
+    examples: [
+        'monday doc get 12345678',
+        'monday doc get 12345678 --json',
+    ],
+    idempotent: true,
+    inputSchema,
+    outputSchema: docGetOutputSchema,
+    attach: (program, ctx) => {
+        const noun = ensureSubcommand(program, 'doc', 'Document commands (workdocs; read-only at v0.4 — see cli-design §13 v0.4 entry)');
+        noun
+            .command('get <docId>')
+            .description(docGetCommand.summary)
+            .addHelpText('after', [
+            '',
+            'Examples:',
+            ...docGetCommand.examples.map((e) => `  ${e}`),
+            '',
+            'Notes:',
+            '  - Output carries the full Document plus `blocks: [DocumentBlock]` (rich-text body).',
+            '  - Non-existent + inaccessible docs both surface `not_found` (Monday\'s wire collapses both cases).',
+            '',
+        ].join('\n'))
+            .action(async (docIdArg) => {
+            const parsed = parseArgv(docGetCommand.inputSchema, {
+                docId: docIdArg,
+            });
+            const { client, apiVersion } = resolveClient(ctx, program.opts());
+            const result = await getDocument({
+                client,
+                docId: parsed.docId,
+            });
+            emitSuccess({
+                ctx,
+                data: result.document,
+                schema: docGetCommand.outputSchema,
+                programOpts: program.opts(),
+                kind: 'single',
+                warnings: [],
+                source: result.source,
+                cacheAgeSeconds: result.cacheAgeSeconds,
+                complexity: result.complexity,
+                apiVersion,
+            });
+        });
+    },
+};
+//# sourceMappingURL=get.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get.js","sourceRoot":"","sources":["../../../src/commands/doc/get.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,gBAAgB,EAAsB,MAAM,aAAa,CAAC;AACnE,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EACL,kBAAkB,EAClB,WAAW,GAEZ,MAAM,wBAAwB,CAAC;AAEhC,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC;AAE9D,MAAM,CAAC,MAAM,aAAa,GAGtB;IACF,IAAI,EAAE,SAAS;IACf,OAAO,EAAE,mDAAmD;IAC5D,QAAQ,EAAE;QACR,yBAAyB;QACzB,gCAAgC;KACjC;IACD,UAAU,EAAE,IAAI;IAChB,WAAW;IACX,YAAY,EAAE,kBAAkB;IAChC,MAAM,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,EAAE;QACvB,MAAM,IAAI,GAAG,gBAAgB,CAC3B,OAAO,EACP,KAAK,EACL,iFAAiF,CAClF,CAAC;QACF,IAAI;aACD,OAAO,CAAC,aAAa,CAAC;aACtB,WAAW,CAAC,aAAa,CAAC,OAAO,CAAC;aAClC,WAAW,CACV,OAAO,EACP;YACE,EAAE;YACF,WAAW;YACX,GAAG,aAAa,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;YAC9C,EAAE;YACF,QAAQ;YACR,uFAAuF;YACvF,sGAAsG;YACtG,EAAE;SACH,CAAC,IAAI,CAAC,IAAI,CAAC,CACb;aACA,MAAM,CAAC,KAAK,EAAE,QAAiB,EAAE,EAAE;YAClC,MAAM,MAAM,GAAG,SAAS,CAAC,aAAa,CAAC,WAAW,EAAE;gBAClD,KAAK,EAAE,QAAQ;aAChB,CAAC,CAAC;YAEH,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,aAAa,CAAC,GAAG,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;YAClE,MAAM,MAAM,GAAG,MAAM,WAAW,CAAC;gBAC/B,MAAM;gBACN,KAAK,EAAE,MAAM,CAAC,KAAK;aACpB,CAAC,CAAC;YACH,WAAW,CAAC;gBACV,GAAG;gBACH,IAAI,EAAE,MAAM,CAAC,QAAQ;gBACrB,MAAM,EAAE,aAAa,CAAC,YAAY;gBAClC,WAAW,EAAE,OAAO,CAAC,IAAI,EAAE;gBAC3B,IAAI,EAAE,QAAQ;gBACd,QAAQ,EAAE,EAAE;gBACZ,MAAM,EAAE,MAAM,CAAC,MAAM;gBACrB,eAAe,EAAE,MAAM,CAAC,eAAe;gBACvC,UAAU,EAAE,MAAM,CAAC,UAAU;gBAC7B,UAAU;aACX,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACP,CAAC;CACF,CAAC"}

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"}