@treeseed/sdk 0.1.2 → 0.3.1

package/dist/operations/services/workspace-save.js

@@ -0,0 +1,235 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { changedWorkspacePackages, publishableWorkspacePackages, run, sortWorkspacePackages, workspacePackages, workspaceRoot } from "./workspace-tools.js";
+const MERGE_CONFLICT_EXIT_CODE = 12;
+function parseSemver(version) {
+  const match = String(version).trim().match(/^(\d+)\.(\d+)\.(\d+)$/);
+  if (!match) {
+    throw new Error(`Unsupported version "${version}". Expected x.y.z.`);
+  }
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3])
+  };
+}
+function incrementPatchVersion(version) {
+  const parsed = parseSemver(version);
+  return `${parsed.major}.${parsed.minor}.${parsed.patch + 1}`;
+}
+function incrementVersion(version, level = "patch") {
+  const parsed = parseSemver(version);
+  if (level === "major") {
+    return `${parsed.major + 1}.0.0`;
+  }
+  if (level === "minor") {
+    return `${parsed.major}.${parsed.minor + 1}.0`;
+  }
+  if (level === "patch") {
+    return `${parsed.major}.${parsed.minor}.${parsed.patch + 1}`;
+  }
+  throw new Error(`Unsupported release bump "${level}". Expected major, minor, or patch.`);
+}
+function readPackageJson(filePath) {
+  return JSON.parse(readFileSync(filePath, "utf8"));
+}
+function writePackageJson(filePath, value) {
+  writeFileSync(filePath, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+function internalDependencyFields(packageJson) {
+  return ["dependencies", "optionalDependencies", "peerDependencies", "devDependencies"].filter((field) => packageJson[field] && typeof packageJson[field] === "object");
+}
+function planWorkspaceVersionChanges(root = workspaceRoot()) {
+  const packages = workspacePackages(root).map((pkg) => ({
+    ...pkg,
+    packageJsonPath: resolve(pkg.dir, "package.json"),
+    packageJson: readPackageJson(resolve(pkg.dir, "package.json"))
+  }));
+  const orderedPackages = sortWorkspacePackages(packages);
+  const publishable = new Set(publishableWorkspacePackages(root).map((pkg) => pkg.name));
+  const changedPublishable = new Set(
+    changedWorkspacePackages({
+      root,
+      packages: orderedPackages.filter((pkg) => publishable.has(pkg.name)),
+      includeDependents: false
+    }).map((pkg) => pkg.name)
+  );
+  const versions = new Map(orderedPackages.map((pkg) => [pkg.name, pkg.packageJson.version]));
+  const bumped = new Set(changedPublishable);
+  const touched = /* @__PURE__ */ new Set();
+  for (const name of changedPublishable) {
+    versions.set(name, incrementPatchVersion(versions.get(name)));
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const pkg of orderedPackages) {
+      let packageDependencyChanged = false;
+      for (const field of internalDependencyFields(pkg.packageJson)) {
+        for (const depName of Object.keys(pkg.packageJson[field] ?? {})) {
+          if (!versions.has(depName)) {
+            continue;
+          }
+          const nextSpec = `^${versions.get(depName)}`;
+          if (pkg.packageJson[field][depName] === nextSpec) {
+            continue;
+          }
+          pkg.packageJson[field][depName] = nextSpec;
+          packageDependencyChanged = true;
+          touched.add(pkg.name);
+        }
+      }
+      if (packageDependencyChanged && publishable.has(pkg.name) && !bumped.has(pkg.name)) {
+        bumped.add(pkg.name);
+        versions.set(pkg.name, incrementPatchVersion(versions.get(pkg.name)));
+        changed = true;
+      }
+    }
+  }
+  for (const pkg of orderedPackages) {
+    if (!bumped.has(pkg.name)) {
+      continue;
+    }
+    const nextVersion = versions.get(pkg.name);
+    if (pkg.packageJson.version !== nextVersion) {
+      pkg.packageJson.version = nextVersion;
+      touched.add(pkg.name);
+    }
+  }
+  return {
+    packages: orderedPackages,
+    publishable,
+    bumped,
+    touched
+  };
+}
+function applyWorkspaceVersionChanges(plan) {
+  for (const pkg of plan.packages) {
+    if (!plan.touched.has(pkg.name)) {
+      continue;
+    }
+    writePackageJson(pkg.packageJsonPath, pkg.packageJson);
+  }
+  return plan;
+}
+function planWorkspaceReleaseBump(level = "patch", root = workspaceRoot()) {
+  const packages = workspacePackages(root).map((pkg) => ({
+    ...pkg,
+    packageJsonPath: resolve(pkg.dir, "package.json"),
+    packageJson: readPackageJson(resolve(pkg.dir, "package.json"))
+  }));
+  const publishable = new Set(publishableWorkspacePackages(root).map((pkg) => pkg.name));
+  const touched = /* @__PURE__ */ new Set();
+  const versions = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    if (!publishable.has(pkg.name)) {
+      continue;
+    }
+    const nextVersion = incrementVersion(pkg.packageJson.version, level);
+    pkg.packageJson.version = nextVersion;
+    versions.set(pkg.name, nextVersion);
+    touched.add(pkg.name);
+  }
+  for (const pkg of packages) {
+    for (const field of internalDependencyFields(pkg.packageJson)) {
+      for (const depName of Object.keys(pkg.packageJson[field] ?? {})) {
+        if (!versions.has(depName)) {
+          continue;
+        }
+        pkg.packageJson[field][depName] = `^${versions.get(depName)}`;
+        touched.add(pkg.name);
+      }
+    }
+  }
+  return {
+    packages,
+    touched,
+    versions,
+    level
+  };
+}
+function repoRoot(cwd = workspaceRoot()) {
+  return run("git", ["rev-parse", "--show-toplevel"], { cwd, capture: true }).trim();
+}
+function currentBranch(repoDir) {
+  return run("git", ["branch", "--show-current"], { cwd: repoDir, capture: true }).trim();
+}
+function originRemoteUrl(repoDir) {
+  return run("git", ["remote", "get-url", "origin"], { cwd: repoDir, capture: true }).trim();
+}
+function gitStatusPorcelain(repoDir) {
+  return run("git", ["status", "--porcelain"], { cwd: repoDir, capture: true }).trim();
+}
+function hasMeaningfulChanges(repoDir) {
+  return gitStatusPorcelain(repoDir).length > 0;
+}
+function countConflictMarkers(source) {
+  return {
+    start: (source.match(/^<{7} /gm) ?? []).length,
+    middle: (source.match(/^={7}$/gm) ?? []).length,
+    end: (source.match(/^>{7} /gm) ?? []).length
+  };
+}
+function collectMergeConflictReport(repoDir) {
+  const branch = currentBranch(repoDir);
+  const conflictedFiles = run("git", ["diff", "--name-only", "--diff-filter=U"], {
+    cwd: repoDir,
+    capture: true
+  }).split("\n").map((line) => line.trim()).filter(Boolean);
+  const status = run("git", ["status", "--short"], { cwd: repoDir, capture: true });
+  const perFile = conflictedFiles.map((filePath) => {
+    const fullPath = resolve(repoDir, filePath);
+    const source = existsSync(fullPath) ? readFileSync(fullPath, "utf8") : "";
+    return {
+      filePath,
+      markers: countConflictMarkers(source),
+      diff: run("git", ["diff", "--", filePath], { cwd: repoDir, capture: true })
+    };
+  });
+  return {
+    branch,
+    rebaseInProgress: true,
+    conflictedFiles,
+    status,
+    perFile
+  };
+}
+function formatMergeConflictReport(report, repoDir, targetBranch = "main") {
+  const lines = [
+    `Treeseed save failed due to merge conflicts during \`git pull --rebase origin ${targetBranch}\`.`,
+    `Repository root: ${repoDir}`,
+    `Branch: ${report.branch}`,
+    `Rebase in progress: ${report.rebaseInProgress ? "yes" : "no"}`,
+    "Git status:",
+    report.status || "(no git status output)",
+    "Conflicted files:"
+  ];
+  for (const file of report.perFile) {
+    lines.push(`- ${file.filePath}`);
+    lines.push(`  markers: start=${file.markers.start} middle=${file.markers.middle} end=${file.markers.end}`);
+    lines.push("  diff:");
+    lines.push(file.diff || "  (no diff output)");
+  }
+  lines.push("Next steps:");
+  lines.push("- Inspect conflicted files and reconcile local vs remote changes.");
+  lines.push("- After resolving files, run `git add <files>` and `git rebase --continue`.");
+  lines.push("- Or abort with `git rebase --abort` if you need to restart the save flow.");
+  return lines.join("\n");
+}
+export {
+  MERGE_CONFLICT_EXIT_CODE,
+  applyWorkspaceVersionChanges,
+  collectMergeConflictReport,
+  countConflictMarkers,
+  currentBranch,
+  formatMergeConflictReport,
+  gitStatusPorcelain,
+  hasMeaningfulChanges,
+  incrementPatchVersion,
+  incrementVersion,
+  originRemoteUrl,
+  planWorkspaceReleaseBump,
+  planWorkspaceVersionChanges,
+  repoRoot
+};

