@treeseed/cli 0.1.1

package/dist/cli/handlers/release.js

@@ -0,0 +1,60 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { applyTreeseedEnvironmentToProcess } from "../../scripts/config-runtime-lib.js";
+import { PRODUCTION_BRANCH, STAGING_BRANCH, mergeStagingIntoMain, prepareReleaseBranches, pushBranch } from "../../scripts/git-workflow-lib.js";
+import { applyWorkspaceVersionChanges, incrementVersion, planWorkspaceReleaseBump, repoRoot } from "../../scripts/workspace-save-lib.js";
+import { run, workspaceRoot } from "../../scripts/workspace-tools.js";
+import { runWorkspaceSavePreflight } from "../../scripts/save-deploy-preflight-lib.js";
+import { guidedResult } from "./utils.js";
+function bumpRootPackageJson(root, level) {
+  const packageJsonPath = resolve(root, "package.json");
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+  packageJson.version = incrementVersion(packageJson.version, level);
+  writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+`, "utf8");
+  return packageJson.version;
+}
+const handleRelease = (invocation, context) => {
+  const commandName = invocation.commandName || "release";
+  const level = ["major", "minor", "patch"].find((candidate) => invocation.args[candidate] === true);
+  const root = workspaceRoot();
+  const gitRoot = repoRoot(root);
+  prepareReleaseBranches(root);
+  applyTreeseedEnvironmentToProcess({ tenantRoot: root, scope: "staging" });
+  runWorkspaceSavePreflight({ cwd: root });
+  const plan = planWorkspaceReleaseBump(level, root);
+  applyWorkspaceVersionChanges(plan);
+  const rootVersion = bumpRootPackageJson(root, level);
+  run("git", ["checkout", STAGING_BRANCH], { cwd: gitRoot });
+  run("git", ["add", "-A"], { cwd: gitRoot });
+  run("git", ["commit", "-m", `release: ${level} bump`], { cwd: gitRoot });
+  pushBranch(gitRoot, STAGING_BRANCH);
+  mergeStagingIntoMain(root);
+  return {
+    ...guidedResult({
+      command: commandName,
+      summary: `Treeseed ${commandName} completed successfully.`,
+      facts: [
+        { label: "Staging branch", value: STAGING_BRANCH },
+        { label: "Production branch", value: PRODUCTION_BRANCH },
+        { label: "Release level", value: level ?? "(unknown)" },
+        { label: "Root version", value: rootVersion },
+        { label: "Updated packages", value: plan.touched.size }
+      ],
+      nextSteps: [
+        "Monitor CI for the production deployment triggered from main.",
+        "treeseed status"
+      ],
+      report: {
+        level,
+        rootVersion,
+        stagingBranch: STAGING_BRANCH,
+        productionBranch: PRODUCTION_BRANCH,
+        touchedPackages: [...plan.touched]
+      }
+    })
+  };
+};
+export {
+  handleRelease
+};

package/dist/cli/handlers/rollback.js

@@ -0,0 +1,163 @@
+import { existsSync, mkdtempSync, symlinkSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, relative, resolve } from "node:path";
+import { applyTreeseedEnvironmentToProcess } from "../../scripts/config-runtime-lib.js";
+import {
+  createPersistentDeployTarget,
+  deployTargetLabel,
+  ensureGeneratedWranglerConfig,
+  finalizeDeploymentState,
+  loadDeployState
+} from "../../scripts/deploy-lib.js";
+import { loadCliDeployConfig, packageScriptPath, resolveWranglerBin } from "../../scripts/package-tools.js";
+import { run } from "../../scripts/workspace-tools.js";
+import { repoRoot } from "../../scripts/workspace-save-lib.js";
+import { guidedResult } from "./utils.js";
+import { copyTreeseedOperationalState } from "../repair.js";
+function selectRollbackCommit(state, requested) {
+  const history = Array.isArray(state.deploymentHistory) ? state.deploymentHistory : [];
+  if (requested) return requested;
+  const latestCommit = typeof state.lastDeployedCommit === "string" ? state.lastDeployedCommit : null;
+  const previous = [...history].reverse().find((entry) => typeof entry.commit === "string" && entry.commit !== latestCommit);
+  return typeof previous?.commit === "string" ? previous.commit : latestCommit;
+}
+function selectRollbackEntry(state, requested) {
+  const history = Array.isArray(state.deploymentHistory) ? state.deploymentHistory : [];
+  if (requested) {
+    return history.find((entry) => entry.commit === requested) ?? null;
+  }
+  const latestCommit = typeof state.lastDeployedCommit === "string" ? state.lastDeployedCommit : null;
+  return [...history].reverse().find((entry) => typeof entry.commit === "string" && entry.commit !== latestCommit) ?? null;
+}
+function isRollbackCompatible(state, candidate) {
+  if (!candidate) {
+    return { ok: true, reason: null };
+  }
+  const current = state.runtimeCompatibility;
+  const currentGeneration = typeof current?.envelopeSchemaGeneration === "string" ? current.envelopeSchemaGeneration : null;
+  const currentWave = typeof current?.migrationWaveId === "string" ? current.migrationWaveId : null;
+  const candidateGeneration = typeof candidate.envelopeSchemaGeneration === "string" ? candidate.envelopeSchemaGeneration : null;
+  const candidateWave = typeof candidate.migrationWaveId === "string" ? candidate.migrationWaveId : null;
+  if (currentGeneration && candidateGeneration && currentGeneration !== candidateGeneration) {
+    return { ok: false, reason: `Rollback target uses envelope generation ${candidateGeneration} but the current environment is on ${currentGeneration}.` };
+  }
+  if (currentWave && candidateWave && currentWave !== candidateWave) {
+    return { ok: false, reason: `Rollback target was deployed before migration wave ${currentWave} and cannot be safely reused without a forward-compatible data bridge.` };
+  }
+  return { ok: true, reason: null };
+}
+function runGitWorktree(repoDir, args) {
+  return run("git", ["worktree", ...args], { cwd: repoDir, capture: true });
+}
+const handleRollback = (invocation, context) => {
+  const scope = invocation.positionals[0];
+  if (scope !== "staging" && scope !== "prod") {
+    return guidedResult({
+      command: "rollback",
+      summary: "Treeseed rollback requires an explicit persistent target.",
+      facts: [{ label: "Provided target", value: scope ?? "(none)" }],
+      nextSteps: ["treeseed rollback staging", "treeseed rollback prod"],
+      report: { scope: scope ?? null },
+      exitCode: 1
+    });
+  }
+  const requestedCommit = typeof invocation.args.to === "string" ? invocation.args.to : null;
+  const tenantRoot = context.cwd;
+  const deployConfig = loadCliDeployConfig(tenantRoot);
+  const target = createPersistentDeployTarget(scope);
+  const state = loadDeployState(tenantRoot, deployConfig, { target });
+  const rollbackEntry = selectRollbackEntry(state, requestedCommit);
+  const rollbackCommit = selectRollbackCommit(state, requestedCommit);
+  if (!rollbackCommit) {
+    return guidedResult({
+      command: "rollback",
+      summary: `No rollback candidate is recorded for ${scope}.`,
+      facts: [{ label: "Target", value: scope }],
+      nextSteps: ["treeseed status"],
+      report: { scope, rollbackCommit: null, deploymentHistory: state.deploymentHistory ?? [] },
+      exitCode: 1
+    });
+  }
+  const compatibility = isRollbackCompatible(state, rollbackEntry);
+  if (!compatibility.ok) {
+    return guidedResult({
+      command: "rollback",
+      summary: `Treeseed rollback refused for ${scope}.`,
+      facts: [
+        { label: "Target", value: scope },
+        { label: "Requested commit", value: rollbackCommit },
+        { label: "Reason", value: compatibility.reason ?? "Unknown compatibility boundary" }
+      ],
+      nextSteps: ["treeseed status", `treeseed publish --environment ${scope}`],
+      report: { scope, rollbackCommit, compatibility, deploymentHistory: state.deploymentHistory ?? [] },
+      exitCode: 1
+    });
+  }
+  const gitRoot = repoRoot(tenantRoot);
+  const tenantRelativePath = relative(gitRoot, tenantRoot);
+  const tempRoot = mkdtempSync(join(tmpdir(), "treeseed-rollback-"));
+  const tempTenantRoot = resolve(tempRoot, tenantRelativePath);
+  const currentNodeModules = resolve(tenantRoot, "node_modules");
+  let finalizedState = null;
+  try {
+    runGitWorktree(gitRoot, ["add", "--detach", tempRoot, rollbackCommit]);
+    copyTreeseedOperationalState(tenantRoot, tempTenantRoot);
+    if (existsSync(currentNodeModules) && !existsSync(resolve(tempTenantRoot, "node_modules"))) {
+      symlinkSync(currentNodeModules, resolve(tempTenantRoot, "node_modules"), "dir");
+    }
+    applyTreeseedEnvironmentToProcess({ tenantRoot, scope });
+    const { wranglerPath } = ensureGeneratedWranglerConfig(tempTenantRoot, { target });
+    const buildResult = context.spawn(process.execPath, [packageScriptPath("tenant-build")], {
+      cwd: tempTenantRoot,
+      env: { ...context.env },
+      stdio: "inherit"
+    });
+    if ((buildResult.status ?? 1) !== 0) {
+      return { exitCode: buildResult.status ?? 1 };
+    }
+    const publishResult = context.spawn(process.execPath, [resolveWranglerBin(), "deploy", "--config", wranglerPath], {
+      cwd: tempTenantRoot,
+      env: { ...context.env },
+      stdio: "inherit"
+    });
+    if ((publishResult.status ?? 1) !== 0) {
+      return { exitCode: publishResult.status ?? 1 };
+    }
+    const previousCommit = process.env.TREESEED_DEPLOY_COMMIT;
+    process.env.TREESEED_DEPLOY_COMMIT = rollbackCommit;
+    try {
+      finalizedState = finalizeDeploymentState(tenantRoot, { target });
+    } finally {
+      if (previousCommit) {
+        process.env.TREESEED_DEPLOY_COMMIT = previousCommit;
+      } else {
+        delete process.env.TREESEED_DEPLOY_COMMIT;
+      }
+    }
+  } finally {
+    try {
+      runGitWorktree(gitRoot, ["remove", "--force", tempRoot]);
+    } catch {
+    }
+  }
+  return guidedResult({
+    command: "rollback",
+    summary: `Treeseed rollback completed for ${scope}.`,
+    facts: [
+      { label: "Target", value: deployTargetLabel(target) },
+      { label: "Rolled back commit", value: rollbackCommit },
+      { label: "Deployed URL", value: finalizedState?.lastDeployedUrl }
+    ],
+    nextSteps: ["treeseed status", `treeseed publish --environment ${scope}`],
+    report: {
+      scope,
+      rollbackCommit,
+      rollbackEntry,
+      target: deployTargetLabel(target),
+      finalizedState
+    }
+  });
+};
+export {
+  handleRollback
+};

package/dist/cli/handlers/save.js

@@ -0,0 +1,87 @@
+import { applyTreeseedEnvironmentToProcess } from "../../scripts/config-runtime-lib.js";
+import {
+  collectMergeConflictReport,
+  currentBranch,
+  formatMergeConflictReport,
+  hasMeaningfulChanges,
+  originRemoteUrl,
+  repoRoot
+} from "../../scripts/workspace-save-lib.js";
+import { PRODUCTION_BRANCH, STAGING_BRANCH, remoteBranchExists } from "../../scripts/git-workflow-lib.js";
+import { run, workspaceRoot } from "../../scripts/workspace-tools.js";
+import { runWorkspaceSavePreflight } from "../../scripts/save-deploy-preflight-lib.js";
+import { guidedResult } from "./utils.js";
+const handleSave = (invocation, context) => {
+  const commandName = invocation.commandName || "save";
+  const optionsHotfix = invocation.args.hotfix === true;
+  const message = invocation.positionals.join(" ").trim();
+  const root = workspaceRoot();
+  const gitRoot = repoRoot(root);
+  const branch = currentBranch(gitRoot);
+  const scope = branch === STAGING_BRANCH ? "staging" : branch === PRODUCTION_BRANCH ? "prod" : "local";
+  applyTreeseedEnvironmentToProcess({ tenantRoot: root, scope });
+  if (!message) {
+    return { exitCode: 1, stderr: [`Treeseed ${commandName} requires a commit message. Usage: treeseed ${commandName} <message>`] };
+  }
+  if (!branch) {
+    return { exitCode: 1, stderr: ["Treeseed save requires an active git branch."] };
+  }
+  if (branch === PRODUCTION_BRANCH && !optionsHotfix) {
+    return {
+      exitCode: 1,
+      stderr: [`Treeseed ${commandName} is blocked on main. Use \`treeseed promote\` for normal production promotion or \`treeseed ${commandName} --hotfix\` for an explicit hotfix.`]
+    };
+  }
+  try {
+    originRemoteUrl(gitRoot);
+  } catch {
+    return { exitCode: 1, stderr: [`Treeseed ${commandName} requires an origin remote.`] };
+  }
+  try {
+    runWorkspaceSavePreflight({ cwd: root });
+  } catch (error) {
+    return { exitCode: error?.exitCode ?? 1, stderr: [error instanceof Error ? error.message : String(error)] };
+  }
+  if (!hasMeaningfulChanges(gitRoot)) {
+    return { exitCode: 1, stderr: [`Treeseed ${commandName} found no meaningful repository changes to commit.`] };
+  }
+  run("git", ["add", "-A"], { cwd: gitRoot });
+  run("git", ["commit", "-m", message], { cwd: gitRoot });
+  try {
+    if (remoteBranchExists(gitRoot, branch)) {
+      run("git", ["pull", "--rebase", "origin", branch], { cwd: gitRoot });
+      run("git", ["push", "origin", branch], { cwd: gitRoot });
+    } else {
+      run("git", ["push", "-u", "origin", branch], { cwd: gitRoot });
+    }
+  } catch {
+    const report = collectMergeConflictReport(gitRoot);
+    return {
+      exitCode: 12,
+      stderr: [formatMergeConflictReport(report, gitRoot, branch)]
+    };
+  }
+  return {
+    ...guidedResult({
+      command: commandName,
+      summary: `Treeseed ${commandName} completed successfully.`,
+      facts: [
+        { label: "Branch", value: branch },
+        { label: "Environment scope", value: scope },
+        { label: "Hotfix", value: optionsHotfix ? "yes" : "no" }
+      ],
+      nextSteps: [
+        branch === STAGING_BRANCH ? "treeseed deploy --environment staging" : branch === PRODUCTION_BRANCH ? "Monitor CI or run `treeseed deploy --environment prod` only if you intentionally need a manual production publish." : "treeseed close"
+      ],
+      report: {
+        branch,
+        scope,
+        hotfix: optionsHotfix,
+        message
+      }
+    })
+  };
+};
+export {
+  handleSave
+};

