@ciderjs/gasbombe 0.1.0 → 0.2.1

package/src/index.ts

@@ -1,6 +1,7 @@
 import { spawn } from 'node:child_process';
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { select } from '@inquirer/prompts';
 import { consola } from 'consola';
 import ejs from 'ejs';
 import { glob } from 'glob';
@@ -10,30 +11,201 @@ export async function runCommand(
   command: string,
   args: string[],
   cwd: string,
-): Promise<void> {
+  capture = false,
+): Promise<string> {
   return new Promise((resolve, reject) => {
     const child = spawn(command, args, {
       cwd,
-      stdio: 'inherit',
+      stdio: capture ? 'pipe' : 'inherit',
       shell: true,
     });
+
+    let stdout = '';
+    let stderr = '';
+
+    if (capture) {
+      child.stdout?.on('data', (data) => {
+        stdout += data.toString();
+      });
+      child.stderr?.on('data', (data) => {
+        stderr += data.toString();
+      });
+    }
+
     child.on('close', (code) => {
       if (code === 0) {
-        resolve();
+        resolve(stdout.trim());
       } else {
-        reject(new Error(`Command failed with exit code ${code}`));
+        const errorMsg = `Command failed with exit code ${code}${stderr ? `:\n${stderr}` : ''}`;
+        reject(new Error(errorMsg));
       }
     });
+
     child.on('error', (err) => {
       reject(err);
     });
   });
 }
 
