glirastes 0.3.0 → 0.3.1

package/dist/cjs/server/testing/mock-executor.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMockToolExecutor = createMockToolExecutor;
+/**
+ * Creates a mock tool executor that validates inputs against Zod schemas
+ * and returns the provided mock responses.
+ *
+ * Does not make any HTTP calls — purely validates and returns mocks.
+ */
+function createMockToolExecutor(toolRegistry) {
+    return {
+        execute(toolName, input, mockResponse) {
+            const tool = toolRegistry[toolName];
+            if (!tool) {
+                return {
+                    success: false,
+                    validationError: `Tool "${toolName}" not found in registry`,
+                    response: null,
+                };
+            }
+            if (tool.inputSchema) {
+                const result = tool.inputSchema.safeParse(input);
+                if (!result.success) {
+                    const issues = result.error?.issues
+                        .map((i) => `${i.path.join('.')}: ${i.message}`)
+                        .join('; ');
+                    return {
+                        success: false,
+                        validationError: issues ?? 'Validation failed',
+                        response: null,
+                    };
+                }
+            }
+            return {
+                success: true,
+                response: mockResponse,
+            };
+        },
+    };
+}

package/dist/cjs/server/testing/regression.d.ts

@@ -0,0 +1,7 @@
+import type { PipelineComponents } from './helpers.js';
+import type { RegressionTestCase } from './types.js';
+/**
+ * Runs user-defined regression tests with access to pipeline simulation
+ * and tool registry for custom assertions.
+ */
+export declare function runRegressionTest(components: PipelineComponents, toolRegistry: Record<string, unknown>, cases: RegressionTestCase[]): void;

package/dist/cjs/server/testing/regression.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRegressionTest = runRegressionTest;
+const vitest_1 = require("vitest");
+const helpers_js_1 = require("./helpers.js");
+/**
+ * Runs user-defined regression tests with access to pipeline simulation
+ * and tool registry for custom assertions.
+ */
+function runRegressionTest(components, toolRegistry, cases) {
+    if (cases.length === 0)
+        return;
+    const ctx = {
+        simulatePipeline: (input, intent) => (0, helpers_js_1.simulatePipeline)(components, input, intent),
+        tools: toolRegistry,
+        modules: components.modules,
+    };
+    (0, vitest_1.describe)('AI Regression Tests', () => {
+        for (const testCase of cases) {
+            const ref = testCase.reference ? `[${testCase.reference}] ` : '';
+            const label = `${ref}${testCase.name}`;
+            (0, vitest_1.it)(label, async () => {
+                await testCase.verify(ctx);
+            });
+        }
+    });
+}

package/dist/cjs/server/testing/routing.d.ts

@@ -0,0 +1,12 @@
+import type { PipelineComponents } from './helpers.js';
+import type { RoutingTestCase } from './types.js';
+/**
+ * Runs deterministic routing tests with provided test cases.
+ *
+ * Each case simulates the pipeline with a given input and a fixed
+ * intent classification (no LLM needed). Asserts:
+ * - Correct module is selected
+ * - Expected tools are present
+ * - Excluded tools are absent
+ */
+export declare function runRoutingTest(components: PipelineComponents, cases: RoutingTestCase[]): void;

