zyflow 0.6.4

package/server/adk/tools/git-tools.ts

@@ -0,0 +1,280 @@
+/**
+ * ADK Git Tools
+ *
+ * 에이전트가 Git 작업을 수행하기 위한 도구들
+ */
+
+import { FunctionTool } from '@google/adk'
+import { z } from 'zod'
+import { execFileSync } from 'child_process'
+import * as path from 'path'
+
+/**
+ * Git 명령어 실행 헬퍼
+ */
+function runGit(args: string[], cwd?: string): { success: boolean; output?: string; error?: string } {
+  try {
+    const output = execFileSync('git', args, {
+      cwd: cwd || process.cwd(),
+      encoding: 'utf-8',
+      maxBuffer: 10 * 1024 * 1024,
+    })
+    return { success: true, output: output.trim() }
+  } catch (err: unknown) {
+    const error = err as { stderr?: string }
+    if (error && error.stderr) {
+      return { success: false, error: String(error.stderr) }
+    }
+    return { success: false, error: String(err) }
+  }
+}
+
+/**
+ * Git 상태 확인 도구
+ */
+export const gitStatusTool = new FunctionTool({
+  name: 'gitStatus',
+  description: '현재 Git 저장소의 상태를 확인합니다.',
+  parameters: z.object({
+    directory: z.string().optional().describe('Git 저장소 디렉토리'),
+  }),
+  execute: async ({ directory }) => {
+    const cwd = directory ? path.resolve(process.cwd(), directory) : process.cwd()
+    const result = runGit(['status', '--porcelain', '-b'], cwd)
+
+    if (!result.success) {
+      return result
+    }
+
+    const lines = (result.output || '').split('\n').filter(Boolean)
+    const branchLine = lines.find(l => l.startsWith('##'))
+    const branch = branchLine?.replace('## ', '').split('...')[0] || 'unknown'
+
+    const changes: Array<{ status: string; file: string }> = []
+    for (const line of lines) {
+      if (line.startsWith('##')) continue
+      const status = line.substring(0, 2).trim()
+      const file = line.substring(3)
+      changes.push({ status, file })
+    }
+
+    return {
+      success: true,
+      branch,
+      changes,
+      hasChanges: changes.length > 0,
+    }
+  },
+})
+
+/**
+ * Git diff 도구
+ */
+export const gitDiffTool = new FunctionTool({
+  name: 'gitDiff',
+  description: '파일의 변경 내용을 확인합니다.',
+  parameters: z.object({
+    file: z.string().optional().describe('diff를 볼 파일'),
+    staged: z.boolean().optional().describe('스테이지된 변경만'),
+    commit: z.string().optional().describe('특정 커밋과 비교'),
+  }),
+  execute: async ({ file, staged, commit }) => {
+    const args = ['diff']
+    if (staged) args.push('--staged')
+    if (commit) args.push(commit)
+    if (file) args.push('--', file)
+    return runGit(args)
+  },
+})
+
+/**
+ * Git 브랜치 생성 도구
+ */
+export const gitCreateBranchTool = new FunctionTool({
+  name: 'gitCreateBranch',
+  description: '새 브랜치를 생성합니다.',
+  parameters: z.object({
+    branchName: z.string().describe('브랜치 이름'),
+    baseBranch: z.string().optional().describe('기준 브랜치'),
+    checkout: z.boolean().optional().describe('생성 후 체크아웃'),
+  }),
+  execute: async ({ branchName, baseBranch, checkout = true }) => {
+    if (!/^[a-zA-Z0-9\-_/]+$/.test(branchName)) {
+      return { success: false, error: '유효하지 않은 브랜치 이름' }
+    }
+
+    if (baseBranch) {
+      const checkoutResult = runGit(['checkout', baseBranch])
+      if (!checkoutResult.success) return checkoutResult
+      runGit(['pull', '--rebase'])
+    }
+
+    if (checkout) {
+      return runGit(['checkout', '-b', branchName])
+    }
+    return runGit(['branch', branchName])
+  },
+})
+
+/**
+ * Git 파일 스테이징 도구
+ */
+export const gitAddTool = new FunctionTool({
+  name: 'gitAdd',
+  description: '파일을 스테이징합니다.',
+  parameters: z.object({
+    files: z.array(z.string()).describe('스테이징할 파일'),
+    all: z.boolean().optional().describe('모든 파일 추가'),
+  }),
+  execute: async ({ files, all }) => {
+    if (all) return runGit(['add', '-A'])
+    if (files.length === 0) return { success: false, error: '파일 필요' }
+    return runGit(['add', ...files])
+  },
+})
+
+/**
+ * Git 커밋 도구
+ */
+export const gitCommitTool = new FunctionTool({
+  name: 'gitCommit',
+  description: '변경사항을 커밋합니다.',
+  parameters: z.object({
+    message: z.string().describe('커밋 메시지'),
+    body: z.string().optional().describe('커밋 본문'),
+  }),
+  execute: async ({ message, body }) => {
+    const args = ['commit', '-m', message]
+    if (body) args.push('-m', body)
+    return runGit(args)
+  },
+})
+
+/**
+ * Git 푸시 도구
+ */
+export const gitPushTool = new FunctionTool({
+  name: 'gitPush',
+  description: '브랜치를 원격으로 푸시합니다.',
+  parameters: z.object({
+    branch: z.string().optional().describe('브랜치'),
+    remote: z.string().optional().describe('원격 저장소'),
+    setUpstream: z.boolean().optional().describe('업스트림 설정'),
+    force: z.boolean().optional().describe('강제 푸시'),
+  }),
+  execute: async ({ branch, remote = 'origin', setUpstream = true, force = false }) => {
+    const args = ['push']
+    if (setUpstream) args.push('-u')
+    if (force) args.push('--force-with-lease')
+    args.push(remote)
+    if (branch) args.push(branch)
+    return runGit(args)
+  },
+})
+
+/**
+ * Git 로그 도구
+ */
+export const gitLogTool = new FunctionTool({
+  name: 'gitLog',
+  description: '커밋 이력을 확인합니다.',
+  parameters: z.object({
+    count: z.number().optional().describe('커밋 수'),
+    file: z.string().optional().describe('파일'),
+    oneline: z.boolean().optional().describe('한 줄 형식'),
+  }),
+  execute: async ({ count = 10, file, oneline = true }) => {
+    const args = ['log', `-n${count}`]
+    if (oneline) args.push('--oneline')
+    else args.push('--format=%H|%an|%ae|%s|%ci')
+    if (file) args.push('--', file)
+    return runGit(args)
+  },
+})
+
+/**
+ * Git stash 도구
+ */
+export const gitStashTool = new FunctionTool({
+  name: 'gitStash',
+  description: '변경사항 임시 저장/복원',
+  parameters: z.object({
+    action: z.enum(['save', 'pop', 'list', 'drop']).describe('작업'),
+    message: z.string().optional().describe('메시지'),
+    index: z.number().optional().describe('인덱스'),
+  }),
+  execute: async ({ action, message, index }) => {
+    const args = ['stash']
+    switch (action) {
+      case 'save':
+        args.push('push')
+        if (message) args.push('-m', message)
+        break
+      case 'pop':
+        args.push('pop')
+        if (index !== undefined) args.push(`stash@{${index}}`)
+        break
+      case 'list':
+        args.push('list')
+        break
+      case 'drop':
+        args.push('drop')
+        if (index !== undefined) args.push(`stash@{${index}}`)
+        break
+    }
+    return runGit(args)
+  },
+})
+
+/**
+ * Git 체크아웃 도구
+ */
+export const gitCheckoutTool = new FunctionTool({
+  name: 'gitCheckout',
+  description: '브랜치 체크아웃 또는 파일 복원',
+  parameters: z.object({
+    target: z.string().describe('브랜치 또는 커밋'),
+    files: z.array(z.string()).optional().describe('파일'),
+  }),
+  execute: async ({ target, files }) => {
+    const args = ['checkout', target]
+    if (files && files.length > 0) args.push('--', ...files)
+    return runGit(args)
+  },
+})
+
+/**
+ * Git reset 도구
+ */
+export const gitResetTool = new FunctionTool({
+  name: 'gitReset',
+  description: '스테이징 취소 또는 리셋',
+  parameters: z.object({
+    mode: z.enum(['soft', 'mixed', 'hard']).optional().describe('모드'),
+    target: z.string().optional().describe('대상'),
+    files: z.array(z.string()).optional().describe('파일'),
+  }),
+  execute: async ({ mode = 'mixed', target, files }) => {
+    const args = ['reset']
+    if (files && files.length > 0) {
+      args.push('--', ...files)
+    } else {
+      args.push(`--${mode}`)
+      if (target) args.push(target)
+    }
+    return runGit(args)
+  },
+})
+
+export const gitTools = [
+  gitStatusTool,
+  gitDiffTool,
+  gitCreateBranchTool,
+  gitAddTool,
+  gitCommitTool,
+  gitPushTool,
+  gitLogTool,
+  gitStashTool,
+  gitCheckoutTool,
+  gitResetTool,
+]

