agentic-lang 0.2.0

package/dist/property-tests/generator-enhanced.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * Enhanced Property-based test generator
+ * Automatically generates fast-check tests with 10+ inference rules
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnhancedPropertyTestGenerator = void 0;
+class EnhancedPropertyTestGenerator {
+    generate(ast) {
+        const tests = [];
+        for (const node of ast) {
+            if (node.type === 'FunctionDeclaration') {
+                const func = node;
+                const funcTests = this.generateForFunction(func);
+                if (funcTests) {
+                    tests.push(funcTests);
+                }
+            }
+        }
+        return tests;
+    }
+    generateForFunction(func) {
+        const properties = this.inferProperties(func);
+        if (properties.length === 0) {
+            return null;
+        }
+        const testCode = this.generateTestCode(func, properties);
+        return {
+            functionName: func.name,
+            properties,
+            testCode,
+        };
+    }
+    inferProperties(func) {
+        const properties = [];
+        // Extract explicit @property annotations
+        for (const annotation of func.annotations) {
+            if (annotation.name === 'property') {
+                properties.push({
+                    name: annotation.args.name || annotation.args.arg0 || 'custom_property',
+                    description: annotation.args.description || annotation.args.arg1 || '',
+                    testFunction: 'typeof result !== "undefined"',
+                });
+            }
+        }
+        // Infer from return type
+        if (func.returnType) {
+            properties.push(...this.inferFromReturnType(func.returnType));
+        }
+        // Infer from parameters (10+ rules)
+        properties.push(...this.inferFromParameters(func));
+        // Infer from function name
+        properties.push(...this.inferFromFunctionName(func));
+        // Infer from confidence level
+        properties.push(...this.inferFromConfidence(func));
+        return properties;
+    }
+    inferFromReturnType(returnType) {
+        const properties = [];
+        // Result<T, E> should handle both cases
+        if (returnType.kind === 'result') {
+            properties.push({
+                name: 'handles_success_case',
+                description: 'Function can return successful result',
+                testFunction: 'result.ok === true || result.ok === false',
+            });
+        }
+        // Never returns null/undefined
+        properties.push({
+            name: 'never_returns_null',
+            description: 'Function never returns null or undefined',
+            testFunction: 'result !== null && result !== undefined',
+        });
+        return properties;
+    }
+    inferFromParameters(func) {
+        const properties = [];
+        const params = func.params;
+        // Check for string parameters
+        const hasStringParam = params.some(p => p.typeAnnotation && p.typeAnnotation.value === 'string');
+        if (hasStringParam) {
+            properties.push({
+                name: 'handles_empty_string',
+                description: 'Function handles empty string input',
+                testFunction: 'typeof result !== "undefined"',
+            });
+            properties.push({
+                name: 'handles_whitespace',
+                description: 'Function handles whitespace-only strings',
+                testFunction: 'typeof result !== "undefined"',
+            });
+            properties.push({
+                name: 'handles_unicode',
+                description: 'Function handles Unicode/emoji characters',
+                testFunction: 'typeof result !== "undefined"',
+            });
+        }
+        // Check for number parameters
+        const hasNumberParam = params.some(p => p.typeAnnotation && p.typeAnnotation.value === 'number');
+        if (hasNumberParam) {
+            properties.push({
+                name: 'handles_zero',
+                description: 'Function handles zero input',
+                testFunction: 'typeof result !== "undefined"',
+            });
+            properties.push({
+                name: 'handles_negative',
+                description: 'Function handles negative numbers',
+                testFunction: 'typeof result !== "undefined"',
+            });
+            properties.push({
+                name: 'handles_decimals',
+                description: 'Function handles floating-point numbers',
+                testFunction: 'typeof result !== "undefined"',
+            });
+            properties.push({
+                name: 'handles_large_numbers',
+                description: 'Function handles very large numbers',
+                testFunction: 'typeof result !== "undefined"',
+            });
+        }
+        return properties;
+    }
+    inferFromFunctionName(func) {
+        const properties = [];
+        const funcName = func.name;
+        // Predicate functions (is*, has*)
+        if (/^(is|has)[A-Z]/.test(funcName)) {
+            properties.push({
+                name: 'returns_boolean',
+                description: 'Predicate function returns boolean',
+                testFunction: 'typeof result === "boolean"',
+            });
+        }
+        // Parse functions
+        if (funcName.toLowerCase().includes('parse')) {
+            properties.push({
+                name: 'rejects_invalid_input',
+                description: 'Parse function handles invalid input',
+                testFunction: '!result.ok || result.ok === true',
+            });
+        }
+        // Validate functions
+        if (funcName.toLowerCase().includes('validate')) {
+            properties.push({
+                name: 'deterministic',
+                description: 'Validation is deterministic',
+                testFunction: 'consistent results',
+            });
+        }
+        return properties;
+    }
+    inferFromConfidence(func) {
+        const properties = [];
+        const confAnnotation = func.annotations.find(a => a.name === 'confidence');
+        if (confAnnotation && confAnnotation.args.arg0) {
+            const confidence = parseFloat(confAnnotation.args.arg0);
+            if (confidence >= 0.95) {
+                properties.push({
+                    name: 'high_confidence_verified',
+                    description: 'High-confidence function passes all tests',
+                    testFunction: 'result !== null && result !== undefined',
+                });
+            }
+        }
+        return properties;
+    }
+    generateTestCode(func, properties) {
+        const imports = `import { test } from '@fast-check/vitest';
+import * as fc from 'fast-check';
+
+`;
+        const arbitraries = func.params.map(p => this.generateArbitrary(p));
+        let testCode = imports;
+        testCode += `describe('${func.name} property tests', () => {\n`;
+        for (const property of properties) {
+            testCode += `  test.prop([${arbitraries.join(', ')}])('${property.description}', (${func.params.map(p => p.name).join(', ')}) => {
+    const result = ${func.name}(${func.params.map(p => p.name).join(', ')});
+    // Property: ${property.testFunction}
+    expect(result).toBeDefined();
+  }, { numRuns: 1000 });
+
+`;
+        }
+        testCode += '});\n';
+        return testCode;
+    }
+    generateArbitrary(param) {
+        if (!param.typeAnnotation) {
+            return 'fc.anything()';
+        }
+        const type = param.typeAnnotation.value;
+        if (typeof type === 'string') {
+            switch (type) {
+                case 'string':
+                    return 'fc.string()';
+                case 'number':
+                    return 'fc.integer()';
+                case 'boolean':
+                    return 'fc.boolean()';
+                default:
+                    return 'fc.anything()';
+            }
+        }
+        return 'fc.anything()';
+    }
+}
+exports.EnhancedPropertyTestGenerator = EnhancedPropertyTestGenerator;
+//# sourceMappingURL=generator-enhanced.js.map

