@jordancoin/notioncli 1.2.1 → 1.3.1

package/lib/markdown.js

@@ -0,0 +1,488 @@
+// lib/markdown.js — Markdown/CSV parsing and conversion
+
+const { richTextToPlain } = require('./format');
+
+/**
+ * Parse markdown text into Notion block objects.
+ * Handles: headings, paragraphs, bullet lists, numbered lists, code blocks, quotes, dividers.
+ */
+function markdownToBlocks(md) {
+  const lines = md.split('\n');
+  const blocks = [];
+  const listStack = [];
+  let i = 0;
+
+  while (i < lines.length) {
+    const line = lines[i];
+
+    // Code block (fenced)
+    if (line.startsWith('```')) {
+      const lang = line.slice(3).trim() || 'plain text';
+      const codeLines = [];
+      i++;
+      while (i < lines.length && !lines[i].startsWith('```')) {
+        codeLines.push(lines[i]);
+        i++;
+      }
+      i++; // skip closing ```
+      blocks.push({
+        object: 'block',
+        type: 'code',
+        code: {
+          rich_text: [{ type: 'text', text: { content: codeLines.join('\n') } }],
+          language: lang,
+        },
+      });
+      listStack.length = 0;
+      continue;
+    }
+
+    // Todo/checkbox (must check BEFORE bullet list since both start with -)
+    if (line.startsWith('- [ ] ') || line.startsWith('- [x] ')) {
+      const checked = line.startsWith('- [x] ');
+      blocks.push({
+        object: 'block', type: 'to_do',
+        to_do: {
+          rich_text: parseInlineFormatting(line.slice(6)),
+          checked,
+        },
+      });
+      i++;
+      listStack.length = 0;
+      continue;
+    }
+
+    const bulletMatch = line.match(/^(\s*)([-*])\s+(.*)$/);
+    if (bulletMatch) {
+      const indent = bulletMatch[1].length;
+      const level = Math.floor(indent / 2);
+      const content = bulletMatch[3];
+      const itemBlock = {
+        object: 'block', type: 'bulleted_list_item',
+        bulleted_list_item: { rich_text: parseInlineFormatting(content) },
+      };
+
+      if (level <= 0) {
+        blocks.push(itemBlock);
+        listStack.length = 0;
+        listStack.push({ level: 0, block: itemBlock });
+      } else {
+        while (listStack.length && listStack[listStack.length - 1].level >= level) {
+          listStack.pop();
+        }
+        const parent = listStack[listStack.length - 1];
+        if (parent) {
+          if (!parent.block.bulleted_list_item.children) {
+            parent.block.bulleted_list_item.children = [];
+          }
+          parent.block.bulleted_list_item.children.push(itemBlock);
+        } else {
+          blocks.push(itemBlock);
+        }
+        listStack.push({ level, block: itemBlock });
+      }
+      i++;
+      continue;
+    }
+
+    listStack.length = 0;
+
+    // Divider
+    if (/^---+\s*$/.test(line) || /^\*\*\*+\s*$/.test(line)) {
+      blocks.push({ object: 'block', type: 'divider', divider: {} });
+      listStack.length = 0;
+      i++;
+      continue;
+    }
+
+    // Headings
+    if (line.startsWith('### ')) {
+      blocks.push({
+        object: 'block', type: 'heading_3',
+        heading_3: { rich_text: parseInlineFormatting(line.slice(4)) },
+      });
+      listStack.length = 0;
+      i++;
+      continue;
+    }
+    if (line.startsWith('## ')) {
+      blocks.push({
+        object: 'block', type: 'heading_2',
+        heading_2: { rich_text: parseInlineFormatting(line.slice(3)) },
+      });
+      listStack.length = 0;
+      i++;
+      continue;
+    }
+    if (line.startsWith('# ')) {
+      blocks.push({
+        object: 'block', type: 'heading_1',
+        heading_1: { rich_text: parseInlineFormatting(line.slice(2)) },
+      });
+      listStack.length = 0;
+      i++;
+      continue;
+    }
+
+    // Quote
+    if (line.startsWith('> ')) {
+      blocks.push({
+        object: 'block', type: 'quote',
+        quote: { rich_text: parseInlineFormatting(line.slice(2)) },
+      });
+      listStack.length = 0;
+      i++;
+      continue;
+    }
+
+    // Numbered list
+    if (/^\d+\.\s/.test(line)) {
+      blocks.push({
+        object: 'block', type: 'numbered_list_item',
+        numbered_list_item: { rich_text: parseInlineFormatting(line.replace(/^\d+\.\s/, '')) },
+      });
+      listStack.length = 0;
+      i++;
+      continue;
+    }
+
+    // Empty line — skip
+    if (line.trim() === '') {
+      listStack.length = 0;
+      i++;
+      continue;
+    }
+
+    // Default: paragraph
+    blocks.push({
+      object: 'block', type: 'paragraph',
+      paragraph: { rich_text: parseInlineFormatting(line) },
+    });
+    listStack.length = 0;
+    i++;
+  }
+
+  return blocks;
+}
+
+/**
+ * Parse inline markdown formatting (bold, italic, code, links) into rich_text array.
+ */
+function parseInlineFormatting(text) {
+  const segments = [];
+  // Simple regex-based parser for **bold**, *italic*, `code`, [text](url)
+  const regex = /(\*\*(.+?)\*\*|\*(.+?)\*|`(.+?)`|\[(.+?)\]\((.+?)\))/g;
+  let lastIdx = 0;
+  let match;
+
+  while ((match = regex.exec(text)) !== null) {
+    // Add plain text before match
+    if (match.index > lastIdx) {
+      segments.push({ type: 'text', text: { content: text.slice(lastIdx, match.index) } });
+    }
+
+    if (match[2]) {
+      // **bold**
+      segments.push({ type: 'text', text: { content: match[2] }, annotations: { bold: true } });
+    } else if (match[3]) {
+      // *italic*
+      segments.push({ type: 'text', text: { content: match[3] }, annotations: { italic: true } });
+    } else if (match[4]) {
+      // `code`
+      segments.push({ type: 'text', text: { content: match[4] }, annotations: { code: true } });
+    } else if (match[5] && match[6]) {
+      // [text](url)
+      segments.push({ type: 'text', text: { content: match[5], link: { url: match[6] } } });
+    }
+
+    lastIdx = match.index + match[0].length;
+  }
+
+  // Add remaining plain text
+  if (lastIdx < text.length) {
+    segments.push({ type: 'text', text: { content: text.slice(lastIdx) } });
+  }
+
+  // If no formatting found, return simple text
+  if (segments.length === 0) {
+    return [{ type: 'text', text: { content: text } }];
+  }
+
+  return segments;
+}
+
+/**
+ * Convert Notion rich_text array into markdown with annotations.
+ */
+function richTextToMarkdown(richText) {
+  if (!Array.isArray(richText)) return '';
+  return richText.map((item) => {
+    const plainText = item.plain_text ?? item.text?.content ?? '';
+    const linkUrl = item.text?.link?.url;
+    const annotations = item.annotations || {};
+    let formatted = plainText;
+
+    if (annotations.code) {
+      formatted = `\`${plainText}\``;
+    } else {
+      if (annotations.bold) formatted = `**${formatted}**`;
+      if (annotations.italic) formatted = `*${formatted}*`;
+      if (annotations.strikethrough) formatted = `~~${formatted}~~`;
+    }
+
+    if (linkUrl) {
+      formatted = `[${formatted}](${linkUrl})`;
+    }
+
+    return formatted;
+  }).join('');
+}
+
+/**
+ * Parse Notion blocks into markdown text.
+ */
+function blocksToMarkdown(blocks) {
+  const lines = [];
+  for (const block of blocks) {
+    const type = block.type;
+    switch (type) {
+      case 'heading_1':
+        lines.push(`# ${richTextToMarkdown(block.heading_1?.rich_text)}`);
+        break;
+      case 'heading_2':
+        lines.push(`## ${richTextToMarkdown(block.heading_2?.rich_text)}`);
+        break;
+      case 'heading_3':
+        lines.push(`### ${richTextToMarkdown(block.heading_3?.rich_text)}`);
+        break;
+      case 'paragraph':
+        lines.push(richTextToMarkdown(block.paragraph?.rich_text));
+        break;
+      case 'bulleted_list_item':
+        lines.push(`- ${richTextToMarkdown(block.bulleted_list_item?.rich_text)}`);
+        break;
+      case 'numbered_list_item':
+        lines.push(`1. ${richTextToMarkdown(block.numbered_list_item?.rich_text)}`);
+        break;
+      case 'to_do': {
+        const check = block.to_do?.checked ? 'x' : ' ';
+        lines.push(`- [${check}] ${richTextToMarkdown(block.to_do?.rich_text)}`);
+        break;
+      }
+      case 'quote':
+        lines.push(`> ${richTextToMarkdown(block.quote?.rich_text)}`);
+        break;
+      case 'code':
+        lines.push(`\`\`\`${block.code?.language || ''}`);
+        lines.push(richTextToPlain(block.code?.rich_text));
+        lines.push('```');
+        break;
+      case 'divider':
+        lines.push('---');
+        break;
+      default:
+        // Attempt generic rich_text extraction
+        if (block[type]?.rich_text) {
+          lines.push(richTextToMarkdown(block[type].rich_text));
+        }
+        break;
+    }
+  }
+  return lines.join('\n');
+}
+
+/**
+ * Parse CSV text into array of objects (rows).
+ * First line is headers.
+ */
+function parseCsv(text) {
+  const lines = [];
+  let current = '';
+  let inQuotes = false;
+
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === '"') {
+      if (inQuotes && text[i + 1] === '"') {
+        current += '""';
+        i++;
+        continue;
+      }
+      inQuotes = !inQuotes;
+      current += ch;
+      continue;
+    }
+
+    if (ch === '\r' && text[i + 1] === '\n') {
+      if (inQuotes) {
+        current += '\n';
+      } else if (current.trim()) {
+        lines.push(current);
+      }
+      current = '';
+      i++;
+      continue;
+    }
+
+    if (ch === '\n') {
+      if (inQuotes) {
+        current += '\n';
+      } else if (current.trim()) {
+        lines.push(current);
+        current = '';
+      } else {
+        current = '';
+      }
+      continue;
+    }
+
+    current += ch;
+  }
+
+  if (current.trim()) {
+    lines.push(current);
+  }
+  if (lines.length < 2) return [];
+
+  const headers = parseCsvLine(lines[0]);
+  const rows = [];
+  for (let i = 1; i < lines.length; i++) {
+    const values = parseCsvLine(lines[i]);
+    const row = {};
+    for (let j = 0; j < headers.length; j++) {
+      row[headers[j]] = values[j] || '';
+    }
+    rows.push(row);
+  }
+  return rows;
+}
+
+/** Parse a single CSV line, handling quoted fields */
+function parseCsvLine(line) {
+  const fields = [];
+  let current = '';
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (inQuotes) {
+      if (ch === '"' && line[i + 1] === '"') {
+        current += '"';
+        i++;
+      } else if (ch === '"') {
+        inQuotes = false;
+      } else {
+        current += ch;
+      }
+    } else {
+      if (ch === '"') {
+        inQuotes = true;
+      } else if (ch === ',') {
+        fields.push(current);
+        current = '';
+      } else {
+        current += ch;
+      }
+    }
+  }
+  fields.push(current);
+  return fields;
+}
+
+/**
+ * Convert kebab-case flag name to a schema property match.
+ * --due-date → "Due Date", --name → "Name", --status → "Status"
+ */
+function kebabToProperty(kebab, schema) {
+  // Remove leading dashes
+  const clean = kebab.replace(/^-+/, '');
+
+  // Try exact lowercase match first
+  if (schema[clean.toLowerCase()]) {
+    return schema[clean.toLowerCase()];
+  }
+
+  // Try kebab → space conversion: "due-date" → "due date"
+  const spaced = clean.replace(/-/g, ' ');
+  if (schema[spaced.toLowerCase()]) {
+    return schema[spaced.toLowerCase()];
+  }
+
+  // Try kebab → title case: "due-date" → "Due Date"
+  const titled = clean.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+  if (schema[titled.toLowerCase()]) {
+    return schema[titled.toLowerCase()];
+  }
+
+  return null;
+}
+
+/**
+ * Extract dynamic property flags from raw argv.
+ * Returns array of "Key=Value" strings compatible with buildProperties.
+ */
+function extractDynamicProps(argv, knownFlags, schema) {
+  const props = [];
+  const known = new Set(knownFlags);
+  const isKnownFlagName = (flagName) => known.has(flagName) || known.has(`--${flagName}`);
+  const isKnownFlagToken = (token) => {
+    if (!token.startsWith('--') || token === '--') return false;
+    const eqIdx = token.indexOf('=');
+    const tokenName = eqIdx === -1 ? token.slice(2) : token.slice(2, eqIdx);
+    return isKnownFlagName(tokenName) || !!kebabToProperty(tokenName, schema);
+  };
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith('--') || arg === '--') continue;
+
+    const eqIdx = arg.indexOf('=');
+    const flagName = eqIdx === -1 ? arg.slice(2) : arg.slice(2, eqIdx);
+    const explicitValue = eqIdx === -1 ? null : arg.slice(eqIdx + 1);
+
+    // Skip known commander flags
+    if (isKnownFlagName(flagName) || known.has(arg)) continue;
+
+    // Try to match against schema
+    const schemaEntry = kebabToProperty(flagName, schema);
+    if (!schemaEntry) continue;
+
+    if (schemaEntry.type === 'checkbox') {
+      const value = explicitValue !== null ? explicitValue : 'true';
+      props.push(`${schemaEntry.name}=${value}`);
+      continue;
+    }
+
+    if (explicitValue !== null) {
+      props.push(`${schemaEntry.name}=${explicitValue}`);
+      continue;
+    }
+
+    if (i + 1 >= argv.length) continue;
+
+    const valueCandidate = argv[i + 1];
+    if (!valueCandidate.startsWith('--') || valueCandidate === '--') {
+      props.push(`${schemaEntry.name}=${valueCandidate}`);
+      i++; // skip value
+      continue;
+    }
+
+    const isLastArg = i + 1 === argv.length - 1;
+    if (isLastArg || !isKnownFlagToken(valueCandidate)) {
+      props.push(`${schemaEntry.name}=${valueCandidate}`);
+      i++; // skip value
+    }
+  }
+
+  return props;
+}
+
+module.exports = {
+  markdownToBlocks,
+  parseInlineFormatting,
+  richTextToMarkdown,
+  blocksToMarkdown,
+  parseCsv,
+  parseCsvLine,
+  kebabToProperty,
+  extractDynamicProps,
+};

package/lib/paginate.js

@@ -0,0 +1,74 @@
+// lib/paginate.js — Generic Notion pagination helper
+
+/**
+ * Paginate Notion list/query/search endpoints that return { results, has_more, next_cursor }.
+ * fetchPage({ start_cursor, page_size }) should return the raw API response.
+ */
+async function paginate(fetchPage, options = {}) {
+  const limit = options.limit == null ? null : Number(options.limit);
+  const pageSizeLimit = options.pageSizeLimit || 100;
+
+  if (limit != null && (!Number.isFinite(limit) || limit < 0)) {
+    throw new Error(`Invalid limit: ${options.limit}`);
+  }
+
+  const results = [];
+  let cursor = undefined;
+  let hasMore = true;
+  let truncated = false;
+  let responseBase = null;
+
+  while (hasMore) {
+    const remaining = limit == null ? null : limit - results.length;
+    if (remaining != null && remaining <= 0) {
+      truncated = true;
+      break;
+    }
+
+    const pageSize = remaining == null ? pageSizeLimit : Math.min(pageSizeLimit, remaining);
+    const res = await fetchPage({ start_cursor: cursor, page_size: pageSize });
+    if (!responseBase) responseBase = res;
+
+    const pageResults = res.results || [];
+    if (limit != null && pageResults.length > 0) {
+      const remaining = limit - results.length;
+      if (remaining <= 0) {
+        truncated = true;
+        break;
+      }
+      if (pageResults.length > remaining) {
+        results.push(...pageResults.slice(0, remaining));
+        truncated = true;
+        cursor = res.next_cursor || null;
+        break;
+      }
+    }
+    results.push(...pageResults);
+
+    hasMore = Boolean(res.has_more);
+    cursor = res.next_cursor || null;
+
+    if (limit != null && results.length >= limit && hasMore) {
+      truncated = true;
+      break;
+    }
+  }
+
+  const finalHasMore = truncated ? true : false;
+  const finalCursor = truncated ? cursor : null;
+  const response = responseBase
+    ? { ...responseBase, results, has_more: finalHasMore, next_cursor: finalCursor }
+    : { object: 'list', results, has_more: finalHasMore, next_cursor: finalCursor };
+
+  return {
+    results,
+    has_more: finalHasMore,
+    next_cursor: finalCursor,
+    truncated,
+    response,
+  };
+}
+
+module.exports = {
+  paginate,
+};

