@lotics/cli 0.96.5 → 0.97.0

package/README.md

@@ -92,11 +92,14 @@ Every command names its target before it acts — `lotics → <org> / <workspace
 
 ```
 --api-key flag  >  LOTICS_API_KEY env  >  LOTICS_ORG env (name|id)
-  >  local .lotics/config.json  >  global active profile
+  >  local .lotics/config.json  >  app manifest workspace → its saved profile
+  >  global active profile
 ```
 
 `LOTICS_WORKSPACE` (or `--workspace <id>` / `-w`) overrides the workspace at any level. For ephemeral or CI use, set `LOTICS_API_KEY` instead of saving anything.
 
+In an app project, `lotics app *` commands derive the credential from the directory when nothing explicit chose one: the manifest names the app's workspace, and when exactly one saved profile owns that workspace, that profile is used — the machine-wide default (which another shell can move between two of your commands) is never consulted. An explicit flag, env var, or directory pin still wins, and an org whose profile remembers a different workspace simply falls through to the announced default, exactly as before.
+
 ## Workspaces
 
 Workspaces live inside the active org. If the org has more than one, select before running tools:

package/dist/render_page.js

@@ -52872,8 +52872,9 @@ ${e.toString()}`);
       const max2 = parseInt(col["@_max"] ?? "1", 10);
       const width = col["@_width"] ? parseFloat(col["@_width"]) : defaultColWidth;
       const hidden = col["@_hidden"] === "1" || col["@_hidden"] === "true";
+      const customWidth = col["@_customWidth"] === "1" || col["@_customWidth"] === "true";
       const outlineLevel = parseInt(col["@_outlineLevel"] ?? "0", 10);
-      columns.push({ min, max: max2, width, hidden, outlineLevel });
+      columns.push({ min, max: max2, width, hidden, customWidth, outlineLevel });
       for (let c = min; c <= max2; c++) {
         if (hidden) colHidden.add(c);
         if (outlineLevel > 0) colOutlineLevels.set(c, outlineLevel);
@@ -52883,9 +52884,11 @@ ${e.toString()}`);
   }
   function buildColumns(colDefs, colHidden, maxContentWidth, colCount, _defaultColWidth) {
     const explicitWidth = /* @__PURE__ */ new Map();
+    const pinned = /* @__PURE__ */ new Set();
     for (const def of colDefs) {
       for (let c = def.min; c <= def.max; c++) {
         explicitWidth.set(c, def.width);
+        if (def.customWidth) pinned.add(c);
       }
     }
     const columns = [];
@@ -52899,7 +52902,7 @@ ${e.toString()}`);
       } else {
         width = Math.max(8, Math.min(contentChars + 2, 40));
       }
-      columns.push({ index: c, width, hidden });
+      columns.push({ index: c, width, hidden, ...pinned.has(c) ? { customWidth: true } : {} });
     }
     return columns;
   }
@@ -52943,6 +52946,7 @@ ${e.toString()}`);
       rowCount++;
       if (rowCount > maxRows) continue;
       const height = rowEl["@_ht"] ? parseFloat(rowEl["@_ht"]) : defaultRowHeight;
+      const customHeight = rowEl["@_customHeight"] === "1" || rowEl["@_customHeight"] === "true";
       const cellArr = rowEl["c"];
       const cells = [];
       if (cellArr) {
@@ -52964,7 +52968,8 @@ ${e.toString()}`);
         index: rowIndex,
         height,
         cells,
