not-manage 0.1.17

package/src/commands-matters.js

@@ -0,0 +1,214 @@
+const {
+  fetchMatter,
+  fetchMattersPage,
+  getValidAccessToken,
+} = require("./clio-api");
+const { getConfig, getTokenSet } = require("./store");
+const {
+  clip,
+  compactQuery,
+  fetchPages,
+  formatBoolean,
+  parseLimit,
+  printKeyValueRows,
+  readContactName,
+  readUserName,
+} = require("./resource-utils");
+const { maybeRedactData, maybeRedactPayload } = require("./redaction");
+
+const DEFAULT_LIST_FIELDS =
+  "id,display_number,number,description,status,billable,open_date,close_date,pending_date,client{id,name,first_name,last_name},practice_area{id,name},responsible_attorney{id,name,email},responsible_staff{id,name,email},originating_attorney{id,name,email},created_at,updated_at";
+const DEFAULT_GET_FIELDS =
+  "id,display_number,number,description,status,billable,open_date,close_date,pending_date,client{id,name,first_name,last_name},practice_area{id,name},responsible_attorney{id,name,email},responsible_staff{id,name,email},originating_attorney{id,name,email},created_at,updated_at";
+
+function readStatus(status) {
+  if (!status) {
+    return "-";
+  }
+  if (typeof status === "string") {
+    return status;
+  }
+  return status.name || status.value || status.state || "-";
+}
+
+function readClientName(matter) {
+  const single = readContactName(matter.client);
+  if (single !== "-") {
+    return single;
+  }
+
+  const list = Array.isArray(matter.clients) ? matter.clients : [];
+  if (list.length > 0) {
+    return readContactName(list[0]);
+  }
+
+  return "-";
+}
+
+function formatMatterRow(matter) {
+  const id = matter.id || "-";
+  const displayNumber = matter.display_number || matter.number || "-";
+  const status = readStatus(matter.status);
+  const client = readClientName(matter);
+  const description = matter.description || "-";
+
+  return {
+    id: String(id),
+    displayNumber: String(displayNumber),
+    status: String(status),
+    client: String(client),
+    description: String(description),
+  };
+}
+
+function buildMatterQuery(options) {
+  return compactQuery({
+    client_id: options.clientId || undefined,
+    created_since: options.createdSince || undefined,
+    fields: options.fields || DEFAULT_LIST_FIELDS,
+    limit: parseLimit(options.limit),
+    order: options.order || undefined,
+    originating_attorney_id: options.originatingAttorneyId || undefined,
+    page_token: options.pageToken || undefined,
+    practice_area_id: options.practiceAreaId || undefined,
+    query: options.query || undefined,
+    responsible_attorney_id: options.responsibleAttorneyId || undefined,
+    responsible_staff_id: options.responsibleStaffId || undefined,
+    status: options.status || undefined,
+    updated_since: options.updatedSince || undefined,
+  });
+}
+
+function printMatterList(matterRows, options) {
+  if (matterRows.length === 0) {
+    console.log("No matters found for the selected filters.");
+    return;
+  }
+
+  const rows = matterRows.slice(0, 50);
+
+  console.log("ID       MATTER                STATUS    CLIENT               DESCRIPTION");
+  console.log("-------- --------------------- --------- -------------------- ------------------------------");
+
+  rows.forEach((row) => {
+    const line = [
+      clip(row.id, 8).padEnd(8, " "),
+      clip(row.displayNumber, 21).padEnd(21, " "),
+      clip(row.status, 9).padEnd(9, " "),
+      clip(row.client, 20).padEnd(20, " "),
+      clip(row.description, 30),
+    ].join(" ");
+
+    console.log(line);
+  });
+
+  if (matterRows.length > rows.length) {
+    console.log(
+      `Showing ${rows.length} of ${matterRows.length} matters. Use --json for full output.`
+    );
+  }
+
+  if (!options.all && options.nextPageUrl) {
+    console.log("");
+    console.log("More results are available.");
+    console.log("Run again with `--all` or pass `--page-token` from `--json` output.");
+  }
+}
+
+function printMatter(matter) {
+  printKeyValueRows([
+    ["ID", matter.id],
+    ["Matter", matter.display_number || matter.number],
+    ["Description", matter.description],
+    ["Status", readStatus(matter.status)],
+    ["Client", readClientName(matter)],
+    ["Practice Area", matter.practice_area?.name],
+    ["Responsible Attorney", readUserName(matter.responsible_attorney)],
+    ["Responsible Staff", readUserName(matter.responsible_staff)],
+    ["Originating Attorney", readUserName(matter.originating_attorney)],
+    ["Billable", formatBoolean(matter.billable)],
+    ["Open Date", matter.open_date],
+    ["Pending Date", matter.pending_date],
+    ["Close Date", matter.close_date],
+    ["Created", matter.created_at],
+    ["Updated", matter.updated_at],
+  ]);
+}
+
+async function getAuthContext() {
+  const config = await getConfig();
+  const tokenSet = await getTokenSet();
+  const accessToken = await getValidAccessToken(config, tokenSet);
+  return { config, accessToken };
+}
+
+async function mattersList(options = {}) {
+  const query = buildMatterQuery(options);
+  const { config, accessToken } = await getAuthContext();
+  const result = await fetchPages(
+    (pageQuery, nextPageUrl) => fetchMattersPage(config, accessToken, pageQuery, nextPageUrl),
+    query,
+    Boolean(options.all)
+  );
+
+  if (options.json) {
+    const firstPage = maybeRedactPayload(result.firstPage, options, "matter");
+    if (!options.all) {
+      console.log(JSON.stringify(firstPage, null, 2));
+      return;
+    }
+
+    const data = maybeRedactData(result.data, options, "matter");
+    console.log(
+      JSON.stringify(
+        {
+          data,
+          meta: {
+            pages_fetched: result.pagesFetched,
+            returned_count: data.length,
+          },
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+
+  const rows = maybeRedactData(result.data, options, "matter").map(formatMatterRow);
+  printMatterList(rows, { all: Boolean(options.all), nextPageUrl: result.nextPageUrl });
+  console.log("");
+  console.log(
+    `Returned ${rows.length} matter${rows.length === 1 ? "" : "s"} across ${result.pagesFetched} page${result.pagesFetched === 1 ? "" : "s"}.`
+  );
+}
+
+async function mattersGet(options = {}) {
+  if (!options.id) {
+    throw new Error("Usage: not-manage matters get <id> [--fields ...] [--json]");
+  }
+
+  const { config, accessToken } = await getAuthContext();
+  const payload = await fetchMatter(config, accessToken, options.id, {
+    fields: options.fields || DEFAULT_GET_FIELDS,
+  });
+  const redactedPayload = maybeRedactPayload(payload, options, "matter");
+
+  if (options.json) {
+    console.log(JSON.stringify(redactedPayload, null, 2));
+    return;
+  }
+
+  printMatter(redactedPayload?.data || {});
+}
+
+module.exports = {
+  mattersGet,
+  mattersList,
+  __private: {
+    buildMatterQuery,
+    formatMatterRow,
+    printMatter,
+    printMatterList,
+  },
+};

package/src/commands-practice-areas.js

@@ -0,0 +1,249 @@
+const {
+  fetchMatter,
+  fetchPracticeArea,
+  fetchPracticeAreasPage,
+  getValidAccessToken,
+} = require("./clio-api");
+const { getConfig, getTokenSet } = require("./store");
+const {
+  clip,
+  compactQuery,
+  fetchPages,
+  parseLimit,
+  printKeyValueRows,
+} = require("./resource-utils");
+const { maybeRedactData, maybeRedactPayload } = require("./redaction");
+
+const DEFAULT_LIST_FIELDS = "id,code,name,category,created_at,updated_at";
+const DEFAULT_GET_FIELDS = "id,code,name,category,created_at,updated_at";
+const MATTER_LOOKUP_FIELDS = "id,practice_area{id}";
+
+function buildPracticeAreaQuery(options) {
+  return compactQuery({
+    code: options.code || undefined,
+    created_since: options.createdSince || undefined,
+    fields: options.fields || DEFAULT_LIST_FIELDS,
+    limit: parseLimit(options.limit),
+    name: options.name || undefined,
+    order: options.order || undefined,
+    page_token: options.pageToken || undefined,
+    updated_since: options.updatedSince || undefined,
+  });
+}
+
+function matchesTimestampOnOrAfter(value, threshold) {
+  if (!threshold) {
+    return true;
+  }
+
+  const valueTime = Date.parse(value);
+  const thresholdTime = Date.parse(threshold);
+
+  if (Number.isNaN(valueTime) || Number.isNaN(thresholdTime)) {
+    return true;
+  }
+
+  return valueTime >= thresholdTime;
+}
+
+function practiceAreaMatchesOptions(practiceArea, options = {}) {
+  const code = String(practiceArea?.code || "");
+  const name = String(practiceArea?.name || "");
+
+  if (options.code && code.toLowerCase() !== String(options.code).toLowerCase()) {
+    return false;
+  }
+
+  if (
+    options.name &&
+    !name.toLowerCase().includes(String(options.name).trim().toLowerCase())
+  ) {
+    return false;
+  }
+
+  if (!matchesTimestampOnOrAfter(practiceArea?.created_at, options.createdSince)) {
+    return false;
+  }
+
+  if (!matchesTimestampOnOrAfter(practiceArea?.updated_at, options.updatedSince)) {
+    return false;
+  }
+
+  return true;
+}
+
+function buildSinglePageResult(data) {
+  return {
+    data,
+    firstPage: {
+      data,
+      meta: {
+        paging: {},
+        records: data.length,
+      },
+    },
+    nextPageUrl: null,
+    pagesFetched: 1,
+  };
+}
+
+async function practiceAreasListForMatter(config, accessToken, options = {}) {
+  const matterPayload = await fetchMatter(config, accessToken, options.matterId, {
+    fields: MATTER_LOOKUP_FIELDS,
+  });
+  const practiceAreaId = matterPayload?.data?.practice_area?.id;
+
+  if (!practiceAreaId) {
+    return buildSinglePageResult([]);
+  }
+
+  const payload = await fetchPracticeArea(config, accessToken, practiceAreaId, {
+    fields: options.fields || DEFAULT_GET_FIELDS,
+  });
+  const practiceArea = payload?.data;
+  const data =
+    practiceArea && practiceAreaMatchesOptions(practiceArea, options)
+      ? [practiceArea]
+      : [];
+
+  return buildSinglePageResult(data);
+}
+
+function formatPracticeAreaRow(practiceArea) {
+  return {
+    id: String(practiceArea.id || "-"),
+    code: String(practiceArea.code || "-"),
+    name: String(practiceArea.name || "-"),
+    category: String(practiceArea.category || "-"),
+  };
+}
+
+function printPracticeAreaList(rows, options) {
+  if (rows.length === 0) {
+    console.log("No practice areas found for the selected filters.");
+    return;
+  }
+
+  const visibleRows = rows.slice(0, 50);
+  console.log("ID       CODE         NAME                         CATEGORY");
+  console.log("-------- ------------ ---------------------------- ------------------------------");
+
+  visibleRows.forEach((row) => {
+    const line = [
+      clip(row.id, 8).padEnd(8, " "),
+      clip(row.code, 12).padEnd(12, " "),
+      clip(row.name, 28).padEnd(28, " "),
+      clip(row.category, 30),
+    ].join(" ");
+
+    console.log(line);
+  });
+
+  if (rows.length > visibleRows.length) {
+    console.log(
+      `Showing ${visibleRows.length} of ${rows.length} practice areas. Use --json for full output.`
+    );
+  }
+
+  if (!options.all && options.nextPageUrl) {
+    console.log("");
+    console.log("More results are available.");
+    console.log("Run again with `--all` or pass `--page-token` from `--json` output.");
+  }
+}
+
+function printPracticeArea(practiceArea) {
+  printKeyValueRows([
+    ["ID", practiceArea.id],
+    ["Code", practiceArea.code],
+    ["Name", practiceArea.name],
+    ["Category", practiceArea.category],
+    ["Created", practiceArea.created_at],
+    ["Updated", practiceArea.updated_at],
+  ]);
+}
+
+async function getAuthContext() {
+  const config = await getConfig();
+  const tokenSet = await getTokenSet();
+  const accessToken = await getValidAccessToken(config, tokenSet);
+  return { config, accessToken };
+}
+
+async function practiceAreasList(options = {}) {
+  const { config, accessToken } = await getAuthContext();
+  const result = options.matterId
+    ? await practiceAreasListForMatter(config, accessToken, options)
+    : await fetchPages(
+        (pageQuery, nextPageUrl) =>
+          fetchPracticeAreasPage(config, accessToken, pageQuery, nextPageUrl),
+        buildPracticeAreaQuery(options),
+        Boolean(options.all)
+      );
+
+  if (options.json) {
+    const firstPage = maybeRedactPayload(result.firstPage, options, "practice-area");
+    if (!options.all) {
+      console.log(JSON.stringify(firstPage, null, 2));
+      return;
+    }
+
+    const data = maybeRedactData(result.data, options, "practice-area");
+    console.log(
+      JSON.stringify(
+        {
+          data,
+          meta: {
+            pages_fetched: result.pagesFetched,
+            returned_count: data.length,
+          },
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+
+  const rows = maybeRedactData(result.data, options, "practice-area").map(
+    formatPracticeAreaRow
+  );
+  printPracticeAreaList(rows, { all: Boolean(options.all), nextPageUrl: result.nextPageUrl });
+  console.log("");
+  console.log(
+    `Returned ${rows.length} practice area${rows.length === 1 ? "" : "s"} across ${result.pagesFetched} page${result.pagesFetched === 1 ? "" : "s"}.`
+  );
+}
+
+async function practiceAreasGet(options = {}) {
+  if (!options.id) {
+    throw new Error("Usage: not-manage practice-areas get <id> [--fields ...] [--json]");
+  }
+
+  const { config, accessToken } = await getAuthContext();
+  const payload = await fetchPracticeArea(config, accessToken, options.id, {
+    fields: options.fields || DEFAULT_GET_FIELDS,
+  });
+  const redactedPayload = maybeRedactPayload(payload, options, "practice-area");
+
+  if (options.json) {
+    console.log(JSON.stringify(redactedPayload, null, 2));
+    return;
+  }
+
+  printPracticeArea(redactedPayload?.data || {});
+}
+
+module.exports = {
+  practiceAreasGet,
+  practiceAreasList,
+  __private: {
+    buildSinglePageResult,
+    buildPracticeAreaQuery,
+    formatPracticeAreaRow,
+    practiceAreaMatchesOptions,
+    practiceAreasListForMatter,
+    printPracticeArea,
+    printPracticeAreaList,
+  },
+};

package/src/commands-tasks.js

@@ -0,0 +1,213 @@
+const {
+  fetchTask,
+  fetchTasksPage,
+  getValidAccessToken,
+} = require("./clio-api");
+const { getConfig, getTokenSet } = require("./store");
+const {
+  clip,
+  compactQuery,
+  fetchPages,
+  formatBoolean,
+  parseLimit,
+  printKeyValueRows,
+  readMatterLabel,
+  readUserName,
+} = require("./resource-utils");
+const { maybeRedactData, maybeRedactPayload } = require("./redaction");
+
+const DEFAULT_LIST_FIELDS =
+  "id,name,description,status,priority,due_at,created_at,updated_at,matter{id,display_number,number,description,client},assignee{id,name},assigner{id,name},task_type{id,name}";
+const DEFAULT_GET_FIELDS =
+  "id,name,description,status,priority,due_at,created_at,updated_at,matter{id,display_number,number,description,client},assignee{id,name},assigner{id,name},task_type{id,name}";
+
+function readTaskStatus(status) {
+  if (!status) {
+    return "-";
+  }
+
+  if (typeof status === "string") {
+    return status;
+  }
+
+  return status.name || status.value || status.state || "-";
+}
+
+function readTaskComplete(task) {
+  if (typeof task?.complete === "boolean") {
+    return task.complete;
+  }
+
+  if (typeof task?.status === "string") {
+    return task.status.toLowerCase() === "complete";
+  }
+
+  return undefined;
+}
+
+function buildTaskQuery(options) {
+  return compactQuery({
+    client_id: options.clientId || undefined,
+    complete:
+      options.complete === undefined || options.complete === null
+        ? undefined
+        : Boolean(options.complete),
+    created_since: options.createdSince || undefined,
+    due_at_from: options.dueAtFrom || undefined,
+    due_at_to: options.dueAtTo || undefined,
+    fields: options.fields || DEFAULT_LIST_FIELDS,
+    limit: parseLimit(options.limit),
+    matter_id: options.matterId || undefined,
+    order: options.order || undefined,
+    page_token: options.pageToken || undefined,
+    priority: options.priority || undefined,
+    query: options.query || undefined,
+    responsible_attorney_id: options.responsibleAttorneyId || undefined,
+    status: options.status || undefined,
+    task_type_id: options.taskTypeId || undefined,
+    updated_since: options.updatedSince || undefined,
+  });
+}
+
+function formatTaskRow(task) {
+  return {
+    id: String(task.id || "-"),
+    status: String(readTaskStatus(task.status)),
+    dueAt: String(task.due_at || "-"),
+    priority: String(task.priority || "-"),
+    matter: readMatterLabel(task.matter),
+    task: String(task.name || "-"),
+  };
+}
+
+function printTaskList(rows, options) {
+  if (rows.length === 0) {
+    console.log("No tasks found for the selected filters.");
+    return;
+  }
+
+  const visibleRows = rows.slice(0, 50);
+  console.log("ID       STATUS       DUE          PRIORITY MATTER               TASK");
+  console.log("-------- ------------ ------------ -------- -------------------- ------------------------------");
+
+  visibleRows.forEach((row) => {
+    const line = [
+      clip(row.id, 8).padEnd(8, " "),
+      clip(row.status, 12).padEnd(12, " "),
+      clip(row.dueAt, 12).padEnd(12, " "),
+      clip(row.priority, 8).padEnd(8, " "),
+      clip(row.matter, 20).padEnd(20, " "),
+      clip(row.task, 30),
+    ].join(" ");
+
+    console.log(line);
+  });
+
+  if (rows.length > visibleRows.length) {
+    console.log(`Showing ${visibleRows.length} of ${rows.length} tasks. Use --json for full output.`);
+  }
+
+  if (!options.all && options.nextPageUrl) {
+    console.log("");
+    console.log("More results are available.");
+    console.log("Run again with `--all` or pass `--page-token` from `--json` output.");
+  }
+}
+
+function printTask(task) {
+  printKeyValueRows([
+    ["ID", task.id],
+    ["Name", task.name],
+    ["Description", task.description],
+    ["Status", readTaskStatus(task.status)],
+    ["Priority", task.priority],
+    ["Due", task.due_at],
+    ["Complete", formatBoolean(readTaskComplete(task))],
+    ["Matter", readMatterLabel(task.matter)],
+    ["Assignee", readUserName(task.assignee)],
+    ["Assigner", readUserName(task.assigner)],
+    ["Task Type", task.task_type?.name],
+    ["Created", task.created_at],
+    ["Updated", task.updated_at],
+  ]);
+}
+
+async function getAuthContext() {
+  const config = await getConfig();
+  const tokenSet = await getTokenSet();
+  const accessToken = await getValidAccessToken(config, tokenSet);
+  return { config, accessToken };
+}
+
+async function tasksList(options = {}) {
+  const query = buildTaskQuery(options);
+  const { config, accessToken } = await getAuthContext();
+  const result = await fetchPages(
+    (pageQuery, nextPageUrl) => fetchTasksPage(config, accessToken, pageQuery, nextPageUrl),
+    query,
+    Boolean(options.all)
+  );
+
+  if (options.json) {
+    const firstPage = maybeRedactPayload(result.firstPage, options, "task");
+    if (!options.all) {
+      console.log(JSON.stringify(firstPage, null, 2));
+      return;
+    }
+
+    const data = maybeRedactData(result.data, options, "task");
+    console.log(
+      JSON.stringify(
+        {
+          data,
+          meta: {
+            pages_fetched: result.pagesFetched,
+            returned_count: data.length,
+          },
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+
+  const rows = maybeRedactData(result.data, options, "task").map(formatTaskRow);
+  printTaskList(rows, { all: Boolean(options.all), nextPageUrl: result.nextPageUrl });
+  console.log("");
+  console.log(
+    `Returned ${rows.length} task${rows.length === 1 ? "" : "s"} across ${result.pagesFetched} page${result.pagesFetched === 1 ? "" : "s"}.`
+  );
+}
+
+async function tasksGet(options = {}) {
+  if (!options.id) {
+    throw new Error("Usage: not-manage tasks get <id> [--fields ...] [--json]");
+  }
+
+  const { config, accessToken } = await getAuthContext();
+  const payload = await fetchTask(config, accessToken, options.id, {
+    fields: options.fields || DEFAULT_GET_FIELDS,
+  });
+  const redactedPayload = maybeRedactPayload(payload, options, "task");
+
+  if (options.json) {
+    console.log(JSON.stringify(redactedPayload, null, 2));
+    return;
+  }
+
+  printTask(redactedPayload?.data || {});
+}
+
+module.exports = {
+  tasksGet,
+  tasksList,
+  __private: {
+    buildTaskQuery,
+    formatTaskRow,
+    readTaskComplete,
+    printTask,
+    printTaskList,
+    readTaskStatus,
+  },
+};