@ericnunes/frame-code-cli 0.0.1

package/dist/cli/commands/multi-agent.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processMultiAgentInput = processMultiAgentInput;
+exports.createMultiAgentCommand = createMultiAgentCommand;
+const commander_1 = require("commander");
+const fs_1 = require("fs");
+const logger_1 = require("../../infrastructure/logging/logger");
+const frame_agent_sdk_1 = require("@ericnunes/frame-agent-sdk");
+const tools_1 = require("../../tools");
+const config_1 = require("../../infrastructure/config");
+const registry_1 = require("../../agent-runtime/registry");
+const reader_1 = require("../input/reader");
+const telemetry_1 = require("../../infrastructure/telemetry");
+const attachments_1 = require("../input/images/attachments");
+async function processMultiAgentInput(input, options) {
+    try {
+        logger_1.logger.info('[MultiAgent] Starting multi-agent execution');
+        const normalizedInput = input.trim();
+        const isPlaceholder = normalizedInput.length === 0;
+        if (isPlaceholder) {
+            logger_1.logger.warn('[MultiAgent] Empty input detected, using default task');
+            input = 'Explique como usar o frame-code-cli com base no codigo atual. Nao modifique arquivos e nao use ferramentas.';
+        }
+        if (options.verbose) {
+            logger_1.logger.info(`[MultiAgent] Input received: ${input.substring(0, 200)}...`);
+        }
+        await (0, config_1.loadConfig)();
+        const { trace, telemetry } = (0, telemetry_1.createCliTelemetry)();
+        const registry = registry_1.AgentRegistry.getInstance();
+        const previousMode = process.env.AGENT_MODE;
+        process.env.AGENT_MODE = 'autonomous';
+        await (0, tools_1.initializeTools)({ allowAskUser: true });
+        if (previousMode !== undefined) {
+            process.env.AGENT_MODE = previousMode;
+        }
+        const graph = await registry.createEngine('supervisor', {
+            trace,
+            telemetry
+        });
+        const imagePaths = options._imagePaths ?? [];
+        const imageDetail = options.imageDetail ?? 'auto';
+        const initialState = {
+            messages: [],
+            data: {
+                input,
+                shared: {
+                    ...(imagePaths.length ? { imagePaths, imageDetail } : {})
+                },
+                ...(options._runId ? { runId: options._runId } : {})
+            },
+            status: frame_agent_sdk_1.GraphStatus.RUNNING
+        };
+        const result = await graph.execute(initialState);
+        if (result.status === frame_agent_sdk_1.GraphStatus.ERROR) {
+            throw new Error(`Execution error: ${result.state.logs?.join('\n') || 'Unknown error'}`);
+        }
+        if (result.status !== frame_agent_sdk_1.GraphStatus.FINISHED) {
+            return `Execution finished with status: ${result.status}`;
+        }
+        const shared = result.state.data?.shared;
+        const output = shared?.output;
+        if (typeof output === 'string' && output.trim().length > 0) {
+            return `[supervisor] ${output}`;
+        }
+        return '[supervisor] Execution finished without captured output';
+    }
+    catch (error) {
+        logger_1.logger.error('[MultiAgent] Execution failed:', error);
+        throw error;
+    }
+}
+function createMultiAgentCommand() {
+    const command = new commander_1.Command('multi-agent');
+    const collect = (value, previous) => {
+        return [...(previous ?? []), value];
+    };
+    command
+        .description('Run multi-agent planner + implementer flow')
+        .argument('[additional-input]', 'Additional text with priority over input file')
+        .option('-i, --input-file <file>', 'Input file with prompt')
+        .option('-o, --output-file <file>', 'Output file for response')
+        .option('-l, --log-file <file>', 'Log file for details')
+        .option('-v, --verbose', 'Verbose mode')
+        .option('--image <path>', 'Caminho de imagem local (pode repetir)', collect, [])
+        .option('--image-detail <low|high|auto>', 'Nivel de detalhe para imagem (low|high|auto)', 'auto')
+        .action(async (additionalInput, options) => {
+        try {
+            if (options.inputFile) {
+                logger_1.logger.info(`[MultiAgent] Reading input from: ${options.inputFile}`);
+            }
+            if (additionalInput) {
+                logger_1.logger.info(`[MultiAgent] Adding input: ${additionalInput.substring(0, 100)}...`);
+            }
+            if (!options.inputFile && !additionalInput) {
+                logger_1.logger.info('[MultiAgent] Reading input from stdin');
+            }
+            const input = await (0, reader_1.readCliInput)({ inputFile: options.inputFile, additionalInput });
+            if (options.image && options.image.length > 0) {
+                await (0, attachments_1.cleanupAttachmentsRoot)((0, attachments_1.getAttachmentsCleanupConfigFromEnv)());
+                const staged = await (0, attachments_1.stageImageAttachments)({ imagePaths: options.image });
+                options._runId = staged.runId;
+                options._imagePaths = staged.stagedPaths;
+            }
+            const result = await processMultiAgentInput(input, options);
+            if (options.outputFile) {
+                logger_1.logger.info(`[MultiAgent] Writing output to: ${options.outputFile}`);
+                (0, fs_1.writeFileSync)(options.outputFile, result, 'utf-8');
+            }
+            else {
+                console.log(result);
+            }
+            if (options.logFile) {
+                (0, fs_1.writeFileSync)(options.logFile, 'Detailed logs not implemented', 'utf-8');
+            }
+            logger_1.logger.info('[MultiAgent] Execution completed');
+            process.exit(0);
+        }
+        catch (error) {
+            logger_1.logger.error('[MultiAgent] Fatal error:', error);
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            if (options.outputFile) {
+                (0, fs_1.writeFileSync)(options.outputFile, `## Error\n\n${errorMessage}`, 'utf-8');
+            }
+            else {
+                console.error('Error:', errorMessage);
+            }
+            process.exit(1);
+        }
+    });
+    return command;
+}

