@raolin2025/claude-code-node 1.0.0

package/src/types/index.js

@@ -0,0 +1,126 @@
+// ====== 消息类型 ======
+
+/** 消息角色 */
+export const Role = {
+  USER: 'user',
+  ASSISTANT: 'assistant',
+  SYSTEM: 'system',
+}
+
+/** 基础消息 */
+export class Message {
+  role
+  content
+  timestamp
+  id
+
+  constructor(role, content) {
+    this.role = role
+    this.content = content
+    this.timestamp = Date.now()
+    this.id = crypto.randomUUID()
+  }
+}
+
+export class UserMessage extends Message {
+  constructor(content) {
+    super(Role.USER, content)
+  }
+}
+
+export class AssistantMessage extends Message {
+  toolCalls
+  constructor(content, toolCalls = []) {
+    super(Role.ASSISTANT, content)
+    this.toolCalls = toolCalls
+  }
+}
+
+export class SystemMessage extends Message {
+  constructor(content) {
+    super(Role.SYSTEM, content)
+  }
+}
+
+// ====== 工具调用类型 ======
+
+export class ToolCall {
+  id
+  name
+  input
+  status // 'pending' | 'running' | 'done' | 'error'
+
+  constructor(id, name, input) {
+    this.id = id
+    this.name = name
+    this.input = input
+    this.status = 'pending'
+  }
+}
+
+export class ToolResult {
+  toolCallId
+  content
+  isError
+
+  constructor(toolCallId, content, isError = false) {
+    this.toolCallId = toolCallId
+    this.content = content
+    this.isError = isError
+  }
+}
+
+// ====== 工具定义 ======
+
+export class ToolDef {
+  name
+  description
+  parameters // JSON Schema
+  handler
+  permissionLevel // 'always-allow' | 'ask' | 'deny'
+
+  constructor(name, description, parameters, handler, permissionLevel = 'ask') {
+    this.name = name
+    this.description = description
+    this.parameters = parameters
+    this.handler = handler
+    this.permissionLevel = permissionLevel
+  }
+}
+
+// ====== Agent 类型 ======
+
+export class AgentDef {
+  id
+  name
+  systemPrompt
+  tools
+  model
+
+  constructor(id, name, systemPrompt, tools = [], model = 'default') {
+    this.id = id
+    this.name = name
+    this.systemPrompt = systemPrompt
+    this.tools = tools
+    this.model = model
+  }
+}
+
+// ====== 会话状态 ======
+
+export class SessionState {
+  messages
+  toolResults
+  turnCount
+  budgetUsed // token 预算
+  isRunning
+
+  constructor() {
+    this.messages = []
+    this.toolResults = new Map()
+    this.turnCount = 0
+    this.budgetUsed = 0
+    this.isRunning = false
+  }
+}
+

package/src/utils/diff.js