package/dist/property-tests/generator-enhanced.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator-enhanced.js","sourceRoot":"","sources":["../../src/property-tests/generator-enhanced.ts"],"names":[],"mappings":"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"}

package/dist/property-tests/generator-fixed.d.ts

@@ -0,0 +1,2 @@
+export { EnhancedPropertyTestGenerator as PropertyTestGenerator } from './generator-enhanced';
+//# sourceMappingURL=generator-fixed.d.ts.map

package/dist/property-tests/generator-fixed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator-fixed.d.ts","sourceRoot":"","sources":["../../src/property-tests/generator-fixed.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,6BAA6B,IAAI,qBAAqB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/property-tests/generator-fixed.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyTestGenerator = void 0;
+// Temporary fix - use the enhanced generator instead
+var generator_enhanced_1 = require("./generator-enhanced");
+Object.defineProperty(exports, "PropertyTestGenerator", { enumerable: true, get: function () { return generator_enhanced_1.EnhancedPropertyTestGenerator; } });
+//# sourceMappingURL=generator-fixed.js.map

package/dist/property-tests/generator-fixed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator-fixed.js","sourceRoot":"","sources":["../../src/property-tests/generator-fixed.ts"],"names":[],"mappings":";;;AAAA,qDAAqD;AACrD,2DAA8F;AAArF,2HAAA,6BAA6B,OAAyB"}

package/dist/property-tests/generator.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Property-based test generator
+ * Automatically generates fast-check tests from function signatures
+ */
+import * as AST from '../types';
+export interface PropertyTest {
+    functionName: string;
+    properties: Property[];
+    testCode: string;
+}
+export interface Property {
+    name: string;
+    description: string;
+    testFunction: string;
+}
+export declare class PropertyTestGenerator {
+    generate(ast: AST.ASTNode[]): PropertyTest[];
+    private generateForFunction;
+    private inferProperties;
+    private inferFromReturnType;
+    private inferFromParameters;
+    private inferFromFunctionName;
+    private inferFromConfidence;
+    private inferErrorHandlingProperties;
+    private generateTestCode;
+    private generateArbitrary;
+}
+//# sourceMappingURL=generator.d.ts.map

