@ericnunes/frame-code-cli 0.0.1

package/dist/infrastructure/compression/promptBuilder.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIPromptBuilder = void 0;
+exports.createDefaultPromptConfig = createDefaultPromptConfig;
+exports.createCompressionPromptConfig = createCompressionPromptConfig;
+const frame_agent_sdk_1 = require("@ericnunes/frame-agent-sdk");
+const logger_1 = require("../logging/logger");
+class CLIPromptBuilder {
+    static formatCompressionContext(compressionHistory) {
+        return [
+            '---',
+            '',
+            '## Context History',
+            '',
+            'O contexto anterior desta sessão foi comprimido para preservar informações importantes:',
+            '',
+            compressionHistory.trim(),
+            '',
+            'Use este contexto histórico para entender o que já foi discutido e continuar a conversa de forma coerente.'
+        ].join('\n');
+    }
+    static buildSystemPrompt(config) {
+        const { mode, agentInfo, additionalInstructions, compressionHistory, tools, toolNames, taskList } = config;
+        let finalAdditionalInstructions = additionalInstructions || '';
+        if (compressionHistory && compressionHistory.trim().length > 0) {
+            const formattedCompressionContext = this.formatCompressionContext(compressionHistory);
+            if (finalAdditionalInstructions.trim().length > 0) {
+                finalAdditionalInstructions = finalAdditionalInstructions + '\n\n' + formattedCompressionContext;
+            }
+            else {
+                finalAdditionalInstructions = formattedCompressionContext;
+            }
+        }
+        return frame_agent_sdk_1.PromptBuilder.buildSystemPrompt({
+            mode,
+            agentInfo,
+            additionalInstructions: finalAdditionalInstructions,
+            tools,
+            toolNames,
+            taskList
+        });
+    }
+    static buildSystemPromptWithCompression(mode, agentInfo, compressionHistory, options) {
+        return this.buildSystemPrompt({
+            mode,
+            agentInfo,
+            compressionHistory,
+            ...options
+        });
+    }
+    static addCompressionToPrompt(existingPrompt, compressionHistory) {
+        if (!compressionHistory || compressionHistory.trim().length === 0) {
+            return existingPrompt;
+        }
+        const compressionSection = [
+            '---',
+            '',
+            '## Context History',
+            '',
+            compressionHistory.trim()
+        ].join('\n');
+        const additionalInstructionsIndex = existingPrompt.indexOf('## Additional Instructions');
+        if (additionalInstructionsIndex > -1) {
+            const before = existingPrompt.substring(0, additionalInstructionsIndex);
+            const after = existingPrompt.substring(additionalInstructionsIndex);
+            return before + compressionSection + '\n\n' + after;
+        }
+        else {
+            return existingPrompt + '\n\n' + compressionSection;
+        }
+    }
+    static removeCompressionFromPrompt(prompt) {
+        const compressionSectionStart = prompt.indexOf('## Context History');
+        if (compressionSectionStart === -1) {
+            return prompt;
+        }
+        const compressionSectionContent = prompt.substring(compressionSectionStart);
+        const nextSectionIndex = compressionSectionContent.indexOf('\n---', 3);
+        if (nextSectionIndex > -1) {
+            const before = prompt.substring(0, compressionSectionStart);
+            const after = compressionSectionContent.substring(nextSectionIndex + 4);
+            return before + after;
+        }
+        else {
+            return prompt.substring(0, compressionSectionStart).trim();
+        }
+    }
+    static hasCompressionContext(prompt) {
+        return prompt.includes('## Context History');
+    }
+    static extractCompressionContext(prompt) {
+        const compressionSectionStart = prompt.indexOf('## Context History');
+        if (compressionSectionStart === -1) {
+            return null;
+        }
+        const compressionSectionContent = prompt.substring(compressionSectionStart + '## Context History'.length);
+        const endOfSectionIndex = compressionSectionContent.indexOf('\n---');
+        if (endOfSectionIndex > -1) {
+            return compressionSectionContent.substring(1, endOfSectionIndex).trim();
+        }
+        else {
+            return compressionSectionContent.substring(1).trim();
+        }
+    }
+    static buildDebugPrompt(config) {
+        const prompt = this.buildSystemPrompt(config);
+        logger_1.logger.debug('[CLIPromptBuilder] Prompt construído:', {
+            mode: config.mode,
+            hasCompression: !!config.compressionHistory,
+            hasAdditionalInstructions: !!config.additionalInstructions,
+            hasTools: !!(config.tools || config.toolNames),
+            promptLength: prompt.length
+        });
+        return prompt;
+    }
+}
+exports.CLIPromptBuilder = CLIPromptBuilder;
+function createDefaultPromptConfig(mode, agentInfo, additionalInstructions) {
+    return {
+        mode,
+        agentInfo,
+        additionalInstructions
+    };
+}
+function createCompressionPromptConfig(mode, agentInfo, compressionHistory, additionalInstructions) {
+    return {
+        mode,
+        agentInfo,
+        additionalInstructions,
+        compressionHistory
+    };
+}

package/dist/infrastructure/config/agentConfig.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/infrastructure/config/agentConfig.js

@@ -0,0 +1,134 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAgentConfig = loadAgentConfig;
+exports.clearConfigCache = clearConfigCache;
+exports.reloadConfig = reloadConfig;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logger_1 = require("../../infrastructure/logging/logger");
+let configFileCache = null;
+const ENV_VAR_REGEX = /\$\{([^}:]+)(?::-([^}]*))?\}/g;
+function substituteEnvVars(value) {
+    if (typeof value !== 'string') {
+        return value;
+    }
+    return value.replace(ENV_VAR_REGEX, (_match, varName, defaultValue) => {
+        const envValue = process.env[varName];
+        if (envValue !== undefined) {
+            return envValue;
+        }
+        if (defaultValue !== undefined) {
+            return defaultValue;
+        }
+        return '';
+    });
+}
+function toNumberIfPossible(value) {
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (/^-?\d+\.?\d*$/.test(trimmed)) {
+            return parseFloat(trimmed);
+        }
+        if (trimmed === 'true')
+            return true;
+        if (trimmed === 'false')
+            return false;
+    }
+    return value;
+}
+function substituteEnvVarsRecursive(config) {
+    if (typeof config === 'string') {
+        const substituted = substituteEnvVars(config);
+        return toNumberIfPossible(substituted);
+    }
+    if (Array.isArray(config)) {
+        return config.map(item => substituteEnvVarsRecursive(item));
+    }
+    if (config !== null && typeof config === 'object') {
+        const result = {};
+        for (const [key, value] of Object.entries(config)) {
+            result[key] = substituteEnvVarsRecursive(value);
+        }
+        return result;
+    }
+    return config;
+}
+function loadConfigFile() {
+    if (configFileCache !== null) {
+        return configFileCache;
+    }
+    const configPath = path.join(process.cwd(), '.code', 'config.json');
+    if (!fs.existsSync(configPath)) {
+        logger_1.logger.debug('[agentConfig] Arquivo .code/config.json não encontrado, usando apenas ENV');
+        return null;
+    }
+    try {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        const parsed = JSON.parse(content);
+        configFileCache = parsed;
+        logger_1.logger.debug('[agentConfig] Arquivo .code/config.json carregado com sucesso');
+        return parsed;
+    }
+    catch (error) {
+        logger_1.logger.error('[agentConfig] Erro ao carregar .code/config.json:', error);
+        return null;
+    }
+}
+function loadAgentConfig(agentName) {
+    const configFile = loadConfigFile();
+    if (!configFile) {
+        return {
+            fromConfigFile: false
+        };
+    }
+    const agentSpecific = configFile.agents?.[agentName];
+    const merged = {
+        ...(configFile.defaults || {}),
+        ...(agentSpecific || {})
+    };
+    const resolved = substituteEnvVarsRecursive(merged);
+    return {
+        ...resolved,
+        fromConfigFile: true
+    };
+}
+function clearConfigCache() {
+    configFileCache = null;
+}
+function reloadConfig() {
+    clearConfigCache();
+    loadConfigFile();
+}

