neotoma 0.3.0 → 0.3.2

package/src/utils/property_keys.test.ts

@@ -1,109 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { humanizePropertyKey, humanizePropertyKeys } from "./property_keys.js";
-
-describe("humanizePropertyKey", () => {
-  it("converts snake_case to human-readable", () => {
-    expect(humanizePropertyKey("full_name")).toBe("Full Name");
-    expect(humanizePropertyKey("user_id")).toBe("User Id");
-    expect(humanizePropertyKey("created_at")).toBe("Created At");
-  });
-
-  it("converts camelCase to human-readable", () => {
-    expect(humanizePropertyKey("fullName")).toBe("Full Name");
-    expect(humanizePropertyKey("userId")).toBe("User Id");
-    expect(humanizePropertyKey("createdAt")).toBe("Created At");
-  });
-
-  it("converts kebab-case to human-readable", () => {
-    expect(humanizePropertyKey("full-name")).toBe("Full Name");
-    expect(humanizePropertyKey("user-id")).toBe("User Id");
-  });
-
-  it("preserves already humanized keys", () => {
-    expect(humanizePropertyKey("Full Name")).toBe("Full Name");
-    expect(humanizePropertyKey("User Id")).toBe("User Id");
-  });
-
-  it("handles single words", () => {
-    expect(humanizePropertyKey("name")).toBe("Name");
-    expect(humanizePropertyKey("id")).toBe("Id");
-  });
-
-  it("handles empty or invalid input", () => {
-    expect(humanizePropertyKey("")).toBe("");
-    expect(humanizePropertyKey(null as any)).toBe(null);
-    expect(humanizePropertyKey(undefined as any)).toBe(undefined);
-  });
-});
-
-describe("humanizePropertyKeys", () => {
-  it("humanizes all property keys in an object", () => {
-    const input = {
-      full_name: "John Doe",
-      user_id: "123",
-      created_at: "2024-01-01",
-    };
-    const result = humanizePropertyKeys(input);
-    expect(result).toEqual({
-      "Full Name": "John Doe",
-      "User Id": "123",
-      "Created At": "2024-01-01",
-    });
-  });
-
-  it("handles mixed case formats", () => {
-    const input = {
-      full_name: "John",
-      fullName: "Jane",
-      "full-name": "Bob",
-    };
-    const result = humanizePropertyKeys(input);
-    // All three humanize to "Full Name", but collision handling keeps original keys
-    expect(result["Full Name"]).toBe("John"); // First one processed
-    expect(result["fullName"]).toBe("Jane"); // Collision, kept original
-    expect(result["full-name"]).toBe("Bob"); // Collision, kept original
-  });
-
-  it("preserves nested objects and arrays", () => {
-    const input = {
-      user_name: "John",
-      metadata: {
-        nested_key: "value",
-      },
-      tags: ["tag1", "tag2"],
-    };
-    const result = humanizePropertyKeys(input);
-    expect(result).toEqual({
-      "User Name": "John",
-      Metadata: {
-        nested_key: "value", // Nested objects are not humanized
-      },
-      Tags: ["tag1", "tag2"], // Arrays are preserved
-    });
-  });
-
-  it("handles collisions by keeping original key", () => {
-    const input = {
-      "Full Name": "John",
-      full_name: "Jane", // Collision with humanized version
-    };
-    const result = humanizePropertyKeys(input);
-    // The collision should result in keeping the original key
-    expect(result["Full Name"]).toBe("John");
-    expect(result["full_name"]).toBe("Jane");
-  });
-
-  it("handles empty objects", () => {
-    expect(humanizePropertyKeys({})).toEqual({});
-  });
-
-  it("handles null and undefined", () => {
-    expect(humanizePropertyKeys(null as any)).toBe(null);
-    expect(humanizePropertyKeys(undefined as any)).toBe(undefined);
-  });
-
-  it("handles arrays (returns as-is)", () => {
-    const input = ["item1", "item2"];
-    expect(humanizePropertyKeys(input as any)).toBe(input);
-  });
-});

package/src/utils/property_keys.ts

