@namzu/sdk 0.1.1 → 0.1.2

package/src/registry/agent/definitions.ts

@@ -1,74 +1,82 @@
-import type { AgentDefinition, AgentType } from "../../types/agent/index.js";
-import type {
-	Agent,
-	BaseAgentConfig,
-	BaseAgentResult,
-} from "../../types/agent/index.js";
-import { type Logger, getRootLogger } from "../../utils/logger.js";
-import { Registry } from "../Registry.js";
+import type { AgentDefinition, AgentType } from '../../types/agent/index.js'
+import type { Agent, BaseAgentConfig, BaseAgentResult } from '../../types/agent/index.js'
+import { type Logger, getRootLogger } from '../../utils/logger.js'
+import { Registry } from '../Registry.js'
 
 export class AgentRegistry extends Registry<AgentDefinition> {
-	private log: Logger;
+	private log: Logger
 
 	constructor() {
-		super();
-		this.log = getRootLogger().child({ component: "AgentRegistry" });
+		super()
+		this.log = getRootLogger().child({ component: 'AgentRegistry' })
 	}
 
-	override register(id: string, definition: AgentDefinition): void;
-	register(definition: AgentDefinition): void;
-	register(definitions: AgentDefinition[]): void;
-	register(
+	override register(id: string, definition: AgentDefinition): void
+	override register(definition: AgentDefinition): void
+	override register(definitions: AgentDefinition[]): void
+	override register(
 		idOrDef: string | AgentDefinition | AgentDefinition[],
 		maybeDef?: AgentDefinition,
 	): void {
 		if (Array.isArray(idOrDef)) {
 			for (const def of idOrDef) {
-				this.register(def);
+				this.register(def)
 			}
-			return;
+			return
 		}
 
-		const def = typeof idOrDef === "string" ? maybeDef! : idOrDef;
-		const id = typeof idOrDef === "string" ? idOrDef : def.info.id;
+		if (typeof idOrDef === 'string') {
+			if (!maybeDef) {
+				throw new Error('register(id, definition) requires a definition argument')
+			}
+			const id = idOrDef
+			const def = maybeDef
+			if (this.has(id)) {
+				this.log.warn(`Agent "${id}" already registered, overwriting.`)
+			}
+			super.register(id, def)
+			this.log.info(`Agent registered: ${id}`)
+			return
+		}
+
+		const def = idOrDef
+		const id = def.info.id
 
 		if (this.has(id)) {
-			this.log.warn(`Agent "${id}" already registered, overwriting.`);
+			this.log.warn(`Agent "${id}" already registered, overwriting.`)
 		}
-		super.register(id, def);
-		this.log.info(`Agent registered: ${id}`);
+		super.register(id, def)
+		this.log.info(`Agent registered: ${id}`)
 	}
 
 	getOrThrow(id: string): AgentDefinition {
-		const def = this.get(id);
+		const def = this.get(id)
 		if (!def) {
-			throw new Error(
-				`Agent not found: "${id}". Available: ${this.listIds().join(", ")}`,
-			);
+			throw new Error(`Agent not found: "${id}". Available: ${this.listIds().join(', ')}`)
 		}
-		return def;
+		return def
 	}
 
 	resolve(agentId: string): Agent<BaseAgentConfig, BaseAgentResult> {
-		return this.getOrThrow(agentId).typedAgent;
+		return this.getOrThrow(agentId).typedAgent
 	}
 
 	listByType(type: AgentType): AgentDefinition[] {
-		return this.getAll().filter((d) => d.typedAgent.type === type);
+		return this.getAll().filter((d) => d.typedAgent.type === type)
 	}
 
 	search(query: { category?: string; query?: string }): AgentDefinition[] {
 		return this.getAll().filter((def) => {
-			if (query.category && def.info.category !== query.category) return false;
+			if (query.category && def.info.category !== query.category) return false
 			if (query.query) {
-				const q = query.query.toLowerCase();
+				const q = query.query.toLowerCase()
 				if (
 					!def.info.name.toLowerCase().includes(q) &&
 					!def.info.description.toLowerCase().includes(q)
 				)
-					return false;
+					return false
 			}
-			return true;
-		});
+			return true
+		})
 	}
 }

package/src/registry/agent/index.ts

@@ -1 +1 @@
-export { AgentRegistry } from "./definitions.js";
+export { AgentRegistry } from './definitions.js'

package/src/registry/connector/definitions.ts

@@ -1,52 +1,62 @@
-import type { ConnectorDefinition } from "../../types/connector/index.js";
-import { type Logger, getRootLogger } from "../../utils/logger.js";
-import { Registry } from "../Registry.js";
+import type { ConnectorDefinition } from '../../types/connector/index.js'
+import { type Logger, getRootLogger } from '../../utils/logger.js'
+import { Registry } from '../Registry.js'
 
 export class ConnectorRegistry extends Registry<ConnectorDefinition> {
-	private log: Logger;
+	private log: Logger
 
 	constructor() {
-		super();
-		this.log = getRootLogger().child({ component: "ConnectorRegistry" });
+		super()
+		this.log = getRootLogger().child({ component: 'ConnectorRegistry' })
 	}
 
-	override register(id: string, definition: ConnectorDefinition): void;
-	register(definition: ConnectorDefinition): void;
-	register(definitions: ConnectorDefinition[]): void;
-	register(
+	override register(id: string, definition: ConnectorDefinition): void
+	override register(definition: ConnectorDefinition): void
+	override register(definitions: ConnectorDefinition[]): void
+	override register(
 		idOrDef: string | ConnectorDefinition | ConnectorDefinition[],
 		maybeDef?: ConnectorDefinition,
 	): void {
 		if (Array.isArray(idOrDef)) {
 			for (const def of idOrDef) {
-				this.register(def);
+				this.register(def)
 			}
-			return;
+			return
 		}
 
-		const def = typeof idOrDef === "string" ? maybeDef! : idOrDef;
-		const id = typeof idOrDef === "string" ? idOrDef : def.id;
+		if (typeof idOrDef === 'string') {
+			if (!maybeDef) {
+				throw new Error('register(id, definition) requires a definition argument')
+			}
+			const id = idOrDef
+			const def = maybeDef
+			if (this.has(id)) {
+				this.log.warn(`Connector "${id}" is already registered, overwriting.`)
+			}
+			super.register(id, def)
+			this.log.info(`Connector registered: ${id}`)
+			return
+		}
+
+		const def = idOrDef
+		const id = def.id
 
 		if (this.has(id)) {
-			this.log.warn(`Connector "${id}" is already registered, overwriting.`);
+			this.log.warn(`Connector "${id}" is already registered, overwriting.`)
 		}
-		super.register(id, def);
-		this.log.info(`Connector registered: ${id}`);
+		super.register(id, def)
+		this.log.info(`Connector registered: ${id}`)
 	}
 
 	getOrThrow(id: string): ConnectorDefinition {
-		const def = this.get(id);
+		const def = this.get(id)
 		if (!def) {
-			throw new Error(
-				`Connector not found: "${id}". Available: ${this.listIds().join(", ")}`,
-			);
+			throw new Error(`Connector not found: "${id}". Available: ${this.listIds().join(', ')}`)
 		}
-		return def;
+		return def
 	}
 
-	listByType(
-		connectionType: ConnectorDefinition["connectionType"],
-	): ConnectorDefinition[] {
-		return this.getAll().filter((d) => d.connectionType === connectionType);
+	listByType(connectionType: ConnectorDefinition['connectionType']): ConnectorDefinition[] {
+		return this.getAll().filter((d) => d.connectionType === connectionType)
 	}
 }

package/src/registry/connector/scoped.ts

@@ -1,129 +1,129 @@
 import type {
-  ScopedConnectorConfig,
-  ResolvedConnectorConfig,
-  ConnectorConfig,
-  ConnectorScope,
-  ScopeRef,
-  ScopeChain,
-  AuthConfig,
+	AuthConfig,
+	ConnectorConfig,
+	ConnectorScope,
+	ResolvedConnectorConfig,
+	ScopeChain,
+	ScopeRef,
+	ScopedConnectorConfig,
 } from '../../types/connector/index.js'
 import { CONNECTOR_SCOPE_ORDER } from '../../types/connector/index.js'
-import { getRootLogger, type Logger } from '../../utils/logger.js'
+import { type Logger, getRootLogger } from '../../utils/logger.js'
 
 function scopeKey(scope: ConnectorScope, scopeId: string, connectorId: string): string {
-  return `${scope}:${scopeId}:${connectorId}`
+	return `${scope}:${scopeId}:${connectorId}`
 }
 
 export class ScopedConnectorRegistry {
-  private configs: Map<string, ScopedConnectorConfig> = new Map()
-  private log: Logger
-
-  constructor() {
-    this.log = getRootLogger().child({ component: 'ScopedConnectorRegistry' })
-  }
-
-  set(config: ScopedConnectorConfig): void {
-    const key = scopeKey(config.scope.scope, config.scope.scopeId, config.connectorId)
-    this.configs.set(key, config)
-    this.log.info(`Scoped config set: ${key}`)
-  }
-
-  remove(scope: ScopeRef, connectorId: string): boolean {
-    const key = scopeKey(scope.scope, scope.scopeId, connectorId)
-    const removed = this.configs.delete(key)
-    if (removed) {
-      this.log.info(`Scoped config removed: ${key}`)
-    }
-    return removed
-  }
-
-  getAt(scope: ScopeRef, connectorId: string): ScopedConnectorConfig | undefined {
-    return this.configs.get(scopeKey(scope.scope, scope.scopeId, connectorId))
-  }
-
-  resolve(connectorId: string, chain: ScopeChain): ResolvedConnectorConfig | undefined {
-    const layers: ScopedConnectorConfig[] = []
-
-    for (const scope of CONNECTOR_SCOPE_ORDER) {
-      const scopeId = chain[scope]
-      if (!scopeId) continue
-
-      const config = this.configs.get(scopeKey(scope, scopeId, connectorId))
-      if (config) {
-        layers.push(config)
-      }
-    }
-
-    if (layers.length === 0) return undefined
-
-    return this.mergeLayers(connectorId, layers)
-  }
-
-  listForConnector(connectorId: string): ScopedConnectorConfig[] {
-    const results: ScopedConnectorConfig[] = []
-    for (const config of this.configs.values()) {
-      if (config.connectorId === connectorId) {
-        results.push(config)
-      }
-    }
-    return results
-  }
-
-  listAtScope(scope: ScopeRef): ScopedConnectorConfig[] {
-    const prefix = `${scope.scope}:${scope.scopeId}:`
-    const results: ScopedConnectorConfig[] = []
-    for (const [key, config] of this.configs.entries()) {
-      if (key.startsWith(prefix)) {
-        results.push(config)
-      }
-    }
-    return results
-  }
-
-  private mergeLayers(
-    connectorId: string,
-    layers: ScopedConnectorConfig[],
-  ): ResolvedConnectorConfig {
-    let mergedOptions: Record<string, unknown> = {}
-    let mergedAuth: AuthConfig | undefined
-    let mergedEnabled = true
-    let mergedPartialConfig: Partial<ConnectorConfig> = {}
-    const resolvedFrom: ScopeRef[] = []
-
-    for (const layer of layers) {
-      resolvedFrom.push(layer.scope)
-
-      if (layer.options) {
-        mergedOptions = { ...mergedOptions, ...layer.options }
-      }
-
-      if (layer.auth !== undefined) {
-        mergedAuth = layer.auth
-      }
-
-      if (layer.enabled !== undefined) {
-        mergedEnabled = layer.enabled
-      }
-
-      if (layer.config) {
-        mergedPartialConfig = { ...mergedPartialConfig, ...layer.config }
-      }
-    }
-
-    const config: ConnectorConfig = {
-      connectorId,
-      name: mergedPartialConfig.name ?? connectorId,
-      auth: mergedAuth ?? mergedPartialConfig.auth,
-      options: mergedOptions,
-    }
-
-    return {
-      connectorId,
-      config,
-      auth: mergedAuth,
-      enabled: mergedEnabled,
-      options: mergedOptions,
-      resolvedFrom,
-    }
-  }
+	private configs: Map<string, ScopedConnectorConfig> = new Map()
+	private log: Logger
+
+	constructor() {
+		this.log = getRootLogger().child({ component: 'ScopedConnectorRegistry' })
+	}
+
+	set(config: ScopedConnectorConfig): void {
+		const key = scopeKey(config.scope.scope, config.scope.scopeId, config.connectorId)
+		this.configs.set(key, config)
+		this.log.info(`Scoped config set: ${key}`)
+	}
+
+	remove(scope: ScopeRef, connectorId: string): boolean {
+		const key = scopeKey(scope.scope, scope.scopeId, connectorId)
+		const removed = this.configs.delete(key)
+		if (removed) {
+			this.log.info(`Scoped config removed: ${key}`)
+		}
+		return removed
+	}
+
+	getAt(scope: ScopeRef, connectorId: string): ScopedConnectorConfig | undefined {
+		return this.configs.get(scopeKey(scope.scope, scope.scopeId, connectorId))
+	}
+
+	resolve(connectorId: string, chain: ScopeChain): ResolvedConnectorConfig | undefined {
+		const layers: ScopedConnectorConfig[] = []
+
+		for (const scope of CONNECTOR_SCOPE_ORDER) {
+			const scopeId = chain[scope]
+			if (!scopeId) continue
+
+			const config = this.configs.get(scopeKey(scope, scopeId, connectorId))
+			if (config) {
+				layers.push(config)
+			}
+		}
+
+		if (layers.length === 0) return undefined
+
+		return this.mergeLayers(connectorId, layers)
+	}
+
+	listForConnector(connectorId: string): ScopedConnectorConfig[] {
+		const results: ScopedConnectorConfig[] = []
+		for (const config of this.configs.values()) {
+			if (config.connectorId === connectorId) {
+				results.push(config)
+			}
+		}
+		return results
+	}
+
+	listAtScope(scope: ScopeRef): ScopedConnectorConfig[] {
+		const prefix = `${scope.scope}:${scope.scopeId}:`
+		const results: ScopedConnectorConfig[] = []
+		for (const [key, config] of this.configs.entries()) {
+			if (key.startsWith(prefix)) {
+				results.push(config)
+			}
+		}
+		return results
+	}
+
+	private mergeLayers(
+		connectorId: string,
+		layers: ScopedConnectorConfig[],
+	): ResolvedConnectorConfig {
+		let mergedOptions: Record<string, unknown> = {}
+		let mergedAuth: AuthConfig | undefined
+		let mergedEnabled = true
+		let mergedPartialConfig: Partial<ConnectorConfig> = {}
+		const resolvedFrom: ScopeRef[] = []
+
+		for (const layer of layers) {
+			resolvedFrom.push(layer.scope)
+
+			if (layer.options) {
+				mergedOptions = { ...mergedOptions, ...layer.options }
+			}
+
+			if (layer.auth !== undefined) {
+				mergedAuth = layer.auth
+			}
+
+			if (layer.enabled !== undefined) {
+				mergedEnabled = layer.enabled
+			}
+
+			if (layer.config) {
+				mergedPartialConfig = { ...mergedPartialConfig, ...layer.config }
+			}
+		}
+
+		const config: ConnectorConfig = {
+			connectorId,
+			name: mergedPartialConfig.name ?? connectorId,
+			auth: mergedAuth ?? mergedPartialConfig.auth,
+			options: mergedOptions,
+		}
+
+		return {
+			connectorId,
+			config,
+			auth: mergedAuth,
+			enabled: mergedEnabled,
+			options: mergedOptions,
+			resolvedFrom,
+		}
+	}
 }