first-tree 0.0.3 → 0.0.5

package/skills/first-tree/SKILL.md

@@ -6,8 +6,9 @@ description: Maintain the canonical `first-tree` skill and the thin `context-tre
 # First Tree
 
 Use this skill when the task depends on the exact behavior of the
-`context-tree` CLI or the installed `skills/first-tree/` payload that
-`context-tree init` ships to user repos.
+`context-tree` CLI or the installed `.agents/skills/first-tree/` and
+`.claude/skills/first-tree/` payloads that `context-tree init` ships to user
+repos.
 
 ## Source Of Truth
 
@@ -17,9 +18,9 @@ Use this skill when the task depends on the exact behavior of the
   repos.
 - `engine/` holds the canonical framework and CLI behavior.
 - `scripts/` holds maintenance helpers for validating and running the skill.
-- In maintainer docs, use `context-tree` for the CLI and `skills/first-tree/`
-  for the installed skill path so it is not confused with the `first-tree`
-  npm package.
+- In maintainer docs, use `context-tree` for the CLI, `skills/first-tree/` for
+  the bundled source path, and `.agents/skills/first-tree/` /
+  `.claude/skills/first-tree/` for installed user-repo paths.
 
 ## When To Read What
 
@@ -51,18 +52,22 @@ Use this skill when the task depends on the exact behavior of the
   thin CLI shell, not as a tree repo.
 - Keep command behavior, validator behavior, shipped assets, maintainer
   references, and package shell aligned.
-- If root README/AGENT/CI text explains something non-obvious, migrate that
+- If root README/AGENTS/CI text explains something non-obvious, migrate that
   information into `references/` and trim the root file back down.
 - If you change runtime assets or skill references, run `pnpm validate:skill`.
 
 ### Working In A User Tree Repo
 
-- `context-tree init` installs this skill into the user's repo and scaffolds
-  `NODE.md`, `AGENT.md`, and `members/NODE.md`.
+- `context-tree init` defaults to creating or reusing a sibling dedicated tree
+  repo when invoked from a source/workspace repo. Use `--here` to initialize
+  the current repo in place when you are already inside the tree repo.
+- `context-tree init` installs this skill into the target tree repo and
+  scaffolds `.agents/skills/first-tree/`, `.claude/skills/first-tree/`,
+  `NODE.md`, `AGENTS.md`, and `members/NODE.md`.
 - `context-tree upgrade` refreshes the installed skill from the copy bundled
   with the currently running `first-tree` package. To pick up a newer
   framework, run a newer package version first. It also migrates older repos
-  that still use `skills/first-tree-cli-framework/`.
+  that still use `skills/first-tree/` or `skills/first-tree-cli-framework/`.
 - The user's tree content lives outside the skill; the skill only carries the
   reusable framework payload plus maintenance guidance.
 - The tree still stores decisions, constraints, and ownership; execution detail
@@ -76,8 +81,11 @@ Use this skill when the task depends on the exact behavior of the
 - Keep decision knowledge in the tree and execution detail in source systems.
 - Keep the skill as the only canonical knowledge source. The root CLI/package
   shell must not become a second source of framework semantics.
+- Keep the CLI name written as `context-tree` in maintainer and user-facing
+  docs so it is not confused with the `first-tree` package that ships it.
 - Keep normal `init` / `upgrade` flows self-contained. They must work from the
-  skill bundled in the current package without cloning the source repo.
+  skill bundled in the current package without cloning the source repo or
+  relying on network access.
 - Make upgrade behavior explicit. If you change installed paths, update
   `references/upgrade-contract.md`, task text, and tests together.
 

package/skills/first-tree/assets/framework/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.1

package/skills/first-tree/assets/framework/examples/claude-code/README.md

@@ -6,9 +6,9 @@ Copy `settings.json` to your tree repo's `.claude/` directory:
 
 ```bash
 mkdir -p .claude
