@aspects-ai/workspace-cli 0.1.12 → 0.1.14

package/README.md

@@ -105,34 +105,33 @@ Generate a `remotion-entry.tsx` file for server-side rendering of Remotion compo
 ```bash
 workspace-cli create-remotion-entry
 ```
-
 Options:
 - `-o, --output <path>` - Output path for remotion-entry.tsx (default: `remotion-entry.tsx`)
-- `-f, --frames-dir <path>` - Path to frames directory (default: `frames`)
+- `-f, --compositions-dir <path>` - Path to compositions directory (default: `compositions`)
 
 This command will:
-1. Scan the frames directory for all frame subdirectories
-2. Validate that each frame has a `main.tsx` file
-3. Generate a `remotion-entry.tsx` file with all frames imported and registered
-4. Display the list of registered frames
+1. Scan the compositions directory for all composition subdirectories
+2. Validate that each composition has a `main.tsx` file
+3. Generate a `remotion-entry.tsx` file with all compositions imported and registered
+4. Display the list of registered compositions
 
 Example output:
 ```
-[INFO] Scanning frames in: frames
+[INFO] Scanning compositions in: compositions
 [SUCCESS] Created remotion entry file: /path/to/remotion-entry.tsx
 
-Registered 3 frame(s):
+Registered 3 compositions(s):
   • example
   • healthee
   • peregrine
 
 Next steps:
-  Render a frame: ANIMATION_SSR_MODE=true npx remotion render remotion-entry.tsx <frame-id> output.mp4
+  Render a composition: ANIMATION_SSR_MODE=true npx remotion render remotion-entry.tsx <composition-id> output.mp4
 ```
 
 The generated file can be used with Remotion CLI for server-side rendering:
 ```bash
-# Render a specific frame
+# Render a specific composition
 ANIMATION_SSR_MODE=true npx remotion render remotion-entry.tsx example output.mp4
 
 # List available compositions

package/dist/index.js

@@ -3,7 +3,45 @@
 // src/index.ts
 import { Command as Command8 } from "commander";
 
-// src/commands/init.ts
+// package.json
+var package_default = {
+  name: "@aspects-ai/workspace-cli",
+  version: "0.1.14",
+  private: false,
+  description: "Lightweight CLI for installing libraries into workspaces",
+  type: "module",
+  bin: {
+    "workspace-cli": "./dist/index.js"
+  },
+  scripts: {
+    build: "tsup src/index.ts --format esm --dts --clean && npm run copy:registry",
+    "copy:registry": "mkdir -p dist/registry && cp src/registry/libraries.json dist/registry/",
+    dev: "tsup src/index.ts --format esm --watch",
+    typecheck: "tsc --noEmit"
+  },
+  files: [
+    "dist",
+    "src/registry"
+  ],
+  dependencies: {
+    chalk: "^5.3.0",
+    commander: "^12.0.0",
+    execa: "^8.0.0",
+    "fs-extra": "^11.2.0",
+    zod: "^3.22.0"
+  },
+  devDependencies: {
+    "@types/fs-extra": "^11.0.0",
+    "@types/node": "^20",
+    tsup: "^8.0.0",
+    typescript: "^5"
+  },
+  engines: {
+    node: ">=18.0.0"
+  }
+};
+
+// src/commands/add.ts
 import { Command } from "commander";
 
 // src/utils/fs.ts
@@ -114,128 +152,6 @@ function getConfigPath(workspaceRoot) {
   return path2.join(workspaceRoot, CONFIG_FILE_NAME);
 }
 
-// src/utils/logger.ts
-import chalk from "chalk";
-var logger = {
-  info(message) {
-    console.log(chalk.blue("[INFO]"), message);
-  },
-  success(message) {
-    console.log(chalk.green("[SUCCESS]"), message);
-  },
-  error(message) {
-    console.error(chalk.red("[ERROR]"), message);
-  },
-  warn(message) {
-    console.warn(chalk.yellow("[WARN]"), message);
-  },
-  log(message) {
-    console.log(message);
-  }
-};
-
-// src/commands/init.ts
-function createInitCommand() {
-  return new Command("init").description("Initialize workspace configuration").action(async () => {
-    try {
-      const workspaceRoot = await ensureWorkspaceRoot();
-      const existing = await loadWorkspaceConfig(workspaceRoot);
-      if (existing) {
-        logger.warn("workspace.config.json already exists");
-        logger.info(`Config file: ${getConfigPath(workspaceRoot)}`);
-        return;
-      }
-      await createDefaultConfig(workspaceRoot);
-      logger.success("Created workspace.config.json");
-      logger.log("\nNext steps:");
-      logger.log("  workspace-cli list          # View available libraries");
-      logger.log("  workspace-cli add <library> # Install a library");
-    } catch (error) {
-      logger.error(error.message);
-      process.exit(1);
-    }
-  });
-}
-
-// src/commands/list.ts
-import { Command as Command2 } from "commander";
-
-// src/core/registry.ts
-import { z as z2 } from "zod";
-var RepositorySchema = z2.object({
-  url: z2.string(),
-  directory: z2.string(),
-  branch: z2.string(),
-  packageJsonPath: z2.string().optional()
-  // Path to package.json in repo (e.g., "noodle-animate-core/package.json")
-});
-var LibrarySchema = z2.object({
-  name: z2.string(),
-  description: z2.string(),
-  version: z2.string().optional(),
-  // Optional - if not provided, will be read from package.json in repo
-  repository: RepositorySchema,
-  installPath: z2.string(),
-  dependencies: z2.record(z2.string()).optional()
-  // Optional - if not provided, will be read from package.json in repo
-});
-var RegistrySchema = z2.object({
-  libraries: z2.record(LibrarySchema)
-});
-var cachedRegistry = null;
-async function loadRegistry() {
-  if (cachedRegistry) {
-    return cachedRegistry;
-  }
-  const registryPath = getRegistryPath();
-  const data = await readJsonFile(registryPath);
-  cachedRegistry = RegistrySchema.parse(data);
-  return cachedRegistry;
-}
-async function getLibrary(libraryName) {
-  const registry = await loadRegistry();
-  const library = registry.libraries[libraryName];
-  if (!library) {
-    throw new Error(
-      `Library '${libraryName}' not found in registry.
-Available libraries: ${Object.keys(registry.libraries).join(", ")}`
-    );
-  }
-  return library;
-}
-async function listLibraries() {
-  const registry = await loadRegistry();
-  return Object.entries(registry.libraries).map(([name, library]) => ({
-    name,
-    library
-  }));
-}
-
-// src/commands/list.ts
-import chalk2 from "chalk";
-function createListCommand() {
-  return new Command2("list").description("List available libraries").action(async () => {
-    try {
-      const libraries = await listLibraries();
-      logger.log(chalk2.bold("\nAvailable libraries:\n"));
-      for (const { name, library } of libraries) {
-        const versionStr = library.version ? ` @${library.version}` : " @latest";
-        logger.log(chalk2.cyan(`  ${name}`) + chalk2.gray(versionStr));
-        logger.log(`    ${library.description}`);
-        logger.log("");
-      }
-      logger.log(`Total: ${libraries.length} ${libraries.length === 1 ? "library" : "libraries"}
-`);
-    } catch (error) {
-      logger.error(error.message);
-      process.exit(1);
-    }
-  });
-}
-
-// src/commands/add.ts
-import { Command as Command3 } from "commander";
-
 // src/core/installer.ts
 import path4 from "path";
 import fs4 from "fs-extra";
@@ -321,6 +237,77 @@ function getToken() {
   return token;
 }
 
+// src/core/registry.ts
+import { z as z2 } from "zod";
+var RepositorySchema = z2.object({
+  url: z2.string(),
+  directory: z2.string(),
+  branch: z2.string(),
+  packageJsonPath: z2.string().optional()
+  // Path to package.json in repo (e.g., "noodle-animate-core/package.json")
+});
+var LibrarySchema = z2.object({
+  name: z2.string(),
+  description: z2.string(),
+  version: z2.string().optional(),
+  // Optional - if not provided, will be read from package.json in repo
+  repository: RepositorySchema,
+  installPath: z2.string(),
+  dependencies: z2.record(z2.string()).optional()
+  // Optional - if not provided, will be read from package.json in repo
+});
+var RegistrySchema = z2.object({
+  libraries: z2.record(LibrarySchema)
+});
+var cachedRegistry = null;
+async function loadRegistry() {
+  if (cachedRegistry) {
+    return cachedRegistry;
+  }
+  const registryPath = getRegistryPath();
+  const data = await readJsonFile(registryPath);
+  cachedRegistry = RegistrySchema.parse(data);
+  return cachedRegistry;
+}
+async function getLibrary(libraryName) {
+  const registry = await loadRegistry();
+  const library = registry.libraries[libraryName];
+  if (!library) {
+    throw new Error(
+      `Library '${libraryName}' not found in registry.
+Available libraries: ${Object.keys(registry.libraries).join(", ")}`
+    );
+  }
+  return library;
+}
+async function listLibraries() {
+  const registry = await loadRegistry();
+  return Object.entries(registry.libraries).map(([name, library]) => ({
+    name,
+    library
+  }));
+}
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var logger = {
+  info(message) {
+    console.log(chalk.blue("[INFO]"), message);
+  },
+  success(message) {
+    console.log(chalk.green("[SUCCESS]"), message);
+  },
+  error(message) {
+    console.error(chalk.red("[ERROR]"), message);
+  },
+  warn(message) {
+    console.warn(chalk.yellow("[WARN]"), message);
+  },
+  log(message) {
+    console.log(message);
+  }
+};
+
 // src/core/installer.ts
 async function installLibrary(workspaceRoot, libraryName, options = {}) {
   if (!options.force && await isLibraryInstalled(workspaceRoot, libraryName)) {
@@ -382,47 +369,16 @@ async function updatePackageDependencies(workspaceRoot, dependencies) {
 }
 
 // src/commands/add.ts
-import chalk3 from "chalk";
+import chalk2 from "chalk";
 function createAddCommand() {
-  return new Command3("add").description("Add a library to the workspace").argument("<library>", "Name of the library to add").option("-f, --force", "Force reinstall if already installed").action(async (libraryName, options) => {
+  return new Command("add").description("Add a library to the workspace").argument("<library>", "Name of the library to add").option("-f, --force", "Force reinstall if already installed").action(async (libraryName, options) => {
     try {
       const workspaceRoot = await ensureWorkspaceRoot();
       await getOrCreateConfig(workspaceRoot);
       await installLibrary(workspaceRoot, libraryName, { force: options.force });
-      logger.log("\n" + chalk3.bold("Next steps:"));
-      logger.log(`  ${chalk3.gray("Import components:")} import { ... } from '@/core/${libraryName.replace("animate-", "")}'`);
-      logger.log(`  ${chalk3.gray("Install dependencies:")} npm install`);
-      logger.log("");
-    } catch (error) {
-      logger.error(error.message);
-      process.exit(1);
-    }
-  });
-}
-
-// src/commands/update.ts
-import { Command as Command4 } from "commander";
-import chalk4 from "chalk";
-function createUpdateCommand() {
-  return new Command4("update").description("Update an installed library to the latest version").argument("<library>", "Name of the library to update").action(async (libraryName) => {
-    try {
-      const workspaceRoot = await ensureWorkspaceRoot();
-      await getOrCreateConfig(workspaceRoot);
-      if (!await isLibraryInstalled(workspaceRoot, libraryName)) {
-        throw new Error(
-          `Library '${libraryName}' is not installed.
-Use 'workspace-cli add ${libraryName}' to install it first.`
-        );
-      }
-      const config = await loadWorkspaceConfig(workspaceRoot);
-      const currentVersion = config?.libraries[libraryName]?.version || "unknown";
-      const currentCommit = config?.libraries[libraryName]?.commit || "unknown";
-      logger.info(`Current version: ${currentVersion} (commit: ${currentCommit.substring(0, 7)})`);
-      logger.info(`Updating ${libraryName}...`);
-      await installLibrary(workspaceRoot, libraryName, { force: true });
-      logger.log("\n" + chalk4.bold("Next steps:"));
-      logger.log(`  ${chalk4.gray("Review changes:")} git diff ./core/${libraryName.replace("animate-", "")}`);
-      logger.log(`  ${chalk4.gray("Install updated dependencies:")} npm install`);
+      logger.log("\n" + chalk2.bold("Next steps:"));
+      logger.log(`  ${chalk2.gray("Import components:")} import { ... } from '@/core/${libraryName.replace("animate-", "")}'`);
+      logger.log(`  ${chalk2.gray("Install dependencies:")} npm install`);
       logger.log("");
     } catch (error) {
       logger.error(error.message);
@@ -431,9 +387,9 @@ Use 'workspace-cli add ${libraryName}' to install it first.`
   });
 }
 