package/dist/infrastructure/config/config.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/infrastructure/config/config.js

@@ -0,0 +1,112 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.loadConfigSync = loadConfigSync;
+const dotenv = __importStar(require("dotenv"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+let envLoaded = false;
+function ensureEnvLoaded() {
+    if (envLoaded)
+        return;
+    dotenv.config();
+    const localEnvPath = (0, path_1.join)(process.cwd(), '.env.local');
+    if ((0, fs_1.existsSync)(localEnvPath)) {
+        dotenv.config({ path: localEnvPath });
+    }
+    envLoaded = true;
+}
+async function loadConfig() {
+    ensureEnvLoaded();
+    return {
+        provider: process.env.LLM_PROVIDER || 'openai',
+        apiKey: process.env.LLM_API_KEY || '',
+        baseURL: process.env.LLM_BASE_URL,
+        vision: {
+            supportsVision: process.env.LLM_SUPPORTS_VISION === 'true',
+            provider: process.env.LLM_VISION_PROVIDER || process.env.LLM_PROVIDER || 'openai',
+            apiKey: process.env.LLM_VISION_API_KEY || process.env.LLM_API_KEY || '',
+            baseURL: process.env.LLM_VISION_BASE_URL || process.env.LLM_BASE_URL,
+            model: process.env.LLM_VISION_MODEL || process.env.LLM_DEFAULT_MODEL
+        },
+        defaults: {
+            model: process.env.LLM_DEFAULT_MODEL || 'gpt-4o-mini',
+            maxTokens: parseInt(process.env.LLM_MAX_OUTPUT_TOKENS || '4096'),
+            maxContextTokens: parseInt(process.env.LLM_MAX_TOKENS || '128000'),
+            temperature: parseFloat(process.env.LLM_TEMPERATURE || '0.7')
+        },
+        compression: {
+            enabled: process.env.COMPRESSION_ENABLED !== 'false',
+            threshold: parseFloat(process.env.COMPRESSION_THRESHOLD || '0.8'),
+            maxCount: parseInt(process.env.COMPRESSION_MAX_COUNT || '5'),
+            maxTokens: parseInt(process.env.COMPRESSION_MAX_TOKENS || '300'),
+            model: process.env.COMPRESSION_MODEL,
+            logging: process.env.COMPRESSION_LOGGING !== 'false',
+            persist: process.env.COMPRESSION_PERSIST !== 'false'
+        },
+        tools: {
+            mcpEnabled: process.env.MCP_TOOLS_ENABLED !== 'false',
+            agentMode: process.env.AGENT_MODE === 'autonomous' ? 'autonomous' : 'interactive'
+        }
+    };
+}
+function loadConfigSync() {
+    ensureEnvLoaded();
+    return {
+        provider: process.env.LLM_PROVIDER || 'openai',
+        apiKey: process.env.LLM_API_KEY || '',
+        baseURL: process.env.LLM_BASE_URL,
+        defaults: {
+            model: process.env.LLM_DEFAULT_MODEL || 'gpt-4o-mini',
+            maxTokens: parseInt(process.env.LLM_MAX_OUTPUT_TOKENS || '4096'),
+            maxContextTokens: parseInt(process.env.LLM_MAX_TOKENS || '128000'),
+            temperature: parseFloat(process.env.LLM_TEMPERATURE || '0.7')
+        },
+        compression: {
+            enabled: process.env.COMPRESSION_ENABLED !== 'false',
+            threshold: parseFloat(process.env.COMPRESSION_THRESHOLD || '0.8'),
+            maxCount: parseInt(process.env.COMPRESSION_MAX_COUNT || '5'),
+            maxTokens: parseInt(process.env.COMPRESSION_MAX_TOKENS || '300'),
+            model: process.env.COMPRESSION_MODEL,
+            logging: process.env.COMPRESSION_LOGGING !== 'false',
+            persist: process.env.COMPRESSION_PERSIST !== 'false'
+        },
+        tools: {
+            mcpEnabled: process.env.MCP_TOOLS_ENABLED !== 'false',
+            agentMode: process.env.AGENT_MODE === 'autonomous' ? 'autonomous' : 'interactive'
+        }
+    };
+}

package/dist/infrastructure/config/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfigSync = exports.loadConfig = void 0;
+var config_1 = require("./config");
+Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return config_1.loadConfig; } });
+Object.defineProperty(exports, "loadConfigSync", { enumerable: true, get: function () { return config_1.loadConfigSync; } });

