chat

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133// Each chat has one pane view, kept while it is one of the last few
// shown so switching back is instant. Detail views (a subagent, a
// workflow, the agents list) open in tabs through the convergence/tabs
// service.
import * as Scope from "effect/Scope";
import * as Effect from "effect/Effect";
import type { Chat, Element, ViewHandle } from "convergence";
import type { Controller, ChatError, ChatView } from "./controller.ts";
import { renderPane } from "./views/panes.ts";
import { renderAgentsPane, renderSubagentPane, renderWorkflowPane } from "./views/tasks.ts";
import { findTask, nameOf } from "./subagents.ts";
import { loadOptions, loadTranscript, loadRequests, noteRecent, refreshHistory } from "./data.ts";

/** Chats whose panes stay mounted (the one shown and the last before it). */
const RETAINED = 3;

export const ensureComposer = Effect.fn("Chat.ensureComposer")(function* (c: Controller, chatId: string) {
  if (!c.state.composers[chatId]) {
    c.composer(chatId);
    if (c.state.restored) delete c.state.restored[chatId];
    yield* Effect.forkIn(loadOptions(c, chatId), c.scope, { startImmediately: true });
  }
});
export const ensureChat = Effect.fn("Chat.ensureChat")(function* (c: Controller, chatId: string) {
  if (!c.state.transcripts[chatId]) {
    c.transcript(chatId);
    yield* Effect.forkIn(loadTranscript(c, chatId), c.scope, { startImmediately: true });
    yield* Effect.forkIn(loadRequests(c, chatId), c.scope, { startImmediately: true });
  }
});
// The chat's pane view, made the first time it shows; the oldest beyond
// the retained few goes.
export const ensurePane = Effect.fn("Chat.ensurePane")(function* (c: Controller, chatId: string) {
  if (!c.state.panes[chatId]) {
    const view = yield* c.views
      .slot("pane", (ctx) => renderPane({ controller: c, ctx }, chatId), {
        key: `chat:${chatId}`,
        on: ["chat_changed", "agents_changed"],
      })
      .pipe(Effect.provideService(Scope.Scope, c.scope));
    c.state.panes[chatId] = { chatId, view };
  }
  c.state.recentPanes = [chatId, ...c.state.recentPanes.filter((id) => id !== chatId)];
  for (const old of c.state.recentPanes.splice(RETAINED)) removePane(c, old);
});
export function removePane(c: Controller, chatId: string) {
  c.state.panes[chatId]?.view.remove();
  delete c.state.panes[chatId];
  c.state.recentPanes = c.state.recentPanes.filter((id) => id !== chatId);
}
export const followApp = Effect.fn("Chat.followApp")(function* (c: Controller): Effect.fn.Return<void, ChatError> {
  const app = c.api.app.state();
  if (app.route !== "chat" || !app.chatId) return;
  const chat = c.state.chats[app.chatId];
  if (!chat) return;
  yield* Effect.forkIn(noteRecent(c, chat.id), c.scope, { startImmediately: true });
  if (chat.id !== c.state.promptedChat && !c.state.switcher) {
    c.state.promptedChat = chat.id;
    yield* c.views.focus(`prompt-${chat.id}`);
  }
  if (chat.id !== c.state.historyChat) {
    c.state.historyChat = chat.id;
    yield* Effect.forkIn(refreshHistory(c, chat.id), c.scope, { startImmediately: true });
  }
  yield* ensurePane(c, chat.id);
});
const paneView = Effect.fn("Chat.paneView")(function* (
  c: Controller,
  key: string,
  chatId: string,
  render: (v: ChatView) => Element | null,
) {
  let entry = c.state.paneViews[key];
  if (!entry) {
    const view = yield* c.views
      .slot("subagent", (ctx) => render({ controller: c, ctx }), { key, on: ["chat_changed", "agents_changed"] })
      .pipe(Effect.provideService(Scope.Scope, c.scope));
    entry = c.state.paneViews[key] = { chatId, view };
  }
  return entry.view;
});
const showInPane = Effect.fn("Chat.showInPane")(function* (
  c: Controller,
  chat: Chat,
  key: string,
  title: string,
  icon: string,
  pane: ViewHandle,
) {
  const client = c.tabs;
  // Without the tabs plugin there is no detail pane; the shared request the
  // baseline wrote would have had no reader either.
  if (!client) return;
  yield* client.open({ kind: "view", workspaceId: chat.workspaceId, path: key, title, icon, view: pane.id }).pipe(
    // A call that loses its provider on the way behaves like no reader.
    Effect.ignore,
  );
});
export const openWorkflow = Effect.fn("Chat.openWorkflow")(function* (c: Controller, chat: Chat, taskId: string) {
  const key = `workflow/${chat.id}/${taskId}`,
    pane = yield* paneView(c, key, chat.id, (v) => renderWorkflowPane(v, chat.id, taskId));
  const item = findTask(c.transcript(chat.id).items, taskId);
  yield* showInPane(
    c,
    chat,
    key,
    item ? item.task.name || item.task.title || "Workflow" : "Workflow",
    "workflow",
    pane,
  );
});
export const openSubagent = Effect.fn("Chat.openSubagent")(function* (
  c: Controller,
  chat: Chat,
  taskId: string,
): Effect.fn.Return<void, ChatError> {
  if (findTask(c.transcript(chat.id).items, taskId)?.task.workflow) return yield* openWorkflow(c, chat, taskId);
  const key = `subagent/${chat.id}/${taskId}`,
    pane = yield* paneView(c, key, chat.id, (v) => renderSubagentPane(v, chat.id, taskId));
  const item = findTask(c.transcript(chat.id).items, taskId);
  yield* showInPane(c, chat, key, item ? item.task.title || nameOf(item.task) : "Subagent", "bot", pane);
});
export const openAgents = Effect.fn("Chat.openAgents")(function* (c: Controller, chat: Chat) {
  const key = `agents/${chat.id}`;
  yield* showInPane(
    c,
    chat,
    key,
    "Agents",
    "network",
    yield* paneView(c, key, chat.id, (v) => renderAgentsPane(v, chat.id)),
  );
});