@happyvertical/utils 0.74.8

package/dist/shared/universal.d.ts

@@ -0,0 +1,400 @@
+import { createId as cuid2CreateId, isCuid } from '@paralleldrive/cuid2';
+import { add, isValid } from 'date-fns';
+import { default as pluralize } from 'pluralize';
+/**
+ * Generates a unique identifier using CUID2 (preferred) or UUID fallback
+ *
+ * CUID2 is more secure and collision-resistant than UUIDs, but UUID is provided
+ * as a fallback for RFC4122 compliance requirements.
+ *
+ * @param type - ID type: 'cuid2' (default) or 'uuid'
+ * @returns A unique identifier string
+ * @example
+ * ```typescript
+ * const id = makeId(); // CUID2: "ckx5f8h3z0000qzrmn831i7rn"
+ * const uuid = makeId('uuid'); // UUID: "f47ac10b-58cc-4372-a567-0e02b2c3d479"
+ * ```
+ */
+export declare const makeId: (type?: "cuid2" | "uuid") => string;
+/**
+ * Generates a CUID2 identifier (collision-resistant, more secure than UUID)
+ *
+ * CUID2 provides better entropy and security compared to UUID v4, making it
+ * ideal for distributed systems and user-facing identifiers.
+ *
+ * @returns A CUID2 identifier string
+ * @example
+ * ```typescript
+ * const id = createId(); // "ckx5f8h3z0000qzrmn831i7rn"
+ * ```
+ */
+export declare const createId: typeof cuid2CreateId;
+/**
+ * Checks if a string is a valid CUID2
+ */
+export { isCuid };
+/**
+ * Converts a string to a URL-friendly slug
+ *
+ * Handles international characters, removes special characters, and replaces
+ * spaces with hyphens. Ampersands are converted to "-38-" for uniqueness.
+ *
+ * @param str - The string to convert to a slug
+ * @returns A URL-friendly slug string
+ * @example
+ * ```typescript
+ * makeSlug("My Example Title & Co."); // "my-example-title-38-co"
+ * makeSlug("Café España"); // "cafe-espana"
+ * ```
+ */
+export declare const makeSlug: (str: string) => string;
+/**
+ * Extracts the filename from a URL's pathname
+ *
+ * Returns the last segment of the URL path. If no filename is found,
+ * defaults to 'index.html'.
+ *
+ * @param url - The URL to extract filename from
+ * @returns The filename from the URL
+ * @throws {TypeError} When URL is invalid
+ * @example
+ * ```typescript
+ * urlFilename("https://example.com/path/file.pdf"); // "file.pdf"
+ * urlFilename("https://example.com/path/"); // "index.html"
+ * ```
+ */
+export declare const urlFilename: (url: string) => string;
+/**
+ * Converts a URL to a file path by joining hostname and pathname
+ *
+ * Creates a file system compatible path from a URL by combining the hostname
+ * with the pathname segments, useful for creating local file structures.
+ *
+ * @param url - The URL to convert to a path
+ * @returns A file path string with hostname and path segments
+ * @throws {TypeError} When URL is invalid
+ * @example
+ * ```typescript
+ * urlPath("https://example.com/path/to/resource"); // "example.com/path/to/resource"
+ * ```
+ */
+export declare const urlPath: (url: string) => string;
+/**
+ * Creates a Promise that resolves after a specified duration
+ *
+ * Useful for adding delays in async functions or rate limiting operations.
+ *
+ * @param duration - Time to wait in milliseconds
+ * @returns Promise that resolves after the specified duration
+ * @example
+ * ```typescript
+ * await sleep(1000); // Wait 1 second
+ * console.log('1 second has passed');
+ * ```
+ */
+export declare const sleep: (duration: number) => Promise<void>;
+/**
+ * Repeatedly calls a function until it returns a defined value or times out
+ *
+ * Polls an async function at regular intervals until it returns a defined value
+ * or the timeout is reached. Useful for waiting for conditions to be met.
+ *
+ * @param it - Async function to poll
+ * @param options - Configuration options
+ * @param options.timeout - Maximum time to wait in milliseconds (0 = no timeout)
+ * @param options.delay - Time between polling attempts in milliseconds
+ * @returns Promise that resolves with the function result or rejects on timeout
+ * @throws {TimeoutError} When timeout is reached before function returns defined value
+ * @example
+ * ```typescript
+ * // Wait for a file to exist
+ * const fileExists = await waitFor(
+ *   async () => {
+ *     try {
+ *       await fs.access('/path/to/file');
+ *       return true;
+ *     } catch {
+ *       return undefined; // Keep polling
+ *     }
+ *   },
+ *   { timeout: 10000, delay: 500 }
+ * );
+ * ```
+ */
+export declare function waitFor(it: () => Promise<any>, { timeout, delay }?: {
+    timeout?: number;
+    delay?: number;
+}): Promise<any>;
+/**
+ * Type guard to check if a value is an array
+ *
+ * @param obj - Value to check
+ * @returns True if value is an array, with TypeScript type narrowing
+ * @example
+ * ```typescript
+ * if (isArray(data)) {
+ *   // TypeScript knows data is unknown[]
+ *   data.forEach(item => console.log(item));
+ * }
+ * ```
+ */
+export declare const isArray: (obj: unknown) => obj is unknown[];
+/**
+ * Type guard to check if a value is a plain object
+ *
+ * Checks for objects that are not null, arrays, or other non-plain object types.
+ *
+ * @param obj - Value to check
+ * @returns True if value is a plain object, with TypeScript type narrowing
+ * @example
+ * ```typescript
+ * if (isPlainObject(data)) {
+ *   // TypeScript knows data is Record<string, unknown>
+ *   Object.keys(data).forEach(key => console.log(key, data[key]));
+ * }
+ * ```
+ */
+export declare const isPlainObject: (obj: unknown) => obj is Record<string, unknown>;
+/**
+ * Checks if a string is a valid URL
+ *
+ * Uses the URL constructor to validate the string format. Returns false
+ * for any string that cannot be parsed as a valid URL.
+ *
+ * @param url - String to validate as URL
+ * @returns True if string is a valid URL
+ * @example
+ * ```typescript
+ * isUrl("https://example.com"); // true
+ * isUrl("not-a-url"); // false
+ * ```
+ */
+export declare const isUrl: (url: string) => boolean;
+/**
+ * Converts a string to camelCase
+ *
+ * Handles kebab-case, snake_case, and space-separated strings.
+ * Removes special characters and ensures proper camelCase formatting.
+ *
+ * @param str - String to convert
+ * @returns camelCase formatted string
+ * @example
+ * ```typescript
+ * camelCase("hello-world"); // "helloWorld"
+ * camelCase("snake_case_string"); // "snakeCaseString"
+ * camelCase("Some Title"); // "someTitle"
+ * ```
+ */
+export declare const camelCase: (str: string) => string;
+/**
+ * Converts a string to snake_case
+ *
+ * Handles camelCase, kebab-case, and space-separated strings.
+ * Converts to lowercase with underscore separators.
+ *
+ * @param str - String to convert
+ * @returns snake_case formatted string
+ * @example
+ * ```typescript
+ * snakeCase("helloWorld"); // "hello_world"
+ * snakeCase("kebab-case-string"); // "kebab_case_string"
+ * snakeCase("Some Title"); // "some_title"
+ * ```
+ */
+export declare const snakeCase: (str: string) => string;
+/**
+ * Recursively converts all object keys to camelCase
+ *
+ * Deeply traverses an object or array and converts all keys to camelCase.
+ * Preserves the structure and values, only transforming key names.
+ *
+ * @param obj - Object or array to transform
+ * @returns New object/array with camelCase keys
+ * @example
+ * ```typescript
+ * keysToCamel({
+ *   user_name: "john",
+ *   user_details: { first_name: "John" }
+ * }); // { userName: "john", userDetails: { firstName: "John" } }
+ * ```
+ */
+export declare const keysToCamel: (obj: unknown) => unknown;
+/**
+ * Recursively converts all object keys to snake_case
+ *
+ * Deeply traverses an object or array and converts all keys to snake_case.
+ * Preserves the structure and values, only transforming key names.
+ *
+ * @param obj - Object or array to transform
+ * @returns New object/array with snake_case keys
+ * @example
+ * ```typescript
+ * keysToSnake({
+ *   userName: "john",
+ *   userDetails: { firstName: "John" }
+ * }); // { user_name: "john", user_details: { first_name: "John" } }
+ * ```
+ */
+export declare const keysToSnake: (obj: unknown) => unknown;
+/**
+ * Converts a domain string to camelCase
+ *
+ * Convenience function that applies camelCase conversion to domain strings.
+ * Useful for converting API service names or domain identifiers.
+ *
+ * @param domain - Domain string to convert
+ * @returns camelCase formatted domain string
+ * @example
+ * ```typescript
+ * domainToCamel("api-service"); // "apiService"
+ * domainToCamel("user_management"); // "userManagement"
+ * ```
+ */
+export declare const domainToCamel: (domain: string) => string;
+/**
+ * Creates a visual progress indicator by cycling through a sequence of characters
+ *
+ * Useful for creating animated progress indicators in CLI applications.
+ * Cycles through provided characters or defaults to dot sequences.
+ *
+ * @param tick - Current tick state (null to start)
+ * @param options - Configuration options
+ * @param options.chars - Array of characters to cycle through
+ * @returns Next character in the sequence
+ * @example
+ * ```typescript
+ * let tick = null;
+ * setInterval(() => {
+ *   tick = logTicker(tick);
+ *   process.stdout.write(`\rProcessing ${tick}`);
+ * }, 500);
+ * // Outputs: "Processing ." → "Processing .." → "Processing ..."
+ * ```
+ */
+export declare const logTicker: (tick: string | null, options?: {
+    chars?: string[];
+}) => string;
+/**
+ * Parses an Amazon date string format (YYYYMMDDTHHMMSSZ) to a Date object
+ *
+ * Specifically handles the compact date format used by Amazon AWS services.
+ * Validates the format and throws detailed errors for invalid inputs.
+ *
+ * @param dateStr - Amazon date string in format YYYYMMDDTHHMMSSZ
+ * @returns Parsed Date object
+ * @throws {ParsingError} When date string format is invalid
+ * @example
+ * ```typescript
+ * parseAmazonDateString('20220223T215409Z');
+ * // Returns: Date object for February 23, 2022, 21:54:09 UTC
+ * ```
+ */
+export declare const parseAmazonDateString: (dateStr: string) => Date;
+/**
+ * Extracts and parses a date from a string
+ *
+ * Intelligently extracts dates from filenames or text strings by looking for
+ * common date patterns. Supports multiple formats including:
+ * - ISO dates (2023-01-15, 2023/01/15)
+ * - US dates (01/15/2023, 01-15-2023)
+ * - Natural language (January 15, 2023, Oct 14 2025)
+ * - Filenames with dates (Report_January_15_2023.pdf)
+ *
+ * @param str - String containing date information (filename, title, or text)
+ * @returns Parsed Date object or null if no valid date found
+ * @example
+ * ```typescript
+ * dateInString("Report_January_15_2023.pdf"); // Date(2023, 0, 15)
+ * dateInString("Regular Council Meeting October 14, 2025"); // Date(2025, 9, 14)
+ * dateInString("financial-report-dec-2023.pdf"); // Date(2023, 11, 1)
+ * dateInString("2023-01-15"); // Date(2023, 0, 15)
+ * dateInString("no-date-here.pdf"); // null
+ * ```
+ */
+export declare const dateInString: (str: string) => Date | null;
+/**
+ * Formats a date string into a human-readable format using the system locale
+ *
+ * Uses the Intl.DateTimeFormat API to create localized, human-readable date strings.
+ * Automatically adapts to the user's system locale settings.
+ *
+ * @param dateString - ISO date string or any valid date string
+ * @returns Human-readable date string in system locale
+ * @example
+ * ```typescript
+ * prettyDate("2023-01-15T12:00:00Z"); // "January 15, 2023" (in English locale)
+ * ```
+ */
+export declare const prettyDate: (dateString: string) => string;
+/**
+ * String pluralization utilities using the pluralize library
+ *
+ * Re-exports the pluralize library function for word pluralization.
+ * Handles English pluralization rules including irregular forms.
+ *
+ * @example
+ * ```typescript
+ * pluralizeWord("cat"); // "cats"
+ * pluralizeWord("mouse"); // "mice"
+ * singularize("cats"); // "cat"
+ * isPlural("cats"); // true
+ * isSingular("cat"); // true
+ * ```
+ */
+export declare const pluralizeWord: typeof pluralize;
+export declare const singularize: typeof pluralize.singular;
+export declare const isPlural: typeof pluralize.isPlural;
+export declare const isSingular: typeof pluralize.isSingular;
+/**
+ * Enhanced date utilities using date-fns library
+ *
+ * Re-exports commonly used date-fns functions for date manipulation and formatting.
+ * Provides more reliable date handling than native Date methods.
+ *
+ * @param date - Date object or ISO string to format
+ * @param formatStr - Format string (defaults to 'yyyy-MM-dd')
+ * @returns Formatted date string
+ * @example
+ * ```typescript
+ * formatDate(new Date(), 'yyyy-MM-dd'); // "2023-01-15"
+ * formatDate(new Date(), 'MM/dd/yyyy'); // "01/15/2023"
+ * parseDate('2023-01-15'); // Date object
+ * isValidDate(new Date()); // true
+ * addInterval(new Date(), { days: 7 }); // Date 7 days from now
+ * ```
+ */
+export declare const formatDate: (date: Date | string, formatStr?: string) => string;
+/**
+ * Parses a date string into a Date object
+ *
+ * When a format string is provided, uses date-fns `parse` with that format.
+ * Otherwise falls back to `parseISO` for ISO 8601 strings.
+ *
+ * @param dateStr - The date string to parse
+ * @param formatStr - Optional format pattern (e.g., 'MM/dd/yyyy', 'dd-MMM-yyyy')
+ * @returns Parsed Date object
+ * @example
+ * ```typescript
+ * parseDate('2023-01-15');                // ISO parse
+ * parseDate('01/15/2023', 'MM/dd/yyyy');  // Custom format parse
+ * ```
+ */
+export declare const parseDate: (dateStr: string, formatStr?: string) => Date;
+export declare const isValidDate: typeof isValid;
+export declare const addInterval: typeof add;
+/**
+ * Gets a temporary directory path (cross-platform)
+ *
+ * Creates a platform-appropriate temporary directory path under the .have-sdk namespace.
+ * Uses environment variables in Node.js or falls back to /tmp.
+ *
+ * @param subfolder - Optional subfolder name within the temp directory
+ * @returns Cross-platform temporary directory path
+ * @example
+ * ```typescript
+ * getTempDirectory(); // "/tmp/.have-sdk" (Unix) or equivalent
+ * getTempDirectory("cache"); // "/tmp/.have-sdk/cache"
+ * ```
+ */
+export declare const getTempDirectory: (subfolder?: string) => string;
+//# sourceMappingURL=universal.d.ts.map

