@chen-rmag/core-infra 1.0.0

package/README.md

@@ -0,0 +1,46 @@
+# @ai-test/core-infra
+
+Core infrastructure package for AI testing framework.
+
+## Features
+
+- **MCP (Model Context Protocol)**: Client and manager implementations
+- **Repositories**: Data access layer with base repository pattern
+- **Model Factory**: Language model creation and tool binding
+- **Storage Service**: Unified storage operations facade
+
+## Installation
+
+```bash
+npm install @ai-test/core-infra
+```
+
+## Usage
+
+```typescript
+import { MCPManager, StorageService, createModel } from '@ai-test/core-infra';
+
+// Use MCP manager
+const mcpManager = new MCPManager();
+await mcpManager.start('en-US');
+
+// Use storage service
+const storage = StorageService.getInstance();
+
+// Create model
+const model = createModel(config, true, mcpManager);
+```
+
+## Development
+
+```bash
+# Build
+npm run build
+
+# Watch mode
+npm run build:watch
+```
+
+## License
+
+MIT

package/dist/ProjectContextManager.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Project Context Manager
+ * Manages the current active project context for the entire application
+ * All data operations use this context to determine project scope
+ */
+export interface AgentCheckCallback {
+    hasRunningAgents: () => boolean;
+}
+declare class ProjectContextManager {
+    private currentProjectId;
+    private agentCheckCallback?;
+    /**
+     * Set a callback to check if there are running agents
+     * This should be called by the host application
+     */
+    setAgentCheckCallback(callback: AgentCheckCallback): void;
+    /**
+     * Set the current project ID
+     */
+    setProjectId(projectId: string | null): void;
+    /**
+     * Get the current project ID
+     */
+    getProjectId(): string;
+}
+declare global {
+    var projectContextManagerInstance: ProjectContextManager | undefined;
+}
+export declare const projectContextManager: ProjectContextManager;
+export {};

package/dist/ProjectContextManager.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Project Context Manager
+ * Manages the current active project context for the entire application
+ * All data operations use this context to determine project scope
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectContextManager = void 0;
+class ProjectContextManager {
+    constructor() {
+        this.currentProjectId = null;
+    }
+    /**
+     * Set a callback to check if there are running agents
+     * This should be called by the host application
+     */
+    setAgentCheckCallback(callback) {
+        this.agentCheckCallback = callback;
+    }
+    /**
+     * Set the current project ID
+     */
+    setProjectId(projectId) {
+        if (this.currentProjectId !== projectId) {
+            // Check if there are running agents before switching projects
+            if (this.agentCheckCallback?.hasRunningAgents()) {
+                throw new Error(`Cannot change project while Test generation is running.`);
+            }
+            this.currentProjectId = projectId;
+        }
+    }
+    /**
+     * Get the current project ID
+     */
+    getProjectId() {
+        return this.currentProjectId || 'default';
+    }
+}
+// Singleton instance
+exports.projectContextManager = global.projectContextManagerInstance ?? new ProjectContextManager();
+global.projectContextManagerInstance = exports.projectContextManager;

package/dist/directory-validator.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Directory name validation utility
+ * Validates directory names against file system restrictions
+ */
+/**
+ * Validate a directory name
+ * @param name - Directory name to validate
+ * @returns { valid: boolean; error?: string }
+ */
+export declare function validateDirectoryName(name: string): {
+    valid: boolean;
+    error?: string;
+};
+/**
+ * Validate a directory path (multiple levels)
+ * @param path - Directory path like 'folder1/folder2/folder3'
+ * @returns { valid: boolean; error?: string }
+ */
+export declare function validateDirectoryPath(path: string): {
+    valid: boolean;
+    error?: string;
+};
+/**
+ * Normalize directory name (basic cleanup)
+ * @param name - Raw directory name
+ * @returns Normalized name
+ */
+export declare function normalizeDirectoryName(name: string): string;

package/dist/directory-validator.js

