bunosh 0.2.2 → 0.3.0

package/README.md

@@ -377,6 +377,9 @@ const { exec, fetch, writeToFile, copyFile, say, ask, yell, task } = global.buno
 ```
 
 ### Shell Execution (`exec`)
+
+The `exec` function runs shell commands and returns a `TaskResult` object with the command output and status.
+
 ```javascript
 // Simple commands
 await exec`echo "Hello World"`;
@@ -392,6 +395,63 @@ await exec`ls -la`.cwd('/tmp');
 await exec`find . -name "*.js" | grep -v node_modules | wc -l`;
 ```
 
+#### TaskResult Object
+
+The `exec` function returns a `TaskResult` object with the following properties and methods:
+
+```javascript
+const result = await exec`ls -la`;
+
+// Properties
+result.status   // 'success' or 'fail' 
+result.output   // Combined stdout/stderr as string
+
+// Getters (boolean)
+result.hasFailed     // true if command failed (non-zero exit code)
+result.hasSucceeded  // true if command succeeded (exit code 0)
+```
+
+#### Error Handling Examples
+
+```javascript
+// Check command success
+const result = await exec`npm test`;
+if (result.hasSucceeded) {
+  say('✅ Tests passed!');
+} else {
+  yell('❌ Tests failed!');
+  console.log(result.output); // Show error details
+}
+
+// Get command output
+const result = await exec`git rev-parse HEAD`;
+if (result.hasSucceeded) {
+  const commitHash = result.output.trim();
+  say(`Current commit: ${commitHash}`);
+}
+
+// Handle failures gracefully
+const result = await exec`optional-command-that-might-fail`;
+if (result.hasFailed) {
+  say('Command failed, but continuing...');
+  console.log('Error output:', result.output);
+}
+
+// Old vs New style comparison
+// ❌ Old: Commands throw on failure
+try {
+  await someOtherTaskRunner('failing-command');
+} catch (error) {
+  // Handle error
+}
+
+// ✅ New: Explicit success/failure handling
+const result = await exec`failing-command`;
+if (result.hasFailed) {
+  // Handle failure explicitly
+}
+```
+
 ### HTTP Requests (`fetch`)
 ```javascript
 // GET request with progress indicator
