@toolbaux/guardian 0.1.0

package/dist/adapters/java-adapter.js

@@ -0,0 +1,122 @@
+import Java from "tree-sitter-java";
+import Parser from "tree-sitter";
+function text(node) {
+    return node ? node.text : "";
+}
+export const JavaAdapter = {
+    name: "Java Spring Boot Adapter",
+    language: Java,
+    fileExtensions: [".java"],
+    queries: {
+        // Endpoints: Methods annotated with @*Mapping (e.g., @GetMapping, @PostMapping)
+        endpoints: `(method_declaration (modifiers (annotation name: (identifier) @mapping (#match? @mapping "Mapping$"))) name: (identifier) @handler) @endpoint`,
+        // Models: Classes annotated with @Entity, @Table, @Document (MongoDB), etc.
+        models: `(class_declaration (modifiers (annotation name: (identifier) @annot (#match? @annot "Entity|Table|Document|MappedSuperclass"))) name: (identifier) @name) @model`,
+        // Tests: Methods annotated with @Test
+        tests: `
+      (method_declaration
+        (modifiers (annotation name: (identifier) @test_annot (#match? @test_annot "Test")))
+        name: (identifier) @test_name
+      )
+    `
+    },
+    extract(file, source, root) {
+        const endpoints = [];
+        const models = [];
+        const components = []; // Not heavily used in backend Java MVCs
+        const tests = [];
+        const epQuery = new Parser.Query(this.language, this.queries.endpoints);
+        const mdQuery = new Parser.Query(this.language, this.queries.models);
+        // Extract Spring Boot Endpoints
+        const epMatches = epQuery.matches(root);
+        for (const match of epMatches) {
+            const mappingNode = match.captures.find(c => c.name === "mapping")?.node;
+            const handlerNode = match.captures.find(c => c.name === "handler")?.node;
+            const endpointNode = match.captures.find(c => c.name === "endpoint")?.node;
+            if (mappingNode && handlerNode && endpointNode) {
+                const mappingType = text(mappingNode); // e.g. "GetMapping"
+                const method = mappingType.replace("Mapping", "").toUpperCase() || "ANY";
+                const handler = text(handlerNode);
+                // Find route path: @GetMapping("/api/users") -> "/api/users"
+                let routePath = "/";
+                const annotationNode = mappingNode.parent;
+                if (annotationNode) {
+                    const strMatch = text(annotationNode).match(/\\"([^\\"]+)\\"/);
+                    if (strMatch)
+                        routePath = strMatch[1];
+                }
+                // Basic payload schemas from parameters
+                let requestSchema = null;
+                let responseSchema = null;
+                // Try to find return type for response schema
+                const typeNode = endpointNode.childForFieldName("type");
+                if (typeNode)
+                    responseSchema = text(typeNode);
+                // Try to find @RequestBody parameter for request schema
+                const paramsNode = endpointNode.childForFieldName("parameters");
+                if (paramsNode) {
+                    for (let i = 0; i < paramsNode.childCount; i++) {
+                        const child = paramsNode.child(i);
+                        if (!child)
+                            continue;
+                        if (text(child).includes("@RequestBody")) {
+                            const typeChild = child.childForFieldName("type");
+                            if (typeChild)
+                                requestSchema = text(typeChild);
+                        }
+                    }
+                }
+                endpoints.push({
+                    method,
+                    path: routePath,
+                    handler,
+                    file,
+                    request_schema: requestSchema,
+                    response_schema: responseSchema,
+                    service_calls: []
+                });
+            }
+        }
+        // Extract JPA Models
+        const mdMatches = mdQuery.matches(root);
+        for (const match of mdMatches) {
+            const nameNode = match.captures.find(c => c.name === "name")?.node;
+            const modelNode = match.captures.find(c => c.name === "model")?.node;
+            if (nameNode && modelNode) {
+                const name = text(nameNode);
+                const fields = [];
+                const relationships = [];
+                // Scan class body for fields
+                const bodyNode = modelNode.childForFieldName("body");
+                if (bodyNode) {
+                    for (let i = 0; i < bodyNode.childCount; i++) {
+                        const child = bodyNode.child(i);
+                        if (!child)
+                            continue;
+                        if (child.type === "field_declaration") {
+                            const declaredNode = child.childForFieldName("declarator");
+                            if (declaredNode) {
+                                const fieldName = declaredNode.childForFieldName("name");
+                                const fText = text(fieldName);
+                                if (fText)
+                                    fields.push(fText);
+                                // Check annotations on the field for JPA Relations
+                                if (text(child).includes("@OneToMany") || text(child).includes("@ManyToOne") || text(child).includes("@ManyToMany") || text(child).includes("@OneToOne")) {
+                                    relationships.push(fText);
+                                }
+                            }
+                        }
+                    }
+                }
+                models.push({
+                    name,
+                    file,
+                    framework: "jpa-hibernate",
+                    fields,
+                    relationships
+                });
+            }
+        }
+        return { endpoints, models, components, tests };
+    }
+};

