AI Assistant

envark
/ai-config

# OpenAI
export OPENAI_API_KEY=sk-...

# Anthropic
export ANTHROPIC_API_KEY=sk-ant-...

# Google Gemini
export GEMINI_API_KEY=...
# or
export GOOGLE_API_KEY=...

# Ollama (no key needed, just ensure service is running)

{
  "provider": "openai",
  "apiKey": "sk-...",
  "model": "gpt-4o",
  "lastUpdated": "2026-03-05T10:30:00.000Z"
}

envark
/chat

You: What's the difference between .env and .env.local?

 AI: .env is typically committed to version control and contains
     default/example values, while .env.local is git-ignored and
     contains your actual local development secrets. The .env.local
     file overrides values from .env when both are present.

You: Should I commit API keys?

 AI: No, never commit API keys or secrets to version control...

You: /exit

/ask How do I secure database credentials?
/ask What's a good naming convention for environment variables?
a Should I use uppercase or lowercase for env vars?

/analyze

Summary:
Your project uses 42 environment variables across Node.js and TypeScript.
Found 2 critical issues and 5 high-priority recommendations.

Recommendations:
  • Move DATABASE_PASSWORD from .env to .env.local to prevent accidental commits
  • Add validation for PORT to ensure it's a valid number
  • Consider using a secret management solution for API keys
  • Standardize naming: use DATABASE_URL instead of mixing DB_URL and DATABASE_URI
  • Add .env.example with placeholder values for all required variables

// From src/ai/agent.ts:213-223
async analyzeEnvironment(context: EnvAnalysisContext): Promise<AIAnalysisResult> {
    if (!this.provider) {
        return {
            summary: 'AI not configured',
            recommendations: ['Configure an AI provider using /config command'],
            securityIssues: []
        };
    }

    return this.provider.analyzeEnvironment(context);
}

/suggest DATABASE_URL

Suggestions for DATABASE_URL:
  1. Add connection pooling parameters (e.g., ?pool_size=10)
  2. Use SSL mode in production: ?sslmode=require
  3. Consider splitting into separate host, port, database for flexibility
  4. Document expected format in .env.example
  5. Validate URL format at startup to fail fast on misconfiguration

/explain NODE_ENV

NODE_ENV is a convention in Node.js applications to specify the runtime
environment.

1. Purpose:
   - Controls application behavior (logging, caching, debugging)
   - Determines which optimizations to enable
   - Often used for conditional logic

2. Common Values:
   - "development" - Local development with debugging
   - "production" - Optimized for production deployment
   - "test" - Used during automated testing

3. Security Considerations:
   - Not inherently secret, safe to expose
   - Production mode should disable debug features
   - Never use "development" in production

4. Framework Support:
   - Express.js uses it for error handling
   - React build tools use it for optimization
   - Many libraries check this for behavior changes

/template Next.js application with authentication
tpl Django REST API with PostgreSQL and Redis

# ==========================================
# Next.js Application Environment Variables
# ==========================================

# Application
NEXT_PUBLIC_APP_NAME=MyApp
NEXT_PUBLIC_APP_URL=http://localhost:3000
NODE_ENV=development

# Database
DATABASE_URL=postgresql://user:password@localhost:5432/myapp

# Authentication
NEXTAUTH_URL=http://localhost:3000
NEXTAUTH_SECRET=changeme-generate-with-openssl-rand-base64-32

# OAuth Providers (optional)
GOOGLE_CLIENT_ID=your-client-id
GOOGLE_CLIENT_SECRET=your-client-secret
GITHUB_CLIENT_ID=your-client-id
GITHUB_CLIENT_SECRET=your-client-secret

# Email (optional)
SMTP_HOST=smtp.gmail.com
SMTP_PORT=587
SMTP_USER=[email protected]
SMTP_PASSWORD=your-app-password

// From src/ai/agent.ts:316-337
private getEnhancedSystemPrompt(): string {
    return `You are Aegis AI, an expert environment variable security analyst integrated into the Aegis CLI tool.

Your capabilities:
- Analyze environment variables for security risks
- Provide recommendations for better configuration management
- Generate secure .env templates and validation code
- Explain best practices for different frameworks and languages
- Help debug configuration issues

Current context:
- Running in Aegis CLI terminal interface
- User can scan their project with /scan, /risk, /missing commands
- Use markdown formatting for code blocks

Guidelines:
- Be concise but thorough
- Always consider security implications
- Provide actionable recommendations
- Use code examples when helpful
- Consider different deployment environments`;
}

// From src/ai/provider.ts:59-94
export abstract class AIProvider {
    protected config: AIProviderConfig;
    protected systemPrompt: string;

    abstract chat(messages: AIMessage[], options?: AICompletionOptions): Promise<string>;
    abstract stream(messages: AIMessage[], options?: AICompletionOptions): AsyncGenerator<AIStreamChunk>;
    abstract isConfigured(): boolean;
    abstract getName(): string;
    abstract getModel(): string;

    async analyzeEnvironment(context: EnvAnalysisContext): Promise<AIAnalysisResult> {
        const prompt = this.buildAnalysisPrompt(context);
        const response = await this.chat([
            { role: 'system', content: this.systemPrompt },
            { role: 'user', content: prompt }
        ], { temperature: 0.3 });

        return this.parseAnalysisResponse(response);
    }

    async suggestImprovements(variableName: string, context?: string): Promise<string[]> {
        // Returns 3-5 actionable recommendations
    }

    async generateEnvTemplate(requirements: string): Promise<string> {
        // Generates production-ready .env template
    }

    async generateValidationCode(variables: string[], language: string): Promise<string> {
        // Creates type-safe validation code
    }
}

// From src/ai/agent.ts:34-37
export class AegisAIAgent {
    private conversationHistory: ConversationMessage[] = [];
    private maxHistoryLength: number = 20;
}

import { getAIAgent } from 'envark/ai/agent';

const agent = getAIAgent();

// Configure provider
agent.configure({
    provider: 'openai',
    apiKey: process.env.OPENAI_API_KEY,
    model: 'gpt-4o'
});

// Check configuration
if (agent.isConfigured()) {
    console.log(agent.getProviderInfo());
    // { name: 'OpenAI', model: 'gpt-4o', configured: true }
}

// Chat
const response = await agent.chat('How should I structure my .env files?');
console.log(response);

// Analyze environment
const analysis = await agent.analyzeEnvironment({
    variables: [
        { name: 'DATABASE_URL', file: 'config.ts', line: 10, riskLevel: 'high' },
        { name: 'API_KEY', file: 'api.ts', line: 5, riskLevel: 'critical' }
    ],
    projectPath: '/path/to/project',
    language: 'typescript',
    framework: 'next.js'
});

console.log(analysis.summary);
console.log(analysis.recommendations);

// Get suggestions
const suggestions = await agent.suggestVariableImprovements('DATABASE_URL');
sugestions.forEach(s => console.log(`- ${s}`));

// Generate template
const template = await agent.generateEnvTemplate('React SPA with REST API');
console.log(template);

// From src/ai/provider.ts
{ temperature: 0.3 }  // Environment analysis (precise)
{ temperature: 0.5 }  // Suggestions (balanced)
{ temperature: 0.4 }  // Template generation (structured)
{ temperature: 0.2 }  // Validation code (deterministic)