@namzu/sdk 0.1.1 → 0.1.2

package/src/runtime/query/prompt.ts

@@ -1,26 +1,25 @@
-import type { AgentPersona } from '../../types/persona/index.js'
-import type { Skill } from '../../types/skills/index.js'
+import { FILESYSTEM_TOOLS } from '../../constants/tools/index.js'
+import { assembleSystemPrompt } from '../../persona/assembler.js'
 import type { ToolRegistry } from '../../registry/tool/execute.js'
 import type { AgentContextLevel } from '../../types/agent/factory.js'
-import { assembleSystemPrompt } from '../../persona/assembler.js'
-
-const FILESYSTEM_TOOLS = new Set(['glob', 'read_file', 'write_file', 'bash'])
+import type { AgentPersona } from '../../types/persona/index.js'
+import type { Skill } from '../../types/skills/index.js'
 
 export interface PromptBuilderConfig {
-  systemPrompt?: string
+	systemPrompt?: string
 
-  persona?: AgentPersona
+	persona?: AgentPersona
 
-  skills?: Skill[]
+	skills?: Skill[]
 
-  basePrompt?: string
+	basePrompt?: string
 
-  tools: ToolRegistry
-  allowedTools?: string[]
+	tools: ToolRegistry
+	allowedTools?: string[]
 }
 
 function buildEnvContext(workingDirectory: string): string {
-  return `<env>
+	return `<env>
 Working directory: ${workingDirectory}
 Platform: ${process.platform}
 </env>
@@ -29,45 +28,45 @@ IMPORTANT: Always use absolute paths based on the working directory above. Befor
 }
 
 function hasFilesystemTools(tools: ToolRegistry, allowedTools?: string[]): boolean {
-  const activeTools = allowedTools ?? tools.listNames()
-  return activeTools.some(name => FILESYSTEM_TOOLS.has(name))
+	const activeTools = allowedTools ?? tools.listNames()
+	return activeTools.some((name) => FILESYSTEM_TOOLS.has(name))
 }
 
 export class PromptBuilder {
-  private config: PromptBuilderConfig
-
-  constructor(config: PromptBuilderConfig) {
-    this.config = config
-  }
-
-  build(contextLevel: AgentContextLevel = 'full', workingDirectory?: string): string {
-    const parts: string[] = []
-
-    if (contextLevel === 'full' && this.config.basePrompt) {
-      parts.push(this.config.basePrompt)
-    }
-
-    if (this.config.systemPrompt) {
-      parts.push(this.config.systemPrompt)
-    } else if (this.config.persona) {
-      parts.push(assembleSystemPrompt(this.config.persona, this.config.skills))
-    }
-
-    if (contextLevel !== 'minimal') {
-      const toolSection = this.config.tools.toPromptSection(this.config.allowedTools)
-      if (toolSection) {
-        parts.push(toolSection)
-      }
-    }
-
-    if (
-      contextLevel !== 'minimal' &&
-      workingDirectory &&
-      hasFilesystemTools(this.config.tools, this.config.allowedTools)
-    ) {
-      parts.push(buildEnvContext(workingDirectory))
-    }
-
-    return parts.join('\n\n---\n\n')
-  }
+	private config: PromptBuilderConfig
+
+	constructor(config: PromptBuilderConfig) {
+		this.config = config
+	}
+
+	build(contextLevel: AgentContextLevel = 'full', workingDirectory?: string): string {
+		const parts: string[] = []
+
+		if (contextLevel === 'full' && this.config.basePrompt) {
+			parts.push(this.config.basePrompt)
+		}
+
+		if (this.config.systemPrompt) {
+			parts.push(this.config.systemPrompt)
+		} else if (this.config.persona) {
+			parts.push(assembleSystemPrompt(this.config.persona, this.config.skills))
+		}
+
+		if (contextLevel !== 'minimal') {
+			const toolSection = this.config.tools.toPromptSection(this.config.allowedTools)
+			if (toolSection) {
+				parts.push(toolSection)
+			}
+		}
+
+		if (
+			contextLevel !== 'minimal' &&
+			workingDirectory &&
+			hasFilesystemTools(this.config.tools, this.config.allowedTools)
+		) {
+			parts.push(buildEnvContext(workingDirectory))
+		}
+
+		return parts.join('\n\n---\n\n')
+	}
 }

