@sowonai/crewx-sdk 0.1.0-dev.2 → 0.1.0-dev.20

package/dist/types/provider.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.types.js","sourceRoot":"","sources":["../../src/types/provider.types.ts"],"names":[],"mappings":""}

package/dist/types/skill-runtime.types.d.ts

@@ -0,0 +1,244 @@
+import { SkillMetadata, SkillContent, SkillDefinition, SkillValidationError as SkillValidationDetail, SkillValidationResult } from '../schema/skills.types';
+import { AgentDefinition } from '../schema/skills.types';
+export type SkillRuntimeStage = 'load' | 'validate' | 'prepare' | 'execute' | 'cleanup';
+export interface SkillLoadOptions {
+    validationMode?: 'strict' | 'lenient';
+    loadContent?: boolean;
+    resolveDependencies?: boolean;
+    searchPaths?: string[];
+    cache?: boolean;
+    filters?: {
+        include?: string[];
+        exclude?: string[];
+    };
+}
+export interface SkillExecutionContext {
+    skillName: string;
+    skillVersion: string;
+    workingDirectory: string;
+    environment: Record<string, string>;
+    timeout: number;
+    runtimeRequirements: {
+        python?: string;
+        node?: string;
+        docker?: boolean;
+        memory?: string;
+        [key: string]: string | boolean | undefined;
+    };
+    configuration: {
+        metadata: SkillMetadata;
+        content?: SkillContent;
+        agentConfig: AgentDefinition;
+    };
+    options: {
+        validationMode: 'strict' | 'lenient';
+        progressiveLoading: boolean;
+        cacheEnabled: boolean;
+    };
+    executionId: string;
+    startTime: Date;
+}
+export interface SDKExecutionContext extends SkillExecutionContext {
+    services: {
+        layoutLoader?: any;
+        templateContext?: any;
+        agentFactory?: any;
+    };
+}
+export interface CLIExecutionContext extends SkillExecutionContext {
+    cliOptions: {
+        verbose?: boolean;
+        dryRun?: boolean;
+        debugMode?: boolean;
+        interactive?: boolean;
+    };
+    terminal: {
+        width: number;
+        height: number;
+        interactive: boolean;
+    };
+}
+export interface SkillExecutionResult {
+    success: boolean;
+    output?: string;
+    error?: Error;
+    metadata: {
+        executionId: string;
+        executionTime: number;
+        memoryUsage?: number;
+        dependenciesUsed: string[];
+        cacheHits: number;
+        cacheMisses: number;
+    };
+    artifacts?: {
+        type: 'file' | 'directory' | 'url';
+        path: string;
+        description?: string;
+    }[];
+}
+export interface IProgressiveSkillLoader {
+    loadMetadata(skillPaths: string[]): Promise<SkillMetadata[]>;
+    loadFullContent(skillName: string): Promise<SkillDefinition>;
+    isFullyLoaded(skillName: string): boolean;
+    preloadContent(skillNames: string[]): Promise<void>;
+    clearContentCache(): Promise<void>;
+}
+export interface SkillCacheStats {
+    metadataCache: {
+        count: number;
+        size: number;
+        hitRate: number;
+    };
+    contentCache: {
+        count: number;
+        size: number;
+        hitRate: number;
+    };
+    total: {
+        size: number;
+        hitRate: number;
+    };
+}
+export interface ISkillRuntime {
+    loadSkills(options?: SkillLoadOptions): Promise<SkillMetadata[]>;
+    validateSkill(skillName: string): Promise<SkillValidationResult>;
+    prepareContext(skillName: string, agentConfig: AgentDefinition, options?: Partial<SkillExecutionContext>): Promise<SkillExecutionContext>;
+    executeSkill(context: SkillExecutionContext, input: string): Promise<SkillExecutionResult>;
+    cleanup(context: SkillExecutionContext): Promise<void>;
+    listAvailableSkills(): Promise<string[]>;
+    getSkillMetadata(skillName: string): Promise<SkillMetadata | null>;
+    getSkillDefinition(skillName: string): Promise<SkillDefinition | null>;
+    resolveDependencies(skillName: string): Promise<SkillResolutionResult>;
+    clearCache(): Promise<void>;
+    getCacheStats(): SkillCacheStats;
+    getRuntimeInfo(): SkillRuntimeInfo;
+    shutdown(): Promise<void>;
+}
+export interface SkillResolutionResult {
+    name: string;
+    definition: SkillDefinition;
+    dependencies: SkillResolutionResult[];
+    sourcePath: string;
+    metadata: {
+        resolvedAt: Date;
+        version: string;
+        dependenciesCount: number;
+    };
+}
+export interface SkillRuntimeInfo {
+    version: string;
+    startTime: Date;
+    skillsLoaded: number;
+    uptime: number;
+    memoryUsage: {
+        rss: number;
+        heapUsed: number;
+        heapTotal: number;
+    };
+}
+export interface IClaudeSkillAdapter {
+    extractMetadata(skillFilePath: string): Promise<SkillMetadata>;
+    parseContent(fullContent: string): SkillContent;
+    mapToCrewXAgent(skill: SkillDefinition): AgentDefinition;
+    validateSkillFile(filePath: string): Promise<SkillValidationResult>;
+    discoverSkills(directory: string): Promise<string[]>;
+}
+export interface SkillExecutionErrorDetails {
+    stage: SkillRuntimeStage;
+    skillName: string;
+    executionId?: string;
+    error: Error;
+    recoverable: boolean;
+    suggestions: string[];
+    timestamp: Date;
+}
+export interface SkillRuntimeEvents {
+    'skill:loaded': {
+        skillName: string;
+        metadata: SkillMetadata;
+    };
+    'skill:validated': {
+        skillName: string;
+        result: SkillValidationResult;
+    };
+    'skill:executed': {
+        skillName: string;
+        result: SkillExecutionResult;
+    };
+    'skill:error': {
+        error: SkillExecutionErrorDetails;
+    };
+    'cache:cleared': {};
+    'runtime:shutdown': {};
+}
+export interface ProgressiveDisclosureConfig {
+    enabled: boolean;
+    metadataCacheTTL: number;
+    contentCacheTTL: number;
+    maxPreloadSkills: number;
+    preloadStrategy: 'recent' | 'popular' | 'dependency' | 'none';
+    contentLoadThreshold: number;
+}
+export interface RuntimeRequirementsValidator {
+    validatePython(requirement: string): Promise<boolean>;
+    validateNode(requirement: string): Promise<boolean>;
+    validateDocker(): Promise<boolean>;
+    validateMemory(requirement: string): Promise<boolean>;
+    getCurrentRuntime(): Promise<RuntimeInfo>;
+}
+export interface RuntimeInfo {
+    python?: {
+        version: string;
+        available: boolean;
+    };
+    node?: {
+        version: string;
+        available: boolean;
+    };
+    docker?: {
+        version: string;
+        available: boolean;
+    };
+    memory: {
+        total: number;
+        available: number;
+    };
+}
+export interface SkillBundleInfo {
+    id: string;
+    version: string;
+    skills: string[];
+    metadata: {
+        name: string;
+        description: string;
+        author?: string;
+        createdAt: Date;
+        size: number;
+    };
+    runtimeRequirements: {
+        python?: string;
+        node?: string;
+        docker?: boolean;
+        [key: string]: string | boolean | undefined;
+    };
+}
+export declare class SkillRuntimeError extends Error {
+    readonly stage: SkillRuntimeStage;
+    readonly skillName?: string | undefined;
+    readonly cause?: Error | undefined;
+    constructor(message: string, stage: SkillRuntimeStage, skillName?: string | undefined, cause?: Error | undefined);
+}
+export declare class ProgressiveLoadingError extends SkillRuntimeError {
+    constructor(message: string, skillName?: string, cause?: Error);
+}
+export declare class SkillValidationError extends SkillRuntimeError {
+    readonly validationErrors: SkillValidationDetail[];
+    constructor(message: string, validationErrors: SkillValidationDetail[], skillName?: string);
+}
+export declare class SkillExecutionError extends SkillRuntimeError {
+    readonly executionId: string;
+    constructor(message: string, skillName: string, executionId: string, cause?: Error);
+}
+export declare class SkillContextError extends SkillRuntimeError {
+    constructor(message: string, skillName?: string, cause?: Error);
+}