package/dist/infrastructure/logging/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return logger_1.logger; } });

package/dist/infrastructure/logging/logger.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/infrastructure/logging/logger.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const isDebug = process.env.DEBUG === 'True' || process.env.DEBUG === 'true';
+const isInfo = process.env.INFO === 'True' || process.env.INFO === 'true';
+const shouldShowInfo = isDebug || isInfo;
+const shouldShowDebug = isDebug;
+exports.logger = {
+    info: (message, ...args) => {
+        if (shouldShowInfo) {
+            console.log(`[INFO] ${message}`, ...args);
+            if (process.stdout.write)
+                process.stdout.write('');
+        }
+    },
+    warn: (message, ...args) => {
+        console.warn(`[WARN] ${message}`, ...args);
+        if (process.stdout.write)
+            process.stdout.write('');
+    },
+    error: (message, ...args) => {
+        console.error(`[ERROR] ${message}`, ...args);
+        if (process.stderr.write)
+            process.stderr.write('');
+    },
+    debug: (message, ...args) => {
+        if (shouldShowDebug) {
+            console.log(`[DEBUG] ${message}`, ...args);
+            if (process.stdout.write)
+                process.stdout.write('');
+        }
+    }
+};

package/dist/infrastructure/logging/raw-output-logger.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRawLlmOutputEnabled = isRawLlmOutputEnabled;
+exports.logRawLlmOutput = logRawLlmOutput;
+exports.instrumentGraphForRawLlmOutput = instrumentGraphForRawLlmOutput;
+function envTruthy(value) {
+    if (!value)
+        return false;
+    const normalized = value.trim().toLowerCase();
+    return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
+}
+function isRawLlmOutputEnabled() {
+    return envTruthy(process.env.DEBUG_LLM_RAW_OUTPUT) || envTruthy(process.env.DEBUG_LLM_RAW);
+}
+function logRawLlmOutput(agentLabel, output) {
+    const header = `[LLM_RAW][${agentLabel}] (${output.length} chars)`;
+    console.log(`\n${header}\n${output}\n`);
+}
+function instrumentGraphForRawLlmOutput(graph, agentLabel) {
+    if (!isRawLlmOutputEnabled())
+        return graph;
+    const nodeId = 'agent';
+    const original = graph.nodes?.[nodeId];
+    if (!original)
+        return graph;
+    graph.nodes[nodeId] = async (state, engine) => {
+        const result = await original(state, engine);
+        const output = result?.lastModelOutput;
+        if (typeof output === 'string' && output.length > 0) {
+            logRawLlmOutput(agentLabel, output);
+        }
+        return result;
+    };
+    return graph;
+}

package/dist/infrastructure/skills/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillLoader = void 0;
+var loader_1 = require("./loader");
+Object.defineProperty(exports, "SkillLoader", { enumerable: true, get: function () { return loader_1.SkillLoader; } });

package/dist/infrastructure/skills/loader.js

