createCommit()

const fs = await import('node:fs/promises');

const result = await repo
  .createCommit({
    targetBranch: 'main',
    commitMessage: 'Update dashboard docs',
    expectedHeadSha: currentHeadSha, // optional safety check
    author: { name: 'Docs Bot', email: 'docs@example.com' },
  })
  .addFileFromString('docs/changelog.md', '# v2.1.0\n- refresh docs\n')
  .addFile('public/logo.svg', await fs.readFile('assets/logo.svg'))
  .deletePath('docs/legacy.txt')
  .send();

console.log(result.commitSha);
console.log(result.refUpdate.newSha);
console.log(result.refUpdate.oldSha);

result = await (
    repo.create_commit(
        target_branch="main",
        commit_message="Update dashboard docs",
        author={"name": "Docs Bot", "email": "docs@example.com"},
    )
    .add_file_from_string("docs/changelog.md", "# v2.1.0\n- refresh docs\n")
    .add_file("public/logo.svg", b"<svg/>")
    .delete_path("docs/legacy.txt")
    .send()
)

print(result["commit_sha"])
print(result["ref_update"]["new_sha"])
print(result["ref_update"]["old_sha"])

// Build a commit and add files
builder, err := repo.CreateCommit(storage.CommitOptions{
	TargetBranch:  "main",
	CommitMessage: "Update dashboard docs",
	Author:        storage.CommitSignature{Name: "Docs Bot", Email: "docs@example.com"},
})

// Add and delete files, then send the commit
result, err := builder.
	AddFileFromString("docs/changelog.md", "# v2.1.0\n- refresh docs\n", nil).
	AddFile("public/logo.svg", bytes.NewReader([]byte("<svg/>")), nil).
	DeletePath("docs/legacy.txt").
	Send(context.Background())

// Inspect the result
fmt.Println(result.CommitSHA)
fmt.Println(result.RefUpdate.NewSHA)
fmt.Println(result.RefUpdate.OldSHA)

import { createReadStream } from 'node:fs';

// Simplest approach: Node.js ReadableStream
await repo
  .createCommit({
    targetBranch: 'assets',
    expectedHeadSha: 'abc123...',
    commitMessage: 'Upload latest design bundle',
    author: { name: 'Assets Uploader', email: 'assets@example.com' },
  })
  .addFile('assets/design-kit.zip', createReadStream('/tmp/large-file.zip'))
  .send();

// Alternative: Async generator for custom chunking
async function* fileChunks() {
  const fs = await import('node:fs/promises');
  const file = await fs.open('/tmp/large-file.zip', 'r');
  const chunkSize = 1024 * 1024; // 1MB chunks

  try {
    while (true) {
      const buffer = Buffer.alloc(chunkSize);
      const { bytesRead } = await file.read(buffer, 0, chunkSize);
      if (bytesRead === 0) break;
      yield buffer.subarray(0, bytesRead);
    }
  } finally {
    await file.close();
  }
}

await repo
  .createCommit({
    targetBranch: 'assets',
    commitMessage: 'Upload with custom chunking',
    author: { name: 'Assets Uploader', email: 'assets@example.com' },
  })
  .addFile('assets/design-kit.zip', fileChunks())
  .send();

# Async generator for streaming files in chunks
async def file_chunks():
    """Generate file chunks asynchronously."""
    with open("/tmp/large-file.zip", "rb") as f:
        while chunk := f.read(1024 * 1024):  # Read 1MB at a time
            yield chunk

result = await (
    repo.create_commit(
        target_branch="assets",
        expected_head_sha="abc123...",
        commit_message="Upload latest design bundle",
        author={"name": "Assets Uploader", "email": "assets@example.com"},
    )
    .add_file("assets/design-kit.zip", file_chunks())
    .send()
)

// Stream a large file without loading it into memory
file, err := os.Open("/tmp/large-file.zip")
defer file.Close()

// Create a commit and attach the stream
builder, err := repo.CreateCommit(storage.CommitOptions{
	TargetBranch:  "assets",
	CommitMessage: "Upload latest design bundle",
	Author:        storage.CommitSignature{Name: "Assets Uploader", Email: "assets@example.com"},
})

_, err = builder.AddFile("assets/design-kit.zip", file, nil).Send(context.Background())