@@ -428,6 +488,275 @@ await task('Installing dependencies', async () => {
 });
 ```
 
+## 🤖 AI-Powered Tasks
+
+Bunosh now supports AI integration with structured outputs! Connect to popular AI providers and generate content, analyze data, or automate text processing with simple function calls.
+
+### Quick Setup
+
+Set your AI provider credentials:
+```bash
+# Required: Choose your model
+export AI_MODEL=gpt-4o                         # or claude-3-5-sonnet-20241022, llama-3.3-70b-versatile, etc.
+
+# Required: Set API key for your chosen provider
+export OPENAI_API_KEY=your_key_here           # for OpenAI models
+# export ANTHROPIC_API_KEY=your_key_here       # for Claude models
+# export GROQ_API_KEY=your_key_here            # for Groq models
+```
+
+### Built-in AI Providers
+
+- **OpenAI** - GPT-4o, GPT-4o-mini, GPT-3.5-turbo (via `OPENAI_API_KEY`)
+- **Anthropic** - Claude 3.5 Sonnet, Claude 3 Haiku (via `ANTHROPIC_API_KEY`)
+- **Groq** - Llama 3.3, Mixtral, Gemma models (via `GROQ_API_KEY` or `GROQ_KEY`)
+
+### Custom AI Providers
+
+For enterprise and custom setups, you can import and register any AI provider manually:
+
+```javascript
+const { ai } = global.bunosh;
+
+// Method 1: Direct model configuration (most flexible)
+import { bedrock } from '@ai-sdk/amazon-bedrock';
+const bedrockModel = bedrock('anthropic.claude-3-sonnet-20240229-v1:0', {
+  region: 'us-east-1',
+  credentials: {
+    accessKeyId: 'your-access-key',
+    secretAccessKey: 'your-secret-key'
+  }
+});
+
+ai.configure({ model: bedrockModel });
+
+// Method 2: Register custom provider with environment variable
+import { xai } from '@ai-sdk/xai';
+ai.configure({
+  registerProvider: {
+    envVar: 'XAI_API_KEY',
+    provider: {
+      createInstance: (modelName) => xai(modelName)
+    }
+  }
+});
+
+// Method 3: Register any custom provider (Azure OpenAI, OpenRouter, etc.)
+import { openrouter } from '@openrouter/ai-sdk-provider';
+ai.configure({
+  registerProvider: {
+    envVar: 'OPENROUTER_API_KEY', 
+    provider: {
+      createInstance: (modelName) => openrouter(modelName)
+    }
+  }
+});
+
+// Method 4: Register completely custom provider
+ai.configure({
+  registerProvider: {
+    envVar: 'CUSTOM_AI_API_KEY',
+    provider: {
+      createInstance: (modelName) => {
+        // Your custom provider logic
+        return customAIProvider(modelName, {
+          apiKey: process.env.CUSTOM_AI_API_KEY,
+          endpoint: 'https://custom-ai.company.com/v1'
+        });
+      }
+    }
+  }
+});
+
+// Reset to environment variable configuration
+ai.reset();
+
+// Check current configuration
+const config = ai.getConfig();
+console.log('Current AI config:', config);
+```
+
+### AI Task Examples
+
+```javascript
+const { ai, writeToFile, say } = global.bunosh;
+
+/**
+ * Generate project documentation with AI
+ */
+export async function generateDocs() {
+  const codebase = fs.readFileSync('src/index.js', 'utf8');
+  
+  const result = await ai(
+    `Generate documentation for this code: ${codebase}`,
+    {
+      overview: 'Brief project overview',
+      apiReference: 'API documentation',
+      examples: 'Usage examples',
+      installation: 'Installation instructions'
+    }
+  );
+  
+  writeToFile('README.md', (line) => {
+    line`# ${result.overview}`;
+    line``;
+    line`## Installation`;
+    line`${result.installation}`;
+    line``;
+    line`## API Reference`;
+    line`${result.apiReference}`;
+    line``;
+    line`## Examples`;
+    line`${result.examples}`;
+  });
+  
+  say('📚 Documentation generated!');
+}
+
+/**
+ * Analyze and optimize code with AI suggestions
+ */
+export async function codeReview(filename) {
+  const code = fs.readFileSync(filename, 'utf8');
+  
+  const analysis = await ai(
+    `Review this code for improvements: ${code}`,
+    {
+      issues: 'List of potential issues',
+      suggestions: 'Specific improvement suggestions',  
+      security: 'Security considerations',
+      performance: 'Performance optimization tips',
+      rating: 'Overall code quality rating (1-10)'
+    }
+  );
+  
+  say(`🔍 Code Review for ${filename}:`);
+  console.log(`Rating: ${analysis.rating}/10`);
+  console.log(`Issues: ${analysis.issues}`);
+  console.log(`Suggestions: ${analysis.suggestions}`);
+  console.log(`Security: ${analysis.security}`);
+  console.log(`Performance: ${analysis.performance}`);
+}
+
+/**
+ * Generate test cases from code
+ */
+export async function generateTests(sourceFile) {
+  const code = fs.readFileSync(sourceFile, 'utf8');
+  
+  const tests = await ai(
+    `Generate comprehensive unit tests for this code: ${code}`,
+    {
+      testSuite: 'Complete test suite code',
+      edgeCases: 'List of edge cases covered',
+      mockSetup: 'Required mocks and setup code'
+    }
+  );
+  
+  const testFile = sourceFile.replace('.js', '.test.js');
+  writeToFile(testFile, (line) => {
+    line`${tests.mockSetup}`;
+    line``;
+    line`${tests.testSuite}`;
+  });
+  
+  say(`🧪 Tests generated: ${testFile}`);
+  say(`Edge cases: ${tests.edgeCases}`);
+}
+
+/**
+ * Create commit messages from git diff
+ */
+export async function smartCommit() {
+  const diff = await exec`git diff --staged`;
+  
+  if (diff.hasFailed || !diff.output.trim()) {
+    say('No staged changes found');
+    return;
+  }
+  
+  const commit = await ai(
+    `Generate a commit message for these changes: ${diff.output}`,
+    {
+      title: 'Concise commit title (50 chars max)',
+      body: 'Detailed commit body explaining what and why',
+      type: 'Commit type (feat/fix/docs/refactor/test/chore)'
+    }
+  );
+  
+  const message = `${commit.type}: ${commit.title}\n\n${commit.body}`;
+  await exec`git commit -m "${message}"`;
+  
+  say(`✅ Committed with AI-generated message:`);
+  console.log(message);
+}
+
+/**
+ * Enterprise AI setup with custom provider
+ */
+export async function setupEnterpriseAI() {
+  // Import your enterprise AI provider
+  import { bedrock } from '@ai-sdk/amazon-bedrock';
+  
+  // Configure for enterprise use
+  const enterpriseModel = bedrock('anthropic.claude-3-sonnet-20240229-v1:0', {
+    region: 'us-east-1'
+    // Uses AWS credentials from environment/profile
+  });
+  
+  ai.configure({ model: enterpriseModel });
+  
+  const analysis = await ai(
+    'Analyze our company performance from this quarterly report: [data]',
+    {
+      summary: 'Executive summary of performance',
+      risks: 'Identified business risks',
+      opportunities: 'Growth opportunities',
+      recommendations: 'Strategic recommendations'
+    }
+  );
+  
+  say('📊 Enterprise AI analysis complete');
+  console.log(analysis);
+}
+```
+
+### Simple Text Generation
+
+For quick text generation without structured output:
+
+```javascript
+/**
+ * Generate marketing copy
+ */
+export async function generateCopy(product) {
+  const copy = await ai(`Write compelling marketing copy for: ${product}`);
+  say('📝 Generated copy:');
+  console.log(copy);
+}
+
+/**
+ * Translate content
+ */
+export async function translate(text, language = 'Spanish') {
+  const translation = await ai(`Translate to ${language}: ${text}`);
+  say(`🌐 Translation to ${language}:`);
+  console.log(translation);
+}
+```
+
+### Progressive Enhancement
+
+The AI task features:
+- **🎭 Animated Progress**: Braille spinner animation during generation
+- **📊 Token Tracking**: Shows token usage for cost monitoring  
+- **⚡ Fast Inference**: Optimized for speed with Groq and other providers
+- **🔧 Structured Output**: Get JSON responses with defined schemas
+- **🎯 Provider Auto-Detection**: Automatically detects available API keys
+- **💪 Error Handling**: Graceful handling of API errors and rate limits
+
+Transform your development workflow with AI-powered automation! Generate documentation, analyze code, create tests, write commit messages, and much more.
+
 ## Command Features
 
 ### Automatic CLI Generation

package/bunosh.js

@@ -3,6 +3,7 @@ import program, { BUNOSHFILE, banner }  from "./src/program.js";
 import { existsSync, readFileSync, statSync } from "fs";
 import init from "./src/init.js";
 import path from "path";
+import color from "chalk";
 import './index.js';
 
 // Parse --bunoshfile flag before importing tasks
@@ -49,8 +50,93 @@ if (!existsSync(tasksFile)) {
 }
 
 import(tasksFile).then((tasks) => {
-  program(tasks, readFileSync(tasksFile, "utf-8"));
-}).catch((e) => {
-  console.error(`Error loading: ${tasksFile}`);
-  console.error(e);
+  try {
+    const source = readFileSync(tasksFile, "utf-8");
+    program(tasks, source);
+  } catch (error) {
+    handleBunoshfileError(error, tasksFile);
+  }
+}).catch((error) => {
+  handleBunoshfileError(error, tasksFile);
 });
+
+function handleBunoshfileError(error, filePath) {
+  banner();
+  console.log();
+  
+  // Check for Babel parser syntax errors
+  if (error.code === 'BABEL_PARSER_SYNTAX_ERROR' || 
+      (error.reasonCode && error.loc) || 
+      error.constructor.name === 'SyntaxError') {
+    
+    console.error(`❌ Syntax Error in ${path.basename(filePath)}:`);
+    console.log();
+    
+    if (error.loc) {
+      console.error(`   Line ${error.loc.line}, Column ${error.loc.column}:`);
+      
+      // Provide specific error messages based on reasonCode
+      if (error.reasonCode === 'VarRedeclaration') {
+        console.error(`   Variable redeclaration - '${error.message}' is already declared`);
+      } else if (error.reasonCode && error.reasonCode.includes('Unexpected')) {
+        console.error(`   ${error.reasonCode}: ${error.message || 'Unexpected token'}`);
+      } else {
+        console.error(`   ${error.message || error.reasonCode || 'Invalid syntax'}`);
+      }
+    } else {
+      console.error(`   ${error.message || 'Invalid JavaScript syntax'}`);
+    }
+    
+    console.log();
+    console.log('💡 Common issues:');
+    console.log('   • Missing semicolons or commas');
+    console.log('   • Unclosed brackets, parentheses, or quotes'); 
+    console.log('   • Invalid variable declarations');
+    console.log('   • Mixing import/export with require/module.exports');
+    console.log();
+    console.log(`📝 Edit your Bunoshfile: ${color.blue('bunosh edit')}`);
+    console.log(`🔧 Validate syntax: ${color.blue(`bun --check ${path.basename(filePath)}`)}`);
+    
+  } else if (error.message && error.message.includes('SyntaxError')) {
+    console.error(`❌ JavaScript Syntax Error in ${path.basename(filePath)}:`);
+    console.log();
+    console.error(`   ${error.message}`);
+    console.log();
+    console.log(`💡 Try running: ${color.blue('bun --check Bunoshfile.js')}`);
+    console.log(`📝 Edit your Bunoshfile: ${color.blue('bunosh edit')}`);
+    
+  } else if (error.code === 'MODULE_NOT_FOUND' || 
+             error.message?.includes('Cannot resolve') ||
+             error.message?.includes('Could not resolve')) {
+    console.error(`❌ Module Import Error in ${path.basename(filePath)}:`);
+    console.log();
+    console.error(`   ${error.message}`);
+    console.log();
+    console.log('💡 Common solutions:');
+    console.log(`   • Run: ${color.blue('bun install')}`);
+    console.log('   • Check import paths are correct');
+    console.log('   • Ensure dependencies are listed in package.json');
+    
+  } else {
+    console.error(`❌ Error loading ${path.basename(filePath)}:`);
+    console.log();
+    console.error(`   ${error.message || error.toString()}`);
+    
+    // Add stack trace for debugging if available
+    if (process.env.BUNOSH_DEBUG) {
+      console.log();
+      console.log('🐛 Debug stack trace:');
+      console.log(error.stack || 'No stack trace available');
+    }
+    
+    console.log();
+    console.log('💡 Try:');
+    console.log(`   • Check the file exists: ${color.blue(`ls -la ${path.basename(filePath)}`)}`);
+    console.log(`   • Validate syntax: ${color.blue(`bun --check ${path.basename(filePath)}`)}`);
+    console.log(`   • Edit the file: ${color.blue('bunosh edit')}`);
+    console.log(`   • Run with debug: ${color.blue('BUNOSH_DEBUG=1 bunosh')}`);
+  }
+  
+  console.log();
+  process.exit(1);
+}

package/index.js

@@ -2,10 +2,11 @@ import exec from "./src/tasks/exec.js";
 import fetch from "./src/tasks/fetch.js";
 import writeToFile from "./src/tasks/writeToFile.js";
 import copyFile from "./src/tasks/copyFile.js";
+import ai from "./src/tasks/ai.js";
 import { ask, yell, say } from "./src/io.js";
 import { task, stopOnFail, ignoreFail } from "./src/task.js";
 
-export { exec, fetch, writeToFile, copyFile, ask, yell, say, task, stopOnFail, ignoreFail };
+export { exec, fetch, writeToFile, copyFile, ai, ask, yell, say, task, stopOnFail, ignoreFail };
 
 
 export function buildCmd(cmd) {
@@ -20,6 +21,7 @@ global.bunosh = {
   exec,
   writeToFile,
   copyFile,
+  ai,
   stopOnFail,
   ignoreFail,
   task,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunosh",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "type": "module",
   "module": "index.js",
   "bin": {
@@ -14,15 +14,20 @@
   },
   "types": "types.d.ts",
   "dependencies": {
+    "@ai-sdk/anthropic": "^2.0.9",
+    "@ai-sdk/groq": "^2.0.16",
+    "@ai-sdk/openai": "^2.0.23",
     "@babel/parser": "^7.27.5",
     "@babel/traverse": "^7.27.4",
+    "ai": "^5.0.29",
     "chalk": "^5.4.1",
     "commander": "^14.0.0",
     "debug": "^4.4.1",
     "fs-extra": "^11.3.0",
     "inquirer": "^12.6.3",
     "open-editor": "^5.1.0",
-    "timer-node": "^5.0.9"
+    "timer-node": "^5.0.9",
+    "zod": "^4.1.5"
   },
   "license": "ISC",
   "files": [

package/src/init.js

@@ -3,8 +3,10 @@ import color from "chalk";
 import fs from 'fs';
 
 const template = `
