@resourcexjs/arp 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,370 @@
+/**
+* Transport Handler Interface
+* Responsible for I/O primitives - read, write, list, exists, delete
+* Transport only handles WHERE and HOW to access bytes, not WHAT they mean
+*/
+/**
+* Transport capabilities declaration
+*/
+interface TransportCapabilities {
+	readonly canRead: boolean;
+	readonly canWrite: boolean;
+	readonly canList: boolean;
+	readonly canDelete: boolean;
+	readonly canStat: boolean;
+}
+/**
+* Resource stat information
+*/
+interface ResourceStat {
+	size: number;
+	modifiedAt?: Date;
+	isDirectory?: boolean;
+}
+/**
+* Transport Handler - provides I/O primitives
+*/
+interface TransportHandler {
+	/**
+	* Transport name (e.g., "https", "file", "s3")
+	*/
+	readonly name: string;
+	/**
+	* Transport capabilities
+	*/
+	readonly capabilities: TransportCapabilities;
+	/**
+	* Read content from location
+	* @param location - The location string after ://
+	* @returns Raw content as Buffer
+	*/
+	read(location: string): Promise<Buffer>;
+	/**
+	* Write content to location
+	* @param location - The location string after ://
+	* @param content - Content to write
+	*/
+	write?(location: string, content: Buffer): Promise<void>;
+	/**
+	* List entries at location (for directory-like transports)
+	* @param location - The location string after ://
+	* @returns Array of entry names
+	*/
+	list?(location: string): Promise<string[]>;
+	/**
+	* Create directory at location
+	* @param location - The location string after ://
+	*/
+	mkdir?(location: string): Promise<void>;
+	/**
+	* Check if resource exists at location
+	* @param location - The location string after ://
+	*/
+	exists?(location: string): Promise<boolean>;
+	/**
+	* Get resource stat information
+	* @param location - The location string after ://
+	*/
+	stat?(location: string): Promise<ResourceStat>;
+	/**
+	* Delete resource at location
+	* @param location - The location string after ://
+	*/
+	delete?(location: string): Promise<void>;
+}
+/**
+* Resource metadata
+*/
+interface ResourceMeta {
+	url: string;
+	semantic: string;
+	transport: string;
+	location: string;
+	size: number;
+	encoding?: string;
+	mimeType?: string;
+	resolvedAt: string;
+}
+/**
+* Context passed to semantic handler
+*/
+interface SemanticContext {
+	url: string;
+	semantic: string;
+	transport: string;
+	location: string;
+	timestamp: Date;
+}
+/**
+* Base resource interface
+*/
+interface Resource<T = unknown> {
+	type: string;
+	content: T;
+	meta: ResourceMeta;
+}
+/**
+* Semantic handler interface
+* Semantic orchestrates Transport primitives to resolve/deposit resources
+*/
+interface SemanticHandler<T = unknown> {
+	/**
+	* Semantic name (e.g., "text", "json", "package")
+	*/
+	readonly name: string;
+	/**
+	* Resolve resource from location
+	* Semantic controls how to use transport primitives to fetch and parse resource
+	*
+	* @param transport - Transport handler for I/O operations
+	* @param location - Resource location
+	* @param context - Semantic context
+	*/
+	resolve(transport: TransportHandler, location: string, context: SemanticContext): Promise<Resource<T>>;
+	/**
+	* Deposit resource to location
+	* Semantic controls how to serialize data and use transport primitives to store
+	*
+	* @param transport - Transport handler for I/O operations
+	* @param location - Resource location
+	* @param data - Data to deposit
+	* @param context - Semantic context
+	*/
+	deposit?(transport: TransportHandler, location: string, data: T, context: SemanticContext): Promise<void>;
+	/**
+	* Check if resource exists at location
+	*
+	* @param transport - Transport handler for I/O operations
+	* @param location - Resource location
+	* @param context - Semantic context
+	*/
+	exists?(transport: TransportHandler, location: string, context: SemanticContext): Promise<boolean>;
+	/**
+	* Delete resource at location
+	*
+	* @param transport - Transport handler for I/O operations
+	* @param location - Resource location
+	* @param context - Semantic context
+	*/
+	delete?(transport: TransportHandler, location: string, context: SemanticContext): Promise<void>;
+}
+/**
+* ARI - Agent Resource Identifier
+* Identifies the type of resource without specifying location
+*/
+interface ARI {
+	readonly semantic: string;
+	readonly transport: string;
+}
+/**
+* ARL - Agent Resource Locator
+* Full resource locator with operations
+*/
+interface ARL extends ARI {
+	readonly location: string;
+	/**
+	* Resolve the resource
+	*/
+	resolve(): Promise<Resource>;
+	/**
+	* Deposit data to the resource
+	*/
+	deposit(data: unknown): Promise<void>;
+	/**
+	* Check if resource exists
+	*/
+	exists(): Promise<boolean>;
+	/**
+	* Delete the resource
+	*/
+	delete(): Promise<void>;
+	/**
+	* Convert to ARP URL string
+	*/
+	toString(): string;
+}
+/**
+* Handler resolver interface (implemented by ARP instance)
+*/
+interface HandlerResolver {
+	getTransportHandler(name: string): TransportHandler;
+	getSemanticHandler(name: string): SemanticHandler;
+}
+/**
+* ARL Implementation
+*/
+declare class ARL2 implements ARL {
+	readonly semantic: string;
+	readonly transport: string;
+	readonly location: string;
+	private readonly resolver;
+	constructor(semantic: string, transport: string, location: string, resolver: HandlerResolver);
+	/**
+	* Create semantic context
+	*/
+	private createContext;
+	/**
+	* Resolve the resource
+	*/
+	resolve(): Promise<Resource>;
+	/**
+	* Deposit data to the resource
+	*/
+	deposit(data: unknown): Promise<void>;
+	/**
+	* Check if resource exists
+	*/
+	exists(): Promise<boolean>;
+	/**
+	* Delete the resource
+	*/
+	delete(): Promise<void>;
+	/**
+	* Convert to ARP URL string
+	*/
+	toString(): string;
+}
+/**
+* ARP Configuration
+*/
+interface ARPConfig {
+	/**
+	* Custom transport handlers
+	*/
+	transports?: TransportHandler[];
+	/**
+	* Custom semantic handlers
+	*/
+	semantics?: SemanticHandler[];
+}
+/**
+* ARP Instance
+*/
+declare class ARP implements HandlerResolver {
+	private readonly transports;
+	private readonly semantics;
+	constructor(config?: ARPConfig);
+	/**
+	* Register a transport handler
+	*/
+	registerTransport(handler: TransportHandler): void;
+	/**
+	* Register a semantic handler
+	*/
+	registerSemantic(handler: SemanticHandler): void;
+	/**
+	* Get transport handler by name
+	*/
+	getTransportHandler(name: string): TransportHandler;
+	/**
+	* Get semantic handler by name
+	*/
+	getSemanticHandler(name: string): SemanticHandler;
+	/**
+	* Parse an ARP URL into an ARL object
+	*
+	* @example
+	* const arl = arp.parse("arp:text:file:///path/to/file.txt");
+	* arl.semantic   // "text"
+	* arl.transport  // "file"
+	* arl.location   // "/path/to/file.txt"
+	*/
+	parse(url: string): ARL2;
+}
+/**
+* Create a new ARP instance
+*
+* @example
+* import { createARP, fileTransport, textSemantic } from "arpjs";
+*
+* const arp = createARP({
+*   transports: [fileTransport],
+*   semantics: [textSemantic],
+* });
+*
+* const arl = arp.parse("arp:text:file:///path/to/file.txt");
+* const resource = await arl.resolve();
+*/
+declare function createARP(config?: ARPConfig): ARP;
+/**
+* ARP Error Types
+*/
+/**
+* Base error class for all ARP errors
+*/
+declare class ARPError extends Error {
+	constructor(message: string, options?: ErrorOptions);
+}
+/**
+* Error thrown when ARP URL parsing fails
+*/
+declare class ParseError extends ARPError {
+	readonly url?: string;
+	constructor(message: string, url?: string);
+}
+/**
+* Error thrown when transport layer fails
+*/
+declare class TransportError extends ARPError {
+	readonly transport?: string;
+	constructor(message: string, transport?: string, options?: ErrorOptions);
+}
+/**
+* Error thrown when semantic layer fails
+*/
+declare class SemanticError extends ARPError {
+	readonly semantic?: string;
+	constructor(message: string, semantic?: string, options?: ErrorOptions);
+}
+declare class FileTransportHandler implements TransportHandler {
+	readonly name = "file";
+	readonly capabilities: TransportCapabilities;
+	private resolvePath;
+	read(location: string): Promise<Buffer>;
+	write(location: string, content: Buffer): Promise<void>;
+	list(location: string): Promise<string[]>;
+	mkdir(location: string): Promise<void>;
+	exists(location: string): Promise<boolean>;
+	stat(location: string): Promise<ResourceStat>;
+	delete(location: string): Promise<void>;
+}
+declare const fileTransport: FileTransportHandler;
+declare class HttpTransportHandler implements TransportHandler {
+	readonly name: string;
+	private readonly protocol;
+	readonly capabilities: TransportCapabilities;
+	constructor(protocol?: "http" | "https");
+	read(location: string): Promise<Buffer>;
+}
+declare const httpsTransport: HttpTransportHandler;
+declare const httpTransport: HttpTransportHandler;
+interface TextResource extends Resource<string> {
+	type: "text";
+	content: string;
+}
+declare class TextSemanticHandler implements SemanticHandler<string> {
+	readonly name = "text";
+	resolve(transport: TransportHandler, location: string, context: SemanticContext): Promise<TextResource>;
+	deposit(transport: TransportHandler, location: string, data: string, _context: SemanticContext): Promise<void>;
+	exists(transport: TransportHandler, location: string, _context: SemanticContext): Promise<boolean>;
+	delete(transport: TransportHandler, location: string, _context: SemanticContext): Promise<void>;
+}
+declare const textSemantic: TextSemanticHandler;
+interface BinaryResource extends Resource<Buffer> {
+	type: "binary";
+	content: Buffer;
+}
+/**
+* Supported binary input types for deposit
+*/
+type BinaryInput = Buffer | Uint8Array | ArrayBuffer | number[];
+declare class BinarySemanticHandler implements SemanticHandler<Buffer> {
+	readonly name = "binary";
+	resolve(transport: TransportHandler, location: string, context: SemanticContext): Promise<BinaryResource>;
+	deposit(transport: TransportHandler, location: string, data: BinaryInput, _context: SemanticContext): Promise<void>;
+	exists(transport: TransportHandler, location: string, _context: SemanticContext): Promise<boolean>;
+	delete(transport: TransportHandler, location: string, _context: SemanticContext): Promise<void>;
+}
+declare const binarySemantic: BinarySemanticHandler;
+declare const VERSION: string;
+export { textSemantic, httpsTransport, httpTransport, fileTransport, createARP, binarySemantic, VERSION, TransportHandler, TransportError, TransportCapabilities, TextSemanticHandler, TextResource, SemanticHandler, SemanticError, SemanticContext, ResourceStat, ResourceMeta, Resource, ParseError, HttpTransportHandler, FileTransportHandler, BinarySemanticHandler, BinaryResource, BinaryInput, ARPError, ARPConfig, ARP, ARL, ARI };

