Repo Transplant's Question to Claude Code: How to Find Features with One URL and One Sentence

When bringing code from another project into your own, the hardest part is finding "which feature is where." If you pick the wrong search keywords, you miss relevant files entirely. If you search too broadly, noise overwhelms signal. hs-hui released repo-transplant on October 31. A tool that takes a GitHub URL and one sentence, then locates and rebuilds features from existing code. This article is a record of reading the original text and repository documentation, then reproducing the process of finding features by URL and sentence with a local example. We did not build repo-transplant itself or run it connected to Claude Code.

What "URL + one sentence" means

The original text introduces repo-transplant as "give Claude Code a GitHub URL + sentence to find/rebuild features." When you provide the repository URL, Claude Code explores that repository and interprets the intent of the sentence you provide to locate relevant features.

Image: Screenshot from hs-hui/repo-transplant official repository.

This design means two things. First, you do not need to define search keywords yourself. You convey intent with a natural language sentence like "bring the login feature." Second, Claude Code explores the source repository's structure directly, so it is not bound by file names or folder structures.

The three stages of feature finding

The work repo-transplant performs can be divided into three stages.

First, repository cloning. The repository specified by URL is copied locally. This step can be completed with a single Git command, but repo-transplant checks the repository size, branches, and file count first before cloning with appropriate options.

Second, intent interpretation. The sentence you provide is analyzed to infer what feature is needed. "Password reset" could include sub-features such as email sending, token generation, and expiration validation.

Third, feature mapping. Relevant code is located in the cloned repository and proposed in a form applicable to your target project.

A small example reproduced in Node.js

CodeBridge implemented a small example of repo-transplant's core flow in Node.js. This is not a reproduction of repo-transplant's actual implementation, but only shows the flow: URL input → clone → search → suggestion.

import { execSync } from "node:child_process";
import fs from "node:fs";
import path from "node:path";

async function transplant(url, intent) {
  const cloneDir = path.join("/tmp", `transplant-${Date.now()}`);

  // Step 1: Clone the repository
  console.log(`[step 1] cloning ${url}`);
  execSync(`git clone --depth 1 ${JSON.stringify(url)} ${cloneDir}`, {
    stdio: "inherit"
  });

  // Step 2: Search for files matching the intent
  console.log(`[step 2] searching for: ${intent}`);
  const keywords = intent.split(/\s+/).filter((w) => w.length > 2);
  const files = execSync(
    `cd ${cloneDir} && grep -rl --include='*.js' --include='*.ts' --include='*.py' ${JSON.stringify(keywords.join("|"))} 2>/dev/null || true`,
    { encoding: "utf8" }
  ).trim().split("\n").filter(Boolean);

  // Step 3: Suggest relevant files
  console.log(`[step 3] found ${files.length} candidates:`);
  for (const file of files.slice(0, 5)) {
    const relPath = path.relative(cloneDir, file).replace(/^\/+/, "");
    console.log(`  → ${relPath}`);
  }

  // Cleanup
  fs.rmSync(cloneDir, { recursive: true, force: true });
  return files.slice(0, 5);
}

export { transplant };

This example does not copy repo-transplant's implementation verbatim. It only shows the flow: URL input → Git clone → keyword search → file suggestion. The actual repo-transplant can interpret intent more sophisticatedly using Claude Code's LLM inference.

Questions to check before adopting repo-transplant

Summarizing the checklist from repo-transplant's documentation:

Constraints before adoption

repo-transplant does not include a model provider by default. It assumes Claude Code's inference capability, so search quality may vary depending on the model. The original text emphasizes the advantage of starting simply with a URL and one sentence, but search accuracy may drop for large repositories or complex projects.

Feature mapping accuracy, large repository processing time, and private repository support are not measured in this article. In particular, "one sentence" does not accurately interpret all intent, and search result quality depends on the model and repository structure.

What to learn from repo-transplant is not the URL input method or Git clone command. It is changing feature finding from keyword sorting to natural language intent delivery. When bringing code from another project next time, try summarizing "what you want to get" in one sentence before the search term.

The paid course below covers verification and constraint design of AI coding harnesses including Claude Code. It is not a course providing repo-transplant usage or reproduction of this experiment; the link is a promotional link.