@@ -0,0 +1,104 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillLoader = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class SkillLoader {
+    constructor(skillsDir) {
+        this.skillsDir = skillsDir || path.join(process.cwd(), '.code');
+    }
+    parseSkillFile(filePath) {
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const lines = content.split('\n');
+            if (lines[0].trim() !== '---')
+                return null;
+            const frontmatter = {};
+            let i = 1;
+            for (; i < lines.length; i++) {
+                if (lines[i].trim() === '---')
+                    break;
+                const [key, ...valueParts] = lines[i].split(':');
+                if (key && valueParts.length > 0) {
+                    const value = valueParts.join(':').trim();
+                    const cleanValue = value.replace(/^['"]|['"]$/g, '');
+                    if (value.startsWith('[') && value.endsWith(']')) {
+                        frontmatter[key.trim()] = value.slice(1, -1).split(',').map(s => s.trim().replace(/^['"]|['"]$/g, ''));
+                    }
+                    else {
+                        frontmatter[key.trim()] = cleanValue;
+                    }
+                }
+            }
+            if (!frontmatter.name)
+                return null;
+            return {
+                name: frontmatter.name,
+                description: frontmatter.description || '',
+                keywords: frontmatter.keywords || [],
+                path: filePath.replace(/\\/g, '/')
+            };
+        }
+        catch (e) {
+            console.error(`Erro ao ler skill ${filePath}:`, e);
+            return null;
+        }
+    }
+    loadAllSkills() {
+        const skills = [];
+        if (!fs.existsSync(this.skillsDir))
+            return skills;
+        const entries = fs.readdirSync(this.skillsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const skillPath = path.join(this.skillsDir, entry.name, 'SKILL.md');
+                if (fs.existsSync(skillPath)) {
+                    const skill = this.parseSkillFile(skillPath);
+                    if (skill)
+                        skills.push(skill);
+                }
+            }
+            else if (entry.name.endsWith('.md')) {
+                const skillPath = path.join(this.skillsDir, entry.name);
+                const skill = this.parseSkillFile(skillPath);
+                if (skill)
+                    skills.push(skill);
+            }
+        }
+        return skills;
+    }
+}
+exports.SkillLoader = SkillLoader;

package/dist/infrastructure/telemetry/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTraceEventForTerminal = exports.ConsoleTraceSink = exports.createCliTelemetry = void 0;
+var telemetryConfig_1 = require("./telemetryConfig");
+Object.defineProperty(exports, "createCliTelemetry", { enumerable: true, get: function () { return telemetryConfig_1.createCliTelemetry; } });
+var traceSinkConsole_1 = require("./traceSinkConsole");
+Object.defineProperty(exports, "ConsoleTraceSink", { enumerable: true, get: function () { return traceSinkConsole_1.ConsoleTraceSink; } });
+var traceEventFormatter_1 = require("./traceEventFormatter");
+Object.defineProperty(exports, "formatTraceEventForTerminal", { enumerable: true, get: function () { return traceEventFormatter_1.formatTraceEventForTerminal; } });

package/dist/infrastructure/telemetry/telemetry.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/infrastructure/telemetry/telemetryConfig.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCliTelemetry = createCliTelemetry;
+const frame_agent_sdk_1 = require("@ericnunes/frame-agent-sdk");
+const traceSinkConsole_1 = require("./traceSinkConsole");
+function readBool(value, defaultValue) {
+    if (value == null)
+        return defaultValue;
+    if (value === '1')
+        return true;
+    if (value === '0')
+        return false;
+    return value.toLowerCase() === 'true';
+}
+function createCliTelemetry() {
+    const enabled = readBool(process.env.TELEMETRY_ENABLED, true);
+    const verbose = readBool(process.env.TELEMETRY_VERBOSE, readBool(process.env.DEBUG, false));
+    const level = (process.env.TELEMETRY_LEVEL ?? (verbose ? 'debug' : 'info'));
+    const telemetry = {
+        enabled,
+        level,
+        persistToState: false,
+        includePrompts: false,
+        maxPayloadChars: 4000,
+        maxEvents: 200,
+    };
+    const consoleSink = new traceSinkConsole_1.ConsoleTraceSink({ verbose });
+    const trace = new frame_agent_sdk_1.MultiplexTraceSink([consoleSink]);
+    return { trace, telemetry, verbose };
+}