@codeany/open-agent-sdk 0.2.2 → 0.2.4

package/src/sdk-mcp-server.ts

@@ -1,78 +0,0 @@
-/**
- * In-Process MCP Server
- *
- * createSdkMcpServer() creates an in-process MCP server from tool() definitions.
- * Compatible with open-agent-sdk's createSdkMcpServer().
- *
- * Usage:
- *   import { tool, createSdkMcpServer } from 'open-agent-sdk'
- *   import { z } from 'zod'
- *
- *   const weatherTool = tool('get_weather', 'Get weather', { city: z.string() },
- *     async ({ city }) => ({ content: [{ type: 'text', text: `22°C in ${city}` }] })
- *   )
- *
- *   const server = createSdkMcpServer({
- *     name: 'weather',
- *     tools: [weatherTool],
- *   })
- *
- *   // Use as MCP server config:
- *   const agent = createAgent({
- *     mcpServers: { weather: server },
- *   })
- */
-
-import type { SdkMcpToolDefinition } from './tool-helper.js'
-import { sdkToolToToolDefinition } from './tool-helper.js'
-import type { ToolDefinition, McpServerConfig } from './types.js'
-
-/**
- * SDK MCP server config that includes the in-process server instance.
- */
-export interface McpSdkServerConfig {
-  type: 'sdk'
-  name: string
-  version: string
-  tools: ToolDefinition[]
-  _sdkTools: SdkMcpToolDefinition<any>[]
-}
-
-/**
- * Create an in-process MCP server from tool definitions.
- *
- * The server runs in the same process as the agent, avoiding
- * subprocess overhead. Tools are directly callable.
- */
-export function createSdkMcpServer(options: {
-  name: string
-  version?: string
-  tools?: SdkMcpToolDefinition<any>[]
-}): McpSdkServerConfig {
-  const sdkTools = options.tools || []
-
-  // Convert SDK tools to engine-compatible tool definitions
-  // Prefix tool names with mcp__{server_name}__ for namespace isolation
-  const toolDefinitions: ToolDefinition[] = sdkTools.map((sdkTool) => {
-    const toolDef = sdkToolToToolDefinition(sdkTool)
-    return {
-      ...toolDef,
-      name: `mcp__${options.name}__${sdkTool.name}`,
-    }
-  })
-
-  return {
-    type: 'sdk',
-    name: options.name,
-    version: options.version || '1.0.0',
-    tools: toolDefinitions,
-    _sdkTools: sdkTools,
-  }
-}
-
-/**
- * Check if a server config is an in-process SDK server.
- */
-export function isSdkServerConfig(config: any): config is McpSdkServerConfig {
-  return config?.type === 'sdk' && Array.isArray(config.tools)
-}

package/src/session.ts

