@kitsy/cnos-cli 1.7.0 → 1.8.0

package/dist/index.js

@@ -23,7 +23,8 @@ var COMMAND_OPTION_KEYS_WITH_VALUE = /* @__PURE__ */ new Set([
   "--as",
   "--set",
   "--debounce",
-  "--expr"
+  "--expr",
+  "--extends"
 ]);
 var COMMAND_FLAG_KEYS = /* @__PURE__ */ new Set([
   "--flatten",
@@ -42,7 +43,8 @@ var COMMAND_FLAG_KEYS = /* @__PURE__ */ new Set([
   "--apply",
   "--rewrite",
   "--signal",
-  "--derive"
+  "--derive",
+  "--onboard-current"
 ]);
 function normalizeCommand(argv) {
   const [command = "doctor", ...rest] = argv;
@@ -2214,10 +2216,48 @@ var COMMANDS = [
   },
   {
     id: "workspace",
-    summary: "Attach or detach package-local workspace config from a parent CNOS root.",
-    usage: "cnos workspace <attach|detach> [options] [global-options]",
-    description: "Detaches a child package into a standalone .cnos root or reattaches a detached package back into a parent workspace.",
-    examples: ["cnos workspace detach", "cnos workspace attach --package-root apps/travel"]
+    summary: "Manage workspace creation, listing, migration, and attach/detach flows.",
+    usage: "cnos workspace <add|list|remove|scaffold|attach|detach> [options] [global-options]",
+    description: "Adds and removes manifest workspaces, scaffolds package anchors, migrates single-root projects into workspace mode, and handles detach/attach flows for independent child packages.",
+    examples: [
+      "cnos workspace list",
+      "cnos workspace add travel --package-root apps/travel --extends base",
+      "cnos workspace add main --onboard-current",
+      "cnos workspace remove gallery",
+      "cnos workspace detach --package-root apps/travel"
+    ]
+  },
+  {
+    id: "workspace add",
+    summary: "Add a workspace to the manifest and scaffold its on-disk layout.",
+    usage: "cnos workspace add <id> [--package-root <path>] [--extends <workspace>] [--onboard-current] [--force] [global-options]",
+    description: "Creates .cnos/workspaces/<id>, updates cnos.yml, writes a .cnosrc.yml anchor at the selected package root, and optionally migrates an existing single-root .cnos tree into workspace mode with --onboard-current.",
+    examples: [
+      "cnos workspace add travel --package-root apps/travel --extends base",
+      "cnos workspace add insights --package-root apps/insights",
+      "cnos workspace add main --onboard-current"
+    ]
+  },
+  {
+    id: "workspace scaffold",
+    summary: "Scaffold a workspace and anchor without changing other runtime flows.",
+    usage: "cnos workspace scaffold <id> [--package-root <path>] [--extends <workspace>] [--force] [global-options]",
+    description: "Creates the workspace manifest entry, workspace folders, and package anchor for a new app or package. This is an alias-oriented workflow for teams that prefer scaffold wording over add.",
+    examples: ["cnos workspace scaffold gallery --package-root apps/gallery --extends base"]
+  },
+  {
+    id: "workspace list",
+    summary: "List declared workspaces and their inheritance.",
+    usage: "cnos workspace list [global-options]",
+    description: "Shows the declared workspace ids, default workspace, and extends relationships from cnos.yml.",
+    examples: ["cnos workspace list", "cnos workspace list --json"]
+  },
+  {
+    id: "workspace remove",
+    summary: "Remove a workspace from the manifest and delete its local workspace tree.",
+    usage: "cnos workspace remove <id> [global-options]",
+    description: "Deletes .cnos/workspaces/<id> and removes the workspace entry from cnos.yml. CNOS refuses to remove the current default workspace until you change workspaces.default.",
+    examples: ["cnos workspace remove gallery", "cnos workspace remove insights --json"]
   },
   {
     id: "workspace detach",
@@ -2576,8 +2616,7 @@ async function ensureGitignore(root) {
 `, "utf8");
   return true;
 }
-async function scaffoldWorkspace(root, workspace) {
-  const cnosRoot = path9.join(root, ".cnos");
+async function ensureWorkspaceLayout(cnosRoot, workspace) {
   const workspaceRoot = workspace ? path9.join(cnosRoot, "workspaces", workspace) : cnosRoot;
   const createdPaths = [];
   await mkdir4(path9.join(workspaceRoot, "profiles"), { recursive: true });
@@ -2598,18 +2637,28 @@ async function scaffoldWorkspace(root, workspace) {
   for (const relativePath of relativePaths) {
     const filePath = path9.join(cnosRoot, ...relativePath);
     if (await ensureFile(filePath, "")) {
-      createdPaths.push(path9.relative(root, filePath).replace(/\\/g, "/"));
+      createdPaths.push(path9.relative(path9.dirname(cnosRoot), filePath).replace(/\\/g, "/"));
     }
   }
-  if (await ensureFile(path9.join(cnosRoot, "cnos.yml"), scaffoldManifest(path9.basename(root), workspace))) {
-    createdPaths.push(".cnos/cnos.yml");
-  }
-  if (await ensureFile(
+  return createdPaths;
+}
+async function ensureCnosrc(root, workspace) {
+  return ensureFile(
     path9.join(root, ".cnosrc.yml"),
     workspace ? `root: ./.cnos
 workspace: ${workspace}
 ` : "root: ./.cnos\n"
-  )) {
+  );
+}
+async function scaffoldWorkspace(root, workspace) {
+  const cnosRoot = path9.join(root, ".cnos");
+  const createdPaths = (await ensureWorkspaceLayout(cnosRoot, workspace)).map(
+    (entry) => entry.replace(/^\.cnos\//, ".cnos/")
+  );
+  if (await ensureFile(path9.join(cnosRoot, "cnos.yml"), scaffoldManifest(path9.basename(root), workspace))) {
+    createdPaths.push(".cnos/cnos.yml");
+  }
+  if (await ensureCnosrc(root, workspace)) {
     createdPaths.push(".cnosrc.yml");
   }
   if (workspace && await ensureFile(path9.join(root, ".cnos-workspace.yml"), `workspace: ${workspace}
@@ -3937,7 +3986,7 @@ async function runValidate(options = {}) {
 // package.json
 var package_default = {
   name: "@kitsy/cnos-cli",
-  version: "1.7.0",
+  version: "1.8.0",
   description: "CLI entry point and developer tooling for CNOS.",
   type: "module",
   main: "./dist/index.js",
@@ -4212,7 +4261,7 @@ async function runWatch(command, options = {}) {
 }
 
 // src/commands/workspace.ts
-import { cp, mkdir as mkdir6, rename, rm as rm5, stat as stat2, writeFile as writeFile9, readFile as readFile6 } from "fs/promises";
+import { cp, mkdir as mkdir6, readdir as readdir5, readFile as readFile6, rename, rm as rm5, stat as stat2, writeFile as writeFile9 } from "fs/promises";
 import path23 from "path";
 import { loadManifest as loadManifest8, parseYaml as parseYaml5, stringifyYaml as stringifyYaml7 } from "@kitsy/cnos/internal";
 async function exists(targetPath) {
@@ -4230,22 +4279,34 @@ async function copyIfExists(source, target) {
   await mkdir6(path23.dirname(target), { recursive: true });
   await cp(source, target, { recursive: true, force: true });
 }
+async function moveIfExists(source, target, force = false) {
+  if (!await exists(source)) {
+    return false;
+  }
+  if (force) {
+    await rm5(target, { recursive: true, force: true });
+  } else if (await exists(target)) {
+    throw new Error(`Refusing to overwrite existing path ${target}. Use --force to replace it.`);
+  }
+  await mkdir6(path23.dirname(target), { recursive: true });
+  await rename(source, target);
+  return true;
+}
 async function mergeWorkspaceRootsIntoStandalone(targetCnosRoot, sourceRoots) {
   for (const sourceRoot of sourceRoots) {
     for (const folderName of ["values", "secrets", "env", "profiles"]) {
-      await copyIfExists(
-        path23.join(sourceRoot, folderName),
-        path23.join(targetCnosRoot, folderName)
-      );
+      await copyIfExists(path23.join(sourceRoot, folderName), path23.join(targetCnosRoot, folderName));
     }
   }
 }
-async function writeCnosrc(packageRoot, config) {
+async function writeAnchor(packageRoot, manifestRoot, workspace) {
+  const relativeRoot = path23.relative(packageRoot, manifestRoot).replace(/\\/g, "/");
+  const rootValue = relativeRoot.length === 0 ? "./.cnos" : relativeRoot.startsWith(".") ? relativeRoot : `./${relativeRoot}`;
   await writeFile9(
     path23.join(packageRoot, ".cnosrc.yml"),
     stringifyYaml7({
-      root: config.root,
-      ...config.workspace ? { workspace: config.workspace } : {}
+      root: rootValue,
+      ...workspace ? { workspace } : {}
     }),
     "utf8"
   );
@@ -4257,6 +4318,36 @@ function createDetachedManifest(rawManifest) {
   }
   return next;
 }
+function normalizeWorkspaceId(value) {
+  const workspaceId = value?.trim();
+  if (!workspaceId) {
+    throw new Error("Workspace id is required");
+  }
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(workspaceId)) {
+    throw new Error(`Invalid workspace id "${workspaceId}". Use letters, numbers, dot, underscore, or dash.`);
+  }
+  return workspaceId;
+}
+function splitExtends(value) {
+  if (!value) {
+    return void 0;
+  }
+  const items = value.split(",").map((entry) => entry.trim()).filter(Boolean);
+  return items.length > 0 ? items : void 0;
+}
+async function hasDirectConfigData(cnosRoot) {
+  for (const folderName of ["values", "secrets", "env", "profiles"]) {
+    const folder = path23.join(cnosRoot, folderName);
+    if (!await exists(folder)) {
+      continue;
+    }
+    const entries = await readdir5(folder, { withFileTypes: true });
+    if (entries.some((entry) => entry.name !== ".gitkeep")) {
+      return true;
+    }
+  }
+  return false;
+}
 async function runDetach(packageRoot, options = {}) {
   const loaded = await loadManifest8({ cwd: packageRoot });
   if (!loaded.anchorPath || !loaded.anchoredWorkspace) {
@@ -4294,7 +4385,7 @@ async function runDetach(packageRoot, options = {}) {
     }
   };
   await writeFile9(path23.join(targetCnosRoot, ".detached"), stringifyYaml7(marker), "utf8");
-  await writeCnosrc(packageRoot, { root: "./.cnos" });
+  await writeFile9(path23.join(packageRoot, ".cnosrc.yml"), stringifyYaml7({ root: "./.cnos" }), "utf8");
   if (options.json) {
     return printJson({
       packageRoot,
@@ -4335,7 +4426,7 @@ async function runAttach(packageRoot, options = {}) {
   for (const folderName of ["values", "secrets", "env", "profiles"]) {
     await copyIfExists(path23.join(childCnosRoot, folderName), path23.join(parentWorkspaceRoot, folderName));
   }
-  const rawManifest = parentLoaded.rawManifest;
+  const rawManifest = structuredClone(parentLoaded.rawManifest);
   const workspaces = rawManifest.workspaces ?? {};
   const items = workspaces.items ?? {};
   items[workspaceId] = items[workspaceId] ?? {};
@@ -4345,10 +4436,7 @@ async function runAttach(packageRoot, options = {}) {
   const archivePath = path23.join(packageRoot, ".cnos.detached.bak");
   await rm5(archivePath, { recursive: true, force: true });
   await rename(childCnosRoot, archivePath);
-  await writeCnosrc(packageRoot, {
-    root: marker.originalCnosrc.root,
-    ...workspaceId ? { workspace: workspaceId } : {}
-  });
+  await writeAnchor(packageRoot, parentLoaded.manifestRoot, workspaceId);
   if (options.json) {
     return printJson({
       packageRoot,
@@ -4359,15 +4447,168 @@ async function runAttach(packageRoot, options = {}) {
   }
   return `attached workspace ${workspaceId} to ${displayPath(parentLoaded.manifestRoot, packageRoot)}`;
 }
-async function runWorkspace(args = [], options = {}) {
-  const [action] = args;
+async function runList2(manifestCwd, options = {}) {
+  const loaded = await loadManifest8({
+    ...options.root ? { root: options.root } : {},
+    cwd: manifestCwd,
+    ...options.processEnv ? { processEnv: options.processEnv } : {}
+  });
+  const entries = Object.entries(loaded.manifest.workspaces.items).map(([id, config]) => ({
+    id,
+    extends: config.extends,
+    default: loaded.manifest.workspaces.default === id,
+    path: path23.join(loaded.manifestRoot, "workspaces", id)
+  })).sort((left, right) => left.id.localeCompare(right.id));
+  if (options.json) {
+    return printJson({
+      default: loaded.manifest.workspaces.default,
+      workspaces: entries
+    });
+  }
+  if (entries.length === 0) {
+    return "no workspaces declared";
+  }
+  return entries.map((entry) => {
+    const tags = [
+      entry.default ? "default" : void 0,
+      entry.extends.length > 0 ? `extends=${entry.extends.join(",")}` : void 0
+    ].filter(Boolean);
+    return `${entry.id}${tags.length > 0 ? ` (${tags.join(", ")})` : ""}`;
+  }).join("\n");
+}
+async function runAddOrScaffold(action, workspaceId, manifestCwd, packageRoot, options = {}) {
   const cliArgs = [...options.cliArgs ?? []];
-  const packageRoot = path23.resolve(consumeOption(cliArgs, "--package-root") ?? options.root ?? process.cwd());
+  const extendsOption = splitExtends(consumeOption(cliArgs, "--extends"));
+  const onboardCurrent = consumeFlag(cliArgs, "--onboard-current");
+  const force = consumeFlag(cliArgs, "--force");
+  if (cliArgs.length > 0) {
+    throw new Error(`Unsupported workspace arguments: ${cliArgs.join(" ")}`);
+  }
+  const loaded = await loadManifest8({
+    ...options.root ? { root: options.root } : {},
+    cwd: manifestCwd,
+    ...options.processEnv ? { processEnv: options.processEnv } : {}
+  });
+  if (loaded.rootResolution.readOnly) {
+    throw new Error(
+      `Cannot ${action} workspace because the active CNOS root is remote and read-only (${loaded.rootResolution.rootUri}). Clone the config repo and edit it directly.`
+    );
+  }
+  const manifestRoot = loaded.manifestRoot;
+  const cnosRoot = manifestRoot;
+  const rawManifest = structuredClone(loaded.rawManifest);
+  const rawWorkspaces = rawManifest.workspaces ?? {};
+  const rawItems = rawWorkspaces.items ?? {};
+  const isWorkspaceMode = Object.keys(rawItems).length > 0;
+  const directConfigPresent = await hasDirectConfigData(cnosRoot);
+  if (!isWorkspaceMode && directConfigPresent && !onboardCurrent) {
+    throw new Error(
+      "This CNOS root is in single-root mode and already has direct values/secrets/env/profiles data. Re-run with --onboard-current to migrate it into workspace mode."
+    );
+  }
+  if (rawItems[workspaceId] && !force) {
+    throw new Error(`workspace "${workspaceId}" already exists. Use --force to update its manifest entry and anchor.`);
+  }
+  const defaultExtends = extendsOption ?? (!["base", "root"].includes(workspaceId) && rawItems.base ? ["base"] : void 0);
+  rawItems[workspaceId] = defaultExtends && defaultExtends.length > 0 ? { extends: defaultExtends } : {};
+  rawWorkspaces.items = rawItems;
+  rawWorkspaces.default = rawWorkspaces.default ?? workspaceId;
+  rawManifest.workspaces = rawWorkspaces;
+  const workspaceRoot = path23.join(cnosRoot, "workspaces", workspaceId);
+  if (onboardCurrent) {
+    if (isWorkspaceMode) {
+      throw new Error("--onboard-current can only be used when the manifest is not already in workspace mode.");
+    }
+    for (const folderName of ["values", "secrets", "env", "profiles"]) {
+      await moveIfExists(path23.join(cnosRoot, folderName), path23.join(workspaceRoot, folderName), force);
+    }
+  }
+  const created = await ensureWorkspaceLayout(cnosRoot, workspaceId);
+  await writeFile9(path23.join(cnosRoot, "cnos.yml"), stringifyYaml7(rawManifest), "utf8");
+  await ensureGitignore(path23.dirname(cnosRoot));
+  await writeAnchor(packageRoot, cnosRoot, workspaceId);
+  await ensureFile(path23.join(packageRoot, ".cnos-workspace.yml"), `workspace: ${workspaceId}
+globalRoot: ~/.cnos
+`);
+  const result = {
+    workspace: workspaceId,
+    root: path23.dirname(cnosRoot),
+    packageRoot,
+    onboarded: onboardCurrent,
+    created
+  };
+  if (options.json) {
+    return printJson(result);
+  }
+  const verb = action === "add" ? "added" : "scaffolded";
+  return `${verb} workspace ${workspaceId} at ${displayPath(workspaceRoot, packageRoot)}`;
+}
+async function runRemove(workspaceId, manifestCwd, options = {}) {
+  const cliArgs = [...options.cliArgs ?? []];
+  consumeFlag(cliArgs, "--force");
+  if (cliArgs.length > 0) {
+    throw new Error(`Unsupported workspace arguments: ${cliArgs.join(" ")}`);
+  }
+  const loaded = await loadManifest8({
+    ...options.root ? { root: options.root } : {},
+    cwd: manifestCwd,
+    ...options.processEnv ? { processEnv: options.processEnv } : {}
+  });
+  if (loaded.rootResolution.readOnly) {
+    throw new Error(
+      `Cannot remove workspace because the active CNOS root is remote and read-only (${loaded.rootResolution.rootUri}). Clone the config repo and edit it directly.`
+    );
+  }
+  const rawManifest = structuredClone(loaded.rawManifest);
+  const rawWorkspaces = rawManifest.workspaces ?? {};
+  const rawItems = rawWorkspaces.items ?? {};
+  if (!rawItems[workspaceId]) {
+    throw new Error(`workspace "${workspaceId}" does not exist`);
+  }
+  if (rawWorkspaces.default === workspaceId) {
+    throw new Error(`Cannot remove workspace "${workspaceId}" because it is the default workspace. Change workspaces.default first.`);
+  }
+  delete rawItems[workspaceId];
+  rawWorkspaces.items = rawItems;
+  rawManifest.workspaces = rawWorkspaces;
+  await writeFile9(path23.join(loaded.manifestRoot, "cnos.yml"), stringifyYaml7(rawManifest), "utf8");
+  await rm5(path23.join(loaded.manifestRoot, "workspaces", workspaceId), { recursive: true, force: true });
+  if (options.json) {
+    return printJson({
+      workspace: workspaceId,
+      removedFrom: loaded.manifestRoot
+    });
+  }
+  return `removed workspace ${workspaceId}`;
+}
+async function runWorkspace(args = [], options = {}) {
+  const [action, workspaceArg] = args;
+  const baseCliArgs = [...options.cliArgs ?? []];
+  const manifestCwd = path23.resolve(options.root ?? process.cwd());
+  const packageRoot = path23.resolve(consumeOption(baseCliArgs, "--package-root") ?? options.root ?? process.cwd());
   switch (action) {
-    case "detach":
-      return runDetach(packageRoot, { ...options, cliArgs });
     case "attach":
-      return runAttach(packageRoot, { ...options, cliArgs });
+      return runAttach(packageRoot, { ...options, cliArgs: baseCliArgs });
+    case "detach":
+      return runDetach(packageRoot, { ...options, cliArgs: baseCliArgs });
+    case "list":
+      return runList2(manifestCwd, options);
+    case "add":
+      return runAddOrScaffold("add", normalizeWorkspaceId(workspaceArg), manifestCwd, packageRoot, {
+        ...options,
+        cliArgs: baseCliArgs
+      });
+    case "scaffold":
+      return runAddOrScaffold("scaffold", normalizeWorkspaceId(workspaceArg), manifestCwd, packageRoot, {
+        ...options,
+        cliArgs: baseCliArgs
+      });
+    case "remove":
+    case "delete":
+      return runRemove(normalizeWorkspaceId(workspaceArg), manifestCwd, {
+        ...options,
+        cliArgs: baseCliArgs
+      });
     default:
       throw new Error(`Unsupported workspace action: ${action ?? "(missing)"}`);
   }
@@ -4393,8 +4634,8 @@ function resolveHelpTopic(command, args) {
   if (command === "dev" && args[0] === "env") {
     return normalizeHelpTopic([command, args[0]]);
   }
-  if (command === "workspace" && args[0] && ["attach", "detach"].includes(args[0])) {
-    return normalizeHelpTopic([command, args[0]]);
+  if (command === "workspace" && args[0] && ["attach", "detach", "add", "list", "remove", "delete", "scaffold"].includes(args[0])) {
+    return normalizeHelpTopic([command, args[0] === "delete" ? "remove" : args[0]]);
   }
   if (command === "vault" && args[0] && ["create", "add", "list", "delete", "remove"].includes(args[0])) {
     return normalizeHelpTopic([command, args[0] === "delete" ? "remove" : args[0] === "add" ? "create" : args[0]]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitsy/cnos-cli",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "CLI entry point and developer tooling for CNOS.",
   "type": "module",
   "main": "./dist/index.js",
@@ -36,7 +36,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@kitsy/cnos": "1.7.0"
+    "@kitsy/cnos": "1.8.0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts",