attio-cli 0.1.0

package/dist/attio.js

@@ -0,0 +1,1325 @@
+#!/usr/bin/env node
+
+// bin/attio.ts
+import { program } from "commander";
+import chalk6 from "chalk";
+
+// src/errors.ts
+import chalk from "chalk";
+var AttioApiError = class extends Error {
+  constructor(statusCode, type, detail) {
+    super(`Attio API Error: ${detail} (${statusCode})`);
+    this.statusCode = statusCode;
+    this.type = type;
+    this.detail = detail;
+  }
+  display() {
+    return [
+      chalk.red(`Error: ${this.detail} (${this.statusCode})`),
+      chalk.dim(`  Type: ${this.type}`)
+    ].join("\n");
+  }
+  get exitCode() {
+    if (this.statusCode === 401 || this.statusCode === 403) return 2;
+    if (this.statusCode === 404) return 3;
+    if (this.statusCode === 400 || this.statusCode === 409) return 4;
+    if (this.statusCode === 429) return 5;
+    return 1;
+  }
+};
+var AttioAuthError = class extends Error {
+  display() {
+    return [
+      chalk.red("Error: Authentication failed"),
+      "",
+      "  No valid API key found. Set one of:",
+      `    1. ${chalk.cyan("ATTIO_API_KEY")} environment variable`,
+      `    2. ${chalk.cyan("attio config set api-key <key>")}`,
+      `    3. ${chalk.cyan("--api-key <key>")} flag`,
+      "",
+      `  Get your API key at: ${chalk.underline("https://app.attio.com/settings/developers")}`
+    ].join("\n");
+  }
+  get exitCode() {
+    return 2;
+  }
+};
+var AttioRateLimitError = class extends Error {
+  display() {
+    return chalk.red("Error: Rate limited after 3 retries. Try again in a few seconds.");
+  }
+  get exitCode() {
+    return 5;
+  }
+};
+
+// src/client.ts
+import chalk2 from "chalk";
+
+// src/config.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import * as dotenv from "dotenv";
+dotenv.config();
+var CONFIG_DIR = join(homedir(), ".config", "attio");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+function loadConfig() {
+  if (!existsSync(CONFIG_FILE)) return {};
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveConfig(config2) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_FILE, JSON.stringify(config2, null, 2));
+}
+function resolveApiKey(flagValue) {
+  return flagValue || process.env.ATTIO_API_KEY || loadConfig().apiKey || "";
+}
+function setApiKey(key) {
+  const config2 = loadConfig();
+  config2.apiKey = key;
+  saveConfig(config2);
+}
+function getConfigPath() {
+  return CONFIG_FILE;
+}
+
+// src/client.ts
+var BASE_URL = "https://api.attio.com/v2";
+var MAX_RETRIES = 3;
+var INITIAL_BACKOFF_MS = 1e3;
+var AttioClient = class {
+  apiKey;
+  debug;
+  constructor(apiKey, debug) {
+    this.apiKey = resolveApiKey(apiKey);
+    this.debug = debug ?? false;
+  }
+  async request(method, path, body) {
+    const url = `${BASE_URL}${path}`;
+    if (this.debug) {
+      console.error(chalk2.dim(`\u2192 ${method} ${url}`));
+    }
+    if (!this.apiKey) {
+      throw new AttioAuthError("No API key configured");
+    }
+    const headers = {
+      "Authorization": `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json"
+    };
+    const init = { method, headers };
+    if (body !== void 0) {
+      init.body = JSON.stringify(body);
+    }
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      const response = await fetch(url, init);
+      if (this.debug) {
+        console.error(chalk2.dim(`\u2190 ${response.status}`));
+      }
+      if (response.status === 429) {
+        if (attempt < MAX_RETRIES) {
+          const backoff = INITIAL_BACKOFF_MS * Math.pow(2, attempt);
+          await new Promise((resolve) => setTimeout(resolve, backoff));
+          continue;
+        }
+        throw new AttioRateLimitError("Rate limited after 3 retries");
+      }
+      if (response.status === 401) {
+        throw new AttioAuthError("Invalid or expired API key");
+      }
+      if (response.status === 204) {
+        return void 0;
+      }
+      const json = await response.json();
+      if (!response.ok) {
+        const errorType = json?.type ?? "unknown_error";
+        let errorDetail = json?.message ?? json?.detail ?? response.statusText;
+        if (json?.validation_errors?.length) {
+          const details = json.validation_errors.map(
+            (e) => `${e.path?.join(".") || "?"}: ${e.message}`
+          ).join("; ");
+          errorDetail += ` [${details}]`;
+        }
+        throw new AttioApiError(response.status, errorType, errorDetail);
+      }
+      return json;
+    }
+    throw new AttioRateLimitError("Rate limited after 3 retries");
+  }
+  async get(path) {
+    return this.request("GET", path);
+  }
+  async post(path, body) {
+    return this.request("POST", path, body);
+  }
+  async put(path, body) {
+    return this.request("PUT", path, body);
+  }
+  async patch(path, body) {
+    return this.request("PATCH", path, body);
+  }
+  async delete(path) {
+    return this.request("DELETE", path);
+  }
+};
+
+// src/output.ts
+import chalk3 from "chalk";
+import Table from "cli-table3";
+import { createInterface } from "readline";
+function detectFormat(opts) {
+  if (opts.quiet) return "quiet";
+  if (opts.json) return "json";
+  if (opts.csv) return "csv";
+  if (opts.table) return "table";
+  return process.stdout.isTTY ? "table" : "json";
+}
+function outputList(items, opts) {
+  const format = opts.format;
+  const idField = opts.idField || "id";
+  if (format === "quiet") {
+    for (const item of items) {
+      const raw = typeof item === "string" ? item : item[idField] || "";
+      const id = typeof raw === "object" && raw !== null ? Object.values(raw)[0] : raw;
+      if (id) console.log(id);
+    }
+    return;
+  }
+  if (format === "json") {
+    console.log(JSON.stringify(items, null, 2));
+    return;
+  }
+  if (items.length === 0) {
+    if (format === "table") console.log(chalk3.dim("No results."));
+    return;
+  }
+  const columns = opts.columns || Object.keys(items[0]).slice(0, 8);
+  if (format === "csv") {
+    console.log(columns.join(","));
+    for (const row of items) {
+      console.log(columns.map((c) => {
+        const v = String(row[c] ?? "");
+        return v.includes(",") || v.includes('"') || v.includes("\n") ? `"${v.replace(/"/g, '""')}"` : v;
+      }).join(","));
+    }
+    return;
+  }
+  const table = new Table({
+    head: columns.map((c) => chalk3.cyan(c)),
+    style: { head: [], border: [] },
+    wordWrap: true
+  });
+  for (const row of items) {
+    table.push(columns.map((c) => {
+      const v = String(row[c] ?? "");
+      return v.length > 60 ? v.slice(0, 57) + "..." : v;
+    }));
+  }
+  console.log(table.toString());
+}
+function outputSingle(item, opts) {
+  if (opts.format === "quiet") {
+    const raw = item[opts.idField || "id"] || "";
+    const id = typeof raw === "object" && raw !== null ? Object.values(raw)[0] : raw;
+    console.log(id || "");
+    return;
+  }
+  if (opts.format === "json") {
+    console.log(JSON.stringify(item, null, 2));
+    return;
+  }
+  const table = new Table({ style: { head: [], border: [] } });
+  for (const [key, value] of Object.entries(item)) {
+    const display = typeof value === "object" ? JSON.stringify(value) : String(value ?? "");
+    table.push({ [chalk3.cyan(key)]: display.length > 80 ? display.slice(0, 77) + "..." : display });
+  }
+  console.log(table.toString());
+}
+async function confirm(message) {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    rl.question(`${message} [y/N] `, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y");
+    });
+  });
+}
+
+// src/commands/whoami.ts
+function register(program2) {
+  program2.command("whoami").description("Show current workspace and authenticated user info").action(async function() {
+    const opts = this.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    const format = detectFormat(opts);
+    const data = await client.get("/self");
+    if (format === "json") {
+      outputSingle(data, { format });
+      return;
+    }
+    if (format === "quiet") {
+      console.log(data.workspace_id || "");
+      return;
+    }
+    const flat = {
+      workspace_id: data.workspace_id || "",
+      workspace_name: data.workspace_name || "",
+      workspace_slug: data.workspace_slug || "",
+      authorized_by: data.authorized_by_workspace_member_id || "",
+      scope: data.scope || ""
+    };
+    outputSingle(flat, { format, idField: "workspace_id" });
+  });
+}
+
+// src/commands/objects.ts
+function register2(program2) {
+  const objects = program2.command("objects").description("Manage workspace objects");
+  objects.command("list").description("List all objects in the workspace").action(async function() {
+    const opts = this.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    const format = detectFormat(opts);
+    const response = await client.get("/objects");
+    const items = response.data;
+    outputList(items, {
+      format,
+      columns: ["api_slug", "singular_noun", "plural_noun"],
+      idField: "api_slug"
+    });
+  });
+  objects.command("get").description("Get details of a specific object").argument("<slug>", "Object API slug (e.g. people, companies)").action(async function(slug) {
+    const opts = this.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    const format = detectFormat(opts);
+    const response = await client.get(`/objects/${encodeURIComponent(slug)}`);
+    const obj = response.data;
+    outputSingle(obj, { format, idField: "api_slug" });
+  });
+}
+
+// src/commands/attributes.ts
+function register3(program2) {
+  const attributes = program2.command("attributes").description("Manage object attributes");
+  attributes.command("list").description("List attributes for an object").argument("<object>", "Object API slug (e.g. people, companies)").action(async function(object) {
+    const opts = this.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    const format = detectFormat(opts);
+    const response = await client.get(
+      `/objects/${encodeURIComponent(object)}/attributes`
+    );
+    const items = response.data;
+    outputList(items, {
+      format,
+      columns: ["api_slug", "title", "type", "is_required", "is_unique", "is_multiselect"],
+      idField: "api_slug"
+    });
+  });
+}
+
+// src/filters.ts
+var OPERATORS = [
+  { cli: ">=", attio: "$gte", numeric: true },
+  { cli: "<=", attio: "$lte", numeric: true },
+  { cli: "!=", attio: "$not", wrapEq: true },
+  { cli: ">", attio: "$gt", numeric: true },
+  { cli: "<", attio: "$lt", numeric: true },
+  { cli: "!~", attio: "$not", wrapContains: true },
+  { cli: "~", attio: "$contains" },
+  { cli: "^", attio: "$starts_with" },
+  { cli: "?", attio: "$not_empty", unary: true },
+  { cli: "=", attio: "$eq" }
+];
+function parseFilterFlag(filterStr) {
+  if (filterStr.endsWith("?")) {
+    const attr = filterStr.slice(0, -1);
+    return { [attr]: { "$not_empty": true } };
+  }
+  for (const op of OPERATORS) {
+    if ("unary" in op && op.unary) continue;
+    const idx = filterStr.indexOf(op.cli);
+    if (idx === -1) continue;
+    const attribute = filterStr.slice(0, idx).trim();
+    const rawValue = filterStr.slice(idx + op.cli.length).trim();
+    const value = "numeric" in op && op.numeric && !isNaN(Number(rawValue)) ? Number(rawValue) : rawValue;
+    if (op.cli === "=") return { [attribute]: value };
+    if (op.cli === "!=") return { "$not": { [attribute]: value } };
+    if (op.cli === "!~") return { "$not": { [attribute]: { "$contains": value } } };
+    return { [attribute]: { [op.attio]: value } };
+  }
+  throw new Error(`Invalid filter syntax: "${filterStr}". Expected: attribute<operator>value`);
+}
+function combineFilters(filters) {
+  if (filters.length === 0) return {};
+  if (filters.length === 1) return filters[0];
+  return { "$and": filters };
+}
+function parseSort(sortStr) {
+  const [attrPart, direction = "asc"] = sortStr.split(":");
+  const [attribute, field] = attrPart.split(".");
+  return { attribute, ...field ? { field } : {}, direction };
+}
+
+// src/values.ts
+function flattenValue(attrValues) {
+  if (!attrValues || attrValues.length === 0) return "";
+  if (attrValues.length > 1) return attrValues.map((v) => flattenSingleValue(v)).join(", ");
+  return flattenSingleValue(attrValues[0]);
+}
+function flattenSingleValue(val) {
+  if (!val) return "";
+  const type = val.attribute_type;
+  switch (type) {
+    case "text":
+    case "number":
+    case "checkbox":
+    case "date":
+    case "timestamp":
+    case "rating":
+      return String(val.value ?? "");
+    case "currency":
+      return String(val.currency_value ?? val.value ?? "");
+    case "personal-name":
+      return val.full_name || `${val.first_name || ""} ${val.last_name || ""}`.trim();
+    case "email-address":
+      return val.email_address || val.original_email_address || "";
+    case "phone-number":
+      return val.original_phone_number || val.phone_number || "";
+    case "domain":
+      return val.domain || "";
+    case "select":
+      return val.option?.title || "";
+    case "status":
+      return val.status?.title || "";
+    case "location":
+      return [val.locality, val.region, val.country_code].filter(Boolean).join(", ");
+    case "record-reference":
+      return `${val.target_object}:${val.target_record_id}`;
+    case "actor-reference":
+      return `member:${val.referenced_actor_id}`;
+    case "interaction":
+      return `${val.interaction_type} @ ${val.interacted_at?.slice(0, 10) || ""}`;
+    default:
+      return String(val.value ?? val.title ?? JSON.stringify(val));
+  }
+}
+function flattenRecord(record) {
+  const flat = {
+    id: record.id?.record_id || record.id?.entry_id || "",
+    created_at: record.created_at?.slice(0, 10) || ""
+  };
+  if (record.web_url) flat.web_url = record.web_url;
+  for (const [key, values] of Object.entries(record.values || {})) {
+    flat[key] = flattenValue(values);
+  }
+  return flat;
+}
+function parseSets(sets) {
+  const values = {};
+  for (const set of sets) {
+    const eqIdx = set.indexOf("=");
+    if (eqIdx === -1) throw new Error(`Invalid --set format: "${set}". Expected: key=value`);
+    const key = set.slice(0, eqIdx).trim();
+    const raw = set.slice(eqIdx + 1).trim();
+    if (raw === "true") {
+      values[key] = true;
+      continue;
+    }
+    if (raw === "false") {
+      values[key] = false;
+      continue;
+    }
+    if (/^-?\d+(\.\d+)?$/.test(raw)) {
+      values[key] = Number(raw);
+      continue;
+    }
+    if (raw.startsWith("[") && raw.endsWith("]")) {
+      values[key] = raw.slice(1, -1).split(",").map((s) => s.trim());
+      continue;
+    }
+    values[key] = raw;
+  }
+  return values;
+}
+async function readStdin() {
+  if (process.stdin.isTTY) return "";
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function resolveValues(options) {
+  if (options.values) {
+    if (options.values.startsWith("@")) {
+      const { readFileSync: readFileSync2 } = await import("fs");
+      return JSON.parse(readFileSync2(options.values.slice(1), "utf-8"));
+    }
+    return JSON.parse(options.values);
+  }
+  if (options.set && options.set.length > 0) {
+    return parseSets(options.set);
+  }
+  const stdin = await readStdin();
+  if (stdin.trim()) return JSON.parse(stdin);
+  return {};
+}
+
+// src/pagination.ts
+async function paginate(fetchPage, options) {
+  if (!options.all) {
+    return fetchPage(options.limit, options.offset);
+  }
+  const allResults = [];
+  let offset = 0;
+  const pageSize = 500;
+  while (true) {
+    const page = await fetchPage(pageSize, offset);
+    allResults.push(...page);
+    if (page.length < pageSize) break;
+    offset += pageSize;
+  }
+  return allResults;
+}
+
+// src/commands/records.ts
+async function listRecords(object, cmdOpts) {
+  const client = new AttioClient(cmdOpts.apiKey, cmdOpts.debug);
+  const format = detectFormat(cmdOpts);
+  let filter;
+  if (cmdOpts.filterJson) {
+    filter = JSON.parse(cmdOpts.filterJson);
+  } else if (cmdOpts.filter && cmdOpts.filter.length > 0) {
+    const parsed = cmdOpts.filter.map(parseFilterFlag);
+    filter = combineFilters(parsed);
+  }
+  let sorts;
+  if (cmdOpts.sort && cmdOpts.sort.length > 0) {
+    sorts = cmdOpts.sort.map(parseSort);
+  }
+  const limit = Number(cmdOpts.limit) || 25;
+  const offset = Number(cmdOpts.offset) || 0;
+  const all = cmdOpts.all ?? false;
+  const fetchPage = async (pageLimit, pageOffset) => {
+    const body = {};
+    if (filter && Object.keys(filter).length > 0) body.filter = filter;
+    if (sorts && sorts.length > 0) body.sorts = sorts;
+    body.limit = pageLimit;
+    body.offset = pageOffset;
+    const res = await client.post(
+      `/objects/${encodeURIComponent(object)}/records/query`,
+      body
+    );
+    return res.data;
+  };
+  const records = await paginate(fetchPage, { limit, offset, all });
+  if (format === "quiet") {
+    for (const r of records) {
+      console.log(r.id?.record_id ?? "");
+    }
+    return;
+  }
+  if (format === "json") {
+    outputList(records, { format });
+    return;
+  }
+  const flat = records.map(flattenRecord);
+  outputList(flat, { format });
+}
+async function getRecord(object, recordId, cmdOpts) {
+  const client = new AttioClient(cmdOpts.apiKey, cmdOpts.debug);
+  const format = detectFormat(cmdOpts);
+  const res = await client.get(
+    `/objects/${encodeURIComponent(object)}/records/${encodeURIComponent(recordId)}`
+  );
+  const record = res.data;
+  if (format === "quiet") {
+    console.log(record.id?.record_id ?? "");
+    return;
+  }
+  if (format === "json") {
+    outputSingle(record, { format });
+    return;
+  }
+  outputSingle(flattenRecord(record), { format });
+}
+async function createRecord(object, cmdOpts) {
+  const client = new AttioClient(cmdOpts.apiKey, cmdOpts.debug);
+  const format = detectFormat(cmdOpts);
+  const values = await resolveValues(cmdOpts);
+  const res = await client.post(
+    `/objects/${encodeURIComponent(object)}/records`,
+    { data: { values } }
+  );
+  const record = res.data;
+  if (format === "quiet") {
+    console.log(record.id?.record_id ?? "");
+    return;
+  }
+  if (format === "json") {
+    outputSingle(record, { format });
+    return;
+  }
+  outputSingle(flattenRecord(record), { format });
+}
+async function updateRecord(object, recordId, cmdOpts) {
+  const client = new AttioClient(cmdOpts.apiKey, cmdOpts.debug);
+  const format = detectFormat(cmdOpts);
+  const values = await resolveValues(cmdOpts);
+  const res = await client.patch(
+    `/objects/${encodeURIComponent(object)}/records/${encodeURIComponent(recordId)}`,
+    { data: { values } }
+  );
+  const record = res.data;
+  if (format === "quiet") {
+    console.log(record.id?.record_id ?? "");
+    return;
+  }
+  if (format === "json") {
+    outputSingle(record, { format });
+    return;
+  }
+  outputSingle(flattenRecord(record), { format });
+}
+async function deleteRecord(object, recordId, cmdOpts) {
+  const yes = cmdOpts.yes ?? false;
+  if (!yes) {
+    const ok = await confirm(`Delete record ${recordId} from ${object}?`);
+    if (!ok) {
+      console.error("Aborted.");
+      return;
+    }
+  }
+  const client = new AttioClient(cmdOpts.apiKey, cmdOpts.debug);
+  await client.delete(
+    `/objects/${encodeURIComponent(object)}/records/${encodeURIComponent(recordId)}`
+  );
+  console.error("Deleted.");
+}
+async function upsertRecord(object, cmdOpts) {
+  const client = new AttioClient(cmdOpts.apiKey, cmdOpts.debug);
+  const format = detectFormat(cmdOpts);
+  const matchAttr = cmdOpts.match;
+  if (!matchAttr) {
+    throw new Error("--match <attribute-slug> is required for upsert");
+  }
+  const values = await resolveValues(cmdOpts);
+  const res = await client.put(
+    `/objects/${encodeURIComponent(object)}/records?matching_attribute=${encodeURIComponent(matchAttr)}`,
+    { data: { values } }
+  );
+  const record = res.data;
+  if (format === "quiet") {
+    console.log(record.id?.record_id ?? "");
+    return;
+  }
+  if (format === "json") {
+    outputSingle(record, { format });
+    return;
+  }
+  outputSingle(flattenRecord(record), { format });
+}
+async function searchRecords(object, query, cmdOpts) {
+  const client = new AttioClient(cmdOpts.apiKey, cmdOpts.debug);
+  const format = detectFormat(cmdOpts);
+  const limit = Number(cmdOpts.limit) || 25;
+  const res = await client.post(
+    "/objects/records/search",
+    {
+      query,
+      objects: [object],
+      request_as: { type: "workspace" },
+      limit
+    }
+  );
+  const records = res.data;
+  if (format === "quiet") {
+    for (const r of records) {
+      console.log(r.id?.record_id ?? "");
+    }
+    return;
+  }
+  if (format === "json") {
+    outputList(records, { format });
+    return;
+  }
+  const flat = records.map(flattenRecord);
+  outputList(flat, { format });
+}
+function register4(program2) {
+  const records = program2.command("records").description("Manage records in any Attio object");
+  records.command("list").description("List or query records for an object").argument("<object>", "Object slug or ID (e.g. companies, people)").option(
+    "--filter <expr>",
+    'Filter expression, e.g. "name~Acme" (repeatable)',
+    (val, prev) => [...prev, val],
+    []
+  ).option("--filter-json <json>", "Raw JSON filter (overrides --filter)").option(
+    "--sort <expr>",
+    'Sort expression, e.g. "name:asc" (repeatable)',
+    (val, prev) => [...prev, val],
+    []
+  ).option("--limit <n>", "Maximum records to return", "25").option("--offset <n>", "Number of records to skip", "0").option("--all", "Auto-paginate to fetch all records").action(async (object, _opts, cmd) => {
+    const opts = cmd.optsWithGlobals();
+    await listRecords(object, opts);
+  });
+  records.command("get").description("Get a single record by ID").argument("<object>", "Object slug or ID").argument("<record-id>", "Record ID").action(async (object, recordId, _opts, cmd) => {
+    const opts = cmd.optsWithGlobals();
+    await getRecord(object, recordId, opts);
+  });
+  records.command("create").description("Create a new record").argument("<object>", "Object slug or ID").option("--values <json>", "JSON string or @file of attribute values").option(
+    "--set <key=value>",
+    "Set an attribute value (repeatable)",
+    (val, prev) => [...prev, val],
+    []
+  ).action(async (object, _opts, cmd) => {
+    const opts = cmd.optsWithGlobals();
+    await createRecord(object, opts);
+  });
+  records.command("update").description("Update an existing record").argument("<object>", "Object slug or ID").argument("<record-id>", "Record ID").option("--values <json>", "JSON string or @file of attribute values").option(
+    "--set <key=value>",
+    "Set an attribute value (repeatable)",
+    (val, prev) => [...prev, val],
+    []
+  ).action(async (object, recordId, _opts, cmd) => {
+    const opts = cmd.optsWithGlobals();
+    await updateRecord(object, recordId, opts);
+  });
+  records.command("delete").description("Delete a record").argument("<object>", "Object slug or ID").argument("<record-id>", "Record ID").option("-y, --yes", "Skip confirmation prompt").action(async (object, recordId, _opts, cmd) => {
+    const opts = cmd.optsWithGlobals();
+    await deleteRecord(object, recordId, opts);
+  });
+  records.command("upsert").description("Create or update a record by matching attribute").argument("<object>", "Object slug or ID").requiredOption("--match <attribute-slug>", "Attribute slug to match on (required)").option("--values <json>", "JSON string or @file of attribute values").option(
+    "--set <key=value>",
+    "Set an attribute value (repeatable)",
+    (val, prev) => [...prev, val],
+    []
+  ).action(async (object, _opts, cmd) => {
+    const opts = cmd.optsWithGlobals();
+    await upsertRecord(object, opts);
+  });
+  records.command("search").description("Full-text search for records within an object").argument("<object>", "Object slug or ID (e.g. companies, people)").argument("<query>", "Search query string").option("--limit <n>", "Maximum results to return", "25").action(async (object, query, _opts, cmd) => {
+    const opts = cmd.optsWithGlobals();
+    await searchRecords(object, query, opts);
+  });
+}
+
+// src/commands/people.ts
+function register5(program2) {
+  const cmd = program2.command("people").description("Manage people records (shortcut for: records <cmd> people)");
+  cmd.command("list").description("List people").option("--filter <expr>", "Filter expression (repeatable)", (v, p) => [...p, v], []).option("--filter-json <json>", "Raw JSON filter").option("--sort <expr>", "Sort expression (repeatable)", (v, p) => [...p, v], []).option("--limit <n>", "Max results per page", "25").option("--offset <n>", "Starting offset", "0").option("--all", "Fetch all pages").action(async (options, command) => {
+    await listRecords("people", command.optsWithGlobals());
+  });
+  cmd.command("get <record-id>").description("Get a person by record ID").action(async (recordId, options, command) => {
+    await getRecord("people", recordId, command.optsWithGlobals());
+  });
+  cmd.command("create").description("Create a person").option("--values <json>", "Values as JSON string or @file").option("--set <key=value>", "Set a field value (repeatable)", (v, p) => [...p, v], []).action(async (options, command) => {
+    await createRecord("people", command.optsWithGlobals());
+  });
+  cmd.command("update <record-id>").description("Update a person").option("--values <json>", "Values as JSON string or @file").option("--set <key=value>", "Set a field value (repeatable)", (v, p) => [...p, v], []).action(async (recordId, options, command) => {
+    await updateRecord("people", recordId, command.optsWithGlobals());
+  });
+  cmd.command("delete <record-id>").description("Delete a person").option("-y, --yes", "Skip confirmation").action(async (recordId, options, command) => {
+    await deleteRecord("people", recordId, command.optsWithGlobals());
+  });
+  cmd.command("search <query>").description("Search people by name or email").option("--limit <n>", "Maximum results", "25").action(async (query, options, command) => {
+    await searchRecords("people", query, command.optsWithGlobals());
+  });
+}
+
+// src/commands/companies.ts
+function register6(program2) {
+  const cmd = program2.command("companies").description("Manage company records (shortcut for: records <cmd> companies)");
+  cmd.command("list").description("List companies").option("--filter <expr>", "Filter expression (repeatable)", (v, p) => [...p, v], []).option("--filter-json <json>", "Raw JSON filter").option("--sort <expr>", "Sort expression (repeatable)", (v, p) => [...p, v], []).option("--limit <n>", "Max results per page", "25").option("--offset <n>", "Starting offset", "0").option("--all", "Fetch all pages").action(async (options, command) => {
+    await listRecords("companies", command.optsWithGlobals());
+  });
+  cmd.command("get <record-id>").description("Get a company by record ID").action(async (recordId, options, command) => {
+    await getRecord("companies", recordId, command.optsWithGlobals());
+  });
+  cmd.command("create").description("Create a company").option("--values <json>", "Values as JSON string or @file").option("--set <key=value>", "Set a field value (repeatable)", (v, p) => [...p, v], []).action(async (options, command) => {
+    await createRecord("companies", command.optsWithGlobals());
+  });
+  cmd.command("update <record-id>").description("Update a company").option("--values <json>", "Values as JSON string or @file").option("--set <key=value>", "Set a field value (repeatable)", (v, p) => [...p, v], []).action(async (recordId, options, command) => {
+    await updateRecord("companies", recordId, command.optsWithGlobals());
+  });
+  cmd.command("delete <record-id>").description("Delete a company").option("-y, --yes", "Skip confirmation").action(async (recordId, options, command) => {
+    await deleteRecord("companies", recordId, command.optsWithGlobals());
+  });
+  cmd.command("search <query>").description("Search companies by name or domain").option("--limit <n>", "Maximum results", "25").action(async (query, options, command) => {
+    await searchRecords("companies", query, command.optsWithGlobals());
+  });
+}
+
+// src/commands/lists.ts
+function register7(program2) {
+  const cmd = program2.command("lists").description("Manage lists");
+  cmd.command("list").description("List all lists").action(async (_options, command) => {
+    const opts = command.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    const format = detectFormat(opts);
+    const res = await client.get("/lists");
+    const lists = res.data;
+    const flat = lists.map((l) => ({
+      id: l.id?.list_id || "",
+      api_slug: l.api_slug || "",
+      name: l.name || "",
+      parent_object: l.parent_object || ""
+    }));
+    outputList(flat, {
+      format,
+      columns: ["id", "api_slug", "name", "parent_object"],
+      idField: "id"
+    });
+  });
+  cmd.command("get <list>").description("Get a list by ID or slug").action(async (list, _options, command) => {
+    const opts = command.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    const format = detectFormat(opts);
+    const res = await client.get(`/lists/${list}`);
+    const listData = res.data;
+    if (format === "json") {
+      outputSingle(listData, { format, idField: "id" });
+      return;
+    }
+    const flat = {
+      id: listData.id?.list_id || "",
+      api_slug: listData.api_slug || "",
+      name: listData.name || "",
+      parent_object: listData.parent_object || "",
+      workspace_access: listData.workspace_access || "",
+      created_by_actor_type: listData.created_by_actor?.type || "",
+      created_by_actor_id: listData.created_by_actor?.id || ""
+    };
+    outputSingle(flat, { format, idField: "id" });
+  });
+}
+
+// src/commands/entries.ts
+function flattenEntry(entry) {
+  const flat = {
+    id: entry.id?.entry_id || "",
+    record_id: entry.record_id || entry.parent_record_id || "",
+    created_at: entry.created_at?.slice(0, 10) || ""
+  };
+  for (const [key, values] of Object.entries(entry.entry_values || {})) {
+    flat[key] = flattenValue(values);
+  }
+  return flat;
+}
+function register8(program2) {
+  const cmd = program2.command("entries").description("Manage list entries");
+  cmd.command("list <list>").description("List entries in a list").option("--filter <expr>", "Filter expression (repeatable)", (v, p) => [...p, v], []).option("--filter-json <json>", "Raw JSON filter").option("--sort <expr>", "Sort expression (repeatable)", (v, p) => [...p, v], []).option("--limit <n>", "Max results per page", "25").option("--offset <n>", "Starting offset", "0").option("--all", "Fetch all pages").action(async (list, _options, command) => {
+    const opts = command.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    const format = detectFormat(opts);
+    let filter;
+    if (opts.filterJson) {
+      filter = JSON.parse(opts.filterJson);
+    } else if (opts.filter && opts.filter.length > 0) {
+      const parsed = opts.filter.map(parseFilterFlag);
+      filter = combineFilters(parsed);
+    }
+    const sorts = (opts.sort || []).map((s) => parseSort(s));
+    const limit = parseInt(opts.limit, 10) || 25;
+    const offset = parseInt(opts.offset, 10) || 0;
+    const entries = await paginate(
+      async (pageLimit, pageOffset) => {
+        const body = { limit: pageLimit, offset: pageOffset };
+        if (filter && Object.keys(filter).length > 0) body.filter = filter;
+        if (sorts.length > 0) body.sorts = sorts;
+        const res = await client.post(`/lists/${list}/entries/query`, body);
+        return res.data;
+      },
+      { limit, offset, all: !!opts.all }
+    );
+    if (format === "json") {
+      outputList(entries, { format, idField: "id" });
+      return;
+    }
+    const flat = entries.map(flattenEntry);
+    outputList(flat, { format, idField: "id" });
+  });
+  cmd.command("get <list> <entry-id>").description("Get an entry by ID").action(async (list, entryId, _options, command) => {
+    const opts = command.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    const format = detectFormat(opts);
+    const res = await client.get(`/lists/${list}/entries/${entryId}`);
+    const entry = res.data;
+    if (format === "json") {
+      outputSingle(entry, { format, idField: "id" });
+      return;
+    }
+    const flat = flattenEntry(entry);
+    outputSingle(flat, { format, idField: "id" });
+  });
+  cmd.command("create <list>").description("Create a new entry in a list").requiredOption("--record <record-id>", "Parent record ID (required)").requiredOption("--object <parent-object>", "Parent object slug (required)").option("--values <json>", "Entry values as JSON string or @file").option("--set <key=value>", "Set a field value (repeatable)", (v, p) => [...p, v], []).action(async (list, _options, command) => {
+    const opts = command.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    const format = detectFormat(opts);
+    const resolvedValues = await resolveValues({ values: opts.values, set: opts.set });
+    const body = {
+      data: {
+        parent_record_id: opts.record,
+        parent_object: opts.object,
+        entry_values: resolvedValues
+      }
+    };
+    const res = await client.post(`/lists/${list}/entries`, body);
+    const entry = res.data;
+    if (format === "json") {
+      outputSingle(entry, { format, idField: "id" });
+      return;
+    }
+    const flat = flattenEntry(entry);
+    outputSingle(flat, { format, idField: "id" });
+  });
+  cmd.command("update <list> <entry-id>").description("Update an entry").option("--values <json>", "Entry values as JSON string or @file").option("--set <key=value>", "Set a field value (repeatable)", (v, p) => [...p, v], []).action(async (list, entryId, _options, command) => {
+    const opts = command.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    const format = detectFormat(opts);
+    const resolvedValues = await resolveValues({ values: opts.values, set: opts.set });
+    const body = {
+      data: {
+        entry_values: resolvedValues
+      }
+    };
+    const res = await client.patch(`/lists/${list}/entries/${entryId}`, body);
+    const entry = res.data;
+    if (format === "json") {
+      outputSingle(entry, { format, idField: "id" });
+      return;
+    }
+    const flat = flattenEntry(entry);
+    outputSingle(flat, { format, idField: "id" });
+  });
+  cmd.command("delete <list> <entry-id>").description("Delete an entry").option("-y, --yes", "Skip confirmation").action(async (list, entryId, _options, command) => {
+    const opts = command.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    if (!opts.yes) {
+      const ok = await confirm(`Delete entry ${entryId} from list ${list}?`);
+      if (!ok) {
+        console.error("Aborted.");
+        return;
+      }
+    }
+    await client.delete(`/lists/${list}/entries/${entryId}`);
+    console.error(`Deleted entry ${entryId}.`);
+  });
+}
+
+// src/commands/tasks.ts
+function register9(program2) {
+  const tasks = program2.command("tasks").description("Manage tasks");
+  tasks.command("list").description("List tasks").option("--assignee <member-id>", "Filter by assignee workspace member ID").option("--is-completed", "Filter to only completed tasks").option("--linked-object <obj>", "Filter by linked object slug").option("--linked-record-id <id>", "Filter by linked record ID").option("--limit <n>", "Maximum tasks to return", "25").option("--offset <n>", "Number of tasks to skip", "0").option("--sort <expr>", "Sort expression").action(async (_options, command) => {
+    const opts = command.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    const format = detectFormat(opts);
+    const params = new URLSearchParams();
+    params.set("limit", String(opts.limit ?? 25));
+    params.set("offset", String(opts.offset ?? 0));
+    if (opts.assignee) params.set("assignee", opts.assignee);
+    if (opts.isCompleted) params.set("is_completed", "true");
+    if (opts.linkedObject) params.set("linked_object", opts.linkedObject);
+    if (opts.linkedRecordId) params.set("linked_record_id", opts.linkedRecordId);
+    if (opts.sort) params.set("sort", opts.sort);
+    const res = await client.get(`/tasks?${params.toString()}`);
+    const tasksList = res.data;
+    const flat = tasksList.map((t) => ({
+      id: t.id?.task_id || "",
+      content: truncate(t.content_plaintext || "", 60),
+      deadline: t.deadline_at || "",
+      completed: t.is_completed ?? false
+    }));
+    outputList(flat, {
+      format,
+      columns: ["id", "content", "deadline", "completed"],
+      idField: "id"
+    });
+  });
+  tasks.command("get <task-id>").description("Get a task by ID").action(async (taskId, _options, command) => {
+    const opts = command.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    const format = detectFormat(opts);
+    const res = await client.get(`/tasks/${encodeURIComponent(taskId)}`);
+    outputSingle(res.data, { format, idField: "id" });
+  });
+  tasks.command("create").description("Create a new task").requiredOption("--content <text>", "Task content (required)").option(
+    "--assignee <member-id>",
+    "Assignee workspace member ID (repeatable)",
+    (val, prev) => [...prev, val],
+    []
+  ).option("--deadline <ISO-date>", "Deadline in ISO-8601 format").option(
+    "--record <object:record-id>",
+    "Link a record as object:record-id (repeatable)",
+    (val, prev) => [...prev, val],
+    []
+  ).action(async (_options, command) => {
+    const opts = command.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    const format = detectFormat(opts);
+    const body = {
+      content: opts.content,
+      format: "plaintext",
+      is_completed: false,
+      deadline_at: opts.deadline || null,
+      assignees: opts.assignee && opts.assignee.length > 0 ? opts.assignee.map((id) => ({
+        referenced_actor_type: "workspace-member",
+        referenced_actor_id: id
+      })) : [],
+      linked_records: opts.record && opts.record.length > 0 ? opts.record.map((r) => {
+        const [targetObject, targetRecordId] = r.split(":");
+        return { target_object: targetObject, target_record_id: targetRecordId };
+      }) : []
+    };
+    const res = await client.post("/tasks", { data: body });
+    outputSingle(res.data, { format, idField: "id" });
+  });
+  tasks.command("update <task-id>").description("Update an existing task").option("--complete", "Mark task as completed").option("--incomplete", "Mark task as not completed").option("--deadline <ISO-date>", "Update deadline").option("--content <text>", "Update task content").action(async (taskId, _options, command) => {
+    const opts = command.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    const format = detectFormat(opts);
+    const body = {};
+    if (opts.complete) body.is_completed = true;
+    if (opts.incomplete) body.is_completed = false;
+    if (opts.deadline) body.deadline_at = opts.deadline;
+    if (opts.content) body.content = opts.content;
+    const res = await client.patch(
+      `/tasks/${encodeURIComponent(taskId)}`,
+      { data: body }
+    );
+    outputSingle(res.data, { format, idField: "id" });
+  });
+  tasks.command("delete <task-id>").description("Delete a task").option("-y, --yes", "Skip confirmation prompt").action(async (taskId, _options, command) => {
+    const opts = command.optsWithGlobals();
+    if (!opts.yes) {
+      const ok = await confirm(`Delete task ${taskId}?`);
+      if (!ok) {
+        console.error("Aborted.");
+        return;
+      }
+    }
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    await client.delete(`/tasks/${encodeURIComponent(taskId)}`);
+    console.error("Deleted.");
+  });
+}
+function truncate(str, max) {
+  if (str.length <= max) return str;
+  return str.slice(0, max - 3) + "...";
+}
+
+// src/commands/notes.ts
+function register10(program2) {
+  const notes = program2.command("notes").description("Manage notes");
+  notes.command("list").description("List notes").option("--object <obj>", "Filter by parent object slug").option("--record <id>", "Filter by parent record ID").option("--limit <n>", "Maximum notes to return", "25").option("--offset <n>", "Number of notes to skip", "0").action(async (_options, command) => {
+    const opts = command.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    const format = detectFormat(opts);
+    const params = new URLSearchParams();
+    params.set("limit", String(opts.limit ?? 25));
+    params.set("offset", String(opts.offset ?? 0));
+    if (opts.object) params.set("parent_object", opts.object);
+    if (opts.record) params.set("parent_record_id", opts.record);
+    const res = await client.get(`/notes?${params.toString()}`);
+    const notesList = res.data;
+    const flat = notesList.map((n) => ({
+      id: n.id?.note_id || "",
+      title: n.title || "",
+      parent_object: n.parent_object || "",
+      parent_record_id: n.parent_record_id || "",
+      created_at: n.created_at || ""
+    }));
+    outputList(flat, {
+      format,
+      columns: ["id", "title", "parent_object", "parent_record_id", "created_at"],
+      idField: "id"
+    });
+  });
+  notes.command("get <note-id>").description("Get a note by ID").action(async (noteId, _options, command) => {
+    const opts = command.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    const format = detectFormat(opts);
+    const res = await client.get(`/notes/${encodeURIComponent(noteId)}`);
+    outputSingle(res.data, { format, idField: "id" });
+  });
+  notes.command("create").description("Create a new note").requiredOption("--object <obj>", "Parent object slug (required)").requiredOption("--record <id>", "Parent record ID (required)").requiredOption("--title <text>", "Note title (required)").requiredOption("--content <text>", "Note content (required)").option("--format <fmt>", "Content format: plaintext or markdown", "plaintext").action(async (_options, command) => {
+    const opts = command.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    const format = detectFormat(opts);
+    const body = {
+      parent_object: opts.object,
+      parent_record_id: opts.record,
+      title: opts.title,
+      format: opts.format ?? "plaintext",
+      content: opts.content
+    };
+    const res = await client.post("/notes", { data: body });
+    outputSingle(res.data, { format, idField: "id" });
+  });
+  notes.command("delete <note-id>").description("Delete a note").option("-y, --yes", "Skip confirmation prompt").action(async (noteId, _options, command) => {
+    const opts = command.optsWithGlobals();
+    if (!opts.yes) {
+      const ok = await confirm(`Delete note ${noteId}?`);
+      if (!ok) {
+        console.error("Aborted.");
+        return;
+      }
+    }
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    await client.delete(`/notes/${encodeURIComponent(noteId)}`);
+    console.error("Deleted.");
+  });
+}
+
+// src/commands/comments.ts
+function register11(program2) {
+  const comments = program2.command("comments").description("Manage comments on records");
+  comments.command("list").description("List comment threads on a record").requiredOption("--object <obj>", "Object slug (required)").requiredOption("--record <id>", "Record ID (required)").option("--limit <n>", "Maximum threads to return", "25").option("--offset <n>", "Number of threads to skip", "0").action(async (_options, command) => {
+    const opts = command.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    const format = detectFormat(opts);
+    const params = new URLSearchParams();
+    params.set("object", opts.object);
+    params.set("record_id", opts.record);
+    if (opts.limit) params.set("limit", String(opts.limit));
+    if (opts.offset) params.set("offset", String(opts.offset));
+    const res = await client.get(`/threads?${params.toString()}`);
+    const threads = res.data;
+    const flat = [];
+    for (const thread of threads) {
+      const threadId = thread.id?.thread_id || thread.thread_id || "";
+      if (thread.comments && Array.isArray(thread.comments)) {
+        for (const c of thread.comments) {
+          flat.push({
+            thread_id: threadId,
+            author: c.author?.id || c.author?.name || "",
+            content: truncate2(c.content_plaintext || c.content || "", 60),
+            created_at: c.created_at || ""
+          });
+        }
+      } else {
+        flat.push({
+          thread_id: threadId,
+          author: thread.created_by_actor?.id || "",
+          content: "",
+          created_at: thread.created_at || ""
+        });
+      }
+    }
+    outputList(flat, {
+      format,
+      columns: ["thread_id", "author", "content", "created_at"],
+      idField: "thread_id"
+    });
+  });
+  comments.command("create").description("Create a comment on a record").requiredOption("--object <obj>", "Object slug (required)").requiredOption("--record <id>", "Record ID (required)").requiredOption("--content <text>", "Comment content (required)").option("--thread <thread-id>", "Thread ID to reply to (creates new thread if omitted)").action(async (_options, command) => {
+    const opts = command.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    const format = detectFormat(opts);
+    const selfRes = await client.get("/self");
+    const memberId = selfRes.authorized_by_workspace_member_id || "";
+    const body = {
+      format: "plaintext",
+      content: opts.content,
+      author: {
+        type: "workspace-member",
+        id: memberId
+      }
+    };
+    if (opts.thread) {
+      body.thread_id = opts.thread;
+    } else {
+      body.record = {
+        object: opts.object,
+        record_id: opts.record
+      };
+    }
+    const res = await client.post("/comments", { data: body });
+    outputSingle(res.data, { format, idField: "id" });
+  });
+  comments.command("delete <comment-id>").description("Delete a comment").option("-y, --yes", "Skip confirmation prompt").action(async (commentId, _options, command) => {
+    const opts = command.optsWithGlobals();
+    if (!opts.yes) {
+      const ok = await confirm(`Delete comment ${commentId}?`);
+      if (!ok) {
+        console.error("Aborted.");
+        return;
+      }
+    }
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    await client.delete(`/comments/${encodeURIComponent(commentId)}`);
+    console.error("Deleted.");
+  });
+}
+function truncate2(str, max) {
+  if (str.length <= max) return str;
+  return str.slice(0, max - 3) + "...";
+}
+
+// src/commands/members.ts
+function register12(program2) {
+  const members = program2.command("members").description("Manage workspace members");
+  members.command("list").description("List all workspace members").action(async function() {
+    const opts = this.optsWithGlobals();
+    const client = new AttioClient(opts.apiKey, opts.debug);
+    const format = detectFormat(opts);
+    const response = await client.get("/workspace_members");
+    const rawItems = response.data;
+    if (format === "json") {
+      console.log(JSON.stringify(rawItems, null, 2));
+      return;
+    }
+    if (format === "quiet") {
+      for (const member of rawItems) {
+        console.log(member.id.workspace_member_id);
+      }
+      return;
+    }
+    const flattened = rawItems.map((m) => ({
+      id: m.id.workspace_member_id,
+      first_name: m.first_name,
+      last_name: m.last_name,
+      email_address: m.email_address,
+      access_level: m.access_level
+    }));
+    outputList(flattened, {
+      format,
+      columns: ["id", "first_name", "last_name", "email_address", "access_level"],
+      idField: "id"
+    });
+  });
+}
+
+// src/commands/config.ts
+import chalk4 from "chalk";
+function register13(program2) {
+  const cmd = program2.command("config").description("Manage CLI configuration");
+  cmd.command("set <key> <value>").description("Set a config value (e.g., attio config set api-key <key>)").action((key, value) => {
+    if (key === "api-key") {
+      setApiKey(value);
+      console.error(chalk4.green(`API key saved to ${getConfigPath()}`));
+    } else {
+      console.error(chalk4.red(`Unknown config key: ${key}. Supported: api-key`));
+      process.exit(1);
+    }
+  });
+  cmd.command("get <key>").description("Get a config value (e.g., attio config get api-key)").action((key) => {
+    if (key === "api-key") {
+      const apiKey = resolveApiKey();
+      if (apiKey) {
+        const masked = "\u2022".repeat(Math.max(0, apiKey.length - 4)) + apiKey.slice(-4);
+        console.log(masked);
+      } else {
+        console.error(chalk4.dim("No API key configured."));
+      }
+    } else {
+      console.error(chalk4.red(`Unknown config key: ${key}. Supported: api-key`));
+      process.exit(1);
+    }
+  });
+  cmd.command("path").description("Print config file location").action(() => {
+    console.log(getConfigPath());
+  });
+  cmd.command("claude-md").description("Print a CLAUDE.md snippet for AI agent discovery").action(() => {
+    console.log(CLAUDE_MD_SNIPPET);
+  });
+}
+var CLAUDE_MD_SNIPPET = `## Attio CLI (\`attio\`)
+
+Use the \`attio\` CLI for all Attio CRM operations. Run \`attio <command> --help\` for full usage.
+
+### Common commands
+
+\`\`\`
+attio companies search <query>              Search companies by name/domain
+attio people search <query>                 Search people by name/email
+attio records list <object> --filter <expr> List/filter records (companies, people, or custom objects)
+attio tasks create --content <text> --deadline <ISO-date> --record <object:record-id>
+attio notes create --object <obj> --record <id> --title <t> --content <text>
+attio open <object> [record-id]             Open in browser
+\`\`\`
+
+### Output
+
+Auto-detects TTY: table for terminal, JSON when piped. Force with \`--json\`, \`--csv\`, or \`--table\`. Use \`-q\` for IDs only.
+
+### Filters & sorting
+
+\`--filter 'name~Acme'\` \`--filter 'revenue>=1000000'\` \`--sort name:asc\`
+Multiple \`--filter\` flags are ANDed together.`;
+
+// src/commands/open.ts
+import { exec } from "child_process";
+import { platform } from "os";
+import chalk5 from "chalk";
+function register14(program2) {
+  program2.command("open <object> [record-id]").description("Open an object or record in the Attio web app").action(async (object, recordId, options, command) => {
+    const opts = command.optsWithGlobals();
+    let url;
+    if (recordId) {
+      const client = new AttioClient(opts.apiKey, opts.debug);
+      const res = await client.get(`/objects/${object}/records/${recordId}`);
+      const record = res.data;
+      url = record.web_url;
+      if (!url) {
+        console.error(chalk5.red("Record has no web_url."));
+        process.exit(1);
+      }
+    } else {
+      const client = new AttioClient(opts.apiKey, opts.debug);
+      const self = await client.get("/self");
+      const slug = self.workspace_slug || "";
+      url = `https://app.attio.com/${slug}/${object}`;
+    }
+    const cmd = platform() === "darwin" ? "open" : platform() === "win32" ? "start" : "xdg-open";
+    exec(`${cmd} "${url}"`, (err) => {
+      if (err) {
+        console.log(url);
+      }
+    });
+  });
+}
+
+// bin/attio.ts
+function handleError(err) {
+  if (err instanceof AttioApiError) {
+    console.error(err.display());
+    process.exit(err.exitCode);
+  }
+  if (err instanceof AttioAuthError) {
+    console.error(err.display());
+    process.exit(err.exitCode);
+  }
+  if (err instanceof AttioRateLimitError) {
+    console.error(err.display());
+    process.exit(err.exitCode);
+  }
+  if (err instanceof Error) {
+    console.error(chalk6.red(`Error: ${err.message}`));
+    if (process.env.ATTIO_DEBUG || program.opts().debug) {
+      console.error(err.stack);
+    }
+  } else {
+    console.error(chalk6.red("An unexpected error occurred"));
+  }
+  process.exit(1);
+}
+program.name("attio").version("0.1.0").description("CLI for the Attio CRM API. Built for scripts, agents, and humans who prefer terminals.").option("--api-key <key>", "Override API key").option("--json", "Force JSON output").option("--table", "Force table output").option("--csv", "Force CSV output").option("-q, --quiet", "Only output IDs").option("--no-color", "Disable colors").option("--debug", "Print request/response details to stderr");
+register(program);
+register2(program);
+register3(program);
+register4(program);
+register5(program);
+register6(program);
+register7(program);
+register8(program);
+register9(program);
+register10(program);
+register11(program);
+register12(program);
+register13(program);
+register14(program);
+program.parseAsync(process.argv).catch(handleError);
+process.on("uncaughtException", handleError);
+process.on("unhandledRejection", (reason) => handleError(reason));