trelly 0.1.0

package/src/cli/commands/custom-fields.ts

@@ -0,0 +1,75 @@
+import type { Command } from "commander";
+import { getClient, parseKvPairs } from "../context.ts";
+import { rootOpts, run } from "./run.ts";
+
+export function registerCustomFieldCommands(program: Command): void {
+  const fields = program
+    .command("custom-fields")
+    .description("Custom field operations");
+
+  fields.command("get <id>").action((id, _opts, cmd) =>
+    run(cmd, async () => {
+      const { client } = getClient(rootOpts(cmd).profile);
+      return client.customFieldGet(id);
+    }),
+  );
+
+  fields
+    .command("create")
+    .requiredOption("--board <boardId>", "Board id")
+    .requiredOption("--name <name>", "Field name")
+    .requiredOption("--type <type>", "text|number|date|checkbox|list")
+    .action((opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.customFieldCreate({
+          idModel: opts.board,
+          modelType: "board",
+          name: opts.name,
+          type: opts.type,
+        });
+      }),
+    );
+
+  fields
+    .command("update <id>")
+    .option("--params <kv...>", "key=value params")
+    .action((id, opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.customFieldUpdate(id, parseKvPairs(opts.params));
+      }),
+    );
+
+  fields.command("delete <id>").action((id, _opts, cmd) =>
+    run(cmd, async () => {
+      const { client } = getClient(rootOpts(cmd).profile);
+      return client.customFieldDelete(id);
+    }),
+  );
+
+  fields
+    .command("set-item <fieldId>")
+    .requiredOption("--card <cardId>", "Card id")
+    .option("--text <text>", "Text value")
+    .option("--number <number>", "Number value")
+    .option("--date <iso>", "Date value")
+    .option("--checked <bool>", "Checkbox value")
+    .action((fieldId, opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.customFieldUpdateItem(
+          fieldId,
+          { idCard: opts.card },
+          {
+            value: {
+              text: opts.text,
+              number: opts.number,
+              date: opts.date,
+              checked: opts.checked,
+            },
+          },
+        );
+      }),
+    );
+}

package/src/cli/commands/labels.ts

@@ -0,0 +1,47 @@
+import type { Command } from "commander";
+import { getClient, parseKvPairs } from "../context.ts";
+import { rootOpts, run } from "./run.ts";
+
+export function registerLabelCommands(program: Command): void {
+  const labels = program.command("labels").description("Label operations");
+
+  labels.command("get <id>").action((id, _opts, cmd) =>
+    run(cmd, async () => {
+      const { client } = getClient(rootOpts(cmd).profile);
+      return client.labelGet(id);
+    }),
+  );
+
+  labels
+    .command("create")
+    .requiredOption("--board <boardId>", "Board id")
+    .requiredOption("--name <name>", "Label name")
+    .requiredOption("--color <color>", "Label color")
+    .action((opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.labelCreate({
+          idBoard: opts.board,
+          name: opts.name,
+          color: opts.color,
+        });
+      }),
+    );
+
+  labels
+    .command("update <id>")
+    .option("--params <kv...>", "key=value params")
+    .action((id, opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.labelUpdate(id, parseKvPairs(opts.params));
+      }),
+    );
+
+  labels.command("delete <id>").action((id, _opts, cmd) =>
+    run(cmd, async () => {
+      const { client } = getClient(rootOpts(cmd).profile);
+      return client.labelDelete(id);
+    }),
+  );
+}

package/src/cli/commands/lists.ts

@@ -0,0 +1,54 @@
+import type { Command } from "commander";
+import { getClient, parseKvPairs } from "../context.ts";
+import { rootOpts, run } from "./run.ts";
+
+export function registerListCommands(program: Command): void {
+  const lists = program.command("lists").description("List (column) operations");
+
+  lists.command("get <id>").action((id, _opts, cmd) =>
+    run(cmd, async () => {
+      const { client } = getClient(rootOpts(cmd).profile);
+      return client.listGet(id);
+    }),
+  );
+
+  lists
+    .command("create")
+    .requiredOption("--board <boardId>", "Board id")
+    .requiredOption("--name <name>", "List name")
+    .option("--pos <pos>", "Position")
+    .action((opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.listCreate({
+          idBoard: opts.board,
+          name: opts.name,
+          pos: opts.pos,
+        });
+      }),
+    );
+
+  lists
+    .command("update <id>")
+    .option("--params <kv...>", "key=value params")
+    .action((id, opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.listUpdate(id, parseKvPairs(opts.params));
+      }),
+    );
+
+  lists.command("archive <id>").action((id, _opts, cmd) =>
+    run(cmd, async () => {
+      const { client } = getClient(rootOpts(cmd).profile);
+      return client.listArchive(id);
+    }),
+  );
+
+  lists.command("cards <id>").action((id, _opts, cmd) =>
+    run(cmd, async () => {
+      const { client } = getClient(rootOpts(cmd).profile);
+      return client.listCards(id);
+    }),
+  );
+}

package/src/cli/commands/members.ts

