@highstate/cli 0.9.18 → 0.9.20

package/dist/main.js

@@ -8,22 +8,23 @@ import { colorize } from 'consola/utils';
 import { getPort } from 'get-port-please';
 import { PassThrough } from 'node:stream';
 import pino, { levels } from 'pino';
-import { writeFile, readFile } from 'node:fs/promises';
+import { writeFile, rm, readFile, mkdir, readdir } from 'node:fs/promises';
 import { parseAsync } from 'oxc-parser';
 import { walk } from 'oxc-walker';
 import MagicString from 'magic-string';
-import { resolve, dirname, relative } from 'node:path';
+import { resolve, dirname, relative, join } from 'node:path';
 import { pathToFileURL, fileURLToPath } from 'node:url';
 import { crc32 } from '@aws-crypto/crc32';
 import { resolve as resolve$1 } from 'import-meta-resolve';
 import { z } from 'zod';
+import { existsSync } from 'node:fs';
 import { pipe, mapValues, mapKeys } from 'remeda';
 import { build } from 'tsup';
 import { encode } from '@msgpack/msgpack';
 import { identityToRecipient } from 'age-encryption';
 
 // package.json
-var version = "0.9.17";
+var version = "0.9.19";
 var logger = pino(
   {
     name: "highstate-cli",
@@ -93,192 +94,164 @@ var schemaTransformerPlugin = {
   }
 };
 async function applySchemaTransformations(content) {
+  let result = await applyZodMetaTransformations(content);
+  result = await applyHelperFunctionTransformations(result);
+  result = await applyDefineFunctionMetaTransformations(result);
+  return result;
+}
+async function applyZodMetaTransformations(content) {
   const { program, comments } = await parseAsync("file.ts", content);
-  const transformations = [];
   const parentStack = [];
+  let hasTransformations = false;
+  const result = new MagicString(content);
   walk(program, {
     enter(node) {
       parentStack.push(node);
-      if (node.type === "Property" && node.key.type === "Identifier" && isInsideZodObject(parentStack)) {
-        const jsdoc2 = comments.find((comment) => isLeadingComment(content, node, comment));
-        if (jsdoc2) {
-          const description2 = cleanJsdoc(jsdoc2.value);
-          const fieldName = node.key.name;
-          const originalValue2 = content.substring(node.value.start, node.value.end);
-          if (!originalValue2.includes(".meta(")) {
-            transformations.push({
-              start: node.value.start,
-              end: node.value.end,
-              newValue: `${originalValue2}.meta({ title: __camelCaseToHumanReadable("${fieldName}"), description: \`${description2}\` })`,
-              type: "zod-meta"
-            });
+      if (isZodObjectProperty(node, parentStack)) {
+        const jsdoc = findLeadingComment(content, node, comments);
+        if (jsdoc) {
+          const description = cleanJsdoc(jsdoc.value);
+          const fieldName = "name" in node.key && typeof node.key.name === "string" ? node.key.name : "unknown";
+          const originalValue = content.substring(node.value.start, node.value.end);
+          if (!originalValue.includes(".meta(")) {
+            const newValue = `${originalValue}.meta({ title: __camelCaseToHumanReadable("${fieldName}"), description: \`${description}\` })`;
+            result.update(node.value.start, node.value.end, newValue);
+            hasTransformations = true;
           }
         }
-        return;
-      }
-      if (node.type !== "Property" || node.key.type !== "Identifier") {
-        return;
-      }
-      const parentKey = getParentObjectKey(parentStack) || getMarkerFunctionName(parentStack);
-      if (!parentKey || !["inputs", "outputs", "args", "secrets"].includes(parentKey)) {
-        return;
-      }
-      const jsdoc = comments.find((comment) => isLeadingComment(content, node, comment));
-      if (!jsdoc) {
-        return;
-      }
-      const description = cleanJsdoc(jsdoc.value);
-      const originalValue = content.substring(node.value.start, node.value.end);
-      const entityField = ["inputs", "outputs"].includes(parentKey) ? "entity" : "schema";
-      const isAlreadyStructured = isStructuredValue(originalValue, entityField);
-      if (isAlreadyStructured) {
-        const modifiedValue = injectDescriptionIntoObject(originalValue, description);
-        transformations.push({
-          start: node.value.start,
-          end: node.value.end,
-          newValue: modifiedValue,
-          type: "schema-structure"
-        });
-      } else {
-        transformations.push({
-          start: node.value.start,
-          end: node.value.end,
-          newValue: `{
-  ${entityField}: ${originalValue},
-  meta: {
-    description: \`${description}\`,
-  },
-}`,
-          type: "schema-structure"
-        });
       }
     },
     leave() {
       parentStack.pop();
     }
   });
-  const zodMetaTransformations = transformations.filter((t) => t.type === "zod-meta");
-  const schemaTransformations = transformations.filter((t) => t.type === "schema-structure");
-  const processedSchemaTransformations = schemaTransformations.map((schemaTransform) => {
-    const containedZodMetas = zodMetaTransformations.filter((zodTransform) => {
-      return schemaTransform.start <= zodTransform.start && schemaTransform.end >= zodTransform.end;
-    });
-    if (containedZodMetas.length > 0) {
-      const originalContent = content.substring(schemaTransform.start, schemaTransform.end);
-      const tempMagicString = new MagicString(originalContent);
-      containedZodMetas.sort((a, b) => b.start - a.start).forEach((zodTransform) => {
-        const relativeStart = zodTransform.start - schemaTransform.start;
-        const relativeEnd = zodTransform.end - schemaTransform.start;
-        tempMagicString.update(relativeStart, relativeEnd, zodTransform.newValue);
-      });
-      const modifiedContent = tempMagicString.toString();
-      const entityField = schemaTransform.newValue.includes("entity:") ? "entity" : "schema";
-      const descriptionMatch = schemaTransform.newValue.match(/description: `([^`]+)`/);
-      if (descriptionMatch) {
-        const description = descriptionMatch[1];
-        const isAlreadyStructured = isStructuredValue(
-          content.substring(schemaTransform.start, schemaTransform.end),
-          entityField
-        );
-        if (isAlreadyStructured) {
-          return {
-            ...schemaTransform,
-            newValue: injectDescriptionIntoObject(modifiedContent, description),
-            containsZodMeta: true
-          };
-        } else {
-          return {
-            ...schemaTransform,
-            newValue: `{
-  ${entityField}: ${modifiedContent},
-  meta: {
-    description: \`${description}\`,
-  },
-}`,
-            containsZodMeta: true
-          };
+  let finalResult = result.toString();
+  if (hasTransformations && !content.includes("__camelCaseToHumanReadable")) {
+    finalResult = 'import { camelCaseToHumanReadable as __camelCaseToHumanReadable } from "@highstate/contract"\n' + finalResult;
+  }
+  return finalResult;
+}
+async function applyHelperFunctionTransformations(content) {
+  const { program, comments } = await parseAsync("file.ts", content);
+  const parentStack = [];
+  let hasTransformations = false;
+  const result = new MagicString(content);
+  walk(program, {
+    enter(node) {
+      parentStack.push(node);
+      if (node.type === "Property" && "key" in node && node.key?.type === "Identifier") {
+        const propertyNode = node;
+        const parentKey = getParentObjectKey(parentStack);
+        if (parentKey && ["inputs", "outputs", "args", "secrets"].includes(parentKey)) {
+          const jsdoc = findLeadingComment(content, node, comments);
+          if (jsdoc) {
+            const description = cleanJsdoc(jsdoc.value);
+            const originalValue = content.substring(
+              propertyNode.value.start,
+              propertyNode.value.end
+            );
+            let helperFunction;
+            if (["args", "secrets"].includes(parentKey)) {
+              helperFunction = "$addArgumentDescription";
+            } else {
+              helperFunction = "$addInputDescription";
+            }
+            const newValue = `${helperFunction}(${originalValue}, \`${description}\`)`;
+            result.update(propertyNode.value.start, propertyNode.value.end, newValue);
+            hasTransformations = true;
+          }
         }
       }
+    },
+    leave() {
+      parentStack.pop();
     }
-    return { ...schemaTransform, containsZodMeta: false };
-  });
-  const independentZodMetas = zodMetaTransformations.filter((zodTransform) => {
-    return !schemaTransformations.some((schemaTransform) => {
-      return schemaTransform.start <= zodTransform.start && schemaTransform.end >= zodTransform.end;
-    });
-  });
-  const finalTransformations = [
-    ...independentZodMetas,
-    ...processedSchemaTransformations.map(({ containsZodMeta, ...rest }) => rest)
-    // eslint-disable-line @typescript-eslint/no-unused-vars
-  ];
-  const hasZodMetaTransformations = zodMetaTransformations.length > 0;
-  const needsImport = hasZodMetaTransformations && !content.includes("__camelCaseToHumanReadable");
-  let result = content;
-  const magicString = new MagicString(result);
-  finalTransformations.sort((a, b) => b.start - a.start).forEach((transformation) => {
-    magicString.update(transformation.start, transformation.end, transformation.newValue);
   });
-  result = magicString.toString();
-  if (needsImport) {
-    result = 'import { camelCaseToHumanReadable as __camelCaseToHumanReadable } from "@highstate/contract"\n' + result;
+  let finalResult = result.toString();
+  if (hasTransformations && !content.includes("$addArgumentDescription")) {
+    finalResult = 'import { $addArgumentDescription, $addInputDescription } from "@highstate/contract"\n' + finalResult;
   }
-  return result;
+  return finalResult;
 }
-function injectDescriptionIntoObject(objectString, description) {
-  const trimmed = objectString.trim();
-  const metaRegex = /meta\s*:\s*\{/;
-  if (metaRegex.test(trimmed)) {
-    const hasDescription = /meta\s*:\s*\{[^}]*description\s*:/.test(trimmed);
-    if (hasDescription) {
-      return trimmed.replace(/description\s*:\s*`[^`]*`/, `description: \`${description}\``);
-    } else {
-      return trimmed.replace(
-        /meta\s*:\s*\{/,
-        `meta: {
-    description: \`${description}\`,`
-      );
-    }
-  } else {
-    const lastBraceIndex = trimmed.lastIndexOf("}");
-    if (lastBraceIndex === -1) {
-      return trimmed;
-    }
-    const beforeBrace = trimmed.substring(0, lastBraceIndex);
-    const afterBrace = trimmed.substring(lastBraceIndex);
-    const needsComma = beforeBrace.trim().length > 1 && !beforeBrace.trim().endsWith(",");
-    const comma = needsComma ? "," : "";
-    return `${beforeBrace}${comma}
+async function applyDefineFunctionMetaTransformations(content) {
+  const { program, comments } = await parseAsync("file.ts", content);
+  const parentStack = [];
+  const result = new MagicString(content);
+  walk(program, {
+    enter(node) {
+      parentStack.push(node);
+      if (node.type === "CallExpression" && "callee" in node && node.callee.type === "Identifier") {
+        const callNode = node;
+        const callee = callNode.callee;
+        const functionName = "name" in callee && typeof callee.name === "string" ? callee.name : void 0;
+        if (functionName && ["defineUnit", "defineEntity", "defineComponent"].includes(functionName)) {
+          const jsdoc = findJsdocForDefineFunction(content, parentStack, comments);
+          if (jsdoc && callNode.arguments && callNode.arguments.length > 0) {
+            const description = cleanJsdoc(jsdoc.value);
+            const firstArg = callNode.arguments[0];
+            if (firstArg.type === "ObjectExpression" && "properties" in firstArg) {
+              const properties = firstArg.properties;
+              const metaProperty = properties?.find(
+                (prop) => prop.type === "Property" && "key" in prop && prop.key?.type === "Identifier" && prop.key?.name === "meta"
+              );
+              if (metaProperty && "value" in metaProperty) {
+                const originalMetaValue = content.substring(
+                  metaProperty.value.start,
+                  metaProperty.value.end
+                );
+                const newMetaValue = injectDescriptionIntoMetaObject(originalMetaValue, description);
+                result.update(metaProperty.value.start, metaProperty.value.end, newMetaValue);
+              } else if (properties && properties.length > 0) {
+                const lastProperty = properties[properties.length - 1];
+                if (lastProperty && "end" in lastProperty) {
+                  const insertPos = lastProperty.end;
+                  const newMetaProperty = `,
+
   meta: {
     description: \`${description}\`,
-  },
-${afterBrace}`;
-  }
-}
-function isStructuredValue(value, expectedField) {
-  const trimmed = value.trim();
-  if (!trimmed.startsWith("{")) {
-    return false;
-  }
-  const fieldPattern = new RegExp(`^\\s*{[^}]*\\b${expectedField}\\s*:`, "s");
-  return fieldPattern.test(trimmed);
+  }`;
+                  result.appendLeft(insertPos, newMetaProperty);
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    leave() {
+      parentStack.pop();
+    }
+  });
+  return result.toString();
 }
-function getMarkerFunctionName(parentStack) {
+function findJsdocForDefineFunction(content, parentStack, comments) {
   for (let i = parentStack.length - 1; i >= 0; i--) {
     const node = parentStack[i];
-    if (node.type === "CallExpression" && node.callee.type === "Identifier") {
-      const functionName = node.callee.name;
-      if (functionName.startsWith("$") && ["$args", "$inputs", "$outputs", "$secrets"].includes(functionName)) {
-        return functionName.substring(1);
-      }
+    if (node.type === "VariableDeclarator" && "id" in node && node.id?.type === "Identifier") {
+      const jsdoc = findLeadingComment(content, node, comments);
+      if (jsdoc) return jsdoc;
+    }
+    if (node.type === "VariableDeclaration") {
+      const jsdoc = findLeadingComment(content, node, comments);
+      if (jsdoc) return jsdoc;
+    }
+    if (node.type === "ExportNamedDeclaration" && "declaration" in node && node.declaration) {
+      const jsdoc = findLeadingComment(content, node, comments);
+      if (jsdoc) return jsdoc;
     }
   }
   return null;
 }
+function isZodObjectProperty(node, parentStack) {
+  return node.type === "Property" && "key" in node && node.key?.type === "Identifier" && isInsideZodObject(parentStack);
+}
+function findLeadingComment(content, node, comments) {
+  return comments.find((comment) => isLeadingComment(content, node, comment)) ?? null;
+}
 function getParentObjectKey(parentStack) {
   for (let i = parentStack.length - 2; i >= 0; i--) {
     const node = parentStack[i];
-    if (node.type === "Property" && node.key.type === "Identifier") {
+    if (node.type === "Property" && "key" in node && node.key.type === "Identifier") {
       return node.key.name;
     }
   }
@@ -294,24 +267,41 @@ function isLeadingComment(content, node, comment) {
 function cleanJsdoc(str) {
   return str.replace(/^\s*\*/gm, "").replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\${/g, "\\${").trim();
 }
+function injectDescriptionIntoMetaObject(objectString, description) {
+  const trimmed = objectString.trim();
+  const hasDescription = /description\s*:/.test(trimmed);
+  if (hasDescription) {
+    return trimmed.replace(/description\s*:\s*`[^`]*`/, `description: \`${description}\``);
+  } else {
+    const openBraceIndex = trimmed.indexOf("{");
+    if (openBraceIndex === -1) {
+      return trimmed;
+    }
+    const beforeBrace = trimmed.substring(0, openBraceIndex + 1);
+    const afterBrace = trimmed.substring(openBraceIndex + 1);
+    return `${beforeBrace}
+    description: \`${description}\`,${afterBrace}`;
+  }
+}
 function isInsideZodObject(parentStack) {
   for (let i = parentStack.length - 1; i >= 0; i--) {
     const node = parentStack[i];
-    if (node.type === "CallExpression" && node.callee.type === "MemberExpression" && isZodObjectCall(node.callee)) {
+    if (node.type === "CallExpression" && "callee" in node && node.callee.type === "MemberExpression" && isZodObjectCall(node.callee)) {
       return true;
     }
   }
   return false;
 }
 function isZodObjectCall(memberExpression) {
-  if (memberExpression.type !== "MemberExpression") {
+  if (memberExpression.type !== "MemberExpression" || !("object" in memberExpression) || !("property" in memberExpression)) {
     return false;
   }
-  if (memberExpression.object.type === "Identifier" && memberExpression.object.name === "z" && memberExpression.property.type === "Identifier" && memberExpression.property.name === "object") {
+  const member = memberExpression;
+  if (member.object.type === "Identifier" && "name" in member.object && member.object.name === "z" && member.property.type === "Identifier" && member.property.name === "object") {
     return true;
   }
-  if (memberExpression.property.type === "Identifier" && memberExpression.property.name === "object" && memberExpression.object.type === "CallExpression" && memberExpression.object.callee.type === "MemberExpression") {
-    return startsWithZodCall(memberExpression.object);
+  if (member.property.type === "Identifier" && member.property.name === "object" && member.object.type === "CallExpression" && "callee" in member.object && member.object.callee.type === "MemberExpression") {
+    return startsWithZodCall(member.object);
   }
   return false;
 }
@@ -320,11 +310,12 @@ function startsWithZodCall(callExpression) {
     return false;
   }
   if (callExpression.callee.type === "MemberExpression") {
-    if (callExpression.callee.object.type === "Identifier" && callExpression.callee.object.name === "z") {
+    const callee = callExpression.callee;
+    if (callee.object.type === "Identifier" && "name" in callee.object && callee.object.name === "z") {
       return true;
     }
-    if (callExpression.callee.object.type === "CallExpression") {
-      return startsWithZodCall(callExpression.callee.object);
+    if (callee.object.type === "CallExpression") {
+      return startsWithZodCall(callee.object);
     }
   }
   return false;
@@ -438,7 +429,6 @@ var SourceHashCalculator = class {
             })
           );
           break;
-        case "auto":
         default:
           promises.push(
             this.getFileHash(fullPath).then((hash) => ({
@@ -594,6 +584,151 @@ ${content}`,
     }
   };
 }
+var packageJsonSchema = z.object({
+  name: z.string(),
+  highstate: highstateConfigSchema.optional()
+});
+function generateTsconfigContent(workspaceRoot, packagePath) {
+  const relativePath = relative(workspaceRoot, packagePath);
+  const depth = relativePath.split("/").length;
+  const relativeNodeModules = `${"../".repeat(depth)}node_modules/@highstate/cli/assets/tsconfig.base.json`;
+  return {
+    extends: relativeNodeModules,
+    include: ["./src/**/*.ts", "./package.json", "./assets/**/*.json"]
+  };
+}
+async function findWorkspaceRoot(startPath = process.cwd()) {
+  let currentPath = resolve(startPath);
+  while (currentPath !== "/") {
+    const packageJsonPath = join(currentPath, "package.json");
+    if (existsSync(packageJsonPath)) {
+      try {
+        const content = await readFile(packageJsonPath, "utf-8");
+        const packageJson = JSON.parse(content);
+        if (packageJson.workspaces) {
+          return currentPath;
+        }
+      } catch {
+      }
+    }
+    const parentPath = resolve(currentPath, "..");
+    if (parentPath === currentPath) break;
+    currentPath = parentPath;
+  }
+  throw new Error("Could not find workspace root (no package.json with workspaces found)");
+}
+async function scanWorkspacePackages(workspaceRoot) {
+  const packages = [];
+  const packagesDir = join(workspaceRoot, "packages");
+  if (!existsSync(packagesDir)) {
+    return packages;
+  }
+  async function scanDirectory(dirPath, depth = 0) {
+    const dirName = relative(packagesDir, dirPath).split("/").pop();
+    if (dirName?.startsWith(".") || dirName === "node_modules") {
+      return;
+    }
+    const entries = await readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const entryPath = join(dirPath, entry.name);
+      if (entry.name.startsWith(".") || entry.name === "node_modules") {
+        continue;
+      }
+      const packageJsonPath = join(entryPath, "package.json");
+      if (existsSync(packageJsonPath)) {
+        try {
+          const content = await readFile(packageJsonPath, "utf-8");
+          const packageJson = packageJsonSchema.parse(JSON.parse(content));
+          const relativePath = relative(workspaceRoot, entryPath);
+          const type = packageJson.highstate?.type ?? "source";
+          packages.push({
+            path: entryPath,
+            relativePath,
+            name: packageJson.name,
+            type
+          });
+        } catch {
+        }
+      }
+      if (depth < 3) {
+        await scanDirectory(entryPath, depth + 1);
+      }
+    }
+  }
+  await scanDirectory(packagesDir);
+  return packages.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+}
+async function updateTsconfigReferences(workspaceRoot, packages, ensureTsconfigs = false) {
+  const tsconfigPath = join(workspaceRoot, "tsconfig.json");
+  if (ensureTsconfigs) {
+    await ensurePackageTsconfigs(
+      workspaceRoot,
+      // only udate for Highstate-managed packages
+      packages.filter((pkg) => pkg.type !== void 0)
+    );
+  }
+  const references = packages.map((pkg) => ({
+    path: `./${pkg.relativePath}/tsconfig.json`
+  }));
+  const tsconfigContent = {
+    files: [],
+    references
+  };
+  await writeFile(tsconfigPath, `${JSON.stringify(tsconfigContent, null, 2)}
+`, "utf-8");
+}
+async function ensurePackageTsconfigs(workspaceRoot, packages) {
+  for (const pkg of packages) {
+    const tsconfigPath = join(pkg.path, "tsconfig.json");
+    const tsconfigContent = generateTsconfigContent(workspaceRoot, pkg.path);
+    await writeFile(tsconfigPath, `${JSON.stringify(tsconfigContent, null, 2)}
+`, "utf-8");
+  }
+}
+async function createPackage(workspaceRoot, name, type) {
+  const packagePath = join(workspaceRoot, "packages", name);
+  const srcPath = join(packagePath, "src");
+  await mkdir(packagePath, { recursive: true });
+  await mkdir(srcPath, { recursive: true });
+  const packageJson = {
+    name: `@highstate/${name}`,
+    version: "0.0.1",
+    type: "module",
+    highstate: {
+      type
+    }
+  };
+  await writeFile(
+    join(packagePath, "package.json"),
+    `${JSON.stringify(packageJson, null, 2)}
+`,
+    "utf-8"
+  );
+  const tsconfigContent = generateTsconfigContent(workspaceRoot, packagePath);
+  await writeFile(
+    join(packagePath, "tsconfig.json"),
+    `${JSON.stringify(tsconfigContent, null, 2)}
+`,
+    "utf-8"
+  );
+  await writeFile(
+    join(packagePath, "CHANGELOG.md"),
+    `# Changelog
+
+All notable changes to this project will be documented in this file.
+`,
+    "utf-8"
+  );
+  await writeFile(join(srcPath, "index.ts"), `// ${name} package
+`, "utf-8");
+  return {
+    path: packagePath,
+    relativePath: `packages/${name}`,
+    name: `@highstate/${name}`,
+    type
+  };
+}
 
 // src/commands/designer.ts
 var DesignerCommand = class extends Command {
@@ -619,10 +754,10 @@ var DesignerCommand = class extends Command {
     const port = await getPort();
     process.env.NITRO_PORT = port.toString();
     process.env.NITRO_HOST = "0.0.0.0";
-    await new Promise((resolve3) => {
+    await new Promise((resolve4) => {
       console.log = (message) => {
         if (message.startsWith("Listening on")) {
-          resolve3();
+          resolve4();
         }
       };
       const path = "@highstate/designer/.output/server/index.mjs";
@@ -759,7 +894,7 @@ var BuildCommand = class extends Command {
       await sourceHashCalculator.writeHighstateManifest("./dist", distPathToExportKey);
     }
     if (this.library) {
-      const { loadLibrary } = await import('./library-loader-ZABUULFB.js');
+      const { loadLibrary } = await import('./library-loader-6TJTW2HX.js');
       const fullModulePaths = Object.values(entry).map((value) => resolve(value.distPath));
       logger.info("evaluating library components from modules: %s", fullModulePaths.join(", "));
       const library = await loadLibrary(logger, fullModulePaths);
@@ -784,6 +919,88 @@ var BackendIdentityCommand = class extends Command {
     logger.info(`run "highstate backend unlock-method add ${recipient}" on other authorized device`);
   }
 };
+var UpdateReferencesCommand = class extends Command {
+  static paths = [["package", "update-references"]];
+  static usage = Command.Usage({
+    category: "Package",
+    description: "Updates the root tsconfig.json with references to all packages in the workspace."
+  });
+  async execute() {
+    const workspaceRoot = await findWorkspaceRoot();
+    const packages = await scanWorkspacePackages(workspaceRoot);
+    await updateTsconfigReferences(workspaceRoot, packages, true);
+  }
+};
+var ListCommand = class extends Command {
+  static paths = [["package", "list"]];
+  static usage = Command.Usage({
+    category: "Package",
+    description: "Lists all packages in the workspace with their types."
+  });
+  async execute() {
+    const workspaceRoot = await findWorkspaceRoot();
+    const packages = await scanWorkspacePackages(workspaceRoot);
+    if (packages.length === 0) {
+      console.log("No packages found in workspace.");
+      return;
+    }
+    const nameWidth = Math.max(4, ...packages.map((pkg) => pkg.name.length));
+    const typeWidth = Math.max(4, ...packages.map((pkg) => pkg.type?.length ?? 0));
+    const pathWidth = Math.max(4, ...packages.map((pkg) => pkg.relativePath.length));
+    console.log(
+      `${"Name".padEnd(nameWidth)} ${"Type".padEnd(typeWidth)} ${"Path".padEnd(pathWidth)}`
+    );
+    console.log(`${"-".repeat(nameWidth)} ${"-".repeat(typeWidth)} ${"-".repeat(pathWidth)}`);
+    for (const pkg of packages) {
+      const type = pkg.type ?? "unknown";
+      console.log(
+        `${pkg.name.padEnd(nameWidth)} ${type.padEnd(typeWidth)} ${pkg.relativePath.padEnd(pathWidth)}`
+      );
+    }
+  }
+};
+var CreateCommand = class extends Command {
+  static paths = [["package", "create"]];
+  static usage = Command.Usage({
+    category: "Package",
+    description: "Creates a new package in the workspace."
+  });
+  name = Option.String({ required: true });
+  type = Option.String("--type,-t", {
+    description: "Package type (source, library, worker)"
+  });
+  async execute() {
+    const workspaceRoot = await findWorkspaceRoot();
+    const packageType = highstateConfigSchema.shape.type.parse(this.type);
+    await createPackage(workspaceRoot, this.name, packageType);
+    const packages = await scanWorkspacePackages(workspaceRoot);
+    await updateTsconfigReferences(workspaceRoot, packages);
+    console.log(`Created package: @highstate/${this.name} (${packageType})`);
+  }
+};
+var RemoveCommand = class extends Command {
+  static paths = [["package", "remove"]];
+  static usage = Command.Usage({
+    category: "Package",
+    description: "Removes a package from the workspace."
+  });
+  name = Option.String({ required: true });
+  async execute() {
+    const workspaceRoot = await findWorkspaceRoot();
+    const packages = await scanWorkspacePackages(workspaceRoot);
+    const targetPackage = packages.find(
+      (pkg) => pkg.name === this.name || pkg.name === `@highstate/${this.name}` || pkg.relativePath.endsWith(this.name)
+    );
+    if (!targetPackage) {
+      console.error(`Package not found: ${this.name}`);
+      process.exit(1);
+    }
+    await rm(targetPackage.path, { recursive: true, force: true });
+    const remainingPackages = await scanWorkspacePackages(workspaceRoot);
+    await updateTsconfigReferences(workspaceRoot, remainingPackages);
+    console.log(`Removed package: ${targetPackage.name}`);
+  }
+};
 
 // src/main.ts
 var cli = new Cli({
@@ -794,6 +1011,10 @@ var cli = new Cli({
 cli.register(BuildCommand);
 cli.register(DesignerCommand);
 cli.register(BackendIdentityCommand);
+cli.register(UpdateReferencesCommand);
+cli.register(ListCommand);
+cli.register(CreateCommand);
+cli.register(RemoveCommand);
 cli.register(Builtins.HelpCommand);
 cli.register(Builtins.VersionCommand);
 await cli.runExit(process.argv.slice(2));