@ysicing/plane-cli 0.1.0 → 1.0.1

package/src/commands/me.js

@@ -5,7 +5,7 @@ import { PlaneClient } from "../core/http.js";
 import { printData } from "../core/output.js";
 
 export async function runMeCommand(args, context) {
-  if (args.includes("--help") || args.includes("help")) {
+  if (args.includes("--help") || args.includes("-h") || args.includes("help")) {
     console.log("Usage:\n  plane me");
     return;
   }

package/src/commands/project.js

@@ -5,6 +5,10 @@ import { PlaneClient } from "../core/http.js";
 import { ensureValue, parseCommandArgs, pickDefined } from "../core/options.js";
 import { printData, printTable } from "../core/output.js";
 
+function hasHelpFlag(args) {
+  return args.includes("--help") || args.includes("-h") || args.includes("help");
+}
+
 function createProjectRender(data) {
   const rows = Array.isArray(data) ? data : data.results || [];
   printTable(rows, [
@@ -16,6 +20,23 @@ function createProjectRender(data) {
   ]);
 }
 
+const PROJECT_FEATURE_FIELDS = {
+  "issue-types": "is_issue_type_enabled",
+  epics: "is_epic_enabled",
+  milestones: "is_milestone_enabled",
+  "time-tracking": "is_time_tracking_enabled",
+  "auto-transition": "gaeaflow_auto_transition_enabled",
+  "auto-assign": "gaeaflow_auto_assign_enabled",
+  "auto-worklog": "gaeaflow_auto_worklog_enabled",
+  "require-worklog-before-completion": "require_worklog_before_completion_enabled",
+};
+
+const PROJECT_ROLE_MAP = {
+  admin: 20,
+  member: 15,
+  guest: 5,
+};
+
 export function buildProjectPayload(values) {
   return pickDefined({
     name: values.name,
@@ -26,19 +47,249 @@ export function buildProjectPayload(values) {
   });
 }
 
+export function splitProjectCreatePayload(values) {
+  const fullPayload = buildProjectPayload(values);
+  const createPayload = pickDefined({
+    name: fullPayload.name,
+    identifier: fullPayload.identifier,
+  });
+  const postCreateUpdatePayload = pickDefined({
+    description: fullPayload.description,
+    project_lead: fullPayload.project_lead,
+    default_assignee: fullPayload.default_assignee,
+  });
+
+  return { createPayload, postCreateUpdatePayload };
+}
+
+export function normalizeProjectRole(value) {
+  const normalized = String(value || "").trim().toLowerCase();
+  const role = PROJECT_ROLE_MAP[normalized];
+  if (!role) {
+    throw new CliError("Role must be one of: admin, member, guest.");
+  }
+  return role;
+}
+
+export function parseToggle(value, optionName) {
+  const normalized = String(value || "").trim().toLowerCase();
+  if (["on", "true", "1", "yes", "enable", "enabled"].includes(normalized)) return true;
+  if (["off", "false", "0", "no", "disable", "disabled"].includes(normalized)) return false;
+  throw new CliError(`Invalid value for ${optionName}: ${value}. Use on/off.`);
+}
+
+export function buildProjectFeaturesPayload(values) {
+  const payload = {};
+
+  for (const [option, field] of Object.entries(PROJECT_FEATURE_FIELDS)) {
+    if (values[option] !== undefined) {
+      payload[field] = parseToggle(values[option], `--${option}`);
+    }
+  }
+
+  return payload;
+}
+
+function pickProjectFeatures(project) {
+  return Object.fromEntries(Object.entries(PROJECT_FEATURE_FIELDS).map(([option, field]) => [field, project[field]]));
+}
+
+function renderProjectMembers(data) {
+  const rows = Array.isArray(data) ? data : [];
+  printTable(rows, [
+    { label: "User ID", get: (row) => row.id || "" },
+    { label: "Email", get: (row) => row.email || "" },
+    { label: "Name", get: (row) => `${row.first_name || ""} ${row.last_name || ""}`.trim() },
+  ]);
+}
+
+function renderWorkspaceMembers(data) {
+  const rows = Array.isArray(data) ? data : [];
+  printTable(rows, [
+    { label: "User ID", get: (row) => row.id || "" },
+    { label: "Email", get: (row) => row.email || "" },
+    { label: "Name", get: (row) => `${row.first_name || ""} ${row.last_name || ""}`.trim() },
+    { label: "Role", get: (row) => row.role ?? "" },
+  ]);
+}
+
 function printHelp() {
   console.log(`Usage:
   plane project ls [--limit <n>] [--cursor <cursor>] [--order-by <field>]
   plane project get <project-id>
+  plane project summary <project-id> [--fields <members,states,labels,cycles,modules,issues,intakes,pages>]
+  plane project members ls --project <project-id>
+  plane project members workspace
+  plane project members add --project <project-id> --member <user-id> --role <admin|member|guest>
+  plane project features get <project-id>
+  plane project features set <project-id> [--issue-types on|off] [--epics on|off] [--milestones on|off] [--time-tracking on|off] [--auto-transition on|off] [--auto-assign on|off] [--auto-worklog on|off] [--require-worklog-before-completion on|off]
+  plane project features enable-all <project-id>
   plane project create --name <name> --identifier <identifier> [--description <text>] [--project-lead <user-id>] [--default-assignee <user-id>]
   plane project update <project-id> [--name <name>] [--identifier <identifier>] [--description <text>] [--project-lead <user-id>] [--default-assignee <user-id>]
 `);
 }
 
+async function runProjectMembersCommand(projectClient, args, context) {
+  const [subcommand, ...rest] = args;
+
+  if (!subcommand || subcommand === "--help" || subcommand === "-h" || subcommand === "help") {
+    printHelp();
+    return;
+  }
+
+  if (hasHelpFlag(rest)) {
+    printHelp();
+    return;
+  }
+
+  if (subcommand === "ls") {
+    const parsed = parseCommandArgs(
+      rest,
+      {
+        project: { type: "string" },
+      },
+      false
+    );
+
+    ensureValue(parsed.values.project, "Project ID is required.");
+    const result = await projectClient.listMembers(parsed.values.project);
+    printData(result, {
+      ...context.output,
+      render: renderProjectMembers,
+    });
+    return;
+  }
+
+  if (subcommand === "workspace") {
+    const result = await projectClient.listWorkspaceMembers();
+    printData(result, {
+      ...context.output,
+      render: renderWorkspaceMembers,
+    });
+    return;
+  }
+
+  if (subcommand === "add") {
+    const parsed = parseCommandArgs(
+      rest,
+      {
+        project: { type: "string" },
+        member: { type: "string" },
+        role: { type: "string" },
+      },
+      false
+    );
+
+    ensureValue(parsed.values.project, "Project ID is required.");
+    ensureValue(parsed.values.member, "Member user ID is required.");
+    ensureValue(parsed.values.role, "Role is required.");
+
+    const result = await projectClient.addMember(parsed.values.project, {
+      member: parsed.values.member,
+      role: normalizeProjectRole(parsed.values.role),
+    });
+    printData(result, context.output);
+    return;
+  }
+
+  throw new CliError(`Unknown project members subcommand: ${subcommand}`);
+}
+
+async function runProjectFeaturesCommand(projectClient, args, context) {
+  const [subcommand, ...rest] = args;
+
+  if (!subcommand || subcommand === "--help" || subcommand === "-h" || subcommand === "help") {
+    printHelp();
+    return;
+  }
+
+  if (hasHelpFlag(rest)) {
+    printHelp();
+    return;
+  }
+
+  if (subcommand === "get") {
+    const [projectId] = rest;
+    ensureValue(projectId, "Project ID is required.");
+    const project = await projectClient.get(projectId);
+    printData(
+      {
+        id: project.id,
+        identifier: project.identifier,
+        name: project.name,
+        ...pickProjectFeatures(project),
+      },
+      context.output
+    );
+    return;
+  }
+
+  if (subcommand === "enable-all") {
+    const [projectId] = rest;
+    ensureValue(projectId, "Project ID is required.");
+    const payload = Object.fromEntries(Object.values(PROJECT_FEATURE_FIELDS).map((field) => [field, true]));
+    const result = await projectClient.update(projectId, payload);
+    printData(
+      {
+        id: result.id,
+        identifier: result.identifier,
+        name: result.name,
+        ...pickProjectFeatures(result),
+      },
+      context.output
+    );
+    return;
+  }
+
+  if (subcommand === "set") {
+    const [projectId, ...optionArgs] = rest;
+    ensureValue(projectId, "Project ID is required.");
+
+    const parsed = parseCommandArgs(
+      optionArgs,
+      {
+        "issue-types": { type: "string" },
+        epics: { type: "string" },
+        milestones: { type: "string" },
+        "time-tracking": { type: "string" },
+        "auto-transition": { type: "string" },
+        "auto-assign": { type: "string" },
+        "auto-worklog": { type: "string" },
+        "require-worklog-before-completion": { type: "string" },
+      },
+      false
+    );
+
+    const payload = buildProjectFeaturesPayload(parsed.values);
+    if (Object.keys(payload).length === 0) {
+      throw new CliError("At least one feature flag is required.");
+    }
+
+    const result = await projectClient.update(projectId, payload);
+    printData(
+      {
+        id: result.id,
+        identifier: result.identifier,
+        name: result.name,
+        ...pickProjectFeatures(result),
+      },
+      context.output
+    );
+    return;
+  }
+
+  throw new CliError(`Unknown project features subcommand: ${subcommand}`);
+}
+
 export async function runProjectCommand(args, context) {
   const [subcommand, ...rest] = args;
 
-  if (!subcommand || subcommand === "--help" || subcommand === "help") {
+  if (!subcommand || subcommand === "--help" || subcommand === "-h" || subcommand === "help") {
+    printHelp();
+    return;
+  }
+
+  if (hasHelpFlag(rest)) {
     printHelp();
     return;
   }
@@ -46,6 +297,16 @@ export async function runProjectCommand(args, context) {
   const config = await resolveRuntimeConfig();
   const projectClient = new ProjectClient(new PlaneClient(config));
 
+  if (subcommand === "members") {
+    await runProjectMembersCommand(projectClient, rest, context);
+    return;
+  }
+
+  if (subcommand === "features") {
+    await runProjectFeaturesCommand(projectClient, rest, context);
+    return;
+  }
+
   if (subcommand === "ls") {
     const parsed = parseCommandArgs(
       rest,
@@ -84,6 +345,27 @@ export async function runProjectCommand(args, context) {
     return;
   }
 
+  if (subcommand === "summary") {
+    const parsed = parseCommandArgs(
+      rest,
+      {
+        fields: { type: "string" },
+      }
+    );
+
+    const [projectId] = parsed.positionals;
+    ensureValue(projectId, "Project ID is required.");
+
+    const result = await projectClient.summary(
+      projectId,
+      pickDefined({
+        fields: parsed.values.fields,
+      })
+    );
+    printData(result, context.output);
+    return;
+  }
+
   if (subcommand === "create") {
     const parsed = parseCommandArgs(
       rest,
@@ -100,7 +382,12 @@ export async function runProjectCommand(args, context) {
     ensureValue(parsed.values.name, "Project name is required.");
     ensureValue(parsed.values.identifier, "Project identifier is required.");
 
-    const result = await projectClient.create(buildProjectPayload(parsed.values));
+    const { createPayload, postCreateUpdatePayload } = splitProjectCreatePayload(parsed.values);
+    let result = await projectClient.create(createPayload);
+    if (Object.keys(postCreateUpdatePayload).length > 0) {
+      result = await projectClient.update(result.id, postCreateUpdatePayload);
+    }
+
     printData(result, context.output);
     return;
   }

package/src/commands/workspace.js

@@ -22,12 +22,12 @@ function workspaceRows(config) {
 export async function runWorkspaceCommand(args, context) {
   const [subcommand = "ls", ...rest] = args;
 
-  if (subcommand === "--help" || subcommand === "help") {
+  if (subcommand === "--help" || subcommand === "-h" || subcommand === "help") {
     printHelp();
     return;
   }
 
-  if (rest.includes("--help") || rest.includes("help")) {
+  if (rest.includes("--help") || rest.includes("-h") || rest.includes("help")) {
     printHelp();
     return;
   }

package/src/core/config.js

@@ -51,6 +51,9 @@ export async function loadConfig() {
 
   try {
     const raw = await readFile(configPath, "utf8");
+    if (!raw.trim()) {
+      return {};
+    }
     return sanitizeConfig(JSON.parse(raw));
   } catch (error) {
     if (error && error.code === "ENOENT") {

package/src/core/output.js

@@ -4,10 +4,27 @@ function stringifyValue(value) {
   return String(value);
 }
 
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
 export function printJson(data) {
   console.log(JSON.stringify(data, null, 2));
 }
 
+export function printKeyValue(data) {
+  const entries = Object.entries(data);
+  if (!entries.length) {
+    console.log("(empty)");
+    return;
+  }
+
+  const width = Math.max(...entries.map(([key]) => key.length));
+  for (const [key, value] of entries) {
+    console.log(`${key.padEnd(width, " ")}  ${stringifyValue(value)}`);
+  }
+}
+
 export function printTable(rows, columns) {
   if (!rows.length) {
     console.log("(empty)");
@@ -37,7 +54,7 @@ export function printTable(rows, columns) {
 }
 
 export function printData(data, options = {}) {
-  if (options.json) {
+  if (options.format === "json") {
     printJson(data);
     return;
   }
@@ -47,5 +64,34 @@ export function printData(data, options = {}) {
     return;
   }
 
-  printJson(data);
+  if (Array.isArray(data)) {
+    if (!data.length) {
+      console.log("(empty)");
+      return;
+    }
+
+    if (data.every(isPlainObject)) {
+      const objectKeys = [...new Set(data.flatMap((item) => Object.keys(item)))];
+      printTable(
+        data,
+        objectKeys.map((key) => ({
+          label: key,
+          get: (row) => row[key],
+        }))
+      );
+      return;
+    }
+
+    for (const item of data) {
+      console.log(`- ${stringifyValue(item)}`);
+    }
+    return;
+  }
+
+  if (isPlainObject(data)) {
+    printKeyValue(data);
+    return;
+  }
+
+  console.log(stringifyValue(data));
 }