@vibesdotdev/kit 0.0.0-stage → 1.0.0-rc.4

package/dist/lib/utils/buckets.js

@@ -0,0 +1,165 @@
+/**
+ * Token bucket implementations for rate limiting.
+ *
+ * Kit-owned token-bucket implementations for rate limiting.
+ */
+function assertBucketOptions(max, intervalSeconds) {
+    if (!Number.isFinite(max) || max < 0) {
+        throw new RangeError('max must be a finite non-negative number');
+    }
+    if (!Number.isFinite(intervalSeconds) || intervalSeconds <= 0) {
+        throw new RangeError('interval must be a finite positive number of seconds');
+    }
+}
+function assertCost(cost) {
+    if (!Number.isFinite(cost) || cost < 0) {
+        throw new RangeError('cost must be a finite non-negative number');
+    }
+}
+/**
+ * Token bucket implementation for rate limiting.
+ * Refills tokens over time at a specified rate.
+ * Fractional capacities and costs are supported; zero capacity refuses positive costs.
+ */
+export class RefillingTokenBucket {
+    max;
+    refillIntervalSeconds;
+    storage = new Map();
+    constructor(max, refillIntervalSeconds) {
+        assertBucketOptions(max, refillIntervalSeconds);
+        this.max = max;
+        this.refillIntervalSeconds = refillIntervalSeconds;
+    }
+    check(key, cost) {
+        assertBucketOptions(this.max, this.refillIntervalSeconds);
+        assertCost(cost);
+        if (cost > this.max)
+            return false;
+        const bucket = this.storage.get(key) ?? null;
+        if (bucket === null) {
+            return true;
+        }
+        const now = Date.now();
+        const elapsed = Math.max(0, now - bucket.refilledAt);
+        const refill = Math.floor(elapsed / (this.refillIntervalSeconds * 1000));
+        return Math.min(bucket.count + refill, this.max) >= cost;
+    }
+    consume(key, cost) {
+        assertBucketOptions(this.max, this.refillIntervalSeconds);
+        assertCost(cost);
+        if (cost > this.max)
+            return false;
+        let bucket = this.storage.get(key) ?? null;
+        const now = Date.now();
+        if (bucket === null) {
+            bucket = { count: this.max - cost, refilledAt: now };
+            this.storage.set(key, bucket);
+            return true;
+        }
+        const interval = this.refillIntervalSeconds * 1000;
+        const elapsed = Math.max(0, now - bucket.refilledAt);
+        const refill = Math.floor(elapsed / interval);
+        bucket.count = Math.min(bucket.count + refill, this.max);
+        if (refill > 0) {
+            bucket.refilledAt = now - (elapsed % interval);
+        }
+        if (bucket.count < cost) {
+            return false;
+        }
+        bucket.count -= cost;
+        this.storage.set(key, bucket);
+        return true;
+    }
+    reset(key) {
+        this.storage.delete(key);
+    }
+}
+/**
+ * Throttling implementation for progressive backoff.
+ * Introduces increasing delays for failed attempts.
+ */
+export class Throttler {
+    timeoutSeconds;
+    storage = new Map();
+    constructor(timeoutSeconds) {
+        this.timeoutSeconds = timeoutSeconds;
+    }
+    consume(key) {
+        let counter = this.storage.get(key) ?? null;
+        const now = Date.now();
+        if (counter === null) {
+            counter = { timeout: 0, updatedAt: now };
+            this.storage.set(key, counter);
+            return true;
+        }
+        const allowed = now - counter.updatedAt >= this.timeoutSeconds[counter.timeout] * 1000;
+        if (!allowed) {
+            return false;
+        }
+        counter.updatedAt = now;
+        counter.timeout = Math.min(counter.timeout + 1, this.timeoutSeconds.length - 1);
+        this.storage.set(key, counter);
+        return true;
+    }
+    reset(key) {
+        this.storage.delete(key);
+    }
+}
+/**
+ * Expiring token bucket for finite time window rate limiting.
+ * Fractional capacities and costs are supported; zero capacity refuses positive costs.
+ */
+export class ExpiringTokenBucket {
+    max;
+    expiresInSeconds;
+    storage = new Map();
+    constructor(max, expiresInSeconds) {
+        assertBucketOptions(max, expiresInSeconds);
+        this.max = max;
+        this.expiresInSeconds = expiresInSeconds;
+    }
+    check(key, cost) {
+        assertBucketOptions(this.max, this.expiresInSeconds);
+        assertCost(cost);
+        if (cost > this.max)
+            return false;
+        const bucket = this.storage.get(key) ?? null;
+        const now = Date.now();
+        if (bucket === null) {
+            return true;
+        }
+        if (now - bucket.createdAt >= this.expiresInSeconds * 1000) {
+            return true;
+        }
+        return Math.min(bucket.count, this.max) >= cost;
+    }
+    consume(key, cost) {
+        assertBucketOptions(this.max, this.expiresInSeconds);
+        assertCost(cost);
+        if (cost > this.max)
+            return false;
+        let bucket = this.storage.get(key) ?? null;
+        const now = Date.now();
+        if (bucket === null) {
+            bucket = { count: this.max - cost, createdAt: now };
+            this.storage.set(key, bucket);
+            return true;
+        }
+        if (now - bucket.createdAt >= this.expiresInSeconds * 1000) {
+            bucket.count = this.max;
+            bucket.createdAt = now;
+        }
+        else {
+            bucket.count = Math.min(bucket.count, this.max);
+        }
+        if (bucket.count < cost) {
+            return false;
+        }
+        bucket.count -= cost;
+        this.storage.set(key, bucket);
+        return true;
+    }
+    reset(key) {
+        this.storage.delete(key);
+    }
+}