package/dist/cjs/server/testing/routing.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRoutingTest = runRoutingTest;
+const vitest_1 = require("vitest");
+const helpers_js_1 = require("./helpers.js");
+/**
+ * Runs deterministic routing tests with provided test cases.
+ *
+ * Each case simulates the pipeline with a given input and a fixed
+ * intent classification (no LLM needed). Asserts:
+ * - Correct module is selected
+ * - Expected tools are present
+ * - Excluded tools are absent
+ */
+function runRoutingTest(components, cases) {
+    (0, vitest_1.describe)('AI Pipeline Routing (deterministic)', () => {
+        for (const testCase of cases) {
+            const confidence = testCase.confidence ?? 0.95;
+            const label = `"${testCase.input}" → ${testCase.expectModule}`;
+            (0, vitest_1.it)(label, () => {
+                const result = (0, helpers_js_1.simulatePipeline)(components, testCase.input, {
+                    intent: testCase.expectModule,
+                    confidence,
+                });
+                (0, vitest_1.expect)(result.blocked).toBe(false);
+                (0, vitest_1.expect)(result.module).toBe(testCase.expectModule);
+                if (testCase.expectTools) {
+                    for (const tool of testCase.expectTools) {
+                        (0, vitest_1.expect)(result.tools, `Expected tool "${tool}" in result`).toContain(tool);
+                    }
+                }
+                if (testCase.excludeTools) {
+                    for (const tool of testCase.excludeTools) {
+                        (0, vitest_1.expect)(result.tools, `Tool "${tool}" should not be in result`).not.toContain(tool);
+                    }
+                }
+            });
+        }
+        // Auto-generated edge cases
+        (0, vitest_1.describe)('edge cases', () => {
+            (0, vitest_1.it)('ambiguous intent gives all tools', () => {
+                const result = (0, helpers_js_1.simulatePipeline)(components, 'Hallo wie geht es dir', { intent: 'ambiguous', confidence: 0.30 });
+                (0, vitest_1.expect)(result.module).toBeNull();
+                (0, vitest_1.expect)(result.tools.length).toBeGreaterThan(0);
+            });
+            (0, vitest_1.it)('low confidence returns all tools (fallback safety)', () => {
+                const firstModule = components.modules[0];
+                if (!firstModule)
+                    return;
+                const result = (0, helpers_js_1.simulatePipeline)(components, 'vague request', { intent: firstModule.id, confidence: 0.30 });
+                (0, vitest_1.expect)(result.module).toBeNull();
+                (0, vitest_1.expect)(result.strategy).toBe('all');
+            });
+            (0, vitest_1.it)('suggest_followups is always included in non-blocked results', () => {
+                const firstModule = components.modules[0];
+                if (!firstModule)
+                    return;
+                const result = (0, helpers_js_1.simulatePipeline)(components, 'test input', { intent: firstModule.id, confidence: 0.95 });
+                (0, vitest_1.expect)(result.tools).toContain('suggest_followups');
+            });
+        });
+    });
+}

package/dist/cjs/server/testing/schema-consistency.d.ts

@@ -0,0 +1,6 @@
+import type { SchemaConsistencyOptions } from './types.js';
+/**
+ * Verifies that tool output field types match the input field types
+ * of downstream tools in declared workflow chains.
+ */
+export declare function runSchemaConsistencyTest(toolRegistry: Record<string, unknown>, options: SchemaConsistencyOptions): void;

package/dist/cjs/server/testing/schema-consistency.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSchemaConsistencyTest = runSchemaConsistencyTest;
+const vitest_1 = require("vitest");
+/**
+ * Verifies that tool output field types match the input field types
+ * of downstream tools in declared workflow chains.
+ */
+function runSchemaConsistencyTest(toolRegistry, options) {
+    if (options.chains.length === 0)
+        return;
+    (0, vitest_1.describe)('AI Tool Schema Consistency', () => {
+        for (const chain of options.chains) {
+            const label = `${chain.from}.${chain.field} → ${chain.to}.${chain.targetField}`;
+            (0, vitest_1.it)(label, () => {
+                // Both tools must exist
+                const fromTool = toolRegistry[chain.from];
+                const toTool = toolRegistry[chain.to];
+                (0, vitest_1.expect)(fromTool, `Source tool "${chain.from}" not in registry`).toBeDefined();
+                (0, vitest_1.expect)(toTool, `Target tool "${chain.to}" not in registry`).toBeDefined();
+                // Target tool must have inputSchema with the target field
+                const toSchema = toTool.inputSchema;
+                (0, vitest_1.expect)(toSchema, `Target tool "${chain.to}" has no inputSchema`).toBeDefined();
+                const toShape = getShape(toSchema);
+                (0, vitest_1.expect)(toShape, `Target tool "${chain.to}" inputSchema is not an object`).not.toBeNull();
+                const targetField = resolveField(toShape, chain.targetField);
+                (0, vitest_1.expect)(targetField, `Target field "${chain.targetField}" not found in ${chain.to} inputSchema`).not.toBeNull();
+                // Verify type compatibility
+                const targetType = getBaseTypeName(targetField);
+                (0, vitest_1.expect)(['ZodString', 'ZodNumber', 'ZodArray', 'ZodEnum', 'ZodBoolean'].includes(targetType), `Target field "${chain.targetField}" in ${chain.to} has unrecognized type: ${targetType}`).toBe(true);
+            });
+        }
+    });
+}
+function getShape(schema) {
+    const def = schema._def;
+    if (def.typeName === 'ZodObject' && typeof def.shape === 'function') {
+        return def.shape();
+    }
+    if ((def.typeName === 'ZodEffects' || def.typeName === 'ZodOptional') && def.innerType) {
+        return getShape(def.innerType);
+    }
+    return null;
+}
+function resolveField(shape, path) {
+    if (shape[path])
+        return shape[path];
+    return null;
+}
+function getBaseTypeName(schema) {
+    const def = schema._def;
+    if (def.typeName === 'ZodOptional' || def.typeName === 'ZodNullable' || def.typeName === 'ZodDefault') {
+        return def.innerType ? getBaseTypeName(def.innerType) : def.typeName;
+    }
+    return def.typeName;
+}