package/src/runtime/query/result.ts

@@ -1,95 +1,95 @@
-import type { AgentRun, RunEvent } from '../../types/run/index.js'
-import type { RunPersistence } from '../../manager/run/persistence.js'
+import { SpanStatusCode } from '@opentelemetry/api'
+import type { Span } from '@opentelemetry/api'
 import type { PlanManager } from '../../manager/plan/lifecycle.js'
+import type { RunPersistence } from '../../manager/run/persistence.js'
 import type { ActivityStore } from '../../store/activity/memory.js'
+import { GENAI, NAMZU } from '../../telemetry/attributes.js'
+import type { AgentRun, RunEvent } from '../../types/run/index.js'
+import { toErrorMessage } from '../../utils/error.js'
 import type { Logger } from '../../utils/logger.js'
 import type { EmitEvent } from './events.js'
-import { SpanStatusCode } from '@opentelemetry/api'
-import { toErrorMessage } from '../../utils/error.js'
-import { GENAI, NAMZU } from '../../telemetry/attributes.js'
-import type { Span } from '@opentelemetry/api'
 
 export interface ResultAssemblerConfig {
-  sessionMgr: RunPersistence
-  planManager: PlanManager
-  activityStore: ActivityStore
-  log: Logger
-  emitEvent: EmitEvent
-  drainPending: () => Generator<RunEvent>
+	sessionMgr: RunPersistence
+	planManager: PlanManager
+	activityStore: ActivityStore
+	log: Logger
+	emitEvent: EmitEvent
+	drainPending: () => Generator<RunEvent>
 }
 
 export class ResultAssembler {
-  private config: ResultAssemblerConfig
+	private config: ResultAssemblerConfig
 
-  constructor(config: ResultAssemblerConfig) {
-    this.config = config
-  }
+	constructor(config: ResultAssemblerConfig) {
+		this.config = config
+	}
 
-  async *completeRun(rootSpan: Span): AsyncGenerator<RunEvent> {
-    const { sessionMgr, activityStore, log, emitEvent, drainPending } = this.config
+	async *completeRun(rootSpan: Span): AsyncGenerator<RunEvent> {
+		const { sessionMgr, activityStore, log, emitEvent, drainPending } = this.config
 
-    if (sessionMgr.status === 'running') {
-      sessionMgr.markCompleted(sessionMgr.stopReason)
-    }
+		if (sessionMgr.status === 'running') {
+			sessionMgr.markCompleted(sessionMgr.stopReason)
+		}
 
-    await emitEvent({
-      type: 'run_completed',
-      runId: sessionMgr.id,
-      result: sessionMgr.getRun().result ?? '',
-    })
-    yield* drainPending()
+		await emitEvent({
+			type: 'run_completed',
+			runId: sessionMgr.id,
+			result: sessionMgr.getRun().result ?? '',
+		})
+		yield* drainPending()
 
-    rootSpan.setAttributes({
-      [NAMZU.SESSION_STATUS]: sessionMgr.stopReason ?? 'completed',
-      [NAMZU.ITERATION]: sessionMgr.currentIteration,
-      [GENAI.USAGE_INPUT_TOKENS]: sessionMgr.tokenUsage.promptTokens,
-      [GENAI.USAGE_OUTPUT_TOKENS]: sessionMgr.tokenUsage.completionTokens,
-    })
-    rootSpan.setStatus({ code: SpanStatusCode.OK })
+		rootSpan.setAttributes({
+			[NAMZU.SESSION_STATUS]: sessionMgr.stopReason ?? 'completed',
+			[NAMZU.ITERATION]: sessionMgr.currentIteration,
+			[GENAI.USAGE_INPUT_TOKENS]: sessionMgr.tokenUsage.promptTokens,
+			[GENAI.USAGE_OUTPUT_TOKENS]: sessionMgr.tokenUsage.completionTokens,
+		})
+		rootSpan.setStatus({ code: SpanStatusCode.OK })
 
-    log.info('Query completed', {
-      runId: sessionMgr.id,
-      iterations: sessionMgr.currentIteration,
-      stopReason: sessionMgr.stopReason,
-      activityStats: activityStore.enabled ? activityStore.stats() : undefined,
-    })
-  }
+		log.info('Query completed', {
+			runId: sessionMgr.id,
+			iterations: sessionMgr.currentIteration,
+			stopReason: sessionMgr.stopReason,
+			activityStats: activityStore.enabled ? activityStore.stats() : undefined,
+		})
+	}
 
-  async *completeSession(rootSpan: Span): AsyncGenerator<RunEvent> {
-    yield* this.completeRun(rootSpan)
-  }
+	async *completeSession(rootSpan: Span): AsyncGenerator<RunEvent> {
+		yield* this.completeRun(rootSpan)
+	}
 
-  async *handleError(err: unknown, rootSpan: Span): AsyncGenerator<RunEvent> {
-    const { sessionMgr, planManager, log, emitEvent, drainPending } = this.config
-    const errorMessage = toErrorMessage(err)
-    sessionMgr.markFailed(errorMessage)
+	async *handleError(err: unknown, rootSpan: Span): AsyncGenerator<RunEvent> {
+		const { sessionMgr, planManager, log, emitEvent, drainPending } = this.config
+		const errorMessage = toErrorMessage(err)
+		sessionMgr.markFailed(errorMessage)
 
-    if (planManager.isActive) {
-      planManager.failPlan(errorMessage)
-    }
+		if (planManager.isActive) {
+			planManager.failPlan(errorMessage)
+		}
 
-    await emitEvent({
-      type: 'run_failed',
-      runId: sessionMgr.id,
-      error: errorMessage,
-    })
-    yield* drainPending()
+		await emitEvent({
+			type: 'run_failed',
+			runId: sessionMgr.id,
+			error: errorMessage,
+		})
+		yield* drainPending()
 
-    rootSpan.setAttributes({
-      [NAMZU.SESSION_STATUS]: 'error',
-      [NAMZU.ITERATION]: sessionMgr.currentIteration,
-    })
-    rootSpan.setStatus({ code: SpanStatusCode.ERROR, message: errorMessage })
-    rootSpan.recordException(err instanceof Error ? err : new Error(errorMessage))
+		rootSpan.setAttributes({
+			[NAMZU.SESSION_STATUS]: 'error',
+			[NAMZU.ITERATION]: sessionMgr.currentIteration,
+		})
+		rootSpan.setStatus({ code: SpanStatusCode.ERROR, message: errorMessage })
+		rootSpan.recordException(err instanceof Error ? err : new Error(errorMessage))
 
-    log.error('Query failed', {
-      runId: sessionMgr.id,
-      error: errorMessage,
-    })
-  }
+		log.error('Query failed', {
+			runId: sessionMgr.id,
+			error: errorMessage,
+		})
+	}
 
-  async finalize(): Promise<AgentRun> {
-    await this.config.sessionMgr.persist()
-    return this.config.sessionMgr.getRun()
-  }
+	async finalize(): Promise<AgentRun> {
+		await this.config.sessionMgr.persist()
+		return this.config.sessionMgr.getRun()
+	}
 }