package/dist/lib/utils/client-ip.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Client IP extraction utilities.
+ *
+ * Kit-owned client-IP extraction utilities.
+ */
+import type { RequestEvent } from '@sveltejs/kit';
+/** What `getClientIp` answers when the client cannot be identified (value-free, never a header value). */
+export declare const UNIDENTIFIED_CLIENT = "unknown";
+/**
+ * Extract client IP from request headers (framework-free).
+ */
+export declare function getClientIpFromHeaders(headers: Headers): string | undefined;
+/**
+ * Extract client IP from a SvelteKit RequestEvent.
+ * Falls back to header inspection when getClientAddress() throws.
+ */
+export declare function getClientIp(event: RequestEvent, trustProxy?: boolean): string;

package/dist/lib/utils/client-ip.js

@@ -0,0 +1,46 @@
+/**
+ * Client IP extraction utilities.
+ *
+ * Kit-owned client-IP extraction utilities.
+ */
+import { settleNow } from '../attempt.js';
+/** What `getClientIp` answers when the client cannot be identified (value-free, never a header value). */
+export const UNIDENTIFIED_CLIENT = 'unknown';
+/**
+ * Extract client IP from request headers (framework-free).
+ */
+export function getClientIpFromHeaders(headers) {
+    const cfConnectingIp = headers.get('cf-connecting-ip');
+    if (cfConnectingIp) {
+        return cfConnectingIp;
+    }
+    const flyClientIp = headers.get('fly-client-ip');
+    if (flyClientIp) {
+        return flyClientIp;
+    }
+    const forwardedFor = headers.get('x-forwarded-for');
+    if (forwardedFor) {
+        return forwardedFor.split(',')[0].trim();
+    }
+    const realIp = headers.get('x-real-ip');
+    if (realIp) {
+        return realIp;
+    }
+    return undefined;
+}
+/**
+ * Extract client IP from a SvelteKit RequestEvent.
+ * Falls back to header inspection when getClientAddress() throws.
+ */
+export function getClientIp(event, trustProxy = false) {
+    if (trustProxy) {
+        const fromHeaders = getClientIpFromHeaders(event.request.headers);
+        if (fromHeaders)
+            return fromHeaders;
+    }
+    const address = settleNow(() => event.getClientAddress());
+    // Forwarding headers are client-controlled unless a proxy is declared
+    // (`trustProxy`). With none declared, a request whose transport address is
+    // unavailable is unidentified: it is never given an address from a header.
+    return address.ok ? address.value : UNIDENTIFIED_CLIENT;
+}

