nolo-cli 0.147.0-alpha.1 → 0.148.0-alpha.1

package/chunk-BKWMNZ2X.js

@@ -0,0 +1,411 @@
+import {
+  fetchAndCacheTableRows
+} from "./chunk-QU5A4LYX.js";
+import {
+  require_react
+} from "./chunk-YDH3FDFQ.js";
+import {
+  resolveBuiltinCapability,
+  resolveBuiltinSkillEntry
+} from "./chunk-B2XUQXQX.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+import {
+  asTrimmedNonEmptyStringArray
+} from "./chunk-3AH7LNUB.js";
+import {
+  createAsyncThunk
+} from "./chunk-WIWM4FE3.js";
+import {
+  selectIdentityUserId
+} from "./chunk-SEJ5OS6F.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+import {
+  __toESM
+} from "./chunk-4VNS5WPM.js";
+
+// packages/core/abortableDelay.ts
+function waitForAbortableDelay(ms, signal) {
+  const delayMs = Number.isFinite(ms) && ms >= 0 ? Math.round(ms) : 0;
+  if (signal?.aborted) {
+    return Promise.reject(new DOMException("Aborted", "AbortError"));
+  }
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      clearTimeout(timeoutId);
+      signal?.removeEventListener("abort", onAbort);
+      reject(new DOMException("Aborted", "AbortError"));
+    };
+    const timeoutId = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, delayMs);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// packages/ai/chat/parseMultilineSSE.ts
+function createSSEParser() {
+  let buffer = "";
+  return function parseSSE(chunk) {
+    const results = [];
+    if (!chunk) return results;
+    buffer += chunk;
+    const events = buffer.split(/\r?\n\r?\n/);
+    buffer = events.pop() ?? "";
+    for (const ev of events) {
+      if (!ev.trim()) continue;
+      const lines = ev.split(/\r?\n/);
+      let accumulator = "";
+      for (const line of lines) {
+        const t = line.trim();
+        if (t === "data: [DONE]") {
+          if (accumulator.trim()) {
+            try {
+              results.push(JSON.parse(accumulator));
+            } catch (e) {
+            }
+            accumulator = "";
+          }
+          results.push("[DONE]");
+          continue;
+        }
+        let content = "";
+        let isDataLine = false;
+        if (t.startsWith("data:")) {
+          content = line.substring(line.indexOf("data:") + 5).trim();
+          isDataLine = true;
+        } else if (accumulator && t && !t.startsWith("event:") && !t.startsWith("id:") && !t.startsWith("retry:")) {
+          content = line;
+        } else {
+          continue;
+        }
+        if (isDataLine && !accumulator) {
+          try {
+            const obj = JSON.parse(content);
+            results.push(obj);
+            continue;
+          } catch (e) {
+          }
+        }
+        accumulator += content;
+      }
+      if (accumulator.trim()) {
+        try {
+          const obj = JSON.parse(accumulator);
+          results.push(obj);
+        } catch (e) {
+        }
+      }
+    }
+    return results;
+  };
+}
+var parseMultilineSSE = createSSEParser();
+
+// packages/core/clipMultilineText.ts
+function clipMultilineText(value, max) {
+  const trimmed = value.trim();
+  if (trimmed.length <= max) return trimmed;
+  return `${trimmed.slice(0, max)}
+...[truncated ${trimmed.length - max} chars]`;
+}
+
+// packages/render/table/utils/tableSerialization.ts
+var fetchAndSerializeTable = async (tableMeta, db, options = {}) => {
+  const tenantId = tableMeta.tenantId;
+  const tableId = tableMeta.tableId;
+  const results = await fetchAndCacheTableRows({
+    db,
+    tenantId,
+    tableId,
+    token: options.token,
+    remoteServers: options.remoteServers ?? []
+  });
+  const columns = tableMeta.columns || [];
+  const headerRow = columns.map((c) => c.label || c.name);
+  const separatorRow = columns.map(() => "---");
+  let tableMd = "";
+  if (columns.length > 0) {
+    tableMd = `| ${headerRow.join(" | ")} |
+| ${separatorRow.join(" | ")} |
+`;
+    results.forEach((row) => {
+      const rowData = columns.map((col) => {
+        const val = row[col.name];
+        return val === void 0 || val === null ? "" : String(val).replace(/\|/g, "\\|");
+      });
+      tableMd += `| ${rowData.join(" | ")} |
+`;
+    });
+  } else {
+    tableMd = "(No columns defined for this table)";
+  }
+  return { rows: results, markdown: tableMd };
+};
+
+// packages/ai/tools/toolResultError.ts
+var ToolResultError = class extends Error {
+  code;
+  rawData;
+  displayData;
+  retryable;
+  constructor(message, options) {
+    super(message);
+    this.name = "ToolResultError";
+    this.code = options?.code;
+    this.rawData = options?.rawData;
+    this.displayData = options?.displayData;
+    this.retryable = options?.retryable;
+  }
+};
+var getToolResultErrorData = (error) => {
+  if (!error || typeof error !== "object") return null;
+  const candidate = error;
+  return {
+    rawData: candidate.rawData,
+    displayData: candidate.displayData,
+    code: candidate.code,
+    retryable: candidate.retryable,
+    message: candidate.message
+  };
+};
+
+// packages/ai/tools/agentSkillConfig.ts
+var MODES = [
+  "required",
+  "recommended",
+  "disabled"
+];
+var DEFAULT_RECOMMENDED_SKILL_SLUGS = [
+  "worktree-isolation",
+  "systematic-investigation",
+  "show-me"
+];
+var asMode = (value) => typeof value === "string" && MODES.includes(value) ? value : null;
+var resolveAgentSkillConfig = (source) => {
+  const out = {};
+  const skills = source?.skills;
+  if (skills && typeof skills === "object" && !Array.isArray(skills)) {
+    for (const [rawSlug, rawMode] of Object.entries(skills)) {
+      const slug = typeof rawSlug === "string" ? rawSlug.trim() : "";
+      const mode = asMode(rawMode);
+      if (slug && mode) out[slug] = mode;
+    }
+    return out;
+  }
+  for (const slug of asTrimmedNonEmptyStringArray(source?.enabledPacks) ?? []) {
+    out[slug] = "required";
+  }
+  return out;
+};
+var resolveAgentRequiredPackIds = (source) => {
+  const config = resolveAgentSkillConfig(source);
+  return Object.keys(config).filter((slug) => config[slug] === "required");
+};
+var resolveAgentRecommendedSkillNames = (source, lookup) => {
+  const config = resolveAgentSkillConfig(source);
+  const resolve = lookup ?? defaultSkillTitleLookup;
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  const push = (slug) => {
+    const title = resolve(slug)?.title || slug;
+    if (seen.has(title)) return;
+    seen.add(title);
+    out.push(title);
+  };
+  for (const slug of Object.keys(config)) {
+    if (config[slug] !== "recommended") continue;
+    push(slug);
+  }
+  for (const slug of DEFAULT_RECOMMENDED_SKILL_SLUGS) {
+    if (Object.hasOwn(config, slug)) continue;
+    push(slug);
+  }
+  return out;
+};
+var defaultSkillTitleLookup = (slug) => {
+  const cap = resolveBuiltinCapability(slug);
+  if (cap) return { title: cap.title };
+  const skill = resolveBuiltinSkillEntry(slug);
+  return skill ? { title: skill.title } : null;
+};
+var isAgentSkillDisabled = (source, slug) => resolveAgentSkillConfig(source)[slug] === "disabled";
+
+// packages/ai/tools/toolRunStore.ts
+var import_react = __toESM(require_react());
+var createToolRunId = () => `toolrun_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+var runsById = /* @__PURE__ */ new Map();
+var listeners = /* @__PURE__ */ new Set();
+var version = 0;
+var notify = () => {
+  version += 1;
+  for (const listener of listeners) {
+    try {
+      listener();
+    } catch {
+    }
+  }
+};
+function toolRunStarted(payload) {
+  const {
+    id,
+    messageId,
+    toolName,
+    behavior,
+    inputSummary,
+    startedAt,
+    interaction,
+    input
+  } = payload;
+  runsById.set(id, {
+    id,
+    messageId,
+    toolName,
+    behavior,
+    inputSummary,
+    status: "running",
+    startedAt: startedAt ?? Date.now(),
+    interaction,
+    input,
+    error: void 0,
+    finishedAt: void 0,
+    outputSummary: void 0,
+    steps: void 0
+  });
+  notify();
+}
+function toolRunSetPending(payload) {
+  const { id } = payload;
+  const run = runsById.get(id);
+  if (run) {
+    run.status = "pending";
+    notify();
+  }
+}
+function toolRunSucceeded(payload) {
+  const { id, outputSummary, steps, finishedAt } = payload;
+  const run = runsById.get(id);
+  if (run) {
+    run.status = "succeeded";
+    run.outputSummary = outputSummary;
+    if (steps !== void 0) {
+      run.steps = steps;
+    }
+    run.finishedAt = finishedAt ?? Date.now();
+    notify();
+  }
+}
+function toolRunUpdated(payload) {
+  const { id, outputSummary, steps } = payload;
+  const run = runsById.get(id);
+  if (run) {
+    if (outputSummary !== void 0) {
+      run.outputSummary = outputSummary;
+    }
+    if (steps !== void 0) {
+      run.steps = steps;
+    }
+    notify();
+  }
+}
+function toolRunFailed(payload) {
+  const { id, error, outputSummary, steps, finishedAt } = payload;
+  const run = runsById.get(id);
+  if (run) {
+    run.status = "failed";
+    run.error = error;
+    if (outputSummary !== void 0) {
+      run.outputSummary = outputSummary;
+    }
+    if (steps !== void 0) {
+      run.steps = steps;
+    }
+    run.finishedAt = finishedAt ?? Date.now();
+    notify();
+  }
+}
+function getAllToolRuns() {
+  return Array.from(runsById.values()).sort((a, b) => a.startedAt - b.startedAt);
+}
+function getToolRunById(id) {
+  return runsById.get(id);
+}
+var executeToolRun = createAsyncThunk(
+  "toolRun/executeToolRun",
+  async ({ id, inputOverride }, thunkApi) => {
+    const run = getToolRunById(id);
+    if (!run) {
+      throw new Error(`ToolRun not found: ${id}`);
+    }
+    const executionInput = inputOverride ?? run.input;
+    if (!executionInput) {
+      throw new Error(`ToolRun ${id} has no input to execute with.`);
+    }
+    const { findToolExecutor } = await import("./tools-DU4JXVAV.js");
+    const { executor } = findToolExecutor(run.toolName);
+    toolRunStarted({
+      id: run.id,
+      messageId: run.messageId,
+      toolName: run.toolName,
+      behavior: run.behavior,
+      inputSummary: run.inputSummary,
+      startedAt: Date.now(),
+      interaction: run.interaction,
+      input: executionInput
+    });
+    try {
+      const result = await executor(executionInput, thunkApi, {
+        parentMessageId: run.messageId
+      });
+      toolRunSucceeded({
+        id: run.id,
+        outputSummary: result?.displayData || ""
+      });
+      if (run.toolName === "deleteSpaces") {
+        const latestState = thunkApi.getState();
+        const userId = selectIdentityUserId(latestState);
+        if (userId) {
+          const { fetchUserSpaceMemberships } = await import("./memberThunks-5ZXPR63F.js");
+          await thunkApi.dispatch(fetchUserSpaceMemberships(userId));
+        }
+      }
+      return {
+        id: run.id,
+        rawData: result?.rawData,
+        displayData: result?.displayData
+      };
+    } catch (e) {
+      const msg = toErrorMessage(e);
+      const structured = getToolResultErrorData(e);
+      toolRunFailed({
+        id: run.id,
+        error: msg,
+        outputSummary: asOptionalTrimmedString(structured?.displayData)
+      });
+      throw e;
+    }
+  }
+);
+
+export {
+  clipMultilineText,
+  fetchAndSerializeTable,
+  ToolResultError,
+  getToolResultErrorData,
+  resolveAgentRequiredPackIds,
+  resolveAgentRecommendedSkillNames,
+  isAgentSkillDisabled,
+  waitForAbortableDelay,
+  createSSEParser,
+  createToolRunId,
+  toolRunStarted,
+  toolRunSetPending,
+  toolRunSucceeded,
+  toolRunUpdated,
+  toolRunFailed,
+  getAllToolRuns
+};

package/{chunk-HNRASX3X.js → chunk-CPUFH46E.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-UAD2WT54.js";
 import {
   toTimestampMs
-} from "./chunk-QALRKMHF.js";
+} from "./chunk-HYZIYH2H.js";
 import {
   fetchFromServer,
   getAllServers

package/{chunk-GMVELWJG.js → chunk-CU3QB4HW.js}

@@ -1,7 +1,7 @@
 import {
   selectCurrentServer,
   selectRemoteServers
-} from "./chunk-3IYMTWYZ.js";
+} from "./chunk-SONWNI3L.js";
 import {
   createUserKey,
   extractAgentInfo,
@@ -14,7 +14,7 @@ import {
 import {
   noloDeleteRequest,
   noloWriteRequest
-} from "./chunk-AUXHZ2M5.js";
+} from "./chunk-WIWM4FE3.js";
 import {
   normalizeTimeFields
 } from "./chunk-QOKAKDPE.js";

package/{chunk-QWYHDF4G.js → chunk-DCFPQW22.js}

@@ -1,9 +1,9 @@
 import {
   toolRegistry
-} from "./chunk-GP4TSLAB.js";
+} from "./chunk-2JMMBU6V.js";
 import {
   i18n_default
-} from "./chunk-C4YCNZFV.js";
+} from "./chunk-42Z3EMC4.js";
 import {
   canonicalizeToolNames
 } from "./chunk-XUWRURDF.js";

package/{chunk-XA4RT4LC.js → chunk-DIXLJWCD.js}

@@ -5,7 +5,7 @@ import {
   inlineImageUrlsForCustomProvider,
   prepareTools,
   shouldInlineImageUrlsForAgent
-} from "./chunk-QWYHDF4G.js";
+} from "./chunk-DCFPQW22.js";
 import {
   parseApiError
 } from "./chunk-OCZKATRC.js";
@@ -15,20 +15,20 @@ import {
   parseToolCallArguments,
   performFetchRequest,
   sanitizeOutboundMessages
-} from "./chunk-A7WFQXNK.js";
+} from "./chunk-P4BX6FFU.js";
 import {
-  createToolRunId,
   findToolExecutor,
+  toolDefinitionsByName
+} from "./chunk-2JMMBU6V.js";
+import {
+  createSSEParser,
+  createToolRunId,
   getToolResultErrorData,
-  toolDefinitionsByName,
   toolRunFailed,
   toolRunSetPending,
   toolRunStarted,
   toolRunSucceeded
-} from "./chunk-GP4TSLAB.js";
-import {
-  createSSEParser
-} from "./chunk-BJ3KD73I.js";
+} from "./chunk-BKWMNZ2X.js";
 import {
   getCurrentSpaceId
 } from "./chunk-ZJ7UHBJS.js";
@@ -37,10 +37,10 @@ import {
   messageStreamEnd,
   messageStreaming,
   updateToolMessage
-} from "./chunk-C4YCNZFV.js";
+} from "./chunk-42Z3EMC4.js";
 import {
   streamAgentChatTurn
-} from "./chunk-NLBUI6IU.js";
+} from "./chunk-LPVCRQMM.js";
 import {
   addActiveController,
   removeActiveController,
@@ -61,7 +61,7 @@ import {
 import {
   EMPTY_ASSISTANT_REPAIR_PROMPT,
   getModelInfo
-} from "./chunk-ZSPC3ZTC.js";
+} from "./chunk-AKG5W4LG.js";
 import {
   toErrorMessage
 } from "./chunk-HNMXYYJR.js";
@@ -70,10 +70,10 @@ import {
 } from "./chunk-3BXNTXYI.js";
 import {
   selectCurrentServer
-} from "./chunk-3IYMTWYZ.js";
+} from "./chunk-SONWNI3L.js";
 import {
   write
-} from "./chunk-QALRKMHF.js";
+} from "./chunk-HYZIYH2H.js";
 import {
   createDialogMessageKeyAndId,
   dialogMessageKey,
@@ -81,7 +81,7 @@ import {
 } from "./chunk-3AH7LNUB.js";
 import {
   createAsyncThunk
-} from "./chunk-AUXHZ2M5.js";
+} from "./chunk-WIWM4FE3.js";
 import {
   isAbortError
 } from "./chunk-QOKAKDPE.js";

package/{chunk-2EE5UD3N.js → chunk-DY7ANLKG.js}

@@ -15,7 +15,7 @@ import {
 } from "./chunk-CYSYR67N.js";
 import {
   fnv1a32Hex
-} from "./chunk-AUXHZ2M5.js";
+} from "./chunk-WIWM4FE3.js";
 import {
   isOwnedAgentKey,
   ownedAgentKey,

package/{chunk-YAE5DQ5C.js → chunk-FWQEKRTD.js}

@@ -1,13 +1,13 @@
 import {
   createCliLocalRuntimeAdapter,
   summarizeEndpoint
-} from "./chunk-7V2HN64K.js";
+} from "./chunk-WRMKCKZ3.js";
 import {
   clipMultilineText
-} from "./chunk-GP4TSLAB.js";
+} from "./chunk-BKWMNZ2X.js";
 import {
   runLocalAgentTurn
-} from "./chunk-O7WXJIUI.js";
+} from "./chunk-4H22P2JV.js";
 import {
   applyToolSurfaceConstraints
 } from "./chunk-RGNEEJ3Y.js";

package/{chunk-I44MDY73.js → chunk-GOH6RW6F.js}

@@ -1,13 +1,13 @@
 import {
   listUserRecordsFromServers,
   readLiveDbRecordAfterTombstoneMerge
-} from "./chunk-YU2THNST.js";
+} from "./chunk-XISEYOGH.js";
 import {
   agentRecordHasConfiguredCredential
-} from "./chunk-7NANRWL4.js";
+} from "./chunk-ALGORS6Y.js";
 import {
   deriveCredentialGroup
-} from "./chunk-2EE5UD3N.js";
+} from "./chunk-DY7ANLKG.js";
 import {
   PUBLIC_AGENT_KEY_PREFIX,
   isOwnedAgentKey,