@delt/claude-jev-advisor 0.1.0

package/dist/context-hook.js

@@ -0,0 +1,394 @@
+#!/usr/bin/env node
+
+// src/context/hook.ts
+import os from "os";
+
+// src/config.ts
+import fs from "fs";
+import path2 from "path";
+
+// src/config-shape.ts
+var DEFAULT_CONFIG = {
+  lang: "ko",
+  keyFile: null,
+  display: "mod",
+  context: { enabled: true, minTokens: 1e5, compactMinTokens: 2e5, redRemainingPct: 20, unitDoneYes: 0.7, goalDoneYes: 0.8 },
+  rm: { enabled: true, jev: true, throwawayYes: 0.8, maxDirFiles: 50 }
+};
+var LANGS = ["ko", "en"];
+var DISPLAYS = ["mod", "statusline", "message"];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeSection(defaults, raw) {
+  const out = { ...defaults };
+  if (!isRecord(raw)) return out;
+  for (const [key, value] of Object.entries(defaults)) {
+    if (typeof raw[key] === typeof value) out[key] = raw[key];
+  }
+  return out;
+}
+function normalizeConfig(raw) {
+  const r = isRecord(raw) ? raw : {};
+  return {
+    lang: typeof r.lang === "string" && LANGS.includes(r.lang) ? r.lang : DEFAULT_CONFIG.lang,
+    keyFile: typeof r.keyFile === "string" && r.keyFile !== "" ? r.keyFile : null,
+    display: typeof r.display === "string" && DISPLAYS.includes(r.display) ? r.display : DEFAULT_CONFIG.display,
+    context: mergeSection(DEFAULT_CONFIG.context, r.context),
+    rm: mergeSection(DEFAULT_CONFIG.rm, r.rm)
+  };
+}
+
+// src/paths.ts
+import path from "path";
+var claudeDir = (home) => path.join(home, ".claude");
+var dataDir = (home) => path.join(claudeDir(home), "claude-jev-advisor");
+var configPath = (home) => path.join(dataDir(home), "config.json");
+var stateDir = (home) => path.join(dataDir(home), "state");
+var logDir = (home) => path.join(dataDir(home), "log");
+
+// src/config.ts
+function readConfig(home) {
+  try {
+    return normalizeConfig(JSON.parse(fs.readFileSync(configPath(home), "utf8").replace(/^\uFEFF/, "")));
+  } catch {
+    return normalizeConfig({});
+  }
+}
+
+// src/display/line.ts
+var PHRASES = {
+  ko: {
+    clear: "\uC0C8\uB86D\uAC8C \uC2DC\uC791\uD558\uB294 \uAC74 \uC5B4\uB5A0\uC138\uC694? /clear",
+    compact: "\uC9C0\uAE08\uAE4C\uC9C0 \uC815\uB9AC\uD558\uACE0 \uC774\uC5B4\uAC00\uB294 \uAC74 \uC5B4\uB5A0\uC138\uC694? /compact",
+    compactLater: "\uC791\uC5C5\uC774 \uB05D\uB098\uBA74 \uC815\uB9AC\uD558\uACE0 \uC774\uC5B4\uAC00\uB294 \uAC74 \uC5B4\uB5A0\uC138\uC694? /compact"
+  },
+  en: {
+    clear: "Start fresh? /clear",
+    compact: "Wrap up what you have and continue? /compact",
+    compactLater: "When this work is done, wrap up and continue? /compact"
+  }
+};
+function formatSize(tokens) {
+  return `${Math.round(tokens / 1e3)}k`;
+}
+function remainingPct(size, threshold) {
+  return Math.max(0, Math.round((threshold - size) / threshold * 100));
+}
+function adviceLine({ size, threshold, judgment, config }) {
+  if (size === null) return "";
+  const k = formatSize(size);
+  const phrases = PHRASES[config.lang];
+  const counted = size >= config.context.minTokens ? judgment : null;
+  if (threshold !== null && threshold > 0 && size >= threshold * (1 - config.context.redRemainingPct / 100)) {
+    const head = `\u{1F534} ${k} ${remainingPct(size, threshold)}%`;
+    if (!counted) return head;
+    if (counted.phase === "working") return `${head} \xB7 ${phrases.compactLater}`;
+    return `${head} \xB7 ${counted.clear ? phrases.clear : phrases.compact}`;
+  }
+  if (!counted) return k;
+  if (counted.phase === "working") return `\u{1F7E2} ${k}`;
+  if (counted.clear) return `\u{1F7E1} ${k} ${phrases.clear}`;
+  if (size >= config.context.compactMinTokens) return `\u{1F7E1} ${k} ${phrases.compact}`;
+  return `\u{1F7E2} ${k}`;
+}
+
+// src/jev.ts
+import fs2 from "fs";
+var JEV_URL = "https://api.typesafe.ai/v1/systemone";
+var JEV_TIMEOUT_MS = 8e3;
+var KEY_PREFIX = "TYPESAFE_API_KEY=";
+function readJevKey(env, keyFile) {
+  const fromEnv = env.TYPESAFE_API_KEY?.trim();
+  if (fromEnv) return fromEnv;
+  if (!keyFile) return null;
+  let text;
+  try {
+    text = fs2.readFileSync(keyFile, "utf8");
+  } catch {
+    return null;
+  }
+  const line = text.replace(/^\uFEFF/, "").split(/\r?\n/).find((l) => l.startsWith(KEY_PREFIX));
+  const key = line?.slice(KEY_PREFIX.length).trim().replace(/^["']|["']$/g, "");
+  return key || null;
+}
+async function callJev(request, opts) {
+  const now = opts.now ?? Date.now;
+  const fetchFn = opts.fetchFn ?? fetch;
+  const limit = opts.timeoutMs ?? JEV_TIMEOUT_MS;
+  const redact = (text) => text.split(opts.key).join("[redacted]");
+  const started = now();
+  const controller = new AbortController();
+  let timer;
+  const expired = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => {
+      const err = new Error(`Jev did not answer within ${limit} ms`);
+      controller.abort(err);
+      reject(err);
+    }, limit);
+  });
+  let requestId = null;
+  const exchange = (async () => {
+    const res = await fetchFn(JEV_URL, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${opts.key}`, "Content-Type": "application/json" },
+      body: JSON.stringify({ model: "jev-latest", ...request }),
+      signal: controller.signal
+    });
+    requestId = res.headers.get("request-id") ?? res.headers.get("x-request-id");
+    return { res, text: await res.text() };
+  })();
+  exchange.catch(() => {
+  });
+  try {
+    const { res, text } = await Promise.race([exchange, expired]);
+    if (!res.ok) return { error: redact(`HTTP ${res.status}: ${text}`).slice(0, 300), requestId, ms: now() - started };
+    const body = JSON.parse(text);
+    const answers = {};
+    for (const [id, answer] of Object.entries(body.answers ?? {})) {
+      if (typeof answer?.noul === "number") answers[id] = answer.noul;
+    }
+    return { answers, model: typeof body.model === "string" ? body.model : null, requestId, ms: now() - started };
+  } catch (err) {
+    return { error: redact(String(err?.message ?? err)).slice(0, 300), requestId, ms: now() - started };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/context/files.ts
+import fs3 from "fs";
+import path3 from "path";
+var SAFE_SESSION_ID = /^[A-Za-z0-9_-]+$/;
+var RENAME_ATTEMPTS = 3;
+var RETRYABLE_RENAME = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES"]);
+function pause(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function statePath(home, sessionId) {
+  return SAFE_SESSION_ID.test(sessionId) ? path3.join(stateDir(home), `${sessionId}.json`) : null;
+}
+function writeState(home, state) {
+  const file = statePath(home, state.sessionId);
+  if (!file) return;
+  fs3.mkdirSync(path3.dirname(file), { recursive: true });
+  const temp = `${file}.${process.pid}.tmp`;
+  fs3.writeFileSync(temp, JSON.stringify(state));
+  try {
+    for (let attempt = 1; ; attempt++) {
+      try {
+        fs3.renameSync(temp, file);
+        return;
+      } catch (err) {
+        if (attempt >= RENAME_ATTEMPTS || !RETRYABLE_RENAME.has(err.code ?? "")) throw err;
+        pause(20 * attempt);
+      }
+    }
+  } catch (err) {
+    fs3.rmSync(temp, { force: true });
+    throw err;
+  }
+}
+function removeState(home, sessionId) {
+  const file = statePath(home, sessionId);
+  if (file) fs3.rmSync(file, { force: true });
+}
+function logFile(home, now) {
+  return path3.join(logDir(home), `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}.jsonl`);
+}
+function appendLog(home, now, record) {
+  const file = logFile(home, now);
+  fs3.mkdirSync(path3.dirname(file), { recursive: true });
+  fs3.appendFileSync(file, `${JSON.stringify({ at: now.toISOString(), ...record })}
+`);
+}
+
+// src/context/judge.ts
+var REPLY_EDGE_CHARS = 1500;
+var QUESTIONS = {
+  unit_done: {
+    type: "noul",
+    instructions: "Has the work asked for in `recent_requests` reached a natural stopping point in `last_assistant_reply`?",
+    criteria: {
+      true: "The requested work is finished, verified or handed over; anything still mentioned is optional.",
+      false: "The work is still in progress: the reply asks a question it needs answered to continue, says what it will do next, or reports something still running or failing."
+    }
+  },
+  goal_done: {
+    type: "noul",
+    instructions: "Does `last_assistant_reply` wrap up the overall goal behind `recent_requests`, with no further steps on that goal left to take next?",
+    criteria: {
+      true: "The goal is finished: the reply hands over the result or reports a commit, release or completion, and plans or proposes no further work toward the same goal.",
+      false: "Steps toward the same goal remain: the next task of a plan, a proposed follow-up, or a review, test or decision the user still has to make."
+    }
+  }
+};
+function cutReply(text, edge = REPLY_EDGE_CHARS) {
+  return text.length <= edge * 2 ? text : `${text.slice(0, edge)}
+\u2026
+${text.slice(-edge)}`;
+}
+function jevRequest(requests, lastReply) {
+  return {
+    state: { recent_requests: requests, last_assistant_reply: cutReply(lastReply) },
+    questions: { unit_done: QUESTIONS.unit_done, goal_done: QUESTIONS.goal_done }
+  };
+}
+function judgmentFrom(answers, config) {
+  const unit = answers.unit_done;
+  if (typeof unit !== "number") return null;
+  if (unit < config.context.unitDoneYes) return { phase: "working", clear: false };
+  const goal = answers.goal_done;
+  return { phase: "unit_done", clear: typeof goal === "number" && goal >= config.context.goalDoneYes };
+}
+function hasBackgroundTasks(value) {
+  if (Array.isArray(value)) return value.length > 0;
+  return typeof value === "object" && value !== null && Object.keys(value).length > 0;
+}
+
+// src/context/transcript.ts
+import fs4 from "fs";
+var TAIL_START_BYTES = 1024 * 1024;
+var TAIL_MAX_BYTES = 8 * 1024 * 1024;
+var REQUEST_COUNT = 3;
+var REQUEST_MAX_CHARS = 1e3;
+var REQUEST_ORIGINS = /* @__PURE__ */ new Set(["human", "channel"]);
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseLines(text) {
+  const entries = [];
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const value = JSON.parse(line);
+      if (isRecord2(value)) entries.push(value);
+    } catch {
+    }
+  }
+  return entries;
+}
+function readTail(file, bytes) {
+  const fd = fs4.openSync(file, "r");
+  try {
+    const size = fs4.fstatSync(fd).size;
+    const length = Math.min(size, bytes);
+    const buffer = Buffer.alloc(length);
+    fs4.readSync(fd, buffer, 0, length, size - length);
+    let text = buffer.toString("utf8");
+    if (length < size) text = text.slice(text.indexOf("\n") + 1);
+    return { entries: parseLines(text), whole: length === size };
+  } finally {
+    fs4.closeSync(fd);
+  }
+}
+function contextSize(entries) {
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const entry = entries[i];
+    if (entry.type === "system" && entry.subtype === "compact_boundary") return 0;
+    if (entry.type !== "assistant" || entry.isSidechain === true || !isRecord2(entry.message)) continue;
+    const { model, usage } = entry.message;
+    if (model === "<synthetic>" || !isRecord2(usage)) continue;
+    const count = (key) => typeof usage[key] === "number" ? usage[key] : 0;
+    return count("input_tokens") + count("cache_read_input_tokens") + count("cache_creation_input_tokens");
+  }
+  return null;
+}
+function requestText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter((block) => isRecord2(block) && block.type === "text" && typeof block.text === "string").map((block) => block.text).join("\n");
+}
+function recentRequests(entries, count = REQUEST_COUNT, maxChars = REQUEST_MAX_CHARS) {
+  const found = [];
+  for (let i = entries.length - 1; i >= 0 && found.length < count; i--) {
+    const entry = entries[i];
+    if (entry.type !== "user" || entry.isSidechain === true || !isRecord2(entry.origin) || !REQUEST_ORIGINS.has(String(entry.origin.kind))) continue;
+    const text = requestText(isRecord2(entry.message) ? entry.message.content : void 0).trim();
+    if (text) found.push(text.slice(0, maxChars));
+  }
+  return found.reverse();
+}
+function readTranscript(file, limits = { start: TAIL_START_BYTES, max: TAIL_MAX_BYTES }) {
+  for (let bytes = limits.start; ; bytes *= 2) {
+    const { entries, whole } = readTail(file, Math.min(bytes, limits.max));
+    const size = contextSize(entries);
+    const requests = recentRequests(entries);
+    if (size !== null && requests.length >= REQUEST_COUNT || whole || bytes >= limits.max) return { size, requests };
+  }
+}
+
+// src/context/run.ts
+var ADVICE = /\/(clear|compact)$/;
+function factsOf(transcriptPath) {
+  if (!transcriptPath) return { size: null, requests: [] };
+  try {
+    return readTranscript(transcriptPath);
+  } catch {
+    return { size: null, requests: [] };
+  }
+}
+async function runContextHook(event, raw, deps) {
+  const config = readConfig(deps.home);
+  if (!config.context.enabled) return null;
+  const input = JSON.parse(raw);
+  if (typeof input !== "object" || input === null || typeof input.session_id !== "string") return null;
+  const sessionId = input.session_id;
+  if (event === "session-end") {
+    removeState(deps.home, sessionId);
+    appendLog(deps.home, deps.now(), { helper: "context", event: "session_end", sessionId, reason: typeof input.reason === "string" ? input.reason : null });
+    return null;
+  }
+  if (input.stop_hook_active === true) return null;
+  const transcriptPath = typeof input.transcript_path === "string" ? input.transcript_path : null;
+  const { size, requests } = factsOf(transcriptPath);
+  let judgment = null;
+  let reason = null;
+  let jev = null;
+  if (size === null) {
+    reason = "unknown_size";
+  } else if (size < config.context.minTokens) {
+    reason = "below_min";
+  } else if (hasBackgroundTasks(input.background_tasks)) {
+    reason = "background_tasks";
+    judgment = { phase: "working", clear: false };
+  } else {
+    const key = readJevKey(deps.env, config.keyFile);
+    if (!key) {
+      reason = "no_key";
+    } else {
+      const request = jevRequest(requests, typeof input.last_assistant_message === "string" ? input.last_assistant_message : "");
+      const result = await callJev(request, { key, fetchFn: deps.fetchFn });
+      jev = { state: request.state, ...result };
+      if ("error" in result) {
+        reason = "jev_error";
+      } else {
+        judgment = judgmentFrom(result.answers, config);
+        if (!judgment) reason = "jev_no_answer";
+      }
+    }
+  }
+  const at = deps.now();
+  const state = { sessionId, at: at.getTime(), size, judgment };
+  try {
+    writeState(deps.home, state);
+  } catch {
+  }
+  appendLog(deps.home, at, { helper: "context", event: "stop", sessionId, transcriptPath, size, reason, judgment, jev });
+  if (config.display !== "message") return null;
+  const line = adviceLine({ size, threshold: null, judgment, config });
+  return ADVICE.test(line) ? JSON.stringify({ systemMessage: line }) : null;
+}
+
+// src/context/hook.ts
+async function main() {
+  const event = process.argv[2];
+  if (event !== "stop" && event !== "session-end") return;
+  let raw = "";
+  process.stdin.setEncoding("utf8");
+  for await (const chunk of process.stdin) raw += chunk;
+  const out = await runContextHook(event, raw, { home: os.homedir(), env: process.env, now: () => /* @__PURE__ */ new Date() });
+  if (out) process.stdout.write(out);
+}
+main().catch(() => {
+});