@lazyingart/agintiflow 0.20.192 → 0.20.193

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.192",
+  "version": "0.20.193",
   "type": "module",
   "description": "AgInTiFlow is a project-aware agent workspace for hybrid wet-dry R&D, hardware-aware intelligence, software automation, and industrial workflows.",
   "license": "Apache-2.0",

package/references/agintiflow-npm-publication-memory.md

@@ -10,6 +10,18 @@ This note records the working publication route for AgInTiFlow so future release
 
 Latest verified release:
 
+- Version: `0.20.192`
+- Commit: `fe571c0`
+- GitHub Actions run: `https://github.com/lazyingart/AgInTiFlow/actions/runs/27003317331`
+- Workflow result: success
+- npm registry check: `npm view @lazyingart/agintiflow version dist-tags.latest --registry=https://registry.npmjs.org` returned `0.20.192`.
+- Temporary install verification: `npm install --prefix <tmp> -g @lazyingart/agintiflow@0.20.192` then `<tmp>/bin/aginti --version` returned `0.20.192`.
+- Installed verification: `npm install -g @lazyingart/agintiflow@0.20.192` then `aginti --version` returned `0.20.192`.
+- Webapp verification: `aginti webapp restart --port 3210` then `curl -fsS http://127.0.0.1:3210/health` returned `version":"0.20.192"` from the global npm package path.
+- Feature verification: `npm run smoke:auth`, `npm run smoke:auxiliary-tools`, `npm run smoke:web-api`, `npm run check`, full `npm test`, and `npm pack --dry-run` passed before release; post-version-bump checks covered `npm run check`, `npm run smoke:auth`, `npm run smoke:auxiliary-tools`, and `npm pack --dry-run`.
+
+Previous verified release:
+
 - Version: `0.20.190`
 - Commit: `f192f8e`
 - GitHub Actions run: `https://github.com/lazyingart/AgInTiFlow/actions/runs/26736284533`

package/scripts/smoke-coding-tools.js

@@ -162,6 +162,33 @@ try {
     interruptedDeepSeekState.messages.at(-1)?.content === "Continue with this new request: /review",
     "interrupted repair dropped the new user request"
   );