@@ -1,66 +0,0 @@
-/**
- * Humanizes property keys by converting snake_case, camelCase, or kebab-case
- * to a human-readable format (e.g., "full_name" -> "Full Name").
- */
-export function humanizePropertyKey(key: string): string {
-  if (!key || typeof key !== "string") {
-    return key;
-  }
-
-  // Handle already humanized keys (contains spaces and capital letters)
-  if (/^[A-Z][a-z]+(\s+[A-Z][a-z]+)*$/.test(key)) {
-    return key;
-  }
-
-  // Split on underscores, hyphens, or camelCase boundaries
-  const parts = key
-    .replace(/([a-z])([A-Z])/g, "$1 $2") // camelCase -> camel Case
-    .replace(/[_-]+/g, " ") // underscores/hyphens -> spaces
-    .split(/\s+/)
-    .filter(Boolean);
-
-  // Capitalize first letter of each word
-  return parts
-    .map((part) => {
-      if (!part) return "";
-      return part.charAt(0).toUpperCase() + part.slice(1).toLowerCase();
-    })
-    .join(" ");
-}
-
-/**
- * Humanizes all property keys in a record's properties object.
- * Preserves nested objects and arrays, only transforming top-level keys.
- */
-export function humanizePropertyKeys(
-  properties: Record<string, unknown>,
-): Record<string, unknown> {
-  if (
-    !properties ||
-    typeof properties !== "object" ||
-    Array.isArray(properties)
-  ) {
-    return properties;
-  }
-
-  const result: Record<string, unknown> = {};
-  const seenHumanized = new Map<string, string>();
-
-  for (const [key, value] of Object.entries(properties)) {
-    const humanized = humanizePropertyKey(key);
-
-    // Handle collisions: if humanized key already exists, append original key
-    if (
-      result[humanized] !== undefined &&
-      seenHumanized.get(humanized) !== key
-    ) {
-      // Collision detected - keep original key to avoid data loss
-      result[key] = value;
-    } else {
-      result[humanized] = value;
-      seenHumanized.set(humanized, key);
-    }
-  }
-
-  return result;
-}

package/src/utils/property_sanitizer.test.ts

