goatchain 0.0.1

package/cli/clack.mjs

@@ -0,0 +1,111 @@
+/**
+ * Optional clack integration.
+ *
+ * We load `@clack/prompts` dynamically so the CLI can run without it.
+ * This file intentionally has no static import of clack.
+ */
+export async function loadClack() {
+  try {
+    const mod = await import('@clack/prompts')
+    if (mod && typeof mod.select === 'function')
+      return mod
+    return null
+  }
+  catch {
+    return null
+  }
+}
+
+export async function selectWithClack({ message, options, initialValue }) {
+  const clack = await loadClack()
+  if (!clack)
+    return { ok: false, reason: 'missing' }
+
+  const res = await clack.select({
+    message,
+    options,
+    initialValue,
+  })
+
+  if (clack.isCancel(res))
+    return { ok: false, reason: 'cancel' }
+
+  return { ok: true, value: res }
+}
+
+export async function multiselectWithClack({ message, options, required = false }) {
+  const clack = await loadClack()
+  if (!clack)
+    return { ok: false, reason: 'missing' }
+
+  if (typeof clack.multiselect !== 'function')
+    return { ok: false, reason: 'unsupported' }
+
+  const res = await clack.multiselect({
+    message,
+    options,
+    required,
+  })
+
+  if (clack.isCancel(res))
+    return { ok: false, reason: 'cancel' }
+
+  return { ok: true, value: res }
+}
+
+export async function confirmWithClack({ message, initialValue = false }) {
+  const clack = await loadClack()
+  if (!clack)
+    return { ok: false, reason: 'missing' }
+
+  if (typeof clack.confirm !== 'function')
+    return { ok: false, reason: 'unsupported' }
+
+  const res = await clack.confirm({
+    message,
+    initialValue,
+  })
+
+  if (clack.isCancel(res))
+    return { ok: false, reason: 'cancel' }
+
+  return { ok: true, value: Boolean(res) }
+}
+
+export async function textWithClack({ message, placeholder }) {
+  const clack = await loadClack()
+  if (!clack)
+    return { ok: false, reason: 'missing' }
+
+  if (typeof clack.text !== 'function')
+    return { ok: false, reason: 'unsupported' }
+
+  const res = await clack.text({
+    message,
+    placeholder,
+  })
+
+  if (clack.isCancel(res))
+    return { ok: false, reason: 'cancel' }
+
+  return { ok: true, value: String(res ?? '') }
+}
+
+export async function passwordWithClack({ message, placeholder }) {
+  const clack = await loadClack()
+  if (!clack)
+    return { ok: false, reason: 'missing' }
+
+  if (typeof clack.password !== 'function')
+    return { ok: false, reason: 'unsupported' }
+
+  const res = await clack.password({
+    message,
+    placeholder,
+  })
+
+  if (clack.isCancel(res))
+    return { ok: false, reason: 'cancel' }
+
+  return { ok: true, value: String(res ?? '') }
+}

package/cli/clipboard.mjs

