anz-legislation 1.2.1

package/dist/utils/plugin-marketplace.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Plugin Marketplace
+ *
+ * Framework for discovering, installing, and managing plugins.
+ * Supports both official and community plugins.
+ */
+export interface PluginInfo {
+    name: string;
+    version: string;
+    description: string;
+    author: string;
+    type: 'official' | 'community';
+    status: 'stable' | 'beta' | 'alpha';
+    downloads: number;
+    rating?: number;
+    repository?: string;
+}
+export interface PluginManifest {
+    name: string;
+    version: string;
+    description: string;
+    main: string;
+    author: string;
+    license: string;
+    peerDependencies: Record<string, string>;
+    pluginType: 'official' | 'community';
+    pluginStatus: 'stable' | 'beta' | 'alpha';
+}
+export declare class PluginMarketplace {
+    private registryUrl;
+    private installedPlugins;
+    constructor(registryUrl?: string);
+    /**
+     * List available plugins
+     */
+    list(filter?: {
+        type?: 'official' | 'community';
+        status?: string;
+    }): Promise<PluginInfo[]>;
+    /**
+     * Install plugin
+     */
+    install(name: string, version?: string): Promise<void>;
+    /**
+     * Uninstall plugin
+     */
+    uninstall(name: string): Promise<void>;
+    /**
+     * Update plugin
+     */
+    update(name: string): Promise<void>;
+    /**
+     * Get installed plugins
+     */
+    getInstalled(): PluginManifest[];
+    /**
+     * Register installed plugin
+     */
+    registerPlugin(manifest: PluginManifest): void;
+    /**
+     * Search plugins
+     */
+    search(query: string): Promise<PluginInfo[]>;
+    /**
+     * Get plugin details
+     */
+    getDetails(name: string): Promise<PluginInfo | null>;
+    /**
+     * Submit community plugin
+     */
+    submit(manifest: PluginManifest): Promise<void>;
+}
+/**
+ * CLI command helpers
+ */
+export declare function formatPluginList(plugins: PluginInfo[]): string;
+export declare function getGlobalMarketplace(): PluginMarketplace;

package/dist/utils/plugin-marketplace.js

@@ -0,0 +1,191 @@
+/**
+ * Plugin Marketplace
+ *
+ * Framework for discovering, installing, and managing plugins.
+ * Supports both official and community plugins.
+ */
+export class PluginMarketplace {
+    registryUrl;
+    installedPlugins = new Map();
+    constructor(registryUrl = 'https://registry.npmjs.org') {
+        this.registryUrl = registryUrl;
+    }
+    /**
+     * List available plugins
+     */
+    async list(filter) {
+        // In real implementation, fetch from registry
+        // For now, return mock data
+        const plugins = [
+            // Official
+            {
+                name: '@nz-legislation/queensland',
+                version: '1.0.0',
+                description: 'Queensland legislation',
+                author: 'ANZ Legislation Team',
+                type: 'official',
+                status: 'stable',
+                downloads: 1000,
+            },
+            {
+                name: '@nz-legislation/commonwealth',
+                version: '1.0.0',
+                description: 'Commonwealth legislation',
+                author: 'ANZ Legislation Team',
+                type: 'official',
+                status: 'stable',
+                downloads: 800,
+            },
+            {
+                name: '@nz-legislation/nsw',
+                version: '1.0.0',
+                description: 'NSW legislation',
+                author: 'ANZ Legislation Team',
+                type: 'official',
+                status: 'stable',
+                downloads: 600,
+            },
+            {
+                name: '@nz-legislation/victoria',
+                version: '1.0.0',
+                description: 'Victoria legislation',
+                author: 'ANZ Legislation Team',
+                type: 'official',
+                status: 'stable',
+                downloads: 500,
+            },
+            // Community
+            {
+                name: '@community/fiji',
+                version: '0.1.0',
+                description: 'Fiji legislation (beta)',
+                author: 'Community',
+                type: 'community',
+                status: 'beta',
+                downloads: 50,
+            },
+            {
+                name: '@community/samoa',
+                version: '0.1.0',
+                description: 'Samoa legislation (alpha)',
+                author: 'Community',
+                type: 'community',
+                status: 'alpha',
+                downloads: 20,
+            },
+        ];
+        if (filter?.type) {
+            return plugins.filter(p => p.type === filter.type);
+        }
+        if (filter?.status) {
+            return plugins.filter(p => p.status === filter.status);
+        }
+        return plugins;
+    }
+    /**
+     * Install plugin
+     */
+    async install(name, version) {
+        console.log(`Installing ${name}${version ? `@${version}` : ''}...`);
+        // In real implementation:
+        // 1. Check compatibility
+        // 2. Download from registry
+        // 3. Install to plugins directory
+        // 4. Register with plugin loader
+        console.log(`✅ ${name} installed successfully`);
+    }
+    /**
+     * Uninstall plugin
+     */
+    async uninstall(name) {
+        console.log(`Uninstalling ${name}...`);
+        // In real implementation:
+        // 1. Remove from plugins directory
+        // 2. Unregister from plugin loader
+        console.log(`✅ ${name} uninstalled successfully`);
+    }
+    /**
+     * Update plugin
+     */
+    async update(name) {
+        console.log(`Updating ${name}...`);
+        // In real implementation:
+        // 1. Check for newer version
+        // 2. Download and install
+        console.log(`✅ ${name} updated successfully`);
+    }
+    /**
+     * Get installed plugins
+     */
+    getInstalled() {
+        return Array.from(this.installedPlugins.values());
+    }
+    /**
+     * Register installed plugin
+     */
+    registerPlugin(manifest) {
+        this.installedPlugins.set(manifest.name, manifest);
+    }
+    /**
+     * Search plugins
+     */
+    async search(query) {
+        const all = await this.list();
+        const queryLower = query.toLowerCase();
+        return all.filter(p => p.name.toLowerCase().includes(queryLower) ||
+            p.description.toLowerCase().includes(queryLower));
+    }
+    /**
+     * Get plugin details
+     */
+    async getDetails(name) {
+        const all = await this.list();
+        return all.find(p => p.name === name) ?? null;
+    }
+    /**
+     * Submit community plugin
+     */
+    async submit(manifest) {
+        console.log(`Submitting community plugin: ${manifest.name}...`);
+        // In real implementation:
+        // 1. Validate manifest
+        // 2. Run tests
+        // 3. Publish to community registry
+        console.log(`✅ ${manifest.name} submitted successfully`);
+    }
+}
+/**
+ * CLI command helpers
+ */
+export function formatPluginList(plugins) {
+    const official = plugins.filter(p => p.type === 'official');
+    const community = plugins.filter(p => p.type === 'community');
+    const lines = ['Available Plugins:', ''];
+    if (official.length > 0) {
+        lines.push('Official Plugins:');
+        for (const plugin of official) {
+            const icon = plugin.status === 'stable' ? '✅' : plugin.status === 'beta' ? '🧪' : '🔬';
+            lines.push(`  ${icon} ${plugin.name}@${plugin.version} - ${plugin.description}`);
+        }
+        lines.push('');
+    }
+    if (community.length > 0) {
+        lines.push('Community Plugins:');
+        for (const plugin of community) {
+            const icon = plugin.status === 'stable' ? '✅' : plugin.status === 'beta' ? '🧪' : '🔬';
+            lines.push(`  ${icon} ${plugin.name}@${plugin.version} - ${plugin.description} (by ${plugin.author})`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+/**
+ * Create global marketplace instance
+ */
+let globalMarketplace = null;
+export function getGlobalMarketplace() {
+    if (!globalMarketplace) {
+        globalMarketplace = new PluginMarketplace();
+    }
+    return globalMarketplace;
+}

package/dist/utils/presentation.d.ts

@@ -0,0 +1,2 @@
+export declare function buildCliHelpFooter(invokedCliName: string, alternateCliName: string): string;
+export declare function buildMcpStartupMessages(invokedBinaryName: string, alternateBinaryName: string): string[];

package/dist/utils/presentation.js

@@ -0,0 +1,32 @@
+export function buildCliHelpFooter(invokedCliName, alternateCliName) {
+    return `
+Jurisdictions:
+  - nz (New Zealand, default)
+  - au-comm (Australian Commonwealth)
+  - au-qld (Queensland)
+
+Examples:
+  $ ${invokedCliName} search --query "health" --type act
+  $ ${invokedCliName} get "act_public_1989_18"
+  $ ${invokedCliName} get "act/1988/123" --jurisdiction au-comm
+  $ ${invokedCliName} get "act_public_1989_18" --versions
+  $ ${invokedCliName} export --query "health" --output health.csv
+  $ ${invokedCliName} stream --query "health" --output health.csv  # Stream large exports
+  $ ${invokedCliName} batch --ids "act_public_1989_18,act_public_1986_132" --type getWork --output results.json
+  $ ${invokedCliName} batch --file works.csv --type getWork --output results.json
+  $ ${invokedCliName} cite "act_public_1989_18" --style bibtex
+  $ ${invokedCliName} config --show
+  $ ${invokedCliName} cache --stats
+
+Documentation: https://github.com/edithatogo/anz-legislation
+Also available as: ${alternateCliName}
+NZ API Documentation: https://api.legislation.govt.nz/docs/`;
+}
+export function buildMcpStartupMessages(invokedBinaryName, alternateBinaryName) {
+    return [
+        `ANZ Legislation MCP Server running on stdio via ${invokedBinaryName} (server id: nz-legislation)`,
+        `Also available as: ${alternateBinaryName}`,
+        'Tools available: search_legislation, get_legislation, get_legislation_versions, generate_citation, export_legislation, get_config',
+        'Resources available: legislation://{workId}',
+    ];
+}

package/dist/utils/rate-limiter.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Rate Limiter
+ *
+ * Per-jurisdiction rate limiting to avoid IP blocks and
+ * be a good internet citizen.
+ */
+export interface RateLimitOptions {
+    requests: number;
+    per: number;
+}
+export interface RateLimitStatus {
+    remaining: number;
+    limit: number;
+    resetTime: Date;
+    retryAfter?: number;
+}
+export declare class RateLimiter {
+    private limit;
+    private windowMs;
+    private tokens;
+    private lastRefill;
+    private queue;
+    private wakeUpTimer;
+    constructor(options: RateLimitOptions);
+    /**
+     * Wait until rate limit allows
+     */
+    throttle(): Promise<void>;
+    /**
+     * Get current rate limit status
+     */
+    getStatus(): RateLimitStatus;
+    /**
+     * Get remaining requests
+     */
+    getRemainingRequests(): number;
+    /**
+     * Get reset time
+     */
+    getResetTime(): Date;
+    /**
+     * Refill tokens based on elapsed time
+     */
+    private refillTokens;
+    /**
+     * Process waiting requests
+     */
+    private processQueue;
+    /**
+     * Get wait time in ms
+     */
+    private getWaitTime;
+    /**
+     * Reset rate limiter
+     */
+    reset(): void;
+    private scheduleQueueProcessing;
+    private clearScheduledWakeUp;
+    /**
+     * Create rate limiter from string (e.g., "30 per minute")
+     */
+    static fromString(spec: string): RateLimiter;
+}
+/**
+ * Rate limiter registry for multiple jurisdictions
+ */
+export declare class RateLimiterRegistry {
+    private limiters;
+    /**
+     * Get or create rate limiter for jurisdiction
+     */
+    get(jurisdiction: string): RateLimiter;
+    /**
+     * Set custom rate limiter for jurisdiction
+     */
+    set(jurisdiction: string, limiter: RateLimiter): void;
+    /**
+     * Get status for all jurisdictions
+     */
+    getAllStatus(): Array<{
+        jurisdiction: string;
+        status: RateLimitStatus;
+    }>;
+    /**
+     * Reset all limiters
+     */
+    resetAll(): void;
+    /**
+     * Create default limiter based on jurisdiction
+     */
+    private createDefaultLimiter;
+}
+/**
+ * Rate limit decorator for methods
+ */
+export declare function rateLimited(jurisdiction: string): <T extends (...args: unknown[]) => Promise<unknown>>(target: object, propertyKey: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>;
+/**
+ * CLI helper for rate limit status
+ */
+export declare function formatRateLimitStatus(status: RateLimitStatus): string;

package/dist/utils/rate-limiter.js

@@ -0,0 +1,256 @@
+/**
+ * Rate Limiter
+ *
+ * Per-jurisdiction rate limiting to avoid IP blocks and
+ * be a good internet citizen.
+ */
+export class RateLimiter {
+    limit;
+    windowMs;
+    tokens;
+    lastRefill;
+    queue = [];
+    wakeUpTimer = null;
+    constructor(options) {
+        this.limit = options.requests;
+        this.windowMs = options.per * 1000; // Convert to ms
+        this.tokens = this.limit;
+        this.lastRefill = Date.now();
+    }
+    /**
+     * Wait until rate limit allows
+     */
+    async throttle() {
+        this.refillTokens();
+        if (this.tokens >= 1) {
+            this.tokens--;
+            return;
+        }
+        // Need to wait
+        const waitTime = this.getWaitTime();
+        if (waitTime > 0) {
+            await new Promise(resolve => {
+                this.queue.push({ resolve, timestamp: Date.now() + waitTime });
+                this.scheduleQueueProcessing();
+            });
+        }
+    }
+    /**
+     * Get current rate limit status
+     */
+    getStatus() {
+        this.refillTokens();
+        const resetTime = new Date(Date.now() + this.windowMs);
+        const remaining = Math.floor(this.tokens);
+        return {
+            remaining,
+            limit: this.limit,
+            resetTime,
+            retryAfter: remaining <= 0 ? Math.ceil(this.getWaitTime() / 1000) : undefined,
+        };
+    }
+    /**
+     * Get remaining requests
+     */
+    getRemainingRequests() {
+        this.refillTokens();
+        return Math.floor(this.tokens);
+    }
+    /**
+     * Get reset time
+     */
+    getResetTime() {
+        return new Date(Date.now() + this.windowMs);
+    }
+    /**
+     * Refill tokens based on elapsed time
+     */
+    refillTokens() {
+        const now = Date.now();
+        const elapsed = now - this.lastRefill;
+        const tokensToAdd = (elapsed / this.windowMs) * this.limit;
+        this.tokens = Math.min(this.limit, this.tokens + tokensToAdd);
+        this.lastRefill = now;
+        // Process queue
+        this.processQueue();
+    }
+    /**
+     * Process waiting requests
+     */
+    processQueue() {
+        const now = Date.now();
+        // Remove stale entries (older than 1 minute) to prevent memory leaks
+        const maxQueueAge = 60 * 1000; // 1 minute
+        this.queue = this.queue.filter(item => now - item.timestamp < maxQueueAge);
+        // Limit queue size to prevent memory issues
+        const maxQueueSize = 1000;
+        if (this.queue.length > maxQueueSize) {
+            console.warn(`Rate limiter queue exceeded ${maxQueueSize} items, trimming...`);
+            this.queue = this.queue.slice(0, maxQueueSize);
+        }
+        while (this.queue.length > 0 && this.tokens >= 1) {
+            const next = this.queue[0];
+            if (now >= next.timestamp) {
+                this.queue.shift();
+                this.tokens--;
+                next.resolve();
+            }
+            else {
+                this.scheduleQueueProcessing(next.timestamp - now);
+                break;
+            }
+        }
+        if (this.queue.length === 0) {
+            this.clearScheduledWakeUp();
+        }
+    }
+    /**
+     * Get wait time in ms
+     */
+    getWaitTime() {
+        if (this.tokens >= 1) {
+            return 0;
+        }
+        const tokensNeeded = 1 - this.tokens;
+        const timePerToken = this.windowMs / this.limit;
+        return tokensNeeded * timePerToken;
+    }
+    /**
+     * Reset rate limiter
+     */
+    reset() {
+        this.tokens = this.limit;
+        this.lastRefill = Date.now();
+        this.clearScheduledWakeUp();
+        // Resolve all waiting
+        for (const item of this.queue) {
+            item.resolve();
+        }
+        this.queue = [];
+    }
+    scheduleQueueProcessing(delayMs) {
+        if (this.queue.length === 0) {
+            this.clearScheduledWakeUp();
+            return;
+        }
+        const nextDelay = Math.max(0, delayMs ?? this.queue[0].timestamp - Date.now());
+        if (this.wakeUpTimer) {
+            clearTimeout(this.wakeUpTimer);
+        }
+        this.wakeUpTimer = setTimeout(() => {
+            this.wakeUpTimer = null;
+            this.refillTokens();
+        }, nextDelay);
+    }
+    clearScheduledWakeUp() {
+        if (this.wakeUpTimer) {
+            clearTimeout(this.wakeUpTimer);
+            this.wakeUpTimer = null;
+        }
+    }
+    /**
+     * Create rate limiter from string (e.g., "30 per minute")
+     */
+    static fromString(spec) {
+        const match = spec.match(/(\d+)\s*per\s*(second|minute|hour|day)/i);
+        if (!match) {
+            throw new Error(`Invalid rate limit spec: ${spec}`);
+        }
+        const requests = parseInt(match[1], 10);
+        const unit = match[2].toLowerCase();
+        const perSeconds = {
+            second: 1,
+            minute: 60,
+            hour: 3600,
+            day: 86400,
+        };
+        return new RateLimiter({
+            requests,
+            per: perSeconds[unit],
+        });
+    }
+}
+/**
+ * Rate limiter registry for multiple jurisdictions
+ */
+export class RateLimiterRegistry {
+    limiters = new Map();
+    /**
+     * Get or create rate limiter for jurisdiction
+     */
+    get(jurisdiction) {
+        if (!this.limiters.has(jurisdiction)) {
+            const limiter = this.createDefaultLimiter(jurisdiction);
+            this.limiters.set(jurisdiction, limiter);
+        }
+        return this.limiters.get(jurisdiction);
+    }
+    /**
+     * Set custom rate limiter for jurisdiction
+     */
+    set(jurisdiction, limiter) {
+        this.limiters.set(jurisdiction, limiter);
+    }
+    /**
+     * Get status for all jurisdictions
+     */
+    getAllStatus() {
+        return Array.from(this.limiters.entries()).map(([jurisdiction, limiter]) => ({
+            jurisdiction,
+            status: limiter.getStatus(),
+        }));
+    }
+    /**
+     * Reset all limiters
+     */
+    resetAll() {
+        for (const limiter of this.limiters.values()) {
+            limiter.reset();
+        }
+    }
+    /**
+     * Create default limiter based on jurisdiction
+     */
+    createDefaultLimiter(jurisdiction) {
+        // Default limits based on jurisdiction
+        const limits = {
+            nz: { requests: 100, per: 60 }, // 100 per minute
+            'au-qld': { requests: 30, per: 60 }, // 30 per minute (more conservative)
+            'au-comm': { requests: 50, per: 60 }, // 50 per minute
+            'au-nsw': { requests: 40, per: 60 },
+            'au-vic': { requests: 40, per: 60 },
+            'au-wa': { requests: 30, per: 60 },
+            'au-sa': { requests: 30, per: 60 },
+            'au-tas': { requests: 20, per: 60 },
+            'au-nt': { requests: 20, per: 60 },
+            'au-act': { requests: 30, per: 60 },
+        };
+        const options = limits[jurisdiction] ?? { requests: 30, per: 60 };
+        return new RateLimiter(options);
+    }
+}
+/**
+ * Rate limit decorator for methods
+ */
+export function rateLimited(jurisdiction) {
+    return function (_target, _propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        const registry = new RateLimiterRegistry();
+        if (!originalMethod) {
+            return descriptor;
+        }
+        descriptor.value = async function (...args) {
+            const limiter = registry.get(jurisdiction);
+            await limiter.throttle();
+            return (await originalMethod.apply(this, args));
+        };
+        return descriptor;
+    };
+}
+/**
+ * CLI helper for rate limit status
+ */
+export function formatRateLimitStatus(status) {
+    const icon = status.remaining > status.limit * 0.5 ? '✅' : status.remaining > 0 ? '⚠️' : '❌';
+    return `${icon} ${status.remaining}/${status.limit} remaining${status.retryAfter ? ` (retry after ${status.retryAfter}s)` : ''}`;
+}