@crewx/sdk 0.8.0-rc.78 → 0.8.0-rc.80

package/dist/esm/layout/props-validator.js

@@ -1,297 +0,0 @@
-/**
- * PropsValidator — React PropTypes style props validation.
- * Ported 1:1 from packages/sdk-bak/src/services/props-validator.service.ts.
- * Only the import path is changed.
- */
-import { PropsValidationError, } from './types';
-export class PropsValidator {
-    defaultMode;
-    constructor(options = {}) {
-        this.defaultMode = options.defaultMode ?? 'lenient';
-    }
-    validate(props, schema, mode = this.defaultMode) {
-        const errors = [];
-        const resolvedProps = this.validateObject(props ?? {}, schema, mode, ['props'], errors);
-        if (errors.length > 0 && mode === 'strict') {
-            throw new PropsValidationError('Props validation failed in strict mode', errors);
-        }
-        return {
-            valid: errors.length === 0,
-            props: resolvedProps,
-            errors,
-        };
-    }
-    validateObject(provided, schema, mode, pathSegments, errors) {
-        const sanitized = {};
-        if (mode === 'strict') {
-            for (const key of Object.keys(provided)) {
-                if (!schema[key]) {
-                    errors.push({
-                        path: this.buildPath([...pathSegments, key]),
-                        message: `Unknown prop '${key}'`,
-                        value: provided[key],
-                    });
-                }
-            }
-        }
-        for (const [key, propSchema] of Object.entries(schema)) {
-            const fullPath = [...pathSegments, key];
-            const rawValue = provided[key];
-            const result = this.resolveProp(rawValue, propSchema, fullPath, mode, errors);
-            if (result.shouldAssign) {
-                sanitized[key] = result.value;
-            }
-        }
-        return sanitized;
-    }
-    resolveProp(value, schema, pathSegments, mode, errors) {
-        const path = this.buildPath(pathSegments);
-        if (this.isNil(value)) {
-            if (schema.isRequired) {
-                errors.push({
-                    path,
-                    message: `Required prop '${pathSegments[pathSegments.length - 1]}' is missing`,
-                });
-            }
-            if (schema.defaultValue !== undefined) {
-                return { shouldAssign: true, value: this.cloneValue(schema.defaultValue) };
-            }
-            if (schema.type === 'shape' && schema.shape) {
-                const nestedDefaults = this.applyDefaults(schema.shape);
-                if (Object.keys(nestedDefaults).length > 0) {
-                    return { shouldAssign: true, value: nestedDefaults };
-                }
-            }
-            return { shouldAssign: false };
-        }
-        const typeResult = this.validateType(value, schema, pathSegments, mode, errors);
-        if (!typeResult.valid) {
-            if (schema.type === 'shape' &&
-                typeResult.value &&
-                this.isPlainObject(typeResult.value)) {
-                return { shouldAssign: true, value: typeResult.value };
-            }
-            errors.push({ path, message: typeResult.error ?? 'Invalid value', value });
-            if (schema.defaultValue !== undefined) {
-                return { shouldAssign: true, value: this.cloneValue(schema.defaultValue) };
-            }
-            if (schema.type === 'shape' && schema.shape) {
-                const nestedDefaults = this.applyDefaults(schema.shape);
-                if (Object.keys(nestedDefaults).length > 0) {
-                    return { shouldAssign: true, value: nestedDefaults };
-                }
-            }
-            return { shouldAssign: false };
-        }
-        return { shouldAssign: true, value: typeResult.value };
-    }
-    validateType(value, schema, pathSegments, mode, errors) {
-        const { type } = schema;
-        switch (type) {
-            case 'string':
-                return this.validateString(value, schema);
-            case 'number':
-                return this.validateNumber(value, schema);
-            case 'bool':
-                return this.validateBoolean(value);
-            case 'array':
-                return this.validateArray(value, schema);
-            case 'arrayOf':
-                return this.validateArrayOf(value, schema, pathSegments, mode, errors);
-            case 'object':
-                return this.validatePlainObject(value);
-            case 'shape':
-                return this.validateShape(value, schema, pathSegments, mode, errors);
-            case 'oneOfType':
-                return this.validateOneOfType(value, schema);
-            case 'func':
-                return this.validateFunction(value);
-            case 'node':
-                return { valid: true, value };
-            default:
-                return { valid: true, value };
-        }
-    }
-    validateString(value, schema) {
-        if (typeof value !== 'string') {
-            return { valid: false, error: `Expected string, got ${this.describeType(value)}` };
-        }
-        if (schema.oneOf && !schema.oneOf.includes(value)) {
-            return { valid: false, error: `Expected one of: ${schema.oneOf.join(', ')}` };
-        }
-        if (schema.minLength !== undefined && value.length < schema.minLength) {
-            return { valid: false, error: `String length must be >= ${schema.minLength}` };
-        }
-        if (schema.maxLength !== undefined && value.length > schema.maxLength) {
-            return { valid: false, error: `String length must be <= ${schema.maxLength}` };
-        }
-        if (schema.pattern) {
-            const pattern = new RegExp(schema.pattern);
-            if (!pattern.test(value)) {
-                return { valid: false, error: `String does not match pattern ${schema.pattern}` };
-            }
-        }
-        return { valid: true, value };
-    }
-    validateNumber(value, schema) {
-        if (typeof value !== 'number' || Number.isNaN(value)) {
-            return { valid: false, error: `Expected number, got ${this.describeType(value)}` };
-        }
-        if (schema.min !== undefined && value < schema.min) {
-            return { valid: false, error: `Number must be >= ${schema.min}` };
-        }
-        if (schema.max !== undefined && value > schema.max) {
-            return { valid: false, error: `Number must be <= ${schema.max}` };
-        }
-        if (schema.oneOf && !schema.oneOf.includes(value)) {
-            return { valid: false, error: `Expected one of: ${schema.oneOf.join(', ')}` };
-        }
-        return { valid: true, value };
-    }
-    validateBoolean(value) {
-        if (typeof value !== 'boolean') {
-            return { valid: false, error: `Expected boolean, got ${this.describeType(value)}` };
-        }
-        return { valid: true, value };
-    }
-    validateArray(value, schema) {
-        if (!Array.isArray(value)) {
-            return { valid: false, error: `Expected array, got ${this.describeType(value)}` };
-        }
-        if (schema.minLength !== undefined && value.length < schema.minLength) {
-            return { valid: false, error: `Array length must be >= ${schema.minLength}` };
-        }
-        if (schema.maxLength !== undefined && value.length > schema.maxLength) {
-            return { valid: false, error: `Array length must be <= ${schema.maxLength}` };
-        }
-        return { valid: true, value: [...value] };
-    }
-    validateArrayOf(value, schema, pathSegments, mode, errors) {
-        const base = this.validateArray(value, schema);
-        if (!base.valid)
-            return base;
-        const itemValues = [];
-        const itemType = schema.itemType;
-        const itemOneOf = schema.itemOneOf;
-        const beforeErrors = errors.length;
-        base.value.forEach((item, index) => {
-            const itemPath = [...pathSegments, String(index)];
-            if (itemType) {
-                const result = this.validateType(item, { type: itemType }, itemPath, mode, errors);
-                if (!result.valid) {
-                    errors.push({
-                        path: this.buildPath(itemPath),
-                        message: result.error ?? 'Invalid array item',
-                        value: item,
-                    });
-                }
-                else {
-                    itemValues.push(result.value);
-                }
-            }
-            else {
-                itemValues.push(item);
-            }
-            if (itemOneOf && !itemOneOf.includes(item)) {
-                errors.push({
-                    path: this.buildPath(itemPath),
-                    message: `Array item must be one of: ${itemOneOf.join(', ')}`,
-                    value: item,
-                });
-            }
-        });
-        return { valid: errors.length === beforeErrors, value: itemValues };
-    }
-    validatePlainObject(value) {
-        if (!this.isPlainObject(value)) {
-            return { valid: false, error: `Expected object, got ${this.describeType(value)}` };
-        }
-        return { valid: true, value: { ...value } };
-    }
-    validateFunction(value) {
-        if (typeof value !== 'function') {
-            return { valid: false, error: `Expected function, got ${this.describeType(value)}` };
-        }
-        return { valid: true, value };
-    }
-    validateShape(value, schema, pathSegments, mode, errors) {
-        if (!this.isPlainObject(value)) {
-            return { valid: false, error: `Expected object, got ${this.describeType(value)}` };
-        }
-        const beforeErrors = errors.length;
-        const nested = this.validateObject(value, schema.shape ?? {}, mode, pathSegments, errors);
-        return { valid: errors.length === beforeErrors, value: nested };
-    }
-    validateOneOfType(value, schema) {
-        const types = schema.types ?? [];
-        const matches = types.some(typeName => this.matchesType(value, typeName));
-        if (!matches) {
-            return {
-                valid: false,
-                error: `Value does not match any allowed type: ${types.join(', ')}`,
-            };
-        }
-        return { valid: true, value };
-    }
-    matchesType(value, typeName) {
-        switch (typeName) {
-            case 'string': return typeof value === 'string';
-            case 'number': return typeof value === 'number' && !Number.isNaN(value);
-            case 'bool':
-            case 'boolean': return typeof value === 'boolean';
-            case 'array': return Array.isArray(value);
-            case 'object': return this.isPlainObject(value);
-            case 'func':
-            case 'function': return typeof value === 'function';
-            case 'shape': return this.isPlainObject(value);
-            case 'node': return value === null || value === undefined || typeof value !== 'symbol';
-            default: return true;
-        }
-    }
-    applyDefaults(schema) {
-        const defaults = {};
-        for (const [key, propSchema] of Object.entries(schema)) {
-            if (propSchema.defaultValue !== undefined) {
-                defaults[key] = this.cloneValue(propSchema.defaultValue);
-                continue;
-            }
-            if (propSchema.type === 'shape' && propSchema.shape) {
-                const nestedDefaults = this.applyDefaults(propSchema.shape);
-                if (Object.keys(nestedDefaults).length > 0) {
-                    defaults[key] = nestedDefaults;
-                }
-            }
-        }
-        return defaults;
-    }
-    cloneValue(value) {
-        if (Array.isArray(value)) {
-            return value.map(item => this.cloneValue(item));
-        }
-        if (this.isPlainObject(value)) {
-            const cloned = {};
-            for (const [key, nested] of Object.entries(value)) {
-                cloned[key] = this.cloneValue(nested);
-            }
-            return cloned;
-        }
-        return value;
-    }
-    isPlainObject(value) {
-        return typeof value === 'object' && value !== null && !Array.isArray(value);
-    }
-    isNil(value) {
-        return value === null || value === undefined;
-    }
-    buildPath(segments) {
-        return segments.join('.');
-    }
-    describeType(value) {
-        if (Array.isArray(value))
-            return 'array';
-        if (value === null)
-            return 'null';
-        return typeof value;
-    }
-}
-//# sourceMappingURL=props-validator.js.map

