resourcexjs 0.0.1

package/README.md

@@ -0,0 +1,129 @@
+# resourcexjs
+
+Agent Resource Protocol (ARP) for AI Agents.
+
+## Installation
+
+```bash
+npm install resourcexjs
+# or
+bun add resourcexjs
+```
+
+## Quick Start
+
+```typescript
+import { createResourceX } from "resourcexjs";
+
+const rx = createResourceX();
+
+// Resolve a remote text resource
+const resource = await rx.resolve("arp:text:https://example.com/file.txt");
+
+console.log(resource.type); // "text"
+console.log(resource.content); // file content as string
+console.log(resource.meta); // { url, semantic, transport, ... }
+```
+
+## ARP URL Format
+
+```
+arp:{semantic}:{transport}://{location}
+```
+
+- **semantic**: What the resource is (e.g., `text`)
+- **transport**: How to fetch it (e.g., `https`, `http`, `file`)
+- **location**: Where to find it
+
+Examples:
+
+- `arp:text:https://example.com/readme.txt`
+- `arp:text:http://localhost:3000/data.txt`
+- `arp:text:file:///path/to/local/file.txt`
+
+## API
+
+### `createResourceX(config?)`
+
+Create a ResourceX instance.
+
+```typescript
+const rx = createResourceX({
+  timeout: 5000, // request timeout in ms
+  transports: [], // custom transport handlers
+  semantics: [], // custom semantic handlers
+});
+```
+
+### `rx.resolve(url)`
+
+Resolve an ARP URL and return the resource.
+
+```typescript
+const resource = await rx.resolve("arp:text:https://example.com/file.txt");
+// Returns: { type, content, meta }
+```
+
+### `rx.parse(url)`
+
+Parse an ARP URL without fetching.
+
+```typescript
+const parsed = rx.parse("arp:text:https://example.com/file.txt");
+// Returns: { semantic: "text", transport: "https", location: "example.com/file.txt" }
+```
+
+### `rx.registerTransport(handler)`
+
+Register a custom transport handler.
+
+### `rx.registerSemantic(handler)`
+
+Register a custom semantic handler.
+
+## Resource Object
+
+```typescript
+interface Resource {
+  type: string; // semantic type (e.g., "text")
+  content: unknown; // parsed content
+  meta: {
+    url: string; // original ARP URL
+    semantic: string; // semantic type
+    transport: string; // transport protocol
+    location: string; // resource location
+    size: number; // content size in bytes
+    encoding?: string; // content encoding
+    mimeType?: string; // MIME type
+    fetchedAt: string; // ISO timestamp
+  };
+}
+```
+
+## Error Handling
+
+All errors extend `ResourceXError`:
+
+```typescript
+import { createResourceX, ResourceXError } from "resourcexjs";
+
+const rx = createResourceX();
+
+try {
+  await rx.resolve("arp:text:https://example.com/file.txt");
+} catch (error) {
+  if (error instanceof ResourceXError) {
+    console.error("ResourceX error:", error.message);
+  }
+}
+```
+
+For fine-grained error handling, import specific error types from `@resourcexjs/core`:
+
+```typescript
+import { ParseError, TransportError, SemanticError } from "@resourcexjs/core";
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,74 @@
+import { ParsedARP, Resource, TransportHandler, SemanticHandler } from "@resourcexjs/core";
+/**
+* ResourceX configuration
+*/
+interface ResourceXConfig {
+	/**
+	* Request timeout in milliseconds
+	*/
+	timeout?: number;
+	/**
+	* Custom transport handlers to register
+	*/
+	transports?: TransportHandler[];
+	/**
+	* Custom semantic handlers to register
+	*/
+	semantics?: SemanticHandler[];
+}
+/**
+* ResourceX instance
+*/
+declare class ResourceX {
+	readonly timeout?: number;
+	constructor(config?: ResourceXConfig);
+	/**
+	* Parse an ARP URL without fetching
+	*/
+	parse(url: string): ParsedARP;
+	/**
+	* Resolve an ARP URL to a resource
+	*/
+	resolve(url: string): Promise<Resource>;
+	/**
+	* Register a custom transport handler
+	*/
+	registerTransport(handler: TransportHandler): void;
+	/**
+	* Register a custom semantic handler
+	*/
+	registerSemantic(handler: SemanticHandler): void;
+	/**
+	* Get a transport handler by type
+	*/
+	getTransport(type: string): TransportHandler;
+	/**
+	* Get a semantic handler by type
+	*/
+	getSemantic(type: string): SemanticHandler;
+}
+/**
+* Create a new ResourceX instance
+*
+* @example
+* ```typescript
+* import { createResourceX } from "resourcexjs";
+*
+* const rx = createResourceX();
+* const resource = await rx.resolve("arp:text:https://example.com/file.txt");
+* ```
+*
+* @example
+* ```typescript
+* // With custom config
+* const rx = createResourceX({
+*   timeout: 5000,
+*   transports: [myCustomTransport],
+*   semantics: [myCustomSemantic],
+* });
+* ```
+*/
+declare function createResourceX(config?: ResourceXConfig): ResourceX;
+import { Resource as Resource2, ResourceMeta, ParsedARP as ParsedARP2, ParseContext, TransportHandler as TransportHandler2, SemanticHandler as SemanticHandler2, TextResource } from "@resourcexjs/core";
+import { ResourceXError, ParseError, TransportError, SemanticError } from "@resourcexjs/core";
+export { createResourceX, TransportHandler2 as TransportHandler, TransportError, TextResource, SemanticHandler2 as SemanticHandler, SemanticError, ResourceXError, ResourceXConfig, ResourceX, ResourceMeta, Resource2 as Resource, ParsedARP2 as ParsedARP, ParseError, ParseContext };

package/dist/index.js

@@ -0,0 +1,223 @@
+// ../core/dist/index.js
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+
+class ResourceXError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ResourceXError";
+  }
+}
+
+class ParseError extends ResourceXError {
+  url;
+  constructor(message, url) {
+    super(message);
+    this.url = url;
+    this.name = "ParseError";
+  }
+}
+
+class TransportError extends ResourceXError {
+  transport;
+  constructor(message, transport, options) {
+    super(message, options);
+    this.transport = transport;
+    this.name = "TransportError";
+  }
+}
+
+class SemanticError extends ResourceXError {
+  semantic;
+  constructor(message, semantic, options) {
+    super(message, options);
+    this.semantic = semantic;
+    this.name = "SemanticError";
+  }
+}
+function parseARP(url) {
+  if (!url.startsWith("arp:")) {
+    throw new ParseError(`Invalid ARP URL: must start with "arp:"`, url);
+  }
+  const content = url.substring(4);
+  const separatorIndex = content.indexOf("://");
+  if (separatorIndex === -1) {
+    throw new ParseError(`Invalid ARP URL: missing "://"`, url);
+  }
+  const typePart = content.substring(0, separatorIndex);
+  const location = content.substring(separatorIndex + 3);
+  const colonIndex = typePart.indexOf(":");
+  if (colonIndex === -1) {
+    throw new ParseError(`Invalid ARP URL: must have exactly 2 types (semantic:transport)`, url);
+  }
+  const semantic = typePart.substring(0, colonIndex);
+  const transport = typePart.substring(colonIndex + 1);
+  if (!semantic) {
+    throw new ParseError(`Invalid ARP URL: semantic type cannot be empty`, url);
+  }
+  if (!transport) {
+    throw new ParseError(`Invalid ARP URL: transport type cannot be empty`, url);
+  }
+  if (!location) {
+    throw new ParseError(`Invalid ARP URL: location cannot be empty`, url);
+  }
+  return { semantic, transport, location };
+}
+
+class HttpTransportHandler {
+  type;
+  protocol;
+  constructor(protocol = "https") {
+    this.protocol = protocol;
+    this.type = protocol;
+  }
+  async fetch(location) {
+    const url = `${this.protocol}://${location}`;
+    try {
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new TransportError(`HTTP ${response.status}: ${response.statusText} - ${url}`, this.type);
+      }
+      const arrayBuffer = await response.arrayBuffer();
+      return Buffer.from(arrayBuffer);
+    } catch (error) {
+      if (error instanceof TransportError) {
+        throw error;
+      }
+      throw new TransportError(`Network error: ${url}`, this.type, { cause: error });
+    }
+  }
+}
+var httpsHandler = new HttpTransportHandler("https");
+var httpHandler = new HttpTransportHandler("http");
+
+class FileTransportHandler {
+  type = "file";
+  async fetch(location) {
+    const filePath = resolve(process.cwd(), location);
+    try {
+      return await readFile(filePath);
+    } catch (error) {
+      const err = error;
+      throw new TransportError(`File read error: ${err.code} - ${filePath}`, this.type, {
+        cause: err
+      });
+    }
+  }
+}
+var fileHandler = new FileTransportHandler;
+var handlers = new Map([
+  ["https", httpsHandler],
+  ["http", httpHandler],
+  ["file", fileHandler]
+]);
+function getTransportHandler(type) {
+  const handler = handlers.get(type);
+  if (!handler) {
+    throw new TransportError(`Unsupported transport type: ${type}`, type);
+  }
+  return handler;
+}
+function registerTransportHandler(handler) {
+  handlers.set(handler.type, handler);
+}
+
+class TextSemanticHandler {
+  type = "text";
+  parse(content, context) {
+    const text = content.toString("utf-8");
+    const meta = {
+      url: context.url,
+      semantic: context.semantic,
+      transport: context.transport,
+      location: context.location,
+      size: content.length,
+      encoding: "utf-8",
+      mimeType: "text/plain",
+      fetchedAt: context.fetchedAt.toISOString()
+    };
+    return {
+      type: "text",
+      content: text,
+      meta
+    };
+  }
+}
+var textHandler = new TextSemanticHandler;
+var handlers2 = new Map([["text", textHandler]]);
+function getSemanticHandler(type) {
+  const handler = handlers2.get(type);
+  if (!handler) {
+    throw new SemanticError(`Unsupported semantic type: ${type}`, type);
+  }
+  return handler;
+}
+function registerSemanticHandler(handler) {
+  handlers2.set(handler.type, handler);
+}
+async function resolve2(url) {
+  const fetchedAt = new Date;
+  const parsed = parseARP(url);
+  const transportHandler = getTransportHandler(parsed.transport);
+  const semanticHandler = getSemanticHandler(parsed.semantic);
+  const content = await transportHandler.fetch(parsed.location);
+  const context = {
+    url,
+    semantic: parsed.semantic,
+    transport: parsed.transport,
+    location: parsed.location,
+    fetchedAt
+  };
+  return semanticHandler.parse(content, context);
+}
+
+// src/ResourceX.ts
+class ResourceX {
+  timeout;
+  constructor(config = {}) {
+    this.timeout = config.timeout;
+    if (config.transports) {
+      for (const handler of config.transports) {
+        registerTransportHandler(handler);
+      }
+    }
+    if (config.semantics) {
+      for (const handler of config.semantics) {
+        registerSemanticHandler(handler);
+      }
+    }
+  }
+  parse(url) {
+    return parseARP(url);
+  }
+  async resolve(url) {
+    return resolve2(url);
+  }
+  registerTransport(handler) {
+    registerTransportHandler(handler);
+  }
+  registerSemantic(handler) {
+    registerSemanticHandler(handler);
+  }
+  getTransport(type) {
+    return getTransportHandler(type);
+  }
+  getSemantic(type) {
+    return getSemanticHandler(type);
+  }
+}
+
+// src/createResourceX.ts
+function createResourceX(config) {
+  return new ResourceX(config);
+}
+export {
+  createResourceX,
+  TransportError,
+  SemanticError,
+  ResourceXError,
+  ResourceX,
+  ParseError
+};
+
+//# debugId=ACA93DAB894BAF0C64756E2164756E21

