zidane-gui 8.2.4 → 8.2.5
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/out/main/chunks/{history-pager-Bd5PUapJ.js → history-pager-DWgllMof.js} +3 -43
- package/out/main/chunks/session-search-sql-BrNTuwjH.js +196 -0
- package/out/main/chunks/transcript-sql-DbZ-a5wb.js +43 -0
- package/out/main/history-worker.js +2 -1
- package/out/main/index.js +116 -210
- package/out/main/session-search-worker.js +20 -0
- package/out/preload/index.mjs +2 -1
- package/out/renderer/assets/{ghostty-web-BTRdAlae.js → ghostty-web-wgkS5jGl.js} +1 -1
- package/out/renderer/assets/{index-D0Yl489p.js → index-CebkAnp4.js} +429 -72
- package/out/renderer/assets/{index-BI29HKE2.css → index-DqGrzqUj.css} +1 -1
- package/out/renderer/index.html +2 -2
- package/package.json +2 -2
|
@@ -4,6 +4,7 @@ import { Worker } from "node:worker_threads";
|
|
|
4
4
|
import { createReadonlySqliteSessionStore } from "zidane";
|
|
5
5
|
import { createTranscriptReplayCache, transcriptPage, LOAD_EVENTS_MAX_PAGE_TURNS, HISTORY_WORKER_KILL_SWITCH, createWorkerRpcClient, WorkerRequestError, WorkerUnavailableError } from "zidane/ipc";
|
|
6
6
|
import { replayTurns } from "zidane/chat";
|
|
7
|
+
import { b as readTranscript } from "./transcript-sql-DbZ-a5wb.js";
|
|
7
8
|
import __cjs_mod__ from "node:module";
|
|
8
9
|
const __filename = import.meta.filename;
|
|
9
10
|
const __dirname = import.meta.dirname;
|
|
@@ -83,42 +84,6 @@ function createTranscriptPager(options = {}) {
|
|
|
83
84
|
size: () => cache.sizes().entries
|
|
84
85
|
};
|
|
85
86
|
}
|
|
86
|
-
function parseRow(data) {
|
|
87
|
-
try {
|
|
88
|
-
return JSON.parse(data);
|
|
89
|
-
} catch {
|
|
90
|
-
return null;
|
|
91
|
-
}
|
|
92
|
-
}
|
|
93
|
-
function parseRows(rows) {
|
|
94
|
-
return rows.flatMap((r) => {
|
|
95
|
-
const parsed = parseRow(r.data);
|
|
96
|
-
return parsed === null ? [] : [parsed];
|
|
97
|
-
});
|
|
98
|
-
}
|
|
99
|
-
function sessionExistsOn(driver, id) {
|
|
100
|
-
return driver.prepare("SELECT 1 FROM sessions WHERE id = ?").get(id) !== void 0;
|
|
101
|
-
}
|
|
102
|
-
function readRuns(driver, id) {
|
|
103
|
-
return parseRows(
|
|
104
|
-
driver.prepare("SELECT data FROM runs WHERE session_id = ? ORDER BY started_at, run_id").all(id)
|
|
105
|
-
);
|
|
106
|
-
}
|
|
107
|
-
function readTranscript(driver, id) {
|
|
108
|
-
if (!sessionExistsOn(driver, id)) return null;
|
|
109
|
-
const rows = driver.prepare("SELECT seq, data FROM turns WHERE session_id = ? ORDER BY seq").all(id);
|
|
110
|
-
const turns = [];
|
|
111
|
-
const seqs = [];
|
|
112
|
-
const turnSeqs = /* @__PURE__ */ new Map();
|
|
113
|
-
for (const row of rows) {
|
|
114
|
-
const turn = parseRow(row.data);
|
|
115
|
-
if (!turn) continue;
|
|
116
|
-
turns.push(turn);
|
|
117
|
-
seqs.push(row.seq);
|
|
118
|
-
if (typeof turn.id === "string" && !turnSeqs.has(turn.id)) turnSeqs.set(turn.id, row.seq);
|
|
119
|
-
}
|
|
120
|
-
return { data: { turns, seqs, runs: readRuns(driver, id) }, turnSeqs };
|
|
121
|
-
}
|
|
122
87
|
const EVENTS_PAGE_TURNS = 200;
|
|
123
88
|
const HISTORY_PAGER_OPTIONS = {
|
|
124
89
|
pageTurns: EVENTS_PAGE_TURNS,
|
|
@@ -181,11 +146,6 @@ function createLocalHistoryPager(deps) {
|
|
|
181
146
|
}
|
|
182
147
|
export {
|
|
183
148
|
EVENTS_PAGE_TURNS as E,
|
|
184
|
-
|
|
185
|
-
|
|
186
|
-
createHistoryPageHandler as c,
|
|
187
|
-
createLocalHistoryPager as d,
|
|
188
|
-
parseRows as p,
|
|
189
|
-
readRuns as r,
|
|
190
|
-
sessionExistsOn as s
|
|
149
|
+
createLocalHistoryPager as a,
|
|
150
|
+
createHistoryPageHandler as c
|
|
191
151
|
};
|
|
@@ -0,0 +1,196 @@
|
|
|
1
|
+
import { setImmediate } from "node:timers/promises";
|
|
2
|
+
import { searchSessionHistory, searchableTurnText, deriveSessionTitle } from "zidane/chat";
|
|
3
|
+
import { parseSessionKey as parseSessionKey$1, LOCAL_HOST_KEY, sessionKey as sessionKey$1 } from "zidane/chat/pure";
|
|
4
|
+
import { a as parseRow } from "./transcript-sql-DbZ-a5wb.js";
|
|
5
|
+
function tokenizeQuery(query) {
|
|
6
|
+
const tokens = [];
|
|
7
|
+
let i = 0;
|
|
8
|
+
while (i < query.length) {
|
|
9
|
+
while (i < query.length && /\s/u.test(query[i])) i += 1;
|
|
10
|
+
if (i >= query.length) break;
|
|
11
|
+
if (query[i] === '"') {
|
|
12
|
+
i += 1;
|
|
13
|
+
let value = "";
|
|
14
|
+
while (i < query.length && query[i] !== '"') {
|
|
15
|
+
value += query[i];
|
|
16
|
+
i += 1;
|
|
17
|
+
}
|
|
18
|
+
if (query[i] === '"') i += 1;
|
|
19
|
+
if (value.length > 0) tokens.push(value);
|
|
20
|
+
continue;
|
|
21
|
+
}
|
|
22
|
+
const start = i;
|
|
23
|
+
while (i < query.length && !/\s/u.test(query[i])) i += 1;
|
|
24
|
+
tokens.push(query.slice(start, i));
|
|
25
|
+
}
|
|
26
|
+
return tokens;
|
|
27
|
+
}
|
|
28
|
+
const LOCAL_SESSION_HOST = LOCAL_HOST_KEY;
|
|
29
|
+
function sessionKey(hostId, sessionId) {
|
|
30
|
+
return sessionKey$1(hostId, sessionId);
|
|
31
|
+
}
|
|
32
|
+
function localSessionKey(sessionId) {
|
|
33
|
+
return sessionKey(null, sessionId);
|
|
34
|
+
}
|
|
35
|
+
function parseSessionKey(key) {
|
|
36
|
+
const { hostKey, sessionId } = parseSessionKey$1(key);
|
|
37
|
+
return { hostId: hostKey, sessionId };
|
|
38
|
+
}
|
|
39
|
+
function sessionIdOf(key) {
|
|
40
|
+
return parseSessionKey(key).sessionId;
|
|
41
|
+
}
|
|
42
|
+
function serverIdOf(key) {
|
|
43
|
+
const { hostId } = parseSessionKey(key);
|
|
44
|
+
return hostId === LOCAL_SESSION_HOST ? null : hostId;
|
|
45
|
+
}
|
|
46
|
+
function siblingSessionKey(of, id) {
|
|
47
|
+
return sessionKey(serverIdOf(of), id);
|
|
48
|
+
}
|
|
49
|
+
function asSessionKey(value) {
|
|
50
|
+
if (typeof value !== "string" || value.length === 0) throw new Error("A session key must be a non-empty string.");
|
|
51
|
+
const { sessionId } = parseSessionKey(value);
|
|
52
|
+
if (sessionId.length === 0) throw new Error("A session key must name a session.");
|
|
53
|
+
return value;
|
|
54
|
+
}
|
|
55
|
+
const MAX_SCANNED_SESSIONS = 200;
|
|
56
|
+
const MATCHING_TURNS_PER_SESSION = 5;
|
|
57
|
+
const FALLBACK_EXCERPT_RADIUS = 60;
|
|
58
|
+
const DEFAULT_SEARCH_LIMIT = 30;
|
|
59
|
+
const generations = /* @__PURE__ */ new Map();
|
|
60
|
+
async function searchSessions(source, query, filter, { limit = DEFAULT_SEARCH_LIMIT, channel = "sidebar" } = {}) {
|
|
61
|
+
const generation = (generations.get(channel) ?? 0) + 1;
|
|
62
|
+
generations.set(channel, generation);
|
|
63
|
+
const superseded = () => generations.get(channel) !== generation;
|
|
64
|
+
const tokens = tokenizeQuery(query);
|
|
65
|
+
if (tokens.length === 0 || limit <= 0) return [];
|
|
66
|
+
const lowerTokens = tokens.map((t) => t.toLowerCase());
|
|
67
|
+
const archiveAxis = filter?.archive ?? "active";
|
|
68
|
+
const candidates = source.listCandidates(
|
|
69
|
+
filter && "projectRoot" in filter ? { projectRoot: filter.projectRoot ?? null } : void 0
|
|
70
|
+
);
|
|
71
|
+
const hits = [];
|
|
72
|
+
let scanned = 0;
|
|
73
|
+
for (const candidate of candidates) {
|
|
74
|
+
if (superseded() || hits.length >= limit || scanned >= MAX_SCANNED_SESSIONS) break;
|
|
75
|
+
const archived = candidate.metadata.archived === true;
|
|
76
|
+
if (archiveAxis === "active" && archived || archiveAxis === "archived" && !archived) continue;
|
|
77
|
+
scanned += 1;
|
|
78
|
+
let matchCount = 0;
|
|
79
|
+
const matchedTurns = [];
|
|
80
|
+
let cursor = 0;
|
|
81
|
+
while (cursor !== null && !superseded()) {
|
|
82
|
+
const chunk = source.matchTurnsChunk(
|
|
83
|
+
candidate.id,
|
|
84
|
+
lowerTokens,
|
|
85
|
+
cursor,
|
|
86
|
+
Math.max(0, MATCHING_TURNS_PER_SESSION - matchedTurns.length)
|
|
87
|
+
);
|
|
88
|
+
matchCount += chunk.count;
|
|
89
|
+
matchedTurns.push(...chunk.turns);
|
|
90
|
+
cursor = chunk.nextSeq;
|
|
91
|
+
await setImmediate();
|
|
92
|
+
}
|
|
93
|
+
if (superseded()) break;
|
|
94
|
+
if (matchCount === 0) continue;
|
|
95
|
+
const excerpt = buildExcerpt(matchedTurns, query, lowerTokens);
|
|
96
|
+
if (!excerpt) continue;
|
|
97
|
+
hits.push({
|
|
98
|
+
sessionId: localSessionKey(candidate.id),
|
|
99
|
+
title: titleFor(source, candidate),
|
|
100
|
+
excerpt,
|
|
101
|
+
matchCount,
|
|
102
|
+
updatedAt: candidate.updatedAt
|
|
103
|
+
});
|
|
104
|
+
}
|
|
105
|
+
return hits;
|
|
106
|
+
}
|
|
107
|
+
function buildExcerpt(turns, query, lowerTokens) {
|
|
108
|
+
const canonical = searchSessionHistory(turns, query, 1)?.excerpts[0]?.text;
|
|
109
|
+
if (canonical) return collapseWhitespace(canonical);
|
|
110
|
+
for (const turn of turns) {
|
|
111
|
+
const text = searchableTurnText(turn);
|
|
112
|
+
const lowerText = text.toLowerCase();
|
|
113
|
+
for (const token of lowerTokens) {
|
|
114
|
+
const at = lowerText.indexOf(token);
|
|
115
|
+
if (at === -1) continue;
|
|
116
|
+
const start = Math.max(0, at - FALLBACK_EXCERPT_RADIUS);
|
|
117
|
+
const end = Math.min(text.length, at + token.length + FALLBACK_EXCERPT_RADIUS);
|
|
118
|
+
return collapseWhitespace(text.slice(start, end));
|
|
119
|
+
}
|
|
120
|
+
}
|
|
121
|
+
return null;
|
|
122
|
+
}
|
|
123
|
+
function collapseWhitespace(text) {
|
|
124
|
+
return text.replace(/\s+/g, " ").trim();
|
|
125
|
+
}
|
|
126
|
+
function titleFor(source, candidate) {
|
|
127
|
+
const stored = candidate.metadata.title;
|
|
128
|
+
if (typeof stored === "string" && stored.trim().length > 0) return collapseWhitespace(stored);
|
|
129
|
+
const first = source.findFirstUserTurn(candidate.id);
|
|
130
|
+
return deriveSessionTitle(first ? [first] : [], candidate.metadata);
|
|
131
|
+
}
|
|
132
|
+
const NOT_SIDE_SQL = "COALESCE(CASE WHEN json_valid(metadata) THEN json_type(metadata, '$.sideOf') = 'text' END, 0) = 0";
|
|
133
|
+
const SEARCH_CHUNK_ROWS = 2e3;
|
|
134
|
+
function parseRecord(text) {
|
|
135
|
+
try {
|
|
136
|
+
const parsed = JSON.parse(text);
|
|
137
|
+
return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
|
|
138
|
+
} catch {
|
|
139
|
+
return {};
|
|
140
|
+
}
|
|
141
|
+
}
|
|
142
|
+
function needlesWhere(count) {
|
|
143
|
+
return Array.from({ length: count }, () => "instr(lower(data), ?) > 0").join(" AND ");
|
|
144
|
+
}
|
|
145
|
+
function createSessionSearchSql(driver) {
|
|
146
|
+
const loadTurnAt = (id, seq) => {
|
|
147
|
+
const row = driver.prepare("SELECT data FROM turns WHERE session_id = ? AND seq = ?").get(id, seq);
|
|
148
|
+
return row ? parseRow(row.data) : null;
|
|
149
|
+
};
|
|
150
|
+
return {
|
|
151
|
+
listCandidates(filter) {
|
|
152
|
+
const conditions = [NOT_SIDE_SQL];
|
|
153
|
+
const params = [];
|
|
154
|
+
if (filter && "projectRoot" in filter) {
|
|
155
|
+
if (filter.projectRoot === null) conditions.push("project_root IS NULL");
|
|
156
|
+
else if (typeof filter.projectRoot === "string") {
|
|
157
|
+
conditions.push("project_root = ?");
|
|
158
|
+
params.push(filter.projectRoot);
|
|
159
|
+
}
|
|
160
|
+
}
|
|
161
|
+
const rows = driver.prepare(
|
|
162
|
+
`SELECT id, metadata, updated_at FROM sessions WHERE ${conditions.join(" AND ")} ORDER BY updated_at DESC`
|
|
163
|
+
).all(...params);
|
|
164
|
+
return rows.map((r) => ({ id: r.id, metadata: parseRecord(r.metadata), updatedAt: r.updated_at }));
|
|
165
|
+
},
|
|
166
|
+
matchTurnsChunk(id, lowerNeedles, fromSeq, parseLimit) {
|
|
167
|
+
if (lowerNeedles.length === 0) return { count: 0, turns: [], nextSeq: null };
|
|
168
|
+
const boundary = driver.prepare("SELECT seq FROM turns WHERE session_id = ? AND seq >= ? ORDER BY seq LIMIT 1 OFFSET ?").get(id, fromSeq, SEARCH_CHUNK_ROWS);
|
|
169
|
+
const range = boundary ? "session_id = ? AND seq >= ? AND seq < ?" : "session_id = ? AND seq >= ?";
|
|
170
|
+
const rangeParams = boundary ? [id, fromSeq, boundary.seq] : [id, fromSeq];
|
|
171
|
+
const matches = driver.prepare(`SELECT seq FROM turns WHERE ${range} AND ${needlesWhere(lowerNeedles.length)} ORDER BY seq`).all(...rangeParams, ...lowerNeedles);
|
|
172
|
+
const turns = matches.slice(0, Math.max(0, parseLimit)).flatMap((m) => {
|
|
173
|
+
const turn = loadTurnAt(id, m.seq);
|
|
174
|
+
return turn ? [turn] : [];
|
|
175
|
+
});
|
|
176
|
+
return { count: matches.length, turns, nextSeq: boundary ? boundary.seq : null };
|
|
177
|
+
},
|
|
178
|
+
findFirstUserTurn(id) {
|
|
179
|
+
const row = driver.prepare("SELECT data FROM turns WHERE session_id = ? AND role = 'user' ORDER BY seq LIMIT 1").get(id);
|
|
180
|
+
return row ? parseRow(row.data) : null;
|
|
181
|
+
}
|
|
182
|
+
};
|
|
183
|
+
}
|
|
184
|
+
export {
|
|
185
|
+
LOCAL_SESSION_HOST as L,
|
|
186
|
+
NOT_SIDE_SQL as N,
|
|
187
|
+
sessionKey as a,
|
|
188
|
+
serverIdOf as b,
|
|
189
|
+
createSessionSearchSql as c,
|
|
190
|
+
asSessionKey as d,
|
|
191
|
+
siblingSessionKey as e,
|
|
192
|
+
sessionIdOf as f,
|
|
193
|
+
localSessionKey as l,
|
|
194
|
+
parseSessionKey as p,
|
|
195
|
+
searchSessions as s
|
|
196
|
+
};
|
|
@@ -0,0 +1,43 @@
|
|
|
1
|
+
function parseRow(data) {
|
|
2
|
+
try {
|
|
3
|
+
return JSON.parse(data);
|
|
4
|
+
} catch {
|
|
5
|
+
return null;
|
|
6
|
+
}
|
|
7
|
+
}
|
|
8
|
+
function parseRows(rows) {
|
|
9
|
+
return rows.flatMap((r) => {
|
|
10
|
+
const parsed = parseRow(r.data);
|
|
11
|
+
return parsed === null ? [] : [parsed];
|
|
12
|
+
});
|
|
13
|
+
}
|
|
14
|
+
function sessionExistsOn(driver, id) {
|
|
15
|
+
return driver.prepare("SELECT 1 FROM sessions WHERE id = ?").get(id) !== void 0;
|
|
16
|
+
}
|
|
17
|
+
function readRuns(driver, id) {
|
|
18
|
+
return parseRows(
|
|
19
|
+
driver.prepare("SELECT data FROM runs WHERE session_id = ? ORDER BY started_at, run_id").all(id)
|
|
20
|
+
);
|
|
21
|
+
}
|
|
22
|
+
function readTranscript(driver, id) {
|
|
23
|
+
if (!sessionExistsOn(driver, id)) return null;
|
|
24
|
+
const rows = driver.prepare("SELECT seq, data FROM turns WHERE session_id = ? ORDER BY seq").all(id);
|
|
25
|
+
const turns = [];
|
|
26
|
+
const seqs = [];
|
|
27
|
+
const turnSeqs = /* @__PURE__ */ new Map();
|
|
28
|
+
for (const row of rows) {
|
|
29
|
+
const turn = parseRow(row.data);
|
|
30
|
+
if (!turn) continue;
|
|
31
|
+
turns.push(turn);
|
|
32
|
+
seqs.push(row.seq);
|
|
33
|
+
if (typeof turn.id === "string" && !turnSeqs.has(turn.id)) turnSeqs.set(turn.id, row.seq);
|
|
34
|
+
}
|
|
35
|
+
return { data: { turns, seqs, runs: readRuns(driver, id) }, turnSeqs };
|
|
36
|
+
}
|
|
37
|
+
export {
|
|
38
|
+
parseRow as a,
|
|
39
|
+
readTranscript as b,
|
|
40
|
+
parseRows as p,
|
|
41
|
+
readRuns as r,
|
|
42
|
+
sessionExistsOn as s
|
|
43
|
+
};
|
|
@@ -1,11 +1,12 @@
|
|
|
1
1
|
import { DatabaseSync } from "node:sqlite";
|
|
2
2
|
import { createSqliteDriver } from "zidane";
|
|
3
3
|
import { serveWorkerRpc } from "zidane/ipc";
|
|
4
|
-
import { c as createHistoryPageHandler } from "./chunks/history-pager-
|
|
4
|
+
import { c as createHistoryPageHandler } from "./chunks/history-pager-DWgllMof.js";
|
|
5
5
|
import "node:fs";
|
|
6
6
|
import "node:path";
|
|
7
7
|
import "node:worker_threads";
|
|
8
8
|
import "zidane/chat";
|
|
9
|
+
import "./chunks/transcript-sql-DbZ-a5wb.js";
|
|
9
10
|
let handle = null;
|
|
10
11
|
void serveWorkerRpc({
|
|
11
12
|
init({ dbPath }) {
|