first-tree 0.0.7 → 0.0.8

package/dist/publish-D0crNDjz.js

@@ -0,0 +1,504 @@
+import { C as SKILL_ROOT, c as CLAUDE_INSTRUCTIONS_FILE, l as CLAUDE_SKILL_ROOT, n as Repo, r as AGENT_INSTRUCTIONS_FILE } from "./repo-BeVpMoHi.js";
+import { t as readBootstrapState } from "./bootstrap-YRjfHJp7.js";
+import { existsSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { dirname, isAbsolute, join, normalize, resolve } from "node:path";
+//#region skills/first-tree/engine/publish.ts
+const PUBLISH_USAGE = `usage: context-tree publish [--open-pr] [--tree-path PATH] [--source-repo PATH] [--submodule-path PATH] [--source-remote NAME]
+
+Run this from the dedicated tree repo after \`context-tree init\`. The command
+creates or reuses the GitHub \`*-context\` repo, pushes the current tree
+commit, adds that repo back to the source/workspace repo as a git submodule,
+and prepares the source-repo branch.
+
+Options:
+  --open-pr               Open a PR in the source/workspace repo after pushing the branch
+  --tree-path PATH        Publish a tree repo from another working directory
+  --source-repo PATH      Explicit source/workspace repo path when it cannot be inferred
+  --submodule-path PATH   Path to use inside the source/workspace repo (default: tree repo name)
+  --source-remote NAME    Source/workspace repo remote to mirror on GitHub (default: origin)
+  --help                  Show this help message
+`;
+function defaultCommandRunner(command, args, options) {
+	try {
+		return execFileSync(command, args, {
+			cwd: options.cwd,
+			encoding: "utf-8",
+			env: {
+				...process.env,
+				GIT_TERMINAL_PROMPT: "0"
+			},
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		}).trim();
+	} catch (err) {
+		const message = err instanceof Error ? err.message : "unknown error";
+		throw new Error(`Command failed in ${options.cwd}: ${command} ${args.join(" ")}\n${message}`);
+	}
+}
+function commandSucceeds(runner, command, args, cwd) {
+	try {
+		runner(command, args, { cwd });
+		return true;
+	} catch {
+		return false;
+	}
+}
+function parseGitHubRemote(url) {
+	if (url.startsWith("https://") || url.startsWith("http://")) try {
+		const parsed = new URL(url);
+		if (parsed.hostname !== "github.com") return null;
+		const parts = parsed.pathname.replace(/^\/+/, "").replace(/\.git$/, "").split("/");
+		if (parts.length !== 2 || parts.some((part) => part.trim() === "")) return null;
+		return {
+			cloneStyle: "https",
+			owner: parts[0],
+			repo: parts[1],
+			slug: `${parts[0]}/${parts[1]}`
+		};
+	} catch {
+		return null;
+	}
+	if (url.startsWith("ssh://")) try {
+		const parsed = new URL(url);
+		if (parsed.hostname !== "github.com") return null;
+		const parts = parsed.pathname.replace(/^\/+/, "").replace(/\.git$/, "").split("/");
+		if (parts.length !== 2 || parts.some((part) => part.trim() === "")) return null;
+		return {
+			cloneStyle: "ssh",
+			owner: parts[0],
+			repo: parts[1],
+			slug: `${parts[0]}/${parts[1]}`
+		};
+	} catch {
+		return null;
+	}
+	const scpMatch = url.match(/^git@github\.com:(.+?)\/(.+?)(?:\.git)?$/);
+	if (scpMatch === null) return null;
+	return {
+		cloneStyle: "ssh",
+		owner: scpMatch[1],
+		repo: scpMatch[2],
+		slug: `${scpMatch[1]}/${scpMatch[2]}`
+	};
+}
+function visibilityFlag(visibility) {
+	switch (visibility) {
+		case "internal": return "--internal";
+		case "private": return "--private";
+		default: return "--public";
+	}
+}
+function buildGitHubCloneUrl(slug, cloneStyle) {
+	if (cloneStyle === "ssh") return `git@github.com:${slug}.git`;
+	return `https://github.com/${slug}.git`;
+}
+function readGitHubRepoMetadata(runner, slug, cwd) {
+	const raw = runner("gh", [
+		"repo",
+		"view",
+		slug,
+		"--json",
+		"defaultBranchRef,nameWithOwner,visibility"
+	], { cwd });
+	const parsed = JSON.parse(raw);
+	const defaultBranch = parsed.defaultBranchRef?.name;
+	const nameWithOwner = parsed.nameWithOwner;
+	const visibility = parsed.visibility?.toLowerCase();
+	if (typeof defaultBranch !== "string" || typeof nameWithOwner !== "string" || visibility !== "internal" && visibility !== "private" && visibility !== "public") throw new Error(`Could not read GitHub metadata for ${slug}.`);
+	return {
+		defaultBranch,
+		nameWithOwner,
+		visibility
+	};
+}
+function readCurrentBranch(runner, root) {
+	return runner("git", ["branch", "--show-current"], { cwd: root }).trim();
+}
+function hasCommit(runner, root) {
+	return commandSucceeds(runner, "git", [
+		"rev-parse",
+		"--verify",
+		"HEAD"
+	], root);
+}
+function hasIndexedChanges(runner, root, paths) {
+	const args = [
+		"diff",
+		"--cached",
+		"--quiet"
+	];
+	if (paths && paths.length > 0) args.push("--", ...paths);
+	return !commandSucceeds(runner, "git", args, root);
+}
+function commitTreeState(runner, treeRepo) {
+	const hadCommit = hasCommit(runner, treeRepo.root);
+	runner("git", ["add", "-A"], { cwd: treeRepo.root });
+	if (!hasIndexedChanges(runner, treeRepo.root)) return false;
+	runner("git", [
+		"commit",
+		"-m",
+		hadCommit ? "chore: update context tree" : "chore: bootstrap context tree"
+	], { cwd: treeRepo.root });
+	return true;
+}
+function resolveSourceRepoRoot(treeRepo, options) {
+	const cwd = options?.currentCwd ?? process.cwd();
+	if (options?.sourceRepoPath) return resolve(cwd, options.sourceRepoPath);
+	const bootstrap = readBootstrapState(treeRepo.root);
+	if (bootstrap !== null) return resolve(treeRepo.root, bootstrap.sourceRepoPath);
+	if (treeRepo.repoName().endsWith("-context")) return join(dirname(treeRepo.root), treeRepo.repoName().slice(0, -8));
+	return null;
+}
+function normalizeSubmodulePath(input) {
+	if (input.trim() === "") return null;
+	if (isAbsolute(input)) return null;
+	const normalized = normalize(input).replaceAll("\\", "/");
+	if (normalized === "." || normalized === "" || normalized.startsWith("../") || normalized.includes("/../")) return null;
+	return normalized;
+}
+function getGitRemoteUrl(runner, root, remote) {
+	try {
+		return runner("git", [
+			"remote",
+			"get-url",
+			remote
+		], { cwd: root }).trim();
+	} catch {
+		return null;
+	}
+}
+function localBranchExists(runner, root, branch) {
+	return commandSucceeds(runner, "git", [
+		"rev-parse",
+		"--verify",
+		`refs/heads/${branch}`
+	], root);
+}
+function remoteTrackingBranchExists(runner, root, remote, branch) {
+	return commandSucceeds(runner, "git", [
+		"rev-parse",
+		"--verify",
+		`refs/remotes/${remote}/${branch}`
+	], root);
+}
+function buildPublishBranchName(treeRepoName) {
+	return `chore/connect-${treeRepoName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "")}`;
+}
+function ensureSourceBranch(runner, sourceRepo, sourceRemote, defaultBranch, treeRepoName) {
+	const branch = buildPublishBranchName(treeRepoName);
+	if (readCurrentBranch(runner, sourceRepo.root) === branch) return branch;
+	if (localBranchExists(runner, sourceRepo.root, branch)) {
+		runner("git", ["switch", branch], { cwd: sourceRepo.root });
+		return branch;
+	}
+	if (!remoteTrackingBranchExists(runner, sourceRepo.root, sourceRemote, defaultBranch)) runner("git", [
+		"fetch",
+		sourceRemote,
+		defaultBranch
+	], { cwd: sourceRepo.root });
+	if (remoteTrackingBranchExists(runner, sourceRepo.root, sourceRemote, defaultBranch)) {
+		runner("git", [
+			"switch",
+			"-c",
+			branch,
+			"--track",
+			`${sourceRemote}/${defaultBranch}`
+		], { cwd: sourceRepo.root });
+		return branch;
+	}
+	runner("git", [
+		"switch",
+		"-c",
+		branch
+	], { cwd: sourceRepo.root });
+	return branch;
+}
+function isTrackedSubmodule(runner, sourceRoot, submodulePath) {
+	try {
+		return runner("git", [
+			"ls-files",
+			"--stage",
+			"--",
+			submodulePath
+		], { cwd: sourceRoot }).split(/\r?\n/).some((line) => line.startsWith("160000 "));
+	} catch {
+		return false;
+	}
+}
+function ensureSubmodule(runner, sourceRepo, submodulePath, remoteUrl) {
+	if (isTrackedSubmodule(runner, sourceRepo.root, submodulePath)) {
+		runner("git", [
+			"submodule",
+			"set-url",
+			"--",
+			submodulePath,
+			remoteUrl
+		], { cwd: sourceRepo.root });
+		runner("git", [
+			"submodule",
+			"sync",
+			"--",
+			submodulePath
+		], { cwd: sourceRepo.root });
+		runner("git", [
+			"submodule",
+			"update",
+			"--init",
+			"--",
+			submodulePath
+		], { cwd: sourceRepo.root });
+		return "updated";
+	}
+	if (existsSync(join(sourceRepo.root, submodulePath))) throw new Error(`Cannot add the submodule at ${submodulePath} because that path already exists in the source/workspace repo.`);
+	runner("git", [
+		"submodule",
+		"add",
+		remoteUrl,
+		submodulePath
+	], { cwd: sourceRepo.root });
+	return "added";
+}
+function commitSourceIntegration(runner, sourceRepo, submodulePath, treeRepoName) {
+	const managedPaths = [
+		...[
+			SKILL_ROOT,
+			CLAUDE_SKILL_ROOT,
+			AGENT_INSTRUCTIONS_FILE,
+			CLAUDE_INSTRUCTIONS_FILE
+		].filter((path) => existsSync(join(sourceRepo.root, path))),
+		".gitmodules",
+		submodulePath
+	].filter((path, index, items) => items.indexOf(path) === index);
+	runner("git", [
+		"add",
+		"--",
+		...managedPaths
+	], { cwd: sourceRepo.root });
+	if (!hasIndexedChanges(runner, sourceRepo.root, managedPaths)) return false;
+	runner("git", [
+		"commit",
+		"-m",
+		`chore: connect ${treeRepoName} context tree`,
+		"--",
+		...managedPaths
+	], { cwd: sourceRepo.root });
+	return true;
+}
+function ensureTreeRemotePublished(runner, treeRepo, treeSlug, sourceCloneStyle, visibility) {
+	const existingOrigin = getGitRemoteUrl(runner, treeRepo.root, "origin");
+	if (existingOrigin !== null) {
+		runner("git", [
+			"push",
+			"-u",
+			"origin",
+			"HEAD"
+		], { cwd: treeRepo.root });
+		return {
+			createdRemote: false,
+			remoteUrl: existingOrigin
+		};
+	}
+	const desiredCloneUrl = buildGitHubCloneUrl(treeSlug, sourceCloneStyle);
+	if (commandSucceeds(runner, "gh", [
+		"repo",
+		"view",
+		treeSlug,
+		"--json",
+		"nameWithOwner"
+	], treeRepo.root)) {
+		runner("git", [
+			"remote",
+			"add",
+			"origin",
+			desiredCloneUrl
+		], { cwd: treeRepo.root });
+		runner("git", [
+			"push",
+			"-u",
+			"origin",
+			"HEAD"
+		], { cwd: treeRepo.root });
+		return {
+			createdRemote: false,
+			remoteUrl: desiredCloneUrl
+		};
+	}
+	runner("gh", [
+		"repo",
+		"create",
+		treeSlug,
+		visibilityFlag(visibility),
+		"--source",
+		treeRepo.root,
+		"--remote",
+		"origin",
+		"--push"
+	], { cwd: treeRepo.root });
+	return {
+		createdRemote: true,
+		remoteUrl: getGitRemoteUrl(runner, treeRepo.root, "origin") ?? desiredCloneUrl
+	};
+}
+function buildPrBody(treeRepoName, treeSlug, submodulePath) {
+	return [
+		`Connect the published \`${treeRepoName}\` Context Tree back into this source/workspace repo.`,
+		"",
+		`- add \`${submodulePath}\` as the tracked Context Tree submodule`,
+		"- keep the local first-tree skill + source integration marker lines in this repo",
+		`- use \`${treeSlug}\` as the GitHub home for tree content`
+	].join("\n");
+}
+function parsePublishArgs(args) {
+	const parsed = {};
+	for (let index = 0; index < args.length; index += 1) {
+		const arg = args[index];
+		switch (arg) {
+			case "--open-pr":
+				parsed.openPr = true;
+				break;
+			case "--tree-path": {
+				const value = args[index + 1];
+				if (!value) return { error: "Missing value for --tree-path" };
+				parsed.treePath = value;
+				index += 1;
+				break;
+			}
+			case "--source-repo": {
+				const value = args[index + 1];
+				if (!value) return { error: "Missing value for --source-repo" };
+				parsed.sourceRepoPath = value;
+				index += 1;
+				break;
+			}
+			case "--submodule-path": {
+				const value = args[index + 1];
+				if (!value) return { error: "Missing value for --submodule-path" };
+				parsed.submodulePath = value;
+				index += 1;
+				break;
+			}
+			case "--source-remote": {
+				const value = args[index + 1];
+				if (!value) return { error: "Missing value for --source-remote" };
+				parsed.sourceRemote = value;
+				index += 1;
+				break;
+			}
+			default: return { error: `Unknown publish option: ${arg}` };
+		}
+	}
+	return parsed;
+}
+function runPublish(repo, options) {
+	const cwd = options?.currentCwd ?? process.cwd();
+	const runner = options?.commandRunner ?? defaultCommandRunner;
+	const treeRepo = repo ?? new Repo(options?.treePath ? resolve(cwd, options.treePath) : void 0);
+	if (treeRepo.hasSourceWorkspaceIntegration() && !treeRepo.looksLikeTreeRepo()) {
+		console.error(`Error: this repo only has the first-tree source/workspace integration installed. Run \`context-tree publish --tree-path ../${treeRepo.repoName()}-context\` or switch into the dedicated tree repo first.`);
+		return 1;
+	}
+	if (!treeRepo.hasFramework() || !treeRepo.looksLikeTreeRepo()) {
+		console.error("Error: `context-tree publish` must run from a dedicated tree repo (or use `--tree-path` to point at one). Run `context-tree init` first.");
+		return 1;
+	}
+	const sourceRepoRoot = resolveSourceRepoRoot(treeRepo, options);
+	if (sourceRepoRoot === null) {
+		console.error("Error: could not determine the source/workspace repo for this tree. Re-run `context-tree init` from the source repo first, or pass `--source-repo PATH`.");
+		return 1;
+	}
+	const sourceRepo = new Repo(sourceRepoRoot);
+	if (!sourceRepo.isGitRepo()) {
+		console.error(`Error: the resolved source/workspace repo is not a git repository: ${sourceRepoRoot}`);
+		return 1;
+	}
+	if (sourceRepo.root === treeRepo.root) {
+		console.error("Error: the source/workspace repo and dedicated tree repo resolved to the same path. `context-tree publish` expects two separate repos.");
+		return 1;
+	}
+	if (!sourceRepo.hasCurrentInstalledSkill() || !sourceRepo.hasSourceWorkspaceIntegration()) {
+		console.error("Error: the source/workspace repo does not have the first-tree source integration installed. Run `context-tree init` from the source/workspace repo first.");
+		return 1;
+	}
+	const submodulePath = normalizeSubmodulePath(options?.submodulePath ?? treeRepo.repoName());
+	if (submodulePath === null) {
+		console.error("Error: `--submodule-path` must be a relative path inside the source/workspace repo.");
+		return 1;
+	}
+	const sourceRemoteName = options?.sourceRemote ?? "origin";
+	try {
+		console.log("Context Tree Publish\n");
+		console.log(`  Tree repo:   ${treeRepo.root}`);
+		console.log(`  Source repo: ${sourceRepo.root}\n`);
+		const sourceRemoteUrl = getGitRemoteUrl(runner, sourceRepo.root, sourceRemoteName);
+		if (sourceRemoteUrl === null) throw new Error(`Could not read git remote \`${sourceRemoteName}\` from the source/workspace repo.`);
+		const sourceGitHub = parseGitHubRemote(sourceRemoteUrl);
+		if (sourceGitHub === null) throw new Error(`The source/workspace remote \`${sourceRemoteName}\` is not a GitHub remote: ${sourceRemoteUrl}`);
+		const sourceMetadata = readGitHubRepoMetadata(runner, sourceGitHub.slug, sourceRepo.root);
+		const treeSlug = `${sourceGitHub.owner}/${treeRepo.repoName()}`;
+		if (commitTreeState(runner, treeRepo)) console.log("  Committed the current tree state.");
+		else console.log("  Tree repo already had a committed working state.");
+		const treeRemote = ensureTreeRemotePublished(runner, treeRepo, treeSlug, sourceGitHub.cloneStyle, sourceMetadata.visibility);
+		if (treeRemote.createdRemote) console.log(`  Created and pushed ${treeSlug}.`);
+		else console.log(`  Pushed the tree repo to ${treeRemote.remoteUrl}.`);
+		const sourceBranch = ensureSourceBranch(runner, sourceRepo, sourceRemoteName, sourceMetadata.defaultBranch, treeRepo.repoName());
+		console.log(`  Working on source/workspace branch \`${sourceBranch}\`.`);
+		const submoduleAction = ensureSubmodule(runner, sourceRepo, submodulePath, treeRemote.remoteUrl);
+		console.log(submoduleAction === "added" ? `  Added \`${submodulePath}\` as a git submodule.` : `  Updated the \`${submodulePath}\` submodule URL and checkout.`);
+		const committedSourceChanges = commitSourceIntegration(runner, sourceRepo, submodulePath, treeRepo.repoName());
+		if (committedSourceChanges) console.log("  Committed the source/workspace integration branch.");
+		else console.log("  Source/workspace integration was already up to date; no new commit was needed.");
+		if (committedSourceChanges || options?.openPr) {
+			runner("git", [
+				"push",
+				"-u",
+				sourceRemoteName,
+				sourceBranch
+			], { cwd: sourceRepo.root });
+			console.log(`  Pushed \`${sourceBranch}\` to \`${sourceRemoteName}\`.`);
+		}
+		if (options?.openPr) {
+			const prUrl = runner("gh", [
+				"pr",
+				"create",
+				"--repo",
+				sourceMetadata.nameWithOwner,
+				"--base",
+				sourceMetadata.defaultBranch,
+				"--head",
+				sourceBranch,
+				"--title",
+				`chore: connect ${treeRepo.repoName()} context tree`,
+				"--body",
+				buildPrBody(treeRepo.repoName(), treeSlug, submodulePath)
+			], { cwd: sourceRepo.root });
+			console.log(`  Opened PR: ${prUrl}`);
+		}
+		console.log();
+		console.log(`The source/workspace repo's \`${submodulePath}\` checkout is now the canonical local working copy for this tree.`);
+		console.log(`You can delete the temporary bootstrap checkout at ${treeRepo.root} once you no longer need it.`);
+		return 0;
+	} catch (err) {
+		const message = err instanceof Error ? err.message : "unknown error";
+		console.error(`Error: ${message}`);
+		return 1;
+	}
+}
+function runPublishCli(args = []) {
+	if (args.includes("--help") || args.includes("-h")) {
+		console.log(PUBLISH_USAGE);
+		return 0;
+	}
+	const parsed = parsePublishArgs(args);
+	if ("error" in parsed) {
+		console.error(parsed.error);
+		console.log(PUBLISH_USAGE);
+		return 1;
+	}
+	return runPublish(void 0, parsed);
+}
+//#endregion
+export { runPublishCli as runPublish };

package/dist/{repo-0z7N9r17.js → repo-BeVpMoHi.js}

@@ -17,6 +17,7 @@ join(FRAMEWORK_ASSET_ROOT, "prompts");
 const FRAMEWORK_EXAMPLES_DIR = join(FRAMEWORK_ASSET_ROOT, "examples");
 join(FRAMEWORK_ASSET_ROOT, "helpers");
 const INSTALLED_PROGRESS = join(SKILL_ROOT, "progress.md");
+const BOOTSTRAP_STATE = join(SKILL_ROOT, "bootstrap.json");
 const AGENT_INSTRUCTIONS_FILE = "AGENTS.md";
 const LEGACY_AGENT_INSTRUCTIONS_FILE = "AGENT.md";
 const AGENT_INSTRUCTIONS_TEMPLATE = "agents.md.template";
@@ -372,4 +373,4 @@ function isDirectory(root, relPath) {
 	}
 }
 //#endregion