-cp skills/first-tree/assets/framework/examples/claude-code/settings.json .claude/settings.json
+cp .claude/skills/first-tree/assets/framework/examples/claude-code/settings.json .claude/settings.json
 ```
 
 ## What It Does
 
-The `SessionStart` hook runs `./skills/first-tree/assets/framework/helpers/inject-tree-context.sh` when a Claude Code session begins. This injects the root `NODE.md` content as additional context, giving the agent an overview of the tree structure before any task.
+The `SessionStart` hook runs `./.claude/skills/first-tree/assets/framework/helpers/inject-tree-context.sh` when a Claude Code session begins. This injects the root `NODE.md` content as additional context, giving the agent an overview of the tree structure before any task.

package/skills/first-tree/assets/framework/examples/claude-code/settings.json

@@ -5,7 +5,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "./skills/first-tree/assets/framework/helpers/inject-tree-context.sh"
+            "command": "./.claude/skills/first-tree/assets/framework/helpers/inject-tree-context.sh"
           }
         ]
       }

package/skills/first-tree/assets/framework/helpers/generate-codeowners.ts

@@ -205,7 +205,7 @@ export function generate(
       return 0;
     }
     console.log(
-      "CODEOWNERS is out-of-date. Run: npx tsx skills/first-tree/assets/framework/helpers/generate-codeowners.ts",
+      "CODEOWNERS is out-of-date. Run: npx tsx .agents/skills/first-tree/assets/framework/helpers/generate-codeowners.ts",
     );
     return 1;
   }

package/skills/first-tree/assets/framework/helpers/run-review.ts

@@ -8,7 +8,7 @@
  */
 
 import { execFileSync } from "node:child_process";
-import { readFileSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
@@ -17,15 +17,29 @@ const MAX_ATTEMPTS = 3;
 // Per-invocation budget cap. Worst case is $1.50 total (3 × $0.50),
 // though retries are cheap in practice due to cached context via --continue.
 const MAX_BUDGET_USD = 0.5;
+const AGENT_INSTRUCTIONS_PATHS = ["AGENTS.md", "AGENT.md"] as const;
+
+function resolveAgentInstructionsPath(): string {
+  for (const candidate of AGENT_INSTRUCTIONS_PATHS) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  throw new Error(
+    "Missing AGENTS.md in repo root (legacy AGENT.md is also accepted during migration).",
+  );
+}
 
 function buildPrompt(diffPath: string): string {
   const parts: string[] = [];
+  const agentInstructionsPath = resolveAgentInstructionsPath();
   const files: [string, string][] = [
-    ["AGENT.md", "AGENT.md"],
+    [agentInstructionsPath, agentInstructionsPath],
     ["Root NODE.md", "NODE.md"],
     [
       "Review Instructions",
-      "skills/first-tree/assets/framework/prompts/pr-review.md",
+      ".agents/skills/first-tree/assets/framework/prompts/pr-review.md",
     ],
   ];
   for (const [heading, path] of files) {

package/skills/first-tree/assets/framework/templates/{agent.md.template → agents.md.template}

@@ -13,7 +13,7 @@ You are working in a **Context Tree** — the living source of truth for decisio
 
 4. **Git-native tree structure.** Each node is a file; each domain is a directory. Soft links allow cross-references without the complexity of a full graph. History, ownership, and review follow Git conventions.
 
-See `skills/first-tree/references/principles.md` for detailed explanations and examples.
+See `.agents/skills/first-tree/references/principles.md` for detailed explanations and examples.
 
 ## Before Every Task
 
@@ -28,6 +28,7 @@ Do not skip this. The tree is already a compression of expensive knowledge — c
 
 - **Decide in the tree, execute in source systems.** If the task involves a decision (not just a bug fix), draft or update the relevant tree node before executing.
 - **The tree is not for execution details.** Function signatures, DB schemas, API endpoints, ad copy — those live in source systems. The tree captures the *why* and *how things connect*.
+- **Bring source repos in as additional working directories.** When you need to inspect or edit code, open the relevant source repositories alongside this tree instead of copying execution detail into the tree.
 - **Respect ownership.** Each node declares owners in its frontmatter. If your changes touch a domain you don't own, flag it — the owner needs to review.
 
 ## After Every Task
@@ -40,7 +41,7 @@ Ask yourself: **Does the tree need updating?**
 
 ## Reference
 
-For ownership rules, tree structure, and key files, see [NODE.md](NODE.md) and `skills/first-tree/references/ownership-and-naming.md`.
+For ownership rules, tree structure, and key files, see [NODE.md](NODE.md) and `.agents/skills/first-tree/references/ownership-and-naming.md`.
 <!-- END CONTEXT-TREE FRAMEWORK -->
 
 # Project-Specific Instructions

package/skills/first-tree/assets/framework/templates/members-domain.md.template

@@ -34,7 +34,7 @@ domains:
 ---
 ```
 
