@nuvin/session 0.1.0-rc.5

package/dist/chunk-FR3R66RD.js

@@ -0,0 +1,678 @@
+// src/state/approvals.ts
+var READ_ONLY_TOOLS = /* @__PURE__ */ new Set([
+  "FileRead",
+  "ViewFile",
+  "Ls",
+  "Grep",
+  "Glob",
+  "LoadSkill",
+  "Lsp",
+  "WebFetch",
+  "WebSearch"
+]);
+var BACKGROUNDLESS_TOOLS = /* @__PURE__ */ new Set([...READ_ONLY_TOOLS, "FileNew"]);
+var INTERACTIVE_TOOLS = /* @__PURE__ */ new Set(["AskUserTool", "TodoWrite", "UpdateTopic"]);
+var AUTO_APPROVED_TOOLS = /* @__PURE__ */ new Set([...READ_ONLY_TOOLS, ...INTERACTIVE_TOOLS]);
+function isAutoApprovedTool(toolName) {
+  return AUTO_APPROVED_TOOLS.has(toolName);
+}
+function createApprovalQueueState() {
+  return { active: null, pending: [] };
+}
+function enqueueApproval(state, approval) {
+  if (!state.active) {
+    return { ...state, active: approval };
+  }
+  return { ...state, pending: [...state.pending, approval] };
+}
+function dequeueActiveApproval(state) {
+  const [nextApproval, ...remainingApprovals] = state.pending;
+  return { active: nextApproval ?? null, pending: remainingApprovals };
+}
+function removeApproval(state, matches) {
+  if (state.active && matches(state.active)) {
+    return dequeueActiveApproval(state);
+  }
+  const pending = state.pending.filter((item) => !matches(item));
+  return pending.length === state.pending.length ? state : { ...state, pending };
+}
+
+// src/state/json.ts
+function asJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+
+// src/state/messages.ts
+import { getReasoningTextFromMessage, getTextFromMessage } from "@nuvin/agent-core/formats";
+function createMessageId(state) {
+  return `message-${state.nextId}`;
+}
+function withUpdatedMessage(state, id, update) {
+  return {
+    ...state,
+    messages: state.messages.map((message) => message.id === id ? update(message) : message)
+  };
+}
+function addMessage(state, message) {
+  return {
+    ...state,
+    messages: [...state.messages, message],
+    nextId: state.nextId + 1
+  };
+}
+function scopedRegistryKey(scope, id) {
+  return scope ? `${scope}::${id}` : id;
+}
+function upsertTrackedTextMessage(state, registryKey, messageId, role, text, mode, live, parentToolCallId, timing) {
+  const trackingKey = scopedRegistryKey(parentToolCallId, messageId);
+  const existingId = state[registryKey][trackingKey];
+  if (existingId) {
+    return withUpdatedMessage(state, existingId, (message) => {
+      if (message.role !== role) {
+        return message;
+      }
+      const updated = {
+        ...message,
+        live,
+        text: mode === "append" ? `${message.text}${text}` : text
+      };
+      if (timing !== void 0 && !live && updated.completedAt === void 0) {
+        updated.completedAt = timing;
+      }
+      return updated;
+    });
+  }
+  const id = createMessageId(state);
+  const nextState = addMessage(state, {
+    id,
+    role,
+    text,
+    live,
+    ...parentToolCallId ? { parentToolCallId } : {},
+    ...timing !== void 0 ? { startedAt: timing } : {},
+    // A reasoning message that arrives already-settled stamps completedAt too.
+    ...timing !== void 0 && !live ? { completedAt: timing } : {}
+  });
+  return {
+    ...nextState,
+    [registryKey]: {
+      ...nextState[registryKey],
+      [trackingKey]: id
+    }
+  };
+}
+function settleLiveReasoning(state, parentToolCallId, now) {
+  let changed = false;
+  const messages = state.messages.map((message) => {
+    if (message.role === "reasoning" && message.live && message.parentToolCallId === parentToolCallId) {
+      changed = true;
+      return { ...message, live: false, completedAt: message.completedAt ?? now };
+    }
+    return message;
+  });
+  return changed ? { ...state, messages } : state;
+}
+function summarizeToolInput(input) {
+  const objectInput = asJsonObject(input);
+  if (!objectInput) {
+    return JSON.stringify(input);
+  }
+  const command = objectInput.command;
+  if (typeof command === "string") {
+    return command;
+  }
+  const entries = Object.entries(objectInput);
+  if (entries.length === 1 && typeof entries[0]?.[1] === "string") {
+    return String(entries[0][1]);
+  }
+  return JSON.stringify(objectInput);
+}
+var BASH_STREAMING_PREVIEW_LINES = 5;
+var STREAM_TAIL_BUDGET = 64 * 1024;
+function countNewlines(text) {
+  let count = 0;
+  for (let index = 0; index < text.length; index++) {
+    if (text.charCodeAt(index) === 10) count++;
+  }
+  return count;
+}
+function capTail(text) {
+  return text.length > STREAM_TAIL_BUDGET ? text.slice(-STREAM_TAIL_BUDGET) : text;
+}
+function trailingWhitespaceLength(text) {
+  const match = /\s*$/.exec(text);
+  return match ? match[0].length : 0;
+}
+function seedStreamAcc(priorText) {
+  const trailLen = trailingWhitespaceLength(priorText);
+  const contentEnd = priorText.length - trailLen;
+  const trailingWs = priorText.slice(contentEnd);
+  return {
+    rawNewlines: countNewlines(priorText),
+    contentTail: capTail(priorText.slice(0, contentEnd)),
+    trailingWs: capTail(trailingWs),
+    trailingWsNewlines: countNewlines(trailingWs)
+  };
+}
+function advanceStreamAcc(acc, chunk) {
+  const rawNewlines = acc.rawNewlines + countNewlines(chunk);
+  const chunkTrailLen = trailingWhitespaceLength(chunk);
+  const chunkContentEnd = chunk.length - chunkTrailLen;
+  if (chunkContentEnd === 0) {
+    return {
+      rawNewlines,
+      contentTail: acc.contentTail,
+      trailingWs: capTail(acc.trailingWs + chunk),
+      trailingWsNewlines: acc.trailingWsNewlines + countNewlines(chunk)
+    };
+  }
+  const chunkTrailingWs = chunk.slice(chunkContentEnd);
+  return {
+    rawNewlines,
+    contentTail: capTail(acc.contentTail + acc.trailingWs + chunk.slice(0, chunkContentEnd)),
+    trailingWs: chunkTrailingWs,
+    trailingWsNewlines: countNewlines(chunkTrailingWs)
+  };
+}
+function previewFromStreamAcc(acc) {
+  if (acc.contentTail.length === 0) return void 0;
+  const totalLines = acc.rawNewlines - acc.trailingWsNewlines + 1;
+  let start = acc.contentTail.length;
+  let newlinesSeen = 0;
+  while (start > 0) {
+    if (acc.contentTail.charCodeAt(start - 1) === 10) {
+      newlinesSeen++;
+      if (newlinesSeen === BASH_STREAMING_PREVIEW_LINES) break;
+    }
+    start--;
+  }
+  return { text: acc.contentTail.slice(start), totalLines, acc };
+}
+function advanceStreamingPreview(priorText, chunk, previous) {
+  const acc = previous?.acc ?? seedStreamAcc(priorText);
+  return previewFromStreamAcc(advanceStreamAcc(acc, chunk));
+}
+function mergeToolResultText(currentText, result) {
+  if (currentText.length === 0) {
+    return result.output;
+  }
+  if (result.output.length === 0 || currentText === result.output) {
+    return currentText;
+  }
+  if (result.output.startsWith(currentText)) {
+    return result.output;
+  }
+  return currentText;
+}
+function ensureToolMessage(state, toolCall, parentToolCallId) {
+  const existingId = state.toolMessageIds[toolCall.id];
+  if (existingId) {
+    return withUpdatedMessage(state, existingId, (message) => {
+      if (message.role !== "tool" || message.input !== void 0) {
+        return message;
+      }
+      return {
+        ...message,
+        input: asJsonObject(toolCall.input)
+      };
+    });
+  }
+  const id = createMessageId(state);
+  const nextState = addMessage(state, {
+    id,
+    role: "tool",
+    toolName: toolCall.name,
+    toolCallId: toolCall.id,
+    summary: summarizeToolInput(toolCall.input),
+    text: "",
+    status: "pending",
+    input: asJsonObject(toolCall.input),
+    ...parentToolCallId ? { parentToolCallId } : {}
+  });
+  return {
+    ...nextState,
+    toolMessageIds: {
+      ...nextState.toolMessageIds,
+      [toolCall.id]: id
+    }
+  };
+}
+function setToolMessageStatus(state, toolCallId, status) {
+  const toolMessageId = state.toolMessageIds[toolCallId];
+  if (!toolMessageId) {
+    return state;
+  }
+  return withUpdatedMessage(state, toolMessageId, (message) => {
+    if (message.role !== "tool") {
+      return message;
+    }
+    return {
+      ...message,
+      status
+    };
+  });
+}
+function setToolMessageHidden(state, toolCallId, hidden) {
+  const toolMessageId = state.toolMessageIds[toolCallId];
+  if (!toolMessageId) {
+    return state;
+  }
+  return withUpdatedMessage(state, toolMessageId, (message) => {
+    if (message.role !== "tool") {
+      return message;
+    }
+    return {
+      ...message,
+      hidden
+    };
+  });
+}
+function applyToolResult(state, result, now) {
+  const toolMessageId = state.toolMessageIds[result.callId];
+  if (!toolMessageId) {
+    const id = createMessageId(state);
+    const next = addMessage(state, {
+      id,
+      completedAt: now,
+      role: "tool",
+      toolName: result.toolName,
+      toolCallId: result.callId,
+      status: result.status,
+      summary: "",
+      text: result.output,
+      structured: result.structured
+    });
+    return {
+      ...next,
+      toolMessageIds: {
+        ...next.toolMessageIds,
+        [result.callId]: id
+      }
+    };
+  }
+  return withUpdatedMessage(state, toolMessageId, (message) => {
+    if (message.role !== "tool") {
+      return message;
+    }
+    return {
+      ...message,
+      completedAt: message.completedAt ?? now,
+      status: result.status,
+      text: mergeToolResultText(message.text, result),
+      structured: result.structured,
+      hidden: false,
+      streamingPreview: void 0
+    };
+  });
+}
+function createMessageState() {
+  return {
+    assistantMessageIds: {},
+    messages: [],
+    nextId: 1,
+    reasoningMessageIds: {},
+    toolMessageIds: {}
+  };
+}
+function createMessageStateFromMessages(messages) {
+  const nextId = messages.reduce((max, message) => {
+    const match = /^message-(\d+)$/.exec(message.id);
+    if (!match) return max;
+    return Math.max(max, Number(match[1]) + 1);
+  }, 1) + messages.length;
+  const toolMessageIds = {};
+  for (const message of messages) {
+    if (message.role === "tool") {
+      toolMessageIds[message.toolCallId] = message.id;
+    }
+  }
+  return {
+    assistantMessageIds: {},
+    messages,
+    nextId,
+    reasoningMessageIds: {},
+    toolMessageIds
+  };
+}
+function appendUserMessage(state, text, attachmentLabels, createdAt) {
+  return addMessage(state, {
+    id: createMessageId(state),
+    role: "user",
+    text,
+    ...attachmentLabels && attachmentLabels.length > 0 ? { attachmentLabels } : {},
+    ...createdAt !== void 0 ? { createdAt } : {}
+  });
+}
+function appendErrorMessage(state, text) {
+  return addMessage(state, {
+    id: createMessageId(state),
+    role: "error",
+    text
+  });
+}
+function appendInfoMessage(state, text) {
+  return addMessage(state, {
+    id: createMessageId(state),
+    role: "info",
+    text
+  });
+}
+function appendWarningMessage(state, text) {
+  return addMessage(state, {
+    id: createMessageId(state),
+    role: "warning",
+    text
+  });
+}
+function applyAgentEvent(state, event, parentToolCallId, now = Date.now()) {
+  switch (event.type) {
+    case "assistant_chunk":
+      if (!event.chunk.text) {
+        return state;
+      }
+      return upsertTrackedTextMessage(
+        settleLiveReasoning(state, parentToolCallId, now),
+        "assistantMessageIds",
+        event.messageId,
+        "assistant",
+        event.chunk.text,
+        "append",
+        true,
+        parentToolCallId
+      );
+    case "assistant_message": {
+      const text = getTextFromMessage(event.message).trim();
+      if (text.length === 0) {
+        return state;
+      }
+      return upsertTrackedTextMessage(
+        settleLiveReasoning(state, parentToolCallId, now),
+        "assistantMessageIds",
+        event.message.id,
+        "assistant",
+        text,
+        "replace",
+        false,
+        parentToolCallId
+      );
+    }
+    case "reasoning_chunk":
+      if (!event.text) {
+        return state;
+      }
+      return upsertTrackedTextMessage(
+        state,
+        "reasoningMessageIds",
+        event.messageId,
+        "reasoning",
+        event.text,
+        "append",
+        true,
+        parentToolCallId,
+        now
+      );
+    case "reasoning_message": {
+      const text = getReasoningTextFromMessage(event.message).trim();
+      if (text.length === 0) {
+        return state;
+      }
+      return upsertTrackedTextMessage(
+        state,
+        "reasoningMessageIds",
+        event.message.id,
+        "reasoning",
+        text,
+        "replace",
+        false,
+        parentToolCallId,
+        now
+      );
+    }
+    case "final_message": {
+      const text = getTextFromMessage(event.message).trim();
+      if (text.length === 0) {
+        return state;
+      }
+      return upsertTrackedTextMessage(
+        settleLiveReasoning(state, parentToolCallId, now),
+        "assistantMessageIds",
+        event.message.id,
+        "assistant",
+        text,
+        "replace",
+        false,
+        parentToolCallId
+      );
+    }
+    case "tool_call":
+      return ensureToolMessage(state, event.toolCall, parentToolCallId);
+    case "tool_started": {
+      const toolState = ensureToolMessage(state, event.toolCall, parentToolCallId);
+      const toolMessageId = toolState.toolMessageIds[event.toolCall.id];
+      return withUpdatedMessage(toolState, toolMessageId, (message) => {
+        if (message.role !== "tool") {
+          return message;
+        }
+        return {
+          ...message,
+          startedAt: message.startedAt ?? now,
+          status: "running"
+        };
+      });
+    }
+    case "tool_output_chunk": {
+      const toolState = ensureToolMessage(state, event.toolCall, parentToolCallId);
+      const toolMessageId = toolState.toolMessageIds[event.toolCall.id];
+      return withUpdatedMessage(toolState, toolMessageId, (message) => {
+        if (message.role !== "tool") {
+          return message;
+        }
+        const nextText = `${message.text}${event.chunk.output}`;
+        return {
+          ...message,
+          text: nextText,
+          streamingPreview: message.toolName === "Bash" ? (
+            // Pass the PRIOR text (not the concatenation): the builder works
+            // from a bounded accumulator and only reads prior text on reseed,
+            // so `message.text` is never indexed and never flattened here.
+            advanceStreamingPreview(message.text, event.chunk.output, message.streamingPreview)
+          ) : message.streamingPreview
+        };
+      });
+    }
+    case "tool_completed": {
+      const toolState = ensureToolMessage(state, event.toolCall, parentToolCallId);
+      return applyToolResult(toolState, event.result, now);
+    }
+    case "tool_result":
+      return applyToolResult(state, event.result, now);
+    case "tool_rejected": {
+      const toolState = ensureToolMessage(state, event.toolCall, parentToolCallId);
+      const toolMessageId = toolState.toolMessageIds[event.toolCall.id];
+      return withUpdatedMessage(toolState, toolMessageId, (message) => {
+        if (message.role !== "tool") {
+          return message;
+        }
+        return {
+          ...message,
+          completedAt: message.completedAt ?? now,
+          status: "rejected",
+          text: event.result.output,
+          structured: event.result.structured
+        };
+      });
+    }
+    case "provider_retry": {
+      const delaySeconds = Math.max(1, Math.ceil(event.delayMs / 1e3));
+      const delayText = event.delayMs > 0 ? `in ${delaySeconds}s` : "now";
+      return appendWarningMessage(
+        state,
+        `Provider request failed, retrying ${delayText} (${event.attempt}/${event.maxAttempts})\u2026`
+      );
+    }
+    default:
+      return state;
+  }
+}
+
+// src/state/workflow-view.ts
+function createWorkflowViewState(runId) {
+  return { runId, status: "running", tree: [], counts: {}, tokens: 0, lastSeq: -1, nodeKeys: {} };
+}
+function nodeIdentity(delta) {
+  return `${delta.nodeId}\0${delta.instanceKey ?? ""}\0${delta.roundKey ?? ""}`;
+}
+function coarseStatus(status) {
+  if (status === "failed") return "failed";
+  if (status === "skipped") return "skipped";
+  if (status === "aborted") return "stopped";
+  return "done";
+}
+function setStatus(tree, phase, title, status) {
+  const phaseIdx = tree.findIndex((p) => p.title === phase);
+  if (phaseIdx === -1) return [...tree, { title: phase, children: [{ title, status }] }];
+  const phaseNode = tree[phaseIdx];
+  const children = phaseNode.children ?? [];
+  const childIdx = children.findIndex((c) => c.title === title);
+  const nextChildren = childIdx === -1 ? [...children, { title, status }] : children.map((c, i) => i === childIdx ? { ...c, status } : c);
+  return tree.map((p, i) => i === phaseIdx ? { ...phaseNode, children: nextChildren } : p);
+}
+function foldWorkflowDelta(state, delta) {
+  if (delta.seq <= state.lastSeq) return state;
+  const base = { ...state, lastSeq: delta.seq };
+  switch (delta.type) {
+    case "node-started": {
+      if (delta.kind === "source" || delta.kind === "sink") return base;
+      const phase = delta.phase ?? "";
+      const title = delta.title ?? delta.nodeId;
+      return {
+        ...base,
+        currentPhase: phase,
+        counts: { ...base.counts, [delta.kind]: (base.counts[delta.kind] ?? 0) + 1 },
+        nodeKeys: { ...base.nodeKeys, [nodeIdentity(delta)]: [phase, title] },
+        tree: setStatus(base.tree, phase, title, "running")
+      };
+    }
+    case "node-finished": {
+      const tokens = base.tokens + (delta.tokens ?? 0);
+      const key = base.nodeKeys[nodeIdentity(delta)];
+      if (!key) return { ...base, tokens };
+      return {
+        ...base,
+        tokens,
+        tree: setStatus(base.tree, key[0], key[1], coarseStatus(delta.status))
+      };
+    }
+    case "run-finished":
+      return { ...base, status: delta.status };
+    default:
+      return base;
+  }
+}
+
+// src/state/session.ts
+function createSessionViewState() {
+  return {
+    approval: createApprovalQueueState(),
+    authFlow: null,
+    busy: false,
+    messages: createMessageState(),
+    meta: { approvalMode: "ask before tools", cwd: "", modelName: "", persona: "default" },
+    metrics: null,
+    queuedCount: 0,
+    queued: [],
+    workflows: {},
+    question: { active: null }
+  };
+}
+function reduceSessionEvent(state, event) {
+  switch (event.type) {
+    case "agent-event": {
+      let messages = applyAgentEvent(
+        state.messages,
+        event.event,
+        event.scope?.parentToolCallId,
+        event.at
+      );
+      if (event.toolStatus && event.event.type === "tool_call") {
+        messages = setToolMessageStatus(messages, event.event.toolCall.id, event.toolStatus);
+      }
+      return { ...state, messages };
+    }
+    case "user-message":
+      return {
+        ...state,
+        messages: appendUserMessage(state.messages, event.text, event.attachmentLabels, event.at)
+      };
+    case "approval-requested":
+      return {
+        ...state,
+        approval: enqueueApproval(state.approval, event.approval),
+        messages: setToolMessageHidden(state.messages, event.approval.toolCallId, true)
+      };
+    case "approval-settled": {
+      const stamped = setToolMessageStatus(state.messages, event.toolCallId, event.status);
+      return {
+        ...state,
+        approval: removeApproval(state.approval, (item) => item.toolCallId === event.toolCallId),
+        // Approved tools materialize as a transcript row; rejected ones never
+        // ran and stay hidden.
+        messages: event.status === "approved" ? setToolMessageHidden(stamped, event.toolCallId, false) : stamped
+      };
+    }
+    case "question-asked":
+      return { ...state, question: { active: event.question } };
+    case "question-settled":
+      return state.question.active?.questionId === event.questionId ? { ...state, question: { active: null } } : state;
+    case "turn-status":
+      return {
+        ...state,
+        busy: event.busy,
+        queuedCount: event.queuedCount,
+        queued: event.queued ?? []
+      };
+    case "info":
+      return { ...state, messages: appendInfoMessage(state.messages, event.message) };
+    case "error":
+      return { ...state, messages: appendErrorMessage(state.messages, event.message) };
+    case "session-meta":
+      return { ...state, meta: event.meta };
+    case "metrics":
+      return { ...state, metrics: event.snapshot };
+    case "auth-flow":
+      return { ...state, authFlow: event.flow };
+    case "workflow-progress": {
+      const prev = state.workflows[event.runId] ?? createWorkflowViewState(event.runId);
+      return {
+        ...state,
+        workflows: { ...state.workflows, [event.runId]: foldWorkflowDelta(prev, event.delta) }
+      };
+    }
+    case "state-reset":
+      return event.state;
+    default:
+      return state;
+  }
+}
+
+export {
+  READ_ONLY_TOOLS,
+  BACKGROUNDLESS_TOOLS,
+  isAutoApprovedTool,
+  createApprovalQueueState,
+  enqueueApproval,
+  dequeueActiveApproval,
+  removeApproval,
+  asJsonObject,
+  setToolMessageStatus,
+  setToolMessageHidden,
+  createMessageState,
+  createMessageStateFromMessages,
+  appendUserMessage,
+  appendErrorMessage,
+  appendInfoMessage,
+  appendWarningMessage,
+  applyAgentEvent,
+  createSessionViewState,
+  reduceSessionEvent
+};

package/dist/chunk-UVJIG4DT.js

@@ -0,0 +1,17 @@
+// src/state/dir-access.ts
+import * as path from "path";
+function dirContains(dir, target) {
+  const relative2 = path.relative(path.resolve(dir), path.resolve(target));
+  return relative2 === "" || !relative2.startsWith("..") && !path.isAbsolute(relative2);
+}
+function resolveGrantDir(requestedPath, proposedDir, edited) {
+  const trimmed = edited?.trim();
+  if (!trimmed) return proposedDir;
+  const dir = path.resolve(trimmed);
+  return dirContains(dir, requestedPath) ? dir : proposedDir;
+}
+
+export {
+  dirContains,
+  resolveGrantDir
+};