@cipherly/plane-cli 1.0.0

package/dist/work-items/list.work-items.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderWorkItem = exports.listWorkItems = void 0;
+const commander_1 = require("commander");
+const utils_1 = require("../utils");
+exports.listWorkItems = new commander_1.Command("list")
+    .description("List work items")
+    .requiredOption("-p, --project-id <projectId>", "Project's ID")
+    .action(async (__, cmd) => {
+    if (cmd.parent == null)
+        return;
+    const { apiKey, apiBase, workspaceSlug, json } = (0, utils_1.checkRequiredOptionsAndReturn)(cmd);
+    const projectId = cmd.getOptionValue("projectId");
+    const { result, status } = await (0, utils_1.requestPlaneAPI)({
+        apiBase,
+        apiKey,
+        endpoint: `workspaces/${workspaceSlug}/projects/${projectId}/work-items/`,
+        method: "GET",
+        params: {
+            expand: "state,labels,assignees",
+        },
+    });
+    if (json)
+        console.log(JSON.stringify(result));
+    else {
+        if (status !== 200)
+            console.table(result);
+        else
+            console.table(result.results.map(exports.renderWorkItem));
+    }
+});
+const renderWorkItem = (workItem) => {
+    return {
+        id: workItem.id,
+        name: workItem.name,
+        state: (workItem.state && workItem.state.name) || null,
+        labels: (workItem.labels && workItem.labels.map((label) => label.name)) ||
+            [],
+        assignees: (workItem.assignees &&
+            workItem.assignees.map((user) => `${user.first_name} ${user.last_name}`.trim())) ||
+            [],
+    };
+};
+exports.renderWorkItem = renderWorkItem;

package/dist/work-items/types/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./list.types.work-items"), exports);

package/dist/work-items/types/list.types.work-items.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderWorkItemType = exports.listWorkItemTypes = void 0;
+const commander_1 = require("commander");
+const utils_1 = require("../../utils");
+exports.listWorkItemTypes = new commander_1.Command("list")
+    .description("List work item types")
+    .requiredOption("-p, --project-id <projectId>", "Project's ID")
+    .action(async (__, cmd) => {
+    if (cmd.parent == null)
+        return;
+    const { apiKey, apiBase, workspaceSlug, json } = (0, utils_1.checkRequiredOptionsAndReturn)(cmd);
+    const projectId = cmd.getOptionValue("projectId");
+    const { result, status } = await (0, utils_1.requestPlaneAPI)({
+        apiBase,
+        apiKey,
+        endpoint: `workspaces/${workspaceSlug}/projects/${projectId}/work-item-types/`,
+        method: "GET",
+    });
+    if (json)
+        console.log(JSON.stringify(result));
+    else {
+        if (status !== 200)
+            console.table(result);
+        else
+            console.table(result.results.map(exports.renderWorkItemType));
+    }
+});
+const renderWorkItemType = (workItemType) => {
+    return {
+        id: workItemType.id,
+        name: workItemType.name,
+        description: workItemType.description,
+        is_epic: workItemType.is_epic,
+        is_default: workItemType.is_default,
+        is_active: workItemType.is_active,
+        level: workItemType.level,
+    };
+};
+exports.renderWorkItemType = renderWorkItemType;

