@resourcexjs/registry 1.6.0 → 2.0.0

package/README.md

@@ -10,36 +10,47 @@ bun add @resourcexjs/registry
 
 ## Overview
 
-The `@resourcexjs/registry` package provides a Maven-style registry for storing and resolving resources locally.
+The `@resourcexjs/registry` package provides a Maven-style registry for storing and resolving resources (local or remote).
 
 ### Key Concepts
 
 - **Registry**: Interface for resource storage and retrieval
-- **ARPRegistry**: Implementation using ARP (Agent Resource Protocol) for I/O
-- **Local-first**: Resources cached locally at `~/.resourcex`
-- **Maven-style**: Organized by `domain/path/name.type@version`
+- **LocalRegistry**: Filesystem-based implementation for local storage
+- **RemoteRegistry**: HTTP API-based implementation for remote access
+- **Well-known discovery**: Auto-discover registry endpoint via `/.well-known/resourcex`
+- **Maven-style**: Organized by `domain/path/name.type/version`
 
 ## Usage
 
 ### Create Registry
 
 ```typescript
-import { createRegistry } from "@resourcexjs/registry";
+import { createRegistry, discoverRegistry } from "@resourcexjs/registry";
 
-// Default configuration (~/.resourcex)
+// Local registry (default)
 const registry = createRegistry();
 
-// Custom path
-const registry = createRegistry({
+// Local registry with custom path
+const registry2 = createRegistry({
   path: "./my-registry",
 });
 
-// With extension types
+// Local registry with extension types
 import { promptType } from "@my-org/types";
 
-const registry = createRegistry({
+const registry3 = createRegistry({
+  path: "~/.resourcex",
   types: [promptType],
 });
+
+// Remote registry
+const registry4 = createRegistry({
+  endpoint: "https://registry.deepractice.ai/v1",
+});
+
+// Remote registry with well-known discovery
+const endpoint = await discoverRegistry("deepractice.ai");
+const registry5 = createRegistry({ endpoint });
 ```
 
 ### Link Resource
@@ -201,30 +212,59 @@ const all = await registry.search();
 
 ## Storage Structure
 
-Resources are stored in Maven-style structure:
+Resources are stored in two separate areas:
+
+- **local/** - Development resources (organized by name.type/version)
+- **cache/** - Remote cached resources (organized by domain/path/name.type/version)
 
 ```
 ~/.resourcex/
-└── {domain}/
-    └── {path}/
-        └── {name}.{type}@{version}/
-            ├── manifest.json    # RXM metadata
-            └── content          # Serialized content
+├── local/                              # Development area
+│   └── {name}.{type}/
+│       └── {version}/
+│           ├── manifest.json
+│           └── content.tar.gz
+│
+└── cache/                              # Remote cache area
+    └── {domain}/
+        └── {path}/
+            └── {name}.{type}/
+                └── {version}/
+                    ├── manifest.json
+                    └── content.tar.gz
 ```
 
 ### Example
 
-For resource `deepractice.ai/prompts/assistant.prompt@1.0.0`:
+For a local development resource `my-prompt.text@1.0.0`:
+
+```
+~/.resourcex/
+└── local/
+    └── my-prompt.text/
+        └── 1.0.0/
+            ├── manifest.json    # domain can be "deepractice.ai" or "localhost"
+            └── content.tar.gz
+```
+
+For a cached remote resource `deepractice.ai/prompts/assistant.text@1.0.0`:
 
 ```
 ~/.resourcex/
-└── deepractice.ai/
-    └── prompts/
-        └── assistant.prompt@1.0.0/
-            ├── manifest.json
-            └── content
+└── cache/
+    └── deepractice.ai/
+        └── prompts/
+            └── assistant.text/
+                └── 1.0.0/
+                    ├── manifest.json
+                    └── content.tar.gz
 ```
 
+### Resolution Order
+
+1. **local/** is checked first (development resources)
+2. **cache/** is checked second (remote cached resources)
+
 **manifest.json:**
 
 ```json
@@ -237,7 +277,7 @@ For resource `deepractice.ai/prompts/assistant.prompt@1.0.0`:
 }
 ```
 
-**content:** (serialized by type's serializer)
+**content.tar.gz:** Archive containing resource files (managed by TypeHandlerChain)
 
 ## Extension Types
 
@@ -373,31 +413,47 @@ await registry.link(agentResource);
 
 ## Resolution Strategy
 
-1. **Check local registry** (`~/.resourcex` or custom path)
-2. **If not found**: (TODO) Fetch from remote registry based on domain
-3. **Cache locally** after fetching
-4. **Return** resource
+### LocalRegistry
+
+1. **Check local filesystem** (`~/.resourcex` or custom path)
+2. **If not found**: Throw RegistryError
+3. **Return** RXR
+
+### RemoteRegistry
+
+1. **Fetch from HTTP API** (`GET /resource` + `GET /content`)
+2. **Return** RXR (no local caching)
+
+### Future: Hybrid Strategy (TODO)
 
-Currently only local resolution is implemented. Remote fetching is planned.
+1. Check local cache first
+2. If not found, fetch from remote based on domain
+3. Cache locally
+4. Return RXR
 
 ## Architecture
 
 ```
-┌─────────────────────────────────────┐
-│          Registry Interface         │
-└──────────────┬──────────────────────┘
-               │
-        ┌──────▼──────┐
-        │ARPRegistry  │
-        │(implements) │
-        └──────┬──────┘
-               │
-     ┌─────────┴─────────┐
-     │                   │
-┌────▼────┐      ┌──────▼──────┐
-│   ARP   │      │TypeHandler  │
-│(I/O)    │      │Chain        │
-└─────────┘      └─────────────┘
+┌─────────────────────────────────────────┐
+│         Registry Interface              │
+└────────────┬────────────────────────────┘
+             │
+    ┌────────┴────────┐
+    │                 │
+┌───▼──────────┐  ┌──▼──────────────┐
+│LocalRegistry │  │RemoteRegistry   │
+│(filesystem)  │  │(HTTP API)       │
+└───┬──────────┘  └──┬──────────────┘
+    │                │
+┌───▼───────┐    ┌──▼──────┐
+│ Node.js   │    │ fetch   │
+│ fs module │    │         │
+└───────────┘    └─────────┘
+     │                │
+┌────▼────────────────▼─────┐
+│   TypeHandlerChain        │
+│  (serialization logic)    │
+└───────────────────────────┘
 ```
 
 ## Type Safety

package/dist/index.d.ts

@@ -1,9 +1,10 @@
 import { RXR, RXL } from "@resourcexjs/core";
 import { ResourceType, ResolvedResource } from "@resourcexjs/type";
 /**
-* Registry configuration options.
+* Local registry configuration.
+* Uses filesystem for storage.
 */
