@resourcexjs/registry 1.1.0 → 1.3.0

package/README.md

@@ -175,9 +175,29 @@ await registry.delete("localhost/my-prompt.text@1.0.0");
 
 Publish resource to remote registry (TODO: not yet implemented).
 
-#### `search(query: string): Promise<RXL[]>`
+#### `search(options?): Promise<RXL[]>`
 
-Search for resources (TODO: not yet implemented).
+Search for resources in local registry.
+
+**Parameters:**
+
+- `options?: SearchOptions`
+  - `query?: string` - Filter by locator substring
+  - `limit?: number` - Max results to return
+  - `offset?: number` - Skip first N results
+
+**Returns**: `Promise<RXL[]>` - Array of matching locators
+
+```typescript
+// Search by name
+const results = await registry.search({ query: "assistant" });
+
+// With pagination
+const page = await registry.search({ query: "prompt", limit: 10, offset: 20 });
+
+// List all resources
+const all = await registry.search();
+```
 
 ## Storage Structure
 

package/dist/index.d.ts

@@ -15,6 +15,23 @@ interface RegistryConfig {
 	types?: ResourceType[];
 }
 /**
+* Search options for querying resources.
+*/
+interface SearchOptions {
+	/**
+	* Search query string (matches against name, domain, path).
+	*/
+	query?: string;
+	/**
+	* Maximum number of results to return.
+	*/
+	limit?: number;
+	/**
+	* Number of results to skip (for pagination).
+	*/
+	offset?: number;
+}
+/**
 * Registry interface for resource storage and retrieval.
 */
 interface Registry {
@@ -40,9 +57,11 @@ interface Registry {
 	*/
 	delete(locator: string): Promise<void>;
 	/**
-	* Search for resources matching query.
+	* Search for resources matching options.
+	* @param options - Search options (query, limit, offset)
+	* @returns Array of matching resource locators
 	*/
-	search(query: string): Promise<RXL[]>;
+	search(options?: SearchOptions): Promise<RXL[]>;
 }
 import { ResourceXError } from "@resourcexjs/core";
 /**
@@ -70,11 +89,16 @@ declare class ARPRegistry implements Registry {
 	resolve(locator: string): Promise<RXR2>;
 	exists(locator: string): Promise<boolean>;
 	delete(locator: string): Promise<void>;
-	search(_query: string): Promise<RXL2[]>;
+	search(options?: SearchOptions): Promise<RXL2[]>;
+	/**
+	* Parse a file entry path to RXL.
+	* Entry format: {domain}/{path}/{name}.{type}@{version}/manifest.json
+	*/
+	private parseEntryToRXL;
 }
 /**
 * Create a registry instance.
 * Uses ARP protocol for storage operations.
 */
 declare function createRegistry(config?: RegistryConfig): Registry;
-export { createRegistry, RegistryError, RegistryConfig, Registry, ARPRegistry };
+export { createRegistry, SearchOptions, RegistryError, RegistryConfig, Registry, ARPRegistry };

package/dist/index.js