+  const workspaceToolConfig = {
+    commandCwd: workspace,
+    allowFileTools: true,
+    workspaceWritePolicy: "allow",
+    sandboxMode: "host",
+  };
+  const cdataSvgResult = await executeWorkspaceTool(
+    "write_file",
+    {
+      path: "figures/cdata-wrapped.svg",
+      content: "<![CDATA[<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"10\" height=\"10\"></svg>]]>",
+    },
+    workspaceToolConfig
+  );
+  assert(cdataSvgResult.ok === false, "CDATA-wrapped SVG write should be marked not ok");
+  assert(cdataSvgResult.artifactValidation?.kind === "svg", "SVG validation result missing");
+  assert(/CDATA/i.test(cdataSvgResult.artifactValidation.errors.join(" ")), "CDATA SVG validation did not explain the wrapper problem");
+  const validSvgResult = await executeWorkspaceTool(
+    "write_file",
+    {
+      path: "figures/valid.svg",
+      content: "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"10\" height=\"10\"><rect width=\"10\" height=\"10\" /></svg>",
+    },
+    workspaceToolConfig
+  );
+  assert(validSvgResult.ok === true, "valid standalone SVG write should pass");
+  assert(validSvgResult.artifactValidation?.ok === true, "valid SVG validation did not pass");
   const blockedBatchResult = {
     ok: false,
     blocked: true,
@@ -1237,6 +1264,8 @@ try {
           "resume_session_write",
           "resume_runtime_time_context",
           "virtual_workspace_path",
+          "svg_cdata_validation_failure",
+          "svg_standalone_validation_pass",
           "apply_patch",
           "multi_file_patch",
           "unified_patch",

package/src/model-client.js

@@ -1535,7 +1535,7 @@ export async function requestNextStep(client, config, messages) {
         function: {
           name: "write_file",
           description:
-            "Create or overwrite a small UTF-8 workspace file. Use mode=create with a descriptive non-conflicting filename for newly generated standalone content. Use mode=overwrite only when the user explicitly asks to replace/update that file, or after reading the file and the task is clearly to modify it. Secret paths, .git, node_modules writes, and outside-workspace paths are blocked. The runtime records before/after hashes and a compact diff.",
+            "Create or overwrite a small UTF-8 workspace file. Use mode=create with a descriptive non-conflicting filename for newly generated standalone content. Use mode=overwrite only when the user explicitly asks to replace/update that file, or after reading the file and the task is clearly to modify it. Secret paths, .git, node_modules writes, and outside-workspace paths are blocked. The runtime records before/after hashes and a compact diff. For .svg files, the runtime reports deterministic XML/SVG validation; if that validation is not ok, repair the file before claiming it is valid.",
           parameters: {
             type: "object",
             properties: {

package/src/workspace-tools.js

@@ -99,6 +99,95 @@ function compactPreview(value, limit = 180) {
   return text.length <= limit ? text : `${text.slice(0, limit)}...`;
 }
 
+function firstXmlElementName(source = "") {
+  let text = String(source || "").replace(/^\uFEFF/, "").trimStart();
+  let changed = true;
+  while (changed) {
+    changed = false;
+    const xmlDeclaration = text.match(/^<\?xml\b[^>]*\?>\s*/i);
+    if (xmlDeclaration) {
+      text = text.slice(xmlDeclaration[0].length).trimStart();
+      changed = true;
+      continue;
+    }
+    const comment = text.match(/^<!--[\s\S]*?-->\s*/);
+    if (comment) {
+      text = text.slice(comment[0].length).trimStart();
+      changed = true;
+      continue;
+    }
+    const doctype = text.match(/^<!DOCTYPE\b[^>]*>\s*/i);
+    if (doctype) {
+      text = text.slice(doctype[0].length).trimStart();
+      changed = true;
+    }
+  }
+  return text.match(/^<([A-Za-z_][\w:.-]*)\b/)?.[1] || "";
+}
+
+function validateXmlTagStack(source = "") {
+  const stack = [];
+  const errors = [];
+  const tagPattern = /<[^>]+>/g;
+  for (const match of String(source || "").matchAll(tagPattern)) {
+    const tag = match[0];
+    if (/^<\?/.test(tag) || /^<!--/.test(tag) || /^<!DOCTYPE\b/i.test(tag) || /^<!\[CDATA\[/i.test(tag)) continue;
+    const end = tag.match(/^<\/\s*([A-Za-z_][\w:.-]*)\s*>$/);
+    if (end) {
+      const expected = stack.pop();
+      if (expected !== end[1]) {
+        errors.push(`Mismatched closing tag </${end[1]}>${expected ? `, expected </${expected}>` : " with no open tag"}.`);
+      }
+      continue;
+    }
+    const start = tag.match(/^<\s*([A-Za-z_][\w:.-]*)\b/);
+    if (!start) {
+      errors.push(`Malformed XML tag near: ${compactPreview(tag, 80)}`);
+      continue;
+    }
+    if (/\/\s*>$/.test(tag)) continue;
+    stack.push(start[1]);
+  }
+  while (stack.length) errors.push(`Unclosed XML tag <${stack.pop()}>.`);
+  return errors;
+}
+
+function validateSvgArtifact(relativePath, content) {
+  if (path.extname(String(relativePath || "")).toLowerCase() !== ".svg") return null;
+  const source = String(content ?? "");
+  const trimmed = source.replace(/^\uFEFF/, "").trim();
+  const errors = [];
+  const warnings = [];
+  if (!trimmed) errors.push("SVG file is empty.");
+  if (/^<!\[CDATA\[[\s\S]*\]\]>\s*$/i.test(trimmed)) {
+    errors.push("SVG is wrapped in a top-level CDATA section; a standalone .svg must start with <svg or an XML declaration.");
+  }
+  if (/^<!\[CDATA\[/i.test(trimmed) && !/^<!\[CDATA\[[\s\S]*\]\]>\s*$/i.test(trimmed)) {
+    errors.push("SVG starts with CDATA instead of an XML/SVG root element.");
+  }
+  const root = firstXmlElementName(trimmed);
+  if (!root) {
+    errors.push("No XML root element found.");
+  } else if (root !== "svg") {
+    errors.push(`Root element is <${root}>; expected <svg>.`);
+  }
+  const cdataOpen = (trimmed.match(/<!\[CDATA\[/gi) || []).length;
+  const cdataClose = (trimmed.match(/\]\]>/g) || []).length;
+  if (cdataOpen !== cdataClose) errors.push("CDATA open/close markers are unbalanced.");
+  errors.push(...validateXmlTagStack(trimmed));
+  if (/<text\b/i.test(trimmed) && !/(viewBox|width|height)=/i.test(trimmed)) {
+    warnings.push("SVG contains text but no obvious sizing/viewBox metadata; render-preview before claiming visual fit.");
+  }
+  return {
+    kind: "svg",
+    ok: errors.length === 0,
+    parser: "builtin-svg-xml-guard",
+    root: root || "",
+    errors,
+    warnings,
+  };
+}
+
 function countOccurrences(text, search) {
   if (!search) return 0;
   let count = 0;
@@ -732,6 +821,7 @@ async function writeChange(target, nextContent, action, details = {}) {
   const afterBuffer = await fs.readFile(target.absolutePath);
   const afterText = afterBuffer.toString("utf8");
   const afterHash = hashBuffer(afterBuffer);
+  const artifactValidation = validateSvgArtifact(target.relativePath, afterText);
 
   return {
     ok: true,
@@ -744,6 +834,7 @@ async function writeChange(target, nextContent, action, details = {}) {
     created: !existed,
     diff: compactDiff(target.relativePath, beforeText, afterText),
     contentSha256: hashText(content),
+    ...(artifactValidation ? { artifactValidation } : {}),
     ...details,
   };
 }
@@ -784,10 +875,11 @@ async function writeFile(config, args) {
     mode,
   });
   return {
-    ok: true,
+    ok: change.artifactValidation ? change.artifactValidation.ok : true,
     toolName: "write_file",
     path: target.relativePath,
     change,
+    ...(change.artifactValidation ? { artifactValidation: change.artifactValidation } : {}),
   };
 }
 
@@ -1060,11 +1152,12 @@ async function applyPatchDocument(config, args) {
   }
 
   return {
-    ok: true,
+    ok: !changes.some((change) => change.artifactValidation && !change.artifactValidation.ok),
     toolName: "apply_patch",
     path: changes.length === 1 ? changes[0].path : "",
     changes,
     change: changes[0],
+    artifactValidations: changes.map((change) => change.artifactValidation).filter(Boolean),
     summary: `${changes.length} file change(s) applied`,
   };
 }