@@ -0,0 +1,14 @@
+import type { Command } from "commander";
+import { getClient } from "../context.ts";
+import { rootOpts, run } from "./run.ts";
+
+export function registerMemberCommands(program: Command): void {
+  const members = program.command("members").description("Member operations");
+
+  members.command("me").action((_opts, cmd) =>
+    run(cmd, async () => {
+      const { client } = getClient(rootOpts(cmd).profile);
+      return client.memberMe();
+    }),
+  );
+}

package/src/cli/commands/orgs.ts

@@ -0,0 +1,23 @@
+import type { Command } from "commander";
+import { getClient } from "../context.ts";
+import { rootOpts, run } from "./run.ts";
+
+export function registerOrgCommands(program: Command): void {
+  const orgs = program
+    .command("orgs")
+    .description("Workspace (organization) operations");
+
+  orgs.command("get <id>").action((id, _opts, cmd) =>
+    run(cmd, async () => {
+      const { client } = getClient(rootOpts(cmd).profile);
+      return client.orgGet(id);
+    }),
+  );
+
+  orgs.command("boards <id>").action((id, _opts, cmd) =>
+    run(cmd, async () => {
+      const { client } = getClient(rootOpts(cmd).profile);
+      return client.orgBoards(id);
+    }),
+  );
+}

package/src/cli/commands/run.ts

@@ -0,0 +1,32 @@
+import type { Command } from "commander";
+import { TrelloError } from "../../api/client.ts";
+import { failure, getClient, printResult, success } from "../context.ts";
+
+export function rootOpts(cmd: Command): {
+  profile?: string;
+  pretty: boolean;
+  json: boolean;
+} {
+  let node: Command | null = cmd;
+  while (node?.parent) node = node.parent;
+  return node?.opts() ?? {};
+}
+
+export async function run<T>(cmd: Command, fn: () => Promise<T>): Promise<void> {
+  const opts = rootOpts(cmd);
+  try {
+    const { profileName } = getClient(opts.profile);
+    const data = await fn();
+    printResult(success(profileName, data), opts);
+  } catch (err) {
+    if (err instanceof TrelloError) {
+      printResult(
+        failure(err.message, { status: err.status, details: err.body }),
+        opts,
+      );
+    } else {
+      printResult(failure(err instanceof Error ? err.message : String(err)), opts);
+    }
+    process.exitCode = 1;
+  }
+}

package/src/cli/commands/search.ts

@@ -0,0 +1,23 @@
+import type { Command } from "commander";
+import { getClient } from "../context.ts";
+import { rootOpts, run } from "./run.ts";
+
+export function registerSearchCommands(program: Command): void {
+  program
+    .command("search")
+    .description("Search boards, cards, members, and actions")
+    .argument("<query>", "Search query")
+    .option("--model-types <types>", "Comma-separated: cards,boards,members,...")
+    .option("--cards-limit <n>", "Max cards")
+    .option("--boards-limit <n>", "Max boards")
+    .action((query, opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.search(query, {
+          modelTypes: opts.modelTypes,
+          cards_limit: opts.cardsLimit,
+          boards_limit: opts.boardsLimit,
+        });
+      }),
+    );
+}

package/src/cli/commands/ui.ts

@@ -0,0 +1,48 @@
+import type { Command } from "commander";
+import { failure, getClient, printResult } from "../context.ts";
+import { rootOpts } from "./run.ts";
+
+const ENTER_ALT_SCREEN = "\u001b[?1049h\u001b[H";
+const LEAVE_ALT_SCREEN = "\u001b[?1049l";
+
+export async function launchUi(
+  boardId: string | undefined,
+  cmd: Command,
+): Promise<void> {
+  const root = rootOpts(cmd);
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    printResult(
+      failure("interactive mode requires a terminal — run trelly --help for commands"),
+      root,
+    );
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    const { profileName, client } = getClient(root.profile);
+    const [{ render }, { createElement }, { App }] = await Promise.all([
+      import("ink"),
+      import("react"),
+      import("../ui/app.tsx"),
+    ]);
+    process.stdout.write(ENTER_ALT_SCREEN);
+    try {
+      const app = render(createElement(App, { client, boardId, profileName }));
+      await app.waitUntilExit();
+    } finally {
+      process.stdout.write(LEAVE_ALT_SCREEN);
+    }
+  } catch (err) {
+    printResult(failure(err instanceof Error ? err.message : String(err)), root);
+    process.exitCode = 1;
+  }
+}
+
+export function registerUiCommand(program: Command): void {
+  program
+    .command("ui [boardId]")
+    .description(
+      "Interactive kanban — picks a board when no id is given (arrows/hjkl, ⏎, r, q)",
+    )
+    .action((boardId, _opts, cmd) => launchUi(boardId, cmd));
+}

package/src/cli/commands/webhooks.ts