@@ -0,0 +1,90 @@
+"use strict";
+/**
+ * Directory name validation utility
+ * Validates directory names against file system restrictions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateDirectoryName = validateDirectoryName;
+exports.validateDirectoryPath = validateDirectoryPath;
+exports.normalizeDirectoryName = normalizeDirectoryName;
+/**
+ * Windows and Linux forbidden characters in file/directory names
+ * Windows: < > : " | ? * and control characters
+ * Linux: only / and null character, but we also exclude other common problematic chars
+ * We use a stricter set to ensure cross-platform compatibility
+ */
+const FORBIDDEN_CHARS = /[<>:"|?*\\\/\x00]/;
+const RESERVED_NAMES = [
+    'CON', 'PRN', 'AUX', 'NUL', // Standard Windows reserved names
+    'COM1', 'COM2', 'COM3', 'COM4', 'COM5', 'COM6', 'COM7', 'COM8', 'COM9',
+    'LPT1', 'LPT2', 'LPT3', 'LPT4', 'LPT5', 'LPT6', 'LPT7', 'LPT8', 'LPT9',
+];
+/**
+ * Validate a directory name
+ * @param name - Directory name to validate
+ * @returns { valid: boolean; error?: string }
+ */
+function validateDirectoryName(name) {
+    if (!name || name.trim().length === 0) {
+        return { valid: false, error: 'Directory name cannot be empty' };
+    }
+    // Check length
+    if (name.length > 255) {
+        return { valid: false, error: 'Directory name cannot exceed 255 characters' };
+    }
+    // Check for forbidden characters
+    if (FORBIDDEN_CHARS.test(name)) {
+        return {
+            valid: false,
+            error: 'Directory name cannot contain the following characters: < > : " | ? * \\ / and control characters',
+        };
+    }
+    // Check for leading/trailing spaces (problematic on Windows)
+    if (name !== name.trim() || name.startsWith('.') || name.endsWith('.')) {
+        return {
+            valid: false,
+            error: 'Directory name cannot start or end with spaces or dots',
+        };
+    }
+    // Check for reserved names (Windows)
+    const upperName = name.toUpperCase();
+    if (RESERVED_NAMES.includes(upperName)) {
+        return {
+            valid: false,
+            error: `"${name}" is a system reserved name and cannot be used as a directory name`,
+        };
+    }
+    return { valid: true };
+}
+/**
+ * Validate a directory path (multiple levels)
+ * @param path - Directory path like 'folder1/folder2/folder3'
+ * @returns { valid: boolean; error?: string }
+ */
+function validateDirectoryPath(path) {
+    if (!path) {
+        // Empty path is valid (root level)
+        return { valid: true };
+    }
+    const parts = path.split('/').filter(p => p.length > 0);
+    // Check max 3 levels
+    if (parts.length > 3) {
+        return { valid: false, error: 'Directory depth cannot exceed 3 levels' };
+    }
+    // Validate each part
+    for (const part of parts) {
+        const validation = validateDirectoryName(part);
+        if (!validation.valid) {
+            return validation;
+        }
+    }
+    return { valid: true };
+}
+/**
+ * Normalize directory name (basic cleanup)
+ * @param name - Raw directory name
+ * @returns Normalized name
+ */
+function normalizeDirectoryName(name) {
+    return name.trim().replace(/\s+/g, ' ');
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import 'server-only';
+export * from './types';
+export type { MCPTool, MCPConfig } from './mcp/mcp-client';
+export { MCPClient } from './mcp/mcp-client';
+export type { ToolGroup } from './mcp/index';
+export { AbstractGroupedMCPManager, type GroupedMCPManager } from './mcp/index';
+export { MCPManager } from './mcp/mcp-manager';
+export type { PlaywrightMCPOpts } from './mcp/playwright-mcp-manager';
+export { PlaywrightMCPManager } from './mcp/playwright-mcp-manager';
+export { FileMCPManager } from './mcp/file-mcp-manager';
+export * from './repositories';
+export { createModel, convertToZodSchema } from './model';
+export { StorageService } from './storageService';
+export { validateDirectoryName, validateDirectoryPath, normalizeDirectoryName } from './directory-validator';

package/dist/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeDirectoryName = exports.validateDirectoryPath = exports.validateDirectoryName = exports.StorageService = exports.convertToZodSchema = exports.createModel = exports.FileMCPManager = exports.PlaywrightMCPManager = exports.MCPManager = exports.AbstractGroupedMCPManager = exports.MCPClient = void 0;
+require("server-only");
+// Types
+__exportStar(require("./types"), exports);
+var mcp_client_1 = require("./mcp/mcp-client");
+Object.defineProperty(exports, "MCPClient", { enumerable: true, get: function () { return mcp_client_1.MCPClient; } });
+var index_1 = require("./mcp/index");
+Object.defineProperty(exports, "AbstractGroupedMCPManager", { enumerable: true, get: function () { return index_1.AbstractGroupedMCPManager; } });
+var mcp_manager_1 = require("./mcp/mcp-manager");
+Object.defineProperty(exports, "MCPManager", { enumerable: true, get: function () { return mcp_manager_1.MCPManager; } });
+var playwright_mcp_manager_1 = require("./mcp/playwright-mcp-manager");
+Object.defineProperty(exports, "PlaywrightMCPManager", { enumerable: true, get: function () { return playwright_mcp_manager_1.PlaywrightMCPManager; } });
+var file_mcp_manager_1 = require("./mcp/file-mcp-manager");
+Object.defineProperty(exports, "FileMCPManager", { enumerable: true, get: function () { return file_mcp_manager_1.FileMCPManager; } });
+// Repositories
+__exportStar(require("./repositories"), exports);
+// Model
+var model_1 = require("./model");
+Object.defineProperty(exports, "createModel", { enumerable: true, get: function () { return model_1.createModel; } });
+Object.defineProperty(exports, "convertToZodSchema", { enumerable: true, get: function () { return model_1.convertToZodSchema; } });
+// Storage Service
+var storageService_1 = require("./storageService");
+Object.defineProperty(exports, "StorageService", { enumerable: true, get: function () { return storageService_1.StorageService; } });
+// Directory Validator
+var directory_validator_1 = require("./directory-validator");
+Object.defineProperty(exports, "validateDirectoryName", { enumerable: true, get: function () { return directory_validator_1.validateDirectoryName; } });
+Object.defineProperty(exports, "validateDirectoryPath", { enumerable: true, get: function () { return directory_validator_1.validateDirectoryPath; } });
+Object.defineProperty(exports, "normalizeDirectoryName", { enumerable: true, get: function () { return directory_validator_1.normalizeDirectoryName; } });

package/dist/mcp/file-mcp-manager.d.ts

@@ -0,0 +1,13 @@
+/**
+ * MCP (Model Context Protocol) Client for Playwright integration
+ * Integrates with https://github.com/microsoft/playwright-mcp
+ */
+import { MCPClient } from './mcp-client';
+import { AbstractGroupedMCPManager } from '.';
+export declare class FileMCPManager extends AbstractGroupedMCPManager {
+    private client?;
+    constructor();
+    start(forced?: boolean): Promise<void>;
+    getClient(): MCPClient;
+    private createClient;
+}

package/dist/mcp/file-mcp-manager.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * MCP (Model Context Protocol) Client for Playwright integration
+ * Integrates with https://github.com/microsoft/playwright-mcp
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileMCPManager = void 0;
+const mcp_client_1 = require("./mcp-client");
+const _1 = require(".");
+class FileMCPManager extends _1.AbstractGroupedMCPManager {
+    constructor() {
+        const groups = [
+            {
+                name: 'file_mcp',
+                description: 'Read, write files on the filesystem',
+                loadByDefault: false,
+            }
+        ];
+        super(groups);
+    }
+    async start(forced = false) {
+        const client = this.createClient();
+        this.client = client;
+        await client.connect(forced);
+    }
+    getClient() {
+        if (!this.client) {
+            throw new Error("MCP Client is not started yet");
+        }
+        return this.client;
+    }
+    createClient() {
+        // Build args with headless mode
+        const args = [
+            '@cotestdev/mcp-files',
+        ];
+        const mcpConfig = {
+            cmd: 'npx',
+            args: args,
+            env: { ...process.env },
+        };
+        return new mcp_client_1.MCPClient(mcpConfig);
+    }
+}
+exports.FileMCPManager = FileMCPManager;

package/dist/mcp/index.d.ts

@@ -0,0 +1,20 @@
+import { MCPClient } from "./mcp-client";
+export interface ToolGroup {
+    name: string;
+    description: string;
+    tools?: string[];
+    loadByDefault: boolean;
+}
+export interface GroupedMCPManager {
+    groups: ToolGroup[];
+    start(forced?: boolean): Promise<void>;
+    getToolGroupInfo(): Record<string, string>;
+    getClient(): MCPClient;
+}
+export declare abstract class AbstractGroupedMCPManager implements GroupedMCPManager {
+    groups: ToolGroup[];
+    constructor(groups: ToolGroup[]);
+    abstract start(forced: boolean): Promise<void>;
+    abstract getClient(): MCPClient;
+    getToolGroupInfo(): Record<string, string>;
+}

package/dist/mcp/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractGroupedMCPManager = void 0;
+class AbstractGroupedMCPManager {
+    constructor(groups) {
+        this.groups = groups;
+    }
+    getToolGroupInfo() {
+        const result = {};
+        for (const group of this.groups) {
+            result[group.name] = group.description;
+        }
+        return result;
+    }
+}
+exports.AbstractGroupedMCPManager = AbstractGroupedMCPManager;

package/dist/mcp/mcp-client.d.ts

@@ -0,0 +1,127 @@
+/**
+ * MCP (Model Context Protocol) Client for Playwright integration
+ * Integrates with https://github.com/microsoft/playwright-mcp
+ */
+import { ToolCall } from '../types';
+export interface MCPTool {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+export interface MCPConfig {
+    cmd?: string;
+    args: string[];
+    url?: string;
+    env?: Record<string, string>;
+}
+export declare class MCPClient {
+    private client;
+    private connected;
+    private connecting;
+    private transport;
+    private availableTools;
+    private config;
+    constructor(config: MCPConfig);
+    getConfig(): MCPConfig;
+    doCallTool(name: string, args: Record<string, any>, signal: AbortSignal): Promise<{
+        [x: string]: unknown;
+        content: ({
+            type: "text";
+            text: string;
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            type: "image";
+            data: string;
+            mimeType: string;
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            type: "audio";
+            data: string;
+            mimeType: string;
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            type: "resource";
+            resource: {
+                uri: string;
+                text: string;
+                mimeType?: string | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            } | {
+                uri: string;
+                blob: string;
+                mimeType?: string | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            };
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            uri: string;
+            name: string;
+            type: "resource_link";
+            description?: string | undefined;
+            mimeType?: string | undefined;
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+            icons?: {
+                src: string;
+                mimeType?: string | undefined;
+                sizes?: string[] | undefined;
+                theme?: "light" | "dark" | undefined;
+            }[] | undefined;
+            title?: string | undefined;
+        })[];
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+        structuredContent?: Record<string, unknown> | undefined;
+        isError?: boolean | undefined;
+    } | {
+        [x: string]: unknown;
+        toolResult: unknown;
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    }>;
+    callTool(toolCall: ToolCall, signal: AbortSignal): Promise<any>;
+    connect(forced?: boolean): Promise<void>;
+    doConnect(): Promise<void>;
+    private loadAvailableTools;
+    getAvailableTools(): MCPTool[];
+    getToolByName(name: string): MCPTool | undefined;
+    getToolsDescription(): string;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+}