vibe-weaver 1.0.0

package/src/tools/git.ts

@@ -0,0 +1,498 @@
+/**
+ * Git tools for Vibe-Weaver CLI
+ * Handles local git operations and GitHub integration
+ */
+
+import simpleGit, { SimpleGit, LogResult, StatusResult } from 'simple-git';
+import chalk from 'chalk';
+import { getGithubToken } from '../auth/index.js';
+import { getSupabaseUrl } from '../config/index.js';
+
+export interface GitStatus {
+  current: string | null;
+  tracking: string | null;
+  ahead: number;
+  behind: number;
+  staged: string[];
+  modified: string[];
+  untracked: string[];
+  conflicted: string[];
+}
+
+export interface GitCommitResult {
+  success: boolean;
+  commitSha?: string;
+  message?: string;
+  files?: string[];
+  error?: string;
+}
+
+export interface GitLogEntry {
+  hash: string;
+  date: string;
+  message: string;
+  author_name: string;
+  author_email: string;
+}
+
+/**
+ * Get a git instance for a directory
+ */
+export function getGit(cwd: string = process.cwd()): SimpleGit {
+  return simpleGit(cwd);
+}
+
+/**
+ * Get the current git status
+ */
+export async function getStatus(cwd: string = process.cwd()): Promise<GitStatus> {
+  const git = getGit(cwd);
+  const status = await git.status();
+  
+  return {
+    current: status.current,
+    tracking: status.tracking,
+    ahead: status.ahead,
+    behind: status.behind,
+    staged: status.staged,
+    modified: status.modified,
+    untracked: status.not_added,
+    conflicted: status.conflicted
+  };
+}
+
+/**
+ * Get the current branch name
+ */
+export async function getBranch(cwd: string = process.cwd()): Promise<string> {
+  const git = getGit(cwd);
+  const branchSummary = await git.branch();
+  return branchSummary.current;
+}
+
+/**
+ * Get recent commit history
+ */
+export async function getLog(cwd: string = process.cwd(), maxCount: number = 10): Promise<GitLogEntry[]> {
+  const git = getGit(cwd);
+  const log = await git.log({ maxCount });
+  
+  return log.all.map(entry => ({
+    hash: entry.hash,
+    date: entry.date,
+    message: entry.message,
+    author_name: entry.author_name,
+    author_email: entry.author_email
+  }));
+}
+
+/**
+ * Stage files for commit
+ */
+export async function stage(files: string | string[], cwd: string = process.cwd()): Promise<void> {
+  const git = getGit(cwd);
+  await git.add(files);
+}
+
+/**
+ * Stage all changes
+ */
+export async function stageAll(cwd: string = process.cwd()): Promise<void> {
+  const git = getGit(cwd);
+  await git.add('.');
+}
+
+/**
+ * Commit changes with a message
+ */
+export async function commit(message: string, cwd: string = process.cwd()): Promise<GitCommitResult> {
+  const git = getGit(cwd);
+  
+  try {
+    const result = await git.commit(message);
+    
+    return {
+      success: true,
+      commitSha: result.commit,
+      message: result.summary.changes + ' file(s) changed'
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+/**
+ * Commit all changes with a conventional commit message
+ */
+export async function commitAll(message: string, cwd: string = process.cwd()): Promise<GitCommitResult> {
+  await stageAll(cwd);
+  return commit(message, cwd);
+}
+
+/**
+ * Push changes to remote
+ */
+export async function push(options: { remote?: string; branch?: string; force?: boolean } = {}, cwd: string = process.cwd()): Promise<GitCommitResult> {
+  const git = getGit(cwd);
+  
+  try {
+    const result = await git.push(options.remote || 'origin', options.branch || 'HEAD', {
+      '--force': options.force || false
+    });
+    
+    return {
+      success: true,
+      commitSha: result.pushed[0]?.hash,
+      message: 'Push successful'
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+/**
+ * Pull changes from remote
+ */
+export async function pull(options: { remote?: string; branch?: string } = {}, cwd: string = process.cwd()): Promise<GitCommitResult> {
+  const git = getGit(cwd);
+  
+  try {
+    const result = await git.pull(options.remote || 'origin', options.branch || 'HEAD');
+    
+    return {
+      success: true,
+      message: 'Pull successful'
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+/**
+ * Create a new branch
+ */
+export async function createBranch(branchName: string, options: { checkout?: boolean } = {}, cwd: string = process.cwd()): Promise<GitCommitResult> {
+  const git = getGit(cwd);
+  
+  try {
+    if (options.checkout) {
+      await git.checkoutLocalBranch(branchName);
+    } else {
+      await git.branch([branchName]);
+    }
+    
+    return {
+      success: true,
+      message: `Branch ${branchName} created`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+/**
+ * Checkout a branch
+ */
+export async function checkout(branchName: string, cwd: string = process.cwd()): Promise<GitCommitResult> {
+  const git = getGit(cwd);
+  
+  try {
+    await git.checkout(branchName);
+    
+    return {
+      success: true,
+      message: `Switched to branch ${branchName}`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+/**
+ * Get the diff between commits, branches, or working tree
+ */
+export async function getDiff(options: { staged?: boolean; from?: string; to?: string } = {}, cwd: string = process.cwd()): Promise<string> {
+  const git = getGit(cwd);
+  
+  if (options.staged) {
+    return git.diff(['--staged']);
+  }
+  
+  if (options.from && options.to) {
+    return git.diff([options.from, options.to]);
+  }
+  
+  return git.diff();
+}
+
+/**
+ * Check if a directory is a git repository
+ */
+export async function isRepo(cwd: string = process.cwd()): Promise<boolean> {
+  const git = getGit(cwd);
+  return git.checkIsRepo();
+}
+
+/**
+ * Initialize a new git repository
+ */
+export async function init(cwd: string = process.cwd()): Promise<GitCommitResult> {
+  const git = getGit(cwd);
+  
+  try {
+    await git.init();
+    
+    return {
+      success: true,
+      message: 'Git repository initialized'
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+/**
+ * Get the remote URL
+ */
+export async function getRemote(cwd: string = process.cwd()): Promise<string | null> {
+  const git = getGit(cwd);
+  const remotes = await git.getRemotes(true);
+  
+  const origin = remotes.find(r => r.name === 'origin');
+  return origin?.refs.fetch || null;
+}
+
+// GitHub-specific operations via the platform's edge function
+
+/**
+ * Call the github-ai-sync edge function
+ */
+async function callGithubSync(action: string, params: Record<string, any>): Promise<any> {
+  const apiKey = await getGithubToken();
+  if (!apiKey) {
+    throw new Error('GitHub token not configured. Run "vibe-weaver login --github" first.');
+  }
+  
+  const supabaseUrl = getSupabaseUrl();
+  const endpoint = `${supabaseUrl}/functions/v1/github-ai-sync`;
+  
+  const response = await fetch(endpoint, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      action,
+      token: apiKey,
+      ...params
+    })
+  });
+  
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+    throw new Error(`GitHub API error: ${error.error || error.message}`);
+  }
+  
+  return response.json();
+}
+
+/**
+ * Commit files via GitHub API
+ */
+export async function commitFilesToGithub(options: {
+  owner: string;
+  repo: string;
+  branch: string;
+  files: { path: string; content: string; message: string }[];
+  commitMessage: string;
+}): Promise<GitCommitResult> {
+  try {
+    const result = await callGithubSync('commit_files', options);
+    
+    return {
+      success: true,
+      commitSha: result.commitSha,
+      message: `Committed ${result.files?.length || 0} file(s) to ${options.branch}`,
+      files: result.files
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+/**
+ * Create a branch via GitHub API
+ */
+export async function createBranchOnGithub(options: {
+  owner: string;
+  repo: string;
+  newBranch: string;
+  fromBranch: string;
+}): Promise<GitCommitResult> {
+  try {
+    const result = await callGithubSync('create_branch', options);
+    
+    return {
+      success: true,
+      commitSha: result.sha,
+      message: `Created branch ${options.newBranch} from ${options.fromBranch}`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+/**
+ * Create a pull request via GitHub API
+ */
+export async function createPullRequestOnGithub(options: {
+  owner: string;
+  repo: string;
+  title: string;
+  body: string;
+  head: string;
+  base: string;
+}): Promise<{ success: boolean; prNumber?: number; prUrl?: string; error?: string }> {
+  try {
+    const result = await callGithubSync('create_pr', options);
+    
+    return {
+      success: true,
+      prNumber: result.prNumber,
+      prUrl: result.prUrl
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+/**
+ * Full PR workflow: create branch, commit changes, open PR
+ */
+export async function fullPRWorkflow(options: {
+  owner: string;
+  repo: string;
+  branchName: string;
+  baseBranch: string;
+  files: { path: string; content: string; message: string }[];
+  commitMessage: string;
+  prTitle: string;
+  prBody: string;
+}): Promise<{
+  success: boolean;
+  branch?: string;
+  commitSha?: string;
+  prUrl?: string;
+  prNumber?: number;
+  error?: string;
+}> {
+  console.log(chalk.blue('\n=== GitHub PR Workflow ==='));
+  
+  // Step 1: Create branch
+  console.log(chalk.gray('1. Creating branch...'));
+  const branchResult = await createBranchOnGithub({
+    owner: options.owner,
+    repo: options.repo,
+    newBranch: options.branchName,
+    fromBranch: options.baseBranch
+  });
+  
+  if (!branchResult.success) {
+    return { success: false, error: `Failed to create branch: ${branchResult.error}` };
+  }
+  
+  console.log(chalk.green(`   ✓ Branch ${options.branchName} created`));
+  
+  // Step 2: Commit files
+  console.log(chalk.gray('2. Committing files...'));
+  const commitResult = await commitFilesToGithub({
+    owner: options.owner,
+    repo: options.repo,
+    branch: options.branchName,
+    files: options.files,
+    commitMessage: options.commitMessage
+  });
+  
+  if (!commitResult.success) {
+    return { success: false, error: `Failed to commit: ${commitResult.error}` };
+  }
+  
+  console.log(chalk.green(`   ✓ Committed ${commitResult.files?.length || 0} file(s)`));
+  
+  // Step 3: Create PR
+  console.log(chalk.gray('3. Creating pull request...'));
+  const prResult = await createPullRequestOnGithub({
+    owner: options.owner,
+    repo: options.repo,
+    title: options.prTitle,
+    body: options.prBody,
+    head: options.branchName,
+    base: options.baseBranch
+  });
+  
+  if (!prResult.success) {
+    return { success: false, error: `Failed to create PR: ${prResult.error}` };
+  }
+  
+  console.log(chalk.green(`   ✓ PR created: ${prResult.prUrl}`));
+  console.log(chalk.blue('===========================\n'));
+  
+  return {
+    success: true,
+    branch: options.branchName,
+    commitSha: commitResult.commitSha,
+    prUrl: prResult.prUrl,
+    prNumber: prResult.prNumber
+  };
+}
+
+export default {
+  getGit,
+  getStatus,
+  getBranch,
+  getLog,
+  stage,
+  stageAll,
+  commit,
+  commitAll,
+  push,
+  pull,
+  createBranch,
+  checkout,
+  getDiff,
+  isRepo,
+  init,
+  getRemote,
+  commitFilesToGithub,
+  createBranchOnGithub,
+  createPullRequestOnGithub,
+  fullPRWorkflow
+};