package/lib/retry.js

@@ -0,0 +1,76 @@
+// lib/retry.js — Retry helpers for Notion API calls
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function isRateLimitError(err) {
+  if (!err || typeof err !== 'object') return false;
+  return err.status === 429 || err.code === 'rate_limited';
+}
+
+function isNotionApiError(err) {
+  if (!err || typeof err !== 'object') return false;
+  if (err.name === 'APIResponseError') return true;
+  return typeof err.status === 'number' && err.body && typeof err.body === 'object';
+}
+
+function getNotionApiErrorDetails(err) {
+  if (!isNotionApiError(err)) return null;
+  const details = {
+    status: err.status,
+    code: err.code,
+    body: err.body,
+  };
+  if (err.message && (!err.body || err.body.message !== err.message)) {
+    details.message = err.message;
+  }
+  return details;
+}
+
+function calculateDelayMs(baseDelayMs, attempt, jitter, randomFn) {
+  const delayMs = baseDelayMs * (2 ** (attempt - 1));
+  if (!jitter) return delayMs;
+  const rand = typeof randomFn === 'function' ? randomFn() : Math.random();
+  const jittered = delayMs * (0.5 + rand);
+  return Math.max(0, Math.floor(jittered));
+}
+
+async function withRetry(fn, options = {}) {
+  const {
+    maxAttempts = 3,
+    baseDelayMs = 1000,
+    jitter = true,
+    random = Math.random,
+    sleep: sleepFn = sleep,
+    onRetry,
+  } = options;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    try {
+      return await fn();
+    } catch (err) {
+      if (!isRateLimitError(err) || attempt === maxAttempts) {
+        throw err;
+      }
+      const delayMs = calculateDelayMs(baseDelayMs, attempt, jitter, random);
+      if (typeof onRetry === 'function') {
+        onRetry({ attempt, maxAttempts, delayMs, error: err });
+      } else {
+        const delaySec = Math.max(0.1, Math.round(delayMs / 100) / 10);
+        console.error(`Rate limited, retrying in ${delaySec}s...`);
+      }
+      await sleepFn(delayMs);
+    }
+  }
+
+  return undefined;
+}
+
+module.exports = {
+  isRateLimitError,
+  isNotionApiError,
+  getNotionApiErrorDetails,
+  withRetry,
+  calculateDelayMs,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jordancoin/notioncli",
-  "version": "1.2.1",
+  "version": "1.3.1",
   "description": "A powerful CLI for the Notion API — query databases, manage pages, and automate your workspace from the terminal.",
   "main": "bin/notion.js",
   "bin": {