+async function handleClaspSetup(
+  claspOption: ProjectOptions['clasp'],
+  projectName: string,
+  outputDir: string,
+  claspProjectId: string | undefined,
+  packageManager: ProjectOptions['packageManager'] = 'npm',
+): Promise<void> {
+  if (claspOption === 'skip') {
+    return;
+  }
+
+  const npxLikeCommand =
+    packageManager === 'npm'
+      ? 'npx'
+      : packageManager === 'pnpm'
+        ? 'pnpx'
+        : 'yarn';
+
+  consola.start(
+    `Setting up .clasp.json with \`${npxLikeCommand} @google/clasp\`...`,
+  );
+
+  if (claspOption === 'create' || claspOption === 'list') {
+    try {
+      await runCommand(npxLikeCommand, ['@google/clasp', 'status'], outputDir);
+    } catch {
+      consola.error(
+        `It seems you are not logged in to clasp. Please run \`${npxLikeCommand} @google/clasp login\` and try again.`,
+      );
+      return;
+    }
+  }
+
+  let scriptId: string | undefined;
+  let existingClaspJson: { scriptId: string; [key: string]: string | string[] } | null = null;
+
+  switch (claspOption) {
+    case 'create':
+      try {
+        const claspJsonPath = path.join(outputDir, '.clasp.json');
+        try {
+          const existingContent = await fs.readFile(claspJsonPath, 'utf-8');
+          existingClaspJson = JSON.parse(existingContent);
+          await fs.unlink(claspJsonPath);
+        } catch {
+          // No existing .clasp.json, which is fine.
+        }
+
+        const result = await runCommand(
+          npxLikeCommand,
+          [
+            '@google/clasp',
+            'create',
+            '--title',
+            `"${projectName}"`,
+            '--type',
+            'standalone',
+          ],
+          outputDir,
+          true,
+        );
+        const match = result.match(/Created new script: .+\/d\/(.+)\/edit/);
+        if (match?.[1]) {
+          scriptId = match[1];
+          consola.info(`Created new Apps Script project with ID: ${scriptId}`);
+        } else {
+          throw new Error('Could not parse scriptId from clasp output.');
+        }
+      } catch (e) {
+        consola.error('Failed to create new Apps Script project.', e);
+        return;
+      }
+      break;
+
+    case 'list':
+      try {
+        const listOutput = await runCommand(
+          npxLikeCommand,
+          ['@google/clasp', 'list'],
+          outputDir,
+          true,
+        );
+        const projects = listOutput
+          .split('\n')
+          .slice(1) // Skip header
+          .map((line) => {
+            const parts = line.split(' - ');
+            if (parts.length >= 2) {
+              const name = parts[0]?.trim();
+              const url = parts[1]?.trim();
+              if (!name || !url) return null;
+
+              const match = url.match(/\/d\/(.+)\/edit/);
+              const scriptId = match?.[1];
+
+              if (scriptId) {
+                return { name, value: scriptId };
+              }
+            }
+            return null;
+          })
+          .filter((p): p is { name: string; value: string } => p !== null);
+
+        if (projects.length === 0) {
+          consola.warn(
+            'No existing Apps Script projects found. Please create one first.',
+          );
+          return;
+        }
+
+        scriptId = await select({
+          message: 'Choose an existing Apps Script project:',
+          choices: projects,
+        });
+      } catch (e) {
+        consola.error('Failed to list Apps Script projects.', e);
+        return;
+      }
+      break;
+
+    case 'input':
+      scriptId = claspProjectId;
+      break;
+  }
+
+  if (scriptId) {
+    const claspJsonPath = path.join(outputDir, '.clasp.json');
+    let claspJson: { scriptId: string; [key: string]: string | string[] } = {
+      scriptId,
+    };
+    let successMessage = `.clasp.json created successfully with scriptId: ${scriptId}`;
+
+    if (existingClaspJson) {
+      claspJson = { ...existingClaspJson, scriptId };
+      successMessage = `.clasp.json updated successfully with scriptId: ${scriptId}`;
+    } else {
+      try {
+        const existingContent = await fs.readFile(claspJsonPath, 'utf-8');
+        const currentClaspJson = JSON.parse(existingContent);
+        claspJson = { ...currentClaspJson, scriptId };
+        successMessage = `.clasp.json updated successfully with scriptId: ${scriptId}`;
+      } catch {
+        // If file doesn't exist or is invalid, we'll just create a new one.
+      }
+    }
+
+    const claspJsonContent = JSON.stringify(claspJson, null, 2);
+    await fs.writeFile(claspJsonPath, claspJsonContent, { encoding: 'utf-8' });
+    consola.success(successMessage);
+  }
+}
+
 export async function generateProject({
   projectName,
   packageManager,
   templateType,
+  clasp,
+  claspProjectId,
+  install,
 }: ProjectOptions): Promise<void> {
   const outputDir = path.resolve(process.cwd(), projectName);
   const templateBaseDir = path.resolve(__dirname, '..', 'dist', 'templates');
@@ -44,12 +216,32 @@ export async function generateProject({
     `Creating a new Project for GoogleAppsScript in ${outputDir}...`,
   );
 
-  try {
-    await fs.access(outputDir);
-    consola.error(`Directory ${projectName} already exists.`);
-    process.exit(1);
-  } catch {
-    // Directory dose not exits, which is what we want.
+  if (projectName === '.') {
+    try {
+      const files = await fs.readdir(outputDir);
+      const relevantFiles = files.filter((file) => !file.startsWith('.'));
+
+      if (relevantFiles.length > 0) {
+        const proceed = await confirm(
+          'Current directory is not empty. Proceed anyway?',
+        );
+
+        if (!proceed) {
+          consola.warn('Operation cancelled.');
+          process.exit(0);
+        }
+      }
+    } catch {
+      // Directory does not exist, then mkdir will create it.
+    }
+  } else {
+    try {
+      await fs.access(outputDir);
+      consola.error(`Directory ${projectName} already exists.`);
+      process.exit(1);
+    } catch {
+      // Directory does not exist, which is what we want.
+    }
   }
 
   await fs.mkdir(outputDir, { recursive: true });
@@ -62,14 +254,12 @@ export async function generateProject({
       cwd: dir,
       nodir: true,
       dot: true,
-      dotRelative: true,
-      follow: true,
-      windowsPathsNoEscape: true,
     });
 
     for (const file of files) {
-      const templatePath = path.join(dir, file);
-      const outputPath = path.join(outputDir, file.replace('.ejs', ''));
+      const relativePath = path.relative(dir, path.resolve(dir, file));
+      const templatePath = path.join(dir, relativePath);
+      const outputPath = path.join(outputDir, relativePath.replace('.ejs', ''));
 
       await fs.mkdir(path.dirname(outputPath), { recursive: true });
 
@@ -77,18 +267,27 @@ export async function generateProject({
         encoding: 'utf-8',
       });
       const renderedContent = ejs.render(templateContent, ejsData);
-      await fs.writeFile(outputPath, renderedContent);
+      await fs.writeFile(outputPath, renderedContent, { encoding: 'utf-8' });
     }
   }
 
-  consola.start(`Installing dependencies with ${packageManager}...`);
-  try {
-    await runCommand(packageManager, ['install'], outputDir);
-    consola.success(`Dependencies installed successfully.`);
-  } catch (e) {
-    consola.fail('Failed to install dependencies.');
-    consola.error(e);
-    process.exit(1);
+  await handleClaspSetup(
+    clasp,
+    projectName,
+    outputDir,
+    claspProjectId,
+    packageManager,
+  );
+
+  if (install) {
+    consola.start(`Installing dependencies with ${packageManager}...`);
+    try {
+      await runCommand(packageManager, ['install'], outputDir);
+      consola.success(`Dependencies installed successfully.`);
+    } catch (e) {
+      consola.fail('Failed to install dependencies. Please do it manually.');
+      consola.error(e);
+    }
   }
 
   consola.start(`Initializing Git repository...`);
@@ -101,14 +300,26 @@ export async function generateProject({
       outputDir,
     );
     consola.success(`Git repository initialized successfully.`);
-  } catch {
+  } catch (e) {
     consola.fail('Failed to initialize Git repository. Please do it manually.');
+    consola.error(e);
   }
 
   consola.success(`Project '${projectName}' created successfully!`);
-  consola.log(`\nTo get started, run:\n`);
-  projectName !== '.' && consola.log(`  cd ${projectName}`);
-  templateType !== 'vanilla-ts'
-    ? consola.log(`  ${packageManager} dev`)
-    : consola.log(`  ...and write your GAS code!`);
+
+  const messages: string[] = [];
+  projectName !== '.' && messages.push(`  cd ${projectName}`);
+  !install && messages.push(`  ${packageManager} install`);
+  templateType !== 'vanilla-ts' && messages.push(`  ${packageManager} dev`);
+
+  if (messages.length > 0) {
+    consola.log(`\nTo get started, run:\n`);
+    for (const message of messages) {
+      consola.log(message);
+    }
+    consola.log('');
+    consola.log(`...and write your GAS code!`);
+  } else {
+    consola.log(`\nTo get started, write your GAS code in \`src/\`!`);
+  }
 }