package/dist/index.js

@@ -0,0 +1,451 @@
+// src/errors.ts
+class ARPError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ARPError";
+  }
+}
+
+class ParseError extends ARPError {
+  url;
+  constructor(message, url) {
+    super(message);
+    this.url = url;
+    this.name = "ParseError";
+  }
+}
+
+class TransportError extends ARPError {
+  transport;
+  constructor(message, transport, options) {
+    super(message, options);
+    this.transport = transport;
+    this.name = "TransportError";
+  }
+}
+
+class SemanticError extends ARPError {
+  semantic;
+  constructor(message, semantic, options) {
+    super(message, options);
+    this.semantic = semantic;
+    this.name = "SemanticError";
+  }
+}
+
+// src/ARL.ts
+class ARL {
+  semantic;
+  transport;
+  location;
+  resolver;
+  constructor(semantic, transport, location, resolver) {
+    this.semantic = semantic;
+    this.transport = transport;
+    this.location = location;
+    this.resolver = resolver;
+  }
+  createContext() {
+    return {
+      url: this.toString(),
+      semantic: this.semantic,
+      transport: this.transport,
+      location: this.location,
+      timestamp: new Date
+    };
+  }
+  async resolve() {
+    const transport = this.resolver.getTransportHandler(this.transport);
+    const semantic = this.resolver.getSemanticHandler(this.semantic);
+    const context = this.createContext();
+    return semantic.resolve(transport, this.location, context);
+  }
+  async deposit(data) {
+    const transport = this.resolver.getTransportHandler(this.transport);
+    const semantic = this.resolver.getSemanticHandler(this.semantic);
+    const context = this.createContext();
+    if (!semantic.deposit) {
+      throw new SemanticError(`Semantic "${semantic.name}" does not support deposit operation`, this.semantic);
+    }
+    await semantic.deposit(transport, this.location, data, context);
+  }
+  async exists() {
+    const transport = this.resolver.getTransportHandler(this.transport);
+    const semantic = this.resolver.getSemanticHandler(this.semantic);
+    const context = this.createContext();
+    if (semantic.exists) {
+      return semantic.exists(transport, this.location, context);
+    }
+    if (transport.exists) {
+      return transport.exists(this.location);
+    }
+    try {
+      await transport.read(this.location);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async delete() {
+    const transport = this.resolver.getTransportHandler(this.transport);
+    const semantic = this.resolver.getSemanticHandler(this.semantic);
+    const context = this.createContext();
+    if (semantic.delete) {
+      return semantic.delete(transport, this.location, context);
+    }
+    if (!transport.delete) {
+      throw new SemanticError(`Neither semantic "${semantic.name}" nor transport "${transport.name}" supports delete operation`, this.semantic);
+    }
+    await transport.delete(this.location);
+  }
+  toString() {
+    return `arp:${this.semantic}:${this.transport}://${this.location}`;
+  }
+}
+
+// src/transport/file.ts
+import { readFile, writeFile, readdir, mkdir, rm, access, stat as fsStat } from "node:fs/promises";
+import { resolve, dirname } from "node:path";
+class FileTransportHandler {
+  name = "file";
+  capabilities = {
+    canRead: true,
+    canWrite: true,
+    canList: true,
+    canDelete: true,
+    canStat: true
+  };
+  resolvePath(location) {
+    return resolve(process.cwd(), location);
+  }
+  async read(location) {
+    const filePath = this.resolvePath(location);
+    try {
+      return await readFile(filePath);
+    } catch (error) {
+      const err = error;
+      throw new TransportError(`File read error: ${err.code} - ${filePath}`, this.name, {
+        cause: err
+      });
+    }
+  }
+  async write(location, content) {
+    const filePath = this.resolvePath(location);
+    try {
+      await mkdir(dirname(filePath), { recursive: true });
+      await writeFile(filePath, content);
+    } catch (error) {
+      const err = error;
+      throw new TransportError(`File write error: ${err.code} - ${filePath}`, this.name, {
+        cause: err
+      });
+    }
+  }
+  async list(location) {
+    const dirPath = this.resolvePath(location);
+    try {
+      return await readdir(dirPath);
+    } catch (error) {
+      const err = error;
+      throw new TransportError(`Directory list error: ${err.code} - ${dirPath}`, this.name, {
+        cause: err
+      });
+    }
+  }
+  async mkdir(location) {
+    const dirPath = this.resolvePath(location);
+    try {
+      await mkdir(dirPath, { recursive: true });
+    } catch (error) {
+      const err = error;
+      throw new TransportError(`Directory create error: ${err.code} - ${dirPath}`, this.name, {
+        cause: err
+      });
+    }
+  }
+  async exists(location) {
+    const filePath = this.resolvePath(location);
+    try {
+      await access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async stat(location) {
+    const filePath = this.resolvePath(location);
+    try {
+      const stats = await fsStat(filePath);
+      return {
+        size: stats.size,
+        modifiedAt: stats.mtime,
+        isDirectory: stats.isDirectory()
+      };
+    } catch (error) {
+      const err = error;
+      throw new TransportError(`File stat error: ${err.code} - ${filePath}`, this.name, {
+        cause: err
+      });
+    }
+  }
+  async delete(location) {
+    const filePath = this.resolvePath(location);
+    try {
+      await rm(filePath, { recursive: true });
+    } catch (error) {
+      const err = error;
+      throw new TransportError(`File delete error: ${err.code} - ${filePath}`, this.name, {
+        cause: err
+      });
+    }
+  }
+}
+var fileTransport = new FileTransportHandler;
+// src/transport/http.ts
+class HttpTransportHandler {
+  name;
+  protocol;
+  capabilities = {
+    canRead: true,
+    canWrite: false,
+    canList: false,
+    canDelete: false,
+    canStat: false
+  };
+  constructor(protocol = "https") {
+    this.protocol = protocol;
+    this.name = protocol;
+  }
+  async read(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.name);
+      }
+      const arrayBuffer = await response.arrayBuffer();
+      return Buffer.from(arrayBuffer);
+    } catch (error) {
+      if (error instanceof TransportError) {
+        throw error;
+      }
+      throw new TransportError(`Network error: ${url}`, this.name, {
+        cause: error
+      });
+    }
+  }
+}
+var httpsTransport = new HttpTransportHandler("https");
+var httpTransport = new HttpTransportHandler("http");
+// src/semantic/text.ts
+class TextSemanticHandler {
+  name = "text";
+  async resolve(transport, location, context) {
+    const buffer = await transport.read(location);
+    const text = buffer.toString("utf-8");
+    const meta = {
+      url: context.url,
+      semantic: context.semantic,
+      transport: context.transport,
+      location: context.location,
+      size: buffer.length,
+      encoding: "utf-8",
+      mimeType: "text/plain",
+      resolvedAt: context.timestamp.toISOString()
+    };
+    return {
+      type: "text",
+      content: text,
+      meta
+    };
+  }
+  async deposit(transport, location, data, _context) {
+    if (!transport.write) {
+      throw new SemanticError(`Transport "${transport.name}" does not support write operation`, this.name);
+    }
+    const buffer = Buffer.from(data, "utf-8");
+    await transport.write(location, buffer);
+  }
+  async exists(transport, location, _context) {
+    if (transport.exists) {
+      return transport.exists(location);
+    }
+    try {
+      await transport.read(location);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async delete(transport, location, _context) {
+    if (!transport.delete) {
+      throw new SemanticError(`Transport "${transport.name}" does not support delete operation`, this.name);
+    }
+    await transport.delete(location);
+  }
+}
+var textSemantic = new TextSemanticHandler;
+// src/semantic/binary.ts
+function toBuffer(data) {
+  if (Buffer.isBuffer(data)) {
+    return data;
+  }
+  if (data instanceof Uint8Array) {
+    return Buffer.from(data);
+  }
+  if (data instanceof ArrayBuffer) {
+    return Buffer.from(data);
+  }
+  if (Array.isArray(data)) {
+    return Buffer.from(data);
+  }
+  throw new SemanticError(`Unsupported binary input type`, "binary");
+}
+
+class BinarySemanticHandler {
+  name = "binary";
+  async resolve(transport, location, context) {
+    const buffer = await transport.read(location);
+    const meta = {
+      url: context.url,
+      semantic: context.semantic,
+      transport: context.transport,
+      location: context.location,
+      size: buffer.length,
+      resolvedAt: context.timestamp.toISOString()
+    };
+    return {
+      type: "binary",
+      content: buffer,
+      meta
+    };
+  }
+  async deposit(transport, location, data, _context) {
+    if (!transport.write) {
+      throw new SemanticError(`Transport "${transport.name}" does not support write operation`, this.name);
+    }
+    const buffer = toBuffer(data);
+    await transport.write(location, buffer);
+  }
+  async exists(transport, location, _context) {
+    if (transport.exists) {
+      return transport.exists(location);
+    }
+    try {
+      await transport.read(location);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async delete(transport, location, _context) {
+    if (!transport.delete) {
+      throw new SemanticError(`Transport "${transport.name}" does not support delete operation`, this.name);
+    }
+    await transport.delete(location);
+  }
+}
+var binarySemantic = new BinarySemanticHandler;
+// src/ARP.ts
+class ARP {
+  transports;
+  semantics;
+  constructor(config = {}) {
+    this.transports = new Map;
+    this.semantics = new Map;
+    const defaultTransports = [fileTransport, httpTransport, httpsTransport];
+    const defaultSemantics = [textSemantic, binarySemantic];
+    for (const handler of defaultTransports) {
+      this.transports.set(handler.name, handler);
+    }
+    for (const handler of defaultSemantics) {
+      this.semantics.set(handler.name, handler);
+    }
+    if (config.transports) {
+      for (const handler of config.transports) {
+        this.transports.set(handler.name, handler);
+      }
+    }
+    if (config.semantics) {
+      for (const handler of config.semantics) {
+        this.semantics.set(handler.name, handler);
+      }
+    }
+  }
+  registerTransport(handler) {
+    this.transports.set(handler.name, handler);
+  }
+  registerSemantic(handler) {
+    this.semantics.set(handler.name, handler);
+  }
+  getTransportHandler(name) {
+    const handler = this.transports.get(name);
+    if (!handler) {
+      throw new TransportError(`Unsupported transport type: ${name}`, name);
+    }
+    return handler;
+  }
+  getSemanticHandler(name) {
+    const handler = this.semantics.get(name);
+    if (!handler) {
+      throw new SemanticError(`Unsupported semantic type: ${name}`, name);
+    }
+    return handler;
+  }
+  parse(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);
+    }
+    this.getTransportHandler(transport);
+    this.getSemanticHandler(semantic);
+    return new ARL(semantic, transport, location, this);
+  }
+}
+function createARP(config) {
+  return new ARP(config);
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+export {
+  textSemantic,
+  httpsTransport,
+  httpTransport,
+  fileTransport,
+  createARP,
+  binarySemantic,
+  VERSION,
+  TransportError,
+  TextSemanticHandler,
+  SemanticError,
+  ParseError,
+  HttpTransportHandler,
+  FileTransportHandler,
+  BinarySemanticHandler,
+  ARPError,
+  ARP
+};
+
+//# debugId=C42DE403B8D4732364756E2164756E21

package/dist/index.js.map

@@ -0,0 +1,17 @@
+{
+  "version": 3,
+  "sources": ["../src/errors.ts", "../src/ARL.ts", "../src/transport/file.ts", "../src/transport/http.ts", "../src/semantic/text.ts", "../src/semantic/binary.ts", "../src/ARP.ts", "../src/index.ts"],
+  "sourcesContent": [
+    "/**\n * ARP Error Types\n */\n\n/**\n * Base error class for all ARP errors\n */\nexport class ARPError extends Error {\n  constructor(message: string, options?: ErrorOptions) {\n    super(message, options);\n    this.name = \"ARPError\";\n  }\n}\n\n/**\n * Error thrown when ARP URL parsing fails\n */\nexport class ParseError extends ARPError {\n  constructor(\n    message: string,\n    public readonly url?: string\n  ) {\n    super(message);\n    this.name = \"ParseError\";\n  }\n}\n\n/**\n * Error thrown when transport layer fails\n */\nexport class TransportError extends ARPError {\n  constructor(\n    message: string,\n    public readonly transport?: string,\n    options?: ErrorOptions\n  ) {\n    super(message, options);\n    this.name = \"TransportError\";\n  }\n}\n\n/**\n * Error thrown when semantic layer fails\n */\nexport class SemanticError extends ARPError {\n  constructor(\n    message: string,\n    public readonly semantic?: string,\n    options?: ErrorOptions\n  ) {\n    super(message, options);\n    this.name = \"SemanticError\";\n  }\n}\n",
+    "/**\n * ARL - Agent Resource Locator Implementation\n */\n\nimport type { ARL as IARL } from \"./types.js\";\nimport type { Resource, SemanticContext, SemanticHandler } from \"./semantic/types.js\";\nimport type { TransportHandler } from \"./transport/types.js\";\nimport { SemanticError } from \"./errors.js\";\n\n/**\n * Handler resolver interface (implemented by ARP instance)\n */\nexport interface HandlerResolver {\n  getTransportHandler(name: string): TransportHandler;\n  getSemanticHandler(name: string): SemanticHandler;\n}\n\n/**\n * ARL Implementation\n */\nexport class ARL implements IARL {\n  readonly semantic: string;\n  readonly transport: string;\n  readonly location: string;\n\n  private readonly resolver: HandlerResolver;\n\n  constructor(semantic: string, transport: string, location: string, resolver: HandlerResolver) {\n    this.semantic = semantic;\n    this.transport = transport;\n    this.location = location;\n    this.resolver = resolver;\n  }\n\n  /**\n   * Create semantic context\n   */\n  private createContext(): SemanticContext {\n    return {\n      url: this.toString(),\n      semantic: this.semantic,\n      transport: this.transport,\n      location: this.location,\n      timestamp: new Date(),\n    };\n  }\n\n  /**\n   * Resolve the resource\n   */\n  async resolve(): Promise<Resource> {\n    const transport = this.resolver.getTransportHandler(this.transport);\n    const semantic = this.resolver.getSemanticHandler(this.semantic);\n    const context = this.createContext();\n\n    return semantic.resolve(transport, this.location, context);\n  }\n\n  /**\n   * Deposit data to the resource\n   */\n  async deposit(data: unknown): Promise<void> {\n    const transport = this.resolver.getTransportHandler(this.transport);\n    const semantic = this.resolver.getSemanticHandler(this.semantic);\n    const context = this.createContext();\n\n    if (!semantic.deposit) {\n      throw new SemanticError(\n        `Semantic \"${semantic.name}\" does not support deposit operation`,\n        this.semantic\n      );\n    }\n\n    await semantic.deposit(transport, this.location, data, context);\n  }\n\n  /**\n   * Check if resource exists\n   */\n  async exists(): Promise<boolean> {\n    const transport = this.resolver.getTransportHandler(this.transport);\n    const semantic = this.resolver.getSemanticHandler(this.semantic);\n    const context = this.createContext();\n\n    if (semantic.exists) {\n      return semantic.exists(transport, this.location, context);\n    }\n\n    // Fallback to transport exists\n    if (transport.exists) {\n      return transport.exists(this.location);\n    }\n\n    // Fallback: try to read\n    try {\n      await transport.read(this.location);\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Delete the resource\n   */\n  async delete(): Promise<void> {\n    const transport = this.resolver.getTransportHandler(this.transport);\n    const semantic = this.resolver.getSemanticHandler(this.semantic);\n    const context = this.createContext();\n\n    if (semantic.delete) {\n      return semantic.delete(transport, this.location, context);\n    }\n\n    // Fallback to transport delete\n    if (!transport.delete) {\n      throw new SemanticError(\n        `Neither semantic \"${semantic.name}\" nor transport \"${transport.name}\" supports delete operation`,\n        this.semantic\n      );\n    }\n\n    await transport.delete(this.location);\n  }\n\n  /**\n   * Convert to ARP URL string\n   */\n  toString(): string {\n    return `arp:${this.semantic}:${this.transport}://${this.location}`;\n  }\n}\n",
+    "/**\n * File Transport Handler\n * Provides I/O primitives for local filesystem\n */\n\nimport { readFile, writeFile, readdir, mkdir, rm, access, stat as fsStat } from \"node:fs/promises\";\nimport { resolve, dirname } from \"node:path\";\nimport { TransportError } from \"../errors.js\";\nimport type { TransportHandler, TransportCapabilities, ResourceStat } from \"./types.js\";\n\nexport class FileTransportHandler implements TransportHandler {\n  readonly name = \"file\";\n\n  readonly capabilities: TransportCapabilities = {\n    canRead: true,\n    canWrite: true,\n    canList: true,\n    canDelete: true,\n    canStat: true,\n  };\n\n  private resolvePath(location: string): string {\n    return resolve(process.cwd(), location);\n  }\n\n  async read(location: string): Promise<Buffer> {\n    const filePath = this.resolvePath(location);\n\n    try {\n      return await readFile(filePath);\n    } catch (error) {\n      const err = error as Error & { code?: string };\n      throw new TransportError(`File read error: ${err.code} - ${filePath}`, this.name, {\n        cause: err,\n      });\n    }\n  }\n\n  async write(location: string, content: Buffer): Promise<void> {\n    const filePath = this.resolvePath(location);\n\n    try {\n      // Ensure directory exists\n      await mkdir(dirname(filePath), { recursive: true });\n      await writeFile(filePath, content);\n    } catch (error) {\n      const err = error as Error & { code?: string };\n      throw new TransportError(`File write error: ${err.code} - ${filePath}`, this.name, {\n        cause: err,\n      });\n    }\n  }\n\n  async list(location: string): Promise<string[]> {\n    const dirPath = this.resolvePath(location);\n\n    try {\n      return await readdir(dirPath);\n    } catch (error) {\n      const err = error as Error & { code?: string };\n      throw new TransportError(`Directory list error: ${err.code} - ${dirPath}`, this.name, {\n        cause: err,\n      });\n    }\n  }\n\n  async mkdir(location: string): Promise<void> {\n    const dirPath = this.resolvePath(location);\n\n    try {\n      await mkdir(dirPath, { recursive: true });\n    } catch (error) {\n      const err = error as Error & { code?: string };\n      throw new TransportError(`Directory create error: ${err.code} - ${dirPath}`, this.name, {\n        cause: err,\n      });\n    }\n  }\n\n  async exists(location: string): Promise<boolean> {\n    const filePath = this.resolvePath(location);\n\n    try {\n      await access(filePath);\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  async stat(location: string): Promise<ResourceStat> {\n    const filePath = this.resolvePath(location);\n\n    try {\n      const stats = await fsStat(filePath);\n      return {\n        size: stats.size,\n        modifiedAt: stats.mtime,\n        isDirectory: stats.isDirectory(),\n      };\n    } catch (error) {\n      const err = error as Error & { code?: string };\n      throw new TransportError(`File stat error: ${err.code} - ${filePath}`, this.name, {\n        cause: err,\n      });\n    }\n  }\n\n  async delete(location: string): Promise<void> {\n    const filePath = this.resolvePath(location);\n\n    try {\n      await rm(filePath, { recursive: true });\n    } catch (error) {\n      const err = error as Error & { code?: string };\n      throw new TransportError(`File delete error: ${err.code} - ${filePath}`, this.name, {\n        cause: err,\n      });\n    }\n  }\n}\n\nexport const fileTransport: FileTransportHandler = new FileTransportHandler();\n",
+    "/**\n * HTTP/HTTPS Transport Handler\n * Provides read-only I/O primitives for HTTP resources\n */\n\nimport { TransportError } from \"../errors.js\";\nimport type { TransportHandler, TransportCapabilities } from \"./types.js\";\n\nexport class HttpTransportHandler implements TransportHandler {\n  readonly name: string;\n  private readonly protocol: \"http\" | \"https\";\n\n  readonly capabilities: TransportCapabilities = {\n    canRead: true,\n    canWrite: false,\n    canList: false,\n    canDelete: false,\n    canStat: false,\n  };\n\n  constructor(protocol: \"http\" | \"https\" = \"https\") {\n    this.protocol = protocol;\n    this.name = protocol;\n  }\n\n  async read(location: string): Promise<Buffer> {\n    const url = `${this.protocol}://${location}`;\n\n    try {\n      const response = await fetch(url);\n\n      if (!response.ok) {\n        throw new TransportError(\n          `HTTP ${response.status}: ${response.statusText} - ${url}`,\n          this.name\n        );\n      }\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.name, {\n        cause: error as Error,\n      });\n    }\n  }\n\n  // HTTP transport is read-only, write/list/delete are not implemented\n}\n\nexport const httpsTransport: HttpTransportHandler = new HttpTransportHandler(\"https\");\nexport const httpTransport: HttpTransportHandler = new HttpTransportHandler(\"http\");\n",
+    "/**\n * Text Semantic Handler\n * Handles plain text resources\n */\n\nimport { SemanticError } from \"../errors.js\";\nimport type { TransportHandler } from \"../transport/types.js\";\nimport type { Resource, SemanticHandler, SemanticContext, ResourceMeta } from \"./types.js\";\n\nexport interface TextResource extends Resource<string> {\n  type: \"text\";\n  content: string;\n}\n\nexport class TextSemanticHandler implements SemanticHandler<string> {\n  readonly name = \"text\";\n\n  async resolve(\n    transport: TransportHandler,\n    location: string,\n    context: SemanticContext\n  ): Promise<TextResource> {\n    const buffer = await transport.read(location);\n    const text = buffer.toString(\"utf-8\");\n\n    const meta: ResourceMeta = {\n      url: context.url,\n      semantic: context.semantic,\n      transport: context.transport,\n      location: context.location,\n      size: buffer.length,\n      encoding: \"utf-8\",\n      mimeType: \"text/plain\",\n      resolvedAt: context.timestamp.toISOString(),\n    };\n\n    return {\n      type: \"text\",\n      content: text,\n      meta,\n    };\n  }\n\n  async deposit(\n    transport: TransportHandler,\n    location: string,\n    data: string,\n    _context: SemanticContext\n  ): Promise<void> {\n    if (!transport.write) {\n      throw new SemanticError(\n        `Transport \"${transport.name}\" does not support write operation`,\n        this.name\n      );\n    }\n\n    const buffer = Buffer.from(data, \"utf-8\");\n    await transport.write(location, buffer);\n  }\n\n  async exists(\n    transport: TransportHandler,\n    location: string,\n    _context: SemanticContext\n  ): Promise<boolean> {\n    if (transport.exists) {\n      return transport.exists(location);\n    }\n\n    // Fallback: try to read\n    try {\n      await transport.read(location);\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  async delete(\n    transport: TransportHandler,\n    location: string,\n    _context: SemanticContext\n  ): Promise<void> {\n    if (!transport.delete) {\n      throw new SemanticError(\n        `Transport \"${transport.name}\" does not support delete operation`,\n        this.name\n      );\n    }\n\n    await transport.delete(location);\n  }\n}\n\nexport const textSemantic: TextSemanticHandler = new TextSemanticHandler();\n",
+    "/**\n * Binary Semantic Handler\n * Handles raw binary resources without any transformation\n */\n\nimport { SemanticError } from \"../errors.js\";\nimport type { TransportHandler } from \"../transport/types.js\";\nimport type { Resource, SemanticHandler, SemanticContext, ResourceMeta } from \"./types.js\";\n\nexport interface BinaryResource extends Resource<Buffer> {\n  type: \"binary\";\n  content: Buffer;\n}\n\n/**\n * Supported binary input types for deposit\n */\nexport type BinaryInput = Buffer | Uint8Array | ArrayBuffer | number[];\n\n/**\n * Convert various binary input types to Buffer\n */\nfunction toBuffer(data: BinaryInput): Buffer {\n  if (Buffer.isBuffer(data)) {\n    return data;\n  }\n  if (data instanceof Uint8Array) {\n    return Buffer.from(data);\n  }\n  if (data instanceof ArrayBuffer) {\n    return Buffer.from(data);\n  }\n  if (Array.isArray(data)) {\n    return Buffer.from(data);\n  }\n  throw new SemanticError(`Unsupported binary input type`, \"binary\");\n}\n\nexport class BinarySemanticHandler implements SemanticHandler<Buffer> {\n  readonly name = \"binary\";\n\n  async resolve(\n    transport: TransportHandler,\n    location: string,\n    context: SemanticContext\n  ): Promise<BinaryResource> {\n    const buffer = await transport.read(location);\n\n    const meta: ResourceMeta = {\n      url: context.url,\n      semantic: context.semantic,\n      transport: context.transport,\n      location: context.location,\n      size: buffer.length,\n      resolvedAt: context.timestamp.toISOString(),\n    };\n\n    return {\n      type: \"binary\",\n      content: buffer,\n      meta,\n    };\n  }\n\n  async deposit(\n    transport: TransportHandler,\n    location: string,\n    data: BinaryInput,\n    _context: SemanticContext\n  ): Promise<void> {\n    if (!transport.write) {\n      throw new SemanticError(\n        `Transport \"${transport.name}\" does not support write operation`,\n        this.name\n      );\n    }\n\n    const buffer = toBuffer(data);\n    await transport.write(location, buffer);\n  }\n\n  async exists(\n    transport: TransportHandler,\n    location: string,\n    _context: SemanticContext\n  ): Promise<boolean> {\n    if (transport.exists) {\n      return transport.exists(location);\n    }\n\n    // Fallback: try to read\n    try {\n      await transport.read(location);\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  async delete(\n    transport: TransportHandler,\n    location: string,\n    _context: SemanticContext\n  ): Promise<void> {\n    if (!transport.delete) {\n      throw new SemanticError(\n        `Transport \"${transport.name}\" does not support delete operation`,\n        this.name\n      );\n    }\n\n    await transport.delete(location);\n  }\n}\n\nexport const binarySemantic: BinarySemanticHandler = new BinarySemanticHandler();\n",
+    "/**\n * ARP - Agent Resource Protocol\n * Factory and instance for parsing ARP URLs\n */\n\nimport { ARL, type HandlerResolver } from \"./ARL.js\";\nimport { ParseError, TransportError, SemanticError } from \"./errors.js\";\nimport type { TransportHandler } from \"./transport/types.js\";\nimport type { SemanticHandler } from \"./semantic/types.js\";\nimport { fileTransport, httpTransport, httpsTransport } from \"./transport/index.js\";\nimport { textSemantic, binarySemantic } from \"./semantic/index.js\";\n\n/**\n * ARP Configuration\n */\nexport interface ARPConfig {\n  /**\n   * Custom transport handlers\n   */\n  transports?: TransportHandler[];\n\n  /**\n   * Custom semantic handlers\n   */\n  semantics?: SemanticHandler[];\n}\n\n/**\n * ARP Instance\n */\nexport class ARP implements HandlerResolver {\n  private readonly transports: Map<string, TransportHandler>;\n  private readonly semantics: Map<string, SemanticHandler>;\n\n  constructor(config: ARPConfig = {}) {\n    this.transports = new Map();\n    this.semantics = new Map();\n\n    // Register default handlers\n    const defaultTransports = [fileTransport, httpTransport, httpsTransport];\n    const defaultSemantics = [textSemantic, binarySemantic];\n\n    for (const handler of defaultTransports) {\n      this.transports.set(handler.name, handler);\n    }\n    for (const handler of defaultSemantics) {\n      this.semantics.set(handler.name, handler);\n    }\n\n    // Register custom handlers (override defaults if same name)\n    if (config.transports) {\n      for (const handler of config.transports) {\n        this.transports.set(handler.name, handler);\n      }\n    }\n\n    if (config.semantics) {\n      for (const handler of config.semantics) {\n        this.semantics.set(handler.name, handler);\n      }\n    }\n  }\n\n  /**\n   * Register a transport handler\n   */\n  registerTransport(handler: TransportHandler): void {\n    this.transports.set(handler.name, handler);\n  }\n\n  /**\n   * Register a semantic handler\n   */\n  registerSemantic(handler: SemanticHandler): void {\n    this.semantics.set(handler.name, handler);\n  }\n\n  /**\n   * Get transport handler by name\n   */\n  getTransportHandler(name: string): TransportHandler {\n    const handler = this.transports.get(name);\n    if (!handler) {\n      throw new TransportError(`Unsupported transport type: ${name}`, name);\n    }\n    return handler;\n  }\n\n  /**\n   * Get semantic handler by name\n   */\n  getSemanticHandler(name: string): SemanticHandler {\n    const handler = this.semantics.get(name);\n    if (!handler) {\n      throw new SemanticError(`Unsupported semantic type: ${name}`, name);\n    }\n    return handler;\n  }\n\n  /**\n   * Parse an ARP URL into an ARL object\n   *\n   * @example\n   * const arl = arp.parse(\"arp:text:file:///path/to/file.txt\");\n   * arl.semantic   // \"text\"\n   * arl.transport  // \"file\"\n   * arl.location   // \"/path/to/file.txt\"\n   */\n  parse(url: string): ARL {\n    // 1. Check protocol prefix\n    if (!url.startsWith(\"arp:\")) {\n      throw new ParseError(`Invalid ARP URL: must start with \"arp:\"`, url);\n    }\n\n    const content = url.substring(4); // Remove \"arp:\"\n\n    // 2. Find :// separator\n    const separatorIndex = content.indexOf(\"://\");\n    if (separatorIndex === -1) {\n      throw new ParseError(`Invalid ARP URL: missing \"://\"`, url);\n    }\n\n    const typePart = content.substring(0, separatorIndex);\n    const location = content.substring(separatorIndex + 3);\n\n    // 3. Split type part by :\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\n    const semantic = typePart.substring(0, colonIndex);\n    const transport = typePart.substring(colonIndex + 1);\n\n    // 4. Validate non-empty\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\n    // 5. Validate handlers exist\n    this.getTransportHandler(transport);\n    this.getSemanticHandler(semantic);\n\n    return new ARL(semantic, transport, location, this);\n  }\n}\n\n/**\n * Create a new ARP instance\n *\n * @example\n * import { createARP, fileTransport, textSemantic } from \"arpjs\";\n *\n * const arp = createARP({\n *   transports: [fileTransport],\n *   semantics: [textSemantic],\n * });\n *\n * const arl = arp.parse(\"arp:text:file:///path/to/file.txt\");\n * const resource = await arl.resolve();\n */\nexport function createARP(config?: ARPConfig): ARP {\n  return new ARP(config);\n}\n",
+    "/**\n * arpjs - Agent Resource Protocol\n *\n * A URL protocol for AI agents to access resources\n * Format: arp:{semantic}:{transport}://{location}\n */\n\ndeclare const __VERSION__: string | undefined;\nexport const VERSION: string = typeof __VERSION__ !== \"undefined\" ? __VERSION__ : \"0.0.0-dev\";\n\n// Core types\nexport type { ARI, ARL } from \"./types.js\";\n\n// ARP factory and class\nexport { ARP, createARP, type ARPConfig } from \"./ARP.js\";\n\n// Errors\nexport { ARPError, ParseError, TransportError, SemanticError } from \"./errors.js\";\n\n// Transport\nexport {\n  type TransportHandler,\n  type TransportCapabilities,\n  type ResourceStat,\n  FileTransportHandler,\n  fileTransport,\n  HttpTransportHandler,\n  httpsTransport,\n  httpTransport,\n} from \"./transport/index.js\";\n\n// Semantic\nexport {\n  type Resource,\n  type SemanticHandler,\n  type ResourceMeta,\n  type SemanticContext,\n  type TextResource,\n  type BinaryResource,\n  type BinaryInput,\n  TextSemanticHandler,\n  textSemantic,\n  BinarySemanticHandler,\n  binarySemantic,\n} from \"./semantic/index.js\";\n"
+  ],
+  "mappings": "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",
+  "debugId": "C42DE403B8D4732364756E2164756E21",
+  "names": []
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@resourcexjs/arp",
+  "version": "0.1.0",
+  "description": "ARP (Agent Resource Protocol) - A URL protocol for AI agents to access resources",
+  "keywords": [
+    "arp",
+    "agent",
+    "resource",
+    "protocol",
+    "ai"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Deepractice/ResourceX.git",
+    "directory": "packages/arp"
+  },
+  "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",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "bun run build.ts",
+    "lint": "eslint .",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "clean": "rm -rf dist"
+  },
+  "devDependencies": {},
+  "publishConfig": {
+    "access": "public"
+  }
+}