@syrin/cli 1.3.0

package/dist/runtime/test/synthetic-input-generator.js

@@ -0,0 +1,154 @@
+/**
+ * Generate system-level synthetic test inputs from tool input schema.
+ * These inputs test edge cases, type validations, and boundary conditions.
+ */
+/**
+ * Generate synthetic test inputs from a JSON schema.
+ * @param schema - Input schema (JSON Schema format)
+ * @returns Array of synthetic test inputs
+ */
+export function generateSyntheticInputs(schema) {
+    const inputs = [];
+    if (!schema || typeof schema !== 'object') {
+        return inputs;
+    }
+    const jsonSchema = schema;
+    // Handle object schemas with properties
+    if (jsonSchema.type === 'object' && jsonSchema.properties) {
+        const properties = jsonSchema.properties;
+        const required = jsonSchema.required || [];
+        // Generate edge case inputs for each property
+        for (const [propName, propSchema] of Object.entries(properties)) {
+            const prop = propSchema;
+            const propType = Array.isArray(prop.type) ? prop.type[0] : prop.type;
+            // Generate edge case values based on property type
+            const edgeCases = generateEdgeCasesForProperty(propName, prop, propType);
+            for (const edgeCase of edgeCases) {
+                inputs.push(edgeCase);
+            }
+        }
+        // Generate input with all required fields (minimal valid input)
+        if (required.length > 0) {
+            const minimalInput = {};
+            for (const reqField of required) {
+                const propSchema = properties[reqField];
+                const propType = Array.isArray(propSchema?.type)
+                    ? propSchema.type[0]
+                    : propSchema?.type;
+                minimalInput[reqField] = getDefaultValue(propType);
+            }
+            inputs.push(minimalInput);
+        }
+    }
+    // Remove duplicates
+    return removeDuplicateInputs(inputs);
+}
+/**
+ * Generate edge case values for a specific property.
+ */
+function generateEdgeCasesForProperty(propName, propSchema, propType) {
+    const edgeCases = [];
+    if (propSchema.enum) {
+        // For enums, test each enum value
+        for (const enumValue of propSchema.enum) {
+            edgeCases.push({ [propName]: enumValue });
+        }
+    }
+    else {
+        switch (propType) {
+            case 'string':
+                edgeCases.push({ [propName]: '' }, // Empty string
+                { [propName]: 'test' }, // Normal string
+                ...(propSchema.minLength !== undefined ? [] : [
+                    { [propName]: 'a'.repeat(100) }, // Long string
+                ]));
+                break;
+            case 'number':
+            case 'integer':
+                edgeCases.push({ [propName]: 0 }, { [propName]: 1 }, { [propName]: -1 }, ...(propSchema.minimum !== undefined ? [] : [
+                    { [propName]: Number.MAX_SAFE_INTEGER },
+                ]), ...(propSchema.maximum !== undefined ? [] : [
+                    { [propName]: Number.MIN_SAFE_INTEGER },
+                ]));
+                break;
+            case 'boolean':
+                edgeCases.push({ [propName]: true }, { [propName]: false });
+                break;
+            case 'array':
+                edgeCases.push({ [propName]: [] }, // Empty array
+                { [propName]: [1, 2, 3] } // Array with values
+                );
+                break;
+            case 'object':
+                edgeCases.push({ [propName]: {} }, // Empty object
+                { [propName]: { key: 'value' } } // Object with values
+                );
+                break;
+            default:
+                // For unknown types, generate a basic test value
+                edgeCases.push({ [propName]: null });
+                break;
+        }
+    }
+    return edgeCases;
+}
+/**
+ * Get a default value for a property type.
+ */
+function getDefaultValue(propType) {
+    switch (propType) {
+        case 'string':
+            return 'test';
+        case 'number':
+        case 'integer':
+            return 0;
+        case 'boolean':
+            return false;
+        case 'array':
+            return [];
+        case 'object':
+            return {};
+        default:
+            return null;
+    }
+}
+/**
+ * Remove duplicate inputs by normalizing and comparing JSON representation.
+ */
+function removeDuplicateInputs(inputs) {
+    const seen = new Set();
+    const unique = [];
+    for (const input of inputs) {
+        const normalized = deepSortObject(input);
+        const key = JSON.stringify(normalized);
+        if (!seen.has(key)) {
+            seen.add(key);
+            unique.push(input);
+        }
+    }
+    return unique;
+}
+/**
+ * Recursively sort object keys for deterministic comparison.
+ */
+function deepSortObject(obj) {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(item => deepSortObject(item));
+    }
+    if (typeof obj === 'object') {
+        const sorted = {};
+        const keys = Object.keys(obj).sort();
+        for (const key of keys) {
+            const value = obj[key];
+            if (value !== undefined) {
+                sorted[key] = deepSortObject(value);
+            }
+        }
+        return sorted;
+    }
+    return obj;
+}
+//# sourceMappingURL=synthetic-input-generator.js.map