@@ -1,227 +0,0 @@
-/**
- * Session Storage & Management
- *
- * Persists conversation transcripts to disk for resumption.
- * Manages session lifecycle (create, resume, list, fork).
- */
-
-import { readFile, writeFile, mkdir, readdir, stat } from 'fs/promises'
-import { join } from 'path'
-import type { Message } from './types.js'
-import type { NormalizedMessageParam } from './providers/types.js'
-
-/**
- * Session metadata.
- */
-export interface SessionMetadata {
-  id: string
-  cwd: string
-  model: string
-  createdAt: string
-  updatedAt: string
-  messageCount: number
-  summary?: string
-}
-
-/**
- * Session data on disk.
- */
-export interface SessionData {
-  metadata: SessionMetadata
-  messages: NormalizedMessageParam[]
-}
-
-/**
- * Get the sessions directory path.
- */
-function getSessionsDir(): string {
-  const home = process.env.HOME || process.env.USERPROFILE || '/tmp'
-  return join(home, '.open-agent-sdk', 'sessions')
-}
-
-/**
- * Get the path for a specific session.
- */
-function getSessionPath(sessionId: string): string {
-  return join(getSessionsDir(), sessionId)
-}
-
-/**
- * Save session to disk.
- */
-export async function saveSession(
-  sessionId: string,
-  messages: NormalizedMessageParam[],
-  metadata: Partial<SessionMetadata>,
-): Promise<void> {
-  const dir = getSessionPath(sessionId)
-  await mkdir(dir, { recursive: true })
-
-  const data: SessionData = {
-    metadata: {
-      id: sessionId,
-      cwd: metadata.cwd || process.cwd(),
-      model: metadata.model || 'claude-sonnet-4-6',
-      createdAt: metadata.createdAt || new Date().toISOString(),
-      updatedAt: new Date().toISOString(),
-      messageCount: messages.length,
-      summary: metadata.summary,
-    },
-    messages,
-  }
-
-  await writeFile(
-    join(dir, 'transcript.json'),
-    JSON.stringify(data, null, 2),
-    'utf-8',
-  )
-}
-
-/**
- * Load session from disk.
- */
-export async function loadSession(sessionId: string): Promise<SessionData | null> {
-  try {
-    const filePath = join(getSessionPath(sessionId), 'transcript.json')
-    const content = await readFile(filePath, 'utf-8')
-    return JSON.parse(content) as SessionData
-  } catch {
-    return null
-  }
-}
-
-/**
- * List all sessions.
- */
-export async function listSessions(): Promise<SessionMetadata[]> {
-  try {
-    const dir = getSessionsDir()
-    const entries = await readdir(dir)
-    const sessions: SessionMetadata[] = []
-
-    for (const entry of entries) {
-      try {
-        const data = await loadSession(entry)
-        if (data?.metadata) {
-          sessions.push(data.metadata)
-        }
-      } catch {
-        // Skip invalid sessions
-      }
-    }
-
-    // Sort by updatedAt descending
-    sessions.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))
-
-    return sessions
-  } catch {
-    return []
-  }
-}
-
-/**
- * Fork a session (create a copy with a new ID).
- */
-export async function forkSession(
-  sourceSessionId: string,
-  newSessionId?: string,
-): Promise<string | null> {
-  const data = await loadSession(sourceSessionId)
-  if (!data) return null
-
-  const forkId = newSessionId || crypto.randomUUID()
-
-  await saveSession(forkId, data.messages, {
-    ...data.metadata,
-    id: forkId,
-    createdAt: new Date().toISOString(),
-    summary: `Forked from session ${sourceSessionId}`,
-  })
-
-  return forkId
-}
-
-/**
- * Get session messages.
- */
-export async function getSessionMessages(
-  sessionId: string,
-): Promise<NormalizedMessageParam[]> {
-  const data = await loadSession(sessionId)
-  return data?.messages || []
-}
-
-/**
- * Append a message to a session transcript.
- */
-export async function appendToSession(
-  sessionId: string,
-  message: NormalizedMessageParam,
-): Promise<void> {
-  const data = await loadSession(sessionId)
-  if (!data) return
-
-  data.messages.push(message)
-  data.metadata.updatedAt = new Date().toISOString()
-  data.metadata.messageCount = data.messages.length
-
-  await saveSession(sessionId, data.messages, data.metadata)
-}
-
-/**
- * Delete a session.
- */
-export async function deleteSession(sessionId: string): Promise<boolean> {
-  try {
-    const { rm } = await import('fs/promises')
-    await rm(getSessionPath(sessionId), { recursive: true, force: true })
-    return true
-  } catch {
-    return false
-  }
-}
-
-/**
- * Get info about a specific session.
- */
-export async function getSessionInfo(
-  sessionId: string,
-  options?: { dir?: string },
-): Promise<SessionMetadata | null> {
-  const data = await loadSession(sessionId)
-  return data?.metadata || null
-}
-
-/**
- * Rename a session.
- */
-export async function renameSession(
-  sessionId: string,
-  title: string,
-  options?: { dir?: string },
-): Promise<void> {
-  const data = await loadSession(sessionId)
-  if (!data) return
-
-  data.metadata.summary = title
-  data.metadata.updatedAt = new Date().toISOString()
-
-  await saveSession(sessionId, data.messages, data.metadata)
-}
-
-/**
- * Tag a session.
- */
-export async function tagSession(
-  sessionId: string,
-  tag: string | null,
-  options?: { dir?: string },
-): Promise<void> {
-  const data = await loadSession(sessionId)
-  if (!data) return
-
-  ;(data.metadata as any).tag = tag
-  data.metadata.updatedAt = new Date().toISOString()
-
-  await saveSession(sessionId, data.messages, data.metadata)
-}

package/src/skills/bundled/commit.ts