package/dist/cli/handlers/setup.js

@@ -0,0 +1,48 @@
+import { handleConfig } from "./config.js";
+import { handleDoctor } from "./doctor.js";
+import { guidedResult } from "./utils.js";
+import { applyTreeseedSafeRepairs } from "../repair.js";
+import { resolveTreeseedWorkflowState } from "../workflow-state.js";
+const handleSetup = async (invocation, context) => {
+  const tenantRoot = context.cwd;
+  const scopes = Array.isArray(invocation.args.environment) ? invocation.args.environment : invocation.args.environment ? [invocation.args.environment] : ["local"];
+  const repairs = resolveTreeseedWorkflowState(tenantRoot).deployConfigPresent ? applyTreeseedSafeRepairs(tenantRoot) : [];
+  const configResult = await handleConfig({
+    ...invocation,
+    commandName: "config",
+    args: {
+      ...invocation.args,
+      environment: scopes,
+      sync: invocation.args.sync ?? "none"
+    },
+    positionals: [],
+    rawArgs: [
+      ...scopes.flatMap((scope) => ["--environment", scope]),
+      ...invocation.args.json === true ? ["--json"] : []
+    ]
+  }, context);
+  if ((configResult.exitCode ?? 0) !== 0) {
+    return configResult;
+  }
+  const doctorResult = handleDoctor({ ...invocation, args: { ...invocation.args } }, context);
+  const doctorPayload = doctorResult.report ?? {};
+  return guidedResult({
+    command: "setup",
+    summary: "Treeseed setup completed.",
+    facts: [
+      { label: "Initialized environments", value: scopes.join(", ") },
+      { label: "Safe repairs", value: repairs.length },
+      { label: "Blocking issues remaining", value: Array.isArray(doctorPayload.mustFixNow) ? doctorPayload.mustFixNow?.length ?? 0 : 0 }
+    ],
+    nextSteps: ["treeseed dev", "treeseed work feature/my-change"],
+    report: {
+      repairs,
+      scopes,
+      config: configResult.report,
+      doctor: doctorPayload
+    }
+  });
+};
+export {
+  handleSetup
+};

package/dist/cli/handlers/ship.js

@@ -0,0 +1,49 @@
+import { guidedResult } from "./utils.js";
+import { handleSave } from "./save.js";
+import { handleDeploy } from "./deploy.js";
+import { resolveTreeseedWorkflowState } from "../workflow-state.js";
+const handleShip = async (invocation, context) => {
+  const beforeState = resolveTreeseedWorkflowState(context.cwd);
+  const saveResult = await handleSave({
+    ...invocation,
+    commandName: "save"
+  }, context);
+  if ((saveResult.exitCode ?? 0) !== 0) {
+    return saveResult;
+  }
+  let previewRefresh = null;
+  if (beforeState.branchRole === "feature" && beforeState.preview.enabled && beforeState.branchName) {
+    const publishResult = await handleDeploy({
+      commandName: "deploy",
+      args: {
+        targetBranch: beforeState.branchName,
+        json: invocation.args.json
+      },
+      positionals: [],
+      rawArgs: ["--target-branch", beforeState.branchName, ...invocation.args.json === true ? ["--json"] : []]
+    }, context);
+    if ((publishResult.exitCode ?? 0) !== 0) {
+      return publishResult;
+    }
+    previewRefresh = publishResult.report ?? null;
+  }
+  const afterState = resolveTreeseedWorkflowState(context.cwd);
+  return guidedResult({
+    command: "ship",
+    summary: "Treeseed ship completed successfully.",
+    facts: [
+      { label: "Branch", value: afterState.branchName ?? beforeState.branchName ?? "(none)" },
+      { label: "Branch role", value: afterState.branchRole },
+      { label: "Preview refreshed", value: previewRefresh ? "yes" : "no" }
+    ],
+    nextSteps: afterState.recommendations.map((item) => `${item.command}  # ${item.reason}`),
+    report: {
+      state: afterState,
+      save: saveResult.report,
+      previewRefresh
+    }
+  });
+};
+export {
+  handleShip
+};