package/dist/index.js.map

@@ -0,0 +1,12 @@
+{
+  "version": 3,
+  "sources": ["../../core/dist/index.js", "../src/ResourceX.ts", "../src/createResourceX.ts"],
+  "sourcesContent": [
+    "// src/errors.ts\nclass ResourceXError extends Error {\n  constructor(message, options) {\n    super(message, options);\n    this.name = \"ResourceXError\";\n  }\n}\n\nclass ParseError extends ResourceXError {\n  url;\n  constructor(message, url) {\n    super(message);\n    this.url = url;\n    this.name = \"ParseError\";\n  }\n}\n\nclass TransportError extends ResourceXError {\n  transport;\n  constructor(message, transport, options) {\n    super(message, options);\n    this.transport = transport;\n    this.name = \"TransportError\";\n  }\n}\n\nclass SemanticError extends ResourceXError {\n  semantic;\n  constructor(message, semantic, options) {\n    super(message, options);\n    this.semantic = semantic;\n    this.name = \"SemanticError\";\n  }\n}\n// src/parser.ts\nfunction parseARP(url) {\n  if (!url.startsWith(\"arp:\")) {\n    throw new ParseError(`Invalid ARP URL: must start with \"arp:\"`, url);\n  }\n  const content = url.substring(4);\n  const separatorIndex = content.indexOf(\"://\");\n  if (separatorIndex === -1) {\n    throw new ParseError(`Invalid ARP URL: missing \"://\"`, url);\n  }\n  const typePart = content.substring(0, separatorIndex);\n  const location = content.substring(separatorIndex + 3);\n  const colonIndex = typePart.indexOf(\":\");\n  if (colonIndex === -1) {\n    throw new ParseError(`Invalid ARP URL: must have exactly 2 types (semantic:transport)`, url);\n  }\n  const semantic = typePart.substring(0, colonIndex);\n  const transport = typePart.substring(colonIndex + 1);\n  if (!semantic) {\n    throw new ParseError(`Invalid ARP URL: semantic type cannot be empty`, url);\n  }\n  if (!transport) {\n    throw new ParseError(`Invalid ARP URL: transport type cannot be empty`, url);\n  }\n  if (!location) {\n    throw new ParseError(`Invalid ARP URL: location cannot be empty`, url);\n  }\n  return { semantic, transport, location };\n}\n// src/transport/http.ts\nclass HttpTransportHandler {\n  type;\n  protocol;\n  constructor(protocol = \"https\") {\n    this.protocol = protocol;\n    this.type = protocol;\n  }\n  async fetch(location) {\n    const url = `${this.protocol}://${location}`;\n    try {\n      const response = await fetch(url);\n      if (!response.ok) {\n        throw new TransportError(`HTTP ${response.status}: ${response.statusText} - ${url}`, this.type);\n      }\n      const arrayBuffer = await response.arrayBuffer();\n      return Buffer.from(arrayBuffer);\n    } catch (error) {\n      if (error instanceof TransportError) {\n        throw error;\n      }\n      throw new TransportError(`Network error: ${url}`, this.type, { cause: error });\n    }\n  }\n}\nvar httpsHandler = new HttpTransportHandler(\"https\");\nvar httpHandler = new HttpTransportHandler(\"http\");\n// src/transport/file.ts\nimport { readFile } from \"node:fs/promises\";\nimport { resolve } from \"node:path\";\nclass FileTransportHandler {\n  type = \"file\";\n  async fetch(location) {\n    const filePath = resolve(process.cwd(), location);\n    try {\n      return await readFile(filePath);\n    } catch (error) {\n      const err = error;\n      throw new TransportError(`File read error: ${err.code} - ${filePath}`, this.type, {\n        cause: err\n      });\n    }\n  }\n}\nvar fileHandler = new FileTransportHandler;\n// src/transport/index.ts\nvar handlers = new Map([\n  [\"https\", httpsHandler],\n  [\"http\", httpHandler],\n  [\"file\", fileHandler]\n]);\nfunction getTransportHandler(type) {\n  const handler = handlers.get(type);\n  if (!handler) {\n    throw new TransportError(`Unsupported transport type: ${type}`, type);\n  }\n  return handler;\n}\nfunction registerTransportHandler(handler) {\n  handlers.set(handler.type, handler);\n}\n// src/semantic/text.ts\nclass TextSemanticHandler {\n  type = \"text\";\n  parse(content, context) {\n    const text = content.toString(\"utf-8\");\n    const meta = {\n      url: context.url,\n      semantic: context.semantic,\n      transport: context.transport,\n      location: context.location,\n      size: content.length,\n      encoding: \"utf-8\",\n      mimeType: \"text/plain\",\n      fetchedAt: context.fetchedAt.toISOString()\n    };\n    return {\n      type: \"text\",\n      content: text,\n      meta\n    };\n  }\n}\nvar textHandler = new TextSemanticHandler;\n// src/semantic/index.ts\nvar handlers2 = new Map([[\"text\", textHandler]]);\nfunction getSemanticHandler(type) {\n  const handler = handlers2.get(type);\n  if (!handler) {\n    throw new SemanticError(`Unsupported semantic type: ${type}`, type);\n  }\n  return handler;\n}\nfunction registerSemanticHandler(handler) {\n  handlers2.set(handler.type, handler);\n}\n// src/resolve.ts\nasync function resolve2(url) {\n  const fetchedAt = new Date;\n  const parsed = parseARP(url);\n  const transportHandler = getTransportHandler(parsed.transport);\n  const semanticHandler = getSemanticHandler(parsed.semantic);\n  const content = await transportHandler.fetch(parsed.location);\n  const context = {\n    url,\n    semantic: parsed.semantic,\n    transport: parsed.transport,\n    location: parsed.location,\n    fetchedAt\n  };\n  return semanticHandler.parse(content, context);\n}\n\n// src/index.ts\nvar VERSION = \"0.0.1\";\nexport {\n  textHandler,\n  resolve2 as resolve,\n  registerTransportHandler,\n  registerSemanticHandler,\n  parseARP,\n  httpsHandler,\n  httpHandler,\n  getTransportHandler,\n  getSemanticHandler,\n  fileHandler,\n  VERSION,\n  TransportError,\n  SemanticError,\n  ResourceXError,\n  ParseError\n};\n\n//# debugId=7FDB8A773330183C64756E2164756E21\n",
+    "/**\n * ResourceX - Main API class\n */\n\nimport {\n  parseARP,\n  resolve as coreResolve,\n  getTransportHandler,\n  getSemanticHandler,\n  registerTransportHandler,\n  registerSemanticHandler,\n  type ParsedARP,\n  type Resource,\n  type TransportHandler,\n  type SemanticHandler,\n} from \"@resourcexjs/core\";\n\n/**\n * ResourceX configuration\n */\nexport interface ResourceXConfig {\n  /**\n   * Request timeout in milliseconds\n   */\n  timeout?: number;\n\n  /**\n   * Custom transport handlers to register\n   */\n  transports?: TransportHandler[];\n\n  /**\n   * Custom semantic handlers to register\n   */\n  semantics?: SemanticHandler[];\n}\n\n/**\n * ResourceX instance\n */\nexport class ResourceX {\n  readonly timeout?: number;\n\n  constructor(config: ResourceXConfig = {}) {\n    this.timeout = config.timeout;\n\n    // Register custom handlers from config\n    if (config.transports) {\n      for (const handler of config.transports) {\n        registerTransportHandler(handler);\n      }\n    }\n\n    if (config.semantics) {\n      for (const handler of config.semantics) {\n        registerSemanticHandler(handler);\n      }\n    }\n  }\n\n  /**\n   * Parse an ARP URL without fetching\n   */\n  parse(url: string): ParsedARP {\n    return parseARP(url);\n  }\n\n  /**\n   * Resolve an ARP URL to a resource\n   */\n  async resolve(url: string): Promise<Resource> {\n    // TODO: implement timeout using this.timeout\n    return coreResolve(url);\n  }\n\n  /**\n   * Register a custom transport handler\n   */\n  registerTransport(handler: TransportHandler): void {\n    registerTransportHandler(handler);\n  }\n\n  /**\n   * Register a custom semantic handler\n   */\n  registerSemantic(handler: SemanticHandler): void {\n    registerSemanticHandler(handler);\n  }\n\n  /**\n   * Get a transport handler by type\n   */\n  getTransport(type: string): TransportHandler {\n    return getTransportHandler(type);\n  }\n\n  /**\n   * Get a semantic handler by type\n   */\n  getSemantic(type: string): SemanticHandler {\n    return getSemanticHandler(type);\n  }\n}\n",
+    "/**\n * Factory function for creating ResourceX instances\n */\n\nimport { ResourceX, type ResourceXConfig } from \"./ResourceX.js\";\n\n/**\n * Create a new ResourceX instance\n *\n * @example\n * ```typescript\n * import { createResourceX } from \"resourcexjs\";\n *\n * const rx = createResourceX();\n * const resource = await rx.resolve(\"arp:text:https://example.com/file.txt\");\n * ```\n *\n * @example\n * ```typescript\n * // With custom config\n * const rx = createResourceX({\n *   timeout: 5000,\n *   transports: [myCustomTransport],\n *   semantics: [myCustomSemantic],\n * });\n * ```\n */\nexport function createResourceX(config?: ResourceXConfig): ResourceX {\n  return new ResourceX(config);\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "ACA93DAB894BAF0C64756E2164756E21",
+  "names": []
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "resourcexjs",
+  "version": "0.0.1",
+  "description": "ResourceX - Agent Resource Protocol for AI Agents",
+  "keywords": [
+    "resourcex",
+    "arp",
+    "agent",
+    "resource",
+    "protocol",
+    "ai"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Deepractice/ResourceX.git"
+  },
+  "homepage": "https://github.com/Deepractice/ResourceX",
+  "license": "MIT",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "bun run build.ts",
+    "lint": "eslint .",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@resourcexjs/core": "workspace:*"
+  },
+  "devDependencies": {},
+  "publishConfig": {
+    "access": "public"
+  }
+}