@treeseed/sdk 0.13.0-rc.2 → 0.13.0-rc.21

package/dist/operations/services/repositories/platform-workset.js

@@ -1,204 +0,0 @@
-import { createHash } from "node:crypto";
-import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { dirname, relative, resolve } from "node:path";
-import { resolveRepositoryIdentity } from "../../../repositories/repository-identity.js";
-import { resolveGitHubCredentialForRepository } from "../configuration/github-credentials.js";
-import { resolveMachineEnvironmentValues } from "../config-runtime/support/resolve-entry-value-from-buckets.js";
-import { classifyGitMode, runRepositoryGit } from "../operations/git-runner.js";
-function validateRepository(root, value, index) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`Platform team inventory repository ${index} is invalid.`);
-  const entry = value;
-  const projectId = typeof entry.projectId === "string" ? entry.projectId.trim() : "";
-  const role = typeof entry.role === "string" ? entry.role.trim() : "";
-  const path = typeof entry.path === "string" ? entry.path.trim().replaceAll("\\", "/") : "";
-  const repository = typeof entry.repository === "string" ? entry.repository.trim() : "";
-  const branch = typeof entry.branch === "string" ? entry.branch.trim() : "";
-  if (!projectId || !role || !repository || !branch) throw new Error(`Platform team inventory repository ${index} is missing projectId, role, repository, or branch.`);
-  if (!path || path.startsWith("/") || path.split("/").some((part) => !part || part === "." || part === "..")) throw new Error(`Platform inventory path "${path}" must be a safe relative path.`);
-  if ([".git", ".treeseed", "node_modules"].includes(path.split("/")[0])) throw new Error(`Platform inventory path "${path}" uses a reserved directory.`);
-  const target = resolve(root, path);
-  if (relative(resolve(root), target).startsWith("..")) throw new Error(`Platform inventory path "${path}" escapes the workspace.`);
-  const identity = resolveRepositoryIdentity(repository.includes("://") || repository.startsWith("/") ? repository : `https://github.com/${repository}.git`);
-  if (/^(market|market-api)$/u.test(identity.repository) || identity.repository.endsWith("-content")) throw new Error(`Platform cannot materialize ${repository}.`);
-  return { projectId, role, path, repository, branch };
-}
-function git(cwd, args, env, allowFailure = false) {
-  return runRepositoryGit(args, { cwd, env, allowFailure, mode: classifyGitMode(args) });
-}
-function repositoryUrl(repository) {
-  return resolveRepositoryIdentity(repository.includes("://") || repository.startsWith("/") ? repository : `https://github.com/${repository}.git`).canonicalRemoteUrl;
-}
-function observeRepository(root, entry, env) {
-  const result = git(root, ["ls-remote", repositoryUrl(entry.repository), `refs/heads/${entry.branch}`], credentialEnvironment(root, entry.repository, env), true);
-  const commit = result.status === 0 ? result.stdout.trim().split(/\s+/u)[0]?.toLowerCase() ?? "" : "";
-  if (!/^[a-f0-9]{40}$/u.test(commit)) throw new Error(`Live branch ${entry.repository}@${entry.branch} could not be resolved to an exact commit.`);
-  return { ...entry, commit };
-}
-function credentialEnvironment(root, repository, env) {
-  if (!/^treeseed-ai\//iu.test(repository)) return { ...process.env, ...env, GIT_TERMINAL_PROMPT: "0" };
-  const values = resolveMachineEnvironmentValues(root, "staging");
-  const credential = resolveGitHubCredentialForRepository(repository, { values, env: { ...values, ...env } });
-  if (!credential.token) return { ...process.env, ...env, GIT_TERMINAL_PROMPT: "0" };
-  const basic = Buffer.from(`x-access-token:${credential.token}`, "utf8").toString("base64");
-  return { ...process.env, ...env, GIT_CONFIG_COUNT: "1", GIT_CONFIG_KEY_0: "http.https://github.com/.extraheader", GIT_CONFIG_VALUE_0: `AUTHORIZATION: basic ${basic}`, GIT_TERMINAL_PROMPT: "0" };
-}
-function existingParent(path) {
-  let candidate = path;
-  while (!existsSync(candidate)) candidate = dirname(candidate);
-  return candidate;
-}
-function ensureContained(root, target) {
-  const actualRoot = realpathSync(root);
-  const parent = realpathSync(existingParent(target));
-  if (parent !== actualRoot && relative(actualRoot, parent).startsWith("..")) throw new Error(`Workset target escapes the Platform workspace: ${target}`);
-}
-function classifyExisting(root, entry, branch, custody) {
-  const target = resolve(root, entry.path);
-  if (!existsSync(target)) return { ...entry, sourceBranch: entry.branch, branch, custody, action: "create", reason: "Materialize the exact live team-inventory commit as an independent repository." };
-  const actionEntry = { ...entry, sourceBranch: entry.branch, branch, custody };
-  if (lstatSync(target).isSymbolicLink() || !lstatSync(target).isDirectory()) return { ...actionEntry, action: "blocked", reason: "The workset path exists but is not an independent repository directory." };
-  const top = git(target, ["rev-parse", "--show-toplevel"], void 0, true);
-  if (top.status !== 0 || resolve(top.stdout.trim()) !== resolve(target)) return { ...actionEntry, action: "blocked", reason: "The workset path is not an independent Git repository." };
-  const origin = git(target, ["remote", "get-url", "origin"], void 0, true);
-  if (origin.status !== 0 || resolveRepositoryIdentity(origin.stdout.trim()).canonicalKey !== resolveRepositoryIdentity(repositoryUrl(entry.repository)).canonicalKey) return { ...actionEntry, action: "blocked", reason: "The existing checkout has a different canonical origin repository." };
-  if (git(target, ["status", "--porcelain"]).stdout.trim()) return { ...actionEntry, action: "blocked", reason: "The existing checkout has uncommitted changes." };
-  const head = git(target, ["rev-parse", "HEAD"], void 0, true).stdout.trim();
-  if (head !== entry.commit) return { ...actionEntry, action: "blocked", reason: `The existing checkout is at ${head || "an unknown commit"}, not ${entry.commit}.` };
-  const currentBranch = git(target, ["branch", "--show-current"], void 0, true).stdout.trim() || null;
-  if (currentBranch !== branch) return { ...actionEntry, action: "blocked", reason: branch ? `The exact checkout is not on requested branch ${branch}.` : "The exact checkout must be detached when no work branch is requested." };
-  return { ...actionEntry, action: "noop", reason: "The independent checkout already matches the exact observed team-inventory ref." };
-}
-function summarize(actions) {
-  return {
-    create: actions.filter((entry) => entry.action === "create").length,
-    noop: actions.filter((entry) => entry.action === "noop").length,
-    blocked: actions.filter((entry) => entry.action === "blocked").length
-  };
-}
-function validateAuthority(teamId, authority, repositories) {
-  if (!authority) return;
-  if (authority.schemaVersion !== 1 || authority.kind !== "treeseed.governed-workset-authority" || authority.status !== "active" || authority.mode !== "acting") throw new Error("Writable Platform workset authority is invalid or inactive.");
-  for (const [field, value] of Object.entries({ decisionId: authority.decisionId, capacityPlanId: authority.capacityPlanId, workDayId: authority.workDayId, assignmentId: authority.assignmentId })) {
-    if (!value.trim()) throw new Error(`Writable Platform workset authority is missing ${field}.`);
-  }
-  if (authority.teamId !== teamId) throw new Error("Writable Platform workset authority belongs to a different team.");
-  if (!repositories.some((entry) => entry.projectId === authority.projectId)) throw new Error("Writable Platform workset authority project is absent from the team inventory.");
-  if (!/^[a-f0-9]{40}$/u.test(authority.baseCommit)) throw new Error("Writable Platform workset authority requires an exact base commit.");
-  if (!Number.isFinite(Date.parse(authority.expiresAt)) || Date.parse(authority.expiresAt) <= Date.now()) throw new Error("Writable Platform workset authority is expired.");
-}
-function planPlatformWorkset(input) {
-  const root = resolve(input.root);
-  const teamId = input.teamId.trim();
-  if (!teamId) throw new Error("Platform workset requires an authenticated team inventory identity.");
-  const branch = input.branch?.trim() || null;
-  if (branch && (!/^[A-Za-z0-9][A-Za-z0-9._/-]*$/u.test(branch) || branch.includes("..") || branch.endsWith("/") || branch.includes("//"))) throw new Error(`Invalid workset branch "${branch}".`);
-  const repositories = input.inventory.map((entry, index) => validateRepository(root, entry, index));
-  const authority = input.authority ?? null;
-  validateAuthority(teamId, authority, repositories);
-  if (branch && !authority) throw new Error("A writable Platform workset branch requires an active acting-assignment authority.");
-  if (repositories.length === 0) throw new Error(`Team ${teamId} has no materializable project repositories.`);
-  const paths = /* @__PURE__ */ new Set();
-  const identities = /* @__PURE__ */ new Set();
-  for (const entry of repositories) {
-    if (paths.has(entry.path)) throw new Error(`Platform team inventory contains duplicate path ${entry.path}.`);
-    const identity = resolveRepositoryIdentity(repositoryUrl(entry.repository)).canonicalKey;
-    if (identities.has(identity)) throw new Error(`Platform team inventory contains duplicate repository ${entry.repository}.`);
-    paths.add(entry.path);
-    identities.add(identity);
-    ensureContained(root, resolve(root, entry.path));
-  }
-  const observed = repositories.map((entry) => observeRepository(root, entry, input.env ?? process.env));
-  if (authority) {
-    const owned = observed.find((entry) => entry.projectId === authority.projectId);
-    if (owned.commit !== authority.baseCommit) throw new Error(`Acting assignment base ${authority.baseCommit} is stale; live inventory resolved ${owned.commit}.`);
-  }
-  const actions = observed.map((entry) => {
-    const writable = Boolean(authority && entry.projectId === authority.projectId);
-    return classifyExisting(root, entry, writable ? branch : null, writable ? "assignment-write" : "read-only");
-  });
-  return { schemaVersion: 2, kind: "treeseed.platform-workset-plan", root, teamId, branch, authority, actions, summary: summarize(actions) };
-}
-function journalPath(root) {
-  return resolve(root, ".treeseed", "worksets", "platform", "latest.json");
-}
-function inventoryDigest(actions, authority) {
-  return createHash("sha256").update(JSON.stringify({
-    repositories: actions.map(({ projectId, role, path, repository, sourceBranch, commit }) => ({ projectId, role, path, repository, branch: sourceBranch, commit })),
-    ...authority ? { authority } : {}
-  })).digest("hex");
-}
-function verifiedPlatformWorksetReceipt(root) {
-  const path = journalPath(root);
-  if (!existsSync(path)) return null;
-  try {
-    const receipt = JSON.parse(readFileSync(path, "utf8"));
-    if (![1, 2].includes(receipt.schemaVersion) || receipt.kind !== "treeseed.platform-workset-receipt" || receipt.status !== "verified" || !Array.isArray(receipt.completed)) return null;
-    const digest = receipt.schemaVersion === 1 ? createHash("sha256").update(JSON.stringify(receipt.completed.map(({ projectId, role, path: path2, repository, sourceBranch, commit }) => ({ projectId, role, path: path2, repository, branch: sourceBranch, commit })))).digest("hex") : inventoryDigest(receipt.completed, receipt.authority);
-    return receipt.inventoryDigest === digest ? receipt : null;
-  } catch {
-    return null;
-  }
-}
-function persistJournal(plan, completed, status) {
-  const path = journalPath(plan.root);
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, `${JSON.stringify({ schemaVersion: 2, kind: "treeseed.platform-workset-receipt", status, teamId: plan.teamId, branch: plan.branch, authority: plan.authority, inventoryDigest: inventoryDigest(plan.actions, plan.authority), completed, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2)}
-`, { encoding: "utf8", mode: 384 });
-}
-function materialize(plan, action, env) {
-  const target = resolve(plan.root, action.path);
-  const parent = dirname(target);
-  mkdirSync(parent, { recursive: true });
-  ensureContained(plan.root, target);
-  const temporaryRoot = resolve(plan.root, ".treeseed", "worksets", "materializing");
-  mkdirSync(temporaryRoot, { recursive: true });
-  const temporary = mkdtempSync(resolve(temporaryRoot, "repository-"));
-  const gitEnv = credentialEnvironment(plan.root, action.repository, env);
-  try {
-    git(temporary, ["init", "--quiet"], gitEnv);
-    git(temporary, ["remote", "add", "origin", repositoryUrl(action.repository)], gitEnv);
-    git(temporary, ["fetch", "--quiet", "--no-tags", "--depth=1", "origin", action.commit], gitEnv);
-    const fetched = git(temporary, ["rev-parse", "FETCH_HEAD"]).stdout.trim();
-    if (fetched !== action.commit) throw new Error(`Fetched ${fetched || "no commit"} for ${action.repository}, expected ${action.commit}.`);
-    if (action.branch) {
-      const remoteBranch = git(temporary, ["fetch", "--quiet", "--no-tags", "--depth=1", "origin", `refs/heads/${action.branch}:refs/remotes/origin/${action.branch}`], gitEnv, true);
-      if (remoteBranch.status === 0) {
-        const remoteCommit = git(temporary, ["rev-parse", `refs/remotes/origin/${action.branch}`]).stdout.trim();
-        if (remoteCommit !== action.commit) throw new Error(`Remote work branch ${action.repository}@${action.branch} is ${remoteCommit}, not observed inventory commit ${action.commit}.`);
-        git(temporary, ["checkout", "--quiet", "-b", action.branch, "--track", `origin/${action.branch}`], gitEnv);
-      } else {
-        git(temporary, ["checkout", "--quiet", "-b", action.branch, action.commit], gitEnv);
-      }
-    } else git(temporary, ["checkout", "--quiet", "--detach", action.commit], gitEnv);
-    if (existsSync(target)) throw new Error(`Workset target appeared during materialization: ${action.path}`);
-    renameSync(temporary, target);
-  } finally {
-    if (existsSync(temporary)) rmSync(temporary, { recursive: true, force: true });
-  }
-}
-function applyPlatformWorkset(input) {
-  const plan = planPlatformWorkset(input);
-  if (plan.summary.blocked) throw new Error(plan.actions.filter((entry) => entry.action === "blocked").map((entry) => `${entry.path}: ${entry.reason}`).join("\n"));
-  const completed = plan.actions.filter((entry) => entry.action === "noop");
-  for (const action of plan.actions.filter((entry) => entry.action === "create")) {
-    materialize(plan, action, input.env ?? process.env);
-    const verified = classifyExisting(plan.root, {
-      projectId: action.projectId,
-      role: action.role,
-      path: action.path,
-      repository: action.repository,
-      branch: action.sourceBranch,
-      commit: action.commit
-    }, action.branch, action.custody);
-    if (verified.action !== "noop") throw new Error(`Fresh workset verification failed for ${action.path}: ${verified.reason}`);
-    completed.push(verified);
-    persistJournal(plan, completed, completed.length === plan.actions.length ? "verified" : "partial");
-  }
-  if (completed.length === plan.actions.length) persistJournal(plan, completed, "verified");
-  return { ...plan, actions: completed, summary: summarize(completed), receiptPath: journalPath(plan.root), status: "verified" };
-}
-export {
-  applyPlatformWorkset,
-  planPlatformWorkset,
-  verifiedPlatformWorksetReceipt
-};