package/dist/cli/handlers/start.js

@@ -0,0 +1,97 @@
+import {
+  applyTreeseedEnvironmentToProcess,
+  assertTreeseedCommandEnvironment
+} from "../../scripts/config-runtime-lib.js";
+import {
+  createBranchPreviewDeployTarget,
+  deployTargetLabel,
+  ensureGeneratedWranglerConfig,
+  finalizeDeploymentState,
+  printDeploySummary,
+  provisionCloudflareResources,
+  runRemoteD1Migrations,
+  syncCloudflareSecrets,
+  validateDeployPrerequisites
+} from "../../scripts/deploy-lib.js";
+import { createFeatureBranchFromStaging, pushBranch } from "../../scripts/git-workflow-lib.js";
+import { packageScriptPath, resolveWranglerBin } from "../../scripts/package-tools.js";
+import { guidedResult } from "./utils.js";
+function provisionBranchPreview(branchName, context, commandName = "start") {
+  const tenantRoot = context.cwd;
+  applyTreeseedEnvironmentToProcess({ tenantRoot, scope: "staging" });
+  assertTreeseedCommandEnvironment({ tenantRoot, scope: "staging", purpose: "deploy" });
+  validateDeployPrerequisites(tenantRoot, { requireRemote: true });
+  const target = createBranchPreviewDeployTarget(branchName);
+  const summary = provisionCloudflareResources(tenantRoot, { target });
+  printDeploySummary(summary);
+  const { wranglerPath } = ensureGeneratedWranglerConfig(tenantRoot, { target });
+  syncCloudflareSecrets(tenantRoot, { target });
+  runRemoteD1Migrations(tenantRoot, { target });
+  const buildResult = context.spawn(process.execPath, [packageScriptPath("tenant-build")], {
+    cwd: tenantRoot,
+    env: { ...context.env },
+    stdio: "inherit"
+  });
+  if ((buildResult.status ?? 1) !== 0) {
+    return { exitCode: buildResult.status ?? 1 };
+  }
+  const deployResult = context.spawn(process.execPath, [resolveWranglerBin(), "deploy", "--config", wranglerPath], {
+    cwd: tenantRoot,
+    env: { ...context.env },
+    stdio: "inherit"
+  });
+  if ((deployResult.status ?? 1) !== 0) {
+    return { exitCode: deployResult.status ?? 1 };
+  }
+  const state = finalizeDeploymentState(tenantRoot, { target });
+  return guidedResult({
+    command: commandName,
+    summary: `Treeseed ${commandName} preview completed for ${branchName}.`,
+    facts: [
+      { label: "Target", value: deployTargetLabel(target) },
+      { label: "Preview URL", value: state.lastDeployedUrl }
+    ],
+    nextSteps: [
+      'treeseed save "describe your change"',
+      `treeseed deploy --target-branch ${branchName}`
+    ],
+    report: {
+      branchName,
+      preview: true,
+      target: deployTargetLabel(target),
+      previewUrl: state.lastDeployedUrl
+    }
+  });
+}
+const handleStart = (invocation, context) => {
+  const commandName = invocation.commandName || "start";
+  const branchName = invocation.positionals[0];
+  const preview = invocation.args.preview === true;
+  const tenantRoot = context.cwd;
+  const result = createFeatureBranchFromStaging(tenantRoot, branchName);
+  pushBranch(result.repoDir, branchName, { setUpstream: true });
+  if (!preview) {
+    return guidedResult({
+      command: commandName,
+      summary: `Created feature branch ${branchName} from staging.`,
+      facts: [
+        { label: "Branch", value: branchName },
+        { label: "Preview", value: "disabled" }
+      ],
+      nextSteps: [
+        "treeseed dev",
+        'treeseed save "describe your change"'
+      ],
+      report: {
+        branchName,
+        preview: false,
+        baseBranch: result.baseBranch
+      }
+    });
+  }
+  return provisionBranchPreview(branchName, context, commandName);
+};
+export {
+  handleStart,
+  provisionBranchPreview
+};

