@nivustec/proteus 1.0.1

package/dist/injector.js

@@ -0,0 +1,157 @@
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { execSync } from "child_process";
+import { glob } from "glob";
+import { parseAndInject } from "./parser.js";
+export async function injectTestIds(config, specificFiles) {
+    const stats = {
+        filesProcessed: 0,
+        totalInjected: 0,
+        errors: 0,
+        errorMessages: [],
+    };
+    let filesToProcess = [];
+    // If we have specific files, process ONLY them (ignore include/exclude)
+    if (specificFiles && specificFiles.length > 0) {
+        filesToProcess = specificFiles.filter((file) => {
+            const exists = existsSync(file);
+            return exists;
+        });
+    }
+    else {
+        // If there are no specific files, use include/exclude
+        for (const pattern of config.include || []) {
+            const matches = await glob(pattern, {
+                ignore: config.exclude,
+                nodir: true,
+            });
+            filesToProcess.push(...matches);
+        }
+        filesToProcess = [...new Set(filesToProcess)];
+    }
+    for (const filePath of filesToProcess) {
+        const code = readFileSync(filePath, "utf-8");
+        if (config.verbose) {
+            console.log("🌊 Proteus is transforming your components...");
+        }
+        const result = parseAndInject(filePath, code, config);
+        if (result.error) {
+            stats.errors++;
+            stats.errorMessages.push(`Error processing ${filePath}: ${result.error.message}`);
+        }
+        if (result.injectedCount > 0) {
+            writeFileSync(filePath, result.code);
+            stats.totalInjected += result.injectedCount;
+        }
+        stats.filesProcessed++;
+    }
+    return stats;
+}
+export async function injectStagedFiles() {
+    const stats = {
+        filesProcessed: 0,
+        totalInjected: 0,
+        errors: 0,
+        errorMessages: [],
+    };
+    try {
+        const stagedBackup = execSync("git diff --cached --name-only", {
+            encoding: "utf8",
+        })
+            .split("\n")
+            .filter(Boolean);
+        execSync("git reset --mixed", { stdio: "pipe" });
+        const filesToProcess = stagedBackup.filter((file) => file.match(/\.(jsx|tsx)$/) &&
+            !file.includes("node_modules") &&
+            existsSync(file));
+        const cfg = loadConfig(undefined, true);
+        cfg.verbose = false;
+        if (cfg.verbose) {
+            console.log(`🔧 Files to process: ${filesToProcess.length} files`);
+        }
+        if (filesToProcess.length === 0) {
+            if (stagedBackup.length > 0) {
+                execSync(`git add ${stagedBackup.join(" ")}`, { stdio: "pipe" });
+            }
+            if (cfg.verbose) {
+                console.log("💡 No React files in commit");
+            }
+            return stats;
+        }
+        const config = cfg;
+        for (const filePath of filesToProcess) {
+            const code = readFileSync(filePath, "utf-8");
+            const result = parseAndInject(filePath, code, config);
+            if (result.error) {
+                stats.errors++;
+                stats.errorMessages.push(`Error processing ${filePath}: ${result.error.message}`);
+            }
+            if (result.injectedCount > 0) {
+                writeFileSync(filePath, result.code);
+                if (config.verbose) {
+                    console.log("🌊 Proteus is transforming your components...");
+                    console.log(`✅ Injected ${result.injectedCount} test IDs in ${filePath}`);
+                }
+                stats.totalInjected += result.injectedCount;
+            }
+            stats.filesProcessed++;
+        }
+        // 4. Re-stage all files (including modifications)
+        if (stagedBackup.length > 0) {
+            execSync(`git add ${stagedBackup.join(" ")}`, { stdio: "pipe" });
+        }
+        if (config.verbose) {
+            if (stats.totalInjected > 0) {
+                console.log(`🎉 Added ${stats.totalInjected} test IDs to the commit`);
+                console.log("💡 Review the changes with 'git diff --cached' before committing");
+            }
+            else {
+                console.log("✅ All files already have data-testid");
+            }
+        }
+        return stats;
+    }
+    catch (error) {
+        stats.errors++;
+        stats.errorMessages.push(error instanceof Error ? error.message : String(error));
+        return stats;
+    }
+}
+export function setupGitHooks() {
+    const packageJsonPath = "./package.json";
+    const huskyDir = "./.husky";
+    if (existsSync(huskyDir)) {
+        try {
+            const preCommitPath = `${huskyDir}/pre-commit`;
+            const script = `#!/usr/bin/env sh\n. "$(dirname "$0")/_/husky.sh"\nproteus pre-commit\n`;
+            writeFileSync(preCommitPath, script, { encoding: "utf8" });
+            console.log("✓ Husky pre-commit configured at .husky/pre-commit");
+            return;
+        }
+        catch (error) {
+            console.error("Error configuring Husky pre-commit:", error);
+        }
+    }
+    if (!existsSync(packageJsonPath)) {
+        console.warn("Warning: package.json not found, cannot setup Git hooks");
+        return;
+    }
+    try {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+        if (!packageJson.scripts) {
+            packageJson.scripts = {};
+        }
+        packageJson.scripts["proteus:pre-commit"] = "proteus pre-commit";
+        if (!packageJson.husky)
+            packageJson.husky = {};
+        if (!packageJson.husky.hooks)
+            packageJson.husky.hooks = {};
+        packageJson.husky.hooks["pre-commit"] = "npm run proteus:pre-commit";
+        writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+        console.log("✓ Legacy Git hooks configured in package.json");
+        console.log("💡 Added pre-commit hook for automatic data-testid injection");
+    }
+    catch (error) {
+        console.error("Error setting up Git hooks:", error);
+    }
+}
+import { loadConfig } from "./config.js";