package/dist/operations/services/repositories/repository-save-orchestrator.d.ts

@@ -1,13 +0,0 @@
-export * from '../repository-save-orchestrator/packages/finalize-clean-package-version.js';
-export * from '../repository-save-orchestrator/repositories/discover-repository-save-nodes.js';
-export * from '../repository-save-orchestrator/repositories/plan-repository-save.js';
-export * from '../repository-save-orchestrator/repositories/run-repository-save-orchestrator.js';
-export * from '../repository-save-orchestrator/repositories/save-one-repository.js';
-export * from '../repository-save-orchestrator/runtime/with-short-process-temp-env.js';
-export * from '../repository-save-orchestrator/support/classify-repo-kind.js';
-export * from '../repository-save-orchestrator/support/has-staged-changes.js';
-export * from '../repository-save-orchestrator/support/standalone-lockfile.js';
-export * from '../repository-save-orchestrator/support/repo-kind.js';
-export * from '../repository-save-orchestrator/support/run-script.js';
-export * from '../repository-save-orchestrator/support/tag-state.js';
-export * from '../repository-save-orchestrator/treedx/repositories/sync-root-workspace-lockfile-metadata.js';

package/dist/operations/services/repositories/repository-save-orchestrator.js

@@ -1,13 +0,0 @@
-export * from "../repository-save-orchestrator/packages/finalize-clean-package-version.js";
-export * from "../repository-save-orchestrator/repositories/discover-repository-save-nodes.js";
-export * from "../repository-save-orchestrator/repositories/plan-repository-save.js";
-export * from "../repository-save-orchestrator/repositories/run-repository-save-orchestrator.js";
-export * from "../repository-save-orchestrator/repositories/save-one-repository.js";
-export * from "../repository-save-orchestrator/runtime/with-short-process-temp-env.js";
-export * from "../repository-save-orchestrator/support/classify-repo-kind.js";
-export * from "../repository-save-orchestrator/support/has-staged-changes.js";
-export * from "../repository-save-orchestrator/support/standalone-lockfile.js";
-export * from "../repository-save-orchestrator/support/repo-kind.js";
-export * from "../repository-save-orchestrator/support/run-script.js";
-export * from "../repository-save-orchestrator/support/tag-state.js";
-export * from "../repository-save-orchestrator/treedx/repositories/sync-root-workspace-lockfile-metadata.js";