@@ -1,38 +0,0 @@
-/**
- * Bundled Skill: commit
- *
- * Create a git commit with a well-crafted message based on staged changes.
- */
-
-import { registerSkill } from '../registry.js'
-import type { SkillContentBlock } from '../types.js'
-
-const COMMIT_PROMPT = `Create a git commit for the current changes. Follow these steps:
-
-1. Run \`git status\` and \`git diff --cached\` to understand what's staged
-2. If nothing is staged, run \`git diff\` to see unstaged changes and suggest what to stage
-3. Analyze the changes and draft a concise commit message that:
-   - Uses imperative mood ("Add feature" not "Added feature")
-   - Summarizes the "why" not just the "what"
-   - Keeps the first line under 72 characters
-   - Adds a body with details if the change is complex
-4. Create the commit
-
-Do NOT push to remote unless explicitly asked.`
-
-export function registerCommitSkill(): void {
-  registerSkill({
-    name: 'commit',
-    description: 'Create a git commit with a well-crafted message based on staged changes.',
-    aliases: ['ci'],
-    allowedTools: ['Bash', 'Read', 'Glob', 'Grep'],
-    userInvocable: true,
-    async getPrompt(args): Promise<SkillContentBlock[]> {
-      let prompt = COMMIT_PROMPT
-      if (args.trim()) {
-        prompt += `\n\nAdditional instructions: ${args}`
-      }
-      return [{ type: 'text', text: prompt }]
-    },
-  })
-}

package/src/skills/bundled/index.ts

@@ -1,28 +0,0 @@
-/**
- * Bundled Skills Initialization
- *
- * Registers all built-in skills at SDK startup.
- */
-
-import { registerSimplifySkill } from './simplify.js'
-import { registerCommitSkill } from './commit.js'
-import { registerReviewSkill } from './review.js'
-import { registerDebugSkill } from './debug.js'
-import { registerTestSkill } from './test.js'
-
-let initialized = false
-
-/**
- * Initialize all bundled skills.
- * Safe to call multiple times (idempotent).
- */
-export function initBundledSkills(): void {
-  if (initialized) return
-  initialized = true
-
-  registerSimplifySkill()
-  registerCommitSkill()
-  registerReviewSkill()
-  registerDebugSkill()
-  registerTestSkill()
-}

package/src/skills/index.ts

@@ -1,25 +0,0 @@
-/**
- * Skills Module - Public API
- */
-
-// Types
-export type {
-  SkillDefinition,
-  SkillContentBlock,
-  SkillResult,
-} from './types.js'
-
-// Registry
-export {
-  registerSkill,
-  getSkill,
-  getAllSkills,
-  getUserInvocableSkills,
-  hasSkill,
-  unregisterSkill,
-  clearSkills,
-  formatSkillsForPrompt,
-} from './registry.js'
-
-// Bundled skills
-export { initBundledSkills } from './bundled/index.js'

package/src/skills/registry.ts

@@ -1,133 +0,0 @@
-/**
- * Skill Registry
- *
- * Central registry for managing skill definitions.
- * Skills can be registered programmatically or loaded from bundled definitions.
- */
-
-import type { SkillDefinition } from './types.js'
-
-/** Internal skill store */
-const skills: Map<string, SkillDefinition> = new Map()
-
-/** Alias -> skill name mapping */
-const aliases: Map<string, string> = new Map()
-
-/**
- * Register a skill definition.
- */
-export function registerSkill(definition: SkillDefinition): void {
-  skills.set(definition.name, definition)
-
-  // Register aliases
-  if (definition.aliases) {
-    for (const alias of definition.aliases) {
-      aliases.set(alias, definition.name)
-    }
-  }
-}
-
-/**
- * Get a skill by name or alias.
- */
-export function getSkill(name: string): SkillDefinition | undefined {
-  // Direct lookup
-  const direct = skills.get(name)
-  if (direct) return direct
-
-  // Alias lookup
-  const resolved = aliases.get(name)
-  if (resolved) return skills.get(resolved)
-
-  return undefined
-}
-
-/**
- * Get all registered skills.
- */
-export function getAllSkills(): SkillDefinition[] {
-  return Array.from(skills.values())
-}
-
-/**
- * Get all user-invocable skills (for /command listing).
- */
-export function getUserInvocableSkills(): SkillDefinition[] {
-  return getAllSkills().filter(
-    (s) => s.userInvocable !== false && (!s.isEnabled || s.isEnabled()),
-  )
-}
-
-/**
- * Check if a skill exists.
- */
-export function hasSkill(name: string): boolean {
-  return skills.has(name) || aliases.has(name)
-}
-
-/**
- * Remove a skill.
- */
-export function unregisterSkill(name: string): boolean {
-  const skill = skills.get(name)
-  if (!skill) return false
-
-  // Remove aliases
-  if (skill.aliases) {
-    for (const alias of skill.aliases) {
-      aliases.delete(alias)
-    }
-  }
-
-  return skills.delete(name)
-}
-
-/**
- * Clear all skills (for testing).
- */
-export function clearSkills(): void {
-  skills.clear()
-  aliases.clear()
-}
-
-/**
- * Format skills listing for system prompt injection.
- *
- * Uses a budget system: skills listing gets a limited character budget
- * to avoid bloating the context window.
- */
-export function formatSkillsForPrompt(
-  contextWindowTokens?: number,
-): string {
-  const invocable = getUserInvocableSkills()
-  if (invocable.length === 0) return ''
-
-  // Budget: 1% of context window in characters (4 chars per token)
-  const CHARS_PER_TOKEN = 4
-  const DEFAULT_BUDGET = 8000
-  const MAX_DESC_CHARS = 250
-  const budget = contextWindowTokens
-    ? Math.floor(contextWindowTokens * 0.01 * CHARS_PER_TOKEN)
-    : DEFAULT_BUDGET
-
-  const lines: string[] = []
-  let used = 0
-
-  for (const skill of invocable) {
-    const desc = skill.description.length > MAX_DESC_CHARS
-      ? skill.description.slice(0, MAX_DESC_CHARS) + '...'
-      : skill.description
-
-    const trigger = skill.whenToUse
-      ? ` TRIGGER when: ${skill.whenToUse}`
-      : ''
-
-    const line = `- ${skill.name}: ${desc}${trigger}`
-
-    if (used + line.length > budget) break
-    lines.push(line)
-    used += line.length
-  }
-
-  return lines.join('\n')
-}

