@honcho-ai/claude-honcho 0.3.1 → 0.3.3
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 +1 -1
- package/README.md +95 -12
- package/dist/hooks/post-tool-use.js +16714 -29
- package/dist/hooks/post-tool-use.js.map +91 -5
- package/dist/hooks/pre-compact.js +16909 -39
- package/dist/hooks/pre-compact.js.map +92 -6
- package/dist/hooks/pre-tool-honcho.js +829 -10
- package/dist/hooks/pre-tool-honcho.js.map +10 -5
- package/dist/hooks/save-user-message.js +16552 -32
- package/dist/hooks/save-user-message.js.map +90 -5
- package/dist/hooks/session-end.js +1003 -20
- package/dist/hooks/session-end.js.map +12 -5
- package/dist/hooks/session-start.js +16961 -51
- package/dist/hooks/session-start.js.map +93 -5
- package/dist/hooks/stop.js +16681 -33
- package/dist/hooks/stop.js.map +90 -5
- package/dist/hooks/user-prompt.js +17004 -14
- package/dist/hooks/user-prompt.js.map +93 -4
- package/dist/mcp-server.js +17097 -907
- package/dist/mcp-server.js.map +88 -4
- package/dist/skills/backfill-runner.js +16309 -69
- package/dist/skills/backfill-runner.js.map +89 -4
- package/dist/skills/setup-runner.js +16185 -60
- package/dist/skills/setup-runner.js.map +88 -5
- package/dist/skills/status-runner.js +16184 -21
- package/dist/skills/status-runner.js.map +88 -4
- package/package.json +1 -1
- package/dist/chunk-084dpgp3.js +0 -556
- package/dist/chunk-084dpgp3.js.map +0 -10
- package/dist/chunk-49wja30f.js +0 -20
- package/dist/chunk-49wja30f.js.map +0 -10
- package/dist/chunk-4ryv9310.js +0 -15534
- package/dist/chunk-4ryv9310.js.map +0 -87
- package/dist/chunk-4zgbdwm4.js +0 -261
- package/dist/chunk-4zgbdwm4.js.map +0 -10
- package/dist/chunk-6yybt92z.js +0 -106
- package/dist/chunk-6yybt92z.js.map +0 -9
- package/dist/chunk-9pntsn3x.js +0 -35
- package/dist/chunk-9pntsn3x.js.map +0 -10
- package/dist/chunk-d2gc13m0.js +0 -161
- package/dist/chunk-d2gc13m0.js.map +0 -11
- package/dist/chunk-dxbm7kmf.js +0 -331
- package/dist/chunk-dxbm7kmf.js.map +0 -10
- package/dist/chunk-gnp95nzg.js +0 -438
- package/dist/chunk-gnp95nzg.js.map +0 -12
- package/dist/chunk-jgtvcc65.js +0 -90
- package/dist/chunk-jgtvcc65.js.map +0 -10
- package/dist/chunk-jr0fd6n2.js +0 -181
- package/dist/chunk-jr0fd6n2.js.map +0 -11
- package/dist/chunk-wm6hvkcv.js +0 -245
- package/dist/chunk-wm6hvkcv.js.map +0 -10
- package/dist/chunk-xdntcesh.js +0 -15450
- package/dist/chunk-xdntcesh.js.map +0 -86
- package/dist/chunk-xtdvbfxw.js +0 -146
- package/dist/chunk-xtdvbfxw.js.map +0 -10
- package/dist/chunk-yfrrc1d5.js +0 -838
- package/dist/chunk-yfrrc1d5.js.map +0 -12
|
@@ -1,11 +1,827 @@
|
|
|
1
1
|
#!/usr/bin/env bun
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
} from "
|
|
5
|
-
import {
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
2
|
+
|
|
3
|
+
// src/config.ts
|
|
4
|
+
import { homedir as homedir2 } from "os";
|
|
5
|
+
import { join as join3, basename, dirname, resolve, sep } from "path";
|
|
6
|
+
import { fileURLToPath } from "url";
|
|
7
|
+
import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, statSync, writeFileSync as writeFileSync2 } from "fs";
|
|
8
|
+
|
|
9
|
+
// src/git.ts
|
|
10
|
+
import { execSync } from "child_process";
|
|
11
|
+
import { existsSync } from "fs";
|
|
12
|
+
import { join } from "path";
|
|
13
|
+
function isGitRepo(cwd) {
|
|
14
|
+
return existsSync(join(cwd, ".git"));
|
|
15
|
+
}
|
|
16
|
+
function gitCommand(cwd, args) {
|
|
17
|
+
try {
|
|
18
|
+
return execSync(`git ${args}`, { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
|
|
19
|
+
} catch {
|
|
20
|
+
return null;
|
|
21
|
+
}
|
|
22
|
+
}
|
|
23
|
+
function captureGitState(cwd) {
|
|
24
|
+
if (!isGitRepo(cwd)) {
|
|
25
|
+
return null;
|
|
26
|
+
}
|
|
27
|
+
const branch = gitCommand(cwd, "rev-parse --abbrev-ref HEAD") || "unknown";
|
|
28
|
+
const commit = gitCommand(cwd, "rev-parse --short HEAD") || "unknown";
|
|
29
|
+
const commitMessage = gitCommand(cwd, "log -1 --format=%s") || "";
|
|
30
|
+
const statusOutput = gitCommand(cwd, "status --porcelain") || "";
|
|
31
|
+
const isDirty = statusOutput.length > 0;
|
|
32
|
+
const dirtyFiles = isDirty ? statusOutput.split(`
|
|
33
|
+
`).filter((line) => line.trim()).map((line) => line.slice(3).trim()).slice(0, 20) : [];
|
|
34
|
+
return {
|
|
35
|
+
branch,
|
|
36
|
+
commit,
|
|
37
|
+
commitMessage,
|
|
38
|
+
isDirty,
|
|
39
|
+
dirtyFiles,
|
|
40
|
+
timestamp: new Date().toISOString()
|
|
41
|
+
};
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
// src/cache.ts
|
|
45
|
+
import { homedir } from "os";
|
|
46
|
+
import { join as join2 } from "path";
|
|
47
|
+
import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync } from "fs";
|
|
48
|
+
var CACHE_DIR = join2(homedir(), ".honcho");
|
|
49
|
+
var ID_CACHE_FILE = join2(CACHE_DIR, "cache.json");
|
|
50
|
+
var CONTEXT_CACHE_FILE = join2(CACHE_DIR, "context-cache.json");
|
|
51
|
+
function ensureCacheDir() {
|
|
52
|
+
if (!existsSync2(CACHE_DIR)) {
|
|
53
|
+
mkdirSync(CACHE_DIR, { recursive: true });
|
|
54
|
+
}
|
|
55
|
+
}
|
|
56
|
+
function loadIdCache() {
|
|
57
|
+
ensureCacheDir();
|
|
58
|
+
if (!existsSync2(ID_CACHE_FILE)) {
|
|
59
|
+
return {};
|
|
60
|
+
}
|
|
61
|
+
try {
|
|
62
|
+
return JSON.parse(readFileSync(ID_CACHE_FILE, "utf-8"));
|
|
63
|
+
} catch {
|
|
64
|
+
return {};
|
|
65
|
+
}
|
|
66
|
+
}
|
|
67
|
+
function saveIdCache(cache) {
|
|
68
|
+
ensureCacheDir();
|
|
69
|
+
writeFileSync(ID_CACHE_FILE, JSON.stringify(cache, null, 2));
|
|
70
|
+
}
|
|
71
|
+
function setCachedSessionId(cwd, name, id, instanceId) {
|
|
72
|
+
const cache = loadIdCache();
|
|
73
|
+
if (!cache.sessions)
|
|
74
|
+
cache.sessions = {};
|
|
75
|
+
cache.sessions[cwd] = { name, id, updatedAt: new Date().toISOString(), instanceId };
|
|
76
|
+
saveIdCache(cache);
|
|
77
|
+
}
|
|
78
|
+
function getLastActiveCwd() {
|
|
79
|
+
const cache = loadIdCache();
|
|
80
|
+
if (!cache.sessions)
|
|
81
|
+
return null;
|
|
82
|
+
let latest = null;
|
|
83
|
+
for (const [cwd, entry] of Object.entries(cache.sessions)) {
|
|
84
|
+
if (!latest || entry.updatedAt > latest.updatedAt) {
|
|
85
|
+
latest = { cwd, updatedAt: entry.updatedAt };
|
|
86
|
+
}
|
|
87
|
+
}
|
|
88
|
+
return latest?.cwd || null;
|
|
89
|
+
}
|
|
90
|
+
function getClaudeInstanceId() {
|
|
91
|
+
const cache = loadIdCache();
|
|
92
|
+
return cache.claudeInstanceId || null;
|
|
93
|
+
}
|
|
94
|
+
function setClaudeInstanceId(instanceId) {
|
|
95
|
+
const cache = loadIdCache();
|
|
96
|
+
cache.claudeInstanceId = instanceId;
|
|
97
|
+
saveIdCache(cache);
|
|
98
|
+
}
|
|
99
|
+
function getInstanceIdForCwd(cwd) {
|
|
100
|
+
const cache = loadIdCache();
|
|
101
|
+
return cache.sessions?.[cwd]?.instanceId ?? null;
|
|
102
|
+
}
|
|
103
|
+
var CONTEXT_CACHE_KNOWN_KEYS = new Set([
|
|
104
|
+
"claudeContext",
|
|
105
|
+
"summaries",
|
|
106
|
+
"messageCount"
|
|
107
|
+
]);
|
|
108
|
+
function loadContextCache() {
|
|
109
|
+
ensureCacheDir();
|
|
110
|
+
if (!existsSync2(CONTEXT_CACHE_FILE)) {
|
|
111
|
+
return {};
|
|
112
|
+
}
|
|
113
|
+
try {
|
|
114
|
+
const raw = JSON.parse(readFileSync(CONTEXT_CACHE_FILE, "utf-8"));
|
|
115
|
+
let cleaned = false;
|
|
116
|
+
for (const key of Object.keys(raw)) {
|
|
117
|
+
if (!CONTEXT_CACHE_KNOWN_KEYS.has(key)) {
|
|
118
|
+
delete raw[key];
|
|
119
|
+
cleaned = true;
|
|
120
|
+
}
|
|
121
|
+
}
|
|
122
|
+
if (cleaned) {
|
|
123
|
+
writeFileSync(CONTEXT_CACHE_FILE, JSON.stringify(raw, null, 2));
|
|
124
|
+
}
|
|
125
|
+
return raw;
|
|
126
|
+
} catch {
|
|
127
|
+
return {};
|
|
128
|
+
}
|
|
129
|
+
}
|
|
130
|
+
function saveContextCache(cache) {
|
|
131
|
+
ensureCacheDir();
|
|
132
|
+
writeFileSync(CONTEXT_CACHE_FILE, JSON.stringify(cache, null, 2));
|
|
133
|
+
}
|
|
134
|
+
function incrementMessageCount() {
|
|
135
|
+
const cache = loadContextCache();
|
|
136
|
+
cache.messageCount = (cache.messageCount || 0) + 1;
|
|
137
|
+
saveContextCache(cache);
|
|
138
|
+
return cache.messageCount;
|
|
139
|
+
}
|
|
140
|
+
function getMessageCount() {
|
|
141
|
+
const cache = loadContextCache();
|
|
142
|
+
return cache.messageCount || 0;
|
|
143
|
+
}
|
|
144
|
+
function resetMessageCount() {
|
|
145
|
+
const cache = loadContextCache();
|
|
146
|
+
cache.messageCount = 0;
|
|
147
|
+
saveContextCache(cache);
|
|
148
|
+
}
|
|
149
|
+
var GIT_STATE_FILE = join2(CACHE_DIR, "git-state.json");
|
|
150
|
+
function loadGitStateCache() {
|
|
151
|
+
ensureCacheDir();
|
|
152
|
+
if (!existsSync2(GIT_STATE_FILE)) {
|
|
153
|
+
return {};
|
|
154
|
+
}
|
|
155
|
+
try {
|
|
156
|
+
return JSON.parse(readFileSync(GIT_STATE_FILE, "utf-8"));
|
|
157
|
+
} catch {
|
|
158
|
+
return {};
|
|
159
|
+
}
|
|
160
|
+
}
|
|
161
|
+
function saveGitStateCache(cache) {
|
|
162
|
+
ensureCacheDir();
|
|
163
|
+
writeFileSync(GIT_STATE_FILE, JSON.stringify(cache, null, 2));
|
|
164
|
+
}
|
|
165
|
+
function getCachedGitState(cwd) {
|
|
166
|
+
const cache = loadGitStateCache();
|
|
167
|
+
return cache[cwd] || null;
|
|
168
|
+
}
|
|
169
|
+
function setCachedGitState(cwd, state) {
|
|
170
|
+
const cache = loadGitStateCache();
|
|
171
|
+
cache[cwd] = state;
|
|
172
|
+
saveGitStateCache(cache);
|
|
173
|
+
}
|
|
174
|
+
function detectGitChanges(previous, current) {
|
|
175
|
+
const changes = [];
|
|
176
|
+
if (!previous) {
|
|
177
|
+
changes.push({
|
|
178
|
+
type: "initial",
|
|
179
|
+
description: `Session started on branch '${current.branch}' at ${current.commit}`
|
|
180
|
+
});
|
|
181
|
+
return changes;
|
|
182
|
+
}
|
|
183
|
+
if (previous.branch !== current.branch) {
|
|
184
|
+
changes.push({
|
|
185
|
+
type: "branch_switch",
|
|
186
|
+
description: `Branch switched from '${previous.branch}' to '${current.branch}'`,
|
|
187
|
+
from: previous.branch,
|
|
188
|
+
to: current.branch
|
|
189
|
+
});
|
|
190
|
+
}
|
|
191
|
+
if (previous.commit !== current.commit) {
|
|
192
|
+
changes.push({
|
|
193
|
+
type: "new_commits",
|
|
194
|
+
description: `New commit: ${current.commit} - ${current.commitMessage}`,
|
|
195
|
+
from: previous.commit,
|
|
196
|
+
to: current.commit
|
|
197
|
+
});
|
|
198
|
+
}
|
|
199
|
+
if (!previous.isDirty && current.isDirty) {
|
|
200
|
+
changes.push({
|
|
201
|
+
type: "files_changed",
|
|
202
|
+
description: `Uncommitted changes detected: ${current.dirtyFiles.slice(0, 5).join(", ")}${current.dirtyFiles.length > 5 ? "..." : ""}`
|
|
203
|
+
});
|
|
204
|
+
}
|
|
205
|
+
return changes;
|
|
206
|
+
}
|
|
207
|
+
var MAX_MESSAGE_SIZE = 24000;
|
|
208
|
+
function chunkContent(content, maxSize = MAX_MESSAGE_SIZE) {
|
|
209
|
+
if (content.length <= maxSize) {
|
|
210
|
+
return [content];
|
|
211
|
+
}
|
|
212
|
+
const chunks = [];
|
|
213
|
+
let remaining = content;
|
|
214
|
+
while (remaining.length > 0) {
|
|
215
|
+
if (remaining.length <= maxSize) {
|
|
216
|
+
chunks.push(remaining);
|
|
217
|
+
break;
|
|
218
|
+
}
|
|
219
|
+
let splitIndex = remaining.lastIndexOf(`
|
|
220
|
+
`, maxSize);
|
|
221
|
+
if (splitIndex <= 0 || splitIndex < maxSize * 0.25) {
|
|
222
|
+
splitIndex = remaining.lastIndexOf(" ", maxSize);
|
|
223
|
+
}
|
|
224
|
+
if (splitIndex <= 0 || splitIndex < maxSize * 0.25) {
|
|
225
|
+
splitIndex = maxSize;
|
|
226
|
+
}
|
|
227
|
+
chunks.push(remaining.slice(0, splitIndex));
|
|
228
|
+
remaining = remaining.slice(splitIndex).trimStart();
|
|
229
|
+
}
|
|
230
|
+
if (chunks.length > 1) {
|
|
231
|
+
return chunks.map((chunk, i) => `[Part ${i + 1}/${chunks.length}] ${chunk}`);
|
|
232
|
+
}
|
|
233
|
+
return chunks;
|
|
234
|
+
}
|
|
235
|
+
var HONCHO_MAX_BATCH = 100;
|
|
236
|
+
async function addMessagesBatched(session, messages, resolveFallback) {
|
|
237
|
+
let active = session;
|
|
238
|
+
let usedFallback = false;
|
|
239
|
+
for (let i = 0;i < messages.length; i += HONCHO_MAX_BATCH) {
|
|
240
|
+
const batch = messages.slice(i, i + HONCHO_MAX_BATCH);
|
|
241
|
+
try {
|
|
242
|
+
await active.addMessages(batch);
|
|
243
|
+
} catch (e) {
|
|
244
|
+
if (usedFallback || !resolveFallback)
|
|
245
|
+
throw e;
|
|
246
|
+
active = await resolveFallback(e);
|
|
247
|
+
usedFallback = true;
|
|
248
|
+
await active.addMessages(batch);
|
|
249
|
+
}
|
|
250
|
+
}
|
|
251
|
+
}
|
|
252
|
+
function clearIdCache() {
|
|
253
|
+
ensureCacheDir();
|
|
254
|
+
writeFileSync(ID_CACHE_FILE, "{}");
|
|
255
|
+
}
|
|
256
|
+
function clearPeerCache() {
|
|
257
|
+
const cache = loadIdCache();
|
|
258
|
+
delete cache.peers;
|
|
259
|
+
saveIdCache(cache);
|
|
260
|
+
}
|
|
261
|
+
function clearUserContextOnly() {
|
|
262
|
+
const cache = loadContextCache();
|
|
263
|
+
delete cache.userContext;
|
|
264
|
+
saveContextCache(cache);
|
|
265
|
+
}
|
|
266
|
+
function clearClaudeContextOnly() {
|
|
267
|
+
const cache = loadContextCache();
|
|
268
|
+
delete cache.claudeContext;
|
|
269
|
+
saveContextCache(cache);
|
|
270
|
+
}
|
|
271
|
+
// node_modules/@honcho-ai/harness-plugin-core/src/telemetry.ts
|
|
272
|
+
var HEADER_HOST = "X-Honcho-Host";
|
|
273
|
+
var HEADER_PLUGIN = "X-Honcho-Plugin";
|
|
274
|
+
var HEADER_AGENT_MODEL = "X-Honcho-Agent-Model";
|
|
275
|
+
function sanitize(value) {
|
|
276
|
+
if (typeof value !== "string")
|
|
277
|
+
return;
|
|
278
|
+
const s = value.replace(/[\r\n]+/g, " ").trim();
|
|
279
|
+
return s || undefined;
|
|
280
|
+
}
|
|
281
|
+
function token(name, ver) {
|
|
282
|
+
const clean = (v) => sanitize(v)?.replace(/[\s()/;]+/g, "-");
|
|
283
|
+
const n = clean(name);
|
|
284
|
+
const v = clean(ver);
|
|
285
|
+
if (n && v)
|
|
286
|
+
return `${n}/${v}`;
|
|
287
|
+
return n || v;
|
|
288
|
+
}
|
|
289
|
+
function hostHeaderValue(id = {}) {
|
|
290
|
+
const host = token(id.host, id.hostVersion);
|
|
291
|
+
if (!host)
|
|
292
|
+
return;
|
|
293
|
+
const platform = token(id.platform ?? process.platform, undefined);
|
|
294
|
+
return platform ? `${host} (${platform})` : host;
|
|
295
|
+
}
|
|
296
|
+
function pluginHeaderValue(id = {}) {
|
|
297
|
+
return token(id.plugin, id.pluginVersion);
|
|
298
|
+
}
|
|
299
|
+
function telemetryHeaders(id = {}, extra) {
|
|
300
|
+
const headers = {};
|
|
301
|
+
const host = hostHeaderValue(id);
|
|
302
|
+
const plugin = pluginHeaderValue(id);
|
|
303
|
+
const model = sanitize(id.model);
|
|
304
|
+
if (host)
|
|
305
|
+
headers[HEADER_HOST] = host;
|
|
306
|
+
if (plugin)
|
|
307
|
+
headers[HEADER_PLUGIN] = plugin;
|
|
308
|
+
if (model)
|
|
309
|
+
headers[HEADER_AGENT_MODEL] = model;
|
|
310
|
+
if (extra) {
|
|
311
|
+
for (const [k, v] of Object.entries(extra)) {
|
|
312
|
+
const value = sanitize(v);
|
|
313
|
+
if (value)
|
|
314
|
+
headers[k] = value;
|
|
315
|
+
}
|
|
316
|
+
}
|
|
317
|
+
return headers;
|
|
318
|
+
}
|
|
319
|
+
// src/config.ts
|
|
320
|
+
function sanitizeForSessionName(s) {
|
|
321
|
+
return s.toLowerCase().replace(/[^a-z0-9-_]/g, "-");
|
|
322
|
+
}
|
|
323
|
+
var SESSION_START_COMPONENTS = ["directives", "summary", "peerCard", "peerRepresentation", "briefing"];
|
|
324
|
+
var PER_TURN_COMPONENTS = ["userContext", "assistantContext", "sessionContext", "dialectic"];
|
|
325
|
+
function normalizePerTurn(components) {
|
|
326
|
+
return components.map((c) => c === "context" ? "userContext" : c);
|
|
327
|
+
}
|
|
328
|
+
var DEFAULT_INJECTION = {
|
|
329
|
+
sessionStart: ["directives", "summary", "peerCard"],
|
|
330
|
+
perTurn: ["userContext"],
|
|
331
|
+
showContents: [],
|
|
332
|
+
searchTopK: 10,
|
|
333
|
+
maxConclusions: 15,
|
|
334
|
+
searchMaxDistance: 0.6,
|
|
335
|
+
searchQuerySource: "prompt",
|
|
336
|
+
sessionContextTokens: 1500,
|
|
337
|
+
dialecticTemplate: "Return a compact, factual list of anything from the user's history — preferences, prior decisions, relevant past work — that would help with the following. Write in the third person as background notes; do not address the user, ask questions, or offer next steps. If nothing relevant exists, say so in one line. Relevant to: %{user_query}",
|
|
338
|
+
dialecticReasoning: "medium"
|
|
339
|
+
};
|
|
340
|
+
var REASONING_LEVELS = ["minimal", "low", "medium", "high", "max"];
|
|
341
|
+
var HONCHO_BASE_URLS = {
|
|
342
|
+
production: "https://api.honcho.dev/v3",
|
|
343
|
+
local: "http://localhost:8000/v3"
|
|
344
|
+
};
|
|
345
|
+
var _detectedHost = null;
|
|
346
|
+
function setDetectedHost(host) {
|
|
347
|
+
_detectedHost = host;
|
|
348
|
+
}
|
|
349
|
+
function getDetectedHost() {
|
|
350
|
+
return _detectedHost ?? "claude_code";
|
|
351
|
+
}
|
|
352
|
+
function detectHost(stdinInput) {
|
|
353
|
+
const envHost = process.env.HONCHO_HOST;
|
|
354
|
+
if (envHost === "cursor" || envHost === "claude_code" || envHost === "obsidian")
|
|
355
|
+
return envHost;
|
|
356
|
+
if (stdinInput?.cursor_version)
|
|
357
|
+
return "cursor";
|
|
358
|
+
if (process.env.CURSOR_PROJECT_DIR)
|
|
359
|
+
return "cursor";
|
|
360
|
+
return "claude_code";
|
|
361
|
+
}
|
|
362
|
+
var DEFAULT_WORKSPACE = {
|
|
363
|
+
cursor: "cursor",
|
|
364
|
+
claude_code: "claude_code",
|
|
365
|
+
obsidian: "obsidian"
|
|
366
|
+
};
|
|
367
|
+
var DEFAULT_AI_PEER = {
|
|
368
|
+
cursor: "cursor",
|
|
369
|
+
claude_code: "claude",
|
|
370
|
+
obsidian: "honcho"
|
|
371
|
+
};
|
|
372
|
+
function coerceBoolean(value) {
|
|
373
|
+
if (typeof value === "string") {
|
|
374
|
+
const v = value.trim().toLowerCase();
|
|
375
|
+
return v !== "false" && v !== "0" && v !== "";
|
|
376
|
+
}
|
|
377
|
+
return Boolean(value);
|
|
378
|
+
}
|
|
379
|
+
var _stdinText = null;
|
|
380
|
+
function cacheStdin(text) {
|
|
381
|
+
_stdinText = text;
|
|
382
|
+
}
|
|
383
|
+
function getCachedStdin() {
|
|
384
|
+
return _stdinText;
|
|
385
|
+
}
|
|
386
|
+
async function readStdinText() {
|
|
387
|
+
const chunks = [];
|
|
388
|
+
for await (const chunk of process.stdin)
|
|
389
|
+
chunks.push(chunk);
|
|
390
|
+
return Buffer.concat(chunks).toString("utf-8");
|
|
391
|
+
}
|
|
392
|
+
async function initHook() {
|
|
393
|
+
const stdinText = await readStdinText();
|
|
394
|
+
cacheStdin(stdinText);
|
|
395
|
+
let input = {};
|
|
396
|
+
try {
|
|
397
|
+
input = JSON.parse(stdinText || "{}");
|
|
398
|
+
} catch {
|
|
399
|
+
process.exit(0);
|
|
400
|
+
}
|
|
401
|
+
if (input.cursor_version)
|
|
402
|
+
process.exit(0);
|
|
403
|
+
setDetectedHost(detectHost(input));
|
|
404
|
+
}
|
|
405
|
+
function deepEqual(a, b) {
|
|
406
|
+
if (a === b)
|
|
407
|
+
return true;
|
|
408
|
+
if (a == null || b == null)
|
|
409
|
+
return a === b;
|
|
410
|
+
if (typeof a !== typeof b)
|
|
411
|
+
return false;
|
|
412
|
+
if (typeof a !== "object")
|
|
413
|
+
return false;
|
|
414
|
+
const aObj = a;
|
|
415
|
+
const bObj = b;
|
|
416
|
+
const keys = new Set([...Object.keys(aObj), ...Object.keys(bObj)]);
|
|
417
|
+
for (const key of keys) {
|
|
418
|
+
if (!deepEqual(aObj[key], bObj[key]))
|
|
419
|
+
return false;
|
|
420
|
+
}
|
|
421
|
+
return true;
|
|
422
|
+
}
|
|
423
|
+
var CONFIG_DIR = join3(homedir2(), ".honcho");
|
|
424
|
+
var CONFIG_FILE = join3(CONFIG_DIR, "config.json");
|
|
425
|
+
function getConfigPath() {
|
|
426
|
+
return CONFIG_FILE;
|
|
427
|
+
}
|
|
428
|
+
function configExists() {
|
|
429
|
+
return existsSync3(CONFIG_FILE);
|
|
430
|
+
}
|
|
431
|
+
function getPluginVersion() {
|
|
432
|
+
const root = process.env.CLAUDE_PLUGIN_ROOT;
|
|
433
|
+
const candidates = [
|
|
434
|
+
...root ? [join3(root, ".claude-plugin", "plugin.json")] : [],
|
|
435
|
+
fileURLToPath(new URL("../.claude-plugin/plugin.json", import.meta.url))
|
|
436
|
+
];
|
|
437
|
+
for (const manifest of candidates) {
|
|
438
|
+
try {
|
|
439
|
+
const version = JSON.parse(readFileSync2(manifest, "utf-8")).version;
|
|
440
|
+
if (typeof version === "string" && version)
|
|
441
|
+
return version;
|
|
442
|
+
} catch {}
|
|
443
|
+
}
|
|
444
|
+
return "unknown";
|
|
445
|
+
}
|
|
446
|
+
function loadConfig2(host) {
|
|
447
|
+
const resolvedHost = host ?? getDetectedHost();
|
|
448
|
+
if (configExists()) {
|
|
449
|
+
try {
|
|
450
|
+
const content = readFileSync2(CONFIG_FILE, "utf-8");
|
|
451
|
+
const raw = JSON.parse(content);
|
|
452
|
+
return resolveConfig2(raw, resolvedHost);
|
|
453
|
+
} catch {}
|
|
454
|
+
}
|
|
455
|
+
return loadConfigFromEnv(resolvedHost);
|
|
456
|
+
}
|
|
457
|
+
function resolveConfig2(raw, host) {
|
|
458
|
+
const hostBlock = raw.hosts?.[host] ?? raw.hosts?.[host.replace(/_/g, "-")] ?? raw.hosts?.[host.replace(/-/g, "_")];
|
|
459
|
+
const apiKey = process.env.HONCHO_API_KEY || hostBlock?.apiKey || raw.apiKey;
|
|
460
|
+
if (!apiKey)
|
|
461
|
+
return null;
|
|
462
|
+
const peerName = raw.peerName || process.env.HONCHO_PEER_NAME || process.env.USER || process.env.USERNAME || "user";
|
|
463
|
+
let workspace;
|
|
464
|
+
let aiPeer;
|
|
465
|
+
if (raw.globalOverride === true) {
|
|
466
|
+
workspace = raw.workspace ?? DEFAULT_WORKSPACE[host];
|
|
467
|
+
aiPeer = raw.aiPeer ?? hostBlock?.aiPeer ?? DEFAULT_AI_PEER[host];
|
|
468
|
+
} else if (hostBlock) {
|
|
469
|
+
workspace = hostBlock.workspace ?? DEFAULT_WORKSPACE[host];
|
|
470
|
+
aiPeer = hostBlock.aiPeer ?? DEFAULT_AI_PEER[host];
|
|
471
|
+
} else {
|
|
472
|
+
workspace = process.env.HONCHO_WORKSPACE ?? raw.workspace ?? DEFAULT_WORKSPACE[host];
|
|
473
|
+
if (host === "cursor") {
|
|
474
|
+
aiPeer = raw.cursorPeer ?? DEFAULT_AI_PEER["cursor"];
|
|
475
|
+
} else {
|
|
476
|
+
aiPeer = raw.claudePeer ?? DEFAULT_AI_PEER["claude_code"];
|
|
477
|
+
}
|
|
478
|
+
}
|
|
479
|
+
const config = {
|
|
480
|
+
apiKey,
|
|
481
|
+
peerName,
|
|
482
|
+
workspace,
|
|
483
|
+
aiPeer,
|
|
484
|
+
sessionStrategy: hostBlock?.sessionStrategy ?? raw.sessionStrategy,
|
|
485
|
+
sessionPeerPrefix: hostBlock?.sessionPeerPrefix ?? raw.sessionPeerPrefix,
|
|
486
|
+
sessions: raw.sessions,
|
|
487
|
+
saveMessages: hostBlock?.saveMessages ?? raw.saveMessages,
|
|
488
|
+
saveToolUse: hostBlock?.saveToolUse ?? raw.saveToolUse,
|
|
489
|
+
saveGitEvents: hostBlock?.saveGitEvents ?? raw.saveGitEvents,
|
|
490
|
+
reasoningLevel: hostBlock?.reasoningLevel ?? raw.reasoningLevel,
|
|
491
|
+
observationMode: hostBlock?.observationMode ?? raw.observationMode,
|
|
492
|
+
messageUpload: hostBlock?.messageUpload ?? raw.messageUpload,
|
|
493
|
+
contextRefresh: hostBlock?.contextRefresh ?? raw.contextRefresh,
|
|
494
|
+
endpoint: hostBlock?.endpoint ?? raw.endpoint,
|
|
495
|
+
redactPatterns: hostBlock?.redactPatterns ?? raw.redactPatterns,
|
|
496
|
+
injection: hostBlock?.injection ?? raw.injection,
|
|
497
|
+
rememberTool: hostBlock?.rememberTool ?? raw.rememberTool,
|
|
498
|
+
enabled: hostBlock?.enabled ?? raw.enabled,
|
|
499
|
+
logging: hostBlock?.logging ?? raw.logging,
|
|
500
|
+
globalOverride: raw.globalOverride
|
|
501
|
+
};
|
|
502
|
+
return mergeWithEnvVars(config);
|
|
503
|
+
}
|
|
504
|
+
function loadConfigFromEnv(host) {
|
|
505
|
+
const apiKey = process.env.HONCHO_API_KEY;
|
|
506
|
+
if (!apiKey) {
|
|
507
|
+
return null;
|
|
508
|
+
}
|
|
509
|
+
const resolvedHost = host ?? getDetectedHost();
|
|
510
|
+
const peerName = process.env.HONCHO_PEER_NAME || process.env.USER || process.env.USERNAME || "user";
|
|
511
|
+
const workspace = process.env.HONCHO_WORKSPACE || DEFAULT_WORKSPACE[resolvedHost];
|
|
512
|
+
const hostPeerEnv = resolvedHost === "cursor" ? process.env.HONCHO_CURSOR_PEER : process.env.HONCHO_CLAUDE_PEER;
|
|
513
|
+
const aiPeer = process.env.HONCHO_AI_PEER || hostPeerEnv || DEFAULT_AI_PEER[resolvedHost];
|
|
514
|
+
const endpoint = process.env.HONCHO_ENDPOINT;
|
|
515
|
+
const config = {
|
|
516
|
+
apiKey,
|
|
517
|
+
peerName,
|
|
518
|
+
workspace,
|
|
519
|
+
aiPeer,
|
|
520
|
+
saveMessages: process.env.HONCHO_SAVE_MESSAGES !== "false",
|
|
521
|
+
saveToolUse: process.env.HONCHO_SAVE_TOOL_USE === "true",
|
|
522
|
+
saveGitEvents: process.env.HONCHO_SAVE_GIT_EVENTS === "true",
|
|
523
|
+
enabled: process.env.HONCHO_ENABLED !== "false",
|
|
524
|
+
logging: process.env.HONCHO_LOGGING !== "false"
|
|
525
|
+
};
|
|
526
|
+
if (endpoint) {
|
|
527
|
+
if (endpoint === "local") {
|
|
528
|
+
config.endpoint = { environment: "local" };
|
|
529
|
+
} else if (endpoint.startsWith("http")) {
|
|
530
|
+
config.endpoint = { baseUrl: endpoint };
|
|
531
|
+
}
|
|
532
|
+
}
|
|
533
|
+
return config;
|
|
534
|
+
}
|
|
535
|
+
function mergeWithEnvVars(config) {
|
|
536
|
+
if (process.env.HONCHO_API_KEY) {
|
|
537
|
+
config.apiKey = process.env.HONCHO_API_KEY;
|
|
538
|
+
}
|
|
539
|
+
if (process.env.HONCHO_PEER_NAME) {
|
|
540
|
+
config.peerName = process.env.HONCHO_PEER_NAME;
|
|
541
|
+
}
|
|
542
|
+
if (process.env.HONCHO_ENABLED === "false") {
|
|
543
|
+
config.enabled = false;
|
|
544
|
+
}
|
|
545
|
+
if (process.env.HONCHO_LOGGING === "false") {
|
|
546
|
+
config.logging = false;
|
|
547
|
+
}
|
|
548
|
+
if (process.env.HONCHO_SAVE_TOOL_USE !== undefined) {
|
|
549
|
+
config.saveToolUse = process.env.HONCHO_SAVE_TOOL_USE === "true";
|
|
550
|
+
}
|
|
551
|
+
if (process.env.HONCHO_SAVE_GIT_EVENTS !== undefined) {
|
|
552
|
+
config.saveGitEvents = process.env.HONCHO_SAVE_GIT_EVENTS === "true";
|
|
553
|
+
}
|
|
554
|
+
return config;
|
|
555
|
+
}
|
|
556
|
+
function saveConfig(config) {
|
|
557
|
+
if (!existsSync3(CONFIG_DIR)) {
|
|
558
|
+
mkdirSync2(CONFIG_DIR, { recursive: true });
|
|
559
|
+
}
|
|
560
|
+
let existing = {};
|
|
561
|
+
if (existsSync3(CONFIG_FILE)) {
|
|
562
|
+
try {
|
|
563
|
+
existing = JSON.parse(readFileSync2(CONFIG_FILE, "utf-8"));
|
|
564
|
+
} catch {}
|
|
565
|
+
}
|
|
566
|
+
if (config.sessions !== undefined) {
|
|
567
|
+
existing.sessions = config.sessions;
|
|
568
|
+
}
|
|
569
|
+
const host = getDetectedHost();
|
|
570
|
+
if (!existing.hosts)
|
|
571
|
+
existing.hosts = {};
|
|
572
|
+
const existingHost = existing.hosts[host] ?? {};
|
|
573
|
+
const hostEntry = {};
|
|
574
|
+
const setHostIfExplicit = (key, value, rootValue) => {
|
|
575
|
+
if (value === undefined)
|
|
576
|
+
return;
|
|
577
|
+
const hasHostOverride = Object.prototype.hasOwnProperty.call(existingHost, key);
|
|
578
|
+
if (hasHostOverride || !deepEqual(value, rootValue)) {
|
|
579
|
+
hostEntry[key] = value;
|
|
580
|
+
}
|
|
581
|
+
};
|
|
582
|
+
setHostIfExplicit("workspace", config.workspace, existing.workspace ?? DEFAULT_WORKSPACE[host]);
|
|
583
|
+
setHostIfExplicit("aiPeer", config.aiPeer, existing.aiPeer ?? DEFAULT_AI_PEER[host]);
|
|
584
|
+
const enabledForSave = process.env.HONCHO_ENABLED === "false" && config.enabled === false ? existingHost.enabled : config.enabled;
|
|
585
|
+
const loggingForSave = process.env.HONCHO_LOGGING === "false" && config.logging === false ? existingHost.logging : config.logging;
|
|
586
|
+
setHostIfExplicit("enabled", enabledForSave, existing.enabled);
|
|
587
|
+
setHostIfExplicit("logging", loggingForSave, existing.logging);
|
|
588
|
+
setHostIfExplicit("saveMessages", config.saveMessages, existing.saveMessages);
|
|
589
|
+
setHostIfExplicit("sessionStrategy", config.sessionStrategy, existing.sessionStrategy);
|
|
590
|
+
setHostIfExplicit("sessionPeerPrefix", config.sessionPeerPrefix, existing.sessionPeerPrefix);
|
|
591
|
+
setHostIfExplicit("reasoningLevel", config.reasoningLevel, existing.reasoningLevel);
|
|
592
|
+
setHostIfExplicit("observationMode", config.observationMode, existing.observationMode);
|
|
593
|
+
setHostIfExplicit("messageUpload", config.messageUpload, existing.messageUpload);
|
|
594
|
+
setHostIfExplicit("contextRefresh", config.contextRefresh, existing.contextRefresh);
|
|
595
|
+
setHostIfExplicit("redactPatterns", config.redactPatterns, existing.redactPatterns);
|
|
596
|
+
setHostIfExplicit("endpoint", config.endpoint, existing.endpoint);
|
|
597
|
+
setHostIfExplicit("injection", config.injection, existing.injection);
|
|
598
|
+
setHostIfExplicit("rememberTool", config.rememberTool, existing.rememberTool);
|
|
599
|
+
if (existingHost.apiKey !== undefined) {
|
|
600
|
+
hostEntry.apiKey = existingHost.apiKey;
|
|
601
|
+
}
|
|
602
|
+
existing.hosts[host] = hostEntry;
|
|
603
|
+
writeFileSync2(CONFIG_FILE, JSON.stringify(existing, null, 2));
|
|
604
|
+
}
|
|
605
|
+
function saveRootField(field, value) {
|
|
606
|
+
if (!existsSync3(CONFIG_DIR)) {
|
|
607
|
+
mkdirSync2(CONFIG_DIR, { recursive: true });
|
|
608
|
+
}
|
|
609
|
+
let existing = {};
|
|
610
|
+
if (existsSync3(CONFIG_FILE)) {
|
|
611
|
+
try {
|
|
612
|
+
existing = JSON.parse(readFileSync2(CONFIG_FILE, "utf-8"));
|
|
613
|
+
} catch {}
|
|
614
|
+
}
|
|
615
|
+
existing[field] = value;
|
|
616
|
+
writeFileSync2(CONFIG_FILE, JSON.stringify(existing, null, 2));
|
|
617
|
+
}
|
|
618
|
+
function resolveWorktreeMainRoot(dir) {
|
|
619
|
+
try {
|
|
620
|
+
const gitPath = join3(dir, ".git");
|
|
621
|
+
if (!statSync(gitPath).isFile())
|
|
622
|
+
return null;
|
|
623
|
+
const match = readFileSync2(gitPath, "utf-8").match(/^gitdir:\s*(.+?)\s*$/m);
|
|
624
|
+
if (!match)
|
|
625
|
+
return null;
|
|
626
|
+
const gitdir = resolve(dir, match[1]);
|
|
627
|
+
const idx = gitdir.lastIndexOf(`${sep}worktrees${sep}`);
|
|
628
|
+
if (idx === -1)
|
|
629
|
+
return null;
|
|
630
|
+
const gitContainer = gitdir.slice(0, idx);
|
|
631
|
+
if (basename(gitContainer) === ".git")
|
|
632
|
+
return dirname(gitContainer);
|
|
633
|
+
if (gitContainer.endsWith(".git"))
|
|
634
|
+
return gitContainer;
|
|
635
|
+
return null;
|
|
636
|
+
} catch {
|
|
637
|
+
return null;
|
|
638
|
+
}
|
|
639
|
+
}
|
|
640
|
+
var MAX_GIT_WALK_UP = 12;
|
|
641
|
+
function worktreeMainRootFor(cwd) {
|
|
642
|
+
try {
|
|
643
|
+
let dir = resolve(cwd);
|
|
644
|
+
for (let i = 0;i < MAX_GIT_WALK_UP; i++) {
|
|
645
|
+
if (existsSync3(join3(dir, ".git")))
|
|
646
|
+
return resolveWorktreeMainRoot(dir);
|
|
647
|
+
const parent = dirname(dir);
|
|
648
|
+
if (parent === dir)
|
|
649
|
+
break;
|
|
650
|
+
dir = parent;
|
|
651
|
+
}
|
|
652
|
+
} catch {}
|
|
653
|
+
return null;
|
|
654
|
+
}
|
|
655
|
+
function getSessionForPath(cwd, mainRoot) {
|
|
656
|
+
const config = loadConfig2();
|
|
657
|
+
if (!config?.sessions)
|
|
658
|
+
return null;
|
|
659
|
+
if (config.sessions[cwd])
|
|
660
|
+
return config.sessions[cwd];
|
|
661
|
+
const mr = mainRoot === undefined ? worktreeMainRootFor(cwd) : mainRoot;
|
|
662
|
+
if (mr && config.sessions[mr])
|
|
663
|
+
return config.sessions[mr];
|
|
664
|
+
return null;
|
|
665
|
+
}
|
|
666
|
+
function deriveSessionName(strategy, cwd, opts = {}) {
|
|
667
|
+
const usePrefix = opts.sessionPeerPrefix !== false;
|
|
668
|
+
const peerPart = opts.peerName ? sanitizeForSessionName(opts.peerName) : "user";
|
|
669
|
+
const repoPart = sanitizeForSessionName(basename(cwd));
|
|
670
|
+
const base = usePrefix ? `${peerPart}-${repoPart}` : repoPart;
|
|
671
|
+
switch (strategy) {
|
|
672
|
+
case "git-branch": {
|
|
673
|
+
if (opts.branch) {
|
|
674
|
+
const branchPart = sanitizeForSessionName(opts.branch);
|
|
675
|
+
return `${base}-${branchPart}`;
|
|
676
|
+
}
|
|
677
|
+
return base;
|
|
678
|
+
}
|
|
679
|
+
case "chat-instance": {
|
|
680
|
+
if (opts.instanceId) {
|
|
681
|
+
return usePrefix ? `${peerPart}-chat-${opts.instanceId}` : `chat-${opts.instanceId}`;
|
|
682
|
+
}
|
|
683
|
+
return base;
|
|
684
|
+
}
|
|
685
|
+
case "per-directory":
|
|
686
|
+
default:
|
|
687
|
+
return base;
|
|
688
|
+
}
|
|
689
|
+
}
|
|
690
|
+
function getSessionName(cwd, instanceId) {
|
|
691
|
+
const config = loadConfig2();
|
|
692
|
+
const strategy = config?.sessionStrategy ?? "per-directory";
|
|
693
|
+
const mainRoot = worktreeMainRootFor(cwd);
|
|
694
|
+
if (strategy === "per-directory") {
|
|
695
|
+
const configuredSession = getSessionForPath(cwd, mainRoot);
|
|
696
|
+
if (configuredSession) {
|
|
697
|
+
return configuredSession;
|
|
698
|
+
}
|
|
699
|
+
}
|
|
700
|
+
let branch;
|
|
701
|
+
if (strategy === "git-branch") {
|
|
702
|
+
branch = captureGitState(cwd)?.branch;
|
|
703
|
+
}
|
|
704
|
+
let resolvedInstanceId;
|
|
705
|
+
if (strategy === "chat-instance") {
|
|
706
|
+
resolvedInstanceId = instanceId || getInstanceIdForCwd(cwd) || getClaudeInstanceId() || undefined;
|
|
707
|
+
}
|
|
708
|
+
return deriveSessionName(strategy, mainRoot ?? cwd, {
|
|
709
|
+
peerName: config?.peerName,
|
|
710
|
+
sessionPeerPrefix: config?.sessionPeerPrefix,
|
|
711
|
+
branch,
|
|
712
|
+
instanceId: resolvedInstanceId
|
|
713
|
+
});
|
|
714
|
+
}
|
|
715
|
+
function setSessionForPath(cwd, sessionName) {
|
|
716
|
+
const config = loadConfig2();
|
|
717
|
+
if (!config)
|
|
718
|
+
return;
|
|
719
|
+
if (!config.sessions) {
|
|
720
|
+
config.sessions = {};
|
|
721
|
+
}
|
|
722
|
+
config.sessions[cwd] = sessionName;
|
|
723
|
+
saveConfig(config);
|
|
724
|
+
}
|
|
725
|
+
function getInjectionConfig(config) {
|
|
726
|
+
const injection = (config === undefined ? loadConfig2() : config)?.injection;
|
|
727
|
+
const resolved = { ...DEFAULT_INJECTION, ...injection ?? {} };
|
|
728
|
+
resolved.perTurn = Array.isArray(resolved.perTurn) ? normalizePerTurn(resolved.perTurn) : DEFAULT_INJECTION.perTurn;
|
|
729
|
+
resolved.showContents = Array.isArray(resolved.showContents) ? normalizePerTurn(resolved.showContents) : DEFAULT_INJECTION.showContents;
|
|
730
|
+
return resolved;
|
|
731
|
+
}
|
|
732
|
+
function isLoggingEnabled() {
|
|
733
|
+
const config = loadConfig2();
|
|
734
|
+
return config?.logging !== false;
|
|
735
|
+
}
|
|
736
|
+
function isPluginEnabled() {
|
|
737
|
+
const config = loadConfig2();
|
|
738
|
+
return config?.enabled !== false;
|
|
739
|
+
}
|
|
740
|
+
function getKnownHosts() {
|
|
741
|
+
const cfgPath = getConfigPath();
|
|
742
|
+
if (!existsSync3(cfgPath))
|
|
743
|
+
return [];
|
|
744
|
+
try {
|
|
745
|
+
const raw = JSON.parse(readFileSync2(cfgPath, "utf-8"));
|
|
746
|
+
return raw.hosts ? Object.keys(raw.hosts) : [];
|
|
747
|
+
} catch {
|
|
748
|
+
return [];
|
|
749
|
+
}
|
|
750
|
+
}
|
|
751
|
+
function getHonchoBaseUrlForEndpoint(endpoint) {
|
|
752
|
+
if (endpoint?.baseUrl) {
|
|
753
|
+
const url = endpoint.baseUrl;
|
|
754
|
+
return url.endsWith("/v3") ? url : `${url}/v3`;
|
|
755
|
+
}
|
|
756
|
+
if (endpoint?.environment === "local") {
|
|
757
|
+
return HONCHO_BASE_URLS.local;
|
|
758
|
+
}
|
|
759
|
+
return HONCHO_BASE_URLS.production;
|
|
760
|
+
}
|
|
761
|
+
function getHonchoBaseUrl(config) {
|
|
762
|
+
return getHonchoBaseUrlForEndpoint(config.endpoint);
|
|
763
|
+
}
|
|
764
|
+
function getTelemetryHeaders(host = getDetectedHost()) {
|
|
765
|
+
return telemetryHeaders({
|
|
766
|
+
host: host.replace(/_/g, "-"),
|
|
767
|
+
plugin: "claude-honcho",
|
|
768
|
+
pluginVersion: getPluginVersion()
|
|
769
|
+
});
|
|
770
|
+
}
|
|
771
|
+
function getHonchoClientOptions(config) {
|
|
772
|
+
return {
|
|
773
|
+
apiKey: config.apiKey,
|
|
774
|
+
baseURL: getHonchoBaseUrl(config),
|
|
775
|
+
workspaceId: config.workspace,
|
|
776
|
+
timeout: 120000,
|
|
777
|
+
maxRetries: 1,
|
|
778
|
+
defaultHeaders: getTelemetryHeaders()
|
|
779
|
+
};
|
|
780
|
+
}
|
|
781
|
+
function getEndpointInfo(config) {
|
|
782
|
+
if (config.endpoint?.baseUrl) {
|
|
783
|
+
return { type: "custom", url: config.endpoint.baseUrl };
|
|
784
|
+
}
|
|
785
|
+
if (config.endpoint?.environment === "local") {
|
|
786
|
+
return { type: "local", url: HONCHO_BASE_URLS.local };
|
|
787
|
+
}
|
|
788
|
+
return { type: "production", url: HONCHO_BASE_URLS.production };
|
|
789
|
+
}
|
|
790
|
+
var VALID_ENVIRONMENTS = new Set(["production", "local"]);
|
|
791
|
+
function getObservationMode(config) {
|
|
792
|
+
return config.observationMode ?? "unified";
|
|
793
|
+
}
|
|
794
|
+
|
|
795
|
+
// src/state.ts
|
|
796
|
+
import { homedir as homedir3 } from "os";
|
|
797
|
+
import { join as join4 } from "path";
|
|
798
|
+
import { writeFileSync as writeFileSync3, unlinkSync } from "fs";
|
|
799
|
+
var DIR = join4(homedir3(), ".honcho");
|
|
800
|
+
function stateFile(sessionId) {
|
|
801
|
+
return join4(DIR, sessionId ? `state-${sessionId}.json` : "state.json");
|
|
802
|
+
}
|
|
803
|
+
function sessionFile(sessionId) {
|
|
804
|
+
return join4(DIR, sessionId ? `session-${sessionId}.json` : "session.json");
|
|
805
|
+
}
|
|
806
|
+
function setMemoryState(phase, detail, sessionId) {
|
|
807
|
+
try {
|
|
808
|
+
writeFileSync3(stateFile(sessionId), JSON.stringify({ phase, since: Date.now(), detail }));
|
|
809
|
+
} catch {}
|
|
810
|
+
}
|
|
811
|
+
function setSessionLink(url, name, sessionId) {
|
|
812
|
+
try {
|
|
813
|
+
writeFileSync3(sessionFile(sessionId), JSON.stringify({ url, name }));
|
|
814
|
+
} catch {}
|
|
815
|
+
}
|
|
816
|
+
function clearSessionFiles(sessionId) {
|
|
817
|
+
if (!sessionId)
|
|
818
|
+
return;
|
|
819
|
+
for (const f of [stateFile(sessionId), sessionFile(sessionId)]) {
|
|
820
|
+
try {
|
|
821
|
+
unlinkSync(f);
|
|
822
|
+
} catch {}
|
|
823
|
+
}
|
|
824
|
+
}
|
|
9
825
|
|
|
10
826
|
// src/hooks/pre-tool-honcho.ts
|
|
11
827
|
var LABELS = {
|
|
@@ -29,10 +845,13 @@ async function handlePreToolHoncho() {
|
|
|
29
845
|
} catch {}
|
|
30
846
|
process.exit(0);
|
|
31
847
|
}
|
|
848
|
+
async function main() {
|
|
849
|
+
await initHook();
|
|
850
|
+
await handlePreToolHoncho();
|
|
851
|
+
}
|
|
32
852
|
|
|
33
853
|
// hooks/pre-tool-honcho.ts
|
|
34
|
-
await
|
|
35
|
-
await handlePreToolHoncho();
|
|
854
|
+
await main();
|
|
36
855
|
|
|
37
|
-
//# debugId=
|
|
856
|
+
//# debugId=0D79439C2A9A5A0B64756E2164756E21
|
|
38
857
|
//# sourceMappingURL=pre-tool-honcho.js.map
|