package/dist/operations/services/repository-save-orchestrator/packages/finalize-clean-package-version.d.ts

@@ -1,4 +0,0 @@
-import { RepoBranchMode, RepositorySaveNode, RepositorySaveOptions, RepositorySaveReport, SaveState } from '../support/repo-kind.js';
-export declare function finalizeCleanPackageVersion(node: RepositorySaveNode, options: RepositorySaveOptions, state: SaveState, report: RepositorySaveReport, branch: string): Promise<boolean>;
-export declare function branchModeLabel(branchMode: RepoBranchMode): "stable package release" | "dev package save" | "project save";
-export declare function repoPlanCommands(node: RepositorySaveNode, options: RepositorySaveOptions, plannedVersion: string | null, plannedDependencySpec: string | null, dependencyUpdates: string[]): string[];

package/dist/operations/services/repository-save-orchestrator/packages/finalize-clean-package-version.js

@@ -1,156 +0,0 @@
-import { existsSync } from "node:fs";
-import { resolve } from "node:path";
-import {
-  headCommit
-} from "../../operations/git-workflow.js";
-import {
-  sshPushUrlForRemote
-} from "../../repositories/git-remote-policy.js";
-import { checkoutCommandFor, remoteBranchExistsSafe } from "../repositories/discover-repository-save-nodes.js";
-import { packageVersionEligibleForBranch, remoteBranchCommitSafe } from "../support/classify-repo-kind.js";
-import { hasNpmLockfile } from "../support/has-staged-changes.js";
-import { emitProgress, readJson } from "../support/repo-kind.js";
-import { finishRepositorySavePublish, pullRebaseFromOrigin, runRepoVerification } from "../support/run-script.js";
-import { assertTagStateMatchesHead, ensurePackageTagReady, ensureRemoteAccessBeforeVerification, finalizePackageReference, tagState } from "../support/tag-state.js";
-import { hasScript, manifestVerifyCommand, runNpmInstallWithRetry, validateRepositoryLockfile } from "../treedx/repositories/sync-root-workspace-lockfile-metadata.js";
-async function finalizeCleanPackageVersion(node, options, state, report, branch) {
-  const version = typeof node.packageJson?.version === "string" ? node.packageJson.version : null;
-  if (!version || !packageVersionEligibleForBranch(node, version, options)) {
-    return false;
-  }
-  const head = headCommit(node.path);
-  const reference = finalizePackageReference(node, version, options);
-  const currentTagState = reference.tagName ? tagState(node.path, reference.tagName) : null;
-  if (reference.tagName && currentTagState) {
-    assertTagStateMatchesHead(node, reference.tagName, currentTagState, head);
-  }
-  const remoteBranchExists = remoteBranchExistsSafe(node.path, branch);
-  const remoteBranchCommit = remoteBranchCommitSafe(node.path, branch);
-  const finalizedRemotely = remoteBranchExists && remoteBranchCommit === head && (!reference.tagName || currentTagState?.localCommit === head && currentTagState?.remoteCommit === head);
-  report.version = version;
-  report.tagName = reference.tagName;
-  report.commitSha = head;
-  report.dependencySpec = reference.spec;
-  state.finalizedVersions.set(node.name, version);
-  state.finalizedReferences.set(node.name, reference);
-  for (const path of node.checkoutAliases) state.finalizedCommits.set(path, head);
-  if (finalizedRemotely) {
-    report.pushed = true;
-    report.skippedReason = "already-finalized";
-    report.publishWait = { recoveredPartialSave: true, remoteBranchExisted: true, tagAlreadyPushed: Boolean(reference.tagName) };
-    emitProgress(options, node, "finalize", `Using existing finalized package version ${version}.`);
-    return true;
-  }
-  emitProgress(options, node, "finalize", `Finalizing interrupted package version ${version}.`);
-  if (hasNpmLockfile(node.path)) {
-    report.install = await runNpmInstallWithRetry(node, options);
-    report.lockfileValidation = await validateRepositoryLockfile(node, options);
-  }
-  const rebase = pullRebaseFromOrigin(node, options, branch);
-  ensureRemoteAccessBeforeVerification(node, options, state);
-  report.verification = await runRepoVerification(node, options, options.verifyMode ?? "action-first");
-  report.verified = report.verification.status === "passed";
-  const tagMessage = reference.tagName ? ensurePackageTagReady(node, options, reference.tagName, branch, options.workflowRunId) : null;
-  void tagMessage;
-  report.dependencySpec = reference.spec;
-  report.skippedReason = "finalized-partial-save";
-  report.commitSha = headCommit(node.path);
-  for (const path of node.checkoutAliases) state.finalizedCommits.set(path, report.commitSha);
-  await finishRepositorySavePublish(node, options, state, report, {
-    branch,
-    rebase: {
-      ...rebase,
-      recoveredPartialSave: true
-    },
-    reference,
-    tagName: reference.tagName
-  });
-  return true;
-}
-function branchModeLabel(branchMode) {
-  switch (branchMode) {
-    case "package-release-main":
-      return "stable package release";
-    case "package-dev-save":
-      return "dev package save";
-    case "project-save":
-      return "project save";
-  }
-}
-function repoPlanCommands(node, options, plannedVersion, plannedDependencySpec, dependencyUpdates) {
-  const branch = node.branch || options.branch;
-  const remoteExists = remoteBranchExistsSafe(node.path, branch);
-  const commands = [
-    checkoutCommandFor(node.path, branch)
-  ];
-  const sshPushUrl = (options.gitRemoteWriteMode ?? "ssh-pushurl") === "off" ? null : sshPushUrlForRemote(node.remoteUrl);
-  if (sshPushUrl) {
-    commands.push(`git remote set-url --push origin ${sshPushUrl} # keep ${node.remoteUrl} for reads`);
-  }
-  if (dependencyUpdates.length > 0) {
-    commands.push(`update package.json internal dependencies: ${dependencyUpdates.join(", ")}`);
-  }
-  if (node.submoduleDependencies.length > 0) {
-    commands.push(`refresh submodule pointers: ${node.submoduleDependencies.join(", ")}`);
-  }
-  const packageJson = node.packageJson ?? (existsSync(resolve(node.path, "package.json")) ? readJson(resolve(node.path, "package.json")) : null);
-  const rootWorkspaceInstall = node.path === options.root && Array.isArray(packageJson?.workspaces);
-  if (node.kind === "package" && plannedVersion) {
-    commands.push(`update package.json version to ${plannedVersion}`);
-    commands.push("npm install --workspaces=false # explicitly refresh changed git commit dependencies with --force; retry up to 5 times with 60s delay");
-  } else if (node.kind === "project" && (dependencyUpdates.length > 0 || rootWorkspaceInstall && node.submoduleDependencies.length > 0) && hasNpmLockfile(node.path)) {
-    commands.push(rootWorkspaceInstall ? "npm install --package-lock-only --ignore-scripts # refresh root workspace lockfile without installing git dependencies" : "npm install --workspaces=false # refresh project lockfile after internal dependency updates");
-  }
-  if (hasNpmLockfile(node.path) && (node.kind === "project" || plannedVersion || dependencyUpdates.length > 0 || node.submoduleDependencies.length > 0)) {
-    commands.push(rootWorkspaceInstall ? "npm ci --ignore-scripts --plan # validate root manifest, workspaces, and lockfile before commit" : "npm ci --ignore-scripts --plan --workspaces=false # validate deployment lockfile before commit");
-  }
-  commands.push("git add -A");
-  commands.push("generate commit message # Cloudflare AI when configured, fallback otherwise");
-  commands.push("git commit -m <generated-message>");
-  commands.push(
-    remoteExists ? `git pull --rebase --recurse-submodules=no origin ${branch}` : `skip pull --rebase # origin/${branch} does not exist yet`
-  );
-  const verifyMode = options.verifyMode ?? "action-first";
-  if (node.changeKind === "content") {
-    commands.push(`skip code verification # content-only change under ${node.contentPath}`);
-  } else if (verifyMode === "skip") {
-    commands.push(node.kind === "package" ? "skip package verification" : "skip project verification");
-  } else if (hasScript(node, "verify:action") || hasScript(node, "verify:local") || hasScript(node, "verify")) {
-    if (verifyMode === "local-only") {
-      commands.push("npm run verify:local");
-    } else if (hasScript(node, "verify:action")) {
-      commands.push("npm run verify:action # fallback to npm run verify:local on failure");
-    } else if (hasScript(node, "verify:local")) {
-      commands.push("npm run verify:local");
-    } else {
-      commands.push("npm run verify");
-    }
-  } else if (manifestVerifyCommand(node, "local") || manifestVerifyCommand(node, "fast")) {
-    const command = verifyMode === "local-only" ? manifestVerifyCommand(node, "local") ?? manifestVerifyCommand(node, "fast") : manifestVerifyCommand(node, "local") ?? manifestVerifyCommand(node, "fast");
-    if (command) commands.push(`${command.command} ${command.args.join(" ")} # treeseed.package.yaml verification`);
-  } else if (node.kind !== "package") {
-    commands.push("skip verification # project repository has no Treeseed verify script");
-  }
-  if (node.kind === "package") {
-    const plansTag = plannedVersion && node.branchMode === "package-release-main";
-    if (plannedVersion && plansTag) {
-      commands.push(`git tag -a ${plannedVersion} -m <release>`);
-      commands.push(remoteExists ? `git push origin ${branch} ${plannedVersion}` : `git push -u origin ${branch} ${plannedVersion}`);
-    } else if (plannedVersion) {
-      commands.push(remoteExists ? `git push origin ${branch}` : `git push -u origin ${branch}`);
-      if (plannedDependencySpec && node.branchMode === "package-dev-save") {
-        commands.push(`npm install ${node.name}@${plannedDependencySpec} --package-lock-only --ignore-scripts --force # validate dependency commit reachability`);
-      }
-    } else {
-      commands.push(remoteExists ? `git push origin ${branch}` : `git push -u origin ${branch}`);
-    }
-  } else {
-    commands.push(remoteExists ? `git push origin ${branch}` : `git push -u origin ${branch}`);
-  }
-  return commands;
-}
-export {
-  branchModeLabel,
-  finalizeCleanPackageVersion,
-  repoPlanCommands
-};