package/src/runtime/query/tooling.ts

@@ -1,41 +1,41 @@
-import type { PermissionMode } from '../../types/permission/index.js'
-import type { RunEvent } from '../../types/run/index.js'
-import type { RunId } from '../../types/ids/index.js'
 import type { ToolRegistry } from '../../registry/tool/execute.js'
 import type { ActivityStore } from '../../store/activity/memory.js'
+import type { RunId } from '../../types/ids/index.js'
+import type { PermissionMode } from '../../types/permission/index.js'
+import type { RunEvent } from '../../types/run/index.js'
 import type { Logger } from '../../utils/logger.js'
 import { ToolExecutor } from './executor.js'
 
 export type EmitEvent = (event: RunEvent) => Promise<void>
 
 export interface ToolingBootstrapConfig {
-  tools: ToolRegistry
-  runId: RunId
-  workingDirectory: string
-  permissionMode: PermissionMode
-  env: Record<string, string>
-  abortSignal: AbortSignal
+	tools: ToolRegistry
+	runId: RunId
+	workingDirectory: string
+	permissionMode: PermissionMode
+	env: Record<string, string>
+	abortSignal: AbortSignal
 }
 
 export class ToolingBootstrap {
-  static init(
-    config: ToolingBootstrapConfig,
-    activityStore: ActivityStore,
-    emitEvent: EmitEvent,
-    log: Logger,
-  ): ToolExecutor {
-    return new ToolExecutor(
-      {
-        tools: config.tools,
-        runId: config.runId,
-        workingDirectory: config.workingDirectory,
-        permissionMode: config.permissionMode,
-        env: config.env,
-        abortSignal: config.abortSignal,
-      },
-      activityStore,
-      emitEvent,
-      log,
-    )
-  }
+	static init(
+		config: ToolingBootstrapConfig,
+		activityStore: ActivityStore,
+		emitEvent: EmitEvent,
+		log: Logger,
+	): ToolExecutor {
+		return new ToolExecutor(
+			{
+				tools: config.tools,
+				runId: config.runId,
+				workingDirectory: config.workingDirectory,
+				permissionMode: config.permissionMode,
+				env: config.env,
+				abortSignal: config.abortSignal,
+			},
+			activityStore,
+			emitEvent,
+			log,
+		)
+	}
 }

