@bussolabs/closeyourit-cli 0.18.0 → 0.20.0

package/dist/commands/tickets/report-show.d.ts

@@ -0,0 +1,20 @@
+import { BaseCommand } from '../../base';
+/**
+ * Legge il resoconto di lavorazione (CYCL-31): senza `--version` la stesura corrente, con `--version N`
+ * quella versione della cronologia — il numero è unico per ticket, quindi non serve l'id.
+ *
+ * Un ticket senza resoconto risponde `R404-REPORT-001` e il comando esce non-zero: uno script che
+ * pretende un resoconto se ne accorge, invece di leggere un output vuoto come "c'è ed è vuoto".
+ */
+export default class TicketsReportShow extends BaseCommand {
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        version: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        project: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/tickets/report-show.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../../base");
+const ticket_report_1 = require("../../lib/ticket-report");
+/**
+ * Legge il resoconto di lavorazione (CYCL-31): senza `--version` la stesura corrente, con `--version N`
+ * quella versione della cronologia — il numero è unico per ticket, quindi non serve l'id.
+ *
+ * Un ticket senza resoconto risponde `R404-REPORT-001` e il comando esce non-zero: uno script che
+ * pretende un resoconto se ne accorge, invece di leggere un output vuoto come "c'è ed è vuoto".
+ */
+class TicketsReportShow extends base_1.BaseCommand {
+    static args = {
+        id: core_1.Args.string({ description: 'Ticket id or code (e.g. DRFL-3)', required: true }),
+    };
+    static description = 'Show the current work report of a ticket, or a past version with --version';
+    static examples = [
+        '<%= config.bin %> tickets report-show <ticket-id> --project acme-api',
+        '<%= config.bin %> tickets report-show DRFL-3 -p acme-api --version 2',
+    ];
+    static flags = {
+        ...base_1.projectFlag,
+        version: core_1.Flags.integer({ description: 'Version number to read instead of the current one' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(TicketsReportShow);
+        const projectId = await this.resolveProjectId(flags.project);
+        const base = `/cli/v1/projects/${encodeURIComponent(projectId)}/tickets/${encodeURIComponent(args.id)}/report`;
+        const path = flags.version === undefined ? base : `${base}/versions/${encodeURIComponent(String(flags.version))}`;
+        const res = await this.api.get(path);
+        if (!this.jsonEnabled()) {
+            this.log((0, ticket_report_1.renderReport)(res.data ?? {}));
+        }
+        return res;
+    }
+}
+exports.default = TicketsReportShow;

package/dist/commands/tickets/report-versions.d.ts

@@ -0,0 +1,19 @@
+import { BaseCommand } from '../../base';
+/**
+ * Cronologia del resoconto di lavorazione (CYCL-31), dalla più recente alla più vecchia. La tabella
+ * porta i metadati e la LUNGHEZZA di ogni stesura, non il testo: i corpi sono lunghi migliaia di
+ * caratteri e incolonnarli renderebbe illeggibile la lista. Il testo di una versione si legge con
+ * `tickets report-show --version N`.
+ */
+export default class TicketsReportVersions extends BaseCommand {
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        page: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
+        project: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/tickets/report-versions.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../../base");
+const limits_1 = require("../../lib/limits");
+const output_1 = require("../../lib/output");
+/**
+ * Cronologia del resoconto di lavorazione (CYCL-31), dalla più recente alla più vecchia. La tabella
+ * porta i metadati e la LUNGHEZZA di ogni stesura, non il testo: i corpi sono lunghi migliaia di
+ * caratteri e incolonnarli renderebbe illeggibile la lista. Il testo di una versione si legge con
+ * `tickets report-show --version N`.
+ */
+class TicketsReportVersions extends base_1.BaseCommand {
+    static args = {
+        id: core_1.Args.string({ description: 'Ticket id or code (e.g. DRFL-3)', required: true }),
+    };
+    static description = 'List the versions of the work report of a ticket (newest first)';
+    static examples = [
+        '<%= config.bin %> tickets report-versions <ticket-id> --project acme-api',
+        '<%= config.bin %> tickets report-versions DRFL-3 -p acme-api --page 2 --json',
+    ];
+    static flags = { ...base_1.projectFlag, ...base_1.pageFlag };
+    async run() {
+        const { args, flags } = await this.parse(TicketsReportVersions);
+        const projectId = await this.resolveProjectId(flags.project);
+        const res = await this.api.get(`/cli/v1/projects/${encodeURIComponent(projectId)}/tickets/${encodeURIComponent(args.id)}/report/versions?page=${flags.page}`);
+        const versions = res.data ?? [];
+        if (!this.jsonEnabled()) {
+            this.log((0, output_1.renderTable)(['VERSION', 'AUTHOR', 'SOURCE', 'CHARS', 'CREATED_AT'], versions.map((version) => [
+                String(version.version ?? ''),
+                String(version.author ?? '-'),
+                String(version.source ?? '-'),
+                String((0, limits_1.charCount)(version.body)),
+                String(version.created_at ?? ''),
+            ])));
+        }
+        return res;
+    }
+}
+exports.default = TicketsReportVersions;

package/dist/commands/tickets/report.d.ts

@@ -0,0 +1,24 @@
+import { BaseCommand } from '../../base';
+/**
+ * Resoconto di lavorazione di un ticket (CYCL-31). È il campo che il server indica quando rifiuta un
+ * commento troppo lungo, e fino a qui esisteva solo nel form web: chi chiudeva una lavorazione dal
+ * terminale doveva aprire il sito o rinunciare a scrivere il resoconto.
+ *
+ * Ogni scrittura AGGIUNGE una versione, non sovrascrive la precedente: correggere un resoconto
+ * significa scriverne uno nuovo, e la cronologia si legge con `tickets report-versions`. Ripassare
+ * lo stesso identico testo non crea una versione in più — è il server a riconoscerlo, quindi un
+ * comando ripetuto (un retry di uno script) non sporca la cronologia.
+ */
+export default class TicketsReport extends BaseCommand {
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        body: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'body-file': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        project: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/tickets/report.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = require("node:fs/promises");
+const core_1 = require("@oclif/core");
+const base_1 = require("../../base");
+const limits_1 = require("../../lib/limits");
+const ticket_report_1 = require("../../lib/ticket-report");
+/**
+ * Resoconto di lavorazione di un ticket (CYCL-31). È il campo che il server indica quando rifiuta un
+ * commento troppo lungo, e fino a qui esisteva solo nel form web: chi chiudeva una lavorazione dal
+ * terminale doveva aprire il sito o rinunciare a scrivere il resoconto.
+ *
+ * Ogni scrittura AGGIUNGE una versione, non sovrascrive la precedente: correggere un resoconto
+ * significa scriverne uno nuovo, e la cronologia si legge con `tickets report-versions`. Ripassare
+ * lo stesso identico testo non crea una versione in più — è il server a riconoscerlo, quindi un
+ * comando ripetuto (un retry di uno script) non sporca la cronologia.
+ */
+class TicketsReport extends base_1.BaseCommand {
+    static args = {
+        id: core_1.Args.string({ description: 'Ticket id or code (e.g. DRFL-3)', required: true }),
+    };
+    static description = 'Write the work report of a ticket — the long text a comment cannot hold. Each write adds a version, it never overwrites the previous one';
+    static examples = [
+        '<%= config.bin %> tickets report <ticket-id> --project acme-api --body "Cosa ho fatto, come si verifica"',
+        '<%= config.bin %> tickets report DRFL-3 -p acme-api --body-file ./report.md',
+    ];
+    static flags = {
+        ...base_1.projectFlag,
+        body: core_1.Flags.string({ description: `Report body (markdown, max ${limits_1.LENGTH_LIMITS.report} characters)` }),
+        'body-file': core_1.Flags.string({
+            description: `Read the report body (max ${limits_1.LENGTH_LIMITS.report} characters) from a local file`,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(TicketsReport);
+        // Una versione è immutabile: se i due valori divergono, sceglierne uno a caso lascia il
+        // resoconto sbagliato per sempre. Meglio fermarsi prima di scrivere.
+        if (flags.body !== undefined && flags['body-file'] !== undefined) {
+            this.error('Pass the report body with --body or --body-file, not both.', { exit: 2 });
+        }
+        let body = flags.body;
+        let bodyFlag = '--body';
+        if (body === undefined && flags['body-file'] !== undefined) {
+            bodyFlag = '--body-file';
+            try {
+                body = await (0, promises_1.readFile)(flags['body-file'], 'utf8');
+            }
+            catch {
+                this.error(`File not found or unreadable: ${flags['body-file']}`, { exit: 2 });
+            }
+        }
+        if (body === undefined) {
+            this.error('Provide the report body via --body or --body-file.', { exit: 2 });
+        }
+        // Ogni scrittura è una versione nuova, quindi il tetto vale sempre pieno: niente da salvaguardare
+        // e nessun motivo di spedire un testo che il server rifiuterebbe comunque (CYCL-32).
+        const tooLong = (0, limits_1.tooLongMessage)([{ flag: bodyFlag, value: body, max: limits_1.LENGTH_LIMITS.report, orthography: true }]);
+        if (tooLong)
+            this.error(tooLong, { exit: 2 });
+        const projectId = await this.resolveProjectId(flags.project);
+        const res = await this.api.post(`/cli/v1/projects/${encodeURIComponent(projectId)}/tickets/${encodeURIComponent(args.id)}/report`, { body });
+        if (!this.jsonEnabled()) {
+            this.log('Work report saved:');
+            this.log((0, ticket_report_1.renderReport)(res.data ?? {}));
+        }
+        return res;
+    }
+}
+exports.default = TicketsReport;

package/dist/commands/tickets/status.d.ts

@@ -6,7 +6,7 @@ export default class TicketsStatus extends BaseCommand {
         id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
     };
     static flags: {
-        'status-id': import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        status: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
         project: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<unknown>;

package/dist/commands/tickets/status.js

@@ -3,20 +3,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
 const base_1 = require("../../base");
 const output_1 = require("../../lib/output");
+const ticket_lookup_1 = require("../../lib/ticket-lookup");
 class TicketsStatus extends base_1.BaseCommand {
-    static description = 'Change a ticket status';
-    static examples = ['<%= config.bin %> tickets status <ticket-id> --project acme-api --status-id <status-id>'];
+    static description = 'Change a ticket status (by code, label or id)';
+    static examples = [
+        '<%= config.bin %> tickets status <ticket-id> --project acme-api --status in_review',
+        '<%= config.bin %> tickets status <ticket-id> --project acme-api --status <status-id>',
+    ];
     static args = {
         id: core_1.Args.string({ description: 'Ticket id', required: true }),
     };
     static flags = {
         ...base_1.projectFlag,
-        'status-id': core_1.Flags.string({ description: 'Target status lookup id', required: true }),
+        // Lo stato si scrive come lo si legge: `--status-id` resta come alias per gli script (CYCL-34).
+        status: core_1.Flags.string({
+            aliases: ['status-id'],
+            description: 'Target status code, label or id (e.g. in_review, "In Review")',
+            required: true,
+        }),
     };
     async run() {
         const { args, flags } = await this.parse(TicketsStatus);
         const projectId = await this.resolveProjectId(flags.project);
-        const res = await this.api.put(`/cli/v1/projects/${projectId}/tickets/${args.id}/status`, { status_id: flags['status-id'] });
+        const statusId = await this.resolveTicketLookupId(ticket_lookup_1.TICKET_STATUS, flags.status);
+        const res = await this.api.put(`/cli/v1/projects/${projectId}/tickets/${args.id}/status`, { status_id: statusId });
         if (!this.jsonEnabled()) {
             this.log(`Ticket ${args.id} status updated:`);
             this.log((0, output_1.renderRecord)(res.data ?? {}));

package/dist/commands/tickets/update.d.ts

@@ -6,6 +6,14 @@ export default class TicketsUpdate extends BaseCommand {
         id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
     };
     static flags: {
+        replace: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        clear: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'assignee-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'milestone-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'parent-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'platform-id': import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        status: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        priority: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         description: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'technical-analysis': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         scenarios: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
@@ -16,15 +24,26 @@ export default class TicketsUpdate extends BaseCommand {
         condition: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         weight: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'due-at': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        'status-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        'priority-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        'assignee-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        'milestone-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        'parent-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        'platform-id': import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         title: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         kind: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         project: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<unknown>;
+    /**
+     * Lo stato attuale del ticket, nella forma che la PUT si aspetta, per i soli campi che chi ha
+     * scritto il comando non ha già deciso. I campi vuoti restano fuori dal corpo: ometterli o
+     * mandarli a null è la stessa cosa, e il corpo resta leggibile.
+     */
+    private currentState;
+    /** Rifiuta `--clear x` insieme a `--x`: impostare e svuotare lo stesso campo è una richiesta ambigua. */
+    private refuseClearConflicts;
+    /** Id della voce di lookup che corrisponde all'etichetta mostrata dalla GET del ticket. */
+    private lookupId;
+    /**
+     * Una lookup non trovata o ambigua ferma il comando: proseguire manderebbe una PUT senza quel
+     * campo, cioè lo cancellerebbe in silenzio — il difetto che questo comando esiste per evitare.
+     */
+    private matchId;
+    /** Ogni pagina di un endpoint di lookup: la voce cercata può stare oltre la prima. */
+    private lookupRows;
 }

package/dist/commands/tickets/update.js

@@ -2,40 +2,175 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
 const base_1 = require("../../base");
+const limits_1 = require("../../lib/limits");
 const output_1 = require("../../lib/output");
 const ticket_body_1 = require("../../lib/ticket-body");
+const ticket_lookup_1 = require("../../lib/ticket-lookup");
+/** Campi che la GET del ticket restituisce già con la chiave e il valore attesi dalla PUT. */
+const PRESERVED_KEYS = ['title', 'kind', 'description', 'technical_analysis', 'weight', 'due_at', 'parent_id'];
 class TicketsUpdate extends base_1.BaseCommand {
-    // PUT /cli/v1/projects/:p/tickets/:id maps to Ticketing::UpdateTicket, a full replace:
-    // fields you omit are cleared server-side. Pass the complete desired state, not a partial patch.
-    static description = 'Update a ticket (full replace — fields you omit are cleared server-side)';
+    // PUT /cli/v1/projects/:p/tickets/:id maps to Ticketing::UpdateTicket, a full replace built for the
+    // web form, which always posts every field: whatever the body omits is cleared server-side, and
+    // status/priority are mandatory, so `--title` alone did not even go through ("Priority must exist")
+    // while a body carrying them silently emptied description, technical analysis, weight, due date,
+    // assignee, milestone and platforms (CYCL-30).
+    //
+    // The command now reads the ticket first and re-sends its current state under the flags you passed:
+    // what you do not name stays as it was. Emptying is a separate, explicit request (`--clear <field>`),
+    // and `--replace` keeps the raw full replace for callers that really do send the whole desired state.
+    //
+    // Scenarios and conditions stay out of the merge: the backend replaces them when the body carries
+    // new ones and leaves them untouched otherwise, so re-sending them would only risk duplicates.
+    //
+    // Known limit — the read and the write are not one atomic operation, and this endpoint offers no
+    // optimistic locking (no lock_version, no If-Match/ETag: the GET exposes nothing to send back),
+    // so an edit landing between them is overwritten by the state this command read. It cannot be
+    // fixed from the client alone, and it is strictly narrower than what it replaces: the full replace
+    // wiped those fields on EVERY call, concurrency or not, while here the exposure is the round trip.
+    // Closing it for good needs a server-side merge (or a version token to send back) — the fix the
+    // ticket calls the "server remedy".
+    static description = 'Update a ticket, changing only the fields you pass (the others keep their current value; use --clear to empty one, --replace for the raw full replace)';
     static examples = [
         '<%= config.bin %> tickets update <ticket-id> --project acme-api --title "New title"',
+        '<%= config.bin %> tickets update <ticket-id> -p acme-api --clear assignee --clear due-at',
         '<%= config.bin %> tickets update <ticket-id> -p acme-api --title "Login bug" --scenarios \'[{"step_given":"logged out","step_when":"I submit","step_then":"it 500s","step_expected":"dashboard loads"}]\' --condition "login works"',
+        '<%= config.bin %> tickets update <ticket-id> -p acme-api --status in_review --priority High',
+        '<%= config.bin %> tickets update <ticket-id> -p acme-api --replace --title "Only this" --status open --priority medium',
     ];
     static args = {
         id: core_1.Args.string({ description: 'Ticket id', required: true }),
     };
     static flags = {
         ...base_1.projectFlag,
-        title: core_1.Flags.string({ description: 'Ticket title' }),
+        title: core_1.Flags.string({ description: `Ticket title (max ${limits_1.LENGTH_LIMITS.title} characters)` }),
         kind: core_1.Flags.string({ description: 'Ticket kind (bug, story, task, epic)', options: ['bug', 'story', 'task', 'epic'] }),
         ...ticket_body_1.ticketBodyFlags,
+        ...ticket_body_1.clearFlag,
+        replace: core_1.Flags.boolean({
+            description: 'Send only the flags you passed (full replace — every field you omit is cleared server-side)',
+            default: false,
+        }),
     };
     async run() {
         const { args, flags } = await this.parse(TicketsUpdate);
         const projectId = await this.resolveProjectId(flags.project);
-        const body = {};
+        const path = `/cli/v1/projects/${encodeURIComponent(projectId)}/tickets/${encodeURIComponent(args.id)}`;
+        const requested = {};
         if (flags.title !== undefined)
-            body.title = flags.title;
+            requested.title = flags.title;
         if (flags.kind !== undefined)
-            body.kind = flags.kind;
-        (0, ticket_body_1.applyTicketBody)(body, flags);
-        const res = await this.api.put(`/cli/v1/projects/${projectId}/tickets/${args.id}`, body);
+            requested.kind = flags.kind;
+        (0, ticket_body_1.applyTicketBody)(requested, flags);
+        // Cambiare stato o priorità non costringe più a cercarne prima l'id: il code o l'etichetta
+        // bastano, e un id passa così com'è (CYCL-34).
+        if (flags.status !== undefined) {
+            requested.status_id = await this.resolveTicketLookupId(ticket_lookup_1.TICKET_STATUS, flags.status);
+        }
+        if (flags.priority !== undefined) {
+            requested.priority_id = await this.resolveTicketLookupId(ticket_lookup_1.TICKET_PRIORITY, flags.priority);
+        }
+        this.refuseClearConflicts(requested, flags.clear);
+        (0, ticket_body_1.applyTicketClears)(requested, flags.clear);
+        let body = requested;
+        if (!flags.replace) {
+            const ticket = (await this.api.get(path)).data ?? {};
+            // I campi troppo lunghi si scoprono qui, tutti insieme, invece che uno per rifiuto (CYCL-32).
+            // Il valore attuale fa da salvaguardia: un testo scritto prima che il tetto esistesse resta
+            // correggibile finché non si allunga, com'è dal server. Con `--replace` lo stato attuale non
+            // si legge, quindi la salvaguardia non è calcolabile e la misura resta al server.
+            const tooLong = (0, limits_1.tooLongMessage)((0, ticket_body_1.ticketLengthChecks)(flags, ticket));
+            if (tooLong)
+                this.error(tooLong, { exit: 2 });
+            body = { ...(await this.currentState(projectId, ticket, requested)), ...requested };
+        }
+        const res = await this.api.put(path, body);
         if (!this.jsonEnabled()) {
             this.log('Ticket updated:');
             this.log((0, output_1.renderRecord)(res.data ?? {}));
         }
         return res;
     }
+    /**
+     * Lo stato attuale del ticket, nella forma che la PUT si aspetta, per i soli campi che chi ha
+     * scritto il comando non ha già deciso. I campi vuoti restano fuori dal corpo: ometterli o
+     * mandarli a null è la stessa cosa, e il corpo resta leggibile.
+     */
+    async currentState(projectId, ticket, requested) {
+        const current = {};
+        for (const key of PRESERVED_KEYS) {
+            const value = ticket[key];
+            if (key in requested || value === null || value === undefined || value === '')
+                continue;
+            current[key] = value;
+        }
+        // Status e priorità sono obbligatorie per il backend: senza di loro l'update non passa. La GET
+        // espone l'id dello status, mentre della priorità dà solo l'etichetta, da rileggere nella lookup.
+        if (!('status_id' in requested)) {
+            const statusId = ticket.status_ref?.id;
+            if (typeof statusId !== 'string' || statusId === '') {
+                this.error('Cannot read the current status of this ticket: pass --status <code|label|id> or use --replace.', {
+                    exit: 2,
+                });
+            }
+            current.status_id = statusId;
+        }
+        if (!('priority_id' in requested)) {
+            current.priority_id = await this.lookupId(ticket_lookup_1.TICKET_PRIORITY.path, ticket.priority, 'priority', '--priority');
+        }
+        if (!('assignee_id' in requested) && ticket.assignee) {
+            current.assignee_id = await this.lookupId('/cli/v1/members', ticket.assignee, 'assignee', '--assignee-id', 'account_id');
+        }
+        if (!('milestone_id' in requested) && ticket.milestone) {
+            const milestones = `/cli/v1/projects/${encodeURIComponent(projectId)}/milestones`;
+            current.milestone_id = await this.lookupId(milestones, ticket.milestone, 'milestone', '--milestone-id');
+        }
+        const platforms = Array.isArray(ticket.platforms) ? ticket.platforms : [];
+        if (!('platform_ids' in requested) && platforms.length > 0) {
+            const rows = await this.lookupRows('/cli/v1/platforms');
+            current.platform_ids = platforms.map((platform) => this.matchId(rows, platform, 'platform', '--platform-id'));
+        }
+        return current;
+    }
+    /** Rifiuta `--clear x` insieme a `--x`: impostare e svuotare lo stesso campo è una richiesta ambigua. */
+    refuseClearConflicts(requested, fields) {
+        for (const field of fields ?? []) {
+            if (ticket_body_1.CLEARABLE_FIELDS[field] in requested) {
+                this.error(`--clear ${field} conflicts with the value passed for the same field: pick one.`, { exit: 2 });
+            }
+        }
+    }
+    /** Id della voce di lookup che corrisponde all'etichetta mostrata dalla GET del ticket. */
+    async lookupId(path, label, field, flag, idKey = 'id') {
+        const rows = await this.lookupRows(path);
+        return this.matchId(rows, label, field, flag, idKey);
+    }
+    /**
+     * Una lookup non trovata o ambigua ferma il comando: proseguire manderebbe una PUT senza quel
+     * campo, cioè lo cancellerebbe in silenzio — il difetto che questo comando esiste per evitare.
+     */
+    matchId(rows, label, field, flag, idKey = 'id') {
+        const wanted = String(label ?? '').toLowerCase();
+        const matches = rows.filter((row) => [row.label, row.code, row.name].some((value) => typeof value === 'string' && value.toLowerCase() === wanted));
+        if (matches.length !== 1 || typeof matches[0][idKey] !== 'string') {
+            const reason = matches.length > 1 ? `${matches.length} entries match it` : 'no entry matches it';
+            this.error(`Cannot keep the current ${field} "${String(label ?? '')}": ${reason}. Pass ${flag} <id> or use --replace.`, { exit: 2 });
+        }
+        return matches[0][idKey];
+    }
+    /** Ogni pagina di un endpoint di lookup: la voce cercata può stare oltre la prima. */
+    async lookupRows(path) {
+        const rows = [];
+        const separator = path.includes('?') ? '&' : '?';
+        let page = 1;
+        let totalPages = 1;
+        do {
+            // eslint-disable-next-line no-await-in-loop
+            const res = await this.api.get(`${path}${separator}page=${page}&per=100`);
+            rows.push(...(Array.isArray(res.data) ? res.data : []));
+            totalPages = Number(res.meta?.total_pages ?? 1);
+            page += 1;
+        } while (page <= totalPages);
+        return rows;
+    }
 }
 exports.default = TicketsUpdate;

package/dist/commands/whoami.js

@@ -5,6 +5,9 @@ class Whoami extends base_1.BaseCommand {
     static description = 'Show the authenticated account, organization, token prefix and permissions';
     static examples = ['<%= config.bin %> whoami', '<%= config.bin %> whoami --json'];
     async run() {
+        // Nothing to read from the parser, but oclif validates the command line only here: without this
+        // call a mistyped flag is silently ignored and the command answers as if it were right (CYCL-33).
+        await this.parse(Whoami);
         const res = await this.api.get('/cli/v1/whoami');
         // Rebuild from an allow-list. If a future backend accidentally includes a token secret or other
         // authentication internals, `--json` must not proxy them to stdout.

package/dist/errors/error-codes.d.ts

@@ -25,10 +25,19 @@ export declare const ErrorCodes: {
     readonly Member: {
         readonly notFound: "C404-MBR-001";
     };
+    readonly TicketStatus: {
+        readonly notFound: "C404-STA-001";
+    };
+    readonly TicketPriority: {
+        readonly notFound: "C404-PRI-001";
+    };
     readonly Device: {
         readonly expired: "C408-DEV-001";
         readonly failed: "C400-DEV-002";
     };
+    readonly Input: {
+        readonly invalid: "C400-INP-001";
+    };
     readonly System: {
         readonly unexpected: "C500-SYS-001";
     };

package/dist/errors/error-codes.js

@@ -30,10 +30,24 @@ exports.ErrorCodes = {
     Member: {
         notFound: 'C404-MBR-001',
     },
+    // Stato e priorità di un ticket, indicati per code o etichetta e non trovati nelle lookup
+    // dell'organizzazione (o corrispondenti a più di una voce) — CYCL-34.
+    TicketStatus: {
+        notFound: 'C404-STA-001',
+    },
+    TicketPriority: {
+        notFound: 'C404-PRI-001',
+    },
     Device: {
         expired: 'C408-DEV-001',
         failed: 'C400-DEV-002',
     },
+    // The command line itself was rejected (missing/unknown flag or arg, value outside the allowed
+    // options, a `this.error(...)` guard): the message says what to fix, and it never reached the
+    // server — the opposite of System.unexpected, which stays for real failures (CYCL-33).
+    Input: {
+        invalid: 'C400-INP-001',
+    },
     System: {
         unexpected: 'C500-SYS-001',
     },

package/dist/errors/input-error.d.ts

@@ -0,0 +1,16 @@
+/**
+ * True for the failures oclif has already worded for whoever typed the command: a parse/validation
+ * error (missing required flag or arg, nonexistent flag, value outside the allowed options) and the
+ * `this.error(...)` guards inside a command (`--confirm` missing, nothing to update, file unreadable).
+ *
+ * Deliberately NOT input errors, although both extend `CLIError`:
+ *  - `ExitError`, thrown by `this.exit(code)` — `cyi run` uses it to propagate the child exit code;
+ *  - `ModuleLoadError`, which is a real internal failure and keeps the generic system code.
+ */
+export declare function isInputError(error: unknown): error is Error;
+/**
+ * Flatten oclif's multi-line, ANSI-decorated message into the single line a JSON consumer reads:
+ * `The following error occurred:\n  Missing required flag project\nSee more help with --help`
+ * becomes `Missing required flag project` (CYCL-33).
+ */
+export declare function inputErrorMessage(error: Error): string;

package/dist/errors/input-error.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInputError = isInputError;
+exports.inputErrorMessage = inputErrorMessage;
+const core_1 = require("@oclif/core");
+/** oclif dims parts of a parse error with ANSI when the terminal has colors; machine output must not. */
+const ANSI = /\x1B\[[\d;]*m/g;
+/** Every parse error ends with this hint, and multi-reason ones open with a header line. */
+const HELP_HINT = 'See more help with --help';
+const HEADER = /^The following errors? occurred:$/;
+/**
+ * True for the failures oclif has already worded for whoever typed the command: a parse/validation
+ * error (missing required flag or arg, nonexistent flag, value outside the allowed options) and the
+ * `this.error(...)` guards inside a command (`--confirm` missing, nothing to update, file unreadable).
+ *
+ * Deliberately NOT input errors, although both extend `CLIError`:
+ *  - `ExitError`, thrown by `this.exit(code)` — `cyi run` uses it to propagate the child exit code;
+ *  - `ModuleLoadError`, which is a real internal failure and keeps the generic system code.
+ */
+function isInputError(error) {
+    if (!(error instanceof core_1.Errors.CLIError))
+        return false;
+    return !(error instanceof core_1.Errors.ExitError) && !(error instanceof core_1.Errors.ModuleLoadError);
+}
+/**
+ * Flatten oclif's multi-line, ANSI-decorated message into the single line a JSON consumer reads:
+ * `The following error occurred:\n  Missing required flag project\nSee more help with --help`
+ * becomes `Missing required flag project` (CYCL-33).
+ */
+function inputErrorMessage(error) {
+    const plain = error.message.replace(ANSI, '');
+    const lines = plain
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line !== '' && line !== HELP_HINT && !HEADER.test(line));
+    // Only noise (a bare hint, or an empty message): keep whatever the error carried rather than nothing.
+    if (lines.length === 0)
+        return plain.trim();
+    // A line ending in `:` introduces the next one ("Missing 1 required arg:" + the arg itself);
+    // anything else is a reason of its own ("Missing required flag environment" + "…flag project").
+    return lines.reduce((acc, line) => (acc.endsWith(':') ? `${acc} ${line}` : `${acc}; ${line}`));
+}

package/dist/lib/alert-events.d.ts

@@ -1,2 +1,9 @@
-/** Event types accepted by alert rules — mirror of the backend enum (Alerting::Rule). */
+/**
+ * Event types accepted by alert rules — mirror of the backend enum (Alerting::Rule).
+ *
+ * CYRA-519: the list had stopped at the first fifteen, so `--event-type` rejected every type added
+ * since (containers, replication, inodes, automation, vulnerabilities…) — the flag looked broken
+ * while the backend accepted them. Keep this in the same order as the backend enum: appending there
+ * means appending here.
+ */
 export declare const ALERT_EVENT_TYPES: string[];