package/dist/operations/services/repository-save-orchestrator/repositories/discover-repository-save-nodes.d.ts

@@ -1,43 +0,0 @@
-import { RepoBranchMode, RepositoryCommitMessageContext, RepositorySaveNode, RepositorySaveOptions } from '../support/repo-kind.js';
-export declare function discoverRepositorySaveNodes(root: string, gitRoot?: string, branch?: string, options?: {
-    stablePackageRelease?: boolean;
-}): RepositorySaveNode[];
-export declare function deriveRepositoryGraph(root: string, nodes: RepositorySaveNode[]): {
-    dependencies: string[];
-    referenceDependencies: string[];
-    dependents: string[];
-    submoduleDependencies: string[];
-    id: string;
-    checkoutAliases: string[];
-    name: string;
-    path: string;
-    relativePath: string;
-    kind: import("../support/repo-kind.js").RepoKind;
-    branch: string | null;
-    branchMode: RepoBranchMode;
-    packageJsonPath: string | null;
-    packageJson: Record<string, unknown> | null;
-    scripts: Record<string, string>;
-    manifestVerifyCommands: Record<"fast" | "local" | "release", import("../../package-adapters/package-kind.js").PackageCommand | null>;
-    remoteUrl: string | null;
-    workflowDependencies?: string[];
-    plannedVersion: string | null;
-    plannedTag: string | null;
-    plannedDependencySpec: string | null;
-    contentPath?: string | null;
-    changeKind?: import("../support/repo-kind.js").RepositoryChangeKind;
-}[];
-export declare function repositorySaveWaves(nodes: RepositorySaveNode[]): RepositorySaveNode[][];
-export declare function selectRepositorySaveNodes(nodes: RepositorySaveNode[], selectedRepositoryPath?: string | null): RepositorySaveNode[];
-export declare function compareNodes(left: RepositorySaveNode, right: RepositorySaveNode): 1 | -1;
-export declare function runLimited<T>(items: T[], limit: number, action: (item: T) => Promise<void>): Promise<void[]>;
-export declare function repositorySaveConcurrency(options: Pick<RepositorySaveOptions, 'verifyMode'>): number;
-export declare function remoteBranchExistsSafe(repoDir: string, branch: string): boolean;
-export declare function checkoutCommandFor(repoDir: string, branch: string): string;
-export declare function checkoutOrCreateBranch(node: RepositorySaveNode, options: RepositorySaveOptions, branch: string): void;
-export declare function commitMessageFor(node: RepositorySaveNode, options: RepositorySaveOptions, context: Pick<RepositoryCommitMessageContext, 'changedFiles' | 'diff' | 'plannedVersion' | 'plannedTag' | 'dependencyUpdates' | 'submodulePointers' | 'packageChanges'>): Promise<import("../../commit-message-provider/default-commit-ai-model.js").CommitMessageResult>;
-export declare function commitSubject(message: string | null | undefined): string | null;
-export declare function gitDiffSummary(repoDir: string): {
-    changedFiles: string;
-    diff: string;
-};