package/dist/property-tests/generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../src/property-tests/generator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,GAAG,MAAM,UAAU,CAAC;AAEhC,MAAM,WAAW,YAAY;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,QAAQ,EAAE,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,qBAAa,qBAAqB;IAChC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,OAAO,EAAE,GAAG,YAAY,EAAE;IAe5C,OAAO,CAAC,mBAAmB;IAgB3B,OAAO,CAAC,eAAe;IAyBvB,OAAO,CAAC,mBAAmB;IA8B3B,OAAO,CAAC,mBAAmB;IAwH3B,OAAO,CAAC,qBAAqB;IAkC7B,OAAO,CAAC,mBAAmB;IA4B3B,OAAO,CAAC,4BAA4B;IAoBpC,OAAO,CAAC,gBAAgB;IAuBxB,OAAO,CAAC,iBAAiB;CAkB1B"}

package/dist/property-tests/generator.js

@@ -0,0 +1,284 @@
+"use strict";
+/**
+ * Property-based test generator
+ * Automatically generates fast-check tests from function signatures
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyTestGenerator = void 0;
+class PropertyTestGenerator {
+    generate(ast) {
+        const tests = [];
+        for (const node of ast) {
+            if (node.type === 'FunctionDeclaration') {
+                const funcTests = this.generateForFunction(node);
+                if (funcTests) {
+                    tests.push(funcTests);
+                }
+            }
+        }
+        return tests;
+    }
+    generateForFunction(func) {
+        const properties = this.inferProperties(func);
+        if (properties.length === 0) {
+            return null;
+        }
+        const testCode = this.generateTestCode(func, properties);
+        return {
+            functionName: func.name,
+            properties,
+            testCode,
+        };
+    }
+    inferProperties(func) {
+        const properties = [];
+        // Extract properties from annotations
+        for (const annotation of func.annotations) {
+            if (annotation.name === 'property') {
+                properties.push({
+                    name: annotation.args.name || 'custom_property',
+                    description: annotation.args.description || '',
+                    testFunction: '',
+                });
+            }
+        }
+        // Infer properties from return type
+        if (func.returnType) {
+            properties.push(...this.inferFromReturnType(func.returnType));
+        }
+        // Infer properties from parameters
+        properties.push(...this.inferFromParameters(func.params));
+        return properties;
+    }
+    inferFromReturnType(returnType) {
+        const properties = [];
+        // Result<T, E> should handle both success and failure
+        if (returnType.kind === 'result') {
+            properties.push({
+                name: 'handles_success_case',
+                description: 'Function handles successful result',
+                testFunction: 'result.ok === true',
+            });
+            properties.push({
+                name: 'handles_error_case',
+                description: 'Function handles error result',
+                testFunction: 'result.ok === false || result.ok === true',
+            });
+        }
+        // Never returns null/undefined
+        if (returnType.kind === 'primitive' || returnType.kind === 'custom') {
+            properties.push({
+                name: 'never_returns_null',
+                description: 'Function never returns null or undefined',
+                testFunction: 'result !== null && result !== undefined',
+            });
+        }
+        return properties;
+    }
+    inferFromParameters(params) {
+        const properties = [];
+        // RULE 1: String parameters - test empty, whitespace, special chars
+        if (params.some(p => p.typeAnnotation?.value === 'string')) {
+            properties.push({
+                name: 'handles_empty_string',
+                description: 'Function handles empty string input',
+                testFunction: 'typeof result !== "undefined"',
+            });
+            properties.push({
+                name: 'handles_whitespace_only',
+                description: 'Function handles whitespace-only strings',
+                testFunction: 'typeof result !== "undefined"',
+            });
+            properties.push({
+                name: 'handles_special_characters',
+                description: 'Function handles strings with special characters',
+                testFunction: 'typeof result !== "undefined"',
+            });
+            properties.push({
+                name: 'handles_unicode',
+                description: 'Function handles Unicode characters (emoji, etc.)',
+                testFunction: 'typeof result !== "undefined"',
+            });
+        }
+        // RULE 2: Number parameters - test zero, negative, infinity, NaN
+        if (params.some(p => p.typeAnnotation?.value === 'number')) {
+            properties.push({
+                name: 'handles_zero',
+                description: 'Function handles zero input',
+                testFunction: 'typeof result !== "undefined"',
+            });
+            properties.push({
+                name: 'handles_negative',
+                description: 'Function handles negative numbers',
+                testFunction: 'typeof result !== "undefined"',
+            });
+            properties.push({
+                name: 'handles_large_numbers',
+                description: 'Function handles very large numbers',
+                testFunction: 'typeof result !== "undefined"',
+            });
+            properties.push({
+                name: 'handles_decimals',
+                description: 'Function handles decimal/floating-point numbers',
+                testFunction: 'typeof result !== "undefined"',
+            });
+            properties.push({
+                name: 'handles_infinity',
+                description: 'Function handles Infinity and -Infinity',
+                testFunction: 'typeof result !== "undefined"',
+            });
+        }
+        // RULE 3: Array parameters - test empty, single, duplicates
+        // Note: TypeAnnotation doesn't have 'kind' property yet, using value for now
+        if (params.some(p => p.typeAnnotation?.value?.includes('[]'))) {
+            properties.push({
+                name: 'handles_empty_array',
+                description: 'Function handles empty array input',
+                testFunction: 'typeof result !== "undefined"',
+            });
+            properties.push({
+                name: 'handles_single_element',
+                description: 'Function handles single-element array',
+                testFunction: 'typeof result !== "undefined"',
+            });
+            properties.push({
+                name: 'handles_duplicate_elements',
+                description: 'Function handles arrays with duplicate values',
+                testFunction: 'typeof result !== "undefined"',
+            });
+        }
+        // RULE 4: Object parameters - test missing fields, extra fields
+        // Note: TypeAnnotation doesn't have 'kind' property yet, using heuristic
+        if (params.some(p => p.typeAnnotation && !['string', 'number', 'boolean', 'void'].includes(p.typeAnnotation.value))) {
+            properties.push({
+                name: 'handles_missing_optional_fields',
+                description: 'Function handles objects with missing optional fields',
+                testFunction: 'typeof result !== "undefined"',
+            });
+            properties.push({
+                name: 'handles_extra_fields',
+                description: 'Function handles objects with unexpected extra fields',
+                testFunction: 'typeof result !== "undefined"',
+            });
+        }
+        // RULE 5: Async functions - test concurrent execution
+        if (func.annotations.some(a => a.name === 'async')) {
+            properties.push({
+                name: 'concurrent_execution_safe',
+                description: 'Function can be called concurrently without issues',
+                testFunction: 'typeof result !== "undefined"',
+            });
+            properties.push({
+                name: 'handles_cancellation',
+                description: 'Function handles cancellation gracefully',
+                testFunction: 'typeof result !== "undefined"',
+            });
+        }
+        return properties;
+    }
+    // NEW: Infer properties from function name patterns
+    inferFromFunctionName(funcName) {
+        const properties = [];
+        // Functions starting with 'is' or 'has' should return boolean
+        if (/^(is|has)[A-Z]/.test(funcName)) {
+            properties.push({
+                name: 'returns_boolean',
+                description: 'Predicate function returns boolean',
+                testFunction: 'typeof result === "boolean"',
+            });
+        }
+        // Functions with 'parse' should handle invalid input
+        if (funcName.includes('parse') || funcName.includes('Parse')) {
+            properties.push({
+                name: 'rejects_invalid_input',
+                description: 'Parse function returns error for invalid input',
+                testFunction: 'result.ok === false when input is invalid',
+            });
+        }
+        // Functions with 'validate' should be deterministic
+        if (funcName.includes('validate') || funcName.includes('Validate')) {
+            properties.push({
+                name: 'deterministic_validation',
+                description: 'Validation gives same result for same input',
+                testFunction: 'validate(x) === validate(x)',
+            });
+        }
+        return properties;
+    }
+    // NEW: Infer properties from confidence levels
+    inferFromConfidence(func) {
+        const properties = [];
+        const confAnnotation = func.annotations.find(a => a.name === 'confidence');
+        if (confAnnotation && confAnnotation.args.level) {
+            const confidence = parseFloat(confAnnotation.args.level);
+            if (confidence >= 0.95) {
+                properties.push({
+                    name: 'high_confidence_verified',
+                    description: 'High-confidence functions should pass all property tests',
+                    testFunction: 'result satisfies all properties',
+                });
+            }
+            if (confidence < 0.70) {
+                properties.push({
+                    name: 'low_confidence_documented',
+                    description: 'Low-confidence functions should document limitations',
+                    testFunction: 'has @uncertain annotation or documentation',
+                });
+            }
+        }
+        return properties;
+    }
+    // NEW: Infer error handling properties
+    inferErrorHandlingProperties(func) {
+        const properties = [];
+        if (func.returnType?.kind === 'result') {
+            properties.push({
+                name: 'error_messages_are_descriptive',
+                description: 'Error results contain meaningful messages',
+                testFunction: 'result.ok === false implies result.error.length > 0',
+            });
+            properties.push({
+                name: 'errors_have_recovery_context',
+                description: 'Errors include recovery suggestions when available',
+                testFunction: 'result.ok === false implies has error context',
+            });
+        }
+        return properties;
+    }
+    generateTestCode(func, properties) {
+        const imports = `import { test } from '@fast-check/vitest';
+import * as fc from 'fast-check';
+import { ${func.name} } from './${func.name}';
+
+`;
+        let testCode = imports;
+        // Generate arbitraries for parameters
+        const arbitraries = func.params.map(p => this.generateArbitrary(p));
+        // Generate test cases
+        for (const property of properties) {
+            testCode += `test.prop([${arbitraries.join(', ')}], (${func.params.map(p => p.name).join(', ')}) => {
+  const result = ${func.name}(${func.params.map(p => p.name).join(', ')});
+  expect(${property.testFunction}).toBe(true);
+}, { numRuns: 1000 });\n\n`;
+        }
+        return testCode;
+    }
+    generateArbitrary(param) {
+        if (!param.typeAnnotation) {
+            return 'fc.anything()';
+        }
+        const type = param.typeAnnotation.value;
+        switch (type) {
+            case 'string':
+                return 'fc.string()';
+            case 'number':
+                return 'fc.integer()';
+            case 'boolean':
+                return 'fc.boolean()';
+            default:
+                return 'fc.anything()';
+        }
+    }
+}
+exports.PropertyTestGenerator = PropertyTestGenerator;
+//# sourceMappingURL=generator.js.map

package/dist/property-tests/generator.js.map

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

package/dist/refinements/refinement-types.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Refinement Types for Agentic
+ * Enables dependent types and logical predicates in type annotations
+ * Inspired by Liquid Haskell and F*
+ */
+export interface RefinementType {
+    baseType: string;
+    predicate: string;
+    variable: string;
+}
+export declare const CommonRefinements: {
+    Positive: {
+        baseType: string;
+        predicate: string;
+        variable: string;
+    };
+    NonNegative: {
+        baseType: string;
+        predicate: string;
+        variable: string;
+    };
+    NonZero: {
+        baseType: string;
+        predicate: string;
+        variable: string;
+    };
+    Range: (min: number, max: number) => {
+        baseType: string;
+        predicate: string;
+        variable: string;
+    };
+    NonEmptyString: {
+        baseType: string;
+        predicate: string;
+        variable: string;
+    };
+    MaxLength: (max: number) => {
+        baseType: string;
+        predicate: string;
+        variable: string;
+    };
+    MinLength: (min: number) => {
+        baseType: string;
+        predicate: string;
+        variable: string;
+    };
+    ConfidenceScore: {
+        baseType: string;
+        predicate: string;
+        variable: string;
+    };
+    HighConfidence: {
+        baseType: string;
+        predicate: string;
+        variable: string;
+    };
+};
+export declare class RefinementTypeChecker {
+    private z3Context;
+    private initialized;
+    initialize(): Promise<void>;
+    /**
+     * Check if a value satisfies a refinement type
+     * Can be used at compile-time (static) or runtime (dynamic)
+     */
+    check(value: any, refinement: RefinementType, mode?: 'static' | 'runtime'): Promise<{
+        valid: boolean;
+        counterexample?: any;
+    }>;
+    /**
+     * Runtime checking (evaluate predicate with actual value)
+     */
+    private checkRuntime;
+    /**
+     * Static checking (verify predicate holds for all values using Z3)
+     */
+    private checkStatic;
+    private createSymbolicVariable;
+    private parsePredicateToZ3;
+    private parseOperand;
+    private evaluatePredicate;
+    private extractCounterexample;
+}
+export declare class RefinementValidator {
+    private checker;
+    validate<T>(value: T, refinement: RefinementType, location: string): Promise<T>;
+}
+export declare class RefinementViolation extends Error {
+    location: string;
+    refinement: RefinementType;
+    value: any;
+    constructor(message: string, location: string, refinement: RefinementType, value: any);
+}
+export declare const refinementChecker: RefinementTypeChecker;
+export declare const refinementValidator: RefinementValidator;
+//# sourceMappingURL=refinement-types.d.ts.map