-See `skills/first-tree/assets/framework/templates/member-node.md.template` for a full scaffold.
+See `.agents/skills/first-tree/assets/framework/templates/member-node.md.template` for a full scaffold.
 
 ---
 

package/skills/first-tree/assets/framework/templates/root-node.md.template

@@ -5,9 +5,9 @@ owners: [<your-github-username>]
 
 # <Your Organization>
 
-<!-- PLACEHOLDER: Replace this with a description of your organization and what this tree captures. -->
+<!-- PLACEHOLDER: Replace this with a description of your organization and what this tree captures across your source repos and systems. -->
 
-The living source of truth for your organization. A structured knowledge base that agents and humans build and maintain together.
+The living source of truth for your organization. A structured knowledge base that agents and humans build and maintain together across one or more source repositories and systems.
 
 ---
 
@@ -29,10 +29,13 @@ The living source of truth for your organization. A structured knowledge base th
 
 ## Working with the Tree
 
-See [AGENT.md](AGENT.md) for agent instructions — the before/during/after workflow, ownership model, and tree maintenance.
+Keep decision context here. Keep implementation detail in the source repos this
+tree describes.
 
-See [about.md](skills/first-tree/references/about.md) for background — the problem, the idea, and who it's for.
+See [AGENTS.md](AGENTS.md) for agent instructions — the before/during/after workflow, ownership model, and tree maintenance.
+
+See [about.md](.agents/skills/first-tree/references/about.md) for background — the problem, the idea, and who it's for.
 
 See the installed framework documentation:
-- [principles.md](skills/first-tree/references/principles.md) — core principles with examples
-- [ownership-and-naming.md](skills/first-tree/references/ownership-and-naming.md) — node naming and ownership model
+- [principles.md](.agents/skills/first-tree/references/principles.md) — core principles with examples
+- [ownership-and-naming.md](.agents/skills/first-tree/references/ownership-and-naming.md) — node naming and ownership model

package/skills/first-tree/assets/framework/workflows/codeowners.yml

@@ -19,7 +19,7 @@ jobs:
         with:
           node-version: "22"
 
-      - run: npx tsx skills/first-tree/assets/framework/helpers/generate-codeowners.ts
+      - run: npx tsx .agents/skills/first-tree/assets/framework/helpers/generate-codeowners.ts
 
       - name: Commit if changed
         run: |

package/skills/first-tree/assets/framework/workflows/pr-review.yml

@@ -45,7 +45,7 @@ jobs:
           gh pr view "$PR_NUMBER" --json headRefOid -q .headRefOid > /tmp/pr-head-sha.txt
 
       - name: Run Claude review
-        run: npx tsx skills/first-tree/assets/framework/helpers/run-review.ts
+        run: npx tsx .agents/skills/first-tree/assets/framework/helpers/run-review.ts
 
       - name: Parse and post review
         run: |

package/skills/first-tree/engine/commands/init.ts

@@ -1 +1 @@
-export * from "#skill/engine/init.js";
+export { INIT_USAGE, parseInitArgs, runInitCli as runInit } from "#skill/engine/init.js";

package/skills/first-tree/engine/commands/upgrade.ts

@@ -1 +1 @@
-export * from "#skill/engine/upgrade.js";
+export { UPGRADE_USAGE, runUpgradeCli as runUpgrade } from "#skill/engine/upgrade.js";

package/skills/first-tree/engine/commands/verify.ts

@@ -1 +1 @@
-export * from "#skill/engine/verify.js";
+export { VERIFY_USAGE, runVerifyCli as runVerify } from "#skill/engine/verify.js";

package/skills/first-tree/engine/init.ts

@@ -1,9 +1,12 @@
+import { execFileSync } from "node:child_process";
 import {
   existsSync,
   mkdirSync,
+  readdirSync,
+  statSync,
   writeFileSync,
 } from "node:fs";
-import { dirname, join } from "node:path";
+import { dirname, join, relative, resolve } from "node:path";
 import { Repo } from "#skill/engine/repo.js";
 import { ONBOARDING_TEXT } from "#skill/engine/onboarding.js";
 import { evaluateAll } from "#skill/engine/rules/index.js";