package/dist/runtime/test/test-runner.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Test input runner.
+ * Executes tools with contract-defined test inputs.
+ */
+import type { ToolContract } from './contract-types.js';
+import type { SandboxExecutor, ToolExecutionResult } from '../../runtime/sandbox/index.js';
+/**
+ * Test execution result with metadata.
+ */
+export type TestExecutionResult = ToolExecutionResult & {
+    /** Test case name */
+    testName: string;
+    /** Test input used */
+    testInput: Record<string, unknown>;
+    /** Test expectation */
+    expectation?: import('./contract-types.js').TestExpectation;
+    /** Expected output schema name (optional, for tests expecting different output schema) */
+    expectedOutputSchema?: string;
+};
+/**
+ * Run contract-defined test cases.
+ * @param executor - Sandbox executor
+ * @param contract - Tool contract
+ * @param determinismRuns - Number of runs for deterministic tests (default: 1)
+ * @returns Array of test execution results
+ */
+export declare function runContractTests(executor: SandboxExecutor, contract: ToolContract, toolTimeoutMs?: number): Promise<TestExecutionResult[]>;
+//# sourceMappingURL=test-runner.d.ts.map

package/dist/runtime/test/test-runner.js

@@ -0,0 +1,55 @@
+/**
+ * Test input runner.
+ * Executes tools with contract-defined test inputs.
+ */
+/**
+ * Run contract-defined test cases.
+ * @param executor - Sandbox executor
+ * @param contract - Tool contract
+ * @param determinismRuns - Number of runs for deterministic tests (default: 1)
+ * @returns Array of test execution results
+ */
+export async function runContractTests(executor, contract, toolTimeoutMs) {
+    if (!contract.tests || contract.tests.length === 0) {
+        return [];
+    }
+    const results = [];
+    for (const test of contract.tests) {
+        // Set environment variables if specified
+        const originalEnv = { ...process.env };
+        if (test.env) {
+            for (const [key, value] of Object.entries(test.env)) {
+                process.env[key] = value;
+            }
+        }
+        try {
+            // Execute tool with test input (run once)
+            const executionResults = await executor.executeTool(contract.tool, [test.input], toolTimeoutMs);
+            // Map to test execution results
+            for (const result of executionResults) {
+                results.push({
+                    ...result,
+                    testName: test.name,
+                    testInput: test.input,
+                    expectation: test.expect,
+                });
+            }
+        }
+        finally {
+            // Restore environment properly (avoid reassigning process.env which breaks Node's proxy)
+            // Remove any keys that were added
+            const currentKeys = Object.keys(process.env);
+            for (const key of currentKeys) {
+                if (!(key in originalEnv)) {
+                    delete process.env[key];
+                }
+            }
+            // Restore any keys that were changed
+            for (const [key, value] of Object.entries(originalEnv)) {
+                process.env[key] = value;
+            }
+        }
+    }
+    return results;
+}
+//# sourceMappingURL=test-runner.js.map

