@andrzejchm/notion-cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,1605 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command as Command14 } from "commander";
+import { fileURLToPath } from "url";
+import { dirname, join as join3 } from "path";
+import { readFileSync } from "fs";
+
+// src/output/color.ts
+import { Chalk } from "chalk";
+var _colorForced = false;
+function setColorForced(forced) {
+  _colorForced = forced;
+}
+function isColorEnabled() {
+  if (process.env.NO_COLOR) return false;
+  if (_colorForced) return true;
+  return Boolean(process.stderr.isTTY);
+}
+function createChalk() {
+  const level = isColorEnabled() ? void 0 : 0;
+  return new Chalk({ level });
+}
+function success(msg) {
+  return createChalk().green(msg);
+}
+function dim(msg) {
+  return createChalk().dim(msg);
+}
+function bold(msg) {
+  return createChalk().bold(msg);
+}
+
+// src/output/format.ts
+import { spawnSync } from "child_process";
+var _mode = "auto";
+function setOutputMode(mode) {
+  _mode = mode;
+}
+function getOutputMode() {
+  return _mode;
+}
+function isatty() {
+  return Boolean(process.stdout.isTTY);
+}
+function isHumanMode() {
+  if (_mode === "json") return false;
+  if (_mode === "md") return false;
+  return isatty();
+}
+function formatJSON(data) {
+  return JSON.stringify(data, null, 2);
+}
+var COLUMN_CAPS = {
+  TITLE: 50,
+  ID: 36
+};
+var DEFAULT_MAX_COL_WIDTH = 40;
+function getColumnCap(header) {
+  return COLUMN_CAPS[header.toUpperCase()] ?? DEFAULT_MAX_COL_WIDTH;
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen - 1) + "\u2026";
+}
+function formatTable(rows, headers) {
+  const colWidths = headers.map((header, colIdx) => {
+    const cap = getColumnCap(header);
+    const headerLen = header.length;
+    const maxRowLen = rows.reduce((max, row) => {
+      const cell = row[colIdx] ?? "";
+      return Math.max(max, cell.length);
+    }, 0);
+    return Math.min(Math.max(headerLen, maxRowLen), cap);
+  });
+  const sep = "\u2500";
+  const colSep = "  ";
+  const headerRow = headers.map((h, i) => h.padEnd(colWidths[i])).join(colSep);
+  const separatorRow = colWidths.map((w) => sep.repeat(w)).join(colSep);
+  const dataRows = rows.map(
+    (row) => headers.map((_, i) => {
+      const cell = row[i] ?? "";
+      return truncate(cell, colWidths[i]).padEnd(colWidths[i]);
+    }).join(colSep)
+  );
+  return [headerRow, separatorRow, ...dataRows].join("\n");
+}
+function printOutput(data, tableHeaders, tableRows) {
+  const mode = getOutputMode();
+  const tty = isatty();
+  if (mode === "json" || !tty && mode === "auto") {
+    process.stdout.write(formatJSON(data) + "\n");
+  } else if (isHumanMode() && tableHeaders && tableRows) {
+    printWithPager(formatTable(tableRows, tableHeaders) + "\n");
+  }
+}
+function printWithPager(text) {
+  if (!isatty()) {
+    process.stdout.write(text);
+    return;
+  }
+  const result = spawnSync("less", ["-IR"], {
+    input: text,
+    stdio: ["pipe", "inherit", "inherit"]
+  });
+  if (result.error) {
+    process.stdout.write(text);
+  }
+}
+
+// src/commands/init.ts
+import { Command } from "commander";
+import { input, password, confirm } from "@inquirer/prompts";
+
+// src/errors/cli-error.ts
+var CliError = class extends Error {
+  constructor(code, message, suggestion) {
+    super(message);
+    this.code = code;
+    this.suggestion = suggestion;
+    this.name = "CliError";
+  }
+  format() {
+    let output = `[${this.code}] ${this.message}`;
+    if (this.suggestion) {
+      output += `
+  \u2192 ${this.suggestion}`;
+    }
+    return output;
+  }
+};
+
+// src/errors/codes.ts
+var ErrorCodes = {
+  // Auth errors
+  AUTH_NO_TOKEN: "AUTH_NO_TOKEN",
+  AUTH_INVALID: "AUTH_INVALID",
+  AUTH_EXPIRED: "AUTH_EXPIRED",
+  AUTH_PROFILE_NOT_FOUND: "AUTH_PROFILE_NOT_FOUND",
+  // Config errors
+  CONFIG_READ_ERROR: "CONFIG_READ_ERROR",
+  CONFIG_WRITE_ERROR: "CONFIG_WRITE_ERROR",
+  CONFIG_INVALID: "CONFIG_INVALID",
+  // Input errors
+  INVALID_ID: "INVALID_ID",
+  INVALID_URL: "INVALID_URL",
+  INVALID_ARG: "INVALID_ARG",
+  // API errors
+  API_ERROR: "API_ERROR",
+  API_RATE_LIMITED: "API_RATE_LIMITED",
+  API_NOT_FOUND: "API_NOT_FOUND",
+  // General
+  UNKNOWN: "UNKNOWN"
+};
+
+// src/config/config.ts
+import { mkdir, readFile, rename, writeFile } from "fs/promises";
+import { parse, stringify } from "yaml";
+
+// src/config/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+function getConfigDir() {
+  const xdgConfigHome = process.env["XDG_CONFIG_HOME"];
+  const base = xdgConfigHome ? xdgConfigHome : join(homedir(), ".config");
+  return join(base, "notion-cli");
+}
+function getConfigPath() {
+  return join(getConfigDir(), "config.yaml");
+}
+
+// src/config/config.ts
+async function readGlobalConfig() {
+  const configPath = getConfigPath();
+  let raw;
+  try {
+    raw = await readFile(configPath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return {};
+    }
+    throw new CliError(
+      ErrorCodes.CONFIG_READ_ERROR,
+      `Failed to read config file: ${configPath}`,
+      'Check file permissions or run "notion init" to create a new config'
+    );
+  }
+  try {
+    const parsed = parse(raw);
+    return parsed ?? {};
+  } catch {
+    throw new CliError(
+      ErrorCodes.CONFIG_READ_ERROR,
+      `Failed to parse config file: ${configPath}`,
+      'The config file may be corrupted. Delete it and run "notion init" to start fresh'
+    );
+  }
+}
+async function writeGlobalConfig(config) {
+  const configDir = getConfigDir();
+  const configPath = getConfigPath();
+  const tmpPath = `${configPath}.tmp`;
+  try {
+    await mkdir(configDir, { recursive: true, mode: 448 });
+  } catch {
+    throw new CliError(
+      ErrorCodes.CONFIG_WRITE_ERROR,
+      `Failed to create config directory: ${configDir}`,
+      "Check that you have write permissions to your home directory"
+    );
+  }
+  const content = stringify(config);
+  try {
+    await writeFile(tmpPath, content, { mode: 384 });
+    await rename(tmpPath, configPath);
+  } catch {
+    throw new CliError(
+      ErrorCodes.CONFIG_WRITE_ERROR,
+      `Failed to write config file: ${configPath}`,
+      "Check file permissions in the config directory"
+    );
+  }
+}
+
+// src/notion/client.ts
+import { Client, APIErrorCode, isNotionClientError } from "@notionhq/client";
+async function validateToken(token) {
+  const notion = new Client({ auth: token });
+  try {
+    const me = await notion.users.me({});
+    const bot = me;
+    const workspaceName = bot.bot?.workspace_name ?? "Unknown Workspace";
+    const workspaceId = bot.bot?.workspace_id ?? "";
+    return { workspaceName, workspaceId };
+  } catch (error2) {
+    if (isNotionClientError(error2) && error2.code === APIErrorCode.Unauthorized) {
+      throw new CliError(
+        ErrorCodes.AUTH_INVALID,
+        "Invalid integration token.",
+        "Check your token at notion.so/profile/integrations/internal"
+      );
+    }
+    throw error2;
+  }
+}
+function createNotionClient(token) {
+  return new Client({ auth: token, timeoutMs: 12e4 });
+}
+
+// src/output/stderr.ts
+function stderrWrite(msg) {
+  process.stderr.write(msg + "\n");
+}
+function reportTokenSource(source) {
+  stderrWrite(dim(`Using token from ${source}`));
+}
+
+// src/errors/error-handler.ts
+function mapNotionErrorCode(code) {
+  switch (code) {
+    case "unauthorized":
+      return ErrorCodes.AUTH_INVALID;
+    case "rate_limited":
+      return ErrorCodes.API_RATE_LIMITED;
+    case "object_not_found":
+      return ErrorCodes.API_NOT_FOUND;
+    default:
+      return ErrorCodes.API_ERROR;
+  }
+}
+function withErrorHandling(fn) {
+  return (async (...args) => {
+    try {
+      await fn(...args);
+    } catch (error2) {
+      if (error2 instanceof CliError) {
+        process.stderr.write(error2.format() + "\n");
+        process.exit(1);
+      }
+      const { isNotionClientError: isNotionClientError2 } = await import("@notionhq/client");
+      if (isNotionClientError2(error2)) {
+        const code = mapNotionErrorCode(error2.code);
+        const mappedError = new CliError(
+          code,
+          error2.message,
+          code === ErrorCodes.AUTH_INVALID ? 'Run "notion init" to reconfigure your integration token' : void 0
+        );
+        process.stderr.write(mappedError.format() + "\n");
+        process.exit(1);
+      }
+      const message = error2 instanceof Error ? error2.message : String(error2);
+      process.stderr.write(`[${ErrorCodes.UNKNOWN}] ${message}
+`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/init.ts
+function initCommand() {
+  const cmd = new Command("init");
+  cmd.description("authenticate with Notion and save a profile").action(withErrorHandling(async () => {
+    if (!process.stdin.isTTY) {
+      throw new CliError(
+        ErrorCodes.AUTH_NO_TOKEN,
+        "Cannot run interactive init in non-TTY mode.",
+        "Set NOTION_API_TOKEN environment variable or create .notion.yaml"
+      );
+    }
+    const profileName = await input({
+      message: "Profile name:",
+      default: "default"
+    });
+    const token = await password({
+      message: "Integration token (from notion.so/profile/integrations/internal):",
+      mask: "*"
+    });
+    stderrWrite("Validating token...");
+    const { workspaceName, workspaceId } = await validateToken(token);
+    stderrWrite(success(`\u2713 Connected to workspace: ${bold(workspaceName)}`));
+    const config = await readGlobalConfig();
+    if (config.profiles?.[profileName]) {
+      const replace = await confirm({
+        message: `Profile "${profileName}" already exists. Replace?`,
+        default: false
+      });
+      if (!replace) {
+        stderrWrite("Aborted.");
+        return;
+      }
+    }
+    const profiles = config.profiles ?? {};
+    profiles[profileName] = {
+      token,
+      workspace_name: workspaceName,
+      workspace_id: workspaceId
+    };
+    await writeGlobalConfig({
+      ...config,
+      profiles,
+      active_profile: profileName
+    });
+    stderrWrite(success(`Profile "${profileName}" saved and set as active.`));
+    stderrWrite(dim("Checking integration access..."));
+    try {
+      const notion = createNotionClient(token);
+      const probe = await notion.search({ page_size: 1 });
+      if (probe.results.length === 0) {
+        stderrWrite("");
+        stderrWrite("\u26A0\uFE0F  Your integration has no pages connected.");
+        stderrWrite("   To grant access, open any Notion page or database:");
+        stderrWrite("     1. Click \xB7\xB7\xB7 (three dots) in the top-right corner");
+        stderrWrite('     2. Select "Connect to"');
+        stderrWrite(`     3. Choose "${workspaceName}"`);
+        stderrWrite("   Then re-run any notion command to confirm access.");
+      } else {
+        stderrWrite(success(`\u2713 Integration has access to content in ${bold(workspaceName)}.`));
+      }
+    } catch {
+      stderrWrite(dim("(Could not verify integration access \u2014 run `notion ls` to check)"));
+    }
+  }));
+  return cmd;
+}
+
+// src/commands/profile/list.ts
+import { Command as Command2 } from "commander";
+function profileListCommand() {
+  const cmd = new Command2("list");
+  cmd.description("list all authentication profiles").action(withErrorHandling(async () => {
+    const config = await readGlobalConfig();
+    const profiles = config.profiles ?? {};
+    const profileNames = Object.keys(profiles);
+    if (profileNames.length === 0) {
+      process.stdout.write("No profiles configured. Run `notion init` to get started.\n");
+      return;
+    }
+    for (const name of profileNames) {
+      const profile = profiles[name];
+      const isActive = config.active_profile === name;
+      const marker = isActive ? bold("* ") : "  ";
+      const activeLabel = isActive ? " (active)" : "";
+      const workspaceInfo = profile.workspace_name ? dim(` \u2014 ${profile.workspace_name}`) : "";
+      process.stdout.write(`${marker}${name}${activeLabel}${workspaceInfo}
+`);
+    }
+  }));
+  return cmd;
+}
+
+// src/commands/profile/use.ts
+import { Command as Command3 } from "commander";
+function profileUseCommand() {
+  const cmd = new Command3("use");
+  cmd.description("switch the active profile").argument("<name>", "profile name to activate").action(withErrorHandling(async (name) => {
+    const config = await readGlobalConfig();
+    const profiles = config.profiles ?? {};
+    if (!profiles[name]) {
+      throw new CliError(
+        ErrorCodes.AUTH_PROFILE_NOT_FOUND,
+        `Profile "${name}" not found.`,
+        `Run "notion profile list" to see available profiles`
+      );
+    }
+    await writeGlobalConfig({
+      ...config,
+      active_profile: name
+    });
+    stderrWrite(success(`Switched to profile "${name}".`));
+  }));
+  return cmd;
+}
+
+// src/commands/profile/remove.ts
+import { Command as Command4 } from "commander";
+function profileRemoveCommand() {
+  const cmd = new Command4("remove");
+  cmd.description("remove an authentication profile").argument("<name>", "profile name to remove").action(withErrorHandling(async (name) => {
+    const config = await readGlobalConfig();
+    const profiles = { ...config.profiles ?? {} };
+    if (!profiles[name]) {
+      throw new CliError(
+        ErrorCodes.AUTH_PROFILE_NOT_FOUND,
+        `Profile "${name}" not found.`,
+        `Run "notion profile list" to see available profiles`
+      );
+    }
+    delete profiles[name];
+    const newActiveProfile = config.active_profile === name ? void 0 : config.active_profile;
+    await writeGlobalConfig({
+      ...config,
+      profiles,
+      active_profile: newActiveProfile
+    });
+    stderrWrite(success(`Profile "${name}" removed.`));
+  }));
+  return cmd;
+}
+
+// src/commands/completion.ts
+import { Command as Command5 } from "commander";
+var BASH_COMPLETION = `# notion bash completion
+_notion_completion() {
+  local cur prev words cword
+  _init_completion || return
+
+  local commands="init profile completion --help --version --verbose --color"
+  local profile_commands="list use remove"
+
+  case "$prev" in
+    notion)
+      COMPREPLY=($(compgen -W "$commands" -- "$cur"))
+      return 0
+      ;;
+    profile)
+      COMPREPLY=($(compgen -W "$profile_commands" -- "$cur"))
+      return 0
+      ;;
+    completion)
+      COMPREPLY=($(compgen -W "bash zsh fish" -- "$cur"))
+      return 0
+      ;;
+  esac
+
+  COMPREPLY=($(compgen -W "$commands" -- "$cur"))
+}
+
+complete -F _notion_completion notion
+`;
+var ZSH_COMPLETION = `#compdef notion
+# notion zsh completion
+
+_notion() {
+  local -a commands
+
+  commands=(
+    'init:authenticate with Notion and save a profile'
+    'profile:manage authentication profiles'
+    'completion:output shell completion script'
+  )
+
+  local -a global_opts
+  global_opts=(
+    '--help[display help]'
+    '--version[output version]'
+    '--verbose[show API requests/responses]'
+    '--color[force color output]'
+  )
+
+  if (( CURRENT == 2 )); then
+    _describe 'command' commands
+    _arguments $global_opts
+    return
+  fi
+
+  case $words[2] in
+    profile)
+      local -a profile_cmds
+      profile_cmds=(
+        'list:list all authentication profiles'
+        'use:switch the active profile'
+        'remove:remove an authentication profile'
+      )
+      _describe 'profile command' profile_cmds
+      ;;
+    completion)
+      local -a shells
+      shells=('bash' 'zsh' 'fish')
+      _describe 'shell' shells
+      ;;
+  esac
+}
+
+_notion "$@"
+`;
+var FISH_COMPLETION = `# notion fish completion
+
+# Disable file completion by default
+complete -c notion -f
+
+# Global options
+complete -c notion -l help -d 'display help'
+complete -c notion -l version -d 'output version'
+complete -c notion -l verbose -d 'show API requests/responses'
+complete -c notion -l color -d 'force color output'
+
+# Top-level commands
+complete -c notion -n '__fish_use_subcommand' -a init -d 'authenticate with Notion and save a profile'
+complete -c notion -n '__fish_use_subcommand' -a profile -d 'manage authentication profiles'
+complete -c notion -n '__fish_use_subcommand' -a completion -d 'output shell completion script'
+
+# profile subcommands
+complete -c notion -n '__fish_seen_subcommand_from profile' -a list -d 'list all authentication profiles'
+complete -c notion -n '__fish_seen_subcommand_from profile' -a use -d 'switch the active profile'
+complete -c notion -n '__fish_seen_subcommand_from profile' -a remove -d 'remove an authentication profile'
+
+# completion shells
+complete -c notion -n '__fish_seen_subcommand_from completion' -a bash -d 'bash completion script'
+complete -c notion -n '__fish_seen_subcommand_from completion' -a zsh -d 'zsh completion script'
+complete -c notion -n '__fish_seen_subcommand_from completion' -a fish -d 'fish completion script'
+`;
+function completionCommand() {
+  const cmd = new Command5("completion");
+  cmd.description("output shell completion script").argument("<shell>", "shell type (bash, zsh, fish)").action(withErrorHandling(async (shell) => {
+    switch (shell) {
+      case "bash":
+        process.stdout.write(BASH_COMPLETION);
+        break;
+      case "zsh":
+        process.stdout.write(ZSH_COMPLETION);
+        break;
+      case "fish":
+        process.stdout.write(FISH_COMPLETION);
+        break;
+      default:
+        throw new CliError(
+          ErrorCodes.UNKNOWN,
+          `Unknown shell: "${shell}".`,
+          "Supported shells: bash, zsh, fish"
+        );
+    }
+  }));
+  return cmd;
+}
+
+// src/commands/search.ts
+import { Command as Command6 } from "commander";
+import { isFullPageOrDataSource } from "@notionhq/client";
+
+// src/config/local-config.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join2 } from "path";
+import { parse as parse2 } from "yaml";
+async function readLocalConfig() {
+  const localConfigPath = join2(process.cwd(), ".notion.yaml");
+  let raw;
+  try {
+    raw = await readFile2(localConfigPath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return null;
+    }
+    throw new CliError(
+      ErrorCodes.CONFIG_READ_ERROR,
+      `Failed to read local config: ${localConfigPath}`,
+      "Check file permissions"
+    );
+  }
+  let parsed;
+  try {
+    parsed = parse2(raw) ?? {};
+  } catch {
+    throw new CliError(
+      ErrorCodes.CONFIG_INVALID,
+      `Failed to parse .notion.yaml`,
+      "Check that the file contains valid YAML"
+    );
+  }
+  if (parsed.profile !== void 0 && parsed.token !== void 0) {
+    throw new CliError(
+      ErrorCodes.CONFIG_INVALID,
+      '.notion.yaml cannot specify both "profile" and "token"',
+      'Use either "profile: <name>" to reference a saved profile, or "token: <value>" for a direct token'
+    );
+  }
+  return parsed;
+}
+
+// src/config/token.ts
+async function resolveToken() {
+  const envToken = process.env["NOTION_API_TOKEN"];
+  if (envToken) {
+    return { token: envToken, source: "NOTION_API_TOKEN" };
+  }
+  const localConfig = await readLocalConfig();
+  if (localConfig !== null) {
+    if (localConfig.token) {
+      return { token: localConfig.token, source: ".notion.yaml" };
+    }
+    if (localConfig.profile) {
+      const globalConfig2 = await readGlobalConfig();
+      const profileToken = globalConfig2.profiles?.[localConfig.profile]?.token;
+      if (profileToken) {
+        return { token: profileToken, source: `profile: ${localConfig.profile}` };
+      }
+    }
+  }
+  const globalConfig = await readGlobalConfig();
+  if (globalConfig.active_profile) {
+    const profileToken = globalConfig.profiles?.[globalConfig.active_profile]?.token;
+    if (profileToken) {
+      return { token: profileToken, source: `profile: ${globalConfig.active_profile}` };
+    }
+  }
+  throw new CliError(
+    ErrorCodes.AUTH_NO_TOKEN,
+    "No authentication token found.",
+    'Run "notion init" to set up a profile'
+  );
+}
+
+// src/commands/search.ts
+function getTitle(item) {
+  if (item.object === "data_source") {
+    return item.title.map((t) => t.plain_text).join("") || "(untitled)";
+  }
+  const titleProp = Object.values(item.properties).find((p) => p.type === "title");
+  if (titleProp?.type === "title") {
+    return titleProp.title.map((t) => t.plain_text).join("") || "(untitled)";
+  }
+  return "(untitled)";
+}
+function toSdkFilterValue(type) {
+  return type === "database" ? "data_source" : "page";
+}
+function displayType(item) {
+  return item.object === "data_source" ? "database" : item.object;
+}
+function searchCommand() {
+  const cmd = new Command6("search");
+  cmd.description("search Notion workspace by keyword").argument("<query>", "search keyword").option("--type <type>", "filter by object type (page or database)", (val) => {
+    if (val !== "page" && val !== "database") {
+      throw new Error('--type must be "page" or "database"');
+    }
+    return val;
+  }).option("--cursor <cursor>", "start from this pagination cursor (from a previous --next hint)").option("--json", "force JSON output").action(
+    withErrorHandling(async (query, opts) => {
+      if (opts.json) {
+        setOutputMode("json");
+      }
+      const { token, source } = await resolveToken();
+      reportTokenSource(source);
+      const notion = createNotionClient(token);
+      const response = await notion.search({
+        query,
+        filter: opts.type ? { property: "object", value: toSdkFilterValue(opts.type) } : void 0,
+        start_cursor: opts.cursor,
+        page_size: 20
+      });
+      const fullResults = response.results.filter((r) => isFullPageOrDataSource(r));
+      if (fullResults.length === 0) {
+        process.stdout.write(`No results found for "${query}"
+`);
+        return;
+      }
+      const headers = ["TYPE", "TITLE", "ID", "MODIFIED"];
+      const rows = fullResults.map((item) => [
+        displayType(item),
+        getTitle(item),
+        item.id,
+        item.last_edited_time.split("T")[0]
+      ]);
+      printOutput(fullResults, headers, rows);
+      if (response.has_more && response.next_cursor) {
+        process.stderr.write(`
+  --next: notion search "${query}" --cursor ${response.next_cursor}
+`);
+      }
+    })
+  );
+  return cmd;
+}
+
+// src/commands/ls.ts
+import { Command as Command7 } from "commander";
+import { isFullPageOrDataSource as isFullPageOrDataSource2 } from "@notionhq/client";
+function getTitle2(item) {
+  if (item.object === "data_source") {
+    return item.title.map((t) => t.plain_text).join("") || "(untitled)";
+  }
+  const titleProp = Object.values(item.properties).find((p) => p.type === "title");
+  if (titleProp?.type === "title") {
+    return titleProp.title.map((t) => t.plain_text).join("") || "(untitled)";
+  }
+  return "(untitled)";
+}
+function displayType2(item) {
+  return item.object === "data_source" ? "database" : item.object;
+}
+function lsCommand() {
+  const cmd = new Command7("ls");
+  cmd.description("list accessible Notion pages and databases").option("--type <type>", "filter by object type (page or database)", (val) => {
+    if (val !== "page" && val !== "database") {
+      throw new Error('--type must be "page" or "database"');
+    }
+    return val;
+  }).option("--cursor <cursor>", "start from this pagination cursor (from a previous --next hint)").option("--json", "force JSON output").action(
+    withErrorHandling(async (opts) => {
+      if (opts.json) {
+        setOutputMode("json");
+      }
+      const { token, source } = await resolveToken();
+      reportTokenSource(source);
+      const notion = createNotionClient(token);
+      const response = await notion.search({
+        start_cursor: opts.cursor,
+        page_size: 20
+      });
+      let items = response.results.filter((r) => isFullPageOrDataSource2(r));
+      if (opts.type) {
+        const filterType = opts.type;
+        items = items.filter(
+          (r) => filterType === "database" ? r.object === "data_source" : r.object === filterType
+        );
+      }
+      if (items.length === 0) {
+        process.stdout.write("No accessible content found\n");
+        return;
+      }
+      const headers = ["TYPE", "TITLE", "ID", "MODIFIED"];
+      const rows = items.map((item) => [
+        displayType2(item),
+        getTitle2(item),
+        item.id,
+        item.last_edited_time.split("T")[0]
+      ]);
+      printOutput(items, headers, rows);
+      if (response.has_more && response.next_cursor) {
+        process.stderr.write(`
+  --next: notion ls --cursor ${response.next_cursor}
+`);
+      }
+    })
+  );
+  return cmd;
+}
+
+// src/commands/open.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import { Command as Command8 } from "commander";
+
+// src/notion/url-parser.ts
+var NOTION_ID_REGEX = /^[0-9a-f]{32}$/i;
+var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var NOTION_URL_REGEX = /https?:\/\/(?:[a-zA-Z0-9-]+\.)?notion\.(?:so|site)\/.*?([0-9a-f]{32})(?:[?#]|$)/i;
+function throwInvalidId(input2) {
+  throw new CliError(
+    ErrorCodes.INVALID_ID,
+    `Cannot parse Notion ID from: ${input2}`,
+    "Provide a valid Notion URL or page/database ID"
+  );
+}
+function parseNotionId(input2) {
+  if (!input2) throwInvalidId(input2);
+  if (NOTION_ID_REGEX.test(input2)) {
+    return input2.toLowerCase();
+  }
+  if (UUID_REGEX.test(input2)) {
+    return input2.replace(/-/g, "").toLowerCase();
+  }
+  const urlMatch = NOTION_URL_REGEX.exec(input2);
+  if (urlMatch) {
+    return urlMatch[1].toLowerCase();
+  }
+  throwInvalidId(input2);
+}
+function toUuid(id) {
+  return `${id.slice(0, 8)}-${id.slice(8, 12)}-${id.slice(12, 16)}-${id.slice(16, 20)}-${id.slice(20)}`;
+}
+
+// src/commands/open.ts
+var execAsync = promisify(exec);
+function openCommand() {
+  const cmd = new Command8("open");
+  cmd.description("open a Notion page in the default browser").argument("<id/url>", "Notion page ID or URL").action(withErrorHandling(async (idOrUrl) => {
+    const id = parseNotionId(idOrUrl);
+    const url = `https://www.notion.so/${id}`;
+    const platform = process.platform;
+    const opener = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
+    await execAsync(`${opener} "${url}"`);
+    process.stdout.write(`Opening ${url}
+`);
+  }));
+  return cmd;
+}
+
+// src/commands/users.ts
+import { Command as Command9 } from "commander";
+
+// src/output/paginate.ts
+async function paginateResults(fetcher) {
+  const allResults = [];
+  let cursor;
+  let hasMore = true;
+  while (hasMore) {
+    const response = await fetcher(cursor);
+    allResults.push(...response.results);
+    cursor = response.next_cursor ?? void 0;
+    hasMore = response.has_more;
+  }
+  return allResults;
+}
+
+// src/commands/users.ts
+function getEmailOrWorkspace(user) {
+  if (user.type === "person") {
+    return user.person.email ?? "\u2014";
+  }
+  if (user.type === "bot") {
+    const bot = user.bot;
+    return "workspace_name" in bot && bot.workspace_name ? bot.workspace_name : "\u2014";
+  }
+  return "\u2014";
+}
+function usersCommand() {
+  const cmd = new Command9("users");
+  cmd.description("list all users in the workspace").option("--json", "output as JSON").action(withErrorHandling(async (opts) => {
+    if (opts.json) setOutputMode("json");
+    const { token, source } = await resolveToken();
+    reportTokenSource(source);
+    const notion = createNotionClient(token);
+    const allUsers = await paginateResults(
+      (cursor) => notion.users.list({ start_cursor: cursor })
+    );
+    const users = allUsers.filter((u) => u.name !== void 0);
+    const rows = users.map((user) => [
+      user.type,
+      user.name ?? "(unnamed)",
+      getEmailOrWorkspace(user),
+      user.id
+    ]);
+    printOutput(users, ["TYPE", "NAME", "EMAIL / WORKSPACE", "ID"], rows);
+  }));
+  return cmd;
+}
+
+// src/commands/comments.ts
+import { Command as Command10 } from "commander";
+function commentsCommand() {
+  const cmd = new Command10("comments");
+  cmd.description("list comments on a Notion page").argument("<id/url>", "Notion page ID or URL").option("--json", "output as JSON").action(withErrorHandling(async (idOrUrl, opts) => {
+    if (opts.json) setOutputMode("json");
+    const id = parseNotionId(idOrUrl);
+    const uuid = toUuid(id);
+    const { token, source } = await resolveToken();
+    reportTokenSource(source);
+    const notion = createNotionClient(token);
+    const comments = await paginateResults(
+      (cursor) => notion.comments.list({ block_id: uuid, start_cursor: cursor })
+    );
+    if (comments.length === 0) {
+      process.stdout.write("No comments found on this page\n");
+      return;
+    }
+    const rows = comments.map((comment) => {
+      const text = comment.rich_text.map((t) => t.plain_text).join("");
+      return [
+        comment.created_time.split("T")[0],
+        comment.created_by.id.slice(0, 8) + "...",
+        text.slice(0, 80) + (text.length > 80 ? "\u2026" : "")
+      ];
+    });
+    printOutput(comments, ["DATE", "AUTHOR ID", "COMMENT"], rows);
+  }));
+  return cmd;
+}
+
+// src/commands/read.ts
+import { Command as Command11 } from "commander";
+
+// src/services/page.service.ts
+import { collectPaginatedAPI, isFullBlock } from "@notionhq/client";
+var MAX_CONCURRENT_REQUESTS = 3;
+async function fetchBlockTree(client, blockId, depth, maxDepth) {
+  if (depth >= maxDepth) return [];
+  const rawBlocks = await collectPaginatedAPI(client.blocks.children.list, {
+    block_id: blockId
+  });
+  const blocks = rawBlocks.filter(isFullBlock);
+  const SKIP_RECURSE = /* @__PURE__ */ new Set(["child_page", "child_database"]);
+  const nodes = [];
+  for (let i = 0; i < blocks.length; i += MAX_CONCURRENT_REQUESTS) {
+    const batch = blocks.slice(i, i + MAX_CONCURRENT_REQUESTS);
+    const batchNodes = await Promise.all(
+      batch.map(async (block) => {
+        const children = block.has_children && !SKIP_RECURSE.has(block.type) ? await fetchBlockTree(client, block.id, depth + 1, maxDepth) : [];
+        return { block, children };
+      })
+    );
+    nodes.push(...batchNodes);
+  }
+  return nodes;
+}
+async function fetchPageWithBlocks(client, pageId) {
+  const page = await client.pages.retrieve({ page_id: pageId });
+  const blocks = await fetchBlockTree(client, pageId, 0, 10);
+  return { page, blocks };
+}
+
+// src/blocks/rich-text.ts
+function richTextToMd(richText) {
+  return richText.map(segmentToMd).join("");
+}
+function segmentToMd(segment) {
+  if (segment.type === "equation") {
+    return `$${segment.equation.expression}$`;
+  }
+  if (segment.type === "mention") {
+    const text = segment.plain_text;
+    return segment.href ? `[${text}](${segment.href})` : text;
+  }
+  const annotated = applyAnnotations(segment.text.content, segment.annotations);
+  return segment.text.link ? `[${annotated}](${segment.text.link.url})` : annotated;
+}
+function applyAnnotations(text, annotations) {
+  let result = text;
+  if (annotations.code) result = `\`${result}\``;
+  if (annotations.strikethrough) result = `~~${result}~~`;
+  if (annotations.italic) result = `_${result}_`;
+  if (annotations.bold) result = `**${result}**`;
+  return result;
+}
+
+// src/blocks/converters.ts
+function indentChildren(childrenMd) {
+  return childrenMd.split("\n").filter(Boolean).map((line) => "  " + line).join("\n") + "\n";
+}
+var converters = {
+  paragraph(block) {
+    const b = block;
+    return `${richTextToMd(b.paragraph.rich_text)}
+`;
+  },
+  heading_1(block) {
+    const b = block;
+    return `# ${richTextToMd(b.heading_1.rich_text)}
+`;
+  },
+  heading_2(block) {
+    const b = block;
+    return `## ${richTextToMd(b.heading_2.rich_text)}
+`;
+  },
+  heading_3(block) {
+    const b = block;
+    return `### ${richTextToMd(b.heading_3.rich_text)}
+`;
+  },
+  bulleted_list_item(block, ctx) {
+    const b = block;
+    const text = richTextToMd(b.bulleted_list_item.rich_text);
+    const header = `- ${text}
+`;
+    if (ctx?.childrenMd) {
+      return header + indentChildren(ctx.childrenMd);
+    }
+    return header;
+  },
+  numbered_list_item(block, ctx) {
+    const b = block;
+    const num = ctx?.listNumber ?? 1;
+    return `${num}. ${richTextToMd(b.numbered_list_item.rich_text)}
+`;
+  },
+  to_do(block) {
+    const b = block;
+    const checkbox = b.to_do.checked ? "[x]" : "[ ]";
+    return `- ${checkbox} ${richTextToMd(b.to_do.rich_text)}
+`;
+  },
+  code(block) {
+    const b = block;
+    const lang = b.code.language === "plain text" ? "" : b.code.language;
+    const content = richTextToMd(b.code.rich_text);
+    return `\`\`\`${lang}
+${content}
+\`\`\`
+`;
+  },
+  quote(block) {
+    const b = block;
+    return `> ${richTextToMd(b.quote.rich_text)}
+`;
+  },
+  divider() {
+    return "---\n";
+  },
+  callout(block) {
+    const b = block;
+    const text = richTextToMd(b.callout.rich_text);
+    const icon = b.callout.icon;
+    if (icon?.type === "emoji") {
+      return `> ${icon.emoji} ${text}
+`;
+    }
+    return `> ${text}
+`;
+  },
+  toggle(block, ctx) {
+    const b = block;
+    const header = `**${richTextToMd(b.toggle.rich_text)}**
+`;
+    if (ctx?.childrenMd) {
+      return header + ctx.childrenMd;
+    }
+    return header;
+  },
+  image(block) {
+    const b = block;
+    const caption = richTextToMd(b.image.caption);
+    if (b.image.type === "file") {
+      const url2 = b.image.file.url;
+      const expiry = b.image.file.expiry_time;
+      return `![${caption}](${url2}) <!-- expires: ${expiry} -->
+`;
+    }
+    const url = b.image.external.url;
+    return `![${caption}](${url})
+`;
+  },
+  bookmark(block) {
+    const b = block;
+    const caption = richTextToMd(b.bookmark.caption);
+    const text = caption || b.bookmark.url;
+    return `[${text}](${b.bookmark.url})
+`;
+  },
+  child_page(block) {
+    const b = block;
+    return `### ${b.child_page.title}
+`;
+  },
+  child_database(block) {
+    const b = block;
+    return `### ${b.child_database.title}
+`;
+  },
+  link_preview(block) {
+    const b = block;
+    return `[${b.link_preview.url}](${b.link_preview.url})
+`;
+  }
+};
+function blockToMd(block, ctx) {
+  const converter = converters[block.type];
+  if (converter) {
+    return converter(block, ctx);
+  }
+  return `<!-- unsupported block: ${block.type} -->
+`;
+}
+
+// src/blocks/properties.ts
+function formatPropertyValue(name, prop) {
+  switch (prop.type) {
+    case "title":
+      return prop.title.map((rt) => rt.plain_text).join("");
+    case "rich_text":
+      return prop.rich_text.map((rt) => rt.plain_text).join("");
+    case "number":
+      return prop.number !== null ? String(prop.number) : "";
+    case "select":
+      return prop.select?.name ?? "";
+    case "status":
+      return prop.status?.name ?? "";
+    case "multi_select":
+      return prop.multi_select.map((s) => s.name).join(", ");
+    case "date":
+      if (!prop.date) return "";
+      return prop.date.end ? `${prop.date.start} \u2192 ${prop.date.end}` : prop.date.start;
+    case "checkbox":
+      return prop.checkbox ? "true" : "false";
+    case "url":
+      return prop.url ?? "";
+    case "email":
+      return prop.email ?? "";
+    case "phone_number":
+      return prop.phone_number ?? "";
+    case "people":
+      return prop.people.map((p) => "name" in p && p.name ? p.name : p.id).join(", ");
+    case "relation":
+      return prop.relation.map((r) => r.id).join(", ");
+    case "formula": {
+      const f = prop.formula;
+      if (f.type === "string") return f.string ?? "";
+      if (f.type === "number") return f.number !== null ? String(f.number) : "";
+      if (f.type === "boolean") return String(f.boolean);
+      if (f.type === "date") return f.date?.start ?? "";
+      return "";
+    }
+    case "rollup": {
+      const r = prop.rollup;
+      if (r.type === "number") return r.number !== null ? String(r.number) : "";
+      if (r.type === "date") return r.date?.start ?? "";
+      if (r.type === "array") return `[${r.array.length} items]`;
+      return "";
+    }
+    case "created_time":
+      return prop.created_time;
+    case "last_edited_time":
+      return prop.last_edited_time;
+    case "created_by":
+      return "name" in prop.created_by ? prop.created_by.name ?? prop.created_by.id : prop.created_by.id;
+    case "last_edited_by":
+      return "name" in prop.last_edited_by ? prop.last_edited_by.name ?? prop.last_edited_by.id : prop.last_edited_by.id;
+    case "files":
+      return prop.files.map((f) => {
+        if (f.type === "external") return f.external.url;
+        return f.name;
+      }).join(", ");
+    case "unique_id":
+      return prop.unique_id.prefix ? `${prop.unique_id.prefix}-${prop.unique_id.number}` : String(prop.unique_id.number ?? "");
+    default:
+      return "";
+  }
+}
+
+// src/blocks/render.ts
+function buildPropertiesHeader(page) {
+  const lines = ["---"];
+  for (const [name, prop] of Object.entries(page.properties)) {
+    const value = formatPropertyValue(name, prop);
+    if (value) {
+      lines.push(`${name}: ${value}`);
+    }
+  }
+  lines.push("---", "");
+  return lines.join("\n");
+}
+function renderBlockTree(blocks) {
+  const parts = [];
+  let listCounter = 0;
+  for (const node of blocks) {
+    if (node.block.type === "numbered_list_item") {
+      listCounter++;
+    } else {
+      listCounter = 0;
+    }
+    const childrenMd = node.children.length > 0 ? renderBlockTree(node.children) : "";
+    const md = blockToMd(node.block, {
+      listNumber: node.block.type === "numbered_list_item" ? listCounter : void 0,
+      childrenMd: childrenMd || void 0
+    });
+    parts.push(md);
+  }
+  return parts.join("");
+}
+function renderPageMarkdown({ page, blocks }) {
+  const header = buildPropertiesHeader(page);
+  const content = renderBlockTree(blocks);
+  return header + content;
+}
+
+// src/output/markdown.ts
+import { Chalk as Chalk2 } from "chalk";
+var c = new Chalk2({ level: 3 });
+function renderMarkdown(md) {
+  if (!isatty()) return md;
+  const lines = md.split("\n");
+  const out = [];
+  let inFence = false;
+  let fenceLang = "";
+  let fenceLines = [];
+  for (const line of lines) {
+    const fenceMatch = line.match(/^```(\w*)$/);
+    if (fenceMatch && !inFence) {
+      inFence = true;
+      fenceLang = fenceMatch[1] ?? "";
+      fenceLines = [];
+      continue;
+    }
+    if (line === "```" && inFence) {
+      inFence = false;
+      const header = fenceLang ? c.dim(`[${fenceLang}]`) : "";
+      if (header) out.push(header);
+      for (const fl of fenceLines) {
+        out.push(c.green("  " + fl));
+      }
+      out.push("");
+      continue;
+    }
+    if (inFence) {
+      fenceLines.push(line);
+      continue;
+    }
+    if (line === "---") {
+      out.push(c.dim("\u2500".repeat(40)));
+      continue;
+    }
+    if (/^<!--.*-->$/.test(line.trim())) {
+      continue;
+    }
+    const h1 = line.match(/^# (.+)/);
+    if (h1) {
+      out.push("\n" + c.bold.cyan(h1[1]));
+      continue;
+    }
+    const h2 = line.match(/^## (.+)/);
+    if (h2) {
+      out.push("\n" + c.bold.blue(h2[1]));
+      continue;
+    }
+    const h3 = line.match(/^### (.+)/);
+    if (h3) {
+      out.push("\n" + c.bold(h3[1]));
+      continue;
+    }
+    const h4 = line.match(/^#### (.+)/);
+    if (h4) {
+      out.push(c.bold.underline(h4[1]));
+      continue;
+    }
+    if (line.startsWith("> ")) {
+      out.push(c.yellow("\u258E ") + renderInline(line.slice(2)));
+      continue;
+    }
+    if (line === "---") {
+      out.push(c.dim("\u2500".repeat(40)));
+      continue;
+    }
+    const propMatch = line.match(/^([A-Za-z_][A-Za-z0-9_ ]*): (.+)$/);
+    if (propMatch) {
+      out.push(c.dim(propMatch[1] + ": ") + c.white(propMatch[2]));
+      continue;
+    }
+    const bulletMatch = line.match(/^(\s*)- (\[[ x]\] )?(.+)/);
+    if (bulletMatch) {
+      const indent = bulletMatch[1] ?? "";
+      const checkbox = bulletMatch[2];
+      const text = bulletMatch[3] ?? "";
+      if (checkbox) {
+        const checked = checkbox.trim() === "[x]";
+        const box = checked ? c.green("\u2611") : c.dim("\u2610");
+        out.push(indent + box + " " + renderInline(text));
+      } else {
+        out.push(indent + c.cyan("\u2022") + " " + renderInline(text));
+      }
+      continue;
+    }
+    const numMatch = line.match(/^(\s*)(\d+)\. (.+)/);
+    if (numMatch) {
+      const indent = numMatch[1] ?? "";
+      const num = numMatch[2] ?? "";
+      const text = numMatch[3] ?? "";
+      out.push(indent + c.cyan(num + ".") + " " + renderInline(text));
+      continue;
+    }
+    out.push(renderInline(line));
+  }
+  return out.join("\n") + "\n";
+}
+function renderInline(text) {
+  const codeSpans = [];
+  let result = text.replace(/`([^`]+)`/g, (_, code) => {
+    codeSpans.push(c.green(code));
+    return `\0CODE${codeSpans.length - 1}\0`;
+  });
+  result = result.replace(/!\[([^\]]*)\]\([^)]+\)/g, (_, alt) => alt ? c.dim(`[image: ${alt}]`) : c.dim("[image]")).replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, t, url) => c.cyan.underline(t) + c.dim(` (${url})`)).replace(/\*\*\*(.+?)\*\*\*/g, (_, t) => c.bold.italic(t)).replace(/\*\*(.+?)\*\*/g, (_, t) => c.bold(t)).replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, (_, t) => c.italic(t)).replace(/(?<!_)_(?!_)(.+?)(?<!_)_(?!_)/g, (_, t) => c.italic(t)).replace(/~~(.+?)~~/g, (_, t) => c.strikethrough(t));
+  result = result.replace(/\x00CODE(\d+)\x00/g, (_, i) => codeSpans[Number(i)] ?? "");
+  return result;
+}
+
+// src/commands/read.ts
+function readCommand() {
+  return new Command11("read").description("Read a Notion page as markdown").argument("<id>", "Notion page ID or URL").option("--json", "Output raw JSON instead of markdown").option("--md", "Output raw markdown (no terminal styling)").action(
+    withErrorHandling(async (id, options) => {
+      const { token } = await resolveToken();
+      const client = createNotionClient(token);
+      const pageId = parseNotionId(id);
+      const pageWithBlocks = await fetchPageWithBlocks(client, pageId);
+      if (options.json) {
+        process.stdout.write(JSON.stringify(pageWithBlocks, null, 2) + "\n");
+      } else {
+        const markdown = renderPageMarkdown(pageWithBlocks);
+        if (options.md || !isatty()) {
+          process.stdout.write(markdown);
+        } else {
+          process.stdout.write(renderMarkdown(markdown));
+        }
+      }
+    })
+  );
+}
+
+// src/commands/db/schema.ts
+import { Command as Command12 } from "commander";
+
+// src/services/database.service.ts
+import { isFullPage as isFullPage2 } from "@notionhq/client";
+async function fetchDatabaseSchema(client, dbId) {
+  const ds = await client.dataSources.retrieve({ data_source_id: dbId });
+  const title = "title" in ds ? ds.title.map((rt) => rt.plain_text).join("") || dbId : dbId;
+  const properties = {};
+  if ("properties" in ds) {
+    for (const [name, prop] of Object.entries(ds.properties)) {
+      const config = {
+        id: prop.id,
+        name,
+        type: prop.type
+      };
+      if (prop.type === "select" && "select" in prop) {
+        config.options = prop.select.options;
+      } else if (prop.type === "status" && "status" in prop) {
+        config.options = prop.status.options;
+      } else if (prop.type === "multi_select" && "multi_select" in prop) {
+        config.options = prop.multi_select.options;
+      }
+      properties[name] = config;
+    }
+  }
+  return { id: dbId, title, properties };
+}
+async function queryDatabase(client, dbId, opts = {}) {
+  const rawPages = await paginateResults(
+    (cursor) => client.dataSources.query({
+      data_source_id: dbId,
+      filter: opts.filter,
+      sorts: opts.sorts,
+      start_cursor: cursor,
+      page_size: 100
+    })
+  );
+  return rawPages.filter(isFullPage2).map((page) => {
+    const propValues = {};
+    for (const [name, prop] of Object.entries(page.properties)) {
+      if (opts.columns && !opts.columns.includes(name)) continue;
+      propValues[name] = displayPropertyValue(prop);
+    }
+    return { id: page.id, properties: propValues, raw: page };
+  });
+}
+function buildFilter(filterStrings, schema) {
+  if (!filterStrings.length) return void 0;
+  const filters = filterStrings.map((raw) => {
+    const eqIdx = raw.indexOf("=");
+    if (eqIdx === -1) {
+      throw new CliError(
+        ErrorCodes.INVALID_ARG,
+        `Invalid filter syntax: "${raw}"`,
+        'Use format: --filter "PropertyName=Value"'
+      );
+    }
+    const propName = raw.slice(0, eqIdx).trim();
+    const value = raw.slice(eqIdx + 1).trim();
+    const propConfig = schema.properties[propName];
+    if (!propConfig) {
+      const available = Object.keys(schema.properties).join(", ");
+      throw new CliError(
+        ErrorCodes.INVALID_ARG,
+        `Property "${propName}" not found`,
+        `Available properties: ${available}`
+      );
+    }
+    return buildPropertyFilter(propName, propConfig.type, value);
+  });
+  return filters.length === 1 ? filters[0] : { and: filters };
+}
+function buildPropertyFilter(property, type, value) {
+  switch (type) {
+    case "select":
+      return { property, select: { equals: value } };
+    case "status":
+      return { property, status: { equals: value } };
+    case "multi_select":
+      return { property, multi_select: { contains: value } };
+    case "checkbox":
+      return { property, checkbox: { equals: value.toLowerCase() === "true" } };
+    case "number":
+      return { property, number: { equals: Number(value) } };
+    case "title":
+      return { property, title: { contains: value } };
+    case "rich_text":
+      return { property, rich_text: { contains: value } };
+    case "url":
+      return { property, url: { contains: value } };
+    case "email":
+      return { property, email: { contains: value } };
+    default:
+      throw new CliError(
+        ErrorCodes.INVALID_ARG,
+        `Filtering by property type "${type}" is not supported`
+      );
+  }
+}
+function buildSorts(sortStrings) {
+  return sortStrings.map((raw) => {
+    const colonIdx = raw.lastIndexOf(":");
+    if (colonIdx === -1) {
+      return { property: raw.trim(), direction: "ascending" };
+    }
+    const property = raw.slice(0, colonIdx).trim();
+    const dir = raw.slice(colonIdx + 1).trim().toLowerCase();
+    return {
+      property,
+      direction: dir === "desc" || dir === "descending" ? "descending" : "ascending"
+    };
+  });
+}
+function displayPropertyValue(prop) {
+  switch (prop.type) {
+    case "title":
+      return prop.title.map((r) => r.plain_text).join("").replace(/\n/g, " ");
+    case "rich_text":
+      return prop.rich_text.map((r) => r.plain_text).join("").replace(/\n/g, " ");
+    case "number":
+      return prop.number !== null && prop.number !== void 0 ? String(prop.number) : "";
+    case "select":
+      return prop.select?.name ?? "";
+    case "status":
+      return prop.status?.name ?? "";
+    case "multi_select":
+      return prop.multi_select.map((s) => s.name).join(", ");
+    case "date":
+      return prop.date ? prop.date.end ? `${prop.date.start} \u2192 ${prop.date.end}` : prop.date.start : "";
+    case "checkbox":
+      return prop.checkbox ? "\u2713" : "\u2717";
+    case "url":
+      return prop.url ?? "";
+    case "email":
+      return prop.email ?? "";
+    case "phone_number":
+      return prop.phone_number ?? "";
+    case "people":
+      return prop.people.map((p) => "name" in p && p.name ? p.name : p.id).join(", ");
+    case "relation":
+      return prop.relation.length > 0 ? `[${prop.relation.length}]` : "";
+    case "formula": {
+      const f = prop.formula;
+      if (f.type === "string") return f.string ?? "";
+      if (f.type === "number")
+        return f.number !== null && f.number !== void 0 ? String(f.number) : "";
+      if (f.type === "boolean") return f.boolean ? "true" : "false";
+      if (f.type === "date") return f.date?.start ?? "";
+      return "";
+    }
+    case "created_time":
+      return prop.created_time;
+    case "last_edited_time":
+      return prop.last_edited_time;
+    case "unique_id":
+      return prop.unique_id.prefix ? `${prop.unique_id.prefix}-${prop.unique_id.number}` : String(prop.unique_id.number ?? "");
+    default:
+      return "";
+  }
+}
+
+// src/commands/db/schema.ts
+function dbSchemaCommand() {
+  return new Command12("schema").description("Show database schema (property names, types, and options)").argument("<id>", "Notion database ID or URL").option("--json", "Output raw JSON").action(
+    withErrorHandling(async (id, options) => {
+      const { token } = await resolveToken();
+      const client = createNotionClient(token);
+      const dbId = parseNotionId(id);
+      const schema = await fetchDatabaseSchema(client, dbId);
+      if (options.json || !isHumanMode()) {
+        process.stdout.write(formatJSON(schema) + "\n");
+        return;
+      }
+      const headers = ["PROPERTY", "TYPE", "OPTIONS"];
+      const rows = Object.values(schema.properties).map((prop) => [
+        prop.name,
+        prop.type,
+        prop.options ? prop.options.map((o) => o.name).join(", ") : ""
+      ]);
+      process.stdout.write(formatTable(rows, headers) + "\n");
+    })
+  );
+}
+
+// src/commands/db/query.ts
+import { Command as Command13 } from "commander";
+var SKIP_TYPES_IN_AUTO = /* @__PURE__ */ new Set(["relation", "rich_text", "people"]);
+function autoSelectColumns(schema, entries) {
+  const termWidth = process.stdout.columns || 120;
+  const COL_SEP = 2;
+  const candidates = Object.values(schema.properties).filter((p) => !SKIP_TYPES_IN_AUTO.has(p.type)).map((p) => p.name);
+  const widths = candidates.map((col) => {
+    const header = col.toUpperCase().length;
+    const maxData = entries.reduce((max, e) => Math.max(max, (e.properties[col] ?? "").length), 0);
+    return Math.min(Math.max(header, maxData), 40);
+  });
+  const selected = [];
+  let usedWidth = 0;
+  for (let i = 0; i < candidates.length; i++) {
+    const needed = (selected.length > 0 ? COL_SEP : 0) + widths[i];
+    if (usedWidth + needed > termWidth) break;
+    selected.push(candidates[i]);
+    usedWidth += needed;
+  }
+  if (selected.length === 0 && candidates.length > 0) {
+    selected.push(candidates[0]);
+  }
+  return selected;
+}
+function dbQueryCommand() {
+  return new Command13("query").description("Query database entries with optional filtering and sorting").argument("<id>", "Notion database ID or URL").option("--filter <filter>", 'Filter entries (repeatable): --filter "Status=Done"', collect, []).option("--sort <sort>", 'Sort entries (repeatable): --sort "Name:asc"', collect, []).option("--columns <columns>", 'Comma-separated list of columns to display: --columns "Title,Status"').option("--json", "Output raw JSON").action(
+    withErrorHandling(
+      async (id, options) => {
+        const { token } = await resolveToken();
+        const client = createNotionClient(token);
+        const dbId = parseNotionId(id);
+        const schema = await fetchDatabaseSchema(client, dbId);
+        const columns = options.columns ? options.columns.split(",").map((c2) => c2.trim()) : void 0;
+        const filter = options.filter.length ? buildFilter(options.filter, schema) : void 0;
+        const sorts = options.sort.length ? buildSorts(options.sort) : void 0;
+        const entries = await queryDatabase(client, dbId, { filter, sorts, columns });
+        if (options.json || !isHumanMode()) {
+          process.stdout.write(formatJSON(entries.map((e) => e.raw)) + "\n");
+          return;
+        }
+        if (entries.length === 0) {
+          process.stdout.write("No entries found.\n");
+          return;
+        }
+        const displayColumns = columns ?? autoSelectColumns(schema, entries);
+        const headers = displayColumns.map((c2) => c2.toUpperCase());
+        const rows = entries.map(
+          (entry) => displayColumns.map((col) => entry.properties[col] ?? "")
+        );
+        process.stdout.write(formatTable(rows, headers) + "\n");
+        process.stderr.write(`${entries.length} entries
+`);
+      }
+    )
+  );
+}
+function collect(value, previous) {
+  return previous.concat([value]);
+}
+
+// src/cli.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var pkg = JSON.parse(readFileSync(join3(__dirname, "../package.json"), "utf-8"));
+var program = new Command14();
+program.name("notion").description("Notion CLI \u2014 read Notion pages and databases from the terminal").version(pkg.version);
+program.option("--verbose", "show API requests/responses").option("--color", "force color output").option("--json", "force JSON output (overrides TTY detection)").option("--md", "force markdown output for page content");
+program.configureOutput({
+  writeOut: (str) => process.stdout.write(str),
+  writeErr: (str) => process.stderr.write(str),
+  outputError: (str, write) => {
+    write(str);
+  }
+});
+program.hook("preAction", (thisCommand) => {
+  const opts = thisCommand.opts();
+  if (opts.color) {
+    setColorForced(true);
+  }
+  if (opts.json) {
+    setOutputMode("json");
+  } else if (opts.md) {
+    setOutputMode("md");
+  }
+});
+program.addCommand(initCommand());
+var profileCmd = new Command14("profile").description("manage authentication profiles");
+profileCmd.addCommand(profileListCommand());
+profileCmd.addCommand(profileUseCommand());
+profileCmd.addCommand(profileRemoveCommand());
+program.addCommand(profileCmd);
+program.addCommand(searchCommand());
+program.addCommand(lsCommand());
+program.addCommand(openCommand());
+program.addCommand(usersCommand());
+program.addCommand(commentsCommand());
+program.addCommand(readCommand());
+var dbCmd = new Command14("db").description("Database operations");
+dbCmd.addCommand(dbSchemaCommand());
+dbCmd.addCommand(dbQueryCommand());
+program.addCommand(dbCmd);
+program.addCommand(completionCommand());
+await program.parseAsync();
+//# sourceMappingURL=cli.js.map