package/dist/parser.d.ts

@@ -0,0 +1,8 @@
+import { ProteuConfig } from "./types.js";
+interface InjectionResult {
+    code: string;
+    injectedCount: number;
+    error?: Error;
+}
+export declare function parseAndInject(filePath: string, code: string, config: ProteuConfig): InjectionResult;
+export {};

package/dist/parser.js

@@ -0,0 +1,402 @@
+import { parse } from "@babel/parser";
+import _traverse from "@babel/traverse";
+import * as t from "@babel/types";
+import { generateTestId, shortStableHash } from "./utils.js";
+// Normalize ESM/CJS interop from @babel/traverse
+const traverse = _traverse.default;
+// Check if we're inside a forwardRef function
+function isInsideForwardRef(path) {
+    let current = path;
+    while (current) {
+        // Check if parent is a CallExpression with forwardRef
+        if (current.isCallExpression() &&
+            current.node.callee &&
+            ((current.node.callee.type === "Identifier" && current.node.callee.name === "forwardRef") ||
+                (current.node.callee.type === "MemberExpression" &&
+                    current.node.callee.property &&
+                    current.node.callee.property.name === "forwardRef"))) {
+            return true;
+        }
+        current = current.parentPath;
+    }
+    return false;
+}
+// Check if element has ref={ref} attribute (forwarded ref)
+function hasForwardedRef(node) {
+    return node.attributes.some((attr) => t.isJSXAttribute(attr) &&
+        t.isJSXIdentifier(attr.name) &&
+        attr.name.name === "ref" &&
+        attr.value &&
+        t.isJSXExpressionContainer(attr.value) &&
+        t.isIdentifier(attr.value.expression) &&
+        attr.value.expression.name === "ref");
+}
+// Check if element has {...props} spread
+function hasPropsSpread(node) {
+    return node.attributes.some((attr) => t.isJSXSpreadAttribute(attr) &&
+        t.isIdentifier(attr.argument) &&
+        attr.argument.name === "props");
+}
+// Parse the source, traverse JSX, and inject data-testid attributes
+export function parseAndInject(filePath, code, config) {
+    let injectedCount = 0;
+    try {
+        const ast = parse(code, {
+            sourceType: "module",
+            plugins: ["jsx", "typescript"],
+            tokens: true,
+        });
+        const lines = code.split("\n");
+        let hasModifications = false;
+        let elementsFound = 0;
+        traverse(ast, {
+            JSXOpeningElement(path) {
+                elementsFound++;
+                const node = path.node;
+                if (!node.loc)
+                    return;
+                const lineNumber = node.loc.start.line;
+                const elementName = getElementName(node);
+                if (!elementName || isExcludedElement(elementName))
+                    return;
+                const hasTestId = node.attributes.some((attr) => t.isJSXAttribute(attr) &&
+                    t.isJSXIdentifier(attr.name) &&
+                    attr.name.name === "data-testid");
+                if (hasTestId)
+                    return;
+                // SKIP if this element is a reusable component wrapper:
+                // - Inside forwardRef
+                // - Has ref={ref}
+                // - Has {...props}
+                if (config.detectReusableComponents) {
+                    const insideForwardRef = isInsideForwardRef(path);
+                    const hasRef = hasForwardedRef(node);
+                    const hasSpread = hasPropsSpread(node);
+                    if (insideForwardRef && hasRef && hasSpread) {
+                        if (config.verbose) {
+                            console.log(`⏭️  Skipping reusable component wrapper at ${filePath}:${lineNumber}`);
+                        }
+                        return; // Skip this element, but continue processing others
+                    }
+                }
+                const mapInfo = getMapInfo(path);
+                const isDynamic = isInsideMapFunction(path);
+                const descriptor = getFunctionalDescriptor(node, path);
+                const componentPath = getComponentPath(path);
+                const classNameHint = getStaticClassName(node);
+                const siblingPos = getSiblingPosition(path, elementName);
+                const elementInfo = {
+                    elementName,
+                    fileName: filePath,
+                    lineNumber,
+                    key: mapInfo.key,
+                    index: mapInfo.index,
+                    isDynamic,
+                    descriptor,
+                    componentPath,
+                };
+                const built = buildAttributeForElement(config, elementInfo, mapInfo, classNameHint, siblingPos);
+                // Insert just before the closing token of the opening tag (supports multi-line and self-closing)
+                const endLineIndex = node.loc.end.line - 1;
+                const endCol = node.loc.end.column;
+                if (endLineIndex >= lines.length)
+                    return;
+                const endLine = lines[endLineIndex];
+                const isSelf = node.selfClosing === true;
+                const insertCol = isSelf ? Math.max(0, endCol - 2) : Math.max(0, endCol - 1);
+                lines[endLineIndex] =
+                    endLine.slice(0, insertCol) +
+                        ` ${built.attributeText}` +
+                        endLine.slice(insertCol);
+                hasModifications = true;
+                injectedCount++;
+            },
+        });
+        // Quiet by default; injector controls logging verbosity
+        return {
+            code: hasModifications ? lines.join("\n") : code,
+            injectedCount,
+        };
+    }
+    catch (error) {
+        return { code, injectedCount: 0, error: error };
+    }
+}
+// Helpers
+function getElementName(node) {
+    if (t.isJSXIdentifier(node.name)) {
+        return node.name.name;
+    }
+    else if (t.isJSXMemberExpression(node.name)) {
+        let name = "";
+        let current = node.name;
+        while (t.isJSXMemberExpression(current)) {
+            name =
+                "." +
+                    (t.isJSXIdentifier(current.property) ? current.property.name : "") +
+                    name;
+            current = current.object;
+        }
+        if (t.isJSXIdentifier(current)) {
+            name = current.name + name;
+        }
+        return name;
+    }
+    return "";
+}
+function isExcludedElement(elementName) {
+    // Self-closing, non-semantic tags we never instrument
+    const excluded = ["br", "hr", "meta", "link", "script", "style"];
+    return excluded.includes(elementName.toLowerCase());
+}
+function isInsideMapFunction(path) {
+    let current = path.parentPath;
+    while (current) {
+        if (current.isCallExpression() &&
+            current.node.callee.type === "MemberExpression" &&
+            current.node.callee.property.type === "Identifier" &&
+            current.node.callee.property.name === "map") {
+            return true;
+        }
+        current = current.parentPath;
+    }
+    return false;
+}
+// Returns map key/index info for elements within Array.prototype.map
+function getMapInfo(path) {
+    let current = path.parentPath;
+    while (current) {
+        if (current.isCallExpression() &&
+            current.node.callee.type === "MemberExpression" &&
+            current.node.callee.property.type === "Identifier" &&
+            current.node.callee.property.name === "map") {
+            // Try current opening element
+            if (path.isJSXOpeningElement()) {
+                const keyAttr = path.node.attributes.find((attr) => t.isJSXAttribute(attr) &&
+                    t.isJSXIdentifier(attr.name) &&
+                    attr.name.name === "key");
+                if (keyAttr && t.isJSXAttribute(keyAttr) && keyAttr.value) {
+                    if (t.isStringLiteral(keyAttr.value)) {
+                        return { key: keyAttr.value.value };
+                    }
+                    else if (t.isJSXExpressionContainer(keyAttr.value)) {
+                        const expr = keyAttr.value.expression;
+                        const keyExpr = expressionToText(expr);
+                        if (keyExpr)
+                            return { key: keyExpr };
+                    }
+                }
+            }
+            // Try nearest ancestor JSXElement's openingElement (e.g., wrapper with key)
+            let ancestor = path.parentPath;
+            while (ancestor) {
+                if (ancestor.node && ancestor.node.type === "JSXElement") {
+                    const opening = ancestor.node.openingElement;
+                    const keyAttr = opening.attributes.find((attr) => t.isJSXAttribute(attr) &&
+                        t.isJSXIdentifier(attr.name) &&
+                        attr.name.name === "key");
+                    if (keyAttr && keyAttr.value) {
+                        if (t.isStringLiteral(keyAttr.value)) {
+                            return { key: keyAttr.value.value };
+                        }
+                        if (t.isJSXExpressionContainer(keyAttr.value)) {
+                            const keyExpr = expressionToText(keyAttr.value.expression);
+                            if (keyExpr)
+                                return { key: keyExpr };
+                        }
+                    }
+                }
+                ancestor = ancestor.parentPath;
+            }
+            break;
+        }
+        current = current.parentPath;
+    }
+    return {};
+}
+// Stringify simple identifiers/member-expressions (e.g., item.id)
+function expressionToText(expr) {
+    if (!expr)
+        return undefined;
+    if (expr.type === "Identifier")
+        return expr.name;
+    if (expr.type === "MemberExpression") {
+        const obj = expressionToText(expr.object);
+        const prop = expr.property && expr.property.name ? expr.property.name : undefined;
+        if (obj && prop)
+            return `${obj}.${prop}`;
+    }
+    return undefined;
+}
+// Derive a semantic descriptor from attributes or children (e.g., placeholder, alt, or text)
+function getFunctionalDescriptor(node, path) {
+    // Prefer explicit semantics on common elements
+    const attrValue = (name) => {
+        const attr = node.attributes.find((a) => t.isJSXAttribute(a) && t.isJSXIdentifier(a.name) && a.name.name === name);
+        if (!attr || !attr.value)
+            return undefined;
+        if (t.isStringLiteral(attr.value))
+            return attr.value.value.toLowerCase();
+        return undefined;
+    };
+    const name = t.isJSXIdentifier(node.name) ? node.name.name.toLowerCase() : "";
+    if (name === "input") {
+        const placeholder = attrValue("placeholder");
+        if (placeholder)
+            return `input-${placeholder.replace(/\s+/g, "-")}`;
+        const type = attrValue("type");
+        if (type)
+            return `input-${type}`;
+    }
+    if (name === "img") {
+        const alt = attrValue("alt");
+        if (alt)
+            return `img-${alt.replace(/\s+/g, "-")}`;
+    }
+    // Infer from children (text or simple expressions)
+    const parentEl = path.parentPath && path.parentPath.parent;
+    if (parentEl && parentEl.type === "JSXElement") {
+        const children = parentEl.children || [];
+        for (const c of children) {
+            if (c.type === "JSXText") {
+                const text = c.value.trim();
+                if (text)
+                    return text.toLowerCase().replace(/\s+/g, "-");
+            }
+            if (c.type === "JSXExpressionContainer") {
+                const d = inferDescriptorFromExpression(c.expression);
+                if (d)
+                    return d;
+            }
+        }
+    }
+    return undefined;
+}
+// Resolve nearest component/function name to build an informative base id
+function getComponentPath(path) {
+    const names = [];
+    let current = path;
+    while (current) {
+        if (current.isFunctionDeclaration() || current.isFunctionExpression() || current.isArrowFunctionExpression()) {
+            const id = current.node.id;
+            if (id && id.name) {
+                names.unshift(id.name);
+                break;
+            }
+        }
+        if (current.isVariableDeclarator() && current.node.id.type === "Identifier") {
+            names.unshift(current.node.id.name);
+            break;
+        }
+        current = current.parentPath;
+    }
+    return names.length ? names : undefined;
+}
+// Read static className literals to refine role inference
+function getStaticClassName(node) {
+    const cls = node.attributes.find((a) => t.isJSXAttribute(a) && t.isJSXIdentifier(a.name) && a.name.name === "className");
+    if (!cls || !cls.value)
+        return undefined;
+    if (t.isStringLiteral(cls.value))
+        return cls.value.value;
+    return undefined;
+}
+// If multiple identical sibling tags exist, return this element's position (1-based)
+function getSiblingPosition(path, elementName) {
+    const parent = path.parentPath && path.parentPath.parent;
+    if (!parent || parent.type !== 'JSXElement')
+        return undefined;
+    const children = parent.children || [];
+    let indices = [];
+    for (let i = 0; i < children.length; i++) {
+        const c = children[i];
+        if (c.type === 'JSXElement') {
+            const open = c.openingElement;
+            const name = getElementName(open);
+            if (name === elementName)
+                indices.push(i);
+        }
+    }
+    if (indices.length <= 1)
+        return undefined;
+    const myIdx = children.findIndex((c) => c === path.parentPath.node);
+    const pos = indices.indexOf(myIdx);
+    if (pos === -1)
+        return undefined;
+    return { index: pos, total: indices.length };
+}
+// Extract a concise name from simple expressions inside JSX
+function inferDescriptorFromExpression(expr) {
+    if (!expr)
+        return undefined;
+    if (expr.type === "MemberExpression") {
+        const prop = expr.property;
+        if (prop && prop.type === "Identifier")
+            return prop.name.toLowerCase();
+    }
+    if (expr.type === "CallExpression") {
+        for (const arg of expr.arguments || []) {
+            const d = inferDescriptorFromExpression(arg);
+            if (d)
+                return d;
+        }
+    }
+    return undefined;
+}
+// Map raw tag name to a coarse role
+function mapRole(tag) {
+    const name = tag.toLowerCase();
+    if (name === "div" || name === "section" || name === "article" || name === "span")
+        return "container";
+    if (name === "img")
+        return "image";
+    return name;
+}
+// Build the data-testid attribute text based on strategy, map context, sibling index, and descriptors
+function buildAttributeForElement(config, info, mapInfo, classNameHint, siblingPos) {
+    if (config.strategy === "functional") {
+        const component = (info.componentPath && info.componentPath[0])
+            ? info.componentPath[0].toLowerCase()
+            : info.fileName.replace(/\.(tsx|jsx|ts|js)$/, "").toLowerCase();
+        let role = mapRole(info.elementName);
+        if (classNameHint) {
+            if (/\bitem\b/.test(classNameHint))
+                role = "item";
+            else if (/\bproduct-list\b/.test(classNameHint))
+                role = "list";
+            else if (/\bheader\b/.test(classNameHint))
+                role = "header";
+            else if (/\badd-to-cart\b/.test(classNameHint))
+                role = "button";
+        }
+        const descriptor = info.descriptor ? info.descriptor.replace(/\s+/g, "-") : undefined;
+        // Add sibling index when multiple identical tags under same parent
+        const siblingIndexPart = siblingPos && siblingPos.total > 1 ? String(siblingPos.index + 1) : undefined;
+        const base = ["qa_" + component, role, siblingIndexPart, descriptor]
+            .filter(Boolean)
+            .join("_");
+        // In functional strategy, always append map key for elements inside map
+        if (info.isDynamic && mapInfo && mapInfo.key) {
+            if (/^[a-zA-Z_][a-zA-Z0-9_]*\.[a-zA-Z_][a-zA-Z0-9_]*$/.test(mapInfo.key)) {
+                const exprAttr = `data-testid={\`${base}_\${${mapInfo.key}}\`}`;
+                return { attributeText: exprAttr, idForRecord: `${base}_${mapInfo.key}` };
+            }
+            return { attributeText: `data-testid="${base}_${mapInfo.key}"`, idForRecord: `${base}_${mapInfo.key}` };
+        }
+        if (info.isDynamic && typeof mapInfo.index === "number") {
+            return { attributeText: `data-testid="${base}_${mapInfo.index}"`, idForRecord: `${base}_${mapInfo.index}` };
+        }
+        // Ensure uniqueness for repeated tags without descriptors
+        const unique = shortStableHash(`${info.fileName}:${info.lineNumber}:${role}:${descriptor || ''}`);
+        return { attributeText: `data-testid="${base}_${unique}"`, idForRecord: `${base}_${unique}` };
+    }
+    // safe-hash fallback
+    const id = generateTestId(config, info);
+    if (info.isDynamic && mapInfo && mapInfo.key) {
+        if (/^[a-zA-Z_][a-zA-Z0-9_]*\.[a-zA-Z_][a-zA-Z0-9_]*$/.test(mapInfo.key)) {
+            return { attributeText: `data-testid={\`${id}_\${${mapInfo.key}}\`}`, idForRecord: `${id}_${mapInfo.key}` };
+        }
+        return { attributeText: `data-testid="${id}_${mapInfo.key}"`, idForRecord: `${id}_${mapInfo.key}` };
+    }
+    return { attributeText: `data-testid="${id}"`, idForRecord: id };
+}