@@ -14,9 +17,13 @@ import {
   resolveBundledPackageRoot,
 } from "#skill/engine/runtime/installer.js";
 import {
+  AGENT_INSTRUCTIONS_FILE,
+  AGENT_INSTRUCTIONS_TEMPLATE,
   FRAMEWORK_ASSET_ROOT,
   FRAMEWORK_VERSION,
   INSTALLED_PROGRESS,
+  LEGACY_AGENT_INSTRUCTIONS_FILE,
+  installedSkillRootsDisplay,
 } from "#skill/engine/runtime/asset-loader.js";
 
 /**
@@ -25,34 +32,88 @@ import {
  * all generated task text at once.
  */
 export const INTERACTIVE_TOOL = "AskUserQuestion";
+export const INIT_USAGE = `usage: context-tree init [--here] [--tree-name NAME] [--tree-path PATH]
 
-const TEMPLATE_MAP: [string, string][] = [
-  ["root-node.md.template", "NODE.md"],
-  ["agent.md.template", "AGENT.md"],
-  ["members-domain.md.template", "members/NODE.md"],
+By default, running \`context-tree init\` inside a source or workspace repo creates
+a sibling dedicated tree repo named \`<repo>-context\`.
+
+Options:
+  --here             Initialize the current repo in place
+  --tree-name NAME   Name the dedicated sibling tree repo to create
+  --tree-path PATH   Use an explicit tree repo path
+  --help             Show this help message
+`;
+
+interface TemplateTarget {
+  templateName: string;
+  targetPath: string;
+  skipIfExists?: string[];
+}
+
+const TEMPLATE_MAP: TemplateTarget[] = [
+  { templateName: "root-node.md.template", targetPath: "NODE.md" },
+  {
+    templateName: AGENT_INSTRUCTIONS_TEMPLATE,
+    targetPath: AGENT_INSTRUCTIONS_FILE,
+    skipIfExists: [AGENT_INSTRUCTIONS_FILE, LEGACY_AGENT_INSTRUCTIONS_FILE],
+  },
+  { templateName: "members-domain.md.template", targetPath: "members/NODE.md" },
 ];
 