package/dist/operations/services/workspace-tools.d.ts

@@ -0,0 +1,16 @@
+export declare function workspaceRoot(startCwd?: string): any;
+export declare function findNearestTreeseedRoot(startCwd?: string): string | null;
+export declare function isWorkspaceRoot(root?: string): any;
+export declare function hasCompleteTreeseedPackageCheckout(root?: string): boolean;
+export declare function findNearestTreeseedWorkspaceRoot(startCwd?: string): any;
+export declare function readJson(filePath: any): any;
+export declare function workspacePackageJson(root?: any): any;
+export declare function workspacePatterns(root?: any): any;
+export declare function workspacePackages(root?: any): any[];
+export declare function sortWorkspacePackages(packages: any): any[];
+export declare function packagesWithScript(scriptName: any, root?: any): any[];
+export declare function run(command: any, args: any, options?: {}): string;
+export declare function changedWorkspacePackages(options?: {}): any[];
+export declare function publishableWorkspacePackages(root?: any): any[];
+export declare function createTempDir(prefix: any): string;
+export declare function cleanupDir(dirPath: any): void;

package/dist/operations/services/workspace-tools.js

@@ -0,0 +1,270 @@
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { join, relative, resolve } from "node:path";
+const TREESEED_WORKSPACE_PACKAGE_DIRS = ["sdk", "core", "cli", "agent", "api"];
+function escapeRegex(source) {
+  return source.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+}
+function segmentPatternToRegex(pattern) {
+  return new RegExp(`^${escapeRegex(pattern).replaceAll("*", ".*")}$`);
+}
+function expandWorkspacePattern(root, pattern) {
+  const segments = pattern.split(/[\\/]+/).filter(Boolean);
+  const results = [];
+  function visit(baseDir, index) {
+    if (index >= segments.length) {
+      results.push(baseDir);
+      return;
+    }
+    const segment = segments[index];
+    if (!segment.includes("*")) {
+      const nextDir = resolve(baseDir, segment);
+      if (existsSync(nextDir)) {
+        visit(nextDir, index + 1);
+      }
+      return;
+    }
+    if (!existsSync(baseDir)) {
+      return;
+    }
+    const matcher = segmentPatternToRegex(segment);
+    for (const entry of readdirSync(baseDir, { withFileTypes: true })) {
+      if (!entry.isDirectory() || !matcher.test(entry.name)) {
+        continue;
+      }
+      visit(resolve(baseDir, entry.name), index + 1);
+    }
+  }
+  visit(root, 0);
+  return results;
+}
+function workspaceRoot(startCwd = process.cwd()) {
+  return findNearestTreeseedWorkspaceRoot(startCwd) ?? resolve(startCwd);
+}
+function findNearestTreeseedRoot(startCwd = process.cwd()) {
+  let current = resolve(startCwd);
+  while (true) {
+    if (existsSync(resolve(current, "treeseed.site.yaml"))) {
+      return current;
+    }
+    const parent = resolve(current, "..");
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function isWorkspaceRoot(root = process.cwd()) {
+  try {
+    return workspacePatterns(root).length > 0 || hasCompleteTreeseedPackageCheckout(root);
+  } catch {
+    return false;
+  }
+}
+function hasCompleteTreeseedPackageCheckout(root = process.cwd()) {
+  return TREESEED_WORKSPACE_PACKAGE_DIRS.every((dirName) => existsSync(resolve(root, "packages", dirName, "package.json")));
+}
+function findNearestTreeseedWorkspaceRoot(startCwd = process.cwd()) {
+  const tenantRoot = findNearestTreeseedRoot(startCwd);
+  if (!tenantRoot) {
+    return null;
+  }
+  return isWorkspaceRoot(tenantRoot) ? tenantRoot : null;
+}
+function readJson(filePath) {
+  return JSON.parse(readFileSync(filePath, "utf8"));
+}
+function workspacePackageJson(root = workspaceRoot()) {
+  return readJson(resolve(root, "package.json"));
+}
+function workspacePatterns(root = workspaceRoot()) {
+  const packageJson = workspacePackageJson(root);
+  const workspaces = Array.isArray(packageJson.workspaces) ? packageJson.workspaces : Array.isArray(packageJson.workspaces?.packages) ? packageJson.workspaces.packages : [];
+  const patterns = workspaces.filter((value) => typeof value === "string" && value.trim().length > 0);
+  if (patterns.length > 0) {
+    return patterns;
+  }
+  return hasCompleteTreeseedPackageCheckout(root) ? ["packages/*"] : [];
+}
+function workspacePackages(root = workspaceRoot()) {
+  const discovered = /* @__PURE__ */ new Map();
+  for (const pattern of workspacePatterns(root)) {
+    for (const dir of expandWorkspacePattern(root, pattern)) {
+      const packageJsonPath = resolve(dir, "package.json");
+      if (!existsSync(packageJsonPath)) {
+        continue;
+      }
+      const packageJson = readJson(packageJsonPath);
+      discovered.set(dir, {
+        dir,
+        name: packageJson.name,
+        packageJson,
+        relativeDir: relative(root, dir).replaceAll("\\", "/")
+      });
+    }
+  }
+  return [...discovered.values()].sort((left, right) => left.name.localeCompare(right.name));
+}
+function internalDependenciesFor(pkg, packageNames) {
+  const internalDeps = /* @__PURE__ */ new Set();
+  for (const field of ["dependencies", "optionalDependencies", "peerDependencies", "devDependencies"]) {
+    for (const name of Object.keys(pkg.packageJson[field] ?? {})) {
+      if (packageNames.has(name)) {
+        internalDeps.add(name);
+      }
+    }
+  }
+  return internalDeps;
+}
+function sortWorkspacePackages(packages) {
+  const packageMap = new Map(packages.map((pkg) => [pkg.name, pkg]));
+  const packageNames = new Set(packageMap.keys());
+  const dependents = new Map(packages.map((pkg) => [pkg.name, /* @__PURE__ */ new Set()]));
+  const indegree = new Map(packages.map((pkg) => [pkg.name, 0]));
+  for (const pkg of packages) {
+    for (const dep of internalDependenciesFor(pkg, packageNames)) {
+      dependents.get(dep)?.add(pkg.name);
+      indegree.set(pkg.name, (indegree.get(pkg.name) ?? 0) + 1);
+    }
+  }
+  const ready = [...packages].filter((pkg) => (indegree.get(pkg.name) ?? 0) === 0).sort((left, right) => left.name.localeCompare(right.name));
+  const ordered = [];
+  while (ready.length > 0) {
+    const next = ready.shift();
+    if (!next) {
+      break;
+    }
+    ordered.push(next);
+    for (const dependentName of [...dependents.get(next.name) ?? []].sort()) {
+      const nextDegree = (indegree.get(dependentName) ?? 0) - 1;
+      indegree.set(dependentName, nextDegree);
+      if (nextDegree === 0) {
+        const dependent = packageMap.get(dependentName);
+        if (dependent) {
+          ready.push(dependent);
+          ready.sort((left, right) => left.name.localeCompare(right.name));
+        }
+      }
+    }
+  }
+  if (ordered.length !== packages.length) {
+    return [...packages].sort((left, right) => left.name.localeCompare(right.name));
+  }
+  return ordered;
+}
+function packagesWithScript(scriptName, root = workspaceRoot()) {
+  return sortWorkspacePackages(
+    workspacePackages(root).filter((pkg) => typeof pkg.packageJson.scripts?.[scriptName] === "string")
+  );
+}
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: options.cwd ?? workspaceRoot(),
+    env: { ...process.env, ...options.env ?? {} },
+    stdio: options.capture ? "pipe" : "inherit",
+    encoding: "utf8",
+    timeout: options.timeoutMs
+  });
+  if (result.status !== 0) {
+    const message = (result.error?.message ? `${result.error.message}
+` : "") + (result.stderr?.trim() || result.stdout?.trim() || `${command} ${args.join(" ")} failed`);
+    throw new Error(message);
+  }
+  return (result.stdout ?? "").trim();
+}
+function canResolveGitRef(baseRef, cwd = workspaceRoot()) {
+  const result = spawnSync("git", ["rev-parse", "--verify", baseRef], {
+    cwd,
+    stdio: "pipe",
+    encoding: "utf8"
+  });
+  return result.status === 0;
+}
+function resolveChangedFilesBaseRef(baseRef, cwd = workspaceRoot()) {
+  if (canResolveGitRef(baseRef, cwd)) {
+    return baseRef;
+  }
+  return null;
+}
+function changedWorkspaceFiles(baseRef, cwd = workspaceRoot()) {
+  const changedFiles = /* @__PURE__ */ new Set();
+  const resolvedBaseRef = resolveChangedFilesBaseRef(baseRef, cwd);
+  const diffCommands = [
+    ["diff", "--name-only"],
+    ["diff", "--name-only", "--cached"],
+    ["ls-files", "--others", "--exclude-standard"]
+  ];
+  if (resolvedBaseRef) {
+    diffCommands.unshift(["diff", "--name-only", resolvedBaseRef, "HEAD"]);
+  }
+  for (const args of diffCommands) {
+    const output = run("git", args, { cwd, capture: true });
+    for (const line of output.split("\n").map((entry) => entry.trim()).filter(Boolean)) {
+      changedFiles.add(line);
+    }
+  }
+  return changedFiles;
+}
+function changedWorkspacePackages(options = {}) {
+  const root = options.root ?? workspaceRoot();
+  const baseRef = options.baseRef ?? process.env.TREESEED_RELEASE_BASE_REF ?? "HEAD^";
+  const includeDependents = options.includeDependents ?? false;
+  const packages = options.packages ?? workspacePackages(root);
+  const changedFiles = changedWorkspaceFiles(baseRef, root);
+  const changed = new Set(
+    packages.filter((pkg) => [...changedFiles].some((file) => file === pkg.relativeDir || file.startsWith(`${pkg.relativeDir}/`))).map((pkg) => pkg.name)
+  );
+  if (includeDependents && changed.size > 0) {
+    const packageMap = new Map(packages.map((pkg) => [pkg.name, pkg]));
+    const packageNames = new Set(packageMap.keys());
+    const reverseDeps = new Map(packages.map((pkg) => [pkg.name, /* @__PURE__ */ new Set()]));
+    for (const pkg of packages) {
+      for (const dep of internalDependenciesFor(pkg, packageNames)) {
+        reverseDeps.get(dep)?.add(pkg.name);
+      }
+    }
+    const queue = [...changed];
+    while (queue.length > 0) {
+      const next = queue.shift();
+      for (const dependent of reverseDeps.get(next) ?? []) {
+        if (changed.has(dependent)) {
+          continue;
+        }
+        changed.add(dependent);
+        queue.push(dependent);
+      }
+    }
+  }
+  return sortWorkspacePackages(packages.filter((pkg) => changed.has(pkg.name)));
+}
+function publishableWorkspacePackages(root = workspaceRoot()) {
+  return packagesWithScript("release:publish", root);
+}
+function createTempDir(prefix) {
+  const baseRoot = resolve(process.env.TREESEED_TEMP_ROOT ?? resolve(workspaceRoot(), ".local", "tmp"));
+  mkdirSync(baseRoot, { recursive: true });
+  return mkdtempSync(join(baseRoot, prefix));
+}
+function cleanupDir(dirPath) {
+  if (dirPath && existsSync(dirPath)) {
+    rmSync(dirPath, { recursive: true, force: true });
+  }
+}
+export {
+  changedWorkspacePackages,
+  cleanupDir,
+  createTempDir,
+  findNearestTreeseedRoot,
+  findNearestTreeseedWorkspaceRoot,
+  hasCompleteTreeseedPackageCheckout,
+  isWorkspaceRoot,
+  packagesWithScript,
+  publishableWorkspacePackages,
+  readJson,
+  run,
+  sortWorkspacePackages,
+  workspacePackageJson,
+  workspacePackages,
+  workspacePatterns,
+  workspaceRoot
+};

