cawplan 0.0.0

package/config/products.json

@@ -0,0 +1,17 @@
+{
+  "products": {
+    "cawplan": {
+      "displayName": "CawPlan",
+      "cliName": "cawplan",
+      "oauthEndpoint": "cawplan-cli",
+      "credentialsDir": ".cawplan",
+      "defaultEnv": "prd",
+      "env": {
+        "prd": {
+          "portalBase": "https://www.cawplan.com",
+          "apiBase": "https://api.cawplan.com/core-product"
+        }
+      }
+    }
+  }
+}

package/dist/commands/activities.d.ts

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

package/dist/commands/activities.js

@@ -0,0 +1,43 @@
+import { cawplanRequest } from "../lib/http.js";
+import { buildQueryFromFlags } from "../lib/cache.js";
+import { resolveApiPath } from "../lib/products.js";
+export function registerActivitiesCommand(program) {
+    const activities = program.command("activities").description("Query activity logs");
+    activities
+        .command("query")
+        .description("Query activities")
+        .option("--time_range <range>", "Time range (e.g. 1m)")
+        .option("--page_size <n>", "Page size")
+        .option("--page_num <n>", "Page number")
+        .option("--user_id <id>", "Filter by user ID")
+        .option("--product_id <id>", "Filter by product ID")
+        .option("--activity_types <csv>", "Activity types (CSV)")
+        .action(async (opts) => {
+        const flags = {};
+        if (opts.time_range)
+            flags.time_range = opts.time_range;
+        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", "page_size", "page_num"]);
+        const body = {};
+        if (opts.user_id)
+            body.user_id = opts.user_id;
+        if (opts.product_id)
+            body.product_id = opts.product_id;
+        if (opts.activity_types) {
+            body.activity_types = opts.activity_types
+                .split(",")
+                .map((t) => t.trim())
+                .filter(Boolean);
+        }
+        const result = await cawplanRequest({
+            method: "POST",
+            path: resolveApiPath("/api/v1/public/openapi/activities/query"),
+            query,
+            body,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+}

package/dist/commands/analytics.d.ts

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

package/dist/commands/analytics.js

@@ -0,0 +1,30 @@
+import { cawplanRequest } from "../lib/http.js";
+import { buildQueryFromFlags } from "../lib/cache.js";
+export function registerAnalyticsCommand(program) {
+    const analytics = program.command("analytics").description("Product analytics (AI-categorized feedback)");
+    analytics
+        .command("get <product_id>")
+        .description("Get AI-categorized feedback analytics for a product")
+        .option("--time_range <range>", "Time range (e.g. 1w, 1m, 3m, 1y)")
+        .option("--start <date>", "Start date YYYY-MM-DD")
+        .option("--end <date>", "End date YYYY-MM-DD")
+        .option("--version <v>", "Filter by version (major.minor, e.g. 3.4)")
+        .action(async (productId, opts) => {
+        const flags = {};
+        if (opts.time_range)
+            flags.time_range = opts.time_range;
+        if (opts.start)
+            flags.start = opts.start;
+        if (opts.end)
+            flags.end = opts.end;
+        if (opts.version)
+            flags.version = opts.version;
+        const query = buildQueryFromFlags(flags, ["time_range", "start", "end", "version"]);
+        const result = await cawplanRequest({
+            method: "GET",
+            path: `/api/v1/public/openapi/product/${productId}/analytics`,
+            query,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+}

package/dist/commands/auth.d.ts

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

package/dist/commands/auth.js

@@ -0,0 +1,145 @@
+import { createInterface } from "node:readline";
+import { readCredentials, writeCredentials, deleteCredentials, isAccessTokenExpired, } from "../lib/credentials.js";
+import { getAuthState } from "../lib/auth-state.js";
+import { runOAuthLogin } from "../lib/oauth.js";
+import { success, error } from "../lib/output.js";
+import { getConfigPath, readUserConfig, writeUserConfig } from "../lib/user-config.js";
+import { getDefaultEnvName, getEnvNames, getProductEnvConfig } from "../lib/products.js";
+function maskKey(key) {
+    if (key.length <= 8)
+        return "****";
+    return `${key.slice(0, 4)}****${key.slice(-4)}`;
+}
+async function prompt(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+async function promptWithDefault(question, defaultValue) {
+    const answer = await prompt(`${question} [${defaultValue}]: `);
+    return answer || defaultValue;
+}
+export function registerAuthCommand(program) {
+    const auth = program.command("auth").description("Manage authentication");
+    auth
+        .command("login")
+        .description("Log in via browser (OAuth2, recommended)")
+        .action(async () => {
+        try {
+            const creds = await runOAuthLogin();
+            const existing = await readCredentials();
+            await writeCredentials({ ...existing, ...creds });
+            const who = creds.email ? ` as ${creds.email}` : "";
+            success(`Logged in${who}. Token expires in 24h (auto-refresh enabled).`);
+        }
+        catch (err_) {
+            error(String(err_ instanceof Error ? err_.message : err_));
+            process.exit(1);
+        }
+    });
+    auth
+        .command("configure")
+        .description("Configure environment and API Key for authentication")
+        .action(async () => {
+        const existingConfig = await readUserConfig();
+        const envNames = getEnvNames();
+        const defaultEnv = existingConfig?.env ?? getDefaultEnvName();
+        console.log("Open https://www.cawplan.com/account/api to generate an API Key");
+        const env = await promptWithDefault(`Environment (${envNames.join(" / ")})`, defaultEnv);
+        if (!envNames.includes(env)) {
+            error(`Unknown environment '${env}'. Expected one of: ${envNames.join(", ")}`);
+            process.exit(1);
+        }
+        const envConfig = getProductEnvConfig(env);
+        const useExistingUrls = existingConfig?.env === env;
+        const baseUrlDefault = useExistingUrls && existingConfig?.baseUrl ? existingConfig.baseUrl : envConfig.apiBase;
+        const portalUrlDefault = useExistingUrls && existingConfig?.portalUrl
+            ? existingConfig.portalUrl
+            : envConfig.portalBase;
+        const baseUrl = await promptWithDefault("API base URL", baseUrlDefault);
+        const portalUrl = await promptWithDefault("Portal URL", portalUrlDefault);
+        const apiKey = await prompt("Paste your API Key: ");
+        if (!apiKey) {
+            error("API Key cannot be empty");
+            process.exit(1);
+        }
+        const existing = await readCredentials();
+        await writeUserConfig({ env, baseUrl, portalUrl });
+        await writeCredentials({ ...existing, apiKey });
+        success(`Configuration saved to ${getConfigPath()}.`);
+        success("API Key saved.");
+    });
+    auth
+        .command("status")
+        .description("Show current authentication status")
+        .action(async () => {
+        const state = await getAuthState();
+        const creds = state.credentials;
+        let oauthLine;
+        let activeLine;
+        if (creds?.accessToken) {
+            const expired = isAccessTokenExpired(creds);
+            if (expired && creds.refreshToken) {
+                const expiry = new Date((creds.expire ?? 0) * 1000).toISOString();
+                oauthLine = `OAuth:   token expired at ${expiry}, auto-refresh enabled`;
+            }
+            else if (!expired) {
+                const nowSec = Math.floor(Date.now() / 1000);
+                const remaining = (creds.expire ?? 0) - nowSec;
+                const hours = Math.floor(remaining / 3600);
+                const email = creds.email ? ` as ${creds.email}` : "";
+                const autoRefresh = creds.refreshToken ? ", auto-refresh enabled" : "";
+                oauthLine = `OAuth:   logged in${email} (expires in ${hours}h${autoRefresh})`;
+            }
+            else {
+                oauthLine = `OAuth:   token expired (no refresh token)`;
+            }
+        }
+        else {
+            oauthLine = "OAuth:   not configured";
+        }
+        if (state.active === "oauth") {
+            activeLine = "Active:  OAuth (preferred)";
+        }
+        else if (state.active === "apiKey") {
+            activeLine = "Active:  API Key";
+        }
+        else {
+            activeLine = "Active:  none";
+        }
+        let apiKeyLine = "API Key: not configured";
+        if (creds?.apiKey && state.envApiKey) {
+            apiKeyLine = `API Key: configured (${maskKey(creds.apiKey)}, env ${maskKey(state.envApiKey)})`;
+        }
+        else if (creds?.apiKey) {
+            apiKeyLine = `API Key: configured (${maskKey(creds.apiKey)})`;
+        }
+        else if (state.envApiKey) {
+            apiKeyLine = `API Key: configured via CAWPLAN_API_KEY (${maskKey(state.envApiKey)})`;
+        }
+        console.log(oauthLine);
+        console.log(apiKeyLine);
+        const config = await readUserConfig();
+        if (config) {
+            console.log(`Config:  ${config.env ?? "default"} (${getConfigPath()})`);
+        }
+        else {
+            console.log("Config:  default");
+        }
+        console.log(activeLine);
+        if (state.active === "none") {
+            process.exit(1);
+        }
+    });
+    auth
+        .command("logout")
+        .description("Remove stored credentials")
+        .action(async () => {
+        await deleteCredentials();
+        success("Logged out.");
+    });
+}

package/dist/commands/community.d.ts

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

package/dist/commands/community.js

@@ -0,0 +1,30 @@
+import { cawplanRequest } from "../lib/http.js";
+import { buildQueryFromFlags } from "../lib/cache.js";
+export function registerCommunityCommand(program) {
+    const community = program.command("community").description("Community data");
+    community
+        .command("timeline")
+        .description("Get community release timeline across all products")
+        .option("--time_range <range>", "Time range (e.g. 1w, 1m, 3m, 1y)")
+        .option("--start <date>", "Start date YYYY-MM-DD")
+        .option("--end <date>", "End date YYYY-MM-DD")
+        .option("--channels <csv>", "Release channels: GA,EA,Alpha")
+        .action(async (opts) => {
+        const flags = {};
+        if (opts.time_range)
+            flags.time_range = opts.time_range;
+        if (opts.start)
+            flags.start = opts.start;
+        if (opts.end)
+            flags.end = opts.end;
+        if (opts.channels)
+            flags.channels = opts.channels;
+        const query = buildQueryFromFlags(flags, ["time_range", "start", "end", "channels"]);
+        const result = await cawplanRequest({
+            method: "GET",
+            path: "/api/v1/public/openapi/community/timeline",
+            query,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+}

package/dist/commands/critical.d.ts

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

package/dist/commands/critical.js

@@ -0,0 +1,205 @@
+import { cawplanRequest } from "../lib/http.js";
+import { getCache, setCache, buildCacheKey, buildScopedCacheKey, buildQueryFromFlags, csvToArray, stableStringify } from "../lib/cache.js";
+import { resolveApiPath } from "../lib/products.js";
+function parseJsonBody(value) {
+    if (!value)
+        return undefined;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        console.error("Error: --body must be valid JSON");
+        process.exit(1);
+    }
+}
+export function registerCriticalCommand(program) {
+    const critical = program.command("critical").description("Manage critical issues");
+    critical
+        .command("list <product_id>")
+        .description("List critical issues for a product")
+        .option("--time_range <range>", "Time range (e.g. 1m)")
+        .option("--start <date>", "Start date YYYY-MM-DD")
+        .option("--end <date>", "End date YYYY-MM-DD")
+        .option("--status <csv>", "Status filter (CSV)")
+        .option("--search <q>", "Search query")
+        .option("--page_size <n>", "Page size")
+        .option("--page_num <n>", "Page number")
+        .action(async (productId, opts) => {
+        const flags = {};
+        if (opts.time_range)
+            flags.time_range = opts.time_range;
+        if (opts.start)
+            flags.start = opts.start;
+        if (opts.end)
+            flags.end = opts.end;
+        if (opts.status)
+            flags.status = opts.status;
+        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;
+        const query = buildQueryFromFlags(flags, ["time_range", "start", "end", "status", "search", "page_size", "page_num"]);
+        const result = await cawplanRequest({
+            method: "GET",
+            path: `/api/v1/public/openapi/product/${productId}/critical_issues`,
+            query,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+    critical
+        .command("line <product_line_id>")
+        .alias("product-line")
+        .description("List critical issues for a product line")
+        .option("--time_range <range>", "Time range")
+        .option("--start <date>", "Start date YYYY-MM-DD")
+        .option("--end <date>", "End date YYYY-MM-DD")
+        .option("--status <csv>", "Status filter (CSV)")
+        .option("--search <q>", "Search query")
+        .option("--page_size <n>", "Page size")
+        .option("--page_num <n>", "Page number")
+        .action(async (productLineId, opts) => {
+        const flags = {};
+        if (opts.time_range)
+            flags.time_range = opts.time_range;
+        if (opts.start)
+            flags.start = opts.start;
+        if (opts.end)
+            flags.end = opts.end;
+        if (opts.status)
+            flags.status = opts.status;
+        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;
+        const query = buildQueryFromFlags(flags, ["time_range", "start", "end", "status", "search", "page_size", "page_num"]);
+        const result = await cawplanRequest({
+            method: "GET",
+            path: `/api/v1/public/openapi/product_line/${productLineId}/critical_issues`,
+            query,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+    critical
+        .command("search")
+        .description("Search critical issues across products")
+        .option("--time_range <range>", "Time range")
+        .option("--days <n>", "Days (deprecated, use --time_range)")
+        .option("--start_date <date>", "Start date YYYY-MM-DD")
+        .option("--end_date <date>", "End date YYYY-MM-DD")
+        .option("--status <csv>", "Status filter (CSV)")
+        .option("--issue_types <csv>", "Issue types (CSV)")
+        .option("--product_line_ids <csv>", "Product line IDs (CSV)")
+        .option("--product_type_ids <csv>", "Product type IDs (CSV)")
+        .option("--product_ids <csv>", "Product IDs (CSV)")
+        .option("--tech_owners <csv>", "Tech owner IDs (CSV)")
+        .option("--search <q>", "Search query")
+        .option("--page_size <n>", "Page size")
+        .option("--page_num <n>", "Page number")
+        .option("--refresh", "Bypass cache")
+        .action(async (opts) => {
+        if (!opts.time_range && !opts.days && !(opts.start_date && opts.end_date)) {
+            console.error("Error: critical search requires --time_range, --days, or --start_date + --end_date");
+            process.exit(1);
+        }
+        const refresh = Boolean(opts.refresh);
+        const flagsMap = {};
+        if (opts.time_range)
+            flagsMap.time_range = opts.time_range;
+        if (opts.days)
+            flagsMap.days = opts.days;
+        if (opts.start_date)
+            flagsMap.start_date = opts.start_date;
+        if (opts.end_date)
+            flagsMap.end_date = opts.end_date;
+        if (opts.page_size)
+            flagsMap.page_size = opts.page_size;
+        if (opts.page_num)
+            flagsMap.page_num = opts.page_num;
+        const query = buildQueryFromFlags(flagsMap, ["time_range", "days", "start_date", "end_date", "page_size", "page_num"]);
+        const body = {};
+        const status = csvToArray(opts.status);
+        const issueTypes = csvToArray(opts.issue_types);
+        const productLineIds = csvToArray(opts.product_line_ids);
+        const productTypeIds = csvToArray(opts.product_type_ids);
+        const productIds = csvToArray(opts.product_ids);
+        const techOwners = csvToArray(opts.tech_owners);
+        if (status)
+            body.status = status;
+        if (issueTypes)
+            body.issue_types = issueTypes;
+        if (productLineIds)
+            body.product_line_ids = productLineIds;
+        if (productTypeIds)
+            body.product_type_ids = productTypeIds;
+        if (productIds)
+            body.product_ids = productIds;
+        if (techOwners)
+            body.tech_owners = techOwners;
+        if (opts.search)
+            body.search = opts.search;
+        const key = await buildScopedCacheKey(`critical: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/critical_issues/search"),
+            query,
+            body,
+        });
+        setCache(key, result);
+        console.log(JSON.stringify(result, null, 2));
+    });
+    critical
+        .command("get <product_id> <critical_issue_id>")
+        .description("Get critical issue details")
+        .action(async (productId, criticalId) => {
+        const result = await cawplanRequest({
+            method: "GET",
+            path: `/api/v1/public/openapi/product/${productId}/critical_issues/${criticalId}`,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+    critical
+        .command("create <product_id>")
+        .description("Create a critical issue")
+        .requiredOption("--body <json>", "JSON body")
+        .action(async (productId, opts) => {
+        const body = parseJsonBody(opts.body);
+        const result = await cawplanRequest({
+            method: "POST",
+            path: `/api/v1/public/openapi/product/${productId}/critical_issues`,
+            body,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+    critical
+        .command("update <product_id> <critical_issue_id>")
+        .description("Update a critical issue")
+        .requiredOption("--body <json>", "JSON body")
+        .action(async (productId, criticalId, opts) => {
+        const body = parseJsonBody(opts.body);
+        const result = await cawplanRequest({
+            method: "PUT",
+            path: `/api/v1/public/openapi/product/${productId}/critical_issues/${criticalId}`,
+            body,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+    critical
+        .command("delete <product_id> <critical_issue_id>")
+        .description("Delete a critical issue")
+        .action(async (productId, criticalId) => {
+        const result = await cawplanRequest({
+            method: "DELETE",
+            path: `/api/v1/public/openapi/product/${productId}/critical_issues/${criticalId}`,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+}

package/dist/commands/knowledge.d.ts

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

package/dist/commands/knowledge.js

@@ -0,0 +1,24 @@
+import { cawplanRequest } from "../lib/http.js";
+export function registerKnowledgeCommand(program) {
+    const knowledge = program.command("knowledge").description("Knowledge base operations");
+    knowledge
+        .command("search")
+        .description("Search the knowledge base")
+        .requiredOption("--query <text>", "Search query text")
+        .option("--product_id <id>", "Optional product ID to scope the search")
+        .option("--limit <n>", "Result limit (default 10)", "10")
+        .action(async (opts) => {
+        const body = {
+            query: opts.query,
+            limit: Number(opts.limit),
+        };
+        if (opts.product_id)
+            body.product_id = opts.product_id;
+        const result = await cawplanRequest({
+            method: "POST",
+            path: "/api/v1/public/openapi/knowledge/search",
+            body,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+}

package/dist/commands/metrics.d.ts

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

package/dist/commands/metrics.js

@@ -0,0 +1,27 @@
+import { cawplanRequest } from "../lib/http.js";
+import { buildQueryFromFlags } from "../lib/cache.js";
+export function registerMetricsCommand(program) {
+    const metrics = program.command("metrics").description("Product metrics");
+    metrics
+        .command("get <product_id>")
+        .description("Get metrics for a product")
+        .option("--time_range <range>", "Time range (e.g. 1m)")
+        .option("--start <date>", "Start date YYYY-MM-DD")
+        .option("--end <date>", "End date YYYY-MM-DD")
+        .action(async (productId, opts) => {
+        const flags = {};
+        if (opts.time_range)
+            flags.time_range = opts.time_range;
+        if (opts.start)
+            flags.start = opts.start;
+        if (opts.end)
+            flags.end = opts.end;
+        const query = buildQueryFromFlags(flags, ["time_range", "start", "end"]);
+        const result = await cawplanRequest({
+            method: "GET",
+            path: `/api/v1/public/openapi/product/${productId}/metrics`,
+            query,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+}

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

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

package/dist/commands/product-activity.js

@@ -0,0 +1,26 @@
+import { cawplanRequest } from "../lib/http.js";
+export function registerProductActivityCommand(program) {
+    const productActivity = program.command("product-activity").description("Product activity reports");
+    productActivity
+        .command("get")
+        .description("Get a product activity report")
+        .requiredOption("--product_id <id>", "Product ID")
+        .requiredOption("--start <date>", "Start date YYYY-MM-DD")
+        .requiredOption("--end <date>", "End date YYYY-MM-DD")
+        .option("--version_id <id>", "Optional version ID")
+        .action(async (opts) => {
+        const query = {
+            product_id: opts.product_id,
+            start_date: opts.start,
+            end_date: opts.end,
+        };
+        if (opts.version_id)
+            query.version_id = opts.version_id;
+        const result = await cawplanRequest({
+            method: "GET",
+            path: "/api/v1/public/openapi/product-report",
+            query,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+}

package/dist/commands/products.d.ts

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