bunosh 0.2.3 → 0.3.1

package/src/tasks/ai.js

@@ -0,0 +1,143 @@
+import { TaskResult, createTaskInfo, finishTaskInfo } from '../task.js';
+import Printer from '../printer.js';
+import { generateObject, generateText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+import { anthropic } from '@ai-sdk/anthropic';
+import { createGroq } from '@ai-sdk/groq';
+import { z } from 'zod';
+
+let customConfiguration = null;
+
+const PROVIDER_REGISTRY = {
+  OPENAI_API_KEY: (modelName) => openai(modelName),
+  ANTHROPIC_API_KEY: (modelName) => anthropic(modelName),
+  GROQ_API_KEY: (modelName) => createGroq({ apiKey: process.env.GROQ_API_KEY })(modelName),
+  GROQ_KEY: (modelName) => createGroq({ apiKey: process.env.GROQ_KEY })(modelName)
+};
+
+const customProviders = new Map();
+
+function detectProvider() {
+  if (customConfiguration) {
+    return customConfiguration.model;
+  }
+
+  if (!process.env.AI_MODEL) {
+    throw new Error('AI_MODEL environment variable is required. Set it to specify which model to use (e.g., AI_MODEL=gpt-4o, AI_MODEL=claude-3-5-sonnet-20241022, AI_MODEL=llama-3.3-70b-versatile).');
+  }
+
+  for (const [envVar, provider] of customProviders) {
+    if (process.env[envVar]) {
+      return provider.createInstance(process.env.AI_MODEL);
+    }
+  }
+
+  for (const [envVar, createInstance] of Object.entries(PROVIDER_REGISTRY)) {
+    if (process.env[envVar]) {
+      return createInstance(process.env.AI_MODEL);
+    }
+  }
+
+  const availableProviders = [
+    ...Object.keys(PROVIDER_REGISTRY),
+    ...Array.from(customProviders.keys())
+  ];
+
+  throw new Error(`No AI provider configured. Set one of these environment variables: ${availableProviders.join(', ')}. Or use ai.configure() for custom setup.`);
+}
+
+function configure(config) {
+  if (!config || typeof config !== 'object') {
+    throw new Error('ai.configure() requires a configuration object');
+  }
+
+  if (config.model && typeof config.model === 'object') {
+    customConfiguration = { model: config.model };
+    return;
+  }
+
+  if (config.registerProvider) {
+    const { envVar, provider } = config.registerProvider;
+    if (!envVar || !provider) {
+      throw new Error('registerProvider requires { envVar: "ENV_VAR_NAME", provider: { createInstance: (model) => providerInstance } }');
+    }
+    customProviders.set(envVar, provider);
+    return;
+  }
+
+  throw new Error('Invalid configuration. Use ai.configure({ model: providerInstance }) or ai.configure({ registerProvider: { envVar: "CUSTOM_API_KEY", provider: { createInstance: (model) => customProvider(model) } } })');
+}
+
+function createSchema(outputFormat) {
+  const schemaObject = {};
+  for (const [key, description] of Object.entries(outputFormat)) {
+    schemaObject[key] = z.string().describe(description);
+  }
+
+  return z.object(schemaObject);
+}
+
+function createProgressIndicator() {
+  const dots = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  let index = 0;
+  
+  return setInterval(() => {
+    const spinner = dots[index % dots.length];
+    process.stdout.write(`\r${spinner} Generating...`);
+    index++;
+  }, 100);
+}
+
+async function ai(prompt, outputFormat = null) {
+  const cleanPrompt = prompt.replace(/\s+/g, ' ').trim();
+  const taskName = `AI: ${cleanPrompt.substring(0, 50)}${cleanPrompt.length > 50 ? '...' : ''}`;
+  
+  const taskInfo = createTaskInfo(taskName);
+  const printer = new Printer('ai', taskInfo.id);
+  printer.start(taskName);
+
+  // Start progress indicator
+  const progressInterval = createProgressIndicator();
+
+  try {
+    const model = detectProvider();
+    let result, usage;
+    
+    if (outputFormat) {
+      const schema = createSchema(outputFormat);
+      const response = await generateObject({ model, prompt, schema });
+      result = response.object;
+      usage = response.usage;
+    } else {
+      const response = await generateText({ model, prompt });
+      result = response.text;
+      usage = response.usage;
+    }
+    
+    clearInterval(progressInterval);
+    process.stdout.write('\r' + ' '.repeat(20) + '\r');
+    const tokenInfo = usage ? `${usage.totalTokens} tokens` : '';
+    printer.finish(taskName, { tokenInfo });
+    finishTaskInfo(taskInfo, true, null, outputFormat ? JSON.stringify(result, null, 2) : result);
+    return TaskResult.success(result);
+    
+  } catch (error) {
+    clearInterval(progressInterval);
+    process.stdout.write('\r' + ' '.repeat(20) + '\r');
+    printer.error(taskName, error);
+    finishTaskInfo(taskInfo, false, error, error.message);
+    return TaskResult.fail(error.message);
+  }
+}
+
+ai.configure = configure;
+
+ai.reset = function() {
+  customConfiguration = null;
+};
+
+ai.getConfig = function() {
+  return customConfiguration;
+};
+
+export default ai;

package/src/tasks/shell.js

@@ -0,0 +1,119 @@
+import { TaskResult, createTaskInfo, finishTaskInfo } from "../task.js";
+import Printer from "../printer.js";
+
+const isBun = typeof Bun !== 'undefined' && typeof Bun.spawn === 'function';
+
+export default function shell(strings, ...values) {
+  const cmd = strings.reduce((accumulator, str, i) => {
+    return accumulator + str + (values[i] || "");
+  }, "");
+
+  let envs = null;
+  let cwd = null;
+
+  const cmdPromise = new Promise(async (resolve, reject) => {
+    const extraInfo = {};
+    if (cwd) extraInfo.cwd = cwd;
+    if (envs) extraInfo.env = envs;
+
+    if (!isBun) {
+      const { default: exec } = await import("./exec.js");
+      let execPromise = exec(strings, ...values);
+      if (envs) execPromise = execPromise.env(envs);
+      if (cwd) execPromise = execPromise.cwd(cwd);
+      const result = await execPromise;
+      resolve(result);
+      return;
+    }
+
+    const taskInfo = createTaskInfo(cmd);
+    const printer = new Printer("shell", taskInfo.id);
+    printer.start(cmd, extraInfo);
+
+    try {
+      const { $ } = await import("bun");
+      
+      let shell = $;
+      
+      if (cwd) {
+        shell = shell.cwd(cwd);
+      }
+      
+      if (envs) {
+        shell = shell.env(envs);
+      }
+
+      let result;
+      try {
+        result = await shell(strings, ...values);
+        
+        const output = await result.text();
+        
+        printer.finish(cmd);
+        finishTaskInfo(taskInfo, true, null, output.trim());
+        resolve(TaskResult.success(output.trim()));
+        return;
+        
+      } catch (shellError) {
+        const isCommandNotFound = shellError.stderr && 
+          (shellError.stderr.includes('command not found') || 
+           shellError.stderr.includes('bun: command not found'));
+        
+        if (isCommandNotFound) {
+          printer.finish(cmd);
+          finishTaskInfo(taskInfo, true, null, "fallback to exec");
+          
+          const { default: exec } = await import("./exec.js");
+          let execPromise = exec`${cmd}`;
+          if (envs) execPromise = execPromise.env(envs);
+          if (cwd) execPromise = execPromise.cwd(cwd);
+          const result = await execPromise;
+          resolve(result);
+          return;
+        }
+        
+        if (shellError.exitCode !== undefined) {
+          const stderr = shellError.stderr ? Buffer.isBuffer(shellError.stderr) ? shellError.stderr.toString() : shellError.stderr : "";
+          const stdout = shellError.stdout ? Buffer.isBuffer(shellError.stdout) ? shellError.stdout.toString() : shellError.stdout : "";
+          const errorOutput = (stderr + stdout).trim() || `Command failed with exit code ${shellError.exitCode}`;
+          
+          if (errorOutput) {
+            const lines = errorOutput.split('\n');
+            for (const line of lines) {
+              if (line.trim()) {
+                printer.output(line, true);
+              }
+            }
+          }
+          
+          const error = new Error(`Exit code: ${shellError.exitCode}`);
+          printer.error(cmd, null, { exitCode: shellError.exitCode });
+          finishTaskInfo(taskInfo, false, error, errorOutput);
+          resolve(TaskResult.fail(errorOutput));
+          return;
+        } else {
+          const errorMessage = shellError.message || shellError.toString();
+          printer.error(cmd, shellError);
+          finishTaskInfo(taskInfo, false, shellError, errorMessage);
+          resolve(TaskResult.fail(errorMessage));
+        }
+      }
+    } catch (error) {
+      printer.error(cmd, error);
+      finishTaskInfo(taskInfo, false, error, error.message);
+      resolve(TaskResult.fail(error.message));
+    }
+  });
+
+  cmdPromise.env = (newEnvs) => {
+    envs = newEnvs;
+    return cmdPromise;
+  };
+
+  cmdPromise.cwd = (newCwd) => {
+    cwd = newCwd;
+    return cmdPromise;
+  };
+
+  return cmdPromise;
+}