package/dist/work-items/update.work-items.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateWorkItem = void 0;
+const commander_1 = require("commander");
+const utils_1 = require("../utils");
+const list_work_items_1 = require("./list.work-items");
+exports.updateWorkItem = new commander_1.Command("update")
+    .description("Update a work-item")
+    .requiredOption("-p, --project-id <projectId>", "Project's ID")
+    .requiredOption("-w, --work-item-id <workItemId>", "Work item's ID")
+    .option("-n, --name [name]", "Work item's name")
+    .option("-d, --description [description]", "Work item's description in HTML")
+    .action(async (__, cmd) => {
+    if (cmd.parent == null)
+        return;
+    const { apiKey, apiBase, workspaceSlug, json } = (0, utils_1.checkRequiredOptionsAndReturn)(cmd);
+    const projectId = cmd.getOptionValue("projectId");
+    const workItemId = cmd.getOptionValue("workItemId");
+    const name = cmd.getOptionValue("name");
+    const description = cmd.getOptionValue("description");
+    const body = {};
+    if (name !== undefined)
+        body.name = name;
+    if (description !== undefined)
+        body.description = description;
+    const { result, status } = await (0, utils_1.requestPlaneAPI)({
+        apiBase,
+        apiKey,
+        endpoint: `workspaces/${workspaceSlug}/projects/${projectId}/work-items/${workItemId}/`,
+        method: "PATCH",
+        body,
+    });
+    if (json)
+        console.log(JSON.stringify(result));
+    else {
+        if (status !== 200)
+            console.table(result);
+        else
+            console.table((0, list_work_items_1.renderWorkItem)(result));
+    }
+});

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@cipherly/plane-cli",
+  "version": "1.0.0",
+  "description": "CLI for api.plane.so",
+  "packageManager": "pnpm@8.8.0",
+  "bin": {
+    "plane": "dist/plane.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "ts-node src/plane.ts"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "commander": "^11.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.8.1",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.2.2"
+  },
+  "keywords": [
+    "plane",
+    "cli"
+  ],
+  "license": "Apache-2.0"
+}

package/src/cycles/create.cycles.ts

@@ -0,0 +1,39 @@
+import { Command } from "commander";
+import { checkRequiredOptionsAndReturn, requestPlaneAPI } from "../utils";
+import { renderCycle } from "./list.cycles";
+
+export const createCycle = new Command("create")
+  .description("Create a new cycle")
+  .requiredOption("-p, --project-id <projectId>", "Project's ID")
+  .requiredOption("-n, --name <name>", "Cycle's name")
+  .option("-d, --description [description]", "Cycle's description")
+  .option("-sd, --start-date [startDate]", "Cycle's start date")
+  .option("-ed, --end-date [endDate]", "Cycle's end date")
+  .action(async (__, cmd: Command) => {
+    if (cmd.parent == null) return;
+    const { apiKey, apiBase, workspaceSlug, json } =
+      checkRequiredOptionsAndReturn(cmd);
+    const projectId = cmd.getOptionValue("projectId");
+    const name = cmd.getOptionValue("name");
+    const description = cmd.getOptionValue("description");
+    const startDate = cmd.getOptionValue("startDate");
+    const endDate = cmd.getOptionValue("endDate");
+    const { result, status } = await requestPlaneAPI({
+      apiBase,
+      apiKey,
+      endpoint: `workspaces/${workspaceSlug}/projects/${projectId}/cycles/`,
+      method: "POST",
+      body: {
+        name,
+        description,
+        project_id: projectId,
+        start_date: startDate,
+        end_date: endDate,
+      },
+    });
+    if (json) console.log(JSON.stringify(result));
+    else {
+      if (status !== 201) console.table(result);
+      else console.table(renderCycle(result));
+    }
+  });

package/src/cycles/delete.cycles.ts

@@ -0,0 +1,25 @@
+import { Command } from "commander";
+import { checkRequiredOptionsAndReturn, requestPlaneAPI } from "../utils";
+
+export const deleteCycle = new Command("delete")
+  .description("Delete a cycle")
+  .requiredOption("-p, --project-id <projectId>", "Project's ID")
+  .requiredOption("-c, --cycle-id <cycleId>", "Cycle's ID")
+  .action(async (__, cmd: Command) => {
+    if (cmd.parent == null) return;
+    const { apiKey, apiBase, workspaceSlug, json } =
+      checkRequiredOptionsAndReturn(cmd);
+    const projectId = cmd.getOptionValue("projectId");
+    const cycleId = cmd.getOptionValue("cycleId");
+    const { result, status } = await requestPlaneAPI({
+      apiBase,
+      apiKey,
+      endpoint: `workspaces/${workspaceSlug}/projects/${projectId}/cycles/${cycleId}/`,
+      method: "DELETE",
+    });
+    if (json) console.log(JSON.stringify(result));
+    else {
+      if (status !== 204) console.table(result);
+      else console.table(result);
+    }
+  });

