@2501-ai/cli
Version:
[](https://www.npmjs.com/package/@2501-ai/cli) [](https://www.2501.ai/research/full-humaneval-benchmark) [![Lic
277 lines (276 loc) • 12.4 kB
JavaScript
;
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;
};
})();
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.queryCommand = void 0;
const chalk_1 = __importDefault(require("chalk"));
const fs_1 = __importDefault(require("fs"));
const marked_1 = require("marked");
const marked_terminal_1 = require("marked-terminal");
const api_1 = require("../helpers/api");
const streams_1 = require("../helpers/streams");
const workspace_1 = require("../helpers/workspace");
const agentManager_1 = require("../managers/agentManager");
const configManager_1 = require("../managers/configManager");
const actions_1 = require("../utils/actions");
const conf_1 = require("../utils/conf");
const credentials_1 = require("../utils/credentials");
const files_1 = require("../utils/files");
const logger_1 = __importStar(require("../utils/logger"));
const loopDetection_1 = require("../utils/loopDetection");
const init_1 = require("./init");
const remoteExecutor_1 = require("../remoteExecution/remoteExecutor");
const telemetry_1 = require("../telemetry");
marked_1.marked.use((0, marked_terminal_1.markedTerminal)());
const logger = new logger_1.default();
const initializeAgentConfig = (resolvedWorkspace, options) => __awaiter(void 0, void 0, void 0, function* () {
let eligibleAgent = (0, conf_1.getEligibleAgent)(resolvedWorkspace);
let force = false;
if (!eligibleAgent) {
yield (0, init_1.initCommand)(Object.assign(Object.assign({}, options), { workspace: resolvedWorkspace }));
eligibleAgent = (0, conf_1.getEligibleAgent)(resolvedWorkspace);
force = true;
}
let workspaceChanged = false;
if (eligibleAgent) {
workspaceChanged = yield synchronizeWorkspace(eligibleAgent, resolvedWorkspace, force);
}
return { agentConfig: eligibleAgent, workspaceChanged };
});
const executeActions = (actions, agentManager) => __awaiter(void 0, void 0, void 0, function* () {
const results = [];
for (const action of actions) {
logger_1.default.debug('Action:', action);
const args = (0, actions_1.getFunctionArgs)(action);
if (args.command) {
args.command = credentials_1.credentialsService.replaceCredentialPlaceholders(args.command);
}
const taskTitle = args.answer || args.command || (args.url ? `Browsing: ${args.url}` : '');
logger.start(`${taskTitle} ${(0, streams_1.getActionPostfix)(action)}`);
const toolOutput = yield agentManager.executeAction(action, args);
logger_1.default.debug('Tool output:', toolOutput);
const subActionMessage = (0, streams_1.getSubActionMessage)(taskTitle, action, toolOutput.success);
if (toolOutput.success) {
logger.stop(subActionMessage, 0);
}
else {
logger.stop(`(failed) ${subActionMessage}`, 1);
}
results.push(toolOutput);
}
return results;
});
const synchronizeWorkspace = (agent_1, workspace_2, ...args_1) => __awaiter(void 0, [agent_1, workspace_2, ...args_1], void 0, function* (agent, workspace, force = false) {
var _a;
logger_1.default.debug('Synchronizing workspace:', workspace);
if ((_a = agent === null || agent === void 0 ? void 0 : agent.remote_exec) === null || _a === void 0 ? void 0 : _a.enabled) {
return false;
}
const { hash, diff } = yield (0, workspace_1.getWorkspaceHash)(workspace, agent.id);
logger_1.default.debug('Workspace diff:', { diff });
if (diff.isEmpty)
return false;
if (diff.hasChanges || force) {
logger.start('Synchronizing workspace');
logger_1.default.debug('Agent Workspace has changes, synchronizing...');
const files = yield (0, workspace_1.generateWorkspaceZip)(workspace, {
fileHashes: hash.fileHashes,
totalSize: hash.totalSize,
});
if (process.env.TFZO_NODE_ENV !== 'dev') {
fs_1.default.unlinkSync(files[0].path);
logger_1.default.debug('Agent : Workspace ZIP deleted:', files[0].path);
}
yield (0, api_1.indexFiles)(agent.id, files);
const newState = {
state_hash: hash.md5,
file_hashes: hash.fileHashes,
path: workspace,
agent_id: agent.id,
};
(0, workspace_1.writeWorkspaceState)(newState);
logger.stop('Workspace synchronized');
return true;
}
return false;
});
const handleReasoningSteps = (streamResponse) => {
streamResponse.on('data', (data) => {
if (!data.toString().includes('reasoning')) {
return;
}
try {
const res = JSON.parse(data.toString());
if (res.status === 'reasoning') {
let stepMessage = `Reasoning steps that will be followed:`;
for (const step of res.steps.steps) {
stepMessage += `\n${chalk_1.default.gray('│')} ${(0, streams_1.toItalic)(` └ ${step}`)}`;
}
logger.stop(stepMessage);
logger.start('Processing');
}
}
catch (_a) {
}
});
};
const parseAgentResponse = (agentResponse, stream) => __awaiter(void 0, void 0, void 0, function* () {
let actions = [];
let queryResponse = '';
if ((0, streams_1.isStreamingContext)(stream, agentResponse)) {
const res = yield (0, streams_1.parseStreamedResponse)(agentResponse);
if (res.actions.length)
actions = res.actions;
if (res.message)
queryResponse = res.message;
}
else {
if (agentResponse.actions)
actions = agentResponse.actions;
if (agentResponse.response)
queryResponse = agentResponse.response;
}
const completion = actions.find((a) => a.function === 'task_completed');
if (completion) {
return [
actions.filter((a) => a.function !== 'task_completed'),
completion.args.response || 'Task completed.',
];
}
return [actions, queryResponse];
});
const queryCommand = (query, options) => __awaiter(void 0, void 0, void 0, function* () {
var _a, _b, _c;
(0, telemetry_1.updateTelemetryContext)({ taskId: options.taskId, agentId: options.agentId });
logger_1.default.debug('Options:', options);
try {
const configManager = configManager_1.ConfigManager.instance;
const resolvedWorkspace = (0, workspace_1.resolveWorkspacePath)(options);
logger_1.default.debug('Workspace:', resolvedWorkspace);
const stream = (_b = (_a = options.stream) !== null && _a !== void 0 ? _a : configManager.get('stream')) !== null && _b !== void 0 ? _b : true;
const { agentConfig, workspaceChanged } = yield initializeAgentConfig(resolvedWorkspace, options);
if (!agentConfig) {
return;
}
(0, telemetry_1.updateTelemetryContext)({
orgId: agentConfig.org_id,
tenantId: agentConfig.tenant_id,
hostId: agentConfig.host_id,
agentId: agentConfig.id,
});
if ((_c = agentConfig.remote_exec) === null || _c === void 0 ? void 0 : _c.enabled) {
remoteExecutor_1.RemoteExecutor.instance.init(agentConfig.remote_exec);
}
let taskId = options.taskId;
if (!taskId) {
const taskResult = yield (0, api_1.createTask)(agentConfig.id, query);
taskId = taskResult.id;
(0, telemetry_1.updateTelemetryContext)({
taskId: taskId,
});
}
logger_1.default.debug('Task ID:', taskId);
const workspaceData = (0, files_1.getDirectoryMd5Hash)({
directoryPath: resolvedWorkspace,
});
const workspaceTree = Array.from(workspaceData.fileHashes.keys()).join(' \n ');
const agentManager = new agentManager_1.AgentManager({
workspace: resolvedWorkspace,
agentConfig,
});
logger.start('Thinking');
const agentResponse = yield (0, api_1.queryAgent)(agentManager.agentConfig.id, workspaceChanged, taskId, workspaceTree, stream);
if (stream) {
const streamResponse = agentResponse;
handleReasoningSteps(streamResponse);
}
let [actions, queryResponse] = yield parseAgentResponse(agentResponse, stream);
if (queryResponse) {
logger.stop(queryResponse);
}
let finalResponse = '';
while (actions.length) {
let toolOutputs;
const loopStatus = (0, loopDetection_1.checkLoopStatus)(actions);
if (loopStatus.status === 'looping') {
toolOutputs = [
{
output: `LOOP DETECTED: You've repeated the same action ${loopStatus.count} times without progress.`,
success: false,
tool_call_id: loopStatus.action.id,
},
];
}
else if (loopStatus.status === 'warning') {
toolOutputs = [
{
output: `WARNING: You've repeated the same action ${loopStatus.count}/${loopDetection_1.REPETITION_THRESHOLD} times. You MUST try a completely different strategy now or execution will be blocked.`,
success: true,
tool_call_id: loopStatus.action.id,
},
];
}
else {
toolOutputs = yield executeActions(actions, agentManager);
}
logger.start('Reviewing the job');
const submitResponse = yield (0, api_1.submitToolOutputs)(agentManager.agentConfig.id, taskId, toolOutputs, stream);
[actions, finalResponse] = yield parseAgentResponse(submitResponse, stream);
if (actions.length && finalResponse) {
logger.stop(finalResponse);
}
}
if (finalResponse) {
logger.stop(chalk_1.default.italic.gray('-'.repeat((0, logger_1.getTerminalWidth)() - 10)));
logger_1.default.agent(finalResponse);
}
}
catch (error) {
logger.stop('Query execution error', 1);
throw error;
}
});
exports.queryCommand = queryCommand;