@rolexjs/core 0.1.0

package/README.md

@@ -0,0 +1,22 @@
+# @rolexjs/core
+
+RoleX Core - AI Agent Role Management Framework
+
+## Installation
+
+```bash
+bun add @rolexjs/core
+```
+
+## Usage
+
+```typescript
+import { createRole } from "@rolexjs/core";
+
+const role = createRole();
+console.log(role);
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,190 @@
+import { RXR, Registry } from "resourcexjs";
+/**
+* RoleX Core Types
+* @rolexjs/core
+*/
+/**
+* Rendered Role object
+*/
+interface RenderedRole {
+	/** Final rendered complete prompt */
+	readonly prompt: string;
+	/** Personality section */
+	readonly personality: string;
+	/** Principle section */
+	readonly principle: string;
+	/** Knowledge section */
+	readonly knowledge: string;
+}
+/**
+* Thought sub-tag types
+*/
+type ThoughtSubTag = "exploration" | "reasoning" | "challenge" | "plan";
+/**
+* Execution sub-tag types
+*/
+type ExecutionSubTag = "process" | "constraint" | "rule" | "guideline" | "criteria";
+/**
+* Parsed Thought content
+*/
+interface ParsedThought {
+	readonly exploration?: string;
+	readonly reasoning?: string;
+	readonly challenge?: string;
+	readonly plan?: string;
+}
+/**
+* Parsed Execution content
+*/
+interface ParsedExecution {
+	readonly process?: string;
+	readonly constraint?: string;
+	readonly rule?: string;
+	readonly guideline?: string;
+	readonly criteria?: string;
+}
+/**
+* Resource resolver function type
+*/
+type ResourceResolver = (src: string) => Promise<string>;
+/**
+* Load and render a Role from RXR
+*
+* @param rxr - Role resource (RXL + RXM + RXC)
+* @param registry - Registry instance (for resolving ARP rxr:// references)
+* @returns Rendered Role object
+*
+* @example
+* ```typescript
+* const registry = createRegistry();
+* const rxr = await registry.get('localhost/my.role@1.0.0');
+* const role = await loadRole(rxr, registry);
+* console.log(role.prompt);
+* ```
+*/
+declare function loadRole(rxr: RXR, registry: Registry): Promise<RenderedRole>;
+import { ResourceType } from "resourcexjs";
+/**
+* Role resource type for ResourceX integration
+*
+* @example
+* ```typescript
+* import { createRegistry } from 'resourcexjs';
+* import { roleType } from '@rolexjs/core';
+*
+* const registry = createRegistry();
+* registry.supportType(roleType);
+*
+* const resource = await registry.resolve('deepractice.dev/nuwa.role@1.0.0');
+* const role = await resource.execute();
+* console.log(role.prompt);
+* ```
+*/
+declare const roleType: ResourceType<void, RenderedRole>;
+/**
+* RoleX Error Classes
+* @rolexjs/core
+*/
+/**
+* Base error class for all RoleX errors
+*/
+declare class RoleXError extends Error {
+	constructor(message: string, options?: ErrorOptions);
+}
+/**
+* Error thrown when role loading fails
+*/
+declare class RoleLoadError extends RoleXError {
+	readonly locator?: string;
+	constructor(message: string, locator?: string);
+}
+/**
+* Error thrown when resource resolution fails
+*/
+declare class ResourceResolveError extends RoleXError {
+	readonly src?: string;
+	constructor(message: string, src?: string);
+}
+/**
+* Error thrown when DPML parsing fails
+*/
+declare class DPMLParseError extends RoleXError {
+	constructor(message: string);
+}
+import { Schema } from "dpml";
+/**
+* RoleX schema collection
+*/
+interface RoleSchemas {
+	readonly role: Schema;
+	readonly thought: Schema;
+	readonly execution: Schema;
+	readonly knowledge: Schema;
+}
+import { Schema as Schema2 } from "dpml";
+/**
+* Create all RoleX schemas
+*
+* Role structure:
+* <role>
+*   <personality>...</personality>
+*   <principle>...</principle>
+*   <knowledge>...</knowledge>
+* </role>
+*/
+declare function defineRoleSchemas(): RoleSchemas;
+declare const roleSchema: Schema2;
+declare const thoughtSchema: Schema2;
+declare const executionSchema: Schema2;
+declare const knowledgeSchema: Schema2;
+/**
+* Transformer input interface (compatible with dpml 0.3.0)
+*/
+interface TransformInput {
+	document: {
+		rootNode: unknown
+		nodesById?: Map<string, unknown>
+		metadata?: Record<string, unknown>
+	};
+	isValid?: boolean;
+	validation?: {
+		isValid: boolean
+		errors: unknown[]
+		warnings: unknown[]
+	};
+	resources?: unknown[];
+}
+/**
+* Role transformer type
+*/
+interface RoleTransformer {
+	name: string;
+	description?: string;
+	transform(input: TransformInput): RenderedRole;
+}
+import { Transformer } from "dpml";
+/**
+* Role Transformer
+* Transforms DPML role document into RenderedRole
+*/
+declare const roleTransformer: Transformer<{
+	document: {
+		rootNode: unknown
+	}
+}, RenderedRole>;
+import { Registry as Registry2 } from "resourcexjs";
+/**
+* Create a resource resolver function
+*
+* @param registry - Registry instance (required for RxrTransport)
+* @returns Resource resolver function that accepts ARP URLs
+*
+* @example
+* ```typescript
+* const resolver = createResourceResolver(registry);
+* const content = await resolver('arp:text:rxr://localhost/my.role@1.0.0/thought/first.thought.md');
+* ```
+*/
+declare function createResourceResolver(registry: Registry2): ResourceResolver;
+declare const VERSION: string;
+export { thoughtSchema, roleType, roleTransformer, roleSchema, loadRole, knowledgeSchema, executionSchema, defineRoleSchemas, createResourceResolver, VERSION, ThoughtSubTag, RoleXError, RoleTransformer, RoleSchemas, RoleLoadError, ResourceResolver, ResourceResolveError, RenderedRole, ParsedThought, ParsedExecution, ExecutionSubTag, DPMLParseError };