@namzu/sdk 0.1.1 → 0.1.2

package/src/skills/registry.ts

@@ -1,102 +1,108 @@
-import type { Skill, SkillChain, SkillDisclosureLevel, SkillLoadResult } from '../types/skills/index.js'
-import { discoverSkills, loadSkill } from './loader.js'
+import type {
+	Skill,
+	SkillChain,
+	SkillDisclosureLevel,
+	SkillLoadResult,
+} from '../types/skills/index.js'
 import { getRootLogger } from '../utils/logger.js'
+import { discoverSkills, loadSkill } from './loader.js'
 
 const logger = getRootLogger().child({ component: 'SkillRegistry' })
 
 export class SkillRegistry {
-  private skills = new Map<string, Skill>()
-
-  async register(dirPath: string, level: SkillDisclosureLevel = 'metadata'): Promise<Skill> {
-    const result = await loadSkill(dirPath, level)
-    this.skills.set(result.skill.metadata.name, result.skill)
-    return result.skill
-  }
-
-  async registerAll(parentDir: string, level: SkillDisclosureLevel = 'metadata'): Promise<Skill[]> {
-    const dirs = await discoverSkills(parentDir)
-    const results: Skill[] = []
-
-    for (const dir of dirs) {
-      const skill = await this.register(dir, level)
-      results.push(skill)
-    }
-
-    logger.debug('Registered skills from directory', {
-      parentDir,
-      count: results.length,
-      names: results.map((s) => s.metadata.name),
-    })
-
-    return results
-  }
-
-  get(name: string): Skill | undefined {
-    return this.skills.get(name)
-  }
-
-  async load(name: string, level: SkillDisclosureLevel = 'full'): Promise<SkillLoadResult | undefined> {
-    const existing = this.skills.get(name)
-    if (!existing) return undefined
-
-    if (level === 'metadata' || existing.body) {
-      return {
-        skill: existing,
-        disclosureLevel: existing.body ? 'full' : 'metadata',
-        tokenEstimate: 0,
-      }
-    }
-
-    const result = await loadSkill(existing.dirPath, level)
-    this.skills.set(name, result.skill)
-    return result
-  }
-
-  list(): Skill[] {
-    return [...this.skills.values()]
-  }
-
-  get size(): number {
-    return this.skills.size
-  }
-
-  has(name: string): boolean {
-    return this.skills.has(name)
-  }
+	private skills = new Map<string, Skill>()
+
+	async register(dirPath: string, level: SkillDisclosureLevel = 'metadata'): Promise<Skill> {
+		const result = await loadSkill(dirPath, level)
+		this.skills.set(result.skill.metadata.name, result.skill)
+		return result.skill
+	}
+
+	async registerAll(parentDir: string, level: SkillDisclosureLevel = 'metadata'): Promise<Skill[]> {
+		const dirs = await discoverSkills(parentDir)
+		const results: Skill[] = []
+
+		for (const dir of dirs) {
+			const skill = await this.register(dir, level)
+			results.push(skill)
+		}
+
+		logger.debug('Registered skills from directory', {
+			parentDir,
+			count: results.length,
+			names: results.map((s) => s.metadata.name),
+		})
+
+		return results
+	}
+
+	get(name: string): Skill | undefined {
+		return this.skills.get(name)
+	}
+
+	async load(
+		name: string,
+		level: SkillDisclosureLevel = 'full',
+	): Promise<SkillLoadResult | undefined> {
+		const existing = this.skills.get(name)
+		if (!existing) return undefined
+
+		if (level === 'metadata' || existing.body) {
+			return {
+				skill: existing,
+				disclosureLevel: existing.body ? 'full' : 'metadata',
+				tokenEstimate: 0,
+			}
+		}
+
+		const result = await loadSkill(existing.dirPath, level)
+		this.skills.set(name, result.skill)
+		return result
+	}
+
+	list(): Skill[] {
+		return [...this.skills.values()]
+	}
+
+	get size(): number {
+		return this.skills.size
+	}
+
+	has(name: string): boolean {
+		return this.skills.has(name)
+	}
 }
 
 export async function resolveSkillChain(
-  categorySkillsDir: string | undefined,
-  agentSkillsDir: string | undefined,
-  level: SkillDisclosureLevel = 'metadata',
+	categorySkillsDir: string | undefined,
+	agentSkillsDir: string | undefined,
+	level: SkillDisclosureLevel = 'metadata',
 ): Promise<SkillChain> {
-  const categoryRegistry = new SkillRegistry()
-  const agentRegistry = new SkillRegistry()
+	const categoryRegistry = new SkillRegistry()
+	const agentRegistry = new SkillRegistry()
 
-  const inherited = categorySkillsDir
-    ? await categoryRegistry.registerAll(categorySkillsDir, level)
-    : []
+	const inherited = categorySkillsDir
+		? await categoryRegistry.registerAll(categorySkillsDir, level)
+		: []
 
-  const own = agentSkillsDir
-    ? await agentRegistry.registerAll(agentSkillsDir, level)
-    : []
+	const own = agentSkillsDir ? await agentRegistry.registerAll(agentSkillsDir, level) : []
 
-  const resolvedMap = new Map<string, Skill>()
+	const resolvedMap = new Map<string, Skill>()
 
-  for (const skill of inherited) {
-    resolvedMap.set(skill.metadata.name, skill)
-  }
-  for (const skill of own) {
-    resolvedMap.set(skill.metadata.name, skill)
-  }
+	for (const skill of inherited) {
+		resolvedMap.set(skill.metadata.name, skill)
+	}
+	for (const skill of own) {
+		resolvedMap.set(skill.metadata.name, skill)
+	}
 
-  const resolved = [...resolvedMap.values()]
+	const resolved = [...resolvedMap.values()]
 
-  logger.debug('Resolved skill chain', {
-    inherited: inherited.map((s) => s.metadata.name),
-    own: own.map((s) => s.metadata.name),
-    resolved: resolved.map((s) => s.metadata.name),
-  })
+	logger.debug('Resolved skill chain', {
+		inherited: inherited.map((s) => s.metadata.name),
+		own: own.map((s) => s.metadata.name),
+		resolved: resolved.map((s) => s.metadata.name),
+	})
 
-  return { inherited, own, resolved }
+	return { inherited, own, resolved }
 }

