autokap 1.0.6 → 1.0.8

package/dist/svg-text.js

@@ -0,0 +1,118 @@
+/**
+ * SVG text rendering via fontkit.
+ *
+ * Converts text strings to native SVG `<path>` elements by laying out glyphs
+ * with fontkit and serializing each glyph's vector path. This avoids depending
+ * on a system font installation or any HTML rendering layer (no Playwright).
+ *
+ * Coordinate system:
+ *   - SVG uses Y-down. Font glyphs use Y-up with the baseline at y=0.
+ *   - We flip Y while serializing each glyph's path commands.
+ *   - The caller passes a baseline Y position; glyphs are placed relative to it.
+ *
+ * Vertical alignment helper:
+ *   - Use `baselineForCenteredText` to compute the baseline Y so the cap-height
+ *     visual centroid lines up with the parent box's vertical centre. This
+ *     matches what `display:flex; align-items:center; line-height:1` produces
+ *     in CSS for the SF Pro status bar layouts.
+ */
+import { getFont } from './fonts-loader.js';
+/**
+ * Lay out a text run and serialize each glyph's vector path into a single
+ * SVG path data string. Y is flipped on the fly so the result is ready to
+ * embed in an SVG document with the standard top-left origin.
+ */
+export function layoutText(opts) {
+    const font = getFont(opts.fontId);
+    const fontSize = opts.fontSize;
+    const scale = fontSize / font.unitsPerEm;
+    const x0 = opts.x ?? 0;
+    const baselineY = opts.baselineY ?? fontSize;
+    const letterSpacing = opts.letterSpacing ?? 0;
+    const run = font.layout(opts.text);
+    let cursorX = x0;
+    let pathData = '';
+    for (let i = 0; i < run.glyphs.length; i++) {
+        const glyph = run.glyphs[i];
+        const pos = run.positions[i];
+        const glyphX = cursorX + pos.xOffset * scale;
+        const glyphY = baselineY - pos.yOffset * scale; // flipped
+        pathData += pathToSvgData(glyph.path, scale, glyphX, glyphY);
+        cursorX += pos.xAdvance * scale + letterSpacing;
+    }
+    return {
+        pathData,
+        width: cursorX - x0,
+        capHeight: font.capHeight * scale,
+        ascent: font.ascent * scale,
+        descent: -font.descent * scale,
+    };
+}
+/** Measure a text run without producing path data. */
+export function measureText(opts) {
+    const font = getFont(opts.fontId);
+    const fontSize = opts.fontSize;
+    const scale = fontSize / font.unitsPerEm;
+    const letterSpacing = opts.letterSpacing ?? 0;
+    const run = font.layout(opts.text);
+    let width = 0;
+    for (let i = 0; i < run.positions.length; i++) {
+        width += run.positions[i].xAdvance * scale + letterSpacing;
+    }
+    return { width, capHeight: font.capHeight * scale };
+}
+/**
+ * Compute the baseline Y so the cap-height visual centroid sits at parentY +
+ * parentH/2. This is what `align-items:center; line-height:1` does for short
+ * runs of digits / latin in SF Pro at status-bar sizes.
+ */
+export function baselineForCenteredText(parentY, parentH, fontId, fontSize) {
+    const font = getFont(fontId);
+    const cap = font.capHeight * (fontSize / font.unitsPerEm);
+    return parentY + (parentH + cap) / 2;
+}
+/** Default font id for SF Pro at status-bar sizes. */
+export function pickStatusBarFontId(weight = 'regular') {
+    return weight === 'semibold' ? 'text-semibold' : 'text-regular';
+}
+// ── Internal: glyph path → SVG path data ──────────────────────────────
+/**
+ * Convert a fontkit Path to SVG path data, scaled by `scale` and translated
+ * to (dx, dy). Y is flipped on every coordinate (font Y-up → SVG Y-down).
+ *
+ * fontkit's Path.toSVG() returns the data in font units with Y-up; we'd then
+ * need a wrapping `<g transform="...">` to place each glyph. Doing the math
+ * inline produces a single flat path string with no nested groups, which Sharp
+ * (librsvg) handles slightly faster and which is easier to debug.
+ */
+function pathToSvgData(path, scale, dx, dy) {
+    let s = '';
+    for (const cmd of path.commands) {
+        const a = cmd.args;
+        switch (cmd.command) {
+            case 'moveTo':
+                s += `M${fmt(dx + a[0] * scale)},${fmt(dy - a[1] * scale)}`;
+                break;
+            case 'lineTo':
+                s += `L${fmt(dx + a[0] * scale)},${fmt(dy - a[1] * scale)}`;
+                break;
+            case 'quadraticCurveTo':
+                s += `Q${fmt(dx + a[0] * scale)},${fmt(dy - a[1] * scale)} ${fmt(dx + a[2] * scale)},${fmt(dy - a[3] * scale)}`;
+                break;
+            case 'bezierCurveTo':
+                s += `C${fmt(dx + a[0] * scale)},${fmt(dy - a[1] * scale)} ${fmt(dx + a[2] * scale)},${fmt(dy - a[3] * scale)} ${fmt(dx + a[4] * scale)},${fmt(dy - a[5] * scale)}`;
+                break;
+            case 'closePath':
+                s += 'Z';
+                break;
+        }
+    }
+    return s;
+}
+/** Round to 3 decimals to keep generated SVGs compact. */
+function fmt(n) {
+    return Number.isInteger(n) ? String(n) : (Math.round(n * 1000) / 1000).toString();
+}
+// Keep Font import side-effect free.
+void null;
+//# sourceMappingURL=svg-text.js.map

package/dist/tools.d.ts

@@ -0,0 +1,4 @@
+import type { ChatCompletionFunctionTool } from 'openai/resources/chat/completions';
+export declare const agentTools: ChatCompletionFunctionTool[];
+/** Restricted tool set for the element capture mini-agent */
+export declare const elementCaptureTools: ChatCompletionFunctionTool[];

package/dist/tools.js

@@ -0,0 +1,216 @@
+// Note: evaluation_previous_action and memory fields are no longer injected into
+// tool schemas. They are documented in the system prompt instead (see prompts.ts),
+// which saves tokens on every iteration.
+const akTypeEnum = [
+    'button', 'input', 'link', 'text', 'image', 'heading',
+    'list', 'table', 'container', 'icon', 'toggle', 'select',
+    'checkbox', 'radio', 'slider', 'tab', 'modal', 'nav', 'form',
+    'video', 'audio', 'iframe',
+];
+const semanticPatternEnum = [
+    'cookie-banner', 'modal', 'navbar', 'footer', 'hero',
+    'sidebar', 'dropdown', 'toast', 'tooltip', 'form', 'card',
+    'pricing-table', 'cta-group',
+];
+const semanticTraitEnum = [
+    'floating', 'overlay', 'sticky', 'fixed',
+    'above-fold', 'below-fold', 'full-width', 'scrollable',
+];
+export const agentTools = [
+    {
+        type: 'function',
+        function: {
+            name: 'tap',
+            description: 'Click an element identified by its AKTree nodeId.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    nodeId: {
+                        type: 'string',
+                        description: 'Stable AKTree node id, for example "ak_3f8a2c1b".',
+                    },
+                },
+                required: ['nodeId'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'type',
+            description: 'Type text into a text-like control identified by AKTree nodeId.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    nodeId: {
+                        type: 'string',
+                        description: 'Stable AKTree node id of the target input.',
+                    },
+                    text: {
+                        type: 'string',
+                        description: 'Text to type. Use credential placeholders when available.',
+                    },
+                },
+                required: ['nodeId', 'text'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'scroll',
+            description: 'Scroll the page or a scrollable AKTree container. Use direction/offset for manual scrolling, or centerOn to center another AKTree node inside the page or container.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    direction: {
+                        type: 'string',
+                        enum: ['up', 'down', 'left', 'right'],
+                        description: 'Scroll direction for manual scrolling. Optional when centerOn is provided.',
+                    },
+                    offset: {
+                        type: 'number',
+                        description: 'Optional scroll offset in pixels for manual scrolling, or bias in pixels from perfect center when centerOn is provided.',
+                    },
+                    target: {
+                        type: 'string',
+                        description: 'Optional AKTree node id of a scrollable container. Omit to scroll the page.',
+                    },
+                    centerOn: {
+                        type: 'string',
+                        description: 'Optional AKTree node id to bring to the center of the page or of the target container.',
+                    },
+                },
+                required: [],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'navigate_to',
+            description: 'Navigate directly to a URL on the current site when that is the fastest deterministic way to reach the target.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    url: {
+                        type: 'string',
+                        description: 'Absolute or site-relative URL to navigate to.',
+                    },
+                },
+                required: ['url'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'press_key',
+            description: 'Press a keyboard key when the workflow requires Escape, Enter, Tab, or arrow keys.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    key: {
+                        type: 'string',
+                        description: 'Keyboard key name, for example "Escape", "Enter", "Tab", "ArrowDown".',
+                    },
+                },
+                required: ['key'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'capture',
+            description: 'Capture the current target and end the current run. When nodeId is provided, crop to that node bounds.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    nodeId: {
+                        type: 'string',
+                        description: 'Optional AKTree node id to crop. Omit for a page-level capture.',
+                    },
+                },
+                required: [],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'analyze_screenshot',
+            description: 'Ask the vision model a targeted question about the current screenshot when AKTree structure is insufficient.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    question: {
+                        type: 'string',
+                        description: 'Specific visual question to answer, for example "Is a modal blocking the page?" or "Does this dialog already show the target template selected?"',
+                    },
+                },
+                required: ['question'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'focus',
+            description: 'Return a filtered AKTree view using typed filters only.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    type: {
+                        type: 'array',
+                        items: { type: 'string', enum: [...akTypeEnum] },
+                        description: 'Optional node types to keep.',
+                    },
+                    semantic: {
+                        type: 'array',
+                        items: { type: 'string', enum: [...semanticPatternEnum] },
+                        description: 'Optional semantic patterns to keep.',
+                    },
+                    trait: {
+                        type: 'array',
+                        items: { type: 'string', enum: [...semanticTraitEnum] },
+                        description: 'Optional semantic traits to keep.',
+                    },
+                    interactive: {
+                        type: 'boolean',
+                        description: 'Optional interactive filter.',
+                    },
+                    visible: {
+                        type: 'boolean',
+                        description: 'Optional visibility filter.',
+                    },
+                    within: {
+                        type: 'string',
+                        description: 'Optional AKTree node id used as subtree scope.',
+                    },
+                    labelContains: {
+                        type: 'string',
+                        description: 'Case-insensitive substring match against node labels.',
+                    },
+                    maxDepth: {
+                        type: 'number',
+                        description: 'Optional maximum subtree depth.',
+                    },
+                    includeAncestors: {
+                        type: 'boolean',
+                        description: 'Include parent path to the root when true.',
+                    },
+                },
+                required: [],
+            },
+        },
+    },
+];
+/** Restricted tool set for the element capture mini-agent */
+export const elementCaptureTools = [
+    agentTools[7],
+    agentTools[2],
+    agentTools[6],
+    agentTools[5],
+];
+//# sourceMappingURL=tools.js.map