@@ -0,0 +1,181 @@
+/**
+ * 文本差异计算 — 简单 LCS 算法
+ * 对应原版: src/utils/diff.ts
+ */
+
+/**
+ * 计算两个文本之间的 unified diff
+ */
+export function unifiedDiff(oldText, newText, filePath = 'file') {
+  const oldLines = oldText.split('\n')
+  const newLines = newText.split('\n')
+  const hunks = computeHunks(oldLines, newLines)
+
+  if (hunks.length === 0) return ''
+
+  const header = `--- a/${filePath}\n+++ b/${filePath}\n`
+  const body = hunks.map(h => formatHunk(h, oldLines, newLines)).join('\n')
+
+  return header + body
+}
+
+/**
+ * 计算差异区域
+ */
+function computeHunks(oldLines, newLines) {
+  const lcs = computeLCS(oldLines, newLines)
+  const edits = extractEdits(oldLines, newLines, lcs)
+
+  // 合并相邻的编辑区域
+  const hunks = []
+  let currentHunk = null
+
+  for (const edit of edits) {
+    if (!currentHunk || edit.oldStart - currentHunk.oldEnd > 3) {
+      if (currentHunk) hunks.push(currentHunk)
+      currentHunk = {
+        oldStart: Math.max(0, edit.oldStart - 3),
+        oldEnd: edit.oldEnd + 3,
+        newStart: Math.max(0, edit.newStart - 3),
+        newEnd: edit.newEnd + 3,
+        edits: [edit],
+      }
+    } else {
+      currentHunk.oldEnd = edit.oldEnd + 3
+      currentHunk.newEnd = edit.newEnd + 3
+      currentHunk.edits.push(edit)
+    }
+  }
+  if (currentHunk) hunks.push(currentHunk)
+
+  return hunks
+}
+
+/**
+ * 简单 LCS 动态规划
+ */
+function computeLCS(a, b) {
+  const m = a.length
+  const n = b.length
+  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0))
+
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (a[i - 1] === b[j - 1]) {
+        dp[i][j] = dp[i - 1][j - 1] + 1
+      } else {
+        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1])
+      }
+    }
+  }
+
+  // 回溯
+  const result = []
+  let i = m, j = n
+  while (i > 0 && j > 0) {
+    if (a[i - 1] === b[j - 1]) {
+      result.unshift({ type: 'equal', oldIdx: i - 1, newIdx: j - 1 })
+      i--; j--
+    } else if (dp[i - 1][j] >= dp[i][j - 1]) {
+      i--
+    } else {
+      j--
+    }
+  }
+
+  return result
+}
+
+/**
+ * 从 LCS 提取编辑操作
+ */
+function extractEdits(oldLines, newLines, lcs) {
+  const edits = []
+  let oldIdx = 0, newIdx = 0
+
+  for (const match of lcs) {
+    if (match.oldIdx > oldIdx || match.newIdx > newIdx) {
+      edits.push({
+        oldStart: oldIdx,
+        oldEnd: match.oldIdx,
+        newStart: newIdx,
+        newEnd: match.newIdx,
+        type: 'change',
+      })
+    }
+    oldIdx = match.oldIdx + 1
+    newIdx = match.newIdx + 1
+  }
+
+  // 末尾
+  if (oldIdx < oldLines.length || newIdx < newLines.length) {
+    edits.push({
+      oldStart: oldIdx,
+      oldEnd: oldLines.length,
+      newStart: newIdx,
+      newEnd: newLines.length,
+      type: 'change',
+    })
+  }
+
+  return edits
+}
+
+/**
+ * 格式化一个 hunk
+ */
+function formatHunk(hunk, oldLines, newLines) {
+  const oldStart = hunk.oldStart + 1
+  const oldCount = Math.min(hunk.oldEnd, oldLines.length) - hunk.oldStart
+  const newStart = hunk.newStart + 1
+  const newCount = Math.min(hunk.newEnd, newLines.length) - hunk.newStart
+
+  let output = `@@ -${oldStart},${oldCount} +${newStart},${newCount} @@\n`
+
+  for (let i = hunk.oldStart; i < Math.min(hunk.oldEnd, oldLines.length); i++) {
+    const isEdit = hunk.edits.some(e => i >= e.oldStart && i < e.oldEnd)
+    output += isEdit ? `-${oldLines[i]}\n` : ` ${oldLines[i]}\n`
+  }
+
+  for (let i = hunk.newStart; i < Math.min(hunk.newEnd, newLines.length); i++) {
+    const isEdit = hunk.edits.some(e => i >= e.newStart && i < e.newEnd)
+    if (isEdit) output += `+${newLines[i]}\n`
+  }
+
+  return output
+}
+
+/**
+ * 简单的字符级 diff（用于行内差异）
+ */
+export function inlineDiff(oldStr, newStr) {
+  if (oldStr === newStr) return oldStr
+
+  const commonPrefix = commonPrefixLength(oldStr, newStr)
+  const commonSuffix = commonSuffixLength(
+    oldStr.slice(commonPrefix),
+    newStr.slice(commonPrefix)
+  )
+
+  const removed = oldStr.slice(commonPrefix, oldStr.length - commonSuffix)
+  const added = newStr.slice(commonPrefix, newStr.length - commonSuffix)
+
+  let result = oldStr.slice(0, commonPrefix)
+  if (removed) result += `[-${removed}-]`
+  if (added) result += `{+${added}+}`
+  result += oldStr.slice(oldStr.length - commonSuffix)
+
+  return result
+}
+
+function commonPrefixLength(a, b) {
+  let i = 0
+  while (i < a.length && i < b.length && a[i] === b[i]) i++
+  return i
+}
+
+function commonSuffixLength(a, b) {
+  let i = 0
+  while (i < a.length && i < b.length && a[a.length - 1 - i] === b[b.length - 1 - i]) i++
+  return i
+}