package/dist/shared/universal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"universal.d.ts","sourceRoot":"","sources":["../../src/shared/universal.ts"],"names":[],"mappings":"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"}

package/dist/web.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Web and URL utility functions
+ *
+ * General-purpose utilities for working with URLs and web content.
+ * Used by scrapers, note systems, and content processors.
+ */
+/**
+ * Normalize URL for consistent key storage
+ * Removes tracking params, sorts query string, lowercases, etc.
+ *
+ * @param url - The URL to normalize
+ * @returns Normalized URL string
+ */
+export declare function normalizeUrl(url: string): string;
+/**
+ * Generate hierarchical scope from URL for organized note storage
+ *
+ * @param url - The URL to generate scope from
+ * @param baseScope - Base scope prefix (default: 'discovery/parser')
+ * @returns Hierarchical scope string
+ *
+ * @example
+ * generateScopeFromUrl('https://cityofboston.gov/meetings/minutes')
+ * // Returns: 'discovery/parser/cityofboston.gov/meetings'
+ */
+export declare function generateScopeFromUrl(url: string, baseScope?: string): string;
+/**
+ * Hash page content for change detection
+ * Uses SHA-256 to create a unique fingerprint of the HTML
+ *
+ * @param html - Page HTML content
+ * @returns SHA-256 hash as hex string
+ */
+export declare function hashPageContent(html: string): string;
+//# sourceMappingURL=web.d.ts.map

