boxsafe 1.0.0

package/adapters/secondary/system/configuration.ts

@@ -0,0 +1,147 @@
+/**
+ * @fileoverview
+ * Adapter for ISystemConfigurationPort
+ * Implementation based on existing loadConfig
+ * 
+ * @module adapters/secondary/system/configuration
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import type { 
+  ISystemConfigurationPort, 
+  ConfigurationResult, 
+  ValidationResult,
+  BoxSafeConfig 
+} from '@core/ports';
+import { DEFAULT_BOXSAFE_CONFIG } from '@core/config/defaults';
+
+/**
+ * System configuration adapter using JSON file and environment variables
+ */
+export class SystemConfigurationAdapter implements ISystemConfigurationPort {
+  private defaultConfigPath: string;
+
+  constructor(defaultConfigPath?: string) {
+    this.defaultConfigPath = defaultConfigPath ?? path.resolve(process.cwd(), 'boxsafe.config.json');
+  }
+
+  /**
+   * Load system configurations
+   */
+  async loadConfiguration(configPath?: string): Promise<ConfigurationResult> {
+    const p = configPath ?? this.defaultConfigPath;
+
+    let rawConfig: unknown = null;
+    try {
+      if (fs.existsSync(p)) {
+        rawConfig = JSON.parse(fs.readFileSync(p, 'utf-8'));
+      }
+    } catch {
+      rawConfig = null;
+    }
+
+    const merged = this.deepMerge(DEFAULT_BOXSAFE_CONFIG, rawConfig ?? {});
+    
+    // Specific normalization for loops
+    const loopsFallback = typeof DEFAULT_BOXSAFE_CONFIG.limits?.loops === 'number' 
+      ? DEFAULT_BOXSAFE_CONFIG.limits.loops 
+      : 2;
+    
+    if (!merged.limits) merged.limits = {} as any;
+    (merged.limits as any).loops = this.normalizeLoops((merged.limits as any).loops, loopsFallback);
+
+    return {
+      config: merged as BoxSafeConfig,
+      source: { path: p, loaded: Boolean(rawConfig) }
+    };
+  }
+
+  /**
+   * Validate system configurations
+   */
+  async validateConfiguration(config: BoxSafeConfig): Promise<ValidationResult> {
+    const errors: string[] = [];
+    const warnings: string[] = [];
+
+    // Mandatory validations
+    if (!config.project?.workspace) {
+      errors.push('project.workspace is required');
+    }
+
+    if (!config.model?.primary?.provider) {
+      errors.push('model.primary.provider is required');
+    }
+
+    if (!config.model?.primary?.name) {
+      errors.push('model.primary.name is required');
+    }
+
+    // Optional validations with warnings
+    if (!config.commands?.run) {
+      warnings.push('commands.run not defined, using default value');
+    }
+
+    if (!config.interface?.prompt) {
+      warnings.push('interface.prompt not defined, using default value');
+    }
+
+    // Limits validations
+    if (config.limits?.loops !== undefined) {
+      if (typeof config.limits.loops === 'number' && config.limits.loops <= 0) {
+        errors.push('limits.loops must be a positive number');
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+
+  /**
+   * Helper for deep merge of objects
+   */
+  private deepMerge<T>(base: T, override: unknown): T {
+    const isPlainObject = (v: unknown): v is Record<string, unknown> => {
+      return Boolean(v) && typeof v === 'object' && !Array.isArray(v);
+    };
+
+    if (!isPlainObject(base) || !isPlainObject(override)) {
+      return (override ?? base) as T;
+    }
+
+    const out: Record<string, unknown> = { ...(base as any) };
+    for (const [k, v] of Object.entries(override)) {
+      const bv = (base as any)[k];
+      if (isPlainObject(bv) && isPlainObject(v)) {
+        out[k] = this.deepMerge(bv, v);
+      } else {
+        out[k] = v;
+      }
+    }
+    return out as T;
+  }
+
+  /**
+   * Helper to normalize loops value
+   */
+  private normalizeLoops(v: unknown, fallback: number): number {
+    if (typeof v === 'number' && Number.isFinite(v)) return v;
+    if (typeof v === 'string') {
+      const trimmed = v.trim().toLowerCase();
+      if (trimmed === 'infinity') return Number.MAX_SAFE_INTEGER;
+      const n = Number(trimmed);
+      if (Number.isFinite(n)) return n;
+    }
+    return fallback;
+  }
+}
+
+/**
+ * Factory function para criar o adapter
+ */
+export function createSystemConfigurationAdapter(configPath?: string): SystemConfigurationAdapter {
+  return new SystemConfigurationAdapter(configPath);
+}

package/ai/caller.ts

@@ -0,0 +1,42 @@
+/**
+ * @fileoverview Unified LLM runner. Executes a prompt and persists the result.
+ * @module pack
+ * The code needs to run in the root directory to work
+ * this ensures it's called in the main method at the project root.
+ */
+
+import "dotenv/config";
+import * as path from "path";
+import fs from "fs/promises";
+import { createLLM } from "@ai/provider";
+import { LService, LModel } from "@ai/label";
+
+interface RunnerConfig {
+  service: LService;
+  model: LModel;
+  outputPath: string;
+}
+
+const DEFAULT_CONFIG: RunnerConfig = {
+  service: LService.GOOGLE,
+  model: LModel.GEMINI,
+  outputPath: process.env.BOXSAFE_MARKDOWN_PATH?.trim() || "./memo/generated/codelog.md",
+};
+
+const writeOutput = async (filePath: string, data: string): Promise<void> => {
+  const resolved = path.isAbsolute(filePath) ? filePath : path.join(process.cwd(), filePath);
+
+  await fs.mkdir(path.dirname(resolved), { recursive: true });
+  await fs.writeFile(resolved, data, "utf8");
+};
+
+export const runLLM = async (
+  prompt: string,
+  llm: ReturnType<typeof createLLM>,
+  config: RunnerConfig = DEFAULT_CONFIG,
+): Promise<void> => {
+  const text = await llm.generate(prompt);
+  await writeOutput(config.outputPath, text);
+};
+
+// ── entry point ──────────────────────────────────────────────────────────────

package/ai/label.ts

@@ -0,0 +1,33 @@
+/**
+ * @fileoverview Service and model identifiers with compatibility constraints.
+ * @module pack/ai
+ */
+
+export enum LService {
+  MOCK = "mock",
+  OPENAI = "openai",
+  GOOGLE = "google",
+}
+
+export enum LModel {
+  MOCK = "mock",
+  GPT = "gpt-4o-mini",
+  GEMINI = "gemini-2.5-flash",
+}
+
+/* Valid model options per service */
+export const SERVICE_MODELS: Record<LService, LModel[]> = {
+  [LService.MOCK]: [LModel.MOCK],
+  [LService.OPENAI]: [LModel.GPT],
+  [LService.GOOGLE]: [LModel.GEMINI],
+};
+
+export function validateServiceModel(service: LService, model: LModel): void {
+  const allowed = SERVICE_MODELS[service];
+  if (!allowed.includes(model)) {
+    throw new Error(
+      `Model "${model}" is not supported by service "${service}". ` +
+      `Allowed: ${allowed.join(", ")}`
+    );
+  }
+}

package/ai/modelConfig.ts

@@ -0,0 +1,236 @@
+/**
+ * Model Configuration - BoxSafe
+ * 
+ * Centralized system for managing model profiles
+ * with capabilities, costs, and prompt strategies.
+ */
+
+export enum ModelCapability {
+  LOW = 'low',        // < 8k tokens (Llama 7B, local models)
+  MEDIUM = 'medium',  // 8k-32k tokens (GPT-3.5, Claude Haiku)
+  HIGH = 'high',      // 32k-128k tokens (GPT-4, Claude Sonnet)
+  EXCELLENT = 'excellent' // >128k tokens (GPT-4 Turbo, Claude Opus)
+}
+
+export interface ModelProfile {
+  name: string;
+  capability: ModelCapability;
+  maxTokens: number;
+  reminderFrequency: number; // interactions before reminder
+  contextThreshold: number; // % context usage for reminder trigger
+  costPerToken?: number; // for cost optimization
+  provider: 'local' | 'openai' | 'anthropic' | 'google';
+  description?: string;
+}
+
+/**
+ * Known model profiles catalog
+ * Easily extensible for new models
+ */
+export const MODEL_PROFILES: Record<string, ModelProfile> = {
+  // === LOCAL MODELS ===
+  'llama-7b': {
+    name: 'Llama 7B',
+    capability: ModelCapability.LOW,
+    maxTokens: 8192,
+    reminderFrequency: 3, // Remind every 3 interactions
+    contextThreshold: 60, // Remind when using 60% of context
+    provider: 'local',
+    description: 'Efficient local model for simple tasks'
+  },
+  'llama-13b': {
+    name: 'Llama 13B',
+    capability: ModelCapability.LOW,
+    maxTokens: 8192,
+    reminderFrequency: 2, // More frequent due to higher capability
+    contextThreshold: 50,
+    provider: 'local',
+    description: 'Local model with more capability than Llama 7B'
+  },
+  'mistral-7b': {
+    name: 'Mistral 7B',
+    capability: ModelCapability.MEDIUM,
+    maxTokens: 16384,
+    reminderFrequency: 5,
+    contextThreshold: 70,
+    provider: 'local',
+    description: 'Local model with good cost-benefit ratio'
+  },
+  'codellama-34b': {
+    name: 'CodeLlama 34B',
+    capability: ModelCapability.MEDIUM,
+    maxTokens: 16384,
+    reminderFrequency: 4,
+    contextThreshold: 65,
+    provider: 'local',
+    description: 'Local model specialized in code'
+  },
+  
+  // === OPENAI ===
+  'gpt-3.5-turbo': {
+    name: 'GPT-3.5 Turbo',
+    capability: ModelCapability.MEDIUM,
+    maxTokens: 16384,
+    reminderFrequency: 8,
+    contextThreshold: 75,
+    costPerToken: 0.0000015,
+    provider: 'openai',
+    description: 'Fast and economical model for production'
+  },
+  'gpt-4': {
+    name: 'GPT-4',
+    capability: ModelCapability.HIGH,
+    maxTokens: 32768,
+    reminderFrequency: 15,
+    contextThreshold: 85,
+    costPerToken: 0.00003,
+    provider: 'openai',
+    description: 'High reasoning capability'
+  },
+  'gpt-4-turbo': {
+    name: 'GPT-4 Turbo',
+    capability: ModelCapability.EXCELLENT,
+    maxTokens: 128000,
+    reminderFrequency: 25,
+    contextThreshold: 90,
+    costPerToken: 0.00001,
+    provider: 'openai',
+    description: 'Maximum performance with optimized cost'
+  },
+  'gpt-4o': {
+    name: 'GPT-4o',
+    capability: ModelCapability.EXCELLENT,
+    maxTokens: 128000,
+    reminderFrequency: 30,
+    contextThreshold: 90,
+    costPerToken: 0.000005,
+    provider: 'openai',
+    description: 'Latest model with excellent cost-benefit'
+  },
+  
+  // === ANTHROPIC ===
+  'claude-3-haiku': {
+    name: 'Claude 3 Haiku',
+    capability: ModelCapability.MEDIUM,
+    maxTokens: 200000,
+    reminderFrequency: 10,
+    contextThreshold: 80,
+    costPerToken: 0.00000025,
+    provider: 'anthropic',
+    description: 'Fast and economical for simple tasks'
+  },
+  'claude-3-sonnet': {
+    name: 'Claude 3 Sonnet',
+    capability: ModelCapability.HIGH,
+    maxTokens: 200000,
+    reminderFrequency: 20,
+    contextThreshold: 85,
+    costPerToken: 0.000003,
+    provider: 'anthropic',
+    description: 'Excellent for complex code'
+  },
+  'claude-3-opus': {
+    name: 'Claude 3 Opus',
+    capability: ModelCapability.EXCELLENT,
+    maxTokens: 200000,
+    reminderFrequency: 25,
+    contextThreshold: 90,
+    costPerToken: 0.000015,
+    provider: 'anthropic',
+    description: 'Maximum capability for critical tasks'
+  },
+  
+  // === GOOGLE ===
+  'gemini-1.5-flash': {
+    name: 'Gemini 1.5 Flash',
+    capability: ModelCapability.MEDIUM,
+    maxTokens: 1048576,
+    reminderFrequency: 7,
+    contextThreshold: 75,
+    costPerToken: 0.000000075,
+    provider: 'google',
+    description: 'Fast and economical from Google'
+  },
+  'gemini-1.5-pro': {
+    name: 'Gemini 1.5 Pro',
+    capability: ModelCapability.HIGH,
+    maxTokens: 2097152,
+    reminderFrequency: 18,
+    contextThreshold: 85,
+    costPerToken: 0.00000125,
+    provider: 'google',
+    description: 'High capability from Gemini Pro'
+  },
+};
+
+/**
+ * Utilities for model management
+ */
+export class ModelConfigManager {
+  
+  /**
+   * Gets model profile with safe fallback
+   */
+  static getModelProfile(modelName: string): ModelProfile {
+    const profile = MODEL_PROFILES[modelName];
+    if (!profile) {
+      console.warn(`Model ${modelName} not found, using default GPT-3.5 Turbo`);
+      return MODEL_PROFILES['gpt-3.5-turbo'] as ModelProfile;
+    }
+    return profile;
+  }
+  
+  /**
+   * Lists all models by capability
+   */
+  static getModelsByCapability(capability: ModelCapability): ModelProfile[] {
+    return Object.values(MODEL_PROFILES).filter(model => model.capability === capability);
+  }
+  
+  /**
+   * Lists all models by provider
+   */
+  static getModelsByProvider(provider: string): ModelProfile[] {
+    return Object.values(MODEL_PROFILES).filter(model => model.provider === provider);
+  }
+  
+  /**
+   * Calculates estimated cost for an interaction
+   */
+  static estimateCost(modelName: string, tokenCount: number): number {
+    const profile = this.getModelProfile(modelName);
+    return profile.costPerToken ? tokenCount * profile.costPerToken : 0;
+  }
+  
+  /**
+   * Checks if model is local vs API
+   */
+  static isLocalModel(modelName: string): boolean {
+    const profile = this.getModelProfile(modelName);
+    return profile.provider === 'local';
+  }
+  
+  /**
+   * Gets usage recommendations based on profile
+   */
+  static getRecommendations(modelName: string): {
+    maxPromptLength: number;
+    reminderFrequency: string;
+    costOptimization: string;
+  } {
+    const profile = this.getModelProfile(modelName);
+    
+    return {
+      maxPromptLength: Math.floor(profile.maxTokens * 0.7), // Leave 30% for response
+      reminderFrequency: `Every ${profile.reminderFrequency} interactions`,
+      costOptimization: profile.costPerToken 
+        ? `Cost: ${(profile.costPerToken * 1000).toFixed(6)} per 1k tokens`
+        : 'Local model - no costs'
+    };
+  }
+}
+
+/**
+ * Default configuration for new models
+ */
+export const DEFAULT_MODEL_CONFIG: ModelProfile = MODEL_PROFILES['gpt-3.5-turbo']!;

package/ai/provider.ts

@@ -0,0 +1,111 @@
+/**
+ * @fileoverview LLM provider factory with pluggable adapters.
+ * @module pack/ai
+ */
+
+import { generateText } from "ai";
+import { openai } from "@ai-sdk/openai";
+import { google } from "@ai-sdk/google";
+import { LService, LModel, validateServiceModel } from "@ai/label";
+import { Logger } from '@util/logger';
+
+const logger = Logger.createModuleLogger('AI');
+
+// Support KEYGemini environment variable as the Google/Gemini API key.
+// Some environments expose the Gemini key under a custom name (e.g., KEYGemini).
+// Map it to the environment variables the Google SDKs commonly check:
+// - `GOOGLE_GENERATIVE_AI_API_KEY` (used by Google Generative AI / Gemini)
+// - `GOOGLE_API_KEY` (older/alternate name)
+const _geminiKey = process.env.KEYGemini ?? process.env.KEY_GEMINI ?? process.env.GOOGLE_GENERATIVE_AI_API_KEY;
+if (_geminiKey) {
+  if (!process.env.GOOGLE_GENERATIVE_AI_API_KEY) {
+    process.env.GOOGLE_GENERATIVE_AI_API_KEY = _geminiKey;
+  }
+  if (!process.env.GOOGLE_API_KEY) {
+    process.env.GOOGLE_API_KEY = _geminiKey;
+  }
+}
+
+interface LLMContract {
+  generate(prompt: string): Promise<string>;
+}
+
+type SDKModelFn<M extends LModel> =
+  (model: M) => Parameters<typeof generateText>[0]["model"];
+
+/** SDK model initializers keyed by service */
+const SDK_PROVIDERS = {
+  [LService.OPENAI]: (model: LModel.GPT) => openai(model),
+  [LService.GOOGLE]: (model: LModel.GEMINI) => google(model),
+} satisfies {
+  [LService.OPENAI]: SDKModelFn<LModel.GPT>;
+  [LService.GOOGLE]: SDKModelFn<LModel.GEMINI>;
+};
+
+function createSDKAdapter(
+  model: Parameters<typeof generateText>[0]["model"]
+): LLMContract {
+  return {
+    async generate(prompt: string): Promise<string> {
+      const { text } = await generateText({ model, prompt });
+      return text;
+    },
+  };
+}
+
+const MOCK_ADAPTER: LLMContract = {
+  async generate(): Promise<string> {
+    // Return a minimal bash code block so extractCode can find runnable code
+    // This keeps mock behavior useful for testing the loop pipeline.
+    return "```bash\necho \"Mock response\"\n```";
+  },
+};
+
+const SERVICE_ADAPTERS = {
+  [LService.OPENAI]: (model: LModel.GPT) =>
+    createSDKAdapter(SDK_PROVIDERS[LService.OPENAI](model)),
+
+  [LService.GOOGLE]: (model: LModel.GEMINI) =>
+    createSDKAdapter(SDK_PROVIDERS[LService.GOOGLE](model)),
+};
+
+// ____________________________________________________________________________
+// ── Factory Function ────────────────────────────────────────────────────────
+export function createLLM(
+  service: LService.MOCK,
+  model: LModel.MOCK
+): LLMContract;
+
+export function createLLM(
+  service: LService.OPENAI,
+  model: LModel.GPT
+): LLMContract;
+
+export function createLLM(
+  service: LService.GOOGLE,
+  model: LModel.GEMINI
+): LLMContract;
+
+export function createLLM(
+  service: LService,
+  model: LModel
+): LLMContract;
+
+export function createLLM(service: LService, model: LModel): LLMContract {
+  // Log chosen service/model and presence of Gemini key for diagnostics
+  logger.info(`LLM Provider - requested service=${service} model=${model}`);
+  logger.info(`LLM Provider - GOOGLE_GENERATIVE_AI_API_KEY present=${Boolean(process.env.GOOGLE_GENERATIVE_AI_API_KEY)}`);
+
+  validateServiceModel(service, model);
+
+  if (service === LService.MOCK) return MOCK_ADAPTER;
+
+  const create = SERVICE_ADAPTERS[service];
+  if (!create) {
+    const errorMsg = `No SDK provider registered for service "${service}"`;
+    logger.error(errorMsg);
+    throw new Error(errorMsg);
+  }
+
+  return create(model as never);
+}

package/boxsafe.config.json

@@ -0,0 +1,68 @@
+{
+  "project": {
+    "workspace": "./",
+    "testDir": "./",
+    "todo":"./TODO.md",
+    "versionControl": {
+      "before": false,
+      "after": false,
+      "generateNotes": true
+    }
+  },
+
+  "model": {
+    "primary": {
+      "provider": "google",
+      "name": "gemini-2.5-flash"
+    },
+    "fallback": [],
+    "endpoint": null,
+    "parameters": {}
+  },
+
+  "smartRotation": {
+    "enabled": false,
+    "simple": [],
+    "complex": []
+  },
+
+  "limits": {
+    "tokens": 100000,
+    "loops": 1,
+    "timeout": {
+      "enabled": false,
+      "duration": "1h",
+      "notify": true
+    }
+  },
+
+  "sandbox": {
+    "enabled": true,
+    "engine": "docker",
+    "memory": "512m",
+    "cpu": 0.5,
+    "network": "none"
+  },
+
+  "commands": {
+    "setup": "npm install",
+    "run": "echo OK",
+    "test": null
+  },
+
+  "interface": {
+    "channel": "terminal",
+    "prompt": "crie um arquivo chamado lv_test.ts, este arquivo deve imprimir hello world no terminal ",
+    "notifications": {
+      "whatsapp": false,
+      "telegram": false,
+      "slack": false,
+      "email": false
+    }
+  },
+
+  "teach": {
+    "urls": [],
+    "files": []
+  }
+}