package/src/skills/types.ts

@@ -1,99 +0,0 @@
-/**
- * Skill System Types
- *
- * Skills are reusable prompt templates that extend agent capabilities.
- * They can be invoked by the model via the Skill tool or by users via /skillname.
- */
-
-import type { ToolContext } from '../types.js'
-import type { HookConfig } from '../hooks.js'
-
-/**
- * Content block for skill prompts (compatible with Anthropic API).
- */
-export type SkillContentBlock =
-  | { type: 'text'; text: string }
-  | { type: 'image'; source: { type: 'base64'; media_type: string; data: string } }
-
-/**
- * Bundled skill definition.
- *
- * Inspired by Claude Code's skill system. Skills provide specialized
- * capabilities by injecting context-specific prompts with optional
- * tool restrictions and model overrides.
- */
-export interface SkillDefinition {
-  /** Unique skill name (e.g., 'simplify', 'commit') */
-  name: string
-
-  /** Human-readable description */
-  description: string
-
-  /** Alternative names for the skill */
-  aliases?: string[]
-
-  /** When the model should invoke this skill (used in system prompt) */
-  whenToUse?: string
-
-  /** Hint for expected arguments */
-  argumentHint?: string
-
-  /** Tools the skill is allowed to use (empty = all tools) */
-  allowedTools?: string[]
-
-  /** Model override for this skill */
-  model?: string
-
-  /** Whether the skill can be invoked by users via /command */
-  userInvocable?: boolean
-
-  /** Runtime check for availability */
-  isEnabled?: () => boolean
-
-  /** Hook overrides while skill is active */
-  hooks?: HookConfig
-
-  /** Execution context: 'inline' runs in current context, 'fork' spawns a subagent */
-  context?: 'inline' | 'fork'
-
-  /** Subagent type for forked execution */
-  agent?: string
-
-  /**
-   * Generate the prompt content blocks for this skill.
-   *
-   * @param args - User-provided arguments (e.g., from "/simplify focus on error handling")
-   * @param context - Tool execution context (cwd, etc.)
-   * @returns Content blocks to inject into the conversation
-   */
-  getPrompt: (
-    args: string,
-    context: ToolContext,
-  ) => Promise<SkillContentBlock[]>
-}
-
-/**
- * Result of executing a skill.
- */
-export interface SkillResult {
-  /** Whether execution succeeded */
-  success: boolean
-
-  /** Skill name that was executed */
-  skillName: string
-
-  /** Execution status */
-  status: 'inline' | 'forked'
-
-  /** Allowed tools override (for inline execution) */
-  allowedTools?: string[]
-
-  /** Model override */
-  model?: string
-
-  /** Result text (for forked execution) */
-  result?: string
-
-  /** Error message */
-  error?: string
-}