package/dist/web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web.d.ts","sourceRoot":"","sources":["../src/web.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAiDhD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,MAAM,EACX,SAAS,SAAqB,GAC7B,MAAM,CASR;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEpD"}

package/metadata.json

@@ -0,0 +1,54 @@
+{
+  "name": "@happyvertical/utils",
+  "path": "packages/utils",
+  "position": {
+    "index": 28,
+    "count": 30
+  },
+  "description": "Foundation utilities for ID generation, date parsing, URL handling, string conversion, error handling, and logging",
+  "provides": [
+    "Foundation utilities for ID generation, date parsing, URL handling, string conversion, error handling, and logging"
+  ],
+  "implements": [],
+  "requires": {
+    "workspace": [],
+    "externalHappyVertical": [],
+    "external": [
+      "@paralleldrive/cuid2",
+      "date-fns",
+      "pluralize",
+      "uuid"
+    ]
+  },
+  "dependents": [
+    "@happyvertical/accounting",
+    "@happyvertical/ai",
+    "@happyvertical/analytics",
+    "@happyvertical/auth",
+    "@happyvertical/cache",
+    "@happyvertical/comfyui",
+    "@happyvertical/directory",
+    "@happyvertical/documents",
+    "@happyvertical/email",
+    "@happyvertical/encryption",
+    "@happyvertical/files",
+    "@happyvertical/geo",
+    "@happyvertical/jobs",
+    "@happyvertical/logger",
+    "@happyvertical/messages",
+    "@happyvertical/sdk-mcp",
+    "@happyvertical/secrets",
+    "@happyvertical/social",
+    "@happyvertical/sql",
+    "@happyvertical/translator",
+    "@happyvertical/video",
+    "@happyvertical/weather"
+  ],
+  "stability": {
+    "level": "stable",
+    "reason": "Primary package surface is described as implemented and production-oriented."
+  },
+  "keywords": [
+    "utils"
+  ]
+}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@happyvertical/utils",
+  "version": "0.74.8",
+  "description": "Foundation utilities for ID generation, date parsing, URL handling, string conversion, error handling, and logging",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "browser": {
+        "import": "./dist/browser.js",
+        "types": "./dist/browser.d.ts"
+      },
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./browser": {
+      "import": "./dist/browser.js",
+      "types": "./dist/browser.d.ts"
+    }
+  },
+  "dependencies": {
+    "@paralleldrive/cuid2": "^3.3.0",
+    "date-fns": "^4.1.0",
+    "pluralize": "^8.0.0",
+    "uuid": "^13.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "25.0.10",
+    "@types/pluralize": "^0.0.33",
+    "typescript": "^5.9.3",
+    "vite": "7.3.2",
+    "vite-plugin-dts": "4.5.4",
+    "vitest": "^4.1.5"
+  },
+  "bin": {
+    "have-utils-context": "./dist/cli/claude-context.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "AGENT.md",
+    "metadata.json"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/happyvertical/sdk.git",
+    "directory": "packages/utils"
+  },
+  "bugs": {
+    "url": "https://github.com/happyvertical/sdk/issues"
+  },
+  "homepage": "https://github.com/happyvertical/sdk/tree/main/packages/utils#readme",
+  "license": "MIT",
+  "scripts": {
+    "test": "npx vitest run",
+    "test:watch": "npx vitest",
+    "build": "vite build",
+    "build:watch": "vite build --watch",
+    "docs": "typedoc --plugin typedoc-plugin-markdown --out docs --entryPoints ./src/index.ts --tsconfig ./tsconfig.json --excludePrivate --excludeInternal --hideGenerator --fileExtension .md --readme none --categorizeByGroup false --includeVersion false --hidePageHeader --hidePageTitle false --outputFileStrategy modules",
+    "docs:watch": "typedoc --plugin typedoc-plugin-markdown --out docs --entryPoints ./src/index.ts --tsconfig ./tsconfig.json --excludePrivate --excludeInternal --hideGenerator --fileExtension .md --readme none --categorizeByGroup false --includeVersion false --hidePageHeader --hidePageTitle false --outputFileStrategy modules --watch",
+    "clean": "rm -rf dist docs",
+    "dev": "npm run build:watch & npm run test:watch"
+  }
+}