package/src/cycles/index.ts

@@ -0,0 +1,5 @@
+export * from "./list.cycles";
+export * from "./work-items";
+export * from "./create.cycles";
+export * from "./update.cycles";
+export * from "./delete.cycles";

package/src/cycles/list.cycles.ts

@@ -0,0 +1,37 @@
+import { Command } from "commander";
+import { checkRequiredOptionsAndReturn, requestPlaneAPI } from "../utils";
+
+export const listCycles = new Command("list")
+  .description("List cycles")
+  .requiredOption("-p, --project-id <projectId>", "Project's ID")
+  .action(async (__, cmd: Command) => {
+    if (cmd.parent == null) return;
+    const { apiKey, apiBase, workspaceSlug, json } =
+      checkRequiredOptionsAndReturn(cmd);
+    const projectId = cmd.getOptionValue("projectId");
+    const { result, status } = await requestPlaneAPI({
+      apiBase,
+      apiKey,
+      endpoint: `workspaces/${workspaceSlug}/projects/${projectId}/cycles/`,
+      method: "GET",
+    });
+    if (json) console.log(JSON.stringify(result));
+    else {
+      if (status !== 200) console.table(result);
+      else console.table(result.results.map(renderCycle));
+    }
+  });
+
+export const renderCycle = (cycle: any) => {
+  return {
+    id: cycle.id,
+    name: cycle.name,
+    description: cycle.description,
+    total_issues: cycle.total_issues,
+    cancelled_issues: cycle.cancelled_issues,
+    completed_issues: cycle.completed_issues,
+    started_issues: cycle.started_issues,
+    unstarted_issues: cycle.unstarted_issues,
+    backlog_issues: cycle.backlog_issues,
+  };
+};

package/src/cycles/update.cycles.ts

@@ -0,0 +1,41 @@
+import { Command } from "commander";
+import { checkRequiredOptionsAndReturn, requestPlaneAPI } from "../utils";
+import { renderCycle } from "./list.cycles";
+
+export const updateCycle = new Command("update")
+  .description("Update a cycle")
+  .requiredOption("-p, --project-id <projectId>", "Project's ID")
+  .requiredOption("-c, --cycle-id <cycleId>", "Cycle's ID")
+  .option("-n, --name [name]", "Cycle's name")
+  .option("-d, --description [description]", "Cycle's description")
+  .option("-sd, --start-date [startDate]", "Cycle's start date")
+  .option("-ed, --end-date [endDate]", "Cycle's end date")
+  .action(async (__, cmd: Command) => {
+    if (cmd.parent == null) return;
+    const { apiKey, apiBase, workspaceSlug, json } =
+      checkRequiredOptionsAndReturn(cmd);
+    const projectId = cmd.getOptionValue("projectId");
+    const cycleId = cmd.getOptionValue("cycleId");
+    const name = cmd.getOptionValue("name");
+    const description = cmd.getOptionValue("description");
+    const startDate = cmd.getOptionValue("startDate");
+    const endDate = cmd.getOptionValue("endDate");
+    const { result, status } = await requestPlaneAPI({
+      apiBase,
+      apiKey,
+      endpoint: `workspaces/${workspaceSlug}/projects/${projectId}/cycles/${cycleId}/`,
+      method: "PATCH",
+      body: {
+        name,
+        description,
+        project_id: projectId,
+        start_date: startDate,
+        end_date: endDate,
+      },
+    });
+    if (json) console.log(JSON.stringify(result));
+    else {
+      if (status !== 200) console.table(result);
+      else console.table(renderCycle(result));
+    }
+  });

package/src/cycles/work-items/index.ts

@@ -0,0 +1 @@
+export * from "./list.cycles.work-items";

package/src/cycles/work-items/list.cycles.work-items.ts