-// tasks
-const { exec, fetch, writeToFile, task } = global.bunosh;
+// Bunosh CLI required to execute tasks from this file
+// Get it here -> https://github.com/DavertMik/bunosh/releases
+
+const { exec, fetch, writeToFile, task, ai } = global.bunosh;
 
 // input/output
 const { say, ask, yell } = global.bunosh;
@@ -22,13 +24,19 @@ export async function helloWorld() {
   // use fetch() to make HTTP requests
   // await fetch('https://reqres.in/api/users')
 
+  // use ai() to make AI requests with structured output:
+  // REQUIRED env vars: AI_MODEL and any of: OPENAI_API_KEY, ANTHROPIC_API_KEY, or GROQ_API_KEY
+  // await ai('Summarize this text: JavaScript is awesome', {
+  //   summary: 'Brief summary of the text',
+  //   sentiment: 'Sentiment of the text (positive/negative/neutral)',
+  //   keyWords: 'Main keywords from the text'
+  // });
+
   // add arguments and options to this function if needed
   // export async function helloWorld(userName, opts = { force: false })
   //
   // bunosh hello:world 'bob' --force
 
-  // use ignoreFail(true) to prevent the command from stopping on error
-
   yell('Heloo Bunosh!');
   say('Edit me with bunosh edit');
 }