-export { SOURCE_INTEGRATION_FILES as C, SKILL_ROOT as S, installedSkillRootsDisplay as T, LEGACY_EXAMPLES_DIR as _, BUNDLED_SKILL_ROOT as a, LEGACY_REPO_SKILL_ROOT as b, CLAUDE_SKILL_ROOT as c, FRAMEWORK_TEMPLATES_DIR as d, FRAMEWORK_VERSION as f, LEGACY_AGENT_INSTRUCTIONS_FILE as g, INSTALLED_SKILL_ROOTS as h, AGENT_INSTRUCTIONS_TEMPLATE as i, FRAMEWORK_ASSET_ROOT as l, INSTALLED_PROGRESS as m, Repo as n, CLAUDE_FRAMEWORK_EXAMPLES_DIR as o, FRAMEWORK_WORKFLOWS_DIR as p, AGENT_INSTRUCTIONS_FILE as r, CLAUDE_INSTRUCTIONS_FILE as s, FRAMEWORK_END_MARKER as t, FRAMEWORK_EXAMPLES_DIR as u, LEGACY_FRAMEWORK_ROOT as v, SOURCE_INTEGRATION_MARKER as w, SKILL_NAME as x, LEGACY_REPO_SKILL_EXAMPLES_DIR as y };
+export { SKILL_ROOT as C, installedSkillRootsDisplay as E, SKILL_NAME as S, SOURCE_INTEGRATION_MARKER as T, LEGACY_AGENT_INSTRUCTIONS_FILE as _, BOOTSTRAP_STATE as a, LEGACY_REPO_SKILL_EXAMPLES_DIR as b, CLAUDE_INSTRUCTIONS_FILE as c, FRAMEWORK_EXAMPLES_DIR as d, FRAMEWORK_TEMPLATES_DIR as f, INSTALLED_SKILL_ROOTS as g, INSTALLED_PROGRESS as h, AGENT_INSTRUCTIONS_TEMPLATE as i, CLAUDE_SKILL_ROOT as l, FRAMEWORK_WORKFLOWS_DIR as m, Repo as n, BUNDLED_SKILL_ROOT as o, FRAMEWORK_VERSION as p, AGENT_INSTRUCTIONS_FILE as r, CLAUDE_FRAMEWORK_EXAMPLES_DIR as s, FRAMEWORK_END_MARKER as t, FRAMEWORK_ASSET_ROOT as u, LEGACY_EXAMPLES_DIR as v, SOURCE_INTEGRATION_FILES as w, LEGACY_REPO_SKILL_ROOT as x, LEGACY_FRAMEWORK_ROOT as y };

