vibe-weaver 1.0.0

package/src/tools/shell.ts

@@ -0,0 +1,248 @@
+/**
+ * Shell execution tool for Vibe-Weaver CLI
+ * Runs real shell commands and streams output
+ */
+
+import { execa, execaCommand } from 'execa';
+import chalk from 'chalk';
+import ora from 'ora';
+
+export interface CommandResult {
+  success: boolean;
+  command: string;
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+  timedOut?: boolean;
+  duration?: number;
+}
+
+/**
+ * Run a shell command and capture output
+ */
+export async function runShell(
+  command: string,
+  options: {
+    cwd?: string;
+    env?: Record<string, string>;
+    timeout?: number;
+    shell?: boolean;
+    dryRun?: boolean;
+  } = {}
+): Promise<CommandResult> {
+  const startTime = Date.now();
+  
+  if (options.dryRun) {
+    console.log(chalk.grey(`[DRY-RUN] Would execute: ${command}`));
+    return {
+      success: true,
+      command,
+      exitCode: 0,
+      stdout: '',
+      stderr: '',
+      duration: 0
+    };
+  }
+  
+  try {
+    const result = await execaCommand(command, {
+      cwd: options.cwd || process.cwd(),
+      env: { ...process.env, ...options.env },
+      timeout: options.timeout || 120000, // 2 minute default timeout
+      shell: options.shell || true,
+      reject: false,
+      cleanup: true
+    });
+    
+    const duration = Date.now() - startTime;
+    
+    return {
+      success: result.exitCode === 0,
+      command,
+      exitCode: result.exitCode || 0,
+      stdout: result.stdout || '',
+      stderr: result.stderr || '',
+      duration
+    };
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    
+    return {
+      success: false,
+      command,
+      exitCode: 1,
+      stdout: '',
+      stderr: error instanceof Error ? error.message : String(error),
+      timedOut: error instanceof Error && error.message.includes('timeout'),
+      duration
+    };
+  }
+}
+
+/**
+ * Run a shell command with streaming output (live display)
+ */
+export async function runShellStream(
+  command: string,
+  options: {
+    cwd?: string;
+    env?: Record<string, string>;
+    timeout?: number;
+    onStdout?: (data: string) => void;
+    onStderr?: (data: string) => void;
+  } = {}
+): Promise<CommandResult> {
+  const startTime = Date.now();
+  
+  try {
+    const childProcess = execa(command, {
+      cwd: options.cwd || process.cwd(),
+      env: { ...process.env, ...options.env },
+      shell: true,
+      cleanup: true
+    });
+    
+    let stdout = '';
+    let stderr = '';
+    
+    childProcess.stdout?.on('data', (data: Buffer) => {
+      const text = data.toString();
+      stdout += text;
+      if (options.onStdout) {
+        options.onStdout(text);
+      } else {
+        process.stdout.write(text);
+      }
+    });
+    
+    childProcess.stderr?.on('data', (data: Buffer) => {
+      const text = data.toString();
+      stderr += text;
+      if (options.onStderr) {
+        options.onStderr(text);
+      } else {
+        process.stderr.write(text);
+      }
+    });
+    
+    const result = await childProcess;
+    const duration = Date.now() - startTime;
+    
+    return {
+      success: result.exitCode === 0,
+      command,
+      exitCode: result.exitCode || 0,
+      stdout,
+      stderr,
+      duration
+    };
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    
+    return {
+      success: false,
+      command,
+      exitCode: 1,
+      stdout: '',
+      stderr: error instanceof Error ? error.message : String(error),
+      duration
+    };
+  }
+}
+
+/**
+ * Run a command with a spinner
+ */
+export async function runWithSpinner(
+  command: string,
+  options: {
+    cwd?: string;
+    env?: Record<string, string>;
+    timeout?: number;
+    message?: string;
+  } = {}
+): Promise<CommandResult> {
+  const spinner = ora(options.message || 'Running command...').start();
+  
+  try {
+    const result = await runShell(command, options);
+    
+    if (result.success) {
+      spinner.succeed(chalk.green('Command completed successfully'));
+    } else {
+      spinner.fail(chalk.red(`Command failed with exit code ${result.exitCode}`));
+    }
+    
+    return result;
+  } catch (error) {
+    spinner.fail(chalk.red('Command failed'));
+    throw error;
+  }
+}
+
+/**
+ * Common build commands
+ */
+export const buildCommands = {
+  npmInstall: 'npm install',
+  npmBuild: 'npm run build',
+  npmTest: 'npm test',
+  npmLint: 'npm run lint',
+  npmTypecheck: 'npm run typecheck' || 'npx tsc --noEmit',
+  pnpmInstall: 'pnpm install',
+  pnpmBuild: 'pnpm run build',
+  bunInstall: 'bun install',
+  bunBuild: 'bun run build',
+  yarnInstall: 'yarn install',
+  yarnBuild: 'yarn run build'
+};
+
+/**
+ * Detect package manager from lock files
+ */
+export function detectPackageManager(cwd: string = process.cwd()): 'npm' | 'pnpm' | 'yarn' | 'bun' {
+  const fs = require('fs');
+  
+  if (fs.existsSync(`${cwd}/pnpm-lock.yaml`)) return 'pnpm';
+  if (fs.existsSync(`${cwd}/yarn.lock`)) return 'yarn';
+  if (fs.existsSync(`${cwd}/bun.lockb`)) return 'bun';
+  return 'npm';
+}
+
+/**
+ * Get the appropriate install command
+ */
+export function getInstallCommand(cwd: string = process.cwd()): string {
+  const pm = detectPackageManager(cwd);
+  
+  switch (pm) {
+    case 'pnpm': return buildCommands.pnpmInstall;
+    case 'yarn': return buildCommands.yarnInstall;
+    case 'bun': return buildCommands.bunInstall;
+    default: return buildCommands.npmInstall;
+  }
+}
+
+/**
+ * Get the appropriate build command
+ */
+export function getBuildCommand(cwd: string = process.cwd()): string {
+  const pm = detectPackageManager(cwd);
+  
+  switch (pm) {
+    case 'pnpm': return buildCommands.pnpmBuild;
+    case 'yarn': return buildCommands.yarnBuild;
+    case 'bun': return buildCommands.bunBuild;
+    default: return buildCommands.npmBuild;
+  }
+}
+
+export default {
+  runShell,
+  runShellStream,
+  runWithSpinner,
+  buildCommands,
+  detectPackageManager,
+  getInstallCommand,
+  getBuildCommand
+};

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/tsup.config.ts

@@ -0,0 +1,34 @@
+import { defineConfig } from 'tsup';
+import { copyFileSync, mkdirSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm'],
+  platform: 'node',
+  target: 'node18',
+  outDir: 'dist',
+  splitting: false,
+  sourcemap: true,
+  dts: true,
+  clean: true,
+  treeshake: true,
+  minify: false,
+  shims: false,
+  noExternal: [],
+  onSuccess: () => {
+    // Ensure bin directory exists in dist
+    const distBinDir = join(__dirname, 'dist', 'bin');
+    if (!existsSync(distBinDir)) {
+      mkdirSync(distBinDir, { recursive: true });
+    }
+    // Copy the bin file
+    copyFileSync(
+      join(__dirname, 'bin', 'vibe-weaver.js'),
+      join(distBinDir, 'vibe-weaver.js')
+    );
+  }
+});