package/dist/tool-executor.d.ts

@@ -0,0 +1,15 @@
+interface ProteusCLIArgs {
+    files?: string[];
+    include?: string[];
+    exclude?: string[];
+    strategy?: "safe-hash" | "functional";
+    json_output: boolean;
+}
+/**
+ * Executes the Proteus CLI as a child process and returns the parsed JSON output.
+ * This function is designed to be universally compatible with any agent.
+ * @param args - The arguments to pass to the 'proteus inject' command.
+ * @returns A promise that resolves with the JSON output from the CLI.
+ */
+export declare function executeProteusCLI(args: ProteusCLIArgs): Promise<any>;
+export {};

package/dist/tool-executor.js

@@ -0,0 +1,52 @@
+import { spawn } from "child_process";
+/**
+ * Executes the Proteus CLI as a child process and returns the parsed JSON output.
+ * This function is designed to be universally compatible with any agent.
+ * @param args - The arguments to pass to the 'proteus inject' command.
+ * @returns A promise that resolves with the JSON output from the CLI.
+ */
+export async function executeProteusCLI(args) {
+    return new Promise((resolve, reject) => {
+        const cliArgs = ["inject"];
+        // Ensure json_output is always true for tool calling
+        if (args.json_output) {
+            cliArgs.push("--json");
+        }
+        else {
+            reject(new Error("The 'json_output' argument must be true for tool calling."));
+            return;
+        }
+        if (args.files && args.files.length > 0)
+            cliArgs.push(...args.files);
+        if (args.include && args.include.length > 0)
+            cliArgs.push("--include", ...args.include);
+        if (args.exclude && args.exclude.length > 0)
+            cliArgs.push("--exclude", ...args.exclude);
+        if (args.strategy)
+            cliArgs.push("--strategy", args.strategy);
+        const proteusProcess = spawn("proteus", cliArgs, { shell: true });
+        let stdoutData = "";
+        let stderrData = "";
+        proteusProcess.stdout.on("data", (data) => {
+            stdoutData += data.toString();
+        });
+        proteusProcess.stderr.on("data", (data) => {
+            stderrData += data.toString();
+        });
+        proteusProcess.on("close", (code) => {
+            if (code !== 0) {
+                return reject(new Error(`Proteus CLI exited with code ${code}: ${stderrData}`));
+            }
+            try {
+                const jsonOutput = JSON.parse(stdoutData);
+                resolve(jsonOutput);
+            }
+            catch (error) {
+                reject(new Error(`Failed to parse Proteus CLI JSON output: ${error}`));
+            }
+        });
+        proteusProcess.on("error", (err) => {
+            reject(new Error(`Failed to start Proteus CLI process: ${err.message}`));
+        });
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,21 @@
+export interface ProteuConfig {
+    injectOnCommit?: boolean;
+    injectOnSave?: boolean;
+    include?: string[];
+    exclude?: string[];
+    strategy?: "safe-hash" | "functional";
+    verbose?: boolean;
+    json?: boolean;
+    detectReusableComponents?: boolean;
+    autoExcludePatterns?: string[];
+}
+export interface ElementInfo {
+    elementName: string;
+    fileName: string;
+    lineNumber: number;
+    key?: string;
+    index?: number;
+    isDynamic?: boolean;
+    componentPath?: string[];
+    descriptor?: string;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+// Lean types only; remove unused records

package/dist/utils.d.ts

@@ -0,0 +1,4 @@
+import { ElementInfo, ProteuConfig } from "./types.js";
+export declare function generateTestId(config: ProteuConfig, info: ElementInfo): string;
+export declare function shortStableHash(input: string): string;
+export declare function normalizePath(path: string): string;