@lotics/cli 0.96.4 → 0.96.6

package/dist/src/cli.js

@@ -70166,6 +70166,16 @@ function runNpm(args, cwd) {
     });
   });
 }
+function readAppWorkspaceId(projectDir) {
+  try {
+    const pkgPath2 = path5.join(projectDir, "package.json");
+    if (!fs4.existsSync(pkgPath2)) return null;
+    const pkg2 = JSON.parse(fs4.readFileSync(pkgPath2, "utf-8"));
+    return pkg2.lotics?.workspace_id ?? null;
+  } catch {
+    return null;
+  }
+}
 function readAppMeta(projectDir) {
   const pkgPath2 = path5.join(projectDir, "package.json");
   if (!fs4.existsSync(pkgPath2)) {
@@ -90242,6 +90252,170 @@ async function ensureContentTypeOverride(doc, partName, contentType) {
   doc.zip.file("[Content_Types].xml", updated);
 }
 
+// ../ooxml/src/queries.ts
+function getBodyElementType(el) {
+  const tag = getTagName(el);
+  if (tag === "w:p") return "paragraph";
+  if (tag === "w:tbl") return "table";
+  return "other";
+}
+function extractParagraphText(el) {
+  const tag = getTagName(el);
+  if (tag !== "w:p") return "";
+  const parts = [];
+  for (const child of getChildren(el)) {
+    const childTag = getTagName(child);
+    if (childTag === "w:r") {
+      for (const runChild of getChildren(child)) {
+        if (getTagName(runChild) === "w:t") {
+          parts.push(getTextContent(runChild));
+        }
+      }
+    } else if (childTag === "w:hyperlink") {
+      for (const hlChild of getChildren(child)) {
+        if (getTagName(hlChild) === "w:r") {
+          for (const runChild of getChildren(hlChild)) {
+            if (getTagName(runChild) === "w:t") {
+              parts.push(getTextContent(runChild));
+            }
+          }
+        }
+      }
+    }
+  }
+  return parts.join("");
+}
+function getRunsFromParagraph(el) {
+  const runs = [];
+  for (const child of getChildren(el)) {
+    if (getTagName(child) !== "w:r") continue;
+    let text = "";
+    let textIdx = -1;
+    const children = getChildren(child);
+    for (let i2 = 0; i2 < children.length; i2++) {
+      if (getTagName(children[i2]) === "w:t") {
+        const tChildren = getChildren(children[i2]);
+        for (const tn of tChildren) {
+          if (typeof tn["#text"] === "string") {
+            text += tn["#text"];
+          }
+        }
+        textIdx = i2;
+      }
+    }
+    if (textIdx >= 0) {
+      runs.push({ element: child, text, textNodeIndex: textIdx });
+    }
+  }
+  return runs;
+}
+function setRunText(run, newText) {
+  const children = getChildren(run.element);
+  children[run.textNodeIndex] = {
+    "w:t": [{ "#text": newText }],
+    ":@": { "@_xml:space": "preserve" }
+  };
+  run.text = newText;
+}
+function computeReplacementRanges(text, query, replacement, matchType, maxReplacements, startCount) {
+  const ranges = [];
+  let count = startCount;
+  if (matchType === "exact") {
+    if (text === query && count < maxReplacements) {
+      ranges.push({ start: 0, end: text.length, replacement });
+      count++;
+    }
+    return { ranges, count };
+  }
+  if (matchType === "regex") {
+    const re2 = new RegExp(query, "gi");
+    let match2;
+    while (count < maxReplacements && (match2 = re2.exec(text)) !== null) {
+      ranges.push({ start: match2.index, end: match2.index + match2[0].length, replacement });
+      count++;
+      if (match2[0].length === 0) re2.lastIndex++;
+    }
+    return { ranges, count };
+  }
+  if (query.length === 0) return { ranges, count };
+  const lower2 = text.toLowerCase();
+  const lowerQuery = query.toLowerCase();
+  let searchFrom = 0;
+  while (count < maxReplacements) {
+    const idx = lower2.indexOf(lowerQuery, searchFrom);
+    if (idx === -1) break;
+    ranges.push({ start: idx, end: idx + query.length, replacement });
+    searchFrom = idx + query.length;
+    count++;
+  }
+  return { ranges, count };
+}
+function applyRangeReplacements(runs, ranges) {
+  if (ranges.length === 0) return;
+  const bounds = [];
+  let offset = 0;
+  for (const run of runs) {
+    bounds.push({ run, start: offset, end: offset + run.text.length });
+    offset += run.text.length;
+  }
+  const joined = runs.map((r) => r.text).join("");
+  const sorted = [...ranges].sort((a, b) => a.start - b.start);
+  for (const { run, start: runStart, end: runEnd } of bounds) {
+    let next = "";
+    let cursor = runStart;
+    for (const range2 of sorted) {
+      if (range2.end <= runStart || range2.start >= runEnd) continue;
+      const keepUntil = Math.min(range2.start, runEnd);
+      const from = Math.max(cursor, runStart);
+      if (keepUntil > from) next += joined.slice(from, keepUntil);
+      if (runStart <= range2.start && range2.start < runEnd) next += range2.replacement;
+      cursor = Math.max(cursor, range2.end);
+    }
+    const tail = Math.max(cursor, runStart);
+    if (runEnd > tail) next += joined.slice(tail, runEnd);
+    if (next !== run.text) setRunText(run, next);
+  }
+}
+function replaceInParagraph(el, query, replacement, matchType, maxReplacements, replacementsMade) {
+  if (!extractParagraphText(el)) return replacementsMade;
+  const runs = getRunsFromParagraph(el);
+  if (runs.length === 0) return replacementsMade;
+  const text = runs.length === 1 ? runs[0].text : runs.map((r) => r.text).join("");
+  const { ranges, count } = computeReplacementRanges(text, query, replacement, matchType, maxReplacements, replacementsMade);
+  applyRangeReplacements(runs, ranges);
+  return count;
+}
+function replaceText(bodyElements, query, replacement, matchType = "contains", maxReplacements = Infinity) {
+  if (matchType === "regex") {
+    try {
+      new RegExp(query);
+    } catch {
+      throw new Error(`Invalid regex pattern: ${query}`);
+    }
+  }
+  let replacementsMade = 0;
+  for (let i2 = 0; i2 < bodyElements.length && replacementsMade < maxReplacements; i2++) {
+    const el = bodyElements[i2];
+    const type = getBodyElementType(el);
+    if (type === "paragraph") {
+      replacementsMade = replaceInParagraph(el, query, replacement, matchType, maxReplacements, replacementsMade);
+    } else if (type === "table") {
+      for (const child of getChildren(el)) {
+        if (getTagName(child) !== "w:tr") continue;
+        for (const cell of getChildren(child)) {
+          if (getTagName(cell) !== "w:tc") continue;
+          for (const p of getChildren(cell)) {
+            if (getTagName(p) === "w:p" && replacementsMade < maxReplacements) {
+              replacementsMade = replaceInParagraph(p, query, replacement, matchType, maxReplacements, replacementsMade);
+            }
+          }
+        }
+      }
+    }
+  }
+  return replacementsMade;
+}
+
 // ../docx/src/parse/parser.ts
 var import_jszip2 = __toESM(require_lib4(), 1);
 async function parseDocx(buffer) {
@@ -90768,18 +90942,102 @@ async function docxReplaceText(filePath, rest) {
     fail2("Usage: lotics docx replace-text <file> '<search>' '<replace>'");
   }
   const doc = await loadFile2(filePath);
-  const newChildren = doc.body.children.map((b) => b.kind === "paragraph" ? replaceInParagraph(b, search, replace2) : b);
-  await writeDoc(filePath, replaceChildren(doc, newChildren));
+  const { children, count } = replaceEverywhere(doc.body.children, search, replace2);
+  if (count === 0) {
+    fail2(`No occurrence of ${JSON.stringify(search)} in ${filePath} \u2014 nothing written.`);
+  }
+  await writeDoc(filePath, replaceChildren(doc, children));
+  console.error(`Wrote ${filePath} (${count} replacement${count === 1 ? "" : "s"})`);
+}
+function replaceEverywhere(blocks, search, replace2) {
+  let count = 0;
+  const children = blocks.map((b) => {
+    if (b.kind === "paragraph") {
+      const [paragraph, n] = replaceInParagraph2(b, search, replace2);
+      count += n;
+      return paragraph;
+    }
+    if (b.kind === "opaque_block") {
+      const xml = structuredClone(b.xml);
+      const n = replaceText([xml], search, replace2, "contains");
+      if (n === 0) return b;
+      count += n;
+      return { kind: "opaque_block", xml };
+    }
+    return b;
+  });
+  return { children, count };
 }
-function replaceInParagraph(p, search, replace2) {
-  const content = p.content.map((inline) => {
+function replaceInParagraph2(p, search, replace2) {
+  if (search === "") return [p, 0];
+  const rewritten = /* @__PURE__ */ new Map();
+  let count = 0;
+  for (const segment of collectTextSegments(p)) {
+    const joined = segment.map((s) => s.value).join("");
+    const matches = [];
+    for (let at2 = joined.indexOf(search); at2 !== -1; at2 = joined.indexOf(search, at2 + search.length)) {
+      matches.push({ start: at2, end: at2 + search.length });
+    }
+    if (matches.length === 0) continue;
+    count += matches.length;
+    for (const slot of segment) {
+      let out = "";
+      let cursor = slot.start;
+      for (const m of matches) {
+        if (m.end <= slot.start || m.start >= slot.end) continue;
+        const keepUntil = Math.max(cursor, Math.min(m.start, slot.end));
+        if (keepUntil > cursor) out += joined.slice(cursor, keepUntil);
+        if (m.start >= slot.start && m.start < slot.end) out += replace2;
+        cursor = Math.max(cursor, Math.min(m.end, slot.end));
+      }
+      if (cursor < slot.end) out += joined.slice(cursor, slot.end);
+      rewritten.set(`${slot.inlineIndex}:${slot.childIndex}`, out);
+    }
+  }
+  if (count === 0) return [p, 0];
+  const content = p.content.map((inline, inlineIndex) => {
     if (inline.kind !== "run") return inline;
-    const newChildren = inline.content.map(
-      (c) => c.kind === "text" ? { kind: "text", value: c.value.split(search).join(replace2), preserveSpace: c.preserveSpace } : c
-    );
-    return { kind: "run", properties: inline.properties, content: newChildren };
+    const children = inline.content.map((c, childIndex) => {
+      if (c.kind !== "text") return c;
+      const next = rewritten.get(`${inlineIndex}:${childIndex}`);
+      if (next === void 0 || next === c.value) return c;
+      return { kind: "text", value: next, preserveSpace: next.startsWith(" ") || next.endsWith(" ") };
+    });
+    return { kind: "run", properties: inline.properties, content: children };
   });
-  return { kind: "paragraph", properties: p.properties, content };
+  return [{ kind: "paragraph", properties: p.properties, content }, count];
+}
+function collectTextSegments(p) {
+  const segments = [];
+  let current = [];
+  let offset = 0;
+  const breakSegment = () => {
+    if (current.length > 0) segments.push(current);
+    current = [];
+    offset = 0;
+  };
+  p.content.forEach((inline, inlineIndex) => {
+    if (inline.kind !== "run") {
+      breakSegment();
+      return;
+    }
+    inline.content.forEach((child, childIndex) => {
+      if (child.kind !== "text") {
+        breakSegment();
+        return;
+      }
+      current.push({
+        inlineIndex,
+        childIndex,
+        value: child.value,
+        start: offset,
+        end: offset + child.value.length
+      });
+      offset += child.value.length;
+    });
+  });
+  breakSegment();
+  return segments.filter((s) => s.length > 0);
 }
 async function docxBatch(filePath, json2) {
   if (!filePath || !json2) fail2("Usage: lotics docx batch <file> '<json-array-of-ops>'");
@@ -90823,8 +91081,9 @@ function applyBatchOp(doc, op, index) {
       return replaceChildren(doc, doc.body.children.filter((_, i2) => i2 !== op.at));
     }
     case "replace-text": {
-      const next = doc.body.children.map((b) => b.kind === "paragraph" ? replaceInParagraph(b, op.search, op.replace) : b);
-      return replaceChildren(doc, next);
+      const { children, count } = replaceEverywhere(doc.body.children, op.search, op.replace);
+      if (count === 0) fail2(`[op ${index}] No occurrence of ${JSON.stringify(op.search)} \u2014 batch aborted.`);
+      return replaceChildren(doc, children);
     }
     default: {
       const exhaustive = op;
@@ -90844,10 +91103,12 @@ Uses Lotics' own OOXML engine; round-trips faithfully with the Lotics editor and
   lotics docx insert-paragraph <file> '<text>' --at=<i> [--style=NAME]
                                                            Insert a paragraph at index <i> (0-based)
   lotics docx delete-block <file> --at=<i>                 Remove the block at index <i>
-  lotics docx replace-text <file> '<search>' '<replace>'   Replace text in all paragraph runs
+  lotics docx replace-text <file> '<search>' '<replace>'   Replace text in paragraphs AND table cells
+                                                           (errors if nothing matched \u2014 never a silent no-op)
   lotics docx batch <file> '<json-array-of-ops>'           Apply many ops in one parse/serialize cycle
 
-Edit ops mutate the file atomically (temp file + rename). Opaque blocks (tables, custom XML) are preserved verbatim.`);
+Edit ops mutate the file atomically (temp file + rename). Structure inside opaque blocks (tables, custom XML) is
+preserved verbatim; replace-text rewrites the text within them.`);
 }
 async function runDocxCommand(subcommand, toolArgs, restArgs) {
   switch (subcommand) {
@@ -91542,6 +91803,14 @@ function announceTarget(ctx, workspaceId) {
   }
   console.error(`lotics \u2192 ${org} / ${workspaceId}`);
 }
+function applyAppManifestWorkspace(ctx, command, subcommand, pathArg, flags) {
+  if (command !== "app") return;
+  if (flags.workspace || process.env.LOTICS_WORKSPACE) return;
+  if (subcommand === "create" || subcommand === "pull") return;
+  const dir = pathArg && !pathArg.startsWith("-") ? pathArg : process.cwd();
+  const workspaceId = readAppWorkspaceId(dir);
+  if (workspaceId) ctx.workspaceId = workspaceId;
+}
 async function resolveWorkspace(client, ctx) {
   if (ctx.workspaceId) {
     announceTarget(ctx, ctx.workspaceId);
@@ -91744,6 +92013,7 @@ async function main() {
       await appCodegen({ projectDir });
       return;
     }
+    applyAppManifestWorkspace(ctx2, command, subcommand, projectDir, flags);
     const viewAsMemberId = flags.viewAs ?? process.env.LOTICS_VIEW_AS;
     const client2 = new LoticsClient({ apiKey: ctx2.apiKey, workspaceId: ctx2.workspaceId, viewAsMemberId });
     await resolveWorkspace(client2, ctx2);
@@ -91969,6 +92239,7 @@ Available workspaces:`);
     if (ctx.orgName) console.error(`Org: ${ctx.orgName}`);
     return;
   }
+  applyAppManifestWorkspace(ctx, command, subcommand, subcommand === "dev" ? toolArgs : void 0, flags);
   await resolveWorkspace(client, ctx);
   if (command === "knowledge") {
     await runKnowledgeCommand(client, subcommand, toolArgs, flags);

package/package.json

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