package/dist/esm/layout/renderer.js

@@ -1,180 +0,0 @@
-/**
- * LayoutRenderer — Handlebars-based layout rendering.
- * Ported from packages/sdk-bak/src/services/layout-renderer.service.ts.
- * Excluded: formatConversation helper, registerTemplateHelpers (exec/shell-quote).
- * Exec is handled separately by TemplateEngine in the facade layer.
- */
-import Handlebars from 'handlebars';
-import { PropsValidator } from './props-validator';
-import { PropsValidationError as LayoutPropsValidationError } from './types';
-export { PropsValidationError } from './types';
-/**
- * LayoutRenderer — renders layout templates with Handlebars.
- */
-export class LayoutRenderer {
-    handlebars;
-    propsValidator;
-    constructor(propsValidator) {
-        this.handlebars = Handlebars.create();
-        this.propsValidator = propsValidator ?? new PropsValidator();
-        this.registerHelpers();
-    }
-    /**
-     * Render a layout template with the given context.
-     */
-    render(layout, context, options = {}) {
-        try {
-            const preparedContext = this.prepareRenderContext(layout, context, options);
-            const template = this.handlebars.compile(layout.template, { noEscape: true });
-            return template(preparedContext);
-        }
-        catch (error) {
-            if (error instanceof Error) {
-                throw new Error(`Template rendering failed for layout '${layout.id}': ${error.message}`);
-            }
-            throw new Error(`Unknown error rendering layout '${layout.id}'`);
-        }
-    }
-    /**
-     * Validate props against schema.
-     */
-    validate(props, propsSchema, mode = 'lenient') {
-        return this.executeValidation(props, propsSchema, mode);
-    }
-    /**
-     * Merge default props and runtime props, then validate.
-     */
-    resolveProps(layout, props, mode = 'lenient') {
-        const mergedProps = this.mergeProps(layout.defaultProps, props);
-        if (!layout.propsSchema || Object.keys(layout.propsSchema).length === 0) {
-            return { valid: true, props: mergedProps, errors: [] };
-        }
-        return this.executeValidation(mergedProps, layout.propsSchema, mode);
-    }
-    prepareRenderContext(layout, context, options) {
-        const { validationMode = 'lenient', skipValidation = false } = options;
-        const resolvedProps = skipValidation
-            ? this.mergeProps(layout.defaultProps, context.props)
-            : this.resolveProps(layout, context.props, validationMode).props;
-        return {
-            ...context,
-            vars: this.sanitizeVars(context.vars),
-            props: resolvedProps,
-        };
-    }
-    /**
-     * Register built-in Handlebars helpers (no exec, no formatConversation).
-     */
-    registerHelpers() {
-        // Built-in block helpers
-        if (Handlebars.helpers.each) {
-            this.handlebars.registerHelper('each', Handlebars.helpers.each);
-        }
-        if (Handlebars.helpers.if) {
-            this.handlebars.registerHelper('if', Handlebars.helpers.if);
-        }
-        if (Handlebars.helpers.unless) {
-            this.handlebars.registerHelper('unless', Handlebars.helpers.unless);
-        }
-        if (Handlebars.helpers.with) {
-            this.handlebars.registerHelper('with', Handlebars.helpers.with);
-        }
-        this.handlebars.registerHelper('eq', function (a, b) {
-            return a === b;
-        });
-        this.handlebars.registerHelper('ne', function (a, b) {
-            return a !== b;
-        });
-        this.handlebars.registerHelper('gt', function (a, b) {
-            return a > b;
-        });
-        this.handlebars.registerHelper('lt', function (a, b) {
-            return a < b;
-        });
-        this.handlebars.registerHelper('json', function (obj) {
-            return new Handlebars.SafeString(JSON.stringify(obj));
-        });
-        this.handlebars.registerHelper('raw', function (options) {
-            return typeof options?.fn === 'function' ? options.fn(this) : '';
-        });
-        this.handlebars.registerHelper('escapeHandlebars', function (text) {
-            if (typeof text !== 'string')
-                return '';
-            return text.replace(/\{\{/g, '&#123;&#123;').replace(/\}\}/g, '&#125;&#125;');
-        });
-        this.handlebars.registerHelper('formatFileSize', function (bytes) {
-            if (bytes === 0)
-                return '0 B';
-            const sizes = ['B', 'KB', 'MB', 'GB'];
-            const i = Math.floor(Math.log(bytes) / Math.log(1024));
-            return Math.round((bytes / Math.pow(1024, i)) * 100) / 100 + ' ' + sizes[i];
-        });
-    }
-    executeValidation(props, propsSchema, mode) {
-        try {
-            return this.propsValidator.validate(props, propsSchema, mode);
-        }
-        catch (error) {
-            if (error instanceof LayoutPropsValidationError && error.errors && error.errors.length > 0) {
-                const firstError = error.errors[0];
-                if (firstError) {
-                    throw new LayoutPropsValidationError(firstError.message, error.errors);
-                }
-            }
-            throw error;
-        }
-    }
-    mergeProps(defaultProps, overrides) {
-        const base = this.cloneDeep(defaultProps ?? {});
-        if (!overrides)
-            return base;
-        return this.deepMerge(base, overrides);
-    }
-    deepMerge(target, source) {
-        for (const [key, value] of Object.entries(source)) {
-            if (this.isPlainObject(value)) {
-                const existing = target[key];
-                target[key] = this.deepMerge(this.isPlainObject(existing) ? existing : {}, value);
-                continue;
-            }
-            if (Array.isArray(value)) {
-                target[key] = this.cloneDeep(value);
-                continue;
-            }
-            target[key] = value;
-        }
-        return target;
-    }
-    cloneDeep(value) {
-        if (Array.isArray(value)) {
-            return value.map(item => this.cloneDeep(item));
-        }
-        if (this.isPlainObject(value)) {
-            const cloned = {};
-            for (const [key, nested] of Object.entries(value)) {
-                cloned[key] = this.cloneDeep(nested);
-            }
-            return cloned;
-        }
-        return value;
-    }
-    isPlainObject(value) {
-        return typeof value === 'object' && value !== null && !Array.isArray(value);
-    }
-    sanitizeVars(vars) {
-        if (!vars)
-            return {};
-        const sanitizedVars = { ...vars };
-        if (typeof vars.user_input === 'string') {
-            sanitizedVars.user_input_raw = vars.user_input;
-            const escapedHandlebars = vars.user_input
-                .replace(/\{\{\{/g, '&#123;&#123;&#123;')
-                .replace(/\}\}\}/g, '&#125;&#125;&#125;')
-                .replace(/\{\{/g, '&#123;&#123;')
-                .replace(/\}\}/g, '&#125;&#125;');
-            sanitizedVars.user_input = this.handlebars.escapeExpression(escapedHandlebars);
-        }
-        return sanitizedVars;
-    }
-}
-//# sourceMappingURL=renderer.js.map