@@ -0,0 +1,40 @@
+import { Command } from "commander";
+import { checkRequiredOptionsAndReturn, requestPlaneAPI } from "../../utils";
+
+export const listCyclesWorkItems = new Command("list-work-items")
+  .description("List cycle work items")
+  .requiredOption("-p, --project-id <projectId>", "Project's ID")
+  .requiredOption("-c, --cycle-id <cycleId>", "Cycle's ID")
+  .action(async (__, cmd: Command) => {
+    if (cmd.parent == null) return;
+    const { apiKey, apiBase, workspaceSlug, json } =
+      checkRequiredOptionsAndReturn(cmd);
+    const projectId = cmd.getOptionValue("projectId");
+    const cycleId = cmd.getOptionValue("cycleId");
+    const { result, status } = await requestPlaneAPI({
+      apiBase,
+      apiKey,
+      endpoint: `workspaces/${workspaceSlug}/projects/${projectId}/cycles/${cycleId}/cycle-issues/`,
+      method: "GET",
+      params: {
+        expand: "state,labels,assignees",
+      },
+    });
+    if (json) console.log(JSON.stringify(result));
+    else {
+      if (status !== 200) console.table(result);
+      else console.table(result.results.map(renderCycleWorkItem));
+    }
+  });
+
+export const renderCycleWorkItem = (workItem: any) => {
+  return {
+    id: workItem.id,
+    name: workItem.name,
+    state: workItem.state.name,
+    labels: workItem.labels.map((label: any) => label.name),
+    assignees: workItem.assignees.map((user: any) =>
+      `${user.first_name} ${user.last_name}`.trim(),
+    ),
+  };
+};

package/src/labels/create.labels.ts

@@ -0,0 +1,29 @@
+import { Command } from "commander";
+import { checkRequiredOptionsAndReturn, requestPlaneAPI } from "../utils";
+import { renderLabel } from "./list.labels";
+
+export const createLabel = new Command("create")
+  .description("Create a new label")
+  .requiredOption("-p, --project-id <projectId>", "Project's ID")
+  .requiredOption("-n, --name <name>", "Label's name")
+  .action(async (__, cmd: Command) => {
+    if (cmd.parent == null) return;
+    const { apiKey, apiBase, workspaceSlug, json } =
+      checkRequiredOptionsAndReturn(cmd);
+    const projectId = cmd.getOptionValue("projectId");
+    const name = cmd.getOptionValue("name");
+    const { result, status } = await requestPlaneAPI({
+      apiBase,
+      apiKey,
+      endpoint: `workspaces/${workspaceSlug}/projects/${projectId}/labels/`,
+      method: "POST",
+      body: {
+        name,
+      },
+    });
+    if (json) console.log(JSON.stringify(result));
+    else {
+      if (status !== 201) console.table(result);
+      else console.table(renderLabel(result));
+    }
+  });

package/src/labels/delete.labels.ts

@@ -0,0 +1,25 @@
+import { Command } from "commander";
+import { checkRequiredOptionsAndReturn, requestPlaneAPI } from "../utils";
+
+export const deleteLabel = new Command("delete")
+  .description("Delete a label")
+  .requiredOption("-p, --project-id <projectId>", "Project's ID")
+  .requiredOption("-l, --label-id <labelId>", "Label's ID")
+  .action(async (__, cmd: Command) => {
+    if (cmd.parent == null) return;
+    const { apiKey, apiBase, workspaceSlug, json } =
+      checkRequiredOptionsAndReturn(cmd);
+    const projectId = cmd.getOptionValue("projectId");
+    const labelId = cmd.getOptionValue("labelId");
+    const { result, status } = await requestPlaneAPI({
+      apiBase,
+      apiKey,
+      endpoint: `workspaces/${workspaceSlug}/projects/${projectId}/labels/${labelId}/`,
+      method: "DELETE",
+    });
+    if (json) console.log(JSON.stringify(result));
+    else {
+      if (status !== 204) console.table(result);
+      else console.table(result);
+    }
+  });

