@ericnunes/frame-code-cli 0.0.1

package/dist/tools/native/read-image.js

@@ -0,0 +1,140 @@
+"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.readImageTool = void 0;
+const frame_agent_sdk_1 = require("@ericnunes/frame-agent-sdk");
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+class ReadImageParamsSchema {
+}
+ReadImageParamsSchema.schemaProperties = {
+    source: 'string',
+    'path?': 'string',
+    'region?': 'object',
+    'detail?': 'string',
+    'maxBytes?': 'number',
+};
+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';
+    }
+}
+function toSafeAbsolutePath(inputPath) {
+    return path.isAbsolute(inputPath) ? inputPath : path.resolve(process.cwd(), inputPath);
+}
+exports.readImageTool = new class extends frame_agent_sdk_1.ToolBase {
+    constructor() {
+        super(...arguments);
+        this.name = 'read_image';
+        this.description = 'Read an image from the host environment. This tool only returns a safe reference + metadata; the host attaches the image to the next LLM call.';
+        this.parameterSchema = ReadImageParamsSchema;
+    }
+    async execute(params) {
+        if (params.source !== 'path') {
+            return {
+                observation: `Unsupported source "${params.source}". Only "path" is supported in frame-code-cli.`,
+                metadata: {
+                    readImage: {
+                        path: '',
+                        mimeType: '',
+                        bytes: 0,
+                        detail: params.detail,
+                    },
+                },
+            };
+        }
+        const rawPath = params.path?.trim();
+        if (!rawPath) {
+            return {
+                observation: 'Missing required param: path (when source="path").',
+                metadata: {
+                    readImage: {
+                        path: '',
+                        mimeType: '',
+                        bytes: 0,
+                        detail: params.detail,
+                    },
+                },
+            };
+        }
+        const absolutePath = toSafeAbsolutePath(rawPath);
+        const stat = await fs_1.promises.stat(absolutePath);
+        const bytes = stat.size;
+        const maxBytes = Number.isFinite(params.maxBytes) ? Math.max(1, Number(params.maxBytes)) : 12 * 1024 * 1024;
+        if (bytes > maxBytes) {
+            return {
+                observation: `Image too large (${bytes} bytes). Max allowed is ${maxBytes} bytes.`,
+                metadata: {
+                    readImage: {
+                        path: absolutePath,
+                        mimeType: inferMimeType(absolutePath),
+                        bytes,
+                        detail: params.detail,
+                    },
+                },
+            };
+        }
+        const buffer = await fs_1.promises.readFile(absolutePath);
+        const hash = (0, crypto_1.createHash)('sha256').update(buffer).digest('hex');
+        const mimeType = inferMimeType(absolutePath);
+        const detail = params.detail;
+        return {
+            observation: `Image loaded. path="${absolutePath}", mimeType="${mimeType}", bytes=${bytes}, sha256=${hash.slice(0, 12)}…`,
+            metadata: {
+                readImage: {
+                    path: absolutePath,
+                    mimeType,
+                    bytes,
+                    detail,
+                    hash,
+                },
+            },
+        };
+    }
+}();

package/dist/tools/registry/ToolInitializer.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolRegistry = void 0;
+exports.initializeTools = initializeTools;
+const frame_agent_sdk_1 = require("@ericnunes/frame-agent-sdk");
+Object.defineProperty(exports, "toolRegistry", { enumerable: true, get: function () { return frame_agent_sdk_1.toolRegistry; } });
+const native_1 = require("../native");
+const register_1 = require("../mcp/register");
+const logger_1 = require("../../infrastructure/logging/logger");
+const config_1 = require("../../infrastructure/config");
+const toolFilter_1 = require("./toolFilter");
+let toolsInitialized = false;
+async function initializeTools(options) {
+    if (toolsInitialized) {
+        return;
+    }
+    (0, config_1.loadConfigSync)();
+    const filterConfig = (() => {
+        const base = (0, toolFilter_1.getToolFilterConfig)();
+        if (typeof options?.allowAskUser === 'boolean') {
+            return { ...base, allowAskUser: options.allowAskUser };
+        }
+        return base;
+    })();
+    const allTools = [
+        native_1.searchTool,
+        native_1.listDirectoryTool,
+        native_1.readImageTool,
+        native_1.fileCreateTool,
+        native_1.fileEditTool,
+        native_1.fileReadTool,
+        native_1.terminalTool,
+        native_1.sleepTool,
+        native_1.fileOutlineTool,
+        native_1.listCapabilitiesTool,
+        native_1.enableCapabilityTool,
+        native_1.toDoIstTool,
+        new frame_agent_sdk_1.FinalAnswerTool(),
+        new frame_agent_sdk_1.CallFlowTool(new frame_agent_sdk_1.FlowRunnerImpl(new frame_agent_sdk_1.FlowRegistryImpl(), {}))
+    ];
+    if (filterConfig.allowAskUser) {
+        allTools.push(new frame_agent_sdk_1.AskUserTool());
+    }
+    const filteredTools = allTools.filter(tool => (0, toolFilter_1.shouldIncludeTool)(tool, filterConfig));
+    filteredTools.forEach(tool => {
+        try {
+            frame_agent_sdk_1.toolRegistry.register(tool);
+        }
+        catch (error) {
+            logger_1.logger.warn(`Falha ao registrar ferramenta ${tool.name}:`, error);
+        }
+    });
+    if (filterConfig.mcpToolsEnabled) {
+        try {
+            await (0, register_1.registerMcpTools)();
+        }
+        catch (err) {
+            logger_1.logger.error('Erro ao registrar MCP tools:', err);
+        }
+    }
+    toolsInitialized = true;
+}