package/dist/cjs/server/testing/smoke.d.ts

@@ -0,0 +1,11 @@
+import type { ModuleDefinition } from '../../types.js';
+/**
+ * Auto-generates smoke tests from module definitions.
+ *
+ * Tests:
+ * - Every module has at least 1 tool
+ * - All tool names use snake_case
+ * - No duplicate tool names within a module
+ * - If a tool registry is provided, all module tools exist in it
+ */
+export declare function runSmokeTest(modules: ModuleDefinition[], toolRegistry?: Record<string, unknown>): void;

package/dist/cjs/server/testing/smoke.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSmokeTest = runSmokeTest;
+const vitest_1 = require("vitest");
+const helpers_js_1 = require("./helpers.js");
+/**
+ * Auto-generates smoke tests from module definitions.
+ *
+ * Tests:
+ * - Every module has at least 1 tool
+ * - All tool names use snake_case
+ * - No duplicate tool names within a module
+ * - If a tool registry is provided, all module tools exist in it
+ */
+function runSmokeTest(modules, toolRegistry) {
+    const toolsByModule = (0, helpers_js_1.getToolsByModule)(modules);
+    const moduleIds = modules.map((m) => m.id);
+    (0, vitest_1.describe)('AI Tool Registry Smoke Tests', () => {
+        (0, vitest_1.describe)('module completeness', () => {
+            (0, vitest_1.it)(`has ${modules.length} intent modules`, () => {
+                (0, vitest_1.expect)(moduleIds).toHaveLength(modules.length);
+                for (const mod of modules) {
+                    (0, vitest_1.expect)(moduleIds).toContain(mod.id);
+                }
+            });
+            (0, vitest_1.it)('every module has at least 1 tool', () => {
+                for (const id of moduleIds) {
+                    (0, vitest_1.expect)(toolsByModule[id].length, `${id} should have tools`).toBeGreaterThan(0);
+                }
+            });
+        });
+        (0, vitest_1.describe)('tool naming conventions', () => {
+            const allTools = Object.values(toolsByModule).flat();
+            (0, vitest_1.it)('all tool names use snake_case', () => {
+                for (const tool of allTools) {
+                    (0, vitest_1.expect)(tool, `Tool "${tool}" should be snake_case`).toMatch(/^[a-z][a-z0-9_]*$/);
+                }
+            });
+            (0, vitest_1.it)('no duplicate tool names within a module', () => {
+                for (const id of moduleIds) {
+                    const tools = toolsByModule[id];
+                    const unique = new Set(tools);
+                    (0, vitest_1.expect)(unique.size, `${id} has duplicates`).toBe(tools.length);
+                }
+            });
+        });
+        if (toolRegistry) {
+            (0, vitest_1.describe)('registry completeness', () => {
+                const registryToolNames = new Set(Object.keys(toolRegistry));
+                (0, vitest_1.it)('all module tools exist in the tool registry', () => {
+                    const missing = [];
+                    for (const id of moduleIds) {
+                        for (const tool of toolsByModule[id]) {
+                            if (!registryToolNames.has(tool)) {
+                                missing.push(`${id}/${tool}`);
+                            }
+                        }
+                    }
+                    (0, vitest_1.expect)(missing, `Missing tools in registry: ${missing.join(', ')}`).toHaveLength(0);
+                });
+            });
+        }
+    });
+}

package/dist/cjs/server/testing/types.d.ts

