@guildai/cli 0.7.1 → 0.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guildai/cli",
-  "version": "0.7.1",
+  "version": "0.8.1",
   "description": "Guild.ai CLI - Build, test, and deploy AI agents",
   "type": "module",
   "main": "dist/index.js",
@@ -34,7 +34,7 @@
     "format": "prettier --write .",
     "format:fix": "prettier --write .",
     "format:check": "prettier --check .",
-    "test": "vitest run",
+    "test": "vitest run test/unit --config vitest.unit.config.ts",
     "test:unit": "vitest run test/unit --config vitest.unit.config.ts",
     "test:e2e": "vitest run test/e2e --exclude='**/**.slow.test.ts'",
     "test:e2e:slow": "vitest run 'test/e2e/**/*.slow.test.ts'",

package/dist/lib/lottie-renderer.d.ts

@@ -1,61 +0,0 @@
-interface LottieKeyframe {
-    t: number;
-    s: number[];
-    e?: number[];
-    i?: {
-        x: number;
-        y: number;
-    };
-    o?: {
-        x: number;
-        y: number;
-    };
-}
-interface LottieProperty {
-    a: number;
-    k: number[] | LottieKeyframe[];
-}
-interface LottieShape {
-    ty: string;
-    ks?: {
-        a: number;
-        k: {
-            v: number[][];
-            c: boolean;
-        };
-    };
-}
-interface LottieLayer {
-    ty: number;
-    nm?: string;
-    refId?: string;
-    shapes?: LottieShape[];
-    ks: {
-        p: LottieProperty;
-        s: LottieProperty;
-        r: LottieProperty;
-        a: LottieProperty;
-    };
-    parent?: number;
-}
-interface LottieAnimation {
-    w: number;
-    h: number;
-    fr: number;
-    op: number;
-    layers: LottieLayer[];
-    assets?: Array<{
-        id: string;
-        layers: LottieLayer[];
-    }>;
-}
-/**
- * Render a single frame of Lottie animation to braille
- */
-export declare function renderLottieFrame(animation: LottieAnimation, frameNumber: number, widthChars: number, heightChars: number, invert?: boolean): string[];
-/**
- * Pre-render all frames of a Lottie animation
- */
-export declare function renderLottieAnimation(animation: LottieAnimation, widthChars: number, heightChars: number, invert?: boolean): string[][];
-export {};
-//# sourceMappingURL=lottie-renderer.d.ts.map

package/dist/lib/lottie-renderer.js

@@ -1,238 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Lottie to Braille Renderer
- *
- * Parses Lottie animation JSON and renders each frame to braille characters.
- * Supports basic shape rendering with position/scale/rotation transformations.
- */
-import { createCanvas, setPixel, fillPath, canvasToStrings, } from './svg-renderer.js';
-/**
- * Interpolate between keyframes at a given time
- */
-function interpolateKeyframes(keyframes, time, dimensions) {
-    if (keyframes.length === 0)
-        return Array(dimensions).fill(0);
-    // Find surrounding keyframes
-    let startKf = keyframes[0];
-    let endKf = keyframes[keyframes.length - 1];
-    for (let i = 0; i < keyframes.length - 1; i++) {
-        if (time >= keyframes[i].t && time <= keyframes[i + 1].t) {
-            startKf = keyframes[i];
-            endKf = keyframes[i + 1];
-            break;
-        }
-    }
-    // If before first or after last keyframe, use start/end value
-    if (time <= startKf.t)
-        return startKf.s;
-    if (time >= endKf.t)
-        return endKf.s;
-    // Linear interpolation (ignoring easing for simplicity)
-    const progress = (time - startKf.t) / (endKf.t - startKf.t);
-    const result = [];
-    for (let i = 0; i < dimensions; i++) {
-        const start = startKf.s[i] || 0;
-        const end = endKf.s[i] || start;
-        result.push(start + (end - start) * progress);
-    }
-    return result;
-}
-/**
- * Get property value at a given time
- */
-function getPropertyValue(prop, time, dimensions) {
-    if (prop.a === 0) {
-        // Static value
-        return Array.isArray(prop.k) ? prop.k : [prop.k];
-    }
-    else {
-        // Animated value
-        return interpolateKeyframes(prop.k, time, dimensions);
-    }
-}
-/**
- * Draw a Lottie shape using bounding box auto-crop
- */
-function drawLottieShapeWithBBox(canvas, shapes, layerTransform, canvasPixelWidth, canvasPixelHeight, bboxCenterX, bboxCenterY, bboxSize) {
-    // Find the path shape
-    const pathShape = shapes.find((s) => s.ty === 'sh');
-    if (!pathShape || !pathShape.ks?.k?.v)
-        return;
-    // Check if we have a fill
-    const hasFill = shapes.some((s) => s.ty === 'fl');
-    const vertices = pathShape.ks.k.v;
-    const closed = pathShape.ks.k.c;
-    // Transform vertices and map to canvas pixels
-    const transformedPoints = vertices.map((v) => {
-        // Step 1: Transform to Lottie coordinate space
-        const lottieX = layerTransform.x + v[0] * layerTransform.scaleX;
-        const lottieY = layerTransform.y + v[1] * layerTransform.scaleY;
-        // Step 2: Center on bounding box and scale to canvas
-        // Map bounding box to canvas with some padding
-        const padding = 0.1; // 10% padding
-        const scale = Math.min(canvasPixelWidth, canvasPixelHeight) / (bboxSize * (1 + padding));
-        const x = (lottieX - bboxCenterX) * scale + canvasPixelWidth / 2;
-        const y = (lottieY - bboxCenterY) * scale + canvasPixelHeight / 2;
-        return [x, y];
-    });
-    // Fill if we have a fill element
-    if (hasFill && closed) {
-        fillPath(canvas, transformedPoints);
-    }
-    // Draw outline
-    for (let i = 0; i < transformedPoints.length; i++) {
-        const p1 = transformedPoints[i];
-        const p2 = transformedPoints[(i + 1) % transformedPoints.length];
-        if (!closed && i === transformedPoints.length - 1)
-            break;
-        drawLine(canvas, p1[0], p1[1], p2[0], p2[1]);
-    }
-}
-/**
- * Simple line drawing (Bresenham)
- */
-function drawLine(canvas, x0, y0, x1, y1) {
-    x0 = Math.round(x0);
-    y0 = Math.round(y0);
-    x1 = Math.round(x1);
-    y1 = Math.round(y1);
-    const dx = Math.abs(x1 - x0);
-    const dy = Math.abs(y1 - y0);
-    const sx = x0 < x1 ? 1 : -1;
-    const sy = y0 < y1 ? 1 : -1;
-    let err = dx - dy;
-    while (true) {
-        setPixel(canvas, x0, y0);
-        if (x0 === x1 && y0 === y1)
-            break;
-        const e2 = 2 * err;
-        if (e2 > -dy) {
-            err -= dy;
-            x0 += sx;
-        }
-        if (e2 < dx) {
-            err += dx;
-            y0 += sy;
-        }
-    }
-}
-/**
- * Render a single frame of Lottie animation to braille
- */
-export function renderLottieFrame(animation, frameNumber, widthChars, heightChars, invert = false) {
-    const canvas = createCanvas(widthChars, heightChars);
-    // Calculate pixel dimensions (braille is 2x4 pixels per character)
-    const canvasPixelWidth = widthChars * 2;
-    const canvasPixelHeight = heightChars * 4;
-    // PASS 1: Collect all vertices in Lottie coordinate space to calculate bounding box
-    const allVertices = [];
-    for (const layer of animation.layers) {
-        if (layer.ty === 0 && layer.refId) {
-            // Pre-composition layer
-            const asset = animation.assets?.find((a) => a.id === layer.refId);
-            if (!asset || !asset.layers)
-                continue;
-            for (const compLayer of asset.layers) {
-                if (compLayer.ty !== 4 || !compLayer.shapes)
-                    continue;
-                const layerPos = getPropertyValue(compLayer.ks.p, frameNumber, 3);
-                const layerScale = getPropertyValue(compLayer.ks.s, frameNumber, 3);
-                // Find shape vertices
-                const pathShape = compLayer.shapes.find((s) => s.ty === 'sh');
-                if (!pathShape || !pathShape.ks?.k?.v)
-                    continue;
-                const vertices = pathShape.ks.k.v;
-                // Transform vertices to Lottie coordinate space
-                vertices.forEach((v) => {
-                    const x = layerPos[0] + v[0] * (layerScale[0] / 100);
-                    const y = layerPos[1] + v[1] * (layerScale[1] / 100);
-                    allVertices.push([x, y]);
-                });
-            }
-        }
-        else if (layer.ty === 4 && layer.shapes) {
-            // Direct shape layer
-            const position = getPropertyValue(layer.ks.p, frameNumber, 3);
-            const scale = getPropertyValue(layer.ks.s, frameNumber, 3);
-            const pathShape = layer.shapes.find((s) => s.ty === 'sh');
-            if (!pathShape || !pathShape.ks?.k?.v)
-                continue;
-            const vertices = pathShape.ks.k.v;
-            vertices.forEach((v) => {
-                const x = position[0] + v[0] * (scale[0] / 100);
-                const y = position[1] + v[1] * (scale[1] / 100);
-                allVertices.push([x, y]);
-            });
-        }
-    }
-    // Calculate bounding box
-    if (allVertices.length === 0) {
-        return canvasToStrings(canvas); // Empty frame
-    }
-    const minX = Math.min(...allVertices.map((v) => v[0]));
-    const maxX = Math.max(...allVertices.map((v) => v[0]));
-    const minY = Math.min(...allVertices.map((v) => v[1]));
-    const maxY = Math.max(...allVertices.map((v) => v[1]));
-    const bboxWidth = maxX - minX;
-    const bboxHeight = maxY - minY;
-    const bboxCenterX = (minX + maxX) / 2;
-    const bboxCenterY = (minY + maxY) / 2;
-    // PASS 2: Render shapes using bounding box as viewport
-    for (const layer of animation.layers) {
-        if (layer.ty === 0 && layer.refId) {
-            const asset = animation.assets?.find((a) => a.id === layer.refId);
-            if (!asset || !asset.layers)
-                continue;
-            for (const compLayer of asset.layers) {
-                if (compLayer.ty !== 4 || !compLayer.shapes)
-                    continue;
-                const layerPos = getPropertyValue(compLayer.ks.p, frameNumber, 3);
-                const layerScale = getPropertyValue(compLayer.ks.s, frameNumber, 3);
-                const layerRot = getPropertyValue(compLayer.ks.r, frameNumber, 1)[0];
-                const layerTransform = {
-                    x: layerPos[0],
-                    y: layerPos[1],
-                    scaleX: layerScale[0] / 100,
-                    scaleY: layerScale[1] / 100,
-                    rotation: layerRot,
-                };
-                drawLottieShapeWithBBox(canvas, compLayer.shapes, layerTransform, canvasPixelWidth, canvasPixelHeight, bboxCenterX, bboxCenterY, Math.max(bboxWidth, bboxHeight));
-            }
-        }
-        else if (layer.ty === 4 && layer.shapes) {
-            const position = getPropertyValue(layer.ks.p, frameNumber, 3);
-            const scale = getPropertyValue(layer.ks.s, frameNumber, 3);
-            const rotation = getPropertyValue(layer.ks.r, frameNumber, 1)[0];
-            const layerTransform = {
-                x: position[0],
-                y: position[1],
-                scaleX: scale[0] / 100,
-                scaleY: scale[1] / 100,
-                rotation,
-            };
-            drawLottieShapeWithBBox(canvas, layer.shapes, layerTransform, canvasPixelWidth, canvasPixelHeight, bboxCenterX, bboxCenterY, Math.max(bboxWidth, bboxHeight));
-        }
-    }
-    // Invert if requested
-    if (invert) {
-        for (let y = 0; y < canvas.pixels.length; y++) {
-            for (let x = 0; x < canvas.pixels[y].length; x++) {
-                canvas.pixels[y][x] = !canvas.pixels[y][x];
-            }
-        }
-    }
-    return canvasToStrings(canvas);
-}
-/**
- * Pre-render all frames of a Lottie animation
- */
-export function renderLottieAnimation(animation, widthChars, heightChars, invert = false) {
-    const frames = [];
-    const totalFrames = Math.floor(animation.op);
-    for (let i = 0; i < totalFrames; i++) {
-        frames.push(renderLottieFrame(animation, i, widthChars, heightChars, invert));
-    }
-    return frames;
-}
-//# sourceMappingURL=lottie-renderer.js.map

package/dist/lib/svg-renderer.d.ts

@@ -1,110 +0,0 @@
-export interface BrailleCanvas {
-    width: number;
-    height: number;
-    pixels: boolean[][];
-}
-export interface SVGRenderOptions {
-    width?: number;
-    height?: number;
-    fill?: boolean;
-    fillDensity?: number;
-    stroke?: boolean;
-    invert?: boolean;
-    rotation?: number;
-    autoFit?: boolean;
-    explicitBounds?: {
-        minX: number;
-        minY: number;
-        maxX: number;
-        maxY: number;
-    };
-}
-interface TransformMatrix {
-    a: number;
-    b: number;
-    c: number;
-    d: number;
-    e: number;
-    f: number;
-}
-/**
- * Apply transform matrix to a point
- */
-export declare function transformPoint(x: number, y: number, m: TransformMatrix): [number, number];
-/**
- * Create an empty braille canvas
- */
-export declare function createCanvas(widthChars: number, heightChars: number): BrailleCanvas;
-/**
- * Set a pixel in the canvas
- */
-export declare function setPixel(canvas: BrailleCanvas, x: number, y: number, value?: boolean): void;
-/**
- * Draw a line using Bresenham's algorithm
- */
-export declare function drawLine(canvas: BrailleCanvas, x0: number, y0: number, x1: number, y1: number): void;
-/**
- * Draw a cubic bezier curve
- */
-export declare function drawCubicBezier(canvas: BrailleCanvas, x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, steps?: number): void;
-/**
- * Draw a quadratic bezier curve
- */
-export declare function drawQuadraticBezier(canvas: BrailleCanvas, x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, steps?: number): void;
-/**
- * Fill a closed path using scanline algorithm
- */
-export declare function fillPath(canvas: BrailleCanvas, points: [number, number][], density?: number): void;
-interface ClipRect {
-    minX: number;
-    minY: number;
-    maxX: number;
-    maxY: number;
-}
-interface ParsedPath {
-    pathData: string;
-    transform: TransformMatrix;
-    clipRect?: ClipRect;
-    fill?: string;
-}
-/**
- * Parse SVG hierarchically to match each path with its correct transform chain
- */
-export declare function parseHierarchicalPaths(svgContent: string): ParsedPath[];
-/**
- * Parse SVG content and extract path points with transforms applied
- */
-export declare function extractPathPoints(svgContent: string, targetWidth: number, targetHeight: number, rotation?: number, autoFit?: boolean, explicitBounds?: {
-    minX: number;
-    minY: number;
-    maxX: number;
-    maxY: number;
-}): [number, number][][];
-/**
- * Render SVG content to a braille canvas
- */
-export declare function renderSVGToCanvas(svgContent: string, options?: SVGRenderOptions): BrailleCanvas;
-/**
- * Convert braille canvas to string array
- */
-export declare function canvasToStrings(canvas: BrailleCanvas): string[];
-/**
- * Render SVG content string to braille strings
- */
-export declare function renderSVGContent(content: string, options?: SVGRenderOptions): string[];
-/**
- * Load and render the Guild logo from local assets
- */
-export declare function renderGuildLogo(widthChars?: number, heightChars?: number, invert?: boolean, rotation?: number): string[];
-/**
- * Get raw path points for animation purposes
- * Returns points in pixel coordinate space for the given dimensions
- */
-export declare function getLogoPathPoints(widthChars?: number, heightChars?: number): [number, number][][];
-/**
- * Get pixel positions from rendered logo (useful for inverted logos)
- * Returns array of [x, y] pixel coordinates that are "on" in the rendered logo
- */
-export declare function getLogoPixelPositions(widthChars?: number, heightChars?: number, invert?: boolean): [number, number][];
-export {};
-//# sourceMappingURL=svg-renderer.d.ts.map