@eldrforge/ai-service 0.1.13 → 0.1.15

package/examples/03-interactive-commit.ts

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+/**
+ * Example 3: Interactive Commit Workflow
+ *
+ * This example demonstrates an interactive workflow where the user can:
+ * - Generate an initial commit message
+ * - Review and choose to confirm, edit, or regenerate
+ * - Optionally add user feedback for improvement
+ * - Automatically create the commit
+ *
+ * Usage:
+ *   1. Stage changes: git add .
+ *   2. Run: npx tsx examples/03-interactive-commit.ts
+ */
+
+/* eslint-disable no-console */
+
+import {
+    runAgenticCommit,
+    getUserChoice,
+    editContentInEditor,
+    STANDARD_CHOICES,
+} from '@eldrforge/ai-service';
+import { execSync } from 'child_process';
+
+async function main() {
+    try {
+    // Check for staged changes
+        const diffContent = execSync('git diff --staged', { encoding: 'utf8' });
+
+        if (!diffContent.trim()) {
+            console.log('❌ No staged changes found.');
+            console.log('   Stage some changes first with: git add <files>');
+            process.exit(1);
+        }
+
+        // Get changed files
+        const statusOutput = execSync('git status --porcelain', { encoding: 'utf8' });
+        const changedFiles = statusOutput
+            .split('\n')
+            .filter(line => line.trim())
+            .map(line => line.substring(3));
+
+        console.log('📝 Changed files:', changedFiles.length);
+        changedFiles.forEach(file => console.log(`   - ${file}`));
+        console.log('');
+
+        // Generate initial commit message
+        console.log('🤖 Generating commit message...\n');
+
+        const result = await runAgenticCommit({
+            changedFiles,
+            diffContent,
+            model: 'gpt-4o-mini',
+            maxIterations: 10,
+        });
+
+        let currentMessage = result.commitMessage;
+        let shouldContinue = true;
+
+        while (shouldContinue) {
+            // Display current message
+            console.log('\n✨ Commit Message:\n');
+            console.log('─'.repeat(60));
+            console.log(currentMessage);
+            console.log('─'.repeat(60));
+            console.log('');
+
+            // Get user choice
+            const choice = await getUserChoice(
+                'What would you like to do?',
+                [
+                    STANDARD_CHOICES.CONFIRM,
+                    STANDARD_CHOICES.EDIT,
+                    STANDARD_CHOICES.SKIP,
+                ],
+                {
+                    nonTtyErrorSuggestions: [
+                        'Run in a terminal environment',
+                        'Use examples/01-simple-commit.ts for non-interactive mode',
+                    ],
+                }
+            );
+
+            switch (choice) {
+                case 'c': { // Confirm
+                    console.log('\n📝 Creating commit...');
+
+                    try {
+                        execSync('git', ['commit', '-m', currentMessage], {
+                            stdio: 'inherit',
+                        });
+                        console.log('✅ Commit created successfully!');
+                    } catch (commitError) {
+                        console.error('❌ Failed to create commit:', commitError);
+                    }
+
+                    shouldContinue = false;
+                    break;
+                }
+
+                case 'e': { // Edit
+                    console.log('\n📝 Opening editor...');
+
+                    const edited = await editContentInEditor(
+                        currentMessage,
+                        [
+                            '# Edit your commit message below',
+                            '# Lines starting with # will be removed',
+                            '# Save and close the editor when done',
+                        ],
+                        '.txt'
+                    );
+
+                    if (edited.wasEdited) {
+                        currentMessage = edited.content;
+                        console.log('\n✅ Commit message updated!');
+                    } else {
+                        console.log('\n⚠️  No changes made');
+                    }
+                    break;
+                }
+
+                case 's': // Skip
+                    console.log('\n⏭️  Commit cancelled. Your changes are still staged.');
+                    shouldContinue = false;
+                    break;
+
+                default:
+                    console.log('\n❌ Invalid choice');
+                    break;
+            }
+        }
+
+    } catch (error) {
+        console.error('❌ Error:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+
+// Check if running in TTY
+if (!process.stdin.isTTY) {
+    console.error('❌ This example requires a terminal (TTY).');
+    console.error('   Run it directly in your terminal, not piped or in CI.');
+    console.error('   For non-interactive mode, use: examples/01-simple-commit.ts');
+    process.exit(1);
+}
+
+main();
+

package/examples/04-custom-storage.ts

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+/**
+ * Example 4: Custom Storage Adapter
+ *
+ * This example demonstrates how to implement a custom storage adapter
+ * to save AI-generated content to a specific location or cloud storage.
+ *
+ * Usage:
+ *   npx tsx examples/04-custom-storage.ts
+ */
+
+/* eslint-disable no-console */
+
+import { runAgenticCommit, type StorageAdapter } from '@eldrforge/ai-service';
+import { execSync } from 'child_process';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+/**
+ * Custom storage adapter that saves files to a structured output directory
+ */
+class CustomStorageAdapter implements StorageAdapter {
+    private outputDir: string;
+    private tempDir: string;
+
+    constructor(outputDir: string, tempDir: string = '/tmp') {
+        this.outputDir = outputDir;
+        this.tempDir = tempDir;
+    }
+
+    async writeOutput(fileName: string, content: string): Promise<void> {
+    // Ensure output directory exists
+        await fs.mkdir(this.outputDir, { recursive: true });
+
+        const filePath = path.join(this.outputDir, fileName);
+        await fs.writeFile(filePath, content, 'utf8');
+
+        console.log(`   📁 Saved to: ${filePath}`);
+    }
+
+    async readTemp(fileName: string): Promise<string> {
+        const filePath = path.join(this.tempDir, fileName);
+        return fs.readFile(filePath, 'utf8');
+    }
+
+    async writeTemp(fileName: string, content: string): Promise<void> {
+        await fs.mkdir(this.tempDir, { recursive: true });
+        const filePath = path.join(this.tempDir, fileName);
+        await fs.writeFile(filePath, content, 'utf8');
+    }
+
+    async readFile(fileName: string): Promise<string> {
+        return fs.readFile(fileName, 'utf8');
+    }
+}
+
+/**
+ * Alternative: Cloud storage adapter (example structure)
+ * In a real implementation, you would integrate with AWS S3, Google Cloud Storage, etc.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+class CloudStorageAdapter implements StorageAdapter {
+    async writeOutput(fileName: string, _content: string): Promise<void> {
+    // Example: Upload to S3
+    // const s3 = new S3Client({ region: 'us-east-1' });
+    // await s3.send(new PutObjectCommand({
+    //   Bucket: 'my-bucket',
+    //   Key: `ai-output/${fileName}`,
+    //   Body: content,
+    // }));
+
+        console.log(`   ☁️  Would upload to cloud: ${fileName}`);
+    }
+
+    async readTemp(fileName: string): Promise<string> {
+    // Local temp files
+        return fs.readFile(path.join('/tmp', fileName), 'utf8');
+    }
+
+    async writeTemp(fileName: string, content: string): Promise<void> {
+        await fs.writeFile(path.join('/tmp', fileName), content, 'utf8');
+    }
+
+    async readFile(fileName: string): Promise<string> {
+        return fs.readFile(fileName, 'utf8');
+    }
+}
+
+async function main() {
+    try {
+        console.log('🔍 Checking for staged changes...\n');
+
+        const diffContent = execSync('git diff --staged', { encoding: 'utf8' });
+
+        if (!diffContent.trim()) {
+            console.log('❌ No staged changes found.');
+            console.log('   Stage some changes first with: git add <files>');
+            process.exit(1);
+        }
+
+        const statusOutput = execSync('git status --porcelain', { encoding: 'utf8' });
+        const changedFiles = statusOutput
+            .split('\n')
+            .filter(line => line.trim())
+            .map(line => line.substring(3));
+
+        console.log('📝 Files changed:', changedFiles.length);
+        console.log('');
+
+        // Create custom storage adapter
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const outputDir = path.join(process.cwd(), 'output', 'ai-service', timestamp);
+        const storage = new CustomStorageAdapter(outputDir);
+
+        console.log('🤖 Generating commit message with custom storage...\n');
+
+        const result = await runAgenticCommit({
+            changedFiles,
+            diffContent,
+            model: 'gpt-4o-mini',
+            maxIterations: 10,
+            storage,
+        });
+
+        console.log('\n✨ Generated Commit Message:\n');
+        console.log('─'.repeat(60));
+        console.log(result.commitMessage);
+        console.log('─'.repeat(60));
+        console.log('');
+
+        // Save additional metadata
+        console.log('💾 Saving files...\n');
+
+        await storage.writeOutput('commit-message.txt', result.commitMessage);
+
+        await storage.writeOutput(
+            'metadata.json',
+            JSON.stringify({
+                timestamp: new Date().toISOString(),
+                iterations: result.iterations,
+                toolCallsExecuted: result.toolCallsExecuted,
+                model: 'gpt-4o-mini',
+                changedFiles,
+            }, null, 2)
+        );
+
+        // Save tool metrics
+        await storage.writeOutput(
+            'tool-metrics.json',
+            JSON.stringify(result.toolMetrics, null, 2)
+        );
+
+        console.log('\n✅ Complete! All files saved to:', outputDir);
+
+    } catch (error) {
+        console.error('❌ Error:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+
+main();
+

package/examples/05-custom-tools.ts

@@ -0,0 +1,243 @@
+#!/usr/bin/env node
+/**
+ * Example 5: Custom Tool Integration
+ *
+ * This example demonstrates how to create and register custom tools
+ * that extend the AI's capabilities for your specific use case.
+ *
+ * Usage:
+ *   npx tsx examples/05-custom-tools.ts
+ */
+
+/* eslint-disable no-console */
+
+import {
+    createToolRegistry,
+    runAgentic,
+    type Tool,
+    type ToolContext,
+} from '@eldrforge/ai-service';
+import { execSync } from 'child_process';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+/**
+ * Custom tool: Check test coverage
+ */
+const checkTestCoverage: Tool = {
+    name: 'check_test_coverage',
+    description: 'Check test coverage for the project or specific files',
+    parameters: {
+        type: 'object',
+        properties: {
+            filePath: {
+                type: 'string',
+                description: 'Optional specific file to check coverage for',
+            },
+        },
+    },
+    execute: async (params: { filePath?: string }, context?: ToolContext) => {
+        try {
+            const cmd = params.filePath
+                ? `npm test -- --coverage --testPathPattern="${params.filePath}"`
+                : 'npm test -- --coverage --silent 2>&1';
+
+            const output = execSync(cmd, {
+                encoding: 'utf8',
+                cwd: context?.workingDirectory || process.cwd(),
+            });
+
+            // Parse coverage from output
+            const coverageMatch = output.match(/All files.*?(\d+\.?\d*)/);
+            const coverage = coverageMatch ? parseFloat(coverageMatch[1]) : 0;
+
+            return {
+                success: true,
+                coverage: `${coverage}%`,
+                message: `Test coverage: ${coverage}%`,
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+};
+
+/**
+ * Custom tool: Check for linter errors
+ */
+const checkLinterErrors: Tool = {
+    name: 'check_linter_errors',
+    description: 'Check for linter/ESLint errors in the codebase',
+    parameters: {
+        type: 'object',
+        properties: {
+            filePath: {
+                type: 'string',
+                description: 'Optional specific file to lint',
+            },
+        },
+    },
+    execute: async (params: { filePath?: string }, context?: ToolContext) => {
+        try {
+            const target = params.filePath || '.';
+            const cmd = `npx eslint ${target} --format json`;
+
+            const output = execSync(cmd, {
+                encoding: 'utf8',
+                cwd: context?.workingDirectory || process.cwd(),
+            });
+
+            const results = JSON.parse(output);
+            const errorCount = results.reduce((sum: number, file: any) => sum + file.errorCount, 0);
+            const warningCount = results.reduce((sum: number, file: any) => sum + file.warningCount, 0);
+
+            return {
+                success: errorCount === 0,
+                errors: errorCount,
+                warnings: warningCount,
+                message: `Found ${errorCount} errors and ${warningCount} warnings`,
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+};
+
+/**
+ * Custom tool: Analyze package dependencies
+ */
+const analyzePackageDeps: Tool = {
+    name: 'analyze_package_dependencies',
+    description: 'Analyze package.json dependencies and check for outdated packages',
+    parameters: {
+        type: 'object',
+        properties: {},
+    },
+    execute: async (_params: any, context?: ToolContext) => {
+        try {
+            const packageJsonPath = path.join(
+                context?.workingDirectory || process.cwd(),
+                'package.json'
+            );
+
+            const packageJson = JSON.parse(
+                await fs.readFile(packageJsonPath, 'utf8')
+            );
+
+            const deps = packageJson.dependencies || {};
+            const devDeps = packageJson.devDependencies || {};
+            const totalDeps = Object.keys(deps).length + Object.keys(devDeps).length;
+
+            // Check for outdated packages
+            let outdatedOutput = '';
+            try {
+                outdatedOutput = execSync('npm outdated --json', {
+                    encoding: 'utf8',
+                    cwd: context?.workingDirectory || process.cwd(),
+                });
+            } catch {
+                // npm outdated exits with code 1 if there are outdated packages
+            }
+
+            const outdated = outdatedOutput ? JSON.parse(outdatedOutput) : {};
+            const outdatedCount = Object.keys(outdated).length;
+
+            return {
+                success: true,
+                totalDependencies: totalDeps,
+                outdatedPackages: outdatedCount,
+                dependencies: Object.keys(deps),
+                devDependencies: Object.keys(devDeps),
+                outdatedDetails: outdated,
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+};
+
+async function main() {
+    try {
+        console.log('🔧 Creating tool registry with custom tools...\n');
+
+        // Create tool registry
+        const registry = createToolRegistry({
+            workingDirectory: process.cwd(),
+        });
+
+        // Register custom tools
+        registry.register(checkTestCoverage);
+        registry.register(checkLinterErrors);
+        registry.register(analyzePackageDeps);
+
+        console.log('✅ Registered custom tools:');
+        console.log('   - check_test_coverage');
+        console.log('   - check_linter_errors');
+        console.log('   - analyze_package_dependencies');
+        console.log('');
+
+        // Create a conversation that uses these tools
+        const messages = [
+            {
+                role: 'system' as const,
+                content: `You are a code quality analyst. Use the available tools to assess the project's health.
+
+Your task:
+1. Check test coverage
+2. Check for linter errors
+3. Analyze package dependencies
+
+Then provide a summary report of the project's code quality status.`,
+            },
+            {
+                role: 'user' as const,
+                content: 'Please analyze the current project and provide a code quality report.',
+            },
+        ];
+
+        console.log('🤖 Running AI analysis with custom tools...\n');
+
+        const result = await runAgentic({
+            messages,
+            tools: registry,
+            model: 'gpt-4o-mini',
+            maxIterations: 10,
+        });
+
+        console.log('✨ Analysis Complete!\n');
+        console.log('═'.repeat(70));
+        console.log(result.finalMessage);
+        console.log('═'.repeat(70));
+        console.log('');
+        console.log(`📊 Tool calls made: ${result.toolCallsExecuted}`);
+        console.log(`🔄 Iterations: ${result.iterations}`);
+        console.log('');
+
+        // Show which tools were used
+        const toolUsage: Record<string, number> = {};
+        result.toolMetrics.forEach(metric => {
+            toolUsage[metric.name] = (toolUsage[metric.name] || 0) + 1;
+        });
+
+        console.log('🔧 Tools used:');
+        Object.entries(toolUsage).forEach(([tool, count]) => {
+            console.log(`   - ${tool}: ${count}x`);
+        });
+
+    } catch (error) {
+        console.error('❌ Error:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+
+main();
+