@rogatio/cli 5.17.0 → 5.19.0

package/dist/editor/index.js

@@ -1844,9 +1844,6 @@ var CREATABLE_RULE_FIELDS = /* @__PURE__ */ new Set([
   ...ACTION_PAYLOAD_FIELDS,
   "redactSensitiveInLogs"
 ]);
-function isBodyRuleType(type) {
-  return type === "request-body" || type === "response-body";
-}
 function setValueAtPath(root, path, value) {
   const segments = decodePointer(path);
   if (!segments || segments.length === 0) return false;
@@ -2003,6 +2000,7 @@ function ownString(record, ...keys) {
   }
   return void 0;
 }
+var RULE_PATH_PATTERN = /^\/groups\/(0|[1-9][0-9]*)\/rules\/(0|[1-9][0-9]*)(?:\/|$)/;
 function applyRuleProposalAction(rule, ruleProposal) {
   const action = ruleProposal.action;
   switch (ruleProposal.kind) {
@@ -2126,6 +2124,7 @@ var EditorControllerImpl = class {
   testRequestId = 0;
   aiAssistPanel = null;
   aiAssistInFlight = false;
+  aiRepairTargets = [];
   constructor(options, initial, extensions) {
     this.root = options.root;
     this.document = options.root.ownerDocument;
@@ -2975,6 +2974,8 @@ var EditorControllerImpl = class {
     this.render();
   }
   applyAIProposal(proposal) {
+    const repairs = [...this.aiRepairTargets];
+    this.aiRepairTargets = [];
     for (const ruleProposal of proposal.rules) {
       let group = this.groupById(ruleProposal.groupId);
       if (!group) {
@@ -2988,7 +2989,19 @@ var EditorControllerImpl = class {
         group = this.groupById(groupId);
       }
       if (!group) return;
-      const ruleId = this.nextId("rule-ai");
+      const rules = group.rules;
+      const repair = repairs.find(
+        (target) => target.groupId === ruleProposal.groupId && rules.some((existing) => String(existing.id) === target.ruleId)
+      );
+      let repairIndex = -1;
+      let ruleId = this.nextId("rule-ai");
+      if (repair) {
+        repairs.splice(repairs.indexOf(repair), 1);
+        ruleId = repair.ruleId;
+        repairIndex = rules.findIndex(
+          (existing) => String(existing.id) === repair.ruleId
+        );
+      }
       const rule = {
         id: ruleId,
         name: ruleProposal.name,
@@ -3001,20 +3014,56 @@ var EditorControllerImpl = class {
         rule.method = ruleProposal.method;
       }
       applyRuleProposalAction(rule, ruleProposal);
-      group.rules.push(rule);
+      if (repairIndex >= 0) {
+        rules[repairIndex] = rule;
+      } else {
+        rules.push(rule);
+      }
       this.markChanged();
       const groupIdStr = String(group.id);
       this.focusRequest = pointer(
         "groups",
         this.groupIndex(groupIdStr),
         "rules",
-        group.rules.length - 1,
+        repairIndex >= 0 ? repairIndex : rules.length - 1,
         "name"
       );
     }
     this.statusMessage = `Applied ${proposal.rules.length} rule${proposal.rules.length === 1 ? "" : "s"} from AI.`;
     this.render();
   }
+  /**
+   * Rules carrying validation errors, in stable path order. A fix proposal
+   * repairs these rules in place (keeping their ids) instead of adding new ones.
+   */
+  repairTargetsFrom(diagnostics) {
+    const seen = /* @__PURE__ */ new Set();
+    const positions = [];
+    for (const diagnostic2 of diagnostics) {
+      const match = RULE_PATH_PATTERN.exec(diagnostic2.path);
+      if (!match) continue;
+      const groupIndex = Number(match[1]);
+      const ruleIndex = Number(match[2]);
+      if (!Number.isSafeInteger(groupIndex) || !Number.isSafeInteger(ruleIndex)) {
+        continue;
+      }
+      const key = `${groupIndex}/${ruleIndex}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      positions.push({ groupIndex, ruleIndex });
+    }
+    positions.sort(
+      (left, right) => left.groupIndex - right.groupIndex || left.ruleIndex - right.ruleIndex
+    );
+    const targets = [];
+    for (const position of positions) {
+      const group = this.draft.groups[position.groupIndex];
+      const rule = group?.rules[position.ruleIndex];
+      if (!group || !rule) continue;
+      targets.push({ groupId: String(group.id), ruleId: String(rule.id) });
+    }
+    return targets;
+  }
   async runAIAssist(prompt) {
     const handler = this.options.aiAssist;
     const panel = this.aiAssistPanel;
@@ -3033,6 +3082,7 @@ var EditorControllerImpl = class {
         diagnostics: diagnostics.length > 0 ? diagnostics : void 0
       }
     };
+    this.aiRepairTargets = request.kind === "fix" && diagnostics.length > 0 ? this.repairTargetsFrom(diagnostics) : [];
     panel.startStreaming("assistant");
     try {
       const result = handler(request);
@@ -3937,25 +3987,23 @@ var EditorControllerImpl = class {
     this.renderField(matcherGrid, "Method", `${rulePath}/method`, method);
     matcherFields.append(matcherGrid);
     card.append(matcherFields);
-    if (!isBodyRuleType(rule.type)) {
-      const redactFieldset = this.document.createElement("fieldset");
-      const redactLegend = this.document.createElement("legend");
-      redactLegend.textContent = "Match logging";
-      redactFieldset.append(redactLegend);
-      const redactGrid = this.document.createElement("div");
-      redactGrid.dataset.editorFields = "true";
-      const redactCheckbox = this.document.createElement("input");
-      redactCheckbox.type = "checkbox";
-      redactCheckbox.checked = rule.redactSensitiveInLogs === true;
-      this.renderField(
-        redactGrid,
-        "Redact sensitive fields in logs",
-        `${rulePath}/redactSensitiveInLogs`,
-        redactCheckbox
-      );
-      redactFieldset.append(redactGrid);
-      card.append(redactFieldset);
-    }
+    const redactFieldset = this.document.createElement("fieldset");
+    const redactLegend = this.document.createElement("legend");
+    redactLegend.textContent = "Match logging";
+    redactFieldset.append(redactLegend);
+    const redactGrid = this.document.createElement("div");
+    redactGrid.dataset.editorFields = "true";
+    const redactCheckbox = this.document.createElement("input");
+    redactCheckbox.type = "checkbox";
+    redactCheckbox.checked = rule.redactSensitiveInLogs === true;
+    this.renderField(
+      redactGrid,
+      "Redact sensitive fields in logs",
+      `${rulePath}/redactSensitiveInLogs`,
+      redactCheckbox
+    );
+    redactFieldset.append(redactGrid);
+    card.append(redactFieldset);
     if (this.extensions.length > 0) {
       const currentType = this.extensions.find(
         (e) => e.matches(rule)

package/dist/node/index.js

@@ -20878,6 +20878,115 @@ function mergeProposalIntoProject(project, proposal) {
   }
   return { ...project, groups };
 }
+var RULE_PATH_PATTERN = /^\/groups\/(0|[1-9][0-9]*)\/rules\/(0|[1-9][0-9]*)(?:\/|$)/;
+function repairTargetsFromDiagnostics(diagnostics) {
+  if (!Array.isArray(diagnostics)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const targets = [];
+  for (const diagnostic of diagnostics) {
+    if (!isRecord(diagnostic) || typeof diagnostic.path !== "string") continue;
+    const match = RULE_PATH_PATTERN.exec(diagnostic.path);
+    if (!match) continue;
+    const groupIndex = Number(match[1]);
+    const ruleIndex = Number(match[2]);
+    if (!Number.isSafeInteger(groupIndex) || !Number.isSafeInteger(ruleIndex)) {
+      continue;
+    }
+    const key = `${groupIndex}/${ruleIndex}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    targets.push({ groupIndex, ruleIndex });
+  }
+  targets.sort(
+    (left, right) => left.groupIndex - right.groupIndex || left.ruleIndex - right.ruleIndex
+  );
+  return targets;
+}
+var RULE_KINDS = /* @__PURE__ */ new Set([
+  "redirect",
+  "query",
+  "header",
+  "response-body",
+  "request-body"
+]);
+function stringArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  const items = value.filter(
+    (item) => typeof item === "string"
+  );
+  return items.length === value.length ? items : void 0;
+}
+function parseProposalRule(value) {
+  if (!isRecord(value)) return null;
+  const kind = value.kind;
+  if (typeof kind !== "string" || !RULE_KINDS.has(kind) || typeof value.groupId !== "string" || typeof value.name !== "string" || typeof value.urlRegex !== "string" || !Object.hasOwn(value, "action")) {
+    return null;
+  }
+  return {
+    kind,
+    groupId: value.groupId,
+    name: value.name,
+    urlRegex: value.urlRegex,
+    origins: stringArray(value.origins),
+    resourceTypes: stringArray(value.resourceTypes),
+    priority: typeof value.priority === "number" ? value.priority : void 0,
+    method: typeof value.method === "string" ? value.method : void 0,
+    action: value.action
+  };
+}
+function repairProposalIntoProject(project, diagnostics, proposal) {
+  const groups = Array.isArray(project.groups) ? project.groups.map((group) => {
+    if (!isRecord(group)) {
+      return { id: "invalid", name: "invalid", origins: [], rules: [] };
+    }
+    return {
+      ...group,
+      rules: Array.isArray(group.rules) ? [...group.rules] : []
+    };
+  }) : [];
+  const queues = /* @__PURE__ */ new Map();
+  for (const target of repairTargetsFromDiagnostics(diagnostics)) {
+    const group = groups[target.groupIndex];
+    if (!group) continue;
+    const rules = group.rules;
+    if (target.ruleIndex >= rules.length) continue;
+    if (!isRecord(rules[target.ruleIndex])) continue;
+    const queue = queues.get(target.groupIndex) ?? [];
+    queue.push(target.ruleIndex);
+    queues.set(target.groupIndex, queue);
+  }
+  let seq = 0;
+  const newId = () => `ai-${Date.now()}-${seq++}`;
+  const proposed = Array.isArray(proposal.rules) ? proposal.rules : [];
+  for (const entry of proposed) {
+    const ruleProposal = parseProposalRule(entry);
+    if (!ruleProposal) continue;
+    const groupIndex = groups.findIndex(
+      (candidate) => candidate.id === ruleProposal.groupId
+    );
+    const queue = groupIndex >= 0 ? queues.get(groupIndex) : void 0;
+    const targetIndex = queue?.shift();
+    if (groupIndex >= 0 && targetIndex !== void 0) {
+      const rules = groups[groupIndex].rules;
+      const existing = rules[targetIndex];
+      const keptId = typeof existing.id === "string" ? existing.id : newId();
+      rules[targetIndex] = ruleFromProposal(ruleProposal, keptId);
+      continue;
+    }
+    let group = groupIndex >= 0 ? groups[groupIndex] : void 0;
+    if (!group) {
+      group = {
+        id: ruleProposal.groupId,
+        name: "AI Group",
+        origins: [],
+        rules: []
+      };
+      groups.push(group);
+    }
+    group.rules.push(ruleFromProposal(ruleProposal, newId()));
+  }
+  return { ...project, groups };
+}
 function parseProposal(content) {
   try {
     const parsed = JSON.parse(content);
@@ -20943,6 +21052,11 @@ async function runStream(client, options) {
 async function runAIAssist(request, config, validate, dryRun, client) {
   const aiClient = client ?? createAIClient(config);
   const systemPrompt = buildSystemPrompt(request.context.project);
+  const merge = (project, proposal) => request.kind === "fix" ? repairProposalIntoProject(
+    project,
+    request.context.diagnostics,
+    proposal
+  ) : mergeProposalIntoProject(project, proposal);
   let currentProposal = null;
   let attempts = 0;
   while (attempts < MAX_FIX_ATTEMPTS) {
@@ -20950,9 +21064,7 @@ async function runAIAssist(request, config, validate, dryRun, client) {
     const isFixAttempt = attempts > 1 || request.kind === "fix";
     const validationErrors = (() => {
       if (!isFixAttempt || !currentProposal) return [];
-      return validate(
-        mergeProposalIntoProject(request.context.project, currentProposal)
-      );
+      return validate(merge(request.context.project, currentProposal));
     })();
     const messages = buildMessages(
       systemPrompt,
@@ -20983,10 +21095,7 @@ async function runAIAssist(request, config, validate, dryRun, client) {
       throw new Error("AI returned invalid proposal format");
     }
     currentProposal = proposal;
-    const testProject = mergeProposalIntoProject(
-      request.context.project,
-      proposal
-    );
+    const testProject = merge(request.context.project, proposal);
     const diagnostics = validate(testProject);
     if (diagnostics.length === 0) {
       if (dryRun && request.context.dryRunCases && request.context.dryRunCases.length > 0) {
@@ -23526,36 +23635,78 @@ Options:
 }
 
 // packages/cli/src/commands/ai.ts
+var pendingInput = "";
+function readLine() {
+  return new Promise((resolve9) => {
+    const take = () => {
+      const newline = pendingInput.search(/[\r\n]/u);
+      if (newline === -1) return false;
+      const line = pendingInput.slice(0, newline);
+      pendingInput = pendingInput.slice(newline + 1);
+      resolve9(line);
+      return true;
+    };
+    if (take()) return;
+    const onData = (chunk) => {
+      pendingInput += chunk.toString();
+      if (!take()) return;
+      process.stdin.off("data", onData);
+      process.stdin.pause();
+    };
+    process.stdin.on("data", onData);
+    process.stdin.resume();
+  });
+}
 async function promptInput(prompt) {
   process.stdout.write(prompt);
-  for await (const chunk of process.stdin) {
-    return chunk.toString().trim();
-  }
-  return "";
+  return (await readLine()).trim();
 }
 async function promptSecret(prompt) {
   process.stdout.write(prompt);
   process.stdin.setRawMode(true);
-  let input = "";
-  for await (const chunk of process.stdin) {
-    const char = chunk.toString();
-    if (char === "\n" || char === "\r") {
-      process.stdout.write("\n");
-      break;
-    } else if (char === "") {
-      process.exit(1);
-    } else if (char === "\x7F" || char === "\b") {
-      if (input.length > 0) {
-        input = input.slice(0, -1);
-        process.stdout.write("\b \b");
-      }
-    } else {
-      input += char;
-      process.stdout.write("*");
-    }
+  try {
+    return await new Promise((resolve9) => {
+      let input = "";
+      let settled = false;
+      const finish = () => {
+        settled = true;
+        process.stdin.off("data", onData);
+        process.stdin.pause();
+        resolve9(input.trim());
+      };
+      const consume = (text) => {
+        if (settled) return;
+        for (let index = 0; index < text.length; index += 1) {
+          const char = text[index];
+          if (char === "\n" || char === "\r") {
+            process.stdout.write("\n");
+            pendingInput = text.slice(index + 1);
+            finish();
+            return;
+          }
+          if (char === "") {
+            process.exit(1);
+          } else if (char === "\x7F" || char === "\b") {
+            if (input.length > 0) {
+              input = input.slice(0, -1);
+              process.stdout.write("\b \b");
+            }
+          } else {
+            input += char;
+            process.stdout.write("*");
+          }
+        }
+      };
+      const onData = (chunk) => consume(chunk.toString());
+      consume(pendingInput);
+      if (settled) return;
+      pendingInput = "";
+      process.stdin.on("data", onData);
+      process.stdin.resume();
+    });
+  } finally {
+    process.stdin.setRawMode(false);
   }
-  process.stdin.setRawMode(false);
-  return input.trim();
 }
 async function aiCommand(args) {
   if (args.includes("--help") || args.includes("-h")) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rogatio/cli",
-  "version": "5.17.0",
+  "version": "5.19.0",
   "private": false,
   "type": "module",
   "description": "Local-first browser request and response rules — editor host, file verification, test runner, and runtime dispatch.",