package/dist/lib/utils/format.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Formatting utilities for consistent data display
+ */
+/**
+ * Format a date to a localized string
+ */
+export declare function formatDate(date: Date | string | null | undefined): string;
+/**
+ * Format a date with time to a localized string
+ */
+export declare function formatDateTime(date: Date | string | null | undefined): string;
+/**
+ * Format a date to relative time (e.g., "2 hours ago")
+ */
+export declare function formatRelativeTime(date: Date | string | null | undefined): string;
+/**
+ * Format a number as currency
+ */
+export declare function formatCurrency(amount: number | null | undefined, currency?: string, locale?: string): string;
+/**
+ * Format a number as a percentage
+ */
+export declare function formatPercent(value: number | null | undefined, decimals?: number, locale?: string): string;
+/**
+ * Format a number with thousand separators
+ */
+export declare function formatNumber(value: number | null | undefined, decimals?: number, locale?: string): string;
+/**
+ * Format bytes to human readable size
+ */
+export declare function formatBytes(bytes: number | null | undefined, decimals?: number): string;
+/**
+ * Truncate text with ellipsis
+ */
+export declare function truncate(text: string | null | undefined, length?: number): string;
+/**
+ * Format a boolean value
+ */
+export declare function formatBoolean(value: boolean | null | undefined, trueLabel?: string, falseLabel?: string, nullLabel?: string): string;
+/**
+ * Format duration in milliseconds to human readable
+ */
+export declare function formatDuration(ms: number | null | undefined): string;
+/**
+ * Format a phone number
+ */
+export declare function formatPhone(phone: string | null | undefined): string;
+/**
+ * Format camelCase or snake_case to Title Case
+ */
+export declare function formatTitle(text: string | null | undefined): string;

package/dist/lib/utils/format.js