package/dist/cli/handlers/status.js

@@ -0,0 +1,31 @@
+import { guidedResult } from "./utils.js";
+import { resolveTreeseedWorkflowState } from "../workflow-state.js";
+const handleStatus = (_invocation, context) => {
+  const state = resolveTreeseedWorkflowState(context.cwd);
+  return guidedResult({
+    command: "status",
+    summary: "Treeseed workflow status",
+    facts: [
+      { label: "Workspace root", value: state.workspaceRoot ? "yes" : "no" },
+      { label: "Tenant config present", value: state.deployConfigPresent ? "yes" : "no" },
+      { label: "Branch", value: state.branchName ?? "(none)" },
+      { label: "Branch role", value: state.branchRole },
+      { label: "Mapped environment", value: state.environment },
+      { label: "Dirty worktree", value: state.dirtyWorktree ? "yes" : "no" },
+      { label: "Local initialized", value: state.persistentEnvironments.local.initialized ? "yes" : "no" },
+      { label: "Staging initialized", value: state.persistentEnvironments.staging.initialized ? "yes" : "no" },
+      { label: "Prod initialized", value: state.persistentEnvironments.prod.initialized ? "yes" : "no" },
+      { label: "Preview enabled", value: state.preview.enabled ? "yes" : "no" },
+      { label: "Preview URL", value: state.preview.url ?? "(none)" },
+      { label: "GitHub auth", value: state.auth.gh ? "ready" : "not ready" },
+      { label: "Wrangler auth", value: state.auth.wrangler ? "ready" : "not ready" }
+    ],
+    nextSteps: state.recommendations.map((item) => `${item.command}  # ${item.reason}`),
+    report: {
+      state
+    }
+  });
+};
+export {
+  handleStatus
+};

package/dist/cli/handlers/teardown.js

@@ -0,0 +1,50 @@
+import { currentManagedBranch, PRODUCTION_BRANCH, STAGING_BRANCH } from "../../scripts/git-workflow-lib.js";
+import { guidedResult } from "./utils.js";
+import { handleClose } from "./close.js";
+import { handleDestroy } from "./destroy.js";
+const handleTeardown = async (invocation, context) => {
+  const commandName = invocation.commandName || "teardown";
+  const environment = typeof invocation.args.environment === "string" ? invocation.args.environment : null;
+  if (environment) {
+    return handleDestroy({
+      ...invocation,
+      commandName
+    }, context);
+  }
+  const branch = currentManagedBranch(context.cwd);
+  if (!branch || branch === STAGING_BRANCH || branch === PRODUCTION_BRANCH) {
+    return guidedResult({
+      command: commandName,
+      summary: "Treeseed teardown needs an explicit persistent environment on staging or main.",
+      facts: [{ label: "Current branch", value: branch ?? "(none)" }],
+      nextSteps: [
+        "treeseed teardown --environment staging",
+        "treeseed teardown --environment prod"
+      ],
+      report: {
+        branch
+      },
+      exitCode: 1
+    });
+  }
+  if (invocation.args.dryRun === true) {
+    return guidedResult({
+      command: commandName,
+      summary: `Dry run: Treeseed would merge ${branch} into staging and remove any branch preview artifacts.`,
+      facts: [{ label: "Branch", value: branch }],
+      nextSteps: ["treeseed teardown"],
+      report: {
+        branch,
+        dryRun: true,
+        mode: "feature-close"
+      }
+    });
+  }
+  return handleClose({
+    ...invocation,
+    commandName
+  }, context);
+};
+export {
+  handleTeardown
+};