package/dist/{source-integration-C2iiN4k_.js → source-integration-DMxnl8Dw.js}

@@ -1,4 +1,4 @@
-import { C as SOURCE_INTEGRATION_FILES, a as BUNDLED_SKILL_ROOT, b as LEGACY_REPO_SKILL_ROOT, h as INSTALLED_SKILL_ROOTS, w as SOURCE_INTEGRATION_MARKER } from "./repo-0z7N9r17.js";
+import { T as SOURCE_INTEGRATION_MARKER, g as INSTALLED_SKILL_ROOTS, o as BUNDLED_SKILL_ROOT, w as SOURCE_INTEGRATION_FILES, x as LEGACY_REPO_SKILL_ROOT } from "./repo-BeVpMoHi.js";
 import { copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";

package/dist/{upgrade-DvBdbph3.js → upgrade-B_NTlNrx.js}

@@ -1,5 +1,5 @@
-import { S as SKILL_ROOT, T as installedSkillRootsDisplay, b as LEGACY_REPO_SKILL_ROOT, c as CLAUDE_SKILL_ROOT, d as FRAMEWORK_TEMPLATES_DIR, f as FRAMEWORK_VERSION, g as LEGACY_AGENT_INSTRUCTIONS_FILE, i as AGENT_INSTRUCTIONS_TEMPLATE, m as INSTALLED_PROGRESS, n as Repo, p as FRAMEWORK_WORKFLOWS_DIR, r as AGENT_INSTRUCTIONS_FILE, s as CLAUDE_INSTRUCTIONS_FILE, v as LEGACY_FRAMEWORK_ROOT, w as SOURCE_INTEGRATION_MARKER } from "./repo-0z7N9r17.js";
-import { a as resolveCanonicalSkillRoot, i as resolveBundledPackageRoot, n as copyCanonicalSkill, t as upsertSourceIntegrationFiles } from "./source-integration-C2iiN4k_.js";
+import { C as SKILL_ROOT, E as installedSkillRootsDisplay, T as SOURCE_INTEGRATION_MARKER, _ as LEGACY_AGENT_INSTRUCTIONS_FILE, c as CLAUDE_INSTRUCTIONS_FILE, f as FRAMEWORK_TEMPLATES_DIR, h as INSTALLED_PROGRESS, i as AGENT_INSTRUCTIONS_TEMPLATE, l as CLAUDE_SKILL_ROOT, m as FRAMEWORK_WORKFLOWS_DIR, n as Repo, p as FRAMEWORK_VERSION, r as AGENT_INSTRUCTIONS_FILE, x as LEGACY_REPO_SKILL_ROOT, y as LEGACY_FRAMEWORK_ROOT } from "./repo-BeVpMoHi.js";
+import { a as resolveCanonicalSkillRoot, i as resolveBundledPackageRoot, n as copyCanonicalSkill, t as upsertSourceIntegrationFiles } from "./source-integration-DMxnl8Dw.js";
 import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 //#region skills/first-tree/engine/runtime/upgrader.ts

package/dist/{verify-DRt5mCqO.js → verify-Chhm1vOF.js}

@@ -1,4 +1,4 @@
-import { S as SKILL_ROOT, g as LEGACY_AGENT_INSTRUCTIONS_FILE, n as Repo, r as AGENT_INSTRUCTIONS_FILE, x as SKILL_NAME } from "./repo-0z7N9r17.js";
+import { C as SKILL_ROOT, S as SKILL_NAME, _ as LEGACY_AGENT_INSTRUCTIONS_FILE, n as Repo, r as AGENT_INSTRUCTIONS_FILE } from "./repo-BeVpMoHi.js";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { join, relative, resolve } from "node:path";
 //#region skills/first-tree/engine/validators/members.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "first-tree",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "CLI tools for Context Tree — the living source of truth for your organization.",
   "homepage": "https://github.com/agent-team-foundation/first-tree#readme",
   "bugs": {

package/skills/first-tree/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: first-tree
-description: Maintain the canonical `first-tree` skill and the thin `context-tree` CLI distributed by the `first-tree` npm package. Use when modifying `context-tree` commands (`init`, `verify`, `upgrade`, `help onboarding`), the installed skill payload under `assets/framework/`, maintainer references, or the build, packaging, test, and CI wiring that supports the framework.
+description: Maintain the canonical `first-tree` skill and the thin `context-tree` CLI distributed by the `first-tree` npm package. Use when modifying `context-tree` commands (`init`, `publish`, `verify`, `upgrade`, `help onboarding`), the installed skill payload under `assets/framework/`, maintainer references, or the build, packaging, test, and CI wiring that supports the framework.
 ---
 
 # First Tree
@@ -72,16 +72,25 @@ repos.
   into the source/workspace repo and scaffolds tree files only in the
   dedicated tree repo. Use `--here` to initialize the current repo in place
   when you are already inside the tree repo.
+- `context-tree publish --open-pr` is the default second-stage command after
+  `init` for source/workspace installs. Run it from the dedicated tree repo
+  once the initial tree version is ready to push.
 - Never run `context-tree init --here` in a source/workspace repo unless the
   user explicitly wants that repo itself to become the dedicated Context Tree.
   `--here` is for when you have already switched into the `*-context` 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`.
-- The default source/workspace workflow is: create or reuse `<repo>-context`,
-  prefer pushing it in the same GitHub organization as the source repo, add it
-  back to the source/workspace repo as a git submodule, and open a PR to the
-  source/workspace repo's default branch instead of merging automatically.
+- The default source/workspace workflow is: run `context-tree init` from the
+  source repo, draft the first tree version in `<repo>-context`, then run
+  `context-tree publish --open-pr` from that dedicated tree repo.
+- After `context-tree publish` succeeds, treat the source/workspace repo's
+  submodule checkout as the canonical local working copy for the tree. The
+  temporary sibling bootstrap checkout can be deleted when you no longer need
+  it.
+- If the dedicated tree repo was initialized manually with `context-tree init --here`
+  and does not have bootstrap metadata yet, pass `--source-repo PATH` to
+  `context-tree publish`.
 - If permissions, auth, or local filesystem constraints block the dedicated
   repo workflow, stop and report the blocker. Do not fall back to in-place tree
   bootstrap in the source/workspace repo.

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

@@ -1 +1 @@
-0.2.1
+0.2.2

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

@@ -0,0 +1,5 @@
+export {
+  PUBLISH_USAGE,
+  parsePublishArgs,
+  runPublishCli as runPublish,
+} from "#skill/engine/publish.js";

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

@@ -16,6 +16,7 @@ import {
   renderTemplateFile,
   resolveBundledPackageRoot,
 } from "#skill/engine/runtime/installer.js";
+import { writeBootstrapState } from "#skill/engine/runtime/bootstrap.js";
 import {
   AGENT_INSTRUCTIONS_FILE,
   AGENT_INSTRUCTIONS_TEMPLATE,
@@ -122,13 +123,10 @@ export function formatTaskList(
       );
       lines.push("## Source Workspace Workflow");
       lines.push(
-        `- [ ] Publish this dedicated tree repo to the same GitHub organization as \`${context.sourceRepoName}\``,
+        `- [ ] When this initial tree version is ready, run \`context-tree publish --open-pr\` from this dedicated tree repo. It will create or reuse the GitHub \`*-context\` repo, add it back to \`${context.sourceRepoName}\` as a git submodule, and open the source/workspace PR.`,
       );
       lines.push(
-        `- [ ] Add this tree repo back to \`${context.sourceRepoName}\` as a git submodule after the remote exists`,
-      );
-      lines.push(
-        `- [ ] Open a PR against the source/workspace repo's default branch with only the installed skill, the \`${SOURCE_INTEGRATION_MARKER}\` marker lines in \`${AGENT_INSTRUCTIONS_FILE}\` / \`${CLAUDE_INSTRUCTIONS_FILE}\`, and the new submodule pointer`,
+        `- [ ] After publish succeeds, treat the source/workspace repo's \`${context.sourceRepoName}\` submodule checkout as the canonical local working copy for this tree. The temporary sibling bootstrap repo can be deleted when you no longer need it.`,
       );
       lines.push("");
     }
@@ -299,6 +297,14 @@ export function runInit(repo?: Repo, options?: InitOptions): number {
     }
   }
 
+  if (initTarget.dedicatedTreeRepo) {
+    writeBootstrapState(r.root, {
+      sourceRepoName: sourceRepo.repoName(),
+      sourceRepoPath: relativePathFrom(r.root, sourceRepo.root),
+      treeRepoName: r.repoName(),
+    });
+  }
+
   console.log(ONBOARDING_TEXT);
   console.log("---\n");