@@ -0,0 +1,169 @@
+/**
+ * Formatting utilities for consistent data display
+ */
+/**
+ * Format a date to a localized string
+ */
+export function formatDate(date) {
+    if (!date)
+        return '-';
+    const d = date instanceof Date ? date : new Date(date);
+    if (isNaN(d.getTime()))
+        return '-';
+    return d.toLocaleDateString();
+}
+/**
+ * Format a date with time to a localized string
+ */
+export function formatDateTime(date) {
+    if (!date)
+        return '-';
+    const d = date instanceof Date ? date : new Date(date);
+    if (isNaN(d.getTime()))
+        return '-';
+    return d.toLocaleString();
+}
+/**
+ * Format a date to relative time (e.g., "2 hours ago")
+ */
+export function formatRelativeTime(date) {
+    if (!date)
+        return '-';
+    const d = date instanceof Date ? date : new Date(date);
+    if (isNaN(d.getTime()))
+        return '-';
+    const now = new Date();
+    const diffMs = now.getTime() - d.getTime();
+    const diffSecs = Math.floor(diffMs / 1000);
+    const diffMins = Math.floor(diffSecs / 60);
+    const diffHours = Math.floor(diffMins / 60);
+    const diffDays = Math.floor(diffHours / 24);
+    if (diffSecs < 60)
+        return 'just now';
+    if (diffMins < 60)
+        return `${diffMins} minute${diffMins === 1 ? '' : 's'} ago`;
+    if (diffHours < 24)
+        return `${diffHours} hour${diffHours === 1 ? '' : 's'} ago`;
+    if (diffDays < 30)
+        return `${diffDays} day${diffDays === 1 ? '' : 's'} ago`;
+    return d.toLocaleDateString();
+}
+/**
+ * Format a number as currency
+ */
+export function formatCurrency(amount, currency = 'USD', locale = 'en-US') {
+    if (amount === null || amount === undefined)
+        return '-';
+    return new Intl.NumberFormat(locale, {
+        style: 'currency',
+        currency
+    }).format(amount);
+}
+/**
+ * Format a number as a percentage
+ */
+export function formatPercent(value, decimals = 2, locale = 'en-US') {
+    if (value === null || value === undefined)
+        return '-';
+    return new Intl.NumberFormat(locale, {
+        style: 'percent',
+        minimumFractionDigits: decimals,
+        maximumFractionDigits: decimals
+    }).format(value);
+}
+/**
+ * Format a number with thousand separators
+ */
+export function formatNumber(value, decimals, locale = 'en-US') {
+    if (value === null || value === undefined)
+        return '-';
+    const options = {};
+    if (decimals !== undefined) {
+        options.minimumFractionDigits = decimals;
+        options.maximumFractionDigits = decimals;
+    }
+    return new Intl.NumberFormat(locale, options).format(value);
+}
+/**
+ * Format bytes to human readable size
+ */
+export function formatBytes(bytes, decimals = 2) {
+    if (bytes === null || bytes === undefined || bytes === 0)
+        return '0 Bytes';
+    const k = 1024;
+    const dm = decimals < 0 ? 0 : decimals;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`;
+}
+/**
+ * Truncate text with ellipsis
+ */
+export function truncate(text, length = 50) {
+    if (!text)
+        return '';
+    if (text.length <= length)
+        return text;
+    return `${text.slice(0, length)}...`;
+}
+/**
+ * Format a boolean value
+ */
+export function formatBoolean(value, trueLabel = 'Yes', falseLabel = 'No', nullLabel = '-') {
+    if (value === null || value === undefined)
+        return nullLabel;
+    return value ? trueLabel : falseLabel;
+}
+/**
+ * Format duration in milliseconds to human readable
+ */
+export function formatDuration(ms) {
+    if (ms === null || ms === undefined)
+        return '-';
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0)
+        return `${days}d ${hours % 24}h`;
+    if (hours > 0)
+        return `${hours}h ${minutes % 60}m`;
+    if (minutes > 0)
+        return `${minutes}m ${seconds % 60}s`;
+    return `${seconds}s`;
+}
+/**
+ * Format a phone number
+ */
+export function formatPhone(phone) {
+    if (!phone)
+        return '';
+    // Remove all non-digits
+    const cleaned = phone.replace(/\D/g, '');
+    // Format US phone numbers
+    if (cleaned.length === 10) {
+        return `(${cleaned.slice(0, 3)}) ${cleaned.slice(3, 6)}-${cleaned.slice(6)}`;
+    }
+    if (cleaned.length === 11 && cleaned[0] === '1') {
+        return `+1 (${cleaned.slice(1, 4)}) ${cleaned.slice(4, 7)}-${cleaned.slice(7)}`;
+    }
+    // Return original for international numbers
+    return phone;
+}
+/**
+ * Format camelCase or snake_case to Title Case
+ */
+export function formatTitle(text) {
+    if (!text)
+        return '';
+    return (text
+        // Insert space before capital letters
+        .replace(/([A-Z])/g, ' $1')
+        // Replace underscores and hyphens with spaces
+        .replace(/[_-]/g, ' ')
+        // Capitalize first letter of each word
+        .replace(/\b\w/g, (l) => l.toUpperCase())
+        // Remove extra spaces
+        .replace(/\s+/g, ' ')
+        .trim());
+}

package/dist/lib/utils/metadata.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Centralized metadata utilities for Vibes application
+ * Provides consistent page titles, SEO metadata, and breadcrumb generation
+ */
+import type { SidebarLayoutMeta, SidebarLayoutBreadcrumb } from '../components/sidebar-layout/sidebar-layout-store.svelte';
+import type { RuntimeMetadata } from '../schemas/types';
+export declare const DEFAULT_METADATA: {
+    readonly appName: "Vibes";
+    readonly separator: " | ";
+    readonly defaultDescription: "AI-powered development platform for building and deploying intelligent agents";
+    readonly defaultKeywords: string[];
+    readonly defaultOgImage: "/vibes-logo.png";
+    readonly defaultOgType: "website";
+    readonly defaultTwitterCard: "summary";
+    readonly twitterSite: "@vibes_dev";
+    readonly author: "Vibes Team";
+    readonly robots: "index, follow";
+};
+/**
+ * Update runtime metadata
+ */
+export declare function updateMetadata(meta: Partial<RuntimeMetadata>): void;
+/**
+ * Get current app name (from settings or fallback)
+ */
+export declare function getAppName(): string;
+/**
+ * Get current app description (from settings or fallback)
+ */
+export declare function getAppDescription(): string;
+/**
+ * Generate a consistent page title with app name suffix
+ */
+export declare function generatePageTitle(title: string, includeAppName?: boolean): string;
+/**
+ * Generate SEO metadata object with defaults
+ */
+export declare function generateMetadata(options: Partial<SidebarLayoutMeta> & {
+    title: string;
+}, location?: Pick<URL, 'origin' | 'href'>): SidebarLayoutMeta;
+/**
+ * Generate breadcrumb data structures.
+ * `icon` is an Iconify icon name string (e.g. "lucide:home").
+ */
+export declare function generateBreadcrumbs(segments: Array<{
+    label: string;
+    href?: string;
+    icon?: string;
+}>): SidebarLayoutBreadcrumb[];
+/**
+ * Generate dynamic metadata for chat conversations
+ */
+export declare function generateChatMetadata(conversationTitle?: string): SidebarLayoutMeta;
+/**
+ * Generate dynamic metadata for knowledge base items
+ */
+export declare function generateKnowledgeMetadata(itemTitle?: string): SidebarLayoutMeta;
+/**
+ * Generate metadata for settings pages
+ */
+export declare function generateSettingsMetadata(settingsSection?: string): SidebarLayoutMeta;
+/**
+ * Generate metadata for dashboard
+ */
+export declare function generateDashboardMetadata(): SidebarLayoutMeta;
+/**
+ * Generate JSON-LD structured data for breadcrumbs
+ */
+export declare function generateBreadcrumbJsonLd(breadcrumbs: SidebarLayoutBreadcrumb[], location: Pick<URL, 'origin'>): string;
+/**
+ * Common breadcrumb segments for reuse
+ */
+export declare const BREADCRUMB_SEGMENTS: {
+    readonly dashboard: {
+        readonly label: "Dashboard";
+        readonly href: "/dashboard";
+    };
+    readonly chat: {
+        readonly label: "Chat";
+        readonly href: "/chat";
+    };
+    readonly knowledge: {
+        readonly label: "Knowledge";
+        readonly href: "/knowledge";
+    };
+    readonly settings: {
+        readonly label: "Settings";
+        readonly href: "/settings";
+    };
+    readonly user: {
+        readonly label: "Settings";
+        readonly href: "/";
+    };
+    readonly profile: {
+        readonly label: "Profile";
+        readonly href: "/profile";
+    };
+    readonly apiKeys: {
+        readonly label: "API Keys";
+        readonly href: "/api-keys";
+    };
+    readonly projects: {
+        readonly label: "Projects";
+        readonly href: "/projects";
+    };
+};
+/**
+ * Format a date range for display
+ */
+export declare function formatDateRange(start: Date | string, end: Date | string): string;
+/**
+ * Format a date as "time ago" (e.g., "2 hours ago", "3 days ago")
+ */
+export declare function formatTimeAgo(date: Date | string): string;
+/** A metadata value as displayed: primitives as text, arrays and objects as JSON. */
+export type MetadataValue = string | number | boolean | null | undefined | MetadataValue[] | {
+    readonly [key: string]: MetadataValue;
+};
+/**
+ * Format metadata object into display strings
+ */
+export declare function formatMetadata(metadata: {
+    readonly [key: string]: MetadataValue;
+}): Array<{
+    key: string;
+    value: string;
+}>;