@@ -0,0 +1,44 @@
+import type { Command } from "commander";
+import { getClient } from "../context.ts";
+import { rootOpts, run } from "./run.ts";
+
+export function registerWebhookCommands(program: Command): void {
+  const webhooks = program.command("webhooks").description("Webhook operations");
+
+  webhooks.command("list").action((_opts, cmd) =>
+    run(cmd, async () => {
+      const { client } = getClient(rootOpts(cmd).profile);
+      return client.webhooksForToken();
+    }),
+  );
+
+  webhooks
+    .command("create")
+    .requiredOption("--callback <url>", "Callback URL")
+    .requiredOption("--id-model <id>", "Board or card id to watch")
+    .option("--desc <desc>", "Description")
+    .action((opts, cmd) =>
+      run(cmd, async () => {
+        const { client } = getClient(rootOpts(cmd).profile);
+        return client.webhookCreate({
+          callbackURL: opts.callback,
+          idModel: opts.idModel,
+          description: opts.desc,
+        });
+      }),
+    );
+
+  webhooks.command("get <id>").action((id, _opts, cmd) =>
+    run(cmd, async () => {
+      const { client } = getClient(rootOpts(cmd).profile);
+      return client.webhookGet(id);
+    }),
+  );
+
+  webhooks.command("delete <id>").action((id, _opts, cmd) =>
+    run(cmd, async () => {
+      const { client } = getClient(rootOpts(cmd).profile);
+      return client.webhookDelete(id);
+    }),
+  );
+}

package/src/cli/context.ts

@@ -0,0 +1,70 @@
+import { createClient } from "../api/client.ts";
+import { resolveProfile } from "../auth/profiles.ts";
+
+export function getClient(profile?: string) {
+  const { name, profile: creds } = resolveProfile(profile);
+  return {
+    profileName: name,
+    client: createClient(creds.apiKey, creds.token),
+  };
+}
+
+export type CliResult<T = unknown> = {
+  ok: true;
+  profile: string;
+  data: T;
+};
+
+export type CliError = {
+  ok: false;
+  profile?: string;
+  error: string;
+  status?: number;
+  details?: unknown;
+};
+
+export function success<T>(profile: string, data: T): CliResult<T> {
+  return { ok: true, profile, data };
+}
+
+export function failure(
+  error: string,
+  extra: Omit<CliError, "ok" | "error"> = {},
+): CliError {
+  return { ok: false, error, ...extra };
+}
+
+export type OutputOptions = { json?: boolean; pretty?: boolean };
+
+export function printResult(
+  result: CliResult | CliError,
+  opts: OutputOptions = {},
+): void {
+  if (opts.json) {
+    const text = opts.pretty ? JSON.stringify(result, null, 2) : JSON.stringify(result);
+    console.log(text);
+    return;
+  }
+  void import("./ui/static.tsx").then(({ renderResult }) => renderResult(result));
+}
+
+export function parseKvPairs(pairs: string[] | undefined): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const pair of pairs ?? []) {
+    const idx = pair.indexOf("=");
+    if (idx <= 0) {
+      throw new Error(`Invalid key=value pair: ${pair}`);
+    }
+    out[pair.slice(0, idx)] = pair.slice(idx + 1);
+  }
+  return out;
+}
+
+export function parseJsonFlag(raw: string | undefined, label: string): unknown {
+  if (!raw) return undefined;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new Error(`${label} must be valid JSON`);
+  }
+}

package/src/cli/index.ts

@@ -0,0 +1,47 @@
+import { Command } from "commander";
+import { packageVersion } from "../version.ts";
+import { registerActionCommands } from "./commands/actions.ts";
+import { registerApiCommand } from "./commands/api.ts";
+import { registerAuthCommands } from "./commands/auth.ts";
+import { registerBoardCommands } from "./commands/boards.ts";
+import { registerCardCommands } from "./commands/cards.ts";
+import { registerChecklistCommands } from "./commands/checklists.ts";
+import { registerCustomFieldCommands } from "./commands/custom-fields.ts";
+import { registerLabelCommands } from "./commands/labels.ts";
+import { registerListCommands } from "./commands/lists.ts";
+import { registerMemberCommands } from "./commands/members.ts";
+import { registerOrgCommands } from "./commands/orgs.ts";
+import { registerSearchCommands } from "./commands/search.ts";
+import { launchUi, registerUiCommand } from "./commands/ui.ts";
+import { registerWebhookCommands } from "./commands/webhooks.ts";
+
+const program = new Command();
+
+program
+  .name("trelly")
+  .description("trelly — Trello CLI; bare `trelly` opens the interactive board UI")
+  .version(packageVersion())
+  .option("-p, --profile <name>", "Auth profile (or TRELLO_PROFILE env)")
+  .option("--json", "Output the raw JSON envelope", false)
+  .option("--pretty", "Indent --json output", false)
+  .action((_opts, cmd) => launchUi(undefined, cmd));
+
+registerAuthCommands(program);
+registerBoardCommands(program);
+registerListCommands(program);
+registerCardCommands(program);
+registerChecklistCommands(program);
+registerLabelCommands(program);
+registerCustomFieldCommands(program);
+registerSearchCommands(program);
+registerWebhookCommands(program);
+registerMemberCommands(program);
+registerOrgCommands(program);
+registerActionCommands(program);
+registerApiCommand(program);
+registerUiCommand(program);
+
+program.parseAsync(process.argv).catch((err) => {
+  console.error(err instanceof Error ? err.message : err);
+  process.exit(1);
+});