package/src/skills/loader.ts

@@ -1,6 +1,11 @@
 import { readFile, readdir, stat } from 'node:fs/promises'
-import { join, basename } from 'node:path'
-import type { Skill, SkillMetadata, SkillDisclosureLevel, SkillLoadResult } from '../types/skills/index.js'
+import { basename, join } from 'node:path'
+import type {
+	Skill,
+	SkillDisclosureLevel,
+	SkillLoadResult,
+	SkillMetadata,
+} from '../types/skills/index.js'
 import { getRootLogger } from '../utils/logger.js'
 
 const logger = getRootLogger().child({ component: 'SkillLoader' })
@@ -9,156 +14,155 @@ const SKILL_FILENAME = 'SKILL.md'
 const FRONTMATTER_DELIMITER = '---'
 
 interface ParsedSkillMd {
-  metadata: SkillMetadata
-  body: string
+	metadata: SkillMetadata
+	body: string
 }
 
 function parseSkillMd(raw: string, dirPath: string): ParsedSkillMd {
-  const trimmed = raw.trimStart()
+	const trimmed = raw.trimStart()
 
-  if (!trimmed.startsWith(FRONTMATTER_DELIMITER)) {
-    throw new Error(`SKILL.md at "${dirPath}" has no YAML frontmatter`)
-  }
+	if (!trimmed.startsWith(FRONTMATTER_DELIMITER)) {
+		throw new Error(`SKILL.md at "${dirPath}" has no YAML frontmatter`)
+	}
 
-  const endIdx = trimmed.indexOf(FRONTMATTER_DELIMITER, FRONTMATTER_DELIMITER.length)
-  if (endIdx === -1) {
-    throw new Error(`SKILL.md at "${dirPath}" has unclosed frontmatter`)
-  }
+	const endIdx = trimmed.indexOf(FRONTMATTER_DELIMITER, FRONTMATTER_DELIMITER.length)
+	if (endIdx === -1) {
+		throw new Error(`SKILL.md at "${dirPath}" has unclosed frontmatter`)
+	}
 
-  const frontmatterRaw = trimmed.slice(FRONTMATTER_DELIMITER.length, endIdx).trim()
-  const body = trimmed.slice(endIdx + FRONTMATTER_DELIMITER.length).trim()
+	const frontmatterRaw = trimmed.slice(FRONTMATTER_DELIMITER.length, endIdx).trim()
+	const body = trimmed.slice(endIdx + FRONTMATTER_DELIMITER.length).trim()
 
-  const metadata = parseFlatYaml(frontmatterRaw, dirPath)
+	const metadata = parseFlatYaml(frontmatterRaw, dirPath)
 
-  return { metadata, body }
+	return { metadata, body }
 }
 
 function parseFlatYaml(raw: string, dirPath: string): SkillMetadata {
-  const lines = raw.split('\n')
-  const kv: Record<string, string> = {}
-
-  for (const line of lines) {
-    const colonIdx = line.indexOf(':')
-    if (colonIdx === -1) continue
-    const key = line.slice(0, colonIdx).trim()
-    const value = line.slice(colonIdx + 1).trim()
-
-    kv[key] = value.replace(/^["']|["']$/g, '')
-  }
-
-  if (!kv['name']) {
-    throw new Error(`SKILL.md at "${dirPath}" missing required field: name`)
-  }
-  if (!kv['description']) {
-    throw new Error(`SKILL.md at "${dirPath}" missing required field: description`)
-  }
-
-  validateSkillName(kv['name'], dirPath)
-  validateDescription(kv['description'], dirPath)
-
-  const metadata: SkillMetadata = {
-    name: kv['name'],
-    description: kv['description'],
-  }
-
-  if (kv['compatibility']) {
-    if (kv['compatibility'].length > 500) {
-      throw new Error(`SKILL.md at "${dirPath}": compatibility exceeds 500 characters`)
-    }
-    metadata.compatibility = kv['compatibility']
-  }
-
-  return metadata
+	const lines = raw.split('\n')
+	const kv: Record<string, string> = {}
+
+	for (const line of lines) {
+		const colonIdx = line.indexOf(':')
+		if (colonIdx === -1) continue
+		const key = line.slice(0, colonIdx).trim()
+		const value = line.slice(colonIdx + 1).trim()
+
+		kv[key] = value.replace(/^["']|["']$/g, '')
+	}
+
+	if (!kv.name) {
+		throw new Error(`SKILL.md at "${dirPath}" missing required field: name`)
+	}
+	if (!kv.description) {
+		throw new Error(`SKILL.md at "${dirPath}" missing required field: description`)
+	}
+
+	validateSkillName(kv.name, dirPath)
+	validateDescription(kv.description, dirPath)
+
+	const metadata: SkillMetadata = {
+		name: kv.name,
+		description: kv.description,
+	}
+
+	if (kv.compatibility) {
+		if (kv.compatibility.length > 500) {
+			throw new Error(`SKILL.md at "${dirPath}": compatibility exceeds 500 characters`)
+		}
+		metadata.compatibility = kv.compatibility
+	}
+
+	return metadata
 }
 
 const SKILL_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/
 
 function validateSkillName(name: string, dirPath: string): void {
-  if (name.length > 64) {
-    throw new Error(`SKILL.md at "${dirPath}": name exceeds 64 characters`)
-  }
-  if (!SKILL_NAME_PATTERN.test(name)) {
-    throw new Error(
-      `SKILL.md at "${dirPath}": name "${name}" must be lowercase alphanumeric with hyphens, ` +
-      `no leading/trailing hyphens, no consecutive hyphens`,
-    )
-  }
-  const expectedName = basename(dirPath)
-  if (name !== expectedName) {
-    throw new Error(
-      `SKILL.md at "${dirPath}": name "${name}" must match directory name "${expectedName}"`,
-    )
-  }
+	if (name.length > 64) {
+		throw new Error(`SKILL.md at "${dirPath}": name exceeds 64 characters`)
+	}
+	if (!SKILL_NAME_PATTERN.test(name)) {
+		throw new Error(
+			`SKILL.md at "${dirPath}": name "${name}" must be lowercase alphanumeric with hyphens, no leading/trailing hyphens, no consecutive hyphens`,
+		)
+	}
+	const expectedName = basename(dirPath)
+	if (name !== expectedName) {
+		throw new Error(
+			`SKILL.md at "${dirPath}": name "${name}" must match directory name "${expectedName}"`,
+		)
+	}
 }
 
 function validateDescription(description: string, dirPath: string): void {
-  if (description.length === 0) {
-    throw new Error(`SKILL.md at "${dirPath}": description must not be empty`)
-  }
-  if (description.length > 1024) {
-    throw new Error(`SKILL.md at "${dirPath}": description exceeds 1024 characters`)
-  }
+	if (description.length === 0) {
+		throw new Error(`SKILL.md at "${dirPath}": description must not be empty`)
+	}
+	if (description.length > 1024) {
+		throw new Error(`SKILL.md at "${dirPath}": description exceeds 1024 characters`)
+	}
 }
 
 const CHARS_PER_TOKEN = 4
 
 function estimateTokens(text: string): number {
-  return Math.ceil(text.length / CHARS_PER_TOKEN)
+	return Math.ceil(text.length / CHARS_PER_TOKEN)
 }
 
 export async function loadSkill(
-  dirPath: string,
-  level: SkillDisclosureLevel = 'metadata',
+	dirPath: string,
+	level: SkillDisclosureLevel = 'metadata',
 ): Promise<SkillLoadResult> {
-  const skillMdPath = join(dirPath, SKILL_FILENAME)
-  const raw = await readFile(skillMdPath, 'utf-8')
-  const parsed = parseSkillMd(raw, dirPath)
-
-  const skill: Skill = {
-    metadata: parsed.metadata,
-    dirPath,
-  }
-
-  if (level === 'full' || level === 'assets') {
-    skill.body = parsed.body
-  }
-
-  const metadataTokens = estimateTokens(`${parsed.metadata.name}: ${parsed.metadata.description}`)
-  const bodyTokens = skill.body ? estimateTokens(skill.body) : 0
-
-  logger.debug('Loaded skill', {
-    name: parsed.metadata.name,
-    level,
-    tokens: metadataTokens + bodyTokens,
-  })
-
-  return {
-    skill,
-    disclosureLevel: level,
-    tokenEstimate: metadataTokens + bodyTokens,
-  }
+	const skillMdPath = join(dirPath, SKILL_FILENAME)
+	const raw = await readFile(skillMdPath, 'utf-8')
+	const parsed = parseSkillMd(raw, dirPath)
+
+	const skill: Skill = {
+		metadata: parsed.metadata,
+		dirPath,
+	}
+
+	if (level === 'full' || level === 'assets') {
+		skill.body = parsed.body
+	}
+
+	const metadataTokens = estimateTokens(`${parsed.metadata.name}: ${parsed.metadata.description}`)
+	const bodyTokens = skill.body ? estimateTokens(skill.body) : 0
+
+	logger.debug('Loaded skill', {
+		name: parsed.metadata.name,
+		level,
+		tokens: metadataTokens + bodyTokens,
+	})
+
+	return {
+		skill,
+		disclosureLevel: level,
+		tokenEstimate: metadataTokens + bodyTokens,
+	}
 }
 
 export async function discoverSkills(parentDir: string): Promise<string[]> {
-  const dirs: string[] = []
-
-  try {
-    const entries = await readdir(parentDir)
-    for (const entry of entries) {
-      if (entry.startsWith('.') || entry.startsWith('_')) continue
-      const fullPath = join(parentDir, entry)
-      const s = await stat(fullPath)
-      if (!s.isDirectory()) continue
-
-      const skillMdPath = join(fullPath, SKILL_FILENAME)
-      try {
-        await stat(skillMdPath)
-        dirs.push(fullPath)
-      } catch {}
-    }
-  } catch {
-    logger.debug('Skills directory not found', { parentDir })
-  }
-
-  return dirs
+	const dirs: string[] = []
+
+	try {
+		const entries = await readdir(parentDir)
+		for (const entry of entries) {
+			if (entry.startsWith('.') || entry.startsWith('_')) continue
+			const fullPath = join(parentDir, entry)
+			const s = await stat(fullPath)
+			if (!s.isDirectory()) continue
+
+			const skillMdPath = join(fullPath, SKILL_FILENAME)
+			try {
+				await stat(skillMdPath)
+				dirs.push(fullPath)
+			} catch {}
+		}
+	} catch {
+		logger.debug('Skills directory not found', { parentDir })
+	}
+
+	return dirs
 }