goatchain 0.0.1

package/cli/index.mjs

@@ -0,0 +1,299 @@
+import { randomUUID } from 'node:crypto'
+import { stat } from 'node:fs/promises'
+import path from 'node:path'
+import { parseCliArgs } from './args.mjs'
+import { createAgent } from './sdk.mjs'
+import { getCachePaths, ensureDir, loadLocalConfig, loadSession, saveLocalConfig, saveSession, listSessions, renameSession, setPinnedSessions, deleteSession, deleteSessions } from './persist.mjs'
+
+async function readPkgVersion() {
+  try {
+    const pkgUrl = new URL('../package.json', import.meta.url)
+    const { readFile } = await import('node:fs/promises')
+    const pkg = JSON.parse(await readFile(pkgUrl, 'utf8'))
+    return typeof pkg?.version === 'string' ? pkg.version : '0.0.0'
+  }
+  catch {
+    return '0.0.0'
+  }
+}
+
+async function runOneShot({ agent, prompt }) {
+  const history = []
+  const sessionId = randomUUID()
+  for await (const event of agent.stream({
+    sessionId,
+    input: prompt,
+    messages: history,
+    toolContext: {
+      approval: {
+        strategy: 'high_risk',
+        autoApprove: process.env.GOATCHAIN_AUTO_APPROVE === '1',
+      },
+    },
+  })) {
+    if (event.type === 'text_delta')
+      process.stdout.write(event.delta)
+    else if (event.type === 'requires_action') {
+      process.stderr.write(`\n[requires action] ${event.kind ?? ''} (${event.toolName ?? 'unknown tool'})\n`)
+      break
+    }
+    else if (event.type === 'done')
+      break
+  }
+  process.stdout.write('\n')
+}
+
+export async function main(argv) {
+  const version = await readPkgVersion()
+
+  const args = parseCliArgs(argv, version)
+
+  let workspaceCwd = process.cwd()
+  let paths = getCachePaths(workspaceCwd)
+  await ensureDir(paths.sessionsDir)
+
+  let localConfig = await loadLocalConfig(paths)
+
+  let currentApiKey = args.apiKey
+  const modelId = args.modelId ?? process.env.GOATCHAIN_MODEL ?? localConfig?.defaults?.modelId ?? 'gpt-4o'
+  const system = args.system
+  let baseUrl = args.baseUrl ?? process.env.GOATCHAIN_OPENAI_BASE_URL ?? localConfig?.openai?.baseUrl
+
+  const requestDefaults = /** @type {Record<string, any>} */ ({})
+  const applyRequestDefaults = (cfg, cliArgs) => {
+    const next = {
+      ...(cfg?.defaults?.requestDefaults ?? {}),
+      temperature: cliArgs?.temperature ?? (cfg?.defaults?.requestDefaults?.temperature),
+      maxOutputTokens: cliArgs?.maxTokens ?? (cfg?.defaults?.requestDefaults?.maxOutputTokens),
+      topP: cliArgs?.topP ?? (cfg?.defaults?.requestDefaults?.topP),
+      presencePenalty: cliArgs?.presencePenalty ?? (cfg?.defaults?.requestDefaults?.presencePenalty),
+      frequencyPenalty: cliArgs?.frequencyPenalty ?? (cfg?.defaults?.requestDefaults?.frequencyPenalty),
+      seed: cliArgs?.seed ?? (cfg?.defaults?.requestDefaults?.seed),
+      timeoutMs: cliArgs?.timeoutMs ?? (cfg?.defaults?.requestDefaults?.timeoutMs),
+    }
+    for (const k of Object.keys(requestDefaults))
+      delete requestDefaults[k]
+    Object.assign(requestDefaults, next)
+  }
+  applyRequestDefaults(localConfig, args)
+
+  const provider = 'openai'
+  const getApiKey = () => currentApiKey ?? process.env.OPENAI_API_KEY ?? localConfig?.openai?.apiKey
+
+  const uiPrefs = /** @type {Record<string, any>} */ ({})
+  const applyUiPrefs = (cfg) => {
+    const envEmoji = process.env.GOATCHAIN_EMOJI
+    const defaultEmoji = envEmoji === '1'
+      ? true
+      : envEmoji === '0'
+        ? false
+        : (process.stdout.isTTY && process.env.TERM !== 'dumb')
+    const next = {
+      toolStyle: cfg?.ui?.toolStyle ?? (process.env.GOATCHAIN_TOOL_STYLE ?? 'inline'),
+      showTools: typeof cfg?.ui?.showTools === 'boolean' ? cfg.ui.showTools : (process.env.GOATCHAIN_SHOW_TOOLS !== '0'),
+      showStatus: typeof cfg?.ui?.showStatus === 'boolean' ? cfg.ui.showStatus : (process.env.GOATCHAIN_SHOW_STATUS !== '0'),
+      showStatusLine: typeof cfg?.ui?.showStatusLine === 'boolean' ? cfg.ui.showStatusLine : (process.env.GOATCHAIN_SHOW_STATUSLINE !== '0'),
+      promptContinue: typeof cfg?.ui?.promptContinue === 'boolean' ? cfg.ui.promptContinue : (process.env.GOATCHAIN_PROMPT_CONTINUE !== '0'),
+      autoContinue: typeof cfg?.ui?.autoContinue === 'boolean' ? cfg.ui.autoContinue : (process.env.GOATCHAIN_AUTO_CONTINUE === '1'),
+      sessionsUi: cfg?.ui?.sessionsUi ?? (process.env.GOATCHAIN_SESSIONS_UI ?? 'auto'),
+      emoji: typeof cfg?.ui?.emoji === 'boolean' ? cfg.ui.emoji : defaultEmoji,
+    }
+    for (const k of Object.keys(uiPrefs))
+      delete uiPrefs[k]
+    Object.assign(uiPrefs, next)
+  }
+  applyUiPrefs(localConfig)
+
+  if (args.prompt) {
+    const { agent } = await createAgent({ getApiKey, modelId, system, baseUrl, requestDefaults })
+    await runOneShot({ agent, prompt: args.prompt })
+    return
+  }
+
+  let sessionId = args.sessionId ?? localConfig?.lastSessionId ?? randomUUID()
+  let history = []
+  let sessionCreatedAt = Date.now()
+  let sessionTitle
+  let sessionSummary
+  let sessionPinned = false
+
+  const loaded = await loadSession(paths, sessionId)
+  if (loaded) {
+    sessionCreatedAt = loaded.createdAt ?? sessionCreatedAt
+    sessionTitle = loaded.title
+    sessionSummary = loaded.summary
+    sessionPinned = Boolean(loaded.pinned)
+    history = Array.isArray(loaded.messages) ? loaded.messages : []
+  }
+
+  let { agent, model, tools } = await createAgent({ getApiKey, modelId, system, baseUrl, requestDefaults })
+  if (loaded?.modelId && typeof model?.setModelId === 'function')
+    model.setModelId(loaded.modelId)
+
+  const persistConfig = async (extra = {}) => {
+    localConfig = await saveLocalConfig(paths, {
+      ...localConfig,
+      ...extra,
+      openai: {
+        ...(localConfig?.openai ?? {}),
+        baseUrl,
+        apiKey: getApiKey(),
+      },
+      defaults: {
+        ...(localConfig?.defaults ?? {}),
+        modelId: model.modelId,
+        requestDefaults,
+      },
+      ui: uiPrefs,
+    })
+  }
+
+  const saveAll = async () => {
+    const saved = await saveSession(paths, {
+      sessionId,
+      createdAt: sessionCreatedAt,
+      modelId: model.modelId,
+      systemPrompt: system,
+      title: sessionTitle,
+      summary: sessionSummary,
+      pinned: sessionPinned,
+      messages: history,
+    })
+    sessionTitle = saved?.title ?? sessionTitle
+    sessionSummary = saved?.summary ?? sessionSummary
+    sessionPinned = Boolean(saved?.pinned)
+    await persistConfig({ lastSessionId: sessionId })
+  }
+
+  let saveQueue = Promise.resolve()
+  const saveAllQueued = () => {
+    const run = () => saveAll()
+    saveQueue = saveQueue.then(run, run)
+    return saveQueue
+  }
+  await saveAllQueued()
+
+  const { runRepl } = await import('./repl.mjs')
+  const agentRef = { get: () => agent }
+  const modelRef = { get: () => model }
+  const baseUrlRef = { get: () => baseUrl }
+
+  const switchWorkspace = async (nextCwdRaw) => {
+    const candidate = path.resolve(process.cwd(), String(nextCwdRaw ?? ''))
+    const st = await stat(candidate)
+    if (!st.isDirectory())
+      throw new Error(`Not a directory: ${candidate}`)
+
+    process.chdir(candidate)
+    workspaceCwd = process.cwd()
+    paths = getCachePaths(workspaceCwd)
+    await ensureDir(paths.sessionsDir)
+    localConfig = await loadLocalConfig(paths)
+    applyUiPrefs(localConfig)
+    applyRequestDefaults(localConfig, null)
+
+    baseUrl = process.env.GOATCHAIN_OPENAI_BASE_URL ?? localConfig?.openai?.baseUrl ?? baseUrl
+
+    sessionId = localConfig?.lastSessionId ?? randomUUID()
+    history = []
+    sessionCreatedAt = Date.now()
+    sessionTitle = undefined
+    sessionSummary = undefined
+    sessionPinned = false
+
+    const loadedNext = await loadSession(paths, sessionId)
+    if (loadedNext) {
+      sessionCreatedAt = loadedNext.createdAt ?? sessionCreatedAt
+      sessionTitle = loadedNext.title
+      sessionSummary = loadedNext.summary
+      sessionPinned = Boolean(loadedNext.pinned)
+      history = Array.isArray(loadedNext.messages) ? loadedNext.messages : []
+    }
+
+    const nextModelId = localConfig?.defaults?.modelId ?? model.modelId ?? 'gpt-4o'
+    ;({ agent, model, tools } = await createAgent({ getApiKey, modelId: nextModelId, system, baseUrl, requestDefaults }))
+    if (loadedNext?.modelId && typeof model?.setModelId === 'function')
+      model.setModelId(loadedNext.modelId)
+
+    await saveAllQueued()
+  }
+
+  const setApiKey = (key) => {
+    currentApiKey = key
+  }
+
+  const setBaseUrl = async (url) => {
+    baseUrl = url
+    if (typeof model?.setBaseUrl === 'function') {
+      model.setBaseUrl(baseUrl)
+      await saveAllQueued()
+      return
+    }
+    ;({ agent, model, tools } = await createAgent({ getApiKey, modelId: model.modelId, system, baseUrl, requestDefaults }))
+    await saveAllQueued()
+  }
+
+  const session = {
+    get sessionId() {
+      return sessionId
+    },
+    set sessionId(v) {
+      sessionId = v
+    },
+    get createdAt() {
+      return sessionCreatedAt
+    },
+    set createdAt(v) {
+      sessionCreatedAt = v
+    },
+    get history() {
+      return history
+    },
+    set history(v) {
+      history = v
+    },
+    get title() {
+      return sessionTitle
+    },
+    set title(v) {
+      sessionTitle = v
+    },
+    get summary() {
+      return sessionSummary
+    },
+    set summary(v) {
+      sessionSummary = v
+    },
+    get pinned() {
+      return sessionPinned
+    },
+    set pinned(v) {
+      sessionPinned = Boolean(v)
+    },
+  }
+
+  await runRepl({
+    version,
+    provider,
+    system,
+    agentRef,
+    modelRef,
+    toolsInfo: tools,
+    requestDefaults,
+    baseUrlRef,
+    setBaseUrl,
+    setApiKey,
+    saveAll: saveAllQueued,
+    listSessions: () => listSessions(paths),
+    loadSessionById: (id) => loadSession(paths, id),
+    saveSessionByData: (session) => saveSession(paths, session),
+    renameSessionById: (id, title) => renameSession(paths, id, title),
+    setPinnedSessionsById: (ids, pinned) => setPinnedSessions(paths, ids, pinned),
+    deleteSessionById: (id) => deleteSession(paths, id),
+    deleteSessionsById: (ids) => deleteSessions(paths, ids),
+    uiPrefs,
+    switchWorkspace,
+    getWorkspaceCwd: () => process.cwd(),
+    session,
+  })
+}