@@ -1,105 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { sanitizePropertyValue, sanitizeRecordProperties } from "./property_sanitizer.js";
-
-describe("sanitizePropertyValue", () => {
-  it("removes trailing Notion URLs in parentheses", () => {
-    const input =
-      "Abdominal roller (https://www.notion.so/Abdominal-roller-23d6ea88f52880c1b574ed1bbbf022c4?pvs=21)";
-    expect(sanitizePropertyValue(input)).toBe("Abdominal roller");
-  });
-
-  it("removes markdown-style Notion links", () => {
-    const input = "[Exercise name](https://notion.so/Some-Page-abc123)";
-    expect(sanitizePropertyValue(input)).toBe("Exercise name");
-  });
-
-  it("preserves non-string primitives", () => {
-    expect(sanitizePropertyValue(42)).toBe(42);
-    expect(sanitizePropertyValue(true)).toBe(true);
-    expect(sanitizePropertyValue(false)).toBe(false);
-    expect(sanitizePropertyValue(null)).toBe(null);
-  });
-
-  it("normalizes whitespace and removes quotes", () => {
-    expect(sanitizePropertyValue("  multiple   spaces  ")).toBe("multiple spaces");
-    expect(sanitizePropertyValue('"quoted"')).toBe("quoted");
-  });
-
-  it("returns undefined for empty strings after cleaning", () => {
-    expect(sanitizePropertyValue("")).toBeUndefined();
-    expect(sanitizePropertyValue("(https://notion.so/page)")).toBeUndefined();
-  });
-
-  it("leaves non-Notion URLs untouched", () => {
-    const input = "Link (https://example.com/page)";
-    expect(sanitizePropertyValue(input)).toBe("Link (https://example.com/page)");
-  });
-});
-
-describe("sanitizeRecordProperties", () => {
-  it("sanitizes primitives and stores removed urls", () => {
-    const input = {
-      exercise: "Abdominal roller (https://notion.so/page-123)",
-      date: "2025-07-26",
-    };
-    expect(sanitizeRecordProperties(input)).toEqual({
-      exercise: "Abdominal roller",
-      exercise_url: "https://notion.so/page-123",
-      date: "2025-07-26",
-    });
-  });
-
-  it("handles markdown links with url fields", () =>
-    expect(
-      sanitizeRecordProperties({
-        summary: "[Notebook entry](https://notion.so/entry-1)",
-      })
-    ).toEqual({
-      summary: "Notebook entry",
-      summary_url: "https://notion.so/entry-1",
-    }));
-
-  it("handles nested objects", () => {
-    const result = sanitizeRecordProperties({
-      metadata: {
-        source: "Notion (https://notion.so/source)",
-      },
-    });
-    expect(result).toEqual({
-      metadata: {
-        source: "Notion",
-        source_url: "https://notion.so/source",
-      },
-    });
-  });
-
-  it("handles arrays and aggregates urls", () => {
-    const result = sanitizeRecordProperties({
-      tags: ["tag1 (https://notion.so/tag1)", "tag2", "tag3 (https://notion.so/tag3)"],
-    });
-    expect(result).toEqual({
-      tags: ["tag1", "tag2", "tag3"],
-      tags_urls: ["https://notion.so/tag1", "https://notion.so/tag3"],
-    });
-  });
-
-  it("drops empty strings but keeps url references", () => {
-    const result = sanitizeRecordProperties({
-      notionUrl: "(https://notion.so/only-url)",
-    });
-    expect(result).toEqual({
-      notionUrl_url: "https://notion.so/only-url",
-    });
-  });
-
-  it("preserves Date objects", () => {
-    const date = new Date("2025-07-26");
-    const result = sanitizeRecordProperties({
-      created: date,
-      name: "Record (https://notion.so/record)",
-    });
-    expect(result.created).toBe(date);
-    expect(result.name).toBe("Record");
-    expect(result.name_url).toBe("https://notion.so/record");
-  });
-});

package/src/utils/property_sanitizer.ts