package/dist/types/skill-runtime.types.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillContextError = exports.SkillExecutionError = exports.SkillValidationError = exports.ProgressiveLoadingError = exports.SkillRuntimeError = void 0;
+class SkillRuntimeError extends Error {
+    constructor(message, stage, skillName, cause) {
+        super(message);
+        this.stage = stage;
+        this.skillName = skillName;
+        this.cause = cause;
+        this.name = 'SkillRuntimeError';
+    }
+}
+exports.SkillRuntimeError = SkillRuntimeError;
+class ProgressiveLoadingError extends SkillRuntimeError {
+    constructor(message, skillName, cause) {
+        super(message, 'load', skillName, cause);
+        this.name = 'ProgressiveLoadingError';
+    }
+}
+exports.ProgressiveLoadingError = ProgressiveLoadingError;
+class SkillValidationError extends SkillRuntimeError {
+    constructor(message, validationErrors, skillName) {
+        super(message, 'validate', skillName);
+        this.validationErrors = validationErrors;
+        this.name = 'SkillValidationError';
+    }
+}
+exports.SkillValidationError = SkillValidationError;
+class SkillExecutionError extends SkillRuntimeError {
+    constructor(message, skillName, executionId, cause) {
+        super(message, 'execute', skillName, cause);
+        this.executionId = executionId;
+        this.name = 'SkillExecutionError';
+    }
+}
+exports.SkillExecutionError = SkillExecutionError;
+class SkillContextError extends SkillRuntimeError {
+    constructor(message, skillName, cause) {
+        super(message, 'prepare', skillName, cause);
+        this.name = 'SkillContextError';
+    }
+}
+exports.SkillContextError = SkillContextError;
+//# sourceMappingURL=skill-runtime.types.js.map