package/dist/types/factories.d.ts

@@ -0,0 +1,16 @@
+import type { SessionID, EventID, ISO8601Timestamp, WorkflowID, PromptID, ProjectName, AgentName, MCPURL, Command, APIKey, ModelName, ProviderIdentifier, ScriptCommand, SyrinVersion } from '../types/ids.js';
+export declare function makeSessionID(value: string): SessionID;
+export declare function makeEventID(value: string): EventID;
+export declare function makeTimestamp(value: string): ISO8601Timestamp;
+export declare function makeWorkflowID(value: string): WorkflowID;
+export declare function makePromptID(value: string): PromptID;
+export declare function makeProjectName(value: string): ProjectName;
+export declare function makeAgentName(value: string): AgentName;
+export declare function makeMCPURL(value: string): MCPURL;
+export declare function makeCommand(value: string): Command;
+export declare function makeAPIKey(value: string): APIKey;
+export declare function makeModelName(value: string): ModelName;
+export declare function makeProviderIdentifier(value: string): ProviderIdentifier;
+export declare function makeScriptCommand(value: string): ScriptCommand;
+export declare function makeSyrinVersion(value: string): SyrinVersion;
+//# sourceMappingURL=factories.d.ts.map

package/dist/types/factories.js

@@ -0,0 +1,43 @@
+export function makeSessionID(value) {
+    return value;
+}
+export function makeEventID(value) {
+    return value;
+}
+export function makeTimestamp(value) {
+    return value;
+}
+export function makeWorkflowID(value) {
+    return value;
+}
+export function makePromptID(value) {
+    return value;
+}
+export function makeProjectName(value) {
+    return value;
+}
+export function makeAgentName(value) {
+    return value;
+}
+export function makeMCPURL(value) {
+    return value;
+}
+export function makeCommand(value) {
+    return value;
+}
+export function makeAPIKey(value) {
+    return value;
+}
+export function makeModelName(value) {
+    return value;
+}
+export function makeProviderIdentifier(value) {
+    return value;
+}
+export function makeScriptCommand(value) {
+    return value;
+}
+export function makeSyrinVersion(value) {
+    return value;
+}
+//# sourceMappingURL=factories.js.map

package/dist/types/ids.d.ts

@@ -0,0 +1,16 @@
+import type { Opaque } from '../types/opaque.js';
+export type SessionID = Opaque<string, 'SessionID'>;
+export type EventID = Opaque<string, 'EventID'>;
+export type WorkflowID = Opaque<string, 'WorkflowID'>;
+export type PromptID = Opaque<string, 'PromptID'>;
+export type ISO8601Timestamp = Opaque<string, 'ISO8601Timestamp'>;
+export type ProjectName = Opaque<string, 'ProjectName'>;
+export type SyrinVersion = Opaque<string, 'SyrinVersion'>;
+export type AgentName = Opaque<string, 'AgentName'>;
+export type MCPURL = Opaque<string, 'MCPURL'>;
+export type Command = Opaque<string, 'Command'>;
+export type APIKey = Opaque<string, 'APIKey'>;
+export type ModelName = Opaque<string, 'ModelName'>;
+export type ProviderIdentifier = Opaque<string, 'ProviderIdentifier'>;
+export type ScriptCommand = Opaque<string, 'ScriptCommand'>;
+//# sourceMappingURL=ids.d.ts.map

package/dist/types/ids.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ids.js.map

package/dist/types/opaque.d.ts

@@ -0,0 +1,4 @@
+export type Opaque<T, Token extends string> = T & {
+    readonly __opaque: Token;
+};
+//# sourceMappingURL=opaque.d.ts.map

package/dist/types/opaque.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=opaque.js.map

package/dist/utils/errors.d.ts