package/src/labels/index.ts

@@ -0,0 +1,5 @@
+export * from "./list.labels";
+export * from "./create.labels";
+export * from "./update.labels";
+export * from "./delete.labels";
+

package/src/labels/list.labels.ts

@@ -0,0 +1,31 @@
+import { Command } from "commander";
+import { checkRequiredOptionsAndReturn, requestPlaneAPI } from "../utils";
+
+export const listLabels = new Command("list")
+  .description("List labels")
+  .requiredOption("-p, --project-id <projectId>", "Project's ID")
+  .action(async (__, cmd: Command) => {
+    if (cmd.parent == null) return;
+    const { apiKey, apiBase, workspaceSlug, json } =
+      checkRequiredOptionsAndReturn(cmd);
+    const projectId = cmd.getOptionValue("projectId");
+    const { result, status } = await requestPlaneAPI({
+      apiBase,
+      apiKey,
+      endpoint: `workspaces/${workspaceSlug}/projects/${projectId}/labels/`,
+      method: "GET",
+    });
+    if (json) console.log(JSON.stringify(result));
+    else {
+      if (status !== 200) console.table(result);
+      else console.table(result.results.map(renderLabel));
+    }
+  });
+
+export const renderLabel = (label: any) => {
+  return {
+    id: label.id,
+    name: label.name,
+    description: label.description,
+  };
+};

package/src/labels/update.labels.ts

@@ -0,0 +1,31 @@
+import { Command } from "commander";
+import { checkRequiredOptionsAndReturn, requestPlaneAPI } from "../utils";
+import { renderLabel } from "./list.labels";
+
+export const updateLabel = new Command("update")
+  .description("Update a label")
+  .requiredOption("-p, --project-id <projectId>", "Project's ID")
+  .requiredOption("-l, --label-id <labelId>", "Label's ID")
+  .requiredOption("-n, --name <name>", "Label's name")
+  .action(async (__, cmd: Command) => {
+    if (cmd.parent == null) return;
+    const { apiKey, apiBase, workspaceSlug, json } =
+      checkRequiredOptionsAndReturn(cmd);
+    const projectId = cmd.getOptionValue("projectId");
+    const labelId = cmd.getOptionValue("labelId");
+    const name = cmd.getOptionValue("name");
+    const { result, status } = await requestPlaneAPI({
+      apiBase,
+      apiKey,
+      endpoint: `workspaces/${workspaceSlug}/projects/${projectId}/labels/${labelId}/`,
+      method: "PATCH",
+      body: {
+        name,
+      },
+    });
+    if (json) console.log(JSON.stringify(result));
+    else {
+      if (status !== 200) console.table(result);
+      else console.table(renderLabel(result));
+    }
+  });