package/src/program.js

@@ -37,7 +37,10 @@ export default function bunosh(commands, source) {
     showGlobalOptions: false,
     visibleGlobalOptions: _opt => [],
     visibleOptions: _opt => [],
-    visibleCommands: cmd => cmd.commands.filter(c => !internalCommands.includes(c)),
+    visibleCommands: cmd => {
+      const commands = cmd.commands.filter(c => !internalCommands.includes(c));
+      return commands.filter(c => !c.name().startsWith('npm:'));
+    },
     subcommandTerm: (cmd) => color.white.bold(cmd.name()),
     subcommandDescription: (cmd) => color.gray(cmd.description()),
   });
@@ -46,13 +49,20 @@ export default function bunosh(commands, source) {
   program.showSuggestionAfterError(true);
   program.addHelpCommand(false);
 
-  const completeAst = babelParser.parse(source, {
-    sourceType: "module",
-    ranges: true,
-    tokens: true,
-    comments: true,
-    attachComment: true,
-  });
+  let completeAst;
+  try {
+    completeAst = babelParser.parse(source, {
+      sourceType: "module",
+      ranges: true,
+      tokens: true,
+      comments: true,
+      attachComment: true,
+    });
+  } catch (parseError) {
+    // Re-throw with more specific error information
+    parseError.code = 'BABEL_PARSER_SYNTAX_ERROR';
+    throw parseError;
+  }
 
   const comments = fetchComments();
 
@@ -282,11 +292,11 @@ export default function bunosh(commands, source) {
       try {
         // Detect current shell or use specified shell
         const shell = options.shell || detectCurrentShell();
-        
+
         if (!shell) {
           console.error('❌ Could not detect your shell. Please specify one:');
           console.log('   bunosh setup-completion --shell bash');
-          console.log('   bunosh setup-completion --shell zsh'); 
+          console.log('   bunosh setup-completion --shell zsh');
           console.log('   bunosh setup-completion --shell fish');
           process.exit(1);
         }
@@ -296,7 +306,7 @@ export default function bunosh(commands, source) {
 
         // Get paths for this shell
         const paths = getCompletionPaths(shell);
-        
+
         // Check if already installed
         if (!options.force && fs.existsSync(paths.completionFile)) {
           console.log(`⚠️  Completion already installed at: ${paths.completionFile}`);
@@ -311,7 +321,7 @@ export default function bunosh(commands, source) {
 
         // Report success
         console.log(`✅ Completion installed: ${color.green(paths.completionFile)}`);
-        
+
         if (result.configFile && result.added) {
           console.log(`📝 Updated shell config: ${color.green(result.configFile)}`);
           console.log();
@@ -327,10 +337,10 @@ export default function bunosh(commands, source) {
           console.log(`ℹ️  Shell config already has completion setup: ${result.configFile}`);
           console.log('   Restart your terminal if completion isn\'t working.');
         }
-        
+
         console.log();
         console.log('🎯 Test completion by typing: ' + color.bold('bunosh <TAB>'));
-        
+
       } catch (error) {
         console.error(`❌ Setup failed: ${error.message}`);
         process.exit(1);
@@ -360,9 +370,9 @@ export default function bunosh(commands, source) {
             const { getLatestRelease, isNewerVersion } = await import('./upgrade.js');
             const release = await getLatestRelease();
             const latestVersion = release.tag_name;
-            
+
             console.log(`📦 Latest version: ${color.bold(latestVersion)}`);
-            
+
             if (isNewerVersion(latestVersion, currentVersion)) {
               console.log(`✨ ${color.green('Update available!')} ${currentVersion} → ${latestVersion}`);
               console.log('Run ' + color.bold('bunosh upgrade') + ' to update.');
@@ -405,7 +415,7 @@ export default function bunosh(commands, source) {
 
       } catch (error) {
         console.error(`❌ Upgrade failed: ${error.message}`);
-        
+
         if (error.message.includes('Unsupported platform')) {
           console.log();
           console.log('💡 Supported platforms:');
@@ -416,21 +426,36 @@ export default function bunosh(commands, source) {
           console.log();
           console.log('💡 Try again later or check your internet connection.');
         }
-        
+
         process.exit(1);
       }
     });
 
   internalCommands.push(upgradeCmd);
 
+  // Add npm scripts help section if npm scripts exist
+  const npmScriptNamesForHelp = Object.keys(npmScripts);
+  if (npmScriptNamesForHelp.length > 0) {
+    const npmCommandsList = npmScriptNamesForHelp.sort().map(scriptName => {
+      const commandName = `npm:${scriptName}`;
+      const scriptCommand = npmScripts[scriptName];
+      return `  ${color.white.bold(commandName.padEnd(18))} ${color.gray(scriptCommand)}`;
+    }).join('\n');
+
+    program.addHelpText('after', `
+
+NPM Scripts:
+${npmCommandsList}
+`);
+  }
+
   program.addHelpText('after', `
 
 Special Commands:
+
   📝 Edit bunosh file: ${color.bold('bunosh edit')}
-  📥 Export scripts to package.json: ${color.bold('bunosh export:scripts')}
-  🔤 Generate shell completion: ${color.bold('bunosh completion bash|zsh|fish')}
-  ⚡ Auto-setup completion: ${color.bold('bunosh setup-completion')}
-  ⬆️  Upgrade bunosh: ${color.bold('bunosh upgrade')}
+  📥 Export commands as scripts to package.json: ${color.bold('bunosh export:scripts')}
+  🦾 Upgrade bunosh: ${color.bold('bunosh upgrade')}
 `);
 
   program.on("command:*", (cmd) => {

package/src/task.js

@@ -138,6 +138,14 @@ export class TaskResult {
     this.output = output;
   }
 
+  get hasFailed() {
+    return this.status === TaskStatus.FAIL;
+  }
+
+  get hasSucceeded() {
+    return this.status === TaskStatus.SUCCESS;
+  }
+
   static fail(output = null) {
     return new TaskResult({ status: TaskStatus.FAIL, output });
   }

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;