@@ -0,0 +1,92 @@
+import type { EventEnvelope } from '../events/types.js';
+/**
+ * Normalize an unknown error value to an Error instance.
+ * This ensures consistent error handling across the codebase.
+ *
+ * @param error - Unknown error value (Error, string, or other)
+ * @returns Error instance
+ */
+export declare function normalizeError(error: unknown): Error;
+/**
+ * Extract error message from unknown error value.
+ * Returns a string representation of the error.
+ *
+ * @param error - Unknown error value
+ * @returns Error message string
+ */
+export declare function getErrorMessage(error: unknown): string;
+/**
+ * Base error class for all Syrin errors.
+ * All errors should extend this class to maintain consistency.
+ */
+export declare class SyrinError extends Error {
+    readonly code: string;
+    readonly event?: EventEnvelope;
+    readonly context?: Record<string, unknown>;
+    readonly cause?: Error;
+    constructor(message: string, code: string, options?: {
+        event?: EventEnvelope;
+        context?: Record<string, unknown>;
+        cause?: Error;
+    });
+}
+/**
+ * Configuration-related errors.
+ */
+export declare class ConfigurationError extends SyrinError {
+    constructor(message: string, options?: {
+        context?: Record<string, unknown>;
+        cause?: Error;
+    });
+}
+/**
+ * Transport layer errors.
+ */
+export declare class TransportError extends SyrinError {
+    constructor(message: string, options?: {
+        event?: EventEnvelope;
+        context?: Record<string, unknown>;
+        cause?: Error;
+    });
+}
+/**
+ * Validation errors.
+ */
+export declare class ValidationError extends SyrinError {
+    constructor(message: string, options?: {
+        event?: EventEnvelope;
+        context?: Record<string, unknown>;
+        cause?: Error;
+    });
+}
+/**
+ * Runtime errors.
+ */
+export declare class RuntimeError extends SyrinError {
+    constructor(message: string, options?: {
+        event?: EventEnvelope;
+        context?: Record<string, unknown>;
+        cause?: Error;
+    });
+}
+/**
+ * Adapter errors.
+ */
+export declare class AdapterError extends SyrinError {
+    constructor(message: string, options?: {
+        event?: EventEnvelope;
+        context?: Record<string, unknown>;
+        cause?: Error;
+    });
+}
+/**
+ * Event store errors.
+ */
+export declare class EventStoreError extends SyrinError {
+    constructor(message: string, options?: {
+        event?: EventEnvelope;
+        context?: Record<string, unknown>;
+        cause?: Error;
+    });
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/utils/errors.js

@@ -0,0 +1,97 @@
+/**
+ * Normalize an unknown error value to an Error instance.
+ * This ensures consistent error handling across the codebase.
+ *
+ * @param error - Unknown error value (Error, string, or other)
+ * @returns Error instance
+ */
+export function normalizeError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+/**
+ * Extract error message from unknown error value.
+ * Returns a string representation of the error.
+ *
+ * @param error - Unknown error value
+ * @returns Error message string
+ */
+export function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * Base error class for all Syrin errors.
+ * All errors should extend this class to maintain consistency.
+ */
+export class SyrinError extends Error {
+    code;
+    event;
+    context;
+    cause;
+    constructor(message, code, options) {
+        super(message);
+        this.name = 'SyrinError';
+        this.code = code;
+        this.event = options?.event;
+        this.context = options?.context;
+        this.cause = options?.cause;
+        // Maintain proper stack trace
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, SyrinError);
+        }
+    }
+}
+/**
+ * Configuration-related errors.
+ */
+export class ConfigurationError extends SyrinError {
+    constructor(message, options) {
+        super(message, 'CONFIG_ERROR', options);
+        this.name = 'ConfigurationError';
+    }
+}
+/**
+ * Transport layer errors.
+ */
+export class TransportError extends SyrinError {
+    constructor(message, options) {
+        super(message, 'TRANSPORT_ERROR', options);
+        this.name = 'TransportError';
+    }
+}
+/**
+ * Validation errors.
+ */
+export class ValidationError extends SyrinError {
+    constructor(message, options) {
+        super(message, 'VALIDATION_ERROR', options);
+        this.name = 'ValidationError';
+    }
+}
+/**
+ * Runtime errors.
+ */
+export class RuntimeError extends SyrinError {
+    constructor(message, options) {
+        super(message, 'RUNTIME_ERROR', options);
+        this.name = 'RuntimeError';
+    }
+}
+/**
+ * Adapter errors.
+ */
+export class AdapterError extends SyrinError {
+    constructor(message, options) {
+        super(message, 'ADAPTER_ERROR', options);
+        this.name = 'AdapterError';
+    }
+}
+/**
+ * Event store errors.
+ */
+export class EventStoreError extends SyrinError {
+    constructor(message, options) {
+        super(message, 'EVENT_STORE_ERROR', options);
+        this.name = 'EventStoreError';
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/utils/gitignore.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Utilities for managing .gitignore file.
+ */
+/**
+ * Ensure .gitignore exists and contains the specified pattern.
+ * @param projectRoot - Project root directory
+ * @param pattern - Pattern to add to .gitignore
+ * @returns true if pattern was added, false if it already existed
+ */
+export declare function ensureGitignorePattern(projectRoot: string, pattern: string): Promise<boolean>;
+//# sourceMappingURL=gitignore.d.ts.map

package/dist/utils/gitignore.js

@@ -0,0 +1,59 @@
+/**
+ * Utilities for managing .gitignore file.
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+/**
+ * Ensure .gitignore exists and contains the specified pattern.
+ * @param projectRoot - Project root directory
+ * @param pattern - Pattern to add to .gitignore
+ * @returns true if pattern was added, false if it already existed
+ */
+export async function ensureGitignorePattern(projectRoot, pattern) {
+    const gitignorePath = path.join(projectRoot, '.gitignore');
+    let content = '';
+    try {
+        content = await fs.readFile(gitignorePath, 'utf-8');
+    }
+    catch (error) {
+        // File doesn't exist, create it
+        const err = error;
+        if (err.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    // Normalize line endings and split into lines
+    const lines = content
+        .replace(/\r\n/g, '\n')
+        .split('\n')
+        .map(line => line.trim());
+    // Check if pattern already exists (exact match or commented out)
+    const patternExists = lines.some(line => line === pattern || line === `# ${pattern}` || line.endsWith(pattern));
+    if (patternExists) {
+        return false;
+    }
+    // Add pattern to .gitignore
+    // Add a blank line if file is not empty and doesn't end with newline
+    if (content && !content.endsWith('\n')) {
+        content += '\n';
+    }
+    // Add pattern to .gitignore
+    if (content) {
+        // Check if we already have a "Syrin" section
+        if (content.includes('# Syrin')) {
+            // Add to existing Syrin section
+            content += `${pattern}\n`;
+        }
+        else {
+            // Create new section with generic comment
+            content += `\n# Syrin files\n${pattern}\n`;
+        }
+    }
+    else {
+        // Create new file with generic comment
+        content = `# Syrin files\n${pattern}\n`;
+    }
+    await fs.writeFile(gitignorePath, content, 'utf-8');
+    return true;
+}
+//# sourceMappingURL=gitignore.js.map

package/dist/utils/json-file-saver.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Utilities for saving large JSON data to external files.
+ */
+/**
+ * Save JSON data to a file.
+ * Returns the file path.
+ */
+export declare function saveJSONToFile(data: unknown, toolName: string, outputDir?: string): string;
+/**
+ * Get the size of a file in human-readable format.
+ */
+export declare function getFileSize(filePath: string): string;
+/**
+ * Format a file path for display (shorten if too long).
+ */
+export declare function formatFilePath(filePath: string, maxLength?: number): string;
+//# sourceMappingURL=json-file-saver.d.ts.map