@treeseed/cli 0.1.1 → 0.4.2

package/dist/cli/help.js

@@ -1,4 +1,4 @@
-import { findCommandSpec, listCommandNames, TRESEED_COMMAND_SPECS } from "./registry.js";
+import { findTreeseedOperation, listTreeseedOperationNames, TRESEED_OPERATION_SPECS } from "./operations-registry.js";
 const GROUP_ORDER = [
   "Workflow",
   "Local Development",
@@ -14,11 +14,7 @@ function levenshtein(left, right) {
   for (let i = 1; i <= left.length; i += 1) {
     for (let j = 1; j <= right.length; j += 1) {
       const cost = left[i - 1] === right[j - 1] ? 0 : 1;
-      rows[i][j] = Math.min(
-        rows[i - 1][j] + 1,
-        rows[i][j - 1] + 1,
-        rows[i - 1][j - 1] + cost
-      );
+      rows[i][j] = Math.min(rows[i - 1][j] + 1, rows[i][j - 1] + 1, rows[i - 1][j - 1] + cost);
     }
   }
   return rows[left.length][right.length];
@@ -31,7 +27,7 @@ ${lines.join("\n")}`;
 function groupedCommands() {
   const groups = /* @__PURE__ */ new Map();
   for (const group of GROUP_ORDER) groups.set(group, []);
-  for (const spec of TRESEED_COMMAND_SPECS) {
+  for (const spec of TRESEED_OPERATION_SPECS) {
     const entries = groups.get(spec.group) ?? [];
     entries.push(spec);
     groups.set(spec.group, entries);
@@ -47,16 +43,16 @@ function renderUsage(spec) {
 function suggestTreeseedCommands(input) {
   const normalized = input.trim().toLowerCase();
   if (!normalized) return [];
-  return listCommandNames().map((name) => ({ name, score: levenshtein(normalized, name) })).sort((left, right) => left.score - right.score || left.name.localeCompare(right.name)).slice(0, 3).map((entry) => entry.name);
+  return listTreeseedOperationNames().map((name) => ({ name, score: levenshtein(normalized, name) })).sort((left, right) => left.score - right.score || left.name.localeCompare(right.name)).slice(0, 3).map((entry) => entry.name);
 }
 function renderTreeseedHelp(commandName) {
   if (!commandName) {
     const groups = groupedCommands();
-    const primaryWorkflow = ["setup", "work", "dev", "ship", "publish", "promote", "rollback", "teardown"].map((name) => findCommandSpec(name)).filter((spec2) => Boolean(spec2));
-    const workflowGuidance = ["status", "next", "continue", "doctor"].map((name) => findCommandSpec(name)).filter((spec2) => Boolean(spec2));
+    const primaryWorkflow = ["init", "status", "config", "tasks", "switch", "dev", "save", "close", "stage", "release", "destroy"].map((name) => findTreeseedOperation(name)).filter((spec2) => Boolean(spec2));
+    const workflowGuidance = ["doctor", "rollback"].map((name) => findTreeseedOperation(name)).filter((spec2) => Boolean(spec2));
     const sections2 = [
       "Treeseed CLI",
-      "Unified TypeScript command interface for Treeseed project setup, branch workflow, deployment, and release automation.",
+      "Thin command wrapper over the Treeseed SDK workflow/operations surface plus the agent runtime namespace.",
       "",
       "Usage",
       "  treeseed <command> [args...]",
@@ -67,7 +63,7 @@ function renderTreeseedHelp(commandName) {
         return `  ${command.name}${spacer}${command.summary}`;
       })),
       "",
-      formatSection("Workflow Guidance", workflowGuidance.map((command) => {
+      formatSection("Workflow Support", workflowGuidance.map((command) => {
         const spacer = command.name.length < 18 ? " ".repeat(18 - command.name.length) : " ";
         return `  ${command.name}${spacer}${command.summary}`;
       })),
@@ -78,29 +74,45 @@ function renderTreeseedHelp(commandName) {
       }))).filter(Boolean),
       "",
       formatSection("Common Flows", [
-        "  treeseed setup",
-        "  treeseed work feature/my-change --preview",
-        '  treeseed ship "feat: describe your change"',
-        "  treeseed publish --environment staging",
-        "  treeseed promote --patch",
-        "  treeseed teardown"
+        "  treeseed status",
+        "  treeseed config",
+        "  treeseed switch feature/my-change --preview",
+        "  treeseed dev",
+        '  treeseed save "feat: describe your change"',
+        '  treeseed stage "feat: describe the resolution"',
+        "  treeseed release --patch"
       ]),
       "",
       formatSection("Help", [
         "  treeseed --help",
-        "  treeseed help publish",
-        "  treeseed publish --help"
+        "  treeseed help stage",
+        "  treeseed stage --help",
+        "  treeseed agents --help"
       ]),
       "",
       "Notes",
-      "  - Workspace-only commands must be run from a Treeseed workspace root.",
-      "  - Use `treeseed setup`, `treeseed work`, `treeseed ship`, `treeseed publish`, `treeseed promote`, and `treeseed teardown` for the simplified workflow.",
-      "  - `config`, `deploy`, `start`, `save`, `release`, `close`, and `destroy` remain available as compatibility commands.",
+      "  - Workspace-only commands must be run inside a Treeseed workspace; the CLI will resolve the project root from ancestor directories when possible.",
+      "  - Use `treeseed status`, `treeseed config`, `treeseed switch`, `treeseed save`, `treeseed stage`, and `treeseed release` for development and release work.",
+      '  - Use `treeseed close "reason"` to archive a task without merging; it creates a deprecated resurrection tag before deleting the branch.',
+      "  - Use `treeseed agents <command>` for agent runtime inspection and execution.",
       "  - Use `--json` on guidance and main workflow commands when an AI agent or script needs machine-readable output."
     ];
     return sections2.filter(Boolean).join("\n");
   }
-  const spec = findCommandSpec(commandName);
+  if (commandName === "agents") {
+    return [
+      "agents  Run the Treeseed agent runtime namespace.",
+      "",
+      "Usage",
+      "  treeseed agents <command>",
+      "  treeseed agents --help",
+      "",
+      "Notes",
+      "  - Delegates to the `@treeseed/agent` CLI contract.",
+      "  - Use `treeseed agents --help` to list supported agent subcommands."
+    ].join("\n");
+  }
+  const spec = findTreeseedOperation(commandName);
   if (!spec) {
     const suggestions = suggestTreeseedCommands(commandName);
     const lines = [`Unknown treeseed command: ${commandName}`];

package/dist/cli/main.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+export * from './runtime.js';
+export * from './help.js';
+export * from './parser.js';
+export * from './registry.js';
+export type * from './types.js';

package/dist/cli/main.js

@@ -1,27 +1,22 @@
 #!/usr/bin/env node
+import { realpathSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { resolve } from "node:path";
 import { runTreeseedCli } from "./runtime.js";
-import { runTreeseedCli as runTreeseedCli2, executeTreeseedCommand, createTreeseedCommandContext } from "./runtime.js";
-import { renderTreeseedHelp, renderUsage, suggestTreeseedCommands } from "./help.js";
-import { findCommandSpec, listCommandNames, TRESEED_COMMAND_SPECS } from "./registry.js";
-import { parseTreeseedInvocation, validateTreeseedInvocation } from "./parser.js";
-const currentFile = fileURLToPath(import.meta.url);
-const entryFile = resolve(process.argv[1] ?? "");
+export * from "./runtime.js";
+export * from "./help.js";
+export * from "./parser.js";
+export * from "./registry.js";
+function resolveExecutablePath(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return resolve(path);
+  }
+}
+const currentFile = resolveExecutablePath(fileURLToPath(import.meta.url));
+const entryFile = resolveExecutablePath(process.argv[1] ?? "");
 if (entryFile === currentFile) {
   const exitCode = await runTreeseedCli(process.argv.slice(2));
   process.exit(exitCode);
 }
-export {
-  TRESEED_COMMAND_SPECS,
-  createTreeseedCommandContext,
-  executeTreeseedCommand,
-  findCommandSpec,
-  listCommandNames,
-  parseTreeseedInvocation,
-  renderTreeseedHelp,
-  renderUsage,
-  runTreeseedCli2 as runTreeseedCli,
-  suggestTreeseedCommands,
-  validateTreeseedInvocation
-};

package/dist/cli/operations-help.d.ts

@@ -0,0 +1 @@
+export * from './help.ts';

package/dist/cli/operations-help.js

@@ -0,0 +1 @@
+export * from "./help.js";

package/dist/cli/operations-parser.d.ts

@@ -0,0 +1 @@
+export * from './parser.ts';

package/dist/cli/operations-parser.js

@@ -0,0 +1 @@
+export * from "./parser.js";

package/dist/cli/operations-registry.d.ts

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

package/dist/cli/operations-registry.js

@@ -0,0 +1,260 @@
+import {
+  findTreeseedOperation as findSdkOperation,
+  listTreeseedOperationNames as listSdkOperationNames,
+  TRESEED_OPERATION_SPECS as SDK_OPERATION_SPECS
+} from "@treeseed/sdk/operations";
+function command(overlay) {
+  return overlay;
+}
+const PASS_THROUGH_ARGS = (invocation) => ({ args: invocation.rawArgs });
+const CLI_COMMAND_OVERLAYS = /* @__PURE__ */ new Map([
+  ["status", command({
+    usage: "treeseed status [--json]",
+    options: [{ name: "json", flags: "--json", description: "Emit machine-readable JSON instead of human-readable text.", kind: "boolean" }],
+    examples: ["treeseed status", "treeseed status --json"],
+    executionMode: "handler",
+    handlerName: "status"
+  })],
+  ["tasks", command({
+    usage: "treeseed tasks [--json]",
+    options: [{ name: "json", flags: "--json", description: "Emit machine-readable JSON instead of human-readable text.", kind: "boolean" }],
+    examples: ["treeseed tasks", "treeseed tasks --json"],
+    executionMode: "handler",
+    handlerName: "tasks"
+  })],
+  ["switch", command({
+    usage: "treeseed switch <branch-name> [--preview] [--json]",
+    arguments: [{ name: "branch-name", description: "Task branch to create or resume.", required: true }],
+    options: [
+      { name: "preview", flags: "--preview", description: "Provision or refresh a branch-scoped Cloudflare preview environment.", kind: "boolean" },
+      { name: "json", flags: "--json", description: "Emit machine-readable JSON instead of human-readable text.", kind: "boolean" }
+    ],
+    examples: ["treeseed switch feature/search-improvements", "treeseed switch feature/search-improvements --preview"],
+    executionMode: "handler",
+    handlerName: "switch"
+  })],
+  ["save", command({
+    usage: "treeseed save [--hotfix] <message> [--json]",
+    arguments: [{ name: "message", description: "Git commit message for the save operation.", required: true, kind: "message_tail" }],
+    options: [
+      { name: "hotfix", flags: "--hotfix", description: "Allow save on main for an explicit hotfix.", kind: "boolean" },
+      { name: "json", flags: "--json", description: "Emit machine-readable JSON instead of human-readable text.", kind: "boolean" }
+    ],
+    examples: ['treeseed save "feat: add search filters"', 'treeseed save --hotfix "fix: unblock production form submit"'],
+    executionMode: "handler",
+    handlerName: "save"
+  })],
+  ["close", command({
+    usage: "treeseed close <message> [--json]",
+    arguments: [{ name: "message", description: "Reason for closing the task without staging it.", required: true, kind: "message_tail" }],
+    options: [{ name: "json", flags: "--json", description: "Emit machine-readable JSON instead of human-readable text.", kind: "boolean" }],
+    examples: ['treeseed close "superseded by feature/search-v2"'],
+    executionMode: "handler",
+    handlerName: "close"
+  })],
+  ["stage", command({
+    usage: "treeseed stage <message> [--json]",
+    arguments: [{ name: "message", description: "Resolution message for the staged task.", required: true, kind: "message_tail" }],
+    options: [{ name: "json", flags: "--json", description: "Emit machine-readable JSON instead of human-readable text.", kind: "boolean" }],
+    examples: ['treeseed stage "feat: add search filters"'],
+    executionMode: "handler",
+    handlerName: "stage"
+  })],
+  ["rollback", command({
+    usage: "treeseed rollback <staging|prod> [--to <deploy-id|commit>] [--json]",
+    arguments: [{ name: "environment", description: "The persistent environment to roll back.", required: true }],
+    options: [
+      { name: "to", flags: "--to <deploy-id|commit>", description: "Explicit commit to roll back to. Defaults to the previous recorded deployment when omitted.", kind: "string" },
+      { name: "json", flags: "--json", description: "Emit machine-readable JSON instead of human-readable text.", kind: "boolean" }
+    ],
+    examples: ["treeseed rollback staging", "treeseed rollback prod --to abc1234"],
+    executionMode: "handler",
+    handlerName: "rollback"
+  })],
+  ["doctor", command({
+    usage: "treeseed doctor [--fix] [--json]",
+    options: [
+      { name: "fix", flags: "--fix", description: "Apply safe local repairs before rerunning diagnostics.", kind: "boolean" },
+      { name: "json", flags: "--json", description: "Emit machine-readable JSON instead of human-readable text.", kind: "boolean" }
+    ],
+    examples: ["treeseed doctor", "treeseed doctor --fix --json"],
+    executionMode: "handler",
+    handlerName: "doctor"
+  })],
+  ["auth:login", command({
+    usage: "treeseed auth:login [--host <id>] [--json]",
+    options: [
+      { name: "host", flags: "--host <id>", description: "Override the configured remote host id for this login.", kind: "string" },
+      { name: "json", flags: "--json", description: "Emit machine-readable JSON instead of human-readable text.", kind: "boolean" }
+    ],
+    examples: ["treeseed auth:login"],
+    executionMode: "handler",
+    handlerName: "auth:login"
+  })],
+  ["auth:logout", command({
+    usage: "treeseed auth:logout [--host <id>] [--json]",
+    options: [
+      { name: "host", flags: "--host <id>", description: "Override the configured remote host id to clear.", kind: "string" },
+      { name: "json", flags: "--json", description: "Emit machine-readable JSON instead of human-readable text.", kind: "boolean" }
+    ],
+    examples: ["treeseed auth:logout"],
+    executionMode: "handler",
+    handlerName: "auth:logout"
+  })],
+  ["auth:whoami", command({
+    usage: "treeseed auth:whoami [--json]",
+    options: [{ name: "json", flags: "--json", description: "Emit machine-readable JSON instead of human-readable text.", kind: "boolean" }],
+    examples: ["treeseed auth:whoami"],
+    executionMode: "handler",
+    handlerName: "auth:whoami"
+  })],
+  ["template", command({
+    usage: "treeseed template [list|show|validate] [id]",
+    arguments: [
+      { name: "action", description: "Template action: list, show, or validate.", required: false },
+      { name: "id", description: "Template id for show or validate.", required: false }
+    ],
+    examples: ["treeseed template", "treeseed template list", "treeseed template show starter-basic", "treeseed template validate"],
+    executionMode: "handler",
+    handlerName: "template"
+  })],
+  ["sync", command({
+    usage: "treeseed sync [--check]",
+    options: [{ name: "check", flags: "--check", description: "Report managed-surface drift without changing files.", kind: "boolean" }],
+    examples: ["treeseed sync --check", "treeseed sync"],
+    executionMode: "handler",
+    handlerName: "sync"
+  })],
+  ["init", command({
+    usage: "treeseed init <directory> [--template <starter-id>] [--name <site-name>] [--slug <slug>] [--site-url <url>] [--contact-email <email>] [--repo <url>] [--discord <url>]",
+    arguments: [{ name: "directory", description: "Target directory for the new tenant.", required: true }],
+    options: [
+      { name: "template", flags: "--template <starter-id>", description: "Select the starter template id to generate. Defaults to starter-basic.", kind: "string" },
+      { name: "name", flags: "--name <site-name>", description: "Override the generated site name.", kind: "string" },
+      { name: "slug", flags: "--slug <slug>", description: "Override the generated package and tenant slug.", kind: "string" },
+      { name: "siteUrl", flags: "--site-url <url>", description: "Set the initial public site URL.", kind: "string" },
+      { name: "contactEmail", flags: "--contact-email <email>", description: "Set the site contact address.", kind: "string" },
+      { name: "repo", flags: "--repo <url>", description: "Set the repository URL.", kind: "string" },
+      { name: "discord", flags: "--discord <url>", description: "Set the Discord/community URL.", kind: "string" }
+    ],
+    examples: ['treeseed init docs-site --template starter-basic --name "Docs Site" --site-url https://docs.example.com'],
+    notes: ["Runs outside an existing repo or from any branch."],
+    executionMode: "handler",
+    handlerName: "init"
+  })],
+  ["config", command({
+    usage: "treeseed config [--environment <all|local|staging|prod>]... [--sync <none|github|cloudflare|railway|all>] [--print-env] [--print-env-only] [--show-secrets] [--rotate-machine-key]",
+    options: [
+      { name: "environment", flags: "--environment <scope>", description: "Select all environments or limit configuration to local, staging, or prod. Defaults to all.", kind: "enum", repeatable: true, values: ["all", "local", "staging", "prod"] },
+      { name: "sync", flags: "--sync <mode>", description: "Sync hosted secrets/variables to GitHub, Cloudflare, Railway, or all providers. Defaults to all.", kind: "enum", values: ["none", "github", "cloudflare", "railway", "all"] },
+      { name: "printEnv", flags: "--print-env", description: "Print resolved environment values before remote initialization.", kind: "boolean" },
+      { name: "printEnvOnly", flags: "--print-env-only", description: "Print resolved environment values, check provider connections, and exit without prompting or initializing remote resources.", kind: "boolean" },
+      { name: "showSecrets", flags: "--show-secrets", description: "Print full secret values in environment reports instead of masking them.", kind: "boolean" },
+      { name: "rotateMachineKey", flags: "--rotate-machine-key", description: "Regenerate the local home machine key and re-encrypt stored Treeseed secrets and remote auth sessions.", kind: "boolean" },
+      { name: "json", flags: "--json", description: "Emit machine-readable JSON instead of human-readable text.", kind: "boolean" }
+    ],
+    examples: ["treeseed config", "treeseed config --environment all", "treeseed config --environment local --sync none", "treeseed config --environment staging --print-env-only --show-secrets", "treeseed config --rotate-machine-key"],
+    notes: ["Does not create branch preview deployments. Use `treeseed switch <branch> --preview` for that."],
+    executionMode: "handler",
+    handlerName: "config"
+  })],
+  ["release", command({
+    usage: "treeseed release --major|--minor|--patch",
+    options: [
+      { name: "major", flags: "--major", description: "Bump to the next major version.", kind: "boolean" },
+      { name: "minor", flags: "--minor", description: "Bump to the next minor version.", kind: "boolean" },
+      { name: "patch", flags: "--patch", description: "Bump to the next patch version.", kind: "boolean" },
+      { name: "json", flags: "--json", description: "Emit machine-readable JSON instead of human-readable text.", kind: "boolean" }
+    ],
+    examples: ["treeseed release --patch", "treeseed release --minor"],
+    notes: ["Requires exactly one bump flag."],
+    executionMode: "handler",
+    handlerName: "release"
+  })],
+  ["destroy", command({
+    usage: "treeseed destroy --environment <local|staging|prod> [--dry-run] [--force] [--skip-confirmation] [--confirm <slug>] [--remove-build-artifacts]",
+    options: [
+      { name: "environment", flags: "--environment <scope>", description: "Select the persistent environment to destroy.", kind: "enum", values: ["local", "staging", "prod"] },
+      { name: "dryRun", flags: "--dry-run", description: "Preview the destroy operation.", kind: "boolean" },
+      { name: "force", flags: "--force", description: "Force worker deletion when supported.", kind: "boolean" },
+      { name: "skipConfirmation", flags: "--skip-confirmation", description: "Skip the interactive confirmation prompt.", kind: "boolean" },
+      { name: "confirm", flags: "--confirm <slug>", description: "Provide the expected slug confirmation non-interactively.", kind: "string" },
+      { name: "removeBuildArtifacts", flags: "--remove-build-artifacts", description: "Also remove local build artifacts after destroy.", kind: "boolean" },
+      { name: "json", flags: "--json", description: "Emit machine-readable JSON instead of human-readable text.", kind: "boolean" }
+    ],
+    examples: ["treeseed destroy --environment staging --dry-run", "treeseed destroy --environment prod --confirm example --skip-confirmation"],
+    notes: ["Only for persistent environments. Task cleanup belongs to treeseed close.", "This command is destructive and requires explicit confirmation."],
+    executionMode: "handler",
+    handlerName: "destroy"
+  })],
+  ["dev", command({ examples: ["treeseed dev"], executionMode: "handler", handlerName: "dev" })],
+  ["dev:watch", command({ examples: ["treeseed dev:watch"], executionMode: "handler", handlerName: "dev" })],
+  ["build", command({ examples: ["treeseed build"], executionMode: "adapter" })],
+  ["check", command({ examples: ["treeseed check"], executionMode: "adapter" })],
+  ["preview", command({ examples: ["treeseed preview"], executionMode: "adapter", buildAdapterInput: PASS_THROUGH_ARGS })],
+  ["lint", command({ examples: ["treeseed lint"], executionMode: "adapter" })],
+  ["test", command({ examples: ["treeseed test"], executionMode: "adapter" })],
+  ["test:unit", command({ examples: ["treeseed test:unit"], executionMode: "adapter" })],
+  ["preflight", command({ examples: ["treeseed preflight"], executionMode: "adapter" })],
+  ["auth:check", command({ examples: ["treeseed auth:check"], executionMode: "adapter", buildAdapterInput: () => ({ requireAuth: true }) })],
+  ["test:e2e", command({ examples: ["treeseed test:e2e"], executionMode: "adapter" })],
+  ["test:e2e:local", command({ examples: ["treeseed test:e2e:local"], executionMode: "adapter" })],
+  ["test:e2e:staging", command({ examples: ["treeseed test:e2e:staging"], executionMode: "adapter" })],
+  ["test:e2e:full", command({ examples: ["treeseed test:e2e:full"], executionMode: "adapter" })],
+  ["test:release", command({ examples: ["treeseed test:release"], executionMode: "adapter" })],
+  ["test:release:full", command({ examples: ["treeseed test:release:full", "treeseed release:verify"], executionMode: "adapter" })],
+  ["release:publish:changed", command({ examples: ["treeseed release:publish:changed"], executionMode: "adapter" })],
+  ["astro", command({ examples: ["treeseed astro -- --help"], executionMode: "adapter", buildAdapterInput: PASS_THROUGH_ARGS })],
+  ["sync:devvars", command({ examples: ["treeseed sync:devvars"], executionMode: "adapter" })],
+  ["mailpit:up", command({ examples: ["treeseed mailpit:up"], executionMode: "adapter" })],
+  ["mailpit:down", command({ examples: ["treeseed mailpit:down"], executionMode: "adapter" })],
+  ["mailpit:logs", command({ examples: ["treeseed mailpit:logs"], executionMode: "adapter" })],
+  ["d1:migrate:local", command({ examples: ["treeseed d1:migrate:local"], executionMode: "adapter" })],
+  ["cleanup:markdown", command({
+    examples: ["treeseed cleanup:markdown docs/README.md"],
+    executionMode: "adapter",
+    buildAdapterInput: (invocation) => ({ targets: invocation.positionals, check: false })
+  })],
+  ["cleanup:markdown:check", command({
+    examples: ["treeseed cleanup:markdown:check docs/README.md"],
+    executionMode: "adapter",
+    buildAdapterInput: (invocation) => ({ targets: invocation.positionals, check: true })
+  })],
+  ["starlight:patch", command({ examples: ["treeseed starlight:patch"], executionMode: "adapter" })]
+]);
+function mergeOperationSpec(metadata) {
+  const overlay = CLI_COMMAND_OVERLAYS.get(metadata.name) ?? {};
+  return {
+    ...metadata,
+    usage: overlay.usage,
+    arguments: overlay.arguments,
+    options: overlay.options,
+    examples: overlay.examples,
+    notes: overlay.notes,
+    executionMode: overlay.executionMode ?? "adapter",
+    handlerName: overlay.handlerName,
+    buildAdapterInput: overlay.buildAdapterInput
+  };
+}
+const TRESEED_OPERATION_SPECS = SDK_OPERATION_SPECS.map(mergeOperationSpec);
+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;
+  const metadata = findSdkOperation(name);
+  return metadata ? TRESEED_OPERATION_INDEX.get(metadata.name) ?? mergeOperationSpec(metadata) : null;
+}
+function listTreeseedOperationNames() {
+  return listSdkOperationNames();
+}
+export {
+  TRESEED_OPERATION_INDEX,
+  TRESEED_OPERATION_SPECS,
+  findTreeseedOperation,
+  listTreeseedOperationNames
+};

package/dist/cli/operations-types.d.ts

@@ -0,0 +1,72 @@
+import type { TreeseedOperationContext as SdkOperationContext, TreeseedOperationGroup, TreeseedOperationId, TreeseedOperationMetadata, TreeseedOperationResult as SdkOperationResult } from '@treeseed/sdk/operations';
+export type TreeseedCommandGroup = TreeseedOperationGroup;
+export type TreeseedExecutionMode = 'handler' | 'adapter';
+export type TreeseedArgumentKind = 'positional' | 'message_tail';
+export type TreeseedOptionKind = 'boolean' | 'string' | 'enum';
+export type TreeseedCommandArgumentSpec = {
+    name: string;
+    description: string;
+    required?: boolean;
+    kind?: TreeseedArgumentKind;
+};
+export type TreeseedCommandOptionSpec = {
+    name: string;
+    flags: string;
+    description: string;
+    kind: TreeseedOptionKind;
+    repeatable?: boolean;
+    values?: string[];
+};
+export type TreeseedCommandExample = string;
+export type TreeseedParsedInvocation = {
+    commandName: string;
+    args: Record<string, string | string[] | boolean | undefined>;
+    positionals: string[];
+    rawArgs: string[];
+};
+export type TreeseedCommandResult = {
+    exitCode?: number;
+    stdout?: string[];
+    stderr?: string[];
+    report?: Record<string, unknown> | null;
+};
+export type TreeseedWriter = NonNullable<SdkOperationContext['write']>;
+export type TreeseedSpawner = NonNullable<SdkOperationContext['spawn']>;
+export type TreeseedPromptHandler = NonNullable<SdkOperationContext['prompt']>;
+export type TreeseedConfirmHandler = NonNullable<SdkOperationContext['confirm']>;
+export type TreeseedCommandContext = {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    write: TreeseedWriter;
+    spawn: TreeseedSpawner;
+    outputFormat?: 'human' | 'json';
+    prompt?: TreeseedPromptHandler;
+    confirm?: TreeseedConfirmHandler;
+};
+export type TreeseedCommandHandler = (invocation: TreeseedParsedInvocation, context: TreeseedCommandContext) => Promise<TreeseedCommandResult> | TreeseedCommandResult;
+export type TreeseedAdapterInputBuilder = (invocation: TreeseedParsedInvocation, context: TreeseedCommandContext) => Record<string, unknown>;
+export type TreeseedOperationSpec = TreeseedOperationMetadata & {
+    usage?: string;
+    arguments?: TreeseedCommandArgumentSpec[];
+    options?: TreeseedCommandOptionSpec[];
+    examples?: TreeseedCommandExample[];
+    notes?: string[];
+    executionMode: TreeseedExecutionMode;
+    handlerName?: string;
+    buildAdapterInput?: TreeseedAdapterInputBuilder;
+};
+export type TreeseedCommandSpec = TreeseedOperationSpec;
+export type TreeseedOperationRequest = {
+    commandName: string;
+    argv?: string[];
+};
+export type TreeseedOperationResult = TreeseedCommandResult & {
+    operation?: TreeseedOperationId;
+    ok?: boolean;
+    payload?: Record<string, unknown> | null;
+    meta?: Record<string, unknown>;
+    nextSteps?: string[];
+};
+export type TreeseedOperationExecutor = (spec: TreeseedOperationSpec, argv: string[], context: TreeseedCommandContext) => Promise<number> | number;
+export type TreeseedHandlerResolver = (handlerName: string) => TreeseedCommandHandler | null;
+export type TreeseedSdkOperationResult = SdkOperationResult;

package/dist/cli/parser.d.ts

@@ -0,0 +1,3 @@
+import type { TreeseedOperationSpec, TreeseedParsedInvocation } from './operations-types.ts';
+export declare function parseTreeseedInvocation(command: TreeseedOperationSpec, argv: string[]): TreeseedParsedInvocation;
+export declare function validateTreeseedInvocation(command: TreeseedOperationSpec, invocation: TreeseedParsedInvocation): string[];

package/dist/cli/parser.js

@@ -77,17 +77,12 @@ function validateTreeseedInvocation(command, invocation) {
       errors.push(`Missing required argument: ${arg.name}`);
     }
   }
-  if (command.name === "release" || command.name === "promote") {
+  if (command.name === "release") {
     const selected = ["major", "minor", "patch"].filter((name) => invocation.args[name] === true);
     if (selected.length !== 1) {
       errors.push(`Treeseed ${command.name} requires exactly one version bump flag: --major, --minor, or --patch.`);
     }
   }
-  if (command.name === "deploy" || command.name === "publish") {
-    if (!invocation.args.environment && !invocation.args.targetBranch && !process.env.CI) {
-      errors.push(`Treeseed ${command.name} requires \`--environment local|staging|prod\` or \`--target-branch <branch>\` outside CI.`);
-    }
-  }
   return errors;
 }
 export {

package/dist/cli/registry.d.ts

@@ -0,0 +1,25 @@
+import type { TreeseedCommandSpec } from './operations-types.js';
+export declare const COMMAND_HANDLERS: {
+    readonly init: import("./operations-types.js").TreeseedCommandHandler;
+    readonly config: import("./operations-types.js").TreeseedCommandHandler;
+    readonly close: import("./operations-types.js").TreeseedCommandHandler;
+    readonly save: import("./operations-types.js").TreeseedCommandHandler;
+    readonly release: import("./operations-types.js").TreeseedCommandHandler;
+    readonly destroy: import("./operations-types.js").TreeseedCommandHandler;
+    readonly status: import("./operations-types.js").TreeseedCommandHandler;
+    readonly dev: import("./operations-types.js").TreeseedCommandHandler;
+    readonly 'dev:watch': import("./operations-types.js").TreeseedCommandHandler;
+    readonly doctor: import("./operations-types.js").TreeseedCommandHandler;
+    readonly rollback: import("./operations-types.js").TreeseedCommandHandler;
+    readonly template: import("./operations-types.js").TreeseedCommandHandler;
+    readonly sync: import("./operations-types.js").TreeseedCommandHandler;
+    readonly tasks: import("./operations-types.js").TreeseedCommandHandler;
+    readonly switch: import("./operations-types.js").TreeseedCommandHandler;
+    readonly stage: import("./operations-types.js").TreeseedCommandHandler;
+    readonly 'auth:login': import("./operations-types.js").TreeseedCommandHandler;
+    readonly 'auth:logout': import("./operations-types.js").TreeseedCommandHandler;
+    readonly 'auth:whoami': import("./operations-types.js").TreeseedCommandHandler;
+};
+export declare const TRESEED_COMMAND_SPECS: TreeseedCommandSpec[];
+export declare function findCommandSpec(name: string | null | undefined): import("./operations-types.js").TreeseedOperationSpec | null;
+export declare function listCommandNames(): string[];