@creativeintelligence/abbie 0.1.0

package/dist/lib/math.js

@@ -0,0 +1,109 @@
+export const add = (a, b) => a + b;
+export const subtract = (a, b) => a - b;
+export const multiply = (a, b) => a * b;
+export const divide = (a, b) => {
+    if (b === 0) {
+        throw new Error("Division by zero");
+    }
+    return a / b;
+};
+export const modulo = (a, b) => {
+    if (b === 0) {
+        throw new Error("Division by zero");
+    }
+    return a % b;
+};
+export const power = (base, exponent) => {
+    if (!Number.isInteger(exponent)) {
+        return base ** exponent;
+    }
+    if (exponent === 0)
+        return 1;
+    if (exponent === 1)
+        return base;
+    let result = 1;
+    const absExponent = Math.abs(exponent);
+    for (let i = 0; i < absExponent; i++) {
+        result *= base;
+    }
+    return exponent < 0 ? 1 / result : result;
+};
+export const clamp = (value, min, max) => {
+    return Math.min(Math.max(value, min), max);
+};
+export const lerp = (start, end, t) => {
+    const clampedT = clamp(t, 0, 1);
+    return start + (end - start) * clampedT;
+};
+export const roundTo = (value, decimals) => {
+    const multiplier = 10 ** decimals;
+    return Math.round(value * multiplier) / multiplier;
+};
+export const sum = (...numbers) => {
+    return numbers.reduce((acc, n) => acc + n, 0);
+};
+export const average = (...numbers) => {
+    if (numbers.length === 0) {
+        throw new Error("Cannot calculate average of empty array");
+    }
+    return sum(...numbers) / numbers.length;
+};
+export const fibonacci = (n) => {
+    if (n < 0) {
+        throw new Error("Fibonacci is not defined for negative numbers");
+    }
+    if (n <= 1)
+        return n;
+    let a = 0, b = 1;
+    for (let i = 2; i <= n; i++) {
+        [a, b] = [b, a + b];
+    }
+    return b;
+};
+export const gcd = (a, b) => {
+    a = Math.abs(a);
+    b = Math.abs(b);
+    while (b !== 0) {
+        [a, b] = [b, a % b];
+    }
+    return a;
+};
+export const lcm = (a, b) => {
+    if (a === 0 || b === 0)
+        return 0;
+    return Math.abs(a * b) / gcd(a, b);
+};
+export const isPrime = (n) => {
+    if (n < 2)
+        return false;
+    if (n === 2)
+        return true;
+    if (n % 2 === 0)
+        return false;
+    const sqrt = Math.sqrt(n);
+    for (let i = 3; i <= sqrt; i += 2) {
+        if (n % i === 0)
+            return false;
+    }
+    return true;
+};
+export const factorial = (n) => {
+    if (n < 0) {
+        throw new Error("Factorial is not defined for negative numbers");
+    }
+    if (n === 0 || n === 1)
+        return 1;
+    let result = 1;
+    for (let i = 2; i <= n; i++) {
+        result *= i;
+    }
+    return result;
+};
+export const degreesToRadians = (degrees) => (degrees * Math.PI) / 180;
+export const radiansToDegrees = (radians) => (radians * 180) / Math.PI;
+export const randomRange = (min, max) => {
+    return Math.random() * (max - min) + min;
+};
+export const randomInt = (min, max) => {
+    return Math.floor(randomRange(min, max + 1));
+};

package/dist/lib/math.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/math.test.js