package/dist/operations-registry.d.ts

@@ -0,0 +1,5 @@
+import type { TreeseedOperationMetadata } from './operations-types.ts';
+export declare const TRESEED_OPERATION_SPECS: TreeseedOperationMetadata[];
+export declare const TRESEED_OPERATION_INDEX: Map<string, TreeseedOperationMetadata>;
+export declare function findTreeseedOperation(name: string | null | undefined): TreeseedOperationMetadata | null;
+export declare function listTreeseedOperationNames(): string[];

package/dist/operations-registry.js

@@ -0,0 +1,68 @@
+function operation(spec) {
+  return spec;
+}
+const TRESEED_OPERATION_SPECS = [
+  operation({ id: "workspace.status", name: "status", aliases: [], group: "Workflow", summary: "Show Treeseed project health and the current task state.", description: "Report branch/task state, runtime readiness, preview/deploy state, auth readiness, and recommended next operations.", provider: "default", related: ["tasks", "switch", "config"] }),
+  operation({ id: "branch.tasks", name: "tasks", aliases: [], group: "Workflow", summary: "List task branches and preview metadata.", description: "List task-based preview Git branches from local and origin, excluding protected and deprecated refs.", provider: "default", related: ["status", "switch", "close"] }),
+  operation({ id: "branch.switch", name: "switch", aliases: [], group: "Workflow", summary: "Create or resume a task branch.", description: "Create a new task branch from staging or resume an existing local or remote task branch.", provider: "default", related: ["tasks", "dev", "save"] }),
+  operation({ id: "branch.save", name: "save", aliases: [], group: "Workflow", summary: "Verify, commit, sync, push, and refresh preview for the current task.", description: "Run lint, test, and build verification, sync the current branch with origin, push it, and refresh the branch preview when enabled.", provider: "default", related: ["switch", "stage", "status"] }),
+  operation({ id: "branch.close", name: "close", aliases: [], group: "Workflow", summary: "Archive a task branch without merging it.", description: "Destroy branch preview resources, create a deprecated resurrection tag, push the tag, and delete the local and remote branch.", provider: "default", related: ["tasks", "switch", "stage"] }),
+  operation({ id: "branch.stage", name: "stage", aliases: [], group: "Workflow", summary: "Merge the current task into staging and clean it up.", description: "Verify the current task branch, merge it into staging, wait for staging automation, clean preview resources, create a deprecated resurrection tag, and delete the task branch.", provider: "default", related: ["save", "release", "close"] }),
+  operation({ id: "deploy.rollback", name: "rollback", aliases: [], group: "Workflow", summary: "Roll back staging or production to a recorded deployment.", description: "Redeploy a previously recorded staging or production commit using a temporary checkout of that revision.", provider: "default", related: ["status", "release"] }),
+  operation({ id: "workspace.doctor", name: "doctor", aliases: [], group: "Validation", summary: "Diagnose Treeseed tooling, auth, and workflow readiness.", description: "Collect doctor-style diagnostics for workspace readiness and optional safe repairs.", provider: "default", related: ["status", "config"] }),
+  operation({ id: "auth.login", name: "auth:login", aliases: [], group: "Validation", summary: "Authenticate against the configured Treeseed API.", description: "Start the device login flow against the active Treeseed API host and persist the returned session locally.", provider: "default", related: ["auth:check", "auth:whoami", "auth:logout"] }),
+  operation({ id: "auth.logout", name: "auth:logout", aliases: [], group: "Validation", summary: "Clear locally stored Treeseed API credentials.", description: "Remove the persisted local device-flow session for the active Treeseed API host.", provider: "default", related: ["auth:login", "auth:whoami"] }),
+  operation({ id: "auth.whoami", name: "auth:whoami", aliases: [], group: "Validation", summary: "Inspect the active Treeseed API identity.", description: "Use the persisted local remote session to query the active Treeseed API principal.", provider: "default", related: ["auth:login", "status"] }),
+  operation({ id: "template.list", name: "template", aliases: [], group: "Utilities", summary: "List, inspect, and validate templates from the Treeseed catalog.", description: "Use remote template metadata to list templates, show one template, or validate local template artifacts.", provider: "default", related: ["init", "sync"] }),
+  operation({ id: "template.sync", name: "sync", aliases: [], group: "Validation", summary: "Validate or reconcile the managed template surface for the current site.", description: "Use remote template metadata plus the local scaffold artifact to check or apply updates to the managed scaffold surface.", provider: "default", related: ["template", "init", "status"] }),
+  operation({ id: "project.init", name: "init", aliases: [], group: "Workflow", summary: "Scaffold a new Treeseed tenant project.", description: "Create a new Treeseed tenant directory from a remote-catalog template backed by the packaged scaffold artifact.", provider: "default", related: ["config", "switch", "dev"] }),
+  operation({ id: "project.config", name: "config", aliases: [], group: "Workflow", summary: "Configure and test the runtime foundation.", description: "Apply safe repairs, collect environment values, write local machine config, generate local env files, initialize environments, sync providers, and run doctor-style checks.", provider: "default", related: ["status", "switch", "dev"] }),
+  operation({ id: "deploy.release", name: "release", aliases: [], group: "Workflow", summary: "Promote staging to production with a version bump.", description: "Validate staging, apply one version bump, tag the release, merge staging into main, push, and rely on production deploy automation.", provider: "default", related: ["stage", "status", "rollback"] }),
+  operation({ id: "deploy.destroy", name: "destroy", aliases: [], group: "Workflow", summary: "Destroy a persistent environment and its local state.", description: "Delete the selected persistent environment resources and remove the local deploy state after confirmation.", provider: "default", related: ["config", "status"] }),
+  operation({ id: "local.dev", name: "dev", aliases: [], group: "Local Development", summary: "Start the unified local Treeseed development environment.", description: "Start the unified local Treeseed development environment.", provider: "default" }),
+  operation({ id: "local.devWatch", name: "dev:watch", aliases: [], group: "Local Development", summary: "Start local development with rebuild and watch mode.", description: "Start local development with rebuild and watch mode.", provider: "default" }),
+  operation({ id: "local.build", name: "build", aliases: [], group: "Local Development", summary: "Build the tenant site and generated worker artifacts.", description: "Build the tenant site and generated worker artifacts.", provider: "default" }),
+  operation({ id: "local.check", name: "check", aliases: [], group: "Local Development", summary: "Run the tenant check flow.", description: "Run the tenant check flow.", provider: "default" }),
+  operation({ id: "local.preview", name: "preview", aliases: [], group: "Local Development", summary: "Preview the built tenant site locally.", description: "Preview the built tenant site locally.", provider: "default" }),
+  operation({ id: "local.lint", name: "lint", aliases: [], group: "Validation", summary: "Run Treeseed lint checks.", description: "Run Treeseed lint checks.", provider: "default" }),
+  operation({ id: "local.test", name: "test", aliases: [], group: "Validation", summary: "Run Treeseed tests.", description: "Run Treeseed tests.", provider: "default" }),
+  operation({ id: "validation.testUnit", name: "test:unit", aliases: [], group: "Validation", summary: "Run workspace unit tests in dependency order.", description: "Run workspace unit tests in dependency order.", provider: "default" }),
+  operation({ id: "validation.preflight", name: "preflight", aliases: [], group: "Validation", summary: "Check local prerequisites and authentication state.", description: "Check local prerequisites and authentication state.", provider: "default" }),
+  operation({ id: "validation.authCheck", name: "auth:check", aliases: [], group: "Validation", summary: "Check local prerequisites and require authenticated tooling.", description: "Check local prerequisites and require authenticated tooling.", provider: "default" }),
+  operation({ id: "release.testE2e", name: "test:e2e", aliases: [], group: "Release Utilities", summary: "Run Treeseed end-to-end command tests.", description: "Run Treeseed end-to-end command tests.", provider: "default" }),
+  operation({ id: "release.testE2eLocal", name: "test:e2e:local", aliases: [], group: "Release Utilities", summary: "Run local-mode Treeseed end-to-end command tests.", description: "Run local-mode Treeseed end-to-end command tests.", provider: "default" }),
+  operation({ id: "release.testE2eStaging", name: "test:e2e:staging", aliases: [], group: "Release Utilities", summary: "Run staging-mode Treeseed end-to-end command tests.", description: "Run staging-mode Treeseed end-to-end command tests.", provider: "default" }),
+  operation({ id: "release.testE2eFull", name: "test:e2e:full", aliases: [], group: "Release Utilities", summary: "Run the full Treeseed end-to-end command suite.", description: "Run the full Treeseed end-to-end command suite.", provider: "default" }),
+  operation({ id: "release.testFast", name: "test:release", aliases: [], group: "Release Utilities", summary: "Run the fast release verification path.", description: "Run the fast release verification path.", provider: "default" }),
+  operation({ id: "release.verify", name: "test:release:full", aliases: ["release:verify"], group: "Release Utilities", summary: "Run the full release verification path.", description: "Run the full release verification path.", provider: "default" }),
+  operation({ id: "release.publishChanged", name: "release:publish:changed", aliases: [], group: "Release Utilities", summary: "Publish changed Treeseed workspace packages.", description: "Publish changed Treeseed workspace packages.", provider: "default" }),
+  operation({ id: "tools.astro", name: "astro", aliases: [], group: "Passthrough", summary: "Pass through to the packaged Astro CLI wrapper.", description: "Pass through to the packaged Astro CLI wrapper.", provider: "default" }),
+  operation({ id: "tools.syncDevvars", name: "sync:devvars", aliases: [], group: "Utilities", summary: "Regenerate .dev.vars from local configuration.", description: "Regenerate .dev.vars from local configuration.", provider: "default" }),
+  operation({ id: "services.mailpitUp", name: "mailpit:up", aliases: [], group: "Utilities", summary: "Start the package-managed Mailpit service.", description: "Start the package-managed Mailpit service.", provider: "default" }),
+  operation({ id: "services.mailpitDown", name: "mailpit:down", aliases: [], group: "Utilities", summary: "Stop the package-managed Mailpit service.", description: "Stop the package-managed Mailpit service.", provider: "default" }),
+  operation({ id: "services.mailpitLogs", name: "mailpit:logs", aliases: [], group: "Utilities", summary: "Show Mailpit logs.", description: "Show Mailpit logs.", provider: "default" }),
+  operation({ id: "data.d1MigrateLocal", name: "d1:migrate:local", aliases: [], group: "Utilities", summary: "Apply local D1 migrations.", description: "Apply local D1 migrations.", provider: "default" }),
+  operation({ id: "content.cleanupMarkdown", name: "cleanup:markdown", aliases: [], group: "Utilities", summary: "Normalize Markdown and MDX files.", description: "Normalize Markdown and MDX files.", provider: "default" }),
+  operation({ id: "content.cleanupMarkdownCheck", name: "cleanup:markdown:check", aliases: [], group: "Utilities", summary: "Check Markdown and MDX formatting without rewriting files.", description: "Check Markdown and MDX formatting without rewriting files.", provider: "default" }),
+  operation({ id: "tools.starlightPatch", name: "starlight:patch", aliases: [], group: "Utilities", summary: "Apply the Starlight content path patch.", description: "Apply the Starlight content path patch.", provider: "default" })
+];
+const TRESEED_OPERATION_INDEX = /* @__PURE__ */ new Map();
+for (const spec of TRESEED_OPERATION_SPECS) {
+  TRESEED_OPERATION_INDEX.set(spec.name, spec);
+  for (const alias of spec.aliases) {
+    TRESEED_OPERATION_INDEX.set(alias, spec);
+  }
+}
+function findTreeseedOperation(name) {
+  if (!name) return null;
+  return TRESEED_OPERATION_INDEX.get(name) ?? null;
+}
+function listTreeseedOperationNames() {
+  return [...new Set(TRESEED_OPERATION_SPECS.map((spec) => spec.name))];
+}
+export {
+  TRESEED_OPERATION_INDEX,
+  TRESEED_OPERATION_SPECS,
+  findTreeseedOperation,
+  listTreeseedOperationNames
+};