cognite-create 0.1.5 → 0.1.7

package/bin/index.js

@@ -1,9 +1,15 @@
 #!/usr/bin/env node
 
+// eslint-disable-next-line @typescript-eslint/no-require-imports
 const { spawn } = require('node:child_process');
+// eslint-disable-next-line @typescript-eslint/no-require-imports
 const fs = require('node:fs/promises');
+// eslint-disable-next-line @typescript-eslint/no-require-imports
 const path = require('node:path');
 
+const TW_ANIMATE_PACKAGE = 'tw-animate-css';
+const TW_ANIMATE_VERSION = '^1.3.8';
+
 async function main() {
   const args = process.argv.slice(2);
 
@@ -54,18 +60,23 @@ async function addCogniteTemplates(projectDir) {
     throw error;
   }
 
-  const appDirectory = await resolveAppDirectory(targetRoot);
+  await ensureTwAnimateCssInstalled(targetRoot);
+
+  const srcDirectory = path.join(targetRoot, 'src');
   const templateFiles = await collectTemplateFiles(templateRoot);
 
+  await fs.mkdir(srcDirectory, { recursive: true });
+
   for (const relativePath of templateFiles) {
     const normalizedPath = normalizeRelativePath(relativePath);
     const source = path.join(templateRoot, relativePath);
 
     const pathSegments = normalizedPath.split('/');
 
-    if (pathSegments[0] === 'app') {
-      const target = path.join(appDirectory, ...pathSegments.slice(1));
-      const isGlobalsCss = pathSegments.length === 2 && pathSegments[1] === 'globals.css';
+    if (pathSegments[0] === 'app' || pathSegments[0] === 'lib') {
+      const target = path.join(srcDirectory, ...pathSegments);
+      const isGlobalsCss =
+        pathSegments[0] === 'app' && pathSegments.length === 2 && pathSegments[1] === 'globals.css';
 
       if (isGlobalsCss) {
         await copyFileWithOverwrite(source, target);
@@ -105,19 +116,6 @@ async function copyFileWithOverwrite(source, target) {
   console.log(`Replaced ${path.relative(process.cwd(), target)}`);
 }
 
-async function fileExists(filePath) {
-  try {
-    await fs.access(filePath);
-    return true;
-  } catch (error) {
-    if (error.code === 'ENOENT') {
-      return false;
-    }
-
-    throw error;
-  }
-}
-
 async function collectTemplateFiles(rootDir) {
   const files = [];
 
@@ -147,14 +145,136 @@ function normalizeRelativePath(relativePath) {
   return relativePath.split(path.sep).join('/');
 }
 
-async function resolveAppDirectory(targetRoot) {
-  const srcAppDir = path.join(targetRoot, 'src', 'app');
+async function ensureTwAnimateCssInstalled(targetRoot) {
+  const packageJsonPath = path.join(targetRoot, 'package.json');
+  let packageJson;
+
+  try {
+    const packageJsonContent = await fs.readFile(packageJsonPath, 'utf8');
+    packageJson = JSON.parse(packageJsonContent);
+  } catch (error) {
+    console.warn(
+      `\nUnable to read or parse ${path.relative(process.cwd(), packageJsonPath)}. ` +
+        `Install ${TW_ANIMATE_PACKAGE}@${TW_ANIMATE_VERSION} manually.`
+    );
+    return false;
+  }
+
+  const hasDependency = Boolean(
+    (packageJson.dependencies && packageJson.dependencies[TW_ANIMATE_PACKAGE]) ||
+      (packageJson.devDependencies && packageJson.devDependencies[TW_ANIMATE_PACKAGE])
+  );
+
+  if (hasDependency) {
+    return false;
+  }
+
+  const packageManager = await detectPackageManager(packageJson, targetRoot);
+
+  if (!packageManager) {
+    console.warn(
+      `\nCould not determine package manager for ${path.relative(process.cwd(), targetRoot)}. ` +
+        `Install ${TW_ANIMATE_PACKAGE}@${TW_ANIMATE_VERSION} manually.`
+    );
+    return false;
+  }
+
+  console.log(
+    `\nInstalling ${TW_ANIMATE_PACKAGE}@${TW_ANIMATE_VERSION} using ${packageManager}...`
+  );
+  await installDependency(packageManager, targetRoot, `${TW_ANIMATE_PACKAGE}@${TW_ANIMATE_VERSION}`);
+
+  return true;
+}
+
+async function detectPackageManager(packageJson, targetRoot) {
+  if (packageJson.packageManager && typeof packageJson.packageManager === 'string') {
+    const [name] = packageJson.packageManager.split('@');
+
+    if (name) {
+      return name;
+    }
+  }
+
+  const candidates = [
+    { name: 'pnpm', lockFile: 'pnpm-lock.yaml' },
+    { name: 'yarn', lockFile: 'yarn.lock' },
+    { name: 'bun', lockFile: 'bun.lockb' },
+    { name: 'npm', lockFile: 'package-lock.json' },
+  ];
+
+  for (const candidate of candidates) {
+    const lockFilePath = path.join(targetRoot, candidate.lockFile);
+
+    if (await pathExists(lockFilePath)) {
+      return candidate.name;
+    }
+  }
+
+  return null;
+}
+
+async function installDependency(packageManager, cwd, dependencySpec) {
+  const { command, args } = getInstallCommand(packageManager, dependencySpec);
 
-  if (await fileExists(srcAppDir)) {
-    return srcAppDir;
+  if (!command) {
+    throw new Error(`Unsupported package manager: ${packageManager}`);
   }
 
-  return path.join(targetRoot, 'app');
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { stdio: 'inherit', cwd });
+
+    child.on('error', reject);
+    child.on('close', (code) => {
+      if (code !== 0) {
+        const error = new Error(
+          `${packageManager} exited with code ${code} while installing ${dependencySpec}`
+        );
+        error.exitCode = code;
+        return reject(error);
+      }
+
+      resolve();
+    });
+  });
+}
+
+function getInstallCommand(packageManager, dependencySpec) {
+  const normalized = normalizeCommand(packageManager);
+
+  switch (packageManager) {
+    case 'npm':
+      return { command: normalized, args: ['install', dependencySpec] };
+    case 'pnpm':
+      return { command: normalized, args: ['add', dependencySpec] };
+    case 'yarn':
+      return { command: normalized, args: ['add', dependencySpec] };
+    case 'bun':
+      return { command: normalized, args: ['add', dependencySpec] };
+    default:
+      return { command: null, args: [] };
+  }
+}
+
+function normalizeCommand(command) {
+  if (process.platform === 'win32' && command !== 'bun') {
+    return `${command}.cmd`;
+  }
+
+  return command;
+}
+
+async function pathExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch (error) {
+    if (error && error.code === 'ENOENT') {
+      return false;
+    }
+
+    throw error;
+  }
 }
 
 main().catch((error) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cognite-create",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Create a Next.js app preconfigured with Cognite defaults.",
   "private": false,
   "bin": {

package/templates/.cursor/rules/general.mdc

@@ -4,4 +4,4 @@ globs:
 alwaysApply: true
 ---
 
-Where possible check the Cognite ShadCN registry for components before making your own.
+Use the ShadCN MCP server to check the Cognite registry for components you could use before making your own. If there are Cognite components available for what you are trying to do you must always use them over alternatives. We want to make sure our app aligns with the Cognite design system.