@@ -1303,8 +1303,10 @@ var textSerializer = {
 };
 var textResolver = {
   async resolve(rxr) {
-    const buffer = await rxr.content.file("content");
-    return buffer.toString("utf-8");
+    return async () => {
+      const buffer = await rxr.content.file("content");
+      return buffer.toString("utf-8");
+    };
   }
 };
 var textType = {
@@ -1328,8 +1330,10 @@ var jsonSerializer = {
 };
 var jsonResolver = {
   async resolve(rxr) {
-    const buffer = await rxr.content.file("content");
-    return JSON.parse(buffer.toString("utf-8"));
+    return async () => {
+      const buffer = await rxr.content.file("content");
+      return JSON.parse(buffer.toString("utf-8"));
+    };
   }
 };
 var jsonType = {
@@ -1353,7 +1357,9 @@ var binarySerializer = {
 };
 var binaryResolver = {
   async resolve(rxr) {
-    return rxr.content.file("content");
+    return async () => {
+      return rxr.content.file("content");
+    };
   }
 };
 var binaryType = {
@@ -1444,8 +1450,8 @@ class TypeHandlerChain {
 var globalTypeHandlerChain = TypeHandlerChain.getInstance();
 
 // ../arp/dist/index.js
-import { readFile, writeFile, readdir, mkdir, rm, access, stat as fsStat } from "node:fs/promises";
-import { resolve, dirname } from "node:path";
+import { readFile, writeFile, readdir, mkdir, rm, access, stat } from "node:fs/promises";
+import { resolve, dirname, join } from "node:path";
 
 class ARPError extends Error {
   constructor(message, options) {
@@ -1492,25 +1498,26 @@ class ARL {
     this.location = location;
     this.resolver = resolver;
   }
-  createContext() {
+  createContext(params) {
     return {
       url: this.toString(),
       semantic: this.semantic,
       transport: this.transport,
       location: this.location,
-      timestamp: new Date
+      timestamp: new Date,
+      params
     };
   }
-  async resolve() {
+  async resolve(params) {
     const transport = this.resolver.getTransportHandler(this.transport);
     const semantic = this.resolver.getSemanticHandler(this.semantic);
-    const context = this.createContext();
+    const context = this.createContext(params);
     return semantic.resolve(transport, this.location, context);
   }
-  async deposit(data) {
+  async deposit(data, params) {
     const transport = this.resolver.getTransportHandler(this.transport);
     const semantic = this.resolver.getSemanticHandler(this.semantic);
-    const context = this.createContext();
+    const context = this.createContext(params);
     if (!semantic.deposit) {
       throw new SemanticError(`Semantic "${semantic.name}" does not support deposit operation`, this.semantic);
     }
@@ -1523,15 +1530,7 @@ class ARL {
     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;
-    }
+    return transport.exists(this.location);
   }
   async delete() {
     const transport = this.resolver.getTransportHandler(this.transport);
@@ -1540,9 +1539,6 @@ class ARL {
     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() {
@@ -1552,57 +1548,88 @@ class ARL {
 
 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) {
+  async get(location, params) {
     const filePath = this.resolvePath(location);
     try {
-      return await readFile(filePath);
+      const stats = await stat(filePath);
+      if (stats.isDirectory()) {
+        return this.getDirectory(filePath, stats, params);
+      } else {
+        return this.getFile(filePath, stats);
+      }
     } catch (error) {
       const err = error;
-      throw new TransportError(`File read error: ${err.code} - ${filePath}`, this.name, {
+      throw new TransportError(`File get 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 getFile(filePath, stats) {
+    const content = await readFile(filePath);
+    return {
+      content,
+      metadata: {
+        type: "file",
+        size: Number(stats.size),
+        modifiedAt: stats.mtime
+      }
+    };
+  }
+  async getDirectory(dirPath, stats, params) {
+    const recursive = params?.recursive === "true";
+    const pattern = params?.pattern;
+    let entries;
+    if (recursive) {
+      entries = await this.listRecursive(dirPath, dirPath);
+    } else {
+      entries = await readdir(dirPath);
+    }
+    if (pattern) {
+      entries = this.filterByPattern(entries, pattern);
     }
+    const content = Buffer.from(JSON.stringify(entries));
+    return {
+      content,
+      metadata: {
+        type: "directory",
+        modifiedAt: stats.mtime
+      }
+    };
   }
-  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 listRecursive(basePath, currentPath) {
+    const entries = await readdir(currentPath, { withFileTypes: true });
+    const results = [];
+    for (const entry of entries) {
+      const fullPath = join(currentPath, entry.name);
+      const relativePath = fullPath.substring(basePath.length + 1);
+      if (entry.isDirectory()) {
+        const subEntries = await this.listRecursive(basePath, fullPath);
+        results.push(...subEntries);
+      } else {
+        results.push(relativePath);
+      }
     }
+    return results;
   }
-  async mkdir(location) {
-    const dirPath = this.resolvePath(location);
+  filterByPattern(entries, pattern) {
+    const regexPattern = pattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".");
+    const regex = new RegExp(`^${regexPattern}$`);
+    return entries.filter((entry) => {
+      const filename = entry.split("/").pop() || entry;
+      return regex.test(filename);
+    });
+  }
+  async set(location, content, _params) {
+    const filePath = this.resolvePath(location);
     try {
-      await mkdir(dirPath, { recursive: true });
+      await mkdir(dirname(filePath), { recursive: true });
+      await writeFile(filePath, content);
     } catch (error) {
       const err = error;
-      throw new TransportError(`Directory create error: ${err.code} - ${dirPath}`, this.name, {
+      throw new TransportError(`File set error: ${err.code} - ${filePath}`, this.name, {
         cause: err
       });
     }
@@ -1616,28 +1643,15 @@ class FileTransportHandler {
       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;
+      if (err.code === "ENOENT") {
+        return;
+      }
       throw new TransportError(`File delete error: ${err.code} - ${filePath}`, this.name, {
         cause: err
       });
@@ -1649,26 +1663,31 @@ var fileTransport = new FileTransportHandler;
 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}`;
+  async get(location, params) {
+    const url = this.buildUrl(location, params);
     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);
+      const content = Buffer.from(arrayBuffer);
+      const contentType = response.headers.get("content-type");
+      const contentLength = response.headers.get("content-length");
+      const lastModified = response.headers.get("last-modified");
+      return {
+        content,
+        metadata: {
+          type: "file",
+          size: contentLength ? parseInt(contentLength, 10) : content.length,
+          modifiedAt: lastModified ? new Date(lastModified) : undefined,
+          contentType
+        }
+      };
     } catch (error) {
       if (error instanceof TransportError) {
         throw error;
@@ -1678,6 +1697,30 @@ class HttpTransportHandler {
       });
     }
   }
+  buildUrl(location, params) {
+    const url = new URL(`${this.protocol}://${location}`);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        url.searchParams.set(key, value);
+      }
+    }
+    return url.toString();
+  }
+  async set(_location, _content, _params) {
+    throw new TransportError("HTTP transport is read-only, set not supported", this.name);
+  }
+  async exists(location) {
+    const url = `${this.protocol}://${location}`;
+    try {
+      const response = await fetch(url, { method: "HEAD" });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  async delete(_location) {
+    throw new TransportError("HTTP transport is read-only, delete not supported", this.name);
+  }
 }
 var httpsTransport = new HttpTransportHandler("https");
 var httpTransport = new HttpTransportHandler("http");
@@ -1685,17 +1728,36 @@ var httpTransport = new HttpTransportHandler("http");
 class TextSemanticHandler {
   name = "text";
   async resolve(transport, location, context) {
-    const buffer = await transport.read(location);
-    const text = buffer.toString("utf-8");
+    const result = await transport.get(location, context.params);
+    if (result.metadata?.type === "directory") {
+      const meta2 = {
+        url: context.url,
+        semantic: context.semantic,
+        transport: context.transport,
+        location: context.location,
+        size: result.content.length,
+        encoding: "utf-8",
+        mimeType: "application/json",
+        resolvedAt: context.timestamp.toISOString(),
+        type: "directory"
+      };
+      return {
+        type: "text",
+        content: result.content.toString("utf-8"),
+        meta: meta2
+      };
+    }
+    const text = result.content.toString("utf-8");
     const meta = {
       url: context.url,
       semantic: context.semantic,
       transport: context.transport,
       location: context.location,
-      size: buffer.length,
+      size: result.metadata?.size ?? result.content.length,
       encoding: "utf-8",
       mimeType: "text/plain",
-      resolvedAt: context.timestamp.toISOString()
+      resolvedAt: context.timestamp.toISOString(),
+      type: "file"
     };
     return {
       type: "text",
@@ -1703,29 +1765,23 @@ class TextSemanticHandler {
       meta
     };
   }
-  async deposit(transport, location, data, _context) {
-    if (!transport.write) {
-      throw new SemanticError(`Transport "${transport.name}" does not support write operation`, this.name);
-    }
+  async deposit(transport, location, data, context) {
     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;
+      await transport.set(location, buffer, context.params);
+    } catch (error) {
+      throw new SemanticError(`Failed to deposit text to "${location}": ${error.message}`, this.name, { cause: error });
     }
   }
+  async exists(transport, location, _context) {
+    return transport.exists(location);
+  }
   async delete(transport, location, _context) {
-    if (!transport.delete) {
-      throw new SemanticError(`Transport "${transport.name}" does not support delete operation`, this.name);
+    try {
+      await transport.delete(location);
+    } catch (error) {
+      throw new SemanticError(`Failed to delete "${location}": ${error.message}`, this.name, { cause: error });
     }
-    await transport.delete(location);
   }
 }
 var textSemantic = new TextSemanticHandler;
@@ -1748,44 +1804,39 @@ function toBuffer(data) {
 class BinarySemanticHandler {
   name = "binary";
   async resolve(transport, location, context) {
-    const buffer = await transport.read(location);
+    const result = await transport.get(location, context.params);
     const meta = {
       url: context.url,
       semantic: context.semantic,
       transport: context.transport,
       location: context.location,
-      size: buffer.length,
-      resolvedAt: context.timestamp.toISOString()
+      size: result.metadata?.size ?? result.content.length,
+      resolvedAt: context.timestamp.toISOString(),
+      type: result.metadata?.type
     };
     return {
       type: "binary",
-      content: buffer,
+      content: result.content,
       meta
     };
   }
-  async deposit(transport, location, data, _context) {
-    if (!transport.write) {
-      throw new SemanticError(`Transport "${transport.name}" does not support write operation`, this.name);
-    }
+  async deposit(transport, location, data, context) {
     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;
+      await transport.set(location, buffer, context.params);
+    } catch (error) {
+      throw new SemanticError(`Failed to deposit binary to "${location}": ${error.message}`, this.name, { cause: error });
     }
   }
+  async exists(transport, location, _context) {
+    return transport.exists(location);
+  }
   async delete(transport, location, _context) {
-    if (!transport.delete) {
-      throw new SemanticError(`Transport "${transport.name}" does not support delete operation`, this.name);
+    try {
+      await transport.delete(location);
+    } catch (error) {
+      throw new SemanticError(`Failed to delete "${location}": ${error.message}`, this.name, { cause: error });
     }
-    await transport.delete(location);
   }
 }
 var binarySemantic = new BinarySemanticHandler;
@@ -1939,8 +1990,80 @@ class ARPRegistry {
     const contentArl = this.arp.parse(contentUrl);
     await contentArl.delete();
   }
-  async search(_query) {
-    throw new RegistryError("Search not implemented yet");
+  async search(options) {
+    const { query, limit, offset = 0 } = options ?? {};
+    const baseUrl = `arp:text:file://${this.basePath}`;
+    const baseArl = this.arp.parse(baseUrl);
+    let entries;
+    try {
+      const result2 = await baseArl.resolve({ recursive: "true" });
+      entries = JSON.parse(result2.content);
+    } catch {
+      return [];
+    }
+    const locators = [];
+    for (const entry of entries) {
+      if (!entry.endsWith("/manifest.json")) {
+        continue;
+      }
+      const rxl = this.parseEntryToRXL(entry);
+      if (rxl) {
+        locators.push(rxl);
+      }
+    }
+    let filtered = locators;
+    if (query) {
+      const lowerQuery = query.toLowerCase();
+      filtered = locators.filter((rxl) => {
+        const searchText = `${rxl.domain ?? ""} ${rxl.path ?? ""} ${rxl.name} ${rxl.type ?? ""}`.toLowerCase();
+        return searchText.includes(lowerQuery);
+      });
+    }
+    let result = filtered.slice(offset);
+    if (limit !== undefined) {
+      result = result.slice(0, limit);
+    }
+    return result;
+  }
+  parseEntryToRXL(entry) {
+    const dirPath = entry.replace(/\/manifest\.json$/, "");
+    const parts = dirPath.split("/");
+    if (parts.length < 2) {
+      return null;
+    }
+    const resourceDir = parts.pop();
+    const domain = parts.shift();
+    const path = parts.length > 0 ? parts.join("/") : undefined;
+    const atIndex = resourceDir.lastIndexOf("@");
+    if (atIndex === -1) {
+      return null;
+    }
+    const nameTypePart = resourceDir.substring(0, atIndex);
+    const version = resourceDir.substring(atIndex + 1);
+    const dotIndex = nameTypePart.lastIndexOf(".");
+    let name;
+    let type;
+    if (dotIndex !== -1) {
+      name = nameTypePart.substring(0, dotIndex);
+      type = nameTypePart.substring(dotIndex + 1);
+    } else {
+      name = nameTypePart;
+      type = undefined;
+    }
+    let locatorStr = domain;
+    if (path) {
+      locatorStr += `/${path}`;
+    }
+    locatorStr += `/${name}`;
+    if (type) {
+      locatorStr += `.${type}`;
+    }
+    locatorStr += `@${version}`;
+    try {
+      return parseRXL(locatorStr);
+    } catch {
+      return null;
+    }
   }
 }
 // src/createRegistry.ts
@@ -1953,4 +2076,4 @@ export {
   ARPRegistry
 };
 
-//# debugId=6B85BCB12D2565AC64756E2164756E21
+//# debugId=B15E14D1A3CBAC5164756E2164756E21