@lotics/cli 0.152.0 → 0.152.2

package/dist/src/cli.js

@@ -44248,6 +44248,17 @@ function sessionId(now = Date.now(), env = process.env) {
 }
 
 // src/client.ts
+function parseContentDispositionFilename(disposition) {
+  const extended = disposition.match(/filename\*=\s*([^']*)'[^']*'([^;\n]+)/i);
+  if (extended) {
+    try {
+      return decodeURIComponent(extended[2].trim());
+    } catch {
+    }
+  }
+  const plain = disposition.match(/filename=\s*"?([^";\n]+)"?/i);
+  return plain ? plain[1].trim() : null;
+}
 function findAvailableFilename(dir, filename, reserved) {
   const isTaken = (name2) => {
     const full = path2.join(dir, name2);
@@ -45115,8 +45126,7 @@ var LoticsClient = class {
     const response = await fetch(url2);
     if (!response.ok) await this.throwResponseError(response);
     const disposition = response.headers.get("content-disposition") ?? "";
-    const match2 = disposition.match(/filename="?([^";\n]+)"?/);
-    const originalFilename = match2?.[1] ?? fileId;
+    const originalFilename = parseContentDispositionFilename(disposition) ?? fileId;
     const buffer = Buffer.from(await response.arrayBuffer());
     const dir = outputDir ? path2.resolve(outputDir) : process.cwd();
     await fs2.promises.mkdir(dir, { recursive: true });
@@ -97544,6 +97554,9 @@ function readChpx(grpprl) {
       case Sprm.CIstd:
         chp.charStyleIstd = s.operand.u16(0);
         break;
+      case Sprm.CPicLocation:
+        chp.picLocation = s.operand.u32(0);
+        break;
       default:
         break;
     }
@@ -98494,9 +98507,93 @@ function applyCellPadding(operand, current) {
   return margins;
 }
 
+// ../ooxml/src/doc/pictures.ts
+var EMU_PER_TWIP = 635;
+var PICF_MIN_HEADER = 68;
+var PICMID_OFFSET = 28;
+var MM_SHAPE = 100;
+var BLIP_TYPES = {
+  61466: { mediaType: "image/x-emf", skipByInstance: { 980: 50, 981: 66 }, extractable: false },
+  61467: { mediaType: "image/x-wmf", skipByInstance: { 534: 50, 535: 66 }, extractable: false },
+  61468: { mediaType: "image/pict", skipByInstance: { 1346: 50, 1347: 66 }, extractable: false },
+  61469: { mediaType: "image/jpeg", skipByInstance: { 1130: 17, 1131: 33 }, extractable: true },
+  61470: { mediaType: "image/png", skipByInstance: { 1760: 17, 1761: 33 }, extractable: true },
+  61471: { mediaType: "image/bmp", skipByInstance: { 1960: 17, 1961: 33 }, extractable: false },
+  61481: { mediaType: "image/tiff", skipByInstance: { 1764: 17, 1765: 33 }, extractable: true },
+  61482: { mediaType: "image/jpeg", skipByInstance: { 1130: 17, 1131: 33 }, extractable: true }
+};
+function pictureExtension(mediaType) {
+  switch (mediaType) {
+    case "image/png":
+      return "png";
+    case "image/jpeg":
+      return "jpeg";
+    case "image/tiff":
+      return "tiff";
+    default:
+      throw new Error(`No part extension for media type "${mediaType}"; it should not have been extracted`);
+  }
+}
+function readInlinePicture(data2, fc) {
+  if (fc < 0 || fc + PICF_MIN_HEADER > data2.length) return null;
+  const lcb = data2.u32(fc);
+  const cbHeader = data2.u16(fc + 4);
+  const mm = data2.u16(fc + 6);
+  if (cbHeader < PICF_MIN_HEADER || lcb <= cbHeader) return null;
+  if (fc + lcb > data2.length) return null;
+  const picmid = fc + PICMID_OFFSET;
+  const dxaGoal = data2.u16(picmid);
+  const dyaGoal = data2.u16(picmid + 2);
+  const mx = data2.u16(picmid + 4) || 1e3;
+  const my = data2.u16(picmid + 6) || 1e3;
+  if (mm < MM_SHAPE) return null;
+  const found = findBlip(data2.bytes.subarray(fc + cbHeader, fc + lcb));
+  if (!found) return null;
+  const widthEmu = Math.round(dxaGoal * EMU_PER_TWIP * mx / 1e3);
+  const heightEmu = Math.round(dyaGoal * EMU_PER_TWIP * my / 1e3);
+  if (widthEmu <= 0 || heightEmu <= 0) return null;
+  return { bytes: found.bytes, mediaType: found.mediaType, widthEmu, heightEmu };
+}
+var BSE_RECORD = 61447;
+var BSE_HEADER = 36;
+var BSE_CB_NAME = 33;
+function findBlip(payload) {
+  const view = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+  let offset = 0;
+  while (offset + 8 <= payload.length) {
+    const verInstance = view.getUint16(offset, true);
+    const recType = view.getUint16(offset + 2, true);
+    const length2 = view.getUint32(offset + 4, true);
+    const body = offset + 8;
+    const spec = BLIP_TYPES[recType];
+    if (spec) {
+      if (!spec.extractable) return null;
+      if (length2 > payload.length - body) return null;
+      const instance = verInstance >> 4;
+      const skip = spec.skipByInstance[instance];
+      if (skip === void 0 || skip > length2) return null;
+      return { bytes: payload.subarray(body + skip, body + length2), mediaType: spec.mediaType };
+    }
+    if (recType === BSE_RECORD) {
+      if (body + BSE_HEADER > payload.length) return null;
+      offset = body + BSE_HEADER + view.getUint8(body + BSE_CB_NAME);
+      continue;
+    }
+    if ((verInstance & 15) === 15) {
+      offset = body;
+      continue;
+    }
+    if (length2 > payload.length - body) return null;
+    offset = body + length2;
+  }
+  return null;
+}
+
 // ../ooxml/src/doc/parse.ts
 var FIB_MAGIC2 = 42476;
 var CH = {
+  picture: 1,
+  // inline picture anchor; its CHPX locates the bytes in Data
   refMark: 2,
   // footnote/endnote auto-number, inside a note subdocument
   cellMark: 7,
@@ -98522,6 +98619,8 @@ function parseDocToModel(bytes) {
   if (!tableBytes) throw new DocParseError("Not a legacy .doc: missing Table stream");
   const table = new Reader(tableBytes);
   const diagnostics = [];
+  const dataBytes = findStream(streams, "Data");
+  const pictures = new PictureCollector();
   const clx = readerFor(table, fib.fcLcb(FcLcbIndex.Clx));
   if (!clx) throw new DocParseError("Not a legacy .doc: empty Clx");
   const pieces = PieceTable.parse(wd, clx);
@@ -98546,6 +98645,8 @@ function parseDocToModel(bytes) {
     stsh,
     fonts,
     footnoteRefs: new Map(footnotes.refs.map((r) => [r.cp, r.index])),
+    data: dataBytes ? new Reader(dataBytes) : null,
+    pictures,
     diagnostics
   };
   const bodyParas = parseParagraphs(ctx, 0, fib.ccpText, numbering);
@@ -98568,9 +98669,32 @@ function parseDocToModel(bytes) {
     section: sectionResult.section,
     settings,
     bookmarks,
+    pictures: pictures.list,
     diagnostics
   };
 }
+var PictureCollector = class {
+  list = [];
+  indexByKey = /* @__PURE__ */ new Map();
+  /** Index of this picture in `list`, adding it on first sight. */
+  intern(picture) {
+    const key = `${picture.mediaType}:${picture.bytes.length}:${fnv1a(picture.bytes)}`;
+    const existing = this.indexByKey.get(key);
+    if (existing !== void 0) return existing;
+    const index = this.list.length;
+    this.list.push({ bytes: picture.bytes, mediaType: picture.mediaType });
+    this.indexByKey.set(key, index);
+    return index;
+  }
+};
+function fnv1a(bytes) {
+  let hash2 = 2166136261;
+  for (let i2 = 0; i2 < bytes.length; i2++) {
+    hash2 ^= bytes[i2];
+    hash2 = Math.imul(hash2, 16777619) >>> 0;
+  }
+  return hash2.toString(16);
+}
 function parseParagraphs(ctx, startCp, endCp, numbering) {
   const paras = [];
   let paraStart = startCp;
@@ -98658,6 +98782,20 @@ function parseParagraphs(ctx, startCp, endCp, numbering) {
       text += "	";
       continue;
     }
+    if (code === CH.picture) {
+      const picture = readPictureAt(ctx, currentRaw, cp);
+      if (picture !== null) {
+        const index = ctx.pictures.intern(picture);
+        pushPart(cp, currentRaw, (chp) => ({
+          kind: "picture",
+          pictureIndex: index,
+          widthEmu: picture.widthEmu,
+          heightEmu: picture.heightEmu,
+          chp
+        }));
+      }
+      continue;
+    }
     if (code < 32) {
       noteControlChar(ctx, cp, code);
       continue;
@@ -98698,9 +98836,22 @@ function finalizeParagraph(ctx, parts, startCp, markCp, isCellMark, numbering) {
     runCps
   };
 }
+function readPictureAt(ctx, raw, cp) {
+  const note = (detail) => {
+    ctx.diagnostics.push({ kind: "image", location: { cp }, detail });
+    return null;
+  };
+  if (raw.picLocation === void 0) return note("Picture anchor carries no Data-stream location; dropped");
+  if (!ctx.data) return note("Picture anchor found but the document has no Data stream; dropped");
+  const picture = readInlinePicture(ctx.data, raw.picLocation);
+  if (!picture) {
+    return note(`Picture at Data+${raw.picLocation} is not a readable inline image; dropped`);
+  }
+  return picture;
+}
 function noteControlChar(ctx, cp, code) {
-  if (code === 1 || code === 8) {
-    ctx.diagnostics.push({ kind: "image", location: { cp }, detail: `Inline object anchor (0x${code.toString(16)}) dropped` });
+  if (code === 8) {
+    ctx.diagnostics.push({ kind: "drawingObject", location: { cp }, detail: "Floating drawing object dropped" });
   } else if (code === 5) {
     ctx.diagnostics.push({ kind: "annotation", location: { cp }, detail: "Annotation reference dropped" });
   }
@@ -100972,8 +101123,66 @@ function textRunContent(text) {
   }
   return out.length > 0 ? out : [textElement("")];
 }
-function specialRunContent(run) {
+function pictureContent(run, ctx) {
+  const relId = ctx.pictureRelIds[run.pictureIndex];
+  if (relId === void 0) {
+    throw new Error(
+      `Picture ${run.pictureIndex} has no relationship; the emitter must register every picture before building runs`
+    );
+  }
+  const name2 = `Picture ${run.pictureIndex + 1}`;
+  const extent = { "@_cx": num2(run.widthEmu), "@_cy": num2(run.heightEmu) };
+  const blipChildren = [
+    leaf("a:blip", { "@_r:embed": relId }),
+    { "a:stretch": [{ "a:fillRect": [] }] }
+  ];
+  return {
+    "w:drawing": [
+      {
+        "wp:inline": [
+          leaf("wp:extent", extent),
+          leaf("wp:docPr", { "@_id": num2(run.pictureIndex + 1), "@_name": name2 }),
+          {
+            "a:graphic": [
+              {
+                "a:graphicData": [
+                  {
+                    "pic:pic": [
+                      {
+                        "pic:nvPicPr": [
+                          leaf("pic:cNvPr", { "@_id": num2(run.pictureIndex + 1), "@_name": name2 }),
+                          { "pic:cNvPicPr": [] }
+                        ]
+                      },
+                      { "pic:blipFill": blipChildren },
+                      {
+                        "pic:spPr": [
+                          {
+                            "a:xfrm": [
+                              leaf("a:off", { "@_x": "0", "@_y": "0" }),
+                              leaf("a:ext", extent)
+                            ]
+                          },
+                          { "a:prstGeom": [{ "a:avLst": [] }], ":@": { "@_prst": "rect" } }
+                        ]
+                      }
+                    ]
+                  }
+                ],
+                ":@": { "@_uri": "http://schemas.openxmlformats.org/drawingml/2006/picture" }
+              }
+            ]
+          }
+        ],
+        ":@": { "@_distT": "0", "@_distB": "0", "@_distL": "0", "@_distR": "0" }
+      }
+    ]
+  };
+}
+function specialRunContent(run, ctx) {
   switch (run.kind) {
+    case "picture":
+      return pictureContent(run, ctx);
     case "break":
       return run.breakType === "textWrapping" ? { "w:br": [] } : leaf("w:br", { "@_w:type": run.breakType });
     case "footnoteReference":
@@ -100991,7 +101200,7 @@ function buildRunElement(run, ctx) {
   const rPr = rPrElement(run.chp, ctx);
   if (rPr) children.push(rPr);
   if (run.kind === "text") children.push(...textRunContent(run.text));
-  else children.push(specialRunContent(run));
+  else children.push(specialRunContent(run, ctx));
   return { "w:r": children };
 }
 function borderChild(tag, border2) {
@@ -101292,7 +101501,7 @@ function overrideElement(override) {
     const loChildren = [];
     if (lo.startOverride !== void 0) loChildren.push(leaf3("w:startOverride", { "@_w:val": String(lo.startOverride) }));
     if (lo.level) {
-      loChildren.push(levelElement(lo.level, { styleIdByIstd: /* @__PURE__ */ new Map() }));
+      loChildren.push(levelElement(lo.level, { styleIdByIstd: /* @__PURE__ */ new Map(), pictureRelIds: [] }));
     }
     children.push({ "w:lvlOverride": loChildren, ":@": { "@_w:ilvl": String(lo.ilvl) } });
   }
@@ -101472,14 +101681,28 @@ function buildFontTableXml(fontNames) {
   const root = { "w:fonts": fonts, ":@": { "@_xmlns:w": W_NS4 } };
   return buildXml([root]);
 }
+async function registerPictures(doc, pictures) {
+  if (pictures.length === 0) return [];
+  ensureDrawingNamespaces(doc);
+  const relIds = [];
+  for (let i2 = 0; i2 < pictures.length; i2++) {
+    const extension = pictureExtension(pictures[i2].mediaType);
+    const name2 = `image${i2 + 1}.${extension}`;
+    doc.zip.file(`word/media/${name2}`, pictures[i2].bytes);
+    await ensureContentType(doc, extension, pictures[i2].mediaType);
+    relIds.push(await addRelationship(doc, `${REL}image`, `media/${name2}`));
+  }
+  return relIds;
+}
 async function docModelToDocx(model) {
   const styleIdByIstd = /* @__PURE__ */ new Map();
   for (const style of model.styles) styleIdByIstd.set(style.istd, style.styleId);
   if (!styleIdByIstd.has(0)) styleIdByIstd.set(0, "Normal");
-  const ctx = { styleIdByIstd };
   const walked = walkModel(model);
   const hasFootnotes = model.footnotes.length > 0;
   const doc = createBlankDocx();
+  const pictureRelIds = await registerPictures(doc, model.pictures);
+  const ctx = { styleIdByIstd, pictureRelIds };
   doc.bodyElements = [...buildBody(model, ctx), buildSectPr(model.section)];
   doc.zip.file("word/styles.xml", buildStylesXml2(model, ctx, walked.referencedStyleIstds));
   doc.zip.file("word/settings.xml", buildSettingsXml(model, hasFootnotes));
@@ -101720,6 +101943,18 @@ async function addRelationship(doc, type, target, targetMode) {
   doc.zip.file("word/_rels/document.xml.rels", updated);
   return rId;
 }
+async function ensureContentType(doc, extension, contentType) {
+  const contentTypesFile = doc.zip.file("[Content_Types].xml");
+  if (!contentTypesFile) return;
+  const ct = await contentTypesFile.async("string");
+  if (ct.includes(`Extension="${extension}"`)) return;
+  const updated = ct.replace(
+    "</Types>",
+    `  <Default Extension="${extension}" ContentType="${contentType}"/>
+</Types>`
+  );
+  doc.zip.file("[Content_Types].xml", updated);
+}
 async function ensureContentTypeOverride(doc, partName, contentType) {
   const contentTypesFile = doc.zip.file("[Content_Types].xml");
   if (!contentTypesFile) return;
@@ -101732,6 +101967,17 @@ async function ensureContentTypeOverride(doc, partName, contentType) {
   );
   doc.zip.file("[Content_Types].xml", updated);
 }
+function ensureDrawingNamespaces(doc) {
+  if (!doc.documentAttrs["@_xmlns:a"]) {
+    doc.documentAttrs["@_xmlns:a"] = "http://schemas.openxmlformats.org/drawingml/2006/main";
+  }
+  if (!doc.documentAttrs["@_xmlns:pic"]) {
+    doc.documentAttrs["@_xmlns:pic"] = "http://schemas.openxmlformats.org/drawingml/2006/picture";
+  }
+  if (!doc.documentAttrs["@_xmlns:wp"]) {
+    doc.documentAttrs["@_xmlns:wp"] = "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing";
+  }
+}
 
 // ../docx/src/parse/parser.ts
 var import_jszip3 = __toESM(require_lib4(), 1);

package/dist/src/client.js

@@ -2,6 +2,31 @@ import { transportErrorMessage } from "@lotics/shared/transport_error";
 import fs from "node:fs";
 import path from "node:path";
 import { getInvocation } from "./invocation.js";
+/**
+ * The filename a `Content-Disposition` names, preferring RFC 5987 `filename*`.
+ *
+ * The server always sends BOTH: `filename*=UTF-8''…` carrying the real name,
+ * and a plain `filename=` whose non-ASCII characters are replaced with `_`
+ * because HTTP header values are Latin-1. Reading only the plain one turned
+ * every accented name into underscores on the way to disk — `GIẤY YÊU CẦU.doc`
+ * saved as `GI_Y Y_U C_U.doc` — even though the correct bytes were in the same
+ * header. The `*` form wins whenever it parses; the plain form is the fallback
+ * it was always meant to be.
+ */
+function parseContentDispositionFilename(disposition) {
+    const extended = disposition.match(/filename\*=\s*([^']*)'[^']*'([^;\n]+)/i);
+    if (extended) {
+        try {
+            return decodeURIComponent(extended[2].trim());
+        }
+        catch {
+            // A malformed percent-escape means this parameter is unusable, not that
+            // the whole header is — fall through to the ASCII form below.
+        }
+    }
+    const plain = disposition.match(/filename=\s*"?([^";\n]+)"?/i);
+    return plain ? plain[1].trim() : null;
+}
 function findAvailableFilename(dir, filename, reserved) {
     // `reserved` tracks absolute paths claimed by in-flight downloads in the same
     // batch — required for parallel callers because the file may not be on disk
@@ -824,8 +849,7 @@ export class LoticsClient {
         if (!response.ok)
             await this.throwResponseError(response);
         const disposition = response.headers.get("content-disposition") ?? "";
-        const match = disposition.match(/filename="?([^";\n]+)"?/);
-        const originalFilename = match?.[1] ?? fileId;
+        const originalFilename = parseContentDispositionFilename(disposition) ?? fileId;
         const buffer = Buffer.from(await response.arrayBuffer());
         const dir = outputDir ? path.resolve(outputDir) : process.cwd();
         // The bytes are already fetched by this point, so a missing output directory

package/docs/knowledge_docs.md

@@ -30,18 +30,24 @@ lotics knowledge create --name "Shipping tariffs" \
 
 This reads the body from your filesystem and creates the doc through `create_knowledge`
 (prints the new id). A raw `lotics run create_knowledge @doc.json` works too — read a large
-`content` from a file or stdin. Either way, `create_knowledge` takes three things:
+`content` from a file or stdin. `create_knowledge` takes five fields, three of them required:
 
-- `name` — what it is.
+- `name` — what it is. Just the name: **grouping belongs in `tags`, not in a prefix baked into
+  every title.**
 - `description` — what the doc is **and what to grep it for**: its vocabulary and the synonyms
   an ambiguous query would use. Surfaced in the tree before any body is read, and truncated at
   200 characters. See *Write for grep* below.
 - `content` — Markdown.
+- `tags` *(optional)* — the labels someone would filter by, e.g. `["Hồ sơ NOXH", "Khoản 13"]`.
+  Give **every** one that is true of the doc, not just the main one — a corpus is narrowed by
+  intersecting tags, so a doc carrying one label can only ever be found down one path. On
+  `update_knowledge` the array **replaces** what is stored, so resend the labels it should keep.
+- `files` *(optional)* — file ids of the source `.docx`/`.pdf`/`.xlsx` the doc was built from,
+  stored alongside it so a reader can open the original. The body stays the searchable text.
 
 A new doc is created **owned by you, active in your own agent context, and private** — no one
-else can see it yet. (The tool itself takes only name/description/content; attaching files to a
-doc and changing its default-active state are done through the web app / REST surface, not this
-tool.)
+else can see it yet. Changing a doc's default-active state is done through the web app / REST
+surface, not this tool.
 
 ## Access vs. activation — both are required
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lotics/cli",
-  "version": "0.152.0",
+  "version": "0.152.2",
   "description": "Lotics SDK and CLI for AI agents",
   "type": "module",
   "bin": {