@@ -0,0 +1,320 @@
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+import { mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+import os from 'node:os'
+
+const execFileAsync = promisify(execFile)
+
+async function runAppleScript(lines, maxBuffer = 1024 * 1024) {
+  if (process.platform !== 'darwin')
+    return null
+  try {
+    const { stdout } = await execFileAsync('osascript', lines.flatMap(l => ['-e', l]), { encoding: 'utf8', maxBuffer })
+    return String(stdout ?? '')
+  }
+  catch {
+    return null
+  }
+}
+
+export function parseClipboardFileUrl(text) {
+  const urls = parseClipboardFileUrls(text)
+  return urls.length > 0 ? urls[0] : null
+}
+
+export function parseClipboardFileUrls(text) {
+  const s = String(text ?? '').trim()
+  if (!s)
+    return []
+
+  // Finder sometimes provides multiple lines or null-separated records.
+  const parts = s
+    .split(/\u0000|\r?\n/)
+    .map(x => x.trim())
+    .filter(Boolean)
+
+  /** @type {string[]} */
+  const out = []
+  for (const part of parts) {
+    if (part.startsWith('file://')) {
+      try {
+        const u = new URL(part)
+        if (u.protocol !== 'file:')
+          continue
+        const p = decodeURIComponent(u.pathname)
+        if (p)
+          out.push(p)
+        continue
+      }
+      catch {
+        continue
+      }
+    }
+
+    // Some apps paste absolute paths directly.
+    if (part.startsWith('/'))
+      out.push(part)
+  }
+  return out
+}
+
+function sniffMimeFromBuffer(buf) {
+  if (!Buffer.isBuffer(buf) || buf.length < 12)
+    return null
+  // PNG
+  if (buf.length >= 8 && buf[0] === 0x89 && buf[1] === 0x50 && buf[2] === 0x4E && buf[3] === 0x47 && buf[4] === 0x0D && buf[5] === 0x0A && buf[6] === 0x1A && buf[7] === 0x0A)
+    return { mime: 'image/png', ext: '.png' }
+  // JPEG
+  if (buf[0] === 0xFF && buf[1] === 0xD8 && buf[2] === 0xFF)
+    return { mime: 'image/jpeg', ext: '.jpg' }
+  // GIF
+  if (buf[0] === 0x47 && buf[1] === 0x49 && buf[2] === 0x46 && buf[3] === 0x38)
+    return { mime: 'image/gif', ext: '.gif' }
+  // WEBP
+  if (buf.subarray(0, 4).toString('ascii') === 'RIFF' && buf.subarray(8, 12).toString('ascii') === 'WEBP')
+    return { mime: 'image/webp', ext: '.webp' }
+  // TIFF: II*\0 or MM\0*
+  if ((buf[0] === 0x49 && buf[1] === 0x49 && buf[2] === 0x2A && buf[3] === 0x00) || (buf[0] === 0x4D && buf[1] === 0x4D && buf[2] === 0x00 && buf[3] === 0x2A))
+    return { mime: 'image/tiff', ext: '.tiff' }
+  // BMP: "BM"
+  if (buf[0] === 0x42 && buf[1] === 0x4D)
+    return { mime: 'image/bmp', ext: '.bmp' }
+  return null
+}
+
+export async function readClipboardTextDarwin() {
+  if (process.platform !== 'darwin')
+    return null
+  try {
+    const { stdout } = await execFileAsync('pbpaste', [], { encoding: 'utf8', maxBuffer: 2 * 1024 * 1024 })
+    return String(stdout ?? '')
+  }
+  catch {
+    return null
+  }
+}
+
+export async function readClipboardTypesDarwin() {
+  if (process.platform !== 'darwin')
+    return null
+  const out = await runAppleScript(['clipboard info'])
+  const s = String(out ?? '').trim()
+  return s || null
+}
+
+async function readClipboardPreferredTextDarwin(uti) {
+  if (process.platform !== 'darwin')
+    return null
+  try {
+    const { stdout } = await execFileAsync('pbpaste', ['-Prefer', String(uti)], { encoding: 'utf8', maxBuffer: 2 * 1024 * 1024 })
+    return String(stdout ?? '')
+  }
+  catch {
+    return null
+  }
+}
+
+async function readClipboardFilePathsDarwinViaOsa() {
+  if (process.platform !== 'darwin')
+    return []
+  const out = await runAppleScript([
+    'try',
+    'set thePaths to {}',
+    'try',
+    'set theItems to the clipboard as alias list',
+    'on error',
+    'set theItems to {(the clipboard as alias)}',
+    'end try',
+    'repeat with a in theItems',
+    'set end of thePaths to POSIX path of a',
+    'end repeat',
+    'set AppleScript\'s text item delimiters to "\\n"',
+    'return thePaths as text',
+    'end try',
+  ])
+  const raw = String(out ?? '').trim()
+  if (!raw)
+    return []
+  return raw.split(/\r?\n/).map(s => s.trim()).filter(Boolean)
+}
+
+export async function readFinderSelectionPathsDarwin() {
+  if (process.platform !== 'darwin')
+    return []
+  const out = await runAppleScript([
+    'try',
+    'tell application "Finder"',
+    'if (count of selection) is 0 then return ""',
+    'set thePaths to {}',
+    'repeat with i in selection',
+    'try',
+    'set end of thePaths to POSIX path of (i as alias)',
+    'end try',
+    'end repeat',
+    'set AppleScript\'s text item delimiters to "\\n"',
+    'return thePaths as text',
+    'end tell',
+    'end try',
+  ])
+  const raw = String(out ?? '').trim()
+  if (!raw)
+    return []
+  return raw.split(/\r?\n/).map(s => s.trim()).filter(Boolean)
+}
+
+async function readClipboardPreferredBinaryDarwin(uti, maxBytes = 12 * 1024 * 1024) {
+  if (process.platform !== 'darwin')
+    return null
+  try {
+    const { stdout } = await execFileAsync('pbpaste', ['-Prefer', String(uti)], { encoding: 'buffer', maxBuffer: maxBytes })
+    if (!Buffer.isBuffer(stdout) || stdout.length < 8)
+      return null
+    return stdout
+  }
+  catch {
+    return null
+  }
+}
+
+export async function readClipboardPngDarwin() {
+  if (process.platform !== 'darwin')
+    return null
+  try {
+    const { stdout } = await execFileAsync('pbpaste', ['-Prefer', 'png'], { encoding: 'buffer', maxBuffer: 12 * 1024 * 1024 })
+    if (!Buffer.isBuffer(stdout) || stdout.length < 8)
+      return null
+    // Confirm it looks like a PNG.
+    const sniff = sniffMimeFromBuffer(stdout)
+    if (!sniff || sniff.mime !== 'image/png')
+      return null
+    return { buf: stdout, mime: sniff.mime, ext: sniff.ext }
+  }
+  catch {
+    return null
+  }
+}
+
+async function convertWithSipsToPng(inputBuf, inExt) {
+  if (process.platform !== 'darwin')
+    return null
+  if (!Buffer.isBuffer(inputBuf) || inputBuf.length === 0)
+    return null
+  const ext = String(inExt ?? '').toLowerCase() || '.bin'
+  const dir = await mkdtemp(path.join(os.tmpdir(), 'goatchain-clip-'))
+  const inPath = path.join(dir, `in${ext}`)
+  const outPath = path.join(dir, 'out.png')
+  try {
+    await writeFile(inPath, inputBuf)
+    await execFileAsync('sips', ['-s', 'format', 'png', inPath, '--out', outPath], { encoding: 'utf8', maxBuffer: 1024 * 1024 })
+    const out = await readFile(outPath)
+    const sniff = sniffMimeFromBuffer(out)
+    if (!sniff || sniff.mime !== 'image/png')
+      return null
+    const dataUrl = `data:${sniff.mime};base64,${out.toString('base64')}`
+    return { buf: out, mime: sniff.mime, ext: sniff.ext, dataUrl }
+  }
+  catch {
+    return null
+  }
+  finally {
+    try {
+      await rm(dir, { recursive: true, force: true })
+    }
+    catch {
+      // ignore
+    }
+  }
+}
+
+export async function readImageFileAsDataUrl(absPath, maxBytes = 4 * 1024 * 1024) {
+  const st = await stat(absPath)
+  if (!st.isFile())
+    return null
+  if (st.size > maxBytes)
+    return null
+  const buf = await readFile(absPath)
+  const sniff = sniffMimeFromBuffer(buf)
+  if (!sniff || !sniff.mime.startsWith('image/'))
+    return null
+  const dataUrl = `data:${sniff.mime};base64,${buf.toString('base64')}`
+  return { buf, mime: sniff.mime, ext: sniff.ext, dataUrl }
+}
+
+export async function readClipboardImageCandidatesDarwin(maxBytes = 4 * 1024 * 1024) {
+  if (process.platform !== 'darwin')
+    return []
+
+  /** @type {Array<{ source: string, absPath: string | null, buf: Buffer, mime: string, ext: string, dataUrl: string }>} */
+  const out = []
+
+  // 1) Prefer file-url(s) if present.
+  const preferred = await readClipboardPreferredTextDarwin('public.file-url')
+  const txt = preferred && preferred.trim() ? preferred : await readClipboardTextDarwin()
+  let paths = parseClipboardFileUrls(txt)
+  if (paths.length === 0) {
+    // Some environments don't expose file-url to pbpaste; use AppleScript as a fallback.
+    paths = await readClipboardFilePathsDarwinViaOsa()
+  }
+  if (paths.length > 0) {
+    for (const p of paths) {
+      try {
+        // eslint-disable-next-line no-await-in-loop
+        const file = await readImageFileAsDataUrl(p, maxBytes)
+        if (file)
+          out.push({ source: 'file', absPath: p, ...file })
+      }
+      catch {
+        // ignore
+      }
+    }
+  }
+
+  if (out.length > 0)
+    return out
+
+  // 2) Try common binary clipboard formats.
+  const formats = [
+    'png',
+    'public.png',
+    'jpeg',
+    'public.jpeg',
+    'jpg',
+    'public.jpg',
+    'public.tiff',
+    'tiff',
+    'public.bmp',
+    'bmp',
+  ]
+
+  for (const fmt of formats) {
+    // eslint-disable-next-line no-await-in-loop
+    const buf = await readClipboardPreferredBinaryDarwin(fmt, Math.max(12 * 1024 * 1024, maxBytes))
+    if (!buf)
+      continue
+    const sniff = sniffMimeFromBuffer(buf)
+    if (!sniff || !sniff.mime.startsWith('image/'))
+      continue
+
+    if (sniff.mime === 'image/tiff' || sniff.mime === 'image/bmp') {
+      // Try to convert unsupported formats into PNG for model compatibility.
+      // eslint-disable-next-line no-await-in-loop
+      const converted = await convertWithSipsToPng(buf, sniff.ext)
+      if (converted) {
+        out.push({ source: fmt, absPath: null, ...converted })
+        break
+      }
+    }
+
+    const dataUrl = `data:${sniff.mime};base64,${buf.toString('base64')}`
+    out.push({ source: fmt, absPath: null, buf, mime: sniff.mime, ext: sniff.ext, dataUrl })
+    break
+  }
+
+  return out
+}
+
+export async function readClipboardImageCandidateDarwin(maxBytes = 4 * 1024 * 1024) {
+  const all = await readClipboardImageCandidatesDarwin(maxBytes)
+  return all.length > 0 ? all[0] : null
+}

package/cli/files.mjs

@@ -0,0 +1,247 @@
+import path from 'node:path'
+import { open, readdir, stat } from 'node:fs/promises'
+
+const DEFAULT_IGNORE_DIRS = new Set([
+  'node_modules',
+  '.git',
+  '.goatchain',
+  'dist',
+  'tmp',
+])
+
+function 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)
+}
+
+export function ensureAllowedFile(workspaceCwd, filePath) {
+  const abs = path.isAbsolute(filePath) ? filePath : path.resolve(workspaceCwd, filePath)
+  if (!isSubpath(workspaceCwd, abs)) {
+    throw new Error(`Access denied: ${abs}\nAllowed directory: ${workspaceCwd}`)
+  }
+  // block cache dir by default
+  const cacheDir = path.join(workspaceCwd, '.goatchain')
+  if (isSubpath(cacheDir, abs)) {
+    throw new Error(`Access denied: ${abs}\nRestricted: ${cacheDir}`)
+  }
+  return abs
+}
+
+export async function listWorkspaceFiles(workspaceCwd, options = {}) {
+  const maxFiles = typeof options.maxFiles === 'number' ? options.maxFiles : 5000
+  const ignoreDirs = new Set(options.ignoreDirs ?? DEFAULT_IGNORE_DIRS)
+
+  /** @type {string[]} */
+  const out = []
+  /** @type {string[]} */
+  const queue = ['.']
+
+  while (queue.length > 0) {
+    const relDir = queue.shift()
+    if (!relDir)
+      break
+
+    const absDir = path.resolve(workspaceCwd, relDir)
+    let entries
+    try {
+      // eslint-disable-next-line no-await-in-loop
+      entries = await readdir(absDir, { withFileTypes: true })
+    }
+    catch {
+      continue
+    }
+
+    for (const ent of entries) {
+      const name = ent.name
+      if (!name)
+        continue
+
+      if (ent.isDirectory()) {
+        if (ignoreDirs.has(name))
+          continue
+        if (name.startsWith('.env'))
+          continue
+        const nextRel = relDir === '.' ? name : path.join(relDir, name)
+        queue.push(nextRel)
+        continue
+      }
+
+      if (!ent.isFile())
+        continue
+
+      const rel = relDir === '.' ? name : path.join(relDir, name)
+      out.push(rel)
+      if (out.length >= maxFiles)
+        return out
+    }
+  }
+
+  return out
+}
+
+function safeSliceLines(lines, n) {
+  if (n <= 0)
+    return []
+  return lines.slice(0, Math.min(lines.length, n))
+}
+
+export function summarizeText(text, opts = {}) {
+  const headLines = typeof opts.headLines === 'number' ? opts.headLines : 40
+  const tailLines = typeof opts.tailLines === 'number' ? opts.tailLines : 20
+  const maxBytes = typeof opts.maxBytes === 'number' ? opts.maxBytes : 60_000
+  const s = String(text ?? '')
+
+  const asBytes = Buffer.byteLength(s, 'utf8')
+  const clipped = asBytes > maxBytes ? s.slice(0, Math.max(0, maxBytes)) : s
+  const lines = clipped.split('\n')
+
+  if (lines.length <= headLines + tailLines)
+    return { text: clipped, truncated: asBytes > maxBytes }
+
+  const head = safeSliceLines(lines, headLines)
+  const tail = lines.slice(Math.max(headLines, lines.length - tailLines))
+  return {
+    text: `${head.join('\n')}\n…\n${tail.join('\n')}`,
+    truncated: true,
+  }
+}
+
+async function readTextFile(absPath, maxBytes, totalBytes) {
+  const toRead = Math.max(0, Math.min(Number(maxBytes) || 0, totalBytes))
+  const fh = await open(absPath, 'r')
+  try {
+    const buf = Buffer.allocUnsafe(toRead)
+    const { bytesRead } = await fh.read(buf, 0, toRead, 0)
+    const text = buf.subarray(0, bytesRead).toString('utf8')
+    return { text, truncated: totalBytes > maxBytes, bytes: totalBytes }
+  }
+  finally {
+    await fh.close()
+  }
+}
+
+function parseFileMentions(input) {
+  const s = String(input ?? '')
+  /** @type {Array<{ raw: string, mode: 'path'|'summary'|'full', filePath: string }>} */
+  const mentions = []
+  const re = /@file(?:\((path|summary|full)\))?:([^\s]+)/g
+  let m
+  while ((m = re.exec(s)) != null) {
+    const raw = m[0]
+    const mode = (m[1] || 'summary')
+    const filePath = m[2]
+    mentions.push({ raw, mode, filePath })
+  }
+  return mentions
+}
+
+export async function expandFileMentions(workspaceCwd, input, options = {}) {
+  const maxTotalBytes = typeof options.maxTotalBytes === 'number' ? options.maxTotalBytes : 220_000
+  const maxBytesPerFile = typeof options.maxBytesPerFile === 'number' ? options.maxBytesPerFile : 120_000
+  const maxBytesPerFileSummary = typeof options.maxBytesPerFileSummary === 'number' ? options.maxBytesPerFileSummary : 40_000
+  const headLines = typeof options.headLines === 'number' ? options.headLines : 60
+  const tailLines = typeof options.tailLines === 'number' ? options.tailLines : 20
+
+  const mentions = parseFileMentions(input)
+  if (mentions.length === 0)
+    return { text: String(input ?? ''), files: [], omitted: [] }
+
+  const unique = new Map()
+  for (const m of mentions) {
+    const key = `${m.mode}:${m.filePath}`
+    if (!unique.has(key))
+      unique.set(key, m)
+  }
+
+  /** @type {Array<{ mode: string, relPath: string, absPath: string, bytes: number, truncated: boolean, content?: string }>} */
+  const files = []
+  /** @type {Array<{ mode: string, filePath: string, reason: 'budget'|'not_file' }>} */
+  const omitted = []
+  let used = 0
+
+  const uniqMentions = [...unique.values()]
+  for (let idx = 0; idx < uniqMentions.length; idx++) {
+    const m = uniqMentions[idx]
+    const abs = ensureAllowedFile(workspaceCwd, m.filePath)
+    // eslint-disable-next-line no-await-in-loop
+    const st = await stat(abs)
+    if (!st.isFile()) {
+      omitted.push({ mode: m.mode, filePath: m.filePath, reason: 'not_file' })
+      continue
+    }
+
+    if (m.mode === 'path') {
+      files.push({ mode: 'path', relPath: path.relative(workspaceCwd, abs), absPath: abs, bytes: st.size, truncated: false })
+      continue
+    }
+
+    const budgetLeft = Math.max(0, maxTotalBytes - used)
+    if (budgetLeft <= 0) {
+      omitted.push({ mode: m.mode, filePath: m.filePath, reason: 'budget' })
+      for (let j = idx + 1; j < uniqMentions.length; j++) {
+        const rest = uniqMentions[j]
+        omitted.push({ mode: rest.mode, filePath: rest.filePath, reason: 'budget' })
+      }
+      break
+    }
+
+    const perFileMax = m.mode === 'summary' ? maxBytesPerFileSummary : maxBytesPerFile
+    const perFile = Math.min(perFileMax, budgetLeft)
+    // eslint-disable-next-line no-await-in-loop
+    const raw = await readTextFile(abs, perFile, st.size)
+    used += Math.min(raw.bytes, perFile)
+
+    if (m.mode === 'full') {
+      files.push({
+        mode: 'full',
+        relPath: path.relative(workspaceCwd, abs),
+        absPath: abs,
+        bytes: raw.bytes,
+        truncated: raw.truncated,
+        content: raw.text,
+      })
+    }
+    else {
+      const summary = summarizeText(raw.text, { headLines, tailLines, maxBytes: perFile })
+      files.push({
+        mode: 'summary',
+        relPath: path.relative(workspaceCwd, abs),
+        absPath: abs,
+        bytes: raw.bytes,
+        truncated: raw.truncated || summary.truncated,
+        content: summary.text,
+      })
+    }
+  }
+
+  let cleaned = String(input ?? '')
+  for (const m of mentions) {
+    cleaned = cleaned.replace(m.raw, '').replace(/\s{2,}/g, ' ')
+  }
+  cleaned = cleaned.trim()
+
+  const blocks = files
+    .filter(f => f.mode !== 'path')
+    .map((f) => {
+      const head = `---\nfile: ${f.relPath}\nmode: ${f.mode}${f.truncated ? ' (truncated)' : ''}\n---\n`
+      return `${head}${String(f.content ?? '')}`.trimEnd()
+    })
+
+  const pathsOnly = files.filter(f => f.mode === 'path').map(f => f.relPath)
+  const preface = [
+    blocks.length > 0 || pathsOnly.length > 0 ? '[attached files]' : '',
+    pathsOnly.length > 0 ? `paths: ${pathsOnly.join(', ')}` : '',
+  ].filter(Boolean).join('\n')
+
+  const expanded = [
+    cleaned,
+    preface,
+    ...blocks,
+  ].filter(Boolean).join('\n\n')
+
+  return { text: expanded, files, omitted }
+}