claude-trello-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,654 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command6 } from "commander";
+
+// src/commands/login.ts
+import { Command } from "commander";
+import { input, password } from "@inquirer/prompts";
+import chalk from "chalk";
+import ora from "ora";
+
+// src/lib/config.ts
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync
+} from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_DIR = join(homedir(), ".config", "claude-trello");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+function ensureDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function getConfig() {
+  ensureDir();
+  if (!existsSync(CONFIG_FILE)) return {};
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveConfig(update) {
+  ensureDir();
+  const current = getConfig();
+  const merged = { ...current, ...update };
+  writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2), { mode: 384 });
+}
+function clearConfig() {
+  if (existsSync(CONFIG_FILE)) {
+    unlinkSync(CONFIG_FILE);
+  }
+}
+function getServerUrl() {
+  const config = getConfig();
+  return config.serverUrl || process.env.CLAUDE_TRELLO_URL || "http://localhost:3000";
+}
+function getSessionCookie() {
+  return getConfig().sessionCookie;
+}
+function isLoggedIn() {
+  return !!getSessionCookie();
+}
+
+// src/lib/api.ts
+var ApiError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "ApiError";
+  }
+};
+async function apiFetch(path, options) {
+  const serverUrl = getServerUrl();
+  const cookie = getSessionCookie();
+  if (!cookie) {
+    throw new ApiError(
+      401,
+      "Not logged in. Run `claude-trello login` first."
+    );
+  }
+  const res = await fetch(`${serverUrl}${path}`, {
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      Cookie: cookie,
+      ...options?.headers ?? {}
+    },
+    redirect: "manual"
+  });
+  if (res.status === 401) {
+    throw new ApiError(
+      401,
+      "Session expired. Run `claude-trello login` to re-authenticate."
+    );
+  }
+  if (!res.ok) {
+    let errorMsg = `${res.status} ${res.statusText}`;
+    try {
+      const body = await res.json();
+      if (body.error) errorMsg = body.error;
+    } catch {
+    }
+    throw new ApiError(res.status, errorMsg);
+  }
+  return res.json();
+}
+async function signIn(serverUrl, email, password2) {
+  const res = await fetch(`${serverUrl}/api/auth/sign-in/email`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ email, password: password2 }),
+    redirect: "manual"
+  });
+  if (!res.ok) {
+    let errorMsg = "Sign-in failed";
+    try {
+      const body = await res.json();
+      errorMsg = body.message || body.error || errorMsg;
+    } catch {
+    }
+    throw new ApiError(res.status, errorMsg);
+  }
+  const setCookieHeaders = res.headers.getSetCookie?.() ?? [];
+  const cookies = setCookieHeaders.map((c) => c.split(";")[0]).join("; ");
+  if (!cookies) {
+    throw new ApiError(500, "No session cookie received from server");
+  }
+  const data = await res.json();
+  return { cookies, user: data.user };
+}
+async function getIntegrationStatus() {
+  return apiFetch("/api/settings/status");
+}
+async function getBoards() {
+  return apiFetch("/api/trello/boards");
+}
+async function getBoardData(boardId) {
+  return apiFetch(
+    `/api/trello/cards?boardId=${encodeURIComponent(boardId)}`
+  );
+}
+async function getCredentials() {
+  return apiFetch("/api/cli/credentials");
+}
+
+// src/commands/login.ts
+var loginCommand = new Command("login").description("Sign in to Claude Trello Bridge").option("-s, --server <url>", "Server URL (default: http://localhost:3000)").action(async (opts) => {
+  const serverUrl = opts.server || getServerUrl();
+  console.log(chalk.bold("Sign in to Claude Trello Bridge"));
+  console.log(chalk.dim(`Server: ${serverUrl}
+`));
+  const email = await input({ message: "Email:" });
+  const pass = await password({ message: "Password:" });
+  const spinner = ora("Signing in...").start();
+  try {
+    const { cookies, user } = await signIn(serverUrl, email, pass);
+    saveConfig({
+      serverUrl,
+      sessionCookie: cookies,
+      userEmail: user.email,
+      userName: user.name
+    });
+    spinner.succeed(
+      `Signed in as ${chalk.bold(user.name)} (${user.email})`
+    );
+  } catch (err) {
+    spinner.fail(err instanceof Error ? err.message : "Sign-in failed");
+    process.exit(1);
+  }
+});
+
+// src/commands/logout.ts
+import { Command as Command2 } from "commander";
+import chalk2 from "chalk";
+var logoutCommand = new Command2("logout").description("Sign out and clear stored session").action(() => {
+  if (!isLoggedIn()) {
+    console.log(chalk2.dim("Not currently logged in."));
+    return;
+  }
+  const config = getConfig();
+  clearConfig();
+  console.log(
+    chalk2.green(
+      `Signed out${config.userEmail ? ` (${config.userEmail})` : ""}.`
+    )
+  );
+});
+
+// src/commands/run.ts
+import { resolve } from "path";
+import { Command as Command3 } from "commander";
+import { select, confirm, input as input2 } from "@inquirer/prompts";
+import chalk3 from "chalk";
+import ora2 from "ora";
+
+// src/lib/runner.ts
+import {
+  query,
+  tool,
+  createSdkMcpServer
+} from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
+
+// src/lib/trello.ts
+var TRELLO_BASE = "https://api.trello.com/1";
+function createTrelloClient(apiKey, token) {
+  async function trelloFetch(path, options) {
+    const separator = path.includes("?") ? "&" : "?";
+    const url = `${TRELLO_BASE}${path}${separator}key=${apiKey}&token=${token}`;
+    const res = await fetch(url, {
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers ?? {}
+      }
+    });
+    if (!res.ok) {
+      throw new Error(`Trello API error: ${res.status} ${res.statusText}`);
+    }
+    return res.json();
+  }
+  return {
+    async updateCheckItem(cardId, checkItemId, state) {
+      await trelloFetch(`/cards/${cardId}/checkItem/${checkItemId}`, {
+        method: "PUT",
+        body: JSON.stringify({ state })
+      });
+    },
+    async moveCard(cardId, listId) {
+      await trelloFetch(`/cards/${cardId}`, {
+        method: "PUT",
+        body: JSON.stringify({ idList: listId })
+      });
+    },
+    async findOrCreateDoneList(boardId) {
+      const lists = await trelloFetch(
+        `/boards/${boardId}/lists?fields=id,name&filter=open`
+      );
+      const doneList = lists.find((l) => l.name.toLowerCase() === "done");
+      if (doneList) return doneList.id;
+      const created = await trelloFetch(
+        `/boards/${boardId}/lists`,
+        {
+          method: "POST",
+          body: JSON.stringify({ name: "Done" })
+        }
+      );
+      return created.id;
+    }
+  };
+}
+
+// src/lib/runner.ts
+var SYSTEM_PROMPT = `You are operating on a codebase. You have been given a Trello board containing tasks.
+Work through each card and checklist item in order.
+For each checklist item you complete, call the check_trello_item tool with the checkItemId and cardId.
+Do not mark items complete unless the code change has actually been made and verified.
+After completing ALL checklist items on a card, call move_card_to_done with the cardId to move it to the Done list.
+Once a card is in Done, do not interact with it again \u2014 move on to the next card.
+Focus on one card at a time. Complete all its items, move it to Done, then proceed to the next.`;
+function buildUserPrompt(boardData) {
+  return `Here is the Trello board with tasks to complete:
+
+${JSON.stringify(boardData, null, 2)}`;
+}
+function launchSession(options) {
+  const { credentials, boardData, cwd, abortController } = options;
+  const trello = createTrelloClient(
+    credentials.trelloApiKey,
+    credentials.trelloToken
+  );
+  const activeBoardData = {
+    ...boardData,
+    cards: boardData.doneListId ? boardData.cards.filter((c) => c.idList !== boardData.doneListId) : boardData.cards
+  };
+  const checkTrelloItem = tool(
+    "check_trello_item",
+    "Mark a Trello checklist item as complete once the corresponding code task is done.",
+    {
+      checkItemId: z.string().describe("The Trello checklist item ID"),
+      cardId: z.string().describe("The Trello card ID")
+    },
+    async ({ checkItemId, cardId }) => {
+      await trello.updateCheckItem(cardId, checkItemId, "complete");
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Marked checklist item ${checkItemId} as complete on card ${cardId}`
+          }
+        ]
+      };
+    }
+  );
+  const moveCardToDone = tool(
+    "move_card_to_done",
+    "Move a Trello card to the Done list after all its checklist items are completed.",
+    {
+      cardId: z.string().describe("The Trello card ID to move to Done")
+    },
+    async ({ cardId }) => {
+      const doneListId = await trello.findOrCreateDoneList(boardData.board.id);
+      await trello.moveCard(cardId, doneListId);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Moved card ${cardId} to Done list`
+          }
+        ]
+      };
+    }
+  );
+  const trelloServer = createSdkMcpServer({
+    name: "trello-tools",
+    tools: [checkTrelloItem, moveCardToDone]
+  });
+  return query({
+    prompt: buildUserPrompt(activeBoardData),
+    options: {
+      abortController,
+      cwd,
+      env: {
+        ANTHROPIC_API_KEY: credentials.anthropicApiKey,
+        CLAUDE_AGENT_SDK_CLIENT_APP: "claude-trello-cli/0.1.0"
+      },
+      systemPrompt: SYSTEM_PROMPT,
+      permissionMode: "acceptEdits",
+      allowedTools: [
+        "mcp__trello-tools__check_trello_item",
+        "mcp__trello-tools__move_card_to_done"
+      ],
+      maxTurns: 50,
+      mcpServers: {
+        "trello-tools": trelloServer
+      },
+      persistSession: false
+    }
+  });
+}
+
+// src/commands/run.ts
+var runCommand = new Command3("run").description("Select a Trello board and start a Claude Code session").option("-b, --board <id>", "Board ID (skip interactive selection)").option("-d, --dir <path>", "Working directory (default: current)").action(async (opts) => {
+  if (!isLoggedIn()) {
+    console.log(
+      chalk3.red("Not logged in. Run `claude-trello login` first.")
+    );
+    process.exit(1);
+  }
+  const cwd = opts.dir ? resolve(opts.dir) : process.cwd();
+  let boardId = opts.board;
+  let boardName = "";
+  if (!boardId) {
+    const spinner = ora2("Fetching boards...").start();
+    let boards;
+    try {
+      boards = await getBoards();
+      spinner.stop();
+    } catch (err) {
+      spinner.fail(
+        err instanceof Error ? err.message : "Failed to fetch boards"
+      );
+      process.exit(1);
+    }
+    if (boards.length === 0) {
+      console.log(
+        chalk3.red("No boards found. Create a board on Trello first.")
+      );
+      process.exit(1);
+    }
+    boardId = await select({
+      message: "Select a board:",
+      choices: boards.map((b) => ({
+        name: b.name,
+        value: b.id,
+        description: b.desc?.slice(0, 60) || void 0
+      }))
+    });
+    boardName = boards.find((b) => b.id === boardId)?.name ?? boardId;
+  }
+  const dataSpinner = ora2("Fetching cards and checklists...").start();
+  let cardsResponse;
+  try {
+    cardsResponse = await getBoardData(boardId);
+    dataSpinner.stop();
+  } catch (err) {
+    dataSpinner.fail(
+      err instanceof Error ? err.message : "Failed to fetch board data"
+    );
+    process.exit(1);
+  }
+  const { cards, lists, doneListId } = cardsResponse;
+  if (!boardName) boardName = boardId;
+  console.log(`
+${chalk3.bold(boardName)}`);
+  console.log(chalk3.dim("\u2500".repeat(boardName.length)));
+  const doneCards = doneListId ? cards.filter((c) => c.idList === doneListId) : [];
+  const activeCards = doneListId ? cards.filter((c) => c.idList !== doneListId) : cards;
+  const listMap = /* @__PURE__ */ new Map();
+  for (const l of lists) listMap.set(l.id, l);
+  const byList = /* @__PURE__ */ new Map();
+  for (const card of activeCards) {
+    const existing = byList.get(card.idList) ?? [];
+    existing.push(card);
+    byList.set(card.idList, existing);
+  }
+  for (const [listId, listCards] of byList) {
+    const listName = listMap.get(listId)?.name ?? "Unknown";
+    console.log(
+      `
+  ${chalk3.cyan.bold(listName)} (${listCards.length} card${listCards.length === 1 ? "" : "s"}):`
+    );
+    for (const card of listCards) {
+      const total = card.checklists.reduce(
+        (sum, cl) => sum + cl.checkItems.length,
+        0
+      );
+      const done = card.checklists.reduce(
+        (sum, cl) => sum + cl.checkItems.filter((i) => i.state === "complete").length,
+        0
+      );
+      const progress = total > 0 ? ` [${done}/${total}]` : "";
+      console.log(
+        `    ${chalk3.white("\u2022")} ${card.name}${chalk3.dim(progress)}`
+      );
+    }
+  }
+  if (doneCards.length > 0) {
+    console.log(
+      `
+  ${chalk3.dim(`Done (${doneCards.length} card${doneCards.length === 1 ? "" : "s"}) [skipped]`)}`
+    );
+  }
+  if (activeCards.length === 0) {
+    console.log(chalk3.dim("\n  No active cards to work on."));
+    return;
+  }
+  console.log(`
+  ${chalk3.dim(`Working directory: ${cwd}`)}`);
+  const proceed = await confirm({
+    message: `Start Claude Code session? (${activeCards.length} active card${activeCards.length === 1 ? "" : "s"})`,
+    default: true
+  });
+  if (!proceed) {
+    console.log(chalk3.dim("Cancelled."));
+    return;
+  }
+  const credSpinner = ora2("Loading credentials...").start();
+  let credentials;
+  try {
+    credentials = await getCredentials();
+    credSpinner.succeed("Credentials loaded");
+  } catch (err) {
+    credSpinner.fail(
+      err instanceof Error ? err.message : "Failed to load credentials"
+    );
+    process.exit(1);
+  }
+  const boardData = {
+    board: { id: boardId, name: boardName },
+    cards,
+    doneListId: doneListId ?? void 0
+  };
+  console.log(`
+${chalk3.bold.blue("Starting Claude Code session...")}
+`);
+  const abortController = new AbortController();
+  const sigintHandler = () => {
+    console.log(chalk3.dim("\n\nAborting session..."));
+    abortController.abort();
+  };
+  process.on("SIGINT", sigintHandler);
+  try {
+    const session = launchSession({
+      credentials,
+      boardData,
+      cwd,
+      abortController
+    });
+    for await (const message of session) {
+      await handleMessage(message, session);
+    }
+    console.log(`
+${chalk3.green.bold("Session complete.")}
+`);
+  } catch (err) {
+    if (abortController.signal.aborted) {
+      console.log(chalk3.dim("\nSession aborted."));
+    } else {
+      console.error(
+        chalk3.red(
+          `
+Session error: ${err instanceof Error ? err.message : "Unknown error"}`
+        )
+      );
+      process.exit(1);
+    }
+  } finally {
+    process.removeListener("SIGINT", sigintHandler);
+  }
+});
+async function handleMessage(message, session) {
+  switch (message.type) {
+    case "system": {
+      if (message.subtype === "init") {
+        console.log(
+          chalk3.dim(
+            `  Session initialized (model: ${message.model})
+`
+          )
+        );
+      }
+      break;
+    }
+    case "assistant": {
+      const msg = message.message;
+      const content = msg?.content;
+      if (!Array.isArray(content)) break;
+      for (const block of content) {
+        if (block.type === "text" && block.text) {
+          console.log(block.text);
+        } else if (block.type === "tool_use" && block.name) {
+          const name = block.name;
+          const toolInput = block.input ?? {};
+          if (name === "mcp__trello-tools__check_trello_item") {
+            console.log(chalk3.green(`  \u2713 Checked item on Trello`));
+          } else if (name === "mcp__trello-tools__move_card_to_done") {
+            console.log(chalk3.green.bold(`  \u2713 Moved card to Done`));
+          } else if (name === "AskUserQuestion") {
+            const questions = toolInput.questions;
+            if (questions && questions.length > 0) {
+              const questionText = questions.map((q) => q.question).join("\n");
+              console.log(chalk3.yellow(`
+  ? ${questionText}
+`));
+              const answer = await input2({ message: ">" });
+              async function* userInput() {
+                yield {
+                  type: "user",
+                  message: {
+                    role: "user",
+                    content: answer
+                  },
+                  parent_tool_use_id: null,
+                  session_id: ""
+                };
+              }
+              await session.streamInput(userInput());
+            }
+          } else {
+            console.log(chalk3.dim(`  [${name}]`));
+          }
+        }
+      }
+      break;
+    }
+    case "result": {
+      const result = message.result ?? message.subtype;
+      console.log(chalk3.dim(`
+  Result: ${result}`));
+      break;
+    }
+  }
+}
+
+// src/commands/boards.ts
+import { Command as Command4 } from "commander";
+import chalk4 from "chalk";
+import ora3 from "ora";
+var boardsCommand = new Command4("boards").description("List your Trello boards").action(async () => {
+  if (!isLoggedIn()) {
+    console.log(
+      chalk4.red("Not logged in. Run `claude-trello login` first.")
+    );
+    process.exit(1);
+  }
+  const spinner = ora3("Fetching boards...").start();
+  try {
+    const boards = await getBoards();
+    spinner.stop();
+    if (boards.length === 0) {
+      console.log(chalk4.dim("No boards found."));
+      return;
+    }
+    console.log(chalk4.bold(`
+Your Trello Boards (${boards.length}):
+`));
+    for (const board of boards) {
+      console.log(`  ${chalk4.cyan(board.name)}  ${chalk4.dim(board.id)}`);
+      if (board.desc) {
+        console.log(`  ${chalk4.dim(board.desc.slice(0, 80))}`);
+      }
+      console.log();
+    }
+  } catch (err) {
+    spinner.fail(
+      err instanceof Error ? err.message : "Failed to fetch boards"
+    );
+    process.exit(1);
+  }
+});
+
+// src/commands/status.ts
+import { Command as Command5 } from "commander";
+import chalk5 from "chalk";
+import ora4 from "ora";
+var statusCommand = new Command5("status").description("Check connection and integration status").action(async () => {
+  const config = getConfig();
+  console.log(chalk5.bold("\nClaude Trello Bridge \u2014 Status\n"));
+  console.log(`  Server:  ${chalk5.dim(getServerUrl())}`);
+  if (!isLoggedIn()) {
+    console.log(`  Auth:    ${chalk5.red("Not logged in")}`);
+    console.log(chalk5.dim("\n  Run `claude-trello login` to sign in.\n"));
+    return;
+  }
+  console.log(
+    `  Auth:    ${chalk5.green("Signed in")} as ${config.userName ?? config.userEmail ?? "unknown"}`
+  );
+  const spinner = ora4("Checking integrations...").start();
+  try {
+    const status = await getIntegrationStatus();
+    spinner.stop();
+    console.log(
+      `  Trello:  ${status.trelloLinked ? chalk5.green("Connected") : chalk5.red("Not connected")}`
+    );
+    console.log(
+      `  API Key: ${status.hasApiKey ? chalk5.green("Configured") : chalk5.red("Not set")}`
+    );
+    if (!status.trelloLinked || !status.hasApiKey) {
+      console.log(
+        chalk5.dim(
+          "\n  Complete setup at your web dashboard to use the CLI.\n"
+        )
+      );
+    } else {
+      console.log(
+        chalk5.green("\n  Ready to go! Run `claude-trello run` to start.\n")
+      );
+    }
+  } catch (err) {
+    spinner.fail(
+      err instanceof Error ? err.message : "Failed to check status"
+    );
+    process.exit(1);
+  }
+});
+
+// src/index.ts
+var program = new Command6();
+program.name("claude-trello").description(
+  "Bridge Trello boards and Claude Code \u2014 work through tasks from your terminal"
+).version("0.1.0");
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(runCommand);
+program.addCommand(boardsCommand);
+program.addCommand(statusCommand);
+program.parse();

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "claude-trello-cli",
+  "version": "0.1.0",
+  "description": "CLI for Claude Trello Bridge — point Claude Code at a Trello board and work through tasks from your terminal",
+  "type": "module",
+  "bin": {
+    "claude-trello": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsup",
+    "prepublishOnly": "pnpm build"
+  },
+  "keywords": [
+    "claude",
+    "trello",
+    "cli",
+    "ai",
+    "anthropic",
+    "claude-code",
+    "automation"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.81",
+    "@anthropic-ai/claude-code": "^2.1.81",
+    "@inquirer/prompts": "^7.0.0",
+    "chalk": "^5.4.0",
+    "commander": "^13.0.0",
+    "ora": "^8.2.0",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "tsup": "^8.4.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.2"
+  }
+}