package/dist/cli/index.js

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./commands"), exports);
+__exportStar(require("./input"), exports);

package/dist/cli/input/images/attachments.js

@@ -0,0 +1,173 @@
+"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.createRunId = createRunId;
+exports.getAttachmentsRoot = getAttachmentsRoot;
+exports.getAttachmentsCleanupConfigFromEnv = getAttachmentsCleanupConfigFromEnv;
+exports.cleanupAttachmentsRoot = cleanupAttachmentsRoot;
+exports.stageImageAttachments = stageImageAttachments;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+function createRunId(now = new Date()) {
+    const pad = (n) => String(n).padStart(2, '0');
+    const ts = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+    const pid = process.pid;
+    const rand = (0, crypto_1.randomBytes)(3).toString('hex');
+    return `${ts}-${pid}-${rand}`;
+}
+function getAttachmentsRoot() {
+    return path.resolve(process.cwd(), 'tmp', 'attachments');
+}
+function parseNumberEnv(name) {
+    const raw = process.env[name];
+    if (!raw)
+        return undefined;
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function getAttachmentsCleanupConfigFromEnv() {
+    return {
+        retentionDays: parseNumberEnv('ATTACHMENTS_RETENTION_DAYS') ?? 7,
+        maxTotalMB: parseNumberEnv('ATTACHMENTS_MAX_TOTAL_MB') ?? 500,
+    };
+}
+async function safeRm(targetPath) {
+    try {
+        await fs_1.promises.rm(targetPath, { recursive: true, force: true });
+    }
+    catch {
+    }
+}
+async function cleanupAttachmentsRoot(config) {
+    const root = getAttachmentsRoot();
+    const retentionDays = config?.retentionDays ?? 7;
+    const maxTotalMB = config?.maxTotalMB ?? 500;
+    let entries;
+    try {
+        entries = await fs_1.promises.readdir(root, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    const now = Date.now();
+    const cutoffMs = retentionDays * 24 * 60 * 60 * 1000;
+    const dirs = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const fullPath = path.join(root, entry.name);
+        try {
+            const stat = await fs_1.promises.stat(fullPath);
+            const sizeBytes = await folderSizeBytes(fullPath);
+            dirs.push({ fullPath, name: entry.name, mtimeMs: stat.mtimeMs, sizeBytes });
+        }
+        catch {
+        }
+    }
+    for (const dir of dirs) {
+        if (now - dir.mtimeMs > cutoffMs) {
+            await safeRm(dir.fullPath);
+        }
+    }
+    const remaining = [];
+    let total = 0;
+    for (const dir of dirs) {
+        try {
+            const stat = await fs_1.promises.stat(dir.fullPath);
+            const sizeBytes = await folderSizeBytes(dir.fullPath);
+            remaining.push({ fullPath: dir.fullPath, mtimeMs: stat.mtimeMs, sizeBytes });
+            total += sizeBytes;
+        }
+        catch {
+        }
+    }
+    const maxBytes = maxTotalMB * 1024 * 1024;
+    if (total <= maxBytes)
+        return;
+    remaining.sort((a, b) => a.mtimeMs - b.mtimeMs);
+    for (const dir of remaining) {
+        if (total <= maxBytes)
+            break;
+        await safeRm(dir.fullPath);
+        total -= dir.sizeBytes;
+    }
+}
+async function folderSizeBytes(root) {
+    let total = 0;
+    const stack = [root];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current)
+            break;
+        let dirents;
+        try {
+            dirents = await fs_1.promises.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const dirent of dirents) {
+            const fullPath = path.join(current, dirent.name);
+            if (dirent.isDirectory()) {
+                stack.push(fullPath);
+            }
+            else if (dirent.isFile()) {
+                try {
+                    const stat = await fs_1.promises.stat(fullPath);
+                    total += stat.size;
+                }
+                catch {
+                }
+            }
+        }
+    }
+    return total;
+}
+async function stageImageAttachments(options) {
+    const runId = options.runId ?? createRunId();
+    const root = getAttachmentsRoot();
+    const runDir = path.join(root, runId);
+    await fs_1.promises.mkdir(runDir, { recursive: true });
+    const stagedPaths = [];
+    for (const imgPath of options.imagePaths) {
+        const absolute = path.isAbsolute(imgPath) ? imgPath : path.resolve(process.cwd(), imgPath);
+        const base = path.basename(absolute);
+        const target = path.join(runDir, base);
+        await fs_1.promises.copyFile(absolute, target);
+        stagedPaths.push(target);
+    }
+    return { runId, stagedPaths };
+}