package/dist/types/skill-runtime.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-runtime.types.js","sourceRoot":"","sources":["../../src/types/skill-runtime.types.ts"],"names":[],"mappings":";;;AA4YA,MAAa,iBAAkB,SAAQ,KAAK;IAC1C,YACE,OAAe,EACC,KAAwB,EACxB,SAAkB,EAClB,KAAa;QAE7B,KAAK,CAAC,OAAO,CAAC,CAAC;QAJC,UAAK,GAAL,KAAK,CAAmB;QACxB,cAAS,GAAT,SAAS,CAAS;QAClB,UAAK,GAAL,KAAK,CAAQ;QAG7B,IAAI,CAAC,IAAI,GAAG,mBAAmB,CAAC;IAClC,CAAC;CACF;AAVD,8CAUC;AAED,MAAa,uBAAwB,SAAQ,iBAAiB;IAC5D,YAAY,OAAe,EAAE,SAAkB,EAAE,KAAa;QAC5D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;QACzC,IAAI,CAAC,IAAI,GAAG,yBAAyB,CAAC;IACxC,CAAC;CACF;AALD,0DAKC;AAED,MAAa,oBAAqB,SAAQ,iBAAiB;IACzD,YACE,OAAe,EACC,gBAAyC,EACzD,SAAkB;QAElB,KAAK,CAAC,OAAO,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC;QAHtB,qBAAgB,GAAhB,gBAAgB,CAAyB;QAIzD,IAAI,CAAC,IAAI,GAAG,sBAAsB,CAAC;IACrC,CAAC;CACF;AATD,oDASC;AAED,MAAa,mBAAoB,SAAQ,iBAAiB;IACxD,YACE,OAAe,EACf,SAAiB,EACD,WAAmB,EACnC,KAAa;QAEb,KAAK,CAAC,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;QAH5B,gBAAW,GAAX,WAAW,CAAQ;QAInC,IAAI,CAAC,IAAI,GAAG,qBAAqB,CAAC;IACpC,CAAC;CACF;AAVD,kDAUC;AAED,MAAa,iBAAkB,SAAQ,iBAAiB;IACtD,YAAY,OAAe,EAAE,SAAkB,EAAE,KAAa;QAC5D,KAAK,CAAC,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;QAC5C,IAAI,CAAC,IAAI,GAAG,mBAAmB,CAAC;IAClC,CAAC;CACF;AALD,8CAKC"}