-        hidden: rowHidden
+        hidden: rowHidden,
+        ...customHeight ? { customHeight: true } : {}
       });
     }
     return {
@@ -54378,7 +54383,7 @@ ${e.toString()}`);
       sheet.freeze = { row: ps.freezePane.frozenRows, col: ps.freezePane.frozenCols };
     }
     for (const col of ps.columns) {
-      if (col.width !== ps.defaultColWidth) {
+      if (col.customWidth || col.width !== ps.defaultColWidth) {
         sheet.colWidths.set(col.index, col.width);
       }
       if (col.hidden) {
@@ -54391,7 +54396,7 @@ ${e.toString()}`);
       return `${startRef}:${endRef}`;
     });
     for (const row of ps.rows) {
-      if (row.height !== ps.defaultRowHeight) {
+      if (row.customHeight || row.height !== ps.defaultRowHeight) {
         sheet.rowHeights.set(row.index, row.height);
       }
       if (row.hidden) {

package/dist/src/cli.js

@@ -45107,7 +45107,7 @@ function resolveProfileByNameOrId(profiles, nameOrId) {
   }
   return null;
 }
-function resolveContext(flags) {
+function resolveContext(flags, appWorkspaceId) {
   const envKey = process.env.LOTICS_API_KEY;
   const envOrg = process.env.LOTICS_ORG;
   const envWorkspace = process.env.LOTICS_WORKSPACE;
@@ -45157,6 +45157,19 @@ function resolveContext(flags) {
       `This directory's .lotics/config.json uses the old self-contained format (inline key), which is no longer supported. Re-pin with "lotics auth api-key <key> --local" (or "lotics org use <name|id> --local").`
     );
   }
+  if (appWorkspaceId && !wsOverride) {
+    const matches = Object.entries(profiles).filter(([, p]) => p.workspace_id === appWorkspaceId);
+    if (matches.length === 1) {
+      const [orgId, profile] = matches[0];
+      return {
+        apiKey: profile.api_key,
+        orgId,
+        orgName: profile.org_name,
+        workspaceId: appWorkspaceId,
+        source: "app_manifest_profile"
+      };
+    }
+  }
   if (global2?.active_org) {
     const profile = profiles[global2.active_org];
     if (!profile) {
@@ -79139,8 +79152,9 @@ function parseCols(worksheet, defaultColWidth) {
     const max3 = parseInt(col["@_max"] ?? "1", 10);
     const width = col["@_width"] ? parseFloat(col["@_width"]) : defaultColWidth;
     const hidden = col["@_hidden"] === "1" || col["@_hidden"] === "true";
+    const customWidth = col["@_customWidth"] === "1" || col["@_customWidth"] === "true";
     const outlineLevel = parseInt(col["@_outlineLevel"] ?? "0", 10);
-    columns.push({ min: min2, max: max3, width, hidden, outlineLevel });
+    columns.push({ min: min2, max: max3, width, hidden, customWidth, outlineLevel });
     for (let c = min2; c <= max3; c++) {
       if (hidden) colHidden.add(c);
       if (outlineLevel > 0) colOutlineLevels.set(c, outlineLevel);
@@ -79150,9 +79164,11 @@ function parseCols(worksheet, defaultColWidth) {
 }
 function buildColumns(colDefs, colHidden, maxContentWidth, colCount, _defaultColWidth) {
   const explicitWidth = /* @__PURE__ */ new Map();
+  const pinned = /* @__PURE__ */ new Set();
   for (const def of colDefs) {
     for (let c = def.min; c <= def.max; c++) {
       explicitWidth.set(c, def.width);
+      if (def.customWidth) pinned.add(c);
     }
   }
   const columns = [];
@@ -79166,7 +79182,7 @@ function buildColumns(colDefs, colHidden, maxContentWidth, colCount, _defaultCol
     } else {
       width = Math.max(8, Math.min(contentChars + 2, 40));
     }
-    columns.push({ index: c, width, hidden });
+    columns.push({ index: c, width, hidden, ...pinned.has(c) ? { customWidth: true } : {} });
   }
   return columns;
 }
@@ -79210,6 +79226,7 @@ function parseSheetData(worksheet, styles, sharedStrings, hyperlinkMap, defaultR
     rowCount++;
     if (rowCount > maxRows) continue;
     const height = rowEl["@_ht"] ? parseFloat(rowEl["@_ht"]) : defaultRowHeight;
+    const customHeight = rowEl["@_customHeight"] === "1" || rowEl["@_customHeight"] === "true";
     const cellArr = rowEl["c"];
     const cells = [];
     if (cellArr) {
@@ -79231,7 +79248,8 @@ function parseSheetData(worksheet, styles, sharedStrings, hyperlinkMap, defaultR
       index: rowIndex,
       height,
       cells,
-      hidden: rowHidden
+      hidden: rowHidden,
+      ...customHeight ? { customHeight: true } : {}
     });
   }
   return {
@@ -83767,7 +83785,7 @@ function loadSheetFromParsed(ps, styles) {
     sheet.freeze = { row: ps.freezePane.frozenRows, col: ps.freezePane.frozenCols };
   }
   for (const col of ps.columns) {
-    if (col.width !== ps.defaultColWidth) {
+    if (col.customWidth || col.width !== ps.defaultColWidth) {
       sheet.colWidths.set(col.index, col.width);
     }
     if (col.hidden) {
@@ -83780,7 +83798,7 @@ function loadSheetFromParsed(ps, styles) {
     return `${startRef}:${endRef}`;
   });
   for (const row of ps.rows) {
-    if (row.height !== ps.defaultRowHeight) {
+    if (row.customHeight || row.height !== ps.defaultRowHeight) {
       sheet.rowHeights.set(row.index, row.height);
     }
     if (row.hidden) {
@@ -84668,6 +84686,103 @@ function clampInertCells(sheet) {
   for (const ref of pruned.keys()) sheet.cells.delete(ref);
   return pruned;
 }
+function axisStores(sheet, axis) {
+  return axis === "row" ? {
+    sizes: sheet.rowHeights,
+    outline: sheet.rowOutlineLevels,
+    hidden: sheet.hiddenRows,
+    breaks: sheet.rowPageBreaks,
+    setBreaks: (next) => {
+      sheet.rowPageBreaks = next;
+    }
+  } : {
+    sizes: sheet.colWidths,
+    outline: sheet.colOutlineLevels,
+    hidden: sheet.hiddenCols,
+    breaks: sheet.colPageBreaks,
+    setBreaks: (next) => {
+      sheet.colPageBreaks = next;
+    }
+  };
+}
+function shiftedIndex(i2, at2, delta) {
+  if (i2 < at2) return i2;
+  if (delta < 0 && i2 < at2 - delta) return null;
+  return i2 + delta;
+}
+function shiftKeys(map3, at2, delta) {
+  const affected = [...map3.entries()].filter(([i2]) => i2 >= at2);
+  for (const [i2] of affected) map3.delete(i2);
+  for (const [i2, value] of affected) {
+    const next = shiftedIndex(i2, at2, delta);
+    if (next !== null) map3.set(next, value);
+  }
+}
+function shiftMembers(set2, at2, delta) {
+  const affected = [...set2].filter((i2) => i2 >= at2);
+  for (const i2 of affected) set2.delete(i2);
+  for (const i2 of affected) {
+    const next = shiftedIndex(i2, at2, delta);
+    if (next !== null) set2.add(next);
+  }
+}
+function shiftBreaks(breaks, at2, delta) {
+  const moved = breaks.map((i2) => shiftedIndex(i2, at2, delta)).filter((i2) => i2 !== null);
+  return [...new Set(moved)].sort((a, b) => a - b);
+}
+function remapHyperlinks(sheet, landing) {
+  const next = /* @__PURE__ */ new Map();
+  for (const [ref, url2] of sheet.hyperlinks) {
+    const rc = refToRowColSafe(ref);
+    if (!rc) {
+      next.set(ref, url2);
+      continue;
+    }
+    const to = landing(rc.row, rc.col);
+    if (to) next.set(rowColToRef(to.row, to.col), url2);
+  }
+  sheet.hyperlinks = next;
+}
+function axisLanding(axis, at2, delta) {
+  return (row, col) => {
+    const next = shiftedIndex(axis === "row" ? row : col, at2, delta);
+    if (next === null) return null;
+    return axis === "row" ? { row: next, col } : { row, col: next };
+  };
+}
+function shiftAxisMetadata(sheet, axis, at2, delta) {
+  const stores = axisStores(sheet, axis);
+  shiftKeys(stores.sizes, at2, delta);
+  shiftKeys(stores.outline, at2, delta);
+  shiftMembers(stores.hidden, at2, delta);
+  stores.setBreaks(shiftBreaks(stores.breaks, at2, delta));
+  remapHyperlinks(sheet, axisLanding(axis, at2, delta));
+}
+var EMPTY_BAND = { sizes: [], outline: [], hidden: [], breaks: [], hyperlinks: [] };
+function snapshotAxisBand(sheet, axis, at2, count) {
+  const stores = axisStores(sheet, axis);
+  const inBand = (i2) => i2 >= at2 && i2 < at2 + count;
+  const links = [];
+  for (const [ref, url2] of sheet.hyperlinks) {
+    const rc = refToRowColSafe(ref);
+    if (rc && inBand(axis === "row" ? rc.row : rc.col)) links.push([ref, url2]);
+  }
+  return {
+    sizes: [...stores.sizes.entries()].filter(([i2]) => inBand(i2)),
+    outline: [...stores.outline.entries()].filter(([i2]) => inBand(i2)),
+    hidden: [...stores.hidden].filter(inBand),
+    breaks: stores.breaks.filter(inBand),
+    hyperlinks: links
+  };
+}
+function restoreAxisBand(sheet, axis, band) {
+  const stores = axisStores(sheet, axis);
+  for (const [i2, value] of band.sizes) stores.sizes.set(i2, value);
+  for (const [i2, value] of band.outline) stores.outline.set(i2, value);
+  for (const i2 of band.hidden) stores.hidden.add(i2);
+  stores.setBreaks([.../* @__PURE__ */ new Set([...stores.breaks, ...band.breaks])].sort((a, b) => a - b));
+  for (const [ref, url2] of band.hyperlinks) sheet.hyperlinks.set(ref, url2);
+}
 function insertRowsCommand(workbook, sheetIndex, at2, count) {
   const sheet = workbook.sheets[sheetIndex];
   let mergeSnapshot = [];
@@ -84688,11 +84803,7 @@ function insertRowsCommand(workbook, sheetIndex, at2, count) {
         sheet.cells.delete(ref);
         sheet.cells.set(rowColToRef(row + count, col), cell);
       }
-      const heightsToShift = Array.from(sheet.rowHeights.entries()).filter(([r]) => r >= at2).sort((a, b) => b[0] - a[0]);
-      for (const [r, h] of heightsToShift) {
-        sheet.rowHeights.delete(r);
-        sheet.rowHeights.set(r + count, h);
-      }
+      shiftAxisMetadata(sheet, "row", at2, count);
       adjustAllFormulasForRowShift(sheet, at2, count);
       adjustMergedCellsForRowInsert(sheet, at2, count);
       workbook.emit({ type: "rows_inserted", sheet: sheetIndex, at: at2, count });
@@ -84714,12 +84825,7 @@ function insertRowsCommand(workbook, sheetIndex, at2, count) {
         sheet.cells.delete(ref);
         sheet.cells.set(rowColToRef(row - count, col), cell);
       }
-      const heightsToShift = Array.from(sheet.rowHeights.entries()).filter(([r]) => r >= at2 + count).sort((a, b) => a[0] - b[0]);
-      for (const [r, h] of heightsToShift) {
-        sheet.rowHeights.delete(r);
-        sheet.rowHeights.set(r - count, h);
-      }
-      for (let r = at2; r < at2 + count; r++) sheet.rowHeights.delete(r);
+      shiftAxisMetadata(sheet, "row", at2, -count);
       for (const [ref, cell] of inertSnapshot) sheet.cells.set(ref, cell);
       workbook.emit({ type: "rows_deleted", sheet: sheetIndex, at: at2, count });
     }
@@ -84736,11 +84842,13 @@ function deleteRowsCommand(workbook, sheetIndex, at2, count) {
   }
   let mergeSnapshot = [];
   let inertSnapshot = /* @__PURE__ */ new Map();
+  let bandSnapshot = EMPTY_BAND;
   return {
     description: `Delete ${count} row${count > 1 ? "s" : ""} at ${at2}`,
     execute() {
       mergeSnapshot = [...sheet.mergedCells];
       inertSnapshot = clampInertCells(sheet);
+      bandSnapshot = snapshotAxisBand(sheet, "row", at2, count);
       for (const ref of snapshot.keys()) sheet.cells.delete(ref);
       const toMove = [];
       for (const [ref] of sheet.cells) {
@@ -84753,12 +84861,15 @@ function deleteRowsCommand(workbook, sheetIndex, at2, count) {
         sheet.cells.delete(ref);
         sheet.cells.set(rowColToRef(row - count, col), cell);
       }
+      shiftAxisMetadata(sheet, "row", at2, -count);
       adjustAllFormulasForRowShift(sheet, at2, -count);
       adjustMergedCellsForRowDelete(sheet, at2, count);
       workbook.emit({ type: "rows_deleted", sheet: sheetIndex, at: at2, count });
     },
     undo() {
       sheet.mergedCells = [...mergeSnapshot];
+      shiftAxisMetadata(sheet, "row", at2, count);
+      restoreAxisBand(sheet, "row", bandSnapshot);
       const toMove = [];
       for (const [ref] of sheet.cells) {
         const rc = refToRowColSafe(ref);
@@ -84798,11 +84909,7 @@ function insertColsCommand(workbook, sheetIndex, at2, count) {
         sheet.cells.delete(ref);
         sheet.cells.set(rowColToRef(row, col + count), cell);
       }
-      const widthsToShift = Array.from(sheet.colWidths.entries()).filter(([c]) => c >= at2).sort((a, b) => b[0] - a[0]);
-      for (const [c, w] of widthsToShift) {
-        sheet.colWidths.delete(c);
-        sheet.colWidths.set(c + count, w);
-      }
+      shiftAxisMetadata(sheet, "col", at2, count);
       adjustAllFormulasForColShift(sheet, at2, count);
       adjustMergedCellsForColInsert(sheet, at2, count);
       workbook.emit({ type: "cols_inserted", sheet: sheetIndex, at: at2, count });
@@ -84824,12 +84931,7 @@ function insertColsCommand(workbook, sheetIndex, at2, count) {
         sheet.cells.delete(ref);
         sheet.cells.set(rowColToRef(row, col - count), cell);
       }
-      const widthsToShift = Array.from(sheet.colWidths.entries()).filter(([c]) => c >= at2 + count).sort((a, b) => a[0] - b[0]);
-      for (const [c, w] of widthsToShift) {
-        sheet.colWidths.delete(c);
-        sheet.colWidths.set(c - count, w);
-      }
-      for (let c = at2; c < at2 + count; c++) sheet.colWidths.delete(c);
+      shiftAxisMetadata(sheet, "col", at2, -count);
       for (const [ref, cell] of inertSnapshot) sheet.cells.set(ref, cell);
       workbook.emit({ type: "cols_deleted", sheet: sheetIndex, at: at2, count });
     }
@@ -84846,11 +84948,13 @@ function deleteColsCommand(workbook, sheetIndex, at2, count) {
   }
   let mergeSnapshot = [];
   let inertSnapshot = /* @__PURE__ */ new Map();
+  let bandSnapshot = EMPTY_BAND;
   return {
     description: `Delete ${count} column${count > 1 ? "s" : ""} at ${at2}`,
     execute() {
       mergeSnapshot = [...sheet.mergedCells];
       inertSnapshot = clampInertCells(sheet);
+      bandSnapshot = snapshotAxisBand(sheet, "col", at2, count);
       for (const ref of snapshot.keys()) sheet.cells.delete(ref);
       const toMove = [];
       for (const [ref] of sheet.cells) {
@@ -84863,12 +84967,15 @@ function deleteColsCommand(workbook, sheetIndex, at2, count) {
         sheet.cells.delete(ref);
         sheet.cells.set(rowColToRef(row, col - count), cell);
       }
+      shiftAxisMetadata(sheet, "col", at2, -count);
       adjustAllFormulasForColShift(sheet, at2, -count);
       adjustMergedCellsForColDelete(sheet, at2, count);
       workbook.emit({ type: "cols_deleted", sheet: sheetIndex, at: at2, count });
     },
     undo() {
       sheet.mergedCells = [...mergeSnapshot];
+      shiftAxisMetadata(sheet, "col", at2, count);
+      restoreAxisBand(sheet, "col", bandSnapshot);
       const toMove = [];
       for (const [ref] of sheet.cells) {
         const rc = refToRowColSafe(ref);
@@ -90252,6 +90359,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) {
@@ -90778,18 +91049,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 replaceInParagraph(p, search, replace2) {
-  const content = p.content.map((inline) => {
+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 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 }, 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;
+    });
   });
-  return { kind: "paragraph", properties: p.properties, content };
+  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>'");
@@ -90833,8 +91188,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;
@@ -90854,10 +91210,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) {
@@ -91522,8 +91880,8 @@ Multiple workspaces in ${info.organization_name}. Run "lotics workspace select <
     console.error(`  Saved to the "${info.organization_name}" profile in ~/.lotics`);
   }
 }
-function requireClient(flags) {
-  const ctx = resolveContext(flags);
+function requireClient(flags, appWorkspaceId) {
+  const ctx = resolveContext(flags, appWorkspaceId);
   if (!ctx) {
     console.error('Not authenticated. Run "lotics auth signup", "lotics auth api-key <key>", or set LOTICS_API_KEY.');
     process.exit(1);
@@ -91539,6 +91897,7 @@ var SOURCE_LABELS = {
   env_key: "LOTICS_API_KEY env",
   env_org: "LOTICS_ORG env",
   local_pointer: "local .lotics/config.json (pin)",
+  app_manifest_profile: "app manifest workspace \u2192 its saved profile",
   global_profile: "global active profile"
 };
 function announceTarget(ctx, workspaceId) {
@@ -91552,12 +91911,15 @@ 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;
+function appManifestWorkspaceId(command, subcommand, pathArg, flags) {
+  if (command !== "app") return void 0;
+  if (flags.workspace || process.env.LOTICS_WORKSPACE) return void 0;
+  if (subcommand === "create" || subcommand === "pull") return void 0;
   const dir = pathArg && !pathArg.startsWith("-") ? pathArg : process.cwd();
-  const workspaceId = readAppWorkspaceId(dir);
+  return readAppWorkspaceId(dir) ?? void 0;
+}
+function applyAppManifestWorkspace(ctx, command, subcommand, pathArg, flags) {
+  const workspaceId = appManifestWorkspaceId(command, subcommand, pathArg, flags);
   if (workspaceId) ctx.workspaceId = workspaceId;
 }
 async function resolveWorkspace(client, ctx) {
@@ -91757,7 +92119,7 @@ async function main() {
   }
   if (command === "app" && subcommand === "codegen") {
     const projectDir = toolArgs;
-    const ctx2 = resolveContext(flags);
+    const ctx2 = resolveContext(flags, appManifestWorkspaceId(command, subcommand, projectDir, flags));
     if (!ctx2) {
       await appCodegen({ projectDir });
       return;
@@ -91874,7 +92236,11 @@ async function main() {
     console.error("Downloads every file on the given file field into the output dir.");
     process.exit(1);
   }
-  const { client, ctx } = requireClient(flags);
+  const appPathArg = subcommand === "dev" ? toolArgs : void 0;
+  const { client, ctx } = requireClient(
+    flags,
+    appManifestWorkspaceId(command, subcommand, appPathArg, flags)
+  );
   if (command === "workspace") {
     if (subcommand === "doctor") {
       await resolveWorkspace(client, ctx);
@@ -91988,7 +92354,7 @@ Available workspaces:`);
     if (ctx.orgName) console.error(`Org: ${ctx.orgName}`);
     return;
   }
-  applyAppManifestWorkspace(ctx, command, subcommand, subcommand === "dev" ? toolArgs : void 0, flags);
+  applyAppManifestWorkspace(ctx, command, subcommand, appPathArg, 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.5",
+  "version": "0.97.0",
   "description": "Lotics SDK and CLI for AI agents",
   "type": "module",
   "bin": {