package/src/plane.ts

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import {
+  createProject,
+  deleteProject,
+  listProjects,
+  updateProject,
+} from "./projects";
+import {
+  createWorkItem,
+  deleteWorkItem,
+  listWorkItems,
+  listWorkItemTypes,
+  updateWorkItem,
+} from "./work-items";
+import { createState, deleteState, listStates, updateState } from "./states";
+import { createLabel, deleteLabel, listLabels, updateLabel } from "./labels";
+import {
+  createCycle,
+  deleteCycle,
+  listCycles,
+  listCyclesWorkItems,
+  updateCycle,
+} from "./cycles";
+import { getCurrentUser } from "./users";
+
+const program = new Command();
+program.name("plane").description("CLI for api.plane.so").version("1.0.0");
+
+program
+  .command("projects")
+  .description("Manage projects")
+  .addCommand(listProjects)
+  .addCommand(createProject)
+  .addCommand(updateProject)
+  .addCommand(deleteProject);
+
+program
+  .command("work-items")
+  .description("Manage work items")
+  .addCommand(listWorkItems)
+  .addCommand(createWorkItem)
+  .addCommand(updateWorkItem)
+  .addCommand(deleteWorkItem);
+
+program
+  .command("work-item-types")
+  .description("Manage work item types")
+  .addCommand(listWorkItemTypes);
+
+program
+  .command("states")
+  .description("Manage states")
+  .addCommand(listStates)
+  .addCommand(createState)
+  .addCommand(updateState)
+  .addCommand(deleteState);
+
+program
+  .command("labels")
+  .description("Manage labels")
+  .addCommand(listLabels)
+  .addCommand(createLabel)
+  .addCommand(updateLabel)
+  .addCommand(deleteLabel);
+
+program
+  .command("cycles")
+  .description("Manage cycles")
+  .addCommand(listCycles)
+  .addCommand(listCyclesWorkItems)
+  .addCommand(createCycle)
+  .addCommand(updateCycle)
+  .addCommand(deleteCycle);
+
+program.command("users").description("Manage users").addCommand(getCurrentUser);
+
+program.commands.forEach((cmd) => {
+  cmd.requiredOption(
+    "--api-key <key>",
+    "Plane API key",
+    process.env.PLANE_API_KEY,
+  );
+  cmd.requiredOption(
+    "--api-base <url>",
+    "Plane API base",
+    process.env.PLANE_API_BASE || "api.plane.so",
+  );
+  cmd.requiredOption(
+    "--workspace-slug <slug>",
+    "Workspace slug",
+    process.env.PLANE_WORKSPACE_SLUG,
+  );
+  cmd.option("-j, --json", "Print in JSON format");
+});
+
+program.parse();

package/src/projects/create.projects.ts

@@ -0,0 +1,33 @@
+import { Command } from "commander";
+import { checkRequiredOptionsAndReturn, requestPlaneAPI } from "../utils";
+import { renderProject } from "./list.projects";
+
+export const createProject = new Command("create")
+  .description("Create a new project")
+  .requiredOption("-n, --name <name>", "Project's name")
+  .requiredOption("-i, --identifier <identifier>", "Project' identifier")
+  .option("-d, --description [description]", "Project's description")
+  .action(async (__, cmd: Command) => {
+    if (cmd.parent == null) return;
+    const { apiKey, apiBase, workspaceSlug, json } =
+      checkRequiredOptionsAndReturn(cmd);
+    const name = cmd.getOptionValue("name");
+    const identifier = cmd.getOptionValue("identifier");
+    const description = cmd.getOptionValue("description");
+    const { result, status } = await requestPlaneAPI({
+      apiBase,
+      apiKey,
+      endpoint: `workspaces/${workspaceSlug}/projects/`,
+      method: "POST",
+      body: {
+        name,
+        identifier,
+        description,
+      },
+    });
+    if (json) console.log(JSON.stringify(result));
+    else {
+      if (status !== 201) console.table(result);
+      else console.table(renderProject(result));
+    }
+  });

package/src/projects/delete.projects.ts

@@ -0,0 +1,23 @@
+import { Command } from "commander";
+import { checkRequiredOptionsAndReturn, requestPlaneAPI } from "../utils";
+
+export const deleteProject = new Command("delete")
+  .description("Delete a project")
+  .requiredOption("-p, --project-id <projectId>", "Project's ID")
+  .action(async (__, cmd: Command) => {
+    if (cmd.parent == null) return;
+    const { apiKey, apiBase, workspaceSlug, json } =
+      checkRequiredOptionsAndReturn(cmd);
+    const projectId = cmd.getOptionValue("projectId");
+    const { result, status } = await requestPlaneAPI({
+      apiBase,
+      apiKey,
+      endpoint: `workspaces/${workspaceSlug}/projects/${projectId}/`,
+      method: "DELETE",
+    });
+    if (json) console.log(JSON.stringify(result));
+    else {
+      if (status !== 204) console.table(result);
+      else console.table(result);
+    }
+  });

package/src/projects/index.ts

@@ -0,0 +1,5 @@
+export * from "./list.projects";
+export * from "./create.projects";
+export * from "./update.projects";
+export * from "./delete.projects";
+