@uipath/agent-tool 1.202.0-preview.159 → 1.203.0-preview.160

package/dist/{packager-tool-bstv6gk4.js → packager-tool-g5g8vyx2.js}

@@ -13,7 +13,7 @@ import {
   isSolutionUploadHttpError,
   migrateLegacyToolGuardrailPolicies,
   resolveStudioWebConfig
-} from "./packager-tool-1p2be2cq.js";
+} from "./packager-tool-abj3ftf8.js";
 import {
   OutputFormatter,
   RESULTS,
@@ -27,10 +27,11 @@ import {
   getSdkUserAgentToken,
   installSdkUserAgentHeader,
   logger,
+  parseBoundedInt,
   prepareProjectLocation,
   processContext,
   tryRegisterProjectInParentSolution
-} from "./packager-tool-r46ma7qq.js";
+} from "./packager-tool-tnz82jk0.js";
 import {
   currentAgentStorageSchema,
   currentEvaluationSetStorageSchema,
@@ -6987,8 +6988,9 @@ var require_index_cjs = __commonJS(function(exports, module) {
 // package.json
 var package_default = {
   name: "@uipath/agent-tool",
+  author: "UiPath",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.202.0-preview.159",
+  version: "1.203.0-preview.160",
   description: "cli plugin for creating and managing UiPath low-code agents",
   private: false,
   repository: {
@@ -7039,8 +7041,8 @@ var package_default = {
     "@uipath/solution-sdk": "workspace:*",
     "@uipath/solutionpackager-tool-core": "workspace:*",
     "@uipath/tool-agent": "^2.0.0",
-    "adm-zip": "^0.6.0",
     commander: "^14.0.3",
+    fflate: "^0.8.2",
     typescript: "^7.0.2"
   }
 };
@@ -7430,8 +7432,9 @@ class VoidApiResponse {
 // ../agent-sdk/package.json
 var package_default2 = {
   name: "@uipath/agent-sdk",
+  author: "UiPath",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.202.0-preview.159",
+  version: "1.203.0-preview.160",
   description: "SDK for the UiPath Agent Runtime API — evaluation execution and debug sessions.",
   repository: {
     type: "git",
@@ -11801,16 +11804,7 @@ var resolveEnvFilePathAsync = async (envFilePath = DEFAULT_ENV_FILENAME, opts) =
     errorMessage: location.source === "absolute" ? `Environment file not found: ${envFilePath}` : `Unable to locate environment file: ${envFilePath}. Run 'uip login' to authenticate.`
   };
 };
-var loadEnvFileAsync = async ({ envPath }) => {
-  const fs7 = getFileSystem2();
-  const absolutePath = fs7.path.isAbsolute(envPath) ? envPath : fs7.path.join(fs7.env.cwd(), envPath);
-  if (!await fs7.exists(absolutePath)) {
-    throw new Error(`Environment file not found: ${envPath}`);
-  }
-  const content = await fs7.readFile(absolutePath, "utf-8");
-  if (content === null) {
-    throw new Error(`Environment file not found: ${envPath}`);
-  }
+var parseEnvContent = (content) => {
   const env = {};
   for (const line of content.split(`
 `)) {
@@ -11831,6 +11825,18 @@ var loadEnvFileAsync = async ({ envPath }) => {
   }
   return env;
 };
+var loadEnvFileAsync = async ({ envPath }) => {
+  const fs7 = getFileSystem2();
+  const absolutePath = fs7.path.isAbsolute(envPath) ? envPath : fs7.path.join(fs7.env.cwd(), envPath);
+  if (!await fs7.exists(absolutePath)) {
+    throw new Error(`Environment file not found: ${envPath}`);
+  }
+  const content = await fs7.readFile(absolutePath, "utf-8");
+  if (content === null) {
+    throw new Error(`Environment file not found: ${envPath}`);
+  }
+  return parseEnvContent(content);
+};
 var saveEnvFileAsync = async ({
   envPath,
   data,
@@ -12337,6 +12343,7 @@ function normalizeTokenRefreshUnavailableFailure() {
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
+init_src();
 init_constants();
 init_src();
 init_constants();
@@ -12792,7 +12799,7 @@ var registerGuardrailCommands = (program) => {
 
 // src/services/project-artifacts.ts
 async function ensureProjectArtifacts(args) {
-  const { addProjectArtifactsToSolutionAsync } = await import("./index-jkdwsj5d.js");
+  const { addProjectArtifactsToSolutionAsync } = await import("./index-s1mvhfbj.js");
   return addProjectArtifactsToSolutionAsync(args);
 }
 
@@ -33283,8 +33290,9 @@ class TextApiResponse {
 // ../integrationservice-sdk/package.json
 var package_default3 = {
   name: "@uipath/integrationservice-sdk",
+  author: "UiPath",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.202.0-preview.159",
+  version: "1.203.0-preview.160",
   repository: {
     type: "git",
     url: "https://github.com/UiPath/cli.git",
@@ -41105,6 +41113,21 @@ var KNOWN_CATEGORIES = [
   "code",
   "general"
 ];
+var GRADES = [
+  "A+",
+  "A",
+  "A-",
+  "B+",
+  "B",
+  "B-",
+  "C+",
+  "C",
+  "C-",
+  "D+",
+  "D",
+  "D-",
+  "F"
+];
 function listCategories() {
   return [...KNOWN_CATEGORIES];
 }
@@ -42959,6 +42982,116 @@ function buildInvalidAgentJsonIssue(loaded) {
     suggestedFix: "Verify agent.json exists and is valid, properly encoded JSON."
   };
 }
+var REVIEW_HISTORY_FILE = "review-history.json";
+var MAX_REVIEW_HISTORY_ENTRIES = 25;
+var isGrade = (value) => typeof value === "string" && GRADES.includes(value);
+var validateEntry = (entry, index) => {
+  if (typeof entry !== "object" || entry === null) {
+    return `[${index}]: expected an object`;
+  }
+  const { grade, runAt, errors: errors3, warnings } = entry;
+  if (!isGrade(grade)) {
+    return `[${index}].grade: expected one of ${GRADES.join(", ")}`;
+  }
+  if (typeof runAt !== "string") {
+    return `[${index}].runAt: expected a string`;
+  }
+  for (const [name, count] of [
+    ["errors", errors3],
+    ["warnings", warnings]
+  ]) {
+    if (count !== undefined && typeof count !== "number") {
+      return `[${index}].${name}: expected a number`;
+    }
+  }
+  return;
+};
+var parseHistory = (raw) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err2) {
+    const message = err2 instanceof Error ? err2.message : String(err2);
+    return { success: false, error: `invalid JSON: ${message}` };
+  }
+  if (!Array.isArray(parsed)) {
+    return { success: false, error: "expected a JSON array of entries" };
+  }
+  for (const [index, entry] of parsed.entries()) {
+    const error51 = validateEntry(entry, index);
+    if (error51 !== undefined) {
+      return { success: false, error: error51 };
+    }
+  }
+  return { success: true, data: parsed };
+};
+var parseRunAt = (entry) => {
+  const time3 = Date.parse(entry.runAt);
+  return Number.isNaN(time3) ? Number.NEGATIVE_INFINITY : time3;
+};
+var writeAtomically = async (file2, content, fs7) => {
+  const tempFile = `${file2}.${globalThis.crypto.randomUUID()}.tmp`;
+  try {
+    await fs7.writeFile(tempFile, content);
+    await fs7.rename(tempFile, file2);
+  } catch (err2) {
+    await fs7.rm(tempFile).catch(() => {
+      return;
+    });
+    throw err2;
+  }
+};
+var appendEntry = async (file2, grade, input, fs7) => {
+  let history = [];
+  const raw = await fs7.readFile(file2, "utf-8");
+  if (raw !== null) {
+    const parsed = parseHistory(raw);
+    if (!parsed.success) {
+      return {
+        ok: false,
+        error: "MALFORMED_HISTORY",
+        file: file2,
+        detail: parsed.error
+      };
+    }
+    history = parsed.data;
+  }
+  const entry = {
+    grade,
+    runAt: new Date().toISOString(),
+    ...input.errors !== undefined && { errors: input.errors },
+    ...input.warnings !== undefined && { warnings: input.warnings }
+  };
+  const newTime = Date.parse(entry.runAt);
+  let index = 0;
+  while (index < history.length && parseRunAt(history[index]) > newTime) {
+    index++;
+  }
+  history.splice(index, 0, entry);
+  if (history.length > MAX_REVIEW_HISTORY_ENTRIES) {
+    history.length = MAX_REVIEW_HISTORY_ENTRIES;
+  }
+  await writeAtomically(file2, `${JSON.stringify(history, null, 2)}
+`, fs7);
+  return { ok: true, entry, history };
+};
+var recordReview = async (projectPath, input, fs7) => {
+  const grade = input.grade.toUpperCase();
+  if (!isGrade(grade)) {
+    return { ok: false, error: "INVALID_GRADE", allowed: GRADES };
+  }
+  const stats = await fs7.stat(projectPath);
+  if (!stats?.isDirectory()) {
+    return { ok: false, error: "NOT_A_DIRECTORY", projectPath };
+  }
+  const file2 = fs7.path.join(projectPath, REVIEW_HISTORY_FILE);
+  const release = await fs7.acquireLock(file2);
+  try {
+    return await appendEntry(file2, grade, input, fs7);
+  } finally {
+    await release();
+  }
+};
 
 // src/services/guardrail-catalog-service.ts
 var LLM_AS_JUDGE_VALIDATOR = "llm_as_judge";
@@ -43145,6 +43278,122 @@ var registerReviewCommand = (program) => {
   });
 };
 
+// src/commands/review-history.ts
+var CODES2 = {
+  success: "AgentReviewHistoryAdd",
+  invalidGrade: "AgentReviewHistoryAddInvalidGrade",
+  invalidPath: "AgentReviewHistoryAddInvalidPath",
+  malformedHistory: "AgentReviewHistoryAddMalformedHistory",
+  failed: "AgentReviewHistoryAddFailed"
+};
+var ADD_EXAMPLES = [
+  {
+    Description: "Record a review grade for a project at a specific path",
+    Command: "uip agent review-history add B ./my-agent",
+    Output: {
+      Code: CODES2.success,
+      Data: {
+        ProjectDir: "./my-agent",
+        Grade: "B",
+        RunAt: "2026-09-02T10:00:00.000Z",
+        HistoryCount: 1
+      }
+    }
+  },
+  {
+    Description: "Record a grade with finding counts",
+    Command: "uip agent review-history add C --errors 2 --warnings 5",
+    Output: {
+      Code: CODES2.success,
+      Data: {
+        ProjectDir: ".",
+        Grade: "C",
+        RunAt: "2026-09-02T10:00:00.000Z",
+        Errors: 2,
+        Warnings: 5,
+        HistoryCount: 3
+      }
+    }
+  }
+];
+var COUNT_BOUNDS = { min: 0, max: Number.MAX_SAFE_INTEGER };
+var parseCount = (flag) => (raw) => parseBoundedInt(raw, flag, COUNT_BOUNDS);
+var reportFailure = (rawGrade, outcome) => {
+  switch (outcome.error) {
+    case "INVALID_GRADE":
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Code: CODES2.invalidGrade,
+        ErrorCode: "invalid_argument",
+        Message: `\`${rawGrade}\` is not a recordable grade.`,
+        Instructions: `Pass one of: ${outcome.allowed.join(", ")}.`
+      });
+      return;
+    case "NOT_A_DIRECTORY":
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Code: CODES2.invalidPath,
+        ErrorCode: "invalid_argument",
+        Message: `\`${outcome.projectPath}\` is not an existing directory.`,
+        Instructions: "Pass the agent project directory as [path], or run from inside it."
+      });
+      return;
+    case "MALFORMED_HISTORY":
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Code: CODES2.malformedHistory,
+        ErrorCode: "configuration_error",
+        Message: `\`${outcome.file}\` exists but is not a JSON array of review entries: ${outcome.detail}`,
+        Instructions: "Fix the file so it parses as a JSON array, or delete it to start a fresh history, then rerun."
+      });
+      return;
+  }
+};
+var registerReviewHistoryCommands = (program) => {
+  const reviewHistory = program.command("review-history").description(`Manage the review grades recorded in the project's ${REVIEW_HISTORY_FILE}`);
+  reviewHistory.command("add").description(`Record a review grade in the project's ${REVIEW_HISTORY_FILE}. ` + `Keeps the newest ${MAX_REVIEW_HISTORY_ENTRIES} entries, most recent first. Does not run the review.`).argument("<grade>", "Letter grade to record (A to F)").argument("[path]", "Agent project directory", ".").option("--errors <count>", "Number of error findings to record", parseCount("--errors")).option("--warnings <count>", "Number of warning findings to record", parseCount("--warnings")).examples(ADD_EXAMPLES).trackedAction(processContext, async (grade, targetPath, options) => {
+    const fs7 = getFileSystem();
+    const projectPath = fs7.path.resolve(targetPath);
+    const [err2, outcome] = await catchError(recordReview(projectPath, {
+      grade,
+      errors: options.errors,
+      warnings: options.warnings
+    }, fs7));
+    if (err2) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Code: CODES2.failed,
+        Message: `Recording the review failed: ${extractErrorMessageSync(err2)}`,
+        Instructions: "Verify the project directory is writable. " + "Run `uip agent review-history add --help` for usage."
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (!outcome.ok) {
+      reportFailure(grade, outcome);
+      processContext.exit(1);
+      return;
+    }
+    const { entry, history } = outcome;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: CODES2.success,
+      Data: {
+        ProjectDir: projectPath,
+        Grade: entry.grade,
+        RunAt: entry.runAt,
+        ...entry.errors !== undefined && {
+          Errors: entry.errors
+        },
+        ...entry.warnings !== undefined && {
+          Warnings: entry.warnings
+        },
+        HistoryCount: history.length
+      }
+    });
+  });
+};
+
 // src/commands/tool-list.ts
 var TOOL_LIST_EXAMPLES = [
   {
@@ -43211,6 +43460,7 @@ var registerCommands = async (program) => {
   registerValidateCommand(program);
   registerRefreshCommand(program);
   registerReviewCommand(program);
+  registerReviewHistoryCommands(program);
   registerToolListCommand(program);
   registerMemoryCommands(program);
   registerEvalCommands(program);
@@ -43221,4 +43471,4 @@ var registerCommands = async (program) => {
 
 export { metadata, registerCommands };
 
-//# debugId=325616C87483A8F964756E2164756E21
+//# debugId=8377E5091839BBF564756E2164756E21