package/dist/tools/registry/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getToolFilterConfig = exports.filterToolsByPolicy = exports.filterTools = exports.shouldIncludeTool = exports.toolRegistry = exports.initializeTools = void 0;
+var ToolInitializer_1 = require("./ToolInitializer");
+Object.defineProperty(exports, "initializeTools", { enumerable: true, get: function () { return ToolInitializer_1.initializeTools; } });
+Object.defineProperty(exports, "toolRegistry", { enumerable: true, get: function () { return ToolInitializer_1.toolRegistry; } });
+var toolFilter_1 = require("./toolFilter");
+Object.defineProperty(exports, "shouldIncludeTool", { enumerable: true, get: function () { return toolFilter_1.shouldIncludeTool; } });
+Object.defineProperty(exports, "filterTools", { enumerable: true, get: function () { return toolFilter_1.filterTools; } });
+Object.defineProperty(exports, "filterToolsByPolicy", { enumerable: true, get: function () { return toolFilter_1.filterToolsByPolicy; } });
+Object.defineProperty(exports, "getToolFilterConfig", { enumerable: true, get: function () { return toolFilter_1.getToolFilterConfig; } });

package/dist/tools/registry/toolFilter.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getToolFilterConfig = getToolFilterConfig;
+exports.shouldIncludeTool = shouldIncludeTool;
+exports.filterTools = filterTools;
+exports.filterToolsByPolicy = filterToolsByPolicy;
+function getToolFilterConfig() {
+    const mode = process.env.AGENT_MODE === 'autonomous' ? 'autonomous' : 'interactive';
+    return {
+        mode,
+        mcpToolsEnabled: process.env.MCP_TOOLS_ENABLED !== 'false',
+        excludedTools: getExcludedToolsList(),
+        allowAskUser: mode !== 'autonomous'
+    };
+}
+function getExcludedToolsList() {
+    const excluded = process.env.EXCLUDED_TOOLS || '';
+    return excluded.split(',').map(tool => tool.trim()).filter(tool => tool.length > 0);
+}
+function shouldIncludeTool(tool, config) {
+    if (config.excludedTools.includes(tool.name)) {
+        return false;
+    }
+    if (!config.allowAskUser && (tool.name === 'ask_user' || tool.name === 'askUser')) {
+        return false;
+    }
+    if (!config.mcpToolsEnabled && tool.name.startsWith('mcp_')) {
+        return false;
+    }
+    if (tool.name === 'approval') {
+        return false;
+    }
+    return true;
+}
+function filterTools(tools, config) {
+    const filterConfig = config || getToolFilterConfig();
+    return tools.filter(tool => shouldIncludeTool(tool, filterConfig));
+}
+function filterToolsByPolicy(tools, policy, config) {
+    const base = filterTools(tools, config);
+    const allow = policy?.allow?.filter(Boolean);
+    const deny = policy?.deny?.filter(Boolean);
+    if (allow && allow.length > 0) {
+        const allowSet = new Set(allow);
+        return base.filter((tool) => allowSet.has(tool.name));
+    }
+    if (deny && deny.length > 0) {
+        const denySet = new Set(deny);
+        return base.filter((tool) => !denySet.has(tool.name));
+    }
+    return base;
+}

package/dist/tools/registry/toolRegistry.interface.js

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

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@ericnunes/frame-code-cli",
+  "version": "0.0.1",
+  "description": "CLI para interagir com agentes de codificação criados com o frame-agent-sdk",
+  "main": "dist/index.js",
+  "bin": {
+    "frame-code": "dist/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ericnunes/frame-code-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ericnunes/frame-code-cli/issues"
+  },
+  "homepage": "https://github.com/ericnunes/frame-code-cli#readme",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc && npm run copy:agents",
+    "copy:agents": "npx cpy \"src/content/agents/*.md\" \"dist/content/agents\"",
+    "dev": "ts-node src/index.ts",
+    "start": "node dist/index.js",
+    "autonomous": "node dist/index.js autonomous",
+    "multi-agent": "node dist/index.js multi-agent",
+    "test:mcp": "ts-node scripts/test-mcp.ts",
+    "interactive": "chmod +x src/scripts/capture-logs.sh && src/scripts/capture-logs.sh npm run dev interactive",
+    "dev:logs": "bash src/scripts/capture-logs.sh npm run dev interactive",
+    "dev:start": "npm run dev interactive",
+    "log:view": "tail -f server.log",
+    "log:clear": "rm -f server.log",
+    "log:stats": "ls -la server.log",
+    "clean": "rm -rf dist"
+  },
+  "keywords": [
+    "cli",
+    "agent",
+    "ai",
+    "framework"
+  ],
+  "author": "Eric Nunes",
+  "license": "SEE LICENSE IN LICENSE",
+  "dependencies": {
+    "@ericnunes/frame-agent-sdk": "^0.0.3",
+    "@modelcontextprotocol/sdk": "^1.23.0",
+    "@typescript-eslint/typescript-estree": "^8.48.0",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.1",
+    "dotenv": "^17.2.3",
+    "eventsource": "^4.1.0",
+    "fast-diff": "^1.3.0",
+    "glob": "^11.0.3",
+    "inquirer": "^12.9.6",
+    "openai": "^6.10.0",
+    "tree-kill": "^1.2.2"
+  },
+  "devDependencies": {
+    "@types/dotenv": "^6.1.1",
+    "@types/node": "^24.7.0",
+    "cpy-cli": "^6.0.0",
+    "nodemon": "^3.1.11",
+    "ts-node": "^10.9.2",
+    "ts-node-dev": "^2.0.0",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.9.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "directories": {
+    "doc": "docs",
+    "example": "examples"
+  },
+  "types": "./dist/index.d.ts"
+}