@@ -1,135 +0,0 @@
-/**
- * Sanitizes record property values to improve readability while preserving removed URLs.
- */
-
-type Primitive = string | number | boolean | null | undefined;
-
-interface SanitizedPrimitiveResult {
-  value: Primitive | undefined;
-  removedUrls: string[];
-}
-
-function sanitizePrimitive(value: Primitive): SanitizedPrimitiveResult {
-  if (value === null || value === undefined) {
-    return { value, removedUrls: [] };
-  }
-
-  if (typeof value !== "string") {
-    return { value, removedUrls: [] };
-  }
-
-  let cleaned = value.trim();
-  const removedUrls: string[] = [];
-
-  cleaned = cleaned.replace(
-    /\[([^\]]+)\]\((https?:\/\/(?:www\.)?notion\.so\/[^\s)]+)\)/gi,
-    (_, label: string, url: string) => {
-      removedUrls.push(url);
-      return label;
-    },
-  );
-
-  cleaned = cleaned.replace(
-    /\s*\((https?:\/\/(?:www\.)?notion\.so\/[^\s)]+)\)\s*/gi,
-    (_, url: string) => {
-      removedUrls.push(url);
-      return " ";
-    },
-  );
-
-  cleaned = cleaned.replace(/\s+/g, " ").trim();
-
-  if (
-    (cleaned.startsWith('"') && cleaned.endsWith('"')) ||
-    (cleaned.startsWith("'") && cleaned.endsWith("'"))
-  ) {
-    cleaned = cleaned.slice(1, -1).trim();
-  }
-
-  if (!cleaned.length) {
-    return { value: undefined, removedUrls };
-  }
-
-  return { value: cleaned, removedUrls };
-}
-
-export function sanitizePropertyValue(value: Primitive): Primitive {
-  return sanitizePrimitive(value).value;
-}
-
-function mergeUrlValue(
-  target: Record<string, unknown>,
-  key: string,
-  urls: string[],
-  plural: boolean,
-): void {
-  if (!urls.length) return;
-  const needsPlural = plural || urls.length > 1;
-  const urlKey = `${key}${needsPlural ? "_urls" : "_url"}`;
-  const incoming: unknown = needsPlural ? urls : urls[0];
-
-  if (target[urlKey] === undefined) {
-    target[urlKey] = incoming;
-    return;
-  }
-
-  const ensureArray = (input: unknown): string[] =>
-    Array.isArray(input) ? input : [input as string];
-  const merged = new Set<string>(ensureArray(target[urlKey]));
-  ensureArray(incoming).forEach((url) => merged.add(url));
-  target[urlKey] = Array.from(merged);
-}
-
-export function sanitizeRecordProperties(
-  properties: Record<string, unknown>,
-): Record<string, unknown> {
-  const sanitized: Record<string, unknown> = {};
-
-  for (const [key, value] of Object.entries(properties)) {
-    if (Array.isArray(value)) {
-      const sanitizedItems: unknown[] = [];
-      const collectedUrls: string[] = [];
-
-      value.forEach((item) => {
-        if (typeof item === "string") {
-          const result = sanitizePrimitive(item);
-          if (result.value !== undefined) {
-            sanitizedItems.push(result.value);
-          }
-          collectedUrls.push(...result.removedUrls);
-        } else if (Array.isArray(item)) {
-          sanitizedItems.push(item);
-        } else if (
-          typeof item === "object" &&
-          item !== null &&
-          !(item instanceof Date)
-        ) {
-          sanitizedItems.push(
-            sanitizeRecordProperties(item as Record<string, unknown>),
-          );
-        } else if (item !== undefined) {
-          sanitizedItems.push(item);
-        }
-      });
-
-      sanitized[key] = sanitizedItems;
-      mergeUrlValue(sanitized, key, collectedUrls, true);
-    } else if (
-      typeof value === "object" &&
-      value !== null &&
-      !(value instanceof Date)
-    ) {
-      sanitized[key] = sanitizeRecordProperties(
-        value as Record<string, unknown>,
-      );
-    } else {
-      const result = sanitizePrimitive(value as Primitive);
-      if (result.value !== undefined) {
-        sanitized[key] = result.value;
-      }
-      mergeUrlValue(sanitized, key, result.removedUrls, false);
-    }
-  }
-
-  return sanitized;
-}

package/src/version_check.test.ts