-interface RegistryConfig {
+interface LocalRegistryConfig {
 	/**
 	* Local storage path. Defaults to ~/.resourcex
 	*/
@@ -15,6 +16,70 @@ interface RegistryConfig {
 	types?: ResourceType[];
 }
 /**
+* Remote registry configuration.
+* Uses HTTP API for access.
+*/
+interface RemoteRegistryConfig {
+	/**
+	* Remote registry API endpoint.
+	* Example: "https://registry.deepractice.ai/v1"
+	*/
+	endpoint: string;
+}
+/**
+* Git registry configuration.
+* Uses git clone to fetch registry content.
+*/
+interface GitRegistryConfig {
+	type: "git";
+	/** Git repository URL (SSH format: git@github.com:owner/repo.git) */
+	url: string;
+	/** Git ref (branch, tag, or commit). Default: "main" */
+	ref?: string;
+	/** Base path in repo for resources. Default: ".resourcex" */
+	basePath?: string;
+	/**
+	* Trusted domain for this registry.
+	* If set, only resources with this domain in manifest are allowed.
+	* Required for security - prevents untrusted registries from claiming any domain.
+	*/
+	domain?: string;
+}
+/**
+* Well-known discovery response format.
+* Used by discoverRegistry() to find registry for a domain.
+*/
+interface WellKnownResponse {
+	version: string;
+	/**
+	* List of registry URLs (git or http).
+	* First one is primary, rest are fallbacks (for future use).
+	*/
+	registries: string[];
+}
+/**
+* Result from discoverRegistry().
+* Contains domain and its authorized registries.
+*/
+interface DiscoveryResult {
+	/** The domain that was discovered */
+	domain: string;
+	/** Authorized registry URLs for this domain */
+	registries: string[];
+}
+/**
+* Registry configuration - local, remote, or git.
+*/
+type RegistryConfig = LocalRegistryConfig | RemoteRegistryConfig | GitRegistryConfig;
+/**
+* Type guard to check if config is for remote registry.
+*/
+declare function isRemoteConfig(config?: RegistryConfig): config is RemoteRegistryConfig;
+/**
+* Type guard to check if config is for git registry.
+*/
+declare function isGitConfig(config?: RegistryConfig): config is GitRegistryConfig;
+/**
 * Search options for querying resources.
 */
 interface SearchOptions {
@@ -32,6 +97,36 @@ interface SearchOptions {
 	offset?: number;
 }
 /**
+* Options for pulling resources from remote registry.
+*/
+interface PullOptions {
+	/**
+	* Pull from a specific registry instead of auto-discovering.
+	*/
+	from?: Registry;
+}
+/**
+* Target configuration for publishing resources.
+*/
+interface PublishTarget {
+	type: "http" | "git";
+	/** HTTP endpoint (for type: "http") */
+	endpoint?: string;
+	/** Git repository URL (for type: "git") */
+	url?: string;
+	/** Git ref - branch/tag (for type: "git"). Default: "main" */
+	ref?: string;
+}
+/**
+* Options for publishing resources to remote registry.
+*/
+interface PublishOptions {
+	/**
+	* Target registry configuration.
+	*/
+	to: PublishTarget;
+}
+/**
 * Registry interface for resource storage and retrieval.
 */
 interface Registry {
@@ -41,14 +136,30 @@ interface Registry {
 	*/
 	supportType(type: ResourceType): void;
 	/**
-	* Publish resource to remote registry (based on domain).
+	* Pull resource from remote registry to local cache.
+	* Discovers remote registry via well-known and caches locally.
+	* @param locator - Resource locator (must include domain)
+	* @param options - Pull options
 	*/
-	publish(resource: RXR): Promise<void>;
+	pull(locator: string, options?: PullOptions): Promise<void>;
+	/**
+	* Publish resource to remote registry.
+	* Resource must exist in local first.
+	* @param resource - Resource to publish
+	* @param options - Publish target configuration
+	*/
+	publish(resource: RXR, options: PublishOptions): Promise<void>;
 	/**
 	* Link resource to local registry (for development/caching).
 	*/
 	link(resource: RXR): Promise<void>;
 	/**
+	* Get raw resource by locator string.
+	* Returns the RXR (locator + manifest + content) without resolving.
+	* Use this when you need access to raw resource content.
+	*/
+	get(locator: string): Promise<RXR>;
+	/**
 	* Resolve resource by locator string.
 	* Returns a ResolvedResource with execute function and original resource.
 	* Checks local first, then fetches from remote if not found.
@@ -82,23 +193,46 @@ declare class RegistryError extends ResourceXError {
 import { RXR as RXR2, RXL as RXL2 } from "@resourcexjs/core";
 import { ResourceType as ResourceType2, ResolvedResource as ResolvedResource2 } from "@resourcexjs/type";
 /**
-* ARP-based registry implementation.
-* Uses ARP protocol for atomic I/O operations.
-* Each instance has its own TypeHandlerChain for type handling.
+* Local filesystem-based registry implementation.
+* Uses Node.js fs module directly for storage operations.
 */
-declare class ARPRegistry implements Registry {
-	private readonly arp;
+declare class LocalRegistry implements Registry {
 	private readonly basePath;
 	private readonly typeHandler;
-	constructor(config?: RegistryConfig);
+	constructor(config?: LocalRegistryConfig);
 	supportType(type: ResourceType2): void;
 	/**
-	* Build ARP URL for a resource file.
-	* Path structure: {basePath}/{domain}/{path}/{name}.{type}/{version}/{filename}
+	* Build filesystem path for a resource.
+	*
+	* Storage structure:
+	* - local: {basePath}/local/{name}.{type}/{version}
+	* - cache: {basePath}/cache/{domain}/{path}/{name}.{type}/{version}
+	*
+	* @param locator - Resource locator
+	* @param area - Storage area ("local" or "cache")
+	*/
+	private buildPath;
+	/**
+	* Determine if a locator refers to a local-only resource (no domain or localhost).
+	*/
+	private isLocalOnlyLocator;
+	/**
+	* Check if a resource exists at a specific path.
 	*/
-	private buildUrl;
-	publish(_resource: RXR2): Promise<void>;
+	private existsAt;
+	/**
+	* Find which area a resource exists in.
+	* Returns the area ("local" or "cache") or null if not found.
+	*/
+	private findArea;
+	/**
+	* Load resource from a specific path.
+	*/
+	private loadFrom;
+	pull(_locator: string, _options?: PullOptions): Promise<void>;
+	publish(_resource: RXR2, _options: PublishOptions): Promise<void>;
 	link(resource: RXR2): Promise<void>;
+	get(locator: string): Promise<RXR2>;
 	resolve<
 		TArgs = void,
 		TResult = unknown
@@ -107,14 +241,125 @@ declare class ARPRegistry implements Registry {
 	delete(locator: string): Promise<void>;
 	search(options?: SearchOptions): Promise<RXL2[]>;
 	/**
-	* Parse a file entry path to RXL.
+	* Recursively list all files in a directory.
+	*/
+	private listRecursive;
+	/**
+	* Parse a local entry path to RXL.
+	* Entry format: {name}.{type}/{version}/manifest.json
+	*/
+	private parseLocalEntry;
+	/**
+	* Parse a cache entry path to RXL.
 	* Entry format: {domain}/{path}/{name}.{type}/{version}/manifest.json
 	*/
+	private parseCacheEntry;
+	/**
+	* Parse name and type from a combined string like "name.type" or "name".
+	*/
+	private parseNameType;
+}
+import { RXR as RXR3, RXL as RXL3 } from "@resourcexjs/core";
+import { ResourceType as ResourceType3, ResolvedResource as ResolvedResource3 } from "@resourcexjs/type";
+/**
+* Remote registry implementation.
+* Uses HTTP API for resource access.
+*/
+declare class RemoteRegistry implements Registry {
+	private readonly endpoint;
+	private readonly typeHandler;
+	constructor(config: RemoteRegistryConfig);
+	supportType(type: ResourceType3): void;
+	pull(_locator: string, _options?: PullOptions): Promise<void>;
+	publish(_resource: RXR3, _options: PublishOptions): Promise<void>;
+	link(_resource: RXR3): Promise<void>;
+	get(locator: string): Promise<RXR3>;
+	resolve<
+		TArgs = void,
+		TResult = unknown
+	>(locator: string): Promise<ResolvedResource3<TArgs, TResult>>;
+	exists(locator: string): Promise<boolean>;
+	delete(_locator: string): Promise<void>;
+	search(options?: SearchOptions): Promise<RXL3[]>;
+}
+/**
+* Discover registry for a domain using well-known.
+* @param domain - The domain to discover (e.g., "deepractice.ai")
+* @returns Discovery result with domain and authorized registries
+*/
+declare function discoverRegistry(domain: string): Promise<DiscoveryResult>;
+import { RXR as RXR4, RXL as RXL4 } from "@resourcexjs/core";
+import { ResourceType as ResourceType4, ResolvedResource as ResolvedResource4 } from "@resourcexjs/type";
+/**
+* Git-based registry implementation.
+* Clones a git repository and reads resources from it.
+*/
+declare class GitRegistry implements Registry {
+	private readonly url;
+	private readonly ref;
+	private readonly basePath;
+	private readonly cacheDir;
+	private readonly typeHandler;
+	private readonly trustedDomain?;
+	constructor(config: GitRegistryConfig);
+	/**
+	* Check if URL is a remote git URL (not local path).
+	*/
+	private isRemoteUrl;
+	/**
+	* Build cache directory name from git URL.
+	* git@github.com:Deepractice/Registry.git → github.com-Deepractice-Registry
+	*/
+	private buildCacheDir;
+	supportType(type: ResourceType4): void;
+	/**
+	* Ensure the repository is cloned and up to date.
+	*/
+	private ensureCloned;
+	/**
+	* Execute git command in the cache directory.
+	*/
+	private gitExec;
+	/**
+	* Build filesystem path for a resource in the cloned repo.
+	* Path structure: {cacheDir}/{basePath}/{domain}/{path}/{name}.{type}/{version}
+	*/
+	private buildResourcePath;
+	get(locator: string): Promise<RXR4>;
+	resolve<
+		TArgs = void,
+		TResult = unknown
+	>(locator: string): Promise<ResolvedResource4<TArgs, TResult>>;
+	exists(locator: string): Promise<boolean>;
+	search(options?: SearchOptions): Promise<RXL4[]>;
+	private listRecursive;
 	private parseEntryToRXL;
+	pull(_locator: string, _options?: PullOptions): Promise<void>;
+	publish(_resource: RXR4, _options: PublishOptions): Promise<void>;
+	link(_resource: RXR4): Promise<void>;
+	delete(_locator: string): Promise<void>;
 }
 /**
 * Create a registry instance.
-* Uses ARP protocol for storage operations.
+*
+* @param config - Registry configuration
+*   - No config or LocalRegistryConfig: Creates LocalRegistry (filesystem-based)
+*   - RemoteRegistryConfig: Creates RemoteRegistry (HTTP-based)
+*   - GitRegistryConfig: Creates GitRegistry (git clone-based)
+*
+* @example
+* // Local registry (default)
+* const registry = createRegistry();
+* const registry2 = createRegistry({ path: "./custom-path" });
+*
+* // Remote registry
+* const registry3 = createRegistry({ endpoint: "https://registry.deepractice.ai/v1" });
+*
+* // Git registry
+* const registry4 = createRegistry({
+*   type: "git",
+*   url: "git@github.com:Deepractice/Registry.git",
+* });
 */
 declare function createRegistry(config?: RegistryConfig): Registry;
-export { createRegistry, SearchOptions, RegistryError, RegistryConfig, Registry, ARPRegistry };
+export { isRemoteConfig, isGitConfig, discoverRegistry, createRegistry, WellKnownResponse, SearchOptions, RemoteRegistryConfig, RemoteRegistry, RegistryError, RegistryConfig, Registry, PullOptions, PublishTarget, PublishOptions, LocalRegistryConfig, LocalRegistry, GitRegistryConfig, GitRegistry, DiscoveryResult };