goatchain 0.0.1

package/cli/sdk.mjs

@@ -0,0 +1,341 @@
+import path from 'node:path'
+
+export async function loadSdk() {
+  try {
+    return await import('../dist/index.js')
+  }
+  catch (err) {
+    const msg = err instanceof Error ? err.message : String(err)
+    throw new Error(
+      [
+        'Failed to load `./dist/index.js`.',
+        'If you are running from the repo, run `pnpm -s build` first.',
+        `cause: ${msg}`,
+      ].join('\n'),
+    )
+  }
+}
+
+function applyDefaultRequestOptions(model, defaults) {
+  const hasSetModelId = typeof model?.setModelId === 'function'
+
+  return {
+    get modelId() {
+      return model.modelId
+    },
+    ...(hasSetModelId
+      ? {
+          setModelId(id) {
+            model.setModelId(id)
+          },
+        }
+      : {}),
+    async invoke(messages, options) {
+      return model.invoke(messages, options)
+    },
+    stream: (messagesOrRequest, options) => {
+      if (Array.isArray(messagesOrRequest)) {
+        return model.stream(messagesOrRequest, options)
+      }
+      return model.stream({ ...defaults, ...messagesOrRequest })
+    },
+    ...(typeof model?.run === 'function'
+      ? {
+          run: (req) => model.run({ ...defaults, ...req }),
+        }
+      : {}),
+  }
+}
+
+function createTools(sdk, workspaceCwd) {
+  const {
+    ToolRegistry,
+    WriteTool,
+    ReadTool,
+    EditTool,
+    GlobTool,
+    GrepTool,
+    WebSearchTool,
+  } = sdk
+
+  if (![ToolRegistry, WriteTool, ReadTool, EditTool, GlobTool, GrepTool, WebSearchTool].every(v => typeof v === 'function')) {
+    throw new Error(
+      [
+        'Missing builtin tool exports from `./dist/index.js`.',
+        'Run `pnpm -s build` (repo) or reinstall the package to get an up-to-date build.',
+      ].join('\n'),
+    )
+  }
+
+  const cacheDir = path.join(workspaceCwd, '.goatchain')
+
+  const isSubpath = (parent, child) => {
+    const rel = path.relative(path.resolve(parent), path.resolve(child))
+    if (rel === '')
+      return true
+    if (rel === '..')
+      return false
+    return !rel.startsWith(`..${path.sep}`) && !path.isAbsolute(rel)
+  }
+
+  const ensureNotInCache = (absPath) => {
+    if (isSubpath(cacheDir, absPath)) {
+      throw new Error(`Access denied: ${absPath}\nRestricted: ${cacheDir}`)
+    }
+  }
+
+  const ensureAllowedFile = (filePath) => {
+    const abs = path.isAbsolute(filePath) ? filePath : path.resolve(workspaceCwd, filePath)
+    if (!isSubpath(workspaceCwd, abs)) {
+      throw new Error(`Access denied: ${abs}\nAllowed directory: ${workspaceCwd}`)
+    }
+    ensureNotInCache(abs)
+    return abs
+  }
+
+  const ensureAllowedDir = (dirPath) => {
+    const abs = path.isAbsolute(dirPath) ? dirPath : path.resolve(workspaceCwd, dirPath)
+    if (!isSubpath(workspaceCwd, abs)) {
+      throw new Error(`Access denied: ${abs}\nAllowed directory: ${workspaceCwd}`)
+    }
+    ensureNotInCache(abs)
+    return abs
+  }
+
+  const registry = new ToolRegistry()
+
+  const writeInner = new WriteTool({ cwd: workspaceCwd, allowedDirectory: workspaceCwd })
+  registry.register({
+    name: writeInner.name,
+    description: writeInner.description,
+    parameters: writeInner.parameters,
+    riskLevel: writeInner.riskLevel,
+    execute: (args) => {
+      if (args && typeof args === 'object' && 'file_path' in args) {
+        ensureAllowedFile(args.file_path)
+      }
+      return writeInner.execute(args)
+    },
+  })
+
+  const readInner = new ReadTool({ cwd: workspaceCwd, allowedDirectory: workspaceCwd })
+  registry.register({
+    name: readInner.name,
+    description: readInner.description,
+    parameters: readInner.parameters,
+    riskLevel: readInner.riskLevel,
+    execute: (args) => {
+      if (args && typeof args === 'object' && 'file_path' in args) {
+        ensureAllowedFile(args.file_path)
+      }
+      return readInner.execute(args)
+    },
+  })
+
+  const editInner = new EditTool({ cwd: workspaceCwd })
+  registry.register({
+    name: editInner.name,
+    description: editInner.description,
+    parameters: editInner.parameters,
+    riskLevel: editInner.riskLevel,
+    execute: (args) => {
+      if (args && typeof args === 'object' && 'file_path' in args) {
+        ensureAllowedFile(args.file_path)
+      }
+      return editInner.execute(args)
+    },
+  })
+
+  const globInner = new GlobTool({ cwd: workspaceCwd })
+  registry.register({
+    name: globInner.name,
+    description: globInner.description,
+    parameters: globInner.parameters,
+    riskLevel: globInner.riskLevel,
+    execute: (args) => {
+      if (args && typeof args === 'object' && 'path' in args && typeof args.path === 'string' && args.path.trim()) {
+        ensureAllowedDir(args.path)
+      }
+      return globInner.execute(args)
+    },
+  })
+
+  const grepInner = new GrepTool({ cwd: workspaceCwd })
+  registry.register({
+    name: grepInner.name,
+    description: grepInner.description,
+    parameters: grepInner.parameters,
+    riskLevel: grepInner.riskLevel,
+    execute: (args) => {
+      if (args && typeof args === 'object' && 'path' in args && typeof args.path === 'string' && args.path.trim()) {
+        ensureAllowedDir(args.path)
+      }
+      return grepInner.execute(args)
+    },
+  })
+
+  if(process.env.SERPER_API_KEY){
+    const webSearchInner = new WebSearchTool({
+      apiKey: process.env.SERPER_API_KEY,
+    })
+    registry.register({
+      name: webSearchInner.name,
+      description: webSearchInner.description,
+      parameters: webSearchInner.parameters,
+      riskLevel: webSearchInner.riskLevel,
+      execute: (args) => webSearchInner.execute(args),
+    })
+  }
+
+  return { registry, workspaceCwd }
+}
+
+async function createModelClient(sdk, { getApiKey, modelId, baseUrl, requestDefaults }) {
+  const { createModel, createOpenAIAdapter } = sdk
+
+  if (typeof createModel === 'function' && typeof createOpenAIAdapter === 'function') {
+    const secretProvider = {
+      get: (name) => {
+        if (name === 'OPENAI_API_KEY')
+          return getApiKey()
+        return process.env[name]
+      },
+    }
+
+    const baseModel = createModel({
+      adapters: [
+        createOpenAIAdapter({
+          defaultModelId: modelId,
+          baseUrl,
+          apiKeySecretName: 'OPENAI_API_KEY',
+          secretProvider,
+        }),
+      ],
+    })
+    return applyDefaultRequestOptions(baseModel, requestDefaults)
+  }
+
+  const { default: OpenAI } = await import('openai')
+  let cachedClient = null
+  let currentModelId = modelId
+  let currentBaseUrl = baseUrl
+
+  const getClient = () => {
+    if (cachedClient)
+      return cachedClient
+    const key = getApiKey() ?? process.env.OPENAI_API_KEY
+    if (!key)
+      throw new Error('Missing OPENAI_API_KEY (required for chatting)')
+    cachedClient = new OpenAI({ apiKey: key, baseURL: currentBaseUrl || undefined })
+    return cachedClient
+  }
+
+  return {
+    get modelId() {
+      return currentModelId
+    },
+    setModelId(id) {
+      currentModelId = id
+    },
+    setBaseUrl(url) {
+      currentBaseUrl = url
+      cachedClient = null
+    },
+    resetClient() {
+      cachedClient = null
+    },
+    async invoke(messages) {
+      const client = getClient()
+      const resp = await client.chat.completions.create({
+        model: currentModelId,
+        messages,
+        stream: false,
+        max_completion_tokens: requestDefaults.maxOutputTokens ?? undefined,
+        temperature: requestDefaults.temperature ?? undefined,
+        top_p: requestDefaults.topP ?? undefined,
+        presence_penalty: requestDefaults.presencePenalty ?? undefined,
+        frequency_penalty: requestDefaults.frequencyPenalty ?? undefined,
+        seed: requestDefaults.seed ?? undefined,
+      })
+      const choice = Array.isArray(resp?.choices) ? resp.choices[0] : undefined
+      const content = typeof choice?.message?.content === 'string' ? choice.message.content : ''
+      return { message: { role: 'assistant', content } }
+    },
+    stream: async function* (messagesOrRequest, options) {
+      const client = getClient()
+      const isLegacy = Array.isArray(messagesOrRequest)
+      const messages = isLegacy ? messagesOrRequest : (messagesOrRequest?.messages ?? [])
+      const tools = isLegacy ? options?.tools : messagesOrRequest?.tools
+      const signal = isLegacy ? undefined : messagesOrRequest?.signal
+      const model = isLegacy ? currentModelId : (messagesOrRequest?.model?.modelId ?? currentModelId)
+
+      const resp = await client.chat.completions.create(
+        {
+          model,
+          messages,
+          tools,
+          stream: true,
+          stream_options: { include_usage: true },
+          max_completion_tokens: requestDefaults.maxOutputTokens ?? undefined,
+          temperature: requestDefaults.temperature ?? undefined,
+          top_p: requestDefaults.topP ?? undefined,
+          presence_penalty: requestDefaults.presencePenalty ?? undefined,
+          frequency_penalty: requestDefaults.frequencyPenalty ?? undefined,
+          seed: requestDefaults.seed ?? undefined,
+        },
+        {
+          signal,
+          timeout: typeof requestDefaults.timeoutMs === 'number' ? requestDefaults.timeoutMs : undefined,
+        },
+      )
+
+      for await (const chunk of resp) {
+        const delta = chunk?.choices?.[0]?.delta?.content
+        if (typeof delta === 'string' && delta.length > 0) {
+          yield { type: 'text_delta', delta }
+        }
+        const usage = chunk?.usage
+        if (usage && typeof usage === 'object') {
+          yield {
+            type: 'usage',
+            usage: {
+              promptTokens: usage.prompt_tokens ?? 0,
+              completionTokens: usage.completion_tokens ?? 0,
+              totalTokens: usage.total_tokens ?? 0,
+            },
+          }
+        }
+      }
+
+      yield { type: 'done' }
+    },
+  }
+}
+
+export async function createAgent({ getApiKey, modelId, system, baseUrl, requestDefaults }) {
+  const sdk = await loadSdk()
+  const { Agent } = sdk
+
+  const workspaceCwd = process.cwd()
+  const tools = createTools(sdk, workspaceCwd)
+  const model = await createModelClient(sdk, { getApiKey, modelId, baseUrl, requestDefaults })
+
+  const defaultSystemPrompt = [
+    'You are a helpful assistant.',
+    'If you need to inspect the local project (files, folders, code), you MUST use the provided tools (Read/Glob/Grep) and must not claim you did unless a tool was actually called.',
+    'When your plan depends on inspecting the project, call the tool(s) immediately instead of stopping after saying you will.',
+    'After using tools, continue and produce a user-visible result in the SAME run (don’t stop right after inspection).',
+    'For coding or file-creation tasks, you MUST implement by creating/editing files in the workspace using Write/Edit, then briefly summarize what you changed and where.',
+    'Write/Edit may require user approval in the CLI; still call them when needed (the CLI will prompt the user).',
+    'Do NOT end your response right after saying “I will create/implement …” — either ask a necessary clarifying question or start writing files with tools.',
+  ].join('\n')
+
+  const agent = new Agent({
+    name: 'GoatChain CLI',
+    systemPrompt: system ?? defaultSystemPrompt,
+    model,
+    tools: tools.registry,
+  })
+
+  return { agent, model, tools }
+}