@@ -0,0 +1,156 @@
+import type { ModuleDefinition, GuardrailsConfig, IntentClassification } from '../../types.js';
+/** Duck-typed Zod schema interface to avoid direct zod dependency */
+interface ZodLikeSchema {
+    safeParse(input: unknown): {
+        success: boolean;
+        error?: {
+            issues: unknown[];
+        };
+    };
+}
+export interface TestSuiteConfig {
+    /** Module definitions (same as used in the app's pipeline) */
+    modules: ModuleDefinition[];
+    /** Tool registry — Record<toolName, toolDefinition> */
+    tools?: Record<string, unknown>;
+    /** Pipeline configuration matching the app */
+    pipeline?: {
+        guardrails?: GuardrailsConfig;
+        confidenceThresholds?: {
+            high?: number;
+            medium?: number;
+        };
+    };
+    /** Locale hint for test descriptions (default: 'en') */
+    locale?: string;
+}
+export interface RoutingTestCase {
+    /** Natural-language input */
+    input: string;
+    /** Expected module ID (e.g., 'task_query') */
+    expectModule: string;
+    /** Tools that MUST be present in the result */
+    expectTools?: string[];
+    /** Tools that MUST NOT be present */
+    excludeTools?: string[];
+    /** Override confidence (default: 0.95) */
+    confidence?: number;
+}
+export interface GuardrailsTestOptions {
+    /** Extra injection patterns to test (appended to defaults) */
+    extraInjectionInputs?: string[];
+    /** Extra valid inputs to test */
+    extraValidInputs?: string[];
+}
+export interface SimulatedPipelineResult {
+    blocked: boolean;
+    tools: string[];
+    module: string | null;
+    intent: IntentClassification;
+    strategy?: 'single' | 'expanded' | 'all';
+}
+export interface AiTestSuite {
+    /** Auto-generated smoke tests: module completeness, tool naming, no duplicates */
+    smokeTest(): void;
+    /** Deterministic routing tests with provided test cases */
+    routingTest(cases: RoutingTestCase[]): void;
+    /** Auto-generated guardrails tests: injection, length, sanitization */
+    guardrailsTest(options?: GuardrailsTestOptions): void;
+    /** Auto-generated approval flag tests: mutations need approval, queries don't */
+    approvalTest(): void;
+    /** Low-level pipeline simulation for custom assertions */
+    simulatePipeline(input: string, intent: IntentClassification): SimulatedPipelineResult;
+    /** Tool combination & workflow chain tests */
+    combinationTest(cases?: CombinationTestCase[], options?: CombinationTestOptions): void;
+    /** Auto-generated edge case tests from Zod schemas + custom business-logic cases */
+    edgeCaseTest(options?: EdgeCaseTestOptions): void;
+    /** Verify tool output→input type compatibility across workflow chains */
+    schemaConsistencyTest(options: SchemaConsistencyOptions): void;
+    /** User-defined regression tests with pipeline simulation context */
+    regressionTest(cases: RegressionTestCase[]): void;
+}
+export interface CombinationTestCase {
+    /** Human-readable workflow name */
+    name: string;
+    /** The module this workflow targets */
+    intent: string;
+    /** All tools that must be available simultaneously */
+    requiredToolChain: string[];
+    /** Confidence level (default: 0.95 for single-module, 0.75 for expanded) */
+    confidence?: number;
+    /** Optional HTTP-level execution chain (requires toolExecutor) */
+    execution?: ExecutionStep[];
+    /** Assertions on the execution result */
+    expect?: {
+        finalToolResult?: unknown;
+        allToolsSucceeded?: boolean;
+    };
+}
+export interface ExecutionStep {
+    tool: string;
+    input: Record<string, unknown>;
+    mockResponse: unknown;
+}
+export interface CombinationTestOptions {
+    /** Mock tool executor for HTTP-level execution tests */
+    toolExecutor?: MockToolExecutor;
+}
+export interface EdgeCaseTestOptions {
+    /** Skip these tools (e.g. synthetic tools like suggest_followups) */
+    skipTools?: string[];
+    /** Custom business-logic edge cases per tool */
+    customCases?: Record<string, CustomEdgeCase[]>;
+}
+export interface CustomEdgeCase {
+    label: string;
+    input: Record<string, unknown>;
+    expectError: boolean;
+    errorMessage?: string;
+}
+export interface SchemaConsistencyChain {
+    /** Source tool name */
+    from: string;
+    /** Output field path (e.g. 'id', 'tasks[].id') */
+    field: string;
+    /** Target tool name */
+    to: string;
+    /** Input field (e.g. 'assigneeId', 'taskIds') */
+    targetField: string;
+}
+export interface SchemaConsistencyOptions {
+    chains: SchemaConsistencyChain[];
+}
+export interface RegressionTestCase {
+    /** Regression name */
+    name: string;
+    /** Bug reference (e.g. 'LIN-123', 'commit abc1234') */
+    reference?: string;
+    /** Description of the original bug */
+    description: string;
+    /** Test function — receives context with pipeline simulation + tool access */
+    verify: (ctx: RegressionContext) => void | Promise<void>;
+}
+export interface RegressionContext {
+    /** Simulate pipeline routing */
+    simulatePipeline: AiTestSuite['simulatePipeline'];
+    /** Tool registry for schema access */
+    tools: Record<string, unknown>;
+    /** Module definitions */
+    modules: ModuleDefinition[];
+}
+export interface MockToolExecutor {
+    execute(toolName: string, input: Record<string, unknown>, mockResponse: unknown): {
+        success: boolean;
+        validationError?: string;
+        response: unknown;
+    };
+}
+export interface ToolDefinitionForTest {
+    toolName?: string;
+    inputSchema?: ZodLikeSchema;
+    needsApproval?: boolean;
+    method?: string;
+    module?: string;
+    [key: string]: unknown;
+}
+export {};

package/dist/cjs/server/testing/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });