cawplan 0.0.0

package/dist/commands/users.d.ts

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

package/dist/commands/users.js

@@ -0,0 +1,80 @@
+import { cawplanRequest } from "../lib/http.js";
+import { getCache, setCache, buildScopedCacheKey, buildQueryFromFlags } from "../lib/cache.js";
+export function registerUsersCommand(program) {
+    const users = program.command("users").description("Manage users");
+    users
+        .command("list")
+        .description("List users")
+        .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 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;
+        const refresh = Boolean(opts.refresh);
+        const query = buildQueryFromFlags(flags, ["search", "page_size", "page_num"]);
+        const key = await buildScopedCacheKey("users: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/users",
+            query,
+        });
+        setCache(key, result);
+        console.log(JSON.stringify(result, null, 2));
+    });
+    users
+        .command("query")
+        .description("Query users by email or keyword")
+        .option("--email <email>", "User email")
+        .option("--keyword <q>", "Search keyword")
+        .option("--page_size <n>", "Page size")
+        .option("--page_num <n>", "Page number")
+        .option("--refresh", "Bypass cache")
+        .action(async (opts) => {
+        if (!opts.email && !opts.keyword) {
+            console.error("Error: users query requires --email or --keyword");
+            process.exit(1);
+        }
+        const refresh = Boolean(opts.refresh);
+        const key = await buildScopedCacheKey("users:query", {
+            email: opts.email || "",
+            keyword: opts.keyword || "",
+            page_num: opts.page_num || "",
+            page_size: opts.page_size || "",
+        });
+        const cached = getCache(key, refresh);
+        if (cached) {
+            console.log(JSON.stringify(cached, null, 2));
+            return;
+        }
+        const body = {};
+        if (opts.email) {
+            body.email = opts.email;
+        }
+        else if (opts.keyword) {
+            body.keyword = opts.keyword;
+        }
+        if (opts.page_num)
+            body.page_num = opts.page_num;
+        if (opts.page_size)
+            body.page_size = opts.page_size;
+        const result = await cawplanRequest({
+            method: "POST",
+            path: "/api/v1/public/openapi/users/query",
+            body,
+        });
+        setCache(key, result);
+        console.log(JSON.stringify(result, null, 2));
+    });
+}

package/dist/commands/versions.d.ts

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

package/dist/commands/versions.js

@@ -0,0 +1,65 @@
+import { cawplanRequest } from "../lib/http.js";
+import { buildQueryFromFlags } from "../lib/cache.js";
+export function registerVersionsCommand(program) {
+    const versions = program.command("versions").description("Manage versions");
+    versions
+        .command("list <product_id>")
+        .description("List versions for a product")
+        .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}/versions`,
+            query,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+    versions
+        .command("get <product_id> <version_id>")
+        .description("Get version details")
+        .action(async (productId, versionId) => {
+        const result = await cawplanRequest({
+            method: "GET",
+            path: `/api/v1/public/openapi/product/${productId}/versions/${versionId}`,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+    versions
+        .command("create <product_id>")
+        .description("Create a new version")
+        .requiredOption("--name <version>", "Version name (e.g. X.Y.Z)")
+        .option("--major_id <id>", "Major version unique_id")
+        .option("--description <text>", "Description")
+        .action(async (productId, opts) => {
+        const body = { name: opts.name };
+        if (opts.major_id)
+            body.major_id = opts.major_id;
+        if (opts.description !== undefined)
+            body.description = opts.description;
+        const result = await cawplanRequest({
+            method: "POST",
+            path: `/api/v1/public/openapi/product/${productId}/versions`,
+            body,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+    // Releases subcommand lives naturally alongside versions
+    const releases = program.command("releases").description("Manage releases");
+    releases
+        .command("list <product_id> <version_id>")
+        .description("List releases for a version")
+        .action(async (productId, versionId) => {
+        const result = await cawplanRequest({
+            method: "GET",
+            path: `/api/v1/public/openapi/product/${productId}/versions/${versionId}/release`,
+        });
+        console.log(JSON.stringify(result, null, 2));
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { createRequire } from "node:module";
+import { registerAuthCommand } from "./commands/auth.js";
+import { registerProductsCommand } from "./commands/products.js";
+import { registerVersionsCommand } from "./commands/versions.js";
+import { registerTicketsCommand } from "./commands/tickets.js";
+import { registerCriticalCommand } from "./commands/critical.js";
+import { registerMetricsCommand } from "./commands/metrics.js";
+import { registerTodosCommand } from "./commands/todos.js";
+import { registerUsersCommand } from "./commands/users.js";
+import { registerActivitiesCommand } from "./commands/activities.js";
+import { registerUserActivityCommand } from "./commands/user-activity.js";
+import { registerProductActivityCommand } from "./commands/product-activity.js";
+import { registerKnowledgeCommand } from "./commands/knowledge.js";
+import { registerAnalyticsCommand } from "./commands/analytics.js";
+import { registerQAReportsCommand } from "./commands/qa-reports.js";
+import { registerCommunityCommand } from "./commands/community.js";
+const require = createRequire(import.meta.url);
+const { version } = require("../package.json");
+const program = new Command();
+program
+    .name("cawplan")
+    .description("CawPlan CLI")
+    .version(version);
+// Register all commands
+registerAuthCommand(program);
+registerProductsCommand(program);
+registerVersionsCommand(program);
+registerTicketsCommand(program);
+registerCriticalCommand(program);
+registerMetricsCommand(program);
+registerTodosCommand(program);
+registerUsersCommand(program);
+registerActivitiesCommand(program);
+registerUserActivityCommand(program);
+registerProductActivityCommand(program);
+registerKnowledgeCommand(program);
+registerAnalyticsCommand(program);
+registerQAReportsCommand(program);
+registerCommunityCommand(program);
+// Raw API passthrough
+program
+    .command("api <method> <path>")
+    .description("Raw API request passthrough")
+    .option("--query <params>", "Query params as key=val&key2=val2")
+    .option("--body <json>", "Request body as JSON")
+    .action(async (method, path, opts) => {
+    const { cawplanRequest } = await import("./lib/http.js");
+    let body;
+    if (opts.body) {
+        try {
+            body = JSON.parse(opts.body);
+        }
+        catch {
+            console.error("Error: --body must be valid JSON");
+            process.exit(1);
+        }
+    }
+    const query = opts.query
+        ? Object.fromEntries(new URLSearchParams(opts.query).entries())
+        : undefined;
+    const result = await cawplanRequest({
+        method: method.toUpperCase(),
+        path,
+        query,
+        body,
+    });
+    console.log(JSON.stringify(result, null, 2));
+});
+// Cache management
+program
+    .command("cache")
+    .description("Manage local cache")
+    .command("clear")
+    .description("Clear the local cache")
+    .action(async () => {
+    const { clearCache } = await import("./lib/cache.js");
+    clearCache();
+    console.log(JSON.stringify({ code: "SUCCESS", msg: "cache cleared" }, null, 2));
+});
+await program.parseAsync(process.argv);

package/dist/lib/auth-state.d.ts

@@ -0,0 +1,11 @@
+import { type Credentials } from "./credentials.js";
+export type ActiveAuthKind = "oauth" | "apiKey" | "none";
+export interface AuthState {
+    credentials: Credentials | null;
+    envApiKey?: string;
+    hasOAuth: boolean;
+    hasApiKey: boolean;
+    active: ActiveAuthKind;
+}
+export declare function getAuthState(): Promise<AuthState>;
+export declare function isAuthenticated(): Promise<boolean>;

package/dist/lib/auth-state.js

@@ -0,0 +1,27 @@
+import { getApiKey } from "./config.js";
+import { isAccessTokenExpired, readCredentials } from "./credentials.js";
+export async function getAuthState() {
+    const credentials = await readCredentials();
+    const envApiKey = getApiKey();
+    const hasOAuth = Boolean(credentials?.accessToken &&
+        (!isAccessTokenExpired(credentials) || credentials.refreshToken));
+    const hasApiKey = Boolean(credentials?.apiKey || envApiKey);
+    let active = "none";
+    if (hasOAuth) {
+        active = "oauth";
+    }
+    else if (hasApiKey) {
+        active = "apiKey";
+    }
+    return {
+        credentials,
+        envApiKey,
+        hasOAuth,
+        hasApiKey,
+        active,
+    };
+}
+export async function isAuthenticated() {
+    const state = await getAuthState();
+    return state.active !== "none";
+}

package/dist/lib/cache.d.ts

@@ -0,0 +1,20 @@
+type CacheEntry = {
+    fetched_at: number;
+    data: unknown;
+};
+type CacheStore = {
+    version: 1;
+    entries: Record<string, CacheEntry>;
+};
+export declare function loadCache(): CacheStore;
+export declare function saveCache(store: CacheStore): void;
+export declare function getCache(key: string, refresh: boolean): unknown | undefined;
+export declare function setCache(key: string, data: unknown): void;
+export declare function clearCache(): void;
+export declare function buildCacheKey(prefix: string, query: Record<string, string> | undefined): string;
+export declare function getCacheScope(): Promise<string>;
+export declare function buildScopedCacheKey(prefix: string, query: Record<string, string> | undefined): Promise<string>;
+export declare function stableStringify(value: unknown): string;
+export declare function buildQueryFromFlags(flags: Record<string, string>, allow: string[]): Record<string, string> | undefined;
+export declare function csvToArray(value: string | undefined): string[] | undefined;
+export {};

package/dist/lib/cache.js

@@ -0,0 +1,135 @@
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { resolve } from "node:path";
+import { getBaseUrl, getCachePath, getCacheTtlMs } from "./config.js";
+import { readCredentials } from "./credentials.js";
+export function loadCache() {
+    const cachePath = getCachePath();
+    if (!existsSync(cachePath))
+        return { version: 1, entries: {} };
+    try {
+        const raw = readFileSync(cachePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed && parsed.version === 1 && typeof parsed.entries === "object") {
+            return parsed;
+        }
+    }
+    catch {
+        // Ignore cache read/parse errors
+    }
+    return { version: 1, entries: {} };
+}
+export function saveCache(store) {
+    const cachePath = getCachePath();
+    try {
+        mkdirSync(resolve(cachePath, ".."), { recursive: true });
+        writeFileSync(cachePath, JSON.stringify(store, null, 2));
+    }
+    catch {
+        // Ignore cache write errors
+    }
+}
+export function getCache(key, refresh) {
+    if (refresh)
+        return undefined;
+    const store = loadCache();
+    const entry = store.entries[key];
+    if (!entry)
+        return undefined;
+    const ttlMs = getCacheTtlMs();
+    if (Date.now() - entry.fetched_at > ttlMs)
+        return undefined;
+    return entry.data;
+}
+export function setCache(key, data) {
+    const store = loadCache();
+    store.entries[key] = { fetched_at: Date.now(), data };
+    saveCache(store);
+}
+export function clearCache() {
+    const cachePath = getCachePath();
+    try {
+        if (existsSync(cachePath)) {
+            unlinkSync(cachePath);
+        }
+    }
+    catch {
+        // Ignore cache delete errors
+    }
+}
+export function buildCacheKey(prefix, query) {
+    if (!query)
+        return prefix;
+    const normalized = Object.keys(query)
+        .sort()
+        .map((k) => `${k}=${query[k]}`)
+        .join("&");
+    return `${prefix}?${normalized}`;
+}
+function shortHash(value) {
+    return createHash("sha256").update(value).digest("hex").slice(0, 16);
+}
+function decodeJwtPayload(token) {
+    const payload = token.split(".")[1];
+    if (!payload)
+        return null;
+    try {
+        return JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export async function getCacheScope() {
+    const base = `base:${shortHash(getBaseUrl())}`;
+    const credentials = await readCredentials();
+    if (credentials?.accessToken) {
+        const payload = decodeJwtPayload(credentials.accessToken);
+        const workspaceId = payload?.workspace_id;
+        if (typeof workspaceId === "string" && workspaceId.trim()) {
+            return `${base}:workspace:${workspaceId}`;
+        }
+        const userId = payload?.uid_id ?? payload?.user_id ?? payload?.sub ?? credentials.email;
+        if (typeof userId === "string" && userId.trim()) {
+            return `${base}:oauth:${shortHash(userId)}`;
+        }
+    }
+    if (credentials?.apiKey) {
+        return `${base}:api-key:${shortHash(credentials.apiKey)}`;
+    }
+    return `${base}:anonymous`;
+}
+export async function buildScopedCacheKey(prefix, query) {
+    const scope = await getCacheScope();
+    return `${scope}:${buildCacheKey(prefix, query)}`;
+}
+export function stableStringify(value) {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+    }
+    const obj = value;
+    const keys = Object.keys(obj).sort();
+    const entries = keys.map((key) => `${JSON.stringify(key)}:${stableStringify(obj[key])}`);
+    return `{${entries.join(",")}}`;
+}
+export function buildQueryFromFlags(flags, allow) {
+    const query = {};
+    for (const key of allow) {
+        if (flags[key] !== undefined) {
+            query[key] = flags[key];
+        }
+    }
+    return Object.keys(query).length ? query : undefined;
+}
+export function csvToArray(value) {
+    if (!value)
+        return undefined;
+    const items = value
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+    return items.length ? items : undefined;
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,8 @@
+/**
+ * API base URL. Reads from products.json (env selected by CAWPLAN_ENV),
+ * overridable via CAWPLAN_BASE_URL for advanced use / debugging.
+ */
+export declare function getBaseUrl(): string;
+export declare function getApiKey(): string | undefined;
+export declare function getCachePath(): string;
+export declare function getCacheTtlMs(): number;

package/dist/lib/config.js

@@ -0,0 +1,25 @@
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+import { getApiBase } from "./products.js";
+/**
+ * API base URL. Reads from products.json (env selected by CAWPLAN_ENV),
+ * overridable via CAWPLAN_BASE_URL for advanced use / debugging.
+ */
+export function getBaseUrl() {
+    return getApiBase();
+}
+export function getApiKey() {
+    return process.env.CAWPLAN_API_KEY;
+}
+export function getCachePath() {
+    return process.env.CAWPLAN_CACHE_PATH ?? resolve(homedir(), ".cawplan", "cache.json");
+}
+export function getCacheTtlMs() {
+    const hoursRaw = process.env.CAWPLAN_CACHE_TTL_HOURS;
+    if (hoursRaw !== undefined) {
+        const hours = Number(hoursRaw);
+        if (Number.isFinite(hours) && hours > 0)
+            return hours * 60 * 60 * 1000;
+    }
+    return 12 * 60 * 60 * 1000;
+}

package/dist/lib/credentials.d.ts

@@ -0,0 +1,15 @@
+export interface Credentials {
+    apiKey?: string;
+    accessToken?: string;
+    refreshToken?: string;
+    /** Unix timestamp (seconds) when access token expires */
+    expire?: number;
+    /** Email of the authenticated user (from OAuth) */
+    email?: string;
+}
+export declare const CREDENTIALS_PATH: string;
+export declare function getCredentialsPath(): string;
+export declare function isAccessTokenExpired(credentials: Credentials, nowSeconds?: number): boolean;
+export declare function readCredentials(): Promise<Credentials | null>;
+export declare function writeCredentials(creds: Credentials): Promise<void>;
+export declare function deleteCredentials(): Promise<void>;

package/dist/lib/credentials.js

@@ -0,0 +1,50 @@
+import { chmod, mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+const CREDENTIALS_MODE = 0o600;
+export const CREDENTIALS_PATH = join(homedir(), ".cawplan", "credentials.json");
+export function getCredentialsPath() {
+    return process.env.CAWPLAN_CREDENTIALS_PATH ?? CREDENTIALS_PATH;
+}
+export function isAccessTokenExpired(credentials, nowSeconds = Math.floor(Date.now() / 1000)) {
+    if (credentials.expire == null)
+        return true;
+    return credentials.expire <= nowSeconds;
+}
+export async function readCredentials() {
+    try {
+        const raw = await readFile(getCredentialsPath(), "utf8");
+        const parsed = JSON.parse(raw);
+        // Return whatever fields are present; no required fields check
+        return {
+            apiKey: parsed.apiKey,
+            accessToken: parsed.accessToken,
+            refreshToken: parsed.refreshToken,
+            expire: parsed.expire,
+            email: parsed.email,
+        };
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return null;
+        }
+        throw err;
+    }
+}
+export async function writeCredentials(creds) {
+    const credentialsPath = getCredentialsPath();
+    await mkdir(dirname(credentialsPath), { recursive: true });
+    const payload = `${JSON.stringify(creds, null, 2)}\n`;
+    await writeFile(credentialsPath, payload, { encoding: "utf8", mode: CREDENTIALS_MODE });
+    await chmod(credentialsPath, CREDENTIALS_MODE);
+}
+export async function deleteCredentials() {
+    try {
+        await unlink(getCredentialsPath());
+    }
+    catch (err) {
+        if (err.code !== "ENOENT") {
+            throw err;
+        }
+    }
+}

package/dist/lib/http.d.ts

@@ -0,0 +1,14 @@
+export declare class ApiError extends Error {
+    readonly status: number;
+    readonly body?: unknown | undefined;
+    constructor(message: string, status: number, body?: unknown | undefined);
+}
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+export interface RequestOptions {
+    method?: HttpMethod;
+    path: string;
+    query?: Record<string, string>;
+    body?: unknown;
+}
+export declare function cawplanRequest(options: RequestOptions): Promise<unknown>;
+export {};