package/src/utils/file-ops.js

@@ -0,0 +1,124 @@
+/**
+ * 文件操作工具
+ * 对应原版: src/utils/file.ts + src/utils/fsOperations.ts
+ */
+import { readFile, writeFile, stat, mkdir, rm, rename, copyFile } from 'fs/promises'
+import { resolve, dirname, basename, isAbsolute } from 'path'
+import { existsSync } from 'fs'
+
+/**
+ * 安全读取文件（带大小限制）
+ */
+export async function safeReadFile(filePath, options = {}) {
+  const maxBytes = options.maxBytes || 256 * 1024 // 256KB
+  const absPath = resolvePath(filePath, options.cwd)
+
+  try {
+    const fileStat = await stat(absPath)
+    if (fileStat.size > maxBytes) {
+      return { ok: false, error: `File too large: ${fileStat.size} bytes (limit: ${maxBytes})` }
+    }
+    const content = await readFile(absPath, 'utf-8')
+    return { ok: true, content, size: fileStat.size, mtime: fileStat.mtimeMs }
+  } catch (err) {
+    return { ok: false, error: err.message, code: err.code }
+  }
+}
+
+/**
+ * 安全写入文件（自动创建目录）
+ */
+export async function safeWriteFile(filePath, content, options = {}) {
+  const absPath = resolvePath(filePath, options.cwd)
+
+  try {
+    await mkdir(dirname(absPath), { recursive: true })
+    await writeFile(absPath, content, 'utf-8')
+    return { ok: true, path: absPath, size: Buffer.byteLength(content, 'utf-8') }
+  } catch (err) {
+    return { ok: false, error: err.message }
+  }
+}
+
+/**
+ * 精确文本替换编辑
+ */
+export async function editFile(filePath, edits, options = {}) {
+  const absPath = resolvePath(filePath, options.cwd)
+
+  try {
+    const content = await readFile(absPath, 'utf-8')
+    let newContent = content
+
+    for (const edit of Array.isArray(edits) ? edits : [edits]) {
+      const { oldText, newText, replaceAll = false } = edit
+
+      if (!newContent.includes(oldText)) {
+        return { ok: false, error: `oldText not found in ${absPath}` }
+      }
+
+      const count = newContent.split(oldText).length - 1
+      if (count > 1 && !replaceAll) {
+        return { ok: false, error: `oldText appears ${count} times. Use replaceAll=true or provide more context.` }
+      }
+
+      if (replaceAll) {
+        newContent = newContent.split(oldText).join(newText)
+      } else {
+        const idx = newContent.indexOf(oldText)
+        newContent = newContent.slice(0, idx) + newText + newContent.slice(idx + oldText.length)
+      }
+    }
+
+    await writeFile(absPath, newContent, 'utf-8')
+    return { ok: true, path: absPath }
+  } catch (err) {
+    return { ok: false, error: err.message }
+  }
+}
+
+/**
+ * 检查文件/目录是否存在
+ */
+export async function pathExists(filePath) {
+  try {
+    await stat(filePath)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * 递归删除
+ */
+export async function removeRecursive(filePath) {
+  try {
+    await rm(filePath, { recursive: true, force: true })
+    return { ok: true }
+  } catch (err) {
+    return { ok: false, error: err.message }
+  }
+}
+
+/**
+ * 获取文件修改时间
+ */
+export async function getMtime(filePath) {
+  try {
+    const s = await stat(filePath)
+    return s.mtimeMs
+  } catch {
+    return null
+  }
+}
+
+/**
+ * 解析路径（支持相对路径）
+ */
+function resolvePath(filePath, cwd) {
+  if (isAbsolute(filePath)) return filePath
+  return resolve(cwd || process.cwd(), filePath)
+}
+
+export { resolvePath as resolvePath }

package/src/utils/format.js

@@ -0,0 +1,130 @@
+/**
+ * 输出格式化工具
+ * 对应原版: src/utils/format.ts + src/outputStyles/
+ */
+
+/**
+ * ANSI 颜色码
+ */
+const ANSI = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  gray: '\x1b[90m',
+  bgRed: '\x1b[41m',
+  bgGreen: '\x1b[42m',
+}
+
+/** 是否支持颜色 */
+const supportsColor = process.stdout?.isTTY && !process.env.NO_COLOR
+
+function color(code, text) {
+  return supportsColor ? `${code}${text}${ANSI.reset}` : text
+}
+
+export const format = {
+  bold: (t) => color(ANSI.bold, t),
+  dim: (t) => color(ANSI.dim, t),
+  red: (t) => color(ANSI.red, t),
+  green: (t) => color(ANSI.green, t),
+  yellow: (t) => color(ANSI.yellow, t),
+  blue: (t) => color(ANSI.blue, t),
+  cyan: (t) => color(ANSI.cyan, t),
+  gray: (t) => color(ANSI.gray, t),
+  magenta: (t) => color(ANSI.magenta, t),
+}
+
+/**
+ * 格式化代码块
+ */
+export function codeBlock(code, lang = '') {
+  return `\`\`\`${lang}\n${code}\n\`\`\``
+}
+
+/**
+ * 格式化文件路径
+ */
+export function formatPath(path) {
+  return format.cyan(path)
+}
+
+/**
+ * 格式化工具调用
+ */
+export function formatToolCall(name, input) {
+  const inputStr = typeof input === 'string' ? input : JSON.stringify(input, null, 2)
+  const shortInput = inputStr.length > 200 ? inputStr.slice(0, 200) + '...' : inputStr
+  return `${format.bold(format.magenta(name))}(${format.dim(shortInput)})`
+}
+
+/**
+ * 格式化工具结果
+ */
+export function formatToolResult(name, result, isError = false) {
+  const icon = isError ? format.red('✗') : format.green('✓')
+  const shortResult = result.length > 300 ? result.slice(0, 300) + '...' : result
+  return `${icon} ${format.bold(name)}: ${shortResult}`
+}
+
+/**
+ * 格式化 token 用量
+ */
+export function formatTokenUsage(used, total) {
+  const percent = Math.round((used / total) * 100)
+  const bar = progressBar(percent, 20)
+  const colorFn = percent > 90 ? format.red : percent > 70 ? format.yellow : format.green
+  return `Tokens: ${colorFn(bar)} ${used.toLocaleString()}/${total.toLocaleString()} (${percent}%)`
+}
+
+/**
+ * 进度条
+ */
+export function progressBar(percent, width = 30) {
+  const filled = Math.round((percent / 100) * width)
+  const empty = width - filled
+  return '█'.repeat(filled) + '░'.repeat(empty)
+}
+
+/**
+ * 格式化时间
+ */
+export function formatDuration(ms) {
+  if (ms < 1000) return `${ms}ms`
+  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`
+  const min = Math.floor(ms / 60000)
+  const sec = Math.round((ms % 60000) / 1000)
+  return `${min}m ${sec}s`
+}
+
+/**
+ * 格式化字节数
+ */
+export function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes}B`
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`
+}
+
+/**
+ * 表格格式化
+ */
+export function formatTable(headers, rows) {
+  const colWidths = headers.map((h, i) => {
+    const maxDataLen = Math.max(...rows.map(r => String(r[i]).length), 0)
+    return Math.max(h.length, maxDataLen)
+  })
+
+  const headerLine = headers.map((h, i) => h.padEnd(colWidths[i])).join(' | ')
+  const separator = colWidths.map(w => '─'.repeat(w)).join('─┼─')
+  const dataLines = rows.map(row =>
+    row.map((cell, i) => String(cell).padEnd(colWidths[i])).join(' | ')
+  )
+
+  return [headerLine, separator, ...dataLines].join('\n')
+}

package/src/utils/index.js

@@ -0,0 +1,7 @@
+/**
+ * 工具函数统一导出
+ */
+export { unifiedDiff, inlineDiff } from './diff.js'
+export { safeReadFile, safeWriteFile, editFile, pathExists, removeRecursive, getMtime, resolvePath } from './file-ops.js'
+export { execCommand, spawnProcess, commandExists, sendInput } from './process.js'
+export { format, codeBlock, formatPath, formatToolCall, formatToolResult, formatTokenUsage, formatDuration, formatBytes, formatTable, progressBar } from './format.js'

package/src/utils/process.js

@@ -0,0 +1,112 @@
+/**
+ * 进程管理工具
+ * 对应原版: src/utils/process.ts + src/utils/Shell.ts
+ */
+import { spawn, exec } from 'child_process'
+
+/**
+ * 执行命令并获取输出
+ */
+export function execCommand(command, options = {}) {
+  const cwd = options.cwd || process.cwd()
+  const timeout = options.timeout || 120_000
+  const env = { ...process.env, ...options.env }
+
+  return new Promise((resolve) => {
+    const proc = exec(command, { cwd, timeout, env, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
+      resolve({
+        ok: !err,
+        exitCode: err ? (err.killed ? -1 : err.code || 1) : 0,
+        stdout: stdout || '',
+        stderr: stderr || '',
+        killed: err?.killed || false,
+      })
+    })
+  })
+}
+
+/**
+ * 启动一个长期运行的进程（带实时输出流）
+ */
+export function spawnProcess(command, args = [], options = {}) {
+  const cwd = options.cwd || process.cwd()
+  const env = { ...process.env, ...options.env }
+  const timeout = options.timeout
+
+  const proc = spawn(command, args, {
+    cwd,
+    env,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    shell: options.shell || false,
+  })
+
+  let stdout = ''
+  let stderr = ''
+
+  proc.stdout.on('data', (data) => {
+    stdout += data.toString()
+    options.onStdout?.(data.toString())
+  })
+
+  proc.stderr.on('data', (data) => {
+    stderr += data.toString()
+    options.onStderr?.(data.toString())
+  })
+
+  // 超时处理
+  let timer = null
+  if (timeout) {
+    timer = setTimeout(() => {
+      proc.kill('SIGTERM')
+      setTimeout(() => { try { proc.kill('SIGKILL') } catch {} }, 5000)
+    }, timeout)
+  }
+
+  const promise = new Promise((resolve) => {
+    proc.on('close', (code) => {
+      if (timer) clearTimeout(timer)
+      resolve({
+        ok: code === 0,
+        exitCode: code || 0,
+        stdout,
+        stderr,
+      })
+    })
+
+    proc.on('error', (err) => {
+      if (timer) clearTimeout(timer)
+      resolve({
+        ok: false,
+        exitCode: -1,
+        stdout,
+        stderr: err.message,
+      })
+    })
+  })
+
+  return { process: proc, promise }
+}
+
+/**
+ * 检查命令是否可用
+ */
+export async function commandExists(cmd) {
+  const checkCmd = process.platform === 'win32' ? `where ${cmd}` : `which ${cmd}`
+  const result = await execCommand(checkCmd, { timeout: 5000 })
+  return result.ok
+}
+
+/**
+ * 向进程发送输入
+ */
+export function sendInput(proc, data) {
+  return new Promise((resolve, reject) => {
+    if (!proc.stdin?.writable) {
+      return reject(new Error('Process stdin is not writable'))
+    }
+    proc.stdin.write(data, (err) => {
+      if (err) reject(err)
+      else resolve()
+    })
+  })
+}