package/server/adk/tools/github-tools.ts

@@ -0,0 +1,249 @@
+/**
+ * ADK GitHub Tools
+ *
+ * 에이전트가 GitHub API와 상호작용하기 위한 도구들
+ */
+
+import { FunctionTool } from '@google/adk'
+import { z } from 'zod'
+import { Octokit } from '@octokit/rest'
+
+function getOctokit(): Octokit {
+  const token = process.env.GITHUB_TOKEN
+  if (!token) {
+    throw new Error('GITHUB_TOKEN 환경변수가 설정되지 않았습니다')
+  }
+  return new Octokit({ auth: token })
+}
+
+function parseRepo(repoPath: string): { owner: string; repo: string } {
+  const parts = repoPath.split('/')
+  if (parts.length !== 2) {
+    throw new Error('저장소 형식: owner/repo')
+  }
+  return { owner: parts[0], repo: parts[1] }
+}
+
+export const createPRTool = new FunctionTool({
+  name: 'createPR',
+  description: 'GitHub에 Pull Request를 생성합니다.',
+  parameters: z.object({
+    repository: z.string().describe('저장소 (owner/repo 형식)'),
+    title: z.string().describe('PR 제목'),
+    body: z.string().describe('PR 본문'),
+    head: z.string().describe('소스 브랜치'),
+    base: z.string().optional().describe('타겟 브랜치 (기본: main)'),
+    labels: z.array(z.string()).optional().describe('라벨'),
+    draft: z.boolean().optional().describe('드래프트 PR 여부'),
+  }),
+  execute: async ({ repository, title, body, head, base = 'main', labels, draft = false }) => {
+    try {
+      const octokit = getOctokit()
+      const { owner, repo } = parseRepo(repository)
+
+      const { data: pr } = await octokit.pulls.create({
+        owner, repo, title, body, head, base, draft,
+      })
+
+      if (labels && labels.length > 0) {
+        await octokit.issues.addLabels({
+          owner, repo, issue_number: pr.number, labels,
+        })
+      }
+
+      return { success: true, prNumber: pr.number, prUrl: pr.html_url, state: pr.state }
+    } catch (err) {
+      const error = err as { message?: string; status?: number }
+      return { success: false, error: error.message || String(err), status: error.status }
+    }
+  },
+})
+
+export const getPRStatusTool = new FunctionTool({
+  name: 'getPRStatus',
+  description: 'PR의 상태와 CI 체크 결과를 확인합니다.',
+  parameters: z.object({
+    repository: z.string().describe('저장소 (owner/repo 형식)'),
+    prNumber: z.number().describe('PR 번호'),
+  }),
+  execute: async ({ repository, prNumber }) => {
+    try {
+      const octokit = getOctokit()
+      const { owner, repo } = parseRepo(repository)
+
+      const { data: pr } = await octokit.pulls.get({ owner, repo, pull_number: prNumber })
+      const { data: checks } = await octokit.checks.listForRef({ owner, repo, ref: pr.head.sha })
+
+      const allChecksPassed = checks.check_runs.every(
+        check => check.conclusion === 'success' || check.conclusion === 'skipped'
+      )
+
+      return {
+        success: true,
+        state: pr.state,
+        mergeable: pr.mergeable,
+        mergeableState: pr.mergeable_state,
+        checksCompleted: checks.check_runs.every(c => c.status === 'completed'),
+        allChecksPassed,
+        headSha: pr.head.sha,
+      }
+    } catch (err) {
+      const error = err as { message?: string }
+      return { success: false, error: error.message || String(err) }
+    }
+  },
+})
+
+export const mergePRTool = new FunctionTool({
+  name: 'mergePR',
+  description: 'PR을 머지합니다.',
+  parameters: z.object({
+    repository: z.string().describe('저장소 (owner/repo 형식)'),
+    prNumber: z.number().describe('PR 번호'),
+    method: z.enum(['merge', 'squash', 'rebase']).optional().describe('머지 방법'),
+    commitTitle: z.string().optional().describe('커밋 제목'),
+    commitMessage: z.string().optional().describe('커밋 메시지'),
+  }),
+  execute: async ({ repository, prNumber, method = 'squash', commitTitle, commitMessage }) => {
+    try {
+      const octokit = getOctokit()
+      const { owner, repo } = parseRepo(repository)
+
+      const { data } = await octokit.pulls.merge({
+        owner, repo, pull_number: prNumber, merge_method: method,
+        commit_title: commitTitle, commit_message: commitMessage,
+      })
+
+      return { success: true, merged: data.merged, sha: data.sha, message: data.message }
+    } catch (err) {
+      const error = err as { message?: string }
+      return { success: false, error: error.message || String(err) }
+    }
+  },
+})
+
+export const waitForCITool = new FunctionTool({
+  name: 'waitForCI',
+  description: 'CI 체크가 완료될 때까지 대기합니다.',
+  parameters: z.object({
+    repository: z.string().describe('저장소 (owner/repo 형식)'),
+    ref: z.string().describe('체크할 커밋 SHA 또는 브랜치'),
+    timeout: z.number().optional().describe('최대 대기 시간 (초, 기본: 600)'),
+    interval: z.number().optional().describe('폴링 간격 (초, 기본: 30)'),
+  }),
+  execute: async ({ repository, ref, timeout = 600, interval = 30 }) => {
+    try {
+      const octokit = getOctokit()
+      const { owner, repo } = parseRepo(repository)
+
+      const startTime = Date.now()
+      const timeoutMs = timeout * 1000
+      const intervalMs = interval * 1000
+
+      while (Date.now() - startTime < timeoutMs) {
+        const { data: checks } = await octokit.checks.listForRef({ owner, repo, ref })
+        const allCompleted = checks.check_runs.every(c => c.status === 'completed')
+
+        if (allCompleted) {
+          const allPassed = checks.check_runs.every(
+            c => c.conclusion === 'success' || c.conclusion === 'skipped'
+          )
+          return { success: true, completed: true, passed: allPassed }
+        }
+
+        await new Promise(resolve => setTimeout(resolve, intervalMs))
+      }
+
+      return { success: true, completed: false, passed: false, error: '타임아웃' }
+    } catch (err) {
+      const error = err as { message?: string }
+      return { success: false, error: error.message || String(err) }
+    }
+  },
+})
+
+export const addCommentTool = new FunctionTool({
+  name: 'addComment',
+  description: 'PR 또는 이슈에 댓글을 추가합니다.',
+  parameters: z.object({
+    repository: z.string().describe('저장소 (owner/repo 형식)'),
+    issueNumber: z.number().describe('이슈/PR 번호'),
+    body: z.string().describe('댓글 내용'),
+  }),
+  execute: async ({ repository, issueNumber, body }) => {
+    try {
+      const octokit = getOctokit()
+      const { owner, repo } = parseRepo(repository)
+
+      const { data } = await octokit.issues.createComment({
+        owner, repo, issue_number: issueNumber, body,
+      })
+
+      return { success: true, commentId: data.id, commentUrl: data.html_url }
+    } catch (err) {
+      const error = err as { message?: string }
+      return { success: false, error: error.message || String(err) }
+    }
+  },
+})
+
+export const getWorkflowRunTool = new FunctionTool({
+  name: 'getWorkflowRun',
+  description: 'GitHub Actions 워크플로우 실행 상태를 조회합니다.',
+  parameters: z.object({
+    repository: z.string().describe('저장소 (owner/repo 형식)'),
+    runId: z.number().describe('워크플로우 실행 ID'),
+  }),
+  execute: async ({ repository, runId }) => {
+    try {
+      const octokit = getOctokit()
+      const { owner, repo } = parseRepo(repository)
+
+      const { data: run } = await octokit.actions.getWorkflowRun({ owner, repo, run_id: runId })
+
+      return {
+        success: true,
+        status: run.status,
+        conclusion: run.conclusion,
+        workflowName: run.name,
+        branch: run.head_branch,
+        commit: run.head_sha,
+        url: run.html_url,
+      }
+    } catch (err) {
+      const error = err as { message?: string }
+      return { success: false, error: error.message || String(err) }
+    }
+  },
+})
+
+export const deleteBranchTool = new FunctionTool({
+  name: 'deleteBranch',
+  description: '원격 브랜치를 삭제합니다.',
+  parameters: z.object({
+    repository: z.string().describe('저장소 (owner/repo 형식)'),
+    branch: z.string().describe('삭제할 브랜치'),
+  }),
+  execute: async ({ repository, branch }) => {
+    try {
+      const octokit = getOctokit()
+      const { owner, repo } = parseRepo(repository)
+
+      await octokit.git.deleteRef({ owner, repo, ref: `heads/${branch}` })
+      return { success: true, deleted: branch }
+    } catch (err) {
+      const error = err as { message?: string }
+      return { success: false, error: error.message || String(err) }
+    }
+  },
+})
+
+export const githubTools = [
+  createPRTool,
+  getPRStatusTool,
+  mergePRTool,
+  waitForCITool,
+  addCommentTool,
+  getWorkflowRunTool,
+  deleteBranchTool,
+]