package/cli/itermPaste.mjs

@@ -0,0 +1,147 @@
+import path from 'node:path'
+
+const START = '\u001B]1337;File='
+
+function findTerminator(s, from) {
+  const bell = s.indexOf('\u0007', from)
+  const st = s.indexOf('\u001B\\', from)
+  if (bell === -1 && st === -1)
+    return { idx: -1, len: 0 }
+  if (bell === -1)
+    return { idx: st, len: 2 }
+  if (st === -1)
+    return { idx: bell, len: 1 }
+  return bell < st ? { idx: bell, len: 1 } : { idx: st, len: 2 }
+}
+
+function decodeBase64Utf8(b64) {
+  try {
+    return Buffer.from(String(b64 ?? ''), 'base64').toString('utf8')
+  }
+  catch {
+    return ''
+  }
+}
+
+function sniffMimeFromBase64(b64) {
+  try {
+    const head = Buffer.from(String(b64 ?? '').slice(0, 96), 'base64')
+    if (head.length >= 8) {
+      // PNG
+      if (head[0] === 0x89 && head[1] === 0x50 && head[2] === 0x4E && head[3] === 0x47 && head[4] === 0x0D && head[5] === 0x0A && head[6] === 0x1A && head[7] === 0x0A)
+        return { mime: 'image/png', ext: '.png' }
+      // JPEG
+      if (head[0] === 0xFF && head[1] === 0xD8 && head[2] === 0xFF)
+        return { mime: 'image/jpeg', ext: '.jpg' }
+      // GIF
+      if (head[0] === 0x47 && head[1] === 0x49 && head[2] === 0x46 && head[3] === 0x38)
+        return { mime: 'image/gif', ext: '.gif' }
+      // WEBP: RIFF....WEBP
+      if (head.length >= 12) {
+        const riff = head.subarray(0, 4).toString('ascii')
+        const webp = head.subarray(8, 12).toString('ascii')
+        if (riff === 'RIFF' && webp === 'WEBP')
+          return { mime: 'image/webp', ext: '.webp' }
+      }
+    }
+  }
+  catch {
+    // ignore
+  }
+  return { mime: 'application/octet-stream', ext: '' }
+}
+
+function mimeFromFilename(filename, fallbackB64) {
+  const lower = String(filename ?? '').toLowerCase()
+  if (lower.endsWith('.png'))
+    return { mime: 'image/png', ext: '.png' }
+  if (lower.endsWith('.jpg') || lower.endsWith('.jpeg'))
+    return { mime: 'image/jpeg', ext: '.jpg' }
+  if (lower.endsWith('.webp'))
+    return { mime: 'image/webp', ext: '.webp' }
+  if (lower.endsWith('.gif'))
+    return { mime: 'image/gif', ext: '.gif' }
+  return sniffMimeFromBase64(fallbackB64)
+}
+
+function parseOneIterm2FileSequence(seq) {
+  // seq includes START and terminator
+  const startIdx = seq.indexOf(START)
+  if (startIdx < 0)
+    return null
+  const withoutTerm = seq.endsWith('\u0007')
+    ? seq.slice(0, -1)
+    : seq.endsWith('\u001B\\')
+      ? seq.slice(0, -2)
+      : seq
+
+  const body = withoutTerm.slice(startIdx + START.length)
+  const colon = body.indexOf(':')
+  if (colon < 0)
+    return null
+
+  const header = body.slice(0, colon)
+  const dataRaw = body.slice(colon + 1)
+  const data = dataRaw.replace(/\s+/g, '')
+  if (!data)
+    return null
+
+  const meta = {}
+  for (const part of header.split(';')) {
+    const [k, ...rest] = part.split('=')
+    if (!k)
+      continue
+    meta[k] = rest.join('=')
+  }
+
+  const decodedName = meta.name ? decodeBase64Utf8(meta.name) : ''
+  const baseName = decodedName ? path.basename(decodedName) : ''
+  const size = meta.size ? Number(meta.size) : undefined
+  const { mime, ext } = mimeFromFilename(baseName, data)
+
+  const name = baseName || `pasted-image${ext || ''}`
+  const bytes = Number.isFinite(size) ? size : (() => {
+    try {
+      return Buffer.from(data, 'base64').byteLength
+    }
+    catch {
+      return 0
+    }
+  })()
+
+  const dataUrl = `data:${mime};base64,${data}`
+  return { name, mime, bytes, dataUrl }
+}
+
+export function extractIterm2FilePastes(input, buffer = '') {
+  const combined = `${String(buffer ?? '')}${String(input ?? '')}`
+  if (!combined.includes(START)) {
+    return { text: String(input ?? ''), files: [], buffer: '' }
+  }
+
+  let out = ''
+  /** @type {Array<{ name: string, mime: string, bytes: number, dataUrl: string }>} */
+  const files = []
+
+  let i = 0
+  while (true) {
+    const start = combined.indexOf(START, i)
+    if (start === -1) {
+      out += combined.slice(i)
+      break
+    }
+    out += combined.slice(i, start)
+    const term = findTerminator(combined, start)
+    if (term.idx === -1) {
+      return { text: out, files, buffer: combined.slice(start) }
+    }
+    const seq = combined.slice(start, term.idx + term.len)
+    const parsed = parseOneIterm2FileSequence(seq)
+    if (parsed)
+      files.push(parsed)
+    i = term.idx + term.len
+  }
+
+  return { text: out, files, buffer: '' }
+}
+

