sphica 0.6.42 → 0.6.44
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/.claude-plugin/plugin.json +7 -1
- package/.codex-plugin/plugin.json +1 -1
- package/README.md +3 -1
- package/dist/capture.js +311 -164
- package/dist/cli.js +501 -343
- package/dist/deliver.js +1078 -541
- package/dist/git-worker.js +365 -0
- package/dist/mcp-record.js +489 -333
- package/dist/mcp.js +359 -232
- package/hooks/codex.json +11 -0
- package/hooks/hooks.json +28 -0
- package/package.json +1 -1
package/dist/deliver.js
CHANGED
|
@@ -1,287 +1,9 @@
|
|
|
1
1
|
#!/usr/bin/env node
|
|
2
2
|
|
|
3
3
|
// server/src/deliver.ts
|
|
4
|
-
import
|
|
5
|
-
import
|
|
6
|
-
import
|
|
7
|
-
|
|
8
|
-
// server/src/anchors.ts
|
|
9
|
-
import path from "node:path";
|
|
10
|
-
|
|
11
|
-
// server/src/text.ts
|
|
12
|
-
import crypto from "node:crypto";
|
|
13
|
-
var segmenter = new Intl.Segmenter("ja", { granularity: "word" });
|
|
14
|
-
var HIRAGANA_ONLY = /^[\p{Script=Hiragana}ー]+$/u;
|
|
15
|
-
var STOP = new Set(["the", "a", "an", "of", "to", "in", "is", "and", "or", "for", "on", "it", "be"]);
|
|
16
|
-
var IDENT = /#\d+|[a-z0-9][a-z0-9_./#-]*[a-z0-9]/g;
|
|
17
|
-
var WORD = /[\p{L}\p{M}\p{N}_]+/gu;
|
|
18
|
-
var JAPANESE = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}ー々]+/u;
|
|
19
|
-
var COMPOUND = /^[A-Za-z0-9_]*(?:[A-Za-z0-9]_|_[A-Za-z0-9]|[a-z0-9][A-Z])[A-Za-z0-9_]*$/;
|
|
20
|
-
var CUT = /_+|(?<=[a-z0-9])(?=[A-Z])/;
|
|
21
|
-
var MAX_PARTS = 6;
|
|
22
|
-
var NAME_PART = /^(?:[A-Za-z]+[0-9]*|[0-9]+)$/;
|
|
23
|
-
var MAX_TERM = 100;
|
|
24
|
-
var OKURIGANA = /^(\p{Script=Han}+)[\p{Script=Hiragana}ー]+$/u;
|
|
25
|
-
function singular(w) {
|
|
26
|
-
if (!/^[a-z]{4,}$/.test(w))
|
|
27
|
-
return w;
|
|
28
|
-
if (w.endsWith("ies"))
|
|
29
|
-
return `${w.slice(0, -3)}y`;
|
|
30
|
-
if (w.endsWith("ie"))
|
|
31
|
-
return `${w.slice(0, -2)}y`;
|
|
32
|
-
if (/(?:ss|us|x|z|ch|sh)es$/.test(w))
|
|
33
|
-
return w.slice(0, -2);
|
|
34
|
-
if (/(?:ch|sh|us)e$/.test(w))
|
|
35
|
-
return w.slice(0, -1);
|
|
36
|
-
return w.endsWith("s") && !/(?:ss|us|is)$/.test(w) ? w.slice(0, -1) : w;
|
|
37
|
-
}
|
|
38
|
-
function terms(text, parts = true) {
|
|
39
|
-
const nfkc = text.normalize("NFKC");
|
|
40
|
-
const norm = nfkc.toLowerCase();
|
|
41
|
-
const out = [];
|
|
42
|
-
const keep = (w) => {
|
|
43
|
-
if (w.length > MAX_TERM || STOP.has(w) || HIRAGANA_ONLY.test(w))
|
|
44
|
-
return;
|
|
45
|
-
out.push(OKURIGANA.exec(w)?.[1] ?? singular(w));
|
|
46
|
-
};
|
|
47
|
-
for (const s of segmenter.segment(norm))
|
|
48
|
-
if (s.isWordLike)
|
|
49
|
-
keep(s.segment.trim());
|
|
50
|
-
for (const m of norm.matchAll(IDENT))
|
|
51
|
-
if (m[0].length >= 3)
|
|
52
|
-
keep(m[0]);
|
|
53
|
-
if (parts)
|
|
54
|
-
for (const [word] of nfkc.matchAll(WORD))
|
|
55
|
-
for (const w of word.split(JAPANESE)) {
|
|
56
|
-
if (w.length > MAX_TERM || !COMPOUND.test(w))
|
|
57
|
-
continue;
|
|
58
|
-
const cut = w.split(CUT).filter(Boolean);
|
|
59
|
-
if (cut.length <= MAX_PARTS && cut.every((p) => NAME_PART.test(p))) {
|
|
60
|
-
for (const p of cut)
|
|
61
|
-
if (p.length >= 2)
|
|
62
|
-
keep(p.toLowerCase());
|
|
63
|
-
}
|
|
64
|
-
}
|
|
65
|
-
return out.filter(Boolean);
|
|
66
|
-
}
|
|
67
|
-
var QUESTION = new Set([
|
|
68
|
-
...[
|
|
69
|
-
"why",
|
|
70
|
-
"what",
|
|
71
|
-
"which",
|
|
72
|
-
"when",
|
|
73
|
-
"where",
|
|
74
|
-
"who",
|
|
75
|
-
"how",
|
|
76
|
-
"do",
|
|
77
|
-
"does",
|
|
78
|
-
"did",
|
|
79
|
-
"we",
|
|
80
|
-
"our",
|
|
81
|
-
"us",
|
|
82
|
-
"you",
|
|
83
|
-
"i",
|
|
84
|
-
"are",
|
|
85
|
-
"was",
|
|
86
|
-
"were"
|
|
87
|
-
],
|
|
88
|
-
...[
|
|
89
|
-
"will",
|
|
90
|
-
"would",
|
|
91
|
-
"should",
|
|
92
|
-
"can",
|
|
93
|
-
"could",
|
|
94
|
-
"there",
|
|
95
|
-
"this",
|
|
96
|
-
"that",
|
|
97
|
-
"with",
|
|
98
|
-
"from",
|
|
99
|
-
"any",
|
|
100
|
-
"ever",
|
|
101
|
-
"long",
|
|
102
|
-
"use",
|
|
103
|
-
"used",
|
|
104
|
-
"using"
|
|
105
|
-
],
|
|
106
|
-
...["add", "get", "make", "have", "has", "not", "no", "yes", "reason"],
|
|
107
|
-
...["理由", "仕組", "何", "方", "場合", "今", "件"]
|
|
108
|
-
]);
|
|
109
|
-
var FOLDED_QUESTION = new Set([...QUESTION].flatMap((w) => terms(w)));
|
|
110
|
-
var sha256 = (s) => crypto.createHash("sha256").update(s).digest();
|
|
111
|
-
function uuidFrom(...parts) {
|
|
112
|
-
const b = crypto.createHash("sha256").update(parts.join("\x00")).digest().subarray(0, 16);
|
|
113
|
-
b[6] = (b[6] ?? 0) & 15 | 128;
|
|
114
|
-
b[8] = (b[8] ?? 0) & 63 | 128;
|
|
115
|
-
const h = b.toString("hex");
|
|
116
|
-
return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
|
|
117
|
-
}
|
|
118
|
-
var bytes = (s) => Buffer.byteLength(s, "utf8");
|
|
119
|
-
function head(s, n) {
|
|
120
|
-
if (bytes(s) <= n)
|
|
121
|
-
return s;
|
|
122
|
-
let out = "";
|
|
123
|
-
let used = 0;
|
|
124
|
-
for (const ch of s) {
|
|
125
|
-
const b = bytes(ch);
|
|
126
|
-
if (used + b > n)
|
|
127
|
-
break;
|
|
128
|
-
out += ch;
|
|
129
|
-
used += b;
|
|
130
|
-
}
|
|
131
|
-
return out;
|
|
132
|
-
}
|
|
133
|
-
function tail(s, n) {
|
|
134
|
-
if (bytes(s) <= n)
|
|
135
|
-
return s;
|
|
136
|
-
const chars = [...s];
|
|
137
|
-
let used = 0;
|
|
138
|
-
let i = chars.length;
|
|
139
|
-
while (i > 0) {
|
|
140
|
-
const b = bytes(chars[i - 1] ?? "");
|
|
141
|
-
if (used + b > n)
|
|
142
|
-
break;
|
|
143
|
-
used += b;
|
|
144
|
-
i--;
|
|
145
|
-
}
|
|
146
|
-
return chars.slice(i).join("");
|
|
147
|
-
}
|
|
148
|
-
var clean = (s) => s.replaceAll("\x00", "");
|
|
149
|
-
var visible = (s) => s.replace(/(?!\p{Join_Control}|\p{Variation_Selector})\p{Default_Ignorable_Code_Point}/gu, "");
|
|
150
|
-
var SECRETS = [
|
|
151
|
-
[/\bsk-(?:proj-|ant-)?[A-Za-z0-9_-]{20,}/g, "API key"],
|
|
152
|
-
[/\b[srp]k_(?:live|test)_[A-Za-z0-9]{16,}/g, "API key"],
|
|
153
|
-
[/\bwhsec_[A-Za-z0-9+/=]{16,}/g, "webhook signing secret"],
|
|
154
|
-
[/\bpa-[A-Za-z0-9_-]{20,}/g, "API key"],
|
|
155
|
-
[/\bAIza[0-9A-Za-z_-]{35}/g, "API key"],
|
|
156
|
-
[/\bnpg_[A-Za-z0-9]{12,}/g, "database password"],
|
|
157
|
-
[/\bnapi_[A-Za-z0-9]{30,}/g, "API key"],
|
|
158
|
-
[/\bnpm_[A-Za-z0-9]{36}\b/g, "npm token"],
|
|
159
|
-
[/\bglpat-[A-Za-z0-9_-]{20,}/g, "GitLab token"],
|
|
160
|
-
[
|
|
161
|
-
/(?<![A-Za-z0-9])ghs_eyJ[A-Za-z0-9_-]{5,200}\.[A-Za-z0-9_-]{8,2000}\.[A-Za-z0-9_-]{8,1000}/g,
|
|
162
|
-
"GitHub token"
|
|
163
|
-
],
|
|
164
|
-
[/(?<![A-Za-z0-9])gh[pousr]_[A-Za-z0-9]{30,}/g, "GitHub token"],
|
|
165
|
-
[/(?<![A-Za-z0-9])github_pat_[A-Za-z0-9_]{40,}/g, "GitHub token"],
|
|
166
|
-
[/\bxox[abprs]-[A-Za-z0-9-]{10,}/g, "Slack token"],
|
|
167
|
-
[/https:\/\/hooks\.slack\.com\/services\/[A-Za-z0-9/]+/g, "Slack webhook"],
|
|
168
|
-
[/\bAKIA[0-9A-Z]{16}\b/g, "AWS key"],
|
|
169
|
-
[/(?<![A-Za-z0-9_-])eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g, "JWT"],
|
|
170
|
-
[/\b(?:Bearer|BEARER)\s+(?=[A-Za-z0-9._~+/=-]{0,512}\d)[A-Za-z0-9._~+/=-]{16,}/g, "auth header value"]
|
|
171
|
-
];
|
|
172
|
-
var AUTH_HEADER = /(\bAuthorization["']?\s*[:=]\s*(?:["']\s*)?(?:Bearer|Basic|Token|Digest)\s+)[A-Za-z0-9._~+/=-]{8,}/gi;
|
|
173
|
-
var HEADER_BEARER = /(:[ \t]*(?:["'][ \t]*)?bearer[ \t]+)[A-Za-z0-9._~+/=-]{16,}/gi;
|
|
174
|
-
var ENV_ASSIGN = /\b((?:[A-Z][A-Z0-9_]*_)?(?:API|SECRET|MASTER|ENCRYPTION|PRIVATE|ACCESS|SIGNING|AUTH)?KEY|[A-Z][A-Z0-9_]*_(?:PASS|PWD)|(?:[A-Z][A-Z0-9_]*?)?(?:TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIALS?))(\s*=\s*)(?:"(?!\$)[^"\n]+"|'(?!\$)[^'\n]+'|(?![$"'])[^\s"']+)/g;
|
|
175
|
-
var FIELD_NAME = /(?:(?:api|account|access|private|secret)[-_]?key|secret|token|passw(?:or)?d)["']?\s*(?::=|=>|[:=])\s*/gi;
|
|
176
|
-
var MAX_QUOTED = 4096;
|
|
177
|
-
var BARE_HEAD = /[^\s"',;)]{1,256}/y;
|
|
178
|
-
var BARE_REST = /[^\s"',;)]*/y;
|
|
179
|
-
var NEXT_PARAM = /&[A-Za-z_][\w.-]*=/;
|
|
180
|
-
var bareAt = (re, text, at) => {
|
|
181
|
-
re.lastIndex = at;
|
|
182
|
-
const v = re.exec(text)?.[0] ?? "";
|
|
183
|
-
const cut = v.search(NEXT_PARAM);
|
|
184
|
-
return cut < 0 ? v : v.slice(0, cut);
|
|
185
|
-
};
|
|
186
|
-
function secretValue(quoted, v) {
|
|
187
|
-
if (v.length < 8 || /^\$(?:\{|[A-Za-z_])/.test(v))
|
|
188
|
-
return false;
|
|
189
|
-
if (!quoted)
|
|
190
|
-
return !/^[#$]/.test(v) && /\d/.test(v) && /[A-Za-z]/.test(v) && !/[()]/.test(v);
|
|
191
|
-
if (/^#[0-9a-f]{3,8}$/i.test(v) || !/[A-Za-z0-9]/.test(v))
|
|
192
|
-
return false;
|
|
193
|
-
return !/\s/.test(v) || v.split(/\s+/).some((w) => /\d/.test(w) && /[A-Za-z]/.test(w));
|
|
194
|
-
}
|
|
195
|
-
function maskFields(text) {
|
|
196
|
-
let out = "";
|
|
197
|
-
let last = 0;
|
|
198
|
-
FIELD_NAME.lastIndex = 0;
|
|
199
|
-
for (let m = FIELD_NAME.exec(text);m; m = FIELD_NAME.exec(text)) {
|
|
200
|
-
const at = m.index + m[0].length;
|
|
201
|
-
const q = text[at];
|
|
202
|
-
let quote = "";
|
|
203
|
-
let value;
|
|
204
|
-
if (q === '"' || q === "'") {
|
|
205
|
-
const close = text.indexOf(q, at + 1);
|
|
206
|
-
if (close < 0 || close - at - 1 > MAX_QUOTED)
|
|
207
|
-
continue;
|
|
208
|
-
value = text.slice(at + 1, close);
|
|
209
|
-
if (value.includes(`
|
|
210
|
-
`))
|
|
211
|
-
continue;
|
|
212
|
-
quote = q;
|
|
213
|
-
} else {
|
|
214
|
-
value = bareAt(BARE_HEAD, text, at);
|
|
215
|
-
}
|
|
216
|
-
if (!secretValue(quote !== "", value))
|
|
217
|
-
continue;
|
|
218
|
-
if (!quote && value.length === 256)
|
|
219
|
-
value += bareAt(BARE_REST, text, at + 256);
|
|
220
|
-
out += `${text.slice(last, at)}${quote}[redacted]`;
|
|
221
|
-
last = at + quote.length + value.length;
|
|
222
|
-
FIELD_NAME.lastIndex = last;
|
|
223
|
-
}
|
|
224
|
-
return out + text.slice(last);
|
|
225
|
-
}
|
|
226
|
-
var MYSQL_COMMAND = /\bmysql(?:dump|admin)?\b(?:'[^'\n]*'|"[^"\n]*"|[^\n;&|\\'"]|\\\r?\n|\\(?!\r?\n))*/g;
|
|
227
|
-
var MYSQL_PASSWORD = /(\s-p)(?:'[^'\n]*'|"[^"\n]*"|(?=[^\s-])\S+)/;
|
|
228
|
-
var URL_CREDENTIALS = /\b((?:postgres(?:ql)?|mysql|mongodb(?:\+srv)?|rediss?|amqps?|https?):\/\/[^:\s/@]*:)[^\s/]*@([^@\s/?#]+)/g;
|
|
229
|
-
var KEY_BEGIN = /-----BEGIN [A-Z ]*PRIVATE KEY-----/g;
|
|
230
|
-
var KEY_END = /-----END [A-Z ]*PRIVATE KEY-----/g;
|
|
231
|
-
function keyBlocks(text) {
|
|
232
|
-
const ends = [...text.matchAll(KEY_END)].map((m) => [m.index, m.index + m[0].length]);
|
|
233
|
-
const out = [];
|
|
234
|
-
let last = 0;
|
|
235
|
-
let e = 0;
|
|
236
|
-
if (ends.length > 0)
|
|
237
|
-
for (const m of text.matchAll(KEY_BEGIN)) {
|
|
238
|
-
const after = m.index + m[0].length;
|
|
239
|
-
if (m.index < last)
|
|
240
|
-
continue;
|
|
241
|
-
while (e < ends.length && (ends[e]?.[0] ?? 0) < after)
|
|
242
|
-
e++;
|
|
243
|
-
const end = ends[e];
|
|
244
|
-
if (!end)
|
|
245
|
-
break;
|
|
246
|
-
out.push([m.index, end[1]]);
|
|
247
|
-
last = end[1];
|
|
248
|
-
}
|
|
249
|
-
return out;
|
|
250
|
-
}
|
|
251
|
-
function maskPrivateKeys(text) {
|
|
252
|
-
let out = "";
|
|
253
|
-
let last = 0;
|
|
254
|
-
for (const [a, b] of keyBlocks(text)) {
|
|
255
|
-
out += `${text.slice(last, a)}[redacted: private key]`;
|
|
256
|
-
last = b;
|
|
257
|
-
}
|
|
258
|
-
return out + text.slice(last);
|
|
259
|
-
}
|
|
260
|
-
function mask(text) {
|
|
261
|
-
let out = maskFields(maskPrivateKeys(text).replace(URL_CREDENTIALS, "$1[redacted]@$2").replace(AUTH_HEADER, "$1[redacted]").replace(HEADER_BEARER, "$1[redacted]").replace(ENV_ASSIGN, "$1$2[redacted]")).replace(MYSQL_COMMAND, (command) => command.replace(MYSQL_PASSWORD, "$1[redacted]"));
|
|
262
|
-
for (const [re, what] of SECRETS)
|
|
263
|
-
out = out.replace(re, `[redacted: ${what}]`);
|
|
264
|
-
return out;
|
|
265
|
-
}
|
|
266
|
-
var reason = (e) => explain(e, 0) || "unknown failure";
|
|
267
|
-
var plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
|
|
268
|
-
function explain(e, depth) {
|
|
269
|
-
if (!(e instanceof Error)) {
|
|
270
|
-
try {
|
|
271
|
-
return String(e);
|
|
272
|
-
} catch {
|
|
273
|
-
return "";
|
|
274
|
-
}
|
|
275
|
-
}
|
|
276
|
-
const own = e.message || (e.name === "Error" || e.name === "AggregateError" ? "" : e.name);
|
|
277
|
-
const parts = depth >= 3 ? [] : [...e instanceof AggregateError ? e.errors : [], ...e.cause === undefined ? [] : [e.cause]];
|
|
278
|
-
const inner = parts.map((x) => explain(x, depth + 1)).filter(Boolean).join(" / ");
|
|
279
|
-
return own && inner ? `${own} (${inner})` : own || inner;
|
|
280
|
-
}
|
|
281
|
-
|
|
282
|
-
// server/src/anchors.ts
|
|
283
|
-
var MAX_BYTES = 2 * 1024 * 1024;
|
|
284
|
-
var leaves = (rel) => rel === ".." || rel.startsWith(`..${path.sep}`) || path.isAbsolute(rel);
|
|
4
|
+
import fs9 from "node:fs";
|
|
5
|
+
import os3 from "node:os";
|
|
6
|
+
import path10 from "node:path";
|
|
285
7
|
|
|
286
8
|
// server/node_modules/kysely/dist/util/object-utils.js
|
|
287
9
|
function isUndefined(obj) {
|
|
@@ -4408,8 +4130,8 @@ class Deferred {
|
|
|
4408
4130
|
this.#resolve?.(value);
|
|
4409
4131
|
this.#resolve = this.#reject = undefined;
|
|
4410
4132
|
};
|
|
4411
|
-
reject = (
|
|
4412
|
-
this.#reject?.(
|
|
4133
|
+
reject = (reason) => {
|
|
4134
|
+
this.#reject?.(reason);
|
|
4413
4135
|
this.#reject = this.#resolve = undefined;
|
|
4414
4136
|
};
|
|
4415
4137
|
}
|
|
@@ -4461,9 +4183,9 @@ function assertNotAborted(signal, timing, beforeThrow) {
|
|
|
4461
4183
|
throwReasonWithTiming(signal.reason, timing);
|
|
4462
4184
|
}
|
|
4463
4185
|
}
|
|
4464
|
-
function throwReasonWithTiming(
|
|
4465
|
-
decorateWithTiming(
|
|
4466
|
-
throw
|
|
4186
|
+
function throwReasonWithTiming(reason, timing) {
|
|
4187
|
+
decorateWithTiming(reason, timing);
|
|
4188
|
+
throw reason;
|
|
4467
4189
|
}
|
|
4468
4190
|
var ABORTED = {};
|
|
4469
4191
|
async function waitOrAbort(promise, signal, name, onAbort) {
|
|
@@ -4488,11 +4210,11 @@ async function waitOrAbort(promise, signal, name, onAbort) {
|
|
|
4488
4210
|
}
|
|
4489
4211
|
}
|
|
4490
4212
|
function printBackgroundFail(name) {
|
|
4491
|
-
return (
|
|
4213
|
+
return (reason) => console.error(`\`${name}\` failed in the background after abortion: ${getMessage(reason)}`);
|
|
4492
4214
|
}
|
|
4493
|
-
function decorateWithTiming(
|
|
4494
|
-
if (
|
|
4495
|
-
Object.defineProperty(
|
|
4215
|
+
function decorateWithTiming(reason, timing) {
|
|
4216
|
+
if (reason !== null && typeof reason === "object" && !Object.isFrozen(reason)) {
|
|
4217
|
+
Object.defineProperty(reason, "__kysely_timing__", {
|
|
4496
4218
|
configurable: true,
|
|
4497
4219
|
enumerable: false,
|
|
4498
4220
|
value: timing,
|
|
@@ -8417,9 +8139,9 @@ class RuntimeDriver {
|
|
|
8417
8139
|
}
|
|
8418
8140
|
this.#initPromise ??= this.#driver.init(options).then(() => {
|
|
8419
8141
|
this.#initDone = true;
|
|
8420
|
-
}).catch((
|
|
8142
|
+
}).catch((reason) => {
|
|
8421
8143
|
this.#initPromise = undefined;
|
|
8422
|
-
throw
|
|
8144
|
+
throw reason;
|
|
8423
8145
|
});
|
|
8424
8146
|
await waitOrAbort(this.#initPromise, options?.signal, "init");
|
|
8425
8147
|
}
|
|
@@ -8480,9 +8202,9 @@ class RuntimeDriver {
|
|
|
8480
8202
|
return;
|
|
8481
8203
|
}
|
|
8482
8204
|
await waitOrAbort(this.#initPromise, options?.signal, "destroy:initPromise");
|
|
8483
|
-
this.#destroyPromise ??= this.#driver.destroy(options).catch((
|
|
8205
|
+
this.#destroyPromise ??= this.#driver.destroy(options).catch((reason) => {
|
|
8484
8206
|
this.#destroyPromise = undefined;
|
|
8485
|
-
throw
|
|
8207
|
+
throw reason;
|
|
8486
8208
|
});
|
|
8487
8209
|
await waitOrAbort(this.#destroyPromise, options?.signal, "destroy");
|
|
8488
8210
|
}
|
|
@@ -11034,33 +10756,312 @@ function parseString(str, jsonPath, options) {
|
|
|
11034
10756
|
if (shouldParse !== maybeJson) {
|
|
11035
10757
|
throw error;
|
|
11036
10758
|
}
|
|
11037
|
-
console.error(error);
|
|
11038
|
-
return str;
|
|
10759
|
+
console.error(error);
|
|
10760
|
+
return str;
|
|
10761
|
+
}
|
|
10762
|
+
}
|
|
10763
|
+
function maybeJson(value) {
|
|
10764
|
+
return value.startsWith("{") && value.endsWith("}") || value.startsWith("[") && value.endsWith("]");
|
|
10765
|
+
}
|
|
10766
|
+
function parseObject(obj, jsonPath, options) {
|
|
10767
|
+
const { objectStrategy } = options;
|
|
10768
|
+
const target = objectStrategy === "create" ? {} : obj;
|
|
10769
|
+
for (const key of Object.keys(obj)) {
|
|
10770
|
+
if (key === "__proto__") {
|
|
10771
|
+
continue;
|
|
10772
|
+
}
|
|
10773
|
+
const parsed = parse(obj[key], `${jsonPath}."${key}"`, options);
|
|
10774
|
+
if (key === "constructor" && isPlainObject(parsed) && Object.hasOwn(parsed, "prototype")) {
|
|
10775
|
+
delete parsed.prototype;
|
|
10776
|
+
}
|
|
10777
|
+
target[key] = parsed;
|
|
10778
|
+
}
|
|
10779
|
+
return target;
|
|
10780
|
+
}
|
|
10781
|
+
|
|
10782
|
+
// server/src/anchors.ts
|
|
10783
|
+
import path from "node:path";
|
|
10784
|
+
|
|
10785
|
+
// server/src/text.ts
|
|
10786
|
+
import crypto from "node:crypto";
|
|
10787
|
+
var segmenter = new Intl.Segmenter("ja", { granularity: "word" });
|
|
10788
|
+
var HIRAGANA_ONLY = /^[\p{Script=Hiragana}ー]+$/u;
|
|
10789
|
+
var STOP = new Set(["the", "a", "an", "of", "to", "in", "is", "and", "or", "for", "on", "it", "be"]);
|
|
10790
|
+
var IDENT = /#\d+|[a-z0-9][a-z0-9_./#-]*[a-z0-9]/g;
|
|
10791
|
+
var WORD = /[\p{L}\p{M}\p{N}_]+/gu;
|
|
10792
|
+
var JAPANESE = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}ー々]+/u;
|
|
10793
|
+
var COMPOUND = /^[A-Za-z0-9_]*(?:[A-Za-z0-9]_|_[A-Za-z0-9]|[a-z0-9][A-Z])[A-Za-z0-9_]*$/;
|
|
10794
|
+
var CUT = /_+|(?<=[a-z0-9])(?=[A-Z])/;
|
|
10795
|
+
var MAX_PARTS = 6;
|
|
10796
|
+
var NAME_PART = /^(?:[A-Za-z]+[0-9]*|[0-9]+)$/;
|
|
10797
|
+
var MAX_TERM = 100;
|
|
10798
|
+
var OKURIGANA = /^(\p{Script=Han}+)[\p{Script=Hiragana}ー]+$/u;
|
|
10799
|
+
function singular(w) {
|
|
10800
|
+
if (!/^[a-z]{4,}$/.test(w))
|
|
10801
|
+
return w;
|
|
10802
|
+
if (w.endsWith("ies"))
|
|
10803
|
+
return `${w.slice(0, -3)}y`;
|
|
10804
|
+
if (w.endsWith("ie"))
|
|
10805
|
+
return `${w.slice(0, -2)}y`;
|
|
10806
|
+
if (/(?:ss|us|x|z|ch|sh)es$/.test(w))
|
|
10807
|
+
return w.slice(0, -2);
|
|
10808
|
+
if (/(?:ch|sh|us)e$/.test(w))
|
|
10809
|
+
return w.slice(0, -1);
|
|
10810
|
+
return w.endsWith("s") && !/(?:ss|us|is)$/.test(w) ? w.slice(0, -1) : w;
|
|
10811
|
+
}
|
|
10812
|
+
function terms(text, parts = true) {
|
|
10813
|
+
const nfkc = text.normalize("NFKC");
|
|
10814
|
+
const norm = nfkc.toLowerCase();
|
|
10815
|
+
const out = [];
|
|
10816
|
+
const keep = (w) => {
|
|
10817
|
+
if (w.length > MAX_TERM || STOP.has(w) || HIRAGANA_ONLY.test(w))
|
|
10818
|
+
return;
|
|
10819
|
+
out.push(OKURIGANA.exec(w)?.[1] ?? singular(w));
|
|
10820
|
+
};
|
|
10821
|
+
for (const s of segmenter.segment(norm))
|
|
10822
|
+
if (s.isWordLike)
|
|
10823
|
+
keep(s.segment.trim());
|
|
10824
|
+
for (const m of norm.matchAll(IDENT))
|
|
10825
|
+
if (m[0].length >= 3)
|
|
10826
|
+
keep(m[0]);
|
|
10827
|
+
if (parts)
|
|
10828
|
+
for (const [word] of nfkc.matchAll(WORD))
|
|
10829
|
+
for (const w of word.split(JAPANESE)) {
|
|
10830
|
+
if (w.length > MAX_TERM || !COMPOUND.test(w))
|
|
10831
|
+
continue;
|
|
10832
|
+
const cut = w.split(CUT).filter(Boolean);
|
|
10833
|
+
if (cut.length <= MAX_PARTS && cut.every((p) => NAME_PART.test(p))) {
|
|
10834
|
+
for (const p of cut)
|
|
10835
|
+
if (p.length >= 2)
|
|
10836
|
+
keep(p.toLowerCase());
|
|
10837
|
+
}
|
|
10838
|
+
}
|
|
10839
|
+
return out.filter(Boolean);
|
|
10840
|
+
}
|
|
10841
|
+
var QUESTION = new Set([
|
|
10842
|
+
...[
|
|
10843
|
+
"why",
|
|
10844
|
+
"what",
|
|
10845
|
+
"which",
|
|
10846
|
+
"when",
|
|
10847
|
+
"where",
|
|
10848
|
+
"who",
|
|
10849
|
+
"how",
|
|
10850
|
+
"do",
|
|
10851
|
+
"does",
|
|
10852
|
+
"did",
|
|
10853
|
+
"we",
|
|
10854
|
+
"our",
|
|
10855
|
+
"us",
|
|
10856
|
+
"you",
|
|
10857
|
+
"i",
|
|
10858
|
+
"are",
|
|
10859
|
+
"was",
|
|
10860
|
+
"were"
|
|
10861
|
+
],
|
|
10862
|
+
...[
|
|
10863
|
+
"will",
|
|
10864
|
+
"would",
|
|
10865
|
+
"should",
|
|
10866
|
+
"can",
|
|
10867
|
+
"could",
|
|
10868
|
+
"there",
|
|
10869
|
+
"this",
|
|
10870
|
+
"that",
|
|
10871
|
+
"with",
|
|
10872
|
+
"from",
|
|
10873
|
+
"any",
|
|
10874
|
+
"ever",
|
|
10875
|
+
"long",
|
|
10876
|
+
"use",
|
|
10877
|
+
"used",
|
|
10878
|
+
"using"
|
|
10879
|
+
],
|
|
10880
|
+
...["add", "get", "make", "have", "has", "not", "no", "yes", "reason"],
|
|
10881
|
+
...["理由", "仕組", "何", "方", "場合", "今", "件"]
|
|
10882
|
+
]);
|
|
10883
|
+
var FOLDED_QUESTION = new Set([...QUESTION].flatMap((w) => terms(w)));
|
|
10884
|
+
var sha256 = (s) => crypto.createHash("sha256").update(s).digest();
|
|
10885
|
+
function uuidFrom(...parts) {
|
|
10886
|
+
const b = crypto.createHash("sha256").update(parts.join("\x00")).digest().subarray(0, 16);
|
|
10887
|
+
b[6] = (b[6] ?? 0) & 15 | 128;
|
|
10888
|
+
b[8] = (b[8] ?? 0) & 63 | 128;
|
|
10889
|
+
const h = b.toString("hex");
|
|
10890
|
+
return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
|
|
10891
|
+
}
|
|
10892
|
+
var bytes = (s) => Buffer.byteLength(s, "utf8");
|
|
10893
|
+
function head(s, n) {
|
|
10894
|
+
if (bytes(s) <= n)
|
|
10895
|
+
return s;
|
|
10896
|
+
let out = "";
|
|
10897
|
+
let used = 0;
|
|
10898
|
+
for (const ch of s) {
|
|
10899
|
+
const b = bytes(ch);
|
|
10900
|
+
if (used + b > n)
|
|
10901
|
+
break;
|
|
10902
|
+
out += ch;
|
|
10903
|
+
used += b;
|
|
10904
|
+
}
|
|
10905
|
+
return out;
|
|
10906
|
+
}
|
|
10907
|
+
function tail(s, n) {
|
|
10908
|
+
if (bytes(s) <= n)
|
|
10909
|
+
return s;
|
|
10910
|
+
const chars = [...s];
|
|
10911
|
+
let used = 0;
|
|
10912
|
+
let i = chars.length;
|
|
10913
|
+
while (i > 0) {
|
|
10914
|
+
const b = bytes(chars[i - 1] ?? "");
|
|
10915
|
+
if (used + b > n)
|
|
10916
|
+
break;
|
|
10917
|
+
used += b;
|
|
10918
|
+
i--;
|
|
10919
|
+
}
|
|
10920
|
+
return chars.slice(i).join("");
|
|
10921
|
+
}
|
|
10922
|
+
var clean = (s) => s.replaceAll("\x00", "");
|
|
10923
|
+
var visible = (s) => s.replace(/(?!\p{Join_Control}|\p{Variation_Selector})\p{Default_Ignorable_Code_Point}/gu, "");
|
|
10924
|
+
var SECRETS = [
|
|
10925
|
+
[/\bsk-(?:proj-|ant-)?[A-Za-z0-9_-]{20,}/g, "API key"],
|
|
10926
|
+
[/\b[srp]k_(?:live|test)_[A-Za-z0-9]{16,}/g, "API key"],
|
|
10927
|
+
[/\bwhsec_[A-Za-z0-9+/=]{16,}/g, "webhook signing secret"],
|
|
10928
|
+
[/\bpa-[A-Za-z0-9_-]{20,}/g, "API key"],
|
|
10929
|
+
[/\bAIza[0-9A-Za-z_-]{35}/g, "API key"],
|
|
10930
|
+
[/\bnpg_[A-Za-z0-9]{12,}/g, "database password"],
|
|
10931
|
+
[/\bnapi_[A-Za-z0-9]{30,}/g, "API key"],
|
|
10932
|
+
[/\bnpm_[A-Za-z0-9]{36}\b/g, "npm token"],
|
|
10933
|
+
[/\bglpat-[A-Za-z0-9_-]{20,}/g, "GitLab token"],
|
|
10934
|
+
[
|
|
10935
|
+
/(?<![A-Za-z0-9])ghs_eyJ[A-Za-z0-9_-]{5,200}\.[A-Za-z0-9_-]{8,2000}\.[A-Za-z0-9_-]{8,1000}/g,
|
|
10936
|
+
"GitHub token"
|
|
10937
|
+
],
|
|
10938
|
+
[/(?<![A-Za-z0-9])gh[pousr]_[A-Za-z0-9]{30,}/g, "GitHub token"],
|
|
10939
|
+
[/(?<![A-Za-z0-9])github_pat_[A-Za-z0-9_]{40,}/g, "GitHub token"],
|
|
10940
|
+
[/\bxox[abprs]-[A-Za-z0-9-]{10,}/g, "Slack token"],
|
|
10941
|
+
[/https:\/\/hooks\.slack\.com\/services\/[A-Za-z0-9/]+/g, "Slack webhook"],
|
|
10942
|
+
[/\bAKIA[0-9A-Z]{16}\b/g, "AWS key"],
|
|
10943
|
+
[/(?<![A-Za-z0-9_-])eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g, "JWT"],
|
|
10944
|
+
[/\b(?:Bearer|BEARER)\s+(?=[A-Za-z0-9._~+/=-]{0,512}\d)[A-Za-z0-9._~+/=-]{16,}/g, "auth header value"]
|
|
10945
|
+
];
|
|
10946
|
+
var AUTH_HEADER = /(\bAuthorization["']?\s*[:=]\s*(?:["']\s*)?(?:Bearer|Basic|Token|Digest)\s+)[A-Za-z0-9._~+/=-]{8,}/gi;
|
|
10947
|
+
var HEADER_BEARER = /(:[ \t]*(?:["'][ \t]*)?bearer[ \t]+)[A-Za-z0-9._~+/=-]{16,}/gi;
|
|
10948
|
+
var ENV_ASSIGN = /\b((?:[A-Z][A-Z0-9_]*_)?(?:API|SECRET|MASTER|ENCRYPTION|PRIVATE|ACCESS|SIGNING|AUTH)?KEY|[A-Z][A-Z0-9_]*_(?:PASS|PWD)|(?:[A-Z][A-Z0-9_]*?)?(?:TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIALS?))(\s*=\s*)(?:"(?!\$)[^"\n]+"|'(?!\$)[^'\n]+'|(?![$"'])[^\s"']+)/g;
|
|
10949
|
+
var FIELD_NAME = /(?:(?:api|account|access|private|secret)[-_]?key|secret|token|passw(?:or)?d)["']?\s*(?::=|=>|[:=])\s*/gi;
|
|
10950
|
+
var MAX_QUOTED = 4096;
|
|
10951
|
+
var BARE_HEAD = /[^\s"',;)]{1,256}/y;
|
|
10952
|
+
var BARE_REST = /[^\s"',;)]*/y;
|
|
10953
|
+
var NEXT_PARAM = /&[A-Za-z_][\w.-]*=/;
|
|
10954
|
+
var bareAt = (re, text, at) => {
|
|
10955
|
+
re.lastIndex = at;
|
|
10956
|
+
const v = re.exec(text)?.[0] ?? "";
|
|
10957
|
+
const cut = v.search(NEXT_PARAM);
|
|
10958
|
+
return cut < 0 ? v : v.slice(0, cut);
|
|
10959
|
+
};
|
|
10960
|
+
function secretValue(quoted, v) {
|
|
10961
|
+
if (v.length < 8 || /^\$(?:\{|[A-Za-z_])/.test(v))
|
|
10962
|
+
return false;
|
|
10963
|
+
if (!quoted)
|
|
10964
|
+
return !/^[#$]/.test(v) && /\d/.test(v) && /[A-Za-z]/.test(v) && !/[()]/.test(v);
|
|
10965
|
+
if (/^#[0-9a-f]{3,8}$/i.test(v) || !/[A-Za-z0-9]/.test(v))
|
|
10966
|
+
return false;
|
|
10967
|
+
return !/\s/.test(v) || v.split(/\s+/).some((w) => /\d/.test(w) && /[A-Za-z]/.test(w));
|
|
10968
|
+
}
|
|
10969
|
+
function maskFields(text) {
|
|
10970
|
+
let out = "";
|
|
10971
|
+
let last = 0;
|
|
10972
|
+
FIELD_NAME.lastIndex = 0;
|
|
10973
|
+
for (let m = FIELD_NAME.exec(text);m; m = FIELD_NAME.exec(text)) {
|
|
10974
|
+
const at = m.index + m[0].length;
|
|
10975
|
+
const q = text[at];
|
|
10976
|
+
let quote = "";
|
|
10977
|
+
let value;
|
|
10978
|
+
if (q === '"' || q === "'") {
|
|
10979
|
+
const close = text.indexOf(q, at + 1);
|
|
10980
|
+
if (close < 0 || close - at - 1 > MAX_QUOTED)
|
|
10981
|
+
continue;
|
|
10982
|
+
value = text.slice(at + 1, close);
|
|
10983
|
+
if (value.includes(`
|
|
10984
|
+
`))
|
|
10985
|
+
continue;
|
|
10986
|
+
quote = q;
|
|
10987
|
+
} else {
|
|
10988
|
+
value = bareAt(BARE_HEAD, text, at);
|
|
10989
|
+
}
|
|
10990
|
+
if (!secretValue(quote !== "", value))
|
|
10991
|
+
continue;
|
|
10992
|
+
if (!quote && value.length === 256)
|
|
10993
|
+
value += bareAt(BARE_REST, text, at + 256);
|
|
10994
|
+
out += `${text.slice(last, at)}${quote}[redacted]`;
|
|
10995
|
+
last = at + quote.length + value.length;
|
|
10996
|
+
FIELD_NAME.lastIndex = last;
|
|
10997
|
+
}
|
|
10998
|
+
return out + text.slice(last);
|
|
10999
|
+
}
|
|
11000
|
+
var MYSQL_COMMAND = /\bmysql(?:dump|admin)?\b(?:'[^'\n]*'|"[^"\n]*"|[^\n;&|\\'"]|\\\r?\n|\\(?!\r?\n))*/g;
|
|
11001
|
+
var MYSQL_PASSWORD = /(\s-p)(?:'[^'\n]*'|"[^"\n]*"|(?=[^\s-])\S+)/;
|
|
11002
|
+
var URL_CREDENTIALS = /\b((?:postgres(?:ql)?|mysql|mongodb(?:\+srv)?|rediss?|amqps?|https?):\/\/[^:\s/@]*:)[^\s/]*@([^@\s/?#]+)/g;
|
|
11003
|
+
var KEY_BEGIN = /-----BEGIN [A-Z ]*PRIVATE KEY-----/g;
|
|
11004
|
+
var KEY_END = /-----END [A-Z ]*PRIVATE KEY-----/g;
|
|
11005
|
+
function keyBlocks(text) {
|
|
11006
|
+
const ends = [...text.matchAll(KEY_END)].map((m) => [m.index, m.index + m[0].length]);
|
|
11007
|
+
const out = [];
|
|
11008
|
+
let last = 0;
|
|
11009
|
+
let e = 0;
|
|
11010
|
+
if (ends.length > 0)
|
|
11011
|
+
for (const m of text.matchAll(KEY_BEGIN)) {
|
|
11012
|
+
const after = m.index + m[0].length;
|
|
11013
|
+
if (m.index < last)
|
|
11014
|
+
continue;
|
|
11015
|
+
while (e < ends.length && (ends[e]?.[0] ?? 0) < after)
|
|
11016
|
+
e++;
|
|
11017
|
+
const end = ends[e];
|
|
11018
|
+
if (!end)
|
|
11019
|
+
break;
|
|
11020
|
+
out.push([m.index, end[1]]);
|
|
11021
|
+
last = end[1];
|
|
11022
|
+
}
|
|
11023
|
+
return out;
|
|
11024
|
+
}
|
|
11025
|
+
function maskPrivateKeys(text) {
|
|
11026
|
+
let out = "";
|
|
11027
|
+
let last = 0;
|
|
11028
|
+
for (const [a, b] of keyBlocks(text)) {
|
|
11029
|
+
out += `${text.slice(last, a)}[redacted: private key]`;
|
|
11030
|
+
last = b;
|
|
11039
11031
|
}
|
|
11032
|
+
return out + text.slice(last);
|
|
11040
11033
|
}
|
|
11041
|
-
function
|
|
11042
|
-
|
|
11034
|
+
function mask(text) {
|
|
11035
|
+
let out = maskFields(maskPrivateKeys(text).replace(URL_CREDENTIALS, "$1[redacted]@$2").replace(AUTH_HEADER, "$1[redacted]").replace(HEADER_BEARER, "$1[redacted]").replace(ENV_ASSIGN, "$1$2[redacted]")).replace(MYSQL_COMMAND, (command) => command.replace(MYSQL_PASSWORD, "$1[redacted]"));
|
|
11036
|
+
for (const [re, what] of SECRETS)
|
|
11037
|
+
out = out.replace(re, `[redacted: ${what}]`);
|
|
11038
|
+
return out;
|
|
11043
11039
|
}
|
|
11044
|
-
|
|
11045
|
-
|
|
11046
|
-
|
|
11047
|
-
|
|
11048
|
-
|
|
11049
|
-
|
|
11050
|
-
}
|
|
11051
|
-
|
|
11052
|
-
if (key === "constructor" && isPlainObject(parsed) && Object.hasOwn(parsed, "prototype")) {
|
|
11053
|
-
delete parsed.prototype;
|
|
11040
|
+
var reason = (e) => explain(e, 0) || "unknown failure";
|
|
11041
|
+
var plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
|
|
11042
|
+
function explain(e, depth) {
|
|
11043
|
+
if (!(e instanceof Error)) {
|
|
11044
|
+
try {
|
|
11045
|
+
return String(e);
|
|
11046
|
+
} catch {
|
|
11047
|
+
return "";
|
|
11054
11048
|
}
|
|
11055
|
-
target[key] = parsed;
|
|
11056
11049
|
}
|
|
11057
|
-
|
|
11050
|
+
const own = e.message || (e.name === "Error" || e.name === "AggregateError" ? "" : e.name);
|
|
11051
|
+
const parts = depth >= 3 ? [] : [...e instanceof AggregateError ? e.errors : [], ...e.cause === undefined ? [] : [e.cause]];
|
|
11052
|
+
const inner = parts.map((x) => explain(x, depth + 1)).filter(Boolean).join(" / ");
|
|
11053
|
+
return own && inner ? `${own} (${inner})` : own || inner;
|
|
11058
11054
|
}
|
|
11059
11055
|
|
|
11056
|
+
// server/src/anchors.ts
|
|
11057
|
+
var MAX_BYTES = 2 * 1024 * 1024;
|
|
11058
|
+
var leaves = (rel) => rel === ".." || rel.startsWith(`..${path.sep}`) || path.isAbsolute(rel);
|
|
11059
|
+
|
|
11060
11060
|
// server/src/authority.ts
|
|
11061
11061
|
var AI_DECIDED = "A record marked decided by an AI was decided by an AI in an earlier session, not by the owner (unmarked delivered decisions are the owner's): with a concrete reason you may depart from it, saying in your reply which record and why. It never relaxes the owner's rules, public contracts, or approval gates.";
|
|
11062
|
-
var ownerAdopted = (unit) => sql`exists (select 1 from unit_adoption a where a.unit_id = ${sql.ref(unit)}
|
|
11063
|
-
and a.route in ('owner_statement', 'explicit') and a.retracted_at is null)
|
|
11062
|
+
var ownerAdopted = (unit, asOf) => asOf === undefined ? sql`exists (select 1 from unit_adoption a where a.unit_id = ${sql.ref(unit)}
|
|
11063
|
+
and a.route in ('owner_statement', 'explicit') and a.retracted_at is null)` : sql`exists (select 1 from unit_adoption a where a.unit_id = ${sql.ref(unit)}
|
|
11064
|
+
and a.route in ('owner_statement', 'explicit') and a.added_at <= ${asOf} and (a.retracted_at is null or a.retracted_at > ${asOf}))`;
|
|
11064
11065
|
async function authorityOf(db, ids, asOf) {
|
|
11065
11066
|
const out = new Map(ids.map((id) => [id, "none"]));
|
|
11066
11067
|
if (!ids.length)
|
|
@@ -11078,9 +11079,9 @@ async function authorityOf(db, ids, asOf) {
|
|
|
11078
11079
|
}
|
|
11079
11080
|
|
|
11080
11081
|
// server/src/capture.ts
|
|
11081
|
-
import { spawn } from "node:child_process";
|
|
11082
|
-
import
|
|
11083
|
-
import
|
|
11082
|
+
import { spawn as spawn2 } from "node:child_process";
|
|
11083
|
+
import fs6 from "node:fs";
|
|
11084
|
+
import path7 from "node:path";
|
|
11084
11085
|
|
|
11085
11086
|
// server/src/kysely-node-sqlite.ts
|
|
11086
11087
|
var plain = (row) => {
|
|
@@ -11111,14 +11112,14 @@ function adapt(raw) {
|
|
|
11111
11112
|
}
|
|
11112
11113
|
|
|
11113
11114
|
// server/src/sqlite.ts
|
|
11114
|
-
import
|
|
11115
|
-
import
|
|
11116
|
-
import
|
|
11115
|
+
import fs3 from "node:fs";
|
|
11116
|
+
import os2 from "node:os";
|
|
11117
|
+
import path4 from "node:path";
|
|
11117
11118
|
import { constants as C, DatabaseSync } from "node:sqlite";
|
|
11118
11119
|
|
|
11119
11120
|
// server/src/plugin.ts
|
|
11120
|
-
import
|
|
11121
|
-
import
|
|
11121
|
+
import fs2 from "node:fs";
|
|
11122
|
+
import path3 from "node:path";
|
|
11122
11123
|
import { fileURLToPath } from "node:url";
|
|
11123
11124
|
|
|
11124
11125
|
// server/node_modules/smol-toml/dist/error.js
|
|
@@ -11388,13 +11389,173 @@ var NO_MATCHER = new Set(["UserPromptSubmit", "Stop", "Interrupt"]);
|
|
|
11388
11389
|
var CONTEXT = new Set(["PreToolUse", "PostToolUse", "SessionStart", "UserPromptSubmit", "SubagentStart"]);
|
|
11389
11390
|
var SHORT = new Set(["SessionEnd", "Interrupt"]);
|
|
11390
11391
|
|
|
11392
|
+
// server/src/git.ts
|
|
11393
|
+
import { execFileSync, spawn } from "node:child_process";
|
|
11394
|
+
import fs from "node:fs";
|
|
11395
|
+
import os from "node:os";
|
|
11396
|
+
import path2 from "node:path";
|
|
11397
|
+
var gitHome = () => path2.join(os.homedir(), ".sphica", "git");
|
|
11398
|
+
function gitEnv(extra = {}) {
|
|
11399
|
+
const env = Object.fromEntries(Object.entries(process.env).filter(([k]) => !/^GIT_/i.test(k)));
|
|
11400
|
+
return {
|
|
11401
|
+
...env,
|
|
11402
|
+
GIT_ALLOW_PROTOCOL: "",
|
|
11403
|
+
GIT_NO_LAZY_FETCH: "1",
|
|
11404
|
+
GIT_TERMINAL_PROMPT: "0",
|
|
11405
|
+
GIT_NO_REPLACE_OBJECTS: "1",
|
|
11406
|
+
...extra
|
|
11407
|
+
};
|
|
11408
|
+
}
|
|
11409
|
+
var gitOptions = (hooks = path2.join(gitHome(), "hooks")) => [
|
|
11410
|
+
"-c",
|
|
11411
|
+
"core.fsmonitor=",
|
|
11412
|
+
"-c",
|
|
11413
|
+
`core.hooksPath=${hooks}`,
|
|
11414
|
+
"-c",
|
|
11415
|
+
"core.quotePath=false",
|
|
11416
|
+
"--no-pager",
|
|
11417
|
+
"--no-optional-locks"
|
|
11418
|
+
];
|
|
11419
|
+
var DIFF_OPTIONS = [
|
|
11420
|
+
"--no-color",
|
|
11421
|
+
"--no-ext-diff",
|
|
11422
|
+
"--no-textconv",
|
|
11423
|
+
"--ignore-submodules=dirty",
|
|
11424
|
+
"--submodule=short"
|
|
11425
|
+
];
|
|
11426
|
+
function startDir() {
|
|
11427
|
+
const home = os.homedir();
|
|
11428
|
+
return fs.statSync(home, { throwIfNoEntry: false })?.isDirectory() ? home : path2.dirname(process.execPath);
|
|
11429
|
+
}
|
|
11430
|
+
function run(root, args, { max = 1024 * 1024, timeout = 1e4 } = {}) {
|
|
11431
|
+
return execFileSync("git", ["-C", root, ...gitOptions(), ...args], {
|
|
11432
|
+
cwd: startDir(),
|
|
11433
|
+
env: gitEnv(),
|
|
11434
|
+
maxBuffer: max,
|
|
11435
|
+
stdio: ["ignore", "pipe", "ignore"],
|
|
11436
|
+
timeout,
|
|
11437
|
+
killSignal: "SIGKILL"
|
|
11438
|
+
});
|
|
11439
|
+
}
|
|
11440
|
+
var text = (root, args, limits) => run(root, args, limits).toString("utf8");
|
|
11441
|
+
var list = (out) => out.split("\x00").filter(Boolean);
|
|
11442
|
+
function revision(rev) {
|
|
11443
|
+
if (!rev || rev.startsWith("-") || /[\0\n]/.test(rev))
|
|
11444
|
+
throw new Error(`not a revision: ${JSON.stringify(rev)}`);
|
|
11445
|
+
return rev;
|
|
11446
|
+
}
|
|
11447
|
+
function objectId(oid) {
|
|
11448
|
+
if (!/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(oid))
|
|
11449
|
+
throw new Error(`not an object id: ${JSON.stringify(oid)}`);
|
|
11450
|
+
return oid;
|
|
11451
|
+
}
|
|
11452
|
+
var topLevel = (dir, limits) => text(dir, ["rev-parse", "--show-toplevel"], limits).trim();
|
|
11453
|
+
var commitOf = (root, rev, limits) => text(root, ["rev-parse", "--verify", "-q", `${revision(rev)}^{commit}`], limits).trim();
|
|
11454
|
+
var baseRef = (root, which, limits) => text(root, which === "origin/HEAD" ? ["rev-parse", "--abbrev-ref", "origin/HEAD"] : ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"], limits).trim();
|
|
11455
|
+
var mergeBase = (root, a, b, limits) => text(root, ["merge-base", revision(a), revision(b)], limits).trim();
|
|
11456
|
+
function isAncestor(root, a, b, limits) {
|
|
11457
|
+
try {
|
|
11458
|
+
run(root, ["merge-base", "--is-ancestor", objectId(a), objectId(b)], limits);
|
|
11459
|
+
return true;
|
|
11460
|
+
} catch {
|
|
11461
|
+
return false;
|
|
11462
|
+
}
|
|
11463
|
+
}
|
|
11464
|
+
var commitDiffNames = (root, a, b, limits) => list(text(root, ["diff", ...DIFF_OPTIONS, "--name-only", "-z", objectId(a), objectId(b), "--"], limits));
|
|
11465
|
+
function listFiles(root, kind, { pathspecs = [], ...limits } = {}) {
|
|
11466
|
+
const which = {
|
|
11467
|
+
tracked: ["--cached"],
|
|
11468
|
+
untracked: ["--others", "--exclude-standard"],
|
|
11469
|
+
"tracked-and-untracked": ["--cached", "--others", "--exclude-standard"],
|
|
11470
|
+
deleted: ["--deleted"]
|
|
11471
|
+
}[kind];
|
|
11472
|
+
return list(text(root, ["ls-files", "-z", ...which, "--", ...pathspecs], limits));
|
|
11473
|
+
}
|
|
11474
|
+
var originUrl = (root, limits) => text(root, ["remote", "get-url", "origin"], limits).trim();
|
|
11475
|
+
async function worktreeStatus(root, deadline) {
|
|
11476
|
+
const out = await inIsolation(root, [{ kind: "status" }], { deadline, max: 16 * 1024 * 1024 });
|
|
11477
|
+
return out?.[0] ?? null;
|
|
11478
|
+
}
|
|
11479
|
+
async function worktreeDiff(root, from, { max, deadline }) {
|
|
11480
|
+
const out = await inIsolation(root, [{ kind: "diff", from: objectId(from) }], { deadline, max });
|
|
11481
|
+
return out && out.length === 2 ? { patch: out[0] ?? "", names: list(out[1] ?? "") } : null;
|
|
11482
|
+
}
|
|
11483
|
+
function workerFile() {
|
|
11484
|
+
const js = path2.join(import.meta.dirname, "git-worker.js");
|
|
11485
|
+
return fs.existsSync(js) ? js : path2.join(import.meta.dirname, "git-worker.ts");
|
|
11486
|
+
}
|
|
11487
|
+
function inIsolation(root, ops, { deadline, max }) {
|
|
11488
|
+
return new Promise((resolve) => {
|
|
11489
|
+
let child;
|
|
11490
|
+
try {
|
|
11491
|
+
child = spawn(process.execPath, [workerFile()], {
|
|
11492
|
+
cwd: startDir(),
|
|
11493
|
+
stdio: ["pipe", "pipe", "ignore"],
|
|
11494
|
+
windowsHide: true,
|
|
11495
|
+
detached: process.platform !== "win32"
|
|
11496
|
+
});
|
|
11497
|
+
} catch {
|
|
11498
|
+
resolve(null);
|
|
11499
|
+
return;
|
|
11500
|
+
}
|
|
11501
|
+
const chunks = [];
|
|
11502
|
+
let size = 0;
|
|
11503
|
+
let done = false;
|
|
11504
|
+
const finish = (out) => {
|
|
11505
|
+
if (done)
|
|
11506
|
+
return;
|
|
11507
|
+
done = true;
|
|
11508
|
+
clearTimeout(timer);
|
|
11509
|
+
if (out === null) {
|
|
11510
|
+
try {
|
|
11511
|
+
if (process.platform !== "win32" && child.pid)
|
|
11512
|
+
process.kill(-child.pid, "SIGKILL");
|
|
11513
|
+
else
|
|
11514
|
+
child.kill("SIGKILL");
|
|
11515
|
+
} catch {
|
|
11516
|
+
child.kill("SIGKILL");
|
|
11517
|
+
}
|
|
11518
|
+
child.stdin?.destroy();
|
|
11519
|
+
child.stdout?.destroy();
|
|
11520
|
+
child.unref();
|
|
11521
|
+
}
|
|
11522
|
+
resolve(out);
|
|
11523
|
+
};
|
|
11524
|
+
const timer = setTimeout(() => finish(null), deadline);
|
|
11525
|
+
const cap = 6 * max * Math.max(1, ops.length * 2) + 64 * 1024;
|
|
11526
|
+
child.stdout?.on("data", (c) => {
|
|
11527
|
+
size += c.length;
|
|
11528
|
+
if (size > cap)
|
|
11529
|
+
finish(null);
|
|
11530
|
+
else
|
|
11531
|
+
chunks.push(c);
|
|
11532
|
+
});
|
|
11533
|
+
child.on("error", () => finish(null));
|
|
11534
|
+
child.on("close", () => {
|
|
11535
|
+
try {
|
|
11536
|
+
const result = JSON.parse(Buffer.concat(chunks).toString("utf8"));
|
|
11537
|
+
finish(result.ok ? result.out : null);
|
|
11538
|
+
} catch {
|
|
11539
|
+
finish(null);
|
|
11540
|
+
}
|
|
11541
|
+
});
|
|
11542
|
+
child.stdin?.on("error", () => finish(null));
|
|
11543
|
+
child.stdin?.end(JSON.stringify({
|
|
11544
|
+
root,
|
|
11545
|
+
ops,
|
|
11546
|
+
max,
|
|
11547
|
+
until: Date.now() + Math.floor(deadline * 0.8)
|
|
11548
|
+
}));
|
|
11549
|
+
});
|
|
11550
|
+
}
|
|
11551
|
+
|
|
11391
11552
|
// server/src/panel.ts
|
|
11392
11553
|
import { stripVTControlCharacters, styleText } from "node:util";
|
|
11393
|
-
var title = (
|
|
11394
|
-
var rule = (
|
|
11554
|
+
var title = (text2) => `✦ ${text2}`;
|
|
11555
|
+
var rule = (text2) => text2.split(`
|
|
11395
11556
|
`).map((line) => line ? `│ ${line}` : "│").join(`
|
|
11396
11557
|
`);
|
|
11397
|
-
var foot = (
|
|
11558
|
+
var foot = (text2) => `╰─ ${text2}`;
|
|
11398
11559
|
var panel = (head2, lines, end) => [title(head2), ...lines.map(rule), foot(end)].join(`
|
|
11399
11560
|
`);
|
|
11400
11561
|
var STRING_SEQUENCE = /\u001b[\]P_^X][^\u0007\u001b]*(?:\u0007|\u001b\\)?/g;
|
|
@@ -11403,11 +11564,11 @@ var plain2 = (s) => visible(stripVTControlCharacters(s.replace(STRING_SEQUENCE,
|
|
|
11403
11564
|
var inline = (s) => plain2(s).replace(/[\n\t]+/g, " ");
|
|
11404
11565
|
|
|
11405
11566
|
// server/src/plugin.ts
|
|
11406
|
-
var MANIFEST =
|
|
11567
|
+
var MANIFEST = path3.join(".claude-plugin", "plugin.json");
|
|
11407
11568
|
var PACKAGE = "package.json";
|
|
11408
11569
|
function versionAt(root) {
|
|
11409
11570
|
try {
|
|
11410
|
-
const m = JSON.parse(
|
|
11571
|
+
const m = JSON.parse(fs2.readFileSync(path3.join(root, MANIFEST), "utf8"));
|
|
11411
11572
|
return m.name === "sphica" && typeof m.version === "string" ? m.version : null;
|
|
11412
11573
|
} catch {
|
|
11413
11574
|
return null;
|
|
@@ -11415,28 +11576,28 @@ function versionAt(root) {
|
|
|
11415
11576
|
}
|
|
11416
11577
|
function packageVersionAt(root) {
|
|
11417
11578
|
try {
|
|
11418
|
-
const m = JSON.parse(
|
|
11579
|
+
const m = JSON.parse(fs2.readFileSync(path3.join(root, PACKAGE), "utf8"));
|
|
11419
11580
|
return m.name === "sphica" && typeof m.version === "string" ? m.version : null;
|
|
11420
11581
|
} catch {
|
|
11421
11582
|
return null;
|
|
11422
11583
|
}
|
|
11423
11584
|
}
|
|
11424
|
-
var here =
|
|
11425
|
-
var ROOT = [
|
|
11585
|
+
var here = path3.dirname(fileURLToPath(import.meta.url));
|
|
11586
|
+
var ROOT = [path3.join(here, ".."), path3.join(here, "..", "..", "plugin")].find((r) => versionAt(r) !== null) ?? path3.join(here, "..");
|
|
11426
11587
|
var HOST_MARKS = new Set([".orphaned_at", ".in_use"]);
|
|
11427
11588
|
|
|
11428
11589
|
// server/src/sqlite.ts
|
|
11429
11590
|
var SCHEMA_GENERATION = 2;
|
|
11430
11591
|
var SCHEMA_REVISION = 12;
|
|
11431
|
-
var sphicaHome = () => process.env.SPHICA_HOME ||
|
|
11432
|
-
var dbFile = () => process.env.SPHICA_DB ||
|
|
11592
|
+
var sphicaHome = () => process.env.SPHICA_HOME || path4.join(os2.homedir(), ".sphica");
|
|
11593
|
+
var dbFile = () => process.env.SPHICA_DB || path4.join(sphicaHome(), "sphica.db");
|
|
11433
11594
|
function requireRuntime() {
|
|
11434
11595
|
const proto = DatabaseSync.prototype;
|
|
11435
11596
|
if (typeof proto.setAuthorizer !== "function" || typeof proto.enableDefensive !== "function")
|
|
11436
11597
|
throw new Error(`Sphica needs Node 24.15 or later (this is ${process.version}). Upgrade Node.`);
|
|
11437
11598
|
}
|
|
11438
11599
|
function requireFile(file) {
|
|
11439
|
-
if (!
|
|
11600
|
+
if (!fs3.existsSync(file))
|
|
11440
11601
|
throw new Error(`No database at ${file}. Create it with \`sphica init\`.`);
|
|
11441
11602
|
}
|
|
11442
11603
|
function prepare(raw, check, busyMs = 5000) {
|
|
@@ -11555,9 +11716,9 @@ function sqliteCode(e) {
|
|
|
11555
11716
|
function byUnit(rows) {
|
|
11556
11717
|
const out = new Map;
|
|
11557
11718
|
for (const r of rows) {
|
|
11558
|
-
const
|
|
11559
|
-
if (
|
|
11560
|
-
|
|
11719
|
+
const list2 = out.get(r.unit_id);
|
|
11720
|
+
if (list2)
|
|
11721
|
+
list2.push(r);
|
|
11561
11722
|
else
|
|
11562
11723
|
out.set(r.unit_id, [r]);
|
|
11563
11724
|
}
|
|
@@ -11795,7 +11956,7 @@ function connectWriter(role, file = dbFile(), create = false, busyMs) {
|
|
|
11795
11956
|
const raw = new DatabaseSync2(file);
|
|
11796
11957
|
try {
|
|
11797
11958
|
prepare(raw, create ? "none" : role === "ingest" || role === "forget" ? "revision" : "generation", busyMs);
|
|
11798
|
-
raw.function("sphica_terms", { deterministic: true }, (
|
|
11959
|
+
raw.function("sphica_terms", { deterministic: true }, (text2) => terms(String(text2 ?? "")).join(" "));
|
|
11799
11960
|
} catch (e) {
|
|
11800
11961
|
raw.close();
|
|
11801
11962
|
throw e;
|
|
@@ -11830,10 +11991,9 @@ function openWriter(role, file = dbFile(), busyMs) {
|
|
|
11830
11991
|
var sessionId = (projectId, host, externalId) => uuidFrom(String(projectId), host, externalId);
|
|
11831
11992
|
|
|
11832
11993
|
// server/src/project.ts
|
|
11833
|
-
import
|
|
11834
|
-
import
|
|
11835
|
-
|
|
11836
|
-
var localFile = () => path4.join(sphicaHome(), "projects.json");
|
|
11994
|
+
import fs4 from "node:fs";
|
|
11995
|
+
import path5 from "node:path";
|
|
11996
|
+
var localFile = () => path5.join(sphicaHome(), "projects.json");
|
|
11837
11997
|
var LOCAL_KEY = /^[a-z0-9][a-z0-9._-]*$/;
|
|
11838
11998
|
function legacyRemote(url) {
|
|
11839
11999
|
const raw = String(url ?? "").trim();
|
|
@@ -11861,21 +12021,18 @@ function normalizeKey(key) {
|
|
|
11861
12021
|
const host = fold(cut < 0 ? rest : rest.slice(0, cut));
|
|
11862
12022
|
return host === "github.com" ? fold(key) : `git:${host}${cut < 0 ? "" : rest.slice(cut)}`;
|
|
11863
12023
|
}
|
|
11864
|
-
var
|
|
12024
|
+
var ask = (fn) => {
|
|
11865
12025
|
try {
|
|
11866
|
-
return
|
|
11867
|
-
encoding: "utf8",
|
|
11868
|
-
stdio: ["ignore", "pipe", "ignore"],
|
|
11869
|
-
timeout: 5000
|
|
11870
|
-
}).trim();
|
|
12026
|
+
return fn() || null;
|
|
11871
12027
|
} catch {
|
|
11872
12028
|
return null;
|
|
11873
12029
|
}
|
|
11874
12030
|
};
|
|
12031
|
+
var top = (dir) => ask(() => topLevel(dir, { timeout: 5000 }));
|
|
11875
12032
|
function localMap() {
|
|
11876
12033
|
let raw;
|
|
11877
12034
|
try {
|
|
11878
|
-
raw =
|
|
12035
|
+
raw = fs4.readFileSync(localFile(), "utf8");
|
|
11879
12036
|
} catch (e) {
|
|
11880
12037
|
if (e.code === "ENOENT")
|
|
11881
12038
|
return {};
|
|
@@ -11887,26 +12044,26 @@ function localMap() {
|
|
|
11887
12044
|
} catch {
|
|
11888
12045
|
m = null;
|
|
11889
12046
|
}
|
|
11890
|
-
if (!m || typeof m !== "object" || Array.isArray(m) || Object.entries(m).some(([root, name]) => !
|
|
12047
|
+
if (!m || typeof m !== "object" || Array.isArray(m) || Object.entries(m).some(([root, name]) => !path5.isAbsolute(root) || typeof name !== "string" || !LOCAL_KEY.test(name)))
|
|
11891
12048
|
throw new Error(`${localFile()} is not a valid JSON project table. Fix or delete it, then name the project again.`);
|
|
11892
12049
|
return m;
|
|
11893
12050
|
}
|
|
11894
12051
|
function identify(dir) {
|
|
11895
|
-
const given =
|
|
11896
|
-
const
|
|
11897
|
-
const root =
|
|
11898
|
-
const legacy =
|
|
12052
|
+
const given = path5.resolve(dir);
|
|
12053
|
+
const found = top(given);
|
|
12054
|
+
const root = found || given;
|
|
12055
|
+
const legacy = found ? legacyRemote(ask(() => originUrl(root, { timeout: 5000 }))) : null;
|
|
11899
12056
|
if (legacy) {
|
|
11900
12057
|
const key = normalizeKey(`git:${legacy}`);
|
|
11901
12058
|
const remote = key.slice(4);
|
|
11902
12059
|
return { key, legacyKey: `git:${legacy}`, root, name: remote.split("/").slice(1).join("/") || remote };
|
|
11903
12060
|
}
|
|
11904
12061
|
const map = localMap();
|
|
11905
|
-
for (let d = root;; d =
|
|
12062
|
+
for (let d = root;; d = path5.dirname(d)) {
|
|
11906
12063
|
const local = map[d];
|
|
11907
12064
|
if (local && LOCAL_KEY.test(local))
|
|
11908
12065
|
return { key: `local:${local}`, legacyKey: `local:${local}`, root: d, name: local };
|
|
11909
|
-
if (
|
|
12066
|
+
if (found || path5.dirname(d) === d)
|
|
11910
12067
|
return null;
|
|
11911
12068
|
}
|
|
11912
12069
|
}
|
|
@@ -11915,11 +12072,11 @@ async function projectId(db, key) {
|
|
|
11915
12072
|
return r?.id ?? null;
|
|
11916
12073
|
}
|
|
11917
12074
|
function relativeTo(root, file, cwd = root) {
|
|
11918
|
-
const abs =
|
|
11919
|
-
const rel =
|
|
12075
|
+
const abs = path5.resolve(cwd, file);
|
|
12076
|
+
const rel = path5.relative(root, abs);
|
|
11920
12077
|
if (!rel || leaves(rel) || /\p{Cc}/u.test(rel))
|
|
11921
12078
|
return null;
|
|
11922
|
-
return rel.split(
|
|
12079
|
+
return rel.split(path5.sep).join("/");
|
|
11923
12080
|
}
|
|
11924
12081
|
function patchPaths(patch) {
|
|
11925
12082
|
const out = [];
|
|
@@ -11933,25 +12090,15 @@ function patchPaths(patch) {
|
|
|
11933
12090
|
}
|
|
11934
12091
|
|
|
11935
12092
|
// server/src/worktree.ts
|
|
11936
|
-
import
|
|
11937
|
-
import
|
|
11938
|
-
import path5 from "node:path";
|
|
12093
|
+
import fs5 from "node:fs";
|
|
12094
|
+
import path6 from "node:path";
|
|
11939
12095
|
var MAX_PATHS = 200;
|
|
11940
|
-
var
|
|
11941
|
-
|
|
11942
|
-
return execFileSync2("git", ["-C", root, ...args], {
|
|
11943
|
-
encoding: "utf8",
|
|
11944
|
-
stdio: ["ignore", "pipe", "ignore"],
|
|
11945
|
-
timeout: 5000,
|
|
11946
|
-
maxBuffer: 16 * 1024 * 1024
|
|
11947
|
-
});
|
|
11948
|
-
} catch {
|
|
11949
|
-
return null;
|
|
11950
|
-
}
|
|
11951
|
-
};
|
|
12096
|
+
var LIMITS = { timeout: 5000, max: 16 * 1024 * 1024 };
|
|
12097
|
+
var STATUS_DEADLINE = 5000;
|
|
11952
12098
|
var usable = (p) => p !== "" && !p.includes("\\") && !/\p{Cc}/u.test(p);
|
|
11953
|
-
function snapshot(root) {
|
|
11954
|
-
const
|
|
12099
|
+
async function snapshot(root) {
|
|
12100
|
+
const until = Date.now() + STATUS_DEADLINE;
|
|
12101
|
+
const out = await worktreeStatus(root, STATUS_DEADLINE);
|
|
11955
12102
|
if (out === null)
|
|
11956
12103
|
return null;
|
|
11957
12104
|
const fields = out.split("\x00");
|
|
@@ -11969,13 +12116,18 @@ function snapshot(root) {
|
|
|
11969
12116
|
continue;
|
|
11970
12117
|
let st;
|
|
11971
12118
|
try {
|
|
11972
|
-
st =
|
|
12119
|
+
st = fs5.lstatSync(path6.join(root, p), { throwIfNoEntry: false });
|
|
11973
12120
|
} catch {
|
|
11974
12121
|
st = undefined;
|
|
11975
12122
|
}
|
|
11976
12123
|
entries[p] = `${parts.slice(0, skip).join(" ")} ${st ? `${st.size}:${st.mtimeMs}` : "gone"}`;
|
|
11977
12124
|
}
|
|
11978
|
-
|
|
12125
|
+
let head2 = null;
|
|
12126
|
+
try {
|
|
12127
|
+
const left = until - Date.now();
|
|
12128
|
+
if (left > 0)
|
|
12129
|
+
head2 = commitOf(root, "HEAD", { ...LIMITS, timeout: left }) || null;
|
|
12130
|
+
} catch {}
|
|
11979
12131
|
return { head: head2, entries };
|
|
11980
12132
|
}
|
|
11981
12133
|
function changed(root, before, after) {
|
|
@@ -11983,8 +12135,12 @@ function changed(root, before, after) {
|
|
|
11983
12135
|
for (const p of new Set([...Object.keys(before.entries), ...Object.keys(after.entries)]))
|
|
11984
12136
|
if (before.entries[p] !== after.entries[p])
|
|
11985
12137
|
paths.add(p);
|
|
11986
|
-
if (before.head && after.head && before.head !== after.head &&
|
|
11987
|
-
|
|
12138
|
+
if (before.head && after.head && before.head !== after.head && isAncestor(root, before.head, after.head, LIMITS)) {
|
|
12139
|
+
let between = [];
|
|
12140
|
+
try {
|
|
12141
|
+
between = commitDiffNames(root, before.head, after.head, LIMITS);
|
|
12142
|
+
} catch {}
|
|
12143
|
+
for (const p of between)
|
|
11988
12144
|
if (usable(p))
|
|
11989
12145
|
paths.add(p);
|
|
11990
12146
|
}
|
|
@@ -11992,15 +12148,15 @@ function changed(root, before, after) {
|
|
|
11992
12148
|
}
|
|
11993
12149
|
|
|
11994
12150
|
// server/src/capture.ts
|
|
11995
|
-
var spoolDir = () =>
|
|
11996
|
-
var stateFile = () =>
|
|
11997
|
-
var rejectedDir = () =>
|
|
11998
|
-
var unregisteredDir = () =>
|
|
11999
|
-
var callsDir = () =>
|
|
12000
|
-
var callsRejectedDir = () =>
|
|
12151
|
+
var spoolDir = () => path7.join(sphicaHome(), "spool");
|
|
12152
|
+
var stateFile = () => path7.join(sphicaHome(), "capture.json");
|
|
12153
|
+
var rejectedDir = () => path7.join(spoolDir(), "rejected");
|
|
12154
|
+
var unregisteredDir = () => path7.join(spoolDir(), "unregistered");
|
|
12155
|
+
var callsDir = () => path7.join(spoolDir(), "calls");
|
|
12156
|
+
var callsRejectedDir = () => path7.join(callsDir(), "rejected");
|
|
12001
12157
|
var HOLD_DAYS = 30;
|
|
12002
12158
|
var HOLD_MAX = 1000;
|
|
12003
|
-
var baselineDir = () =>
|
|
12159
|
+
var baselineDir = () => path7.join(sphicaHome(), "worktree");
|
|
12004
12160
|
function current(raw) {
|
|
12005
12161
|
const r = raw;
|
|
12006
12162
|
if (typeof r.project !== "string")
|
|
@@ -12049,7 +12205,7 @@ ${z}`,
|
|
|
12049
12205
|
function prune(held, removed = () => {}) {
|
|
12050
12206
|
let files;
|
|
12051
12207
|
try {
|
|
12052
|
-
files =
|
|
12208
|
+
files = fs6.readdirSync(held).filter((f) => f.endsWith(".json") && !f.startsWith(".")).sort();
|
|
12053
12209
|
} catch {
|
|
12054
12210
|
return;
|
|
12055
12211
|
}
|
|
@@ -12057,26 +12213,26 @@ function prune(held, removed = () => {}) {
|
|
|
12057
12213
|
const stale = files.filter((f) => Number(f.split("-")[0]) < cutoff);
|
|
12058
12214
|
const over = files.slice(0, Math.max(0, files.length - HOLD_MAX));
|
|
12059
12215
|
for (const f of new Set([...stale, ...over])) {
|
|
12060
|
-
|
|
12216
|
+
fs6.rmSync(path7.join(held, f), { force: true });
|
|
12061
12217
|
removed();
|
|
12062
12218
|
}
|
|
12063
12219
|
}
|
|
12064
12220
|
function put(dir, record) {
|
|
12065
|
-
|
|
12221
|
+
fs6.mkdirSync(dir, { recursive: true, mode: 448 });
|
|
12066
12222
|
const name = `${Date.now()}-${process.pid}-${Math.random().toString(36).slice(2, 10)}.json`;
|
|
12067
|
-
const tmp =
|
|
12068
|
-
|
|
12069
|
-
|
|
12070
|
-
return
|
|
12223
|
+
const tmp = path7.join(dir, `.${name}`);
|
|
12224
|
+
fs6.writeFileSync(tmp, JSON.stringify(record), { mode: 384 });
|
|
12225
|
+
fs6.renameSync(tmp, path7.join(dir, name));
|
|
12226
|
+
return path7.join(dir, name);
|
|
12071
12227
|
}
|
|
12072
12228
|
function spool(record) {
|
|
12073
12229
|
put(spoolDir(), record);
|
|
12074
12230
|
}
|
|
12075
12231
|
var branchOf = (root) => {
|
|
12076
12232
|
try {
|
|
12077
|
-
const dotgit =
|
|
12078
|
-
const gitdir =
|
|
12079
|
-
const h =
|
|
12233
|
+
const dotgit = path7.join(root, ".git");
|
|
12234
|
+
const gitdir = fs6.statSync(dotgit).isFile() ? path7.resolve(root, fs6.readFileSync(dotgit, "utf8").match(/^gitdir: (.+)$/m)?.[1]?.trim() ?? "") : dotgit;
|
|
12235
|
+
const h = fs6.readFileSync(path7.join(gitdir, "HEAD"), "utf8").trim();
|
|
12080
12236
|
return h.startsWith("ref: refs/heads/") ? h.slice("ref: refs/heads/".length) : null;
|
|
12081
12237
|
} catch {
|
|
12082
12238
|
return null;
|
|
@@ -12122,7 +12278,7 @@ Notes: ${notes.trim()}` : "";
|
|
|
12122
12278
|
};
|
|
12123
12279
|
}
|
|
12124
12280
|
function captureNotice(file = dbFile()) {
|
|
12125
|
-
if (!
|
|
12281
|
+
if (!fs6.existsSync(file))
|
|
12126
12282
|
return panel("sphica: no database, so conversations are not recorded", [file], "Create it with sphica init");
|
|
12127
12283
|
const s = readState();
|
|
12128
12284
|
if (s.unreadable)
|
|
@@ -12133,15 +12289,15 @@ function captureNotice(file = dbFile()) {
|
|
|
12133
12289
|
return panel(`sphica: the database rejected ${plural(s.rejected, "record")}`, [rejectedDir(), `Move them back to ${spoolDir()} to resend`], "Fix them first, then check with sphica doctor");
|
|
12134
12290
|
return null;
|
|
12135
12291
|
}
|
|
12136
|
-
var turnDir = (host, session) =>
|
|
12137
|
-
var startFile = (dir, turn) =>
|
|
12292
|
+
var turnDir = (host, session) => path7.join(baselineDir(), digest(`${host}\x00${session}`));
|
|
12293
|
+
var startFile = (dir, turn) => path7.join(dir, `${digest(turn)}.json`);
|
|
12138
12294
|
var isStart = (v) => {
|
|
12139
12295
|
const s = v;
|
|
12140
12296
|
return !!s && typeof s === "object" && typeof s.turn === "string" && typeof s.running === "boolean" && (s.seq === null || Number.isSafeInteger(s.seq)) && (s.entries === null || typeof s.entries === "object" && !Array.isArray(s.entries)) && (s.head === null || typeof s.head === "string");
|
|
12141
12297
|
};
|
|
12142
12298
|
function readStart(file) {
|
|
12143
12299
|
try {
|
|
12144
|
-
const s = JSON.parse(
|
|
12300
|
+
const s = JSON.parse(fs6.readFileSync(file, "utf8"));
|
|
12145
12301
|
return isStart(s) ? s : null;
|
|
12146
12302
|
} catch {
|
|
12147
12303
|
return null;
|
|
@@ -12150,7 +12306,7 @@ function readStart(file) {
|
|
|
12150
12306
|
function readStarts(dir) {
|
|
12151
12307
|
let names;
|
|
12152
12308
|
try {
|
|
12153
|
-
names =
|
|
12309
|
+
names = fs6.readdirSync(dir);
|
|
12154
12310
|
} catch (e) {
|
|
12155
12311
|
return e.code === "ENOENT" ? [] : null;
|
|
12156
12312
|
}
|
|
@@ -12158,7 +12314,7 @@ function readStarts(dir) {
|
|
|
12158
12314
|
for (const name of names) {
|
|
12159
12315
|
if (name.startsWith("."))
|
|
12160
12316
|
continue;
|
|
12161
|
-
const s = readStart(
|
|
12317
|
+
const s = readStart(path7.join(dir, name));
|
|
12162
12318
|
if (!s)
|
|
12163
12319
|
return null;
|
|
12164
12320
|
starts.push(s);
|
|
@@ -12168,30 +12324,30 @@ function readStarts(dir) {
|
|
|
12168
12324
|
function newestTurn(starts) {
|
|
12169
12325
|
if (!starts?.length || starts.some((s) => s.seq === null))
|
|
12170
12326
|
return null;
|
|
12171
|
-
const
|
|
12172
|
-
const at = starts.filter((s) => s.seq ===
|
|
12327
|
+
const top2 = Math.max(...starts.map((s) => s.seq));
|
|
12328
|
+
const at = starts.filter((s) => s.seq === top2);
|
|
12173
12329
|
return at.length === 1 ? at[0]?.turn ?? null : null;
|
|
12174
12330
|
}
|
|
12175
12331
|
function writeStart(dir, s, file = startFile(dir, s.turn)) {
|
|
12176
|
-
|
|
12177
|
-
const tmp =
|
|
12178
|
-
|
|
12179
|
-
|
|
12332
|
+
fs6.mkdirSync(dir, { recursive: true, mode: 448 });
|
|
12333
|
+
const tmp = path7.join(dir, `.${path7.basename(file)}.${process.pid}.tmp`);
|
|
12334
|
+
fs6.writeFileSync(tmp, JSON.stringify(s), { mode: 384 });
|
|
12335
|
+
fs6.renameSync(tmp, file);
|
|
12180
12336
|
}
|
|
12181
|
-
function openTurn(dir, turn, root) {
|
|
12337
|
+
async function openTurn(dir, turn, root) {
|
|
12182
12338
|
if (readStart(startFile(dir, turn))?.running)
|
|
12183
12339
|
return null;
|
|
12184
12340
|
const starts = readStarts(dir);
|
|
12185
12341
|
const seq = starts && !starts.some((s) => s.seq === null) ? Math.max(0, ...starts.map((s) => s.seq)) + 1 : null;
|
|
12186
|
-
const now = snapshot(root);
|
|
12342
|
+
const now = await snapshot(root);
|
|
12187
12343
|
return () => writeStart(dir, { head: now?.head ?? null, entries: now?.entries ?? null, running: true, turn, seq });
|
|
12188
12344
|
}
|
|
12189
|
-
function closeTurn(dir, turn, root) {
|
|
12345
|
+
async function closeTurn(dir, turn, root) {
|
|
12190
12346
|
const own = readStart(startFile(dir, turn));
|
|
12191
12347
|
if (!own?.entries)
|
|
12192
12348
|
return null;
|
|
12193
12349
|
const before = { head: own.head, entries: own.entries };
|
|
12194
|
-
const now = snapshot(root);
|
|
12350
|
+
const now = await snapshot(root);
|
|
12195
12351
|
return () => {
|
|
12196
12352
|
if (newestTurn(readStarts(dir)) !== turn || JSON.stringify(readStart(startFile(dir, turn))) !== JSON.stringify(own))
|
|
12197
12353
|
return [];
|
|
@@ -12206,22 +12362,22 @@ function stopTurn(dir, turn) {
|
|
|
12206
12362
|
}
|
|
12207
12363
|
function pruneBaselines() {
|
|
12208
12364
|
const cutoff = Date.now() - HOLD_DAYS * 24 * 60 * 60 * 1000;
|
|
12209
|
-
const fresh = (file) => (
|
|
12365
|
+
const fresh = (file) => (fs6.statSync(file, { throwIfNoEntry: false })?.mtimeMs ?? Date.now()) >= cutoff;
|
|
12210
12366
|
let names;
|
|
12211
12367
|
try {
|
|
12212
|
-
names =
|
|
12368
|
+
names = fs6.readdirSync(baselineDir());
|
|
12213
12369
|
} catch {
|
|
12214
12370
|
return;
|
|
12215
12371
|
}
|
|
12216
12372
|
for (const name of names) {
|
|
12217
|
-
const at =
|
|
12218
|
-
if (!
|
|
12373
|
+
const at = path7.join(baselineDir(), name);
|
|
12374
|
+
if (!fs6.statSync(at, { throwIfNoEntry: false })?.isDirectory()) {
|
|
12219
12375
|
if (!fresh(at))
|
|
12220
|
-
|
|
12376
|
+
fs6.rmSync(at, { force: true });
|
|
12221
12377
|
} else {
|
|
12222
|
-
const files =
|
|
12223
|
-
if (files.length && !files.some((f) => fresh(
|
|
12224
|
-
|
|
12378
|
+
const files = fs6.readdirSync(at);
|
|
12379
|
+
if (files.length && !files.some((f) => fresh(path7.join(at, f))))
|
|
12380
|
+
fs6.rmSync(at, { recursive: true, force: true });
|
|
12225
12381
|
}
|
|
12226
12382
|
}
|
|
12227
12383
|
}
|
|
@@ -12232,7 +12388,14 @@ function attempt(fn) {
|
|
|
12232
12388
|
return;
|
|
12233
12389
|
}
|
|
12234
12390
|
}
|
|
12235
|
-
function
|
|
12391
|
+
async function attemptAsync(fn) {
|
|
12392
|
+
try {
|
|
12393
|
+
return await fn();
|
|
12394
|
+
} catch {
|
|
12395
|
+
return;
|
|
12396
|
+
}
|
|
12397
|
+
}
|
|
12398
|
+
async function onHook(host, input) {
|
|
12236
12399
|
const event = input.hook_event_name;
|
|
12237
12400
|
const owner = () => isOwnerTurn(input, undefined, undefined, host === "codex" ? process.env.CODEX_THREAD_ID : undefined);
|
|
12238
12401
|
if (event === "SessionStart") {
|
|
@@ -12240,7 +12403,7 @@ function onHook(host, input) {
|
|
|
12240
12403
|
return { flush: false };
|
|
12241
12404
|
const file = process.env.CLAUDE_ENV_FILE;
|
|
12242
12405
|
if (file && input.session_id && /^[A-Za-z0-9_-]+$/.test(input.session_id)) {
|
|
12243
|
-
|
|
12406
|
+
fs6.appendFileSync(file, `export SPHICA_PARENT_SESSION=${input.session_id}
|
|
12244
12407
|
`);
|
|
12245
12408
|
}
|
|
12246
12409
|
attempt(pruneBaselines);
|
|
@@ -12284,12 +12447,12 @@ function onHook(host, input) {
|
|
|
12284
12447
|
say(`${turn}:owner`, "owner", prompt);
|
|
12285
12448
|
}
|
|
12286
12449
|
if (event === "UserPromptSubmit")
|
|
12287
|
-
|
|
12450
|
+
await attemptAsync(async () => (await openTurn(dir, turn, place.root))?.());
|
|
12288
12451
|
if (event === "Stop") {
|
|
12289
12452
|
if (input.last_assistant_message)
|
|
12290
12453
|
say(`${turn}:assistant`, "assistant", input.last_assistant_message);
|
|
12291
|
-
const paths =
|
|
12292
|
-
const finish = closeTurn(dir, turn, place.root);
|
|
12454
|
+
const paths = await attemptAsync(async () => {
|
|
12455
|
+
const finish = await closeTurn(dir, turn, place.root);
|
|
12293
12456
|
if (finish)
|
|
12294
12457
|
return finish();
|
|
12295
12458
|
stopTurn(dir, turn);
|
|
@@ -12323,7 +12486,7 @@ function onHook(host, input) {
|
|
|
12323
12486
|
function readStateFile() {
|
|
12324
12487
|
let raw = {};
|
|
12325
12488
|
try {
|
|
12326
|
-
const parsed = JSON.parse(
|
|
12489
|
+
const parsed = JSON.parse(fs6.readFileSync(stateFile(), "utf8"));
|
|
12327
12490
|
if (parsed && typeof parsed === "object")
|
|
12328
12491
|
raw = parsed;
|
|
12329
12492
|
} catch {}
|
|
@@ -12337,7 +12500,7 @@ function readStateFile() {
|
|
|
12337
12500
|
}
|
|
12338
12501
|
function writeState(s) {
|
|
12339
12502
|
try {
|
|
12340
|
-
|
|
12503
|
+
fs6.writeFileSync(stateFile(), JSON.stringify({ ...s, pruned: s.pruned ?? readStateFile().pruned }));
|
|
12341
12504
|
} catch {}
|
|
12342
12505
|
}
|
|
12343
12506
|
function readState() {
|
|
@@ -12353,7 +12516,7 @@ function readState() {
|
|
|
12353
12516
|
}
|
|
12354
12517
|
function listQueue(dir) {
|
|
12355
12518
|
try {
|
|
12356
|
-
const names =
|
|
12519
|
+
const names = fs6.readdirSync(dir);
|
|
12357
12520
|
return {
|
|
12358
12521
|
files: names.filter((f) => f.endsWith(".json") && !f.startsWith(".")),
|
|
12359
12522
|
temp: names.filter((f) => f.endsWith(".json") && f.startsWith(".")),
|
|
@@ -12365,25 +12528,25 @@ function listQueue(dir) {
|
|
|
12365
12528
|
}
|
|
12366
12529
|
}
|
|
12367
12530
|
function lock() {
|
|
12368
|
-
const file =
|
|
12369
|
-
|
|
12531
|
+
const file = path7.join(spoolDir(), ".lock");
|
|
12532
|
+
fs6.mkdirSync(spoolDir(), { recursive: true, mode: 448 });
|
|
12370
12533
|
for (let attempt2 = 0;attempt2 < 2; attempt2++) {
|
|
12371
12534
|
try {
|
|
12372
|
-
|
|
12535
|
+
fs6.writeFileSync(file, String(process.pid), { flag: "wx", mode: 384 });
|
|
12373
12536
|
return () => {
|
|
12374
12537
|
try {
|
|
12375
|
-
if (
|
|
12376
|
-
|
|
12538
|
+
if (fs6.readFileSync(file, "utf8") === String(process.pid))
|
|
12539
|
+
fs6.rmSync(file, { force: true });
|
|
12377
12540
|
} catch {}
|
|
12378
12541
|
};
|
|
12379
12542
|
} catch (e) {
|
|
12380
12543
|
if (e.code !== "EEXIST")
|
|
12381
12544
|
throw e;
|
|
12382
12545
|
}
|
|
12383
|
-
const st =
|
|
12546
|
+
const st = fs6.statSync(file, { throwIfNoEntry: false });
|
|
12384
12547
|
if (!st)
|
|
12385
12548
|
continue;
|
|
12386
|
-
const holder = Number(
|
|
12549
|
+
const holder = Number(fs6.readFileSync(file, "utf8") || 0);
|
|
12387
12550
|
const fresh = Date.now() - st.mtimeMs < 5 * 60000;
|
|
12388
12551
|
const alive = (() => {
|
|
12389
12552
|
if (holder <= 0)
|
|
@@ -12396,7 +12559,7 @@ function lock() {
|
|
|
12396
12559
|
})();
|
|
12397
12560
|
if (alive && fresh)
|
|
12398
12561
|
return null;
|
|
12399
|
-
|
|
12562
|
+
fs6.rmSync(file, { force: true });
|
|
12400
12563
|
}
|
|
12401
12564
|
return null;
|
|
12402
12565
|
}
|
|
@@ -12495,23 +12658,23 @@ var REJECTED = new Set([18, 19, 20, 25]);
|
|
|
12495
12658
|
var rejected = (e) => REJECTED.has(sqliteCode(e) ?? -1);
|
|
12496
12659
|
var queued = (from) => {
|
|
12497
12660
|
try {
|
|
12498
|
-
return
|
|
12661
|
+
return fs6.readdirSync(from).filter((f) => f.endsWith(".json") && !f.startsWith(".")).sort().map((name) => ({ name, from }));
|
|
12499
12662
|
} catch {
|
|
12500
12663
|
return [];
|
|
12501
12664
|
}
|
|
12502
12665
|
};
|
|
12503
12666
|
var CODE_NAMES = { 18: "TOOBIG", 19: "CONSTRAINT", 20: "MISMATCH", 25: "RANGE" };
|
|
12504
12667
|
function setAside(from, name, dir, reason2) {
|
|
12505
|
-
|
|
12668
|
+
fs6.mkdirSync(dir, { recursive: true, mode: 448 });
|
|
12506
12669
|
try {
|
|
12507
|
-
|
|
12670
|
+
fs6.renameSync(path7.join(from, name), path7.join(dir, name));
|
|
12508
12671
|
} catch (e) {
|
|
12509
12672
|
if (e.code === "ENOENT")
|
|
12510
12673
|
return;
|
|
12511
12674
|
throw e;
|
|
12512
12675
|
}
|
|
12513
12676
|
try {
|
|
12514
|
-
|
|
12677
|
+
fs6.writeFileSync(path7.join(dir, `${name}.reason`), reason2, { mode: 384 });
|
|
12515
12678
|
} catch {}
|
|
12516
12679
|
}
|
|
12517
12680
|
async function sendBatch(db, names) {
|
|
@@ -12521,7 +12684,7 @@ async function sendBatch(db, names) {
|
|
|
12521
12684
|
let raw;
|
|
12522
12685
|
let r;
|
|
12523
12686
|
try {
|
|
12524
|
-
raw = JSON.parse(
|
|
12687
|
+
raw = JSON.parse(fs6.readFileSync(path7.join(from, name), "utf8"));
|
|
12525
12688
|
} catch {
|
|
12526
12689
|
setAside(from, name, rejectedDir(), "unreadable");
|
|
12527
12690
|
continue;
|
|
@@ -12535,7 +12698,7 @@ async function sendBatch(db, names) {
|
|
|
12535
12698
|
if (r)
|
|
12536
12699
|
records.push({ name, from, r });
|
|
12537
12700
|
else
|
|
12538
|
-
|
|
12701
|
+
fs6.rmSync(path7.join(from, name), { force: true });
|
|
12539
12702
|
}
|
|
12540
12703
|
let sent = 0;
|
|
12541
12704
|
let strayed = [];
|
|
@@ -12563,12 +12726,12 @@ async function sendBatch(db, names) {
|
|
|
12563
12726
|
for (const x of bad)
|
|
12564
12727
|
setAside(x.from, x.name, rejectedDir(), x.why);
|
|
12565
12728
|
if (strayed.length) {
|
|
12566
|
-
|
|
12729
|
+
fs6.mkdirSync(held, { recursive: true, mode: 448 });
|
|
12567
12730
|
for (const x of strayed) {
|
|
12568
12731
|
if (x.from === held)
|
|
12569
12732
|
continue;
|
|
12570
12733
|
try {
|
|
12571
|
-
|
|
12734
|
+
fs6.renameSync(path7.join(x.from, x.name), path7.join(held, x.name));
|
|
12572
12735
|
} catch (e) {
|
|
12573
12736
|
if (e.code !== "ENOENT")
|
|
12574
12737
|
throw e;
|
|
@@ -12578,7 +12741,7 @@ async function sendBatch(db, names) {
|
|
|
12578
12741
|
const moved = new Set([...bad, ...strayed].map((x) => x.name));
|
|
12579
12742
|
for (const x of records)
|
|
12580
12743
|
if (!moved.has(x.name))
|
|
12581
|
-
|
|
12744
|
+
fs6.rmSync(path7.join(x.from, x.name), { force: true });
|
|
12582
12745
|
return { sent, rejected: bad.length };
|
|
12583
12746
|
}
|
|
12584
12747
|
async function sendObservations(db, names) {
|
|
@@ -12589,16 +12752,16 @@ async function sendObservations(db, names) {
|
|
|
12589
12752
|
};
|
|
12590
12753
|
const rows = [];
|
|
12591
12754
|
for (const { name, from } of names) {
|
|
12592
|
-
let
|
|
12755
|
+
let text2;
|
|
12593
12756
|
try {
|
|
12594
|
-
|
|
12757
|
+
text2 = fs6.readFileSync(path7.join(from, name), "utf8");
|
|
12595
12758
|
} catch {
|
|
12596
12759
|
continue;
|
|
12597
12760
|
}
|
|
12598
12761
|
let o = null;
|
|
12599
12762
|
let why = "unreadable";
|
|
12600
12763
|
try {
|
|
12601
|
-
o = observation(JSON.parse(
|
|
12764
|
+
o = observation(JSON.parse(text2));
|
|
12602
12765
|
why = "shape";
|
|
12603
12766
|
} catch {}
|
|
12604
12767
|
if (o)
|
|
@@ -12630,7 +12793,7 @@ async function sendObservations(db, names) {
|
|
|
12630
12793
|
aside(x.name, why);
|
|
12631
12794
|
else
|
|
12632
12795
|
try {
|
|
12633
|
-
|
|
12796
|
+
fs6.rmSync(path7.join(callsDir(), x.name), { force: true });
|
|
12634
12797
|
} catch {}
|
|
12635
12798
|
}
|
|
12636
12799
|
return true;
|
|
@@ -12773,7 +12936,7 @@ async function observeRecordCall(file, input, owner, waitMs = OBSERVE_WAIT_MS) {
|
|
|
12773
12936
|
}
|
|
12774
12937
|
if (kept)
|
|
12775
12938
|
try {
|
|
12776
|
-
|
|
12939
|
+
fs6.rmSync(kept, { force: true });
|
|
12777
12940
|
} catch {}
|
|
12778
12941
|
}
|
|
12779
12942
|
async function main() {
|
|
@@ -12789,11 +12952,11 @@ async function main() {
|
|
|
12789
12952
|
}
|
|
12790
12953
|
if (host === "codex" && input.hook_event_name === "Stop")
|
|
12791
12954
|
process.stdout.write("{}");
|
|
12792
|
-
const { flush: send, notice } = onHook(host, input);
|
|
12955
|
+
const { flush: send, notice } = await onHook(host, input);
|
|
12793
12956
|
if (notice)
|
|
12794
12957
|
process.stdout.write(JSON.stringify({ systemMessage: notice }));
|
|
12795
12958
|
if (send)
|
|
12796
|
-
|
|
12959
|
+
spawn2(process.execPath, [process.argv[1] ?? "", "--flush"], {
|
|
12797
12960
|
detached: true,
|
|
12798
12961
|
stdio: "ignore",
|
|
12799
12962
|
windowsHide: true
|
|
@@ -12835,13 +12998,13 @@ function gitPath(token, prefix) {
|
|
|
12835
12998
|
}
|
|
12836
12999
|
return prefix && out.startsWith(prefix) ? out.slice(prefix.length) : out;
|
|
12837
13000
|
}
|
|
12838
|
-
function parseDiff(
|
|
13001
|
+
function parseDiff(text2) {
|
|
12839
13002
|
const files = [];
|
|
12840
|
-
const at = (
|
|
12841
|
-
const found = files.find((f2) => f2.path ===
|
|
13003
|
+
const at = (path8) => {
|
|
13004
|
+
const found = files.find((f2) => f2.path === path8);
|
|
12842
13005
|
if (found)
|
|
12843
13006
|
return found;
|
|
12844
|
-
const f = { path:
|
|
13007
|
+
const f = { path: path8, added: [], lines: [] };
|
|
12845
13008
|
files.push(f);
|
|
12846
13009
|
return f;
|
|
12847
13010
|
};
|
|
@@ -12855,7 +13018,7 @@ function parseDiff(text) {
|
|
|
12855
13018
|
at(block);
|
|
12856
13019
|
block = null;
|
|
12857
13020
|
};
|
|
12858
|
-
const rows =
|
|
13021
|
+
const rows = text2.split(/\r?\n/);
|
|
12859
13022
|
for (const [i, raw] of rows.entries()) {
|
|
12860
13023
|
if (cur && (oldLeft > 0 || newLeft > 0)) {
|
|
12861
13024
|
if (raw.startsWith("+")) {
|
|
@@ -12952,11 +13115,11 @@ async function selectForReview(db, projectId2, files) {
|
|
|
12952
13115
|
}
|
|
12953
13116
|
|
|
12954
13117
|
// server/src/review-bridge.ts
|
|
12955
|
-
import
|
|
12956
|
-
import
|
|
12957
|
-
import path7 from "node:path";
|
|
13118
|
+
import fs7 from "node:fs";
|
|
13119
|
+
import path8 from "node:path";
|
|
12958
13120
|
var NAME = /^[\w.:/-]{1,100}$/;
|
|
12959
13121
|
var MAX_DIFF = 4 * 1024 * 1024;
|
|
13122
|
+
var DIFF_DEADLINE = 5000;
|
|
12960
13123
|
var MAX_FILES = 500;
|
|
12961
13124
|
var MAX_UNTRACKED_BYTES = 256 * 1024;
|
|
12962
13125
|
function reviewCall(input) {
|
|
@@ -12974,28 +13137,22 @@ function reviewCall(input) {
|
|
|
12974
13137
|
const lower = name.toLowerCase();
|
|
12975
13138
|
if (lower === "sphica:review")
|
|
12976
13139
|
return null;
|
|
12977
|
-
const names = (
|
|
13140
|
+
const names = (list2) => (list2 ?? "").split(",").map((n) => n.trim().toLowerCase()).filter((n) => NAME.test(n));
|
|
12978
13141
|
const option = names(process.env.CLAUDE_PLUGIN_OPTION_REVIEW_COMMANDS);
|
|
12979
13142
|
const named = option.length > 0 ? option : names(process.env.SPHICA_REVIEW_COMMANDS);
|
|
12980
13143
|
if (!named.includes(lower) && !lower.includes("review"))
|
|
12981
13144
|
return null;
|
|
12982
13145
|
return { name, args: typeof args === "string" ? args.slice(0, 1000) : "" };
|
|
12983
13146
|
}
|
|
12984
|
-
|
|
12985
|
-
encoding: "utf8",
|
|
12986
|
-
stdio: ["ignore", "pipe", "ignore"],
|
|
12987
|
-
maxBuffer
|
|
12988
|
-
});
|
|
12989
|
-
function localChange(root, args) {
|
|
13147
|
+
async function localChange(root, args) {
|
|
12990
13148
|
if (/^\s*#?\d+\s*$|(^|\s)#\d+\b|\/pull\/\d+/.test(args))
|
|
12991
13149
|
return { problem: "it names a pull request, and Sphica sees only the local change" };
|
|
13150
|
+
const until = Date.now() + DIFF_DEADLINE;
|
|
13151
|
+
const left = () => Math.max(1, until - Date.now());
|
|
12992
13152
|
let base = "";
|
|
12993
|
-
for (const
|
|
12994
|
-
["--abbrev-ref", "origin/HEAD"],
|
|
12995
|
-
["--abbrev-ref", "--symbolic-full-name", "@{upstream}"]
|
|
12996
|
-
]) {
|
|
13153
|
+
for (const which of ["origin/HEAD", "upstream"]) {
|
|
12997
13154
|
try {
|
|
12998
|
-
base =
|
|
13155
|
+
base = baseRef(root, which, { timeout: left() });
|
|
12999
13156
|
if (base)
|
|
13000
13157
|
break;
|
|
13001
13158
|
} catch {}
|
|
@@ -13004,28 +13161,22 @@ function localChange(root, args) {
|
|
|
13004
13161
|
return { problem: "there is no default branch (origin/HEAD) or upstream to compare with" };
|
|
13005
13162
|
let from;
|
|
13006
13163
|
try {
|
|
13007
|
-
from =
|
|
13164
|
+
from = mergeBase(root, "HEAD", base, { timeout: left() });
|
|
13008
13165
|
} catch {
|
|
13009
13166
|
return { problem: `HEAD shares no history with ${base}` };
|
|
13010
13167
|
}
|
|
13011
|
-
|
|
13012
|
-
let names;
|
|
13168
|
+
const got = await worktreeDiff(root, from, { max: MAX_DIFF, deadline: left() });
|
|
13013
13169
|
let untracked;
|
|
13014
13170
|
try {
|
|
13015
|
-
|
|
13016
|
-
"
|
|
13017
|
-
|
|
13018
|
-
"--no-textconv",
|
|
13019
|
-
"--no-renames",
|
|
13020
|
-
"--src-prefix=a/",
|
|
13021
|
-
"--dst-prefix=b/"
|
|
13022
|
-
];
|
|
13023
|
-
diff = git3(root, ["diff", ...plain3, from], MAX_DIFF);
|
|
13024
|
-
names = git3(root, ["diff", "--name-only", "-z", "--no-renames", from], MAX_DIFF).split("\x00").filter(Boolean);
|
|
13025
|
-
untracked = git3(root, ["ls-files", "--others", "--exclude-standard", "-z"], MAX_DIFF).split("\x00").filter(Boolean);
|
|
13171
|
+
if (!got)
|
|
13172
|
+
throw new Error("no diff");
|
|
13173
|
+
untracked = listFiles(root, "untracked", { max: MAX_DIFF, timeout: left() });
|
|
13026
13174
|
} catch {
|
|
13027
|
-
return {
|
|
13175
|
+
return {
|
|
13176
|
+
problem: "the change could not be read in time, or is too large to read (over 4 MB of diff or file names)"
|
|
13177
|
+
};
|
|
13028
13178
|
}
|
|
13179
|
+
const { patch: diff, names } = got;
|
|
13029
13180
|
const files = parseDiff(diff);
|
|
13030
13181
|
for (const name of names)
|
|
13031
13182
|
if (!files.some((f) => f.path === name))
|
|
@@ -13034,20 +13185,239 @@ function localChange(root, args) {
|
|
|
13034
13185
|
return { problem: `the change has more than ${MAX_FILES} files` };
|
|
13035
13186
|
const read = [from, diff];
|
|
13036
13187
|
for (const rel of untracked) {
|
|
13037
|
-
let
|
|
13188
|
+
let text2 = "";
|
|
13038
13189
|
try {
|
|
13039
|
-
const file =
|
|
13040
|
-
const st =
|
|
13190
|
+
const file = path8.join(root, rel);
|
|
13191
|
+
const st = fs7.lstatSync(file);
|
|
13041
13192
|
if (st.isFile() && st.size <= MAX_UNTRACKED_BYTES)
|
|
13042
|
-
|
|
13193
|
+
text2 = fs7.readFileSync(file, "utf8");
|
|
13043
13194
|
} catch {}
|
|
13044
|
-
const added =
|
|
13195
|
+
const added = text2 ? text2.split(/\r?\n/) : [];
|
|
13045
13196
|
files.push({ path: rel, added, lines: added.map((_, i) => i + 1) });
|
|
13046
|
-
read.push(rel,
|
|
13197
|
+
read.push(rel, text2);
|
|
13047
13198
|
}
|
|
13048
13199
|
return { base, files, digest: sha256(read.join("\x00")).toString("hex") };
|
|
13049
13200
|
}
|
|
13050
13201
|
|
|
13202
|
+
// server/src/shell-state.ts
|
|
13203
|
+
import { createHash } from "node:crypto";
|
|
13204
|
+
import fs8 from "node:fs";
|
|
13205
|
+
import path9 from "node:path";
|
|
13206
|
+
var READS = 3;
|
|
13207
|
+
var SNAPSHOT_LIFE_MS = 7 * 24 * 60 * 60 * 1000;
|
|
13208
|
+
var dir = (...parts) => path9.join(sphicaHome(), "shell-state", ...parts);
|
|
13209
|
+
var sha = (s) => createHash("sha256").update(s).digest("hex");
|
|
13210
|
+
var signature = (st) => ({
|
|
13211
|
+
dev: String(st.dev),
|
|
13212
|
+
ino: String(st.ino),
|
|
13213
|
+
size: String(st.size),
|
|
13214
|
+
mtimeNs: String(st.mtimeNs),
|
|
13215
|
+
ctimeNs: String(st.ctimeNs)
|
|
13216
|
+
});
|
|
13217
|
+
var same = (a, b) => a.dev === b.dev && a.ino === b.ino && a.size === b.size && a.mtimeNs === b.mtimeNs && a.ctimeNs === b.ctimeNs;
|
|
13218
|
+
function inside(root, rel) {
|
|
13219
|
+
const real = fs8.realpathSync.native(root);
|
|
13220
|
+
const file = path9.resolve(root, rel);
|
|
13221
|
+
if (leaves2(path9.relative(root, file)))
|
|
13222
|
+
return null;
|
|
13223
|
+
let probe = file;
|
|
13224
|
+
while (!fs8.existsSync(probe)) {
|
|
13225
|
+
const up = path9.dirname(probe);
|
|
13226
|
+
if (up === probe)
|
|
13227
|
+
return null;
|
|
13228
|
+
probe = up;
|
|
13229
|
+
}
|
|
13230
|
+
return leaves2(path9.relative(real, fs8.realpathSync.native(probe))) ? null : file;
|
|
13231
|
+
}
|
|
13232
|
+
var leaves2 = (rel) => rel === ".." || rel.startsWith(`..${path9.sep}`) || path9.isAbsolute(rel);
|
|
13233
|
+
var cacheFile = (root) => dir("cache", `${sha(fs8.realpathSync.native(root))}.json`);
|
|
13234
|
+
function loadCache(root) {
|
|
13235
|
+
try {
|
|
13236
|
+
const raw = JSON.parse(fs8.readFileSync(cacheFile(root), "utf8"));
|
|
13237
|
+
const out = new Map;
|
|
13238
|
+
if (raw && typeof raw === "object" && !Array.isArray(raw))
|
|
13239
|
+
for (const [k, v] of Object.entries(raw)) {
|
|
13240
|
+
const e = v;
|
|
13241
|
+
if (e?.sig && typeof e.hash === "string" && /^[0-9a-f]{64}$/.test(e.hash) && validSig(e.sig))
|
|
13242
|
+
out.set(k, { sig: e.sig, hash: e.hash });
|
|
13243
|
+
}
|
|
13244
|
+
return out;
|
|
13245
|
+
} catch {
|
|
13246
|
+
return new Map;
|
|
13247
|
+
}
|
|
13248
|
+
}
|
|
13249
|
+
var validSig = (s) => !!s && typeof s === "object" && ["dev", "ino", "size"].every((k) => /^\d+$/.test(String(s[k]))) && ["mtimeNs", "ctimeNs"].every((k) => /^-?\d+$/.test(String(s[k])));
|
|
13250
|
+
function publish(file, text2) {
|
|
13251
|
+
fs8.mkdirSync(path9.dirname(file), { recursive: true });
|
|
13252
|
+
const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
|
|
13253
|
+
fs8.writeFileSync(tmp, text2);
|
|
13254
|
+
fs8.renameSync(tmp, file);
|
|
13255
|
+
}
|
|
13256
|
+
function saveCache(root, cache, watched) {
|
|
13257
|
+
try {
|
|
13258
|
+
const kept = watched.flatMap((rel) => {
|
|
13259
|
+
const e = cache.get(rel);
|
|
13260
|
+
return e ? [[rel, e]] : [];
|
|
13261
|
+
});
|
|
13262
|
+
publish(cacheFile(root), JSON.stringify(Object.fromEntries(kept)));
|
|
13263
|
+
} catch {}
|
|
13264
|
+
}
|
|
13265
|
+
function readHash(fd, deadline) {
|
|
13266
|
+
const h = createHash("sha256");
|
|
13267
|
+
const buf = Buffer.allocUnsafe(1 << 20);
|
|
13268
|
+
for (let n = fs8.readSync(fd, buf, 0, buf.length, null);n > 0; n = fs8.readSync(fd, buf, 0, buf.length, null)) {
|
|
13269
|
+
h.update(buf.subarray(0, n));
|
|
13270
|
+
if (Date.now() >= deadline)
|
|
13271
|
+
return "deadline";
|
|
13272
|
+
}
|
|
13273
|
+
return h.digest("hex");
|
|
13274
|
+
}
|
|
13275
|
+
var failed = (e) => {
|
|
13276
|
+
const code = e.code;
|
|
13277
|
+
return code === "ENOENT" || code === "ENOTDIR" ? { kind: "missing" } : { kind: "unreadable", reason: String(code) };
|
|
13278
|
+
};
|
|
13279
|
+
function readOpened(root, file, fd, sig, deadline) {
|
|
13280
|
+
const opened = fs8.fstatSync(fd, { bigint: true });
|
|
13281
|
+
if (!same(sig, signature(opened)))
|
|
13282
|
+
return "again";
|
|
13283
|
+
const real = fs8.realpathSync.native(file);
|
|
13284
|
+
if (leaves2(path9.relative(fs8.realpathSync.native(root), real)))
|
|
13285
|
+
return { kind: "unreadable", reason: "outside the checkout" };
|
|
13286
|
+
const there = fs8.lstatSync(real, { bigint: true });
|
|
13287
|
+
if (there.dev !== opened.dev || there.ino !== opened.ino)
|
|
13288
|
+
return "again";
|
|
13289
|
+
const hash = readHash(fd, deadline);
|
|
13290
|
+
if (hash === "deadline")
|
|
13291
|
+
return { kind: "unknown", reason: "deadline" };
|
|
13292
|
+
if (!same(sig, signature(fs8.fstatSync(fd, { bigint: true }))))
|
|
13293
|
+
return "again";
|
|
13294
|
+
if (!same(sig, signature(fs8.lstatSync(file, { bigint: true }))))
|
|
13295
|
+
return "again";
|
|
13296
|
+
return { kind: "ok", sig, hash };
|
|
13297
|
+
}
|
|
13298
|
+
function stateOf(root, rel, cache, deadline) {
|
|
13299
|
+
for (let i = 0;i < READS; i++) {
|
|
13300
|
+
if (Date.now() >= deadline)
|
|
13301
|
+
return { kind: "unknown", reason: "deadline" };
|
|
13302
|
+
let file;
|
|
13303
|
+
let before;
|
|
13304
|
+
try {
|
|
13305
|
+
file = inside(root, rel);
|
|
13306
|
+
if (!file)
|
|
13307
|
+
return { kind: "unreadable", reason: "outside the checkout" };
|
|
13308
|
+
before = fs8.lstatSync(file, { bigint: true });
|
|
13309
|
+
if (before.isSymbolicLink()) {
|
|
13310
|
+
file = fs8.realpathSync.native(file);
|
|
13311
|
+
if (leaves2(path9.relative(fs8.realpathSync.native(root), file)))
|
|
13312
|
+
return { kind: "unreadable", reason: "outside the checkout" };
|
|
13313
|
+
before = fs8.lstatSync(file, { bigint: true });
|
|
13314
|
+
}
|
|
13315
|
+
} catch (e) {
|
|
13316
|
+
return failed(e);
|
|
13317
|
+
}
|
|
13318
|
+
if (!before.isFile())
|
|
13319
|
+
return { kind: "unreadable", reason: "not a regular file" };
|
|
13320
|
+
const sig = signature(before);
|
|
13321
|
+
const cached = cache.get(rel);
|
|
13322
|
+
if (cached && same(cached.sig, sig))
|
|
13323
|
+
return { kind: "ok", sig, hash: cached.hash };
|
|
13324
|
+
let fd;
|
|
13325
|
+
try {
|
|
13326
|
+
fd = fs8.openSync(file, "r");
|
|
13327
|
+
} catch (e) {
|
|
13328
|
+
if (e.code === "ENOENT")
|
|
13329
|
+
continue;
|
|
13330
|
+
return failed(e);
|
|
13331
|
+
}
|
|
13332
|
+
let outcome;
|
|
13333
|
+
try {
|
|
13334
|
+
outcome = readOpened(root, file, fd, sig, deadline);
|
|
13335
|
+
} catch (e) {
|
|
13336
|
+
outcome = e.code === "ENOENT" ? "again" : failed(e);
|
|
13337
|
+
} finally {
|
|
13338
|
+
fs8.closeSync(fd);
|
|
13339
|
+
}
|
|
13340
|
+
if (outcome === "again")
|
|
13341
|
+
continue;
|
|
13342
|
+
if (outcome.kind === "ok")
|
|
13343
|
+
cache.set(rel, { sig, hash: outcome.hash });
|
|
13344
|
+
return outcome;
|
|
13345
|
+
}
|
|
13346
|
+
return { kind: "unknown", reason: "changed while read" };
|
|
13347
|
+
}
|
|
13348
|
+
function takeStates(root, rels, cache, deadline) {
|
|
13349
|
+
const out = Object.create(null);
|
|
13350
|
+
for (const rel of rels)
|
|
13351
|
+
out[rel] = stateOf(root, rel, cache, deadline);
|
|
13352
|
+
return out;
|
|
13353
|
+
}
|
|
13354
|
+
function compare(before, after) {
|
|
13355
|
+
const changed2 = [];
|
|
13356
|
+
const unknown = [];
|
|
13357
|
+
for (const rel of new Set([...Object.keys(before), ...Object.keys(after)])) {
|
|
13358
|
+
const a = before[rel];
|
|
13359
|
+
const b = after[rel];
|
|
13360
|
+
if (!a || !b || a.kind === "unknown" || a.kind === "unreadable" || b.kind === "unknown" || b.kind === "unreadable") {
|
|
13361
|
+
unknown.push(rel);
|
|
13362
|
+
continue;
|
|
13363
|
+
}
|
|
13364
|
+
if (a.kind === "missing" && b.kind === "missing")
|
|
13365
|
+
continue;
|
|
13366
|
+
if (a.kind !== b.kind || a.kind === "ok" && b.kind === "ok" && a.hash !== b.hash)
|
|
13367
|
+
changed2.push(rel);
|
|
13368
|
+
}
|
|
13369
|
+
return { changed: changed2.sort(), unknown: unknown.sort() };
|
|
13370
|
+
}
|
|
13371
|
+
var snapshotKey = (host, session, agent, call) => sha(JSON.stringify([host, session, agent ?? "", call]));
|
|
13372
|
+
var snapshotFile = (key) => dir("calls", `${key}.json`);
|
|
13373
|
+
function writeSnapshot(s) {
|
|
13374
|
+
publish(snapshotFile(s.key), JSON.stringify(s));
|
|
13375
|
+
}
|
|
13376
|
+
function takeSnapshot(key) {
|
|
13377
|
+
const file = snapshotFile(key);
|
|
13378
|
+
let raw;
|
|
13379
|
+
try {
|
|
13380
|
+
raw = JSON.parse(fs8.readFileSync(file, "utf8"));
|
|
13381
|
+
} catch {
|
|
13382
|
+
return null;
|
|
13383
|
+
}
|
|
13384
|
+
fs8.rmSync(file, { force: true });
|
|
13385
|
+
const s = raw;
|
|
13386
|
+
if (s?.v !== 1 || s.key !== key || typeof s.root !== "string" || typeof s.project !== "string" || typeof s.at !== "string" || !s.paths || typeof s.paths !== "object" || Array.isArray(s.paths) || Number.isNaN(Date.parse(s.at)))
|
|
13387
|
+
return null;
|
|
13388
|
+
if (Date.now() - Date.parse(s.at) > SNAPSHOT_LIFE_MS)
|
|
13389
|
+
return "expired";
|
|
13390
|
+
for (const v of Object.values(s.paths)) {
|
|
13391
|
+
const st = v;
|
|
13392
|
+
if (!st || !["ok", "missing", "unreadable", "unknown"].includes(st.kind))
|
|
13393
|
+
return null;
|
|
13394
|
+
if (st.kind === "ok" && (!validSig(st.sig) || !/^[0-9a-f]{64}$/.test(st.hash)))
|
|
13395
|
+
return null;
|
|
13396
|
+
}
|
|
13397
|
+
return s;
|
|
13398
|
+
}
|
|
13399
|
+
function pruneSnapshots(now = Date.now(), deadline = Number.POSITIVE_INFINITY) {
|
|
13400
|
+
let removed = 0;
|
|
13401
|
+
let names;
|
|
13402
|
+
try {
|
|
13403
|
+
names = fs8.readdirSync(dir("calls"));
|
|
13404
|
+
} catch {
|
|
13405
|
+
return 0;
|
|
13406
|
+
}
|
|
13407
|
+
for (const n of names) {
|
|
13408
|
+
if (Date.now() >= deadline)
|
|
13409
|
+
break;
|
|
13410
|
+
const file = dir("calls", n);
|
|
13411
|
+
try {
|
|
13412
|
+
if (now - fs8.statSync(file).mtimeMs > SNAPSHOT_LIFE_MS) {
|
|
13413
|
+
fs8.rmSync(file, { force: true });
|
|
13414
|
+
removed++;
|
|
13415
|
+
}
|
|
13416
|
+
} catch {}
|
|
13417
|
+
}
|
|
13418
|
+
return removed;
|
|
13419
|
+
}
|
|
13420
|
+
|
|
13051
13421
|
// server/src/trace.ts
|
|
13052
13422
|
var PENDING_DAYS = 14;
|
|
13053
13423
|
var pendingCutoff = (now) => new Date(now.getTime() - PENDING_DAYS * 86400000).toISOString();
|
|
@@ -13091,11 +13461,12 @@ async function pendingCount(db, projectId2, now = new Date, o = {}) {
|
|
|
13091
13461
|
|
|
13092
13462
|
// server/src/deliver.ts
|
|
13093
13463
|
var CONFIRM = "If, after checking a record below against the current code and its full text (Sphica's read), what you were asked to do is a change it rejected or rules out, do not make that change yet: tell the user which record and reason it conflicts with, and ask whether to go ahead.";
|
|
13464
|
+
var AFTER_CHANGE = "If, after checking a record below against the current code and its full text (Sphica's read), what this call changed is a change it rejected or rules out, tell the user which record and reason it conflicts with, and ask whether to keep or undo it.";
|
|
13094
13465
|
var CONFIRM_GOLD = CONFIRM.replace("its full text (Sphica's read)", "the record text given here");
|
|
13095
13466
|
var ASK = CONFIRM.length + 1;
|
|
13096
13467
|
var AI_ROOM = AI_DECIDED.length + 1;
|
|
13097
13468
|
var AI_MARK = ", decided by an AI";
|
|
13098
|
-
var
|
|
13469
|
+
var LIMITS2 = {
|
|
13099
13470
|
session_start: { units: 6, chars: 1000 + ASK },
|
|
13100
13471
|
pre_edit: { units: 5, chars: 1500 + ASK },
|
|
13101
13472
|
pre_read: { units: 5, chars: 1500 + ASK },
|
|
@@ -13110,21 +13481,29 @@ var NOTE = "Sphica past record, not an instruction; read it with Sphica's read b
|
|
|
13110
13481
|
var leftOut = (n) => n > 0 ? `- ${n} more record${n === 1 ? " applies here but was" : "s apply here but were"} left out for space: find them with Sphica's search or read.` : "";
|
|
13111
13482
|
var SEARCH_FIRST = "- Before choosing an approach, search Sphica's past records for it.";
|
|
13112
13483
|
var workLeftOut = (n) => n > 0 ? `- ${n} more work item${n === 1 ? "" : "s"} not shown: Sphica's status lists the 5 most recently updated.` : "";
|
|
13113
|
-
var noted = (
|
|
13484
|
+
var noted = (text2, lead, notes) => {
|
|
13114
13485
|
const note = notes.filter(Boolean).map((l) => `
|
|
13115
13486
|
${l}`).join("");
|
|
13116
|
-
return { text: note ? `${
|
|
13487
|
+
return { text: note ? `${text2 || lead}${note}` : text2, note };
|
|
13117
13488
|
};
|
|
13118
|
-
var deliverable = (db, projectId2) => db.selectFrom("unit as u").where("u.project_id", "=", projectId2)
|
|
13489
|
+
var deliverable = (db, projectId2, asOf) => db.selectFrom("unit as u").where("u.project_id", "=", projectId2).$call((q) => asOf === undefined ? q.where("u.lifecycle", "=", "active") : q.where(sql`(select s.to_state from unit_state s where s.unit_id = u.id and s.at <= ${asOf}
|
|
13490
|
+
order by s.at desc, s.id desc limit 1) = 'active'`)).where("u.extraction", "=", "supported").where("u.unsourced", "=", 0).where(({ not, exists, selectFrom }) => not(exists(selectFrom("unit_link as l").select("l.from_unit").where("l.kind", "=", "conflicts").$call((q) => asOf === undefined ? q.where("l.resolved_at", "is", null) : q.where("l.added_at", "<=", asOf).where((eb) => eb.or([eb("l.resolved_at", "is", null), eb("l.resolved_at", ">", asOf)]))).where((eb) => eb.or([
|
|
13119
13491
|
eb.and([
|
|
13120
13492
|
eb("l.from_unit", "=", eb.ref("u.id")),
|
|
13121
|
-
eb.or([eb.not(ownerAdopted("u.id")), ownerAdopted("l.to_unit")])
|
|
13493
|
+
eb.or([eb.not(ownerAdopted("u.id", asOf)), ownerAdopted("l.to_unit", asOf)])
|
|
13122
13494
|
]),
|
|
13123
13495
|
eb.and([
|
|
13124
13496
|
eb("l.to_unit", "=", eb.ref("u.id")),
|
|
13125
|
-
eb.or([eb.not(ownerAdopted("u.id")), ownerAdopted("l.from_unit")])
|
|
13497
|
+
eb.or([eb.not(ownerAdopted("u.id", asOf)), ownerAdopted("l.from_unit", asOf)])
|
|
13126
13498
|
])
|
|
13127
13499
|
])))));
|
|
13500
|
+
async function deliverablePaths(db, projectId2) {
|
|
13501
|
+
const rows = await deliverable(db, projectId2).innerJoin("unit_anchor as a", "a.unit_id", "u.id").where("a.role", "=", "applies_to").where("a.retired_at", "is", null).where("u.kind", "in", ["decision", "constraint"]).select("a.path").distinct().orderBy("a.path").execute();
|
|
13502
|
+
return rows.map((r) => r.path);
|
|
13503
|
+
}
|
|
13504
|
+
async function deliverableIds(db, projectId2, asOf) {
|
|
13505
|
+
return new Set((await deliverable(db, projectId2, asOf).select("u.id").execute()).map((r) => r.id));
|
|
13506
|
+
}
|
|
13128
13507
|
var line = (u, extra = "", ai = false) => `- ${inline(u.key)} (${u.kind}${u.stance ? ` ${u.stance}` : ""}${ai ? AI_MARK : ""}): ${head(inline(u.text), 240)}${extra}`;
|
|
13129
13508
|
async function aiDecided(db, ids) {
|
|
13130
13509
|
const whose = await authorityOf(db, ids);
|
|
@@ -13138,8 +13517,8 @@ function fitMarked(lines, chars, lead, ai, ids) {
|
|
|
13138
13517
|
return { ...f, lead: wide.lead };
|
|
13139
13518
|
return { ...f, text: f.text && `${lead}${f.text.slice(wide.lead.length)}`, lead };
|
|
13140
13519
|
}
|
|
13141
|
-
var clip = (
|
|
13142
|
-
const chars = Array.from(inline(
|
|
13520
|
+
var clip = (text2, n) => {
|
|
13521
|
+
const chars = Array.from(inline(text2));
|
|
13143
13522
|
return chars.length <= n ? chars.join("") : `${chars.slice(0, n - 1).join("")}…`;
|
|
13144
13523
|
};
|
|
13145
13524
|
async function reasons(db, ids) {
|
|
@@ -13198,13 +13577,18 @@ function fit2(lines, chars, lead, free = []) {
|
|
|
13198
13577
|
};
|
|
13199
13578
|
}
|
|
13200
13579
|
var anchoredTo = (db, projectId2, rels) => deliverable(db, projectId2).innerJoin("unit_anchor as a", "a.unit_id", "u.id").where("a.path", "in", rels).where("a.role", "=", "applies_to").where("a.retired_at", "is", null).select(["u.id", "u.key", "u.kind", "u.stance", "u.text"]).groupBy("u.id").orderBy("u.id", "desc");
|
|
13580
|
+
async function anchoredRules(db, projectId2, rels) {
|
|
13581
|
+
const wanted = new Set(rels);
|
|
13582
|
+
const anchors = await deliverable(db, projectId2).innerJoin("unit_anchor as a", "a.unit_id", "u.id").where("a.role", "=", "applies_to").where("a.retired_at", "is", null).where("u.kind", "in", ["decision", "constraint"]).select(["u.id", "a.path"]).execute();
|
|
13583
|
+
return [...new Set(anchors.filter((a) => wanted.has(a.path)).map((a) => a.id))].sort((a, b) => b - a);
|
|
13584
|
+
}
|
|
13201
13585
|
var named = (rels) => rels.length <= 3 ? rels.map(inline).join(", ") : `${rels.slice(0, 3).map(inline).join(", ")} and ${rels.length - 3} more`;
|
|
13202
13586
|
async function beforeEdit(db, projectId2, rels) {
|
|
13203
13587
|
const rows = await anchoredTo(db, projectId2, rels).execute();
|
|
13204
|
-
const shown = rows.slice(0,
|
|
13588
|
+
const shown = rows.slice(0, LIMITS2.pre_edit.units);
|
|
13205
13589
|
const why = await reasons(db, shown.map((u) => u.id));
|
|
13206
13590
|
const ai = await aiDecided(db, shown.map((u) => u.id));
|
|
13207
|
-
const f = fitMarked(shown.map((u) => why.has(u.id) ? [line(u, why.get(u.id), ai.has(u.id)), line(u, "", ai.has(u.id))] : line(u, "", ai.has(u.id))),
|
|
13591
|
+
const f = fitMarked(shown.map((u) => why.has(u.id) ? [line(u, why.get(u.id), ai.has(u.id)), line(u, "", ai.has(u.id))] : line(u, "", ai.has(u.id))), LIMITS2.pre_edit.chars, `Active decisions applying to ${named(rels)} (current code relevance unverified). ${CONFIRM} ${NOTE}:`, ai, shown.map((u) => u.id));
|
|
13208
13592
|
const omitted = rows.length - shown.length + f.omitted;
|
|
13209
13593
|
return {
|
|
13210
13594
|
...noted(f.text, f.lead, [leftOut(omitted)]),
|
|
@@ -13219,10 +13603,33 @@ var agentOf = (input) => typeof input.agent_id === "string" && /^[\x21-\x7e]{1,2
|
|
|
13219
13603
|
var sameAgent = (agent) => (eb) => agent === null ? eb("d.agent_id", "is", null) : eb("d.agent_id", "=", agent);
|
|
13220
13604
|
var START_SOURCES = new Set(["startup", "resume", "clear", "compact", "fork"]);
|
|
13221
13605
|
var RESTARTS = ["compact", "clear"];
|
|
13222
|
-
async function
|
|
13606
|
+
async function sinceRestart(db, session, agent) {
|
|
13223
13607
|
const restart = await db.selectFrom("delivery as d").where("d.session_id", "=", session).where(sameAgent(agent)).where("d.event", "=", "session_start").where("d.reason", "in", RESTARTS).select((eb) => eb.fn.max("d.id").as("id")).executeTakeFirst();
|
|
13224
13608
|
const since = restart?.id ?? 0;
|
|
13225
13609
|
const sent = await db.selectFrom("delivery as d").innerJoin("delivery_unit as x", "x.delivery_id", "d.id").where("d.session_id", "=", session).where(sameAgent(agent)).where("d.id", ">", since).where("d.outcome", "=", "emitted").select(["x.unit_id", "d.event"]).execute();
|
|
13610
|
+
return { since, sent };
|
|
13611
|
+
}
|
|
13612
|
+
async function afterShellWrite(db, projectId2, rels, session, agent) {
|
|
13613
|
+
const { sent } = await sinceRestart(db, session, agent);
|
|
13614
|
+
const seen = new Set(sent.map((r) => r.unit_id));
|
|
13615
|
+
const ids = (await anchoredRules(db, projectId2, rels)).filter((id) => !seen.has(id));
|
|
13616
|
+
const top2 = ids.slice(0, LIMITS2.pre_edit.units);
|
|
13617
|
+
const shown = top2.length ? await db.selectFrom("unit as u").where("u.id", "in", top2).select(["u.id", "u.key", "u.kind", "u.stance", "u.text"]).orderBy("u.id", "desc").execute() : [];
|
|
13618
|
+
const why = await reasons(db, shown.map((u) => u.id));
|
|
13619
|
+
const ai = await aiDecided(db, shown.map((u) => u.id));
|
|
13620
|
+
const f = fitMarked(shown.map((u) => why.has(u.id) ? [line(u, why.get(u.id), ai.has(u.id)), line(u, "", ai.has(u.id))] : line(u, "", ai.has(u.id))), LIMITS2.pre_edit.chars - ASK + AFTER_CHANGE.length + 1, `Active decisions applying to ${named(rels)}, files whose content changed between before and after this call (current code relevance unverified). ${AFTER_CHANGE} ${NOTE}:`, ai, shown.map((u) => u.id));
|
|
13621
|
+
const omitted = ids.length - shown.length + f.omitted;
|
|
13622
|
+
return {
|
|
13623
|
+
...noted(f.text, f.lead, [leftOut(omitted)]),
|
|
13624
|
+
units: f.kept.flatMap((i) => shown[i]?.id ?? []),
|
|
13625
|
+
eligible: ids.length,
|
|
13626
|
+
omitted,
|
|
13627
|
+
path: head(rels.join(" "), 500),
|
|
13628
|
+
reason: SHELL_WRITE
|
|
13629
|
+
};
|
|
13630
|
+
}
|
|
13631
|
+
async function beforeRead(db, projectId2, rels, session, agent, how) {
|
|
13632
|
+
const { since, sent } = await sinceRestart(db, session, agent);
|
|
13226
13633
|
const spent = await db.selectFrom("delivery as d").where("d.session_id", "=", session).where(sameAgent(agent)).where("d.id", ">", since).where("d.event", "=", "pre_read").where("d.outcome", "=", "emitted").where(({ exists, selectFrom }) => exists(selectFrom("delivery_unit as x").select("x.unit_id").whereRef("x.delivery_id", "=", "d.id"))).select(["d.id", "d.at", "d.chars"]).execute();
|
|
13227
13634
|
const shownBy = spent.length ? await db.selectFrom("delivery_unit").select(["delivery_id", "unit_id"]).where("delivery_id", "in", spent.map((r) => r.id)).execute() : [];
|
|
13228
13635
|
const marked = new Map;
|
|
@@ -13235,11 +13642,11 @@ async function beforeRead(db, projectId2, rels, session, agent, how) {
|
|
|
13235
13642
|
const seen = new Set(sent.map((r) => r.unit_id));
|
|
13236
13643
|
const readUnits = sent.filter((r) => r.event === "pre_read").length;
|
|
13237
13644
|
const rows = (await anchoredTo(db, projectId2, rels).where("u.kind", "in", ["decision", "constraint"]).execute()).filter((u) => !seen.has(u.id));
|
|
13238
|
-
const room = Math.min(
|
|
13645
|
+
const room = Math.min(LIMITS2.pre_read.units, READ_SESSION.units - readUnits);
|
|
13239
13646
|
const shown = rows.slice(0, Math.max(room, 0));
|
|
13240
13647
|
const why = await reasons(db, shown.map((u) => u.id));
|
|
13241
13648
|
const ai = await aiDecided(db, shown.map((u) => u.id));
|
|
13242
|
-
const f = fitMarked(shown.map((u) => why.has(u.id) ? [line(u, why.get(u.id), ai.has(u.id)), line(u, "", ai.has(u.id))] : line(u, "", ai.has(u.id))), Math.min(
|
|
13649
|
+
const f = fitMarked(shown.map((u) => why.has(u.id) ? [line(u, why.get(u.id), ai.has(u.id)), line(u, "", ai.has(u.id))] : line(u, "", ai.has(u.id))), Math.min(LIMITS2.pre_read.chars, READ_SESSION.chars + ASK - spent.reduce((n, r) => {
|
|
13243
13650
|
const ai2 = marked.get(r.id) ?? 0;
|
|
13244
13651
|
return n + Math.max(r.chars - ASK - (ai2 ? AI_ROOM + ai2 * AI_MARK.length : 0), 0);
|
|
13245
13652
|
}, 0)), `Active decisions applying to ${named(rels)}, which ${how === "reading" ? "you are reading" : "this command names"} (current code relevance unverified). ${CONFIRM} ${NOTE}:`, ai, shown.map((u) => u.id));
|
|
@@ -13268,19 +13675,19 @@ function shellPatch(input) {
|
|
|
13268
13675
|
return typeof c === "string" && /^\s*\*\*\* Begin Patch\s*$/m.test(c) ? c : null;
|
|
13269
13676
|
}
|
|
13270
13677
|
async function namedInCommand(db, projectId2, root, cwd, command) {
|
|
13271
|
-
const paths = await
|
|
13678
|
+
const paths = (await deliverablePaths(db, projectId2)).map((p) => ({ path: p }));
|
|
13272
13679
|
const edge = `\\s'"=(){}<>|;&,`;
|
|
13273
13680
|
const esc = (t) => t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
|
|
13274
13681
|
const forms = (p) => {
|
|
13275
|
-
const abs =
|
|
13276
|
-
const fromCwd =
|
|
13682
|
+
const abs = path10.join(root, p);
|
|
13683
|
+
const fromCwd = path10.relative(cwd, abs);
|
|
13277
13684
|
const out = new Set;
|
|
13278
13685
|
for (const f of [p, abs, leaves(fromCwd) ? "" : fromCwd])
|
|
13279
13686
|
if (f)
|
|
13280
13687
|
for (const sep of ["/", "\\"]) {
|
|
13281
13688
|
const t = f.split(/[\\/]/).join(sep);
|
|
13282
13689
|
out.add(t);
|
|
13283
|
-
if (!
|
|
13690
|
+
if (!path10.isAbsolute(f))
|
|
13284
13691
|
out.add(`.${sep}${t}`);
|
|
13285
13692
|
}
|
|
13286
13693
|
return [...out];
|
|
@@ -13289,7 +13696,7 @@ async function namedInCommand(db, projectId2, root, cwd, command) {
|
|
|
13289
13696
|
}
|
|
13290
13697
|
function pathNamed(prompt, root, rel) {
|
|
13291
13698
|
const steps = (p) => p.split(/[\\/]/).map((s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("[\\\\/]");
|
|
13292
|
-
return new RegExp(`(?<![A-Za-z0-9_$.\\-/\\\\])(?:(?:\\.[\\\\/])?${steps(rel)}|${steps(
|
|
13699
|
+
return new RegExp(`(?<![A-Za-z0-9_$.\\-/\\\\])(?:(?:\\.[\\\\/])?${steps(rel)}|${steps(path10.join(root, rel))})(?![A-Za-z0-9_$\\-/\\\\]|\\.[A-Za-z0-9_$])`).test(prompt);
|
|
13293
13700
|
}
|
|
13294
13701
|
function once(f) {
|
|
13295
13702
|
const seen = new Map;
|
|
@@ -13299,32 +13706,37 @@ function once(f) {
|
|
|
13299
13706
|
return seen.get(k);
|
|
13300
13707
|
};
|
|
13301
13708
|
}
|
|
13302
|
-
async function
|
|
13303
|
-
const
|
|
13304
|
-
const lower =
|
|
13709
|
+
async function namedRecords(db, projectId2, root, prompt, asOf) {
|
|
13710
|
+
const text2 = prompt.normalize("NFKC");
|
|
13711
|
+
const lower = text2.toLowerCase();
|
|
13305
13712
|
const word = (w, s) => s.includes(w) && new RegExp(`(?<![\\p{L}\\p{N}_$])${w.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![\\p{L}\\p{N}_$])`, "u").test(s);
|
|
13306
|
-
const named2 = once((symbol) => symbol.length >= 3 && (/[^a-z]/.test(symbol) ? word(symbol,
|
|
13713
|
+
const named2 = once((symbol) => symbol.length >= 3 && (/[^a-z]/.test(symbol) ? word(symbol, text2) : text2.includes(`${symbol}(`) || text2.includes(`\`${symbol}\``)));
|
|
13307
13714
|
const slashed = prompt.replaceAll("\\", "/");
|
|
13308
13715
|
const pathIn = once((rel) => slashed.includes(rel) && pathNamed(prompt, root, rel));
|
|
13309
13716
|
const optionIn = once((option) => option.length >= 3 && word(option.normalize("NFKC").toLowerCase(), lower));
|
|
13310
|
-
const units = await deliverable(db, projectId2).select(["u.id", "u.key", "u.kind", "u.stance", "u.text"]).orderBy("u.kind").orderBy("u.id").execute();
|
|
13311
|
-
const ids = deliverable(db, projectId2).select("u.id");
|
|
13717
|
+
const units = await deliverable(db, projectId2, asOf).select(["u.id", "u.key", "u.kind", "u.stance", "u.text"]).orderBy("u.kind").orderBy("u.id").execute();
|
|
13718
|
+
const ids = deliverable(db, projectId2, asOf).select("u.id");
|
|
13312
13719
|
const [anchors, options] = await Promise.all([
|
|
13313
|
-
db.selectFrom("unit_anchor").select(["unit_id", "path", "symbol"]).where("unit_id", "in", ids).where("retired_at", "is", null).orderBy("id").execute().then(byUnit),
|
|
13720
|
+
db.selectFrom("unit_anchor").select(["unit_id", "path", "symbol"]).where("unit_id", "in", ids).$call((q) => asOf === undefined ? q.where("retired_at", "is", null) : q.where("added_at", "<=", asOf).where((eb) => eb.or([eb("retired_at", "is", null), eb("retired_at", ">", asOf)]))).orderBy("id").execute().then(byUnit),
|
|
13314
13721
|
db.selectFrom("unit_option").select(["unit_id", "text", "outcome"]).where("unit_id", "in", ids).orderBy("id").execute().then(byUnit)
|
|
13315
13722
|
]);
|
|
13316
13723
|
const hits = [];
|
|
13317
13724
|
for (const u of units) {
|
|
13318
13725
|
const a = anchors.get(u.id)?.find((x) => x.symbol && named2(x.symbol) || pathIn(x.path));
|
|
13319
13726
|
const o = options.get(u.id)?.find((x) => optionIn(x.text));
|
|
13727
|
+
const symbol = a?.symbol && named2(a.symbol) ? a.symbol : null;
|
|
13320
13728
|
if (a)
|
|
13321
|
-
hits.push({ u, why: ` [names ${
|
|
13729
|
+
hits.push({ u, why: ` [names ${symbol ?? a.path}]`, hit: symbol ? "symbol" : "path" });
|
|
13322
13730
|
else if (o)
|
|
13323
|
-
hits.push({ u, why: ` [names the ${o.outcome} option ${inline(o.text)}]
|
|
13731
|
+
hits.push({ u, why: ` [names the ${o.outcome} option ${inline(o.text)}]`, hit: "option" });
|
|
13324
13732
|
}
|
|
13325
|
-
|
|
13733
|
+
return hits;
|
|
13734
|
+
}
|
|
13735
|
+
async function onPrompt(db, projectId2, root, prompt) {
|
|
13736
|
+
const hits = await namedRecords(db, projectId2, root, prompt);
|
|
13737
|
+
const shown = hits.slice(0, LIMITS2.prompt.units);
|
|
13326
13738
|
const ai = await aiDecided(db, shown.map((h) => h.u.id));
|
|
13327
|
-
const wide = withAi(CONFIRM,
|
|
13739
|
+
const wide = withAi(CONFIRM, LIMITS2.prompt.chars, ai);
|
|
13328
13740
|
const lines = shown.map((h) => `${NOTE}: ${line(h.u, h.why, ai.has(h.u.id)).slice(2)}`);
|
|
13329
13741
|
const kept = [];
|
|
13330
13742
|
let used = wide.lead.length + 1;
|
|
@@ -13335,10 +13747,10 @@ async function onPrompt(db, projectId2, root, prompt) {
|
|
|
13335
13747
|
kept.push(l);
|
|
13336
13748
|
used += cost + 1;
|
|
13337
13749
|
}
|
|
13338
|
-
const
|
|
13750
|
+
const ask2 = shown.slice(0, kept.length).some((h) => ai.has(h.u.id)) ? wide.lead : CONFIRM;
|
|
13339
13751
|
return {
|
|
13340
|
-
...noted(kept.length ? [
|
|
13341
|
-
`) : "",
|
|
13752
|
+
...noted(kept.length ? [ask2, ...kept].join(`
|
|
13753
|
+
`) : "", ask2, [leftOut(hits.length - kept.length)]),
|
|
13342
13754
|
units: shown.slice(0, kept.length).map((h) => h.u.id),
|
|
13343
13755
|
eligible: hits.length,
|
|
13344
13756
|
omitted: hits.length - kept.length,
|
|
@@ -13346,6 +13758,40 @@ async function onPrompt(db, projectId2, root, prompt) {
|
|
|
13346
13758
|
reason: null
|
|
13347
13759
|
};
|
|
13348
13760
|
}
|
|
13761
|
+
var SHELL_WRITE = "shell_write";
|
|
13762
|
+
var SNAPSHOT_MS = 3500;
|
|
13763
|
+
var SHELL_WRITE_ON = new Set(["on", "1", "true", "yes"]);
|
|
13764
|
+
var TRIAL_CAP = 10 * 1024 * 1024;
|
|
13765
|
+
function shellWriteDelivery() {
|
|
13766
|
+
const env = (process.env.SPHICA_SHELL_WRITE_DELIVERY ?? "").trim().toLowerCase();
|
|
13767
|
+
if (AUTO_TRACE_OFF.has(env))
|
|
13768
|
+
return false;
|
|
13769
|
+
if (SHELL_WRITE_ON.has(env))
|
|
13770
|
+
return true;
|
|
13771
|
+
return SHELL_WRITE_ON.has((process.env.CLAUDE_PLUGIN_OPTION_SHELL_WRITE_DELIVERY ?? "").trim().toLowerCase());
|
|
13772
|
+
}
|
|
13773
|
+
function trialLog(line2) {
|
|
13774
|
+
try {
|
|
13775
|
+
const file = path10.join(sphicaHome(), "shell-state", "trial.jsonl");
|
|
13776
|
+
fs9.mkdirSync(path10.dirname(file), { recursive: true });
|
|
13777
|
+
if ((fs9.statSync(file, { throwIfNoEntry: false })?.size ?? 0) >= TRIAL_CAP)
|
|
13778
|
+
rotateTrial(path10.dirname(file), file);
|
|
13779
|
+
fs9.appendFileSync(file, `${JSON.stringify({ at: iso(Date.now()), ...line2 })}
|
|
13780
|
+
`);
|
|
13781
|
+
} catch {}
|
|
13782
|
+
}
|
|
13783
|
+
function rotateTrial(dir2, file) {
|
|
13784
|
+
try {
|
|
13785
|
+
fs9.renameSync(file, path10.join(dir2, `trial.${Date.now()}.${process.pid}.jsonl`));
|
|
13786
|
+
const archives = fs9.readdirSync(dir2).filter((n) => /^trial\.\d+\.\d+\.jsonl$/.test(n)).sort((a, b) => Number(b.split(".")[1]) - Number(a.split(".")[1]));
|
|
13787
|
+
let kept = 0;
|
|
13788
|
+
for (const n of archives) {
|
|
13789
|
+
kept += fs9.statSync(path10.join(dir2, n), { throwIfNoEntry: false })?.size ?? 0;
|
|
13790
|
+
if (kept > 2 * TRIAL_CAP)
|
|
13791
|
+
fs9.rmSync(path10.join(dir2, n), { force: true });
|
|
13792
|
+
}
|
|
13793
|
+
} catch {}
|
|
13794
|
+
}
|
|
13349
13795
|
var AUTO_TRACE_OFF = new Set(["off", "0", "false", "no"]);
|
|
13350
13796
|
var AUTO_TRACE = (n) => `- ${n} earlier session${n === 1 ? "" : "s"} of this project ${n === 1 ? "waits" : "wait"} to be traced. After the user's request is done, run the trace Skill on your own for the oldest (at most 2), as its "On your own" section says, without asking the user.`;
|
|
13351
13797
|
async function waiting(db, projectId2, place) {
|
|
@@ -13358,7 +13804,7 @@ async function waiting(db, projectId2, place) {
|
|
|
13358
13804
|
});
|
|
13359
13805
|
if (!total)
|
|
13360
13806
|
return "";
|
|
13361
|
-
if (!markOnce("auto-trace", `${
|
|
13807
|
+
if (!markOnce("auto-trace", `${path10.resolve(place.file)}\x00${place.key}\x00${place.host}\x00${place.auto}`))
|
|
13362
13808
|
return "";
|
|
13363
13809
|
return AUTO_TRACE(total);
|
|
13364
13810
|
}
|
|
@@ -13366,7 +13812,7 @@ async function waiting(db, projectId2, place) {
|
|
|
13366
13812
|
if (!n)
|
|
13367
13813
|
return "";
|
|
13368
13814
|
const day = new Date().toLocaleDateString("sv-SE");
|
|
13369
|
-
if (!markOnce("pending", `${
|
|
13815
|
+
if (!markOnce("pending", `${path10.resolve(place.file)}\x00${place.key}\x00${day}`))
|
|
13370
13816
|
return "";
|
|
13371
13817
|
const trace = place.host === "codex" ? "$sphica:trace" : "/sphica:trace";
|
|
13372
13818
|
return `- ${n} session${n === 1 ? "" : "s"} waiting to be traced: run ${trace} pending.`;
|
|
@@ -13388,7 +13834,7 @@ async function atStart(db, projectId2, branch, place) {
|
|
|
13388
13834
|
}),
|
|
13389
13835
|
...broad.map((u) => line(u, "", ai.has(u.id)))
|
|
13390
13836
|
];
|
|
13391
|
-
const f = fitMarked(lines,
|
|
13837
|
+
const f = fitMarked(lines, LIMITS2.session_start.chars, `Sphica: this project's current work and standing constraints. ${CONFIRM} ${NOTE}:`, ai, [...work.map(() => null), ...broad.map((u) => u.id)]);
|
|
13392
13838
|
const shownUnits = f.kept.flatMap((i) => i >= work.length ? broad[i - work.length]?.id ?? [] : []);
|
|
13393
13839
|
const workLeft = Math.max((workTotal ?? 0) - f.kept.filter((i) => i < work.length).length, 0);
|
|
13394
13840
|
const broadLeft = Math.max((broadTotal ?? 0) - shownUnits.length, 0);
|
|
@@ -13407,9 +13853,9 @@ async function atStart(db, projectId2, branch, place) {
|
|
|
13407
13853
|
};
|
|
13408
13854
|
}
|
|
13409
13855
|
async function beforeReview(db, projectId2, root, call) {
|
|
13410
|
-
const change = localChange(root, call.args);
|
|
13411
|
-
const said = (
|
|
13412
|
-
text,
|
|
13856
|
+
const change = await localChange(root, call.args);
|
|
13857
|
+
const said = (text2, why) => ({
|
|
13858
|
+
text: text2,
|
|
13413
13859
|
note: "",
|
|
13414
13860
|
units: [],
|
|
13415
13861
|
eligible: 0,
|
|
@@ -13429,9 +13875,9 @@ async function beforeReview(db, projectId2, root, call) {
|
|
|
13429
13875
|
const checked = `checked ${n} changed path${n === 1 ? "" : "s"} against ${base}`;
|
|
13430
13876
|
if (!rows.length)
|
|
13431
13877
|
return { ...said(`Sphica ${checked}: no active recorded decision applies.`, null), once: once2 };
|
|
13432
|
-
const shown = rows.slice(0,
|
|
13878
|
+
const shown = rows.slice(0, LIMITS2.review.units);
|
|
13433
13879
|
const ai = await aiDecided(db, shown.map((u) => u.id));
|
|
13434
|
-
const f = fitMarked(shown.map((u) => line(u, ` [${inline(u.because)}]`, ai.has(u.id))),
|
|
13880
|
+
const f = fitMarked(shown.map((u) => line(u, ` [${inline(u.because)}]`, ai.has(u.id))), LIMITS2.review.chars, `Sphica: past decisions that apply to this change (${checked}). ${NOTE}; compare the change against each:`, ai, shown.map((u) => u.id));
|
|
13435
13881
|
const omitted = rows.length - shown.length + f.omitted;
|
|
13436
13882
|
return {
|
|
13437
13883
|
...noted(f.text, f.lead, [leftOut(omitted)]),
|
|
@@ -13449,15 +13895,15 @@ function toldBefore(session, key) {
|
|
|
13449
13895
|
function markOnce(kind, key) {
|
|
13450
13896
|
const user = (() => {
|
|
13451
13897
|
try {
|
|
13452
|
-
return
|
|
13898
|
+
return os3.userInfo().username;
|
|
13453
13899
|
} catch {
|
|
13454
13900
|
return String(process.getuid?.() ?? "user");
|
|
13455
13901
|
}
|
|
13456
13902
|
})();
|
|
13457
|
-
const
|
|
13903
|
+
const dir2 = path10.join(os3.tmpdir(), `sphica-${sha256(user).toString("hex").slice(0, 12)}`, kind);
|
|
13458
13904
|
try {
|
|
13459
|
-
|
|
13460
|
-
|
|
13905
|
+
fs9.mkdirSync(dir2, { recursive: true, mode: 448 });
|
|
13906
|
+
fs9.writeFileSync(path10.join(dir2, sha256(key).toString("hex").slice(0, 24)), "", { flag: "wx" });
|
|
13461
13907
|
return true;
|
|
13462
13908
|
} catch (e) {
|
|
13463
13909
|
return e.code !== "EEXIST";
|
|
@@ -13501,27 +13947,103 @@ async function log(file, e, plan) {
|
|
|
13501
13947
|
await cap.destroy().catch(() => {});
|
|
13502
13948
|
}
|
|
13503
13949
|
}
|
|
13504
|
-
async function lockedPlan(file, e, make, keep) {
|
|
13950
|
+
async function lockedPlan(file, e, make, keep, logged = () => {}) {
|
|
13505
13951
|
const cap = openWriter("capture", file, LOG_WAIT_MS);
|
|
13506
13952
|
let held = false;
|
|
13953
|
+
let wrote = false;
|
|
13507
13954
|
let plan = null;
|
|
13508
13955
|
try {
|
|
13509
13956
|
await inTransaction(cap, async (trx) => {
|
|
13510
13957
|
held = true;
|
|
13511
13958
|
plan = await make();
|
|
13512
|
-
if (keep(plan))
|
|
13959
|
+
if (keep(plan)) {
|
|
13513
13960
|
await write2(trx, e, plan);
|
|
13961
|
+
wrote = true;
|
|
13962
|
+
}
|
|
13514
13963
|
});
|
|
13515
13964
|
} catch (err) {
|
|
13965
|
+
wrote = false;
|
|
13516
13966
|
if (held && !plan)
|
|
13517
13967
|
throw err;
|
|
13518
13968
|
} finally {
|
|
13519
13969
|
await cap.destroy().catch(() => {});
|
|
13520
13970
|
}
|
|
13971
|
+
logged(wrote);
|
|
13521
13972
|
return plan ?? make();
|
|
13522
13973
|
}
|
|
13974
|
+
async function snapshotCall(db, projectId2, place, host, input, started) {
|
|
13975
|
+
const paths = await deliverablePaths(db, projectId2);
|
|
13976
|
+
const cache = loadCache(place.root);
|
|
13977
|
+
const states = takeStates(place.root, paths, cache, started + SNAPSHOT_MS);
|
|
13978
|
+
saveCache(place.root, cache, paths);
|
|
13979
|
+
const expired = pruneSnapshots(Date.now(), started + SNAPSHOT_MS);
|
|
13980
|
+
if (expired)
|
|
13981
|
+
trialLog({ host, event: "snapshot_expired", count: expired });
|
|
13982
|
+
const key = snapshotKey(host, String(input.session_id), agentOf(input), String(input.tool_use_id));
|
|
13983
|
+
writeSnapshot({ v: 1, key, at: iso(started), root: place.root, project: place.key, paths: states });
|
|
13984
|
+
}
|
|
13985
|
+
async function afterShell(input, host, file, started) {
|
|
13986
|
+
if (!shellWriteDelivery() || !input.session_id || !input.tool_use_id)
|
|
13987
|
+
return "";
|
|
13988
|
+
const agent = agentOf(input);
|
|
13989
|
+
const base = { host, session: input.session_id, agent, call: input.tool_use_id };
|
|
13990
|
+
let line2 = { ...base, event: "post_shell" };
|
|
13991
|
+
let db = null;
|
|
13992
|
+
try {
|
|
13993
|
+
const before = takeSnapshot(snapshotKey(host, input.session_id, agent, input.tool_use_id));
|
|
13994
|
+
if (before === "expired" || !before) {
|
|
13995
|
+
if (!before && !identify(input.cwd ?? process.cwd()))
|
|
13996
|
+
return "";
|
|
13997
|
+
trialLog({ ...base, event: before ? "snapshot_expired" : "snapshot_missing" });
|
|
13998
|
+
return "";
|
|
13999
|
+
}
|
|
14000
|
+
const cache = loadCache(before.root);
|
|
14001
|
+
for (const [rel, st] of Object.entries(before.paths))
|
|
14002
|
+
if (st.kind === "ok")
|
|
14003
|
+
cache.set(rel, { sig: st.sig, hash: st.hash });
|
|
14004
|
+
const after = takeStates(before.root, Object.keys(before.paths), cache, started + SNAPSHOT_MS);
|
|
14005
|
+
saveCache(before.root, cache, Object.keys(before.paths));
|
|
14006
|
+
const { changed: changed2, unknown } = compare(before.paths, after);
|
|
14007
|
+
line2 = { ...line2, paths: Object.keys(before.paths).length, changed: changed2, unknown };
|
|
14008
|
+
if (!changed2.length) {
|
|
14009
|
+
trialLog({ ...line2, delivered: [] });
|
|
14010
|
+
return "";
|
|
14011
|
+
}
|
|
14012
|
+
if (!fs9.existsSync(file))
|
|
14013
|
+
throw new Error(`no database at ${file}`);
|
|
14014
|
+
db = openReader(file);
|
|
14015
|
+
const pid = await projectId(db, before.project);
|
|
14016
|
+
if (pid === null)
|
|
14017
|
+
throw new Error("the project is not registered");
|
|
14018
|
+
const reader = db;
|
|
14019
|
+
const entry = {
|
|
14020
|
+
projectId: pid,
|
|
14021
|
+
host,
|
|
14022
|
+
external: input.session_id,
|
|
14023
|
+
agent,
|
|
14024
|
+
event: "pre_edit",
|
|
14025
|
+
branch: branchOf(before.root)
|
|
14026
|
+
};
|
|
14027
|
+
let logged = false;
|
|
14028
|
+
const plan = await lockedPlan(file, entry, () => afterShellWrite(reader, pid, changed2, sessionId(pid, host, input.session_id), agent), (p) => Boolean(p.text), (w) => {
|
|
14029
|
+
logged = w;
|
|
14030
|
+
});
|
|
14031
|
+
const keys = plan.units.length ? (await reader.selectFrom("unit").select("key").where("id", "in", plan.units).execute()).map((u) => u.key) : [];
|
|
14032
|
+
trialLog({ ...line2, delivered: keys, logged: plan.text ? logged : null });
|
|
14033
|
+
return plan.text;
|
|
14034
|
+
} catch (e) {
|
|
14035
|
+
trialLog({ ...line2, delivered: [], error: head(reason(e), 200) });
|
|
14036
|
+
return "";
|
|
14037
|
+
} finally {
|
|
14038
|
+
await db?.destroy().catch(() => {});
|
|
14039
|
+
}
|
|
14040
|
+
}
|
|
13523
14041
|
async function deliver(input, host = "claude-code", file = dbFile()) {
|
|
14042
|
+
const started = Date.now();
|
|
13524
14043
|
const name = input.hook_event_name;
|
|
14044
|
+
if ((name === "PostToolUse" || name === "PostToolUseFailure") && SHELL_TOOLS.has(input.tool_name ?? ""))
|
|
14045
|
+
return afterShell(input, host, file, started);
|
|
14046
|
+
const snap = name === "PreToolUse" && SHELL_TOOLS.has(input.tool_name ?? "") && Boolean(input.tool_use_id) && shellWriteDelivery();
|
|
13525
14047
|
const call = reviewCall(input);
|
|
13526
14048
|
const event = call ? "review" : name === "SessionStart" || name === "SubagentStart" ? "session_start" : name === "UserPromptSubmit" ? "prompt" : name === "PreToolUse" ? input.tool_name === "Read" || SHELL_TOOLS.has(input.tool_name ?? "") && !(host === "codex" && shellPatch(input)) ? "pre_read" : "pre_edit" : null;
|
|
13527
14049
|
if (!event || !input.session_id)
|
|
@@ -13535,22 +14057,33 @@ async function deliver(input, host = "claude-code", file = dbFile()) {
|
|
|
13535
14057
|
const shell = SHELL_TOOLS.has(input.tool_name ?? "") && !patch && typeof ti.command === "string" ? ti.command : null;
|
|
13536
14058
|
const targets = patch ? patchPaths2(patch) : [ti.file_path, ti.notebook_path].filter((p) => typeof p === "string").slice(0, 1);
|
|
13537
14059
|
const onPath = event === "pre_edit" || event === "pre_read";
|
|
13538
|
-
if (onPath && !shell && (!(event === "pre_read" || patch || EDIT_TOOLS.has(input.tool_name ?? "")) || !targets.length))
|
|
14060
|
+
if (onPath && !shell && !snap && (!(event === "pre_read" || patch || EDIT_TOOLS.has(input.tool_name ?? "")) || !targets.length))
|
|
13539
14061
|
return "";
|
|
13540
14062
|
const place = identify(input.cwd ?? process.cwd());
|
|
13541
14063
|
if (!place)
|
|
13542
14064
|
return "";
|
|
13543
|
-
let rels = targets.map((t) =>
|
|
13544
|
-
if (onPath && !shell && !rels.length)
|
|
14065
|
+
let rels = targets.map((t) => path10.relative(place.root, path10.resolve(input.cwd ?? place.root, t))).filter((r) => r && !leaves(r)).map((r) => r.split(path10.sep).join("/"));
|
|
14066
|
+
if (onPath && !shell && !snap && !rels.length)
|
|
13545
14067
|
return "";
|
|
13546
14068
|
let db = null;
|
|
13547
14069
|
try {
|
|
13548
|
-
if (!
|
|
14070
|
+
if (!fs9.existsSync(file))
|
|
13549
14071
|
throw new Error(`no database at ${file}`);
|
|
13550
14072
|
db = openReader(file);
|
|
13551
14073
|
const pid = await projectId(db, place.key);
|
|
13552
14074
|
if (pid === null)
|
|
13553
14075
|
return "";
|
|
14076
|
+
if (snap)
|
|
14077
|
+
await snapshotCall(db, pid, place, host, input, started).catch((e) => trialLog({
|
|
14078
|
+
host,
|
|
14079
|
+
session: input.session_id,
|
|
14080
|
+
agent: agentOf(input),
|
|
14081
|
+
call: input.tool_use_id,
|
|
14082
|
+
event: "snapshot_failed",
|
|
14083
|
+
error: head(reason(e), 200)
|
|
14084
|
+
}));
|
|
14085
|
+
if (onPath && !shell && !rels.length)
|
|
14086
|
+
return "";
|
|
13554
14087
|
if (shell) {
|
|
13555
14088
|
rels = await namedInCommand(db, pid, place.root, input.cwd ?? place.root, shell);
|
|
13556
14089
|
if (!rels.length)
|
|
@@ -13617,7 +14150,11 @@ export {
|
|
|
13617
14150
|
AUTO_TRACE,
|
|
13618
14151
|
CONFIRM,
|
|
13619
14152
|
CONFIRM_GOLD,
|
|
14153
|
+
anchoredRules,
|
|
13620
14154
|
deliver,
|
|
14155
|
+
deliverableIds,
|
|
14156
|
+
deliverablePaths,
|
|
13621
14157
|
leadFor,
|
|
14158
|
+
namedRecords,
|
|
13622
14159
|
recordLines
|
|
13623
14160
|
};
|