@@ -1,107 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import {
-  isUpdateAvailable,
-  formatUpgradeCommand,
-  getLatestFromRegistry,
-} from "./version_check.js";
-
-describe("isUpdateAvailable", () => {
-  it("returns true when current is less than latest", () => {
-    expect(isUpdateAvailable("0.2.15", "0.2.16")).toBe(true);
-    expect(isUpdateAvailable("1.0.0", "2.0.0")).toBe(true);
-    expect(isUpdateAvailable("0.2.15", "1.0.0")).toBe(true);
-  });
-
-  it("returns false when current equals latest", () => {
-    expect(isUpdateAvailable("0.2.15", "0.2.15")).toBe(false);
-  });
-
-  it("returns false when current is greater than latest", () => {
-    expect(isUpdateAvailable("0.2.16", "0.2.15")).toBe(false);
-    expect(isUpdateAvailable("1.0.0", "0.2.16")).toBe(false);
-  });
-
-  it("returns false for invalid current version", () => {
-    expect(isUpdateAvailable("not-a-version", "1.0.0")).toBe(false);
-    expect(isUpdateAvailable("", "1.0.0")).toBe(false);
-  });
-
-  it("returns false for invalid latest version", () => {
-    expect(isUpdateAvailable("1.0.0", "not-a-version")).toBe(false);
-    expect(isUpdateAvailable("1.0.0", "")).toBe(false);
-  });
-});
-
-describe("formatUpgradeCommand", () => {
-  it("returns global npm install for context global", () => {
-    expect(formatUpgradeCommand("neotoma", "latest", "global")).toBe(
-      "npm i -g neotoma@latest"
-    );
-    expect(formatUpgradeCommand("some-pkg", "next", "global")).toBe(
-      "npm i -g some-pkg@next"
-    );
-  });
-
-  it("defaults to global when context omitted", () => {
-    expect(formatUpgradeCommand("neotoma", "latest")).toBe(
-      "npm i -g neotoma@latest"
-    );
-  });
-
-  it("returns npx hint for context npx", () => {
-    expect(formatUpgradeCommand("neotoma", "latest", "npx")).toBe(
-      "npx neotoma@latest"
-    );
-    expect(formatUpgradeCommand("some-pkg", "next", "npx")).toBe(
-      "npx some-pkg@next"
-    );
-  });
-});
-
-describe("getLatestFromRegistry", () => {
-  const originalFetch = globalThis.fetch;
-
-  beforeEach(() => {
-    vi.stubGlobal(
-      "fetch",
-      vi.fn((url: string) => {
-        if (url.includes("/neotoma/")) {
-          return Promise.resolve({
-            ok: true,
-            json: () =>
-              Promise.resolve({ latest: "0.2.20", next: "0.3.0-beta.1" }),
-          } as Response);
-        }
-        if (url.includes("/nonexistent-pkg-xyz/")) {
-          return Promise.resolve({ ok: false } as Response);
-        }
-        return Promise.reject(new Error("network"));
-      })
-    );
-  });
-
-  afterEach(() => {
-    vi.stubGlobal("fetch", originalFetch);
-  });
-
-  it("returns latest version for existing package", async () => {
-    const latest = await getLatestFromRegistry("neotoma");
-    expect(latest).toBe("0.2.20");
-  });
-
-  it("returns requested dist-tag when specified", async () => {
-    const next = await getLatestFromRegistry("neotoma", "next");
-    expect(next).toBe("0.3.0-beta.1");
-  });
-
-  it("returns null when response is not ok", async () => {
-    const result = await getLatestFromRegistry("nonexistent-pkg-xyz");
-    expect(result).toBeNull();
-  });
-
-  it("returns null on fetch failure and does not throw", async () => {
-    vi.stubGlobal("fetch", () => Promise.reject(new Error("network")));
-    const result = await getLatestFromRegistry("neotoma");
-    expect(result).toBeNull();
-  });
-});

package/src/version_check.ts

@@ -1,58 +0,0 @@
-/**
- * Shared version check for CLI and MCP: query npm registry, compare semver,
- * format upgrade command. Never throws; returns null on registry failure.
- */
-
-import semver from "semver";
-
-const REGISTRY_DIST_TAGS = "https://registry.npmjs.org/-/package";
-
-/**
- * Fetch latest version for a package from npm registry (dist-tags).
- * On failure (network, non-2xx) returns null; never throws.
- */
-export async function getLatestFromRegistry(
-  packageName: string,
-  distTag: string = "latest"
-): Promise<string | null> {
-  try {
-    const url = `${REGISTRY_DIST_TAGS}/${encodeURIComponent(packageName)}/dist-tags`;
-    const res = await fetch(url, {
-      headers: { accept: "application/json" },
-      signal: AbortSignal.timeout(5000),
-    });
-    if (!res.ok) return null;
-    const data = (await res.json()) as Record<string, string>;
-    const version = data?.[distTag] ?? data?.latest ?? null;
-    return typeof version === "string" ? version : null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * True if current is a valid semver and is strictly less than latest.
- * Invalid versions yield false.
- */
-export function isUpdateAvailable(current: string, latest: string): boolean {
-  const c = semver.valid(current);
-  const l = semver.valid(latest);
-  if (!c || !l) return false;
-  return semver.lt(c, l);
-}
-
-/**
- * Format the upgrade command for display.
- * context 'global' => npm i -g <name>@<distTag>
- * context 'npx' => npx <name>@<distTag> ...
- */
-export function formatUpgradeCommand(
-  packageName: string,
-  distTag: string,
-  context: "global" | "npx" = "global"
-): string {
-  if (context === "npx") {
-    return `npx ${packageName}@${distTag}`;
-  }
-  return `npm i -g ${packageName}@${distTag}`;
-}