package/dist/esm/layout/types.js

@@ -1,31 +0,0 @@
-/**
- * Layout system type definitions for CrewX SDK.
- * Ported from packages/sdk-bak/src/types/layout.types.ts (1:1, import path only changed).
- */
-/**
- * Error thrown when layout loading fails.
- */
-export class LayoutLoadError extends Error {
-    layoutId;
-    cause;
-    constructor(message, layoutId, cause) {
-        super(message);
-        this.layoutId = layoutId;
-        this.cause = cause;
-        this.name = 'LayoutLoadError';
-    }
-}
-/**
- * Error thrown when props validation fails (strict mode).
- */
-export class PropsValidationError extends Error {
-    errors;
-    cause;
-    constructor(message, errors = [], cause) {
-        super(message);
-        this.errors = errors;
-        this.cause = cause;
-        this.name = 'PropsValidationError';
-    }
-}
-//# sourceMappingURL=types.js.map

package/dist/esm/parallel/agent-runtime.js

@@ -1,21 +0,0 @@
-/**
- * Minimal AgentRuntime for the parallel execution module.
- * Provides query/execute methods to run agent operations.
- * Tests use vi.spyOn(AgentRuntime.prototype, 'query') to mock these methods.
- */
-/**
- * Runtime that executes agent query/execute operations.
- * Default implementation throws — callers must inject a working provider
- * or mock the prototype methods in tests.
- */
-export class AgentRuntime {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async query(_request) {
-        throw new Error('AgentRuntime.query is not implemented. Provide a subclass or mock AgentRuntime.prototype.query.');
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async execute(_request) {
-        throw new Error('AgentRuntime.execute is not implemented. Provide a subclass or mock AgentRuntime.prototype.execute.');
-    }
-}
-//# sourceMappingURL=agent-runtime.js.map