package/dist/adapters/python-adapter.js

@@ -0,0 +1,183 @@
+import Python from "tree-sitter-python";
+import Parser from "tree-sitter";
+// Utility to recursively find children of a certain type
+function findChildren(node, type) {
+    const results = [];
+    if (node.type === type)
+        results.push(node);
+    for (const child of node.namedChildren) {
+        results.push(...findChildren(child, type));
+    }
+    return results;
+}
+export const PythonAdapter = {
+    name: "python",
+    language: Python,
+    fileExtensions: [".py"],
+    queries: {
+        endpoints: `
+      (decorated_definition (decorator) @decorator definition: (function_definition name: (identifier) @handler))
+      (call function: (identifier) @func_name (#match? @func_name "^path$|^re_path$")) @django_route
+    `,
+        models: `
+      (class_definition name: (identifier) @name body: (block))
+    `,
+        tests: `
+      (class_definition name: (identifier) @suite_name (#match? @suite_name "^Test"))
+      (function_definition name: (identifier) @test_name (#match? @test_name "^test_"))
+    `
+    },
+    extract(file, source, root) {
+        const endpoints = [];
+        const models = [];
+        const components = [];
+        const tests = [];
+        // Helper to get text
+        const text = (n) => source.substring(n.startIndex, n.endIndex);
+        // 1. Process Endpoints
+        const epQuery = new Parser.Query(this.language, this.queries.endpoints);
+        const epMatches = epQuery.matches(root);
+        for (const match of epMatches) {
+            let isFastAPI = false;
+            let isDjango = false;
+            let method = "GET";
+            let routePath = "";
+            let handler = "";
+            let decoratorNode = null;
+            let handlerNode = null;
+            for (const cap of match.captures) {
+                if (cap.name === "decorator")
+                    decoratorNode = cap.node;
+                if (cap.name === "handler") {
+                    handlerNode = cap.node;
+                    handler = text(cap.node);
+                }
+                if (cap.name === "django_route")
+                    isDjango = true;
+            }
+            if (decoratorNode) {
+                const decText = text(decoratorNode);
+                if (decText.includes(".get(") || decText.includes(".post(") || decText.includes(".put(") || decText.includes(".delete(") || decText.includes(".patch(")) {
+                    isFastAPI = true;
+                    if (decText.includes(".post("))
+                        method = "POST";
+                    else if (decText.includes(".put("))
+                        method = "PUT";
+                    else if (decText.includes(".delete("))
+                        method = "DELETE";
+                    else if (decText.includes(".patch("))
+                        method = "PATCH";
+                    else
+                        method = "GET";
+                    const strMatch = decText.match(/['"](.*?)['"]/);
+                    routePath = strMatch ? strMatch[1] : "";
+                }
+            }
+            if (!isFastAPI && !isDjango)
+                continue; // Not an endpoint
+            const service_calls = [];
+            let request_schema = null;
+            let response_schema = null;
+            // Deep Intra-node inspection
+            if (handlerNode && handlerNode.parent) {
+                // Find request schema from arguments
+                const paramsNode = handlerNode.parent.childForFieldName("parameters");
+                if (paramsNode) {
+                    for (const param of paramsNode.namedChildren) {
+                        if (param.type === "typed_parameter") {
+                            const typeNode = param.childForFieldName("type");
+                            if (typeNode) {
+                                const t = text(typeNode);
+                                if (t !== "Request" && t !== "Response" && t !== "Session" && t !== "Depends") {
+                                    request_schema = t;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+                // Find service calls
+                const bodyNode = handlerNode.parent.childForFieldName("body");
+                if (bodyNode) {
+                    const calls = findChildren(bodyNode, "call");
+                    for (const call of calls) {
+                        const funcNode = call.childForFieldName("function");
+                        if (funcNode) {
+                            const fname = text(funcNode);
+                            if (fname !== "Depends")
+                                service_calls.push(fname);
+                        }
+                    }
+                }
+            }
+            // Find response schema from decorator
+            if (decoratorNode) {
+                const decText = text(decoratorNode);
+                const rmMatch = decText.match(/response_model=([a-zA-Z0-9_]+)/);
+                if (rmMatch)
+                    response_schema = rmMatch[1];
+            }
+            endpoints.push({
+                file,
+                method,
+                path: routePath,
+                handler,
+                request_schema,
+                response_schema,
+                service_calls: Array.from(new Set(service_calls))
+            });
+        }
+        // 2. Process Models
+        const mdQuery = new Parser.Query(this.language, this.queries.models);
+        const mdMatches = mdQuery.matches(root);
+        for (const match of mdMatches) {
+            let name = "";
+            let classNode = null;
+            for (const cap of match.captures) {
+                if (cap.name === "name") {
+                    name = text(cap.node);
+                    classNode = cap.node.parent;
+                }
+            }
+            if (!classNode)
+                continue;
+            const superclasses = classNode.childForFieldName("superclasses");
+            const baseText = superclasses ? text(superclasses) : "";
+            let framework = "unknown";
+            if (baseText.includes("BaseModel"))
+                framework = "pydantic";
+            else if (baseText.includes("Model"))
+                framework = "django";
+            else if (baseText.includes("Base"))
+                framework = "sqlalchemy";
+            if (framework === "unknown")
+                continue; // Not a recognized model
+            const fields = [];
+            const relationships = [];
+            const body = classNode.childForFieldName("body");
+            if (body) {
+                // Collect class-level assignments
+                const assignments = findChildren(body, "expression_statement")
+                    .map(e => e.namedChildren.find(c => c.type === "assignment" || c.type === "type" || c.type === "typed_parameter") || e);
+                for (const stmt of assignments) {
+                    const stmtText = text(stmt);
+                    const matchField = stmtText.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\\s*[:=]/);
+                    if (matchField) {
+                        fields.push(matchField[1]);
+                        if (stmtText.includes("ForeignKey") || stmtText.includes("relationship(") || stmtText.includes("ManyTo")) {
+                            relationships.push(matchField[1]);
+                        }
+                    }
+                }
+            }
+            models.push({
+                name,
+                file,
+                framework,
+                fields,
+                relationships
+            });
+        }
+        return { endpoints, models, components, tests };
+    }
+};

package/dist/adapters/runner.js

@@ -0,0 +1,69 @@
+import Parser from "tree-sitter";
+export function runAdapter(adapter, file, source) {
+    const parser = new Parser();
+    parser.setLanguage(adapter.language);
+    const tree = parser.parse(source);
+    if (adapter.extract) {
+        return adapter.extract(file, source, tree.rootNode);
+    }
+    const endpoints = [];
+    const models = [];
+    const components = [];
+    const tests = [];
+    if (adapter.queries.endpoints) {
+        const query = new Parser.Query(adapter.language, adapter.queries.endpoints);
+        const matches = query.matches(tree.rootNode);
+        for (const match of matches) {
+            let method = "GET";
+            let path = "";
+            let handler = "";
+            for (const capture of match.captures) {
+                const text = source.substring(capture.node.startIndex, capture.node.endIndex);
+                if (capture.name === "method")
+                    method = text.replace(/['"]/g, "");
+                if (capture.name === "path")
+                    path = text.replace(/['"]/g, "");
+                if (capture.name === "handler")
+                    handler = text;
+            }
+            if (handler) {
+                endpoints.push({ file, method, path, handler, service_calls: [] });
+            }
+        }
+    }
+    if (adapter.queries.models) {
+        const query = new Parser.Query(adapter.language, adapter.queries.models);
+        const matches = query.matches(tree.rootNode);
+        for (const match of matches) {
+            let name = "";
+            for (const capture of match.captures) {
+                if (capture.name === "name") {
+                    name = source.substring(capture.node.startIndex, capture.node.endIndex);
+                }
+            }
+            if (name) {
+                models.push({ name, file, framework: "unknown", fields: [], relationships: [] });
+            }
+        }
+    }
+    if (adapter.queries.tests) {
+        const query = new Parser.Query(adapter.language, adapter.queries.tests);
+        const matches = query.matches(tree.rootNode);
+        for (const match of matches) {
+            let test_name = "";
+            let suite_name = null;
+            for (const capture of match.captures) {
+                if (capture.name === "test_name") {
+                    test_name = source.substring(capture.node.startIndex, capture.node.endIndex).replace(/['"]/g, "");
+                }
+                if (capture.name === "suite_name") {
+                    suite_name = source.substring(capture.node.startIndex, capture.node.endIndex).replace(/['"]/g, "");
+                }
+            }
+            if (test_name) {
+                tests.push({ file, test_name, suite_name });
+            }
+        }
+    }
+    return { endpoints, models, components, tests };
+}

package/dist/adapters/types.js

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

package/dist/adapters/typescript-adapter.js

@@ -0,0 +1,179 @@
+import TypeScript from "tree-sitter-typescript";
+import Parser from "tree-sitter";
+import path from "node:path";
+// Utility to recursively find children of a certain type
+function findChildren(node, type) {
+    const results = [];
+    if (node.type === type)
+        results.push(node);
+    for (const child of node.namedChildren) {
+        results.push(...findChildren(child, type));
+    }
+    return results;
+}
+export const TypeScriptAdapter = {
+    name: "typescript",
+    language: TypeScript.tsx, // We use the TSX grammar to capture both TS and TSX seamlessly
+    fileExtensions: [".ts", ".tsx", ".js", ".jsx"],
+    queries: {
+        // Endpoints: Express "app.get('/route', (req, res) => {})" or NextJS Route Handlers
+        endpoints: `
+      (call_expression
+        function: (member_expression
+          object: (identifier) @app_instance
+          property: (property_identifier) @method (#match? @method "^get$|^post$|^put$|^delete$|^patch|use$")
+        )
+        arguments: (arguments (string (string_fragment) @path))
+      ) @express_route
+
+      (export_statement
+        declaration: (lexical_declaration
+          (variable_declarator
+            name: (identifier) @method (#match? @method "^GET$|^POST$|^PUT$|^DELETE$|^PATCH$")
+            value: (arrow_function)
+          )
+        )
+      ) @next_route
+    `,
+        // Components: React functions returning JSX, or default exports
+        components: `
+      (function_declaration
+        name: (identifier) @name
+        parameters: (formal_parameters)? @params
+      ) @react_component
+    `,
+        // Tests: Jest/Vitest describe and it/test blocks
+        tests: `
+      (call_expression
+        function: (identifier) @suite_func (#match? @suite_func "^describe$")
+        arguments: (arguments (string (string_fragment) @suite_name))
+      )
+      (call_expression
+        function: (identifier) @test_func (#match? @test_func "^it$|^test$")
+        arguments: (arguments (string (string_fragment) @test_name))
+      )
+    `
+    },
+    extract(file, source, root) {
+        const endpoints = [];
+        const models = [];
+        const components = [];
+        const tests = [];
+        const text = (n) => source.substring(n.startIndex, n.endIndex);
+        const isNextJS = source.includes("next/server") || source.includes("next/router") || file.includes("app/") || file.includes("pages/");
+        // 1. Process Endpoints
+        const epQuery = new Parser.Query(this.language, this.queries.endpoints);
+        const epMatches = epQuery.matches(root);
+        for (const match of epMatches) {
+            let isExpress = false;
+            let isNextRoute = false;
+            let method = "GET";
+            let routePath = "";
+            for (const cap of match.captures) {
+                if (cap.name === "express_route")
+                    isExpress = true;
+                if (cap.name === "next_route")
+                    isNextRoute = true;
+                if (cap.name === "method")
+                    method = text(cap.node).toUpperCase();
+                if (cap.name === "path")
+                    routePath = text(cap.node);
+            }
+            if (isNextRoute && isNextJS) {
+                // NextJS App Router infers path from the filesystem
+                const parts = file.split("app/");
+                if (parts.length > 1) {
+                    routePath = "/" + path.dirname(parts[1]);
+                    if (routePath.endsWith("/."))
+                        routePath = routePath.slice(0, -2);
+                }
+            }
+            if (isExpress || isNextRoute) {
+                endpoints.push({
+                    file,
+                    method,
+                    path: routePath || "/",
+                    handler: isNextRoute ? method : "anonymous_handler",
+                    request_schema: null,
+                    response_schema: null,
+                    service_calls: []
+                });
+            }
+        }
+        // 2. Process React Components
+        const compQuery = new Parser.Query(this.language, this.queries.components);
+        const compMatches = compQuery.matches(root);
+        for (const match of compMatches) {
+            let name = path.basename(file, path.extname(file)); // Fallback name
+            let export_kind = "named";
+            let propsNode = null;
+            let id = "";
+            for (const cap of match.captures) {
+                if (cap.name === "name")
+                    name = text(cap.node);
+                if (cap.name === "default_react_component")
+                    export_kind = "default";
+                if (cap.name === "params")
+                    propsNode = cap.node;
+            }
+            id = file + "#" + name;
+            const props = [];
+            // Extract React Prop definitions if typed
+            if (propsNode) {
+                const firstParam = propsNode.namedChildren[0];
+                if (firstParam && firstParam.type === "required_parameter") {
+                    const pattern = firstParam.childForFieldName("pattern");
+                    const typeAnn = firstParam.childForFieldName("type");
+                    if (pattern && pattern.type === "object_pattern") {
+                        // Destructured props { title, className }
+                        for (const prop of pattern.namedChildren) {
+                            if (prop.type === "shorthand_property_identifier") {
+                                props.push({ name: text(prop), type: "any" });
+                            }
+                        }
+                    }
+                    if (typeAnn) {
+                        // If it's a typed parameter (props: ItemProps)
+                        const t = text(typeAnn).replace(/^:\\s*/, "");
+                        if (props.length === 0) {
+                            props.push({ name: "props", type: t });
+                        }
+                        else {
+                            props.forEach(p => p.type = t); // Assign the generic interface type
+                        }
+                    }
+                }
+            }
+            components.push({
+                id,
+                name,
+                file,
+                export_kind,
+                props
+            });
+        }
+        // 3. Process Tests
+        if (this.queries.tests) {
+            const testsQuery = new Parser.Query(this.language, this.queries.tests);
+            const testsMatches = testsQuery.matches(root);
+            let currentSuite = null;
+            for (const match of testsMatches) {
+                let test_name = "";
+                let suite_name = null;
+                for (const cap of match.captures) {
+                    if (cap.name === "suite_name")
+                        suite_name = text(cap.node);
+                    if (cap.name === "test_name")
+                        test_name = text(cap.node);
+                }
+                // Very basic tracking: if we see a describe block, we remember its name.
+                if (suite_name)
+                    currentSuite = suite_name;
+                if (test_name) {
+                    tests.push({ file, test_name, suite_name: currentSuite });
+                }
+            }
+        }
+        return { endpoints, models, components, tests };
+    }
+};

package/dist/benchmarking/framework.js

@@ -0,0 +1,91 @@
+/**
+ * SPECGUARD BENCHMARKING FRAMEWORK
+ *
+ * Shared framework for measuring:
+ * - Token consumption (input/output)
+ * - Implementation time
+ * - Test coverage
+ * - Hallucination risk
+ * - Code quality
+ */
+/**
+ * Calculate costs using accurate GPT-4o pricing
+ */
+export function calculateCost(inputTokens, outputTokens) {
+    const INPUT_PRICE = 5 / 1_000_000; // $5/1M tokens
+    const OUTPUT_PRICE = 15 / 1_000_000; // $15/1M tokens (3x more expensive)
+    return inputTokens * INPUT_PRICE + outputTokens * OUTPUT_PRICE;
+}
+/**
+ * Calculate token reduction percentage
+ */
+export function calculateTokenReduction(withContext, withoutContext) {
+    return ((withoutContext - withContext) / withoutContext) * 100;
+}
+/**
+ * Calculate cost reduction percentage
+ */
+export function calculateCostReduction(withContext, withoutContext) {
+    return ((withoutContext - withContext) / withoutContext) * 100;
+}
+/**
+ * Calculate time reduction percentage
+ */
+export function calculateTimeReduction(withContext, withoutContext) {
+    return ((withoutContext - withContext) / withoutContext) * 100;
+}
+/**
+ * Build comparative metrics table
+ */
+export function buildComparativeTable(features) {
+    const rows = features.map((f) => ({
+        feature: f.featureName,
+        tokenReduction: calculateTokenReduction(f.withContext.totalTokens, f.withoutContext.totalTokens),
+        costReduction: calculateTokenReduction(f.withContext.apiCost, f.withoutContext.apiCost),
+        timeReduction: calculateTimeReduction(f.withContext.implementationTimeMinutes, f.withoutContext.implementationTimeMinutes),
+        hallucReduction: f.withoutContext.hallucationRiskPercent - f.withContext.hallucationRiskPercent,
+    }));
+    return {
+        rows,
+        averageTokenReduction: rows.reduce((sum, r) => sum + r.tokenReduction, 0) / rows.length,
+        averageCostReduction: rows.reduce((sum, r) => sum + r.costReduction, 0) / rows.length,
+        averageTimeReduction: rows.reduce((sum, r) => sum + r.timeReduction, 0) / rows.length,
+        averageHallucReduction: rows.reduce((sum, r) => sum + r.hallucReduction, 0) / rows.length,
+    };
+}
+/**
+ * Generate markdown benchmark report
+ */
+export function generateBenchmarkMarkdown(agg) {
+    let md = "# SPECGUARD MULTI-FEATURE BENCHMARK REPORT\n\n";
+    md += `**Generated:** ${new Date().toISOString()}\n`;
+    md += `**Features Tested:** ${agg.features.length}\n\n`;
+    // Summary
+    md += "## Executive Summary\n\n";
+    md += `- **Total Tokens Saved:** ${(agg.summary.totalTokensSaved / 1000).toFixed(1)}K tokens (${calculateTokenReduction(agg.summary.totalTokensSaved, agg.summary.totalTokensSaved + (agg.summary.totalTokensSaved * 9)).toFixed(1)}%)\\n`;
+    md += `- **Total Cost Saved:** $${agg.summary.totalCostSaved.toFixed(2)}\\n`;
+    md += `- **Total Time Saved:** ${agg.summary.totalTimeSaved.toFixed(1)} hours\\n`;
+    md += `- **Avg Hallucination Reduction:** ${agg.summary.averageHallucinationReduction.toFixed(1)}pp\\n\n`;
+    // Per-feature breakdown
+    md += "## Per-Feature Results\n\n";
+    for (const feature of agg.features) {
+        md += `### ${feature.featureName} (Feature ${feature.featureId})\n`;
+        md += `${feature.description}\n\n`;
+        md += `| Metric | WITH Context | WITHOUT Context | Savings |\\n`;
+        md += `|--------|--------------|-----------------|---------|\\n`;
+        md += `| Tokens | ${feature.withContext.totalTokens.toLocaleString()} | ${feature.withoutContext.totalTokens.toLocaleString()} | ${calculateTokenReduction(feature.withContext.totalTokens, feature.withoutContext.totalTokens).toFixed(1)}% |\\n`;
+        md += `| Cost | $${feature.withContext.apiCost.toFixed(3)} | $${feature.withoutContext.apiCost.toFixed(3)} | ${calculateCostReduction(feature.withContext.apiCost, feature.withoutContext.apiCost).toFixed(1)}% |\\n`;
+        md += `| Time | ${feature.withContext.implementationTimeMinutes.toFixed(1)}h | ${feature.withoutContext.implementationTimeMinutes.toFixed(1)}h | ${calculateTimeReduction(feature.withContext.implementationTimeMinutes, feature.withoutContext.implementationTimeMinutes).toFixed(1)}% |\\n`;
+        md += `| Hallucinations | ${feature.withContext.hallucationRiskPercent.toFixed(1)}% | ${feature.withoutContext.hallucationRiskPercent.toFixed(1)}% | ${(feature.withoutContext.hallucationRiskPercent - feature.withContext.hallucationRiskPercent).toFixed(1)}pp |\\n`;
+        md += `| Tests | ${feature.withContext.testsPassing}/${feature.withContext.testsTotal} | - | - |\\n\n`;
+    }
+    return md;
+}
+export default {
+    calculateCost,
+    calculateTokenReduction,
+    calculateCostReduction,
+    calculateTimeReduction,
+    buildComparativeTable,
+    generateBenchmarkMarkdown,
+};