+interface TaskListContext {
+  sourceRepoPath?: string;
+  dedicatedTreeRepo?: boolean;
+}
+
 function installSkill(source: string, target: string): void {
   copyCanonicalSkill(source, target);
   console.log(
-    "  Installed skills/first-tree/ from the bundled first-tree package",
+    `  Installed ${installedSkillRootsDisplay()} from the bundled first-tree package`,
   );
 }
 
 function renderTemplates(target: string): void {
   const frameworkDir = join(target, FRAMEWORK_ASSET_ROOT);
-  for (const [templateName, targetPath] of TEMPLATE_MAP) {
-    if (existsSync(join(target, targetPath))) {
-      console.log(`  Skipped ${targetPath} (already exists)`);
+  for (const { templateName, targetPath, skipIfExists } of TEMPLATE_MAP) {
+    const existingPaths = skipIfExists ?? [targetPath];
+    const existingPath = existingPaths.find((candidate) =>
+      existsSync(join(target, candidate)),
+    );
+
+    if (existingPath !== undefined) {
+      console.log(`  Skipped ${targetPath} (found existing ${existingPath})`);
     } else if (renderTemplateFile(frameworkDir, templateName, target, targetPath)) {
       console.log(`  Created ${targetPath}`);
     }
   }
 }
 
-export function formatTaskList(groups: RuleResult[]): string {
+export function formatTaskList(
+  groups: RuleResult[],
+  context?: TaskListContext,
+): string {
   const lines: string[] = [
     "# Context Tree Init\n",
+  ];
+
+  if (context?.dedicatedTreeRepo) {
+    lines.push(
+      "This repository is the dedicated Context Tree. Keep decisions, rationale," +
+        " cross-domain relationships, and ownership here; keep execution detail" +
+        " in your source repositories.",
+      "",
+    );
+    if (context.sourceRepoPath) {
+      lines.push(`**Bootstrap source repo:** \`${context.sourceRepoPath}\``, "");
+    }
+    lines.push(
+      "When you publish this tree repo, keep it in the same GitHub organization" +
+        " as the source repo unless you have a reason not to.",
+      "",
+    );
+  }
+
+  lines.push(
     "**Agent instructions:** Before starting work, analyze the full task list below and" +
       " identify all information you need from the user. Ask the user for their code" +
       " repositories or project directories so you can analyze the source yourself —" +
@@ -61,7 +122,7 @@ export function formatTaskList(groups: RuleResult[]): string {
       ` **${INTERACTIVE_TOOL}** tool with structured options — present selectable choices` +
       " (with label and description) so the user can pick instead of typing free-form" +
       ` answers. You may batch up to 4 questions per ${INTERACTIVE_TOOL} call.\n`,
-  ];
+  );
   for (const group of groups) {
     lines.push(`## ${group.group}`);
     for (const task of group.tasks) {
@@ -75,7 +136,9 @@ export function formatTaskList(groups: RuleResult[]): string {
   );
   lines.push(`- [ ] \`${FRAMEWORK_VERSION}\` exists`);
   lines.push("- [ ] Root NODE.md has valid frontmatter (title, owners)");
-  lines.push("- [ ] AGENT.md exists with framework markers");
+  lines.push(
+    `- [ ] \`${AGENT_INSTRUCTIONS_FILE}\` is the only agent instructions file and has framework markers`,
+  );
   lines.push("- [ ] `context-tree verify` passes with no errors");
   lines.push("- [ ] At least one member node exists");
   lines.push("");
@@ -99,19 +162,44 @@ export function writeProgress(repo: Repo, content: string): void {
 
 export interface InitOptions {
   sourceRoot?: string;
+  here?: boolean;
+  treeName?: string;
+  treePath?: string;
+  currentCwd?: string;
+  gitInitializer?: (root: string) => void;
 }
 
 export function runInit(repo?: Repo, options?: InitOptions): number {
-  const r = repo ?? new Repo();
-
-  if (!r.isGitRepo()) {
+  const sourceRepo = repo ?? new Repo();
+  const initTarget = resolveInitTarget(sourceRepo, options);
+  if (initTarget.ok === false) {
     console.error(
-      "Error: not a git repository. Initialize one first:\n  git init",
+      `Error: ${initTarget.message}`,
     );
     return 1;
   }
+  const r = initTarget.repo;
+  const taskListContext = initTarget.dedicatedTreeRepo
+    ? {
+        dedicatedTreeRepo: true,
+        sourceRepoPath: relativePathFrom(r.root, sourceRepo.root),
+      }
+    : undefined;
+
+  if (initTarget.dedicatedTreeRepo) {
+    console.log(
+      "Recommended workflow: keep the Context Tree in a dedicated repo separate" +
+        " from your source/workspace repo.",
+    );
+    console.log(`  Source repo: ${sourceRepo.root}`);
+    console.log(`  Tree repo:   ${r.root}`);
+    if (initTarget.createdGitRepo) {
+      console.log("  Initialized a new git repo for the tree.");
+    }
+    console.log();
+  }
 
-  if (!r.hasFramework()) {
+  if (!r.hasCurrentInstalledSkill()) {
     try {
       const sourceRoot = options?.sourceRoot ?? resolveBundledPackageRoot();
       console.log(
@@ -137,9 +225,191 @@ export function runInit(repo?: Repo, options?: InitOptions): number {
     return 0;
   }
 
-  const output = formatTaskList(groups);
+  const output = formatTaskList(groups, taskListContext);
   console.log(output);
   writeProgress(r, output);
   console.log(`Progress file written to ${r.preferredProgressPath()}`);
+  if (initTarget.dedicatedTreeRepo) {
+    console.log(
+      `Continue in ${relativePathFrom(sourceRepo.root, r.root)} and keep your source repos available as additional working directories when you populate the tree.`,
+    );
+  }
   return 0;
 }
+
+export interface ParsedInitArgs {
+  here?: boolean;
+  treeName?: string;
+  treePath?: string;
+}
+
+export function parseInitArgs(
+  args: string[],
+): ParsedInitArgs | { error: string } {
+  const parsed: ParsedInitArgs = {};
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    switch (arg) {
+      case "--here":
+        parsed.here = true;
+        break;
+      case "--tree-name": {
+        const value = args[index + 1];
+        if (!value) {
+          return { error: "Missing value for --tree-name" };
+        }
+        parsed.treeName = value;
+        index += 1;
+        break;
+      }
+      case "--tree-path": {
+        const value = args[index + 1];
+        if (!value) {
+          return { error: "Missing value for --tree-path" };
+        }
+        parsed.treePath = value;
+        index += 1;
+        break;
+      }
+      default:
+        return { error: `Unknown init option: ${arg}` };
+    }
+  }
+
+  if (parsed.here && parsed.treeName) {
+    return { error: "Cannot combine --here with --tree-name" };
+  }
+  if (parsed.here && parsed.treePath) {
+    return { error: "Cannot combine --here with --tree-path" };
+  }
+  if (parsed.treeName && parsed.treePath) {
+    return { error: "Cannot combine --tree-name with --tree-path" };
+  }
+
+  return parsed;
+}
+
+export function runInitCli(args: string[] = []): number {
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(INIT_USAGE);
+    return 0;
+  }
+
+  const parsed = parseInitArgs(args);
+  if ("error" in parsed) {
+    console.error(parsed.error);
+    console.log(INIT_USAGE);
+    return 1;
+  }
+
+  return runInit(undefined, parsed);
+}
+
+interface ResolvedInitTarget {
+  ok: true;
+  createdGitRepo: boolean;
+  dedicatedTreeRepo: boolean;
+  repo: Repo;
+}
+
+interface FailedInitTarget {
+  message: string;
+  ok: false;
+}
+
+function resolveInitTarget(
+  sourceRepo: Repo,
+  options?: InitOptions,
+): FailedInitTarget | ResolvedInitTarget {
+  if (!sourceRepo.isGitRepo()) {
+    return {
+      ok: false,
+      message:
+        "not a git repository. Run this from your source/workspace repo, or create a dedicated tree repo first:\n  git init\n  context-tree init --here",
+    };
+  }
+
+  const targetRoot = determineTargetRoot(sourceRepo, options);
+  const dedicatedTreeRepo = targetRoot !== sourceRepo.root;
+  let createdGitRepo = false;
+  try {
+    createdGitRepo = ensureGitRepo(targetRoot, options?.gitInitializer);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "unknown error";
+    return {
+      ok: false,
+      message,
+    };
+  }
+
+  return {
+    ok: true,
+    createdGitRepo,
+    dedicatedTreeRepo,
+    repo: new Repo(targetRoot),
+  };
+}
+
+function determineTargetRoot(sourceRepo: Repo, options?: InitOptions): string {
+  if (options?.treePath) {
+    return resolve(options.currentCwd ?? process.cwd(), options.treePath);
+  }
+
+  if (options?.here) {
+    return sourceRepo.root;
+  }
+
+  if (options?.treeName) {
+    return join(dirname(sourceRepo.root), options.treeName);
+  }
+
+  if (
+    sourceRepo.looksLikeTreeRepo()
+    || sourceRepo.isLikelyEmptyRepo()
+    || !sourceRepo.isLikelySourceRepo()
+  ) {
+    return sourceRepo.root;
+  }
+
+  return join(dirname(sourceRepo.root), `${sourceRepo.repoName()}-context`);
+}
+
+function ensureGitRepo(
+  targetRoot: string,
+  gitInitializer?: (root: string) => void,
+): boolean {
+  if (existsSync(targetRoot)) {
+    if (!statSync(targetRoot).isDirectory()) {
+      throw new Error(`Target path is not a directory: ${targetRoot}`);
+    }
+    if (new Repo(targetRoot).isGitRepo()) {
+      return false;
+    }
+    if (readdirSync(targetRoot).length !== 0) {
+      throw new Error(
+        `Target path exists and is not a git repository: ${targetRoot}. Run \`git init\` there first or choose a different tree path.`,
+      );
+    }
+  } else {
+    mkdirSync(targetRoot, { recursive: true });
+  }
+
+  (gitInitializer ?? defaultGitInitializer)(targetRoot);
+  return true;
+}
+
+function defaultGitInitializer(root: string): void {
+  execFileSync("git", ["init"], {
+    cwd: root,
+    stdio: "ignore",
+  });
+}
+
+function relativePathFrom(from: string, to: string): string {
+  const rel = relative(from, to);
+  if (rel === "") {
+    return ".";
+  }
+  return rel.startsWith("..") ? rel : `./${rel}`;
+}