-// src/commands/create-frame.ts
-import chalk5 from "chalk";
-import { Command as Command5 } from "commander";
+// src/commands/create-composition.ts
+import chalk3 from "chalk";
+import { Command as Command2 } from "commander";
 import fs5 from "fs-extra";
 import path5 from "path";
 function generateId() {
@@ -446,73 +402,77 @@ function parseManifestOption(manifestStr) {
     throw new Error(`Invalid manifest JSON: ${error instanceof Error ? error.message : "Unknown error"}`);
   }
 }
-function validateAndFixManifest(manifest, toolName, frameName) {
+function validateAndFixManifest(manifest, toolName, compositionName) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const validatedManifest = {
-    id: frameName,
+    id: compositionName,
     // Always match the directory name
     projectId: manifest.projectId || "default-project",
-    title: manifest.title || frameName.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" "),
-    description: manifest.description || `Frame for ${toolName}`,
+    title: manifest.title || compositionName.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" "),
+    description: manifest.description || `Composition for ${toolName}`,
     createdAt: now,
     // Always update createdAt
-    type: manifest.type || "animationComposition"
+    compositionType: manifest.compositionType || "animationComposition",
+    width: manifest.width,
+    height: manifest.height
   };
   if (toolName === "animate-core") {
-    validatedManifest.type = "animationComposition";
+    validatedManifest.compositionType = "animationComposition";
+    if (!validatedManifest.width) validatedManifest.width = 1920;
+    if (!validatedManifest.height) validatedManifest.height = 1080;
   }
   return validatedManifest;
 }