@@ -0,0 +1,238 @@
+import { describe, it, expect } from 'bun:test';
+import { add, subtract, multiply, divide, modulo, power, clamp, lerp, roundTo, sum, average, fibonacci, gcd, lcm, isPrime, factorial, degreesToRadians, radiansToDegrees, randomRange, randomInt, } from './math';
+describe('math', () => {
+    describe('basic arithmetic', () => {
+        it('adds two numbers correctly', () => {
+            expect(add(2, 3)).toBe(5);
+            expect(add(-1, 1)).toBe(0);
+            expect(add(0, 0)).toBe(0);
+            expect(add(1.5, 2.5)).toBe(4);
+        });
+        it('subtracts two numbers correctly', () => {
+            expect(subtract(5, 3)).toBe(2);
+            expect(subtract(0, 1)).toBe(-1);
+            expect(subtract(-5, -3)).toBe(-2);
+            expect(subtract(5.5, 0.5)).toBe(5);
+        });
+        it('multiplies two numbers correctly', () => {
+            expect(multiply(2, 3)).toBe(6);
+            expect(multiply(-2, 3)).toBe(-6);
+            expect(multiply(-2, -3)).toBe(6);
+            expect(multiply(0, 5)).toBe(0);
+        });
+        it('divides two numbers correctly', () => {
+            expect(divide(6, 2)).toBe(3);
+            expect(divide(5, 2)).toBe(2.5);
+            expect(divide(-6, 2)).toBe(-3);
+        });
+        it('throws error when dividing by zero', () => {
+            expect(() => divide(5, 0)).toThrow('Division by zero');
+        });
+        it('calculates modulo correctly', () => {
+            expect(modulo(10, 3)).toBe(1);
+            expect(modulo(10, 5)).toBe(0);
+            expect(modulo(10, 2)).toBe(0);
+        });
+        it('throws error when calculating modulo by zero', () => {
+            expect(() => modulo(5, 0)).toThrow('Division by zero');
+        });
+    });
+    describe('power function', () => {
+        it('calculates positive exponents correctly', () => {
+            expect(power(2, 3)).toBe(8);
+            expect(power(5, 0)).toBe(1);
+            expect(power(5, 1)).toBe(5);
+            expect(power(3, 2)).toBe(9);
+        });
+        it('calculates fractional exponents correctly', () => {
+            expect(power(9, 0.5)).toBeCloseTo(3);
+            expect(power(16, 0.25)).toBeCloseTo(2);
+            expect(power(27, 1 / 3)).toBeCloseTo(3);
+        });
+        it('calculates negative exponents correctly', () => {
+            expect(power(2, -1)).toBe(0.5);
+            expect(power(10, -2)).toBe(0.01);
+        });
+        it('handles zero as base correctly', () => {
+            expect(power(0, 5)).toBe(0);
+            expect(power(0, 1)).toBe(0);
+        });
+    });
+    describe('clamp function', () => {
+        it('clamps values within range', () => {
+            expect(clamp(5, 0, 10)).toBe(5);
+            expect(clamp(-5, 0, 10)).toBe(0);
+            expect(clamp(15, 0, 10)).toBe(10);
+            expect(clamp(0, 0, 10)).toBe(0);
+            expect(clamp(10, 0, 10)).toBe(10);
+        });
+    });
+    describe('lerp function', () => {
+        it('linearly interpolates between values', () => {
+            expect(lerp(0, 10, 0.5)).toBe(5);
+            expect(lerp(0, 10, 0)).toBe(0);
+            expect(lerp(0, 10, 1)).toBe(10);
+            expect(lerp(0, 100, 0.25)).toBe(25);
+        });
+        it('clamps t parameter to [0, 1]', () => {
+            expect(lerp(0, 10, -1)).toBe(0);
+            expect(lerp(0, 10, 2)).toBe(10);
+        });
+    });
+    describe('roundTo function', () => {
+        it('rounds to specified decimal places', () => {
+            expect(roundTo(3.14159, 2)).toBe(3.14);
+            expect(roundTo(3.14159, 3)).toBe(3.142);
+            expect(roundTo(3.14159, 0)).toBe(3);
+            expect(roundTo(3.5, 0)).toBe(4);
+        });
+    });
+    describe('sum function', () => {
+        it('sums array of numbers', () => {
+            expect(sum(1, 2, 3, 4)).toBe(10);
+            expect(sum(1, 2, 3)).toBe(6);
+            expect(sum(-1, 1)).toBe(0);
+            expect(sum(0, 0, 0)).toBe(0);
+        });
+        it('handles single value', () => {
+            expect(sum(5)).toBe(5);
+        });
+        it('handles no values', () => {
+            expect(sum()).toBe(0);
+        });
+    });
+    describe('average function', () => {
+        it('calculates average correctly', () => {
+            expect(average(1, 2, 3)).toBe(2);
+            expect(average(2, 4, 6, 8)).toBe(5);
+            expect(average(5)).toBe(5);
+        });
+        it('handles negative numbers', () => {
+            expect(average(-5, 5)).toBe(0);
+        });
+        it('throws error on empty array', () => {
+            expect(() => average()).toThrow('Cannot calculate average of empty array');
+        });
+    });
+    describe('fibonacci function', () => {
+        it('calculates fibonacci numbers correctly', () => {
+            expect(fibonacci(0)).toBe(0);
+            expect(fibonacci(1)).toBe(1);
+            expect(fibonacci(2)).toBe(1);
+            expect(fibonacci(3)).toBe(2);
+            expect(fibonacci(4)).toBe(3);
+            expect(fibonacci(5)).toBe(5);
+            expect(fibonacci(10)).toBe(55);
+        });
+        it('throws error for negative input', () => {
+            expect(() => fibonacci(-1)).toThrow('Fibonacci is not defined for negative numbers');
+        });
+    });
+    describe('gcd function', () => {
+        it('calculates greatest common divisor correctly', () => {
+            expect(gcd(12, 8)).toBe(4);
+            expect(gcd(17, 5)).toBe(1);
+            expect(gcd(100, 10)).toBe(10);
+            expect(gcd(0, 5)).toBe(5);
+            expect(gcd(5, 0)).toBe(5);
+            expect(gcd(0, 0)).toBe(0);
+        });
+        it('handles negative numbers', () => {
+            expect(gcd(-12, 8)).toBe(4);
+            expect(gcd(12, -8)).toBe(4);
+            expect(gcd(-12, -8)).toBe(4);
+        });
+    });
+    describe('lcm function', () => {
+        it('calculates least common multiple correctly', () => {
+            expect(lcm(4, 6)).toBe(12);
+            expect(lcm(5, 7)).toBe(35);
+            expect(lcm(12, 8)).toBe(24);
+            expect(lcm(1, 5)).toBe(5);
+        });
+        it('handles zero correctly', () => {
+            expect(lcm(0, 5)).toBe(0);
+            expect(lcm(5, 0)).toBe(0);
+        });
+        it('handles negative numbers', () => {
+            expect(lcm(-4, 6)).toBe(12);
+            expect(lcm(4, -6)).toBe(12);
+            expect(lcm(-4, -6)).toBe(12);
+        });
+    });
+    describe('isPrime function', () => {
+        it('identifies prime numbers correctly', () => {
+            expect(isPrime(2)).toBe(true);
+            expect(isPrime(3)).toBe(true);
+            expect(isPrime(5)).toBe(true);
+            expect(isPrime(7)).toBe(true);
+            expect(isPrime(11)).toBe(true);
+            expect(isPrime(97)).toBe(true);
+        });
+        it('identifies non-prime numbers correctly', () => {
+            expect(isPrime(0)).toBe(false);
+            expect(isPrime(1)).toBe(false);
+            expect(isPrime(4)).toBe(false);
+            expect(isPrime(6)).toBe(false);
+            expect(isPrime(9)).toBe(false);
+            expect(isPrime(100)).toBe(false);
+        });
+    });
+    describe('factorial function', () => {
+        it('calculates factorial correctly', () => {
+            expect(factorial(0)).toBe(1);
+            expect(factorial(1)).toBe(1);
+            expect(factorial(2)).toBe(2);
+            expect(factorial(3)).toBe(6);
+            expect(factorial(4)).toBe(24);
+            expect(factorial(5)).toBe(120);
+        });
+        it('throws error for negative input', () => {
+            expect(() => factorial(-1)).toThrow('Factorial is not defined for negative numbers');
+        });
+    });
+    describe('degree/radian conversion', () => {
+        it('converts degrees to radians correctly', () => {
+            expect(degreesToRadians(0)).toBe(0);
+            expect(degreesToRadians(180)).toBeCloseTo(Math.PI);
+            expect(degreesToRadians(90)).toBeCloseTo(Math.PI / 2);
+            expect(degreesToRadians(360)).toBeCloseTo(2 * Math.PI);
+        });
+        it('converts radians to degrees correctly', () => {
+            expect(radiansToDegrees(0)).toBe(0);
+            expect(radiansToDegrees(Math.PI)).toBeCloseTo(180);
+            expect(radiansToDegrees(Math.PI / 2)).toBeCloseTo(90);
+            expect(radiansToDegrees(2 * Math.PI)).toBeCloseTo(360);
+        });
+        it('conversions are reversible', () => {
+            const degrees = 45;
+            const radians = degreesToRadians(degrees);
+            expect(radiansToDegrees(radians)).toBeCloseTo(degrees);
+        });
+    });
+    describe('random functions', () => {
+        it('randomRange returns value within bounds', () => {
+            const min = 5;
+            const max = 10;
+            for (let i = 0; i < 100; i++) {
+                const value = randomRange(min, max);
+                expect(value).toBeGreaterThanOrEqual(min);
+                expect(value).toBeLessThan(max);
+            }
+        });
+        it('randomInt returns integer within bounds', () => {
+            const min = 5;
+            const max = 10;
+            for (let i = 0; i < 100; i++) {
+                const value = randomInt(min, max);
+                expect(value).toBeGreaterThanOrEqual(min);
+                expect(value).toBeLessThanOrEqual(max);
+                expect(Number.isInteger(value)).toBe(true);
+            }
+        });
+        it('randomInt handles same min and max', () => {
+            const value = randomInt(5, 5);
+            expect(value).toBe(5);
+        });
+    });
+});

package/dist/lib/ngrok.d.ts

@@ -0,0 +1,157 @@
+import { EventStore } from "./events.js";
+/**
+ * Tunnel information from ngrok API.
+ */
+export interface NgrokTunnel {
+    name: string;
+    public_url: string;
+    proto: string;
+    config: {
+        addr: string;
+        inspect: boolean;
+    };
+    metrics?: {
+        conns: {
+            count: number;
+            rate1: number;
+            rate5: number;
+            rate15: number;
+        };
+        http?: {
+            count: number;
+            rate1: number;
+            rate5: number;
+            rate15: number;
+        };
+    };
+}
+/**
+ * Agent status from ngrok API.
+ */
+interface AgentStatus {
+    version: string;
+    region: string;
+    status: string;
+}
+/**
+ * Stored tunnel metadata (supplements API data).
+ */
+export interface StoredTunnel {
+    name: string;
+    session_id: string;
+    port: number;
+    created_at: string;
+}
+/**
+ * Check if ngrok agent is running.
+ * Uses the status endpoint for lightweight health check.
+ */
+export declare function isAgentRunning(): Promise<boolean>;
+/**
+ * Get ngrok agent status.
+ */
+export declare function getAgentStatus(): Promise<AgentStatus | undefined>;
+/**
+ * List all active tunnels via ngrok API.
+ * @see GET /api/tunnels
+ */
+export declare function listTunnels(): Promise<NgrokTunnel[]>;
+/**
+ * Get a specific tunnel by name.
+ * @see GET /api/tunnels/:name
+ */
+export declare function getTunnel(name: string): Promise<NgrokTunnel | undefined>;
+/**
+ * Start a new tunnel via ngrok API.
+ * Requires ngrok agent to be running.
+ * @see POST /api/tunnels
+ */
+export declare function startTunnel(port: number, name?: string): Promise<NgrokTunnel | undefined>;
+/**
+ * Stop a tunnel by name.
+ * @see DELETE /api/tunnels/:name
+ */
+export declare function stopTunnel(name: string): Promise<boolean>;
+/**
+ * Start ngrok agent in background if not running.
+ * This starts the agent without any tunnels - tunnels are created via API.
+ */
+export declare function ensureAgentRunning(): Promise<boolean>;
+/**
+ * Find tunnel by port number.
+ */
+export declare function findTunnelByPort(port: number): Promise<NgrokTunnel | undefined>;
+/**
+ * Get public URL for a port, creating tunnel if needed.
+ * This is the main high-level function for getting a public URL.
+ */
+export declare function getPublicUrl(port: number): Promise<string | undefined>;
+/**
+ * Kill all ngrok processes.
+ */
+export declare function killNgrok(): void;
+/**
+ * NgrokManager - higher-level manager with session tracking and events.
+ */
+export declare class NgrokManager {
+    private basePath;
+    private eventStore;
+    constructor(basePath?: string, eventStore?: EventStore);
+    /**
+     * Get stored tunnel metadata path.
+     */
+    private getMetadataPath;
+    /**
+     * Store tunnel metadata.
+     */
+    private storeMetadata;
+    /**
+     * Load tunnel metadata.
+     */
+    private loadMetadata;
+    /**
+     * Remove tunnel metadata.
+     */
+    private removeMetadata;
+    /**
+     * Start a tunnel with session tracking.
+     */
+    start(port: number, sessionId: string, name?: string): Promise<{
+        tunnel: NgrokTunnel;
+        public_url: string;
+    } | undefined>;
+    /**
+     * Stop a tunnel by name.
+     */
+    stop(name: string): Promise<boolean>;
+    /**
+     * Stop all tunnels for a session.
+     */
+    stopSession(sessionId: string): Promise<number>;
+    /**
+     * List all tunnels with metadata.
+     */
+    list(): Promise<Array<NgrokTunnel & {
+        metadata?: StoredTunnel;
+    }>>;
+    /**
+     * Cleanup stale metadata (tunnels that no longer exist).
+     */
+    cleanup(): Promise<number>;
+}
+/**
+ * Create an NgrokManager with default path.
+ */
+export declare function createNgrokManager(eventStore?: EventStore): NgrokManager;
+/**
+ * Print public URL to stdout.
+ * Usage: abbie tunnel url 3000 | xargs open
+ */
+export declare function printPublicUrl(port: number): Promise<void>;
+/**
+ * Print all tunnel URLs to stdout.
+ * Usage: abbie tunnel urls | xargs -I{} curl {}
+ */
+export declare function printAllUrls(): Promise<void>;
+export {};
+//# sourceMappingURL=ngrok.d.ts.map

package/dist/lib/ngrok.d.ts.map

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