package/dist/cli/input/images/imageInput.js

@@ -0,0 +1,77 @@
+"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.readFileAsDataUrl = readFileAsDataUrl;
+exports.buildMultimodalContent = buildMultimodalContent;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+function inferMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    switch (ext) {
+        case '.png':
+            return 'image/png';
+        case '.jpg':
+        case '.jpeg':
+            return 'image/jpeg';
+        case '.webp':
+            return 'image/webp';
+        case '.gif':
+            return 'image/gif';
+        case '.bmp':
+            return 'image/bmp';
+        default:
+            return 'application/octet-stream';
+    }
+}
+async function readFileAsDataUrl(absolutePath) {
+    const buffer = await fs_1.promises.readFile(absolutePath);
+    const mimeType = inferMimeType(absolutePath);
+    const hash = (0, crypto_1.createHash)('sha256').update(buffer).digest('hex');
+    const base64 = buffer.toString('base64');
+    return {
+        url: `data:${mimeType};base64,${base64}`,
+        mimeType,
+        bytes: buffer.length,
+        hash,
+    };
+}
+function buildMultimodalContent(options) {
+    const detail = options.detail ?? 'auto';
+    return [
+        { type: 'text', text: options.text },
+        { type: 'image_url', image_url: { url: options.dataUrl, detail } },
+    ];
+}

package/dist/cli/input/images/readImageAttachment.js

@@ -0,0 +1,56 @@
+"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.maybeAttachReadImageToContext = maybeAttachReadImageToContext;
+const path = __importStar(require("path"));
+const imageInput_1 = require("./imageInput");
+async function maybeAttachReadImageToContext(options) {
+    const metadataObj = (options.metadata ?? {});
+    const readImage = (metadataObj.readImage ?? null);
+    const imagePath = readImage?.path?.trim();
+    if (!imagePath)
+        return false;
+    const dataUrl = await (0, imageInput_1.readFileAsDataUrl)(imagePath);
+    const detail = readImage?.detail ?? 'auto';
+    const shortName = path.basename(imagePath);
+    const prefix = options.textPrefix?.trim() || 'Imagem anexada (use-a para tomar decisōes no próximo passo).';
+    const text = `${prefix}\nArquivo: ${shortName}`;
+    const contentParts = (0, imageInput_1.buildMultimodalContent)({ text, dataUrl: dataUrl.url, detail });
+    options.engine.addMessage({
+        role: 'user',
+        content: contentParts,
+    });
+    return true;
+}

package/dist/cli/input/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maybeAttachReadImageToContext = exports.buildMultimodalContent = exports.readFileAsDataUrl = exports.getAttachmentsCleanupConfigFromEnv = exports.stageImageAttachments = exports.cleanupAttachmentsRoot = exports.readCliInput = void 0;
+var reader_1 = require("./reader");
+Object.defineProperty(exports, "readCliInput", { enumerable: true, get: function () { return reader_1.readCliInput; } });
+var attachments_1 = require("./images/attachments");
+Object.defineProperty(exports, "cleanupAttachmentsRoot", { enumerable: true, get: function () { return attachments_1.cleanupAttachmentsRoot; } });
+Object.defineProperty(exports, "stageImageAttachments", { enumerable: true, get: function () { return attachments_1.stageImageAttachments; } });
+Object.defineProperty(exports, "getAttachmentsCleanupConfigFromEnv", { enumerable: true, get: function () { return attachments_1.getAttachmentsCleanupConfigFromEnv; } });
+var imageInput_1 = require("./images/imageInput");
+Object.defineProperty(exports, "readFileAsDataUrl", { enumerable: true, get: function () { return imageInput_1.readFileAsDataUrl; } });
+Object.defineProperty(exports, "buildMultimodalContent", { enumerable: true, get: function () { return imageInput_1.buildMultimodalContent; } });
+var readImageAttachment_1 = require("./images/readImageAttachment");
+Object.defineProperty(exports, "maybeAttachReadImageToContext", { enumerable: true, get: function () { return readImageAttachment_1.maybeAttachReadImageToContext; } });

package/dist/cli/input/reader.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCliInput = readCliInput;
+const fs_1 = require("fs");
+async function readStdinUtf8() {
+    const chunks = [];
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
+    await new Promise((resolve) => {
+        process.stdin.on('end', () => resolve());
+    });
+    return Buffer.concat(chunks).toString('utf-8');
+}
+async function readCliInput(options) {
+    let input = '';
+    if (options.inputFile) {
+        input = (0, fs_1.readFileSync)(options.inputFile, 'utf-8');
+    }
+    if (options.additionalInput) {
+        input = input ? `${input}\n\n${options.additionalInput}` : options.additionalInput;
+    }
+    if (!input) {
+        input = await readStdinUtf8();
+    }
+    return input;
+}