cawplan 0.0.0

package/dist/commands/products.js

@@ -0,0 +1,100 @@
+import { cawplanRequest } from "../lib/http.js";
+import { getCache, setCache, buildScopedCacheKey, buildQueryFromFlags } from "../lib/cache.js";
+export function registerProductsCommand(program) {
+    const products = program.command("products").description("Manage products");
+    products
+        .command("list")
+        .description("List all products")
+        .option("--search <q>", "Search query")
+        .option("--page_size <n>", "Page size")
+        .option("--page_num <n>", "Page number")
+        .option("--type_id <id>", "Filter by type ID")
+        .option("--product_line_id <id>", "Filter by product line ID")
+        .option("--refresh", "Bypass cache")
+        .action(async (opts) => {
+        const flags = {};
+        if (opts.search)
+            flags.search = opts.search;
+        if (opts.page_size)
+            flags.page_size = opts.page_size;
+        if (opts.page_num)
+            flags.page_num = opts.page_num;
+        if (opts.type_id)
+            flags.type_id = opts.type_id;
+        if (opts.product_line_id)
+            flags.product_line_id = opts.product_line_id;
+        const refresh = Boolean(opts.refresh);
+        const query = buildQueryFromFlags(flags, ["search", "page_size", "page_num", "type_id", "product_line_id"]);
+        const key = await buildScopedCacheKey("products:list", query);
+        const cached = getCache(key, refresh);
+        if (cached) {
+            console.log(JSON.stringify(cached, null, 2));
+            return;
+        }
+        const result = await cawplanRequest({
+            method: "GET",
+            path: "/api/v1/public/openapi/products",
+            query,
+        });
+        setCache(key, result);
+        console.log(JSON.stringify(result, null, 2));
+    });
+    const productLines = program.command("product-lines").description("Manage product lines");
+    productLines
+        .command("list")
+        .description("List all product lines")
+        .option("--page_size <n>", "Page size")
+        .option("--page_num <n>", "Page number")
+        .option("--refresh", "Bypass cache")
+        .action(async (opts) => {
+        const flags = {};
+        if (opts.page_size)
+            flags.page_size = opts.page_size;
+        if (opts.page_num)
+            flags.page_num = opts.page_num;
+        const refresh = Boolean(opts.refresh);
+        const query = buildQueryFromFlags(flags, ["page_size", "page_num"]);
+        const key = await buildScopedCacheKey("product-lines:list", query);
+        const cached = getCache(key, refresh);
+        if (cached) {
+            console.log(JSON.stringify(cached, null, 2));
+            return;
+        }
+        const result = await cawplanRequest({
+            method: "GET",
+            path: "/api/v1/public/openapi/product_lines",
+            query,
+        });
+        setCache(key, result);
+        console.log(JSON.stringify(result, null, 2));
+    });
+    productLines
+        .command("get <product_line_id>")
+        .description("Get product line details")
+        .option("--refresh", "Bypass cache")
+        .action(async (productLineId, opts) => {
+        const refresh = Boolean(opts.refresh);
+        const key = await buildScopedCacheKey(`product-lines:detail:${productLineId}`, undefined);
+        const cached = getCache(key, refresh);
+        if (cached) {
+            console.log(JSON.stringify(cached, null, 2));
+            return;
+        }
+        const result = await cawplanRequest({
+            method: "GET",
+            path: `/api/v1/public/openapi/product_lines/${productLineId}`,
+        });
+        setCache(key, result);
+        console.log(JSON.stringify(result, null, 2));
+    });
+    productLines
+        .command("statuses <product_line_id>")
+        .description("Get ticket statuses for a product line")
+        .action(async (productLineId) => {
+        const result = await cawplanRequest({
+            method: "GET",
+            path: `/api/v1/public/openapi/product_lines/${productLineId}/ticket_statuses`,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+}

package/dist/commands/qa-reports.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerQAReportsCommand(program: Command): void;

package/dist/commands/qa-reports.js

@@ -0,0 +1,71 @@
+import { cawplanRequest } from "../lib/http.js";
+import { buildQueryFromFlags } from "../lib/cache.js";
+export function registerQAReportsCommand(program) {
+    const qa = program.command("qa-reports").description("QA reports");
+    qa
+        .command("list <product_id>")
+        .description("List QA reports for a product, grouped by version")
+        .option("--type <type>", "Report type: sqa|aqa|stress|performance|smoke")
+        .option("--result <r>", "Result: pass|pass_with_issues|failed")
+        .option("--status <s>", "Status filter")
+        .option("--page_size <n>", "Page size (max 100)")
+        .option("--page_num <n>", "Page number")
+        .action(async (productId, opts) => {
+        const flags = {};
+        if (opts.type)
+            flags.type = opts.type;
+        if (opts.result)
+            flags.result = opts.result;
+        if (opts.status)
+            flags.status = opts.status;
+        if (opts.page_size)
+            flags.page_size = opts.page_size;
+        if (opts.page_num)
+            flags.page_num = opts.page_num;
+        const query = buildQueryFromFlags(flags, ["type", "result", "status", "page_size", "page_num"]);
+        const result = await cawplanRequest({
+            method: "GET",
+            path: `/api/v1/public/openapi/product/${productId}/qa_report`,
+            query,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+    qa
+        .command("list-version <product_id> <version_id>")
+        .description("List QA reports for a specific version")
+        .option("--type <type>", "Report type: sqa|aqa|stress|performance|smoke")
+        .option("--result <r>", "Result: pass|pass_with_issues|failed")
+        .option("--status <s>", "Status filter")
+        .option("--page_size <n>", "Page size (max 100)")
+        .option("--page_num <n>", "Page number")
+        .action(async (productId, versionId, opts) => {
+        const flags = {};
+        if (opts.type)
+            flags.type = opts.type;
+        if (opts.result)
+            flags.result = opts.result;
+        if (opts.status)
+            flags.status = opts.status;
+        if (opts.page_size)
+            flags.page_size = opts.page_size;
+        if (opts.page_num)
+            flags.page_num = opts.page_num;
+        const query = buildQueryFromFlags(flags, ["type", "result", "status", "page_size", "page_num"]);
+        const result = await cawplanRequest({
+            method: "GET",
+            path: `/api/v1/public/openapi/product/${productId}/versions/${versionId}/qa_report`,
+            query,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+    qa
+        .command("get <product_id> <version_id> <qa_report_id>")
+        .description("Get a specific QA report by ID")
+        .action(async (productId, versionId, qaReportId) => {
+        const result = await cawplanRequest({
+            method: "GET",
+            path: `/api/v1/public/openapi/product/${productId}/versions/${versionId}/qa_report/${qaReportId}`,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+}

package/dist/commands/tickets.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerTicketsCommand(program: Command): void;

package/dist/commands/tickets.js

@@ -0,0 +1,431 @@
+import { cawplanRequest } from "../lib/http.js";
+import { getCache, setCache, buildCacheKey, buildScopedCacheKey, buildQueryFromFlags, csvToArray, stableStringify } from "../lib/cache.js";
+import { resolveApiPath } from "../lib/products.js";
+export function registerTicketsCommand(program) {
+    const tickets = program.command("tickets").description("Manage tickets");
+    tickets
+        .command("list <product_id> <version_id>")
+        .description("List tickets for a version")
+        .requiredOption("--type <type>", "Ticket type: FEATURE|BUGFIX")
+        .option("--page_size <n>", "Page size")
+        .option("--page_num <n>", "Page number")
+        .action(async (productId, versionId, opts) => {
+        const flags = { type: opts.type };
+        if (opts.page_size)
+            flags.page_size = opts.page_size;
+        if (opts.page_num)
+            flags.page_num = opts.page_num;
+        const query = buildQueryFromFlags(flags, ["type", "page_size", "page_num"]);
+        const result = await cawplanRequest({
+            method: "GET",
+            path: `/api/v1/public/openapi/product/${productId}/versions/${versionId}/tickets`,
+            query,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+    tickets
+        .command("poll")
+        .description("Poll tickets by status across products")
+        .requiredOption("--status <csv>", "Ticket statuses (CSV)")
+        .option("--product_ids <csv>", "Product IDs (CSV)")
+        .option("--product_line_ids <csv>", "Product line IDs (CSV)")
+        .option("--since_updated_at <ts>", "Unix timestamp filter")
+        .option("--page_size <n>", "Page size")
+        .option("--page_num <n>", "Page number")
+        .action(async (opts) => {
+        const status = csvToArray(opts.status);
+        if (!status) {
+            console.error("Error: tickets poll requires --status CSV");
+            process.exit(1);
+        }
+        const body = { status };
+        const productIds = csvToArray(opts.product_ids);
+        const productLineIds = csvToArray(opts.product_line_ids);
+        if (productIds)
+            body.product_ids = productIds;
+        if (productLineIds)
+            body.product_line_ids = productLineIds;
+        if (opts.since_updated_at !== undefined)
+            body.since_updated_at = Number(opts.since_updated_at);
+        if (opts.page_num !== undefined)
+            body.page_num = Number(opts.page_num);
+        if (opts.page_size !== undefined)
+            body.page_size = Number(opts.page_size);
+        const result = await cawplanRequest({
+            method: "POST",
+            path: resolveApiPath("/api/v1/public/openapi/tickets/poll"),
+            body,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+    tickets
+        .command("search")
+        .description("Search tickets")
+        .option("--time_range <range>", "Time range (e.g. 1m, 3m)")
+        .option("--start_date <date>", "Start date YYYY-MM-DD")
+        .option("--end_date <date>", "End date YYYY-MM-DD")
+        .option("--product_ids <csv>", "Product IDs")
+        .option("--product_line_ids <csv>", "Product line IDs")
+        .option("--version_ids <csv>", "Version IDs")
+        .option("--unique_ids <csv>", "Ticket unique IDs")
+        .option("--display_ids <csv>", "Ticket display IDs")
+        .option("--parent_ids <csv>", "Parent ticket IDs")
+        .option("--type <csv>", "Ticket types")
+        .option("--status <csv>", "Ticket statuses")
+        .option("--priority <csv>", "Priorities")
+        .option("--platform <csv>", "Platforms")
+        .option("--assignees <csv>", "Assignees")
+        .option("--search <q>", "Search query")
+        .option("--page_size <n>", "Page size")
+        .option("--page_num <n>", "Page number")
+        .option("--refresh", "Bypass cache")
+        .action(async (opts) => {
+        const uniqueIds = csvToArray(opts.unique_ids);
+        const displayIds = csvToArray(opts.display_ids);
+        const parentIds = csvToArray(opts.parent_ids);
+        const idLookup = Boolean(uniqueIds || displayIds || parentIds);
+        if (!idLookup && !opts.time_range && !(opts.start_date && opts.end_date)) {
+            console.error("Error: tickets search requires --time_range or --start_date + --end_date (unless --unique_ids/--display_ids/--parent_ids is set)");
+            process.exit(1);
+        }
+        const refresh = Boolean(opts.refresh);
+        const flags = {};
+        if (opts.time_range)
+            flags.time_range = opts.time_range;
+        if (opts.start_date)
+            flags.start_date = opts.start_date;
+        if (opts.end_date)
+            flags.end_date = opts.end_date;
+        if (opts.page_size)
+            flags.page_size = opts.page_size;
+        if (opts.page_num)
+            flags.page_num = opts.page_num;
+        const query = buildQueryFromFlags(flags, ["time_range", "start_date", "end_date", "page_size", "page_num"]);
+        const body = {};
+        const productIds = csvToArray(opts.product_ids);
+        const productLineIds = csvToArray(opts.product_line_ids);
+        const versionIds = csvToArray(opts.version_ids);
+        const type = csvToArray(opts.type);
+        const status = csvToArray(opts.status);
+        const priority = csvToArray(opts.priority);
+        const platform = csvToArray(opts.platform);
+        const assignees = csvToArray(opts.assignees);
+        if (productIds)
+            body.product_ids = productIds;
+        if (productLineIds)
+            body.product_line_ids = productLineIds;
+        if (versionIds)
+            body.version_ids = versionIds;
+        if (uniqueIds)
+            body.unique_ids = uniqueIds;
+        if (displayIds)
+            body.display_ids = displayIds;
+        if (parentIds)
+            body.parent_ids = parentIds;
+        if (type)
+            body.type = type;
+        if (status)
+            body.status = status;
+        if (priority)
+            body.priority = priority;
+        if (platform)
+            body.platform = platform;
+        if (assignees)
+            body.assignees = assignees;
+        if (opts.search)
+            body.search = opts.search;
+        const key = await buildScopedCacheKey(`tickets:search:${buildCacheKey("query", query)}|body=${stableStringify(body)}`, undefined);
+        const cached = getCache(key, refresh);
+        if (cached) {
+            console.log(JSON.stringify(cached, null, 2));
+            return;
+        }
+        const result = await cawplanRequest({
+            method: "POST",
+            path: resolveApiPath("/api/v1/public/openapi/tickets/search"),
+            query,
+            body,
+        });
+        setCache(key, result);
+        console.log(JSON.stringify(result, null, 2));
+    });
+    tickets
+        .command("batch-create <product_id>")
+        .description("Batch-create tickets under a product")
+        .requiredOption("--tickets <json>", "JSON array of ticket objects")
+        .action(async (productId, opts) => {
+        let tickets;
+        try {
+            tickets = JSON.parse(opts.tickets);
+            if (!Array.isArray(tickets))
+                throw new Error("must be an array");
+        }
+        catch (e) {
+            console.error(`Error: --tickets must be a valid JSON array: ${e.message}`);
+            process.exit(1);
+        }
+        const result = await cawplanRequest({
+            method: "POST",
+            path: `/api/v1/public/openapi/product/${productId}/tickets/batch`,
+            body: { tickets },
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+    tickets
+        .command("create-version <product_id> <version_id>")
+        .description("Create a version ticket")
+        .requiredOption("--description <text>", "Ticket description")
+        .option("--type <type>", "Ticket type: FEATURE|BUGFIX")
+        .option("--priority <p>", "Priority: LOW|MEDIUM|HIGH|CRITICAL")
+        .option("--status <key>", "Status key")
+        .option("--assignees <csv>", "Assignee IDs (CSV)")
+        .option("--parent_id <id>", "Parent ticket ID")
+        .option("--label_ids <csv>", "Label IDs (CSV)")
+        .option("--reporter_id <id>", "Reporter user ID")
+        .option("--due_date <date>", "Due date YYYY-MM-DD")
+        .option("--comment <text>", "Comment")
+        .action(async (productId, versionId, opts) => {
+        const body = { description: opts.description };
+        if (opts.type)
+            body.type = opts.type;
+        if (opts.priority)
+            body.priority = opts.priority;
+        if (opts.status)
+            body.status = opts.status;
+        if (opts.parent_id)
+            body.parent_id = opts.parent_id;
+        if (opts.reporter_id)
+            body.reporter_id = opts.reporter_id;
+        if (opts.due_date)
+            body.due_date = opts.due_date;
+        if (opts.comment)
+            body.comment = opts.comment;
+        const assignees = csvToArray(opts.assignees);
+        if (assignees)
+            body.assignee_ids = assignees;
+        const labelIds = csvToArray(opts.label_ids);
+        if (labelIds)
+            body.label_ids = labelIds;
+        const result = await cawplanRequest({
+            method: "POST",
+            path: `/api/v1/public/openapi/product/${productId}/versions/${versionId}/tickets`,
+            body,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+    tickets
+        .command("create-backlog <product_id>")
+        .description("Create a backlog ticket (not assigned to any version)")
+        .requiredOption("--description <text>", "Ticket description")
+        .option("--type <type>", "Ticket type: FEATURE|BUGFIX")
+        .option("--priority <p>", "Priority: LOW|MEDIUM|HIGH|CRITICAL")
+        .option("--status <key>", "Status key")
+        .option("--assignees <csv>", "Assignee IDs (CSV)")
+        .option("--parent_id <id>", "Parent ticket ID")
+        .option("--label_ids <csv>", "Label IDs (CSV)")
+        .option("--reporter_id <id>", "Reporter user ID")
+        .option("--due_date <date>", "Due date YYYY-MM-DD")
+        .option("--comment <text>", "Comment")
+        .action(async (productId, opts) => {
+        const body = { description: opts.description };
+        if (opts.type)
+            body.type = opts.type;
+        if (opts.priority)
+            body.priority = opts.priority;
+        if (opts.status)
+            body.status = opts.status;
+        if (opts.parent_id)
+            body.parent_id = opts.parent_id;
+        if (opts.reporter_id)
+            body.reporter_id = opts.reporter_id;
+        if (opts.due_date)
+            body.due_date = opts.due_date;
+        if (opts.comment)
+            body.comment = opts.comment;
+        const assignees = csvToArray(opts.assignees);
+        if (assignees)
+            body.assignee_ids = assignees;
+        const labelIds = csvToArray(opts.label_ids);
+        if (labelIds)
+            body.label_ids = labelIds;
+        const result = await cawplanRequest({
+            method: "POST",
+            path: `/api/v1/public/openapi/product/${productId}/tickets`,
+            body,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+    tickets
+        .command("update <product_id> <version_id> <ticket_id>")
+        .description("Update a ticket")
+        .option("--status <key>", "Status key")
+        .option("--progress_comment <text>", "Progress comment")
+        .option("--priority <p>", "Priority")
+        .option("--description <text>", "Description")
+        .option("--comment <text>", "Comment")
+        .option("--parent_id <id>", "Parent ticket ID")
+        .option("--due_date <date>", "Due date YYYY-MM-DD")
+        .option("--assignees <csv>", "Assignee IDs (CSV)")
+        .option("--label_ids <csv>", "Label IDs (CSV)")
+        .option("--expected_version <n>", "Optimistic lock version")
+        .action(async (productId, versionId, ticketId, opts) => {
+        const body = {};
+        if (opts.status)
+            body.status = opts.status;
+        if (opts.progress_comment !== undefined)
+            body.progress_comment = opts.progress_comment;
+        if (opts.priority)
+            body.priority = opts.priority;
+        if (opts.description !== undefined)
+            body.description = opts.description;
+        if (opts.comment !== undefined)
+            body.comment = opts.comment;
+        if (opts.parent_id)
+            body.parent_id = opts.parent_id;
+        if (opts.due_date)
+            body.due_date = opts.due_date;
+        const assignees = csvToArray(opts.assignees);
+        if (assignees)
+            body.assignee_ids = assignees;
+        const labelIds = csvToArray(opts.label_ids);
+        if (labelIds)
+            body.label_ids = labelIds;
+        const hasExpectedVersion = opts.expected_version !== undefined;
+        if (hasExpectedVersion)
+            body.version = Number(opts.expected_version);
+        if (Object.keys(body).length === 0) {
+            console.error("Error: tickets update requires at least one updatable flag");
+            process.exit(1);
+        }
+        try {
+            const result = await cawplanRequest({
+                method: "PUT",
+                path: `/api/v1/public/openapi/product/${productId}/versions/${versionId}/tickets/${ticketId}`,
+                body,
+            });
+            console.log(JSON.stringify(result, null, 2));
+        }
+        catch (err) {
+            const apiErr = err;
+            if (hasExpectedVersion && apiErr?.status === 409) {
+                console.error(`Conflict: ticket was modified since version ${opts.expected_version}. Re-read and retry with the latest --expected_version.`);
+                process.exit(1);
+            }
+            throw err;
+        }
+    });
+    // Ticket relations sub-commands
+    const relate = tickets.command("relate").description("Manage ticket relations");
+    relate
+        .command("create <product_id> <version_id> <ticket_id>")
+        .description("Create a relation")
+        .requiredOption("--target <ticket_uid>", "Target ticket UID")
+        .requiredOption("--type <type>", "Relation type: RELATED|BLOCKING|BLOCKED_BY|DUPLICATE")
+        .action(async (productId, versionId, ticketId, opts) => {
+        const result = await cawplanRequest({
+            method: "POST",
+            path: `/api/v1/public/openapi/product/${productId}/versions/${versionId}/tickets/${ticketId}/relations`,
+            body: { target_ticket_id: opts.target, relation_type: opts.type },
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+    relate
+        .command("update <product_id> <version_id> <ticket_id> <relation_id>")
+        .description("Update a relation")
+        .requiredOption("--type <type>", "Relation type")
+        .action(async (productId, versionId, ticketId, relationId, opts) => {
+        const result = await cawplanRequest({
+            method: "PUT",
+            path: `/api/v1/public/openapi/product/${productId}/versions/${versionId}/tickets/${ticketId}/relations/${relationId}`,
+            body: { relation_type: opts.type },
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+    relate
+        .command("delete <product_id> <version_id> <ticket_id> <relation_id>")
+        .description("Delete a relation")
+        .action(async (productId, versionId, ticketId, relationId) => {
+        const result = await cawplanRequest({
+            method: "DELETE",
+            path: `/api/v1/public/openapi/product/${productId}/versions/${versionId}/tickets/${ticketId}/relations/${relationId}`,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+    relate
+        .command("list <product_id> <version_id> <ticket_id>")
+        .description("List relations for a ticket")
+        .action(async (productId, versionId, ticketId) => {
+        const result = await cawplanRequest({
+            method: "GET",
+            path: `/api/v1/public/openapi/product/${productId}/versions/${versionId}/tickets/${ticketId}/relations`,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+    // Backlog commands
+    const backlog = program.command("backlog").description("Manage product backlog");
+    backlog
+        .command("list <product_id>")
+        .description("List backlog tickets")
+        .option("--page_size <n>", "Page size")
+        .option("--page_num <n>", "Page number")
+        .action(async (productId, opts) => {
+        const flags = {};
+        if (opts.page_size)
+            flags.page_size = opts.page_size;
+        if (opts.page_num)
+            flags.page_num = opts.page_num;
+        const query = buildQueryFromFlags(flags, ["page_size", "page_num"]);
+        const result = await cawplanRequest({
+            method: "GET",
+            path: `/api/v1/public/openapi/product/${productId}/tickets`,
+            query,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+    backlog
+        .command("get <product_id> <ticket_id>")
+        .description("Get a backlog ticket")
+        .action(async (productId, ticketId) => {
+        const result = await cawplanRequest({
+            method: "GET",
+            path: `/api/v1/public/openapi/product/${productId}/tickets/${ticketId}`,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+    // Labels
+    const labels = program.command("labels").description("Manage labels");
+    labels
+        .command("list")
+        .description("List labels")
+        .option("--search <q>", "Search query")
+        .option("--product_id <id>", "Filter by product ID")
+        .option("--page_size <n>", "Page size")
+        .option("--page_num <n>", "Page number")
+        .option("--refresh", "Bypass cache")
+        .action(async (opts) => {
+        const flags = {};
+        if (opts.search)
+            flags.search = opts.search;
+        if (opts.product_id)
+            flags.product_id = opts.product_id;
+        if (opts.page_size)
+            flags.page_size = opts.page_size;
+        if (opts.page_num)
+            flags.page_num = opts.page_num;
+        const refresh = Boolean(opts.refresh);
+        const query = buildQueryFromFlags(flags, ["search", "product_id", "page_size", "page_num"]);
+        const key = await buildScopedCacheKey("labels:list", query);
+        const cached = getCache(key, refresh);
+        if (cached) {
+            console.log(JSON.stringify(cached, null, 2));
+            return;
+        }
+        const result = await cawplanRequest({
+            method: "GET",
+            path: "/api/v1/public/openapi/labels",
+            query,
+        });
+        setCache(key, result);
+        console.log(JSON.stringify(result, null, 2));
+    });
+}

package/dist/commands/todos.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerTodosCommand(program: Command): void;

package/dist/commands/todos.js

@@ -0,0 +1,24 @@
+import { cawplanRequest } from "../lib/http.js";
+import { buildQueryFromFlags } from "../lib/cache.js";
+export function registerTodosCommand(program) {
+    const todos = program.command("todos").description("Manage todos");
+    todos
+        .command("user <user_id>")
+        .description("Get todos for a user")
+        .option("--ticket_status <csv>", "Ticket status filter (CSV)")
+        .option("--issue_status <csv>", "Issue status filter (CSV)")
+        .action(async (userId, opts) => {
+        const flags = {};
+        if (opts.ticket_status)
+            flags.ticket_status = opts.ticket_status;
+        if (opts.issue_status)
+            flags.issue_status = opts.issue_status;
+        const query = buildQueryFromFlags(flags, ["ticket_status", "issue_status"]);
+        const result = await cawplanRequest({
+            method: "GET",
+            path: `/api/v1/public/openapi/todos/users/${userId}`,
+            query,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+}

package/dist/commands/user-activity.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerUserActivityCommand(program: Command): void;

package/dist/commands/user-activity.js

@@ -0,0 +1,31 @@
+import { cawplanRequest } from "../lib/http.js";
+export function registerUserActivityCommand(program) {
+    const userActivity = program.command("user-activity").description("User activity reports");
+    userActivity
+        .command("get")
+        .description("Get user activity report")
+        .option("--user_id <id>", "User ID")
+        .option("--email <email>", "User email (exact match)")
+        .requiredOption("--start <date>", "Start date YYYY-MM-DD")
+        .requiredOption("--end <date>", "End date YYYY-MM-DD")
+        .action(async (opts) => {
+        if (!opts.user_id && !opts.email) {
+            console.error("Error: user-activity get requires --user_id or --email");
+            process.exit(1);
+        }
+        const query = {
+            start_date: opts.start,
+            end_date: opts.end,
+        };
+        if (opts.user_id)
+            query.user_id = opts.user_id;
+        if (opts.email)
+            query.email = opts.email;
+        const result = await cawplanRequest({
+            method: "GET",
+            path: "/api/v1/public/openapi/user-report",
+            query,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+}