package/dist/types/template.types.d.ts

@@ -0,0 +1,38 @@
+import type { BaseMessage } from '../conversation/conversation-history.interface';
+export interface AgentMetadata {
+    specialties?: string[];
+    capabilities?: string[];
+    description?: string;
+}
+export interface TemplateVars {
+    security_key?: string;
+    [key: string]: unknown;
+}
+export interface BaseContext {
+    user_input?: string;
+    messages?: BaseMessage[];
+    mode?: 'query' | 'execute';
+    platform?: string;
+    env?: Record<string, string | undefined>;
+    tools?: {
+        list: Array<{
+            name: string;
+            description: string;
+            input_schema: any;
+            output_schema?: any;
+        }>;
+        json: string;
+        count: number;
+    };
+    vars?: TemplateVars;
+}
+export interface TemplateContext extends BaseContext {
+    agent?: {
+        id: string;
+        name: string;
+        provider?: string;
+        model?: string;
+        workingDirectory?: string;
+    };
+    agentMetadata?: AgentMetadata;
+}

package/dist/types/template.types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=template.types.js.map

package/dist/types/template.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"template.types.js","sourceRoot":"","sources":["../../src/types/template.types.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sowonai/crewx-sdk",
-  "version": "0.1.0-dev.2",
+  "version": "0.1.0-dev.20",
   "license": "Apache-2.0",
   "description": "SowonAI CrewX SDK",
   "type": "commonjs",
@@ -12,16 +12,6 @@
     "README.md",
     "LICENSE"
   ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "test": "vitest run --config ./vitest.config.ts",
-    "test:watch": "vitest --config ./vitest.config.ts",
-    "test:ui": "vitest --ui --config ./vitest.config.ts",
-    "test:unit": "vitest run --config ./vitest.config.ts tests/unit/**/*.test.ts",
-    "test:integration": "vitest run --config ./vitest.config.ts tests/integration/**/*.test.ts --passWithNoTests",
-    "test:coverage": "vitest run --config ./vitest.config.ts --coverage",
-    "lint": "echo \"SDK lint pending\" && exit 0"
-  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -52,6 +42,17 @@
     "access": "public"
   },
   "devDependencies": {
-    "@types/js-yaml": "^4.0.9"
+    "@types/js-yaml": "^4.0.9",
+    "typescript": "^5.0.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run --config ./vitest.config.ts",
+    "test:watch": "vitest --config ./vitest.config.ts",
+    "test:ui": "vitest --ui --config ./vitest.config.ts",
+    "test:unit": "vitest run --config ./vitest.config.ts tests/unit/**/*.test.ts",
+    "test:integration": "vitest run --config ./vitest.config.ts tests/integration/**/*.test.ts --passWithNoTests",
+    "test:coverage": "vitest run --config ./vitest.config.ts --coverage",
+    "lint": "echo \"SDK lint pending\" && exit 0"
   }
-}
+}