package/dist/cli/handlers/utils.js

@@ -0,0 +1,59 @@
+function ok(lines = []) {
+  return { exitCode: 0, stdout: lines };
+}
+function fail(message, exitCode = 1) {
+  return { exitCode, stderr: [message] };
+}
+function guidedResult(options) {
+  const lines = [options.summary];
+  const facts = (options.facts ?? []).filter((fact) => fact.value !== void 0 && fact.value !== null && `${fact.value}`.length > 0);
+  if (facts.length > 0) {
+    lines.push("");
+    for (const fact of facts) {
+      lines.push(`${fact.label}: ${fact.value}`);
+    }
+  }
+  if ((options.nextSteps ?? []).length > 0) {
+    lines.push("", "Next steps:");
+    for (const step of options.nextSteps ?? []) {
+      lines.push(`- ${step}`);
+    }
+  }
+  return {
+    exitCode: options.exitCode ?? 0,
+    stdout: lines,
+    stderr: options.stderr,
+    report: {
+      command: options.command,
+      ok: (options.exitCode ?? 0) === 0,
+      summary: options.summary,
+      facts: facts.map((fact) => ({ label: fact.label, value: fact.value })),
+      nextSteps: options.nextSteps ?? [],
+      ...options.report ?? {}
+    }
+  };
+}
+function writeResult(result, context) {
+  if (context.outputFormat === "json") {
+    const payload = result.report ?? {
+      ok: (result.exitCode ?? 0) === 0,
+      stdout: result.stdout ?? [],
+      stderr: result.stderr ?? []
+    };
+    context.write(JSON.stringify(payload, null, 2), (result.exitCode ?? 0) === 0 ? "stdout" : "stderr");
+    return result.exitCode ?? 0;
+  }
+  for (const line of result.stdout ?? []) {
+    context.write(line, "stdout");
+  }
+  for (const line of result.stderr ?? []) {
+    context.write(line, "stderr");
+  }
+  return result.exitCode ?? 0;
+}
+export {
+  fail,
+  guidedResult,
+  ok,
+  writeResult
+};