package/cli/sessionTransfer.mjs

@@ -0,0 +1,118 @@
+import { randomUUID } from 'node:crypto'
+
+function normalizeMessageContent(content) {
+  if (typeof content === 'string')
+    return content
+  try {
+    return JSON.stringify(content ?? '')
+  }
+  catch {
+    return String(content ?? '')
+  }
+}
+
+export function selectSessionsById(allSessions, ids) {
+  const set = new Set(Array.isArray(ids) ? ids.map(String) : [])
+  return (Array.isArray(allSessions) ? allSessions : []).filter(s => s && set.has(String(s.sessionId)))
+}
+
+export function buildSessionsExportBundle(sessions) {
+  const list = Array.isArray(sessions) ? sessions : []
+  return {
+    schemaVersion: 1,
+    exportedAt: Date.now(),
+    sessions: list.map(s => ({
+      sessionId: s.sessionId,
+      createdAt: s.createdAt,
+      updatedAt: s.updatedAt,
+      modelId: s.modelId,
+      systemPrompt: s.systemPrompt,
+      title: s.title,
+      summary: s.summary,
+      pinned: Boolean(s.pinned),
+      messages: Array.isArray(s.messages) ? s.messages : [],
+    })),
+  }
+}
+
+export function sessionsToMarkdown(sessions, opts = {}) {
+  const exportedAt = typeof opts.exportedAt === 'string' ? opts.exportedAt : new Date().toISOString()
+  const list = Array.isArray(sessions) ? sessions : []
+  const lines = []
+  lines.push('# Sessions export')
+  lines.push('')
+  lines.push(`exportedAt: ${exportedAt}`)
+  lines.push('')
+  for (const s of list) {
+    lines.push('---')
+    lines.push(`## ${s?.title ?? 'New session'}`)
+    lines.push(`- id: ${s?.sessionId ?? ''}`)
+    if (s?.modelId)
+      lines.push(`- model: ${String(s.modelId)}`)
+    lines.push(`- pinned: ${Boolean(s?.pinned)}`)
+    if (s?.summary)
+      lines.push(`- summary: ${String(s.summary).replace(/\n/g, ' ')}`)
+    lines.push('')
+    lines.push('### Messages')
+    const msgs = Array.isArray(s?.messages) ? s.messages : []
+    for (const m of msgs) {
+      const role = m?.role ? String(m.role) : 'message'
+      const content = normalizeMessageContent(m?.content).replace(/\n/g, '\\n')
+      lines.push(`- ${role}: ${content}`)
+    }
+    lines.push('')
+  }
+  return `${lines.join('\n')}\n`
+}
+
+export function parseSessionsImportJson(parsed) {
+  if (Array.isArray(parsed))
+    return parsed
+  if (parsed && typeof parsed === 'object') {
+    if (Array.isArray(parsed.sessions))
+      return parsed.sessions
+    if (typeof parsed.sessionId === 'string')
+      return [parsed]
+  }
+  return []
+}
+
+export async function planSessionImports(rawSessions, opts) {
+  const conflict = String(opts?.conflict ?? 'new_ids')
+  const exists = typeof opts?.exists === 'function' ? opts.exists : async () => false
+  const makeId = typeof opts?.makeId === 'function' ? opts.makeId : () => randomUUID()
+
+  const out = []
+  const list = Array.isArray(rawSessions) ? rawSessions : []
+  for (const s of list) {
+    if (!s || typeof s !== 'object')
+      continue
+    const baseId = typeof s.sessionId === 'string' && s.sessionId.trim() ? s.sessionId.trim() : makeId()
+    let id = baseId
+    // eslint-disable-next-line no-await-in-loop
+    const has = await exists(id)
+    if (has) {
+      if (conflict === 'skip')
+        continue
+      if (conflict === 'new_ids')
+        id = makeId()
+    }
+
+    out.push({
+      sessionId: id,
+      session: {
+        sessionId: id,
+        createdAt: typeof s.createdAt === 'number' ? s.createdAt : Date.now(),
+        modelId: typeof s.modelId === 'string' ? s.modelId : undefined,
+        systemPrompt: typeof s.systemPrompt === 'string' ? s.systemPrompt : undefined,
+        title: typeof s.title === 'string' ? s.title : undefined,
+        summary: typeof s.summary === 'string' ? s.summary : undefined,
+        pinned: Boolean(s.pinned),
+        messages: Array.isArray(s.messages) ? s.messages : [],
+      },
+    })
+  }
+
+  return out
+}
+