package/cli/persist.mjs

@@ -0,0 +1,205 @@
+import path from 'node:path'
+import { randomUUID } from 'node:crypto'
+import { mkdir, readdir, readFile, rename, unlink, writeFile } from 'node:fs/promises'
+import { deriveSessionSummary, deriveSessionTitle } from './ui.mjs'
+
+export function getCachePaths(workspaceCwd) {
+  const cacheDir = path.join(workspaceCwd, '.goatchain')
+  const sessionsDir = path.join(cacheDir, 'sessions')
+  return {
+    workspaceCwd,
+    cacheDir,
+    sessionsDir,
+    configPath: path.join(cacheDir, 'config.json'),
+  }
+}
+
+export async function ensureDir(dirPath) {
+  await mkdir(dirPath, { recursive: true })
+}
+
+export async function readJsonFile(filePath) {
+  try {
+    const raw = await readFile(filePath, 'utf8')
+    return JSON.parse(raw)
+  }
+  catch (err) {
+    if (err && typeof err === 'object' && err.code === 'ENOENT')
+      return undefined
+    throw err
+  }
+}
+
+export async function writeJsonFileAtomic(filePath, data) {
+  const dir = path.dirname(filePath)
+  await ensureDir(dir)
+  const tmpPath = `${filePath}.tmp.${randomUUID()}`
+  const content = `${JSON.stringify(data, null, 2)}\n`
+  await writeFile(tmpPath, content, { mode: 0o600 })
+  await rename(tmpPath, filePath)
+}
+
+export async function loadLocalConfig(paths) {
+  const cfg = await readJsonFile(paths.configPath)
+  if (!cfg || typeof cfg !== 'object')
+    return { schemaVersion: 1 }
+  return cfg
+}
+
+export async function saveLocalConfig(paths, cfg) {
+  const next = {
+    schemaVersion: 1,
+    ...cfg,
+    updatedAt: Date.now(),
+  }
+  await writeJsonFileAtomic(paths.configPath, next)
+  return next
+}
+
+function sessionPath(paths, sessionId) {
+  return path.join(paths.sessionsDir, `${sessionId}.json`)
+}
+
+export async function loadSession(paths, sessionId) {
+  const p = sessionPath(paths, sessionId)
+  const data = await readJsonFile(p)
+  if (!data || typeof data !== 'object')
+    return undefined
+  const messages = Array.isArray(data.messages) ? data.messages : []
+  return {
+    sessionId: typeof data.sessionId === 'string' ? data.sessionId : sessionId,
+    createdAt: typeof data.createdAt === 'number' ? data.createdAt : Date.now(),
+    updatedAt: typeof data.updatedAt === 'number' ? data.updatedAt : Date.now(),
+    modelId: typeof data.modelId === 'string' ? data.modelId : undefined,
+    systemPrompt: typeof data.systemPrompt === 'string' ? data.systemPrompt : undefined,
+    title: typeof data.title === 'string' ? data.title : undefined,
+    summary: typeof data.summary === 'string' ? data.summary : undefined,
+    pinned: Boolean(data.pinned),
+    messages,
+  }
+}
+
+export async function saveSession(paths, session) {
+  const p = sessionPath(paths, session.sessionId)
+  const messages = Array.isArray(session.messages) ? session.messages : []
+  const title = typeof session.title === 'string' && session.title.trim()
+    ? session.title.trim()
+    : deriveSessionTitle(messages)
+  const summary = typeof session.summary === 'string' && session.summary.trim()
+    ? session.summary.trim()
+    : deriveSessionSummary(messages)
+  const pinned = typeof session.pinned === 'boolean' ? session.pinned : false
+
+  const next = {
+    schemaVersion: 1,
+    sessionId: session.sessionId,
+    createdAt: session.createdAt ?? Date.now(),
+    updatedAt: Date.now(),
+    modelId: session.modelId,
+    systemPrompt: session.systemPrompt,
+    title,
+    summary,
+    pinned,
+    messages,
+  }
+  await writeJsonFileAtomic(p, next)
+  return next
+}
+
+export async function listSessions(paths) {
+  await ensureDir(paths.sessionsDir)
+  const entries = await readdir(paths.sessionsDir)
+  const sessions = []
+  for (const name of entries) {
+    if (!name.endsWith('.json'))
+      continue
+    try {
+      const s = await loadSession(paths, name.slice(0, -'.json'.length))
+      if (s)
+        sessions.push(s)
+    }
+    catch {
+      // ignore broken session files
+    }
+  }
+  sessions.sort((a, b) => {
+    const ap = a.pinned ? 1 : 0
+    const bp = b.pinned ? 1 : 0
+    if (bp !== ap)
+      return bp - ap
+    return (b.updatedAt ?? 0) - (a.updatedAt ?? 0)
+  })
+  return sessions
+}
+
+export async function renameSession(paths, sessionId, title) {
+  const s = await loadSession(paths, sessionId)
+  if (!s)
+    return undefined
+  const nextTitle = typeof title === 'string' ? title.trim() : ''
+  return saveSession(paths, {
+    sessionId: s.sessionId,
+    createdAt: s.createdAt,
+    modelId: s.modelId,
+    systemPrompt: s.systemPrompt,
+    title: nextTitle,
+    summary: s.summary,
+    pinned: s.pinned,
+    messages: s.messages,
+  })
+}
+
+export async function setPinned(paths, sessionId, pinned) {
+  const s = await loadSession(paths, sessionId)
+  if (!s)
+    return undefined
+  return saveSession(paths, {
+    sessionId: s.sessionId,
+    createdAt: s.createdAt,
+    modelId: s.modelId,
+    systemPrompt: s.systemPrompt,
+    title: s.title,
+    summary: s.summary,
+    pinned: Boolean(pinned),
+    messages: s.messages,
+  })
+}
+
+export async function setPinnedSessions(paths, sessionIds, pinned) {
+  const ids = Array.isArray(sessionIds) ? sessionIds : []
+  const results = []
+  for (const id of ids) {
+    if (!id || typeof id !== 'string')
+      continue
+    // eslint-disable-next-line no-await-in-loop
+    const updated = await setPinned(paths, id, pinned)
+    results.push({ sessionId: id, pinned: Boolean(pinned), updated: Boolean(updated) })
+  }
+  return results
+}
+
+export async function deleteSession(paths, sessionId) {
+  const p = sessionPath(paths, sessionId)
+  try {
+    await unlink(p)
+    return true
+  }
+  catch (err) {
+    if (err && typeof err === 'object' && err.code === 'ENOENT')
+      return false
+    throw err
+  }
+}
+
+export async function deleteSessions(paths, sessionIds) {
+  const ids = Array.isArray(sessionIds) ? sessionIds : []
+  const results = []
+  for (const id of ids) {
+    if (!id || typeof id !== 'string')
+      continue
+    // eslint-disable-next-line no-await-in-loop
+    const deleted = await deleteSession(paths, id)
+    results.push({ sessionId: id, deleted })
+  }
+  return results
+}