-async function getNextFrameName(framesDir, customName) {
-  let frameName;
+async function getNextCompositionName(compositionsDir, customName) {
+  let compositionName;
   if (customName) {
     const truncatedName = customName.slice(0, 20);
     const uniqueId = generateId();
-    frameName = `${truncatedName}-${uniqueId}`;
+    compositionName = `${truncatedName}-${uniqueId}`;
   } else {
-    frameName = generateId();
+    compositionName = generateId();
   }
-  while (await fs5.pathExists(path5.join(framesDir, frameName))) {
+  while (await fs5.pathExists(path5.join(compositionsDir, compositionName))) {
     const uniqueId = generateId();
-    frameName = customName ? `${customName.slice(0, 20)}-${uniqueId}` : uniqueId;
+    compositionName = customName ? `${customName.slice(0, 20)}-${uniqueId}` : uniqueId;
   }
-  return frameName;
+  return compositionName;
 }
-async function fetchExampleFrame(toolName, targetPath) {
+async function fetchExampleComposition(toolName, targetPath) {
   const library = await getLibrary(toolName);
   const token = getToken();
-  logger.info(`Fetching example frame from ${chalk5.cyan(library.repository.url)}`);
-  const exampleFrameDirectory = library.repository.directory.replace("/src", "/example-frame-123");
+  logger.info(`Fetching example composition from ${chalk3.cyan(library.repository.url)}`);
+  const exampleCompositionDirectory = library.repository.directory.replace("/src", "/starter-composition-123");
   await fetchDirectory({
     repository: library.repository.url,
-    directory: exampleFrameDirectory,
+    directory: exampleCompositionDirectory,
     branch: library.repository.branch,
     token,
     targetPath
   });
 }
-function createCreateFrameCommand() {
-  return new Command5("create-frame").description("Create a new frame for a given tool").argument("<tool>", "Name of the tool (e.g., animate-core)").argument("<manifest>", "Manifest data as JSON string").option("-n, --name <name>", "Name for the new frame", "new-frame").action(async (toolName, manifestStr, options) => {
+function createCreateCompositionCommand() {
+  return new Command2("create-composition").description("Create a new composition for a given tool").argument("<tool>", "Name of the tool (e.g., animate-core)").argument("<manifest>", "Manifest data as JSON string").option("-n, --name <name>", "Name for the new composition", "new-composition").action(async (toolName, manifestStr, options) => {
     try {
       const workspaceRoot = await ensureWorkspaceRoot();
-      const framesDir = path5.join(workspaceRoot, "frames");
-      await fs5.ensureDir(framesDir);
-      const customName = options.name && options.name !== "new-frame" ? options.name : void 0;
-      const frameName = await getNextFrameName(framesDir, customName);
-      const frameDir = path5.join(framesDir, frameName);
-      logger.info(`Creating frame: ${chalk5.cyan(frameName)} for ${chalk5.cyan(toolName)}`);
-      await fetchExampleFrame(toolName, frameDir);
+      const compositionsDir = path5.join(workspaceRoot, "compositions");
+      await fs5.ensureDir(compositionsDir);
+      const customName = options.name && options.name !== "new-composition" ? options.name : void 0;
+      const compositionName = await getNextCompositionName(compositionsDir, customName);
+      const compositionDir = path5.join(compositionsDir, compositionName);
+      logger.info(`Creating composition: ${chalk3.cyan(compositionName)} for ${chalk3.cyan(toolName)}`);
+      await fetchExampleComposition(toolName, compositionDir);
       const manifestData = parseManifestOption(manifestStr);
-      const validatedManifest = validateAndFixManifest(manifestData, toolName, frameName);
-      const manifestPath = path5.join(frameDir, "manifest.json");
+      const validatedManifest = validateAndFixManifest(manifestData, toolName, compositionName);
+      const manifestPath = path5.join(compositionDir, "manifest.json");
       await fs5.writeJson(manifestPath, validatedManifest, { spaces: 4 });
-      logger.success(`Frame created at: ${chalk5.green(path5.relative(workspaceRoot, frameDir))}`);
+      logger.success(`Composition created at: ${chalk3.green(path5.relative(workspaceRoot, compositionDir))}`);
       logger.log("");
-      logger.log(chalk5.bold("Manifest:"));
+      logger.log(chalk3.bold("Manifest:"));
       logger.log(JSON.stringify(validatedManifest, null, 2));
       logger.log("");
-      logger.log(chalk5.bold("Next steps:"));
-      logger.log(`  ${chalk5.gray("Edit frame:")} ${path5.relative(workspaceRoot, path5.join(frameDir, "main.tsx"))}`);
+      logger.log(chalk3.bold("Next steps:"));
+      logger.log(`  ${chalk3.gray("Edit composition:")} ${path5.relative(workspaceRoot, path5.join(compositionDir, "main.tsx"))}`);
       logger.log("");
     } catch (error) {
       logger.error(error.message);
@@ -521,10 +481,154 @@ function createCreateFrameCommand() {
   });
 }
 
+// src/commands/create-remotion-entry.ts
+import chalk4 from "chalk";
+import { Command as Command3 } from "commander";
+import fs6 from "fs-extra";
+import path6 from "path";
+async function createRemotionEntry(compositionsDir, outputPath, animateCorePath) {
+  if (!await fs6.pathExists(compositionsDir)) {
+    throw new Error(`Compositions directory not found: ${compositionsDir}`);
+  }
+  const entries = await fs6.readdir(compositionsDir, { withFileTypes: true });
+  const compositionDirs = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  if (compositionDirs.length === 0) {
+    throw new Error(`No composition directories found in ${compositionsDir}`);
+  }
+  const validCompositions = [];
+  for (const compositionDir of compositionDirs) {
+    const mainPath = path6.join(compositionsDir, compositionDir, "main.tsx");
+    if (await fs6.pathExists(mainPath)) {
+      validCompositions.push(compositionDir);
+    } else {
+      logger.warn(`Skipping ${compositionDir}: main.tsx not found`);
+    }
+  }
+  if (validCompositions.length === 0) {
+    throw new Error("No valid compositions found (compositions must contain main.tsx)");
+  }
+  const imports = validCompositions.map((compositionDir, index) => {
+    const varName = `Composition${index}`;
+    const defName = `composition${index}Def`;
+    return {
+      compositionDir,
+      varName,
+      defName,
+      statement: `import ${varName}, { compositionDefinition as ${defName} } from './compositions/${compositionDir}/main';`
+    };
+  });
+  const compositionsObject = imports.map(({ compositionDir, varName, defName }) => {
+    return `  '${compositionDir}': { component: ${varName}, compositionDefinition: ${defName} },`;
+  }).join("\n");
+  const content = `/**
+ * Auto-generated Remotion SSR Entry Point
+ *
+ * Generated by: @aspects-ai/workspace-cli create-remotion-entry
+ * DO NOT EDIT THIS FILE MANUALLY - it will be overwritten
+ *
+ * This file serves as the entry point for server-side rendering with Remotion.
+ * It automatically registers all compositions in the ./compositions directory.
+ *
+ * Usage:
+ *   ANIMATION_SSR_MODE=true npx remotion render remotion-entry.tsx <composition-id> output.mp4
+ *
+ * To regenerate this file:
+ *   npx @aspects-ai/workspace-cli create-remotion-entry
+ */
+
+import { registerRoot } from 'remotion';
+import { createRemotionRoot } from '${animateCorePath}/remotion';
+
+// Composition imports
+${imports.map((i) => i.statement).join("\n")}
+
+// Register all compositions with Remotion
+const Root = createRemotionRoot({
+${compositionsObject}
+});
+
+registerRoot(Root);
+`;
+  await fs6.writeFile(outputPath, content, "utf-8");
+  logger.success(`Created remotion entry file: ${chalk4.green(outputPath)}`);
+  logger.log("");
+  logger.log(chalk4.bold(`Registered ${validCompositions.length} composition(s):`));
+  validCompositions.forEach((composition) => {
+    logger.log(`  ${chalk4.cyan("\u2022")} ${composition}`);
+  });
+  logger.log("");
+  logger.log(chalk4.bold("Next steps:"));
+  logger.log(`  ${chalk4.gray("Render a composition:")} ANIMATION_SSR_MODE=true npx remotion render remotion-entry.tsx <composition-id> output.mp4`);
+  logger.log("");
+}
+function createCreateRemotionEntryCommand() {
+  return new Command3("create-remotion-entry").description("Create a remotion-entry.tsx file for server-side rendering").option("-o, --output <path>", "Output path for remotion-entry.tsx", "remotion-entry.tsx").option("-f, --compositions-dir <path>", "Path to compositions directory", "compositions").option("-a, --animate-core-path <path>", "Path to animate-core (e.g., ./core/animate-core or @aspects-ai/noodle-animate-core)", "./core/animate-core").action(async (options) => {
+    try {
+      const workspaceRoot = await ensureWorkspaceRoot();
+      const compositionsDir = path6.resolve(workspaceRoot, options.compositionsDir || "compositions");
+      const outputPath = path6.resolve(workspaceRoot, options.output || "remotion-entry.tsx");
+      const animateCorePath = options.animateCorePath || "./core/animate-core";
+      logger.info(`Scanning compositions in: ${chalk4.cyan(path6.relative(workspaceRoot, compositionsDir))}`);
+      logger.info(`Using animate-core from: ${chalk4.cyan(animateCorePath)}`);
+      await createRemotionEntry(compositionsDir, outputPath, animateCorePath);
+    } catch (error) {
+      logger.error(error.message);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/init.ts
+import { Command as Command4 } from "commander";
+function createInitCommand() {
+  return new Command4("init").description("Initialize workspace configuration").action(async () => {
+    try {
+      const workspaceRoot = await ensureWorkspaceRoot();
+      const existing = await loadWorkspaceConfig(workspaceRoot);
+      if (existing) {
+        logger.warn("workspace.config.json already exists");
+        logger.info(`Config file: ${getConfigPath(workspaceRoot)}`);
+        return;
+      }
+      await createDefaultConfig(workspaceRoot);
+      logger.success("Created workspace.config.json");
+      logger.log("\nNext steps:");
+      logger.log("  workspace-cli list          # View available libraries");
+      logger.log("  workspace-cli add <library> # Install a library");
+    } catch (error) {
+      logger.error(error.message);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/list.ts
+import { Command as Command5 } from "commander";
+import chalk5 from "chalk";
+function createListCommand() {
+  return new Command5("list").description("List available libraries").action(async () => {
+    try {
+      const libraries = await listLibraries();
+      logger.log(chalk5.bold("\nAvailable libraries:\n"));
+      for (const { name, library } of libraries) {
+        const versionStr = library.version ? ` @${library.version}` : " @latest";
+        logger.log(chalk5.cyan(`  ${name}`) + chalk5.gray(versionStr));
+        logger.log(`    ${library.description}`);
+        logger.log("");
+      }
+      logger.log(`Total: ${libraries.length} ${libraries.length === 1 ? "library" : "libraries"}
+`);
+    } catch (error) {
+      logger.error(error.message);
+      process.exit(1);
+    }
+  });
+}
+
 // src/commands/update-template.ts
 import { Command as Command6 } from "commander";
-import path6 from "path";
-import fs6 from "fs-extra";
+import path7 from "path";
+import fs7 from "fs-extra";
 import { execa as execa2 } from "execa";
 import os2 from "os";
 import chalk6 from "chalk";
@@ -535,9 +639,9 @@ function createUpdateTemplateCommand() {
   return new Command6("update-template").description("Update EDITING.md file from noodle-base template").action(async () => {
     try {
       const workspaceRoot = await ensureWorkspaceRoot();
-      const targetFile = path6.join(workspaceRoot, "EDITING.md");
+      const targetFile = path7.join(workspaceRoot, "EDITING.md");
       const token = getToken();
-      const targetExists = await fs6.pathExists(targetFile);
+      const targetExists = await fs7.pathExists(targetFile);
       if (targetExists) {
         logger.info("Existing EDITING.md found, it will be overwritten.");
       }
@@ -548,7 +652,7 @@ function createUpdateTemplateCommand() {
         branch: NOODLE_BASE_BRANCH,
         token
       });
-      await fs6.writeFile(targetFile, content, "utf-8");
+      await fs7.writeFile(targetFile, content, "utf-8");
       logger.success(
         `Successfully ${targetExists ? "updated" : "copied"} EDITING.md to workspace`
       );
@@ -562,7 +666,7 @@ function createUpdateTemplateCommand() {
   });
 }
 async function fetchFileFromGit(options) {
-  const tempDir = await fs6.mkdtemp(path6.join(os2.tmpdir(), "workspace-cli-"));
+  const tempDir = await fs7.mkdtemp(path7.join(os2.tmpdir(), "workspace-cli-"));
   try {
     const repoUrl = options.repository.replace(
       "https://github.com/",
@@ -571,18 +675,18 @@ async function fetchFileFromGit(options) {
     await execa2("git", ["init"], { cwd: tempDir });
     await execa2("git", ["remote", "add", "origin", repoUrl], { cwd: tempDir });
     await execa2("git", ["config", "core.sparseCheckout", "true"], { cwd: tempDir });
-    const sparseFile = path6.join(tempDir, ".git", "info", "sparse-checkout");
-    await fs6.writeFile(sparseFile, `${options.filePath}
+    const sparseFile = path7.join(tempDir, ".git", "info", "sparse-checkout");
+    await fs7.writeFile(sparseFile, `${options.filePath}
 `);
     await execa2("git", ["pull", "origin", options.branch, "--depth=1"], {
       cwd: tempDir,
       stderr: "pipe"
     });
-    const sourceFile = path6.join(tempDir, options.filePath);
-    if (!await fs6.pathExists(sourceFile)) {
+    const sourceFile = path7.join(tempDir, options.filePath);
+    if (!await fs7.pathExists(sourceFile)) {
       throw new Error(`File '${options.filePath}' not found in repository`);
     }
-    return await fs6.readFile(sourceFile, "utf-8");
+    return await fs7.readFile(sourceFile, "utf-8");
   } catch (error) {
     if (error.stderr && error.stderr.includes("Authentication failed")) {
       throw new Error(
@@ -591,100 +695,34 @@ async function fetchFileFromGit(options) {
     }
     throw new Error(`Failed to fetch file from git: ${error.message}`);
   } finally {
-    await fs6.remove(tempDir);
+    await fs7.remove(tempDir);
   }
 }
 
-// src/commands/create-remotion-entry.ts
-import chalk7 from "chalk";
+// src/commands/update.ts
 import { Command as Command7 } from "commander";
-import fs7 from "fs-extra";
-import path7 from "path";
-async function createRemotionEntry(framesDir, outputPath, animateCorePath) {
-  if (!await fs7.pathExists(framesDir)) {
-    throw new Error(`Frames directory not found: ${framesDir}`);
-  }
-  const entries = await fs7.readdir(framesDir, { withFileTypes: true });
-  const frameDirs = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-  if (frameDirs.length === 0) {
-    throw new Error(`No frame directories found in ${framesDir}`);
-  }
-  const validFrames = [];
-  for (const frameDir of frameDirs) {
-    const mainPath = path7.join(framesDir, frameDir, "main.tsx");
-    if (await fs7.pathExists(mainPath)) {
-      validFrames.push(frameDir);
-    } else {
-      logger.warn(`Skipping ${frameDir}: main.tsx not found`);
-    }
-  }
-  if (validFrames.length === 0) {
-    throw new Error("No valid frames found (frames must contain main.tsx)");
-  }
-  const imports = validFrames.map((frameDir, index) => {
-    const varName = `Frame${index}`;
-    const defName = `frame${index}Def`;
-    return {
-      frameDir,
-      varName,
-      defName,
-      statement: `import ${varName}, { compositionDefinition as ${defName} } from './frames/${frameDir}/main';`
-    };
-  });
-  const framesObject = imports.map(({ frameDir, varName, defName }) => {
-    return `  '${frameDir}': { component: ${varName}, compositionDefinition: ${defName} },`;
-  }).join("\n");
-  const content = `/**
- * Auto-generated Remotion SSR Entry Point
- *
- * Generated by: @aspects-ai/workspace-cli create-remotion-entry
- * DO NOT EDIT THIS FILE MANUALLY - it will be overwritten
- *
- * This file serves as the entry point for server-side rendering with Remotion.
- * It automatically registers all frames in the ./frames directory.
- *
- * Usage:
- *   ANIMATION_SSR_MODE=true npx remotion render remotion-entry.tsx <frame-id> output.mp4
- *
- * To regenerate this file:
- *   npx @aspects-ai/workspace-cli create-remotion-entry
- */
-
-import { registerRoot } from 'remotion';
-import { createRemotionRoot } from '${animateCorePath}/remotion';
-
-// Frame imports
-${imports.map((i) => i.statement).join("\n")}
-
-// Register all frames with Remotion
-const Root = createRemotionRoot({
-${framesObject}
-});
-
-registerRoot(Root);
-`;
-  await fs7.writeFile(outputPath, content, "utf-8");
-  logger.success(`Created remotion entry file: ${chalk7.green(outputPath)}`);
-  logger.log("");
-  logger.log(chalk7.bold(`Registered ${validFrames.length} frame(s):`));
-  validFrames.forEach((frame) => {
-    logger.log(`  ${chalk7.cyan("\u2022")} ${frame}`);
-  });
-  logger.log("");
-  logger.log(chalk7.bold("Next steps:"));
-  logger.log(`  ${chalk7.gray("Render a frame:")} ANIMATION_SSR_MODE=true npx remotion render remotion-entry.tsx <frame-id> output.mp4`);
-  logger.log("");
-}
-function createCreateRemotionEntryCommand() {
-  return new Command7("create-remotion-entry").description("Create a remotion-entry.tsx file for server-side rendering").option("-o, --output <path>", "Output path for remotion-entry.tsx", "remotion-entry.tsx").option("-f, --frames-dir <path>", "Path to frames directory", "frames").option("-a, --animate-core-path <path>", "Path to animate-core (e.g., ./core/animate-core or @aspects-ai/noodle-animate-core)", "./core/animate-core").action(async (options) => {
+import chalk7 from "chalk";
+function createUpdateCommand() {
+  return new Command7("update").description("Update an installed library to the latest version").argument("<library>", "Name of the library to update").action(async (libraryName) => {
     try {
       const workspaceRoot = await ensureWorkspaceRoot();
-      const framesDir = path7.resolve(workspaceRoot, options.framesDir || "frames");
-      const outputPath = path7.resolve(workspaceRoot, options.output || "remotion-entry.tsx");
-      const animateCorePath = options.animateCorePath || "./core/animate-core";
-      logger.info(`Scanning frames in: ${chalk7.cyan(path7.relative(workspaceRoot, framesDir))}`);
-      logger.info(`Using animate-core from: ${chalk7.cyan(animateCorePath)}`);
-      await createRemotionEntry(framesDir, outputPath, animateCorePath);
+      await getOrCreateConfig(workspaceRoot);
+      if (!await isLibraryInstalled(workspaceRoot, libraryName)) {
+        throw new Error(
+          `Library '${libraryName}' is not installed.
+Use 'workspace-cli add ${libraryName}' to install it first.`
+        );
+      }
+      const config = await loadWorkspaceConfig(workspaceRoot);
+      const currentVersion = config?.libraries[libraryName]?.version || "unknown";
+      const currentCommit = config?.libraries[libraryName]?.commit || "unknown";
+      logger.info(`Current version: ${currentVersion} (commit: ${currentCommit.substring(0, 7)})`);
+      logger.info(`Updating ${libraryName}...`);
+      await installLibrary(workspaceRoot, libraryName, { force: true });
+      logger.log("\n" + chalk7.bold("Next steps:"));
+      logger.log(`  ${chalk7.gray("Review changes:")} git diff ./core/${libraryName.replace("animate-", "")}`);
+      logger.log(`  ${chalk7.gray("Install updated dependencies:")} npm install`);
+      logger.log("");
     } catch (error) {
       logger.error(error.message);
       process.exit(1);
@@ -692,44 +730,6 @@ function createCreateRemotionEntryCommand() {
   });
 }
 
-// package.json
-var package_default = {
-  name: "@aspects-ai/workspace-cli",
-  version: "0.1.12",
-  private: false,
-  description: "Lightweight CLI for installing libraries into workspaces",
-  type: "module",
-  bin: {
-    "workspace-cli": "./dist/index.js"
-  },
-  scripts: {
-    build: "tsup src/index.ts --format esm --dts --clean && npm run copy:registry",
-    "copy:registry": "mkdir -p dist/registry && cp src/registry/libraries.json dist/registry/",
-    dev: "tsup src/index.ts --format esm --watch",
-    typecheck: "tsc --noEmit"
-  },
-  files: [
-    "dist",
-    "src/registry"
-  ],
-  dependencies: {
-    chalk: "^5.3.0",
-    commander: "^12.0.0",
-    execa: "^8.0.0",
-    "fs-extra": "^11.2.0",
-    zod: "^3.22.0"
-  },
-  devDependencies: {
-    "@types/fs-extra": "^11.0.0",
-    "@types/node": "^20",
-    tsup: "^8.0.0",
-    typescript: "^5"
-  },
-  engines: {
-    node: ">=18.0.0"
-  }
-};
-
 // src/index.ts
 var program = new Command8();
 program.name("workspace-cli").description("Lightweight CLI for installing libraries into workspaces").version(package_default.version);
@@ -737,7 +737,7 @@ program.addCommand(createInitCommand());
 program.addCommand(createListCommand());
 program.addCommand(createAddCommand());
 program.addCommand(createUpdateCommand());
-program.addCommand(createCreateFrameCommand());
+program.addCommand(createCreateCompositionCommand());
 program.addCommand(createUpdateTemplateCommand());
 program.addCommand(createCreateRemotionEntryCommand());
 program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aspects-ai/workspace-cli",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "private": false,
   "description": "Lightweight CLI for installing libraries into workspaces",
   "type": "module",