package/src/store/InMemoryStore.ts

@@ -1,72 +1,69 @@
-import type { PaginationParams, PaginatedResponse } from '../contracts/index.js'
+import type { PaginatedResponse, PaginationParams } from '../contracts/index.js'
 
 export interface Identifiable {
-  id: string
+	id: string
 }
 
 export interface Timestamped {
-  created_at: string
+	created_at: string
 }
 
 export class InMemoryStore<T extends Identifiable & Timestamped> {
-  protected items: Map<string, T> = new Map()
+	protected items: Map<string, T> = new Map()
 
-  get(id: string): T | undefined {
-    return this.items.get(id)
-  }
+	get(id: string): T | undefined {
+		return this.items.get(id)
+	}
 
-  has(id: string): boolean {
-    return this.items.has(id)
-  }
+	has(id: string): boolean {
+		return this.items.has(id)
+	}
 
-  set(item: T): void {
-    this.items.set(item.id, item)
-  }
+	set(item: T): void {
+		this.items.set(item.id, item)
+	}
 
-  delete(id: string): boolean {
-    return this.items.delete(id)
-  }
+	delete(id: string): boolean {
+		return this.items.delete(id)
+	}
 
-  size(): number {
-    return this.items.size
-  }
+	size(): number {
+		return this.items.size
+	}
 
-  all(): T[] {
-    return Array.from(this.items.values())
-  }
+	all(): T[] {
+		return Array.from(this.items.values())
+	}
 
-  paginate(
-    items: T[],
-    params: PaginationParams = {},
-  ): PaginatedResponse<T> {
-    const { limit = 20, order = 'desc', after, before } = params
+	paginate(items: T[], params: PaginationParams = {}): PaginatedResponse<T> {
+		const { limit = 20, order = 'desc', after, before } = params
 
-    let sorted = [...items]
-    sorted.sort((a, b) => {
-      const cmp = a.created_at.localeCompare(b.created_at)
-      return order === 'desc' ? -cmp : cmp
-    })
+		let sorted = [...items]
+		sorted.sort((a, b) => {
+			const cmp = a.created_at.localeCompare(b.created_at)
+			return order === 'desc' ? -cmp : cmp
+		})
 
-    if (after) {
-      const idx = sorted.findIndex((item) => item.id === after)
-      if (idx !== -1) sorted = sorted.slice(idx + 1)
-    }
-    if (before) {
-      const idx = sorted.findIndex((item) => item.id === before)
-      if (idx !== -1) sorted = sorted.slice(0, idx)
-    }
+		if (after) {
+			const idx = sorted.findIndex((item) => item.id === after)
+			if (idx !== -1) sorted = sorted.slice(idx + 1)
+		}
+		if (before) {
+			const idx = sorted.findIndex((item) => item.id === before)
+			if (idx !== -1) sorted = sorted.slice(0, idx)
+		}
 
-    const sliced = sorted.slice(0, Math.min(limit, 100))
+		const sliced = sorted.slice(0, Math.min(limit, 100))
 
-    return {
-      data: sliced,
-      has_more: sorted.length > sliced.length,
-      first_id: sliced[0]?.id ?? null,
-      last_id: sliced[sliced.length - 1]?.id ?? null,
-    }
-  }
+		return {
+			data: sliced,
+			has_more: sorted.length > sliced.length,
+			first_id: sliced[0]?.id ?? null,
+			last_id: sliced[sliced.length - 1]?.id ?? null,
+		}
+	}
 
-  list(params: PaginationParams = {}): PaginatedResponse<T> {
-    return this.paginate(this.all(), params)
-  }
+	list(params: PaginationParams = {}): PaginatedResponse<T> {
+		return this.paginate(this.all(), params)
+	}
 }